python मैं कैसे जांचूं कि कोई सूची खाली है या नहीं?




list is-empty (24)

उदाहरण के लिए, यदि निम्नलिखित पारित किया गया है:

a = []

मैं यह देखने के लिए कैसे जांच करूं कि a खाली है या नहीं?


एक खाली सूची का वास्तविक मूल्य Falseयह है कि एक गैर-खाली सूची के लिए यह है True


कई उत्तरों दिए गए हैं, और उनमें से बहुत अच्छे हैं। मैं बस उस चेक को जोड़ना चाहता था

not a

Noneऔर अन्य प्रकार के खाली ढांचे के लिए भी पास होगा । यदि आप वास्तव में एक खाली सूची की जांच करना चाहते हैं, तो आप यह कर सकते हैं:

if isinstance(a, list) and len(a)==0:
    print("Received an empty list")

अन्य लोग सिर्फ सूचियों से परे प्रश्न को सामान्यीकृत कर रहे हैं, इसलिए मैंने सोचा कि मैं एक अलग प्रकार के अनुक्रम के लिए एक चेतावनी जोड़ूंगा जिसमें बहुत से लोग उपयोग कर सकते हैं, खासकर जब से यह "पायथन परीक्षण खाली सरणी" के लिए पहला Google हिट है ।

अन्य विधियां numpy arrays के लिए काम नहीं करते हैं

आपको numpy arrays से सावधान रहना होगा, क्योंकि list या अन्य मानक कंटेनर के लिए ठीक काम करने वाली अन्य विधियां numpy arrays के लिए विफल होती हैं। मैं नीचे क्यों समझाता हूं, लेकिन संक्षेप में, पसंदीदा विधि size का उपयोग करना size

"पायथनिक" तरीका काम नहीं करता है: भाग 1

"पायथनिक" रास्ता numpy arrays के साथ विफल रहता है क्योंकि numpy सरणी को bool एस की सरणी में डालने का प्रयास करता है, और if x किसी भी प्रकार के कुल सत्य मूल्य के लिए उन सभी बूलों का मूल्यांकन करने का प्रयास करता है। लेकिन इससे कोई मतलब नहीं आता है, इसलिए आपको ValueError मिलता है:

>>> x = numpy.array([0,1])
>>> if x: print("x")
ValueError: The truth value of an array with more than one element is ambiguous. Use a.any() or a.all()

"पायथनिक" तरीका काम नहीं करता है: भाग 2

लेकिन कम से कम मामला आपको बताता है कि यह असफल रहा। यदि आपके पास बिल्कुल एक तत्व के साथ एक numpy सरणी होती है, तो if कथन आपको "काम" करेगा, इस अर्थ में कि आपको कोई त्रुटि नहीं मिलती है। हालांकि, अगर वह तत्व 0 (या 0.0 , या false , ...) होता है, तो if कथन गलत तरीके से गलत होगा:

>>> x = numpy.array([0,])
>>> if x: print("x")
... else: print("No x")
No x

लेकिन स्पष्ट रूप से x मौजूद है और खाली नहीं है! यह परिणाम वह नहीं है जो आप चाहते थे।

len का उपयोग अप्रत्याशित परिणाम दे सकते हैं

उदाहरण के लिए,

len( numpy.zeros((1,0)) )

1 देता है, भले ही सरणी में शून्य तत्व हों।

Numpythonic रास्ता

जैसा कि एससीआई एफएक्यू में बताया गया है, सभी मामलों में सही विधि जहां आप जानते हैं कि आपके पास एक numpy सरणी है x.size का उपयोग if x.size :

>>> x = numpy.array([0,1])
>>> if x.size: print("x")
x

>>> x = numpy.array([0,])
>>> if x.size: print("x")
... else: print("No x")
x

>>> x = numpy.zeros((1,0))
>>> if x.size: print("x")
... else: print("No x")
No x

यदि आप सुनिश्चित नहीं हैं कि यह एक list हो सकता है, एक numpy सरणी, या कुछ और, आप इस दृष्टिकोण को उत्तर के साथ जोड़ सकते हैं @ dubiousjim यह सुनिश्चित करने के लिए देता है कि प्रत्येक प्रकार के लिए सही परीक्षण का उपयोग किया जाता है। बहुत "पायथनिक" नहीं है, लेकिन यह पता चला है कि कम से कम इस अर्थ में जानबूझकर पाइथोनिसिटी टूट गई है।

