Pandas Tutorial: DataFrames in Python

• Du weißt auch, dass .iloc[] sich die Positionen im Index ansehen wird. Wenn du 2 passierst, wirst du zurückkommen:

48    7
49    8
50    9

• Da der Index nicht nur Ganzzahlen enthält, verhält sich .ix[] genauso wie iloc und schaut sich die Positionen im Index an. Du erhältst das gleiche Ergebnis wie .iloc[].

Jetzt, da der Unterschied zwischen .iloc[], .loc[] und .ix[] klar ist, kannst du deinem DataFrame Zeilen hinzufügen!

Tipp: Als Konsequenz aus dem, was du gerade gelesen hast, verstehst du jetzt auch, dass die allgemeine Empfehlung lautet, dass du .loc verwendest, um Zeilen in deinen DataFrame einzufügen. Denn wenn du df.ix[] verwenden würdest, könntest du versuchen, einen numerisch bewerteten Index mit dem Indexwert zu referenzieren und versehentlich eine bestehende Zeile deines DataFrame überschreiben. Das solltest du vermeiden!

Sieh dir den Unterschied noch einmal in dem DataFrame unten an:

df = pd.DataFrame(data=np.array([[1, 2, 3], [4, 5, 6], [7, 8, 9]]), index= [2.5, 12.6, 4.8], columns=[48, 49, 50])

# This will make an index labeled `2` and add the new values
df.loc[2] = [11, 12, 13]
print(df)

     48  49  50

2.5    1   2   3

12.6   4   5   6

4.8    7   8   9

2.0   11  12  13

Du verstehst, warum das alles verwirrend sein kann, oder?

Hinzufügen einer Spalte zu deinem DataFrame

In manchen Fällen möchtest du deinen Index zu einem Teil deines DataFrames machen. Du kannst dies ganz einfach tun, indem du eine Spalte aus deinem DataFrame nimmst oder indem du auf eine Spalte verweist, die du noch nicht erstellt hast, und sie der Eigenschaft .index zuweist, so wie hier:

df = pd.DataFrame(data=np.array([[1, 2, 3], [4, 5, 6], [7, 8, 9]]), columns=['A', 'B', 'C'])
​
# Use `.index`
df['D'] = df.index
​
# Print `df`
print(df)

  A  B  C  D

0  1  2  3  0

1  4  5  6  1

2  7  8  9  2

Mit anderen Worten: Du sagst deinem DataFrame, dass er die Spalte A als Index nehmen soll.

Wenn du jedoch Spalten an deinen DataFrame anhängen möchtest, kannst du auch den gleichen Ansatz verfolgen, wie wenn du einen Index zu deinem DataFrame hinzufügst: Du verwendest .loc[] oder .iloc[]. In diesem Fall fügst du mit Hilfe von .loc[] eine Reihe zu einem bestehenden DataFrame hinzu:

# Study the DataFrame `df`
print(df)

# Append a column to `df`
df.loc[:, 4] = pd.Series(['5', '6', '7'], index=df.index)

# Print out `df` again to see the changes
print(df)

  A  B  C  D

0  1  2  3  0

1  4  5  6  1

2  7  8  9  2

   A  B  C  D  4

0  1  2  3  0  5

1  4  5  6  1  6

2  7  8  9  2  7

Denke daran, dass ein Series-Objekt ähnlich wie eine Spalte eines DataFrame ist. Das erklärt, warum du ganz einfach eine Reihe zu einem bestehenden Datenrahmen hinzufügen kannst. Beachte auch, dass die zuvor gemachte Beobachtung über .loc[] immer noch gültig ist, auch wenn du Spalten zu deinem DataFrame hinzufügst!

Den Index deines DataFrame zurücksetzen

Wenn dein Index nicht ganz so aussieht, wie du ihn haben willst, kannst du ihn zurücksetzen. Das kannst du ganz einfach mit .reset_index() machen. Trotzdem solltest du aufpassen, denn du kannst mehrere Argumente übergeben, die über den Erfolg deines Reset entscheiden können:

# Check out the weird index of your dataframe
print(df)

# Use `reset_index()` to reset the values. 
df_reset = df.reset_index(level=0, drop=True)

# Print `df_reset`
print(df_reset)

  A  B  C  D  4

0  1  2  3  0  5

1  4  5  6  1  6

2  7  8  9  2  7

   A  B  C  D  4

0  1  2  3  0  5

1  4  5  6  1  6

