Dicionários e conjuntos em Python

Um dicionário armazena pares: uma chave identifica um item, e seu valor contém a informação desejada. Uma lista de contatos é um modelo útil: um nome leva a um número de telefone. Uma consulta em dicionário usa uma chave, mesmo quando essa chave é um número.

Escreva os pares

ages = {"Ana": 31, "Ben": 27, "Cara": 35}
print(ages["Ben"])
print(len(ages))

Isso imprime 27 e depois 3. Os dois-pontos ligam cada chave a seu valor; as vírgulas separam os pares. len conta os pares. Tanto {} quanto dict() criam um dicionário vazio.

Cada chave aparece apenas uma vez. Em {"a": 1, "b": 2, "a": 3}, o valor posterior de "a" substitui o anterior, restando {'a': 3, 'b': 2}. Duas chaves diferentes podem ter o mesmo valor: {"Ana": "blue", "Ben": "blue"} continua tendo dois itens.

Crie a partir de outros dados

Escolha a forma que corresponde à entrada:

colors = dict(red=1, blue=2)
coordinates = dict([("x", 10), ("y", 20)])
labels = dict(zip(["a", "b", "c"], [1, 2, 3]))

A primeira forma cria chaves do tipo string a partir dos nomes dos argumentos. A segunda lê uma sequência de pares de dois itens. A terceira forma pares com elementos correspondentes de duas listas, produzindo {'a': 1, 'b': 2, 'c': 3}. As strings na primeira forma são 'red' e 'blue', não consultas a variáveis.

Escolha chaves utilizáveis

As chaves de dicionário devem ser hasháveis. Strings e números funcionam, assim como tuplas formadas inteiramente por itens hasháveis. Listas, dicionários e conjuntos comuns não funcionam como chaves. Para uma localização, use (2, 3), uma tupla, em vez de [2, 3], uma lista:

board = {(0, 0): "start", (2, 3): "treasure"}
print(board[(2, 3)])

Isso imprime treasure. Os parênteses fazem do par de coordenadas uma única chave. Uma tupla que contém uma lista ainda viola a regra de hashabilidade. Valores de dicionário não têm essa restrição: um valor pode ser uma lista, outro dicionário ou qualquer outro tipo.

Chaves numéricas iguais se referem à mesma entrada. Como 1, 1.0 e True são considerados iguais na comparação, {1: "one", 1.0: "float one"} contém um par, com o valor 'float one'. A string "1" é uma chave diferente do número 1.

Distinga ordem de identidade

Desde o Python 3.7, dicionários preservam a ordem de inserção. As idades acima aparecem como Ana, Ben, Cara quando impressas ou percorridas. Elas continuam tendo chaves, não posições de lista: ages[0] procura a chave 0 e lança KeyError: 0.

Dicionários são mutáveis. Após backup = ages, ambos os nomes se referem ao mesmo dicionário. Definir backup["Ana"] = 32 também altera o valor acessado por ages. Para copiar o dicionário externo, escreva backup = ages.copy() ou backup = dict(ages). Dicionários externos separados ainda podem compartilhar listas e dicionários aninhados.

Uma consulta deve corresponder ao que uma chave ausente significa no seu programa. Às vezes ela indica um erro. Às vezes é normal, como no caso de um produto que ainda não foi contado. O Python oferece formas diferentes de tratar esses casos.

Leia um valor existente

stock = {"apples": 12, "pears": 0, "plums": 7}
print(stock["plums"])

A consulta com colchetes retorna 7. As chaves devem corresponder exatamente: "Plums" é diferente de "plums". Ler stock["kiwis"] lança KeyError: 'kiwis', pois essa chave está ausente. A consulta não fornece um valor vazio nem uma contagem igual a zero.

Use essa consulta direta quando uma chave for obrigatória. Nesse caso, um erro chama a atenção para dados incompletos ou um erro de digitação no ponto em que ocorre.

Verifique se uma chave existe

A expressão key in stock testa se uma chave existe. "pears" in stock é True, embora seu valor armazenado seja zero. "kiwis" not in stock também é True.

item = "kiwis"
if item in stock:
    print(stock[item])
else:
    print("No stock record for", item)

Aqui, a chave ausente leva a uma mensagem. A consulta ocorre apenas no ramo em que a chave existe.

O teste de pertencimento em um dicionário procura nas chaves. 12 in stock é False; para perguntar se algum item tem o valor armazenado 12, escreva 12 in stock.values(). A coleção colocada após in determina onde a busca é feita.

Leia com um valor padrão

