Python dictionary append: How one can add Key-value Pair?

Python is a well-liked programming language that gives a variety of built-in information constructions, together with lists, tuples, units, and dictionaries. Amongst these, dictionaries are one of the crucial generally used information constructions in Python because of their capability to retailer information in a key-value pair format.

Python dictionaries are a strong information construction that means that you can retailer and manipulate information in a key-value pair format. One widespread job when working with dictionaries is to append new values to an current dictionary. Whereas Python dictionaries wouldn’t have an append() technique like lists do, there are a number of methods so as to add new key-value pairs to a dictionary. On this weblog submit, we are going to discover a few of these strategies and focus on when to make use of every one. So, let’s dive in!

Dictionary in Python

A dictionary is a vital information sort in Python programming. It’s a assortment of knowledge values which can be unordered. Python dictionary is used to retailer objects during which every merchandise has a key-value pair. The dictionary is made up of those key-value pairs, and this makes the dictionary extra optimized. 

For instance –

Dict = {1: 'Studying', 2: 'For', 3: 'Life'}
print(Dict)

Right here, 

The colon is used to pair keys with the values.

The comma is used as a separator for the weather. 

The output is:

{1: ‘Learnings’, 2: ‘For’, 3: ‘Life’}

Python dictionary append is solely used so as to add key/worth to the prevailing dictionary. The dictionary objects are mutable. Not like different objects, the dictionary merely shops a key together with its worth. Subsequently, the mixture of a key and its subsequent worth represents a single factor within the Python dictionary.  

Restrictions on Key Dictionaries

Beneath are enlisted some restrictions on the important thing dictionaries –

• A given key seems solely as soon as in a dictionary. Duplicates of keys usually are not allowed. 
• It received’t make sense for those who map a selected key greater than as soon as. That is so as a result of the dictionary will map every key to its worth.
• In case of a duplication of a key, the final one will likely be thought of.
• If a secret’s specified a second time after the creation of a dictionary, then the second time will likely be thought of as it’s going to override the primary time.
• The important thing have to be immutable, which signifies that the information sort could be an integer, string, tuple, boolean, and so forth. Subsequently, lists or one other dictionary cannot be used as they’re changeable.  

How one can append a component to a key in a dictionary with Python?

Making a Dictionary

In Python, you possibly can create a dictionary simply utilizing fastened keys and values. The sequence of parts is positioned inside curly brackets, and key: values are separated by commas. It have to be famous that the worth of keys could be repeated however cannot have duplicates. Additionally, keys ought to have immutable information sorts corresponding to strings, tuples, or numbers. 

Right here’s an instance –

# Making a Dictionary
# with Integer Keys
Dict = {1: 'Studying', 2: 'For', 3: Life}
print("nDictionary with the usage of Integer Keys: ")
print(Dict)
  
# Making a Dictionary
# with Blended keys
Dict = {'Identify': ‘Nice Studying’, 1: [1, 2, 3, 4]}
print("nDictionary with the usage of Blended Keys: ")
print(Dict)

The output is :

Dictionary with the usage of Integer Keys: 

{1: ‘Studying’, 2: ‘For’, 3: ‘Life’}

Dictionary with the usage of Blended Keys: 

{‘Identify’: ‘GreatLearning’, 1: [1, 2, 3, 4]}

Dictionary with integer keys

Right here’s how one can create a dictionary utilizing the integer keys –

# creating the dictionary
dict_a = {1 : "India", 2 : "UK", 3 : "US", 4 : "Canada"}

# printing the dictionary
print("Dictionary 'dict_a' is...")
print(dict_a)

# printing the keys solely
print("Dictionary 'dict_a' keys...")
for x in dict_a:
    print(x)

# printing the values solely
print("Dictionary 'dict_a' values...")
for x in dict_a.values():
    print(x)

# printing the keys & values
print("Dictionary 'dict_a' keys & values...")
for x, y in dict_a.objects():
    print(x, ':', y)

The output is:

Dictionary ‘dict_a’ is…

{1: ‘India’, 2: ‘USA’, 3: ‘UK’, 4: ‘Canada’}

Dictionary ‘dict_a’ keys…

1

2

3

4

Dictionary ‘dict_a’ values…

India

USA

UK

Canada

