函数

动态参数
def chi (good_food,no_good_food,zero_food,drink):
    print("我要吃",good_food,no_good_food,zero_food,drink)

chi("一锅大米饭","一箱辣条","一桶方便面","4L可乐")
chi("方便面")
chi("一大锅米饭","一锅小米饭","一箱辣条","一桶方便面","4L可乐")



def chi (*food): # *表示的是不定参数,可以传递任意个信息   food接受的是元组  *表示接受为止参数的动态传参
    print("我要吃",food)
chi("一锅大米饭","一箱辣条","一桶方便面","4L可乐")
chi("方便面")
chi("一大锅米饭","一锅小米饭","一箱辣条","一桶方便面","4L可乐")

def chi (*food):
    print("我要吃",food)
chi("米饭","包子","饺子","可乐","果汁")
chi("煎饼")
chi("果汁","叉烧包","天津麻花","天津狗不理包子")
chi("苹果","葡萄","芒果","香蕉","西瓜","火龙果","桃子","梨子",)


顺序的问题 传参的顺序    *args  在默认值前  **kwargs

def func(a, b, *args): #arguments 参数
    print(a, b, args)
func(1.2.3..)

如果默认值参数在*args前面,如果想让默认值生效.*args将永远接不到值

def func(a, b, *args , c = 5): #
    print( a,b,c,args)

实参 1.位置参数2.关键字参数 3.
*args  位置参数
**kwargs   关键字参数


def func (**kwargs):#key word arguments
    print(kwargs)
func(a =10, b = 20,jay = "周杰伦",)
无敌模式  接受所有的参数    动态传参
def func (*args, **kwargs):
    print(args)
    print(kwargs)

func(1, 2, 5, jj="陶洁",jay = "周杰伦")

def func (*args):在这里其实相当于吧传进来的参数做了一次聚合,聚合成一个元祖
    print(args)
lst = ["大白菜","小白菜","娃娃菜","大头菜"]
# func(lst[0],lst[1],lst[2],lst[3])
fuc(*lst)          #在实参位置* 表示打散  打散的是可迭代对象



def func (**kwargs):**把接收到的关键字参数打包(聚合)成字典
    print(kwsrgs)  一定是字典

dic = {"张无忌":"明教教主","谢逊":"金毛狮王","范瑶":"光明右使"}
func(张无忌 =dic["张无忌"],谢逊 =dic["谢逊"],范瑶 =[""])
func(**dic)这里的**是吧字典打散,字典的key作为参数的名字,字典的值作为参数的值传递给形参



在形参上
1.位置参数
2.默认值参数
3..动态参数
    1.*args 位置参数的动态传参,系统会自动的吧所有的位置参数聚合成元组
    2.**kwargs  关键字的动态传参,系统会自动把所有的国建参数聚合成字典
    3.def func(*args,**kwargs):无敌传参
    4.顺序:位置参数, *args ,默认值 ,**kwargs
    5.在使用的时候,可以任意的进行搭配
4. 在实参上.* ,**表示的打散. 在形参*. **表示聚合

名称空间
def func():
    a = 10
    print(a)
最开始会开辟一个自己的命名空间___内置名称空间
a = 10
print(a)
直接在py文件一个层面上的全局名称空间
def func():
    hasakey = 10
在函数内部属于局部名称空间
func()
加载顺序:  内置 =>全局 =>局部


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

取值顺序  局部 =>全局 =>内置

def func():
    print(a)

作用域:   变量或者函数的声明周期
a = 10   #全局
def func():
    func = "名字"


全局作用域: 全局名称空间+ 内置名称空间
局部作用域: 局部名称空间

#1.globals() 查看全局作用域中的所有内容
qiao = "乔峰"
def func ():func 名字
    bgm = "降龙十八掌"
    print("娃哈哈")
    print(locals())
# print(globals()) #查看全局作用域中的内容
# print(locals())# locals()查看的是当前作用域中的内容


函数的嵌套
def func1 ():
    print("我是func1")

def func2 ():
    print("我是func2")
    func1()

def func3 ():
     func2()
     print("我是func3")
func3()
这样的的代码不是嵌套,互相调用:

函数可以互相嵌套
def outer():
    def inner():
        print("我是内部的")
    print("我是外部的")

outer()

引入全局变量,可以定义全局变量
def func():
    global a 没有也得有, 自动帮你创建
    a = 20

func()
print(a)

nonlocal 引入局部中离他最近的外层变量
def outer():
    a = 10
    def inner():
        nonlocal a  找的是局部当中,理他最近的上层的那个变量
        a = 20
        print(a)
    print(a)
    inner()
    print(a)
outer()