30-days-of-code.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Day 1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1. Python Keyword\n",
      "['False', 'None', 'True', 'and', 'as', 'assert', 'async', 'await', 'break', 'class', 'continue', 'def', 'del', 'elif', 'else', 'except', 'finally', 'for', 'from', 'global', 'if', 'import', 'in', 'is', 'lambda', 'nonlocal', 'not', 'or', 'pass', 'raise', 'return', 'try', 'while', 'with', 'yield'] \n",
      "\n",
      "Total keyword count in python is:  35\n"
     ]
    }
   ],
   "source": [
    "#TODO Get all keywords in Python\n",
    "\n",
    "import keyword\n",
    "print(\"1. Python Keyword\")\n",
    "print(keyword.kwlist, \"\\n\")\n",
    "\n",
    "print(\"Total keyword count in python is: \", len(keyword.kwlist))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "\n",
      "2. Yield keyword\n",
      "Yeild generator function output:\n",
      "0\n",
      "1\n",
      "2\n",
      "3\n",
      "4\n",
      "5\n",
      "6\n",
      "7\n",
      "8\n",
      "9\n"
     ]
    }
   ],
   "source": [
    "#Yield keyword\n",
    "print(\"\\n\\n2. Yield keyword\")\n",
    "## generator function\n",
    "def yieldFunction():\n",
    "    for i in range(10):\n",
    "        yield(i)\n",
    "    \n",
    "\n",
    "#print \n",
    "print(\"Yeild generator function output:\")\n",
    "for x in yieldFunction():\n",
    "    \n",
    "    print(x)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "\n",
      "3. Python Statement\n",
      "\n",
      "New Line Character\n",
      "Output: 56 \n",
      "\n",
      "Line Continuation Character\n",
      "Output: 56 \n",
      "\n",
      "Multiple statement in single line using ';'\n",
      "20 \n",
      "33 \n"
     ]
    }
   ],
   "source": [
    "#Python Statement\n",
    "print(\"\\n\\n3. Python Statement\")\n",
    "\n",
    "print(\"\\nNew Line Character\")\n",
    "a = 1 + 23 + \\\n",
    "    21 + 2 + \\\n",
    "    9\n",
    "\n",
    "print(\"Output:\",a,\"\")\n",
    "\n",
    "\n",
    "print(\"\\nLine Continuation Character\")\n",
    "a = (1 + 23 + \n",
    "    21 + 2 + \n",
    "    9)\n",
    "\n",
    "print(\"Output:\",a,\"\")\n",
    "\n",
    "print(\"\\nMultiple statement in single line using ';'\")\n",
    "a = 20; b = 21; c = 12; print(a,\"\"); print(b+c,\"\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Day 2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "4. Variables in python\n",
      "a =  2 ,\n",
      "b =  5.3 ,\n",
      "c =  Python is awesome \n",
      "\n"
     ]
    }
   ],
   "source": [
    "#Variables in python\n",
    "print(\"\\n4. Variables in python\")\n",
    "\n",
    "a = 2\n",
    "b = 5.3\n",
    "c = \"Python is awesome\"\n",
    "\n",
    "print(\"a = \",a, ',\\nb = ', b,',\\nc = ', c,'\\n')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "5. Multiple Assignment\n",
      "\n",
      "Assigning different values to different variables in single line\n",
      "a, b, c = 10, 5.2, \"Python Multiple Assignment\"\n",
      "a =  10\n",
      "b =  5.2\n",
      "c =  Python Multiple Assignment\n",
      "\n",
      "Assigning same values to different variables at once\n",
      "a = b = c = \"Same Data assigned to multiple variables\"\n",
      "a =  Same Data assigned to multiple variables\n",
      "b =  Same Data assigned to multiple variables\n",
      "c =  Same Data assigned to multiple variables\n"
     ]
    }
   ],
   "source": [
    "#Multiple Assignment \n",
    "print(\"\\n5. Multiple Assignment\")\n",
    "\n",
    "\n",
    "#Assigning different values to different variables in single line\n",
    "print(\"\\nAssigning different values to different variables in single line\")\n",
    "\n",
    "a, b, c = 10, 5.2, \"Python Multiple Assignment\"\n",
    "\n",
    "print(\"a, b, c = 10, 5.2, \\\"Python Multiple Assignment\\\"\")\n",
    "print(\"a = \", a)\n",
    "print(\"b = \", b)\n",
    "print(\"c = \", c)\n",
    "\n",
    "#Assigning same values to different variables at once\n",
    "print(\"\\nAssigning same values to different variables at once\")\n",
    "\n",
    "a = b = c = \"Same Data assigned to multiple variables\"\n",
    "\n",
    "print(\"a = b = c = \\\"Same Data assigned to multiple variables\\\"\")\n",
    "print(\"a = \", a)\n",
    "print(\"b = \", b)\n",
    "print(\"c = \", c)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 58,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "6. Storage Location in Python\n",
      "id(x) is used to get the location of variable x in memory.\n",
      "x = 10\n",
      "Location of variable x is 4299568544\n",
      "y = 10\n",
      "Location of variable y is 4299568544\n",
      "\n",
      "Note: Both x and y refrence to same memory location that's why there memory address is same,\n",
      "Python link the new defined variable y to same memory location if that data is already in momory\n",
      "\n",
      "If we change the value it point to a new memory address\n",
      "y = 20\n",
      "Location of variable y is 4299568864\n"
     ]
    }
   ],
   "source": [
    "#Storage Location in Python\n",
    "print(\"\\n6. Storage Location in Python\")\n",
    "print(\"id(x) is used to get the location of variable x in memory.\")\n",
    "\n",
    "x = 10\n",
    "print(\"x = 10\")\n",
    "print(\"Location of variable x is\",id(x))\n",
    "\n",
    "y = 10\n",
    "print(\"y = 10\")\n",
    "print(\"Location of variable y is\",id(y))\n",
    "\n",
    "print(\"\"\"\\nNote: Both x and y refrence to same memory location that's why there memory address is same,\n",
    "Python link the new defined variable y to same memory location if that data is already in momory\"\"\")\n",
    "\n",
    "\n",
    "print(\"\\nIf we change the value it point to a new memory address\")\n",
    "y = 20\n",
    "print(\"y = 20\")\n",
    "print(\"Location of variable y is\", id(y))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "7. Data Types in Python\n",
      "\n",
      "Numbers\n",
      "x = 4\n",
      "We will use type(x) function to identify the type of data\n",
      "4 is type of <class 'int'>\n",
      "x = 4.44\n",
      "4.44 is type of <class 'float'>\n",
      "x = 1 + 2j\n",
      "(1+2j) is type of <class 'complex'>\n",
      "\n",
      "\n",
      "String\n",
      "x = \"Python is awesome\"\n",
      "Python is awesome\n",
      "Type of x <class 'str'>\n",
      "Length of x 17\n",
      "Last character of x is e\n",
      "Sub-String or Slice of string x from position 2 to 9 is \" thon is \"\n"
     ]
    }
   ],
   "source": [
    "#Data Types in Python\n",
    "print(\"\\n7. Data Types in Python\")\n",
    "\n",
    "#Numbers\n",
    "print(\"\\nNumbers\")\n",
    "x = 4\n",
    "print(\"x = 4\")\n",
    "print(\"We will use type(x) function to identify the type of data\")\n",
    "print(x, 'is type of', type(x))\n",
    "\n",
    "x = 4.44\n",
    "print(\"x = 4.44\")\n",
    "print(x, 'is type of', type(x))\n",
    "\n",
    "x = 1 + 2j\n",
    "print(\"x = 1 + 2j\")\n",
    "print(x, 'is type of', type(x))\n",
    "\n",
    "\n",
    "print(\"\\n\\nString\")\n",
    "\n",
    "x = \"Python is awesome\"\n",
    "print(\"x = \\\"Python is awesome\\\"\")\n",
    "print(x)\n",
    "print(\"Type of x\", type(x))\n",
    "print(\"Length of x\", len(x))\n",
    "print(\"Last character of x is\",x[len(x) - 1])\n",
    "print(\"Sub-String or Slice of string x from position 2 to 9 is \\\"\", x[2:9],\"\\\"\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Day 3"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "7. Data Types in Python\n",
      "\n",
      "List\n",
      "[1, 34.4, 'Python List item']\n",
      "1\n",
      "34.4\n",
      "Python List item\n",
      "[1, 34.4, 23]\n",
      "\n",
      "Tupples\n",
      "(5, 4.5, 'Hello Python')\n",
      "5\n",
      "4.5\n",
      "Hello Python\n",
      "\n",
      "Set\n",
      "{10, 43, 20, 50}\n",
      "Set is an unorderd collection of unique items\n",
      "<class 'set'>\n",
      "{10, 43, 50, 20, 28, 30}\n",
      "\n",
      "Dictionary\n",
      "{'a': 10, 'b': 23, 'c': 'Hello'}\n",
      "10\n"
     ]
    }
   ],
   "source": [
    "#Data Types in Python\n",
    "print(\"\\n7. Data Types in Python\")\n",
    "\n",
    "print(\"\\nList\")\n",
    "\n",
    "a = [1, 34.4, \"Python List item\"]\n",
    "print(a)\n",
    "print(a[0])\n",
    "print(a[1])\n",
    "print(a[2])\n",
    "\n",
    "a[2] = 23\n",
    "print(a) #We can change the value of list which means its mutable\n",
    "\n",
    "\n",
    "print(\"\\nTupples\")\n",
    "\n",
    "a = (5, 4.5, \"Hello Python\")\n",
    "print(a)\n",
    "print(a[0])\n",
    "print(a[1])\n",
    "print(a[2])\n",
    "# a[0] = 1 we can not change the value of a tupple as its immutable.\n",
    "\n",
    "\n",
    "print(\"\\nSet\")\n",
    "\n",
    "a= {10, 20, 43,50}\n",
    "print(a)\n",
    "print(\"Set is an unorderd collection of unique items\")\n",
    "\n",
    "print(type(a))\n",
    "\n",
    "a = {10,10,20,43, 50, 28, 20, 30, 10}\n",
    "print(a) #Set do not consider duplicate values\n",
    "\n",
    "print(\"\\nDictionary\")\n",
    "x = {'a': 10, 'b': 23, 'c':\"Hello\"}\n",
    "\n",
    "print(x)\n",
    "print(x['a'])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Day 4"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "8. Standard Input and Output in Python\n",
      "\n",
      "Standard Output\n",
      "We use print() function to output data to output device\n",
      "hello python world\n",
      "The value of a is 10\n",
      "The value of a is 10\n",
      "The value of a is 10 and value of b is 20\n",
      "The value of a is 20 and value of b is 10\n",
      "Hello my name is Ravi and my age is 24\n",
      "\n",
      "Standard Input\n"
     ]
    }
   ],
   "source": [
    "#Standard Input and Output in Python\n",
    "print(\"\\n8. Standard Input and Output in Python\")\n",
    "\n",
    "\n",
    "print(\"\\nStandard Output\")\n",
    "#We use print() function to output data to output device\n",
    "print(\"We use print() function to output data to output device\")\n",
    "print(\"hello python world\")\n",
    "\n",
    "\n",
    "a =10 \n",
    "print(\"The value of a is\", a) #in python 3 and above\n",
    "print(\"The value of a is \" + str(a))\n",
    "\n",
    "\n",
    "a = 10; b = 20\n",
    "\n",
    "\n",
    "print(\"The value of a is {} and value of b is {}\".format(a, b))\n",
    "print(\"The value of a is {1} and value of b is {0}\".format(a, b))\n",
    "print(\"Hello my name is {name} and my age is {age}\".format(name = \"Ravi\", age = 24))\n",
    "\n",
    "\n",
    "\n",
    "print(\"\\nStandard Input\")\n",
    "age = input(\"Enter your age\")\n",
    "print(\"Your age is\", age)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "\n",
    "## Day 5\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 58,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "9. Operators\n",
      "\n",
      "Arithmetic Operator\n",
      "12\n",
      "20\n",
      "5.0\n",
      "2\n",
      "5\n",
      "100\n",
      "\n",
      "Comparision Operator\n",
      "False\n",
      "\n",
      "Logical Operator\n",
      "False\n",
      "True\n",
      "\n",
      "Biwise Operator\n",
      "0\n",
      "14\n",
      "\n",
      "Assignment Operators\n",
      "7\n"
     ]
    }
   ],
   "source": [
    "print(\"\\n9. Operators\")\n",
    "\n",
    "print(\"\\nArithmetic Operator\")\n",
    "\n",
    "# +, -, *, /, %, //, ** these are arithmetic operator in python\n",
    "\n",
    "x, y  = 10, 2\n",
    "#addition\n",
    "print(x + y) \n",
    "print(x * y)\n",
    "print(x / y)\n",
    "print(y % x)\n",
    "print(x // y)\n",
    "print(x ** y)\n",
    "\n",
    "print(\"\\nComparision Operator\")\n",
    "\n",
    "# <, >, ==, !=, >=, <= are comparision operators\n",
    "print(x < y) # check x is less than y\n",
    "\n",
    "print(\"\\nLogical Operator\")\n",
    "# and, or, not are operators\n",
    "a , b = True, False\n",
    "print(a and b)\n",
    "print(a and a)\n",
    "\n",
    "print(\"\\nBitwise Operator\")\n",
    "# &, |, ~, ^, >>, << are bitwise operators\n",
    "\n",
    "a , b = 10, 4\n",
    "\n",
    "#Bitwise AND\n",
    "print(a & b)\n",
    "\n",
    "#Bitwise OR\n",
    "print(a | b)\n",
    "\n",
    "print(\"\\nAssignment Operators\")\n",
    "\n",
    "# =, +=, -=, *=, /=, %=, //=, **=, &=, |=, ^=, >>=, <<= are assignment operators\n",
    "\n",
    "a = 2\n",
    "a+=5\n",
    "print(a)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Day 6"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "10. Special Operators\n",
      "\n",
      "Identity Operators\n",
      "True\n",
      "False\n",
      "True\n",
      "False\n",
      "\n",
      "MemberShip Operators\n",
      "True\n",
      "False\n",
      "True\n",
      "False\n"
     ]
    }
   ],
   "source": [
    "print(\"\\n10. Special Operators\")\n",
    "\n",
    "print(\"\\nIdentity Operators\")\n",
    "# \"is\" keyword is used to check the identity between two\n",
    "a = 5\n",
    "b = 5\n",
    "print(a is b)\n",
    "\n",
    "x = [11, 22, 33]\n",
    "y = [11, 22, 33]\n",
    "\n",
    "print(x is y)\n",
    "\n",
    "s1 = \"Python\"\n",
    "s2 = \"Python\"\n",
    "\n",
    "print(s1 is s2)\n",
    "print(s1 is not s2)\n",
    "\n",
    "print(\"\\nMemberShip Operators\")\n",
    "# \"in\" and \"not in\" are the membership operators in python\n",
    "a = [1, 2, 3, 4]\n",
    "print(1 in a)\n",
    "print(23 in a)\n",
    "\n",
    "d = {1: \"a\", 2: \"c\"}\n",
    "print( 1 in d)\n",
    "print(\"a\" in d)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Day 7"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "11. Control Flow: if else\n",
      "\n",
      "if statement syntax\n",
      "Greater\n",
      "This will print always whether it satisfies condition or not.\n",
      "\n",
      "if else statement syntax\n",
      "Greater\n",
      "This will print always whether it satisfies condition or not.\n",
      "\n",
      "if elif else statement syntax\n",
      "n is 10\n",
      "This will print always whether it satisfies condition or not.\n",
      "\n",
      "Nested \"if\" statement\n",
      "Positive Number\n"
     ]
    }
   ],
   "source": [
    "print(\"\\n11. Control Flow: if else\")\n",
    "\n",
    "\n",
    "print(\"\\nif statement syntax\")\n",
    "\n",
    "n = 10\n",
    "if n > 0:\n",
    "    print(\"Greater\")\n",
    "print(\"This will print always whether it satisfies condition or not.\")\n",
    "\n",
    "print(\"\\nif else statement syntax\")\n",
    "\n",
    "n = 10\n",
    "if n > 0:\n",
    "    print(\"Greater\")\n",
    "else:\n",
    "    print(\"Smaller\")\n",
    "print(\"This will print always whether it satisfies condition or not.\")\n",
    "\n",
    "\n",
    "print(\"\\nif elif else statement syntax\")\n",
    "n = 10\n",
    "if n == 10 :\n",
    "    print(\"n is 10\")\n",
    "elif (n > 0):\n",
    "    print(\"Greater\")\n",
    "else:\n",
    "    print(\"Smaller\")\n",
    "print(\"This will print always whether it satisfies condition or not.\")\n",
    "\n",
    "\n",
    "print(\"\\nNested \\\"if\\\" statement\")\n",
    "num = 10.2\n",
    "\n",
    "if num >=0:\n",
    "    if num == 0:\n",
    "        print(\"Zero\")\n",
    "    else:\n",
    "        print(\"Positive Number\")\n",
    "else:\n",
    "    print(\"Negative Number\")\n",
    "\n",
    "#Todo : Python porogram to find the largest element among three numbers\n",
    "\n",
    "num1 = 100\n",
    "num2 = 20\n",
    "num3 = 150\n",
    "\n",
    "if(num1> num2) and (num1 > num3):\n",
    "    largest = num1\n",
    "elif (num2 >= num1) and (num2 >= num3):\n",
    "    largest = num2\n",
    "else:\n",
    "    largest = num3\n",
    "print(largest)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Day 8"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "12. Contriol Flow: while loop\n",
      "\n",
      "While Loop\n",
      "Sum is:150\n",
      "\n",
      "While loop with else\n",
      "10\n",
      "20\n",
      "30\n",
      "40\n",
      "50\n",
      "No item left in list\n"
     ]
    }
   ],
   "source": [
    "print(\"\\n12. Contriol Flow: while loop\")\n",
    "\n",
    "#Syntax:\n",
    "# while test_expression:\n",
    "#    Body of while\n",
    "\n",
    "\n",
    "print('\\nWhile Loop')\n",
    "a = [10,20,30,40,50]\n",
    "sumVal = 0\n",
    "index = 0\n",
    "\n",
    "while index < len(a):\n",
    "    sumVal += a[index]\n",
    "    index +=1\n",
    "    \n",
    "print('Sum is:{}'.format(sumVal))\n",
    "\n",
    "\n",
    "\n",
    "print('\\nWhile loop with else')\n",
    "a = [10,20,30,40,50]\n",
    "index = 0\n",
    "\n",
    "while index< len(a):\n",
    "    print(a[index])\n",
    "    index += 1\n",
    "else:\n",
    "    print('No item left in list')\n",
    "\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {
    "scrolled": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "13. Contriol Flow: for loop\n",
      "\n",
      "for loop\n",
      "10\n",
      "20\n",
      "30\n",
      "40\n",
      "50\n",
      "\n",
      "Range function\n",
      "0\n",
      "1\n",
      "2\n",
      "3\n",
      "4\n",
      "5\n",
      "6\n",
      "7\n",
      "8\n",
      "9\n",
      "\n",
      "Range function with step size\n",
      "20\n",
      "30\n",
      "40\n",
      "50\n",
      "60\n",
      "70\n",
      "80\n",
      "90\n",
      "100\n",
      "110\n",
      "120\n",
      "130\n",
      "140\n",
      "150\n",
      "160\n",
      "170\n",
      "180\n",
      "190\n",
      "\n",
      "Range function : iterate over the list using index\n",
      "ravi\n",
      "shankar\n",
      "singh\n",
      "\n",
      "Range function : iterate over elements in the list\n",
      "ravi\n",
      "shankar\n",
      "singh\n",
      "\n",
      "for loop with else\n",
      "10\n",
      "20\n",
      "30\n",
      "40\n",
      "50\n",
      "No item found\n"
     ]
    }
   ],
   "source": [
    "print(\"\\n13. Contriol Flow: for loop\")\n",
    "\n",
    "#Syntax:\n",
    "# for element in sequence:\n",
    "#    Body of for\n",
    "\n",
    "\n",
    "print('\\nfor loop')\n",
    "a = [10,20,30,40,50]\n",
    "\n",
    "for element in a:\n",
    "    print(element)\n",
    "\n",
    "    \n",
    "print('\\nRange function')\n",
    "#print range of 10\n",
    "for i in range(10):\n",
    "    print(i)\n",
    "    \n",
    "#print range of number from 20 to 200 with step size of 10\n",
    "print('\\nRange function with step size')\n",
    "for i in range(20, 200, 10):\n",
    "    print(i)\n",
    "\n",
    "    \n",
    "#iterate over the list using index\n",
    "print('\\nRange function : iterate over the list using index')\n",
    "b = [\"ravi\", \"shankar\", \"singh\"]\n",
    "for index in range(len(b)):\n",
    "    print(b[index])\n",
    "    \n",
    "#iterate over elements in the list\n",
    "print('\\nRange function : iterate over elements in the list')\n",
    "for element in b:\n",
    "    print(element)\n",
    "    \n",
    "\n",
    "print('\\nfor loop with else')\n",
    "a = [10,20,30,40,50]\n",
    "for element in a:\n",
    "    print(element)\n",
    "else:\n",
    "    print('No item found')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Day 9"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "13. Contriol Flow: break and continue\n",
      "\n",
      "break:\n",
      "1\n",
      "2\n",
      "2\n",
      "Outside loop\n"
     ]
    }
   ],
   "source": [
    "print(\"\\n13. Contriol Flow: break and continue\")\n",
    "\n",
    "\n",
    "print('\\nbreak:')\n",
    "#syntax : \n",
    "# for var in sequence:\n",
    "#     code inside loop\n",
    "#     if condition:\n",
    "#       break\n",
    "#     code inside loop\n",
    "\n",
    "# code outside loop\n",
    "\n",
    "# while test expression:\n",
    "#     code inside loop\n",
    "#     if condition:\n",
    "#       break\n",
    "#     code inside loop\n",
    "\n",
    "# code outside loop\n",
    "\n",
    "\n",
    "numbers = [1,2,2,3,4,5]\n",
    "\n",
    "for num in numbers:\n",
    "    if num == 3:\n",
    "        break\n",
    "    print(num)\n",
    "else:\n",
    "    print('Else-block')\n",
    "print('Outside loop')\n",
    "\n",
    "\n",
    "\n",
    "number = int(input('Enter a number '))\n",
    "\n",
    "isDivisible = False\n",
    "\n",
    "i = 2\n",
    "\n",
    "while i < number:\n",
    "    if(number % i ==0):\n",
    "        isDivisible = True\n",
    "        print('{} is divisible by {}'.format(number, i))\n",
    "        break\n",
    "    i += 1\n",
    "    \n",
    "if isDivisible:\n",
    "    print('{} is not a Prime Numnber'.format(number))\n",
    "else:\n",
    "    print('{} is a Prime Number'.format(number))\n",
    "    \n",
    "\n",
    "print('\\ncontinue:')\n",
    "#syntax : \n",
    "# for var in sequence:\n",
    "#     code inside loop\n",
    "#     if condition:\n",
    "#       continue\n",
    "#     code inside loop\n",
    "\n",
    "# code outside loop\n",
    "\n",
    "\n",
    "numbers = [1,2,3,5]\n",
    "\n",
    "for num in numbers:\n",
    "    if num % 2 == 0:\n",
    "        print('{} is a even number '.format(num))\n",
    "        continue\n",
    "    print('{} is an odd number '.format(num))\n",
    "else:\n",
    "    print('Else-block')\n",
    "print('Outside loop')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Day 10"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "14. Data Strcture: Lists\n",
      "\n",
      "List Creation:\n",
      "list of strings ['one', 'two', 'three']\n",
      "list of integers [1, 2, 3, 4, 5]\n",
      "list of lists [[1, 2], [3, 4]]\n",
      "list of different datatypes [1, 'ravi', 24, 1.24]\n",
      "\n",
      "List Length\n",
      "Length of list is:  4\n",
      "\n",
      "List Append\n",
      "['one', 'two', 'three']\n",
      "['one', 'two', 'three', 'four']\n",
      "\n",
      "List Insert\n",
      "['one', 'two', 'four']\n",
      "['one', 'two', 'three', 'four']\n",
      "\n",
      "List Remove\n",
      "['one', 'two', 'four', 'two']\n",
      "['one', 'four', 'two']\n",
      "\n",
      "List Append & Extend\n",
      "['one', 'two', 'three', ['four', 'five']]\n"
     ]
    }
   ],
   "source": [
    "print(\"\\n14. Data Strcture: Lists\")\n",
    "\n",
    "print('\\nList Creation:')\n",
    "#List creation\n",
    "emptyList = []\n",
    "\n",
    "list1 = ['one', 'two', 'three'] #list of strings\n",
    "list2 = [1,2,3,4,5] #list of integers\n",
    "list3 = [[1,2], [3,4]] #list of lists\n",
    "list4 = [1, 'ravi', 24, 1.24] #list of different datatypes\n",
    "print('list of strings',list1)\n",
    "print('list of integers',list2)\n",
    "print('list of lists',list3)\n",
    "print('list of different datatypes',list4)\n",
    "\n",
    "print('\\nList Length')\n",
    "list1 = ['one', 'two','three','four']\n",
    "#find length of a list\n",
    "print('Length of list is: ',len(list1))\n",
    "\n",
    "print('\\nList Append')\n",
    "list2 = ['one', 'two','three']\n",
    "print(list2)\n",
    "list2.append('four') #append will add the item at the end\n",
    "print(list2)\n",
    "\n",
    "print('\\nList Insert')\n",
    "list2 = ['one', 'two','four']\n",
    "print(list2)\n",
    "list2.insert(2,'three')\n",
    "print(list2)\n",
    "\n",
    "print('\\nList Remove')\n",
    "list2 = ['one', 'two','four', 'two']\n",
    "print(list2)\n",
    "list2.remove('two') # it will remove first occurance of two from the list\n",
    "print(list2)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Day 11"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "14. Data Strcture: Lists\n",
      "\n",
      "List Append\n",
      "['one', 'two', 'three', ['four', 'five']]\n",
      "\n",
      "List Extend\n",
      "['one', 'two', 'three', 'four', 'five']\n",
      "\n",
      "List Delete\n",
      "['one', 'three']\n",
      "Poped element is:  two\n",
      "['one', 'three']\n"
     ]
    }
   ],
   "source": [
    "print(\"\\n14. Data Strcture: Lists\")\n",
    "\n",
    "print('\\nList Append')\n",
    "list3 = ['one', 'two','three']\n",
    "list4 = ['four', 'five']\n",
    "list3.append(list4)\n",
    "\n",
    "print(list3)\n",
    "\n",
    "print('\\nList Extend')\n",
    "list3 = ['one', 'two','three']\n",
    "list4 = ['four', 'five']\n",
    "list3.extend(list4)\n",
    "\n",
    "print(list3)\n",
    "\n",
    "\n",
    "print('\\nList Delete')\n",
    "\n",
    "list5 =['one', 'two','three']\n",
    "del list5[1]\n",
    "print(list5)\n",
    "\n",
    "#or we can pop\n",
    "\n",
    "list5 =['one', 'two','three']\n",
    "a = list5.pop(1)\n",
    "print('Poped element is: ',a)\n",
    "print(list5)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "#List Related KeyWords in Python\n",
    "# keyword 'in' is used to test if an item is in a list\n",
    "list6 = ['one', 'two','three']\n",
    "if 'two' not in list6:\n",
    "    print('Presenet')\n",
    "\n",
    "if 'six' in list6:\n",
    "    print('Not Present')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Day 12"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "14. Data Strcture: Lists\n",
      "\n",
      "List Reverse\n",
      "Reversed List :  ['three', 'two', 'one']\n",
      "\n",
      "List Sorting\n",
      "Sorted List: [1, 3, 5, 6, 8]\n",
      "Original List:  [1, 6, 8, 3, 5]\n",
      "List having multiple refrences\n",
      "Original List:  [1, 2, 3, 4, 5, 6, 7]\n",
      "\n",
      "String Split to create a list\n",
      "['one', 'two', 'three', 'four']\n",
      "\n",
      "List Slicing\n",
      "[1, 2, 3, 4, 5, 6, 7, 8, 9]\n",
      "[1, 2, 3, 4, 5]\n"
     ]
    }
   ],
   "source": [
    "print('\\n14. Data Strcture: Lists')\n",
    "\n",
    "print('\\nList Reverse')\n",
    "list = ['one','two','three']\n",
    "\n",
    "list.reverse()\n",
    "print('Reversed List : ', list)\n",
    "\n",
    "\n",
    "print('\\nList Sorting')\n",
    "numberList = [1,6,8,3,5]\n",
    "sortedList = sorted(numberList)\n",
    "print('Sorted List:', sortedList)\n",
    "print('Original List: ', numberList)\n",
    "\n",
    "print('List having multiple refrences')\n",
    "list1 = [1, 2, 3, 4, 5, 6]\n",
    "abc = list1\n",
    "abc.append(7)\n",
    "print('Original List: ', list1)\n",
    "\n",
    "\n",
    "print('\\nString Split to create a list')\n",
    "a = 'one,two,three,four'\n",
    "sList = a.split(',')\n",
    "print(sList)\n",
    "\n",
    "print('\\nList Slicing')\n",
    "list1 = [1, 2, 3, 4, 5, 6, 7, 8, 9]\n",
    "\n",
    "#prints all elements of the list\n",
    "print(list1[:])\n",
    "\n",
    "#prints sliced elements of the list\n",
    "print(list1[0:5])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Day 13"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "14. Data Strcture: Lists\n",
      "\n",
      "List extend using '+'\n",
      "[1, 2, 3, 4, 5, 'Ravi', 'Shankar', 'Singh']\n",
      "\n",
      "List Count\n",
      "4\n",
      "\n",
      "List Looping\n",
      "one\n",
      "two\n",
      "three\n",
      "\n",
      "List Comprehensions\n",
      "[0, 1, 4, 9, 16, 25, 36, 49, 64, 81]\n",
      "[0, 1, 4, 9, 16, 25, 36, 49, 64, 81]\n",
      "[2, 4, 7]\n",
      "\n",
      "Nested List Comprehensions\n",
      "without list comprehension\n",
      "[[1, 5, 9], [2, 6, 10], [3, 7, 11], [4, 8, 12]]\n",
      "with list comprehension\n",
      "[[1, 5, 9], [2, 6, 10], [3, 7, 11], [4, 8, 12]]\n"
     ]
    }
   ],
   "source": [
    "print('\\n14. Data Strcture: Lists')\n",
    "\n",
    "print('\\nList extend using \\'+\\'')\n",
    "\n",
    "list1 = [1,2,3,4,5]\n",
    "list2 = ['Ravi','Shankar','Singh']\n",
    "\n",
    "newList= list1 + list2\n",
    "print(newList)\n",
    "\n",
    "print('\\nList Count')\n",
    "list3 = [1,3,1,5,2,1,5,1]\n",
    "#frequency of 1 in list\n",
    "print(list3.count(1))\n",
    "\n",
    "print('\\nList Looping')\n",
    "\n",
    "list4 = ['one', 'two', 'three']\n",
    "for element in list4:\n",
    "    print(element)\n",
    "    \n",
    "print('\\nList Comprehensions')\n",
    "\n",
    "#without list comprehension\n",
    "squares = []\n",
    "\n",
    "for i in range(10):\n",
    "    squares.append(i**2)\n",
    "print(squares)\n",
    "\n",
    "#with comprehension\n",
    "squares = [i**2 for i in range(10)]\n",
    "print(squares)\n",
    "\n",
    "\n",
    "#filter the list to exclude negative numbers\n",
    "list1 = [-1,2,4,7,-5,-3,-6]\n",
    "\n",
    "newList = [i for i in list1 if i> 0]\n",
    "print(newList)\n",
    "\n",
    "print('\\nNested List Comprehensions')\n",
    "\n",
    "#lets suppose we have a matrix\n",
    "\n",
    "matrix = [\n",
    "    [1, 2, 3, 4],\n",
    "    [5, 6, 7, 8],\n",
    "    [9, 10, 11, 12]\n",
    "]\n",
    "\n",
    "#transpose of a matrix without list comprehension\n",
    "transpose = []\n",
    "print('without list comprehension')\n",
    "for i in range(4):\n",
    "    listTemp = []\n",
    "    for row in matrix:\n",
    "        listTemp.append(row[i])\n",
    "    transpose.append(listTemp)\n",
    "print(transpose)\n",
    "\n",
    "#matrix transpose with list comprehension\n",
    "print('with list comprehension')\n",
    "transposeList = [[row[i] for row in matrix] for i in range(4)]\n",
    "print(transposeList)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Day 14"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "15. Data Strcture: Tuples\n",
      "\n",
      "Tuple creation\n",
      "(1, 2, 3)\n",
      "(1, 'ravi', 4.4, 'abc')\n",
      "<class 'tuple'>\n",
      "('ravi',)\n",
      "\n",
      "Accessing Elements in Tuple\n",
      "shankar\n",
      "singh\n",
      "('shankar', 'singh')\n",
      "singh\n",
      "(2, 3, 4)\n",
      "(1, 2, 3, 4)\n",
      "(1, 2, 3, 4, 5, 6)\n",
      "\n",
      "Changing a tuple\n",
      "(1, 2, 3, 4, [5, 6, 7, 8])\n",
      "(1, 2, 3, 4, [5, 'ravi', 7, 8])\n",
      "(1, 2, 3, 4, 5, 4, 5, 6, 7, 8)\n",
      "('satish', 'satish', 'satish', 'satish')\n",
      "\n",
      "Tuple Deletion\n",
      "\n",
      "Tuple Count\n",
      "\n",
      "Tuple Index\n",
      "2\n",
      "\n",
      "Tuple Membership\n",
      "True\n",
      "False\n",
      "\n",
      "Tuple Length\n",
      "8\n",
      "\n",
      "Tuple Sort\n",
      "[1, 1, 1, 2, 2, 3, 3, 4]\n"
     ]
    }
   ],
   "source": [
    "print('\\n15. Data Strcture: Tuples')\n",
    "\n",
    "print('\\nTuple creation')\n",
    "\n",
    "#empty tuple\n",
    "t = ()\n",
    "#tuple having integers\n",
    "t = (1,2,3)\n",
    "print(t)\n",
    "#tuple with mixed datatypes\n",
    "t = (1, 'ravi', 4.4, 'abc')\n",
    "print(t)\n",
    "\n",
    "# only parenthesis is not enough otherwise it will show the datatype of its element\n",
    "t = ('ravi')\n",
    "type(t) # this will show type(t) as string\n",
    "#need a comma at the end\n",
    "t = ('ravi',)\n",
    "type(t) #now the output will be tuple\n",
    "\n",
    "#parenthesis is optional\n",
    "t = 'ravi',\n",
    "print(type(t))\n",
    "print(t)\n",
    "\n",
    "print('\\nAccessing Elements in Tuple')\n",
    "t = ('ravi', 'shankar', 'singh')\n",
    "print(t[1])\n",
    "\n",
    "#negative index\n",
    "print(t[-1])#prints last element in tuple\n",
    "\n",
    "#nested tuple\n",
    "t = ('ravi',('shankar', 'singh'))\n",
    "print(t[1])\n",
    "print(t[1][1])\n",
    "\n",
    "#slicing\n",
    "t = (1,2,3,4,5,6)\n",
    "\n",
    "print(t[1:4])\n",
    "#print elements from startig to 2nd last elements\n",
    "print(t[:-2])\n",
    "#print elements from starting to end\n",
    "print(t[:])\n",
    "\n",
    "print('\\nChanging a tuple')\n",
    "t = (1,2,3,4,[5,6,7,8])\n",
    "print(t)\n",
    "# t[2] = 'x' # this will produce TypeError i.e 'tuple' object does not support item assignment\n",
    "t[4][1] = 'ravi'\n",
    "print(t)\n",
    "\n",
    "#concatinating tuples\n",
    "t = (1,2,3,4,5) + (4,5,6,7,8)\n",
    "print(t)\n",
    "\n",
    "#repeat the elements in a tuple for a given number of times using the * operator\n",
    "t = (('satish',) * 4)\n",
    "print(t)\n",
    "\n",
    "print('\\nTuple Deletion')\n",
    "#we can not change the element in a tuple.\n",
    "# And we can not delete or remove items from a tuple\n",
    "\n",
    "#delete entire tuple using del keyword\n",
    "t = (1,2,3,4,5)\n",
    "del t\n",
    "\n",
    "print('\\nTuple Count')\n",
    "t = (1, 2, 3, 4, 1, 3, 2, 1)\n",
    "#get the frequency of a particular element in tuple\n",
    "t.count(1)\n",
    "\n",
    "print('\\nTuple Index')\n",
    "t = (1, 2, 3, 4, 1, 3, 2, 1)\n",
    "print(t.index(3)) #returns the index of the first element which is 3\n",
    "\n",
    "print('\\nTuple Membership')\n",
    "print(1 in t) # if presents print true\n",
    "print(8 in t)\n",
    "\n",
    "print('\\nTuple Length')\n",
    "print(len(t))\n",
    "\n",
    "print('\\nTuple Sort')\n",
    "newTuple = sorted(t)\n",
    "print(newTuple)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Day 15"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "15. Data Strcture: Tuples\n",
      "\n",
      "Tuple max\n",
      "9\n",
      "\n",
      "Tuple min\n",
      "1\n",
      "\n",
      "Tuple sum\n",
      "23\n"
     ]
    }
   ],
   "source": [
    "print('\\n15. Data Strcture: Tuples')\n",
    "\n",
    "t = (2, 5, 1, 6, 9)\n",
    "print('\\nTuple max')\n",
    "#get the largest element in a tuple\n",
    "print(max(t))\n",
    "\n",
    "#get the smallest element in a tuple\n",
    "print('\\nTuple min')\n",
    "print(min(t))\n",
    "\n",
    "#get the sum of element in a tuple\n",
    "print('\\nTuple sum')\n",
    "print(sum(t))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Day 16"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "16. Data Strcture: Sets\n",
      "\n",
      "Sets Creation\n",
      "{1, 2, 3, 4}\n",
      "{1, 2, 3, 5}\n",
      "{1, 2, 3, 4}\n",
      "<class 'set'>\n",
      "\n",
      "Add element to a Set\n",
      "{1, 2, 3}\n",
      "{1, 2, 3, 5, 8, 9}\n",
      "{0, 1, 2, 3, 4, 5, 8, 9, 10, 12}\n",
      "\n",
      "Remove elements of a Set\n",
      "{1, 2, 5, 7, 9}\n",
      "{1, 5, 7, 9}\n",
      "{5, 7, 9}\n",
      "set()\n"
     ]
    }
   ],
   "source": [
    "print('\\n16. Data Strcture: Sets')\n",
    "\n",
    "print('\\nSets Creation')\n",
    "\n",
    "#sets of integers\n",
    "s = {1,2,3,4}\n",
    "print(s)\n",
    "\n",
    "#set does not allow duplicate elements. Stores only one instance\n",
    "s = {1,2,3,5,3}\n",
    "print(s)\n",
    "\n",
    "#we can make set from list\n",
    "s = set([1,2,3,4])\n",
    "print(s)\n",
    "\n",
    "#initialize set with set() method\n",
    "s = set()\n",
    "print(type(s))\n",
    "\n",
    "print('\\nAdd element to a Set')\n",
    "s = {1,3}\n",
    "#sets object does not supports indexing\n",
    "# print(s[1]) This will get TyoeError\n",
    "\n",
    "#add element\n",
    "s.add(2)\n",
    "print(s)\n",
    "\n",
    "#add multiple element\n",
    "s.update([2,5,8,9])\n",
    "print(s)\n",
    "\n",
    "#add  list and set\n",
    "s.update([0,4,], {10,3,12})\n",
    "print(s)\n",
    "\n",
    "\n",
    "print('\\nRemove elements of a Set')\n",
    "s = {1,2,5,7,9,3}\n",
    "# using discard\n",
    "s.discard(3)\n",
    "print(s)\n",
    "\n",
    "#using remove\n",
    "s.remove(2) #removing any element not in set will get keyError\n",
    "print(s)\n",
    "\n",
    "#we can remove item using pop()\n",
    "s.pop()\n",
    "print(s)\n",
    "\n",
    "#clear a list using clear()\n",
    "s.clear()\n",
    "print(s)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Day 17"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "16. Data Strcture: Sets\n",
      "\n",
      "Sets Operations\n",
      "{1, 2, 3, 4, 5, 6}\n",
      "{1, 2, 3, 4, 5, 6}\n",
      "{3, 4}\n",
      "{3, 4}\n",
      "{1, 2}\n",
      "{1, 2}\n",
      "{1, 2, 5, 6}\n",
      "{1, 2, 5, 6}\n",
      "set 'set1' is subset of 'set2' ? False\n",
      "set 'set2' is subset of 'set1' ? True\n",
      "\n",
      "Frozen Sets\n",
      "frozenset({1, 2, 3, 4, 5, 6})\n",
      "frozenset({3, 4})\n",
      "frozenset({1, 2, 5, 6})\n"
     ]
    }
   ],
   "source": [
    "print('\\n16. Data Strcture: Sets')\n",
    "\n",
    "print('\\nSets Operations')\n",
    "#union of two sets using  | operator\n",
    "set1 = {1,2,3,4}\n",
    "set2 = {3,4,5,6}\n",
    "print(set1 | set2)\n",
    "\n",
    "#another way of union is using\n",
    "print(set1.union(set2))\n",
    "\n",
    "#intersection of two sets using & operators\n",
    "print(set1 & set2)\n",
    "\n",
    "#use intersection function\n",
    "print(set1.intersection(set2))\n",
    "\n",
    "#set difference: set of elements that are only in set1 but not in set2\n",
    "print(set1 - set2)\n",
    "\n",
    "#use difference function\n",
    "print(set1.difference(set2))\n",
    "\n",
    "#use ^ operator\n",
    "#symmetric difference: set of elements in both set1 and set2\n",
    "#except those that are common in both\n",
    "print(set1^set2)\n",
    "\n",
    "#use symmetric difference function\n",
    "print(set1.symmetric_difference(set2))\n",
    "\n",
    "#find issinset()\n",
    "set1 = {'a', 'b', 'c', 'd', 'e'}\n",
    "set2 = {'c', 'd'}\n",
    "\n",
    "print('set \\'set1\\' is subset of \\'set2\\' ?', set1.issubset(set2)) #check set1 is subset of set2\n",
    "print('set \\'set2\\' is subset of \\'set1\\' ?', set2.issubset(set1))\n",
    "\n",
    "print('\\nFrozen Sets')\n",
    "set1 = frozenset([1,2,3,4])\n",
    "set2 = frozenset([3,4,5,6])\n",
    "\n",
    "#try to add element into set1 gives an error\n",
    "# set1.add(5) This will throw an error 'frozenset' object has no attribute 'add'\n",
    "#frozen set doen't support indexing\n",
    "\n",
    "#union of 2 frozensets\n",
    "print(set1 | set2)\n",
    "#intersection of 2 frozensets\n",
    "print(set1 & set2)\n",
    "#symmetric difference of 2 frozensets\n",
    "print(set1 ^ set2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Day 18"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "16. Data Strcture: Dictionary\n",
      "\n",
      "Dictionary Creation\n",
      "{1: 'abc', 2: 'def'}\n",
      "{'name': 'ravi', 1: ['abc', 'def']}\n",
      "{1: 'abc', 2: 'def'}\n",
      "\n",
      "Dictionary Access\n",
      "Ravi\n",
      "Ravi\n",
      "None\n"
     ]
    }
   ],
   "source": [
    "print('\\n17. Data Strcture: Dictionary')\n",
    "\n",
    "print('\\nDictionary Creation')\n",
    "#empty dictionary\n",
    "dict1 = {} \n",
    "\n",
    "#dictionary with interger keys\n",
    "dict1 = {1: 'abc', 2: 'def'}\n",
    "print(dict1)\n",
    "\n",
    "#dictionary with mixed keys\n",
    "dict1 = {'name': 'ravi', 1: ['abc', 'def']}\n",
    "print(dict1)\n",
    "\n",
    "#creating empty dictionary using dict()\n",
    "dict1 = dict()\n",
    "\n",
    "#create dictionary with of tuple\n",
    "dict1 = dict([(1, 'abc'), (2, 'def')])\n",
    "print(dict1)\n",
    "\n",
    "print('\\nDictionary Access')\n",
    "dict1 = {'name': 'Ravi', 'profile': 'Software Developer'}\n",
    "print(dict1['name'])\n",
    "# print(dict1['age']) #if key is not present it will give KeyError\n",
    "\n",
    "#access data using get()\n",
    "print(dict1.get('name'))\n",
    "#if key is not present it will give None using get() method\n",
    "print(dict1.get('age'))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Day 19"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "16. Data Strcture: Dictionary\n",
      "\n",
      "Dictionary Add or Modify\n",
      "{'name': 'Shankar', 'profile': 'Software Developer'}\n",
      "{'name': 'Shankar', 'profile': 'Software Developer', 'degree': 'B.Tech'}\n",
      "\n",
      "Dictionary Delete or Remove Element\n",
      "B.Tech\n",
      "{'profile': 'Software Developer'}\n",
      "{}\n"
     ]
    }
   ],
   "source": [
    "print('\\n17. Data Strcture: Dictionary')\n",
    "\n",
    "print('\\nDictionary Add or Modify')\n",
    "dict1 = {'name': 'Ravi', 'profile': 'Software Developer'}\n",
    "#update name\n",
    "dict1['name'] = 'Shankar'\n",
    "print(dict1)\n",
    "\n",
    "#add new key\n",
    "dict1['degree'] = 'B.Tech'\n",
    "print(dict1)\n",
    "\n",
    "print('\\nDictionary Delete or Remove Element')\n",
    "#remove a particular item\n",
    "print(dict1.pop('degree'))\n",
    "\n",
    "#remove particular key\n",
    "del dict1['name']\n",
    "print(dict1)\n",
    "\n",
    "#remove all items\n",
    "dict1.clear()\n",
    "print(dict1)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Day 20"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "16. Data Strcture: Dictionary\n",
      "\n",
      "Dictionary Methods\n",
      "{'name': 'Ravi', 'profile': 'Software Developer'}\n",
      "{'B.Tech': 0, 'BCA': 0, 'MCA': 0}\n",
      "dict_items([('B.Tech', 0), ('BCA', 0), ('MCA', 0)])\n",
      "dict_keys(['B.Tech', 'BCA', 'MCA'])\n",
      "dict_values([0, 0, 0])\n",
      "['__class__', '__contains__', '__delattr__', '__delitem__', '__dir__', '__doc__', '__eq__', '__format__', '__ge__', '__getattribute__', '__getitem__', '__gt__', '__hash__', '__init__', '__init_subclass__', '__iter__', '__le__', '__len__', '__lt__', '__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__setattr__', '__setitem__', '__sizeof__', '__str__', '__subclasshook__', 'clear', 'copy', 'fromkeys', 'get', 'items', 'keys', 'pop', 'popitem', 'setdefault', 'update', 'values']\n"
     ]
    }
   ],
   "source": [
    "print('\\n17. Data Strcture: Dictionary')\n",
    "\n",
    "print('\\nDictionary Methods')\n",
    "dict1 = {'name': 'Ravi', 'profile': 'Software Developer'}\n",
    "#copy method\n",
    "dict2 = dict1.copy()\n",
    "print(dict2)\n",
    "\n",
    "#fromkeys[seq[ , v]] -> Return a new dictionary with keys from seq and assigned values \n",
    "courses = {}.fromkeys(['B.Tech', 'BCA', 'MCA'], 0)\n",
    "print(courses)\n",
    "\n",
    "print(courses.items())# returns a new view of dictonary items(key, value)\n",
    "\n",
    "print(courses.keys())# returns a new view of dictonary keys\n",
    "\n",
    "print(courses.values())# returns a new view of dictonary values\n",
    "\n",
    "#get list of all the methods and attributes available for dictionary\n",
    "d = {}\n",
    "print(dir(d))\n",
    "\n",
    "print('\\nDictionary Comprehension')\n",
    "#creatig a new dictionary with only pairs where value is larger than 5\n",
    "d = {'a': 1, 'b': 5, 'c': 8, 'd': 11}\n",
    "newDict = {k:v for k,v in d.items() if v >5}\n",
    "print(newDict)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Day 21"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "18. Strings\n",
      "H\n",
      "o\n",
      "llo\n",
      "Hello\n",
      "HelloRavi\n",
      "HelloHelloHello\n",
      "\n",
      "Iterating through String\n",
      "2 letters found\n"
     ]
    }
   ],
   "source": [
    "print('\\n18. Strings')\n",
    "\n",
    "#access characters in a string\n",
    "myString = 'Hello'\n",
    "\n",
    "#print first character\n",
    "print(myString[0])\n",
    "\n",
    "#print last character using negative indexing\n",
    "print(myString[-1])\n",
    "\n",
    "#slicing 2nd to 5th character\n",
    "print(myString[2:5])\n",
    "\n",
    "#change or delete a string\n",
    "myString2 = 'Hello'\n",
    "# myString[4] = 's' This will produce TypeError because string is immutable\n",
    "\n",
    "#delete complete string\n",
    "# del myString2\n",
    "print(myString2)\n",
    "\n",
    "#concatenation\n",
    "s1 = 'Hello'\n",
    "s2 = 'Ravi'\n",
    "\n",
    "#concatenation of 2 string \n",
    "print(s1 + s2)\n",
    "\n",
    "#repeat string n times\n",
    "print(s1 * 3)\n",
    "\n",
    "print('\\nIterating through String')\n",
    "count = 0\n",
    "for l in 'Hello Ravi':\n",
    "    if l == 'l':\n",
    "        count +=1\n",
    "print(count, 'letters found')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Day 22"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "18. Strings\n",
      "\n",
      "String methods\n",
      "Hello World\n",
      "Hello Python\n"
     ]
    }
   ],
   "source": [
    "print('\\n18. Strings')\n",
    "\n",
    "print('\\nString methods')\n",
    "\n",
    "#lower()\n",
    "'Hello'.lower()\n",
    "#upper()\n",
    "'Hello'.upper()\n",
    "#split()\n",
    "'This is a dummy string'.split()\n",
    "#join()\n",
    "' '.join(['This', 'is', 'a', 'dummy', 'string'])\n",
    "#find()\n",
    "'Hello World'.find('Wo')\n",
    "#replace\n",
    "'Hello World'.replace('World', 'Python')\n",
    "s1 = 'Hello World'\n",
    "\n",
    "s2 = s1.replace('World', 'Python')\n",
    "print(s1)\n",
    "print(s2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Day 23"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "19. Python Functions\n",
      "Hello Ravi\n",
      "\n",
      "    This function prints the name\n",
      "    \n",
      "Welcome to Python Ravi\n",
      "This a local variable\n",
      "This is global variable\n",
      "This is global variable\n"
     ]
    },
    {
     "ename": "NameError",
     "evalue": "name 'localVariable' is not defined",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mNameError\u001b[0m                                 Traceback (most recent call last)",
      "\u001b[0;32m<ipython-input-6-939e5155716a>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m\u001b[0m\n\u001b[1;32m     49\u001b[0m \u001b[0mprint\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mglobalVariable\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     50\u001b[0m \u001b[0;31m#print local variable localVariable\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 51\u001b[0;31m \u001b[0mprint\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mlocalVariable\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[0;31mNameError\u001b[0m: name 'localVariable' is not defined"
     ]
    }
   ],
   "source": [
    "print('\\n19. Python Functions')\n",
    "\n",
    "#Syntax:\n",
    "# def function_name(parameters):\n",
    "#    \"\"\"\n",
    "#   Doc String here \n",
    "#    \"\"\"\n",
    "#   statements(s)\n",
    "\n",
    "def printName(name):\n",
    "    \"\"\"\n",
    "    This function prints the name\n",
    "    \"\"\"\n",
    "    print('Hello ' + str(name))\n",
    "    \n",
    "    \n",
    "printName('Ravi')\n",
    "\n",
    "#Doc String\n",
    "print(printName.__doc__)\n",
    "\n",
    "#return Statement\n",
    "\n",
    "#Syntax\n",
    "# return [expression]\n",
    "\n",
    "def getWelcomeMessage(name):\n",
    "    msg = 'Welcome to Python ' + name\n",
    "    return msg\n",
    "\n",
    "print(getWelcomeMessage('Ravi'))\n",
    "\n",
    "#Scope and lifetime of variable\n",
    "\n",
    "globalVariable = 'This is global variable'\n",
    "\n",
    "def testVariableLifeTime():\n",
    "    \"\"\"\n",
    "    This function test the lifetime of a variable\n",
    "    \"\"\"\n",
    "    localVariable = 'This a local variable'\n",
    "    print(localVariable)\n",
    "    \n",
    "    print(globalVariable)\n",
    "    \n",
    "#calling function\n",
    "testVariableLifeTime()\n",
    "#print global variable globalVariable\n",
    "print(globalVariable)\n",
    "#print local variable localVariable\n",
    "print(localVariable)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Day 24"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "19. Python Functions\n",
      "\n",
      "Types of Function\n",
      "\n",
      "Build-in Functions\n",
      "100\n",
      "True\n",
      "False\n",
      "False\n",
      "(4, 1)\n",
      "index 0 has value 10\n",
      "index 1 has value 20\n",
      "index 2 has value 30\n",
      "index 3 has value 40\n"
     ]
    }
   ],
   "source": [
    "print('\\n19. Python Functions')\n",
    "\n",
    "print('\\nTypes of Function')\n",
    "\n",
    "print('\\nBuild-in Functions')\n",
    "\n",
    "#abs\n",
    "#find the absolute value\n",
    "num = -100\n",
    "print(abs(num))\n",
    "\n",
    "#all\n",
    "list1 = [1,2,3,4]\n",
    "print(all(list1)) #True if all elements in iterable are true\n",
    "list1 = [0,1,2,3,4]\n",
    "print(all(list1)) #False if any elements in iterable is False\n",
    "\n",
    "list1 = [False, 1, 2, 4]\n",
    "print(all(list1)) #False present\n",
    "\n",
    "#divmod\n",
    "print(divmod(9,2)) #print quotient and remainder as a tuple\n",
    "\n",
    "#enumerate\n",
    "numbers = [10, 20,30,40]\n",
    "\n",
    "for index, num in enumerate(numbers):\n",
    "    print('index {0} has value {1}'.format(index, num))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Day 25"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "19. Python Functions\n",
      "\n",
      "Build-in Functions\n",
      "[-20, -19, -18, -17, -16, -15, -14, -13, -12, -11, -10, -9, -8, -7, -6, -5, -4, -3, -2, -1, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19]\n",
      "[1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19]\n",
      "True\n",
      "False\n",
      "[1, 4, 9, 16]\n",
      "[1, 4, 9, 16]\n",
      "24\n",
      "24\n"
     ]
    }
   ],
   "source": [
    "print('\\n19. Python Functions')\n",
    "\n",
    "print('\\nBuild-in Functions')\n",
    "\n",
    "#filter\n",
    "def find_positive_number(num):\n",
    "    \"\"\"\n",
    "    This function will find positive number\n",
    "    \"\"\"\n",
    "    if(num>0):\n",
    "        return num;\n",
    "    \n",
    "numberList = range(-20, 20) #create a list of numbers from -20 to 20\n",
    "print(list(numberList))\n",
    "\n",
    "positiveNumberList = list(filter(find_positive_number, numberList))\n",
    "print(positiveNumberList)\n",
    "\n",
    "#isinstance\n",
    "list1 = [1,1,3,4,3]\n",
    "print(isinstance(list1, list))\n",
    "print(isinstance(list1, tuple))\n",
    "\n",
    "#map\n",
    "num = [1,2,3,4]\n",
    "\n",
    "##normal way of computing num^2 for each elements in list\n",
    "squared = []\n",
    "for n in num:\n",
    "    squared.append(n ** 2)\n",
    "    \n",
    "print(squared)\n",
    "\n",
    "##using map()\n",
    "num = [1,2,3,4]\n",
    "\n",
    "def powerOfTwo(n):\n",
    "    return n ** 2;\n",
    "\n",
    "squared = list(map(powerOfTwo, num))\n",
    "print(squared)\n",
    "\n",
    "#reduce\n",
    "##product of elements in a list\n",
    "product = 1\n",
    "list1 = [1,2,3,4]\n",
    "\n",
    "##without using reduce()\n",
    "for num in list1:\n",
    "    product *= num\n",
    "print(product)\n",
    "\n",
    "##with reduce\n",
    "from functools import reduce #In Python3\n",
    "\n",
    "def multiply(x,y):\n",
    "    return x*y;\n",
    "product = reduce(multiply, list1)\n",
    "print(product)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Day 26"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "19. Python Functions\n",
      "\n",
      "User-defined Functions\n",
      "Product of 4 and 5 is 20\n",
      "Select Options\n",
      "1. Addition\n",
      "1. Subtract\n",
      "1. Multiply\n",
      "Enter your choice : 1/2/3/41\n",
      "Enter first number12\n",
      "Enter second number11\n",
      "Sum of 12.0 and 11.0 is 23.0 \n"
     ]
    }
   ],
   "source": [
    "print('\\n19. Python Functions')\n",
    "\n",
    "print('\\nUser-defined Functions')\n",
    "\n",
    "def productOfTwoNumbers(a, b):\n",
    "    \"\"\"\n",
    "    This function will return product of two numbers\n",
    "    \"\"\"\n",
    "    product = a * b\n",
    "    return product;\n",
    "num1 = 4\n",
    "num2 = 5\n",
    "print('Product of {0} and {1} is {2}'.format(num1, num2, productOfTwoNumbers(num1 , num2)))\n",
    "\n",
    "\n",
    "\n",
    "#calculator\n",
    "\n",
    "#add function\n",
    "def add(a, b):\n",
    "    \"\"\"\n",
    "    This function adds two numbers\n",
    "    \"\"\"\n",
    "    return a + b;\n",
    "#subtract function\n",
    "def subtract(a, b):\n",
    "    \"\"\"\n",
    "    This function subtract two numbers\n",
    "    \"\"\"\n",
    "    return a - b;\n",
    "#multiply function\n",
    "def multiply(a, b):\n",
    "    \"\"\"\n",
    "    This function multiply two numbers\n",
    "    \"\"\"\n",
    "    return a * b;\n",
    "\n",
    "print('Select Options')\n",
    "print('1. Addition')\n",
    "print('1. Subtract')\n",
    "print('1. Multiply')\n",
    "#take input from user\n",
    "choice = int(input('Enter your choice : 1/2/3/4'))\n",
    "num1 = float(input('Enter first number'))\n",
    "num2 = float(input('Enter second number'))\n",
    "\n",
    "if(choice ==1):\n",
    "        print('Sum of {0} and {1} is {2} '.format(num1, num2, add(num1, num2)))\n",
    "elif(choice == 2):\n",
    "        print('Difference of {0} and {1} is {2} '.format(num1, num2, subtract(num1, num2)))\n",
    "elif(choice == 3):\n",
    "        print('Product of {0} and {1} is {2} '.format(num1, num2, multiply(num1, num2)))\n",
    "else:\n",
    "    print('Invalid Choice')     "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Day 27"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "19. Python Functions\n",
      "\n",
      "Function Arguments\n",
      "Hello Ravi, welcome to world of Python programming.\n",
      "\n",
      "Default Argument\n",
      "Hello Ravi, Welcome Home.\n",
      "Hello Ravi, welcome to world of Python programming.\n",
      "\n",
      "Keyword Argument\n",
      "Hello Ravi, Welcome Back!\n",
      "\n",
      "Arbitary Arguments\n",
      "('Ravi', 'Shankar', 'Singh')\n",
      "Hello Ravi\n",
      "Hello Shankar\n",
      "Hello Singh\n"
     ]
    }
   ],
   "source": [
    "print('\\n19. Python Functions')\n",
    "\n",
    "print('\\nFunction Arguments')\n",
    "\n",
    "def greetuser(name, message):\n",
    "    \"\"\"\n",
    "    This function greets user with a message\n",
    "    \"\"\"\n",
    "    print('Hello {0}, {1}'.format(name, message));\n",
    "#call function with argumnets\n",
    "greetuser('Ravi', 'welcome to world of Python programming.')\n",
    "\n",
    "#Different forms of Arguments\n",
    "print('\\nDefault Argument')\n",
    "\n",
    "def greetuser(name, message = 'welcome to world of Python programming.'):\n",
    "    \"\"\"\n",
    "    This function greets user with a message\n",
    "    \"\"\"\n",
    "    print('Hello {0}, {1}'.format(name, message));\n",
    "\n",
    "#call function with argumnets\n",
    "greetuser('Ravi', 'Welcome Home.')\n",
    "greetuser('Ravi')\n",
    "\n",
    "\n",
    "print('\\nKeyword Argument')\n",
    "def greetUser(**kwargs):\n",
    "    \"\"\"\n",
    "    This function greets user with a message\n",
    "    \"\"\"\n",
    "    if kwargs:\n",
    "        print('Hello {0}, {1}'.format(kwargs['name'], kwargs['message']))\n",
    "greetUser(name = \"Ravi\", message = \"Welcome Back!\")\n",
    "\n",
    "print('\\nArbitary Arguments')\n",
    "\n",
    "def greetUser(*names):\n",
    "    \"\"\"\n",
    "    This function greets user with a message\n",
    "    \"\"\"\n",
    "    print(names)\n",
    "    \n",
    "    for name in names:\n",
    "        print('Hello {0}'.format(name))\n",
    "        \n",
    "greetUser('Ravi', 'Shankar', 'Singh')\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Day 28"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "19. Recursive Functions\n",
      "\n",
      "Recursion\n",
      "Factorial of 3 is 6\n",
      "Fabonacci Sequence\n",
      "0\n",
      "1\n",
      "1\n",
      "2\n",
      "3\n",
      "5\n",
      "8\n",
      "13\n",
      "21\n",
      "34\n",
      "\n",
      "Lambda Function\n",
      "8\n",
      "[1, 4, 9, 16, 25]\n"
     ]
    }
   ],
   "source": [
    "print('\\n19. Recursive Functions')\n",
    "\n",
    "print('\\nRecursion')\n",
    "\n",
    "#factorial\n",
    "def factorial(num):\n",
    "    \"\"\"\n",
    "    This is recursive function to find factorial of a given number\n",
    "    \"\"\"\n",
    "    return 1 if num == 1 else (num * factorial(num -1))\n",
    "\n",
    "num = 3\n",
    "print('Factorial of {0} is {1}'.format(num, factorial(num)))\n",
    "\n",
    "\n",
    "#fabonacci sequence\n",
    "def fabonacci(num):\n",
    "    \"\"\"\n",
    "    This recursive function prints fabonacci sequence\n",
    "    \"\"\"\n",
    "    return num if num <= 1 else fabonacci(num -1) + fabonacci(num - 2) \n",
    "\n",
    "n = 10\n",
    "print('Fabonacci Sequence')\n",
    "for num in range(n):\n",
    "    print(fabonacci(num))\n",
    "    \n",
    "print('\\nLambda Function')\n",
    "\n",
    "#syntax\n",
    "#    lambda argument: expression\n",
    "\n",
    "double = lambda x: x*2\n",
    "print(double(4))\n",
    "\n",
    "#example with map()\n",
    "list1 = [1,2,3,4,5]\n",
    "newList = list(map(lambda x: x**2, list1))\n",
    "print(newList)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Day 29"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "Module\n",
      "3.141592653589793\n",
      "3.141592653589793\n",
      "Value of PI is 3.141592653589793\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "['__doc__',\n",
       " '__file__',\n",
       " '__loader__',\n",
       " '__name__',\n",
       " '__package__',\n",
       " '__spec__',\n",
       " 'acos',\n",
       " 'acosh',\n",
       " 'asin',\n",
       " 'asinh',\n",
       " 'atan',\n",
       " 'atan2',\n",
       " 'atanh',\n",
       " 'ceil',\n",
       " 'copysign',\n",
       " 'cos',\n",
       " 'cosh',\n",
       " 'degrees',\n",
       " 'e',\n",
       " 'erf',\n",
       " 'erfc',\n",
       " 'exp',\n",
       " 'expm1',\n",
       " 'fabs',\n",
       " 'factorial',\n",
       " 'floor',\n",
       " 'fmod',\n",
       " 'frexp',\n",
       " 'fsum',\n",
       " 'gamma',\n",
       " 'gcd',\n",
       " 'hypot',\n",
       " 'inf',\n",
       " 'isclose',\n",
       " 'isfinite',\n",
       " 'isinf',\n",
       " 'isnan',\n",
       " 'ldexp',\n",
       " 'lgamma',\n",
       " 'log',\n",
       " 'log10',\n",
       " 'log1p',\n",
       " 'log2',\n",
       " 'modf',\n",
       " 'nan',\n",
       " 'pi',\n",
       " 'pow',\n",
       " 'radians',\n",
       " 'remainder',\n",
       " 'sin',\n",
       " 'sinh',\n",
       " 'sqrt',\n",
       " 'tan',\n",
       " 'tanh',\n",
       " 'tau',\n",
       " 'trunc']"
      ]
     },
     "execution_count": 6,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "print('\\n20. Module')\n",
    "\n",
    "#importing modules\n",
    "import math\n",
    "print(math.pi)\n",
    "\n",
    "import datetime\n",
    "datetime.datetime.now()\n",
    "\n",
    "import math as m\n",
    "print(m.pi)\n",
    "\n",
    "#from...import statement\n",
    "from datetime import datetime\n",
    "datetime.now()\n",
    "\n",
    "#import all names\n",
    "from math import *\n",
    "print('Value of PI is ' + str(pi))\n",
    "\n",
    "#dir() build in function\n",
    "dir(math)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Day 30"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "21. File Handling\n",
      "\n",
      "Open a File\n",
      "\n",
      "Closing a File\n",
      "\n",
      "Writing to a File\n",
      "\n",
      "Reading from a File\n",
      "\n",
      "Renaming and Deleting Files in Python\n",
      "\n",
      "Python Directory and file Management\n"
     ]
    }
   ],
   "source": [
    "print('\\n21. File Handling')\n",
    "\n",
    "# File I/O\n",
    "# File operations\n",
    "# 1. Open a file\n",
    "# 2. Read or write\n",
    "# 3. Close file\n",
    "\n",
    "print('\\nOpen a File')\n",
    "f = open('sample.txt', 'w') #open file in current durectory\n",
    "\n",
    "# Python FIle Modes\n",
    "# 'r' Open a file for reading [default]\n",
    "# 'w' Open a file for writing. Creates a new file if it does not exists or truncates the file if it exists.\n",
    "# 'x' Open a file for exclusive creation. If the file already exists, the operation fails\n",
    "# 'a' Open for appending at the end of the file without truncating it. Creates a new file if it does not exists.\n",
    "# 't' Open in text mode (default)\n",
    "# 'b' Open in binary mode\n",
    "# '+' Open file for updating(reading & writing)\n",
    "\n",
    "f = open('sample.txt', 'r')\n",
    "f = open('smaple.txt', 'w')\n",
    "\n",
    "print('\\nClosing a File')\n",
    "f = open('sample.txt')\n",
    "f.close()\n",
    "\n",
    "try:\n",
    "    f = open('sample.txt')\n",
    "    #perform file operation\n",
    "finally:\n",
    "    f.close()\n",
    "    \n",
    "print('\\nWriting to a File')\n",
    "\n",
    "f = open('testing.txt', 'w')\n",
    "f.write('This is first text from python file I/O\\n')\n",
    "f.write('Second line\\n')\n",
    "f.close()\n",
    "\n",
    "print('\\nReading from a File')\n",
    "f = open('testing.txt', 'r')\n",
    "f.read()\n",
    "\n",
    "f = open('testing.txt', 'r')\n",
    "f.read(10)\n",
    "\n",
    "f = open('testing.txt', 'r')\n",
    "f.readline()\n",
    "\n",
    "f.seek(0)\n",
    "f.readlines()\n",
    "\n",
    "\n",
    "print('\\nRenaming and Deleting Files in Python')\n",
    "\n",
    "import os\n",
    "\n",
    "#Rename a file from testing.txt to test.txt\n",
    "os.rename('testing.txt', 'test.txt')\n",
    "\n",
    "f = open('test.txt', 'r')\n",
    "f.readlines()\n",
    "\n",
    "#Deleting a file\n",
    "os.remove('test.txt')\n",
    "\n",
    "\n",
    "print('\\nPython Directory and file Management')\n",
    "\n",
    "import os\n",
    "#Get current directory\n",
    "os.getcwd()\n",
    "\n",
    "#change directory\n",
    "os.chdir('/Users/mobcoderllc/Documents/Python/')\n",
    "os.getcwd()\n",
    "\n",
    "#List files and sub directories\n",
    "os.listdir(os.getcwd())\n",
    "\n",
    "#Make new directory\n",
    "os.mkdir('test')\n",
    "\n",
    "#Remove directory\n",
    "os.rmdir('test')"
   ]
  },
  {
   "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.6"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}