L'ereditarietà è il meccanismo che consente di riutilizzare codice già esistente organizzato in classi: grazie ad essa possiamo creare nuove classi che estendono e modificano quelle esistenti. Esemplifichiamo il funzionamento, considerando una classe Punto2D, che estendiamo per ottenere un Punto3D:

import math

class Punto2D:
 def __init__(self, x, y):
  self.x = x
  self.y = y 
 def dist(self):
  return math.sqrt(self.x **2 + self.y **2)

class Punto3D(Punto2D):
  def __init__(self, x, y, z):
  Punto2D.__init__(self, x, y):
    self.z = z
  def dist(self):
    return math.sqrt(Punto2D.dist(self)**2 + self.z**2)

Per ereditare da una classe si usa la sintassi class Derivata(Base1,Base2), dove Derivata è la classe che eredita dalle classi Base1 , Base2. Nell'esempio di sopra è mostrato un caso di ereditarietà singola ma Python supporta in generale l'ereditarietà multipla. La nuova classe eredita tutti i metodi delle classi base, il che significa che un metodo disponibile in una Base1 o Base2 è disponibile anche nella classe Derivata. Un metodo può trovarsi anche in più di una delle classi base: in tal caso viene usato il metodo trovato effettuando una ricerca deep-first nel grafo delle classi.

La cosa importante è che ereditando possiamo ridefinire i metodi della classe base, come si vede nell'esempio, dove il metodo dist di Punto3D ridefinisce il metodo dist di Punto2D. Per accedere ai metodi della classe base (operazione necessaria per sfruttare il codice preesistente) si deve far riferimento esplicitamente al metodo chiamandolo con il nome della classe e passando self come parametro. Nell'esempio si nota come vengano chiamati esplicitamente Punto2D.dist e Punto2D.__init__. Infine accenniamo al fatto che Python supporta anche l'operator overloading: è possibile per esempio ridefinire l'operatore + definendo il metodo __sum__, l'operatore * ridefinendo il metodo __mult__ e così via. Non trattiamo in dettaglio queste caratteristiche per ragioni di spazio.