Pandas库入门

Python
字数统计: 2.8k   |   阅读时长≈ 13 分钟

Pandas库入门

简介

Pandas是python第三方库，以提供高性能易用数据类型和分析工具。Pandas基于NumPy实现，常与NumPy和Matplotlib一同使用

1
import pandas as pd

Pandas库的理解

Pandas主要提供两个数据类型：Series和DataFrame

  • Series相当于一维的数据类型
  • DataFrame相当于二维（N维）的数据类型

基于上述数据类型的各类操作有：基本操作、运算操作、特征类操作、关联类操作

NumPy Pandas
基础数据类型 扩展数据类型
关注数据的结构表达 关注数据的应用表达
维度：数据间关系 数据与索引关系

Series类型

Series类型由一组数据及与之相关的数据索引组成

例如：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
>>> a = pd.Series([9, 9, 7, 6])
>>> a
# 第一列为自动索引
# 第二列为传入的列表值
0    9
1    9
2    7
3    6
dtype: int64
    
# 自定义索引，其中index参数位于第二个参数时，可以不指定index
>>> b = pd.Series([9, 8, 7, 6], index=['a', 'b', 'c', 'd'])
>>> b
a    9
b    8
c    7
d    6
dtype: int64

Series类型可以由如下类型创建：

  • python列表
  • 标量值
    • s = pd.Series(25, index=['a', 'b', 'c'])，这里的index不能省略
  • python字典
    • d = pd.Series({'a':9, 'b':8, 'c':7})
    • e = pd.Series({'a':9, 'b':8, 'c':7}, index=['c', 'a', 'b', 'd'])
  • ndarray
    • n = pd.Series(numpy.arange(5))
    • n = pd.Series(numpy.arange(5), index=numpy.arange(9, 4, -1))
  • 其他函数

Series类型的基本操作

Series类型包括index和values两部分

Series类型的操作类似ndarray类型

  • 索引方法相同，使用[]

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    >>> b = pd.Series([9, 8, 7, 6], ['a', 'b', 'c', 'd'])
    >>> b.index
    Index(['a', 'b', 'c', 'd'], dtype='object')	# Series.index的类型为Index，为pandas内建的类型，不可修改
    >>> b.values
    array([9, 8, 7, 6], dtype=int64)	# Series.values的类型为array，沿用了ndarray


    >>> b['b']
    8
    >>> b[1]	# 自动索引是默认生成的，但自动索引和自定义索引不能混用
    8
    >>> b[['c', 'd', 'a']]
    c    7
    d    6
    a    9
    dtype: int64

  • NumPy中运算和操作可用于Series类型

  • 可以通过Series自定义索引的类别进行切片

  • 可以通过自动索引进行切片，如果存在自定义索引，则一同被切片

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    # 切片
    >>> b
    a    9
    b    8
    c    7
    d    6
    dtype: int64
    >>> b[3]
    6
    >>> b[:3]
    a    9
    b    8
    c    7
    dtype: int64
    >>> b[b > b.median()]	# 大于中位数的
    a    9
    b    8
    dtype: int64

    Series类型的操作类似python字典类型

  • 通过自定义索引访问

  • 保留字in操作

  • 使用.get()方法

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    >>> b
    a    9
    b    8
    c    7
    d    6
    dtype: int64
    >>> b['b']
    8
    >>> 'c' in b	# 可以判断自定义索引
    True
    >>> 0 in b		# 不能判断自动索引
    False
    >>> b.get('f', 100)
    100

Series类型对齐操作

Series对齐操作：Series + Series，索引值相同的进行运算，索引不同的不进行运算

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
>>> a = pd.Series([1, 2, 3], ['c', 'd', 'e'])
>>> a
c    1
d    2
e    3
dtype: int64
>>> b
a    9
b    8
c    7
d    6
dtype: int64
>>> a + b
a    NaN
b    NaN
c    8.0
d    8.0
e    NaN
dtype: float64

Series类型的name

Series对象和索引都可以有一个名字，存储在属性.name中

1
2
3
4
5
6
7
8
9
10
11
>>> b.name = 'Series对象'
>>> b.index.name = '索引对象'
>>> b
索引对象
a    9
b    8
c    7
d    6
Name: Series对象, dtype: int64
>>> b.index
Index(['a', 'b', 'c', 'd'], dtype='object', name='索引对象')

