Diferencia entre tipo (obj) y obj .__ class__

Question

¿Cuál es la diferencia entre type(obj) y obj.__class__? ¿Existe alguna posibilidad de type(obj) is not obj.__class__?

Quiero escribir una función que funcione genéricamente en los objetos suministrados, utilizando un valor predeterminado de 1 en el mismo tipo que otro parámetro. ¿Qué variación, n. ° 1 o n. ° 2 a continuación, va a hacer lo correcto.

def f(a, b=None): 
    if b is None: 
    b = type(a)(1) # #1 
    b = a.__class__(1) # #2 

Answer 1

type(obj) y type.__class__ no se comportan de la misma para las clases de estilo antiguo:

>>> class a(object): 
...  pass 
... 
>>> class b(a): 
...  pass 
... 
>>> class c: 
...  pass 
... 
>>> ai=a() 
>>> bi=b() 
>>> ci=c() 
>>> type(ai) is ai.__class__ 
True 
>>> type(bi) is bi.__class__ 
True 
>>> type(ci) is ci.__class__ 
False 

Answer 2

clases de estilo antiguo son el problema, suspiro:

>>> class old: pass 
... 
>>> x=old() 
>>> type(x) 
<type 'instance'> 
>>> x.__class__ 
<class __main__.old at 0x6a150> 
>>> 

No es un problema en Python 3, ya que todas las clases son de nuevo cuño ahora ;-).

En Python 2, es una clase única de nuevo estilo si se hereda de otra clase de nuevo estilo (incluyendo object y los diversos tipos incorporados como dict, list, set, ...) o de forma implícita o explícita establece __metaclass__ a type.

Answer 3

Esta es una vieja pregunta, pero ninguna de las respuestas parece mencionar que. en el caso general, se ES posible para una clase de nuevo estilo para tener valores diferentes para type(instance) y instance.__class__:

class ClassA(object): 
    def display(self): 
     print("ClassA") 

class ClassB(object): 
    __class__ = ClassA 

    def display(self): 
     print("ClassB") 

instance = ClassB() 

print(type(instance)) 
print(instance.__class__) 
instance.display() 

Salida:

<class '__main__.ClassB'> 
<class '__main__.ClassA'> 
ClassB 

La razón es que ClassB es reemplazar el __class__ descriptor, sin embargo, el campo de tipo interno en el objeto no se cambia. type(instance) lee directamente desde ese campo de tipo, por lo que devuelve el valor correcto, mientras que instance.__class__ hace referencia al nuevo descriptor que reemplaza el descriptor original proporcionado por Python, que lee el campo de tipo interno. En lugar de leer ese campo de tipo interno, devuelve un valor codificado.