Python 数据分析5

数据规整化

　　清理

　　转换

　　合并

　　重塑

数据库风格的DataFrame合并

pd.merge(df1, df2)
# 默认会将重叠列的列名当作键，最好显式的指定下，另外merge默认是使用的inner join
 
pd.merge(df1, df2, on='key') 
 
pd.merge(df3, df4, left_on='lkey', right_on='rkey')
# 如果两个对象的列名不同，需要分别指定，如上df3里面的是lkey，df4里面的是rkey
 
pd.merge(df1, df2, how='outer')
# how参数用来指定连接方式，总共是inner、left、right、outer四种方式
 
pd.merge(df1, df2, on='key', how='left')
pd.merge(df1, df2, how='inner')
# 多对多合并如此简单
 
pd.merge(left, right, on=['key1', 'key2'], how='outer')
# 多个合并列的时候，列表
 
pd.merge(left, right, on='key1')
# 需要注意的是如果以key1进行连接，但是两个对象里面有其他相同列名的列存在， left会被表示成key_x，right会被表示成key_y
 
pd.merge(left, right, on='key1', suffixes=('_left', '_right'))
# 可以自定义的为左右设定后缀，这样相当于定制了列名

索引上的合并

pd.merge(left1, right1, left_on='key', right_index=True)
# 左边是的key，右边的是index
 
pd.merge(left1, right1, left_on='key', right_index=True, how='outer')
# 合并方式跟之前一样还是inner、outer、left、right
 
pd.merge(lefth, righth, left_on=['key1', 'key2'], right_index=True)
# 合并键是多个列用列表指明
 
pd.merge(lefth, righth, left_on=['key1', 'key2'], right_index=True, how='outer')
# 同样可以设置合并方式
 
pd.merge(left2, right2, how='outer', left_index=True, right_index=True)
# 两个合并对象都通过index连接
 
left2.join(right2, how='outer')
# dataframe里面提供了join方法，用来更方便的实现按索引合并，不过join支持的是左连接
 
left1.join(right1, on='key')
# 还支持参数dataframe的索引跟调用dataframe的列进行连接
 
left2.join([right2, another])
left2.join([right2, another], how='outer')
# 对于简单的索引合并，你还可以向join传入一组DataFrame

轴向连接

刚刚上面讲了数据层的横向连接合并，现在是关于数据堆叠。NumPy的concatenation函数可以用NumPy数组来做：

arr = np.arange(12).reshape((3, 4))
np.concatenate([arr, arr], axis=1)
# 默认axis=0，axis为1的时候就会变成横向的拼接

而在pandas里面提供了concat函数

s1 = pd.Series([0, 1], index=['a', 'b'])
s2 = pd.Series([2, 3, 4], index=['c', 'd', 'e'])
s3 = pd.Series([5, 6], index=['f', 'g'])
 
pd.concat([s1, s2, s3])
# concat可以将值和索引粘合在一起

pd.concat([s1, s2, s3], axis=1)
# concat是在axis=0上工作的，最终产生一个新的Series。如果传入axis=1，则结果就会变成一个DataFrame（axis=1是列）
 
pd.concat([s1, s2, s3], axis=1)

pd.concat([s1, s4], axis=1, join='inner')
# join='inner' 可以得到两个对象的交集
 
pd.concat([s1, s4], axis=1, join_axes=[['a', 'c', 'b', 'e']])
# 你可以通过join_axes指定要在其它轴上使用的索引
# 会建立在另外一个索引上
 
result = pd.concat([s1, s1, s3], keys=['one','two', 'three'])
result.unstack()
#有个问题，参与连接的片段在结果中区分不开。假设你想要在连接轴上创建一个层次化索引。使用keys参数即可达到这个目的

pd.concat([s1, s2, s3], axis=1, keys=['one','two', 'three'])
# 如果沿着axis=1对Series进行合并，则keys就会成为DataFrame的列头

