01_python_basics.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Python Cheat Sheet\n",
    "This sheet includes the very basics of python that i have created for future reference."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#Comments\n",
    "\n",
    "\n",
    "\"\"\"\n",
    "My name is Jashan Bansal.\n",
    "I am a Computer Engineering Student.\n",
    "This is a multi line comment\n",
    "\"\"\"\n",
    "\n",
    "'''\n",
    "My name is Jashan Bansal.\n",
    "I am a Computer Engineering Student.\n",
    "This is also a multi line comment\n",
    "'''"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['False', 'None', 'True', 'and', 'as', 'assert', '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",
      "33\n"
     ]
    }
   ],
   "source": [
    "# Keywords of python\n",
    "\n",
    "import keyword\n",
    "print(keyword.kwlist)\n",
    "print(len(keyword.kwlist))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Jashan Bansal\n",
      "More Readable\n",
      "Jashan Bansal\n",
      "Less Readable\n"
     ]
    }
   ],
   "source": [
    "if True:\n",
    "    print(\"Jashan Bansal\")\n",
    "    print(\"More Readable\")\n",
    "\n",
    "    \n",
    "if True: print(\"Jashan Bansal\"); print(\"Less Readable\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1\n",
      "36\n",
      "36\n",
      "10 20 30\n"
     ]
    }
   ],
   "source": [
    "# Statements\n",
    "a = 1\n",
    "print(a)\n",
    "\n",
    "# Multiline statement\n",
    "\n",
    "a = 1 + 2 + 3 + \\\n",
    "    4 + 5 + 6 + \\\n",
    "    7 + 8\n",
    "print(a)\n",
    "\n",
    "# Another way for Multiline statement\n",
    "\n",
    "a = (1 + 2 + 3 + \n",
    "    4 + 5 + 6 + \n",
    "    7 + 8)\n",
    "print(a)\n",
    "\n",
    " \n",
    "# Multiple lines in a single line for shortness\n",
    "\n",
    "a= 10; b= 20; c= 30;\n",
    "print(a,b,c)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Variable Assignments\n",
    "a = 10\n",
    "b = 5.5\n",
    "c = 'ML'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Multiline Assignments\n",
    " \n",
    "a, b, c = 10, 5.5, 'ML'\n",
    "\n",
    "a = b = c = 'ML' # Assign the same value to multiple variables\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1649176096\n"
     ]
    }
   ],
   "source": [
    "# Storage Locations\n",
    "\n",
    "x = 3\n",
    "print(id(x))         # print the address of variable x"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1649176096\n"
     ]
    }
   ],
   "source": [
    "y = 3\n",
    "print(id(y))        # print the address of variable x\n",
    "\n",
    "# See the Address of y, it is same as of x"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1649176064\n"
     ]
    }
   ],
   "source": [
    "y = 2\n",
    "print(id(y))       # Now see the address is changed"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<class 'int'>\n",
      "<class 'float'>\n",
      "<class 'str'>\n",
      "<class 'complex'>\n",
      "True\n"
     ]
    }
   ],
   "source": [
    "# Data Types\n",
    "\n",
    "# Everything in python is an Object\n",
    "\n",
    "# Numbers - int float complex class in python\n",
    "\n",
    "# Use type() function \n",
    "\n",
    "# Use isinstance()\n",
    "\n",
    "a = 5\n",
    "print(type(a))\n",
    "\n",
    "b = 2.5\n",
    "print(type(b))\n",
    "\n",
    "c = 'ML'\n",
    "print(type(c))\n",
    "\n",
    "d = 1 + 2j\n",
    "print(type(d))\n",
    "\n",
    "print(isinstance(a, int))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<class 'bool'>\n"
     ]
    }
   ],
   "source": [
    "# Boolean\n",
    "\n",
    "a = True\n",
    "print(type(a))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 59,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<class 'str'>\n",
      "Jashan Bansal\n"
     ]
    }
   ],
   "source": [
    "# Strings: Sequence of Unicode characters '' '' \"\" \"\"\n",
    "# Multiline Strigs \"\"\" \"\"\", ''' '''\n",
    "\n",
    "st = \"Jashan Bansal\"\n",
    "print(type(st))\n",
    "print(st)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 56,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Jashan\n",
      "Bansal\n"
     ]
    }
   ],
   "source": [
    "st = \"\"\"Jashan\n",
    "Bansal\"\"\"\n",
    "print(st)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 62,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "J\n",
      "l\n",
      "l\n"
     ]
    }
   ],
   "source": [
    "# Indexing \n",
    "print(st[0])\n",
    "\n",
    "# Last character s[len(s)-1] or s[-1]\n",
    "print(st[len(st)-1])\n",
    "print(st[-1])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 60,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'n Bansal'"
      ]
     },
     "execution_count": 60,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Strings Slicing\n",
    "\n",
    "st[5:]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[10, 20.5, 'Jashan']\n"
     ]
    }
   ],
   "source": [
    "# Lists : Ordered Sequence of items\n",
    "\n",
    "a = [10, 20.5, 'Jashan']\n",
    "print(a)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[10, 30.7, 'Jashan']\n"
     ]
    }
   ],
   "source": [
    "# Lists are mutable, meaning value of elements can be changed\n",
    "a[1] = 30.7\n",
    "print(a)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(1, 2, 3)\n"
     ]
    }
   ],
   "source": [
    "# Tuples: Tuples created can not be modified\n",
    "\n",
    "t = (1,2,3)\n",
    "print(t)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {},
   "outputs": [
    {
     "ename": "TypeError",
     "evalue": "'tuple' object does not support item assignment",
     "output_type": "error",
     "traceback": [
      "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[1;31mTypeError\u001b[0m                                 Traceback (most recent call last)",
      "\u001b[1;32m<ipython-input-37-5ff931556598>\u001b[0m in \u001b[0;36m<module>\u001b[1;34m()\u001b[0m\n\u001b[1;32m----> 1\u001b[1;33m \u001b[0mt\u001b[0m\u001b[1;33m[\u001b[0m\u001b[1;36m1\u001b[0m\u001b[1;33m]\u001b[0m \u001b[1;33m=\u001b[0m \u001b[1;34m'Jashan'\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[1;31mTypeError\u001b[0m: 'tuple' object does not support item assignment"
     ]
    }
   ],
   "source": [
    "t[1] = 'Jashan'\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{1, 2, 3, 4}\n",
      "<class 'set'>\n"
     ]
    }
   ],
   "source": [
    "# python sets: unordered collection of unique items \n",
    "\n",
    "a = {1,2,3,4}\n",
    "print(a)\n",
    "print(type(a))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{1}\n"
     ]
    }
   ],
   "source": [
    "a = {1,1,1,1,1,1}\n",
    "print(a)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "metadata": {},
   "outputs": [
    {
     "ename": "TypeError",
     "evalue": "'set' object does not support indexing",
     "output_type": "error",
     "traceback": [
      "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[1;31mTypeError\u001b[0m                                 Traceback (most recent call last)",
      "\u001b[1;32m<ipython-input-42-bb6a8a2f4689>\u001b[0m in \u001b[0;36m<module>\u001b[1;34m()\u001b[0m\n\u001b[1;32m----> 1\u001b[1;33m \u001b[0mprint\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0ma\u001b[0m\u001b[1;33m[\u001b[0m\u001b[1;36m1\u001b[0m\u001b[1;33m]\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[1;31mTypeError\u001b[0m: 'set' object does not support indexing"
     ]
    }
   ],
   "source": [
    "print(a[1])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'a': 1, 1: 'a'}\n",
      "1\n",
      "a\n"
     ]
    }
   ],
   "source": [
    "# Python Dictionary: Unordered colletion os key-value pairs\n",
    "\n",
    "d = { 'a': 1, 1: 'a'}\n",
    "print(d)\n",
    "print(d['a'])\n",
    "print(d[1])\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "metadata": {},
   "outputs": [
    {
     "ename": "SyntaxError",
     "evalue": "invalid syntax (<ipython-input-44-3f46e10a7785>, line 10)",
     "output_type": "error",
     "traceback": [
      "\u001b[1;36m  File \u001b[1;32m\"<ipython-input-44-3f46e10a7785>\"\u001b[1;36m, line \u001b[1;32m10\u001b[0m\n\u001b[1;33m    int(10p)\u001b[0m\n\u001b[1;37m          ^\u001b[0m\n\u001b[1;31mSyntaxError\u001b[0m\u001b[1;31m:\u001b[0m invalid syntax\n"
     ]
    }
   ],
   "source": [
    "# Conversion between DataTypes\n",
    "\n",
    "'''\n",
    "int()\n",
    "float()\n",
    "str()\n",
    "'''\n",
    "\n",
    "int(10.4)\n",
    "int(10p)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 67,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<class 'list'>\n",
      "<class 'set'>\n"
     ]
    }
   ],
   "source": [
    "a = [1,2,3]\n",
    "print(type(a))\n",
    "\n",
    "s = set(a)\n",
    "print(type(s))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['J', 'a', 's', 'h', 'a', 'n']"
      ]
     },
     "execution_count": 1,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "list('Jashan')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "30\n"
     ]
    }
   ],
   "source": [
    "# Operators and operands\n",
    "\n",
    "x,y = 10, 20\n",
    "z = x+y\n",
    "print(z)\n",
    "\n",
    "#     + - * / // **\n",
    "#     == = > < >= <=\n",
    "#     and or not\n",
    "#     & | ! ^ >> <<\n",
    "#     Compound assignment operators"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "True\n"
     ]
    }
   ],
   "source": [
    "# Identity operators is, is not (check if two values are located in same part of the memory)\n",
    "a = 5\n",
    "b = 5\n",
    "print(a is b)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "False\n"
     ]
    }
   ],
   "source": [
    "# Not true for complex variables\n",
    "l1 = [1,2,3]\n",
    "l2 = [1,2,3]\n",
    "print(l1 is l2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "True\n"
     ]
    }
   ],
   "source": [
    "# True for strings \n",
    "s1 = 'Jashan'\n",
    "s2 = 'Jashan'\n",
    "print(s1 is s2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "True\n"
     ]
    }
   ],
   "source": [
    "# Memebership operators: for strings, dict, list, set etc\n",
    "l1 = [1,2,3,4]\n",
    "print(1 in l1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "True\n"
     ]
    }
   ],
   "source": [
    "d1 = {'a':1, 'b':2}    # in oper to check only the keys\n",
    "print('a' in d1)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Jashan Bansal\n",
      "Enter a number100\n",
      "100\n"
     ]
    }
   ],
   "source": [
    "# Input/ Output in Pyhton\n",
    "\n",
    "print('Jashan', 'Bansal')\n",
    "num = input('Enter a number')\n",
    "print(num)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The value of a is 10 and b is 20\n"
     ]
    }
   ],
   "source": [
    "# Output Formatting\n",
    "a= 10; b=20\n",
    "print('The value of a is {} and b is {}'.format(a,b))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The value of b is 20 and a is 10\n"
     ]
    }
   ],
   "source": [
    "a= 10; b=20\n",
    "print('The value of b is {1} and a is {0}'.format(a,b))   # specify positions"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Hello Jashan, Nice to see you!\n"
     ]
    }
   ],
   "source": [
    "print('Hello {name}, {greeting}'.format(name='Jashan', greeting=\"Nice to see you!\"))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The story of Jashan, Jimmy, and Brad\n"
     ]
    }
   ],
   "source": [
    "print('The story of {0}, {1}, and {other}'.format('Jashan', 'Jimmy', other='Brad'))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'\\nEverything is taken True except 0 and None\\n'"
      ]
     },
     "execution_count": 19,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Conditional Statements\n",
    "\n",
    "'''\n",
    "if\n",
    "if-else\n",
    "if-elif-else\n",
    "Nested if statments\n",
    "'''\n",
    "\n",
    "\n",
    "'''\n",
    "Everything is taken True except 0 and None\n",
    "'''"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "10\n"
     ]
    }
   ],
   "source": [
    "# Concise way of writing if else\n",
    "\n",
    "a = 10\n",
    "b = 20\n",
    "\n",
    "smaller = b if a>b else a\n",
    "print(smaller)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Product is: 12000000\n"
     ]
    }
   ],
   "source": [
    "# Control Flow while loop: Used to iterate as long as the test expression is true\n",
    "\n",
    "lst = [10, 20 ,30, 40, 50]\n",
    "\n",
    "product = 1\n",
    "index = 0\n",
    "\n",
    "while index < len(lst):\n",
    "    product *= lst[index]\n",
    "    index += 1\n",
    "    \n",
    "print('Product is: {}'.format(product))\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1\n",
      "2\n",
      "3\n",
      "Voila\n"
     ]
    }
   ],
   "source": [
    "# While loop with else: The else part is executed if the condition in the while loop evalutes to false\n",
    "\n",
    "nList = [1,2,3]\n",
    "\n",
    "index = 0\n",
    "while index < len(nList):\n",
    "    print(nList[index])\n",
    "    index += 1\n",
    "else:\n",
    "    print('Voila')\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Product is: 12000000\n"
     ]
    }
   ],
   "source": [
    "# For loop: iterate over a sequence(list, tuple, string) or other iterable objects. Itearating over a sequence is called traversal.\n",
    "\n",
    "\n",
    "lst = [10, 20 ,30, 40, 50]\n",
    "\n",
    "product = 1\n",
    "\n",
    "# Iterating over the list\n",
    "for ele in lst:\n",
    "    product *= ele\n",
    "    \n",
    "print('Product is: {}'.format(product))\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Jashan 0\n",
      "Jashan 1\n",
      "Jashan 2\n",
      "Jashan 3\n",
      "Jashan 4\n",
      "Jashan 5\n",
      "Jashan 6\n",
      "Jashan 7\n",
      "Jashan 8\n",
      "Jashan 9\n"
     ]
    }
   ],
   "source": [
    "# range() function in python\n",
    "\n",
    "\"\"\"\n",
    "We can generate a sequnce of numbers using range() fxn.\n",
    "We can define start stop and step size.\n",
    "The function does not store the values in memory. It would be efficient. So it remembers the start stop and step size and generates the nexr numbers on the go\n",
    "\"\"\"\n",
    "\n",
    "for i in range(10):\n",
    "    print('Jashan', i)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Jashan 1\n",
      "Jashan 3\n",
      "Jashan 5\n",
      "Jashan 7\n",
      "Jashan 9\n"
     ]
    }
   ],
   "source": [
    "for i in range(1, 10, 2):\n",
    "    print('Jashan', i)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Jashan\n",
      "Jimmy\n",
      "JashanJim\n"
     ]
    }
   ],
   "source": [
    "lst = ['Jashan', 'Jimmy', 'JashanJim']\n",
    "\n",
    "for index in range(len(lst)):\n",
    "    print(lst[index])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Jashan\n",
      "Jimmy\n",
      "JashanJim\n",
      "Jashan\n"
     ]
    }
   ],
   "source": [
    "# for else loop\n",
    "\n",
    "for item in lst:\n",
    "    print(item)\n",
    "else:\n",
    "    print('Jashan')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1\n",
      "2\n",
      "3\n",
      "Outside of for-else block\n"
     ]
    }
   ],
   "source": [
    "// Break statament\n",
    "\n",
    "numbers = [1,2,3,4]\n",
    "\n",
    "for num in numbers:\n",
    "    if num == 4:\n",
    "        break;\n",
    "    print(num)\n",
    "else:\n",
    "    print('In the else block')\n",
    "print('Outside of for-else block')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1\n",
      "3\n",
      "Else block\n"
     ]
    }
   ],
   "source": [
    "# Continue statement\n",
    "\n",
    "numbers = [1,2,3,4]\n",
    "\n",
    "for i in numbers:\n",
    "    if i % 2 == 0:\n",
    "        continue\n",
    "    print(i)\n",
    "else:\n",
    "    print('Else block')\n",
    "    "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.6.4"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}