కొన్ని సమయాల్లో, మా ప్రోగ్రామ్ లేదా మా ప్రోగ్రామ్ యొక్క విభాగాలు కొద్ది వ్యవధి తర్వాత అమలు చేయాల్సిన అవసరం ఉంది. ఈ పనిని అప్రయత్నంగా చేస్తుంది time.sleep () ఫంక్షన్ . టిఅతని వ్యాసం దాని పనితీరుతో పాటు ఈ ఫంక్షన్ యొక్క కార్యాచరణను వివరిస్తుంది.
కొనసాగడానికి ముందు, ఈ వ్యాసంలో ఉన్న అంశాలను శీఘ్రంగా చూద్దాం:
ప్రారంభిద్దాం. :)
పైథాన్ time.sleep () ను ఎందుకు ఉపయోగించాలి?
మేము ప్రోగ్రామ్ ప్రవాహాన్ని నిలిపివేయాలనుకుంటున్న పరిస్థితిలో స్లీప్ ఫంక్షన్ చాలా ముఖ్యమైన పాత్ర పోషిస్తుంది మరియు ఇతర మరణశిక్షలు జరగనివ్వండి. ఈ ఫంక్షన్ పైథాన్ అనగా 2 మరియు 3 యొక్క రెండు వెర్షన్లలో నిర్వచించబడింది.ఇది పైథాన్ యొక్క టైమ్ మాడ్యూల్‌కు చెందినది. ఇది ప్రాథమికంగా అమలుకు ఆలస్యాన్ని జోడిస్తుంది మరియు ఇది ప్రస్తుత థ్రెడ్‌ను మాత్రమే పాజ్ చేస్తుంది మరియు మొత్తం ప్రోగ్రామ్ కాదు.
సమయం మాడ్యూల్
పైథాన్ టైమ్ మాడ్యూల్‌లో పైథాన్ టైమ్.స్లీప్ () ఫంక్షన్ ఉంది. దీన్ని ఉపయోగించుకునే ముందు , మీరు ఆదేశాన్ని ఉపయోగించి ఈ మాడ్యూల్‌ను దిగుమతి చేసుకోవాలి:
దిగుమతి సమయం
ఈ మాడ్యూల్ దిగుమతి అయిన తర్వాత, మీరు time.sleep () ఫంక్షన్‌ను ఉపయోగించుకోవచ్చు. వాక్యనిర్మాణం క్రింది విధంగా ఉంది:
సింటాక్స్:
java system.exit (0)
మీరు చూడగలిగినట్లుగా ఇది ఒక పరామితిని తీసుకుంటుంది. ఇది ప్రాథమికంగా అమలు సమయంలో చాలా సెకన్ల ఆలస్యాన్ని ప్రేరేపిస్తుంది. తిరిగి ఈ ఫంక్షన్ కోసం విలువ శూన్యమైనది .
ఈ ఫంక్షన్ యొక్క పనిని అర్థం చేసుకోవడానికి ఇప్పుడు కొన్ని ఉదాహరణలు తీసుకుందాం.
పైథాన్ time.sleep () ఉదాహరణలు:
అవుట్‌పుట్‌ల మధ్య ఒక సెకను ఆలస్యాన్ని ప్రేరేపించే క్రింది ఉదాహరణను పరిశీలించండి.
ఉదాహరణ:
దిగుమతి సమయం # దిగుమతి సమయం మాడ్యూల్ స్లీప్_టైమ్ = 1 # మొదటి ప్రింట్ స్టేట్మెంట్ ప్రింట్ ('హలో') సమయం తర్వాత ఆలస్యాన్ని జోడించే సమయం.స్లీప్ (స్లీప్_టైమ్) # స్లీప్ టైమ్ ప్రింట్ ('ఎడురేకా!')అవుట్పుట్:
పై కోడ్ అమలు చేయబడితే అది ప్రోగ్రామ్‌లో ఆలస్యాన్ని జోడిస్తుంది, తదుపరి స్టేట్మెంట్ 1 సెకన్ల (ల) తర్వాత అమలు అవుతుంది.ఖచ్చితమైన ఆలస్యం కోసం, మీరు ఫ్లోటింగ్ పాయింట్ విలువలను ఫంక్షన్‌కు కూడా పంపవచ్చు. ఉదాహరణకు, 0.1 సెకన్లు దాటితే అది 100 మిల్లీసెకన్ల ఆలస్యం అవుతుంది.
ప్రోగ్రామ్ అమలుకు ముందు మరియు తరువాత సిస్టమ్ సమయాన్ని తిరిగి ఇచ్చే మరొక ఉదాహరణ ఇక్కడ ఉంది.
ఉదాహరణ:
# నిద్ర ప్రదర్శన దిగుమతి సమయం # ప్రారంభ సమయ ముద్రణ ('కోడ్ అమలు ప్రారంభమయ్యే సమయం:', ముగింపు = '') ముద్రణ (time.ctime ()) # వెంటాడే ప్రోగ్రామ్ సమయం. నిద్ర (6) # ముగింపు సమయం ముద్రణ ('ది కోడ్ అమలు ముగింపు సమయం: ', ముగింపు =' ') ముద్రణ (time.ctime ())అవుట్పుట్:
కోడ్ అమలు ప్రారంభమయ్యే సమయం: సన్ జూన్ 23 22:36:19 2019
కోడ్ అమలు ముగింపు సమయం: సన్ జూన్ 23 22:36:25 2019
ప్రాసెస్ తిరిగి 0 (0x0) అమలు సమయం: 6.089 సె
కొనసాగించడానికి ఏదైనా కీని నొక్కండి . . .
నిద్ర ఉదాహరణ:
నిద్ర పనితీరుకు క్రింది ఉదాహరణ:
దిగుమతి సమయం startTime = time.time () నేను పరిధిలో (5, 10): ప్రింట్ (i) # 1 సెకనుకు ఆలస్యం చేస్తోంది. నిద్ర (1) ఎండ్‌టైమ్ = టైమ్.టైమ్ () గడిచిన టైమ్ = ఎండ్‌టైమ్ - స్టార్‌టైమ్ ప్రింట్ (' గడిచిన సమయం =% s '% గడిచిన సమయం)అవుట్పుట్:
5
6
7
8
9
గడిచిన సమయం = 5.006335258483887
ప్రాసెస్ తిరిగి 0 (0x0) అమలు సమయం: 5.147 సె
జావా మరియు తరగతి మధ్య వ్యత్యాసం
ప్రతిసారీ 1 సెకను (లు) కోసం అమలు ఆగిపోవడంతో పూర్తి అమలు 5 సెకన్లు పట్టింది. అలాగే, అమలు కోసం అవసరమైన అదనపు సమయం ప్రోగ్రామ్‌ల కోసం సిస్టమ్ బ్యాక్‌గ్రౌండ్ ఆపరేషన్లు చేసే సమయం.
పైథాన్ నిద్ర యొక్క వివిధ ఆలస్యం సమయం ()
లో ప్రోగ్రామ్ అమలు మధ్య వేర్వేరు ఆలస్యం సమయాలను జోడించవచ్చు పైథాన్ అవసరమైన ఉత్పత్తిని బట్టి.క్రింది కోడ్ అది ఎలా చేయవచ్చో ప్రదర్శిస్తుంది:
ఉదాహరణ:
[1, 0.1, 2, 0.3] లో i కోసం దిగుమతి సమయం: ముద్రణ ('నేను% s'% i, end = '' కోసం ముద్రించాను) ముద్రణ ('సెకన్లు') time.sleep (i)అవుట్పుట్:
నేను 1 సెకన్లు నిద్రపోతాను
నేను 0.1 సెకన్లు నిద్రపోతాను
నేను 2 సెకన్లు నిద్రపోతాను
నేను 0.3 సెకన్లపాటు నిద్రపోతాను
ప్రాసెస్ తిరిగి 0 (0x0) అమలు సమయం: 3.538 సె
లేజీ ప్రింటింగ్:
మీరు ఏదో ఒక ఫాన్సీ మార్గంలో ప్రింట్ చేయాలనుకుంటే, మీరు ఈ క్రింది విధంగా స్లీప్ () ఫంక్షన్‌ను ఉపయోగించి చేయవచ్చు:
# దిగుమతి సమయం మాడ్యూల్ దిగుమతి సమయ సందేశం = 'కొన్ని ఫాన్సీ అక్షరాల ముద్రణ!' సందేశంలో నేను: ప్రింట్ (i) time.sleep (0.3)
మీరు పై కోడ్‌ను అమలు చేస్తే, ప్రతి అక్షరం ముద్రించడంలో ఆలస్యం కనిపిస్తుంది, ఇది ఫాన్సీగా కనిపిస్తుంది.
పైథాన్ థ్రెడ్ స్లీప్
మల్టీథ్రెడ్డ్ ఎన్విరాన్మెంట్ స్లీప్ () అమలులో ఉన్నప్పుడు ఇది చాలా ముఖ్యమైనదని రుజువు చేస్తుంది, ఇది అమలు చేయబడుతున్న ప్రస్తుత థ్రెడ్‌లో ఆలస్యాన్ని జోడించగలదు.
ఉదాహరణ:
థ్రెడింగ్ దిగుమతి నుండి దిగుమతి సమయం థ్రెడ్ క్లాస్ రన్నర్ (థ్రెడ్): డెఫ్ రన్ (సెల్ఫ్): x పరిధిలో (0, 7): ప్రింట్ (x) సమయం.స్లీప్ (2) క్లాస్ ఆలస్యం (థ్రెడ్): డెఫ్ రన్ (సెల్ఫ్): పరిధిలో x కోసం (106, 109): ప్రింట్ (x) time.sleep (7) ప్రింట్ ('స్టార్రింగ్ రన్నర్ థ్రెడ్') రన్నర్ (). ప్రారంభం () ముద్రణ ('ప్రారంభ ఆలస్యం థ్రెడ్') ఆలస్యం (). ప్రారంభం () ముద్రణ ('పూర్తయింది')పైన ఉన్న థ్రెడింగ్ ఉదాహరణ యొక్క అవుట్పుట్ క్రింద ఉంది:
అవుట్పుట్:
మీరు ప్రోగ్రామ్‌ను ఎగ్జిక్యూట్ చేస్తే, మొత్తం ప్రోగ్రామ్ ఆగిపోదని మీరు గమనించవచ్చు, కాని, ప్రస్తుతం అమలు చేయబడుతున్న థ్రెడ్ మాత్రమే ముందుకు సాగండి.
అప్లికేషన్:
ఈ పద్ధతి యొక్క అనేక అనువర్తనాలు ఉన్నాయి, ఉదాహరణకు, మెను లేదా శీర్షికను కొన్ని ఫాన్సీ మార్గంలో ముద్రించే చక్కని వినియోగదారు ఇంటర్‌ఫేస్‌ను సృష్టించడానికి మేము దీనిని ఉపయోగించవచ్చు, అయినప్పటికీ, అమలు చేయవలసిన నేపథ్య ప్రక్రియను ఆపడం ఒక ముఖ్యమైన అనువర్తనం. కొంత విరామంలో.
అప్లికేషన్ ఉదాహరణ:
దిగుమతి సమయం స్ట్రింగ్ = 'ఎడురేకా!' ప్రింట్_స్ట్రింగ్ = '' నేను పరిధిలో (0, లెన్ (స్ట్రింగ్)): print_string = print_string + string [i] print (print_string) time.sleep (2)
అవుట్పుట్:
IS
ఎడ్
విజయం
ఎడూర్
అంచు
ఎడురెక్
ఎడురేకా
ఎడురేకా!
పైథాన్ యొక్క టైమ్ మాడ్యూల్ ఉపయోగపడే చోట స్లీప్ ఫంక్షన్ కొంత సమయం వరకు ప్రోగ్రామ్‌ను పాజ్ చేస్తుందని మేము చూశాము. మేము వినియోగదారు నుండి ఇన్పుట్ ఎలా తీసుకోవచ్చు మరియు అదే ఫంక్షన్‌ను డైనమిక్‌గా ఎలా ఉపయోగించగలం అనే దాని గురించి కొంచెం చూద్దాం.
డైనమిక్ స్లీప్ ఉదాహరణ
రెండు ప్రింట్ ఫంక్షన్ల మధ్య ఆలస్యాన్ని జోడించడానికి మరియు ప్రింట్ ఫంక్షన్‌ను అమలు చేయడానికి తీసుకున్న సమయాన్ని ప్రింట్ చేయడానికి వినియోగదారు నుండి ఇన్పుట్ తీసుకునే నిద్ర యొక్క ఉదాహరణ ఇక్కడ ఉంది, ఈ క్రింది ఉదాహరణ పైథాన్ 3.x పై ఆధారపడి ఉంటుంది.
దిగుమతి సమయం డెఫ్ స్లీపర్ (): అయితే ట్రూ: num = ఇన్పుట్ ('వేచి ఉండే సమయాన్ని నమోదు చేయండి:') ప్రయత్నించండి: విలువ తప్ప సంఖ్య = ఫ్లోట్ (సంఖ్య) లోపం: ముద్రణ ('సంఖ్య మాత్రమే. n') కొనసాగించండి # మన సమయాన్ని అమలు చేయండి. నిద్ర () ఆదేశం, # మరియు ముందు మరియు తరువాత ముద్రణను చూపించు ('ముందు:% s'% time.ctime ()) time.sleep (num) print ('తర్వాత:% sn'% time.ctime ()) ప్రయత్నించండి: స్లీపర్ ( ) కీబోర్డ్ ఇంటర్‌రప్ట్ తప్ప: ప్రింట్ ('nnException నిష్క్రమించడం.') నిష్క్రమించు ()అవుట్పుట్:
వేచి ఉండే సమయాన్ని నమోదు చేయండి: 1
ముందు: ఆది జూన్ 23 22:44:13 2019
తరువాత: ఆది జూన్ 23 22:44:14 2019
వేచి ఉండే సమయాన్ని నమోదు చేయండి: 3
ముందు: ఆది జూన్ 23 22:44:16 2019
తరువాత: ఆది జూన్ 23 22:44:19 2019
ఖచ్చితత్వం
ఈ ఫంక్షన్ ఆపరేటింగ్ సిస్టమ్స్ స్లీప్ () ఫంక్షన్‌ను ఉపయోగిస్తున్నందున ఆపరేటింగ్ సిస్టమ్‌పై ఆధారపడి ఈ ఫంక్షన్‌కు పరిమితులు ఉన్నాయి, లైనక్స్‌లో విండోస్‌తో పోలిస్తే వేచి ఉండే సమయం చిన్నదిగా ఉంటుంది.
సారాంశం
html మరియు xml మధ్య వ్యత్యాసం
పై వ్యాసంలో మేము పైథాన్‌లో స్లీప్ () పద్ధతిని కవర్ చేసాము, ఇది ప్రాథమికంగా ప్రోగ్రామ్ ఎగ్జిక్యూషన్‌లో ఆలస్యాన్ని జోడించడానికి ఉపయోగిస్తారు, ఈ ప్యాకేజీ పైథాన్‌లోని టైమ్ మాడ్యూల్‌లో ఉంది, ఇది ప్రాథమికంగా ఆపరేటింగ్ సిస్టమ్ యొక్క నిద్ర () ఫంక్షన్‌ను ఉపయోగిస్తుంది. మేము ఈ ఫంక్షన్‌ను ఎలా ఉపయోగించాలో కొన్ని కోడ్ ఉదాహరణలను కూడా కవర్ చేసాము మరియు నిద్ర యొక్క అనువర్తనాలను పరిశీలించాము. ఈ ఫంక్షన్‌ను థ్రెడ్ చేసిన వాతావరణంలో ఎలా పనిచేస్తుందో చూడటానికి ఫాన్సీ మార్గాలను ప్రదర్శించారు.
పైథాన్‌తో పాటు దాని వివిధ అనువర్తనాలతో లోతైన జ్ఞానం పొందడానికి, మీరు ప్రత్యక్ష ప్రసారం కోసం నమోదు చేసుకోవచ్చు 24/7 మద్దతు మరియు జీవితకాల ప్రాప్యతతో.
మాకు ప్రశ్న ఉందా? దయచేసి ఈ “పైథాన్‌లో పైథాన్ టైమ్ స్లీప్ మెథడ్” బ్లాగులోని వ్యాఖ్యల విభాగంలో పేర్కొనండి మరియు మేము వీలైనంత త్వరగా మిమ్మల్ని సంప్రదిస్తాము.