数据分析核心包——pandas

Posted 2021-02-08 xiugeng

一、pandas简介

　　pandas是一个强大的Python数据分析的工具包，是基于NumPy构建的。

1、pandas的主要功能

　　(1)具备对其功能的数据结构DataFrame、Series
　　(2)集成时间序列功能
　　(3)提供丰富的数学运算和操作
　　(4)灵活处理缺失数据

2、安装和引用

# 安装方法：
# pip install pandas

# 引用方法：
import pandas as pd

二、Series——一维数据对象

　　Series是一种类似于一维数组的对象，由一组数据和一组与之相关的数据标签（索引）组成。

# Series创建方式
>>> import pandas as pd
>>> pd.Series([2,3,4,5])
0    2
1    3
2    4
3    5
dtype: int64
>>> pd.Series([2,3,4,5], index=['a','b','c','d'])
a    2
b    3
c    4
d    5
dtype: int64

　　获取值数组和索引数组：values属性和index属性。
　　Series比较像列表（数组）和字典的结合体。

1、Series——使用特性

(1)Series支持array的特性(下标)

# 从ndarray创建Series：Series(arr)
>>> import numpy as np
>>> pd.Series(np.arange(5))
0    0
1    1
2    2
3    3
4    4
dtype: int64
# 与标量运算：sr*2
>>> sr = pd.Series([2,3,4,5], index=['a','b','c','d'])
>>> sr
a    2
b    3
c    4
d    5
dtype: int64
>>> sr*2
a     4
b     6
c     8
d    10
dtype: int64
>>> sr+2
a    4
b    5
c    6
d    7
dtype: int64
# 两个Series运算：sr1+sr2
>>> sr + sr
a     4
b     6
c     8
d    10
dtype: int64
# 索引：sr[0],sr[[1,2,4]]
>>> sr[0]
2
>>> sr[[1,2,3]]
b    3
c    4
d    5
dtype: int64
# 切片：sr[0:2]
>>> sr[0:2]
a    2
b    3
dtype: int64
# 通用函数(最大值、绝对值等)，如：np.abs(sr)
>>> sr.max()
5
>>> np.abs(sr)
a    2
b    3
c    4
d    5
dtype: int64 
# 布尔值过滤：sr[sr>0]
>>> sr>4
a    False
b    False
c    False
d     True
dtype: bool
>>> sr[sr>4]
d    5
dtype: int64

(2)Series支持字典的特性(标签)

# 从字典创建Series：Series(dic)
>>> sr = pd.Series({'a':3, 'b':2, 'c':4})
>>> sr
a    3
b    2
c    4
dtype: int64
# in运算：'a' in sr
>>> 'a' in sr
True
>>> 'e' in sr
False
>>> for i in sr:
    print(i)   # 只遍历打印值，而不是打印键
    
3
2
4
# 键索引：sr['a'], sr[['a','b','c']]
>>> sr['a']
3
>>> sr[['a','b','c']]
a    3
b    2
c    4
dtype: int64
# 获取索引对应及对应值
>>> sr.index
Index(['a', 'b', 'c'], dtype='object')
>>> sr.index[0]
'a'
>>> sr.values
array([1, 2, 3, 4])

>>> sr = pd.Series([1,2,3,4],index=['a','b','c','d'])
sr
a    1
b    2
c    3
d    4
dtype: int64
>>> sr[['a','c']]
a    1
c    3
>>> sr['a':'c']  # 标签形式索引切片(前包后也包)
a    1
b    2
c    3
dtype: int64

2、Series——整数索引问题

　　整数索引的pandas对象往往会使新手抓狂。

>>> sr = pd.Series(np.arange(4.))
>>> sr
0    0.0
1    1.0
2    2.0
3    3.0
dtype: float64
>>> sr[-1]
报错信息
KeyError: -1
>>> sr = pd.Series(np.arange(10))
>>> sr
0    0
1    1
2    2
3    3
4    4
5    5
6    6
7    7
8    8
9    9
dtype: int64
>>> sr2 = sr[5:].copy()   # 切片后复制
>>> sr2  # 可以看到索引还是保留之前的值
5    5
6    6
7    7
8    8
9    9
dtype: int64

