Python 函数

1.函数

函数是指将一组语句的集合通过一个名字(函数名)封装起来，要想执行这个函数，只需调用其函数名即可

特性:

• 减少重复代码
• 使程序变的可扩展
• 使程序变得易维护

1.1 函数的定义与调用

• 函数先定义后调用，先调用会报错
• 没有调用函数，函数里的代码不会执行
• 函数的执行流程：
  • 调用函数时，解释器回到定义函数的地方执行函数体内的代码，代码执行完回到调用代码的地方，继续向下执行
  • 定义函数时，函数体内部的代码不会执行

def func():# func 函数名
    print("Hello")
func() # 调用函数

1.2 函数参数

函数参数的传值顺序，第一个实参(2)传给第一个形参(x)

# 改成用函数写
def calc(x,y): x,y形参
    res = x**y
    return res # 返回函数执行结果
  
c = calc(2,3)  # # 2,3实参，也是位置参数,结果赋值给c变量
print(c)

1.3 默认参数

def test(x,y=1):   # y=1 就是默认参数
      print(x)
      print(y)
test(21)          # 如果y的实参不写，默认y=1
test(21,22)　　　　# y 有实参，就不会用默认值

1.4 关键参数

正常情况下，给函数传参数要按顺序，不想按顺序就可以用关键参数，只需指定参数名即可，但是关键参数必须放到位置参数后

def test(x,y): 
      print(x)
      print(y)

test(x=2,y=1)

1.5 非固定参数

若你的函数在定义时不确定用户想传入多少个参数，就可以使用非固定参数

• *args，会把传入的参数变成一个元组

def test1(x,*args):    
      print(x)
      print(args)
test1(21)
#结果: 21 ()     # 后面这个()就是args,只是因为没传值,所以为空
 
test1(1,2,3,4) 
#结果：1 (2,3,4)

• **kwargs，会把传入的关键字参数打包成字典

def test1(x, *args, **kwargs):
    print(x)
    print(args)
    print(kwargs)


test1(21) # 结果：21 () {} #后面这个{}就是kwargs,只是因为没传值,所以为空

# 结果：21,(12,22),{'name':'ale','age':'6'}
test1(21, 12, 22, name='jack', age='8')

• 在调用时使用 * 或 **

  • *，把元组或列表进行解包
  • **，把字典进行解包

def test(*args,**kwargs):
    print(args)
    print(kwargs)

lis = [1,2]
dic = {"name":"Jack","age":18}
test(*lis,**dic)    # 相当于 test(1,2,name="Jack",age=18)

2. 局部变量与全局变量

2.1 全局与局部变量

• 在子程序中定义的变量称为局部变量，在程序的一开始定义的变量称为全局变量。
• 全局变量作用域是整个程序，局部变量作用域是定义该变量的子程序。
• 当全局变量与局部变量同名时：在定义局部变量的子程序内，局部变量起作用；在其它地方全局变量起作用。

2.2 特殊

• 列表，字典，集合，类可以在局部变量里修改。
• 字符串和整数不可以在局部变量里修改

"""
def change_name(name):
    print("before change",name) # 输出：before change jack
    name="kaer"
    age=23
    print("sfer change",name)   # 输出：sfer change kaer

name='jack'
change_name(name)
print(name) # jack
"""

"""
def change_list(name):
    print("before change",name) # 输出：before change [1, 2, 3]
    name.append(4)
    print("sfer change",name)   # 输出：sfer change [1, 2, 3, 4]

list1 = [1,2,3]
change_list(list1)
print(list1) # 输出：[1, 2, 3, 4]
"""

3. return 返回值

要想获取函数的执行结果，就可以用return语句把结果返回

注意:

• 函数在执行过程中只要遇到return语句，就会停止执行并返回结果，也可以理解为 return 语句代表着函数的结束
• 如果未在函数中指定return，那这个函数的返回值为None

# 把传入的参数相乘，在返回
def test(*args):
    num = 1
    for i in args:
        num *= i
    return num
res = test(2,3,4)
print(res)  # 结果：24

