一、层级索引

下面创建一个Series， 在输入索引Index时，输入了由两个子list组成的list，第一个子list是外层索引，第二个list是内层索引。

示例代码：

# 导入numpy，别名np
import numpy as np
# 导入pandas，别名 pd
import pandas as pd

ser_obj = pd.Series(np.random.randn(12),index=[
                ['a', 'a', 'a', 'b', 'b', 'b', 'c', 'c', 'c', 'd', 'd', 'd'],
                [0, 1, 2, 0, 1, 2, 0, 1, 2, 0, 1, 2]
            ])
print(ser_obj)

显示结果：

1，MultiIndex索引对象

打印这个Series的索引类型，显示是MultiIndex
直接将索引打印出来，可以看到有lavels,和labels两个信息。lavels表示两个层级中分别有那些标签，labels是每个位置分别是什么标签。

示例代码：

# 导入numpy，别名np
import numpy as np
# 导入pandas，别名 pd
import pandas as pd

ser_obj = pd.Series(np.random.randn(12),index=[
                ['a', 'a', 'a', 'b', 'b', 'b', 'c', 'c', 'c', 'd', 'd', 'd'],
                [0, 1, 2, 0, 1, 2, 0, 1, 2, 0, 1, 2]
            ])
print(type(ser_obj.index))
print(ser_obj.index)

显示结果：

2，选取子集

根据索引获取数据。因为现在有两层索引，当通过外层索引获取数据的时候，可以直接利用外层索引的标签来获取。
当要通过内层索引获取数据的时候，在list中传入两个元素，前者是表示要选取的外层索引，后者表示要选取的内层索引。

（1）外层选取

语法格式：ser_obj['outer_label']

示例代码：

# 导入numpy，别名np
import numpy as np
# 导入pandas，别名 pd
import pandas as pd

ser_obj = pd.Series(np.random.randn(12),index=[
                ['a', 'a', 'a', 'b', 'b', 'b', 'c', 'c', 'c', 'd', 'd', 'd'],
                [0, 1, 2, 0, 1, 2, 0, 1, 2, 0, 1, 2]
            ])
# 外层选取
print(ser_obj['c'])

显示结果：

（2）内层选取

语法格式：ser_obj[:, 'inner_label']

示例代码：

# 导入numpy，别名np
import numpy as np
# 导入pandas，别名 pd
import pandas as pd

ser_obj = pd.Series(np.random.randn(12),index=[
                ['a', 'a', 'a', 'b', 'b', 'b', 'c', 'c', 'c', 'd', 'd', 'd'],
                [0, 1, 2, 0, 1, 2, 0, 1, 2, 0, 1, 2]
            ])
# 内层选取
print(ser_obj[:, 2])

显示结果：

3，交换分层顺序

swaplevel()：.swaplevel( )交换内层与外层索引。

示例代码：

# 导入numpy，别名np
import numpy as np
# 导入pandas，别名 pd
import pandas as pd

ser_obj = pd.Series(np.random.randn(12),index=[
                ['a', 'a', 'a', 'b', 'b', 'b', 'c', 'c', 'c', 'd', 'd', 'd'],
                [0, 1, 2, 0, 1, 2, 0, 1, 2, 0, 1, 2]
            ])
print(ser_obj.swaplevel())

显示结果：

4，交换并排序分层

sortlevel()：.sortlevel( )先对外层索引进行排序，再对内层索引进行排序，默认是升序。
但是pandas的包中在0.23.4版本中就取消了sort方法，老版本的Series和DataFrame对象中还包含这个函数，新版本中推荐使用sort_index和sort_values函数。
所以应该首先查看自己的版本，然后选取对应的函数对索引进行排序。

示例代码：

# 导入numpy，别名np
import numpy as np
# 导入pandas，别名 pd
import pandas as pd

ser_obj = pd.Series(np.random.randn(12),index=[
                ['a', 'a', 'a', 'b', 'b', 'b', 'c', 'c', 'c', 'd', 'd', 'd'],
                [0, 1, 2, 0, 1, 2, 0, 1, 2, 0, 1, 2]
            ])
# 交换并排序分层
print(ser_obj.swaplevel().sort_index())

显示结果：

二、统计计算和描述