Series类型的修改

Series对象可以随时修改并立即生效

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
>>> b
索引对象
a    9
b    8
c    7
d    6
Name: Series对象, dtype: int64
>>> b['a'] = 15
>>> b.name = 'New Series'
>>> b['b', 'c'] = 20
>>> b
索引对象
a    15
b    20
c    20
d     6
Name: New Series, dtype: int64

DataFrame类型

DataFrame类型由共用相同索引的一组列组成，如下纵向的叫做index，其坐标轴为axis=0，横向的叫做column，其坐标轴为axis=1

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

DataFrame可以由以下类型来创建：

  • 二维ndarray对象

    • pd.DataFrame(numpy.arange(10).reshape(2, 5))

  • 一维ndarray、列表、字典、元组或Series构成的字典

    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
    # 由Series构成的字段创建DataFrame
    # 字典中的键成了列索引
    >>> dt = {'one':pd.Series([1,2,3], index=['a','b','c']),
    ... 'two':pd.Series([9, 9, 7, 6], index=['a','b','c','d'])}
    >>> d = pd.DataFrame(dt)
    >>> d
       one  two
    a  1.0    9
    b  2.0    9
    c  3.0    7
    d  NaN    6

    >>> pd.DataFrame(dt, index=['b', 'c', 'd'], columns=['two', 'three'])
       two three
    b    9   NaN
    c    7   NaN
    d    6   NaN

    # 以列表类似的字典创建
    >>> dl = {'one':[1,2,3,4], 'two':['a', 'b', 'c', 'd']}
    >>> d = pd.DataFrame(dl, index=['a', 'b', 'c', 'd'])
    >>> d
       one two
    a    1   a
    b    2   b
    c    3   c
    d    4   d

  • Series类型

  • 其他DataFrame类型

DataFrame类型的基本操作

通过[columns]直接获取columns数据，此数据为Series类型，通过[columns][index]获取value

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
>>> d
   one two
a    1   a
b    2   b
c    3   c
d    4   d
# 获取one column数据
>>> d['one']
a    1
b    2
c    3
d    4
# 获取two column数据
>>> d['two']
a    a
b    b
c    c
d    d
# 获取value
>>> d['one']['b']
2

Pandas库的数据类型操作

改变Series和DataFrame对象

  • 增加或重排：重新索引

  • 删除：drop

1
2
3
4
5
6
7
8
9
10
11
12
>>> dl = {'城市':['北京','上海','广州','深圳','沈阳'],
... '环比':[101.5,101.2,101.3,102.0,100.1],
... '同比':[120.7,127.3,119.4,140.9,101.4],
... '定基':[121.4,127.8,120.0,145.5,101.6]}
>>> d = pd.DataFrame(dl, index=['c1','c2','c3','c4','c5'])
>>> d
    城市     环比     同比     定基
c1  北京  101.5  120.7  121.4
c2  上海  101.2  127.3  127.8
c3  广州  101.3  119.4  120.0
c4  深圳  102.0  140.9  145.5
c5  沈阳  100.1  101.4  101.6

重新索引

.reindex()能够改变或重排Series和DataFrame索引

  • 以columns重排列

    1
    2
    3
    4
    5
    6
    7
    8
    >>> d = d.reindex(columns=['城市', '定基','同比', '环比'])
    >>> d
        城市     定基     同比     环比
    c1  北京  121.4  120.7  101.5
    c2  上海  127.8  127.3  101.2
    c3  广州  120.0  119.4  101.3
    c4  深圳  145.5  140.9  102.0
    c5  沈阳  101.6  101.4  100.1

  • 以index重排列

    1
    2
    3
    4
    5
    6
    7
    8
    >>> d = d.reindex(index=['c5','c4','c3','c2','c1'])
    >>> d
        城市     定基     同比     环比
    c5  沈阳  101.6  101.4  100.1
    c4  深圳  145.5  140.9  102.0
    c3  广州  120.0  119.4  101.3
    c2  上海  127.8  127.3  101.2
    c1  北京  121.4  120.7  101.5

索引类型的常用方法

