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.
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])
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()
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étodo | Conceito | Exemplo | Saída |
---|---|---|---|
in | Verifica 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) | True |
not in | Verifica 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) | False |
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étodo | Conceito | Exemplo | Conjunto 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}
eb = {3, 4, 5}
:
Método | Conceito | Exemplo | Saí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}
eb = {1, 2, 3, 4}
:
Método | Conceito | Exemplo | Saída |
---|---|---|---|
issubset(set2) ou (<=) | Verifica se um conjunto é subconjunto de outro. | a.issubset(b) ou a <= b | True |
issuperset(set2) ou (>=) | Verifica se um conjunto é superconjunto de outro. | b.issuperset(a) ou a >= b | True |
isdisjoint(set2) | Verifica se os conjuntos não têm elementos em comum. | c = {5, 6, 7} | 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() | {1, 2} |
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)
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()
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}
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"}
}
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étodo | Conceito | Exemplo | Saída |
---|---|---|---|
nome_dicionario[chave] | Acessar um valor por uma chave. | dic["nome"] | Ana |
nome_dicionario[chave] = valor | Atribuir 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étodo | Conceito | Exemplo | Saída |
---|---|---|---|
in | Verifica se uma chave está presente no dicionário. Retorna True se a chave existir e False caso contrário. | print("nome" in dic) | True |
not in | Verifica 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 |
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étodo | Conceito | Exemplo | Saí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étodo | Conceito | Exemplo | Saída |
---|---|---|---|
get(chave, padrão=None) | Obtém um valor sem erro se a chave não existir. | dicionario.get("nome") | Ana |
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) | ["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étodo | Conceito | Exemplo | Saí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() | {"a": 1.0, "b": 2, "d": 4} |
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.
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!
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:
Impulsione a sua carreira com os melhores cursos e faça parte da maior comunidade tech.
1 ano de Alura
Assine o PLUS e garanta:
Formações com mais de 1500 cursos atualizados e novos lançamentos semanais, em Programação, Inteligência Artificial, Front-end, UX & Design, Data Science, Mobile, DevOps e Inovação & Gestão.
A cada curso ou formação concluído, um novo certificado para turbinar seu currículo e LinkedIn.
No Discord, você tem acesso a eventos exclusivos, grupos de estudos e mentorias com especialistas de diferentes áreas.
Faça parte da maior comunidade Dev do país e crie conexões com mais de 120 mil pessoas no Discord.
Acesso ilimitado ao catálogo de Imersões da Alura para praticar conhecimentos em diferentes áreas.
Explore um universo de possibilidades na palma da sua mão. Baixe as aulas para assistir offline, onde e quando quiser.
Acelere o seu aprendizado com a IA da Alura e prepare-se para o mercado internacional.
1 ano de Alura
Todos os benefícios do PLUS e mais vantagens exclusivas:
Luri é nossa inteligência artificial que tira dúvidas, dá exemplos práticos, corrige exercícios e ajuda a mergulhar ainda mais durante as aulas. Você pode conversar com a Luri até 100 mensagens por semana.
Aprenda um novo idioma e expanda seus horizontes profissionais. Cursos de Inglês, Espanhol e Inglês para Devs, 100% focado em tecnologia.
Transforme a sua jornada com benefícios exclusivos e evolua ainda mais na sua carreira.
1 ano de Alura
Todos os benefícios do PRO e mais vantagens exclusivas:
Mensagens ilimitadas para estudar com a Luri, a IA da Alura, disponível 24hs para tirar suas dúvidas, dar exemplos práticos, corrigir exercícios e impulsionar seus estudos.
Envie imagens para a Luri e ela te ajuda a solucionar problemas, identificar erros, esclarecer gráficos, analisar design e muito mais.
Escolha os ebooks da Casa do Código, a editora da Alura, que apoiarão a sua jornada de aprendizado para sempre.