დროის მოდული Python 3-ში. ძირითადი მეთოდები, შაბლონები, მაგალითები

თითქმის ნებისმიერი პროგრამა იყენებს დროს. პითონში ამისთვის შეიქმნა ცალკე ბიბლიოთეკა - დროგამოიყენება მასთან სხვადასხვა მოქმედებების შესასრულებლად. იმისთვის, რომ ის იმუშაოს, ჯერ უნდა გამოცხადდეს კოდის დასაწყისში. ეს ხაზი გამოიყენება ამისათვის:

იმპორტის დრო

მოდით განვიხილოთ სხვადასხვა ვარიანტები, თუ როგორ გამოვიყენოთ ეს მოდული სწორად პრაქტიკაში. 

ეპოქიდან წამების რაოდენობის განსაზღვრა

ამ ამოცანის შესასრულებლად არის ფუნქცია დრო() რომელიც არ იღებს პარამეტრებს. მისი დაბრუნების მნიშვნელობა არის რამდენი წამი გავიდა 1 წლის 1970 იანვრიდან. პითონში ამ დროს ეპოქის დაწყებას უწოდებენ. ყოველ შემთხვევაში Unix ოჯახის ოპერაციულ სისტემებში.

რაც შეეხება Windows-ს, თარიღი იგივეა, მაგრამ შეიძლება იყოს პრობლემები ამ თარიღამდე არსებულ უარყოფით მნიშვნელობებთან. 

გამოყენებული დროის ზონა არის UTC.

იმპორტის დრო

წამი = დრო.დრო()

ბეჭდვა ("წამები ეპოქიდან =", წამი)

ამ ფუნქციის სირთულე ის არის, რომ ის არ აჩვენებს ზუსტად თარიღს, არამედ მხოლოდ წამების რაოდენობას. ყველასთვის ნაცნობ ფორმატში გადასაყვანად საჭიროა ზუსტი ინფორმაციის გამოყენება. ამისათვის გამოიყენება ფუნქცია დრო.ctime().

თარიღის, დროის დაბრუნება ჩვეულ ფორმატში

დროის ჩვეულ ფორმატში დასაბრუნებლად, არსებობს მეთოდი დრო.ctime(). ფრჩხილებში მითითებულია ცვლადი ან რიცხვი, რომელიც მიუთითებს ეპოქის დაწყებიდან გასული წამების რაოდენობაზე. ეს მეთოდი აბრუნებს თარიღისა და დროის ყველა მახასიათებელს, მათ შორის თარიღს, წელიწადს, საათების რაოდენობას, წუთებს, წამებს და კვირის დღეებს.

ამ ფუნქციის გამოყენება ასევე შესაძლებელია არგუმენტების გარეშე. ამ შემთხვევაში, ის აბრუნებს მიმდინარე თარიღს, დროს და ა.შ.

აქ არის კოდის ფრაგმენტი, რომელიც ამას აჩვენებს.

იმპორტის დრო

ბეჭდვა (time.ctime ())

სამ ოქტომბერი 23 10:18:23 2018 წ

ბოლო სტრიქონი არის ის, რაც იბეჭდება კონსოლზე, სადაც მუშაობს პითონის ინტერპრეტატორი. მეთოდი ავტომატურად აფორმებს მიღებულ წამების რაოდენობას მომხმარებლისთვის ნაცნობ ფორმაში. მართალია, ზემოთ აღწერილი ყველა ელემენტი იშვიათად გამოიყენება. როგორც წესი, თქვენ უნდა მიიღოთ ან მხოლოდ დრო, ან მხოლოდ დღევანდელი თარიღი. ამისათვის გამოიყენება ცალკე ფუნქცია - strftime(). მაგრამ სანამ მას განვიხილავთ, ჩვენ უნდა გავაანალიზოთ კლასი დრო.struct_time.

კლასის დრო.struct_time

