ಪೈಥಾನ್ 3 ರಲ್ಲಿ ಟೈಮ್ ಮಾಡ್ಯೂಲ್. ಮುಖ್ಯ ವಿಧಾನಗಳು, ಟೆಂಪ್ಲೇಟ್ಗಳು, ಉದಾಹರಣೆಗಳು

ಬಹುತೇಕ ಯಾವುದೇ ಪ್ರೋಗ್ರಾಂ ಸಮಯವನ್ನು ಬಳಸುತ್ತದೆ. ಪೈಥಾನ್‌ನಲ್ಲಿ, ಇದಕ್ಕಾಗಿ ಪ್ರತ್ಯೇಕ ಗ್ರಂಥಾಲಯವನ್ನು ಅಭಿವೃದ್ಧಿಪಡಿಸಲಾಗಿದೆ - ಸಮಯಅದರೊಂದಿಗೆ ವಿವಿಧ ಕ್ರಿಯೆಗಳನ್ನು ಮಾಡಲು ಬಳಸಲಾಗುತ್ತದೆ. ಅದನ್ನು ಕೆಲಸ ಮಾಡಲು, ಅದನ್ನು ಮೊದಲು ಕೋಡ್‌ನ ಆರಂಭದಲ್ಲಿ ಘೋಷಿಸಬೇಕು. ಈ ಸಾಲನ್ನು ಇದಕ್ಕಾಗಿ ಬಳಸಲಾಗುತ್ತದೆ:

ಆಮದು ಸಮಯ

ಆಚರಣೆಯಲ್ಲಿ ಈ ಮಾಡ್ಯೂಲ್ ಅನ್ನು ಹೇಗೆ ಸರಿಯಾಗಿ ಬಳಸುವುದು ಎಂಬುದರ ಕುರಿತು ವಿವಿಧ ಆಯ್ಕೆಗಳನ್ನು ಪರಿಗಣಿಸೋಣ. 

ಯುಗದಿಂದ ಸೆಕೆಂಡುಗಳ ಸಂಖ್ಯೆಯನ್ನು ನಿರ್ಧರಿಸುವುದು

ಈ ಕಾರ್ಯವನ್ನು ಸಾಧಿಸಲು, ಒಂದು ಕಾರ್ಯವಿದೆ ಸಮಯ() ಇದು ಯಾವುದೇ ನಿಯತಾಂಕಗಳನ್ನು ತೆಗೆದುಕೊಳ್ಳುವುದಿಲ್ಲ. ಇದರ ರಿಟರ್ನ್ ಮೌಲ್ಯವು ಜನವರಿ 1, 1970 ರಿಂದ ಎಷ್ಟು ಸೆಕೆಂಡುಗಳು ಕಳೆದಿವೆ ಎಂಬುದು. ಪೈಥಾನ್‌ನಲ್ಲಿ, ಈ ಸಮಯವನ್ನು ಯುಗ ಪ್ರಾರಂಭ ಎಂದು ಕರೆಯಲಾಗುತ್ತದೆ. ಕನಿಷ್ಠ ಯುನಿಕ್ಸ್ ಕುಟುಂಬದ ಆಪರೇಟಿಂಗ್ ಸಿಸ್ಟಂಗಳಲ್ಲಿ.

ವಿಂಡೋಸ್‌ಗೆ ಸಂಬಂಧಿಸಿದಂತೆ, ದಿನಾಂಕವು ಒಂದೇ ಆಗಿರುತ್ತದೆ, ಆದರೆ ಈ ದಿನಾಂಕದ ಮೊದಲು ಇದ್ದ ನಕಾರಾತ್ಮಕ ಮೌಲ್ಯಗಳೊಂದಿಗೆ ಸಮಸ್ಯೆಗಳಿರಬಹುದು. 

ಬಳಸಿದ ಸಮಯ ವಲಯ ಯುಟಿಸಿ.

ಆಮದು ಸಮಯ

ಸೆಕೆಂಡುಗಳು = ಸಮಯ. ಸಮಯ()

ಮುದ್ರಣ ("ಯುಗದಿಂದ ಸೆಕೆಂಡುಗಳು =", ಸೆಕೆಂಡುಗಳು)

