Python3.0理论之变量&内存地址

目录

全局变量与局部变量：

global全局变量声明：

内存地址：

赋值、浅拷贝与深拷贝：

---

全局变量与局部变量：

全局变量可作用于函数内，函数内的局部变量只能作用于函数内；

全局与局部变量同名，则函数优先调用局部变量；

全局变量与局部变量的内存地址不同，若函数内引用了全局变量，则内存地址即为全局变量的地址

a=1              #全局变量
def he(b):
    print(a+b)
he(10)
print(a)
>>> 11
>>> 1


a=1            #全局变量
def he(b):
    a=5        #局部变量
    print(a+b)
he(10)
print(a)
>>> 15
>>> 1

global全局变量声明：

a=1
def he(b):
    global a   #全局变量声明
    a=5
    print(a+b)
he(10)
print(a)
>>> 15
>>> 5

a=1
def he(b):
    global a   #全局变量声明
    a=a+5      #这里如果不事先声明a为全局变量则会报错,因为若等号左边的a为局部变量却没有事先定义好
    print(a+b)
he(10)
print(a)
>>> 16
>>> 6

内存地址：

# 每一次赋值，内存地址地址都会变化；列表、字典修改后内存地址不变，但是重新赋值地址也会变化

#在调用函数前后，形参和实参指向的是同一个对象（对象 id 相同），在函数内部修改形参后，形参指向的是不同的 id。

对照组一：

对照组二：

赋值、浅拷贝与深拷贝：

赋值：常量和元素引用对象的赋值会单独开辟内存空间；对象赋值则直接引用对象，内存地址一样。

浅拷贝：单独开辟内存空间存储被拷贝对象的值，而保持被拷贝对象的引用对象；引用对象或拷贝对象的引用部分改变了会互相影响；被拷贝对象或拷贝对象的常量部分不会互相影响。

深拷贝：单独开辟内存空间存储对象的值，不保持对象的引用，会递归查找所有引用对象的值存入自己的内存；原对象或拷贝对象改变了不会互相影响。

示例1：

a=[] #可修改数据
b=a # 对象赋值，直接引用，ab地址相同
a.append(1)
print("b的值：",b)
print("a的内存地址：",id(a))
print("b的内存地址：",id(b))

c=2 #不可修改数据
d=c
print("c的内存地址：",id(c))
print("d的内存地址：",id(d))
c=3 #常量赋值，内存地址变化
print("c的值：",c)
print("d的值：",d)
print("新c的内存地址：",id(c))
print("再看d的内存地址：",id(d)) #d保持2这个常数的引用，所以地址不变
输出：
b的值： [1]
a的内存地址： 27985032
b的内存地址： 27985032
c的内存地址： 2046556096
d的内存地址： 2046556096
c的值： 3
d的值： 2
新c的内存地址： 2046556112
再看d的内存地址： 2046556096

示例2：

from copy import deepcopy,copy
a=['a']
b=[a,"b"] # 赋值，第一元素引用a对象，ab地址不同
c=copy(b) # 浅拷贝
c[0].append("c") #c[0]引用了a，所以也会影响a的值
d=deepcopy(b)#深拷贝
d[0].append("d") #d[0]没有引用a，不影响a的值
a.append(1) #a值变化，所有引用了a的对象也会变化
b.append(2) #b值变化，不影响c、d
print("a的内存地址：",id(a))
print("b的内存地址：",id(b))
print("c的内存地址：",id(c))
print("d的内存地址：",id(d))
print("a的值：",a)
print("b的值：",b)
print("c的值：",c)
print("d的值：",d)
输出：
a的内存地址： 33621128
b的内存地址： 33993992
c的内存地址： 33993832
d的内存地址： 33994024
a的值： ['a', 'c', 1]
b的值： [['a', 'c', 1], 'b', 2]
c的值： [['a', 'c', 1], 'b']
d的值： [['a', 'c', 'd'], 'b']