Valeurs de Remap dans la colonne pandas avec un dict
j'ai un dictionnaire qui ressemble à ceci: di = {1: "A", 2: "B"}
je voudrais l'appliquer à la colonne" col1 "d'un dataframe similaire à:
col1 col2
0 w a
1 1 2
2 2 NaN
pour obtenir:
col1 col2
0 w a
1 A 2
2 B NaN
Comment puis-je faire au mieux? Pour une raison quelconque, googler des termes relatifs à cela ne me montre des liens sur la façon de faire des colonnes à partir de dicts et vice-versa: - /
7 réponses
vous pouvez utiliser .replace
. Par exemple:
>>> df = pd.DataFrame({'col2': {0: 'a', 1: 2, 2: np.nan}, 'col1': {0: 'w', 1: 1, 2: 2}})
>>> di = {1: "A", 2: "B"}
>>> df
col1 col2
0 w a
1 1 2
2 2 NaN
>>> df.replace({"col1": di})
col1 col2
0 w a
1 A 2
2 B NaN
ou directement sur le Series
, c'est à dire df["col1"].replace(di, inplace=True)
.
map
peut être beaucoup plus rapide que replace
si votre dictionnaire a plus d'un couple de clés, en utilisant map
peut être beaucoup plus rapide que replace
. Il y a deux versions de cette approche, selon que votre dictionnaire trace de façon exhaustive toutes les valeurs possibles (et aussi si vous voulez remplacer les non-correspondances ou les laisser comme valeurs manquantes):
Cartographie Exhaustive
dans ce cas, la forme est très simple:
df['col1'].map(di) # note: if the dictionary does not exhaustively map all
# entries then non-matched entries are changed to NaNs
bien que map
prenne le plus souvent une fonction comme argument, il peut alternativement prendre un dictionnaire ou une série: Documentation pour Pandas.série.carte
Cartographie Non Exhaustive
si vous avez une cartographie non exhaustive et que vous souhaitez conserver les variables existantes pour les non-correspondances, vous pouvez ajouter fillna
:
df['col1'].map(di).fillna(df['col1'])
comme dans la réponse de @jpp ici: remplacer les valeurs dans une série de pandas via le dictionnaire efficacement
Repères
utilisant les données suivantes avec pandas version 0.23.1:
di = {1: "A", 2: "B", 3: "C", 4: "D", 5: "E", 6: "F", 7: "G", 8: "H" }
df = pd.DataFrame({ 'col1': np.random.choice( range(1,9), 100000 ) })
et l'essai avec %timeit
, il apparaît que map
est environ 10 fois plus rapide que replace
.
notez que votre vitesse avec map
variera avec votre données. La plus grande accélération semble être avec de grands dictionnaires et remplace exhaustifs. Voir la réponse de @jpp (liée ci-dessus) pour des références et des discussions plus détaillées.
Il y a un peu d'ambiguïté dans votre question. Il y a au moins trois deux interprétations:
- les touches dans
di
se réfèrent aux valeurs de l'indice - les touches
di
se réfèrent àdf['col1']
valeurs - les touches dans
di
font référence à l'emplacement de l'index (pas la question de L'OP, mais jeté dans pour le plaisir.)
ci-dessous est un solution pour chaque cas.
Cas 1:
Si les clés de di
sont destinées à se référer à des valeurs d'indice, alors vous pouvez utiliser la update
méthode:
df['col1'].update(pd.Series(di))
par exemple,
import pandas as pd
import numpy as np
df = pd.DataFrame({'col1':['w', 10, 20],
'col2': ['a', 30, np.nan]},
index=[1,2,0])
# col1 col2
# 1 w a
# 2 10 30
# 0 20 NaN
di = {0: "A", 2: "B"}
# The value at the 0-index is mapped to 'A', the value at the 2-index is mapped to 'B'
df['col1'].update(pd.Series(di))
print(df)
rendements
col1 col2
1 w a
2 B 30
0 A NaN
j'ai modifié les valeurs de votre post original pour qu'il soit plus clair ce que update
fait.
Notez comment les clés dans di
sont associés à des valeurs indicielles. L'ordre des valeurs de l'indice-qui est, l'indice emplacements -- n'a pas d'importance.
Cas 2:
Si les touches di
se réfèrent aux valeurs df['col1']
, alors @DanAllan et @DSM montrent comment réaliser ceci avec replace
:
import pandas as pd
import numpy as np
df = pd.DataFrame({'col1':['w', 10, 20],
'col2': ['a', 30, np.nan]},
index=[1,2,0])
print(df)
# col1 col2
# 1 w a
# 2 10 30
# 0 20 NaN
di = {10: "A", 20: "B"}
# The values 10 and 20 are replaced by 'A' and 'B'
df['col1'].replace(di, inplace=True)
print(df)
rendements
col1 col2
1 w a
2 A 30
0 B NaN
noter comment dans ce cas les clés dans di
ont été changées pour correspondre à valeurs dans df['col1']
.
Cas 3:
Si les touches di
se réfèrent à l'emplacement de l'index, alors vous pouvez utiliser
df['col1'].put(di.keys(), di.values())
depuis
df = pd.DataFrame({'col1':['w', 10, 20],
'col2': ['a', 30, np.nan]},
index=[1,2,0])
di = {0: "A", 2: "B"}
# The values at the 0 and 2 index locations are replaced by 'A' and 'B'
df['col1'].put(di.keys(), di.values())
print(df)
rendements
col1 col2
1 A a
2 10 30
0 B NaN
Ici, les première et troisième lignes ont été modifiées, parce que les touches di
sont 0
et 2
, qui avec l'indexation basée sur 0 de Python se réfèrent aux premier et troisième emplacements.
ajouter à cette question si vous avez déjà plus d'une colonnes pour refaire dans une dataframe de données:
def remap(data,dict_labels):
"""
This function take in a dictionnary of labels : dict_labels
and replace the values (previously labelencode) into the string.
ex: dict_labels = {{'col1':{1:'A',2:'B'}}
"""
for field,values in dict_labels.items():
print("I am remapping %s"%field)
data.replace({field:values},inplace=True)
print("DONE")
return data
espérons qu'il puisse être utile à quelqu'un.
Cheers
DSM a la réponse acceptée, mais le codage ne semble pas fonctionner pour tout le monde. Voici un qui fonctionne avec la version actuelle de pandas (0.23.4 à partir de 8/2018):
import pandas as pd
df = pd.DataFrame({'col1': [1, 2, 2, 3, 1],
'col2': ['negative', 'positive', 'neutral', 'neutral', 'positive']})
conversion_dict = {'negative': -1, 'neutral': 0, 'positive': 1}
df['converted_column'] = df['col2'].replace(conversion_dict)
print(df.head())
on dirait:
col1 col2 converted_column
0 1 negative -1
1 2 positive 1
2 2 neutral 0
3 3 neutral 0
4 1 positive 1
Les docs pour pandas.DataFrame.remplacer sont ici .
natifs de pandas approche consiste à appliquer une fonction remplacer comme ci-dessous:
def multiple_replace(dict, text):
# Create a regular expression from the dictionary keys
regex = re.compile("(%s)" % "|".join(map(re.escape, dict.keys())))
# For each match, look-up corresponding value in dictionary
return regex.sub(lambda mo: dict[mo.string[mo.start():mo.end()]], text)
une Fois que vous avez défini la fonction, vous pouvez l'appliquer à votre dataframe.
di = {1: "A", 2: "B"}
df['col1'] = df.apply(lambda row: multiple_replace(di, row['col1']), axis=1)
ou do apply
:
df['col1'].apply(lambda x: {1: "A", 2: "B"}.get(x,x))
Démo:
>>> df['col1']=df['col1'].apply(lambda x: {1: "A", 2: "B"}.get(x,x))
>>> df
col1 col2
0 w a
1 1 2
2 2 NaN
>>>