പൈത്തൺ - ഒരു ലിസ്റ്റ് ശൂന്യമാണോ എന്ന് പരിശോധിക്കുന്നതിനുള്ള രീതികൾ

പൈത്തണിൽ ലിസ്റ്റ് ശൂന്യത പരിശോധിക്കുന്നു

പൈത്തണിലെ ലിസ്റ്റുകളിൽ പ്രവർത്തിക്കുമ്പോൾ, ഒരു ലിസ്റ്റ് ശൂന്യമാണോ എന്ന് നിങ്ങൾ പലപ്പോഴും നിർണ്ണയിക്കേണ്ടി വന്നേക്കാം. നിലവിലില്ലാത്ത ഘടകങ്ങൾ പ്രോസസ്സ് ചെയ്യാൻ നിങ്ങൾ ശ്രമിക്കുന്നില്ലെന്ന് ഉറപ്പാക്കിക്കൊണ്ട് നിങ്ങളുടെ കോഡിലെ പിശകുകൾ ഒഴിവാക്കാൻ സഹായിക്കുന്ന ഒരു പൊതു ചുമതലയാണിത്.

ഈ ലേഖനത്തിൽ, ഒരു ലിസ്റ്റ് ശൂന്യമാണോ എന്ന് പരിശോധിക്കുന്നതിനുള്ള വിവിധ രീതികൾ ഞങ്ങൾ പര്യവേക്ഷണം ചെയ്യും. ഈ രീതികൾ മനസ്സിലാക്കുന്നത് കൂടുതൽ കാര്യക്ഷമവും പിശകുകളില്ലാത്തതുമായ പൈത്തൺ കോഡ് എഴുതാൻ നിങ്ങളെ പ്രാപ്തരാക്കും, പ്രത്യേകിച്ച് ഡൈനാമിക് ഡാറ്റാ ഘടനകൾ കൈകാര്യം ചെയ്യുമ്പോൾ.

ലിസ്റ്റ് ശൂന്യത പരിശോധിക്കുന്നതിനായി പൈത്തൺ സ്ക്രിപ്റ്റുകൾ മനസ്സിലാക്കുന്നു

ആദ്യ സ്ക്രിപ്റ്റ് ഉദാഹരണത്തിൽ, ഒരു ലിസ്റ്റ് ശൂന്യമാണോ എന്ന് പരിശോധിക്കാൻ ഞങ്ങൾ രണ്ട് പ്രാഥമിക രീതികൾ ഉപയോഗിച്ചു. ആദ്യ രീതി ഉപയോഗിക്കുന്നു 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(), ഒരു ലിസ്റ്റ് ശൂന്യമാണോ എന്ന് പരിശോധിക്കാൻ പൈത്തൺ മറ്റ് സാങ്കേതിക വിദ്യകൾ വാഗ്ദാനം ചെയ്യുന്നു. അത്തരത്തിലുള്ള ഒരു രീതി ഒഴിവാക്കലുകൾ പ്രയോജനപ്പെടുത്തുന്നത് ഉൾപ്പെടുന്നു. ഇൻഡെക്സിംഗ് ഉപയോഗിച്ച് നിങ്ങൾക്ക് ലിസ്റ്റിൻ്റെ ആദ്യ ഘടകം ആക്സസ് ചെയ്യാൻ ശ്രമിക്കാം, ലിസ്റ്റ് ശൂന്യമാണെങ്കിൽ ഫലമായുണ്ടാകുന്ന IndexError കൈകാര്യം ചെയ്യാം. കൂടുതൽ സങ്കീർണ്ണമായ സ്ക്രിപ്റ്റുകളിലെ ബ്ലോക്കുകളൊഴികെ ശ്രമിക്കുമ്പോൾ ഈ സമീപനം പ്രത്യേകിച്ചും ഉപയോഗപ്രദമാകും. ഉദാഹരണത്തിന്, try ആക്സസ് ചെയ്യുന്നു a[0] ഒരു ട്രൈ ബ്ലോക്കിനുള്ളിൽ പിടിക്കുക IndexError പട്ടികയുടെ ശൂന്യത നിർണ്ണയിക്കാൻ. ഈ രീതി മുമ്പത്തേതിനേക്കാൾ നേരിട്ടുള്ളതല്ലെങ്കിലും, നിങ്ങളുടെ കോഡിലെ കൂടുതൽ വിപുലമായ പിശക് കൈകാര്യം ചെയ്യുന്ന ചട്ടക്കൂടുകളിലേക്ക് ഇത് തടസ്സമില്ലാതെ സംയോജിപ്പിക്കാൻ കഴിയും.

