Ik zou graag willen weten hoe ik een vertraging in een Python-script kan zetten.

Antwoord 1, autoriteit 100%

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

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

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

Antwoord 2, autoriteit 26%

U kunt de functie sleep()gebruiken in de timemodule. Er kan een float-argument voor nodig zijn voor een resolutie van minder dan een seconde.

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

Antwoord 3, autoriteit 3%

Hoe kan ik een vertraging maken in Python?

In een enkele thread stel ik de slaapfunctievoor:

>>> from time import sleep
>>> sleep(4)

Deze functie onderbreekt de verwerking van de thread waarin deze wordt aangeroepen door het besturingssysteem, waardoor andere threads en processen kunnen worden uitgevoerd terwijl deze slaapt.

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

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

“hoera!” wordt afgedrukt 3 seconden nadat ik op Enterheb gedrukt.

Voorbeeld van het gebruik van sleepmet meerdere threads en processen

Nogmaals, sleepschort je thread op – het gebruikt bijna nul verwerkingskracht.

Maak ter demonstratie een script zoals dit (ik heb dit eerst geprobeerd in een interactieve Python 3.5-shell, maar subprocessen kunnen de functie party_laterom de een of andere reden niet vinden):

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

Je kunt een functie activeren om op een later tijdstip in een aparte thread te worden aangeroepen met de Timerthreadingobject:

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

De lege regel illustreert dat de functie naar mijn standaarduitvoer is afgedrukt en dat ik op Entermoest drukken om er zeker van te zijn dat ik een prompt kreeg.

Het voordeel van deze methode is dat terwijl de Timer-thread wachtte, ik andere dingen kon doen, in dit geval één keer op Enterdrukken – vóór de functie uitgevoerd (zie de eerste lege prompt).

Er is geen respectievelijk object in de multiprocessing-bibliotheek. Je kunt er een maken, maar het bestaat waarschijnlijk niet voor een reden. Een subthread is veel logischer voor een eenvoudige timer dan een geheel nieuw subproces.

Antwoord 4, autoriteit 2%

Vertragingen kunnen ook worden geïmplementeerd door de volgende methoden te gebruiken.

De eerste methode:

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

De tweede methode om te vertragen zou de impliciete wachtmethode zijn:

driver.implicitly_wait(5)

De derde methode is handiger 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'))

Antwoord 5, autoriteit 2%

Een beetje plezier met een slaperige generator.

De vraag gaat over vertraging. 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 laatste keer (regelmatig wakker worden)

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

Zoemergenerator

De volgende code (sleepy.py) definieert een buzzergengenerator:

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

Gewone zoemer oproepen

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 we het uitvoeren, 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 misschien:

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 kunnen we regelmatige slaperige intervallen inhalen, zelfs als we ons verslapen en buiten het normale schema komen.

Antwoord 6

Er zijn vijf methoden die ik ken: time.sleep(), pygame.time.wait(), matplotlib’s pyplot.pause(), .after()en asyncio.sleep().

time.sleep()voorbeeld (niet gebruiken bij gebruik van tkinter):

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

pygame.time.wait()voorbeeld (niet aanbevolen als je het pygame-venster niet gebruikt, maar je zou het venster onmiddellijk kunnen verlaten):

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

matplotlib’s functie pyplot.pause()voorbeeld (niet aanbevolen als je de grafiek niet gebruikt, maar je zou de grafiek meteen kunnen verlaten):

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

