មាតិកា
- កំណត់ចំនួនវិនាទីចាប់តាំងពីសម័យ
- ត្រឡប់កាលបរិច្ឆេទ ពេលវេលាក្នុងទម្រង់ធម្មតា។
- class time.struct_time
- ត្រឡប់ទម្រង់ជាក់លាក់
- ពន្យារពេលខ្សែស្រឡាយសម្រាប់ចំនួនវិនាទីជាក់លាក់
- ទទួលបានម៉ោងក្នុងស្រុក
- ត្រឡប់ struct_time ក្នុង UTC ដោយផ្អែកលើចំនួនវិនាទីចាប់តាំងពីសម័យ
- ត្រឡប់ចំនួនវិនាទីចាប់តាំងពីការចាប់ផ្តើមនៃសម័យជាមួយនឹងការបំប្លែងដោយស្វ័យប្រវត្តិទៅម៉ោងក្នុងស្រុក
- កាលបរិច្ឆេទលទ្ធផលពីលេខ 9 ដែលសំដៅទៅលើ struct_time
- ទទួលបានពេលវេលា និងកាលបរិច្ឆេទដោយផ្អែកលើខ្សែអក្សរ Python
ស្ទើរតែកម្មវិធីណាមួយប្រើពេលវេលា។ នៅក្នុង Python បណ្ណាល័យដាច់ដោយឡែកមួយត្រូវបានបង្កើតឡើងសម្រាប់រឿងនេះ - ពេលធ្លាប់ធ្វើសកម្មភាពផ្សេងៗជាមួយវា។ ដើម្បីធ្វើឱ្យវាដំណើរការដំបូងវាត្រូវតែត្រូវបានប្រកាសនៅដើមកូដ។ បន្ទាត់នេះត្រូវបានប្រើសម្រាប់ការនេះ:
ពេលវេលានាំចូល
តោះពិចារណាជម្រើសផ្សេងៗអំពីរបៀបប្រើម៉ូឌុលនេះឱ្យបានត្រឹមត្រូវក្នុងការអនុវត្ត។
កំណត់ចំនួនវិនាទីចាប់តាំងពីសម័យ
ដើម្បីសម្រេចកិច្ចការនេះ មានមុខងារមួយ។ ពេល() ដែលមិនមានប៉ារ៉ាម៉ែត្រ។ តម្លៃត្រឡប់មកវិញរបស់វាគឺប៉ុន្មានវិនាទីបានកន្លងផុតទៅចាប់តាំងពីថ្ងៃទី 1 ខែមករា ឆ្នាំ 1970។ នៅក្នុង Python ពេលនេះត្រូវបានគេហៅថាការចាប់ផ្តើមនៃសម័យមួយ។ យ៉ាងហោចណាស់នៅក្នុងប្រព័ន្ធប្រតិបត្តិការនៃគ្រួសារយូនីក។
សម្រាប់ Windows កាលបរិច្ឆេទគឺដូចគ្នា ប៉ុន្តែអាចមានបញ្ហាជាមួយនឹងតម្លៃអវិជ្ជមានដែលនៅមុនកាលបរិច្ឆេទនេះ។
តំបន់ពេលវេលាដែលប្រើគឺ UTC ។
ពេលវេលានាំចូល
វិនាទី = time.time()
បោះពុម្ព ("វិនាទីចាប់តាំងពីសម័យ =" វិនាទី)
ភាពស្មុគស្មាញនៃមុខងារនេះគឺថាវាមិនបង្ហាញកាលបរិច្ឆេទពិតប្រាកដនោះទេ ប៉ុន្តែមានតែចំនួនវិនាទីប៉ុណ្ណោះ។ ដើម្បីបំប្លែងទៅជាទម្រង់ដែលអ្នកគ្រប់គ្នាស្គាល់ អ្នកត្រូវប្រើព័ត៌មានត្រឹមត្រូវ។ ចំពោះបញ្ហានេះមុខងារត្រូវបានប្រើ time.ctime()
ត្រឡប់កាលបរិច្ឆេទ ពេលវេលាក្នុងទម្រង់ធម្មតា។
ដើម្បីត្រឡប់ពេលវេលាក្នុងទម្រង់ធម្មតា មានវិធីសាស្ត្រមួយ។ time.ctime() តង្កៀបបង្ហាញពីអថេរ ឬលេខដែលបង្ហាញពីចំនួនវិនាទីដែលបានកន្លងផុតទៅចាប់តាំងពីការចាប់ផ្តើមនៃសម័យកាល។ វិធីសាស្រ្តនេះត្រឡប់លក្ខណៈកាលបរិច្ឆេទ និងពេលវេលាទាំងអស់ រួមទាំងកាលបរិច្ឆេទ ឆ្នាំ ចំនួនម៉ោង នាទី វិនាទី និងថ្ងៃនៃសប្តាហ៍។
មុខងារនេះក៏អាចប្រើដោយគ្មានអាគុយម៉ង់ផងដែរ។ ក្នុងករណីនេះ វាត្រឡប់កាលបរិច្ឆេទបច្ចុប្បន្ន ពេលវេលា និងដូច្នេះនៅលើ។
នេះជាអត្ថបទកូដដែលបង្ហាញពីការនេះ។
ពេលវេលានាំចូល
បោះពុម្ព(time.ctime())
ថ្ងៃអង្គារ ទី23 ខែតុលា 10:18:23 2018
បន្ទាត់ចុងក្រោយគឺជាអ្វីដែលត្រូវបានបោះពុម្ពទៅកុងសូលដែលអ្នកបកប្រែ Python កំពុងដំណើរការ។ វិធីសាស្ត្រនេះធ្វើទ្រង់ទ្រាយចំនួនវិនាទីដែលបានទទួលដោយស្វ័យប្រវត្តិទៅក្នុងទម្រង់ដែលអ្នកប្រើប្រាស់ស្គាល់។ ពិត ធាតុទាំងអស់ដែលបានពិពណ៌នាខាងលើគឺកម្រប្រើណាស់។ តាមក្បួនមួយ អ្នកត្រូវទទួលបានតែពេលវេលា ឬមានតែកាលបរិច្ឆេទថ្ងៃនេះប៉ុណ្ណោះ។ ចំពោះបញ្ហានេះមុខងារដាច់ដោយឡែកមួយត្រូវបានប្រើ - strftime () ។ ប៉ុន្តែមុននឹងយើងពិចារណា យើងត្រូវញែកថ្នាក់ time.struct_time ។
class time.struct_time
នេះគឺជាប្រភេទនៃអាគុយម៉ង់ដែលអាចត្រូវបានទទួលយកដោយជួរនៃវិធីសាស្រ្តមួយ។ វាមិនមានជម្រើសណាមួយទេ។ វាគឺជា tuple ដែលមានចំណុចប្រទាក់ដែលមានឈ្មោះ។ និយាយឱ្យសាមញ្ញ ធាតុនៃថ្នាក់នេះអាចចូលបានទាំងដោយឈ្មោះ និងដោយលេខលិបិក្រម។
វាមានគុណលក្ខណៈដូចខាងក្រោម។
យកចិត្តទុកដាក់! មិនដូចភាសាសរសេរកម្មវិធីផ្សេងទៀតទេ នៅទីនេះខែអាចមានចាប់ពីលេខ 1 ដល់ 12 ហើយមិនមែនពីសូន្យដល់លេខ 11 ទេ។
ត្រឡប់ទម្រង់ជាក់លាក់
ការប្រើប្រាស់មុខងារ strftime() អ្នកអាចទទួលបានឆ្នាំ ខែ ថ្ងៃ ម៉ោង នាទី វិនាទីរៀងៗខ្លួន ហើយត្រឡប់ពួកវាទៅខ្សែអក្សរ។ បន្ទាប់មកវាអាចត្រូវបានបោះពុម្ពទៅអ្នកប្រើប្រាស់ដោយប្រើមុខងារ បោះពុម្ព () ឬដំណើរការផ្សេងទៀត។
ជាអាគុយម៉ង់ អនុគមន៍អាចយកអថេរណាមួយដែលយកតម្លៃត្រឡប់ដោយមុខងារផ្សេងទៀតនៃម៉ូឌុលនេះ។ ឧទាហរណ៍ អ្នកអាចផ្ទេរម៉ោងក្នុងស្រុកទៅវា (វានឹងត្រូវបានពិភាក្សានៅពេលក្រោយ) ដែលវានឹងទាញទិន្នន័យចាំបាច់ចេញ។
នេះជាលេខកូដដែលយើងធ្វើវា។
ពេលវេលានាំចូល
named_tuple = time.localtime() # ទទួលបាន struct_time
time_string = time.strftime(«%m/%d/%Y, %H:%M:%S», named_tuple)
print(time_string)
ប្រសិនបើអ្នកដំណើរការកូដនេះ កាលបរិច្ឆេទ និងពេលវេលាបច្ចុប្បន្ននឹងត្រូវបានបង្ហាញ។ ទម្រង់ និងលំដាប់នៃធាតុអាចផ្លាស់ប្តូរបាន។ ពួកគេមានដូចខាងក្រោម:
- % Y គឺជាឆ្នាំ។
- %m គឺជាខែ។
- %d – ថ្ងៃ។
- % H - ពេលវេលា។
- %M – នាទី
- %S – ទីពីរ។
ដូច្នោះហើយអ្នកអាចធ្វើវាបានដើម្បីឱ្យទិន្នផលគឺផ្តាច់មុខនៃខែនិងថ្ងៃ។ ដើម្បីធ្វើដូចនេះអ្នកមិនចាំបាច់ផ្តល់ពាក្យបញ្ជាដើម្បីបង្ហាញឆ្នាំទេ។ នោះគឺសរសេរក្នុងរូបមន្តខាងលើជាអាគុយម៉ង់ %m/%d ហើយនោះហើយជាវា។ ឬផ្ទុយទៅវិញ %d/%m។
តាមពិតចំនួនអក្សរកាត់គឺធំជាង។ នេះគឺជាតារាងមួយដែលពួកគេត្រូវបានពិពណ៌នាលម្អិត។
ពន្យារពេលខ្សែស្រឡាយសម្រាប់ចំនួនវិនាទីជាក់លាក់
ចំពោះបញ្ហានេះមុខងារត្រូវបានប្រើ គេង (). ប្លុកដ៏ធំមួយនៃភារកិច្ចសរសេរកម្មវិធីត្រូវបានផ្សារភ្ជាប់ជាមួយនឹងការឆ្លងកាត់នៃពេលវេលា។ ពេលខ្លះអ្នកត្រូវពន្យារពេលជំហានបន្ទាប់សម្រាប់ពេលវេលាជាក់លាក់មួយ។ ឧទាហរណ៍ ប្រសិនបើអ្នកត្រូវការធ្វើអន្តរកម្មជាមួយមូលដ្ឋានទិន្នន័យដែលត្រូវការពេលវេលាជាក់លាក់មួយដើម្បីដំណើរការ។
ជាអាគុយម៉ង់ វិធីសាស្ត្រប្រើតម្លៃដែលបង្ហាញពីចំនួនវិនាទី ដើម្បីពន្យារជំហានបន្ទាប់ពីក្បួនដោះស្រាយ។
ជាឧទាហរណ៍ ក្នុងអត្ថបទនេះ ការពន្យាពេលគឺ 10 វិនាទី។
ពេលវេលានាំចូល
ផ្អាក = ១០
បោះពុម្ព ("កម្មវិធីបានចាប់ផ្តើម ... ")
time.sleep(ផ្អាក)
បោះពុម្ព (str (ផ្អាក) + » វិនាទីកន្លងផុតទៅ។»)
ជាលទ្ធផលយើងនឹងទទួលបាន៖
កម្មវិធីបានចាប់ផ្តើម…
10 វិនាទីបានកន្លងផុតទៅ។
ដូចដែលយើងអាចមើលឃើញពីលទ្ធផលកម្មវិធីដំបូងរាយការណ៍ថាវាបានចាប់ផ្តើម។ ហើយបន្ទាប់ពីដប់វិនាទីនាងបានសរសេរថាពេលវេលានេះបានកន្លងផុតទៅ។
មុខងារអនុញ្ញាតឱ្យអ្នកបញ្ជាក់រយៈពេលនៃការផ្អាកគិតជាមិល្លីវិនាទី។ ដើម្បីធ្វើដូចនេះយើងប្រើតម្លៃប្រភាគនៃអាគុយម៉ង់មុខងារ គេង ឧទាហរណ៍ 0,1 ។ នេះមានន័យថាការពន្យាពេលនឹងមាន 100 មិល្លីវិនាទី។
ទទួលបានម៉ោងក្នុងស្រុក
ដោយប្រើមុខងារ localtime() កម្មវិធីទទួលបានចំនួនវិនាទីចាប់តាំងពីការចាប់ផ្តើមនៃសម័យនៅក្នុងតំបន់ពេលវេលាជាក់លាក់មួយ។
ចូរយើងផ្តល់ឧទាហរណ៍កូដមួយសម្រាប់ភាពច្បាស់លាស់។
ពេលវេលានាំចូល
លទ្ធផល = time.localtime(1575721830)
បោះពុម្ព ("លទ្ធផល៖" លទ្ធផល)
print(«nгод:», result.tm_year)
print(«tm_hour:», result.tm_hour)
ត្រឡប់ struct_time ក្នុង UTC ដោយផ្អែកលើចំនួនវិនាទីចាប់តាំងពីសម័យ
កិច្ចការនេះត្រូវបានសម្រេចដោយប្រើ time.gmtime()។ វិធីសាស្រ្ត។ វានឹងកាន់តែច្បាស់ប្រសិនបើយើងផ្តល់ឧទាហរណ៍។
ពេលវេលានាំចូល
លទ្ធផល = time.gmtime(1575721830)
បោះពុម្ព ("លទ្ធផល៖" លទ្ធផល)
print(«nгод:», result.tm_year)
print(«tm_hour:», result.tm_hour)
ប្រសិនបើអ្នកបើកលំដាប់នៃសកម្មភាពនេះ នោះសំណុំនៃធាតុដែលទាក់ទងនឹងពេលវេលា ឆ្នាំ និងតំបន់ពេលវេលានឹងត្រូវបានបង្ហាញ។
ត្រឡប់ចំនួនវិនាទីចាប់តាំងពីការចាប់ផ្តើមនៃសម័យជាមួយនឹងការបំប្លែងដោយស្វ័យប្រវត្តិទៅម៉ោងក្នុងស្រុក
ប្រសិនបើអ្នកប្រឈមមុខនឹងកិច្ចការបែបនេះវាត្រូវបានអនុវត្តដោយប្រើវិធីសាស្ត្រ mktime()ដែលត្រូវចំណាយពេល struct_time. បន្ទាប់ពីនោះវាអនុវត្តសកម្មភាពបញ្ច្រាសនៃមុខងារ ម៉ោងក្នុងស្រុក()។ នោះគឺវាបំប្លែងពេលវេលាទៅតាមតំបន់ម៉ោងក្នុងស្រុកទៅជាចំនួនវិនាទីដែលបានកន្លងផុតទៅចាប់តាំងពីការចាប់ផ្តើមនៃសម័យនោះ ដោយកែសម្រួលសម្រាប់តំបន់ពេលវេលា។
មុខងារ mktime() និង localtime() ត្រូវបានទាក់ទងគ្នាយ៉ាងជិតស្និទ្ធ។ អត្ថបទកូដនេះបង្ហាញយ៉ាងច្បាស់អំពីរឿងនេះ។ តោះមើលវាដើម្បីយល់កាន់តែស៊ីជម្រៅពីរបៀបដែលវាដំណើរការ។
ពេលវេលានាំចូល
វិនាទី = 1575721830
# ត្រឡប់ struct_time
t = time.localtime(វិនាទី)
បោះពុម្ព («t1: «, t)
# ត្រឡប់វិនាទីពី struct_time
s = time.mktime(t)
បោះពុម្ព(«ns:», វិនាទី)
យើងឃើញថាអថេរ វិនាទី ត្រូវបានកំណត់ 1575721830 វិនាទីចាប់តាំងពីសម័យ។ ជាដំបូង កម្មវិធីទទួលបានកាលបរិច្ឆេទ ពេលវេលាពិតប្រាកដ និងប៉ារ៉ាម៉ែត្រផ្សេងទៀត ដោយផ្អែកលើតម្លៃនេះ ដាក់វានៅក្នុងអថេរ tហើយបន្ទាប់មកបំប្លែងមាតិការបស់វាទៅជាអថេរ s.
បន្ទាប់ពីនោះវាយចេញពីបន្ទាត់ថ្មី ហើយបង្ហាញចំនួនវិនាទីនៅក្នុងកុងសូល។ អ្នកអាចពិនិត្យមើលថាវានឹងជាលេខដូចគ្នាដែលត្រូវបានកំណត់ទៅអថេរវិនាទី។
កាលបរិច្ឆេទលទ្ធផលពីលេខ 9 ដែលសំដៅទៅលើ struct_time
ឧបមាថាយើងមានលេខចំនួន 9 ដែលតំណាងឱ្យឆ្នាំ ខែ កាលបរិច្ឆេទ ថ្ងៃនៃសប្តាហ៍ និងចំនួននៃតម្លៃផ្សេងទៀត ហើយយើងត្រូវបញ្ចូលវាទៅក្នុងខ្សែតែមួយ។ ចំពោះបញ្ហានេះមុខងារត្រូវបានប្រើ asctime(). នាងទទួលយកឬត្រៀមខ្លួន struct_time, ឬ tuple ផ្សេងទៀតនៃតម្លៃ 9 ដែលតំណាងឱ្យដូចគ្នា។ បន្ទាប់ពីនោះ ខ្សែអក្សរមួយត្រូវបានត្រលប់មកវិញ ដែលជាកាលបរិច្ឆេទ ពេលវេលា និងចំនួនប៉ារ៉ាម៉ែត្រផ្សេងទៀត។
វាងាយស្រួលណាស់ក្នុងការប្រើវិធីសាស្ត្រនេះ ដើម្បីនាំយកទិន្នន័យដែលបានបញ្ជាក់ដោយអ្នកប្រើប្រាស់ខុសគ្នាទៅជាអថេរតែមួយ។.
ឧទាហរណ៍ វាអាចជាកម្មវិធីដែលអ្នកប្រើប្រាស់បញ្ជាក់ដោយឡែកពីគ្នានូវថ្ងៃ ខែ ឆ្នាំ ថ្ងៃនៃសប្តាហ៍ និងទិន្នន័យផ្សេងទៀតទាក់ទងនឹងការចុះឈ្មោះសម្រាប់ព្រឹត្តិការណ៍មួយ។ បន្ទាប់ពីនោះព័ត៌មានដែលទទួលបានត្រូវបានបញ្ចូលទៅក្នុងមូលដ្ឋានទិន្នន័យ ហើយបន្ទាប់មកចេញឱ្យអ្នកផ្សេងដែលស្នើសុំវា។
ទទួលបានពេលវេលា និងកាលបរិច្ឆេទដោយផ្អែកលើខ្សែអក្សរ Python
ឧបមាថាអ្នកប្រើប្រាស់បានបញ្ជាក់ទិន្នន័យមិនស្មើគ្នា ហើយយើងត្រូវបញ្ចូលពួកវាទៅក្នុងបន្ទាត់មួយក្នុងទម្រង់ដែលបុគ្គលនោះបានបញ្ចូល ហើយបន្ទាប់មកចម្លងទៅអថេរផ្សេងទៀត ហើយបង្កើតវាឡើងវិញជាទម្រង់ស្តង់ដារនៅទីនោះ។ ចំពោះបញ្ហានេះមុខងារត្រូវបានប្រើ time.strptime() ។
វាត្រូវការអថេរដែលតម្លៃនេះត្រូវបានបញ្ជាក់ ហើយត្រឡប់តម្លៃដែលធ្លាប់ស្គាល់រួចហើយមកយើង struct_time.
សម្រាប់ភាពច្បាស់លាស់យើងនឹងសរសេរកម្មវិធីបែបនេះ។
ពេលវេលានាំចូល
time_string = « ១៥ មិថុនា ២០១៩ »
លទ្ធផល = 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 មិនពិបាកទាល់តែសោះ។ វាគ្រប់គ្រាន់ហើយក្នុងការធ្វើតាមការណែនាំទាំងនេះ ហើយអ្វីៗនឹងដំណើរការ។ ការប្រើប្រាស់បណ្ណាល័យ ពេល អ្នកប្រើប្រាស់ទទួលបានឱកាសជាច្រើនសម្រាប់ធ្វើការជាមួយនឹងពេលវេលា ដូចជា៖
- ផ្អាកការប្រតិបត្តិកម្មវិធីសម្រាប់រយៈពេលជាក់លាក់មួយ។
- បង្ហាញពេលវេលាដែលបានកន្លងផុតទៅតាំងពីសម័យកាល គិតជាវិនាទី។ ព័ត៌មាននេះអាចត្រូវបានប្រើដើម្បីសង្ខេបពេលវេលា ឬអនុវត្តប្រតិបត្តិការគណិតវិទ្យាផ្សេងទៀតនៅលើវា។
- បម្លែងទៅជាទម្រង់ងាយស្រួល។ ជាងនេះទៅទៀត អ្នកសរសេរកម្មវិធីខ្លួនឯងអាចកំណត់ថាតើធាតុណាមួយនឹងត្រូវបានបង្ហាញ និងនៅក្នុងលំដាប់ណា។
វាក៏មានលទ្ធភាពមួយចំនួនផ្សេងទៀតដែរ ប៉ុន្តែថ្ងៃនេះ យើងបានធ្វើការវិភាគជាមូលដ្ឋានបំផុត។ ពួកគេនឹងងាយស្រួលក្នុងកម្មវិធីស្ទើរតែទាំងអស់ដែលដំណើរការជាមួយពេលវេលា។ សំណាងល្អ។