పైథాన్‌లో if స్టేట్‌మెంట్‌లతో షరతులతో కూడిన శాఖలను ఎలా వ్రాయాలి

వ్యాపారం

పైథాన్‌లో if స్టేట్‌మెంట్‌లతో షరతులతో కూడిన శాఖలను వివరించండి.

  • if స్టేట్‌మెంట్‌ల ప్రాథమిక అంశాలు (if, elif, else)
  • పోలిక ఆపరేటర్లు మొదలైన వాటితో షరతులను పేర్కొనండి.
  • సంఖ్య, జాబితా మొదలైన వాటి ద్వారా షరతులను పేర్కొనండి.
  • లాజికల్ ఆపరేటర్‌లతో బహుళ షరతులు లేదా ప్రతికూలతలను పేర్కొనండి (మరియు, లేదా, కాదు)
  • కొత్త పంక్తులు మరియు బహుళ పంక్తులపై షరతులతో కూడిన వ్యక్తీకరణలు

ఒక లైన్‌లో షరతులతో కూడిన శాఖను వివరించే టెర్నరీ ఆపరేటర్ కూడా ఉంది. కింది కథనాన్ని చూడండి.

if స్టేట్‌మెంట్‌ల ప్రాథమిక అంశాలు (if, elif, else)

if స్టేట్‌మెంట్ యొక్క ప్రాథమిక రూపం క్రింది విధంగా ఉంటుంది

if Conditional expression 1:
    `Processing to be performed if Expression 1 is True.`
elif Conditional expression 2:
    `Processing to be performed when expression 1 is false and expression 2 is true.`
elif Expression 3:
    `Process when expression 1 and 2 are false and expression 3 is true.`
...
else:
    `Processing when all conditionals are false.`

“elif” అనేది C మరియు ఇతర భాషలలోని “else if”కి అనుగుణంగా ఉంటుంది మరియు “elifs” ఎన్ని అయినా ఉండవచ్చు.

తప్పు అవసరం లేనప్పుడు ఒకే ఒక షరతులతో కూడిన వ్యక్తీకరణ లేదా ప్రాసెసింగ్ ఉంటే, “elif” మరియు “else” బ్లాక్‌లను విస్మరించవచ్చు.

పోలిక ఆపరేటర్లు మొదలైన వాటితో షరతులను పేర్కొనండి.

పోలిక ఆపరేటర్ వంటి బూల్ రకాన్ని (నిజం, తప్పు) అందించే ఆపరేషన్‌తో పరిస్థితిని పేర్కొనండి.

పైథాన్ కంపారిజన్ ఆపరేటర్లు ఈ క్రింది విధంగా ఉన్నాయి

ఆపరేటర్ఫలితం
x < yx y కంటే తక్కువగా ఉంటే నిజం
x <= yx y కంటే తక్కువ లేదా సమానంగా ఉంటే నిజం
x > yx y కంటే ఎక్కువగా ఉంటే నిజం
x >= yx y కంటే ఎక్కువ లేదా సమానంగా ఉంటే నిజం
x == yx మరియు y విలువలు సమానంగా ఉంటే నిజం
x != yx మరియు y విలువలు సమానంగా లేకుంటే నిజంx is yx మరియు y ఒకే వస్తువు అయితే నిజంx is not yx మరియు y ఒకే వస్తువు కాకపోతే నిజమైనదిx in yyలో x ఉంటే నిజంx not in yyలో x లేకుంటే నిజం

ఉదాహరణ. సౌలభ్యం కోసం, ఇది డెఫ్ స్టేట్‌మెంట్‌తో ఫంక్షన్‌గా నిర్వచించబడింది.

def if_test(num):
    if num > 100:
        print('100 < num')
    elif num > 50:
        print('50 < num <= 100')
    elif num > 0:
        print('0 < num <= 50')
    elif num == 0:
        print('num == 0')
    else:
        print('num < 0')

if_test(1000)
# 100 < num

if_test(70)
# 50 < num <= 100

if_test(0)
# num == 0

if_test(-100)
# num < 0

పైథాన్‌కు ప్రత్యేకమైన విధంగా ఈ క్రింది వాటిని వ్రాయవచ్చు. వివరాల కోసం క్రింది కథనాన్ని చూడండి.
a < x < b

