39_Pandas.Serise用map方法替换列元素

39_Pandas.Serise用map方法替换列元素

pandas.Series的map，通过将函数作为参数传递给pandas.Series的每个元素的函数。

• 06_Pandas中map(),applymap(),apply()函数的使用方法

可以将字典类型dict指定为map（）的参数。

替换元素的方法具有replace（），但是如果要使用不同的值替换pandas.Series或pandas.DataFrame列（= pandas.Series）中的所有元素，则map（）会更好。

• 24_Pandas.DataFrame,Series元素值的替换（replace）

这里，

• 元素替换中map（）和replace（）之间的区别
  • 速度比较
• 使用map（）的示例：将定性数据转换为定量数据

将予以描述。 以下面的数据为例。

import pandas as pd

df = pd.read_csv('./data/39/sample_pandas_normal.csv')

print(df)
#       name  age state  point
# 0    Alice   24    NY     64
# 1      Bob   42    CA     92
# 2  Charlie   18    CA     70
# 3     Dave   68    TX     70
# 4    Ellen   24    CA     88
# 5    Frank   30    NY     57

s = df['state']
print(s)
# 0    NY
# 1    CA
# 2    CA
# 3    TX
# 4    CA
# 5    NY
# Name: state, dtype: object

元素替换中map（）和replace（）之间的区别

如果在map（）的参数中指定了字典dict（{key：value}），则将元素匹配键替换为value。

s_map_all = s.map({'NY': 'NewYork', 'CA': 'California', 'TX': 'Texas'})
print(s_map_all)
# 0       NewYork
# 1    California
# 2    California
# 3         Texas
# 4    California
# 5       NewYork
# Name: state, dtype: object

可以将字典指定为replace（）的参数。如果pandas.Series的所有元素都被替换，则结果类似于replace（）。

s_replace_all = s.replace({'NY': 'NewYork', 'CA': 'California', 'TX': 'Texas'})
print(s_replace_all)
# 0       NewYork
# 1    California
# 2    California
# 3         Texas
# 4    California
# 5       NewYork
# Name: state, dtype: object

如果字典键未涵盖pandas.Series中所有元素的值，则结果将不同。 在map（）中，未被替换的值变为NaN。使用replace（）时，原始值保持不变。

s_map = s.map({'NY': 'NewYork'})
print(s_map)
# 0    NewYork
# 1        NaN
# 2        NaN
# 3        NaN
# 4        NaN
# 5    NewYork
# Name: state, dtype: object

s_replace = s.replace({'NY': 'NewYork'})
print(s_replace)
# 0    NewYork
# 1         CA
# 2         CA
# 3         TX
# 4         CA
# 5    NewYork
# Name: state, dtype: object

结合使用map（）和update（），可以将未替换的元素保留为其原始值。但是，使用update（）会修改原始对象，这与在replace（）中将参数replace设置为True的行为相同。

s_copy = s.copy()
s_copy.update(s_copy.map({'NY': 'NewYork'}))
print(s_copy)
# 0    NewYork
# 1         CA
# 2         CA
# 3         TX
# 4         CA
# 5    NewYork
# Name: state, dtype: object

s_copy = s.copy()
s_copy.replace({'NY': 'NewYork'}, inplace=True)
print(s_copy)
# 0    NewYork
# 1         CA
# 2         CA
# 3         TX
# 4         CA
# 5    NewYork
# Name: state, dtype: object

速度比较

使用Jupyter Notebook的％timeit进行了简单的速度比较。 如果所有元素都被替换，则Map（）比replace（）更快。

%timeit s.map({'NY': 'NewYork', 'CA': 'California', 'TX': 'Texas'})
# 345 µs ± 14 µs per loop (mean ± std. dev. of 7 runs, 1000 loops each)

%timeit s.replace({'NY': 'NewYork', 'CA': 'California', 'TX': 'Texas'})
# 519 µs ± 15.9 µs per loop (mean ± std. dev. of 7 runs, 1000 loops each)

与update（）结合使用时，replace（）比map（）更快。

s_copy = s.copy()
%timeit s_copy.update(s_copy.map({'NY': 'NewYork'}))
# 643 µs ± 21.4 µs per loop (mean ± std. dev. of 7 runs, 1000 loops each)

s_copy = s.copy()
%timeit s_copy.replace({'NY': 'NewYork'}, inplace=True)
# 230 µs ± 10 µs per loop (mean ± std. dev. of 7 runs, 1000 loops each)

还有报告说，即使使用update（），map（）也会更快，其结果取决于原始pandas.Series的大小和指定替换的字典的大小。

特别是，replace（）的变化取决于指定替换的字典的大小。

s_copy = s.copy()
%timeit s_copy.update(s_copy.map({'NY': 'NewYork', 'CA': 'California', 'TX': 'Texas'}))
# 627 µs ± 10.9 µs per loop (mean ± std. dev. of 7 runs, 1000 loops each)

s_copy = s.copy()
%timeit s_copy.replace({'NY': 'NewYork', 'CA': 'California', 'TX': 'Texas'}, inplace=True)
# 441 µs ± 22.1 µs per loop (mean ± std. dev. of 7 runs, 1000 loops each)

如果只替换一次小数据没有太大的区别，但是如果对海量数据重复相同的替换过程，则速度会很有效，因此在实际替换的情况下进行映射可能要尝试（）和replace（）在决定使用哪一个之前。 如果要用不同的值替换所有元素，则Map（）通常会更快。

使用map（）的示例：将定性数据转换为定量数据

使用map（）的常见示例是将一串定性数据（类别数据）转换为许多定量数据时。 当将其用作机器学习数据时，将示例中的字符串（例如地名和性别划分（男性，女性））替换为0和1的数值。

s_map_num = s.map({'NY': 0, 'CA': 1, 'TX': 2})
print(s_map_num)
# 0    0
# 1    1
# 2    1
# 3    2
# 4    1
# 5    0
# Name: state, dtype: int64

由于map（）没有参数位置来更新原始对象，因此当用map（）替换pandas.DataFrame的列时，请将其分配给原始列。

df['state'] = df['state'].map({'NY': 0, 'CA': 1, 'TX': 2})
print(df)
#       name  age  state  point
# 0    Alice   24      0     64
# 1      Bob   42      1     92
# 2  Charlie   18      1     70
# 3     Dave   68      2     70
# 4    Ellen   24      1     88
# 5    Frank   30      0     57

print(df['state'].dtype)
# int64

有一个名为pandas.get_dummies（）的函数，用于将定性数据（类别变量）转换为虚拟变量。