stock.get("kiwis") retorna None sem lançar KeyError. Forneça um segundo argumento para escolher outro valor padrão: stock.get("kiwis", 0) retorna 0. Nenhuma das chamadas insere um novo item. Após ambas, o dicionário ainda contém apenas maçãs, peras e ameixas.

O valor padrão substitui uma consulta a uma chave ausente, não um valor armazenado. stock.get("pears", 99) retorna 0, pois peras já tem um valor.

Não confunda zero com ausência

if stock.get("pears"): verifica o valor lógico do resultado. Zero é falso, então esse ramo é ignorado. O mesmo teste também ignora uma chave ausente cuja consulta retorna None. Para distinguir esses casos, teste diretamente o pertencimento da chave.

Processe um pedido inteiro

prices = {"coffee": 3.5, "tea": 2.75}
order = ["tea", "coffee", "tea", "soda"]
total = 0
for item in order:
    if item in prices:
        total += prices[item]
    else:
        print("No price for", item)
print(total)

O primeiro chá leva o total a 2,75, o café o leva a 6,25 e o segundo chá o leva a 9,0. O refrigerante produz a mensagem No price for soda e não acrescenta nada. Uma consulta direta a cada passagem falharia no refrigerante; usar silenciosamente um preço padrão igual a zero esconderia o preço ausente. O ramo separado torna essa informação ausente visível.

Atualizações de dicionário usam chaves para identificar o que muda. Atribuir um valor pode adicionar um novo par ou substituir um valor antigo. Remover um par também pode retornar informações necessárias, como a quantidade retirada de um estoque.

Adicione e substitua

scores = {"Ana": 8}
scores["Ben"] = 6
scores["Ana"] = 9
scores["Ben"] += 2
print(scores)

O resultado é {'Ana': 9, 'Ben': 8}. Ben é adicionado, Ana é atualizada e, depois, a pontuação existente de Ben aumenta. A linha com += primeiro lê o valor antigo, então lança KeyError para uma chave ausente. Dicionários não têm o método append.

Combine dicionários

update copia pares para um dicionário existente. Com essas pontuações, scores.update({"Ben": 7, "Cara": 10}) altera a pontuação de Ben para 7 e adiciona Cara com 10.

Desde o Python 3.9, o operador de mesclagem pode criar um novo dicionário:

left = {"x": 1, "y": 2}
right = {"y": 5, "z": 3}
merged = left | right
print(merged)

Isso imprime {'x': 1, 'y': 5, 'z': 3}. O lado direito prevalece para uma chave comum. left permanece inalterado; left |= right o atualizaria no próprio objeto.

update() retorna None. Escrever scores = scores.update(new_scores) altera o dicionário antigo e depois faz scores se referir a None. Chame update em uma linha própria. Atribua o resultado de left | right quando quiser um novo dicionário mesclado.

Remova pares

Para {"a": 1, "b": 2, "c": 3}, popitem() retorna ('c', 3). Isso usa a ordem de inserção, não a ordem alfabética nem o maior valor.

Acompanhe uma alteração no estoque

inventory = {"pens": 10, "pads": 4}
inventory["pens"] -= 3
inventory["clips"] = 50
removed = inventory.pop("pads")

A venda deixa 7 canetas. Adicionar clipes cria uma nova chave. Remover blocos armazena 4 em removed, deixando {'pens': 7, 'clips': 50}. O retorno de pop permite que o programa use a quantidade removida depois que o par foi retirado.

Insira apenas quando estiver ausente

setdefault(key, default) retorna o valor existente ou insere e retorna o valor padrão quando a chave está ausente. Para stock = {"apples": 12, "pears": 0, "plums": 7}, stock.setdefault("kiwis", 0) insere kiwis e retorna 0. stock.setdefault("apples", 99) retorna 12 e deixa maçãs inalteradas. Essa inserção é a diferença em relação a get.

Atualizar uma chave existente mantém sua posição. Começando com {"a": 1, "b": 2, "c": 3}, definir d["a"] = 10 mantém "a" em primeiro lugar. Excluir "a" e inseri-la novamente a coloca depois de "c". Um valor substituto e um par recém-inserido afetam a ordem de maneiras diferentes.

Escolha um laço que forneça a parte necessária de cada par. Um dicionário usado diretamente fornece chaves. Suas visões podem fornecer valores ou pares inteiros, para que você não precise recuperar informações que o laço poderia fornecer diretamente.

Percorra chaves, valores ou pares

temps = {"Mon": 68, "Tue": 75, "Wed": 71}
for day, temp in temps.items():
    print(day, temp)

