Skip to content

Pandas: Holen/Setzen von Elementwerten mit at, iat, loc, iloc

Python

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