பைதான் - ஒரு பட்டியல் காலியாக உள்ளதா என்பதைச் சரிபார்க்கும் முறைகள்

பைத்தானில் பட்டியல் வெறுமையை சரிபார்க்கிறது

பைத்தானில் பட்டியல்களுடன் பணிபுரியும் போது, ​​ஒரு பட்டியல் காலியாக உள்ளதா என்பதை நீங்கள் அடிக்கடி தீர்மானிக்க வேண்டும். இது ஒரு பொதுவான பணியாகும், இது உங்கள் குறியீட்டில் உள்ள பிழைகளைத் தவிர்க்க உதவும், நீங்கள் இல்லாத கூறுகளைச் செயலாக்க முயற்சிக்கவில்லை என்பதை உறுதிப்படுத்திக் கொள்ளலாம்.

இந்தக் கட்டுரையில், பட்டியல் காலியாக உள்ளதா என்பதைச் சரிபார்க்க பல்வேறு முறைகளை ஆராய்வோம். இந்த முறைகளைப் புரிந்துகொள்வது மிகவும் திறமையான மற்றும் பிழையற்ற பைதான் குறியீட்டை எழுத உதவும், குறிப்பாக டைனமிக் தரவு கட்டமைப்புகளைக் கையாளும் போது.

கட்டளை	விளக்கம்
if not	அதன் உண்மைத்தன்மையை மதிப்பிடுவதன் மூலம் பட்டியல் காலியாக உள்ளதா என்பதைச் சரிபார்க்கிறது, இது வெற்றுப் பட்டியல்களுக்கு தவறானது என்பதை வழங்குகிறது.
len()	பட்டியலில் உள்ள உருப்படிகளின் எண்ணிக்கையை வழங்குகிறது. வெற்று பட்டியலுக்கு, அது 0 ஐ வழங்குகிறது.
def	ஒரு செயல்பாட்டை வரையறுக்கிறது. பட்டியல் காலியாக உள்ளதா என்பதைச் சரிபார்க்க மீண்டும் பயன்படுத்தக்கூடிய குறியீடு தொகுதிகளை உருவாக்கப் பயன்படுகிறது.
return	ஒரு செயல்பாட்டிலிருந்து வெளியேறி, விருப்பமாக ஒரு வெளிப்பாடு அல்லது மதிப்பை அழைப்பாளருக்கு அனுப்புகிறது.
print()	கன்சோல் அல்லது பிற நிலையான வெளியீட்டு சாதனத்தில் குறிப்பிட்ட செய்தியை அச்சிடுகிறது.

பட்டியல் வெறுமையை சரிபார்க்க பைதான் ஸ்கிரிப்ட்களைப் புரிந்துகொள்வது

முதல் ஸ்கிரிப்ட் எடுத்துக்காட்டில், பட்டியல் காலியாக உள்ளதா என்பதைச் சரிபார்க்க இரண்டு முதன்மை முறைகளைப் பயன்படுத்தினோம். முதல் முறை பயன்படுத்துகிறது அறிக்கை. நாம் எழுதும் போது , பைதான் பட்டியல் என்பதை மதிப்பிடுகிறது காலியாக உள்ளது. பூலியன் சூழலில் ஒரு வெற்று பட்டியல் தவறானதாகக் கருதப்படுகிறது, எனவே பட்டியல் காலியாக இருந்தால் நிபந்தனை உண்மையாகி, தொடர்புடைய அச்சு அறிக்கையைத் தூண்டும். இரண்டாவது முறை உள்ளடக்கியது len() செயல்பாடு. பயன்படுத்தி , பட்டியலில் உள்ள உருப்படிகளின் எண்ணிக்கை பூஜ்ஜியமாக உள்ளதா என்பதை நேரடியாகச் சரிபார்க்கிறோம். அது இருந்தால், பட்டியல் காலியாக உள்ளது மற்றும் தொடர்புடைய அச்சு அறிக்கை செயல்படுத்தப்படும். இந்த முறைகள் உங்கள் குறியீட்டில் சாத்தியமான பிழைகளைத் தவிர்த்து, வெற்றுப் பட்டியல்களைச் சரிபார்க்க விரைவான மற்றும் திறமையான வழிகளை வழங்குகிறது.