As temperaturas estão em graus Fahrenheit. Isso imprime Mon 68, Tue 75 e Wed 71 em linhas separadas, na ordem de inserção. Cada item é uma tupla de dois elementos que o laço desempacota em day e temp.

Com for day in temps:, use temps[day] dentro do laço quando precisar do valor correspondente. Se o programa precisar das duas partes em cada passagem, .items() geralmente expressa a tarefa com mais clareza.

Entenda as visões

keys(), values() e items() retornam visões, que refletem alterações posteriores em seu dicionário. Elas não são listas e não têm indexação por posição. temps.keys()[0] lança TypeError. Converta para uma lista quando precisar de uma cópia do estado atual com posições: list(temps) produz ['Mon', 'Tue', 'Wed'].

Calcule um total ou encontre uma chave correspondente

sum(temps.values()) retorna 214, e dividir por len(temps) produz uma média de aproximadamente 71,33. max(temps.values()) retorna 75. Para encontrar o dia que tem esse valor, escreva max(temps, key=temps.get), que retorna 'Tue'.

O argumento key= fornece uma função usada para comparação. Aqui, o Python percorre as chaves de dias e chama temps.get para cada uma, obtendo sua temperatura. Escreva o nome da função sem chamá-la: temps.get, não temps.get(). Se houver empate entre valores, max retorna a primeira chave que encontra.

Ordene um relatório

sorted(temps) retorna chaves em ordem alfabética. sorted(temps.items()) retorna pares ordenados por chave. Para ordenar as chaves de dias por temperatura, use sorted(temps, key=temps.get), produzindo ['Mon', 'Wed', 'Tue']. Adicione reverse=True para obter ['Tue', 'Wed', 'Mon']. Essas chamadas retornam listas; elas não reorganizam temps.

grades = {"Ana": 88, "Ben": 72, "Cara": 95}
passing = 0
for name, grade in grades.items():
    print(f"{name}: {grade}")
    if grade >= 75:
        passing += 1

O relatório imprime cada nome com sua nota. Ana e Cara atingem o valor limiar, então passing termina em 2.

Remova entradas sem interromper o percurso

Não adicione nem exclua chaves enquanto percorre diretamente um dicionário. Alterar seu tamanho pode lançar RuntimeError: dictionary changed size during iteration. Substituir um valor existente é permitido.

Para remover os dias mais frios, use for day in list(temps): e exclua temps[day] quando seu valor for menor que 70. O laço percorre uma lista separada de chaves, deixando {'Tue': 75, 'Wed': 71} no dicionário. Criar um novo dicionário filtrado é outra maneira de manter o percurso separado das alterações.

Um novo dicionário muitas vezes resulta de uma regra aplicada a dados existentes. Comece com um laço que você consiga explicar e depois use uma compreensão quando a mesma regra couber claramente em uma expressão.

Crie um par por vez

words = ["kiwi", "fig", "banana"]
lengths = {}
for word in words:
    lengths[word] = len(word)

Cada passagem escolhe uma palavra como chave e seu comprimento como valor. O resultado é {'kiwi': 4, 'fig': 3, 'banana': 6}. O dicionário é criado antes do laço para que os pares anteriores continuem disponíveis nas passagens posteriores.

Uma compreensão de dicionário expressa o mesmo trabalho:

lengths = {word: len(word) for word in words}

Leia a parte for para ver o que é percorrido e depois a expressão anterior a ela para ver qual par é produzido. Os dois-pontos separam a expressão da chave da expressão do valor. Sem esses dois-pontos, {word for word in words} cria um conjunto.

Mantenha alguns itens

Uma cláusula if filtra a entrada:

grades = {"Ana": 88, "Ben": 72, "Cara": 95}
high_grades = {
    name: grade
    for name, grade in grades.items()
    if grade >= 80
}

Ana e Cara passam no teste, produzindo {'Ana': 88, 'Cara': 95}. O par de Ben fica de fora. O dicionário de entrada permanece inalterado; o resultado contém apenas pares que atendem à condição.

Transforme valores

Uma compreensão pode manter os dias enquanto converte as temperaturas de Fahrenheit para Celsius:

temps = {"Mon": 68, "Tue": 75, "Wed": 71}
celsius = {
    day: round((f - 32) * 5 / 9, 1)
    for day, f in temps.items()
}

O resultado é {'Mon': 20.0, 'Tue': 23.9, 'Wed': 21.7}. Para terça-feira, subtrair 32 resulta em 43; multiplicar por 5 e dividir por 9 resulta em aproximadamente 23,89. round(..., 1) armazena 23,9. A chave permanece a mesma enquanto o valor muda.

