from the desk of stinkpot

one line factorial in python

March 8th, 2007 by Lawrence David

here’s a compact way of calculating factorials in python. in fact, since this method doesn’t rely on for or while loops and their ancillary overhead, it might be one of the faster ways of calculating a factorial.

let’s say you’d like to calculate k!

>>> reduce(lambda i,j : i*j, range(1,k+1))

Posted in Uncategorized | 11 Comments »

if that was helpful ...

check out the other tips and tricks i've compiled on these pages. you might learn something else interesting!

11 Responses to “one line factorial in python”

1. on 15 Mar 2007 at 8:31 pm   Rickard Sandberg

   think you got a typo in the formula:
   the i in the range function should be one?

   reduce(lambda i,j : i*j, range(1,k+1))

2. on 15 Mar 2007 at 8:34 pm   Lawrence David

   thanks rickard – you were right about the typo!

3. on 08 Oct 2008 at 12:56 am   ploden

   Very nice! Just be aware that this doesn’t work for k=0.

4. on 16 Feb 2009 at 10:59 am   Nick_Greece

   Very nice and elegant!!!

5. on 23 Feb 2009 at 10:10 pm   Saprophyte

   Very cool one liner Lawrence. I just wanted to note that it can be easily made to work for the k=0 case by the following modification:

   reduce(lambda i,j: i*j, range(1,k+1),1)

6. on 04 Apr 2009 at 1:01 am   Rich

   You don’t need to lambda-define multiplication. How about reduce(int.__mul__, range(1, k+1))?

7. on 24 Aug 2009 at 6:47 pm   Arkapravo

   Rich ! ….. you are cool ! …. no lambda ….. keep it as python is to be done …. int._mul_ ….

   The correct function is ….

   >>>reduce(int.__mul__, range(1, k+1),1)

8. on 14 Sep 2009 at 10:57 pm   Manas Shaikh

   Yeah, that helped. Thanks!

9. on 15 Sep 2009 at 9:40 am   Yiannis Tsiouris

   By changing range(…) with xrange(…), ie:

   >>> reduce(int.__mul__, xrange(1, k+1), 1)

   someone can accomplish even (slightly) better performance code as far as looping and memory efficiency is concerned (see help(xrange) for details).

   Another “fix” would be to use the mul function from the operator module (import operator) so as not to have problems with the factorial of “big numbers”:

   >>>import operator
   >>> reduce(operator.mul, xrange(1, k+1))

   Here are some measures trying to compute 60! using timeit module:

   In [74]: timeit.Timer(‘reduce(lambda i,j: i*j, range(1, 61))’).timeit(number=100000)
   Out[74]: 2.4469389915466309

   In [75]: timeit.Timer(‘reduce(lambda i,j: i*j, xrange(1, 61))’).timeit(number=100000)
   Out[75]: 2.3416600227355957

   In [76]: timeit.Timer(‘import operator; reduce(operator.mul, xrange(1, 61))’).timeit(number=100000)
   Out[76]: 1.5750751495361328

10. on 11 Jan 2012 at 6:18 pm   Willem Wardenaar

    Why spend time on multiplying with one?

    So I would use:
    reduce(int.__mul__, xrange(2, k+1), 1)

    I actually are using:

    from operator import mul
    fact = lambda k: reduce( mul, range( 2, k + 1 ), 1 )
    fact( 61 )

11. on 11 Jan 2012 at 6:28 pm   Willem Wardenaar

    Can anybody change the line “I actually are using:” into “I am actually using:” in my previous entry and remove this entry?