　　如果索引是整数类型，则根据整数进行下标获取值时总是面向标签的。（意思是说，当索引值为整数时，索引一定会解释为标签）
　　解决方法：

# loc属性：将索引解释为标签
>>> sr2.loc[7]
7

# iloc属性：将索引解释为下标
sr2.iloc[3]
8

　　因此涉及到整数的时候一定要loc和iloc指明，中括号里的索引是标签还是下标。

3、Series——数据对齐

　　pandas在进行两个Series对象的运算时，会按索引进行对齐然后计算。

（1）Series对象运算

>>> sr1 = pd.Series([12,23,34], index=['c','a','d'])
>>> sr2 = pd.Series([11,20,10], index=['d','c','a'])
>>> sr1 + sr2
a    33     # 23+10
c    32     # 12+20
d    45     # 34+11
dtype: int64

>>> sr1 = pd.Series([12,23,34], index=['c','a','d'])
>>> sr2 = pd.Series([11,20,10,21], index=['d','c','a','b'])
>>> sr1 + sr2   # 不一样长Series相加
a    33.0
b     NaN   # 在pandas中用来当做数据缺失值
c    32.0
d    45.0
dtype: float64

>>> sr1 = pd.Series([12,23,34], index=['c','a','d'])
>>> sr2 = pd.Series([11,20,10], index=['b','c','a'])
>>> sr1 + sr2
a    33.0
b     NaN
c    32.0
d     NaN
dtype: float64

　　如果两个Series对象的索引不完全相同，则结果的索引是两个操作数索引的并集。
　　如果只有一个对象在某索引下有值，则结果中该索引的值为nan(缺失值)。

（2）灵活算术方法

　　灵活算术方法：add,sub,div,mul（分别对应加减乘除）。

>>> sr1 = pd.Series([12,23,34], index=['c','a','d'])
>>> sr2 = pd.Series([11,20,10], index=['b','c','a'])
>>> sr1.add(sr2)
a    33.0
b     NaN
c    32.0
d     NaN
dtype: float64
>>> sr1.add(sr2, fill_value=0)    # 标签对应的值一个有一个没有，没有的那个赋值为0
a    33.0
b    11.0
c    32.0
d    34.0
dtype: float64

4、Series——缺失值处理

　　缺失数据：使用NaN(Not a Number)来表示缺失数据。其值等于np.nan。
　　内置的None值也会被当做NaN处理。

(1)处理缺失数据的相关方法

>>> sr = sr1+sr2
>>> sr
a    33.0
b     NaN
c    32.0
d     NaN
dtype: float64

# dropna():过滤掉值为NaN的行

# fillna():填充缺失数据

# isnull():返回布尔数组，缺失值对应为True(判断是否为缺失数据)
>>> sr.isnull()
a    False
b     True   # True的是NaN
c    False
d     True
dtype: bool

# notnull():返回布尔数组，缺失值对应为False
sr.notnull()
a     True
b    False   # False对应NaN
c     True
d    False
dtype: bool

(2)缺失值处理方式一：过滤缺失数据

# sr.dropna()
>>> sr.dropna()
a    33.0
c    32.0
dtype: float64

# sr[data.notnull()]
>>> sr[sr.notnull()]   # 剔除所有缺失值的行
a    33.0
c    32.0
dtype: float64

(3)缺失值处理方式二：填充缺失数据

# fillna()
>>> sr.fillna(0)   # 给缺失值赋值为0
a    33.0
b     0.0
c    32.0
d     0.0
dtype: float64
>>> sr.mean()     # 剔除NaN求得平均值
32.5
>>> sr.fillna(sr.mean())   # 给缺失值填充平均值
a    33.0
b    32.5
c    32.0
d    32.5
dtype: float64