ಈ ಕಾರ್ಯದ ಸಂಕೀರ್ಣತೆಯು ನಿಖರವಾಗಿ ದಿನಾಂಕವನ್ನು ಪ್ರದರ್ಶಿಸುವುದಿಲ್ಲ, ಆದರೆ ಸೆಕೆಂಡುಗಳ ಸಂಖ್ಯೆಯನ್ನು ಮಾತ್ರ ಪ್ರದರ್ಶಿಸುತ್ತದೆ. ಎಲ್ಲರಿಗೂ ಪರಿಚಿತವಾಗಿರುವ ಸ್ವರೂಪಕ್ಕೆ ಪರಿವರ್ತಿಸಲು, ನೀವು ನಿಖರವಾದ ಮಾಹಿತಿಯನ್ನು ಬಳಸಬೇಕಾಗುತ್ತದೆ. ಇದಕ್ಕಾಗಿ, ಕಾರ್ಯವನ್ನು ಬಳಸಲಾಗುತ್ತದೆ time.ctime().

ಸಾಮಾನ್ಯ ಸ್ವರೂಪದಲ್ಲಿ ದಿನಾಂಕ, ಸಮಯವನ್ನು ಹಿಂತಿರುಗಿಸಲಾಗುತ್ತಿದೆ

ಸಾಮಾನ್ಯ ಸ್ವರೂಪದಲ್ಲಿ ಸಮಯವನ್ನು ಹಿಂದಿರುಗಿಸಲು, ಒಂದು ವಿಧಾನವಿದೆ time.ctime(). ಬ್ರಾಕೆಟ್‌ಗಳು ವೇರಿಯಬಲ್ ಅಥವಾ ಸಂಖ್ಯೆಯನ್ನು ಸೂಚಿಸುತ್ತವೆ, ಇದು ಯುಗ ಪ್ರಾರಂಭದಿಂದ ಕಳೆದ ಸೆಕೆಂಡುಗಳ ಸಂಖ್ಯೆಯನ್ನು ಸೂಚಿಸುತ್ತದೆ. ಈ ವಿಧಾನವು ದಿನಾಂಕ, ವರ್ಷ, ಗಂಟೆಗಳ ಸಂಖ್ಯೆ, ನಿಮಿಷಗಳು, ಸೆಕೆಂಡುಗಳು ಮತ್ತು ವಾರದ ದಿನ ಸೇರಿದಂತೆ ಎಲ್ಲಾ ದಿನಾಂಕ ಮತ್ತು ಸಮಯದ ಗುಣಲಕ್ಷಣಗಳನ್ನು ಹಿಂದಿರುಗಿಸುತ್ತದೆ.

ಈ ಕಾರ್ಯವನ್ನು ವಾದಗಳಿಲ್ಲದೆಯೂ ಬಳಸಬಹುದು. ಈ ಸಂದರ್ಭದಲ್ಲಿ, ಇದು ಪ್ರಸ್ತುತ ದಿನಾಂಕ, ಸಮಯ ಮತ್ತು ಮುಂತಾದವುಗಳನ್ನು ಹಿಂದಿರುಗಿಸುತ್ತದೆ.

ಇದನ್ನು ಪ್ರದರ್ಶಿಸುವ ಕೋಡ್ ತುಣುಕು ಇಲ್ಲಿದೆ.

ಆಮದು ಸಮಯ

ಮುದ್ರಣ(time.ctime())

ಮಂಗಳವಾರ ಅಕ್ಟೋಬರ್ 23 10:18:23 2018

ಪೈಥಾನ್ ಇಂಟರ್ಪ್ರಿಟರ್ ಚಾಲನೆಯಲ್ಲಿರುವ ಕನ್ಸೋಲ್‌ಗೆ ಮುದ್ರಿತವಾದದ್ದು ಕೊನೆಯ ಸಾಲು. ವಿಧಾನವು ಸ್ವಯಂಚಾಲಿತವಾಗಿ ಸ್ವೀಕರಿಸಿದ ಸೆಕೆಂಡುಗಳ ಸಂಖ್ಯೆಯನ್ನು ಬಳಕೆದಾರ-ಪರಿಚಿತ ರೂಪದಲ್ಲಿ ಫಾರ್ಮ್ಯಾಟ್ ಮಾಡುತ್ತದೆ. ನಿಜ, ಮೇಲೆ ವಿವರಿಸಿದ ಎಲ್ಲಾ ಅಂಶಗಳನ್ನು ವಿರಳವಾಗಿ ಬಳಸಲಾಗುತ್ತದೆ. ನಿಯಮದಂತೆ, ನೀವು ಸಮಯವನ್ನು ಮಾತ್ರ ಪಡೆಯಬೇಕು ಅಥವಾ ಇಂದಿನ ದಿನಾಂಕವನ್ನು ಮಾತ್ರ ಪಡೆಯಬೇಕು. ಇದಕ್ಕಾಗಿ, ಪ್ರತ್ಯೇಕ ಕಾರ್ಯವನ್ನು ಬಳಸಲಾಗುತ್ತದೆ - strftime (). ಆದರೆ ನಾವು ಅದನ್ನು ಪರಿಗಣಿಸುವ ಮೊದಲು, ನಾವು ವರ್ಗವನ್ನು ಪಾರ್ಸ್ ಮಾಡಬೇಕಾಗಿದೆ time.struct_time.