ეს არის არგუმენტების კატეგორია, რომელიც შეიძლება იქნას მიღებული სხვადასხვა მეთოდებით. არავითარი ვარიანტი არ აქვს. ეს არის ტუპლი დასახელებული ინტერფეისით. მარტივად რომ ვთქვათ, ამ კლასის ელემენტებზე წვდომა შესაძლებელია როგორც სახელით, ასევე ინდექსის ნომრით.

იგი შედგება შემდეგი ატრიბუტებისაგან.დროის მოდული Python 3-ში. ძირითადი მეთოდები, შაბლონები, მაგალითები

ყურადღება! სხვა პროგრამირების ენებისგან განსხვავებით, აქ თვე შეიძლება იყოს 1-დან 12-მდე და არა ნულიდან 11-მდე.

კონკრეტული ფორმატის დაბრუნება

ფუნქციის გამოყენებით strftime () შეგიძლიათ ინდივიდუალურად მიიღოთ წელი, თვე, დღე, საათი, წუთი, წამი და დააბრუნოთ ისინი ტექსტის სტრიქონში. შემდეგ ის შეიძლება დაიბეჭდოს მომხმარებლისთვის ფუნქციის გამოყენებით ბეჭდვა () ან სხვაგვარად დამუშავებული.

არგუმენტად, ფუნქციას შეუძლია მიიღოს ნებისმიერი ცვლადი, რომელიც მიიღებს ამ მოდულის სხვა ფუნქციების მიერ დაბრუნებულ მნიშვნელობას. მაგალითად, შეგიძლიათ გადაიტანოთ მას ადგილობრივი დრო (მას მოგვიანებით განვიხილავთ), საიდანაც ის ამოიღებს საჭირო მონაცემებს.

აქ არის კოდის ნაწყვეტი, სადაც ამას ვაკეთებთ.

იმპორტის დრო

named_tuple = time.localtime() # get 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. 

სინამდვილეში, სიმებიანი ლიტერალების რაოდენობა გაცილებით დიდია. აქ არის ცხრილი, სადაც ისინი დეტალურად არის აღწერილი.დროის მოდული Python 3-ში. ძირითადი მეთოდები, შაბლონები, მაგალითები

გადადეთ თემა გარკვეული წამით

ამისათვის გამოიყენება ფუნქცია ძილი (). პროგრამირების ამოცანების საკმაოდ დიდი ბლოკი დაკავშირებულია დროის მსვლელობასთან. ზოგჯერ თქვენ უნდა გადადოთ შემდეგი ნაბიჯი გარკვეული დროით. მაგალითად, თუ გჭირდებათ მონაცემთა ბაზასთან ურთიერთობა, რომლის დამუშავებას გარკვეული დრო სჭირდება.

არგუმენტად მეთოდი იყენებს მნიშვნელობას, რომელიც გამოხატავს წამების რაოდენობას ალგორითმიდან შემდეგი ნაბიჯის გადადების მიზნით.

მაგალითად, ამ ფრაგმენტში დაგვიანება არის 10 წამი.

იმპორტის დრო

პაუზა = 10

ბეჭდვა ("პროგრამა დაიწყო...")

დრო.ძილი (პაუზა)

