Python Data type - dictionary

In Python, dictionaries are a built-in data type that allows you to store collections of key-value pairs. They are also known as associative arrays or hash maps in other programming languages. Dictionaries are mutable, unordered, and indexed by keys, which must be unique and immutable.

Characteristics of Dictionaries

1. Key-Value Pairs: Each item in a dictionary is a pair of a key and a value. The key serves as an identifier for the value.
2. Unordered: Dictionaries in Python 3.7 and later maintain the insertion order as a property of their implementation. However, this order should not be relied upon for functionality that depends strictly on ordering.
3. Mutable: You can change, add, or remove key-value pairs in a dictionary.
4. Keys: Keys must be immutable types (e.g., strings, numbers, tuples) and must be unique within a dictionary.
5. Values: Values can be of any data type and can be repeated.

Creating Dictionaries

You can create dictionaries using curly braces {} with key-value pairs separated by colons, or by using the dict() constructor.

 

# Using curly braces
person = {
    "name": "Alice",
    "age": 30,
    "city": "New York"
}

# Using dict() constructor
person = dict(name="Alice", age=30, city="New York")

# An empty dictionary
empty_dict = {}

 

 

Accessing and Modifying Values

1. Accessing Values: You can access the value associated with a key using the key inside square brackets or the get() method.

name = person["name"]  # "Alice"
age = person.get("age")  # 30

 

Modifying Values: Assign a new value to a key to change it.

person["age"] = 31  # person is now {"name": "Alice", "age": 31, "city": "New York"}

Adding Key-Value Pairs: Simply assign a value to a new key.

person["email"] = "alice@example.com"  # person is now {"name": "Alice", "age": 31, "city": "New York", "email": "alice@example.com"}

 

Removing Key-Value Pairs:

 - pop(): Removes a key and returns its value.

age = person.pop("age")  # age is 31, person is now {"name": "Alice", "city": "New York", "email": "alice@example.com"}

 

 

 -  del: Removes a key-value pair.

del person["email"]  # person is now {"name": "Alice", "city": "New York"}

 

 -  popitem(): Removes and returns the last inserted key-value pair.

last_item = person.popitem()  # ("city", "New York"), person is now {"name": "Alice"}

 

 -  clear(): Removes all key-value pairs.

 

person.clear()  # person is now {}

 

Dictionary Methods

1. keys(): Returns a view object containing the keys of the dictionary.

keys = person.keys()  # dict_keys(['name'])

values(): Returns a view object containing the values of the dictionary.

values = person.values()  # dict_values(['Alice'])

items(): Returns a view object containing the key-value pairs as tuples.

items = person.items()  # dict_items([('name', 'Alice')])

 

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

person.update({"age": 32, "city": "Los Angeles"})  # person is now {"name": "Alice", "age": 32, "city": "Los Angeles"}

 

setdefault(): Returns the value of a key if it exists; otherwise, inserts the key with a specified value.

email = person.setdefault("email", "alice@example.com")  # Adds email if not present

Iterating Through a Dictionary

You can iterate through dictionaries to access keys, values, or key-value pairs.

# Iterating through keys
for key in person:
    print(key)

# Iterating through values
for value in person.values():
    print(value)

# Iterating through key-value pairs
for key, value in person.items():
    print(f"{key}: {value}")

 

Dictionary Comprehensions

Similar to list comprehensions, dictionary comprehensions provide a concise way to create dictionaries.

# Squaring numbers
squared_numbers = {x: x**2 for x in range(5)}  # {0: 0, 1: 1, 2: 4, 3: 9, 4: 16}

# Filtering items
filtered_dict = {k: v for k, v in person.items() if isinstance(v, str)}  # Keeps only string values

 

 

Use Cases and Benefits of Dictionaries

1. Efficient Data Lookup: Dictionaries provide fast access to data based on keys, making them ideal for situations where you need to quickly retrieve or update values.
2. Structured Data Storage: They are useful for storing structured data where you want to associate values with specific identifiers (keys).
3. Flexible Keys and Values: Dictionaries can accommodate different types of keys and values, allowing for versatile data representation.
4. Namespace Representation: Dictionaries are often used to represent namespaces, such as attributes in an object, configurations, or mappings.

 

 

Dictionaries are a powerful and flexible data structure in Python, well-suited for storing and managing data with key-value associations. Their mutability and support for various data types as values make them versatile for many programming tasks. Whether you're looking to create mappings, count occurrences, or store configuration settings, dictionaries are an essential tool in Python programming.