NumPy und Pandas: Warum, wieso, weshalb?

Python
NumPy
Pandas
Autor:in

Norman Markgraf

Veröffentlichungsdatum

27. März 2026

Geändert

28. März 2026

NumPy und Pandas: Warum, wieso, weshalb?

In der Welt der Datenanalyse und wissenschaftlichen Berechnung sind NumPy und Pandas zwei unverzichtbare Bibliotheken in Python. Aber warum sind sie so wichtig? In diesem Artikel werden wir die Gründe untersuchen, warum NumPy und Pandas in der Datenanalyse so weit verbreitet sind, welche Vorteile sie bieten und wie sie sich voneinander unterscheiden.

Warum NumPy?

NumPy, kurz für “Numerical Python”, ist eine Bibliothek, die effiziente Operationen auf großen, mehrdimensionalen Arrays und Matrizen ermöglicht. Hier sind einige Gründe, warum NumPy so beliebt ist:

  1. Leistung: NumPy ist in C und Fortran geschrieben, was es extrem schnell macht. Es bietet Funktionen, die auf Vektorisierung basieren, wodurch Operationen auf Arrays viel schneller ausgeführt werden können als mit herkömmlichen Python-Listen.

  2. Funktionalität: NumPy bietet eine breite Palette von Funktionen für mathem atische Operationen, lineare Algebra, Fourier-Transformationen und vieles mehr. Es ist die Grundlage für viele andere Bibliotheken wie SciPy, Matplotlib und Pandas.

  3. Kompatibilität: Viele andere Bibliotheken in der Datenwissenschaft und maschinellen Lernen basieren auf NumPy, was es zu einem unverzichtbaren Werkzeug für die Arbeit mit Daten macht.

  4. Einfachheit: NumPy bietet eine einfache und intuitive Syntax für die Arbeit mit Arrays, was es Anfängern leicht macht, sich in die Welt der Datenanalyse einzuarbeiten

Kurz:

“NumPy = schnelle Mathematik + feste Typen + große Reihungen” in Python

Beispiel

Stellen wir uns vor, wir wollen 10 Millionen Zahlen in einer Python Liste speichern.

Eine Python Liste aber:

  • Speichert die Werte irgendwo im Speicher und nicht unmittelbar hintereinander.
  • Speichert die Werte als Objekte, was zusätzlichen Speicherplatz benötigt.
  • Ist nicht für numerische Berechnungen optimiert, da jedes Objekt individuell behandelt werden muss.

Stellen wir uns vor, wie wollen zu jeder Zahl 10 hinzuaddieren. Mit einer Python Liste müssten wir eine Schleife verwenden, um durch die Liste zu iterieren und die Addition für jedes Element durchzuführen, was sehr langsam sein kann.

import time
# Erstellen einer Liste mit 10 Million Zahlen
my_list = list(range(10_000_000))
# Startzeit
start_time = time.time()
# Hinzufügen von 10 zu jedem Element in der Liste
for i in range(len(my_list)):
    my_list[i] += 10
# Endzeit
end_time = time.time()
print(f"Zeit für die Addition in der Liste: {end_time - start_time:0.4} Sekunden")
Zeit für die Addition in der Liste: 0.6944 Sekunden

Die angegebe Laufzeit hängen natürlich von den Rechner und den Versionen der Software ab.

Der Grund wieso das alles so langsam ist, liegt unter anderem daran, dass die 10.000.000 Einträge in der Python Liste in der Schleife durchlaufen wird. Und das ist langsam, denn die ergentliche Liste ist eine Liste von Verweisen auf die in einem Objekt gespeicherten eigentlichen Werte. Python geht also (schnell) eine Liste von Referenzen durch, muss aber jedesmal (irgendwo) im Speicher den eigentlichen Werte suchen, dann anpassen und dann in der (Referenz-)Liste den nächsten suchen.

Die Lösung dieses Problems ist NumPy.

