उदाहरण के लिए, यदि निम्न पास हो:

a = []

अगर aखाली है तो मैं कैसे देखूं ?

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

खाली के निहित बूलनेस का उपयोग करना listकाफी pythonic है।

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

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

Yes: if not seq:
     if seq:

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

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

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

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

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

अन्य तरीके NumPy सरणियों के लिए काम नहीं करते हैं

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

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

"पाइथोनिक" तरीका NumPy सरणियों के साथ विफल हो जाता है क्योंकि NumPy सरणी को एस के एक सरणी में डालने की कोशिश करता है bool, और किसी भी तरह के कुल सत्य मूल्य के लिए if xउन सभी का मूल्यांकन करने की कोशिश करता है bool। लेकिन इसका कोई मतलब नहीं है, इसलिए आपको एक 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कथन गलत परिणाम देगा False:

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

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

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

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

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

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

सुन्नतर तरीका

जैसा कि SciPy FAQ में बताया गया है , उन सभी मामलों में सही विधि जहाँ आप जानते हैं कि आपके पास एक NumPy सरणी है, का उपयोग करना है 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 सरणी होने के लिए मजबूर करना । जल्दी से ऐसा करने के लिए कुछ अच्छे कार्य हैं - सबसे महत्वपूर्ण बात numpy.asarray। यह आपका इनपुट लेता है, अगर यह पहले से ही एक सरणी है, तो कुछ भी नहीं करता है, या यदि यह एक सूची, ट्यूपल, आदि है, तो अपने इनपुट को एक सरणी में लपेटता है, और वैकल्पिक रूप से इसे आपके चुने हुए में बदल देता है dtype। जब भी यह हो सकता है तो यह बहुत जल्दी है, और यह सुनिश्चित करता है कि आप बस इनपुट को एक NumPy सरणी मान लें। हम आमतौर पर केवल एक ही नाम का उपयोग करते हैं, क्योंकि एक सरणी में रूपांतरण वर्तमान दायरे से बाहर वापस नहीं आएगा :

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

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

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

उदाहरण के लिए, यदि निम्न पास हो:

a = []

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

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

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

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

पीईपी 8

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

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

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

ये उनकी अन्य भाषाओं में सही हैं। और यह पाइथन में शब्दार्थ रूप से सही है।

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

से डॉक्स (और टिप्पणी विशेष रूप से खाली सूची के शामिल किए जाने, []):

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

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

और डेटामॉडल प्रलेखन:

object.__bool__(self)

सत्य मूल्य परीक्षण और अंतर्निहित ऑपरेशन को लागू करने के लिए कहा जाता है bool(); लौट जाना चाहिए Falseया True। जब इस पद्धति को परिभाषित नहीं किया __len__()जाता है, तो इसे कहा जाता है, अगर यह परिभाषित किया गया है, और वस्तु को सही माना जाता है यदि इसका परिणाम गैर-शून्य हो। यदि कोई वर्ग न तो परिभाषित करता है और न __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

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

क्यों?

के लिए 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मैक्रो के विस्तार से परिभाषित क्षेत्रों से मेल खाती है ।

शामिल स्रोत से सूची / 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

टिप्पणियों का जवाब:

मैं कहना है कि यह भी साथ के रूप में गैर खाली मामला हालांकि अपनी सुंदर कुरूप के लिए सच है l=[]तो %timeit len(l) != 090.6 एनएस ± 8.3 एनएस, %timeit l != []55.6 एनएस ± 3.09, %timeit not not l38.5 एनएस ± 0.372। लेकिन ऐसा कोई तरीका नहीं है जिससे कोई भी not not lट्रिपल स्पीड के बावजूद आनंद ले सके। यह हास्यास्पद लगता है। लेकिन गति जीतता है
मुझे लगता है कि समस्या समय के साथ परीक्षण कर रही है क्योंकि बस if l:पर्याप्त है, लेकिन आश्चर्यजनक रूप %timeit bool(l)से 101 ns। 2.64 ss उपज है। दिलचस्प है कि इस दंड के बिना बूल के लिए ज़बरदस्ती करने का कोई तरीका नहीं है। %timeit lतब से बेकार है जब तक कोई रूपांतरण नहीं होगा।

