1. 动态传参(重点)  *, **
        *, ** :
            形参: 聚合
                位置参数* -> 元组
                关键字** -> 字典
            实参: 打散(##动态参数的另一种传参方式,第一种是直接传递多个位置参数或关键字参数)
                列表, 字符串, 元组 -> *
                字典 -> **

        形参顺序(重点):
            位置, *args, 默认值, **kwargs

        无敌传参
        def func(*args, **kwargs): arguments参数  keyword-arguments关键字参数
            pass
        ## 所谓的接收动态位置参数或者说接收动态关键字参数是指的实参(手动重点:位置,关键字),因为参数是从实参传递给形参,进而给到函数内部调用的
        ##原本实参位置是接收位置参数或者关键字参数,然后传递给形参位置以供函数内部调用的,这里通过*加列表来打散成多个位置参数,传递给形参位置的动态位置参数*args.
同理实参位置通过**加字典来打散成多个
关键字参数,传递给形参位置的动态关键字参数**kwargs

    2. 作用域和名称空间
        名称空间: 用来存放名字(变量, 函数名, 类名, 引入的模块名)的

        1. 全局名称空间: 我们在py文件中自己写的变量, 函数.....
        2. 内置名称空间: 我们python解释器提供好的一些内置内容(print, input....)
        3. 局部名称空间: 在我们执行函数的时候.会产生一个局部名称空间. 放的是: 函数内部的内容(变量, 函数,类...)

        名称空间可能会有无数个, 局部名称空间而言. 相对是独立的.一般互不干扰

        作用域:
            1. 全局作用域: 内置+全局
            2. 局部作用域: 局部

        globals() 查看全局作用域
        locals() 查看当前作用域

    3. 函数的嵌套
        在函数中声明函数
        在内部函数中使用变量的时候, 查找顺序: 先找自己 -> 上一层 -> 上一层..全局 -> 内置

    4. nonlocal和global关键字(重点)
        global: 在局部引入全局变量
        nonlocal: 在局部...内层函数引入外层离他最近的那个变量.

def chi(quality_ food, junk food):
    print("我要吃”，quality food, junk_ food)

chi("大米饭”，"小米饭”)# "大米饭"传递给quality_ food,“小米饭”传递给junk_ food,按照位置传

def chi(*food):
    print("我要吃”，food)

chi("大米饭”，“小米饭")

结果:
我要吃(‘大米饭’，‘小米饭‘)#多个参数传递进去.收到的内容是元组tuple

# 报错的写法
def chi(*food, a, b):  # 报错
    print("我要吃"，food, a, b)

chi("大米饭”，“小米饭”， “黄瓜”， “茄子")

Traceback (most recent call last):
    File "/Users/sylar/PycharmProjects/oldboy/fun.py"， line 95，in <module> chi("大米饭",“小米饭”，“黄瓜”， “茄子")
TypeError: chi() missing 2 required keyword-only arguments: ‘a‘ and ‘b‘

# 有限制条件的写法
def chi(*food, a, b):
    print("我要吃”，food, a, b)

chi("大米饭"，“小米饭"，a="黄瓜"， b="茄子") # 必须用关键字参数来指定

# 正确的形参顺序,实参传参没有限制
def chi(a, b, *food): #动态参数放在位置参数后面,这样就可以使用位置参数给形参的位置和动态参数传值了
    print("我要吃"，a, b, food)

chi("大米饭"，”小米饭"， ”馒头”， “面条") # 前两个参数用位置参数来接收，后面的参数用动态参数接收

# 错误的写法
def chi(a, b，c=‘馒头‘，*food):  # 动态位置参数是多个位置参数的集合,也是位置参数,带等号的默认值参数就应该在后面
    print(a, b，C, food)

chi("香蕉"，"菠萝") #香蕉  菠萝  馒头  () ==>默认值生效
chi("香蕉"，"菠萝"，”葫芦娃") #香蕉  菠萝  葫芦娃  ()  ==>默认值不生效
chi("香蕉”，”菠萝”，“葫芦娃”，“口罩") # 香蕉  菠萝  葫芦娃  (‘口罩‘,)  ==>默认值不生效

# 正确的写法
def chi(a, b, *food, c=" 娃哈哈"):
    print(a, b, food, c)

chi("香蕉"，"菠萝") #香蕉菠萝(娃哈哈默认值生效
chi("香蕉"，"菠萝"，”葫芦娃") # 香蕉菠萝(‘葫芦娃‘,)娃哈哈默认值生效
chi("香蕉”，"菠萝"， “葫芦娃”， “口罩") # 香蕉菠萝(‘葫芦娃’，‘口罩‘)娃哈哈默认值生效

def func(**kwargs):
    print(kwargs)

func(a=1, b=2, c=3)
func(a=1, b=2)

结果:
{‘a‘: 1, ‘b‘: 2, ‘c‘: 3} #多个参数传递进去.收到的内容是字典dict

{‘a‘: 1，‘b‘: 2}

def func(a, b, c, d):
    print(a, b, C, d)

#关键字参数必须在位置参数后面，否则参数会混乱
func(1, 2，c=3, 4)  # 报错

def func(*args, **kwargs):
    print(args, kwargs)  # 分别是元组,字典

func("麻花藤" ,"马晕" ,wtf="胡辣汤")  # (‘麻花藤‘, ‘马晕‘) {‘wtf‘: ‘胡辣汤‘}

def fun(*args):
    print(args)

lst=[1,4,7]
fun(lst[0]，lst[1]， Ist[2])

fun(*1st)  #可以使用*把一个列表按顺序打散,等效于上面一行的写法(手动打散传递多个位置参数),这样写内部会自动帮我们打散


s =“臣妾做不到”
fun(*s)  #字符串也可以打散，(可迭代对象)

def fun(**kwargs): 
    print(kwargs)

dic = {‘a‘:1, ‘b‘:2}
fun(**dic)

# 动态接收位置参数
def chi(*food):
    print("我要吃", food)  # 我要吃 (‘?大?米饭‘, ‘?小?米饭‘)
    print(type(food))  # <class ‘tuple‘>


chi("?大?米饭", "?小?米饭")  #多个参数传递进去. 收到的内容是元组tuple  ==>动态位置参数的第一种传参方式:直接传递多个位置参数
chi(*["?大?米饭", "?小?米饭"])  # *[列表]:打散成位置参数,等效于上面的调用 ==>动态位置参数的第二种传参方式:*可迭代对象(在实参位置会将可迭代对象打散,
将其每一元素变成一个位置参数进行传递给形参上面的动态位置参数)



# 动态接收关键字参数
def he(**drink):
    print("我要喝", drink)  # 我要喝 {‘a‘: ‘?大?米饭‘, ‘b‘: ‘?小?米饭‘}
    print(type(drink))  # <class ‘dict‘>


he(a="?大?米饭", b="?小?米饭")  #多个参数传递进去. 收到的内容是字典dict  ==>动态关键字参数的第一种传参方式:直接传递多个关键字参数
he(**{"a":"?大?米饭", "b":"?小?米饭"})  # **{字典}:打散成关键字参数,等效于上面的调用  ==>动态关键字参数的第二种传参方式:**字典(在实参位置会将字典打散,
将其每一个键值对变成一个关键字参数进行传递给形参上面的动态关键字参数)

def chi(food, drink):
    """
    这里是函数的注释，先写一下当前这 个函数是干什么的，比如我这个函数就是-个吃
    :param food: 参数food是什么意思
    :param drink:参数drink是什么意思
    :return:返回的是什么东东
　　"""
    print(food, drink)
    return "very good"

def fun():
    a =10
    print(a)

fun()
print(a) # a不存在了已经..所以会报错

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

func() # 20

a =10
def func():
    a= 40
    b=20
    def abc():
        print("哈哈")
    print(a, b) # 这里使用的是局部作用域  40 20
    print(globals())  #打印全局作用域中的内容  {‘__name__‘: ‘__main__‘, ‘__doc__‘: None, ‘__package__‘: None, ‘__loader__‘: <_frozen_importlib_external.SourceFileLoader object at 0x10316f550>, ‘__spec__‘: None, ‘__annotations__‘: {}, ‘__builtins__‘: <module ‘builtins‘ (built-in)>, ‘__file__‘: ‘/tt.py‘, ‘__cached__‘: None, ‘a‘: 10, ‘func‘: <function func at 0x101ecee18>}
    print(locals())  #打印局部作用域中的内容  {‘abc‘: <function func.<locals>.abc at 0x103514f28>, ‘b‘: 20, ‘a‘: 40}

print(locals())  #打印全局作用域中的内容  {‘__name__‘: ‘__main__‘, ‘__doc__‘: None, ‘__package__‘: None, ‘__loader__‘: <_frozen_importlib_external.SourceFileLoader object at 0x10306f550>, ‘__spec__‘: None, ‘__annotations__‘: {}, ‘__builtins__‘: <module ‘builtins‘ (built-in)>, ‘__file__‘: ‘/tt.py‘, ‘__cached__‘: None, ‘a‘: 10, ‘func‘: <function func at 0x101ecee18>}
func()

def fun1():
    print(111)

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

fun2()
print(111)

# 结果
222
111
111




#函数的嵌套
def fun2():
    print(222)
    def fun3():
        print(666)
    print(444)
    fun3()
    print(888)
print(33)
fun2()
print(555)   

# 结果
33
222 
444
666
888

global: 在局部引入全局变量
nonlocal: 在局部...内层函数引入外层离他最近的那个局部变量.

global:在局部命名空间引入全局命名空间中的变量
nonlocal:在局部命名空间引入外层局部命名空间中的变量

nonlocal找离它自身最近的局部
global只找全局的，全局没有报错;nonlocal只找局部的,局部没有报错

a =100
def func():
    global a #加了个global表示不再局部创建这个变量了，而是直接使用全局的a
    a=28  # 这里是修改全局的变量,如果不加上面一行是在局部空间创建一个新的变量
    print(a)  # 28

func()
print(a)  # 28

lst = ["麻花藤”， “刘嘉玲”， ”詹姆斯"]
def func():
    lst . append("马云云")#对于可变数据类型可以直接进行访问，但是不能改地址.说白了.不能赋值
    print(lst)  # lst = ["麻花藤”， “刘嘉玲”， ”詹姆斯","马云云"]


func()
print(lst)  # lst = ["麻花藤”， “刘嘉玲”， ”詹姆斯","马云云"]

a=10
def func1():
    a=20
    def func2():
        nonlocal a  # 将a=20引入
        a=30  # 改变引入的a
        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 = 2
        a=3  # 改变外层的a从2变成3
        def fun_3():
            a=4  # 新建
            print(a)  # 4
        print(a)  # 3
        fun_3() # 4
        print(a)  # 3
    print(a)  # 2
    fun_2()  # 3  4  3
    print(a)  # 3


print(a)  # 1
fun_1()  # 2    3  4  3   3
print(a)  # 1