Summary  
Demonstrates how to generate empirical cumulative distribution function (ECDF) plots in Python using Seaborn, including options to switch the y-axis between proportions and counts and to display the complementary (survival) curve.  

General domain of usage  
Exploratory data analysis

An `ecdfplot` represents the proportion or count of observations falling below each unique value in a dataset.

Compared to a histogram or density plot, it has a significant advantage: **each observation is visualized directly**. This means there are no bins to adjust and no smoothing parameters that might distort the data. It is often considered the most "honest" way to visualize a distribution.

## Key Parameters

By default, the plot shows the proportion (0 to 1) of data smaller than X. You can change this behavior:

* **`stat='count'`:** instead of a percentage, the Y-axis shows the **number** of observations;
* **`complementary=True`:** reverses the logic. Instead of showing values **below** the threshold, it shows values **above** it. This is essentially a "survival curve" (e.g., "How many penguins have a beak **longer** than 50mm?").

### Example

Here is how `complementary` changes the visualization. The curve goes down instead of up.

import seaborn as sns
import matplotlib.pyplot as plt

# Load dataset
df = sns.load_dataset('penguins')

# Create a Complementary ECDF
# This answers: "How many penguins have a flipper length GREATER than X?"
sns.ecdfplot(
    data=df,
    x='flipper_length_mm',
    hue='species',
    stat='count',       # Show exact number of penguins
    complementary=True  # Curve descends from Total to 0
)

plt.show()

import unittest
import importlib
import sys
import pandas as pd
from unittest.mock import patch, MagicMock

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

    def setUp(self):
        self.patcher_csv = patch('pandas.read_csv')
        self.mock_read_csv = self.patcher_csv.start()
        
        # Provide real data structure to satisfy Seaborn's internal checks
        self.mock_df = pd.DataFrame({
            'bill_length_mm': [39.1, 39.5, 40.3, 36.7, 39.3],
            'island': ['Torgersen', 'Biscoe', 'Dream', 'Torgersen', 'Biscoe']
        })
        self.mock_read_csv.return_value = self.mock_df

    def tearDown(self):
        self.patcher_csv.stop()

    # Test if ecdfplot is used
    def test_ecdfplot_called(self):
        with patch('seaborn.ecdfplot') as mock_ecdf:
            with patch('matplotlib.pyplot.show'):
                if 'user_code' in sys.modules:
                    importlib.reload(sys.modules['user_code'])
                else:
                    import user_code
            
            _dynamic_test(
                self,
                mock_ecdf.called,
                "The `sns.ecdfplot()` function is used.",
                "Expected `sns.ecdfplot()` to be used."
            )

    # Test basic data parameters
    def test_basic_params(self):
        with patch('seaborn.ecdfplot') as mock_ecdf:
            with patch('matplotlib.pyplot.show'):
                if 'user_code' in sys.modules:
                    importlib.reload(sys.modules['user_code'])
                else:
                    import user_code
            
            if not mock_ecdf.called:
                _dynamic_test(self, False, "", "Expected `sns.ecdfplot()` to be used.")
                return

            args, kwargs = mock_ecdf.call_args
            
            # Use user_code.df to ensure we compare against the object in their scope
            # (though mocking makes them effectively the same)
            data_check = kwargs.get('data') is user_code.df
            x_check = kwargs.get('x') == 'bill_length_mm'
            hue_check = kwargs.get('hue') == 'island'

            _dynamic_test(
                self,
                data_check and x_check and hue_check,
                "The `x`, `hue`, and `data` parameters are set correctly.",
                "Expected `x='bill_length_mm'`, `hue='island'`, and `data=df`."
            )

    # Test logic parameters (complementary, stat, palette)
    def test_logic_params(self):
        with patch('seaborn.ecdfplot') as mock_ecdf:
            with patch('matplotlib.pyplot.show'):
                if 'user_code' in sys.modules:
                    importlib.reload(sys.modules['user_code'])
                else:
                    import user_code
            
            if not mock_ecdf.called:
                return

            args, kwargs = mock_ecdf.call_args
            
            complementary_check = kwargs.get('complementary') is True
            stat_check = kwargs.get('stat') == 'count'
            palette_check = kwargs.get('palette') == 'mako'

            _dynamic_test(
                self,
                complementary_check and stat_check and palette_check,
                "The plot uses `complementary=True`, `stat='count'`, and `palette='mako'`.",
                f"Expected `complementary=True`, `stat='count'`, `palette='mako'`. Got: {kwargs}"
            )

    # Test show
    def test_show_used(self):
        with patch('seaborn.ecdfplot'):
            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.

Plotting Cumulative Distributions

Key Parameters

Example

解答