ತರಗತಿ ಸಮಯ.struct_time

ಇದು ವಾದಗಳ ಒಂದು ವರ್ಗವಾಗಿದ್ದು ಇದನ್ನು ಹಲವಾರು ವಿಧಾನಗಳಿಂದ ಸ್ವೀಕರಿಸಬಹುದು. ಇದು ಯಾವುದೇ ಆಯ್ಕೆಗಳನ್ನು ಹೊಂದಿಲ್ಲ. ಇದು ಹೆಸರಿಸಲಾದ ಇಂಟರ್ಫೇಸ್ನೊಂದಿಗೆ ಟ್ಯೂಪಲ್ ಆಗಿದೆ. ಸರಳವಾಗಿ ಹೇಳುವುದಾದರೆ, ಈ ವರ್ಗದ ಅಂಶಗಳನ್ನು ಹೆಸರು ಮತ್ತು ಸೂಚ್ಯಂಕ ಸಂಖ್ಯೆಯ ಮೂಲಕ ಪ್ರವೇಶಿಸಬಹುದು.

ಇದು ಈ ಕೆಳಗಿನ ಗುಣಲಕ್ಷಣಗಳನ್ನು ಒಳಗೊಂಡಿದೆ.

ಗಮನ! ಹಲವಾರು ಇತರ ಪ್ರೋಗ್ರಾಮಿಂಗ್ ಭಾಷೆಗಳಿಗಿಂತ ಭಿನ್ನವಾಗಿ, ಇಲ್ಲಿ ತಿಂಗಳು 1 ರಿಂದ 12 ರವರೆಗೆ ಇರುತ್ತದೆ ಮತ್ತು ಶೂನ್ಯದಿಂದ 11 ರವರೆಗೆ ಅಲ್ಲ.

ನಿರ್ದಿಷ್ಟ ಸ್ವರೂಪವನ್ನು ಹಿಂತಿರುಗಿಸಲಾಗುತ್ತಿದೆ

ಕಾರ್ಯವನ್ನು ಬಳಸುವುದು strftime() ನೀವು ವರ್ಷ, ತಿಂಗಳು, ದಿನ, ಗಂಟೆ, ನಿಮಿಷಗಳು, ಸೆಕೆಂಡುಗಳನ್ನು ಪ್ರತ್ಯೇಕವಾಗಿ ಪಡೆಯಬಹುದು ಮತ್ತು ಅವುಗಳನ್ನು ಪಠ್ಯ ಸ್ಟ್ರಿಂಗ್‌ಗೆ ಹಿಂತಿರುಗಿಸಬಹುದು. ನಂತರ ಅದನ್ನು ಕಾರ್ಯವನ್ನು ಬಳಸಿಕೊಂಡು ಬಳಕೆದಾರರಿಗೆ ಮುದ್ರಿಸಬಹುದು ಮುದ್ರಿಸಿ () ಅಥವಾ ಇಲ್ಲದಿದ್ದರೆ ಸಂಸ್ಕರಿಸಲಾಗುತ್ತದೆ.

ಒಂದು ವಾದದಂತೆ, ಈ ಮಾಡ್ಯೂಲ್‌ನ ಇತರ ಕಾರ್ಯಗಳಿಂದ ಹಿಂತಿರುಗಿದ ಮೌಲ್ಯವನ್ನು ತೆಗೆದುಕೊಳ್ಳುವ ಯಾವುದೇ ವೇರಿಯೇಬಲ್ ಅನ್ನು ಕಾರ್ಯವು ತೆಗೆದುಕೊಳ್ಳಬಹುದು. ಉದಾಹರಣೆಗೆ, ನೀವು ಸ್ಥಳೀಯ ಸಮಯವನ್ನು ಅದಕ್ಕೆ ವರ್ಗಾಯಿಸಬಹುದು (ಅದನ್ನು ನಂತರ ಚರ್ಚಿಸಲಾಗುವುದು), ಇದರಿಂದ ಅದು ಅಗತ್ಯ ಡೇಟಾವನ್ನು ಹೊರತೆಗೆಯುತ್ತದೆ.

