利用Python进行数据分析之pandas

Numpy能够帮助我们处理数值型数据，但是这还不够，我们的数据除了数值以外，还有字符串还有时间序列等等，所以pandas出现了。pandas是一个强大的分析结构话数据的工具集，基于Numpy构建，提供了高级数据结构和数据操作工具，是使Python成为强大而高效的数据分析环境的重要因素之一

  • 一个强大的分析和操作大型结构化数据集所需的工具集
  • 基础是numpy，提供了高性能矩阵的运算
  • 提供了大量能够快速便捷地处理数据的函数和方法
  • 应用于数据挖掘，数据分析
  • 提供数据清洗功能

详细pandas内容可前往pandas官方网站进行学习。

pandas数据结构

为了入门pandas，需要熟悉两个常用的工具数据结构：Series和DataFrame。尽管它们并不能解决所有问题，但它们为大多数应用提供了一个有效、易用的基础。

Series

Series是一种一维的数组型对象，包含一个值序列，并且包含了数据标签（index）。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
import pandas as pd
import numpy as np
# Series是一种一维的数组型对象，包含一个值序列和索引，索引（index）在左边，值（value）在右边
# 默认的索引是从0开始到N-1（N是数据的长度）

def prints(a):
    print(a)
    print('='*30)
# 创建Series的方法有三种
    # 通过list创建：
obj = pd.Series([4,7,-5,3])
prints(obj)
prints(obj.values)
prints(obj.index) # 与 range(4) 类似
prints(obj[1])
obj2 = pd.Series([4,7,-5,3],index=['d','b','a','c'])
prints(obj2.index)
prints(obj2['a'])

    # 通过数组创建
obj3 = pd.Series(np.arange(1,6))
prints(obj3)

    # 通过字典创建
sdata = {'Tom':180,'Jim':175,'Lily':168,'Jerry':185}
obj4 = pd.Series(sdata)
prints(obj4)

Series的基本用法包括

  • isnull notnull 检查缺失值
  • 通过索引获取数据
  • 数据对齐：在数学操作中自动对齐索引
  • Series的name属性
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
import pandas as pd
import numpy as np
def prints(a):
    print(a)
    print('='*30)
# isnull notnull 检查缺失值
sdata = {'Tom':180,'Jim':175,'Lily':168,'Jerry':185}
obj1 = pd.Series(sdata,index=['Tom','Jim','Lily','Jerry','Toby'])
prints(obj1)
prints(pd.isnull(obj1))
prints(pd.notnull(obj1))
prints(obj1.isnull()) # 实例方法
prints(obj1.notnull())
# 通过索引/切片获取数据
prints(obj1.index)
prints(obj1.values)
prints(obj1['Tom'])
prints(obj1[0])
prints(obj1[['Tom','Lily']]) #选取多个值
prints(obj1[1:3]) # 切片取值
prints(obj1['Tom':'Jerry']) # 标签切片包含末端数据
prints(obj1[obj1>170]) # 布尔索引
# 索引与数据的对应关系不被运算结果影响
prints(obj1 * 2)
# name属性
obj1.name = 'height'
obj1.index.name = 'name'
prints(obj1)
prints(obj1.head(3)) # 打印前3行
prints(obj1.tail(3)) # 打印后3行

DataFrame

DataFrame是表示矩阵的数据表，它包含已排序的列集合，每一列可以是不同的数据类型。DataFrame有行索引也有列索引，数据被存储为一个以上的二维块。后续可以利用分层索引在DataFrame中展现更高维度的数据。

