神刀安全网

python中类变量

最近我参加了一次面试,面试官要求用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类变量的理解。

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]
python中类变量

赋值

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

通过类来赋值

举个例子

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就是通过这样的机制防止’私有’的变量被访问到。

转载本站任何文章请注明:转载至神刀安全网,谢谢神刀安全网 » python中类变量

分享到:更多 ()

评论 抢沙发

  • 昵称 (必填)
  • 邮箱 (必填)
  • 网址