2  7  8  9  2  7

Du kannst versuchen, das Argument drop im obigen Beispiel durch inplace zu ersetzen und sehen, was passiert!

Beachte, dass du mit dem Argument drop angibst, dass du den vorhandenen Index loswerden willst. Wenn du inplace verwendet hättest, würde der ursprüngliche Index mit Floats als zusätzliche Spalte zu deinem DataFrame hinzugefügt.

Einen Index aus deinem DataFrame löschen

Wenn du den Index aus deinem DataFrame entfernen willst, solltest du es dir noch einmal überlegen, denn DataFrames und Reihen haben immer einen Index.

Was du jedoch tun *kannst*, ist zum Beispiel:

• den Index deines DataFrame zurücksetzen (siehe den vorherigen Abschnitt, um zu sehen, wie das gemacht wird) oder
• entferne den Indexnamen, falls es einen gibt, indem du del df.index.name ausführst,
• doppelte Indexwerte entfernen, indem du den Index zurücksetzt, die Duplikate der Indexspalte, die zu deinem DataFrame hinzugefügt wurde, löschst und die duplikatlose Spalte wieder als Index einsetzt
• und schließlich einen Index und damit eine Zeile entfernen. Dies wird in diesem Lernprogramm näher erläutert.

df = pd.DataFrame(data=np.array([[1, 2, 3], [4, 5, 6], [7, 8, 9], [40, 50, 60], [23, 35, 37]]), 
                  index= [2.5, 12.6, 4.8, 4.8, 2.5], 
                  columns=[48, 49, 50])
                  
df.reset_index().drop_duplicates(subset='index', keep='last').set_index('index')

Da du nun weißt, wie du einen Index aus deinem DataFrame entfernst, kannst du mit dem Entfernen von Spalten und Zeilen fortfahren!

Löschen einer Spalte aus deinem DataFrame

Um (eine Auswahl von) Spalten aus deinem DataFrame loszuwerden, kannst du die Methode drop() verwenden:

df = pd.DataFrame(data=np.array([[1, 2, 3], [4, 5, 6], [7, 8, 9]]), columns=['A', 'B', 'C'])

# Check out the DataFrame `df`
print(df)

# Drop the column with label 'A'                  
df.drop('A', axis=1, inplace=True)

# Drop the column at position 1
df.drop(df.columns[[1]], axis=1)

  A  B  C

0  1  2  3

1  4  5  6

2  7  8  9

Du denkst jetzt vielleicht: Na ja, das ist nicht so einfach; es gibt einige zusätzliche Argumente, die an die Methode drop() übergeben werden!

• Das Argument axis ist entweder 0, wenn es Zeilen angibt, und 1, wenn es zum Ablegen von Spalten verwendet wird.
• Du kannst inplace auf True setzen, um die Spalte zu löschen, ohne den DataFrame neu zuordnen zu müssen.

Eine Zeile aus deinem DataFrame entfernen

Du kannst doppelte Zeilen aus deinem DataFrame entfernen, indem du df.drop_duplicates() ausführst. Du kannst auch Zeilen aus deinem DataFrame entfernen, wobei du nur die doppelten Werte in einer Spalte berücksichtigst.

Schau dir dieses Beispiel an:

df = pd.DataFrame(data=np.array([[1, 2, 3], [4, 5, 6], [7, 8, 9], [40, 50, 60], [23, 35, 37]]), 
                  index= [2.5, 12.6, 4.8, 4.8, 2.5], 
                  columns=[48, 49, 50])

# Check out your DataFrame `df`
print(df)

# Drop the duplicates in `df`
df.drop_duplicates([48], keep='last')

      48  49  50

2.5    1   2   3

12.6   4   5   6

4.8    7   8   9

4.8   40  50  60

2.5   23  35  37

Wenn es kein Einzigartigkeitskriterium für die Löschung gibt, die du durchführen möchtest, kannst du die Methode drop() verwenden, bei der du mit der Eigenschaft index den Index der Zeilen angibst, die du aus deinem DataFrame entfernen möchtest:

# Check out the DataFrame `df`
print(df)

# Drop the index at position 1
df.drop(df.index[1])

     48  49  50

2.5    1   2   3

12.6   4   5   6

4.8    7   8   9

4.8   40  50  60

2.5   23  35  37

Nach diesem Befehl möchtest du vielleicht den Index wieder zurücksetzen.

