Sélection de plusieurs colonnes dans une base de données pandas
J'ai des données dans différentes colonnes mais je ne sais pas comment les extraire pour les sauvegarder dans une autre variable.
index a b c
1 2 3 4
2 3 4 5
Comment sélectionner 'a', 'b' et l'enregistrer dans df1?
J'ai essayé
df1 = df['a':'b']
df1 = df.ix[:, 'a':'b']
Aucun ne semble fonctionner.
Les noms de colonne (qui sont des chaînes) ne peuvent pas être découpés de la manière que vous avez essayée.
Ici, vous avez deux options. Si vous connaissez le contexte des variables que vous souhaitez découper, vous pouvez simplement renvoyer une vue de ces colonnes uniquement en transmettant une liste dans la syntaxe __getitem__ (celle du []).
df1 = df[['a','b']]
Alternativement, s'il est important de les indexer numériquement et non par leur nom (supposons que votre code le fasse automatiquement sans connaître les noms des deux premières colonnes), vous pouvez le faire à la place:
df1 = df.iloc[:,0:2] # Remember that Python does not slice inclusive of the ending index.
De plus, vous devriez vous familiariser avec l'idée d'une vue dans un objet Pandas par rapport à une copie de cet objet. La première des méthodes ci-dessus renverra une nouvelle copie en mémoire du sous-objet souhaité (les tranches souhaitées).
Parfois, cependant, certaines conventions d'indexation dans les pandas ne le font pas et vous donnent plutôt une nouvelle variable qui fait simplement référence au même bloc de mémoire que le sous-objet ou la tranche de l'objet d'origine. Cela se produira avec la deuxième méthode d’indexation, vous pourrez donc la modifier avec la fonction copy() pour obtenir une copie normale. Lorsque cela se produit, changer ce que vous pensez être l'objet découpé peut parfois modifier l'objet d'origine. Toujours bon d'être à l'affût de cela.
df1 = df.iloc[0,0:2].copy() # To avoid the case where changing df1 also changes df
En supposant que vos noms de colonnes (df.columns) sont ['index','a','b','c'], les données que vous souhaitez se trouvent dans les colonnes 3rd et 4th. Si vous ne connaissez pas leurs noms lorsque votre script est exécuté, vous pouvez le faire.
newdf = df[df.columns[2:4]] # Remember, Python is 0-offset! The "3rd" entry is at slot 2.
Comme le souligne EMS dans sa réponse , df.ix divise les colonnes de façon plus concise, mais l'interface de découpage .columns peut sembler plus naturelle car elle utilise la syntaxe d'indexation/découpage de liste python Vanilla 1-D.
WARN: 'index' est un mauvais nom pour une colonne DataFrame. Cette même étiquette est également utilisée pour l'attribut réel df.index, un tableau Index. Votre colonne est donc renvoyée par df['index'] et le véritable index DataFrame est renvoyé par df.index. Une Index est un type spécial de Series optimisé pour la recherche des valeurs de ses éléments. Pour df.index, il permet de rechercher des lignes par leur libellé. Cet attribut df.columns est également un tableau pd.Index, qui permet de rechercher les colonnes par leur libellé.
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
Je me rends compte que cette question est assez ancienne, mais dans la dernière version des pandas, il existe un moyen facile de faire exactement cela. Les noms de colonnes (qui sont des chaînes) can / peuvent être découpés de la manière que vous préférez.
columns = ['b', 'c']
df1 = pd.DataFrame(df, columns=columns)
Vous pouvez fournir une liste de colonnes à supprimer et renvoyer le DataFrame avec uniquement les colonnes nécessaires à l'aide de la fonction drop() sur un Pandas DataFrame.
Juste dire
colsToDrop = ['a']
df.drop(colsToDrop, axis=1)
renverrait un DataFrame avec uniquement les colonnes b et c.
La méthode drop est documentée ici .
J'ai trouvé cette méthode très utile:
# iloc[row slicing, column slicing]
surveys_df.iloc [0:3, 1:4]
Plus de détails peuvent être trouvés ici
utilisez simplement: les colonnes b et c seront sélectionnées.
df1=pd.DataFrame()
df1=df[['b','c']]
alors vous pouvez simplement appeler df1:
df1
Avec des pandas,
noms de colonne
dataframe[['column1','column2']]
avec iloc, l'index de colonne peut être utilisé comme
dataframe[:,[1,2]]
avec des noms de colonne loc peuvent être utilisés comme
dataframe[:,['column1','column2']]
j'espère que ça aide !
Si vous voulez obtenir un élément par index de ligne et nom de colonne, vous pouvez le faire comme pour df['b'][0]. C'est aussi simple que vous pouvez imaginer.
Ou vous pouvez utiliser df.ix[0,'b'], utilisation mixte d'index et d'étiquette.
Remarque: Depuis la version 0,20, ix est devenu obsolète en faveur de loc/iloc.
Ci-dessous mon code:
import pandas as pd
df = pd.read_Excel("data.xlsx", sheet_name = 2)
print df
df1 = df[['emp_id','date']]
print df1
Sortie:
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
Le premier cadre de données est le maître. Je viens de copier deux colonnes dans DF1.
Les différentes approches discutées dans les réponses ci-dessus sont basées sur l'hypothèse que l'utilisateur sait quels index de colonne doivent être supprimés ou sous-définis, ou l'utilisateur souhaite sous-définir un cadre de données en utilisant une plage de colonnes (par exemple entre 'C': 'E') . pandas.DataFrame.drop () est certainement une option pour sous-définir les données en fonction d’une liste de colonnes définie par l’utilisateur (vous devez cependant veiller à ne pas utiliser toujours les paramètres copy of dataframe et inplace). être réglé sur True !!)
Une autre option consiste à utiliser pandas.columns.difference () , qui crée une différence définie sur les noms de colonne et renvoie un type d’index de tableau contenant les colonnes souhaitées. Voici la solution:
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)
La sortie serait:
b c
1 3 4
2 4 5
Je suis tout à fait sûr que cette approche n’est pas optimisée mais peut être considérée comme différente.
en utilisant 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()
J'ai vu plusieurs réponses à ce sujet, mais ce n'est toujours pas clair pour moi. Comment choisiriez-vous ces colonnes d'intérêt? La réponse à cela est que si vous les avez rassemblés dans une liste, vous pouvez simplement référencer les colonnes en utilisant la liste.
Exemple
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']
J'ai le tableau suivant list/numpy extracted_features, spécifiant 63 colonnes. Le jeu de données original a 103 colonnes, et je voudrais extraire exactement celles-ci, alors je voudrais utiliser
dataset[extracted_features]
Et vous allez vous retrouver avec ça
C'est quelque chose que vous utiliseriez assez souvent dans Machine Learning (plus précisément dans la sélection des fonctionnalités). J'aimerais aussi discuter d'autres moyens, mais je pense que cela a déjà été couvert par d'autres stackoverflowers. J'espère que cela a été utile!
vous pouvez aussi utiliser 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
laissez-moi savoir si cela vous aide, merci d'utiliser df.pop
Vous pouvez utiliser des pandas . Je crée le 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'])
Le DataFrame:
Test_1 Test_2 Test_3
Jane 1 2 5
Peter 5 4 5
Alex 7 7 8
Ann 7 6 9
Pour sélectionner 1 ou plusieurs colonnes par nom:
df[['Test_1','Test_3']]
Test_1 Test_3
Jane 1 5
Peter 5 5
Alex 7 8
Ann 7 9
Vous pouvez aussi utiliser:
df.Test_2
Et vous obtenez la colonne Test_2
Jane 2
Peter 4
Alex 7
Ann 6
Vous pouvez également sélectionner des colonnes et des lignes à partir de ces lignes en utilisant.loc(). Cela s'appelle "trancher" . Notez que je prends de la colonne Test_1 à Test_3
df.loc[:,'Test_1':'Test_3']
La "tranche" est:
Test_1 Test_2 Test_3
Jane 1 2 5
Peter 5 4 5
Alex 7 7 8
Ann 7 6 9
Et si vous voulez simplement Peter et Ann dans les colonnes Test_1 et Test_3:
df.loc[['Peter', 'Ann'],['Test_1','Test_3']]
Vous recevez:
Test_1 Test_3
Peter 5 5
Ann 7 9