இரண்டாவது ஸ்கிரிப்ட் எடுத்துக்காட்டில், நாங்கள் இரண்டு செயல்பாடுகளை வரையறுத்துள்ளோம்: மற்றும் . ஒரு பட்டியல் காலியாக உள்ளதா என்பதை முதல் செயல்பாடு சரிபார்க்கிறது அறிக்கை, பட்டியல் காலியாக இருந்தால் True என்றும் இல்லையெனில் Fal என்றும் வழங்கும். இரண்டாவது செயல்பாடு பயன்படுத்துகிறது len() அதே முடிவை அடைய செயல்பாடு. இந்த காசோலைகளை செயல்பாடுகளில் இணைப்பதன் மூலம், அவற்றை நமது குறியீடு முழுவதும் மீண்டும் பயன்படுத்தலாம், இது தூய்மையானதாகவும் மேலும் பராமரிக்கக்கூடியதாகவும் இருக்கும். செயல்பாடுகளை வரையறுத்த பிறகு, அவற்றை வெற்று பட்டியலுடன் சோதித்தோம் மற்றும் நிபந்தனை வெளிப்பாடுகளைப் பயன்படுத்தி முடிவுகளை அச்சிடப்பட்டது. இந்த அணுகுமுறை மீண்டும் பயன்படுத்தக்கூடிய குறியீடு தொகுதிகளை உருவாக்குவதன் முக்கியத்துவத்தை வலியுறுத்துகிறது மற்றும் டைனமிக் தரவு கட்டமைப்புகளை எவ்வாறு திறம்பட கையாள்வது என்பதை நிரூபிக்கிறது.

# 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")

பைத்தானில் பட்டியல் வெறுமையை சரிபார்க்க கூடுதல் முறைகள்

பயன்படுத்தும் அடிப்படை முறைகளுக்கு அப்பால் மற்றும் , பட்டியல் காலியாக உள்ளதா என்பதைச் சரிபார்க்க பைதான் பிற நுட்பங்களை வழங்குகிறது. அத்தகைய ஒரு முறை விதிவிலக்குகளை மேம்படுத்துவதை உள்ளடக்கியது. அட்டவணைப்படுத்தலைப் பயன்படுத்தி பட்டியலின் முதல் உறுப்பை அணுக முயற்சி செய்யலாம் மற்றும் பட்டியல் காலியாக இருந்தால் அதன் விளைவாக வரும் IndexError ஐக் கையாளலாம். மிகவும் சிக்கலான ஸ்கிரிப்ட்களில் உள்ள தொகுதிகளைத் தவிர்த்து முயற்சி செய்யும்போது இந்த அணுகுமுறை மிகவும் பயனுள்ளதாக இருக்கும். உதாரணத்திற்கு, அணுகுகிறது a[0] ஒரு முயற்சி தொகுதிக்குள் மற்றும் பிடிக்க பட்டியலின் வெறுமையைத் தீர்மானிக்க. இந்த முறை முந்தையதை விட நேரடியானது என்றாலும், இது உங்கள் குறியீட்டில் உள்ள விரிவான பிழை-கையாளுதல் கட்டமைப்பில் தடையின்றி ஒருங்கிணைக்கப்படலாம்.

மற்றொரு மேம்பட்ட நுட்பம் உள்ளமைவைப் பயன்படுத்துவதை உள்ளடக்கியது மற்றும் செயல்பாடுகள். தி பட்டியலிலிருந்து குறைந்தபட்சம் ஒரு உறுப்பு True என மதிப்பிட்டால், செயல்பாடு Trueஐ வழங்கும் all() அனைத்து கூறுகளும் True என மதிப்பிட்டால் மட்டுமே செயல்பாடு True என்பதை வழங்கும். வெற்று பட்டியலைச் சரிபார்க்க, இந்த செயல்பாடுகளை நீங்கள் இணைக்கலாம் இயக்குபவர். உதாரணமாக, அனைத்து கூறுகளும் தவறானதா அல்லது பட்டியல் காலியாக உள்ளதா என்பதைச் சரிபார்க்கிறது. இதேபோல், உண்மை கூறுகள் எதுவும் இல்லையா அல்லது பட்டியல் காலியாக உள்ளதா என்பதைச் சரிபார்க்கப் பயன்படுத்தலாம். இந்த முறைகள், குறைவான பொதுவானவை என்றாலும், பூலியன் அல்லது உண்மை மதிப்புகளைக் கொண்ட பட்டியல்களைக் கையாளும் போது கூடுதல் நெகிழ்வுத்தன்மையை வழங்குகின்றன.

பட்டியல் வெறுமையை சரிபார்ப்பதற்கான முடிவு மற்றும் சிறந்த நடைமுறைகள்

சுருக்கமாக, பைத்தானில் பட்டியல் காலியாக உள்ளதா என்பதைச் சரிபார்ப்பது, இல்லையெனில், len(), மற்றும் ப்ளாக்குகளைத் தவிர முயற்சி போன்ற மேம்பட்ட நுட்பங்கள் உட்பட பல முறைகள் மூலம் அடையலாம். சரியான முறையைத் தேர்ந்தெடுப்பது உங்கள் குறிப்பிட்ட பயன்பாட்டு வழக்கு மற்றும் குறியீட்டு பாணியைப் பொறுத்தது. இந்த முறைகளைப் பயன்படுத்துவது உங்கள் குறியீடு சீராக இயங்குவதை உறுதிசெய்ய உதவுகிறது மற்றும் வெற்று பட்டியல்களுடன் தொடர்புடைய பொதுவான ஆபத்துக்களைத் தவிர்க்கிறது.