python - उपलब - सीट खाली




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

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

a = []

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

https://code.i-harness.com


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

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

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 = []

for item in a:
    <do something with item>

<rest of code>

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

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


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

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

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

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


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

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

ऐसा करने का पाइथोनिक तरीका पीईपी 8 स्टाइल गाइड से है (जहां हां का मतलब है "अनुशंसित" और इसका मतलब है "अनुशंसित नहीं"):

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

Yes: if not seq:
     if seq:

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

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

if not a:
    print "list is empty"


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

मैं इसे स्पष्ट रूप से पसंद करता हूं:

if len(li) == 0:
    print('the list is empty')

इस तरह यह 100% स्पष्ट है कि li एक अनुक्रम (सूची) है और हम इसके आकार का परीक्षण करना चाहते हैं। if not li: ... मेरी समस्या if not li: ... यह है कि यह झूठी छाप देता है कि li एक बुलियन चर है।


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

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

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


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

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

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

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 len(a) == 0:
    print("a is empty")


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

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

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

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

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


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

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

पैट्रिक (स्वीकृत) उत्तर सही है: 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: पाठक को गुमराह कर रहा है। जब आप ऐसा नहीं करते हैं तो आप कुछ महत्वपूर्ण संकेत दे रहे हैं। (आप कोड को कम लचीला, या धीमा, या जो कुछ भी बना सकते हैं, लेकिन यह सब कम महत्वपूर्ण है।) और यदि आप इस तरह के पाठक को आदत से गुमराह करते हैं, तो जब आपको एक भेद करने की आवश्यकता होती है, तो यह ध्यान नहीं दिया जा रहा है क्योंकि आप अपने कोड पर "रोना भेड़िया" रहे हैं।


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

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

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


आप जांच सकते हैं कि सरणी की लंबाई शून्य है (या नहीं।) यदि सरणी की लंबाई शून्य है , तो यह खाली है । निम्नलिखित कोशिश करें:

>>> 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
>>> 

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


a == []

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

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

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




is-empty