రద్దు చేయడానికి వినియోగదారు ఇన్పుట్ కోసం స్క్రిప్ట్‌ను పాజ్ చేయండి:
స్క్రిప్ట్‌ను ముగించే ముందు యూజర్ ఏదైనా కీని నొక్కే వరకు మీరు వేచి ఉండాలనుకుంటే, మీరు కాల్ చేయవచ్చు ఇన్పుట్ () స్క్రిప్ట్ చివర సందేశంతో ఉన్న పద్ధతి. కింది స్క్రిప్ట్ మీరు స్క్రిప్ట్ రద్దును పాజ్ చేసి యూజర్ ఇన్పుట్ కోసం ఎలా వేచి ఉండాలో చూపుతుంది. ది ఇన్పుట్ () పద్ధతి స్ట్రింగ్ డేటాను తీసుకుంటుంది మరియు వేరియబుల్‌లో నిల్వ చేస్తుంది, పేరు . వేరియబుల్ ఖాళీగా లేనట్లయితే, స్వాగత సందేశం ముద్రించబడుతుంది, లేకపోతే దోష సందేశం ముద్రించబడుతుంది. తరువాత, ఏదైనా కీని నొక్కమని వినియోగదారుకు తెలియజేయడానికి సూచన సందేశం ముద్రించబడుతుంది. వినియోగదారు ఏదైనా కీని నొక్కినప్పుడు రద్దు సందేశం ముద్రించబడుతుంది.
#!/usr/bin/env పైథాన్ 3
# యూజర్ ఇన్పుట్ తీసుకోండి
పేరు= ఇన్పుట్('నీ పేరు ఏమిటి? ')
# ఇన్పుట్ విలువను తనిఖీ చేయండి
ఉంటే(పేరు! = ''):
# విలువ ఖాళీగా లేకపోతే స్వాగత సందేశాన్ని ముద్రించండి
ముద్రణ('హలో %s, మా సైట్‌కు స్వాగతం'%పేరు)
లేకపోతే:
# ఖాళీ సందేశాన్ని ముద్రించండి
ముద్రణ('పేరు ఖాళీగా ఉండకూడదు.')
# ప్రోగ్రామ్‌ను రద్దు చేయడానికి వినియోగదారు ఇన్పుట్ కోసం వేచి ఉండండి
ఇన్పుట్('ప్రోగ్రామ్‌ని ముగించడానికి ఏదైనా కీని నొక్కండి')
# బై సందేశాన్ని ముద్రించండి
ముద్రణ('తర్వాత కలుద్దాం.')
అవుట్‌పుట్:
స్క్రిప్ట్‌ను అమలు చేసిన తర్వాత, అది స్ట్రింగ్ ఇన్పుట్ కోసం వేచి ఉంటుంది. ఇక్కడ, 'ఫహ్మిదా' స్ట్రింగ్ విలువగా టైప్ చేయబడింది. స్వాగత సందేశం విలువతో ముద్రించబడింది మరియు ఏదైనా కీప్రెస్ కోసం వేచి ఉంది. ఏదైనా కీని నొక్కిన తర్వాత బై సందేశం ముద్రించబడుతుంది.
ఒక నిర్దిష్ట కాలానికి ఇన్‌పుట్‌ను పాజ్ చేయండి
నిద్ర () నిర్దిష్ట వ్యవధిలో యూజర్ ఇన్‌పుట్‌ను పాజ్ చేయడానికి ఈ పద్ధతిని ఉపయోగించవచ్చు. కింది స్క్రిప్ట్‌లో, వినియోగదారు కోసం ఒక సాధారణ అదనపు పని ఇవ్వబడింది. సమాధానం టైప్ చేయడానికి ముందు యూజర్ కోసం 5 సెకన్ల పాటు వేచి ఉండడానికి స్లీప్ () పద్ధతి ఇక్కడ ఉపయోగించబడుతుంది. తరువాత, పరిస్థితి సరియైనదా లేదా సరికానిది అని తనిఖీ చేయడానికి ఉపయోగించినట్లయితే.
#!/usr/bin/env పైథాన్ 3# సమయ మాడ్యూల్‌ను దిగుమతి చేయండి
దిగుమతి సమయం
# సందేశాన్ని ముద్రించండి
ముద్రణ ('మీరు మనిషి అని నిరూపించడానికి సమస్యను పరిష్కరించండి.')
# ప్రశ్నను ముద్రించండి
ముద్రణ(10 మరియు 40 మొత్తం ఎంత? ')
# ప్రింట్ వెయిట్ మెసేజ్
ముద్రణ('లెక్కించడానికి ఐదు సెకన్ల పాటు వేచి ఉంది ...')
# 2 సెకన్లు వేచి ఉండండి
సమయం.నిద్ర(5)
# వినియోగదారు నుండి ఇన్పుట్ తీసుకోండి
సమాధానం= ఇన్పుట్('మీ సమాధానం: ')
# సమాధానాన్ని తనిఖీ చేయండి
ఉంటే(int(సమాధానం) == యాభై):
ముద్రణ('మీ సమాధానం సరైనది. బాగా చేసారు. ')
లేకపోతే:
ముద్రణ('మీరు నిరూపించడంలో విఫలమయ్యారు.')
అవుట్‌పుట్:
స్క్రిప్ట్ అమలు చేసిన తర్వాత ఒక ప్రశ్న ముద్రించబడుతుంది మరియు సమాధానం తెలుసుకోవడానికి 5 సెకన్లు వేచి ఉండమని వినియోగదారుకు తెలియజేస్తుంది. ఇక్కడ, స్క్రిప్ట్ సరైన సమాధానం మరియు తప్పు సమాధానంతో రెండుసార్లు అమలు చేయబడుతుంది.
ఉపయోగించి స్క్రిప్ట్‌ను పాజ్ చేయండి ఇన్పుట్ సూచన సందేశాలను ప్రదర్శించడానికి
కొన్నిసార్లు స్క్రిప్ట్‌ను అనేకసార్లు పాజ్ చేయడం అవసరం ఇన్పుట్ () వివిధ ప్రయోజనాల కోసం పద్ధతి. బహుళ సందేశాలను ఉపయోగించి వినియోగదారుకు సమాచారాన్ని అందించే ప్రక్రియ క్రింది స్క్రిప్ట్‌లో చూపబడింది. ఏదైనా పైథాన్ స్క్రిప్ట్‌ను అమలు చేయడానికి దశలు బహుళ ఉపయోగించి ఇక్కడ చూపబడతాయి ఇన్పుట్ () పద్ధతి తదుపరి దశలను చూపించడానికి వినియోగదారు ఏదైనా కీని నొక్కాలి. మొదటిది ఇన్పుట్ () సందేశం మరియు చివరిది చూపడం ప్రారంభించడానికి పద్ధతి ఉపయోగించబడుతుంది ఇన్పుట్ () రద్దు సందేశాన్ని చూపించడానికి పద్ధతి ఉపయోగించబడుతుంది.
#!/usr/bin/env పైథాన్ 3# ప్రారంభ సందేశాన్ని ముద్రించండి
ముద్రణ('పైథాన్ స్క్రిప్ట్ అమలు చేయడానికి దశలు:')
# ఏదైనా కీప్రెస్ కోసం వేచి ఉండండి
ఇన్పుట్('కొనసాగించడానికి ఏదైనా కీని నొక్కండి')
# ఏదైనా కీప్రెస్ కోసం వేచి ఉండండి
ఇన్పుట్('ఏదైనా ఎడిటర్‌లో స్క్రిప్ట్ రాయండి.')
# ఏదైనా కీప్రెస్ కోసం వేచి ఉండండి
ఇన్పుట్('Alt+Ctrl+T నొక్కడం ద్వారా టెర్మినల్‌ని తెరవండి.')
# ఏదైనా కీప్రెస్ కోసం వేచి ఉండండి
ఇన్పుట్('రకం:' పైథాన్ స్క్రిప్ట్ నేమ్. Py '.')
# ఏదైనా కీప్రెస్ కోసం వేచి ఉండండి
ఇన్పుట్('స్క్రిప్ట్ లోపం లేకుండా ఉంటే మీ అవుట్‌పుట్ మీకు లభిస్తుంది.')
# ఏదైనా కీప్రెస్ కోసం వేచి ఉండండి
ఇన్పుట్(ముగించడానికి ఏదైనా కీని నొక్కండి. ')
# రద్దు సందేశాన్ని ముద్రించండి
ముద్రణ(' nగుడ్ బై. ')
అవుట్‌పుట్:
స్క్రిప్ట్ అమలు చేసిన తర్వాత కింది అవుట్‌పుట్ కనిపిస్తుంది. స్క్రిప్ట్ అమలును పూర్తి చేయడానికి యూజర్ ఏదైనా కీని ఐదుసార్లు నొక్కాలి.
నిర్దిష్ట ఇన్పుట్ విలువ కోసం స్క్రిప్ట్‌ను పాజ్ చేయండి
యూజర్ ఏదైనా నిర్దిష్ట కీని నొక్కే వరకు మీరు కొన్ని స్క్రిప్ట్‌లను నిరంతరం అమలు చేయాలనుకుంటే, మీరు ఆ స్క్రిప్ట్‌ని ఏదైనా అనంతమైన లూప్‌లో నిర్వచించాలి. ఈ పని ఈ ఉదాహరణలో చూపబడింది. ఇక్కడ, అనంతమైన సమయంలో లూప్ ప్రకటించబడింది మరియు రెండు సంఖ్యలను తీసుకొని ప్రతి పునరుక్తిలో ఆ సంఖ్యల సమ్మషన్‌ను ముద్రించాలని భావిస్తున్నారు. లూప్ చివరలో, వినియోగదారు 'నొక్కడం కోసం ఇది వేచి ఉంటుంది' మరియు లూప్‌ను కొనసాగించడానికి మరియు స్క్రిప్ట్‌ను మళ్లీ పునరావృతం చేయడానికి.
#!/usr/bin/env పైథాన్ 3# అనంతమైన లూప్‌ను నిర్వచించండి
అయితే(నిజమే):
# రెండు పూర్ణాంక సంఖ్యలను తీసుకోండి
x= int(ఇన్పుట్('ఒక సంఖ్యను నమోదు చేయండి:'))
మరియు= int(ఇన్పుట్('ఒక సంఖ్యను నమోదు చేయండి:'))
# రెండు సంఖ్యలను జోడించండి
ఫలితం=x + y
# సమ్మషన్ ఫలితాన్ని ముద్రించండి
ముద్రణ(' %D మరియు %d మొత్తం: %d'%(x,మరియు,ఫలితం))
# వినియోగదారు ఇన్పుట్ కొనసాగడానికి లేదా లూప్‌ను ముగించడానికి వేచి ఉండండి
సంవత్సరాలు= ఇన్పుట్('మీరు మళ్లీ చేయాలనుకుంటున్నారా? (y/n) ')
ఇన్పుట్ విలువ 'n' అయితే స్క్రిప్ట్‌ను రద్దు చేయండి
ఉంటే (సంవత్సరాలు.తక్కువ() == 'n'):
విరామం
అవుట్‌పుట్:
అయితే లూప్ లోపల ఉన్న స్క్రిప్ట్ ఇక్కడ రెండుసార్లు అమలు చేయబడుతుంది. సమ్మషన్‌ను లెక్కించిన తర్వాత మొదటిసారి, 'మరియు' నొక్కినప్పుడు మరియు లూప్ యొక్క స్క్రిప్ట్ మళ్లీ పునరావృతమవుతుంది. వినియోగదారు నొక్కినప్పుడు 'N' అప్పుడు లూప్ ముగించబడుతుంది.
ముగింపు:
యూజర్ ఇన్పుట్ కోసం పాజ్ చేయడం అనేది ఏదైనా ప్రోగ్రామింగ్ లాంగ్వేజ్ యొక్క చాలా సాధారణ అవసరం. ఇన్పుట్ కోసం పాజ్ యొక్క వివిధ ప్రయోజనాలు ఈ వ్యాసంలో చాలా సులభమైన పైథాన్ ఉదాహరణలను ఉపయోగించి చూపబడ్డాయి. ఇన్పుట్ కోసం పాజ్ యొక్క ఉపయోగాలను తెలుసుకోవడానికి మరియు అవసరమైనప్పుడు స్క్రిప్ట్‌లో వర్తింపజేయడానికి ఈ కథనం పాఠకులకు సహాయపడుతుందని నేను ఆశిస్తున్నాను.