Objective

In this unit, we will learn about dictionaries in Python. Dictionaries are a type of data structure that allows you to store data as key-value pairs. By the end of this unit, you will understand how to create, access, and modify dictionaries, and you will know about some real-world applications of dictionaries.

Understanding Dictionaries

A dictionary in Python is an unordered collection of items. Each item of a dictionary has a key/value pair. Dictionaries are optimized to retrieve values when the key is known.

Here's an example of creating a dictionary:

person = {
    "name": "Alice",
    "age": 25,
    "city": "New York"
}

This dictionary represents a person, with a name, age, and city.

Creating, Accessing, and Modifying Dictionaries

You can create a dictionary by enclosing a comma-separated list of key-value pairs in curly braces {}. A colon : separates each key from its associated value.

You can access the items of a dictionary by referring to its key name, inside square brackets:

print(person["name"])

This will output Alice.

You can also change the value of a specific item by referring to its key name:

person["age"] = 26

Now, person["age"] will return 26.

Dictionary Methods

Python provides several methods that allow you to perform various operations on dictionaries. Here's a closer look at some of the most commonly used dictionary methods:

keys()

This method returns a new object that displays a list of all the keys in the dictionary.

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

values()

This method returns a new object that displays a list of all the values in the dictionary.

person_values = person.values()
print(person_values)  # Output: dict_values(['Alice', 26, 'New York'])

items()

This method returns a new object displaying a list of the dictionary's key-value tuple pairs.

person_items = person.items()
print(person_items)  # Output: dict_items([('name', 'Alice'), ('age', 26), ('city', 'New York')])

get(key[, default])

This method returns the value for the specified key if the key is in the dictionary. If not, it returns the value specified as the default. If the default value is not provided, it returns None.

age = person.get("age")
print(age)  # Output: 26

unknown = person.get("unknown_key", "Not Found")
print(unknown)  # Output: Not Found

update([other])

This method updates the dictionary with the key-value pairs from another dictionary or from an iterable of key-value pairs. If a key already exists in the dictionary, its value is updated.

person.update({"city": "Los Angeles", "state": "California"})
print(person)  # Output: {'name': 'Alice', 'age': 26, 'city': 'Los Angeles', 'state': 'California'}

pop(key[, default])

This method removes and returns the value for the specified key from the dictionary. If the key does not exist and the default value is not provided, it raises a KeyError.

city = person.pop("city")
print(city)  # Output: Los Angeles

clear()

This method removes all items from the dictionary.

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

These methods provide powerful ways to manipulate and interact with dictionaries in Python, making them an essential tool for many programming tasks.

Project: Create a Turtle Drawing Program with Command Mapping

In this project, you will create a drawing program using the Turtle library where the user can enter commands to control the turtle's actions. You will use a dictionary to map user commands to specific Turtle actions, such as moving forward, turning, changing pen color, etc.

import turtle

# Create a new turtle screen and set its background color
screen = turtle.Screen()
screen.setup(width=800, height=600)
screen.bgcolor("white")

# Initialize a turtle object
t = turtle.Turtle()

# Dictionary to map user commands to Turtle actions
command_mapping = {
    'forward': t.forward,
    'backward': t.backward,
    'left': t.left,
    'right': t.right,
    'color': t.color
}

# Function to execute user commands
def execute_command(command, value):
    command_mapping[command](value)

# Main loop to get user input
while True:
    command = input("Enter command (or 'exit' to quit): ")
    if command == 'exit':
        break

    if command not in command_mapping:
        print("Unknown command! Available commands:", list(command_mapping.keys()))
        continue

    value = input("Enter value: ")

    if command != 'color':
        value = int(value)

    execute_command(command, value)

# Hide the turtle and wait until the window is closed
t.hideturtle()
turtle.done()

Here, a dictionary called command_mapping is defined to map user-friendly command strings like "forward" and "backward" to specific Turtle functions like t.forward and t.backward. This dictionary serves as the core of the program, allowing for a flexible and easily extendable command system.

A function named execute_command is created to take a command and a value as its parameters, using the command_mapping dictionary to find the Turtle function that corresponds to the given command, and then calling that function with the given value.

The main part of the program is a while loop that continuously asks the user for a command. If the user enters 'exit', the loop breaks, and the program ends. If the command is not found in the command_mapping dictionary, an error message is displayed, and the loop continues. The value is taken as a string or an integer depending on the command, and the execute_command function is called to execute the corresponding Turtle action.

Take some time to play with the code and try adding more commands to the dictionary. For example, can you add a dictionary key called "pensize" that maps to t.pensize?

In the next unit, we'll look at file operations in Python and learn how to read and write data to files.