使用字典重新映射 Pandas 列中的值，并保留 NaN-IT科技

摘要：问题描述：我有一本如下所示的字典：di = {1: "A", 2: "B"}我想将它应用到col1类似于以下的数据框的列： col1 col2 0 w a 1 1 2 2 2 NaN 要得到： ...

问题描述：

我有一本如下所示的字典：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

我怎样才能最好地做到这一点？

解决方案 1：

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

解决方案 2：

`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 答案（上面有链接）。

解决方案 3：

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

中的键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 的索引来引用第一和第三个位置。

解决方案 4：

DSM 有可接受的答案，但编码似乎并不适合所有人。这是一个适用于当前版本 pandas (截至 2018 年 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

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

解决方案 5：

给定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

解决方案 6：

TL;DR：使用`map`+`fillna`表示大`di`，使用`replace`表示小`di`

1. 替代方案：`np.select()`

如果重映射字典不是太大，另一个选择是numpy.select。的语法np.select需要单独的条件和替换值的数组/列表，因此的键和值di应该分开。

import numpy as np
df['col1'] = np.select((df[['col1']].values == list(di)).T, di.values(), df['col1'])

注意：如果重映射字典di非常大，这可能会遇到内存问题，因为正如您从上面的代码行看到的那样，(len(df), len(di))需要一个布尔形状的数组来评估条件。

2. `map`+`fillna`与`replace`. 哪个更好？

如果我们查看源代码，如果将字典传递给它，map则是一种优化方法，该方法调用 Cython 优化take_nd()函数进行替换并fillna()调用where()（另一种优化方法）来填充值。另一方面，replace()是用 Python 实现的，并使用字典循环。因此，如果字典很大，replace则可能比+慢数千倍。让我们通过以下示例来说明差异，其中在列中替换单个值（）（一个使用长度为 1000 的字典（），另一个使用长度为 1 的字典（））。map`fillna0di1`di2

df = pd.DataFrame({'col1': range(1000)})
di1 = {k: k+1 for k in range(-1000, 1)}
di2 = {0: 1}

%timeit df['col1'].map(di1).fillna(df['col1'])
# 1.19 ms ± 6.77 µs per loop (mean ± std. dev. of 7 runs, 1,000 loops each)

%timeit df['col1'].replace(di1)
# 41.4 ms ± 400 µs per loop (mean ± std. dev. of 7 runs, 100 loops each)

%timeit df['col1'].map(di2).fillna(df['col1'])
# 691 µs ± 27.9 µs per loop (mean ± std. dev. of 7 runs, 1,000 loops each)

%timeit df['col1'].replace(di2)
# 157 µs ± 3.34 µs per loop (mean ± std. dev. of 7 runs, 10,000 loops each)

如你所见，如果len(di)==1000，replace速度会慢 35 倍，但如果len(di)==1，速度会快 4.5 倍。随着重映射字典的大小di增加，这种差距会变得更大。

事实上，如果我们查看性能图，我们可以得出以下观察结果。这些图是使用每个图中固定的特定参数绘制的。您可以使用下面的代码来更改数据框的大小以查看不同的参数，但它会产生非常相似的图。

对于给定的数据框，无论重映射字典的大小如何， map+都会在几乎恒定的时间内进行替换，而随着重映射字典的大小增加，情况会变得更糟（左上图）。fillna`replace`
数据框中被替换的值的百分比对运行时间差异的影响很小。长度的影响di完全超过了它所产生的任何影响（右上图）。
对于给定的重映射字典，随着数据框大小的增加， map+fillna的表现会更好replace（左下图）。
同样，如果di很大，数据框的大小并不重要；map+比（右下图）fillna快得多。replace

性能图

用于生成图表的代码：

import numpy as np
import pandas as pd
from perfplot import plot
import matplotlib.pyplot as plt

kernels = [lambda df,di: df['col1'].replace(di), 
           lambda df,di: df['col1'].map(di).fillna(df['col1'])]
labels = ["replace", "map+fillna"]


# first plot
N, m = 100000, 20
plot(
    setup=lambda n: (pd.DataFrame({'col1': np.resize(np.arange(m*n), N)}), 
                     {k: (k+1)/2 for k in range(n)}),
    kernels=kernels, labels=labels,
    n_range=range(1, 21),
    xlabel='Length of replacement dictionary',
    title=f'Remapping values in a column (len(df)={N:,}, {100//m}% replaced)',
    equality_check=pd.Series.equals)
_, xmax = plt.xlim()
plt.xlim((0.5, xmax+1))
plt.xticks(np.arange(1, xmax+1, 2));


# second plot
N, m = 100000, 1000
di = {k: (k+1)/2 for k in range(m)}
plot(
    setup=lambda n: pd.DataFrame({'col1': np.resize(np.arange((n-100)*m//100, n*m//100), N)}),
    kernels=kernels, labels=labels,
    n_range=[1, 5, 10, 15, 25, 40, 55, 75, 100],
    xlabel='Percentage of values replaced',
    title=f'Remapping values in a column (len(df)={N:,}, len(di)={m})',
    equality_check=pd.Series.equals);


# third plot
m, n = 10, 0.01
di = {k: (k+1)/2 for k in range(m)}
plot(
    setup=lambda N: pd.DataFrame({'col1': np.resize(np.arange((n-1)*m, n*m), N)}),
    kernels=kernels, labels=labels,
    n_range=[2**k for k in range(6, 21)], 
    xlabel='Length of dataframe',
    logy=False,
    title=f'Remapping values in a column (len(di)={m}, {int(n*100)}% replaced)',
    equality_check=pd.Series.equals);

# fourth plot
m, n = 100, 0.01
di = {k: (k+1)/2 for k in range(m)}
plot(
    setup=lambda N: pd.DataFrame({'col1': np.resize(np.arange((n-1)*m, n*m), N)}),
    kernels=kernels, labels=labels,
    n_range=[2**k for k in range(6, 21)], 
    xlabel='Length of dataframe',
    title=f'Remapping values in a column (len(di)={m}, {int(n*100)}% replaced)',
    equality_check=pd.Series.equals);

解决方案 7：

您可以使用数据框中缺失的对来更新映射字典。例如：

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

解决方案 8：

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

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

希望它对某些人有用。

干杯

解决方案 9：

或者这样做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
>>>

解决方案 10：

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

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

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

解决方案 11：

作为 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() 表达式中使用整个系列。除非我误解了它的行为，否则它会按顺序处理系列，而不是按位处理。

这.get(x,x)解释了你在映射字典中没有提到的值，否则该方法将被视为.map()Nan

解决方案 12：

更原生的 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)