పైథాన్ 3లో టైమ్ మాడ్యూల్. ప్రధాన పద్ధతులు, టెంప్లేట్లు, ఉదాహరణలు

దాదాపు ఏ కార్యక్రమం అయినా సమయాన్ని ఉపయోగిస్తుంది. పైథాన్‌లో, దీని కోసం ప్రత్యేక లైబ్రరీ అభివృద్ధి చేయబడింది - సమయందానితో వివిధ రకాల చర్యలను చేయడానికి ఉపయోగిస్తారు. ఇది పని చేయడానికి, ఇది మొదట కోడ్ ప్రారంభంలో ప్రకటించబడాలి. ఈ లైన్ దీని కోసం ఉపయోగించబడుతుంది:

దిగుమతి సమయం

ఆచరణలో ఈ మాడ్యూల్ సరిగ్గా ఎలా ఉపయోగించాలో వివిధ ఎంపికలను పరిశీలిద్దాం. 

యుగం నుండి సెకన్ల సంఖ్యను నిర్ణయించడం

ఈ పనిని నెరవేర్చడానికి, ఒక ఫంక్షన్ ఉంది సమయం() ఇది ఏ పారామితులను తీసుకోదు. దాని రిటర్న్ విలువ జనవరి 1, 1970 నుండి ఎన్ని సెకన్లు గడిచిపోయాయి. పైథాన్‌లో, ఈ సమయాన్ని యుగం ప్రారంభం అంటారు. కనీసం Unix కుటుంబం యొక్క ఆపరేటింగ్ సిస్టమ్‌లలో.

విండోస్ విషయానికొస్తే, తేదీ ఒకే విధంగా ఉంటుంది, కానీ ఈ తేదీకి ముందు ఉన్న ప్రతికూల విలువలతో సమస్యలు ఉండవచ్చు. 

ఉపయోగించిన సమయ క్షేత్రం UTC.

దిగుమతి సమయం

సెకన్లు = సమయం. సమయం()

ప్రింట్ (“యుగం నుండి సెకన్లు =”, సెకన్లు)

ఈ ఫంక్షన్ యొక్క సంక్లిష్టత ఏమిటంటే ఇది ఖచ్చితంగా తేదీని ప్రదర్శించదు, కానీ సెకన్ల సంఖ్య మాత్రమే. అందరికీ తెలిసిన ఆకృతికి మార్చడానికి, మీరు ఖచ్చితమైన సమాచారాన్ని ఉపయోగించాలి. దీని కోసం, ఫంక్షన్ ఉపయోగించబడుతుంది time.ctime().

సాధారణ ఫార్మాట్‌లో తేదీ, సమయాన్ని చూపుతోంది

సాధారణ ఆకృతిలో సమయాన్ని తిరిగి ఇవ్వడానికి, ఒక పద్ధతి ఉంది time.ctime(). బ్రాకెట్‌లు యుగం ప్రారంభం నుండి గడిచిన సెకన్ల సంఖ్యను సూచించే వేరియబుల్ లేదా సంఖ్యను సూచిస్తాయి. ఈ పద్ధతి తేదీ, సంవత్సరం, గంటల సంఖ్య, నిమిషాలు, సెకన్లు మరియు వారంలోని రోజుతో సహా అన్ని తేదీ మరియు సమయ లక్షణాలను అందిస్తుంది.

ఈ ఫంక్షన్ వాదనలు లేకుండా కూడా ఉపయోగించవచ్చు. ఈ సందర్భంలో, ఇది ప్రస్తుత తేదీ, సమయం మొదలైనవాటిని అందిస్తుంది.

దీన్ని ప్రదర్శించే కోడ్ స్నిప్పెట్ ఇక్కడ ఉంది.

దిగుమతి సమయం

ప్రింట్(time.ctime())

మంగళ అక్టోబర్ 23 10:18:23 2018

పైథాన్ ఇంటర్‌ప్రెటర్ రన్ అవుతున్న కన్సోల్‌కు ప్రింట్ చేయబడినది చివరి పంక్తి. పద్ధతి స్వయంచాలకంగా స్వీకరించబడిన సెకన్ల సంఖ్యను వినియోగదారు-తెలిసిన రూపంలోకి ఫార్మాట్ చేస్తుంది. నిజమే, పైన వివరించిన అన్ని అంశాలు చాలా అరుదుగా ఉపయోగించబడతాయి. నియమం ప్రకారం, మీరు సమయాన్ని మాత్రమే పొందాలి లేదా నేటి తేదీని మాత్రమే పొందాలి. దీని కోసం, ఒక ప్రత్యేక ఫంక్షన్ ఉపయోగించబడుతుంది - strftime(). కానీ మేము దానిని పరిగణించే ముందు, మేము తరగతిని అన్వయించవలసి ఉంటుంది సమయం.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», నేమ్_టుపుల్)

ప్రింట్ (సమయం_స్ట్రింగ్)

