博客

Python 函数式编程：

函数式编程是一种编程范式，它将计算机运算视为数学上的函数计算，强调函数的输入输出和函数本身的状态无关。函数式编程遵循函数不可变、无副作用、高阶函数等基本规则，它可以帮助程序员编写更加简洁、健壮、可维护的代码。

Python 里面函数式编程的核心是 lambda 函数、reduce 函数、map 函数、filter 函数、sorted 函数等，下面我们将介绍这些函数及其使用方法：

1. lambda 函数

lambda 函数是一种匿名函数，通常用于函数式编程的过程中。

它的基本语法是：lambda parameter_list:expression

例如，我们定义一个 lambda 函数，传入参数为 x 和 y，返回 x 和 y 的和。

add = lambda x, y: x + y
result = add(1, 2)
print(result)

输出结果为 3。

1. reduce 函数

reduce 函数是对一个序列做一些累积操作。

它的基本语法是：reduce(function, sequence[, initial])

其中，function 为一个二元函数，sequence 为一个序列，initial 为初始值，如果不指定初始值，默认为序列的第一个元素。

例如，我们使用 reduce 函数计算序列 [1, 2, 3, 4, 5] 的累积值。

from functools import reduce
result = reduce(lambda x, y: x * y, [1, 2, 3, 4, 5])
print(result)

输出结果为 120。

1. map 函数

map 函数将一个函数映射到一个序列上，返回一个新的序列，其中每个元素都是原序列元素经过函数计算得到的结果。

它的基本语法是：map(function, sequence)

例如，我们使用 map 函数将序列 [1, 2, 3, 4, 5] 的每个元素平方。

result = map(lambda x: x ** 2, [1, 2, 3, 4, 5])
print(list(result))

输出结果为 [1, 4, 9, 16, 25]。

1. filter 函数

filter 函数是用于过滤一个序列的元素，返回一个新的序列，其中每个元素都是原序列中满足条件的元素。

它的基本语法是：filter(function, sequence)

例如，我们使用 filter 函数从序列 [1, 2, 3, 4, 5] 中过滤出所有奇数的元素。

result = filter(lambda x: x % 2 == 1, [1, 2, 3, 4, 5])
print(list(result))

输出结果为 [1, 3, 5]。

1. sorted 函数

sorted 函数用于对一个序列进行排序，返回一个新的序列。

它的基本语法是：sorted(iterable, key=None, reverse=False)

其中，iterable 为要排序的序列，key 为一个用于排序的函数，可以自定义排序规则，reverse 为是否逆序排序，默认为 False。

例如，我们使用 sorted 函数对序列 [3, 1, 4, 1, 5, 9, 2, 6, 5, 3, 5] 进行排序。

result = sorted([3, 1, 4, 1, 5, 9, 2, 6, 5, 3, 5])
print(result)

输出结果为 [1, 1, 2, 3, 3, 4, 5, 5, 5, 6, 9]。

Python 并发编程：

并发编程是一种编程范式，它能够在单个程序中实现多个独立的任务或程序段的同时执行，同时不影响各自的运行效率和正确性。在 Python 中，我们可以使用多线程和多进程来进行并发编程。

下面介绍 Python 中多线程和多进程的具体使用方法：

1. 多线程

Python 中的多线程使用的基本模块是 threading 模块。我们可以通过使用该模块创建多个线程，同时执行多个任务。

例如，我们创建两个线程，分别计算出 100000 以内的所有质数，并打印出质数的个数。

import threading

def is_prime(num):
    for i in range(2, num):
        if num % i == 0:
            return False
    return True

def count_primes(start, end):
    count = 0
    for num in range(start, end):
        if is_prime(num):
            count += 1
    print('Primes count:', count)

t1 = threading.Thread(target=count_primes, args=(1, 50000))
t2 = threading.Thread(target=count_primes, args=(50000, 100000))
t1.start()
t2.start()
t1.join()
t2.join()

输出结果为：

Primes count: 5133
Primes count: 4868

1. 多进程

Python 中的多进程使用的基本模块是 multiprocessing 模块。我们可以通过使用该模块创建多个进程，同时执行多个任务。

例如，我们创建两个进程，分别计算出 100000 以内的所有质数，并打印出质数的个数。

import multiprocessing

def is_prime(num):
    for i in range(2, num):
        if num % i == 0:
            return False
    return True

def count_primes(start, end):
    count = 0
    for num in range(start, end):
        if is_prime(num):
            count += 1
    print('Primes count:', count)

if __name__ == '__main__':
    p1 = multiprocessing.Process(target=count_primes, args=(1, 50000))
    p2 = multiprocessing.Process(target=count_primes, args=(50000, 100000))
    p1.start()
    p2.start()
    p1.join()
    p2.join()

输出结果同样为：

Primes count: 5133
Primes count: 4868