常用的构建DataFrame的方式是利用Numpy数组的字典或包含等长度列表。

  1. 通过字典创建DataFrame

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    import pandas as pd
    import numpy as np
    def prints(a):
        print(a)
        print('='*30)
    # 字典类：
        # 数组、列表或元组构成的字典构造dataframe
    data1 = {'a':[1,2,3,4],'b':[5,6,7,8],'c':np.arange(9,13)}
    frame1 = pd.DataFrame(data1)
    prints(frame1)
    prints(frame1.index) # 行索引
    prints(frame1.columns) # 列索引
    prints(frame1.values) # 值
    frame2 = pd.DataFrame(data1,index=['A','B','C','D'],columns=['a','v','c','d'])
    prints(frame2)
        # Series构成的字典构造dataframe
    frame3 = pd.DataFrame({'a':pd.Series(np.arange(3)),'b':pd.Series(np.arange(3,5))})
    prints(frame3)
        # 字典构成的字典构造dataframe
    data2 = {
        'a':{'apple':3.6,'banana':'5.6'},
        'b':{'apple':3.6,'banana':'5.6'},
        'c':{'apple':3.6}
    }
    frame4 = pd.DataFrame(data2)
    prints(frame4)

  2. 通过列表创建DataFrame

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    import pandas as pd
    import numpy as np

    def prints(a):
        print(a)
        print('='*30)

    # 列表类
        # 2D ndarray构造dataframe
    arr1 = np.arange(12).reshape(4,3)
    prints(arr1)
    frame1 = pd.DataFrame(arr1,index=['a','b','c','d'],columns=['A','B','C'])
    prints(frame1)
        # 字典构成的列表构造dataframe
    list1 = [{'apple':3.6,'banana':5.6},{'apple':3,'banana':5},{'apple':3.2}]
    frame2 = pd.DataFrame(list1,index=['a','b','c'])
    prints(frame2)
        # Series构成的列表构造dataframe
    list2 = [pd.Series(np.random.rand(3)),pd.Series(np.random.rand(2))]
    frame3 = pd.DataFrame(list2)
    prints(list2)
    prints(frame3)

  3. DataFrame构造函数的有效输入

    类型 描述
    2D ndarray 数据的矩阵，行和列标签是可选参数
    数组、列表和元组构成的字典 每个序列成为DataFrame的一列，所有的序列必须长度相等
    Numpy结构化数组 与数组构成的字典一致
    Series构成的字典 每个值成为一列，每个Series的索引形成行索引，也可以显式地传递索引
    字典构成的字典 每个内部字典成为一列，字典的键形成行索引，
    字典或Series构成的列表 列表中的一个元素形成DataFrame的一行，字典键或Series索引形成列标签
    列表或元组构成的列表 与2D ndarray一致
    其他DataFrame 如果不显示传递索引，则会使用原DataFrame索引
    Numpy MaskedArray 与2D ndarray类似，但隐蔽值会在结果DataFrame中成为缺失值

DataFrame的基本使用

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
import pandas as pd
import numpy as np

def prints(a):
    print(a)
    print('='*30)

# 转置
frame1 = pd.DataFrame(np.arange(9).reshape(3,3),index=['a','b','c'],columns=['A','B','C'])
prints(frame1)
prints(frame1.T) # 行与列转置
# 通过列索引获取数据（Series类型）
prints(frame1['A'])
prints(type(frame1['A']))
# 增加列数据
frame1['D'] = 9
prints(frame1)
frame1['D'] = [1,2,3]
prints(frame1)
# 删除列
del(frame1['D'])
prints(frame1)

索引对象

索引对象是用于存储轴标签和其他元数据的，索引对象不可变，保证了数据的安全。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
import pandas as pd
import numpy as np
# Series和DataFrame中的索引都是Index对象
def prints(a):
    print(a)
    print('='*30)

ps = pd.Series(np.arange(1,5),index=('a','b','c','d'))
prints(ps)
prints(ps.index)
prints(type(ps.index))
pd1 = pd.DataFrame(np.arange(9).reshape(3,3),index=('a','b','c'),columns=('A','B','C'))
prints(pd1)
prints(pd1.index)
prints(pd1.columns)

与Python集合不同，pandas索引对象可以包含重复标签，根据重复标签进行筛选，会选取所有重复标签对应的数据。下表总结了一些索引集合逻辑的方法和属性：

方法 描述
append 将额外的索引对象粘贴到原索引后，产生一个新的索引
difference 计算两个索引的差集
intersection 计算两个索引的交集
union 计算两个索引的并集
isin 计算表示每一个值是否在传值容器中的布尔数值
delete 将位置i的元素删除，并产生新的索引
drop 根据传参删除置顶索引值，并产生新的索引
insert 在位置i插入元素，并产生新的索引
is_monotonic 如果索引序列递增，则返回True
is_unique 如果索引序列唯一，则返回True
unique 计算索引的唯一值序列

pandas基本功能

重点了解Series和DataFrame中数据交互的基础机制。

重建索引

reindex方法用于创建一个符合新索引的新对象

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
import pandas as pd
import numpy as np

def prints(a):
    print(a)
    print('='*30)

# reindex 创建一个符合新索引的新对象
ps1 = pd.Series(np.arange(1,5),index=('a','b','c','d'))
ps2 = ps1.reindex(['a','b','c','d','e'])
prints(ps1)
prints(ps2)

