De um bolo para uma festa: listas, dicionários e tuplas#

O que você saberá se você ler todo este capítulo?#

  1. É possível armazenarmos mais de um valor dentro de uma variável.

  2. Para guardar mais de um valor em uma variável podemos usar listas, tuplas e dicionários.

  3. Que tuplas são imutáveis (depois de criada, não dá para alterar/adicionar/remover coisas), mas que listas e dicionários são mutáveis (dá para modificar depois de criados).

Sabe o que é melhor do que um bolo? Bolo + coxinha + brigadeiro + empadão + café…#

Sabe as variáveis que estudamos até agora? Então, até o momento elas guardavam somente um valor, não é? De certa forma, ou elas guardavam um número inteiro, ou um número real, ou um texto, ou um valor binário. Pensando em analogias, é como se uma variável guardasse um bolo de chocolate, outra guardasse um bolo de baunilha, outra guardasse um bolo de cenoura.

Mas, e se quiséssemos juntar tudo? E se quiséssemos guardar dentro de uma só variável várias informações? Assim como uma rede de fast-food oferece seus combos contendo um sanduíche, uma bebida e uma batata, às vezes poderíamos ser aquela pessoa em uma festinha de aniversário que coloca, dentro de um só pratinho de plástico, 3 coxinhas, uma fatia de bolo, umas empadinhas, 5 beijinhos e, se sobrar espaço nesta obra arquitetônica brasileira efêmera, um cajuzinho. E que tal fazer isso nos nossos algoritmos? Vamos lá?

Imagem de uma mesa de festa simples, contendo coxinas, dois bolos de chocolate, brigadeiros, e pratos de plástico vazios.
Só faltou um guaraná. Créditos: Márcio Cabral de Moura, no Flickr.

Diferenças e semelhanças de listas, dicionários e tuplas#

Listas, dicionário e tuplas são estruturas de dados que permitem que armazenemos mais de um dado dentro de uma variável. Você está acostumado a trabalhar com variáveis assim até agora, não é?

peso = 75
nome = 'João da Silva'
pagou_ingresso = True
preco = 25.71

Veja que cada variável guarda somente um dado: ou é um número inteiro, ou uma string, ou um booleno, ou um número decimal. Porém, existem casos em que precisamos guardar mais de uma informação.

Listas#

Vamos supor que você precise criar um algoritmo em que precisa armazenar todos os estudantes de uma disciplina e, em seguida, ordená-los seguindo uma ordem alfabética. Não seria nada produtivo você fazer assim:

estudante1 = 'Fulano'
estudante2 = 'João'
estudante3 = 'Maria'
estudante4 = 'Roberta'

Primeiro, porque cada turma terá uma quantidade específica de estudantes (imagine ter que criar até o estudante46 em uma turma e, depois, ter que modificar novamente para ir até o estudante9 em outra). Segundo, porque criar um for ou while para comparar estudante por estudante seria meio chato e demorado.

Imagine também um banco de dados: com o Python, você poderá se conectar a um banco de dados e ler as informações de lá. Digamos que você se conectou a um banco de dados de um supermercado e quer mostrar na tela para o usuário o nome de todos os produtos da seção de bebidas usando Python: como você poderia guardar todos aqueles nomes dentro de uma única variável?

É para isso que existem as listas: uma estrutura de dados que armazena uma sequência de dados dentro de uma única variável. Como uma analogia, imagine que você vá ao supermercado e precisa comprar vários itens, como maçãs, bananas e laranjas. Você pode colocar todos esses itens em uma sacola e, ao chegar no caixa, retirar cada um deles conforme a necessidade. As listas são como estas sacolas que permitem guardar vários itens em um mesmo lugar.

Veja um exemplo básico de lista:

estudantes = ['Fulano', 'João', 'Maria', 'Roberta']
frutas = ["maçã", "banana", "laranja", "uva"]
paises = ["Brasil", "Estados Unidos", "Japão", "Alemanha", "Portugal"]
numeros = [1, 5, 0]

Em Python, as listas são definidas utilizando colchetes ([]) e separando seus elementos por vírgulas (,). Consegue perceber esse padrão em todos os casos acima?

Criando listas#

A sintaxe básica para criar uma lista é a seguinte:

nomes = ['João', 'Maria', 'Pedro', 'Ana']

Neste exemplo, uma variável do tipo lista e chamada de nomes foi criada com quatro elementos do tipo string.

numeros = [-10, 0.50, 4]

Neste outro exemplo, uma variável do tipo lista e chamada de numeros foi criada com três números.

Criando listas do zero#

É possível também criar listas vazias ou adicionar elementos a uma lista existente utilizando o método append(). Veja como seria, um exemplo de como criar uma lista vazia e adicionar elementos a ela:

lista_vazia = []
print(lista_vazia)

lista_vazia.append(10)
lista_vazia.append(20)
lista_vazia.append(30)
print(lista_vazia)

A lista lista_vazia foi inicializada vazia e, em seguida, três elementos do tipo inteiro foram adicionados ao final dela utilizando a função append(). O primeiro print() mostrará o resultado dela antes de incluirmos cada um dos três elementos. O segundo print() mostrará o resultado da mesma lista após incluirmos todos os elementos.

🔓 As listas são manipuláveis em Python. Isso significa que podemos adicionar, remover ou modificarmos os elementos dentro dela como quisermos. É como se fosse uma sacola de supermercado onde podemos organizarmos, removermos ou adicionarmos as coisas como quisermos, mesmo.

Operações com listas#

Percorrendo listas#

E se quiséssemos percorrer uma lista? Isto é, ler cada um dos elementos dentro dela? Isto é possível por padrão, já. Olha só:

frutas = ["maçã", "banana", "laranja", "uva"]
for fruta in frutas:
    print(fruta)

O código acima cria uma lista chamada frutas que contém quatro elementos: “maçã”, “banana”, “laranja” e “uva”. Em seguida, ele percorre a lista utilizando um loop for, onde a cada iteração a variável fruta assume um dos valores da lista frutas. Dentro do loop, é executada a função print() que mostra na tela o valor da variável fruta.

Assim, o resultado final é a impressão de cada elemento da lista frutas em linhas separadas, na ordem em que foram definidos na lista: “maçã”, “banana”, “laranja” e “uva”.

Essa é uma das formas mais comuns de se trabalhar com listas em Python: percorrendo-as com loops for para realizar operações em cada elemento da lista.

Adicionando elementos#

Agora, e se quiséssemos adicionar elementos a uma lista? É o mesmo append() que vimos antes. Olha só:

numeros = [1, 2, 3, 4]
numeros.append(5)
print(numeros)

Esse código cria uma lista chamada numeros com os valores 1, 2, 3 e 4. Em seguida, a função append() é utilizada para adicionar o número 5 à lista, resultando em uma nova lista: [1, 2, 3, 4, 5]. Por fim, a nova lista é mostrada na tela utilizando a função print().

A função append() é uma das várias funções que podem ser utilizadas para manipular listas em Python. Ela adiciona um elemento ao final da lista, aumentando seu tamanho em uma unidade. A sintaxe básica para utilizar a função append() é a seguinte:

nome_da_lista.append(elemento_a_ser_adicionado)

No exemplo acima, o nome_da_lista é numeros e o elemento_a_ser_adicionado é o número 5. Ah: veja que nós não fazemos algo como numeros = numeros.append(5). Isto acontece porque o numeros.append(5) já atualizará o numeros por baixo dos panos e, com isso, não é necessário adicionarmos aquele numeros = no começo.

Removendo elementos#

E se quiséssemos remover elementos de uma lista? É simples: basta usarmos o remove():

paises = ["Brasil", "EUA", "Japão", "Alemanha"]
paises.remove("Japão")
print(paises)

O código acima apresenta uma lista de países armazenados na variável paises. Através da função remove(), é removido o país "Japão" da lista.

O remove() é utilizado para remover um item específico da lista. Ou seja, é necessário passar o elemento a ser removido como argumento da função. No caso do código, o item "Japão" foi passado como argumento, fazendo com que aquele país fosse removido da lista.

Ao final, é exibida a lista atualizada sem o país “Japão” através da função print().

Ordenando#

Assim como temos o append() para adicionar e o remove() para remover, o sort() serve para ordenar:

numeros = [3, 1, 4, 2, 5]
numeros.sort()
print(numeros)

O código acima cria uma lista de números chamada numeros com os valores 3, 1, 4, 2 e 5. Em seguida, a função sort() é usada para ordenar a lista em ordem crescente. Dessa forma, o código irá mostrar na tela a lista ordenada em ordem crescente, que no caso é: [1, 2, 3, 4, 5].

Se quiséssemos ordená-la de forma decrescente bastaria trocar a segunda linha para numeros.sort(reverse=True). Assim, ela iria mostrar na tela os valores na ordem decrescente ([5, 4, 3, 2, 1]).

Acessando elementos#

E se você quisesse ler uma posição específica da lista? Quer dizer: e se, ao invés de fazer um for para mostrar cada elemento da lista, quisesse só mostrar o primeiro e terceiro itens? Veja no exemplo abaixo:

frutas = ["maçã", "banana", "laranja", "uva"]
print(frutas[0]) # imprime "maçã"
print(frutas[2]) # imprime "laranja"

O código acima cria uma lista chamada frutas que contém quatro elementos: “maçã”, “banana”, “laranja” e “uva”. Em seguida, o código usa o índice dos elementos da lista para imprimir o primeiro elemento (índice 0), que é “maçã”, e o terceiro elemento (índice 2), que é “laranja”.

Agora, por que usamos os índices 0 e 2? O correto não seria 1 e 3, já que queríamos o primeiro e terceiro itens? Em Python, as listas são indexadas começando do zero. Ou seja, o primeiro elemento é representado pelo índice 0, o segundo elemento é representado pelo índice 1, e assim por diante. O índice é colocado entre colchetes depois do nome da lista. Portanto, para acessar um elemento específico de uma lista em Python, basta informar o índice desejado entre colchetes.

Modificando elementos#

E se quiséssemos mudar alguma coisa da lista? Também é possível. Veja só:

lista = [1, 2, 3, 4, 5]
lista[2] = 10
print(lista)

Neste código, a lista é inicializada com os valores [1, 2, 3, 4, 5]. Em seguida, o elemento de índice 2 (que hoje possui o valor 3) é modificado para o valor 10 usando o código lista[2] = 10. Por fim, a lista é impressa na tela com a função print(lista), resultando na saída [1, 2, 10, 4, 5].

Tuplas#

Tanto listas quanto tuplas (não escrevi errado: não são duplas, mas sim tuplas) são tipos de dados usados para armazenar em uma única variável vários valores. A diferença entre elas está na forma como os elementos são armazenados. Em uma lista, os elementos são armazenados em uma estrutura mutável, ou seja, é possível adicionar, remover e alterar elementos depois que a lista é criada. Já em uma tupla, os elementos são armazenados em uma estrutura imutável, ou seja, uma vez criada, a tupla não pode ser alterada.

Por essa razão, as tuplas são mais adequadas quando se deseja armazenar elementos que não precisam ser modificados, como as coordenadas de um ponto em um plano cartesiano ou os valores de uma data (dia, mês e ano). Já as listas são mais flexíveis e mais indicadas quando se deseja armazenar uma coleção de elementos que podem ser alterados ao longo do tempo.

Está claro? Como uma analogia, as tuplas são como ingressos de cinema que contêm informações sobre um filme. Quando você compra um ingresso de cinema, recebe um bilhete que contém informações sobre o filme, como o título, o horário e o número da sala. Essas informações ficam agrupadas em um bilhete e não podem ser alteradas depois que o ingresso foi comprado.

Quer dois exemplos de tuplas? Olha só:

pessoas = ("João", "Maria", "José")
elementos = ("banana", 5, True, 3.14)

A primeira tupla é chamada pessoas e contém três valores: "João", "Maria" e "José". Já a segunda tupla é chamada elementos e contém quatro valores diferentes: a string "banana", o número inteiro 5, o booleano True e o número real 3.14. Em listas também podemos misturar tipos de dados diferentes, se quisermos. Mas e então, qual é a diferença na hora de criar uma lista para uma tupla? O que tem de diferente no código acima?

Veja: as tuplas são definidas usando parênteses (()), em vez de colchetes ([]), que são usados para definir listas. Os elementos dentro de uma tupla são separados por vírgulas, assim como fazemos com as listas. Ainda, acessamos os elementos de uma tupla do mesmo jeito que fazemos com as listas.

Criando tuplas#

Lembra que uma tupla não pode ser modificada, né? Isto é: do jeito que ela foi criada, assim ela continuará sempre. Para criar uma tupla, basta listar os elementos dentro de parênteses (()) e separados por vírgulas.

coordenadas = (40.7128, -74.0060)
dias_da_semana = ("segunda", "terça", "quarta", "quinta", "sexta", "sábado", "domingo")
pontuacao_jogo = (1200, 3)

Aí nós temos quatro exemplos de tuplas. Perceba o padrão: valores separados por vírgulas e os parênteses para definir quando a tupla começa e quando ela termina.

Criando tuplas do zero#

Até dá para criar uma tupla vazia, mas não teria muita utilidade. Se a sequência é vazia, você usaria onde este tipo de cenário? Dito isso, veja abaixo um exemplo de tupla vazia, que nada mais é do que uma tupla que não possui elementos dentro dos parênteses:

tupla_vazia = ()

Operações com tuplas#

Percorrendo tuplas#

Também dá para percorrer as tuplas usando um loop como o for, e de um jeito bem parecido com as listas. Olha só:

animais = ("gato", "cachorro", "papagaio", "peixe")

for animal in animais:
    print(animal)

Temos aqui uma tupla chamada animais que possui quatro elementos: “gato”, “cachorro”, “papagaio” e “peixe”. Em seguida, percorremos a tupla com um loop for e mostramos cada elemento na tela. Acho que neste ponto você já sabe disso, mas a variável animal é uma variável temporária que assume o valor de cada elemento da tupla em cada iteração do loop. Ou seja, na primeira iteração, animal é "gato", na segunda é "cachorro" e assim por diante até a última iteração em que animal é "peixe".

Agora, e se quiséssemos saber se um elemento está ou não em uma tupla? Veja só

carros = ("fusca", "fiesta", "oggi", "uno")

if "fusca" in carros:
    print("O fusca está na lista")
else:
    print("O fusca não está na lista")

Este código cria uma tupla chamada carros com alguns modelos de carros. Em seguida, vemos se o elemento "fusca" está presente na tupla. Se estiver presente, o código mostrará a mensagem "O fusca está na lista". Caso contrário, ele imprime a mensagem "O fusca não está na lista".

No caso específico do código, como o elemento "fusca" está presente na tupla, a mensagem "O fusca está na lista" é exibida na tela.

Adicionando e removendo elementos#

Olha, como as tuplas são imutáveis, não dá para adicionar ou remover elementos depois que ela foi criada. Dito isso, temos uma alternativa: colocar as alterações que queremos em uma tupla dentro de uma nova tupla. Por exemplo:

Para adicionar um novo item ao dicionário, podemos simplesmente atribuir um valor a uma nova chave, como por exemplo:

tupla1 = (1, 2, 3)
tupla2 = tupla1 + (4,)
print(tupla2)  # saída: (1, 2, 3, 4)

Aqui, temos uma tupla chamada tupla1 com três elementos. Para adicionar o número 4 dentro desta tupla tivemos que criar uma nova tupla chamada tupla2, que é formada pela concatenação (veja o símbolo +) da tupla1 com uma nova tupla contendo apenas o número 4.

A adição da vírgula depois do número 4 é importante para indicar que se trata de uma tupla de um único elemento. Caso contrário, o Python entenderia apenas como um inteiro comum e a operação de concatenação com a tupla1 não seria possível. Agora, e se fosse para remover? Teríamos que fazer algo como:

tupla1 = (10, 20, 30, 40, 50)
tupla2 = (tupla1[0], tupla1[2], tupla1[4])
print(tupla2)  # saída: (10, 30, 50)

Nesse exemplo, foi criada uma nova tupla tupla2, contendo apenas o primeiro, terceiro e quinto elementos da tupla (lembra que sempre começamos a contar a partir do índice 0?).

Ordenando#

Hmmmm, acho que já falamos disso antes, mas as tuplas são imutáveis, lembra? Ou seja: não dá para mudar. De verdade! O máximo que dá seria criarmos uma nova tupla. Aí poderíamos fazer assim:

numeros = (5, 1, 3, 2, 4)
numeros_ordenados = tuple(sorted(numeros))
print(numeros_ordenados) # saída: (1, 2, 3, 4, 5)

Aqui, ordenamos uma tupla chamada numeros com o uso da função sorted(), que já vimos antes. Só que temos um problema: o resultado dessa sorted() não retorna uma tupla, mas sim uma lista. Então, usamos a função tuple() para converter uma lista em tuplas. Epa, pera:

🆕 Podemos converter listas para tuplas usando a função tuple(). Da mesma forma, podemos converter tuplas em listas usando a função list(). Funciona de um jeito bem parecido com a forma que usamos as funções string(), int() e float() para fazermos outras conversões com variáveis, sabe?

Também podemos usar a mesma lógica com tuplas que contenham strings. Veja só:

nomes = ("Ana", "Carlos", "Beatriz", "Daniel")
nomes_ordenados = tuple(sorted(nomes))
print(nomes_ordenados) # saída: ('Ana', 'Beatriz', 'Carlos', 'Daniel')

Aqui, o funcionamento é igual: temos uma tupla chamada nomes e que possui uma lista de strings que não está ordenada alfabeticamente. Então, usamos a sorted() para ordenar. O resultado da sorted() é uma lista ordenada alfabeticamente. Para converter esta lista de volta em tupla utilizamos o tuple().

Acessando elementos#

A lógica é a mesma de uma lista. Por isso, vou aproveitar para te ensinar algumas coisinhas a mais que também funcionam com as listas. Olha só:

tupla = ('a', 'b', 'c', 'd', 'e')
elemento = tupla[2]
print(elemento)  # saída: 'c'

O código acima começou com uma variável chamada tupla e que tinha 5 elementos. Em seguida, é criada a variável elemento e atribuída a ela o terceiro elemento da tupla, ou seja, o elemento de índice 2 (lembrando mais uma vez que em Python a contagem dos índices começa em 0). Por fim, é impresso na tela o valor da variável elemento, que nesse caso é a letra 'c'. Até aí, tudo bem né? E se quiséssemos o segundo, terceiro e quarto elementos de uma vez só? Veja:

tupla = ('a', 'b', 'c', 'd', 'e')
subtupla = tupla[1:4]
print(subtupla)  # saída: ('b', 'c', 'd')

Perceba a segunda linha: a subtupla é criada a partir da indexação dos elementos da tupla original usando o operador de fatiamento (slice). Nesta segunda linha, o operador de slice é utilizado para selecionar uma parte da tupla original. No caso, a subtupla vai conter todos os elementos de índice 1, 2 e 3 da tupla original ('b', 'c', 'd').

💡 A sintaxe para selecionar um range de elementos em uma tupla é [start:end], onde start é o índice do primeiro elemento a ser incluído na sub-tupla e end é o índice do primeiro elemento a ser excluído da sub-tupla.

Agora, e se quiséssemos o último elemento? Também conseguimos fazer isso:

tupla = ('a', 'b', 'c', 'd', 'e')
ultimo_elemento = tupla[-1]
print(ultimo_elemento)  # saída: 'e'

Estranhou aquele tupla[-1]? Em Python, é possível acessar os elementos de trás para frente usando índices negativos, onde -1 representa o último elemento, -2 o penúltimo e assim por diante. Lembrando mais uma vez: isso também funciona com listas, tá?

Dicionários#

Apesar das listas serem versáteis, não significa necessariamente que poderíamos fazer tudo nelas. Vamos supor que estamos criando um sistema de um condomínio de apartamentos e, para cada apartamento, precisamos guardar o nome de cada responsável e se o apartamento possui animais de estimação ou não.

Até poderíamos fazer algo assim:

apartamentos = [100, 101, 102, 103]
nomes = ['Fulano', 'Ana', 'Roberta', 'Maria', 'Eduardo']
pets = [True, False, True]

Só que aí houve um problema: em algum momento, alguém fez um append() a mais lá em nomes. Temos 4 apartamentos, 5 nomes. O Eduardo é de qual apartamento? Estaria ele substituindo alguma outra pessoa? Como saber se os nomes seguem a mesma ordem dos apartamentos, já que estão em variáveis diferentes? Consegue entender o problema?

É para resolver casos assim que temos as estruturas de dicionários. Os dicionários funcionam como um dicionário de palavras em um idioma estrangeiro, mesmo. Nesses dicionários de palavras você procura por uma palavra em específico (que é como se fosse uma chave). Dentro desta palavra você terá acesso aos significados dela, que geralmente são explicados em frases mais longas (que é como se fosse um valor que aquela chave estaria guardando).

Assim como um dicionário de palavras, um dicionário em Python é uma coleção de informações organizadas por chaves e valores. Cada chave é única (isto é, não podemos ter duas chaves iguais), e cada chave possui dentro dela mais valores. O exemplo acima poderia ser escrito em formato de dicionário assim:

apartamentos = {
    100: 'Ana',
    101: 'Roberta',
    102: 'Fulano',
    103: 'Eduardo'
}

Criando dicionários#

Agora sabemos que os nomes também estavam fora de ordem. Veja também que a sintaxe é um pouco diferente das listas. Em Python, a sintaxe básica para criar um dicionário é usando chaves ({}) e separando as chaves e seus valores correspondentes com dois pontos (:). Um exemplo simples de um dicionário com algumas informações de uma pessoa pode ser definido da seguinte forma:

pessoa = {
    "nome": "João",
    "idade": 30,
    "cidade": "São Paulo"
}

Nesse exemplo, "nome", "idade" e "cidade" são as chaves do dicionário e "João", 30 e "São Paulo" são seus valores correspondentes.

🤚 Atenção: observe a ordem - sempre colocamos primeiro a chave, depois os dois-pontos e, depois, o valor. Dito isso, você pode colocar as chaves do jeito que quiser. Ou seja: você poderia criar esse dicionário com a idade primeiro, depois o nome e, por último, a cidade. Ou qualquer outra ordem que quiser. O que realmente importa é ter sempre a chave primeiro e, depois, o valor.

Criando dicionários do zero#

Para criar um dicionário vazio em Python, basta usar um par de chaves sem nenhum elemento dentro:

meu_dicionario = {}

Também é possível criar um dicionário vazio utilizando a função dict():

meu_dicionario = dict()

Ambas as formas terão o mesmo resultado: um dicionário vazio que poderá ser preenchido posteriormente com chaves e valores.

Operações com dicionários#

Percorrendo dicionários#

Também dá para percorrer os dicionários usando um loop como o for, e de um jeito bem parecido com as listas. Olha só:

# criação de um dicionário com algumas informações
pessoa = {
    "nome": "João",
    "idade": 30,
    "cidade": "São Paulo"
}

# percorrendo as chaves do dicionário
for chave in pessoa:
    print(chave)
    
for chave in pessoa.keys():
    print(chave)
    
# percorrendo os valores do dicionário
for valor in pessoa.values():
    print(valor)
    
# percorrendo as chaves e valores do dicionário ao mesmo tempo
for chave, valor in pessoa.items():
    print(chave, valor)

Este código cria um dicionário chamado pessoa que contém informações sobre uma pessoa, como o nome, idade e cidade. Em seguida, são usados três exemplos de percorrer os elementos do dicionário.

No primeiro exemplo, o código usa um for para percorrer as chaves (keys) do dicionário. Dentro do loop, cada chave é mostrada na tela usando o comando print(). No caso, as chaves são nome, idade e cidade. O segundo loop possui o mesmo funcionamento - a diferença é que estamos pedindo explicitamente pelas chaves do dicionário ao fazermos um pessoa.keys() no código.

No terceiro for nós percorremos os valores (values) do dicionário. Dentro do loop, cada valor é impresso na tela usando o comando print(). Consegue ver as diferenças e semelhanças entre o segundo e o terceiro for? Um deles é para mostrar somente as chaves e o outro, somente os valores. Dito isso, a forma de se usar o for é a mesma.

No quarto for nós percorremos as chaves e valores do dicionário ao mesmo tempo com o uso do items(). Dentro do loop, tanto a chave quanto o valor são impressos na tela usando o comando print(). Esta função items() retorna uma lista de pares chave e valor do dicionário (ou seja: retorna a chave e também o seu valor correspondente).

Quer ver outro exemplo de uso? Olha só:

# criação de um dicionário com algumas informações
estoque = {
    'banana': 10,
    'maçã': 5,
    'laranja': 8
}

# percorrendo as chaves e valores do dicionário e exibindo informações sobre o estoque
for chave, valor in estoque.items():
    print(f"Temos {valor} unidades de {chave} em estoque.")

Aqui, temos um dicionário chamado estoque que armazena a quantidade de frutas disponíveis em um estabelecimento. A estrutura do dicionário é formada pelas chaves (que representam o nome das frutas) e pelos valores (que representam a quantidade de cada fruta).

Para percorrer o dicionário, o código utiliza o método items() para obter uma lista de tuplas (lembra delas?) contendo as chaves e valores do dicionário. Em seguida, um loop for é utilizado para percorrer cada uma das tuplas e exibir a quantidade de cada fruta disponível em estoque.

O código utiliza a função print() para exibir as informações na tela. Veja como formatamos uma frase mais bonita usando f-strings na última linha do código para facilitar a exibição das informações. Outra forma de mostrar os mesmos valores seria:

for chave in estoque.keys():
    print(f"Temos {estoque[chave]} unidades de {chave} em estoque.")

O resultado seria o mesmo. A diferença é que usamos um loop for para percorrer todas as chaves do dicionário com a função keys(). Aqui, a variável chave é usada para armazenar cada chave do dicionário em cada iteração do loop.

Dentro do loop, a string formatada é usada para imprimir informações sobre cada item do estoque. Veja a expressão estoque[chave]. Ela existe para acessar o valor correspondente à chave atual do dicionário. Por exemplo: estoque['banana'] lê o valor que está dentro da chave banana, que é o valor 10.

Adicionando elementos#

Para adicionar um novo item ao dicionário, podemos simplesmente atribuir um valor a uma nova chave, como por exemplo:

pessoa = {
    "nome": "João",
    "idade": 30,
    "cidade": "São Paulo"
}

pessoa["profissao"] = "engenheiro"
print(pessoa)

Isso adiciona a chave profissao ao dicionário pessoa com o valor "engenheiro". Simples assim!

Removendo elementos#
meu_dicionario = {
    "a": 1,
    "b": 2,
    "c": 3
}

