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

Na programação Python, os dicionários são incrivelmente versáteis, permitindo que você armazene dados em pares de valores-chave para gerenciamento e acesso eficientes. Se você é novo no Python, é importante entender como manipular esses dicionários, pois isso melhorará muito a forma como você lida com os dados em vários aplicativos. Se você estiver definindo configurações, gerenciando conjuntos de dados complexos ou simplesmente armazenando dados para consulta rápida, os dicionários são a sua resposta.

Uma das principais operações que você precisará realizar com frequência é acrescentar elementos a um dicionário. Este artigo guiará você por diferentes métodos para acrescentar itens a um dicionário em Python, desde a notação básica de colchetes até técnicas mais avançadas, como o uso do método update() e o operador de mesclagem. 

Se você é novo no conceito de dicionários em Python, considere ler também nosso Tutorial de dicionários em Python, que é um ótimo recurso para aprender sobre pares de valores-chave e outras ideias fundamentais para dicionários. Além disso, você pode achar nossa Folha de dicas de introdução ao Python útil como referência rápida se precisar relembrar a sintaxe e as funções do Python.

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

Se você estiver procurando uma solução rápida para acrescentar 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 de Alice na chave 'person_1', alterando seu city para 'Los Angeles' e adicionando um novo detalhe age: 30. Ele também adiciona uma nova pessoa, Bob, sob a chave 'person_2'.

Entendendo os dicionários do Python

Para começar, podemos discutir os dicionários do 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 é exclusiva e mapeia para um valor, que pode ser de qualquer tipo de dados (como strings, inteiros, listas ou até mesmo outros dicionários). Essa estrutura permite a recuperação, adição e modificação de 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 seus valores correspondentes.

Estrutura de um dicionário Python

Os dicionários são coleções não ordenadas, o que significa que os itens não têm uma ordem definida. No entanto, a partir do Python 3.7, os dicionários mantêm a ordem de inserção, o que pode ser útil em vários aplicativos. Aqui está um exemplo mais detalhado para ilustrar a estrutura:

# 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 contém vários tipos de dados, incluindo uma lista ('skills' ) e outro dicionário ('address'). Isso demonstra como os dicionários podem ser usados para armazenar e organizar estruturas de dados complexas.

Agora que já abordamos os conceitos básicos, vamos explorar os vários métodos para acrescentar elementos a um dicionário com mais detalhes.

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

Acrescentar elementos a um dicionário é uma tarefa comum em Python, e há vários métodos para fazer isso, cada um com seus próprios casos de uso e vantagens. Vamos examiná-las uma a uma.

Usando a notação de colchetes

A maneira mais direta de adicionar um único par chave-valor a um dicionário é usar a notação de colchetes. Esse método é simples e eficiente para adicionar elementos individuais. Aqui está a sintaxe do site:

dictionary[key] = value

Aqui está um exemplo usando a notação de 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, seu valor será atualizado.

Quando você usa a notação de colchetes para adicionar uma chave que já existe no dicionário, o valor associado a essa chave é atualizado. Isso pode ser tanto um recurso quanto uma ressalva, dependendo de suas necessidades. Aqui está um exemplo que demonstra como lidar com chaves existentes:

# 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 que você adicione vários pares de valores-chave a um dicionário de uma só vez. Ele pode aceitar outro dicionário ou um iterável de pares de valores-chave. Aqui está a sintaxeyntax:

dictionary.update(other)

Aqui está 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 de valores-chave. Aqui está 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() é particularmente útil quando você precisa atualizar o dicionário com várias entradas novas simultaneamente. Se uma chave já existir, seu valor será atualizado.

Usando o método .setdefault()

O método.setdefault() é usado para adicionar um par chave-valor a um dicionário somente se a chave ainda não existir. Se a chave existir, ele retornará o valor existente. Aqui está a sintaxeyntax:

dictionary.setdefault(key, default_value)

Aqui está 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. Ao tentar adicionar a chave 'age', você não altera o valor existente 25 porque a chave já existe.

Essa abordagem é adequada quando você precisa garantir que uma chave tenha um valor padrão se ela não existir. Ele também pode ser usado quando você deseja adicionar novos pares de valores-chave sem substituir os existentes.

Usando o construtor dict()

Você também pode criar um novo dicionário com pares de valores-chave adicionais usando o construtordict(). Essa abordagem é útil quando você deseja criar um novo dicionário com base em um dicionário existente. Aqui está a sintaxeyntax:

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 de valores-chave originais de my_dict e os pares de valores-chave adicionais 'city': 'New York' e 'email': 'alice@example.com'.

Essa abordagem é boa quando você deseja criar um novo dicionário combinando dicionários existentes e pares de valores-chave adicionais. Ele também pode ser usado quando você precisa criar um novo dicionário com algumas modificações, mantendo o dicionário original inalterado.

Tabela de comparação

Aqui está uma tabela de referência rápida para os métodos que abordamos em nosso tutorial:

Técnicas avançadas para anexar dicionários em Python

Compreender os conceitos básicos da manipulação de dicionários é essencial, mas para que você realmente domine os dicionários em Python, é importante explorar algumas técnicas avançadas. Esses métodos aumentarão sua capacidade de gerenciar e manipular dicionários com eficiência em cenários mais complexos.

Anexar a listas em um dicionário

Geralmente, os dicionários são usados para armazenar listas como valores. Acrescentar elementos a essas listas requer uma abordagem ligeiramente diferente. Veja como você pode fazer isso usando .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']. Ao usar o método .append(), adicionamos 'cherry' à lista. Essa técnica é particularmente útil ao gerenciar coleções de itens em um único dicionário.

Combinação de dicionários com o operador de mesclagem

O Python 3.9 introduziu o operador de mesclagem (|) para combinar dicionários. Esse operador permite que você mescle 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 mesclados em um novo dicionário merged_dictionary. O operador de mesclagem (| ) combina os pares de valores-chave de ambos os dicionários, tornando-o um método rápido e conveniente para mesclar dicionários.

Usando o operador de atualização

Para atualizações in-place, o Python 3.9 também introduziu o operador update |=. Esse operador permite que você atualize o dicionário original com os pares de valores-chave 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 operadorupdate |= atualiza first_dictionary com o conteúdo de second_dictionary no lugar. Isso significa que o site first_dictionary é modificado diretamente. Esse método é particularmente útil quando você precisa atualizar um dicionário existente sem criar um novo.

Conclusão

Neste artigo, aprendemos sobre os dicionários do Python e os métodos para anexar pares de valores-chave. Começamos com técnicas fundamentais, como o uso de notação de colchetes e o método .update(), que é essencial para atualizações rápidas e diretas. Em seguida, passamos a técnicas mais avançadas, incluindo o acréscimo de listas em dicionários, a fusão de dicionários com o operador de fusão (| ) e a realização de atualizações no local com o operador de atualização |=. Esses métodos oferecem ferramentas poderosas para gerenciar estruturas de dados complexas e realizar operações eficientes.

Há alguns de nossos recursos que você pode consultar para aumentar sua experiência em Python. Você pode conferir o curso Introduction to Python, que é um excelente ponto de partida, pois fornece uma base sólida dos fundamentos do Python com foco em aplicativos de ciência de dados. O programa de habilidades em programação Python também oferece um currículo abrangente que leva você do iniciante ao programador proficiente.

Você também pode se dedicar à programação em Python em nosso programa Python Developer. Ele oferece uma ampla cobertura de técnicas e construções de programação mais complexas.