Ga naar hoofdinhoud

Hoe sla je een Pandas DataFrame op als CSV

In Pandas kun je een DataFrame opslaan als een CSV-bestand met de methode df.to_csv('your_file_name.csv', index=False), waarbij df je DataFrame is en index=False voorkomt dat er een indexkolom wordt toegevoegd.
· 7 min lezen

Verken met AI

Als je een DataFrame maakt of een bestaande aanpast, wil je die misschien exporteren zodat anderen ermee kunnen werken, of wil je ’m bewaren voor later. Misschien moet je bijvoorbeeld een voorspelling uit een machinelearningproject inleveren bij je docent of een aangepast dataset naar een collega sturen.

In Python kun je een DataFrame exporteren als CSV-bestand met de .to_csv() methode van Pandas.

In dit artikel neem ik je mee door de belangrijkste stappen en leg ik de parameters van de methode uit.

Wil je meer leren over Pandas, bekijk dan deze cursus over Data Manipulation with Pandas.

Ik begin met een kort antwoord voor als je snel verder wilt, daarna ga ik de diepte in.

Kort antwoord: zo sla je een Pandas DataFrame op als CSV

Om een Pandas DataFrame als CSV op te slaan, gebruik je de methode DataFrame.to_csv(): 

df.to_csv('your_file_name.csv', index=False)

Vervang 'your_file_name.csv' door de gewenste bestandsnaam en -pad. Het argument index=False voorkomt dat Pandas een indexkolom toevoegt aan je CSV.

Een Pandas DataFrame maken

Laten we nu naar het lange antwoord kijken. In plaats van een DataFrame from scratch te maken, importeer ik een dataset, pas ik die aan en sla ik het resulterende DataFrame op in CSV-formaat. De eerste stap is het importeren van de benodigde libraries:

import pandas as pd
import seaborn as sns
from sklearn.preprocessing import MinMaxScaler

Daarna kunnen we een seaborn-dataset importeren. De geïmporteerde dataset is al een Pandas DataFrame, dus we hoeven ’m niet te transformeren.

# We’ll import the 'titanic' dataset from seaborn
df = sns.load_dataset('titanic')
print(df.head())
survived  pclass     sex   age  sibsp  parch     fare embarked  class  
0         0       3    male  22.0      1      0   7.2500        S  Third   
1         1       1  female  38.0      1      0  71.2833        C  First   
2         1       3  female  26.0      0      0   7.9250        S  Third   
3         1       1  female  35.0      1      0  53.1000        S  First   
4         0       3    male  35.0      0      0   8.0500        S  Third 
    who  adult_male deck  embark_town alive  alone  
0    man        True  NaN  Southampton    no  False  
1  woman       False    C    Cherbourg   yes  False  
2  woman       False  NaN  Southampton   yes   True  
3  woman       False    C  Southampton   yes  False  
4    man        True  NaN  Southampton    no   True

Een Pandas DataFrame aanpassen

Laten we nu wat bewerkingen doen om een nieuw DataFrame te krijgen. Omdat ik de .to_csv()-methode van Pandas wil laten zien, doe ik alleen een min-max-normalisatie op numerieke variabelen.

scaler = MinMaxScaler()
# Choose the columns that have integer or float data-types                                           
numerical columns - df.select_dtypes(include=['float64','int64']).columns
new_df = df.copy()
# The min-max scaler will represent all numbers on a 0-to-1 scale
new_df[numerical_columns] = scaler.fit_transform(df[numerical_columns])
print(new_df.head())
survived  pclass     sex       age  sibsp  parch      fare embarked    
0       0.0     1.0    male  0.271174  0.125    0.0  0.014151        S  
1       1.0     0.0  female  0.472229  0.125    0.0  0.139136        C  
2       1.0     1.0  female  0.321438  0.000    0.0  0.015469        S  
3       1.0     0.0  female  0.434531  0.125    0.0  0.103644        S  
4       0.0     1.0    male  0.434531  0.000    0.0  0.015713        S  
class   who  adult_male deck  embark_town alive  alone  
Third   man        True  NaN  Southampton    no  False  
First   woman      False   C    Cherbourg   yes  False  
Third   woman      False NaN  Southampton   yes   True  
First   woman      False   C  Southampton   yes  False  
Third   man        True  NaN  Southampton    no   True

Een Pandas DataFrame opslaan als CSV

We gebruiken de DataFrame.to_csv()-methode om het aangepaste DataFrame als CSV-bestand op te slaan.

new_df.to_csv('new_titanic.csv')

Dit slaat het CSV-bestand op in de huidige map. Heb je een opfrisser nodig, lees dan deze tutorial over hoe je de huidige map in Python ophaalt.

De manier waarop ik deze methode heb aangeroepen, zorgt ervoor dat alle parameters hun standaardwaarden hebben. Nu presenteer ik de parameters en hoe je de waarden naar wens kunt aanpassen.

Uitleg van de parameters van DataFrame.to_csv()

Hier is dezelfde .to_csv()-methode met alle parameters opgesomd:

new_df.to_csv(
    path_or_buf='new_titanic.csv',
    sep=',',
    na_rep='',
    float_format=None,
    columns=[],
    header=True,
    index=True,
    index_label=None,
    mode='w',
    encoding='utf-8',
    quoting=csv.QUOTE_MINIMAL,
    lineterminator=os.linesep,
    storage_options={},
    compression='infer',
    quotechar='',
    chunksize=None,
    date_format=None,
    doublequote=True,
    escapechar=None,
    decimal='.',
    errors='strict'
)

Sommige van deze parameters zijn optioneel, zoals columns, encoding, quoting, lineterminator en storage_options, dus ik heb daar gewoon waarden voor ingevuld, niet per se de standaardwaarden.

De eerste parameter kan een string zijn, wat dan de bestandsnaam is, of een file object. Bekijk dit voorbeeld:

with open('new_titanic.csv',  'w', encoding = 'utf=8') as file:
     new_df.to_csv(file)

Scheidingstekens en missende waarden

De volgende parameter is het scheidingsteken, oftewel hoe de data gescheiden worden. Standaard is dit de komma, maar we kunnen het veranderen naar een tab of puntkomma. Een tab of puntkomma kan handig zijn wanneer je geëxporteerde data in een bepaald formaat moeten staan. Ook bij data met komma’s, zoals teksten, kan een komma als scheidingsteken ongewenste veranderingen geven.

Als je bijvoorbeeld ‘Hello, world’ als datapunt hebt, dan heb je bij een komma-sscheidingsteken ook aanhalingstekens nodig om het als één datapunt te behouden. Een tab of puntkomma gebruiken kan dan een betere optie zijn, omdat dat mogelijk minder geheugen kost dan komma’s met aanhalingstekens.

new_df.to_csv('new_titanic.csv', sep = '\t')
new_df_tab = pd.read_csv('new_titanic.csv')
0\t0\t3\tmale\t22.0\t1\t0\t7.25\tS\tThird\tman...                                                                 
1\t1\t1\tfemale\t38.0\t1\t0\t71.2833\tC\tFirst...                                                                 
2\t1\t3\tfemale\t26.0\t0\t0\t7.925\tS\tThird\t...                                                                 
3\t1\t1\tfemale\t35.0\t1\t0\t53.1\tS\tFirst\tw...                                                                 
4\t0\t3\tmale\t35.0\t0\t0\t8.05\tS\tThird\tman...

De derde parameter, na_rep, gaat over de weergave van missende waarden. Veelgebruikte opties zijn de cel leeg laten of ‘NaN’ of ‘Na’ invullen, maar je kunt ook je eigen string opgeven. In het volgende voorbeeld vul ik ‘Datacamp’ in voor elke missende waarde.

new_df.to_csv('new_titanic.csv', na_rep='Datacamp')
new_df_datacamp = pd.read_csv('new_titanic.csv') 
new_df_datacamp = pd.DataFrame(new_df_datacamp) 
#find the missing values
missing_values = new_df_datacamp.isnull().sum()
print(missing_values)
survived         0
pclass           0
sex              0
age            177
sibsp            0
parch            0
fare             0
embarked         2
class            0
who              0
adult_male       0
deck           688
embark_town      2
alive            0
alone            0

Kolommen en indexen beheren

Laten we kijken hoe de missende waarden worden weergegeven voor de kolom age:

print(new_df_datacamp['age'][:10])
     0.2711736617240512
     0.4722292033174164
    0.32143754712239253
     0.4345312892686604
     0.4345312892686604
               Datacamp
     0.6732847449107816
    0.01985423473234481
    0.33400351847197784
    0.17064589092736868

Wil je minder decimalen, gebruik dan de parameter float_format om het aantal decimalen te specificeren. Hier gebruiken we er drie.

new_df.to_csv('new_titanic.csv', na_rep='Datacamp', float_format='%.3f')
new_df_datacamp = pd.read_csv('new_titanic.csv')
new_df_datacamp = pd.DataFrame(new_df_datacamp)
print(new_df_datacamp['age'][:10])
0.271
0.472
0.321
0.435
0.435
Datacamp
0.673
0.020
0.334
0.171

Wil je de index niet zien, zet dan de index parameter op False.

Je kunt ook bepalen of je de kolomnamen wilt behouden met de header parameter door die op True of False te zetten (of je kunt zelf namen voor de kolommen meegeven).

