数据科学包-Day2-pandas(三)

1026-徐同学

发表文章数:41

首页 » 数据科学库 » 正文

重新索引

import pandas as pd
import numpy as np

Series

s = pd.Series([1, 3, 5, 6, 8], index=list('acefh'))
s
s.reindex(list('abcdefgh'))
s.reindex(list('abcdefgh'), fill_value=0)
#method='bfill'
s.reindex(list('abcdefgh'), method='ffill')

DataFrame

df = pd.DataFrame(np.random.randn(4, 6), index=list('ADFH'), columns=['one', 'two', 'three', 'four', 'five', 'six'])
df
df2 = df.reindex(index=list('ABCDEFGH'))
df2
df.loc['A']['one'] = 100
df
df.reindex(columns=['one', 'three', 'five', 'seven'])
df.reindex(columns=['one', 'three', 'five', 'seven'], fill_value=0)
# fill method 只对行有效
df.reindex(columns=['one', 'three', 'five', 'seven'], method='ffill')
df.reindex(index=list('ABCDEFGH'), method='ffill')

丢弃部分数据

df = pd.DataFrame(np.random.randn(4, 6), index=list('ABCD'), columns=['one', 'two', 'three', 'four', 'five', 'six'])
df
df.drop('A')
df2 = df.drop(['two', 'four'], axis=1)
df2
# 数据拷贝
df.iloc[0, 0] = 100
df

广播运算

df = pd.DataFrame(np.arange(12).reshape(4, 3), index=['one', 'two', 'three', 'four'], columns=list('ABC'))
df
df.loc['one']
df - df.loc['one']

函数应用
apply: 将数据按行或列进行计算
applymap: 将数据按元素为进行计算

df = pd.DataFrame(np.arange(12).reshape(4, 3), index=['one', 'two', 'three', 'four'], columns=list('ABC'))
df
# 每一列作为一个 Series 作为参数传递给 lambda 函数
df.apply(lambda x: x.max() - x.min())
# 每一行作为一个 Series 作为参数传递给 lambda 函数
df.apply(lambda x: x.max() - x.min(), axis=1)
# 返回多个值组成的 Series
def min_max(x):
    return pd.Series([x.min(), x.max()], index=['min', 'max'])
df.apply(min_max, axis=1)
# applymap: 逐元素运算
df = pd.DataFrame(np.random.randn(4, 3), index=['one', 'two', 'three', 'four'], columns=list('ABC'))
df
formater = '{0:.02f}'.format
# formater = lambda x: '%.02f' % x
df.applymap(formater)

排序和排名

df = pd.DataFrame(np.random.randint(1, 10, (4, 3)), index=list('ABCD'), columns=['one', 'two', 'three'])
df
df.sort_values(by='one')
s = pd.Series([3, 6, 2, 6, 4])
s.rank()
s.rank(method='first', ascending=False)

数据唯一性及成员资格
适用于 Series

s = pd.Series(list('abbcdabacad'))
s
s.unique()
s.value_counts()
s.isin(['a', 'b', 'c'])

索引
行索引
列索引
索引的分类
重复索引的处理

s = pd.Series(np.random.rand(5), index=list('abcde'))
s
s.index
s.index.name = 'alpha'
s
df = pd.DataFrame(np.random.randn(4, 3), columns=['one', 'two', 'three'])
df
df.index
df.columns

重复索引

s = pd.Series(np.arange(6), index=list('abcbda'))
s
s['a']
s['c']
s.index.is_unique
s.index.unique()
s.groupby(s.index).sum()

层次化索引
可以使数据在一个轴上有多个索引级别。即可以用二维的数据表达更高维度的数据,使数据组织方式更清晰。它使用 pd.MultiIndex 类来表示。

层次化索引有什么作用?
比如我们在分析股票数据,我们的一级行索引可以是日期;二级行索引可以是股票代码,列索引可以是股票的交易量,开盘价,收盘价等等。这样我们就可以把多个股票放在同一个时间维度下进行考察和分析。

Series 多层索引

a = [['a', 'a', 'a', 'b', 'b', 'c', 'c'], [1, 2, 3, 1, 2, 2, 3]]
tuples = list(zip(*a))
tuples
index = pd.MultiIndex.from_tuples(tuples, names=['first', 'second'])
index
s = pd.Series(np.random.randn(7), index=index)
s
s.index
s.index.levels[0]
s.index.levels[1]
s['b']
s['b':'c']
s[['b', 'a']]
s['b', 1]
s[:, 2]

DataFrame 多层索引

