最近我参加了一次面试，面试官要求用python实现某个api，一部分代码如下

class Service(object):
    data = []
    
    def __init__(self, other_data):
        self.other_data = other_data

面试官说:“ data = []这一行是错误的。”
我：“这没问题啊，为一个成员变量设定了初始值。”
面试官：“那么这段代码什么时候被执行呢？”
我：“我也不太清楚。为了不导致混乱还是把它删了吧”

于是把代码改成了下面这样

class Service(object):
    def __init__(self, other_data):
        self.data = []
        self.other_data = other_data

面试回来后再想想，我们都错了。问题出在对python类变量的理解。

类成员

面试官错在，上面的代码在语法上是对的。
我错在，这句并不是为一个成员变量设置初始值，而是定义一个类变量，其初始值为空list。
和我一样，很多人都知道类变量，但是并不完全理解。

区别

类变量是类的一个属性，而不是一个对象的属性。
举个例子来说明吧，class_var是一个类变量，i_var是一个实例变量

class MyClass(object):
    class_var = 1
    def __init__(self, i_var):
        self.i_var = i_var

所有MyClass的对象都能够访问到class_var，同时class_var也能被MyClass直接访问到

foo = MyClass(2)
bar = MyClass(3)

foo.class_var, foo.i_var
## 1, 2
bar.class_var, bar.i_var
## 1, 3
MyClass.class_var
## 1

这个类成员有点像Java或者C++里面的静态成员，但是又不一样。

类和对象的命名空间

这里需要简单了解一下python的命名空间。

python中，命名空间是名字到对象映射的结合，不同命名空间中的名字是没有关联的。这种映射的实现有点类似于python中的字典

根据上下文的不同，可以通过"."或者是直接访问到命名空间中的名字。举个例子

class MyClass(object):
    # 在类的命名空间内，不需要用"."访问
    class_var = 1
    
    def __init__(self, i_var):
        self.i_var = i_var

## 不在类的命名空间内，需要用"."访问
MyClass.class_var
## 1

python中，类和对象都有自己的命名空间，可以通过下面的方式访问。

>>> MyClass.__dict__
dict_proxy({'__module__': 'namespace', 'class_var': 1, '__dict__': <attribute '__dict__' of 'MyClass' objects>, '__weakref__': <attribute '__weakref__' of 'MyClass' objects>, '__doc__': None, '__init__': <function __init__ at 0x106cb9230>})
>>> a = MyClass(3)
>>> a.__dict__
{'i_var': 3}

当你名字访问一个对象的属性时，先从对象的命名空间寻找。如果找到了这个属性，就返回这个属性的值；如果没有找到的话，则从类的命名空间中寻找，找到了就返回这个属性的值，找不到则抛出异常。
举个例子

foo = MyClass(2)
## 在对象的命名空间中寻找i_var
foo.i_var
## 2

## 在对象的命名空间中找不到class_var，则从类的命名空间中寻找
foo.class_var
## 1

逻辑类似下面的代码

def instlookup(inst, name):
    if inst.__dict__.has_key(name):
        return inst.__dict__[name]
    else:
        return inst.__class__.__dict__[name]

赋值

有了上面的基础，就能了解怎样给类变量赋值了。

通过类来赋值

举个例子

foo = MyClass(2)
foo.class_var
## 1
MyClass.class_var = 2
foo.class_var
## 2

在类的命名空间内，设置
setattr(MyClass, 'class_var', 2)
需要说明的是，MyClass.dict返回的是一个dictproxy，这是不可变的，所以不能通过MyClass.__dict__['class_var']=2
的方式修改。之后在对象中访问class_var，得到返回值是2

通过对象来赋值

如果通过对象来给类变量赋值，将只会覆盖那个对象中的值。举个例子

foo = MyClass(2)
foo.class_var
## 1
foo.class_var = 2
foo.class_var
## 2
foo.__dict__
{'i_var': 2, 'class_var': 2}

MyClass.class_var
## 1
MyClass.__dict__
## dict_proxy({'__module__': 'namespace', 'class_var': 1, '__dict__': <attribute '__dict__' of 'MyClass' objects>, '__weakref__': <attribute '__weakref__' of 'MyClass' objects>, '__doc__': None, '__init__': <function __init__ at 0x10fa5d230>})

上面的代码在对象的命名空间内，加入了class_var属性，这时候，类的命名空间中的class_var属性并没有被改变，MyClass的其他对象的命名空间中并没有class_var这个属性，所以在其他对象中访问这个属性时，依然会返回类命名空间中的class_var，也就是1。

可变属性

假如类命名空间中的变量是可变的话，这时候会发生什么呢？
答案是，如果通过类的实例改变了变量，类变量也会发生改变，还是举个例子看看吧。

class Service(object):
    data = []
    def __init__(self, other_data):
        self.other_data = other_data

在上面的代码中，在Service的命名空间中定义一个data，其初始值为空list，现在通过对象来改变它

s1 = Service(['a', 'b'])
s2 = Service(['c', 'd'])
s1.data.append(1)

s1.data
## [1]
s2.data
## [1]

s2.data.append(2)

s1.data
## [1, 2]
s2.data
## [1, 2]

可以看到，如果属性是可变的，在对象中改变这个属性，将会影响到类的命名空间。
可以通过赋值防止对象改变类变量。

s1 = Service(['a', 'b'])
s2 = Service(['c', 'd'])

s1.data = [1]
s2.data = [2]

s1.data
## [1]
s2.data
## [2]

在上面的例子中，我们给s1加了一个data，所以Service中的data不受影响。

