super () plantea "TypeError: debe ser type, no classobj" para la clase de estilo nuevo

El siguiente uso de super()plantea un error de tipo: ¿por qué?

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

Hay una pregunta similar en StackOverflow: Python super () plantea TypeError , donde el error se explica por el hecho de que la clase de usuario no es una clase de estilo nuevo. Sin embargo, la clase anterior es una clase de nuevo estilo, ya que hereda de object:

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

¿Qué me estoy perdiendo? ¿Cómo puedo usar super()aquí?

Usar en HTMLParser.__init__(self)lugar de super(TextParser, self).__init__()funcionaría, pero me gustaría entender el TypeError.

PD: Joachim señaló que ser una instancia de clase de estilo nuevo no es equivalente a ser un object. Leí lo contrario muchas veces, de ahí mi confusión (ejemplo de prueba de instancia de clase de nuevo estilo basada en objectprueba de instancia: https://stackoverflow.com/revisions/2655651/3 ).

Muy bien, es lo habitual " super()no se puede usar con una clase de estilo antiguo".

Sin embargo, el punto importante es que la prueba correcta para "¿es esta una instancia de nuevo estilo (es decir, un objeto)?" es

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

y no (como en la pregunta):

>>> isinstance(instance, object)
True

Para las clases , la prueba correcta de "es una clase de estilo nuevo" es:

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

El punto crucial es que con las clases de estilo antiguo, la clase de una instancia y su tipo son distintos. En este caso, OldStyle().__class__es OldStyleque no hereda de object, mientras que type(OldStyle())es el instancetipo, que no heredan de object. Básicamente, una clase de estilo antiguo solo crea objetos de tipo instance(mientras que una clase de estilo nuevo crea objetos cuyo tipo es la clase misma). Esta es probablemente la razón por la cual la instancia OldStyle()es object: type()hereda de object(el hecho de que su clase no herede de objectno cuenta: las clases de estilo antiguo simplemente construyen nuevos objetos de tipo instance). Referencia parcial:https://stackoverflow.com/a/9699961/42973 .

PD: La diferencia entre una clase de estilo nuevo y una de estilo antiguo también se puede ver 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

(las clases de estilo antiguo no son tipos, por lo que no pueden ser el tipo de sus instancias).

super () solo se puede usar en las clases de estilo nuevo, lo que significa que la clase raíz debe heredar de la clase 'objeto'.

Por ejemplo, la clase superior debe ser así:

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

no

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

Entonces, la solución es llamar directamente al método init del padre , de esta manera:

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

También puedes usar class TextParser(HTMLParser, object):. Esto hace TextParseruna nueva clase de estilo , y super()se puede usar.

El problema es que supernecesita objectun antepasado:

>>> 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 un examen más detallado, uno encuentra:

>>> type(myclass)
classobj

Pero:

>>> class newstyle(object): pass

>>> type(newstyle)
type    

Entonces, la solución a su problema sería heredar del objeto y de HTMLParser. Pero asegúrese de que el objeto venga último en las clases MRO:

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

>>> myclass().os
True

Si observa el árbol de herencia (en la versión 2.6), HTMLParserhereda de lo SGMLParserque hereda de ParserBaselo que no hereda object. Es decir, HTMLParser es una clase de estilo antiguo.

Sobre su verificación con isinstance, hice una prueba rápida en ipython:

En [1]: clase A:
   ...: pasar
   ...: 

En [2]: isinstance (A, objeto)
Fuera [2]: verdadero

Incluso si una clase es de estilo antiguo, sigue siendo una instancia de object.

la forma correcta de hacerlo será la siguiente en las clases de estilo antiguo que no hereda de 'objeto'

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

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

FWIW y aunque no soy un gurú de Python, me las arreglé con esto

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

Acabo de recibir los resultados del análisis según sea necesario.