Tutorial 2: Basic Operators and Data Structures in Python

When I first started learning Python for data analysis, I felt overwhelmed by the sheer volume of information and the complexity of the tasks ahead. But as I began to explore Python's basic operators and data structures, I discovered a world of possibilities that transformed my approach to data analysis. In this tutorial, I'll share my journey and the key insights I've gained, focusing on three fundamental Python concepts: for loops, conditional statements, and dictionaries.

These building blocks of Python programming have not only streamlined my data processing tasks but have also opened up new avenues for insightful analysis that I couldn't have imagined when I first started. Even if you're just beginning your Python journey, or you're looking to enhance your existing skills, this tutorial will provide you with practical examples and real-world applications that you can apply to your own data analysis projects. Here's what we'll cover:

1. We'll start by exploring Python for loops, which are incredibly useful for handling repetitive tasks and help with keeping your code DRY (Don't Repeat Yourself). As an example, in a recent project at Dataquest, I used a for loop to process each course in our catalog in order to create a script that would automate the creation of course prerequisites. This experience reminded me of how Python can transform tedious tasks into efficient processes. Whenever you're dealing with lots of data or performing repetitive tasks, for loops can save you time and avoid headaches.

2. After learning about loops, we'll examine conditional statements―the decision-making tools of your code. By using if, else, and elif statements, you'll be able to empower your program to make choices based on specific conditions before executing particular code snippets. These conditional tools are essential when you need your analysis to adapt to different scenarios or data characteristics.

3. Next up, we'll explore dictionaries, one of Python's most versatile data structures. Think of them as organized containers for data, where each piece of information is easily accessible by name. In data analysis, dictionaries can help you structure complex datasets, making them easier to manipulate and understand.

4. Finally, by combining these concepts, you'll see how you can create scripts that automate tasks, clean datasets, and perform complex calculations. You'll discover how these tools can be applied across various areas of data science, from preprocessing data for machine learning models to extracting actionable insights from your data.

As we explore these essential Python building blocks, think about how you might apply them in your own work. What time-consuming tasks could you automate? How could you use these tools to dig deeper into your datasets and uncover hidden insights?

Let's begin by taking a close look at Python for loops and learn how we can leverage them to become more efficient programmers.

Lesson 1 – Python For Loops

When I started working with large datasets, I often found myself repeating the same operations over and over. That's when I really started to take advantage of using Python for loops. These powerful tools will forever change the way you handle repetitive tasks, allowing you to process large amounts of data with just a few lines of code. Here's a short animation showing a Python for loop in action:

In their most basic form, Python for loops allow you to iterate over a sequence (like a list or string) and perform an action for each item. Let's breakdown a simple example based on the animation above:

In this example, value is our iteration variable. However, we can use any iteration variable name we want here. So in real-world situations, it's a good idea to choose something that's a little more descriptive. While iterating over a_list, the iteration variable (value) takes on the value of each item in a_list (one at a time), allowing us to perform an action (in this case, printing) for each item in the list.

Although this was a simple example, for loops really shine when working with larger datasets. Imagine you have information about multiple apps, each represented as a list within a larger list. You can use a for loop to process this data efficiently:

app_data_set = [row_1, row_2, row_3, row_4, row_5]

rating_sum = 0
for row in app_data_set:
    rating = row[-1]
    rating_sum = rating_sum + rating

print(rating_sum)

Let's break this code down:

1. We start with rating_sum = 0 to initialize our sum.
2. The loop goes through each row in app_data_set.
3. For each row, we extract the rating (the last item in the list) with row[-1].
4. We add this rating to our running total in rating_sum.
5. After the loop finishes, we print the total sum of ratings.

I've noticed many learners struggle with knowing which lines of code are part of the loop and which aren't. Allow me to clarify this for you now. Notice that the two lines of code following the for loop are indented compared to the rest of the code. These two lines form the body of the loop and signals that only they are executed with each iteration of the loop. At the end of the day, this loop calculates the sum of ratings for all apps in the dataset and then prints the result. The result would represent the total of all ratings. From here, we could go on to calculate the average rating by dividing rating_sum by the number of apps.

At Dataquest, we use for loops daily to analyze course data. For example, we once needed to calculate the average completion time for each lesson in a course. By using a for loop to iterate through the lesson data, we were able to quickly identify which lessons were taking longer than expected. This insight helped us optimize our course content, improving the learning experience for our students.