1，常用的统计计算

sum, mean, max, min…
axis=0 按列统计，axis=1按行统计
skipna 排除缺失值， 默认为True

示例代码：

# 导入numpy，别名np
import numpy as np
# 导入pandas，别名 pd
import pandas as pd

df_obj = pd.DataFrame(np.random.randn(5,4), columns = ['a', 'b', 'c', 'd'])
print(df_obj)

print(df_obj.sum())
print(df_obj.max())
print(df_obj.min(axis=1, skipna=False))

显示结果：

2，常用的统计描述

describe 产生多个统计数据

示例代码：

# 导入numpy，别名np
import numpy as np
# 导入pandas，别名 pd
import pandas as pd

df_obj = pd.DataFrame(np.random.randn(5,4), columns = ['a', 'b', 'c', 'd'])
print(df_obj)

print(df_obj.describe())

显示结果：

3，常用的统计描述方法

方法	说明
count	非NA值的数量
describe	针对DataFrame与Series计算汇总统计
min、max	计算最大值与最小值
argmin、argmax	计算能够获取到的最大值与最小值的索引位置
idxmin、idmax	计算能够获取到的最大值与最小值的索引值
quantile	计算样本的分位数
sum	值的总和
mean	值的平均值
median	值的算术中位数
mad	根据平均值计算平均绝对离差
var	样本值的方差
std	样本值的标准差
skew	样本值的偏度
kurt	样本值的峰度
cumsum	样本值的累计和
cummin、cummax	样本值的累计最大值与累计最小值
cumprod	样本值的累计积
diff	计算一阶差分（一般使用在时间序列中）
pct_change	计算百分比的变化

三、分组

定义：对数据集进行分组，然后对每组进行统计分析；SQL能够对数据进行过滤，分组聚合；pandas能利用groupby进行更加复杂的分组运算。
分组运算过程：split->apply->combine
	拆分：进行分组的根据
	应用：每个分组运行的计算规则
	合并：把每个分组的计算结果合并起来

示例代码：

# 导入numpy，别名np
import numpy as np
# 导入pandas，别名 pd
import pandas as pd

dict_obj = {'key1' : ['a', 'b', 'a', 'b', 
                      'a', 'b', 'a', 'a'],
            'key2' : ['one', 'one', 'two', 'three',
                      'two', 'two', 'one', 'three'],
            'data1': np.random.randn(8),
            'data2': np.random.randn(8)}
df_obj = pd.DataFrame(dict_obj)
print(df_obj)

显示结果：

1，GroupBy对象：DataFrameGroupBy，SeriesGroupBy

（1）分组操作

groupby()进行分组，GroupBy对象没有进行实际运算，只是包含分组的中间数据。
按列名分组代码格式：obj.groupby(‘label’)

示例代码：

# 导入numpy，别名np
import numpy as np
# 导入pandas，别名 pd
import pandas as pd

dict_obj = {'key1' : ['a', 'b', 'a', 'b', 
                      'a', 'b', 'a', 'a'],
            'key2' : ['one', 'one', 'two', 'three',
                      'two', 'two', 'one', 'three'],
            'data1': np.random.randn(8),
            'data2': np.random.randn(8)}
df_obj = pd.DataFrame(dict_obj)

# dataframe根据key1进行分组
print(type(df_obj.groupby('key1')))

# dataframe的 data1 列根据 key1 进行分组
print(type(df_obj['data1'].groupby(df_obj['key1'])))

显示结果：

（2）分组运算

对GroupBy对象进行分组运算/多重分组运算，如mean()
非数值数据不进行分组运算
size() 返回每个分组的元素个数

示例代码：

# 导入numpy，别名np
import numpy as np
# 导入pandas，别名 pd
import pandas as pd

dict_obj = {'key1' : ['a', 'b', 'a', 'b', 
                      'a', 'b', 'a', 'a'],
            'key2' : ['one', 'one', 'two', 'three',
                      'two', 'two', 'one', 'three'],
            'data1': np.random.randn(8),
            'data2': np.random.randn(8)}
df_obj = pd.DataFrame(dict_obj)

# 分组运算
grouped1 = df_obj.groupby('key1')
print(grouped1.mean())

