一个很好的完整的解决方案，保持你的类标签的映射:

labels = features['col1'].unique()
labels_dict = dict(zip(labels, range(len(labels))))
features = features.replace({"col1": labels_dict})

这样，您可以在任何时候引用labels_dict中的原始类标签。

你的问题有点模棱两可。至少有三种两种解释:

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

我已经修改了你的原始帖子的值，所以它是更清楚的更新正在做什么。 注意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的索引中，它们指的是第一行和第三个位置。

更本土的熊猫方法是应用替换函数，如下所示:

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)

你可以用数据帧中缺失的对来更新你的映射字典。例如:

df = pd.DataFrame({'col1': ['a', 'b', 'c', 'd', np.nan]})
map_ = {'a': 'A', 'b': 'B', 'd': np.nan}

# Get mapping from df
uniques = df['col1'].unique()
map_new = dict(zip(uniques, uniques))
# {'a': 'a', 'b': 'b', 'c': 'c', 'd': 'd', nan: nan}

# Update mapping
map_new.update(map_)
# {'a': 'A', 'b': 'B', 'c': 'c', 'd': nan, nan: nan}

df['col2'] = df['col1'].map(dct_map_new)

结果:

  col1 col2
0    a    A
1    b    B
2    c    c
3    d  NaN
4  NaN  NaN

你可以使用。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

或直接在级数上，即df["col1"]。替换(di,原地= True)。

作为Nico Coallier(应用于多个列)和U10-Forward(使用apply风格的方法)提出的扩展，并将其总结为一行程序，我建议:

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()表达式中使用整个系列。除非我误解了它的行为，它按顺序处理系列而不是按位处理。 .get(x,x)表示映射字典中没有提到的值，否则.map()方法会将这些值视为Nan