Python OOP.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": true
   },
   "source": [
    "# OOP (Object Oriented Programming)\n",
    "\n",
    "In informatica la programmazione orientata agli oggetti (OOP, Object Oriented Programming) è un paradigma di programmazione che permette di definire oggetti software in grado di interagire gli uni con gli altri attraverso lo scambio di messaggi.\n",
    "\n",
    "Con \"oggetto software\" si intende un’unica entità **(la classe)** all'interno della quale si raggruppano delle strutture dati e delle procedure che operano su di esse.\n",
    "\n",
    "Istanziando la classe, che rappresenta fondamentalmente una struttura astratta, è possibile creare **oggetti** concreti (le cosiddette istanze) dotati di **proprietà** (dati/variabili) e **metodi** (procedure/funzioni) che operano sui dati dell’oggetto stesso.\n",
    "\n",
    "Tra gli altri vantaggi della programmazione orientata agli oggetti:\n",
    "\n",
    "- fornisce un supporto **naturale** alla modellazione software degli oggetti del mondo reale o del modello astratto da riprodurre\n",
    "- permette una più facile **gestione e manutenzione** di progetti di grandi dimensioni\n",
    "- l'organizzazione del codice sotto forma di classi favorisce la **modularità** e il **riuso** di codice"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Cosa rende un linguaggio OOP?\n",
    "\n",
    "La programmazione ad oggetti prevede di raggruppare in una zona circoscritta del codice sorgente (chiamata classe), la dichiarazione delle strutture dati e delle procedure che operano su di esse. Le classi, quindi, costituiscono dei modelli astratti, che a tempo di esecuzione vengono invocate per istanziare o creare oggetti software relativi alla classe invocata. Questi ultimi sono dotati di attributi (dati) e metodi (procedure) secondo quanto definito/dichiarato dalle rispettive classi.\n",
    "\n",
    "La parte del programma che fa uso di un oggetto si chiama **client**.\n",
    "\n",
    "Un linguaggio di programmazione è definito **ad oggetti** quando permette di implementare tre meccanismi usando la sintassi nativa del linguaggio:\n",
    "\n",
    "- incapsulamento\n",
    "- ereditarietà\n",
    "- polimorfismo\n",
    "\n",
    "**L'incapsulamento** consiste nella separazione della cosiddetta interfaccia di una classe dalla corrispondente implementazione, in modo che i client di un oggetto di quella classe possano utilizzare la prima, ma non la seconda.\n",
    "\n",
    "**L'ereditarietà** permette essenzialmente di definire delle classi a partire da altre già definite.\n",
    "\n",
    "**Il polimorfismo** permette di scrivere un client che può servirsi di oggetti di classi diverse, ma dotati di una stessa interfaccia comune; a tempo di esecuzione, quel client attiverà comportamenti diversi senza conoscere a priori il tipo specifico dell'oggetto che gli viene passato."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": false
   },
   "source": [
    "## Incapsulamento\n",
    "\n",
    "L'incapsulamento è la proprietà per cui i dati che definiscono lo stato interno di un oggetto e i metodi che ne definiscono la logica sono accessibili ai metodi dell'oggetto stesso, mentre non sono visibili ai client. \n",
    "\n",
    "Per alterare lo stato interno dell'oggetto, **è necessario invocarne i metodi pubblici**, ed è questo lo scopo principale dell'incapsulamento. \n",
    "\n",
    "Permette di vedere l'oggetto come una **black-box**, cioè una \"scatola nera\" con la quale l'interazione avviene solo e solamente tramite i metodi definiti dall'interfaccia. "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": true
   },
   "source": [
    "## Ereditarietà\n",
    "\n",
    "Permette di derivare nuove classi a partire da quelle già definite realizzando una gerarchia di classi. \n",
    "\n",
    "Una classe derivata attraverso l'ereditarietà (sottoclasse o classe figlia), mantiene i metodi e gli attributi delle classi da cui deriva (classi base, superclassi o classi padre); inoltre, può definire i propri metodi o attributi, e ridefinire il codice di alcuni dei metodi ereditati tramite un meccanismo chiamato **overriding**."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Polimorfismo\n",
    "\n",
    "Nella programmazione ad oggetti, con il nome di polimorfismo per inclusione, si indica il fatto che lo stesso codice eseguibile può essere utilizzato con istanze di classi diverse, **aventi una superclasse comune**."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# OOP in Python"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Classi\n",
    "\n",
    "Come abbiamo visto non sono altro che il blueprint del nostro modello, uno strumento per condensare in un unica porzione di codice comportamento e dati"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "class Rocket:\n",
    "    def __init__(self):\n",
    "        print(\"Called automatically\")\n",
    "        self.x = 0\n",
    "        self.y = 0"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Come notate la classe Rocket al momento **inizializza** i dati ma non definisce alcun comportamento."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "class Rocket:\n",
    "    def __init__(self):\n",
    "        print(\"Called automatically\")\n",
    "        self.x = 0\n",
    "        self.y = 0\n",
    "\n",
    "    def moveUp(self):\n",
    "        self.y += 1"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Perfetto, abbiamo creato la nostra prima classe, con attributi e metodi...Cosa manca?\n",
    "\n",
    "**L'instanziazione** di un oggetto"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Called automatically\n",
      "<__main__.Rocket object at 0x7fc03c1cea58>\n"
     ]
    }
   ],
   "source": [
    "my_rocket = Rocket()\n",
    "print(my_rocket)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Esercizio\n",
    "\n",
    "Create un Rocket.\n",
    "Ciascun Rocket deve poter essere inizializzato, devo poterne modificare successivamentealtezza e distanza (y e x).\n",
    "\n",
    "**N.B.** NON POTETE USARE LE CLASSI"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'x': 1, 'y': 1}\n"
     ]
    }
   ],
   "source": [
    "def rocket_change_x(rocket):\n",
    "    rocket['x']+=1\n",
    "    return rocket\n",
    "\n",
    "def rocket_change_y(rocket):\n",
    "    rocket['y']+=1\n",
    "    return rocket\n",
    "    \n",
    "rocket = {}\n",
    "rocket['x'] = 0\n",
    "rocket['y'] = 0\n",
    "\n",
    "rocket = rocket_change_x(rocket)\n",
    "rocket = rocket_change_y(rocket)\n",
    "print(rocket)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Il metodo __init__()\n",
    "\n",
    "Il metodo **\\__init__()** viene chiamato automaticamente quando create un oggetto di una determinata classe. Quando lo andiamo a definire occorre prestare attenzione a inizializzare tutti i campi che il nostro oggetto dovrà avere.\n",
    "\n",
    "La keyword **self** si riferisce all'oggetto con cui stiamo lavorando, ogni metodo che creeremo all'interno della nostra classe dovrà passare come parametro self, tranne alcuni casi che vedremo dopo."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Esercizio\n",
    "\n",
    "Ripetete l'esercizio precedente utilizzando il costrutto **class** .\n",
    "    \n",
    "    Challenge: Costruire 5 razzi in una sola riga di codice"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Esercizio\n",
    "- Stampare ciascun oggetto Rocket \n",
    "- Stampare il valore y di ciascun oggetto Rocket"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Accettare parametri da parte di un metodo\n",
    "\n",
    "Quanto visto fino ad ora ci permette di creare Rocket con posizione predefinita. Ma se noi intercettassimo un Rocket che è già in viaggio? Come possiamo fare per inizializzare un Rocket che abbia una posizione diversa da quella (0,0)?\n",
    "\n",
    "Modifichiamo leggermente il metodo \\__init()__ .\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "class Rocket:\n",
    "    \n",
    "    def __init__(self, x=0, y=0):\n",
    "        # Each rocket has an (x,y) position.\n",
    "        self.x = x\n",
    "        self.y = y        "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "5 7\n",
      "0 0\n"
     ]
    }
   ],
   "source": [
    "my_rocket = Rocket(5,7)\n",
    "print(my_rocket.x, my_rocket.y)\n",
    "my_rocket = Rocket()\n",
    "print(my_rocket.x, my_rocket.y)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Esercizio Person\n",
    "\n",
    "- definire la classe Person\n",
    "- inizializzare l'istanza con età, nome, cognome e luogo di nascita\n",
    "- creare il metodo presentati() che stampa le informazioni di ogni persona\n",
    "- creare il metodo invecchia() che incremente di uno l'eta della persona (challenge: salvare la data di nascita e calcolare l'età ogni volta)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Esercizio Car\n",
    "- definire la classe Car\n",
    "- inizializzare l'istanza con marca, modello, anno di immatricolazione e targa\n",
    "- scrivete un metodo, qualsiasi"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Ereditarietà\n",
    "\n",
    "Uno degli obiettivi più importanti dell'approccio orientato agli oggetti è la creazione di un codice stabile, affidabile e riutilizzabile. \n",
    "Se dovessi creare una nuova classe per ogni tipo di oggetto che volevi modellare, difficilmente avresti alcun codice riutilizzabile.\n",
    "\n",
    "In Python e in qualsiasi altro linguaggio che supporti OOP, una classe può ereditare da un'altra classe. Ciò significa che puoi basare una nuova classe su una classe esistente; la nuova classe eredita tutti gli attributi e il comportamento della classe su cui è basata.\n",
    "\n",
    "Una nuova classe può ignorare qualsiasi attributo o comportamento indesiderato della classe da cui eredita e può aggiungere nuovi attributi o comportamenti appropriati. La classe originale è chiamata classe padre e la nuova classe è figlia della classe padre. \n",
    "La classe padre è anche chiamata superclasse e la classe figlia è anche chiamata sottoclasse.\n",
    "\n",
    "La classe figlia eredita tutti gli attributi e il comportamento dalla classe padre, ma tutti gli attributi definiti nella classe figlio non sono disponibili per la classe genitore. \n",
    "**Questo può essere ovvio per molte persone, ma vale la pena affermarlo.**\n",
    "\n",
    "Ciò significa anche che una classe figlio può ignorare il comportamento della classe genitore. Se una classe figlio definisce un metodo che appare anche nella classe genitore, gli oggetti della classe figlio useranno il nuovo metodo piuttosto che il metodo della classe genitore.\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Classe SpaceShuttle \n",
    "\n",
    "Se volessi modellare uno space shuttle, potresti scrivere una classe completamente nuova. Ma uno space shuttle è solo un tipo speciale di razzo. Invece di scrivere una classe completamente nuova, è possibile ereditare tutti gli attributi e il comportamento di un missile, quindi aggiungere alcuni attributi e comportamenti appropriati per uno Shuttle.\n",
    "\n",
    "Una delle caratteristiche più significative di una navetta spaziale è che può essere riutilizzata. Quindi l'unica differenza che aggiungeremo a questo punto è di registrare il numero di voli completati dal shutttle. Tutto il resto che devi sapere su una navetta è già stato codificato nella classe Rocket.\n",
    "\n",
    "Ecco come si presenta la classe Shuttle:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Lo shuttle è in posizione 10-0 ed ha completato 3 voli\n"
     ]
    }
   ],
   "source": [
    "from math import sqrt\n",
    "\n",
    "class Rocket():    \n",
    "    def __init__(self, x=0, y=0):\n",
    "        # Each rocket has an (x,y) position.\n",
    "        self.x = x\n",
    "        self.y = y\n",
    "        \n",
    "    def move_rocket(self, x_increment=0, y_increment=1):\n",
    "        # Move the rocket according to the paremeters given.\n",
    "        #  Default behavior is to move the rocket up one unit.\n",
    "        self.x += x_increment\n",
    "        self.y += y_increment\n",
    "        \n",
    "    def get_distance(self, other_rocket):\n",
    "        # Calculates the distance from this rocket to another rocket,\n",
    "        #  and returns that value.\n",
    "        distance = sqrt((self.x-other_rocket.x)**2+(self.y-other_rocket.y)**2)\n",
    "        return distance\n",
    "    \n",
    "class Shuttle(Rocket):    \n",
    "    def __init__(self, x=0, y=0, flights_completed=0):\n",
    "        super().__init__(x, y)\n",
    "        self.flights_completed = flights_completed\n",
    "    def __str__(self):\n",
    "        return \"Lo shuttle è in posizione {}-{} ed ha completato {} voli\".format(self.x,self.y,self.flights_completed)\n",
    "        \n",
    "shuttle = Shuttle(10,0,3)\n",
    "print(shuttle)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Variabili e metodi di classe\n",
    "\n",
    "Definendo una classe in python è possibile a sua volta definire:\n",
    "\n",
    "- metodi di classe\n",
    "- variabili di classe\n",
    "\n",
    "Qui sotto un pratico esempio:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 53,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "class Employee:\n",
    "    empCount = 0\n",
    "\n",
    "    def __init__(self, name, salary):\n",
    "        self.name = name\n",
    "        self.salary = salary\n",
    "        Employee.empCount += 1\n",
    "   \n",
    "    def displayCount(self):\n",
    "        print (\"Total Employee %d\" % Employee.empCount)\n",
    "\n",
    "    def displayEmployee(self):\n",
    "        print (\"Name : \", self.name,  \", Salary: \", self.salary)\n",
    "        \n",
    "    @staticmethod\n",
    "    def how_may_employee():\n",
    "        return Employee.empCount\n",
    "\n",
    "    @classmethod\n",
    "    def create_from_string(cls, string_creation):\n",
    "        name,salary = string_creation.split()\n",
    "        return cls(name,int(salary))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 54,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0"
      ]
     },
     "execution_count": 54,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "Employee.how_may_employee()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 55,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1"
      ]
     },
     "execution_count": 55,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "c = Employee(\"pippo\", 50000)\n",
    "Employee.how_may_employee()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 56,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "2"
      ]
     },
     "execution_count": 56,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "c2 = Employee.create_from_string(\"ppiero 30000\")\n",
    "Employee.how_may_employee()"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.4.3"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 0
}