Summary  
Demonstrates how to retrieve and printing subsets of rows from a DataFrame using head(), tail(), and sample() methods.

General domain of usage  
Exploratory data analysis

To view the first few rows of a dataset, use the `head()` method. This method accepts an **integer** argument that specifies how many rows to display (by default, it shows the **first 5 rows**). Display the first 10 rows of the dataset:

```python
df = pd.read_csv('file.csv')
# Extracting the first 10 rows
first_lines = df.head(10)
```

To see the **last few rows** of a `DataFrame`, use the `tail()` method. It works the same way as the `head()` method:

```python
df = pd.read_csv('file.csv')
# Extracting the last 10 rows
last_lines = df.tail(10)
```

Another useful method for exploring DataFrames is `sample()`. This method fetches random records from a DataFrame. By default, it retrieves a **single random record** unless specified otherwise.
```python
df = pd.read_csv('file.csv')
# Extracting 10 random rows
random_lines = df.sample(10)
```

import unittest
import importlib
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)


def get_first_differing_row(expected_df, actual_df):
    expected_list = expected_df.astype(str).apply(tuple, axis=1)
    actual_list = actual_df.astype(str).apply(tuple, axis=1)

    for i, (row1, row2) in enumerate(zip(expected_list, actual_list)):
        if row1 != row2:
            return i, expected_df.iloc[i].values, actual_df.iloc[i].values

    if len(expected_df) > len(actual_df):
        return len(actual_df), expected_df.iloc[len(actual_df)].values, None
    else:
        return len(expected_df), None, actual_df.iloc[len(expected_df)].values


class TestUserCode(unittest.TestCase):

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

    def test_first_lines_is_dataframe(self):
        import user_code

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

        _dynamic_test(
            self,
            condition,
            "The variable `first_lines` is a `DataFrame`.",
            failure_message
        )

    def test_first_lines_has_correct_values(self):
        import user_code
        wine_data = pd.read_csv(
            'https://codefinity-content-media.s3.eu-west-1.amazonaws.com/a43d24b6-df61-4e11-9c90-5b36552b3437/wine.csv')
        expected_df = wine_data.head(10)

        variable = 'first_lines'
        actual_df = getattr(user_code, variable, None)
        condition = False
        if actual_df is None:
            failure_message = f"The `{variable}` variable is not declared."
        elif not isinstance(actual_df, pd.DataFrame):
            failure_message = f"`{variable}` is not a `DataFrame`."
        elif actual_df.empty:
            failure_message = f"`{variable}` is empty."
        elif actual_df.equals(expected_df):
            condition = True
            failure_message = None
        else:
            idx, expected_row, actual_row = get_first_differing_row(expected_df, actual_df)
            failure_message = f"Expected `{variable}` to contain `{expected_row}` at row {idx}, but got `{actual_row}`."

        _dynamic_test(
            self,
            condition,
            f"`{variable}` contains the correct data.",
            failure_message
        )

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

    def test_last_lines_is_dataframe(self):
        import user_code

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

        _dynamic_test(
            self,
            condition,
            "The variable `last_lines` is a `DataFrame`.",
            failure_message
        )

    def test_last_lines_has_correct_values(self):
        import user_code
        wine_data = pd.read_csv(
            'https://codefinity-content-media.s3.eu-west-1.amazonaws.com/a43d24b6-df61-4e11-9c90-5b36552b3437/wine.csv')
        expected_df = wine_data.tail(15)

        variable = 'last_lines'
        actual_df = getattr(user_code, variable, None)
        condition = False
        if actual_df is None:
            failure_message = f"The `{variable}` variable is not declared."
        elif not isinstance(actual_df, pd.DataFrame):
            failure_message = f"`{variable}` is not a `DataFrame`."
        elif actual_df.empty:
            failure_message = f"`{variable}` is empty."
        elif actual_df.equals(expected_df):
            condition = True
            failure_message = None
        else:
            idx, expected_row, actual_row = get_first_differing_row(expected_df, actual_df)
            failure_message = f"Expected `{variable}` to contain `{expected_row}` at row {idx}, but got `{actual_row}`."

        _dynamic_test(
            self,
            condition,
            f"`{variable}` contains the correct data.",
            failure_message
        )

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

    def test_random_rows_is_dataframe(self):
        import user_code

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

        _dynamic_test(
            self,
            condition,
            "The variable `random_rows` is a `DataFrame`.",
            failure_message
        )

    def test_random_rows_has_correct_values(self):
        import user_code
        import numpy as np
        np.random.seed(5)
        wine_data = pd.read_csv(
            'https://codefinity-content-media.s3.eu-west-1.amazonaws.com/a43d24b6-df61-4e11-9c90-5b36552b3437/wine.csv')
        expected_df = wine_data.sample(12)

        variable = 'random_rows'
        actual_df = getattr(user_code, variable, None)
        condition = False
        if actual_df is None:
            failure_message = f"The `{variable}` variable is not declared."
        elif not isinstance(actual_df, pd.DataFrame):
            failure_message = f"`{variable}` is not a `DataFrame`."
        elif actual_df.empty:
            failure_message = f"`{variable}` is empty."
        elif actual_df.equals(expected_df):
            condition = True
            failure_message = None
        else:
            idx, expected_row, actual_row = get_first_differing_row(expected_df, actual_df)
            failure_message = f"Expected `{variable}` to contain `{expected_row}` at row {idx}, but got `{actual_row}`."

        _dynamic_test(
            self,
            condition,
            f"`{variable}` contains the correct data.",
            failure_message
        )


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

test_main.py

Build practical data manipulation skills using pandas. Learn to work with Series and DataFrames, read and explore datasets, select and filter data, perform aggregations, reshape tables, combine multiple DataFrames, and prepare data for analysis.

Viewing the Data

Soluzione