Mit NumPy können wir ein Array erstellen, das die Zahlen direkt hintereinander im Speicher speichert und die Werte als numerische Datentypen behandelt, da es davon ausgeht, dass diese alle vom selben Datentyp sind. (Python schaut erst in den Metadaten des Objekts nach, ob dem so ist. Das kostet auch Zeit.) Dadurch können wir die Addition von 10 zu jedem Element in einem einzigen Schritt durchführen, ohne eine Python-Schleife zu verwenden, was viel schneller ist.

Okay, wir durchlaufen schon eine Schleife, aber diese muss nicht nach dem eigentlichen Objekt mit dem Eintrag in Speicher suchen. Denn im Array sind alle Objekte vom selbern Datentyp und belegen immer den selber Speicherplatz und das hintereinander. Wir springen also direkt zum nächsten Eintrag, ändern und gehen weiter. Das ist deutlich schneller und ermöglicht das die Verarbeitung optimiert ist. NumPy nutzt auch Vektorisierung, um Operationen auf Arrays effizienter durchzuführen, indem es sie in C (oder Fortran) ausführt, anstatt in Python.

import numpy as np
import time
# Erstellen eines NumPy-Arrays mit 10 Million Zahlen
my_array = np.arange(10_000_000)
# Startzeit
start_time = time.time()
# Hinzufügen von 10 zu jedem Element im Array
my_array += 10
# Endzeit
end_time = time.time()
print(f"Zeit für die Addition im NumPy-Array: {end_time - start_time:0.4} Sekunden.")
Zeit für die Addition im NumPy-Array: 0.009774 Sekunden.

Auch hier hängt die angegebene Laufzeit vom Rechner und den Software Versionen ab. Aber die Tendenzen zeigen sich hier schon klar. NumPy ist deutlich schneller als reines Python.

Darum ist NumPy die Grundlage für die Pakete:

  • Tensoflow
  • PyTorch
  • Scikit-learn
  • SciPy
  • JAX
  • u.v.m.

Ein paar NumPy Grundlagen

NumPy Arrays erstellen

import numpy as np
# Erstellen eines 1D-Arrays
array_1d = np.array([1, 2, 3, 4, 5])
print(array_1d)
[1 2 3 4 5]
# Erstellen eines 2D-Arrays
array_2d = np.array([[1, 2, 3], [4, 5, 6]])
print(array_2d)
[[1 2 3]
 [4 5 6]]
# Erstellen eines Arrays mit Nullen
zeros_array = np.zeros((3, 3))
print(zeros_array)
[[0. 0. 0.]
 [0. 0. 0.]
 [0. 0. 0.]]
# Erstellen eines Arrays mit Einsen
ones_array = np.ones((2, 4))
print(ones_array)
[[1. 1. 1. 1.]
 [1. 1. 1. 1.]]
# Erstellen eines Arrays mit einem bestimmten Wert
full_array = np.full((2, 3), 7)
print(full_array)
[[7 7 7]
 [7 7 7]]
# Erstellen eines Arrays mit zufälligen Werten
random_array = np.random.rand(4, 4)
print(random_array)
[[0.2424124  0.36481336 0.6578541  0.94303291]
 [0.14924699 0.4103965  0.17397575 0.81790553]
 [0.15089817 0.82787736 0.25031211 0.53856544]
 [0.6382477  0.19304652 0.05265733 0.52864991]]
# Erstellen eines Arrays der ersten 10 natürlichen Zahlen
arange_array = np.arange(10)
print(arange_array)
[0 1 2 3 4 5 6 7 8 9]
# Erstellen eines Arrays mit fünf gleichmäßig verteilten Werten zwischen 0 und 1
linspace_array = np.linspace(0, 1, 5)
print(linspace_array)
[0.   0.25 0.5  0.75 1.  ]

Gestalt (shape), Größe (size) und Dimensionen (ndim) von NumPy Arrays

import numpy as np
# Erstellen eines 2D-Arrays
array_2d = np.array([[1, 2, 3], [4, 5, 6]])
print("Array:\n", array_2d)
Array:
 [[1 2 3]
 [4 5 6]]