df1 = pd.DataFrame(np.arange(6).reshape(3, 2), index=['a', 'b', 'c'], columns=['one', 'two'])
df2 = pd.DataFrame(5 + np.arange(4).reshape(2, 2), index=['a', 'c'],columns=['three', 'four'])
pd.concat([df1, df2], axis=1, keys=['level1', 'level2'])
# 在dataframe里面也是同理
 
pd.concat({'level1': df1, 'level2': df2}, axis=1)
# 如果传入的不是列表而是字典，则健值就变成keys
 
pd.concat([df1, df2], axis=1, keys=['level1', 'level2'], names=['upper', 'lower'])
此外还有两个用于管理层次化索引创建方式的参数（参见表8-3）。举个例子，我们可以用names参数命名创建的轴级别
 
df1 = pd.DataFrame(np.random.randn(3, 4), columns=['a', 'b', 'c', 'd'])
df2 = pd.DataFrame(np.random.randn(2, 3), columns=['b', 'd', 'a'])
pd.concat([df1, df2], ignore_index=True)
# DataFrame的行索引不包含任何相关数据，在这种情况下，传入ignore_index=True即可

合并重复数据

还有一种数据组合问题不能用简单的合并（merge）或连接（concatenation）运算来处理。比如说，你可能有索引全部或部分重叠的两个数据集。举个有启发性的例子，我们使用NumPy的where函数，它表示一种等价于面向数组的if-else：

a = pd.Series([np.nan, 2.5, np.nan, 3.5, 4.5, np.nan], index=['f', 'e', 'd', 'c', 'b', 'a'])
b = pd.Series(np.arange(len(a), dtype=np.float64), index=['f', 'e', 'd', 'c', 'b', 'a'])
b[-1] = np.nan
np.where(pd.isnull(a), b, a)
# array([ 0. ,  2.5,  2. ,  3.5,  4.5,  nan])
where(if a then a else b)
 
b[:-2].combine_first(a[2:])
# 以b为标准，不存在的索引用a内的索引
a    NaN
b    4.5
c    3.0
d    2.0
e    1.0
f    0.0

对于dataframe，也是同样的

df1 = pd.DataFrame({'a': [1., np.nan, 5., np.nan], 'b': [np.nan, 2., np.nan, 6.], 'c': range(2, 18, 4)})
df2 = pd.DataFrame({'a': [5., 4., np.nan, 3., 7.], 'b': [np.nan, 3., 4., 6., 8.]})
df1.combine_first(df2)

重塑层次化索引

stack：将数据的列“旋转”为行。
unstack：将数据的行“旋转”为列。

data = pd.DataFrame(np.arange(6).reshape((2, 3)), index=pd.Index(['Ohio','Colorado'], name='state'),columns=pd.Index(['one', 'two', 'three'],name='number'))
 
result = data.stack()
# 对该数据使用stack方法即可将列转换为行，得到一个Series
result.unstack()
# 对于一个层次化索引的Series，你可以用unstack将其重排为一个DataFrame

result.unstack(0)
result.unstack('state')
# 默认情况下，unstack操作的是最内层（stack也是如此）。传入分层级别的编号或名称即可对其它级别进行unstack操作
 
s1 = pd.Series([0, 1, 2, 3], index=['a', 'b', 'c', 'd'])
s2 = pd.Series([4, 5, 6], index=['c', 'd', 'e'])
data2 = pd.concat([s1, s2], keys=['one', 'two'])
data2.unstack()
# 如果不是所有的级别值都能在各分组中找到的话，则unstack操作可能会引入缺失数据
 
data2.unstack().stack()
# stack默认会滤除缺失数据，因此该运算是可逆的
data2.unstack().stack(dropna=False)
# 可以通过参数来取消滤缺失数据

df = pd.DataFrame({'left': result, 'right': result + 5}, columns=pd.Index(['left', 'right'], name='side'))
df.unstack('state')
# 在对DataFrame进行unstack操作时，作为旋转轴的级别将会成为结果中的最低级别
 
df.unstack('state').stack('side')
# 当调用stack，我们可以指明轴的名字