def if_test2(num):
    if 50 < num < 100:
        print('50 < num < 100')
    else:
        print('num <= 50 or num >= 100')

if_test2(70)
# 50 < num < 100

if_test2(0)
# num <= 50 or num >= 100
  • #ERROR!
  • !=

పైన పేర్కొన్నది విలువల పోలిక; వస్తువు గుర్తింపులను సరిపోల్చడానికి, కింది వాటిని ఉపయోగించండి

  • is
  • is not

ఉదాహరణకు, పూర్ణాంకం మరియు ఫ్లోటింగ్-పాయింట్ సంఖ్యను పోల్చినప్పుడు, “==” విలువలు సమానమైతే నిజం అని చూపుతుంది, కానీ అవి వేర్వేరు వస్తువులు అయినందున “is” తప్పు అని చూపుతుంది.

i = 10
print(type(i))
# <class 'int'>

f = 10.0
print(type(f))
# <class 'float'>

print(i == f)
# True

print(i is f)
# False

జాబితా లేదా స్ట్రింగ్‌లో నిర్దిష్ట మూలకం (అక్షరం) ఉందా అనే షరతును రూపొందించడం కూడా సాధ్యమే.

  • in:చేర్చండి
  • not in:సహా కాదు
def if_test_in(s):
    if 'a' in s:
        print('a is in string')
    else:
        print('a is NOT in string')

if_test_in('apple')
# a is in string

if_test_in('melon')
# a is NOT in string

సంఖ్య, జాబితా మొదలైన వాటి ద్వారా షరతులను పేర్కొనండి.

if స్టేట్‌మెంట్ యొక్క షరతులతో కూడిన వ్యక్తీకరణ బూల్ రకం (నిజం, తప్పు) లేని సంఖ్య, జాబితా లేదా ఇతర వస్తువు కావచ్చు.

if 10:
    print('True')
# True

if [0, 1, 2]:
    print('True')
# True

పైథాన్ if స్టేట్‌మెంట్ యొక్క షరతులతో కూడిన వ్యక్తీకరణలో, కింది వస్తువులు తప్పుగా పరిగణించబడతాయి.

  • స్థిరాంకాలు తప్పుగా నిర్వచించబడ్డాయి:None,false
  • సంఖ్యా రకంలో సున్నా:0,0,0j,Decimal(0),Fraction(0, 1)
  • ఖాళీ సీక్వెన్స్ లేదా సేకరణ:',(),[],{},set(),range(0)Truth Value Testing — Built-in Types — Python 3.10.4 Documentation

సున్నా, ఖాళీ స్ట్రింగ్‌లు, జాబితాలు మొదలైన వాటిని సూచించే సంఖ్యలు తప్పుగా పరిగణించబడతాయి; మిగతావన్నీ నిజమైనవిగా పరిగణించబడతాయి.

ఆబ్జెక్ట్ ఎలా నిర్ణయించబడుతుందో bool()తో తనిఖీ చేయవచ్చు.

print(bool(10))
# True

print(bool(0.0))
# False

print(bool([]))
# False

print(bool('False'))
# True

జాబితా ఖాళీగా ఉన్నప్పుడు ప్రక్రియను వ్రాయడానికి ఇది ఉపయోగించబడుతుంది, ఉదాహరణకు.

def if_test_list(l):
    if l:
        print('list is NOT empty')
    else:
        print('list is empty')

if_test_list([0, 1, 2])
# list is NOT empty

if_test_list([])
# list is empty

తప్పు’ అనే స్ట్రింగ్ కూడా నిజం అవుతుందని గమనించండి, ఎందుకంటే పై ఉదాహరణలో చూపిన విధంగా, స్ట్రింగ్‌లో ఖాళీగా లేని ఏదైనా స్ట్రింగ్ నిజం అవుతుంది.’ ‘ట్రూ’ లేదా ‘ఫాల్స్’ వంటి నిర్దిష్ట స్ట్రింగ్‌ను 1,0కి మార్చడానికి, distutils.util మాడ్యూల్‌లో strtobool()ని ఉపయోగించండి.

లాజికల్ ఆపరేటర్‌లతో బహుళ షరతులు లేదా ప్రతికూలతలను పేర్కొనండి (మరియు, లేదా, కాదు)

