文章目录

• 5-1 Pandas介绍与安装
• 为什么会有Pandas
• Pandas是什么？
• 安装Pandas
• Pandas涉及内容
• 5-2 Pandas数据结构介绍
• Series介绍
• Series创建
• Pandas数组函数
• Series的索引与值
• Series索引与切片
• Series修改值
• Series运算

5-1 Pandas介绍与安装

为什么会有Pandas

​ Pandas支持大部分Numpy语言风格，尤其是数组函数与广播机制的各种数据处理。单是Numpy更适合处理同质型的数据。而Pandas的设计就是用来处理表格型或异性数据的，高效的清洗、处理数据。

Pandas是什么？

​ Pandas是基于Numpy的一种工具，提供高性能矩阵的运算，该工具是为了解决数据分析任何而创建的。也是贯穿整个Python数据分析非常核心的工具

安装Pandas

pip install Pandas

Pandas涉及内容

​ Pandas基础 、数据清洗与准备、数据聚合与分组、时间序列

5-2 Pandas数据结构介绍

Series介绍

​ Series是一种一维数组对象，它包含了一个值序列(value) ,并且包含了数据标签，称之为索引 (index)

Series创建

pd.Series(data=None,index=None,dtype=None,name=None,copy=False)

• data : 创建数组的数据，可为array、like、dict、or scalar value
• index : 指定索引
• dtype : 数组数据类型
• name : 数组名称
• copy : 是否拷贝

Pandas数组函数

语法	基本使用
dtype	查看数据类型
astype	修改数据类型
head()	预览前几条数据
tail()	预览后几条数据

In [15]: # 指定索引序列

In [16]: series = pd.Series(np.arange(4),index=['a','b','c','d'])

In [17]: series
Out[17]:
a    0
b    1
c    2
d    3
dtype: int32

In [18]: # 指定索引的名字

In [19]: series = pd.Series(np.arange(4),index=['a','b','c','d'],name='SmallJ')

In [20]: series
Out[20]:
a    0
b    1
c    2
d    3
Name: SmallJ, dtype: int32

In [21]: # 默认返回int32,可指定其他类型

In [23]: series = pd.Series(np.arange(4),index=['a','b','c','d'],name='SmallJ',dtype='int64')

In [24]: series
Out[24]:
a    0
b    1
c    2
d    3
Name: SmallJ, dtype: int64

In [29]: import numpy as np

In [30]: import pandas as pd

In [31]: series = pd.Series(np.arange(10),name='SmallJ')

In [32]: series
Out[32]:
0    0
1    1
2    2
3    3
4    4
5    5
6    6
7    7
8    8
9    9
Name: SmallJ, dtype: int32

In [33]: # 前面为索引后面为值

In [34]: series.dtype
Out[34]: dtype('int32')

In [35]: # 查看数据类型

In [36]: series.dtype
Out[36]: dtype('int32')

In [37]: # 修改数据类型

In [38]: series.astype('float64')
Out[38]:
0    0.0
1    1.0
2    2.0
3    3.0
4    4.0
5    5.0
6    6.0
7    7.0
8    8.0
9    9.0
Name: SmallJ, dtype: float64

In [39]: # 预览从头开始的数据 (括号内填指定的数据)

In [40]: series.head(5)
Out[40]:
0    0
1    1
2    2
3    3
4    4
Name: SmallJ, dtype: int32

In [41]: series.head(6)
Out[41]:
0    0
1    1
2    2
3    3
4    4
5    5
Name: SmallJ, dtype: int32

In [42]: # 预览最后的数据 (括号填指定的数据)

In [43]: series.tail(5)
Out[43]:
5    5
6    6
7    7
8    8
9    9
Name: SmallJ, dtype: int32

Series的索引与值

• series.index
  • 查看索引
• series.values
  • 查看值序列
• series.reset_index(drop=False)
  • 重置索引
  • drop 是否删除原索引 默认为否

In [89]: import pandas as pd

In [90]: import numpy as np

In [91]: series = pd.Series(data=np.arange(5),index=['a','b','c','d','e'])

In [92]: series
Out[92]:
a    0
b    1
c    2
d    3
e    4
dtype: int32

In [93]: # 查看索引

In [94]: series.index
Out[94]: Index(['a', 'b', 'c', 'd', 'e'], dtype='object')

In [95]: series.values
Out[95]: array([0, 1, 2, 3, 4])

