Python 高级教程之函数式编程

2401_86454391

于 2024-09-12 04:24:19 发布

阅读量719

点赞数 17

文章标签： python windows 服务器

本文链接：https://blog.csdn.net/2401_86454391/article/details/142155053

版权

函数式编程是一种编程范式，我们在其中尝试以纯数学函数风格绑定所有内容。它是一种声明式的编程风格。它的主要焦点是“要解决什么”，而命令式风格的主要焦点是“如何解决”。它使用表达式而不是语句。计算表达式以产生值，而执行语句以分配变量。

函数式编程的概念

任何函数式编程语言都应该遵循这些概念。

纯函数：这些函数有两个主要属性。首先，它们总是为相同的参数产生相同的输出，而不管其他任何事情。其次，它们没有副作用，即它们确实修改了任何参数或全局变量或输出了一些东西。
递归：函数式语言中没有“for”或“while”循环。函数式语言中的迭代是通过递归实现的。
函数是一等的并且可以是高阶的：一等函数被视为一等变量。第一类变量可以作为参数传递给函数，可以从函数返回或存储在数据结构中。
变量是不可变的：在函数式编程中，我们不能在变量初始化后对其进行修改。我们可以创建新变量——但我们不能修改现有变量。

Python 中的函数式编程

Python 也支持函数式编程范式，而无需任何特殊功能或库的支持。

纯函数

如上所述，纯函数有两个属性。

它总是为相同的参数产生相同的输出。例如，无论如何，3+7 永远是 10。
它不会更改或修改输入变量。

第二个属性也称为不变性。纯函数的唯一结果是它返回的值。它们是确定性的。使用函数式编程完成的程序很容易调试，因为纯函数没有副作用或隐藏的 I/O。纯函数还可以更轻松地编写并行/并发应用程序。当代码以这种风格编写时，智能编译器可以做很多事情——它可以并行化指令，在需要时等待评估结果，并记住结果，因为只要输入不改变，结果就永远不会改变。

例子：


# 演示纯函数的 Python 程序



# 一个不改变输入列表并返回新列表的纯函数

def pure_func(List):



    New_List = []



    for i in List:

        New_List.append(i**2)

        

    return New_List



# 驱动程序代码

Original_List = [1, 2, 3, 4]

Modified_List = pure_func(Original_List)



print("Original List:", Original_List)

print("Modified List:", Modified_List)

输出：


Original List: [1, 2, 3, 4]

Modified List: [1, 4, 9, 16]

递归

在函数式编程中，没有 for 循环或 while 循环的概念，而是使用递归。递归是一个函数直接或间接调用自身的过程。在递归程序中，提供了基本情况的解决方案，而较大问题的解决方案则用较小的问题来表示。可能会出现一个问题，什么是基本情况？基本情况可以被认为是告诉编译器或解释器退出函数的条件。

示例：让我们考虑一个程序，该程序将在不使用任何 for 循环的情况下找到列表中所有元素的总和。


# 演示递归的 Python 程序



# 递归函数查找列表的总和

def Sum(L, i, n, count):



    # Base case

    if n <= i:

        return count



    count += L[i]



    # 进入递归

    count = Sum(L, i + 1, n, count)



    return count



# 驱动程序代码

L = [1, 2, 3, 4, 5]

count = 0

n = len(L)

print(Sum(L, 0, n, count))

输出：

函数是一等的，可以是高阶的

一等的对象自始至终统一处理。它们可以存储在数据结构中，作为参数传递，或者在控制结构中使用。如果一种编程语言将函数视为一等对象，则称其支持一等函数。

一等函数的性质：

函数是 Object 类型的实例。
你可以将函数存储在变量中。
你可以将函数作为参数传递给另一个函数。
你可以从函数返回函数。
你可以将它们存储在数据结构中，例如哈希表、列表……


# 演示高阶函数的 Python 程序



def shout(text):

    return text.upper()



    def whisper(text):

    return text.lower()



    def greet(func):

    # 将函数存储在变量中

    greeting = func("我是由作为参数传递的函数创建的。")

    print(greeting)



greet(shout)

greet(whisper)

输出：


我是由作为参数传递的函数创建的。

我是由作为参数传递的函数创建的。

内置高阶函数

为了使列表和迭代器等可迭代对象的处理更加容易，Python 实现了一些常用的高阶函数。这些函数返回一个节省空间的迭代器。一些内置的高阶函数是：

Map()

map() 函数在将给定函数应用于给定迭代（列表、元组等）的每个项目后返回结果列表

语法： map(fun, iter)

参数：

fun：这是一个函数，map 将给定迭代的每个元素传递给该函数。

