python的高阶函数

接下来讲解一下python的高阶函数，再讲解下基于高阶函数的返回函数、装饰器等高阶函数：一个函数接收另外一个函数作为参数，这种函数就称之为高阶函数在这之前先看python的两种参数类型一、可变参数

---

python的函数中，可以定义可变函数，也就是传入的参数个数可变，如下：

正常函数写法

def mynum(numbers):
    mysum = 0
    for n in numbers:
        mysum =  mysum+n
    return mysum

print(mynum([1,2,3,4,5]))

使用可变参数

#使用可变参数
def mynum2(*numbers):
    mysum = 0
    for n in numbers:
        mysum =  mysum+n
    return mysum
print(mynum2(1,2,3,4,5))

#或者
mylist = [1,2,3,4,5]
print(mynum2(*mylist))

二、关键字参数

---

关键字参数允许传入任意个含参数名的参数，这些参数在函数内部自动组装成一个字典

如下：

def person(name,age,**kw):
    print('name:',name,"age:",age,"other:",kw)

person("zhan",30)
person("zhan",30,city="guangdong",school="beida")
others = {'city':"guangdong",'school':"beida"}
person("zhan",30,**others)

三、高阶函数

---

一个函数接收另外一个函数作为参数，这种函数就称之为高阶函数

a = abs(-10)
print(a)

def add(a,b,f):
    return f(a)+f(b)
a1 = add(-2,-4,abs)
print(a1)

内置高阶函数map

#内置高阶函数map
#map接收两个参数，一个是函数，一个是可迭代对象，map将传入的函数作用到序列每个元素，并作为迭代器返回
#示例：
def f(x):
    return x*x
r = map(f,[1,2,3,4,5])
#print(r) 迭代器
# for r1 in r:
#     print(r1)
print(list(r))

 

内置高阶函数reduce

#内置高阶函数reduce,序列的值做累计计算
from functools import reduce
def fn(x,y):
    return x + y
result = reduce(fn,[1,2,3,4,5])
print(result)

 

内置高阶函数filter()

#内置高阶函数filter(),把传入的函数依次作用于每个元素，并根据返回值是否为True还是False决定保留还是丢弃元素

def is_odd(n):
    return n%2 ==1
result = filter(is_odd,[1,2,3,4,5])
print(list(result))

#内置高阶函数sorted(),可以对列表进行排序
a = sorted([1,3,5,3,1,2,0,-1,-2])
print(a)
b = sorted([1,3,5,3,1,2,0,-1,-2],key=abs)
print(b)

 

四、返回函数

---

除了上述把函数作为参数之外，还能把函数当作结果返回

#除了上述把函数作为参数之外，还能把函数当作结果返回

def my_sum(*arg):
    def innersum():
        a = 0
        for i in arg:
            a = a+i
        return a
    return innersum

testf = my_sum(1,2,3,4,5)
print(testf)
print(testf())


#返回函数-闭包
#一个函数返回了一个函数后，其内部的局部变量还能被新函数引用
#创建私有变量示例，外部无法改变
def make_counter():
    count = 0#私有变量
    def counter():
        nonlocal count
        count  += 1
        return count
    return counter

a = make_counter()
a = make_counter()
a = make_counter()
print(a(),a(),a())

 

五、装饰器

---

装饰器是高阶函数一种应用，允许给其他函数增加功能而又无需改动其他函数

#示例：写一个计算函数运行时间的装饰器

import functools

def runtime(func):
    @functools.wraps(func)#避免包装函数覆盖原始函数的元数据，如函数名，文档字符串，解释等
    def wrapper(*arg,**kw):#代表这个函数可以接收任意数量的位置参数和关键字参数，参见1中*arg,**kw的说明，这样子写代码所有函数可以被包在其中
        startime = time.time()
        result = func(*arg,**kw)#运行被执行的函数
        endtime = time.time()
        usedtime = endtime-startime
        print("函数运行了"+str(usedtime)+"秒")
        return result#返回被执行函数
    return wrapper#返回函数

#可以看到，装饰器的本质是把被运行的函数当作参数赋予到一个新的函数中，并返回这个函数
#看上述代码，函数被包装在里面执行，通过这样的形式，可以做到不改动原函数又可以新增功能


#装饰器应用，计算下面这个函数的运行时间
@runtime
def new_sum(n):
    reallysum = 0
    for i in range(1,n):
        reallysum = reallysum + i
    print(reallysum)
    return reallysum

new_sum(10000000)

带参数的装饰器：

#带参数的装饰器,需要三层嵌套
#把上述的函数再改造一下，可以让时间的展示通过参数配置选择为毫秒或者秒

import functools
import time

def runtime_decorator(unit='seconds'):#打印出来的时间可以选择秒或者毫秒
    """
    一个带参数的装饰器工厂，用于测量函数运行时间并打印。
    :param unit: 时间单位，'seconds' 表示秒，'milliseconds' 表示毫秒。
    """
    def decorator(func):
        @functools.wraps(func)
        def wrapper(*args, **kwargs):
            start_time = time.time()
            result = func(*args, **kwargs)
            end_time = time.time()
            elapsed_time = end_time - start_time
            if unit == 'seconds':
                print(f"函数运行了 {elapsed_time:.6f} 秒")
            elif unit == 'milliseconds':
                print(f"函数运行了 {elapsed_time * 1000:.6f} 毫秒")
            else:
                print(f"未知的时间单位: {unit}")
            return result
        return wrapper
    return decorator


@runtime_decorator('milliseconds')
def new_sum(n):
    reallysum = 0
    for i in range(1,n):
        reallysum = reallysum + i
    print(reallysum)
    return reallysum

new_sum(1000000) 

六、结语

    通过这些高阶函数，可以应用到我们的自动化测试中，如每一次接口响应的断言都需要断言响应码是否=200，需要断言接口响应文本，需要断言接口返回值格式，那就把这几个用装饰器的方法实现，后续就一行语句解决所有繁琐的断言。

    类似的，很多公共的做法都可以通过装饰器实现。