Πώς να προσθέσετε καθυστερήσεις στον κώδικα

Αυτό το σεμινάριο θα σας διδάξει πώς να χρησιμοποιήσετε τη συνάρτηση sleep() από την ενσωματωμένη μονάδα χρόνου της Python για να προσθέσετε χρονικές καθυστερήσεις στον κώδικα.

Όταν εκτελείτε ένα απλό πρόγραμμα Python, η εκτέλεση του κώδικα γίνεται διαδοχικά — τη μία πρόταση μετά την άλλη — χωρίς καμία χρονική καθυστέρηση. Ωστόσο, μπορεί να χρειαστεί να καθυστερήσετε την εκτέλεση του κώδικα σε ορισμένες περιπτώσεις. Η συνάρτηση sleep() από την ενσωματωμένη μονάδα χρόνου Python σας βοηθά να το κάνετε αυτό.

Σε αυτό το σεμινάριο, θα μάθετε τη σύνταξη της χρήσης της συνάρτησης sleep() στην Python και πολλά παραδείγματα για να κατανοήσετε πώς λειτουργεί. Ας αρχίσουμε!

Σύνταξη Python time.sleep()

Η ενότητα χρόνου, ενσωματωμένη στην τυπική βιβλιοθήκη Python, παρέχει πολλές χρήσιμες λειτουργίες που σχετίζονται με το χρόνο. Ως πρώτο βήμα, εισαγάγετε τη μονάδα χρόνου στο περιβάλλον εργασίας σας:

import time

Καθώς η συνάρτηση sleep() είναι μέρος της μονάδας χρόνου, μπορείτε πλέον να έχετε πρόσβαση και να τη χρησιμοποιήσετε με την ακόλουθη γενική σύνταξη:

time.sleep(n) 

Εδώ, n είναι ο αριθμός των δευτερολέπτων για ύπνο. Μπορεί να είναι ακέραιος ή αριθμός κινητής υποδιαστολής.

Μερικές φορές η απαιτούμενη καθυστέρηση μπορεί να είναι μερικά χιλιοστά του δευτερολέπτου. Σε αυτές τις περιπτώσεις, μπορείτε να μετατρέψετε τη διάρκεια σε χιλιοστά του δευτερολέπτου σε δευτερόλεπτα και να τη χρησιμοποιήσετε στην κλήση προς τη λειτουργία ύπνου. Για παράδειγμα, εάν θέλετε να εισάγετε μια καθυστέρηση 100 χιλιοστών του δευτερολέπτου, μπορείτε να την ορίσετε ως 0,1 δευτερόλεπτο: time.sleep(0,1).

▶ Μπορείτε επίσης να εισαγάγετε μόνο τη λειτουργία ύπνου από τη μονάδα χρόνου:

from time import sleep

Εάν χρησιμοποιείτε την παραπάνω μέθοδο για εισαγωγή, μπορείτε στη συνέχεια να καλέσετε τη συνάρτηση sleep() απευθείας—χωρίς να χρησιμοποιήσετε το time.sleep().

Τώρα που μάθατε τη σύνταξη της συνάρτησης Python sleep(), ας κωδικοποιήσουμε παραδείγματα για να δούμε τη συνάρτηση σε δράση. Μπορείτε να κάνετε λήψη των σεναρίων Python που χρησιμοποιούνται σε αυτό το σεμινάριο από τον φάκελο python-sleep σε αυτό το αποθετήριο GitHub. 👩🏽‍💻

Καθυστέρηση εκτέλεσης κώδικα με sleep()

Ως πρώτο παράδειγμα, ας χρησιμοποιήσουμε τη συνάρτηση ύπνου για να καθυστερήσουμε την εκτέλεση ενός απλού προγράμματος Python.

  19 Καλύτερη συσκευή εγγραφής οθόνης για Mac

Στο παρακάτω απόσπασμα κώδικα:

  • Η πρώτη δήλωση print() εκτελείται χωρίς καθυστέρηση.
  • Στη συνέχεια εισάγουμε μια καθυστέρηση 5 δευτερολέπτων χρησιμοποιώντας τη συνάρτηση sleep().
  • Η δεύτερη πρόταση print() θα εκτελεστεί μόνο αφού ολοκληρωθεί η λειτουργία αναστολής λειτουργίας.
# /python-sleep/simple_example.py
import time

print("Print now")
time.sleep(5)
print("Print after sleeping for 5 seconds")

Τώρα εκτελέστε το αρχείο simple_example.py και παρατηρήστε την έξοδο:

$ python3 simple_example.py

Προσθέστε διαφορετικές καθυστερήσεις σε ένα μπλοκ κωδικών

Στο προηγούμενο παράδειγμα, εισαγάγαμε μια σταθερή καθυστέρηση 5 δευτερολέπτων μεταξύ της εκτέλεσης δύο εντολών print(). Στη συνέχεια, ας κωδικοποιήσουμε ένα άλλο παράδειγμα για να εισαγάγουμε διαφορετικούς χρόνους καθυστέρησης κατά τον επαναληπτικό κύκλο.

