The `SimpleImputer` class replaces missing values automatically.

```python
from sklearn.impute import SimpleImputer
imputer = SimpleImputer()
```

Its key parameters:

* `missing_value`: placeholder treated as missing (default `np.nan`);
* `strategy`: method for filling gaps (`'mean'` by default);
* `fill_value`: used when `strategy='constant'`.

As a transformer, it provides methods such as `.fit()`, `.transform()`, and `.fit_transform()`.

Choosing how to fill missing data is essential. A common approach:

* numerical features → **mean**;
* categorical features → **most frequent value**.

`strategy` options:

* `'mean'` — fill with mean;
* `'median'` — fill with median;
* `'most_frequent'` — fill with mode;
* `'constant'` — fill with a specified value via `fill_value`.

`missing_values` defines which values are treated as missing (default `NaN`, but may be `''` or another marker).

`SimpleImputer` expects a **DataFrame**, not a Series.
A single-column DataFrame must be selected using double brackets:

```python
imputer.fit_transform(df[['column']])
```

Note

`fit_transform()` returns a **2D array**, but assigning back to a DataFrame column requires a **1D** array.
Flatten the result using `.ravel()`:

```python
df['column'] = imputer.fit_transform(df[['column']]).ravel()
```

import unittest
import pandas as pd

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 TestSimpleImputerMostFrequent(unittest.TestCase):

    @classmethod
    def setUpClass(cls):
        # ÐÑÐ¸Ð³ÑÐ½Ð°Ð»ÑÐ½Ñ Ð´Ð°Ð½Ñ Ð±ÐµÐ· ÑÐ¼Ð¿ÑÑÐ°ÑÑÐ¹
        cls.df_raw = pd.read_csv(
            'https://codefinity-content-media.s3.eu-west-1.amazonaws.com/a65bbc96-309e-4df9-a790-a1eb8c815a1c/penguins.csv'
        )
        cls.df_raw = cls.df_raw[cls.df_raw.isna().sum(axis=1) < 2]

        import user_code
        cls.user_code = user_code

    def test_uses_simpleimputer_most_frequent(self):
        from sklearn.impute import SimpleImputer
        uc = self.user_code
        cond = isinstance(getattr(uc, 'imputer', None), SimpleImputer) and getattr(uc.imputer, 'strategy', None) == 'most_frequent'
        _dynamic_test(
            self,
            cond,
            "Used SimpleImputer with strategy='most_frequent'",
            "You must use sklearn.impute.SimpleImputer with strategy='most_frequent'"
        )

    def test_no_nans_in_sex(self):
        uc = self.user_code
        cond = 'sex' in uc.df.columns and not uc.df['sex'].isna().any()
        _dynamic_test(
            self,
            cond,
            "Column 'sex' contains no NaN after imputation",
            "Column 'sex' still contains NaN values after imputation"
        )

    def test_nans_reduced_vs_raw(self):
        raw_nans = self.df_raw['sex'].isna().sum()
        uc = self.user_code
        after_nans = uc.df['sex'].isna().sum() if 'sex' in uc.df.columns else raw_nans
        cond = raw_nans > 0 and after_nans < raw_nans
        _dynamic_test(
            self,
            cond,
            "Number of NaN in 'sex' decreased compared to raw data",
            "The number of NaN in 'sex' did not decrease compared to raw data"
        )

    def test_imputer_fitted_on_sex_mode(self):
        uc = self.user_code
        has_stats = hasattr(getattr(uc, 'imputer', object()), 'statistics_')
        try:
            mode_val = uc.df['sex'].mode(dropna=True).iloc[0]
        except Exception:
            mode_val = None
        stats_match = False
        if has_stats and getattr(uc.imputer, 'statistics_', None) is not None and len(uc.imputer.statistics_) > 0:
            stats_match = uc.imputer.statistics_[0] == mode_val
        cond = has_stats and stats_match
        _dynamic_test(
            self,
            cond,
            "Imputer appears fitted on 'sex' (statistics_ matches column mode)",
            "Imputer does not seem fitted correctly on 'sex' (statistics_ mismatch)"
        )

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


test_code.py

Machine learning drives modern technological innovation across all industries. Embark on a comprehensive introduction to predictive modeling by mastering foundational algorithmic concepts utilizing Scikit-Learn. Participants will construct robust classifiers, evaluate performance metrics, ultimately culminating in the development of a complete predictive project.

Challenge: Imputing Missing Values

Oplossing