Pandas初体验

目录

• Pandas
• 一、简介
  • 1、安装
  • 2、引用方法
• 二、series
  • 1、创建方法
  • 2、缺失数据处理
    • 2.1 什么是缺失值
    • 2.2 NaN特性
    • 2.3 填充NaN
    • 2.4 删除NaN
    • 2.5 其他方法
  • 3、特性
  • 4、索引取值
  • 5、花式索引
  • 6、整数索引(切片索引)
• 三、DataFrame
  • 1、创建方式
  • 2、常见属性和方法
    • 2.1 属性
    • 2.2 方法
  • 3、索引和切片
    • 3.1 索引取值
• 四、处理文件
  • 1、读取文件
  • 2、保存数据到文件
  • 3、其他方法
    • 3.1 显示前n行
    • 3.2 显示后n行
• 五、处理网页数据
  • 1、获取网页中的数据
  • 2、改变DataFrame的列名
  • 3、删除某一行的数据
• 六、DataFrame分组与聚合

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