Python之Pandas库学习(1)

Pandas库简介

pandas是一个开源的, BSD许可的库, 为Python编程语言提供高性能, 易于使用的数据结构和数据分析工具.

Pandas库的安装

安装Pandas库的最快也是最简单的方法是在shell上使用以下命令：
pip install pandas
一般使用时直接import即可
import pandas as pd

Pandas库的Series类型

Series类型的创建

Serise类型是由一组数据及其相关的索引组成, 是一维数据类型.

pandas.Series(data=None, index=None, dtype=None, name=None, copy=False, fastpath=False) [官方文档]

data : 列表, 迭代对象, 字典, 或标量. 也可以使用ndarry数组.
index : 数据索引, 若不给出则自动生成索引.
dtype : 数据类型.
copy : 是否复制输出数据.

例如:

>>> import pandas as pd
>>> a = pd.Series([9, 8, 7, 6])
>>> a
0    9
1    8
2    7
3    6
dtype: int64
>>> b = pd.Series({'a':9, 'b':8, 'c':7})
>>> b
a    9
b    8
c    7
dtype: int64
>>> c = pd.Series({'a':9, 'b':8, 'c':7}, index={'c', 'a', 'b', 'd'})
>>> c
c    7.0
d    NaN
b    8.0
a    9.0
dtype: float64
>>> import numpy as np
>>> d = pd.Series(np.arange(5), index=np.arange(9, 4, -1))
>>> d
9    0
8    1
7    2
6    3
5    4
dtype: int32

需要注意的是, 当用户自定义索引之后, 自动索引与自定义索引并存, 均可以使用, 但不能混合使用.

Series类型的基本操作

Series类型的操作和ndarry有相似之处, 均可使用[]方法进行索引和切片.与dict也有相同的方法, 均可以使用in和get().

函数	描述
Series.index	获取Series的index
Series.values	获取Series的values
Series.get(key, default=None)	获取key对应的值, 如无返回default
Series.name	返回Series类型的name

例如:

>>> import pandas as pd
>>> a = pd.Series({'a':9, 'b':8, 'c':7})
>>> a
a    9
b    8
c    7
dtype: int64
>>> a.index
Index(['a', 'b', 'c'], dtype='object')
>>> a.values
array([9, 8, 7], dtype=int64)
>>> 9 in a
False
>>> 'a' in a
True
>>> a.get('d', 100)
100
>>> a.name = 'Series'
>>> a.index.name = '索引'
>>> a
索引
a    9
b    8
c    7
Name: Series, dtype: int64

Series类型同样可以简单赋值或者相加减:

>>> a['a', 'b'] = 20
>>> a
索引
a    20
b    20
c     7
Name: Series, dtype: int64
>>> b = pd.Series({'a':4, 'c':5, 'd':6})
>>> b
a    4
c    5
d    6
dtype: int64
>>> a + b
a    24.0
b     NaN
c    12.0
d     NaN
dtype: float64

其他Series函数可以参考相关文档 .

Pandas库的DataFrame类型

DataFrame类型的创建

DataFrame类型由共用相同索引的一组列组成, 是多维数据类型.

pandas.DataFrame(data=None, index=None, columns=None, dtype=None, copy=False)) [官方文档]

data: ndarray数组, 列表, 字典, 元组, Series字典, Series数据或其他DataFrame类型数据.
index: 数据索引, 若不给出则自动生成索引.
columns: 列数据索引.
dtype: 数据类型.
copy: 是否复制输出数据.

DateFrame是一个表格型的数据类型, 每列值类型可以不同.
DataFrame既有行索引也有列索引.
DataFrame常用于表达二维数据, 但可表达多维数据.

例如:

>>> import pandas as pd
>>> import numpy as np
>>> a = pd.DataFrame(np.arange(10).reshape(2, 5))
>>> a
   0  1  2  3  4    #自动生成了行索引和列索引
0  0  1  2  3  4
1  5  6  7  8  9
>>> b = {'one': pd.Series([1, 2, 3], index=['a', 'b', 'c']), 'two': pd.Series([9, 8, 7, 6], index=['a', 'b', 'c', 'd'])}
>>> c = pd.DataFrame(b)
>>> c
   one  two
a  1.0    9
b  2.0    8
c  3.0    7
d  NaN    6
>>> pd.DataFrame(c, index=['b', 'c', 'd'], columns=['two', 'three'])
   two  three
b    8    NaN
c    7    NaN
d    6    NaN
>>> d = {'姓名':['YaoLin', 'ChenRuiyi', 'LiXin', 'ZhangQin'], '性别':['男', '女', '男', '女'], '成绩':[87, 88, 88, 83], '干部':[True, False, False, True]}
>>> e = pd.DataFrame(d, index=[1, 2, 3, 4])
>>> e
          姓名 性别  成绩     干部
1     YaoLin  男  87   True
2  ChenRuiyi  女  88  False
3      LiXin  男  88  False
4   ZhangQin  女  83   True

DataFrame类型的基本操作

Frame类型的操作和Series很相似, 根据行列索引.