Met de parameter columns kun je selecteren welke kolommen je wilt behouden. Met de parameter index_label kun je een naam instellen voor de indexkolom, of een lijst met namen als je meerdere indexen hebt.

new_df.to_csv(
    'new_titanic.csv', 
    index=True, 
    header=True, 
    columns=['age', 'alive'], 
    index_label='Index'
)
new_df = pd.read_csv('new_titanic.csv')
new_df = pd.DataFrame(new_df)
print(new_df.head())
  Index       age alive
      0  0.271174    no
      1  0.472229   yes
      2  0.321438   yes
      3  0.434531   yes
      4  0.434531    no

Bestand openen, encoding en compressie

De mode-parameter bepaalt wat er gebeurt als er al een CSV-bestand bestaat met dezelfde naam als die van jouw bestand. Als je de parameter op ‘w’ zet en er bestaat al een new_titanic.csv, dan vervangt het nieuwe bestand het oude. Zet je ’m op ‘x’, dan wordt het nieuwe bestand alleen aangemaakt als er nog geen bestand met die naam bestaat. En met ‘a’ wordt het nieuwe bestand aan het bestaande toegevoegd (handig als je alleen wat rijen wilt bijvoegen).

De parameter encoding stelt de tekencodering van het nieuwe bestand in. Als je data speciale tekens bevatten, zoals letters uit andere alfabetten, kun je deze op ‘utf-8’ of een andere encoding zetten.

De parameter compression bepaalt hoe het nieuwe bestand gecomprimeerd wordt. Standaard staat deze op ‘infer’, wat betekent dat de compressie afhangt van de extensie, maar je kunt ook zelf de gewenste extensie opgeven.

# Infer the compression
new_df.to_csv('new_titanic.csv.gz')
# Specify the compression explicitly
new_df.to_csv('new_data.csv.gz', compression='gzip')
# Specify the compression via a dictionary
new_df.to_csv(
    'new_data.zip', 
    compression={
        'method': 'zip', 
        'archive_name': 'data.csv'
    }
)

Quoting gebruiken

De parameter quoting bepaalt welk soort data tussen aanhalingstekens komt. Zoals eerder gezegd: als je een komma als scheidingsteken hebt en ook cellen met komma’s (zoals teksten), moet je bepalen wat tussen aanhalingstekens komt.

# Default value, quotes only fields with special characters or separators like tabs and commas
new_df.to_csv('new_titanic.csv', quoting=csv.QUOTE_MINIMAL)
# Quotes all fields
new_df.to_csv('new_titanic.csv', quoting=csv.QUOTE_ALL)
# Quotes only fields with non-numeric values
new_df.to_csv('new_titanic.csv', quoting=csv.QUOTE_NONNUMERIC)
# No field is quoted
new_df.to_csv('new_titanic.csv', quoting=csv.QUOTE_NONE)

Chunksize en datum-tijd-data

De parameter chunksize bepaalt hoeveel van je bestand er in één keer wordt weggeschreven. Laat je de standaardwaarde staan, dan worden alle rijen in één keer geschreven, maar je kunt ook een getal opgeven, wat handig kan zijn bij zeer grote bestanden.

De parameter date_format bepaalt de weergave van datetime-objecten. Je kunt dit opgeven met de strftime-notatie.

# Write DataFrame to CSV with dates formatted as 'MM/DD/YYYY'
new_df.to_csv('new_titanic.csv', date_format='%m/%d/%Y')
# You can set datetime objects up to seconds
new_df.to_csv('new_titanic.csv', date_format='%Y-%m-%d %H:%M:%S')

Conclusie

Hopelijk kun je je DataFrame nu exporteren in het formaat dat bij jouw behoeften past!

Blijf vooral leren—hier zijn wat resources die je kunt proberen:

Tudor Mărginean

Auteur

Tudor Mărginean

Ik rond mijn master data science af aan de Universiteit van Boekarest, Roemenië, met een thesis over verkeersstroomvoorspelling met verschillende modellen gebaseerd op Graph Neural Networks. De belangrijkste vaardigheden die ik heb opgedaan zijn datacleaning en visualisatie in Python en Power BI, preprocessing voor diverse machinelearning-taken, en het bouwen van modellen met PyTorch (of TensorFlow). Tegelijkertijd geef ik als promovendus in de filosofie werkgroepen in eerstegraadslogica, terwijl ik werk aan mijn proefschrift over Bayesiaanse bevestigingstheorie. Ik leer graag meer over data en het bouwen van modellen, en ik vind het leuk om door te geven wat ik leer.

Onderwerpen

Data-analyseData Science