Comment prendre des tranches de colonnes de dataframe dans pandas ?

Question

Je charge des données d'apprentissage automatique à partir d'un fichier CSV. Les deux premières colonnes sont des observations et les autres colonnes sont des caractéristiques.

Actuellement, je fais ce qui suit :

data = pandas.read_csv('mydata.csv')

ce qui donne quelque chose comme :

data = pandas.DataFrame(np.random.rand(10,5), columns = list('abcde'))

Je voudrais découper ce cadre de données en deux cadres de données : l'un contenant les colonnes a et b et une autre contenant les colonnes c , d et e .

Il n'est pas possible d'écrire quelque chose comme

observations = data[:'c']
features = data['c':]

Je ne sais pas quelle est la meilleure méthode. Ai-je besoin d'un pd.Panel ?

Au fait, je trouve l'indexation des dataframes assez incohérente : data['a'] est autorisé, mais data[0] ne l'est pas. De l'autre côté, data['a':] n'est pas autorisé mais data[0:] est. Y a-t-il une raison pratique à cela ? C'est vraiment déroutant si les colonnes sont indexées par Int, étant donné que data[0] != data[0:1]

Answer 1

Réponse 2017 - pandas 0.20 : .ix est déprécié. Utilisez .loc

Voir le dépréciation dans la documentation

.loc utilise une indexation basée sur les étiquettes pour sélectionner à la fois les lignes et les colonnes. Les étiquettes sont les valeurs de l'index ou des colonnes. Découpage en tranches avec .loc inclut le dernier élément.

Supposons que nous ayons un DataFrame avec les colonnes suivantes :
foo , bar , quz , ant , cat , sat , dat .

# selects all rows and all columns beginning at 'foo' up to and including 'sat'
df.loc[:, 'foo':'sat']
# foo bar quz ant cat sat

.loc accepte la même notation en tranches que les listes Python pour les lignes et les colonnes. La notation en tranches étant start:stop:step

# slice from 'foo' to 'cat' by every 2nd column
df.loc[:, 'foo':'cat':2]
# foo quz cat

# slice from the beginning to 'bar'
df.loc[:, :'bar']
# foo bar

# slice from 'quz' to the end by 3
df.loc[:, 'quz'::3]
# quz sat

# attempt from 'sat' to 'bar'
df.loc[:, 'sat':'bar']
# no columns returned

# slice from 'sat' to 'bar'
df.loc[:, 'sat':'bar':-1]
sat cat ant quz bar

# slice notation is syntatic sugar for the slice function
# slice from 'quz' to the end by 2 with slice function
df.loc[:, slice('quz',None, 2)]
# quz cat dat

# select specific columns with a list
# select columns foo, bar and dat
df.loc[:, ['foo','bar','dat']]
# foo bar dat

Vous pouvez trancher par lignes et par colonnes. Par exemple, si vous avez 5 lignes avec des étiquettes v , w , x , y , z

# slice from 'w' to 'y' and 'foo' to 'ant' by 3
df.loc['w':'y', 'foo':'ant':3]
#    foo ant
# w
# x
# y

Answer 2

Note : .ix est déprécié depuis la version 0.20 de Pandas. Vous devriez plutôt utiliser .loc ou .iloc le cas échéant.

C'est à l'index DataFrame.ix que vous devez accéder. C'est un peu confus (je suis d'accord que l'indexation de Pandas est parfois perplexe !), mais ce qui suit semble faire ce que vous voulez :

>>> df = DataFrame(np.random.rand(4,5), columns = list('abcde'))
>>> df.ix[:,'b':]
      b         c         d         e
0  0.418762  0.042369  0.869203  0.972314
1  0.991058  0.510228  0.594784  0.534366
2  0.407472  0.259811  0.396664  0.894202
3  0.726168  0.139531  0.324932  0.906575

où .ix[tranche de ligne, tranche de colonne] est ce qui est interprété. Pour en savoir plus sur l'indexation de Pandas, cliquez ici : http://pandas.pydata.org/pandas-docs/stable/indexing.html#indexing-advanced

Answer 3

Prenons l'exemple de l'ensemble de données titanic du paquet seaborn.

# Load dataset (pip install seaborn)
>> import seaborn.apionly as sns
>> titanic = sns.load_dataset('titanic')

en utilisant les noms des colonnes

titanic.loc[:,['sex','age','fare']]

en utilisant les indices de colonne

titanic.iloc[:,[2,3,6]]

en utilisant ix (plus ancien que la version <.20 de Pandas)

titanic.ix[:,[‘sex’,’age’,’fare’]]

ou

>> titanic.ix[:,[2,3,6]]

en utilisant la méthode de réindexation

titanic.reindex(columns=['sex','age','fare'])

Answer 4

De même, étant donné un DataFrame

données

Comme dans votre exemple, si vous souhaitez extraire les colonnes a et d uniquement (c'est-à-dire la 1ère et la 4ème colonne), la méthode iloc du dataframe pandas est ce dont vous avez besoin et peut être utilisée très efficacement. Tout ce dont vous avez besoin, c'est de connaître l'index des colonnes que vous souhaitez extraire. Par exemple :

>>> data.iloc[:,[0,3]]

vous donnera

          a         d
0  0.883283  0.100975
1  0.614313  0.221731
2  0.438963  0.224361
3  0.466078  0.703347
4  0.955285  0.114033
5  0.268443  0.416996
6  0.613241  0.327548
7  0.370784  0.359159
8  0.692708  0.659410
9  0.806624  0.875476

Answer 5

Vous pouvez trancher le long des colonnes d'un DataFrame en faisant référence aux noms de chaque colonne dans une liste, comme ceci :

data = pandas.DataFrame(np.random.rand(10,5), columns = list('abcde'))
data_ab = data[list('ab')]
data_cde = data[list('cde')]