Python-Basics-Class-Mahendra (1).ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Python Programming Language Introduction "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "\n",
    "Python is a widely used general-purpose, high level programming language.\n",
    "It was initially designed by Guido van Rossum in 1991 and developed by Python Software Foundation.\n",
    "It was mainly developed for emphasis on code readability, and its syntax allows programmers to express concepts in fewer lines of code.\n",
    "\n",
    "Python is an object-oriented programming language that can be used for analyzing data, developing web applications, games, and more.\n",
    "This course will teach you how to code in Python to eventually create something of your own!\n",
    "\n",
    "Python is a programming language that lets you work quickly and integrate systems more efficiently.\n",
    "There are two major Python versions- Python 2 and Python 3. Both are quite different. Beginning with Python programming:"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Python Keywords and Identifiers "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Here, we will get some idea about keywords(reserved words in Python) and identifiers (names given to variables, functions etc.)."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Python Keywords"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Keywords are the reserved words in Python.\n",
    "\n",
    "We cannot use a keyword as a variable name, function name or any other identifier. They are used to define the syntax and structure of the Python language.\n",
    "\n",
    "In Python, keywords are case sensitive.\n",
    "\n",
    "There are 33 keywords in Python 3.7. This number can vary slightly in the course of time.\n",
    "\n",
    "All the keywords except True, False and None are in lowercase and they must be written as it is. The list of all the keywords is given below."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# keywords:    False, await, else, import, pass, None, break, except, in, raise, True, class, finally, is, return, and, continue, for, lambda, try, as, def, from, nonloack, while, assert, del, global, not, with, async, elif, if, or, yield "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Python identifiers "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "An identifier is a name given to entities like class, functions, variables, etc. It helps to differentiate one entity from another.\n",
    "\n",
    "Rules for writing identifiers\n",
    "\n",
    "\n",
    "Identifiers can be a combination of letters in lowercase (a to z) or uppercase (A to Z) or digits (0 to 9) or an underscore _. Names like myClass, var_1 and print_this_to_screen, all are valid example.\n",
    "\n",
    "An identifier cannot start with a digit. 1variable is invalid, but variable1 is perfectly fine.\n",
    "\n",
    "Keywords cannot be used as identifiers.\n",
    "\n",
    "\n",
    "We cannot use special symbols like !, @, #, $, % etc. in our identifier.\n",
    "\n",
    "\n",
    "Identifier can be of any length.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "ename": "SyntaxError",
     "evalue": "invalid syntax (<ipython-input-1-cef8676af03d>, line 1)",
     "output_type": "error",
     "traceback": [
      "\u001b[0;36m  File \u001b[0;32m\"<ipython-input-1-cef8676af03d>\"\u001b[0;36m, line \u001b[0;32m1\u001b[0m\n\u001b[0;31m    global = 1File\u001b[0m\n\u001b[0m           ^\u001b[0m\n\u001b[0;31mSyntaxError\u001b[0m\u001b[0;31m:\u001b[0m invalid syntax\n"
     ]
    }
   ],
   "source": [
    "global = 1 File "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "ename": "SyntaxError",
     "evalue": "invalid syntax (<ipython-input-2-4914ce6c5f76>, line 1)",
     "output_type": "error",
     "traceback": [
      "\u001b[0;36m  File \u001b[0;32m\"<ipython-input-2-4914ce6c5f76>\"\u001b[0;36m, line \u001b[0;32m1\u001b[0m\n\u001b[0;31m    a@ = 0 File\u001b[0m\n\u001b[0m       ^\u001b[0m\n\u001b[0;31mSyntaxError\u001b[0m\u001b[0;31m:\u001b[0m invalid syntax\n"
     ]
    }
   ],
   "source": [
    "a@ = 0 File"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Things to remember"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "1. Python is a case-sensitive language. This means, Variable and variable are not the same. Always name identifiers that make sense.\n",
    "\n",
    "2. While, c = 10 is valid. Writing count = 10 would make more sense and it would be easier to figure out what it does even when you look at your code after a long gap.\n",
    "\n",
    "3. Multiple words can be separated using an underscore, this_is_a_long_variable."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "ename": "SyntaxError",
     "evalue": "invalid syntax (<ipython-input-2-c2399011f3a7>, line 1)",
     "output_type": "error",
     "traceback": [
      "\u001b[0;36m  File \u001b[0;32m\"<ipython-input-2-c2399011f3a7>\"\u001b[0;36m, line \u001b[0;32m1\u001b[0m\n\u001b[0;31m    mean temp=84\u001b[0m\n\u001b[0m         ^\u001b[0m\n\u001b[0;31mSyntaxError\u001b[0m\u001b[0;31m:\u001b[0m invalid syntax\n"
     ]
    }
   ],
   "source": [
    "mean temp=38"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "mean_temp=38"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Python Statment, Indentation and Commants "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Python  Statment"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Instructions that a Python interpreter can execute are called statements. \n",
    "For example, a = 1 is an assignment statement. if statement, for statement, while statement etc. are other kinds of statements which will be discussed later"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Multi-Line Statement"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In Python, end of a statement is marked by a newline character. But we can make a statement extend over multiple lines with the line continuation character (\\). \n",
    "For example:\n",
    "\n",
    "In Python, keywords are case sensitive."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [],
   "source": [
    "a=1+2+3+\\\n",
    "  4+5+6+\\\n",
    "  7+8+9\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "45"
      ]
     },
     "execution_count": 11,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "This is explicit line continuation. In Python, line continuation is implied inside parentheses ( ), brackets [ ] and braces { }. For instance, we can implement the above multi-line statement as"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [],
   "source": [
    "b=(1+2+3+\\\n",
    "  4+5+6+\\\n",
    "  7+8+9)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "45"
      ]
     },
     "execution_count": 9,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "b"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "c=[1+2+3+\\\n",
    "  4+5+6+\\\n",
    "  7+8+9]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[45]"
      ]
     },
     "execution_count": 7,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "c"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [],
   "source": [
    "d={1+2+3+\\\n",
    "  4+5+6+\\\n",
    "  7+8+9}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{45}"
      ]
     },
     "execution_count": 16,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "d"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We could also put multipule statements in a single line using semiconlons, as follows. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [],
   "source": [
    "e=25; f=78; c=25"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Python Indentation"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Most of the programming languages like C, C++, Java use braces { } to define a block of code. Python uses indentation.\n",
    "\n",
    "A code block (body of a function, loop etc.) starts with indentation and ends with the first unindented line. The amount of indentation is up to you, but it must be consistent throughout that block.\n",
    "\n",
    "Generally four whitespaces are used for indentation and is preferred over tabs. Here is an example.\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "if True: print('Hello') a = 5"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Hello\n"
     ]
    }
   ],
   "source": [
    "if True: \n",
    "    print('Hello'); \n",
    "    a = 5"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1\n",
      "2\n",
      "3\n",
      "4\n",
      "5\n"
     ]
    }
   ],
   "source": [
    "for i in range(1,11): \n",
    "    print(i) \n",
    "    if i == 5:\n",
    "        break\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Indentation can be ignored in line continuation. But it's a good idea to always indent. It makes the code more readable. For example:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Hello\n"
     ]
    }
   ],
   "source": [
    "if True:\n",
    "    print('Hello')\n",
    "    a=5"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Hello\n"
     ]
    }
   ],
   "source": [
    "if True: print('Hello'); a=5"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "both are valid and do the same thing. But the former style is clearer.\n",
    "\n",
    "Incorrect indentation will result into IndentationError."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Python Comments"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Comments are very important while writing a program. It describes what's going on inside a program so that a person looking at the source code does not have a hard time figuring it out.\n",
    "\n",
    "You might forget the key details of the program you just wrote in a month's time. So taking time to explain these concepts in form of comments is always fruitful.\n",
    "\n",
    "In Python, we use the hash (#) symbol to start writing a comment.\n",
    "\n",
    "It extends up to the newline character. Comments are for programmers for better understanding of a program. Python Interpreter ignores comment."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Multi-line comments\n",
    "\n",
    "\n",
    "If we have comments that extend multiple lines, one way of doing it is to use hash (#) in the beginning of each line. For example:\n",
    "\n",
    "Another way of doing this is to use triple quotes, either ''' or '''."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [],
   "source": [
    "#This is a long comment \n",
    "#and it extends \n",
    "#to multiple lines"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "\"This is a comment \\nprint out Hello\\nprint('Hello')\\n\""
      ]
     },
     "execution_count": 13,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "'''This is a comment \n",
    "print out Hello\n",
    "print('Hello')\n",
    "'''"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.8.3"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}