函数

函数的动态参数

动态参数可以接受很多的实参对象

动态接受位置参数

def func(*args):   #args是万能的位置参数
    print(args)    # *在函数定义的时候是聚合，接收形式是元组

def func(*args):   
    print(*args)   #  *在函数调用的时候是打散

# args可进行修改，约定俗称，一般不做修改

def eat(*args):
    print('我想吃',args)
eat('大米饭','中米饭','小米饭')  
#结果：我想吃 ('大米饭', '中米饭', '小米饭') 以元组形式返回

def eat(*args):
    print('我想吃',*args)
eat('大米饭','中米饭','小米饭')  
#结果：我想吃 大米饭 中米饭 小米饭

在函数定义时，动态参数必须在位置参数后面

def func(*args,a,b):
    print(*args,a,b)
func(3,4,53,74,7,234)
#结果：TypeError: func() missing 2 required keyword-only arguments: 'a' and 'b'
func函数在传参的过程中发现了两个参数没有传递

默认参数与动态参数优先级

def func(a,b=34,*args):
    print(a,b,*args)
func(1,1,23,42,6346,754)
#结果：1 1 23 42 6346 754  默认参数b的值由34覆盖为1

由此，我们得出形参以下优先级关系：

位置参数，动态位置参数，默认参数

动态接受关键字参数

def func(**kwargs):  #kwargs是万能的关键字参数
    print(kwargs)
func(a=1,b=4,c=3)
#结果：{'a': 1, 'b': 4, 'c': 3}  #kwargs接收到的是字典的形式

def func(**kwargs):
    print(*kwargs)
func(a=1,b=4,c=3)
#结果：a b c  # *kwargs接收到的是字典的键

形参优先级关系：

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

万能传参

def func(*args,**kwargs):
    print(args,kwargs)
func(1,23,5,a=1,b=6)

补充内容

lst = [1,4,7]

# 方法一(笨方法)

def func(*args):
    print(args)
func(lst[0],lst[1],lst[2])



# 方法二

def func(*args):
    print(args)
func(*lst)  
# 在实参的位置上用*将lst(可迭代对象)按照顺序打散

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

dic = {'a':1,'b':2}
def func(**kwargs):
    print(kwargs)
func(**dic)   #字典也可以进行打散,不过需要**

函数的注释

def func(a,b):
    """
    比较大小函数
    :param a: a int
    :param b: b int
    :return: 返回a和b中较大的一个数
    """
    return a if a > b else b
print(func(5,6))

三元运算符

return a if a > b else b

名称空间

名称空间的分类

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

加载顺序

内置空间 全局空间 局部空间

取值空间

局部空间 全局空间 内置空间(找不到就报错了!)

作用域

全局作用域：内置空间 +全局空间

局部作用域：局部空间

函数的嵌套

• 不管在什么位置，只要是函数名+（）就是调用此函数
• 函数调用执行后，函数体中开辟的空间就自动销毁了

def fun1():        # 1
    print(111)     # 6
def fun2():        # 2
    print(222)     # 4
    fun1()         # 5
fun2()             # 3
print(111)         # 7

def fun2():            # 1  
    print(222)         # 4
    def fun3():        # 5
        print(666)     # 8
    print(444)         # 6
    fun3()             # 7
    print(888)         # 9
print(33)              # 2
fun2()                 # 3
print(555)             # 10

global 和nonlocal

global

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

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

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

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

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)
#结果
1  2  3  4  3   3  1

函数补充

原文：https://www.cnblogs.com/lifangzheng/p/11203456.html