Fungsi Tidur Python: Cara Menambahkan Penundaan ke Kode

Tutorial ini akan mengajari Anda cara menggunakan fungsi sleep() dari modul waktu bawaan Python untuk menambahkan penundaan waktu ke kode.

Saat Anda menjalankan program Python sederhana, eksekusi kode terjadi secara berurutan —pernyataan demi pernyataan— tanpa penundaan waktu. Namun, Anda mungkin perlu menunda eksekusi kode dalam beberapa kasus. Fungsi sleep() dari modul waktu bawaan Python membantu Anda melakukan ini.

Dalam tutorial ini, Anda akan mempelajari sintaks penggunaan fungsi sleep() dengan Python dan beberapa contoh untuk memahami cara kerjanya. Mari kita mulai!

Sintaks waktu Python.sleep()

Modul time , dibangun ke dalam pustaka standar Python, menyediakan beberapa fungsi berguna yang berkaitan dengan waktu. Sebagai langkah pertama, impor modul time ke lingkungan kerja Anda:

 import time

Karena fungsi sleep() adalah bagian dari modul time , kini Anda dapat mengakses dan menggunakannya dengan sintaks umum berikut:

 time.sleep(n)

Di sini, n adalah jumlah detik untuk tidur. Itu bisa berupa bilangan bulat atau angka floating point.

Terkadang penundaan yang diperlukan mungkin beberapa milidetik. Dalam kasus ini, Anda dapat mengonversi durasi dalam milidetik menjadi detik dan menggunakannya dalam panggilan ke fungsi tidur. Misalnya, jika Anda ingin memperkenalkan penundaan 100 milidetik, Anda dapat menentukannya sebagai 0,1 detik: time.sleep(0.1) .

Anda juga dapat mengimpor hanya fungsi sleep dari modul time :

 from time import sleep

Jika Anda menggunakan metode di atas untuk mengimpor, Anda kemudian dapat memanggil fungsi sleep() secara langsung—tanpa menggunakan time.sleep() .

Sekarang setelah Anda mempelajari sintaks fungsi sleep() Python, mari kita membuat contoh kode untuk melihat fungsi dalam tindakan. Anda dapat mengunduh skrip Python yang digunakan dalam tutorial ini dari folder python-sleep di repo GitHub ini.

Tunda Eksekusi Kode dengan sleep()

Sebagai contoh pertama, mari gunakan fungsi tidur untuk menunda eksekusi program Python sederhana.

Dalam cuplikan kode berikut:

• Pernyataan print() pertama dijalankan tanpa penundaan.
• Kami kemudian memperkenalkan penundaan 5 detik menggunakan fungsi sleep() .
• Pernyataan print() kedua akan dieksekusi hanya setelah operasi sleep selesai.

 # /python-sleep/simple_example.py import time print("Print now") time.sleep(5) print("Print after sleeping for 5 seconds")

Sekarang jalankan file simple_example.py dan amati hasilnya:

 $ python3 simple_example.py

Tambahkan Penundaan Berbeda ke Blok Kode

Pada contoh sebelumnya, kami memperkenalkan penundaan tetap selama 5 detik antara eksekusi dua pernyataan print() . Selanjutnya, mari kita buat kode contoh lain untuk memperkenalkan waktu tunda yang berbeda saat melakukan perulangan melalui iterable.

Dalam contoh ini, kami ingin melakukan hal berikut:

• Ulangi kalimat, akses setiap kata, dan cetak.
• Setelah mencetak setiap kata, kami ingin menunggu selama durasi waktu tertentu—sebelum mencetak kata berikutnya dalam kalimat.

Looping Melalui String of Strings

Pertimbangkan string, sentence . Ini adalah string di mana setiap kata adalah string itu sendiri.

Jika kita mengulang string, kita akan mendapatkan setiap karakter, seperti yang ditunjukkan:

 >>> sentence = "How long will this take?" >>> for char in sentence: ... print(char) # Output (truncated for readability) H o w . . . t a k e ?

Tapi ini bukan yang kita inginkan. Kami ingin mengulangi kalimat dan mengakses setiap kata. Untuk melakukan ini, kita dapat memanggil metode split() pada string sentence . Ini akan mengembalikan daftar string—diperoleh dengan memisahkan string sentence —pada semua kemunculan spasi.

 >>> sentence.split() ['How', 'long', 'will', 'this', 'take?'] >>> for word in sentence.split(): ... print(word) # Output How long will this take?

Looping Through Iterables dengan Delay Berbeda

Mari kita lihat kembali contohnya:

• sentence adalah string yang ingin kita lewati untuk mengakses setiap kata.
• delay_times adalah daftar waktu tunda yang akan kita gunakan sebagai argumen untuk fungsi sleep() selama setiap melewati loop.

Di sini kami ingin mengulang secara bersamaan melalui dua daftar: daftar delay_times dan daftar string yang diperoleh dengan memisahkan string sentence . Anda dapat menggunakan fungsi zip() untuk melakukan iterasi paralel ini.

Fungsi Python zip() : zip(list1, list2) mengembalikan iterator tuple, di mana setiap tuple berisi item pada indeks i di list1 dan list2.

 # /python-sleep/delay_times.py import time sleep_times = [3,4,1.5,2,0.75] sentence = "How long will this take?" for sleep_time,word in zip(sleep_times,sentence.split()): print(word) time.sleep(sleep_time)

Tanpa fungsi sleep, kontrol akan langsung melanjutkan ke iterasi berikutnya. Karena kami telah memperkenalkan penundaan, melewati loop berikutnya hanya terjadi setelah operasi tidur selesai.

