Alura > Cursos de Programação > Cursos de Python > Conteúdos de Python > Primeiras aulas do curso Praticando Python: conjuntos e dicionários

Praticando Python: conjuntos e dicionários

Praticando o uso de conjunto e dicionário em Python - Conjuntos e dicionários

Olá, meu nome é Laís Urano, sou instrutora na Escola de Programação da Alura.

Audiodescrição: Laís Urano se identifica como uma mulher parda. Possui olhos e cabelos castanho. Seus cabelos são longos e cacheados, com mechas azuis. Usa delineador preto, batom vermelho e blusa vermelha. Ao fundo, parede branca sem decorações, iluminada por uma luz azul.

Se você estiver acompanhando a formação Praticando Python, você já se deparou com uma estrutura chamada listas. Neste curso, vamos explorar duas novas estruturas de armazenamento de dados no Python: conjuntos e dicionários.

Entendendo conjuntos em Python

Os conjuntos são coleções não ordenadas de elementos, sem elementos repetidos.

Podemos defini-los diretamente com chaves {}, onde os elementos são separados por vírgula. Por exemplo, um conjunto pode conter elementos como a, b e c:

conjunto1 = {'a', 'b', 'c'}

Outra forma de criar um conjunto é através da função set(), que é nativa do Python. Nessa função, devemos passar uma lista que contém os elementos que queremos dentro daquele conjunto:

conjunto2 = set([3, 4, 5, 6])

Criando conjuntos vazios

A função set() é útil, especialmente, para inicializar um conjunto vazio, ou seja, um conjunto que não contém nenhum elemento. Isso porquê utilizar chaves vazias criaria outra estrutura, não um conjunto:

tipo = type({})
print(tipo) # Saída: <class 'dict'>

Para criar conjuntos vazios, devemos obrigatoriamente usar a função set() sem argumentos:

conjunto_vazio = set()

Acessando elementos

Podemos acessar e modificar elementos de conjuntos utilizando os operadores in e not in, que verificam, respectivamente, a presença ou ausência de um elemento e retornam um valor booleano (verdadeiro ou falso).

Considere conjunto = {1, 2, 3, 4, 5}:

MétodoConceitoExemploSaída
inVerifica se um elemento está presente em um conjunto. Retorna True se o elemento estiver no conjunto e False caso contrário.print(3 in conjunto)

print(6 in conjunto)

True

False

not inVerifica se um elemento não está presente em um conjunto. Retorna True se o elemento não estiver no conjunto e False caso contrário.print(3 not in conjunto)

print(6 not in conjunto)

False

True

Explorando métodos de manipulação

Existem diversos métodos de manipulação para conjuntos para adicionar e remover elementos. Podemos adicionar apenas um ou vários elementos de uma vez, remover itens com ou sem geração de erro e até limpar todos os elementos de um conjunto.

Considere conjunto = {1, 2, 3}:

MétodoConceitoExemploConjunto Atual
add(elemento)Adiciona um único elemento.conjunto.add(4){1, 2, 3, 4}
update(iterável)Adiciona vários elementos de uma vez.conjunto.update([5, 6, 7]){1, 2, 3, 4, 5, 6, 7}
remove(elemento)Remove um item. Se o elemento não existir, gera um KeyError.conjunto.remove(2){1, 3, 4, 5, 6, 7}
discard(elemento)Remove um item. Se o elemento não existir, não gera erro.conjunto.discard(2){1, 3, 4, 5, 6, 7}
pop()Remove e retorna um elemento aleatório.conjunto.pop(){3, 4, 5, 6, 7}
clear()Remove todos os elementos do conjunto.conjunto.clear()set()

Além disso, podemos realizar operações entre conjuntos, como união, interseção, diferença e diferença simétrica. Essas operações são utilizadas, principalmente, quando trabalhamos com operações matemáticas em um projeto.

Considere a = {1, 2, 3} e b = {3, 4, 5}:

MétodoConceitoExemploSaída
union(set2) ou (|)União de dois conjuntos.a.union(b) ou a | b{1, 2, 3, 4, 5}
intersection(set2) ou (&)Interseção de dois conjuntos.a.intersection(b) ou a & b{3}
difference(set2) ou (-)Diferença entre dois conjuntos, considerando elementos exclusivos do primeiro conjunto.a.difference(b) ou a - b{1, 2}
symmetric_difference(set2) ou (^)Diferença entre dois conjuntos, considerando elementos exclusivos de ambos conjuntos.a.symmetric_difference(b) ou a ^ b{1, 2, 4, 5}

Também existem métodos de manipulação utilizados para verificar relações entre conjuntos. Assim, podemos verificar se há relações de subconjunto e superconjunto, além de conferir existência de elementos em comum e a quantidade de elementos. Também é possível criar uma cópia de um conjunto caso necessário.

