我有一个字典，如下所示：di = {1: "A", 2: "B"}
我想将它应用于类似于：
的数据框的“col1”列 col1 col2
0 w a
1 1 2
2 2 NaN
得到：
col1 col2
0 w a
1 A 2
2 B NaN
我怎样才能做到最好？出于某种原因谷歌搜索与此相关的术语只显示了如何从dicts制作列的链接，反之亦然： - /
答案 0 :(得分：231)
您可以使用.replace。例如：
>>> 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
或直接在Series上，即df["col1"].replace(di, inplace=True)。
答案 1 :(得分：124)
map可能比replace 如果您的词典包含多个键，则使用map可能比replace快得多。此方法有两种版本，具体取决于您的词典是否详尽地映射了所有可能的值（以及您是否希望非匹配保留其值或转换为NaN）：
在这种情况下，表单非常简单：
df['col1'].map(di) # note: if the dictionary does not exhaustively map all
# entries then non-matched entries are changed to NaNs
虽然map最常用函数作为参数，但也可以使用字典或系列：Documentation for Pandas.series.map
如果您有非详尽的映射并希望保留不匹配的现有变量，则可以添加fillna：
df['col1'].map(di).fillna(df['col1'])
在@ jpp的回答中：Replace values in a pandas series via dictionary efficiently
将以下数据与pandas版本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 ) })
并使用%timeit进行测试，map似乎比replace快约10倍。
请注意，map的加速速度会因您的数据而异。最大的加速似乎是大型词典和详尽的替换。请参阅@jpp答案（上面链接）以获得更广泛的基准和讨论。
答案 2 :(得分：52)
你的问题有点含糊不清。至少有三两种解释：
di中的键引用索引值di中的键引用df['col1']值di中的键指的是索引位置（不是OP的问题，而是为了好玩而引入。）以下是每种情况的解决方案。
案例1：
如果di的密钥用于引用索引值，那么您可以使用update方法：
df['col1'].update(pd.Series(di))
例如，
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)
产量
col1 col2
1 w a
2 B 30
0 A NaN
我已经修改了原始帖子中的值，因此update正在做的更清楚。
请注意di中的键如何与索引值相关联。索引值的顺序 - 即索引位置 - 无关紧要。
案例2：
如果di中的键引用了df['col1']值，则@DanAllan和@DSM会显示如何使用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)
产量
col1 col2
1 w a
2 A 30
0 B NaN
请注意，在这种情况下，di中的键被更改为与df['col1']中的值匹配。
案例3：
如果di中的键引用索引位置，则可以使用
df['col1'].put(di.keys(), di.values())
因为
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)
产量
col1 col2
1 A a
2 10 30
0 B NaN
此处，第一行和第三行被更改，因为di中的键是0和2，其中Python的基于0的索引指的是第一个和第三个位置。
答案 3 :(得分：3)
如果您要在数据数据框中重新映射多列，请添加此问题：
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
希望它对某人有用。
干杯
答案 4 :(得分：2)
鉴于map比替换（@JohnE的解决方案）要快，您需要小心非穷举映射，您打算将特定值映射到NaN 。在这种情况下，正确的方法要求您在mask时.fillna系列，否则撤消到NaN的映射。
import pandas as pd
import numpy as np
d = {'m': 'Male', 'f': 'Female', 'missing': np.NaN}
df = pd.DataFrame({'gender': ['m', 'f', 'missing', 'Male', 'U']})
keep_nan = [k for k,v in d.items() if pd.isnull(v)]
s = df['gender']
df['mapped'] = s.map(d).fillna(s.mask(s.isin(keep_nan)))
gender mapped
0 m Male
1 f Female
2 missing NaN
3 Male Male
4 U U
答案 5 :(得分：1)
DSM的答案已被接受，但编码似乎并不适合所有人。这是与当前版本的熊猫一起使用的版本（截至2018年8月8日为0.23.4）：
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())
您会看到它像：
col1 col2 converted_column
0 1 negative -1
1 2 positive 1
2 2 neutral 0
3 3 neutral 0
4 1 positive 1
答案 6 :(得分：0)
更本土的pandas方法是应用替换函数，如下所示：
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)
定义函数后，您可以将其应用于数据框。
di = {1: "A", 2: "B"}
df['col1'] = df.apply(lambda row: multiple_replace(di, row['col1']), axis=1)
答案 7 :(得分：0)
或者执行apply：
df['col1'].apply(lambda x: {1: "A", 2: "B"}.get(x,x))
演示：
>>> 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
>>>
答案 8 :(得分：0)
一个很好的完整解决方案，可以保留您的班级标签图：
$("#div1").load("_TileManager");
这样，您可以随时从labels_dict引用原始类标签。
答案 9 :(得分：0)
作为对Nico Coallier（适用于多列）和U10-Forward（使用应用方式的方法）的建议的扩展，并将其概括为一个单一的行，我建议：
df.loc[:,['col1','col2']].transform(lambda x: x.map(lambda x: {1: "A", 2: "B"}.get(x,x))
.transform()将每一列处理为一系列。与.apply()相反，后者传递了DataFrame中聚集的列。
因此，您可以应用Series方法map()。
最后，由于U10，我发现了此行为，您可以在.get（）表达式中使用整个Series。除非我误解了它的行为，并且它按顺序而不是按位处理序列。
.get(x,x)代表您在映射字典中未提及的值，否则将被.map()方法视为Nan