Core Data Structures: Lists, Tuples, and Dictionaries

1. Lists: The Workhorse of Data Collections

A list is an ordered, mutable (changeable) collection of items. This is your most frequently used data structure for holding sequences of data.

In the previous lesson, we created a list like this: campaign_ctrs = [1.2, 3.5, 0.4]. Let's now dive deep into how to work with them.

A Practical Example: Managing Ad Campaigns

Let's apply these concepts to a business scenario. Imagine you're managing a list of active ad campaigns for a client.

# A list of campaign IDs (as strings)
active_campaigns = ['SummerSale_2024', 'BackToSchool_2024', 'HolidayPromo_Q4']

# A new campaign is launched
active_campaigns.append('NewYear_2025')
print(f"After adding a campaign: {active_campaigns}")

# The 'BackToSchool' campaign is over and needs to be removed
active_campaigns.remove('BackToSchool_2024')
print(f"After removing a campaign: {active_campaigns}")

# You want to access the first campaign in the list
first_campaign = active_campaigns[0]
print(f"The first campaign is: {first_campaign}")

Sorting and Looping

Once you have data in a list, you often need to sort it or iterate through it to perform an action on each item. This connects directly to what we learned about for loops.

Here's how you might combine these ideas. Let's say you have a list of daily ad spend and you want to find the total, min, and max spend.

daily_spend = [250.75, 310.50, 198.00, 450.25, 290.00]

total_spend = sum(daily_spend)
min_spend = min(daily_spend)
max_spend = max(daily_spend)

print(f"Total spend: ${total_spend:.2f}")
print(f"Lowest daily spend: ${min_spend:.2f}")
print(f"Highest daily spend: ${max_spend:.2f}")

# You can also loop through to generate a report
print("\n--- Daily Spend Report ---")
for day, spend in enumerate(daily_spend):
    print(f"Day {day + 1}: ${spend:.2f}")

scores = [7, 8, 10, 5, 9]

# 1. Add a new score
scores.append(6)  # scores is now [7, 8, 10, 5, 9, 6]

# 2. Remove a score
scores.remove(5)  # scores is now [7, 8, 10, 9, 6]

# 3. Sort in descending order
scores.sort(reverse=True)

# 4. Print the final list
print(scores)

2. Tuples: The Immutable Collection

Tuples are very similar to lists—they are also ordered collections. However, there is one critical difference: tuples are immutable, meaning they cannot be changed after they are created. You create them with parentheses () instead of square brackets [].

So, when would you use a tuple instead of a list?

• Data Integrity: When you have data that should not change, like the RGB color code (255, 0, 0) for red, or the geographic coordinates (40.7128, -74.0060) for New York City.
• Performance: Tuples can be slightly more memory-efficient and faster than lists.
• Dictionary Keys: As we'll see next, you can use tuples as keys in a dictionary, but you cannot use lists.

3. Dictionaries: Storing Data with Key-Value Pairs

A dictionary is an unordered (in Python versions before 3.7) collection of key-value pairs. Think of it like a real-world dictionary: you look up a unique word (the key) to find its definition (the value). Dictionaries are created with curly braces {}.

This structure is incredibly useful for a BA because it allows you to represent a single object with many named attributes. For example, instead of separate variables for a user's ID, country, and status, you can group them into one dictionary.

A Practical Example: Representing User Data

Let's model a user from your AdTech platform using a dictionary.

user_profile = {
    'user_id': 'xyz-987',
    'country': 'USA',
    'total_spend': 150.50,
    'last_seen_days_ago': 5
}

# Accessing data
print(f"User {user_profile['user_id']} is from {user_profile['country']}.")

# Using .get() for a key that might not exist
# This avoids an error and returns 'not provided' instead
subscription_tier = user_profile.get('tier', 'not provided')
print(f"Subscription Tier: {subscription_tier}")

# Updating the user's spend
user_profile['total_spend'] += 25.00
print(f"User's new total spend: {user_profile['total_spend']}")

# Adding a new key-value pair
user_profile['is_active'] = True

# Looping through to display all profile information
print("\n--- Full User Profile ---")
for key, value in user_profile.items():
    print(f"{key}: {value}")

4. Application: Structuring Data for Analysis

Now let's see how these structures are combined in a real-world analytical task. Imagine you need to generate synthetic data for customer segmentation analysis. You have to define the statistical properties (like average age and income) for several customer segments.

How would you store this configuration data in your script? A nested dictionary is a perfect solution.

The segment_statistics dictionary is a great example of professional-level data structuring. It's self-describing—you access income with ['income'] instead of remembering it's the 3rd item in a list (index 2). As a BA writing scripts for analysis, adopting this clear, explicit style is a key skill that makes your work more reliable and easier for others to understand.

5. A Brief Look at Sets

Before we conclude, there's one more built-in data structure to know: the set. A set is an unordered collection with no duplicate elements.

For a BA, the most common use of a set is to find unique items.

AdTech Example: Imagine you have a log file of every ad impression, with the user_id for each impression. How do you find the number of unique users reached?

# A list of user IDs from impression logs (with duplicates)
impression_log = ['user1', 'user2', 'user1', 'user3', 'user2', 'user1']

# Convert the list to a set to get unique users
unique_users = set(impression_log)

print(f"Raw impressions: {len(impression_log)}")
print(f"Unique users reached: {len(unique_users)}")
print(f"The unique users are: {unique_users}")

Conclusion

Great work! You've just covered the fundamental ways Python stores and organizes collections of data. Mastering these is non-negotiable for anyone working with data in Python.

Key Takeaways:

• Lists []: Your go-to for an ordered sequence of items that you might need to change (add, remove, sort).
• Tuples (): Use these for ordered sequences of items that should not change, ensuring data integrity.
• Dictionaries {}: The best choice for storing a single record with named fields (key-value pairs), like a user profile or a product's attributes.
• Sets set(): The perfect tool when you need to work with unique items or check for membership efficiently.

Choosing the right data structure for the task at hand is a hallmark of an effective programmer and analyst.

Preview of the Next Lesson:
So far, we've been writing our code in one long script. If you wanted to calculate the average spend for three different lists of campaigns, you'd have to copy and paste your code three times. This is inefficient and error-prone. In our next lesson, we will learn how to create reusable code blocks called functions, allowing you to write cleaner, more modular, and more powerful analytical scripts.