Respostas:
if not a:
print("List is empty")
Usar a booleanidade implícita do vazio list
é bastante pitônico.
if a == []
está forçando um tipo específico ( () == []
é False
). aqui, parece haver consenso geral de que a digitação com patos vence (na verdade, dizendo que essa __nonzero__
é a interface para testar o vazio docs.python.org/reference/datamodel.html#object.__nonzero__ )
A maneira pitônica de fazer isso é no guia de estilo do PEP 8 (onde Sim significa "recomendado" e Não significa "não recomendado"):
Para seqüê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):
seq
se espera que seja algum tipo de objeto parecido com uma lista.
Eu prefiro explicitamente:
if len(li) == 0:
print('the list is empty')
Dessa forma, é 100% claro que li
é uma sequência (lista) e queremos testar seu tamanho. Meu problema if not li: ...
é que ele dá a falsa impressão de que li
é uma variável booleana.
li
é um bool e não se importará. Se for importante, você deve adicionar um comentário, não mais código.
None
ou não 0
para criar uma exceção em vez de passar). Então, quando você faz isso sem razão, que é enganosa e isso também significa que quando o código faz necessidade de fazer a distinção, a distinção é invisível porque você "lobo gritou" todo o resto da fonte.
if bool(len(li) == 0) is True:
?
Este é o primeiro hit do Google para "array vazio de teste python" e consultas semelhantes, além de outras pessoas parecerem generalizar 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 pode usar.
Você precisa ter cuidado com as matrizes NumPy, porque outros métodos que funcionam bem para list
s ou outros contêineres padrão falham nas matrizes NumPy. Eu explico o porquê abaixo, mas, resumindo, o método preferido é usar size
.
A maneira "pitônica" falha com as matrizes NumPy porque o NumPy tenta converter a matriz em uma matriz de bool
s e if x
tenta avaliar todos esses bool
s ao mesmo tempo para algum tipo de valor agregado de verdade. Mas isso não faz sentido, então você recebe 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()
Mas pelo menos o caso acima diz que ele falhou. Se você tiver uma matriz NumPy com exatamente um elemento, a if
instrução "funcionará", no sentido de que você não recebe um erro. No entanto, se esse elemento for 0
(ou 0.0
, ou False
...), a if
instrução resultará incorretamente em False
:
>>> x = numpy.array([0,])
>>> if x: print("x")
... else: print("No x")
No x
Mas x
existe claramente e não está vazio! Este resultado não é o que você queria.
len
pode gerar resultados inesperadosPor exemplo,
len( numpy.zeros((1,0)) )
retorna 1, mesmo que a matriz tenha zero elementos.
Conforme explicado nas Perguntas frequentes do SciPy , o método correto em todos os casos em que você sabe que possui uma matriz 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 fornece para garantir que o teste correto seja usado para cada tipo. Não é muito "pitônico", mas acontece que o NumPy intencionalmente quebrou 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 operações de indexação ou matemática, é provavelmente mais eficiente (e certamente mais comum) forçar a entrada a ser uma matriz NumPy. Existem algumas funções interessantes para fazer isso rapidamente - o mais importante numpy.asarray
. Isso pega sua entrada, não faz nada se já é uma matriz ou agrupa sua entrada em uma matriz se for uma lista, tupla etc., e, opcionalmente, a converte para a sua escolhida dtype
. Portanto, é muito rápido, sempre que possível, e garante que você apenas assuma que a entrada é uma matriz NumPy. Normalmente, usamos apenas o mesmo nome, pois a conversão em uma matriz não retorna ao escopo atual :
x = numpy.asarray(x, dtype=numpy.double)
Isso fará com que a x.size
verificação funcione em todos os casos que vejo nesta página.
numpy
- numpy
é uma biblioteca com um caso de uso muito específico e possui uma definição "natural" diferente do que a veracidade em uma matriz é para o Padrão Python para contêineres. Faz sentido otimizar para esse caso, da maneira que pathlib
costuma /
concatenar caminhos em vez de +
- não é padrão, mas faz sentido no contexto.
if x
quanto para os len(x)
idiomas - e às vezes essa quebra pode ser muito difícil de detectar e depurar.
Melhor maneira de verificar se uma lista está vazia
Por exemplo, se passou o seguinte:
a = []
Como verifico se um está vazio?
Coloque a lista em um contexto booleano (por exemplo, com uma instrução if
ou while
). Ele testará False
se está vazio ou True
não. Por exemplo:
if not a: # do this!
print('a is an empty list')
O PEP 8 , o guia de estilo oficial do Python para código Python na biblioteca padrão do Python, afirma:
Para seqüê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 seja o mais eficiente e correto possível. Mas por que esse é o caso e por que precisamos dessa orientação?
Frequentemente vejo código como este de programadores experientes novos no Python:
if len(a) == 0: # Don't do this!
print('a is an empty list')
E os usuários de idiomas preguiçosos podem ficar tentados a fazer isso:
if a == []: # Don't do this!
print('a is an empty list')
Eles estão corretos nos respectivos idiomas. E isso é semanticamente correto no Python.
Mas consideramos isso não-pitonico porque o Python suporta essas semânticas diretamente na interface do objeto de lista por meio de coerção booleana.
Nos 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 retorneFalse
ou um__len__()
método que retorne zero, quando chamado com o objeto. Aqui estão a maioria dos objetos internos considerados falsos:
- constantes definidas como falsas:
None
eFalse
.- zero, de qualquer tipo numérico:
0
,0.0
,0j
,Decimal(0)
,Fraction(0, 1)
- sequências de vazios e colecções:
''
,()
,[]
,{}
,set()
,range(0)
E a documentação do modelo de dados:
Chamado para implementar testes de valor de verdade e a operação interna
bool()
; deve retornarFalse
ouTrue
. Quando esse método não é definido,__len__()
é chamado, se definido, e o objeto é considerado verdadeiro se o resultado for diferente de zero. Se uma classe não define nem__len__()
nem__bool__()
, todas as suas instâncias são consideradas verdadeiras.
e
Chamado para implementar a função interna
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__()
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')
Faça isso:
if not a:
print('a is an empty list')
Vale a pena? (Observe que menos tempo para executar 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 escala, eis o custo de chamar a função e construir e retornar uma lista vazia, que você pode subtrair dos custos das verificações de vazio usadas acima:
>>> min(timeit.repeat(lambda: [], repeat=100))
0.07074015751817342
Vemos que a verificação do comprimento com a função interna len
comparada 0
ou a verificação de uma lista vazia tem muito menos desempenho do que o uso da sintaxe interna do idioma, conforme documentado.
Por quê?
Para a len(a) == 0
verificação:
Primeiro, o Python precisa verificar as globais para ver se len
está sombreado.
Em seguida, ele deve chamar a função, carregar 0
e fazer a comparação de igualdade no Python (em vez de com 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 [] == []
isso ele precisa criar uma lista desnecessária e, novamente, fazer a operação de comparação na máquina virtual do Python (ao contrário de 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
Esta é uma extensão
PyObject
que adiciona oob_size
campo. Isso é usado apenas para objetos que tenham alguma noção de comprimento. Esse tipo geralmente não aparece na API Python / C. Corresponde aos campos definidos pela expansão daPyObject_VAR_HEAD
macro.
Na fonte c em 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
Gostaria de salientar que isso também é verdade para o caso não vazio embora o seu muito feio como com
l=[]
em seguida,%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. Mas não há como alguém gostar,not not l
apesar do triplo da velocidade. Parece ridículo. Mas a velocidade vence,
suponho que o problema esteja sendo testado com o tempo, uma vez que apenasif l:
é suficiente, mas surpreendentemente%timeit bool(l)
gera 101 ns ± 2,64 ns. Interessante não há como coagir a bool sem essa penalidade.%timeit l
é inútil, pois nenhuma conversão ocorreria.
A magia do IPython,, %timeit
não é totalmente inútil aqui:
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)
Podemos ver que há um pouco de custo linear para cada adicional not
aqui. Queremos ver os custos, ceteris paribus , ou seja, tudo o mais igual - onde tudo o mais é minimizado na medida do possível:
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)
Agora vamos ver o caso de uma lista de desempregados:
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)
O que podemos ver aqui é que faz pouca diferença se você passa em um bool
para a condição ou a própria lista e, se houver, fornecer a lista, como é, é mais rápido.
Python é escrito em C; ele usa sua lógica no nível C. Tudo o que você escreve em Python será mais lento. E provavelmente haverá ordens de magnitude mais lentas, a menos que você esteja usando os mecanismos embutidos no Python diretamente.
l=[]
em seguida, %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. Mas não há como alguém gostar, not not l
apesar do triplo da velocidade. Parece ridículo. Mas a velocidade vence
if l:
é suficiente, mas surpreendentemente %timeit bool(l)
gera 101 ns ± 2,64 ns. Interessante não há como coagir a bool sem essa penalidade. %timeit l
é inútil, pois nenhuma conversão ocorreria.
Uma lista vazia é considerada falsa no teste de valor verdadeiro (consulte a documentação do python ):
a = []
if a:
print "not empty"
@Daren Thomas
EDIT: Outro ponto contra testar a lista vazia como False: E o polimorfismo? Você não deve depender de uma lista ser uma lista. Ele deveria grasnar como um pato - como você fará sua coleção de pato gritar '' False '' quando não possui elementos?
Sua duckCollection deve implementar __nonzero__
ou __len__
então o if a: funcionará sem problemas.
[] == False
irá avaliar a embora Falso
bool()
. bool([]) == False
será avaliado True
conforme o esperado.
A resposta (aceita) de Patrick está certa: if not a:
é o caminho certo para fazê-lo. A resposta de Harley Holcombe está certa de que isso está no guia de estilo do PEP 8. Mas o que nenhuma das respostas explica é por que é uma boa idéia seguir o idioma - mesmo se você achar pessoalmente que não é explícito o suficiente ou confuso para os usuários do Ruby ou o que seja.
O código Python e a comunidade Python têm expressões muito fortes. Seguir essas expressões facilita a leitura do código para qualquer pessoa com experiência em Python. E quando você viola esses idiomas, esse é um sinal forte.
É verdade que if not a:
não distingue listas vazias de None
, ou 0 numéricas, tuplas vazias, tipos de coleções criadas pelo usuário ou tipos de coleções que não são completamente vazias criadas pelo usuário ou matriz NumPy de elemento único que atua como escalares com falsey valores, etc. E, às vezes, é importante ser explícito sobre isso. E, nesse caso, você sabe sobre o que deseja ser explícito, para poder testar exatamente isso. Por exemplo, if not a and a is not None:
significa "qualquer coisa falsa, exceto Nenhuma", 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 a ser explícito, algo além de if not a:
engana o leitor. Você está sinalizando algo tão importante quando não é. (Você também pode ser tornar o código menos flexível, ou mais lento, ou o que quer, mas isso é tudo menos importante.) E se você habitualmente enganar o leitor como este, então, quando você fazer necessidade de fazer uma distinção, que vai passar porque despercebida você esteve "chorando lobo" em todo o seu código.
Parece que ninguém resolveu questionar sua necessidade de testar a lista em primeiro lugar. Como você não forneceu nenhum contexto adicional, posso imaginar que você talvez não precise fazer essa verificação em primeiro lugar, mas não está familiarizado com o processamento de lista no Python.
Eu diria que a maneira mais pitônica é não checar, mas apenas processar a lista. Dessa forma, ele fará a coisa certa, vazia ou cheia.
a = []
for item in a:
<do something with item>
<rest of code>
Isso tem o benefício de manipular qualquer conteúdo de a , embora não exija uma verificação específica quanto ao vazio. Se a estiver vazio, o bloco dependente não será executado e o intérprete passará para a próxima linha.
Se você realmente precisa verificar o vazio da matriz, as outras respostas são suficientes.
<rest of code>
que possa usar o resultado do for
loop? Ou use diretamente alguns valores em a
? De fato, se o script for projetado para executar com entrada estritamente controlada, a verificação poderá ser um pouco desnecessária. Mas, na maioria dos casos, a entrada varia e a verificação geralmente é melhor.
len()
é uma operação O (1) para listas, seqüências de caracteres, dictos e conjuntos de Python. O Python controla 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 com -1. Não tenho certeza se isso ocorre porque os leitores se opuseram à estratégia ou pensaram que a resposta não foi útil como apresentada. Vou fingir que foi o último, já que - o que quer que seja considerado "pitô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ê pode usar algo como isto:
if isinstance(a, numpy.ndarray) and not a.size:
do_stuff
elif isinstance(a, collections.Sized) and not a:
do_stuff
o primeiro teste é em 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ê deseja aceitar apenas instâncias de tipos específicos (e seus subtipos) ou com:
elif isinstance(a, (list, tuple)) and not len(a):
Você pode fugir sem a verificação explícita de tipo, mas apenas se o contexto circundante já garantir que você a
é um valor dos tipos que você está preparado para lidar ou se tiver certeza de que os tipos que você não está preparado para lidar estão indo para gerar erros (por exemplo, a TypeError
se você chamar len
um valor cujo valor não está definido) com o qual está preparado para lidar. Em geral, as convenções "pitônicas" parecem seguir este último caminho. Aperte-o como um pato e deixe-o criar um DuckError se não souber grasnar. No entanto, você ainda precisa pensar em quais suposições de tipo está fazendo e se os casos que você não está preparado para lidar adequadamente realmente vão errar nos lugares certos. As matrizes Numpy são um bom exemplo em que apenas confiar cegamente emlen
ou o tipo de letra booleano pode não fazer exatamente o que você espera.
collections.abc.Sized
or collections.abc.Sequence
, mas pode ser aquele em que você escreve a si mesmo register(list)
. Se você realmente possui um código em que é importante distinguir vazio de outro falsey e também para distinguir listas e tuplas de qualquer outra sequência, isso está correto - mas não acredito que você tenha esse código.
[]
e não algo falso de outro tipo, certamente if a == []:
é necessário, em vez de mexer com a instância.
==
entanto, existem algumas coerções automáticas . Do alto da minha cabeça, não consigo identificar []
. [] == ()
por exemplo, retorna False
. Mas, por exemplo, frozenset()==set()
retorna True
. Portanto, vale pelo menos pensar um pouco sobre se algum tipo indesejado pode ser coagido []
(ou vice-versa) ao fazê-lo a == []
.
Da documentação sobre teste de valor de verdade:
Todos os valores diferentes dos listados aqui são considerados True
None
False
0
, 0.0
, 0j
.''
, ()
, []
.{}
.__bool__()
ou __len__()
método, quando este método retorna o valor inteiro zero ou booleano False
.Como pode ser visto, a lista vazia []
é falsa ; portanto, fazer o que seria feito com um valor booleano parece mais eficiente:
if not a:
print('"a" is empty!')
assert(not myList)
. Se você também deseja afirmar que o objeto é a list
, pode usar assertIsInstance()
.
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")
No Python, contêineres vazios , como listas, tuplas, conjuntos, dictos, variáveis etc. são vistos como False
. Pode-se simplesmente tratar a lista como um predicado ( retornando um valor booleano ). E um True
valor indicaria que não está vazio.
2) Uma maneira muito explícita: usar o len()
para encontrar o comprimento e verificar se é igual a 0
:
if len(a) == 0:
print("a is empty")
3) Ou comparando-o a uma lista vazia anônima:
if a == []:
print("a is empty")
4) Outra maneira ainda boba 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."
if not a:
e quebra mais facilmente. Por favor, não faça isso.
() == []
também é igual a false. Embora eu goste de como essa implementação lê if not a:
todos os casos, se você definitivamente espera uma lista, seu exemplo deve ser suficiente.
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 verificar o vazio separadamente, pois esses 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 que None
seja falso. Portanto, se você não deseja separar o teste para None
-ness, 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 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 uma lista vazia, pode fazer o seguinte:
if isinstance(a, list) and len(a)==0:
print("Received an empty list")
a
não for uma lista e a
não tiver um método __len__
implementado. Eu recomendaria:if isinstance(obj, list): if len(obj) == 0: print '...'
and
é preguiçoso no Python. Nada depois and
será executado se a condição anterior and
for False.
nós poderíamos usar um simples se mais:
item_list=[]
if len(item_list) == 0:
print("list is empty")
else:
print("list is not empty")
Se você deseja verificar se uma lista está vazia:
l = []
if l:
# do your stuff.
Se você deseja verificar se todos os valores na lista estão vazios. No entanto, será True
para uma lista vazia:
l = ["", False, 0, '', [], {}, ()]
if all(bool(x) for x in l):
# do your stuff.
Se você deseja usar os dois casos juntos:
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.
Sendo inspirado pela solução do @ 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)
Nota: uma sequência é considerada iterável. - adicione 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
if a:
, seria porque eu queria uma exceção se a
não fosse algum tipo de contêiner. (Sendo um iteráveis também permite iterators, que não pode ser utilmente testados para vazio.)
print('not empty' if a else 'empty')
um pouco mais prático:
a.pop() if a else None
e versão shertest:
if a: a.pop()
A partir do python3, você pode usar
a == []
para verificar se a lista está vazia
EDIT: Isso funciona com python2.7 também ..
Não sei por que existem tantas respostas complicadas. É bem claro e direto
a
está vazia ou não.
pythonic
a==[]
, imprimirá true no terminal python se a estiver vazio. Caso contrário, ele imprimirá Falso. Você pode usar isso dentro de uma condição if também comoif(a==[])
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
Eu amo esse caminho para a lista de verificação está vazia ou não.
Muito útil e útil.
bool()
converte uma variável Python em um booleano para que você possa armazenar a veracidade ou falsidade de um valor sem precisar usar uma declaração if. Eu acho que é menos legível do que simplesmente usar uma condicional como a resposta aceita, mas tenho certeza que existem outros bons casos de uso para ela.
Simplesmente use is_empty () ou faça a 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
Pode ser usado para qualquer estrutura de dados como uma lista, tuplas, dicionário e muito mais. Por estes, você pode chamá-lo muitas vezes usando apenas is_empty(any_structure)
.
is_empty
sugere que ele retorne algo. Mas, se o fizesse, isso seria algo bool(any_structure)
que você deveria usar ( quando precisar de um bool
).
bool
disso (também) imprime mensagens na saída padrão?
bool
variável de retorno . A escolha é sua. Eu escrevo os dois para que você possa escolher entre eles.
Maneira simples é verificar o comprimento é igual a zero.
if len(a) == 0:
print("a is empty")
O valor verdadeiro de uma lista vazia é o de uma lista False
não vazia True
.
O que me trouxe aqui é um caso de uso especial: eu realmente queria que uma função me dissesse 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)))
Obviamente, não use 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 uma função, bool
é a melhor opção.
Para verificar se uma lista está vazia ou não, você pode usar as duas maneiras a seguir. Mas lembre-se, devemos evitar a maneira de verificar explicitamente um tipo de sequência (é uma
less pythonic
maneira):
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".
O segundo caminho é
more pythonic
esse. Este método é uma maneira implícita de verificação e muito mais preferível que a anterior.
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"
Espero que isto ajude.