成都网站建设公司哪家比较好？

 让我们更好地进行测试，运行每个迭代10000次，并从后者中排除函数定义时间（仅计算运行时）： 
 
>>> import timeit
>>> c1='''
... num = 600851475143
... while num % 2 == 0:
...     num /= 2
... if num == 1:
...     i = 2
... else:
...     i = 3
...     while num > 1:
...         if num % i == 0:
...             num /= i
...         else:
...             i += 2
... '''
>>> timeit.timeit(c1, number=10000)
3.5007779598236084
 
 ......和替代方案： 
 
>>> c2_setup='''
... def lpf(num):
...     while num % 2 == 0:
...         num /= 2
...     if num == 1:
...         return 2
...     else:
...         i = 3
...         while num > 1:
...             if num % i == 0:
...                 num /= i
...             else:
...                 i += 2
...         return i
... '''
>>> c2_run='l = lpf(600851475143)'
>>> timeit.timeit(setup=c2_setup, stmt=c2_run, number=10000)
3.3825008869171143
 
 ......差异要小得多 
 
 
 那么，为什么会有任何差异呢？ 用语言无关的术语来说，更容易优化局部变量的变化; 它们不需要写入一个范围，任何其他可能正在运行或未运行的执行线程都可以访问它们。 在JITted编译器（如PyPi或JVM）中，对locals的更改实际上可能最终被实现为寄存器修改，根本不会转到CPU外部内存。 
 
 CPython没有JIT支持，但@chepner给了我们答案：全局变量的读取使用更昂贵的LOAD_GLOBAL指令，而不是LOAD_FAST可用的LOAD_FAST 。 

Let's do a better job of testing, running 10,000 iterations of each, and excluding the function definition time from the latter (to count only runtime):
 
>>> import timeit
>>> c1='''
... num = 600851475143
... while num % 2 == 0:
...     num /= 2
... if num == 1:
...     i = 2
... else:
...     i = 3
...     while num > 1:
...         if num % i == 0:
...             num /= i
...         else:
...             i += 2
... '''
>>> timeit.timeit(c1, number=10000)
3.5007779598236084
 
...and the alternative:
 
>>> c2_setup='''
... def lpf(num):
...     while num % 2 == 0:
...         num /= 2
...     if num == 1:
...         return 2
...     else:
...         i = 3
...         while num > 1:
...             if num % i == 0:
...                 num /= i
...             else:
...                 i += 2
...         return i
... '''
>>> c2_run='l = lpf(600851475143)'
>>> timeit.timeit(setup=c2_setup, stmt=c2_run, number=10000)
3.3825008869171143
 
...a far smaller difference.
 
 
So, why any difference at all? To put it in language-agnostic terms, it's easier to optimize away changes to local variables; they don't need to be written to a scope where they're accessible by any other threads of execution which may or may not be running. In a JITted compiler (like PyPi or the JVM), changes to locals may actually end up being implemented as register modifications that don't go to off-CPU memory at all.
 
CPython doesn't have JIT support, but @chepner gave us our answer there: Reads from global variables use a more expensive LOAD_GLOBAL instruction, vs the LOAD_FAST available for locals.