מודול זמן ב- Python 3. שיטות עיקריות, תבניות, דוגמאות

כמעט כל תוכנית משתמשת בזמן. ב-Python פותחה ספרייה נפרדת לכך - זמןמשמש לביצוע מגוון פעולות איתו. כדי לגרום לזה לעבוד, תחילה יש להכריז עליו בתחילת הקוד. השורה הזו משמשת לכך:

זמן יבוא

בואו נבחן אפשרויות שונות כיצד להשתמש במודול זה בצורה נכונה בפועל. 

קביעת מספר השניות מאז התקופה

כדי לבצע משימה זו, יש פונקציה זמן() שלא לוקח פרמטרים. ערך ההחזר שלו הוא כמה שניות חלפו מאז 1 בינואר 1970. בפייתון קוראים לזמן הזה תחילת עידן. לפחות במערכות הפעלה של משפחת יוניקס.

לגבי Windows, התאריך זהה, אבל ייתכנו בעיות עם ערכים שליליים שהיו לפני תאריך זה. 

אזור הזמן המשמש הוא UTC.

זמן יבוא

seconds = time.time()

print("שניות מאז עידן =", שניות)

המורכבות של פונקציה זו היא שהיא לא מציגה בדיוק את התאריך, אלא רק את מספר השניות. כדי להמיר לפורמט המוכר לכולם, עליך להשתמש במידע מדויק. לשם כך, הפונקציה משמשת time.ctime().

החזרת התאריך והשעה בפורמט הרגיל

כדי להחזיר את השעה בפורמט הרגיל, יש שיטה time.ctime(). הסוגריים מציינים משתנה או מספר המציינים את מספר השניות שחלפו מתחילת העידן. שיטה זו מחזירה את כל מאפייני התאריך והשעה, כולל התאריך, השנה, מספר השעות, הדקות, השניות והיום בשבוע.

ניתן להשתמש בפונקציה זו גם ללא ארגומנטים. במקרה זה, הוא מחזיר את התאריך הנוכחי, השעה, וכן הלאה.

הנה קטע קוד שמדגים זאת.

זמן יבוא

print(time.ctime())

יום שלישי 23 באוקטובר 10:18:23 2018

השורה האחרונה היא מה שמודפס לקונסולה שבה פועל המתורגמן של Python. השיטה מפרמטת אוטומטית את מספר השניות שהתקבל לטופס המוכר למשתמש. נכון, כל האלמנטים שתוארו לעיל משמשים לעתים רחוקות. ככלל, אתה צריך לקבל רק את השעה, או רק את התאריך של היום. לשם כך, נעשה שימוש בפונקציה נפרדת - strftime(). אבל לפני שנחשוב על זה, עלינו לנתח את הכיתה time.struct_time.

class time.struct_time

זוהי קטגוריה של טיעונים שניתן לקבל במגוון שיטות. אין לזה אפשרויות. זהו טאפל עם ממשק בעל שם. במילים פשוטות, ניתן לגשת לרכיבים של מחלקה זו הן לפי שם והן לפי מספר אינדקס.

הוא מורכב מהתכונות הבאות.

תשומת הלב! בניגוד למספר שפות תכנות אחרות, כאן החודש יכול לנוע בין 1 ל-12, ולא בין אפס ל-11.

החזרת פורמט מסוים

באמצעות הפונקציה זמן עבודה () אתה יכול לקבל את השנה, החודש, היום, השעה, הדקות, השניות בנפרד ולהחזיר אותם למחרוזת טקסט. לאחר מכן ניתן להדפיס למשתמש באמצעות הפונקציה הדפס () או מעובד אחרת.

כארגומנט, פונקציה יכולה לקחת כל משתנה שלוקח ערך המוחזר על ידי פונקציות אחרות של מודול זה. לדוגמה, אתה יכול להעביר אליו את השעה המקומית (על זה נדון בהמשך), ממנו הוא ישלוף את הנתונים הדרושים.