Forme pares de listas com cuidado

dict(zip(names, scores)) forma pares com cada nome e a pontuação na mesma posição. zip para quando a entrada mais curta termina. Formar pares com ["Ana", "Ben", "Cara"] e [90, 85] produz {'Ana': 90, 'Ben': 85}. Nenhum erro informa que a pontuação de Cara está ausente, então verifique os comprimentos das entradas quando cada nome precisar ter uma pontuação.

Troque chaves e valores

favorites = {"Ana": "blue", "Ben": "red", "Cara": "blue"}
by_color = {color: name for name, color in favorites.items()}

O resultado é {'blue': 'Cara', 'red': 'Ben'}. Tanto Ana quanto Cara precisariam da mesma nova chave, então o par posterior de Cara substitui o de Ana. A inversão preserva todos os pares apenas quando os valores antigos são únicos e hasháveis. Um valor do tipo lista não pode se tornar uma chave de dicionário. Para manter vários nomes sob uma cor, armazene uma lista de nomes sob essa cor.

Use um laço comum quando a tarefa exigir várias instruções, mensagens ou verificações. Uma compreensão é útil porque torna uma regra curta visível; comprimir um procedimento maior nela torna a regra mais difícil de acompanhar.

Uma tabela de frequências responde quantas vezes cada item distinto ocorre. Suas chaves identificam os itens; seus valores são contadores. O dicionário cresce quando um novo item aparece, enquanto aparições posteriores aumentam uma contagem existente.

Rastreie um contador

counts = {}
for letter in "banana":
    if letter in counts:
        counts[letter] += 1
    else:
        counts[letter] = 1

A primeira letra cria 'b': 1. A seguinte cria 'a': 1 e depois vem 'n': 1. O próximo "a" aumenta sua contagem existente para 2. Após as duas últimas letras, o dicionário é {'b': 1, 'a': 3, 'n': 2}. Sua ordem registra quando cada letra apareceu pela primeira vez, não qual é a mais comum.

Use zero antes da primeira ocorrência

Os dois ramos podem se tornar uma atribuição:

counts = {}
for letter in "banana":
    counts[letter] = counts.get(letter, 0) + 1

O lado direito lê a contagem anterior, usando zero quando a chave está ausente, e depois adiciona um. O lado esquerdo armazena essa nova contagem. O próprio get não insere nada; a atribuição é que insere.

Usar apenas counts[letter] += 1 falha quando uma letra é nova. Mover counts = {} para dentro do laço causa outro problema: cada passagem apaga as contagens anteriores. Inicialize uma vez antes de processar os itens.

Decida o que conta como a mesma palavra

Em textos, maiúsculas, minúsculas e pontuação afetam as chaves. As strings "The" e "the" são diferentes, assim como "dog." e "dog". Limpe as formas antes de usá-las como chaves:

text = "The cat saw the dog. The dog ran."
counts = {}
for word in text.lower().split():
    word = word.strip(".,!?")
    counts[word] = counts.get(word, 0) + 1

Isso produz {'the': 3, 'cat': 1, 'saw': 1, 'dog': 2, 'ran': 1}. lower trata maiúsculas e minúsculas, split separa palavras nos caracteres em branco e strip remove os caracteres de pontuação listados das extremidades. Ele não remove pontuação do meio de uma palavra.

Encontre os itens mais comuns

Para essa tabela não vazia, max(counts, key=counts.get) retorna 'the'. Para encontrar as duas palavras mais comuns, use sorted(counts, key=counts.get, reverse=True)[:2], produzindo ['the', 'dog']. Contagens iguais mantêm sua ordem original na ordenação.

O padrão também conta números ou tuplas. Para os lançamentos [3, 6, 3, 1, 6, 3], ele cria {3: 3, 6: 2, 1: 1}. Um valor nunca observado não tem entrada. Leia-o com valor padrão zero quando isso for útil.

Reconheça o atalho da biblioteca

from collections import Counter
letter_counts = Counter("banana")
print(letter_counts.most_common(1))
print(letter_counts["z"])

Isso imprime [('a', 3)] e depois 0. A importação disponibiliza Counter da biblioteca padrão do Python. Um Counter é um dicionário projetado para contagens: suas chaves são itens hasháveis, e a consulta direta de um item ausente retorna zero. Suas contagens exibidas para essa entrada são Counter({'a': 3, 'n': 2, 'b': 1}).

Um dicionário pode armazenar um grupo inteiro sob cada chave. A chave nomeia a categoria, e uma lista contém os itens atribuídos a ela. Isso mantém todos os membros disponíveis para totais, médias ou relatórios posteriores.

