Summary  
This chapter explains how to read and write CSV files using pandas’ read_csv and DataFrame.to_csv functions, covering key parameters like delimiters, headers, column selection, and index handling.  

General domain of usage  
Data analysis and manipulation

Omdat `pandas` de standaardbibliotheek is voor data-analyse en -manipulatie, is een van de belangrijkste functies het kunnen lezen en schrijven van verschillende bestandstypen, waaronder CSV-bestanden.

Een **CSV (Comma-Separated Values)**-bestand is een tekstbestand dat tabelgegevens opslaat, waarbij elke rij een record voorstelt en kolommen gescheiden zijn door komma's.

Een CSV-bestand kan de volgende gegevens bevatten:

- **Getallen**: gehele of decimale waarden (bijv. `42`, `3.14`);
- **Tekst**: strings of categorische gegevens (bijv. `John`, `Active`);
- **Datums/Tijden**: tijdsaanduidingen (bijv. `2023-12-30`);
- **Booleans**: logische waarden (`True`, `False`).

Elke rij moet hetzelfde aantal kolommen hebben en de eerste rij bevat vaak **kolomkoppen**.

Functies zoals `read_csv()` en `to_csv()` zijn handig bij het werken met CSV-gegevens.

De basis-syntaxis van `read_csv()` en de belangrijkste parameters zijn als volgt:

Hier is de bijgewerkte versie met de **`index_col`**-parameter toegevoegd en duidelijk uitgelegd:

---

```python
pandas.read_csv(filepath_or_buffer, sep=',', header=0, names=None, usecols=None, index_col=None, ...)
```

* **`filepath_or_buffer`**: pad naar het CSV-bestand (string of URL);
* **`sep`**: scheidingsteken (standaard een komma `,`);
* **`header`**: rijnummer dat als kolomkoppen wordt gebruikt (standaard de eerste rij);
* **`names`**: lijst met kolomnamen om te gebruiken;
* **`usecols`**: subset van kolommen om te lezen;
* **`index_col`**: kolom (of lijst van kolommen) die als index van de DataFrame wordt ingesteld.

# Loading the CSV into a `DataFrame`
import pandas as pd

salary_data = pd.read_csv('https://codefinity-content-media.s3.eu-west-1.amazonaws.com/a43d24b6-df61-4e11-9c90-5b36552b3437/Salary+Dataset.csv')
print(salary_data)

Zorg ervoor dat de datasetlink tussen aanhalingstekens staat.

Opmerking

De basis-syntaxis van `to_csv()` en de belangrijkste parameters zijn als volgt:

```python
pandas.DataFrame.to_csv(path_or_buf=None, sep=',', ..., columns=None, header=True, index=True, ...)
```

- **`path_or_buf`**: bestandspad of object waar het CSV-bestand naartoe geschreven moet worden;  
- **`sep`**: scheidingsteken voor het scheiden van waarden (standaard is een komma `,`);  
- `columns`: subset van kolommen om te schrijven (standaard zijn alle kolommen);
- **`header`**: of kolomnamen als kop moeten worden opgenomen (standaard is `True`);
- **`index`**: of rij-indexen naar het bestand moeten worden geschreven (standaard is `True`).

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)

countries.to_csv('countries.csv')
print('Done')

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

    def test_wine_data_is_dataframe(self):
        import user_code

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

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

    def test_wine_data_is_correct(self):
        import user_code
        file_url = 'https://codefinity-content-media.s3.eu-west-1.amazonaws.com/a43d24b6-df61-4e11-9c90-5b36552b3437/wine.csv'
        expected_df = pd.read_csv(file_url)

        variable = 'wine_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 data.",
            failure_message
        )


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

test_main.py

Pandas is een uiterst gebruiksvriendelijke bibliotheek voor data-analyse. Het is ook ontworpen om grote datasets te verwerken, met behulp van datastructuren zoals DataFrame en Series. Dit maakt het een onmisbaar hulpmiddel voor Data Science. In deze gids maak je kennis met diverse statistische functies, waaronder het vinden van correlaties, modi, medianen en maximale en minimale waarden binnen een dataset. Je leert ook hoe je omgaat met ontbrekende waarden en specifieke waarden kunt manipuleren en verwijderen.

Verdiep je in de basisprincipes van de pandas-bibliotheek. Het aanmaken en manipuleren van Series en DataFrames, het verkennen van hun structuur en het opbouwen van vertrouwen in het uitvoeren van essentiële data-operaties.

Beheers het laden en beheren van gegevens uit CSV- en TXT-bestanden. Verkrijg praktische ervaring met het importeren van datasets en het voorbereiden ervan voor verdere analyse met behulp van pandas-tools.

Leer hoe u gegevens effectief kunt verkennen, opschonen en samenvatten. Begrijp hoe u omgaat met ontbrekende waarden, inzichten verkrijgt en basisstatistische bewerkingen uitvoert met pandas.

CSV-Bestanden

Oplossing