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



15 Answers

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

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

Yes: if not seq:
     if seq:

No:  if len(seq):
     if not len(seq):
python list is-empty

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

a = []

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




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




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

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

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

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




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

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






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

a = []

.
.
.

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

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




सत्य मूल्य परीक्षण पर documentation से:

यहां सूचीबद्ध चीज़ों के अलावा सभी मूल्यों को True माना जाता है

  • None
  • False
  • किसी भी संख्यात्मक प्रकार का शून्य, उदाहरण के लिए, 0 , 0.0 , 0j
  • कोई खाली अनुक्रम, उदाहरण के लिए, '' , () , []
  • कोई खाली मैपिंग, उदाहरण के लिए, {}
  • उपयोगकर्ता परिभाषित वर्गों के उदाहरण, यदि वर्ग __bool__() या __len__() विधि को परिभाषित करता है, जब वह विधि पूर्णांक शून्य या बूल मान को False

जैसा कि देखा जा सकता है, खाली सूची [] झूठी है , इसलिए बूलियन मूल्य के साथ क्या किया जाएगा सबसे कुशल लगता है:

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



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

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

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




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

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



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

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

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

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




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

not a

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

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



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.



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




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

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





Related