目录
Pandas
一、简介
pandas是一个强大的Python数据分析的工具包，它是基于Numpy构建的，正因pandas的出现，让Python语言也成为使用最广泛而且强大的数据分析环境之一。
Pandas的主要功能：
- 具备对其功能的数据结构DataFrame，Series
- 集成时间序列功能
- 提供丰富的数学运算和操作
- 灵活处理缺失数据
1、安装
pip install pandas
2、引用方法
import pandas as pd
二、series
Series是一种类似于一维数组的对象，由一组数据和一组与之相关的数据标签(索引)组成。
1、创建方法
方法一：pd.Series(列表)
pd.Series(列表, index=[自定义索引])
如果没有定义index，索引默认为从0开始的数字
# 创建普通series数组
>>>:pd.Series([2,3,4,5,6])
0 2
1 3
2 4
3 5
4 6
dtype: int64
# 如何获取series中的元素
>>>:s1[1],s1[2]
(3, 4)
>>>:pd.Series([4,6,2,56,4])
0 4
1 6
2 2
3 56
4 4
dtype: int64
>>>:s2[3]
56
# 创建自定义索引的series数组
# 注意：index设定的索引需要和列表中的元素个数相同
>>>:pd.Series([6,5,4,3,2],index=['a','b','c', 'd','e'])
a 6
b 5
c 4
d 3
e 2
dtype: int64
# 数字型索引和自定义索引是共存的
>>>:s3['a'],s3['d'],s3[4]
(6, 3, 2)
# 创建元素都为0的series数组
>>>:s0 = pd.Series(0)
>>>:s0
0 0
dtype: int64
# 不定义index，默认只有一个元素
>>>:s0 = pd.Series(0,index=(1,2,3,4,5))
>>>:s0
1 0
2 0
3 0
4 0
5 0
dtype: int64
方法二：pd.Series(字典)
>>>:s4 = pd.Series({'a':1,'b':2})
s4
a 1
b 2
dtype: int64
2、缺失数据处理
2.1 什么是缺失值
>>>:st = pd.Series({'a':12,'b':15,'c':20,'d':23})
>>>:st
a 12
b 15
c 20
d 23
dtype: int64
>>>:st1 = pd.Series(st,index=('a','b','c'))
>>>:st1
a 12
b 15
c 20
dtype: int64
>>>:st2 = pd.Series(st,index=('a','b','c','e'))
>>>:st2
a 12.0
b 15.0
c 20.0
e NaN # 当索引不存在时，就会出现缺失值NaN
dtype: float64 # 值的类型改变了
# 为啥值的类型从整型变成了浮点型？
# 答：因为NaN是浮点类型，所以为了兼容NaN的浮点类型，因此强制的将之前的整型变成了浮点型。
2.2 NaN特性
NaN谁都不等于，甚至不等于它自己。
>>>:np.nan == np.nan
False
2.3 填充NaN
fillna(数)方法，可以返回一个 用括号中的填充数字代替NaN 的新数组。
>>>:st2
a 12.0
b 15.0
c 20.0
e NaN
dtype: float64
>>>:st2.fillna(0)
a 12.0
b 15.0
c 20.0
e 0.0
dtype: float64
>>>:st2
a 12.0
b 15.0
c 20.0
e NaN
dtype: float64
2.4 删除NaN
dropna(inplace=False)方法，返回一个删去NaN所在的记录的新数组。
默认参数inplace=False，不会将原有数组中的NaN真的删去，且会返回一个删去NaN的新数组；
如果inplace=True，则直接将原有数组中的NaN所在行真实删除，且没有返回值。
>>>:st2
a 12.0
b 15.0
c 20.0
e NaN
dtype: float64
>>>:st3 = st2.dropna() # 有返回值
>>>:st3
a 12.0
b 15.0
c 20.0
dtype: float64
>>>:st2 # st2并没有改变
a 12.0
b 15.0
c 20.0
e NaN
dtype: float64
-------------------------------------------
>>>:st2
a 12.0
b 15.0
c 20.0
e NaN
dtype: float64
>>>:st2.dropna(inplace=True) # 没有返回值
>>>:st2
a 12.0
b 15.0
c 20.0
dtype: float64
2.5 其他方法
isnull() # 返回布尔数组，缺失值对应为True
notnull() # 返回布尔数组，缺失值对应为False
>>>:st2
a 12.0
b 15.0
c 20.0
e NaN
dtype: float64
# 是缺失值返回Ture
>>>:st2.isnull()
a False
b False
c False
e True
dtype: bool
# 不是缺失值返回Ture
>>>:st2.notnull()
a True
b True
c True
e False
dtype: bool
# 过滤缺失值 布尔型索引
>>>:st2[st2.notnull()]
a 12.0
b 15.0
c 20.0
dtype: float64
3、特性
1、支持使用ndarray数组创建Series数组
>>>:n1 = np.array([1,2,3,4])
>>>:n1
array([1, 2, 3, 4])
>>>:pd.Series(n1)
0 1
1 2
2 3
3 4
dtype: int32
2、支持矢量运算
>>>:s1 = pd.Series([1, 2, 3, 4])
>>>:s1
0 1
1 2
2 3
3 4
dtype: int32
>>>:s1 *3
0 3
1 6
2 9
3 12
dtype: int32
3、支持两个Series运算(向量运算)
索引所对应的值可以进行加减乘除运算。
>>>:s1 = pd.Series({'a':1,'b':2,'c':3})
>>>:s1
a 1
b 2
c 3
dtype: int64
>>>:s2 = pd.Series({'a':4,'b':5,'c':6})
>>>:s2
a 4
b 5
c 6
dtype: int64
>>>:s1 + s2
a 5
b 7
c 9
dtype: int64
------------------------------------------
>>>:s3 = pd.Series({'a':4,'b':5,'d':6})
>>>:s3
a 4
b 5
d 6
dtype: int64
>>>:s1 + s3
a 5.0
b 7.0
c NaN
d NaN
dtype: float64
4、支持numpy通用函数
>>>:s2 = pd.Series([-1,2,-3,4])
>>>:s2
0 -1
1 2
2 -3
3 4
dtype: int64
>>>:abs(s2)
0 1
1 2
2 3
3 4
dtype: int64
5、支持布尔值过滤：sr[sr>0]
>>>:s1 >3
0 False
1 False
2 False
3 True
dtype: bool
>>>:s1[s1>3]
3 4
dtype: int32
6、支持统计函数：mean()、sum()、cumsum()
>>>:s1
0 1
1 2
2 3
3 4
dtype: int32
>>>:sum(s1)
10
4、索引取值
通过默认整数索引或自定义索引获取series数组中的值。
>>>:pd.Series([2,3,4,5,6])
0 2
1 3
2 4
3 5
4 6
dtype: int64
# 通过默认整数索引取值
>>>:s1[1],s1[2]
(3, 4)
---------------------------
>>>:pd.Series([6,5,4,3,2],index=['a','b','c', 'd','e'])
a 6
b 5
c 4
d 3
e 2
dtype: int64
# 通过自定义索引取值
>>>:s3['a'],s3['d'],s3[4]
(6, 3, 2)
5、花式索引
中括号中套中括号，内层中括号中写索引下标，可取多个不连续值。和numpy一样。
>>>:s1
a 1
b 2
c 3
dtype: int64
>>>:s1[[0,2]]
a 1
c 3
dtype: int64
6、整数索引(切片索引)
- loc方法 # 和
[]取值一样，以索引取值 - iloc方法 # 以真实顺序取值，从0开始
>>>:s1 = pd.Series(np.arange(10))
>>>:s2 = s1[3:]
>>>:s2
3 3
4 4
5 5
6 6
7 7
8 8
9 9
dtype: int32
>>>:s2[3]
3
>>>:s2[9]
9
>>>:s2.loc[3]
3
>>>:s2.iloc[0]
3
>>>:s2.iloc[6]
9
三、DataFrame
DataFrame是一个表格型的数据结构，相当于是一个二维数组，含有一组有序的列。他可以被看做是由Series组成的字典，并且共用一个索引。
1、创建方式
# 第一种
pd.DataFrame('列名1':[元素...],'列名2':[元素...])
>>>:d1 = pd.DataFrame({'one':[1,2,3,4],'two':[5,6,7,8]})
>>>:d1
one two
0 1 5
1 2 6
2 3 7
3 4 8
# 第二种：指定索引
pd.DataFrame({
'列名1':pd.Series(['元素1','元素2'...],index=['索引1','索引2'...],
'列名2':pd.Series(['元素1','元素2'...],index=['索引1','索引2'...],
})
>>>:d2 = pd.DataFrame({
'one':pd.Series([1,2,3,4],index=['a','b','c','d']),
'two':pd.Series([5,6,7,8],index=['a','b','c','d'])
})
>>>:d2
one two
a 1 5
b 2 6
c 3 7
d 4 8
# 索引会自动对齐
>>>:d3 = pd.DataFrame({
'one':pd.Series([1,2,3,4],index=['a','b','c','d']),
'two':pd.Series([5,6,7,8],index=['b','a','c','e'])
})
>>>:d3
one two
a 1.0 6.0
b 2.0 5.0
c 3.0 7.0
d 4.0 NaN
e NaN 8.0
2、常见属性和方法
2.1 属性
columns属性可以充值DataFrame二维数组的列。
>>>:d1
one two
0 1 5
1 2 6
2 3 7
3 4 8
>>>:pd.DataFrame(d1,columns=['two','one'])
two one
0 5 1
1 6 2
2 7 3
3 8 4
2.2 方法
- index 获取行索引
- columns 获取列索引
- T 转置
- columns 获取列索引
- values 获取值索引
- describe 获取快速统计
>>>:d1
one two
0 1 5
1 2 6
2 3 7
3 4 8
>>>:d1.index
RangeIndex(start=0, stop=4, step=1)
>>>:d1.columns
Index(['one', 'two'], dtype='object')
>>>:d1.T
0 1 2 3
one 1 2 3 4
two 5 6 7 8
>>>:d1.values
array([[1, 5],
[2, 6],
[3, 7],
[4, 8]], dtype=int64)
>>>:d1.describe()
one two
count 4.000000 4.000000
mean 2.500000 6.500000
std 1.290994 1.290994
min 1.000000 5.000000
25% 1.750000 5.750000
50% 2.500000 6.500000
75% 3.250000 7.250000
max 4.000000 8.000000
3、索引和切片
3.1 索引取值
通过[]来获取元素，先获取列，后获取行。
通过.iloc[]获取元素，可以直接获取某一行。
>>>:d1['one']
0 1
1 2
2 3
3 4
Name: one, dtype: int64
>>>:d1['one'][1] # 先获取列后获取行
2
--------------------------------------
>>>:d2
one two
a 1 5
b 2 6
c 3 7
d 4 8
# 获取第一行
>>>:d2.iloc[0]
one 1
two 5
Name: a, dtype: int64
>>>:d2['one'].iloc[0]
1
四、处理文件
1、读取文件
企业中，一般会将数据打包到csv文件中进行处理。
我们可以使用read_csv方法将文件中的数据读取为DataFrame对象进行操作。
# 使用read_csv方法读取csv文件
>>>:data = pd.read_csv('文件路径/文件.csv')
>>>:data
2、保存数据到文件
使用to_csv方法可以将数据保存成csv格式的文件。
# 将文件保存到当前目录下
movie_df.to_csv('./文件名.csv') # 这样做会多出一行索引列，可以去掉
# 可以加一个index=False属性，使保存时，去除索引
movie_df.to_csv('./movies.csv',index=False)
3、其他方法
3.1 显示前n行
通过read_csv读取出的数据对象，可以通过head()方法，查看前n行。默认为前5行。括号内可以指定查看的行数。
>>>:data = pd.read_csv('文件路径/文件.csv')
>>>:data
# 查看前5行的数据
>>>:data.head()
# 查看前10行的数据
>>>:data.head(10)
3.2 显示后n行
通过read_csv读取出的数据对象，可以通过tail()方法，查看后n行。默认为后5行。括号内可以指定查看的行数。
>>>:data = pd.read_csv('文件路径/文件.csv')
>>>:data
# 查看后5行的数据
>>>:data.tail()
# 查看后10行的数据
>>>:data.tail(10)
五、处理网页数据
1、获取网页中的数据
有时候我们需要处理一些网页上的数据，read_html方法可以帮我们直接读取HTML文件中的表格，直接转成DataFrame对象，方便操作。
# 百度百科‘NBA总冠军’，中有两个表格，我们尝试将他们读取：
>>>:res = pd.read_html('https://baike.baidu.com/item/NBA%E6%80%BB%E5%86%A0%E5%86%9B/2173192?fr=aladdin')
# 由于这个页面上有两个表格，所以得到了一个列表
# 取第一个表格
>>>:res[0]
0 1 2 3 4 5
0 年份 比赛日期 冠军 总比分 亚军 FMVP
1 1947 4.16-4.22 费城勇士队 4-1 芝加哥牡鹿队 无
2 1948 4.10-4.21 巴尔的摩子弹队 4-2 费城勇士队 无
3 1949 4.4-4.13 明尼阿波利斯湖人队 4-2 华盛顿国会队 无
4 1950 4.8-4.23 明尼阿波利斯湖人队 4-2 塞拉库斯民族队 无
... ... ... ... ... ... ...
69 2015 6.5-6.17 金州勇士队 4-2 克里夫兰骑士队 安德烈·伊戈达拉
70 2016 6.3-6.20 克里夫兰骑士队 4-3 金州勇士队 勒布朗·詹姆斯
71 2017 6.2-6.13 金州勇士队 4-1 克利夫兰骑士队 凯文·杜兰特
72 2018 6.1-6.9 金州勇士队 4-0 克利夫兰骑士队 凯文·杜兰特
73 2019 5.31-6.14 多伦多猛龙队 4-2 金州勇士队 科怀·伦纳德
74 rows × 6 columns
2、改变DataFrame的列名
直接修改
>>>:champion.head()
0 1 2 3 4 5
0 年份 比赛日期 冠军 总比分 亚军 FMVP
1 1947 4.16-4.22 费城勇士队 4-1 芝加哥牡鹿队 无
2 1948 4.10-4.21 巴尔的摩子弹队 4-2 费城勇士队 无
3 1949 4.4-4.13 明尼阿波利斯湖人队 4-2 华盛顿国会队 无
4 1950 4.8-4.23 明尼阿波利斯湖人队 4-2 塞拉库斯民族队 无
# 直接修改
>>>:champion.columns = champion.iloc[0]
>>>:champion.head()
年份 比赛日期 冠军 总比分 亚军 FMVP
0 年份 比赛日期 冠军 总比分 亚军 FMVP
1 1947 4.16-4.22 费城勇士队 4-1 芝加哥牡鹿队 无
2 1948 4.10-4.21 巴尔的摩子弹队 4-2 费城勇士队 无
3 1949 4.4-4.13 明尼阿波利斯湖人队 4-2 华盛顿国会队 无
4 1950 4.8-4.23 明尼阿波利斯湖人队 4-2 塞拉库斯民族队 无
3、删除某一行的数据
DataFrame.drop([索引1，索引2...])，将索引所对应的行删除。
可通过inplace=True属性
>>>:champion.head()
年份 比赛日期 冠军 总比分 亚军 FMVP
0 年份 比赛日期 冠军 总比分 亚军 FMVP
1 1947 4.16-4.22 费城勇士队 4-1 芝加哥牡鹿队 无
2 1948 4.10-4.21 巴尔的摩子弹队 4-2 费城勇士队 无
3 1949 4.4-4.13 明尼阿波利斯湖人队 4-2 华盛顿国会队 无
4 1950 4.8-4.23 明尼阿波利斯湖人队 4-2 塞拉库斯民族队 无
>>>:champion.drop([0]).head()
年份 比赛日期 冠军 总比分 亚军 FMVP
1 1947 4.16-4.22 费城勇士队 4-1 芝加哥牡鹿队 无
2 1948 4.10-4.21 巴尔的摩子弹队 4-2 费城勇士队 无
3 1949 4.4-4.13 明尼阿波利斯湖人队 4-2 华盛顿国会队 无
4 1950 4.8-4.23 明尼阿波利斯湖人队 4-2 塞拉库斯民族队 无
5 1951 4.7-4.21 罗切斯特皇家队 4-3 纽约尼克斯队 无
# 删除多行
>>>:champion.drop([0,1]).head()
年份 比赛日期 冠军 总比分 亚军 FMVP
2 1948 4.10-4.21 巴尔的摩子弹队 4-2 费城勇士队 无
3 1949 4.4-4.13 明尼阿波利斯湖人队 4-2 华盛顿国会队 无
4 1950 4.8-4.23 明尼阿波利斯湖人队 4-2 塞拉库斯民族队 无
5 1951 4.7-4.21 罗切斯特皇家队 4-3 纽约尼克斯队 无
6 1952 4.12-4.25 明尼阿波利斯湖人队 4-3 纽约尼克斯队 无
六、DataFrame分组与聚合
分组：groupby()
聚合：size()
# 以上文处理过的champion为例
>>>:champion
年份 比赛日期 冠军 总比分 亚军 FMVP
1 1947 4.16-4.22 费城勇士队 4-1 芝加哥牡鹿队 无
2 1948 4.10-4.21 巴尔的摩子弹队 4-2 费城勇士队 无
3 1949 4.4-4.13 明尼阿波利斯湖人队 4-2 华盛顿国会队 无
4 1950 4.8-4.23 明尼阿波利斯湖人队 4-2 塞拉库斯民族队 无
5 1951 4.7-4.21 罗切斯特皇家队 4-3 纽约尼克斯队 无
... ... ... ... ... ... ...
69 2015 6.5-6.17 金州勇士队 4-2 克里夫兰骑士队 安德烈·伊戈达拉
70 2016 6.3-6.20 克里夫兰骑士队 4-3 金州勇士队 勒布朗·詹姆斯
71 2017 6.2-6.13 金州勇士队 4-1 克利夫兰骑士队 凯文·杜兰特
72 2018 6.1-6.9 金州勇士队 4-0 克利夫兰骑士队 凯文·杜兰特
73 2019 5.31-6.14 多伦多猛龙队 4-2 金州勇士队 科怀·伦纳德
73 rows × 6 columns
# 我们想对【冠军】这一列进行分组，查看每一队分别拿过几次冠军，该怎么办呢？
>>>:champion.groupby('冠军')
<pandas.core.groupby.generic.DataFrameGroupBy object at 0x00000215200FF9E8>
# 使用groupby函数，发现生成了一个DataFrameGroupBy对象
# 想查看这个DataFrameGroupBy对象的具体内容，可以使用groups方法
>>>:champion.groupby('冠军').groups
{'休斯顿火箭队': Int64Index([48, 49], dtype='int64'),
'克里夫兰骑士队': Int64Index([70], dtype='int64'),
'华盛顿子弹队': Int64Index([32], dtype='int64'),
'圣安东尼奥马刺队': Int64Index([53, 57, 59, 61, 68], dtype='int64'),
'圣路易斯老鹰队': Int64Index([12], dtype='int64'),
'塞拉库斯民族队': Int64Index([9], dtype='int64'),
'多伦多猛龙队': Int64Index([73], dtype='int64'),
'密尔沃基雄鹿队': Int64Index([25], dtype='int64'),
'巴尔的摩子弹队': Int64Index([2], dtype='int64'),
'底特律活塞队': Int64Index([43, 44, 58], dtype='int64'),
'明尼阿波利斯湖人队': Int64Index([3, 4, 6, 7, 8], dtype='int64'),
'波士顿凯尔特人队': Int64Index([11, 13, 14, 15, 16, 17, 18, 19, 20, 22, 23, 28, 30, 35, 38, 40,
62],
dtype='int64'),
'波特兰开拓者队': Int64Index([31], dtype='int64'),
'洛杉矶湖人队': Int64Index([26, 34, 36, 39, 41, 42, 54, 55, 56, 63, 64], dtype='int64'),
'纽约尼克斯队': Int64Index([24, 27], dtype='int64'),
'罗切斯特皇家队': Int64Index([5], dtype='int64'),
'芝加哥公牛队': Int64Index([45, 46, 47, 50, 51, 52], dtype='int64'),
'西雅图超音速队': Int64Index([33], dtype='int64'),
'费城76人队': Int64Index([21, 37], dtype='int64'),
'费城勇士队': Int64Index([1, 10], dtype='int64'),
'达拉斯小牛队': Int64Index([65], dtype='int64'),
'迈阿密热火队': Int64Index([60, 66, 67], dtype='int64'),
'金州勇士队': Int64Index([29, 69, 71, 72], dtype='int64')}
# 我们知道，在MySQL中使用group by 进行分组，通常是与count之类的聚合函数一起使用的，由此可见，DataFrame的groupby分组，应该也与聚合函数一起使用。
# 比方说聚合函数size()，它可以将分组后，每一组的个数统计出来，相当于MySQL中的count
>>>:champion.groupby('冠军').size()
冠军
休斯顿火箭队 2
克里夫兰骑士队 1
华盛顿子弹队 1
圣安东尼奥马刺队 5
圣路易斯老鹰队 1
塞拉库斯民族队 1
多伦多猛龙队 1
密尔沃基雄鹿队 1
巴尔的摩子弹队 1
底特律活塞队 3
明尼阿波利斯湖人队 5
波士顿凯尔特人队 17
波特兰开拓者队 1
洛杉矶湖人队 11
纽约尼克斯队 2
罗切斯特皇家队 1
芝加哥公牛队 6
西雅图超音速队 1
费城76人队 2
费城勇士队 2
达拉斯小牛队 1
迈阿密热火队 3
金州勇士队 4
dtype: int64
# 之后我们可以用sort_values()方法对获得的数据进行一个排序。就像MySQL中的order by一样。
# 该函数默认升序排列，可以指定属性ascending=False使排列为降序。
>>>:champion.groupby('冠军').size().sort_values(ascending=False)
冠军
波士顿凯尔特人队 17
洛杉矶湖人队 11
芝加哥公牛队 6
圣安东尼奥马刺队 5
明尼阿波利斯湖人队 5
金州勇士队 4
迈阿密热火队 3
底特律活塞队 3
休斯顿火箭队 2
纽约尼克斯队 2
费城76人队 2
费城勇士队 2
塞拉库斯民族队 1
克里夫兰骑士队 1
华盛顿子弹队 1
达拉斯小牛队 1
圣路易斯老鹰队 1
西雅图超音速队 1
多伦多猛龙队 1
密尔沃基雄鹿队 1
罗切斯特皇家队 1
波特兰开拓者队 1
巴尔的摩子弹队 1
dtype: int64