用字典重新映射pandas列中的值，保留nan

小开

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

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的索引中，它们指向第一行和第三个位置。

小开

最佳答案

您可以使用.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通常以函数作为参数，但它也可以接受字典或系列

简单的映射

如果你有一个非穷尽的映射，并且希望保留不匹配的现有变量，你可以添加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大约比replace快10倍。

请注意，使用map的加速将随着数据的不同而不同。最大的加速似乎是使用大字典和详尽的替换。参见@jpp的回答(上面有链接)，了解更广泛的基准测试和讨论。

小开

如果你在一个数据框架中有多个列需要重新映射，那么这个问题就更严重了:

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

希望对别人有用。

干杯

小开

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

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)

小开

DSM有一个公认的答案，但编码似乎并不适用于每个人。下面是一个适用于当前版本的熊猫(截至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在这里的文档。

小开

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

小开

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

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

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

小开

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

df.loc[:,['col1','col2']].transform(lambda x: x.map(lambda x: {1: "A", 2: "B"}.get(x,x))

.transform()将每个列作为一个系列处理。与# eyz1相反，它传递在数据帧中聚合的列。

因此，您可以应用系列方法map()。

最后，多亏了U10，我发现了这个行为，你可以在.get()表达式中使用整个Series。除非我误解了它的行为，它是按顺序处理序列，而不是按位处理 # eyz0表示您在映射字典中没有提到的值，否则将被.map()方法

视为Nan

小开

考虑到map比替换(@JohnE的解决方案)更快，你需要小心使用非穷举映射，您打算将特定的值映射到NaN。在这种情况下，正确的方法需要在使用.fillna时使用mask，否则将撤销到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

小开

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

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

用字典重新映射pandas列中的值，保留nan

map可以比replace快得多

详尽的映射

简单的映射

基准

`map`可以比`replace`快得多