temporizador - Como posso fazer um atraso no Python?




temporizador python (9)

Como posso fazer um atraso no Python?

Em um único segmento eu sugiro a função do sono:

>>> from time import sleep

>>> sleep(4)

Isso na verdade suspende o processamento do encadeamento no qual ele é chamado pelo sistema operacional, permitindo que outros encadeamentos e processos sejam executados enquanto ele estiver inativo.

Use-o para esse propósito ou simplesmente para atrasar a execução de uma função. Por exemplo:

>>> def party_time():
...     print('hooray!')
... 
>>> sleep(3); party_time()
hooray!

"hooray!" impresso 3 segundos depois que eu apertei Enter .

Exemplo usando sleep com vários encadeamentos e processos

Novamente, o sleep suspende seu thread - ele usa quase zero de poder de processamento.

Para demonstrar, crie um script como este (tentei pela primeira vez em um shell interativo do Python 3.5, mas os subprocessos não conseguem encontrar a função party_later por algum motivo):

from concurrent.futures import ThreadPoolExecutor, ProcessPoolExecutor, as_completed
from time import sleep, time

def party_later(kind='', n=''):
    sleep(3)
    return kind + n + ' party time!: ' + __name__

def main():
    with ProcessPoolExecutor() as proc_executor:
        with ThreadPoolExecutor() as thread_executor:
            start_time = time()
            proc_future1 = proc_executor.submit(party_later, kind='proc', n='1')
            proc_future2 = proc_executor.submit(party_later, kind='proc', n='2')
            thread_future1 = thread_executor.submit(party_later, kind='thread', n='1')
            thread_future2 = thread_executor.submit(party_later, kind='thread', n='2')
            for f in as_completed([
              proc_future1, proc_future2, thread_future1, thread_future2,]):
                print(f.result())
            end_time = time()
    print('total time to execute four 3-sec functions:', end_time - start_time)

if __name__ == '__main__':
    main()

Exemplo de saída deste script:

thread1 party time!: __main__
thread2 party time!: __main__
proc1 party time!: __mp_main__
proc2 party time!: __mp_main__
total time to execute four 3-sec functions: 3.4519670009613037

Multithreading

Você pode acionar uma função para ser chamada mais tarde em um thread separado com o objeto de threading Timer :

>>> from threading import Timer
>>> t = Timer(3, party_time, args=None, kwargs=None)
>>> t.start()
>>>
>>> hooray!

>>> 

A linha em branco ilustra que a função foi impressa no meu padrão e eu tive que apertar Enter para garantir que eu estava em um prompt.

A vantagem deste método é que enquanto o thread Timer estava esperando, eu era capaz de fazer outras coisas, neste caso, pressionando Enter uma vez - antes da função ser executada (veja o primeiro prompt vazio).

Não há um objeto respectivo na biblioteca de multiprocessamento. Você pode criar um, mas provavelmente não existe por um motivo. Um sub-thread faz muito mais sentido para um temporizador simples do que um novo sub-processo.

Eu gostaria de saber como colocar um atraso em um script Python.


A biblioteca tkinter na biblioteca padrão do Python é uma ferramenta interativa que você pode importar. Basicamente, você pode criar botões e caixas e popups e coisas que aparecem como janelas que você manipula com código.

Se você usar o tkinter, NÃO USE TIME.SLEEP() porque isso TIME.SLEEP() seu programa. Isso aconteceu comigo. Em vez disso, use root.after() e substitua os valores por quantos segundos, com milissegundos. Por exemplo, time.sleep(1) é equivalente a root.after(1000) no tkinter.

Caso contrário, time.sleep() , que muitas respostas apontaram, é o caminho a seguir.


Atrasos podem ser implementados usando três métodos.

Vamos começar com o mais fácil:

import time
time.sleep(5) # Delay for 5 seconds.

O segundo método a atrasar seria usar o método implícito de espera:

 driver.implicitly_wait(5)

O terceiro método é mais útil quando você precisa esperar até que uma determinada ação seja concluída ou até que um elemento seja encontrado:

