Home-theater-designers
ది ఉంటే ప్రకటన అనేది లాజికల్ ప్రోగ్రామింగ్ యొక్క చోదక శక్తి. ఫలితంగా, పైథాన్‌ని బాగా అర్థం చేసుకోండి ఉంటే మీ పైథాన్ ప్రోగ్రామింగ్ నైపుణ్యాలకు గణనీయమైన అదనంగా ఉంది.
మీరు పైథాన్ గురించి మరింత తెలుసుకోవాలనుకుంటున్నారా ఉంటే ప్రకటన? చింతించకండి, ఇక్కడ, ఎలా ఉపయోగించాలో మేము వివరిస్తాము ఉంటే మీ ప్రోగ్రామ్‌ని నియంత్రించడానికి పైథాన్ పరిస్థితి.
ఒకవేళ పైథాన్‌లో స్టేట్మెంట్ ఎలా పనిచేస్తుంది
సాధారణంగా, పైథాన్‌లో షరతులతో కూడిన స్టేట్‌మెంట్‌లు ప్రారంభమవుతాయి ఉంటే , మరియు అది లేకుండా, అవి అస్సలు తార్కికంగా లేవు. ఏదేమైనా, షరతులు ప్రోగ్రామర్ నిర్వచించిన నియమాల సమితి, ఇది ఒక నిర్దిష్ట సంఘటన నిజమా లేదా అబద్ధమా అని తనిఖీ చేస్తుంది. సారాంశంలో, వారు ఈవెంట్ యొక్క చెల్లుబాటును తనిఖీ చేస్తారు.
ఒక ఉంటే పైథాన్‌లో స్టేట్మెంట్ సాధారణంగా ఈ ఆకృతిని తీసుకుంటుంది:
if an event is True:
Execute some commands...
అయినాసరే ఉంటే ప్రకటన ఒంటరిగా నిలబడగలదు, వంటి ఇతర పరిస్థితులు ఎలిఫ్ , మరియు లేకపోతే ఇతర నియమాలను అమలు చేయడానికి దాన్ని బ్యాకప్ చేయవచ్చు. అయితే, మీరు వంటి స్టేట్‌మెంట్‌లను కూడా ఉపయోగించవచ్చు కాదు , మరియు , లేదా , మరియు లో తో ఉంటే పైథాన్ పరిస్థితి.
పైథాన్ కూడా మీరు ఉపయోగించడానికి అనుమతిస్తుంది ఉంటే వంటి ప్రకటన ప్రవాహాలతో నేరుగా ప్రకటన కోసం లూప్. దీనిని ఎలా ఉపయోగించాలో చూద్దాం ఉంటే దిగువ ఉదాహరణలలో ఈ ప్రతి కేసుతో ప్రకటన.
ఒకవేళ పైథాన్‌ను ఎలా ఉపయోగించాలి ... ఇతర స్టేట్‌మెంట్‌లు
తో ఉంటే షరతు, ఈవెంట్ నిజం అయినంత వరకు మీరు పైథాన్‌కు ఆదేశాల సమితిని అమలు చేయమని చెప్పవచ్చు:
మల్టీప్లేయర్ మిన్‌క్రాఫ్ట్ ప్రపంచాన్ని ఎలా తయారు చేయాలి
if 5 > 3:
print('Valid')
Output: Valid
అయితే, కలయిక ఉంటే లేకపోతే మొదటిది తప్పు అయితే మీరు మరొక సెట్ ఆదేశాలను అమలు చేయాల్సి వచ్చినప్పుడు పరిస్థితులు ఉపయోగపడతాయి. దీనిని ఆచరణలో చూద్దాం:
a = 10
b = 3
if a == b:
print('They're the same')
else:
print('They're not the same')
Output: They're not the same
పైథాన్ బూలియన్ విలువను తిరిగి పొందడం ద్వారా పై రెండు వేరియబుల్స్ యొక్క సమానత్వాన్ని మీరు నేరుగా తనిఖీ చేయవచ్చు. ఉదాహరణకు, ప్రింటింగ్ a == బి తప్పును తిరిగి ఇస్తుంది:
a = 10
b = 3
print(a==b)
Output: False
పైథాన్ ఉంటే ... ఎలిఫ్ ... ఇతర షరతులను ఎలా ఉపయోగించాలి
జావాస్క్రిప్ట్ వంటి ప్రోగ్రామింగ్ భాషలు ఉపయోగిస్తున్నప్పుడు వేరే ఉంటే , పైథాన్ ఉపయోగిస్తుంది ఎలిఫ్ . అయితే, ఒక లేకపోతే సాధారణంగా పైథాన్‌లో షరతులతో కూడిన స్టేట్మెంట్ సమితిని ముగుస్తుంది. మీ షరతులను ముగించే ముందు మీరు ఇంకా ఇతర ఈవెంట్‌లను ధృవీకరించాలనుకుంటే, మీరు దానిని ఉపయోగించాలి ఎలిఫ్ ప్రకటన. పైథాన్ యొక్క వినియోగ కేసును చూద్దాం ఎలిఫ్ క్రింద:
a = 10
b = 3
if b == a:
print(a + b)
elif b * a == 30:
print(b - a)
else:
print('impossible')
Output: -7
పై కోడ్‌లో, పైథాన్ ఆదేశాన్ని లోపల అమలు చేస్తుంది ఉంటే ఈవెంట్ నిజమైతే ప్రకటన. కాకపోతే, అది అమలు చేస్తుంది ఎలిఫ్ ప్రకటన. లేకపోతే, అది అవుట్పుట్ చేస్తుంది లేకపోతే ప్రకటన.
మీరు ఒకటి కంటే ఎక్కువ ఉపయోగించవచ్చు ఎలిఫ్ మరియు ఒక లేకపోతే ఇతర షరతులను అమలు చేయడానికి:
myList = ['Python', 'MUO', 'Hello']
if ('Python') in myList:
print('No')
elif 'N' in myList[1]:
print('MUO')
elif 'e' in myList[2]:
print('Hello')
else:
print('None is true')
Output: Hello
'ఇన్,' 'మరియు,' మరియు 'లేదా' పైథాన్‌తో కీవర్డ్‌లు ఎలా ఉపయోగించాలి
మీరు దీనిని ఉపయోగించవచ్చు లో తో కీవర్డ్ ఉంటే జాబితా లేదా శ్రేణిలో ఒక అంశం ఉందో లేదో తనిఖీ చేయడానికి ప్రకటన:
myList = ['Python', 'MUO', 'Hello']
if ('Python') in myList:
print('It's in the list')
Output: It's in the list
మీరు కూడా ఉపయోగించవచ్చు మరియు తో వ్యక్తీకరణ ఉంటే ఒకే వస్తువు కంటే ఎక్కువ తనిఖీ చేయడానికి:
myList = ['Python', 'MUO', 'Hello']
if ('Python' and 'Hello') in myList:
print('Hello Python')
Output: Hello Python
సంబంధిత: బడ్డింగ్ ప్రోగ్రామర్‌ల కోసం పైథాన్ రీఎక్స్ చీట్ షీట్
జాబితాలో ఏదైనా అంశం ఉందో లేదో తనిఖీ చేయడానికి, మీరు దాన్ని ఉపయోగించవచ్చు లేదా కీవర్డ్:
myList = ['Python', 'MUO', 'Hello']
if ('Python' or 'Bags') in myList:
print('One of them is on the list')
Output: One of them is on the list
లూప్‌తో ఉంటే పైథాన్‌ను ఎలా ఉపయోగించాలి
మీరు ఏమి జరుగుతుందో కూడా నియంత్రించవచ్చు కోసం తో లూప్ ఉంటే పరిస్థితి. ఉదాహరణకు, మీరు పరిస్థితులను సెట్ చేయవచ్చు లూప్ కోసం పైథాన్‌తో జాబితా లేదా శ్రేణి ద్వారా లూపింగ్ . ఇది ఎలా పని చేస్తుందో చూడటానికి దిగువ ఉదాహరణ కోడ్‌ని చూడండి:
myList = myList = ['Python', 'MUO', 'Hello']
myList2 = ['Fish', 'Gold', 'Bag']
if len(myList) == 3:
for items in myList:
print(items)
else:
for items2 in myList2:
print(items2)
పైన ఉన్న కోడ్ పొడవును చెక్ చేస్తుంది myList స్టేట్మెంట్ నిజమైతే సరిగ్గా మూడు మరియు దాని ద్వారా ఉచ్చులు. లేకపోతే, అది అమలు చేస్తుంది లేకపోతే స్టేట్మెంట్ మరియు ప్రతి అంశాన్ని అవుట్పుట్ చేస్తుంది myList2 .
అయితే, మీరు ఆ కోడ్‌ని కూడా సరిగా నాలుగు వర్డ్‌కౌంట్‌లతో జాబితాలోని అన్ని అంశాలను ప్రింట్ చేయడానికి సవరించవచ్చు:
myList = ['Python', 'MUO', 'Hello', 'Books', 'Pizza', 'Four']
myList2 = ['Fish', 'Gold', 'Bag']
for items in (myList + myList2):
if len(items) == 4:
print(items)
పైన ఉన్న కోడ్ మొదట రెండు జాబితాలను కలుపుతుంది. ఇది రెండు జాబితాలలో సరిగ్గా నాలుగు వర్డ్‌కౌంట్‌లతో ఐటెమ్‌లు ఉన్నాయా అని తనిఖీ చేస్తుంది మరియు స్టేట్మెంట్ నిజమేనా అని వాటిని లూప్ చేస్తుంది.
విండోస్ 7 లో బాహ్య హార్డ్ డిస్క్ కనుగొనబడలేదు
పైథాన్ ఫంక్షన్‌లో if స్టేట్‌మెంట్‌ను ఎలా ఉపయోగించాలి
ది ఉంటే పైథాన్‌లో ఫంక్షన్ వ్రాసేటప్పుడు పరిస్థితి కూడా ఉపయోగపడుతుంది. సాదా కోడ్‌లో చేసినట్లుగా, ది ఉంటే ఫంక్షన్‌లో ఏమి జరుగుతుందో పరిస్థితి నిర్దేశిస్తుంది.
సంబంధిత: పైథాన్‌లో మీ స్వంత మాడ్యూల్‌ను ఎలా సృష్టించాలి, దిగుమతి చేసుకోవాలి మరియు తిరిగి ఉపయోగించాలి
దీనిని ఎలా ఉపయోగించాలో చూద్దాం ఉంటే పైథాన్ ఫంక్షన్‌లో స్టేట్మెంట్ మరియు ఇతర షరతులు పై మునుపటి విభాగంలో కోడ్ యొక్క చివరి బ్లాక్‌ను రీఫ్యాక్టరింగ్ చేయడం ద్వారా:
def checkString(list1, list2):
for items in (list1 + list2):
if len(items) == 4:
print(items)
break
else:
print('impossible')
List1 = ['Python', 'MUO', 'Hello', 'Books', 'Pizza', 'Four']
List2 = ['Fish', 'Gold', 'Bag']
checkString(List, List2)
మునుపటి విభాగంలో కోడ్ వలె, పై ఫంక్షన్ అన్ని అంశాలను ఖచ్చితంగా నాలుగు వర్డ్‌కౌంట్‌లతో అందిస్తుంది. అయితే, ది విరామం పరిస్థితిని సంతృప్తిపరిచే చివరి అంశాన్ని ముద్రించిన తర్వాత అమలు నిలిపివేయబడుతుందని ప్రకటన నిర్ధారిస్తుంది. లోపల ఈవెంట్ ఉంటే ఉంటే ప్రకటన తప్పు, ది లేకపోతే కండిషన్ దానిలోని ఆదేశాన్ని అమలు చేస్తుంది.
పైథాన్ లంబ్డా ఫంక్షన్‌తో if స్టేట్‌మెంట్‌ని ఉపయోగించడం
మీరు అజ్ఞాత లాంబ్డా ఫంక్షన్‌తో కూడా if స్టేట్‌మెంట్‌ను ఉపయోగించవచ్చు. మీకు కావలసిందల్లా ఒక పైథాన్ లాంబ్డా ఫంక్షన్ యొక్క ప్రాథమిక అవగాహన ఇది చేయుటకు.
ఇది ఎలా పనిచేస్తుందో అర్థం చేసుకోవడానికి మునుపటి విభాగంలో ఫంక్షన్‌ను లాంబ్డా ఫంక్షన్‌గా మళ్లీ వ్రాద్దాం:
checkString = lambda a, b: [y for y in (a + b) if len(y) == 4]
print(checkString(List1, List2))
Output: ['Four', 'Fish', 'Gold']
పైన ఉన్న లాంబ్డా ఫంక్షన్ మునుపటి విభాగంలో మేము ఉపయోగించిన సాధారణ ఫంక్షన్ వలె అదే అవుట్‌పుట్‌ను ఇస్తుంది. అయితే, ఇక్కడ, పైథాన్ లిస్ట్ కాంప్రహెన్షన్‌ను సృష్టించడం ద్వారా మేము కోడ్‌ను వ్యక్తం చేసాము.
పైథాన్ లిస్ట్ కాంప్రహెన్షన్‌లో ఇఫ్ స్టేట్‌మెంట్‌ను ఎలా ఉపయోగించాలి
దీనిని ఉపయోగించడం కూడా సాధ్యమే ఉంటే తో ప్రకటన కోసం జాబితా అవగాహనలో లూప్. ఈ ఉదాహరణలో, జాబితా కాంప్రహెన్షన్‌లోని నాలుగు వర్డ్‌కౌంట్‌లతో అన్ని అంశాలను ప్రింట్ చేయడానికి మునుపటి కోడ్‌ని మళ్లీ వ్రాద్దాం:
ఆండ్రాయిడ్‌లో టెక్స్ట్‌ను ఎలా ఫార్వార్డ్ చేయాలి
myList = ['Python', 'MUO', 'Hello', 'Books', 'Pizza', 'Four']
myList2 = ['Fish', 'Gold', 'Bag']
lis = [lists for lists in (myList + myList2) if len(lists) is 4]
print(lis)
Output: ['Four', 'Fish', 'Gold']
సంబంధిత: పైథాన్ లిస్ట్ కాంప్రహెన్షన్‌లను ఎలా ఉపయోగించాలి (మరియు వాటిని ఎప్పుడు ఉపయోగించకూడదు)
మీరు కూడా ఉపయోగించవచ్చు ఉంటే ... మరియు లేదా ఉంటే ... లేదా జాబితా అవగాహనలో. ముందుగా, యొక్క వినియోగ కేసును చూద్దాం ఉంటే ... లేదా పైథాన్ జాబితా అవగాహనలో:
myList = ['Python', 'MUO', 'Hello', 'Books', 'Pizza', 'Four']
myList2 = ['Fish', 'Gold', 'Bag']
lis = [lists for lists in (myList + myList2) if ('P' in lists or 'F' in lists)]
print(lis)
Output: ['Python', 'Pizza', 'Four', 'Fish']
వాటిలో 'P' లేదా 'F' అనే వర్ణమాల ఉన్న అంశాలు ఉన్నాయా అని కోడ్ తనిఖీ చేస్తుంది మరియు స్టేట్మెంట్ నిజమైతే వాటిని అవుట్పుట్ చేస్తుంది.
మనం కూడా ఉపయోగించవచ్చు ఉంటే ... మరియు 'P' మరియు 'o' రెండు తీగలను కలిగి ఉన్న అంశాలను ముద్రించడానికి:
lis = [lists for lists in (myList + myList2) if ('P' in lists and 'o' in lists)]
print(lis)
Output: ['Python']
జాబితాలో 'P' మరియు 'o' రెండింటిని కలిగి ఉన్న ఏకైక అంశం కనుక పై కోడ్ 'పైథాన్' మాత్రమే అవుట్పుట్ చేస్తుంది.
పైథాన్ లిస్ట్ కాంప్రహెన్షన్‌లో నెస్టెడ్ ఎలా ఉపయోగించాలి
కొన్ని సందర్భాల్లో, మీరు గూడును కూడా ఉపయోగించవచ్చు ఉంటే జాబితా గ్రహణంలోని పరిస్థితి. గూడు ఉపయోగించి మూడు మరియు ఐదులను విభజించగల అన్ని సంఖ్యలను అవుట్పుట్ చేసే లిస్ట్ కాంప్రహెన్షన్ యొక్క ఉదాహరణను చూద్దాం. ఉంటే పరిస్థితులు:
B = range(31)
A = [x for x in B if x % 3 == 0 if x % 5 ==0]
print(A)
Output: [0, 15, 30]
అయితే, జాబితాకు బదులుగా సెట్ కాంప్రహెన్షన్ ఉపయోగించి పై కోడ్ ఏమి చేస్తుందో మీరు చేయవచ్చు. కానీ ఈసారి, మీరు మీ అవుట్‌పుట్‌ను సెట్ అక్షరాలా పొందుతారు:
A = {x for x in B if x % 3 == 0 if x % 5 ==0}
print(A)
Output: {0, 30, 15}
ఇతర జాబితా కాంప్రహెన్షన్ ఉదాహరణలను కూడా గ్రహించడానికి సెట్ చేయడం ద్వారా వాటిని ఆడటానికి సంకోచించకండి.
లాజికల్ స్టేట్‌మెంట్‌లు అనేక ఆటోమేటెడ్ ప్రోగ్రామ్‌లను నియంత్రిస్తాయి
లాజికల్ స్టేట్‌మెంట్‌లు నేడు అనేక కోడెడ్ ప్రోగ్రామ్‌ల బిల్డింగ్ బ్లాక్స్, మరియు పైథాన్‌లో పనిచేసే ప్రోగ్రామ్‌ల విషయానికి వస్తే ఇది భిన్నంగా లేదు. అయితే, మేము ముందే చెప్పినట్లుగా, షరతులతో కూడిన స్టేట్‌మెంట్‌లు మీ కోడ్‌ని బాగా అర్థం చేసుకుంటాయి, కాబట్టి మీరు మీకు కావలసిన విధంగా విషయాలను సర్దుబాటు చేయవచ్చు.
గేమ్ డెవలప్‌మెంట్, మెషిన్ లెర్నింగ్ మరియు వెబ్ డెవలప్‌మెంట్ వంటి నిజ-జీవిత ప్రాజెక్ట్‌లు టాస్క్ ఆటోమేషన్ కోసం ఈ షరతులతో కూడిన స్టేట్‌మెంట్‌లపై ఆధారపడి ఉంటాయి. కాబట్టి, రాబోయే ప్రోగ్రామర్‌గా, డైనమిక్ మరియు ప్రతిస్పందించే ఆధునిక టెక్ ప్రోగ్రామ్‌లను కోడ్ చేయడానికి వాటి గురించి మరియు అవి ఎలా పని చేస్తాయనే దాని గురించి మరింత నేర్చుకోవడం అవసరం.
షేర్ చేయండి షేర్ చేయండి ట్వీట్ ఇమెయిల్ పైథాన్‌లో కొంతకాలం లూప్‌ను ఎలా ఉపయోగించాలిలూప్లు కోడింగ్‌లో ప్రాథమిక భాగం అయితే, వాటిని ఇక్కడ ఉత్తమంగా ఎలా ఉపయోగించాలో తెలుసుకోండి.
తదుపరి చదవండి సంబంధిత అంశాలు- ప్రోగ్రామింగ్
- పైథాన్
ఇడోవు ఏదైనా స్మార్ట్ టెక్ మరియు ఉత్పాదకతపై మక్కువ చూపుతుంది. తన ఖాళీ సమయంలో, అతను కోడింగ్‌తో ఆడుతాడు మరియు అతను విసుగు చెందినప్పుడు చెస్‌బోర్డ్‌కు మారతాడు, కానీ అతను ఒక్కోసారి రొటీన్ నుండి దూరంగా ఉండడాన్ని కూడా ఇష్టపడతాడు. ఆధునిక సాంకేతిక పరిజ్ఞానం చుట్టూ ప్రజలకు మార్గం చూపించాలనే అతని అభిరుచి అతన్ని మరింత రాయడానికి ప్రేరేపిస్తుంది.
ఇడోవు ఒమిసోలా నుండి మరిన్నిమా వార్తాలేఖకు సభ్యత్వాన్ని పొందండి
టెక్ చిట్కాలు, సమీక్షలు, ఉచిత ఈబుక్‌లు మరియు ప్రత్యేకమైన డీల్స్ కోసం మా వార్తాలేఖలో చేరండి!
సభ్యత్వం పొందడానికి ఇక్కడ క్లిక్ చేయండి