यदि आपको केवल यह जांचने के अलावा अधिक करने की आवश्यकता है कि इनपुट खाली है या नहीं, और आप इंडेक्सिंग या गणित संचालन जैसी अन्य numpy सुविधाओं का उपयोग कर रहे हैं, तो इनपुट को मजबूती देने के लिए यह अधिक कुशल (और निश्चित रूप से अधिक आम) है। इसे जल्दी करने के लिए कुछ अच्छे काम हैं - सबसे महत्वपूर्ण रूप से numpy.asarray । यह आपके इनपुट को लेता है, अगर यह पहले से ही एक सरणी है, तो कुछ भी नहीं करता है, या अगर यह एक सूची, dtype इत्यादि है, तो आपके इनपुट को सरणी में लपेटता है, और वैकल्पिक रूप से इसे आपके चुने हुए dtype रूप में परिवर्तित करता है। तो जब भी यह हो सकता है, यह बहुत तेज़ है, और यह सुनिश्चित करता है कि आपको लगता है कि इनपुट एक numpy सरणी है। हम आमतौर पर एक ही नाम का उपयोग करते हैं, क्योंकि एक सरणी में रूपांतरण इसे वर्तमान scope बाहर नहीं कर देगा:

x = numpy.asarray(x, dtype=numpy.double)

यह इस पृष्ठ पर देखे गए सभी मामलों में x.size जांच कार्य करेगा।


def list_test (L):
    if   L is None  : print 'list is None'
    elif not L      : print 'list is empty'
    else: print 'list has %d elements' % len(L)

list_test(None)
list_test([])
list_test([1,2,3])

कभी-कभी None और खालीपन के लिए अलग-अलग परीक्षण करना अच्छा होता है क्योंकि ये दो अलग-अलग राज्य होते हैं। उपरोक्त कोड निम्नलिखित आउटपुट उत्पन्न करता है:

list is None 
list is empty 
list has 3 elements

हालांकि यह कुछ भी लायक नहीं है कि None भी झूठा None है। इसलिए यदि आप किसी के लिए परीक्षण अलग नहीं करना चाहते हैं, तो आपको ऐसा करने की ज़रूरत नहीं है।

def list_test2 (L):
    if not L      : print 'list is empty'
    else: print 'list has %d elements' % len(L)

list_test2(None)
list_test2([])
list_test2([1,2,3])

उम्मीद पैदा करता है

list is empty
list is empty
list has 3 elements

बिल्कुल जांच क्यों करें?

ऐसा लगता है कि किसी ने सूची की जांच करने की आपकी आवश्यकता पर सवाल उठाते हुए संबोधित नहीं किया है। चूंकि आपने कोई अतिरिक्त संदर्भ प्रदान नहीं किया है, इसलिए मैं कल्पना कर सकता हूं कि आपको पहले स्थान पर यह जांच करने की आवश्यकता नहीं है, लेकिन पाइथन में सूची प्रसंस्करण से अपरिचित हैं।

मैं तर्क दूंगा कि सबसे पाइथोनिक तरीका बिल्कुल जांचना नहीं है, बल्कि सूची को संसाधित करने के लिए। इस तरह यह सही चीज करेगा चाहे वह खाली या पूर्ण हो।

a = []

for item in a:
    <do something with item>

<rest of code>

इसमें किसी भी सामग्री को संभालने का लाभ होता है , जबकि खालीपन के लिए एक विशिष्ट जांच की आवश्यकता नहीं होती है। यदि कोई खाली है, तो निर्भर ब्लॉक निष्पादित नहीं होगा और दुभाषिया अगली पंक्ति में गिर जाएगी।

यदि आपको वास्तव में खालीपन के लिए सरणी की जांच करने की आवश्यकता है, तो अन्य उत्तरों पर्याप्त हैं।


मैं लिख चुका था:

if isinstance(a, (list, some, other, types, i, accept)) and not a:
    do_stuff

