Vraag Hoe kan ik een vertraging in Python maken?


Ik zou graag willen weten hoe je een tijdsvertraging in een Python-script kunt aanbrengen.


2026
2018-02-04 07:04


oorsprong


antwoorden:


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

Hier is nog een voorbeeld waarbij ongeveer een keer per minuut iets wordt uitgevoerd:

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

2254
2018-02-04 07:05



U kunt de sleep() functie in de tijdmodule. Het kan een float-argument gebruiken voor een sub-second resolution.

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

564
2017-09-15 16:34



Gelieve te lezen https://web.archive.org/web/20090207081238/http://faqts.com/knowledge_base/view.phtml/aid/2609/fid/378, wat je verder kan helpen:

Probeer de slaapfunctie in de tijdmodule.

import time
time.sleep(60)

En zet dit in een while lus en een instructie worden alleen uitgevoerd op de   minuut ... Hiermee kunt u een instructie uitvoeren met vooraf gedefinieerde intervallen   ongeacht hoe lang de opdracht duurt (zolang het minder dan nodig is   een minuut of 5 of 60 of wat je maar wilt) Bijvoorbeeld, ik wilde   voer één keer per minuut een ping uit. Als ik gewoon time.sleep(60) of time.sleep(45)    zelfs, de ping zal niet altijd even lang duren. Hier is de   code :)

time.sleep(time.localtime(time.time())[5])

De [5] trekt gewoon de seconden uit de time.localtime()is terug   waarde.

Het goede van time.sleep is dat het drijvende-komma ondersteunt   getallen!

import time
time.sleep(0.1) 

http://python.org/doc/current/lib/module-time.html


118
2018-02-04 07:07



Je kunt het krijgen door dit simpelweg te doen:

from time import sleep

# Doing stuff
sleep(0.5) # Sleeping half a second (sleep() uses seconds, but you can also use floats)
# Doing stuff...

55
2018-01-18 18:48



Een beetje plezier met een slaperig generator.

De vraag gaat over tijdvertraging. Het kan een vaste tijd zijn, maar in sommige gevallen hebben we mogelijk een vertraging nodig die sinds de vorige keer is gemeten. Hier is een mogelijke oplossing:

Vertraging gemeten sinds de vorige keer (regelmatig wakker worden)

De situatie kan zijn, we willen zo vaak mogelijk iets doen en we willen ons niet druk maken over alle last_time, next_time dingen rondom onze code.

Zoemer generator

De volgende code (sleepy.py) definieert a buzzergen generator:

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

Roepen normale buzzergen

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()

En als het wordt uitgevoerd, zien we:

1400102636.46
1400102639.46
1400102642.46
1400102647.47
1400102650.47

We kunnen het ook direct in een lus gebruiken:

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

En als we het uitvoeren, zien we mogelijk:

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)

Zoals we zien, is deze zoemer niet te rigide en stellen we ons in staat om regelmatig slaperige tussenpozen in te halen, zelfs als we verslapen en ons schema verlaten.


33
2018-05-14 21:30



Hoe kan ik een vertraging in Python maken?

In een enkele thread stel ik de slaapfunctie voor:

>>> from time import sleep

>>> sleep(4)

Dit onderbreekt in feite de verwerking van de thread waarin het door het besturingssysteem wordt opgeroepen, waardoor andere threads en processen kunnen worden uitgevoerd terwijl het slaapt.

Gebruik het voor dat doel, of gewoon om een ​​functie uit te stellen van het uitvoeren. Bijvoorbeeld:

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

"Hoera!" afgedrukt 3 seconden nadat ik heb geraakt invoeren.

Voorbeeld met sleep met meerdere threads en processen

Nog een keer, sleep onderbreekt uw thread - deze gebruikt bijna nul verwerkingskracht.

Om te demonstreren, maak een script zoals dit (ik probeerde dit voor het eerst in een interactieve Python 3.5-shell, maar subprocessen kunnen de party_later functie om wat voor reden dan ook):

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()

Voorbeelduitvoer van dit 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

U kunt een functie activeren die op een later tijdstip in een afzonderlijke thread moet worden aangeroepen met de Timerinrijgobject:

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

>>> 

De lege regel illustreert dat de functie op mijn standaard is afgedrukt en dat ik moest raken invoeren om ervoor te zorgen dat ik op tijd was.

Het voordeel van deze methode is dat terwijl de Timer draad wachtte, ik was in staat om andere dingen te doen, in dit geval, slaan invoeren één keer - voordat de functie wordt uitgevoerd (zie de eerste lege prompt).

Er is geen respectief object in de multiprocessingbibliotheek. Je kunt er een maken, maar het bestaat waarschijnlijk niet voor een reden. Een subtoom is logischer voor een eenvoudige timer dan een heel nieuw subproces.


21
2018-06-21 03:25



De tkinter-bibliotheek in de standaardbibliotheek van Python is een interactieve tool die u kunt importeren. Kortom, je kunt knoppen en vakken en pop-ups maken en dingen die verschijnen als vensters die je manipuleert met code.

Als u tkinter gebruikt, NIET GEBRUIKEN TIME.SLEEP() omdat het je programma zal bederven. Dit is mij overkomen. Gebruik in plaats daarvan root.after() en vervang de waarden gedurende vele seconden, met een milliseconde. bijv, time.sleep(1) is gelijk aan root.after(1000) in tkinter.

Anders, time.sleep(), waar veel antwoorden op hebben gewezen, wat de manier is om te gaan.


20
2018-02-28 19:45



Vertragingen kunnen worden geïmplementeerd met behulp van drie methoden.

Laten we beginnen met de gemakkelijkste:

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

De tweede methode om uit te stellen zou de impliciete wachtmethode zijn:

 driver.implicitly_wait(5)

De derde methode is nuttiger wanneer u moet wachten tot een bepaalde actie is voltooid of totdat een element is gevonden:

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

11
2018-01-05 10:41



Om een ​​vertraging in te stellen, moet u het time module. En met die module hoeft u alleen maar te schrijven:

time.sleep(The amount of time)

Als u bijvoorbeeld een vertraging van een seconde wilt instellen voordat de computer een andere regel uitvoert, moet u het volgende doen:

time.sleep(1)
print('Hello, World!')

Dat is alles :)


9
2017-07-04 10:55



Vertragingen zijn opgetreden met de tijd bibliotheek, in het bijzonder de time.sleep () functie...

Om het even te laten wachten:

from time import sleep
sleep(1)

Dit werkt omdat door te doen:

from time import sleep

je extraheer de slaapfunctie  enkel en alleen van de tijd bibliotheek wat betekent dat je het gewoon kunt bellen met:

sleep(seconds)

in plaats van te moeten typen

time.sleep()

wat onhandig lang is om te typen.

Met deze methode krijgt u geen toegang tot de andere functies van de tijd bibliotheek en je kunt geen variabele hebben die slaap wordt genoemd. Maar je zou een variabele met de naam tijd kunnen creëren.

Aan het doen uit [bibliotheek] import [functie] (, [functie2]) is geweldig als je alleen bepaalde delen van een module wilt.

Je zou het net zo kunnen doen als

import time
time.sleep(1)

en je zou toegang hebben tot de andere kenmerken van de tijd bibliotheek graag willen time.clock() zolang je typt tijd.functie, maar u kunt de variabele tijd niet maken.


6
2018-06-13 19:04