python第二阶段学习-函数

函数

函数结构

自定义函数写上帮助内容，便于自己和他人阅读：
用函数名称.help()调用

def 函数名称(参数):
    """
    设置参数，可用help()调用显示
    :param 参数:
    :return:
    """
    代码1
    代码2
    return 返回值

函数作用域

全局变量以及局部变量

函数使用外部变量时，可以传参，要么进行全局变量

data = 100  # 口袋里面的money

def bonus(value):
    """奖金"""
    global data
    # 计算奖金和口袋的总余额
    data = data + value
    print(f'口袋余额{data}元')

def fine(value):
    """罚款"""
    global data
    data = data - value
    print(f'口袋余额{data}元')

bonus(1000)
fine(9999)

当使用可变数据类型，不需要global申明

data = []

def a():  # 当使用的是可变数据类型，不需要global声明
    # global data
    data.append(1)
    pass

a()
print(data)

#--------------------------------------------------
输出结果：
[1]

函数传参

多参数传参

def func(a, c):
    return a, c

a, c = func(1, 2)
print(a, c)

默认值传参以及关键字传参

传参
name = '小明'
age = 18
gender = '女'

# gender='男' 设置默认值  默认值后面跟默认值
def func(name,age,  gender='男'):  # 传参:位置 顺序 个数
    print(name, age, gender)

# 调用
func(name,age=age)

输出结果为：

小明 18 男

不确定参数传参

*args：不定长传参

def burden(*args):  # 打包和不打包
    print(f"爆炒土豆里面的配料有 {'/'.join(args)}")
    print(f"爆炒土豆里面的配料有 {args}")

burden('辣椒粉', '番茄酱', '葱丝', '孜然')  # 不知道里面会加什么

kwargs：不定长关键字传参
键值对kwargs：key=value
其内部的结果：kwargs：是字典

# **kwargs  不定长关键字参数

def burden(**kwargs):
    print(kwargs)

# 需要以关键字传入
burden(data1='辣椒粉', data2='番茄酱', data3='葱丝', data4='孜然') # **kwargs的关键字传入
# 键值对传入是用等号赋值的形式,而不是字典的形式，传入的不是字典而是键值对

递归

递归特点：

1.函数内部调用自己
2.必须要有出口，无限循环的是报错，不算递归

def total(data):
    if data == 1:
        return 1
    return data + total(data - 1)

print(total(5))

匿名函数

匿名函数定义

匿名函数作用： 优化代码 减少内存的使用 匿名函数一般使用在函数的里面
从其他函数转换而来 函数的简易写法
函数只能有一个返回值 ，只能有一句代码

匿名函数结构

原函数：

def func(a, b):
    return print(a + b)

func(1, 2)

匿名函数

# (lambda a, b: print(a + b))(1, 2)
func = (lambda a, b: print(a + b))
func(1, 2)

匿名函数应用

常作为函数传参使用

list1 = [['a-1', 10], ['d-2', 80], ['c-6', 20], ['b-0', 40]]
list1.sort(key=lambda i: i[0][2])  # 根据数据的具体值进行排序
# 其中i为传入参数，i[0][2]为输出参数
print(list1)

2. map()函数映射

list1 = [1, 2, 3, 4, 5, 6, 7, 8, 9]
# map(匿名表达式,需要映射的数据)
print(list(map(lambda x: str(x+1), list1)))  # 可迭代对象
print(list1)

3.其他函数

from functools import reduce
# 从 functools库里面 导入(import) reduce

list1 = [1, 2, 3, 4]  # sum()
print(reduce(lambda a, b: a * b, list1))

# filter 过滤数据
list1 = [1, 2, 3, 4, 5, 6, 7, 8, 9]
print(list(filter(lambda s: s % 2 != 0, list1)))

函数嵌套

一闭三器

装饰器

装饰器是函数嵌套，在一个函数中有另一个函数，函数只是声明
其目的是在不改变源代码的情况下为源代码增添新功能

def func(fun1):

    def inner(*args):
        res = fun1(*args)
        return res

    return inner


# @func  # fun1 = func(fun1)
# def fun1(a, b):
#     return a + b

@func
def fun1(a, b):
    c = a + b
    return c


@func  # 2
def fun2(a, b, c):
    c = a - b + c
    return c

print(fun1(1, 2))
print(fun2(2, 1, 3))

其具体流程是调用fun1(1,2)时，现在外面寻找fun1=func(fun1),调用func函数。在里面遇到inner函数的声明，没有运行里面的代码，然后返回的时候调用了inner函数，再运行里面的