Introdução à Compreensão de Lista Python
A compreensão da lista Python é outra maneira de criar listas usando uma operação de iteração. Funciona da mesma maneira que um loop, mas o LC é usado especificamente para retornar listas. As compreensões de lista têm expressões entre colchetes, como a criação de uma lista normal, a expressão será executada para todos os elementos.
A compreensão de lista é muito útil na ciência de dados, onde é possível ler listas / filtrar nomes de colunas / remover itens de listas etc. Embora possamos usar loops e funções lambda para executar alguma ação, a compreensão de lista fornece uma maneira elegante e simples de representar a mesma.
A compreensão da lista pode ser usada para substituir os métodos map (), reduzir () e filter ().
A compreensão da lista é como a Teoria dos Conjuntos das aulas do ensino médio.
Exemplo:
( x: x is a natural number greater than 15 )
( x: x is a vowel in word 'Data Science', x is a vowel )
Vamos criar uma lista de compreensão para as duas declarações acima.
(x for x in range(0, 20) if x>15) (x for x in 'Data Science' if x in ('a', 'e', 'i', 'o', 'u'))
Resultado:
(16, 17, 18, 19) ('a', 'a', 'i', 'e', 'e')A compreensão da lista é fácil de entender e implementar. Basicamente, eles são criados em tabelas. Há três coisas a serem consideradas ao escrever a sintaxe para compreensão de listas.
- Parâmetro para saída
- O iterável
- Condições
A sintaxe pode ter duas das opções acima ou três acima como uma sintaxe para a compreensão da lista.
Sintaxe:
(output parameter | The Iterable)(output Parameter | The Iterable | Condition )
Exemplos de compreensão da lista Python
Aqui discutiremos como usar a compreensão de lista usando python. Veremos os exemplos de uma maneira diferente, à medida que o executaremos usando o loop for e, em seguida, criaremos o mesmo usando a compreensão da lista.
Exemplo # 1: Encontrando os Quadrados Perfeitos
Aqui estão exemplos de quadrados perfeitos com diferentes condições, dados abaixo:
1. Com for Loop
for i in range(1, 30):
if int(i**0.5)==i**0.5:
print(i)
2. Usando Compreensões de Lista
(x for x in range(1, 30) if int(x**0.5)==x**0.5)
Resultado:
Exemplo # 2: obtenha apenas consoantes de uma sentença
Aqui, tomaremos uma sentença arbitrária e tentaremos obter consoantes na sentença como nossa saída.
1. Usando o loop For
def consonants_for(sentence):
vowels = 'aeiou'
consonants = () for x in sentence:
if x not in vowels:
consonants.append(x)
return ''.join(consonants)
sentence = 'we are studying list comprehensions'
print("With For Loop : " + consonants_for(sentence))
Resultado:
Com para loop: wr stdyng lst cmprhnsns
2. Usando a compreensão da lista
def consonants_lc(sentence):
vowels = 'aeiou'
return ''.join(( x for x in sentence if x not in vowels))
sentence = 'we are studying list comprehensions'
print("Using List Compr: " + consonants_lc(sentence))
Resultado:
Usando a lista Compr: wr stdyng lst cmprhnsns
Exemplo # 3: Criando um dicionário a partir de duas listas diferentes
Aqui estão exemplos de dicionário com diferentes condições, dados abaixo:
1. Usando o loop For
def dict_for(keys, values):
dictionary = ()
for i in range(len(keys)):
dictionary(keys(i)) = values(i) return dictionary
Movie = ('RDB', 'Wanted', 'DDLG', 'Sholay', 'War', ) Actor = ('Aamire', 'Salman', 'SRK', 'Amitabh', 'Hritik') print("FOR-loop result: " + str(dict_for(Movie, Actor)))
Resultado:
Resultado do loop FOR: ('RDB': 'Aamire', 'Wanted': 'Salman', 'DDLG': 'SRK', 'Sholay': 'Amitabh', 'War': 'Hritik')
2. Usando a compreensão da lista
def dict_lc(keys, values):
return ( keys(i) : values(i) for i in range(len(keys)) )
Movie = ('RDB', 'Wanted', 'DDLG', 'Sholay', 'War', ) Actor = ('Aamire', 'Salman', 'SRK', 'Amitabh', 'Hritik') print("LC result : " + str(dict_lc(Movie, Actor)))
Resultado:
Resultado da LC: ('RDB': 'Aamire', 'Procura-se': 'Salman', 'DDLG': 'SRK', 'Sholay': 'Amitabh', 'Guerra': 'Hritik')
Benefícios da Compreensão de Lista Python
As compreensões de lista executam a mesma tarefa, mas de uma maneira diferente!
A compreensão da lista tem muitas vantagens sobre o loop e outros métodos. Alguns dos benefícios são os seguintes:
- As compreensões de lista são fáceis de entender e tornam o código elegante. Podemos escrever o programa com expressões simples.
- As compreensões de lista são muito mais rápidas do que para loop e outros métodos, como um mapa. (O mesmo é explicado no exemplo abaixo:
Tomaremos o exemplo 1 como referência e calcularemos o tempo gasto por diferentes métodos para executar a mesma função. Primeiro, veremos o tempo gasto pelo “for loop” e, em seguida, o tempo gasto pelo método map () e, finalmente, veremos o tempo gasto pelas compreensões da lista.
Uma tabela mostra o tempo gasto pelas diferentes técnicas.
1. Para Loop
Exemplo usando o loop for fornecido abaixo:
Código:
def perf_square(x):
output = () for i in x:
if int(i**0.5)==i**0.5:
output.append(i)
return output
%timeit perf_square(range(1, 30))
2. Método do mapa
Exemplo usando o método de mapa fornecido abaixo:
Código:
def perf_square_map(x):
return map(lambda i: i**0.5==i**0.5, x)
%timeit perf_square_map(range(1, 30))
3. Compreensões da lista
Exemplo usando a compreensão da lista fornecida abaixo:
Código:
def perf_square_lc(x):
return (i**0.5 == i**0.5 for i in x) %timeit perf_square_lc(range(1, 30))
Resultado:
| Método | Tempo |
| For loop | 787 ns |
| Método Map () | 518 ns |
| Compreensões da lista | 276 ns |
O tempo de execução claramente da compreensão da lista é 2, 85 vezes mais rápido que o loop for e 1, 87 vezes mais rápido que o método map. A compreensão da lista deixa para trás outros métodos com uma grande margem. Poderia haver especulações, por que não usamos apenas LC em todos os lugares, e não loops? O LC é mais rápido na maioria dos casos e pode substituir os loops em quase 80% dos casos. Mas não podemos substituir loops, há alguns casos em que temos um bom número de condições e as classes são aninhadas em um loop. Nesses casos, o uso de LC pode ser bastante complicado e inviável também. É melhor fazer loops nessas situações. Embora se possa usar a compreensão da lista em loops para substituir outros por loops. Isso diminuirá o tempo de execução e manterá a facilidade de uso do código.
- Podemos aninhar várias condições em uma compreensão de lista.
- LC pode executar manipulação de múltiplas variáveis.
- Não há necessidade de fornecer um comando separado para obter a saída.
- A compreensão da lista reduz a complexidade do código.
- As compreensões de lista são eficientes.
Conclusão
As compreensões de lista são usadas para criar listas a partir do processo iterativo. A compreensão da lista é fácil de entender / implementar e torna o código elegante. A compreensão da lista é compacta e fácil de usar.
Discutimos a sintaxe para compreensão de lista, juntamente com alguns bons exemplos perspicazes. Por fim, escrevemos um programa para obter o tempo de cada método. Concluímos que o LC é 2, 85 vezes mais rápido que o loop for e 1, 87 vezes mais rápido que o método map ().
Artigos recomendados
Este é um guia para a compreensão da lista do Python. Aqui discutimos os benefícios da compreensão da lista python, juntamente com a sintaxe e os exemplos com diferentes condições. Você também pode consultar os seguintes artigos para saber mais:
- Construtor em Java
- Classificação em Java
- Construtor em Java
- JCheckBox em Java
- Guia de classificação em c # com exemplos
- Função de classificação em Python com exemplos
- Loops no VBScript com exemplos
- Exemplos para implementar a caixa de seleção no Bootstrap