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

Berikut adalah contoh lain di mana ada sesuatu yang berjalan sekitar satu menit sekali:

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

Anda dapat menggunakan tidur() di dalam waktu module. Hal ini dapat mengambil pelampung argumen untuk sub-resolusi kedua.

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

Bagaimana saya bisa membuat waktu keterlambatan dalam Python?

Di satu thread saya sarankan fungsi tidur:

>>> from time import sleep

>>> sleep(4)

Fungsi ini benar-benar menunda pengolahan benang yang disebut oleh sistem operasi, yang memungkinkan benang lain dan proses untuk mengeksekusi ketika tidur.

Menggunakannya untuk tujuan itu, atau hanya untuk menunda fungsi dari pelaksana. Misalnya:

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

"hore!" dicetak 3 detik setelah aku memukul Enter.

Contoh dengan menggunakan tidur dengan beberapa benang dan proses

Lagi, tidur menunda thread anda - menggunakan sebelah nol kekuatan pemrosesan.

Untuk menunjukkan, membuat script seperti ini (saya pertama kali mencoba hal ini dalam sebuah interaktif Python shell 3.5, tapi sub-proses dapat't menemukan party_later fungsi untuk beberapa alasan):

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

Contoh output dari script ini:

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

Anda dapat memicu fungsi yang akan dipanggil nanti di thread terpisah dengan Timer threading obyek:

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

>>> 

Baris kosong menggambarkan bahwa fungsi dicetak untuk standar saya keluar dan saya harus memukul Enter untuk memastikan saya berada di sebuah prompt.

Keuntungan dari metode ini adalah bahwa sementara Timer benang menunggu, saya mampu melakukan hal-hal lain, dalam hal ini, memukul Enter satu waktu - sebelum fungsi dijalankan (lihat pertama kosong prompt).

Ada isn't masing-masing objek di multiprocessing perpustakaan. Anda bisa membuat satu, tapi itu tidak mungkin't ada untuk sebuah alasan. Sub-thread membuat banyak lebih masuk akal untuk sebuah timer sederhana dari keseluruhan sub-proses.

Sedikit bersenang-senang dengan mengantuk generator.

Pertanyaannya adalah tentang waktu tunda. Hal ini dapat menjadi waktu yang tetap, tetapi dalam beberapa kasus kita mungkin perlu menunda diukur sejak terakhir kali. Berikut ini adalah salah satu solusi yang mungkin:

Delay diukur sejak terakhir kali (bangun secara teratur)

Situasi dapat, kita ingin melakukan sesuatu secara teratur mungkin dan kami tidak ingin repot-repot dengan semua last_time, next_time hal-hal di sekitar kita kode.

Buzzer generator

Kode berikut (sleepy.py) mendefinisikan 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

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

Dan berjalan ini kita melihat:

1400102636.46
1400102639.46
1400102642.46
1400102647.47
1400102650.47

Kita juga dapat menggunakannya secara langsung dalam loop:

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

Dan berjalan itu kita bisa melihat:

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)

Seperti yang kita lihat, ini buzzer tidak terlalu kaku dan memungkinkan kita untuk mengejar ketinggalan dengan teratur mengantuk interval bahkan jika kita kesiangan dan keluar dari jadwal rutin.

Keterlambatan dapat juga dilaksanakan dengan menggunakan metode berikut.

Metode pertama

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

Metode kedua untuk menunda akan menggunakan implisit menunggu metode:

 driver.implicitly_wait(5)

Metode ketiga adalah lebih berguna ketika anda harus menunggu sampai tindakan tertentu selesai atau sampai elemen ditemukan:

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

Dengan tkinter perpustakaan di Python library standar adalah alat interaktif yang dapat anda impor. Pada dasarnya, anda dapat membuat tombol dan kotak dan popup dan hal-hal yang muncul sebagai windows yang anda memanipulasi dengan kode.

Jika anda menggunakan tkinter, TIDAK MENGGUNAKAN WAKTU.TIDUR() karena itu akan muck up program anda. Hal ini terjadi pada saya. Sebaliknya, gunakan akar.setelah() dan mengganti nilai namun beberapa detik, dengan milidetik. E. g, waktu.tidur(1) setara dengan akar.setelah(1000) di tkinter.