లాజికల్ ఆపరేటర్లు (మరియు, లేదా, కాదు) లాజికల్ సంయోగం, లాజికల్ డిస్‌జంక్షన్ మరియు బహుళ పరిస్థితుల నిరాకరణను నిర్వహించడానికి ఉపయోగించవచ్చు.

ఆపరేటర్(ఫలితం (ఒక if స్టేట్‌మెంట్ యొక్క షరతులతో కూడిన వ్యక్తీకరణలో)
x and yx మరియు y రెండూ నిజమైతే నిజం
x or yx లేదా y నిజమైతే నిజం
not xx నిజమైతే తప్పు, x తప్పు అయితే నిజం
def if_test_and_not(num):
    if num >= 0 and not num % 2 == 0:
        print('num is positive odd')
    else:
        print('num is NOT positive odd')

if_test_and_not(5)
# num is positive odd

if_test_and_not(10)
# num is NOT positive odd

if_test_and_not(-10)
# num is NOT positive odd

నిజానికి, “x మరియు y” మరియు “x లేదా y” అనేవి ట్రూ లేదా ఫాల్స్ ఇవ్వవు, కానీ x లేదా y. if స్టేట్‌మెంట్‌లలో షరతులతో కూడిన వ్యక్తీకరణలలో అవి ఉపయోగించబడినంత కాలం, వాటి గురించి ఆందోళన చెందాల్సిన అవసరం లేదు, ఎందుకంటే అవి ఒప్పు లేదా తప్పుగా మూల్యాంకనం చేస్తాయి. వివరాల కోసం క్రింది కథనాన్ని చూడండి.

ఇది ఒకటి కంటే ఎక్కువసార్లు మరియు మరియు లేదా అంతకంటే ఎక్కువ సార్లు ఉపయోగించడం సాధ్యమవుతుంది.

def if_test_and_not_or(num):
    if num >= 0 and not num % 2 == 0 or num == -10:
        print('num is positive odd or -10')
    else:
        print('num is NOT positive odd or -10')

if_test_and_not_or(5)
# num is positive odd or -10

if_test_and_not_or(10)
# num is NOT positive odd or -10

if_test_and_not_or(-10)
# num is positive odd or -10

కొత్త పంక్తులు మరియు బహుళ పంక్తులపై షరతులతో కూడిన వ్యక్తీకరణలు

బహుళ షరతులతో కూడిన వ్యక్తీకరణలను “మరియు” లేదా “లేదా”తో కనెక్ట్ చేయడం ద్వారా ఉపయోగించినప్పుడు మరియు ప్రతి పంక్తి పొడవుగా మారినప్పుడు, కొన్నిసార్లు షరతులతో కూడిన వ్యక్తీకరణను విచ్ఛిన్నం చేసి బహుళ పంక్తులలో వ్రాయడం అవసరం.

బ్యాక్‌స్లాష్‌ని ఉపయోగించడం ద్వారా లేదా మొత్తం పంక్తిని కుండలీకరణాల్లో చేర్చడం ద్వారా లైన్ బ్రేక్ చేయవచ్చు.

def if_test_and_backslash(num):
    if num >= 0 \
       and not num % 2 == 0:
        print('num is positive odd')
    else:
        print('num is NOT positive odd')

if_test_and_backslash(5)
# num is positive odd

def if_test_and_brackets(num):
    if (num >= 0
        and not num % 2 == 0):
        print('num is positive odd')
    else:
        print('num is NOT positive odd')

if_test_and_brackets(5)
# num is positive odd

మీకు నచ్చినన్ని సార్లు లైన్‌ను బ్రేక్ చేయడానికి మీరు బ్యాక్‌స్లాష్‌ని ఉపయోగించవచ్చు. అదేవిధంగా, మీరు కుండలీకరణాల్లో ఎన్నిసార్లు అయినా పంక్తిని విచ్ఛిన్నం చేయవచ్చు. ఇండెంటేషన్ పరిమితి లేదు.

ఇది if స్టేట్‌మెంట్‌లలో మాత్రమే కాకుండా పైథాన్ కోడ్‌లో ఎక్కడైనా ఉపయోగించగల టెక్నిక్ అని గమనించండి.

Copied title and URL