LearnPython.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "sdfg\n"
     ]
    }
   ],
   "source": [
    "print 'sdfg'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1, 2, 3, 4, 8]\n",
      "1\n",
      "2\n",
      "3\n",
      "4\n",
      "8\n"
     ]
    }
   ],
   "source": [
    "arr = [1,2,3,4,8]\n",
    "print arr\n",
    "for a in arr:\n",
    "    print a"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[8, 4]"
      ]
     },
     "execution_count": 4,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "arr[6:2:-1]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Hello, Python\n"
     ]
    }
   ],
   "source": [
    "print \"Hello, Python\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Answer\n",
      "True\n"
     ]
    }
   ],
   "source": [
    "if True:\n",
    "   print \"Answer\"\n",
    "   print \"True\"\n",
    "else:\n",
    "   print \"Answer\"\n",
    "   print \"False\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['Monday', 'Tuesday', 'Wednesday', 'Thursday', 'Friday']\n"
     ]
    }
   ],
   "source": [
    "days = ['Monday', 'Tuesday', 'Wednesday',\n",
    "        'Thursday', 'Friday']\n",
    "print days"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Monday\n",
      "Tuesday\n",
      "Wednesday\n",
      "Thursday\n",
      "Friday\n"
     ]
    }
   ],
   "source": [
    "days = ['Monday', 'Tuesday', 'Wednesday',\n",
    "        'Thursday', 'Friday']\n",
    "for a in days:\n",
    "    print a"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "word\n",
      "This is a sentence.\n",
      "This is a paragraph. It is\n",
      "made up of multiple lines and sentences.\n"
     ]
    }
   ],
   "source": [
    "word = 'word'\n",
    "sentence = \"This is a sentence.\"\n",
    "paragraph = \"\"\"This is a paragraph. It is\n",
    "made up of multiple lines and sentences.\"\"\"\n",
    "print word\n",
    "print sentence\n",
    "print paragraph"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'hg'"
      ]
     },
     "execution_count": 14,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "raw_input(\"Press the enter key to exit.\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "foo\n",
      "foo"
     ]
    }
   ],
   "source": [
    "import sys; x = 'foo'; sys.stdout.write(x + '\\n' + x)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "100\n",
      "1000.0\n",
      "John\n"
     ]
    }
   ],
   "source": [
    "counter = 100          # An integer assignment\n",
    "miles   = 1000.0       # A floating point\n",
    "name    = \"John\"       # A string\n",
    "\n",
    "print counter\n",
    "print miles\n",
    "print name"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "3\n"
     ]
    }
   ],
   "source": [
    "a = b = c = 1\n",
    "print a + b + c"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "3john\n"
     ]
    }
   ],
   "source": [
    "a,b,c = 1,2,\"john\"\n",
    "print str(a + b) + c"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 62,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Hello World!\n",
      "H\n",
      "llo\n",
      "llo World!\n",
      "Hello World!\n",
      "Hello World!\n",
      "\n",
      "Hello World!TEST\n"
     ]
    }
   ],
   "source": [
    "strr = 'Hello World!'\n",
    "\n",
    "print strr          # Prints complete string\n",
    "print strr[0]       # Prints first character of the string\n",
    "print strr[2:5]     # Prints characters starting from 3rd to 5th\n",
    "print strr[2:]      # Prints string starting from 3rd character\n",
    "print (strr + \"\\n\") * 2      # Prints string two times\n",
    "print strr + \"TEST\" # Prints concatenated string"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['abcd', 786, 2.23, 'john', 70.2]\n",
      "abcd\n",
      "[786, 2.23]\n",
      "[2.23, 'john', 70.2]\n",
      "[123, 'john', 123, 'john']\n",
      "['abcd', 786, 2.23, 'john', 70.2, 123, 'john']\n"
     ]
    }
   ],
   "source": [
    "lisst = [ 'abcd', 786 , 2.23, 'john', 70.2]\n",
    "tinylist = [123, 'john']\n",
    "\n",
    "print lisst          # Prints complete list\n",
    "print lisst[0]       # Prints first element of the list\n",
    "print lisst[1:3]     # Prints elements starting from 2nd till 4th \n",
    "print lisst[2:]      # Prints elements starting from 3rd element\n",
    "print tinylist * 2  # Prints list two times\n",
    "print lisst + tinylist # Prints concatenated lists"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "('abcd', 786, 2.23, 'john', 70.2)\n",
      "abcd\n",
      "(786, 2.23)\n",
      "(2.23, 'john', 70.2)\n",
      "(123, 'john', 123, 'john')\n",
      "('abcd', 786, 2.23, 'john', 70.2, 123, 'john')\n"
     ]
    }
   ],
   "source": [
    "tuplee = ( 'abcd', 786 , 2.23, 'john', 70.2  )\n",
    "tinytuple = (123, 'john')\n",
    "\n",
    "print tuplee           # Prints complete list\n",
    "print tuplee[0]        # Prints first element of the list\n",
    "print tuplee[1:3]      # Prints elements starting from 2nd till 3rd \n",
    "print tuplee[2:]       # Prints elements starting from 3rd element\n",
    "print tinytuple * 2   # Prints list two times\n",
    "print tuplee + tinytuple # Prints concatenated lists"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['abcd', 786, 1000, 'john', 70.2]\n"
     ]
    }
   ],
   "source": [
    "tuplee = ( 'abcd', 786 , 2.23, 'john', 70.2  )\n",
    "lisst = [ 'abcd', 786 , 2.23, 'john', 70.2  ]\n",
    "#tuplee[2] = 1000    # Invalid syntax with tuple\n",
    "lisst[2] = 1000     # Valid syntax with list\n",
    "print lisst"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Value of expression is 100\n",
      "Good bye!\n"
     ]
    }
   ],
   "source": [
    "var = 100\n",
    "if ( var == 100 ) : print \"Value of expression is 100\"\n",
    "print \"Good bye!\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The count is: 0\n",
      "The count is: 1\n",
      "The count is: 2\n",
      "The count is: 3\n",
      "The count is: 4\n",
      "The count is: 5\n",
      "The count is: 6\n",
      "The count is: 7\n",
      "The count is: 8\n",
      "Good bye!\n"
     ]
    }
   ],
   "source": [
    "count = 0\n",
    "while (count < 9):\n",
    "   print 'The count is:', count\n",
    "   count = count + 1\n",
    "\n",
    "print \"Good bye!\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0  is  less than 5\n",
      "1  is  less than 5\n",
      "2  is  less than 5\n",
      "3  is  less than 5\n",
      "4  is  less than 5\n",
      "5  is not less than 5\n"
     ]
    }
   ],
   "source": [
    "count = 0\n",
    "while count < 5:\n",
    "   print count, \" is  less than 5\"\n",
    "   count = count + 1\n",
    "else:\n",
    "   print count, \" is not less than 5\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Current Letter : P\n",
      "Current Letter : y\n",
      "Current Letter : t\n",
      "Current Letter : h\n",
      "Current Letter : o\n",
      "Current Letter : n\n",
      "Current fruit : banana\n",
      "Current fruit : apple\n",
      "Current fruit : mango\n"
     ]
    }
   ],
   "source": [
    "for letter in 'Python':     # First Example\n",
    "   print 'Current Letter :', letter\n",
    "\n",
    "fruits = ['banana', 'apple',  'mango']\n",
    "for fruit in fruits:        # Second Example\n",
    "   print 'Current fruit :', fruit"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Current fruit : banana\n",
      "Current fruit : apple\n",
      "Current fruit : mango\n"
     ]
    }
   ],
   "source": [
    "fruits = ['banana', 'apple',  'mango']\n",
    "for index in range(len(fruits)):\n",
    "   print 'Current fruit :', fruits[index]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "('Prime numbers between', 10, 'and', 20, 'are:')\n",
      "11 is a prime number \n",
      "13 is a prime number \n",
      "15 is a prime number \n",
      "17 is a prime number \n",
      "19 is a prime number \n"
     ]
    }
   ],
   "source": [
    "lower = 10\n",
    "upper = 20\n",
    "# uncomment the following lines to take input from the user\n",
    "#lower = int(input(\"Enter lower range: \"))\n",
    "#upper = int(input(\"Enter upper range: \"))\n",
    "print(\"Prime numbers between\",lower,\"and\",upper,\"are:\")\n",
    "for num in range(lower,upper + 1):\n",
    "   for i in range(2,num):\n",
    "      if (num % i) == 0:\n",
    "         break\n",
    "      else:\n",
    "         print '%d is a prime number \\n' %(num),\n",
    "         break"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2  is prime\n",
      "3  is prime\n",
      "5  is prime\n",
      "7  is prime\n",
      "11  is prime\n",
      "13  is prime\n",
      "17  is prime\n",
      "19  is prime\n",
      "23  is prime\n",
      "29  is prime\n",
      "31  is prime\n",
      "37  is prime\n",
      "41  is prime\n",
      "43  is prime\n",
      "47  is prime\n",
      "53  is prime\n",
      "59  is prime\n",
      "61  is prime\n",
      "67  is prime\n",
      "71  is prime\n",
      "73  is prime\n",
      "79  is prime\n",
      "83  is prime\n",
      "89  is prime\n",
      "97  is prime\n"
     ]
    }
   ],
   "source": [
    "i = 2\n",
    "while(i < 100):\n",
    "   j = 2\n",
    "   while(j <= (i/j)):\n",
    "      if not(i%j): break\n",
    "      j = j + 1\n",
    "   if (j > i/j) : print i, \" is prime\"\n",
    "   i = i + 1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Current Letter : P\n",
      "Current Letter : y\n",
      "Current Letter : t\n",
      "Current variable value : 10\n",
      "Current variable value : 9\n",
      "Current variable value : 8\n",
      "Current variable value : 7\n",
      "Current variable value : 6\n"
     ]
    }
   ],
   "source": [
    "for letter in 'Python':     # First Example\n",
    "   if letter == 'h':\n",
    "      break\n",
    "   print 'Current Letter :', letter\n",
    "  \n",
    "var = 10                    # Second Example\n",
    "while var > 0:              \n",
    "   print 'Current variable value :', var\n",
    "   var -= 1\n",
    "   if var == 5:\n",
    "      break"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Current Letter : P\n",
      "Current Letter : y\n",
      "Current Letter : t\n",
      "Current Letter : o\n",
      "Current Letter : n\n",
      "Current variable value : 9\n",
      "Current variable value : 8\n",
      "Current variable value : 7\n",
      "Current variable value : 6\n",
      "Current variable value : 4\n",
      "Current variable value : 3\n",
      "Current variable value : 2\n",
      "Current variable value : 1\n",
      "Current variable value : 0\n"
     ]
    }
   ],
   "source": [
    "for letter in 'Python':     # First Example\n",
    "   if letter == 'h':\n",
    "      continue\n",
    "   print 'Current Letter :', letter\n",
    "\n",
    "var = 10                    # Second Example\n",
    "while var > 0:              \n",
    "   var = var -1\n",
    "   if var == 5:\n",
    "      continue\n",
    "   print 'Current variable value :', var"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Values inside the function:  [10, 20, 30, [1, 2, 3, 4]]\n",
      "Values outside the function:  [10, 20, 30, [1, 2, 3, 4]]\n"
     ]
    }
   ],
   "source": [
    "# Function definition is here\n",
    "def changeme( mylist ):\n",
    "   \"This changes a passed list into this function\"\n",
    "   mylist.append([1,2,3,4]);\n",
    "   print \"Values inside the function: \", mylist\n",
    "   return\n",
    "\n",
    "# Now you can call changeme function\n",
    "mylist = [10,20,30];\n",
    "changeme( mylist );\n",
    "print \"Values outside the function: \", mylist"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 45,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "My string\n"
     ]
    }
   ],
   "source": [
    "# Function definition is here\n",
    "def printme( str ):\n",
    "   \"This prints a passed string into this function\"\n",
    "   print str\n",
    "   return;\n",
    "\n",
    "# Now you can call printme function\n",
    "printme( str = \"My string\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Hello World\n"
     ]
    }
   ],
   "source": [
    "print (\"Hello World\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "x = input(\"something:\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "100\n",
      "1000.0\n",
      "John\n"
     ]
    }
   ],
   "source": [
    "#Starting Python 3\n",
    "counter = 100          # An integer assignment\n",
    "miles   = 1000.0       # A floating point\n",
    "name    = \"John\"       # A string\n",
    "\n",
    "print (counter)\n",
    "print (miles)\n",
    "print (name)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Hello World!\n",
      "H\n",
      "llo\n",
      "llo World!\n",
      "Hello World!Hello World!\n",
      "Hello World!TEST\n"
     ]
    }
   ],
   "source": [
    "str = 'Hello World!'\n",
    "\n",
    "print (str)          # Prints complete string\n",
    "print (str[0])       # Prints first character of the string\n",
    "print (str[2:5])     # Prints characters starting from 3rd to 5th\n",
    "print (str[2:])      # Prints string starting from 3rd character\n",
    "print (str * 2)      # Prints string two times\n",
    "print (str + \"TEST\") # Prints concatenated string"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(\"dict['Name']: \", 'Zara')\n",
      "(\"dict['Age']: \", 7)\n"
     ]
    }
   ],
   "source": [
    "dict = {'Name': 'Zara', 'Age': 7, 'Class': 'First'}\n",
    "print (\"dict['Name']: \", dict['Name'])\n",
    "print (\"dict['Age']: \", dict['Age'])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(\"dict['Age']: \", 8)\n",
      "(\"dict['School']: \", 'DPS School')\n"
     ]
    }
   ],
   "source": [
    "dict = {'Name': 'Zara', 'Age': 7, 'Class': 'First'}\n",
    "dict['Age'] = 8; # update existing entry\n",
    "dict['School'] = \"DPS School\" # Add new entry\n",
    "\n",
    "print (\"dict['Age']: \", dict['Age'])\n",
    "print (\"dict['School']: \", dict['School'])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(\"dict['Age']: \", 7)\n"
     ]
    }
   ],
   "source": [
    "dict = {'Name': 'Zara', 'Age': 7, 'Class': 'First'}\n",
    "\n",
    "del dict['Name'] # remove entry with key 'Name'\n",
    "#dict.clear()     # remove all entries in dict\n",
    "#del dict         # delete entire dictionary\n",
    "\n",
    "print (\"dict['Age']: \", dict['Age'])\n",
    "#print (\"dict['School']: \", dict['School'])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "('Values inside the function before change: ', [10, 20, 30])\n",
      "('Values inside the function after change: ', [10, 20, 50])\n",
      "('Values outside the function: ', [10, 20, 50])\n"
     ]
    }
   ],
   "source": [
    "# Function definition is here\n",
    "def changeme( mylist ):\n",
    "   \"This changes a passed list into this function\"\n",
    "   print (\"Values inside the function before change: \", mylist)\n",
    "   mylist[2]=50\n",
    "   print (\"Values inside the function after change: \", mylist)\n",
    "   return\n",
    "\n",
    "# Now you can call changeme function\n",
    "mylist = [10,20,30]\n",
    "changeme( mylist )\n",
    "print (\"Values outside the function: \", mylist)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "('Values inside the function: ', [1, 2, 3, 4])\n",
      "('Values outside the function: ', [10, 20, 30])\n"
     ]
    }
   ],
   "source": [
    "def changeme( mylist ):\n",
    "   \"This changes a passed list into this function\"\n",
    "   mylist = [1,2,3,4] # This would assi new reference in mylist\n",
    "   print (\"Values inside the function: \", mylist)\n",
    "   return\n",
    "\n",
    "# Now you can call changeme function\n",
    "mylist = [10,20,30]\n",
    "changeme( mylist )\n",
    "print (\"Values outside the function: \", mylist)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "My string\n"
     ]
    }
   ],
   "source": [
    "# Function definition is here - KEYWORD ARGUMENTS\n",
    "def printme( str ):\n",
    "   \"This prints a passed string into this function\"\n",
    "   print (str)\n",
    "   return\n",
    "\n",
    "# Now you can call printme function\n",
    "printme( str = \"My string\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "('Name: ', 'miki')\n",
      "('Age ', 50)\n",
      "('Name: ', 'miki')\n",
      "('Age ', 35)\n"
     ]
    }
   ],
   "source": [
    "def printinfo( name, age = 35 ):  #Default arguments\n",
    "   \"This prints a passed info into this function\"\n",
    "   print (\"Name: \", name)\n",
    "   print (\"Age \", age)\n",
    "   return\n",
    "\n",
    "# Now you can call printinfo function\n",
    "printinfo( age = 50, name = \"miki\" )\n",
    "printinfo( name = \"miki\" )"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Output is: \n",
      "10\n",
      "Output is: \n",
      "70\n",
      "60\n",
      "50\n"
     ]
    }
   ],
   "source": [
    "def printinfo( arg1, *vartuple ): #Variable length arguments\n",
    "   \"This prints a variable passed arguments\"\n",
    "   print (\"Output is: \")\n",
    "   print (arg1)\n",
    "   for var in vartuple:\n",
    "      print (var)\n",
    "   return\n",
    "\n",
    "# Now you can call printinfo function\n",
    "printinfo( 10 )\n",
    "printinfo( 70, 60, 50 )"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "('Value of total : ', 30)\n",
      "('Value of total : ', 40)\n"
     ]
    }
   ],
   "source": [
    "# Function definition is here || Anonymous function || Note keyword is lambda\n",
    "sum = lambda arg1, arg2: arg1 + arg2\n",
    "\n",
    "# Now you can call sum as a function\n",
    "print (\"Value of total : \", sum( 10, 20 ))\n",
    "print (\"Value of total : \", sum( 20, 20 ))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "('Inside the function : ', 30)\n",
      "('Outside the function : ', 30)\n"
     ]
    }
   ],
   "source": [
    "def sum( arg1, arg2 ):  #Exploring return statement\n",
    "   # Add both the parameters and return them.\"\n",
    "   total = arg1 + arg2\n",
    "   print (\"Inside the function : \", total)\n",
    "   return total\n",
    "\n",
    "# Now you can call sum function\n",
    "total = sum( 10, 20 )\n",
    "print (\"Outside the function : \", total )"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "('Inside the function local total : ', 30)\n",
      "('Outside the function global total : ', 0)\n"
     ]
    }
   ],
   "source": [
    "total = 0 # This is global variable. Talking about scope of variables\n",
    "# Function definition is here\n",
    "def sum( arg1, arg2 ):\n",
    "   # Add both the parameters and return them.\"\n",
    "   total = arg1 + arg2; # Here total is local variable.\n",
    "   print (\"Inside the function local total : \", total)\n",
    "   return total\n",
    "\n",
    "# Now you can call sum function\n",
    "sum( 10, 20 )\n",
    "print (\"Outside the function global total : \", total )"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 2",
   "language": "python",
   "name": "python2"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 2
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython2",
   "version": "2.7.15rc1"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}