పైథాన్ - జాబితా ఖాళీగా ఉందో లేదో తనిఖీ చేసే పద్ధతులు

పైథాన్‌లో జాబితా శూన్యతను తనిఖీ చేస్తోంది

పైథాన్‌లో జాబితాలతో పని చేస్తున్నప్పుడు, జాబితా ఖాళీగా ఉందో లేదో మీరు తరచుగా గుర్తించవలసి ఉంటుంది. మీరు ఉనికిలో లేని మూలకాలను ప్రాసెస్ చేయడానికి ప్రయత్నించడం లేదని నిర్ధారించుకోవడం ద్వారా మీ కోడ్‌లో లోపాలను నివారించడంలో ఇది మీకు సహాయపడే సాధారణ పని.

ఈ కథనంలో, జాబితా ఖాళీగా ఉందో లేదో తనిఖీ చేయడానికి మేము వివిధ పద్ధతులను అన్వేషిస్తాము. ఈ పద్ధతులను అర్థం చేసుకోవడం వలన మీరు మరింత సమర్థవంతమైన మరియు లోపం లేని పైథాన్ కోడ్‌ను వ్రాయగలుగుతారు, ప్రత్యేకించి డైనమిక్ డేటా స్ట్రక్చర్‌లతో వ్యవహరించేటప్పుడు.

జాబితా శూన్యతను తనిఖీ చేయడం కోసం పైథాన్ స్క్రిప్ట్‌లను అర్థం చేసుకోవడం

మొదటి స్క్రిప్ట్ ఉదాహరణలో, జాబితా ఖాళీగా ఉందో లేదో తనిఖీ చేయడానికి మేము రెండు ప్రాథమిక పద్ధతులను ఉపయోగించాము. మొదటి పద్ధతిని ఉపయోగిస్తుంది if not ప్రకటన. మేము వ్రాసేటప్పుడు if not a:, పైథాన్ జాబితాను మూల్యాంకనం చేస్తుంది a ఖాళీగా ఉంది. బూలియన్ సందర్భంలో ఖాళీ జాబితా తప్పుగా పరిగణించబడుతుంది, కాబట్టి జాబితా ఖాళీగా ఉంటే, సంబంధిత ప్రింట్ స్టేట్‌మెంట్‌ను ట్రిగ్గర్ చేయడం ద్వారా షరతు నిజం అవుతుంది. రెండవ పద్ధతిని కలిగి ఉంటుంది len() ఫంక్షన్. ఉపయోగించడం ద్వార len(a) == 0, జాబితాలోని అంశాల సంఖ్య సున్నా అయితే మేము నేరుగా తనిఖీ చేస్తాము. అది ఉంటే, జాబితా ఖాళీగా ఉంటుంది మరియు సంబంధిత ప్రింట్ స్టేట్‌మెంట్ అమలు చేయబడుతుంది. ఈ పద్ధతులు మీ కోడ్‌లో సంభావ్య లోపాలను నివారించడం ద్వారా ఖాళీ జాబితాల కోసం తనిఖీ చేయడానికి శీఘ్ర మరియు సమర్థవంతమైన మార్గాలను అందిస్తాయి.

రెండవ స్క్రిప్ట్ ఉదాహరణలో, మేము రెండు ఫంక్షన్లను నిర్వచించాము: is_list_empty1(lst) మరియు is_list_empty2(lst). మొదటి ఫంక్షన్‌ని ఉపయోగించి జాబితా ఖాళీగా ఉందో లేదో తనిఖీ చేస్తుంది if not ప్రకటన, జాబితా ఖాళీగా ఉంటే ఒప్పు మరియు లేకపోతే తప్పు అని తిరిగి వస్తుంది. రెండవ ఫంక్షన్ ఉపయోగిస్తుంది len() అదే ఫలితాన్ని సాధించడానికి ఫంక్షన్. ఈ చెక్‌లను ఫంక్షన్‌లలో ఎన్‌క్యాప్సులేట్ చేయడం ద్వారా, మేము వాటిని మా కోడ్ అంతటా మళ్లీ ఉపయోగించుకోవచ్చు, ఇది క్లీనర్‌గా మరియు మరింత మెయింటెనబుల్‌గా చేస్తుంది. ఫంక్షన్లను నిర్వచించిన తర్వాత, మేము వాటిని ఖాళీ జాబితాతో పరీక్షించాము a మరియు షరతులతో కూడిన వ్యక్తీకరణలను ఉపయోగించి ఫలితాలను ముద్రించారు. ఈ విధానం పునర్వినియోగ కోడ్ బ్లాక్‌లను సృష్టించడం యొక్క ప్రాముఖ్యతను నొక్కి చెబుతుంది మరియు డైనమిక్ డేటా నిర్మాణాలను ఎలా సమర్థవంతంగా నిర్వహించాలో చూపుతుంది.

