数据分析工具--pandas

一、简介

1.1定义

Pandas是一个强大的分析结构化数据的工具集；它的使用基础是Numpy（提供高性能的矩阵运算）；用于数据挖掘和数据分析，同时也提供数据清洗功能。

Pandas 是 Python 的核心数据分析支持库，提供了快速、灵活、明确的数据结构，旨在简单、直观地处理关系型、标记型数据。

1.2 优势

$\bullet$ 处理浮点与非浮点数据里的缺失数据，表示为 NaN；
$\bullet$ 大小可变：插入或删除 DataFrame 等多维对象的列；
$\bullet$ 自动、显式数据对齐：显式地将对象与一组标签对齐，也可以忽略标签，在 Series、 DataFrame 计算时自动与数据对齐；
$\bullet$ 强大、灵活的分组（group by）功能：拆分-应用-组合数据集，聚合、转换数据；
把 Python 和 NumPy 数据结构里不规则、不同索引的数据轻松地转换为 DataFrame 对象；
$\bullet$基于智能标签，对大型数据集进行切片、花式索引、子集分解等操作；
$\bullet$ 直观地合并（merge）、**连接（join）**数据集；
$\bullet$ 灵活地重塑（reshape）、**透视（pivot）**数据集；
$\bullet$ 轴支持结构化标签：一个刻度支持多个标签；
$\bullet$ 成熟的 IO 工具：读取文本文件（CSV 等支持分隔符的文件）、Excel 文件、数据库等来源的数据，利用超快的 HDF5 格式保存 / 加载数据；
$\bullet$ 时间序列：支持日期范围生成、频率转换、移动窗口统计、移动窗口线性回归、日期位移等时间序列功能
$\bullet$ 它是专门为了处理表格和混杂数据设计的

二、series对象

1.1定义

它是一种类似于一维数组的对象，是由一组数据(各种NumPy数据类型)以及一组与之相关的数据标签(即索引)组成。仅由一组数据也可产生简单的Series对象。

1.2 Series对象属性

# 属性一：index
s.index  # Index(['A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I', 'J'], dtype='object')
s.index=='B' 
# array([False,  True, False, False, False, False, False, False, False,False])


# 属性二：values
s.values  # array([23, 29, 24, 22, 25,  6, 28, 20, 28, 14])
s.values==23 # array([ True, False, False, False, False, False, False, False, False,False])
s.values<25  # array([ True, False,  True,  True, False,  True, False,  True, False,True])


# 属性三：size
s.size   # 10，返回元素的个数


# 属性四：shape
s.shape  # (10,)，获取形状

# 属性五：name
s.name = 'age'
s.index.name = 'gender'

1.3 生成series对象

格式：

     pd.Series(data=None,index=None,dtype=None,name=None,copy=False,fastpath=False)
     参数描述：index默认从0开始也可以自定义，可以为非整型。
               name为表的名字
               copy为复制输入的数据

创建series对象的两种方式：

$\bullet$ 列表元组等生成series对象
$\bullet$ 字典生成Series对象

直接传入一个字典

data = {'name':'tyl','age':25}
info = pd.Series(data)
info          #   name  tyl
                   age  25

传入排好序字典的键以改变顺序

index1 = ['age','name','gender']
info1 = pd.Series(data,index=index1)
info1     #  age  25
             name tyl
             gender nan

$\bullet$ array数组生成series对象

两者区别：
列表方式是生成一个副本，而array数组是引用。

在数据中使用np.nan表示空值

1.4 索引

$\bullet$ 显式索引

s=pd.Series(data=np.random.randint(1,30,size=10),index=list('ABCDEFGHIJ'))     # A    23
                                                                                 B    29
                                                                                 C    24
                                                                                 D    22
                                                                                 E    25
                                                                                 F     6
                                                                                 G    28
                                                                                 H    20
                                                                                 I    28
                                                                                 J    14
                                                                                 dtype: int32

通过索引的方式选取Series对象中的一组值或者单个值
s['C']    # 24

