函数中，易遗忘记载

 

def func1():
    name = "nezha"
    def func2():
        print("inner")   # 内层函数，对外层函数的变量（非全局变量）的引用，叫闭包，这里没有闭包
    data = {"action":func2}
    print(func2.__closure__)     # None
    return data  # 外层函数有返回对内层函数的引用，在外层函数结束，外层函数就不会在内存消失

#
func1()['action']()
print(func1)  #   <function func1 at 0x00000217ECBD8B70>

在函数的形参中，有默认参数，并且默认参数的数据类型为 容器类数据类型时 ，在函数的调用过程中，如果使用默认值 ，那们始终使用默认值 创建的那一个 同一个对象

nonlocal : 仅用于父子函数，这里的父子是指函数定义时，这的嵌套关系。而不指，两个分开定义的函数，嵌套调用关系：

def func1():
    flag_l = True
    func2()              # 这里仅是嵌套调用，func1 与 func2 并不是父子函数
    print(flag_l)

def func2():
    flag_l = False
    print(flag_g)
    return flag_l
func1()

下面是父子函数的举例：

def func1():
    x = 5
    def func2():
        y = 10
        print(x + y)  # 15
    func2()
    print(x)  # 5 
func1()


def func1():
    x = 5
    def func2():
        y = 10
        x = 20   #本地局部变量
        print(x + y)   # 30
    func2()
    print(x)   # 5
func1()

def func1():
    x = 5
    def func2():
        y = 10
        nonlocal x  # 声明使用父级函数变量（非全局变量）
        x = 22
        print(x + y)
    func2()
    print(x)
func1()

 

shoppingCart = {}    # global 用来声明 整型 与 字符串类型  ，对于可变数据类型，比如列表，函数可以直接修改

* 打散 用法

lis = [1,3,5,7]
print(*lis)  # 1 3 5 7

 

def min_max(*args):         # 定义函数时，加星号 是聚合的作用，一颗星，聚合实参中的所有位置参数，为元组
    max1 = max(*args)      # 函数调用时，加星号，是打散的作用，一颗星，把对象打散成实参的位置参数，二颗星，是打散成 关键字参数
    min1 = min(*args)
    return {'max':max1,'min':min1}
print(min_max(11,23,18))

print("分隔线".center(100,'&'))
def min_max(*args):
    max1 = max(args)                # max(),min()函数，参数支持可迭代对象
    min1 = min(args)
    return {'max':max1,'min':min1}
print(min_max(11,23,18))

函数中的形参是 默认参数 时的陷井：

5.2，下面代码打印的结果分别是_________,________,________.
def extendList(val,list=[]):
    list.append(val)
    return list
'''
def calc(a,b,c,d=1,e=2):
    return (a+b)*(c-d)+e
print(calc(1,2,3,4,5)) # 2
# print(calc(1,2)) # 报错，位置参数，必须传参数，且一一对应
print(calc(e=4,c=5,a=2,b=3))  # 24 实参 关键字参数，没有顺序
print(calc(1,2,3))   # 8 实参的位置参数，必须一一对应，
print(calc(1,2,3,e=4))  # 10 # 形参的默认参数，实参没有传参，则采用默认值，否则覆盖
#print(calc(1,2,3,d=5,4)) # 报错，实参 混合传参，关键字参数，必须在位置参数之后
'''
5.2，下面代码打印的结果分别是_________,________,________.
def extendList(val,list=[]):
    list.append(val)
    return list
list1 = extendList(10)
list2 = extendList(123,[])
list3 = extendList('a')

print('list1=%s'%list1)
print('list2=%s'%list2)
print('list3=%s'%list3)
'''
def extendList(val,list=[]):
    list.append(val)
    return list
list1 = extendList(10)  #
list2 = extendList(123,[])
list3 = extendList('a')
list4 = extendList(456,[])

print('list1=%s' %list1) # [10,'a] 
print("list2=%s" % list2) # [123] 
print("list3=%s" %list3) # [10,'a']
print("list4=%s" %list4)  # [456]

 当默认参数是 可变数据类型时， 如果默认参数，在函数调用时 实参 传参 不覆盖默认值，则凡是采用默认参数 默认值的调用，共有一个对象；
但是，如实参传参，覆盖，那怕值一样，在函数执行时，创建新的对象