Python'da hem tek hem de çoklu değerleri kapsayacak tek uygulama</p> <p>n = 5</p> <p>ve bunun faktöriyelini döndüren şöyle bir yöntem:</p> <p>Faktoriyel (5)</p> <p>Nasıl yapmalıyım

Question

bir böyle bir değere sahip Say birden çok değer:

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

Faktöriyel (nums)

böylece tüm bu değerlerin özelliklerini bir liste olarak döndürür.

Bunu işlemenin en temiz yolu, 2 yöntem yazmadan nelerdir? Python'un bu tür durumlarla başa çıkmak için iyi bir yolu var mı?

Answer 1

Bu bazen yapılır: Eğer Factorial gövdesi TypeError yükseltmek asla eminseniz için

, bu basitleştirilmiş olabilir.

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

Basit değerler ve sekanslarla çalışan neredeyse sihirli bir işlev verir.

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

Answer 2

List comprehension:

[fac(n) for n in nums] 

DÜZENLEME:

Üzgünüm, her iki dizileri ve tek değerleri işleyen bir yöntem istiyor yanlış? Bunu neden iki yöntemle yapmayacağını hayal bile edemiyorum.

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

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

alternatif bunu yapmak için bazı korkunç önemli neden yoksa daha iyi kaçınılmalıdır tip denetimi, çeşit yapmak olacaktır.

DÜZENLEME 2:

MizardX cevabı daha iyidir, o biri için oy. Şerefe.

Answer 3

Python'un aşırı yükleme yöntemi yapıp yapamayacağını sorarsanız: hayır. Bu nedenle, bu gibi çok-yöntemlerin yapılması, bir yöntemi tanımlamak için oldukça Pythonic olmayan bir yoldur. Ayrıca, adlandırma kuralı genellikle büyük harf sınıf adları ve küçük harf işlevleri/yöntemleri. Eğer fantezi hissediyorsanız, herhangi işleve yapar bir dekoratör yapabilir,

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

Veya: zaten önde gitmek isterseniz

, basit yolu sadece bir dal oluşturmak için olacaktır:

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] 

daha Pythonic bir şekilde değişken bağımsız değişken uzunluklarının kullanmak da:

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] 

P Derin bir haritalama dekoratör bir araya ikisini Utting: Bu iterable ise

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]] 

Answer 4

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

, recursivly geçerlidir. Aksi takdirde normal şekilde ilerleyin.

Alternatif olarak, son return'u except bloğuna taşıyabilirsiniz.

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

Answer 5

Yoksa liste anlama sözdizimi gibi ve yeni bir yöntem olan atlamak istemiyorsanız:

def factorial(num): 
    if num == 0: 
     return 1 
    elif num > 0: 
     return num * factorial(num - 1) 
    else: 
     raise Exception("Negative num has no factorial.") 

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

map(factorial, nums) 
# [1, 2, 6, 24, 120, 720] 

Answer 6

Sen NumPy/scipy en vectorize bir göz atmak isteyebilirsiniz. numpy dünyada

, dün durum ham yerine tek öğeli numpy dizi döndüren not rağmen

vFactorial=np.vectorize(Factorial) 
    vFactorial([1,2,3,4,5]) 
    vFactorial(6) 

gibi şeyler yapardım senin tek int-arg Faktoriyel fonksiyonu, verilen int.