If the dataset has rows with null values, we should consider removing them. In `pandas`, this can be achieved using the `dropna()` method.

import unittest
import importlib


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 test_length_before_is_declared(self):
        import user_code
        _dynamic_test(
            self,
            hasattr(user_code, 'length_before'),
            "The `length_before` variable is declared.",
            "Expected `length_before` to be declared."
        )

    def test_length_before_is_int(self):
        import user_code

        try:
            condition = isinstance(user_code.length_before, int)
            failure_message = f"Expected `length_before` to be `int`, but got `{type(user_code.length_before).__name__}`."
        except AttributeError:
            condition = False
            failure_message = "The `length_before` variable is not declared."

        _dynamic_test(
            self,
            condition,
            "The variable `length_before` is `int`.",
            failure_message
        )

    def test_length_before_is_correct(self):
        import user_code

        expected_value = 456

        try:
            condition = user_code.length_before == expected_value
            failure_message = f"Expected `length_before` to be `{expected_value}`, but got `{user_code.length_before}`."
        except AttributeError:
            condition = False
            failure_message = "The `length_before` variable is not declared."

        _dynamic_test(
            self,
            condition,
            f"`length_before` contains the correct value.",
            failure_message
        )

    def test_length_after_is_declared(self):
        import user_code
        _dynamic_test(
            self,
            hasattr(user_code, 'length_after'),
            "The `length_after` variable is declared.",
            "Expected `length_after` to be declared."
        )

    def test_length_after_is_int(self):
        import user_code

        try:
            condition = isinstance(user_code.length_after, int)
            failure_message = f"Expected `length_after` to be `int`, but got `{type(user_code.length_after).__name__}`."
        except AttributeError:
            condition = False
            failure_message = "The `length_after` variable is not declared."

        _dynamic_test(
            self,
            condition,
            "The variable `length_after` is `int`.",
            failure_message
        )

    def test_length_after_is_correct(self):
        import user_code

        expected_value = 450

        try:
            condition = user_code.length_after == expected_value
            failure_message = f"Expected `length_after` to be `{expected_value}`, but got `{user_code.length_after}`."
        except AttributeError:
            condition = False
            failure_message = "The `length_after` variable is not declared."

        _dynamic_test(
            self,
            condition,
            f"`length_after` contains the correct value.",
            failure_message
        )

    def test_wine_data_is_declared(self):
        import user_code
        _dynamic_test(
            self,
            hasattr(user_code, 'wine_data'),
            "The `wine_data` variable is declared.",
            "Expected `wine_data` to be declared."
        )

    def test_length_before_greater_than_length_after(self):
        import user_code

        try:
            condition = user_code.length_before > user_code.length_after
            failure_message = f"Expected `length_before` to be greater than `length_after`, but got `length_before`: {user_code.length_before}, `length_after`: {user_code.length_after}."
        except AttributeError:
            condition = False
            if not getattr(user_code, 'length_before', None):
                failure_message = "The `length_before` variable is not declared."
            else:
                failure_message = "The `length_after` variable is not declared."
        _dynamic_test(
            self,
            condition,
            f"`length_before` is greater than `length_after`.",
            failure_message
        )

    def test_wine_data_has_no_nulls(self):
        import user_code

        try:
            condition = not user_code.wine_data.isnull().values.any()
            failure_message = "Expected `wine_data` to have no null values, but null values are still present."
        except AttributeError:
            condition = False
            if not getattr(user_code, 'wine_data', None):
                failure_message = "The `wine_data` variable is not declared."
            else:
                failure_message = f"`wine_data` is not a `DataFrame`."
        _dynamic_test(
            self,
            condition,
            "`wine_data` has no null values after cleaning.",
            failure_message
        )


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

test_main.py

Pandas is an extremely user-friendly library for data analysis. It's also designed to handle large datasets, using data structures like DataFrame and Series. This makes it an invaluable tool for Data Science. In this guide, you'll get acquainted with a range of statistical functions, including how to find correlations, modes, medians, and maximum and minimum values within a dataset. You'll also learn how to handle missing values and manipulate specific values, as well as how to remove them.

In this section, we'll explore the fundamentals of Series and DataFrame structures. You'll also learn about the distinctions between these two types of structures.

Data can be sourced in various formats, such as CSV, JSON, SQL, HTML, and more. With Pandas, you're not limited to a single format — you can work with data across a multitude of file types. In this chapter, we'll specifically focus on the CSV and TXT formats.

Here, you'll learn how to process raw data by removing extraneous information and managing null values in a dataset.

Challenge: Dropping Null Values

Solution

Challenge: Dropping Null Values

Solution