ตัวอย่างเช่น หากผ่านสิ่งต่อไปนี้:

a = []

เช็คยังไงว่าaว่าง?

ตอบ
if not a:
  print("List is empty")

การใช้ค่าบูลีนโดยปริยายของค่าว่างlistนั้นค่อนข้างจะเป็น pythonic

วิธี pythonic ทำได้จากคำแนะนำสไตล์ PEP 8 (โดยที่Yesหมายถึง "แนะนำ" และNoหมายถึง "ไม่แนะนำ"):

For sequences, (strings, lists, tuples), use the fact that empty sequences are false.

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เป็นตัวแปรบูลีน

นี่เป็นครั้งแรกที่ google hit สำหรับ "python test empty array" และข้อความค้นหาที่คล้ายกัน รวมทั้งคนอื่น ๆ ที่ดูเหมือนจะถามคำถามทั่วไปมากกว่าแค่รายการ ดังนั้นฉันคิดว่าฉันจะเพิ่มข้อแม้สำหรับลำดับประเภทอื่นที่ผู้คนจำนวนมาก อาจใช้.

วิธีอื่นใช้ไม่ได้กับ NumPy arrays

คุณต้องระมัดระวังกับอาร์เรย์ NumPy เนื่องจากวิธีการอื่นๆ ที่ทำงานได้ดีสำหรับlists หรือคอนเทนเนอร์มาตรฐานอื่นๆ จะล้มเหลวสำหรับอาร์เรย์ NumPy ฉันอธิบายเหตุผลด้านล่าง แต่โดยย่อวิธีที่ต้องการคือการใช้size.

วิธี "pythonic" ใช้งานไม่ได้: ตอนที่ 1

วิธี "pythonic" ล้มเหลวด้วยอาร์เรย์ NumPy เนื่องจาก NumPy พยายามส่งอาร์เรย์ไปยังอาร์เรย์ของbools และ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()

วิธี "pythonic" ใช้งานไม่ได้: ตอนที่ 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 แม้ว่าอาร์เรย์จะมีองค์ประกอบเป็นศูนย์

วิธี numpythonic

ตามที่อธิบายไว้ใน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

หากคุณไม่แน่ใจว่าอาจเป็น a list, NumPy array หรืออย่างอื่น คุณสามารถรวมวิธีนี้กับคำตอบที่ @dubiousjim ให้เพื่อให้แน่ใจว่าการทดสอบที่ถูกต้องสำหรับแต่ละประเภท ไม่ใช่ "pythonic" มากนัก แต่ปรากฎว่า NumPy ตั้งใจทำลาย pythonicity อย่างน้อยในแง่นี้

หากคุณต้องการทำมากกว่าแค่ตรวจสอบว่าอินพุตว่างหรือไม่ และคุณกำลังใช้ฟีเจอร์ NumPy อื่นๆ เช่น การทำดัชนีหรือการคำนวณทางคณิตศาสตร์ การบังคับอินพุตให้เป็นอาร์เรย์ NumPy อาจมีประสิทธิภาพมากกว่า (และเป็นเรื่องปกติมากกว่า) มีฟังก์ชั่นที่ดีบางประการสำหรับการทำเช่นนี้ได้อย่างรวดเร็ว - numpy.asarrayที่สำคัญที่สุดการดำเนินการนี้จะรับข้อมูลที่คุณป้อน ไม่ทำอะไรเลยหากเป็นอาร์เรย์อยู่แล้ว หรือรวมข้อมูลที่คุณป้อนลงในอาร์เรย์หากเป็นรายการ ทูเปิล ฯลฯ และเลือกที่จะแปลงเป็นไฟล์dtype. ดังนั้นมันจึงรวดเร็วมากเมื่อไรก็ได้ และทำให้แน่ใจว่าคุณเพิ่งจะถือว่าอินพุตเป็นอาร์เรย์ NumPy เรามักจะใช้ชื่อเดียวกันด้วยซ้ำ เนื่องจากการแปลงเป็นอาร์เรย์จะไม่ทำให้มันกลับคืนมานอกขอบเขตปัจจุบัน:

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

ซึ่งจะทำให้การx.sizeตรวจสอบทำงานได้ในทุกกรณีที่ฉันเห็นในหน้านี้

Best way to check if a list is empty

For example, if passed the following:

a = []

How do I check to see if a is empty?

คำตอบสั้น ๆ:

วางรายการในบริบทบูลีน (เช่น ด้วยคำสั่งifหรือwhile) มันจะทดสอบFalseว่าว่างเปล่าTrueหรือไม่ ตัวอย่างเช่น:

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

PEP 8

PEP 8คู่มือสไตล์ Python อย่างเป็นทางการสำหรับโค้ด Python ในไลบรารีมาตรฐานของ Python ยืนยันว่า:

For sequences, (strings, lists, tuples), use the fact that empty sequences are false.

Yes: if not seq:
     if seq:

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

เราควรคาดหวังว่าโค้ดไลบรารีมาตรฐานควรมีประสิทธิภาพและถูกต้องมากที่สุด แต่ทำไมถึงเป็นเช่นนั้น และเหตุใดเราจึงต้องการคำแนะนำนี้

คำอธิบาย

ฉันมักจะเห็นโค้ดเช่นนี้จากโปรแกรมเมอร์ที่มีประสบการณ์ซึ่งเพิ่งเริ่มใช้ Python:

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

สิ่งเหล่านี้ถูกต้องในภาษาอื่นๆ ที่เกี่ยวข้อง และนี่ก็ยังถูกต้องตามความหมายใน Python

แต่เราพิจารณาว่าเป็น un-Pythonic เนื่องจาก Python รองรับความหมายเหล่านี้โดยตรงในอินเทอร์เฟซของรายการวัตถุผ่านการบีบบังคับบูลีน

จากเอกสาร (และสังเกตเฉพาะการรวมรายการว่าง[]):

By default, an object is considered true unless its class defines either a __bool__() method that returns False or a __len__() method that returns zero, when called with the object. Here are most of the built-in objects considered false:

  • constants defined to be false: None and False.
  • zero of any numeric type: 0, 0.0, 0j, Decimal(0), Fraction(0, 1)
  • empty sequences and collections: '', (), [], {}, set(), range(0)

และเอกสาร datamodel:

object.__bool__(self)

Called to implement truth value testing and the built-in operation bool(); should return False or True. When this method is not defined, __len__() is called, if it is defined, and the object is considered true if its result is nonzero. If a class defines neither __len__() nor __bool__(), all its instances are considered true.

และ

object.__len__(self)

Called to implement the built-in function len(). Should return the length of the object, an integer >= 0. Also, an object that doesn’t define a __bool__() method and whose __len__() method returns zero is considered to be false in a Boolean context.

ดังนั้นแทนที่จะ:

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

ทำสิ่งที่ Pythonic มักจะให้ผลตอบแทนในการทำงาน:

มันจ่ายออก? (โปรดทราบว่าเวลาที่น้อยกว่าในการดำเนินการเทียบเท่าจะดีกว่า :)

>>> 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 หรือตรวจสอบกับรายการที่ว่างเปล่าเป็นมากน้อย performant กว่าการใช้ไวยากรณ์ในตัวของภาษาที่เป็นเอกสาร

ทำไม?

สำหรับlen(a) == 0เช็ค:

Python ก่อนอื่นต้องตรวจสอบ globals เพื่อดูว่าlenมีเงาหรือไม่

จากนั้นจะต้องเรียกใช้ฟังก์ชัน load 0และทำการเปรียบเทียบความเท่าเทียมกันใน Python (แทนที่จะเป็น C):

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

และสำหรับ[] == []มันต้องสร้างรายการที่ไม่จำเป็นแล้วทำการเปรียบเทียบในเครื่องเสมือนของ Python อีกครั้ง (ตรงข้ามกับ C)

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

วิธี "Pythonic" เป็นการตรวจสอบที่ง่ายกว่าและเร็วกว่ามาก เนื่องจากความยาวของรายการถูกแคชไว้ในส่วนหัวของอินสแตนซ์อ็อบเจ็กต์:

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

หลักฐานจากแหล่ง C และเอกสารประกอบ

PyVarObject

This is an extension of PyObject that adds the ob_size field. This is only used for objects that have some notion of length. This type does not often appear in the Python/C API. It corresponds to the fields defined by the expansion of the PyObject_VAR_HEAD macro.

จากแหล่ง c ใน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

ตอบกลับความคิดเห็น:

I would point out that this is also true for the non-empty case though its pretty ugly as with l=[] then %timeit len(l) != 0 90.6 ns ± 8.3 ns, %timeit l != [] 55.6 ns ± 3.09, %timeit not not l 38.5 ns ± 0.372. But there is no way anyone is going to enjoy not not l despite triple the speed. It looks ridiculous. But the speed wins out
I suppose the problem is testing with timeit since just if l: is sufficient but surprisingly %timeit bool(l) yields 101 ns ± 2.64 ns. Interesting there is no way to coerce to bool without this penalty. %timeit l is useless since no conversion would occur.

IPython magic %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ตรวจสอบเงื่อนไขจริงหรือตัวรายการเอง และหากมีสิ่งใด การให้รายการตามที่เป็นอยู่จะเร็วขึ้น

Python เขียนด้วย C; มันใช้ตรรกะของมันที่ระดับ C สิ่งที่คุณเขียนใน Python จะช้าลง และมีแนวโน้มว่าลำดับความสำคัญจะช้าลง เว้นแต่คุณจะใช้กลไกที่สร้างไว้ใน Python โดยตรง

รายการว่างถือเป็นเท็จในการทดสอบค่าจริง (ดูเอกสารประกอบของ python ):

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

@ดาเรน โทมัส

EDIT: Another point against testing the empty list as False: What about polymorphism? You shouldn't depend on a list being a list. It should just quack like a duck - how are you going to get your duckCollection to quack ''False'' when it has no elements?

DuckCollection ของคุณควรนำไปใช้__nonzero__หรือ__len__ดังนั้น if a: จะทำงานโดยไม่มีปัญหา

คำตอบของ Patrick (ยอมรับ)ถูกต้อง: if not a:เป็นวิธีที่ถูกต้อง คำตอบของ Harley Holcombeนั้นถูกต้องในคู่มือสไตล์ PEP 8 แต่สิ่งที่ไม่มีคำตอบใดอธิบายได้คือเหตุใดจึงเป็นความคิดที่ดีที่จะปฏิบัติตามสำนวนนี้ แม้ว่าคุณจะพบว่ามันไม่ชัดเจนเพียงพอหรือสร้างความสับสนให้กับผู้ใช้ Ruby หรืออะไรก็ตาม

รหัส Python และชุมชน Python มีสำนวนที่ชัดเจนมาก การปฏิบัติตามสำนวนเหล่านี้ทำให้โค้ดของคุณอ่านง่ายขึ้นสำหรับทุกคนที่มีประสบการณ์ใน Python และเมื่อคุณละเมิดสำนวนเหล่านั้น นั่นเป็นสัญญาณที่แรง

เป็นความจริงที่if not a:จะไม่แยกแยะรายการว่างจากNone, หรือตัวเลข 0 หรือทูเพิลว่าง หรือประเภทคอลเลกชันที่ผู้ใช้สร้างขึ้นที่ว่างเปล่า หรือประเภทการรวบรวมที่ผู้ใช้สร้างขึ้นที่ว่างเปล่า หรืออาร์เรย์ NumPy องค์ประกอบเดียวที่ทำหน้าที่เป็นสเกลาร์ที่มีความเท็จ ค่านิยม ฯลฯ และบางครั้ง สิ่งสำคัญคือต้องมีความชัดเจนเกี่ยวกับสิ่งนั้น และในกรณีนั้น คุณรู้ว่าคุณต้องการให้ชัดเจนเกี่ยวกับอะไร คุณจึงสามารถทดสอบสิ่งนั้นได้อย่างแน่นอน ตัวอย่างเช่นif not a and a is not None:หมายถึง "สิ่งใดก็ตามที่เป็นเท็จ ยกเว้นไม่มี" ในขณะที่if len(a) != 0:หมายถึง "เฉพาะลำดับที่ว่างเปล่า—และสิ่งใดๆ นอกเหนือจากลำดับคือข้อผิดพลาดที่นี่" เป็นต้น นอกจากการทดสอบสิ่งที่คุณต้องการทดสอบแล้ว ยังส่งสัญญาณให้ผู้อ่านทราบว่าการทดสอบนี้มีความสำคัญ

แต่เมื่อคุณไม่มีอะไรจะชัดเจน สิ่งอื่นที่ไม่ใช่if not a:จะทำให้ผู้อ่านเข้าใจผิด คุณกำลังส่งสัญญาณบางอย่างที่สำคัญเมื่อมันไม่ใช่ (คุณยังอาจจะทำให้รหัสที่มีความยืดหยุ่นน้อยกว่าหรือช้ากว่าหรืออะไรก็ตาม แต่นั่นคือทั้งหมดที่มีความสำคัญน้อย.) และถ้าคุณเป็นประจำทำให้เข้าใจผิดของผู้อ่านเช่นนี้แล้วเมื่อคุณทำจำเป็นที่จะต้องสร้างความแตกต่างก็จะผ่านเพราะไม่มีใครสังเกตเห็น คุณได้รับ "หมาป่าร้องไห้" ทั่วรหัสของคุณ