iter：它是一个要被映射的可迭代对象。

返回类型：返回 map 类的迭代器。

例子：


# 用于演示 map 工作的 Python 程序。



# Return double of n

def addition(n):

    return n + n



# 我们使用 map() 将所有数字翻倍

numbers = (1, 2, 3, 4)

results = map(addition, numbers)



# 不打印值

print(results)



# 打印值

for result in results:

    print(result, end = " ")

输出：


<map object at 0x7fae3004b630>

2 4 6 8

filter()

filter() 方法在一个函数的帮助下过滤给定的序列，该函数测试序列中的每个元素是否为真。

语法：过滤器（函数，序列）

参数：

function：测试序列的每个元素是否为真的函数。

sequence：需要过滤的序列，可以是集合、列表、元组或任何迭代器的容器。

返回类型：返回一个已经过滤的迭代器。

例子：


# 演示过滤器工作的 Python 程序。



# 过滤元音的函数

def fun(variable):



    letters = ['a', 'e', 'i', 'o', 'u']



    if (variable in letters):

        return True

    else:

        return False



# sequence

sequence = ['g', 'e', 'e', 'j', 'k', 's', 'p', 'r']



# 使用过滤功能

filtered = filter(fun, sequence)



print('过滤后的字母是：')



for s in filtered:

    print(s)

输出：


过滤后的字母是：

e 

e

Lambda 函数

在 Python 中，匿名函数意味着函数没有名称。我们已经知道 def 关键字用于定义普通函数，而 lambda 关键字用于创建匿名函数。

语法：

lambda 参数：表达式

这个函数可以有任意数量的参数，但只有一个表达式，它被计算并返回。
任何需要函数对象的地方都可以使用 lambda 函数。
你需要了解 lambda 函数在语法上仅限于单个表达式。
除了函数中的其他类型的表达式外，它在特定的编程领域有多种用途。

例子：


# 演示 lambda 的 Python 代码



cube = lambda x: x * x*x

print(cube(7))



L = [1, 3, 2, 4, 5, 6]

is_even = [x for x in L if x % 2 == 0]



print(is_even)

输出：


343 

[2, 4, 6]

生成器

生成器函数

生成器函数的定义与普通函数一样，但无论何时它需要生成一个值，它都会使用 yield 关键字而不是 return。如果 def 的主体包含 yield，则该函数自动成为生成器函数。


# 一个生成器函数，第一次产生 1，第二次产生 2，第三次产生 3

def simpleGeneratorFun():

    yield 1			

    yield 2			

    yield 3			



# 用于检查上述生成器功能的驱动代码

for value in simpleGeneratorFun():

    print(value)

输出：

生成器对象

生成器函数返回一个生成器对象。通过调用生成器对象的 next 方法或在“for in”循环中使用生成器对象来使用生成器对象（如上面的程序所示）。


# 一个 Python 程序，用于演示通过 next() 使用生成器对象



# 一个生成器函数

def simpleGeneratorFun():

    yield 1

    yield 2

    yield 3



# x 是一个生成器对象

x = simpleGeneratorFun()



# 使用 next 遍历生成器对象

print(x.next()) # In Python 3, __next__()

print(x.next())

print(x.next())

输出：

所以生成器函数返回一个可迭代的生成器对象，即可以用作迭代器。

作为另一个示例，下面是斐波那契数列的生成器。


# 斐波那契数列的简单生成器

def fib(limit):



    # 初始化前两个斐波那契数

    a, b = 0, 1



    # 一个接一个地生成下一个斐波那契数

    while a < limit:

        yield a

        a, b = b, a + b



# 创建一个生成器对象

x = fib(5)



# 使用 next 遍历生成器对象

print(x.next()) # In Python 3, __next__()

print(x.next())

print(x.next())

print(x.next())

print(x.next())



# 使用 for in 循环遍历生成器对象。

print("\n在循环中使用 for")

for i in fib(5):

    print(i)

输出：

应用：假设我们要创建一个斐波那契数流，我们只需要调用 next(x) 来获取下一个斐波那契数，无需担心数字流在何处或何时结束。更实用的流处理类型是处理大型数据文件，例如日志文件。生成器为此类数据处理提供了一种节省空间的方法，因为在一个给定的时间点只处理文件的一部分。我们也可以将迭代器用于这些目的，但是生成器提供了一种快速的方法（我们不需要在这里编写 __next__ 和 __iter__ 方法）。

2401_86454391

关注

17
点赞
踩
16

收藏

觉得还不错? 一键收藏
0
评论
复制链接

分享到 QQ

分享到新浪微博

扫一扫