1.可变长参数

1.1 形参名之 *

def f1(*args):  # 调用函数时，有多少个位置实参，我就接收多少个参数
    print(args)
    
f1()  # () # a是空元组
# f1(1)  # (1, )
# f1(1, 2)
f1(1, 2, 3, 3, 4, 5, 5, 6, 7, 7, 7, 7, 7, 7, 7, )

# *args(约定俗称的),用元组接收 多余 的位置实参

1.2形参名之 **

def f1(**kwargs):
print(kwargs)## f1(x=1)  # 空字典
# **kwargs,用字典接收多余的关键字实参

1.3实参名之 *(了解)

def f1(a, b, c, e, d, f, g):
    print(a, b, c, e, d, f, g)
    
lt = [1, 2, 3, 4, 5, 6, 7]
# f1(lt[0],lt[1],lt[2],lt[3],lt[4],lt[5],lt[6])
f1(*lt)  # *lt把列表中的元素打散成位置实参依次传给位置形参

1.4实参名之 **(了解)

def f1(z, b):
    print(z, b)
    dic = {'z': 1, 'b': 2}  # a=1,b=2
    f1(**dic)  # **dic把字典打散成关键字实参然后传给函数f1

2.函数对象

python中一切皆对象

2.1 引用

func = f1
print('f1:', f1)
print('func:', func)

func()

2.2 容器元素

lt = [f1, 1, 2, 3]

print('lt[0]', lt[0])
print('f1', f1)

lt[0]()

2.3 作为函数实参

def f2(f2_f1):
     print('f2_f1',f2_f1)
     f2_f1()

f2(f1)

print('f1', f1)

2.4 作为函数返回值

def f2(f2_f1):
    return f2_f1


res = f2(f1)
print('res', res)
print('f1', f1)

res()

引用（拷贝）
当作容器类元素
当作函数的实参
当作函数的返回值

函数对象的联系

def register():
    print('register')


def login():
    print('login')


def withdraw():
    print('wightdraw')


def shopping():
    print('shopping')


func_dict = {
    '1': register,
    '2': login,
    '3': withdraw,
    '4': shopping,
}

print('''
1 注册
2 登录
3 提现
4 购物
''')

while True:
    choice = input('请选择你需要的功能(输入q退出)：')
    if choice == 'q':
        break
    func_dict[choice]()

3.函数的嵌套

打印九九乘法表

for i in range(1, 10):  # i控制的是行
     for j in range(i):  # j控制的是列
         print(f'{j+1}*{i}={(i)*(j+1)}', end=' ')

     print()  # 打印换行

 '''
 i控制行，j控制列
 i = 1  for j in range(1) j = 0 + 1
 i = 2  for j in range(2) j = 0 + 1 j = 1 + 1
 i = 3  for j in range(3) j = 0 + 1 j = 1 +1 j = 2 + 1
 i = 4
 i = 5

函数嵌套：函数里面有函数

# 定义函数，只检测语法，不会执行代码
 def f1():
     print('from f1')

     def f2():
         print('from f2')



res = f1()

函数内部定义的函数，外部不能用

4.名称空间和作用域

4.1变量名/函数名 --》名称 --》名称空间：专门存储名称的

4.2内置名称空间：存储了内置方法的名称

3数据类型自带内置方法；python解释器自带内置方法(print/len/list/str/dict)

全局名称空间：除了内置和局部都叫全局

def f1():
     x = 10
     def f2():
         z = 20

 y = 10

 lt = [1, 2, 3]

局部名称空间：函数内部定义的都叫局部

4.1 名称空间的执行（生成）顺序：

内置名称空间：python解释器启动的时候就有了

全局名称空间：执行文件代码的时候才会有全局

局部名称空间：函数调用的时候才会有局部

搜索顺序: 先从当前所在位置寻找，找不到再按照这种顺序，不会逆着方向寻找局部 --》全局 --》内置 --》报错

len  =10

 def f1():
     # len = 20

     print(len)

 f1()


 def f1():
     print('from f1')

     def f2():
         print('from f2')

 res = f1()

4.2 作用域

全局作用域: 内置名称空间+全局名称空间 --》全局作用域

def f1():
     y = 2

     print(1, y)


 y = 10
 f1()

 print(2, y)

 print(y)

局部作用域

def f1():
     def f2():
         def f3():
             x = 1
             print(x)

         x = 2
         f3()

     f2()


 f1()

局部作用域：局部名称空间 --》局部名称空间

局部作用域1的x和局部作用域2的x也没有任何关系，即使局部作用域1和局部作用域2再同一个局部作用域下

global和nonlocal了解，尽量不要使用

global:打破了上述的第1点规则

x = 10


def f1():
    global x  # 让global以下的局部的x变成全局的x
    x = 20

f1()
print(x)

nonlocal：打破了上述的第2点规则

x = 10

def f1():
    def f2():
        def f3():
            nonlocal x  # nonlocal让x成为顶层函数的局部，不是让他成为全局  # 压根没有应用情景，尽量不要嵌套函数
            x = 1
        x = 2
       f3()
        print(1, x)
    f2()
def f0():
#     x  = 3  # f1的nonlocal无法修改
#     f1()
f1()
print(2, x)

所有可变数据类型均可打破上述一切规则

lt = [10]

def f1():
    lt.append(12)
    lt[0] = 11
   

f1()
print(lt)python

不理解就记住/算了

def f1(i, lt=[]):
    lt.append(i)
    print(lt)

for i in range(10):
    f1(i)


def f1(i, lt):
    lt.append(i)
    print(lt)


for i in range(10):
    f1(i, [])

定义函数:只检测语法，不执行代码

def f1():
    def f2():
        def f3():
            print('f3')
        f3()


f1()

x = 10
print(x)

def f1():
    x = 10
    print(x)

f1()

day 11小结