Data Type 6. – Dictionary

Dictionaries in Python are powerful and versatile data structures that allow you to store and manipulate collections of key-value pairs. Unlike sequences such as lists and tuples that are indexed by a range of numbers, dictionaries are indexed by keys, which can be of various types, providing flexibility in data retrieval. In this blog, we’ll explore the fundamentals of dictionaries, their characteristics, operations, and common use cases.

Dictionary Storage in Python

In Python, dictionaries are implemented using a data structure called a hash table, which allows for efficient storage and retrieval of key-value pairs. Hash tables are widely used for their fast access times and efficient memory usage.

A hash table is a data structure that stores key-value pairs. The basic idea is to use a hash function to compute an index from which the desired value can be found. The hash function transforms the key into a hash value, which is used to index the array.

Dictionaries in Python use memory efficiently, as they store only references to the actual objects (keys and values), not the objects themselves. This allows dictionaries to handle large amounts of data with lower memory requirements.

1. Introduction to Dictionaries

A dictionary in Python is an unordered collection of items, where each item consists of a key-value pair. The keys in a dictionary are unique and immutable, acting as identifiers for the associated values. The values can be of any data type and can be duplicated. This association of keys and values makes dictionaries incredibly efficient for retrieving and managing data.

2. Creating Dictionaries

In Python, you can create a dictionary by enclosing a comma-separated sequence of key-value pairs within curly braces {}, where each pair is in the form key: value.

# Creating a dictionary
student = {'name': 'Alice', 'age': 25, 'course': 'Mathematics'}

3. Dictionary Operations

a. Accessing Elements

You can access the value associated with a specific key using square brackets []. If the key doesn’t exist, it raises a KeyError.

# Accessing values using keys
print(student['name'])  # Output: 'Alice'

b. Modifying Elements

Dictionaries are mutable, allowing you to modify existing keys or add new key-value pairs.

# Modifying values
student['age'] = 26

# Adding a new key-value pair
student['gender'] = 'Female'

{'name': 'Alice', 'age': 26, 'course': 'Mathematics', 'gender': 'Female'}

c. Comparison Operators

Equality and Inequality (==, !=):
- Two dictionaries are considered equal (==) if they have the same key-value pairs. The order of the pairs doesn’t matter.
Inequality (<, <=, >, >=) – Not Supported:
- Comparison operators like <, <=, >, and >= are not supported for dictionaries in Python. Attempting to use them will result in a TypeError.

dict1 = {'a': 1, 'b': 2}
dict2 = {'b': 2, 'a': 1}
print(dict1 == dict2)  # Output: True (order of key-value pairs doesn't matter)

dict3 = {'a': 1, 'b': 3}
print(dict1 != dict3)  # Output: True (values are different)


# Unsupported comparison operators (will raise a TypeError)
# print(dict1 < dict2)
# print(dict1 <= dict2)
# print(dict1 > dict2)
# print(dict1 >= dict2)

4. Dictionary Functions

len():
- The len() function returns the number of key-value pairs in the dictionary.
min() and max():
- The min() and max() functions return the minimum and maximum keys (based on their natural order) from the dictionary, respectively.
sum():
- The sum() function, when used with dictionaries, returns the sum of all the keys (not the values). If the keys are not numeric, it will raise a TypeError.

my_dict = {'a': 1, 'b': 2, 'c': 3}
print(len(my_dict))  # Output: 3
print(min(my_dict))  # Output: 'a' (minimum key)
print(max(my_dict))  # Output: 'c' (maximum key)
print(min(my_dict, key=lambda k: my_dict[k]))  # Output: 'a' (minimum value's key)
print(max(my_dict, key=lambda k: my_dict[k]))  # Output: 'b' (maximum value's key)
print(sum(numeric_dict))  # Output: 6 (sum of the numeric keys)

non_numeric_dict = {'a': 'apple', 'b': 'banana'}
# print(sum(non_numeric_dict))  # This will raise a TypeError

5. Dictionary Methods

clear():
- Removes all elements from the dictionary.
copy():
- Returns a shallow copy of the dictionary.
fromkeys(seq[, v]):
- Returns a new dictionary with keys from seq and values set to v.
get(key[,d]):
- Returns the value for the key if it exists, else returns d (defaults to None).
items():
- Returns a view of the dictionary’s key-value pairs.
keys():
- Returns a view of the dictionary’s keys.
values():
- Returns a view of the dictionary’s values.
pop(key[,d]):
- Removes the key and returns its value, or returns d if the key is not found.
popitem():
- Removes and returns an arbitrary key-value pair as a tuple.
setdefault(key[,d]):
- Returns the value for the key if it exists, else sets the key to d and returns d.
update([other]):
- Updates the dictionary with key-value pairs from another dictionary or an iterable of key-value pairs.
dict.fromkeys(keys[, value]):
- Returns a new dictionary with keys from keys and values set to value.
dict.setdefault(key, default=None):
- Returns the value for the key if it exists, else sets the key to default and returns default.
dict.update([other]):
- Updates the dictionary with key-value pairs from another dictionary or an iterable of key-value pairs.

