Question

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

我已经为此提出了两个解决方案，但我认为我没有找到适合该问题的正确OOP设计模式，因为对象是具有对该数据进行操作的方法的数据，并且在此问题是没有什么数据可以操作，这对我天真的眼睛来说更像是一个功能（功能？）问题。下面是两个，一个基本上是在配置文件中为算法执行适当的静态方法，另一个是返回对函数的引用。两者都生成数字并将其打印到屏幕上。

第一种方法：

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()

大多数面向对象的方法在python中解决这个问题？

1 个答案: