Praticando Python: estruturas de dados

Estruturas de dados - Estruturas de dados

Boas-vindas ao curso de "Praticando Python: Estruturas de Dados"! Me chamo Allan Spadini.

Audiodescrição: Allan se descreve como um homem de pele clara, com cabelos e olhos castanhos. Está no estúdio da Alura, onde ao fundo há uma parede iluminada em um tom de azul esverdeado, e à direita, uma estante com diversas decorações.

O que vamos aprender?

Neste curso, estudaremos as estruturas de dados, com foco nas listas, tuplas e na interação com essas estruturas por meio dos loops for, if/else e também das list comprehensions ("compreensões de lista").

Recapitulando

Iniciaremos com uma revisão sobre as listas e as tuplas, compreendendo suas utilidades. Tomaremos como exemplo uma lista e uma tupla.

Ao observarmos o conteúdo em nosso notebook, perceberemos que ambos os exemplos, de lista e de tupla, são quase idênticos:

lista = [0, 'banana', 'pizza', 3.14]
tupla = (0, 'banana', 'pizza', 3.14)

A única diferença é que a tupla é escrita entre parênteses, enquanto as listas são escritas entre colchetes. Teclamos "Shift + Enter" para executar a célula no Google Colab.

Relembramos algumas diferenças importantes.

Diferenças entre listas e tuplas

A principal diferença que nos interessa é que a lista é mutável, ou seja, podemos alterar os valores. Por exemplo, em uma nova célula, é possível modificar o elemento na posição zero da lista para 10. Na lista original, o elemento possui o valor zero.

lista[0]=10

Executamos teclando "Shift + Enter". Logo após, chamamos a lista em uma nova célula:

lista

[10, 'banana', 'pizza', 3.14]

Ao executar teclando "Shift + Enter", observamos que o valor na posição zero da lista original foi alterado.

No caso da tupla, a situação é diferente. Se tentarmos realizar a mesma alteração, ocorrerá um erro, indicando que não é possível modificar a tupla. Para verificar, em uma nova célula, digitamos:

tupla[0]=10

TypeError: 'tuple' object does not support item assignment

Isso pode ser vantajoso, pois a tupla preserva a informação de forma segura, sem permitir alterações.

Loop for

A maneira de interagir com essas informações é equivalente. Por exemplo, para imprimir os elementos de uma lista ou de uma tupla, podemos utilizar um loop for. Em uma nova célula, colamos:

for item in lista:
    print(item)

Teclamos "Shift + Enter" e obtemos:

10

banana

pizza

3.14

Através do loop for acima, percorremos cada elemento da lista e imprimimos os valores 10, "banana", "pizza" e 3.14. O mesmo resultado será obtido ao substituir a lista pela tupla.

for item in tupla:
    print(item)

10

banana

pizza

3.14

Lista de produtos de um mercado

Abordaremos um problema mais tangível.

Criamos uma lista representando os produtos em um mercado, ou seja, uma lista de listas. Em uma nova célula, inserimos:

# Lista de produtos: [nome, preço, quantidade]
produtos = [
    ["Arroz", 5.99, 30],
    ["Feijão", 8.49, 20],
    ["Macarrão", 4.79, 50],
    ["Óleo", 7.89, 15],
    ["Açúcar", 3.99, 40],
    ["Sal", 2.49, 100],
    ["Café", 14.99, 10],
    ["Leite", 6.49, 25],
]

Cada elemento dessa lista corresponde a outra lista, contendo o nome do produto, o preço e a quantidade em estoque. Para trabalhar com isso, podemos, por exemplo, selecionar apenas os preços dos produtos.

Para isso, em uma nova célula, criamos uma nova lista vazia de preços (precos = []), utilizando um loop for para percorrer os produtos e extrair os preços, que estão na coluna 1.

# Inicializa uma lista para armazenar os preços
precos = []

# Loop para extrair os preços
for produto in produtos:
    precos.append(produto[1])

Executamos a célula acima com "Shift + Enter" e depois, em uma nova célula, digitamos:

precos

[5.99, 8.49, 4.79, 7.89, 3.99, 2.49, 14.99, 6.49]

Após executar o código, obtemos a lista de preços e podemos somá-los para calcular o total, caso uma pessoa comprasse um de cada produto.

Para obter essa soma, digitamos em uma nova célula:

soma_precos = sum(precos)

Executamos e, numa nova célula, usamos:

soma_precos 

55.120000000000005

Com isso, obtemos o valor total de soma_precos.

List comprehension

É possível escrever este loop for para obter os preços de maneira mais concisa utilizando list comprehension. O código permanece quase idêntico, mas é reduzido a uma única linha:

# Inicializa uma lista para armazenar os preços
precos = []

# Usando list comprehension
precos = [produto[1] for produto in produtos]

Criamos novamente a lista vazia de preços, mas agora com list comprehension, extraindo os dados da coluna 1 dos preços.

A soma dos preços continua sendo realizada da mesma maneira que anteriormente:

# Inicializa uma lista para armazenar os preços
precos = []

# Usando list comprehension
precos = [produto[1] for produto in produtos]

# Calcula a soma dos preços usando sum()
soma_precos = sum(precos)
soma_precos

55.120000000000005

Executamos a célula com "Shift + Enter" e obtemos o mesmo resultado.

É possível simplificar ainda mais, colocando a função sum() em torno do list comprehension para retornar diretamente à soma dos preços.

# Inicializa uma lista para armazenar os preços
precos = []

# Usando list comprehension
soma_precos = sum([produto[1] for produto in produtos])
soma_precos

55.120000000000005

List comprehension com if e else

Outro exemplo de list comprehension pode envolver o uso de if/else. Suponhamos que seja necessário verificar se o estoque está alto ou baixo.

# Verificar estoque e marcar como "Estoque baixo" ou "Estoque OK"
status_estoque = [
    [produto[0], "Estoque baixo" if produto[2] < 20 else "Estoque OK"]
    for produto in produtos
]

Escrevemos o nome do produto, que está na coluna zero (produto[0]), e em seguida aplicamos um list comprehension com uma regra utilizando if/else. A lista status_estoque verifica se a quantidade é menor que 20, considerando o estoque como baixo, ou, caso contrário, como "ok". Em seguida, percorremos cada produto na lista para gerar a lista status_estoque dessa maneira.

Executamos a célula e, em uma nova célula, chamamos o status_estoque:

status_estoque

[['Arroz', 'Estoque OK'],

['Feijão', 'Estoque OK'],

['Macarrão', 'Estoque OK'],

['Óleo', 'Estoque baixo'],

['Açúcar', 'Estoque OK'],

['Sal', 'Estoque OK'],

['Café', 'Estoque baixo'],

['Leite', 'Estoque OK']]

Observamos que há produtos que o estoque está "Ok" e outros que constam como "Baixo".

Dict comprehension

Além de listas, também poderíamos utilizar tuplas ou dicionários. Vamos criar um exemplo utilizando um dicionário para representar a lista de produtos.

#Status do estoque:
estoque = {
    "Arroz": {"quantidade": 30, "preco": 25.00},
    "Feijão": {"quantidade": 15, "preco": 18.50},
    "Macarrão": {"quantidade": 50, "preco": 10.00},
    "Óleo": {"quantidade": 10, "preco": 22.00},
    "Açúcar": {"quantidade": 40, "preco": 8.00},
    "Café": {"quantidade": 5, "preco": 30.00},
}

Criamos um dicionário chamado estoque, no qual cada produto é associado a um par chave-valor, sendo que o valor é um dicionário contendo a quantidade e o preço do produto. Podemos aplicar os conceitos de list comprehension por meio de dict comprehension para trabalhar com este dicionário.

Executamos a célula.

Agora, obteremos o estoque com desconto utilizando o seguinte código:

estoque_com_desconto = {
    nome: {
        "quantidade": dados["quantidade"],
        "preco": dados["preco"] * 0.9 if dados["preco"] > 20 else dados["preco"]
    }
    for nome, dados in estoque.items()
}
estoque_com_desconto

Criamos o dicionário estoque_com_desconto, aplicando um desconto nos preços superiores a 20. Capturamos o nome do produto (valor do dicionário) e percorremos os produtos no dicionário estoque e atualizamos os preços, aplicando um desconto de 0.9 quando o preço for maior que 20.

Em seguida, percorremos os nomes dos produtos no dicionário e os dados no dicionário de estoque utilizando o método estoque.items().

{'Arroz': {'quantidade': 30, 'preco': 22.5},

'Feijão': {'quantidade': 15, 'preco': 18.5},

'Macarrão': {'quantidade': 50, 'preco': 10.0},

'Óleo': {'quantidade': 10, 'preco': 19.8},

'Açúcar': {'quantidade': 40, 'preco': 8.0},

'Café': {'quantidade': 5, 'preco': 27.0}}

Após a execução do código, observamos que o dicionário resultante tem os preços alterados conforme a regra definida.

Próximos passos

Esta foi uma revisão sobre listas, tuplas e dicionários. Com isso, espera-se que já possuam conhecimento sobre esses conceitos.

Agora, com essa revisão, há problemas para resolver e praticar os conhecimentos adquiridos. Em caso de dúvidas, é possível postar no fórum ou interagir com a comunidade no Discord. Até a próxima oportunidade!

Sobre o curso Praticando Python: estruturas de dados

O curso Praticando Python: estruturas de dados possui 12 minutos de vídeos, em um total de 14 atividades. Gostou? Conheça nossos outros cursos de Data Science em Data Science, ou leia nossos artigos de Data Science.

Matricule-se e comece a estudar com a gente hoje! Conheça outros tópicos abordados durante o curso:

• Estruturas de dados