type(obj) 和 obj.__class__ 之间的区别

Question

type(obj) 和 obj.__class__ 有什么区别？ 是否有可能 type(obj) 不是 obj.__class__？

我想编写一个对所提供的对象通用的函数，使用与另一个参数相同类型的默认值 1。 下面的#1 或#2 哪种变体会做正确的事情？

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

Answer 1

这是一个老问题，但似乎没有一个答案提到这一点。 在一般情况下，新样式类可能有不同的type(instance)和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()

： ：

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

原因是 ClassB 覆盖了 __class__ 描述符，但对象中的内部类型字段并未更改。 type(instance) 直接从该类型字段读取，因此它返回正确的值，而 instance.__class__ 指的是新的描述符替换 Python 提供的原始描述符，这读取内部类型字段。 它不读取该内部类型字段，而是返回一个硬编码值。

Answer 2

旧式类是问题所在，叹息：

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

在 Python 3 中不是问题，因为现在所有类都是新式的;-)。

在Python 2中，只有当一个类继承自另一个新式类（包括object和各种内置类型，例如dict、>list、set、...) 或隐式或显式将 __metaclass__ 设置为 type。

Answer 3

对于 Python 2 中的旧样式类，type(obj) 和 type.__class__ 的行为不同：

>>> 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
>>> type(ci)
<type 'instance'>
>>> ci.__class__
<class __main__.c at 0x7f437cee8600>

对此进行了解释 文档中：

对于旧式类，语句 x.__class__ 提供 x 的类，但 type(x) 始终为 <代码><输入“实例”>。 这反映了这样一个事实：所有旧式实例（与其类无关）都是使用单个内置类型（称为实例）实现的。

Answer 4

代理对象（使用弱引用）有一个有趣的边缘情况：

>>> import weakref
>>> class MyClass:
...     x = 42
... 
>>> obj = MyClass()
>>> obj_proxy = weakref.proxy(obj)
>>> obj_proxy.x  # proxies attribute lookup to the referenced object
42
>>> type(obj_proxy)  # returns type of the proxy 
weakproxy
>>> obj_proxy.__class__  # returns type of the referenced object
__main__.MyClass
>>> del obj  # breaks the proxy's weak reference
>>> type(obj_proxy)  # still works
weakproxy
>>> obj_proxy.__class__  # fails
ReferenceError: weakly-referenced object no longer exists

Answer 5

仅供参考 - Django 就是这样做的。

>>> from django.core.files.storage import default_storage
>>> type(default_storage)
django.core.files.storage.DefaultStorage
>>> default_storage.__class__
django.core.files.storage.FileSystemStorage

作为一个认知能力有限的人，只是想弄清楚正在发生什么才能完成工作……这是令人沮丧的。

Answer 6

这将使您更好地理解差异：
概括：
classA.one、self.class.one 和 type(obj).one 是相同的。
self.one 和 obj.one 是相同的，并且它们在每个实例中都是不同的。

class classA:

    one = "One"

    def __init__(self, val):
        self.__class__.one = val

    def show(self, marker):
        print("{}: self.one= {}, self.__class__.one= {}, classA.one= {}, type(self).one = {}".format(marker, self.one, self.__class__.one, classA.one, type(self).one))


one = classA('A')

one.show('One')

two = classA('B')
two.one = 'C'

two.show('Two')
print("{}".format(type(two).one))

three = classA('C')
classA.one = 'D'
three.one = 'E'
three.__class__.one = 'F'
three.show('Three')
two.show('Two')
one.show('One')

One: self.one= A, self.__class__.one= A, classA.one= A, type(self).one = A
Two: self.one= C, self.__class__.one= B, classA.one= B, type(self).one = B
B
Three: self.one= E, self.__class__.one= F, classA.one= F, type(self).one = F
Two: self.one= C, self.__class__.one= F, classA.one= F, type(self).one = F
One: self.one= F, self.__class__.one= F, classA.one= F, type(self).one = F