Day10 python基础---函数进阶

一，动态参数

　　你的函数，为了拓展，对于传入的实参数量不固定，无能参数，动态参数

def sum1(*args,**kwargs):  #在函数的定义时，在*位置参数，聚合。
    print(args)       #*args 将所用的实参的位置参数聚合到一个元组，并将这个元组赋值给args
   print((kwargs))    #**kwargs将实参的关键字参数的聚合到一个字典，并赋值给kwargs
sum1(1,2,3,4)

#例：计算器
def count(*args):
    count = 0
    for li in args:
        count += li
    return count

print(count(1,2,3,34,23,45,436))

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

#例1：
l1 = [1,2,3]
l2 = [111,22,33,'alex']

def func1(*args):
    print(args)
print(func1(*l1,*l2))

#例2：
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

例：
# 位置参数，默认参数
def func(a,b,sex='男'):
    # print(a)
    print(sex)
func(100,200,)

# 位置参数，*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]))

加载顺序：

　　#内置名称空间----> 全局名称空间（当程序执行时）----->局部名称空间（当函数调用时）

四，函数的嵌套

例1： 
func1():
    print(111)
def func2():
    print(222)
    func1()
    print(333)
print(666)
func2()
print(555)

例2：
def func1():
    print(222)
    def func2():
        print(333)
    print(111)
    func2()
    print(666)
func1()

global:

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

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 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