IPython जादू, %timeitपूरी तरह से यहाँ बेकार नहीं है:

In [1]: l = []                                                                  

In [2]: %timeit l                                                               
20 ns ± 0.155 ns per loop (mean ± std. dev. of 7 runs, 100000000 loops each)

In [3]: %timeit not l                                                           
24.4 ns ± 1.58 ns per loop (mean ± std. dev. of 7 runs, 10000000 loops each)

In [4]: %timeit not not l                                                       
30.1 ns ± 2.16 ns per loop (mean ± std. dev. of 7 runs, 10000000 loops each)

हम देख सकते हैं कि notयहां प्रत्येक अतिरिक्त के लिए थोड़ी सी रैखिक लागत है। हम लागतों को देखना चाहते हैं, ceteris paribus , अर्थात् , बाकी सब बराबर - जहाँ बाकी सब कम से कम हो:

In [5]: %timeit if l: pass                                                      
22.6 ns ± 0.963 ns per loop (mean ± std. dev. of 7 runs, 10000000 loops each)

In [6]: %timeit if not l: pass                                                  
24.4 ns ± 0.796 ns per loop (mean ± std. dev. of 7 runs, 10000000 loops each)

In [7]: %timeit if not not l: pass                                              
23.4 ns ± 0.793 ns per loop (mean ± std. dev. of 7 runs, 10000000 loops each)

अब इस मामले को एक खाली सूची के लिए देखते हैं:

In [8]: l = [1]                                                                 

In [9]: %timeit if l: pass                                                      
23.7 ns ± 1.06 ns per loop (mean ± std. dev. of 7 runs, 10000000 loops each)

In [10]: %timeit if not l: pass                                                 
23.6 ns ± 1.64 ns per loop (mean ± std. dev. of 7 runs, 10000000 loops each)

In [11]: %timeit if not not l: pass                                             
26.3 ns ± 1 ns per loop (mean ± std. dev. of 7 runs, 10000000 loops each)

हम यहां जो देख सकते हैं, वह यह है कि यह बहुत कम फर्क पड़ता है कि क्या आप एक वास्तविक boolस्थिति में चेक या सूची में पास हो जाते हैं, और यदि कुछ भी है, तो सूची, जैसा कि है, तेजी से है।

अजगर सी में लिखा है; यह सी स्तर पर अपने तर्क का उपयोग करता है। पाइथन में आप जो भी लिखेंगे वह धीमा होगा। और यह संभवतः परिमाण धीमे के आदेश होंगे जब तक कि आप सीधे पाइथन में निर्मित तंत्र का उपयोग नहीं कर रहे हैं।

एक खाली सूची को सही मान परीक्षण में गलत माना जाता है ( अजगर प्रलेखन देखें ):

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

@ डारेन थॉमस

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

आपके duckCollection को लागू करना चाहिए __nonzero__या __len__यदि कोई a: समस्याओं के बिना काम करेगा।

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

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

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

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

आखिर जांच क्यों?

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

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

a = []

for item in a:
    <do something with item>

<rest of code>

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

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

len()पायथन सूचियों, तार, डिकेट और सेट के लिए O (1) ऑपरेशन है । पायथन आंतरिक रूप से इन कंटेनरों में तत्वों की संख्या पर नज़र रखता है।

जावास्क्रिप्ट में सत्य / मिथ्या के समान धारणा है ।

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

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

