Auswahl mehrerer Spalten in ein pandas dataframe

Ich habe Daten in verschiedenen Spalten, aber ich weiß nicht, wie um Sie zu extrahieren, um es zu speichern in einer anderen variable.

index  a   b   c
1      2   3   4
2      3   4   5

Wie wähle ich 'a', 'b' und speichern Sie es auf df1?

Versuchte ich

df1 = df['a':'b']
df1 = df.ix[:, 'a':'b']

Keiner scheint zu arbeiten.

Sie wollen nie zu verwenden .ix wie es ist mehrdeutig. Verwenden .iloc oder .loc wenn Sie müssen.
Gibt es eine Möglichkeit es getan werden kann, ohne Bezugnahme auf die header-Namen? wie in R, kann ich es so machen: > csvtable_imp_1 <- csvtable_imp[0:6] und es wählt die delta-Betrag der ersten Spalten zwischen 0 und 6. Alle die ich tun musste, ist das Lesen der csv-Tabelle als Trennzeichen mit der readr lib.
Ich habe gearbeitet, ein bisschen mehr mit ihm. Etwas gefunden, das funktionierte wie gewollt. Standardmäßig wählen Sie die Nummern der char und nicht Spalten. infile_1 = largefile_stay.ix[:,0:6]
Für diejenigen, stolpern auf dieser spät ix ist jetzt veraltet. Pandas empfiehlt die Verwendung entweder: loc (label-based indexing) oder iloc (positions-basierte Indizierung).
Pandas: Ersatz für .ix

InformationsquelleAutor user1234440 | 2012-07-01

1389

Die Spalte mit Namen (strings) können nicht geschnitten werden, in der Weise, die Sie versucht haben.

