blocks|key|505359|text|while+n+<+1:|type|code-block|depth|inlineStyleRanges|entityRanges|data|syntax|javascript|505360|反而应该是|unstyled|505361|while+num+>+1:|505362|entityMap^0|0|0|0^^$0|@$1|2|3|4|5|6|7|K|8|@]|9|@]|A|$B|C]]|$1|D|3|E|5|F|7|L|8|@]|9|@]|A|$]]|$1|G|3|H|5|6|7|M|8|@]|9|@]|A|$B|C]]|$1|I|3|-4|5|F|7|N|8|@]|9|@]|A|$]]]|J|$]]

<pre><code>while n &lt; 1:
</code></pre>

should instead be

<pre><code>while num &gt; 1:
</code></pre>

blocks|key|1802405|text|while+5+<+1始终为false，因此返回result+=+1。这是错误的。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|1802406|entityMap^0|0|B|O|A|0^^$0|@$1|2|3|4|5|6|7|H|8|@$9|I|A|J|B|C]|$9|K|A|L|B|C]]|D|@]|E|$]]|$1|F|3|-4|5|6|7|M|8|@]|D|@]|E|$]]]|G|$]]

<code>while 5 &lt; 1</code> is always false, so <code>result = 1</code> is returned. That's wrong.

blocks|key|1802417|text|让我们看看：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1802418|调用函数时设置n=5。|ordered-list-item|offset|length|style|CODE|1802419|你告诉Python，当n+<+1做事情的时候。|1802420|n已经比1大了，它不会执行while代码。|1802421|您的代码返回result，在定义的第一行中设置为1。|1802422|entityMap^0|0|7|3|0|B|5|0|0|1|4|1|D|5|0|6|6|O|1|0^^$0|@$1|2|3|4|5|6|7|Q|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|R|8|@$E|S|F|T|G|H]]|9|@]|A|$]]|$1|I|3|J|5|D|7|U|8|@$E|V|F|W|G|H]]|9|@]|A|$]]|$1|K|3|L|5|D|7|X|8|@$E|Y|F|Z|G|H]|$E|10|F|11|G|H]|$E|12|F|13|G|H]]|9|@]|A|$]]|$1|M|3|N|5|D|7|14|8|@$E|15|F|16|G|H]|$E|17|F|18|G|H]]|9|@]|A|$]]|$1|O|3|-4|5|6|7|19|8|@]|9|@]|A|$]]]|P|$]]

Let's see:

<ol>
<li>You set <code>n=5</code> when you call the function.</li>
<li>You tell Python that while <code>n &lt; 1</code> do things.</li>
<li><code>n</code> is already bigger than <code>1</code>, it won't execute the <code>while</code> code .</li>
<li>Your code returns <code>result</code>, set to <code>1</code> in the first line of the definition.</li>
</ol>

blocks|key|2319542|text|试试这个，它更干净：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|2319543|def+factorial(+n+):
++++if+n+<=+1:
++++++++return+1;
++++else:
++++++++return+n*factorial(n-1)|code-block|syntax|javascript|2319544|这是一种解决问题的递归方法。|2319545|entityMap^0|0|0|0^^$0|@$1|2|3|4|5|6|7|K|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|L|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|M|8|@]|9|@]|A|$]]|$1|I|3|-4|5|6|7|N|8|@]|9|@]|A|$]]]|J|$]]

Try this, it's cleaner:

<pre><code>def factorial( n ):
 if n &lt;= 1:
 return 1;
 else:
 return n*factorial(n-1)
</code></pre>

This is a recursive way to solve the problem.

blocks|key|2319563|text|您的代码不会进入while循环本身。将其从n<1更改为n>1。例如，如果找到5的阶乘，n<1将被视为5<1，这是假的。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|2319564|entityMap^0|L|3|R|3|0^^$0|@$1|2|3|4|5|6|7|H|8|@$9|I|A|J|B|C]|$9|K|A|L|B|C]]|D|@]|E|$]]|$1|F|3|-4|5|6|7|M|8|@]|D|@]|E|$]]]|G|$]]

Your code will not enter in the while loop itself. Change it from <code>n&lt;1</code> to <code>n&gt;1</code>. If for example, finding factorial of 5, n&lt;1 will be treated as 5&lt;1 which is false.