4. 递归函数

在函数内部，可以调用其他函数。如果一个函数在内部调用自身本身，这个函数就是递归函数

def test(x):
    print(x)
    if int(x/2) > 0:
        return test(int(x/2))
test(10)

递归特性:

• 必须有一个明确的结束条件
• 每次进入更深一层递归时，问题规模相比上次递归都应有所减少
• 递归效率不高，递归层次过多会导致栈溢出（在计算机中，函数调用是通过栈（stack）这种数据结构实现的，每当进入一个函数调用，栈就会加一层栈帧，每当函数返回，栈就会减一层栈帧。由于栈的大小不是无限的，所以，递归调用的次数过多，会导致栈溢出）

5. 高阶函数

变量可以指向函数，函数的参数能接收变量，那么一个函数就可以接收另一个函数作为参数，这种函数就称之为高阶函数.

# abs() 函数的作用：数字求绝对值的计算
def add(x,y,f):
      return f(x)+f(y)
res = add(3,-6,abs)
print(res)

6. 闭包函数

闭包的定义: 内函数使用外函数的局部变量，外函数将内函数返回出来的方法叫闭包，返回的内函数叫闭包函数.
闭包的特点: 延长了外函数局部变量的生命周期(实际内存给它存储了这个值,暂时不释放)
闭包的意义: 闭包可以优先使用外函数中的变量，并对闭包中的值起到了封装保护的作用。外部无法访问。

def test():
    name = "Jack"
    age = 18
    def youName():
        print("他的名字叫{}。".format(name))
    def youAge():
        print(f"{name}今年{age}岁了。")

    def master():
        return [youName,youAge]
    return master
func = test()   # 返回 master() 函数的内存地址
lis = func()    # 返回 youName()和youAge() 函数的内存地址
print(lis)
he_name = lis[0]   # 获取函数的内存地址
he_name()       # 执行函数
he_age = lis[1]
he_age()        # 执行函数

6.1 closure 和 cell_contents

• __closure__　 # 判断是不是闭包
• cell_contents　 # 获取对象中的内容

def test():
    name = "Jack"
    age = 18
    def youName():
        print("他的名字叫{}。".format(name))
    def youAge():
        print(f"{name}今年{age}岁了。")

    def master():
        return [youName,youAge]
    return master
func = test()   # 返回 master() 函数的内存地址
lis = func()    # 返回 youName()和youAge() 函数的内存地址


tup = func.__closure__    # 如果返回的元组中有数据说明是闭包
print(tup)                # 打印返回值 
func1 = tup[0].cell_contents    # 获取第一个元素对象中的内容
func1()
func2 = tup[1].cell_contents    # 获取第二个元素对象中的内容
func2() 

7. 匿名函数

用一句话来表达只有返回值的函数

• 特点：简洁，高效
• 语法：

lambda 参数 : 表达式

无参的lambda表达式

# 函数
def func():
    return "无参的 lambda 表达式"

# lambda 表达式
func_lam = lambda :  "无参的 lambda 表达式"
print(func_lam())    # 打印结果：无参的 lambda 表达式

有参的lambda表达式

# 函数
def func(n):
    return "有参的 lambda 表达式，参数：{}".format(n)

# lambda 表达式
func_lam = lambda n :  f"有参的 lambda 表达式，参数：{n}"
print(func_lam("90"))   # 打印结果

可变参数的表达式

# *args 表达式
res = lambda *args : args
print(res(1,2,3))
 
# **kwargs 表达式
res2 = lambda **kwargs : kwargs
print(res2(name="Kaer",age=18))

判断条件的lambda表达式

# 函数
def func(n):
    return "奇数" if n % 2 == 1 else "偶数"

# lambda 表达式
func_lam = lambda n :  "奇数" if n % 2 == 1 else "偶数"
print(func_lam(907))   # 打印结果

排序的lambda表达式

stu = [
    {"name":"Jack","age":18},
    {"name":"Kaer","age":22},
    {"name":"Tom","age":20}
]
stu.sort(key = lambda x:x["age"],reverse=True)
print(stu)