Working with Lists and Dictionaries

Part 1: Lists - Your Digital Backpack

Think of a list in Python like an inventory in an RPG. It's a container where you can store items in a specific order, add new ones, and remove old ones.

A list is an ordered, changeable collection of items.

Let's start with a comprehensive video that covers the basics of creating and working with lists.

As the video explained, zero-based indexing is a core concept. The first item is at index 0, the second at index 1, and so on. This is a common convention in many programming languages.

Here's a quick example for your RPG:

# A player's starting inventory
inventory = ["Rusty Sword", "Bread", "Cloth Tunic"]

# Let's see what the first item is
first_item = inventory[0]
print(f"The first item is: {first_item}") # Output: The first item is: Rusty Sword

# What's the last item?
last_item = inventory[-1]
print(f"The last item is: {last_item}") # Output: The last item is: Cloth Tunic

Manipulating Lists: Adding and Removing Items

Your inventory changes as you play an RPG. You find new loot and use up items. Lists have built-in functions (called methods) to handle this.

Let's continue with the video to see how to add and remove items.

The .pop() method is especially useful in games. Imagine using a potion: you want to remove it from your inventory and get its information to apply its healing effect.

inventory = ["Rusty Sword", "Healing Potion", "Cloth Tunic"]
print(f"Inventory before using potion: {inventory}")

# The player uses a potion. We remove it from the list and can use the value.
used_item = inventory.pop(1) # Removes the item at index 1
print(f"Player uses a {used_item}!")
# Now you could write code to restore the player's health.

print(f"Inventory after using potion: {inventory}")

Output:

Inventory before using potion: ['Rusty Sword', 'Healing Potion', 'Cloth Tunic']
Player uses a Healing Potion!
Inventory after using potion: ['Rusty Sword', 'Cloth Tunic']

inventory = ["Shield", "Apple"]

# 1. Add "Dragon's Tooth"
inventory.append("Dragon's Tooth")
# inventory is now ["Shield", "Apple", "Dragon's Tooth"]

# 2. Remove "Shield" and add it to the end
inventory.remove("Shield")
inventory.append("Shield")
# inventory is now ["Apple", "Dragon's Tooth", "Shield"]

# 3. Remove "Apple"
inventory.remove("Apple")
# inventory is now ["Dragon's Tooth", "Shield"]

# 4. Print the final list
print(f"Final inventory: {inventory}")

# Expected output:
# Final inventory: ['Dragon's Tooth', 'Shield']

Part 2: Dictionaries - Your Character Sheet

While lists are great for ordered collections, they aren't ideal for storing structured data like a character's stats. It would be confusing to remember that stats[0] is HP, stats[1] is MP, and so on.

A dictionary is perfect for this. It's an unordered collection of key-value pairs. You look up a value by its specific key, just like looking up a word in a dictionary to find its definition.

Using .get() is a great habit to build. If you try player_stats['Stamina'] and the 'Stamina' key doesn't exist, your program will crash. If you use player_stats.get('Stamina'), it will simply return None (or a default value you provide), which you can handle gracefully.

Here's how you'd define a character and a monster:

player = {
    "Name": "Galador",
    "HP": 100,
    "MP": 50,
    "Class": "Knight"
}

slime_monster = {
    "Name": "Green Slime",
    "HP": 25,
    "Attack": 4
}

# Accessing data is clear and readable
print(f"{player['Name']} has {player['HP']} HP.")
print(f"The {slime_monster['Name']} has {slime_monster['Attack']} attack power.")

Output:

Galador has 100 HP.
The Green Slime has 25 attack power.

Manipulating Dictionaries: Updating Stats

A character's stats are not static. Their HP changes in combat, and they might gain new abilities. Dictionaries are easy to modify.

Here's a combat example. Notice how readable it is:

slime_monster = {
    "Name": "Green Slime",
    "HP": 25,
    "Attack": 4
}

damage_taken = 10
print(f"The {slime_monster['Name']} has {slime_monster['HP']} HP.")

# Update the slime's HP
slime_monster['HP'] = slime_monster['HP'] - damage_taken

print(f"After taking {damage_taken} damage, it now has {slime_monster['HP']} HP.")

# The slime gets enraged! Let's add a status effect.
slime_monster['Status'] = 'Enraged'
print(f"The slime's current status is: {slime_monster}")

Output:

The Green Slime has 25 HP.
After taking 10 damage, it now has 15 HP.
The slime's current status is: {'Name': 'Green Slime', 'HP': 15, 'Attack': 4, 'Status': 'Enraged'}

Looping Through Dictionaries

What if you want to display all of a character's stats? You can loop through a dictionary. The .items() method is especially useful as it gives you both the key and the value on each iteration.

Example: Displaying a character sheet.

player = {
    "Name": "Galador",
    "HP": 100,
    "MP": 50,
    "Class": "Knight"
}

print("--- CHARACTER SHEET ---")
for stat_name, stat_value in player.items():
    print(f"{stat_name}: {stat_value}")
print("-----------------------")

Output:

--- CHARACTER SHEET ---
Name: Galador
HP: 100
MP: 50
Class: Knight
-----------------------

Combining Lists and Dictionaries

The real power for game development comes when you combine these two data structures.

• An inventory can be a list of dictionaries, where each dictionary describes an item.
• A game world can be a dictionary of dictionaries, where each key is a room name and its value is a dictionary describing that room's exits and items.

This is exactly how many text-based RPGs are built.

This structure is powerful and flexible. You can define your entire game world in a structure like this, and then write functions that navigate and modify it based on player commands.

Here's another example: an inventory as a list of dictionaries.

inventory = [
    {
        "name": "Healing Potion",
        "type": "Consumable",
        "effect": "Heals 25 HP"
    },
    {
        "name": "Iron Sword",
        "type": "Weapon",
        "damage": 12
    }
]

# Get the name of the second item in the inventory
print(inventory[1]["name"]) # Output: Iron Sword

# Loop through the inventory and print a description for each item
for item in inventory:
    print(f"- {item['name']} ({item['type']})")

Output:

Iron Sword
- Healing Potion (Consumable)
- Iron Sword (Weapon)

To see these concepts in the context of simple, complete games, check out the examples in the article "9 Easy Games to Make in Python".

• The "Word Rescue" game (Section 2) uses a list to store the letters of the hidden word.
• The "Quiz Game" (Section 4) uses a dictionary to store questions and answers.

You can find this resource here: https://www.idtech.com/blog/easy-games-to-make-in-python. Exploring its code is a great way to reinforce what you've learned.

Conclusion

You've just learned about two of the most important tools in your Python toolbox. Mastering lists and dictionaries is essential for managing the complex data that makes a game world feel alive.

Here are the key takeaways:

• Lists are ordered collections, accessed by an integer index (starting at 0). Use them for sequences like inventories, waypoints, or animations.
• Dictionaries are unordered collections of key-value pairs, accessed by a unique key. Use them for structured data like character stats, item properties, or level data.
• The most powerful applications often come from nesting lists and dictionaries to model complex game data.

In our next lesson, we'll take another big step forward by learning about classes and objects. You've learned how to store data in lists and dictionaries, and how to write logic in functions. Classes will allow us to bundle related data and functions together into a single, neat package, like a Player object that not only holds HP and inventory but also has its own attack() and use_item() methods.