用python解决这个问题的最面向对象的方法是什么？

Question

我被告知要编写一个生成优惠券代码的简单程序，它应该提供两个以上的算法（任意两个），并且算法和生成的代码数应该从配置文件中读取。还有人告诉我，解决方案将涉及使用已知的设计模式，我应该寻找模式是什么。你知道吗

我为此提出了两种解决方案，但我认为我还没有找到一种适合这个问题的OOP设计模式，因为对象是数据，其方法可以对这些数据进行操作，而在这个问题中，几乎没有数据可供操作，它更像是一个函数（functional？）我天真的眼睛有问题。这里有两个，一个基本上是在配置文件中为算法执行正确的静态方法，另一个返回对函数的引用。两者都生成数字并打印到屏幕上。你知道吗

第一种方法：

class CouponGenerator:
    SEQUENTIAL_NUMBERS = "sequentialNumbers"
    FIBONACCI_NUMBERS = "fibonacciNumbers"
    ALPHANUMERIC_SEQUENCE = "alphanumericSequence"
    quantity = 0
    algorithm = ""

    def __init__(self, quantity, algorithm):
        self.quantity = quantity
        self.algorithm = algorithm

    def generateCouponList(self):
        numbers = list()

        if self.algorithm == self.SEQUENTIAL_NUMBERS:
            numbers = CouponGenerator.generateSequentialNumbers(self.quantity)
        elif self.algorithm == self.FIBONACCI_NUMBERS:
            numbers = CouponGenerator.generateFibonacciSequence(self.quantity)

        for number in numbers:
            print number

    @staticmethod
    def getCouponGenerator(configFile):
        cfile = open(configFile)
        config = cfile.read()
        jsonconfig = json.loads(config)
        cg = CouponGenerator(jsonconfig['quantity'], jsonconfig['algorithm'])
        return cg

    @staticmethod
    def generateSequentialNumbers(quantity):
        numbers = list()
        for n in range(1, quantity+1):
            zeroes = 6-len(str(n))
            numbers.append(zeroes*"0"+str(n))

        return numbers

    @staticmethod
    def generateFibonacciSequence(quantity):
        def fib(n):
            a, b = 0, 1
            for _ in xrange(n):
                a, b = b, a + b
            return a

        numbers = list()
        for n in range(1, quantity+1):
            number = fib(n)
            zeros = 6-len(str(number))
            numbers.append(zeros*"0"+str(number))
        return numbers

if __name__ == "__main__":
    generator = CouponGenerator.getCouponGenerator("config")
    generator.generateCouponList()

第二种解决方案：

class CouponGenerator:
    @staticmethod
    def getCouponGenerator(algorithm):
        def generateSequentialNumbers(quantity):
            numbers = list()
            for n in range(1, quantity+1):
                zeroes = 6-len(str(n))
                numbers.append(zeroes*"0"+str(n))
            return numbers


        def generateFibonacciSequence(quantity):
            def fib(n):
                a, b = 0, 1
                for _ in xrange(n):
                    a, b = b, a + b
                return a

            numbers = list()
            for n in range(1, quantity+1):
                number = fib(n)
                zeros = 6-len(str(number))
                numbers.append(zeros*"0"+str(number))
            return numbers

        generators = {"sequentialNumbers": generateSequentialNumbers,
                      "fibonacciNumbers": generateFibonacciSequence}

        return generators[algorithm]

class CouponGeneratorApp:
    configFile = "config"
    def __init__(self):
        cfile = open(self.configFile)
        config = cfile.read()
        self.jsonconfig = json.loads(config)
        self.generateCouponCodes()

    def generateCouponCodes(self):
        generator = CouponGenerator.getCouponGenerator(self.jsonconfig["algorithm"])
        numbers = generator(self.jsonconfig["quantity"])
        for n in numbers:
            print n

if __name__ == "__main__":
    app = CouponGeneratorApp()

Answer 1

如果你想让它更面向对象一点，我建议你使用某种策略模式，也就是说，使用每一代的类算法（应该有一个公共接口），并指定CouponGenrator使用一个实现这个接口的对象来做它必须做的事情。这是一个理论和制作界面，你的案例中的每件事都可能有点多。你知道吗

http://en.wikipedia.org/wiki/Strategy_pattern

你可以尝试以下方法：

class SequentialGenerator(Object):
    def implementation():
        ...

class FibonacciGenerator(Object):
    def implementation():
        ...

class CouponGenerator(Object):
    def set_generator(generator):
        # set self.generator to either an instance 
        # of FibonacciGenerator or SequentialGenerator

    def generate_coupon_code():
        # at some point calls self.generator.implementation()