python_tutorial.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Python tutorial\n",
    "\n",
    "## Installation\n",
    "\n",
    "For the Python examples, we use Anaconda Python 2.7 or 3.6. We expect that any other Python distribution should work equally well. \n",
    "\n",
    "If you opt for the Anaconda distribution, you can download the installer, which is available for Windows, Mac OSX, and Linux platforms, from [this link](https://www.anaconda.com).\n",
    "\n",
    "Following the [installation instructions](https://docs.anaconda.com/anaconda/), python should be ready for usage within few minutes. We advice to create different environments for easily switching between different versions of python. The documnentation can be found [at this URL](https://docs.conda.io/projects/conda/en/latest/user-guide/tasks/manage-environments.html)\n",
    "\n",
    "## Documentation\n",
    "\n",
    "There are many books and resources online to learn how to program in Python. The list below is just a starting point and does not want to be complete: \n",
    "\n",
    "* the official online documentation, as well as links to many other useful guides and books, can be found [at this url](http://www.python.org/doc)\n",
    "* several platforms for e-learning propose courses to learn Python. Some of these courses can be found at [Codeacademy](https://www.codecademy.com/catalog/language/python), [Datacamp](https://learn.datacamp.com), and [Coursera](https://www.coursera.org)\n",
    "* Google also offers a [python class](https://developers.google.com/edu/python/?csw=1) online;\n",
    "* [A Byte of Python](https://python.swaroopch.com/) is a free, online book for beginners.\n",
    "\n",
    "\n",
    "## Run python\n",
    "\n",
    "Python can be run in several ways:\n",
    "You can run Python programs in several ways:\n",
    "\n",
    "* for using the interactive interpreter, launch ```python``` in a shell. At the Python prompt, type your commands. Quit the interpreter with Ctrl+D or type ```exit()``` when finished.\n",
    "* create your own script with an extension ```.py``` and run it in a shell by typing python ```scriptname.py```\n",
    "* use an Interactive Development Environment (IDE). These are software which include an editor for coding and capabilities for executing the code. There are several options available (e.g. spyder, Rodeo, etc.)\n",
    "*  use a web-based interactive development environment like [jupyter notebook](http://jupyter-notebook-beginner-guide.readthedocs.io/en/latest/what_is_jupyter.html), or [jupyter lab](https://jupyter.org/) (if you use Python 3.x).\n",
    "\n",
    "\n",
    "## Your first python code\n",
    "\n",
    "Try running the code:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {
    "jupyter": {
     "outputs_hidden": false
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Hello World!\n"
     ]
    }
   ],
   "source": [
    "# your first python code -- this is a comment\n",
    "print (\"Hello World!\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Congratulations! You have run your first python code!"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Variables\n",
    "\n",
    "Variables are names pointing to values or objects. Setting them in python is extremely easy, and you don't need to declare them before:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {
    "collapsed": true,
    "jupyter": {
     "outputs_hidden": true
    }
   },
   "outputs": [],
   "source": [
    "int_var = 4\n",
    "float_var = 7.89778\n",
    "boolean_var = False\n",
    "string_var = \"My name is Python\"\n",
    "cmplx_var = 3+4j\n",
    "#obj_var=some_class_name(par1,par2) # this won't work yet, because the class some_class_name does not exist yet"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Strings\n",
    "\n",
    "String constants can be defined in three ways:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {
    "jupyter": {
     "outputs_hidden": false
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "my name is Python \n",
      "and this is  a multiline  string.\n"
     ]
    }
   ],
   "source": [
    "single_quotes = 'my name is Python'\n",
    "double_quotes = \"my name is Python\"\n",
    "triple_quotes = \"\"\"my name is Python \n",
    "and this is  a multiline  string.\"\"\" #This can contain line breaks!\n",
    "\n",
    "print (triple_quotes)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Note that you can combine single and double quotes when you want to define strings which contain quotes themselves:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {
    "jupyter": {
     "outputs_hidden": false
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "my name is \"Python\"\n",
      "don't\n"
     ]
    }
   ],
   "source": [
    "double_quotes1 = 'my name is \"Python\"'\n",
    "double_quotes2 = \"don't\"\n",
    "\n",
    "print (double_quotes1)\n",
    "print (double_quotes2)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Otherwise you have to use backslashes:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {
    "jupyter": {
     "outputs_hidden": false
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "don't\n"
     ]
    }
   ],
   "source": [
    "double_quotes3 = 'don\\'t'\n",
    "print (double_quotes3)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Strings can me sliced: "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {
    "jupyter": {
     "outputs_hidden": false
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Massimo Meneghetti\n",
      "Massimo\n",
      "Meneghetti\n",
      "imo\n"
     ]
    }
   ],
   "source": [
    "my_name='Massimo Meneghetti'\n",
    "name = my_name[:7]\n",
    "surname = my_name[8:]\n",
    "a_piece_of_my_name=my_name[4:7]\n",
    "\n",
    "print (my_name)\n",
    "print (name)\n",
    "print (surname)\n",
    "print (a_piece_of_my_name)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "You can make many operations with strings. These are objects and have many methods. Check out [this url](https://docs.python.org/2/library/stdtypes.html#string-methods) to learn more.\n",
    "\n",
    "Some examples:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {
    "jupyter": {
     "outputs_hidden": false
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Massimo Meneghetti\n"
     ]
    }
   ],
   "source": [
    "# string concatenation:\n",
    "back_to_my_full_name=name+\" \"+surname\n",
    "\n",
    "print (back_to_my_full_name)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "which can be achieved also by typing"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {
    "jupyter": {
     "outputs_hidden": false
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Massimo Meneghetti\n"
     ]
    }
   ],
   "source": [
    "back_to_my_full_name = '%s %s' % (name, surname)\n",
    "print (back_to_my_full_name)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {
    "jupyter": {
     "outputs_hidden": false
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "MASSIMO MENEGHETTI\n"
     ]
    }
   ],
   "source": [
    "# Convert to uppercase:\n",
    "\n",
    "my_name_uppercase=back_to_my_full_name.upper()\n",
    "\n",
    "print (my_name_uppercase)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The built-in function ```str``` converts numbers to strings:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {
    "jupyter": {
     "outputs_hidden": false
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2\n",
      "2.0\n"
     ]
    }
   ],
   "source": [
    "my_int=2\n",
    "my_float=2.0\n",
    "str_int=str(my_int)\n",
    "str_float=str(my_float)\n",
    "\n",
    "print (str_int)\n",
    "print (str_float)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Another way to include numbers in strings:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {
    "jupyter": {
     "outputs_hidden": false
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "My integer is 2\n",
      "My float is 2.000000.\n",
      "My float is 2.000 (with only one decimal)\n"
     ]
    }
   ],
   "source": [
    "my_string1 = 'My integer is %d' % my_int \n",
    "my_string2 = 'My float is %f.' % my_float\n",
    "my_string3 = 'My float is %3.3f (with only one decimal)' % my_float\n",
    "\n",
    "print (my_string1)\n",
    "print (my_string2)\n",
    "print (my_string3)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "With several variables, we need to use parentheses:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {
    "jupyter": {
     "outputs_hidden": false
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2 + 67 = 69\n",
      "2 + 67.30 =  69.3\n"
     ]
    }
   ],
   "source": [
    "a = 2\n",
    "b = 67\n",
    "my_string4 = '%d + %d = %d' % (a, b, a+b)\n",
    "print (my_string4)\n",
    "\n",
    "a = 2\n",
    "b = 67.3\n",
    "my_string5 = '%d + %5.2f = %5.1f' % (a, b, a+b)\n",
    "print (my_string5)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Possible type conversion are:"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "|conversion   |meaning   |\n",
    "|---|---|\n",
    "| d  | signed integer decimal  |\n",
    "| i  | signed integer decimal |\n",
    "| u  | signed integer (obsolete) |\n",
    "| o  | unsigned octal |\n",
    "| x  | unsigned hexadecimal (lower case) |\n",
    "| X  | unsigned hexadecimal (upper case) |\n",
    "| e | floating point exponential (lower case) |\n",
    "| E | floating point exponential (upper case) |\n",
    "| f | floating point decimal |\n",
    "| F | floating point decimal |\n",
    "| g | Same as \"e\" if exponent is greater than -4 or less than precision, \"f\" otherwise |\n",
    "| G | Same as \"E\" if exponent is greater than -4 or less than precision, \"F\" otherwise |\n",
    "| c | Single character (accepts integer or single character string) |\n",
    "| r | String (converts any python object using repr()) |\n",
    "| s | String (converts any python object using str()) |\n",
    "| % | No argument is converted, results in a \"%\" character in the result |"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Examples:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "  1.24e+02\n",
      "  1.24E+02\n",
      "      55\n",
      "     055\n",
      "   00055\n",
      "   15\n",
      " 0015\n",
      " 0015\n",
      "Only one percentage sign: % \n"
     ]
    }
   ],
   "source": [
    "print(\"%10.2e\"% (123.56239))\n",
    "print(\"%10.2E\"% (123.56239))\n",
    "print(\"%8o\"% (45))\n",
    "print(\"%8.3o\"% (45))\n",
    "print(\"%8.5o\"% (45))\n",
    "print(\"%5x\"% (21))\n",
    "print(\"%5.4x\"% (21))\n",
    "print(\"%5.4X\"% (21))\n",
    "print(\"Only one percentage sign: %% \" % ())"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Not only you can convert numbers to string, but you can do the reverse operation:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {
    "jupyter": {
     "outputs_hidden": false
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "23 23\n",
      "<class 'str'> <class 'int'>\n"
     ]
    }
   ],
   "source": [
    "s = '23'\n",
    "i = int(s)\n",
    "\n",
    "print (s, i)\n",
    "print (type(s), type(i))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {
    "jupyter": {
     "outputs_hidden": false
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "23 23.0\n",
      "<class 'str'> <class 'float'>\n"
     ]
    }
   ],
   "source": [
    "s = '23'\n",
    "i = float(s)\n",
    "\n",
    "print (s, i)\n",
    "print (type(s), type(i))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Lists\n",
    "\n",
    "A list is a dynamic array of any objects.\n",
    "It is declared with square brackets:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {
    "collapsed": true,
    "jupyter": {
     "outputs_hidden": true
    }
   },
   "outputs": [],
   "source": [
    "a_list = [1, 2, 3, 'abc', 'def']"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Lists may contain lists:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {
    "collapsed": true,
    "jupyter": {
     "outputs_hidden": true
    }
   },
   "outputs": [],
   "source": [
    "another_list = [a_list, 'abc', a_list, [1, 2, 3]]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Note that ```a_list``` in this case is a pointer.\n",
    "Access a specific element by index (index starts at zero):"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {
    "collapsed": true,
    "jupyter": {
     "outputs_hidden": true
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "3 2\n",
      "1\n"
     ]
    }
   ],
   "source": [
    "elem = a_list[2]\n",
    "elem2 = another_list[3][1]\n",
    "elem3= another_list[0][0]\n",
    "\n",
    "print (elem,elem2)\n",
    "print (elem3)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "It's easy to test if an item is in the list:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {
    "jupyter": {
     "outputs_hidden": false
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "bingo!\n"
     ]
    }
   ],
   "source": [
    "if 'abc' in a_list:\n",
    "    print ('bingo!')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Extracting a part of a list is called slicing:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {
    "jupyter": {
     "outputs_hidden": false
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[3, 'abc']\n"
     ]
    }
   ],
   "source": [
    "list2 = a_list[2:4] # returns a list with items 2 and 3 (not 4)\n",
    "print (list2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Other list operations like appending:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {
    "jupyter": {
     "outputs_hidden": false
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1, 2, 3, 'abc', 'def', 'ghi']\n"
     ]
    }
   ],
   "source": [
    "a_list.append('ghi')\n",
    "print (a_list)\n",
    "a_list.remove('abc')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {
    "jupyter": {
     "outputs_hidden": false
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1, 2, 3, 'def', 'ghi']\n"
     ]
    }
   ],
   "source": [
    "print(a_list)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Additional methods for lists can be found [here](https://docs.python.org/2/tutorial/datastructures.html#more-on-lists)."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Tuples\n",
    "\n",
    "A tuple is similar to a list but it is a fixed-size, immutable array. This means that once a tuple has been created, its elements may not be changed, removed, appended or inserted.\n",
    "\n",
    "It is declared using parentheses and comma-separated values:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {
    "collapsed": true,
    "jupyter": {
     "outputs_hidden": true
    }
   },
   "outputs": [],
   "source": [
    "a_tuple = (1, 2, 3, 'abc', 'def')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "but parentheses are optional:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {
    "collapsed": true,
    "jupyter": {
     "outputs_hidden": true
    }
   },
   "outputs": [],
   "source": [
    "another_tuple = 1, 2, 3, 'abc', 'def'"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Tip: a tuple containing only one item must be declared using a comma, otherwise it is not considered as a tuple:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {
    "collapsed": true,
    "jupyter": {
     "outputs_hidden": true
    }
   },
   "outputs": [],
   "source": [
    "a_single_item_tuple = ('one value',) "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Tuples are not constant lists -- this is a common misconception. Lists are intended to be homogeneous sequences, while tuples are hetereogeneous data structures.\n",
    "\n",
    "In some sense, tuples may be regarded as simplified structures, in which position has semantic value [e.g. (name,surname,age,height,weight)] and not an order. For this reason they are immutable, contrary to lists."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Dictionaries\n",
    "A Dictionary (or \"dict\") is a way to store data just like a tuples, but instead of using only numbers to get the data, you can use almost anything. This lets you treat a dict like it's a database for storing and organizing data.\n",
    "\n",
    "Dictionaries are initialized using curl brackets:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {
    "collapsed": true,
    "jupyter": {
     "outputs_hidden": true
    }
   },
   "outputs": [],
   "source": [
    "person = {'name': 'Massimo', 'surname': 'Meneghetti', 'age': 39, 'height': 1.74}"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "You can access the elements of the dictionary by using the entry keys:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {
    "jupyter": {
     "outputs_hidden": false
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'Massimo'"
      ]
     },
     "execution_count": 26,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "person['name']"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The keys can also be numbers:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {
    "collapsed": true,
    "jupyter": {
     "outputs_hidden": true
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'new data'"
      ]
     },
     "execution_count": 27,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "person = {'name': 'Massimo', 'surname': 'Meneghetti', 'age': 39, 'height': 1.74, 1: 'new data'}\n",
    "person[1]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Blocks and indentation\n",
    "\n",
    "Blocks of code are delimited using indentation, either spaces or tabs at the beginning of lines. This will become clearer in the next sections, when loops will be introduced.\n",
    "\n",
    "Tip: NEVER mix tabs and spaces in a script, as this could generate bugs that are very difficult to be found."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## IF/ELIF/ELSE\n",
    "\n",
    "Here is an example of how to implement an IF/ELIF/ELSE loop:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {
    "jupyter": {
     "outputs_hidden": false
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The value of a is:\n",
      "a=3\n",
      "a!=\"test\"\n",
      "condition 1\n"
     ]
    }
   ],
   "source": [
    "a=3\n",
    "b=4\n",
    "\n",
    "if a == 3:\n",
    "    print ('The value of a is:')\n",
    "    print ('a=3')\n",
    "    \n",
    "if a == 'test':\n",
    "    print ('The value of a is:')\n",
    "    print ('a=\"test\"')\n",
    "    test_mode = True\n",
    "else:\n",
    "    print ('a!=\"test\"')\n",
    "    test_mode = False\n",
    "    \n",
    "if a == 1 or a == 2:\n",
    "    pass # do nothing\n",
    "elif a == 3 and b > 1:\n",
    "    print (\"condition 1\")\n",
    "elif a==3 and not b>1:\n",
    "    print ('condition 2')\n",
    "else:\n",
    "    pass"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## WHILE loops"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {
    "jupyter": {
     "outputs_hidden": false
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1\n",
      "2\n",
      "3\n",
      "4\n",
      "5\n",
      "6\n",
      "7\n",
      "8\n",
      "9\n"
     ]
    }
   ],
   "source": [
    "a=1\n",
    "while a<10:\n",
    "    print (a)\n",
    "    a += 1"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## FOR Loops"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {
    "jupyter": {
     "outputs_hidden": false
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0\n",
      "1\n",
      "2\n",
      "3\n",
      "4\n",
      "5\n",
      "6\n",
      "7\n",
      "8\n",
      "9\n",
      "2\n",
      "4\n",
      "8\n",
      "16\n",
      "32\n"
     ]
    }
   ],
   "source": [
    "for a in range(10):\n",
    "    print (a)\n",
    "\n",
    "my_list = [2, 4, 8, 16, 32]\n",
    "for a in my_list:\n",
    "    print (a)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Functions\n",
    "Functions can be defined in python as follows:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {
    "collapsed": true,
    "jupyter": {
     "outputs_hidden": true
    }
   },
   "outputs": [],
   "source": [
    "def compute_sum(arg1,arg2):\n",
    "    # implement function to calculate the sum of two numbers\n",
    "    res=arg1+arg2\n",
    "    return(res)  "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The function can be called by typing the function name. If the function returns a value or object, this is assigned to a variable as follows:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {
    "jupyter": {
     "outputs_hidden": false
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "10.0"
      ]
     },
     "execution_count": 32,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "summa=compute_sum(3.0,7.0)\n",
    "summa"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Otherwise, the function can just be called without setting it equal to any variable."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {
    "jupyter": {
     "outputs_hidden": false
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "3\n",
      "10\n"
     ]
    }
   ],
   "source": [
    "c=3\n",
    "print (c)\n",
    "\n",
    "def change_global_c(val):\n",
    "    global c\n",
    "    c=val\n",
    "\n",
    "change_global_c(10)\n",
    "\n",
    "print (c)\n",
    "    "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Classes\n",
    "\n",
    "Classes are a way to group a set of functions inside a container. These can be accessed using the . operator. The main purpose of classes is to define objects of a certain type and the corresponding methods. For example, we may want to define a class called 'square', containing the methods to compute the square properties, such as the perimeter and the area. The object is initialized by means of a \"constructor'':"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {
    "collapsed": true,
    "jupyter": {
     "outputs_hidden": true
    }
   },
   "outputs": [],
   "source": [
    "class square:\n",
    "    \n",
    "    #the constructor:\n",
    "    def __init__(self,side):\n",
    "        self.side=side\n",
    "        \n",
    "    #area of the square:\n",
    "    def area(self):\n",
    "        return(self.side*self.side)\n",
    "        \n",
    "    #perimeter of the square:\n",
    "    def perimeter(self):\n",
    "        return(4.0*self.side)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can then use the class to define a square object:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {
    "jupyter": {
     "outputs_hidden": false
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "9.0\n",
      "12.0\n"
     ]
    }
   ],
   "source": [
    "s=square(3.0) # a square with side length 3\n",
    "print (s.area())\n",
    "print (s.perimeter())"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "As in other languages (e.g. C++), python supports inheritance. A class can be used as an argument for another class. In this case the new class will inherit the methods of the parent class. For example:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {
    "jupyter": {
     "outputs_hidden": false
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "this is a square\n",
      "this is a circle\n"
     ]
    }
   ],
   "source": [
    "class geometrical_figure(object):\n",
    "    \n",
    "    def __init__(self,name):\n",
    "        self.name=name\n",
    "        \n",
    "    def getName(self):\n",
    "        print ('this is a %s' % self.name)\n",
    "    \n",
    "class square(geometrical_figure):\n",
    "    \n",
    "    #the constructor:\n",
    "    def __init__(self,side):\n",
    "        geometrical_figure.__init__(self,'square')\n",
    "        self.side=side\n",
    "        \n",
    "    #area of the square:\n",
    "    def area(self):\n",
    "        return(self.side*self.side)\n",
    "        \n",
    "    #perimeter of the square:\n",
    "    def perimeter(self):\n",
    "        return(4.0*self.side)\n",
    "    \n",
    "class circle(geometrical_figure):\n",
    "    \n",
    "    #the constructor:\n",
    "    def __init__(self,radius):\n",
    "        geometrical_figure.__init__(self,'circle')\n",
    "        self.radius=radius\n",
    "        \n",
    "    #area of the square:\n",
    "    def area(self):\n",
    "        return(3.141592653*self.radius**2)\n",
    "        \n",
    "    #perimeter of the square:\n",
    "    def perimeter(self):\n",
    "        return(2.0*self.radius*3.141592653)\n",
    "    \n",
    "    \n",
    "s=square(3.0)\n",
    "c=circle(3.0)\n",
    "s.getName()\n",
    "c.getName()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In the example above, ```square``` and ```circle``` are two examples of ```geometricalFigure```. They have some specialized methods to compute the area and the perimeter, but both can access the method ```getName```, which belongs to ```geometricalFigure```, because they have inherited it from the parent class."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Modules\n",
    "\n",
    "A module is a file containing Python definitions and statements (constants, functions, classes, etc). The file name is the module name with the suffix .py appended.\n",
    "\n",
    "Modules can be imported in another script by using the ```import``` statement:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true,
    "jupyter": {
     "outputs_hidden": true
    }
   },
   "outputs": [],
   "source": [
    "import modulename # this won't work because the module modulename.py does not exist"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The functions and statements contained in the module can be accessed using the . operator.\n",
    "\n",
    "Modules can import other modules. It is customary but not required to place all import statements at the beginning of a module (or script, for that matter). \n",
    "\n",
    "There is a variant of the import statement that imports names from a module directly into the importing module’s symbol table. For example:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true,
    "jupyter": {
     "outputs_hidden": true
    }
   },
   "outputs": [],
   "source": [
    "from modulename import something # this won't work because the module modulename.py does not exist"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Importing packages\n",
    "Packages can be added to your python distribution by using either the  ``` pip``` or ```easy\\_install``` utilities. Anaconda has its own utility for installing a (limited) set of supported packages, called ```conda```. To learn more, check out [this documentation](https://packaging.python.org/installing/).\n",
    "\n",
    "Packages can be used by importing modules and classes in the code as discussed above.\n",
    "\n",
    "Some packages that we will use a lot:\n",
    "\n",
    "* numpy\n",
    "* scipy\n",
    "* matplotlib\n",
    "* astropy\n",
    "\n",
    "Other packages will be introduced in the examples.\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Numpy and scipy\n",
    "\n",
    "```numpy``` and ```scipy``` are widely used packages containing high level functions for scientific computing. In particular:\n",
    "\n",
    "* ```numpy``` defines the numerical array and matrix types and basic operations on them. The ```numpy``` documentation can be found [here](http://www.numpy.org). A nice tutorial is instead available at [this url](https://www.python-course.eu/numpy.php). The numerical array object of ```numpy``` is a grid of values, all of the same type, and is indexed by a tuple of nonnegative integers. The number of dimensions is the rank of the array; the shape of an array is a tuple of integers giving the size of the array along each dimension. Compared to python lists, numpy array are more efficient in terms of memory and speed. Most importantly they have built-in functionalities, specifically for linear algebra operations, Fourier transform, random number capabilities. ```numpy``` also includes tools for integrating C/C++ and Fortran codes. The following example shows how more efficiently a ```numpy``` array performes compared to a python list:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0.026996135711669922 0.0008528232574462891\n",
      "Numpy is in this example 31.655018171652223 faster!\n"
     ]
    }
   ],
   "source": [
    "import time\n",
    "import numpy as np\n",
    "\n",
    "size_of_vec = 100000\n",
    "\n",
    "def pure_python_version():\n",
    "    t1 = time.time()\n",
    "    X = range(size_of_vec)\n",
    "    Y = range(size_of_vec)\n",
    "    Z = [X[i] + Y[i] for i in range(len(X)) ]\n",
    "    #for i in range(len(X)):\n",
    "    #    Z.append(X[i]+Y[i])\n",
    "    return time.time() - t1\n",
    "\n",
    "def numpy_version():\n",
    "    t1 = time.time()\n",
    "    X = np.arange(size_of_vec)\n",
    "    Y = np.arange(size_of_vec)\n",
    "    Z = X + Y\n",
    "    return time.time() - t1\n",
    "\n",
    "\n",
    "t1 = pure_python_version()\n",
    "t2 = numpy_version()\n",
    "print(t1, t2)\n",
    "print(\"Numpy is in this example \" + str(t1/t2) + \" faster!\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "A list of the methods implemented in numpy for linear algebra operations can be found at [this url](https://docs.scipy.org/doc/numpy-1.15.1/reference/routines.linalg.html)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Dot product:\n",
      "[[4 1]\n",
      " [2 2]]\n",
      "which is different from:\n",
      "[[4 0]\n",
      " [0 2]]\n",
      "but equal to:\n",
      "[[4 1]\n",
      " [2 2]]\n"
     ]
    }
   ],
   "source": [
    "# dot product between matrices\n",
    "a = [[1, 0], [0, 1]]\n",
    "b = [[4, 1], [2, 2]]\n",
    "print ('Dot product:')\n",
    "print (np.dot(a, b))\n",
    "print ('which is different from:')\n",
    "print (np.array(a)*np.array(b))\n",
    "print ('but equal to:')\n",
    "print (np.matmul(a,b))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "* The ```scipy``` package contains various toolboxes dedicated to common issues in scientific computing. Its different submodules correspond to different applications, such as interpolation, integration, optimization, image processing, statistics, special functions, etc. Some documentation/tutorial can be found [here](https://scipy-lectures.org/intro/scipy.html)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "metadata": {},
   "outputs": [],
   "source": [
    "measured_time = np.linspace(0, 1, 10)\n",
    "noise = (np.random.random(10)*2 - 1) * 1e-1\n",
    "measures = np.sin(2 * np.pi * measured_time) + noise\n",
    "\n",
    "from scipy.interpolate import interp1d\n",
    "linear_interp = interp1d(measured_time, measures)\n",
    "\n",
    "interpolation_time = np.linspace(0, 1, 50)\n",
    "linear_results = linear_interp(interpolation_time)\n",
    "\n",
    "cubic_interp = interp1d(measured_time, measures, kind='cubic')\n",
    "cubic_results = cubic_interp(interpolation_time)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Matplotlib\n",
    "\n",
    "```matplotlib``` is a Python 2D plotting library. In the course of these lectures, we will widely use it for visualizing results and examples. It can be used for producing scatter-plots, plotting curves, images, and surfaces. A gallery of examples as well as the library documentation can be found [here](https://matplotlib.org).\n",
    "\n",
    "Here is a simple example to visualize the results of the previous calculation:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Text(0, 0.5, 'signal')"
      ]
     },
     "execution_count": 42,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 1000x1000 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# Provides a MATLAB-like plotting framework.\n",
    "import matplotlib.pyplot as plt\n",
    "# only needed in jupyter notebooks\n",
    "%matplotlib inline\n",
    "fig,ax=plt.subplots(1,1,figsize=(10,10))\n",
    "ax.plot(measured_time,measures,'o')\n",
    "ax.plot(interpolation_time,linear_results,'-')\n",
    "ax.plot(interpolation_time,cubic_results,'--')\n",
    "ax.set_xlabel('time')\n",
    "ax.set_ylabel('signal')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Astropy\n",
    "The [Astropy Project](http://www.astropy.org) is a community effort to develop a common core package for Astronomy in Python. The ```astropy``` package contains modules for doing the most common operations in astronomical data-analysis, including:\n",
    "\n",
    "* input/output operations\n",
    "* photometry\n",
    "* time, coordinate transformations\n",
    "* convolutions, filtering\n",
    "* statistics\n",
    "* much more...\n",
    "Several other packages used by astronomers depend on astropy. See a list [here](http://www.astropy.org/affiliated/index.html)"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3.8.15 ('tonale')",
   "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.8.15"
  },
  "vscode": {
   "interpreter": {
    "hash": "80049abdef48e04a217b57438db502bd877ddf91a719032c10ed240a9419ff14"
   }
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}