python中函数式编程与高阶函数，装饰器与生成器，异常处理与日志记录以及项目实战

函数式编程是 Python 强大且灵活的编程范式之一，与此同时，Python 也为开发者提供了高阶函数、装饰器、生成器等工具，极大提高了代码的可读性和复用性。此外，异常处理与日志记录是编写可靠、可维护的 Python 代码的重要组成部分。最后，通过一个项目实战来整合这些概念。

我们将从以下几个方向展开：

1. 函数式编程与高阶函数
2. 装饰器与生成器
3. 异常处理与日志记录
4. 项目实战：文件批量处理工具

一、函数式编程与高阶函数

1.1 函数式编程概念

函数式编程是一种编程范式，强调函数的不可变性和无副作用。Python 作为多范式编程语言，提供了函数式编程的支持。函数式编程中的核心概念包括：

• 纯函数：函数的输出仅依赖输入，不依赖外部状态，且不会改变外部状态。
• 不可变性：数据一旦创建便不可修改。
• 高阶函数：可以接受函数作为参数或返回函数。

1.2 常见的高阶函数

map()

map() 函数将一个函数应用于一个可迭代对象中的每个元素，返回一个迭代器。

# 例子：将列表中的每个元素平方
numbers = [1, 2, 3, 4]
squares = list(map(lambda x: x**2, numbers))
print(squares)  # 输出: [1, 4, 9, 16]

filter()

filter() 函数用于过滤可迭代对象中符合条件的元素。

# 例子：过滤出列表中的偶数
numbers = [1, 2, 3, 4, 5, 6]
evens = list(filter(lambda x: x % 2 == 0, numbers))
print(evens)  # 输出: [2, 4, 6]

reduce()

reduce() 来自 functools 模块，作用是将可迭代对象中的元素累计计算出一个值。

from functools import reduce

# 例子：累积相乘列表中的元素
numbers = [1, 2, 3, 4]
product = reduce(lambda x, y: x * y, numbers)
print(product)  # 输出: 24

1.3 函数作为参数与返回值

Python 中函数是一等公民，可以作为参数传递，或作为返回值。

# 函数作为参数
def apply_function(func, value):
    return func(value)

print(apply_function(lambda x: x + 2, 10))  # 输出: 12

# 函数作为返回值
def outer_function():
    def inner_function():
        return "Hello from inner function!"
    return inner_function

hello_func = outer_function()
print(hello_func())  # 输出: Hello from inner function!

二、装饰器与生成器

2.1 装饰器

装饰器是一种函数，它用于在不改变原函数代码的情况下，扩展或修改函数的功能。装饰器通常用于函数的前后执行某些操作，比如记录日志、计时等。

装饰器基本用法

# 基本的装饰器函数
def my_decorator(func):
    def wrapper():
        print("在函数调用前")
        func()
        print("在函数调用后")
    return wrapper

@my_decorator
def say_hello():
    print("Hello!")

say_hello()
# 输出:
# 在函数调用前
# Hello!
# 在函数调用后

带参数的装饰器

装饰器也可以装饰带参数的函数：

def my_decorator(func):
    def wrapper(*args, **kwargs):
        print("在函数调用前")
        result = func(*args, **kwargs)
        print("在函数调用后")
        return result
    return wrapper

@my_decorator
def greet(name):
    print(f"Hello, {name}!")

greet("Alice")
# 输出:
# 在函数调用前
# Hello, Alice!
# 在函数调用后

2.2 生成器

生成器 是一种特殊的迭代器，通过 yield 关键字逐步生成值，生成器不会一次性将所有值计算出来，而是按需生成，节省内存。

生成器函数

def my_generator():
    for i in range(3):
        yield i

gen = my_generator()
print(next(gen))  # 输出: 0
print(next(gen))  # 输出: 1
print(next(gen))  # 输出: 2

生成器表达式

与列表推导式类似，生成器表达式使用小括号代替方括号：

gen = (x**2 for x in range(3))
for val in gen:
    print(val)
# 输出:
# 0
# 1
# 4

三、异常处理与日志记录

3.1 异常处理

异常处理是编写健壮代码的重要手段。通过 try、except、finally 语句捕获异常并处理，防止程序崩溃。

异常处理基本语法

try:
    result = 10 / 0
except ZeroDivisionError as e:
    print(f"发生错误: {e}")
finally:
    print("无论是否有异常，我都会执行")

自定义异常

可以通过继承 Exception 类创建自定义异常：

class CustomError(Exception):
    pass

def raise_error():
    raise CustomError("自定义异常发生了！")

try:
    raise_error()
except CustomError as e:
    print(e)

3.2 日志记录

使用 logging 模块记录程序执行的关键信息。

基本的日志记录

import logging

logging.basicConfig(level=logging.INFO)

def divide(a, b):
    try:
        result = a / b
        logging.info(f"成功计算: {a} / {b} = {result}")
        return result
    except ZeroDivisionError:
        logging.error("除数不能为零！")

divide(10, 2)  # 输出日志: 成功计算: 10 / 2 = 5.0
divide(10, 0)  # 输出日志: 除数不能为零！

日志文件记录

logging.basicConfig(filename='app.log', level=logging.INFO)

logging.info("程序启动")

四、项目实战：文件批量处理工具

项目简介

需求：开发一个工具来批量处理多个文件。假设我们有大量文本文件，内容是多个数字，我们需要统计每个文件的平均值，并将结果写入日志文件中。

项目设计思路

1. 读取文件：从目录中读取所有文本文件。
2. 处理文件内容：解析每个文件中的数字，计算平均值。
3. 记录日志：将每个文件的处理结果记录到日志中。

项目代码实现

1. 读取文件列表

import os

def get_files_from_directory(directory):
    return [f for f in os.listdir(directory) if f.endswith('.txt')]

2. 处理文件内容

def process_file(filepath):
    with open(filepath, 'r') as file:
        numbers = [int(line.strip()) for line in file.readlines()]
        return sum(numbers) / len(numbers) if numbers else 0

3. 日志记录与异常处理

import logging

logging.basicConfig(filename='file_processing.log', level=logging.INFO)

def log_result(filename, result):
    logging.info(f"文件 {filename} 的平均值为: {result}")

4. 整合代码

def main():
    directory = './files'
    files = get_files_from_directory(directory)

    for file in files:
        try:
            filepath = os.path.join(directory, file)
            result = process_file(filepath)
            log_result(file, result)
        except Exception as e:
            logging.error(f"处理文件 {file} 时发生错误: {e}")

if __name__ == "__main__":
    main()

运行结果

1. 所有文件的平均值会记录到 file_processing.log 文件中。
2. 如果有任何文件处理失败，日志中会有详细的错误信息。

总结

通过这个项目，我们整合了 Python 的函数式编程、高阶函数、装饰器、生成器，以及异常处理与日志记录的概念。这个工具展示了如何结合这些强大的特性来编写简洁、优雅且高效的代码。

Python 提供了极大的灵活性和可扩

展性，通过充分利用这些工具和技术，可以轻松应对各种复杂的任务。你可以根据项目需求，进一步扩展这个工具，例如添加并行处理文件的功能，或者通过命令行参数动态配置输入输出目录。