del meu_dicionario["b"]
print(meu_dicionario)

Nesse exemplo, é criado um dicionário com três elementos: "a": 1, "b": 2 e "c": 3. Em seguida, o del meu_dicionario["b"] remove o elemento com chave "b" do dicionário. O resultado da execução é um dicionário com os elementos "a": 1 e "c": 3.

Agora, e se você quisesse reaproveitar aquele 2? No caso, salvar aquele valor em uma variável e também remover este elemento no dicionário? Basta usarmos o pop(). Olha só:

meu_dicionario = {
    "a": 1,
    "b": 2,
    "c": 3
}

valor = meu_dicionario.pop("b")
print(meu_dicionario)
print(valor)

Nesse exemplo, é criado o mesmo dicionário com os três elementos: "a": 1, "b": 2 e "c": 3. Em seguida, o valor = meu_dicionario.pop("b") remove o elemento com chave "b" do dicionário e também armazena o valor associado a essa chave na variável valor. O resultado da execução é um dicionário com os elementos "a": 1 e "c": 3", e o valor 2 é posteriormente mostrado na tela e salvo dentro da variável valor.

Ordenando#

Agora, vou ficar devendo esta parte. Um dicionário em Python é uma estrutura de dados que não é ordenada. Dito isso, dá para ordenarmos as chaves ou os valores de forma separada. Veja só:

dicionario = {"c": 3, "a": 1, "d": 4, "b": 2}
chaves_ordenadas = sorted(dicionario.keys())
print(chaves_ordenadas) # imprime ['a', 'b', 'c', 'd']

Aqui, a função sorted() é usada para ordenar as chaves do dicionário dicionario. O resultado disso é uma lista de chaves ordenadas em ordem crescente. Por outro lado, isto não significa que o nosso dicionário foi ordenado: apenas criamos uma lista separada contendo as chaves ordenadas. O mesmo vale para os valores. Veja só:

dicionario = {"c": 3, "a": 1, "d": 4, "b": 2}
valores_ordenados = sorted(dicionario.values())
print(valores_ordenados) # imprime [1, 2, 3, 4]

Aqui, a função sorted() é usada para ordenar os valores do dicionário dicionario. Assim como foi no caso das chaves, o nosso dicionario não está ordenado: apenas criamos uma lista separada contendo os valores ordenados.

Acessando elementos#

Beleza, e se quiséssemos ler o valor de uma chave específica em um dicionário? Acho que já dei um spoiler disso antes, mas lá vai:

# Definindo um dicionário
pessoa = {
    "nome": "João",
    "idade": 30,
    "cidade": "São Paulo"
}

# Acessando um valor através da chave
print(pessoa["nome"]) # Saída: "João"

No exemplo acima, é definido um dicionário com três chaves e valores correspondentes. Para acessar o valor associado à chave nome, é utilizado o operador de colchetes ([]) e o nome da chave. O resultado é o valor "João" sendo mostrado na tela. Outra forma de fazermos isto é com a função get(). Olha só:

# Definindo um dicionário
pessoa = {
    "nome": "João",
    "idade": 30,
    "cidade": "São Paulo"
}

# Acessando um valor com o método get()
print(pessoa.get("idade")) # Saída: 30

Nesse exemplo, o get() é usado para acessar o valor associado à chave idade. Esse método recebe como argumento o nome da chave e retorna o valor correspondente, ou o valor None caso a chave não exista no dicionário. A saída no console é o valor 30, que está associado à chave idade no dicionário pessoa.

Modificando elementos#

Agora, vamos supor que queremos modificar um valor de uma chave que já está no dicionário. A sintaxe é a mesma que usamos para adicionar elementos. Veja só:

# criação do dicionário
pessoa = {
    "nome": "João",
    "idade": 25,
    "cidade": "São Paulo"
}

# modificando um elemento
pessoa["idade"] = 30

# impressão do dicionário após a modificação
print(pessoa)

Neste exemplo, é criado um dicionário que representa uma pessoa, com as chaves "nome", "idade" e "cidade" e seus respectivos valores. Em seguida, é feita a modificação da idade da pessoa para 30. Por fim, o dicionário atualizado é mostrado na tela (ou seja, com a idade igual a 30). Quer outro exemplo? Olha só:

# criação do dicionário
estoque = {
    "laranja": 10,
    "maçã": 15,
    "banana": 20
}

# modificando um elemento
estoque["banana"] = 30

# impressão do dicionário após a modificação
print(estoque)

