צייט מאָדולע אין פּיטהאָן 3. הויפּט מעטהאָדס, טעמפּלאַטעס, ביישפילן

כּמעט קיין פּראָגראַם ניצט צייט. אין פּיטהאָן, אַ באַזונדער ביבליאָטעק איז דעוועלאָפּעד פֿאַר דעם - צייַטגעוויינט צו דורכפירן אַ פאַרשיידנקייַט פון אַקשאַנז מיט אים. צו מאַכן עס אַרבעט, עס מוזן ערשטער זיין דערקלערט אין די אָנהייב פון די קאָד. די שורה איז געניצט פֿאַר דעם:

אַרייַנפיר צייט

זאל ס באַטראַכטן פאַרשידענע אָפּציעס ווי צו נוצן דעם מאָדולע ריכטיק אין פיר. 

באַשטימען די נומער פון סעקונדעס זינט די עפּאָכע

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

ווי פֿאַר Windows, די דאַטע איז די זעלבע, אָבער עס קען זיין פּראָבלעמס מיט נעגאַטיוו וואַלועס וואָס זענען געווען איידער דעם טאָג. 

די צייט זאָנע געניצט איז UTC.

אַרייַנפיר צייט

סעקונדעס = צייט. צייט ()

print ("סעקאָנדס זינט עפּאָכע =", סעקונדעס)

די קאַמפּלעקסיטי פון דעם פֿונקציע איז אַז עס קען נישט ווייַזן פּונקט די דאַטע, אָבער בלויז די נומער פון סעקונדעס. צו גער צו דעם פֿאָרמאַט באַקאַנט צו אַלעמען, איר דאַרפֿן צו נוצן פּינטלעך אינפֿאָרמאַציע. פֿאַר דעם, די פֿונקציע איז געניצט time.ctime().

צוריקקומען די דאַטע, צייט אין די געוויינטלעך פֿאָרמאַט

צו צוריקקומען די צייט אין די געוויינטלעך פֿאָרמאַט, עס איז אַ אופֿן time.ctime(). די בראַקאַץ אָנווייַזן אַ וועריאַבאַל אָדער אַ נומער וואָס ינדיקייץ די נומער פון סעקונדעס וואָס זענען דורכגעגאנגען זינט די אָנהייב פון דער עפּאָכע. דער אופֿן קערט אַלע דאַטע און צייט קעראַקטעריסטיקס, אַרייַנגערעכנט די דאַטע, יאָר, נומער פון שעה, מינוט, סעקונדעס און טאָג פון די וואָך.

די פֿונקציע קענען אויך זיין געוויינט אָן אַרגומענטן. אין דעם פאַל, עס קערט די קראַנט דאַטע, צייט, און אַזוי אויף.

דאָ איז אַ קאָד סניפּאַט וואָס דעמאַנסטרייץ דעם.

אַרייַנפיר צייט

print(time.ctime())

די 23 אקטאבער 10:18:23 2018

די לעצטע שורה איז וואָס איז געדרוקט צו די קאַנסאָול ווו די פּיטהאָן יבערזעצער איז פליסנדיק. דער אופֿן פאָרמאַץ אויטאָמאַטיש די באקומען נומער פון סעקונדעס אין אַ באַניצער-באַקאַנט פאָרעם. אמת, אַלע די אויבן דיסקרייבד עלעמענטן זענען ראַרעלי געניצט. ווי אַ הערשן, איר דאַרפֿן צו באַקומען אָדער בלויז די צייט, אָדער בלויז הייַנט ס טאָג. פֿאַר דעם, אַ באַזונדער פֿונקציע איז געניצט - סטרפטיים(). אבער איידער מיר באַטראַכטן עס, מיר דאַרפֿן צו פּאַרסירן די קלאַס time.struct_time.

class time.struct_time

דאָס איז אַ קאַטעגאָריע פון ​​אַרגומענטן וואָס קענען זיין אנגענומען דורך אַ קייט פון מעטהאָדס. עס האט קיין אָפּציעס. עס איז אַ טופּלע מיט אַ געהייסן צובינד. סימפּלי, די עלעמענטן פון דעם קלאַס קענען זיין אַקסעסט ביידע דורך נאָמען און דורך אינדעקס נומער.

