1.函数的动态参数

1.1 动态接收位置参数

在参数位置用*表示接受任意参数

def eat(*args):
    print('我想吃',args)
eat('蒸羊羔','蒸熊掌','蒸鹿尾儿','烧花鸭','烧雏鸡','烧子鹅','卤猪','卤鸭','酱鸡','腊肉','松花小肚儿','晾肉','香肠儿') # 收到的结果是一个tuple元祖

动态接收参数的时候要注意: 动态参数必须在位置参数后面

def eat(*args):
    print('我想吃',args,a,b)
eat('蒸羊羔','蒸熊掌','蒸鹿尾儿','烧花鸭','烧雏鸡','烧子鹅','卤猪','卤鸭','酱鸡','腊肉','松花小肚儿','晾肉','香肠儿')

结果:

TypeError: eat() missing 2 required keyword-only arguments: 'a' and 'b'
# eat函数在调用的时候发现缺少俩个位置参数没有进行传递
# 把所有的位置参数都给接受了,a和b接收不到值,所有会报错.

def eat(a,b,*args):
    print('我想吃',args,a,b)
eat('蒸羊羔','蒸熊掌','蒸鹿尾儿','烧花鸭','烧雏鸡','烧子鹅','卤猪','卤鸭','酱鸡','腊肉','松花小肚儿','晾肉','香肠儿')

结果:
我想吃 ('蒸鹿尾儿', '烧花鸭', '烧雏鸡', '烧子鹅', '卤猪', '卤鸭', '酱鸡', '腊肉', '松花小肚儿', '晾肉', '香肠儿') 蒸羊羔 蒸熊掌

def func(a,b,*args):
    print(a,b,args)     #*args 是 万能(接受任意多个)的位置参数, *在函数定义的时候叫做聚合
    print(*args)        #  在这一行 *args作用是 打散

args 是 万能(接受任意多个)的位置参数, 在函数定义的时候叫做聚合

动态接收参数的时候要注意:动态参数必须在位置参数后面

优先级:位置参数 > 动态位置参数

1.2 动态接收关键字参数

在python中可以动态的位置参数,但是*这种情况只能接收位置参数无法接收关键字参数,在python中使用**来接收动态关键字参数

def func(**kwargs):
    print(kwargs)     
func(a=1, b=2, c=3)

结果:
{'a': 1, 'b': 2, 'c': 3}    #dict字典形式

动态关键字参数最后获取的是一个dict字典形式

位置参数必须在关键字参数前面.动态接收关键字参数也要在后面

俩个动态参数:

def trans_para(*args,**kwargs):
    print(args,type(args))      # args是元祖形式
    print(kwargs,type(kwargs))  # kwargs接收的只是键值对的参数，并保存在字典中。
trans_para("jinxin",12,[1,2,3,4],[3,4,],(1,4,7),{"a":"123","c":456},country="china")

结果:
('jinxin', 12, [1, 2, 3, 4], [3, 4], (1, 4, 7), {'c': 456, 'a': '123'}) <class 'tuple'>
{'country': 'china'} <class 'dict'>

动态参数，也叫不定长传参，就是你需要传给函数的参数很多，不定个数，那这种情况下，你就用*args，**kwargs接收，args是元祖形式，接收除去键值对以外的所有参数，kwargs接收的只是键值对的参数，并保存在字典中。

*args和 **kwargs

args是元祖形式,kwargs是字典形式

最终顺序:

位置参数 > *args(动态位置参数) > 默认值参数 > **kwargs(动态默认参数)

如果想接收所有的参数:

def func(*args,**kwargs):
    print(args,kwargs)
    print(*args,*kwargs)    #*args为把元组打散,*kwargs为字典的keys

func(1,23,5,a=1,b=6)

结果:
(1, 23, 5) {'a': 1, 'b': 6}
1 23 5 a b

动态参数还可以这样传参:

lst = [1,4,7]
# 方法一
def func(*args):
    print(args)

func(lst[0],lst[1],lst[2])  # (1, 4, 7)


# 方法二
def func(*args):
    print(args)

func(*lst)      # (1, 4, 7)
# 在实参的位置上用*将lst(可迭代对象)按照顺序打散

# 在形参的位置上用*把收到的参数组合成一个元祖

字典也可以进行打散,不过需要**

dic = {'a':1,'b':2}
lst = [1,2,3,4,5,6,7,81]
def func(*args,**kwargs):
    print(args)
    print(kwargs)
func(*lst,**dic)

结果:
(1, 2, 3, 4, 5, 6, 7, 81)
{'a': 1, 'b': 2}

2.函数的注释

# 函数的注释

def func(*args,**kwargs):
    '''
    #很重要　写函数一定要写注释
    :param args:   要标识的内容
    :param kwargs: 要标识的内容
    :return: 要标识的内容
    '''

    pass

# 函数名.__doc__   查看函数的注释
# 函数名.__name__  查看函数名(在学反射的时候使用)

3.名称空间

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

def fun():   
    a = 10   
    print(a)
fun()
print(a)    # a不存在了已经..

我们给存放名字和值的关系的空间起一个名字叫: 命名空间. 我们的变量在存储的时候就 是存储在这片空间中的.

命名空间分类:

1. 全局命名空间--> 我们直接在py文件中, 函数外声明的变量都属于全局命名空间
2. 局部命名空间--> 在函数中声明的变量会放在局部命名空间
3. 内置命名空间--> 存放python解释器为我们提供的名字, list, tuple, str, int这些都是内置命名空间　　

