编写在Python中接受单个项目或可迭代的方法

Question

我有一个设计问题。 我想写一个接受单个对象或可迭代对象的方法。 例如，假设我有Dog类：

class Dog(object):
    """
    An animal with four legs that may slobber a lot
    """
    def __init__(self, name="Fido"):
       self.name = name

现在，假设我有一个使用Dog类的类，例如DogWalker：

class DogWalker(object):
    """
    Someone who cares for Fido when Human Companion is not available
    """
    def __init__(self):
        self.dogs_walked = 0
        self.dogs_watered = 0

    def walk(self, dogs):
        """
        Take a dog for a walk
        """
        # This is not Pythonic
        if isinstance(Dog, dogs):
            # Walk a single dog
            pass
            self.dogs_walked +=1
        else:
            # walk lots of dogs
            pass


    def water(self, dogs):
        """
        Provide water to dogs
        """
        # More pythonic
        try:
            # Try to water single dog
            ...
            self.dogs_walked += 1
        except  AttributeError:
            # Try to water lots of dogs
            pass

在上面的示例中，我实现了walk和water两种方法。 water方法更具有Python风格，因为它使用Duck Typing。 但是，我想进一步谈谈。 假设我有一个看护人班，可以给不同类型的动物浇水：

class CareTaker(object):
    """
    Someone who cares for things
    """
    def __init__(self):
        self.things_watered = 0

    def water(self, things):
        """
        Provide water to a thing
        """
        # Here is where I need help!
        # 1. I need to figure out if things is a single item or iterable
        # 2. If thing is a single item I need to figure out what type of thing a thing is
        # 3. If thing is an iterable, I need to figure out what type of things are in the iterable.
        pass

现在，发生在我身上的一件事是，每件事物都知道如何给自己浇水，然后护理人员只需要调用事物浇水方法即可。 例如：

class CareTaker(object):
    """
    Someone who cares for things
    """
    def __init__(self):
        self.things_watered = 0

    def water(self, thing):
        """
        Provide water to a thing
        """
        result = thing.water()
        self.things_watered += 1
        return result

这样，使用代码可能看起来像：

ct = CareTaker()
dog = Dog()
bird = Bird()
water_dog = ct.water(dog)
water_bird = ct.water(bird)

things = [dog, bird]

for thing in things:
    ct.water(thing)

我还有其他想法，但是在我采用特定的设计方法之前，我想从其他可能会遇到此类问题的人那里得到一些建议。 如果您还可以列出您的想法的利弊。 那将是额外的奖励！ 谢谢。

更新：到目前为止，似乎有两个同样好的建议。

1. 测试传入参数的行为，例如，编写一个is_itereable方法。
2. 使用位置参数并遍历位置参数列表中的项目列表。

我还没有确定哪个更适合我的实际问题。

Answer 1

您可以使用*args “通配符”位置参数：

def walk(self, *dogs):
    for dog in dogs:
        # handle each dog.

并将其称为：

owner.walk(onedog, anotherdog)

要么

owner.walk(*listofdogs)

Answer 2

我建议您将两者结合起来。 如果狗，猫和鸟可以使用相同的方法，请使用方法名称而不关心您实际拥有的对象。 （常见的方法是您的动物API）。 但是，如果您传递了一个容器，这将无法正常工作，除非您遇到了伪造将每个API方法都应用于其每个子级的容器类的麻烦。 从技术上讲，这是可行的，但我发现以下更具吸引力：编写代码以始终期望有一个容器，并通过将单个对象嵌入到列表中来转换单个对象：

class Caretaker(object):
    ...
    def water(self, things):
        if isinstance(things, animal): # actually only one: fix it
            things = [ things ]

        for thing in things:
            ...

这假定您有一个从中衍生出dog和bird的父类animal 。 或者，您可以显式检查things是否可迭代，如下所示：

        if not isinstance(things, collections.Iterable):
            things = [ things ]

但是我更喜欢第一种方法。