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

En ocasiones, ciertas columnas pueden no aportar información valiosa, por lo que resulta conveniente eliminarlas. La biblioteca `pandas` ofrece el método `drop()` para este propósito.

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

- `index`: especifica los índices de las filas que se eliminarán (se utiliza cuando `axis=0`);
- `columns`: identifica los nombres de las columnas que se eliminarán (se utiliza cuando `axis=1`);
- `axis`: permite elegir si se eliminan etiquetas de las **filas** (`0`) o de las **columnas** (`1`). El valor predeterminado es `0`.

Comenzar examinando el `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)

Se puede observar que la columna `'continent'` contiene muchos valores faltantes, por lo que resulta menos informativa. Eliminar esta columna.


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 es una biblioteca sumamente intuitiva para el análisis de datos. También está diseñada para manejar grandes conjuntos de datos, utilizando estructuras como DataFrame y Series. Esto la convierte en una herramienta invaluable para la Ciencia de Datos. En esta guía, se presentarán diversas funciones estadísticas, incluyendo cómo encontrar correlaciones, modas, medianas y valores máximos y mínimos dentro de un conjunto de datos. También se abordará el manejo de valores faltantes y la manipulación de valores específicos, así como su eliminación.

Sumérgete en los fundamentos de la biblioteca pandas. Creación y manipulación de Series y DataFrames. Exploración de su estructura. Desarrollo de confianza en la realización de operaciones esenciales de datos.

Domina cómo cargar y gestionar datos desde archivos CSV y TXT. Adquiere experiencia práctica importando conjuntos de datos y preparándolos para análisis posteriores utilizando herramientas de pandas.

Aprenda a explorar, limpiar y resumir datos de manera efectiva. Comprenda cómo manejar valores faltantes, extraer información y realizar operaciones estadísticas básicas con pandas.

Eliminando una Fila/Columna

Solución