it-swarm.com.de

Auswählen mehrerer Spalten in einem Pandas-Datenrahmen

Ich habe Daten in verschiedenen Spalten, weiß aber nicht, wie ich sie extrahieren muss, um sie in einer anderen Variablen zu speichern.

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

Wie wähle ich 'a', 'b' und speichere es in df1?

Ich habe es versucht 

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

Keiner scheint zu funktionieren.

663
user1234440

Die Spaltennamen (die Zeichenfolgen sind) können nicht in der von Ihnen gewählten Weise in Scheiben geschnitten werden.

Hier haben Sie einige Möglichkeiten. Wenn Sie aus dem Kontext wissen, welche Variablen Sie herausschneiden möchten, können Sie nur eine Ansicht dieser Spalten zurückgeben, indem Sie eine Liste in die __getitem__-Syntax (die [] 's) übergeben.

df1 = df[['a','b']]

Wenn es wichtig ist, sie numerisch und nicht nach ihrem Namen zu indizieren (sagen Sie, Ihr Code sollte dies automatisch tun, ohne die Namen der ersten beiden Spalten zu kennen), können Sie stattdessen Folgendes tun:

df1 = df.iloc[:,0:2] # Remember that Python does not slice inclusive of the ending index.

Darüber hinaus sollten Sie sich mit der Idee einer Ansicht in ein Pandas-Objekt gegenüber einer Kopie dieses Objekts vertraut machen. Die erste der obigen Methoden gibt eine neue Kopie des gewünschten Unterobjekts (der gewünschten Segmente) im Speicher zurück. 

In Pandas gibt es jedoch manchmal Indizierungskonventionen, die dies nicht tun und stattdessen eine neue Variable angeben, die nur auf den gleichen Speicherbereich verweist wie das Unterobjekt oder das Slice im ursprünglichen Objekt. Dies geschieht bei der zweiten Art der Indizierung. Sie können sie mit der Funktion copy() ändern, um eine reguläre Kopie zu erhalten. Wenn dies der Fall ist, kann das ursprüngliche Objekt manchmal geändert werden, wenn Sie das, was Sie für das in Scheiben geschnittene Objekt halten, ändern. Es ist immer gut, darauf zu achten.

df1 = df.iloc[0,0:2].copy() # To avoid the case where changing df1 also changes df
1121
ely

Angenommen, Ihre Spaltennamen (df.columns) sind ['index','a','b','c'], dann befinden sich die gewünschten Daten in der 3. & 4. Spalte. Wenn Sie deren Namen nicht kennen, 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.

Wie EMS in seiner Antwort zeigt, schneidet df.ix Spalten etwas prägnanter, aber das .columns-Slicing-Interface ist möglicherweise natürlicher, da es die Vanilla 1-D-Python-Listen-Indizierungs-/Slicing-Syntax verwendet.

WARNUNG: 'index' ist ein falscher Name für eine DataFrame-Spalte. Dieselbe Bezeichnung wird auch für das echte df.index-Attribut verwendet, ein Index-Array. Ihre Spalte wird also von df['index'] zurückgegeben, und der tatsächliche DataFrame-Index wird von df.index zurückgegeben. Eine Index ist eine spezielle Art von Series, die für das Nachschlagen der Werte ihrer Elemente optimiert ist. Bei df.index wird nach Zeilen nach ihrem Label gesucht. Dieses df.columns-Attribut ist auch ein pd.Index-Array, um Spalten anhand ihrer Beschriftungen nachzuschlagen.

85
hobs

Seit Version 0.11.0 wurden die Spalten kann so geschnitten, wie Sie es mit dem .loc indexer versucht haben: 

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

ist gleichbedeutend mit

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

und gibt die Spalten C bis E zurück.


Eine Demo zu einem 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

Um die Spalten von C bis E zu erhalten (beachten Sie, dass im Gegensatz zum Integer-Slicing 'E' in den Spalten enthalten ist):

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
...

Gleiches funktioniert bei der Auswahl von Zeilen basierend auf Beschriftungen. Holen Sie sich die Zeilen 'R6' bis '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 akzeptiert auch ein boolesches Array, sodass Sie die Spalten auswählen können, deren entsprechender Eintrag im Array True lautet. Zum Beispiel gibt df.columns.isin(list('BCD'))array([False, True, True, True, False, False], dtype=bool) - True zurück, wenn der Spaltenname in der Liste steht ['B', 'C', 'D']; Falsch, 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
...
80
ayhan
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
55
Wes McKinney

Ich weiß, dass diese Frage ziemlich alt ist, aber in der neuesten Version von Pandas gibt es eine einfache Möglichkeit, genau dies zu tun. Spaltennamen (die Zeichenfolgen sind) can können auf beliebige Weise in Scheiben geschnitten werden.

columns = ['b', 'c']
df1 = pd.DataFrame(df, columns=columns)
39
zerovector

Sie können eine Liste der zu löschenden Spalten bereitstellen und den DataFrame nur mit den erforderlichen Spalten mit der Funktion drop() eines Pandas DataFrame zurückgeben.

Nur sagen

colsToDrop = ['a']
df.drop(colsToDrop, axis=1)

würde einen DataFrame nur mit den Spalten b und c zurückgeben.

Die drop-Methode ist hier dokumentiert.

Ich fand diese Methode sehr nützlich:

# iloc[row slicing, column slicing]
surveys_df.iloc [0:3, 1:4]

Weitere Details finden Sie hier

16
Alvis

verwenden Sie einfach:.

df1=pd.DataFrame()
df1=df[['b','c']]

dann kannst du einfach df1 anrufen:

df1
11
Akash Nayak

Mit Pandas, 

mit Spaltennamen 

dataframe[['column1','column2']]

mit iloc kann der Spaltenindex ähnlich verwendet werden

dataframe[:,[1,2]]

mit loc können Spaltennamen verwendet werden

dataframe[:,['column1','column2']]

ich hoffe es hilft !

5
Vivek Ananthan

Wenn Sie ein Element nach Zeilenindex und Spaltennamen abrufen möchten, können Sie dies genauso wie df['b'][0] tun. Es ist so einfach wie Sie sich vorstellen können. 

Oder Sie können df.ix[0,'b'] verwenden, gemischte Verwendung von Index und Label.

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

5
W.Perrin

Unten ist mein Code:

import pandas as pd
df = pd.read_Excel("data.xlsx", sheet_name = 2)
print df
df1 = df[['emp_id','date']]
print df1

Ausgabe:

  emp_id        date  count
0   1001   11/1/2018      3
1   1002   11/1/2018      4
2          11/2/2018      2
3          11/3/2018      4
  emp_id        date
0   1001   11/1/2018
1   1002   11/1/2018
2          11/2/2018
3          11/3/2018

Der erste Datenrahmen ist der Master. Ich habe gerade zwei Spalten in df1 kopiert.

3
Rishi Bansal

Die verschiedenen Ansätze, die in den obigen Antworten erörtert wurden, basieren auf der Annahme, dass entweder der Benutzer Spaltenindizes kennt oder ablehnt oder der Benutzer einen Datenrahmen unter Verwendung eines Spaltenbereichs (beispielsweise zwischen 'C': 'E') subsetieren möchte. . pandas.DataFrame.drop () ist sicherlich eine Option, um Daten basierend auf einer vom Benutzer definierten Liste von Spalten zu subsetieren (obwohl Sie vorsichtig sein müssen, dass Sie immer eine Kopie von dataframe und inplace - Parametern nicht verwenden auf True gesetzt sein !!) 

Eine andere Option ist die Verwendung von pandas.columns.difference () , die einen bestimmten Unterschied bei den Spaltennamen bewirkt und einen Indextyp des Arrays zurückgibt, der die gewünschten Spalten enthält. Im Folgenden 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

3
Harshit

Ab 0.21.0 wird die Verwendung von .loc Oder [] Mit einer Liste mit einem oder mehreren fehlenden Bezeichnungen zugunsten von .reindex Nicht mehr empfohlen. Die Antwort auf Ihre Frage lautet also:

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

In früheren Versionen funktionierte die Verwendung von .loc[list-of-labels], Solange mindestens 1 der Schlüssel gefunden wurde (andernfalls würde ein KeyError ausgelöst). Dieses Verhalten ist veraltet und zeigt jetzt eine Warnmeldung an. Die empfohlene Alternative ist die Verwendung von .reindex().

Weitere Informationen finden Sie unter Indizieren und Auswählen von Daten

2
tozCSS

Ich bin mir ziemlich sicher, dass dies kein optimierter Ansatz ist, sondern als anderer Ansatz betrachtet werden kann.

iterows verwenden

`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()
2
Ankita

Ich habe mehrere Antworten darauf gesehen, aber weiter blieb mir unklar. Wie würden Sie diese interessanten Spalten auswählen? Die Antwort darauf ist, dass Sie, wenn Sie sie in einer Liste gesammelt haben, einfach die Spalten mithilfe der Liste referenzieren können.

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']

Ich habe die folgende Liste/Numpy-Array extracted_features, wobei 63 Spalten angegeben werden. Der ursprüngliche Datensatz hat 103 Spalten, und ich möchte genau diese extrahieren, dann würde ich verwenden

dataset[extracted_features]

Und Sie werden damit enden

 enter image description here 

Dies ist etwas, das Sie beim maschinellen Lernen (genauer gesagt bei der Funktionsauswahl) häufig verwenden würden. Ich würde auch gerne andere Möglichkeiten diskutieren, aber ich denke, das wurde bereits von anderen Stackoverflowers abgedeckt. Hoffe das war hilfreich!

0
Kareem Jeiroudi

sie können auch df.pop () verwenden

>>> 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, wenn dies für Sie hilfreich ist.

0
Puneet Sinha

Sie können Pandas verwenden. 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'])

Der Datenrahmen:

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

So wählen Sie eine oder mehrere Spalten nach Namen aus:

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

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

Sie können auch verwenden:

    df.Test_2

Und Sie erhalten Spalte Test_2

    Jane     2
    Peter    4
    Alex     7
    Ann      6

Sie können auch Spalten und Zeilen aus diesen Zeilen mit.loc()auswählen. Dies wird als "Slicing" bezeichnet. Beachten Sie, dass ich aus Spalte Test_1 bis Test_3 entnehme.

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

Das "Slice" 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 nur Peter und Ann aus den Spalten Test_1 und Test_3 wollen:

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

Du kriegst:

           Test_1  Test_3
    Peter       5       5
    Ann         7       9
0
pink.slash