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

Et **countplot** er et diagram som tar en kategorisk liste og returnerer søyler som representerer antall listeoppføringer for hver kategori.

# 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()

For å initialisere et countplot må du angi minst én parameter: `x` (kolonnen hvor verdiene skal telles).

Du kan også bruke `y` i stedet for `x` for å endre orienteringen på diagrammet.

Merk

Siden `seaborn` er basert på `matplotlib`, kan du bruke det spesielle biblioteket `matplotlib.pyplot` og funksjonen `plt.show()` for å vise diagrammet.

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

Utforsk kraften i statistisk datavisualisering utviklet for å avdekke mønstre og sammenhenger. Bruk Seaborn til å lage informative fordelingsdiagrammer, varmekart og kategoriske diagrammer med minimal kode. Lær å anvende estetiske temaer og fargepaletter som gjør kompleks statistisk data tilgjengelig og lett å tolke.

Telling av Kategoriske Data

Løsning