Crie listas separadas para grupos

words = ["apple", "bean", "avocado", "beet", "corn"]
groups = {}
for word in words:
    first = word[0]
    if first not in groups:
        groups[first] = []
    groups[first].append(word)

Para "apple", o programa cria uma lista vazia sob "a" e acrescenta a palavra. "bean" inicia uma lista "b" separada. "avocado" entra na lista "a" existente. O resultado é {'a': ['apple', 'avocado'], 'b': ['bean', 'beet'], 'c': ['corn']}.

A lista vazia é criada apenas para um novo rótulo. Criá-la em cada passagem descartaria os membros anteriores desse grupo.

Simplifique a inicialização

groups.setdefault(word[0], []).append(word) realiza a mesma etapa de agrupamento. setdefault retorna a lista existente, se houver uma. Caso contrário, armazena a lista vazia fornecida e a retorna. O append seguinte altera essa lista retornada.

Outra opção cria listas automaticamente:

from collections import defaultdict
groups = defaultdict(list)
for word in words:
    groups[word[0]].append(word)

Passe list, a função que cria uma nova lista, sem parênteses. Na consulta a uma chave ausente, esse defaultdict cria e armazena uma nova lista vazia. Até mesmo uma leitura como groups["z"] insere essa chave ausente. Use "z" in groups quando quiser apenas verificar se um grupo existe.

Mantenha as listas independentes

groups = dict.fromkeys(["a", "b"], []) coloca a mesma lista sob ambas as chaves. Acrescentar 1 por meio de groups["a"] produz então {'a': [1], 'b': [1]}. As listas são compartilhadas, não copiadas.

Para começar com listas separadas, use {key: [] for key in keys}, setdefault com uma nova [] ou defaultdict(list). Cada nova categoria deve receber seu próprio objeto de lista.

Some valores por categoria

A contagem adiciona um por ocorrência. Um total por categoria adiciona o valor de cada item:

expenses = [("food", 12.5), ("travel", 30),
            ("food", 7.25), ("books", 18)]
totals = {}
for category, amount in expenses:
    totals[category] = totals.get(category, 0) + amount

Alimentação começa em 12,5 e depois recebe 7,25, terminando em 19,75. Viagem totaliza 30 e livros totalizam 18. Armazenar apenas amount substituiria o total anterior em vez de somar a ele.

Calcule a média ou remova duplicatas de um grupo

Para scores = {"A": [80, 90], "B": [70]}, percorra scores.items() e calcule sum(values) / len(values). O grupo A tem média 85,0; o grupo B tem média 70,0. Teste if values: antes de dividir para que um grupo vazio seja tratado separadamente.

Quando as repetições devem desaparecer dentro de cada grupo, use conjuntos como valores. tags.setdefault(post, set()).add(tag) cria um conjunto para uma nova publicação e adiciona sua etiqueta. Uma etiqueta repetida permanece como um elemento; uma lista manteria cada ocorrência.

Um registro reúne campos relacionados, como idade, área de estudo e notas de um estudante. Um dicionário aninhado armazena outro dicionário como valor. As chaves externas podem identificar registros, enquanto as internas identificam campos.

Leia um nível por vez

students = {
    "ana": {"age": 19, "major": "math", "grades": [88, 92]},
    "ben": {"age": 22, "major": "history", "grades": [75, 81, 79]},
}

students["ana"] fornece o dicionário de registro de Ana. Adicionar ["major"] lê sua área de estudo, então students["ana"]["major"] retorna 'math'. Para a nota mais recente de Ben, students["ben"]["grades"][-1] acessa o registro, depois sua lista e, então, o último elemento da lista, 79.

Cada consulta atua sobre o objeto retornado pela consulta anterior. A mesma sintaxe de colchetes pode significar uma chave de dicionário em um nível e uma posição de lista em outro.

Altere um campo ou adicione um registro

students["ana"]["age"] = 20
students["ben"]["email"] = "ben@example.com"
students["cara"] = {"age": 21, "major": "art", "grades": []}
students["cara"]["grades"].append(90)

As duas primeiras linhas alteram ou adicionam campos dentro de registros existentes. A terceira adiciona um registro inteiro sob um novo ID. A quarta acessa a lista de notas de Cara e acrescenta uma nota a ela.

Atribuir students["dev"]["age"] = 30 falha porque a consulta externa de "dev" ocorre primeiro e lança KeyError: 'dev'. Crie o registro antes de atribuir seus campos.

