单一实现可以覆盖Python中的单个值和多个值吗？

假设你有这样的价值:

n = 5

以及返回它的阶乘的方法,如下所示:

因子(5)

你如何处理多个值:

nums = [1,2,3,4,5]

因子(nums)

所以它将所有这些值的阶乘返回为列表.

如果不编写2种方法,最简洁的方法是什么？python有一个很好的方法来处理这种情况吗？

def Factorial(arg):
    try:
        it = iter(arg)
    except TypeError:
        pass
    else:
        return [Factorial(x) for x in it]
    return math.factorial(arg)

如果它是可迭代的,则应用recursivly.否则,正常进行.

或者,您可以将最后一个移动return到except块中.

如果你确定身体Factorial永远不会升起TypeError,可以简化为:

def Factorial(arg):
    try:
        return [Factorial(x) for x in arg]
    except TypeError:
        return math.factorial(arg)

列表理解:

[fac(n) for n in nums]

编辑:

对不起,我误解了,你想要一个处理序列和单值的方法吗？我无法想象为什么你不会用两种方法做到这一点.

def factorial(n):
    # implement factorial here
    return answer

def factorial_list(nums):
    return [factorial(n) for n in nums]

另一种方法是进行某种类型检查,除非你有一些非常有说服力的理由,否则最好避免这种类型检查.

编辑2:

MizardX的答案更好,投票给那个.干杯.

这有时是完成的.

def factorial( *args ):
    def fact( n ):
        if n == 0: return 1
        return n*fact(n-1)
    return [ fact(a) for a in args ]

它提供了一个几乎神奇的功能,可以使用简单的值和序列.

>>> factorial(5)
[120]
>>> factorial( 5, 6, 7 )
[120, 720, 5040]
>>> factorial( *[5, 6, 7] )
[120, 720, 5040]

如果你问的是Python是否可以进行方法重载:不.因此,像这样的多方法是一种非Pythonic定义方法的方法.此外,命名约定通常是大写的类名和小写的函数/方法.

如果你想继续前进,最简单的方法就是建立一个分支:

def Factorial(arg):
  if getattr(arg, '__iter__', False): # checks if arg is iterable
    return [Factorial(x) for x in arg]
  else:
    # ...

或者,如果你感觉很花哨,你可以制作一个装饰器来执行任何功能:

def autoMap(f):
    def mapped(arg):
        if getattr(arg, '__iter__', False):
            return [mapped(x) for x in arg]
        else:
            return f(arg)
    return mapped

@autoMap
def fact(x):
    if x == 1 or x == 0:
        return 1
    else:
        return fact(x-1) + fact(x-2)

>>> fact(3)
3
>>> fact(4)
5
>>> fact(5)
8
>>> fact(6)
13
>>> fact([3,4,5,6])
[3, 5, 8, 13]

虽然更Pythonic的方法是使用变量参数长度:

def autoMap2(f):
    def mapped(*arg):
        if len(arg) != 1:
            return [f(x) for x in arg]
        else:
            return f(arg[0])
    return mapped

@autoMap2
def fact(n):
# ...

>>> fact(3,4,5,6)
[3, 5, 8, 13]

将两者组合成一个深度映射装饰器:

def autoDeepMap(f):
    def mapped(*args):
        if len(args) != 1:
            return [mapped(x) for x in args]
        elif getattr(args[0], '__iter__', False):
            return [mapped(x) for x in args[0]]
        else:
            return f(args[0])
    return mapped

@autoDeepMap
def fact(n):
# ...

>>> fact(0)
1
>>> fact(0,1,2,3,4,5,6)
[1, 1, 2, 3, 5, 8, 13]
>>> fact([0,1,2,3,4,5,6])
[1, 1, 2, 3, 5, 8, 13]
>>> fact([0,1,2],[3,4,5,6])
[[1, 1, 2], [3, 5, 8, 13]]
>>> fact([0,1,2],[3,(4,5),6])
[[1, 1, 2], [3, [5, 8], 13]]