python 函数的动态参数 命名空间,作用域以及函数嵌套,global和nonlocal (重点)

*** 坚持坚持,即使你不太强***

1.函数的动态传参

2.函数的命名空间及作用域

3.函数嵌套

4.global和nonlocal关键字

一.函数的动态传参

1. *args: 位置参数动态传参,  *号在这里表示接收位置参数的动态传参,接收的是元组.

例:

def chi(*food):            #参数名是food *表示动态传参
    print(food)
chi("大米饭","龙虾面","馒头")
chi("馒头","盖浇饭")
chi()

# ('大米饭', '龙虾面', '馒头')
   ('馒头', '盖浇饭')
   ()

例:

def chi(name,*food,location = "北京"):    #默认值参数需要放到后面
     print(location)
     print(name + "要吃",food)
chi("李启政","盖浇饭","火腿肠","大米饭",)
 #  北京
    李启政要吃 ('盖浇饭', '火腿肠', '大米饭')

默认值参数放在位置参数动态传参前面之前只有一种情况可能会生效,那就是没有动态参数时;如果位置排序如上图,这个时候如果不给出关键字传参. 那么你的默认值是永远都生效的.

例:

def chi(a, b, c='馒头', *food):
 print(a, b, c, food)
chi("大米饭","盖浇饭")  #'大米饭','盖浇饭','馒头',() 默认值生效
chi("大米饭","盖浇饭","火腿肠","猪蹄")  # '大米饭', '盖浇饭', '火腿肠','猪蹄' 默认值不生效

注: 动态接收参数的时候要注意, 动态参数必须在位置参数后面,不然程序会报错,后面的位置参数永远接收不到参数.想要解决报错问题,就要

　把后面的位置参数改为关键字参数.

例:

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 = "猪蹄") # 必须用关键字参数来指定

所以,顺序为: 位置参数 =>  *args(位置参数动态参数) => 默认值参数

2. **kwargs : 关键字参数动态传参 ,接收关键字参数的动态传参.接收的是字典.

在python中使用 **kwargs 来表示接收关键字动态参数

例:

def func(**kwargs):
 print(kwargs)
func(a=1, b=2, c=3)
func(a=1, b=2)
# 接收的是一个字典
{'a': 1, 'b': 2, 'c': 3}
{'a': 1, 'b': 2}

 顺序的问题, 在函数调用的时候, 如果先给出关键字参数, 则整个参数列表会报错.所以关键字参数必须在位置参数后面. 由于实参是这个顺序. 所以形参接收的时候也是这个顺序. 也就是说位置参数必须在关键字参数前面. 动态接收关键字参数也要在后面.

例:

 def func(a, b, c, d): print(a, b, c, d) # 关键字参数必须在位置参数后面, 否则参数会混乱 func(1, 2, c=3, 4) 

如果想接收所有的参数:

*args , **kwargs       #无敌传参

def chi(*food2, **food): # 无敌传参
        print(food)

chi("狗不理", "汉堡",drink="大白梨",ice_cream="哈根达斯")

 def fun(a, *args, c="哈哈", **kwargs): print(a, args, c, kwargs) 

所以,最终顺序为: 位置参数 =>  *args => 默认值参数 => **kwargs

3.函数的注释:

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

4.形参和实参的聚合与打散:

形参: 聚合
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.命名空间

在python解释器开始执行之后, 就会在内存中开辟一个空间,我们给存放名字和值的关系的空间起一个名字叫: 命名空间. 我们的变量在存储的时候就是存储在这片空间中的.

命名空间分类: 1. 全局命名空间--> 我们直接在py文件中, 函数外声明的变量都属于全局命名空间

　　　　　　  2. 局部命名空间--> 在函数中声明的变量会放在局部命名空间

　　　　　　 3. 内置命名空间--> 存放python解释器为我们提供的名字, list, tuple, str, int这些都是内置命名空间

a = 10 # 全局名称空间中的内容

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

取值顺序: 1. 局部命名空间 2. 全局命名空间 3. 内置命名空间

2.作用域:

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

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

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

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

例:

1. 内置, 2. 全局 , 3. 局部(函数调用)
a = 110 # 全局
def fn(): #
    b = 20 # 局部
    def gn(): # 局部
        print(globals())  # 可以查看全局作用域中的内容
        print(locals())  # 查看当前作用域中的内容
    gn()
fn()

三. 函数的嵌套

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

2. 函数的执行顺序

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

四.global 和 nonlocal 关键字

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

例:

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

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

例:

 a = 10                      #全局变量
    def func1():            
     a = 20
     def func2():          #在func中改变a的值
     nonlocal a             #寻找外层中离他最近的那个变量
     a = 30
     print(a)
 func2()
 print(a)

例:

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)