Python系列 之 函数

OS：Windows
Python：3.8.8
IDE：Sublime Text 3

函数的参数

位置参数和默认参数

定义一个函数，里面包含两个参数，param1 是位置参数在调用函数的时候必须提供的，param2是 默认参数 设置的默认值为 None（当然可以设置成其他值；注意：定义默认参数尽量指向不变对象）

def demo_function1(param1, param2=None):
    """
    函数的 位置参数 和 默认参数
    param1:位置参数，调用函数时应给予参数，否则报TypeError
    TypeError: * missing 1 required positional argument: *
    param2:默认参数,调用函数时可不提供该参数,当前默认None
    """
    print(param1)
    print(param2)

调用 demo_function1 参数 param1 赋值 “param1”

# 调用 demo_function1 只给位置参数 param1 赋值
#两种赋值方式都可以
#demo_function1(param1="param1")
demo_function1("param1")

输出：

param1
None

调用 demo_function1 参数 param2 重新赋值 “param2”

    demo_function1("param1", param2="param2")
    # demo_function1("param1", "param2")

输出：

param1
param2

可变参数和关键字参数

定义函数的可变参数和关键字参数和上面的位置参数和关键字参数理论上是一样的，只是把参数的概念进行了抽象化
定义一个可变参数和关键字参数的函数：

def demo_function2(*args, **keywords):
    """
    函数的可变参数和关键字参数
    *args :    可变参数
    *keywords :关键字参数
    """
    print(args, keywords)

*args ： *符号定义了 args 是可变参数(备注 args 只是一个名字，也可以是别的名字)
**keywords： **符号定义了 keywords 是关键字参数(备注 keywords 也只是一个名字，也可以是别的名字)
调用 demo_function2：

	# args 是 1, 2,"3" keywords是 A="a",B="b"
    demo_function2(1, 2,"3", A="a",B="b")

输出：

(1, 2, ‘3’) {‘A’: ‘a’, ‘B’: ‘b’}

可以看出 args 相当于是一个 tuple ; keywords是个 dict
把 demo_function2 改动一下就可以拿到args和keywords的每个值；修改 demo_function2 ：

def demo_function2(*args, **keywords):
    """
    函数的可变参数和关键字参数
    *args :    可变参数
    *keywords :关键字参数
    """
    #print(args, keywords)
    for arg in args:
        print(arg)
    for keyword in keywords:
        print(keywords[keyword])

再次调用修改后的 demo_function2：

    # args 是 1, 2,"3" keywords 是 A="a",B="b"
    demo_function2(1, 2, "3", A="a", B="b")

输出：

1
2
3
a
b

print部分可以改成你想要的逻辑
也可以像下面这样调用demo_function2函数 效果是一样的：

    param_list = [1, 2, "3"]
    param_dict = {"A": "a", "B": "b"}
    #demo_function2(1, 2, "3", A="a", B="b")
    demo_function2(*param_list, **param_dict)

高阶函数

map函数

map函数接收两个参数：第一个参数是一个函数，第二个函数是一个 Iterable对象；map函数的作用是将 Iterable对象中的每一个元素代入到 第一个函数中，返回一个新的 Iterator

先定义一个函数用来当做map函数的参数：
函数 map_function 功能：如果param是str类型的就转小写

def map_function(param):
    """将参数param变成小写"""
    if isinstance(param, str):
        param = param.lower()
    return param

定义一个列表 作为map函数的第二个参数：

demo_list = ["A", "B", "c", 1, 2, 3]

map函数调用：

result = map(map_function, demo_list)

由于map函数返回的是Iterator 惰性序列，可以用list转换成列表

result = list(result)

完整示例：

def demo_function3():
    """
    map函数使用
    """
    demo_list = ["A", "B", "c", 1, 2, 3]
    result = map(map_function, demo_list)
    result = list(result)
    print(result)

def map_function(param):
    """将参数param变成小写"""
    if isinstance(param, str):
        param = param.lower()
    return param

调用 demo_function3 函数：
输出：

[‘a’, ‘b’, ‘c’, 1, 2, 3]

filter函数

filter函数可以用来过滤序列中的特定元素
用法和map函数一样，语法结构

filter(filter_function, iterable_list)

先定义一个 filter_function ：

def filter_function(param):
    """如果是str 就返回 True"""
    return isinstance(param, str)

然后给出一个 iterable_list ：

iterable_list = [1, 2, 3, "A", "b", "C"]

用filter函数进行过滤 并输出结果：

result = list(filter(filter_function, iterable_list))
print(result)

输出：

[‘A’, ‘b’, ‘C’]

最后的结果只保留了 str 类型，int型 被过滤掉了。
完整示例：

def filter_function(param):
    """如果是str 就返回 True"""
    return isinstance(param, str)

def demo_function6():
    iterable_list = [1, 2, 3, "A", "b", "C"]
    result = list(filter(filter_function, iterable_list))
    print(result)

调用demo_function6函数，输出：

[‘A’, ‘b’, ‘C’]

结合map函数和filter函数 输出 列表中字符串，并转换成小写：

def map_function(param):
    """将参数param变成小写"""
    if isinstance(param, str):
        param = param.lower()
    return param
    
def demo_function6():
    iterable_list = [1, 2, 3, "A", "b", "C"]
    result = list(filter(filter_function, map(map_function, iterable_list)))
    print(result)

调用demo_function6函数，输出：

[‘a’, ‘b’, ‘c’]

reduce函数

reduce函数和map函数类似，第一个参数是一个函数，第二个函数是一个 Iterable对象，不同的地方在于，reduce的第一个参数的函数需要接收两个参数，reduce函数从Iterable对象中每次取两个元素计算结果，并将结果与Iterable对象的下一个元素代入第一个参数函数
先定义一个函数 reduce_function 用来作为reduce函数的第一个参数：