blocks|key|1802523|text|其他人指出了代码的问题所在，但我想指出的是，factorial函数实际上可以使用更实用的解决方案(如:+functional+)；这避免了完全获得while循环的条件的问题，因为您根本没有任何循环。可以看出，n的阶乘是1..n的乘积，使用reduce函数可以很容易地找到产品。为了避免失去性能，下面是我的Python2.7解释器为您的(固定)代码提供的内容：|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|1802524|python+-m+timeit+-s+"import+original"+"original.factorial(10)"
1000000+loops,+best+of+3:+1.22+usec+per+loop|code-block|syntax|javascript|1802525|较短的版本(单行)更具有声明性是可能的：|1802526|def+factorial(n):
++++return+reduce(lambda+x,y:+x*y,+range(1,+n%2B1))|1802527|...alas，它慢一些：|1802528|python+-m+timeit+-s+"import+func1"+"func1.factorial(10)"
1000000+loops,+best+of+3:+1.98+usec+per+loop|1802529|但是，可以通过使用xrange而不是range和operator.mul来解决这个问题，而不是使用自定义lambda：|1802530|import+operator

def+factorial(n):
++++return+reduce(operator.mul,+xrange(1,+n%2B1))|1802531|对我来说，这比原来的代码还要快：|1802532|python+-m+timeit+-s+"import+func2"+"func2.factorial(10)"
1000000+loops,+best+of+3:+1.14+usec+per+loop|1802533|就我个人而言，为了使代码更加清晰(代价是牺牲一点性能)，我会把reduce调用分解出来：|1802534|import+operator

def+product(it):
++++return+reduce(operator.mul,+it)

def+factorial(n):
++++return+product(xrange(1,+n%2B1))|1802535|我喜欢这个版本是快速的，也是显式的:阶乘被定义为范围的乘积[1..n%2B1[+(即排除n%2B1+))。如果试图计算较大数字的阶乘，则性能差异变得更加明显：|1802536|python+-m+timeit+-s+"import+original"+"original.factorial(30)"
100000+loops,+best+of+3:+5.25+usec+per+loop|1802537|与|1802538|python+-m+timeit+-s+"import+func3"+"func3.factorial(30)"
100000+loops,+best+of+3:+3.96+usec+per+loop|1802539|entityMap^0|M|9|21|5|2W|1|31|4|3B|6|0|0|0|0|0|0|9|6|I|5|O|C|0|0|0|0|V|6|0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|1E|8|@$9|1F|A|1G|B|C]|$9|1H|A|1I|B|C]|$9|1J|A|1K|B|C]|$9|1L|A|1M|B|C]|$9|1N|A|1O|B|C]]|D|@]|E|$]]|$1|F|3|G|5|H|7|1P|8|@]|D|@]|E|$I|J]]|$1|K|3|L|5|6|7|1Q|8|@]|D|@]|E|$]]|$1|M|3|N|5|H|7|1R|8|@]|D|@]|E|$I|J]]|$1|O|3|P|5|6|7|1S|8|@]|D|@]|E|$]]|$1|Q|3|R|5|H|7|1T|8|@]|D|@]|E|$I|J]]|$1|S|3|T|5|6|7|1U|8|@$9|1V|A|1W|B|C]|$9|1X|A|1Y|B|C]|$9|1Z|A|20|B|C]]|D|@]|E|$]]|$1|U|3|V|5|H|7|21|8|@]|D|@]|E|$I|J]]|$1|W|3|X|5|6|7|22|8|@]|D|@]|E|$]]|$1|Y|3|Z|5|H|7|23|8|@]|D|@]|E|$I|J]]|$1|10|3|11|5|6|7|24|8|@$9|25|A|26|B|C]]|D|@]|E|$]]|$1|12|3|13|5|H|7|27|8|@]|D|@]|E|$I|J]]|$1|14|3|15|5|6|7|28|8|@]|D|@]|E|$]]|$1|16|3|17|5|H|7|29|8|@]|D|@]|E|$I|J]]|$1|18|3|19|5|6|7|2A|8|@]|D|@]|E|$]]|$1|1A|3|1B|5|H|7|2B|8|@]|D|@]|E|$I|J]]|$1|1C|3|-4|5|6|7|2C|8|@]|D|@]|E|$]]]|1D|$]]

Others pointed out what's wrong with your code, but I wanted to point out that a <code>factorial</code> function really lends itself to a more functional (as in: functional programming) solution; this avoids the issue with getting the condition for the <code>while</code> loop altogether because you don't have any loop at all. The insight is that the factorial of <code>n</code> is the product of <code>1..n</code>, and the product can be defind very easily using Python's <code>reduce</code> function. To avoid losing performance out of sight, here's what my Python 2.7 interpreter gives for your (fixed) code:

<pre><code>python -m timeit -s "import original" "original.factorial(10)"
1000000 loops, best of 3: 1.22 usec per loop
</code></pre>

A shorter version (a one-liner) which is more declarative is possible:

<pre><code>def factorial(n):
 return reduce(lambda x,y: x*y, range(1, n+1))
</code></pre>

...alas, it's slower:

<pre><code>python -m timeit -s "import func1" "func1.factorial(10)"
1000000 loops, best of 3: 1.98 usec per loop
</code></pre>

However, this can be solved by using <code>xrange</code> instead of <code>range</code> and <code>operator.mul</code> instead of a custom lambda:

<pre><code>import operator

def factorial(n):
 return reduce(operator.mul, xrange(1, n+1))
</code></pre>

And for me, this is even faster than the original code:

<pre><code>python -m timeit -s "import func2" "func2.factorial(10)"
1000000 loops, best of 3: 1.14 usec per loop
</code></pre>

Personally, I'd factor out the <code>reduce</code> call to make the code even clearer (at the expense of a tiny little bit of performance):

<pre><code>import operator

def product(it):
 return reduce(operator.mul, it)

def factorial(n):
 return product(xrange(1, n+1))
</code></pre>

I like this version for being fast, and for being explicit: the factorial is defined to be the product of the range [1..n+1[ (i.e. n+1 is excluded). The performance difference becomes more apparent if you try to compute the factorial of larger numbers:

<pre><code>python -m timeit -s "import original" "original.factorial(30)"
100000 loops, best of 3: 5.25 usec per loop
</code></pre>

vs.

<pre><code>python -m timeit -s "import func3" "func3.factorial(30)"
100000 loops, best of 3: 3.96 usec per loop
</code></pre>

blocks|key|1802555|text|说到短Pythonic码|type|unstyled|depth|inlineStyleRanges|offset|length|style|BOLD|entityRanges|data|1802556|def+factorial(n):
++++return+reduce(lambda+res,+val:+res*val,+xrange(n,+0,+-1),+1)|code-block|syntax|javascript|1802557|对于那些不了解火山的代码是如何工作的人，下面是一个近似值：|1802558|'''+Equivalent+code+by+PM+2Ring+'''

def+f(res,+val):
++++return+res+*+val

def+factorial(n):
++++res+=+1
++++for+val+in+xrange(n,+0,+-1):
++++++++res+=+f(res,+val)
++++return+res|1802559|entityMap^0|3|8|0|0|0|0^^$0|@$1|2|3|4|5|6|7|Q|8|@$9|R|A|S|B|C]]|D|@]|E|$]]|$1|F|3|G|5|H|7|T|8|@]|D|@]|E|$I|J]]|$1|K|3|L|5|6|7|U|8|@]|D|@]|E|$]]|$1|M|3|N|5|H|7|V|8|@]|D|@]|E|$I|J]]|$1|O|3|-4|5|6|7|W|8|@]|D|@]|E|$]]]|P|$]]

Speaking of short Pythonic code

<pre><code>def factorial(n):
 return reduce(lambda res, val: res*val, xrange(n, 0, -1), 1)
</code></pre>

<hr>

For those that don't understand how volcano's code works, here is a close approximation:

<pre><code>''' Equivalent code by PM 2Ring '''

def f(res, val):
 return res * val

def factorial(n):
 res = 1
 for val in xrange(n, 0, -1):
 res = f(res, val)
 return res
</code></pre>

blocks|key|505540|text|def+factorial(n):
++++result+=+1
++++while+n+>+1:
++++++++result+=+result+*+n
++++++++n+=+n+-+1
++++return+result

print+factorial(5)
120|type|code-block|depth|inlineStyleRanges|entityRanges|data|syntax|javascript|505541|unstyled|entityMap^0|0^^$0|@$1|2|3|4|5|6|7|G|8|@]|9|@]|A|$B|C]]|$1|D|3|-4|5|E|7|H|8|@]|9|@]|A|$]]]|F|$]]

<pre><code>def factorial(n):
 result = 1
 while n &gt; 1:
 result = result * n
 n = n - 1
 return result

print factorial(5)
120
</code></pre>

blocks|key|1802625|text|正如Simon所解释的，您的代码|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1802626|while+n+<+1:|offset|length|style|CODE|1802627|而不是|1802628|while+num+>+1:|1802629|因此，您有小于而不是大于，因此while语句中的测试将立即失败。但是，如果您将其更改为while+n+>+1:，它将永远循环，因为您从未在while循环中更改过n的值。|1802630|Haresh+Shyara发布了您的代码的更正版本，转载于此：|1802631|def+factorial(n):
++++result+=+1
++++while+n+>+1:
++++++++result+=+result+*+n
++++++++n+=+n+-+1
++++return+result|code-block|syntax|javascript|1802632|请注意，这段代码不需要将n复制到num+--它只是直接使用n。这不会影响调用函数的参数，因为|1802633|Python整数是不可变的，|ordered-list-item|1802634|n+=+n+-+1实际上创建了一个名为n的新本地对象。|1802635|我的灵感来自Frerich+Raabe的回答，他写了一个程序，以更系统的方式完成这里提供的各种解决方案的时间安排。我还包括了math.factorial()和一个简单的基于for循环的函数。|1802636|我通过定义operator.mul对调用mul+=+operator.mul的函数进行了优化，但是我必须向那些使用reduce()的函数提供一个1的initial参数，这样它们就不会在factorial(0)上失败(应该返回1)。|1802637|我已经大致订购了从最快到最慢的函数。|1802638|我刚刚对这个程序进行了增强，使运行多个测试和为测试添加新功能变得更加容易。另外，它现在使用函数的docstring打印每个函数的简短描述。在运行定时测试之前，它将验证每个函数是否计算出正确的值。|1802639|#!/usr/bin/env+python