הנה קטע הקוד שבו אנחנו עושים את זה.

זמן יבוא

named_tuple = time.localtime() # קבל struct_time

time_string = time.strftime(«%m/%d/%Y, %H:%M:%S», named_tuple)

print(time_string)

אם תפעיל את הקוד הזה, התאריך והשעה הנוכחיים יוצגו. ניתן לשנות את הפורמט ורצף האלמנטים. הם כדלקמן:

1. %Y היא השנה.
2. %m הוא החודש.
3. %d – יום.
4. %H - זמן.
5. %M – דקות.
6. %S – שניה.

בהתאם, אתה יכול לעשות את זה כך שהפלט יהיה בלעדי של החודש והיום. כדי לעשות זאת, אתה פשוט לא צריך לתת פקודה כדי להציג את השנה. כלומר, כתוב בנוסחה לעיל כארגומנט %m/%d, וזהו. או להיפך, %d/%m. 

למעשה, מספר המיתרים של מחרוזת גדול בהרבה. הנה טבלה שבה הם מתוארים בפירוט.

דחה שרשור למספר מסוים של שניות

לשם כך, הפונקציה משמשת לישון (). בלוק גדול למדי של משימות תכנות קשור לחלוף הזמן. לפעמים צריך לדחות את השלב הבא לזמן מסוים. לדוגמה, אם אתה צריך אינטראקציה עם מסד נתונים שלוקח פרק זמן מסוים לעיבוד.

כטיעון, השיטה משתמשת בערך המבטא את מספר השניות לעיכוב השלב הבא מהאלגוריתם.

לדוגמה, בקטע זה, ההשהיה היא 10 שניות.

זמן יבוא

הפסקה = 10

הדפס («התוכנית התחילה...»)

time.sleep(pause)

print(str(pause) + » שניות חלפו.»)

כתוצאה מכך, נקבל את זה:

התוכנית התחילה…

עברו 10 שניות.

כפי שאנו יכולים לראות מהפלט, התוכנית מדווחת לראשונה שהיא התחילה. ואחרי עשר שניות היא כתבה שהזמן הזה חלף.

הפונקציה מאפשרת לך לציין את משך ההפסקה באלפיות שניות. לשם כך, אנו משתמשים בערכי שבר של ארגומנט הפונקציה לישון. לדוגמה, 0,1. המשמעות היא שהעיכוב יהיה 100 מילישניות.

קבל זמן מקומי

באמצעות הפונקציה localtime(), התוכנית מקבלת את מספר השניות מאז תחילת העידן באזור זמן מסוים. 

בואו ניתן קוד לדוגמה לבהירות.

זמן יבוא

תוצאה = time.localtime(1575721830)

print("תוצאה:", תוצאה)

print(«nгод:», result.tm_year)

print(«tm_hour:», result.tm_hour)

החזר struct_time ב-UTC בהתבסס על מספר השניות מאז התקופה

משימה זו מושגת באמצעות ה-time.gmtime(). שיטה. זה יהיה ברור יותר אם ניתן דוגמה.

זמן יבוא

תוצאה = time.gmtime(1575721830)

print("תוצאה:", תוצאה)

print(«nгод:», result.tm_year)

print(«tm_hour:», result.tm_hour)

אם תפעיל את רצף הפעולות הזה, תוצג קבוצה של אלמנטים הקשורים לזמן, שנה ואזור זמן.

החזר את מספר השניות מאז תחילת העידן עם המרה אוטומטית לזמן מקומי

אם אתם עומדים בפני משימה כזו, היא מיושמת בשיטה זמן זמן (), שלוקח struct_time. לאחר מכן, הוא מבצע את הפעולה ההפוכה של הפונקציה זמן מקומי(). כלומר, הוא ממיר את הזמן לפי אזור הזמן המקומי למספר השניות שחלפו מתחילת העידן, מותאם לאזור הזמן.

