List and Dictionary Essentials

Part 1: Lists - Ordered Collections

A list in Python is an ordered, mutable (changeable) collection of items. Think of it like a to-do list or a list of test cases to execute—the order is important, and you can add, remove, or change items.

Creating and Understanding Lists

The most common way to create a list is by placing items inside square brackets [], separated by commas.

# A list of browsers for cross-browser testing
browsers = ["chromium", "firefox", "webkit"]




# A list of test case IDs (mixed data types)
test_ids = ["TC-01", "TC-02", 5, 12] 

The video "How to Use Lists in Python" by Programming with Mosh provides an excellent, fast-paced introduction to creating and working with lists.

Accessing and Modifying List Items

Because lists are ordered, you can access any item by its position, or index. Python uses a zero-based index, meaning the first item is at index 0. You can also use negative indices to count from the end of the list (-1 is the last item).

Beyond accessing single items, you can extract a sub-list using a technique called slicing.

Let's continue with the video from Programming with Mosh to see these concepts in action.

Adding and Removing Items

Your test data and the state of your application are rarely static. You'll often need to add or remove items from a list. Python provides several methods for this.

Looping and Finding Items in Lists

In the last lesson, you learned how to use a for loop to iterate over a list. A common requirement is to get not only the item but also its index. For this, Python provides the enumerate() function.

If you just need to find where an item is or check if it exists, you can use the index() method or the in operator.

The final segments of the video we've been watching cover these techniques perfectly.

Part 2: Dictionaries - Key-Value Pairs

While lists are great for ordered sequences, we often need to store data with named labels. For example, instead of ['John', 25, 'Math'], it's much clearer to have { 'name': 'John', 'age': 25, 'course': 'Math' }. This is where dictionaries come in.

A dictionary is a mutable collection of key-value pairs. Each key must be unique and is used to look up its corresponding value. This structure is extremely similar to JSON, which is the standard format for most modern APIs.

Creating and Working with Dictionaries

Dictionaries are created with curly braces {}. Let's watch a comprehensive tutorial by Corey Schafer that walks through the essential dictionary operations.

Adding, Updating, and Removing Entries

Like lists, dictionaries are mutable. You can add new key-value pairs, change existing values, and remove entries.

Looping Over Dictionaries

Looping is a primary way to process all the data in a dictionary. You can loop through its keys, its values, or its key-value pairs.

Let's Practice

Now, let's combine these concepts in a practical exercise. A common task is to count the occurrences of items in a collection. We will write a script to count the occurrences of each word in a sentence.

This is a classic problem that perfectly illustrates how dictionaries are used to aggregate data. The logic follows a simple pattern:

1. Initialize an empty dictionary.
2. Loop through each word in the sentence.
3. For each word, check if it's already a key in our dictionary.
   • If yes, increment its value (the count).
   • If no, add it as a new key with a value of 1.

The following flowchart visualizes this exact process.

Your Task:
Using the logic from the flowchart, write a Python script that takes the string sentence and produces a dictionary where each key is a word and its value is the number of times that word appears.

Hint: The split() string method will be useful for getting a list of words, and the dictionary's .get(key, 0) method is perfect for handling words you haven't seen yet.

sentence = "the quick brown fox jumps over the lazy dog"




# Your code here
# 1. Initialize an empty dictionary
word_counts = {}




# 2. Split the sentence into a list of words
words = sentence.split()




# 3. Loop through the list of words
for word in words:



    # 4. For each word, update the dictionary
    # If the word is already a key, get its current count, otherwise default to 0.
    # Then add 1 and update the key.
    word_counts[word] = word_counts.get(word, 0) + 1




# 5. Print the final dictionary
print(word_counts)

Expected Output:

{'the': 2, 'quick': 1, 'brown': 1, 'fox': 1, 'jumps': 1, 'over': 1, 'lazy': 1, 'dog': 1}

This simple but powerful pattern of using .get() with a default value is one you will use frequently when processing data.

Conclusion

In this lesson, you've gained a solid understanding of Python's two most important data structures. They are the containers you will use to manage almost all of your test data.

Here are the key takeaways:

• Lists are ordered, zero-indexed collections, accessed by their numerical position. They are ideal for sequences of items, like a list of test environments or expected results.
• Dictionaries are collections of key-value pairs, accessed by a unique key. They are perfect for storing structured information, like a user's profile, test configuration, or an API response.
• Both lists and dictionaries are mutable, meaning you can change their contents after they are created.
• You can use for loops to iterate over both, but the patterns differ slightly. Looping over a dictionary's .items() to get both the key and value is a very common and powerful technique.

You now have a strong grasp of Python's basic data types, control flow (if/else), loops, and data collections. In our next lesson, we'll learn how to package all this logic into functions, allowing us to create reusable, organized, and maintainable code—the foundation of any good test automation framework.