在Series和DataFrame的索引是Index类型，Index对象本身属于不可修改的，其常用方法如下：

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

  • 插入一个新的columns

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    >>> newc = d.columns.insert(4, '新增')	# 获取原来的columns，inser插入了一个新列
    >>> newc
    Index(['城市', '定基', '同比', '环比', '新增'], dtype='object')
    >>> newd = d.reindex(columns=newc, fill_value=200)	# 以新的columns列表重新排列，并设置填充值fill_value为200
    >>> newd
        城市     定基     同比     环比   新增
    c5  沈阳  101.6  101.4  100.1  200
    c4  深圳  145.5  140.9  102.0  200
    c3  广州  120.0  119.4  101.3  200
    c2  上海  127.8  127.3  101.2  200
    c1  北京  121.4  120.7  101.5  200

  • 删除第二个columns，插入一个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
    >>> d
        城市     定基     同比     环比
    c5  沈阳  101.6  101.4  100.1
    c4  深圳  145.5  140.9  102.0
    c3  广州  120.0  119.4  101.3
    c2  上海  127.8  127.3  101.2
    c1  北京  121.4  120.7  101.5
    # 删除columns
    >>> nc = d.columns.delete(2)
    >>> nc
    Index(['城市', '定基', '环比'], dtype='object')
    # 增加index
    >>> ni = d.index.insert(5, 'c0')
    >>> ni
    Index(['c5', 'c4', 'c3', 'c2', 'c1', 'c0'], dtype='object')
    # 重排，c0由c1填充
    # 这里如果是nd = d.reindex(index=ni, columns=nc, method='ffill')则会报错，可能是pandas版本不同
    >>> nd = d.reindex(index=ni, columns=nc).ffill()
    >>> nd
        城市     定基     环比
    c5  沈阳  101.6  100.1
    c4  深圳  145.5  102.0
    c3  广州  120.0  101.3
    c2  上海  127.8  101.2
    c1  北京  121.4  101.5
    c0  北京  121.4  101.5

drop删除索引元素

.drop可以删除Series和DataFrame指定的行或列索引

  • Series删除索引元素

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    >>> a = pd.Series([9,8,7,6], index=['a','b','c','d'])
    >>> a
    a    9
    b    8
    c    7
    d    6
    dtype: int64
    >>> a.drop(['b','c'])
    a    9
    d    6
    dtype: int64

  • DataFrame删除指定行、列索引元素

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    >>> d
        城市     定基     同比     环比
    c5  沈阳  101.6  101.4  100.1
    c4  深圳  145.5  140.9  102.0
    c3  广州  120.0  119.4  101.3
    c2  上海  127.8  127.3  101.2
    c1  北京  121.4  120.7  101.5
    # 删除index c5，默认axis=0
    >>> d.drop('c5')
        城市     定基     同比     环比
    c4  深圳  145.5  140.9  102.0
    c3  广州  120.0  119.4  101.3
    c2  上海  127.8  127.3  101.2
    c1  北京  121.4  120.7  101.5
    # 删除columns 城市，需要指定axis=1
    >>> d.drop('城市', axis=1)
           定基     同比     环比
    c5  101.6  101.4  100.1
    c4  145.5  140.9  102.0
    c3  120.0  119.4  101.3
    c2  127.8  127.3  101.2
    c1  121.4  120.7  101.5

Pandas库数据类型运算

算术运算法则

  • 根据行列索引，补齐后运算，运算默认产生浮点数
  • 补齐残缺项默认填充NaN
  • 维度不同运算采取广播运算
    • 广播运算，即低维度的将作用到高维度的每个数据上
    • 一维Series默认在axis=1轴上参与运算
  • 采用+-*/符号进行的二元运算会产生新的对象
  • 运算也有一些方法，如.add/.sub等，采用方法可以多设定一些额外参数

比较运算法则

  • 比较运算只能比较相同索引的元素，不进行补齐
  • 不同维度采取 广播运算
  • 采用> < >= <= == !=等符号进行的二元运算会产生布尔对象

参考

pandas documentation

pandas - API reference

打赏
  • 版权声明： 本博客所有文章除特别声明外，著作权归作者所有。转载请注明出处！
  • Copyrights © 2021 lzeroyuee
  • 访问人数: | 浏览次数:

请我喝杯咖啡吧~

支付宝
微信