这两者之间是否存在实质性的区别:
class A(object):
foo = 5 # some default value
对比。
class B(object):
def __init__(self, foo=5):
self.foo = foo
如果你正在创建大量实例,那么这两种样式在性能或空间要求方面有什么区别吗?当你阅读代码时,你是否认为这两种样式的含义有显著不同?
这两者之间是否存在实质性的区别:
class A(object):
foo = 5 # some default value
对比。
class B(object):
def __init__(self, foo=5):
self.foo = foo
如果你正在创建大量实例,那么这两种样式在性能或空间要求方面有什么区别吗?当你阅读代码时,你是否认为这两种样式的含义有显著不同?
在定义类属性与实例属性时,语义上存在显著差异(除了性能方面的考虑):
例如:
>>> class A: foo = []
>>> a, b = A(), A()
>>> a.foo.append(5)
>>> b.foo
[5]
>>> class A:
... def __init__(self): self.foo = []
>>> a, b = A(), A()
>>> a.foo.append(5)
>>> b.foo
[]
int
和str
这样的类型,它们仍然与每个实例相关联,而不是与类相关联。 - Babuint
和str
也是以完全相同的方式共享的。您可以使用is
或id
轻松检查。或者只需查看每个实例的__dict__
和类的__dict__
即可。通常,不可变类型是否共享并不太重要。 - abarnerta.foo = 5
,那么在两种情况下都将看到 b.foo
返回 []
。 这是因为在第一种情况下,您正在用同名的新实例属性覆盖类属性 a.foo
。 - Konstantin Schubert区别在于类上的属性被所有实例共享,而实例上的属性则是唯一的。
如果从C++转来,类上的属性更像静态成员变量。
>>> class A(object): foo = 5
>>> a, b = A(), A()
>>> a.foo = 10
>>> b.foo
5
- Rafea.foo.append(5)
所做的是改变a.foo
引用的值,而a.foo = 5
则是将a.foo
变成一个新名称,指向值5
。因此,你最终得到了一个实例属性,它隐藏了类属性。在Alex的版本中尝试使用相同的a.foo = 5
,你会发现b.foo
没有改变。 - abarnertclass Bar(object):
## No need for dot syntax
class_var = 1
def __init__(self, i_var):
self.i_var = i_var
## Need dot syntax as we've left scope of class namespace
Bar.class_var
## 1
foo = Bar(2)
## Finds i_var in foo's instance namespace
foo.i_var
## 2
## Doesn't find class_var in instance namespace…
## So look's in class namespace (Bar.__dict__)
foo.class_var
## 1
类属性赋值
如果通过访问类来设置类属性,它将覆盖所有实例的值。
foo = Bar(2)
foo.class_var
## 1
Bar.class_var = 2
foo.class_var
## 2
如果通过访问实例来设置类变量,它将仅覆盖该实例的值。这实质上覆盖了类变量,并将其转换为一个只对该实例有效的实例变量。
foo = Bar(2)
foo.class_var
## 1
foo.class_var = 2
foo.class_var
## 2
Bar.class_var
## 1
何时使用类属性?
存储常量。由于类属性可以作为类本身的属性访问,因此通常可以将其用于存储整个类范围内、类特定的常量。
class Circle(object):
pi = 3.14159
def __init__(self, radius):
self.radius = radius
def area(self):
return Circle.pi * self.radius * self.radius
Circle.pi
## 3.14159
c = Circle(10)
c.pi
## 3.14159
c.area()
## 314.159
定义默认值。作为一个简单的例子,我们可以创建一个有界列表(即只能容纳一定数量的元素或更少),并选择将默认容量设置为10个项目。
class MyClass(object):
limit = 10
def __init__(self):
self.data = []
def item(self, i):
return self.data[i]
def add(self, e):
if len(self.data) >= self.limit:
raise Exception("Too many elements")
self.data.append(e)
MyClass.limit
## 10
由于在这里的评论和其他两个被标记为重复的问题中,所有人似乎都以同样的方式感到困惑,因此我认为值得在Alex Coventry's之上添加一个额外的答案。
像列表一样的可变类型是赋值一个值与是否共享无关。我们可以通过id
函数或is
操作符来证明这一点:
>>> class A: foo = object()
>>> a, b = A(), A()
>>> a.foo is b.foo
True
>>> class A:
... def __init__(self): self.foo = object()
>>> a, b = A(), A()
>>> a.foo is b.foo
False
(如果你想知道为什么我使用了object()
而不是5
,那是为了避免遇到另外两个问题,这里不想深入讨论;由于两个完全分开创建的5
实例可能会成为数字5
的同一实例。但是完全分开创建的object()
则不会。)
那么,为什么Alex的示例中a.foo.append(5)
会影响b.foo
,而我的示例中a.foo = 5
却不会呢?好吧,在Alex的示例中尝试a.foo = 5
,注意到它也没有影响b.foo
。
a.foo = 5
只是将a.foo
变成5
的名称。这不会影响b.foo
或任何其他名称,用于引用旧值的a.foo
。* 这有点棘手,因为我们正在创建一个隐藏类属性的实例属性,**但是一旦你理解了这一点,这里就没有复杂的事情发生。
希望现在很明显为什么Alex使用了列表:可以改变列表意味着更容易显示两个变量命名了同一个列表,并且在实际代码中更重要的是知道是否有两个列表或两个名称指向同一个列表。
* 对于像C ++这样的语言来说,人们的困惑在于在Python中,值不存储在变量中。值独立存在于自己的value-land中,变量只是值的名称,赋值只是为值创建新的名称。如果有帮助,请将每个Python变量视为shared_ptr<T>
而不是T
。
** 一些人利用这一点,使用类属性作为实例属性的“默认值”,实例可能设置也可能不设置。这在某些情况下可能很有用,但也可能会令人困惑,因此请小心使用。
还有一种情况。
类和实例属性是描述符。
# -*- encoding: utf-8 -*-
class RevealAccess(object):
def __init__(self, initval=None, name='var'):
self.val = initval
self.name = name
def __get__(self, obj, objtype):
return self.val
class Base(object):
attr_1 = RevealAccess(10, 'var "x"')
def __init__(self):
self.attr_2 = RevealAccess(10, 'var "x"')
def main():
b = Base()
print("Access to class attribute, return: ", Base.attr_1)
print("Access to instance attribute, return: ", b.attr_2)
if __name__ == '__main__':
main()
以上将输出:
('Access to class attribute, return: ', 10)
('Access to instance attribute, return: ', <__main__.RevealAccess object at 0x10184eb50>)
通过类或实例访问相同类型的实例返回不同的结果!
我在c.PyObject_GenericGetAttr definition中发现了一个很棒的post。
如果在对象MRO中组成的类的字典中找到属性,则检查要查找的属性是否指向数据描述符(即实现
__get__
和__set__
方法的类)。如果是,则通过调用数据描述符的__get__
方法(第28-33行)来解析属性查找。