ทำไมต้องตรวจสอบเลย?

ดูเหมือนจะไม่มีใครตั้งคำถามถึงความต้องการของคุณในการทดสอบรายการตั้งแต่แรก เนื่องจากคุณไม่ได้ให้บริบทเพิ่มเติม ฉันจึงจินตนาการได้ว่าคุณอาจไม่จำเป็นต้องทำการตรวจสอบนี้ตั้งแต่แรก แต่ไม่คุ้นเคยกับการประมวลผลรายการใน Python

ฉันจะเถียงว่าวิธีpythonic ที่สุดคือไม่ตรวจสอบเลย แต่ให้ประมวลผลรายการ ด้วยวิธีนี้จะทำสิ่งที่ถูกต้องไม่ว่าจะว่างหรือเต็ม

a = []

for item in a:
    <do something with item>

<rest of code>

สิ่งนี้มีประโยชน์ในการจัดการเนื้อหาใด ๆ ของaในขณะที่ไม่ต้องการการตรวจสอบเฉพาะสำหรับความว่างเปล่า หากaว่างเปล่า บล็อกที่ขึ้นต่อกันจะไม่ทำงานและล่ามจะข้ามไปยังบรรทัดถัดไป

หากคุณต้องการตรวจสอบความว่างเปล่าของอาร์เรย์จริงๆ คำตอบอื่นๆ ก็เพียงพอแล้ว

len()เป็นการดำเนินการ O(1)สำหรับรายการ Python, strings, dicts และ sets Python ติดตามจำนวนองค์ประกอบในคอนเทนเนอร์เหล่านี้ภายใน

JavaScript มีความคิดที่คล้ายกันของ truthy

ฉันได้เขียน:

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

ซึ่งได้รับการโหวต -1 ฉันไม่แน่ใจว่าเป็นเพราะผู้อ่านคัดค้านกลยุทธ์นี้หรือคิดว่าคำตอบไม่เป็นประโยชน์ตามที่เสนอ ฉันจะแสร้งทำเป็นว่าเป็นสิ่งหลัง เนื่องจาก---สิ่งที่นับเป็น "pythonic"---นี่คือกลยุทธ์ที่ถูกต้อง จนกว่าคุณจะได้ตัดสินแล้วออกหรือกำลังเตรียมที่จะจับกรณีที่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

การทดสอบครั้งแรกเป็นการตอบสนองต่อคำตอบของ @ Mike ด้านบน บรรทัดที่สามยังสามารถแทนที่ด้วย:

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

หากคุณต้องการยอมรับเฉพาะอินสแตนซ์บางประเภท (และประเภทย่อย) หรือด้วย:

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

คุณสามารถหนีไปได้โดยไม่ต้องมีการตรวจสอบประเภทที่ชัดเจน แต่เฉพาะในกรณีที่บริบทโดยรอบยืนยันกับคุณแล้วว่าaเป็นค่าของประเภทที่คุณเตรียมที่จะจัดการ หรือหากคุณแน่ใจว่าประเภทที่คุณไม่ได้เตรียมรับมือกำลังดำเนินการอยู่ เพื่อสร้างข้อผิดพลาด (เช่นTypeErrorหากคุณเรียกlenใช้ค่าที่ไม่ได้กำหนดไว้) ที่คุณพร้อมจะจัดการ โดยทั่วไป อนุสัญญา "หลาม" ดูเหมือนจะไปทางสุดท้าย บีบมันเหมือนเป็ดแล้วปล่อยให้ DuckError เกิดข้อผิดพลาดหากไม่รู้วิธีต้มตุ๋น คุณยังคงต้องคิดว่าคุณกำลังตั้งสมมติฐานประเภทใด และกรณีที่คุณไม่ได้เตรียมรับมืออย่างเหมาะสมจริง ๆ จะผิดพลาดในสถานที่ที่เหมาะสมหรือไม่ อาร์เรย์ Numpy เป็นตัวอย่างที่ดีที่พึ่งพิงlen หรือ typecast บูลีนอาจไม่ตรงตามที่คุณคาดหวัง