pd1 = pd.DataFrame(np.arange(9).reshape(3,3),index=('a','b','c'),columns=('A','B','C'))
pd2 = pd1.reindex(['a','b','c','d']) # 重建行索引
prints(pd2)
pd3 = pd1.reindex(columns=['C','B','A']) # 重建列索引
prints(pd3)

reindex方法的参数：

方法 描述
index 新建作为索引的序列
method 插值方式：’ffill’为前向填充，’bfill’为后向填充
fill_value 通过重新索引引入缺失数据时使用替代值
limit 前向/后向填充时，所需填充的最大尺寸间隙(元素数量)
tolerance 前向/后向填充时，所需填充的不精确匹配下的最大尺寸间隙(绝对值距离)
level 匹配MultiIndex级别的简单索引
copy True时，总是复制底层数据；False时，在索引相同时不复制数据

索引操作

pandas索引操作与Numpy数组索引的功能类似，但pandas的索引值可以不仅仅是整数，简单来说可以分为增删改查四种基本操作。

增

append函数和insert函数

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
import pandas as pd
import numpy as np

def prints(a):
    print(a)
    print('='*30)

ps1 = pd.Series(np.arange(1,5),index=('a','b','c','d'))
ps1['e'] = 9
prints(ps1)
ps2 = pd.Series({'f':8})
ps3 = ps1.append(ps2) # 拼接两个Series
prints(ps3)

pd1 = pd.DataFrame(np.arange(9).reshape(3,3),index=('a','b','c'),columns=('A','B','C'))
# 增加列
pd1[4] = 9
prints(pd1)
pd1[4] = [10,11,12] # 在末尾增加列
prints(pd1)
pd1.insert(0,'E',[18,19,20]) # 在指定位置插入列
prints(pd1)

# 增加行
# 标签索引loc
pd1.loc['d'] = [1,1,1,1,1] # 末尾添加行
prints(pd1)
row = {4:6,'A':7,'B':8,'C':9,'E':10}
pd2 = pd1.append(row,ignore_index= True) # 拼接字典
prints(pd2)

删

del函数和drop函数

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
import pandas as pd
import numpy as np

def prints(a):
    print(a)
    print('='*30)

# 通过del函数删除，会改变原来的值
    # Series
ps1 = pd.Series(np.arange(1,7),index=('a','b','c','d','e','f'))
del ps1['b']
prints(ps1)
    # DataFrame
pd1 = pd.DataFrame(np.arange(16).reshape(4,4),index=('a','b','c','d'),columns=('A','B','C','D'))
del pd1['C'] # 删除一列
prints(pd1)

# 通过drop函数删除，不会改变原来的值
    # Series 
ps2 = ps1.drop('a') # 删除一条
prints(ps1)
prints(ps2)
ps3 = ps1.drop(['a','d']) # 删除多条
prints(ps3)
    # DataFrame
        # 删除行
pd2 = pd1.drop('a') # 删除一行
prints(pd2)
pd3 = pd1.drop(['a','b']) # 删除多行
prints(pd3)
        # 删除列
pd4 = pd1.drop('A',axis=1) # axis = 1 列；axis = 0 行
prints(pd4)
pd5 = pd1.drop('A',axis= 'columns')
prints(pd5)

# 通过inplace属性，在原对象上删除，不会返回新的对象
ps1.drop('e',inplace=True)
prints(ps1)

改

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
import pandas as pd
import numpy as np

def prints(a):
    print(a)
    print('='*30)

ps1 = pd.Series(np.arange(1,7),index=('a','b','c','d','e','f'))
pd1 = pd.DataFrame(np.arange(16).reshape(4,4),index=('a','b','c','d'),columns=('A','B','C','D'))
# Series
ps1['a'] = 999 # 通过标签索引进行修改
prints(ps1)
ps1[0] = 888 # 通过位置索引进行修改
prints(ps1)

# DataFrame
    # 修改列
pd1['A'] = 9
prints(pd1)
pd1['A'] = [9,10,11,12]
prints(pd1)

pd1.A = 6 # 对象.列 的方式进行数据修改
prints(pd1)
    # 修改行
    # loc 标签索引
pd1.loc['a'] = 777
prints(pd1)
pd1.loc['a','A'] = 888
prints(pd1)

查

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
import pandas as pd
import numpy as np

