0Pricing
Python Academy · Lezione

Metodi magici: __str__ e __repr__

Implementi i metodi dunder per ottenere rappresentazioni leggibili degli oggetti.

Metodi magici: __str__ e __repr__ è una lezione Python Academy gratuita su CoddyKit. Questa è la lezione 4 di 4. Puoi leggere la lezione completa qui gratuitamente — poi esercitati direttamente nel browser con un editor di codice integrato e un tutor IA disponibile 24/7. Fa parte del percorso di apprendimento Python Academy, e i tuoi progressi si sincronizzano tra il web e l'app CoddyKit. Il corso Python Academy include 4 lezioni in totale.

Che cosa sono i metodi magici?

I metodi magici (dunder) sono metodi speciali con doppio carattere di sottolineatura che Python chiama in contesti specifici, ad esempio durante la stampa o il confronto.

class Foo:
    def __str__(self):
        return "I am Foo"

f = Foo()
print(f)        # I am Foo
print(str(f))   # I am Foo

__repr__: rappresentazione per gli sviluppatori

__repr__ dovrebbe restituire una stringa non ambigua che, idealmente, consenta di ricreare l'oggetto. Viene visualizzata nella REPL e utilizzata da repr().

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

    def __repr__(self):
        return f"Point({self.x}, {self.y})"

p = Point(3, 4)
print(repr(p))  # Point(3, 4)

__str__: rappresentazione per gli utenti

__str__ fornisce una stringa di facile lettura. print() e str() lo chiamano. Se non è presente, Python utilizza __repr__ come alternativa.

class Temperature:
    def __init__(self, celsius):
        self.celsius = celsius

    def __str__(self):
        return f"{self.celsius}°C"

    def __repr__(self):
        return f"Temperature({self.celsius})"

t = Temperature(100)
print(t)        # 100°C
print(repr(t))  # Temperature(100)

Quando viene chiamato ciascun metodo

__str__: print(), str()__repr__: REPL, repr(), contenitori che visualizzano i propri elementi.

class Item:
    def __str__(self): return "str"
    def __repr__(self): return "repr"

x = Item()
print(x)         # str
print([x])       # [repr]  ← list uses repr for elements

__format__ per la formattazione personalizzata

Definisca __format__ per controllare come il Suo oggetto viene visualizzato nelle f-string con specifiche di formato.

class Money:
    def __init__(self, amount):
        self.amount = amount

    def __format__(self, spec):
        if spec == "usd":
            return f"${self.amount:.2f}"
        return str(self.amount)

m = Money(9.5)
print(f"{m:usd}")  # $9.50

__bool__ per la valutazione booleana

__bool__ consente di valutare l'oggetto nei contesti booleani. Restituisca True o False.

class Bag:
    def __init__(self, items):
        self.items = items

    def __bool__(self):
        return len(self.items) > 0

b = Bag([])
if not b:
    print("Bag is empty")  # Bag is empty

__len__ per len()

__len__ rende possibile utilizzare len(obj). Viene utilizzato anche da __bool__ quando __bool__ non è definito.

class Stack:
    def __init__(self):
        self.data = []

    def push(self, v): self.data.append(v)

    def __len__(self):
        return len(self.data)

s = Stack()
s.push(1)
print(len(s))  # 1

__eq__ per l'uguaglianza

Definisca __eq__ per specificare quando due istanze sono uguali con ==.

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

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

print(Vector(1,2) == Vector(1,2))  # True

Abbinamento di __hash__ a __eq__

Quando definisce __eq__, Python imposta __hash__ su None, rendendo l'oggetto non hashable. Definisca anche __hash__ se deve utilizzare l'oggetto in set o dizionari.

class Point:
    def __init__(self, x, y): self.x, self.y = x, y
    def __eq__(self, o): return (self.x, self.y) == (o.x, o.y)
    def __hash__(self): return hash((self.x, self.y))

pts = {Point(1,2), Point(1,2)}
print(len(pts))  # 1

__add__ e l'aritmetica

Gli operatori aritmetici corrispondono ai metodi dunder: __add__ per +, __sub__ per - e così via.

class Vector:
    def __init__(self, x, y): self.x, self.y = x, y
    def __add__(self, o): return Vector(self.x+o.x, self.y+o.y)
    def __repr__(self): return f"Vector({self.x},{self.y})"

print(Vector(1,2) + Vector(3,4))  # Vector(4,6)

__getitem__ per l'indicizzazione

__getitem__ consente alla classe di supportare l'indicizzazione con parentesi quadre, come in obj[key].

class Matrix:
    def __init__(self, data):
        self.data = data

    def __getitem__(self, idx):
        return self.data[idx]

m = Matrix([[1,2],[3,4]])
print(m[0])     # [1, 2]
print(m[1][0])  # 3

Controllo rapido

Quale metodo dunder viene chiamato quando utilizza print(obj)?

Ripasso

I metodi magici conferiscono alle classi un comportamento idiomatico di Python. __repr__ è rivolto agli sviluppatori, mentre __str__ è rivolto agli utenti. Definisca __eq__, __hash__ e i dunder aritmetici per rendere gli oggetti pienamente funzionali.

Domande Frequenti

La lezione «Metodi magici: __str__ e __repr__» è gratuita?

Sì — il testo completo di «Metodi magici: __str__ e __repr__» è gratuito qui sul web. Per esercitarvi in modo interattivo (un editor di codice integrato e un tutor IA 24/7) e sbloccare il resto del corso Python Academy, passa a CoddyKit PRO. Il corso Python Academy include 4 lezioni in totale.

Cosa imparerò in «Metodi magici: __str__ e __repr__»?

Implementi i metodi dunder per ottenere rappresentazioni leggibili degli oggetti. Eserciti Python Academy con codice pratico che esegui direttamente nel browser, e un tutor IA 24/7 risponde alle tue domande mentre lavori sulla lezione.

Ho bisogno di esperienza per iniziare Python Academy?

Non è richiesta alcuna esperienza precedente. Python Academy su CoddyKit è strutturato per principianti e studenti avanzati, quindi puoi iniziare da qui o dall'inizio e procedere al tuo ritmo. Questa è la lezione 4 di 4.

Quanto tempo richiede la lezione «Metodi magici: __str__ e __repr__»?

La maggior parte delle lezioni CoddyKit richiede circa 5–10 minuti. Ogni lezione è breve e interattiva, quindi fai progressi costanti e riprendi esattamente da dove hai lasciato su web e app.

Posso scrivere ed eseguire codice in questa lezione Python Academy?

Sì. Ogni lezione Python Academy include un editor di codice integrato, quindi scrivi ed esegui codice reale direttamente nel tuo browser e ricevi feedback istantaneo dall'IA — nessuna configurazione locale necessaria.

Tutte le lezioni di questo corso

  1. Classi e metodo __init__
  2. Attributi di istanza e di classe
  3. Metodi di istanza e self
  4. Metodi magici: __str__ e __repr__
← Torna a Python Academy