जवाबों:
if not a:
print("List is empty")
खाली के निहित बूलनेस का उपयोग करना listकाफी pythonic है।
if a == []एक विशेष प्रकार के लिए मजबूर कर रहा है ( () == []है False)। यहाँ, आम सहमति यह प्रतीत होती है कि बतख टाइपिंग जीत जाती है (वास्तव में, यह कहते हुए कि __nonzero__शून्यता का परीक्षण करने के लिए इंटरफ़ेस docs.python.org/reference/datamodel.html#object.__nonzero__ )
Pythonic जिस तरह से यह से है करने के लिए पीईपी 8 स्टाइल गाइड (जहां हाँ का अर्थ है "सिफारिश" और कोई अर्थ है "अनुशंसित नहीं"):
अनुक्रमों के लिए, (स्ट्रिंग्स, सूचियों, ट्यूपल्स), इस तथ्य का उपयोग करें कि खाली क्रम झूठे हैं।
Yes: if not seq: if seq: No: if len(seq): if not len(seq):
seqकिसी प्रकार की सूची जैसी वस्तु होने की उम्मीद है।
मैं इसे स्पष्ट रूप से पसंद करता हूं:
if len(li) == 0:
print('the list is empty')इस तरह यह 100% स्पष्ट है कि liएक अनुक्रम (सूची) है और हम इसके आकार का परीक्षण करना चाहते हैं। इसके साथ मेरी समस्या if not li: ...यह है कि यह गलत धारणा देता liहै जो बूलियन चर है।
liहै कि यह एक बूल है, और अभ्यस्त देखभाल नहीं है। यदि यह महत्वपूर्ण है, तो आपको एक टिप्पणी जोड़नी चाहिए, न कि अधिक कोड।
Noneया 0पारित करने के बजाय एक अपवाद जुटाने के लिए)। इसलिए, जब आप कोई कारण नहीं, कि है के लिए यह करना भ्रामक-और यह भी मतलब है कि जब अपने कोड करता है भेद करने की आवश्यकता, भेद अदृश्य है क्योंकि आप "रोया भेड़िया" सभी स्रोत के बाकी हिस्सों में है।
if bool(len(li) == 0) is True:?
यह "अजगर टेस्ट खाली एरे" और इसी तरह के प्रश्नों के लिए पहली हिट है, साथ ही अन्य लोग सिर्फ सूचियों से परे प्रश्न का सामान्यीकरण करते दिखते हैं, इसलिए मैंने सोचा कि मैं एक अलग प्रकार के अनुक्रम के लिए एक चेतावनी जोड़ूंगा जो बहुत सारे लोग करते हैं उपयोग कर सकते हैं।
आपको NumPy सरणियों से सावधान रहने की आवश्यकता है, क्योंकि अन्य तरीके जो lists या अन्य मानक कंटेनरों के लिए ठीक काम करते हैं, वे NumPy सरणियों के लिए विफल हो जाते हैं। मैं नीचे क्यों समझाता हूं, लेकिन संक्षेप में, पसंदीदा विधि का उपयोग करना है size।
"पाइथोनिक" तरीका 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()लेकिन कम से कम ऊपर का मामला आपको बताता है कि यह विफल रहा। यदि आपके पास वास्तव में एक तत्व के साथ एक 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इस पृष्ठ पर मेरे द्वारा देखे जाने वाले सभी मामलों में चेक का काम करेगा ।
numpy- numpyएक पुस्तकालय है जो एक बहुत ही विशिष्ट उपयोग के मामले के साथ है, और इसमें एक सरणी पर सत्यता की एक अलग 'प्राकृतिक' परिभाषा है। कंटेनरों के लिए पायथन मानक। यह उस मामले के लिए अनुकूलन करने के लिए समझ में आता है, जिस तरह से इसके बजाय पथों pathlibका उपयोग /करने के लिए +- यह गैर-मानक है, लेकिन संदर्भ में समझ में आता है।
if xऔर len(x)मुहावरों दोनों के लिए बतख टाइपिंग को तोड़ने का विकल्प चुना है - और कभी-कभी उस टूटना का पता लगाना और डीबग करना बहुत कठिन हो सकता है।
सूची खाली है या नहीं, यह जांचने का सबसे अच्छा तरीका है
उदाहरण के लिए, यदि निम्न पास हो:
a = []मैं यह देखने के लिए कैसे जांचूं कि क्या कोई खाली है?
सूची को बूलियन संदर्भ में रखें (उदाहरण के लिए, ifया whileकथन के साथ)। यह Falseखाली होने पर परीक्षण करेगा , और Trueअन्यथा। उदाहरण के लिए:
if not a: # do this!
print('a is an empty list')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)
और डेटामॉडल प्रलेखन:
सत्य मूल्य परीक्षण और अंतर्निहित ऑपरेशन को लागू करने के लिए कहा जाता है
bool(); लौट जाना चाहिएFalseयाTrue। जब इस पद्धति को परिभाषित नहीं किया__len__()जाता है, तो इसे कहा जाता है, अगर यह परिभाषित किया गया है, और वस्तु को सही माना जाता है यदि इसका परिणाम गैर-शून्य हो। यदि कोई वर्ग न तो परिभाषित करता है और न__len__()ही__bool__(), उसके सभी उदाहरण सत्य माने जाते हैं।
तथा
अंतर्निहित फ़ंक्शन को लागू करने के लिए कहा जाता है
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यह
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स्थिति में चेक या सूची में पास हो जाते हैं, और यदि कुछ भी है, तो सूची, जैसा कि है, तेजी से है।
अजगर सी में लिखा है; यह सी स्तर पर अपने तर्क का उपयोग करता है। पाइथन में आप जो भी लिखेंगे वह धीमा होगा। और यह संभवतः परिमाण धीमे के आदेश होंगे जब तक कि आप सीधे पाइथन में निर्मित तंत्र का उपयोग नहीं कर रहे हैं।
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 64 2.64 n उपज है। दिलचस्प है कि इस दंड के बिना बूल के लिए ज़बरदस्ती करने का कोई तरीका नहीं है। %timeit lतब से बेकार है जब तक कोई रूपांतरण नहीं होगा।
एक खाली सूची को सही मान परीक्षण में गलत माना जाता है ( अजगर प्रलेखन देखें ):
a = []
if a:
print "not empty"@ डारेन थॉमस
संपादित करें: खाली सूची को गलत के रूप में परीक्षण करने के खिलाफ एक और बिंदु: बहुरूपता के बारे में क्या? आपको एक सूची होने वाली सूची पर निर्भर नहीं होना चाहिए। यह सिर्फ एक बतख की तरह होना चाहिए - जब आप कोई तत्व नहीं रखते हैं, तो आप '' गलत '' को खत्म करने के लिए कैसे अपने duckCollection पाने जा रहे हैं?
आपके duckCollection को लागू करना चाहिए __nonzero__या __len__यदि कोई a: समस्याओं के बिना काम करेगा।
[] == Falseगलत हालांकि मूल्यांकन करेंगे
bool()। bool([]) == Falseउम्मीद के अनुसार मूल्यांकन Trueकरेंगे।
पैट्रिक का (स्वीकृत) उत्तर सही है: 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>इस के किसी भी सामग्री से निपटने को लाभ मिलता है एक , जबकि शून्य के लिए एक विशेष जांच की जरूरत नहीं। यदि कोई खाली है, तो आश्रित ब्लॉक निष्पादित नहीं करेगा और दुभाषिया अगली पंक्ति से होकर गुजरेगा।
यदि आपको वास्तव में खालीपन के लिए सरणी की जांच करने की आवश्यकता है, तो अन्य उत्तर पर्याप्त हैं।
<rest of code>जो forलूप से परिणाम का उपयोग कर सकती है ? या सीधे कुछ मूल्यों का उपयोग करें a? वास्तव में, यदि स्क्रिप्ट को कड़ाई से नियंत्रित इनपुट के साथ चलाने के लिए डिज़ाइन किया गया है, तो चेक थोड़ा अनावश्यक हो सकता है। लेकिन ज्यादातर मामलों में, इनपुट भिन्न होता है, और एक चेक आमतौर पर बेहतर होता है।
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 या बूलियन टाइपकास्ट ठीक नहीं कर सकता है कि आप क्या उम्मीद कर रहे हैं।
collections.abc.Sizedया collections.abc.Sequence, लेकिन यह वह हो सकता है जिसे आप स्वयं और register(list)पर लिखते हैं । यदि आपके पास वास्तव में ऐसा कोड है जहां अन्य फाल्सी से खाली को अलग करना महत्वपूर्ण है, और सूचियों और ट्यूपल्स को किसी अन्य अनुक्रम से अलग करना भी है, तो यह सही है - लेकिन मेरा मानना है कि आपके पास ऐसा कोड नहीं है।
[]और किसी अन्य प्रकार का झूठा नहीं है, तो निश्चित रूप if a == []:से आइंस्टीन के साथ छेड़छाड़ करने के बजाय, इसे बुलाया जाता है।
==। मेरे सिर के ऊपर से, मैं किसी के लिए पहचान नहीं कर सकता []। [] == ()उदाहरण के लिए रिटर्न False। लेकिन उदाहरण के लिए frozenset()==set()रिटर्न True। तो यह कम से कम कुछ विचार देने के लायक है कि क्या कुछ अवांछित प्रकार करने पर [](या इसके विपरीत) करने के लिए मजबूर किया जा सकता है a == []।
सत्य मूल्य परीक्षण पर प्रलेखन से :
यहां सूचीबद्ध के अलावा अन्य सभी मूल्यों पर विचार किया जाता है True
NoneFalse0, 0.0, 0j।'', (), []।{}।__bool__()या __len__()पद्धति को परिभाषित करता है , जब वह विधि पूर्णांक शून्य या बूल मान लौटाती है False।देखा जा सकता है, खाली सूची []है falsy , क्या एक बूलियन मान आवाज़ सबसे कुशल करने के लिए किया जाएगा ताकि:
if not a:
print('"a" is empty!')assert(not myList)। यदि आप भी दावा करना चाहते हैं कि वस्तु ए है list, तो आप उपयोग कर सकते हैं assertIsInstance()।
यदि कोई सूची खाली है, तो आप कुछ तरीके देख सकते हैं:
a = [] #the list1) सुंदर सरल 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."if not a:और अधिक आसानी से टूट जाता है। कृपया इसे न करें।
() == []भी असत्य के बराबर है। हालांकि मुझे यह पसंद है कि यह कार्यान्वयन if not a:सभी मामलों को कैसे कवर करता है, यदि आप निश्चित रूप से सूची की उम्मीद कर रहे हैं तो आपका उदाहरण पर्याप्त होना चाहिए।
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")aसूची नहीं है और aकोई विधि __len__लागू नहीं की गई है। मैं सिफारिश करूंगा:if isinstance(obj, list): if len(obj) == 0: print '...'
andपायथन में ऑपरेटर आलसी है। इसके बाद कुछ भी नहीं किया andजा रहा है अगर पहले andकी स्थिति गलत है।
हम एक सरल का उपयोग कर सकते हैं अगर और:
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(())
Trueif a:होता, तो ऐसा इसलिए होता क्योंकि मैं aकिसी तरह का कंटेनर नहीं चाहता था। (एक चलने योग्य होने के नाते भी पुनरावृत्तियों की अनुमति देता है, जो शून्यता के लिए उपयोगी नहीं हो सकता है।)
print('not empty' if a else 'empty')थोड़ा और व्यावहारिक:
a.pop() if a else Noneऔर shertest संस्करण:
if a: a.pop() Python3 के बाद से आप उपयोग कर सकते हैं
a == []जाँच करें कि सूची खाली है या नहीं
संपादित करें: यह python2.7 के साथ भी काम करता है।
मुझे यकीन नहीं है कि इतने सारे जटिल उत्तर क्यों हैं। यह बहुत स्पष्ट और सीधा है
aखाली है या नहीं।
pythonic
a==[]यह एक खाली होने पर अजगर टर्मिनल पर सच प्रिंट होगा। इसके बजाय यह फाल्स प्रिंट करेगा। आप इसे एक दशा के अंदर भी उपयोग कर सकते हैं जैसेif(a==[])
आप इस तरह से बूल () का उपयोग करके भी देख सकते हैं
a = [1,2,3];
print bool(a); # it will return True
a = [];
print bool(a); # it will return Falseमुझे पसंद है कि सूची की जाँच के लिए यह तरीका खाली है या नहीं।
बहुत आसान और उपयोगी।
bool()पायथन वैरिएबल को बूलियन में परिवर्तित कर देता है ताकि आप एक इफ -स्टेटमेंट का उपयोग किए बिना किसी मूल्य की सत्यता या झूठ को स्टोर कर सकें । मुझे लगता है कि यह केवल स्वीकृत उत्तर की तरह एक सशर्त का उपयोग करने से कम पठनीय है, लेकिन मुझे यकीन है कि इसके लिए अन्य अच्छे उपयोग के मामले हैं।
बस 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)।
is_emptyपता चलता है कि यह कुछ लौटाता है। लेकिन अगर ऐसा किया जाता है, तो कुछ ऐसा होगा bool(any_structure), जिसका आपको उपयोग करना चाहिए ( जब आपको boolबिल्कुल भी ज़रूरत हो)।
boolउस पर भी बदलाव क्यों चाहते हैं (भी) मानक उत्पादन के लिए संदेश प्रिंट करता है?
boolवेरिएबल का उपयोग करें। चुनना आपको है। मैं दोनों लिखता हूं ताकि आप उनके बीच चयन कर सकें।
सरल तरीके से जाँच की जा रही है कि लंबाई बराबर शून्य है।
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"उम्मीद है की यह मदद करेगा।