Como posso verificar se uma lista está vazia?
https://stackoverflow.com/questions/53513
italiano
english
français
española
中国
日本の
العربية
Deutsch
한국어
Português
RussianPergunta
Por exemplo, se for aprovado o seguinte:
a = []
Como faço para verificar se a está vazia?
Solução
if not a:
print("List is empty")
Usando a booleanidade implícita do vazio list é bastante pitônico.
Outras dicas
A maneira pitônica de fazer isso é a partir do Guia de estilo PEP 8 (onde Sim significa “recomendado” e Não significa “não recomendado”):
Para sequências (strings, listas, tuplas), use o fato de que sequências vazias são falsas.
Sim: if not seq: if seq: Não: if len(seq): if not len(seq):
Eu prefiro explicitamente:
if len(li) == 0:
print('the list is empty')
Dessa forma fica 100% claro que li é uma sequência (lista) e queremos testar seu tamanho.Meu problema com if not li: ... é que dá a falsa impressão de que li é uma variável booleana.
Outras pessoas parecem estar generalizando a questão além de apenas listas, então pensei em adicionar uma advertência para um tipo diferente de sequência que muitas pessoas podem usar, especialmente porque este é o primeiro hit do Google para "python test array vazio" .
Outros métodos não funcionam para matrizes NumPy
Você precisa ter cuidado com arrays NumPy, porque outros métodos que funcionam bem para lists ou outros contêineres padrão falham em matrizes NumPy.Explico o porquê abaixo, mas resumindo, o método preferido é usar size.
A maneira "pythônica" não funciona:Parte 1
A maneira "pythônica" falha com arrays NumPy porque NumPy tenta converter o array em um array de boolareia if x tenta avaliar todos aqueles boolé imediatamente algum tipo de valor de verdade agregado.Mas isso não faz nenhum sentido, então você recebe um 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()
A maneira "pythônica" não funciona:Parte 2
Mas pelo menos o caso acima indica que falhou.Se acontecer de você ter um array NumPy com exatamente um elemento, o if instrução "funcionará", no sentido de que você não receberá um erro.No entanto, se esse elemento for 0 (ou 0.0, ou False, ...), o if declaração resultará incorretamente em False:
>>> x = numpy.array([0,])
>>> if x: print("x")
... else: print("No x")
No x
Mas claramente x existe e não está vazio!Este resultado não é o que você queria.
Usando len pode dar resultados inesperados
Por exemplo,
len( numpy.zeros((1,0)) )
retorna 1, mesmo que a matriz tenha zero elementos.
A maneira numpythônica
Como explicado no Perguntas frequentes sobre o SciPy, o método correto em todos os casos em que você sabe que possui um array NumPy é usar 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
Se você não tem certeza se pode ser um list, um array NumPy ou qualquer outra coisa, você pode combinar essa abordagem com a resposta que @dubiousjim dá para garantir que o teste correto seja usado para cada tipo.Não é muito "pitônico", mas acontece que o NumPy quebrou intencionalmente a pitonicidade pelo menos nesse sentido.
Se você precisar fazer mais do que apenas verificar se a entrada está vazia e estiver usando outros recursos do NumPy, como indexação ou operações matemáticas, provavelmente será mais eficiente (e certamente mais comum) forçar a entrada ser uma matriz NumPy.Existem algumas funções interessantes para fazer isso rapidamente — a mais importante numpy.asarray.Isso pega sua entrada, não faz nada se já for um array ou agrupa sua entrada em um array se for uma lista, tupla, etc., e opcionalmente converte-a para o seu escolhido dtype.Portanto, é muito rápido sempre que possível e garante que você apenas presuma que a entrada é uma matriz NumPy.Geralmente usamos apenas o mesmo nome, já que a conversão para um array não retornará para fora do atual escopo:
x = numpy.asarray(x, dtype=numpy.double)
Isto fará com que x.size verifique o trabalho em todos os casos que vejo nesta página.
Melhor maneira de verificar se uma lista está vazia
Por exemplo, se for aprovado o seguinte:
a = []Como posso verificar se a está vazio?
Resposta curta:
Coloque a lista em um contexto booleano (por exemplo, com um if ou while declaração).Ele irá testar False se estiver vazio e True de outra forma.Por exemplo:
if not a: # do this!
print('a is an empty list')
Apelo à Autoridade
PEP 8, o guia de estilo oficial do Python para código Python na biblioteca padrão do Python, afirma:
Para sequências (strings, listas, tuplas), use o fato de que sequências vazias são falsas.
Yes: if not seq: if seq: No: if len(seq): if not len(seq):
Devemos esperar que o código da biblioteca padrão tenha o melhor desempenho e seja o mais correto possível.Mas por que isso acontece e por que precisamos dessa orientação?
Explicação
Freqüentemente vejo códigos como este de programadores experientes, novos em Python:
if len(a) == 0: # Don't do this!
print('a is an empty list')
E os usuários de linguagens preguiçosas podem ficar tentados a fazer isso:
if a == []: # Don't do this!
print('a is an empty list')
Eles estão corretos em seus respectivos outros idiomas.E isso é até semanticamente correto em Python.
Mas consideramos isso não-Pythônico porque o Python suporta essa semântica diretamente na interface do objeto de lista por meio de coerção booleana.
De documentos (e observe especificamente a inclusão da lista vazia, []):
Por padrão, um objeto é considerado verdadeiro, a menos que sua classe defina um
__bool__()método que retornaFalseou um__len__()Método que retorna zero, quando chamado com o objeto.Aqui estão a maioria dos objetos integrados considerados falsos:
- constantes definidas como falsas:
NoneeFalse.- zero de qualquer tipo numérico:
0,0.0,0j,Decimal(0),Fraction(0, 1)- sequências e coleções vazias:
'',(),[],{},set(),range(0)
E a documentação do modelo de dados:
Chamado para implementar testes de valor de verdade e a operação integrada
bool();deveria retornarFalseouTrue.Quando este método não está definido,__len__()é chamado, se estiver definido, e o objeto é considerado verdadeiro se seu resultado for diferente de zero.Se uma classe não define nenhum dos dois__len__()nem__bool__(), todas as suas instâncias são consideradas verdadeiras.
e
Chamado para implementar a função integrada
len().Deve retornar o comprimento do objeto, um número inteiro >= 0.Além disso, um objeto que não define um__bool__()método e cujo__len__()o método retorna zero é considerado falso em um contexto booleano.
Então, em vez disso:
if len(a) == 0: # Don't do this!
print('a is an empty list')
ou isto:
if a == []: # Don't do this!
print('a is an empty list')
Fazem isto:
if not a:
print('a is an empty list')
Fazer o que é Pythonic geralmente compensa em desempenho:
Isso compensa?(Observe que menos tempo para realizar uma operação equivalente é melhor :)
>>> 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
Para escalar, aqui está o custo de chamar a função e construir e retornar uma lista vazia, que você pode subtrair dos custos das verificações de vazios usadas acima:
>>> min(timeit.repeat(lambda: [], repeat=100))
0.07074015751817342
Nós vemos que qualquer verificando o comprimento com a função interna len comparado com 0 ou verificar em uma lista vazia é muito menos desempenho do que usar a sintaxe interna da linguagem conforme documentado.
Por que?
Para o len(a) == 0 verificar:
Primeiro Python precisa verificar os globais para ver se len está sombreado.
Então ele deve chamar a função, carregar 0, e faça a comparação de igualdade em Python (em vez de 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
E para o [] == [] ele tem que construir uma lista desnecessária e então, novamente, fazer a operação de comparação na máquina virtual do Python (em oposição a C)
>>> dis.dis(lambda: [] == [])
1 0 BUILD_LIST 0
2 BUILD_LIST 0
4 COMPARE_OP 2 (==)
6 RETURN_VALUE
A maneira "Pythonic" é uma verificação muito mais simples e rápida, pois o comprimento da lista é armazenado em cache no cabeçalho da instância do objeto:
>>> dis.dis(lambda: not [])
1 0 BUILD_LIST 0
2 UNARY_NOT
4 RETURN_VALUE
Evidências da fonte C e documentação
Esta é uma extensão de
PyObjectque adiciona oob_sizecampo.Isso é usado apenas para objetos que possuem alguma noção de comprimento.Esse tipo não aparece com frequência na API Python/C.Corresponde aos campos definidos pela expansão doPyObject_VAR_HEADmacro.
Da fonte c em Incluir/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
Gostei de pesquisar isso e passo muito tempo selecionando minhas respostas.Se você acha que estou deixando algo de fora, por favor me avise em um comentário.
Uma lista vazia é considerada falsa em testes de valor verdadeiro (veja documentação python):
a = []
if a:
print "not empty"
@Daren Thomas
EDITAR:Outro ponto contra testar a lista vazia como falsa:E quanto ao polimorfismo?Você não deve depender de uma lista de ser uma lista.Deveria apenas gritar como um pato - como você vai fazer com que sua coleta de pato quisesse '' falsa '' quando não tem elementos?
Seu duckCollection deve implementar __nonzero__ ou __len__ então se um:funcionará sem problemas.
Resposta (aceita) de Patrick está certo: if not a: é a maneira certa de fazer isso. A resposta de Harley Holcombe está certo que isso está no guia de estilo PEP 8.Mas o que nenhuma das respostas explica é por que é uma boa ideia seguir o idioma - mesmo que você pessoalmente ache que não é explícito o suficiente ou confuso para usuários de Ruby ou algo assim.
O código Python e a comunidade Python possuem expressões idiomáticas muito fortes.Seguir essas expressões torna seu código mais fácil de ler para qualquer pessoa com experiência em Python.E quando você viola essas expressões, é um sinal forte.
É verdade que if not a: não distingue listas vazias de None, ou numérico 0, ou tuplas vazias, ou tipos de coleção vazios criados pelo usuário, ou tipos vazios de coleção não exatamente criados pelo usuário, ou matriz NumPy de elemento único agindo como escalares com valores falsey, etc.E às vezes é importante ser explícito sobre isso.E nesse caso, você sabe o que você deseja ser explícito, para poder testar exatamente isso.Por exemplo, if not a and a is not None: significa "qualquer coisa falsa, exceto Nenhum", enquanto if len(a) != 0: significa "apenas sequências vazias - e qualquer coisa além de uma sequência é um erro aqui" e assim por diante.Além de testar exatamente o que você deseja testar, isso também sinaliza ao leitor que esse teste é importante.
Mas quando você não tem nada para ser explícito, qualquer coisa além de if not a: está enganando o leitor.Você está sinalizando algo tão importante quando não é.(Você também pode tornar o código menos flexível, ou mais lento, ou algo assim, mas isso é menos importante.) E se você habitualmente enganar o leitor assim, então quando você fazer precisa fazer uma distinção, isso vai passar despercebido porque você está "chorando lobo" em todo o seu código.
Por que verificar?
Ninguém parece ter questionado seu precisar para testar a lista em primeiro lugar.Como você não forneceu nenhum contexto adicional, posso imaginar que talvez você não precise fazer essa verificação em primeiro lugar, mas não está familiarizado com o processamento de listas em Python.
Eu diria que o mais pitônico A maneira é não verificar nada, mas apenas processar a lista.Dessa forma, ele fará a coisa certa, esteja vazio ou cheio.
a = []
for item in a:
<do something with item>
<rest of code>
Isto tem a vantagem de lidar com qualquer conteúdo de a, embora não exija uma verificação específica de vazio.Se a estiver vazio, o bloco dependente não será executado e o interpretador passará para a próxima linha.
Se você realmente precisar verificar se há vazio na matriz, as outras respostas serão suficientes.
len() é uma operação O(1) para listas, strings, dictos e conjuntos do Python.Python monitora internamente o número de elementos nesses contêineres.
JavaScript tem uma noção semelhante de verdade/falsidade.
Eu tinha escrito:
if isinstance(a, (list, some, other, types, i, accept)) and not a:
do_stuff
que foi votado -1.Não tenho certeza se isso ocorre porque os leitores se opuseram à estratégia ou pensaram que a resposta não era útil conforme apresentada.Vou fingir que foi o último, já que – tudo o que é considerado “pythônico” – esta é a estratégia correta.A menos que você já tenha descartado ou esteja preparado para lidar com casos em que a é, por exemplo, False, você precisa de um teste mais restritivo do que apenas if not a:.Você poderia usar algo assim:
if isinstance(a, numpy.ndarray) and not a.size:
do_stuff
elif isinstance(a, collections.Sized) and not a:
do_stuff
o primeiro teste é uma resposta à resposta de @Mike acima.A terceira linha também pode ser substituída por:
elif isinstance(a, (list, tuple)) and not a:
se você quiser aceitar apenas instâncias de tipos específicos (e seus subtipos) ou com:
elif isinstance(a, (list, tuple)) and not len(a):
Você pode escapar sem a verificação explícita de tipo, mas somente se o contexto circundante já garantir que a é um valor dos tipos com os quais você está preparado para lidar ou se tiver certeza de que os tipos com os quais não está preparado para lidar irão gerar erros (por exemplo, um TypeError se você ligar len em um valor para o qual é indefinido) que você está preparado para lidar.Em geral, as convenções “pitônicas” parecem seguir este último caminho.Aperte-o como um pato e deixe-o gerar um DuckError se ele não souber grasnar.Você ainda tem que pensar sobre que tipo de suposições você está fazendo e se os casos que você não está preparado para lidar adequadamente realmente cometerão erros nos lugares certos.Os arrays Numpy são um bom exemplo de onde confiar cegamente em len ou o typecast booleano pode não fazer exatamente o que você espera.
De documentação no teste do valor de verdade:
Todos os valores diferentes dos listados aqui são considerados True
NoneFalse- zero de qualquer tipo numérico, por exemplo,
0,0.0,0j. - qualquer sequência vazia, por exemplo,
'',(),[]. - qualquer mapeamento vazio, por exemplo,
{}. - instâncias de classes definidas pelo usuário, se a classe definir um
__bool__()ou__len__()método, quando esse método retorna o número inteiro zero ou valor boolFalse.
Como pode ser visto, lista vazia [] é falso, então fazer o que seria feito com um valor booleano parece mais eficiente:
if not a:
print('"a" is empty!')
Aqui estão algumas maneiras de verificar se uma lista está vazia:
a = [] #the list
1) A maneira pitônica bastante simples:
if not a:
print("a is empty")
Em Python, recipientes vazios como listas, tuplas, conjuntos, dictos, variáveis etc. são vistos como False.Poderíamos simplesmente tratar a lista como um predicado (retornando um valor booleano).E um True valor indicaria que não está vazio.
2) Uma forma muito explícita:usando o len() para encontrar o comprimento e verificar se é igual a 0:
if len(a) == 0:
print("a is empty")
3) Ou comparando-o com uma lista vazia anônima:
if a == []:
print("a is empty")
4) Outro ainda bobagem maneira de fazer é usar exception e iter():
try:
next(iter(a))
# list has elements
except StopIteration:
print("Error: a is empty")
Eu prefiro o seguinte:
if a == []:
print "The list is empty."
Método 1 (preferencial):
if not a :
print ("Empty")
Método 2:
if len(a) == 0 :
print( "Empty" )
Método 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])
Às vezes é bom testar None e para o vazio separadamente, pois são dois estados diferentes.O código acima produz a seguinte saída:
list is None
list is empty
list has 3 elements
Embora não valha nada isso None é falso.Então, se você não quiser separar o teste para None-ness, você não precisa fazer isso.
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])
produz esperado
list is empty
list is empty
list has 3 elements
Muitas respostas foram dadas e muitas delas são muito boas.Eu só queria acrescentar que o cheque
not a
também passará por None e outros tipos de estruturas vazias.Se você realmente deseja verificar se há uma lista vazia, você pode fazer o seguinte:
if isinstance(a, list) and len(a)==0:
print("Received an empty list")
Inspirado na solução de @dubiousjim, proponho usar uma verificação geral adicional para saber se é algo iterável
import collections
def is_empty(a):
return not a and isinstance(a, collections.Iterable)
Observação:uma string é considerada iterável.- adicionar and not isinstance(a,(str,unicode)) se você deseja que a string vazia seja excluída
Teste:
>>> 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
Você pode até tentar usar bool() assim
a = [1,2,3];
print bool(a); # it will return True
a = [];
print bool(a); # it will return False
Adoro esse jeito de verificar se a lista está vazia ou não.
Muito prático e útil.
A maneira simples é verificar se o comprimento é igual a zero.
if len(a) == 0:
print("a is empty")
print('not empty' if a else 'empty')
um pouco mais prático:
a.pop() if a else None
Do python3 em diante você pode usar
a == []
para verificar se a lista está vazia
EDITAR:Isso funciona com python2.7 também.
Não sei por que existem tantas respostas complicadas.É bem claro e direto
poderíamos usar um simples if else:
list=[]
if len(list)==0:
print ("list is empty")
else:
print ("list is not empty")
Simplesmente use is_empty() ou faça uma função como: –
def is_empty(any_structure):
if any_structure:
print('Structure is not empty.')
return True
else:
print('Structure is empty.')
return False
Ele pode ser usado para qualquer estrutura de dados, como lista, tuplas, dicionário e muito mais.Por meio deles, você pode chamá-lo várias vezes usando apenas is_empty(any_structure).
Para verificar se uma lista está vazia ou não, você pode usar as duas maneiras a seguir.Mas lembre-se, devemos evitar a verificação explícita de uma sequência ou lista (é uma
less pythoniccaminho):
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".
A segunda maneira é uma
more pythonicum.Este método é uma forma implícita de verificação e muito mais preferível que o anterior.
def Enquiry(list1):
if not list1:
return 1
else:
return 0
# ––––––––––––––––––––––––––––––––
list1 = []
if Enquiry(list1):
print ("The list is Empty")
else:
print ("The list isn't empty")
# Result: "The list is Empty"
Espero que isto ajude.
Verifique se: len(list) == 0 retorna: True
Se você quiser verificar se a lista está vazia;
l = []
if l:
# do your stuff.
Se você quiser verificar o clima, todos os valores da lista estarão vazios.
l = ["", False, 0, '', [], {}, ()]
if all(bool(x) for x in l):
# do your stuff.
No entanto, isso será verdadeiro para uma lista vazia.
def empty_list(lst):
if len(lst) ==0:
return false
else:
return all(bool(x) for x in l)
Agora você pode usar:
if empty_list(lst):
# do your stuff.
O valor verdade de uma lista vazia é False enquanto que para uma lista não vazia é True.
O que me trouxe aqui é um caso de uso especial:Na verdade eu queria um função para me dizer se uma lista está vazia ou não.Eu queria evitar escrever minha própria função ou usar uma expressão lambda aqui (porque parecia que deveria ser bastante simples):
foo = itertools.takewhile(is_not_empty, (f(x) for x in itertools.count(1)))
E, claro, existe uma maneira muito natural de fazer isso:
foo = itertools.takewhile(bool, (f(x) for x in itertools.count(1)))
Claro, faça não usar bool em if (ou seja, if bool(L):) porque está implícito.Mas, para os casos em que "não está vazio" é explicitamente necessário como função, bool é a melhor escolha.
Uma maneira boba de usar pop e try except cláusula (não recomendada):
a = []
try:
a.pop()
print('list isn\'t empty')
except:
print('list is empty')
Saída:
list is empty
Uma abordagem não oficial:
a = []
try:
print(a[-1])
except IndexError:
print("List is empty")