Para uma leitura opcional, students.get("dev", {}).get("age") retorna None. O primeiro valor padrão é um dicionário vazio, então o segundo get tem um dicionário para ler mesmo quando o registro está ausente. Para esses registros, cada valor externo é um dicionário.

Escolha uma estrutura adequada ao acesso

Uma lista de dicionários mantém as linhas em ordem:

rows = [{"name": "Ana", "city": "Austin"},
        {"name": "Ben", "city": "Denver"}]
print(rows[1]["city"])

Isso imprime Denver: primeiro o índice da lista, depois a chave do campo. Um dicionário de listas, como {"A": [80, 90], "B": [70]}, armazena vários valores por rótulo. Essas estruturas podem ser combinadas quando um registro precisa tanto de campos nomeados quanto de uma lista ordenada.

Quando nomes identificam linhas de forma única, crie by_name = {row["name"]: row for row in rows}. Então by_name["Ben"] encontra diretamente a linha de Ben. Os valores são os dicionários de linha existentes, então edições por meio desse índice também afetam essas linhas. Se nomes se repetirem, uma linha posterior substituirá uma anterior sob essa chave.

Copie dados aninhados de forma consciente

backup = students compartilha o dicionário inteiro. backup = students.copy() cria um dicionário externo separado, mas mantém os mesmos registros internos. Após essa cópia superficial, backup["ana"]["age"] = 99 também altera a idade de Ana em students.

import copy
independent = copy.deepcopy(students)
independent["ana"]["age"] = 25

Para esses dicionários e listas aninhados, a cópia profunda também cria objetos internos separados. Alterar a idade na cópia deixa a idade original inalterada. Use nomes de campo consistentes entre os registros para que o mesmo código de consulta funcione em cada um.

Processar dados aninhados significa acompanhar o nível alcançado pelo laço. Um laço externo escolhe um registro. Uma consulta a campo acessa um valor dentro desse registro, e um laço interno pode então percorrer os elementos de uma lista armazenada.

Resuma um registro por passagem

students = {
    "ana": {"major": "math", "grades": [88, 92]},
    "ben": {"major": "history", "grades": [75, 81, 79]},
    "cara": {"major": "art", "grades": []},
}
for name, info in students.items():
    grades = info["grades"]
    major = info["major"]
    if grades:
        average = sum(grades) / len(grades)
        print(f"{name}: {major}, average {average:.1f}")
    else:
        print(f"{name}: {major}, no grades")

As notas de Ana somam 180, então sua média é 90,0. O total de Ben é 235 em três notas, resultando em aproximadamente 78,33; o formato :.1f exibe 78,3. A lista de Cara está vazia, então o programa imprime cara: art, no grades sem dividir por zero.

Atribuir valores a grades e major dentro do laço faz cada nome receber os valores do registro atual. A média também pertence ao laço: ela deve ser calculada separadamente para cada estudante.

Leia campos opcionais

info.get("email", "no email") fornece texto para um campo opcional de e-mail. Uma consulta direta info["email"] lançaria KeyError para um registro sem esse campo. Um valor padrão deve ficar no nível em que o campo pode estar ausente. O get do dicionário externo procuraria IDs de estudantes, não campos de e-mail.

Selecione registros

math_students = []
for name, info in students.items():
    if info["major"] == "math":
        math_students.append(name)

Isso produz ['ana']. A condição lê um campo do registro atual; o valor acrescentado é a chave externa. Se o relatório precisasse de registros inteiros, poderia acrescentar info. Decida de qual tipo de resultado a próxima parte do programa precisa.

Percorra cada nota armazenada

count = 0
for info in students.values():
    for grade in info["grades"]:
        if grade > 80:
            count += 1

O laço interno percorre 88 e 92 de Ana, depois 75, 81 e 79 de Ben. A lista vazia de Cara não acrescenta passagens. Três notas são superiores a 80: 88, 92 e 81. A contagem é inicializada fora dos dois laços porque descreve todos os estudantes em conjunto. Reiniciá-la dentro do laço externo manteria apenas a contagem do último registro.

Conte registros por um campo

majors = {}
for info in students.values():
    major = info["major"]
    majors[major] = majors.get(major, 0) + 1

Cada registro acrescenta um à contagem de sua área de estudo. Apenas para Ana e Ben, o resultado é {'math': 1, 'history': 1}; incluir Cara adiciona 'art': 1. Para totalizar ou agrupar por outro campo, mantenha o laço externo de registros e altere o valor com que cada registro contribui.