grouped2 = df_obj['data1'].groupby(df_obj['key1'])
print(grouped2.mean())

print(grouped1.size())
print(grouped2.size())

显示结果：

（3）按自定义的key分组

语法格式：obj.groupby(self_def_key)
自定义的key可为列表或多层列表
obj.groupby([‘label1’, ‘label2’])->多层dataframe

示例代码：

# 导入numpy，别名np
import numpy as np
# 导入pandas，别名 pd
import pandas as pd

dict_obj = {'key1' : ['a', 'b', 'a', 'b', 
                      'a', 'b', 'a', 'a'],
            'key2' : ['one', 'one', 'two', 'three',
                      'two', 'two', 'one', 'three'],
            'data1': np.random.randn(8),
            'data2': np.random.randn(8)}
df_obj = pd.DataFrame(dict_obj)

# 按自定义key分组，列表
self_def_key = [0, 1, 2, 3, 3, 4, 5, 7]
print(df_obj.groupby(self_def_key).size())

# 按自定义key分组，多层列表
print(df_obj.groupby([df_obj['key1'], df_obj['key2']]).size())

# 按多个列多层分组
grouped2 = df_obj.groupby(['key1', 'key2'])
print(grouped2.size())

# 多层分组按key的顺序进行
grouped3 = df_obj.groupby(['key2', 'key1'])
print(grouped3.mean())
# unstack可以将多层索引的结果转换成单层的dataframe
print(grouped3.mean().unstack())

显示结果：

2，GroupBy对象支持迭代操作

每次迭代返回一个元组 (group_name, group_data)
可用于分组数据的具体运算

（1）单层分组

示例代码：

# 导入numpy，别名np
import numpy as np
# 导入pandas，别名 pd
import pandas as pd

dict_obj = {'key1' : ['a', 'b', 'a', 'b', 
                      'a', 'b', 'a', 'a'],
            'key2' : ['one', 'one', 'two', 'three',
                      'two', 'two', 'one', 'three'],
            'data1': np.random.randn(8),
            'data2': np.random.randn(8)}
df_obj = pd.DataFrame(dict_obj)

# 按自定义key分组，列表
self_def_key = [0, 1, 2, 3, 3, 4, 5, 7]
print(df_obj.groupby(self_def_key).size())

grouped1 = df_obj.groupby('key1')
# print(grouped1.mean())

grouped2 = df_obj['data1'].groupby(df_obj['key1'])
# print(grouped2.mean())
# 单层分组，根据key1
for group_name, group_data in grouped1:
    print(group_name)
    print(group_data)

显示结果：

（2）多层分组

示例代码：

# 导入numpy，别名np
import numpy as np
# 导入pandas，别名 pd
import pandas as pd

dict_obj = {'key1' : ['a', 'b', 'a', 'b', 
                      'a', 'b', 'a', 'a'],
            'key2' : ['one', 'one', 'two', 'three',
                      'two', 'two', 'one', 'three'],
            'data1': np.random.randn(8),
            'data2': np.random.randn(8)}
df_obj = pd.DataFrame(dict_obj)

# 按自定义key分组，列表
self_def_key = [0, 1, 2, 3, 3, 4, 5, 7]
print(df_obj.groupby(self_def_key).size())

grouped1 = df_obj.groupby('key1')
# print(grouped1.mean())

# 按多个列多层分组
grouped2 = df_obj.groupby(['key1', 'key2'])
#print(grouped2.size())

# 多层分组，根据key1 和 key2
for group_name, group_data in grouped2:
    print(group_name)
    print(group_data)

显示结果：

3，GroupBy对象可以转换成列表或字典

（1）GroupBy对象可以转换成列表或字典

（2）按列分组、按数据类型分组

示例代码：

# 导入numpy，别名np
import numpy as np
# 导入pandas，别名 pd
import pandas as pd

dict_obj = {'key1' : ['a', 'b', 'a', 'b', 
                      'a', 'b', 'a', 'a'],
            'key2' : ['one', 'one', 'two', 'three',
                      'two', 'two', 'one', 'three'],
            'data1': np.random.randn(8),
            'data2': np.random.randn(8)}
df_obj = pd.DataFrame(dict_obj)