ನಾವು ಮಾಡುವ ಕೋಡ್ ತುಣುಕು ಇಲ್ಲಿದೆ.

ಆಮದು ಸಮಯ

name_tuple = time.localtime() # get struct_time

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

ಮುದ್ರಣ (ಸಮಯ_ಸ್ಟ್ರಿಂಗ್)

ನೀವು ಈ ಕೋಡ್ ಅನ್ನು ರನ್ ಮಾಡಿದರೆ, ಪ್ರಸ್ತುತ ದಿನಾಂಕ ಮತ್ತು ಸಮಯವನ್ನು ಪ್ರದರ್ಶಿಸಲಾಗುತ್ತದೆ. ಅಂಶಗಳ ಸ್ವರೂಪ ಮತ್ತು ಅನುಕ್ರಮವನ್ನು ಬದಲಾಯಿಸಬಹುದು. ಅವು ಈ ಕೆಳಗಿನಂತಿವೆ:

1. %Y ವರ್ಷವಾಗಿದೆ.
2. %m ತಿಂಗಳು.
3. %d - ದಿನ.
4. %H - ಸಮಯ.
5. %M - ನಿಮಿಷಗಳು.
6. %S - ಎರಡನೇ.

ಅಂತೆಯೇ, ನೀವು ಅದನ್ನು ಮಾಡಬಹುದು ಇದರಿಂದ ಔಟ್‌ಪುಟ್ ಪ್ರತ್ಯೇಕವಾಗಿ ತಿಂಗಳು ಮತ್ತು ದಿನವಾಗಿರುತ್ತದೆ. ಇದನ್ನು ಮಾಡಲು, ವರ್ಷವನ್ನು ಪ್ರದರ್ಶಿಸಲು ನೀವು ಆಜ್ಞೆಯನ್ನು ನೀಡುವ ಅಗತ್ಯವಿಲ್ಲ. ಅಂದರೆ, ಮೇಲಿನ ಸೂತ್ರದಲ್ಲಿ ಆರ್ಗ್ಯುಮೆಂಟ್ %m/%d ಎಂದು ಬರೆಯಿರಿ ಮತ್ತು ಅಷ್ಟೆ. ಅಥವಾ ಪ್ರತಿಯಾಗಿ, %d/%m. 

ವಾಸ್ತವವಾಗಿ, ಸ್ಟ್ರಿಂಗ್ ಅಕ್ಷರಗಳ ಸಂಖ್ಯೆ ಹೆಚ್ಚು ದೊಡ್ಡದಾಗಿದೆ. ಅವುಗಳನ್ನು ವಿವರವಾಗಿ ವಿವರಿಸುವ ಟೇಬಲ್ ಇಲ್ಲಿದೆ.

ನಿರ್ದಿಷ್ಟ ಸಂಖ್ಯೆಯ ಸೆಕೆಂಡುಗಳವರೆಗೆ ಥ್ರೆಡ್ ಅನ್ನು ಮುಂದೂಡಿ

ಇದಕ್ಕಾಗಿ, ಕಾರ್ಯವನ್ನು ಬಳಸಲಾಗುತ್ತದೆ ನಿದ್ರೆ (). ಪ್ರೋಗ್ರಾಮಿಂಗ್ ಕಾರ್ಯಗಳ ಸಾಕಷ್ಟು ದೊಡ್ಡ ಬ್ಲಾಕ್ ಸಮಯದ ಅಂಗೀಕಾರದೊಂದಿಗೆ ಸಂಬಂಧಿಸಿದೆ. ಕೆಲವೊಮ್ಮೆ ನೀವು ಮುಂದಿನ ಹಂತವನ್ನು ನಿರ್ದಿಷ್ಟ ಸಮಯದವರೆಗೆ ಮುಂದೂಡಬೇಕಾಗುತ್ತದೆ. ಉದಾಹರಣೆಗೆ, ಪ್ರಕ್ರಿಯೆಗೊಳಿಸಲು ನಿರ್ದಿಷ್ಟ ಸಮಯವನ್ನು ತೆಗೆದುಕೊಳ್ಳುವ ಡೇಟಾಬೇಸ್‌ನೊಂದಿಗೆ ನೀವು ಸಂವಹನ ನಡೆಸಬೇಕಾದರೆ.