הפונקציות mktime() ו-localtime() שלובות זה בזה. קטע הקוד הזה מדגים זאת בבירור. בואו נסתכל על זה כדי להבין יותר לעומק איך זה עובד. 

זמן יבוא

שניות = 1575721830

# מחזירה struct_time

t = time.localtime(seconds)

print(«t1: «, t)

# מחזיר שניות מ-struct_time

s = time.mktime(t)

print(«ns:», שניות)

אנו רואים שהמשתנה שניות הוקצו 1575721830 שניות מאז התקופה. ראשית, התוכנית מקבלת את התאריך המדויק, השעה ופרמטרים אחרים, בהתבסס על ערך זה, לשים אותו במשתנה t, ולאחר מכן ממירה את תוכנו למשתנה s.

לאחר מכן, מפסיק שורה חדשה ומציג את מספר השניות בקונסולה. אתה יכול לבדוק שזה יהיה אותו מספר שהוקצה למשתנה השניות.

תאריך פלט מ-9 מספרים המתייחסים ל-struct_time

נניח שיש לנו 9 מספרים המייצגים את השנה, החודש, התאריך, היום בשבוע ועוד מספר ערכים, ועלינו לשלב אותם למחרוזת אחת. לשם כך, הפונקציה משמשת asctime(). היא מקבלת או מוכנה struct_time, או כל טופל אחר של 9 ערכים שמייצג אותו דבר. לאחר מכן, מוחזרת מחרוזת שהיא תאריך, שעה ועוד מספר פרמטרים. 

זה מאוד נוח להשתמש בשיטה זו על מנת להביא נתונים שונים שצוינו על ידי המשתמש למשתנה בודד..

לדוגמה, זו עשויה להיות תוכנית שבה המשתמש מציין בנפרד את היום, החודש, השנה, היום בשבוע ונתונים נוספים לגבי הרשמה לאירוע. לאחר מכן, המידע המתקבל מוכנס למאגר ולאחר מכן מופק לאדם אחר המבקש זאת.

קבלת שעה ותאריך על סמך מחרוזת Python

נניח שהמשתמש ציין נתונים שונים, ואנחנו צריכים לשלב אותם לשורה אחת בפורמט שהאדם הזין, ואז לעשות עותק למשתנה אחר, ולבנות אותו מחדש לפורמט סטנדרטי שם. לשם כך, הפונקציה משמשת time.strptime().

זה לוקח משתנה שבו הערך הזה מצוין, ומחזיר את המוכר לנו כבר struct_time.

לשם הבהירות, נכתוב תוכנית כזו.

זמן יבוא

time_string = «15 ביוני, 2019»

result = time.strptime(time_string, «%d %B, %Y»)

הדפס (תוצאה)

נחשו מה יהיה הפלט? נסו לנחש מבלי להסתכל על השורה התחתונה. ואז תבדוק את התשובה.

time.struct_time(tm_year=2019, tm_mon=6, tm_mday=15, tm_hour=0, tm_min=0, tm_sec=0, tm_wday=5, tm_yday=166, tm_isdst=-1)

במילה אחת, העבודה עם תאריכים ושעות ב-Python אינה קשה כלל. זה מספיק לעקוב אחר ההוראות האלה, והכל יסתדר. שימוש בספרייה זמן המשתמש מקבל מספר עצום של הזדמנויות לעבוד עם הזמן, כגון:

1. השעה את הפעלת התוכנית למשך פרק זמן מוגדר.
2. הצג את הזמן שחלף מאז התקופה, בשניות. ניתן להשתמש במידע זה כדי לסכם זמן או לבצע בו פעולות מתמטיות אחרות.
3. המר לפורמט נוח. יתרה מכך, המתכנת עצמו יכול להגדיר אילו אלמנטים יוצגו ובאיזה רצף. 

יש גם מספר אפשרויות אחרות, אבל היום ניתחנו את הבסיסיות ביותר. הם יהיו שימושיים כמעט בכל תוכנית שאיכשהו עובדת עם הזמן. בהצלחה.