python中的类变量

其他 2018-05-16 10:22:36 阅读次数: 3

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类变量的理解。

类成员

面试官错在，上面的代码在语法上是对的。
我错在，这句并不是为一个成员变量设置初始值，而是定义一个类变量，其初始值为空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就是通过这样的机制防止'私有'的变量被访问到。



作者：大蟒传奇
链接：https://www.jianshu.com/p/3aca78a84def
來源：简书
著作权归作者所有。商业转载请联系作者获得授权，非商业转载请注明出处。

猜你喜欢

转载自blog.csdn.net/feng98ren/article/details/80068036
今日推荐
面壁智能发布 Eurux-8x22B 开源大模型 —— 堪称「理科状元」
开源日报 | 谷歌扶持鸿蒙上位；开源Rabbit R1；Docker加持的安卓手机；微软的焦虑和野心；海尔电器把开放平台关了
中国码农的“35岁魔咒”
蘭雅 CorelDRAW 插件 2024.5.1 国际劳动节版，免费下载
Arc Browser for Windows 1.0 正式 GA
90后程序员开发视频搬运软件、不到一年获利超 700 万，结局很刑！
周排行
【转】spring中对控制反转和依赖注入的理解
tms webcore 安装和使用
java程序员进阶相关书籍
SpringMVC接受请求参数、
如何保存训练好的机器学习模型
MyEclipse、Eclipse设置项目JDK的三个地方
商超行业微信小程序开发定制一般多少钱 （行业技术人员解读）
Markdown编辑器语言——30分钟入门到到精通
Linux系统下MongoDB的简单安装与基本操作
Power Strings
每日归档
更多
2024-05-07(14)
2024-05-06(40)
2024-05-05(0)
2024-05-04(7)
2024-05-03(19)
2024-05-02(0)
2024-05-01(4)
2024-04-30(1)
2024-04-29(40)
2024-04-28(0)

代码天地 © 2018 codetd.com

境外服务器   最新电视剧2022