Para relatórios legíveis, imprima uma linha formatada por registro em vez do dicionário aninhado inteiro. Em uma f-string, primeiro armazene um campo em uma variável, como acima, ou use o estilo oposto de aspas dentro das chaves, como em f"{name}: {info['major']}".

Um conjunto registra quais valores distintos estão presentes. Ele mantém cada elemento uma vez e não tem ordem garantida. Conjuntos são adequados para testes de pertencimento e para remover duplicatas quando o número de ocorrências não importa.

Crie um conjunto

colors = {"red", "green"}
numbers = set([3, 1, 3, 2, 1])
print(len(numbers))
print(sorted(numbers))

Isso imprime 3 e depois [1, 2, 3]. Entradas repetidas tornam-se um único elemento. Um conjunto vazio é set(); {} cria um dicionário vazio.

set("banana") percorre os caracteres da string, deixando as letras distintas "a", "b" e "n". {"banana"} fornece a string inteira como um único elemento. Assim como nas chaves de dicionário, valores numéricos iguais contam uma vez: {1, 1.0, True} tem um elemento.

Os elementos devem ser hasháveis. Números, strings e tuplas de valores hasháveis funcionam; listas, dicionários e conjuntos comuns não. Use (1, 2) como elemento de coordenadas em vez de [1, 2]. Um frozenset é um conjunto imutável e pode ser elemento de conjunto ou chave de dicionário.

Trabalhe sem posições

colors[0] lança TypeError porque um conjunto não tem posições. Sua ordem de impressão não é garantida, e elementos do tipo string podem ser impressos em outra ordem em uma execução diferente. sorted(colors) produz uma nova lista ordenada quando os elementos podem ser comparados. Isso não atribui uma ordem ao conjunto.

Altere os elementos

add("blue") adiciona uma string. update(["blue", "gold"]) adiciona duas strings. Usar update("blue") adiciona caracteres separados, pois uma string é iterável. Conjuntos não têm o método append.

Preserve as primeiras ocorrências quando necessário

list(set(items)) remove duplicatas, mas perde sua ordem original. Se as primeiras ocorrências importarem, use a ordem de inserção de dicionários:

items = [3, 1, 3, 2, 1]
unique = list(dict.fromkeys(items))
print(unique)

Isso imprime [3, 1, 2]. Os valores tornam-se chaves de dicionário, então cada um aparece uma vez na ordem em que foi encontrado pela primeira vez.

Você também pode deixar as funções explícitas:

seen = set()
unique = []
for item in items:
    if item not in seen:
        seen.add(item)
        unique.append(item)

O conjunto responde se um item já apareceu; a lista mantém as primeiras ocorrências em ordem. Ambas as formas exigem itens de entrada hasháveis.

Conte itens distintos ou verifique o pertencimento

Para as oito palavras em "the cat saw the dog the dog ran".split(), len(set(words)) é 5: the, cat, saw, dog e ran. Isso conta palavras diferentes, não suas frequências.

Um conjunto de remetentes bloqueados permite que sender in blocked responda se um endereço está presente. Para coleções grandes, testar o pertencimento em conjuntos e dicionários geralmente é muito mais rápido do que procurar em uma lista, um item por vez.

Operações de conjuntos expressam perguntas sobre o pertencimento a duas coleções. Use a operação que corresponde à pergunta: qualquer pessoa em uma das coleções, apenas membros compartilhados ou membros restantes após exclusões.

Entenda as quatro operações

Suponha que as matrículas nos cursos sejam:

python = {"Ana", "Ben", "Cara", "Dev"}
sql = {"Ben", "Dev", "Eli"}

A união inclui os cinco estudantes uma vez. A interseção mantém apenas os dois estudantes compartilhados. A diferença começa pelo conjunto à esquerda e exclui tudo que está no conjunto à direita. Inverter a diferença muda a pergunta: sql - python contém apenas Eli. A diferença simétrica mantém as duas partes sem sobreposição; ela equivale à união menos a interseção.

As formas nomeadas são python.union(sql), python.intersection(sql), python.difference(sql) e python.symmetric_difference(sql).

Teste uma relação

a <= b pergunta se cada membro de a pertence a b. Esse é o teste de subconjunto. a < b também exige que b tenha pelo menos um membro adicional, fazendo de a um subconjunto próprio. a >= b e a > b testam as relações correspondentes de superconjunto.

print({"Ben"} <= sql)
print(sql <= sql)
print(sql < sql)
print(python.isdisjoint(sql))

Isso imprime True, True, False e False. Um conjunto é subconjunto de si mesmo, mas não é subconjunto próprio de si mesmo. Conjuntos disjuntos não têm membros compartilhados; Python e SQL compartilham Ben e Dev. As formas de método issubset e issuperset também retornam resultados booleanos.

