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

Et si, comme moi, vous êtes venu ici pour couper deux plages de colonnes et les combiner ensemble, vous pouvez faire quelque chose comme ceci

op = df[list(df.columns[0:899]) + list(df.columns[3593:])]
print op

Cela créera un nouveau cadre de données avec les 900 premières colonnes et (toutes) les colonnes > 3593 (en supposant que vous avez environ 4000 colonnes dans votre ensemble de données).

Answer 2

Voici comment vous pouvez utiliser différentes méthodes pour effectuer un découpage sélectif en colonnes, y compris le découpage sélectif en colonnes basé sur les étiquettes, les index et les plages sélectives.

In [37]: import pandas as pd    
In [38]: import numpy as np
In [43]: df = pd.DataFrame(np.random.rand(4,7), columns = list('abcdefg'))

In [44]: df
Out[44]: 
          a         b         c         d         e         f         g
0  0.409038  0.745497  0.890767  0.945890  0.014655  0.458070  0.786633
1  0.570642  0.181552  0.794599  0.036340  0.907011  0.655237  0.735268
2  0.568440  0.501638  0.186635  0.441445  0.703312  0.187447  0.604305
3  0.679125  0.642817  0.697628  0.391686  0.698381  0.936899  0.101806

In [45]: df.loc[:, ["a", "b", "c"]] ## label based selective column slicing 
Out[45]: 
          a         b         c
0  0.409038  0.745497  0.890767
1  0.570642  0.181552  0.794599
2  0.568440  0.501638  0.186635
3  0.679125  0.642817  0.697628

In [46]: df.loc[:, "a":"c"] ## label based column ranges slicing 
Out[46]: 
          a         b         c
0  0.409038  0.745497  0.890767
1  0.570642  0.181552  0.794599
2  0.568440  0.501638  0.186635
3  0.679125  0.642817  0.697628

In [47]: df.iloc[:, 0:3] ## index based column ranges slicing 
Out[47]: 
          a         b         c
0  0.409038  0.745497  0.890767
1  0.570642  0.181552  0.794599
2  0.568440  0.501638  0.186635
3  0.679125  0.642817  0.697628

### with 2 different column ranges, index based slicing: 
In [49]: df[df.columns[0:1].tolist() + df.columns[1:3].tolist()]
Out[49]: 
          a         b         c
0  0.409038  0.745497  0.890767
1  0.570642  0.181552  0.794599
2  0.568440  0.501638  0.186635
3  0.679125  0.642817  0.697628

Answer 3

Son équivalent

 >>> print(df2.loc[140:160,['Relevance','Title']])
 >>> print(df2.ix[140:160,[3,7]])

Answer 4

Si le cadre de données ressemble à ça :

group         name      count
fruit         apple     90
fruit         banana    150
fruit         orange    130
vegetable     broccoli  80
vegetable     kale      70
vegetable     lettuce   125

et OUTPUT pourrait être comme

   group    name  count
0  fruit   apple     90
1  fruit  banana    150
2  fruit  orange    130

si vous utilisez l'opérateur logique np.logical_not

df[np.logical_not(df['group'] == 'vegetable')]

plus sur

https://docs.scipy.org/doc/numpy-1.13.0/reference/routines.logic.html

autres opérateurs logiques

1. logical_and(x1, x2, /[, out, where, ...]) Calcule la valeur de vérité de x1 ET x2 par élément.

2. logical_or(x1, x2, /[, out, where, casting, ...]) Calcule la valeur de vérité de x1 OU x2 par élément.

3. logical_not(x, /[, out, where, casting, ...]) Calcule la valeur de vérité de NOT x par éléments. valeur de vérité de NOT x par élément.

4. logical_xor(x1, x2, /[, out, where, ..]) Calcule la valeur de vérité de x1 XOR x2, par éléments.

Answer 5

Une autre façon d'obtenir un sous-ensemble de colonnes à partir de votre DataFrame, en supposant que vous voulez toutes les lignes, serait de faire :
data[['a','b']] et data[['c','d','e']]
Si vous voulez utiliser des index de colonnes numériques, vous pouvez le faire :
data[data.columns[:2]] et data[data.columns[2:]]