たとえば、以下を渡した場合：

a = []

a空かどうかを確認するにはどうすればよいですか？

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

空の暗黙のブール値を使用することlistは、かなりpythonicです。

それを行うためのpythonicの方法は、PEP 8スタイルガイドからです（ここで、「はい」は「推奨」を意味し、「いいえ」は「非推奨」を意味します）。

シーケンス（文字列、リスト、タプル）の場合、空のシーケンスはfalseであるという事実を使用します。

Yes: if not seq:
     if seq:

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

私はそれを明示的に好みます：

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

このようにしてli、シーケンス（リスト）であることが100％明確であり、そのサイズをテストします。私の問題は、ブール変数if not li: ...でliあるという誤った印象を与えることです。

_{これは、「python test empty array」と同様のクエリに対する最初のgoogleヒットです。さらに、他の人々はリストだけでなく質問を一般化しているようですので、多くの人々が異なるタイプのシーケンスについて警告を追加すると思いました使用するかもしれません。}

他のメソッドはNumPy配列では機能しません

NumPy配列では、listsまたは他の標準コンテナーで正常に機能する他のメソッドが失敗するため、NumPy配列には注意する必要があります。以下で理由を説明しますが、簡単に言うと、推奨される方法はを使用することsizeです。

「pythonic」の方法は機能しません：パート1

「pythonic」の方法は、NumPy配列で失敗します。NumPyは、配列をboolsの配列にキャストしようとし、ある種の集計真理値についてif xそれらすべてのboolsを一度に評価しようとするためです。しかし、これは意味をなさないので、次のようになります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

しかし、少なくとも上記の場合は、失敗したことを示しています。要素が1つだけのNumPy配列がifある場合、エラーが発生しないという意味で、ステートメントは「機能」します。ただし、その1つの要素が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)) )

配列の要素が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

あなたは必ずそれはあるかもしれないかどうかをしていない場合はlist、numpyの配列、または何か他のもの、あなたがこのアプローチを組み合わせることができ@dubiousjimが与える答えてください右テストは、各タイプのために使用されていることを確認します。それほど「Pythonic」ではありませんが、NumPyは少なくともこの意味でPythonicityを意図的に壊したことがわかりました。

入力が空であるかどうかを確認するだけでなく、インデックス作成や数学演算などの他のNumPy機能を使用している場合は、入力を NumPy配列に強制する方がおそらくより効率的です（そしてより一般的です）。これをすばやく行うための便利な関数がいくつかあります—最も重要なのはnumpy.asarrayです。これはあなたの入力を受け取り、それがすでに配列の場合は何もせず、それがリストやタプルなどの場合は入力を配列にラップし、オプションでそれをあなたが選んだに変換しますdtype。そのため、可能な限り非常に高速であり、入力がNumPy配列であると想定できるようにします。配列に変換しても現在のスコープの外には戻らないため、通常は同じ名前を使用します。

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

これにより、x.sizeこのページに表示されるすべてのケースでチェックが機能します。

リストが空かどうかを確認する最良の方法

たとえば、以下を渡した場合：

a = []

が空かどうかを確認するにはどうすればよいですか？

簡潔な答え：

リストをブールコンテキストに配置します（たとえば、ifor whileステートメントを使用）。False空かどうかをテストしTrueます。例えば：

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

PEP 8

Pythonの標準ライブラリにあるPythonコードの公式PythonスタイルガイドであるPEP 8は、次のように主張しています。

シーケンス（文字列、リスト、タプル）の場合、空のシーケンスは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でも意味的に正しいです。

ただし、Pythonはブール型強制を介してリストオブジェクトのインターフェースで直接これらのセマンティクスをサポートしているため、Pythonではないものと見なします。

ドキュメントから（そして空のリストが含まれていることに特に注意してください[]）：

デフォルトでは、オブジェクトで呼び出されたときに、そのクラス__bool__()が返すメソッドFalseまたは__len__()ゼロを返すメソッドのいずれかをクラスで定義しない限り、オブジェクトはtrueと見なされます。以下は、falseと見なされる組み込みオブジェクトのほとんどです。

• false Noneと定義された定数：およびFalse。
• 任意の数値型のゼロ：0、0.0、0j、Decimal(0)、Fraction(0, 1)
• 空のシーケンスやコレクション：''、()、[]、{}、set()、range(0)

そして、データモデルのドキュメント：

object.__bool__(self)

