added operator isinstance in section 09

Author: hifly81

09_oop.ipynb

@@ -169,7 +169,7 @@
     "\n",
     "L'**incapsulamento** è un principio fondamentale dell'OOP che consiste nel nascondere i dettagli interni di un oggetto e proteggerne i dati dall'accesso diretto ed esterno. In Python, usiamo delle convenzioni per indicare che un attributo non dovrebbe essere modificato direttamente:\n",
     "- Un singolo underscore (`_`) suggerisce che l'attributo è **protetto** (`_attributo_protetto`).\n",
-    "- Un doppio underscore (`__`) rende l'attributo **privato** (`__attributo_privato`) usando una tecnica chiamata `name mangling`.\n"
+    "- Un doppio underscore (`__`) rende l'attributo **privato** (`__attributo_privato`) usando una tecnica chiamata `name mangling`."
    ]
   },
   {
@@ -189,21 +189,83 @@
     "            self.__saldo += importo\n",
     "            print(f\"Deposito di {importo} euro. Nuovo saldo: {self.__saldo}\")\n",
     "\n",
-    "    def get_saldo(self):\n",
-    "        # Metodo pubblico per accedere in modo controllato al saldo\n",
-    "        return self.__saldo\n",
+    "    def get_saldo(self, pin):\n",
+    "        # Metodo pubblico per accedere in modo controllato al saldo, magari con un PIN\n",
+    "        if pin == \"1234\": # Esempio semplice\n",
+    "            return self.__saldo\n",
+    "        else:\n",
+    "            return \"PIN errato!\"\n",
     "\n",
     "conto = ContoBancario(100)\n",
     "conto.deposita(50)\n",
     "\n",
     "# Tentare di accedere direttamente fallirà (genera un errore)\n",
     "# print(conto.__saldo) # Questo causerebbe un AttributeError\n",
-    "print(f\"Il saldo tramite il metodo get_saldo è: {conto.get_saldo()}\")"
+    "print(f\"Il saldo tramite il metodo get_saldo è: {conto.get_saldo('1234')}\")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "---"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "b73c734e",
+   "metadata": {},
+   "source": [
+    "## 5. L'operatore `isinstance()`: Controllo del Tipo 🤔\n",
+    "\n",
+    "L'operatore integrato `isinstance()` è una funzione molto utile per verificare se un oggetto è un'**istanza** di una determinata classe o di una delle sue sottoclassi.\n",
+    "\n",
+    "**Sintassi:**\n",
+    "```python\n",
+    "isinstance(oggetto, classe)\n",
+    "```\n",
+    "- `oggetto`: L'istanza che vuoi verificare.\n",
+    "- `classe`: La classe (o una tupla di classi) rispetto a cui vuoi fare la verifica.\n",
+    "\n",
+    "La funzione ritorna `True` se l'oggetto è del tipo specificato (o di una delle sue sottoclassi), altrimenti `False`.\n",
+    "\n",
+    "Python, essendo un linguaggio a tipizzazione dinamica, incoraggia il cosiddetto **duck typing** (se un oggetto cammina come un'anatra e starnazza come un'anatra, allora è un'anatra), basato sul comportamento dell'oggetto (cioè sui metodi che ha). Tuttavia, `isinstance()` è indispensabile in diverse situazioni:\n",
+    "\n",
+    "- Quando hai bisogno di agire in modo diverso in base al **tipo esatto** di un oggetto.\n",
+    "- Per verificare che un oggetto sia conforme a un'**interfaccia** o a una classe astratta specifica.\n",
+    "- Per garantire la compatibilità con librerie esterne che si aspettano tipi specifici.\n",
+    "\n",
+    "È importante usare `isinstance()` con parsimonia per evitare una **proliferazione eccessiva** di controlli sul tipo, che può rendere il codice rigido e meno `pythonico`. La flessibilità del polimorfismo è spesso la soluzione migliore, ma `isinstance()` è lo strumento giusto quando serve un controllo più preciso sul tipo di dato in gioco.\n",
+    "\n",
+    "**Esempio:**\n",
+    "```python\n",
+    "class Veicolo:\n",
+    "    pass\n",
+    "\n",
+    "class Auto(Veicolo):\n",
+    "    pass\n",
+    "\n",
+    "mia_auto = Auto()\n",
+    "mia_moto = Veicolo()\n",
+    "\n",
+    "# Verifica se mia_auto è un'istanza della classe Auto\n",
+    "print(isinstance(mia_auto, Auto))      # Output: True\n",
+    "\n",
+    "# Verifica se mia_auto è un'istanza della classe Veicolo\n",
+    "# Ritorna True perché Auto è una sottoclasse di Veicolo\n",
+    "print(isinstance(mia_auto, Veicolo))   # Output: True\n",
+    "\n",
+    "# Verifica se un oggetto è di uno dei tipi specificati\n",
+    "print(isinstance(mia_auto, (int, str, Auto))) # Output: True\n",
+    "\n",
+    "# Verifica se una stringa è un'istanza di Auto\n",
+    "print(isinstance(\"testo\", Auto))       # Output: False\n",
+    "```"
    ]
   },
   {
    "cell_type": "markdown",
-   "id": "5f5817ea",
+   "id": "c5de76d0",
    "metadata": {},
    "source": [
     "---"
@@ -214,7 +276,7 @@
    "id": "c5de76d0",
    "metadata": {},
    "source": [
-    "## 5. Polimorfismo: Tante Forme, Stesso Comportamento 🎭\n",
+    "## 6. Polimorfismo: Tante Forme, Stesso Comportamento 🎭\n",
     "\n",
     "Il **polimorfismo** permette a oggetti di classi diverse di rispondere in modo specifico allo stesso metodo. Questo rende il tuo codice più flessibile e facile da estendere."
    ]
@@ -258,7 +320,7 @@
    "id": "f92678a7",
    "metadata": {},
    "source": [
-    "## 6. Classi Astratte 📝\n",
+    "## 7. Classi Astratte 📝\n",
     "\n",
     "Una **classe astratta** serve come modello e non può essere istanziata direttamente. Contiene uno o più **metodi astratti** (metodi senza implementazione), che devono essere obbligatoriamente implementati da qualsiasi sottoclasse che eredita da essa. Questo garantisce una struttura comune per tutte le classi derivate.\n",
     "\n",
@@ -318,7 +380,10 @@
     "### Esercizio 4: Polimorfismo in azione (Concetti Avanzati)\n",
     "Crea una lista che contiene un oggetto `Leone` e un oggetto `Mucca` (dall'esercizio precedente). Scorri la lista con un ciclo `for` e chiama il metodo `verso()` su ogni oggetto.\n",
     "\n",
-    "### Esercizio 5: Incapsulamento con un `Prodotto` (Concetti Avanzati)\n",
+    "### Esercizio 5: Usare `isinstance()`\n",
+    "Data la lista `elementi = [10, \"ciao\", Cane(\"Fido\", \"Labrador\"), 50.5]`, scrivi un ciclo `for` che scorra la lista. Se l'elemento è di tipo `Cane`, stampa il suo nome. Altrimenti, stampa un messaggio generico come \"Non è un cane.\".\n",
+    "\n",
+    "### Esercizio 6: Incapsulamento con un `Prodotto` (Concetti Avanzati)\n",
     "Crea una classe `Prodotto` con un attributo privato `__prezzo`. Il costruttore deve accettare un prezzo iniziale. Aggiungi un metodo `get_prezzo()` per leggere il prezzo e un metodo `set_sconto()` che applica uno sconto al prezzo solo se lo sconto è tra 0 e 100."
    ]
   },
@@ -451,12 +516,39 @@
     "    animale.verso()"
    ]
   },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### Soluzione Esercizio 5: Usare `isinstance()`"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "class Cane:\n",
+    "    def __init__(self, nome, razza):\n",
+    "        self.nome = nome\n",
+    "        self.razza = razza\n",
+    "\n",
+    "elementi = [10, \"ciao\", Cane(\"Fido\", \"Labrador\"), 50.5]\n",
+    "\n",
+    "for elemento in elementi:\n",
+    "    if isinstance(elemento, Cane):\n",
+    "        print(f\"Trovato un cane! Si chiama {elemento.nome}.\")\n",
+    "    else:\n",
+    "        print(f\"Non è un cane. È un {type(elemento)}.\")"
+   ]
+  },
   {
    "cell_type": "markdown",
    "id": "7b95316c",
    "metadata": {},
    "source": [
-    "### Soluzione Esercizio 5: Incapsulamento con un `Prodotto`"
+    "### Soluzione Esercizio 6: Incapsulamento con un `Prodotto`"
    ]
   },
   {
@@ -508,4 +600,4 @@
  },
  "nbformat": 4,
  "nbformat_minor": 5
-}
+}