Python - Dictionaries

The keys(), values(), and items() methods are used to retrieve information from dictionaries in Python. Let's explore the differences with examples:

# Creating a sample dictionary
sample_dict = {'name': 'John', 'age': 25, 'city': 'New York'}

# Using keys() method to get keys
keys = sample_dict.keys()
print("Keys:", keys)

# Using values() method to get values
values = sample_dict.values()
print("Values:", values)

# Using items() method to get key-value pairs
items = sample_dict.items()
print("Items:", items)

Output:

Keys: dict_keys(['name', 'age', 'city'])
Values: dict_values(['John', 25, 'New York'])
Items: dict_items([('name', 'John'), ('age', 25), ('city', 'New York')])

The keys() method returns a view of the dictionary's keys, values() returns a view of the dictionary's values, and items() returns a view of the dictionary's key-value pairs as tuples.

Note that these methods return views, which are dynamic and reflect changes made to the dictionary. If you want to work with static lists, you can convert the views to lists using list().

# Convert views to lists
keys_list = list(keys)
values_list = list(values)
items_list = list(items)

print("Keys (as list):", keys_list)
print("Values (as list):", values_list)
print("Items (as list):", items_list)

Output:

Keys (as list): ['name', 'age', 'city']
Values (as list): ['John', 25, 'New York']
Items (as list): [('name', 'John'), ('age', 25), ('city', 'New York')]

In this example, the views are converted to lists, providing a more traditional data structure that won't reflect changes to the original dictionary.

You can iterate over keys and values in a dictionary using a for loop in Python. Here's an example:

# Creating a sample dictionary
sample_dict = {'name': 'John', 'age': 25, 'city': 'New York'}

# Iterating over keys
print("Iterating over keys:")
for key in sample_dict:
    print("Key:", key)

# Iterating over values
print("\nIterating over values:")
for value in sample_dict.values():
    print("Value:", value)

# Iterating over key-value pairs
print("\nIterating over key-value pairs:")
for key, value in sample_dict.items():
    print(f"{key}: {value}")

Output:

Iterating over keys:
Key: name
Key: age
Key: city

Iterating over values:
Value: John
Value: 25
Value: New York

Iterating over key-value pairs:
name: John
age: 25
city: New York

In the example, we use a for loop to iterate over the keys, values, and key-value pairs of the dictionary. The values() method is used to directly iterate over values, and the items() method is used for key-value pairs.

The pop() method in Python dictionaries is used to remove and return an item with a specified key. If the key is not found, it raises a KeyError or returns a default value if provided. Here's an example:

# Creating a sample dictionary
sample_dict = {'name': 'John', 'age': 25, 'city': 'New York'}

# Using pop() to remove and return an item
removed_item = sample_dict.pop('age')

# Displaying the removed item and the updated dictionary
print(f"Removed item: {removed_item}")
print("Updated dictionary:", sample_dict)

# Using pop() with a default value for a non-existing key
non_existing_key = 'gender'
default_value = 'Not specified'
default_item = sample_dict.pop(non_existing_key, default_value)

# Displaying the result with a non-existing key
print(f"\nRemoved item with default value: {default_item}")
print("Updated dictionary:", sample_dict)

Output:

Removed item: 25
Updated dictionary: {'name': 'John', 'city': 'New York'}

Removed item with default value: Not specified
Updated dictionary: {'name': 'John', 'city': 'New York'}

In the example, the pop() method is used to remove and return the item with the key 'age'. The updated dictionary is then displayed. Additionally, pop() is used with a default value for a non-existing key ('gender'). The default value is returned, and the dictionary remains unchanged.

The clear() method in Python dictionaries is used to remove all elements from the dictionary. After using clear(), the dictionary becomes empty. Here's an example:

# Creating a sample dictionary
sample_dict = {'name': 'John', 'age': 25, 'city': 'New York'}

# Displaying the original dictionary
print("Original dictionary:", sample_dict)

# Using clear() to remove all elements
sample_dict.clear()

# Displaying the dictionary after using clear()
print("Dictionary after using clear():", sample_dict)

Output:

Original dictionary: {'name': 'John', 'age': 25, 'city': 'New York'}
Dictionary after using clear(): {}

In the example, the clear() method is applied to the sample dictionary, and the original dictionary is displayed before and after using clear(). After calling clear(), the dictionary becomes empty.