函数	描述
DataFrame.index	获取DataFrame的index
DataFrame.columns	获取DataFrame的columns
DataFrame.values	获取DataFrame的values
DataFrame.loc[columns]	返回选中列的Series类型数据

例如:

>>> e.index
Int64Index([1, 2, 3, 4], dtype='int64')
>>> e.columns
Index(['姓名', '性别', '成绩', '干部'], dtype='object')
>>> e.values
array([['YaoLin', '男', 87, True],
       ['ChenRuiyi', '女', 88, False],
       ['LiXin', '男', 88, False],
       ['ZhangQin', '女', 83, True]], dtype=object)
>>> e.loc[2]
姓名    ChenRuiyi
性别            女
成绩           88
干部        False
Name: 2, dtype: object
>>> e['成绩'][3]    #联合索引
88

Pandas库的数据类型操作

重新索引

重新索引的方法为:

Series.reindex(index=None) [官方文档]

DataFrame.reindex(labels=None, axis=None, index=None, columns=None, method=None, copy=True, level=None, fill_value=nan, limit=None) [官方文档]

label: 新的自定义索引, axis=0时为行, axis=1时为列.
axis: 定义label指定的索引.
index, columns: 新的行列自定义索引.
method: {None, ‘backfill’/‘bfill’, ‘pad’/‘ffill’, ‘nearest’}, 用于填充重新索引的空白数据的方法.
- None (default): 不填充.
- pad / ffill: 当前值由前值填充.
- backfill / bfill: 当前值由后值填充.
- nearest: 当前值由最近的值填充.
copy: 是否返回新的数据.
level: 匹配更深层次索引.
fill_value: 用于填充空白数据的值
limit: 最大填充值

例如:

# 接上一个例子
>>> e.reindex(index=[4, 3, 2, 1])
          姓名 性别  成绩     干部
4   ZhangQin  女  83   True
3      LiXin  男  88  False
2  ChenRuiyi  女  88  False
1     YaoLin  男  87   True
>>> e.reindex(columns=['性别','成绩','干部','姓名'])
  性别  成绩     干部         姓名
1  男  87   True     YaoLin
2  女  88  False  ChenRuiyi
3  男  88  False      LiXin
4  女  83   True   ZhangQin
>>> col0 = e.columns.insert(4, '新增')
>>> col0
Index(['姓名', '性别', '成绩', '干部', '新增'], dtype='object')
>>> f = e.reindex(columns=col1, fill_value=200)
>>> f
          姓名 性别  成绩     干部   新增
1     YaoLin  男  87   True  200
2  ChenRuiyi  女  88  False  200
3      LiXin  男  88  False  200
4   ZhangQin  女  83   True  200

索引的常用方法

索引的常用方法有:

方法	描述
.append(idx)	连接另一个Index对象, 产生新的Index对象
.diff(idx)	计算差集, 产生新的Index对象
.intersection(idx)	计算交集
.union(idx)	计算并集
.delete(loc)	删除loc位置处的元素
.insert(loc, e)	在loc位置增加一个元素e

例如:

# 接上一个例子
>>> col1 = f.columns.delete(2)
>>> col1
Index(['姓名', '性别', '干部', '新增'], dtype='object')
>>> col2 = f.index.insert(5, 5)
>>> col2
Int64Index([1, 2, 3, 4, 5], dtype='int64')
>>> g = f.reindex(index=ind1, columns=col1)
>>> g
          姓名   性别     干部     新增
1     YaoLin    男   True  200.0
2  ChenRuiyi    女  False  200.0
3      LiXin    男  False  200.0
4   ZhangQin    女   True  200.0
5        NaN  NaN    NaN    NaN

删除指定索引对象

Series.drop(labels=None, axis=0, index=None, columns=None, inplace=False, level=None) [官方文档]

DataFrame.drop(labels=None, axis=0, index=None, columns=None, inplace=False, level=None) [官方文档]

label: 要删除的索引, 当axis=0时指行索引, axis为1时指列索引.
axis: 定义label指定的索引.
index, columns: 要删除行索引, 列索引.
inplace: 为True时无返回值.
level 匹配更深层次的索引, 将移除标签级别的数据.

例如:

>>> import pandas as pd
>>> import numpy as np
# Series:
>>> s = pd.Series(data=np.arange(3), index=['A','B','C'])
>>> s
A    0
B    1
C    2
dtype: int32
>>> s.drop(labels=['B','C'])
A    0
dtype: int32
>>> midx = pd.MultiIndex(levels=[['lama', 'cow', 'falcon'], ['speed', 'weight', 'length']], codes=[[0, 0, 0, 1, 1, 1, 2, 2, 2],  [0, 1, 2, 0, 1, 2, 0, 1, 2]])
>>> s = pd.Series([45, 200, 1.2, 30, 250, 1.5, 320, 1, 0.3], index=midx)
>>> s
lama    speed      45.0
        weight    200.0
        length      1.2
cow     speed      30.0
        weight    250.0
        length      1.5
falcon  speed     320.0
        weight      1.0
        length      0.3
