Anexar ao dicionário Python: Como adicionar pares de chave-valor

Na programação Python, os dicionários são super versáteis, permitindo que você guarde dados em pares de chave-valor para gerenciamento e acesso eficientes. Se você é novo no Python, é importante entender como manipular esses dicionários, pois isso vai melhorar muito a forma como você lida com dados em várias aplicações. Se você está configurando ajustes, gerenciando conjuntos de dados complexos ou só armazenando dados para uma consulta rápida, os dicionários são a resposta.

Uma das principais operações que você vai precisar fazer com frequência é adicionar elementos a um dicionário. Este artigo vai te mostrar diferentes maneiras de adicionar itens a um dicionário em Python, desde a notação básica com colchetes até técnicas mais avançadas, como usar o método update() e o operador de mesclagem. 

Se você ainda não conhece o conceito de dicionários em Python, dá uma olhada no nosso Tutorial de Dicionários Python ou no Tutorial de Compreensão de Dicionários Python, que são ótimos recursos para aprender sobre pares chave-valor e outras ideias fundamentais para dicionários. Além disso, você pode achar útil a nossa Folha de Referência Rápida para Iniciantes em Python como uma referência rápida se precisar refrescar a memória sobre a sintaxe e as funções do Python.

Resposta rápida: Como adicionar algo a um dicionário em Python

Se você está procurando uma solução rápida para adicionar elementos a um dicionário Python, o método update() é um dos métodos mais comuns e fáceis de usar:

# Initial dictionary with information for one person
people_info = {
    'person_1': {
        'name': 'Alice',
        'city': 'New York'
    }
}

# Updating Alice's information and adding another person
people_info.update({
    'person_1': {
        'name': 'Alice',
        'city': 'Los Angeles',  # Updated city
        'age': 30               # Added new detail
    },
    'person_2': {
        'name': 'Bob',
        'city': 'San Francisco'
    }
})

print(people_info)

# {
#     'person_1': {'name': 'Alice', 'city': 'Los Angeles', 'age': 30},
#     'person_2': {'name': 'Bob', 'city': 'San Francisco'}
# }

Neste exemplo, o método update() atualiza as informações da Alice sob a chave 'person_1', mudando seu city para 'Los Angeles' e adicionando um novo detalhe age: 30. Também adiciona uma nova pessoa, Bob, com a chave 'person_2'.

Entendendo os dicionários Python

Pra começar, vamos falar sobre os dicionários Python e por que eles são tão importantes na programação.

O que é um dicionário Python?

Um dicionário em Python é uma coleção de pares chave-valor. Cada chave em um dicionário é única e mapeia um valor, que pode ser de qualquer tipo de dados (como strings, inteiros, listas ou até mesmo outros dicionários). Essa estrutura permite recuperar, adicionar e modificar dados. Aqui está um exemplo simples de um dicionário Python:

# Example of a dictionary
person = {
    'name': 'Alice',
    'age': 25,
    'city': 'New York'
}

# Accessing a value
print(person['name'])  # Output: Alice

Neste exemplo, 'name', 'age' e 'city' são chaves, e 'Alice', 25 e 'New York' são os valores correspondentes.

Estrutura de um dicionário Python

Os dicionários são coleções sem ordem, o que significa que os itens não têm uma ordem definida. Mas, a partir do Python 3.7, os dicionários mantêm a ordem de inserção, o que pode ser útil em várias aplicações. Aqui vai um exemplo mais detalhado pra mostrar como funciona:

# A more complex dictionary
employee = {
    'id': 101,
    'name': 'John Doe',
    'age': 30,
    'department': 'Engineering',
    'skills': ['Python', 'Machine Learning', 'Data Analysis'],
    'address': {
        'street': '123 Main St',
        'city': 'San Francisco',
        'state': 'CA',
        'zip': '94105'
    }
}

# Accessing nested data
print(employee['skills'][1])  # Output: Machine Learning
print(employee['address']['city'])  # Output: San Francisco

Neste exemplo, o dicionáriode funcionários tem vários tipos de dados, incluindo uma lista ('skills') e outro dicionário ('address'). Isso mostra como os dicionários podem ser usados pra guardar e organizar estruturas de dados complexas.

Agora que já falamos sobre o básico, vamos ver melhor os vários jeitos de adicionar elementos a um dicionário.

Métodos para adicionar elementos a um dicionário em Python

Adicionar elementos a um dicionário é uma tarefa comum em Python, e tem vários métodos pra fazer isso, cada um com seus casos de uso e vantagens. Vamos ver um por um.

Usando a notação entre colchetes