Tipp: Versuche selbst, den Index des resultierenden DataFrame zurückzusetzen! Vergiss nicht, das Argument drop zu verwenden, wenn du es für nötig hältst.

Ersetzen aller Vorkommen einer Zeichenkette in einem DataFrame

Um bestimmte Zeichenfolgen in deinem DataFrame zu ersetzen, kannst du ganz einfach replace() verwenden: Übergib die Werte, die du ändern möchtest, gefolgt von den Werten, durch die du sie ersetzen willst.

Genau so:

df = pd.DataFrame({"Student1":['OK','Awful','Acceptable'], 
                   "Student2":['Perfect','Awful','OK'], 
                   "Student3":['Acceptable','Perfect','Poor']})

# Study the DataFrame `df` first
print(df)

# Replace the strings by numerical values (0-4)
df.replace(['Awful', 'Poor', 'OK', 'Acceptable', 'Perfect'], [0, 1, 2, 3, 4]) 

     Student1 Student2    Student3

0          OK  Perfect  Acceptable

1       Awful    Awful     Perfect

2  Acceptable       OK        Poor

Beachte, dass es auch ein regex Argument gibt, das dir sehr helfen kann, wenn du mit seltsamen Zeichenkettenkombinationen konfrontiert wirst:

df =  pd.DataFrame([["1\n", 2, "3\n"], [4, 5, "6\n"] ,[7, "8\n", 9]])

# Check out your DataFrame `df`
print(df)

# Replace strings by others with `regex`
df.replace({'\n': ''}, regex=True)

    0    1    2

0  1\n    2  3\n

1    4    5  6\n

2    7  8\n    9

Kurz gesagt: replace() ist das, womit du dich meistens beschäftigen musst, wenn du Werte oder Zeichenketten in deinem DataFrame durch andere ersetzen willst!

Teile von Strings in den Zellen deines DataFrame entfernen

Unerwünschte Teile von Strings zu entfernen ist eine mühsame Arbeit. Zum Glück gibt es eine einfache Lösung für dieses Problem!

df =  pd.DataFrame([["+-1aAbBcC", "2", "+-3aAbBcC"], ["4", "5", "+-6aAbBcC"] ,["7", "+-8aAbBcC", "9"]])

# Check out your DataFrame
print(df)

# Delete unwanted parts from the strings in the first column
df[0] = df[0].map(lambda x: x.lstrip('+-').rstrip('aAbBcC'))

# Check out the result again
df

          0          1          2

0  +-1aAbBcC          2  +-3aAbBcC

1          4          5  +-6aAbBcC

2          7  +-8aAbBcC          9

Du verwendest map() für die Spalte result, um die Lambda-Funktion auf jedes Element oder elementweise der Spalte anzuwenden. Die Funktion selbst nimmt den Wert der Zeichenkette und entfernt das + oder -, das sich auf der linken Seite befindet, und entfernt auch die sechs aAbBcC auf der rechten Seite.

Text in einer Spalte in mehrere Zeilen in einem DataFrame aufteilen

Dies ist eine etwas schwierigere Formatierungsaufgabe. Der nächste Codeabschnitt führt dich jedoch durch die einzelnen Schritte:

df = pd.DataFrame({"Age": [34, 22, 19], 
                   "PlusOne":[0,0,1], 
                   "Ticket":["23:44:55", "66:77:88", "43:68:05 56:34:12"]})

# Inspect your DataFrame `df`
print(df)

# Split out the two values in the third row
# Make it a Series
# Stack the values
ticket_series = df['Ticket'].str.split(' ').apply(pd.Series, 1).stack()

# Get rid of the stack:
# Drop the level to line up with the DataFrame
ticket_series.index = ticket_series.index.droplevel(-1)

print(ticket_series)

  Age  PlusOne             Ticket

0   34        0           23:44:55

1   22        0           66:77:88

2   19        1  43:68:05 56:34:12

0    23:44:55

1    66:77:88

2    43:68:05

2    56:34:12

dtype: object

          0

0  23:44:55

1  66:77:88

2  43:68:05

2  56:34:12

Kurz gesagt, was du tust, ist:

• Zuerst untersuchst du den vorliegenden DataFrame. Du siehst, dass die Werte in der letzten Zeile und in der letzten Spalte ein bisschen zu lang sind. Es scheint, als gäbe es zwei Tickets, weil ein Gast eine Begleitperson zum Konzert mitgenommen hat.
• Du nimmst die Spalte Ticket aus dem DataFrame df und fügst ein Leerzeichen hinzu. So wird sichergestellt, dass die beiden Tickets am Ende in zwei getrennten Reihen landen. Als Nächstes nimmst du diese vier Werte (die vier Ticketnummern) und fügst sie in ein Serienobjekt ein:

      0         1
