पायथन में फैक्टरियल के लिए कार्य

Question

पायथन में पूर्णांक के एक भाज्य की गणना करने के बारे में मैं क्या करूँ?

Answer 1

सबसे आसान तरीका उपयोग करना है math.factorial(पायथन 2.6 और उससे ऊपर में उपलब्ध है):

import math
math.factorial(1000)

यदि आप इसे स्वयं लिखना चाहते हैं, तो आप पुनरावृत्त दृष्टिकोण का उपयोग कर सकते हैं:

def factorial(n):
    fact = 1
    for num in range(2, n + 1):
        fact *= num
    return fact

या एक पुनरावर्ती दृष्टिकोण:

def factorial(n):
    if n < 2:
        return 1
    else:
        return n * factorial(n-1)

ध्यान दें कि फैक्टरियल फ़ंक्शन केवल सकारात्मक पूर्णांकों के लिए परिभाषित किया गया है, इसलिए आपको यह n >= 0और वह भी जांचना चाहिए isinstance(n, int)। यदि ऐसा नहीं है, एक उठाना ValueErrorया एक TypeErrorक्रमशः। math.factorialआप के लिए इस का ख्याल रखना होगा।

Comments

मुझे समझ नहीं आ रहा है कि आप फ़ंक्शन के factorialभीतर कैसे उपयोग कर सकते हैं factorial। जिस फ़ंक्शन को आप वर्तमान में परिभाषित कर रहे हैं, आप उसी फ़ंक्शन का उपयोग कैसे कर सकते हैं? मैं अजगर के लिए नया हूं इसलिए मैं सिर्फ समझने की कोशिश कर रहा हूं।

— J82

