🎁Compreensão de Listas (List Comprehension)

Doe, ajude a continuar criando conteúdo

A compreensão de listas (ou list comprehension, em inglês) é uma poderosa ferramenta em Python que permite criar novas listas de forma concisa e eficiente. Com essa técnica, é possível gerar listas a partir de sequências já existentes aplicando operações e condições, tudo em uma única linha de código. Esse recurso torna o código mais legível e reduz a necessidade de loops explícitos, como o for.

Neste capítulo, vamos explorar o conceito de compreensão de listas, sua sintaxe e exemplos práticos que ilustram seu uso no dia a dia da programação.

Sintaxe Básica

A sintaxe básica da compreensão de listas segue a seguinte estrutura:

[nova_expressao for item in sequencia]

Onde:

• nova_expressão é o valor ou operação que será aplicada a cada item da sequência original.

• item é o elemento atual da sequência.

• sequência pode ser qualquer estrutura iterável, como uma lista, tupla, string ou range.

Vamos ver um exemplo simples:

# Exemplo 1: Quadrado de números de 0 a 9
quadrados = [x**2 for x in range(10)]
print(quadrados)

Saída:

[0, 1, 4, 9, 16, 25, 36, 49, 64, 81]

Neste exemplo, o valor de x**2 é calculado para cada x na sequência range(10) e armazenado na lista quadrados.

Compreensão de Listas com Condicionais

É possível adicionar uma condição na compreensão de listas usando uma cláusula if, permitindo filtrar quais elementos da sequência serão processados. A sintaxe é a seguinte:

[nova_expressao for item in sequencia if condicao]

Exemplo:

# Exemplo 2: Números pares de 0 a 9
pares = [x for x in range(10) if x % 2 == 0]
print(pares)

Saída:

[0, 2, 4, 6, 8]

Neste caso, a condição if x % 2 == 0 filtra apenas os números pares da sequência, e esses valores são incluídos na lista resultante.

Compreensão de Listas com else

Se quisermos aplicar uma operação diferente para os elementos que não satisfazem uma condição, podemos usar um operador ternário dentro da compreensão de listas:

[nova_expressao if condicao else outra_expressao for item in sequencia]

Exemplo:

# Exemplo 3: Se for par, manter o número, se for ímpar, multiplicar por 2
resultado = [x if x % 2 == 0 else x * 2 for x in range(10)]
print(resultado)

Saída:

[0, 2, 2, 6, 4, 10, 6, 14, 8, 18]

Aqui, o número x é mantido se for par, e multiplicado por 2 se for ímpar.

Compreensão de Listas com Múltiplos for

Também é possível aninhar múltiplos loops for dentro de uma compreensão de listas, o que equivale a usar laços de repetição aninhados em código tradicional. A sintaxe é:

[nova_expressao for item1 in sequencia1 for item2 in sequencia2]

Exemplo:

# Exemplo 4: Produto cartesiano entre duas listas
produto_cartesiano = [(x, y) for x in [1, 2, 3] for y in ['a', 'b', 'c']]
print(produto_cartesiano)

Saída:

[(1, 'a'), (1, 'b'), (1, 'c'), (2, 'a'), (2, 'b'), (2, 'c'), (3, 'a'), (3, 'b'), (3, 'c')]

Esse exemplo gera o produto cartesiano entre os elementos das duas listas, criando pares (x, y).

Comparação entre Compreensão de Listas e Laços Tradicionais

A principal vantagem da compreensão de listas é a sua concisão. Considere o seguinte exemplo com um loop tradicional:

# Exemplo 5: Usando um loop for tradicional
quadrados = []
for x in range(10):
    quadrados.append(x**2)
print(quadrados)

Embora esse código funcione, ele requer mais linhas e a criação explícita de uma lista vazia. Comparado ao uso de compreensão de listas:

# Usando compreensão de listas
quadrados = [x**2 for x in range(10)]
print(quadrados)

A compreensão de listas é mais direta e requer menos código.

Performance

A compreensão de listas não é apenas mais concisa, mas também pode ser mais rápida em termos de desempenho, já que o processo de criar e preencher a lista acontece de maneira otimizada internamente.

Exemplo de comparação de performance usando a biblioteca timeit:

import timeit

# Função com loop tradicional
def loop_tradicional():
    resultado = []
    for x in range(1000):
        resultado.append(x**2)
    return resultado

# Função com compreensão de listas
def list_comprehension():
    return [x**2 for x in range(1000)]

# Medindo o tempo de execução
print(timeit.timeit(loop_tradicional, number=1000))  # Exemplo de tempo com loop
print(timeit.timeit(list_comprehension, number=1000))  # Exemplo de tempo com compreensão de listas

Em muitos casos, a compreensão de listas será mais eficiente.

Outros Usos de Compreensão

Além de listas, a mesma sintaxe de compreensão pode ser aplicada a outros tipos de coleções, como sets e dicionários.

1. Compreensão de sets:

# Exemplo 6: Criando um set com números ao quadrado
quadrados_set = {x**2 for x in range(10)}
print(quadrados_set)

2. Compreensão de dicionários:

# Exemplo 7: Criando um dicionário com chaves e valores ao quadrado
quadrados_dict = {x: x**2 for x in range(10)}
print(quadrados_dict)

Conclusão

A compreensão de listas é uma ferramenta poderosa que pode melhorar significativamente a clareza e a eficiência do seu código. Embora seja uma técnica simples, ela se aplica a uma ampla variedade de cenários, desde a criação de listas e filtragem de dados até a construção de estruturas mais complexas como dicionários e sets. Ao dominar a compreensão de listas, você será capaz de escrever códigos Python mais limpos e rápidos.