Summary  
This chapter covers generating a countplot to visualize the frequency of categorical data by tallying each category’s occurrences using a plotting library.

General domain of usage  
Data visualization

A **countplot** is a plot that takes a categorical list and returns columns that represent the number of list entries for each category.

# Importing the `seaborn` library
import seaborn as sns
# Importing `matplotlib.pyplot`
import matplotlib.pyplot as plt

# Data list
data_list = ['apple', 'milk', 'milk', 'milk', 'apple', 'milk', 'milk', 'milk', 'fish']

# Creating the countplot
sns.countplot(x=data_list, palette='mako')

# Showing the plot
plt.show()

To initialize a countplot, you need to input at least 1 parameter: `x` (the column in which values will be counted).

You may also use `y` instead of `x` to change the orientation of the plot.

Note

As `seaborn` is based on `matplotlib`, you may use a special `matplotlib.pyplot` library and its function `plt.show()` to show the plot.

import unittest
import importlib
import sys
from unittest.mock import patch

# Helper function to dynamically generate test names and assertions
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 TestUserCode(unittest.TestCase):

    # Test if seaborn is imported with alias sns
    def test_seaborn_import(self):
        import user_code
        _dynamic_test(
            self,
            hasattr(user_code, 'sns'),
            "The `seaborn` library is imported as `sns`.",
            "Expected `seaborn` to be imported as `sns`."
        )

    # Test if matplotlib.pyplot is imported with alias plt
    def test_matplotlib_import(self):
        import user_code
        _dynamic_test(
            self,
            hasattr(user_code, 'plt'),
            "The `matplotlib.pyplot` library is imported as `plt`.",
            "Expected `matplotlib.pyplot` to be imported as `plt`."
        )

    # Test if guests_list contains the correct data
    def test_guests_list_correct(self):
        import user_code
        expected_list = ['Girl', 'Boy', 'Boy', 'Boy', 'Girl', 'Boy', 'Boy', 'Boy', 'Girl', 'Boy', 'Girl', 'Girl', 'Girl', 'Girl', 'Girl', 'Girl']
        
        # Check if variable exists first
        if not hasattr(user_code, 'guests_list'):
             _dynamic_test(self, False, "", "The `guests_list` variable is not declared.")
             return

        _dynamic_test(
            self,
            user_code.guests_list == expected_list,
            "The `guests_list` contains the correct data.",
            f"Expected `guests_list` to be `{expected_list}`, but got `{user_code.guests_list}`."
        )

    # Test if countplot function is used
    def test_countplot_used(self):
        # We patch seaborn.countplot to intercept the call
        with patch('seaborn.countplot') as mock_countplot:
            # We also patch plt.show to prevent the plot window from actually popping up during tests
            with patch('matplotlib.pyplot.show'):
                # Reload user_code to force the script to run again with our mocks active
                if 'user_code' in sys.modules:
                    importlib.reload(sys.modules['user_code'])
                else:
                    import user_code
        
        _dynamic_test(
            self,
            mock_countplot.called,
            "The `sns.countplot()` function is used.",
            "Expected `sns.countplot()` function to be used to create the plot."
        )

    # Test if the correct argument is passed to countplot
    def test_countplot_argument(self):
        with patch('seaborn.countplot') as mock_countplot:
            with patch('matplotlib.pyplot.show'):
                if 'user_code' in sys.modules:
                    importlib.reload(sys.modules['user_code'])
                else:
                    import user_code
            
            # Check arguments passed to countplot
            # kwargs retrieves named arguments like x=...
            passed_x = None
            if mock_countplot.called:
                args, kwargs = mock_countplot.call_args
                passed_x = kwargs.get('x')

            import user_code
            # We compare the actual list object passed to the function
            condition = passed_x == user_code.guests_list

            _dynamic_test(
                self,
                condition,
                "The `sns.countplot()` uses `guests_list` for the `x` parameter.",
                "Expected `sns.countplot()` to be called with `x=guests_list`."
            )

    # Test if plt.show() is used
    def test_show_used(self):
        with patch('seaborn.countplot'):
            with patch('matplotlib.pyplot.show') as mock_show:
                if 'user_code' in sys.modules:
                    importlib.reload(sys.modules['user_code'])
                else:
                    import user_code

                _dynamic_test(
                    self,
                    mock_show.called,
                    "The `plt.show()` function is used.",
                    "Expected `plt.show()` to be used to display the plot."
                )

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

test_code.py

Explore the power of statistical data visualization designed to reveal patterns and relationships. Use Seaborn to create informative distribution plots, heatmaps, and categorical charts with minimal code. Learn to apply aesthetic themes and color palettes that make complex statistical data accessible and easy to interpret.

Counting Categorical Data

解答