# Form des Arrays
print("Shape:", array_2d.shape)
Shape: (2, 3)
# Größe des Arrays
print("Size:", array_2d.size)
Size: 6
# Anzahl der Dimensionen
print("Number of dimensions:", array_2d.ndim)
Number of dimensions: 2

NumPy Array Indexierung und Slicing

import numpy as np
# Erstellen eines 2D-Arrays
array_2d = np.array([[1, 2, 3], [4, 5, 6]])
print("Ein 2D-Array:\n",array_2d)
Ein 2D-Array:
 [[1 2 3]
 [4 5 6]]
# Zugriff auf ein Element
print("Element at (0, 1):\n", array_2d[0, 1])
Element at (0, 1):
 2
# Zugriff auf eine Zeile
print("First row:\n", array_2d[0])
First row:
 [1 2 3]
# Zugriff auf eine Spalte
print("Second column:\n", array_2d[:, 1])
Second column:
 [2 5]
# Slicing eines Subarrays
print("Subarray (first two rows and first two columns):\n", array_2d[:2, :2])
Subarray (first two rows and first two columns):
 [[1 2]
 [4 5]]
# Slicing eines Submatrix
print("Submatrix (last row and last two columns):\n", array_2d[1:, 1:])
Submatrix (last row and last two columns):
 [[5 6]]
import numpy as np
# Erstellen eines 1D-Arrays
array_1d = np.array([1, 2, 3, 4, 5])
print("Ein 1D-Array:\n", array_1d)
Ein 1D-Array:
 [1 2 3 4 5]
# Zugriff auf ein Element
print("Element at index 2:\n", array_1d[2])
Element at index 2:
 3
# Slicing eines Subarrays
print("Subarray (die ersten 3 Elemente):\n", array_1d[:3])
Subarray (die ersten 3 Elemente):
 [1 2 3]
print("Subarray (die Elemente an der 2. und 3. Stelle):\n", array_1d[2:4])
Subarray (die Elemente an der 2. und 3. Stelle):
 [3 4]

Vektorisierte Operationen auf NumPy Arrays

import numpy as np
# Erstellen eines 1D-Arrays
array_1d = np.array([1, 2, 3, 4, 5])
print("Ein 1D-Array:\n", array_1d)
Ein 1D-Array:
 [1 2 3 4 5]
# Vektorisierte Operationen
print("Array + 10:\n", array_1d + 10)
Array + 10:
 [11 12 13 14 15]
print("Array * 2:\n", array_1d * 2)
Array * 2:
 [ 2  4  6  8 10]
print("Array - 1:\n", array_1d - 1)
Array - 1:
 [0 1 2 3 4]
print("Array / 2:\n", array_1d / 2)
Array / 2:
 [0.5 1.  1.5 2.  2.5]
print("Wurzel aus einem Array:\n", np.sqrt(array_1d))
Wurzel aus einem Array:
 [1.         1.41421356 1.73205081 2.         2.23606798]
import numpy as np
# Erstellen zweier 1D-Arrays
a = np.array([1, 2, 3, 4, 5, 6, 7, 8, 9, 10])
b = np.array([10, 9, 8, 7, 6, 5, 4, 3, 2, 1])
print("Array a:\n", a)
Array a:
 [ 1  2  3  4  5  6  7  8  9 10]
print("Array b:\n", b)
Array b:
 [10  9  8  7  6  5  4  3  2  1]
# Vektorisierte Operationen zwischen Arrays
a + b
array([11, 11, 11, 11, 11, 11, 11, 11, 11, 11])
a * b
array([10, 18, 24, 28, 30, 30, 28, 24, 18, 10])
a - b
array([-9, -7, -5, -3, -1,  1,  3,  5,  7,  9])
a / b
array([ 0.1       ,  0.22222222,  0.375     ,  0.57142857,  0.83333333,
        1.2       ,  1.75      ,  2.66666667,  4.5       , 10.        ])

Warum ist NumPy so schnell?

Intern werden optimierte C- oder Fortran-Code ausgeführt, der direkt auf die Daten im Speicher zugreift. Dies ermöglicht es NumPy, Operationen auf großen Arrays viel schneller durchzuführen als herkömmliche Python-Listen, die in einer Schleife verarbeitet werden müssen.