df = pd.DataFrame(np.random.randint(1, 10, (4, 3)), 
                  index=[['a', 'a', 'b', 'b'], [1, 2, 1, 2]], 
                  columns=[['one', 'one', 'two'], ['blue', 'red', 'blue']])
df.index.names = ['row-1', 'row-2']
df.columns.names = ['col-1', 'col-2']
df
df.loc['a']
type(df.loc['a'])
df.loc['a', 1]
df.loc['a', 1].index

索引交换及排序

df
df2 = df.swaplevel('row-1', 'row-2')
df2
df2.sortlevel(0)

按照索引级别进行统计

df
df.sum(level=0)
df.sum(level=1)
df2.sum(level=0)

索引与列的转换

df = pd.DataFrame({
        'a': range(7),
        'b': range(7, 0, -1),
        'c': ['one', 'one', 'one', 'two', 'two', 'two', 'two'],
        'd': [0, 1, 2, 0, 1, 2, 3]
    })
df
df.set_index('c')
df2 = df.set_index(['c', 'd'])
df2
df3 = df2.reset_index().sort_index('columns')
df3
(df3 == df)
pd.IndexSlice

分组计算

import pandas as pd
import numpy as np

分组计算
分组计算三步曲:拆分 -> 应用 -> 合并

拆分:根据什么进行分组?
应用:每个分组进行什么样的计算?
合并:把每个分组的计算结果合并起来。

df = pd.DataFrame({'key1': ['a', 'a', 'b', 'b', 'a'],
                  'key2': ['one', 'two', 'one', 'two', 'one'],
                  'data1': np.random.randint(1, 10, 5),
                  'data2': np.random.randint(1, 10, 5)})
df

对 Series 进行分组
通过索引对齐关联起来

grouped = df['data1'].groupby(df['key1'])
grouped.mean()
df['data1'].groupby([df['key1'], df['key2']]).mean()

对 DataFrame 进行分组

df.groupby('key1').mean()
means = df.groupby(['key1', 'key2']).mean()['data1']
means
means.unstack()
df.groupby(['key1', 'key2'])['data1'].mean()

每个分组的元素个数

df.groupby(['key1', 'key2']).size()

对分组进行迭代

for name, group in df.groupby('key1'):
    print name
    print group
for name, group in df.groupby(['key1', 'key2']):
print name
print group
 

转化为字典

d = dict(list(df.groupby('key1')))
d
d['a']

按列分组

df.dtypes
grouped = df.groupby(df.dtypes, axis=1)
dict(list(grouped))
df = pd.DataFrame(np.random.randint(1, 10, (5, 5)), 
                  columns=['a', 'b', 'c', 'd', 'e'], 
                  index=['Alice', 'Bob', 'Candy', 'Dark', 'Emily'])
df
df.ix[1, 1:3] = np.NaN
df
mapping = {'a': 'red', 'b': 'red', 'c': 'blue', 'd': 'orange', 'e': 'blue'}
grouped = df.groupby(mapping, axis=1)
grouped.sum()
grouped.count()
grouped.size()

通过函数来分组
当函数作为分组依据时,数据表里的每个索引(可以是行索引,也可以是列索引)都会调用一次函数,函数的返回值作为分组的索引,即相同的返回值分在同一组。

df = pd.DataFrame(np.random.randint(1, 10, (5, 5)), 
                  columns=['a', 'b', 'c', 'd', 'e'], 
                  index=['Alice', 'Bob', 'Candy', 'Dark', 'Emily'])
df
def _dummy_group(idx):
    print idx
    return idx
df.groupby(_dummy_group)
df.groupby(_dummy_group, axis=1)
grouped = df.groupby(len)
grouped.sum()
grouped.size()
grouped.count()

多级索引数据根据索引级别来分组

columns = pd.MultiIndex.from_arrays([['China', 'USA', 'China', 'USA', 'China'],
                                     ['A', 'A', 'B', 'C', 'B']], names=['country', 'index'])
df = pd.DataFrame(np.random.randint(1, 10, (5, 5)), columns=columns)
df
df.groupby(level='country', axis=1).count()
df.groupby(level='country', axis=1).sum()
df.groupby(level='index', axis=1).count()

数据聚合
分组运算,先根据一定规则拆分后的数据,然后对数据进行聚合运算,如前面见到的 mean(), sum() 等就是聚合的例子。聚合时,拆分后的第一个索引指定的数据都会依次传给聚合函数进行运算。最后再把运算结果合并起来,生成最终结果。

聚合函数除了内置的 sum(), min(), max(), mean() 等等之外,还可以自定义聚合函数。自定义聚合函数时,使用 agg() 或 aggregate() 函数。