# Creating a dictionary
my_dict = {'name': 'Alice', 'age': 30, 'city': 'New York'}

# clear()
my_dict.clear()
print(my_dict)  # Output: {}

# Creating a new dictionary
my_dict = {'name': 'Alice', 'age': 30, 'city': 'New York'}

# copy()
copy_dict = my_dict.copy()
print(copy_dict)  # Output: {'name': 'Alice', 'age': 30, 'city': 'New York'}

# items()
print(my_dict.items())  # Output: dict_items([('name', 'Alice'), ('age', 30), ('city', 'New York')])

# keys()
print(my_dict.keys())  # Output: dict_keys(['name', 'age', 'city'])

# values()
print(my_dict.values())  # Output: dict_values(['Alice', 30, 'New York'])

# pop()
age = my_dict.pop('age')
print(age)  # Output: 30
print(my_dict)  # Output: {'name': 'Alice', 'city': 'New York'}

# popitem()
item = my_dict.popitem()
print(item)  # Output: ('city', 'New York')
print(my_dict)  # Output: {'name': 'Alice'}

# setdefault()
country = my_dict.setdefault('country', 'USA')
print(country)  # Output: USA
print(my_dict)  # Output: {'name': 'Alice', 'country': 'USA'}

# update()
my_dict.update({'age': 30, 'city': 'New York'})
print(my_dict)  # Output: {'name': 'Alice', 'country': 'USA', 'age': 30, 'city': 'New York'}

{}
{'name': 'Alice', 'age': 30, 'city': 'New York'}
dict_items([('name', 'Alice'), ('age', 30), ('city', 'New York')])
dict_keys(['name', 'age', 'city'])
dict_values(['Alice', 30, 'New York'])
30
{'name': 'Alice', 'city': 'New York'}
('city', 'New York')
{'name': 'Alice'}
USA
{'name': 'Alice', 'country': 'USA'}
{'name': 'Alice', 'country': 'USA', 'age': 30, 'city': 'New York'}

6. Dictionary Comprehension

Dictionary comprehension in Python is a concise way to create dictionaries using an expression followed by at least one for clause and zero or more for or if clauses. It allows you to construct dictionaries based on some iterable and apply an expression to define the key-value pairs.

# Creating a dictionary of squares:
squares = {x: x*x for x in range(1, 6)}
print(squares)  # Output: {1: 1, 2: 4, 3: 9, 4: 16, 5: 25}

# Creating a dictionary from two lists:
names = ['Alice', 'Bob', 'Charlie']
ages = [30, 25, 35]

# Create a dictionary using names as keys and ages as values
age_dict = {name: age for name, age in zip(names, ages)}
print(age_dict)  # Output: {'Alice': 30, 'Bob': 25, 'Charlie': 35}

# Filtering a dictionary based on a condition:
my_dict = {'a': 10, 'b': 20, 'c': 30}

# Create a new dictionary with values greater than 15
filtered_dict = {key: value for key, value in my_dict.items() if value > 15}
print(filtered_dict)  # Output: {'b': 20, 'c': 30}

{1: 1, 2: 4, 3: 9, 4: 16, 5: 25}
{'Alice': 30, 'Bob': 25, 'Charlie': 35}
{'b': 20, 'c': 30}

7. Mutable Nature of Dictionary & The Key Value Pair Nature

Dictionaries are mutable, meaning you can modify their contents after creation. This mutability allows you to add, modify, or remove key-value pairs, providing flexibility in managing and updating data within the dictionary. The ability to modify the dictionary’s contents makes it a powerful data structure for dynamic data handling and manipulation.

Dictionaries in Python are comprised of key-value pairs, where each key is unique and associated with a specific value. This structure allows for efficient and quick retrieval of values based on their corresponding keys.

Key: The key serves as an identifier and must be unique within a dictionary. It can be of any immutable type, such as strings, numbers, or tuples.
Value: The value is associated with a key and can be of any data type, including lists, other dictionaries, or custom objects.

The combination of keys and their corresponding values provides a powerful way to organize, access, and modify data in a dictionary.

Understanding the mutable nature of dictionaries and the importance of key-value pairs allows you to utilize dictionaries effectively for storing and organizing data in your Python programs.