పైథాన్ టెర్నరీ ఆపరేటర్లు (షరతులతో కూడిన ఆపరేటర్లు) అని పిలువబడే ఒక వ్రాత శైలిని కలిగి ఉంది, ఇది ఒకే లైన్‌లో if స్టేట్‌మెంట్ వంటి ప్రక్రియను వివరించగలదు.
నమూనా కోడ్‌తో పాటు క్రిందివి ఇక్కడ వివరించబడ్డాయి.
- టెర్నరీ ఆపరేటర్ల ప్రాథమిక రచన
if ... elif ... else ...దీన్ని ఒక లైన్‌లో వివరించండి- జాబితా సమగ్ర సంజ్ఞామానం మరియు టెర్నరీ ఆపరేటర్లను కలపడం
- అనామక ఫంక్షన్‌లు (లాంబ్డా వ్యక్తీకరణలు) మరియు టెర్నరీ ఆపరేటర్ల కలయిక
సాధారణ if స్టేట్‌మెంట్‌పై మరింత సమాచారం కోసం క్రింది కథనాన్ని చూడండి.
టెర్నరీ ఆపరేటర్ల ప్రాథమిక రచన
పైథాన్‌లో, టెర్నరీ ఆపరేటర్‌ని ఈ క్రింది విధంగా వ్రాయవచ్చు
Expression evaluated when the conditional expression is true if conditional expression else Expression evaluated when the conditional expression is false
మీరు షరతులకు అనుగుణంగా విలువలను మార్చాలనుకుంటే, ప్రతి విలువను అలాగే వ్రాయండి.
Value to return if conditional expression is true if conditional expression else Value to return if conditional expression is false
a = 1
result = 'even' if a % 2 == 0 else 'odd'
print(result)
# odd
a = 2
result = 'even' if a % 2 == 0 else 'odd'
print(result)
# even
మీరు షరతులకు అనుగుణంగా ప్రాసెసింగ్‌ని మార్చాలనుకుంటే, ప్రతి వ్యక్తీకరణను వివరించండి.
a = 1
result = a * 2 if a % 2 == 0 else a * 3
print(result)
# 3
a = 2
result = a * 2 if a % 2 == 0 else a * 3
print(result)
# 4
విలువను అందించని వ్యక్తీకరణలు (ఏదీ ఇవ్వని వ్యక్తీకరణలు) కూడా ఆమోదయోగ్యమైనవి. పరిస్థితిపై ఆధారపడి, వ్యక్తీకరణలలో ఒకటి మూల్యాంకనం చేయబడుతుంది మరియు ప్రక్రియ అమలు చేయబడుతుంది.
a = 1
print('even') if a % 2 == 0 else print('odd')
# odd
సాధారణ if స్టేట్‌మెంట్‌తో వ్రాసిన క్రింది కోడ్‌కి సమానం.
a = 1
if a % 2 == 0:
print('even')
else:
print('odd')
# odd
లాజికల్ ఆపరేటర్లను (మరియు, లేదా, మొదలైనవి) ఉపయోగించి బహుళ షరతులతో కూడిన వ్యక్తీకరణలను కూడా కలపవచ్చు.
a = -2
result = 'negative and even' if a < 0 and a % 2 == 0 else 'positive or odd'
print(result)
# negative and even
a = -1
result = 'negative and even' if a < 0 and a % 2 == 0 else 'positive or odd'
print(result)
# positive or odd
if ... elif ... else ...ఒక లైన్ వివరణ
if ... elif ... else ...దీన్ని సింగిల్ లైన్‌లో రాయడానికి ప్రత్యేకంగా ఏమీ లేదు. అయినప్పటికీ, టెర్నరీ ఆపరేటర్ యొక్క షరతులతో కూడిన వ్యక్తీకరణ తప్పు అయినప్పుడు మూల్యాంకనం చేయబడిన వ్యక్తీకరణలో మరొక టెర్నరీ ఆపరేటర్‌ని ఉపయోగించడం ద్వారా దీనిని గ్రహించవచ్చు. టెర్నరీ ఆపరేటర్ల గూడులో ఉన్న చిత్రం.
ఏది ఏమైనప్పటికీ, ఇది చదవగలిగే సామర్థ్యాన్ని తగ్గిస్తుంది కాబట్టి దీనిని విస్తృతంగా ఉపయోగించకపోవడమే మంచిది.
a = 2
result = 'negative' if a < 0 else 'positive' if a > 0 else 'zero'
print(result)
# positive
a = 0
result = 'negative' if a < 0 else 'positive' if a > 0 else 'zero'
print(result)
# zero
a = -2
result = 'negative' if a < 0 else 'positive' if a > 0 else 'zero'
print(result)
# negative
కింది షరతులతో కూడిన వ్యక్తీకరణను క్రింది రెండు విధాలుగా అర్థం చేసుకోవచ్చు, అయితే ఇది మునుపటిది (1)గా పరిగణించబడుతుంది.
A if condition 1 else B if condition 2 else C
1. A if condition 1 else ( B if condition 2 else C )
2. ( A if condition 1 else B ) if condition 2 else C
ఒక నిర్దిష్ట ఉదాహరణ క్రింది విధంగా ఉంది. మొదటి వ్యక్తీకరణ రెండవది వలె పరిగణించబడుతుంది.
a = -2
result = 'negative' if a < 0 else 'positive' if a > 0 else 'zero'
print(result)
# negative
result = 'negative' if a < 0 else ('positive' if a > 0 else 'zero')
print(result)
# negative
result = ('negative' if a < 0 else 'positive') if a > 0 else 'zero'
print(result)
# zero
జాబితా సమగ్ర సంజ్ఞామానం మరియు టెర్నరీ ఆపరేటర్లను కలపడం
లిస్ట్ కాంప్రహెన్షన్ నోటేషన్‌లో జాబితాలను ప్రాసెస్ చేస్తున్నప్పుడు టెర్నరీ ఆపరేటర్ యొక్క ఉపయోగకరమైన ఉపయోగం.
టెర్నరీ ఆపరేటర్ మరియు జాబితా కాంప్రహెన్షన్ సంజ్ఞామానాన్ని కలపడం ద్వారా, జాబితా యొక్క మూలకాలను భర్తీ చేయడం లేదా షరతులపై ఆధారపడి కొన్ని ఇతర ప్రాసెసింగ్ చేయడం సాధ్యపడుతుంది.
l = ['even' if i % 2 == 0 else i for i in range(10)]
print(l)
# ['even', 1, 'even', 3, 'even', 5, 'even', 7, 'even', 9]
l = [i * 10 if i % 2 == 0 else i for i in range(10)]
print(l)
# [0, 1, 20, 3, 40, 5, 60, 7, 80, 9]
జాబితా కాంప్రహెన్షన్ సంజ్ఞామానం గురించి మరింత సమాచారం కోసం, క్రింది కథనాన్ని చూడండి.
అనామక ఫంక్షన్‌లు (లాంబ్డా వ్యక్తీకరణలు) మరియు టెర్నరీ ఆపరేటర్ల కలయిక
టెర్నరీ ఆపరేటర్, ఇది అనామక ఫంక్షన్ (లాంబ్డా ఎక్స్‌ప్రెషన్)లో కూడా క్లుప్తంగా వివరించబడుతుంది.
get_odd_even = lambda x: 'even' if x % 2 == 0 else 'odd'
print(get_odd_even(1))
# odd
print(get_odd_even(2))
# even
టెర్నరీ ఆపరేటర్‌తో సంబంధం లేనప్పటికీ, పై ఉదాహరణ లాంబ్డా వ్యక్తీకరణకు పేరును కేటాయించిందని గమనించండి. కాబట్టి, పైథాన్ కోడింగ్ కన్వెన్షన్ PEP8 వంటి ఆటోమేటిక్ చెకింగ్ టూల్స్ హెచ్చరికను రూపొందించవచ్చు.
ఎందుకంటే ఫంక్షన్‌లకు పేర్లను కేటాయించేటప్పుడు PEP8 డెఫ్‌ని ఉపయోగించమని సిఫార్సు చేస్తుంది.
PEP8 యొక్క భావన క్రింది విధంగా ఉంది
- లాంబ్డా వ్యక్తీకరణలు కాల్ చేయగల వస్తువులను ఆర్గ్యుమెంట్‌లుగా పాస్ చేయడానికి ఉపయోగించబడతాయి, ఉదాహరణకు, వాటికి పేరు పెట్టకుండా
- లాంబ్డా వ్యక్తీకరణలలో, పేరు ద్వారా నిర్వచించడానికి డెఫ్ ఉపయోగించండి