'''+Test+and+time+various+implementations+of+the+factorial+function

++++From+https://stackoverflow.com/q/28475637/4014959

++++Written+by+PM+2Ring+2015.02.13
'''

import+operator
import+math
from+timeit+import+Timer

factorial0+=+math.factorial

def+factorial0a(n):
++++'''+call+math.factorial+'''
++++return+math.factorial(n)

def+factorial1(n):
++++'''+for+loop'''
++++p+=+1
++++for+i+in+xrange(2,+n%2B1):
++++++++p+*=+i
++++return+p

mul+=+operator.mul

def+product(it):
++++return+reduce(mul,+it,+1)

def+factorial2(n):
++++'''+reduce+with+op.mul+'''
++++return+reduce(mul,+xrange(1,+n%2B1),+1)

def+factorial3(n):
++++'''+call+product()+'''
++++return+product(xrange(1,+n%2B1))++++

def+factorial4(n):
++++'''+while+loop+'''
++++result+=+1
++++while+n+>+1:
++++++++result+=+result+*+n
++++++++n+=+n+-+1
++++return+result

def+factorial4a(n):
++++'''+while+loop+with+assignment+operators+'''
++++result+=+1
++++while+n+>+1:
++++++++result+*=+n
++++++++n+-=+1
++++return+result

def+factorial5(n):
++++'''+recursive+'''
++++if+n+<=+1:
++++++++return+1;
++++else:
++++++++return+n*factorial5(n-1)

def+factorial6(n):
++++'''+reduce+with+lambda+'''
++++return+reduce(lambda+res,+val:+res*val,+xrange(n,+0,+-1),+1)

funcs+=+(
++++factorial0,
++++factorial0a,
++++factorial1,
++++factorial2,
++++factorial3,
++++factorial4,
++++factorial4a,
++++factorial5,
++++factorial6,
)

def+verify(n):
++++'''+Check+that+each+function+calculates+the+same+result+as+math.factorial+'''
++++r+=+xrange(n)
++++fac+=+[factorial0(i)+for+i+in+r]
++++rc+=+True
++++for+func+in+funcs[1:]:
++++++++for+i+in+r:
++++++++++++v+=+func(i)
++++++++++++if+v+!=+fac[i]:
++++++++++++++++print+'Error:+%25s(%25d)+returns+%25d+instead+of+%25d'+%25+(func.func_name,+i,+v,+fac[i])
++++++++++++++++rc+=+False
++++return+rc

def+time_test(arg=10,+loops=100000,+reps=3):
++++'''+Print+timing+stats+for+all+the+factorial+functions+'''
++++print+'Arg+=+%25d,+Loops+=+%25d,+Repetitions+=+%25d'+%25+(arg,+loops,+reps)

++++for+func+in+funcs:
++++++++#Get+function+name+and+docstring
++++++++try:
++++++++++++fname+=+func.func_name
++++++++++++fdoc+=+func.__doc__
++++++++except+AttributeError:
++++++++++++#Math.factorial+has+no+name,+and+we+can't+modify+its+docstring
++++++++++++fname+=+'factorial0'
++++++++++++fdoc+=+'+math.factorial+itself+'

++++++++print+'\n%25s:%25s'+%25+(fname,+fdoc)
++++++++t+=+Timer('%25s(%25d)'+%25+(fname,+arg),+'from+__main__+import+%25s'+%25+fname)
++++++++r+=+t.repeat(reps,+loops)
++++++++r.sort()
++++++++print+r
++++print+'\n'

def+main():
++++if+not+verify(100):+exit(1)
++++time_test(arg=5,+loops=500000,+reps=4)
++++time_test(arg=10,+loops=200000,+reps=4)
++++time_test(arg=50,+loops=100000,+reps=4)

if+__name__+==+'__main__':
++++main()|1802640|输出|BOLD|1802641|Arg+=+5,+Loops+=+500000,+Repetitions+=+4

