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 is now used everywhere. Want to learn it yourself? This course is an introduction to the world of Machine learning for you to learn basic concepts, work with Scikit-learn – the most popular library for ML and build your first Machine Learning project.
This course is intended for students with a basic knowledge of Python, Pandas, and Numpy.

Learn the Machine Learning concepts and the ML project workflow.

Preprocessing is probably the most important stage of an ML project. This chapter covers the preprocessing steps needed for almost any dataset.

A pipeline is a neat way to combine all the preprocessing steps as well as a model. Pipelines make it much easier to train and use a model.

Modeling is the most fun stage of an ML project. Let's learn to build, fine-tune and evaluate the model!

Challenge: Imputing Missing Values

Solution

Challenge: Imputing Missing Values

Solution