Python 简单易懂测试（三）：测试浅复制、深复制，lambda匿名函数，测试参数的类型，递归函数的基本原理运用

亦凉 2022-12-19 09:27 108阅读 0赞

[Python 简单易懂测试（二）：测试全局变量、局部变量，两变量的效率，嵌套函数，参数的传递、传递可变与不可变对象，对其修改影响][Python]

[Python 简单易懂测试（四）：测试嵌套函数（内部函数）的定义，测试nonlocal、global关键字的用法][Python _nonlocal_global]

1.  测试浅复制、深复制，对两者深入了解
2.  测试lambda表达式、匿名函数
3.  测试参数的类型：位置参数、默认值参数、命名参数
4.  测试递归函数的基本原理
5.  使用递归函数，计算阶乘

> 测试浅复制、深复制，对两者深入了解

# 测试浅拷贝、深拷贝
    import copy
    
    def testCopy():
        '''测试浅拷贝'''
        a = [10, 20, [5, 6]]
        b = copy.copy(a)
    
        print(id(a),"a:", a) 
        print(id(b),"b:", b)
    
        b.append(30) #  b添加了30，a是否也是同样添加了？
        b[2].append(7) 
        print("浅拷贝.....")
        print(id(a),"a:", a) # 可见，浅复制就是，改变原有对象会对新对象同样发生改变
        print(id(b),"b:", b)
    
    testCopy()
    print("--"*10)
    
    def testDeepCopy():
        '''测试深拷贝'''
        a = [10, 20, [5, 6]]
        b = copy.deepcopy(a)
    
        print(id(a),"a:", a)
        print(id(b),"b:", b)
    # 改变原有被复制对象不会对已经复制出来的新对象产生影响，
    # 新对象是一个独立的个体，就是深复制
        b.append(30)
        b[2].append(7)
        print("深拷贝.....")
        print(id(a),"a:", a)
        print(id(b),"b:", b)
    
    testDeepCopy()

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NDc3NTI1NQ_size_16_color_FFFFFF_t_70_pic_center]

> 测试lambda表达式、匿名函数

# 测试lambda表达式、匿名函数
    
    f = lambda a,b,c,d:a*b*c*d      
    g = [lambda a:a*2,lambda b:b*3] # lambda匿名函数
    
    print("使用lambda函数：",f(2,3,4,5))
    print("g的结果：",g[1](6))
    
    print("-"*15)
    def test01(a,b,c,d):
        return a*b*c*d
    
    h = [test01,test01]    # 函数也是对象，可以调用
    print(h[0](3,4,5,6),h[1](3,4,5,6))

![在这里插入图片描述][20201106182605315.png_pic_center]

> 测试参数的类型：位置参数、默认值参数、命名参数

# 测试参数的类型：位置参数、默认值参数、命名参数
    def test01(a,b,c,d):
        print("{0}-{1}-{2}-{3}".format(a,b,c,d))
    
    test01(10,20,30,40)   # 位置参数
    # test01(10,20)   # 参数个数不匹配，报错
    test01(d=20,b=40,a=10,c=100)   # 命名参数，通过形参名称来匹配
    
    
    def test02(a,b,c=10,d=15):     # 默认值参数，必须位于其他参数后面！
        print("{0}-{1}-{2}-{3}".format(a, b, c, d))
        
    test02(2,3)
    test02(2,3,4) # c会覆盖掉默认值参数

![在这里插入图片描述][20201106180912369.png_pic_center]

> eval() 函数简单应用

# 测试eval()函数，去除双引号，可计算执行
    s = "print('可输出')"
    eval(s)
    
    a = 10
    b = 20
    c = eval("a+b")
    print(c)
    
    dict1 = dict(a=100,b=200)
    
    d = eval("a+b",dict1) # 执行➕运算
    e = eval("a*b",dict1) # 执行*运算
    print("{0},{1}".format(d,e))

![在这里插入图片描述][20201106183430440.png_pic_center]

> 测试递归函数的基本原理

# 测试递归函数的基本原理
    
    def test01(n):
        print("test01:",n) #  1️⃣ 函数从这一行开始执行 依次输出 4 3 2 1 0
        if n==0:        #   2️⃣ 非0
            print("over") #  4️⃣ 当n==0输出
        else:
            test01(n-1) #  3️⃣ 执行test(4-1),然后调用第4行代码，直到 n==0;
        print("test01***",n) #  5️⃣ 依次输出 0 1 2 3 4
    
    test01(4) # 开始执行

![在这里插入图片描述][20201106184915693.png_pic_center]

> 使用递归函数，计算阶乘

# 使用递归函数，计算阶乘
    def factorial(n):
        if n==1:
            return 1
        else:
            return n*factorial(n-1)
            
    result = factorial(5)
    print(result)

[Python]: https://blog.csdn.net/weixin_44775255/article/details/109533689
[Python _nonlocal_global]: https://blog.csdn.net/weixin_44775255/article/details/109537437
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NDc3NTI1NQ_size_16_color_FFFFFF_t_70_pic_center]: /images/20221120/63f5c2e51ee741a19ff95ae9ab5e1150.png
[20201106182605315.png_pic_center]: https://img-blog.csdnimg.cn/20201106182605315.png#pic_center
[20201106180912369.png_pic_center]: https://img-blog.csdnimg.cn/20201106180912369.png#pic_center
[20201106183430440.png_pic_center]: https://img-blog.csdnimg.cn/20201106183430440.png#pic_center
[20201106184915693.png_pic_center]: https://img-blog.csdnimg.cn/20201106184915693.png#pic_center