Python打卡十三——函数2

Python打卡（十三）

1、浅拷贝和深拷贝

浅拷贝：不拷贝子对象的内容，只是拷贝子对象的引用。
深拷贝：会连子对象的内存也全部拷贝一份，对子对象的修改不会影响源对象

'''
    测试浅拷贝和深拷贝
    浅拷贝只拷贝本人，而深拷贝拷贝一整个家庭
'''
import copy
def text_copy():
    a = [10,20,[5,6]]
    b = copy.copy(a)
    print("浅拷贝前：")
    print("a:",a)
    print("b:",b)
    b.append(30)
    b[2].append(7)
    print("浅拷贝后：")
    print("a:", a)
    print("b:", b)

text_copy()

def text_deepcopy():
    a = [10,20,[5,6]]
    b = copy.deepcopy(a)
    print("深拷贝前：")
    print("a:",a)
    print("b:",b)
    b.append(30)
    b[2].append(7)
    print("深拷贝后：")
    print("a:", a)
    print("b:", b)

text_deepcopy()

运行结果：

浅拷贝前：
a: [10, 20, [5, 6]]
b: [10, 20, [5, 6]]
浅拷贝后：
a: [10, 20, [5, 6, 7]]
b: [10, 20, [5, 6, 7], 30]
深拷贝前：
a: [10, 20, [5, 6]]
b: [10, 20, [5, 6]]
深拷贝后：
a: [10, 20, [5, 6]]
b: [10, 20, [5, 6, 7], 30]

浅拷贝与深拷贝内存示意图：
（1）浅拷贝

（2）深拷贝

传递不可变对象时。不可变对象里面包含的子对象是可变的。则方法内修改了这个可变对象，源对象也发生了变化

m =(10,20,[5,6])
print("id(m):",id(m))
def text_copyordeepcopy(n):
    '''传递不可变对象时。不可变对象里面包含的子对象是可变的。则方法内修改了这个可变对象，源对象也发生了变化'''
    print("id(n):",id(n))
    n[2][0] = 888
    print("n:",n)
    print("id(n):",id(n))

text_copyordeepcopy(m)
print("m:",m)

执行结果：

id(m): 2510032780488
id(n): 2510032780488
n: (10, 20, [888, 6])
id(n): 2510032780488
m: (10, 20, [888, 6])

2、参数类型

参数类型包括位置参数、默认值参数、命名参数、可变参数和强制命名参数，测试如下：

'''测试参数类型，包括位置参数，默认值参数，命名参数，可变参数和强制命名参数'''
def weizhicanshu(a,b,c):
    print("位置参数:a = {0} , b = {1} , c = {2}".format(a,b,c))

def morenzhicanshu(a,b,c=20,d=30): #默认值参数必须位于其他参数后面
    print("默认值参数:a = {0} , b = {1} , c = {2} , d = {3}".format(a,b,c,d))

def mingmingcanshu(a,b,c):
    print("命名参数:a = {0} , b = {1} , c = {2}".format(a, b, c))

'''
    可变参数指的是“可变数量的参数”。分两种情况：
    1. *param（一个星号），将多个参数收集到一个“元组”对象中。
    2. **param（两个星号），将多个参数收集到一个“字典”对象中。
'''
def kebiancanshu01(a,b,*c):
    print("可变参数:a = {0} , b = {1} , c = {2}".format(a, b, c))

def kebiancanshu02(a,b,**c):
    print("可变参数:a = {0} , b = {1} , c = {2}".format(a, b, c))


'''
    在带星号的“可变参数”后面增加新的参数，必须在调用的时候使用“强制命名参数”。
'''
def qiangzhimingmingcanshu(*a,b,c):
    print("强制命名参数:a = {0} , b = {1} , c = {2}".format(a, b, c))

weizhicanshu(1,2,3)
morenzhicanshu(5,6)
morenzhicanshu(5,6,7)
mingmingcanshu(c=10,a=90,b=30)
kebiancanshu01(2,3,4,5,6)
kebiancanshu02(2,3,name="renjialun",age="31",job="actor")
qiangzhimingmingcanshu(4,b=5,c=9)

运行结果：

位置参数:a = 1 , b = 2 , c = 3
默认值参数:a = 5 , b = 6 , c = 20 , d = 30
默认值参数:a = 5 , b = 6 , c = 7 , d = 30
命名参数:a = 90 , b = 30 , c = 10
可变参数:a = 2 , b = 3 , c = (4, 5, 6)
可变参数:a = 2 , b = 3 , c = {'name': 'renjialun', 'age': '31', 'job': 'actor'}
强制命名参数:a = (4,) , b = 5 , c = 9