Dictionary ‘dict_a’ keys & values…

1 : India

2 : UK

3 : US

4 : Canada

Accessing parts of a dictionary

Key names are used to entry parts of a dictionary. To entry the weather, you have to use sq. brackets ([‘key’]) with the important thing inside it. 

Right here’s an instance –

# Python program to display
# accessing a component from a dictionary
  
# Making a Dictionary
Dict = {1: 'Studying', 'identify': 'For', 3: 'Life'}
  
# accessing a component utilizing key
print("Accessing a component utilizing key:")
print(Dict['name'])
  
# accessing a component utilizing key
print("Accessing a component utilizing key:")
print(Dict[1])

The output is:

Accessing a component utilizing key:

For

Accessing a component utilizing key:

Life

Various technique 

There’s one other technique referred to as get() that’s used to entry parts from a dictionary. On this technique, the secret is accepted as an argument and returned with a worth. 

Right here’s an instance –

# Making a Dictionary
Dict = {1: 'Studying', 'identify': 'For', 3: 'Life'}
  
# accessing a component utilizing get()
# technique
print("Accessing a component utilizing get:")
print(Dict.get(3))

The output is:

Accessing a component utilizing get:

Life

Deleting factor(s) in a dictionary

You’ll be able to delete parts in a dictionary utilizing the ‘del’ key phrase.

The syntax is –

del dict['yourkey']  #It will take away the factor along with your key.

Use the next syntax to delete your complete dictionary –

del my_dict  # it will delete the dictionary with identify my_dict

One other various is to make use of the clear() technique. This technique helps to scrub the content material contained in the dictionary and empty it. The syntax is –

Allow us to verify an instance of the deletion of parts that lead to emptying your complete dictionary –

my_dict = {"username": "ABC", "electronic mail": "abc@gmail.com", "location":"Gurgaon"}
del my_dict['username']  # it's going to take away "username": "ABC" from my_dict
print(my_dict)
my_dict.clear()  # until will make the dictionarymy_dictempty
print(my_dict)
delmy_dict # it will delete the dictionarymy_dict
print(my_dict)

The output is:

{’electronic mail’: ‘abc@gmail.com’, ‘location’: ‘Gurgaon’}

{}

Traceback (most up-to-date name final):

  File “important.py”, line 7, in <module>

    print(my_dict)

NameError: identify ‘my_dict’ just isn’t outlined

Deleting Component(s) from dictionary utilizing pop() technique

The dict.pop() technique can also be used to delete parts from a dictionary. Utilizing the built-in pop() technique, you possibly can simply delete a component based mostly on its given key. The syntax is:

dict.pop(key, defaultvalue)

The pop() technique returns the worth of the eliminated key. In case of the absence of the given key, it’s going to return the default worth. If neither the default worth nor the secret is current, it’s going to give an error. 

Right here’s an instance that reveals the deletion of parts utilizing dict.pop() –

my_dict = {"username": "ABC", "electronic mail": "abc@gmail.com", "location":"Gurgaon"}
my_dict.pop("username")
print(my_dict)

The output is:

{’electronic mail’: ‘abc@gmail.com’, ‘location’: ‘Gurgaon’}

Appending factor(s) to a dictionary

It’s straightforward to append parts to the prevailing dictionary utilizing the dictionary identify adopted by sq. brackets with a key inside it and assigning a worth to it. 

Right here’s an instance:

my_dict = {"username": "ABC", "electronic mail": "abc@gmail.com", "location":"Gurgaon"}

my_dict['name']='Nick'

print(my_dict)

The output is:

{‘username’: ‘ABC’, ’electronic mail’: ‘abc@gmail.com’, ‘location’: ‘Gurgaon’, ‘identify’: ‘Nick’}

Updating current factor(s) in a dictionary

For updating the prevailing parts in a dictionary, you want a reference to the important thing whose worth must be up to date. 

On this instance, we are going to replace the username from ABC to XYZ. Right here’s how one can do it:

my_dict = {"username": "ABC", "electronic mail": "abc@gmail.com", "location":"Gurgaon"}

my_dict["username"] = "XYZ"

print(my_dict)

The output is:

{‘username’: ‘XYZ’, ’electronic mail’: ‘abc@gmail.com’, ‘location’: ‘Gurgaon’}