加载顺序:

1. 内置命名空间
2. 全局命名空间
3. 局部命名空间(函数被执行的时候)

取值顺序:

1. 局部命名空间
2. 全局命名空间
3. 内置命名空间

a = 10
def func():  
    a = 20   
    print(a)

func()  # 20

作用域: 作用域就是作用范围, 按照生效范围来看分为 全局作用域 和 局部作用域

　　 全局作用域: 包含内置命名空间和全局命名空间. 在整个文件的任何位置都可以使用(遵循 从上到下逐⾏执行).

　　 局部作用域: 在函数内部可以使用.

作⽤域命名空间:

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

我们可以通过globals()函数来查看全局作⽤用域中的内容,也可以通过locals()来查看局部作 ⽤用域中的变量量和函数信息

a = 10
def func():   
    a = 40   
    b = 20   
    print("哈哈")   
    print(a, b)        
    print(globals())    # 打印全局作用域中的内容   
    print(locals())     # 打印当前作用域中的内容
func()

4.函数嵌套

1. 只要遇见了()就是函数的调用. 如果没有()就不是函数的调用
2. 函数的执行顺序

def fun1():   
    print(111)  
def fun2():   
    print(222)   
    fun1()   
fun2()
print(111)

def fun2():   
    print(222)   
    def fun3():       
        print(666)   
    print(444)   
    fun3()   
    print(888)
print(33)
fun2()
print(555)

5.global nonlocal (很重要)

首先我们写这样一个代码, 首先在全局声明一个变量, 然后再局部调用这个变量, 并改变这 个变量的值

a = 100
def func():   
    global a    # 加了个global表示不再局部创建这个变量了. 而是直接使用全局的a   
    a = 28   
print(a)
func()
print(a)

结果:
100
28

global表示不再使用局部作用域中的内容了. 而改用全局作用域中的变量

2.1global 宗旨

在函数内部修改全局的变量,如果全局中不存在就创建一个变量

lst = ["周道镕", "章超印", "杨红兴"]
def func():   
    lst.append("朱凡宇")   
    # 对于可变数据类型可以直接进行访问
　　 print(lst)
func()
print(lst)

2.2 nonlocal宗旨

nonlocal 只修改上一层变量,如果上一层中没有变量就往上找一层,只会找到函数的最外层,不会找到全局进行修改

a = 10
def func1():   
    a = 20   
    def func2():
        nonlocal a       
        a = 30       
        print(a)  
    func2()   
    print(a)
func1()


结果:
加了nonlocal
30
30

不加nonlocal
30
20

再看, 如果嵌套了很多层, 会是一种什么效果:

a = 1
def fun_1():   
    a = 2   
    def fun_2():       
        nonlocal a       
        a = 3       
        def fun_3():           
            a = 4           
            print(a)       
        print(a)       
        fun_3()       
        print(a)   
    print(a)   
    fun_2()   
    print(a)
print(a)
fun_1()
print(a)
# 这样的程序如果能分析明白. 那么作用域, global, nonlocal就没问题了

globals()和locals()

locals() 返回是当前局部变量的深拷贝，修改locals() 中变量值的时候，实际上对于原变量本身是没有任何影响的。而globals()返回的是全局变量的字典，修改其中的内容，值会真正的发生改变。

6.其他

三元运算符
a = 10
b = 30
c = a if a > b else b
print(c)

结果:
30

enumerate() #枚举
lst = [11,22,33,44,55,66]
for i,j in enumerate(lst):
    print(i,j)
    
结果:
0 11
1 22
2 33
3 44
4 55
5 66



元组和字典打散:
tu = (1,2,3,4,5,6)
dic = {1:2,2:4}
print(*tu)
print(*dic)

结果:
1 2 3 4 5 6
1 2

一日总结:

# 1.函数的动态参数
# *args,**kwargs (能够接受动态的位置参数和动态的关键字参数)
# 定义阶段(*args,**kwargs) 聚合
#     *args -  tuple
#     **kwargs -- dict
# 使用阶段*args,*kwargs 打散
#     *args - 源数据类型
#     *kwargs - 打散是字典的键
# 优先级: 位置 > 动态位置> 默认 > 动态关键字

# lst = [12,23,3,4,5,6]
# def func(*args):
#     print(*args)
# func(lst[0],lst[1]) # 笨的办法
# func(*lst)

# dic = {"key":1,"key1":34}
# def func(**kwargs):
#     print(kwargs)
# func(**dic)

# 2.函数的注释
"""
每次写函数的时候需要写注释
函数名.__doc__
函数名.__name__
"""

# 3.名称空间
# 内置空间: python解释器自带的
# 全局空间:当前文件(.py文件)
# 局部空间:函数体开辟的空间

# 加载顺序: 内置 > 全局> 局部
# 取值顺序: 局部 > 全局 > 内置

# 作用域:
# 全局作用域 内置 + 全局
# 局部作用域: 局部

# 4.函数嵌套
# 函数中套函数
# 函数嵌套调用
# 函数嵌套参数的传递
# 函数嵌套返回值的传递

# 5.global nonlocal
# global : 修改全局空间的变量对应的值
# nonlocal :在外层的函数中,修改局部空间的变量值.完全不涉及全局变量,
# 只修改离它最近的一层,最近的一层没有变量继续向上找,直到找到最外层函数

# 6.三元运算符
# a = 10
# b = 20
# c = a if a> b else b
# 变量名 = 条件成立的结果 条件 条件不成立的结果