ಒಂದು ವಾದದಂತೆ, ವಿಧಾನವು ಅಲ್ಗಾರಿದಮ್‌ನಿಂದ ಮುಂದಿನ ಹಂತವನ್ನು ವಿಳಂಬಗೊಳಿಸಲು ಸೆಕೆಂಡುಗಳ ಸಂಖ್ಯೆಯನ್ನು ವ್ಯಕ್ತಪಡಿಸುವ ಮೌಲ್ಯವನ್ನು ಬಳಸುತ್ತದೆ.

ಉದಾಹರಣೆಗೆ, ಈ ತುಣುಕಿನಲ್ಲಿ, ವಿಳಂಬವು 10 ಸೆಕೆಂಡುಗಳು.

ಆಮದು ಸಮಯ

ವಿರಾಮ = 10

ಮುದ್ರಿಸು ("ಪ್ರೋಗ್ರಾಂ ಪ್ರಾರಂಭವಾಯಿತು...")

ಸಮಯ.ನಿದ್ರೆ (ವಿರಾಮ)

ಮುದ್ರಣ(str(ವಿರಾಮ) + »ಸೆಕೆಂಡ್‌ಗಳು ಕಳೆದಿವೆ.»)

ಪರಿಣಾಮವಾಗಿ, ನಾವು ಇದನ್ನು ಪಡೆಯುತ್ತೇವೆ:

ಕಾರ್ಯಕ್ರಮ ಪ್ರಾರಂಭವಾಯಿತು...

10 ಸೆಕೆಂಡುಗಳು ಕಳೆದವು.

ನಾವು ಔಟ್ಪುಟ್ನಿಂದ ನೋಡುವಂತೆ, ಪ್ರೋಗ್ರಾಂ ಮೊದಲು ಅದು ಪ್ರಾರಂಭವಾಗಿದೆ ಎಂದು ವರದಿ ಮಾಡುತ್ತದೆ. ಮತ್ತು ಹತ್ತು ಸೆಕೆಂಡುಗಳ ನಂತರ, ಈ ಸಮಯ ಕಳೆದಿದೆ ಎಂದು ಅವಳು ಬರೆದಳು.

ವಿರಾಮದ ಅವಧಿಯನ್ನು ಮಿಲಿಸೆಕೆಂಡ್‌ಗಳಲ್ಲಿ ನಿರ್ದಿಷ್ಟಪಡಿಸಲು ಕಾರ್ಯವು ನಿಮಗೆ ಅನುಮತಿಸುತ್ತದೆ. ಇದನ್ನು ಮಾಡಲು, ನಾವು ಫಂಕ್ಷನ್ ಆರ್ಗ್ಯುಮೆಂಟ್ನ ಭಾಗಶಃ ಮೌಲ್ಯಗಳನ್ನು ಬಳಸುತ್ತೇವೆ ನಿದ್ರೆ. ಉದಾಹರಣೆಗೆ, 0,1. ಇದರರ್ಥ ವಿಳಂಬವು 100 ಮಿಲಿಸೆಕೆಂಡುಗಳಾಗಿರುತ್ತದೆ.

ಸ್ಥಳೀಯ ಸಮಯವನ್ನು ಪಡೆಯಿರಿ

ಸ್ಥಳೀಯ ಸಮಯ() ಕಾರ್ಯವನ್ನು ಬಳಸಿಕೊಂಡು, ಪ್ರೋಗ್ರಾಂ ನಿರ್ದಿಷ್ಟ ಸಮಯ ವಲಯದಲ್ಲಿ ಯುಗ ಪ್ರಾರಂಭವಾದಾಗಿನಿಂದ ಸೆಕೆಂಡುಗಳ ಸಂಖ್ಯೆಯನ್ನು ಪಡೆಯುತ್ತದೆ. 

ಸ್ಪಷ್ಟತೆಗಾಗಿ ಉದಾಹರಣೆ ಕೋಡ್ ಅನ್ನು ನೀಡೋಣ.

ಆಮದು ಸಮಯ

ಫಲಿತಾಂಶ = time.localtime(1575721830)

ಮುದ್ರಣ ("ಫಲಿತಾಂಶ:", ಫಲಿತಾಂಶ)