Here are some tips for using for loops effectively in your data analysis:

• Start with basic loops and gradually increase complexity as you become more comfortable.
• Use descriptive variable names to make your code more readable and easier to understand.
• Pay attention to indentation, as Python uses it to define the body of the loop.
• Consider using enumerate() if you need both the index and value of items in your loop.
• Be mindful of performance, and consider using more advanced techniques like list comprehensions or vectorized operations for very large datasets.

Loops are a powerful tool that can help you automate repetitive tasks, handle large datasets efficiently, and uncover insights that might be missed with manual analysis. As you continue to work with Python, you'll find countless ways to apply for loops in your data science projects.

Remember, practice makes perfect. Don't be afraid to experiment with for loops in your own projects. Start by identifying repetitive tasks in your current workflows. Could a for loop make that task more efficient? Could it help you analyze your data in a new way? You might be surprised at how much they can improve your data analysis capabilities.

In the next lesson, we'll explore how to combine for loops with conditional statements, opening up even more possibilities for your data analysis toolkit. But for now, try writing a few for loops of your own. The more you practice, the more natural they'll become, and the more time you'll save in your data analysis tasks.

Lesson 2 – Making Decisions with Python: If, Else, and Elif Statements

As you continue to expand your Python skillset, you're going to need a tool that allows your code to make decisions: conditional statements. These statements are essential for creating flexible and responsive data analysis workflows, especially if, else, and elif.

At its core, an if statement allows your code to ask a question and take different actions based on the answer. Let's look at a simple example:

if True:
    print(100)

Running this code would output:

100

In this case, the condition True is always met, so the code inside the if block (indented) will always run. But conditions aren't always True.

The real power comes when we use conditions that can change based on our data. So now let's look at some more examples of how if statements behave if they're always False:

if True:
    print('First Output')

if False:
    print('Second Output')

if True:
    print('Third Output')

Output:

First Output
Third Output

Notice how the second print() statement doesn't execute because its condition is False. This demonstrates how if statements allow your code to selectively run based on conditions you specify. To be clear, we rarely use True and False like this when creating conditional statements. Rather, we tend to use comparison operators like >, <, ==, and != which will evaluate to either True or False based on our data. For reference, here are some of the most used Python comparison operators:

And here's a coding example that shows how they work:

Let's take a look at one more example where we iterate over a list of apps and their prices in order to create a list of free apps based on the condition price == 0:

app_and_price = [['Facebook', 0], 
                ['Instagram', 0], 
                ['Plants vs. Zombies', 0.99], 
                ['Minecraft: Pocket Edition', 6.99], 
                ['Temple Run', 0], 
                ['Plague Inc.', 0.99]
]

free_apps = []
for app in app_and_price:
    name = app[0]
    price = app[1]

    if price == 0:
        free_apps.append(name)

print(free_apps)

This code produces this output:

['Facebook', 'Instagram', 'Temple Run']

I recall when I first started using if statements in my data analysis work. We were analyzing student progress data, and I needed to flag courses where less than 50% of learners were finishing. Here's a simplified version of what I used:

if completion_rate < 0.5:
    print('This course needs attention')

This simple condition allowed us to quickly identify courses that needed improvement, streamlining our curriculum development process. By automating this check, we were able to focus our efforts on the courses that truly needed our attention, rather than manually reviewing each one. It made a significant difference for our team's efficiency.

In your data analysis work, you might use if statements to filter out outliers or irrelevant data points, categorize data into different groups based on certain criteria, or handle missing or incorrect data.

While if statements are powerful on their own, they become even more versatile when combined with else and elif (a combination of else and if) statements. These allow you to specify alternative actions when the initial condition isn't met. For example, you might use an else statement to handle all cases that don't meet your if condition, or use elif to check multiple conditions in sequence. We'll explore these in more depth in the next lesson.

When you're using if statements in your data analysis workflows, keep these tips in mind:

1. Make your conditions clear and readable: Complex conditions can be hard to debug.
2. Be careful with floating-point comparisons: Due to how computers represent decimals, it's often better to use ranges rather than exact equality.
3. Don't nest if statements within else statements: Use elif when you have multiple mutually exclusive conditions to check. We'll look at these in the next lesson.