Hier haben Sie ein paar Optionen. Wenn Sie wissen, aus dem Kontext die Variablen, die Sie wollen, zu schneiden, können Sie nur zurück, eine Ansicht, die nur die Spalten, indem eine Liste in der __getitem__ syntax (die []'s).
```
df1 = df[['a','b']]
```
Alternativ, wenn es darauf ankommt, zu indizieren Sie numerisch und nicht durch Ihren Namen (sagen dein code sollte automatisch tun, ohne zu wissen, die Namen der ersten zwei Spalten), können Sie dies tun, statt:
```
df1 = df.iloc[:,0:2] # Remember that Python does not slice inclusive of the ending index.
```
Darüber hinaus sollten Sie vertraut machen mit der Idee, einen Blick in ein Pandas Objekt vs. eine Kopie des Objekts. Die erste der oben genannten Methoden zurückkehren, eine neue Kopie im Arbeitsspeicher des gewünschten teilobjektes (die gewünschten slices).

Manchmal gibt es jedoch die Indizierung Konventionen Pandas, die dies nicht tun und stattdessen geben Sie eine neue variable, die nur bezieht sich auf den gleichen Speicherblock als sub-Objekt oder Scheibe in das ursprüngliche Objekt. Dies geschieht bei der zweiten Art der Indizierung, so dass Sie können es ändern, mit der copy() - Funktion, um eine regelmäßige kopieren. Wenn dies geschieht, ändern, was Sie denken, ist das geschnittene Objekt kann manchmal verändern Sie das ursprüngliche Objekt. Immer gut zu sein auf der Suche für diese.
```
df1 = df.iloc[0,0:2].copy() # To avoid the case where changing df1 also changes df
```
Verwenden iloc Sie müssen wissen, daß die Spalte Positionen (oder Indizes). Als Spalten-Positionen ändern können, statt hart zu codieren Indizes, die Sie verwenden können iloc zusammen mit get_loc Funktion columns Methode der dataframe-Objekt zum abrufen von Spalten-Indizes.
```
{df.columns.get_loc(c):c for idx, c in enumerate(df.columns)}
```
Jetzt können Sie dieses Wörterbuch, um Zugriff auf die Spalten über Namen und mit iloc.
- Hinweis: df[['a','b']] erzeugt eine Kopie
- Ja, das war implizit in meine Antwort. Die etwas über die Kopie wurde nur für die Nutzung ix[] wenn Sie lieber zu verwenden ix[] aus irgendeinem Grund.
- ix Indizes der Zeilen, nicht Spalten. Ich dachte, der OP wollte Spalten.
- ix akzeptiert Scheibe Argumente, so können Sie auch Spalten. Zum Beispiel df.ix[0:2, 0:2] bekommt der oberen linken 2x2-sub-array so wie es für ein NumPy matrix (je nach Spalte die Namen natürlich). Sie können sogar verwenden Sie das slice-syntax für string-Namen der Spalten, wie df.ix[0, 'Col1':'Col5']. Das bringt alle Spalten, die zufällig angeordnet werden, zwischen Col1 und Col5 im df.columns array. Es ist falsch zu sagen, dass ix Indizes der Zeilen. Das ist einfach in seiner einfachsten zu verwenden. Es unterstützt auch viel mehr indizieren als das. Also ix ist perfekt allgemein für diese Frage.
- was ist, wenn ich wollen, wählen Sie mehrere nicht aufeinanderfolgende Spalten, z.B. index_retain=c(1,3,9)? in R würde ich nur tun my_data_frame[,index_retain]
- Die entsprechende Dokumentation ist verwiesen. Die kurze Antwort ist die Verwendung der iloc Indizierung Helfer, wie my_data_frame.iloc[:, [1, 3, 9]] in deinem Beispiel. Beachten Sie, dass Python Indizierung ist null-basiert. Allgemein, obwohl, da ein DataFrame ist in der Regel soll eine relationale Datenstruktur mit keine implizite Sortierung der Spalten, ist es manchmal sicherer, schreiben Sie einfach Ihre eigene helper-Funktionen, die sich auf die Spalten name und entfernen Sie alle müssen auf Sie zugreifen, indem Sie die position.
- Zum Beispiel, wenn Sie instanziieren Sie ein DataFrame von einer dict, da dict ist grundsätzlich ungeordnet und die Reihenfolge der iterierten Elemente hängt von der (willkürlichen) Reihenfolge, in der Elemente, die gespeichert wurden, während der dict-Konstruktor, der dann von einer Ausführung des Programms zur nächsten werden in der Spalte Bestellung ändern konnte. Ähnliches kann passieren, wenn Sie serialisieren Sie die Daten beispielsweise in eine .csv-Datei und laden Sie dann aus der Datei in ein anderes Programm. Viele Male die Reihenfolge wird stabil sein, aber es ist der seltene, von wenigen Ausnahmefällen, wenn Sie angenommen positionelle Ordnung stabil war, doch es war nicht wirklich Probleme verursachen.
- Die schneiden in .ix() ist inklusive, wenn Sie verwenden Sie verwenden Sie Etiketten und die Etiketten selbst sind ganze zahlen, dann schneiden passiert, inklusive der für das Ende des index. Versuchen Sie den nachfolgenden snippet... df = pd.DataFrame(np.diejenigen([2,3])) print df df.ix[:, 1:2] = 0 print df
- df.ix[:,0:2] ergibt slice-inclusive? df.ix[:,0:2].Form #(2, 3)? Ich weiß ix ist veraltet
- Verwenden Sie nie .ix wieder. Wenn Sie möchten, um die Scheibe mit Ganzzahlen verwenden .iloc welche exklusiv von der letzten position, genau wie Python Listen.
- Die "Mittelwert" - Funktion vermeiden, die null-Werte? Ich meine, wenn ich hatte insgesamt 3 Spalten, und eine der Säulen war leer für eine bestimmte Zeile, dann die Mittelwert-Funktion sollte einfach nur wieder der Durchschnitt der beiden Spalten. Macht es das?
- Wie würden Sie die .iloc Methode, wenn wir auswählen müssen, um a und c Spalte, die nicht nebeneinander? Danke.
- ist veraltet.
- Alter thread, aber ersuchenden eine Klarstellung, da es wahrscheinlich nicht Wert, seine eigene Frage. Im Falle der Indizierung wie df[['a','b']] ist die Reihenfolge der Spalten garantiert zu bewahren (ich.e a dann b)? So zum Beispiel df.loc[0, ['a','b']].to_numpy() wäre es egal, in welcher Reihenfolge die Spalten waren.
InformationsquelleAutor ely
98

Vorausgesetzt, Ihre Spaltennamen (df.columns) sind ['index','a','b','c'], dann die Daten, die Sie wollen, ist in der
3rd & 4th Spalten. Wenn Sie nicht wissen, Ihre Namen, wenn Ihr Skript ausgeführt wird, können Sie dies tun
```
newdf = df[df.columns[2:4]] # Remember, Python is 0-offset! The "3rd" entry is at slot 2.
```
Als EMS weist in seine Antwort, df.ix Scheiben Spalten etwas prägnanter, aber das .columns slicing-Schnittstelle könnte natürlicher sein, denn es nutzt das Vanille 1-D python-Liste-Indizierung/slicing-syntax.

WARNEN: 'index' ist ein schlechter name für eine DataFrame Spalte. Dieselbe Bezeichnung wird auch verwendet für die real df.index Attribut, eine Index array. Damit Ihre Spalte zurückgegeben wird df['index'] und die Reale DataFrame index zurück df.index. Ein Index ist eine Besondere Art von Series optimiert für die lookup-Elemente " Werte. Für df.index es ist für das suchen nach Zeilen, die von Ihrem label. Dass df.columns - Attribut ist auch ein pd.Index array, um die Spalten und deren Beschriftungen.
- Wie ich bereits in meinem Kommentar oben .ix ist nicht nur für Zeilen. Es ist für den Allgemeinen Zweck schneiden, und kann verwendet werden für mehrdimensionale schneiden. Es ist im Grunde nur eine Schnittstelle zu NumPy üblichen __getitem__ syntax. Das heißt, Sie können leicht umwandeln eine Spalte-slicing-problem in einer Zeile-slicing-problem nur durch die Anwendung einer Transposition operation df.T. Dein Beispiel verwendet columns[1:3], das ist ein wenig irreführend. Das Ergebnis columns ist ein Series; vorsichtig sein, nicht nur behandeln es wie ein array. Auch, sollten Sie vielleicht ändern Sie es zu columns[2:3] zu passen mit Ihrer "3rd & 4." Kommentar.
- Meine [2:4] korrekt ist. Ihre [2:3] ist falsch. Und mit standard-python slicing-notation erzeugen einer Sequenz/Reihe ist nicht irreführend, IMO. Aber ich mag deine Umgehung des DataFrame Schnittstelle zum Zugriff auf die zugrunde liegenden numpy-array mit ix.
- Sie sind richtig in diesem Fall, aber der Punkt ich versuche zu machen ist, dass im Allgemeinen, slicing mit Etiketten in Pandas ist inclusive der Scheibe Endpunkt (oder zumindest war das Verhalten in den meisten früheren Pandas Versionen). Also, wenn Sie Sie abrufen df.columns und wollen die Scheibe label, dann hätten Sie verschiedene slice-Semantik, als wenn Sie die Scheibe integer-index-position. Ich auf jeden Fall nicht erklären, es auch in meinen vorherigen Kommentar aber.
- Ahh, jetzt sehe ich deinen Punkt. Ich vergaß, dass columns ist eine unveränderliche Serie und die get-Methode wurde überschrieben, um Etiketten verwenden als Indizes. Vielen Dank für die Zeit nehmen, zu klären.
- Hinweis: die Deprecation-Warnung: .ix ist veraltet. Daher macht dies Sinn: newdf = df[df.Spalten[2:4]]
InformationsquelleAutor hobs

Ab der version 0.11.0, Spalten werden kann in Scheiben geschnitten in der Art und Weise Sie versucht, mit dem .loc indexer:

df.loc[:, 'C':'E']

entspricht der

df[['C', 'D', 'E']]  # or df.loc[:, ['C', 'D', 'E']]

und gibt die Spalten C durch E.

Einer demo auf einer zufällig generierten DataFrame:

import pandas as pd
import numpy as np
np.random.seed(5)
df = pd.DataFrame(np.random.randint(100, size=(100, 6)), 
                  columns=list('ABCDEF'), 
                  index=['R{}'.format(i) for i in range(100)])
df.head()

Out: 
     A   B   C   D   E   F
R0  99  78  61  16  73   8
R1  62  27  30  80   7  76
R2  15  53  80  27  44  77
R3  75  65  47  30  84  86
R4  18   9  41  62   1  82

Erhalten Sie die Spalten von C bis E (beachten Sie, dass im Gegensatz zu integer-slicing, 'E' ist enthalten in den Spalten):

df.loc[:, 'C':'E']

Out: 
      C   D   E
R0   61  16  73
R1   30  80   7
R2   80  27  44
R3   47  30  84
R4   41  62   1
R5    5  58   0
...

Gleiche funktioniert auch für das auswählen von Zeilen basierend auf den Etiketten. Holen Sie sich die Zeilen 'R6' auf 'R10' aus diesen Spalten:

df.loc['R6':'R10', 'C':'E']

Out: 
      C   D   E
R6   51  27  31
R7   83  19  18
R8   11  67  65
R9   78  27  29
R10   7  16  94

.loc auch akzeptiert einen boolean-array, so dass Sie können wählen Sie die Spalten, deren entsprechende Eintrag im array ist True. Zum Beispiel df.columns.isin(list('BCD')) zurück array([False, True, True, True, False, False], dtype=bool) - True, wenn die Spalte name in der Liste ['B', 'C', 'D']; False, sonst.

df.loc[:, df.columns.isin(list('BCD'))]

Out: 
      B   C   D
R0   78  61  16
R1   27  30  80
R2   53  80  27
R3   65  47  30
R4    9  41  62
R5   78   5  58
...

InformationsquelleAutor ayhan

57
```
In [39]: df
Out[39]: 
   index  a  b  c
0      1  2  3  4
1      2  3  4  5

In [40]: df1 = df[['b', 'c']]

In [41]: df1
Out[41]: 
   b  c
0  3  4
1  4  5
```
- Was ist, wenn ich wollte, benennen Sie die Spalte, zum Beispiel so etwas wie: df[['b as foo', 'c as bar'] so dass die Ausgabe benennt Spalte b als foo und Spalte c als bar?
- df[['b', 'c']].rename(columns = {'b' : 'foo', 'c' : 'bar'})
InformationsquelleAutor Wes McKinney
49

Merke ich, diese Frage ist schon ziemlich alt, aber in der neuesten version von pandas gibt es einen einfachen Weg, genau das zu tun. Spalte mit Namen (strings) kann geschnitten werden, in welcher Weise auch immer Sie möchten.
```
columns = ['b', 'c']
df1 = pd.DataFrame(df, columns=columns)
```
- Dies kann nur bei der Erstellung. Die Frage ist, zu Fragen, wenn Sie bereits haben es in einem dataframe.
- es funktioniert mit einem vorhandenen dataframe
InformationsquelleAutor zerovector
20

Können Sie eine Liste der Spalten, die gelöscht werden, und wieder zurück das DataFrame mit nur die benötigten Spalten mit den drop() Funktion auf ein Pandas DataFrame.

Nur sagen
```
colsToDrop = ['a']
df.drop(colsToDrop, axis=1)
```
zurückkehren würde, ein DataFrame mit nur den Spalten b und c.

Den drop Methode ist dokumentiert hier.

InformationsquelleAutor Muthu Chithambara Jothi
17

Fand ich diese Methode sehr nützlich:
```
# iloc[row slicing, column slicing]
surveys_df.iloc [0:3, 1:4]
```
Mehr details finden Sie hier

InformationsquelleAutor Alvis
9

Mit pandas,

Witz Spaltennamen
```
dataframe[['column1','column2']]
```
mit iloc -, Spalten-index kann verwendet werden, wie
```
dataframe[:,[1,2]]
```
mit loc Spaltennamen können verwendet werden, wie
```
dataframe[:,['column1','column2']]
```
hoffe, es hilft !

InformationsquelleAutor Vivek Ananthan
6

Wenn Sie möchten, um ein element durch Zeilen-index und der Spalte name können Sie es genau so machen wie df['b'][0]. Es ist so einfach, wie Sie können Bild.

Oder verwenden Sie df.ix[0,'b']ist die Benutzung von index und Labels.

Hinweis: Seit v0.20 ix verworfen wurde zugunsten von loc /iloc.

InformationsquelleAutor W.Perrin
4

Werden die unterschiedlichen Ansätze diskutiert, die in obigen Reaktionen beruhen auf der Annahme, dass der Benutzer weiß, Spalte Indizes fallen oder Teilsätze auf, oder der Benutzer möchte Teilmenge ein dataframe mit einer Reihe von Spalten (z.B. zwischen 'C' : 'E'). pandas.DataFrame.drop() ist sicherlich eine option, um die Teilmenge der Daten basierend auf einer Liste der Spalten, die vom Benutzer definiert (obwohl Sie müssen vorsichtig sein, dass Sie immer mit Kopie des dataframe und inplace sollten die Parameter nicht gesetzt werden Wahr!!)

Andere Möglichkeit ist die Verwendung pandas.Spalten.Unterschied(), die nicht einen Satz Unterschied auf den Spaltennamen, und gibt einen index-array-Typ, mit gewünschten Spalten. Folgendes ist die Lösung:
```
df = pd.DataFrame([[2,3,4],[3,4,5]],columns=['a','b','c'],index=[1,2])
columns_for_differencing = ['a']
df1 = df.copy()[df.columns.difference(columns_for_differencing)]
print(df1)
```
Die Ausgabe wäre:b c 1 3 4 2 4 5
- Die copy() ist nicht notwendig. ich.e: df1 = df[df.columns.difference(columns_for_differencing)] gibt eine neue/kopierte dataframe. Sie werden in der Lage sein zu ändern df1 ohne änderung df. Danke, btw. Das war genau das was ich brauchte.
InformationsquelleAutor Harshit

Können Sie pandas.
Ich erstelle den DataFrame:

    import pandas as pd
    df = pd.DataFrame([[1, 2,5], [5,4, 5], [7,7, 8], [7,6,9]], 
                      index=['Jane', 'Peter','Alex','Ann'],
                      columns=['Test_1', 'Test_2', 'Test_3'])

Den DataFrame:

           Test_1  Test_2  Test_3
    Jane        1       2       5
    Peter       5       4       5
    Alex        7       7       8
    Ann         7       6       9

Wählen Sie 1 oder mehr Spalten-name:

    df[['Test_1','Test_3']]

           Test_1  Test_3
    Jane        1       5
    Peter       5       5
    Alex        7       8
    Ann         7       9

Können Sie auch verwenden:

    df.Test_2

Und yo get Spalte Test_2

    Jane     2
    Peter    4
    Alex     7
    Ann      6

Können Sie auch wählen Sie Spalten und Zeilen aus diesen Zeilen mit .loc(). Dies wird als "slicing". Beachten Sie, dass ich aus Spalte Test_1zu Test_3

    df.loc[:,'Test_1':'Test_3']

Die "Scheibe" ist:

            Test_1  Test_2  Test_3
     Jane        1       2       5
     Peter       5       4       5
     Alex        7       7       8
     Ann         7       6       9

Und wenn Sie wollen einfach nur Peter und Ann von Spalten Test_1 und Test_3:

    df.loc[['Peter', 'Ann'],['Test_1','Test_3']]

Erhalten Sie:

           Test_1  Test_3
    Peter       5       5
    Ann         7       9

InformationsquelleAutor pink.slash

3

Einen anderen und einfachen Ansatz : Iteration von Reihen

mit iterows
```
`df1= pd.DataFrame() #creating an empty dataframe
 for index,i in df.iterrows():
 df1.loc[index,'A']=df.loc[index,'A']
 df1.loc[index,'B']=df.loc[index,'B']
 df1.head()
```
- Bitte empfehlen nicht die Verwendung von iterrows(). Es ist eine himmelschreiende enabler der schlimmsten anti-pattern in der Geschichte der pandas.
- Könnten Sie bitte erklären, was meinst du mit "Schlimmste anti-pattern" ?
- en.wikipedia.org/wiki/Anti-pattern
- IMHO, iterrows() sollte die Letzte option sein, wenn mit pandas.
InformationsquelleAutor Ankita
2

Ab 0.21.0, mit .loc oder [] mit einer Liste mit einem oder mehreren fehlenden Etiketten, ist veraltet, zu Gunsten der .reindex. Also, die Antwort auf Ihre Frage ist:

df1 = df.reindex(columns=['b','c'])

In früheren Versionen, mit .loc[list-of-labels] funktionieren würde, solange mindestens 1 der Schlüssel gefunden wurde (sonst würde es heben ein KeyError). Dieses Verhalten ist veraltet und zeigt nun eine Warnmeldung. Die empfohlene alternative ist die Verwendung .reindex().

Lesen Sie mehr auf Die Indizierung und Auswahl von Daten

InformationsquelleAutor tozCSS

Habe ich gesehen, dass mehrere Antworten auf, aber blieb mir unklar. Wie würden Sie wählen Sie die Spalten, die von Interesse? Die Antwort auf diese Frage ist, dass, wenn Sie Ihnen gesammelt in einer Liste können Sie nur Verweis auf die Spalten mit der Liste.

Beispiel

print(extracted_features.shape)
print(extracted_features)

(63,)
['f000004' 'f000005' 'f000006' 'f000014' 'f000039' 'f000040' 'f000043'
 'f000047' 'f000048' 'f000049' 'f000050' 'f000051' 'f000052' 'f000053'
 'f000054' 'f000055' 'f000056' 'f000057' 'f000058' 'f000059' 'f000060'
 'f000061' 'f000062' 'f000063' 'f000064' 'f000065' 'f000066' 'f000067'
 'f000068' 'f000069' 'f000070' 'f000071' 'f000072' 'f000073' 'f000074'
 'f000075' 'f000076' 'f000077' 'f000078' 'f000079' 'f000080' 'f000081'
 'f000082' 'f000083' 'f000084' 'f000085' 'f000086' 'f000087' 'f000088'
 'f000089' 'f000090' 'f000091' 'f000092' 'f000093' 'f000094' 'f000095'
 'f000096' 'f000097' 'f000098' 'f000099' 'f000100' 'f000101' 'f000103']

Habe ich die folgende Liste/numpy-array extracted_features Angabe 63 Spalten. Der original-Datensatz 103 Spalten, und ich möchte zu extrahieren, also genau jene, dann würde ich

dataset[extracted_features]

Und Sie werden am Ende mit dieser

Auswahl mehrerer Spalten in ein pandas dataframe

Dies etwas, das Sie verwenden würden, sehr oft in Machine Learning (genauer gesagt, in der feature-Auswahl). Ich würde gerne diskutieren, andere Möglichkeiten zu, aber ich denke, das ist bereits bedeckt durch andere stackoverflowers. Hoffe, diese habe hilfreich!

InformationsquelleAutor Kareem Jeiroudi

können Sie auch df.pop()

>>> df = pd.DataFrame([('falcon', 'bird',    389.0),
...                    ('parrot', 'bird',     24.0),
...                    ('lion',   'mammal',   80.5),
...                    ('monkey', 'mammal', np.nan)],
...                   columns=('name', 'class', 'max_speed'))
>>> df
     name   class  max_speed
0  falcon    bird      389.0
1  parrot    bird       24.0
2    lion  mammal       80.5
3  monkey  mammal 

>>> df.pop('class')
0      bird
1      bird
2    mammal
3    mammal
Name: class, dtype: object

>>> df
     name  max_speed
0  falcon      389.0
1  parrot       24.0
2    lion       80.5
3  monkey        NaN

lassen Sie mich wissen, ob das hilft so für Sie , benutzen Sie bitte df.pop - (c)

InformationsquelleAutor Puneet Sinha

Schreibe einen Kommentar

Du musst angemeldet sein, um einen Kommentar abzugeben.

mit iterows

Beispiel