Day 1. Python introduction and Variables.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## <font color = \"red\">Python Roadmap </font>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Python Programming\n",
    " 1. Basics to Advanced\n",
    " 2. Conditional and Control statements, Loops\n",
    " 3. Functions & Oops\n",
    "\n",
    "Essential Python Libraries\n",
    " 1. Numpy\n",
    " 2. Pandas\n",
    " 3. Matplotlib\n",
    " 4. Seaborn\n",
    "\n",
    "- File handling & DateTime\n",
    "- Regular Expressions\n",
    "- Web scraping"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### <font color = \"green\"> Why we use jupyter notebook??? </font>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Jupyter notebook, formerly known as the IPython(Interactive Python) notebook, is a flexible tool that helps you create readable analyses, as you can keep code, images, comments, formulae and plots together"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The name Jupyter is an indirect acronyum of the three core languages it was designed for: **JU**lia, **PYT**hon, and **R** and is inspired by the planet Jupiter."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## <font color = red> Keyboard shortcuts </font>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "1. **Command Mode (press Esc to unable)**\n",
    " > `Enter` - enter edit mode <br>\n",
    " > `shift` + `enter` - run cell , select below <br>\n",
    " > `ctrl` + `enter` - run cell <br>\n",
    " > `Alt` + `enter` - run cell, insert below <br>\n",
    " > `Y` - to code<br>\n",
    " > `M` - to markdown<br>\n",
    " > `R` - to raw<br>\n",
    " > `1` - to heading 1 <br>\n",
    " > `23456` - to heading 23456 <br>\n",
    " > `A`/`B` - insert above and below cell <br>\n",
    " > `X` - cut selected cell <br>\n",
    " > `C` - copy selected cell <br>\n",
    " > `shift` + `v` - paste cell above <br>\n",
    " > `v` - paste cell below <br>\n",
    " > `z` - undo last cell deletion <br>\n",
    " > `D` - delet selected cell <br>\n",
    " > `shift`+ `M` - merge cell below <br>\n",
    " > `ctrl` + `S` - save and checkpoint <br>\n",
    " > `L` - toggle line number <br>\n",
    " > `o` - toggle output <br>\n",
    " > `shift`+`o` - toggle output scrolling <br>\n",
    " > `Esc` - close pager <br>\n",
    " > `o` - restart kernel <br>\n",
    " > `space` - scroll down <br>\n",
    " > `shift` + `space` - scroll up <br>\n",
    " > `shift` - ignore <br>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "2. **Edit Mode (press Enter to enable)**\n",
    "> `tab` - code completion or indent<br>\n",
    "> `shift`+`tab`- tooltip<br>\n",
    "> `ctrl` + `]` - indent<br>\n",
    "> `ctrl` + `[` - denent<br>\n",
    "> `ctrl` + `A` - select all<br>\n",
    "> `ctrl` + `shift` + `z` - redo<br>\n",
    "> `ctrl` + `y` - redo<br>\n",
    "> `ctrl` + `Home` - go to cell start<br>\n",
    "> `ctrl` + `up` - go to cell start<br>\n",
    "> `ctrl` + `End` - go to cell end<br>\n",
    "> `ctrl` + `Down` - go to cell end<br>\n",
    "> `ctrl` + `left` - go one word left<br>\n",
    "> `ctrl` + `right` - go one word right<br>\n",
    "> `ctrl` + `backspace` - delet word before<br>\n",
    "> `ctrl` + `delet` -  delet word after<br>\n",
    "> `ctrl` + `M` - command mode<br>\n",
    "> `ctrl`+`shift`+`minus` - split cell<br>\n",
    "> `ctrl`+ `/` - toggle comment on current or selected lines <br>\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Python variables"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "A variable is a reserved memory area (memory address) to store value. For example, we want to store an employee’s salary. In such a case, we can create a variable and store salary using it. Using that variable name, you can read or modify the salary amount.\n",
    "\n",
    "In other words, a variable is a value that varies according to the condition or input pass to the program. Everything in Python is treated as an object so every variable is nothing but an object in Python.\n",
    "\n",
    "A variable can be either mutable or immutable. If the variable’s value can change, the object is called mutable, while if the value cannot change, the object is called immutable."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Creating a variable"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Python programming language is dynamically typed, so there is no need to declare a variable before using it or declare the data type of variable like in other programming languages. The declaration happens automatically when we assign a value to the variable."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "##### Creating a variable and assigning a value\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can assign a value to the variable at that time variable is created. We can use the assignment operator = to assign a value to a variable.\n",
    "\n",
    "The operand, which is on the left side of the assignment operator, is a variable name. And the operand, which is the right side of the assignment operator, is the variable’s value.\n",
    "\n",
    "variable_name = variable_value"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Deepali\n",
      "25\n",
      "25800.6\n"
     ]
    }
   ],
   "source": [
    "name = \"Deepali\"  # string assignment\n",
    "age = 25  # integer assignment\n",
    "salary = 25800.60  # float assignment\n",
    "\n",
    "print(name)  # Deepali\n",
    "print(age)  # 25\n",
    "print(salary)  # 25800.6"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In the above example, “Deepali”, 25, 25800.60 are values that are assigned to name, age, and salary respectively."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Changing the value of a variable"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Many programming languages are statically typed languages where the variable is initially declared with a specific type, and during its lifetime, it must always have that type.\n",
    "\n",
    "But in Python, variables are dynamically typed and not subject to the data type restriction. A variable may be assigned to a value of one type, and then later, we can also re-assigned a value of a different type. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "10\n",
      "<class 'int'>\n",
      "55\n",
      "Now I'm a string\n",
      "<class 'str'>\n",
      "35.69\n",
      "<class 'float'>\n"
     ]
    }
   ],
   "source": [
    "var = 10\n",
    "print(var)  # 10\n",
    "# print its type\n",
    "print(type(var))  # <class 'int'>\n",
    "\n",
    "# assign different integer value to var\n",
    "var = 55\n",
    "print(var)  # 55\n",
    "\n",
    "# change var to string\n",
    "var = \"Now I'm a string\"\n",
    "print(var)  # Now I'm a string\n",
    "# print its type\n",
    "print(type(var))  # <class 'str'>\n",
    "\n",
    "# change var to float\n",
    "var = 35.69\n",
    "print(var)  # 35.69\n",
    "# print its type\n",
    "print(type(var))  # <class 'float'>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Create Number, String, List variables"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can create different types of variables as per our requirements."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Number"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "A number is a data type to store numeric values. The object for the number will be created when we assign a value to the variable. In Python3, we can use the following three data types to store numeric values.\n",
    "\n",
    "1. Int\n",
    "2. float\n",
    "3. complex"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Integer variable"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The int is a data type that returns integer type values (signed integers); they are also called ints or integers. The integer value can be positive or negative without a decimal point."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "24\n",
      "<class 'int'>\n"
     ]
    }
   ],
   "source": [
    "# create integer variable\n",
    "age = 24\n",
    "print(age)  # 24\n",
    "print(type(age))  # <class 'int'>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Note: We used the built-in Python method type() to check the variable type."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Float variable"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Floats are the values with the decimal point dividing the integer and the fractional parts of the number.  Use float data type to store decimal values."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "10800.55\n",
      "<class 'float'>\n"
     ]
    }
   ],
   "source": [
    "# create float variable\n",
    "salary = 10800.55\n",
    "print(salary)  # 10800.55\n",
    "print(type(salary))  # <class 'float'>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "\n",
    "In the above example, the variable salary assigned to value 10800.55, which is a float value."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Complex type"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The complex is the numbers that come with the real and imaginary part. A complex number is in the form of a+bj, where a and b contain integers or floating-point values."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(9+5j)\n",
      "<class 'complex'>\n"
     ]
    }
   ],
   "source": [
    "a = 9 + 5j\n",
    "print(a)  # (9+5j)\n",
    "print(type(a))  # <class 'complex'>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### String variable"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In Python, a string is a set of characters represented in quotation marks. Python allows us to define a string in either pair of single or double quotation marks. For example, to store a person’s name we can use a string type."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "To retrieve a piece of string from a given string, we can use to slice operator [] or [:]. Slicing provides us the subset of a string with an index starting from index 0 to index end-1.\n",
    "\n",
    "To concatenate the string, we can use the addition(+) operator."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "DataScience\n",
      "D\n",
      "taS\n",
      "11\n",
      "DataScienceTEST\n"
     ]
    }
   ],
   "source": [
    "# create a variable of type string\n",
    "str = 'DataScience'\n",
    "# prints complete string\n",
    "print(str)  # Data Science\n",
    "\n",
    "# prints first character of the string\n",
    "print(str[0])  # D\n",
    "\n",
    "# prints characters starting from 2nd to 5th\n",
    "print(str[2:5])  # taS\n",
    "\n",
    "# length of string\n",
    "print(len(str))  # 12\n",
    "\n",
    "# concatenate string\n",
    "print(str + \"TEST\")  # Data ScienceTEST"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Print"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "hi    how      are     you\n"
     ]
    }
   ],
   "source": [
    "print(\"hi    how      are     you\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "HiHello\n"
     ]
    }
   ],
   "source": [
    "print(\"Hi\" + \"Hello\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Hi Hello\n"
     ]
    }
   ],
   "source": [
    "print(\"Hi\"+ \" \"+ \"Hello\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "HyderabadHyderabadHyderabad\n"
     ]
    }
   ],
   "source": [
    "print(\"Hyderabad\" * 3)  # its prints string multiple times"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "I multipy 6 Is the result\n"
     ]
    }
   ],
   "source": [
    "print(\"I multipy\", 2 * 3 , \"Is the result\") # print multiply with  numbers"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### multi lines strings"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "To get the list of all keywords of Python programmatically, you can use kwlist of keyword library. \n",
      "Following is the quick code snippet to get the list of all keywords. \n",
      "kwlist returns sequence containing all the keywords defined for the interpreter.\n"
     ]
    }
   ],
   "source": [
    "print('''To get the list of all keywords of Python programmatically, you can use kwlist of keyword library. \n",
    "Following is the quick code snippet to get the list of all keywords. \n",
    "kwlist returns sequence containing all the keywords defined for the interpreter.''')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### print with space , \\n , \\t"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      " Hi How are you?\n"
     ]
    }
   ],
   "source": [
    "print(\" Hi How are you?\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      " hi \n",
      "How are you\n"
     ]
    }
   ],
   "source": [
    "print( \" hi \\nHow are you\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "hi\thiiiiiiiiiii\n"
     ]
    }
   ],
   "source": [
    "print(\"hi\\thiiiiiiiiiii\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "ename": "SyntaxError",
     "evalue": "invalid syntax (<ipython-input-15-ffef336255b4>, line 1)",
     "output_type": "error",
     "traceback": [
      "\u001b[1;36m  File \u001b[1;32m\"<ipython-input-15-ffef336255b4>\"\u001b[1;36m, line \u001b[1;32m1\u001b[0m\n\u001b[1;33m    print('I don't know')\u001b[0m\n\u001b[1;37m                 ^\u001b[0m\n\u001b[1;31mSyntaxError\u001b[0m\u001b[1;31m:\u001b[0m invalid syntax\n"
     ]
    }
   ],
   "source": [
    "print('I don't know')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "I don't know\n"
     ]
    }
   ],
   "source": [
    "print('I don\\'t know')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\"Hi\", He Said\n"
     ]
    }
   ],
   "source": [
    "print(\"\\\"Hi\\\", He Said\") "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [],
   "source": [
    "pi = 3.141592653"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "I am pi 3\n"
     ]
    }
   ],
   "source": [
    "print(\"I am pi %d\"%(pi)) # %d is place holder for Integers"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "I am pi 3.141593\n"
     ]
    }
   ],
   "source": [
    "print(\"I am pi %f\"%(pi)) # %f is place holder for Integers"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "I am pi 3.142\n"
     ]
    }
   ],
   "source": [
    "print(\"I am pi %.3f\"%(pi)) # %f is place holder for Integers"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [],
   "source": [
    "x = 25\n",
    "y = 2\n",
    "tempScale = 'Celsius'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The temperature is 12.50 Celsius\n"
     ]
    }
   ],
   "source": [
    "print(\"The temperature is %.2f %s\"%(x/y, tempScale))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "I am FIVE 5, I am SIX 6\n"
     ]
    }
   ],
   "source": [
    "a = 5\n",
    "b = 6\n",
    "print(\"I am FIVE {}, I am SIX {}\".format(a,b))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "I am pi 3.141592653\n"
     ]
    }
   ],
   "source": [
    "print(\"I am pi {}\".format(pi))\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "I am pi 3.142\n"
     ]
    }
   ],
   "source": [
    "print(\"I am pi {:.3f}\".format(pi))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "If we want to represent a group of elements (or value) as a single entity, we should go for the list variable type. For example, we can use them to store student names. In the list, the insertion order of elements is preserved. That means, in which order elements are inserted in the list, the order will be intact.\n",
    "\n",
    "The list can be accessed in two ways, either positive or negative index.  The list has the following characteristics:\n",
    "\n",
    "1. In the list insertion order of elements is preserved.\n",
    "2. Heterogeneous (all types of data types int, float, string) elements are allowed.\n",
    "3. Duplicates elements are permitted.\n",
    "4. The list is mutable(can change).\n",
    "5. Growable in nature means based on our requirement, we can increase or decrease the list’s size.\n",
    "6. List elements should be enclosed within square brackets []."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Variable’s case-sensitive"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Python is a case-sensitive language. If we define a variable with names a = 100 and A =200 then, Python differentiates between a and A. These variables are treated as two different variables (or objects)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "100\n",
      "200\n",
      "300\n"
     ]
    }
   ],
   "source": [
    "a = 100\n",
    "A = 200\n",
    "\n",
    "# value of a\n",
    "print(a)  # 100\n",
    "# Value of A\n",
    "print(A)  # 200\n",
    "\n",
    "a = a + A\n",
    "print(a)  # 300"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Constant"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Constant is a variable or value that does not change, which means it remains the same and cannot be modified. But in the case of Python, the constant concept is not applicable. By convention, we can use only uppercase characters to define the constant variable if we don’t want to change it."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [],
   "source": [
    "MIN_VALUE = 500\n",
    "# It is just convention, but we can change the value of MAX_VALUE variable."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Rules and naming convention for variables and constants"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    " A name in a Python program is called an identifier. An identifier can be a variable name, class name, function name, and module name.\n",
    "\n",
    "There are some rules to define variables in Python.\n",
    "\n",
    "In Python, there are some conventions and rules to define variables and constants that should follow.\n",
    "\n",
    "* Rule 1: The name of the variable and constant should have a combination of letters, digits, and underscore symbols.\n",
    "\n",
    "Alphabet/letters i.e., lowercase (a to z) or uppercase (A to Z)\n",
    "Digits(0 to 9)\n",
    "Underscore symbol (_)\n",
    "\n",
    "For Example :\n",
    "* total_addition\n",
    "* TOTAL_ADDITION\n",
    "* totalAddition\n",
    "* Totaladdition"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    " * Rule 2: The variable name and constant name should make sense.\n",
    "\n",
    "Note: we should always create a meaningful variable name so it will be easy to understand. That is, it should be meaningful.\n",
    "\n",
    "For Example:\n",
    "x = \"Deepali\"  \n",
    "student_name = \"Deepali\"\n",
    "\n",
    "It above example variable x does not make more sense, but student_name is a meaningful variable.\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "* Rule 3: Don’t’ use special symbols in a variable name\n",
    "\n",
    "For declaring variable and constant, we cannot use special symbols like $, #, @, %, !~, etc. If we try to declare names with a special symbol, Python generates an error\n",
    "\n",
    "Example\n",
    "* ca$h = 1000\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "* Rule 4:  Variable and constant should not start with digit letters.\n",
    "\n",
    "You will receive an error if you start a variable name with a digit. Let’s verify this using a simple example.\n",
    "\n",
    "* 1studnet = \"Deepali\"\n",
    "* print(1studnet)\n",
    "* Here Python will generate a syntax error at 1studnet. instead of this, you can declare a variable like studnet_1 = \"Deepali\""
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "* Rule 5: Identifiers are case sensitive.\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "120\n",
      "130\n",
      "150\n"
     ]
    }
   ],
   "source": [
    "total = 120\n",
    "Total = 130\n",
    "TOTAL = 150\n",
    "print(total)\n",
    "print(Total)\n",
    "print(TOTAL)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Here, Python makes a difference between these variables that is uppercase and lowercase, so that it will create three different variables total, Total, TOTAL."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "* Rule 6: To declare constant should use capital letters.\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [],
   "source": [
    "MIN_VALUE = 100\n",
    "MAX_VALUE = 1000"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    " Use an underscore symbol for separating the words in a variable name\n",
    "\n",
    "If we want to declare variable and constant names having two words, use an underscore symbol for separating the words."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [],
   "source": [
    "current_temperature = 24"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Assigning multiple values to multiple variables\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "10 70 Deepali\n"
     ]
    }
   ],
   "source": [
    "roll_no, marks, name = 10, 70, \"Deepali\"\n",
    "print(roll_no, marks, name) # 10 20 Deepali"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In the above example, two integer values 10 and 70 are assigned to variables roll_no and marks, respectively, and string literal, “Deepali,” is assigned to the variable name."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Quick Summary to keep in mind:"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Checklist while giving variable names\n",
    " - Allowed values -> alphabets, numbers and underscore (_).\n",
    " - A variable name should start with alphabet or underscore. It can not start with a number.\n",
    " - Variable names are case-sensitive."
   ]
  },
  {
   "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": 4
}