Insert a dictionary into one other dictionary

Allow us to think about an instance with two dictionaries – Dictionary 1 and Dictionary 2 as proven under –

Dictionary 1:

my_dict = {“username”: “ABC”, “electronic mail”: “abc@gmail.com”, “location”:”Gurgaon”}

Dictionary 2:

my_dict1 = {“firstName” : “Nick”, “lastName”: “Jonas”}

Now we wish to merge Dictionary 1 into Dictionary 2. This may be executed by making a key referred to as “identify” in my_dict and assigning my_dict1 dictionary to it. Right here’s how one can do it:

my_dict = {"username": "ABC", "electronic mail": "abc@gmail.com", "location":"Gurgaon"}

my_dict1 = {"firstName" : "Nick", "lastName": "Jonas"}

my_dict["name"] = my_dict1

print(my_dict)

The output is:

{‘username’: ‘ABC’, ’electronic mail’: ‘abc@gmail.com’, ‘location’: ‘Gurgaon’, ‘identify’: {‘firstName’: ‘Nick’, ‘lastName’: Jonas}}

As noticed within the output, the important thing ‘identify’ has the dictionary my_dict1. 

Fast Applications on Python Dictionary Append

1. Restrictions on Key Dictionaries:

Python dictionaries have some restrictions on their keys. Listed here are some examples of invalid dictionary keys:

bashCopy codemy_dict = {[1,2]: 'worth'}  # Lists are unhashable and can't be used as keys
my_dict = {{1:2}: 'worth'}  # Dictionaries are unhashable and can't be used as keys
my_dict = {'a': 'value1', 'a': 'value2'}  # Duplicate keys usually are not allowed in dictionaries

2. How one can append a component to a key in a dictionary with Python:

You’ll be able to append a component to an inventory that could be a worth related to a key in a dictionary like this:

cssCopy codemy_dict = {'key': [1, 2, 3]}
my_dict['key'].append(4)
print(my_dict)  # Output: {'key': [1, 2, 3, 4]}

3. Accessing parts of a dictionary:

You’ll be able to entry parts in a dictionary utilizing their keys like this:

bashCopy codemy_dict = {'key1': 'value1', 'key2': 'value2'}
print(my_dict['key1'])  # Output: 'value1'

You may also use the get() technique to entry dictionary parts. This technique returns None if the secret is not current within the dictionary:

bashCopy codemy_dict = {'key1': 'value1', 'key2': 'value2'}
print(my_dict.get('key1'))  # Output: 'value1'
print(my_dict.get('key3'))  # Output: None

4. Deleting factor(s) in a dictionary:

You’ll be able to delete a component from a dictionary utilizing the del key phrase like this:

cssCopy codemy_dict = {'key1': 'value1', 'key2': 'value2'}
del my_dict['key1']
print(my_dict)  # Output: {'key2': 'value2'}

5. Deleting Component(s) from dictionary utilizing pop() technique:

You may also delete a component from a dictionary utilizing the pop() technique. This technique removes the key-value pair from the dictionary and returns the worth:

goCopy codemy_dict = {'key1': 'value1', 'key2': 'value2'}
worth = my_dict.pop('key1')
print(my_dict)  # Output: {'key2': 'value2'}
print(worth)  # Output: 'value1'

6. Appending factor(s) to a dictionary:

You’ll be able to append a brand new key-value pair to a dictionary like this:

cssCopy codemy_dict = {'key1': 'value1'}
my_dict['key2'] = 'value2'
print(my_dict)  # Output: {'key1': 'value1', 'key2': 'value2'}

7. Updating current factor(s) in a dictionary:

You’ll be able to replace an current factor in a dictionary by assigning a brand new worth to its key like this:

cssCopy codemy_dict = {'key1': 'value1', 'key2': 'value2'}
my_dict['key2'] = 'new_value'
print(my_dict)  # Output: {'key1': 'value1', 'key2': 'new_value'}

8. Insert a dictionary into one other dictionary:

You’ll be able to insert a dictionary into one other dictionary through the use of the replace() technique like this:

bashCopy codemy_dict1 = {'key1': 'value1'}
my_dict2 = {'key2': 'value2'}
my_dict1.replace(my_dict2)
print(my_dict1)  # Output:

FAQs