ಪ್ರಿಂಟ್ ("nгод:", result.tm_year)

ಪ್ರಿಂಟ್ («tm_hour:», result.tm_hour)

ಯುಗದಿಂದ ಸೆಕೆಂಡುಗಳ ಸಂಖ್ಯೆಯನ್ನು ಆಧರಿಸಿ UTC ಯಲ್ಲಿ struct_time ಹಿಂತಿರುಗಿಸಿ

ಈ ಕೆಲಸವನ್ನು time.gmtime() ಬಳಸಿ ಸಾಧಿಸಲಾಗುತ್ತದೆ. ವಿಧಾನ. ನಾವು ಉದಾಹರಣೆ ನೀಡಿದರೆ ಅದು ಸ್ಪಷ್ಟವಾಗುತ್ತದೆ.

ಆಮದು ಸಮಯ

ಫಲಿತಾಂಶ = time.gmtime(1575721830)

ಮುದ್ರಣ ("ಫಲಿತಾಂಶ:", ಫಲಿತಾಂಶ)

ಪ್ರಿಂಟ್ ("nгод:", result.tm_year)

ಪ್ರಿಂಟ್ («tm_hour:», result.tm_hour)

ನೀವು ಈ ಕ್ರಮಗಳ ಅನುಕ್ರಮವನ್ನು ಆನ್ ಮಾಡಿದರೆ, ಸಮಯ, ವರ್ಷ ಮತ್ತು ಸಮಯ ವಲಯಕ್ಕೆ ಸಂಬಂಧಿಸಿದ ಅಂಶಗಳ ಒಂದು ಸೆಟ್ ಅನ್ನು ಪ್ರದರ್ಶಿಸಲಾಗುತ್ತದೆ.

ಸ್ಥಳೀಯ ಸಮಯಕ್ಕೆ ಸ್ವಯಂಚಾಲಿತ ಪರಿವರ್ತನೆಯೊಂದಿಗೆ ಯುಗ ಪ್ರಾರಂಭವಾದಾಗಿನಿಂದ ಸೆಕೆಂಡುಗಳ ಸಂಖ್ಯೆಯನ್ನು ಹಿಂತಿರುಗಿಸಿ

ನೀವು ಅಂತಹ ಕೆಲಸವನ್ನು ಎದುರಿಸಿದರೆ, ಅದನ್ನು ವಿಧಾನವನ್ನು ಬಳಸಿಕೊಂಡು ಕಾರ್ಯಗತಗೊಳಿಸಲಾಗುತ್ತದೆ mktime(), ಇದು ತೆಗೆದುಕೊಳ್ಳುತ್ತದೆ struct_time. ಅದರ ನಂತರ, ಇದು ಕ್ರಿಯೆಯ ಹಿಮ್ಮುಖ ಕ್ರಿಯೆಯನ್ನು ನಿರ್ವಹಿಸುತ್ತದೆ ಸ್ಥಳೀಯ ಸಮಯ(). ಅಂದರೆ, ಇದು ಸ್ಥಳೀಯ ಸಮಯ ವಲಯದ ಪ್ರಕಾರ ಸಮಯವನ್ನು ಯುಗದ ಪ್ರಾರಂಭದಿಂದ ಕಳೆದ ಸೆಕೆಂಡುಗಳ ಸಂಖ್ಯೆಗೆ ಪರಿವರ್ತಿಸುತ್ತದೆ, ಸಮಯ ವಲಯಕ್ಕೆ ಸರಿಹೊಂದಿಸುತ್ತದೆ.

mktime() ಮತ್ತು localtime() ಕಾರ್ಯಗಳು ನಿಕಟವಾಗಿ ಹೆಣೆದುಕೊಂಡಿವೆ. ಈ ಕೋಡ್ ತುಣುಕು ಇದನ್ನು ಸ್ಪಷ್ಟವಾಗಿ ತೋರಿಸುತ್ತದೆ. ಇದು ಹೇಗೆ ಕಾರ್ಯನಿರ್ವಹಿಸುತ್ತದೆ ಎಂಬುದನ್ನು ಹೆಚ್ಚು ಆಳವಾಗಿ ಅರ್ಥಮಾಡಿಕೊಳ್ಳಲು ಅದನ್ನು ನೋಡೋಣ. 

ಆಮದು ಸಮಯ

ಸೆಕೆಂಡುಗಳು = 1575721830