真理値テストと組み込み操作を実装するために呼び出されbool()ます。Falseまたはを返す必要がありTrueます。このメソッドが定義されていない __len__()場合、それが定義されていればが呼び出され、その結果がゼロ以外であればオブジェクトはtrueと見なされます。クラスがもも定義してい__len__() ない場合、__bool__()そのインスタンスはすべてtrueと見なされます。

そして

object.__len__(self)

組み込み関数を実装するために呼び出されますlen()。オブジェクトの長さ、0以上の整数を返す必要があります。また、__bool__()メソッドを定義せず、__len__()メソッドがゼロを返すオブジェクトは、ブール値のコンテキストではfalseと見なされます。

したがって、これの代わりに：

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 または空のリストと照合がある多くの文書化されているように、言語の組み込みの構文を使用して、より少ないパフォーマンス。

どうして？

以下のためのlen(a) == 0チェック：

最初のPythonは、グローバルlenがシャドウされているかどうかを確認する必要があります。

次に、関数を呼び出してロードし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

そして、[] == []それは不必要なリストを構築しなければならず、それから再び、（Cとは対照的に）Pythonの仮想マシンで比較操作を行います

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

これはPyObject、ob_sizeフィールドを追加するの拡張です。これは、長さの概念を持つオブジェクトにのみ使用されます。このタイプは、Python / C APIではあまり表示されません。PyObject_VAR_HEADマクロの展開で定義されたフィールドに対応します。

Include / listobject.hの Cソースから：

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、3倍の速度にもかかわらず、誰もが楽しむことはできません。ばかげて見えます。しかし、速度は勝つ
と思います。問題は時間でテストしているだけだと思います。これif l:は十分なこと%timeit bool(l)ですが、驚くほど101 ns±2.64 nsです。興味深いことに、このペナルティなしにブールを強制する方法はありません。%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に条件チェックに渡しても、リスト自体に渡してもほとんど違いがなく、どちらかと言えば、リストをそのまま渡す方が速いということです。

PythonはCで書かれています。Cレベルでロジックを使用します。Pythonで書くものはすべて遅くなります。また、Pythonに直接組み込まれているメカニズムを使用している場合を除き、速度はおそらく桁違いに遅くなります。

空のリストは、それ自体が真の値のテストでfalseと見なされます（pythonのドキュメントを参照）。

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

@ダレン・トーマス

編集：空のリストをFalseとしてテストすることに対するもう1つのポイント：ポリモーフィズムはどうですか？リストがリストであることに依存すべきではありません。それはアヒルのようにいちゃつくべきです-それが要素を持たないとき、どのようにあなたのduckCollectionを '' False ''をいじくりますか？

あなたのduckCollectionは実装する__nonzero__必要があります__len__ので、a：ifは問題なく動作します。

Patrickの（承認された）答えは正しいですif not a:。正しい方法です。Harley Holcombeの答えは、これがPEP 8スタイルガイドにあることです。しかし、答えがどれも説明しないのは、たとえイディオムに従うのが良い考えである理由です。たとえ個人的にそれが十分に明示的ではなく、Rubyユーザーなどにとって混乱している場合でもです。

PythonコードとPythonコミュニティには、非常に強力なイディオムがあります。これらの慣用句に従うと、Pythonの経験者にとってコードが読みやすくなります。そして、それらのイディオムに違反するとき、それは強いシグナルです。

それは事実ですif not a:から、空のリストを区別していないNone、または数値0、または空のタプル、または空のユーザが作成したコレクション型、または空のユーザーが作成していない-かなり-コレクション型、または単一要素numpyの配列はfalseyとスカラとして働きます値など。そして、それについて明示することが重要な場合があります。その場合は、何を明示したいかがわかっているので、それを正確にテストできます。たとえば、if not a and a is not None:「None以外の誤ったもの」をif len(a) != 0:意味し、「空のシーケンスのみ。シーケンス以外のエラーはここではエラーです」などを意味します。これは、テストしたいものを正確にテストすることに加えて、このテストが重要であることを読者に知らせます。

しかし、明確にする必要のあるものが何もない場合if not a:、読者を誤解させる以外の何かが必要です。それが重要ではないときに重要なことを伝えています。（また、柔軟性の低い、あるいはより遅く、または何が、すべての重要度の低いのコードを作成することができる。）そして、あなたがあれば常習的に使用すると、ときに、次のように読者を欺く行う区別する必要があると、見過ごさ理由を渡すために起こっていますコード全体で「オオカミを泣いている」。