但是上面的做法也有问题，因为Service的对象很容易就改变了data，应该从设计上来来避免这个问题。我个人的意见是，如果要用一个类变量来为对象的变量设定初始值，不要使用可变类型来定义这个类变量。我们可以这样

class Service(object):
    data = None
    def __init__(self, other_data):
        self.other_data = other_data

当然，这样就要多花一点心思来处理None了。

使用

类变量有时候会很有用

存储常量

类变量可以用来存储常量，比如下面的例子

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

定义默认值

比如下面的例子

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

追踪类的所有对象

比如下面的例子

class Person(object):
    all_names = []

    def __init__(self, name):
        self.name = name
        Person.all_names.append(name)

joe = Person('Joe')
bob = Person('Bob')
print Person.all_names
## ['Joe', 'Bob']

深入底层

之前提到，类的命名空间在声明的时候就创建了。也就是说，对一个类，只会执行一次初始化，而对象每创建一次，就要初始化一次。举个例子

def called_class():
    print "Class assignment"
    return 2

class Bar(object):
    y = called_class()

    def __init__(self, x):
        self.x = x

## "Class assignment"

def called_instance():
    print "Instance assignment"
    return 2

class Foo(object):
    def __init__(self, x):
        self.y = called_instance()
        self.x = x

Bar(1)
Bar(2)
Foo(1)
## "Instance assignment"
Foo(2)
## "Instance assignment"

可以看到，Bar中的y被初始化了一次，而Foo中的y在每次生成新的对象时都要被初始化一次。
为了进一步的探究，我们使用Python disassembler

import dis

class Bar(object):
    y = 2

    def __init__(self, x):
        self.x = x

class Foo(object):
    def __init__(self, x):
        self.y = 2
        self.x = x

dis.dis(Bar)
##  Disassembly of __init__:
##  7           0 LOAD_FAST                1 (x)
##              3 LOAD_FAST                0 (self)
##              6 STORE_ATTR               0 (x)
##              9 LOAD_CONST               0 (None)
##             12 RETURN_VALUE

dis.dis(Foo)
## Disassembly of __init__:
## 11           0 LOAD_CONST               1 (2)
##              3 LOAD_FAST                0 (self)
##              6 STORE_ATTR               0 (y)

## 12           9 LOAD_FAST                1 (x)
##             12 LOAD_FAST                0 (self)
##             15 STORE_ATTR               1 (x)
##             18 LOAD_CONST               0 (None)
##             21 RETURN_VALUE

可以明显看到Foo.__init__执行了两次赋值操作，而Bar.__init__只有一次赋值操作。
那么在实际中这两种方式性能有没有差别呢？
这里需要说明的是，影响代码执行速度的因素是很多的。
不过在这里的简单例子应该还是能说明一些问题，使用python中timeit模块来进行测试。
为了方便，笔者使用ipython写一些测试代码。

In [1]: class Bar(object):
   ...:     y = 2
   ...:     def __init__(self, x):
   ...:         self.x = x
   ...: class Foo(object):
   ...:     def __init__(self, x):
   ...:         self.x = x
   ...:         self.y = 2

初始化测试

In [2]: %timeit Bar(2)
The slowest run took 8.17 times longer than the fastest. This could mean that an intermediate result is being cached.
1000000 loops, best of 3: 379 ns per loop
In [3]: %timeit Foo(2)
The slowest run took 8.10 times longer than the fastest. This could mean that an intermediate result is being cached.
1000000 loops, best of 3: 471 ns per loop

可以看到Bar的初始化比Foo的初始化要快了不少。
为什么会这样呢，一个合理的解释是：Bar对象初始化的时候执行了一次赋值，而Foo对象初始化时执行了两次赋值

赋值测试

In [4]: %timeit Bar(2).y = 15
The slowest run took 27.73 times longer than the fastest. This could mean that an intermediate result is being cached.
1000000 loops, best of 3: 430 ns per loop
In [5]: %timeit Foo(2).y = 15
1000000 loops, best of 3: 511 ns per loop

因为这里实际上执行了一次初始化操作，所以需要减掉之前的初始化值

Bar assignments: 430 - 379 = 51ns
Foo assignments: 511 - 471 = 40ns

看起来Foo的赋值操作比Bar的赋值操作要快一些。一个合理的解释是，在Foo的对象命名空间中能够直接找到(Foo(2).__dict__[y])这个属性，而在Bar的对象命名空间中找不到(Bar(2).__dict__[y])这个属性，然后就去Bar的类命令空间中找，这多出来的查找导致了性能的消耗。

虽然在实际中这样的性能差别几乎可以忽略不计，但是对于理解类中的变量和对象中的变量之间的差异还是有帮助的。

总结

在学习python的时候，了解类属性和对象属性还是很有必要的。
不过在工作中，为了保证不入坑，还是避免使用的好。

私有变量

额外说一点，python中并没有私有变量，但是通过取名可以部分实现私有变量的效果。

python文档中说，不希望被外部访问到的属性取名时，前面应该加上__，这不仅仅是个标志，而且是一种保护措施。比如下面的代码

class Bar(object):
    def __init__(self):
        self.__zap = 1

a = Bar()
a.__zap
## Traceback (most recent call last):
##   File "<stdin>", line 1, in <module>
## AttributeError: 'Bar' object has no attribute '__zap'

## 查看命名空间
a.__dict__
{'_Bar__zap': 1}
a._Bar__zap
## 1

可以看到，前面加了__的变量，被自动加上了前缀_Bar，python就是通过这样的机制防止'私有'的变量被访问到。