Sebaliknya, waktu.tidur(), yang banyak jawaban telah menunjukkan, yang adalah cara untuk pergi.

Ada 5 metode yang saya tahu: waktu.tidur(), pygame.waktu.menunggu(), matplotlib's pyplot.pause(), .setelah(), dan sopir.implicitly_wait().

waktu.tidur() contoh (jangan gunakan jika menggunakan Tkinter):

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

pygame.waktu.menunggu() misalnya (tidak dianjurkan jika anda tidak menggunakan pygame jendela, tapi anda bisa keluar jendela langsung):

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 fungsi pyplot.pause() misalnya (tidak dianjurkan jika anda tidak menggunakan grafik, tapi anda bisa keluar grafik langsung):

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

The .setelah() metode (terbaik dengan 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')

Akhirnya, sopir.implicitly_wait() metode (selenium):

driver.implicitly_wait(5)#waits 5 seconds

Penundaan dilakukan dengan android, khususnya waktu.tidur() fungsi.

Hanya membuatnya menunggu kedua:

from time import sleep
sleep(1)

Ini bekerja karena dengan melakukan:

from time import sleep

Anda mengekstrak fungsi tidur hanya dari android, yang berarti anda hanya bisa menyebutnya dengan:

sleep(seconds)

Daripada harus mengetikkan

time.sleep()

Yang canggung lama untuk mengetik.

Dengan metode ini, anda tidak't mendapatkan akses ke fitur-fitur lainnya dari android dan anda dapat't memiliki sebuah variabel yang disebut tidur. Tapi anda bisa membuat sebuah variabel yang disebut waktu.

Melakukan dari [perpustakaan] impor [fungsi] (, [function2]) adalah besar jika anda hanya ingin bagian-bagian tertentu dari sebuah modul.

Anda bisa sama-sama melakukannya sebagai:

import time
time.sleep(1)

dan anda akan memiliki akses ke fitur-fitur lainnya dari android seperti waktu.jam() selama anda ketik waktu.[fungsi](), tapi anda tidak't membuat variabel waktu karena hal itu akan menimpa impor. Solusi untuk ini untuk melakukan

import time as t

yang akan memungkinkan anda untuk referensi android sebagai t, yang memungkinkan anda untuk melakukan:

t.sleep()

Ini bekerja pada setiap perpustakaan.

asyncio.tidur

Pemberitahuan dalam beberapa versi python (python 3.4 atau lebih tinggi) anda dapat menggunakan asyncio.tidur. It's yang terkait dengan pemrograman asynchronous dan asyncio. Check out contoh berikutnya:

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

Kita mungkin berpikir itu akan "tidur" selama 2 detik untuk metode pertama dan kemudian 3 detik dalam metode kedua, total 5 detik waktu berjalan dari kode ini. Tapi itu akan mencetak:

total_running_time: 0:00:03.01286

Sarankan untuk membaca asyncio dokumentasi resmi untuk lebih jelasnya

Jika anda ingin menempatkan waktu keterlambatan dalam Python script:

Menggunakan waktu.tidur atau Event().menunggu seperti ini:

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

Namun, jika anda ingin menunda eksekusi dari fungsi yang melakukan hal ini:

Gunakan threading.Timer seperti ini:

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 sec later with [delay_in_sec] as *args parameter
t.start()  # returns None
print("Started")

Output:

Started
function called after 2 seconds         

Mengapa menggunakan kemudian pendekatan?

• Tidak tidak menghentikan eksekusi dari keseluruhan naskah. (kecuali untuk fungsi yang anda lulus)
• Setelah memulai timer anda juga dapat menghentikannya dengan melakukan timer_obj.batal().

Ini adalah contoh mudah dari waktu tunda:

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

Lain, di Tkinter:

import tkinter

def tick():
    pass

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

Sementara orang lain telah menyarankan de facto waktu modul, saya pikir saya'd berbagi metode yang berbeda menggunakan matplotlib's pyplot fungsi, pause.

Contoh

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

Biasanya ini digunakan untuk mencegah plot dari menghilang secepat itu diplot atau untuk membuat minyak mentah animasi.

Ini akan menyelamatkan anda sebuah impor jika anda sudah memiliki matplotlib diimpor.