Deshalb werden im ML und DL die meisten Operationen auf NumPy Arrays ausgeführt. Dinge wie “scaling” und Matrix-Operationen werden so sehr viel schneller als im reinen Python.

Reshaping (umorganisieren von NumPy Arrays)

import numpy as np
# Erstellen eines 1D-Arrays mit 12 Elementen
array_1d = np.arange(12) + 1
print("Ein 1D-Array:", array_1d)
Ein 1D-Array: [ 1  2  3  4  5  6  7  8  9 10 11 12]
# Reshaping in ein 2D-Array mit 3 Zeilen und 4
array_2d = array_1d.reshape(3, 4)
print("Reshaped Array (3x4):\n", array_2d)
Reshaped Array (3x4):
 [[ 1  2  3  4]
 [ 5  6  7  8]
 [ 9 10 11 12]]
# Reshaping in ein 2D-Array mit 4 Zeilen und 3
array_2d_4x3 = array_1d.reshape(4, 3)
print("Reshaped Array (4x3):\n", array_2d_4x3)
Reshaped Array (4x3):
 [[ 1  2  3]
 [ 4  5  6]
 [ 7  8  9]
 [10 11 12]]
# Reshaping in ein 3D-Array mit 2 Blöcken, 2 Zeilen und 3 Spalten
array_3d = array_1d.reshape(2, 2, 3)
print("Reshaped Array (2x2x3):\n", array_3d)
Reshaped Array (2x2x3):
 [[[ 1  2  3]
  [ 4  5  6]]

 [[ 7  8  9]
  [10 11 12]]]

Nahezu alle ML und DL modelle nutzen das Reshaping von Arrays, um die Daten in die richtige Form zu bringen, damit sie von den Modellen verarbeitet werden können. Zum Beispiel müssen Bilder oft in 4D-Arrays umgeformt werden, bevor sie in ein Convolutional Neural Network (CNN) eingespeist werden können.

Jedoch wird dabei niemals die Daten ansich verändert, sondern nur die Art und Weise, wie sie organisiert und interpretiert werden. Das Reshaping ermöglicht es, die Daten in einer Form zu präsentieren, die für die Verarbeitung durch ML-Modelle optimal ist, ohne die zugrunde liegenden Werte zu verändern.

Natürlich geht das nur, wenn die Anzahl der Elemente im ursprünglichen Array mit der Anzahl der Elemente im neuen Array übereinstimmt. Das bedeutet, dass die Gesamtzahl der Elemente vor und nach dem Reshaping gleich sein muss, damit die Daten korrekt umorganisiert werden können.

Das wird oft in der Praxis genutzt in der Vorverarbeitung von Daten (pre-processing), um sicherzustellen, dass die Daten die richtige Form haben, bevor sie in ein ML-Modell eingespeist werden.

Warum Pandas?

Pandas ist eine Bibliothek, die speziell für die Datenanalyse und -manipulation entwickelt wurde. Der Name leitet sich vom englischen “panel datas”, eine ökonometrischen Bezeichnung für Datentabellen, ab. Hier sind einige Gründe, warum Pandas so wichtig ist:

  1. Datenstrukturen: Pandas bietet zwei Hauptdatenstrukturen, den DataFrame und die Series, die es ermöglichen, Daten in tabellarischer Form zu organisieren und zu manipulieren. Diese Strukturen sind besonders nützlich für die Arbeit mit heterogenen Daten.

  2. Datenmanipulation: Pandas bietet eine Vielzahl von Funktionen für die Datenmanipulation, einschließlich Filtern, Gruppieren, Pivot-Tabellen und mehr. Es ermöglicht es Benutzern, komplexe Datenoperationen mit Leichtigkeit durchzuführen.

  3. Datenbereinigung: Pandas bietet leistungsstarke Werkzeuge zur Bereinigung von Daten, einschließlich Funktionen zum Umgang mit fehlenden Werten, Duplikaten und Inkonstanzen in den Daten.

  4. Integration: Pandas lässt sich nahtlos mit anderen Bibliotheken wie NumPy, Matplotlib und Scikit-learn integrieren, was es zu einem unverzichtbaren Werkzeug für die Datenanalyse macht.