s[['A','G']] # A  23
               G  28
               
s.loc['C'] # 24
# 使用loc取多个值,可以放重复的索引
s.loc[['A','D','J']]  # A    23
                        D    22
                        J    14
                        dtype: int32
# 可以使用bool列表取值，但是bool列表长度需要和s对象元素个数一致
s.loc[[True,False,False,True,False,False,True,False,False,True]]  # A    23
                                                                    D    22
                                                                    G    28
                                                                    J    14
                                                                    dtype: int32
                                                                    
 使⽤NumPy函数或类似NumPy的运算（如根据布尔型数组进⾏过滤、标量乘法、应⽤数学函数等）都会保留索引值的链接
 s[s>25]  ->  s[['B','G','I']]   #  B 29
                                    G 28
                                    I 28

$\bullet$ 隐式索引

默认从0开始

s[0]   # 23
s[8]   # 28
s.iloc[8] # 28
s.iloc[[8,0,5]]   # I    28
                    A    23
                    F     6
                    dtype: int32

s.loc和s.iloc返回值都是Series类型

$\bullet$ 修改索引

就地赋值修改索引：s.index = [‘a’,‘b’,‘c’…]

1.5 切片

$\bullet$ 显式索引与列表等的切片基本一致，但是顾左也顾右。
$\bullet$ 隐式索引顾左不顾右

1.6 Series对象方法

s1 = pd.Series(data=np.random.randint(1,10,size=6),index=list('ABCDEF'))  # A    4
                                                                            B    2
                                                                            C    3
                                                                            D    8
                                                                            E    3
                                                                            F    2
                                                                            dtype: int32

# 方法一：head（n） 获取前n个元素
s.head(2)  # A    23
             B    29
             dtype: int32

# 方法二：tail（n）获取后n个元素
s.tail(2)  # I    28
             J    14
             dtype: int32

# 方法三：检测空值
s.isnull()
s.notnull()
pd.isnull(obj)
pd.notnull(obj)

# 方法四：排序
s1.sort_values() # B    2
                   F    2
                   C    3
                   E    3
                   A    4
                   D    8
                   dtype: int32

s1.sort_index()  # A    4
                   B    2
                   C    3
                   D    8
                   E    3
                   F    2
                   dtype: int32

# 方法五：值的个数统计
s1.value_counts() # 3    2
                    2    2
                    4    1
                    8    1
                    dtype: int64

# 方法六：对值进行去重
s1.unique()  # array([4, 2, 3, 8])

# 方法七：any() 判断整个数组中是否至少有一个符合条件。
# 方法八：all() 判断整个数组中是否全部满足条件。

# 方法七：丢弃指定轴的数据
s1.drop(['A','C'])

1.7 运算

Series兼容numpy array的运算
Series最重要的⼀个功能是，它会根据运算的索引标签⾃动对⻬数据

s2 = pd.Series(data=np.random.randint(1,10,size=5))  # 0    1
                                                       1    1
                                                       2    3
                                                       3    6
                                                       4    2
                                                       dtype: int32
s3 = pd.Series(data=np.random.randint(1,10,size=5))  # 0    8
                                                       1    8
                                                       2    2
                                                       3    3
                                                       4    1
                                                       dtype: int32
#进行运算时，是相同的索引对应的值进行运算
s2+s3   # 0    9
          1    9
          2    5
          3    9
          4    3
          dtype: int32

s2-s3   # 0   -7
          1   -7
          2    1
          3    3
          4    1
          dtype: int32

s2*s3    # 0     8
           1     8
           2     6
           3    18
           4     2
           dtype: int32

# 广播机制
s2 +1    # 0    2
           1    2
           2    4
           3    7
           4    3
           dtype: int32

两个Series对象可以进行基本的运算，不用形状相同
Series对象和ndarray形状相同可以进行运算

s4 = s2+5   #  0     6
               1     6
               2     8
               3    11
               4     7
               dtype: int32
