Python数据分析 | (23) 数据转换

本章到目前为止介绍的都是数据的重排。另一类重要操作则是过滤、清理以及其他的转换工作。

目录

1. 移除重复数据

2. 利用函数或映射进行数据转换

3. 替换值

4. 重命名轴索引

5. 离散化和面元划分

6. 检测和过滤异常值

7. 排列和随机采样

8. 计算指标/哑变量

---

1. 移除重复数据

DataFrame中出现重复行有多种原因。下面就是一个例子:

data = pd.DataFrame({'k1': ['one', 'two'] * 3 + ['two'],
                     'k2': [1, 1, 2, 3, 3, 4, 4]})
data

DataFrame的duplicated方法返回一个布尔型Series，表示各行是否是重复行 (前面出现过的行):

data.duplicated()

还有一个与此相关的drop_duplicates方法，它会返回一个DataFrame，重复 的数组会标为False:

data.drop_duplicates()

这两个方法默认会判断全部列，你也可以指定部分列进行重复项判断。假设 我们还有一列值，且只希望根据k1列过滤重复项:

data['v1'] = range(7)
print(data)
data.drop_duplicates(['k1'])

duplicated和drop_duplicates默认保留的是第一个出现的值组合。传入keep='last'则保留最后一个:

data.drop_duplicates(['k1', 'k2'], keep='last')

2. 利用函数或映射进行数据转换

对于许多数据集，你可能希望根据数组、Series或DataFrame列中的值来实 现转换工作。我们来看看下面这组有关肉类的数据:

data = pd.DataFrame({'food': ['bacon', 'pulled pork', 'bacon',
                              'Pastrami', 'corned beef', 'Bacon',
                              'pastrami', 'honey ham', 'nova lox'],
                     'ounces': [4, 3, 12, 6, 7.5, 8, 3, 5, 6]})
data

假设你想要添加一列表示该肉类食物来源的动物类型。我们先编写一个不同肉类到动物的映射:

meat_to_animal = {
  'bacon': 'pig',
  'pulled pork': 'pig',
  'pastrami': 'cow',
  'corned beef': 'cow',
  'honey ham': 'pig',
  'nova lox': 'salmon'
}

Series的map方法可以接受一个函数或含有映射关系的字典型对象，但是这 里有一个小问题，即有些肉类的首字母大写了，而另一些则没有。因此，我 们还需要使用Series的str.lower方法，将各个值转换为小写:

lowercased = data['food'].str.lower()
print(lowercased)
data['animal'] = lowercased.map(meat_to_animal)
data

我们也可以传入一个能够完成全部这些工作的函数:

data['food'].map(lambda x: meat_to_animal[x.lower()])

使用map是一种实现元素级转换以及其他数据清理工作的便捷方式。

3. 替换值

利用fillna方法填充缺失数据可以看做值替换的一种特殊情况。前面已经看 到，map可用于修改对象的数据子集，而replace则提供了一种实现该功能的 更简单、更灵活的方式。我们来看看下面这个Series:

data = pd.Series([1., -999., 2., -999., -1000., 3.])
data

-999这个值可能是一个表示缺失数据的标记值。要将其替换为pandas能够理 解的NA值，我们可以利用replace来产生一个新的Series(除非传入inplace=True，原地更改):

data.replace(-999, np.nan)

如果你希望一次性替换多个值，可以传入一个由待替换值组成的列表以及一个替换值:

data.replace([-999, -1000], np.nan)

要让每个值有不同的替换值，可以传递一个替换列表:

data.replace([-999, -1000], [np.nan, 0])

传入的参数也可以是字典:

data.replace({-999: np.nan, -1000: 0})

data.replace方法与data.str.replace不同，后者做的是字符串的 元素级替换。我们会在后面学习Series的字符串方法。

4. 重命名轴索引

跟Series中的值一样，轴标签也可以通过函数或映射进行转换，从而得到一 个新的不同标签的对象。轴还可以被就地修改，而无需新建一个数据结构。 接下来看看下面这个简单的例子:

data = pd.DataFrame(np.arange(12).reshape((3, 4)),
                    index=['Ohio', 'Colorado', 'New York'],
                    columns=['one', 'two', 'three', 'four'])
data

和Series一样，轴索引也有一个map方法：

transform = lambda x: x[:4].upper()
data.index.map(transform)

你可以将其赋值给index，这样就可以对DataFrame进行就地修改:

data.index = data.index.map(transform)
data

如果想要创建数据集的转换版(而不是修改原始数据)，比较实用的方法是rename:

data.rename(index=str.title, columns=str.upper)

特别说明一下，rename可以结合字典型对象实现对部分轴标签的更新:

data.rename(index={'OHIO': 'INDIANA'},
            columns={'three': 'peekaboo'})

rename可以实现复制DataFrame并对其索引和列标签进行赋值。如果希望就 地修改某个数据集，传入inplace=True即可:

data.rename(index={'OHIO': 'INDIANA'}, inplace=True)
data

5. 离散化和面元划分

为了便于分析，连续数据常常被离散化或拆分为“面元”(bin)。假设有一组 人员数据，而你希望将它们划分为不同的年龄组:

ages = [20, 22, 25, 27, 21, 23, 37, 31, 61, 45, 41, 32]

接下来将这些数据划分为“18到25”、“26到35”、“35到60”以及“60以上”几个面 元。要实现该功能，你需要使用pandas的cut函数:

bins = [18, 25, 35, 60, 100]
cats = pd.cut(ages, bins)
cats #ages中每个数值所属的区间 以及类别

pandas返回的是一个特殊的Categorical对象。结果展示了pandas.cut划分的 面元。你可以将其看做一组表示面元名称的字符串。它的底层含有一个表示 不同分类名称的类型数组，以及一个codes属性中的年龄数据的标签:

print(cats.codes)
print(cats.categories)
pd.value_counts(cats)

pd.value_counts(cats)是pandas.cut结果的面元计数。

跟“区间”的数学符号一样，圆括号表示开端，而方括号则表示闭端(包括)。哪边是闭端可以通过right=False进行修改:

pd.cut(ages, [18, 26, 36, 61, 100], right=False)

你可 以通过传递一个列表或数组到labels，设置自己的面元名称:

group_names = ['Youth', 'YoungAdult', 'MiddleAged', 'Senior']
pd.cut(ages, bins, labels=group_names)

如果向cut传入的是面元的数量而不是确切的面元边界，则它会根据数据的最 小值和最大值计算等长面元。下面这个例子中，我们将一些均匀分布的数据 分成四组:

data = np.random.rand(20)
pd.cut(data, 4, precision=2)

选项precision=2，限定小数只有两位。

qcut是一个非常类似于cut的函数，它可以根据样本分位数对数据进行面元划 分。根据数据的分布情况，cut可能无法使各个面元中含有相同数量的数据 点。而qcut由于使用的是样本分位数，因此可以得到大小基本相等的面元:

data = np.random.randn(1000)  # Normally distributed
cats = pd.qcut(data, 4)  # Cut into quartiles
print(cats)
pd.value_counts(cats)

与cut类似，你也可以传递自定义的分位数(0到1之间的数值，包含端点):

pd.qcut(data, [0, 0.1, 0.5, 0.9, 1.])

之后在讲解聚合和分组运算时会再次用到cut和qcut，因为这两个离散化 函数对分位和分组分析非常重要。

 

6. 检测和过滤异常值

过滤或变换异常值(outlier)在很大程度上就是运用数组运算。来看一个含有正态分布数据的DataFrame:

data = pd.DataFrame(np.random.randn(1000, 4))
data.describe()

假设你想要找出某列中绝对值大小超过3的值:

col = data[2]
col[np.abs(col) > 3]

要选出全部含有“超过3或-3的值”的行，你可以在布尔型DataFrame中使用any方法:

data[(np.abs(data) > 3).any(1)]

