Python函数式编程(python系列27)

前言:函数式编程有什么用,为什么要学函数式编程?函数式编程是一种编程范式,可减少程序的错误和复杂度,提高代码的可维护性和可重用性。

1.定义:用一系列函数解决问题

        函数可以赋值给变量,赋值后变量绑定函数。

        允许将函数作为参数传入另一个函数。

2.高阶函数:将函数作为参数或返回值的函数

函数作为参数

将核心逻辑传入方法体,使该方法的适用性更广,体现了面向对象的开闭原则

那什么是开闭原则呢?

对扩展开放,对修改封闭。

当软件系统需要进行功能扩展时,应该可以通过增加新的代码来实现,而不是修改已有的代码。开闭原则的核心思想是面向接口编程,通过抽象和封装来实现代码的可扩展性和可维护性。开闭原则和前面所提到的先确定用法后决定做法如出一辙,用法不能修改,但是能新加做法。

假如现在有两个需求:

1.定义函数,在列表中查找第一个奇数

2.定义函数,在列表中查找第一个能被3或5整除的数字

不使用函数式编程思想来实现:

# 不使用函数式编程思想
# 1.定义函数,在列表中查找第一个奇数
def find_first_odd(numbers):
    for number in numbers:
        if number % 2 != 0:
            return number


# 2.定义函数,在列表中查找第一个能被3或5整除的数字
def find_first_divisible(numbers):
    for number in numbers:
        if number % 3 == 0 or number % 5 == 0:
            return number


if __name__ == '__main__':
    list_num = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
    print(find_first_odd(list_num))  # 1
    print(find_first_divisible(list_num))  # 3

上述代码当然能实现我们提到的两个需求,可当我们的功能增加,查找列表中第一个偶数,我们则有需要定义一个函数。可我们发现其实这些需求的主体逻辑相同,核心算法不同,这个时候我们就可以抽象主题逻辑创建一个适用性更广的函数,再将核心算法通过参数传递给主题逻辑函数,而这个被抽象化的主题逻辑函数被称为高阶函数。高阶函数是早就写好的不能修改,是闭,而核心算法是当下决定实现的扩展功能,属于开,这也体现了面向对象的开闭原则。

使用函数式编程的思想实现:

# 使用函数式编程思想
# 抽象相同的主题结构,创建一个高阶函数
def find_single(iterable, condition):
    for item in iterable:
        if condition(item):
            return item


def find_first_odd(number):
    return number % 2 == 1


def find_first_divisible(number):
    return number % 3 == 0 or number % 5 == 0


if __name__ == '__main__':
    list_num = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
    print(find_single(list_num, find_first_odd))  # 1
    print(find_single(list_num, find_first_divisible))  # 3

用为主题逻辑相同,核心算法不同

所以使用函数式编程思想(分,隔,做)

分:将主题逻辑和核心算法分开

隔:将核心算法使用形参代替

做:将想要实现的需求的核心算法做出来

上述的代码中的核心算法非常简单,但是还需要给它定义函数名,显得非常的麻烦,应该如何解决呢?lambda 表达式,匿名方法

lambda表达式

定义:是一种匿名方法

作用:

作为参数传递时语法简洁,优雅,代码可读性强。

随时创建和销毁,减少程序耦合度。

语法:

变量 = lambda 形参:方法体

调用:变量(实参)

限制:形参没有可以不填,方法体只能有一条语句,且不支持赋值语句。

有了lambda我们再来优化我们上面的代码吧:

# 使用函数式编程思想
# 抽象相同的主题结构,创建一个高阶函数
def find_single(iterable, condition):
    for item in iterable:
        if condition(item):
            return item


if __name__ == '__main__':
    list_num = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
    print(find_single(list_num, lambda x: x % 2 == 1))  # 1
    print(find_single(list_num, lambda x: x % 3 == 0 or x % 5 == 0))  # 3

一般我们都将自定义的高阶函数封装起来:

from common.iterable_tools import IterableHelper


if __name__ == '__main__':
    list_num = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
    print(IterableHelper.find_single(list_num, lambda x: x % 2 == 1))  # 1
    print(IterableHelper.find_single(list_num, lambda x: x % 3 == 0 or x % 5 == 0))  # 3
# common -> iterable_tools.py
"""
    对可迭代对象的常用操作
"""


class IterableHelper:
    """
        可迭代对象助手:封装对可迭代对象常用的高阶函数
        集成操作框架
    """

    @staticmethod  # 静态方法:不让python解释器自动为第一个参数传递self
    def find_single(iterable, condition):
        """
            在可迭代对象中查找第一个满足条件的元素
        :param iterable:可迭代对象
        :param condition:函数类型,一个参数,一个bool返回值
        :return:第一个满足条件的元素
        """
        for item in iterable:
            if condition(item):
                return item

在工作中,或者在学习中我们自定义的通用工具都应该封装起来,提高工作效率。

内置高阶函数

map(函数,可迭代对象):使用可迭代对象中的每个元素调用函数,将返回值作为新可迭代对象元素;返回值为新可迭代对象。

filter(函数,可迭代对象):根据条件筛选可迭代对象中的元素,返回值为新可迭代对象。

sorted(可迭代对象,key = 函数,reverse = bool值):排序,返回值为排序结果。

max(可迭代对象,key = 函数):根据函数获取可迭代对象的最大值

min(可迭代对象,key = 函数):根据函数获取可迭代对象的最小值

大家要学会举一反三,我们刚才自己写了高阶函数,面对祖师爷给我们写的内置高阶函数我们也应该使用,并能模拟出能实现相同功能的高阶函数。

大家可以来写一些高阶函数:

my_map, my_filter, my_sorted, my_max, my_min

实现和对应内置高阶函数相同的功能。

函数作为返回值

逻辑连续,当内部函数被调用时,不脱离当前的逻辑。

闭包

三要素:外中有内,内使用外,外返回内。

代码案例:

#  闭包案例
def func01():
    print("func01")
    a = 10

    def func02():
        print("func02")
        print(a)

    return func02


if __name__ == '__main__':
    condition = func01()  # func01
    condition()  # func02 10

上面代码它包含了闭包三要素,它是一个闭包。

优点:内部函数可以使用外部变量

缺点:外部变量一直存在于内存中,不会在调用结束后释放,占用内存。

作用:实现python装饰器

装饰器原理:

#  装饰器


def new(func):
    def wrapper(*args, **kwargs):
        print('我是新功能')
        res = func(*args, **kwargs)
        return res
    return wrapper


def old(a, b, c):
    print('我是旧功能')
    print(a, b, c)
    return '执行旧功能成功'


old = new(old)
old()



上面代码,在不修改旧功能的前提下,在每次执行旧功能时都会先执行新功能。

上面是原理,在实际开发中我们一般写成这样

#  装饰器


def new(func):
    def wrapper(*args, **kwargs):
        print('我是新功能1')
        res = func(*args, **kwargs)
        return res

    return wrapper


def new2(func):
    def wrapper(*args, **kwargs):
        print('我是新功能2')
        res = func(*args, **kwargs)
        return res

    return wrapper


@new2
@new
def old(a, b, c):
    print('我是旧功能')
    print(a, b, c)
    return '执行旧功能成功'


old(1, 2, 3)

使用@函数装饰器名称来修饰原函数

一个函数可以被多个装饰器修饰,执行顺序为从近到远。

你可能感兴趣的:(python,开发语言)