self.wait.until(EC.presence_of_element_located((By.ID, 'UserName'))

Atrasos são feitos com a biblioteca de tempo , especificamente a função time.sleep() ...

Para apenas esperar por um segundo:

from time import sleep
sleep(1)

Isso funciona porque fazendo:

from time import sleep

você extrai a time.sleep() apenas da biblioteca de tempo, o que significa que você pode apenas chamá-la com:

sleep(seconds)

em vez de ter que digitar

time.sleep()

que é desajeitadamente longo para digitar.

Com esse método, você não teria acesso a outros recursos da biblioteca de tempos e não pode ter uma variável chamada sleep. Mas você poderia criar uma variável chamada tempo.

Fazer from [library] import [function] (, [function2]) é ótimo se você quer apenas certas partes de um módulo.

Você poderia igualmente fazer isso

import time
time.sleep(1)

e você teria acesso a outros recursos da biblioteca de tempo, como time.clock() , desde que você time.clock() time.[function]() , mas você não poderia criar a variável time.


Este é um exemplo fácil de um atraso de tempo:

import time

def delay(period='5'):
    # If the user enters nothing, It'll wait 5 seconds
    try:
        #If the user not enters a int, I'll just return ''
        time.sleep(period)
    except:
        return ''

Outro, no Tkinter:

import tkinter

def tick():
    pass

root=Tk()
delay=100 # time in milliseconds
root.after(delay,tick)
root.mainloop()

Existem 4 métodos que eu conheço: time.sleep() , pygame.time.wait() , pyplot.pause() e .after() .

time.sleep() (não use se estiver usando Tkinter):

import time
print('Hello')
time.sleep(5) #number of seconds
print('Bye')

pygame.time.wait() exemplo (não recomendado se você não estiver usando a janela pygame, mas você pode sair da janela instantaneamente):

import pygame
#If you are going to use the time module
#don't do "from pygame import *"
pygame.init()
print('Hello')
pygame.time.wait(5000)#milliseconds
print('Bye')

Exemplo da função de matplotlib pyplot.pause() (não recomendado se você não estiver usando o gráfico, mas você pode sair do gráfico instantaneamente):

import matplotlib
print('Hello')
matplotlib.pyplot.pause(5)#seconds 
print('Bye')

Finalmente, o método .after() (melhor com o Tkinter):

import tkinter as tk #Tkinter for python 2
root = tk.Tk()
print('Hello')
def ohhi():
 print('Oh, hi!')
root.after(5000, ohhi)#milliseconds and then a function
print('Bye')

Um pouco de diversão com um generator sonolento.

A questão é sobre o atraso de tempo. Pode ser um tempo fixo, mas em alguns casos podemos precisar de um atraso medido desde a última vez. Aqui está uma solução possível:

Atraso medido desde a última vez (acordando regularmente)

A situação pode ser, queremos fazer algo o mais regularmente possível e não queremos nos incomodar com todas as coisas next_time , next_time todo o nosso código.

Gerador de campainha

O código a seguir ( sleepy.py ) define um gerador de buzzergen :

import time
from itertools import count

def buzzergen(period):
    nexttime = time.time() + period
    for i in count():
        now = time.time()
        tosleep = nexttime - now
        if tosleep > 0:
            time.sleep(tosleep)
            nexttime += period
        else:
            nexttime = now + period
        yield i, nexttime

Invocando o buzzergen regular

from sleepy import buzzergen
import time
buzzer = buzzergen(3) # Planning to wake up each 3 seconds
print time.time()
buzzer.next()
print time.time()
time.sleep(2)
buzzer.next()
print time.time()
time.sleep(5) # Sleeping a bit longer than usually
buzzer.next()
print time.time()
buzzer.next()
print time.time()

E correndo, vemos:

1400102636.46
1400102639.46
1400102642.46
1400102647.47
1400102650.47

Nós também podemos usá-lo diretamente em um loop:

import random
for ring in buzzergen(3):
    print "now", time.time()
    print "ring", ring
    time.sleep(random.choice([0, 2, 4, 6]))

E correndo, podemos ver:

now 1400102751.46
ring (0, 1400102754.461676)
now 1400102754.46
ring (1, 1400102757.461676)
now 1400102757.46
ring (2, 1400102760.461676)
now 1400102760.46
ring (3, 1400102763.461676)
now 1400102766.47
ring (4, 1400102769.47115)
now 1400102769.47
ring (5, 1400102772.47115)
now 1400102772.47
ring (6, 1400102775.47115)
now 1400102775.47
ring (7, 1400102778.47115)

Como podemos ver, essa campainha não é muito rígida e nos permite alcançar intervalos com sono regulares, mesmo que durmamos demais e saímos do horário regular.


Você pode usar a função sleep() no módulo de tempo. Pode levar um argumento float para resolução sub-segundo.

from time import sleep
sleep(0.1) # Time in seconds.

import time
time.sleep(5)   # Delays for 5 seconds. You can also use a float value.

Aqui está outro exemplo em que algo é executado aproximadamente uma vez por minuto:

import time
while True:
    print("This prints once a minute.")
    time.sleep(60) # Delay for 1 minute (60 seconds).




timedelay