As you continue to work with Python, you'll find that becoming proficient in conditional statements opens up new possibilities for your data analysis. They help your code respond to the data, making your analysis more reliable and informative. By implementing these decision-making tools, you're taking a significant step towards more sophisticated and efficient data analysis workflows.

Now let's build on this foundation and explore how to use else and elif statements to create even more nuanced decision-making processes in your code. These tools will further enhance your ability to handle complex data scenarios and extract meaningful insights from your datasets.

Lesson 3 – Working with Multiple Conditions in Python

Learning how to use multiple conditions in if statements was a turning point in my data analysis journey. I could create nuanced categories and handle complex scenarios with ease.

Let me share an example from one of our Python lessons at Dataquest that uses the same dataset as the previous example above. In the lesson, you're given a dataset of mobile apps, and you need to categorize them based on their price. Here's how you'd do that:

apps_data = [['Facebook', 0.0], 
             ['Notion', 14.99], 
             ['Astropad Standard', 29.99], 
             ['NAVIGON Europe', 74.99]
]

for app in apps_data:
    price = app[1]

    if price == 0.0:
        app.append('free')
    elif price > 0.0 and price < 20:
        app.append('affordable')
    elif price >= 20 and price < 50:
        app.append('expensive')
    elif price >= 50:
        app.append('very expensive')

print(apps_data)

This code sorts each app into a price category. When you run it, here's what you'd get:

[['Facebook', 0.0, 'free'], 
['Notion', 14.99, 'affordable'], 
['Astropad Standard', 29.99, 'expensive'], 
['NAVIGON Europe', 74.99, 'very expensive']]

But price isn't the only thing you might want to evaluate. Let's look at another example where you categorize apps based on their user ratings:

app_ratings = [['Facebook', 3.5], 
               ['Notion', 4.0], 
               ['Astropad Standard', 4.5], 
               ['NAVIGON Europe', 3.5]
]

for app in app_ratings:
    rating = app[1]

    if rating < 3.0:
        app.append('below average')
    elif rating >= 3.0 and rating < 4.0:
        app.append('roughly average')
    elif rating >= 4.0:
        app.append('better than average')

print(app_ratings)

This script puts apps into categories based on their ratings. The output would look like this:

[['Facebook', 3.5, 'roughly average'], 
 ['Notion', 4.0, 'better than average'], 
 ['Astropad Standard', 4.5, 'better than average'], 
 ['NAVIGON Europe', 3.5, 'roughly average']]
 

We use similar approaches at Dataquest all the time. For instance, when we developed a new data science course, we used multiple conditions to analyze student performance across different topics. By looking at both practice problem scores and project completion rates, we could identify areas where students needed extra help.

Here are some tips to keep in mind when working with multiple conditions:

1. Keep your conditions simple: Write them in a way that's easy to read and understand. You'll thank yourself later when you're debugging!
2. Be careful with decimals: Computers can be tricky with decimal numbers. It's often safer to use ranges instead of exact comparisons.
3. Use elif for options that can't overlap: If you're dealing with categories where an item can only be in one category, elif is your friend.
4. Test your logic: Always run your code with different inputs to make sure it's behaving the way you expect.

By becoming proficient at setting up multiple conditions, you're adding a powerful tool to your data analysis toolkit. You'll be able to ask more nuanced questions of your data and get more insightful answers.

As you continue working with Python, you'll find all sorts of ways to use these concepts in your data projects. In the next lesson, we'll explore how to store our data in one of Python's most convenient data structures: dictionaries.

Lesson 4 – Organizing Data with Python Dictionaries

Now that we've explored for loops and conditional statements, let's discuss a powerful tool that has revolutionized the way we work with data: Python dictionaries. If you've been following our Introduction to Python guide, you know how useful lists can be. But what if you need to organize information in a more structured way than lists allow?

Dictionaries are the perfect solution. They're flexible and incredibly useful for analyzing data. Unlike lists, which use numerical indices, dictionaries use keys to access values. This makes them ideal for storing and retrieving data that has a natural pairing, like words and their definitions in an actual dictionary, or in the example below, content ratings and their corresponding numbers.

Let's create a dictionary:

content_ratings = {'4+': 4433, '9+': 987, '12+': 1155, '17+': 622}
print(content_ratings)

And here's the resulting dictionary output:

{'4+': 4433, '9+': 987, '12+': 1155, '17+': 622}