जिसे वोट दिया गया था -1। मुझे यकीन नहीं है कि ऐसा इसलिए है क्योंकि पाठकों ने रणनीति पर आपत्ति जताई या सोचा कि उत्तर प्रस्तुत करने में मददगार नहीं था। मैं दिखावा करता हूँ कि यह बाद की बात है, --- "पाइथोनिक" के रूप में जो भी मायने रखता है --- यह सही रणनीति है। जब तक आप पहले से ही इनकार नहीं करते हैं, या ऐसे मामलों को संभालने के लिए तैयार हैं, जहां aउदाहरण के लिए 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):

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

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

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

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

देखा जा सकता है, खाली सूची []है falsy , क्या एक बूलियन मान आवाज़ सबसे कुशल करने के लिए किया जाएगा ताकि:

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

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

a = [] #the list

1) सुंदर सरल pythonic तरीका:

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

विधि 1 (पसंदीदा):

if not a : 
   print ("Empty") 

विधि 2:

if len(a) == 0 :
   print( "Empty" )

विधि 3:

if a == [] :
  print ("Empty")

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

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

not a

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

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

हम एक सरल का उपयोग कर सकते हैं अगर और:

item_list=[]
if len(item_list) == 0:
    print("list is empty")
else:
    print("list is not empty")

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

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

यदि आप जांचना चाहते हैं कि सूची के सभी मूल्य खाली हैं या नहीं। हालाँकि यह Trueएक खाली सूची के लिए होगा:

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.

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

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

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

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

a.pop() if a else None

और shertest संस्करण:

if a: a.pop() 

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

a == []

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

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

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

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

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

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

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

बस is_empty () का उपयोग करें या जैसे कार्य करें: -

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

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

सरल तरीके से जाँच की जा रही है कि लंबाई बराबर शून्य है।

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

एक खाली सूची का सत्य मान है, Falseजबकि एक गैर-रिक्त सूची के लिए है True।

क्या मुझे यहाँ लाया एक विशेष उपयोग-मामला है: मैं वास्तव में एक चाहते थे समारोह मुझे बताने की अगर एक सूची खाली है या नहीं। मैं अपने स्वयं के फ़ंक्शन को लिखने या लैम्बडा-एक्सप्रेशन का उपयोग करने से बचना चाहता था (क्योंकि ऐसा लगता था कि यह काफी सरल होना चाहिए):

foo = itertools.takewhile(is_not_empty, (f(x) for x in itertools.count(1)))

और, ज़ाहिर है, यह करने के लिए एक बहुत ही स्वाभाविक तरीका है:

foo = itertools.takewhile(bool, (f(x) for x in itertools.count(1)))

बेशक, करते नहीं का उपयोग boolमें if(यानी, if bool(L):), क्योंकि यह निहित है। लेकिन, ऐसे मामलों के लिए जब "खाली नहीं है" स्पष्ट रूप से एक फ़ंक्शन के रूप में आवश्यक boolहै, सबसे अच्छा विकल्प है।

यह जाँचने के लिए कि कोई सूची खाली है या नहीं, आप निम्नलिखित दो तरीकों का उपयोग कर सकते हैं। लेकिन याद रखें, हमें एक प्रकार के अनुक्रम के लिए स्पष्ट रूप से जाँच करने के तरीके से बचना चाहिए (यह एक less pythonicतरीका है):

def enquiry(list1): 
    if len(list1) == 0: 
        return 0
    else: 
        return 1

# ––––––––––––––––––––––––––––––––

list1 = [] 

if enquiry(list1): 
    print ("The list isn't empty") 
else: 
    print("The list is Empty") 

# Result: "The list is Empty".

दूसरा तरीका more pythonicएक है। यह विधि जाँच का एक निहित तरीका है और पिछले एक की तुलना में अधिक बेहतर है।

def enquiry(list1): 
    if not list1: 
        return True
    else: 
        return False

# ––––––––––––––––––––––––––––––––

list1 = [] 

if enquiry(list1): 
    print ("The list is Empty") 
else: 
    print ("The list isn't empty") 

# Result: "The list is Empty"

उम्मीद है की यह मदद करेगा।