factorial0:+math.factorial+itself+
[0.30838108062744141,+0.3119349479675293,+0.31210899353027344,+0.32166290283203125]

factorial0a:+call+math.factorial+
[0.62141299247741699,+0.62747406959533691,+0.63309717178344727,+0.66500306129455566]

factorial1:+for+loop
[1.4656128883361816,+1.476855993270874,+1.4897668361663818,+1.5052030086517334]

factorial2:+reduce+with+op.mul+
[1.5841941833496094,+1.5868480205535889,+1.6007061004638672,+1.6253509521484375]

factorial3:+call+product()+
[1.8745129108428955,+1.8750350475311279,+1.8822829723358154,+1.9097139835357666]

factorial4:+while+loop+
[1.1264691352844238,+1.1348199844360352,+1.1348659992218018,+1.178135871887207]

factorial4a:+while+loop+with+assignment+operators+
[1.1867551803588867,+1.1881229877471924,+1.1893219947814941,+1.2020411491394043]

factorial5:+recursive+
[1.9756920337677002,+1.9862890243530273,+1.9910380840301514,+2.0284240245819092]

factorial6:+reduce+with+lambda+
[2.8342490196228027,+2.8369259834289551,+2.8390510082244873,+2.8969988822937012]


Arg+=+10,+Loops+=+200000,+Repetitions+=+4

factorial0:+math.factorial+itself+
[0.24756813049316406,+0.24919605255126953,+0.26395106315612793,+0.28582406044006348]

factorial0a:+call+math.factorial+
[0.3732609748840332,+0.37482404708862305,+0.37592387199401855,+0.38288402557373047]

factorial1:+for+loop
[0.88677501678466797,+0.89632201194763184,+0.89948821067810059,+0.90272784233093262]

factorial2:+reduce+with+op.mul+
[0.89040708541870117,+0.89259791374206543,+0.89863204956054688,+0.90652203559875488]

factorial3:+call+product()+
[1.0093960762023926,+1.031667947769165,+1.2325050830841064,+1.7492170333862305]

factorial4:+while+loop+
[0.93423891067504883,+0.93978404998779297,+0.94000387191772461,+0.95153117179870605]

factorial4a:+while+loop+with+assignment+operators+
[0.97296595573425293,+0.97462797164916992,+0.98288702964782715,+1.0095341205596924]

factorial5:+recursive+
[1.6726200580596924,+1.6786048412322998,+1.691572904586792,+1.6946439743041992]

factorial6:+reduce+with+lambda+
[1.8484599590301514,+1.8502249717712402,+1.8615908622741699,+1.9228360652923584]


Arg+=+50,+Loops+=+100000,+Repetitions+=+4

factorial0:+math.factorial+itself+
[1.6450450420379639,+1.6641650199890137,+1.6790158748626709,+1.7192811965942383]

factorial0a:+call+math.factorial+
[1.7563199996948242,+2.0039281845092773,+2.1530590057373047,+2.3621060848236084]

factorial1:+for+loop
[2.7895750999450684,+2.8117640018463135,+2.8381040096282959,+3.0019519329071045]

factorial2:+reduce+with+op.mul+
[2.4697721004486084,+2.4750289916992188,+2.4813871383666992,+2.5051541328430176]

factorial3:+call+product()+
[2.4983038902282715,+2.4994339942932129,+2.5271379947662354,+2.5356400012969971]

factorial4:+while+loop+
[3.6446011066436768,+3.650169849395752,+3.6579680442810059,+3.7304909229278564]

factorial4a:+while+loop+with+assignment+operators+
[3.7421870231628418,+3.7477319240570068,+3.7655398845672607,+3.7749569416046143]

factorial5:+recursive+
[5.523845911026001,+5.5555410385131836,+5.5760359764099121,+6.2132260799407959]