जिसे वोट दिया गया था -1। मुझे यकीन नहीं है कि ऐसा इसलिए है क्योंकि पाठकों ने रणनीति पर आक्षेप किया था या सोचा था कि प्रस्तुत प्रस्तुत करने में उत्तर सहायक नहीं था। मैं दिखाऊंगा कि यह बाद वाला था, क्योंकि --- जो भी "पायथनिक" के रूप में गिना जाता है --- यह सही रणनीति है। जब तक कि आप पहले से ही इनकार नहीं कर चुके हैं, या जहां मामलों में हैं, उन्हें संभालने के लिए तैयार हैं, उदाहरण के लिए, False , आपको एक परीक्षण की आवश्यकता है, केवल इतना if not a: :। आप इस तरह कुछ उपयोग कर सकते हैं:

if isinstance(a, numpy.ndarray) and not a.size:
    do_stuff
elif isinstance(a, collections.Sized) and not a:
    do_stuff

पहला परीक्षण ऊपर @ माइक के जवाब के जवाब में है। तीसरी पंक्ति को भी प्रतिस्थापित किया जा सकता है:

elif isinstance(a, (list, tuple)) and not a:

यदि आप केवल विशेष प्रकार (और उनके उपप्रकार) के उदाहरण स्वीकार करना चाहते हैं, या इसके साथ:

elif isinstance(a, (list, tuple)) and not len(a):

आप स्पष्ट प्रकार की जांच के बिना दूर हो सकते हैं, लेकिन केवल अगर आसपास के संदर्भ से पहले ही आपको आश्वस्त किया जाता है कि आप उन प्रकारों का मूल्य हैं जिन्हें आप संभालने के लिए तैयार हैं, या यदि आप सुनिश्चित हैं कि आप हैंडल करने के लिए तैयार नहीं हैं त्रुटियों को बढ़ाने के लिए जा रहा है (उदाहरण के लिए, एक TypeError यदि आप उस मान पर len को कॉल करते हैं जिसके लिए यह अनिर्धारित है) कि आप इसे संभालने के लिए तैयार हैं। आम तौर पर, "पायथनिक" सम्मेलन इस आखिरी तरीके से प्रतीत होते हैं। इसे एक बतख की तरह निचोड़ें और इसे डक इरर बढ़ाएं यदि यह नहीं पता कि कैसे क्वाक करना है। आपको अभी भी इस बारे में सोचना होगा कि आप किस प्रकार की धारणाएं बना रहे हैं, और क्या आप जिन मामलों को सही तरीके से संभालने के लिए तैयार नहीं हैं, वे वास्तव में सही जगहों पर त्रुटि के लिए जा रहे हैं। बेवकूफ सरणी एक अच्छा उदाहरण है जहां केवल अंधेरे से len या बूलियन टाइपकास्ट पर भरोसा करना ठीक से ठीक नहीं हो सकता है जो आप उम्मीद कर रहे हैं।



पाइथन खालीपन के इलाज के बारे में बहुत समान है। निम्नलिखित को देखते हुए:

a = []

.
.
.

if a:
   print("List is not empty.")
else:
   print("List is empty.")

आप बस "if" कथन के साथ सूची को चेक करने के लिए जांचें कि यह खाली है या नहीं। जो मैंने पढ़ा और पढ़ाया है, उससे यह देखने के लिए "पायथनिक" तरीका है कि कोई सूची या ट्यूपल खाली है या नहीं।


a == []

थोड़ा और व्यावहारिक:

def is_empty(any_structure):
    if any_structure:
        print('Structure is not empty.')
        return True
    else:
        print('Structure is empty.')
        return False  

पाइथन इंटरैक्टिव टर्मिनल पर निष्पादित निम्न कोड देखें।

 >>> a = [] >>> if a: ... print "List is not empty"; ... else: ... print "List is empty" ... List is empty >>> >>> a = [1, 4, 9] >>> if a: ... print "List is not empty"; ... else: ... print "List is empty" ... List is not empty >>> 