Σε αυτό το παράδειγμα, θα θέλαμε να κάνουμε τα εξής:

  • Περιηγηθείτε σε μια πρόταση, αποκτήστε πρόσβαση σε κάθε λέξη και εκτυπώστε την.
  • Μετά την εκτύπωση κάθε λέξης, θα θέλαμε να περιμένουμε για μια συγκεκριμένη χρονική διάρκεια — πριν εκτυπώσουμε την επόμενη λέξη στην πρόταση.

Looping Through a String of Strings

Σκεφτείτε τη συμβολοσειρά, πρόταση. Είναι μια συμβολοσειρά όπου κάθε λέξη είναι μια χορδή από μόνη της.

Αν κάνουμε βρόχο μέσα από τη συμβολοσειρά, θα λάβουμε κάθε χαρακτήρα, όπως φαίνεται:

>>> sentence = "How long will this take?"
>>> for char in sentence:
...     print(char)

# Output (truncated for readability)
H
o
w
.
.
.
t
a
k
e
?

Δεν είναι όμως αυτό που θέλουμε. Θα θέλαμε να περιηγηθούμε στην πρόταση και να αποκτήσουμε πρόσβαση σε κάθε λέξη. Για να γίνει αυτό, μπορούμε να καλέσουμε τη μέθοδο split() στη συμβολοσειρά πρότασης. Αυτό θα επιστρέψει μια λίστα συμβολοσειρών—που λαμβάνονται με διαίρεση της συμβολοσειράς της πρότασης—σε όλες τις εμφανίσεις κενού διαστήματος.

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

# Output
How
long
will
this
take?

Looping Through Iterables με διαφορετικές καθυστερήσεις

Ας ξαναδούμε το παράδειγμα:

  • Η πρόταση είναι η συμβολοσειρά που θα θέλαμε να περάσουμε για να αποκτήσουμε πρόσβαση σε κάθε λέξη.
  • Delay_times είναι η λίστα των χρόνων καθυστέρησης που θα χρησιμοποιήσουμε ως όρισμα στη συνάρτηση sleep() κατά τη διάρκεια κάθε διέλευσης από τον βρόχο.

Εδώ θα θέλαμε να κάνουμε βρόχο ταυτόχρονα σε δύο λίστες: τη λίστα delay_times και τη λίστα των συμβολοσειρών που λαμβάνονται με το διαχωρισμό της συμβολοσειράς της πρότασης. Μπορείτε να χρησιμοποιήσετε τη συνάρτηση zip() για να εκτελέσετε αυτήν την παράλληλη επανάληψη.

Η συνάρτηση zip() της Python: zip(list1, list2) επιστρέφει έναν επαναλήπτη πλειάδων, όπου κάθε πλειάδα περιέχει το στοιχείο στο ευρετήριο i στη λίστα1 και στη λίστα2.

# /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)

Χωρίς τη λειτουργία ύπνου, ο έλεγχος θα προχωρούσε αμέσως στην επόμενη επανάληψη. Επειδή έχουμε εισαγάγει μια καθυστέρηση, το επόμενο πέρασμα μέσω του βρόχου γίνεται μόνο μετά την ολοκλήρωση της λειτουργίας ύπνου.

  Πώς να εισαγάγετε ένα σύμβολο με μια συντόμευση πληκτρολογίου στο MS Word

Τώρα εκτελέστε το delay_times.py και παρατηρήστε την έξοδο:

$ python3 delay_times.py

Οι επόμενες λέξεις στη συμβολοσειρά θα εκτυπωθούν μετά από καθυστέρηση. Η καθυστέρηση μετά την εκτύπωση της λέξης στο ευρετήριο i στη συμβολοσειρά είναι ο αριθμός στο ευρετήριο i στη λίστα delay_times.

Αντίστροφη μέτρηση σε Python

Ως επόμενο παράδειγμα, ας κωδικοποιήσουμε ένα απλό χρονόμετρο αντίστροφης μέτρησης στην Python.

Ας ορίσουμε μια συνάρτηση 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)

Στη συνέχεια, ας αναλύσουμε τον ορισμό της συνάρτησης countDown():

  • Η συνάρτηση παίρνει έναν αριθμό n ως όρισμα και μετρά αντίστροφα μέχρι το μηδέν ξεκινώντας από αυτόν τον αριθμό n.
  • Χρησιμοποιούμε time.sleep(1) για να επιτύχουμε καθυστέρηση ενός δευτερολέπτου μεταξύ των μετρήσεων.
  • Όταν η αρίθμηση φτάσει στο 0, η συνάρτηση εκτυπώνει “Έτοιμο να πάει!”.

🎯 Για να πετύχουμε τη λειτουργία αντίστροφης μέτρησης, χρησιμοποιήσαμε τη συνάρτηση range() με αρνητική τιμή βήματος -1. Το range(n, -1, -1) θα μας βοηθήσει να κάνουμε βρόχο μέσα από το εύρος των αριθμών σε n, n – 1, n – 2 και ούτω καθεξής μέχρι το μηδέν. Θυμηθείτε ότι το τελικό σημείο εξαιρείται από προεπιλογή όταν χρησιμοποιείτε τη συνάρτηση range().

