函数

1.1认识函数

函数将一些代码进行封装:减少代码重复性 (冗余),代码可读性高,将功能进行封装(造工具)

1.1.1定义函数：

# def 关键字  函数名():
    函数体(代码块)
def make():
    print('1')
    print('2')
    print('3')
    print('4')
    print('5')
    return 多个返回值是元组
make()  #函数名 + 小括号 == 调用
msg = make() # make == None  make() == '美女一枚'
print(msg)

1.2函数的返回值

def func():
    print('今天是周二')
    print('明天是周三')
    return 0.125
    print('后天是周四')
# return 返回值
# return 返回一个内容(就是内容本身) 可以返回任意类型
# return 返回多个内容,以元组的形式返回
# return 终止函数 ,切记不能终止循环
# return 下方的代码不执行
# return 不写返回值或者没有return就返回None
# return 将内容返回给了函数的调用

1.3函数的参数

# 参数
# 参数 定义的参数 形参
# 调用的参数是 实参         形参和实参的数量  一一对应
# 从实参到形参的过程 传参
# addr 是不是一个变量  addr = '家'
def func(addr,school): # 形参
    print(f'我在{addr}睡觉{school}')
    
func(addr = '家'，age = 18)
# 实参的角度：
    # func('清华','东莞')         位置
    # func(addr = '清华',school = '东莞')   关键字
    # func('清华',school = '东莞')         混合
# 实参的角度：
    # func(addr,school)             位置
    # func(school = '东莞')         默认参数
    # func(addr,school = '东莞')    混合   
    
#函数形参规则       位置参数 > 默认参数
#函数实参规则       位置参数 > 关键字参数

1.4函数的动态参数

def eat(a,b*args):      # 聚合 打包
    print(a,b,args)     # 元组
    # 形参位置    ：    位置参数   >   动态位置参数
 eat('1','2','3','4','5')
def eat(**kwargs):
    print(kwargs)       # 字典
 eat('q' = '1','w' = '2','e' = '3')   

def func(a,b,*args):    #聚合  
    print(a,b,*args)    #打散
# args 返回的是元组  *args 将元组打回原来的数组
func(1,2,3,4,5,6,7)

def func(a = 1,b = 2,**kwargs):    # 默认参数  ** 聚合
    print(a,b,kwargs)
func(a = 56, c = 22, b = 333, d = 66)

 def func(a,b,c = 1,*arg,**kwargs):  # 位置 > 动态位置 > 默认参数 > 动态默认参数
        print(a,b,c,args,kwargs)
 func(1,2,3,4,5,6,7,8,c = 33,d = 123,f = 345)

def func(*args,**kwargs):  #万能   无敌
    print(args,kwargs)
func(1,2,3,4,a = 1,b = 2)   # 位置  关键字  混合

'''
参数的优先级: 位置参数 > 动态位置参数 > 默认参数(关键字参数) > 动态关键字参数
1.万能传参: 动态位置参数,动态关键字参数 (最常用******)
2.位置参数,动态位置参数
3 动态位置参数,关键字参数,动态关键字参数
'''

1.5函数的注释

def func(*args,**kwargs):
    '''
    逻辑判断...
    :param args: 万能的位置参数
    :param kwargs: 万能的默认参数
    :return: 返回值
    '''
    print(args)
    print(kwargs)
    return

print(func.__doc__)   # 查看函数的注释 函数名.__doc__
print(func.__name__)  # 查看函数名 函数名__name__

1.6函数的命名空间

# 内置空间
# 全局空间
# 局部空间
    
# python关键字是存在内置空间的
# py文件中顶头写的内容就存在全局空间
# 函数内写的变量存在局部空间

# a = 1
# b = 2
y = 9
def func():
    y = 3     # 局部空间
    print(y)   #  3
def func1():
    print(y)   #  9  局部空间不能共享

# 找值顺序：局部空间 > 全局空间 > 内置空间
# 加载顺序：内置空间 > 全局空间 > 内置空间

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

1.7函数的嵌套

def func():
    print(1)
    def f1():
        print(2)
    return f1()
func()

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

1.8 global及nonlocal

 # 内置空间 +  全局空间 = 全局 globals()
 # 局部空间                 loacals()
a = 10
def func():
    a = 20
    print(a)
    print(globals())    # 查看全局作用域的内容
    print(locals())     # 查看局部作用域的内容
func()

a = 10
def func():
    global a    # 声明我要修改全局的变量a的值
    a = 20
    print(a)
func()
print(a)

n = 1
def func():
    n = 10
    def fun2():
        def func1():
            nolocal n  # 修改离得最近上一次里的变量值 上一层没有就继续往上找，找到全局最外层局部
            n = 100
            print(n)   # 10
        func1()
    func2()
func()
print(n)

# golbal  : 修改全局空间的变量对应的值
# nonlocal: 在外层的函数中，修改局部空间的变量值完全不涉及全局变量。只修改离它最近的一层，最近的一层没有变量继续向上找，直到找到最外层函数。

函数初识

原文：https://www.cnblogs.com/fengqiang626/p/11201358.html