Summary  
This chapter covers removing rows or columns from a DataFrame using the drop() method with the axis parameter.

General domain of usage  
Data cleaning

Manche Spalten liefern möglicherweise keine wertvollen Informationen, sodass es sinnvoll ist, sie zu entfernen. Die Bibliothek `pandas` stellt dafür die Methode `drop()` zur Verfügung.

```python
drop(index, columns, axis)
```

- `index`: gibt die zu löschenden Zeilenindizes an (wird verwendet, wenn `axis=0`);
- `columns`: benennt die zu löschenden Spaltennamen (wird verwendet, wenn `axis=1`);
- `axis`: Auswahl, ob Bezeichnungen aus den **Zeilen** (`0`) oder **Spalten** (`1`) entfernt werden. Standardwert ist `0`.

Zunächst eine Betrachtung des `DataFrame`:


import pandas as pd 

countries_data = {'country' : ['Thailand', 'Philippines', 'Monaco', 'Malta', 'Sweden', 'Paraguay', 'Latvia'],
          'continent' : [None, None, 'Europe', None, 'Europe', None, 'Europe'],
          'capital':['Bangkok', 'Manila', 'Monaco', 'Valletta', 'Stockholm', 'Asuncion', 'Riga']}
countries = pd.DataFrame(countries_data)
print(countries)

Es ist erkennbar, dass die Spalte `'continent'` viele fehlende Werte enthält und daher wenig aussagekräftig ist. Diese Spalte wird entfernt.


import pandas

countries_data = {'country' : ['Thailand', 'Philippines', 'Monaco', 'Malta', 'Sweden', 'Paraguay', 'Latvia'],
          'continent' : [None, None, 'Europe', None, 'Europe', None, 'Europe'],
          'capital':['Bangkok', 'Manila', 'Monaco', 'Valletta', 'Stockholm', 'Asuncion', 'Riga']}
countries = pandas.DataFrame(countries_data)
countries = countries.drop(columns = ['continent'],axis=1)
print(countries)

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

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

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

    def test_capital_column_removed(self):
        import user_code
        try:
            condition = 'capital' not in user_code.audi_cars.columns
            failure_message = "Expected `'capital'` column to be removed from `audi_cars`, but it still exists."

        except AttributeError:
            condition = False
            if not getattr(user_code, 'audi_cars', None):
                failure_message = "The `audi_cars` variable is not declared."
            else:
                failure_message = "`audi_cars` is not a `DataFrame`."

        _dynamic_test(
            self,
            condition,
            "The `'capital'` column is removed from `audi_cars`.",
            failure_message
        )

    def test_audi_cars_columns_correct(self):
        import user_code
        expected_columns = ['fueltype', 'model', 'year']
        try:
            actual_columns = sorted(list(user_code.audi_cars.columns))
            condition = actual_columns == expected_columns
            failure_message = f"Expected `audi_cars` to have columns `{expected_columns}`, but got `{actual_columns}`."

        except AttributeError:
            condition = False
            if not getattr(user_code, 'audi_cars', None):
                failure_message = "The `audi_cars` variable is not declared."
            else:
                failure_message = "`audi_cars` is not a `DataFrame`."

        _dynamic_test(
            self,
            condition,
            f"`audi_cars` has the correct columns.",
            failure_message
        )

    def test_audi_cars_is_correct(self):
        import user_code

        cars_data = {
            'model': ['Audi A1', 'Audi A6', 'Audi A4', 'Audi A3', 'Audi A1'],
            'year': [2017, 2016, 2017, 2019, 2016],
            'fueltype': ['petrol', 'diesel', 'diesel', 'petrol', 'petrol']}

        expected_df = pd.DataFrame(cars_data)

        variable = 'audi_cars'
        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

Pandas ist eine äußerst benutzerfreundliche Bibliothek für die Datenanalyse. Sie ist zudem darauf ausgelegt, große Datensätze mithilfe von Datenstrukturen wie DataFrame und Series zu verarbeiten. Dadurch ist sie ein unverzichtbares Werkzeug für Data Science. In diesem Leitfaden lernen Sie eine Vielzahl statistischer Funktionen kennen, darunter das Ermitteln von Korrelationen, Modalwerten, Mediane sowie Maximal- und Minimalwerten innerhalb eines Datensatzes. Sie erfahren außerdem, wie Sie fehlende Werte behandeln und bestimmte Werte manipulieren sowie entfernen können.

Tauchen Sie in die Grundlagen der pandas-Bibliothek ein. Erstellen und bearbeiten Sie Series und DataFrames, untersuchen Sie deren Struktur und gewinnen Sie Sicherheit bei der Durchführung grundlegender Datenoperationen.

Erlernen des Ladens und Verwaltens von Daten aus CSV- und TXT-Dateien. Praktische Erfahrung im Importieren von Datensätzen und deren Vorbereitung für die weitere Analyse mit Pandas-Werkzeugen.

Erlernen Sie das effektive Erkunden, Bereinigen und Zusammenfassen von Daten. Verständnis für den Umgang mit fehlenden Werten, das Extrahieren von Erkenntnissen und das Durchführen grundlegender statistischer Operationen mit pandas.

Löschen Einer Zeile/Spalte

Lösung