In this example, we're storing information about content ratings. The keys ('4+', '9+', etc.) represent different rating categories, and the values (4433, 987, etc.) represent the number of apps in each category. Here's a quick animation showing how we can take this data represented in a table, and convert it to a Python dictionary:

One of the things I appreciate most about dictionaries is how intuitive they are when retrieving data; referencing dictionary_name[key] will return its associated value. Need to know how many apps have a '12+' rating? Simply access the data using content_ratings['12+'] and you'll get 1155. It's that easy!

But what if you need to build your dictionary piece by piece? No problem. Here's another way to create that same content ratings dictionary:

content_ratings = {} 
content_ratings['4+'] = 4433
content_ratings['9+'] = 987
content_ratings['12+'] = 1155
content_ratings['17+'] = 622

print(content_ratings)

Since it's the same dictionary, this produces the same output as before:

{'4+': 4433, '9+': 987, '12+': 1155, '17+': 622}

This method can be particularly useful when you're working with a small dataset and you want your code to be highly readable. It's also a useful method for adding data to an existing dictionary.

When I started working on a new course on data cleaning at Dataquest, we needed a way to track different types of data issues and their frequencies. Dictionaries were the ideal solution. We could easily update the count for each issue type as we processed the data, giving us a clear overview of the most common problems. This not only streamlined our course development process but also provided valuable insights that we used to improve our curriculum.

If you're working with data you want to organize it, dictionaries can significantly improve your workflow. They allow you to create meaningful associations between data points, making your code more readable and your analysis more intuitive. For instance, you could use dictionaries to organize customer data, linking each customer ID to a set of attributes like name, age, and purchase history.

Here are a few tips I've picked up for using dictionaries effectively in data analysis:

1. Use descriptive keys: Make your dictionaries self-documenting by using clear, meaningful keys.
2. Be consistent: If you're using dictionaries to represent similar objects, keep the structure consistent.
3. Combine with other data structures: Dictionaries can contain lists, or even other dictionaries, allowing for complex data representation. This applies to both dictionary keys and values.

As you continue to enhance your data analysis skills, you'll find that dictionaries become an essential part of your Python toolkit. They're not just for storing data―they're a powerful way to structure your thinking about data relationships. Whether you're cleaning datasets, building feature sets for machine learning, or creating complex data pipelines, dictionaries will help you organize and access your data efficiently.

In the next lesson, we'll explore how to use dictionaries to create frequency tables, a common task in data analysis. This will further demonstrate how Python's data structures can streamline your workflow and reveal deeper insights from complex datasets. For now, I encourage you to experiment with dictionaries in your own projects. You might be surprised at how they can simplify your code and improve the structure of your data.

Lesson 5 – Creating Frequency Tables with Python Dictionaries

Now that we've learned about Python dictionaries, let's explore how they can be used to create frequency tables. These tables are a powerful tool in data analysis, helping us understand how often each value appears in our data.

At Dataquest, we regularly use frequency tables to analyze our course data. For example, we might want to know how many students are enrolled in each course category or what percentage of users are completing different types of projects.

Here's how we can create a frequency table for the app data example using Python dictionaries:

content_ratings = {}
ratings = ['4+', '4+', '4+', '9+', '9+', '12+', '17+']

for c_rating in ratings:
    if c_rating in content_ratings:
        content_ratings[c_rating] += 1
    else:
        content_ratings[c_rating] = 1

print(content_ratings)

This code gives us:

{'4+': 3, '9+': 2, '12+': 1, '17+': 1}

We're looping through our data, checking each app's content rating. If we've seen that rating before, we increment its count. If it's new, we add it to our dictionary with a count of 1. The result is a summary of how many apps fall into each content rating category.

Dictionaries are great for frequency tables because they're efficient. They make it easy to access and update our counts as we process our data. This efficiency is especially important when working with larger datasets.

On top of the raw count, we often need to know the proportion or percentage of items in each category. Here's how we can transform our frequency table to proportions and percentages:

c_ratings_proportions = {}
c_ratings_percentages = {}
total_number_of_apps = 7

for key in content_ratings:
    proportion = content_ratings[key] / total_number_of_apps
    percentage = proportion * 100

    c_ratings_proportions[key] = proportion
    c_ratings_percentages[key] = percentage

