python 面向对象之变量

发布时间:2018-03-25 11:52:50编辑:admin阅读(4070)

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

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


    类变量的用途?

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


    看下面一段代码

    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的内存变量地址是一样的。所以有一个修改了,那么其他的都生效。



关键字