Summary  
This chapter covers generating count plots to visualize the frequency distribution of categorical data using seaborn’s `countplot` function, demonstrating how to pass category values directly as arrays or by specifying DataFrame column names.  

General domain of usage  
Exploratory data analysis

A **countplot** is a plot which creates columns (bars) that represent the number of  entries for each **category** of a categorical list. It can be also thought of as a histogram of a categorical variable.

Definition

Here each column represents the number of Titanic passengers of each class. You may have already noticed that this plot is very similar to the **bar chart**. Indeed, it is a rather specific kind of bar chart representing the **frequency** of each category.

You still have to import the `pyplot` module from `matplotlib` and use the `plt.show()` function to display the plots created with `seaborn`. 

Note

In order to create a countplot with `seaborn`, you should use the `countplot()` function. There are several possible options to pass our data to this function. 

## Passing a 1D Array

The first option is to simply pass the value for the `x` parameter which can be some kind of an **array**:

import seaborn as sns
import matplotlib.pyplot as plt

fruits = ['apple', 'banana', 'orange', 'apple', 'apple', 'apple', 'orange', 'banana', 'banana', 'banana', 'banana', 'banana', 'banana', 'banana']

sns.countplot(x=fruits)

plt.show()

The function counts each **unique** element in the list and creates a column with the corresponding height.

The `y` parameter can be used instead of `x` to change the orientation of the plot from vertical to horizontal.


## Passing a 2D Object

Another option is to use the `data` parameter combined with the `x` or `y` parameter. This approach is suitable for working with `pandas` `DataFrame`. You can pass a **list of arrays** or a `DataFrame` as the value for `data`. For `x` or `y` you can pass a name of the column in the `DataFrame`.


import seaborn as sns
import matplotlib.pyplot as plt

# Loading a built-in dataset of the Titanic passengers
titanic_df = sns.load_dataset('titanic')

sns.countplot(data=titanic_df, x='class')

plt.show()

In this example, the function creates a countplot using the `'class'` column of the Titanic `DataFrame`, showing how many entries exist for each unique value in that column.


import unittest
import ast
import inspect
import user_code  # This should contain the student's solution code

def _dynamic_test(test_case, condition, success_message, failure_message):
    if condition:
        test_case._testMethodName = success_message
        test_case.assertTrue(True, success_message)
    else:
        test_case._testMethodName = failure_message
        test_case.fail(failure_message)

class TestDiamondCountplot(unittest.TestCase):

    @classmethod
    def setUpClass(cls):
        source = inspect.getsource(user_code)
        cls.tree = ast.parse(source)

    def test_seaborn_imported_as_sns(self):
        imports = [
            node for node in self.tree.body
            if isinstance(node, ast.Import) or isinstance(node, ast.ImportFrom)
        ]
        imported = any(
            isinstance(imp, ast.Import) and
            any(alias.name == 'seaborn' and alias.asname == 'sns' for alias in imp.names)
            for imp in imports
        )
        _dynamic_test(
            self,
            imported,
            "Seaborn is imported as sns",
            "Seaborn is not imported as sns"
        )

    def test_pyplot_imported_as_plt(self):
        imports = [
            node for node in self.tree.body
            if isinstance(node, ast.Import) or isinstance(node, ast.ImportFrom)
        ]
        imported = any(
            isinstance(imp, ast.Import) and
            any(alias.name == 'matplotlib.pyplot' and alias.asname == 'plt' for alias in imp.names)
            for imp in imports
        )
        _dynamic_test(
            self,
            imported,
            "matplotlib.pyplot is imported as plt",
            "matplotlib.pyplot is not imported as plt"
        )

    def test_countplot_used_correctly(self):
        countplot_calls = [
            node for node in ast.walk(self.tree)
            if isinstance(node, ast.Call)
            and isinstance(node.func, ast.Attribute)
            and node.func.attr == 'countplot'
        ]
        correct_usage = False
        for call in countplot_calls:
            keywords = {kw.arg: kw.value for kw in call.keywords}
            if (
                'data' in keywords and isinstance(keywords['data'], ast.Name) and keywords['data'].id == 'diamonds'
                and 'y' in keywords and isinstance(keywords['y'], ast.Constant) and keywords['y'].value == 'cut'
            ):
                correct_usage = True
                break
        _dynamic_test(
            self,
            correct_usage,
            "sns.countplot() is used with data=diamonds and y='cut'",
            "sns.countplot() is not used correctly"
        )

    def test_plot_displayed(self):
        show_calls = [
            node for node in ast.walk(self.tree)
            if isinstance(node, ast.Call)
            and isinstance(node.func, ast.Attribute)
            and node.func.attr == 'show'
        ]
        correct = any(
            isinstance(call.func.value, ast.Name) and call.func.value.id == 'plt'
            for call in show_calls
        )
        _dynamic_test(
            self,
            correct,
            "plt.show() is called to display the plot",
            "plt.show() is not called"
        )

if __name__ == '__main__':
    unittest.main()


test_countplot.py

Learn how to explore and communicate data through visual analysis. The course covers creating common plots, customizing visualizations, and using statistical charts to examine data distributions, relationships, and patterns. Exploratory data analysis techniques are applied to identify trends, anomalies, and insights in real-world datasets.

Countplot

Passing a 1D Array

Passing a 2D Object

Lösung