python中的一些函数相关的知识

局部变量和全局变量效率测试

局部变量的查询和访问速度较快

尤其是循环的时候使用局部变量会具有更高的效率 

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中的一切都是对象

所有的赋值操作都是引用的赋值

具体操作又分为两种 

1. 对于可变对象进行写操作 直接作用于 原对象本身
2. 对于不可变对象进行写操作 会产生一个新的对象空间 并用新的值填充这块空间

可变对象	字典、列表、集合、自定义的对象等
不可变对象	数字、字符串、元组、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])

# 不可变对象里面包含了可变对象 我们去修改的时候仍然是修改的原来的子对象