内置聚合函数

df = pd.DataFrame({'key1': ['a', 'a', 'b', 'b', 'a'],
                  'key2': ['one', 'two', 'one', 'two', 'one'],
                  'data1': np.random.randint(1, 10, 5),
                  'data2': np.random.randint(1, 10, 5)})
df
df['data1'].groupby(df['key1']).sum()

自定义聚合函数

def peak_verbose(s):
    print type(s)
    return s.max() - s.min()
grouped = df.groupby('key1')
grouped.agg(peak_verbose)

应用多个聚合函数

grouped['data1', 'data2'].agg(['mean', 'std', peak])
# 给聚合后的列取名
grouped['data1'].agg([('agerage', 'mean'), ('max-range', peak)])

给不同的列应用不同的聚合函数
使用 dict 作为参数来实现

d = {'data1': ['mean', peak, 'max', 'min'],
     'data2': 'sum'}
grouped.agg(d)

重置索引

grouped.agg(d).reset_index()
df.groupby('key1', as_index=False).agg(d)

分组运算和转换
groupby 是特殊的分组运算。更一般的分组运算包括 “拆分 – 应用 – 合并”。这里介绍 transform() 和 apply() 来实现分组运算。
transform

df = pd.DataFrame({'key1': ['a', 'a', 'b', 'b', 'a'],
                  'key2': ['one', 'two', 'one', 'two', 'one'],
                  'data1': np.random.randint(1, 10, 5),
                  'data2': np.random.randint(1, 10, 5)})
df
# 给 df 每行都添加一个以 key1 分组后的平均值
k1_mean = df.groupby('key1').mean().add_prefix('mean_')
k1_mean
pd.merge(df, k1_mean, left_on='key1', right_index=True)
# 使用 transform 简化处理
k1_mean = df.groupby('key1').transform(np.mean).add_prefix('mean_')
k1_mean
df[k1_mean.columns] = k1_mean
df

距平化
与平均值的差异值

df = pd.DataFrame(np.random.randint(1, 10, (5, 5)), 
                  columns=['a', 'b', 'c', 'd', 'e'], 
                  index=['Alice', 'Bob', 'Candy', 'Dark', 'Emily'])
df
def demean(s):
    return s - s.mean()

key = ['one', 'one', 'two', 'one', 'two']
demeaned = df.groupby(key).transform(demean)
demeaned
demeaned.groupby(key).mean()

apply 函数
我们介绍过 DataFrame 的 apply 函数是逐行或逐列来处理数据。GroupBy 的 apply 函数对每个分组进行计算。

df = pd.DataFrame({'key1': ['a', 'a', 'b', 'b', 'a', 'a', 'a', 'b', 'b', 'a'],
                  'key2': ['one', 'two', 'one', 'two', 'one', 'one', 'two', 'one', 'two', 'one'],
                  'data1': np.random.randint(1, 10, 10),
                  'data2': np.random.randint(1, 10, 10)})
df
# 根据 column 排序,输出其最大的 n 行数据
def top(df, n=2, column='data1'):
    return df.sort_values(by=column, ascending=False)[:n]

top(df, n=5)
df.groupby('key1').apply(top)
# 传递参数
df.groupby('key1').apply(top, n=3, column='data2')
# 禁用分组键
df.groupby('key1', group_keys=False).apply(top)

apply 应用示例:用不同的分组平均值填充空缺数据

states = ['Ohio', 'New York', 'Vermont', 'Florida',
          'Oregon', 'Nevada', 'California', 'Idaho']
group_key = ['East'] * 4 + ['West'] * 4
data = pd.Series(np.random.randn(8), index=states)
data[['Vermont', 'Nevada', 'Idaho']] = np.nan
data
data.groupby(group_key).mean()
fill_mean = lambda g: g.fillna(g.mean())

data.groupby(group_key).apply(fill_mean)

未经允许不得转载:作者:1026-徐同学, 转载或复制请以 超链接形式 并注明出处 拜师资源博客
原文地址:《数据科学包-Day2-pandas(三)》 发布于2020-05-26

分享到:
赞(0) 打赏

评论 抢沙发

评论前必须登录!

  注册



长按图片转发给朋友

觉得文章有用就打赏一下文章作者

支付宝扫一扫打赏

微信扫一扫打赏

Vieu3.3主题
专业打造轻量级个人企业风格博客主题!专注于前端开发,全站响应式布局自适应模板。

登录

忘记密码 ?

您也可以使用第三方帐号快捷登录

Q Q 登 录
微 博 登 录