Herència, mètodes especials, classes abstractes i genèrics. Els conceptes bàsics (definició, atributs, mètodes, @property, dataclasses) estan en clases.
Vegeu també: clases · errors (excepcions pròpies, que també hereten) · sort
Per a definir una classe que hereta d'una altra s'indica la classe pare entre parèntesis en la línia de definició de la classe:
class ClasseFilla(ClassePare):
pass- Podem afegir nous elements membres (atributs i mètodes) a la nova classe.
- En el constructor hem d'invocar el constructor de la superclasse amb
super().__init__(...). - Podem sobreescriure mètodes de la classe pare.
Exemple:
class SeleccionFutbol:
# Les variables que es declaren ací són atributs de classe ("estàtics"),
# compartits per totes les instàncies
q_elements = 0
def __init__(self, id: int, nombre: str, apellidos: str, edad: int):
self.id = id
self.nombre = nombre
self.apellidos = apellidos
self.edad = edad
# Accés a la variable estàtica a través del nom de la classe
SeleccionFutbol.q_elements += 1
def mostrar(self) -> None:
print("Selecció:", self.nombre)class Futbolista(SeleccionFutbol):
q_futbolistas = 0
def __init__(self, id=0, nombre="", apellidos="", edad=16, dorsal=1, demarcacion=""):
super().__init__(id, nombre, apellidos, edad)
Futbolista.q_futbolistas += 1
self.dorsal = dorsal
self.demarcacion = demarcacion
# Sobreescrivim el mètode de la classe pare
def mostrar(self) -> None:
print("Futbolista", self.nombre)
f = Futbolista(1, "David", "Albelda", 32, 6, "Pivot")
f.mostrar() # -> Futbolista David
SeleccionFutbol.q_elements # -> 1
isinstance(f, SeleccionFutbol) # -> True
issubclass(Futbolista, SeleccionFutbol) # -> True
⚠️ Si els atributs foren privats (self.__nombre), la classe filla no podria accedir-hi comself.__nombre(el name mangling el converteix en_SeleccionFutbol__nombre). Per a atributs que han d'usar les filles, millorself._nombre(protected) o una@property(veure clases). Getters/setters a l'estil Java (getNombre()) no són idiomàtics en Python.
Marca que un mètode sobreescriu un del pare: els comprovadors de tipus (mypy, pyright) avisen si el pare no el té (p. ex. per un error d'escriptura).
from typing import override
class Porter(Futbolista):
@override
def mostrar(self) -> None:
print("Porter", self.nombre)class A:
def hola(self): return "A"
class B(A):
def hola(self): return "B -> " + super().hola()
class C(A):
def hola(self): return "C -> " + super().hola()
class D(B, C):
pass
D().hola() # -> 'B -> C -> A'
[k.__name__ for k in D.__mro__] # -> ['D', 'B', 'C', 'A', 'object']super() segueix l'ordre de resolució de mètodes (MRO), no necessàriament "el pare directe".
__str__: representació "per a l'usuari"; s'invoca ambstr(obj),print(obj)i en f-stringsf"{obj}".__repr__: representació "per al programador" (idealment, codi que recrea l'objecte); s'usa en el REPL, en llistes i enf"{obj!r}". Si no hi ha__str__,str()usa__repr__.
# A la classe SeleccionFutbol
def __str__(self):
return f"{self.nombre}, {self.apellidos}"
def __repr__(self):
return f"{type(self).__name__}({self.id!r}, {self.nombre!r}, {self.apellidos!r}, {self.edad!r})"
# A la classe Futbolista
def __str__(self):
# retornem el str del pare i afegim el nostre
return f"{super().__str__()}, dorsal={self.dorsal}"f = Futbolista(1, "David", "Albelda", 32, 6)
print(f) # -> David, Albelda, dorsal=6
[f] # -> [Futbolista(1, 'David', 'Albelda', 32)]Aquest mètode s'invoca quan es comparen dos objectes amb ==. Imaginem el codi següent:
s1 = SeleccionFutbol(100, "David", "Albelda", 32)
s2 = SeleccionFutbol(100, "David", "Albelda", 32)
print("Són iguals", s1 == s2) # -> Són iguals FalseAixò ens retorna False donat que, encara que tinguen els mateixos valors, són instàncies distintes.
Però si escrivim el codi següent a la classe SeleccionFutbol:
def __eq__(self, altre):
if not isinstance(altre, SeleccionFutbol):
return NotImplemented # deixa que Python provi l'altra comparació / retorne False
return (self.id, self.nombre, self.apellidos, self.edad) == \
(altre.id, altre.nombre, altre.apellidos, altre.edad)Ara ja ens retornarà True.
⚠ Notes:
- Ara
==ja no compara referències: per a saber si són la mateixa instància cal usaris(s1 is s2->False). - En definir
__eq__, Python posa__hash__ = None: l'objecte deixa de ser hashable (no es pot posar en unsetni ser clau d'undict). Si cal, defineix també__hash__amb els mateixos camps:return hash((self.id, self.nombre, self.apellidos, self.edad)). - Una
@dataclassgenera__eq__(i__repr__) automàticament (veure clases).
| Mètode | S'invoca amb |
|---|---|
__lt__, __le__, __gt__... |
<, <=, >... (i per tant sorted()) |
__len__ |
len(obj) |
__getitem__ |
obj[i], i fa l'objecte iterable |
__iter__ |
for x in obj |
__contains__ |
x in obj |
__add__, __mul__... |
obj + altre, obj * altre... |
__call__ |
obj() |
__enter__ / __exit__ |
with obj: |
__bool__ |
if obj: |
from functools import total_ordering
@total_ordering # a partir de __eq__ i __lt__ genera la resta
class Equip:
def __init__(self, nom: str, jugadors: list[str]):
self.nom = nom
self.jugadors = jugadors
def __len__(self):
return len(self.jugadors)
def __iter__(self):
return iter(self.jugadors)
def __contains__(self, jugador):
return jugador in self.jugadors
def __eq__(self, altre):
return len(self) == len(altre)
def __lt__(self, altre):
return len(self) < len(altre)
e1 = Equip("València", ["Albelda", "Baraja", "Ayala"])
e2 = Equip("Llevant", ["Morales"])
len(e1) # -> 3
"Baraja" in e1 # -> True
list(e1) # -> ['Albelda', 'Baraja', 'Ayala']
e2 < e1, e1 >= e2 # -> (True, True)
max(e1, e2).nom # -> 'València'Una classe abstracta no es pot instanciar; obliga les filles a implementar certs mètodes.
from abc import ABC, abstractmethod
class Figura(ABC):
@abstractmethod
def area(self) -> float: ...
def descripcio(self) -> str: # mètode normal, heretat
return f"{type(self).__name__} d'àrea {self.area():.2f}"
class Cercle(Figura):
def __init__(self, r: float):
self.r = r
def area(self) -> float:
return 3.14159 * self.r ** 2
Figura() # TypeError: Can't instantiate abstract class Figura without an implementation for abstract method 'area'
Cercle(1).descripcio() # -> "Cercle d'àrea 3.14"Un Protocol defineix una interfície sense herència: qualsevol classe que tinga els mètodes la compleix (comprovat pel type checker).
from typing import Protocol
class TeArea(Protocol):
def area(self) -> float: ...
class Quadrat: # no hereta de TeArea
def __init__(self, c: float):
self.c = c
def area(self) -> float:
return self.c ** 2
def area_total(figures: list[TeArea]) -> float:
return sum(f.area() for f in figures)
area_total([Quadrat(2), Cercle(1)]) # -> 7.14159match pot comprovar el tipus i extraure atributs alhora:
def descriu(fig) -> str:
match fig:
case Cercle(r=0):
return "punt"
case Cercle(r=r):
return f"cercle de radi {r}"
case Quadrat(c=c) if c > 10:
return "quadrat gran"
case Quadrat():
return "quadrat"
case _:
return "desconegut"
descriu(Cercle(2)), descriu(Quadrat(20)), descriu(Quadrat(1))
# -> ('cercle de radi 2', 'quadrat gran', 'quadrat')💡 Amb
__match_args__ = ("r",)(lesdataclassel generen soles) es pot escriurecase Cercle(r):posicionalment.
Classes i funcions parametritzades per tipus, amb la sintaxi [T]:
class Pila[T]:
def __init__(self) -> None:
self._items: list[T] = []
def push(self, item: T) -> None:
self._items.append(item)
def pop(self) -> T:
return self._items.pop()
def __len__(self) -> int:
return len(self._items)
p = Pila[int]()
p.push(1)
p.push(2)
p.pop() # -> 2
len(p) # -> 1
def primer[T](items: list[T]) -> T: # funció genèrica
return items[0]
def maxim[T: (int, float)](a: T, b: T) -> T: # T restringit a int o float
return a if a > b else b
type Parell[T] = tuple[T, T] # àlies de tipus genèricAbans de 3.12 calia T = TypeVar("T") i class Pila(Generic[T]).