Python Pandas 的使用——Series

Python Pandas 的使用——Series

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

1. Pandas 安装

官方推荐的安装方式是通过Anaconda安装，但Anaconda太过庞大，若只是需要Pandas的功能，则可通过PyPi方式安装。

pip install Pandas

2. Pandas 的数据结构——Series

使用pandas前需要先引入pandas，若无特别说明，pd作为Pandas别名的通用写法

import pandas as pd   

2.1 Series的创建

• Series定义
  • Series像是一个Python的dict类型，因为它的索引与元素是映射关系
  • Series也像是一个ndarray类型，因为它也可以通过series_name[index]方式访问
  • Series是一维的，但能够存储不同类型的数据
  • 每个Series都有一组索引与数据对应，若不指定则默认为整型索引
• 不显式指定index

# Series 默认索引（不显式指定index，则Series使用默认索引，[0, 1, 2, 3, 4...]
series1 = pd.Series([10, 7, -4, 1])

# 或者通过以下方式创建Series
l = [10, 7, -4, 1]
series1 = pd.Series(l)

out:
    series1
0    10
1     7
2    -4
3     1
dtype: int64

• 显式指定index

series2 = pd.Series(['ant', 'bear', 'cat', 'dog'], index=['a', 'b', 'c', 'd'])

# 或者通过以下方式创建Series
l = ['ant', 'bear', 'cat', 'dog']
index = ['a', 'b', 'c', 'd']
series1 = pd.Series(l, index=index)

out:
    series2
a     ant
b    bear
c     cat
d     dog
dtype: object

Pandas 中整型为int64，浮点型为float64，字符串、布尔型等其他数据类型为object

• 通过dict生成Series

d = {'b': 1, 'a': 0, 'c': 2}
series3 = pd.Series(d)

out:
    series3
b    1
a    0
c    2
dtype: int64

相比于python中的dict，Series中索引与元素是一种映射关系，元素在Series对象中是有序存储的，并是通过索引实现其有序的。

如果python版本 >= 3.6 并且 Pandas 版本 >= 0.23 , 则通过dict创建的Series索引按照dict的插入顺序排序

如果python版本 < 3.6 或者 Pandas 版本 < 0.23，则通过dict创建的Series索引按照按词汇顺序排列

• 指定dict索引顺序创建Series

d = {'b': 1, 'a': 0, 'c': 2, 'd': 3}
names = ['a', 'b', 'c']
series4 = pd.Series(d,index=names)

out:
    series4
a    0
b    1
c    2
dtype: int64

由原先的 [‘b’, ‘a’, ‘c’] 变成了指定的 [‘a’,‘b’,‘c’]，对于指定索引names未出现的index ’d’ ，则自动过滤掉了，若names中出现dict中没有的索引，则该索引对应值为NaN

d = {'b': 1, 'a': 0, 'c': 2, 'd': 3}
names = ['a', 'b', 'c' ,'e']
series4 = pd.Series(d,index=names)

out:
    series4
a    0.0
b    1.0
c    2.0
e    NaN
dtype: float64

• 通过ndarray创建

series5 = pd.Series(np.random.randn(5), index=['a', 'b', 'c', 'd', 'e'])

# 或者通过以下方式创建Series
l = np.random.randn(5)
index = ['a', 'b', 'c', 'd', 'e']
series1 = pd.Series(l, index=index)

out:
    series5
a    1.025255
b   -0.684486
c    1.870848
d   -0.517517
e   -0.087879
dtype: float64

• 通过标量创建

Pandas 通过标量(scalar)创建Series 有两种，一种是创建int64，另一种则是float64，区别在于标量类型

series6 = pd.Series(5, index=['a', 'b', 'c'])
series7 = pd.Series(5.0, index=['a', 'b', 'c'])

# 对于创建float64来说，可缩写标量，eg：
series7 = pd.Series(5., index=['a', 'b', 'c'])

out:
    series6
a    5
b    5
c    5
dtype: int64
    
    series7
a    5.0
b    5.0
c    5.0
dtype: float64

2.2 Series元素的访问

• series_name[index] 方式

一如 ndarray 对元素的访问采 用ndarray_name[index] 的方式，Series 的访问也可采用 series_name[index] 方式访问。

这里的index指的是在不给Series显式指定index的时候，Series默认的整型索引

print(series2[0])  # out:ant
print(series2[:3]) # out:a      ant;b     bear;c    camel;dtype: objectd
print(series1[series1 > series1.median()])  # out:0    10;1     7;dtype: int64
print(series2[[2, 3, 1]]) # out:c    camel;d      dog;b     bear;dtype: object