# 按自定义key分组，列表
self_def_key = [0, 1, 2, 3, 3, 4, 5, 7]
print(df_obj.groupby(self_def_key).size())

grouped1 = df_obj.groupby('key1')
# print(grouped1.mean())

# 按多个列多层分组
grouped2 = df_obj.groupby(['key1', 'key2'])
#print(grouped2.size())

# 按列分组
print(df_obj.dtypes)

# 按数据类型分组
print(df_obj.groupby(df_obj.dtypes, axis=1).size())
print(df_obj.groupby(df_obj.dtypes, axis=1).sum())

显示结果：

（3）通过字典分组

示例代码：

# 导入numpy，别名np
import numpy as np
# 导入pandas，别名 pd
import pandas as pd

dict_obj = {'key1' : ['a', 'b', 'a', 'b', 
                      'a', 'b', 'a', 'a'],
            'key2' : ['one', 'one', 'two', 'three',
                      'two', 'two', 'one', 'three'],
            'data1': np.random.randn(8),
            'data2': np.random.randn(8)}
df_obj = pd.DataFrame(dict_obj)

# 按自定义key分组，列表
self_def_key = [0, 1, 2, 3, 3, 4, 5, 7]
#print(df_obj.groupby(self_def_key).size())

grouped1 = df_obj.groupby('key1')
# print(grouped1.mean())

# 按多个列多层分组
grouped2 = df_obj.groupby(['key1', 'key2'])
#print(grouped2.size())

df_obj2 = pd.DataFrame(np.random.randint(1, 10, (5,5)),
                       columns=['a', 'b', 'c', 'd', 'e'],
                       index=['A', 'B', 'C', 'D', 'E'])
# 通过字典分组
mapping_dict = {'a':'Python', 'b':'Python', 'c':'Java', 'd':'C', 'e':'Java'}
print(df_obj2.groupby(mapping_dict, axis=1).size())
print(df_obj2.groupby(mapping_dict, axis=1).count()) # 非NaN的个数
print(df_obj2.groupby(mapping_dict, axis=1).sum())

显示结果：

（4）通过函数分组，函数传入的参数为行索引或列索引

示例代码：

# 导入numpy，别名np
import numpy as np
# 导入pandas，别名 pd
import pandas as pd

dict_obj = {'key1' : ['a', 'b', 'a', 'b', 
                      'a', 'b', 'a', 'a'],
            'key2' : ['one', 'one', 'two', 'three',
                      'two', 'two', 'one', 'three'],
            'data1': np.random.randn(8),
            'data2': np.random.randn(8)}
df_obj = pd.DataFrame(dict_obj)

# 按自定义key分组，列表
self_def_key = [0, 1, 2, 3, 3, 4, 5, 7]
#print(df_obj.groupby(self_def_key).size())

grouped1 = df_obj.groupby('key1')
# print(grouped1.mean())

# 按多个列多层分组
grouped2 = df_obj.groupby(['key1', 'key2'])
#print(grouped2.size())

# 通过函数分组
df_obj3 = pd.DataFrame(np.random.randint(1, 10, (5,5)),
                       columns=['a', 'b', 'c', 'd', 'e'],
                       index=['AA', 'BBB', 'CC', 'D', 'EE'])
#df_obj3

def group_key(idx):
    """
        idx 为列索引或行索引
    """
    #return idx
    return len(idx)

print(df_obj3.groupby(group_key).size())

# 以上自定义函数等价于
#df_obj3.groupby(len).size()

显示结果：

（5）通过索引级别分组

示例代码：

# 导入numpy，别名np
import numpy as np
# 导入pandas，别名 pd
import pandas as pd

dict_obj = {'key1' : ['a', 'b', 'a', 'b', 
                      'a', 'b', 'a', 'a'],
            'key2' : ['one', 'one', 'two', 'three',
                      'two', 'two', 'one', 'three'],
            'data1': np.random.randn(8),
            'data2': np.random.randn(8)}
df_obj = pd.DataFrame(dict_obj)

# 按自定义key分组，列表
self_def_key = [0, 1, 2, 3, 3, 4, 5, 7]
#print(df_obj.groupby(self_def_key).size())

