使用dict重新映射pandas列中的值

Question

我有一个字典,看起来像这样: 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制作列的链接,反之亦然: - /

Answer 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).

Answer 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系列中的值

基准

在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答案(上面链接)以获得更广泛的基准和讨论.

Answer 3

你的问题有点含糊不清.至少有三种解释:

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的索引指向第一和第三位置.

Answer 4

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

Answer 5

DSM 有公认的答案，但编码似乎并不适合所有人。这是一个适用于当前版本的熊猫（0.23.4 截至 2018 年 8 月）：

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的文档在这里。

Answer 6

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

\n\n

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

\n

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

\n

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

\n

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

\n

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

\n

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

\n

df = pd.DataFrame({\'col1\': range(1000)})\ndi1 = {k: k+1 for k in range(-1000, 1)}\ndi2 = {0: 1}\n\n%timeit df[\'col1\'].map(di1).fillna(df[\'col1\'])\n# 1.19 ms \xc2\xb1 6.77 \xc2\xb5s per loop (mean \xc2\xb1 std. dev. of 7 runs, 1,000 loops each)\n\n%timeit df[\'col1\'].replace(di1)\n# 41.4 ms \xc2\xb1 400 \xc2\xb5s per loop (mean \xc2\xb1 std. dev. of 7 runs, 100 loops each)\n\n%timeit df[\'col1\'].map(di2).fillna(df[\'col1\'])\n# 691 \xc2\xb5s \xc2\xb1 27.9 \xc2\xb5s per loop (mean \xc2\xb1 std. dev. of 7 runs, 1,000 loops each)\n\n%timeit df[\'col1\'].replace(di2)\n# 157 \xc2\xb5s \xc2\xb1 3.34 \xc2\xb5s per loop (mean \xc2\xb1 std. dev. of 7 runs, 10,000 loops each)\n

\n

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

\n

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

\n

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

\n

\n

用于生成绘图的代码：

\n

import numpy as np\nimport pandas as pd\nfrom perfplot import plot\nimport matplotlib.pyplot as plt\n\nkernels = [lambda df,di: df[\'col1\'].replace(di), \n           lambda df,di: df[\'col1\'].map(di).fillna(df[\'col1\'])]\nlabels = ["replace", "map+fillna"]\n\n\n# first plot\nN, m = 100000, 20\nplot(\n    setup=lambda n: (pd.DataFrame({\'col1\': np.resize(np.arange(m*n), N)}), \n                     {k: (k+1)/2 for k in range(n)}),\n    kernels=kernels, labels=labels,\n    n_range=range(1, 21),\n    xlabel=\'Length of replacement dictionary\',\n    title=f\'Remapping values in a column (len(df)={N:,}, {100//m}% replaced)\',\n    equality_check=pd.Series.equals)\n_, xmax = plt.xlim()\nplt.xlim((0.5, xmax+1))\nplt.xticks(np.arange(1, xmax+1, 2));\n\n\n# second plot\nN, m = 100000, 1000\ndi = {k: (k+1)/2 for k in range(m)}\nplot(\n    setup=lambda n: pd.DataFrame({\'col1\': np.resize(np.arange((n-100)*m//100, n*m//100), N)}),\n    kernels=kernels, labels=labels,\n    n_range=[1, 5, 10, 15, 25, 40, 55, 75, 100],\n    xlabel=\'Percentage of values replaced\',\n    title=f\'Remapping values in a column (len(df)={N:,}, len(di)={m})\',\n    equality_check=pd.Series.equals);\n\n\n# third plot\nm, n = 10, 0.01\ndi = {k: (k+1)/2 for k in range(m)}\nplot(\n    setup=lambda N: pd.DataFrame({\'col1\': np.resize(np.arange((n-1)*m, n*m), N)}),\n    kernels=kernels, labels=labels,\n    n_range=[2**k for k in range(6, 21)], \n    xlabel=\'Length of dataframe\',\n    logy=False,\n    title=f\'Remapping values in a column (len(di)={m}, {int(n*100)}% replaced)\',\n    equality_check=pd.Series.equals);\n\n# fourth plot\nm, n = 100, 0.01\ndi = {k: (k+1)/2 for k in range(m)}\nplot(\n    setup=lambda N: pd.DataFrame({\'col1\': np.resize(np.arange((n-1)*m, n*m), N)}),\n    kernels=kernels, labels=labels,\n    n_range=[2**k for k in range(6, 21)], \n    xlabel=\'Length of dataframe\',\n    title=f\'Remapping values in a column (len(di)={m}, {int(n*100)}% replaced)\',\n    equality_check=pd.Series.equals);\n

\n