用字典重新映射熊猫列中的值

我有一本字典，看起来像这样： 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

我怎样才能最好地做到这一点？由于某种原因，与此相关的谷歌搜索术语仅向我显示了有关如何根据字典创建列的链接，反之亦然：-/

您可以使用.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)。

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最常用函数作为参数，但也可以选择字典或系列： Pandas.series.map的文档

非穷举映射

如果您有一个非详尽的映射，并且希望保留现有变量用于非匹配，则可以添加fillna：

df['col1'].map(di).fillna(df['col1'])

如@jpp的答案在这里： 通过字典有效地替换熊猫系列中的值

基准测试

在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速度大约比速度快10倍replace。

请注意，您的加速map会随数据而变化。最大的提速似乎是使用大词典和详尽的替换方法。有关更广泛的基准测试和讨论，请参见@jpp答案（上面链接）。

您的问题有点含糊。至少有三种解释：

1. 中的键di引用索引值
2. 中的键是di指df['col1']值
3. 中的键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的索引对其进行索引，它们指向第一位置和第三位置。

如果您有多个列要在数据数据帧中重新映射，则添加到此问题：

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

希望它对某人有用。

干杯

DSM已经接受了答案，但是编码似乎并不适合所有人。这是与当前版本的熊猫一起使用的版本（截至8/2018为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

pandas.DataFrame.replace的文档在这里。

或做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
>>> 

给定map的速度比替换（@JohnE的解决方案）要快，因此在打算将特定值映射到的非穷举映射时，您NaN需要格外小心。在这种情况下，正确的方法需要在您mask使用Series时执行.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

一个很好的完整解决方案，可以保留您的类标签的地图：

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

这样，您可以随时从labels_dict引用原始类标签。

作为对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

一种更本地的熊猫方法是应用如下替换函数：

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)