Mantenha resultados separados ou altere um conjunto

result = a | b cria um novo conjunto, deixando ambas as entradas inalteradas. As formas que operam no próprio objeto, a |= b, a &= b, a -= b e a ^= b, alteram a para a união, interseção, diferença ou diferença simétrica. Qualquer outro nome que se refira ao mesmo conjunto vê a alteração.

Métodos nomeados de conjuntos aceitam iteráveis como listas. python.union(["Fay"]) funciona. Os operadores comuns de conjuntos exigem operandos do tipo conjunto: {"a"} | ["b"] lança TypeError.

Use | para combinar conjuntos, não +. Distinga também & de and: {1, 2} and {3} retorna {3} porque o conjunto à esquerda é considerado verdadeiro. Isso não calcula os membros comuns.

Encontre requisitos ausentes

required = {"python", "sql", "git"}
skills = {"python", "excel", "git"}
missing = required - skills
extra = skills - required
qualified = required <= skills

O conjunto de habilidades ausentes contém "sql"; o conjunto de habilidades adicionais contém "excel". A interseção contém "git" e "python". qualified é False, pois pelo menos uma habilidade exigida está ausente. Uma pessoa candidata pode ter muitas habilidades e ainda falhar no teste de subconjunto: todos os elementos específicos exigidos devem estar presentes.

Escolha uma coleção de acordo com o trabalho que o programa deve fazer com ela. Ordem, repetições, consulta por nome e possibilidade de alteração são necessidades distintas. Um programa pode usar vários tipos de coleção porque diferentes partes de seus dados servem a tarefas diferentes.

Compare as coleções embutidas

Uma lista é adequada para uma sequência de eventos: a ordem importa, e o mesmo evento pode ocorrer mais de uma vez. Uma tupla é adequada para um grupo fixo de valores relacionados, como coordenadas. Uma tupla pode conter um objeto mutável, então suas posições fixas não tornam imutável todo objeto contido nela. Apenas uma tupla de itens hasháveis pode ser chave de dicionário ou elemento de conjunto.

Um dicionário é adequado para informações nomeadas: um ID leva a um registro ou um nome de produto leva a uma quantidade. Seus valores podem se repetir e ser coleções inteiras. Um conjunto é adequado para uma pergunta de pertencimento: o programa precisa saber se um ID está presente, não de um valor separado para ele.

Preserve as informações necessárias à tarefa

Converter [1, 2, 1] em um conjunto perde tanto a ocorrência repetida quanto a sequência. Isso é útil para uma lista de itens distintos, mas inadequado para um registro completo de eventos. Um dicionário como {"reader": True, "editor": True} muitas vezes pode se tornar {"reader", "editor"} quando os valores não trazem informações adicionais. Se cada função precisar de um nível de permissão, mantenha o dicionário.

A igualdade segue o significado de cada coleção. [1, 2] == [2, 1] é False, pois a ordem da sequência é diferente. {1, 2} == {2, 1} é True. Dicionários com pares chave-valor iguais são considerados iguais mesmo que as chaves tenham sido inseridas em ordens diferentes. Sua ordem de inserção afeta o percurso, não esse teste de igualdade.

Compare chaves de dicionários como conjuntos

store_a = {"pens": 10, "pads": 4, "ink": 2}
store_b = {"pads": 7, "clips": 30, "ink": 5}
common = store_a.keys() & store_b.keys()
only_a = store_a.keys() - store_b.keys()

As chaves comuns são "ink" e "pads"; only_a contém "pens". Esses são os produtos vendidos, independentemente de suas quantidades. As duas lojas têm quantidades diferentes de tinta, mas tinta ainda é uma chave compartilhada.

Visões de chaves de dicionário aceitam operações de conjuntos porque as chaves são únicas e hasháveis. Visões de valores não aceitam esses operadores: store_a.values() & {1} lança TypeError. É possível converter valores em um conjunto quando são hasháveis, mas isso descarta valores repetidos e responde a uma pergunta diferente da comparação de chaves de produtos.

Combine estruturas em um programa

Uma biblioteca pode usar um dicionário que associa IDs de livros a dicionários de registros, um conjunto de IDs atualmente emprestados e uma lista dos empréstimos de hoje em ordem de horário. Uma tupla como ("Dune", 1965) mantém juntos um título e um ano. O dicionário encontra os detalhes de um livro; o conjunto verifica a situação do empréstimo; a lista preserva o histórico do dia.