print(c_ratings_proportions)
print(c_ratings_percentages)

This creates two new dictionaries: one for proportions and one for percentages. We can easily switch between different types of measurements, which lets us analyze our data in different ways. Here's what that output would look like:

{'4+': 0.43, '9+': 0.29, '12+': 0.14, '17+': 0.14}
{'4+': 42.86, '9+': 28.57, '12+': 14.29, '17+': 14.29}

I've used these exact techniques to analyze our course completion rates at Dataquest by creating a frequency table to see how many students were completing each course. When I converted the raw numbers to percentages, we discovered our SQL courses had a lower completion rate than our Python courses. This insight led us to revamp our SQL curriculum, making it more engaging and practical. Within a few months, we saw the SQL completion rates improve significantly.

If you're working with data, I encourage you to try using frequency tables with dictionaries. They're a simple yet powerful way to summarize and understand your data. Here are some tips to get you started:

1. Identify what you want to count in your dataset.
2. Create a dictionary to store your counts.
3. Loop through your data, updating the dictionary as you go.
4. Consider converting your frequencies to proportions or percentages for easier interpretation.
5. Use separate dictionaries for different types of measurements (counts, proportions, percentages) to keep your data organized.

Remember, frequency tables are just one tool in your data analysis toolkit, but they're one I find incredibly useful in my day-to-day work. They can help you quickly identify patterns, outliers, and trends in your data, providing a solid foundation for deeper analysis.

In the final lesson of this tutorial, we'll explore how to combine all the concepts we've learned so far to tackle more complex data analysis tasks. You'll see how loops, conditionals, and dictionaries work together to create powerful data processing pipelines.

Lesson 6 – Bringing It All Together

By combining loops, conditionals, and dictionaries, we can create sophisticated data analysis workflows that can handle complex, real-world datasets. Let me share a recent experience from my work at Dataquest that illustrates this perfectly.

We wanted to analyze student engagement across all our courses, looking at factors like course score, time spent on lessons, and the number of attempts made on practice problems. This task required us to use all the concepts we've discussed above.

Here's a simplified version of the code we used:

course_data = [
    ['Python Basics', [80, 85, 90, 75, 88]],
    ['SQL Fundamentals', [70, 65, 72, 68, 74]],
    ['Data Visualization', [85, 92, 88, 90, 95]]
]

course_stats = {}

for course in course_data:
    course_name = course[0]
    scores = course[1]

    total_score = 0
    num_students = len(scores)

    for score in scores:
        total_score += score

    avg_score = total_score / num_students

    if avg_score >= 85:
        performance = 'Excellent'
    elif avg_score >= 70:
        performance = 'Good'
    else:
        performance = 'Needs Improvement'

    course_stats[course_name] = {
        'average_score': avg_score,
        'performance': performance
    }

print(course_stats)

This code does several things:

1. It loops through each course in our dataset.
2. For each course, it calculates the average score using a nested loop.
3. It uses conditional statements to categorize the course performance based on the average score.
4. Finally, it stores all this information in a dictionary, with the course name as the key and another dictionary containing the statistics as the value.

When we run this code, we get output like this:

{'Python Basics': {'average_score': 83.6, 'performance': 'Good'}, 
'SQL Fundamentals': {'average_score': 69.8, 'performance': 'Needs Improvement'}, 
'Data Visualization': {'average_score': 90.0, 'performance': 'Excellent'}}

This dictionary gave us a clear overview of how each course was performing. With it, we could quickly see which courses were doing well and which ones needed our attention. As mentioned earlier, we noticed that our SQL Fundamentals course needed some optimizations, which led us to revise the curriculum and add more interactive elements to boost student engagement.

By combining loops, conditionals, and dictionaries in this way, we were able to process a complex dataset and extract meaningful insights that directly impacted our course development strategy. This is the power of Python for data analysis―it allows you to take raw data and transform it into actionable information.

As you continue to develop your Python skills, you'll find more and more ways to combine these concepts to solve complex data problems. Here are some tips to keep in mind as you work on your own projects:

1. Start simple: Begin with a basic version of your analysis and gradually add complexity.
2. Break down your problem: Identify the different steps you need to take and tackle them one at a time.
3. Use meaningful variable names: This will make your code easier to read and debug.
4. Comment your code: Explain what each section does, especially for complex operations.
5. Test as you go: Run your code frequently to catch and fix errors early.