De .after()methode (het beste met 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')

Tot slot, de asyncio.sleep()methode:

import asyncio
asyncio.sleep(5)

Antwoord 7

De Tkinter-bibliotheek in de Python-standaardbibliotheek is een interactieve tool die u kunt importeren. In principe kun je knoppen en vakken en pop-ups en zo maken die verschijnen als vensters die je manipuleert met code.

Als je Tkinter gebruikt, gebruik dan geen time.sleep(), omdat dit je programma in de war brengt. Dit is mij overkomen. Gebruik in plaats daarvan root.after()en vervang de waarden voor hoeveel seconden dan ook, door milliseconden. time.sleep(1)is bijvoorbeeld gelijk aan root.after(1000)in Tkinter.

Anders, time.sleep(), waar veel antwoorden op hebben gewezen, is de juiste keuze.

Antwoord 8

Vertragingen worden gedaan met de tijdbibliotheek, met name 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

U extraheert de slaapfunctiealleen uit de tijdbibliotheek, wat betekent dat je het gewoon kunt noemen 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 bibliotheeken u kunt geen variabele hebben met de naam sleep. Maar je zou een variabele kunnen maken met de naam time.

Doen from [library] import [function] (, [function2])is geweldig als je alleen bepaalde delen van een module wilt.

Je zou het net zo goed kunnen doen als:

import time
time.sleep(1)

en je hebt toegang tot de andere functies van de tijdbibliotheekzoals time.clock()zolang u time.[function]()typt, maar u kunt de variabele tijd niet maken omdat dit de import zou overschrijven. Een oplossing om dit te doen

import time as t

waarmee je naar de tijdbibliotheekkunt verwijzen als t, zodat u het volgende kunt doen:

t.sleep()

Dit werkt in elke bibliotheek.

Antwoord 9

asyncio.slaap

Opmerking in recente Python-versies (Python 3.4 of hoger) dat u asyncio.sleepkunt gebruiken. Het is gerelateerd aan asynchrone programmering en asyncio. Bekijk het volgende voorbeeld:

import asyncio
from datetime import datetime
@asyncio.coroutine
def countdown(iteration_name, countdown_sec):
    """
    Just count for some countdown_sec seconds and do nothing else
    """
    while countdown_sec > 0:
       print(f'{iteration_name} iterates: {countdown_sec} seconds')
       yield from asyncio.sleep(1)
       countdown_sec -= 1
loop = asyncio.get_event_loop()
tasks = [asyncio.ensure_future(countdown('First Count', 2)),
         asyncio.ensure_future(countdown('Second Count', 3))]
start_time = datetime.utcnow()
# Run both methods. How much time will both run...?
loop.run_until_complete(asyncio.wait(tasks))
loop.close()
print(f'total running time: {datetime.utcnow() - start_time}')

We denken misschien dat het 2 seconden “slaapt” voor de eerste methode en dan 3 seconden voor de tweede methode, een totaal van 5 seconden looptijd van deze code. Maar het zal afdrukken:

total_running_time: 0:00:03.01286

Het wordt aanbevolen om officiële documentatie van asynciote lezen voor meer details.

Antwoord 10

Als je een vertraging in een Python-script wilt plaatsen:

Gebruik time.sleepof Event().waitals volgt:

from threading import Event
from time import sleep
delay_in_sec = 2
# Use time.sleep like this
sleep(delay_in_sec)         # Returns None
print(f'slept for {delay_in_sec} seconds')
# Or use Event().wait like this
Event().wait(delay_in_sec)  # Returns False
print(f'waited for {delay_in_sec} seconds')

Als u de uitvoering van een functie echter wilt uitstellen, doet u dit:

Gebruik threading.Timerals volgt:

from threading import Timer
delay_in_sec = 2
def hello(delay_in_sec):
    print(f'function called after {delay_in_sec} seconds')
t = Timer(delay_in_sec, hello, [delay_in_sec])  # Hello function will be called 2 seconds later with [delay_in_sec] as the *args parameter
t.start()  # Returns None
print("Started")

Uitgangen:

Started
function called after 2 seconds

Waarom de latere benadering gebruiken?

• Het stopt nietde uitvoering van het hele script (behalve de functie die je het doorgeeft).
• Na het starten van de timer kun je deze ook stoppen door timer_obj.cancel()te doen.

Antwoord 11

Terwijl iedereen de de facto time-module heeft voorgesteld, dacht ik dat ik een andere methode zou delen met behulp van matplotlib‘s pyplot-functie , pause.

Een voorbeeld

from matplotlib import pyplot as plt
plt.pause(5)    # Pauses the program for 5 seconds

Dit wordt meestal gebruikt om te voorkomen dat de plot verdwijnt zodra deze is uitgezet of om grove animaties te maken.

Dit zou u een importbesparen als u matplotlibal heeft geïmporteerd.

Antwoord 12

Dit is een eenvoudig voorbeeld van een vertraging:

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 ''

Nog een, in Tkinter:

import tkinter
def tick():
    pass
root = Tk()
delay = 100 # Time in milliseconds
root.after(delay, tick)
root.mainloop()

Antwoord 13

Je kunt ook dit proberen:

import time
# The time now
start = time.time() 
while time.time() - start < 10: # Run 1- seconds
    pass
# Do the job

Nu zal de shell niet crashen of niet reageren.