విషయ సూచిక
ప్రోగ్రామ్ నేర్చుకునే ప్రక్రియలో, నిజ జీవితంలో దరఖాస్తు చేసుకోవడం అంత సులభం కాని ప్రోగ్రామ్‌లను రూపొందించడం తరచుగా అవసరం. అన్నింటికంటే, ఎప్పటికప్పుడు మీరు కొన్ని షరతులలో మాత్రమే సూచనలను అనుసరించాలి. ప్రోగ్రామ్‌లో దీన్ని అమలు చేయడానికి, అన్ని భాషలకు నియంత్రణ ప్రకటనలు ఉంటాయి. వారి సహాయంతో, మీరు కోడ్ అమలు యొక్క ప్రవాహాన్ని నియంత్రించవచ్చు, లూప్‌లను సృష్టించడం లేదా నిర్దిష్ట షరతు నిజం అయినప్పుడు మాత్రమే నిర్దిష్ట చర్యలను చేయడం.
ఈ రోజు మనం if స్టేట్‌మెంట్ గురించి మాట్లాడుతాము, ఇది ఒక నిర్దిష్ట పరిస్థితి కోసం ప్రస్తుత పరిస్థితిని తనిఖీ చేస్తుంది మరియు ఈ సమాచారం ఆధారంగా తదుపరి చర్యల గురించి నిర్ణయాలు తీసుకుంటుంది.
నియంత్రణ ప్రకటనల రకాలు
సాధారణంగా, ప్రోగ్రామ్ యొక్క ప్రవాహాన్ని నియంత్రించే ఏకైక ప్రకటన కాకపోతే. అలాగే అతను పెద్ద ఆపరేటర్ల గొలుసులో ఒక భాగం కావచ్చు.
దాని అమలు ప్రక్రియను నియంత్రించే ఉచ్చులు మరియు ప్రకటనలు కూడా ఉన్నాయి. ఈ రోజు మనం షరతులతో కూడిన ఆపరేటర్ మరియు అది పాల్గొనే గొలుసుల గురించి మాత్రమే మాట్లాడుతాము.
ప్రోగ్రామింగ్‌లో, బ్రాంచింగ్ వంటి విషయం ఉంది. ఇది ఖచ్చితంగా ఇది ఒక నిర్దిష్ట షరతు నిజమైతే మాత్రమే అమలు చేయబడే ఆదేశాల క్రమం అని అర్థం. ప్రమాణాలు భిన్నంగా ఉండవచ్చు:
- ఒక నిర్దిష్ట విలువకు వేరియబుల్ యొక్క సమానత్వం.
- నిర్దిష్ట చర్యను అమలు చేయడం.
- అప్లికేషన్ స్థితి (కుప్పకూలింది లేదా కాదు).
స్పెక్ట్రమ్ చాలా పెద్దది కావచ్చు. షరతులతో కూడిన ప్రకటనలు అనేక రకాలుగా వస్తాయి:
- ఒక శాఖతో. అంటే, ఒకే చెక్ నిర్వహించబడుతుంది, దీని ఫలితంగా కొన్ని చర్యలు నిర్వహించబడతాయి.
- రెండు లేదా అంతకంటే ఎక్కువ శాఖలతో. ప్రమాణం 1 నిజమైతే, ప్రమాణం 2ని తనిఖీ చేయండి. అది నిజమైతే, ఆపై 3ని తనిఖీ చేయండి. కాబట్టి, అవసరమైనన్ని తనిఖీలు చేయండి.
- అనేక షరతులతో. ఇక్కడ ప్రతిదీ సులభం. వ్యాఖ్యాత బహుళ షరతులు లేదా వాటిలో ఒకదాని కోసం తనిఖీ చేస్తాడు.
ప్రకటన ఉంటే
if స్టేట్‌మెంట్ యొక్క నిర్మాణం అన్ని భాషలలో ఒకేలా ఉంటుంది. అయినప్పటికీ, పైథాన్‌లో, దాని వాక్యనిర్మాణం మిగతా వాటి కంటే కొంత భిన్నంగా ఉంటుంది:
పరిస్థితి ఉంటే:
<входящее выражение 1>
<входящее выражение 2>
<не входящее выражение>
మొదట, ఆపరేటర్ స్వయంగా ప్రకటించబడుతుంది, దాని తర్వాత అది పని చేయడం ప్రారంభించే పరిస్థితి వ్రాయబడుతుంది. పరిస్థితి నిజం లేదా తప్పు కావచ్చు.
దీని తర్వాత కమాండ్‌లతో కూడిన బ్లాక్ వస్తుంది. అది వెంటనే పాటించాల్సిన ప్రమాణాన్ని అనుసరిస్తే, సంబంధిత ఆదేశాల క్రమాన్ని if block అంటారు. మీరు దానిలో ఎన్ని కమాండ్‌లనైనా ఉపయోగించవచ్చు.
అటెన్షన్! బ్లాక్ కమాండ్‌లన్నింటిలో ఇండెంటేషన్ తప్పనిసరిగా ఒకే పరిమాణంలో ఉండాలి. బ్లాక్ సరిహద్దులు ఇండెంట్ల ద్వారా నిర్ణయించబడతాయి.
భాషా డాక్యుమెంటేషన్ ప్రకారం, ఇండెంటేషన్ 4 ఖాళీలు.
ఈ ఆపరేటర్ ఎలా పని చేస్తుంది? వ్యాఖ్యాత if పదాన్ని చూసినప్పుడు, అది వెంటనే వినియోగదారు పేర్కొన్న ప్రమాణాలకు వ్యతిరేకంగా వ్యక్తీకరణను తనిఖీ చేస్తుంది. ఇదే జరిగితే, అతను సూచనల కోసం వెతకడం మరియు వాటిని అనుసరించడం ప్రారంభిస్తాడు. లేకపోతే, ఈ బ్లాక్ నుండి అన్ని ఆదేశాలు దాటవేయబడతాయి.
పరిస్థితి తర్వాత ప్రకటన ఇండెంట్ చేయకపోతే, అది if బ్లాక్‌గా పరిగణించబడదు. మా పరిస్థితిలో, ఈ లైన్
ఈ ఆపరేటర్ ఎలా పని చేస్తుందో ఉదాహరణ కోసం ఇక్కడ కోడ్ స్నిప్పెట్ ఉంది.
సంఖ్య = int(ఇన్‌పుట్ ("సంఖ్యను నమోదు చేయండి:"))
సంఖ్య > 10 అయితే:
ప్రింట్ ("సంఖ్య 10 కంటే ఎక్కువ")
ఈ ప్రోగ్రామ్ వినియోగదారుని సంఖ్య కోసం అడుగుతుంది మరియు అది 10 కంటే ఎక్కువ ఉంటే తనిఖీ చేస్తుంది. అలా అయితే, అది తగిన సమాచారాన్ని అందిస్తుంది. ఉదాహరణకు, వినియోగదారు సంఖ్య 5 ను నమోదు చేస్తే, ప్రోగ్రామ్ కేవలం ముగుస్తుంది మరియు అంతే.
కానీ మీరు 100 సంఖ్యను పేర్కొన్నట్లయితే, అది పది కంటే ఎక్కువ అని వ్యాఖ్యాత అర్థం చేసుకుంటాడు మరియు దానిని నివేదించండి.
అటెన్షన్! మా విషయంలో, షరతు తప్పుగా ఉంటే, ప్రోగ్రామ్ ఆగిపోతుంది, ఎందుకంటే సూచనల తర్వాత ఆదేశాలు ఇవ్వబడవు.
పై కోడ్‌లో ఒకే ఒక కమాండ్ ఉంది. కానీ వాటిలో చాలా ఉన్నాయి. ఇండెంట్ మాత్రమే అవసరం.
ఇప్పుడు ఈ ఆదేశాల క్రమాన్ని విశ్లేషిద్దాం.
సంఖ్య = పూర్ణం (ఇన్‌పుట్ ("సంఖ్యను వ్రాయండి: "))
సంఖ్య > 10 అయితే:
ప్రింట్ ("మొదటి పంక్తి")
ప్రింట్ ("రెండవ పంక్తి")
ప్రింట్ ("మూడవ లైన్")
ప్రింట్ ("నమోదు చేయబడిన సంఖ్యతో సంబంధం లేకుండా అమలు చేయబడిన పంక్తి")
ప్రింట్ (“అప్లికేషన్ ముగించు”)
మీరు 2, 5, 10, 15, 50 విలువలను నమోదు చేస్తే అవుట్‌పుట్ ఎలా ఉంటుందో ఊహించడానికి ప్రయత్నించండి.
మీరు చూడగలిగినట్లుగా, వినియోగదారు నమోదు చేసిన సంఖ్య పది కంటే ఎక్కువ ఉంటే, మూడు పంక్తులు అవుట్‌పుట్ + ఒకటి "ప్రతిసారీ రన్ ..." మరియు ఒక "ముగింపు" అనే టెక్స్ట్‌తో ఉంటాయి మరియు పది కంటే తక్కువ ఉంటే, అప్పుడు ఒకటి మాత్రమే వేరే వచనం. నిజమైతే 3,4,5 పంక్తులు మాత్రమే అమలు చేయబడతాయి. అయితే, వినియోగదారు ఏ సంఖ్యను పేర్కొన్నా చివరి రెండు పంక్తులు వ్రాయబడతాయి.
మీరు స్టేట్‌మెంట్‌లను నేరుగా కన్సోల్‌లో ఉపయోగిస్తే, ఫలితం భిన్నంగా ఉంటుంది. ధృవీకరణ ప్రమాణాన్ని పేర్కొన్న తర్వాత, Enter నొక్కితే వ్యాఖ్యాత వెంటనే బహుళ-లైన్ మోడ్‌ను ఆన్ చేస్తాడు.
కింది వరుస ఆదేశాలను వ్రాసాము అనుకుందాం.
>>>
>>> n = 100
>>> n > 10 అయితే:
...
ఆ తర్వాత, >>> ఎలిప్సిస్‌తో భర్తీ చేయబడిందని మనం చూస్తాము. మల్టీలైన్ ఇన్‌పుట్ మోడ్ ప్రారంభించబడిందని దీని అర్థం. సరళంగా చెప్పాలంటే, మీరు ఎంటర్ నొక్కితే, మీరు సూచనల యొక్క రెండవ దశ యొక్క ఇన్‌పుట్‌కు బదిలీ చేయబడతారు.
మరియు ఈ బ్లాక్ నుండి నిష్క్రమించడానికి, మీరు బ్లాక్‌కు మరో నిర్మాణాన్ని జోడించాలి if.
>>>
>>> n = 100
>>> n > 10 అయితే:
… ప్రింట్ (“nv 10”)
...
షరతు నిజం కాకపోతే, ప్రోగ్రామ్ ముగుస్తుంది. ఇది ఒక సమస్య, ఎందుకంటే వినియోగదారు అటువంటి ప్రోగ్రామ్ వైఫల్యం కారణంగా మూసివేయబడిందని గ్రహించవచ్చు. అందువల్ల, వినియోగదారుకు అభిప్రాయాన్ని తెలియజేయడం అవసరం. దీని కోసం, ఒక లింక్ ఉపయోగించబడుతుంది ఉంటే-లేకపోతే.
వ్యక్తీకరణ ఆపరేటర్ ఉంటే-లేకపోతే
ఈ ఆపరేటర్ లింక్‌ను అమలు చేయడానికి మిమ్మల్ని అనుమతిస్తుంది: వ్యక్తీకరణ ఒక నిర్దిష్ట నియమానికి సరిపోలితే, ఈ చర్యలను చేయండి మరియు లేకపోతే, ఇతరులు. అంటే, ఇది ప్రోగ్రామ్ యొక్క ప్రవాహాన్ని రెండు రోడ్లుగా విభజించడానికి మిమ్మల్ని అనుమతిస్తుంది. వాక్యనిర్మాణం సహజమైనది:
పరిస్థితి ఉంటే:
# బ్లాక్ చేస్తే
ప్రకటన 1
ప్రకటన 2
మరియు అందువలన న
లేకపోతే:
# else బ్లాక్
ప్రకటన 3
ప్రకటన 4
మరియు మొదలైనవి:
ఈ ఆపరేటర్ ఎలా పని చేస్తుందో వివరించండి. మొదట, ప్రామాణిక ప్రకటన థ్రెడ్‌లో అమలు చేయబడుతుంది అవును, ఇది సరిపోతుందో లేదో తనిఖీ చేస్తోంది పరిస్థితి "నిజమా లేక అబధ్ధమా". తదుపరి చర్యలు చెక్ ఫలితాలపై ఆధారపడి ఉంటాయి. ఒప్పు అయితే, షరతును అనుసరించి సూచనల క్రమంలో ఉన్న సూచన నేరుగా అమలు చేయబడుతుంది. అవును, అది తప్పు అయితే, అప్పుడు వేరే.
ఈ విధంగా మీరు లోపాలను నిర్వహించవచ్చు. ఉదాహరణకు, వినియోగదారు వ్యాసార్థాన్ని నమోదు చేయాలి. సహజంగానే, ఇది ప్లస్ గుర్తుతో కూడిన సంఖ్య మాత్రమే కావచ్చు లేదా అది శూన్య విలువ. ఇది 0 కంటే తక్కువగా ఉంటే, మీరు సానుకూల సంఖ్యను నమోదు చేయమని కోరుతూ సందేశాన్ని జారీ చేయాలి.
ఈ పనిని అమలు చేసే కోడ్ ఇక్కడ ఉంది. అయితే ఇక్కడ ఒక తప్పు ఉంది. ఏది ఊహించడానికి ప్రయత్నించండి.
వ్యాసార్థం = int(ఇన్‌పుట్ ("వ్యాసార్థాన్ని నమోదు చేయండి:"))
వ్యాసార్థం >= 0:
ప్రింట్ (“చుట్టుకొలత = “, 2 * 3.14 * వ్యాసార్థం)
ప్రింట్ (“ఏరియా = “, 3.14 * వ్యాసార్థం ** 2)
లేకపోతే:
ప్రింట్ (“దయచేసి సానుకూల సంఖ్యను నమోదు చేయండి”)
ఇండెంటేషన్ సరిపోలని లోపం. ఒకవేళ మరియు వేరే అవి లేకుండా లేదా అదే సంఖ్యలో (అవి గూడు కట్టుకున్నాయా లేదా అనేదానిపై ఆధారపడి) ఉండాలి.
పాస్‌వర్డ్‌ని తనిఖీ చేసే అప్లికేషన్ ఎలిమెంట్ - మరొక వినియోగ సందర్భాన్ని (ఆపరేటర్ అలైన్‌మెంట్‌తో ప్రతిదీ సరిగ్గా చేసే చోట) ఇద్దాం.
పాస్వర్డ్ = ఇన్‌పుట్ ("పాస్‌వర్డ్‌ని నమోదు చేయండి:")
పాస్వర్డ్ ఉంటే == «sshh»:
ప్రింట్ ("స్వాగతం")
లేకపోతే:
ప్రింట్ (“యాక్సెస్ నిరాకరించబడింది”)
పాస్వర్డ్ sshh అయితే ఈ సూచన వ్యక్తిని మరింత దాటవేస్తుంది. ఏదైనా ఇతర అక్షరాలు మరియు సంఖ్యల కలయిక ఉంటే, అది “యాక్సెస్ నిరాకరించబడింది” అనే సందేశాన్ని ప్రదర్శిస్తుంది.
ప్రకటన-వ్యక్తీకరణ if-elif-else
అనేక షరతులు నిజం కాకపోతే మాత్రమే, బ్లాక్‌లో ఉన్న ప్రకటన అమలు చేయబడుతుంది. వేరే. ఈ వ్యక్తీకరణ ఇలా పనిచేస్తుంది.
ఒకవేళ షరతు_1:
# బ్లాక్ చేస్తే
ప్రకటన
ప్రకటన
మరింత ప్రకటన
ఎలిఫ్ పరిస్థితి_2:
# మొదటి ఎలిఫ్ బ్లాక్
ప్రకటన
ప్రకటన
మరింత ప్రకటన
ఎలిఫ్ పరిస్థితి_3:
# రెండవ ఎలిఫ్ బ్లాక్
ప్రకటన
ప్రకటన
మరింత ప్రకటన
...
వేరే
ప్రకటన
ప్రకటన
మరింత ప్రకటన
మీరు ఏవైనా అదనపు షరతులను పేర్కొనవచ్చు.
సమూహ ప్రకటనలు
బహుళ షరతులను అమలు చేయడానికి మరొక మార్గం if బ్లాక్‌లో అదనపు కండిషన్ చెక్‌లను చొప్పించడం.
ఆపరేటర్ if మరొక కండిషన్ బ్లాక్ లోపల
gre_score = int(ఇన్‌పుట్ ("మీ ప్రస్తుత క్రెడిట్ పరిమితిని నమోదు చేయండి"))
per_grad = int(ఇన్‌పుట్ ("మీ క్రెడిట్ రేటింగ్‌ను నమోదు చేయండి:"))
per_grad > 70:
# ఔటర్ అయితే బ్లాక్
gre_స్కోరు > 150:
# లోపలి ఉంటే బ్లాక్
ప్రింట్ (“అభినందనలు, మీరు రుణం పొందారు”)
లేకపోతే:
ప్రింట్ (“క్షమించండి, మీరు రుణం పొందేందుకు అర్హులు కాదు”)
ఈ ప్రోగ్రామ్ క్రెడిట్ రేటింగ్ తనిఖీని చేస్తుంది. 70 కంటే తక్కువ ఉంటే, వినియోగదారు క్రెడిట్‌కు అర్హులు కాదని ప్రోగ్రామ్ నివేదిస్తుంది. అది ఎక్కువగా ఉంటే, ప్రస్తుత క్రెడిట్ పరిమితి 150 కంటే ఎక్కువగా ఉందో లేదో తెలుసుకోవడానికి రెండవ చెక్ నిర్వహిస్తారు. అవును అయితే, రుణం జారీ చేయబడిందని సందేశం ప్రదర్శించబడుతుంది.
రెండు విలువలు తప్పు అయితే, వినియోగదారుకు రుణం పొందే అవకాశం లేదని సందేశం ప్రదర్శించబడుతుంది.
ఇప్పుడు ఆ ప్రోగ్రామ్‌ని కొంచెం రీవర్క్ చేద్దాం.
gre_score = int(ఇన్‌పుట్ ("ప్రస్తుత పరిమితిని నమోదు చేయండి: "))
per_grad = int(ఇన్‌పుట్("క్రెడిట్ స్కోర్‌ని నమోదు చేయండి:"))
per_grad > 70:
gre_స్కోరు > 150:
ప్రింట్ (“అభినందనలు, మీరు రుణం పొందారు”)
లేకపోతే:
ప్రింట్ ("మీ క్రెడిట్ పరిమితి తక్కువగా ఉంది")
లేకపోతే:
ప్రింట్ (“క్షమించండి, మీరు క్రెడిట్‌కు అర్హులు కాదు”)
కోడ్ చాలా పోలి ఉంటుంది, కానీ గూడులో ఉంది if దాని నుండి పరిస్థితి తప్పు అని తేలితే అల్గోరిథం కూడా అందిస్తుంది. అంటే, కార్డుపై పరిమితి సరిపోదు, కానీ క్రెడిట్ చరిత్ర బాగుంది, "మీకు తక్కువ క్రెడిట్ రేటింగ్ ఉంది" అనే సందేశం ప్రదర్శించబడుతుంది.
if-else ఒక షరతు లోపల ప్రకటన వేరే
పరీక్ష స్కోర్‌ల ఆధారంగా విద్యార్థి యొక్క గ్రేడ్‌ను నిర్ణయించే మరొక ప్రోగ్రామ్‌ను తయారు చేద్దాం.
స్కోర్ = int (ఇన్‌పుట్ ("మీ స్కోర్‌ని నమోదు చేయండి:"))
ఒకవేళ స్కోరు >= 90:
ప్రింట్ (“గొప్పది! మీ గ్రేడ్ A”)
లేకపోతే:
ఒకవేళ స్కోరు >= 80:
ప్రింట్ (“గొప్పది! మీ గ్రేడ్ B”)
లేకపోతే:
ఒకవేళ స్కోరు >= 70:
ప్రింట్ (“బాగుంది! మీ గ్రేడ్ సి”)
లేకపోతే:
ఒకవేళ స్కోరు >= 60:
ప్రింట్ (“మీ గ్రేడ్ D. ఇది మెటీరియల్‌ని పునరావృతం చేయడం విలువైనది.”)
లేకపోతే:
ప్రింట్ ("మీరు పరీక్షలో విఫలమయ్యారు")
అప్లికేషన్ మొదట స్కోర్ 90 కంటే ఎక్కువ లేదా సమానంగా ఉందో లేదో తనిఖీ చేస్తుంది. అవును అయితే, అది A గ్రేడ్‌ను అందిస్తుంది. ఈ షరతు తప్పు అయితే, తదుపరి తనిఖీలు నిర్వహించబడతాయి. మొదటి చూపులో అల్గోరిథం దాదాపు ఒకే విధంగా ఉందని మేము చూస్తాము. కాబట్టి లోపల తనిఖీ చేయడానికి బదులుగా వేరే కలయికను ఉపయోగించడం మంచిది if-elif- else.
కాబట్టి ఆపరేటర్ if చాలా ముఖ్యమైన విధిని నిర్వహిస్తుంది - ఇది అవసరమైనప్పుడు మాత్రమే నిర్దిష్ట కోడ్ ముక్కలు అమలు చేయబడేలా చేస్తుంది. ఇది లేకుండా ప్రోగ్రామింగ్ ఊహించడం అసాధ్యం, ఎందుకంటే సరళమైన అల్గారిథమ్‌లకు కూడా "మీరు ఎడమ వైపుకు వెళితే, మీరు దానిని కనుగొంటారు, మరియు మీరు కుడి వైపుకు వెళితే, మీరు దీన్ని మరియు అది చేయాలి" వంటి ఫోర్కులు అవసరం.