In [96]: series.reset_index()
Out[96]:
  index  0
0     a  0
1     b  1
2     c  2
3     d  3
4     e  4

In [98]: series
Out[98]:
a    0
b    1
c    2
d    3
e    4
dtype: int32

In [99]: # 查看值序列

In [100]: series.values
Out[100]: array([0, 1, 2, 3, 4])

In [101]: # 当drop中的值为True的时候将采用删除原索引,并不会对原数据进行修改，需要复制

In [102]: series = series.reset_index(drop=True)
In [103]: series
Out[103]:
0    0
1    1
2    2
3    3
4    4
dtype: int32

Series索引与切片

• series.[‘标签索引’]
  • 通过标签索引来取值
• series[‘索引’]
  • 通过下标索引来取值
• series.loc(标签索引)
  • 通过标签索引来取值
• series.iloc(索引)
  • 通过索引

In [115]: # 通过标签来取值

In [116]: series.loc['b']
Out[116]: 1

In [117]: # 通过索引下标来取值

In [118]: series.iloc[1]
Out[118]: 1

采用神奇索引

In [139]: series
Out[139]:
a     0
b     1
c    10
d     3
e    22
dtype: int32

In [141]: # 采用标签来取值

In [142]: series[['a','e']]
Out[142]:
a     0
e    22
dtype: int32

In [143]: # 采用索引取值

In [144]: series[[0,-1]]
Out[144]:
a     0
e    22
dtype: int32

Series修改值

In [122]: series
Out[122]:
a    0
b    1
c    2
d    3
e    4
dtype: int32

通过索引来修改值

series.iloc[2] = 10

通过标签来修改值

series.loc['e'] = 22

In [139]: series
Out[139]:
a     0
b     1
c    10
d     3
e    22
dtype: int32

判断值是否存在

• in 并不是判断值，而是根据标签索引来判断

Series运算

• 共同索引对应运算，其他值填充为NaN
• Pandas会自动帮我们进行数据转换，当我们的数据类型为None时，会把数据替换为NaN
• 当没用通过索引的时候，将全部变为NaN
• NaN与任何值计算都是NaN

In [148]: data = pd.Series(data=[1,2,3,4,None],index=['a','b','c','d','e'])

In [149]: data
Out[149]:
a    1.0
b    2.0
c    3.0
d    4.0
e    NaN
dtype: float64

当进行对应标签索引进行相加的时候

In [148]: data = pd.Series(data=[1,2,3,4,None],index=['a','b','c','d','e'])

In [149]: data
Out[149]:
a    1.0
b    2.0
c    3.0
d    4.0
e    NaN
dtype: float64

In [150]: data1 = pd.Series(data=[1,2,3,4,None],index=['a','b','c','d','e'])

In [151]: data1
Out[151]:
a    1.0
b    2.0
c    3.0
d    4.0
e    NaN
dtype: float64

In [152]: data + data1
Out[152]:
a    2.0
b    4.0
c    6.0
d    8.0
e    NaN
dtype: float64

当对应的标签索引位置进行相加时

• 当对应是索引的位置没有数值时，显示的数值为NaN

In [148]: data = pd.Series(data=[1,2,3,4,None],index=['a','b','c','d','e'])
In [153]: data2 = pd.Series(data=[1,2,3],index=['a','b','c'])
In [156]: data          
Out[156]:               
a    1.0                
b    2.0                
c    3.0                
d    4.0                
e    NaN                
dtype: float64          
                        
In [157]: data2         
Out[157]:               
a    1                  
b    2                  
c    3                  
dtype: int64            
                        
In [158]: data + data2  
Out[158]:               
a    2.0                
b    4.0                
c    6.0                
d    NaN                
e    NaN                
dtype: float64          

当不对应的索引标签进行相加的时候

• 当对应的索引标签不相同的时，显示的全部结果为NaN

In [161]: data2 = pd.Series(data=[1,2,3],index=['a','b','c'])

In [162]: data3 = pd.Series(data=[1,2,3,4],index=['d','e','f','g'])

In [163]: data2
Out[163]:
a    1
b    2
c    3
dtype: int64

In [164]: data3
Out[164]:
d    1
e    2
f    3
g    4
dtype: int64

In [165]: data2 + data3
Out[165]:
a   NaN
b   NaN
c   NaN
d   NaN
e   NaN
f   NaN
g   NaN
dtype: float64