ម៉ូឌុលពេលវេលានៅក្នុង Python 3. វិធីសាស្ត្រសំខាន់ៗ គំរូ ឧទាហរណ៍

ស្ទើរតែកម្មវិធីណាមួយប្រើពេលវេលា។ នៅក្នុង 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 ដែលមានចំណុចប្រទាក់ដែលមានឈ្មោះ។ និយាយឱ្យសាមញ្ញ ធាតុនៃថ្នាក់នេះអាចចូលបានទាំងដោយឈ្មោះ និងដោយលេខលិបិក្រម។

វាមានគុណលក្ខណៈដូចខាងក្រោម។ម៉ូឌុលពេលវេលានៅក្នុង Python 3. វិធីសាស្ត្រសំខាន់ៗ គំរូ ឧទាហរណ៍

យកចិត្តទុកដាក់! មិនដូចភាសាសរសេរកម្មវិធីផ្សេងទៀតទេ នៅទីនេះខែអាចមានចាប់ពីលេខ 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)

ប្រសិនបើអ្នកដំណើរការកូដនេះ កាលបរិច្ឆេទ និងពេលវេលាបច្ចុប្បន្ននឹងត្រូវបានបង្ហាញ។ ទម្រង់ និងលំដាប់នៃធាតុអាចផ្លាស់ប្តូរបាន។ ពួកគេមានដូចខាងក្រោម:

  1. % Y គឺជាឆ្នាំ។
  2. %m គឺជាខែ។
  3. %d – ថ្ងៃ។
  4. % H - ពេលវេលា។
  5. %M – នាទី
  6. %S – ទីពីរ។

ដូច្នោះហើយអ្នកអាចធ្វើវាបានដើម្បីឱ្យទិន្នផលគឺផ្តាច់មុខនៃខែនិងថ្ងៃ។ ដើម្បីធ្វើដូចនេះអ្នកមិនចាំបាច់ផ្តល់ពាក្យបញ្ជាដើម្បីបង្ហាញឆ្នាំទេ។ នោះគឺសរសេរក្នុងរូបមន្តខាងលើជាអាគុយម៉ង់ %m/%d ហើយនោះហើយជាវា។ ឬផ្ទុយទៅវិញ %d/%m។ 

តាមពិតចំនួនអក្សរកាត់គឺធំជាង។ នេះគឺជាតារាងមួយដែលពួកគេត្រូវបានពិពណ៌នាលម្អិត។ម៉ូឌុលពេលវេលានៅក្នុង Python 3. វិធីសាស្ត្រសំខាន់ៗ គំរូ ឧទាហរណ៍

ពន្យារពេល​ខ្សែ​ស្រឡាយ​សម្រាប់​ចំនួន​វិនាទី​ជាក់លាក់

ចំពោះបញ្ហានេះមុខងារត្រូវបានប្រើ គេង (). ប្លុកដ៏ធំមួយនៃភារកិច្ចសរសេរកម្មវិធីត្រូវបានផ្សារភ្ជាប់ជាមួយនឹងការឆ្លងកាត់នៃពេលវេលា។ ពេលខ្លះអ្នកត្រូវពន្យារពេលជំហានបន្ទាប់សម្រាប់ពេលវេលាជាក់លាក់មួយ។ ឧទាហរណ៍ ប្រសិនបើអ្នកត្រូវការធ្វើអន្តរកម្មជាមួយមូលដ្ឋានទិន្នន័យដែលត្រូវការពេលវេលាជាក់លាក់មួយដើម្បីដំណើរការ។

ជាអាគុយម៉ង់ វិធីសាស្ត្រប្រើតម្លៃដែលបង្ហាញពីចំនួនវិនាទី ដើម្បីពន្យារជំហានបន្ទាប់ពីក្បួនដោះស្រាយ។

ជាឧទាហរណ៍ ក្នុងអត្ថបទនេះ ការពន្យាពេលគឺ 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 មិនពិបាកទាល់តែសោះ។ វាគ្រប់គ្រាន់ហើយក្នុងការធ្វើតាមការណែនាំទាំងនេះ ហើយអ្វីៗនឹងដំណើរការ។ ការប្រើប្រាស់បណ្ណាល័យ ពេល អ្នកប្រើប្រាស់ទទួលបានឱកាសជាច្រើនសម្រាប់ធ្វើការជាមួយនឹងពេលវេលា ដូចជា៖

  1. ផ្អាកការប្រតិបត្តិកម្មវិធីសម្រាប់រយៈពេលជាក់លាក់មួយ។
  2. បង្ហាញពេលវេលាដែលបានកន្លងផុតទៅតាំងពីសម័យកាល គិតជាវិនាទី។ ព័ត៌មាននេះអាចត្រូវបានប្រើដើម្បីសង្ខេបពេលវេលា ឬអនុវត្តប្រតិបត្តិការគណិតវិទ្យាផ្សេងទៀតនៅលើវា។
  3. បម្លែងទៅជាទម្រង់ងាយស្រួល។ ជាងនេះទៅទៀត អ្នកសរសេរកម្មវិធីខ្លួនឯងអាចកំណត់ថាតើធាតុណាមួយនឹងត្រូវបានបង្ហាញ និងនៅក្នុងលំដាប់ណា។ 

វាក៏មានលទ្ធភាពមួយចំនួនផ្សេងទៀតដែរ ប៉ុន្តែថ្ងៃនេះ យើងបានធ្វើការវិភាគជាមូលដ្ឋានបំផុត។ ពួកគេ​នឹង​ងាយស្រួល​ក្នុង​កម្មវិធី​ស្ទើរតែ​ទាំងអស់​ដែល​ដំណើរការ​ជាមួយ​ពេលវេលា។ សំណាងល្អ។

សូមផ្ដល់យោបល់