Python 处理状态更新逻辑

Python 处理状态更新逻辑

flyfish

以根据书籍类型（如小说、科学、历史等）处理不同的书籍，并更新相应的状态和记录已处理书籍的描述为例，通过使用生成器，可以逐步处理每种类型的书籍，并在每次迭代中返回当前的状态和已处理书籍描述列表。

def process_fiction_book(result):
    # 示例处理逻辑
    return 1, "小说类别：已处理"

def process_science_book(result):
    # 示例处理逻辑
    return 1, "科学类别：已处理"

def process_history_book(result):
    # 示例处理逻辑
    return 1, "历史类别：已处理"

def update_status(status_vars, **updates):
    """
    更新状态变量
    :param status_vars: 包含当前状态变量的字典
    :param updates: 需要更新的状态变量及其新值
    :return: 更新后的状态变量字典
    """
    for key, value in updates.items():
        if key in status_vars:
            status_vars[key] = value
    return status_vars

def process_book(book_type, result, processed_books, status_vars):
    """
    根据 book_type 的值调用相应的处理函数
    :param book_type: 书籍类型标识
    :param result: 处理结果
    :param processed_books: 存储已处理书籍描述的列表
    :param status_vars: 当前状态变量字典
    :return: 更新后的状态变量字典和processed_books
    """
    print("Processing book:", result)

    if book_type == 1:
        fiction_status, book_desc = process_fiction_book(result)
        status_vars.update({"fictionStatus": fiction_status})
    elif book_type == 2:
        science_status, book_desc = process_science_book(result)
        status_vars.update({"scienceStatus": science_status})
    elif book_type == 3:
        history_status, book_desc = process_history_book(result)
        status_vars.update({"historyStatus": history_status})

    processed_books.append(book_desc)
    return status_vars, processed_books

# 初始化状态变量和已处理书籍描述列表
status_vars = {"fictionStatus": -1, "scienceStatus": -1, "historyStatus": -1}
processed_books = []

# 示例调用过程
status_vars, processed_books = process_book(1, "数据结果1", processed_books, status_vars)
print(status_vars)  # 查看更新后的状态变量
status_vars, processed_books = process_book(2, "数据结果2", processed_books, status_vars)
print(status_vars)  # 查看更新后的状态变量
status_vars, processed_books = process_book(3, "数据结果3", processed_books, status_vars)
print(status_vars)  # 查看更新后的状态变量

# 如果需要使用生成器来逐步处理
def process_books_generator(books, status_vars):
    """
    生成器函数，根据不同的书籍类型依次处理结果
    :param books: 包含(book_type, result)元组的列表
    :param status_vars: 初始状态变量字典
    :return: 每次调用返回更新后的状态变量和已处理书籍描述列表
    """
    processed_books = []
    
    for book_type, result in books:
        print("Processing book:", result)
        
        if book_type == 1:
            fiction_status, book_desc = process_fiction_book(result)
            status_vars.update({"fictionStatus": fiction_status})
        elif book_type == 2:
            science_status, book_desc = process_science_book(result)
            status_vars.update({"scienceStatus": science_status})
        elif book_type == 3:
            history_status, book_desc = process_history_book(result)
            status_vars.update({"historyStatus": history_status})
        
        processed_books.append(book_desc)
        yield status_vars.copy(), processed_books  # 返回当前状态的副本和已处理书籍描述列表

# 定义需要处理的书籍列表
books = [(1, "数据结果1"), (2, "数据结果2"), (3, "数据结果3")]

# 创建生成器实例
gen = process_books_generator(books, status_vars)

# 使用生成器
for status, books_processed in gen:
    print("Current Status:", status)
    print("Processed Books:", books_processed)

结果