def prints(a):
    print(a)
    print('='*30)

ps1 = pd.Series(np.arange(1,7),index=('a','b','c','d','e','f'))
pd1 = pd.DataFrame(np.arange(16).reshape(4,4),index=('a','b','c','d'),columns=('A','B','C','D'))
# Series
prints(ps1['a']) # 标签索引
prints(ps1[0]) # 位置索引
prints(ps1['a':'e']) # 标签切片索引，包含终止标签索引
prints(ps1[0:5]) # 位置切片索引，不包含终止位置索引
prints(ps1[['a','c','d']]) # 不连续索引，两个中括号
prints(ps1[[0,2,4]]) # 同上
prints(ps1[ps1>2]) # 布尔索引

# DataFrame
    # 列索引
prints(pd1['A'])
prints(pd1[['A','C','D']]) # 不连续索引
prints(pd1['A']['d'])
    #  行索引
prints(pd1[:2]) # 切片索引

高级索引

当对一个包含整数轴索引的DataFrame对象进行索引操作时，标签索引和位置索引的表达方式是很类似的，未避免将来引起歧义，数据选择时建议始终使用标签索引，为更精确地处理，可以使用loc(用于标签)或iloc(用于整数位置)进行索引。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
import pandas as pd
import numpy as np


def prints(a):
    print(a)
    print('='*30)


ps1 = pd.Series(np.arange(1, 7), index=('a', 'b', 'c', 'd', 'e', 'f'))
pd1 = pd.DataFrame(np.arange(16).reshape(4, 4), index=(
    'a', 'b', 'c', 'd'), columns=('A', 'B', 'C', 'D'))
# loc 标签索引，loc是基于标签名的索引
prints(ps1['a':'c'])
prints(ps1.loc['a':'c'])

prints(pd1.loc['a':'c', 'A':'C'])  # 第一个参数是索引行，第二个参数是列
# iloc 位置索引
prints(ps1[0:3])
prints(ps1.iloc[0:3])

prints(pd1.iloc[0:3, 1:3])  # 第一个参数是索引行，第二个参数是列
# ix 标签与位置混合索引
# prints(ps1.ix[1:3])
# 在pandas版本0.20.0及其以后版本中，ix已经不被推荐使用，建议采用iloc和loc实现ix。

下表总结了DataFrame不同的索引选项：

类型 描述
df[val] 从DataFrame中选择单列或列序列
df.loc[val] 根据标签选择单行或多行
df.loc[ : , val] 根据标签选择单列或多列
df.loc[val1, val2] 同时选择行和列的一部分
df.iloc[where] 根据整数位置选择单行或多行
df.iloc[ : , where] 根据整数位置选择单列或多列
df.iloc[where_i, where_j] 根据整数位置选择行和列
df.at[label_i, label_j] 根据行、列标签选择单个标量值
df.iat[i, j] 根据行、列整数位置选择单个标量值
reindex 通过标签选择行或列
get_value, set_value 根据行和列的标签设置单个值

算术和数据对齐

不同索引对象之间的算术行为是pandas提供给一些应用的重要特性之一。如果某个索引对不相同，则返回结果的索引将是索引对的并集，类似于索引标签的自动外连接(outer join)

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
import pandas as pd
import numpy as np

def prints(a):
    print(a)
    print('='*30)

# pandas的对齐运算是数据清洗的重要过程，可以按索引对齐进行运算
# 如果没有对齐的位置则补NAN，最后也可以填充NAN

# Series按行索引对齐
s1 = pd.Series(range(10,20),index=range(10))
s2 = pd.Series(range(20,25),index=range(0,10,2))
print('s1:')
prints(s1)
print('s2:')
prints(s2)
print('s1 + s2:')
prints(s1+s2)

# DataFrame对齐运算
df1 = pd.DataFrame(np.arange(16).reshape(4,4),index=['a','b','c','d'],columns=['A','B','C','D'])
df2 = pd.DataFrame(np.random.randint(2,20,size=(2,3)),index=['b','d'],columns=list('ABD'))
print('df1:')
prints(df1)
print('df2:')
prints(df2)
print('df1 + df2:')
prints(df1 + df2)

使用填充值的算术运算

在两个不同的索引对象之间进行算术操作时，可能想要使用特殊填充值，可以利用算术方法实现：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
import pandas as pd
import numpy as np


def prints(a):
    print(a)
    print('='*30)