# struct_time ಹಿಂತಿರುಗಿಸುತ್ತದೆ

t = ಸಮಯ. ಸ್ಥಳೀಯ ಸಮಯ(ಸೆಕೆಂಡ್‌ಗಳು)

ಮುದ್ರಣ (“ಟಿ1: «, ಟಿ)

# struct_time ನಿಂದ ಸೆಕೆಂಡುಗಳನ್ನು ಹಿಂತಿರುಗಿಸುತ್ತದೆ

s = time.mktime(t)

ಮುದ್ರಿಸು ("ns:", ಸೆಕೆಂಡುಗಳು)

ವೇರಿಯಬಲ್ ಎಂದು ನಾವು ನೋಡುತ್ತೇವೆ ಸೆಕೆಂಡುಗಳ ಯುಗದಿಂದ 1575721830 ಸೆಕೆಂಡುಗಳನ್ನು ನಿಗದಿಪಡಿಸಲಾಗಿದೆ. ಮೊದಲಿಗೆ, ಪ್ರೋಗ್ರಾಂ ನಿಖರವಾದ ದಿನಾಂಕ, ಸಮಯ ಮತ್ತು ಇತರ ನಿಯತಾಂಕಗಳನ್ನು ಪಡೆಯುತ್ತದೆ, ಈ ಮೌಲ್ಯವನ್ನು ಆಧರಿಸಿ, ಅದನ್ನು ವೇರಿಯಬಲ್ನಲ್ಲಿ ಇರಿಸಿ t, ತದನಂತರ ಅದರ ವಿಷಯಗಳನ್ನು ವೇರಿಯೇಬಲ್ ಆಗಿ ಪರಿವರ್ತಿಸುತ್ತದೆ s.

ಅದರ ನಂತರ ಹೊಸ ಸಾಲನ್ನು ಬೀಟ್ ಮಾಡುತ್ತದೆ ಮತ್ತು ಕನ್ಸೋಲ್‌ನಲ್ಲಿ ಸೆಕೆಂಡುಗಳ ಸಂಖ್ಯೆಯನ್ನು ಪ್ರದರ್ಶಿಸುತ್ತದೆ. ಇದು ಸೆಕೆಂಡುಗಳ ವೇರಿಯಬಲ್‌ಗೆ ನಿಯೋಜಿಸಲಾದ ಅದೇ ಸಂಖ್ಯೆಯಾಗಿರುತ್ತದೆ ಎಂದು ನೀವು ಪರಿಶೀಲಿಸಬಹುದು.

struct_time ಅನ್ನು ಉಲ್ಲೇಖಿಸುವ 9 ಸಂಖ್ಯೆಗಳಿಂದ ಔಟ್‌ಪುಟ್ ದಿನಾಂಕ

ನಾವು ವರ್ಷ, ತಿಂಗಳು, ದಿನಾಂಕ, ವಾರದ ದಿನ ಮತ್ತು ಇತರ ಹಲವಾರು ಮೌಲ್ಯಗಳನ್ನು ಪ್ರತಿನಿಧಿಸುವ 9 ಸಂಖ್ಯೆಗಳನ್ನು ಹೊಂದಿದ್ದೇವೆ ಎಂದು ಭಾವಿಸೋಣ ಮತ್ತು ನಾವು ಅವುಗಳನ್ನು ಒಂದು ಸ್ಟ್ರಿಂಗ್ ಆಗಿ ಸಂಯೋಜಿಸಬೇಕಾಗಿದೆ. ಇದಕ್ಕಾಗಿ, ಕಾರ್ಯವನ್ನು ಬಳಸಲಾಗುತ್ತದೆ asctime(). ಅವಳು ಸ್ವೀಕರಿಸುತ್ತಾಳೆ ಅಥವಾ ಸಿದ್ಧಳಾಗುತ್ತಾಳೆ struct_time, ಅಥವಾ ಅದೇ 9 ಮೌಲ್ಯಗಳ ಯಾವುದೇ ಇತರ ಟ್ಯೂಪಲ್. ಅದರ ನಂತರ, ಸ್ಟ್ರಿಂಗ್ ಅನ್ನು ಹಿಂತಿರುಗಿಸಲಾಗುತ್ತದೆ, ಇದು ದಿನಾಂಕ, ಸಮಯ ಮತ್ತು ಹಲವಾರು ಇತರ ನಿಯತಾಂಕಗಳು. 

