Dictionary in Python

A dictionary in Python is a built-in data type that stores collections of key-value pairs.
Dictionaries are also known as associative arrays or hash maps. They are unordered, mutable,
and indexed by keys, which can be of any immutable data type (such as strings, numbers, or
tuples).

Creating a Dictionary

Dictionaries can be created in several ways:

1. Using curly braces {}:

my_dict = {"key1": "value1", "key2": "value2"}

2. Using the dict() constructor:

my_dict = dict(key1="value1", key2="value2")

3. Using a list of tuples:

my_dict = dict([("key1", "value1"), ("key2", "value2")])

Accessing Values

You can access values by using their corresponding keys:

value = my_dict["key1"]

If you try to access a key that does not exist, a KeyError will be raised. To avoid this, use the
get() method, which returns None or a default value if the key is not found:

value = my_dict.get("key1", "default_value")

Adding or Modifying Entries

You can add a new key-value pair or modify an existing one by using the assignment
operator:

my_dict["key3"] = "value3" # Adds a new key-value pair

my_dict["key1"] = "new_value" # Modifies an existing key-value pair

Removing Entries

There are several methods to remove items from a dictionary:

1. Using the del statement:

del my_dict["key1"]
 2. Using the pop() method, which returns the removed value:

value = my_dict.pop("key2")

3. Using the popitem() method to remove and return an arbitrary key-value pair
(in Python 3.7+ it removes the last item):

key, value = my_dict.popitem()

4. Using the clear() method to remove all items:

my_dict.clear()

Dictionary Methods

Python dictionaries come with various useful methods:

 keys(): Returns a view object of all keys.

keys = my_dict.keys()

 values(): Returns a view object of all values.

values = my_dict.values()

 items(): Returns a view object of all key-value pairs.

items = my_dict.items()

 update(): Updates the dictionary with key-value pairs from another dictionary or an
iterable of key-value pairs.

my_dict.update({"key4": "value4"})

Dictionary Comprehensions

Similar to list comprehensions, you can create dictionaries using dictionary comprehensions:

python
squares = {x: x*x for x in range(6)}

Nested Dictionaries

Dictionaries can contain other dictionaries, which allows you to create nested structures:

nested_dict = {"first": {"a": 1, "b": 2}, "second": {"c": 3, "d": 4}}

Iterating Through Dictionaries

You can iterate through dictionaries using loops:

for key in my_dict:
print(key, my_dict[key])

# or

for key, value in my_dict.items():

print(key, value)

Common Use Cases

 Lookup tables: Efficiently find a value associated with a unique key.

 Data storage: Store related pieces of data together, using descriptive keys.
 Counting occurrences: Track how many times something appears in a collection.

# Creating a simple dictionary

fruit_colors = {

"apple": "red",

"banana": "yellow",

"cherry": "red",

"grape": "purple"

print("Initial dictionary:")

print("fruit_colors:", fruit_colors)

# Accessing values

print("\nAccessing values:")

print("Color of apple:", fruit_colors["apple"])

print("Color of banana:", fruit_colors.get("banana"))

print("Color of orange (with default):", fruit_colors.get("orange", "unknown"))

# Adding or modifying entries

fruit_colors["orange"] = "orange" # Adding a new key-value pair

fruit_colors["banana"] = "green" # Modifying an existing key-value pair

print("\nAfter adding and modifying entries:")

print("fruit_colors:", fruit_colors)
# Removing entries

del fruit_colors["cherry"] # Using del to remove an entry

print("\nAfter deleting 'cherry':")

print("fruit_colors:", fruit_colors)

removed_color = fruit_colors.pop("grape") # Using pop() to remove an entry

print("\nAfter popping 'grape':", removed_color)

print("fruit_colors:", fruit_colors)

fruit_colors.clear() # Using clear() to remove all entries

print("\nAfter clearing the dictionary:")

print("fruit_colors:", fruit_colors)

# Dictionary methods

fruit_colors = {"apple": "red", "banana": "yellow", "cherry": "red"}

print("\nDictionary methods:")

print("Keys:", fruit_colors.keys())

print("Values:", fruit_colors.values())

print("Items:", fruit_colors.items())

# Updating a dictionary

fruit_colors.update({"grape": "purple", "orange": "orange"})

print("\nAfter updating the dictionary:")

print("fruit_colors:", fruit_colors)

# Dictionary comprehension

fruit_lengths = {fruit: len(fruit) for fruit in fruit_colors}

print("\nDictionary comprehension (fruit lengths):")

print("fruit_lengths:", fruit_lengths)
# Nested dictionaries

fruit_properties = {

"apple": {"color": "red", "taste": "sweet"},

"banana": {"color": "yellow", "taste": "sweet"},

"grape": {"color": "purple", "taste": "sweet or sour"}

print("\nNested dictionary:")

print("fruit_properties:", fruit_properties)

# Iterating through dictionaries

print("\nIterating through fruit_colors:")

for fruit in fruit_colors:

print(f"Fruit: {fruit}, Color: {fruit_colors[fruit]}")

print("\nIterating through fruit_colors using items():")

for fruit, color in fruit_colors.items():

print(f"Fruit: {fruit}, Color: {color}")

# Common use cases

# Counting occurrences

fruit_basket = ["apple", "banana", "apple", "cherry", "banana", "banana"]

fruit_count = {}

for fruit in fruit_basket:

if fruit in fruit_count:

fruit_count[fruit] += 1

else:

fruit_count[fruit] = 1

print("\nCounting occurrences in the fruit basket:")

print("fruit_count:", fruit_count)
Output:
Initial dictionary:
fruit_colors: {'apple': 'red', 'banana': 'yellow', 'cherry': 'red', 'grape': 'purple'}

Accessing values:
Color of apple: red
Color of banana: yellow
Color of cherry (with default): red

After adding and modifying entries:

fruit_colors: {'apple': 'red', 'banana': 'green', 'cherry': 'red', 'grape': 'purple', 'orange':
'orange'}

After deleting 'cherry':

fruit_colors: {'apple': 'red', 'banana': 'green', 'grape': 'purple', 'orange': 'orange'}

After popping 'grape': purple

fruit_colors: {'apple': 'red', 'banana': 'green', 'orange': 'orange'}

After clearing the dictionary:

fruit_colors: {}

Dictionary methods:
Keys: dict_keys(['apple', 'banana', 'cherry'])
Values: dict_values(['red', 'yellow', 'red'])
Items: dict_items([('apple', 'red'), ('banana', 'yellow'), ('cherry', 'red')])

After updating the dictionary:

fruit_colors: {'apple': 'red', 'banana': 'yellow', 'cherry': 'red', 'grape': 'purple', 'orange':
'orange'}
Dictionary comprehension (fruit lengths):
fruit_lengths: {'apple': 5, 'banana': 6, 'cherry': 6, 'grape': 5, 'orange': 6}

Nested dictionary:
fruit_properties: {'apple': {'color': 'red', 'taste': 'sweet'}, 'banana': {'color': 'yellow', 'taste':
'sweet'}, 'grape': {'color': 'purple', 'taste': 'sweet or sour'}}

Iterating through fruit_colors:

Fruit: apple, Color: red
Fruit: banana, Color: yellow
Fruit: cherry, Color: red
Fruit: grape, Color: purple
Fruit: orange, Color: orange

Iterating through fruit_colors using items():

Fruit: apple, Color: red
Fruit: banana, Color: yellow
Fruit: cherry, Color: red
Fruit: grape, Color: purple
Fruit: orange, Color: orange

Counting occurrences in the fruit basket:

fruit_count: {'apple': 2, 'banana': 3, 'cherry': 1}