5、Series数据对象小结

　　Series是数组和字典的结合体，可以通过下标和标签来访问。
　　当索引值为整数时，索引一定会解释为标签。可以使用loc和iloc来明确指明索引被解释为标签还是下标。
　　如果两个Series对象的索引不完全相同，则结果的索引是两个操作数索引的并集。
　　如果只有一个对象在某索引下有值，则结果中该索引的值为nan(缺失值)。
　　缺失数据处理方法：dropna（过滤）、fillna（填充）。

三、DataFrame——二维数据对象

　　DataFrame是一个表格式的数据结构，含有一组有序的列（即：好几列）。
　　DataFrame可以被看做是由Series组成的字典，并且共用一个索引。

# 创建方式：
# 方法一：通过一个字典来创建
>>> pd.DataFrame({'one':[1,2,3],'two':[4,5,6]})
   one  two
0    1    4
1    2    5
2    3    6
>>> pd.DataFrame({'one':[1,2,3],'two':[4,5,6]}, index=['a','b','c'])  # index指定行索引
   one  two
a    1    4
b    2    5
c    3    6
# 方法二：用Series来组成字典
>>> pd.DataFrame({'one':pd.Series([1,2,3],index=['a','b','c']),'two':pd.Series([1,2,3,4],index=['b','a','c','d'])})
   one  two
a  1.0    2
b  2.0    1
c  3.0    3
d  NaN    4

# MacBook-Pro:pandas hqs$ vi test.csv   # 创建并写入csv文件
# a,b,c
# 1,2,3
# 2,4,6
# 3,6,9

# csv文件读取和写入：
>>> pd.read_csv('test.csv')    # read_csv():读取csv文件
   a  b  c
0  1  2  3
1  2  4  6
2  3  6  9

>>> df = pd.DataFrame({'one':pd.Series([1,2,3],index=['a','b','c']),'two':pd.Series([1,2,3,4],index=['b','a','c','d'])})
>>> df
   one  two
a  1.0    2
b  2.0    1
c  3.0    3
d  NaN    4
>>> df .to_csv('test2.csv')    # to_csv():写入csv文件

# MacBook-Pro:pandas hqs$ vi test2.csv   # 查看csv文件，缺失的值自动为空
# ,one,two
# a,1.0,2
# b,2.0,1
# c,3.0,3
# d,,4

1、DataFrame——常用属性

>>> df= pd.DataFrame({'one':pd.Series([1,2,3],index=['a','b','c']),'two':pd.Series([1,2,3,4],index=['b','a','c','d'])})
>>> df
   one  two
a  1.0    2
b  2.0    1
c  3.0    3
d  NaN    4

# index:获取行索引
>>> df.index
Index(['a', 'b', 'c', 'd'], dtype='object')

# columns:获取列索引
>>> df.columns
Index(['one', 'two'], dtype='object')

# values:获取值数组（一般是二维数组）
>>> df.values
array([[ 1.,  2.],
       [ 2.,  1.],
       [ 3.,  3.],
       [nan,  4.]])

# T:转置
>>> df
   one  two
a  1.0    2
b  2.0    1
c  3.0    3
d  NaN    4
>>> df.T      # 行变成列，列变成行
       a    b    c    d
one  1.0  2.0  3.0  NaN
two  2.0  1.0  3.0  4.0

# describe():获取快速统计
>>> df.describe()
       one       two
count  3.0  4.000000    # 统计每一列个数
mean   2.0  2.500000    # 统计每一列平均数
std    1.0  1.290994    # 统计每一列标准差
min    1.0  1.000000    # 统计每一列最小值
25%    1.5  1.750000    # 1/4位上的数
50%    2.0  2.500000    # 1/2位上的数
75%    2.5  3.250000    # 3/4位上的数
max    3.0  4.000000    # 统计每一列最大值

2、DataFrame——索引和切片

3、DataFrame——数据对齐和缺失数据