'长格式'旋转为'宽格式'

pivoted = data.pivot('date', 'item', 'value')
# pivot内(行索引， 列索引， 值)
 
pivoted = data.pivot('date', 'item')
#如果有两个同时需要重塑的数据列，忽略最后一个参数，得到的DataFrame就会带有层次化的列
 
unstacked = ldata.set_index(['date', 'item']).unstack('item')
# pivot其实就是用set_index创建层次化索引，再用unstack重塑

将'宽格式'旋转为'长格式'

旋转DataFrame的逆运算是pandas.melt。它不是将一列转换到多个新的DataFrame，而是合并多个列成为一个，产生一个比输入长的DataFrame

df = pd.DataFrame({'key': ['foo', 'bar', 'baz'], 'A': [1, 2, 3], 'B': [4, 5, 6], 'C': [7, 8, 9]})
melted = pd.melt(df, ['key'])
# key列可能是分组指标，其它的列是数据值。当使用pandas.melt，我们必须指明哪些列是分组指标。

reshaped = melted.pivot('key', 'variable', 'value')
# 使用pivot，可以重塑回原来的样子
 
reshaped.reset_index()
# 因为pivot的结果从列创建了一个索引，用作行标签，我们可以使用reset_index将数据移回列
 
pd.melt(df, id_vars=['key'], value_vars=['A', 'B'])
# 还可以指定列的子集，作为值的列
 
pd.melt(df, value_vars=['A', 'B', 'C'])
pd.melt(df, value_vars=['key', 'A', 'B'])
# pandas.melt也可以不用分组指标

移除重复数据

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

data = pd.DataFrame({'k1': ['one', 'two'] * 3 + ['two'], 'k2': [1, 1, 2, 3, 3, 4, 4]})
data.duplicated()
 
data.drop_duplicates()
# drop_duplicates重复的列移除掉，返回dataframe，移除的列是后出现的重复列，即上面的值为True的

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

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

data.drop_duplicates(['k1', 'k2'], keep='last')
# duplicated和drop_duplicates默认保留的是第一个出现的值组合。传入keep='last'则保留最后一个

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

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]})

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

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

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

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

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

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

替换值

data = pd.Series([1., -999., 2., -999., -1000., 3.])
data.replace(-999, np.nan)
# 将-999替换成NA值
 
data.replace([-999, -1000], np.nan)
# 将多个值转换成NA值
 
data.replace([-999, -1000], [np.nan, 0])
#要让每个值有不同的替换值，可以传递一个替换列表
 
data.replace({-999: np.nan, -1000: 0})
# 传入的参数也可以是字典

笔记：data.replace方法与data.str.replace不同，后者做的是字符串的元素级替换。

重命名轴索引

data = pd.DataFrame(np.arange(12).reshape((3, 4)), index=['Ohio', 'Colorado', 'New York'], columns=['one', 'two', 'three', 'four'])
transform = lambda x: x[:4].upper()
data.index.map(transform)
 
data.index = data.index.map(transform)  # 修改index

如果想要创建数据集的转换版（而不是修改原始数据），比较实用的方法是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)

离散化和面元划分

为了便于分析，连续数据常常被离散化或拆分为面元。

ages = [20, 22, 25, 27, 21, 23, 37, 31, 61, 45, 41, 32]
 
bins = [18, 25, 35, 60, 100]
cats = pd.cut(ages, bins)
# 将age列表数据划分到面元，相当于归类到区间

cats.codes
# array([0, 0, 0, 1, 0, 0, 2, 1, 3, 2, 2, 1], dtype=int8)
 
cats.categories
# IntervalIndex([(18, 25], (25, 35], (35, 60], (60, 100]], closed='right', dtype='interval[int64]')
 
pd.value_counts(cats)

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

cats = pd.cut(ages, bins, 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)
cats = pd.qcut(data, 4)
 
pd.value_counts(cats)
# 可以发现四个区间是一样大的都是250个元素

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

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