# 算术方法表：(字母r开头，代表会反转参数)
# add/radd 加法(+)
# sub/rsub 减法(-)
# div/rdiv 除法(/)
# floordiv/rfloordiv 整除(//)
# mul/rmul 乘法(*)
# pow/rpow 幂次方(**)


# Series
s1 = pd.Series(range(10, 20), index=range(10))
s2 = pd.Series(range(20, 25), index=range(0, 10, 2))
prints(s1.add(s2, fill_value=0))

# DataFrame
df1 = pd.DataFrame(np.arange(16).reshape(4, 4), index=[
                   'a', 'b', 'c', 'd'], columns=['A', 'B', 'C', 'D'])
df2 = pd.DataFrame(np.random.randint(2, 20, size=(2, 3)),
                   index=['b', 'd'], columns=list('ABD'))
prints(df1.add(df2, fill_value=0))
prints(df2.reindex(columns=df1.columns, fill_value=9))

DataFrame和Series的混合运算

DataFrame和Series之间的算术操作与Numpy中不同维度数组间的操作类似，Series的索引会和DataFrame的列/行进行匹配，并广播到各行/列：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
import pandas as pd
import numpy as np


def prints(a):
    print(a)
    print('='*30)


# Series
s1 = pd.Series(range(10, 20), index=range(10))
s2 = pd.Series(range(20, 25), index=range(0, 10, 2))

# DataFrame
df1 = pd.DataFrame(np.arange(16).reshape(4, 4), index=[
                   'a', 'b', 'c', 'd'], columns=['A', 'B', 'C', 'D'])
df2 = pd.DataFrame(np.random.randint(2, 20, size=(2, 3)),
                   index=['b', 'd'], columns=list('ABD'))
s3 = df1.iloc[0]
prints(df1-s3)  # 按照行进行广播
s4 = df1['A']
prints(s4)
prints(df1.sub(s4, axis='index'))  # 按照列广播，axis=0能达到同样的效果

函数应用与映射

利用DataFrame中的apply和applymap方法可以将常用的一些函数应用到一行或一列的一维数组上：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
import pandas as pd
import numpy as np


def prints(a):
    print(a)
    print('='*30)


# Series
s1 = pd.Series(range(10, 20), index=range(10))
s2 = pd.Series(range(20, 25), index=range(0, 10, 2))

# DataFrame
df = pd.DataFrame(np.random.randn(5, 4), index=[
                  'a', 'b', 'c', 'd', 'e'], columns=list('ABCD'))
prints(df)
# 方法一 dataframe可以直接使用numpy的函数
prints(np.abs(df))
# 通过apply将函数应用到列或者行
def f(x): return x.max()


prints(np.abs(df).apply(f))  # 默认axis=0，取的是列方向上的最大值
prints(np.abs(df).apply(f, axis=1))  # 取行方向上的最大值
# 通过applymap将函数应用到每个数据
def f2(x): return '%.2f' % x  # '%.2f'表示保留两位小数


prints(np.abs(df).applymap(f2))

大部分最常用的数据统计(比如sum和mean)都是DataFrame的方法，因此计算统计值时使用apply并不是必须的，传递给apply的函数并不一定要返回一个标量值，也可以返回带有多个值的Series。

排序与排名

根据某些准则对数据集进行排序是另一个重要的内建操作，需要掌握sort_index和sort_values

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
import pandas as pd
import numpy as np

def prints(a):
    print(a)
    print('='*30)

# Series
s1 = pd.Series(range(10,20),index=list('fghjkdsabc'))
s2 = pd.Series(range(20,25),index=range(0,10,2))

# 按索引排序
prints(s1.sort_index())
prints(s1.sort_index(ascending=False))
# 按值排序
prints(s1.sort_values())

# DataFrame
df = pd.DataFrame(np.random.randn(5,4),index=['d','c','a','e','b'],columns=list('CADB'))
prints(df.sort_index()) # 行排序，默认升序
prints(df.sort_index(axis=1)) # 列排序，默认升序
prints(df.sort_values(by='A')) # 列排序
prints(df.sort_values(by=['A','B'])) # 多列排序，类似Order by，先根据A列排 再根据B列排

排名是指对数组从1到有效数据点总数分配名次的操作，需要掌握rank方法。

1
2
3
4
5
6
7
8
9
10
11
import pandas as pd
import numpy as np

obj = pd.Series([7,-5,7,4,2,0,4])
print(obj)
print(obj.rank())
print(obj.rank(ascending=False,method='max'))