ವಿಭಿನ್ನ ಬಳಕೆದಾರ-ನಿರ್ದಿಷ್ಟ ಡೇಟಾವನ್ನು ಒಂದೇ ವೇರಿಯೇಬಲ್ ಆಗಿ ತರಲು ಈ ವಿಧಾನವನ್ನು ಬಳಸುವುದು ತುಂಬಾ ಅನುಕೂಲಕರವಾಗಿದೆ..

ಉದಾಹರಣೆಗೆ, ಬಳಕೆದಾರರು ದಿನ, ತಿಂಗಳು, ವರ್ಷ, ವಾರದ ದಿನ ಮತ್ತು ಈವೆಂಟ್‌ಗಾಗಿ ನೋಂದಣಿಗೆ ಸಂಬಂಧಿಸಿದ ಇತರ ಡೇಟಾವನ್ನು ಪ್ರತ್ಯೇಕವಾಗಿ ನಿರ್ದಿಷ್ಟಪಡಿಸುವ ಪ್ರೋಗ್ರಾಂ ಆಗಿರಬಹುದು. ಅದರ ನಂತರ, ಸ್ವೀಕರಿಸಿದ ಮಾಹಿತಿಯನ್ನು ಡೇಟಾಬೇಸ್‌ಗೆ ನಮೂದಿಸಲಾಗುತ್ತದೆ ಮತ್ತು ನಂತರ ಅದನ್ನು ವಿನಂತಿಸುವ ಇನ್ನೊಬ್ಬ ವ್ಯಕ್ತಿಗೆ ನೀಡಲಾಗುತ್ತದೆ.

ಪೈಥಾನ್ ಸ್ಟ್ರಿಂಗ್ ಅನ್ನು ಆಧರಿಸಿ ಸಮಯ ಮತ್ತು ದಿನಾಂಕವನ್ನು ಪಡೆಯಲಾಗುತ್ತಿದೆ

ಬಳಕೆದಾರರು ವಿಭಿನ್ನ ಡೇಟಾವನ್ನು ನಿರ್ದಿಷ್ಟಪಡಿಸಿದ್ದಾರೆ ಎಂದು ಭಾವಿಸೋಣ ಮತ್ತು ನಾವು ಅವುಗಳನ್ನು ವ್ಯಕ್ತಿ ನಮೂದಿಸಿದ ಸ್ವರೂಪದಲ್ಲಿ ಒಂದು ಸಾಲಿನಲ್ಲಿ ಸಂಯೋಜಿಸಬೇಕು ಮತ್ತು ನಂತರ ಮತ್ತೊಂದು ವೇರಿಯಬಲ್‌ಗೆ ನಕಲು ಮಾಡಿ ಮತ್ತು ಅದನ್ನು ಅಲ್ಲಿ ಪ್ರಮಾಣಿತ ಸ್ವರೂಪಕ್ಕೆ ಮರುನಿರ್ಮಾಣ ಮಾಡಬೇಕಾಗುತ್ತದೆ. ಇದಕ್ಕಾಗಿ, ಕಾರ್ಯವನ್ನು ಬಳಸಲಾಗುತ್ತದೆ time.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. ಅನುಕೂಲಕರ ಸ್ವರೂಪಕ್ಕೆ ಪರಿವರ್ತಿಸಿ. ಇದಲ್ಲದೆ, ಪ್ರೋಗ್ರಾಮರ್ ಸ್ವತಃ ಯಾವ ಅಂಶಗಳನ್ನು ಪ್ರದರ್ಶಿಸಬೇಕು ಮತ್ತು ಯಾವ ಅನುಕ್ರಮದಲ್ಲಿ ಹೊಂದಿಸಬಹುದು. 

ಇನ್ನೂ ಹಲವಾರು ಸಾಧ್ಯತೆಗಳಿವೆ, ಆದರೆ ಇಂದು ನಾವು ಅತ್ಯಂತ ಮೂಲಭೂತವಾದವುಗಳನ್ನು ವಿಶ್ಲೇಷಿಸಿದ್ದೇವೆ. ಸಮಯದೊಂದಿಗೆ ಹೇಗಾದರೂ ಕೆಲಸ ಮಾಡುವ ಯಾವುದೇ ಪ್ರೋಗ್ರಾಂನಲ್ಲಿ ಅವು ಸೂಕ್ತವಾಗಿ ಬರುತ್ತವೆ. ಒಳ್ಳೆಯದಾಗಲಿ.