s4<10       # 0     True
              1     True
              2     True
              3    False
              4     True
              dtype: bool

s4.values<10  # array([ True,  True,  True, False,  True])

# 获取值小于10的项
s4.loc[s4<10]
s4.loc[s4.values<10]

三、DataFrame

2.1 定义

DataFrame 是由多种类型的列构成的二维标签数据结构，类似于 Excel 、SQL 表，或 Series 对象构成的字典。DataFrame 是最常用的 Pandas 对象，与 Series 一样，DataFrame 支持多种类型的输入数据：

2.2 DataFrame属性

d.index   #  RangeIndex(start=0, stop=3, step=1)
d.index.name = ''
d.values #  array([[100,  48,  88],
                   [ 50,  69,  47],
                   [ 60,  40,  95]], dtype=int64)
d.columns  # Index(['python', 'java', 'php'], dtype='object')
d.colums.name = ''
d.dtypes  # python    int64
            java      int64
             php       int64
            dtype: object

2.3 创建DataFrame对象

格式：

pd.DataFrame(data=None,index=None,columns=None,dtype=None,copy=False)

如果传入的列在数据中找不到，会自动用NAN补齐

# 方式一：通过numpy的array对象创建

p = pd.DataFrame(data=np.random.randint(40,100,size=(5,3)),index=('a','b','c','d','e'),columns=('python','java','php'))

# 
   python java	php
a	47	49	98
b	82	56	42
c	56	87	99
d	49	41	78
e	58	41	62

# 方法二： 通过字典创建

dict1 = {'python':[100,50,60],
         'java':[48,69,40],
         'php':[88,47,95]}
d = pd.DataFrame(data=dict1)  
# 	python	java	php
0	100	48	88
1	50	69	47
2	60	40	95
#  此方式字典的values必须为一维array数组、列表、series一维数组

嵌套字典传给DataFrame，pandas就会被解释为：外层字典的键作为列，内层键则作为⾏索引

# 方法三：通过传递一个 numpyarray，时间索引以及列标签来创建一个DataFrame
dates = pd.date_range('20130101', periods=6)
df = pd.DataFrame(np.random.randn(6,4), index=dates, columns=list('ABCD'))

2.4 索引和切片

# 索引
d2 = pd.DataFrame(data=np.random.randint(1,100,size=(4,3)),columns=('python','java','php'),index=('lucy','tony','jack','mark'))
#  
    python	java php
lucy	6	99	89
tony	46	5	58
jack	67	28	3
mark	61	19	79

# 获取某列
d2['python']
d2.python  这种方式不适用于所有的列
           它返回Series对象，并且拥有原DataFrame对象的索引，并且name也被设为python
# 获取某几列
d2[['python','php']]
d2.loc[:,['python','php']]
# 获取某几行某几列
d2.loc[['lucy','jack'],['python','php']]
# 获取一个元素
d2.loc['mark','php']
# bool列表的访问
d2.loc[[True,False,False,False]]  # 获取第一行
d2.drop(['tony','jack','mark'])
d2[[True,False,False,False]]      # 获取第一行
d2.loc[:,[True,False,True]]       #  获取一三列

# 切片
d2[0:2]    # 获取第一二行
d2.iloc[0:2]  # 获取第一二行

# Index 对象

index对象是不可变的，可以使Index对象在多个数据结构之间安全共享
Index的功能也类似⼀个固定⼤⼩的集合
pandas的Index可以包含重复的标签

2.5 运算

# 与一个数的运算，运用广播机制
d2+1   # 所有数+1

# 与numpy array数组的运算
arr = np.ones(3,dtype=int)  # [1,1,1]
arr+d2 
# 	 python	java php
lucy	7	100	90
tony	47	6	59
jack	68	29	4
mark	62	20	80

# 与Series对象运算
s = pd.Series(data=[1,2,3],index=['python','java','php'])
d2+s
# 	python	java	php
lucy	7	101	92
tony	47	7	61
jack	68	30	6
mark	62	21	82

