All about Loops.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Loops"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "\n",
    "<tbody><tr>\n",
    "<th style=\"text-align:justify;\">Sr.No.</th>\n",
    "<th style=\"text-align:justify;\">Type of Loop.</th>\n",
    "<th style=\"text-align:justify;\">Description</th>\n",
    "</tr>\n",
    "<tr>\n",
    "<td class=\"ts\">1</td>\n",
    "<td>while loop</td>\n",
    "<td>Repeats a statement or group of statements while a given condition is TRUE. It tests the condition before executing the loop body.</td>\n",
    "\n",
    "</tr>\n",
    "<tr>\n",
    "<td class=\"ts\">2</td>\n",
    "<td>for loop</td>\n",
    "<td>Executes a sequence of statements multiple times and abbreviates the code that manages the loop variable.</td>\n",
    "</tr>\n",
    "<tr>\n",
    "<td class=\"ts\">3</td>\n",
    "<td>nested loops</td>\n",
    "<td>You can use one or more loop inside any another while, for or do..while loop.</td>\n",
    "</tr>\n",
    "</tbody>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "\n",
    "<tbody><tr>\n",
    "<th style=\"text-align:justify;\">Sr.No.</th>\n",
    "<th style=\"text-align:justify;\">Control Statement</th>\n",
    "<th style=\"text-align:justify;\">Description</th>\n",
    "</tr>\n",
    "<tr>\n",
    "<td>1</td>\n",
    "<td>break statement</td>\n",
    "<td>Terminates the loop statement and transfers execution to the statement immediately following the loop.</td>\n",
    "</tr>\n",
    "<tr>\n",
    "<td>2</td>\n",
    "<td>continue statement</td>\n",
    "<td>Causes the loop to skip the remainder of its body and immediately retest its condition prior to reiterating.</td>\n",
    "</tr>\n",
    "<tr>\n",
    "<td>3</td>\n",
    "<td>pass statement</td>\n",
    "<td>The pass statement in Python is used when a statement is required syntactically but you do not want any command or code to execute.</td>\n",
    "</tr>\n",
    "</tbody></table>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### While Loop"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Syntax\n",
    "# While expression/condition:\n",
    "#       statement(s)\n",
    "\n",
    "# Sum of first 10 numbers\n",
    "number = float(input(\"Enter the number:\"))\n",
    "sum_total = 0\n",
    "i = 0\n",
    "while i<=number:\n",
    "    sum_total += i\n",
    "    i += 1\n",
    "print(sum_total)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### for Loop"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#Syntax\n",
    "#for iterating_var in sequence:\n",
    "#   statements(s)\n",
    "\n",
    "# Note for loop works for sequences like list, tuple, range etc\n",
    "\n",
    "degrees = ['10th','intermediate','btech','mtech','phd']\n",
    "for i in degrees:\n",
    "    print(i)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "degrees = ['10th','intermediate','btech','mtech','phd']\n",
    "for i in range(0,len(degrees),2):\n",
    "    print(degrees[i])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### functions"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### types of arguemnts:\n",
    "1) Required arguements\n",
    "\n",
    "2) Keyword arguements\n",
    "\n",
    "3) Default arguements\n",
    "\n",
    "4) Variable-length arguments"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Define a function to greet the person\n",
    "\n",
    "def greet(name,msg): # Parameters are the names used when defining a function or a method :In this case name and msg\n",
    "    print(\"Hello\" , name + ', ' + msg)\n",
    "    \n",
    "greet('Harish','Good Evening!') #  arguments are the things which are supplied to any function or method call: In this case Harish and Good Evening\n",
    "\n",
    "#Talk about parameters and arguments"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "greet()\n",
    "\n",
    "#greet('Harish')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Default Argument\n",
    "\n",
    "def greet(name,msg=\"Good Evening\"):\n",
    "    print(\"Hello\" , name + ', ' + msg)\n",
    "    \n",
    "greet('Harish')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "greet('Harish','Good Morning')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#Note: Any number of arguments in a function can have a default value. \n",
    "#      But once we have a default argument, all the arguments to its right must also have default values.\n",
    "\n",
    "\n",
    "def greet(msg=\"Good Evening\",name):\n",
    "    print(\"Hello\" , name + ', ' + msg)\n",
    "    \n",
    "greet('Harish')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "## Python Keyword Arguments\n",
    "\n",
    "def greet(name,msg): # Parameters are the names used when defining a function or a method :In this case name and msg\n",
    "    print(\"Hello\" , name + ', ' + msg)\n",
    "\n",
    "# 2 keyword arguments\n",
    "greet(name=\"Harish\",msg=\"Good Evening\")\n",
    "\n",
    "# 2 keyword arguements\n",
    "greet(msg=\"How are you doing?\",name='Harish')\n",
    "\n",
    "# 1 keyword arguement and 1 positional argument\n",
    "greet(\"Harish\",msg=\"Good Morning\")\n",
    "\n",
    "# As we can see, we can mix positional arguments with keyword arguments during a function call. \n",
    "# But we must keep in mind that keyword arguments must follow positional arguments.\n",
    "\n",
    "greet(msg='Good Morning',\"Harish\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## List Comprehension"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# We will see 3 ways to solve a problem\n",
    "\n",
    "#Problem: Sum of squared numbers of a list\n",
    "\n",
    "list1 = [1,3,5,7,9]\n",
    "sum_squared = 0\n",
    "for i in range(len(list1)):\n",
    "    sum_squared += list1[i]**2\n",
    "print(sum_squared)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 2nd approach\n",
    "list1 = [1,3,5,7,9]\n",
    "sum_squared = 0\n",
    "for i in list1:\n",
    "    sum_squared += i**2\n",
    "print(sum_squared)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 3rd approach\n",
    "list1 = [1,3,5,7,9]\n",
    "sum_squared = sum([y**2 for y in list1])\n",
    "print(sum_squared)\n",
    "\n",
    "#This approach is called list comprehension"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# We can also use if in list comprehension\n",
    "\n",
    "#porblem: squared the even numbers in a list\n",
    "list2 = [1,2,3,4,5,6,7,8,9,10]\n",
    "#[y**2 if y%2==0 for y in list2]\n",
    "[y**2 for y in list2 if y%2==0]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#problem: square the even numbers and cube the odd numbers in a list\n",
    "[y**2 if y%2==0 else y**3 for y in list2]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Enumerate"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "list3 = ['green','yellow','red','blue']\n",
    "for i in list3:\n",
    "    print(i)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "for i,val in enumerate(list3):\n",
    "    print(\"index is \" + str(i) + \", value is \" + val)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Note: Use list comprehension  when you need a for loop."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Lambda functions\n",
    "\n",
    "In Python, an anonymous function means that a function is without a name. As we already know that the def keyword is used to define a normal function in Python. Similarly, the lambda keyword is used to define an anonymous function in Python. It has the following syntax: \n",
    "\n",
    "## Syntax: lambda arguments: expression"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Python code to illustrate cube of a number\n",
    "# showing difference between def() and lambda().\n",
    "def cube(y):\n",
    "    return y*y*y\n",
    " \n",
    "lambda_cube = lambda y: y*y*y\n",
    " \n",
    "# using the normally\n",
    "# defined function\n",
    "print(cube(5))\n",
    " \n",
    "# using the lambda function\n",
    "print(lambda_cube(5))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Lambda functions are commonly used in places where a throw-away function is required\n",
    "# Something You minght just use once, and hence need not create a named-function.\n",
    "# Common applications of Lambda expressions are sorting and filtering.\n",
    "# General Syntax > lambda inputs: expression\n",
    "# lambda x1, x2, x3, ..., xn: Expression\n",
    "# Some more examples : \n",
    "\n",
    "\n",
    "\n",
    "names = [{'name' : 'Brad', 'Age':24}, \n",
    "{'name' : 'Eve', 'Age' : 26},\n",
    "{'name' : 'Jacob', 'Age' : 21},\n",
    "{'name' : 'Joelene', 'Age' : 18},\n",
    "{'name' : 'Ashton', 'Age' : 24}]\n",
    "\n",
    "# using sorted and lambda to print list sorted\n",
    "# by age\n",
    "print(\"The list printed sorting by age: \")\n",
    "print(sorted(names, key = lambda i: i['Age']))\n",
    "\n",
    "# using sorted and lambda to print list sorted\n",
    "# by both age and name.\n",
    "\n",
    "print(\"The list printed sorting by age and name: \")\n",
    "print(sorted(names, key = lambda i: (i['Age'], i['name'])))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Define a function to extract the list of vowels\n",
    "\n",
    "# eg: input : ['a', 'b', 'd', 'e', 'i', 'j', 'o'] Output: ['a','e','i','o']\n",
    "\n",
    "l1 = ['a', 'b', 'd', 'e', 'i', 'j', 'o'] \n",
    "l2 = []\n",
    "for i in l1:\n",
    "    if i in ['a','e','i','o','u']:\n",
    "        l2.append(i)\n",
    "\n",
    "print(l2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "## Some important tips to know"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "## Spend some time on slicing\n",
    "#s[i:j:k] is, \"slice of s from i to j with step k\".\n",
    "\n",
    "\n",
    "list1 = [10,20,30,40,50,60,70,80,90]\n",
    "list1[-1:-9:1]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "## Some string operations\n",
    "\n",
    "str1 = \"Python Programming\"\n",
    "print(str1.split())\n",
    "print(str1.lower())\n",
    "print(str1.upper())\n",
    "print(max(['a','b']))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<h2> Data Type Conversion/Type Casting </h2>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<p>Python defines type conversion functions to directly convert one data type to another </p>\n",
    "<p>There are two types of Type Conversion in Python:</p>\n",
    "<ol><li>Implicit Type Conversion</li><li>Explicit Type Conversion</li></ol>\n",
    "\n",
    "<h2 style=\"text-align:center\">Implicit Type Conversion</h2>\n",
    "\n",
    "<p>In Implicit type conversion of data types in Python, the Python interpreter automatically converts one data type to another without any user involvement. </p>\n",
    "\n",
    "<h2 style=\"text-align:center\">Explicit Type Conversion</h2>\n",
    "<p>In Explicit Type Conversion in Python, the data type is manually changed by the user as per their requirement. Various form of explicit type conversion are explained below:<br>&nbsp;</p>\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<h2 style=\"text-align:center\">Implicit Type Conversion</h2>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "num_int = 123\n",
    "print(\"Type of num_int\",type(num_int))\n",
    "num_float = 456.1\n",
    "print(\"Type of num_float\",type(num_float))\n",
    "\n",
    "num_int + num_float"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "num_int = 10\n",
    "print(\"Type of num_int\",type(num_int))\n",
    "num_str = \"20\"\n",
    "print(\"Type of num_str\",type(num_str))\n",
    "\n",
    "num_int + num_str"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<h2 style=\"text-align:center\">Explicit Type Conversion</h2>\n",
    "<table class=\"grey\">\n",
    "<tbody><tr>\n",
    "<td class=\"greyout\"><b>Function</b></td>\n",
    "<td class=\"greyout\"><b>Converting what to what</b></td>\n",
    "<td class=\"greyout\"><b>Example</b></td>\n",
    "</tr>\n",
    "\n",
    "<tr>\n",
    "<td><br><tt style=\"font-size: 1.3em\">int()</tt></td>\n",
    "<td><br>string, floating point → integer </td>\n",
    "<td>\n",
    "<pre><span class=\"pysrc-prompt\">&gt;&gt;&gt; </span>int(<span class=\"pysrc-string\">'2014'</span>) \n",
    "<span class=\"pysrc-output\">2014</span> \n",
    "<span class=\"pysrc-prompt\">&gt;&gt;&gt; </span>int(3.141592)\n",
    "<span class=\"pysrc-output\">3</span> \n",
    "</pre></td></tr>\n",
    "\n",
    "<tr>\n",
    "<td><br><tt style=\"font-size: 1.3em\">float()</tt></td>\n",
    "<td><br>string, integer → floating point number</td>\n",
    "<td>\n",
    "<pre><span class=\"pysrc-prompt\">&gt;&gt;&gt; </span>float(<span class=\"pysrc-string\">'1.99'</span>) \n",
    "<span class=\"pysrc-output\">1.99</span> \n",
    "<span class=\"pysrc-prompt\">&gt;&gt;&gt; </span>float(5)\n",
    "<span class=\"pysrc-output\">5.0</span> \n",
    "</pre></td></tr>\n",
    "\n",
    "\n",
    "<tr>\n",
    "<td><br><tt style=\"font-size: 1.3em\">str()</tt></td>\n",
    "<td><br>integer, float, list, tuple, dictionary → string</td>\n",
    "<td>\n",
    "<pre><span class=\"pysrc-prompt\">&gt;&gt;&gt; </span>str(3.141592) \n",
    "<span class=\"pysrc-output\">'3.141592'</span> \n",
    "<span class=\"pysrc-prompt\">&gt;&gt;&gt; </span>str([1,2,3,4])\n",
    "<span class=\"pysrc-output\">'[1, 2, 3, 4]'</span> \n",
    "</pre></td></tr>\n",
    "\n",
    "<tr>\n",
    "<td><br><tt style=\"font-size: 1.3em\">list()</tt></td>\n",
    "<td><br>string, tuple, set, dictionary → list</td>\n",
    "<td>\n",
    "<pre><span class=\"pysrc-prompt\">&gt;&gt;&gt; </span>list(<span class=\"pysrc-string\">'Mary'</span>)      <span class=\"pysrc-comment\"># list of characters in 'Mary'</span> \n",
    "<span class=\"pysrc-output\">['M', 'a', 'r', 'y']</span> \n",
    "<span class=\"pysrc-prompt\">&gt;&gt;&gt; </span>list((1,2,3,4))   <span class=\"pysrc-comment\"># (1,2,3,4) is a tuple</span>\n",
    "<span class=\"pysrc-output\">[1, 2, 3, 4]</span> \n",
    "<span class=\"pysrc-prompt\">&gt;&gt;&gt; </span>list({1, 2, 3})   <span class=\"pysrc-comment\"># {1, 2, 3} is a set</span>\n",
    "<span class=\"pysrc-output\">[1, 2, 3]</span> \n",
    "</pre></td></tr>\n",
    "\n",
    "<tr>\n",
    "<td><br><tt style=\"font-size: 1.3em\">tuple()</tt></td>\n",
    "<td><br>string, list, set → tuple</td>\n",
    "<td>\n",
    "<pre><span class=\"pysrc-prompt\">&gt;&gt;&gt; </span>tuple(<span class=\"pysrc-string\">'Mary'</span>)\n",
    "<span class=\"pysrc-output\">('M', 'a', 'r', 'y')</span> \n",
    "<span class=\"pysrc-prompt\">&gt;&gt;&gt; </span>tuple([1,2,3,4])   <span class=\"pysrc-comment\"># [ ] for list, ( ) for tuple</span>\n",
    "<span class=\"pysrc-output\">(1, 2, 3, 4)</span> \n",
    "</pre></td></tr>\n",
    "\n",
    "<tr>\n",
    "<td><br><tt style=\"font-size: 1.3em\">set()</tt></td>\n",
    "<td><br>string, list, tuple → set</td>\n",
    "<td>\n",
    "<pre><span class=\"pysrc-prompt\">&gt;&gt;&gt; </span>set(<span class=\"pysrc-string\">'alabama'</span>)            <span class=\"pysrc-comment\"># unique character set from a string</span>\n",
    "<span class=\"pysrc-output\">{'b', 'm', 'l', 'a'}</span> \n",
    "<span class=\"pysrc-prompt\">&gt;&gt;&gt; </span>set([1, 2, 3, 3, 3, 2])   <span class=\"pysrc-comment\"># handy for removing duplicates from list</span>\n",
    "<span class=\"pysrc-output\">{1, 2, 3}</span> \n",
    "</pre></td></tr>\n",
    "    \n",
    "<tr>\n",
    "<td><br><tt style=\"font-size: 1.3em\">dict()</tt></td>\n",
    "<td><br>tuple of order(key,value) → dict (This function is used to convert a tuple of order (key,value) into a dictionary.)</td>\n",
    "<td><br>tup = (('a', 1) ,('f', 2), ('g', 3)) , dict(tup) , {'a': 1, 'f': 2, 'g': 3}\n",
    "</td></tr>\n",
    "\n",
    "    \n",
    "    \n",
    "</tbody></table>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "num_int = 10\n",
    "print(\"Type of num_int\",type(num_int))\n",
    "num_str = \"20\"\n",
    "print(\"Type of num_str\",type(num_str))\n",
    "\n",
    "num_str = int(num_str)\n",
    "\n",
    "num_int + num_str"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "str1 = \"python\"\n",
    "tuple(str1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "list1 = [('a',1),('b',10),('c',20)]\n",
    "dict(list1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "## Additional information\n",
    "# To convert data types using astype\n",
    "\n",
    "[1,2,3] + list({2,3,4})"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Operators"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Operatores"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Python divides the operators in the following groups:\n",
    "\n",
    "1. Arithmetic operators\n",
    "2. Assignment operators\n",
    "3. Comparison operators\n",
    "4. Logical operators\n",
    "5. Membership operators"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 1. Arithmetic Operators"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "\n",
    "<tbody><tr>\n",
    "<th style=\"width:25%\">Operator</th>\n",
    "<th style=\"width:35%\">Name</th>\n",
    "<th style=\"width:30%\">Example</th>\n",
    "</tr>\n",
    "<tr>\n",
    "<td>+</td>\n",
    "<td>Addition</td>\n",
    "<td>x + y</td>\n",
    "</tr>\n",
    "<tr>\n",
    "<td>-</td>\n",
    "<td>Subtraction</td>\n",
    "<td>x - y</td>\n",
    "</tr>\n",
    "<tr>\n",
    "<td>*</td>\n",
    "<td>Multiplication</td>\n",
    "<td>x * y</td>\n",
    "</tr>\n",
    "<tr>\n",
    "<td>/</td>\n",
    "<td>Division</td>\n",
    "<td>x / y</td>\n",
    "</tr>\n",
    "<tr>\n",
    "<td>%</td>\n",
    "<td>Modulus</td>\n",
    "<td>x % y</td>\n",
    "</tr>\n",
    "  <tr>\n",
    "<td>**</td>\n",
    "<td>Exponentiation</td>\n",
    "<td>x ** y</td>\n",
    "  </tr>\n",
    "<tr>\n",
    "<td>//</td>\n",
    "<td>Floor division</td>\n",
    "<td>x // y</td>\n",
    "</td>\n",
    "</tr>\n",
    "</tbody></table>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "a = 13\n",
    "b = 5\n",
    "\n",
    "print(a//b)\n",
    "print(a%b)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# only + operator is valid for list and tuple\n",
    "\n",
    "[1,2,3] + [3,4]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 2. Assignment Operators"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<tbody><tr>\n",
    "<th style=\"width:25%\">Operator</th>\n",
    "<th style=\"width:20%\">Example</th>\n",
    "<th style=\"width:20%\">Same As</th>\n",
    "</tr>\n",
    "<tr>\n",
    "<td>=</td>\n",
    "<td>x = 5</td>\n",
    "<td>x = 5</td>\n",
    "</tr>\n",
    "  <tr>\n",
    "<td>+=</td>\n",
    "<td>x += 3</td>\n",
    "<td>x = x + 3</td>\n",
    "  </tr>\n",
    "  <tr>\n",
    "<td>-=</td>\n",
    "<td>x -= 3</td>\n",
    "<td>x = x - 3</td>\n",
    "  </tr>\n",
    "  <tr>\n",
    "<td>*=</td>\n",
    "<td>x *= 3</td>\n",
    "<td>x = x * 3</td>\n",
    "  </tr>\n",
    "  <tr>\n",
    "<td>/=</td>\n",
    "<td>x /= 3</td>\n",
    "<td>x = x / 3</td>\n",
    "  </tr>\n",
    "  <tr>\n",
    "<td>%=</td>\n",
    "<td>x %= 3</td>\n",
    "<td>x = x % 3</td>\n",
    "  </tr>\n",
    "  <tr>\n",
    "<td>//=</td>\n",
    "<td>x //= 3</td>\n",
    "<td>x = x // 3</td>\n",
    "  </tr>\n",
    "  <tr>\n",
    "<td>**=</td>\n",
    "<td>x **= 3</td>\n",
    "<td>x = x ** 3</td>\n",
    "  </tr>\n",
    "\n",
    "</tbody></table>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 3. Comparision Operators"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<tbody><tr>\n",
    "<th style=\"width:25%\">Operator</th>\n",
    "<th style=\"width:35%\">Name</th>\n",
    "<th style=\"width:30%\">Example</th>\n",
    "</tr>\n",
    "<tr>\n",
    "<td>==</td>\n",
    "<td>Equal</td>\n",
    "<td>x == y</td>\n",
    "</tr>\n",
    "<tr>\n",
    "<td>!=</td>\n",
    "<td>Not equal</td>\n",
    "<td>x != y</td>\n",
    "</tr>\n",
    "<tr>\n",
    "<td>&gt;</td>\n",
    "<td>Greater than</td>\n",
    "<td>x &gt; y</td>\n",
    "</tr>\n",
    "<tr>\n",
    "<td>&lt;</td>\n",
    "<td>Less than</td>\n",
    "<td>x &lt; y</td>\n",
    "</tr>\n",
    "  <tr>\n",
    "<td>&gt;=</td>\n",
    "<td>Greater than or equal to</td>\n",
    "<td>x &gt;= y</td>\n",
    "  </tr>\n",
    "<tr>\n",
    "<td>&lt;=</td>\n",
    "<td>Less than or equal to</td>\n",
    "<td>x &lt;= y</td>\n",
    "</tr>\n",
    "</tbody></table>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 4. Logical Operators"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<table class=\"\">\n",
    "<tbody><tr>\n",
    "<th style=\"width:25%\">Operator</th>\n",
    "<th style=\"width:35%\">Description</th>\n",
    "<th style=\"width:30%\">Example</th>\n",
    "</tr>\n",
    "<tr>\n",
    "<td>and&nbsp;</td>\n",
    "<td>Returns True if both statements are true</td>\n",
    "<td>x &lt; 5 and&nbsp; x &lt; 10</td>\n",
    "</tr>\n",
    "<tr>\n",
    "<td>or</td>\n",
    "<td>Returns True if one of the statements is true</td>\n",
    "<td>x &lt; 5 or x &lt; 4</td>\n",
    "</tr>\n",
    "<tr>\n",
    "<td>not</td>\n",
    "<td>Reverse the result, returns False if the result is true</td>\n",
    "<td>not(x &lt; 5 and x &lt; 10)</td>\n",
    "</tr>\n",
    "</tbody></table>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 5. Membership Operators"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "\n",
    "<tbody><tr>\n",
    "<th style=\"width:25%\">Operator</th>\n",
    "<th style=\"width:35%\">Description</th>\n",
    "<th style=\"width:30%\">Example</th>\n",
    "\n",
    "</tr>\n",
    "<tr>\n",
    "<td>in&nbsp;</td>\n",
    "<td>Returns True if a sequence with the specified value is present in the object</td>\n",
    "<td>x in y</td>\n",
    "</tr>\n",
    "<tr>\n",
    "<td>not in</td>\n",
    "<td>Returns True if a sequence with the specified value is not present in the \n",
    "object</td>\n",
    "<td>x not in y</td>\n",
    "</tr>\n",
    "</tbody></table>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 34
    },
    "colab_type": "code",
    "id": "2OSqzORfVxa3",
    "outputId": "03e40422-9c97-4688-c78d-655671728f9e"
   },
   "outputs": [],
   "source": [
    "\"Jan\" in set1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 68
    },
    "colab_type": "code",
    "id": "ZXJ08r8dSezk",
    "outputId": "07727463-7a53-4e3a-deb2-feff0de95483"
   },
   "outputs": [],
   "source": [
    "for i in set1:\n",
    "  print(i)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## if - else "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Check weather a num of positive or negative\n",
    "num = 10\n",
    "if num >= 0:\n",
    "    if num == 0:\n",
    "        print(\"Zero\")\n",
    "    else:\n",
    "        print(\"Positive number\")\n",
    "else:\n",
    "    print(\"Negative number\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# check weather a num if positive or negative or zero\n",
    "num = 10\n",
    "if num == 0:\n",
    "    print(\"Zero\")\n",
    "elif num >0:\n",
    "    print(\"Positive number\")\n",
    "else:\n",
    "    print(\"Negative number\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Short hand if statement\n",
    "\n",
    "if 100 > 12: print(\"Inside if condition\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Short hand of if-else statement\n",
    "marks = 37\n",
    "\n",
    "print(\"Student passed\") if marks > 36 else print(\"Student failed\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "num = float(input(\"Enter a number: \"))\n",
    "#if num == 0:\n",
    "#    print(\"Zero\")\n",
    "#elif num >0:\n",
    "#    print(\"Positive number\")\n",
    "#else:\n",
    "#    print(\"Negative number\")\n",
    "    \n",
    "print(\"zero\") if num == 0 else print(\"Positive number\") if num >0 else print(\"Negative Number\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Loops"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "\n",
    "<tbody><tr>\n",
    "<th style=\"text-align:justify;\">Sr.No.</th>\n",
    "<th style=\"text-align:justify;\">Type of Loop.</th>\n",
    "<th style=\"text-align:justify;\">Description</th>\n",
    "</tr>\n",
    "<tr>\n",
    "<td class=\"ts\">1</td>\n",
    "<td>while loop</td>\n",
    "<td>Repeats a statement or group of statements while a given condition is TRUE. It tests the condition before executing the loop body.</td>\n",
    "\n",
    "</tr>\n",
    "<tr>\n",
    "<td class=\"ts\">2</td>\n",
    "<td>for loop</td>\n",
    "<td>Executes a sequence of statements multiple times and abbreviates the code that manages the loop variable.</td>\n",
    "</tr>\n",
    "<tr>\n",
    "<td class=\"ts\">3</td>\n",
    "<td>nested loops</td>\n",
    "<td>You can use one or more loop inside any another while, for or do..while loop.</td>\n",
    "</tr>\n",
    "</tbody>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "\n",
    "<tbody><tr>\n",
    "<th style=\"text-align:justify;\">Sr.No.</th>\n",
    "<th style=\"text-align:justify;\">Control Statement</th>\n",
    "<th style=\"text-align:justify;\">Description</th>\n",
    "</tr>\n",
    "<tr>\n",
    "<td>1</td>\n",
    "<td>break statement</td>\n",
    "<td>Terminates the loop statement and transfers execution to the statement immediately following the loop.</td>\n",
    "</tr>\n",
    "<tr>\n",
    "<td>2</td>\n",
    "<td>continue statement</td>\n",
    "<td>Causes the loop to skip the remainder of its body and immediately retest its condition prior to reiterating.</td>\n",
    "</tr>\n",
    "<tr>\n",
    "<td>3</td>\n",
    "<td>pass statement</td>\n",
    "<td>The pass statement in Python is used when a statement is required syntactically but you do not want any command or code to execute.</td>\n",
    "</tr>\n",
    "</tbody></table>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### While Loop"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Syntax\n",
    "# While expression/condition:\n",
    "#       statement(s)\n",
    "\n",
    "# Sum of first 10 numbers\n",
    "number = 5\n",
    "sum_total = 0\n",
    "i = 0\n",
    "while i<=number:\n",
    "    sum_total += i\n",
    "    i += 1\n",
    "print(sum_total)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "l1 = []\n",
    "while l1:\n",
    "    print(1)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### for Loop"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#Syntax\n",
    "#for iterating_var in sequence:\n",
    "#   statements(s)\n",
    "\n",
    "# Note for loop works for sequences like list, tuple, range etc\n",
    "\n",
    "degrees = ['10th','intermediate','btech','mtech','phd']\n",
    "for i in degrees:\n",
    "    print(i)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "degrees = ['10th','intermediate','btech','mtech','phd']\n",
    "for i in range(0,len(degrees),2):\n",
    "    print(degrees[i])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### functions"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Define a function to greet the person\n",
    "\n",
    "def greet(name,msg): # Parameters are the names used when defining a function or a method :In this case name and msg\n",
    "    print(\"Hello\" , name + ', ' + msg)\n",
    "    \n",
    "greet('Harish','Good Evening!') #  arguments are the things which are supplied to any function or method call: In this case Harish and Good Evening\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "greet()\n",
    "\n",
    "#greet('Harish')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# If no of arguments are not defined\n",
    "# Arbitrary Arguments, *args\n",
    "\n",
    "def greet(*args):\n",
    "    print(args[0])\n",
    "    \n",
    "greet('Harsha')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def greet(name,*msg):\n",
    "    print(name)\n",
    "    for arg in msg:\n",
    "        print(arg)\n",
    "        \n",
    "greet(\"harsha\",\"wish you all the best\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## List Comprehension"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# We will see 3 ways to solve a problem\n",
    "\n",
    "#Problem: Sum of squared numbers of a list\n",
    "\n",
    "list1 = [1,3,5,7,9]\n",
    "sum_squared = 0\n",
    "for i in range(len(list1)):\n",
    "    sum_squared += list1[i]**2\n",
    "print(sum_squared)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 2nd approach\n",
    "list1 = [1,3,5,7,9]\n",
    "sum_squared = 0\n",
    "for i in list1:\n",
    "    sum_squared += i**2\n",
    "print(sum_squared)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 3rd approach\n",
    "list1 = [1,3,5,7,9]\n",
    "sum_squared = sum([y**2 for y in list1])\n",
    "print(sum_squared)\n",
    "\n",
    "#This approach is called list comprehension"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# We can also use if in list comprehension\n",
    "\n",
    "#problem: squared the even numbers in a list\n",
    "list2 = [1,2,3,4,5,6,7,8,9,10]\n",
    "#[y**2 if y%2==0 for y in list2]\n",
    "[y**2 for y in list2 if y%2==0]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#problem: square the even numbers and cube the odd numbers in a list\n",
    "[y**2 if y%2==0 else y**3 for y in list2]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Note: Use list comprehension  when you need a for loop."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Define a function to extract the list of vowels\n",
    "\n",
    "# eg: input : ['a', 'b', 'd', 'e', 'i', 'j', 'o'] Output: ['a','e','i','o']\n",
    "\n",
    "l1 = ['a', 'b', 'd', 'e', 'i', 'j', 'o'] \n",
    "l2 = []\n",
    "for i in l1:\n",
    "    if i in ['a','e','i','o','u']:\n",
    "        l2.append(i)\n",
    "\n",
    "print(l2)"
   ]
  }
 ],
 "metadata": {
  "interpreter": {
   "hash": "31f2aee4e71d21fbe5cf8b01ff0e069b9275f58929596ceb00d14d90e3e16cd6"
  },
  "kernelspec": {
   "display_name": "Python 3.8.9 64-bit",
   "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.9"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}