Στη συνέχεια, ας προσθέσουμε μια κλήση στη συνάρτηση countDown() με όρισμα το 5.

countDown(5)

Τώρα εκτελέστε το σενάριο countdown.py και δείτε τη λειτουργία countdown σε δράση!

$ python3 countdown.py

Λειτουργία Sleep σε Multithreading

Η ενότητα Python threading προσφέρει εξωγενείς δυνατότητες πολλαπλών νημάτων. Στην Python, το Global Interpreter Lock ή GIL διασφαλίζει ότι υπάρχει μόνο ένα ενεργό νήμα που εκτελείται ανά πάσα στιγμή.

Ωστόσο, κατά τις λειτουργίες I/O και τις λειτουργίες αναμονής, όπως η αναμονή, ο επεξεργαστής μπορεί να αναστείλει την εκτέλεση του τρέχοντος νήματος και να μεταβεί σε άλλο νήμα που βρίσκεται σε αναμονή.

Για να καταλάβετε πώς λειτουργεί αυτό, ας πάρουμε ένα παράδειγμα.

Δημιουργία και εκτέλεση νημάτων στην Python

Εξετάστε τις ακόλουθες συναρτήσεις, func1(), func2() και func3(). Περιλαμβάνουν μια σειρά από αριθμούς και τους εκτυπώνουν. Αυτό ακολουθείται από μια λειτουργία ύπνου – για συγκεκριμένο αριθμό δευτερολέπτων – κατά τη διάρκεια κάθε διέλευσης από τον βρόχο. Χρησιμοποιήσαμε διαφορετικούς χρόνους καθυστέρησης για καθεμία από τις συναρτήσεις για να κατανοήσουμε καλύτερα πώς η εκτέλεση αλλάζει μεταξύ νημάτων ταυτόχρονα.

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)

Στην Python, μπορείτε να χρησιμοποιήσετε τον κατασκευαστή Thread() για να δημιουργήσετε ένα αντικείμενο νήματος. Χρησιμοποιώντας τη σύνταξη threading.Thread(target = …, args =…) δημιουργεί ένα νήμα που εκτελεί τη συνάρτηση προορισμού με το όρισμα που καθορίζεται στην πλειάδα args.

  Πώς να αλλάξετε το όνομα χρήστη Kik Display

Σε αυτό το παράδειγμα, οι συναρτήσεις func1, func2 και func3 δεν λαμβάνουν κανένα όρισμα. Επομένως, αρκεί να ορίσετε μόνο το όνομα της συνάρτησης ως στόχο. Στη συνέχεια ορίζουμε τα αντικείμενα νήματος, t1, t2 και t3 με τα func1, func2 και func3 ως στόχους, αντίστοιχα.

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

t1.start()
t2.start()
t3.start()

Ακολουθεί ο πλήρης κώδικας για το παράδειγμα νήματος:

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

Παρατηρήστε την έξοδο. Η εκτέλεση αλλάζει μεταξύ των τριών νημάτων. Το νήμα t3 έχει τον χαμηλότερο χρόνο αναμονής, επομένως τίθεται σε αναστολή για το λιγότερο χρονικό διάστημα. Το νήμα t1 έχει τη μεγαλύτερη διάρκεια ύπνου δύο δευτερολέπτων, επομένως είναι το τελευταίο νήμα που τελειώνει την εκτέλεση.

Για να μάθετε περισσότερα, διαβάστε το σεμινάριο σχετικά με τα βασικά του multithreading στην Python.

συμπέρασμα

Σε αυτό το σεμινάριο, έχετε μάθει πώς να χρησιμοποιείτε τη συνάρτηση sleep() της Python για να προσθέτετε χρονικές καθυστερήσεις στον κώδικα.

Μπορείτε να αποκτήσετε πρόσβαση στη λειτουργία sleep() από την ενσωματωμένη μονάδα χρόνου, time.sleep(). Για να καθυστερήσετε την εκτέλεση κατά n δευτερόλεπτα, χρησιμοποιήστε time.sleep(n). Επίσης, έχετε δει παραδείγματα καθυστέρησης επακόλουθων επαναλήψεων σε έναν βρόχο με διαφορετικές τιμές, αντίστροφη μέτρηση και πολλαπλών νημάτων.

Μπορείτε τώρα να εξερευνήσετε πιο προηγμένες δυνατότητες της ενότητας χρόνου. Θέλετε να εργαστείτε με ημερομηνίες και ώρες στην Python; Εκτός από τη μονάδα ώρας, μπορείτε να αξιοποιήσετε τη λειτουργικότητα των μονάδων ημερομηνίας ώρας και ημερολογίου.

Στη συνέχεια, μάθετε να υπολογίζετε τη διαφορά ώρας στην Python.⏰