Wybieranie wielu kolumn w ramce danych pandy

Zakładając, że Twoje nazwy kolumn (df.columns) są ['index','a','b','c'], wówczas żądane dane znajdują się w 3. i 4. kolumny. Jeśli nie znasz ich nazw podczas uruchamiania skryptu, możesz to zrobić

newdf = df[df.columns[2:4]] # Remember, Python is 0-offset! The "3rd" entry is at slot 2.

Jak wskazuje EMS w jego odpowiedź, df.ix kolumny w plasterkach są nieco bardziej zwięzłe, ale interfejs krojenia .columns może być bardziej naturalny, ponieważ używa vanilla 1-d składni indeksowania/krojenia listy Pythona.

WARN: 'index' is a bad name for a DataFrame column. Ta sama etykieta jest również używana do rzeczywisty atrybut df.index, tablica Index. Tak więc twoja kolumna jest zwracana przez df['index'], a prawdziwy indeks ramki danych jest zwracany przez df.index. An {[8] } jest specjalnym rodzajem Series zoptymalizowanym do wyszukiwania wartości jego elementów. Dla df.indeks służy do wyszukiwania wierszy według ich etykiet. Atrybut df.columns jest również tablicą pd.Index do wyszukiwania kolumn według ich etykiet.

Od wersji 0.11.0 kolumny mogą być pokrojone w sposób, w jaki próbowałeś użyć .loc indexer:

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

Zwraca kolumny C do E.

Demo na losowo wygenerowanej ramce danych:

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

Aby uzyskać kolumny od C do E (zauważ, że w przeciwieństwie do przecinania liczb całkowitych,' E ' jest zawarte w kolumnach):

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

To samo działa przy zaznaczaniu wierszy na podstawie etykiet. Uzyskaj wiersze " R6 " do " R10 " z tych kolumny:

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 akceptuje również tablicę boolowską, dzięki czemu można wybrać kolumny, których odpowiednim wpisem w tablicy jest True. Na przykład, df.columns.isin(list('BCD')) zwraca array([False, True, True, True, False, False], dtype=bool) - True, Jeśli nazwa kolumny znajduje się na liście ['B', 'C', 'D']; False, w przeciwnym razie.

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

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

Zdaję sobie sprawę, że to pytanie jest dość stare, ale w najnowszej wersji pand jest łatwy sposób, aby to zrobić. Nazwy kolumn (które są ciągami) Mogą być wycinane w dowolny sposób.

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

Możesz podać listę kolumn do upuszczenia i zwrócić ramkę danych z tylko tymi kolumnami, które są potrzebne przy użyciu funkcji drop() w ramce danych Pandy.

Tylko mówię

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

Zwróci ramkę danych tylko z kolumnami b i c.

Metoda drop jest udokumentowana tutaj .

Uznałem tę metodę za bardzo przydatną:

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

Więcej szczegółów można znaleźć tutaj

Wystarczy użyć: wybierze kolumnę b i C.

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

Wtedy możesz po prostu zadzwonić do df1:

df1

Jeśli chcesz uzyskać jeden element według indeksu wiersza i nazwy kolumny, możesz to zrobić tak jak df['b'][0]. To jest tak proste, jak można sobie wyobrazić.

Lub możesz użyć df.ix[0,'b'], mieszanego użycia indeksu i etykiety.

Uwaga: od v0.20 ix jest przestarzały na rzecz loc / iloc.

Różne podejścia omówione w powyższych odpowiedziach opierają się na założeniu, że użytkownik zna indeksy kolumn do spadku lub podzbioru, lub użytkownik chce podzestawić ramkę danych za pomocą zakresu kolumn (na przykład między 'C' : 'E'). Pandy.Ramka danych.drop () jest z pewnością opcją podzestawiania danych na podstawie listy kolumn zdefiniowanych przez użytkownika (należy jednak zachować ostrożność, aby zawsze używać kopii ramki danych i inplace parametry NIE POWINNY być ustawiane na True !!)

Inną opcją jest użycie pand.kolumny.difference () , która ustawia różnicę w nazwach kolumn i zwraca indeks typu tablicy zawierającej pożądane kolumny. Poniżej znajduje się rozwiązanie:

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)

Wyjście będzie: b c 1 3 4 2 4 5

Począwszy od 0.21.0, używając .loc LUB [] z listą z jedną lub więcej brakującymi etykietami, jest przestarzałe, na rzecz .reindex. Tak więc odpowiedź na twoje pytanie brzmi:

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

W poprzednich wersjach użycie .loc[list-of-labels] będzie działać tak długo, jak długo zostanie znaleziony co najmniej 1 klucz (w przeciwnym razie wywoła KeyError). To zachowanie jest przestarzałe i teraz wyświetla komunikat ostrzegawczy. Zalecaną alternatywą jest użycie .reindex().

Czytaj więcej na https://pandas.pydata.org/pandas-docs/stable/indexing.html#reindexing