动态参数,作用域

一.函数的动态参数

1.*args 位置参数动态传参

def chi(name,*food, location="北京"): # 参数名是food  *表示动态传参
     print(location)
     print(name+"要吃", food)
chi("刘旺鑫","狗不理","大麻花","天津")
chi("刘旺鑫","大米饭","小米饭")
chi("刘旺鑫","馒头")

2.*kwargs 关键字参数动态传参

形参列表顺序:位置参数  ,   *args   ,  默认值参数 ,   *kwargs

以上参数可以随意搭配使用

def chi(**food): 
     print(food)
chi(good_food="狗不理", no_good_food="汉堡",drink="大梨",ice_cream="巧乐兹")

def func(*food,**food2)  #参数名是food,food2.动态传参*,**

def fun(a, *args, c="哈哈",  **kwargs):
    print(a, args, c, kwargs)
fun(1, 2, 3, c=4,d=5, e=6)#c d e是变量名不能加""
结果:
1 (2, 3) 4 {'d': 5, 'e': 6}#key值加""

def func(*args,*kwargs ):   #使用情况多,  无敌参数

　　pass

3函数注释

 def func(a, b):
     """
     这个函数是用来计算a和b的和       
     :param a: 第一个数据
     :param b: 第二个数据
     :return: 返回的是两个数的和
     """
     return a + b

print(func.__doc__) # document文档       打印是不加()的函数名.__doc__
结果:
这个函数是用来计算a和b的和
    :param a: 第一个数据
    :param b: 第二个数据
    :return: 返回的是两个数的和
    

养成写注释的好习惯,能够让我们在工作中更顺利

形参的位置*,**:聚合

实参的位置*,**:打散

def func(*food): # 聚合, 位置参数
     print(food)
lst = ["鸡蛋","煎饼果子","猪蹄","滋滋冒油"]
#  实参: 打散
func(*lst) # 打散. 把list, tuple, set, str 进行迭代打散

# 聚合成关键字参数
def func(**kwargs):
    print(kwargs)
dic = {"name":'alex', 'age':'18'}
func(**dic) # 打散成关键字参数

二.命名空间

1.内置名称空间

2.全局名称空间

3.局部名称空间

a = 10 # 全局名称空间中的内容
def fn(): # fn也在全局名称空间
    b = 20 # 局部名称空间
    print(a)
def gn():
    print(a)
fn()
gn()

作用域:

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

2.局部作用域:局部名称空间

3.globals()和locals()的使用

　　globals():  查看全局中的内容

　　locals(): 查看当前作用域的内容

a = 110 # 全局
def fn(): #
    b = 20 # 局部
    def gn(): # 局部
        print(globals())  # 可以查看全局作用域中的内容
        print(locals())  # 查看当前作用域中的内容
    gn()
fn()

三.函数的嵌套

　　函数可以互相嵌套

def outer():
    print("哈哈")
    def inner_1():
        print("呵呵")
        def inner_1_1():
            print("嘻嘻")
        inner_1_1()
        print("吼吼")
    def inner_2():
        print("嘿嘿")
    inner_2()
    inner_1()
outer()

1.在函数嵌套中global和nonlocal的使用

global:在局部中访问全局中的内容

nonlocal: 在局部寻找外层函数中离他最近的那个变量

a = 10 # 全局变量本身就是不安全的, 不能随意修改
def func():
    global a  # 1. 可以把全局中的内容引入到函数内部 , 2. 在全局创建一个变量
    a = 20
    print(a)
func()
print(a)



def outer():
    a = 10
    def inner(): # 在inner中改变a的值
        nonlocal a # 寻找外层函数中离他最近的那个变量
        a = 20
    inner()

outer()

作用域的练习题:

a = 1
def fun_1():
    a = 2
    def fun_2():
        global 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)

总结:综上,函数嵌套后全局和局部的变量要分清,