• series_name[key]

一如dict对元素的访问采用 dict_name[key] 的方式，Series 的访问也可采用 series_name[key] 方式访问。

这里的key指的是在给 Series 显式指定的index，类似于dict的key

print(series2['a']) # out:ant

2.3 Series内容修改

• Series元素值的修改

series2['c'] = 'camel'
# 或者 series2['2'] = 'camel'
print(series2['c'])   # out:camel

• Series元素索引的修改

# 通过series.index 可以获取到Series的索引，替换该索引即可
print(series2.index)  # Index(['a', 'b', 'c', 'd'], dtype='object')
# series.index 是一个list对象，可通过series.index[index]来访问指定的索引并替换之

2.4 Series的元素属性

属性	说明
values	以数组方式获取Series的元素值
index	以数组方式获取Series的元素索引
name	获取values的name（需额外指定）
index.name	获取index的name（需额外指定）
dtype	获取Series数据类型
array	以数组方式获取Series的值，与values的区别在于array返回的是PandasArray()数据结构

2.5 Series常用函数

• Series 拷贝

  • 深拷贝

  cpys = series2.copy(deep=True)  # deep参数设置为True，则实现深拷贝，创建一个新对象，对series进行复制
  

  print(cpys.values is series2.values or cpys.index is series2.index) # False
  

  • 浅拷贝

  cpys = series2.copy(deep=False)  # deep参数设置为False，则实现浅拷贝，创建一个新对象，但不复制原series的数据，也不复制其索引，仅对索引与数据指向原数据，不同于（cpys = series2)
  

  print(cpys.values is series2.values and cpys.index is series2.index) # True
  

  如果不指定deep参数，则默认deep=True

  • 浅拷贝不同于“=”

  cpys2 = series2   # 该操作不创建对象，只对原对象创建一个新的变量名称
  

  “=” 与 Series.copy(deep=False)的浅拷贝是不一样的，”=“ 是直接对整个series贴上一个新标签，并不创建新的对象。但Series.copy(deep=False)是先创建一个新的对象，之后，对原对象中values与index贴上新的标签并使新对象的values与index指向之。

  print(cpys2 is series2) # True
  print(cpys is series2) # False
  

• Series重设索引reindex函数

  reindex() 函数会创建一个新的对象，用以适应新的索引，并不会修改源对象

  • fill_value 参数 : 对缺失值进行填充

  s = pd.Series(['Tom', 'Kim', 'Andy'], index=['No.1', 'No.2', 'No.3'])
  rs = s.reindex(['No.0', 'No.1', 'No.2', 'No.3', 'No.4']) # 缺失索引对应数值默认使用Nan填充
  rs2 = s.reindex(['No.0', 'No.1', 'No.2', 'No.3', 'No.4'], fill_value='填充值')
  # 设置索引对应数值默认使用“填充值”填充
  

  out:
      rs
  No.0     NaN
  No.1     Tom
  No.2     Kim
  No.3    Andy
  No.4     NaN
  dtype: object
  
  	rs2
  No.0     填充值
  No.1     Tom
  No.2     Kim
  No.3    Andy
  No.4     填充值
  dtype: object
  

  • method参数
    • ffill或pad：前向填充，即将缺失值的前一个索引的值填充在缺失值位置上
    • bfill或backfill：后向（或进位）填充，即将缺失值的后一个索引的值填充在缺失值位置上

  s = pd.Series(['Tom', 'Kim', 'Andy'], index=['No.1', 'No.2', 'No.3'])
  rs = s.reindex(['No.0', 'No.1', 'No.4', 'No.5'], method='ffill')
  rs2 = s.reindex(['No.0', 'No.1', 'No.4', 'No.5'], method='bfill')
  

  out:
      rs
  No.0     NaN    # 由于前一个索引没有值，则不填充
  No.1     Tom
  No.4    Andy    # 因为前向填充(取No.3的值Andy作为填充值)
  No.5    Andy    # 取No.4的值作为填充值
  dtype: object
      
      rs2
  No.0    Tom
  No.1    Tom    
  No.4    NaN     # 取No.5的值作为填充值，即NaN
  No.5    NaN     # 由于后一个索引没有值，则不填充，默认为NaN
  dtype: object
  

• Series 删除元素

  series2.drop('c')
  print(series2)
  

  series2
  a      ant
  b     bear
  c    camel
  d      dog
  dtype: object