super() solleva "TypeError: deve essere type, non classobj" per la classe new-style

Question

Il seguente uso di super() solleva un'eccezione TypeError: perché?

>>> from HTMLParser import HTMLParser 
>>> class TextParser(HTMLParser): 
...  def __init__(self): 
...   super(TextParser, self).__init__() 
...   self.all_data = [] 
...   
>>> TextParser() 
(...) 
TypeError: must be type, not classobj 

C'è una domanda simile su StackOverflow: Python super() raises TypeError, dove l'errore si spiega con il fatto che la classe utente non è un classe di nuovo stile. Tuttavia, la classe di cui sopra è un classe di nuovo stile, visto che eredita da object:

>>> isinstance(HTMLParser(), object) 
True 

Che cosa mi manca? Come posso usare super(), qui?

Utilizzare HTMLParser.__init__(self) invece di super(TextParser, self).__init__() funzionerebbe, ma mi piacerebbe capire l'errore TypeError.

PS: Joachim ha sottolineato che essere un'istanza di classe new-style non equivale a object. Ho letto il contrario molte volte, quindi la mia confusione (esempio di test di istanze di classi di nuovo stile basato sul test di istanza object: https://stackoverflow.com/revisions/2655651/3).

Answer 1

OK, è il solito "super() non può essere utilizzato con una classe vecchio stile ".

Tuttavia, il punto importante è che il criterio corretto per "è questo un nuovo stile esempio (cioè oggetto)?"È

>>> class OldStyle: pass 
>>> instance = OldStyle() 
>>> issubclass(instance.__class__, object) 
False 

e non (come nella questione):

>>> isinstance(instance, object) 
True 

Per classi, il corretto "Si tratta di una classe di nuovo stile" di prova è:

>>> issubclass(OldStyle, object) # OldStyle is not a new-style class 
False 
>>> issubclass(int, object) # int is a new-style class 
True 

Il punto cruciale è quello con classi vecchio stile, la classe di un'istanza e il suo tipo sono distinti. Qui, OldStyle().__class__ è OldStyle, che non eredita da object, mentre type(OldStyle()) è il tipo instance, che fa ereditare da object. Fondamentalmente, una classe vecchio stile crea solo oggetti di tipo instance (mentre una classe di nuovo stile crea oggetti il ​​cui tipo è la classe stessa). Questo è probabilmente il motivo per l'istanza OldStyle() è un object: i suoi type() eredita dal object (il fatto che la sua classe non non ereditare da object non conta: le classi vecchio stile semplicemente costruiscono nuovi oggetti di tipo instance). Riferimento parziale: https://stackoverflow.com/a/9699961/42973.

PS: La differenza tra una classe di nuovo stile e un vecchio-stile si può anche essere visto con:

>>> type(OldStyle) # OldStyle creates objects but is not itself a type 
classobj 
>>> isinstance(OldStyle, type) 
False 
>>> type(int) # A new-style class is a type 
type 

(classi vecchio stile sono non tipi, quindi non possono essere il tipo delle loro istanze).

Answer 2

Se si guarda l'albero di ereditarietà (in versione 2.6), HTMLParser eredita da SGMLParser che eredita da ParserBase che non eredita da object. Cioè HTMLParser è una classe vecchio stile.

Circa il vostro controllo con isinstance, ho fatto un test rapido in ipython:

 
In [1]: class A: 
    ...:  pass 
    ...: 

In [2]: isinstance(A, object) 
Out[2]: True 

Anche se una classe è classe di vecchio stile, è ancora un esempio di object.

Answer 3

super() può essere utilizzato solo nelle classi di nuovo stile, il che significa che la classe radice deve ereditare dalla classe 'oggetto'.

Ad esempio, la classe ha bisogno di essere in questo modo:

class SomeClass(object): 
    def __init__(self): 
     .... 

non

class SomeClass(): 
    def __init__(self): 
     .... 

Quindi, la soluzione è quella chiamata metodo init del genitore direttamente, come in questo modo:

class TextParser(HTMLParser): 
    def __init__(self): 
     HTMLParser.__init__(self) 
     self.all_data = [] 

Answer 4

È inoltre possibile utilizzare class TextParser(HTMLParser, object):. Questo rende TextParser a nuovo stile classe e super() può essere utilizzato.

Answer 5

il modo corretto di fare non sarà come in seguito nelle classi vecchio stile, che non ereditano da 'oggetto'

class A: 
    def foo(self): 
     return "Hi there" 

class B(A): 
    def foo(self, name): 
     return A.foo(self) + name 

Answer 6

Il problema è che ha bisogno di un superobject come un antenato:

>>> class oldstyle: 
...  def __init__(self): self.os = True 

>>> class myclass(oldstyle): 
...  def __init__(self): super(myclass, self).__init__() 

>>> myclass() 
TypeError: must be type, not classobj 

A ben un esame trova:

>>> type(myclass) 
classobj 

Ma:

>>> class newstyle(object): pass 

>>> type(newstyle) 
type  

---

Quindi la soluzione al vostro problema sarebbe quello di ereditare da oggetti come pure da HTMLParser. Ma assicuratevi che l'oggetto arrivi per ultimo nelle classi MRO:

>>> class myclass(oldstyle, object): 
...  def __init__(self): super(myclass, self).__init__() 

>>> myclass().os 
True