0  23:44:55       NaN
1  66:77:88       NaN
2  43:68:05  56:34:12

• Das scheint immer noch nicht ganz richtig zu sein. Du hast NaN Werte da drin! Du musst die Reihen stapeln, um sicherzustellen, dass du keine NaN Werte in der resultierenden Reihe hast.
• Als nächstes siehst du, dass deine Serie gestapelt ist.

0  0    23:44:55
1  0    66:77:88
2  0    43:68:05
   1    56:34:12

• Auch das ist nicht ideal. Deshalb lässt du die Ebene fallen, damit sie mit dem DataFrame übereinstimmt:

0    23:44:55
1    66:77:88
2    43:68:05
2    56:34:12
dtype: object

• Das ist es, wonach du suchst.
• Wandle deine Reihe in einen DataFrame um, damit du sie wieder mit deinem ursprünglichen DataFrame verbinden kannst. Um jedoch Duplikate in deinem DataFrame zu vermeiden, kannst du die ursprüngliche Spalte Ticket löschen.

Anwenden einer Funktion auf die Spalten oder Zeilen deines Pandas DataFrame

Vielleicht möchtest du die Daten in deinem DataFrame anpassen, indem du eine Funktion auf sie anwendest. Beginnen wir mit der Beantwortung dieser Frage, indem wir deine eigene Lambda-Funktion erstellen:

doubler = lambda x: x*2

Tipp: Wenn du mehr über Funktionen in Python wissen willst, solltest du dieses Python-Funktionen-Tutorial besuchen.

df = pd.DataFrame(data=np.array([[1, 2, 3], [4, 5, 6], [7, 8, 9]]), columns=['A', 'B', 'C'])

# Study the `df` DataFrame
print(df)

# Apply the `doubler` function to the `A` DataFrame column
df['A'].apply(doubler)
 A  B  C

0  1  2  3

1  4  5  6

2  7  8  9

0     2

1     8

2    14

Name: A, dtype: int64

Beachte, dass du auch die Zeile deines DataFrame auswählen und die doubler Lambda-Funktion darauf anwenden kannst. Vergiss nicht, dass du mit .loc[] oder .iloc[] ganz einfach eine Zeile aus deinem DataFrame auswählen kannst.

Je nachdem, ob du deinen Index anhand seiner Position oder anhand seiner Beschriftung auswählen möchtest, würdest du dann etwas Ähnliches ausführen:

df.loc[0].apply(doubler)

Beachte, dass die Funktion apply() die Funktion doubler nur entlang der Achse deines DataFrame anwendet. Das bedeutet, dass du entweder auf den Index oder auf die Spalten abzielst. Oder anders gesagt, entweder eine Zeile oder eine Spalte.

Wenn du sie jedoch auf jedes Element oder elementweise anwenden möchtest, kannst du die Funktion map() verwenden. Du kannst die Funktion apply() im obigen Codeabschnitt einfach durch map() ersetzen. Vergiss nicht, die Funktion doubler zu übergeben, um sicherzustellen, dass du die Werte mit 2 multiplizierst.

Angenommen, du möchtest diese Verdopplungsfunktion nicht nur auf die Spalte A deines DataFrame anwenden, sondern auf den gesamten DataFrame. In diesem Fall kannst du applymap() verwenden, um die Funktion doubler auf jedes einzelne Element im gesamten DataFrame anzuwenden:

doubled_df = df.applymap(doubler)
print(doubled_df)

   A   B   C

0   2   4   6

1   8  10  12

2  14  16  18

Beachte, dass wir in diesen Fällen mit Lambda-Funktionen oder anonymen Funktionen gearbeitet haben, die zur Laufzeit erstellt werden. Du kannst aber auch deine eigene Funktion schreiben. Zum Beispiel:

def doubler(x):
    if x % 2 == 0:
        return x
    else:
        return x * 2

# Use `applymap()` to apply `doubler()` to your DataFrame
doubled_df = df.applymap(doubler)

# Check the DataFrame
print(doubled_df)

   A   B   C

0   2   2   6

1   4  10   6

2  14   8  18