factorial6:+reduce+with+lambda+
[4.9984982013702393,+5.0106558799743652,+5.0363597869873047,+5.0808289051055908]|1802642|与所有的timeit结果一样，每个列表中最快的条目是重要的条目，慢的条目应该被忽略。|1802643|来自timeit文档+(由菲菲吉德提供)：|1802644|..。最低值为机器运行给定代码段的速度提供了一个下限；结果向量中较高的值通常不是由Python速度的变异性造成的，而是由其他进程干扰您的计时精度造成的。所以结果的min()可能是你唯一感兴趣的数字.|blockquote|1802645|entityMap|0|LINK|mutability|MUTABLE|url|https://docs.python.org/3.4/library/timeit.html#timeit.Timer.repeat|1|https://stackoverflow.com/users/3005188/ffisegydd^0|0|0|C|0|0|0|E|0|F|5|17|C|1X|5|28|1|0|0|0|C|1|G|3|T|1|0|0|0|9|J|1|0|1Q|G|2E|3|0|5|C|K|I|1L|8|22|7|2K|C|0|0|0|0|0|2|0|0|4|6|0|2|8|0|D|4|1|0|29|5|0^^$0|@$1|2|3|4|5|6|7|1X|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|1Y|8|@$D|1Z|E|20|F|G]]|9|@]|A|$]]|$1|H|3|I|5|6|7|21|8|@]|9|@]|A|$]]|$1|J|3|K|5|6|7|22|8|@$D|23|E|24|F|G]]|9|@]|A|$]]|$1|L|3|M|5|6|7|25|8|@$D|26|E|27|F|G]|$D|28|E|29|F|G]|$D|2A|E|2B|F|G]|$D|2C|E|2D|F|G]]|9|@]|A|$]]|$1|N|3|O|5|6|7|2E|8|@]|9|@]|A|$]]|$1|P|3|Q|5|R|7|2F|8|@]|9|@]|A|$S|T]]|$1|U|3|V|5|6|7|2G|8|@$D|2H|E|2I|F|G]|$D|2J|E|2K|F|G]|$D|2L|E|2M|F|G]]|9|@]|A|$]]|$1|W|3|X|5|Y|7|2N|8|@]|9|@]|A|$]]|$1|Z|3|10|5|Y|7|2O|8|@$D|2P|E|2Q|F|G]|$D|2R|E|2S|F|G]]|9|@]|A|$]]|$1|11|3|12|5|6|7|2T|8|@$D|2U|E|2V|F|G]|$D|2W|E|2X|F|G]]|9|@]|A|$]]|$1|13|3|14|5|6|7|2Y|8|@$D|2Z|E|30|F|G]|$D|31|E|32|F|G]|$D|33|E|34|F|G]|$D|35|E|36|F|G]|$D|37|E|38|F|G]]|9|@]|A|$]]|$1|15|3|16|5|6|7|39|8|@]|9|@]|A|$]]|$1|17|3|18|5|6|7|3A|8|@]|9|@]|A|$]]|$1|19|3|1A|5|R|7|3B|8|@]|9|@]|A|$S|T]]|$1|1B|3|1C|5|6|7|3C|8|@$D|3D|E|3E|F|1D]]|9|@]|A|$]]|$1|1E|3|1F|5|R|7|3F|8|@]|9|@]|A|$S|T]]|$1|1G|3|1H|5|6|7|3G|8|@$D|3H|E|3I|F|G]]|9|@]|A|$]]|$1|1I|3|1J|5|6|7|3J|8|@]|9|@$D|3K|E|3L|1|3M]|$D|3N|E|3O|1|3P]]|A|$]]|$1|1K|3|1L|5|1M|7|3Q|8|@$D|3R|E|3S|F|G]]|9|@]|A|$]]|$1|1N|3|-4|5|6|7|3T|8|@]|9|@]|A|$]]]|1O|$1P|$5|1Q|1R|1S|A|$1T|1U]]|1V|$5|1Q|1R|1S|A|$1T|1W]]]]

As Simon Gibbons explained, your code has

<code>while n &lt; 1:</code>

instead of

<code>while num &gt; 1:</code>

So you have less than instead of greater than, thus the test in your <code>while</code> statement will fail immediately. However, if you changed it to <code>while n &gt; 1:</code> it would loop forever, since you never change the value of <code>n</code> inside the <code>while</code> loop.

Haresh Shyara posted a corrected version of your code, reproduced here:

<pre><code>def factorial(n):
 result = 1
 while n &gt; 1:
 result = result * n
 n = n - 1
 return result
</code></pre>

Note that this code doesn't bother with copying <code>n</code> to <code>num</code> - it just uses <code>n</code> directly. This will not affect the argument that you call the function with because 

<ol>
<li>Python integers are immutable and </li>
<li><code>n = n - 1</code> actually creates a new local object named <code>n</code>.</li>
</ol>

<hr>

I was inspired by Frerich Raabe's answer to write a program to do the timings of the various solutions offered here in a more systematic fashion. I've also included the <code>math.factorial()</code> and a simple <code>for</code> loop based function I just threw together.

I've optimized the functions that call <code>operator.mul</code> slightly by defining <code>mul = operator.mul</code>, but I had to supply an <code>initial</code> parameter of 1 to those functions that use <code>reduce()</code> so that they don't fail on <code>factorial(0)</code> (which should return 1).

I've approximately ordered the functions from fastest to slowest. 

I've just enhanced this program to make it a little easier to run multiple tests and to add new functions to test. Also, it now prints a brief description of each function, using the function's docstring. And before running the timing tests it verifies that each function calculates correct values.

