È necessario o utile ereditare dall'oggetto di Python in Python 3.x?


94

Nella versione precedente di Python, quando crei una classe in Python, può ereditare da object che è per quanto ne so uno speciale elemento Python integrato che consente al tuo oggetto di essere un oggetto di nuovo stile.

E la versione più recente (> 3.0 e 2.6)? Ho cercato su Google l'oggetto della classe ma ottengo così tanti risultati (per ovvie ragioni). Qualche suggerimento?

Grazie!


2
Se il tuo codice verrà utilizzato anche sotto 2.x, è bene essere espliciti.
smci

1
E 'ben risolta in questa domanda: stackoverflow.com/questions/4015417/...
nngeek

Risposte:


94

Non è necessario ereditare da objectper avere un nuovo stile in Python 3. Tutte le classi sono di nuovo stile.


5
Si noti che questo significa che tutte le classi ereditano da objectindipendentemente dal fatto che si digiti un esplicito (object)o meno in Python 3.1
u0b34a0f6ae

8
Non è necessario, ma il "Porting del codice Python su Python 3" dice che è ancora valido: docs.python.org/py3k/howto/pyporting.html#subclass-object Inoltre: docs.python.org/reference/ ...
iperboreo

Da questo post menzionato nel commento di nngeek, sembra che un buon riferimento stabile per il vecchio e il nuovo stile (rilevante solo per Py2) sia: docs.python.org/2/reference/… - i collegamenti sopra sembravano avere da allora è cambiato.
Eric Cousineau,

80

Mi rendo conto che questa è una vecchia domanda, ma vale la pena notare che anche in Python 3 queste due cose non sono esattamente la stessa cosa.

Se erediti esplicitamente da object, ciò che stai effettivamente facendo è ereditare da builtins.object indipendentemente da ciò a cui punta in quel momento.

Pertanto, potrei avere un modulo (molto stravagante) che sovrascrive l'oggetto per qualche motivo. Chiameremo questo primo modulo "newobj.py":

import builtins

old_object = builtins.object  # otherwise cyclic dependencies

class new_object(old_object):

    def __init__(self, *args, **kwargs):
        super(new_object, self).__init__(*args, **kwargs)
        self.greeting = "Hello World!" 

builtins.object = new_object  #overrides the default object

Quindi in qualche altro file ("klasses.py"):

class Greeter(object):
    pass

class NonGreeter:
    pass

Quindi in un terzo file (che possiamo effettivamente eseguire):

import newobj, klasses  # This order matters!

greeter = klasses.Greeter()
print(greeter.greeting)  # prints the greeting in the new __init__

non_greeter = klasses.NonGreeter()
print(non_greeter.greeting) # throws an attribute error

Quindi puoi vedere che, nel caso in cui erediti esplicitamente da un oggetto, otteniamo un comportamento diverso da quello in cui permetti l'ereditarietà implicita.


14
È rilevante perché in generale l'aspettativa è che il comportamento sia equivalente. Non è equivalente, da qui le mie osservazioni.
Philip Adler,
Utilizzando il nostro sito, riconosci di aver letto e compreso le nostre Informativa sui cookie e Informativa sulla privacy.
Licensed under cc by-sa 3.0 with attribution required.