Python Dictionaries: Key-Value Pairs Explained

Python programming tutorial

Python Dictionaries: Key-Value Pairs Explained

Beginner

Dictionaries are Python's versatile mapping type, storing data in key-value pairs for efficient retrieval.

Core Concept

Dictionaries are unordered collections of items. Each item is a key-value pair. Keys must be unique and immutable (e.g., strings, numbers, tuples).

Basic Example

Basics.py 

# Creating a dictionary
student = {
    "name": "Alice",
    "age": 20,
    "major": "Computer Science"
}

# Accessing values by key
print(student["name"])  # Output: Alice
print(student.get("age")) # Output: 20

# Adding a new key-value pair
student["gpa"] = 3.8
print(student)
# Output: {'name': 'Alice', 'age': 20, 'major': 'Computer Science', 'gpa': 3.8}

How It Works

You create dictionaries using curly braces `{}` with key:value pairs separated by commas. Access values using square brackets `[]` or the `.get()` method. You can add or modify items by assigning values to keys.

Advanced Example

advance.py 

# Dictionary comprehension
squares = {x: x**2 for x in range(5)}
print(squares)
# Output: {0: 0, 1: 1, 2: 4, 3: 9, 4: 16}

# Iterating through a dictionary
for key, value in squares.items():
    print(f"Key: {key}, Value: {value}")

# Removing items
del squares[2]
print(squares)
# Output: {0: 0, 1: 1, 3: 9, 4: 16}

Common Use Cases

  • Storing configuration settings.
  • Representing JSON data.
  • Counting item frequencies.
  • Implementing caches.

Common Pitfalls

  • Using mutable objects (like lists) as keys.
  • Forgetting that dictionaries are unordered in older Python versions (pre-3.7).
  • Trying to access a non-existent key without using `.get()` or checking existence.

Related Tutorials

Mastering Modern Python: Top Trending Lessons for 2024 Success
Master the Future: Top Trending Python Lessons & Skills for 2024
Mastering Ethical AI in Python: Top Trending Lessons for 2026
Python Type Hinting with Pydantic for Robust Data Validation
Python Structural Pattern Matching: The `match` Statement

FAQs

Q: How do I check if a key exists in a dictionary?
A: Use the `in` operator: `if 'key' in my_dict:`. Or use `.get()` with a default value: `value = my_dict.get('key', 'default_value')`.

Q: Can dictionary keys be lists?
A: No, keys must be immutable. Lists are mutable.

Q: What is the difference between `.keys()`, `.values()`, and `.items()`?
A: `.keys()` returns a view object of all keys. `.values()` returns a view object of all values. `.items()` returns a view object of key-value tuple pairs.

Conclusion

Dictionaries are fundamental to Python programming, providing an efficient and flexible way to manage data through key-value associations.

Comments

Post a Comment

Popular posts from this blog

Python Structural Pattern Matching: The `match` Statement

Image
Python Structural Pattern Matching: The `match` Statement Beginner Python 3.10+ introduces structural pattern matching, a powerful way to control flow based on the structure of data. Core Concept The `match` statement allows you to compare a value against a series of patterns and execute code based on the first match found. It's more than just a simple `if-elif-else` chain; it inspects the *structure* of the data. Basic Example example.py Copy def http_status(status): match status: case 200: return "OK" case 404: return "Not Found" case 500: return "Internal Server Error" case _: # Wildcard pattern return "Unknown Status Code" print(http_status(200)) print(http_status(404)) print(http_status(503)) How It Works The `match` statement evaluates th...
Read more

Python Structural Pattern Matching: The `match` Statement

Image
Python Structural Pattern Matching: The `match` Statement Intermediate The match statement, introduced in recent Python versions, provides a powerful and elegant way to implement conditional logic. It simplifies complex if/elif chains by allowing destructuring of data structures and pattern-based matching. This feature enhances readability and maintainability for control flow. Core Concept Python's match statement allows you to compare a value against several distinct patterns. It's a robust alternative to if/elif for handling multiple conditions, especially when dealing with data structures like lists, dictionaries, or objects. The match statement evaluates an expression and attempts to match its value against patterns defined in case blocks. Basic Example Copy # Simple command processing using match command = "status" match command: case "quit": print("Exiting application.") case "status": ...
Read more

Python Dictionaries: Key-Value Pairs for Efficient Data Mapping

Image
Python Dictionaries: Key-Value Pairs for Efficient Data Mapping Beginner Python dictionaries are mutable, unordered collections that store data in key-value pairs. They are ideal for fast lookups and representing relationships between data. Core Concept Dictionaries use unique keys to access associated values. Keys must be immutable (e.g., strings, numbers, tuples), while values can be of any data type. Basic Example basics.py Copy # Creating a dictionary student = { "name": "Alice", "age": 20, "major": "Computer Science" } # Accessing values print(student["name"]) print(student.get("age")) # Adding a new key-value pair student["gpa"] = 3.8 print(student) How It Works When you create a dictionary, Python uses a hashing mechanism. This allows for nearly c...
Read more