如何最好地实现对此类的每个对象都不同的类方法

Question

作为一名教师，我想为数学问题编写一个工作表生成器。 Python 应该生成数学问题及其解决方案（例如，创建一个多项式函数并计算它们的零点）。然后它会写入一个 LaTeX 输入文件并通过pdflatex 创建一个 pdf。它适用于几个问题，但现在我想对其进行概括并使其面向对象以加快进一步工作表的创建。

所以我创建了一个类Problem，其中包含几个参数和方法。但是每个Problem-instance 都应该有不同的函数来为数学问题及其解决方案创建文本（因为每个对象都是不同的数学问题）。而且我不知道我应该如何以优雅/适当的方式管理它。

目前我正在做这样的事情：

import random


class Problem_generator(object):
    def __init__(self):
        self.problemlist = []

    def create_worksheet(self):
        """ Creates the latex-document by writing the output in a LaTeX input file. For 
            this minimal example, I'll just print the outputs instead.
        """
        for problem in self.problemlist:
            text = problem.create()
            print("Problem: " + text[0])
            print("Solution: " + text[1])


class Problem(object):
    def __init__(self, problem_generator, function):
        # do some stuff like to create Tkinter-GUI-objects for every problem
        self.function = function
        problem_generator.problemlist.append(self)

    def create(self):
        return self.function()


def add_numbers():
    """ Create the problem to add two numbers. """

    a, b = random.randint(0, 100), random.randint(0, 100)
    problem_text = str(a) + " + " + str(b)
    solution_text = str(a+b)
    return problem_text, solution_text


generator = Problem_generator()
problem_1 = Problem(generator, add_numbers)

generator.create_worksheet()  # in the complete program I start this over a GUI

它工作正常，但感觉不“正确”。 我还考虑过使用create() 方法实现Problem 类，该方法只会引发未实现的错误，然后为我创建的每个问题更新create() 方法。但据我所知，这将为类的每个对象更新 create() 方法。

因此，我很乐意获得一些提示/建议，我可以如何以“优雅”的方式处理所描述的问题。

Answer 1

这是我的做法：

import random
from typing import Callable, List, Tuple


ProblemCreator = Callable[[], Tuple[str, str]]  # returns (problem, solution)


class Problem:
    def __init__(self, function: ProblemCreator) -> None:
        # do some stuff like to create Tkinter-GUI-objects for every problem
        self.create = function


class ProblemGenerator:
    def __init__(self) -> None:
        self.problem_list: List[Problem] = []

    def create_worksheet(self) -> None:
        """
        Creates the latex-document by writing the output in a *.tex-file.
        For this minimal example, I'll just print the outputs instead.
        """
        for problem in self.problem_list:
            p, s = problem.create()
            print(f"Problem: {p}")
            print(f"Solution: {s}")

    def generate_problem(self, problem: ProblemCreator) -> None:
        self.problem_list.append(Problem(problem))


def add_numbers() -> Tuple[str, str]:
    """  Create the problem to add two numbers. """
    a, b = random.randint(0, 100), random.randint(0, 100)
    return f"{a} + {b}", f"{a+b}"


generator = ProblemGenerator()
generator.generate_problem(add_numbers)

generator.create_worksheet()  # in the complete program I start this over a GUI

我使用了类型注释和其他 Python 3 特性（如 f 字符串）来提高清晰度。

create 不需要成为一个方法——只需将其设为可调用属性即可（我已为该可调用属性的类型命名，ProblemCreator，因为它构成了此接口的重要部分） .同样，Problem 也不需要知道ProblemGenerator 并负责将自己添加到生成器的列表中；它只是创建了一个你不需要的循环依赖。相反，让ProblemGenerator 负责产生问题（就像它的名字一样）！

Answer 2

我真的没有发现 Problem_generator 类有什么用处，这就是我的做法（我添加了一个 ProblemGenerator 类，但您可以循环调用 issue.create）

通过这个你可以

• 将问题定义为问题的子类（参见 AddTwoNumbers 类）
• 将问题定义为函数（参见 subtract_numbers 函数）并使用问题装饰器将它们转换为 FunctionProblems（Problem 的子类）。

from abc import ABC, abstractmethod
from functools import wraps
import random
from typing import Callable, List, Tuple