A maneira mais fácil de adicionar um único par chave-valor a um dicionário é usando a notação de colchetes. Esse jeito é simples e eficiente pra adicionar elementos individuais. Aqui está asintaxe dos:

dictionary[key] = value

Aqui vai um exemplo usando a notação com colchetes:

# Initialize a dictionary
my_dict = {'name': 'Alice', 'age': 25}

# Add a new key-value pair
my_dict['city'] = 'New York'

# Print the updated dictionary
print(my_dict)
# Output: {'name': 'Alice', 'age': 25, 'city': 'New York'}

Esse método adiciona ou atualiza diretamente o par chave-valor no dicionário. Se a chave já existir, o valor dela vai ser atualizado.

Quando você usa a notação entre colchetes para adicionar uma chave que já existe no dicionário, o valor associado a essa chave é atualizado. Isso pode ser uma vantagem ou uma desvantagem, dependendo do que você precisa. Aqui vai um exemplo que mostra como lidar com chaves que já existem:

# Initialize a dictionary
my_dict = {'name': 'Alice', 'age': 25}

# Add a new key-value pair
my_dict['city'] = 'New York'

# Update an existing key-value pair
my_dict['age'] = 30

# Print the updated dictionary
print(my_dict)
# Output: {'name': 'Alice', 'age': 30, 'city': 'New York'}

Neste exemplo, o valor da chave 'age' é atualizado de 25 para 30.

Usando o método .update()

O método.update() permite adicionar vários pares chave-valor a um dicionário de uma só vez. Ele aceita outro dicionário ou um iterável de pares chave-valor. Aqui está o ssintaxe:

dictionary.update(other)

Aqui vai um exemplo usando o método .update() método:

# Initialize a dictionary
my_dict = {'name': 'Alice', 'age': 25}

# Add new key-value pairs using update()
my_dict.update({'city': 'New York', 'email': 'alice@example.com'})

# Print the updated dictionary
print(my_dict)
# Output: {'name': 'Alice', 'age': 25, 'city': 'New York', 'email': 'alice@example.com'}

O método .update() também pode ser usado com um iterável de pares chave-valor. Aqui vai um exemplo:

# Initialize a dictionary
my_dict = {'name': 'Alice', 'age': 25}

# Add new key-value pairs using update() with an iterable
my_dict.update([('city', 'New York'), ('email', 'alice@example.com')])

# Print the updated dictionary
print(my_dict)
# Output: {'name': 'Alice', 'age': 25, 'city': 'New York', 'email': 'alice@example.com'}

O método .update() é super útil quando você precisa atualizar o dicionário com várias novas entradas ao mesmo tempo. Se uma chave já existir, o valor dela vai ser atualizado.

Usando o método .setdefault()

O método .setdefault() é usado pra adicionar um par chave-valor a um dicionário só se a chave ainda não existir. Se a chave existir, ele mostra o valor que já está lá. Aqui está o ssintaxe:

dictionary.setdefault(key, default_value)

Aqui tá um exemplo usando o método .setdefault() método:

# Initialize a dictionary
my_dict = {'name': 'Alice', 'age': 25}

# Use setdefault to add a new key-value pair
my_dict.setdefault('city', 'New York')

# Attempt to add an existing key
my_dict.setdefault('age', 30)

# Print the updated dictionary
print(my_dict)
# Output: {'name': 'Alice', 'age': 25, 'city': 'New York'}

Neste exemplo, o método .setdefault() adiciona a chave 'city' com o valor 'New York', porque ela ainda não existia no dicionário. Quando você tenta adicionar a chave 'age', ela não altera o valor existente 25, porque a chave já existe.

Essa abordagem é boa quando você precisa garantir que uma chave tenha um valor padrão se ela não existir. Também dá pra usar quando você quer adicionar novos pares de chave-valor sem sobrescrever os que já existem.

Usando o construtor dict()

Você também pode criar um novo dicionário com pares chave-valor adicionais usando o construtor dict(). Essa abordagem é útil quando você quer criar um novo dicionário com base em um já existente. Aqui está o ssintaxe:

new_dict = dict(existing_dict, key1=value1, key2=value2)

Aqui está um exemplo usando o dict() construtor:

# Initialize a dictionary
my_dict = {'name': 'Alice', 'age': 25}

# Create a new dictionary with additional key-value pairs
new_dict = dict(my_dict, city='New York', email='alice@example.com')

# Print the new dictionary
print(new_dict)
# Output: {'name': 'Alice', 'age': 25, 'city': 'New York', 'email': 'alice@example.com'}