frame = pd.DataFrame({'b':[4.3,7,-3,2],'a':[0,1,0,1],'c':[-2,5,8,-2.5]})
print(frame)
print(frame.rank(axis='columns'))

排名中的平级关系打破方法：

方法 描述
‘average’ 默认：在每个组中分配平均排名
‘min’ 对整个组使用最小排名
‘max’ 对整个组使用最大排名
‘first’ 按照值在数据中出现的次序分配排名
‘dense’ 类似于method='min'，但组间排名总是增加1，而不是一个组中的相等元素数量

含有重复标签的轴索引

pandas中并不强制索引标签是唯一的，索引的is_unique属性可以查看标签是否唯一：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
import pandas as pd
import numpy as np


def prints(a):
    print(a)
    print('='*30)


# Series
s1 = pd.Series(list([2, 6, 8, 9, 3, 6, 4, 7, 3, 4]), index=list('fghjkdsabc'))
s2 = s1.unique()  # s2变为了唯一值数组
s3 = pd.Series(list([2, 6, 8, 9, 3, 6, 4, 7, 3, 4]), index=list('aaaaaccccc'))
s4 = s3.unique()
prints(s1)
prints(s2)
prints(s1.index.is_unique)
prints(s3)
prints(s4)
prints(s3.index.is_unique)
prints(s1.value_counts())  # 统计value出现的次数
prints(s1.isin([8]))  # 判断参数值是否在Series中出现，返回布尔类型的Series
prints(s1.isin([8, 2]))

# DataFrame
df = pd.DataFrame(np.random.randint(2, 10, size=(5, 4)), index=[
                  'd', 'c', 'a', 'e', 'b'], columns=list('CADB'))
prints(df)
prints(df.isin([2, 4]))

描述性统计概述与计算

pandas对象装配了一个常用数学、统计学方法的集合，其中大部分属于归约或汇总统计的类别，它们从DataFrame的行或列中抽取一个Series或一系列值的单个值(比如总和或平均值)，这些函数内建了处理缺失值的功能。

处理缺失值

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
import pandas as pd
import numpy as np

def prints(a):
    print(a)
    print('='*30)

# Series
s1 = pd.Series(list([2,6,8,9,3,6,4,7,3,4]),index=list('fghjkdsabc'))

# DataFrame
df = pd.DataFrame([np.random.randn(3),[1,2,np.nan],[np.nan,4,np.nan],[1,2,3]])
prints(df)

# Step1:判断是否存在缺失值 isnull()
prints(df.isnull())
# Step2:丢弃缺失数据 dropna()
prints(df.dropna(axis=1)) # axis决定按行丢失还是按列丢失
prints(df)
# Step3:填充缺失数据 fillna()
prints(df.fillna(0))
prints(df.fillna({0:9,2:100})) # 第一列的nan替换成9，第三列的nan替换成100
prints(df.fillna(method='ffill',limit=1)) # 用nan上一列的值向下替换nan,limit限制向下填充的nan数量

层级索引

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
import pandas as pd
import numpy as np

def prints(a):
    print(a)
    print('='*30)

# Series 层级索引
s1 = pd.Series(np.random.randn(12),index=[list('aaabbbcccddd'),list([0,1,2,0,1,2,0,1,2,0,1,2])])
prints(s1)
prints(type(s1.index))
prints(s1.index)

# Series 索引选取
prints(s1['a',0])
prints(s1['a'])
prints(s1[:,2])

# Series 索引交换 
    # swaplevel() 交换内层和外层索引
prints(s1.swaplevel())
    # sortlevel() 先对外层索引进行排序，再对内层索引进行排序，默认升序
    # pandas的包中在0.23.4版本中就取消了sort方法，老版本的Series和DataFrame对象中还包含这个函数
    # 新版本中推荐使用sort_index和sort_values函数
prints(s1.swaplevel().sort_index())

归约方法与积累型方法

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
import pandas as pd
import numpy as np

def prints(a):
    print(a)
    print('='*30)

# Series 层级索引
s1 = pd.Series(np.random.randn(12),index=[list('aaabbbcccddd'),list([0,1,2,0,1,2,0,1,2,0,1,2])])
df = pd.DataFrame([np.random.rand(3),[1,2,np.nan],[np.nan,4,np.nan],[1,2,3]],index=list(['Bob','Sam','Tom','Jim']),columns=list(['Math','History','English']))
prints(df)
prints(df.sum()) # nan当作0，或者nan不参与求和计算
prints(df.sum(axis=1))
prints(df.sum(axis=1,skipna=False)) # nan参与计算
prints(df.idxmax()) # 返回最大值的索引
prints(df.cumsum()) # 样本值的累积和
prints(df.describe())