def reduce_function(param_x, parax_y):
    """返回参数乘积"""
    return param_x * parax_y

调用 reduce函数：

"""reduce函数使用"""
from functools import reduce
param_list = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
result = reduce(reduce_function, param_list)
print(result)

输出：

3628800

匿名函数 lambda

lambda语法结构 ： lambda 参数:逻辑表达式
例如：

lambda x: x + 1
#相当于 下面这个函数
# def f(x): 
#     return x + 1
lambda x, y: x + y
#相当于 下面这个函数
# def f(x, y):
#     return x + y

lambda 冒号之前的元素代表 函数参数（多个参数用逗号分隔）；冒号之后的表达式代表 计算逻辑，并将表达式的运算结果作为返回值 return

返回函数

函数也可以作为函数的返回值 例如：
可以直接用 lambda 作为函数的返回值 return（也可以是你自己定义的函数）
定义一个 demo_function5 函数：

def demo_function5():
    return lambda x, y: x + y

lambda作为函数的返回值 return
然后调用 demo_function5 ：

f = demo_function5()
print(f)
print(f.__name__)
print(f(1, 2))

输出：

<function demo_function5.<locals>.<lambda> at ***>
<lambda>
3

可以看出demo_function5的返回值 f 是个函数；函数 f 的名字是：lambda；调用 f(x,y) 可以计算 x+y的计算结果
注意：函数作为返回值，必须进行再次调用才会真正调用返回的函数 ：f(1, 2) 调用 f 之后 才会对 lambda 函数的表达式进行计算

装饰器

假如现在有一个函数，如果不想改变现有函数，而且想让函数执行的时候新增其他功能，那这时候就可以使用装饰器；先写个简单的例子：
demo_function7函数 ：

def demo_function7():
    print("这里是demo_function7函数")

如果想要在demo_function7执行前再执行其他功能的话；先写一个装饰器函数：

def wrapper_function(fn):
    """装饰器函数"""
    def wrapper(*args, **keywords):
        print("这里是装饰器函数输出")
        return fn(*args, **keywords)
    return wrapper

然后修改demo_function7函数：

@wrapper_function
def demo_function7():
    print("这里是demo_function7函数")

只是在函数定义上面添加了 @wrapper_function
调用demo_function7 输出：

这里是装饰器函数输出
这里是demo_function7函数

调用demo_function7函数的时候就相当于调用了：

wrapper_function(demo_function7)()

如果想要在demo_function7函数执行前后都进行一些操作的话，
修改wrapper_function函数：

def wrapper_function(fn):
    """装饰器函数"""
    def wrapper(*args, **keywords):
        print("这里是demo_function7函数执行之前")
        func = fn(*args, **keywords)
        print("这里是demo_function7函数执行之后")
        return func
    return wrapper

调用demo_function7 输出：

这里是demo_function7函数执行之前
这里是demo_function7函数
这里是demo_function7函数执行之后

如果wrapper_function函数需要传入参数的话；
修改wrapper_function函数：

def wrapper_function(param):
    """装饰器函数"""
    def decorator(fn):
        def wrapper(*args, **keywords):
            print(f"这是wrapper_function的参数：{param}")
            print("这里是demo_function7函数执行之前")
            func = fn(*args, **keywords)
            print("这里是demo_function7函数执行之后")
            return func
        return wrapper
    return decorator

然后修改demo_function7函数：

@wrapper_function("param")
def demo_function7():
    print("这里是demo_function7函数")

“param” 就是传给wrapper_function函数的参数
调用demo_function7函数 输出：

这是wrapper_function的参数：param
这里是demo_function7函数执行之前
这里是demo_function7函数
这里是demo_function7函数执行之后

此时调用demo_function7函数，相当于执行了：

wrapper_function("param")(demo_function7)()

接下来，如果直接调用wrapper_function函数：

res = wrapper_function(demo_function7)
print(type(res))
res = wrapper_function("param")(demo_function7)
print(type(res))

输出

<class ‘function’>

返回值是个 函数 类型；那看看函数名字是什么：

print(res.__name__)#输出函数名称

输出：

wrapper

这是因为wrapper_function的返回值是wrapper函数；所以加载了装饰器的函数__name__属性，被更换成了wrapper，这样一来，有些依赖函数签名的代码执行就会出错，现在需要借助functools.wraps来解决这个问题；
现在修改wrapper_function函数：

def wrapper_function(param):
    """装饰器函数"""
    def decorator(fn):
        from functools import wraps

        @wraps(fn)
        def wrapper(*args, **keywords):
            print(f"这是wrapper_function的参数：{param}")
            print("这里是demo_function7函数执行之前")
            func = fn(*args, **keywords)
            print("这里是demo_function7函数执行之后")
            return func
        return wrapper
    return decorator

在wrapper_function函数里面的wrapper函数定义上面加装了
wraps作为装饰器，wraps是Python内置的工具
注意需要：

from functools import wraps

再次调用：

res = wrapper_function("param")(demo_function7)
print(res.__name__)#输出函数名称

输出：

demo_function7

带参数装饰器的完整示例：

def wrapper_function(param):
    """装饰器函数"""
    def decorator(fn):
        from functools import wraps

        @wraps(fn)
        def wrapper(*args, **keywords):
            print(f"这是wrapper_function的参数：{param}")
            print("这里是demo_function7函数执行之前")
            func = fn(*args, **keywords)
            print("这里是demo_function7函数执行之后")
            return func
        return wrapper
    return decorator
    
@wrapper_function("param")
def demo_function7():
    print("这里是demo_function7函数")

至此，有关Python的函数暂时告一段落；
如果有什么错误的地方，欢迎评论指正。