Sekarang jalankan delay_times.py dan amati hasilnya:

 $ python3 delay_times.py

Kata-kata selanjutnya dalam string akan dicetak setelah penundaan. Penundaan setelah mencetak kata pada indeks i dalam string adalah angka pada indeks i dalam daftar delay_times .

Penghitung Waktu Mundur dengan Python

Sebagai contoh selanjutnya, mari kita membuat kode penghitung waktu mundur sederhana dengan Python.

Mari kita tentukan fungsi countDown() :

 # /python-sleep/countdown.py import time def countDown(n): for i in range(n,-1,-1): if i==0: print("Ready to go!") else: print(i) time.sleep(1)

Selanjutnya, mari kita parsing definisi fungsi countDown() :

• Fungsi mengambil angka n sebagai argumen dan menghitung mundur hingga nol mulai dari angka n .
• Kami menggunakan time.sleep(1) untuk mencapai penundaan satu detik di antara hitungan.
• Saat hitungan mencapai 0, fungsi mencetak "Siap untuk digunakan!".

Untuk mencapai operasi hitung mundur, kami telah menggunakan fungsi range() dengan nilai langkah negatif -1. range(n, -1, -1) akan membantu kita melewati rentang angka dalam n, n – 1, n – 2, dan seterusnya hingga nol. Ingatlah bahwa titik akhir dikecualikan secara default saat menggunakan fungsi range() .

Selanjutnya mari tambahkan panggilan ke fungsi countDown() dengan 5 sebagai argumennya.

 countDown(5)

Sekarang jalankan skrip countdown.py dan lihat fungsi countDown beraksi!

 $ python3 countdown.py

Fungsi Tidur di Multithreading

Modul threading Python menawarkan kemampuan multithreading out-of-the-box. Dengan Python, Global Interpreter Lock atau GIL memastikan bahwa hanya ada satu utas aktif yang berjalan kapan saja.

Namun, selama operasi I/O dan menunggu operasi seperti tidur, prosesor dapat menangguhkan eksekusi utas saat ini dan beralih ke utas lain yang sedang menunggu.

Untuk memahami cara kerjanya, mari kita ambil contoh.

Membuat dan Menjalankan Utas dengan Python

Pertimbangkan fungsi-fungsi berikut, func1() , func2() , dan func3() . Mereka mengulang serangkaian angka dan mencetaknya. Ini diikuti oleh operasi tidur—untuk jumlah detik tertentu—selama setiap melewati loop. Kami telah menggunakan waktu tunda yang berbeda untuk setiap fungsi untuk lebih memahami bagaimana eksekusi beralih di antara utas secara bersamaan.

 import time def func1(): for i in range(5): print(f"Running t1, print {i}.") time.sleep(2) def func2(): for i in range(5): print(f"Running t2, print {i}.") time.sleep(1) def func3(): for i in range(4): print(f"Running t3, print {i}.") time.sleep(0.5)

Di Python, Anda bisa menggunakan konstruktor Thread() untuk membuat instance objek thread. Menggunakan sintaks threading.Thread(target = …, args = …) membuat utas yang menjalankan fungsi target dengan argumen yang ditentukan dalam args tuple.

Dalam contoh ini fungsi, func1 , func2 , dan func3 , tidak menggunakan argumen apa pun. Jadi cukup menentukan nama fungsi saja sebagai target. Kami kemudian mendefinisikan objek utas, t1 , t2 , dan t3 dengan func1 , func2 , dan func3 sebagai targetnya masing-masing.

 t1 = threading.Thread(target=func1) t2 = threading.Thread(target=func2) t3 = threading.Thread(target=func3) t1.start() t2.start() t3.start()

Berikut kode lengkap untuk contoh threading:

 # /python-sleep/threads.py import time import threading def func1(): for i in range(5): print(f"Running t1, print {i}.") time.sleep(2) def func2(): for i in range(5): print(f"Running t2, print {i}.") time.sleep(1) def func3(): for i in range(4): print(f"Running t3, print {i}.") time.sleep(0.5) t1 = threading.Thread(target=func1) t2 = threading.Thread(target=func2) t3 = threading.Thread(target=func3) t1.start() t2.start() t3.start()

Perhatikan keluarannya. Eksekusi berubah antara tiga utas. Utas t3 memiliki waktu tunggu terendah, sehingga ditangguhkan untuk waktu paling sedikit. Thread t1 memiliki durasi sleep terlama yaitu dua detik, jadi ini adalah thread terakhir yang menyelesaikan eksekusi.

Untuk mempelajari lebih lanjut, baca tutorial tentang dasar-dasar multithreading dengan Python.

Kesimpulan

Dalam tutorial ini, Anda telah mempelajari cara menggunakan fungsi sleep() Python untuk menambahkan penundaan waktu ke kode.

Anda dapat mengakses fungsi sleep() dari modul waktu bawaan, time.sleep() . Untuk menunda eksekusi sebanyak n detik, gunakan time.sleep(n) . Juga, Anda telah melihat contoh menunda iterasi berikutnya dalam satu lingkaran dengan nilai yang berbeda, hitungan mundur, dan multithreading.

Anda sekarang dapat menjelajahi kemampuan modul waktu yang lebih canggih. Ingin bekerja dengan tanggal dan waktu dengan Python? Selain modul waktu, Anda dapat memanfaatkan fungsionalitas modul datetime dan kalender.

Selanjutnya, pelajari cara menghitung perbedaan waktu dengan Python.