Pandas iloc vs ix vs loc erklärung?

Kann jemand erklären, wie diese drei Methoden des Schneidens anders sind?
Ich habe die Docs gesehen , und ich habe diese Antworten gesehen , aber ich finde mich immer noch nicht in der Lage zu erklären, wie die drei anders sind. Für mich, sie scheinen austauschbar in großen Teil, weil sie auf der unteren Ebenen des Schneidens sind.

Zum Beispiel sagen wir, wir wollen die ersten fünf Zeilen eines DataFrame . Wie ist das alles?

 df.loc[:5] df.ix[:5] df.iloc[:5] 

Kann jemand drei Fälle vorstellen, wo die Unterscheidung in den Verwendungen klarer ist?

  • Wie kann man ein Pandas-Dataframe mit einem modifizierten Index pflegen?
  • Pandas: Konvertieren Sie Dataframe in Listen von Listen
  • Füge Tausende Trennzeichen mit Komma bei IPython.display HTML hinzu
  • Konvertieren Sie N durch N Dataframe zu 3 Spalte Dataframe
  • Neue Spalte in Pandas DataFrame Python hinzufügen
  • Resampling Dataframe nach Stunden und Datum
  • 2 Solutions collect form web for “Pandas iloc vs ix vs loc erklärung?”

    Anmerkung: In Pandas Version 0.20.0 und höher ist ix veraltet und die Verwendung von loc und iloc wird stattdessen gefördert. Ich habe die Teile dieser Antwort verlassen, die ix intakt als Referenz für Benutzer früherer Versionen von Pandas beschreiben. Nachfolgend wurden Beispiele für Alternativen zu ix hinzugefügt .


    Zuerst eine Wiederholung:

    • loc arbeitet auf Labels im Index.
    • iloc arbeitet an den Positionen im Index (also braucht es nur ganze Zahlen).
    • ix versucht gewöhnlich, sich wie loc zu benehmen, aber fällt zurück, um sich wie iloc zu benehmen, wenn das Label nicht im Index ist.

    Es ist wichtig, einige Feinheiten zu beachten, die ix leicht heikel machen können:

    • Wenn der Index vom Integer-Typ ist, wird ix nur die beschriftungsbasierte Indizierung verwenden und nicht auf die positionsbasierte Indizierung zurückgreifen. Wenn sich das Etikett nicht im Index befindet, wird ein Fehler aufgetreten.

    • Wenn der Index nicht nur ganze Zahlen enthält, dann erhält er eine ganzzahlige, sondern wird sofort eine positionsbasierte Indizierung verwenden, anstatt eine beschriftungsbasierte Indizierung. Wenn aber ix ein anderer Typ (zB ein String) gegeben wird, kann er die beschriftungsbasierte Indizierung verwenden.


    Um die Unterschiede zwischen den drei Methoden zu veranschaulichen, betrachte die folgende Serie:

     >>> s = pd.Series(np.nan, index=[49,48,47,46,45, 1, 2, 3, 4, 5]) >>> s 49 NaN 48 NaN 47 NaN 46 NaN 45 NaN 1 NaN 2 NaN 3 NaN 4 NaN 5 NaN 

    Dann gibt es die ersten 3 Zeilen zurück (da sie die Position s.loc[:3] ) und s.loc[:3] gibt die ersten 8 Zeilen zurück (da sie die Etiketten ansieht):

     >>> s.iloc[:3] # slice the first three rows 49 NaN 48 NaN 47 NaN >>> s.loc[:3] # slice up to and including label 3 49 NaN 48 NaN 47 NaN 46 NaN 45 NaN 1 NaN 2 NaN 3 NaN >>> s.ix[:3] # the integer is in the index so s.ix[:3] works like loc 49 NaN 48 NaN 47 NaN 46 NaN 45 NaN 1 NaN 2 NaN 3 NaN 

    Hinweis s.ix[:3] gibt dieselbe Serie wie s.loc[:3] da sie nach dem Label zuerst sucht, anstatt nach Position zu gehen (und der Index ist ganzzahlig).

    Was, wenn wir mit einem Integer-Label versuchen, das nicht im Index ist (zB 6 )?

    Hier s.iloc[:6] gibt die ersten 6 Reihen der Serie wie erwartet zurück. Allerdings hebt s.loc[:6] einen KeyError an, da 6 nicht im Index ist.

     >>> s.iloc[:6] 49 NaN 48 NaN 47 NaN 46 NaN 45 NaN 1 NaN >>> s.loc[:6] KeyError: 6 >>> s.ix[:6] KeyError: 6 

    Wie bei den oben s.ix[:6] Feinheiten, s.ix[:6] hebt nun ein KeyError auf, weil es versucht, wie loc zu arbeiten, aber keine 6 im Index finden kann. Weil unser Index von ganzzahliger Art ist, fällt es nicht zurück, sich wie iloc zu benehmen.

    Wenn aber unser Index von gemischtem Typ war, da eine Ganzzahl ix sich wie iloc sofort verhalten iloc anstatt einen KeyError anzuheben:

     >>> s2 = pd.Series(np.nan, index=['a','b','c','d','e', 1, 2, 3, 4, 5]) >>> s2.index.is_mixed() # index is mix of types True >>> s2.ix[:6] # behaves like iloc given integer a NaN b NaN c NaN d NaN e NaN 1 NaN 

    Denken Sie daran, dass ix noch Nicht-Integer akzeptieren und sich wie loc verhalten kann:

     >>> s2.ix[:'c'] # behaves like loc given non-integer a NaN b NaN c NaN 

    Als allgemeine Ratschläge, wenn Sie nur Indizierung mit Etiketten oder nur Indizierung mit Integer-Positionen, Stick mit loc oder iloc , um unerwartete Ergebnisse zu vermeiden – versuchen Sie nicht verwenden ix .


    Kombination von standortbasierter und etikettbasierter Indizierung

    Manchmal, wenn ein DataFrame gegeben wird, möchten Sie Etiketten- und Positionsindizierungsmethoden für die Zeilen und Spalten mischen.

    Betrachten Sie zum Beispiel den folgenden DataFrame. Wie am besten, um die Zeilen bis hin zu 'c' zu schneiden und die ersten vier Spalten zu nehmen?

     >>> df = pd.DataFrame(np.nan, index=list('abcde'), columns=['x','y','z', 8, 9]) >>> df xyz 8 9 a NaN NaN NaN NaN NaN b NaN NaN NaN NaN NaN c NaN NaN NaN NaN NaN d NaN NaN NaN NaN NaN e NaN NaN NaN NaN NaN 

    In früheren Versionen von Pandas (vor 0,20.0) kannst du das ganz ordentlich machen – wir können die Zeilen durch Etikett und die Spalten nach Position schneiden (beachten Sie, dass für die Spalten ix standardmäßig auf positionbasiertes Slicing seit dem Label 4 steht Kein Spaltenname):

     >>> df.ix[:'c', :4] xyz 8 a NaN NaN NaN NaN b NaN NaN NaN NaN c NaN NaN NaN NaN 

    In späteren Versionen von Pandas können wir dieses Ergebnis mit iloc und der Hilfe einer anderen Methode erreichen:

     >>> df.iloc[:df.index.get_loc('c') + 1, :4] xyz 8 a NaN NaN NaN NaN b NaN NaN NaN NaN c NaN NaN NaN NaN 

    get_loc() ist eine Indexmethode, die bedeutet, "die Position des Labels in diesem Index zu erhalten". Beachten Sie, dass, da das Slicing mit iloc exklusiv seinen Endpunkt ist, müssen wir 1 zu diesem Wert hinzufügen, wenn wir auch die '' '' '' ''

    Es gibt weitere Beispiele in der Pandas-Dokumentation hier .

    iloc arbeitet auf einer ganzzahligen Positionierung. Also egal was deine Zeilenetiketten sind, kannst du immer zB die erste Zeile bekommen

     df.iloc[0] 

    Oder die letzten fünf Zeilen

     df.iloc[-5:] 

    Sie können es auch auf den Spalten verwenden. Dies ruft die 3. Spalte ab:

     df.iloc[:, 2] # the : in the first position indicates all rows 

    Sie können sie kombinieren, um Kreuzungen von Zeilen und Spalten zu erhalten:

     df.iloc[:3, :3] # The upper-left 3 X 3 entries (assuming df has 3+ rows and columns) 

    Auf der anderen Seite, verwenden Sie benannte Indizes. Lassen Sie uns einen Datenrahmen mit Strings als Zeilen- und Spaltenbeschriftungen einrichten:

     df = pd.DataFrame(index=['a', 'b', 'c'], columns=['time', 'date', 'name']) 

    Dann können wir die erste Reihe bekommen

     df.loc['a'] # equivalent to df.iloc[0] 

    Und die zweiten beiden Zeilen der Spalte 'date'

     df.loc['b':, 'date'] # equivalent to df.iloc[1:, 1] 

    und so weiter. Nun ist es wahrscheinlich wert, dass die Standard-Zeilen- und Spaltenindizes für ein DataFrame ganzzahlige Zahlen von 0 sind und in diesem Fall iloc und loc auf dieselbe Weise funktionieren würden. Deshalb sind deine drei Beispiele gleichwertig. Wenn du einen nicht-numerischen Index wie zB Strings oder datetimes hast, würde df.loc[:5] einen Fehler df.loc[:5] .

    Außerdem kannst du den Spaltenabruf nur unter Verwendung des __getitem__ :

     df['time'] # equivalent to df.loc[:, 'time'] 

    Nehmen wir an, dass Sie die Position und die Namensindizierung mischen möchten, dh die Indexierung mit Namen auf Zeilen und Positionen auf Spalten (um zu klären, ich meine aus unserem Datenrahmen aus, anstatt ein Datenrahmen mit Strings im Zeilenindex und Integer zu erstellen Der Spaltenindex). Hier kommt .ix kommt .ix :

     df.ix[:2, 'time'] # the first two rows of the 'time' column 

    EDIT: Ich denke, es ist auch erwähnenswert, dass man auch boolesche Vektoren an die loc Methode weitergeben kann. Beispielsweise:

      b = [True, False, True] df.loc[b] 

    Wird die 1. und 3. Reihe von df . Dies ist gleichbedeutend mit df[b] zur Auswahl, kann aber auch für die Zuordnung über boolesche Vektoren verwendet werden:

     df.loc[b, 'name'] = 'Mary', 'John' 
    Python ist die beste Programmiersprache der Welt.