Kurz:

“Pandas = Tabellenkalkulation + SQL + NumPy” in Python

Beispiel

NumPy ist wundervoll für mathematische Probleme, aber die Daten in der realen Welt sind oft unstrukturiert und heterogen. Hier kommt Pandas ins Spiel, um diese Daten in eine strukturierte Form zu bringen, die leichter zu analysieren ist.

Es gibt zwei grundlegende Datenstrukturen in Pandas: Series und DataFrame.

  • Eine Series ist eine eindimensionale, beschriftete Datenstruktur, die eine Liste von Werten enthält. Sie kann als eine Art erweiterte Liste betrachtet werden, die zusätzlich zu den Werten auch Indizes hat.

  • Ein DataFrame ist eine zweidimensionale, tabellarische Datenstruktur, die aus mehreren Series besteht. Es ist vergleichbar mit einer Tabelle in einer Datenbank oder einem Arbeitsblatt in Excel, wobei Zeilen und Spalten beschriftet sind.

import pandas as pd
# Erstellen einer Series
my_series = pd.Series([10, 20, 30, 40, 50], index=['a', 'b', 'c', 'd', 'e'])
print("Eine Series:\n", my_series)
# Erstellen eines DataFrames
my_dataframe = pd.DataFrame({
    'Name': ['Alice', 'Bob', 'Charlie', 'David', 'Eve'],
    'Alter': [25, 30, 35, 40, 45],
    'Stadt': ['New York', 'Los Angeles', 'Chicago', 'Houston', 'Phoenix']
})
print("Ein DataFrame:\n", my_dataframe)
Eine Series:
 a    10
b    20
c    30
d    40
e    50
dtype: int64
Ein DataFrame:
       Name  Alter        Stadt
0    Alice     25     New York
1      Bob     30  Los Angeles
2  Charlie     35      Chicago
3    David     40      Houston
4      Eve     45      Phoenix

Anschauen der Daten in einem DataFrame

import pandas as pd
# Erstellen eines DataFrames
my_dataframe = pd.DataFrame({
    'Name': ['Alice', 'Bob', 'Charlie', 'David', 'Eve'],
    'Alter': [25, 30, 35, 40, 45],
    'Stadt': ['New York', 'Los Angeles', 'Chicago', 'Houston', 'Phoenix']
})
print("Ein DataFrame:\n", my_dataframe)
# Anzeigen der ersten 3 Zeilen
print("Die ersten 3 Zeilen:\n", my_dataframe.head(3))
# Anzeigen der letzten 2 Zeilen
print("Die letzten 2 Zeilen:\n", my_dataframe.tail(2))
# Anzeigen der Spaltennamen
print("Spaltennamen:", my_dataframe.columns)
# Anzeigen der Datenarten jeder Spalte
print("Datenarten:\n", my_dataframe.dtypes)
# Anzeigen der Anzahl der Zeilen und Spalten
print("Anzahl der Zeilen und Spalten:", my_dataframe.shape)
# Anzeigen von statistischen Zusammenfassungen der numerischen Spalten
print("Statistische Zusammenfassung:\n", my_dataframe.describe())
# Anzeigen der Informationen über den DataFrame 
print("Informationen:\n", my_dataframe.info())
Ein DataFrame:
       Name  Alter        Stadt
0    Alice     25     New York
1      Bob     30  Los Angeles
2  Charlie     35      Chicago
3    David     40      Houston
4      Eve     45      Phoenix
Die ersten 3 Zeilen:
       Name  Alter        Stadt
0    Alice     25     New York
1      Bob     30  Los Angeles
2  Charlie     35      Chicago
Die letzten 2 Zeilen:
     Name  Alter    Stadt
3  David     40  Houston
4    Eve     45  Phoenix
Spaltennamen: Index(['Name', 'Alter', 'Stadt'], dtype='str')
Datenarten:
 Name       str