మీరు ఈ కోడ్‌ని అమలు చేస్తే, ప్రస్తుత తేదీ మరియు సమయం ప్రదర్శించబడుతుంది. మూలకాల యొక్క ఆకృతి మరియు క్రమాన్ని మార్చవచ్చు. అవి క్రింది విధంగా ఉన్నాయి:

1. %Y సంవత్సరం.
2. %m అనేది నెల.
3. %d – రోజు.
4. %H - సమయం.
5. %M – నిమిషాలు.
6. %S – రెండవ.

దీని ప్రకారం, మీరు అవుట్‌పుట్ ప్రత్యేకంగా నెల మరియు రోజు ఉండేలా చేయవచ్చు. దీన్ని చేయడానికి, మీరు సంవత్సరాన్ని ప్రదర్శించడానికి కమాండ్ ఇవ్వాల్సిన అవసరం లేదు. అంటే, పై సూత్రంలో %m/%d వాదనగా వ్రాయండి మరియు అంతే. లేదా వైస్ వెర్సా, %d/%m. 

నిజానికి, స్ట్రింగ్ లిటరల్స్ సంఖ్య చాలా పెద్దది. అవి వివరంగా వివరించబడిన పట్టిక ఇక్కడ ఉంది.

థ్రెడ్‌ను నిర్దిష్ట సంఖ్యలో సెకన్ల పాటు వాయిదా వేయండి

దీని కోసం, ఫంక్షన్ ఉపయోగించబడుతుంది నిద్ర (). ప్రోగ్రామింగ్ టాస్క్‌ల యొక్క చాలా పెద్ద బ్లాక్ సమయం గడిచేకొద్దీ సంబంధం కలిగి ఉంటుంది. కొన్నిసార్లు మీరు తదుపరి దశను నిర్దిష్ట సమయానికి వాయిదా వేయాలి. ఉదాహరణకు, మీరు ప్రాసెస్ చేయడానికి కొంత సమయం తీసుకునే డేటాబేస్‌తో ఇంటరాక్ట్ కావాల్సి వస్తే.

వాదనగా, అల్గోరిథం నుండి తదుపరి దశను ఆలస్యం చేయడానికి సెకన్ల సంఖ్యను వ్యక్తీకరించే విలువను పద్ధతి ఉపయోగిస్తుంది.

ఉదాహరణకు, ఈ స్నిప్పెట్‌లో, ఆలస్యం 10 సెకన్లు.

దిగుమతి సమయం

విరామం = 10

ప్రింట్ ("ప్రోగ్రామ్ ప్రారంభించబడింది...")

సమయం.నిద్ర(పాజ్)

ప్రింట్ (str(పాజ్) + » సెకన్లు గడిచాయి.»)

ఫలితంగా, మేము దీన్ని పొందుతాము:

కార్యక్రమం ప్రారంభమైంది…

10 సెకన్లు గడిచాయి.

అవుట్‌పుట్ నుండి మనం చూడగలిగినట్లుగా, ప్రోగ్రామ్ మొదట ప్రారంభించబడిందని నివేదిస్తుంది. మరియు పది సెకన్ల తర్వాత, ఈ సమయం గడిచిపోయిందని ఆమె రాసింది.

మిల్లీసెకన్లలో పాజ్ వ్యవధిని పేర్కొనడానికి ఫంక్షన్ మిమ్మల్ని అనుమతిస్తుంది. దీన్ని చేయడానికి, మేము ఫంక్షన్ ఆర్గ్యుమెంట్ యొక్క పాక్షిక విలువలను ఉపయోగిస్తాము నిద్ర. ఉదాహరణకు, 0,1. అంటే 100 మిల్లీసెకన్ల ఆలస్యం అవుతుంది.

స్థానిక సమయాన్ని పొందండి

లోకల్‌టైమ్() ఫంక్షన్‌ని ఉపయోగించి, ప్రోగ్రామ్ నిర్దిష్ట టైమ్ జోన్‌లో యుగం ప్రారంభమైనప్పటి నుండి సెకన్ల సంఖ్యను పొందుతుంది. 

స్పష్టత కోసం ఒక ఉదాహరణ కోడ్ ఇద్దాం.

దిగుమతి సమయం

ఫలితం = సమయం.స్థానిక సమయం(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 = సమయం.స్థానిక సమయం(సెకన్లు)

ప్రింట్ (“t1: «, t)

# struct_time నుండి సెకన్లు తిరిగి వస్తుంది

s = సమయం.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. అనుకూలమైన ఆకృతికి మార్చండి. అంతేకాకుండా, ప్రోగ్రామర్ స్వయంగా ఏ అంశాలు ప్రదర్శించబడాలి మరియు ఏ క్రమంలో సెట్ చేయవచ్చు. 

అనేక ఇతర అవకాశాలు కూడా ఉన్నాయి, కానీ ఈ రోజు మనం చాలా ప్రాథమికమైన వాటిని విశ్లేషించాము. కాలానుగుణంగా ఏదో ఒకవిధంగా పనిచేసే ఏ కార్యక్రమంలోనైనా అవి ఉపయోగపడతాయి. అదృష్టవంతులు.