മറ്റൊരു നൂതന സാങ്കേതികതയിൽ ബിൽറ്റ്-ഇൻ ഉപയോഗിക്കുന്നത് ഉൾപ്പെടുന്നു any() ഒപ്പം all() പ്രവർത്തനങ്ങൾ. ദി any() ലിസ്റ്റിലെ ഒരു ഘടകമെങ്കിലും True എന്നതിലേക്ക് മൂല്യനിർണ്ണയം നടത്തിയാൽ ഫംഗ്‌ഷൻ True നൽകുന്നു, അതേസമയം all() എല്ലാ ഘടകങ്ങളും True എന്നതിലേക്ക് മൂല്യനിർണ്ണയം നടത്തിയാൽ മാത്രമേ ഫംഗ്ഷൻ True നൽകുന്നുള്ളൂ. ഒരു ശൂന്യമായ ലിസ്റ്റ് പരിശോധിക്കുന്നതിന്, നിങ്ങൾക്ക് ഈ ഫംഗ്‌ഷനുകൾ ഇവയുമായി സംയോജിപ്പിക്കാം not ഓപ്പറേറ്റർ. ഉദാഹരണത്തിന്, if not any(a) എല്ലാ ഘടകങ്ങളും തെറ്റാണോ അല്ലെങ്കിൽ ലിസ്റ്റ് ശൂന്യമാണോ എന്ന് പരിശോധിക്കുന്നു. സമാനമായി, if not all(a) യഥാർത്ഥ ഘടകങ്ങൾ ഇല്ലെങ്കിലോ ലിസ്റ്റ് ശൂന്യമാണോ എന്ന് പരിശോധിക്കാൻ ഉപയോഗിക്കാവുന്നതാണ്. ഈ രീതികൾ സാധാരണമല്ലെങ്കിലും, ബൂളിയൻ അല്ലെങ്കിൽ സത്യസന്ധമായ മൂല്യങ്ങൾ അടങ്ങിയ ലിസ്റ്റുകൾ കൈകാര്യം ചെയ്യുമ്പോൾ അധിക വഴക്കം നൽകുന്നു.

ലിസ്റ്റ് ശൂന്യത പരിശോധിക്കുന്നതിനുള്ള ഉപസംഹാരവും മികച്ച രീതികളും

ചുരുക്കത്തിൽ, പൈത്തണിൽ ഒരു ലിസ്റ്റ് ശൂന്യമാണോ എന്ന് പരിശോധിക്കുന്നത് ഒന്നിലധികം രീതികളിലൂടെ നേടാനാകും, ഇല്ലെങ്കിൽ, len(), കൂടാതെ ബ്ലോക്കുകൾ ഒഴികെയുള്ള ശ്രമങ്ങൾ പോലെയുള്ള കൂടുതൽ നൂതന സാങ്കേതിക വിദ്യകൾ. ശരിയായ രീതി തിരഞ്ഞെടുക്കുന്നത് നിങ്ങളുടെ നിർദ്ദിഷ്ട ഉപയോഗ കേസിനെയും കോഡിംഗ് ശൈലിയെയും ആശ്രയിച്ചിരിക്കുന്നു. ഈ രീതികൾ ഉപയോഗിക്കുന്നത് നിങ്ങളുടെ കോഡ് സുഗമമായി പ്രവർത്തിക്കുന്നുവെന്ന് ഉറപ്പാക്കാനും ശൂന്യമായ ലിസ്‌റ്റുകളുമായി ബന്ധപ്പെട്ട പൊതുവായ അപകടങ്ങൾ ഒഴിവാക്കാനും സഹായിക്കുന്നു.