<pre><code>#!/usr/bin/env python

''' Test and time various implementations of the factorial function

 From https://stackoverflow.com/q/28475637/4014959

 Written by PM 2Ring 2015.02.13
'''

import operator
import math
from timeit import Timer

factorial0 = math.factorial

def factorial0a(n):
 ''' call math.factorial '''
 return math.factorial(n)

def factorial1(n):
 ''' for loop'''
 p = 1
 for i in xrange(2, n+1):
 p *= i
 return p

mul = operator.mul

def product(it):
 return reduce(mul, it, 1)

def factorial2(n):
 ''' reduce with op.mul '''
 return reduce(mul, xrange(1, n+1), 1)

def factorial3(n):
 ''' call product() '''
 return product(xrange(1, n+1)) 

def factorial4(n):
 ''' while loop '''
 result = 1
 while n &gt; 1:
 result = result * n
 n = n - 1
 return result

def factorial4a(n):
 ''' while loop with assignment operators '''
 result = 1
 while n &gt; 1:
 result *= n
 n -= 1
 return result

def factorial5(n):
 ''' recursive '''
 if n &lt;= 1:
 return 1;
 else:
 return n*factorial5(n-1)

def factorial6(n):
 ''' reduce with lambda '''
 return reduce(lambda res, val: res*val, xrange(n, 0, -1), 1)

funcs = (
 factorial0,
 factorial0a,
 factorial1,
 factorial2,
 factorial3,
 factorial4,
 factorial4a,
 factorial5,
 factorial6,
)

def verify(n):
 ''' Check that each function calculates the same result as math.factorial '''
 r = xrange(n)
 fac = [factorial0(i) for i in r]
 rc = True
 for func in funcs[1:]:
 for i in r:
 v = func(i)
 if v != fac[i]:
 print 'Error: %s(%d) returns %d instead of %d' % (func.func_name, i, v, fac[i])
 rc = False
 return rc

def time_test(arg=10, loops=100000, reps=3):
 ''' Print timing stats for all the factorial functions '''
 print 'Arg = %d, Loops = %d, Repetitions = %d' % (arg, loops, reps)

 for func in funcs:
 #Get function name and docstring
 try:
 fname = func.func_name
 fdoc = func.__doc__
 except AttributeError:
 #Math.factorial has no name, and we can't modify its docstring
 fname = 'factorial0'
 fdoc = ' math.factorial itself '

 print '\n%s:%s' % (fname, fdoc)
 t = Timer('%s(%d)' % (fname, arg), 'from __main__ import %s' % fname)
 r = t.repeat(reps, loops)
 r.sort()
 print r
 print '\n'

def main():
 if not verify(100): exit(1)
 time_test(arg=5, loops=500000, reps=4)
 time_test(arg=10, loops=200000, reps=4)
 time_test(arg=50, loops=100000, reps=4)

if __name__ == '__main__':
 main()
</code></pre>

output

<pre><code>Arg = 5, Loops = 500000, Repetitions = 4

factorial0: math.factorial itself 
[0.30838108062744141, 0.3119349479675293, 0.31210899353027344, 0.32166290283203125]

factorial0a: call math.factorial 
[0.62141299247741699, 0.62747406959533691, 0.63309717178344727, 0.66500306129455566]

factorial1: for loop
[1.4656128883361816, 1.476855993270874, 1.4897668361663818, 1.5052030086517334]

factorial2: reduce with op.mul 
[1.5841941833496094, 1.5868480205535889, 1.6007061004638672, 1.6253509521484375]

factorial3: call product() 
[1.8745129108428955, 1.8750350475311279, 1.8822829723358154, 1.9097139835357666]

factorial4: while loop 
[1.1264691352844238, 1.1348199844360352, 1.1348659992218018, 1.178135871887207]

factorial4a: while loop with assignment operators 
[1.1867551803588867, 1.1881229877471924, 1.1893219947814941, 1.2020411491394043]

factorial5: recursive 
[1.9756920337677002, 1.9862890243530273, 1.9910380840301514, 2.0284240245819092]

factorial6: reduce with lambda 
[2.8342490196228027, 2.8369259834289551, 2.8390510082244873, 2.8969988822937012]


Arg = 10, Loops = 200000, Repetitions = 4

factorial0: math.factorial itself 
[0.24756813049316406, 0.24919605255126953, 0.26395106315612793, 0.28582406044006348]

factorial0a: call math.factorial 
[0.3732609748840332, 0.37482404708862305, 0.37592387199401855, 0.38288402557373047]

factorial1: for loop
[0.88677501678466797, 0.89632201194763184, 0.89948821067810059, 0.90272784233093262]

