super () gera "TypeError: deve ser do tipo, não classobj" para a classe de novo estilo

O seguinte uso de super()gera um TypeError: 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

Há uma pergunta semelhante no StackOverflow: Python super () gera TypeError , onde o erro é explicado pelo fato de a classe de usuário não ser uma classe de novo estilo. No entanto, a classe acima é uma classe de novo estilo, pois herda de object:

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

o que estou perdendo? Como posso usar super()aqui?

Usar em HTMLParser.__init__(self)vez de super(TextParser, self).__init__()funcionaria, mas eu gostaria de entender o TypeError.

PS: Joachim apontou que ser uma instância de nova classe de estilo não é equivalente a ser uma object. Eu li o contrário várias vezes, daí a minha confusão (exemplo de teste de instância de classe de novo estilo com base no objectteste de instância: https://stackoverflow.com/revisions/2655651/3 ).

Tudo bem, é o habitual " super()não pode ser usado com uma classe de estilo antigo".

No entanto, o ponto importante é que o teste correto para "esta é uma instância de novo estilo (ou seja, objeto)?" é

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

e não (como na pergunta):

>>> isinstance(instance, object)
True

Para as classes , o teste "é uma classe de novo estilo" correto é:

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

O ponto crucial é que, com classes de estilo antigo, a classe de uma instância e seu tipo são distintos. Aqui, OldStyle().__class__é OldStyle, que não herda de object, ao mesmo tempo type(OldStyle())é o instancetipo, que não herdam object. Basicamente, uma classe de estilo antigo apenas cria objetos do tipo instance(enquanto uma classe de estilo novo cria objetos cujo tipo é a própria classe). Provavelmente é por isso que a instância OldStyle()é uma object: type()herda de object(o fato de sua classe não herdar de objectnão conta: classes de estilo antigo apenas constroem novos objetos do tipo instance). Referência parcial:https://stackoverflow.com/a/9699961/42973 .

PS: A diferença entre uma classe de estilo novo e uma classe de estilo antigo também pode ser vista com:

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

(as classes de estilo antigo não são tipos, portanto, não podem ser o tipo de suas instâncias).

super () pode ser usado apenas nas classes de novo estilo, o que significa que a classe raiz precisa herdar da classe 'objeto'.

Por exemplo, a classe superior precisa ser assim:

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

não

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

Portanto, a solução é chamar o método init do pai diretamente, assim:

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

Você também pode usar class TextParser(HTMLParser, object):. Isso cria TextParseruma classe de novo estilo e super()pode ser usado.

O problema é que superprecisa de objectum ancestral:

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

Em um exame mais detalhado, encontra-se:

>>> type(myclass)
classobj

Mas:

>>> class newstyle(object): pass

>>> type(newstyle)
type    

Portanto, a solução para o seu problema seria herdar do objeto e do HTMLParser. Mas verifique se o objeto vem por último nas classes MRO:

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

>>> myclass().os
True

Se você olhar para a árvore de herança (na versão 2.6), HTMLParserherda da SGMLParserqual herda da ParserBasequal não herda object. Ou seja, HTMLParser é uma classe de estilo antigo.

Sobre a sua verificação isinstance, fiz um teste rápido no ipython:

Em [1]: classe A:
   ...: pass
   ...: 

Em [2]: isinstance (A, objeto)
Fora [2]: Verdadeiro

Mesmo que uma classe seja de estilo antigo, ainda é uma instância de object.

a maneira correta de fazer será a seguinte nas classes de estilo antigo que não herdam de 'objeto'

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

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

FWIW e, embora eu não seja um guru de Python, convivi com isso

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

Apenas recebi os resultados da análise, conforme necessário.