`pandas` erbjuder den praktiska metoden `mean()` som beräknar **medelvärdet** av alla värden för varje kolumn.
```python
df = pd.read_csv(file.csv)
mean_values = df.mean()
```

Du kan också använda samma metod för att bestämma medelvärdet för en specifik kolumn:
```python
df = pd.read_csv(file.csv)
mean_values = df['column_name'].mean()
```

`pandas` tillhandahåller också metoden `mode()`, som identifierar det **mest frekvent förekommande värdet** i varje kolumn.
```python
df = pd.read_csv(file.csv)
mode_values = df.mode()
```

För att hitta läget för en specifik kolumn används samma metod:
```python
df = pd.read_csv(file.csv)
mode_values = df['column_name'].mode()[0]
```

En annan användbar metod i `pandas` är `describe()`.
```python
df = pd.read_csv(file.csv)
important_metrics = df.describe()
```

Denna metod ger en **översikt över olika mått** från datasetet, inklusive:
- Totalt antal poster;
- Medelvärde eller genomsnittligt värde;
- Standardavvikelse;
- Minimi- och maximivärden;
- De 25:e, 50:e (median) och 75:e percentilerna.

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

    def test_residual_sugar_mean_is_correct(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_value = wine_data['residual sugar'].mean()

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

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

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

    def test_fixed_acidity_mode_is_correct(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_value = wine_data['fixed acidity'].mode()[0]

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

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

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

    def test_described_data_is_dataframe(self):
        import user_code

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

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

    def test_described_data_is_correct(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.describe()

        variable = 'described_data'
        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 statistical summary.",
            failure_message
        )


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

test_main.py

Pandas är ett extremt användarvänligt bibliotek för dataanalys. Det är också utformat för att hantera stora datamängder, med hjälp av datastrukturer som DataFrame och Series. Detta gör det till ett ovärderligt verktyg för Data Science. I denna guide kommer du att bekanta dig med en rad statistiska funktioner, inklusive hur man hittar korrelationer, lägen, medianer och maximala och minimala värden inom en dataset. Du kommer också att lära dig hur man hanterar saknade värden och manipulerar specifika värden, samt hur man tar bort dem.

I det här avsnittet kommer vi att utforska grunderna i Series och DataFrame-strukturer. Du kommer också att lära dig om skillnaderna mellan dessa två typer av strukturer.

Data kan hämtas i olika format, såsom CSV, JSON, SQL, HTML och fler. Med Pandas är du inte begränsad till ett enda format — du kan arbeta med data från en mängd olika filtyper. I detta kapitel kommer vi specifikt att fokusera på CSV- och TXT-formaten.

Här kommer du att lära dig hur man bearbetar rådata genom att ta bort överflödig information och hantera nullvärden i en dataset.

Beskriva Data

Lösning

Beskriva Data

Lösning