默认情况下，DataFrame和Series之间的算术运算会将Series的索引匹配到DataFrame的列，然后沿着⾏⼀直向下⼴播
如果你希望匹配⾏且在列上⼴播，则必须使⽤算术运算⽅法 

2.6 DataFrame对象方法

方法名	描述
df.describe()	数据的快速统计汇总
df.T	数据的转置
df.sort_index()	按轴进行排序
df.sort_values()	按值进行排序
df.reindex(index,method,fill_value)	创建一个数据符合新索引的新对象
df.drop()	丢弃指定轴的数据
df.add(df1,fill_value)	将两个df对象相加，缺失值用指定数代替
df.sub()	两个df对象之差
df.apply(f)	将函数应⽤到由各列或⾏所形成的⼀维数组上

2.7 从文件中读取数据创建DataFrame对象

逐块读取文件：

读取几行可以使用nrows参数

逐块读取需要指定chunksize参数，返回一个TextParse对象，用于迭代。它有一个get_chunk方法，使我们可以读取任意大小的数据块

2.8 数据库访问

import pymysql
conn = pymysql.connect(host='127.0.0.1',port=3306,user='tyl',password='tyl',db='mydb')
sql='select * from department'
pd.read_sql(sql,conn)
conn.close()

2.9 分组

2.9.1 分组操作格式：

分组的一般模式：

               df.groupby(分组依据)[数据来源].使用操作

多维度分组(根据列名分组 )

              df.groupby(['分组依据1','分组依据2'，...])[数据来源].使用操作

根据复杂逻辑分组：

              df.groupby(condition)[数据来源].使用操作

查看分组类别：

              df.drop_duplicates()

2.9.2 groupby对象

改对象本身不会返回什么，只有调用方法后才会起作用

属性：

属性名	描述
ngroups	查看分组个数
groups	返回组名映射到组索引列表的字典
size	统计每个组的元素个数
ngroups	返回组数

方法：

方法名	描述
get_group(name, obj=None)	获取该组所在的行即，使用提供的名称从组构造DataFrame。
head()	返回每个组的前几行
first()	返回以分组为索引的每组的第一个分组信息

2.9.3 分组三大操作‘

聚合函数：

根据返回标量值原则，常见的聚合函数有：

max、min、mean、median中位数、count不统计NAN值、size统计元素个数，包含NAN值、all、any、idxmax、idxmin、mad、nunique去重再计数、skew、quantile、sum、std、var、sem、prod

agg方法：

groupby对象其他函数的缺点：

$\bullet$ 无法同时使用多个函数
$\bullet$ 无法对特定的列使用特定的聚合函数
$\bullet$ 无法使用自定义的聚合函数
$\bullet$ 无法对结果的列名在聚合前进行自定义命名

agg方法克服了上述的四个缺点：

① 使用多个函数

                  gb.agg(['函数1','函数2','函数3',.....])

此时返回的列索引为多级索引，第一层为数据源，第二层为聚合函数

② 对特定的列使用特定的聚合函数

                  gb.agg({'列1':'聚合函数1','列2':['聚合函数2','聚合函数3']})

通过向agg方法的参数中传入字典实现，字典的键为列名，值为聚合函数

③ 使用自定义函数

                  gb.agg(lambda 变量:条件)

需要注意传入函数的参数是之前数据源的列，逐列计算

④ 聚合结果重命名

                  gb.agg([('新名字','聚合函数1'),('新名字','聚合函数2')])

变换：

返回一个Series对象，与原序列同长度

常用的内置变换函数为累计函数：cumsum、cumcount、cumprod、cummax、rank

自定义变换使用transform方法，参数为自定义函数还可以为聚合函数

过滤：
fliter函数

filter函数是用来筛选某些组的（务必记住结果是组的全体），因此传入的值应当是布尔标量

2.9.4 跨列分组

四、pandas函数

函数名	描述
cut( )	将值归为离散间隔。