7.10 函数的嵌套等

一。命名关键字参数。（了解）

　　1.在函数阶段，写在*与** 可变长参数之间的形参称为命名关键字参数。

　　在给命名关键字参数传值时，只能用关键字为其传值。诸如以下函数的形参

def func(x,y=1,*args,z=3,m,**kwargs):
    print(x,y)
    print(args)
    print(z,m)
    print(kwargs)

　　z=3，m，这些函数型参看似会报错，因为关键字参数写在了位置参数的前面，但其实是在*args和**kwargs之间的位置参数。所以，给其传参时统一使用关键字传参

func(1,2,1,2,3,4,5,6,7,78,8,9,0,z=69,m=999,o=666999,l = 999666)

二。函数对象

　　1.函数是第一类对象：函数名指向的值可以被当成参数传递。

　　如同变量名一样，函数的名字也指向一个地址，打印变量名就是打印其地址

def func():
    print('from func')
# print(func)
print(id(func))
f = func
func()
print(f)
f()

　　像函数名被print时，输出的就是它的详细内存地址，而当函数名接触到（）时会被优先执行，包括使用另一变量指向该函数名，如f。运行结果如下

1982808399520
from func
<function func at 0x000001CDA8971EA0>
from func

　　2.函数名可以被当做参数传递给其他函数

def func():
    print('from func')

def index(args):
    print(args)
    args()
    print('from index')
# index(1)
index(func)

　　上代码中在函数调用阶段，func就被以函数名的方式赋值给index的参数，而index将其函数名打印，输出的也就是func的内存地址，再运行该函数，最后输出自己的打印，所以输出的结果应该是：

<function func at 0x000001E05AB91EA0>
from func
from index

　　3.函数名可以 被当作函数的返回值。

def index():
    print('index')

def func():
    print('func')
    return index
res = func()
print(res)
res()

　　上述代码中，func将index函数名返回给func函数，所以func()所代表的返回值 就是index并执行，将index赋值额、给res并打印，其结果必定是index的内存地址。res（）代表的是执行index函数所以结果如下：

func
<function index at 0x000002238A071EA0>
index

　　4.函数名可以作为容器类型的参数

def func():
    print('func')
print(func())
l = [1,2,func,func()]  # [1,2,<function func at 0x000001F7D79899D8>,None]
print(l)

　　函数名所代表的集合到列表中 ，可以被用来调用。运行结果如下

func
None
func
[1, 2, <function func at 0x00000267F2071EA0>, None]

　　这种特性可以被用来编写可添加式菜单，如

func_dict = {
    '1':register,
    '2':login,
    '3':transfer,
    '4':shopping,
    '5':pay,
}
while True:
    print(msg)
    choice = input('请现在你想要执行的功能>>>:').strip()
    if choice in func_dict:
        func_dict.get(choice)()  # 函数名()

　　将各个函数模块都添加到字典，然后根据用户输入的key值获取其 存储的函数名，在以函数名（）的形式执行代码。如此实现可添加的菜单。

三。函数的嵌套调用

　　在函数的编写中，也可以调另外一个函数，只要在调用主函数之前定义该函数即可正常运行：

def my_max(x,y):
    if x > y:
        return x
    return y

def my_max4(a,b,c,d):
    res1 = my_max(a,b)
    res2 = my_max(res1,c)
    res3 = my_max(res2,d)
    return res3
print(my_max4(1,2,10,4))
#输出结果>>>10

四.函数的嵌套定义

　　在函数的定义阶段，也可以通过其他函数的定义来实现某种功能。

def outer():
    x = 1
    print('outer')
    def inner():
        print('inner')
    # print(inner)
    return inner

res = outer()
print(res)
res()
#输出结果>>>outer
#<function outer.<locals>.inner at 0x000001875EBBC9D8>
#inner

五。名称空间：

　　名称空间里存放了变量名与变量值的内存地址的绑定关系的地方。

　　想要访问一个变量的值，必须先去名称空间中拿到对应的名字，才能够访问该变量的值。

　　名称空间有很多种：

x = 1
if 1 ==1 :
    y = 2
# print(y)
# while True:
#     z = 3
for i in [1,2,3]:
    print(i)
print(i)
def func():
    username = 'jason'
print(x)
func()

　　名称空间分3类：

　　1.内置名称空间：python解释器提前给你定义好的名字（已经存放到内置名称空间里）

　　如len，max min 等内置函数的名字都在内置名称空间

　　2.全局名称空间：文件级别的代码

　　如上函数所示，x，y，等都可以说是全局变量。

　　3.局部名称空间：函数体内创建的名字都属于局部名称空间的。

　　如上所示代码中username等。

　　生命周期：每种名称都有他的作用时间

　　1.内置名称空间：只要python解释器一启动，该名称空间就会立马创建，当解释器关闭时，内置名称空间也会自动销毁

　　2.全局名称空间：只要右键运行py文件，就会自动创建全局变量空间：py程序运行结束时自动销毁

　　3.局部名称空间：函数被调用的时候自动创建。函数指向结束变立即销毁，这种方式被称为动态创建，动态销毁。

六。名称的查找顺序

　　在名称查找的过程中顺序如下

　　当在局部函数中寻找名称时，会按照局部名称空间-》全局名称空间-》内置名称空间-》的顺序查询名称，而且值得注意的是当查询顺序确定以后就不会修改，所以

def func():
    x = 1
    def index():
        print(x)  # 获取全局找x
    return index

res = func()
x = 999
res()
#输出结果>>>1

七。作用域

　　1.在其名称的使用时，内置名称空间，全局名称空间是全局有效的，而局部名称空间只在该局域内有效。

 　　修改值的时候也是如此，在局部时只能修改局部的数据，不能修改全局的数据，各个局部之间也不能修改，所以，要想实现局部修改全局的功能需要两个关键字的帮助：nonlocal，global

　　global

　　代表在局部修改全局的变量，如果想要修改多个值，之间用逗号隔开

x = 1  # 不可变类型
username = 'jason'
def func():
    # x.append('嘿嘿嘿')
    global x,username  # 修改全局变量 而不是创建局部名称空间
    x = 999
    username = 'egon'
func()
print(x)
print(username)
#输出结果>>>999
#egon

　　像这样的修改如在函数中修改全局变量x，和username的值。使用的就是global

　　nonlocal

　　当想要在函数中定义的函数里改变原来定义的函数中的变量时，，就是使用nonlocal关键字实现，如果想改变多个值，值与值之间要加逗号。

　　

def func():
    x = 1
    def index():
        nonlocal x
        x = 2
    index()
    print(x)
func()
#输出结果>>>2