Processing book: 数据结果1
{'fictionStatus': 1, 'scienceStatus': -1, 'historyStatus': -1}
Processing book: 数据结果2
{'fictionStatus': 1, 'scienceStatus': 1, 'historyStatus': -1}
Processing book: 数据结果3
{'fictionStatus': 1, 'scienceStatus': 1, 'historyStatus': 1}
Processing book: 数据结果1
Current Status: {'fictionStatus': 1, 'scienceStatus': 1, 'historyStatus': 1}
Processed Books: ['小说类别：已处理']
Processing book: 数据结果2
Current Status: {'fictionStatus': 1, 'scienceStatus': 1, 'historyStatus': 1}
Processed Books: ['小说类别：已处理', '科学类别：已处理']
Processing book: 数据结果3
Current Status: {'fictionStatus': 1, 'scienceStatus': 1, 'historyStatus': 1}
Processed Books: ['小说类别：已处理', '科学类别：已处理', '历史类别：已处理']

修改后的代码主要描述了一个图书管理系统的功能，该系统能够根据书籍类型（如小说、科学、历史等）处理不同的书籍，并更新相应的状态和记录已处理书籍的描述。具体来说，代码实现了以下几个核心功能：

1. 书籍类型的处理逻辑：

   • process_fiction_book(result)：处理小说类书籍的逻辑。
   • process_science_book(result)：处理科学类书籍的逻辑。
   • process_history_book(result)：处理历史类书籍的逻辑。

2. 状态变量更新：

   • update_status(status_vars, **updates)：一个辅助函数，用于更新状态变量字典中的特定字段。

3. 书籍处理函数：

   • process_book(book_type, result, processed_books, status_vars)：根据书籍类型调用相应的处理函数，并更新状态变量和已处理书籍描述列表。

4. 生成器函数：

   • process_books_generator(books, status_vars)：一个生成器函数，逐步处理每种类型的书籍，并在每次迭代中返回当前的状态变量和已处理书籍描述列表。

详细功能描述

• 初始化状态变量和已处理书籍描述列表：

  status_vars = {"fictionStatus": -1, "scienceStatus": -1, "historyStatus": -1}
  processed_books = []
  

• 单次处理书籍：

  • 调用 process_book 函数来处理不同类型的书籍，并更新状态变量和已处理书籍描述列表：

    status_vars, processed_books = process_book(1, "数据结果1", processed_books, status_vars)
    print(status_vars)  # 查看更新后的状态变量
    status_vars, processed_books = process_book(2, "数据结果2", processed_books, status_vars)
    print(status_vars)  # 查看更新后的状态变量
    status_vars, processed_books = process_book(3, "数据结果3", processed_books, status_vars)
    print(status_vars)  # 查看更新后的状态变量
    

• 使用生成器逐步处理书籍：

  • 创建并使用生成器实例来逐步处理每种类型的书籍，并在每次迭代中获取当前的状态和已处理书籍描述列表：

    books = [(1, "数据结果1"), (2, "数据结果2"), (3, "数据结果3")]
    
    gen = process_books_generator(books, status_vars)
    
    for status, books_processed in gen:
        print("Current Status:", status)
        print("Processed Books:", books_processed)
    

示例输出

假设我们有以下书籍处理顺序：

books = [(1, "数据结果1"), (2, "数据结果2"), (3, "数据结果3")]

生成器的输出如下：

Processing book: 数据结果1
Current Status: {'fictionStatus': 1, 'scienceStatus': -1, 'historyStatus': -1}
Processed Books: ['小说类别：已处理']

Processing book: 数据结果2
Current Status: {'fictionStatus': 1, 'scienceStatus': 1, 'historyStatus': -1}
Processed Books: ['小说类别：已处理', '科学类别：已处理']

Processing book: 数据结果3
Current Status: {'fictionStatus': 1, 'scienceStatus': 1, 'historyStatus': 1}
Processed Books: ['小说类别：已处理', '科学类别：已处理', '历史类别：已处理']

用设计模式来封装代码

使用**策略模式（Strategy Pattern）和工厂方法模式（Factory Method Pattern）**来重构代码
将不同类型的书籍处理逻辑分离成独立的策略类，并通过工厂方法动态创建这些策略类的实例。如果将来需要添加新的书籍类型或修改现有类型的处理逻辑，只需添加或修改相应的策略类即可，而无需修改核心处理逻辑。

策略模式

策略模式允许定义一系列算法，并将每个算法封装起来，使它们可以互换使用。在这个场景中，不同类型的书籍处理逻辑可以被视为不同的策略。