Aqui, criamos um dicionário que representa um estoque de frutas com as chaves "laranja", "maçã" e "banana" e seus respectivos valores. Em seguida, é feita a modificação do valor correspondente à chave "banana" para 30 (ou seja: estamos alterando o estoque de 20 para 30 bananas). Por fim, é impresso o dicionário atualizado.

Exercícios#

  1. Crie uma lista com números de 1 a 10 e, em seguida, imprima apenas os números pares.

  2. Crie uma lista com nomes de frutas e, em seguida, remova a fruta “banana”.

  3. Crie uma lista com os números de 1 a 5 e, em seguida, adicione o número 6 ao final da lista.

  4. Escreva um código que armazena o nome de 5 frutas em uma tupla e imprime cada uma em uma linha.

  5. Crie um dicionário com o nome e a profissão de duas pessoas e adicione uma terceira pessoa com nome e profissão.

  6. Crie um dicionário com o nome e a idade de três pessoas e exiba a idade de cada uma delas na tela.

Respostas#

1. Crie uma lista com números de 1 a 10 e, em seguida, imprima apenas os números pares.

numeros = list(range(1, 11))

for num in numeros:
    if num % 2 == 0:
        print(num)

Primeiro é criada uma lista de números de 1 a 10 utilizando a função range() e convertendo-a para uma lista utilizando a função list(). Em seguida, é utilizado um loop for para percorrer cada número na lista e, caso o número seja par (verificando se o resto da divisão por 2 é igual a zero), o número é mostrado na tela utilizando a função print(). Também poderíamos criar a lista manualmente. Dessa forma, o código poderia ser:

numeros = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]

for num in numeros:
    if num % 2 == 0:
        print(num)

2. Crie uma lista com nomes de frutas e, em seguida, remova a fruta “banana”.

frutas = ["maçã", "banana", "laranja", "uva"]
frutas.remove("banana")
print(frutas)

No exemplo acima, a função remove() é utilizada para remover a fruta "banana" da lista frutas. A função recebe como argumento o elemento que se deseja remover da lista. Em seguida, a lista atualizada é mostrada na tela com a função print().

3. Crie uma lista com os números de 1 a 5 e, em seguida, adicione o número 6 ao final da lista.

numeros = [1, 2, 3, 4, 5]
numeros.append(6)
print(numeros)

Primeiro, definimos uma lista contendo todos os números de 1 a 5 e armazenamos esta lista dentro da variável numeros. Então, usamos a função append() para adicionar o número 6 ao final da lista. No final, usamos o print() para mostrar a lista atualizada na tela.

4. Escreva um código que armazena o nome de 5 frutas em uma tupla e imprime cada uma em uma linha.

frutas = ("maçã", "banana", "laranja", "uva", "morango")

for fruta in frutas:
    print(fruta)

Aqui, a tupla chamada frutas é criada com cinco elementos. Em seguida, é usado um for para percorrer cada elemento da tupla e imprimir na tela. A função print() é chamada dentro do loop para imprimir cada elemento em uma linha separada.

5. Crie um dicionário com o nome e a profissão de duas pessoas e adicione uma terceira pessoa com nome e profissão.

pessoas = {}

# adiciona as duas primeiras pessoas
for i in range(2):
    nome = input("Digite o nome da pessoa: ")
    profissao = input("Digite a profissão da pessoa: ")
    pessoas[nome] = profissao

# adiciona a terceira pessoa
nome = input("Digite o nome da terceira pessoa: ")
profissao = input("Digite a profissão da terceira pessoa: ")
pessoas[nome] = profissao

print(pessoas)

Aqui, observe que usamos o for para popular o dicionário pessoas pedindo ao usuário para que digite os dados das duas primeiras pessoas. Em seguida, o código também pede ao usuário o nome e a profissão da terceira pessoa e a adiciona ao dicionário usando a mesma sintaxe dicionario[chave] = valor. Por fim, o dicionário completo é impresso na tela usando a função print().

6. Crie um dicionário com o nome e a idade de três pessoas e exiba a idade de cada uma delas na tela.

pessoas = {'João': 25, 'Maria': 30, 'José': 40}

for nome, idade in pessoas.items():
    print(f'{nome} tem {idade} anos.')

Nesse exemplo, a variável pessoas é um dicionário que armazena o nome e idade de três pessoas. O código for nome, idade in pessoas.items() percorre o dicionário e separa o nome e idade de cada pessoa. A função items() é usada para obter uma tupla de pares chave e valor (nome e idade) do dicionário. Finalmente, o print(f'{nome} tem {idade} anos.') exibirá o nome e idade de cada pessoa na tela.

Referências bibliográficas#