Lecture 3. Object programming.ipynb

{
  "nbformat": 4,
  "nbformat_minor": 0,
  "metadata": {
    "colab": {
      "name": "Lec3_DataSci.ipynb",
      "provenance": [],
      "collapsed_sections": [
        "ayZVM95FK8Sg"
      ],
      "authorship_tag": "ABX9TyNsL+fbBYixj0wsSA6qF6gK"
    },
    "kernelspec": {
      "name": "python3",
      "display_name": "Python 3"
    },
    "language_info": {
      "name": "python"
    }
  },
  "cells": [
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "bYaCbRBuF6bY"
      },
      "source": [
        "**Lecture 3: Object programming**"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "Xi3TxnAYITKx"
      },
      "source": [
        "## **Exceptions**\n",
        "\n",
        "When catching the expression with the try statement, it is possible to deal with the error, and to decide how the program should continue\n",
        "\n",
        "```\n",
        "try:\n",
        "  <Block of code>\n",
        "except:\n",
        "  <Block of code to execute if anything went wrong in the block above>\n",
        "```\n",
        "\n"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 197
        },
        "id": "ZPgscMbVF0O1",
        "outputId": "74e613c8-b06e-4d7c-d847-94f6f209c35b"
      },
      "source": [
        "#The following gives an error - zeroDivisionError: division by zero\n",
        "x = 0\n",
        "y = 1/x\n"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "error",
          "ename": "ZeroDivisionError",
          "evalue": "ignored",
          "traceback": [
            "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
            "\u001b[0;31mZeroDivisionError\u001b[0m                         Traceback (most recent call last)",
            "\u001b[0;32m<ipython-input-1-1d8c3ad48b8e>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m()\u001b[0m\n\u001b[1;32m      1\u001b[0m \u001b[0;31m#The following gives an error\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m      2\u001b[0m \u001b[0mx\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;36m0\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m----> 3\u001b[0;31m \u001b[0my\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;36m1\u001b[0m\u001b[0;34m/\u001b[0m\u001b[0mx\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
            "\u001b[0;31mZeroDivisionError\u001b[0m: division by zero"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "HA4PLlTFGwme",
        "outputId": "6cb29e4f-c4d1-4b1f-d745-37754b5c976e"
      },
      "source": [
        "#BUT we can overcome it by running:\n",
        "x = 0\n",
        "try:\n",
        "  y = 1/x\n",
        "except:  #this part is executed in case of error\n",
        "  print('ERROR: DIVISION BY ZERO')\n",
        "\n",
        "#another way\n",
        "x = 0\n",
        "try:\n",
        "  y = 1/x\n",
        "except: \n",
        "  y = 10"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "ERROR: DIVISION BY ZERO\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "plXcJhiZKZGu"
      },
      "source": [
        "It is possible:\n",
        "- to choose the kind of exception to capture\n",
        "- to handle different exceptions in different ways\n",
        "\n",
        "```\n",
        "try:\n",
        "    <Block of code>\n",
        "except Exception1:\n",
        "    <Block of code to execute if Exception1 occurred>\n",
        "else:\n",
        "    <Block executed if no exception occurred>\n",
        "finally:\n",
        "    <Block executed in any case>\n",
        "```"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "HA1sBx8XHtCo",
        "outputId": "d4ae9927-3de3-46e6-bc42-610c6e2989ac"
      },
      "source": [
        "#x = 0\n",
        "try:\n",
        "  y = 1/x\n",
        "except ZeroDivisionError:\n",
        "  print('ERROR: divizion by zero')\n",
        "except NameError:\n",
        "  print('ERROR: x is not defined')"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "ERROR: x is not defined\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "7vJOtCwcLDiL"
      },
      "source": [
        "### Raising exceptions\n",
        "\n",
        "sometimes it is useful to raise a particular exception in your\n",
        "own code (so that another part of the program can handle it)\n",
        "\n",
        "Exceptions are raised by the raise function:\n",
        "```\n",
        "def convert_C_to_F(t):\n",
        "  if (not isinstance(t, float)) and (not isinstance(t, int)):\n",
        "    raise TypeError('temperature is a number')\n",
        "    if t < 0:\n",
        "      raise ValueError('temperature in C is >= 0')\n",
        "      return (t - 273.15) * 9/5 + 32\n",
        "```"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 197
        },
        "id": "WORT08CiICkm",
        "outputId": "d2f9b1a4-155c-4783-be3b-7efad71d3dbf"
      },
      "source": [
        "x = 0\n",
        "if x == 0:\n",
        "  raise ZeroDivisionError #WHY DOESN'T WORK?\n"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "error",
          "ename": "ZeroDivisionError",
          "evalue": "ignored",
          "traceback": [
            "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
            "\u001b[0;31mZeroDivisionError\u001b[0m                         Traceback (most recent call last)",
            "\u001b[0;32m<ipython-input-6-e4d320a230d2>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m()\u001b[0m\n\u001b[1;32m      1\u001b[0m \u001b[0mx\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;36m0\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m      2\u001b[0m \u001b[0;32mif\u001b[0m \u001b[0mx\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\u001b[0m\u001b[0m\n\u001b[0;32m----> 3\u001b[0;31m   \u001b[0;32mraise\u001b[0m \u001b[0mZeroDivisionError\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
            "\u001b[0;31mZeroDivisionError\u001b[0m: "
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "9hIFW49yIiwO"
      },
      "source": [
        "# **Import**\n",
        "\n",
        "- `import` MODULE \n",
        "- `import` MODULE `as` NEW_MODULE_NAME\n",
        "- `from` MODULE `import` OBJECT\n",
        "- `from` MODULE `import *`"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "rktuRsCRImO2",
        "outputId": "575f10a2-96d3-4cfb-fe11-55cce0aedd22"
      },
      "source": [
        "import math\n",
        "x = 10\n",
        "y = math.log(x)\n",
        "print(y)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "2.302585092994046\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "vOe6tr_PJObP",
        "outputId": "514ab106-6a96-4f88-92ce-49fafb256efe"
      },
      "source": [
        "import numpy as np\n",
        "x = 10\n",
        "y = np.log(x)\n",
        "print(y)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "2.302585092994046\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "JwIDxf0SJtjP",
        "outputId": "6f61a221-0a05-4492-ca24-af46b84437f6"
      },
      "source": [
        "from math import log\n",
        "x = 10\n",
        "y = log(x)\n",
        "print(y)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "2.302585092994046\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "VDW1K7NjJ1le"
      },
      "source": [
        "from math import *"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "MIQuIPaWKEM9"
      },
      "source": [
        "**Useful libraries:**\n",
        "\n",
        "- *os, sys, shutils*: tools for interacting with the operative system\n",
        "\n",
        "- *math, cmath*: some basic mathematical tools\n",
        "\n",
        "- *pickle*: writing/reading objects to disk\n",
        "\n",
        "- *collections*: common data structures\n",
        "\n",
        "- *time, datetime*: tools to handle time-related tasks\n",
        "\n",
        "- *csv*: reading/writing csv files"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "ayZVM95FK8Sg"
      },
      "source": [
        "# **Package and Environment Managing**\n",
        "\n",
        "ANACONDA: A conda environment is a set of system variables and libraries\n",
        "\n",
        "-`conda update conda` \n",
        "- `conda env list `list all the environments available\n",
        "- `conda create --name NAME [--clone NAME] [python=VERSION]`\n",
        "-- with clone it is possible to inheritfrom a previous environment\n",
        "- `conda activate NAME` activate the environment\n",
        "- `conda deactivate close` the current environment\n",
        "- `conda env remove --name NAME `delete the environment"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "sxw0TAltL094"
      },
      "source": [
        "- `conda list`\n",
        "- `conda list WHAT `List installed packages with name containing\n",
        "WHAT\n",
        "- `conda search WHAT` \n",
        "- `conda install PACKAGE ` \n",
        "- `conda install PACKAGE=VERSION ` \n",
        "- `conda uninstall PACKAGE` remove it (and everything depending\n",
        "on it)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "65gIpjg6MGCv"
      },
      "source": [
        "- `conda config --show` show the entire configuration\n",
        "- `conda config --get` channels which channels are used for\n",
        "getting packages\n",
        "- `conda config --add` channels NAME add a new channel\n",
        "-- the last added it he highest priority one\n",
        "- `conda install -c CHANNEL1 [-c CHANNEL2, ...] PACKAGE`\n",
        "-- install the package using channel1 as highest priority"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "RjlJJUEwMt8q"
      },
      "source": [
        "# **Object programming**\n",
        "\n",
        "***Imperative programming***: Solve the task with a sequence of commands\n",
        "\n",
        "***Object programming***: Solve the task using objects and corresponding operations\n",
        "\n",
        "- `class` - an abstract model for a group of entities (*persons, vehicles, random number generators, etc*) -> **the data type**\n",
        "- `object` - an entity of a particular `class` -> **the variable**\n",
        "- `attribute` - a characteristic of the `object`(*random number generator: mean, std, etc*)\n",
        "- `method` - function offered to the outside world (*random number generator: generate new sample*)\n",
        "- ***inheritance*** - relationship among `classes` (*generators of random numbers with gaussian/uniform/... distributions are a special kind of random number generators*)"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "OMLswRE1NapX",
        "outputId": "5dfea8a4-5342-4eb6-c66b-fb0cb7ff3524"
      },
      "source": [
        "#The class can be named as any python object \n",
        "# __init__  the constructor of the object. It’s called every time an object of the class Point is created\n",
        "# The first argument of __init__ is always the object itself. It’s not compulsory to call it self\n",
        "\n",
        "class Point(object):\n",
        "  '''\n",
        "  a point in a 2D-dimensional space\n",
        "  '''\n",
        "  def __init__(self, x, y):  \n",
        "    self.x = x #it's equal to the argument X or Y\n",
        "    self.y = y\n",
        "    \n",
        "p1 = Point(1,2) #to define an instance of the class Point\n",
        "print(p1)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "<__main__.Point object at 0x7fc82a4ead90>\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "mnP0b5svPpad"
      },
      "source": [
        "### **SUM UP of Methods:**\n",
        "\n",
        "- `__init__`  the constructor of the object, it’s called every time an object of the class `Point` is created\n",
        "-` __repr__` method that is used every time it's necessary to convert the object into a string\n",
        "- `__str__` method that is used to convert the object into a string for printing"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "kPn3-npVPeeQ",
        "outputId": "e9e9f2c2-7bd9-49e8-d8e5-5b36b86fb0ff"
      },
      "source": [
        "# __repr__: method that is used every time it's necessary to convert the object into a string\n",
        "# __str__: method that is used to convert the object into a string for printing; \n",
        "#__repr__ is used if __str__ is not defined\n",
        "\n",
        "class Point(object):\n",
        "  def __init__(self, x, y):\n",
        "    self.x = x\n",
        "    self.y = y\n",
        "  def __repr__(self):\n",
        "    return 'Point with x = {} and y = {}'. format(self.x, self.y)\n",
        "    \n",
        "p1 = Point(1,2)\n",
        "print(p1)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Point with x = 1 and y = 2\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "6vSlFIrZQRje",
        "outputId": "0ff74384-17bb-40d1-c03c-04e3d54456c6"
      },
      "source": [
        "class Point(object):\n",
        "  def __init__(self, x, y):\n",
        "    self.x = x\n",
        "    self.y = y\n",
        "  #f to calculate the norm of the Point\n",
        "  def norm(self):\n",
        "    return self.x**2.0 + self.y**2.0\n",
        "  def __repr__(self):\n",
        "    return 'Point with x = {} and y = {}'. format(self.x, self.y)\n",
        "    \n",
        "p1 = Point(1,2)\n",
        "print(p1.norm())"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "5.0\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "-7u3WBqAQ1g-",
        "outputId": "52c79968-980a-49cc-84ba-ec6a4e439b27"
      },
      "source": [
        "class Point(object):\n",
        "  def __init__(self, x, y):\n",
        "    self.x = x\n",
        "    self.y = y\n",
        "  def norm(self):\n",
        "    return self.x**2.0 + self.y**2.0\n",
        "  def __repr__(self):\n",
        "    return 'Point with x = {} and y = {}'. format(self.x, self.y)\n",
        "\n",
        "#Remember aliasing   \n",
        "p1 = Point(1,2)\n",
        "p2 = p1 #This is a new link to the same object\n",
        "p2.x = 3 #So here, we’re changing the object pointed both by p1 and p2\n",
        "print(p1)\n",
        "print(p2) "
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Point with x = 3 and y = 2\n",
            "Point with x = 3 and y = 2\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "BJVZKNQJCcfW"
      },
      "source": [
        "Otherwise, we can run `copy/deepcopy` method to create a new object\n",
        "\n",
        "```\n",
        "from copy import deepcopy\n",
        "p1 = Point(1,2)\n",
        "p2 = deepcopy(p1)\n",
        "```\n",
        "\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "bf4YgQaWSALv"
      },
      "source": [
        "### **Aliasing**:\n",
        "\n",
        "The object `c` includes a link to the object `p` -> changes in `p` also change `c`"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "rRY1SGjHTL6n",
        "outputId": "b65741e3-ffd1-433c-c36e-bba6f7e53c4e"
      },
      "source": [
        "class Point(object):\n",
        "  def __init__(self, x, y):\n",
        "    self.x = x\n",
        "    self.y = y\n",
        "  def __repr__(self):\n",
        "    return 'Point with x = {} and y = {}'. format(self.x, self.y)\n",
        "\n",
        "class Circle(Point):\n",
        "  def __init__(self, center, radius):\n",
        "    self.c = center\n",
        "    self.r = radius\n",
        "  def __repr__(self):\n",
        "    return 'center ({}) and radius = {}'.format(self.c.__repr__(), self.r)\n",
        "\n",
        "p = Point(1,2)\n",
        "c = Circle(p, 1)\n",
        "print(c) #center (x = 1 y = 2) and radius = 1 \n",
        "p.x = 3\n",
        "print(c) # center (x = 3 y = 2) and radius = 1"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "center (Point with x = 1 and y = 2) and radius = 1\n",
            "center (Point with x = 3 and y = 2) and radius = 1\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "p35JtVaHUSlN"
      },
      "source": [
        "### **Operator overloading**\n",
        "\n",
        "It is possible to define how operators $(+,-,==,...)$ work on object of your own classes\n",
        "\n",
        "```\n",
        "<  | __lt__\n",
        "<= | __le__\n",
        ">  | __gt__\n",
        ">= | __ge__\n",
        "== | __eq__\n",
        "!= | __ne__\n",
        "```\n",
        "For binary operators, it is convention to call the second operand in the method definition `other`"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "LgQl58PyR1b3"
      },
      "source": [
        "#Define the > operator of the class Point, so that p1 > p2 returns \n",
        "# True if p1 is further away from the origin than p2\n",
        "\n",
        "#for operator <\n",
        "class Point(object):\n",
        "  def __init__(self, x, y):\n",
        "    self.x = x\n",
        "    self.y = y\n",
        "  def norm(self):\n",
        "    return self.x**2.0 + self.y**2.0\n",
        "  def __lt__(self,other): #__lt__, __le__, __gt__, __ge__,__eq__,__ne___\n",
        "    if type(other) == float:\n",
        "      #the point is lower if the norm is lower\n",
        "      self.norm() < other\n",
        "    elif type(other) == Point:\n",
        "      return self.norm() < other.norm()\n",
        "    else:\n",
        "      raise TypeError()\n",
        "\n",
        "  def __repr__(self):\n",
        "    return 'Point with x = {} and y = {}'. format(self.x, self.y)\n",
        "\n",
        "p1 = Point(1,2)\n",
        "p2 = Point(3,0.5)\n",
        "if p1 < 5.0: #now it's a float\n",
        "  print('norm p1 lower than norm float')"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "RMjGfQpcWIfN",
        "outputId": "74eda6c2-c742-4026-dc96-dea05be28935"
      },
      "source": [
        "# Define the == operator to check if two objects of the class Point are the same\n",
        "class Point(object):\n",
        "  def __init__(self, x, y):\n",
        "    self.x = x\n",
        "    self.y = y\n",
        "  def __eq__(self, other):\n",
        "    return (self.x == other.x) and (self.y == other.y)\n",
        "\n",
        "p1 = Point(1,2)\n",
        "p2 = Point(1,2)\n",
        "print(p1 == p2) # True"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "True\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "a7Yl_msNVB_8"
      },
      "source": [
        "**Other operators:**\n",
        "\n",
        "```\n",
        "+   | __add__\n",
        "+=  | __iadd__\n",
        "-   | __sub__\n",
        "-=  | __isub__\n",
        "*   | __mul__\n",
        "*=  | __imul__\n",
        "/   | __truediv__\n",
        "/=  | __idiv__\n",
        "//  | __floordiv__\n",
        "//= | __ifloordiv\n",
        "%   | __mod__\n",
        "%=  | __imod__\n",
        "**  | __pow__\n",
        "**= | __ipow__\n",
        "```\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "4Ay9-lIbVkCH"
      },
      "source": [
        "**Unary operators**\n",
        "\n",
        "```\n",
        "+       | __pos__\n",
        "-       | __neg__\n",
        "abs()   | __abs__\n",
        "int()   | __int__\n",
        "float() | __float__\n",
        "round() | __round__\n",
        "bool()* | __bool__\n",
        "```\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "4QK6a-c2VkAl"
      },
      "source": [
        "## **Problem 1(ex4) - \"Atlas\"**\n",
        "\n",
        "**Step 1**\n",
        "\n",
        "Define a class \"`City`\" with attributes the following information about a city:\n",
        "- attribute: Name of the city\n",
        "- attribute: Number of inhabitants\n",
        "\n",
        "Define a class \"`Region`\" with\n",
        "- attibute: Name of the region\n",
        "- attribute: An arbitrary number of cities\n",
        "- method: to get the number of cities\n",
        "- method: to get the total number of inhabitants of the region\n",
        "\n",
        "Define a class \"`Nation`\" with\n",
        "- attribute: Name of the nation\n",
        "- attribute: An arbitrary number of regions\n",
        "- method: to get the number of regions\n",
        "- method: to get the number of cities\n",
        "- method: to get the total number of inhabitants of the nation\n",
        "\n",
        "**Step 2**\n",
        "\n",
        "Create some cities, regions and a nation"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "uBJIekdMYM4F"
      },
      "source": [
        "class City(object):\n",
        "  def __init__(self, name, pop):\n",
        "    self.name = name\n",
        "    self.pop =  pop\n",
        "    \n",
        "class Region(object):\n",
        "  def __init__(self, name, *args):\n",
        "    self.name = name\n",
        "    self.cities = [city for city in args]\n",
        "  def num_cities(self):\n",
        "    return len(self.cities) #to get the number of cities\n",
        "  def pop(self):\n",
        "    return sum([city.pop for city in self.cities]) #to return the population -> list comprehension\n",
        "\n",
        "class Nation(object):\n",
        "  def __init__(self, name, *args):\n",
        "    self.name = name\n",
        "    self.regions = [region for region in args]\n",
        "  def num_regions(self):\n",
        "    return len(self.regions) #to get the number of regions\n",
        "  def num_cities(self):\n",
        "    return sum([region.num_cities() for region in self.regions]) #to get the number of cities\n",
        "  def pop(self):\n",
        "    return sum([region.pop() for region in self.regions]) #to return the population\n",
        "  #__repr__ & __str__ are basically the same methods\n",
        "  def __repr__(self):\n",
        "    return '{}.pop {}'.format(self.name, self.pop())"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "AHPvfMOIZVq1",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "35f5cdcb-0688-4f75-d194-4624bd5114ad"
      },
      "source": [
        "bo = City('Bologna', 500000)\n",
        "mo = City('Modena', 200000)\n",
        "fe = City('Ferrara', 50000)\n",
        "emilia = Region('Emilia Romagna', bo, mo, fe)\n",
        "\n",
        "fi = City('Firenze', 500000)\n",
        "pi = City('Pisa', 200000)\n",
        "si = City('Siena', 53772)\n",
        "toscana = Region('Toscana', fi, pi, si)\n",
        "\n",
        "italia = Nation(\"Italia\", emilia, toscana)\n",
        "\n",
        "print(italia)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Italia.pop 1503772\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "3ZS8CWtYcUum"
      },
      "source": [
        "**Step 4**\n",
        "\n",
        "Overload some operators.\n",
        "\n",
        "For the class `City`:\n",
        "- \"`<`\": to check if a city has less inhabitants then another\n",
        "- \"`<=`\": to check if a city has less inhabitants then another\n",
        "\n",
        "For the class `Region`:\n",
        "- \"`in`\": to check if a city belongs to a given region\n",
        "\n",
        "For the class `Nation`\n",
        "- \"`in`\": to check if a region OR city belongs to the given region"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "P4Q3_9-1cTts"
      },
      "source": [
        "# __lt__, ....\n",
        "# Arithmetic methosds: __add__ +, __iadd__+=, __sub__, __mul__, __div__, __mod__, __pow__\n",
        "# To convert smth: __bool__, __int__, __float__\n",
        "# To work with collection of elements: __contains__in\n",
        "\n",
        "class City(object):\n",
        "  def __init__(self, name, pop):\n",
        "    self.name = name\n",
        "    self.pop =  pop\n",
        "  #to check if a city has less inhabitants then another \n",
        "  def __lt__(self, other):\n",
        "    return self.pop < other.pop\n",
        "  #to check if a city has less-equal inhabitants then another \n",
        "  def __le__(self, other):\n",
        "    return self.pop <= other.pop\n",
        "  def __repr__(self):\n",
        "    return self.name\n",
        "    \n",
        "class Region(object):\n",
        "  def __init__(self, name, *args):\n",
        "    self.name = name\n",
        "    self.cities = [city for city in args]\n",
        "  def num_cities(self):\n",
        "    return len(self.cities)\n",
        "  def pop(self):\n",
        "    return sum([city.pop for city in self.cities])\n",
        "  #to check if a city belongs to a given region\n",
        "  def __contains__(self, city):\n",
        "    return city in self.cities\n",
        "\n",
        "class Nation(object):\n",
        "  def __init__(self, name, *args):\n",
        "    self.name = name\n",
        "    self.regions = [region for region in args]\n",
        "  def num_regions(self):\n",
        "    return len(self.regions)\n",
        "  def num_cities(self):\n",
        "    return sum([region.num_cities() for region in self.regions])\n",
        "  def pop(self):\n",
        "    return sum([region.pop() for region in self.regions])\n",
        "  def __repr__(self):\n",
        "    return '{}.pop {}'.format(self.name, self.pop())"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "qHcB5gQadDJF",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "f32b1349-7141-4bbd-fb4e-8cfb81795126"
      },
      "source": [
        "if bo < fe:\n",
        "  print('Bologna is smaller than Ferrara')\n",
        "else:\n",
        "  print('Bologna is bigger than Ferrara')\n",
        "\n",
        "#defining the list of cities\n",
        "l = [fe, bo, mo]\n",
        "print(l)\n",
        "\n",
        "#BUT\n",
        "l.sort() #since we defined '<' the sort method works properly\n",
        "print(l)\n",
        "\n",
        "#in operator: to check if a city belongs to a given region\n",
        "if bo in emilia:\n",
        "  print('Bologna is in Emilia')\n",
        "else:\n",
        "  print('Bologna is not in Emilia')"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Bologna is bigger than Ferrara\n",
            "[Ferrara, Bologna, Modena]\n",
            "[Ferrara, Modena, Bologna]\n",
            "Bologna is in emilia\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "qYEJyN-0LfQg"
      },
      "source": [
        "## **Operator for sequences** \n",
        "aka: Method for Collection of elements\n",
        "\n",
        "* `__len__ ` - implements the `len` function, it should return an integer\n",
        "* `__getitem__` - it's called when the syntax object[key] is used, key might be an integer (as in list) or another object (as in dictionaries)\n",
        "* `__setitem__` - this is called when the syntax object[key] is used to assign an item\n",
        "* `__delitem__ `- it's called when the `del` keyword is used\n",
        "* `__missing__` - it's called by `__getitem__` when the item does not exist\n",
        "* `__contains__` - it's called when the in operator is used\n"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "j6plHabmL2Zt",
        "outputId": "6a281ff4-9a39-4c5f-bca7-387676b7832d"
      },
      "source": [
        "class Point(object):\n",
        "  def __init__(self, x, y):\n",
        "    self.x = x\n",
        "    self.y = y\n",
        "  def __repr__(self):\n",
        "    return 'Point with x = {} and y = {}'. format(self.x, self.y) \n",
        "\n",
        "#So, the Polygon is a collection/sequence of Points\n",
        "class Polygon(object):\n",
        "  def __init__(self, *args):\n",
        "    self.vs = []\n",
        "    #it makes a cycle over all these arguments\n",
        "    for arg in args:\n",
        "      #it checks if arg-s are Points\n",
        "      if isinstance(arg, Point):\n",
        "        #and if they are Point, they are appended to the list self.vs\n",
        "        self.vs.append(arg)\n",
        "      else:\n",
        "        #if not we raise an exception\n",
        "        raise TypeError()\n",
        "  def __repr__(self):\n",
        "    output = 'Polygon with {} vertexes\\n'. format(len(self.vs))\n",
        "    #to print the vertexes\n",
        "    for v in self.vs:\n",
        "      output += '\\t'+v.__repr__()+'\\n'\n",
        "    return output\n",
        "\n",
        "p1 = Point(1,2)\n",
        "p2 = Point(3,0.5)\n",
        "p3 = Point(5,8)\n",
        "t = Polygon(p1,p2,p3)\n",
        "print(t)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Polygon with 3 vertexes\n",
            "\tPoint with x = 1 and y = 2\n",
            "\tPoint with x = 3 and y = 0.5\n",
            "\tPoint with x = 5 and y = 8\n",
            "\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "-Y3b3rXLOt3P"
      },
      "source": [
        "#to know the number of Points:\n",
        "class Point(object):\n",
        "  def __init__(self, x, y):\n",
        "    self.x = x\n",
        "    self.y = y\n",
        "  def __repr__(self):\n",
        "    return 'Point with x = {} and y = {}'. format(self.x, self.y) \n",
        "\n",
        "class Polygon(object):\n",
        "  def __init__(self, *args):\n",
        "    self.vs = []\n",
        "    for arg in args:\n",
        "      if isinstance(arg, Point):\n",
        "        self.vs.append(arg)\n",
        "      else:\n",
        "        raise TypeError()\n",
        "  \n",
        "  #to know the number of Points:\n",
        "  def __len__(self):\n",
        "    return len(self.vs)\n",
        "  \n",
        "  #to change the first vertex of my value\n",
        "  def __setitem__(self, ind, item):\n",
        "    #if the index isn't an integer it's an exeption\n",
        "    if not isinstance(ind,int):\n",
        "      raise TypeError()\n",
        "    #if the item isn't a Point it's an exeption\n",
        "    if not isinstance(item, Point):\n",
        "      raise TypeError()\n",
        "    if (ind < 0) or (ind >= self.__len__()):\n",
        "      raise ValueError()\n",
        "    elif ind == self.__len__():\n",
        "      self.vs.append(item)\n",
        "    else:\n",
        "      self.vs[ind] = item\n",
        "  \n",
        "  #to print the first vertex of the Polygon\n",
        "  def __getitem__(self, ind):\n",
        "    #if the index isn't an integer it's an exeption\n",
        "    if not isinstance(ind,int):\n",
        "      raise TypeError()\n",
        "    #once we know that index is an ineger\n",
        "    return self.vs[ind]\n",
        "\n",
        "  def __repr__(self):\n",
        "    output = 'Polygon with {} vertexes\\n'. format(len(self.vs))\n",
        "    for v in self.vs:\n",
        "      output += '\\t'+v.__repr__()+'\\n'\n",
        "    return output\n"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "7bypiHmiPSTt",
        "outputId": "b2ba4091-00e0-4dd2-b59c-172b9e6bc616"
      },
      "source": [
        "p1 = Point(1,2)\n",
        "p2 = Point(3,0.5)\n",
        "p3 = Point(5,8)\n",
        "t = Polygon(p1,p2,p3)\n",
        "t[0] = Point(3,4) #to change the first vertex of my value\n",
        "#t[3] = Point(7,8)\n",
        "print(t[0])\n",
        "print(len(t))"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Point with x = 3 and y = 4\n",
            "3\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "27wrzirRTjFp"
      },
      "source": [
        "# **Inheritance**\n",
        "\n",
        "* New classes are created inheriting from previous classes. Only differences between the parent class and the new class need to be implemented\n",
        "\n",
        "* Methods defined in the new class override methods defined in the\n",
        "parent class\n",
        "\n",
        "`class New(Parent): `With this syntax, the class *New* inherits from the class *Parent*\n",
        "\n",
        "`class New:` \n",
        "\n",
        "`class New(object):`  Actually when the parent class is not defined, it is assumed equal to the class object, where object is a completely generic python class\n",
        "\n",
        "* **Multiple inheritance**: One class might inherit from multiple classes\n",
        "```\n",
        "class New(Parent1, Parent2, Parent3, ...):\n",
        "```\n",
        "\n"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "0kOjnHPchUl8"
      },
      "source": [
        "#for example here's the class that is a particular instance of the Polygon\n",
        "#and to define the difference b/w the two classes:\n",
        "\n",
        "class Triangle(Polygon):\n",
        "  def __init__(self, *args):\n",
        "    if len(args) != 3:\n",
        "      raise TypeError()\n",
        "    #it is possible to call a method of one class from any other class\n",
        "    #The built-in function super() returns the parent class\n",
        "    super().__init__(*args) #BUT we don't need to pass self here\n",
        "    \n",
        "    #Polygon.__init__(self, *args) #the same way\n",
        "\n",
        "p1 = Point(1,2)\n",
        "p2 = Point(3,0.5)\n",
        "p3 = Point(5,8)\n",
        "t = Triangle(p1,p2,p3)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "He6lk4SyjFT-"
      },
      "source": [
        "## **Problem 1 (ex6)**\n",
        "\n",
        "Given the class `Vehicle`\n",
        "```\n",
        "class Vehicle(object):\n",
        "    def __init__(self, name, km = 0, num_wheels = None):\n",
        "        self.name = name\n",
        "        self.km = km\n",
        "        self.num_wheels = num_wheels\n",
        "```"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "yJTp15KujZuv"
      },
      "source": [
        "**Step 1:** Modify the class so to\n",
        "\n",
        "- include a metod to accumulate travelled kilometres. The method can receive as input an arbitrary number or arguments to be added;\n",
        "- define `__ str __ ()` to print on screen the vehicle's name and travelled kilometers.\n",
        "- define a few vehicles to test the class"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "gSpBjamljXqy"
      },
      "source": [
        "class Vehicle(object):\n",
        "    def __init__(self, name, km = 0, num_wheels = None):\n",
        "        self.name = name\n",
        "        self.km = km\n",
        "        self.num_wheels = num_wheels\n",
        "\n",
        "    #to add killometers\n",
        "    def run(self, *args):\n",
        "      for arg in args:\n",
        "        self.km += arg\n",
        "    def __repr__(self):\n",
        "      return ' {} travelled {} km'.format(self.name, self,km)\n",
        "\n",
        "class Car(Vehicle):\n",
        "  def __init__(self,name,plate,year = None, fuel = None):\n",
        "    self.plate = plate\n",
        "    self.year = year\n",
        "    self.fuel = fuel\n",
        "    self.owners = []\n",
        "    super().__init__(name, num_wheels = 4)\n",
        "  def add_owner(self, owner):\n",
        "    self.owners.append(owner)\n",
        "  def __str__(self):\n",
        "    output = 'List of owners for {}'.format(self.name)\n",
        "    for owner in self.owners:\n",
        "      output += '\\t{}\\n'.format(owner)\n",
        "    return output\n",
        "\n",
        "class Bicycle(Vehicle):\n",
        "  def __init__(self, *args, **kwargs):\n",
        "    super().__init__(*args, **kwargs, num_wheels = 2)\n",
        "  def print_condition(self):\n",
        "    if self.km == 0:\n",
        "      print('NEW')\n",
        "    elif self.km < 1000:\n",
        "      print('USED')\n",
        "    else:\n",
        "      print('OLD')"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "4e1bX6_lkxDX",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "825f1b8c-fd3a-4608-87b1-172652b76925"
      },
      "source": [
        "a = Car('ferrari', 'HJHJ3DS', 2008)\n",
        "a.add_owner('Paolo')\n",
        "a.add_owner('Giorgio')\n",
        "a.run(10000)\n",
        "a.run(5000)\n",
        "print(a)\n",
        "\n",
        "b = Bicycle"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "List of owners for ferrari\tPaolo\n",
            "\tGiorgio\n",
            "\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "trH81Wtnng6i"
      },
      "source": [
        "# **Loops & Iterators**\n",
        "\n",
        "* Any object that implements the `__iter__` method and the `__next__` method can be used as an iterator\n",
        "\n",
        "* `__iter__` -  method that returns the object to iterate (usually the object itself, if the `__next__` method is implemented)\n",
        "\n",
        "* `__next__` - method that returns the next item of the object, or raises a `StopIteration` exception when there are no more items available"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "auIdqDFEZxaU",
        "outputId": "8ffdc09f-7864-4b37-dc6b-488a88e84b6c"
      },
      "source": [
        "l = [1,2,3]\n",
        "for x in l:\n",
        "  print(x)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "1\n",
            "2\n",
            "3\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "yOmn8k9-ngVS"
      },
      "source": [
        "#Loops\n",
        "l = [1,2,3]\n",
        "i = l.__iter__()"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "o9x0hiqIoAOu",
        "outputId": "312df38a-1745-4bcf-b39f-668647d74342"
      },
      "source": [
        "#the cycle will be over and the iteration stops at 3 here\n",
        "i.__next__()"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "1"
            ]
          },
          "metadata": {},
          "execution_count": 62
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "cnoOflSFoGSe"
      },
      "source": [
        "#1,1,2,3,5,8,13,.... Fibonacci\n",
        "#the next value in a serie is equal to the sum of the previous 2 values\n",
        "\n",
        "class Fibonacci(object):\n",
        "  def __init__(self):\n",
        "    self.values = [1,1,2,3,5,8,13,21,34,55]\n",
        "    self.i = 0\n",
        "  def __iter__(self):\n",
        "    return self \n",
        "  def __next__(self):\n",
        "    if self.i >= len(self.values):\n",
        "      #to reset the counter: This instruction, reset the index, and so new iterations are possible\n",
        "      self.i = 0\n",
        "      raise StopIteration\n",
        "    #the value that we want to return\n",
        "    value = self.values[self.i]\n",
        "    self.i += 1\n",
        "    return value"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "yFxIVEpapS1u",
        "outputId": "d5e5281f-0237-49ae-e5c6-7d2d6813b85e"
      },
      "source": [
        "f = Fibonacci()\n",
        "for x in f:\n",
        "  print(x)\n",
        "\n",
        "print(f.i)\n",
        "\n",
        "for x in f:\n",
        "  print(x)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "1\n",
            "1\n",
            "2\n",
            "3\n",
            "5\n",
            "8\n",
            "13\n",
            "21\n",
            "34\n",
            "55\n",
            "0\n",
            "1\n",
            "1\n",
            "2\n",
            "3\n",
            "5\n",
            "8\n",
            "13\n",
            "21\n",
            "34\n",
            "55\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "zRSQuJ8wqSCH"
      },
      "source": [
        "class Fibonacci(object):\n",
        "  def __init__(self, max_n = 20): #max_n - to limit the generation of new elements\n",
        "    self.n1 = 0\n",
        "    self.n2 = 1\n",
        "    self.max_n = max_n\n",
        "  def __iter__(self):\n",
        "    return self \n",
        "  def __next__(self):\n",
        "    #the value stand for Fibonacci principle\n",
        "    value = self.n1 + self.n2\n",
        "    if value > self.max_n:\n",
        "      self.n1 = 0\n",
        "      self.n2 = 1\n",
        "      raise StopIteration\n",
        "    self.n1 = self.n2\n",
        "    self.n2 = value\n",
        "    return value\n",
        "\n",
        "class FibonacciIter(object):\n",
        "  def __init__(self, max_n = 20):\n",
        "    self.max_n = max_n\n",
        "  def __iter__(self):\n",
        "    return FibonacciIter(self.max_n)\n",
        "\n",
        "#self.n1 = 1\n",
        "#self.n2 = 1\n",
        "# --> 2, self.n1 = 1, self.n2 = 2\n",
        "# --> 3, self.n1 = 2, self.n2 = 3\n",
        "# ...\n",
        "\n",
        "f = Fibonacci()\n",
        "for x in f:\n",
        "  print(x)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "3OLqJhZLdRsp"
      },
      "source": [
        "f = Fibonacci()\n",
        "for x in f:\n",
        "  for y in f:\n",
        "    print(x, y)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "f-yrrpwVqCOT"
      },
      "source": [
        "# **Lecture 4. The begining**\n",
        "\n",
        "- `enumerate(iter)`: It creates an iterator that provides the sequence of pairs (index, value) for all the elements in object `iter`\n",
        "\n",
        "- `zip(iter1, iter2)` : It creates an iterator that runs along `iter1`, `iter2`, etc  simultaneously. If the lengths of the input iterators is different, it stops at the shortest\n",
        "\n",
        "- `map(func, iter)` : It creates an iterator by applying the function `func` to the elements of the iterator `iter`\n",
        "\n",
        "- `filter(func, iter)` : It creates an iterator by applying the function `func` to the elements of the iterator `iter`, and returning only the elements where `func` is True\n",
        "\n",
        "- `reversed(iter)` : An iterator with the items in `iter` cycled in the reversed order\n",
        "\n",
        "```\n",
        "l = [7,2,3]\n",
        "for x in reversed(l):\n",
        "print(x)\n",
        "```\n",
        "\n",
        "- `sorted(iter)` : An iterator with the items in iter cycled in sorted order\n",
        "\n",
        "```\n",
        "l = [7,2,3]\n",
        "for x in sorted(l):\n",
        "print(x)\n",
        "```\n"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "vVr17NFhqJKR",
        "outputId": "6015ea94-eac6-4594-ffd0-40988cacc03d"
      },
      "source": [
        "#We have an object that can be used as an iterator\n",
        "l = ['a', 'b', 'c']\n",
        "\n",
        "#ENUMERATE\n",
        "#We can use method enumerate and get both the elements and index\n",
        "for i, x in enumerate(l): \n",
        "  print(i, x)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "0 a\n",
            "1 b\n",
            "2 c\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "cJZZZOfDqgOo",
        "outputId": "94d14521-1738-4079-ace3-1174951ac22b"
      },
      "source": [
        "#ZIP\n",
        "#We cycle all these elements at the same time\n",
        "l = ['a', 'b', 'c']\n",
        "l2 = ['e','f','g']\n",
        "for x, y in zip(l, l2):\n",
        "  print(x, y)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "a e\n",
            "b f\n",
            "c g\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "XNnSG2_Vq-VJ",
        "outputId": "7e0d3910-bcd9-4e50-e238-f421d81c8359"
      },
      "source": [
        "#ZIP\n",
        "#it takes an arbitrary number of elements\n",
        "l = ['a', 'b', 'c']\n",
        "l2 = ['e','f','g']\n",
        "l3 = ['h','i','j','l']\n",
        "for x, y,z in zip(l, l2, l3):\n",
        "  print(x, y,z)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "a e h\n",
            "b f i\n",
            "c g j\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "pjDPsH59rYdz",
        "outputId": "59748ee4-165e-40c2-e8d7-06f9c97d5729"
      },
      "source": [
        "#MAP\n",
        "#It applies the f to all the elements in the object\n",
        "l = [1,2,3,4]\n",
        "square = lambda x: x**2\n",
        "for x2 in map(square, l):\n",
        "  print(x2)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "1\n",
            "4\n",
            "9\n",
            "16\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "RfTzCX6WrYbo",
        "outputId": "8b1df4c1-b410-49d9-cc03-162e1d3f00f2"
      },
      "source": [
        "#FILTER\n",
        "#It applies the f to the elements and then we cycle only along the elements that are T for this f\n",
        "l = [1,2,3,4]\n",
        "pos = lambda x: x>0\n",
        "for x2 in filter(pos, l):\n",
        "  print(x2)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "1\n",
            "2\n",
            "3\n",
            "4\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "7GBeG1k3sMcf",
        "outputId": "07152539-00c1-48db-b4f3-284746489840"
      },
      "source": [
        "#MODULE: ITETOOLS - we can use all of such iterators\n",
        "#EXAMPLE:\n",
        "import itertools\n",
        "for x in itertools.permutations([1,2,3]):\n",
        "  print(x)\n",
        "\n",
        "#also: itertools.combinations([4,5,6],2) -> (4, 5) (4, 6) (5, 6)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "(1, 2, 3)\n",
            "(1, 3, 2)\n",
            "(2, 1, 3)\n",
            "(2, 3, 1)\n",
            "(3, 1, 2)\n",
            "(3, 2, 1)\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "UmsnR6NtuUHe"
      },
      "source": [
        "## **Generators**\n",
        "\n",
        "- `yield`: when a function returns with a `yield` statement, the execution is not stopped but suspended; when the function is called again with next execution restart from there;\n",
        "\n",
        "- `range(start, stop, step)` : Sequence of ordered integer numbers"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 129
        },
        "id": "alA95prnuWmG",
        "outputId": "ad631ee1-d6dc-44ce-8753-99b1acb52863"
      },
      "source": [
        "#YIELD\n",
        "#1,1,2,3,5,8,13,.... Fibonacci\n",
        "class fibonacci(maxn = 10000):\n",
        "  n1 = 0\n",
        "  n2 = 1\n",
        "  while True:\n",
        "    value = n1 + n2\n",
        "    if value > maxn:\n",
        "      break\n",
        "    n1 = n2\n",
        "    n2 = value\n",
        "    yield value\n",
        "\n",
        "for x in fibonacci():\n",
        "  print(x)    "
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "error",
          "ename": "SyntaxError",
          "evalue": "ignored",
          "traceback": [
            "\u001b[0;36m  File \u001b[0;32m\"<ipython-input-20-c452f33fd557>\"\u001b[0;36m, line \u001b[0;32m12\u001b[0m\n\u001b[0;31m    yield value\u001b[0m\n\u001b[0m    ^\u001b[0m\n\u001b[0;31mSyntaxError\u001b[0m\u001b[0;31m:\u001b[0m 'yield' outside function\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "eO05wtFiwaGe"
      },
      "source": [
        "**Generator expression**\n",
        "\n",
        "`( expression for value in iterator if expression )`\n",
        "\n",
        "- It’s similar to list comprehension but it creates a generator\n",
        "- The if part might be missing\n",
        "- More than one for cycle (each one eventually including an if) can also\n",
        "be used"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "r1cNtSDKwHWG",
        "outputId": "056cbfba-dc61-4513-ca7a-ce2e3f912831"
      },
      "source": [
        "#RANGE\n",
        "x1 = [i for i in range(10)] #it creates a list\n",
        "print(x1)\n",
        "x2 = (i**2 for i in range(10)) # it creates a generator\n",
        "print(x2)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]\n",
            "<generator object <genexpr> at 0x7fa407ea7ad0>\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "CgL6OjFlwxJl"
      },
      "source": [
        "## **Problems(ex7)**\n",
        "\n",
        "1) Define a class to iterate over numbers of the series $n(n+1)/2$ up to a maximum value `max_n`"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "UkoFXWIUxJpN",
        "outputId": "d8fbb140-2293-4645-e148-785cefc2f146"
      },
      "source": [
        "class Triangular(object):\n",
        "  def __init__(self,max_n = 10):\n",
        "    self.max_n = max_n\n",
        "    self.n = 0\n",
        "  def __iter__(self):\n",
        "    return self\n",
        "  def __next__(self):\n",
        "    self.n += 1\n",
        "    if self.n > 10:\n",
        "      raise StopIteration\n",
        "    return self.n * (self.n +1)/2\n",
        "\n",
        "for x in Triangular():\n",
        "  print(x)    "
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "1.0\n",
            "3.0\n",
            "6.0\n",
            "10.0\n",
            "15.0\n",
            "21.0\n",
            "28.0\n",
            "36.0\n",
            "45.0\n",
            "55.0\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "NcrH-ttixOxE"
      },
      "source": [
        "Define a class to iterate over prime numbers up to a maximum value `max_n`. Calculate the prime numbers at run-time by finding the next number that can not be divided by any lower number higher than 1 (**Hint**: remember `break/else` in cycle)"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "CWWo8-MBxTC4",
        "outputId": "d3beb8d3-9b93-400b-e889-49167211add1"
      },
      "source": [
        "class Prime(object):\n",
        "  def __init__(self,max_n = 10):\n",
        "    self.max_n = max_n\n",
        "    self.n = 0\n",
        "  def __iter__(self):\n",
        "    return self\n",
        "  def __next__(self):\n",
        "    self.n += 1\n",
        "    while self.n < self.max_n: #to stop once we reach the threshold max_n\n",
        "      i = 2\n",
        "      while i < self.n:\n",
        "        if self.n % i == 0:\n",
        "          break\n",
        "        i += 1\n",
        "      else:\n",
        "        return self.n\n",
        "      self.n += 1\n",
        "      self.n = 0\n",
        "      raise StopIteration\n",
        "     \n",
        "\n",
        "for x in Prime():\n",
        "  print(x)    "
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "1\n",
            "2\n",
            "3\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "tMa15sE2xXWn"
      },
      "source": [
        "Conver the previous two classes to generators"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "rkbYv5lLxX-u",
        "outputId": "f8f27eb5-8911-43bc-c71c-b28096e2a3f7"
      },
      "source": [
        "def convertion(max_n = 10):\n",
        "  n = 1\n",
        "  while n < max_n:\n",
        "    n += 1\n",
        "    yield n*(n+1)/2\n",
        "\n",
        "for i in convertion():\n",
        "  print(i)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "3.0\n",
            "6.0\n",
            "10.0\n",
            "15.0\n",
            "21.0\n",
            "28.0\n",
            "36.0\n",
            "45.0\n",
            "55.0\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "xmGg2uT4xkaP"
      },
      "source": [
        "## **Scope and Lifetime of variables**\n",
        "\n",
        "- `global` : is needed when we want to change a global variable inside a function. Beware: it’s not possible to refer both to a local and a global variable with the same name\n",
        "\n",
        "- `nonlocal` : it's used for variables in the previous namespace (useful for nested functions); With `global`, if the variable does not exist, it is created; With `nonlocal`, it must exist"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "u9s0WCZ4zo9B"
      },
      "source": [
        "#GLOBAL VARIABLE\n",
        "def function():\n",
        "  global x #now the x is the same both outside the f and inside it\n",
        "  x = 7\n",
        "  print(x)\n",
        "\n",
        "x = 1\n",
        "function()\n",
        "print(x)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "gqP26s2kzo7I",
        "outputId": "d413105d-d6aa-4cb3-f4e0-61841f61ea4b"
      },
      "source": [
        "#NONLOCAL\n",
        "def function():\n",
        "  x = 1\n",
        "  def nested_f():\n",
        "    nonlocal x #???? x is the same in the whole f\n",
        "    x = 3\n",
        "    print(x)\n",
        "  nested_f()\n",
        "  print(x)\n",
        "\n",
        "x = 7\n",
        "function()\n",
        "print(x)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "3\n",
            "3\n",
            "7\n"
          ]
        }
      ]
    }
  ]
}