จากเอกสารเกี่ยวกับการทดสอบค่าความจริง:

ค่าทั้งหมดนอกเหนือจากที่ระบุไว้ที่นี่ถือเป็นค่า True

  • None
  • False
  • ศูนย์ของตัวเลขประเภทใดก็ได้ เช่น0, 0.0, 0j.
  • ลำดับว่างใดๆ เช่น'', (), [].
  • การแมปเปล่าใดๆ เช่น{}.
  • อินสแตนซ์ของคลาสที่ผู้ใช้กำหนด หากคลาสกำหนด a __bool__()หรือ__len__()เมธอด เมื่อเมธอดนั้นคืนค่าศูนย์จำนวนเต็มหรือค่าบูFalse

อย่างที่เห็น รายการว่าง[]คือfalsyดังนั้นการทำสิ่งที่จะทำกับค่าบูลีนจึงมีประสิทธิภาพมากที่สุด:

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

ฉันชอบสิ่งต่อไปนี้:

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

ต่อไปนี้เป็นวิธีตรวจสอบว่ารายการว่างเปล่าหรือไม่:

a = [] #the list

1)วิธี pythonic ที่ค่อนข้างง่าย:

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

ใน Python คอนเทนเนอร์เปล่าเช่นรายการ tuples ชุด dicts ตัวแปร ฯลฯ จะถูกมองว่าเป็นFalse. หนึ่งสามารถรักษารายการเป็นเพรดิเคต ( ส่งคืนค่าบูลีน ) และTrueค่าจะระบุว่าไม่ว่างเปล่า

2)วิธีที่ชัดเจนมาก: ใช้ the 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")

วิธีที่ 1 (แนะนำ):

if not a : 
   print ("Empty") 

วิธีที่ 2:

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

วิธีที่ 3:

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

คุณสามารถลองใช้วิธีbool()นี้ได้ แม้ว่าจะอ่านได้น้อยกว่า แต่ก็เป็นวิธีที่กระชับในการดำเนินการนี้

    a = [1,2,3];
    print bool(a); # it will return True
    a = [];
    print bool(a); # it will 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-ness คุณไม่จำเป็นต้องทำอย่างนั้น

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

หากคุณต้องการตรวจสอบว่ารายการว่างหรือไม่:

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.

To check whether a list is empty or not you can use two following ways. But remember, we should avoid the way of explicitly checking for a type of sequence (it's a less pythonic way):

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

The second way is a more pythonic one. This method is an implicit way of checking and much more preferable than the previous one.

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"

หวังว่านี่จะช่วยได้

ด้วยแรงบันดาลใจจากวิธีแก้ปัญหาของ @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

เราสามารถใช้ simple if else:

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

ใช้งานได้จริงมากขึ้นเล็กน้อย:

a.pop() if a else None

และเวอร์ชัน shertest:

if a: a.pop() 

เพียงใช้ is_empty() หรือสร้างฟังก์ชันเช่น:-

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

สามารถใช้สำหรับ data_structure เช่น รายการ ทูเพิล พจนานุกรม และอื่นๆ อีกมากมาย คุณสามารถเรียกมันได้หลายครั้งโดยใช้เพียงis_empty(any_structure).

วิธีง่ายๆ คือ การตรวจสอบความยาวเท่ากับศูนย์

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

ตั้งแต่ python3 เป็นต้นไป คุณสามารถใช้

a == []

เพื่อตรวจสอบว่ารายการว่างหรือไม่

แก้ไข: สิ่งนี้ใช้ได้กับ python2.7 ด้วย ..

ฉันไม่แน่ใจว่าทำไมจึงมีคำตอบที่ซับซ้อนมากมาย ค่อนข้างชัดเจนและตรงไปตรงมา

ค่าความจริงของรายการที่ว่างเปล่าคือในขณะที่สำหรับรายการที่ไม่ว่างเปล่ามันเป็นFalseTrue

สิ่งที่นำฉันมาที่นี่คือกรณีการใช้งานพิเศษ: จริง ๆ แล้วฉันต้องการให้ฟังก์ชันบอกฉันว่ารายการว่างเปล่าหรือไม่ ฉันต้องการหลีกเลี่ยงการเขียนฟังก์ชันของตัวเองหรือใช้ lambda-expression ที่นี่ (เพราะดูเหมือนว่าควรจะง่ายพอ):

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ตัวเลือกที่ดีที่สุด