Wenn du mehr Informationen über den Kontrollfluss in Pythonmöchtest, kannst du dir auch unsere anderen Ressourcen ansehen.

Pivotieren deines DataFrame

Du kannst die Funktion pivot() verwenden, um eine neue abgeleitete Tabelle aus deiner ursprünglichen Tabelle zu erstellen. Wenn du die Funktion verwendest, kannst du drei Argumente übergeben:

1. valuesMit diesem Argument kannst du angeben, welche Werte deines ursprünglichen DataFrame du in deiner Pivot-Tabelle sehen möchtest.
2. columns: Was auch immer du diesem Argument übergibst, wird eine Spalte in deiner Tabelle.
3. index: Was auch immer du diesem Argument übergibst, wird ein Index in deiner Tabelle.

# Import pandas
import pandas as pd

# Create your DataFrame
products = pd.DataFrame({'category': ['Cleaning', 'Cleaning', 'Entertainment', 'Entertainment', 'Tech', 'Tech'],
        'store': ['Walmart', 'Dia', 'Walmart', 'Fnac', 'Dia','Walmart'],
        'price':[11.42, 23.50, 19.99, 15.95, 55.75, 111.55],
        'testscore': [4, 3, 5, 7, 5, 8]})

# Use `pivot()` to pivot the DataFrame
pivot_products = products.pivot(index='category', columns='store', values='price')

# Check out the result
print(pivot_products)

store            Dia   Fnac  Walmart

category                            

Cleaning       23.50    NaN    11.42

Entertainment    NaN  15.95    19.99

Tech           55.75    NaN   111.55

Wenn du nicht ausdrücklich angibst, welche Werte du in deiner Tabelle erwartest, wirst du nach mehreren Spalten pivotieren:

# Import the Pandas library
import pandas as pd
​
# Construct the DataFrame
products = pd.DataFrame({'category': ['Cleaning', 'Cleaning', 'Entertainment', 'Entertainment', 'Tech', 'Tech'],
                       'store': ['Walmart', 'Dia', 'Walmart', 'Fnac', 'Dia','Walmart'],
                       'price':[11.42, 23.50, 19.99, 15.95, 55.75, 111.55],
                       'testscore': [4, 3, 5, 7, 5, 8]})
​
# Use `pivot()` to pivot your DataFrame
pivot_products = products.pivot(index='category', columns='store')
​
# Check out the results
print(pivot_products)

             price                testscore             

store            Dia   Fnac Walmart       Dia Fnac Walmart

category                                                  

Cleaning       23.50    NaN   11.42       3.0  NaN     4.0

Entertainment    NaN  15.95   19.99       NaN  7.0     5.0

Tech           55.75    NaN  111.55       5.0  NaN     8.0

Beachte, dass deine Daten keine Zeilen mit doppelten Werten für die von dir angegebenen Spalten enthalten dürfen. Wenn dies nicht der Fall ist, erhältst du eine Fehlermeldung. Wenn du die Einzigartigkeit deiner Daten nicht sicherstellen kannst, solltest du stattdessen die Methode pivot_table verwenden:

# Import the Pandas library
import pandas as pd

# Your DataFrame
products = pd.DataFrame({'category': ['Cleaning', 'Cleaning', 'Entertainment', 'Entertainment', 'Tech', 'Tech'],
                        'store': ['Walmart', 'Dia', 'Walmart', 'Fnac', 'Dia','Walmart'],
                        'price':[11.42, 23.50, 19.99, 15.95, 19.99, 111.55],
                        'testscore': [4, 3, 5, 7, 5, 8]})

# Pivot your `products` DataFrame with `pivot_table()`
pivot_products = products.pivot_table(index='category', columns='store', values='price', aggfunc='mean')

# Check out the results
print(pivot_products)

store            Dia   Fnac  Walmart

category                            

Cleaning       23.50    NaN    11.42

Entertainment    NaN  15.95    19.99

Tech           19.99    NaN   111.55

Beachte das zusätzliche Argument aggfunc, das an die Methode pivot_table übergeben wird. Dieses Argument zeigt an, dass du eine Aggregationsfunktion verwendest, um mehrere Werte zu kombinieren. In diesem Beispiel kannst du deutlich sehen, dass die Funktion mean verwendet wird.

Mit stack() und unstack() um deinen Pandas DataFrame umzugestalten