Considere a = {1, 2} e b = {1, 2, 3, 4}:

MétodoConceitoExemploSaída
issubset(set2) ou (<=)Verifica se um conjunto é subconjunto de outro.a.issubset(b) ou a <= bTrue
issuperset(set2) ou (>=)Verifica se um conjunto é superconjunto de outro.b.issuperset(a) ou a >= bTrue
isdisjoint(set2)Verifica se os conjuntos não têm elementos em comum.c = {5, 6, 7}

a.isdisjoint(c)

True
len(conjunto)Verifica o número de elementos de um conjunto.len(a)2
copy()Retorna uma cópia do conjunto.copia = a.copy()

print(copia)

{1, 2}

Entendendo dicionários em Python

Os dicionários são estruturas de dados que armazenam pares de chave-valor. Sua vantagem é facilitar o acesso aos valores por meio das chaves.

Um dicionário pode ser criado de forma semelhante aos conjuntos, entre chaves e com pares de elementos separados entre vírgulas. Porém, cada par de elemento contém dois valores separados por dois-pontos (:), onde o primeiro valor é a chave e o segundo é o valor associado.

Vamos exemplificar com um dicionário que armazena nomes e notas de estudantes. O primeiro par é composto pela chave "nome", cujo valor é a string "Ana". O segundo par é composto pela chave "nota", cujo valor é 10.0.

dic1 = {"nome": "Ana", "nota": 10.0}

Além da forma padrão, também podemos criar dicionários utilizando a função dict(), passando argumentos nomeamos que representam as chaves e seus valores associados:

dic2 = dict(nome="Eva", nota=9.4)

Criando dicionários vazios

Para criar dicionários vazios, ou seja, sem nenhum elemento, podemos usar tanto chaves vazias quanto a função dict() sem parâmetros.

dicionario = {}
dicionario = dict()

Criando dicionários com listas de tuplas

Além disso, é possível criar dicionários a partir de listas de tuplas, onde cada tupla deve conter dois elementos, a chave e o valor.

No código de exemplo, vamos criar uma lista de tupla com dois pares chave-valor. Em seguida, passamos a lista de tuplas para a função de dict() e recebemos um dicionário com os dados organizados de forma estruturada.

lista_de_tuplas = [("nome", "Ana"), ("nota", 10.0)]
dicionario = dict(lista_de_tuplas)
print(dicionario) 
# Saída: {'nome': 'Ana', 'nota': 10.0}

Identificando tipos permitidos para chaves e valores

As chaves dos dicionários devem ser, obrigatoriamente, valores imutáveis, como strings, números (inteiros ou pontos flutuantes) e tuplas (desde que todos os elementos também sejam imutáveis). Por isso, as chaves não podem ser listas ou dicionários, pois são elementos mutáveis.

No código de exemplo, criamos um dicionário válido com três pares chave-valor, cujas chaves são inteiro, string e tupla, respectivamente. Note que um dicionário pode conter vários tipos diferentes de chaves.

Se tentamos criar um dicionário que contém uma lista como chave, obteremos um erro de tipo, pois não será um dicionário válido.

dicionario_valido = {1: "um", "dois": 2, (3, 4): "par"}
dicionario_invalido = {[1, 2]: "lista"}  # Saída: TypeError: unhashable type: 'list'

Os valores, por outro lado, podem ser de qualquer tipo de dado, incluindo strings, números, tuplas, listas, dicionários e até mesmo objetos personalizados.

Confira esse exemplo de dicionário válido com diversos tipos de valores:

dicionario = {
    "nome": "João",
    "idade": 25,
    "notas": [10.0, 6.3, 7.5],
    "endereco": {"cidade": "São Paulo", "bairro": "Centro"}
}

Acessando e modificando elementos

Podemos acessar e modificar dados em dicionários utilizando colchetes []. A vantagem do dicionário é exatamente ter acesso fácil aos valores associados às chaves.

Para acessar um valor, basta usar o nome do dicionário seguido do nome da chave entre colchetes. Para modificar esse valor, basta atribuir um novo valor à chave através do sinal de igual. Vamos conferir um exemplo.

Considere dic = {"nome": "Ana", "nota": 10.0}:

MétodoConceitoExemploSaída
nome_dicionario[chave]Acessar um valor por uma chave.dic["nome"]Ana
nome_dicionario[chave] = valorAtribuir um valor a uma chave.dic["nota"] = 9.2{"nome": "Ana", "nota": 9.2}
del nome_dicionario[chave]Remover um item específico.del dic["nome"]{"nota": 9.2}

Desse modo, conseguimos acessar, atribuir e remover itens de um dicionário facilmente.

Além disso, podemos acessar e modificar dicionário da mesma maneira que é feito em conjuntos, isto é, utilizando os métodos in e not in. Esperamos um booleano como retorno, caso o elemento esteja presente ou ausente do dicionário.

Considere dic = {"nome": "Ana", "nota": 10.0}:

MétodoConceitoExemploSaída
inVerifica se uma chave está presente no dicionário. Retorna True se a chave existir e False caso contrário.print("nome" in dic)

print("idade" in dic)

True

False

not inVerifica se uma chave não está presente no dicionário. Retorna True se a chave não existir e False caso contrário.print("idade" not in dic)True

Explorando métodos de manipulação

Existem diversos métodos de manipulação para acessar e verificar o tamanho do dicionário. Desse modo, é possível retornar as chaves e os valores do dicionário separadamente; retornar os itens, que são os pares de chave-valor; e também verificar quantos pares chave-valor existem no dicionário.

Considere dicionario = {"nome": "João", "idade": 28}:

MétodoConceitoExemploSaída
keys()Retorna as chaves do dicionário.dicionario.keys()dict_keys(['nome', 'idade'])
values()Retorna os valores do dicionário.dicionario.values()dict_values(['João', 28])
items()Retorna pares (chave, valor) como tuplas.dicionario.items()dict_items([('nome', 'João'), ('idade', 28)])
len(dicionario)Conta quantos pares (chave, valor) o dicionário possui.len(dicionario)2

Também existem métodos de manipulação de busca e modificação de elementos. Com esses métodos, podemos obter valores sem erro caso a chave não exista; remover uma chave; listas todas as chaves do dicionário; e limpar todos os itens do dicionário, caso você queira reiniciá-lo.

Considere dicionario = {"nome": "João", "idade": 28}:

MétodoConceitoExemploSaída
get(chave, padrão=None)Obtém um valor sem erro se a chave não existir.dicionario.get("nome")

dicionario.get("altura", "Não informado!")

Ana

Não Informado!

pop(chave, padrão)Remove uma chave e retorna seu valor. Se o padrão não for fornecido e a chave não existir, um KeyError é levantado.dicionario.pop("idade"){"nome": "João"}
list(dicionario)Usada para obter todas as chaves do dicionário em forma de lista.chaves = list(dicionario)

print(chaves)

["nome"]
clear()Apaga todos os itens do dicionário.dicionario.clear(){}

Alguns outros métodos de manipulação permitem atualizar e remover os elementos de dicionários de diversas maneiras. Assim, é possível remover o último par inserido; ordenar o dicionário de uma forma diferente; atualizar o dicionário; e até mesmo fazer uma cópia rasa, caso seja necessário.

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

MétodoConceitoExemploSaída
popitem()Remove e retorna o último par (chave, valor) inserido. Se o dicionário estiver vazio, um KeyError é levantado.dicionario.popitem(){"a": 1, "b": 2}
reversed(dicionario)Retorna um iterador sobre as chaves do dicionário em ordem reversa.print(list(reversed(dicionario)))["b", "a"]
update(outro)Atualiza o dicionário com outro mapeamento.dicionario.update({"a": 1.0, "d": 4}){"a": 1.0, "b": 2, "d": 4}
copy()Retorna uma cópia rasa do dicionário.copia = dicionario.copy()

print(copia)

{"a": 1.0, "b": 2, "d": 4}

Integrando conjuntos e dicionários

Vamos entender como integrar conjuntos e dicionários? Para exemplificar, vamos criar um dicionário de estoque com duas chaves, "frutas" e "verduras", onde cada chave tem um conjunto associado.

estoque = {
  "frutas": {"maça", "uva"},
  "verduras": {"cenoura", "alface"}
}

Para acessar ou modificar itens nesse dicionário, utilizamos a estrutura dicionario[chave] seguida dos métodos de conjunto, como add() para adicionar elementos ou discard() para remover.

estoque["frutas"].add("morango") 
estoque["verduras"].discard("alface")

print(estoque)
# Saída: {'frutas: {'maça', 'morango', 'uva'}, 'verduras': {'cenoura'}}

Nesse exemplo, adicionamos o morango ao estoque de frutas e retiramos a alface do estoque de verduras.

Conclusão

Agora que aprendemos a utilizar essas estruturas, é importante praticar os conhecimentos adquiridos nas atividades do curso. Em caso de dúvidas, você pode contar com a comunidade do fórum e do Discord da Alura.

Lembre-se também de compartilhar seus conhecimentos nas redes sociais utilizando a hashtag #aprendizadoalura. Até a próxima!

Sobre o curso Praticando Python: conjuntos e dicionários

O curso Praticando Python: conjuntos e dicionários possui 11 minutos de vídeos, em um total de 14 atividades. Gostou? Conheça nossos outros cursos de Python em Programação, ou leia nossos artigos de Programação.

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

Aprenda Python acessando integralmente esse e outros cursos, comece hoje!

Conheça os Planos para Empresas