JNotebooks/tutorial01-python.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Introduction to Python\n",
    "\n",
    "Python is a powerful programming language commonly used in image processing and machine learning applications. Most of the deep learning (hot-topic on machine learning) libraries have a Python interface. This tutorial is meant to give you an introduction to the python programming language.\n",
    "\n",
    "The goals of this tutorial is introducing the basics of Python (we use Python 3), such as:\n",
    "- Python data types,\n",
    "- Flow control commands (if, while, for,...),\n",
    "- Declaring functions in Python.\n",
    "\n",
    "## Python variable types\n",
    "\n",
    "Python is a high level, object oriented, and interpreted programming language. It has the following characteristics:\n",
    "\n",
    "- No need to pre-declare variables and their types;\n",
    "- Blocks, such as \"if\", \"for\" are delimited by code identation and\n",
    "  not delimiters like \"{}\" \"BEGIN...END\";\n",
    "- It has high level data types: strings, lists, tuples, dictionaries, classes...\n",
    "\n",
    "Python is a modern language suitable both for scientific and non-scientific applications. For scientific applications that involve numerical computations, it has a very powerful package for processing multidimensional arrays called *NumPy*, which we will learn more in our next tutorial.\n",
    "  \n",
    "In its native form, Python supports the following variable types:\n",
    "\n",
    "| Variable type | Description                                 | Syntax example    |\n",
    "|---------------|---------------------------------------------|----------------------|\n",
    "| *int*         | Integer variable                            | a = 103458            |\n",
    "| *float*       | Floating point variable                     | pi = 3.14159265 |\n",
    "| *bool*        | *boolean* variable - *True* or *False*      | a = False            |\n",
    "| *complex*     | Complex number variable                     | c = 2+3j              |\n",
    "| *str*         | UNICODE characters variable                 | a = \"Example\"  |\n",
    "| *list*        | Heterogeneous list (any type of elements)   | my_list = [4,'me',1] |\n",
    "| *tuple*       | Heterogeneous tuple (values can't change)   | my_tuple = (1,'I',2) |\n",
    "| *dict*        | Associative set of values                   | dic = {'me':1,'you':2} |        \n",
    "\n",
    "\n",
    "## Numerical Types\n",
    "\n",
    "- Declaring integer, boolean, floating point and complex variables and doing some simple operations, like:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<class 'int'>\n",
      "<class 'float'>\n",
      "<class 'complex'>\n",
      "<class 'bool'>\n",
      "6.140000000000001\n",
      "(9.42+12.56j)\n",
      "(1+1.3333333333333333j)\n"
     ]
    }
   ],
   "source": [
    "a = 3\n",
    "print(type(a))\n",
    "b = 3.14\n",
    "print(type(b))\n",
    "c = 3 + 4j\n",
    "print(type(c))\n",
    "d = False\n",
    "print(type(d))\n",
    "print(a + b)  \n",
    "print(b * c) \n",
    "print(c / a)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Notice that when performing operations with variables of different types, Python converts the variables to a suitable type according to the following hierarchy: complex > floating point > integer. Integer division will result in a floating point number.\n",
    "\n",
    "## Sequential types\n",
    "\n",
    "Python has three main sequential types: lists, tuples and strings.\n",
    "\n",
    "### Strings\n",
    "\n",
    "Strings can be declared both using single quotation (') and double quotation (\"). Strings are immutable vectors of characters. The size of a string can be computed using the command *len*."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Type: <class 'str'> \n",
      "Name1: Faraday \n",
      "Length: 7\n"
     ]
    }
   ],
   "source": [
    "name1 = 'Faraday' # Single quoation\n",
    "name2 = \"Maxwell\" #Double quotation\n",
    "print('Type:', type(name1), '\\nName1:', name1, '\\nLength:', len(name1))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "It is possible to access a character in a specific position of a string by indexing its position. The first element of the string has the index 0. It is also possible to use negative indexes. For instance, -1 corresponds to the last element of the string."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "First character of  Faraday  is:  F\n",
      "The last character of  Faraday  is:  y\n",
      "String multiplication replicates the string: FaradayFaradayFaraday\n"
     ]
    }
   ],
   "source": [
    "print('First character of ', name1, ' is: ', name1[0])\n",
    "print('The last character of ', name1, ' is: ', name1[-1])\n",
    "print('String multiplication replicates the string:', 3 * name1) "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Lists\n",
    "\n",
    "A list is a sequence of elements that may be of different types. The elements can be indexed, altered, and operations can be performed on them. Lists are defined by [ ] and the elements are separated by commas."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "list1 type= <class 'list'>\n",
      "list2 type= <class 'list'>\n",
      "list2= [(3+4j), 'Faraday']\n",
      "list3= [1, 1.1, 'one', (3+4j), 'Faraday']\n",
      "List multiplication replicates the list: [1, 1.1, 'one', (3+4j), 'Faraday', 1, 1.1, 'one', (3+4j), 'Faraday']\n"
     ]
    }
   ],
   "source": [
    "list1 = [1, 1.1, 'one'] \n",
    "list2 = [3+4j, list1] # Other lists can be elements of a list!\n",
    "print('list1 type=', type(list1))\n",
    "print('list2 type=', type(list2))\n",
    "list2[1] = 'Faraday' # list elements can be altered\n",
    "print('list2=', list2)\n",
    "list3 = list1 + list2 # Concatenates 2 lists\n",
    "print('list3=',list3)\n",
    "print('List multiplication replicates the list:',2*list3)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Tuples\n",
    "\n",
    "A tuple is similar to a list, but its values can not be altered. A tuple is defined by () and its elements are delimited by commas.\n",
    "\n",
    "**Note:** Tuples are very important, because many functions of the NumPy library receive tuples as input arguments."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "tuple1= ()\n",
      "tuple2= ('Gauss',)\n",
      "tuple3= (1.1, 'Ohm', (3+4j))\n",
      "tuple4= (3, 'aqui', True)\n",
      "tuple3 type= <class 'tuple'>\n"
     ]
    },
    {
     "ename": "TypeError",
     "evalue": "'type' object does not support item assignment",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mTypeError\u001b[0m                                 Traceback (most recent call last)",
      "\u001b[0;32m<ipython-input-5-c6436733c4a3>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m\u001b[0m\n\u001b[1;32m      9\u001b[0m \u001b[0mprint\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m'tuple4='\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mtuple4\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     10\u001b[0m \u001b[0mprint\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m'tuple3 type='\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mtype\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mtuple3\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 11\u001b[0;31m \u001b[0mtuple\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;36m0\u001b[0m\u001b[0;34m]\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;34m\"reset\"\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[0;31mTypeError\u001b[0m: 'type' object does not support item assignment"
     ]
    }
   ],
   "source": [
    "#Declaring tuples\n",
    "tuple1 = () # empty tuple\n",
    "tuple2 = ('Gauss',)  # One element tuple. Pay attention at the comma!\n",
    "tuple3 = (1.1, 'Ohm', 3+4j)\n",
    "tuple4 = 3, 'aqui', True\n",
    "print('tuple1=',tuple1)\n",
    "print('tuple2=', tuple2)\n",
    "print('tuple3=',tuple3)\n",
    "print('tuple4=', tuple4)\n",
    "print('tuple3 type=', type(tuple3))\n",
    "tuple[0] = \"reset\""
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Slicing Sequential Types\n",
    "\n",
    "Slicing is an operation that selects a subset of the elements of a sequential type variable. See the examples below:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "s= abcdefg\n",
      "s[0:2] = ab\n",
      "s[2:5] = cde\n"
     ]
    }
   ],
   "source": [
    "s = 'abcdefg'\n",
    "print('s=',s)\n",
    "print('s[0:2] =', s[0:2])  # Characters between [0,1]\n",
    "print('s[2:5] =', s[2:5])  # Characters between [2,4]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "When the first element is the initial element or the last element of the slice is the last element of the sequential variable, they can be ommited from the slicing syntax:  "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "s= abcdefg\n",
      "s[:2] = ab\n",
      "s[2:] = cdefg\n",
      "s[-2:] = fg\n"
     ]
    }
   ],
   "source": [
    "s = 'abcdefg'\n",
    "print('s=',s)\n",
    "print('s[:2] =', s[:2])  # Characters between [0,1]\n",
    "print('s[2:] =', s[2:])  # Characters between [2,last element]\n",
    "print('s[-2:] =', s[-2:]) # Last 2 elements"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Observe that the initial index is included in the slice, while the last element is not included. Therefore, s[:i] + s[i:] is equal to s.\n",
    "\n",
    "Slicing allows a third parameter, which is the step. \n",
    "\n",
    "If you are familiar with the C programming language, the 3 slicing parameters are similar to the  *for* command in C:\n",
    "\n",
    "\n",
    "|Command *for*                            |  *slicing*            |\n",
    "|-----------------------------------------|-----------------------|\n",
    "|`for (i=begin; i < end; i += step) a[i]` | `a[begin:end:step]` |\n",
    "\n",
    "\n",
    "\n",
    "See some slicing examples below:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "s= abcdefg\n",
      "s[2:5]= cde\n",
      "s[0:5:2]= ace\n",
      "s[::2]= aceg\n",
      "s[:5]= abcde\n",
      "s[3:]= defg\n",
      "s[::-1]= gfedcba\n"
     ]
    }
   ],
   "source": [
    "s = 'abcdefg'\n",
    "print('s=',s)\n",
    "print('s[2:5]=',  s[2:5])\n",
    "print('s[0:5:2]=',s[0:5:2])\n",
    "print('s[::2]=',  s[::2])\n",
    "print('s[:5]=',   s[:5])\n",
    "print('s[3:]=',   s[3:])\n",
    "print('s[::-1]=', s[::-1])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The slicing concept is essential to become a good Python/NumPy programmer. It is applicable to strings, lists, tuples and NumPy arrays.\n",
    "    \n",
    "### Unpacking Sequential Types\n",
    "\n",
    "Sequential types can be unpacked using assignment operation. See the example below:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "s1: a\n",
      "s2: b\n",
      "s3: c\n",
      "list1= [1, 2, 3]\n",
      "list1= (8, 9, True)\n",
      "a= 9\n"
     ]
    }
   ],
   "source": [
    "s = \"abc\"\n",
    "s1,s2,s3 = s\n",
    "print('s1:',s1)\n",
    "print('s2:',s2)\n",
    "print('s3:',s3)\n",
    "list1 = [1,2,3]\n",
    "t = 8,9,True\n",
    "print('list1=',list1)\n",
    "list1 = t\n",
    "print('list1=',list1)\n",
    "(_,a,_) = t\n",
    "print('a=',a)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Formatting a string for printing\n",
    "\n",
    "A string can be formatted using a similar syntax as the one used by the sprintf function from C/C++. %d stands for integers, %f for floating point variables, and %s for strings. See if you can understand the example below:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Formatting strings. Integer:5, float:3.200000, string:hello\n"
     ]
    }
   ],
   "source": [
    "s = 'Formatting strings. Integer:%d, float:%f, string:%s' % (5, 3.2, 'hello')\n",
    "print(s)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Other data types\n",
    "\n",
    "Other data types not so commonly used in our applications are the sets and dictionaries.\n",
    "   \n",
    "\n",
    "### Dictionary\n",
    "\n",
    "Dicitionaries can be seen as associative lists. Instead of associating its elements to numerical indexes, each of its elements is associated to a unique key-word.\n",
    "\n",
    "See below how to declare a dictionary, access its elements and listing its keys."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<class 'dict'>\n",
      "{'blue': 135, 'green': 12.34, 'red': 'ocean'}\n",
      "135\n",
      "dict_keys(['blue', 'green', 'red'])\n",
      "dict_keys(['green', 'red'])\n"
     ]
    }
   ],
   "source": [
    "dict1 = {'blue':135,'green':12.34,'red':'ocean'} # dictionary declaration\n",
    "print(type(dict1))\n",
    "print(dict1) \n",
    "print(dict1['blue'])\n",
    "print(dict1.keys()) # Dictionary keys\n",
    "del dict1['blue'] # Deleting a dictionary element\n",
    "print(dict1.keys()) # Dicitionary keys after deleting 'blue'"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Sets\n",
    "\n",
    "Sets are collections of elements with no clear ordering. Sets elements are always unique.\n",
    "\n",
    "See below how to declare a set variable and perform some simple operations."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'banana', 'apple', 'orange', 'pear'}\n",
      "<class 'set'>\n",
      "{'blue', 'green', 'banana', 'red', 'apple', 'orange', 'pear'}\n"
     ]
    }
   ],
   "source": [
    "list1 = ['apple', 'orange', 'apple', 'pear', 'orange', 'banana'] \n",
    "list2 = ['red', 'blue', 'green','red','red']\n",
    "set1 = set(list1) # Defining a set\n",
    "set2 = set(list2)\n",
    "print(set1) # Repeated elements are counted only once\n",
    "print(type(set1))\n",
    "print(set1 | set2) # Union of the 2 sets"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## The importance of Indentation on the Python Language\n",
    "\n",
    "Unlike other programming languages, Python does not use *begin* and *end*, or  {, } to delimit its code blocks (if, for, while, etc.). Python uses code indentation to determine, which commands are encompassed within a block. Therefore, indentation is fundamental in Python."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "x is smaller than zero!\n",
      "This sentence is writen regardless of the value of x\n",
      "x is smaller than zero!\n"
     ]
    }
   ],
   "source": [
    "#Example1: The last print command writes to the output \n",
    "#independently of the value of x\n",
    "x = -1\n",
    "if x<0:\n",
    "   print('x is smaller than zero!')\n",
    "elif x==0:\n",
    "   print('x is equal to zero')\n",
    "else:\n",
    "   print ('x is greater than zero!')\n",
    "print ('This sentence is writen regardless of the value of x')\n",
    "\n",
    "#Example2: The last 2 print commands are within the last \"else\" block,\n",
    "# therefore they are only executed if x is gretaer than zero\n",
    "if x<0:\n",
    "   print('x is smaller than zero!')\n",
    "elif x==0:\n",
    "   print('x is euqal to zero')\n",
    "else:\n",
    "   print('x is greater than zero!')\n",
    "   print('This sentence is writen only if x > 0')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Loops\n",
    "\n",
    "\n",
    "## for\n",
    "\n",
    "Looping through a list of strings:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Safari\n",
      "Firefox\n",
      "Google Chrome\n",
      "Opera\n",
      "IE\n"
     ]
    }
   ],
   "source": [
    "browsers = [\"Safari\", \"Firefox\", \"Google Chrome\", \"Opera\", \"IE\"]\n",
    "for browser in browsers:\n",
    "    print(browser)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Looping through a list of integers:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "151\n"
     ]
    }
   ],
   "source": [
    "numbers = [1,10,20,30,40,50]\n",
    "sum = 0\n",
    "for number in numbers:\n",
    "    sum = sum + number\n",
    "print(sum)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Looping through the characters of a string:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "c\n",
      "o\n",
      "m\n",
      "p\n",
      "u\n",
      "t\n",
      "e\n",
      "r\n"
     ]
    }
   ],
   "source": [
    "word = \"computer\"\n",
    "for letter in word:\n",
    "    print(letter)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Looping through a sequence of numbers with the help of the xrange iterator:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "21\n",
      "19\n",
      "17\n",
      "15\n",
      "13\n",
      "11\n",
      "9\n",
      "7\n",
      "5\n",
      "3\n",
      "1\n"
     ]
    }
   ],
   "source": [
    "for a in range(21,-1,-2):\n",
    "    print(a)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## while\n",
    "\n",
    "The loop executes until a stop condition is reached."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Safari\n",
      "Firefox\n",
      "Google Chrome\n"
     ]
    }
   ],
   "source": [
    "browsers = [\"Safari\", \"Firefox\", \"Google Chrome\", \"Opera\", \"IE\"]\n",
    "i = 0\n",
    "while browsers[i]!= \"Opera\": # 2 conditions checked in order to continue\n",
    "    print(browsers[i])\n",
    "    i = i + 1\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Nested Loops\n",
    "\n",
    "It is possible to nest loops in python. Notice that in order to do that identation is really important!"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1 * 1 = 1\n",
      "1 * 2 = 2\n",
      "Inside the first for loop, but out of the second\n",
      "2 * 1 = 2\n",
      "2 * 2 = 4\n",
      "Inside the first for loop, but out of the second\n",
      "3 * 1 = 3\n",
      "3 * 2 = 6\n",
      "Inside the first for loop, but out of the second\n"
     ]
    }
   ],
   "source": [
    "for x in range(1, 4):\n",
    "    for y in range(1, 3):\n",
    "        print('%d * %d = %d' % (x, y, x*y))\n",
    "    print('Inside the first for loop, but out of the second')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Functions\n",
    "\n",
    "## Function Declaration Syntax\n",
    "\n",
    "Python functions are declared using the keyword *def* followed by the function name, the list of input parameters between parenthesis, and an ending colon (:).\n",
    "\n",
    "Look at the example below where a function is defined to perform the + operation between two elements and return the result."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [],
   "source": [
    "def sum1( x, y):\n",
    "    s = x + y\n",
    "    return s"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Here is how to call the function:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "70\n"
     ]
    }
   ],
   "source": [
    "r = sum1(50, 20)\n",
    "print(r)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Function Parameters\n",
    "\n",
    "There are 2 kinds of function parameters: positional and key-word. The positional parameters are identified by their position in the sequence of parameters. The key-word parameters are identified by their name. Key-word parameters come with a default value, so you do not have to always pass it as an input when calling the function. See the example below with two 2 positional and 1 key-word parameters."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [],
   "source": [
    "def sum2( x, y, squared=False):\n",
    "    if squared:\n",
    "        s = (x + y)**2\n",
    "    else:\n",
    "        s = (x + y)\n",
    "    return s"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "See examples of the function calling:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "sum2(2, 3): 5\n",
      "sum2(2, 3, False): 5\n",
      "sum2(2, 3, True): 25\n",
      "sum2(2, 3, squared= True): 25\n"
     ]
    }
   ],
   "source": [
    "print('sum2(2, 3):', sum2(2, 3)) \n",
    "print('sum2(2, 3, False):', sum2(2, 3, False))\n",
    "print('sum2(2, 3, True):', sum2(2, 3, True)) \n",
    "print('sum2(2, 3, squared= True):', sum2(2, 3, squared= True)) "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Where to learn Python?\n",
    "\n",
    "The best way to become a Python expert is by studying its documentation and examples. See some interesting links:\n",
    "\n",
    "- [Python Language Reference](http://docs.python.org/2/reference/)\n",
    "- [Python Standard Library](http://docs.python.org/2/library/index.html)\n"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.6.9"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 1
}