工厂方法模式

工厂方法模式提供了一种创建对象的接口，但由子类决定要实例化的类是哪一个。这样可以避免在客户端代码中直接使用具体类名，从而增强灵活性。

以下是使用这两种设计模式重构后的代码示例：

from abc import ABC, abstractmethod

# 策略接口
class BookProcessor(ABC):
    @abstractmethod
    def process(self, result):
        pass

# 具体策略：小说类书籍处理器
class FictionBookProcessor(BookProcessor):
    def process(self, result):
        return 1, "小说类别：已处理"

# 具体策略：科学类书籍处理器
class ScienceBookProcessor(BookProcessor):
    def process(self, result):
        return 1, "科学类别：已处理"

# 具体策略：历史类书籍处理器
class HistoryBookProcessor(BookProcessor):
    def process(self, result):
        return 1, "历史类别：已处理"

# 工厂方法模式：用于创建具体的书籍处理器
class BookProcessorFactory:
    @staticmethod
    def create_processor(book_type):
        if book_type == 1:
            return FictionBookProcessor()
        elif book_type == 2:
            return ScienceBookProcessor()
        elif book_type == 3:
            return HistoryBookProcessor()
        else:
            raise ValueError("未知的书籍类型")

# 上下文类：负责调用合适的处理器
class BookContext:
    def __init__(self, processor: BookProcessor):
        self.processor = processor

    def process_book(self, result, status_vars, processed_books):
        status, book_desc = self.processor.process(result)
        if isinstance(self.processor, FictionBookProcessor):
            status_vars.update({"fictionStatus": status})
        elif isinstance(self.processor, ScienceBookProcessor):
            status_vars.update({"scienceStatus": status})
        elif isinstance(self.processor, HistoryBookProcessor):
            status_vars.update({"historyStatus": status})

        processed_books.append(book_desc)
        return status_vars, processed_books

# 使用生成器逐步处理书籍
def process_books_generator(books, status_vars):
    processed_books = []
    
    for book_type, result in books:
        print("Processing book:", result)
        
        # 根据书籍类型创建相应的处理器
        processor = BookProcessorFactory.create_processor(book_type)
        context = BookContext(processor)
        
        status_vars, processed_books = context.process_book(result, status_vars, processed_books)
        yield status_vars.copy(), processed_books

# 初始化状态变量
status_vars = {"fictionStatus": -1, "scienceStatus": -1, "historyStatus": -1}

# 定义需要处理的书籍列表
books = [(1, "数据结果1"), (2, "数据结果2"), (3, "数据结果3")]

# 创建生成器实例
gen = process_books_generator(books, status_vars)

# 使用生成器
for status, books_processed in gen:
    print("Current Status:", status)
    print("Processed Books:", books_processed)

代码说明

1. 策略接口 (BookProcessor)：

   • 定义了一个抽象基类 BookProcessor，所有具体的书籍处理器都必须实现 process 方法。

2. 具体策略：

   • FictionBookProcessor、ScienceBookProcessor 和 HistoryBookProcessor 是具体的策略类，分别实现了 process 方法来处理不同类型书籍的逻辑。

3. 工厂方法模式 (BookProcessorFactory)：

   • BookProcessorFactory 提供了一个静态方法 create_processor，根据传入的书籍类型返回相应的处理器实例。

4. 上下文类 (BookContext)：

   • BookContext 负责调用具体的处理器来处理书籍，并更新状态变量和已处理书籍描述列表。

5. 生成器函数 (process_books_generator)：

   • 该函数使用生成器逐步处理每种类型的书籍，并在每次迭代中返回当前的状态和已处理书籍描述列表。

示例输出

假设我们有以下书籍处理顺序：

books = [(1, "数据结果1"), (2, "数据结果2"), (3, "数据结果3")]

生成器的输出如下：

Processing book: 数据结果1
Current Status: {'fictionStatus': 1, 'scienceStatus': -1, 'historyStatus': -1}
Processed Books: ['小说类别：已处理']

