super () déclenche "TypeError: doit être de type, pas classobj" pour une classe de nouveau style

L'utilisation suivante de super()déclenche une TypeError: pourquoi?

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

Il y a une question similaire sur StackOverflow: Python super () déclenche TypeError , où l'erreur est expliquée par le fait que la classe utilisateur n'est pas une classe de nouveau style. Cependant, la classe ci-dessus est une classe de nouveau style, car elle hérite de object:

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

Qu'est-ce que je rate? Comment puis-je utiliser super(), ici?

Utiliser HTMLParser.__init__(self)au lieu de super(TextParser, self).__init__()fonctionnerait, mais je voudrais comprendre le TypeError.

PS: Joachim a souligné qu'être une instance de classe de nouveau style n'est pas équivalent à être un object. J'ai lu l'opposé plusieurs fois, d'où ma confusion (exemple de test d'instance de classe de nouveau style basé sur le objecttest d'instance: https://stackoverflow.com/revisions/2655651/3 ).

D'accord, c'est l'habituel " super()ne peut pas être utilisé avec une classe à l'ancienne".

Cependant, le point important est que le test correct pour "est-ce une instance de nouveau style (c'est-à-dire un objet)?" est

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

et non (comme dans la question):

>>> isinstance(instance, object)
True

Pour les classes , le test correct "est-ce une classe de nouveau style" est:

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

Le point crucial est qu'avec les classes à l'ancienne, la classe d'une instance et son type sont distincts. , Ici OldStyle().__class__est OldStyle, qui ne hérite de object, tout type(OldStyle())est le instancetype, qui ne hérite de object. Fondamentalement, une classe à l'ancienne crée simplement des objets de type instance(alors qu'une classe à nouveau style crée des objets dont le type est la classe elle-même). Ceci est probablement la raison pour laquelle l'instance OldStyle()est object: ses type()hérite de object(le fait que sa classe ne pas hériter de objectne compte pas: les classes de style ancien construisent simplement de nouveaux objets de type instance). Référence partielle:https://stackoverflow.com/a/9699961/42973 .

PS: La différence entre une classe de style nouveau et une classe de style ancien peut également être vue avec:

>>> 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

(les classes à l'ancienne ne sont pas des types, elles ne peuvent donc pas être le type de leurs instances).

super () ne peut être utilisé que dans les classes de nouveau style, ce qui signifie que la classe racine doit hériter de la classe 'object'.

Par exemple, la classe supérieure doit être comme ceci:

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

ne pas

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

Donc, la solution est d'appeler directement la méthode init du parent , comme ceci:

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

Vous pouvez également utiliser class TextParser(HTMLParser, object):. Cela crée TextParserune classe de nouveau style et super()peut être utilisé.

Le problème est qu'il a superbesoin d' objectun ancêtre:

>>> 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

En y regardant de plus près, on constate:

>>> type(myclass)
classobj

Mais:

>>> class newstyle(object): pass

>>> type(newstyle)
type    

Ainsi, la solution à votre problème serait d'hériter de l'objet ainsi que de HTMLParser. Mais assurez-vous que l'objet arrive en dernier dans les classes MRO:

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

>>> myclass().os
True

Si vous regardez l'arbre d'héritage (dans la version 2.6), HTMLParserhérite de SGMLParserqui hérite de ParserBasequi n'hérite pas de object. Ie HTMLParser est une classe à l'ancienne.

À propos de votre vérification avec isinstance, j'ai fait un test rapide en ipython:

Dans [1]: classe A:
   ...: passer
   ...: 

Dans [2]: isinstance (A, objet)
Sortie [2]: Vrai

Même si une classe est une classe à l'ancienne, c'est toujours une instance de object.

la bonne façon de faire sera comme suit dans les classes à l'ancienne qui n'hérite pas de 'object'

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

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

FWIW et bien que je ne sois pas un gourou de Python, je m'en suis sorti

>>> 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
(...)

Je viens de récupérer les résultats de l'analyse au besoin.