Summary  
This chapter explains how to access single and multiple columns in a pandas DataFrame using bracket notation (with single brackets for one column and double brackets for multiple columns) and dot notation for valid identifiers.

General domain of usage  
Data analysis

When working with a DataFrame, you can access each column individually.
```python
df['column_name']
```

To clarify this syntax:
- Start by writing the name of the DataFrame you're working with;
- Next, place the column name you want to access inside **square brackets**. Remember to enclose the column name in quotation marks.

Alternatively, you can use **dot notation** to access a column if the column name:

1. Is a valid Python identifier (e.g., no spaces, special characters, or starting with a number);
2. Does not conflict with an existing `pandas` attribute or method name.

```python
df.column_name
```

import pandas as pd

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

capitals = countries['capital']

# Second option
# capitals = countries.capital

print(capitals)

Executing this code will display just the column containing capital cities, rather than the entire DataFrame.

You can also access **multiple** columns like this:
```python
df[['column1', 'column2', 'column3']]
```

Compared to accessing a single column, there is only one difference. This time, you'll need to put the **list of column names** inside an additional set of square brackets — meaning you'll use **double square brackets**.

import pandas as pd

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

import unittest
import importlib
import pandas as pd


# Helper function for dynamic test naming
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_columns_variable_is_declared(self):
        import user_code
        _dynamic_test(
            self,
            hasattr(user_code, 'columns'),
            "The `columns` variable is declared.",
            "Expected `columns` to be declared."
        )

    def test_text_columns_is_dataframe(self):
        import user_code

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

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

    def test_columns_contains_correct_values(self):
        import user_code

        expected_df = pd.DataFrame({
            'model': ['audi A1', 'audi A6', 'audi A4', 'audi A3', 'audi A1'],
            'price': [12500, 16500, 16800, 17300, 13900],
            'year': [2017, 2016, 2017, 2019, 2016]
        })

        variable = 'columns'
        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.sort_index(axis=1).equals(expected_df):
            condition = True
            failure_message = None
        else:
            actual_df = actual_df.sort_index(axis=1)
            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
        )

        _dynamic_test(
            self,
            condition,
            "`columns` contains the correct values.",
            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.

Working with Columns

Oplossing