# Method 1: Using the 'if not' statement
a = []
if not a:
    print("List is empty")
else:
    print("List is not empty")

# Method 2: Using the len() function
a = []
if len(a) == 0:
    print("List is empty")
else:
    print("List is not empty")

# Function to check if a list is empty using 'if not'
def is_list_empty1(lst):
    return not lst

# Function to check if a list is empty using len()
def is_list_empty2(lst):
    return len(lst) == 0

a = []
print("List is empty" if is_list_empty1(a) else "List is not empty")
print("List is empty" if is_list_empty2(a) else "List is not empty")

పైథాన్‌లో జాబితా శూన్యతను తనిఖీ చేయడానికి అదనపు పద్ధతులు

ఉపయోగించి ప్రాథమిక పద్ధతులకు మించి if not మరియు len(), జాబితా ఖాళీగా ఉందో లేదో తనిఖీ చేయడానికి పైథాన్ ఇతర పద్ధతులను అందిస్తుంది. అటువంటి పద్ధతిలో మినహాయింపులను పెంచడం ఉంటుంది. మీరు ఇండెక్సింగ్‌ని ఉపయోగించి జాబితా యొక్క మొదటి మూలకాన్ని యాక్సెస్ చేయడానికి ప్రయత్నించవచ్చు మరియు జాబితా ఖాళీగా ఉన్నట్లయితే ఫలితంగా వచ్చే ఇండెక్స్‌లోపాన్ని నిర్వహించవచ్చు. మరింత సంక్లిష్టమైన స్క్రిప్ట్‌లలో బ్లాక్‌లను మినహాయించి ప్రయత్నించినప్పుడు ఈ విధానం ప్రత్యేకంగా ఉపయోగపడుతుంది. ఉదాహరణకి, try యాక్సెస్ చేస్తోంది a[0] ఒక ప్రయత్నించండి బ్లాక్ మరియు క్యాచ్ లోపల IndexError జాబితా యొక్క శూన్యతను గుర్తించడానికి. ఈ పద్ధతి మునుపటి వాటి కంటే తక్కువ ప్రత్యక్షంగా ఉన్నప్పటికీ, మీ కోడ్‌లోని మరింత విస్తృతమైన ఎర్రర్-హ్యాండ్లింగ్ ఫ్రేమ్‌వర్క్‌లలో ఇది సజావుగా విలీనం చేయబడుతుంది.

మరొక అధునాతన సాంకేతికత అంతర్నిర్మితాన్ని ఉపయోగించడం any() మరియు all() విధులు. ది any() జాబితాలో కనీసం ఒక మూలకం ట్రూ అని మూల్యాంకనం చేస్తే, ఫంక్షన్ ఒప్పు అని తిరిగి వస్తుంది, అయితే all() అన్ని మూలకాలు ఒప్పుకు మూల్యాంకనం చేస్తే మాత్రమే ఫంక్షన్ ట్రూని అందిస్తుంది. ఖాళీ జాబితా కోసం తనిఖీ చేయడానికి, మీరు ఈ ఫంక్షన్‌లను దీనితో కలపవచ్చు not ఆపరేటర్. ఉదాహరణకి, if not any(a) అన్ని అంశాలు తప్పుగా ఉన్నాయా లేదా జాబితా ఖాళీగా ఉందా అని తనిఖీ చేస్తుంది. అదేవిధంగా, if not all(a) నిజమైన మూలకాలు లేకపోయినా లేదా జాబితా ఖాళీగా ఉంటే ధృవీకరించడానికి ఉపయోగించవచ్చు. ఈ పద్ధతులు తక్కువ సాధారణమైనప్పటికీ, బూలియన్ లేదా సత్యమైన విలువలను కలిగి ఉన్న జాబితాలతో వ్యవహరించేటప్పుడు అదనపు సౌలభ్యాన్ని అందిస్తాయి.

జాబితా శూన్యతను తనిఖీ చేయడానికి ముగింపు మరియు ఉత్తమ పద్ధతులు

సారాంశంలో, పైథాన్‌లో జాబితా ఖాళీగా ఉందో లేదో తనిఖీ చేయడం, కాకపోతే, len(), మరియు బ్లాక్‌లను మినహాయించి ప్రయత్నించండి వంటి మరింత అధునాతన సాంకేతికతలతో సహా బహుళ పద్ధతుల ద్వారా సాధించవచ్చు. సరైన పద్ధతిని ఎంచుకోవడం అనేది మీ నిర్దిష్ట వినియోగ సందర్భం మరియు కోడింగ్ శైలిపై ఆధారపడి ఉంటుంది. ఈ పద్ధతులను ఉపయోగించడం వలన మీ కోడ్ సజావుగా నడుస్తుందని మరియు ఖాళీ జాబితాలతో అనుబంధించబడిన సాధారణ ఆపదలను నివారించడంలో సహాయపడుతుంది.