Daten auswählen und filtern#
Die Indizierung von Serien (obj[...])
funktioniert analog zur Indizierung von NumPy-Arrays, außer dass ihr Indexwerte der Serie statt nur Ganzzahlen verwenden könnt. Hier sind einige Beispiele dafür:
[1]:
import numpy as np
import pandas as pd
[2]:
idx = pd.date_range("2022-02-02", periods=7)
s = pd.Series(np.random.randn(7), index=idx)
[3]:
s
[3]:
2022-02-02 0.647976
2022-02-03 -0.456759
2022-02-04 1.645400
2022-02-05 -0.327128
2022-02-06 0.289596
2022-02-07 -0.443900
2022-02-08 0.688924
Freq: D, dtype: float64
[4]:
s["2022-02-03"]
[4]:
-0.456758843961271
[5]:
s[1]
[5]:
-0.456758843961271
[6]:
s[2:4]
[6]:
2022-02-04 1.645400
2022-02-05 -0.327128
Freq: D, dtype: float64
[7]:
s[["2022-02-04", "2022-02-03", "2022-02-02"]]
[7]:
2022-02-04 1.645400
2022-02-03 -0.456759
2022-02-02 0.647976
dtype: float64
[8]:
s[[1, 3]]
[8]:
2022-02-03 -0.456759
2022-02-05 -0.327128
Freq: 2D, dtype: float64
[9]:
s[s > 0]
[9]:
2022-02-02 0.647976
2022-02-04 1.645400
2022-02-06 0.289596
2022-02-08 0.688924
dtype: float64
Zwar könnt ihr auf diese Weise Daten nach Label auswählen, doch die bevorzugte Methode zur Auswahl von Indexwerten ist der loc
-Operator:
[10]:
s.loc[["2022-02-04", "2022-02-03", "2022-02-02"]]
[10]:
2022-02-04 1.645400
2022-02-03 -0.456759
2022-02-02 0.647976
dtype: float64
Der Grund für die Bevorzugung von loc
liegt in der unterschiedlichen Behandlung von Ganzzahlen bei der Indexierung mit []
. Bei der regulären []
-basierten Indizierung werden Ganzzahlen als Label behandelt, wenn der Index Ganzzahlen enthält, so dass das Verhalten je nach Datentyp des Index unterschiedlich ist. In unserem Beispiel wird der Ausdruck s.loc[[3, 2, 1]]
fehlschlagen, da der Index keine ganzen Zahlen enthält:
[11]:
s.loc[[3, 2, 1]]
---------------------------------------------------------------------------
KeyError Traceback (most recent call last)
Cell In[11], line 1
----> 1 s.loc[[3, 2, 1]]
File ~/.local/share/virtualenvs/python-311-6zxVKbDJ/lib/python3.11/site-packages/pandas/core/indexing.py:1103, in _LocationIndexer.__getitem__(self, key)
1100 axis = self.axis or 0
1102 maybe_callable = com.apply_if_callable(key, self.obj)
-> 1103 return self._getitem_axis(maybe_callable, axis=axis)
File ~/.local/share/virtualenvs/python-311-6zxVKbDJ/lib/python3.11/site-packages/pandas/core/indexing.py:1332, in _LocIndexer._getitem_axis(self, key, axis)
1329 if hasattr(key, "ndim") and key.ndim > 1:
1330 raise ValueError("Cannot index with multidimensional key")
-> 1332 return self._getitem_iterable(key, axis=axis)
1334 # nested tuple slicing
1335 if is_nested_tuple(key, labels):
File ~/.local/share/virtualenvs/python-311-6zxVKbDJ/lib/python3.11/site-packages/pandas/core/indexing.py:1272, in _LocIndexer._getitem_iterable(self, key, axis)
1269 self._validate_key(key, axis)
1271 # A collection of keys
-> 1272 keyarr, indexer = self._get_listlike_indexer(key, axis)
1273 return self.obj._reindex_with_indexers(
1274 {axis: [keyarr, indexer]}, copy=True, allow_dups=True
1275 )
File ~/.local/share/virtualenvs/python-311-6zxVKbDJ/lib/python3.11/site-packages/pandas/core/indexing.py:1462, in _LocIndexer._get_listlike_indexer(self, key, axis)
1459 ax = self.obj._get_axis(axis)
1460 axis_name = self.obj._get_axis_name(axis)
-> 1462 keyarr, indexer = ax._get_indexer_strict(key, axis_name)
1464 return keyarr, indexer
File ~/.local/share/virtualenvs/python-311-6zxVKbDJ/lib/python3.11/site-packages/pandas/core/indexes/base.py:5877, in Index._get_indexer_strict(self, key, axis_name)
5874 else:
5875 keyarr, indexer, new_indexer = self._reindex_non_unique(keyarr)
-> 5877 self._raise_if_missing(keyarr, indexer, axis_name)
5879 keyarr = self.take(indexer)
5880 if isinstance(key, Index):
5881 # GH 42790 - Preserve name from an Index
File ~/.local/share/virtualenvs/python-311-6zxVKbDJ/lib/python3.11/site-packages/pandas/core/indexes/base.py:5938, in Index._raise_if_missing(self, key, indexer, axis_name)
5936 if use_interval_msg:
5937 key = list(key)
-> 5938 raise KeyError(f"None of [{key}] are in the [{axis_name}]")
5940 not_found = list(ensure_index(key)[missing_mask.nonzero()[0]].unique())
5941 raise KeyError(f"{not_found} not in index")
KeyError: "None of [Index([3, 2, 1], dtype='int64')] are in the [index]"
Während der loc
-Operator ausschließlich Label indiziert, indiziert der iloc
-Operator ausschließlich mit ganzen Zahlen:
[12]:
s.iloc[[3, 2, 1]]
[12]:
2022-02-05 -0.327128
2022-02-04 1.645400
2022-02-03 -0.456759
Freq: -1D, dtype: float64
Ihr könnt auch mit Labels slicen, aber das funktioniert anders als das normale Python-Slicing, da der Endpunkt inklusive ist:
[13]:
s.loc["2022-02-03":"2022-02-04"]
[13]:
2022-02-03 -0.456759
2022-02-04 1.645400
Freq: D, dtype: float64
Durch die Einstellung mit diesen Methoden wird der entsprechende Abschnitt der Reihe geändert:
[14]:
s.loc["2022-02-03":"2022-02-04"] = 0
s
[14]:
2022-02-02 0.647976
2022-02-03 0.000000
2022-02-04 0.000000
2022-02-05 -0.327128
2022-02-06 0.289596
2022-02-07 -0.443900
2022-02-08 0.688924
Freq: D, dtype: float64
Die Indizierung in einem DataFrame dient dazu, eine oder mehrere Spalten entweder mit einem einzelnen Wert oder einer Folge abzurufen:
[15]:
data = {
"Code": ["U+0000", "U+0001", "U+0002", "U+0003", "U+0004", "U+0005"],
"Decimal": [0, 1, 2, 3, 4, 5],
"Octal": ["001", "002", "003", "004", "004", "005"],
"Key": ["NUL", "Ctrl-A", "Ctrl-B", "Ctrl-C", "Ctrl-D", "Ctrl-E"],
}
df = pd.DataFrame(data)
df = pd.DataFrame(data, columns=["Decimal", "Octal", "Key"], index=df["Code"])
df
[15]:
Decimal | Octal | Key | |
---|---|---|---|
Code | |||
U+0000 | 0 | 001 | NUL |
U+0001 | 1 | 002 | Ctrl-A |
U+0002 | 2 | 003 | Ctrl-B |
U+0003 | 3 | 004 | Ctrl-C |
U+0004 | 4 | 004 | Ctrl-D |
U+0005 | 5 | 005 | Ctrl-E |
[16]:
df["Key"]
[16]:
Code
U+0000 NUL
U+0001 Ctrl-A
U+0002 Ctrl-B
U+0003 Ctrl-C
U+0004 Ctrl-D
U+0005 Ctrl-E
Name: Key, dtype: object
[17]:
df[["Decimal", "Key"]]
[17]:
Decimal | Key | |
---|---|---|
Code | ||
U+0000 | 0 | NUL |
U+0001 | 1 | Ctrl-A |
U+0002 | 2 | Ctrl-B |
U+0003 | 3 | Ctrl-C |
U+0004 | 4 | Ctrl-D |
U+0005 | 5 | Ctrl-E |
[18]:
df[:2]
[18]:
Decimal | Octal | Key | |
---|---|---|---|
Code | |||
U+0000 | 0 | 001 | NUL |
U+0001 | 1 | 002 | Ctrl-A |
[19]:
df[df["Decimal"] > 2]
[19]:
Decimal | Octal | Key | |
---|---|---|---|
Code | |||
U+0003 | 3 | 004 | Ctrl-C |
U+0004 | 4 | 004 | Ctrl-D |
U+0005 | 5 | 005 | Ctrl-E |
Die Zeilenauswahlsyntax df[:2]
wird aus Gründen der Bequemlichkeit bereitgestellt. Durch die Übergabe eines einzelnen Elements oder einer Liste an den []
-Operator werden Spalten ausgewählt.
Ein weiterer Anwendungsfall ist die Indizierung mit einem booleschen DataFrame, der beispielsweise durch einen Skalarvergleich erzeugt wird:
[20]:
df["Decimal"] > 2
[20]:
Code
U+0000 False
U+0001 False
U+0002 False
U+0003 True
U+0004 True
U+0005 True
Name: Decimal, dtype: bool
[21]:
df[df["Decimal"] > 2] = "NA"
df
[21]:
Decimal | Octal | Key | |
---|---|---|---|
Code | |||
U+0000 | 0 | 001 | NUL |
U+0001 | 1 | 002 | Ctrl-A |
U+0002 | 2 | 003 | Ctrl-B |
U+0003 | NA | NA | NA |
U+0004 | NA | NA | NA |
U+0005 | NA | NA | NA |
Wie Series verfügt auch DataFrame über spezielle Operatoren loc
und iloc
für label-basierte bzw. ganzzahlige Indizierung. Da DataFrame zweidimensional ist, könnt ihr eine Teilmenge der Zeilen und Spalten mit NumPy-ähnlicher Notation auswählen, indem ihr entweder Achsenbeschriftungen (loc
) oder Ganzzahlen (iloc
) verwendet.
[22]:
df.loc["U+0002", ["Decimal", "Key"]]
[22]:
Decimal 2
Key Ctrl-B
Name: U+0002, dtype: object
[23]:
df.iloc[[2], [1, 2]]
[23]:
Octal | Key | |
---|---|---|
Code | ||
U+0002 | 003 | Ctrl-B |
[24]:
df.iloc[[0, 1], [1, 2]]
[24]:
Octal | Key | |
---|---|---|
Code | ||
U+0000 | 001 | NUL |
U+0001 | 002 | Ctrl-A |
Beide Indizierungsfunktionen arbeiten mit Slices zusätzlich zu einzelnen Label oder Listen von Label:
[25]:
df.loc[:"U+0003", "Key"]
[25]:
Code
U+0000 NUL
U+0001 Ctrl-A
U+0002 Ctrl-B
U+0003 NA
Name: Key, dtype: object
[26]:
df.iloc[:3, :3]
[26]:
Decimal | Octal | Key | |
---|---|---|---|
Code | |||
U+0000 | 0 | 001 | NUL |
U+0001 | 1 | 002 | Ctrl-A |
U+0002 | 2 | 003 | Ctrl-B |
Es gibt also viele Möglichkeiten, die in einem pandas-Objekt enthaltenen Daten auszuwählen und neu anzuordnen. Im folgenden stelle ich für DataFrames eine kurze Zusammenfassung der meisten dieser Möglichkeiten zusammen:
Typ |
Hinweis |
---|---|
|
wählt eine einzelne Spalte oder eine Folge von Spalten aus dem DataFrame aus |
|
wählt eine einzelne Zeile oder eine Teilmenge von Zeilen aus dem DataFrame nach Label aus |
|
wählt eine einzelne Spalte oder eine Teilmenge von Spalten nach dem Label aus |
|
wählt sowohl Zeilen als auch Spalten nach dem Label aus |
|
wählt eine einzelne Zeile oder eine Teilmenge von Zeilen aus dem DataFrame anhand der Ganzzahlposition aus |
|
Wählt eine einzelne Spalte oder eine Teilmenge von Spalten anhand einer ganzzahligen Position aus |
|
wählt einen Einzelwert nach Zeilen- und Spaltenbezeichnung aus |
|
wählt einen Einzelwert nach Zeilen- und Spaltenposition (Ganzzahlen) aus |
|
wählt Zeilen oder Spalten nach Labels aus |
|
veraltet seit Version 0.21.0: Verwendet stattdessen |