# 通过索引级别分组
columns = pd.MultiIndex.from_arrays([['Python', 'Java', 'Python', 'Java', 'Python'],
                                     ['A', 'A', 'B', 'C', 'B']], names=['language', 'index'])
df_obj4 = pd.DataFrame(np.random.randint(1, 10, (5, 5)), columns=columns)
print(df_obj4)

# 根据language进行分组
print(df_obj4.groupby(level='language', axis=1).sum())
# 根据index进行分组
print(df_obj4.groupby(level='index', axis=1).sum())

显示结果：

四，聚合

数组产生标量的过程，如mean()、count()等
常用于对分组后的数据进行计算

示例代码：

# 导入numpy，别名np
import numpy as np
# 导入pandas，别名 pd
import pandas as pd

dict_obj = {'key1' : ['a', 'b', 'a', 'b', 
                      'a', 'b', 'a', 'a'],
            'key2' : ['one', 'one', 'two', 'three',
                      'two', 'two', 'one', 'three'],
            'data1': np.random.randint(1,10, 8),
            'data2': np.random.randint(1,10, 8)}
df_obj5 = pd.DataFrame(dict_obj)
print(df_obj5)

显示结果：

1，内置的聚合函数

sum(), mean(), max(), min(), count(), size(), describe()

示例代码：

# 导入numpy，别名np
import numpy as np
# 导入pandas，别名 pd
import pandas as pd

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

print(df_obj5.groupby('key1').sum())
print(df_obj5.groupby('key1').max())
print(df_obj5.groupby('key1').min())
print(df_obj5.groupby('key1').mean())
print(df_obj5.groupby('key1').size())
print(df_obj5.groupby('key1').count())
print(df_obj5.groupby('key1').describe())

显示结果：

2，可自定义函数，传入agg方法中

grouped.agg(func)
func的参数为groupby索引对应的记录

示例代码：

# 导入numpy，别名np
import numpy as np
# 导入pandas，别名 pd
import pandas as pd

dict_obj = {'key1' : ['a', 'b', 'a', 'b', 
                      'a', 'b', 'a', 'a'],
            'key2' : ['one', 'one', 'two', 'three',
                      'two', 'two', 'one', 'three'],
            'data1': np.random.randint(1,10, 8),
            'data2': np.random.randint(1,10, 8)}
df_obj = pd.DataFrame(dict_obj)
df_obj5 = pd.DataFrame(dict_obj)

# 自定义聚合函数
def peak_range(df):
    """
        返回数值范围
    """
    #print type(df) #参数为索引所对应的记录
    return df.max() - df.min()

print(df_obj5.groupby('key1').agg(peak_range))
print(df_obj.groupby('key1').agg(lambda df : df.max() - df.min()))

显示结果：

3，应用多个聚合函数

同时应用多个函数进行聚合操作，使用函数列表

示例代码：

# 导入numpy，别名np
import numpy as np
# 导入pandas，别名 pd
import pandas as pd

dict_obj = {'key1' : ['a', 'b', 'a', 'b', 
                      'a', 'b', 'a', 'a'],
            'key2' : ['one', 'one', 'two', 'three',
                      'two', 'two', 'one', 'three'],
            'data1': np.random.randint(1,10, 8),
            'data2': np.random.randint(1,10, 8)}
df_obj = pd.DataFrame(dict_obj)
df_obj5 = pd.DataFrame(dict_obj)

# 自定义聚合函数
def peak_range(df):
    """
        返回数值范围
    """
    #print type(df) #参数为索引所对应的记录
    return df.max() - df.min()

# 应用多个聚合函数

# 同时应用多个聚合函数
print(df_obj.groupby('key1').agg(['mean', 'std', 'count', peak_range])) # 默认列名为函数名

print(df_obj.groupby('key1').agg(['mean', 'std', 'count', ('range', peak_range)])) # 通过元组提供新的列名

显示结果：

4，对不同的列分别作用不同的聚合函数，使用dict

示例代码：

# 导入numpy，别名np
import numpy as np
# 导入pandas，别名 pd
import pandas as pd

dict_obj = {'key1' : ['a', 'b', 'a', 'b', 
                      'a', 'b', 'a', 'a'],
            'key2' : ['one', 'one', 'two', 'three',
                      'two', 'two', 'one', 'three'],
            'data1': np.random.randint(1,10, 8),
            'data2': np.random.randint(1,10, 8)}
