Question

我对Python有些新意，我想更好地理解类。下面是一些函数，这些函数具有许多相似之处但功能不同，这些函数被传递到每个multiprocessing函数中。无论如何，我可以将所有这些功能放入class FruitPie中吗？

def apple():
    if __name__ == '__main__':
        pool = mp.Pool(processes=8)
        pool.map(func1, same_list)
        pool.close()

def banana():
    if __name__ == '__main__':
        pool = mp.Pool(processes=8)
        pool.map(func2, same_list)
        pool.close()

def orange():
    if __name__ == '__main__':
        pool = mp.Pool(processes=8)
        pool.map(func3, same_list)
        pool.close()

Answer 1

你的意思是做点什么：

class FruitPie:
    def __init__(self, arguments):
        self.same_list = arguments

    def apple(self):
        # in python3.3+ you can use the with statement with Pools
        with mp.Pool(processes=8) as pool:
            pool.map(func1, self.same_list)

    def banana(self):
        with mp.Pool(processes=8) as pool:
            pool.map(func2, self.same_list)

    def orange(self):
        with mp.Pool(processes=8) as pool:
            pool.map(func3, self.same_list)

您可以将其用作：

# this if is needed only at module level, not everytime you create a pool.
if __name__ == '__main__':
    pie = FruitPie(['some', 'arguments'])
    pie.apple()
    pie.banana()
    pie.orange()

请注意，在创建类时，您必须使用self显式引用该实例。

Answer 2

由于每个函数都非常相似，因此您可以创建一个接受要运行的函数的方法（参见下面的_run_pool()）：

class FruitPie(object):
    def __init__(self, same_list):
        self.same_list = same_list

    def _run_pool(self, func):
        pool = mp.Pool(processes=8)
        pool.map(func, self.same_list)
        pool.close()

    def apple(self):
        self._run_pool(func1)

    def banana(self):
        self._run_pool(func2)

    def orange(self):
        self._run_pool(func3)

# use like this...
pie = FruitPie(same_list)
pie.apple()
pie.banana()
pie.orange()

但是，我倾向于做一些这样的事情，它使用字典来发送给一个给出水果名称的函数：

class FruitPie(object):
    funcs = {'apple': func1, 'banana': func2, 'orange', func3}

    def __init__(self, same_list):
        self.same_list = same_list

    def run_pool(self, fruit):
        pool = mp.Pool(processes=8)
        pool.map(FruitPie.funcs[fruit], self.same_list)
        pool.close()

# use like this...
pie = FruitPie(same_list)
for fruit in 'apple', 'banana', 'orange':
    pie.run_pool(fruit)

Answer 3

首先，面向对象编程不仅仅是将函数放在一个类中。对象应表示实体（真实或虚拟），提供与其关联的所有行为，封装其内部实现。

其次，方法名称（或该事项的函数名称）应该是动词而不是名词，而类（代表实体应该是名词）。

第三，这是多态行为的一个例子

简单（天真）的实现可能如下所示 -

class Fruit(object):
      """ An abstract class"""

      func = None

      def process(self, arguments):
          with mp.Pool(processes=8) as pool:
               pool.map(self.func, arguments)

class Apple(Fruit):

      func = func1

class Banana(Fruit):

      func = func2

class Orange(Fruit):

      func = func3

class FruitPie(object):

      def __init__(self, fruits):
          self.fruits = fruits

      def process(self, arguments):
          for fruit in self.fruits:
              fruit.process(arguments)

if __name__ == '__main__':
     pie = FruitPie(Apple(), Banana(), Orange())
     pie.process()

这不是一个完美的设计，根据我不完全了解的课程要求，可以有很多改进。但是就这些问题而言。

Python：将函数放入类中

3 个答案: