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

Il seguente uso di super()genera un 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 () genera TypeError , dove l'errore è spiegato dal fatto che la classe utente non è una nuova classe. Tuttavia, la classe sopra è una nuova classe, poiché eredita da object:

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

Cosa mi sto perdendo? Come posso usare super()qui?

Usando HTMLParser.__init__(self)invece di super(TextParser, self).__init__()avrebbe funzionato, ma vorrei capire TypeError.

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

Va bene, è il solito " super()non può essere usato con una classe vecchio stile".

Tuttavia, il punto importante è che il test corretto per "è un'istanza di nuovo stile (cioè un oggetto)?" è

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

e non (come nella domanda):

>>> isinstance(instance, object)
True

Per le classi , il test corretto "è questa una nuova classe" è:

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

Il punto cruciale è che con le 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 instancetipo, che non eredita da object. Fondamentalmente, una classe vecchio stile crea oggetti di tipo instance(mentre una nuova classe crea oggetti il ​​cui tipo è la classe stessa). Questo è probabilmente il motivo per cui l'istanza OldStyle()è una object: type()eredita da object(il fatto che la sua classe non erediti objectnon conta: le classi di vecchio stile costruiscono semplicemente nuovi oggetti di tipo instance). Riferimento parziale:https://stackoverflow.com/a/9699961/42973 .

PS: la differenza tra una nuova classe e una vecchia può essere vista anche 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

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

super () può essere utilizzato solo nelle classi new-style, il che significa che la classe root deve ereditare dalla classe 'object'.

Ad esempio, la classe superiore deve essere così:

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

non

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

Quindi, la soluzione è quella di chiamare direttamente il metodo init del genitore , in questo modo:

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

Puoi anche usare class TextParser(HTMLParser, object):. Questo rende TextParseruna classe di nuovo stile e super()può essere utilizzato.

Il problema è che ha superbisogno objectdi 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 un esame più attento si trova:

>>> type(myclass)
classobj

Ma:

>>> class newstyle(object): pass

>>> type(newstyle)
type    

Quindi la soluzione al tuo problema sarebbe ereditare dall'oggetto e da HTMLParser. Ma assicurati che l'oggetto arrivi per ultimo nelle classi MRO:

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

>>> myclass().os
True

Se guardi l'albero delle eredità (nella versione 2.6), HTMLParser eredita da SGMLParsercui eredita da ParserBasecui non eredita object. Vale a dire HTMLParser è una classe vecchio stile.

A proposito del tuo controllo isinstance, ho fatto un rapido test su ipython:

In [1]: classe A:
   ...: passa
   ...: 

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

Anche se una classe è una classe vecchio stile, è comunque un'istanza di object.

il modo corretto di fare sarà il seguente 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

FWIW e anche se non sono un guru di Python, ci sono riuscito

>>> class TextParser(HTMLParser):
...    def handle_starttag(self, tag, attrs):
...        if tag == "b":
...            self.all_data.append("bold")
...        else:
...            self.all_data.append("other")
...     
...         
>>> p = TextParser()
>>> p.all_data = []
>>> p.feed(text)
>>> print p.all_data
(...)

Mi hanno appena restituito i risultati dell'analisi, se necessario.