3、lambma表达式

'''
        lambda 表达式可以用来声明匿名函数。lambda 函数是一种简单的、在同一行中定义函数
    的方法。lambda 函数实际生成了一个函数对象。
        lambda 表达式只允许包含一个表达式，不能包含复杂语句，该表达式的计算结果就是函数
    的返回值。
'''
f = lambda a,b,c:a*b*c
print(f(2,3,4))

g = [lambda a:a*2,lambda b:b*3]
print("g[0] = ",g[0](8))
print("g[1] = ",g[1](8))

def text_lambma(a,b,c):
    print("text_lambma:",end=" ")
    return a*b*c
k = [text_lambma,text_lambma]      #函数也是对象
print(k[0](2,3,4))

运行结果：

24
g[0] =  16
g[1] =  24
text_lambma: 24

4、eval()函数

语法： eval(source[, globals[, locals]]) -> value

'''
    测试eval()函数
        eval函数可以用来执行一段Python代码，此情况下直接返回Python代码的结果
    也可以用来计算表达式的值，此情况下返回的是表达式的值，若想得到结果还需使用print打印结果值
'''
s = "print('abcdef')"
eval(s)

a = 10
b = 20
c = eval("a+b")
print(c)

dict1 = dict(a = 100,b = 200)
d = eval("a+b",dict1)         #将dict1中的值作为字符串a+b的引用值
print(d)

运行结果：

abcdef
30
300

5、嵌套函数

'''
        嵌套函数就是在函数内部定义的函数
        使用嵌套函数可以：
    (1)封装实现数据隐藏，在外部函数体外部不可调用内部定义的函数
    (2)避免书写过多重复的代码
'''
#定义两个类似的函数实现两个功能
def printChineseName(familyName,name):
    print("普通函数中国：{0}{1}".format(familyName,name))
def printEnglishName(familyName,name):
    print("普通函数外国：{0}{1}".format(name,familyName))


#使用嵌套函数实现上述功能
def printName(isChinese,familyName,name):
    if isChinese:
        guojia = "中国"
    else:
        guojia = "外国"
    def inner_print(a,b):
        print("嵌套函数：{0}-{1}{2}".format(guojia,a,b))
    if isChinese:
        inner_print(familyName,name)
    else:
        inner_print(name,familyName)

printChineseName("任","嘉伦")
printEnglishName("任","嘉伦")
printName(True,"肉","骨茶")
printName(False,"肉","骨茶")

运行结果：

普通函数中国：任嘉伦
普通函数外国：嘉伦任
嵌套函数：中国-肉骨茶
嵌套函数：外国-骨茶肉

6、nonlocal

'''
    nonlocal是内部函数用来修改本函数局部变量的一种声明
'''
def outer():
    a = 100
    def inner():
        print("inner a:",a)
    inner()
    print("outer a:", a)

outer()

def outer02():
    a = 100
    def inner():
        nonlocal a
        print("inner a (before nonlocal):",a)
        a = 200
    inner()
    print("outer a (after nonlocal):", a)

outer02()

运行结果：

inner a: 100
outer a: 100
inner a (before nonlocal): 100
outer a (after nonlocal): 200

7、LEGB规则

Python 在查找“名称”时，是按照 LEGB 规则查找的：
Local–>Enclosed–>Global–>Built in
Local 指的就是函数或者类的方法内部
Enclosed 指的是嵌套函数（一个函数包裹另一个函数，闭包）
Global 指的是模块中的全局变量
Built in 指的是 Python 为自己保留的特殊名称。
如果都没有找到就会报错——NameError

'''
    Python 在查找“名称”时，是按照 LEGB 规则查找的：
    Local-->Enclosed-->Global-->Built in
        Local 指的就是函数或者类的方法内部
        Enclosed 指的是嵌套函数（一个函数包裹另一个函数，闭包）
        Global 指的是模块中的全局变量
        Built in 指的是 Python 为自己保留的特殊名称。
    如果都没有找到就会报错——NameError
'''

str = "global"
def outer01():
    str = "outer"
    def inner():
        str = "inner"
        print("outer01",str)
    inner()
outer01()

def outer02():
    str = "outer"
    def inner():
        #str = "inner"
        print("outer02",str)
    inner()
outer02()

def outer03():
    #str = "outer"
    def inner():
        #str = "inner"
        print("outer03",str)
    inner()
outer03()
'''
#此段程序需单独运行
def outer04():
    #str = "outer"
    def inner():
        #str = "inner"
        print("outer04",str)
    inner()
outer04()
'''

运行结果：

outer01 inner
outer02 outer
outer03 global
outer04 <class 'str'>