factorial2: reduce with op.mul 
[0.89040708541870117, 0.89259791374206543, 0.89863204956054688, 0.90652203559875488]

factorial3: call product() 
[1.0093960762023926, 1.031667947769165, 1.2325050830841064, 1.7492170333862305]

factorial4: while loop 
[0.93423891067504883, 0.93978404998779297, 0.94000387191772461, 0.95153117179870605]

factorial4a: while loop with assignment operators 
[0.97296595573425293, 0.97462797164916992, 0.98288702964782715, 1.0095341205596924]

factorial5: recursive 
[1.6726200580596924, 1.6786048412322998, 1.691572904586792, 1.6946439743041992]

factorial6: reduce with lambda 
[1.8484599590301514, 1.8502249717712402, 1.8615908622741699, 1.9228360652923584]


Arg = 50, Loops = 100000, Repetitions = 4

factorial0: math.factorial itself 
[1.6450450420379639, 1.6641650199890137, 1.6790158748626709, 1.7192811965942383]

factorial0a: call math.factorial 
[1.7563199996948242, 2.0039281845092773, 2.1530590057373047, 2.3621060848236084]

factorial1: for loop
[2.7895750999450684, 2.8117640018463135, 2.8381040096282959, 3.0019519329071045]

factorial2: reduce with op.mul 
[2.4697721004486084, 2.4750289916992188, 2.4813871383666992, 2.5051541328430176]

factorial3: call product() 
[2.4983038902282715, 2.4994339942932129, 2.5271379947662354, 2.5356400012969971]

factorial4: while loop 
[3.6446011066436768, 3.650169849395752, 3.6579680442810059, 3.7304909229278564]

factorial4a: while loop with assignment operators 
[3.7421870231628418, 3.7477319240570068, 3.7655398845672607, 3.7749569416046143]

factorial5: recursive 
[5.523845911026001, 5.5555410385131836, 5.5760359764099121, 6.2132260799407959]

factorial6: reduce with lambda 
[4.9984982013702393, 5.0106558799743652, 5.0363597869873047, 5.0808289051055908]
</code></pre>

As with all <code>timeit</code> results, the fastest entries in each list are the significant ones, the slower ones should be ignored. 

From the <a href="https://docs.python.org/3.4/library/timeit.html#timeit.Timer.repeat" rel="nofollow noreferrer">timeit docs</a> (courtesy of <a href="https://stackoverflow.com/users/3005188/ffisegydd">Ffisegydd</a>):

<blockquote>
 ... the lowest value gives a lower bound for how fast your machine can
 run the given code snippet; higher values in the result vector are
 typically not caused by variability in Python’s speed, but by other
 processes interfering with your timing accuracy. So the <code>min()</code> of the
 result is probably the only number you should be interested in...
</blockquote>

I have the following code for calculating the factorial of a number in python. but I couldnt understand why I am getting the answer as 1. 
can some one correct my code. I want to calculate the factorial without using recursion. 

<pre><code>def factorial (n):
 result =1 
 num = n
 while n&lt;1:
 result = result * num
 num = num -1
 return result

 factorial(5)
 1
</code></pre>

what is wrong with my factorial code in python

翻译质量差，导致语言生硬或混乱。

没有提供实际的解决方法或示例。

解答不清晰，无法理解或解决问题。

页面排版不美观，阅读体验差。

文章

问答

视频

学习中心

腾讯云实验室

直播

竞赛

腾讯云代码分析专区

腾讯iOA零信任安全管理系统专区

腾讯云架构师技术同盟交流圈

腾讯云数据库专区

腾讯云顾问专区

腾讯云原生专区

腾讯混元专区

腾讯云TCE专区

腾讯云Lighthouse专区

腾讯云HAI专区

腾讯云Edgeone专区

腾讯云存储专区

腾讯云智能专区

腾讯轻联专区 

腾讯云开发专区

TAPD专区

腾讯轻量云游戏服专区

腾讯云最具价值专家

腾讯云架构师技术同盟

腾讯云创作之星

腾讯云开发者先锋

腾讯云代码助手

云原生构建

TAPD 敏捷项目管理

Cloud Studio

SDK中心

API中心

命令行工具

涵盖代码开发、场景应用、自动测试全流程，助你从零构建专属AI助手

一站式MCP教程库，解锁AI应用新玩法

下面的代码用于计算python中一个数字的阶乘。但我不明白为什么我得到的答案是1.有人能纠正我的代码吗？我想不使用递归计算阶乘。def factorial (n): result =1 num = n while n<1: result = result...

问我在python中的阶乘代码有什么问题？
EN

社区

活动

圈层

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问我在python中的阶乘代码有什么问题？EN

社区

活动

圈层

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问我在python中的阶乘代码有什么问题？
EN