OOP Avanzata

Programmazione a Oggetti (Avanzata)

Basato su: Manuale Python per principianti (freeCodeCamp)

---

🎯 Obiettivi del Modulo

• ✅ Polimorfismo e duck typing
• ✅ Overloading degli operatori (metodi speciali)
• ✅ Docstring per documentare
• ✅ Introspezione degli oggetti
• ✅ Type hints e annotazioni

---

📅 Lezione 1 — Polimorfismo

Contenuti (dal manuale, sezione “Polimorfismo in Python”)

1. Polimorfismo: stessa interfaccia per tipi diversi
2. Duck typing: “se cammina come un’anatra e starnazza come un’anatra…”
3. Metodi con stesso nome in classi diverse

Attività (esercizi)

class Cane:
    def fai_verso(self):
        return "Bau!"

class Gatto:
    def fai_verso(self):
        return "Miao!"

class Mucca:
    def fai_verso(self):
        return "Muu!"

# Polimorfismo: stessa chiamata, comportamento diverso
animali = [Cane(), Gatto(), Mucca()]
for animale in animali:
    print(animale.fai_verso())

Riferimenti

• Manuale → sezione Polimorfismo in Python

---

📅 Lezione 2 — Overloading operatori

Contenuti (dal manuale, sezione “Overloading degli operatori in Python”)

1. Metodi speciali (dunder) per personalizzare gli operatori
2. __str__, __repr__: rappresentazione
3. __add__, __sub__: + e -
4. __eq__, __lt__: confronti
5. __len__: lunghezza

Attività (esercizi)

class Punto2D:
    def __init__(self, x, y):
        self.x = x
        self.y = y

    def __str__(self):
        return f"P({self.x}, {self.y})"

    def __add__(self, altro):
        return Punto2D(self.x + altro.x, self.y + altro.y)

    def __eq__(self, altro):
        return self.x == altro.x and self.y == altro.y

p1 = Punto2D(3, 4)
p2 = Punto2D(1, 2)
p3 = p1 + p2
print(p3)
print(p1 == Punto2D(3, 4))

Riferimenti

• Manuale → sezione Overloading degli operatori in Python

---

📅 Lezione 3 — Docstring e Introspezione

Contenuti (dal manuale, sezioni “Docstring in Python” e “Introspezione in Python”)

1. Docstring: """...""" per documentare
2. Accesso: funzione.__doc__, help(funzione)
3. Introspezione: esaminare oggetti a runtime
4. dir(), type(), isinstance(), hasattr(), getattr()

Attività (esercizi)

def somma(a, b):
    """Restituisce la somma di a e b."""
    return a + b

print(somma.__doc__)
help(somma)

# Introspezione su un oggetto
s = "Ciao"
print(type(s))
print(isinstance(s, str))
print(hasattr(s, "upper"))
print(dir(s))  # tutti i metodi disponibili

Riferimenti

• Manuale → sezioni Docstring in Python e Introspezione in Python

---

📅 Lezione 4 — Annotazioni (Type Hints)

Contenuti (dal manuale, sezione “Annotazioni in Python”)

1. Type hints: nome: tipo, def f(x: int) -> str:
2. from typing import List, Dict, Optional, Tuple
3. Vantaggi: documentazione, mypy, IDE autocomplete

Attività (esercizi)

from typing import List, Optional

def media(voti: List[float]) -> float:
    """Calcola la media dei voti."""
    if not voti:
        return 0.0
    return sum(voti) / len(voti)

def trova_studente(id: int) -> Optional[str]:
    """Cerca studente per ID."""
    db = {1: "Alice", 2: "Bob"}
    return db.get(id)

print(media([28, 30, 25]))
print(trova_studente(1))

Riferimenti

• Manuale → sezione Annotazioni in Python

---

🏠 Esercizi per Casa

"""
ESERCIZIO 1: Overloading
Crea una classe Vettore2D con x, y.
Implementa __add__, __sub__, __mul__ (scalare),
__str__ e __eq__.
"""

"""
ESERCIZIO 2: Introspezione
Data una lista di oggetti misti (int, str, list, dict),
usa isinstance() per stampare il tipo di ognuno
e hasattr() per verificare metodi specifici.
"""

"""
ESERCIZIO 3: Type Hints
Riscrivi una funzione che hai scritto prima
aggiungendo type hints per parametri e return.
"""

---

📊 Verifica Apprendimento

Domanda	Risposta
Cos’è il duck typing?	”Se sembra un’anatra e starnazza…” — conta il comportamento, non il tipo
Metodo per personalizzare print() su un oggetto?	__str__
Metodo per personalizzare + ?	__add__
Come accedere alla docstring?	funzione.__doc__ o help(funzione)
Cosa fa dir(oggetto)?	Elenca tutti gli attributi e metodi
A cosa servono i type hints?	Documentazione, mypy, autocomplete