random.seed(0) # for reproducability

class Problem(ABC):
    @property
    @abstractmethod
    def text(self) -> str:
        pass

    @property
    @abstractmethod
    def solution_text(self) -> str:
        pass


class AddTwoNumbers(Problem):
    def __init__(self) -> None:
        self._a = random.randint(0, 100)
        self._b = random.randint(0, 100)

    @property
    def text(self) -> str:
        return f'{self._a} + {self._b}'

    @property
    def solution_text(self) -> str:
        return str(self._a + self._b)

# If you want to define functions as problems you can do something like that
class FunctionProblem(Problem):
    def __init__(self, func: Callable[[], Tuple[str, str]]):
        self._text, self._solution_text = func()

    @property
    def text(self) -> str:
        return self._text

    @property
    def solution_text(self) -> str:
        return self._solution_text

# Define a decorator so that functions become FunctionProblems
def problem_decorator(func: Callable[[], Tuple[str, str]]) -> Callable[[], FunctionProblem]:
    @wraps(func)
    def wrapper():
        return FunctionProblem(func)
    return wrapper

@problem_decorator
def subtract_numbers() -> Tuple[str, str]:
    a, b = random.randint(0, 100), random.randint(0, 100)
    text = f'{a} - {b}'
    solution = str(a - b)
    return text, solution

# If you really want to define a ProblemGenerator
class ProblemGenerator:
    def __init__(self, *problems: Problem) -> None:
        self.problems = list(problems)

    def add_problem(self, problem: Problem) -> None:
        self.problems.append(problem)

    def create_worksheet(self) -> List[Tuple[str, str]]:
        for problem in self.problems:
            print(f'Problem text is {problem.text!r}, Solution is {problem.solution_text!r}')

generator = ProblemGenerator(AddTwoNumbers())
generator.add_problem(subtract_numbers())
generator.create_worksheet()

打印

Problem text is '49 + 97', Solution is '146'
Problem text is '53 - 5', Solution is '48'

Answer 3

正如我在评论中已经说过的那样，处理这种情况的经典 object-oriented programming (OOP) 方法是定义一个具有整体接口的抽象基类，也许还有一些通用帮助方法，然后定义特定问题的“具体”子类.这是一个基于您问题中的代码在 Python 上执行类似操作的玩具示例。如果看起来你正在创建一堆几乎相同的类。有时解决方法是子类化你的子类，但通常这只是意味着你没有很好地抽象问题......

从示例代码中的 cmets 看来，您似乎还希望您的类负责为图形用户界面 (GUI) 创建自己的 tkinter 对象。一般来说，这可能不是一个好主意——类通常应该只有一个single responsibility，这意味着尝试将其中的许多堆放在一起会使测试、调试和扩展你所拥有的东西变得更加困难，从而使事情变得非常复杂。

有一种常用的软件设计模式称为model–view–controller (MVC)，它通常用于开发用户界面，将程序分成三个相互连接的组件，但将每个组件分开以降低复杂性——所以我建议你花时间研究它.

import abc
import random


class Problem(metaclass=abc.ABCMeta):
    """ Abstract base class of all mathematical problems. """

    def __init__(self):
        self.lines = []

    @abc.abstractmethod
    def create_problem(self):
        """ Creates input to be fed to the create_worksheet method. """
        ...

    def create_worksheet(self, indent=4, char=' '):
        """ Creates the latex-document by writing the output in a LaTeX input file.
            In this toy example, it just print the lines the create_problem() method
            generated.
        """
        padding = indent * char
        for line in self.lines:
            print(padding + line)


class AddNumbers(Problem):
    def __init__(self):
        super().__init__()  # Initialize base class.
        self.create_problem()  # Create subclass-specific data.

    def create_problem(self):
        a, b = random.randint(0, 100), random.randint(0, 100)
        self.lines.append(f'Problem: Add the two numbers {a} and {b} together')
        self.lines.append(f'Solution: {a+b}')


if __name__ == '__main__':

    # Create some sample Problem subclass instances.
    problems = [AddNumbers(), AddNumbers()]

    # Create worksheet the worksheet for each one.
    for i, problem in enumerate(problems, start=1):
        print(f'Worksheet {i}:')
        problem.create_worksheet(indent=2)