dtype: float64
>>> s.drop(labels='weight', level=1)
lama    speed      45.0
        length      1.2
cow     speed      30.0
        length      1.5
falcon  speed     320.0
        length      0.3
dtype: float64
# DataFrame
>>> df = pd.DataFrame(np.arange(12).reshape(3, 4), columns=['A', 'B', 'C', 'D'])
>>> df
   A  B   C   D
0  0  1   2   3
1  4  5   6   7
2  8  9  10  11
>>> df.drop(['B', 'C'], axis=1)
   A   D
0  0   3
1  4   7
2  8  11
>>> midx = pd.MultiIndex(levels=[['lama', 'cow', 'falcon'], ['speed', 'weight', 'length']], codes=[[0, 0, 0, 1, 1, 1, 2, 2, 2], [0, 1, 2, 0, 1, 2, 0, 1, 2]])
>>> df = pd.DataFrame(index=midx, columns=['big', 'small'], data=[[45, 30], [200, 100], [1.5, 1], [30, 20], [250, 150], [1.5, 0.8], [320, 250], [1, 0.8], [0.3, 0.2]])
>>> df
                big     small
lama    speed   45.0    30.0
        weight  200.0   100.0
        length  1.5     1.0
cow     speed   30.0    20.0
        weight  250.0   150.0
        length  1.5     0.8
falcon  speed   320.0   250.0
        weight  1.0     0.8
        length  0.3     0.2
>>> df.drop(index='length', level=1)
                big     small
lama    speed   45.0    30.0
        weight  200.0   100.0
cow     speed   30.0    20.0
        weight  250.0   150.0
falcon  speed   320.0   250.0
        weight  1.0     0.8

Pandas库的数据类型运算

算数运算法则

算数运算根据行列索引, 补齐后运算, 运算默认产生浮点数.
补齐时缺项填充NaN.
二维和一维, 一维和零维之间为广播运算.
采用+-*/符号进行的二元运算产生新的对象.

例如:

>>> import pandas as pd
>>> import numpy as np
>>> a = pd.DataFrame(np.arange(12).reshape(3, 4))
>>> a
   0  1   2   3
0  0  1   2   3
1  4  5   6   7
2  8  9  10  11
>>> b = pd.DataFrame(np.arange(20).reshape(4, 5))
>>> b
    0   1   2   3   4
0   0   1   2   3   4
1   5   6   7   8   9
2  10  11  12  13  14
3  15  16  17  18  19
>>> a + b
      0     1     2     3   4
0   0.0   2.0   4.0   6.0 NaN
1   9.0  11.0  13.0  15.0 NaN
2  18.0  20.0  22.0  24.0 NaN
3   NaN   NaN   NaN   NaN NaN
>>> a * b
      0     1      2      3   4
0   0.0   1.0    4.0    9.0 NaN
1  20.0  30.0   42.0   56.0 NaN
2  80.0  99.0  120.0  143.0 NaN
3   NaN   NaN    NaN    NaN NaN

还有方法形式的运算:

方法	描述
.add(d, **argws)	类型间加法运算, 可选参数
.sub(d, **argws)	类型间减法运算, 可选参数
.mul(d, **argws)	类型间乘法运算, 可选参数
.div(d, **argws)	类型间除法运算, 可选参数

**argws(可选参数)包含的参数有:

axis: {0/‘index’, 1/‘columns’} 指定运算的轴.
level: 匹配更深层次索引.
fill_value: 指定缺省值.

例如:

>>> df = pd.DataFrame({'angles': [0, 3, 4], 'degrees': [360, 180, 360]}, index=['circle', 'triangle', 'rectangle'])
>>> df
           angles  degrees
circle          0      360
triangle        3      180
rectangle       4      360
>>> df - [1, 2]
           angles  degrees
circle         -1      358
triangle        2      178
rectangle       3      358
>>> df.sub([1, 2], axis='columns')
           angles  degrees
circle         -1      358
triangle        2      178
rectangle       3      358

比较运算法则

比较运算只能比较相同索引的元素, 不进行补齐.
二维和一维, 一维和零维之间维广播运算.
采用 > < >= <= == != 等符号进行的二元运算产生布尔对象.

例如:

>>> import pandas as pd
>>> import numpy as np
>>> a = pd.DataFrame(np.arange(12).reshape(3, 4))
>>> a
   0  1   2   3
0  0  1   2   3
1  4  5   6   7
2  8  9  10  11
>>> b = pd.DataFrame(np.arange(12, 0, -1).reshape(3, 4))
>>> b
    0   1   2  3
0  12  11  10  9
1   8   7   6  5
2   4   3   2  1
>>> a > b
       0      1      2      3
0  False  False  False  False
1  False  False  False   True
2   True   True   True   True
>>> c = pd.Series(np.arange(4))
>>> c
0    0
1    1
2    2
3    3
dtype: int32
>>> a > c    # 广播运算
       0      1      2      3
0  False  False  False  False
1   True   True   True   True
2   True   True   True   True
>>> c > 1
0    False
1    False
2     True
3     True
dtype: bool