
Sie at, iat, loc oder iloc, um auf Daten an beliebigen Stellen in pandas.DataFrame zugreifen und Werte abzurufen/einzustellen. Schreiben Sie at[], nicht at().
Die Unterschiede sind wie folgt:
- So geben Sie die Position an
- at, loc : Zeilen-/Spaltenbezeichnung (Name)
- iat, iloc : Zeilen-/Spaltennummer (Ganzzahlposition)
- Daten, die SIE abrufen/einstellen können
- at, iat : Einzelwert
- loc, iloc : Einzelne oder mehrere Werte
Dieser Artikel hat folgenden Inhalt.
- at, iat : Greifen Sie auf einen einzelnen Wert zu und erhalten/setzen Sie ihn
- loc, iloc : Greifen Sie auf Einzelne oder mehrere Werte zu und erhalten/setzen Sie sie
- Greifen Sie auf einen einzelnen Wert zu
- Greifen Sie auf mehrere Werte zu
- Greifen Sie auf Zeilen und Spalten zu
- Maske durch boolesches Array und pandas.Series
- Doppelte Zeilen-/Spaltenbeschriftungen
- Geben SIE nach Nummer und Beschriftung an
- Implizite Typkonvertierung beim Auswählen einer Zeile als pandas.Series
Sie können auch Zeilen und Spalten von pandas.DataFrame und Elemente von pandas.Series auswählen, indem Sie [] indizieren.
Beachten Sie, dass get_value() und ix[], die zuvor bereitgestellt wurden, in Version 1.0 entfernt wurden.
Verwenden Sie die folgende CSV-Datei im Beispielcode.
import pandas as pd
print(pd.__version__)
# 1.4.1
df = pd.read_csv('data/src/sample_pandas_normal.csv', index_col=0)
print(df)
# age state point
# name
# Alice 24 NY 64
# Bob 42 CA 92
# Charlie 18 CA 70
# Dave 68 TX 70
# Ellen 24 CA 88
# Frank 30 NY 57
at, iat : Greifen Sie auf einen einzelnen Wert zu und erhalten/setzen Sie ihn
Sie können die Position durch die Zeilen-/Spaltenbezeichnung (Name) in at angeben. Zusätzlich zum Abrufen von Daten können Sie auch einen neuen Wert festlegen (zuweisen).
print(df.at['Bob', 'age'])
# 42
df.at['Bob', 'age'] = 60
print(df.at['Bob', 'age'])
# 60
Sie können die Position durch Zeilen-/Spaltennummer (0-basierte Indizierung) in iat angeben.
print(df.iat[1, 0])
# 60
df.iat[1, 0] = 42
print(df.iat[1, 0])
# 42
loc, iloc : Greifen Sie auf Einzelne oder mehrere Werte zu und erhalten/setzen Sie sie
loc und iloc können nicht nur auf einen einzelnen Wert zugreifen, sondern auch auf mehrere Werte.
Sie können die Position durch Zeilen-/Spaltenbeschriftung für loc und durch Zeilen-/Spaltennummer für iloc angeben.
Greifen Sie auf einen einzelnen Wert zu
Auf einen einzelnen Wert können Sie sowohl mit loc und iloc als auch mit at und iat zugreifen. Allerdings sind at und iat schneller als loc und iloc.
print(df.loc['Bob', 'age'])
# 42
print(df.iloc[1, 0])
# 42
df.loc['Bob', 'age'] = 60
print(df.loc['Bob', 'age'])
# 60
df.iloc[1, 0] = 42
print(df.iloc[1, 0])
# 42
Greifen Sie auf mehrere Werte zu
Um auf mehrere Werte zuzugreifen, geben Sie eine Gruppe von Daten mit einer Liste [a, b, c, …] und Slice start:stop:step an. pandas.Series oder pandas.DataFrame wird zurückgegeben.
Siehe den folgenden Artikel für die klassische Verwendung von Slices. Sie können den Schritt weglassen.
Beachten Sie, dass bei der Angabe mit dem Slice start:stop:step der Wert von stop in loc (Zeilen-/Spaltenbeschriftung) enthalten ist. Der Wert von stop ist nicht wie normale Slices in iloc (Zeilen-/Spaltennummer) enthalten.
Bei Angabe durch Eine Liste Werden Zeilen und Spalten in der Reihenfolge der angegebenen Liste angeordnet.
print(df.loc['Bob':'Dave', 'age'])
print(type(df.loc['Bob':'Dave', 'age']))
# name
# Bob 42
# Charlie 18
# Dave 68
# Name: age, dtype: int64
# <class 'pandas.core.series.Series'>
print(df.loc[:'Dave', ['point', 'age']])
print(type(df.loc[:'Dave', ['point', 'age']]))
# point age
# name
# Alice 64 24
# Bob 92 42
# Charlie 70 18
# Dave 70 68
# <class 'pandas.core.frame.DataFrame'>
print(df.iloc[:3, [2, 0]])
print(type(df.iloc[:3, [2, 0]]))
# point age
# name
# Alice 64 24
# Bob 92 42
# Charlie 70 18
# <class 'pandas.core.frame.DataFrame'>
Case can you ungerade/gerade Zeilen extrahieren, indes you step angeben.
print(df.iloc[::2, 0])
print(type(df.iloc[::2, 0]))
# name
# Alice 24
# Charlie 18
# Ellen 24
# Name: age, dtype: int64
# <class 'pandas.core.series.Series'>
print(df.iloc[1::2, 0])
print(type(df.iloc[1::2, 0]))
# name
# Bob 42
# Dave 68
# Frank 30
# Name: age, dtype: int64
# <class 'pandas.core.series.Series'>
Sie können mehrere Werte gleichzeitig zuweisen.
df.loc['Bob':'Dave', 'age'] = 0
print(df.loc['Bob':'Dave', 'age'])
# name
# Bob 0
# Charlie 0
# Dave 0
# Name: age, dtype: int64
df.loc['Bob':'Dave', 'age'] = [20, 30, 40]
print(df.loc['Bob':'Dave', 'age'])
# name
# Bob 20
# Charlie 30
# Dave 40
# Name: age, dtype: int64
Greifen Sie auf Zeilen und Spalten zu
Sie können Zeilen und Spalten mit df[] auswählen. Zeilen und Spalten werden wie folgt angegeben.
- Zeilen: Segment der Zeilenbeschriftung/-nummer
- Spalten: Spaltenbezeichnung oder Liste von Spaltenbezeichnungen
print(df['Bob':'Ellen'])
# age state point
# name
# Bob 20 CA 92
# Charlie 30 CA 70
# Dave 40 TX 70
# Ellen 24 CA 88
print(df[:3])
# age state point
# name
# Alice 24 NY 64
# Bob 20 CA 92
# Charlie 30 CA 70
print(df['age'])
# name
# Alice 24
# Bob 20
# Charlie 30
# Dave 40
# Ellen 24
# Frank 30
# Name: age, dtype: int64
print(df[['age', 'point']])
# age point
# name
# Alice 24 64
# Bob 20 92
# Charlie 30 70
# Dave 40 70
# Ellen 24 88
# Frank 30 57
Mit loc und iloc can SIE Zeilen und Spalten auf verschiedene Weise angeben.
Wenn SIE keine Spalten mit loc oder iloc angeben, werden Zeilen ausgewählt. Es ist möglich, nach Zeilenbezeichnung/-nummer oder einer Liste davon anzugeben.
print(df.loc['Bob'])
print(type(df.loc['Bob']))
# age 20
# state CA
# point 92
# Name: Bob, dtype: object
# <class 'pandas.core.series.Series'>
print(df.iloc[[4, 1]])
print(type(df.iloc[[4, 1]]))
# age state point
# name
# Ellen 24 CA 88
# Bob 20 CA 92
# <class 'pandas.core.frame.DataFrame'>
Sie können Spalten mit loc und iloc auswählen, indem Sie Zeilen als : angeben. Es ist möglich, nach Slice zu spezifizieren.
print(df.loc[:, 'age':'point'])
print(type(df.loc[:, 'age':'point']))
# age state point
# name
# Alice 24 NY 64
# Bob 20 CA 92
# Charlie 30 CA 70
# Dave 40 TX 70
# Ellen 24 CA 88
# Frank 30 NY 57
# <class 'pandas.core.frame.DataFrame'>
print(df.iloc[:, [0, 2]])
print(type(df.iloc[:, [0, 2]]))
# age point
# name
# Alice 24 64
# Bob 20 92
# Charlie 30 70
# Dave 40 70
# Ellen 24 88
# Frank 30 57
# <class 'pandas.core.frame.DataFrame'>
Bei der Auswahl Einer einzelnen Zeile oder Spalte WIRD pandas.Series zurückgegeben, wenn es durch einen Skalarwert angegeben WIRD, und pandas.DataFrame wird zurückgegeben, wenn es durch ein Segment oder eine Liste angegeben WIRD.
print(df.loc['Bob'])
print(type(df.loc['Bob']))
# age 20
# state CA
# point 92
# Name: Bob, dtype: object
# <class 'pandas.core.series.Series'>
print(df.loc['Bob':'Bob'])
print(type(df.loc['Bob':'Bob']))
# age state point
# name
# Bob 20 CA 92
# <class 'pandas.core.frame.DataFrame'>
print(df.loc[['Bob']])
print(type(df.loc[['Bob']]))
# age state point
# name
# Bob 20 CA 92
# <class 'pandas.core.frame.DataFrame'>
print(df.iloc[:, 1])
print(type(df.iloc[:, 1]))
# name
# Alice NY
# Bob CA
# Charlie CA
# Dave TX
# Ellen CA
# Frank NY
# Name: state, dtype: object
# <class 'pandas.core.series.Series'>
print(df.iloc[:, 1:2])
print(type(df.iloc[:, 1:2]))
# state
# name
# Alice NY
# Bob CA
# Charlie CA
# Dave TX
# Ellen CA
# Frank NY
# <class 'pandas.core.frame.DataFrame'>
print(df.iloc[:, [1]])
print(type(df.iloc[:, [1]]))
# state
# name
# Alice NY
# Bob CA
# Charlie CA
# Dave TX
# Ellen CA
# Frank NY
# <class 'pandas.core.frame.DataFrame'>
Beachten Sie, dass sterben Auswahl Einer Zeile als pandas.Series zu Einer impliziten Typkonvertierung führen kann. Siehe unten für Einzelheiten.
Maske durch boolesches Array und pandas.Series
Sie können Daten mit einem booleschen Array (Liste, numpy.ndarray usw.) maskieren. Im Beispiel WIRD das boolesche Array für Zeilen angegeben, es can aber auch für Spalten angegeben Werden.
l_bool = [True, False, False, True, False, True]
print(df.loc[l_bool, ['age', 'point']])
# age point
# name
# Alice 24 64
# Dave 40 70
# Frank 30 57
print(df.iloc[l_bool, [0, 2]])
# age point
# name
# Alice 24 64
# Dave 40 70
# Frank 30 57
Wenn die Anzahl der Elemente nicht gefunden wird, wird ein Fehler ausgelöst.
l_bool_wrong = [True, False, False]
# print(df.loc[l_bool_wrong, ['age', 'point']])
# IndexError: Boolean index has wrong length: 3 instead of 6
Sie können auch einen booleschen Wert pandas.Series in loc angeben. Die Daten werden basierend auf dem Etikett maskiert, nicht auf der Grundlage der Reihenfolge.
s_bool = pd.Series([True, False, True, True, False, False],
index=reversed(df.index))
print(s_bool)
# Frank True
# Ellen False
# Dave True
# Charlie True
# Bob False
# Alice False
# dtype: bool
print(df.loc[s_bool, ['age', 'point']])
# age point
# name
# Charlie 30 70
# Dave 40 70
# Frank 30 57
Sie können pandas.Series nicht in iloc angeben.
# print(df.iloc[s_bool, [0, 2]])
# ValueError: Location based indexing can only have [integer,
# integer slice (START point is INCLUDED, END point is EXCLUDED), listlike of integers, boolean array] types
Selbst in loc WIRD ein Fehler ausgelöst, wenn die Labels nicht übereinstimmen.
s_bool_wrong = pd.Series([True, False, False], index=['Frank', 'Ellen', 'Dave'])
print(s_bool_wrong)
# Frank True
# Ellen False
# Dave False
# dtype: bool
# print(df.loc[s_bool_wrong, ['age', 'point']])
# IndexingError: Unalignable boolean Series provided as indexer
# (index of the boolean Series and of the indexed object do not match).
s_bool_wrong2 = pd.Series([True, False, False, True, False, True],
index=['A', 'B', 'C', 'D', 'E', 'F'])
print(s_bool_wrong2)
# A True
# B False
# C False
# D True
# E False
# F True
# dtype: bool
# print(df.loc[s_bool_wrong2, ['age', 'point']])
# IndexingError: Unalignable boolean Series provided as indexer
# (index of the boolean Series and of the indexed object do not match).
Doppelte Zeilen-/Spaltenbeschriftungen
Zeilenbeschriftungsindex und Spaltenbeschriftungsspalten können doppelte Werte enthalten.
Nehmen wir als Beispiel pandas.DataFrame mit doppelten Zeilen- und Spaltenbeschriftungen.
df_duplicated = pd.read_csv('data/src/sample_pandas_normal.csv', index_col=2)
df_duplicated.columns = ['name', 'age', 'age']
print(df_duplicated)
# name age age
# state
# NY Alice 24 64
# CA Bob 42 92
# CA Charlie 18 70
# TX Dave 68 70
# CA Ellen 24 88
# NY Frank 30 57
Für at und loc werden durch Angabe doppelter Beschriftungen die entsprechenden Mehrfachelemente ausgewählt.
print(df_duplicated.at['NY', 'age'])
print(type(df_duplicated.at['NY', 'age']))
# age age
# state
# NY 24 64
# NY 30 57
# <class 'pandas.core.frame.DataFrame'>
print(df_duplicated.loc['NY', 'age'])
print(type(df_duplicated.loc['NY', 'age']))
# age age
# state
# NY 24 64
# NY 30 57
# <class 'pandas.core.frame.DataFrame'>
Bei der Angabe nach Zeilen-/Spaltennummer mit iat und iloc spielt es keine Rolle, ob Labels dupliziert werden.
print(df_duplicated.iat[0, 1])
# 24
print(df_duplicated.iloc[:2, [0, 1]])
# name age
# state
# NY Alice 24
# CA Bob 42
Wenn es keinen triftigen Grund gibt, ist es besser, eindeutige Werte für Zeilen- und Spaltennamen zu verwenden.
Sie können mit index.is_unique und column.is_unique überprüfen, ob Zeilen- und Spaltenbeschriftungen eindeutig (nicht dupliziert) sind.
print(df_duplicated.index.is_unique)
# False
print(df_duplicated.columns.is_unique)
# False
Im following Artikel erfahren Sie, wie Sie Zeilen- und Spaltenbeschriftungen umbenennen.
Geben SIE nach Nummer und Beschriftung an
Wenn SIE die Position durch Nummer und Bezeichnung angeben möchten, können Sie die Attribute at oder loc und index oder column verwenden.
Sie können ihre Zeilen-/Spaltenbezeichnungen aus der Zeilen-/Spaltennummer mit den Index- und Spaltenattributen erhalten.
print(df)
# age state point
# name
# Alice 24 NY 64
# Bob 20 CA 92
# Charlie 30 CA 70
# Dave 40 TX 70
# Ellen 24 CA 88
# Frank 30 NY 57
print(df.index[2])
# Charlie
print(df.columns[1])
# state
Sie können Slices und Listen angeben.
print(df.index[2:4])
# Index(['Charlie', 'Dave'], dtype="object", name="name")
print(df.columns[[0, 2]])
# Index(['age', 'point'], dtype="object")
Mit diesem und at oder loc can SIE den Standort durch Nummer und Bezeichnung angeben.
print(df.at[df.index[2], 'age'])
# 30
print(df.loc[['Alice', 'Dave'], df.columns[[0, 2]]])
# age point
# name
# Alice 24 64
# Dave 40 70
Es ist möglich, wie folgt wiederholt [], loc oder iloc zu schreiben, aber dies WIRD als verkettete Indizierung bezeichnet und ist eine Ursache für SettingWithCopyWarning.
Dies ist kein Problem, wenn SIE nur Daten abrufen und prüfen, aber beachten Sie, dass das Zuweisen neuer Werte zu unerwarteten Ergebnissen führen kann.
print(df['age'][2])
# 30
print(df.loc[['Alice', 'Dave']].iloc[:, [0, 2]])
# age point
# name
# Alice 24 64
# Dave 40 70
Implizite Typkonvertierung beim Auswählen einer Zeile als pandas.Series
Bei der Auswahl einer Zeile als pandas.Series mit loc oder iloc kann der Elementtyp implizit konvertiert werden, wenn der Datentyp dtype jeder Spalte im ursprünglichen pandas.DataFrame unterschiedlich ist.
Verwenden Sie einen pandas.DataFrame mit Spalten von Ganzzahlen int und Gleitkommazahlen float.
df_mix = pd.DataFrame({'col_int': [0, 1, 2], 'col_float': [0.1, 0.2, 0.3]}, index=['A', 'B', 'C'])
print(df_mix)
# col_int col_float
# A 0 0.1
# B 1 0.2
# C 2 0.3
print(df_mix.dtypes)
# col_int int64
# col_float float64
# dtype: object
Wenn Sie eine Zeile als pandas.Series in loc oder iloc erhalten, ist ihr Datentyp Float. Elemente in int-Spalten werden in Float konvertiert.
print(df_mix.loc['B'])
# col_int 1.0
# col_float 0.2
# Name: B, dtype: float64
print(type(df_mix.loc['B']))
# <class 'pandas.core.series.Series'>
Wenn Sie Folgendes schreiben, wird ein in Float konvertiertes Element von pandas.Series zurückgegeben.
print(df_mix.loc['B']['col_int'])
# 1.0
print(type(df_mix.loc['B']['col_int']))
# <class 'numpy.float64'>
Sie können Elemente des ursprünglichen Typs mit at oder iat erhalten.
print(df_mix.at['B', 'col_int'])
# 1
print(type(df_mix.at['B', 'col_int']))
# <class 'numpy.int64'>
Wenn eine Zeile von einer Liste oder einem Slice in loc oder iloc ausgewählt WIRD, WIRD pandas.DataFrame anstelle von pandas.Series zurückgegeben. In diesem Fall bleibt der ursprüngliche Datentyp erhalten.
print(df_mix.loc[['B']])
# col_int col_float
# B 1 0.2
print(type(df_mix.loc[['B']]))
# <class 'pandas.core.frame.DataFrame'>
print(df_mix.loc[['B']].dtypes)
# col_int int64
# col_float float64
# dtype: object