Neste exemplo, o construtor dict() é usado para criar um novo dicionário new_dict que inclui os pares chave-valor originais de my_dict e os pares chave-valor adicionais 'city': 'New York' e 'email': 'alice@example.com'.

Essa abordagem é boa quando você quer criar um novo dicionário combinando dicionários já existentes e pares chave-valor adicionais. Também dá pra usar quando você precisa criar um novo dicionário com algumas mudanças, mas sem mexer no original.

Tabela comparativa

Aqui tá uma tabela rápida pra você dar uma olhada nos métodos que a gente falou no tutorial:

Técnicas avançadas para adicionar itens a dicionários em Python

Entender o básico sobre como mexer em dicionários é essencial, mas pra realmente dominar os dicionários em Python, é importante explorar algumas técnicas mais avançadas. Esses métodos vão te ajudar a gerenciar e mexer em dicionários de um jeito mais eficiente em situações mais complicadas.

Adicionando itens a listas dentro de um dicionário

Muitas vezes, os dicionários são usados pra guardar listas como valores. Para adicionar elementos a essas listas, é preciso fazer um pouco diferente. Veja como você pode fazer isso usando o .append():

# Initialize a dictionary with a list as a value
dictionary_w_list = {'fruits': ['apple', 'banana']}

# Append an element to the list within the dictionary
dictionary_w_list['fruits'].append('cherry')

# Print the updated dictionary
print(dictionary_w_list)
# Output: {'fruits': ['apple', 'banana', 'cherry']}

Neste exemplo, começamos com dictionary_w_list, onde a chave 'fruits' mapeia para uma lista ['apple', 'banana']. Usando o método .append(), a gente adiciona 'cherry' à lista. Essa técnica é super útil pra gerenciar coleções de itens dentro de um único dicionário.

Combinando dicionários com o operador de mesclagem

O Python 3.9 trouxe o operador merge (|) pra juntar dicionários. Esse operador te deixa juntar dois dicionários em um novo sem esforço:

# Initialize two dictionaries
first_dictionary = {'name': 'Alice', 'age': 25}
second_dictionary = {'city': 'New York', 'email': 'alice@example.com'}

# Merge the dictionaries using the merge operator
merged_dictionary = first_dictionary | second_dictionary

# Print the merged dictionary
print(merged_dictionary)
# Output: {'name': 'Alice', 'age': 25, 'city': 'New York', 'email': 'alice@example.com'}

Neste exemplo, first_dictionary e second_dictionary são juntados num novo dicionário merged_dictionary. O operador merge (|) junta os pares chave-valor dos dois dicionários, sendo um jeito rápido e prático de juntar dicionários.

Usando o operador de atualização

Para atualizações no local, o Python 3.9 também trouxe o operador de atualização |=. Esse operador te deixa atualizar o dicionário original com os pares chave-valor de outro dicionário.

# Initialize two dictionaries
first_dictionary = {'name': 'Alice', 'age': 25}
second_dictionary = {'city': 'New York', 'email': 'alice@example.com'}

# Update dict1 in-place using the update |= operator
first_dictionary |= second_dictionary

# Print the updated dictionary
print(first_dictionary)
# Output: {'name': 'Alice', 'age': 25, 'city': 'New York', 'email': 'alice@example.com'}

Aqui, o operadorde atualização |= atualiza first_dictionary com o conteúdo de second_dictionary no lugar. Isso quer dizer que o arquivo first_dictionary foi alterado diretamente. Esse método é bem útil quando você precisa atualizar um dicionário que já existe sem precisar criar um novo.

Conclusão

Neste artigo, a gente aprendeu sobre os dicionários Python e os métodos para adicionar pares chave-valor. Começamos com técnicas básicas, como usar a notação de colchetes e o método .update(), que é essencial para atualizações rápidas e diretas. Depois, a gente passou pra técnicas mais avançadas, como adicionar itens a listas dentro de dicionários, juntar dicionários com o operador de junção (|) e fazer atualizações no lugar com o operador de atualização ( |= ). Esses métodos são ferramentas poderosas pra gerenciar estruturas de dados complexas e fazer operações eficientes.

Tem alguns recursos que você pode conferir pra melhorar seus conhecimentos em Python. Você pode conferir o curso Introdução ao Python, que é um excelente ponto de partida, pois oferece uma base sólida nos fundamentos do Python com foco em aplicações de ciência de dados. O programa de habilidades em programação Python também oferece um currículo completo que leva você do nível iniciante ao avançado.

Nosso programa de carreira para desenvolvedores Python também foi feito pra quem quer dar uma olhada na programação Python. Ele oferece uma cobertura bem completa sobre construções e técnicas de programação mais complexas.