なぜチェックするの？

そもそもリストをテストする必要性を問うことに誰も対処していないようです。追加のコンテキストを提供しなかったので、最初にこのチェックを行う必要はないかもしれませんが、Pythonでのリスト処理に慣れていない可能性があります。

最もパイソン的な方法は、まったくチェックしないで、リストを処理するだけであると私は主張します。そうすれば、それは空であろうと満杯であろうと正しいことをします。

a = []

for item in a:
    <do something with item>

<rest of code>

これは、任意の内容の取り扱いの利点がある空虚のための具体的なチェックを必要としないながらに、。場合は空で、依存ブロックは実行されませんし、インタプリタは次の行に通じ分類されます。

空の配列を実際に確認する必要がある場合は、他の回答で十分です。

len()Pythonリスト、文字列、辞書、セットのO（1）操作です。Pythonは内部的にこれらのコンテナー内の要素の数を追跡します。

JavaScript にも同様の真実/虚偽の概念があります。

私は書いた：

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の回答に対する応答です。3行目も次のように置き換えることができます。

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

特定のタイプ（およびそのサブタイプ）のインスタンスのみを受け入れる場合、または以下を使用する場合：

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

明示的な型チェックがなくても回避できますが、周囲のコンテキストaが、処理する準備ができている型の値であることをすでに保証している場合、または処理する準備ができていない型が確実に実行される場合に限ります。処理する準備ができているエラー（たとえば、未定義の値をTypeError呼び出す場合）を発生させるためlen。一般的に、「pythonic」の慣習は、この最後の方法に行くようです。それをアヒルのように絞って、いちゃつく方法がわからない場合はDuckErrorを発生させます。あなたはまだしなければならないと思う、とあなたが本当に適切に処理するために準備していない場合は、適切な場所に出てエラーしようとしているかどうかが、あなたはどのような種類の仮定うとしている意思を。Numpy配列は、盲目的に依存している良い例ですlen または、ブール型キャストが期待どおりに動作しない場合があります。

真理値テストに関するドキュメントから：

ここにリストされているもの以外のすべての値が考慮されます True

• None
• False
• 例えば、任意の数値型のゼロ、0、0.0、0j。
• 例えば、任意の空のシーケンス、''、()、[]。
• 空のマッピング（例：）{}。
• クラスが__bool__()or __len__()メソッドを定義している場合、そのメソッドが整数のゼロまたはブール値を返すとき、ユーザー定義クラスのインスタンスFalse。

見てわかるように、空のリスト[]は偽であるので、ブール値に対して行われることを行うことが最も効率的に聞こえます。

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

リストが空かどうかを確認する方法はいくつかあります。

a = [] #the list

1）かなり単純なpythonicの方法：

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

Pythonでは、リスト、タプル、セット、ディクショナリ、変数などの空のコンテナはと見なされFalseます。リストを述語として扱う（ブール値を返す）だけです。そして、True値はそれが空でないことを示します。

2）より明確な方法：len()長さを見つけ、それが以下と等しいかどうかを確認するためにを使用する0：

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

3）または、それを匿名の空のリストと比較します。

if a == []:
    print("a is empty")

4）もう1つの馬鹿げた方法は、exceptionand を使用することです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空と空を別々にテストすることは、2つの異なる状態であるため、時々良いことです。上記のコードは次の出力を生成します。

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

それ以外の場合は、シンプルなものを使用できます。

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

そして最強のバージョン：

if a: a.pop() 

python3以降から使用できます

a == []

リストが空かどうかを確認するには

編集：これはpython2.7でも動作します。

なぜこんなに複雑な答えがあるのか​​わかりません。それはかなり明確で簡単です

このようにbool（）を使用することもできます

    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  

リスト、タプル、辞書など、あらゆるdata_structureに使用できます。これらにより、だけで何度も呼び出すことができます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)))

もちろん、暗黙のうちに（つまり）で使用しないでください。ただし、「空でない」が関数として明示的に必要な場合は、これが最良の選択です。boolifif bool(L):bool

リストが空かどうかを確認するには、次の2つの方法を使用できます。ただし、シーケンスのタイプを明示的にチェックする方法は回避する必要があります（それは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".

2番目の方法はmore pythonic1つです。この方法は暗黙的なチェック方法であり、以前の方法よりもはるかに望ましい方法です。

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"

お役に立てれば。