Summary  
This chapter explains how to access single or multiple columns in a DataFrame using bracket notation (single brackets for one column, double brackets for multiple) or dot notation when column names are valid identifiers.

General domain of usage  
Data analysis

Når du arbeider med en DataFrame, kan du få tilgang til hver kolonne individuelt.
```python
df['column_name']
```

For å tydeliggjøre denne syntaksen:
- Start med å skrive navnet på DataFrame-en du arbeider med;
- Deretter plasserer du kolonnenavnet du vil ha tilgang til i **firkantede parenteser**. Husk å omslutte kolonnenavnet med anførselstegn.

Alternativt kan du bruke **punktnotasjon** for å få tilgang til en kolonne hvis kolonnenavnet:

1. Er en gyldig Python-identifikator (f.eks. ingen mellomrom, spesialtegn eller starter med et tall);
2. Ikke er i konflikt med et eksisterende `pandas`-attributt eller metodenavn.

```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)

Å kjøre denne koden vil vise kun kolonnen som inneholder hovedsteder, i stedet for hele DataFrame.

Du kan også få tilgang til **flere** kolonner slik:
```python
df[['column1', 'column2', 'column3']]
```

Sammenlignet med å hente ut én kolonne, er det bare én forskjell. Denne gangen må du plassere **listen med kolonnenavn** innenfor et ekstra sett med hakeparenteser — altså bruke **dobbelt sett med hakeparenteser**.

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

Pandas er et svært brukervennlig bibliotek for dataanalyse. Det er også utviklet for å håndtere store datasett, ved å bruke datastrukturer som DataFrame og Series. Dette gjør det til et uvurderlig verktøy innen Data Science. I denne veiledningen blir du kjent med ulike statistiske funksjoner, inkludert hvordan du finner korrelasjoner, typetall, medianer samt maksimums- og minimumsverdier i et datasett. Du lærer også hvordan du håndterer manglende verdier og manipulerer spesifikke verdier, samt hvordan du fjerner dem.

Fordypning i grunnleggende konsepter i pandas-biblioteket. Opprettelse og manipulering av Series og DataFrames, utforskning av deres struktur, samt utvikling av trygghet i å utføre essensielle dataoperasjoner.

Lær å laste inn og håndtere data fra CSV- og TXT-filer. Få praktisk erfaring med å importere datasett og klargjøre dem for videre analyse ved hjelp av pandas-verktøy.

Lær å utforske, rense og oppsummere data på en effektiv måte. Forstå hvordan man håndterer manglende verdier, trekker ut innsikt og utfører grunnleggende statistiske operasjoner med pandas.

Arbeide med kolonner

Løsning