描述性统计和汇总统计方法汇总：

方法 描述
count 非NA值的个数
describe 计算各列的汇总统计集合
min, max 计算最小值、最大值
argmin, argmax 分别计算最小值、最大值所在的索引位置
idxmin, idxmax 分别计算最小值、最大值所在的索引标签
quantile 计算样本的从0到1间的分位数
sum 加和
mean 平均数
median 中位数(50%分位数)
mad 平均值的平均绝对偏差
prod 所有值的积
var 值的样本方差
std 值的样本标准差
skew 样本偏度值(第三时刻)
kurt 样本峰度值(第四时刻)
cumsum 累积和
cummin, cummax 累积和的最小值或最大值
cumprod 累积积
diff 计算第一个算术差值(对时间序列有用)
pct_change 计算百分比

相关性和协方差

相关性和协方差的方法：

方法 描述
corr 重叠的、非NA的、按索引对齐的值的相关性
corrwith 计算两个对象的相关性
cov 重叠的、非NA的、按索引对齐的值的协方差
covwith 计算两个对象的协方差

唯一值、计数与成员属性

唯一值、计数和集合成员属性的方法：

方法 描述
isin 计算表征Series中每个值是否包含于传入序列的布尔值数组
match 计算数组中每个值的整数索引，形成一个唯一值数组。有助于数据对齐和join类型的操作
unique 计算Series值中的唯一值数组，按照观察顺序返回
value_counts 返回一个Series，索引是唯一值序列，值是计数个数，按照个数降序排序

计算DataFrame多个相关列的直方图，可参考下面的例子：

1
2
3
4
5
6
data = pd.DataFrame({'Qu1':[1,3,4,3,4],'Qu2':[2,3,1,2,3],'Qu3':[1,5,2,4,4]})
print(data)
# 将pd.value_counts传入apply函数
result = data.apply(pd.value_counts).fillna(0)
print(result)
# 结果中的行标签是所有列中出现的不同值，数值则是这些不同值在每个列中出现的次数

补充知识点

数学期望：如果X是离散的随机变量，输出值为x1,x2,…,xn，和输出值相应的概率为p1,p2,…,pn(概率和为1)，那么期望值E(X)=x1 * p1 + x2 * p2 + … + xn * pn

假设有X和Y两个随机变量，它们的均值(期望值)是μX ,μY，它们的标准差是σX以及σY，E代表求数学期望，它们的协方差和相关性可以通过以下式子计算

协方差：covariance σXY=E[(X−μX)(Y−μY)]，表示的是两个变量的总体的误差

相关性：correlation ρXY=E[(X−μX)(Y−μY)]/(σXσY)，表示的是两个变量的相关性

以上数学概念详细公式可参考协方差百度百科。

lambda表达式：Lambda表达式是Python中一类特殊的定义函数的形式，使用它可以定义一个匿名函数。语法如下：

lambda 形参列表 : 函数返回值表达式语句

具体语法可参考以下实例：

1
2
3
4
5
6
7
8
9
10
11
li=[{"age":20,"name":"def"},{"age":25,"name":"abc"},{"age":10,"name":"ghi"}]

# 使用lambda表达式
li=sorted(li, key=lambda x:x["age"])
print(li)

# 不使用lambda表达式，采用常规函数
def comp(x):
    return x["age"]
li=sorted(li, key=comp)
print(li)

 今日も一日、頑張るぞう！💪

赏

谢谢你请我吃糖果

tag:

    缺失模块。
    1、请确保node版本大于6.2
    2、在博客根目录（注意不是yilia根目录）执行以下命令：
    npm i hexo-generator-json-content --save

    3、在根目录_config.yml里添加配置： 

      jsonContent:
    meta: false
    pages: false
    posts:
      title: true
      date: true
      path: true
      text: false
      raw: false
      content: false
      slug: false
      updated: false
      comments: false
      link: false
      permalink: false
      excerpt: false
      categories: false
      tags: true

萌新伊始<br><br>把这里作为记录学习和成长的平台<br><br>如果您觉得不错<br><br>可以请我喝杯咖啡☕️<br>