python 面向对象之变量

发布时间：2018-03-25 11:52:50编辑：admin阅读（4839）

类变量：类变量在整个实例化的对象中是公用的。类变量定义在类中且在函数体之外。类变量通常不作为实例变量使用。

实例变量：定义在方法中的变量，只作用于当前实例的类。




类变量的用途？

大家公共的属性，节省开销




看下面一段代码

class Role(object): #类名
    n1 = 123 #类变量
    # 构造函数，在实例化时做一些类的初始化工作
    def __init__(self, ...):
        #实例变量(静态属性)，作用域就是实例本身
        self.name = name
        pass

    def shot(self): #类的方法(动态属性)
        print("shooting...")

r1 = Role('Jack',...) #Role对象的实例
r2 = Role('Rore',...)

r1的name变量是不能给r2使用的，因为作用域只能是实例本身




类变量和实例变量的区别

class Role(object):
    n = 123
    def __init__(self, name):
        self.name = name

    def shot(self):
        print("shooting...")

#打印类变量
print(Role.n)

执行输出：123




从这段代码可以看出，类还没有实例化，就可以直接打印类变量了。那么类变量存在哪里呢？

是存在类的内存里面


class Role(object):
    n = 123
    def __init__(self, name):
        self.name = name

    def shot(self):
        print("shooting...")

r1 = Role('jack')
r2 = Role('rose')

print(r1.n,r1.name)
print(r2.n,r2.name)

执行输出：

123 jack

123 rose




可以看出，实例化之后，也可以打印类变量




在类里面定义个同名变量name

class Role(object):
    n = 123
    name = "我是类name"
    def __init__(self, name):
        self.name = name

    def shot(self):
        print("shooting...")

r1 = Role('jack')
r2 = Role('rose')

print(r1.n,r1.name)
print(r2.n,r2.name)

执行输出：

123 jack

123 rose




为什么新定义的name变量，没有打印出来呢？

因为优先级不一样，实例化之后，先找实例本身的，如果找不到，就去类里面找。


从上面例子可以看出,name是在实例本身的,输出jack

n不在实例本身里面，所以从类里面找到了n，输出123




实例变量优先于类变量




实例化之后，可不可修改实例变量呢？当然可以啊，请看下面的例子

class Role(object):
    n = 123
    name = "我是类name"
    def __init__(self, name):
        self.name = name

    def shot(self):
        print("shooting...")

r1 = Role('jack')
#修改实例变量
r1.name = "Newton"

print(r1.n,r1.name)

执行输出：

123 Newton




实例化之后，还可以增加一个变量

class Role(object):
    n = 123
    name = "我是类name"
    def __init__(self, name):
        self.name = name

    def shot(self):
        print("shooting...")

r1 = Role('jack')
#修改实例变量
r1.name = "Newton"
#增加实例变量
r1.age = 21

print(r1.n,r1.name,r1.age)

执行输出：

123 Newton 21




实例化之后，是做什么事情呢？

比如 r1 = Role('jack')

就相当于

def __init__(self, name):
    self.name = name #相当于r1.name = name

把name传给了实例

所增加变量的时候，也同样是给实例做了赋值操作

r1.age = age




删除一个实例变量

class Role(object):
    n = 123
    name = "我是类name"
    def __init__(self, name):
        self.name = name

    def shot(self):
        print("shooting...")

r1 = Role('jack')
#修改实例变量
r1.name = "Newton"
#增加实例变量
r1.age = 21
#删除实例变量
del r1.age

print(r1.n,r1.name,r1.age)

执行报错

AttributeError: 'Role' object has no attribute 'age'




修改类变量

class Role(object):
    n = 123
    name = "我是类name"
    def __init__(self, name):
        self.name = name

    def shot(self):
        print("shooting...")

r1 = Role('jack')
r2 = Role('rose')
#修改类变量
r1.n = "改变变量"

print(r1.n,r1.name)
print(r2.n,r2.name)

执行输出：

改变变量 jack

123 rose




为什么r2没有改变呢？

是因为r1实例化之后，执行了r1.n = "改变变量"，就相当于在r1实例里面，加了一个实例变量n = "改变变量"

它和类变量n=123不是同一个，虽然是同名的，根据查询原则，优先查找实例变量，再去找类变量。

所以输出了

改变变量 jack




r2实例化之后，去查找变量n，发现没有，就去类变量找，最后输出

123 rose




下面升级一下，直接修改类变量，再查看r1和r2 n的值

class Role(object):
    n = 123
    name = "我是类name"
    def __init__(self, name):
        self.name = name

    def shot(self):
        print("shooting...")

r1 = Role('jack')
r2 = Role('rose')
#修改类变量
r1.n = "改变变量"
#不实例化,直接修改类变量
Role.n = "ABC"

print(r1.n,r1.name)
print(r2.n,r2.name)

执行输出：

改变变量 jack

ABC rose




为什么r2的n变量改了，r1的没有改呢？

是因为r1的n变量，是实例变量，优先级高于类变量，所以输出时，不受影响。




class Role(object):
    n = 123
    n_list = []
    name = "我是类name"
    def __init__(self, name):
        self.name = name

    def shot(self):
        print("shooting...")

r1 = Role('jack')
r2 = Role('rose')
#修改类变量
r1.n = "改变变量"
#不实例化,直接修改类变量
Role.n = "ABC"
#增加一个列表元素
r1.n_list.append("from r1")
r2.n_list.append("from r2")
#打印r1,r2,类 变量n_list
print(r1.n,r1.n_list)
print(r2.n,r2.n_list)
print(Role.n_list)

执行输出：

改变变量 ['from r1', 'from r2']

ABC ['from r1', 'from r2']

['from r1', 'from r2']




发现n_list都是一样的,为什么呢?因为n_list的内存变量地址是一样的。所以有一个修改了,那么其他的都生效。

关键字：