显示python sleep函数的倒计时

Question

我在程序中使用 time.sleep(10) 。当我运行程序时可以在 shell 中显示倒计时吗？

>>>run_my_program()
tasks done, now sleeping for 10 seconds

然后我希望它执行 10,9,8,7....

这可能吗？

Answer 1

你总是可以做

#do some stuff
print 'tasks done, now sleeping for 10 seconds'
for i in xrange(10,0,-1):
    time.sleep(1)
    print i

此代码片段有一个有点烦人的功能，即每个数字都会在换行符上打印出来。 为了避免这种情况，你可以

import sys
import time
for i in xrange(10,0,-1):
    sys.stdout.write(str(i)+' ')
    sys.stdout.flush()
    time.sleep(1)

Answer 2

这是在 Python 3.x 的控制台中显示计时器的最佳方式：

import time
import sys

for remaining in range(10, 0, -1):
    sys.stdout.write("\r")
    sys.stdout.write("{:2d} seconds remaining.".format(remaining))
    sys.stdout.flush()
    time.sleep(1)

sys.stdout.write("\rComplete!            \n")

这会在每个周期覆盖前一行。

Answer 3

一个简单的解决方案，从控制台清除最后一个数字：

import time

for i in range(10,0,-1):
    print(f"{i}", end="\r", flush=True)
    time.sleep(1)

默认情况下，打印函数设置

end="\n"

，这意味着后续对 print 的调用将打印在新行上。您可以将其更改为

end="\r"

以在每次调用后替换输出。 （如何回车” “在Python中工作）。

这里

f"{i}"

仅用于打印个位数。您可以根据位数进行修改。 例如在这里，只需添加一个空格作为后缀即可用于两位数 -

f"{i} "

此外，使用

flush

意味着您不必担心缓冲问题。 （print() 的

flush

是做什么的？）

这就是它的样子：

Answer 4

您可以执行倒计时功能，例如：

import sys
import time

def countdown(t, step=1, msg='sleeping'):  # in seconds
    pad_str = ' ' * len('%d' % step)
    for i in range(t, 0, -step):
        print '%s for the next %d seconds %s\r' % (msg, i, pad_str),
        sys.stdout.flush()
        time.sleep(step)
    print 'Done %s for %d seconds!  %s' % (msg, t, pad_str)

回车符

\r

和逗号

,

将使打印保持在同一行（避免每个倒计时值占一行）

随着秒数的减少，pad_str 将确保最后一行被空格覆盖，而不是随着输出的缩短而留下最后一个字符。

最终打印用完成消息覆盖最后一个状态消息并增加输出行，因此有延迟的证据。

Answer 5

这是我在第一堂Python课程中学到的东西，我们玩过[“/”，“-”，“|”，“\”，“|”]，但原理是相同的：

import time

for i in reversed(range(0, 10)):
    time.sleep(1)
    print "%s\r" %i,

Answer 6

如果睡眠被信号中断，

time.sleep()

可能会更早返回（取决于操作系统/解释器对其他进程/线程的调度）。

为了提高多次迭代的准确性，避免大量迭代的漂移，倒计时可能会与时钟锁定：

#!/usr/bin/env python
import sys
import time

for i in reversed(range(1, 1001)):
    time.sleep(1 - time.time() % 1) # sleep until a whole second boundary
    sys.stderr.write('\r%4d' % i)

Answer 7

这是我做的：

import time
a = input("How long is the countdown?")
while a != 0:
    print a
    time.sleep(1)
    a = a-1

最后，如果你和其他人可以设置闹钟或其他什么。

Answer 8

另一种无需重新发明轮子的简单方法是使用 tqdm，它会自动显示进度条：

from time import sleep
from tqdm import tqdm

for _ in tqdm(range(10)):
    sleep(1)

您也可以根据需要修改加载栏的显示。

Answer 9

当然，只需编写一个循环，打印 10 减去迭代计数器，然后让它每次迭代休眠 1 秒并运行 10 次迭代。 或者，更加灵活：

def printer(v):
    print v
def countdown_timer(duration, step=1, output_function=printer,
                    prompt='Waiting {duration} seconds.'):
    output_function(prompt.format(duration=duration))
    for i in xrange(duration/step):
        output_function(duration - step * i)

Answer 10

这个精度是亚秒级的：

    print()
    _k = 0.5  # ensure k != _k first time round (as k will be integer)
    print('Starting in ')
    while _k > 0:
        k = round(event_timestamp - time())
        if k != _k:
            print(f'\r{k} ', end='', flush=True)
            _k = k
        sleep(0.1)

    print('boom')

注意

f'\r{k} '

中的尾随空格。 因此，如果我们从

100

到

99

或

10

到

9

，则会清除第二个数字。

而且也不需要

import sys

。

sleep(0.0003)

如果你想要毫秒精度。

Answer 11

如果你不限制自己睡觉，那么（由automatetheboringstuff提供），pyautogui有一个漂亮的倒计时功能：

import pyautogui
print('Starting in ', end=''); pyautogui.countdown(3)

Answer 12

也许这会有所帮助

    import turtle
    for i in range(10):
        t2 = turtle.Turtle()
        t2.hideturtle()
        t2.penup()
        t2.goto(0,0)
        t2.write(i,font=("Arial", 16, "normal"))
        i-=1
        sleep(1)
        t2.clear()

Answer 13

我的解决方案如下：

from sys import stdout                                                                                                                                                                                                                                                                                                        
write = stdout.write                                                                                                                                                                                                                                                                                                          
flush = stdout.flush                                                                                                                                                                                                                                                                                                          
                                                                                                                                                                                                                                                                                                                              
import time                                                                                                                                                                                                                                                                                                                   
                                                                                                                                                                                                                                                                                                                              
def sleepTicker(delay, pretext, posttext):                                                                                                                                                                                                                                                                                    
  precount = write(pretext)                                                                                                                                                                                                                                                                                                   
  for i in range(delay, 0, -1):                                                                                                                                                                                                                                                                                               
    count = write(f"{i}{posttext}")                                                                                                                                                                                                                                                                                           
    flush()                                                                                                                                                                                                                                                                                                                   
    time.sleep(1)                                                                                                                                                                                                                                                                                                             
    write('\b \b' * count)                                                                                                                                                                                                                                                                                                    
    flush()                                                                                                                                                                                                                                                                                                                   
  write('\b \b' * precount)                                                                                                                                                                                                                                                                                                   
  flush()                                                                                                                                                                                                                                                                                                                     
                                                                                                                                                                                                                                                                                                                              
print("Processing... ", end="", flush=True)                                                                                                                                                                                                                                                                                   
sleepTicker(10, "waiting (", ")")                                                                                                                                                                                                                                                                                             
print("Done")    

结果：