@ J82: यहाँ इस्तेमाल की जाने वाली अवधारणा को पुनरावर्तन ( en.wikipedia.org/wiki/Recursion_(computer_science) कहा जाता है - एक फ़ंक्शन जो स्वयं को बुलाता है वह पूरी तरह से ठीक है और अक्सर उपयोगी होता है।

— श्नाडर 10

जब तक आप अजगर की पुनरावृत्ति सीमा नहीं बढ़ाते हैं, तब तक पुनरावर्ती कार्य RecursionError998 (कोशिश factorial(999)) की तुलना में किसी भी संख्या के लिए बड़ा होगा

— बोरिस

Answer 2

पायथन 2.6 और ऊपर, कोशिश करें:

import math
math.factorial(n)

Comments

पायथन 3.9 के साथ शुरू , floatइस समारोह के लिए एक गुजर एक होगा DeprecationWarning। यदि आप ऐसा करना चाहते हैं, तो आपको nएक intस्पष्ट रूप से परिवर्तित करने की आवश्यकता है : math.factorial(int(n))जो दशमलव के बाद कुछ भी छोड़ देगा, इसलिए आप यह जांचना चाहते हैं किn.is_integer()

— बोरिस

Answer 3

वास्तव में आवश्यक नहीं है क्योंकि यह इतना पुराना धागा है। लेकिन मैंने यहाँ किया था एक लूप का उपयोग करके पूर्णांक के भाज्य की गणना करने का एक और तरीका।

def factorial(n):
    num = 1
    while n >= 1:
        num = num * n
        n = n - 1
    return num

Comments

factorial (-1) 1 वापस आएगा, ValueError या कुछ और उठाना चाहिए।

— f.rodrigues

यदि आप दशमलव के बाद संख्याओं के साथ फ्लोट में पास होते हैं तो यह फ़ंक्शन गलत परिणाम देगा।

— बोरिस

इस फ़ंक्शन के साथ, मैं पहले चार पूर्णांकों के भाज्य का प्रिंट आउट लेना चाहता हूं। जब मैं इसके num = num * nसाथ लाइन की स्थिति स्वैप करता हूं n = n - 1और इसे चलाता for i in range(1, 5): print('Factorial of', i, 'is', factorial(i))हूं, तो प्रत्येक तथ्य के लिए, आउटपुट 0. मैं औचित्य जानना चाहूंगा कि num = num * nपहले क्यों आने की जरूरत है। धन्यवाद!!

Answer 4

मौजूदा समाधान

सबसे छोटा और शायद सबसे तेज़ समाधान है:

from math import factorial
print factorial(1000)

अपना खुद का निर्माण

आप अपना समाधान भी बना सकते हैं। आम तौर पर आपके पास दो दृष्टिकोण होते हैं। जो मुझे सबसे अच्छा लगता है वह है:

from itertools import imap
def factorial(x):
    return reduce(long.__mul__, imap(long, xrange(1, x + 1)))

print factorial(1000)

(यह बड़ी संख्या के लिए भी काम करता है, जब परिणाम बन जाता है long)

उसी को प्राप्त करने का दूसरा तरीका है:

def factorial(x):
    result = 1
    for i in xrange(2, x + 1):
        result *= i
    return result

print factorial(1000)

Answer 5

def factorial(n):
    if n < 2:
        return 1
    return n * factorial(n - 1)

Comments

factorial(999)(और ऊपर) RuntimeErrorजब तक आप अजगर की पुनरावृत्ति सीमा नहीं बढ़ाएंगे

— बोरिस

Answer 6

यदि आप Python2.5 या पुराने प्रयास का उपयोग कर रहे हैं

from operator import mul
def factorial(n):
    return reduce(mul, range(1,n+1))

नए पायथन के लिए, गणित मॉड्यूल में तथ्यात्मक है जैसा कि यहां अन्य उत्तरों में दिया गया है

Comments

यह पायथन 2-एकमात्र उत्तर है, reduceपायथन 3 से हटा दिया गया था

— बोरिस

@ बोरिस, पायथन 3 में आपको बस जोड़ने की जरूरत हैfrom functools import reduce

— जॉन ला रोय

इसे एक कारण के लिए हटा दिया गया था, आपको इसका उपयोग नहीं करना चाहिए artima.com/weblogs/viewpost.jsp?thread=98196

— Boris

Answer 7

def fact(n):
    f = 1
    for i in range(1, n + 1):
        f *= i
    return f

Answer 8

for-लूप का उपयोग , पीछे से गिनती n:

def factorial(n):
    base = 1
    for i in range(n, 0, -1):
        base = base * i
    print(base)

Answer 9

प्रदर्शन कारणों के लिए, कृपया पुनरावृत्ति का उपयोग न करें। यह विनाशकारी होगा।

def fact(n, total=1):
    while True:
        if n == 1:
            return total
        n, total = n - 1, total * n

चल रहे परिणामों की जाँच करें

cProfile.run('fact(126000)')

---

4 function calls in 5.164 seconds

स्टैक का उपयोग करना सुविधाजनक है (जैसे पुनरावर्ती कॉल), लेकिन यह एक लागत पर आता है: विस्तृत जानकारी संग्रहीत करने में बहुत अधिक मेमोरी लग सकती है।

यदि स्टैक अधिक है, तो इसका मतलब है कि कंप्यूटर फ़ंक्शन कॉल के बारे में बहुत सारी जानकारी संग्रहीत करता है।

विधि केवल निरंतर मेमोरी (जैसे पुनरावृत्ति) लेती है।

या लूप के लिए उपयोग करना

def fact(n):
    result = 1
    for i in range(2, n + 1):
        result *= i
    return result

चल रहे परिणामों की जाँच करें

cProfile.run('fact(126000)')

---

4 function calls in 4.708 seconds

---

या अंतर्निहित फ़ंक्शन गणित का उपयोग करना

def fact(n):
    return math.factorial(n)

चल रहे परिणामों की जाँच करें

cProfile.run('fact(126000)')

---

5 function calls in 0.272 seconds

Comments

मुझे लगता है कि यह लूप थोड़ा साफ दिखता है <! - भाषा: अजगर -> def fact (n): ret = 1 जबकि n> 1: n, ret = n - 1, ret * n return ret

— edilio

Answer 10

def factorial(n):
    result = 1
    i = n * (n -1)
    while n >= 1:
        result = result * n
        n = n - 1
    return result

print (factorial(10)) #prints 3628800

Answer 11

यहाँ मेरी कोशिश है

>>> import math
>>> def factorial_verbose(number):
...     for i in range(number):
...             yield f'{i + 1} x '
...
>>> res = ''.join([x for x in factorial_verbose(5)])
>>> res = ' '.join([res[:len(res)-3], '=', str(math.factorial(5))])
>>> res
'1 x 2 x 3 x 4 x 5 = 120'

Comments

@ नीर लेवी, क्या मजेदार बात है

— पेड्रो रॉड्रिक्स

Answer 12

एक पंक्ति, तेज और बड़ी संख्या भी काम करती है:

#use python3.6.x for f-string
fact = lambda x: globals()["x"] if exec(f'x=1\nfor i in range(1, {x+1}):\n\tx*=i', globals()) is None else None

Answer 13

मैं जानता हूं कि इसका उत्तर दिया जा चुका है, लेकिन यहां रिवर्स रेंज लिस्ट कॉम्प्रिहेंशन के साथ एक और तरीका है, जिससे रेंज को पढ़ना और अधिक कॉम्पैक्ट बनाना आसान हो जाता है:

    #   1. Ensure input number is an integer by attempting to cast value to int
    #       1a. To accomplish, we attempt to cast the input value to int() type and catch the TypeError/ValueError 
    #           if the conversion cannot happen because the value type is incorrect
    #   2. Create a list of all numbers from n to 1 to then be multiplied against each other 
    #       using list comprehension and range loop in reverse order from highest number to smallest.
    #   3. Use reduce to walk the list of integers and multiply each against the next.
    #       3a. Here, reduce will call the registered lambda function for each element in the list.
    #           Reduce will execute lambda for the first 2 elements in the list, then the product is
    #           multiplied by the next element in the list, and so-on, until the list ends.

    try :
        num = int( num )
        return reduce( lambda x, y: x * y, [n for n in range(num, 0, -1)] )

    except ( TypeError, ValueError ) :
        raise InvalidInputException ( "Input must be an integer, greater than 0!" )

आप इस gist के भीतर कोड का एक पूर्ण संस्करण देख सकते हैं: https://gist.github.com/sadmicrowave/d4fbefc124eb69027d7a3131526e8c06

Comments

उपयोग करने की आवश्यकता नहीं है [n for n in range(num, 0, -1)], rangeपहले से ही चलने योग्य है।

— मार्क मिशिन

Answer 14

इसे करने का एक और तरीका np.prodनीचे दिखाया गया है:

def factorial(n):
    if n == 0:
        return 1
    else:
         return np.prod(np.arange(1,n+1))

Answer 15

कारख़ाने का एक सकारात्मक पूर्णांक एन, एन द्वारा सूचित किया जाता का !, कम से कम सभी सकारात्मक पूर्णांक उत्पाद है या n के बराबर।

सूत्र :n! = n * (n-1) * (n-2) * (n-3) * (n-4) * ....... * 1

बिलियन फनटेशन / लाइब्रेरी आदि का उपयोग करके अजगर में फैक्टरियल खोजने की कई विधियाँ हैं। यहाँ मैंने फैक्टरियल की मूल परिभाषा के संदर्भ में उपयोगकर्ता-परिभाषित फ़ंक्शन बनाया है।

def factorial(n):
    fact = 1
    for i in range(1,n+1):
        fact = fact * i
    return(fact)

print(factorial(4))

हम recursiveनीचे दिखाए गए अनुसार तकनीक का उपयोग करके फैक्टरियल फ़ंक्शन को भी लागू कर सकते हैं। लेकिन यह विधि केवल छोटे पूर्णांक मानों के लिए कुशल है। क्योंकि पुनरावृत्ति में, फ़ंक्शन को बार-बार कॉल किया जाता है और स्टैक को बनाए रखने के लिए मेमोरी स्पेस की आवश्यकता होती है जो कि फैक्टरियल खोजने के लिए बड़े पूर्णांक मानों के लिए एक कुशल या अनुकूलित दृष्टिकोण नहीं है।

def factorial(n):
    if n == 1:
        return 1
    else:
        return n * factorial(n-1)

print(factorial(4))

Answer 16

def factorial(n):
mul = 1
for i in range( 1, n + 1):
    mul *= i
print(factorial(6))

Comments

यह पूछने के लिए एक और सवाल है कि यह अन्य 17 उत्तरों में क्या जोड़ता है।

— पिपरी

यह उत्तर इस मौजूदा उत्तर का एक डुप्लिकेट है: stackoverflow.com/a/5136481

— karel

Answer 17

नीचे दिए गए कोड में, मैं उस संख्या का इनपुट ले रहा हूं, जिसकी मैं जिस तथ्यात्मक गणना करना चाहता हूं, उसके बाद मैं उस -> संख्या को गुणा कर रहा हूं, जिसकी संख्या को हम 1,2 से शुरू होने वाली संख्याओं के साथ गणना करना चाहते हैं, ...., (संख्या जिसका भाज्य मैं -1 की गणना करना चाहता हूं)

    f = int(input("Enter a number whose factorial you want to calculate = "))#Number 
                                           #whose factorial I want to calculate                              
for i in range(1,f): #assume I have taken f as 5
    f=f*i # In 1st iteration f=5*1 => 5 , in second iteration f = 5*2 => 10, 3rd 
          #iteration f = 10*3 =>30, 4th iteration f = 30*4 =>120  
print(f) #It will print the updated value of "f" i.e 120