@ ड्यूब्यूजिम के समाधान से प्रेरित होने के नाते, मैं एक अतिरिक्त सामान्य जांच का उपयोग करने का प्रस्ताव करता हूं कि क्या यह कुछ हद तक अक्षम है या नहीं

import collections
def is_empty(a):
    return not a and isinstance(a, collections.Iterable)

नोट: एक स्ट्रिंग को पुनरावर्तनीय माना जाता है। - अगर आप रिक्त स्ट्रिंग को बाहर करना चाहते हैं तो जोड़ें and not isinstance(a,(str,unicode))

परीक्षा:

>>> is_empty('sss')
False
>>> is_empty(555)
False
>>> is_empty(0)
False
>>> is_empty('')
True
>>> is_empty([3])
False
>>> is_empty([])
True
>>> is_empty({})
True
>>> is_empty(())
True

यह जांचने का सबसे अच्छा तरीका है कि कोई सूची खाली है या नहीं

उदाहरण के लिए, यदि निम्नलिखित पारित किया गया है:

a = []

मैं यह देखने के लिए कैसे जांच करूं कि कोई खाली है या नहीं?

संक्षिप्त जवाब:

सूची को एक बुलियन संदर्भ में रखें (उदाहरण के लिए, if या कथन के साथ)। यह False अगर यह खाली है, और अन्यथा True है। उदाहरण के लिए:

if not a:                           # do this!
    print('a is an empty list')

प्राधिकरण के लिए अपील

पीईपी 8 , पायथन के मानक पुस्तकालय में पायथन कोड के लिए आधिकारिक पायथन शैली मार्गदर्शिका, जोर देती है:

अनुक्रमों के लिए, (तार, सूचियां, tuples), इस तथ्य का उपयोग करें कि खाली अनुक्रम झूठे हैं।

Yes: if not seq:
     if seq:

No: if len(seq):
    if not len(seq):

हमें उम्मीद करनी चाहिए कि मानक लाइब्रेरी कोड जितना संभव हो उतना निष्पादक और सही होना चाहिए। लेकिन यह मामला क्यों है, और हमें इस मार्गदर्शन की आवश्यकता क्यों है?

व्याख्या

मैं अक्सर इस तरह के कोड अनुभवी प्रोग्रामर से नए पायथन तक देखता हूं:

if len(a) == 0:                     # Don't do this!
    print('a is an empty list')

और आलसी भाषाओं के उपयोगकर्ता इसे करने के लिए लुभाने वाले हो सकते हैं:

if a == []:                         # Don't do this!
    print('a is an empty list')

ये उनकी संबंधित अन्य भाषाओं में सही हैं। और यह पायथन में भी अर्थात् सही है।

लेकिन हम इसे गैर-पायथनिक मानते हैं क्योंकि पायथन इन शब्दावली को सीधे ऑब्जेक्ट के इंटरफेस में बूलियन जबरदस्ती के माध्यम से समर्थन देता है।

docs (और विशेष रूप से खाली सूची को शामिल करने पर ध्यान दें, [] ):

डिफ़ॉल्ट रूप से, एक ऑब्जेक्ट को तब तक सही माना जाता है जब तक कि इसकी कक्षा या तो __bool__() विधि को परिभाषित नहीं करती है जो ऑब्जेक्ट के साथ बुलाए जाने पर False या __len__() विधि देता है जो शून्य लौटाता है। यहां निर्मित अधिकांश अंतर्निहित वस्तुएं झूठी मानी जाती हैं:

  • स्थिरांक को गलत माना जाता है: None और False None
  • किसी भी संख्यात्मक प्रकार का शून्य: 0 , 0.0 , 0j , Decimal(0) , Fraction(0, 1)
  • खाली अनुक्रम और संग्रह: '' , () , [] , {} , set() , range(0)

और डेटामैडल दस्तावेज:

object.__bool__(self)

सत्य मूल्य परीक्षण और अंतर्निहित ऑपरेशन bool() को लागू करने के लिए बुलाया गया; False या True वापसी करनी चाहिए। जब यह विधि परिभाषित नहीं की जाती है, तो __len__() को परिभाषित किया जाता है, यदि इसे परिभाषित किया गया है, और ऑब्जेक्ट को सही माना जाता है यदि इसका परिणाम nonzero है। यदि कोई वर्ग न तो __len__() और न ही __bool__() को परिभाषित करता है, तो इसके सभी उदाहरण सत्य मानते हैं।

