参考资料
练习题 icon lost
交流讨论
笔记
img lost

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

函数式编程的概念

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

  • 纯函数:这些函数有两个主要属性。首先,它们总是为相同的参数产生相同的输出,而不管其他任何事情。其次,它们没有副作用,即它们确实修改了任何参数或全局变量或输出了一些东西。
  • 递归:函数式语言中没有“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))

输出

15

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

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

一等函数的性质

  • 函数是 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 参数:表达式

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

例子

# 演示 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)

输出 :

1 
2 
3

生成器对象

生成器函数返回一个生成器对象。通过调用生成器对象的 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())

输出 :

1 
2 
3

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

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

# 斐波那契数列的简单生成器
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)

输出 :

0 
1 
1 
2 
3

在循环中使用 for
0 
1 
1 
2 
3

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

装饰器

装饰器是 Python 中一个非常强大和有用的工具,因为它允许程序员修改函数或类的行为。装饰器允许我们包装另一个函数以扩展被包装函数的行为,而无需永久修改它。但在深入研究装饰器之前,让我们了解一些在学习装饰器时会派上用场的概念。

装饰器用于修改函数或类的行为。在装饰器中,函数作为参数传入另一个函数,然后在包装函数内部调用。

装饰器的语法:

@hy_decorator
def hello_decorator():
    print("HY")

# 上面的代码等价于 -

def hello_decorator():
    print("HY")
    
hello_decorator = hy_decorator(hello_decorator)'''

在上面的代码中,gfg_decorator 是一个可调用函数,将在另一个可调用函数 hello_decorator 函数之上添加一些代码并返回包装函数。

装饰器可以修改行为:

# 定义装饰器
def hello_decorator(func):

    # inner1 是一个 Wrapper 函数,其中调用了参数

    # 内部函数可以访问外部局部函数,如本例中的“func”
    def inner1():
        print("这是在函数执行之前")

        # 现在在包装函数中调用实际函数。
        func()

        print("这是在函数执行之后")
        
    return inner1

# 定义一个函数,在包装器内部调用
def function_to_be_used():
    print("这是在函数内部")

# 在装饰器内部传递“function_to_be_used”来控制其行为
function_to_be_used = hello_decorator(function_to_be_used)

# 调用函数
function_to_be_used()

输出:

这是在函数执行之前
这是在函数内部
这是在函数执行之后

让我们看另一个示例,在该示例中,我们可以使用装饰器轻松找出函数的执行时间。

# 导入库
import time
import math

# 装饰器来计算任何函数的持续时间
def calculate_time(func):

    # 在 inner1 中添加的参数,如果函数接受任何参数,可以像这样添加。
    def inner1(*args, **kwargs):

        # 在函数执行前存储时间
        begin = time.time()
        
        func(*args, **kwargs)

        # 函数执行后存储时间
        end = time.time()
        print("总时间:", func.__name__, end - begin)

    return inner1

# 这可以添加到任何存在的函数中,在这种情况下计算阶乘
@calculate_time
def factorial(num):

    # 因为它花费的时间非常少,因此 sleep 2 秒你可以看到实际的差异
    time.sleep(2)
    print(math.factorial(num))

# 调用函数
factorial(10)

输出:

3628800
总时间:factorial 2.0061802864074707

不变性

不变性是一种可用于调试的函数式编程范例,因为它会在变量被更改而不是值被更改的地方引发错误。Python 也支持一些不可变的数据类型,如字符串、元组、数字等。

例子

# 演示不可变数据类型的 Python 程序

# 字符串数据类型
immutable = "Haiyong"

# 更改值将引发错误
immutable[1] = 'K'

输出

Traceback (most recent call last):
  File "/home/ee8bf8d8f560b97c7ec0ef080a077879.py", line 10, in 
    immutable[1] = 'K'
TypeError: 'str' object does not support item assignment

函数式编程和面向对象编程的区别

当你对事物有一组固定的操作时,面向对象的语言是很好的,并且随着代码的发展,你主要是添加新事物。这可以通过添加实现现有方法的新类来完成,而现有类则不作任何处理。

当你有一组固定的东西时,函数式语言是很好的,并且随着你的代码的发展,你主要是在现有的东西上添加新的操作。这可以通过添加使用现有数据类型进行计算的新函数来完成,而现有函数将被单独保留。

函数编程面向对象编程
这种编程范式强调函数的使用,其中每个函数都执行特定的任务。这种编程范式基于面向对象的概念。在创建对象实例的地方使用类
使用的基本元素是变量和函数。函数中的数据是不可变的(创建后无法更改)。使用的基本元素是对象和方法,这里使用的数据是可变数据。
它遵循声明式编程模型。它遵循命令式编程模型。
它使用递归进行迭代。它使用循环进行迭代。
它支持并行编程。它不支持并行编程。
此编程范例中的语句在执行时不需要遵循特定的顺序。这种编程范式中的语句需要遵循一个顺序,即执行时自底向上的方法。
资料来源 Python 高级教程之函数式编程
博客作者 qq_44273429
前往答题
我的笔记