函数的进阶

你的函数，为了拓展，对于传入的参数数量不固定，万能参数，动态参数，*args,**kwarge
def sum1(*args,**kwargs): #在函数的定义时，在*位置参数，聚合
                #*args 将所有的实参的位置参数聚合到一个元组，并将这个元组赋值给args
    print(args)#(1, 2, 3, 4)
    print(kwargs)#{'name': 'alex', 'age': 1000}
sum1(1,2,3,4,name='alex',age=1000)

def sum1(*args,**kwargs):
    count=0
    for i in args:
        count+=i
    return count
print(sum1(10,12,22,33,445)) #522

*的魔性用法
在函数的定义时，在*位置参数，**位置参数聚合
在函数的调用（执行）时，在*位置参数，**位置打伞参数
l1=[1,2,3]
l2=[111,222,333,'alex']
方法一
def fun1(*args):
    return args[0]+args[1]
print(fun1(l1,l2))
方法二
def func1(*args,**kwargs):
    print(args)
一个*
func1(*l1,*l2)#(1, 2, 3, 111, 222, 333, 'alex')
func1(*(1,2,3),*('alex','sb')) #(1, 2, 3, 'alex', 'sb')
func1(*'alex',*'sb') #('a', 'l', 'e', 'x', 's', 'b')
func1(1,2,3,'alex','sb') #(1, 2, 3, 'alex', 'sb')
2个*

def func1(*args,**kwargs):
    print(kwargs)
func1(**{'name':'alex'},**{'age':1000})#{'name': 'alex', 'age': 1000}

形参的顺序
位置参数，默认参数，*args,**kwargs
（1）位置参数在前，默认参数在后面
def func(a,sex='男'):
    print(a)
    print(sex)
func(100,'女')
>>>100
女
（2）位置参数，*args,默认参数
def func(a,b,*args,sex='男'):
    print(a,b)
    print(sex)
    print(args)
func(100,200,1,2,33,4,5)
>>>100 200
男
(1, 2, 33, 4, 5)
位置参数，*args,，默认参数，**kwargs
def func(a,b,*args,sex='男',**kwargs):
    print(a,b)
    print(sex)
    print(args)
    print(kwargs)
func(100,200,1,2,33,4,5,sex='女',name='alex',age=1000)
>>>100 200
女
(1, 2, 33, 4, 5)
{'name': 'alex', 'age': 1000}

# # 代码在运行伊始，创建的存储“变量名与值的关系”的空间叫做全局命名空间；
# a=123
# b=456
# name='alex'
# # 在函数的运行中开辟的临时的空间叫做局部命名空间也叫做临时名称空间。
# def fun1():
#     a1='alsmcnxbz'
# fun1()

接下来我们讲的内容，理论性的偏多，就是从空间角度，内存级别去研究python。首先我们看看什么是全局名称空间：

​ 在python解释器开始执行之后, 就会在内存中开辟一个空间, 每当遇到一个变量的时候, 就把变量名和值之间的关系记录下来, 
但是当遇到函数定义的时候, 解释器只是把函数名读入内存, 表示这个函数存在了, 至于函数内部的变量和逻辑, 解释器是不关心的. 
也就是说一开始的时候函数只是加载进来, 仅此而已, 只有当函数被调用和访问的时候, 解释器才会根据函数内部声明的变量来进行开
辟变量的内部空间. 随着函数执行完毕, 这些函数内部变量占用的空间也会随着函数执行完毕而被清空.

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

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

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

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

在函数的运行中开辟的临时的空间叫做局部命名空间也叫做临时名称空间。

现在我们知道了，py文件中，存放变量与值的关系的一个空间叫做全局名称空间，而当执行一个函数时，内存中会临时开辟一个空间，临时存放函数中的变量与值的关系，这个叫做临时名称空间，或者局部名称空间。

总结:

​ \1. 全局命名空间--> 我们直接在py文件中, 函数外声明的变量都属于全局命名空间

​ \2. 局部命名空间--> 在函数中声明的变量会放在局部命名空间

​ 3. 内置命名空间--> 存放python解释器为我们提供的名字, list, tuple, str, int这些都是内置命名空间

作用域
1. 全局作用域: 全局命名空间 + 内置命名空间

​2. 局部作⽤域: 局部命名空间（临时）
def len(l):
    return l
print(len([1,2,3])) #[1, 2, 3]
1)取值顺序:满足就近原则
局部名称空间--->全局名称空间----->内置名称空间   单向从小到大范围
len=6
def func1():
    len=3
    print(len)
func1() #3

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

案例一：
def func1():
    print(111)
def func2():
    print(222)
    func1()
    print(333)
print(666)
func2()
print(555)
666
222
111
333
555
案例二
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()
如果你在局部名称空间对一个变量进行修改，那么解释器会认为你的变量在局部中已经定义了，
但是对于上面的例题，局部中没有定义，所有他会报错
global
    1.在局部名称空间声明一个全局变量
def func2():
    global name
    name='alex'
func2()
print(name) #alex
    2.在局部名称空间可以对全局变量进行修改
count = 1
def fun1():
    global count
    count =count+ 2
    print(count)
fun1()
print(count) #3  3

nonlocal
nonlocal是python3x新加的功能，
与global用法差不多，就是在局部作用域
如果想对父级作用域的变量进行改变时，需要用到nonlocal，
当然这个用的不是很多，了解即可。
子函数对父函数的变量进行修改
此变量不能是全局变量
def func1():
    count=666
    def func2():
        nonlocal count
        count+=1
        print(count)
    func2()
    print('***',count) # *** 667
func1()  #667
2，在局部作用域中，对父级作用域（或者更外层作用域非全局作用域）的变量进行引用和修改，
并且引用的哪层，从那层及以下此变量全部发生改变。
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