עס באשטייט פון די פאלגענדע אַטריביוץ.

ופמערקזאַמקייַט! ניט ענלעך אַ נומער פון אנדערע פּראָגראַממינג שפראַכן, דאָ דער חודש קען זיין צווישן 1 און 12 און נישט פון נול צו 11.

צוריקקומען אַ ספּעציפיש פֿאָרמאַט

ניצן די פֿונקציע strftime () איר קענען באַקומען די יאָר, חודש, טאָג, שעה, מינוט, סעקונדעס ינדיווידזשואַלי און צוריקקומען זיי צו אַ טעקסט שטריקל. דערנאָך עס קענען זיין געדרוקט צו דער באַניצער ניצן די פונקציע דרוק () אָדער אַנדערש פּראַסעסט.

ווי אַן אַרגומענט, אַ פֿונקציע קענען נעמען קיין וועריאַבאַלז וואָס נעמט אַ ווערט אומגעקערט דורך אנדערע פאַנגקשאַנז פון דעם מאָדולע. פֿאַר בייַשפּיל, איר קענען אַריבערפירן די היגע צייט צו עס (עס וועט זיין דיסקאַסט שפּעטער), פון וואָס עס וועט ציען די נייטיק דאַטן.

דאָ איז די קאָד סניפּאַט ווו מיר טאָן דאָס.

אַרייַנפיר צייט

named_tuple = time.localtime() # באַקומען struct_time

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

דרוק (צייט_שטריקל)

אויב איר לויפן דעם קאָד, די קראַנט דאַטע און צייט וועט זיין געוויזן. די פֿאָרמאַט און סיקוואַנס פון עלעמענטן קענען זיין פארענדערט. זיי זענען ווי גייט:

1. % Y איז די יאָר.
2. %m איז דער חודש.
3. %d – טאָג.
4. %H - צייט.
5. %M – מינוט.
6. %S – רגע.

אַקקאָרדינגלי, איר קענען מאַכן עס אַזוי אַז דער רעזולטאַט איז אויסשליסלעך פון די חודש און טאָג. צו טאָן דאָס, איר פשוט טאָן ניט דאַרפֿן צו געבן אַ באַפֿעל צו ווייַזן די יאָר. דאָס איז, שרייַבן אין די אויבן פאָרמולע ווי אַן אַרגומענט %m/%d, און דאָס איז עס. אָדער וויצע ווערסאַ, %d/%m. 

אין פאַקט, די נומער פון שטריקל ליטעראַלז איז פיל גרעסערע. דאָ איז אַ טיש ווו זיי זענען דיסקרייבד אין דעטאַל.

אָפּלייגן אַ פאָדעם פֿאַר אַ זיכער נומער פון סעקונדעס

פֿאַר דעם, די פֿונקציע איז געניצט שלאָף (). א פערלי גרויס בלאָק פון פּראָגראַממינג טאַסקס איז פארבונדן מיט די דורכפאָר פון צייט. מאל איר האָבן צו אָפּלייגן די ווייַטער שריט פֿאַר אַ זיכער צייט. פֿאַר בייַשפּיל, אויב איר דאַרפֿן צו ינטעראַקט מיט אַ דאַטאַבייס וואָס נעמט אַ זיכער צייט צו פּראָצעס.

ווי אַן אַרגומענט, דער אופֿן ניצט אַ ווערט וואָס יקספּרעסאַז די נומער פון סעקונדעס צו פאַרהאַלטן די ווייַטער שריט פון די אַלגערידאַם.

פֿאַר בייַשפּיל, אין דעם סניפּאַט, די פאַרהאַלטן איז 10 סעקונדעס.

אַרייַנפיר צייט

פּויזע = 10

דרוק ("פּראָגראַם סטאַרטעד ...")

צייט.שלאָפן (פּזע)

print(str(פּויזע) + » סעקונדעס דורכגעגאנגען.»)

ווי אַ רעזולטאַט, מיר וועלן באַקומען דעם:

פּראָגראַם סטאַרטעד…

10 סעקונדעס דורכגעגאנגען.

ווי מיר קענען זען פֿון דער רעזולטאַט, דער פּראָגראַם ערשטער ריפּאָרץ אַז עס איז סטאַרטעד. און נאך צען סעקונדעס האט זי געשריבן אז די צייט איז פארביי.

די פונקציע אַלאַוז איר צו ספּעציפיצירן די געדויער פון די פּויזע אין מיליסעקאַנדז. צו טאָן דאָס, מיר נוצן פראַקשאַנאַל וואַלועס פון די פונקציע אַרגומענט שלאָף. פֿאַר בייַשפּיל, 0,1. דעם מיטל אַז די פאַרהאַלטן וועט זיין 100 מיליסעקאַנדז.

באַקומען היגע צייט

מיט די לאָקאַלטימע () פֿונקציע, דער פּראָגראַם באַקומען די נומער פון סעקונדעס זינט די אָנהייב פון דער עפּאָכע אין אַ ספּעציפיש צייט זאָנע. 

זאל ס געבן אַ בייַשפּיל קאָד פֿאַר קלעריטי.

אַרייַנפיר צייט

רעזולטאַט = time.localtime(1575721830)

print ("רעזולטאַט:", רעזולטאַט)

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

דרוק («טמ_שעה:», רעזולטאַט.טמ_שעה)

צוריקקומען struct_time אין UTC באזירט אויף נומער פון סעקונדעס זינט עפּאָס

דעם אַרבעט איז אַטשיווד ניצן די time.gmtime (). אופֿן. עס וועט זיין קלאָר אויב מיר געבן אַ בייַשפּיל.

אַרייַנפיר צייט

רעזולטאַט = time.gmtime(1575721830)

print ("רעזולטאַט:", רעזולטאַט)

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

דרוק («טמ_שעה:», רעזולטאַט.טמ_שעה)

אויב איר קער אויף דעם סיקוואַנס פון אַקשאַנז, אַ סכום פון עלעמענטן שייַכות צו צייט, יאָר און צייט זאָנע וועט זיין געוויזן.

צוריקקומען די נומער פון סעקונדעס זינט די אָנהייב פון די עפּאָס מיט אָטאַמאַטיק קאַנווערזשאַן צו היגע צייט

אויב איר זענט פייסט מיט אַזאַ אַ אַרבעט, עס איז ימפּלאַמענאַד מיט דעם אופֿן מקטימע(), וואָס נעמט struct_time. נאָך דעם, עס פּערפאָרמז די פאַרקערט קאַמף פון די פֿונקציע localtime(). דאָס הייסט, עס קאַנווערץ די צייט לויט די היגע צייט זאָנע אין די נומער פון סעקונדעס וואָס זענען דורכגעגאנגען זינט די אָנהייב פון די עפּאָכע, אַדזשאַסטיד פֿאַר די צייט זאָנע.

די mktime () און לאָקאַלטימע () פאַנגקשאַנז זענען ענג ינטערטוויינד. דער קאָד סניפּאַט קלאר דעמאַנסטרייץ דעם. זאל ס נעמען אַ קוק אין עס צו פֿאַרשטיין מער דיפּלי ווי עס אַרבעט. 

אַרייַנפיר צייט

סעקונדעס = 1575721830

# קערט struct_time

ט = צייט.לאָקאַלטימע (סעקונדן)

דרוק («ט1: «, ה)

# קערט סעקונדעס פֿון struct_time

s = time.mktime(t)

print(«ns:», סעקונדעס)

מיר זען אַז די בייַטעוודיק סעקונדעס האט שוין אַסיינד 1575721830 סעקונדעס זינט די עפּאָס. ערשטער, די פּראָגראַם געץ די פּינטלעך דאַטע, צייט און אנדערע פּאַראַמעטערס, באזירט אויף דעם ווערט, שטעלן עס אין אַ בייַטעוודיק t, און דעמאָלט קאַנווערץ זייַן אינהאַלט אין אַ בייַטעוודיק s.