Ein Beispiel für das Stapeln hast du bereits in Abschnitt 5 gesehen. Im Grunde erinnerst du dich vielleicht noch daran, dass du einen DataFrame größer machst, wenn du ihn stapelst. Du verschiebst den Index der innersten Spalte zum Index der innersten Zeile. Du gibst einen DataFrame mit einem Index mit einer neuen innersten Ebene von Zeilenbeschriftungen zurück.

Die Umkehrung des Stapelns wird Entstapeln genannt. Ähnlich wie bei stack() verwendest du unstack(), um den innersten Zeilenindex zum innersten Spaltenindex zu machen.

Eine Erklärung zum Pivotieren, Stapeln und Entstapeln von Pandas findest du in unserem Daten umgestalten mit Pandas Kurs.

Gestalte deinen DataFrame um mit melt()

Das Schmelzen wird als nützlich angesehen, wenn du Daten hast, die eine oder mehrere Spalten haben, die Identifikatorvariablen sind, während alle anderen Spalten als Messvariablen gelten.

Diese Messgrößen sind alle "unpivot" zur Zeilenachse. Das heißt, während die gemessenen Variablen über die Breite des DataFrames verteilt wurden, sorgt die Schmelze dafür, dass sie in der Höhe des DataFrames platziert werden. Oder anders gesagt, dein DataFrame wird jetzt länger statt breiter.

Als Ergebnis hast du zwei nicht identifizierende Spalten, nämlich "Variable" und "Wert".

Lass uns das anhand eines Beispiels verdeutlichen:

# The `people` DataFrame
people = pd.DataFrame({'FirstName' : ['John', 'Jane'],
                       'LastName' : ['Doe', 'Austen'],
                       'BloodType' : ['A-', 'B+'],
                       'Weight' : [90, 64]})

# Use `melt()` on the `people` DataFrame
print(pd.melt(people, id_vars=['FirstName', 'LastName'], var_name='measurements'))

 FirstName LastName measurements value

0      John      Doe    BloodType    A-

1      Jane   Austen    BloodType    B+

2      John      Doe       Weight    90

3      Jane   Austen       Weight    64

Wenn du nach weiteren Möglichkeiten suchst, deine Daten umzugestalten, sieh dir die Dokumentation an.

Einen DataFrame in CSV ausgeben

Um einen DataFrame als CSV-Datei zu schreiben, kannst du to_csv() verwenden:

import pandas as pd
df.to_csv('myDataFrame.csv')

Dieser Teil des Codes scheint recht einfach zu sein, aber genau hier fangen für die meisten Leute die Schwierigkeiten an, denn du wirst bestimmte Anforderungen an die Ausgabe deiner Daten haben. Vielleicht möchtest du kein Komma als Trennzeichen verwenden oder du möchtest eine bestimmte Kodierung angeben.

Mach dir keine Sorgen! Du kannst einige zusätzliche Argumente an to_csv() übergeben, um sicherzustellen, dass deine Daten so ausgegeben werden, wie du sie haben möchtest!

• Um durch einen Tabulator abzugrenzen, verwende das Argument sep:

import pandas as pd
df.to_csv('myDataFrame.csv', sep='\t')

• Um eine bestimmte Zeichenkodierung zu verwenden, kannst du das Argument encoding verwenden:

import pandas as pd
df.to_csv('myDataFrame.csv', sep='\t', encoding='utf-8')

• Außerdem kannst du angeben, wie deine NaN oder fehlende Werte dargestellt werden sollen, ob du die Kopfzeile ausgeben willst oder nicht, ob du die Zeilennamen ausschreiben willst oder nicht, ob du eine Komprimierung wünschst, du kannst die Optionen nachlesen.

Ein DataFrame in Excel schreiben

Ähnlich wie bei der Ausgabe deines DataFrames in CSV kannst du mit to_excel() deine Tabelle in Excel schreiben. Allerdings ist es ein bisschen komplizierter:

import pandas as pd
writer = pd.ExcelWriter('myDataFrame.xlsx')
df.to_excel(writer, 'DataFrame')
writer.save()

Beachte jedoch, dass du genau wie bei to_csv() eine Menge zusätzlicher Argumente wie startcol, startrow usw. hast, um sicherzustellen, dass du deine Daten korrekt ausgibst. In unserem Tutorial erfährst du mehr darüber, wie du mit Pandas Daten aus CSV-Dateien importieren und in diese exportieren kannst. 

Wenn du jedoch mehr Informationen über die IO-Tools in Pandas haben möchtest, schau dir die Dokumentation zu Pandas DataFrames to excel an.