तथा

object.__len__(self)

बिल्ट-इन फ़ंक्शन len() को लागू करने के लिए बुलाया गया। ऑब्जेक्ट की लंबाई, एक पूर्णांक> = 0. लौटा देना चाहिए। इसके अलावा, एक ऑब्जेक्ट जो __bool__() विधि को परिभाषित नहीं करता है और जिसका __len__() विधि शून्य लौटाता है उसे एक बूलियन संदर्भ में गलत माना जाता है।

तो इसके बजाय:

if len(a) == 0:                     # Don't do this!
    print('a is an empty list')

या यह:

if a == []:                     # Don't do this!
    print('a is an empty list')

यह करो:

if not a:
    print('a is an empty list')

पाइथोनिक आमतौर पर प्रदर्शन में भुगतान करता है:

क्या यह भुगतान करता है? (ध्यान दें कि बराबर ऑपरेशन करने के लिए कम समय बेहतर है :)

>>> import timeit
>>> min(timeit.repeat(lambda: len([]) == 0, repeat=100))
0.13775854044661884
>>> min(timeit.repeat(lambda: [] == [], repeat=100))
0.0984637276455409
>>> min(timeit.repeat(lambda: not [], repeat=100))
0.07878462291455435

स्केल के लिए, यहां फ़ंक्शन को कॉल करने और खाली सूची को वापस करने और वापस करने की लागत है, जिसे आप उपर्युक्त खालीपन चेक की लागत से घटा सकते हैं:

>>> min(timeit.repeat(lambda: [], repeat=100))
0.07074015751817342

हम देखते हैं कि या तो 0 की तुलना में बिल्टिन फ़ंक्शन len साथ लंबाई की जांच करना या रिक्त सूची के विरुद्ध जांच करना दस्तावेज़ के बिल्टिन सिंटैक्स का उपयोग करने से बहुत कम प्रदर्शनकारी है।

क्यूं कर?

len(a) == 0 चेक:

पहली पाइथन को यह देखने के लिए ग्लोबल्स की जांच करनी है कि क्या len छाया है या नहीं।

फिर इसे फ़ंक्शन को कॉल करना होगा, 0 लोड करें, और पायथन में समानता तुलना करें (सी के बजाय):

>>> import dis
>>> dis.dis(lambda: len([]) == 0)
  1           0 LOAD_GLOBAL              0 (len)
              2 BUILD_LIST               0
              4 CALL_FUNCTION            1
              6 LOAD_CONST               1 (0)
              8 COMPARE_OP               2 (==)
             10 RETURN_VALUE

और [] == [] इसे एक अनावश्यक सूची बनाना है और फिर, फिर से, पाइथन की आभासी मशीन में तुलना ऑपरेशन करें (सी के विपरीत)

>>> dis.dis(lambda: [] == [])
  1           0 BUILD_LIST               0
              2 BUILD_LIST               0
              4 COMPARE_OP               2 (==)
              6 RETURN_VALUE

ऑब्जेक्ट इंस्टेंस हेडर में सूची की लंबाई कैश की गई है क्योंकि "पायथनिक" तरीका एक बहुत ही सरल और तेज़ जांच है:

>>> dis.dis(lambda: not [])
  1           0 BUILD_LIST               0
              2 UNARY_NOT
              4 RETURN_VALUE

सी स्रोत और दस्तावेज़ीकरण से साक्ष्य

PyVarObject

यह PyObject का एक विस्तार है जो ob_size फ़ील्ड जोड़ता है। यह केवल उन वस्तुओं के लिए उपयोग किया जाता है जिनमें लंबाई की कुछ धारणा होती है। यह प्रकार अक्सर पायथन / सी एपीआई में दिखाई नहीं देता है। यह PyObject_VAR_HEAD मैक्रो के विस्तार द्वारा परिभाषित फ़ील्ड से मेल खाता है।

Include/listobject.h में सी स्रोत से:

typedef struct {
    PyObject_VAR_HEAD
    /* Vector of pointers to list elements.  list[0] is ob_item[0], etc. */
    PyObject **ob_item;

    /* ob_item contains space for 'allocated' elements.  The number
     * currently in use is ob_size.
     * Invariants:
     *     0 <= ob_size <= allocated
     *     len(list) == ob_size

मैंने इसका शोध करने का आनंद लिया है और मैं अपने उत्तरों को कम करने में काफी समय बिताता हूं। अगर आपको लगता है कि मैं कुछ छोड़ रहा हूं, तो कृपया मुझे एक टिप्पणी में बताएं।


आप इस तरह बूल () का उपयोग करने का भी प्रयास कर सकते हैं

    a = [1,2,3];
    print bool(a); # it will return True
    a = [];
    print bool(a); # it will return False

सूची की जांच के लिए मुझे इस तरह से प्यार है या नहीं।

बहुत आसान और उपयोगी।


मैंने नीचे दिए गए पसंदीदा को देखा है:

if not a:
    print("The list is empty or null")

एक और आसान तरीका हो सकता है

a = []
if len(a) == 0:
  print("Empty")
else:
  print(" Not empty")

बस is_empty () का उपयोग करें या फ़ंक्शन करें: -

l = []
if l:
    # do your stuff.

इसका उपयोग किसी भी डेटा_स्ट्रक्चर जैसे सूची, टुपल्स, डिक्शनरी और कई अन्य के लिए किया जा सकता है। इनके द्वारा, आप इसे कई बार कॉल कर सकते हैं is_empty(any_structure)


Python3 से आगे आप उपयोग कर सकते हैं

 a = []
 try:
  print(a[-1])
 except IndexError:
  print("List is empty")

यह जांचने के लिए कि क्या सूची खाली है या नहीं

संपादित करें: यह python2.7 के साथ भी काम करता है ..

मुझे यकीन नहीं है कि इतने जटिल जवाब क्यों हैं। यह बहुत स्पष्ट और सीधा है


कुछ विधियों का उपयोग मैं करता हूं:

if not a:
    print "list is empty"


if len(a) == 0:
    print "list is empty"

यहां कुछ तरीकों से आप जांच सकते हैं कि कोई सूची खाली है या नहीं:

a = [] #the list

1) सुंदर सरल पायथनिक तरीका:

if not a:
    print("a is empty")

पायथन में, रिक्त कंटेनर जैसे सूचियां, टुपल्स, सेट, डिकट्स, वैरिएबल इत्यादि को False रूप में देखा जाता है। कोई भी सूची को भविष्यवाणी के रूप में देख सकता है ( एक बूलियन मान लौटा रहा है )। और एक True मूल्य इंगित करेगा कि यह खाली नहीं है।

2) एक बहुत स्पष्ट तरीका: लंबाई खोजने के लिए len() का उपयोग करके जांचें कि यह 0 बराबर है या नहीं:

if len(a) == 0:
    print("a is empty")

3) या इसे एक अज्ञात खाली सूची से तुलना करना:

if a == []:
    print("a is empty")

4) exception और iter() का उपयोग करने के लिए एक और अभी तक मूर्ख तरीका है:

try:
    next(iter(a))
    # list has elements
except StopIteration:
    print("Error: a is empty")

मैं निम्नलिखित पसंद करता हूं:

if a == []:
   print "The list is empty."

पढ़ने योग्य और आपको वैरिएबल के माध्यम से len() जैसे फ़ंक्शन को कॉल करने के बारे में चिंता करने की आवश्यकता नहीं है। हालांकि मुझे पूरी तरह से यकीन नहीं है कि इस तरह की किसी चीज का बिगो नोटेशन क्या है ... लेकिन पाइथन इतनी तेजस्वी है कि मुझे संदेह है कि इससे a फर्क नहीं पड़ता कि यह a विशाल था।


एक अनौपचारिक दृष्टिकोण:

l = ["", False, 0, '', [], {}, ()]
if all(bool(x) for x in l):
    # do your stuff.

यदि आप जांचना चाहते हैं कि सूची खाली है या नहीं;

def empty_list(lst):
    if len(lst) ==0:
        return false
    else:
        return all(bool(x) for x in l)

यदि आप मौसम की जांच करना चाहते हैं तो सूची में सभी मूल्य खाली हैं।

if empty_list(lst):
    # do your stuff.

हालांकि यह खाली सूची के लिए सच होगा।

print('not empty' if a else 'empty')

अब आप इसका उपयोग कर सकते हैं:

a.pop() if a else None

पैट्रिक (स्वीकृत) उत्तर सही है: if not a: ऐसा करने का सही तरीका है। हार्ले होलकोबे का जवाब सही है कि यह पीईपी 8 स्टाइल गाइड में है। लेकिन उत्तर में से कोई भी नहीं बताता है कि मुहावरे का पालन करना क्यों अच्छा विचार है-भले ही आपको व्यक्तिगत रूप से यह स्पष्ट न हो या रूबी उपयोगकर्ताओं या जो कुछ भी भ्रमित न हो।

पायथन कोड, और पायथन समुदाय, बहुत मजबूत मुहावरे है। उन मुहावरे के बाद पाइथन में अनुभवी किसी भी व्यक्ति के लिए आपके कोड को पढ़ने में आसान बनाता है। और जब आप उन मुहावरों का उल्लंघन करते हैं, तो यह एक मजबूत संकेत है।

यह सच है कि if not a: None खाली सूची, या संख्यात्मक 0, या खाली tuples, या खाली उपयोगकर्ता द्वारा बनाए गए संग्रह प्रकार, या खाली उपयोगकर्ता द्वारा निर्मित नहीं-संग्रहित प्रकार, या एकल तत्व NumPy सरणी से खाली सूचियों को अलग नहीं करता है झूठे मूल्यों के साथ स्केलर के रूप में कार्य करना, आदि। और कभी-कभी इसके बारे में स्पष्ट होना महत्वपूर्ण है। और उस स्थिति में, आप जानते हैं कि आप किस बारे में स्पष्ट होना चाहते हैं, ताकि आप इसके लिए परीक्षण कर सकें। उदाहरण के लिए, if not a and a is not None: इसका मतलब है "किसी को छोड़कर कुछ भी झूठी नहीं", जबकि if len(a) != 0: अर्थ है "केवल खाली अनुक्रम- और अनुक्रम के अलावा कुछ भी एक त्रुटि है", और इसी तरह । आप जो परीक्षण करना चाहते हैं उसके लिए परीक्षण के अलावा, यह पाठक को भी संकेत देता है कि यह परीक्षण महत्वपूर्ण है।

लेकिन जब आपके पास स्पष्ट होने के लिए कुछ भी नहीं है, तो इसके अलावा कुछ भी if not a: पाठक को गुमराह कर रहा है। जब आप ऐसा नहीं करते हैं तो आप कुछ महत्वपूर्ण संकेत दे रहे हैं। (आप कोड को कम लचीला, या धीमा, या जो कुछ भी बना सकते हैं, लेकिन यह सब कम महत्वपूर्ण है।) और यदि आप इस तरह के पाठक को आदत से गुमराह करते हैं, तो जब आपको एक भेद करने की आवश्यकता होती है, तो यह ध्यान नहीं दिया जा रहा है क्योंकि आप अपने कोड पर "रोना भेड़िया" रहे हैं।


एक खाली सूची को स्वयं को वास्तविक मूल्य परीक्षण में झूठा माना जाता है ( पायथन दस्तावेज देखें):

a = []
if a:
     print "not empty"

@ डैरेन थॉमस

संपादित करें: रिक्त सूची का परीक्षण गलत के रूप में एक और बिंदु: बहुरूपता के बारे में क्या? आपको सूची में सूचीबद्ध सूची पर निर्भर नहीं होना चाहिए। इसे सिर्फ एक बतख की तरह रैक करना चाहिए - आप अपने बतख को कैसे प्राप्त कर रहे हैं '' गलत '' को रद्द करने के लिए चयन करें जब इसमें कोई तत्व न हो?

आपके बतख को __nonzero__ या __len__ को कार्यान्वित करना चाहिए ताकि अगर कोई समस्या के बिना काम करेगा।







is-empty