נאָך דעם ביץ אַ נייַ שורה און דיספּלייז די נומער פון סעקונדעס אין די קאַנסאָול. איר קענען קאָנטראָלירן אַז עס וועט זיין די זעלבע נומער וואָס איז געווען אַסיינד צו די סעקונדן בייַטעוודיק.

רעזולטאַט דאַטע פון ​​9 נומערן וואָס אָפּשיקן צו struct_time

רעכן מיר האָבן 9 נומערן רעפּריזענטינג די יאָר, חודש, דאַטע, טאָג פון דער וואָך און אַ נומער פון אנדערע וואַלועס, און מיר דאַרפֿן צו פאַרבינדן זיי אין איין שטריקל. פֿאַר דעם, די פֿונקציע איז געניצט asctime (). זי אַקסעפּץ אָדער גרייט סטרוקטור_צייט, אָדער קיין אנדערע טופּלע פון ​​9 וואַלועס וואָס שטייט פֿאַר די זעלבע. נאָך דעם, אַ שטריקל איז אומגעקערט, וואָס איז אַ דאַטע, צייט און אַ נומער פון אנדערע פּאַראַמעטערס. 

עס איז זייער באַקוועם צו נוצן דעם אופֿן אין סדר צו ברענגען דיספּעראַט באַניצער-ספּעסיפיעד דאַטן אין אַ איין בייַטעוודיק..

פֿאַר בייַשפּיל, עס קען זיין אַ פּראָגראַם ווו דער באַניצער ספּעציפיצירט סעפּעראַטלי די טאָג, חודש, יאָר, טאָג פון די וואָך און אנדערע דאַטן וועגן רעגיסטראַציע פֿאַר אַ געשעעניש. נאָך דעם, די אינפֿאָרמאַציע באקומען איז אריין אין די דאַטאַבייס און דעמאָלט ארויס צו אן אנדער מענטש וואס ריקוועס עס.

באַקומען צייט און דאַטע באזירט אויף פּיטהאָן שטריקל

רעכן דער באַניצער האט ספּעסיפיעד דיספּעראַט דאַטן, און מיר דאַרפֿן צו פאַרבינדן זיי אין איין שורה אין דעם פֿאָרמאַט וואָס דער מענטש איז אריין, און דעמאָלט מאַכן אַ קאָפּיע צו אן אנדער בייַטעוודיק, און ריבילד עס אין אַ נאָרמאַל פֿאָרמאַט דאָרט. פֿאַר דעם, די פֿונקציע איז געניצט צייט.סטרפּטיים().

עס נעמט אַ בייַטעוודיק אין וואָס דעם ווערט איז ספּעסיפיעד, און קערט די שוין באַקאַנט צו אונדז struct_time.

פֿאַר קלאָרקייט, מיר וועלן שרייַבן אַזאַ אַ פּראָגראַם.

אַרייַנפיר צייט

צייט_סטרינג = «15 יוני, 2019»

רעזולטאַט = time.strptime (טיים_סטרינג, «% ד % ב, % י»)

דרוק (רעזולטאט)

טרעפן וואָס די רעזולטאַט וועט זיין? פּרובירן צו טרעפן אָן קוקן בייַ די דנאָ שורה. און דעמאָלט טשעק די ענטפער.

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)

אין אַ וואָרט, ארבעטן מיט דאַטעס און צייט אין פּיטהאָן איז נישט שווער. עס איז גענוג צו נאָכפאָלגן די ינסטראַקשאַנז, און אַלץ וועט אַרבעטן אויס. ניצן די ביבליאָטעק צייַט דער באַניצער געץ אַ ריזיק נומער פון אַפּערטונאַטיז צו אַרבעטן מיט צייט, אַזאַ ווי:

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

עס זענען אויך אַ נומער פון אנדערע פּאַסאַבילאַטיז, אָבער הייַנט מיר האָבן אַנאַלייזד די מערסט יקערדיק אָנעס. זיי וועלן קומען אין האַנטיק אין כּמעט קיין פּראָגראַם וואָס עפעס אַרבעט מיט צייט. זאָל זייַנ מיט מאַזל.