Processing book: 数据结果2
Current Status: {'fictionStatus': 1, 'scienceStatus': 1, 'historyStatus': -1}
Processed Books: ['小说类别：已处理', '科学类别：已处理']

Processing book: 数据结果3
Current Status: {'fictionStatus': 1, 'scienceStatus': 1, 'historyStatus': 1}
Processed Books: ['小说类别：已处理', '科学类别：已处理', '历史类别：已处理']

yield 生成器对象和参数解包（Unpacking）的语法说明

yield 生成器对象：

• 生成器是一种特殊的迭代器，允许逐步生成一系列值。
• 使用 yield 关键字定义生成器函数。
• 生成器适合处理大量数据或需要逐步计算的场景，因为它们可以节省内存并提高效率。

参数解包（Unpacking）：

• 使用单星号 * 解包列表或元组，并将其元素作为单独的参数传递给函数。
• 使用双星号 ** 解包字典，并将其键值对作为关键字参数传递给函数。
• 参数解包使得函数调用更加灵活和简洁

1. yield 生成器对象

什么是生成器？

生成器是一种特殊的迭代器，它允许你逐步生成一系列值，而不是一次性生成所有值。生成器非常适合处理大量数据或需要逐步计算的场景，因为它可以节省内存并提高效率。

如何创建生成器？

生成器可以通过两种方式创建：

1. 生成器函数：使用 yield 关键字定义的函数。
2. 生成器表达式：类似于列表推导式，但使用圆括号而不是方括号。

示例：生成器函数

def simple_generator():
    yield 1
    yield 2
    yield 3

gen = simple_generator()
for value in gen:
    print(value)

输出：

1
2
3

示例：生成器表达式

gen_expr = (x * x for x in range(3))
for value in gen_expr:
    print(value)

输出：

0
1
4

生成器的优势

• 节省内存：生成器一次只生成一个值，而不是将所有值存储在内存中。
• 惰性计算：生成器中的值是按需生成的，这意味着你可以处理无限序列。

2. 参数解包（Unpacking）

参数解包是指在函数调用时，通过使用星号 * 或双星号 ** 来解包可迭代对象或字典，以便将它们作为单独的参数传递给函数。

单星号 * 解包列表或元组

单星号 * 可以用于解包列表或元组，并将其元素作为单独的参数传递给函数。

示例：

def add(a, b, c):
    return a + b + c

numbers = [1, 2, 3]
result = add(*numbers)  # 等价于 add(1, 2, 3)
print(result)  # 输出 6

双星号 ** 解包字典

双星号 ** 可以用于解包字典，并将其键值对作为关键字参数传递给函数。

示例：

def greet(name, greeting="Hello"):
    return f"{greeting}, {name}!"

params = {"name": "Alice", "greeting": "Hi"}
result = greet(**params)  # 等价于 greet(name="Alice", greeting="Hi")
print(result)  # 输出 Hi, Alice!

结合 yield 和 参数解包的实际应用示例

假设我们有一个生成器函数，它可以生成一些书籍处理结果，并且我们希望在每次生成结果时使用参数解包来调用另一个函数。

示例代码：

def process_book(book_type, result):
    if book_type == 1:
        return "小说类别：已处理", result
    elif book_type == 2:
        return "科学类别：已处理", result
    elif book_type == 3:
        return "历史类别：已处理", result
    else:
        raise ValueError("未知的书籍类型")

def process_books_generator(books):
    for book_type, result in books:
        yield process_book(book_type, result)

# 定义一个函数，接收解包后的参数
def log_book_processing(description, result):
    print(f"处理结果: {description}, 原始数据: {result}")

# 定义需要处理的书籍列表
books = [(1, "数据结果1"), (2, "数据结果2"), (3, "数据结果3")]

# 创建生成器实例
gen = process_books_generator(books)

# 使用生成器和参数解包
for description, result in gen:
    log_book_processing(description, result)

输出：

处理结果: 小说类别：已处理, 原始数据: 数据结果1
处理结果: 科学类别：已处理, 原始数据: 数据结果2
处理结果: 历史类别：已处理, 原始数据: 数据结果3

。