函数进阶

函数为了拓展，对于传入的实参数量不固定，万能参数，动态参数，*args, **kwargs

def sum1(*args,**kwargs):  # 在函数的定义时，在 *位置参数，聚合。
                   # *args 将所有的实参的位置参数聚合到一个元组，并将这个元组赋值给args
    print(args)
    print(kwargs)
sum1(1,2,3,4,name='alex',age=1000)
def sum1(*args,**kwargs):
    count = 0
    for i in args:
        count = count + i
    return count
print(sum1(10,10,20,30,100))

* 的魔性用法
在函数的定义时，在 *位置参数，**位置参数聚合。
在函数的调用(执行)时，在 *位置参数，**位置参数打散。

l1 = [1,2,3]
l2 = [111,22,33,'alex']
#
def func1(*args):
    print(args)
    return args[0] + args[1]
print(func1(l1,l2))

def func1(*args,**kwargs):
    # print(args)
    print(kwargs)
func1(*l1,*l2)
func1(*(1,2,3),*('alex','sb'))
func1(*'alex',*'sb')
func1(1,2,3,'alex','sb')

func1(**{'name':'alex'},**{'age':1000})  # func1(name='alex',age=1000})

形参的顺序
位置参数，默认参数，*args,**kwargs
推到：
　　1.位置参数，默认参数

def func(a,b,sex='男'):
    # print(a)
    print(sex)
func(100,200,)

　　2.位置参数，*args, 默认参数

def func(a,b,*args,sex='男',):
    # print(a)
    print(a,b)
    print(sex)
    print(args)
func(100,200,1,2,34,5,6)

结论：位置参数，*args, 默认参数 **kwargs

def func(a,b,*args,sex='男',**kwargs,):
    print(a,b)
    print(sex)
    print(args)
    print(kwargs)
func(100,200,1,2,34,5,6,sex='nv',name='alex',age=1000)

我们首先回忆一下Python代码运行的时候遇到函数是怎么做的，从Python解释器开始执行之后，就在内存中开辟里一个空间，每当遇到一个变量的时候，就把变量名和值之间对应的关系记录下来，但是当遇到函数定义的时候，解释器只是象征性的将函数名读如内存，表示知道这个函数存在了，至于函数内部的变量和逻辑，解释器根本不关心。

　　等执行到函数调用的时候，Python解释器会再开辟一块内存来储存这个函数里面的内容，这个时候，才关注函数里面有哪些变量，而函数中的变量回储存在新开辟出来的内存中，函数中的变量只能在函数内部使用，并且会随着函数执行完毕，这块内存中的所有内容也会被清空。

我们给这个‘存放名字与值的关系’的空间起了一个名字-------命名空间。

代码在运行伊始，创建的存储“变量名与值的关系”的空间叫做全局命名空间；

在函数的运行中开辟的临时的空间叫做局部命名空间。
'''
# python中，名称空间分三种：
    # 全局名称空间
    # 局部名称空间（临时）
    # 内置名称空间

 作用域：
     全局作用域 全局名称空间 内置名称空间
     局部作用域 局部名称空间（临时）

 取值顺序： 就近原则
   局部名称空间  ---->  全局名称空间 ----->内置名称空间  单向从小到大范围

 len = 6
 def func1():
     len = 3
 func1()
 print(len)
 def len(l):
     return l
 
 print(len([1,2,3]))

 print(''333)
 input()
a = 1

加载顺序
内置名称空间 ----> 全局名称空间（当程序执行时） --- > 局部名称空间（当函数调用的时候）

def func1():
    print(222)
    def func2():
        print(333)
    print(111)
    func2()
    print(666)
func1()
#222 111 333 666

global nonlocal
局部名称空间 对全局名称空间的变量可以引用，但是不能改变。

count = 1
def func1():
    count = 2
    print(count)
func1()
count = 1
def func1():
    # count = 3
    count = count + 1  # local variable 'count' referenced before assignment
    print(count)
func1()

如果你在局部名称空间 对一个变量进行修改，那么解释器会认为你的这个变量在局部中已经定义了，
但是对于上面的例题，局部中没有定义，所以他会报错，
global
    1，在局部名称空间声明一个全局变量。

def func2():
    global name
    name = 'alex'
func2()
print(name)

 2，在局部名称空间可以对全局变量进行修改。

count = 1
def func1():
    global count
    count = count + 1
    print(count)
func1()
print(count)

nonlocal
def func1():
    count = 666
    def func2():
        print(count)
    func2()
func1()

nonlocal
子函数对父函数的变量进行修改。
此变量不能是全局变量。

在局部作用域中，对父级作用域（或者更外层作用域非全局作用域）的变量进行引用和修改，
并且引用的哪层，从那层及以下此变量全部发生改变。

def func1():
    count = 666
    def inner():
        print(count)
        def func2():
            nonlocal count
            count += 1
            print('func2',count)
        func2()
        print('inner',count)
    inner()
    print('func1',count)
func1()
#  666  func2 667  inner 667  func1 667

1.函数的函数名是函数的内存地址

def fun():
    return '执行返回内容！'
print(fun)
print(fun())

2.函数的函数名可以作为函数参数被调用

def fun():
    return '函数的返回结果'
fun(fun)

def fun1():
    print('函数fun1的返回')
def fun2(x):
    x()
fun2(fun)   #fun作为函数fun2的参数被调用

3.函数名可以作为变量

a = 1       #变量赋值的传递
b = a
c = b
print(c)

def fun():
    print(686868)
f1= fun     #函数名作为变量赋值给另外的变量
f2 =f1
f2()        #变量加上（）可以实现fun（）的函数的功能

4.函数名可以当做函数的的返回值

def fun():
    def inner():
        return 'inner的返回结果'
    return inner
f2 = fun()  #返回值inner
print(f2()) #f2()相当于inner()

5.函数名可以作为容器类的元素

def fun1():
    print('fun1')
def fun2():
    print("fun2")
def fun3():
    print('fun3')
def fun4():
    print('fun4')
li =[fun1,fun2,fun3,fun4]
for i in li:
    i()

nonlocal,locals(),globals,globals()四者的区别
nonlocal申明变量可以从父级的变量进行调用

def fun():
    a=10
    def inner():
        nonlocal a
        a =20
        print(a)
    inner()
    print(a)
    def two_inter():
        a = 30
    print(a)
print(fun())

globals() # 返回全局变量的一个字典。
locals()  返回 当前位置 的局部变量的字典。

def func1():
    a = 2
    b = 3
    # print(globals())
    # print(locals())
    def inner():
        c = 5
        d = 6
        print(globals())
        print(locals())
    inner()
# print(globals())
# print(locals())
func1()