根据这些条件，就可以对值进行设置。下面的代码可以将值限制在区间-3到3以内:

data[np.abs(data) > 3] = np.sign(data) * 3 #>3的数设置为3 小于-3的数设置为-3
data.describe()

根据数据的值是正还是负，np.sign(data)可以生成1和-1:

np.sign(data).head()

7. 排列和随机采样

利用numpy.random.permutation函数可以轻松实现对Series或DataFrame的 列的排列工作(permuting，随机重排序)。通过需要排列的轴的长度调用permutation，可产生一个表示新顺序的整数数组:

df = pd.DataFrame(np.arange(5 * 4).reshape((5, 4)))
sampler = np.random.permutation(5)
sampler

 然后就可以在基于iloc的索引操作或take函数中使用该数组了:

print(df)
df.take(sampler)

如果不想用替换的方式选取随机子集，可以在Series和DataFrame上使用sample方法:

df.sample(n=3)

 要通过替换的方式产生样本(允许重复选择)，可以传递replace=True到sample:

choices = pd.Series([5, 7, -1, 6, 4])
draws = choices.sample(n=10, replace=True)
draws

 

8. 计算指标/哑变量

另一种常用于统计建模或机器学习的转换方式是:将分类变量(categorical variable)转换为“哑变量”或“指标矩阵”。

如果DataFrame的某一列中含有k个不同的值，则可以派生出一个k列矩阵或DataFrame(其值全为1和0)。pandas有一个get_dummies函数可以实现该 功能(其实自己动手做一个也不难)。使用之前的一个DataFrame例子:

df = pd.DataFrame({'key': ['b', 'b', 'a', 'c', 'a', 'b'],
                   'data1': range(6)})
print(df)
pd.get_dummies(df['key'])

有时候，你可能想给指标DataFrame的列加上一个前缀，以便能够跟其他数 据进行合并。get_dummies的prefix参数可以实现该功能:

dummies = pd.get_dummies(df['key'], prefix='key')
df_with_dummy = df[['data1']].join(dummies)
df_with_dummy

如果DataFrame中的某行同属于多个分类，则事情就会有点复杂。看一下MovieLens 1M数据集，后续会更深入地研究它:

mnames = ['movie_id', 'title', 'genres']
movies = pd.read_table('datasets/movielens/movies.dat', sep='::',
                       header=None, names=mnames)
movies[:10]

要为每个genre添加指标变量就需要做一些数据规整操作。首先，我们从数据 集中抽取出不同的genre值:

all_genres = []
for x in movies.genres:
    all_genres.extend(x.split('|'))
genres = pd.unique(all_genres)
genres

构建指标DataFrame的方法之一是从一个全零DataFrame开始:

zero_matrix = np.zeros((len(movies), len(genres)))
dummies = pd.DataFrame(zero_matrix, columns=genres)

现在，迭代每一部电影，并将dummies各行的条目设为1。要这么做，我们 使用dummies.columns来计算每个类型的列索引:

gen = movies.genres[0]
print(gen.split('|'))
dummies.columns.get_indexer(gen.split('|'))

然后，根据索引，使用.iloc设定值:

for i, gen in enumerate(movies.genres):
    indices = dummies.columns.get_indexer(gen.split('|'))
    dummies.iloc[i, indices] = 1

然后，和以前一样，再将其与movies合并起来:

movies_windic = movies.join(dummies.add_prefix('Genre_'))

movies_windic.iloc[0]

对于很大的数据，用这种方式构建多成员指标变量就会变得非常 慢。最好使用更低级的函数，将其写入NumPy数组，然后结果包装在DataFrame中。

一个对统计应用有用的秘诀是:结合get_dummies和诸如cut之类的离散化函 数:

np.random.seed(12345)
values = np.random.rand(10)
print(values)
bins = [0, 0.2, 0.4, 0.6, 0.8, 1]
pd.get_dummies(pd.cut(values, bins))

我们用numpy.random.seed，使这个例子具有确定性。后面会介绍pandas.get_dummies。