df_obj = pd.DataFrame(dict_obj)
df_obj5 = pd.DataFrame(dict_obj)

# 每列作用不同的聚合函数
dict_mapping = {'data1':'mean',
                'data2':'sum'}
print(df_obj.groupby('key1').agg(dict_mapping))

dict_mapping = {'data1':['mean','max'],
                'data2':'sum'}
print(df_obj.groupby('key1').agg(dict_mapping))

显示结果：

5，常用的内置聚合函数

函数名	说明
count	分组中非NA的数量
sum	非NA的和
mean	非NA值的平均值
median	非NA值的算数中位数
std、var	标准差和方差
min、max	非NA值的最大值和最小值
prod	非NA值的积
first、last	第一个或者最后一个非NA值

五、数据的分组运算

示例代码：

# 导入numpy，别名np
import numpy as np
# 导入pandas，别名 pd
import pandas as pd

dict_obj = {'key1' : ['a', 'b', 'a', 'b', 
                      'a', 'b', 'a', 'a'],
            'key2' : ['one', 'one', 'two', 'three',
                      'two', 'two', 'one', 'three'],
            'data1': np.random.randint(1, 10, 8),
            'data2': np.random.randint(1, 10, 8)}
df_obj = pd.DataFrame(dict_obj)
print(df_obj)

# 按key1分组后，计算data1，data2的统计信息并附加到原始表格中，并添加表头前缀
k1_sum = df_obj.groupby('key1').sum().add_prefix('sum_')
print(k1_sum)

显示结果：

1，merge

示例代码：

# 导入numpy，别名np
import numpy as np
# 导入pandas，别名 pd
import pandas as pd

dict_obj = {'key1' : ['a', 'b', 'a', 'b', 
                      'a', 'b', 'a', 'a'],
            'key2' : ['one', 'one', 'two', 'three',
                      'two', 'two', 'one', 'three'],
            'data1': np.random.randint(1, 10, 8),
            'data2': np.random.randint(1, 10, 8)}
df_obj = pd.DataFrame(dict_obj)
#print(df_obj)
k1_sum = df_obj.groupby('key1').sum().add_prefix('sum_')
# 方法1，使用merge
k1_sum_merge = pd.merge(df_obj, k1_sum, left_on='key1', right_index=True)
print(k1_sum_merge)

显示结果：

2，transform

transform的计算结果和原始数据的形状保持一致，

示例代码：

# 导入numpy，别名np
import numpy as np
# 导入pandas，别名 pd
import pandas as pd

dict_obj = {'key1' : ['a', 'b', 'a', 'b', 
                      'a', 'b', 'a', 'a'],
            'key2' : ['one', 'one', 'two', 'three',
                      'two', 'two', 'one', 'three'],
            'data1': np.random.randint(1, 10, 8),
            'data2': np.random.randint(1, 10, 8)}
df_obj = pd.DataFrame(dict_obj)
#print(df_obj)
k1_sum = df_obj.groupby('key1').sum().add_prefix('sum_')
# 方法2，使用transform
k1_sum_tf = df_obj.groupby('key1').transform(np.sum).add_prefix('sum_')
df_obj[k1_sum_tf.columns] = k1_sum_tf
print(df_obj)

显示结果：

六、聚类模型：K-Means

1，K-Means算法

算法接收参数k；然后将样本点划分为k个聚类；同一聚类中的样本相似度较高；不同聚类中的样本相似度较小

2，算法思想

以空间中k个样本点为中心进行聚类，对最靠近它们的样本点归类。通过迭 代的方法，逐步更新各聚类中心，直至达到最好的聚类效果

3，算法描述

（1）选择k个聚类的初始中心
（2）在第n次迭代中，对任意一个样本点，求其到k个聚类中心的距离，将该 样本点归类到距离最小的中心所在的聚类
（3）利用均值等方法更新各类的中心值
（4）对所有的k个聚类中心，如果利用2,3步的迭代更新后，达到稳定，则迭代 结束。

4，优缺点

优点：速度快，简单
缺点：最终结果和初始点的选择相关，容易陷入局部最优，需要给定k值