Python中的定时算法

我想计算一下我的计算机在一秒钟内能做多少次

计数器+=1

。天真的做法如下：

from time import time

counter = 0
startTime = time()

while time() - startTime < 1:
    counter += 1

print counter

从时间导入时间
计数器=0
开始时间=时间（）
而time（）-startTime<1:
计数器+=1
打印计数器

问题是

time（）-startTime<1

可能比

计数器+=1

昂贵得多

---

有没有一种方法可以让我的算法在1秒内不那么“干净”呢？

给算法计时的通常方法是另一种方法：使用固定的迭代次数，并测量完成它们所需的时间。进行此类计时的最佳方法是模块

---

注意，尽管计时

计数器+=1

似乎毫无意义。你想实现什么？

对算法计时的通常方法是另一种方法：使用固定数量的迭代，并测量完成它们所需的时间。进行此类计时的最佳方法是模块

---

注意，尽管计时

计数器+=1

似乎毫无意义。您想要实现什么？

我从未使用过time（）库，但根据该代码，我假设它是秒数，那么如果在ctrl+C发生后执行/sec计算会怎么样？可能是这样的：

#! /usr/bin/env python

from time import time
import signal
import sys

#The ctrl+C interruption function:
def signal_handler(signal, frame):
    counts_per_sec = counter/(time()-startTime)
    print counts_per_sec
    exit(0)
signal.signal(signal.SIGINT, signal_handler)

counter = 0
startTime = time()
while 1:
    counter = counter + 1

from datetime import datetime

def operation():
    counter = 0
    tbeg = datetime.utcnow()
    for _ in range(10**6):
        counter += 1
    td = datetime.utcnow() - tbeg
    return (td.microseconds + (td.seconds + td.days * 24 * 3600) * 10**6)/10.0**6

def timer(n):
    stack = []
    for _ in range(n):        
        stack.append(operation()) #  units of musec/increment
    print sum(stack) / len(stack)

if __name__ == "__main__":
    timer(10)

---

当然，由于处理的最后一秒与中断信号之间经过的时间不同，它不会精确，但您让脚本运行的时间越长，它就越精确：）

我从未使用过time（）库，但根据该代码，我假设它是秒数，那么，如果在ctrl+C发生后进行每秒计算会怎么样？可能是这样的：

#! /usr/bin/env python

from time import time
import signal
import sys

#The ctrl+C interruption function:
def signal_handler(signal, frame):
    counts_per_sec = counter/(time()-startTime)
    print counts_per_sec
    exit(0)
signal.signal(signal.SIGINT, signal_handler)

counter = 0
startTime = time()
while 1:
    counter = counter + 1

from datetime import datetime

def operation():
    counter = 0
    tbeg = datetime.utcnow()
    for _ in range(10**6):
        counter += 1
    td = datetime.utcnow() - tbeg
    return (td.microseconds + (td.seconds + td.days * 24 * 3600) * 10**6)/10.0**6

def timer(n):
    stack = []
    for _ in range(n):        
        stack.append(operation()) #  units of musec/increment
    print sum(stack) / len(stack)

if __name__ == "__main__":
    timer(10)

---

当然，由于处理的最后一秒和中断信号之间经过的时间不同，它不会精确，但是您让脚本运行的时间越长，它就越精确：）

为什么不推断时间呢？您可以运行以下操作：

#! /usr/bin/env python

from time import time
import signal
import sys

#The ctrl+C interruption function:
def signal_handler(signal, frame):
    counts_per_sec = counter/(time()-startTime)
    print counts_per_sec
    exit(0)
signal.signal(signal.SIGINT, signal_handler)

counter = 0
startTime = time()
while 1:
    counter = counter + 1

from datetime import datetime

def operation():
    counter = 0
    tbeg = datetime.utcnow()
    for _ in range(10**6):
        counter += 1
    td = datetime.utcnow() - tbeg
    return (td.microseconds + (td.seconds + td.days * 24 * 3600) * 10**6)/10.0**6

def timer(n):
    stack = []
    for _ in range(n):        
        stack.append(operation()) #  units of musec/increment
    print sum(stack) / len(stack)

if __name__ == "__main__":
    timer(10)

并获得每个增量的平均运行微秒数；我得到0.09（很可能非常不准确）。现在，这是一个简单的操作来推断，如果我能在0.09微秒内增加一次，那么我能在一秒钟内增加11258992次

---

我认为测量值非常不准确，但可能是一个合理的近似值？

你为什么不推断时间呢？您可以运行以下操作：

#! /usr/bin/env python

from time import time
import signal
import sys

#The ctrl+C interruption function:
def signal_handler(signal, frame):
    counts_per_sec = counter/(time()-startTime)
    print counts_per_sec
    exit(0)
signal.signal(signal.SIGINT, signal_handler)

counter = 0
startTime = time()
while 1:
    counter = counter + 1

from datetime import datetime

def operation():
    counter = 0
    tbeg = datetime.utcnow()
    for _ in range(10**6):
        counter += 1
    td = datetime.utcnow() - tbeg
    return (td.microseconds + (td.seconds + td.days * 24 * 3600) * 10**6)/10.0**6

def timer(n):
    stack = []
    for _ in range(n):        
        stack.append(operation()) #  units of musec/increment
    print sum(stack) / len(stack)

if __name__ == "__main__":
    timer(10)

并获得每个增量的平均运行微秒数；我得到0.09（很可能非常不准确）。现在，这是一个简单的操作来推断，如果我能在0.09微秒内增加一次，那么我能在一秒钟内增加11258992次

我认为测量结果非常不准确，但可能是一个合理的近似值？

以下是我的方法

import time

m = 0
timeout = time.time() + 1 

while True:
    if time.time() > timeout:
        break
    m = m + 1
print(m)

这是我的方法

import time

m = 0
timeout = time.time() + 1 

while True:
    if time.time() > timeout:
        break
    m = m + 1
print(m)

---

是的，我知道。我对我的计算机每秒能处理多少次操作感兴趣，这是一个稍有不同的问题。@Randomblue：“每秒操作”并不是一个定义良好的概念。Python脚本当然不是测试处理器速度的正确方法。@blue如果你真的想用另一种方法来测试，请测量它在一小时内可以完成多少“操作”，然后除以3600。是的，我知道。我对我的计算机每秒能处理多少次操作感兴趣，这是一个稍有不同的问题。@Randomblue：“每秒操作”并不是一个定义良好的概念。Python脚本显然不是测试处理器速度的正确方法。如果你真的想用另一种方法来测试，请测量它在一小时内可以完成多少“操作”，然后除以3600。