Remember, becoming proficient in data analysis with Python is a journey. Each project you work on will teach you something new and help you refine your skills. Don't be afraid to experiment and try new approaches―that's how you'll grow as a data analyst.

Advice from a Python Expert

As we wrap up this tutorial, I hope you've gained a deeper understanding of how Python's basic operators and data structures can transform your approach to data analysis. We've explored for loops, conditional statements, and dictionaries, seeing how each can be used to efficiently process and analyze data. More importantly, we've seen how combining these tools can lead to powerful, flexible data analysis workflows.

Throughout this post, we've used real-world examples and learning material from the Dataquest platform to illustrate these concepts. From analyzing course completion rates to categorizing mobile apps, these examples show how Python can be applied to solve actual data challenges. The skills you've learned here are the same ones I use daily in my work, and they form the foundation of more advanced data science techniques.

Remember, the key to becoming proficient in Python for data analysis is practice. Start by applying these concepts to your own datasets. Can you use a for loop to automate a repetitive task? Could conditional statements help you categorize your data more effectively? Might a dictionary provide a more intuitive way to store and access your information?

As you continue to develop your skills, you'll find that these fundamental concepts open doors to more advanced topics in data science. They're the building blocks that will allow you to tackle machine learning, data visualization, and complex statistical analyses.

If you're excited to dive deeper into Python for data analysis, I encourage you to check out the Basic Operators and Data Structures in Python course at Dataquest. This course expands on the concepts we've covered here, providing hands-on practice with real-world datasets and expert guidance to help you take your skills to the next level.

Remember, every data scientist, from beginners to experienced professionals, is on a continuous learning path. The Dataquest Community is particularly supportive, so don't hesitate to seek help when you need it. With each line of code you write and each dataset you analyze, you're building a skillset that can uncover valuable insights and drive important decisions. So keep exploring, stay curious, and enjoy the adventure that Python and data science offer. Who knows what new discoveries await you?

Frequently Asked Questions

app_data_set = [row_1, row_2, row_3, row_4, row_5]

rating_sum = 0
for row in app_data_set:
    rating = row[-1]
    rating_sum = rating_sum + rating

print(rating_sum)

ratings = [3.5, 4.0, 4.5, 3.5]

content_ratings = {'4+': 4433, '9+': 987, '12+': 1155, '17+': 622}

course_stats = {
    'Python Basics': {'average_score': 83.6, 'performance': 'Good'},
    'SQL Fundamentals': {'average_score': 69.8, 'performance': 'Needs Improvement'}
}

ratings = ['4+', '4+', '4+', '9+', '9+', '12+', '17+']

content_ratings = {}
for c_rating in ratings:
    if c_rating in content_ratings:
        content_ratings[c_rating] += 1
    else:
        content_ratings[c_rating] = 1

content_ratings = {'4+': 4433, '9+': 987, '12+': 1155, '17+': 622}

course_stats[course_name] = {
    'average_score': avg_score,
    'performance': performance
}

course_data = [
    ['Python Basics', [80, 85, 90, 75, 88]],
    ['SQL Fundamentals', [70, 65, 72, 68, 74]],
    ['Data Visualization', [85, 92, 88, 90, 95]]
]

for course in course_data:
    course_name = course[0]
    scores = course[1]

    for score in scores:
        # Process each score

ratings = ['4+', '4+', '4+', '9+', '9+', '12+', '17+']

content_ratings = {}
for c_rating in ratings:
    if c_rating in content_ratings:
        content_ratings[c_rating] += 1
    else:
        content_ratings[c_rating] = 1

total_apps = len(ratings)
for rating in content_ratings:
    content_ratings[rating] = content_ratings[rating] / total_apps

course_stats[course_name_1] = {
    'average_score': avg_score_course_1,
    'performance': performance_course_1
course_stats[course_name_2] = {
    'average_score': avg_score_course_2,
    'performance': performance_course_2
course_stats[course_name_3] = {
    'average_score': avg_score_course_3,
    'performance': performance_course_3
}

ratings = ['4+', '4+', '4+', '9+', '9+', '12+', '17+']

content_ratings = {}
for c_rating in ratings:
    if c_rating in content_ratings:
        content_ratings[c_rating] += 1
    else:
        content_ratings[c_rating] = 1