Abhipsa.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    " PYTHON BASICS\n",
    " TABLE OF CONTENTS:-\n",
    "1.  Variables\n",
    "2.  Print Statement\n",
    "3.  Data types and Type casting\n",
    "4.  Strings and String Formatting\n",
    "5.  String Methods\n",
    "6.  Lists and List methods\n",
    "7.  Tuples and Tuple methods\n",
    "8.  Sets and its methods\n",
    "9.  Dictionaries and its methods\n",
    "10. Functions\n",
    "11. Lambdas\n",
    "12. Conditionals\n",
    "13. Operators\n",
    "14. Loops\n",
    "15. Modules\n",
    "16. Classes,Constructors and objects\n",
    "17. Extended class(Inheritance)\n",
    "18. File handling\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "5\n"
     ]
    }
   ],
   "source": [
    "#1\n",
    "#VARIABLES\n",
    "add=2+3                            #Variable names can contain letters and numbers but should not start with a number\n",
    "print(add)                         #should not contain a special character and should not be a reserved keyword\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "ename": "SyntaxError",
     "evalue": "invalid syntax (<ipython-input-3-4d4576cbba3c>, line 2)",
     "output_type": "error",
     "traceback": [
      "\u001b[1;36m  File \u001b[1;32m\"<ipython-input-3-4d4576cbba3c>\"\u001b[1;36m, line \u001b[1;32m2\u001b[0m\n\u001b[1;33m    print(anime@)\u001b[0m\n\u001b[1;37m                ^\u001b[0m\n\u001b[1;31mSyntaxError\u001b[0m\u001b[1;31m:\u001b[0m invalid syntax\n"
     ]
    }
   ],
   "source": [
    "anime@='Koi no Katachi'             #Error since it contains an illegal character\n",
    "print(anime@)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "ename": "SyntaxError",
     "evalue": "invalid syntax (<ipython-input-4-d4a54bae7865>, line 1)",
     "output_type": "error",
     "traceback": [
      "\u001b[1;36m  File \u001b[1;32m\"<ipython-input-4-d4a54bae7865>\"\u001b[1;36m, line \u001b[1;32m1\u001b[0m\n\u001b[1;33m    23names='Interstellar'              #Error since it started with a number\u001b[0m\n\u001b[1;37m          ^\u001b[0m\n\u001b[1;31mSyntaxError\u001b[0m\u001b[1;31m:\u001b[0m invalid syntax\n"
     ]
    }
   ],
   "source": [
    "23names='Interstellar'              #Error since it started with a number"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "ename": "SyntaxError",
     "evalue": "invalid syntax (<ipython-input-5-b4282382a509>, line 1)",
     "output_type": "error",
     "traceback": [
      "\u001b[1;36m  File \u001b[1;32m\"<ipython-input-5-b4282382a509>\"\u001b[1;36m, line \u001b[1;32m1\u001b[0m\n\u001b[1;33m    import='Decode Morse'              #Error since import is python's reserved word\u001b[0m\n\u001b[1;37m          ^\u001b[0m\n\u001b[1;31mSyntaxError\u001b[0m\u001b[1;31m:\u001b[0m invalid syntax\n"
     ]
    }
   ],
   "source": [
    "import='Decode Morse'              #Error since import is python's reserved word"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "#Python contains 35 Reseved words and they cant be used as variables.They are as follows:\n",
    "# False        class      return      is      finally     none      if\n",
    "# for          lamda      continue    True    def         from      while\n",
    "# non local    and        del         global  not         with      as\n",
    "# elif         try        or          yield   assert      else      import\n",
    "# pass         break      except      in      raise\n",
    "   "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1\n",
      "2\n"
     ]
    }
   ],
   "source": [
    "#2\n",
    "#PRINT STATEMENT\n",
    "#A print statement is a unit of code that the python interpreter can execute to display output.\n",
    "print(1)\n",
    "x=2        #Assignment statement produces no output\n",
    "print(x)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<class 'int'>\n"
     ]
    }
   ],
   "source": [
    "#3\n",
    "#DATA TYPES AND TYPE CASTING \n",
    "# Python has the following data types built-in by default\n",
    "# Text type      :     str\n",
    "# Numeric type   :     int,float,complex\n",
    "# Sequence type  :     list,tuple,range\n",
    "# Mapping type   :     dict\n",
    "# Set types      :     set,frozenset\n",
    "# Boolean type   :     bool\n",
    "# Binary Types   :     bytes,byte array, memory view\n",
    "\n",
    "#Print the data type of variable x:\n",
    "x=5\n",
    "print(type(x))\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "199.0\n"
     ]
    }
   ],
   "source": [
    "#TYPE CASTING (Example )\n",
    "print (float(99)+100)     #When you put an int and float in an expression then it gets converted to float"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "HALO-WELT\n"
     ]
    }
   ],
   "source": [
    "#4\n",
    "#STRINGS\n",
    "#Assigning a string to a variable is done with a variable name followed by an equal sign and a string\n",
    "str=\"HALO-WELT\"\n",
    "print(str)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Cooper is 124 years old.\n"
     ]
    }
   ],
   "source": [
    "#STRING FORMATTING\n",
    "# Python uses C-style string formatting to create new,formatted strings.\n",
    "#The \"%\" operator is used to format a set of variables enclosed in a \"tupple\"(a fixed size list)\n",
    "#together with a format string which contains normal text together with argument specifiers like \"%s\" and \"%d\"\n",
    "name=\"Cooper\"\n",
    "age=124\n",
    "print(\"%s is %d years old.\" %(name, age))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [],
   "source": [
    "#Some basic argument specifiers\n",
    "#  %s                       string(or any object with a string representaion,like numbers)\n",
    "#  %d                       integers\n",
    "#  %f                       float\n",
    "#  %.<number of digits>f    floating point numbers with a fixed amount of digits to the right of dot\n",
    "#  %x/%X                    integers in hex representation(lower case/upper case)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [],
   "source": [
    "#5\n",
    "# STRING METHODS\n",
    "#     Method                           Description\n",
    "#    capitalize()                  Converts the first character to upper case\n",
    "#    casefold()                    Converts string into lower case\n",
    "#    center()                      Returns a centered string\n",
    "#    count()                       Returns the number of times a specified value occurs in a string\n",
    "#    encode()                      Returns an encoded version of the string\n",
    "#    endswith()                    Returns true if the string ends with the specified value\n",
    "#    expandtabs()                  Sets the tab size of the string\n",
    "#    find()                        Searches the string for a specified value and returns the position of where it was found\n",
    "#    format()                      Formats specified values in a string\n",
    "#    format_map()                  Formats specified values in a string\n",
    "#    index()                       Searches the string for a specified value and returns the position of where it was found\n",
    "#    isalnum()                     Returns True if all characters in the string are alphanumeric\n",
    "#    isalpha()                     Returns True if all characters in the string are in the alphabet\n",
    "#    isdecimal()                   Returns True if all characters in the string are decimals\n",
    "#    isdigit()                     Returns True if all characters in the string are digits\n",
    "#    isidentifier()                Returns True if the string is an identifier\n",
    "#    islower()                     Returns True if all characters in the string are lower case\n",
    "#    isnumeric()                   Returns True if all characters in the string are numeric\n",
    "#    isprintable()                 Returns True if all characters in the string are printable\n",
    "#    isspace()                     Returns True if all characters in the string are whitespaces\n",
    "#    istitle()                     Returns True if the string follows the rules of a title\n",
    "#    isupper()                     Returns True if all characters in the string are upper case\n",
    "#    join()                        Joins the elements of an iterable to the end of the string\n",
    "#    ljust()                       Returns a left justified version of the string\n",
    "#    lower()                       Converts a string into lower case\n",
    "#    lstrip()                      Returns a left trim version of the string\n",
    "#    maketrans()                   Returns a translation table to be used in translations\n",
    "#    partition()                   Returns a tuple where the string is parted into three parts\n",
    "#    replace()                     Returns a string where a specified value is replaced with a specified value\n",
    "#    rfind()                       Searches the string for a specified value and returns the last position of where it was found\n",
    "#    rindex()                      Searches the string for a specified value and returns the last position of where it was found\n",
    "#    rjust()                       Returns a right justified version of the string\n",
    "#    rpartition()                  Returns a tuple where the string is parted into three parts\n",
    "#    rsplit()                      Splits the string at the specified separator, and returns a list\n",
    "#    rstrip()                      Returns a right trim version of the string\n",
    "#    split()                       Splits the string at the specified separator, and returns a list\n",
    "#    splitlines()                  Splits the string at line breaks and returns a list\n",
    "#    startswith()                  Returns true if the string starts with the specified value\n",
    "#    strip()                       Returns a trimmed version of the string\n",
    "#    swapcase()                    Swaps cases, lower case becomes upper case and vice versa\n",
    "#    title()                       Converts the first character of each word to upper case\n",
    "#    translate()                   Returns a translated string\n",
    "#    upper()                       Converts a string into upper case\n",
    "#    zfill()                       Fills the string with a specified number of 0 values at the beginning"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "RAGE AGAINST THE DYING OF LIGHT!\n",
      "rAGE AGAINST THE DYING OF LIGHT!\n"
     ]
    }
   ],
   "source": [
    "#EXAMPLES OF STRING METHODS\n",
    "txt = \"Rage against the dying of light!\"\n",
    "x = txt.upper()\n",
    "print(x)\n",
    "y =txt.swapcase()\n",
    "print(y)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['Cheddar', 'Edam', 'Gouda'] [17, 123] []\n",
      "Cheddar\n",
      "[17, 5]\n"
     ]
    }
   ],
   "source": [
    "#6\n",
    "#LISTS\n",
    "# A list is a collection which is ordered and changeable. In Python lists are written with square brackets and can be of any type.\n",
    "# EXAMPLES ARE AS FOLLOWS:\n",
    "cheeses = ['Cheddar', 'Edam', 'Gouda']\n",
    "numbers = [17, 123]\n",
    "empty = []\n",
    "print(cheeses, numbers, empty)\n",
    "print(cheeses[0])    #lists are mutable\n",
    "numbers[1] = 5\n",
    "print(numbers)       #The one-th element of numbers, which used to be 123, is now 5.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [],
   "source": [
    "#LIST METHODS\n",
    "#   Method                    Description\n",
    "#   append()                  Adds an element at the end of the list\n",
    "#   clear()                   Removes all the elements from the list\n",
    "#   copy()                    Returns a copy of the list\n",
    "#   count()                   Returns the number of elements with the specified value\n",
    "#   extend()                  Add the elements of a list (or any iterable), to the end of the current list\n",
    "#   index()                   Returns the index of the first element with the specified value\n",
    "#   pop()                     Removes the element at the specified position\n",
    "#   remove()                  Removes the first item with the specified value\n",
    "#   reverse()                 Reverses the order of the list\n",
    "#   sort()                    Sorts the list"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['a', 'b', 'c', 'd']\n",
      "['a', 'b', 'c', 'd', 'e']\n",
      "[]\n",
      "['a', 'b', 'c', 'd', 'e']\n",
      "['e', 'd']\n"
     ]
    }
   ],
   "source": [
    "# LIST METHOD EXAMPLES\n",
    "t = ['a', 'b', 'c']\n",
    "t.append('d')       #Adds d at the end of the list\n",
    "print(t)\n",
    "t1 = ['a', 'b', 'c']\n",
    "t2 = ['d', 'e']\n",
    "t1.extend(t2)       # d and e gets added to a,b and c\n",
    "print(t1)\n",
    "t.clear()           # all elements in t gets removed\n",
    "print(t)\n",
    "t1.copy()           # a copy of the list in t1 is returned\n",
    "print(t1)\n",
    "t2.reverse()        # Elements in t2 gets reversed\n",
    "print(t2)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "('R', 'e', 'n', 'd', 'e', 'z', 'v', 'o', 'u', 's')\n"
     ]
    }
   ],
   "source": [
    "#7\n",
    "# TUPLES\n",
    "#  A tuple1 is a sequence of values much like a list. \n",
    "#  The values stored in a tuple can be any type, and they are indexed by integers. \n",
    "#  The important difference is that tuples are immutable.\n",
    "#  Tuples are also comparable and hashable so we can sort lists\n",
    "#  of them and use tuples as key values in Python dictionaries.\n",
    "\n",
    "t = ('a', 'b', 'c', 'd', 'e')  #Syntactically, a tuple is a comma-separated list of values\n",
    "str=tuple('Rendezvous')\n",
    "print(str)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2\n",
      "7\n"
     ]
    }
   ],
   "source": [
    "#TUPLE METHODS\n",
    "#count()Returns the number of times a specified value occurs in a tuple\n",
    "tuple = (0, 1, 1, 2, 3, 5, 8, 13, 21, 34)\n",
    "x = tuple.count(1)\n",
    "print(x)\n",
    "\n",
    "#index()Searches the tuple for a specified value and returns the position of where it was found\n",
    "y =tuple.index(13)\n",
    "print(y)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{4, 5, 6}\n",
      "{4.0, 'Industry'}\n",
      "{9, 2, 5, 6}\n",
      "{'Emerald ', 'Topaz', 'Sapphire', 'Ruby'}\n"
     ]
    }
   ],
   "source": [
    "#8\n",
    "# SETS AND ITS METHODS\n",
    "# A set is created by placing all the items (elements) inside curly braces {},\n",
    "# separated by comma, or by using the built-in set() function.\n",
    "# It can have any number of items and they may be of different types (integer, float, tuple, string etc.). \n",
    "# But a set cannot have mutable elements like lists, sets or dictionaries as its elements.\n",
    "\n",
    "set1 = {4, 5, 6}             #Set of integers\n",
    "print(set1)\n",
    "\n",
    "set2={\"Industry\", 4.0}       #Set of mixed data types\n",
    "print(set2)\n",
    "\n",
    "set3={2,2,6,9,6,9,5}        #Set cannot have duplicates\n",
    "print(set3)\n",
    "\n",
    "set4 = {\"Ruby\", \"Emerald \", \"Sapphire\"}  \n",
    "set4.add(\"Topaz\")           #Add an element to the given set\n",
    "print(set4)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'Name': 'oindrilla', 'Age': '28', 'Appraisal': 0.8}\n",
      "oindrilla\n",
      "28\n",
      "0.8\n",
      "{'Name': 'oindrilla', 'Age': '28', 'Appraisal': 0.9}\n",
      "{'Name': 'oindrilla', 'Age': '28', 'Appraisal': 0.9, 'email': 'oin@tech.org'}\n"
     ]
    }
   ],
   "source": [
    "#9\n",
    "#DICTIONARIES\n",
    "employee={'Name':'oindrilla','Age':'28','Appraisal':8/10} \n",
    "print(employee)\n",
    "print(employee['Name'])\n",
    "print(employee['Age'])\n",
    "print(employee['Appraisal'])\n",
    "employee.update({'Name':'oindrilla','Age':'28','Appraisal':9/10})  #updates the employee details\n",
    "print(employee)\n",
    "employee['email']='oin@tech.org'                                   #adds an extra key to the existing dictionary\n",
    "print(employee)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "20\n"
     ]
    }
   ],
   "source": [
    "#10\n",
    "#FUNCTIONS\n",
    "#Functions are reusable pieces of code\n",
    "def calc(a,b,c):             #Function declaration with arguments\n",
    " z=(a+b+c)\n",
    " return z                    #return statement\n",
    "sum=calc(5,4,11)             #Function call\n",
    "print(sum)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "10\n"
     ]
    }
   ],
   "source": [
    "#11\n",
    "#LAMBDAS\n",
    "#A lambda function is a small anonymous function.\n",
    "#A lambda function can take any number of arguments, but can only have one expression.\n",
    "double = lambda x: x * 2           #x is the argument and x*2 is the expression\n",
    "print(double(5))\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[4, 6, 8, 12]\n",
      "[2, 10, 8, 12, 16, 22, 6, 24]\n"
     ]
    }
   ],
   "source": [
    "#Lambda functions are used along with built-in functions like filter(), map() etc.\n",
    "# The filter() function in Python takes in a function and a list as arguments.\n",
    "rno_list = [1, 5, 4, 6, 8, 11, 3, 12]\n",
    "new_list = list(filter(lambda x: (x%2 == 0) , rno_list))   #filters out the even numbers from the list\n",
    "print(new_list)\n",
    "\n",
    "#The map() function in Python takes in a function and a list.\n",
    "my_list = [1, 5, 4, 6, 8, 11, 3, 12]\n",
    "f_list = list(map(lambda x: x * 2 , my_list))              #doubles all the elements of the list\n",
    "print(f_list)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Larger than 2\n",
      "Done!\n",
      "Large\n",
      "Smaller than 25\n"
     ]
    }
   ],
   "source": [
    "#12\n",
    "#CONDITIONALS\n",
    "x=5\n",
    "if x>2 :                   #Using only if\n",
    "    print('Larger than 2')\n",
    "print('Done!')    \n",
    "\n",
    "y=20                      #Two-way decision(if-else)\n",
    "if y>2:\n",
    "    print('Large')\n",
    "else:\n",
    "    print('Small')\n",
    "    \n",
    "z=50                    #Multi-way decision(if-else if-else)\n",
    "if x<25:\n",
    "    print('Smaller than 25')\n",
    "elif x==25:\n",
    "    print('Equals 25')\n",
    "else:\n",
    "    print('Greater than 25')\n",
    "    \n",
    "    "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "ARITHMETIC OPERATORS EXAMPLES\n",
      "15\n",
      "-5\n",
      "50\n",
      "2\n",
      "0\n",
      "9765625\n",
      "2\n",
      "ASSIGNMENT OPERATORS EXAMPLES\n",
      "5\n",
      "8\n"
     ]
    }
   ],
   "source": [
    "#13\n",
    "#OPERATORS\n",
    "#Python divides the operators in the following groups:\n",
    " #Arithmetic operators\n",
    " #Assignment operators\n",
    " #Comparison operators\n",
    " #Logical operators\n",
    " #Identity operators\n",
    " #Membership operators\n",
    " #Bitwise operators\n",
    "    \n",
    "#ARITHMETIC OPERATORS\n",
    "print('ARITHMETIC OPERATORS EXAMPLES')\n",
    "a=5\n",
    "b=10\n",
    "sum=int(a+b)      #Addition operator\n",
    "print(sum)\n",
    "sub=int(a-b)      #Subtraction operator\n",
    "print(sub)\n",
    "prod=int(a*b)     #Multiplication operator\n",
    "print(prod)\n",
    "divide=int(b/a)   #Division operator\n",
    "print(divide)\n",
    "mod=int(b%a)      #Modulus operator\n",
    "print(mod)\n",
    "exp=int(a**b)     #Exponentiation operator\n",
    "print(exp)\n",
    "fld=int(b//a)     #Floor division operator\n",
    "print(fld)\n",
    "\n",
    "#ASSIGNMENT OPERATORS\n",
    "print('ASSIGNMENT OPERATORS EXAMPLES')\n",
    "x=5\n",
    "print(x)\n",
    "x+=3\n",
    "print(x)\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "COMPARISON OPERATORS EXAMPLES\n",
      "False\n",
      "True\n",
      "True\n",
      "False\n",
      "True\n",
      "False\n",
      "LOGICAL OPERATORS EXAMPLE\n",
      "True\n",
      "True\n",
      "False\n"
     ]
    }
   ],
   "source": [
    "#COMPARISON OPERATORS\n",
    "print('COMPARISON OPERATORS EXAMPLES')\n",
    "x = 5\n",
    "y = 3\n",
    "print(x == y)        # Equal:returns False because 5 is not equal to 3\n",
    "\n",
    "print(x != y)        # not equal: returns True because 5 is not equal to 3\n",
    "\n",
    "print(x > y)         # greater than: returns True because 5 is greater than 3\n",
    "\n",
    "print(x < y)         # smaller than: returns False because 5 is not less than 3\n",
    "\n",
    "print(x >= y)        # greater than or equal to: returns True because five is greater, or equal, to 3\n",
    "\n",
    "print(x <= y)        # less than or equal to: returns False because 5 is neither less than or equal to 3\n",
    "\n",
    "print('LOGICAL OPERATORS EXAMPLE')\n",
    "\n",
    "print(x > 3 and x < 10)# returns True because 5 is greater than 3 AND 5 is less than 10\n",
    "\n",
    "print(x > 3 or x < 4)  # returns True because one of the conditions are true (5 is greater than 3, but 5 is not less than 4)\n",
    "\n",
    "print(not(x > 3 and x < 10))# returns False because not is used to reverse the result\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "True\n",
      "False\n",
      "True\n",
      "False\n",
      "True\n",
      "False\n"
     ]
    }
   ],
   "source": [
    "#IDENTITY OPERATORS\n",
    "x = [\"TARS\", \"CASE\"]\n",
    "y = [\"TARS\", \"CASE\"]\n",
    "z = x\n",
    "#is\n",
    "print(x is z) # returns True because z is the same object as x\n",
    "print(x is y) # returns False because x is not the same object as y, even if they have the same content\n",
    "print(x == y)# to demonstrate the difference betweeen \"is\" and \"==\": this comparison returns True because x is equal to y\n",
    "#is not\n",
    "print(x is not z) # returns False because z is the same object as x\n",
    "print(x is not y) # returns True because x is not the same object as y, even if they have the same content\n",
    "print(x != y)     # to demonstrate the difference betweeen \"is not\" and \"!=\": this comparison returns False because x is equal to y\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 45,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "MEMBERSHIP OPERATORS EXAMPLES\n",
      "True\n",
      "True\n",
      "BITWISE OPERATORS EXAMPLES\n",
      "Same\n"
     ]
    }
   ],
   "source": [
    "#MEMBERSHIP OPERATORS\n",
    "print('MEMBERSHIP OPERATORS EXAMPLES')\n",
    "x = [\"apple\", \"banana\"]\n",
    "print(\"banana\" in x)       # in: returns True because a sequence with the value \"banana\" is in the list\n",
    "print(\"pineapple\" not in x)#not in: returns True because a sequence with the value \"pineapple\" is not in the list\n",
    "\n",
    "#BITWISE OPERATORS\n",
    "#  &  AND                   Sets each bit to 1 if both bits are 1\n",
    "# |   OR                    Sets each bit to 1 if one of two bits is 1\n",
    "# ^   XOR                   Sets each bit to 1 if only one of two bits is 1\n",
    "# ~   NOT                   Inverts all the bits\n",
    "# <<  Zero fill left shift  Shift left by pushing zeros in from the right and let the leftmost bits fall off\n",
    "# >>  Signed right shift    Shift right by pushing copies of the leftmost bit in from the left, and let the rightmost bits fall off\n",
    "print('BITWISE OPERATORS EXAMPLES')\n",
    "a=2\n",
    "b=2\n",
    "if(a&b==2):\n",
    " print(\"Same\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "CHEERS!\n",
      "CHEERS!\n",
      "CHEERS!\n",
      "CHEERS!\n",
      "CHEERS!\n",
      "DONE\n"
     ]
    }
   ],
   "source": [
    "#14\n",
    "#LOOPS\n",
    "#WHILE LOOP\n",
    "n=5\n",
    "while n>0:\n",
    " print('CHEERS!')\n",
    " n=n-1\n",
    "print('DONE')\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "KUDOS!  Sumi\n",
      "KUDOS!  Abhi\n",
      "KUDOS!  Medha\n",
      "KUDOS!  Ismita\n",
      "KUDOS!  Ritzz\n"
     ]
    }
   ],
   "source": [
    "#FOR LOOP\n",
    "friends=['Sumi','Abhi','Medha','Ismita','Ritzz']\n",
    "for friend in friends:\n",
    " print('KUDOS! ',friend)    \n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 60,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Hello, Proff.Brand\n"
     ]
    }
   ],
   "source": [
    "#15\n",
    "#MODULES\n",
    "import createmodule as cm\n",
    "cm.intro('Proff.Brand')\n",
    "\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 58,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "TARS:\n",
      "Honesty,new setting- Ninety-Five percent!\n"
     ]
    }
   ],
   "source": [
    "#16\n",
    "#CLASSES, CONSTRUCTORS and OBJECTS\n",
    "class myClass():             #class declaration\n",
    "  def dia1(self):            #The self-argument refers to the object itself.\n",
    "                             #self will refer to the specific instance of this object that's being operated on.\n",
    "      print(\"TARS:\")\n",
    "        \n",
    "  def dia2(self,value):    \n",
    "      print(\"Honesty,new setting-\" + value)\n",
    "\n",
    "c = myClass ()               #c here is the object of the class\n",
    "c.dia1()\n",
    "c.dia2(\" Ninety-Five percent!\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Cars\n",
      "Aventador\n",
      "Urus\n",
      "Huracan\n"
     ]
    }
   ],
   "source": [
    "#17\n",
    "#EXTENDED CLASS(INHERITANCE)\n",
    "class Transport:                 #class declaration\n",
    "    def fourwheeler(self):\n",
    "        print(\"Cars\")\n",
    "    def Luxury(self):\n",
    "        print(\"Lambo\")\n",
    "    def Fantasy(self):\n",
    "        print(\"Dream Cars\")\n",
    "\n",
    "\n",
    "class Car(Transport):               #class car is inherited from Transport\n",
    "    def fourwheeler(self):\n",
    "        Transport.fourwheeler(self)\n",
    "        print(\"Aventador\")\n",
    "    def Luxury(self):\n",
    "        print(\"Urus\")\n",
    "    def Fantasy(self):\n",
    "        print(\"Huracan\")\n",
    "        \n",
    "c=Car()                        #object of class Car\n",
    "c.fourwheeler()                 #method of dog class\n",
    "c.Luxury()                        \n",
    "c.Fantasy()                       "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "...And that our greatest accomplishments cannot be behind us,because our destiny lies above us!\n"
     ]
    }
   ],
   "source": [
    "#18\n",
    "#FILE HANDLING\n",
    "f = open(\"newfile.txt\", \"a\")\n",
    "f.write(\"...And that our greatest accomplishments cannot be behind us,because our destiny lies above us!\")\n",
    "f.close()                    \n",
    "f = open(\"newfile.txt\", \"r\")#open and read the file after the appending\n",
    "print(f.read())\n",
    "\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.7.4"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}