局部变量和全局变量效率测试
局部变量的查询和访问速度较快
尤其是循环的时候使用局部变量会具有更高的效率
import time
a = 1000
def test01():
start = time.time()
global a
for i in range(100000000):
a += 1
end = time.time()
print("耗时{0}".format(end-start))
def test02():
start = time.time()
c = 1000
for i in range(100000000):
c += 1
end = time.time()
print("耗时{0}".format(end-start))
test01()
test02()
# 耗时3.173107624053955
# 耗时2.180661201477051
参数的传递 传递可变对象 内存分析
参数的传递
从实际参数 到形式参数的赋值效果 先要记住一个点就是python中的一切都是对象
所有的赋值操作都是引用的赋值
具体操作又分为两种
- 对于可变对象进行写操作 直接作用于 原对象本身
- 对于不可变对象进行写操作 会产生一个新的对象空间 并用新的值填充这块空间
可变对象 | 字典、列表、集合、自定义的对象等 |
不可变对象 | 数字、字符串、元组、function等 |
# 可变对象的引用怎么进行传递
b = [10,20]
def f2(m):
print("m:",id(m))
m.append(30)
f2(b)
print("b:",id(b))
# m: 1433029497216
# b: 1433029497216
# m 和 b 引用的是同一个对象
print(b)
# [10, 20, 30] # 因为m和b指向的是同一个对象 所以对m进行修改就相当于对b 进行修改
# 对于可变对象进来之后修改的是原对象
参数的传递 传递不可变对象 内存分析
不可变对象 int float 字符串 等
a = 100
def f1(n):
print("n:",id(n)) #传递进来的是a 对象的地址
print(n)
f1(a)
print("a:",id(a))
# n: 140722845976088
# 100
# a: 140722845976088
# 说明这里现在引用的是同一个对象
def f2(n):
print("n:",id(n)) #传递进来的是a 对象的地址
n = n+200
print("n:",id(n)) # n 已经变成了新的对象
print(n)
f2(a)
print("a:",id(a))
# n: 140722845976088
# n: 1934333685200
# 300
# a: 140722845976088
print(a)
# 100 # 这里的a没有发生变化还是100 只是n发生了变化变成了300
不可变对象进行写操作的时候会进行拷贝也就是创建新的对象
浅拷贝和深拷贝
shallow copy 浅拷贝就是做一个简单的拷贝 就是他的子对象还是之前的对象
就是相当于克隆了一个你但是你的家人没有进行克隆
deep copy 深拷贝 就相当于对你的全家都进行了拷贝
浅拷贝 拷贝对象 不拷贝子对象的内容 只拷贝子对象的引用
深拷贝 拷贝对象并且会连子对象的内存也全部(递归)拷贝一份,对子对象的修改不会影响原对象
# 测试浅拷贝和深拷贝
import copy # 导入一个模块
def testCopy():
'''测试浅拷贝'''
a = [10,20,[5,6]]
b = copy.copy(a) # 就是进行浅拷贝
print("a",a)
print("b",b)
b.append(30)
b[2].append(7)
print("浅拷贝……")
print("a",a)
print("b",b)
# a [10, 20, [5, 6]]
# b [10, 20, [5, 6]]
# 浅拷贝……
# a [10, 20, [5, 6, 7]]
# b [10, 20, [5, 6, 7], 30]
def testDeepCopy():
'''测试深拷贝'''
a = [10,20,[5,6]]
b = copy.deepcopy(a)
print("a", a)
print("b", b)
b.append(30)
b[2].append(7)
print("深拷贝……")
print("a", a)
print("b", b)
# a [10, 20, [5, 6]]
# b [10, 20, [5, 6]]
# 深拷贝……
# a [10, 20, [5, 6]]
# b [10, 20, [5, 6, 7], 30]
testCopy()
print("************")
testDeepCopy()
参数的传递 不可变对象含可变子对象 内存分析
传递不可变对象包含的子对象是可变的情况
不是很理解 这个地方就先记住不可变对象里面包含子对象是可以进行修改的
# 传递的不可变对象的子对象是可变的情况
# 传递不可变对象的时候 不可变对象里面包含的子对象是可变的 则方法内修改了这个可变对象 原对象也发生了变化
a = (10,20,[5,6])
print("a:",id(a))
def test01(m):
print("m:",id(m))
m[2][0] = 888
print(m)
print("m:",id(m))
test01(a)
print(a)
# a: 3011439107904
# m: 3011439107904
# (10, 20, [888, 6])
# m: 3011439107904
# (10, 20, [888, 6])
# 不可变对象里面包含了可变对象 我们去修改的时候仍然是修改的原来的子对象