print(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 = დრო.ადგილობრივი დრო(წამები)

ბეჭდვა («t1: «, t)

# აბრუნებს წამს struct_time-დან

s = time.mktime(t)

ბეჭდვა («ns:», წამი)

ჩვენ ვხედავთ, რომ ცვლადი წამში ეპოქიდან მინიჭებული აქვს 1575721830 წამი. პირველი, პროგრამა იღებს ზუსტ თარიღს, დროს და სხვა პარამეტრებს, ამ მნიშვნელობიდან გამომდინარე, ჩასვით ცვლადში t, და შემდეგ გარდაქმნის მის შინაარსს ცვლადად s.

ამის შემდეგ სცემს ახალ ხაზს და აჩვენებს წამების რაოდენობას კონსოლში. შეგიძლიათ შეამოწმოთ, რომ ეს იქნება იგივე რიცხვი, რომელიც მინიჭებული იყო წამების ცვლადზე.

გამომავალი თარიღი 9 რიცხვიდან, რომლებიც ეხება struct_time-ს

დავუშვათ, რომ გვაქვს 9 რიცხვი, რომელიც წარმოადგენს წელიწადს, თვეს, თარიღს, კვირის დღეს და სხვა მნიშვნელობებს და უნდა გავაერთიანოთ ისინი ერთ სტრიქონში. ამისათვის გამოიყენება ფუნქცია asctime(). ის იღებს ან მზად არის struct_time, ან 9 მნიშვნელობის ნებისმიერი სხვა ტოპი, რომელიც იგივეა. ამის შემდეგ ბრუნდება სტრიქონი, რომელიც არის თარიღი, დრო და რიგი სხვა პარამეტრები. 

ძალიან მოსახერხებელია ამ მეთოდის გამოყენება მომხმარებლის მიერ მითითებული განსხვავებული მონაცემების ერთ ცვლადში მოსაყვანად..

მაგალითად, ეს შეიძლება იყოს პროგრამა, სადაც მომხმარებელი ცალ-ცალკე აზუსტებს დღეს, თვეს, წელიწადს, კვირის დღეს და სხვა მონაცემებს ღონისძიების რეგისტრაციასთან დაკავშირებით. ამის შემდეგ მიღებული ინფორმაცია შეიტანება მონაცემთა ბაზაში და შემდეგ გადაეცემა სხვა პირს, ვინც ამას ითხოვს.

დროისა და თარიღის მიღება პითონის სტრიქონზე დაყრდნობით

დავუშვათ, მომხმარებელმა მიუთითა განსხვავებული მონაცემები და ჩვენ უნდა გავაერთიანოთ ისინი ერთ სტრიქონში იმ ფორმატში, რომელიც ადამიანმა შეიყვანა, შემდეგ გადავიღოთ ასლი სხვა ცვლადში და ავვაშენოთ იგი სტანდარტულ ფორმატში. ამისათვის გამოიყენება ფუნქცია დრო.strptime().

ის იღებს ცვლადს, რომელშიც მითითებულია ეს მნიშვნელობა და აბრუნებს ჩვენთვის უკვე ნაცნობს struct_time.

სიცხადისთვის ჩვენ დავწერთ ასეთ პროგრამას.

იმპორტის დრო

time_string = «15 ივნისი, 2019»

შედეგი = 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)

ერთი სიტყვით, პითონში თარიღებთან და დროებთან მუშაობა სულაც არ არის რთული. საკმარისია მიჰყვეთ ამ ინსტრუქციებს და ყველაფერი გამოვა. ბიბლიოთეკის გამოყენება დრო მომხმარებელი იღებს უამრავ შესაძლებლობებს დროში მუშაობისთვის, როგორიცაა:

  1. შეაჩერეთ პროგრამის შესრულება განსაზღვრული დროით.
  2. აჩვენე ეპოქიდან გასული დრო, წამებში. ეს ინფორმაცია შეიძლება გამოყენებულ იქნას დროის შესაჯამებლად ან მასზე სხვა მათემატიკური ოპერაციების შესასრულებლად.
  3. გადაიყვანეთ მოსახერხებელ ფორმატში. უფრო მეტიც, თავად პროგრამისტს შეუძლია დააყენოს რომელი ელემენტები იქნება ნაჩვენები და რა თანმიმდევრობით. 

ასევე არსებობს მრავალი სხვა შესაძლებლობა, მაგრამ დღეს ჩვენ გავაანალიზეთ ყველაზე ძირითადი. ისინი გამოგადგებათ თითქმის ნებისმიერ პროგრამაში, რომელიც გარკვეულწილად მუშაობს დროსთან ერთად. Წარმატებები.

დატოვე პასუხი