Python Tutorial
.
In this tutorial, we delve deep into one of Python's most versatile data structures: the dictionary. Dictionary in Python is a foundational component for those upskilling in the field as it offers efficient key-value data storage, proving indispensable for data manipulation, storage, and retrieval tasks.
Dictionary in Python, termed "dict", stands out as dynamic collections of key-value pairs. With their ability to provide rapid and efficient data access, they become an inevitable tool, especially when dealing with voluminous data that needs a structured format for easy access and modification.
Code:
# Creating a dictionary using curly braces {} student = { "name": "Alice", "age": 20, "major": "Computer Science" } print(student)
The complexities for creating a dictionary in Python depend on various factors, including the size of the dictionary, the hash function's efficiency, and the implementation details of the Python interpreter. Here are the general complexities:
Time Complexity:
Best Case: O(1) - When creating an empty dictionary or adding the first few elements.
Average Case: O(1) - Constant time for inserting a new key-value pair.
Worst Case: O(n) - In the worst case, when there are hash collisions or frequent resizing, insertion can become linear. Resizing involves rehashing and reinserting elements, which can take time proportional to the size of the dictionary.
Space Complexity:
O(n) - The space complexity for a dictionary depends on the number of key-value pairs it contains.
Code:
student = { "name": "Alice", "age": 20, "major": "Computer Science" } # Changing the value of an existing key student["age"] = 21 print(student) # Output: {'name': 'Alice', 'age': 21, 'major': 'Computer Science'}
Code:
student = { "name": "Alice", "age": 20, "major": "Computer Science" } # Changing the value of an existing key student["age"] = 21 print(student) # Output: {'name': 'Alice', 'age': 21, 'major': 'Computer Science'} # Adding a new key-value pair student["university"] = "ABC University" print(student) # Output: {'name': 'Alice', 'age': 21, 'major': 'Computer Science', 'university': 'ABC University'}
Code:
student = { "name": "Alice", "age": 20, "major": "Computer Science" } # Accessing values using keys name = student["name"] age = student["age"] major = student["major"] print("Name:", name) # Output: Name: Alice print("Age:", age) # Output: Age: 20 print("Major:", major) # Output: Major: Computer Science
Code:
# Creating a nested dictionary student = { "name": "Alice", "age": 20, "contact": { "email": "alice@example.com", "phone": "123-456-7890" }, "courses": { "math": 95, "history": 85, "english": 90 } } # Accessing elements in the nested dictionary email = student["contact"]["email"] math_score = student["courses"]["math"] print("Email:", email) # Output: Email: alice@example.com print("Math Score:", math_score) # Output: Math Score: 95
Code:
# Nested dictionary student = { "name": "Alice", "age": 20, "contact": { "email": "alice@example.com", "phone": "123-456-7890" }, "courses": { "math": 95, "history": 85, "english": 90 } } # Accessing a nested element email = student["contact"]["email"] math_score = student["courses"]["math"] print("Email:", email) # Output: Email: alice@example.com print("Math Score:", math_score) # Output: Math Score: 95
Code:
student = { "name": "Alice", "age": 20, "major": "Computer Science" } # Deleting a key-value pair del student["age"] print(student) # Output: {'name': 'Alice', 'major': 'Computer Science'}
Code:
# Creating a dictionary student = { "name": "Alice", "age": 20, "major": "Computer Science" } # Accessing keys, values, and items keys = student.keys() values = student.values() items = student.items() print("Keys:", keys) # Output: Keys: dict_keys(['name', 'age', 'major']) print("Values:", values) # Output: Values: dict_values(['Alice', 20, 'Computer Science']) print("Items:", items) # Output: Items: dict_items([('name', 'Alice'), ('age', 20), ('major', 'Computer Science')]) # Getting a value by key, with a default value if the key is not present age = student.get("age", "N/A") gender = student.get("gender", "N/A") print("Age:", age) # Output: Age: 20 print("Gender:", gender) # Output: Gender: N/A # Adding or updating a key-value pair student["university"] = "ABC University" print(student) # Output: {'name': 'Alice', 'age': 20, 'major': 'Computer Science', 'university': 'ABC University'} # Removing a key-value pair and returning its value removed_major = student.pop("major") print("Removed Major:", removed_major) # Output: Removed Major: Computer Science # Removing the last key-value pair and returning it as a tuple last_item = student.popitem() print("Last Item:", last_item) # Output: Last Item: ('university', 'ABC University') # Clearing all items from the dictionary student.clear() print(student) # Output: {} # Copying a dictionary original_dict = {"a": 1, "b": 2} copy_dict = original_dict.copy() print(copy_dict) # Output: {'a': 1, 'b': 2}
Iterating Through Keys:
Code:
student = { "name": "Alice", "age": 20, "major": "Computer Science" } # Iterating through keys using a for loop for key in student: print(key) # Output: # name # age # major
Iterating Through Values:
Code:
student = { "name": "Alice", "age": 20, "major": "Computer Science" } # Iterating through values using a for loop for value in student.values(): print(value) # Output: # Alice # 20 # Computer Science
Iterating With Key-Value Pairs (Items):
Code:
student = { "name": "Alice", "age": 20, "major": "Computer Science" } # Iterating with key-value pairs using a for loop for key, value in student.items(): print(key, ":", value) # Output: # name : Alice # age : 20 # major : Computer Science
Using keys() Method with for loop:
Code:
student = { "name": "Alice", "age": 20, "major": "Computer Science" } # Iterating through keys using keys() method and a for loop for key in student.keys(): print(key) # Output: # name # age # major
Using values() Method with for loop:
Code:
student = { "name": "Alice", "age": 20, "major": "Computer Science" } # Iterating through values using values() method and a for loop for value in student.values(): print(value) # Output: # Alice # 20 # Computer Science
Using items() Method with for Loop:
Code:
student = { "name": "Alice", "age": 20, "major": "Computer Science" } # Iterating with key-value pairs using items() method and a for loop for key, value in student.items(): print(key, ":", value) # Output: # name : Alice # age : 20 # major : Computer Science
Dictionary keys in Python have certain properties that influence their behavior and usage. Here are some important properties of dictionary keys:
Immutable: Dictionary keys must be of an immutable data type. Immutable types include strings, numbers, and tuples (as long as the tuples contain only immutable elements).
Unique: Dictionary keys must be unique. If you try to use the same key multiple times, the later values will overwrite the earlier ones.
Hashable: Since dictionary keys are used to hash and retrieve values, they must be hashable. Immutable data types are hashable, allowing for efficient lookups.
Order (Python 3.7+): In Python 3.7 and later, dictionaries maintain the insertion order of keys. This behavior was later made part of the Python language specification, so you can rely on ordered dictionaries in newer versions.
Unordered (Python < 3.7): In Python versions prior to 3.7, dictionaries do not guarantee the order of keys. If you need ordered behavior, you should use collections.OrderedDict.
No Duplicates: As mentioned, keys must be unique. Trying to insert duplicate keys will overwrite the existing value associated with that key.
Changing Values: Dictionary values can be of any type, including mutable ones like lists. Keys, however, must remain immutable to maintain dictionary integrity.
Performance: Dictionary lookups are very efficient due to the underlying hash table implementation. However, excessive hash collisions can degrade performance.
Here's an example demonstrating some of these properties:
Code:
# Immutable keys dict1 = {1: "one", "two": 2, (3, 4): "tuple_key"} print(dict1) # Unique keys dict2 = {"name": "Alice", "age": 25, "name": "Bob"} print(dict2) # Output: {'name': 'Bob', 'age': 25} # Unordered behavior (Python < 3.7) dict3 = {"a": 1, "b": 2, "c": 3} print(dict3) # Output may not maintain order
len() - Returns the number of key-value pairs in the dictionary.
clear() - Removes all key-value pairs from the dictionary.
copy() - Returns a shallow copy of the dictionary.
fromkeys(keys, value) - Creates a new dictionary with the specified keys and a common value.
get(key, default) - Returns the value associated with the key. In the case that the key is not found, this function will return the default value.
items() - Returns a view of key-value pairs in the dictionary as tuples.
keys() - Returns a view of keys in the dictionary.
values() - Returns a view of values in the dictionary.
pop(key, default) - Removes and returns the value associated with the key. When the key cannot be found, this returns the default value.
popitem() - Removes and returns the last key-value pair as a tuple.
setdefault(key, default) - Returns the value associated with the key. In the case that the key is not found, this sets the key with the provided default value and returns it.
update(other_dict) - Updates the dictionary with key-value pairs from another dictionary or iterable.
dict() - Creates a new dictionary from a sequence of key-value pairs, a dictionary, or keyword arguments.
keys_view() - Returns a dynamic view of keys.
values_view() - Returns a dynamic view of values.
items_view() - Returns a dynamic view of key-value pairs.
popitem() - Removes and returns an arbitrary key-value pair as a tuple.
Here's an example showcasing some of these functions and methods:
Code:
student = { "name": "Alice", "age": 20, "major": "Computer Science" } print(len(student)) # Output: 3 print(student.get("age")) # Output: 20 print(student.keys()) # Output: dict_keys(['name', 'age', 'major']) print(student.values()) # Output: dict_values(['Alice', 20, 'Computer Science']) print(student.items()) # Output: dict_items([('name', 'Alice'), ('age', 20), ('major', 'Computer Science')]) # Removing and returning a key-value pair removed_item = student.popitem() print(removed_item) # Output: ('major', 'Computer Science') # Updating the dictionary with new data new_data = {"university": "ABC University", "age": 21} student.update(new_data) print(student) # Output: {'name': 'Alice', 'age': 21, 'university': 'ABC University'}
clear() - Removes all key-value pairs from the dictionary.
copy() - Returns a shallow copy of the dictionary.
fromkeys(keys, value) - Creates a new dictionary with the specified keys and a common value.
get(key, default) - Returns the value associated with the key. When the key cannot be found, this returns the default value.
items() - Returns a view of key-value pairs in the dictionary as tuples.
keys() - Returns a view of keys in the dictionary.
values() - Returns a view of values in the dictionary.
pop(key, default) - Removes and returns the value associated with the key. In the case that the key is not found, this returns the default value.
popitem() - Removes and returns an arbitrary key-value pair as a tuple.
setdefault(key, default) - Returns the value associated with the key. When the key cannot be found, this sets the key with the provided default value and returns it.
update(other_dict) - Updates the dictionary with key-value pairs from another dictionary or iterable.
Here's an example demonstrating how to use some of these built-in dictionary methods:
Code:
# Creating a dictionary student = { "name": "Alice", "age": 20, "major": "Computer Science" } # Using dictionary methods print(student.keys()) # Output: dict_keys(['name', 'age', 'major']) print(student.values()) # Output: dict_values(['Alice', 20, 'Computer Science']) print(student.items()) # Output: dict_items([('name', 'Alice'), ('age', 20), ('major', 'Computer Science')]) # Removing and returning a key-value pair removed_item = student.popitem() print(removed_item) # Output: ('major', 'Computer Science') # Updating the dictionary with new data new_data = {"university": "ABC University", "age": 21} student.update(new_data) print(student) # Output: {'name': 'Alice', 'age': 21, 'university': 'ABC University'} # Clearing the dictionary student.clear() print(student) # Output: {}
Dictionaries in Python are undeniably a pivotal data structure, bridging the gap between data storage needs and efficiency. Their flexible nature, combined with Python's suite of methods tailored for them, ensures their broad application, from simple data manipulations to complex algorithm implementations. For those on the path to Python mastery, understanding dictionaries is paramount. Hungry for more? upGrad offers a variety of courses tailored to nourish your thirst for knowledge in Python.
Is a dictionary in Python mutable or immutable?
Dictionaries in Python are mutable, allowing modifications after their creation.
What are some dictionary methods in Python?
Some common dictionary methods in Python include dict.keys(), dict.values(), and dict.update(). These enhance interactions with dictionaries.
How do you loop through a dictionary in Python?
Utilize the for loop with dict.items() for efficient key-value pair iteration.
How can you sort a dictionary by its values?
Employ the sorted() function and specify key=lambda x: x[1].
How to retrieve all keys from a dictionary?
The method dict.keys() will fetch all keys present in the dictionary.
Leave a Reply
Your email address will not be published. Required fields are marked *