python中的类变量和对象变量，以及传值传引用的探究

最新推荐文章于 2024-08-16 20:23:56 发布

戈扬

最新推荐文章于 2024-08-16 20:23:56 发布

阅读量1.1w

点赞数 15

分类专栏： PYTHON

PYTHON 专栏收录该内容

67 篇文章 20 订阅

订阅专栏

一、类变量

python中类变量和成员变量、局部变量总结

class Member():
    num=0 #类变量,可以直接用类调用，或用实例对象调用
    def __init__(self,x,y):
        self.x=x  #实例变量（成员变量）,需要它是在类的构造函数内以self.开头来定义的
        self.y=y
        self.fuc(self.x,self.y)

    def add(self):
        total=2  #局部变量
        self.vara=3  # 局部变量，虽是以self.给出，但并没有在构造函数中进行初始化
        self.varb=4
        fina=(self.x+self.y)*total
        return fina

    def fuc(self,a,b):
        self.varc=a #成员变量，他们在成员函数fuc()中定义，但是在构造函数中调用了fuc()函数
        self.vard=b

1.1 可变变量作为类变量：对于列表、字典、自定义类这些可变变量，如果将其作为类变量，则是传引用。即所有对象的类变量公用一个内存地址。

1.2不可变变量作为类变量：对于INT，STRING这种不可变变量，如果将其作为类变量，则是传值。即所有对象的类变量有各自的内存地址。

二、对象变量

2.1 不管是可变变量还是不可变变量，只要是放在构造函数中，则都是传值。即各个对象拥有自己的对象属性。

三、举例说明

(1) 一个类的三个对象实例的属性被同时修改

代码如下：

class task_queue:
    queue=[]
    
    def append(self,obj):
        self.queue.append(obj)
        
    def print_queue(self):
        print self.queue
        

if __name__=="__main__":
    a=task_queue()
    b=task_queue()
    c=task_queue()
    
    a.append('tc_1')
    
    a.print_queue()
    b.print_queue()
    c.print_queue()

我们期望在队列 a 中插入 tc_1，结果 b 和 c 也被同时操作了，这并不是我们所期望的

['tc_1']
['tc_1']
['tc_1']

这种行为很像静态变量的行为，可是 Python 中并没有 static 关键字，这是怎么回事？

(2) Java 和 C++ 中的 static 关键字有多种用法

其中，如果 static 去修饰一个类的属性，那么该属性就不是被各个对象所持有，而是一片公共的区域

利用这种方法，我们可以在构造函数中对一个静态变量 ++ 以查看它被实例化了多少次

class a(){
    static private count  
    public a(){
        this.count++
    }
    public static instance_count(){
        System.out.println(this.count)
    }
}

(3) 回到 Python

Python 中并没有访问限定符 static，这种机制在 Python 中被称为类的属性和对象的属性

第一段代码中的 queue 在类的声明中被初始化为空，这是类的属性

a.append() 之后，queue 中添加了 ‘tc_1’，而 b 和 c 获取的 queue 依然是公共的类的属性

如何让这个属性变为对象自己的呢？改动如下：

class task_queue:
    
    def __init__(self):
        self.queue=[]
    
    def append(self,obj):
        self.queue.append(obj)
        
    def print_queue(self):
        print self.queue

在构造对象实例时构造对象自己的属性 queue

['tc_1']
[]
[]

(4) 另一个例子

class a():  
    num = 0  

if __name__=="__main__":
    
    obj1 = a()  
    obj2 = a()   
    print obj1.num, obj2.num, a.num   
          
    obj1.num += 1  
    print obj1.num, obj2.num, a.num     
      
    a.num += 2  
    print obj1.num, obj2.num, a.num

实例化 obj1 和 obj2 的时候，他们都没有对属性 num 进行操作，所以打印出来的都是类 a 的属性 num，也就是 0

后来 obj1 对自己的 num 进行 +1 之后，与类的属性脱离了关系，属性 num 就变成对象 obj1 自己的属性，而 obj2 尝试打印属性 num 的时候还是从类的属性中去读取

第三段中，类的属性 +2 后，obj1.num 没有受到影响，而 obj2 尝试读取 num 属性时，依旧从类中去拿，所以它拿到的 num 是2

0 0 0
1 0 0
1 2 2

(5) 数字字符串元祖修改全局变量时需要加global,列表和字典则不需要。

a = [1,2]
c = {'q':1}
d = 5
e = 'qw'
f = (1,2,3)
def b():
    global d #数字 字符串 元祖 修改全局变量时需要加global,列表和字典则不需要。
    global e
    global f

    a[1] = 1
    a.append(7)

    c['b'] = 2

    d = d + 1

    e = e + 'rr'

    f = f + (222,)

    print (a)
    print (c)
    print (d)
    print (e)
    print (f)
b()

(6) python中的全局变量与局部变量

全局变量与局部变量两者的本质区别就是在于作用域，全局变量即在整个程序中，任何地方都可以访问。而局部变量，试着在函数内部声明的变量，当函数运行结束时，局部变量就会被内存释放。

例子：

1 name='zs'
2 def change():
3      name='ls'
4      change()
5 print(name)   #输出为：’zs'  函数内的name是一个局部变量，函数运行结束即消失

如果要修改全局变量，要在函数内部用关键字global声明。

1 name='zs'
2 def change():
3     global name
4     name='ls'
5 change()
6 print(name)     #输出为 ls

其实局部变量是有层次的，如果出现函数的嵌套，内层函数想调用外层的变量是，是不能用global声明的，因为外层的变量不叫全局变量。这时候如果想修改外层的变量，就得用到一个新的关键字：nonlocal

强行使用global变量会报错，下面代码可以自己运行试试

def fun():
    a = 3

    def fun2():
        global a
        a*= 2
        print(a)

    return fun2()
fun()

如果使用nonlocal就可以完美解决：

 1 def fun():
 2     a = 3
 3 
 4     def fun2():
 5         nonlocal a
 6         a*= 2
 7         print(a)
 8 
 9     return fun2()
10 fun()           #输出 6

例子请参考：

https://www.cnblogs.com/turtle-fly/p/3280610.html

作者：daijiguo
来源：CSDN
原文：https://blog.csdn.net/daijiguo/article/details/79736757
版权声明：本文为博主原创文章，转载请附上博文链接！