เนื้อหา
- การกำหนดจำนวนวินาทีตั้งแต่ยุค
- ส่งคืนวันที่ เวลา ในรูปแบบปกติ
- เวลาเรียน.struct_time
- ส่งคืนรูปแบบเฉพาะ
- เลื่อนกระทู้ไปสักวินาที
- รับเวลาท้องถิ่น
- ส่งคืน struct_time ใน UTC ตามจำนวนวินาทีตั้งแต่ epoch
- ส่งกลับจำนวนวินาทีตั้งแต่เริ่มต้นยุคด้วยการแปลงอัตโนมัติเป็นเวลาท้องถิ่น
- วันที่ส่งออกจากตัวเลข 9 ตัวที่อ้างถึง struct_time
- รับเวลาและวันที่ตามสตริง Python
เกือบทุกโปรแกรมใช้เวลา ใน Python มีการพัฒนาไลบรารีแยกต่างหากสำหรับสิ่งนี้ - เวลาใช้ในการดำเนินการต่างๆ กับมัน เพื่อให้ใช้งานได้ จะต้องประกาศที่จุดเริ่มต้นของโค้ดก่อน บรรทัดนี้ใช้สำหรับสิ่งนี้:
เวลานำเข้า
ลองพิจารณาตัวเลือกต่างๆ เกี่ยวกับวิธีการใช้โมดูลนี้อย่างถูกต้องในทางปฏิบัติ
การกำหนดจำนวนวินาทีตั้งแต่ยุค
เพื่อให้บรรลุภารกิจนี้มีฟังก์ชั่น เวลา() ที่ไม่รับพารามิเตอร์ ค่าที่ส่งคืนคือจำนวนวินาทีที่ผ่านไปตั้งแต่วันที่ 1 มกราคม 1970 ใน Python เวลานี้เรียกว่าจุดเริ่มต้นของยุค อย่างน้อยในระบบปฏิบัติการของตระกูล Unix
สำหรับ Windows วันที่จะเหมือนกัน แต่อาจมีปัญหากับค่าลบที่อยู่ก่อนวันที่นี้
เขตเวลาที่ใช้คือ UTC
เวลานำเข้า
วินาที = time.time()
พิมพ์("วินาทีตั้งแต่ยุค =" วินาที)
ความซับซ้อนของฟังก์ชันนี้คือไม่แสดงวันที่แน่นอน แต่แสดงเฉพาะจำนวนวินาทีเท่านั้น หากต้องการแปลงเป็นรูปแบบที่ทุกคนคุ้นเคย คุณต้องใช้ข้อมูลที่ถูกต้อง สำหรับสิ่งนี้ ฟังก์ชันนี้ถูกใช้ เวลา.ctime().
ส่งคืนวันที่ เวลา ในรูปแบบปกติ
ในการคืนเวลาในรูปแบบปกติมีวิธี เวลา.ctime(). วงเล็บระบุตัวแปรหรือตัวเลขที่ระบุจำนวนวินาทีที่ผ่านไปตั้งแต่เริ่มต้นยุค เมธอดนี้ส่งคืนคุณลักษณะของวันที่และเวลาทั้งหมด รวมถึงวันที่ ปี จำนวนชั่วโมง นาที วินาที และวันในสัปดาห์
ฟังก์ชันนี้ยังใช้ได้โดยไม่มีอาร์กิวเมนต์อีกด้วย ในกรณีนี้ จะส่งกลับวันที่ เวลาปัจจุบัน และอื่นๆ
นี่คือข้อมูลโค้ดที่แสดงสิ่งนี้
เวลานำเข้า
พิมพ์(time.ctime())
อ. 23 ต.ค. 10:18:23 2018
บรรทัดสุดท้ายคือสิ่งที่พิมพ์ไปยังคอนโซลที่ล่าม Python ทำงานอยู่ วิธีการจัดรูปแบบจำนวนวินาทีที่ได้รับโดยอัตโนมัติในรูปแบบที่ผู้ใช้คุ้นเคย จริงอยู่องค์ประกอบทั้งหมดที่อธิบายไว้ข้างต้นไม่ค่อยได้ใช้ ตามกฎแล้ว คุณต้องได้รับเฉพาะเวลาหรือวันที่ของวันนี้เท่านั้น สำหรับสิ่งนี้จะใช้ฟังก์ชันแยกต่างหาก - สตริฟไทม์() แต่ก่อนจะพิจารณาเราต้องแยกวิเคราะห์คลาสก่อน เวลา.struct_time.
เวลาเรียน.struct_time
นี่คือหมวดหมู่ของอาร์กิวเมนต์ที่สามารถยอมรับได้ด้วยวิธีการต่างๆ มันไม่มีตัวเลือกใดๆ เป็น tuple ที่มีอินเทอร์เฟซที่มีชื่อ พูดง่ายๆ ก็คือ องค์ประกอบของคลาสนี้สามารถเข้าถึงได้ทั้งจากชื่อและหมายเลขดัชนี
ประกอบด้วยคุณลักษณะดังต่อไปนี้
ความสนใจ! ต่างจากภาษาโปรแกรมอื่น ๆ จำนวนมาก ที่นี่เดือนสามารถอยู่ในช่วงตั้งแต่ 1 ถึง 12 และไม่ใช่จากศูนย์ถึง 11
ส่งคืนรูปแบบเฉพาะ
การใช้ฟังก์ชัน สตริฟไทม์() คุณสามารถรับปี เดือน วัน ชั่วโมง นาที วินาทีแยกกัน แล้วส่งกลับเป็นสตริงข้อความ จากนั้นสามารถพิมพ์ให้ผู้ใช้ใช้ฟังก์ชันได้ พิมพ์ () หรือแปรรูปเป็นอย่างอื่น
เป็นอาร์กิวเมนต์ ฟังก์ชันสามารถรับตัวแปรใดๆ ก็ได้ที่รับค่าที่ส่งคืนโดยฟังก์ชันอื่นๆ ของโมดูลนี้ ตัวอย่างเช่น คุณสามารถโอนเวลาท้องถิ่นไปยังมันได้ (จะมีการหารือในภายหลัง) ซึ่งจะดึงข้อมูลที่จำเป็นออกมา
นี่คือข้อมูลโค้ดที่เราทำ
เวลานำเข้า
name_tuple = time.localtime() # รับ struct_time
time_string = time.strftime(«%m/%d/%Y, %H:%M:%S», names_tuple)
พิมพ์ (time_string)
หากคุณเรียกใช้รหัสนี้ วันที่และเวลาปัจจุบันจะปรากฏขึ้น รูปแบบและลำดับขององค์ประกอบสามารถเปลี่ยนแปลงได้ พวกเขามีดังนี้:
- %Y คือปี
- %m คือเดือน
- %d – วัน
- %H – เวลา
- %M – นาที
- %S – วินาที
ดังนั้น คุณสามารถสร้างมันขึ้นมาเพื่อให้ผลลัพธ์นั้นเป็นของเดือนและวันเท่านั้น ในการทำเช่นนี้ คุณไม่จำเป็นต้องให้คำสั่งแสดงปี นั่นคือ เขียนในสูตรข้างต้นเป็นอาร์กิวเมนต์ %m/%d และนั่นคือมัน หรือในทางกลับกัน %d/%m
อันที่จริง จำนวนตัวอักษรสตริงนั้นมากกว่ามาก นี่คือตารางที่มีการอธิบายโดยละเอียด
เลื่อนกระทู้ไปสักวินาที
สำหรับสิ่งนี้ ฟังก์ชันนี้ถูกใช้ นอน (). กลุ่มงานเขียนโปรแกรมที่ค่อนข้างใหญ่นั้นสัมพันธ์กับกาลเวลา บางครั้งคุณต้องเลื่อนขั้นตอนต่อไปเป็นช่วงเวลาหนึ่ง ตัวอย่างเช่น หากคุณต้องการโต้ตอบกับฐานข้อมูลที่ใช้เวลาในการประมวลผลเป็นระยะเวลาหนึ่ง
เป็นอาร์กิวเมนต์ วิธีการใช้ค่าที่แสดงจำนวนวินาทีเพื่อชะลอขั้นตอนถัดไปจากอัลกอริทึม
ตัวอย่างเช่น ในตัวอย่างนี้ การหน่วงเวลาคือ 10 วินาที
เวลานำเข้า
หยุดชั่วคราว = 10
พิมพ์(«เริ่มโปรแกรม…»)
time.sleep (หยุดชั่วคราว)
print(str(pause) + » วินาทีที่ผ่านไป»)
เป็นผลให้เราได้รับสิ่งนี้:
เริ่มโปรแกรม…
ผ่านไป 10 วินาที
ดังที่เราเห็นจากผลลัพธ์ โปรแกรมแรกรายงานว่าได้เริ่มต้นขึ้นแล้ว และหลังจากนั้นสิบวินาที เธอเขียนว่าเวลานี้ผ่านไปแล้ว
ฟังก์ชันนี้ช่วยให้คุณระบุระยะเวลาของการหยุดชั่วคราวเป็นมิลลิวินาที ในการทำเช่นนี้เราใช้ค่าเศษส่วนของอาร์กิวเมนต์ของฟังก์ชัน นอน. ตัวอย่างเช่น 0,1 ซึ่งหมายความว่าการหน่วงเวลาจะอยู่ที่ 100 มิลลิวินาที
รับเวลาท้องถิ่น
การใช้ฟังก์ชัน localtime() โปรแกรมจะได้รับจำนวนวินาทีตั้งแต่เริ่มต้นยุคในเขตเวลาที่กำหนด
ให้โค้ดตัวอย่างเพื่อความชัดเจน
เวลานำเข้า
ผลลัพธ์ = time.localtime(1575721830)
พิมพ์("ผลลัพธ์:", ผลลัพธ์)
พิมพ์(«nгод:», result.tm_year)
พิมพ์(«tm_hour:», result.tm_hour)
ส่งคืน struct_time ใน UTC ตามจำนวนวินาทีตั้งแต่ epoch
งานนี้ทำได้โดยใช้ time.gmtime() กระบวนการ. จะชัดเจนขึ้นถ้าเรายกตัวอย่าง
เวลานำเข้า
ผลลัพธ์ = time.gmtime(1575721830)
พิมพ์("ผลลัพธ์:", ผลลัพธ์)
พิมพ์(«nгод:», result.tm_year)
พิมพ์(«tm_hour:», result.tm_hour)
หากคุณเปิดลำดับการดำเนินการนี้ ชุดขององค์ประกอบที่เกี่ยวข้องกับเวลา ปี และเขตเวลาจะปรากฏขึ้น
ส่งกลับจำนวนวินาทีตั้งแต่เริ่มต้นยุคด้วยการแปลงอัตโนมัติเป็นเวลาท้องถิ่น
หากคุณต้องเผชิญกับงานดังกล่าว จะดำเนินการโดยใช้วิธีการ เอ็มเคไทม์()ซึ่งใช้เวลา struct_time. หลังจากนั้นจะทำการย้อนกลับของฟังก์ชัน เวลาท้องถิ่น(). นั่นคือจะแปลงเวลาตามเขตเวลาท้องถิ่นเป็นจำนวนวินาทีที่ผ่านไปตั้งแต่เริ่มต้นยุคซึ่งปรับตามเขตเวลา
ฟังก์ชัน mktime() และ localtime() สัมพันธ์กันอย่างใกล้ชิด ข้อมูลโค้ดนี้แสดงให้เห็นอย่างชัดเจน ลองดูที่มันเพื่อทำความเข้าใจอย่างลึกซึ้งยิ่งขึ้นว่ามันทำงานอย่างไร
เวลานำเข้า
วินาที = 1575721830
# ส่งคืน struct_time
t = time.localtime(วินาที)
พิมพ์(«t1: «, t)
# ส่งคืนวินาทีจาก struct_time
s = time.mktime(เสื้อ)
พิมพ์(«ns:», วินาที)
เราจะเห็นว่าตัวแปร วินาที ได้รับมอบหมาย 1575721830 วินาทีตั้งแต่ยุค ขั้นแรก โปรแกรมจะรับวันที่ เวลา และพารามิเตอร์อื่นๆ ที่แน่นอนตามค่านี้ นำไปใส่ในตัวแปร tแล้วแปลงเนื้อหาเป็นตัวแปร s.
หลังจากนั้นจะขึ้นบรรทัดใหม่และแสดงจำนวนวินาทีในคอนโซล คุณสามารถตรวจสอบได้ว่าจะเป็นตัวเลขเดียวกับที่กำหนดให้กับตัวแปรวินาที
วันที่ส่งออกจากตัวเลข 9 ตัวที่อ้างถึง struct_time
สมมติว่าเรามีตัวเลข 9 ตัวที่แทนปี เดือน วันที่ วันในสัปดาห์ และค่าอื่นๆ อีกจำนวนหนึ่ง และเราจำเป็นต้องรวมเป็นสตริงเดียว สำหรับสิ่งนี้ ฟังก์ชันนี้ถูกใช้ แอสไทม์(). เธอยอมรับหรือพร้อม โครงสร้าง_เวลา, หรือทูเพิลอื่น ๆ ของ 9 ค่าที่แทนค่าเดียวกัน หลังจากนั้น สตริงจะถูกส่งกลับ ซึ่งเป็นวันที่ เวลา และพารามิเตอร์อื่นๆ จำนวนหนึ่ง
เป็นวิธีที่สะดวกมากที่จะใช้วิธีนี้เพื่อนำข้อมูลที่ผู้ใช้ระบุที่แตกต่างกันมาไว้ในตัวแปรเดียว.
ตัวอย่างเช่น อาจเป็นโปรแกรมที่ผู้ใช้ระบุวัน เดือน ปี วันในสัปดาห์ และข้อมูลอื่นๆ เกี่ยวกับการลงทะเบียนสำหรับกิจกรรมแยกต่างหาก หลังจากนั้นข้อมูลที่ได้รับจะถูกป้อนลงในฐานข้อมูลแล้วออกให้กับบุคคลอื่นที่ร้องขอ
รับเวลาและวันที่ตามสตริง Python
สมมติว่าผู้ใช้ระบุข้อมูลที่แตกต่างกัน และเราจำเป็นต้องรวมเป็นบรรทัดเดียวในรูปแบบที่ผู้ใช้ป้อน จากนั้นคัดลอกไปยังตัวแปรอื่น และสร้างใหม่ให้เป็นรูปแบบมาตรฐานที่นั่น สำหรับสิ่งนี้ ฟังก์ชันนี้ถูกใช้ เวลา.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)
การทำงานกับวันที่และเวลาใน Python นั้นไม่ยากเลย ทำตามคำแนะนำเหล่านี้เพียงพอแล้วทุกอย่างจะเรียบร้อย การใช้ห้องสมุด เวลา ผู้ใช้ได้รับโอกาสมากมายในการทำงานกับเวลา เช่น:
- ระงับการทำงานของโปรแกรมตามระยะเวลาที่กำหนด
- แสดงเวลาที่ผ่านไปตั้งแต่ยุคเป็นวินาที ข้อมูลนี้สามารถใช้เพื่อสรุปเวลาหรือดำเนินการทางคณิตศาสตร์อื่นๆ ได้
- แปลงเป็นรูปแบบที่สะดวก นอกจากนี้ โปรแกรมเมอร์เองสามารถกำหนดองค์ประกอบที่จะแสดงและในลำดับใด
นอกจากนี้ยังมีความเป็นไปได้อื่นๆ อีกหลายประการ แต่วันนี้เราได้วิเคราะห์สิ่งพื้นฐานที่สุดแล้ว พวกเขาจะมีประโยชน์ในเกือบทุกโปรแกรมที่ใช้งานได้กับเวลา ขอให้โชคดี.