0.Python crash-course(Optional).ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Python Crash Course"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Table of contents\n",
    "<ul class=\"toc-item\">\n",
    "            <ul class=\"toc-item\">\n",
    "                <li><span><a href=\"#Python-features\">Python features</a></span></li>\n",
    "                <li><span><a href=\"#What-is-jupyter-(formerly-ipython)-notebook?\">What is jupyter (formerly ipython) notebook?</a></span></li>\n",
    "            </ul>\n",
    "        <li><span></i><a href=\"#PART---1\">PART - 1</a></span>\n",
    "            <ul class=\"toc-item\">\n",
    "                <li><span><a href=\"#Built-in-magic-commands-in-jupyter\">Built-in magic commands in jupyter</a></span></li>\n",
    "                <li><span><a href=\"#Python-interpreter\">Python interpreter</a></span></li>\n",
    "                <li><span><a href=\"#print()\">print()</a></span></li>\n",
    "                <li><span><a href=\"#type()\">type()</a></span></li>\n",
    "                <li><span><a href=\"#help()\">help()</a></span></li>\n",
    "                <li><span><a href=\"#Identifiers\">Identifiers</a></span></li>\n",
    "                <li><span><a href=\"#Python3-keywords-list\">Python3 keywords list</a></span></li>\n",
    "                <li><span><a href=\"#Assignment-operator\">Assignment operator</a></span></li>\n",
    "                <li><span><a href=\"#List-of-python-literals\">List of python literals</a></span></li>\n",
    "                <li><span><a href=\"#Comments-and-multiline-strings-in-python\">Comments and multiline strings in python</a></span></li>\n",
    "                <li><span><a href=\"#Python-is-strongly-dynamically-typed\">Python is strongly dynamically typed</a></span></li>\n",
    "                <li><span><a href=\"#Type-conversion\">Type conversion</a></span></li>\n",
    "                <li><span><a href=\"#Math-operators\">Math operators</a></span></li>\n",
    "                <li><span><a href=\"#Boolean-operations\">Boolean operations</a></span></li>\n",
    "                <li><span><a href=\"#Explicit-type-conversion\">Explicit type conversion</a></span></li>\n",
    "                <li><span><a href=\"#Standard-numeric-operations\">Standard numeric operations</a></span></li>\n",
    "                <li><span><a href=\"#Input-data\">Input data</a></span></li>\n",
    "            </ul>\n",
    "        </li>\n",
    "        <li><span></i><a href=\"#PART-2\">PART-2</a></span>\n",
    "            <ul class=\"toc-item\">\n",
    "                <li><span><a href=\"#Python-modules\">Python modules</a></span></li>\n",
    "                <li><span><a href=\"#Import-a-module\">Import a module</a></span></li>\n",
    "                <li><span><a href=\"#Common-compound-data-structure-literals\">Common compound data structure literals</a></span></li>\n",
    "                <li><span><a href=\"#Tuples\">Tuples</a></span></li>\n",
    "                <li><span><a href=\"#named-tuples\">named tuples</a></span></li>\n",
    "                <li><span><a href=\"#Lists\">Lists</a></span></li>\n",
    "                <li><span><a href=\"#Shallow-copy-vs-Deep-copy\">Shallow copy vs Deep copy</a></span></li>\n",
    "                <li><span><a href=\"#More-on-lists\">More on lists</a></span></li>\n",
    "                <li><span><a href=\"#Set-types\">Set types</a></span></li>\n",
    "                <li><span><a href=\"#Set-operations\">Set operations</a></span></li>\n",
    "                <li><span><a href=\"#Dictionaries\">Dictionaries</a></span></li>\n",
    "                <li><span><a href=\"#Looping-dictionary's-elements\">Looping dictionary's elements</a></span></li>\n",
    "                <li><span><a href=\"#Other-dictionary's-methods\">Other dictionary's methods</a></span></li>\n",
    "                <li><span><a href=\"#Control-flow-tools:\">Control flow tools:</a></span></li>\n",
    "                <li><span><a href=\"#Conditional-statements\">Conditional statements</a></span></li>\n",
    "                <li><span><a href=\"#Loops\">Loops</a></span></li>\n",
    "                <li><span><a href=\"#The-pass-statement\">The pass statement</a></span></li>\n",
    "                <li><span><a href=\"#Iterables\">Iterables</a></span></li>\n",
    "                <li><span><a href=\"#Looping-techniques-on-iterables\">Looping techniques on iterables</a></span></li>\n",
    "                <li><span><a href=\"#Context-manager\">Context manager</a></span></li>\n",
    "                <li><span><a href=\"#Handling-exceptions\">Handling exceptions</a></span></li>\n",
    "                <li><span><a href=\"#Function-definition-in-python\">Function definition in python</a></span></li>\n",
    "                <li><span><a href=\"#Keyword-and-positional-arguments\">Keyword and positional arguments</a></span></li>\n",
    "                <li><span><a href=\"#Lambda-expressions\">Lambda expressions</a></span></li>\n",
    "            </ul>\n",
    "        </li>\n",
    "</ul>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "cell_style": "center",
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Python features\n",
    "* Easy to use and learn \n",
    " * Readability \n",
    "* Interpreted language \n",
    " * Portability "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## What is jupyter (formerly ipython) notebook? \n",
    "* this document is a jupyter notebook\n",
    "* flexible tool to create readable documents that embed:\n",
    " * code\n",
    " * images\n",
    " * comments\n",
    " * formulas\n",
    " * plots\n",
    "* jupyter supports notebooks form many different languages (including python, julia and R) \n",
    "* each document runs a computational engine that executes the code written in the cells\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# PART - 1"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Built-in magic commands in jupyter \n",
    "* jupyter embeds special commands (called magics) that enables to run different kind of code. \n",
    " * magic inline commands start with \"%\" \n",
    " * magic multiple line commands start with \"%%\"\n",
    " * you can list magic commands running %lsmagic\n",
    " * you can pop-up the magic command documentation (if any) adding \"?\" after the command with no space\n",
    "* few magics you might find useful: \n",
    " * ! runs inline shell commands\n",
    " * %%bash to run bash program (same syntax for other languages)\n",
    " * embed latex inline between \\$\\$ \n",
    " * %%latex to render a latex block \n",
    " * ... \n",
    " * %reset to remove all names defined by the user"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": true,
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [],
   "source": [
    "%lsmagic"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [],
   "source": [
    "!ls | grep ipy"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Python interpreter\n",
    "* Compile source to bytecode then execute it on a virtual machine \n",
    "* Survives any execution error, even in case of syntax errors\n",
    " * in python also indentation is syntax\n",
    "* expression is code that returns an object \n",
    "* if no error, the prompt (\">>>\") automatically: \n",
    " * prints the result on screen\n",
    " * assigns the result to \"_\"\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [],
   "source": [
    "# expression that returns something\n",
    "12345"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [],
   "source": [
    "# that something was assigned to \"_\"\n",
    "_"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [],
   "source": [
    "# Error example: division by 0\n",
    "1/0"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Note: Some of the cells in this notebook create such errors as you will see once you try them. Notice them carefully to see how python errors are written."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## print()\n",
    "\n",
    "* prints arguments on standard output\n",
    "* can receive an arbitrary number of arguments\n",
    "* ends with \"\\n\" unless differently specified with \"end\" key\n",
    "* --\n",
    "\n",
    "## type()\n",
    "\n",
    "* returns the type of the argument\n",
    "* --\n",
    "\n",
    "## help()\n",
    "\n",
    "* The Python interpreter comes with a help() function \n",
    " * call \"help(something)\" to learn about something (if something is defined\n",
    " * type \"help()\" to start the help prompt (\"help>\"), to exit execute quit\n",
    " "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Following import is for printing in python 3.x format\n",
    "# ignore this line for now\n",
    "from __future__ import print_function "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [],
   "source": [
    "print(\"print\") \n",
    "print(\"ends\")\n",
    "print(\"with\")\n",
    "print(\"newline\") \n",
    "\n",
    "print(\"\\nunless\", end=\" \")   # ends with a space instead of newline\n",
    "print(\"differently specified\")\n",
    "\n",
    "print(\"\\nprint\",\"can\",\"accept\",\"multiple\",\"arguments\")   # sep with a separator instead of a space \n",
    "print(\"\\nprint\",\"can\",\"accept\",\"multiple\",\"arguments\", sep=\"\\_/\")  "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [],
   "source": [
    "type(print)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [],
   "source": [
    "help(print)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Identifiers \n",
    "* Identifiers are names that are assigned to objects\n",
    " * Identifiers cannot start with a digit\n",
    " * nor contain hyphens (minus signs)\n",
    " * nor periods (dot signs)\n",
    " * nor blank spaces\n",
    "* descriptive names should be preferred \n",
    "* short names should be preferred \n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Python3 keywords list\n",
    "\n",
    "* keywords are reserved words that already means something\n",
    "* reserved means these words cannot be Identifiers"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "```python\n",
    "False,None,True,and,as,assert,break,class,continue,def,del,elif,else,except,finally,for,\n",
    "from,global,if,import,in,is,lambda,nonlocal,not,or,pass,raise,return,try,while,with,yield\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Assignment operator\n",
    "* the equal sign is the assignment operator, which means...\n",
    "* ...\"evaluate the operand/expression on the right side of the equal sign and assign that to the operand on the left (the 'lvalue').”\n",
    "* python provides cascaded assignments  \n",
    " * var1 = var2 = var3 = value\n",
    "* python provides augmented assignment operators \n",
    " * standard math operations: +=,-=,\\*=,/= \n",
    " * modulo,remainder,exponentiation: %=,//=,\\**= \n",
    " * bitwise math operations: &=,|=,^=,>>=,<<=\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [],
   "source": [
    "# cascade assignments\n",
    "x = y = z = 10  \n",
    "# augmented assignments\n",
    "x/=2\n",
    "y+=1\n",
    "print(\"x =\",x,type(x))\n",
    "print(\"y =\",y,type(x))\n",
    "print(\"z =\",z,type(x))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## List of python literals\n",
    "\n",
    "* strings (collection of characters enclosed in quotes \"\" or '')\n",
    " * ''' or \"\"\" starts (ends) a multiline string (triple-quoted string)\n",
    "* integer numeric literals \n",
    "* float numeric literals \n",
    "* complex numeric literals ('j'/'J' yields an imaginary number)\n",
    "* boolean literals which are \"True\" or \"False\" (both keywords)\n",
    "* None"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [],
   "source": [
    "print(\"\\\"A\\\"\", \"is a\", type(\"A\"))\n",
    "print(\"\\'A\\'\", \"is also a\", type(\"A\"))\n",
    "print(\"in other words, \\\"A\\\" is 'A' - >\",\"A\" is 'A')\n",
    "print(\"\\\"\\\"\\\"\\nmulti\\nline\\nstring\\n\\\"\\\"\\\"\", \"is also a\", type(\"\"\"\\nmulti\\nline\\nstring\\n\"\"\"))\n",
    "print(1,\"is a\", type(1))\n",
    "print(1.,\"is a\", type(1.))\n",
    "print(1.+1j,\"is a\",type(1.+1j))\n",
    "print(\"True\",\"is a\",type(True))\n",
    "print(None,\"is a\",type(None))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [],
   "source": [
    "print(\"\\nyou should use \\\\ to print special characters \\\" or \\'\")\n",
    "print(\"\\nstrings defined by \\\" understands special character ' without \\\\ \")\n",
    "print('strings defined by \\' understands special character \" without \\\\' )"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Comments and multiline strings in python\n",
    "\n",
    "* \\# starts an inline comment \n",
    "* triple-quoted strings can be used for documentation (returned by help() function)\n",
    " * we'll see this later\n",
    "* triple-quoted strings can be used as multiline comments"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [],
   "source": [
    "# to comment this line\n",
    "\n",
    "s = '''triple-quoted \n",
    "strings\n",
    "are   \n",
    "multiline\n",
    "'''\n",
    "'''\n",
    "triple-quoted strings that are not docstrings (first thing in a class/function/module) are ignored \n",
    "and can be used \n",
    "as multiline comments\n",
    "'''\n",
    "\n",
    "print(s) "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Python is strongly dynamically typed\n",
    "\n",
    "* strong means that every change requires an explicit conversion \n",
    "* dynamic typing means that values have a type, not variables \n",
    " * i.e., variables can name any object \n",
    " * only keywords cannot be reassigned \n",
    "* also functions such as print() and type() use names that are not keywords\n",
    " * they could potentially reassigned to new objects \n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [],
   "source": [
    "print(\"What means that python is DYNAMICALLY typed\\n\")\n",
    "myVar = 1\n",
    "print(\"myVar =\",myVar,\"\\n -> myVar names a\",type(myVar))\n",
    "myVar = \"myVar\"\n",
    "print(\"myVar =\",myVar,\"\\n -> now it names a\",type(myVar))\n",
    "myVar = None\n",
    "print(\"myVar =\",myVar,\"\\n -> now it names a\",type(myVar))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [],
   "source": [
    "print(\"\\n#reassign objects to print and type \\nprint=10 \\ntype=-1 \\nprint,type\")\n",
    "print = 10\n",
    "type = -1\n",
    "print, type"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [],
   "source": [
    "print(1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [],
   "source": [
    "# force reset of all user defined names, included print and type\n",
    "%reset -f \n",
    "# now print and type are back to work\n",
    "print(\"back to work\", type(\"back to work\"))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Type conversion\n",
    "\n",
    "* Generally, conversions MUST be explicit because Python is strongly dynamically typed\n",
    "* However, Python does some automatic conversions\n",
    " * between numeric types (where it makes sense)\n",
    " * empty container types as well as zero are considered False in a boolean context \n",
    "\n",
    "\n",
    "## Math operators \n",
    "\n",
    "* python provides standard arithmetic operators +,-,*,/ \n",
    "* exponentiation operator ** \n",
    " * ** is right associative\n",
    "* floor division operator // \n",
    " * a//b returns the greatest whole number that does not exceed a/b\n",
    "* modulo (reminder) %\n",
    " * complements // by telling what remains from the floor division\n",
    "* parentheses can change the order of operations\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [],
   "source": [
    "print(\"implicit conversion between numeric literals is allowed, if that makes sense\")\n",
    "print(\"(12.+1j)+3 -> \",(12.+1j)+3)\n",
    "print(\"\\nimplicit conversion from string to a numeric literal returns an error\")\n",
    "print(\"'12'+3 \\n -> returns\")\n",
    "'12'+3"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [],
   "source": [
    "print(\"\\n#Operations between numbers\")\n",
    "print(\"\\n# summation with float -> float\",\"\\ntype(1+1.)\")\n",
    "print(type(1+1.))     \n",
    "print(\"\\n# division with integers -> float\",\"\\ntype(3/2)\")\n",
    "print(type(3/2))      \n",
    "print(\"\\n# operations between parentheses are executed earlier \",\"\\n4/(2+2)\")\n",
    "print(4/(2+2))        \n",
    "print(\"\\n# exponentiation (default right associative)\",\"\\n2**3\",\", 2**3**2\",\", 2**(3**2)\",\", (2**3)**2\")\n",
    "print(2**3, \",\", 2**3**2, \",\", 2**(3**2), \",\", (2**3)**2)\n",
    "print(\"\\n# floor division \",\"\\n9.5/2\",\", 9.5//2\",\", 9.1//2\",\", 9.9//2\")\n",
    "print(9.5/2, \",\", 9.5//2, \",\", 9.1//2, \",\", 9.9//2)\n",
    "print(\"\\n# modulo \",\", 9.5%2\",\", 9.1%2\",\", 9.9%2\")\n",
    "print(9.5%2, \",\", 9.1%2, \",\", 9.9%2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Boolean operations\n",
    "* standard boolean operations: and, or, not \n",
    " * x or y  (if x is false, then y, else x)\n",
    " * x and y (if x is false, then x, else y)\n",
    " * not x (if x is false, then True, else False)\n",
    "* standard comparison operations: <,<=,>,>=,==,!= \n",
    " * (strictly) greater/less (or equal) than, equal, not equal\n",
    "* object identity \"is\" \n",
    "* negated object identity \"is not\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [],
   "source": [
    "x = True\n",
    "y = False\n",
    "\n",
    "print(\"\\nx=True\",\"y=False\")\n",
    "print (\"\\nx or y =\",x or y,\"\\nx and y =\",x and y,\"\\nnot x =\", not x)\n",
    "\n",
    "print(\"\\n0>0 =\",0>0, \"\\n0>=0 =\",0>=0,\"\\n0<0 =\",0>0, \"\\n0<=0 =\",0>=0, \"\\n0==0 =\",0==0, \"\\n0!=0 =\",0!=0)\n",
    "\n",
    "print(\"\\ntype(5.) is float =\",type(5.) is float, \"\\ntype(5.) is not float =\",type(5.) is not float)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Explicit type conversion \n",
    "* int(x): x converted to integer\n",
    " * bin(x): returns a string with the binary representation\n",
    "* float(x): x converted to float\n",
    "* complex(re,im): real part re, imaginary part im (im default is zero)\n",
    "* str(x): x converted to string"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [],
   "source": [
    "print(\"\\nconverting numeric literals to other numeric literals\")\n",
    "print(\"int(-4.) ->\",int(-4.),type(int(-4.)))\n",
    "print(\"float(-4) ->\",float(-4),type(float(-4)))\n",
    "print(\"complex(-4) ->\",complex(-4),type(complex(-4)))\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [],
   "source": [
    "print(\"complex type cannot be converted neither to int...\")\n",
    "int(4.+0j)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": true,
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [],
   "source": [
    "print(\"...nor to float\")\n",
    "float(4.+0j)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [],
   "source": [
    "print(\"\\nconverting strings to numbers\")\n",
    "print(\"int(\\\"3\\\") ->\",int(\"3\"),type(int(\"3\")))\n",
    "print(\"float(\\\"3.\\\") ->\",float(\"3.\"),type(float(\"3.\")))\n",
    "print(\"complex(\\\"3.\\\") ->\",complex(\"3.\"),type(complex(\"3.\")))\n",
    "print(\"float(\\\"3\\\") ->\",float(\"3\"),type(float(\"3\")))\n",
    "print(\"float(\\\"3.\\\") ->\",float(\"3.\"),type(float(\"3.\")))\n",
    "print(\"complex(\\\"3\\\") ->\",complex(\"3\"),type(complex(\"3\")))\n",
    "print(\"complex(\\\"3.\\\") ->\",complex(\"3.\"),type(complex(\"3.\")))    \n",
    "print(\"complex(\\\"3+0j\\\") ->\",complex(\"3+0j\"),type(complex(\"3+0j\")))    \n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [],
   "source": [
    "print(\"\\nconverting numbers to strings\")\n",
    "print(\"str(3) ->\",str(3),type(str(3)))\n",
    "print(\"str(3.) ->\",str(3.),type(str(3.)))\n",
    "print(\"str(3+3j) ->\",str(3+3j),type(str(3+3j)))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [],
   "source": [
    "print(\"\\nwhen the conversion numeric to string fails: \\n\")\n",
    "try:\n",
    "    print(\"int(\\\"3.\\\") ->\",int(\"3.\"),type(int(\"3.\")))\n",
    "except ValueError:\n",
    "    print(\"int(\\\"3.\\\")\\n ->\",\"error: invalid literal for int() with base 10: '3.'\")\n",
    "print()    \n",
    "try:\n",
    "    print(\"float(\\\"3+0j\\\") ->\",float(\"3+0j\"),type(float(\"3+0j\")))    \n",
    "except ValueError:\n",
    "    print(\"float(\\\"3+0j\\\")\\n ->\",\"error: could not convert string to float: '3+0j'\")    "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [],
   "source": [
    "print(\"print integers in binary format\")\n",
    "print(\"bin(40) ->\",bin(40),type(bin(40)))\n",
    "print(\"bin(40%2**4) ->\",bin(40%2**4))\n",
    "print(\"bin(40%2**6) ->\",bin(40%2**6))\n",
    "print(\"bin(40%2**32) ->\",bin(40%2**32))\n",
    "\n",
    "print(\"\\nbinary format make sense only for integers\\n\")\n",
    "try:\n",
    "    print(\"bin(0.) ->\",bin(0.))\n",
    "except: \n",
    "    print(\"bin(0.)\\n ->\",\"'float' object cannot be interpreted as an integer\")\n",
    "print()\n",
    "try:\n",
    "    print(\"bin(0j) ->\",bin(0j))\n",
    "except:\n",
    "    print(\"bin(0j)\\n ->\",\"'complex' object cannot be interpreted as an integer\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Standard numeric operations\n",
    "* abs(x): absolute value or magnitude of x\n",
    "* c.conjugate(): conjugate of the complex number c\n",
    "* divmod(x,y): the pair (x // y, x % y)\n",
    "* pow(x,y): x to the power y, same as x ** y\n",
    "* round(x,n): rounds x to a given precision in n decimal digits\n",
    " * default n=0\n",
    " * n can be negative\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [],
   "source": [
    "\n",
    "print(\"\\nabs(-4.5) ->\",abs(-4.5),type(abs(-4.5)))\n",
    "print(\"complex(-4+1j).conjugate() ->\",complex(-4+1j).conjugate())\n",
    "print(\"divmod(10,3) -> \",divmod(10,3))\n",
    "print(\" -> (10//3,10%3) -> \",(10//3,10%3))\n",
    "print(\"pow(10,3) -> \",pow(10,3))\n",
    "print(\" -> (10**3) -> \",(10**3))\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [],
   "source": [
    "print('round(1234.1234,4) ->',round(1234.1234,4))\n",
    "print('round(1234.1234,3) ->',round(1234.1234,3))\n",
    "print('round(1234.1234,2) ->',round(1234.1234,2))\n",
    "print('round(1234.1234,1) ->',round(1234.1234,1))\n",
    "print('round(1234.1234,0) ->',round(1234.1234,0))\n",
    "print('round(1234.1234,-1) ->',round(1234.1234,-1))\n",
    "print('round(1234.1234,-2) ->',round(1234.1234,-2))\n",
    "print('round(1234.1234,-3) ->',round(1234.1234,-3))\n",
    "print('round(1234.1234,-4) ->',round(1234.1234,-4))\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Input data\n",
    "* input(): forward row input to frontends (as a **string**)\n",
    "* eval(): evaluate the expression contained in a **string**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [],
   "source": [
    "name = input(\"name: \")\n",
    "age = input(\"age: \")\n",
    "print(name,\"is\",age,\"years old\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [],
   "source": [
    "thisVal = \"\\nthis expression just prints a string\\n\"\n",
    "expression = input(\"expression (e.g., print(thisVal)): \")\n",
    "eval(expression)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<br><br>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<a id='part2'></a>\n",
    "# PART-2"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Python modules\n",
    "\n",
    "* a module is a file containing Python definitions and statements\n",
    "* the file name is the module name with the suffix .py appended \n",
    "* within a module, the module’s name (as a string) is available as the value of the global variable \\__name\\__\n",
    "* a module can contain executable statements as well as function definitions\n",
    " * statements initialize the module and are executed once\n",
    "* modules can import other modules\n",
    "* dir() builtin function lists the names the user has defined currently  \n",
    " * dir(module) returns which names the module \"module\" defines as a sorted list of strings"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "## Import a module \n",
    "\n",
    "* import module \\[as\\] followed by a module name \n",
    " * imports the module referred as that name\n",
    " * customary but not required to place import statements at the beginning of a module/script\n",
    "* from import keywords \n",
    " * pros: less typing and more control over which items can be accessed \n",
    " * cons: lose context (i.e., you call fun() instead of module.fun()) \n",
    " * the namespace can be cluttered by import \\* (anything) \n",
    " \n",
    " \n",
    "```python \n",
    "import <module-name> [as <alias>] \n",
    "from <module-name> import <submodule>\n",
    "from <module-name> import * \n",
    "```"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [],
   "source": [
    "import math\n",
    "\n",
    "print(\"\\nimport math\",\"# include math\"\\\n",
    "      \"\\n%reset -f\", \"# cleans the environment\")\n",
    "%reset -f\n",
    "\n",
    "print(\"\\nprint(dir())\", \"# math should not be listed\")\n",
    "print(dir())\n",
    "print(\"\\nimport math\", \"\")\n",
    "import math\n",
    "print(\"\\nprint(dir())\", \"# now math is listed\")\n",
    "print(dir())\n",
    "print(\"\\nprint(dir(math))\")\n",
    "print(dir(math))\n",
    "\n",
    "#dir(math) "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [],
   "source": [
    "\n",
    "print(\"math.__name__ ->\",math.__name__)\n",
    "print(\"math.sin(math.pi/2) ->\",math.sin(math.pi/2),\"\\n\")\n",
    "\n",
    "import math as m\n",
    "print(\"import math as m\")\n",
    "print(\"m.__name__ ->\",m.__name__)\n",
    "print(\"m.sin(m.pi/2) ->\",m.sin(m.pi/2),\"\\n\")\n",
    "\n",
    "from math import sin\n",
    "print(\"from math import sin\")\n",
    "print(\"sin(3.14/2) ->\",sin(3.14/2),\"\\n\")\n",
    "\n",
    "from math import * # now I know pi!\n",
    "print(\"from math import * # now I know pi!\")\n",
    "print(\"pi is\",pi)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Common compound data structure literals  \n",
    "\n",
    "* sequence types\n",
    " * tuples: (1,2,3) \n",
    " * lists: \\[1,2,3\\]\n",
    " * range() - explained with loop statements\n",
    "* --\n",
    "* set types\n",
    " * sets: {1,2,3}\n",
    " * frozenset \n",
    "* --\n",
    "* mapping type\n",
    " * dictionaries: {1:'one',2:'two',3:'three'}"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Tuples \n",
    "\n",
    "* tuples store a collection of ordered objects\n",
    "* tuples are meant to store data and are immutable (do not support item assignment)\n",
    " * no add, remove or or replace on the fly\n",
    " * immutability is a feature, not a restriction\n",
    "* tuples can be used to assign simultaneously multiple objects"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [],
   "source": [
    "t = (1,1.,\"str\",(\"another\",\"tuple\"))\n",
    "v1,v2,v3,v4 = t\n",
    "\n",
    "print(\"\\nsimultaneous assignment\")\n",
    "print(\"t = (1,1.,\\\"str\\\",(\\\"another\\\",\\\"tuple\\\"))\",type(t))\n",
    "print(\"\\nsimultaneous assignment\")\n",
    "print(\"v1,v2,v3,v4 = t\")\n",
    "print(\"-->\\nv1 =\",v1,type(v1),\"\\nv2 =\",v2,type(v2),\"\\nv3 =\",v3,type(v3),\"\\nv4 =\",v4,type(v4))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [],
   "source": [
    "print(\"tuples are immutable\")\n",
    "t[0] = 2"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "## named tuples\n",
    "* named tuples are tuples who have an identifiers and attributes\n",
    " * need to import from the module collections"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [],
   "source": [
    "from collections import namedtuple\n",
    "contact = namedtuple(\"Contact\", \"Name Surname Email Phone\")\n",
    "myContact = contact(\"J\",\"R\",\"jr-mail\",\"jr-phone\")\n",
    "\n",
    "name,surname,email,phone=myContact\n",
    "print(myContact,\"is a\",type(myContact))\n",
    "print(name,surname,email,phone)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [],
   "source": [
    "print(\"# assign nametuple needs all fields\")\n",
    "anotherContact = contact('Name')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Lists \n",
    "\n",
    "* a list collects comma separated values between squared brackets\n",
    " * len(list) or list.\\__len\\__() gives the list length \n",
    "* lists are mutable \n",
    "* a list can indexed and sliced (using \":\")\n",
    "* a list can contain any data type\n",
    "* the same list can contain different data types (e.g., lists can nest lists)\n",
    "* support concatenation\n",
    " "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [],
   "source": [
    "squares = [1, 4, 9, 16, 24] # 24 should be 25 \n",
    "print(\"squares ->\", squares) \n",
    "print(\"length of square is\", squares.__len__())\n",
    "print(\"\\n# indexing returns the item\")\n",
    "print(\"squares[0] ->\",squares[0],type(squares[0])) \n",
    "print(\"squares[-1] -> \",squares[-1],type(squares[-1]))   \n",
    "\n",
    "print(\"\\n# slicing returns a list of items\")\n",
    "print(\"squares[2:] ->\",squares[2:],type(squares[2:])) # list of idx 2,3,...,len(list)\n",
    "print(\"squares[:3] ->\",squares[:3],type(squares[:3])) # list of idx 0,1,2\n",
    "print(\"squares[0:1] ->\",squares[0:1],type(squares[0:1]))  \n",
    "print(\"squares[-3:] -> \",squares[-3:],type(squares[-3:])) # list of last three elements\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [],
   "source": [
    "squares = [1, 4, 9, 16, 24] # 24 should be 25 \n",
    "print(\"\\n# new values can be assigned both using indexing and slicing\")\n",
    "print(\"squares ->\",squares)\n",
    "squares[4] = 25 \n",
    "print(\"squares[4] = 25 \")\n",
    "print(\"squares ->\",squares)\n",
    "print(\"squares[0:2] = [-1,-1]\")\n",
    "squares[0:2] = [-1,-1] \n",
    "print(\"squares ->\",squares)\n",
    "\n",
    "print(\"\\n# NB: assignment does not need consistency between lengths of slices\")\n",
    "print(\"squares[0:1] = ['what?',squares[0]]\")\n",
    "squares[0:1] = ['what?',squares[0]]\n",
    "print(\"squares ->\", squares)\n",
    "print(\"squares[0:3] ->\", squares[0:3])\n",
    "print(\"squares[0:3] = [1,4]\")\n",
    "squares[0:3] = [1,4]\n",
    "print(\"squares ->\", squares)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [],
   "source": [
    "squares = [1, 4, 9, 16, 25]\n",
    "other_squares = [36,49,64]\n",
    "print(\"\\n# lists can be concatenated\")\n",
    "print(\"squares -> \",squares)\n",
    "print(\"other_squares -> \",other_squares)\n",
    "print(\"squares+other_squares -> \",squares+other_squares)\n",
    "\n",
    "print(\"\\n# new values can be appended to list\")\n",
    "print(\"squares -> \",squares)\n",
    "print(\"squares.append(36)\")\n",
    "squares.append(36)\n",
    "print(\"squares -> \",squares)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [],
   "source": [
    "print(\"\\n# values can be removed just by slicing\")\n",
    "print(\"squares[5:6] = []\")\n",
    "squares[-3:] = []\n",
    "print(\"squares -> \",squares)\n",
    "\n",
    "print(\"\\n# clear a list replacing with empty list\")\n",
    "print(\"squares[:] = []\")\n",
    "squares[:] = []\n",
    "print(\"squares -> \",squares)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [],
   "source": [
    "print(\"\\n# nested list\")\n",
    "print(\"l = [['a','b'],[1,2]]\")\n",
    "l = [['a','b'],[1,2]]\n",
    "print(\"l[0][1] ->\",l[0][1])\n",
    "print(\"l[1][0] ->\",l[1][0])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "## Shallow copy vs Deep copy\n",
    "\n",
    "\n",
    "* shallow copy: the target is bind to the assigned object (i.e., they have the same reference)\n",
    "* deep copy: the target contains the same values of the assigned object (i.e., they do not have the same reference) \n",
    "\n",
    "* python copies the reference \n",
    " * there is a difference for compound objects (i.e., objects that contain other objects, like nested lists) \n",
    " \n",
    "* module copy contains the implementation for deep copy\n",
    " * copy.copy(x): returns a shallow copy of x\n",
    " * copy.deepcopy(x): returns a deep copy of x"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [],
   "source": [
    "%reset -f\n",
    "import copy\n",
    "\n",
    "l_1 = [1,2,'3']\n",
    "l_2 = copy.copy(l_1)     # shallow copy\n",
    "l_3 = copy.deepcopy(l_1) # deep copy\n",
    "\n",
    "l_2[0] = 'changes!'\n",
    "l_3[0] = 'changes!'\n",
    "\n",
    "print(l_1)\n",
    "print(l_2, \"<- shallow copy\")\n",
    "print(l_3, \"<- deep copy\")\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [],
   "source": [
    "%reset -f\n",
    "import copy\n",
    "a1 = [[1, 2, 3], [4, 5, 6]]\n",
    "a2 = copy.copy(a1) # shallow copy\n",
    "\n",
    "print(\"before assignments\")\n",
    "print(\"a1 =\",a1)\n",
    "print(\"a2 =\",a2)\n",
    "\n",
    "a2[0][0] = 'one'\n",
    "\n",
    "print(\"after assignments\")\n",
    "\n",
    "print(\"a1 =\",a1)\n",
    "print(\"a2 =\",a2)\n",
    "print(\"Note: \")\n",
    "print(\"aX[0][0] ==\",\\\n",
    "      a1[0][0],'==',\\\n",
    "      a2[0][0])\n",
    "print(\"aX[1][1] ==\",\\\n",
    "      a1[1][1],'==',\\\n",
    "      a2[1][1])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [],
   "source": [
    "%reset -f\n",
    "import copy\n",
    "a1 = [[1, 2, 3], [4, 5, 6]]\n",
    "\n",
    "a2 = copy.deepcopy(a1) # deep copy\n",
    "\n",
    "print(\"before assignments\")\n",
    "print(\"a1 =\",a1)\n",
    "print(\"a2 =\",a2)\n",
    "\n",
    "a2[0][0] = 'one'\n",
    "a2[1][1] = 'five'\n",
    "\n",
    "print(\"after assignments\")\n",
    "\n",
    "print(\"a1 =\",a1)\n",
    "print(\"a2 =\",a2)\n",
    "print(\"Note: \")\n",
    "print(\"aX[0][0] ->\",\\\n",
    "      a1[0][0],'!=',\\\n",
    "      a2[0][0])\n",
    "print(\"aX[1][1] ->\",\\\n",
    "      a1[1][1],'!=',\\\n",
    "      a2[1][1])\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "## More on lists\n",
    "\n",
    "* list.append(x): appends x to the end of the list\n",
    "* list.extend(iterable): appends all items from iterable\n",
    " * same of a\\[len(a):\\] = iterable\n",
    "* list.insert(i,x): inserts the value x at a given i-th position \n",
    "* list.remove(x): removes the first item whose value is x\n",
    "* list.pop(\\[i\\]): returns the i-th item and removes it from the list \n",
    "* list.clear(x): clear the list\n",
    " * same of del a\\[:\\]\n",
    "* list.index(x\\[, start\\[, end\\]\\]): returns index of first item whose value is x\n",
    " * if none raises a ValueError \n",
    " * start/end limit the search in a slice\n",
    "* list.count(x): returns the number of times x appears in the list \n",
    "* list.sort(key=None,reverse=False): sort items, see sorted() \n",
    "* list.reverse(): reverse the elements in place  \n",
    "* list.copy(): returns a shallow copy \n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [],
   "source": [
    "%reset -f\n",
    "# append, extend\n",
    "l = [] \n",
    "l.append(1)\n",
    "l.append(2)\n",
    "\n",
    "l2 = [0] \n",
    "l2.extend(l)\n",
    "\n",
    "print('l  ->',l)\n",
    "print('l2 ->',l2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [],
   "source": [
    "%reset -f\n",
    "# insert, remove, pop, clear\n",
    "l = [0,1,2] \n",
    "l.insert(2,1.5)\n",
    "l.insert(4,2.5)\n",
    "l.insert(4,3.5)\n",
    "print('l  ->',l)\n",
    "l.remove(2.5)\n",
    "print('l.remove(2.5)  ->\\n\\t l =',l)\n",
    "el = l.pop()\n",
    "print('el = l.pop() ->\\n\\tl =',l, '\\n\\tel =',el)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [],
   "source": [
    "%reset -f\n",
    "# copy,sort,count,reverse,index\n",
    "l = [0,1,0,1,1,2,2,2,3,1,1,2,2,2,2] \n",
    "lc = l # lc = l.copy() works only in python 3.X\n",
    "lc[0] = -1\n",
    "print('l   -> ',l)\n",
    "print('lc  ->',lc)\n",
    "l.sort()\n",
    "print('\\nl.sort()\\nl ->',l)\n",
    "print('\\nl.count(2) is',l.count(2))\n",
    "l.reverse()\n",
    "print('\\nl.reverse()\\nl ->',l)\n",
    "print('\\nfirst zero at idx',l.index(0))\n",
    "print('l[12:] ->',l[12:])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "##  Set types \n",
    "\n",
    "* curly braces or set() function create sets\n",
    " * set() with no arguments creates a set\n",
    " * \\{\\} with no arguments creates a dictionary - see later\n",
    "* sets are unordered collections with no duplicate elements\n",
    "* sets are mutable objects\n",
    "* in keyword is suitable to check the membership of a value in the list \n",
    "* elements in set must be hashable object\n",
    " * means they have a hash value which never changes during their lifetime \n",
    " * hashability makes objects usable as a dictionary key and a set member\n",
    "* sets themselves are NOT hashable \n",
    " * cannot be used as dictionary keys\n",
    " * sets of sets are not allowed\n",
    "* frozen sets are hashable sets\n",
    " * can be used as dictionary keys\n",
    " * sets of frozen sets are allowed"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "source": [
    "## Set operations\n",
    "\n",
    "* a.difference(b) or a-b: elements in set a that are not in set b\n",
    "* a.union(b) a|b: union of elements in set a and in set b\n",
    "* a.intersection(b) a&b: intersection of elements in set a and in set b\n",
    "* a.symmetric_difference(b) a^b: elements in set a or set b but not in both\n",
    " * equals union-intersection ((a|b)-(a&b))\n",
    "* a.issubset(b) a<=b: test whether every element of a is in b\n",
    "* a.issuperset(b) a>=b: test whether every element of b is in a"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [],
   "source": [
    "set_1 = set([1,2,1,2,3]) \n",
    "set_2 = set([4,5,6,1,7]) \n",
    "\n",
    "print(\"set_1 ->\",\"{1,2,1,2,3} # 1 and 2 are repeated\")\n",
    "print(\"set_2 ->\",\"{4,5,6,1,7} # 1 is in both \")\n",
    "print(\"\\n# use of 'in' keyword\")\n",
    "print(\"3 in set_1 ->\",3 in set_1)\n",
    "print(\"\\n#set difference: elements in one but not in the other\")\n",
    "print(\"set_1-set_2 ->\",set_1-set_2)\n",
    "print(\"set_2-set_1 ->\",set_2-set_1)\n",
    "print(\"\\n#set union and intersection\")\n",
    "print(\"set_1|set_2 ->\",\"set_2|set_1 ->\",set_1|set_2)\n",
    "print(\"set_1&set_2 ->\",\"set_2&set_1 ->\",set_1&set_2)\n",
    "print(\"\\n#set symmetric difference == set difference between set union and set intersection\")\n",
    "print(\"set_1^set_2 ->\",\"set_2^set_1  ->\",set_1^set_2)\n",
    "print(\"(set_1|set_2)-(set_1&set_2) ->\",(set_1|set_2)-(set_1&set_2))\n",
    "print(\"\\n#super/subset test\")\n",
    "print(\"set_1>=set_2 ->\",set_1>=set_2)\n",
    "print(\"set_1<=set_2 ->\",set_1<=set_2)\n",
    "print(\"{1,2,3}<={1,2,3,4,5,6,7} ->\",{1,2,3}<={1,2,3,4,5,6,7})\n",
    "print(\"{1,2,3,4,5,6,7}>={1,2,3} ->\",{1,2,3,4,5,6,7}>={1,2,3})"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [],
   "source": [
    "print(\"# sets cannot contain unhashable types\")\n",
    "set_1 = set([set(['a'])])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [],
   "source": [
    "print(\"\\n# frozen sets are hashable\",\\\n",
    "      \"\\n# -> can be elements of set\",\\\n",
    "      \"\\n# -> can be keys of dictionaries\")\n",
    "set_1 = set([frozenset('a'),frozenset('b')])\n",
    "print(set_1)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Dictionaries \n",
    "\n",
    "* it is mapping type (also called \"associative memories\" or \"associative arrays\")\n",
    "* dict() builds dictionaries from sequences of key-value pairs\n",
    "* unlike sequence types, indexed by numbers, dictionaries are indexed by keys\n",
    " * only hashable types can be keys \n",
    "* dict are unordered sets of key:value pairs \n",
    " * module collections offers a class of ordered dictionaries (i.e., OrderedDict, which remembers the order in which its contents are added)\n",
    " * ordered dictionaries support reversed() \n",
    "* \\[not\\] in keywords check if a key is \\[not\\] in dictionaries \n",
    "* del keyword is needed to delete a key:value pair "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [],
   "source": [
    "%reset -f\n",
    "\n",
    "# using {}\n",
    "address_book={'Anoop':1,'Vasily':2}\n",
    "print(\"\\naddress_book ->\",\\\n",
    "      address_book,\"\\n ->\",\\\n",
    "      type(address_book))\n",
    "print(\"'Jens' not in address_book' ->\",\\\n",
    "         'Jens' not in address_book)\n",
    "\n",
    "\n",
    "# using dict(list_of_tuples)\n",
    "mensa_dishes=dict([('first','pasta'),\\\n",
    "                   ('second','salade'),\\\n",
    "                   ('dessert','apple')])\n",
    "print(\"\\nmensa_dishes ->\",\\\n",
    "      mensa_dishes,\"\\n ->\",\\\n",
    "      type(address_book))\n",
    "print(\"'first' in address_book' ->\",\\\n",
    "         'first' in mensa_dishes)\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": true,
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [],
   "source": [
    "from collections import OrderedDict\n",
    "data = {'c':3,'a':1,'b':2,'d':4}\n",
    "ordered_data = OrderedDict(sorted(data.items())) \n",
    "print('\\n# dictionary vs ordered dictionary')\n",
    "print('\\ndata is', type(data),'\\n ->            ',data)\n",
    "print('\\nordered_data is',  type(ordered_data),'\\n ->',ordered_data)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [],
   "source": [
    "%reset -f\n",
    "address_book={'Anoop':1,'Vasily':2}\n",
    "print(\"address_book =\",address_book)\n",
    "\n",
    "print(\"\\n# delete key\")\n",
    "print(\"'Anoop' in address_book ->\",'Anoop' in address_book)\n",
    "print(\"del address_book['Anoop']\")\n",
    "del address_book['Anoop']\n",
    "print(\"address_book ->\",address_book)\n",
    "print(\"'Anoop' in address_book ->\",'Anoop' in address_book)\n",
    "\n",
    "print(\"\\n# add new key\")\n",
    "print(\"address_book['Jens'] = 3\")\n",
    "address_book['Jens'] = 3\n",
    "print(\"address_book ->\",address_book)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Looping dictionary's elements\n",
    "\n",
    "* it is possible looping dictionary's elements\n",
    " * dict.keys(): retrieves list of keys\n",
    " * dict.values(): retrieves list of values\n",
    " * dict.items(): retrieves list of (key,value) pairs \n",
    "* list() or sorted() built-in functions list values (arbitrary or sorted order)\n",
    "* to sort keys by value\n",
    " * sorted(dict,key=dict.get)\n",
    " * use lambda functions \n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [],
   "source": [
    "%reset -f\n",
    "week = {'mon':1,'tue':2,'wed':3,'thu':4,'fri':5,'sat':6,'sun':7}\n",
    "print('\\nlist(week)\\n->',list(week))\n",
    "print('\\nsorted(week)\\n->', sorted(week))\n",
    "print('\\nsorted(week, key=week.get)\\n->',sorted(week, key=week.get))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Other dictionary's methods\n",
    "\n",
    "* dict.copy(): shallow copy of of dict\n",
    "* dict.clear(): removes all key/value pairs in dict\n",
    "* dict.update(\\[key:value\\]): overwrites key/value pairs from another dict\n",
    "* dict.get(k\\[,x\\]): retreives dict\\[k\\] if k in dict else x  \n",
    "* dict.setdefault(k\\[,x\\]): if k in keys, then get(), otherwise set the key\n",
    "* dict.pop(k\\[,x\\]): get(k\\[,x\\]), then remove key k\n",
    "* dict.popitem(): pop() first element in dict"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "%reset -f\n",
    "week = {'mon':1,'tue':2,'wed':3,'thu':4,'fri':5,'sat':6,'sun':7}\n",
    "\n",
    "print(\"\\n#update value for a key\")\n",
    "print(\"week.get('_8thday',8) ->\",\\\n",
    "      week.get('_8thday',8)) # week['_8thday'] does not exist\n",
    "\n",
    "week.setdefault('_8thday',8)\n",
    "print(\"\\nweek.setdefault('_8thday',8)\") \n",
    "print(\"week\\n ->\",week)\n",
    "\n",
    "print(\"\\n#update value for a given key\")\n",
    "print(\"week['_8thday'] ->\",week['_8thday'])\n",
    "week.update({'_8thday':None})\n",
    "print(\"week.update({'_8thday':None})\\nweek['_8thday'] ->\",week['_8thday'])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [],
   "source": [
    "%reset -f\n",
    "week = {'mon':1,'tue':2,'wed':3,'thu':4,'fri':5,'sat':6,'sun':7}\n",
    "\n",
    "print(\"\\nweek\\n ->\",week)\n",
    "_9thday = week.pop('_9thday','8_days_already_too_much')\n",
    "print(\"_9thday = week.pop('_9thday','8_days_already_too_much')\"+\\\n",
    "      \"\\n_9thday ->\",_9thday)\n",
    "\n",
    "print(\"\\nweek\\n ->\",week)\n",
    "_8thday = week.pop('_8thday','8_days_already_too_much')\n",
    "print(\"_8thday = week.pop('_8thday','8_days_already_too_much')\"+\\\n",
    "      \"\\n_8thday ->\",_8thday)\n",
    "print(\"week\\n ->\",week)\n",
    "\n",
    "print(\"\\nweek\\n ->\",week)\n",
    "a_day = week.popitem()\n",
    "print(\"a_day = week.popitem() ->\",a_day)\n",
    "print(\"week\\n ->\",week)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Control flow tools: \n",
    "* conditional statements\n",
    " * if, elif, else, keywords\n",
    "* loop statements\n",
    " * while, for, break, continue, else keywords\n",
    " * range() function\n",
    "* reminder statement\n",
    " * pass keyword\n",
    "* context manager\n",
    " * with, as keywords\n",
    " * open() function\n",
    "* handling exceptions statement\n",
    " * try, except, finally keywords\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Conditional statements\n",
    "* conditional statements\n",
    " * if, elif, else, keywords\n",
    "``` python\n",
    "if <condition>:\n",
    "        <body_1>\n",
    "elif <another_condition>:\n",
    "        <body_2>\n",
    "else:\n",
    "        <body_default>    \n",
    "```    \n",
    " * in, not keywords\n",
    "``` python\n",
    "# is there an item equal to value?\n",
    "if <value> in <group_of_items> \n",
    "# none items are equal to value?\n",
    "if <value> not in <group_of_items> \n",
    "```"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "if True: print(\"if can be inline\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [],
   "source": [
    "if 5>4:\n",
    "    print(\"5 is bigger than 4\")\n",
    "if 4<5:\n",
    "    print(\"because 4 is smaller than 5\")\n",
    "else:\n",
    "    print(\"I would be confused otherwise\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [],
   "source": [
    "if 0:\n",
    "    print(\"this should not be printed\")\n",
    "elif None:    \n",
    "    print(\"this should not be printed\")\n",
    "elif (-1.+2j): \n",
    "    print(\"0 and None means False\\n any other value is True \")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [],
   "source": [
    "%reset -f\n",
    "t = (3,4,5)       # tuple\n",
    "l = [3,4,5]       # list\n",
    "s = {3,4,5}       # set\n",
    "d = {3:1,4:2,5:3} # dictionary\n",
    "v = 1\n",
    "print(\"'in'/'not in' work on any iterable\")\n",
    "if v not in t:\n",
    "    print(\"if v not in t:     -> True if none is equal to v\")\n",
    "if v not in l:\n",
    "    print(\"if v not in l:     -> True if none is equal to v\")   \n",
    "if v not in s:\n",
    "    print(\"if v not in s:     -> True if none is equal to v\")    \n",
    "if v not in d:\n",
    "    print(\"if v not in d:     -> True if none is equal to v\")      "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "\n",
    "## Loops\n",
    "\n",
    "* loop statements\n",
    " * while, for, break, continue, else keywords\n",
    "* range(\\[start,\\]stop\\[,step\\]) is very handy in loops\n",
    " * returns an object that produces a sequence of integers from start (inclusive, default 0) to stop (exclusive) by step (default 1)\n",
    " * start, stop and step must be integers\n",
    "* pass statement is a reminder and can be used anywhere\n",
    "\n",
    "* --\n",
    "``` python\n",
    "for <var> in <set_of_values>: \n",
    "    <body>\n",
    "    if <condition>:\n",
    "        continue\n",
    "    <something_that_runs_if_condition_not_True>        \n",
    "```\n",
    "* --\n",
    "``` python    \n",
    "while <true_condition>:\n",
    "    <body>\n",
    "    if <another_condition>:\n",
    "        break    \n",
    "``` \n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [],
   "source": [
    "print(\"range(2) is\",type(range(2)),\"\\n\")\n",
    "print(\"\\nfor loop example\")\n",
    "for i in range(2):\n",
    "    print(i)\n",
    "    \n",
    "print(\"\\nsame behavior using while loop\")\n",
    "i = 0    \n",
    "while i in range(2): \n",
    "    print(i)\n",
    "    i+=1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [],
   "source": [
    "for i in range(5):\n",
    "    if i is 0: \n",
    "        continue # 0 is neither odd nor even\n",
    "    if i%2 is 0:\n",
    "        print(i,\"is even\")\n",
    "        continue # an even number is not odd\n",
    "    print(i,\"is odd\") # if i is even, this expression is not run"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## The pass statement\n",
    "\n",
    "* does nothing \n",
    "* helps avoiding unexpected EOF\n",
    "* useful to include conditions that have not been coded yet\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [],
   "source": [
    "if True:\n",
    "    pass\n",
    "print('no syntax error')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": true,
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [],
   "source": [
    "# use range with start,stop and step\n",
    "for i in range(-5,7,2):\n",
    "    print(i,end=\",\")# -5,-3,-1,1,3,5,\n",
    "print()    \n",
    "for i in range(-5,7,2): \n",
    "    if i is 3:\n",
    "        print(i,\"== 3\")\n",
    "    elif i == -1:\n",
    "        print(i,\"== -1\")\n",
    "    else:\n",
    "        pass # not decided yet \n",
    "             # pass is handy even if it does nothing"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Iterables\n",
    "\n",
    "* objects capable of returning its members one at a time\n",
    "* e.g., list, str, tuple, dict are all iterables\n",
    "\n",
    "## Looping techniques on iterables\n",
    "\n",
    "* reversed(iterable): returnes a reversed iterator (iterates from last to first)\n",
    "* zip(\\*iterables): returns an iterator of tuples that aggregates elements from each iterable\n",
    " * if \\*iterables have different size, zip aggregates up to the shortest length\n",
    "* enumerate(iterable): returns an iterator of tuples that retreives both position index and item  \n",
    "* sorted(iterable\\[,key\\]\\[,reverse\\]): returns the \\[reverse\\] sorted sequence as a key for sort comparison\n",
    "* dictionary items() method: retreives key and value zipped\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [],
   "source": [
    "%reset -f\n",
    "\n",
    "myList1 = ['1st_el','2nd_el','3rd_el'] \n",
    "myList2 = [111,222,333]\n",
    "\n",
    "# myList1\n",
    "for i in myList1:\n",
    "    print(i,end=\", \")\n",
    "print()    \n",
    "\n",
    "# reversed myList1\n",
    "for i in reversed(myList1):\n",
    "    print(i,end=\", \")  \n",
    "print('\\n')        \n",
    "\n",
    "# zipped lists (with same size)\n",
    "for i,j in zip(myList1,myList2):\n",
    "    print(\"[\",i,\",\",j,\"]\", end=\", \")\n",
    "print()\n",
    "\n",
    "# zipped lists (with different size)\n",
    "myList2.pop()\n",
    "for i,j in zip(myList1,myList2):\n",
    "    print(\"[\",i,\",\",j,\"]\", end=\", \")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [],
   "source": [
    "%reset -f\n",
    "\n",
    "myList1 = ['1st_el','2nd_el','3rd_el'] \n",
    "for i,j in enumerate(myList1):\n",
    "    print(\"[\",i,\",\",j,\"]\", end=\", \")   \n",
    "print('\\n')   \n",
    "\n",
    "unorderedList = ['2nd_el','1st_el','3rd_el'] \n",
    "print(unorderedList)\n",
    "for i in sorted(myList1):\n",
    "    print(i,end=\", \")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Context manager\n",
    "\n",
    "* with \\[as\\] creates a context manager\n",
    " \n",
    "``` python    \n",
    "with <expression> [as <variable>]:\n",
    "    <with-body-block>    \n",
    "```\n",
    "* the expression (e.g., open()) must be an object that defines \\__enter\\__  and \\__exit\\__ methods \n",
    " * open() opens a file and returns a stream (read/write)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [],
   "source": [
    "with open('README.md', 'r') as f:\n",
    "     print(f.readline()) # read first line of the file README.md "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Handling exceptions\n",
    "\n",
    "* handling exceptions using try, except, finally keywords\n",
    " * finally is executed no matters what\n",
    " * finally is good to release external resources\n",
    "* common exceptions are ZeroDivisionError, NameError, TypeError, ValueError, SyntaxError\n",
    "* exceptions of type AssertionError: assert keyword\n",
    "* exceptions of type Exception:  raise keyword\n",
    " \n",
    "``` python    \n",
    "try: \n",
    "    <try-body-block>    \n",
    "except <Exception-name> as <alias>: \n",
    "    <except-body-block>        \n",
    "```"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [],
   "source": [
    "print(\"# let's catch some common exceptions\\n\")\n",
    "to_execute = ['1/0',\\\n",
    "              '4+unknown_var',\\\n",
    "              '\"2\"+2',\\\n",
    "              \"int('s')\",\n",
    "              \"print 1\"]\n",
    "for i in to_execute:\n",
    "    try:\n",
    "        print(i)\n",
    "        eval(i)\n",
    "        print(\"I am not going to be printed\")\n",
    "    except (ZeroDivisionError,NameError,TypeError,ValueError) as err:\n",
    "        print(err.__class__,\":\",err)\n",
    "    except SyntaxError as err: \n",
    "        print(\"'print 1' was not caught because it causes SyntaxError\")\n",
    "        print(err.__class__,\":\",err)\n",
    "    finally: # should be at the end of try statement\n",
    "             # useful to make sure all resources are released\n",
    "             # even if an exception occurs\n",
    "             # even if no exception was caught\n",
    "        print(\"\\t---last but not least, finally is executed---\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [],
   "source": [
    "x = -1\n",
    "try:\n",
    "    assert x>=0, 'x is negative'\n",
    "except AssertionError as err: \n",
    "    print(err)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [],
   "source": [
    "try: \n",
    "    raise Exception(1,[2],{'3':3}) # an exception can be raised\n",
    "                                   # with any argument\n",
    "except Exception as err:\n",
    "    print(type(err))\n",
    "    print(err.args)\n",
    "    print(err)      # print its arguments\n",
    "    a,b,c = err.args    \n",
    "    print(a,b,c)\n",
    "    try: \n",
    "        a,b,c = err\n",
    "    except TypeError as err: \n",
    "        print(err)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Function definition in python\n",
    "\n",
    "* def \\[return\\] keywords\n",
    " * non-void functions should be called for the returned value \n",
    " * void functions should be called to obtain <i>side effects</i> (e.g., print() function)\n",
    "* parentheses follow function's name and contain comma separated parameters \n",
    " * mandatory even if no parameter\n",
    "* return keywords embeds multiple outputs in a tuple\n",
    "* functions can embed docstrings for documentation \n",
    "* scope of a function\n",
    "\n",
    "``` python\n",
    "def <function_name>(<parameter_list>):\n",
    "    '''docstring'''\n",
    "    <body>\n",
    "    return <result>\n",
    "```  "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [],
   "source": [
    "print_returns = print()\n",
    "print(\"print() returns \",print_returns)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [],
   "source": [
    "def f0():\n",
    "    def g0():\n",
    "        return \"g0 is scoped\"\n",
    "    return g0()\n",
    "\n",
    "try:\n",
    "    g0()\n",
    "except NameError as err:\n",
    "    print(err)\n",
    "print(\"\\n\",f0(),sep=\"\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [],
   "source": [
    "def EUR_to_USD(eur):\n",
    "    '''\n",
    "    calculate conversion from EUR to USD\n",
    "    '''\n",
    "    usd_for_1eur = 1.17\n",
    "    return eur*usd_for_1eur\n",
    "\n",
    "print(\"10 EUR means\",EUR_to_USD(10),\"USD\")\n",
    "print(\"\\n---------------\\n\")\n",
    "help(EUR_to_USD)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [],
   "source": [
    "def EUR_to_many(eur):\n",
    "    '''\n",
    "    calculate conversion from EUR to different currencies\n",
    "    '''\n",
    "    usd_for_1eur = 1.17\n",
    "    yen_for_1eur = 0.0075\n",
    "    gbp_for_1eur = 1.13 \n",
    "    \n",
    "    return (eur*usd_for_1eur,\\\n",
    "            eur*yen_for_1eur,\\\n",
    "            eur*gbp_for_1eur)\n",
    "\n",
    "currencies = EUR_to_many(10) # tuple\n",
    "USD,YEN,GBP = currencies     # unpack tuple\n",
    "print(\"10 EUR means\",USD,\"USD\\n\\t\",\\\n",
    "                \"or\",YEN,\"YEN\\n\\t\",\\\n",
    "                \"or\",GBP,\"GBP\")\n",
    "print(\"EUR_to_many returns\",type(currencies))\n",
    "\n",
    "print(\"\\n---------------\\n\")\n",
    "help(EUR_to_many) # docstring"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Keyword and positional arguments\n",
    "\n",
    "* default argument values can be passed, even unordered, using keyword arguments (named arguments)\n",
    "* keyword arguments are passed as a dictionary {key:value,...}\n",
    "* not keyword arguments are called positional arguments\n",
    "* positional arguments should be starred if after a keyword argument\n",
    " * \\*expression must evaluate an iterable "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [],
   "source": [
    "def foo(par1=None,par2=None):\n",
    "    res = None\n",
    "    if par1 is 1:\n",
    "        res = par1\n",
    "    elif par2 is 2:\n",
    "        res = par2\n",
    "    if par1 is 1 and par2 is 2:\n",
    "        res = \"what a surprise!\"\n",
    "    return res\n",
    "\n",
    "# order of positional args is important\n",
    "print(\"foo(par1=1) ->\",foo(par1=1),\\\n",
    "      \"which equals foo(1) ->\",foo(1))\n",
    "print(\"foo(par2=2) ->\",foo(par2=2),\\\n",
    "      \"which is not foo(2) ->\",foo(2))\n",
    "# order of keyword args is not important\n",
    "print(\"foo(par1=1,par2=2) ->\",\\\n",
    "      foo(par1=1,par2=2))  \n",
    "print(\"foo(par2=2,par1=1) ->\",\\\n",
    "      foo(par2=2,par1=1))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "subslide"
    }
   },
   "outputs": [],
   "source": [
    "def foo(*positional, **keywords):\n",
    "    print(\"Positional:\", positional, end='\\t')\n",
    "    print(\"Keywords:\", keywords)\n",
    "    \n",
    "foo('1st', '2nd', '3rd')\n",
    "foo(par1='1st', par2='2nd', par3='3rd')\n",
    "foo('1st', par2='2nd', par3='3rd')\n",
    "\n",
    "# #Uncomment the following lines in python 3.x\n",
    "# foo(par1='1st_key',*'1st_pos', par2='2nd_key')\n",
    "# foo(par1='1st_key',*['1st_pos'], par2='2nd_key',*['2st_pos','3rd_pos'])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## Lambda expressions\n",
    "\n",
    "* anonymous functions can be created with the lambda keyword "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [],
   "source": [
    "def weighted_value(value):\n",
    "    return lambda weight,bias: value*weight+bias # Please note: returns a lambda function\n",
    "\n",
    "f1 = weighted_value(1)      \n",
    "f10 = weighted_value(10)\n",
    "print(f1(1.5,-1))           # weight=1.5, bias=-1:             (1.5*1)-1 == 0.5\n",
    "print(f1(weight=0,bias=-1)) # supports keyword arguments       (0*1)-1 == -1    \n",
    "print(f10(0,-2))            # (0*10)-2 == -2\n",
    "print(f10(1.5,100))         # (1.5*10)+100 == 115"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [],
   "source": [
    "pairs = [(1, 'one'), (2, 'two'), (3, 'three'), (4, 'four')]\n",
    "pairs.sort(key=lambda pair: pair[0])\n",
    "print(pairs)\n",
    "pairs.sort(key=lambda pair: pair[1])\n",
    "print(pairs)"
   ]
  }
 ],
 "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.16"
  },
  "latex_metadata": {
   "affiliation": "PGI-1",
   "author": "Anoop Chandran",
   "title": "python-crash-course"
  },
  "toc": {
   "base_numbering": 1,
   "nav_menu": {},
   "number_sections": false,
   "sideBar": true,
   "skip_h1_title": false,
   "title_cell": "Table of Contents",
   "title_sidebar": "Contents",
   "toc_cell": false,
   "toc_position": {
    "height": "calc(100% - 180px)",
    "left": "10px",
    "top": "150px",
    "width": "330px"
   },
   "toc_section_display": true,
   "toc_window_display": false
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}