Python dictionary append: Methods to do it?

Dictionary in Python

A dictionary is a crucial knowledge kind in Python programming. It’s a assortment of information values which are unordered. Python dictionary is used to retailer objects through 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. In contrast to different objects, the dictionary merely shops a key together with its worth. Subsequently, the mix of a key and its subsequent worth represents a single ingredient 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. The duplicates of keys aren’t allowed. 
• It gained’t make sense if you happen to 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 can be thought of.
• If a secret’s specified a second time after the creation of a dictionary, then the second time can be thought of as it would override the primary time.
• The important thing have to be immutable, which implies that the info kind will be an integer, string, tuples, boolean, and so forth. Subsequently, lists or one other dictionary can’t be used as they’re changeable.  

Methods to append a component to a key in a dictionary with Python?

Making a Dictionary

In Python, you may create a dictionary simply utilizing fastened keys and values. The sequence of components is positioned inside curly brackets, and key: values are separated by commas. It have to be famous that the worth of keys will be repeated however can’t have duplicates. Additionally, keys ought to have immutable knowledge 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 Combined keys
Dict = {'Title': ‘Nice Studying’, 1: [1, 2, 3, 4]}
print("nDictionary with the usage of Combined Keys: ")
print(Dict)

The output is :

Dictionary with the usage of Integer Keys: 

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

Dictionary with the usage of Combined Keys: 

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

Dictionary with integer keys

Right here’s learn how to 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 components of a dictionary

Key names are used to entry components of a dictionary. To entry the weather, it’s essential use sq. brackets ([‘key’]) with key 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

Different methodology 

There’s one other methodology referred to as get() that’s used to entry components from a dictionary. On this methodology, the hot button 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()
# methodology
print("Accessing a component utilizing get:")
print(Dict.get(3))

The output is:

Accessing a component utilizing get:

Life

Deleting ingredient(s) in a dictionary

You may delete components in a dictionary utilizing the ‘del’ key phrase.

The syntax is –

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

Use the next syntax to delete your entire dictionary –

del my_dict  # it will delete the dictionary with identify my_dict

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

Allow us to examine an instance of the deletion of components that lead to emptying your entire dictionary –

my_dict = {"username": "ABC", "e-mail": "abc@gmail.com", "location":"Gurgaon"}
del my_dict['username']  # it would 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:

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

{}

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

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

    print(my_dict)

NameError: identify ‘my_dict’ isn’t outlined

Deleting Factor(s) from dictionary utilizing pop() methodology

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

dict.pop(key, defaultvalue)

The pop() methodology returns the worth of the eliminated key. In case of the absence of the given key, it would return the default worth. If neither the default worth nor the hot button is current, it would give an error. 

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

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

The output is:

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

Appending ingredient(s) to a dictionary

It’s simple to append components 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", "e-mail": "abc@gmail.com", "location":"Gurgaon"}

my_dict['name']='Nick'

print(my_dict)

The output is:

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

Updating present ingredient(s) in a dictionary

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

On this instance, we’ll replace the username from ABC to XYZ. Right here’s learn how to do it:

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

my_dict["username"] = "XYZ"

print(my_dict)

The output is:

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

Insert a dictionary into one other dictionary

Allow us to contemplate an instance with two dictionaries – Dictionary 1 and Dictionary 2 as proven beneath –

Dictionary 1:

my_dict = {“username”: “ABC”, “e-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 finished by making a key referred to as “identify” in my_dict and assigning my_dict1 dictionary to it. Right here’s learn how to do it:

my_dict = {"username": "ABC", "e-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’, ’e-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. 

FAQs