Introdução
Neste laboratório, você será apresentado às compreensões (comprehensions) em Python, uma sintaxe especial que permite criar estruturas de dados como listas, conjuntos (sets) e dicionários a partir de outros iteráveis de forma muito concisa. As compreensões são incrivelmente úteis ao lidar com um ou dois níveis de laços for aninhados, tornando seu código mais legível e, frequentemente, mais eficiente.
Você começará com o tipo mais comum, as compreensões de lista (list comprehensions), e verá como elas se comparam aos laços for tradicionais. Em seguida, aprenderá a adicionar lógica condicional para filtrar ou transformar elementos. Por fim, verá como os mesmos princípios se aplicam à criação de conjuntos e dicionários.
Compreensão de Lista
Nesta etapa, você aprenderá a sintaxe básica das compreensões de lista como uma maneira concisa de criar listas a partir de outros iteráveis. Compararemos a abordagem tradicional de loop for com a sintaxe mais elegante da compreensão de lista.
Nota: Se você não está familiarizado com o uso do WebIDE (semelhante ao VS Code), aprenda primeiro neste laboratório.
Primeiro, vejamos como criaríamos uma nova lista a partir de uma existente usando um loop for padrão.
Abra o arquivo main.py no explorador de arquivos à esquerda. Copie e cole o seguinte código no arquivo:
## Abordagem tradicional: criar lista usando um loop for
names = ['Charles', 'Susan', 'Patrick', 'George']
new_list = []
for n in names:
new_list.append(n)
print(new_list)
Para executar o código, abra um terminal clicando no ícone + no painel do terminal e selecionando "New Terminal". Em seguida, execute o seguinte comando:
python3 main.py
Você verá a seguinte saída:
['Charles', 'Susan', 'Patrick', 'George']
Agora, vamos obter o mesmo resultado usando uma compreensão de lista. A sintaxe básica é [expressão for item in iterável].
Substitua o conteúdo de main.py pelo seguinte código:
## Compreensão de lista: maneira concisa de criar uma nova lista
## Sintaxe: [expressão for item in iterável]
names = ['Charles', 'Susan', 'Patrick', 'George']
new_list = [n for n in names] ## Cria a lista com todos os nomes
print(new_list)
Execute o script novamente:
python3 main.py
A saída é idêntica, mas o código é muito mais curto e descritivo.
['Charles', 'Susan', 'Patrick', 'George']
As compreensões de lista também podem lidar com loops aninhados (nested loops). Por exemplo, para criar uma lista de tuplas a partir de dois intervalos (ranges), você pode fazer o seguinte.
Atualize seu arquivo main.py com este código e execute-o.
## Compreensão de lista aninhada: criar tuplas a partir de dois intervalos
## Equivalente a loops for aninhados
n = [(a, b) for a in range(1, 3) for b in range(1, 3)]
print(n)
Execute o script:
python3 main.py
A saída será uma lista de todas as combinações de tuplas possíveis:
[(1, 1), (1, 2), (2, 1), (2, 2)]
Adicionando condicionais
Nesta etapa, você explorará como incorporar lógica condicional nas compreensões de lista. Você aprenderá a filtrar elementos usando uma instrução if e como aplicar expressões condicionais a cada elemento usando uma estrutura if-else.
Digamos que queremos criar uma nova lista contendo apenas os nomes que começam com a letra 'C'. Com um laço for tradicional, você adicionaria uma instrução if dentro do laço.
Atualize seu main.py com o seguinte código:
## Abordagem tradicional: filtrar com condição if
names = ['Charles', 'Susan', 'Patrick', 'George', 'Carol']
new_list = []
for n in names:
if n.startswith('C'): ## Filtra nomes que começam com 'C'
new_list.append(n)
print(new_list)
Execute o script para ver o resultado:
python3 main.py
Saída:
['Charles', 'Carol']
Para fazer isso com uma compreensão de lista, você adiciona a instrução if no final. A sintaxe é [expressão for item in iterável if condição].
Experimente isto em seu main.py:
## Compreensão de lista com condição: filtrar itens
## Sintaxe: [expressão for item in iterável if condição]
names = ['Charles', 'Susan', 'Patrick', 'George', 'Carol']
new_list = [n for n in names if n.startswith('C')]
print(new_list)
Execute-o e você obterá a mesma lista filtrada:
python3 main.py
Saída:
['Charles', 'Carol']
Você também pode usar uma instrução if-else para realizar uma ação condicional em cada elemento. Neste caso, a expressão if-else vem antes do laço for. A sintaxe é [expressão_se_verdadeiro if condição else expressão_se_falso for item in iterável].
Vamos criar uma nova lista que dobra os números pares, mas mantém os números ímpares como estão. Atualize o main.py com o seguinte código e execute-o.
## Compreensão de lista com if-else: expressão condicional
## Sintaxe: [expressão_se_verdadeiro if condição else expressão_se_falso for item in iterável]
nums = [1, 2, 3, 4, 5, 6]
new_list = [num*2 if num % 2 == 0 else num for num in nums] ## Dobra números pares
print(new_list)
Execute o script:
python3 main.py
A saída mostra que apenas os números pares foram dobrados:
[1, 4, 3, 8, 5, 12]
Compreensão de Conjunto (Set Comprehension)
Nesta etapa, você entenderá como aplicar a sintaxe de compreensão para criar conjuntos (sets). Os conceitos básicos das compreensões de list (lista) também se aplicam a sets e dictionaries (dicionários).
As compreensões de conjunto são muito semelhantes às compreensões de lista. A principal diferença é que elas usam chaves {} em vez de colchetes [] e produzem um conjunto (set), que é uma coleção não ordenada de elementos únicos.
A sintaxe é {expressão for item in iterável}.
Vamos criar um conjunto a partir de outro conjunto, convertendo todos os seus elementos de string para maiúsculas. Atualize seu arquivo main.py com o seguinte código:
## Compreensão de conjunto: criar um conjunto usando a sintaxe de compreensão
## Sintaxe: {expressão for item in iterável}
b = {"abc", "def"}
upper_set = {s.upper() for s in b} ## Converte todas as strings para maiúsculas
print(upper_set)
Agora, execute o script:
python3 main.py
A saída será um novo conjunto contendo as strings em maiúsculas. Observe que, como os conjuntos não são ordenados, a ordem dos elementos na saída pode variar.
{'DEF', 'ABC'}
Se o iterável original tivesse itens duplicados, o conjunto resultante conteria apenas os elementos únicos, pois os conjuntos descartam duplicatas automaticamente.
Compreensão de Dicionário (Dict Comprehension)
Nesta etapa, você aprenderá a construir dicionários usando compreensões de dicionário. Assim como as compreensões de conjunto, elas também usam chaves {} , mas exigem um par chave-valor separado por dois pontos.
A sintaxe é {expressão_chave: expressão_valor for item in iterável}.
Um caso de uso comum é criar um novo dicionário transformando ou trocando os pares chave-valor de um dicionário existente. Vamos tentar trocar as chaves e valores de um dicionário.
Atualize seu arquivo main.py com o seguinte código:
## Compreensão de dicionário: trocar chaves e valores
## Sintaxe: {expressão_chave: expressão_valor for item in iterável}
c = {'name': 'Pooka', 'age': 5}
swapped_dict = {v: k for k, v in c.items()} ## Inverte os pares chave-valor
print(swapped_dict)
Execute o script:
python3 main.py
A saída será um novo dicionário onde os valores originais são agora chaves, e as chaves originais são valores.
{'Pooka': 'name', 5: 'age'}
Você também pode usar compreensões para criar outros tipos de dados a partir de dicionários. Por exemplo, veja como você pode usar uma compreensão de lista para gerar uma lista de strings formatadas a partir dos itens de um dicionário.
Substitua o código em main.py por este exemplo e execute-o:
## Compreensão de lista a partir de dicionário: criar strings formatadas
c = {'name': 'Pooka', 'age': 5}
formatted_list = ["{}:{}".format(k.upper(), v) for k, v in c.items()] ## Formata como "CHAVE:valor"
print(formatted_list)
Execute o script:
python3 main.py
Isso produzirá uma lista de strings, não um dicionário.
['NAME:Pooka', 'AGE:5']
Isso demonstra a flexibilidade de usar compreensões para processar e transformar diferentes estruturas de dados. Para sua tarefa final nesta etapa, certifique-se de que seu main.py contenha o código de troca de dicionário.
Resumo
Neste laboratório, você aprendeu a usar a poderosa sintaxe de compreensão do Python para criar listas, conjuntos (sets) e dicionários de maneira concisa e legível.
Você começou com compreensões de lista, vendo como elas fornecem uma alternativa mais elegante aos loops for tradicionais. Em seguida, aprendeu a adicionar lógica condicional, usando um if final para filtragem e uma expressão if-else para transformar elementos. Por fim, você viu como esses mesmos princípios se aplicam às compreensões de conjunto e dicionário, usando chaves {} para construir conjuntos de itens únicos e dicionários de pares chave-valor.
As compreensões são uma parte fundamental do código Python idiomático. Dominá-las tornará seu código mais eficiente e elegante. Continue praticando para torná-las uma parte natural do seu conjunto de ferramentas de programação Python.