Alter    int64
Stadt      str
dtype: object
Anzahl der Zeilen und Spalten: (5, 3)
Statistische Zusammenfassung:
            Alter
count   5.000000
mean   35.000000
std     7.905694
min    25.000000
25%    30.000000
50%    35.000000
75%    40.000000
max    45.000000
<class 'pandas.DataFrame'>
RangeIndex: 5 entries, 0 to 4
Data columns (total 3 columns):
 #   Column  Non-Null Count  Dtype
---  ------  --------------  -----
 0   Name    5 non-null      str  
 1   Alter   5 non-null      int64
 2   Stadt   5 non-null      str  
dtypes: int64(1), str(2)
memory usage: 252.0 bytes
Informationen:
 None

Datenselektierung mit Pandas

Pandas bietet verschiedene Möglichkeiten, um Daten aus einem DataFrame auszuwählen, einschließlich der Verwendung von Spaltennamen, Zeilenindizes und Bedingungen. Hier sind einige Beispiele:

import pandas as pd
# Erstellen eines DataFrames
my_dataframe = pd.DataFrame({
    'Name': ['Alice', 'Bob', 'Charlie', 'David', 'Eve'],
    'Alter': [25, 30, 35, 40, 45],
    'Stadt': ['New York', 'Los Angeles', 'Chicago', 'Houston',
    'Phoenix']
})
print("Ein DataFrame:\n", my_dataframe)
# Auswahl einer Spalte
print("Spalte 'Name':\n", my_dataframe['Name'])
# Auswahl mehrerer Spalten
print("Spalten 'Name' und 'Alter':\n", my_dataframe[['Name', 'Alter']])
# Auswahl einer Zeile basierend auf dem Index
print("Zeile mit Index 2:\n", my_dataframe.loc[2])
# Auswahl von Zeilen basierend auf ihrer Position
print("Die ersten 3 Zeilen:\n", my_dataframe.iloc[:3])
# Auswahl von Zeilen basierend auf einer Bedingung
print("Zeilen, in denen das Alter größer als 30 ist:\n", my_dataframe[my_dataframe['Alter'] > 30])
# Auswahl von Zeilen basierend auf einer Bedingung
print("Zeilen, in denen das Alter größer als 30 und kleiner gleich 40 ist:\n", my_dataframe[(my_dataframe['Alter'] > 30) & (my_dataframe['Alter'] <= 40)])
Ein DataFrame:
       Name  Alter        Stadt
0    Alice     25     New York
1      Bob     30  Los Angeles
2  Charlie     35      Chicago
3    David     40      Houston
4      Eve     45      Phoenix
Spalte 'Name':
 0      Alice
1        Bob
2    Charlie
3      David
4        Eve
Name: Name, dtype: str
Spalten 'Name' und 'Alter':
       Name  Alter
0    Alice     25
1      Bob     30
2  Charlie     35
3    David     40
4      Eve     45
Zeile mit Index 2:
 Name     Charlie
Alter         35
Stadt    Chicago
Name: 2, dtype: object
Die ersten 3 Zeilen:
       Name  Alter        Stadt
0    Alice     25     New York
1      Bob     30  Los Angeles
2  Charlie     35      Chicago
Zeilen, in denen das Alter größer als 30 ist:
       Name  Alter    Stadt
2  Charlie     35  Chicago
3    David     40  Houston
4      Eve     45  Phoenix
Zeilen, in denen das Alter größer als 30 und kleiner gleich 40 ist:
       Name  Alter    Stadt
2  Charlie     35  Chicago
3    David     40  Houston

Datenmanipulation mit Pandas

Pandas bietet eine Vielzahl von Funktionen für die Datenmanipulation, einschließlich Filtern, Gruppieren, Pivot-Tabellen und mehr. Hier sind einige Beispiele:

import pandas as pd
# Erstellen eines DataFrames
my_dataframe = pd.DataFrame({
    'Name': ['Alice', 'Bob', 'Charlie', 'David', 'Eve'],
    'Alter': [25, 30, 35, 40, 45],
    'Stadt': ['New York', 'Los Angeles', 'Chicago', 'Houston', 'Phoenix']
})
print("Ein DataFrame:\n", my_dataframe)
# Filtern von Zeilen basierend auf einer Bedingung
filtered_df = my_dataframe[my_dataframe['Alter'] > 30]
print("Gefilterter DataFrame (Alter > 30):\n", filtered_df)
# Gruppieren von Daten und Berechnen von Durchschnittsalter pro Stadt
grouped_df = my_dataframe.groupby('Stadt')['Alter'].mean()
print("Durchschnittsalter pro Stadt:\n", grouped_df)
# Erstellen einer Pivot-Tabelle
pivot_table = my_dataframe.pivot_table(values='Alter', index='Stadt', aggfunc='mean')
print("Pivot-Tabelle (Durchschnittsalter pro Stadt):\n", pivot_table)
Ein DataFrame:
       Name  Alter        Stadt
0    Alice     25     New York
1      Bob     30  Los Angeles
2  Charlie     35      Chicago
3    David     40      Houston
4      Eve     45      Phoenix
Gefilterter DataFrame (Alter > 30):
       Name  Alter    Stadt
2  Charlie     35  Chicago
3    David     40  Houston
4      Eve     45  Phoenix
Durchschnittsalter pro Stadt:
 Stadt
Chicago        35.0
Houston        40.0
Los Angeles    30.0
New York       25.0
Phoenix        45.0
Name: Alter, dtype: float64
Pivot-Tabelle (Durchschnittsalter pro Stadt):
              Alter
Stadt             
Chicago       35.0
Houston       40.0
Los Angeles   30.0
New York      25.0
Phoenix       45.0

Hinzufügen von Daten zu einem DataFrame

import pandas as pd
# Erstellen eines DataFrames
my_dataframe = pd.DataFrame({
    'Name': ['Alice', 'Bob', 'Charlie', 'David', 'Eve'],
    'Alter': [25, 30, 35, 40, 45],
    'Stadt': ['New York', 'Los Angeles', 'Chicago', 'Houston', 'Phoenix']
})
print("Ein DataFrame:\n", my_dataframe)

# Hinzufügen einer neuen Spalte
my_dataframe['Beruf'] = ['Ingenieur', 'Arzt', 'Lehrer', 'Künstler', 'Anwalt']
print("DataFrame mit neuer Spalte 'Beruf':\n", my_dataframe)

# Hinzufügen einer neuen Zeile
new_row = pd.Series({'Name': 'Frank', 'Alter': 50, 'Stadt': 'Miami', 'Beruf': 'Architekt'})
my_dataframe = pd.concat([my_dataframe, new_row.to_frame().T], ignore_index=True)
print("DataFrame mit neuer Zeile:\n", my_dataframe)
Ein DataFrame:
       Name  Alter        Stadt
0    Alice     25     New York
1      Bob     30  Los Angeles
2  Charlie     35      Chicago
3    David     40      Houston
4      Eve     45      Phoenix
DataFrame mit neuer Spalte 'Beruf':
       Name  Alter        Stadt      Beruf
0    Alice     25     New York  Ingenieur
1      Bob     30  Los Angeles       Arzt
2  Charlie     35      Chicago     Lehrer
3    David     40      Houston   Künstler
4      Eve     45      Phoenix     Anwalt
DataFrame mit neuer Zeile:
       Name Alter        Stadt      Beruf
0    Alice    25     New York  Ingenieur
1      Bob    30  Los Angeles       Arzt
2  Charlie    35      Chicago     Lehrer
3    David    40      Houston   Künstler
4      Eve    45      Phoenix     Anwalt
5    Frank    50        Miami  Architekt

Fazit

NumPy und Pandas sind zwei der wichtigsten Bibliotheken in der Python-Datenanalyse. NumPy bietet eine leistungsstarke Grundlage für die Arbeit mit Arrays und mathematischen Operationen, während Pandas speziell für die Datenmanipulation und -analyse entwickelt wurde. Beide Bibliotheken ergänzen sich hervorragend und sind unverzichtbar für jeden, der in der Welt der Datenanalyse tätig ist.