一、简介
pandas是一个强大的Python数据分析的工具包，它是基于Numpy构建的，正因pandas的出现，让Python语言也成为使用最广泛而且强大的数据分析环境之一。
Pandas的主要功能：
- 具备对其功能的数据结构DataFrame，Series
- 集成时间序列功能
- 提供丰富的数学运算和操作
- 灵活处理缺失数据
安装方法：
pip install pandas
引用方法：
import pandas as pd
二、Series
Series是一种类似于一维数组的对象，由一组数据和一组与之相关的数据标签(索引)组成
2.1创建方法
第一种：
pd.Series([4,5,6,7,8])
执行结果：
0 4
1 5
2 6
3 7
4 8
dtype: int64
# 将数组索引以及数组的值打印出来，索引在左，值在右，由于没有为数据指定索引，于是会自动创建一个0到N-1（N为数据的长度）的整数型索引，取值的时候可以通过索引取值，跟之前学过的数组和列表一样
-----------------------------------------------
第二种：
pd.Series([4,5,6,7,8],index=['a','b','c','d','e'])
执行结果：
a 4
b 5
c 6
d 7
e 8
dtype: int64
# 自定义索引，index是一个索引列表，里面包含的是字符串，依然可以通过默认索引取值。
-----------------------------------------------
第三种：
pd.Series({"a":1,"b":2})
执行结果：
a 1
b 2
dtype: int64
# 指定索引
-----------------------------------------------
第四种：
pd.Series(0,index=['a','b','c'])
执行结果：
a 0
b 0
c 0
dtype: int64
# 创建一个值都是0的数组
-----------------------------------------------
对于Series，其实我们可以认为它是一个长度固定且有序的字典，因为它的索引和数据是按位置进行匹配的，像我们会使用字典的上下文，就肯定也会使用Series
2.2缺失值处理
- dropna() 过滤掉值为NaN的行
- fill() 填充缺失数据
- fillna(数据，inplace=True)填充数据
# inplace=true:代表在对象本身的基础上更改，只有为True才是真正修改数据本身，为False则修改的不是数据本身
- isnull() # 返回布尔数组，缺失值对应为True
- notnull() # 返回布尔数组，缺失值对应为False
# 第一步，创建一个字典，通过Series方式创建一个Series对象
st = {"sean":18,"yang":19,"bella":20,"cloud":21}
obj = pd.Series(st)
obj
运行结果：
sean 18
yang 19
bella 20
cloud 21
dtype: int64
------------------------------------------
# 第二步
a = {'sean','yang','cloud','rocky'} # 定义一个索引变量
------------------------------------------
#第三步
obj1 = pd.Series(st,index=a)
obj1 # 将第二步定义的a变量作为索引传入
# 运行结果：
rocky NaN
cloud 21.0
sean 18.0
yang 19.0
dtype: float64
# 因为rocky没有出现在st的键中，所以返回的是缺失值，NaN是浮点类型
通过上面的代码演示，对于缺失值已经有了一个简单的了解，接下来就来看看如何判断缺失值
1、
obj1.isnull() # 是缺失值返回Ture
运行结果：
rocky True
cloud False
sean False
yang False
dtype: bool
2、
obj1.notnull() # 不是缺失值返回Ture
运行结果：
rocky False
cloud True
sean True
yang True
dtype: bool
3、过滤缺失值 # 布尔型索引
obj1[obj1.notnull()]
运行结果：
cloud 21.0
yang 19.0
sean 18.0
dtype: float64
#不同的nan是不相等的
np.nan == np.nan
False
2.3Series特性
- 从ndarray创建Series:Series(arr)
- 与标量（数字）：sr * 2
- 两个Series运算
- 通用函数：np.ads(sr)
- 布尔值过滤：sr[sr>0]
- 统计函数：mean()、sum()、cumsum()
s1 = pd.Series([2,3,4,5,6])
s1
0 2
1 3
2 4
3 5
4 6
dtype: int64
s1 * 2 #类似于矩阵的数乘
0 4
1 6
2 8
3 10
4 12
dtype: int64
s1[s1 > 4] #布尔型索引
3 5
4 6
dtype: int64
abs(s1)
0 2
1 3
2 4
3 5
4 6
dtype: int64
sum(s1)
20
支持字典的特性：
- 从字典创建Series：Series(dic),
- In运算：'a'in sr、for x in sr
- 键索引：sr['a'],sr[['a','b','d']]
- 键切片：sr['a':'c']
- 其他函数：get('a',default=0)等
2.4两个Series的运算
#### 向量运算
s4 = pd.Series({'height':170, 'age':18, 'salary':2000})
s4
height 170
age 18
salary 2000
dtype: int64
s5 = pd.Series({'height':110, 'age':20, 'salary':2367})
s5
height 110
age 20
salary 2367
dtype: int64
s4 + s5 #索引所对应的值进行加减乘除
height 280
age 38
salary 4367
dtype: int64
s6 = pd.Series({'name':110, 'age':20, 'salary':2367})
s6
name 110
age 20
salary 2367
dtype: int64
s4
height 170
age 18
salary 2000
dtype: int64
s4 + s6
age 38.0
height NaN
name NaN
salary 4367.0
dtype: float64
s1
0 2
1 3
2 4
3 5
4 6
dtype: int64
2.5整数索引
pandas当中的整数索引对象可能会让初次接触它的人很懵逼，接下来通过代码演示：
sr = pd.Series(np.arange(10))
sr1 = sr[3:].copy()
sr1
运行结果：
3 3
4 4
5 5
6 6
7 7
8 8
9 9
dtype: int32
# 到这里会发现很正常，一点问题都没有，可是当使用整数索引取值的时候就会出现问题了。因为在pandas当中使用整数索引取值是优先以标签解释的，而不是下标
sr1[1]
解决方法：
- loc属性(location) # 以标签解释
- iloc属性(index location) # 以下标解释
sr1.iloc[1] # 以下标解释
sr1.loc[3] # 以标签解释
2.6Series数据对齐
pandas在运算时，会按索引进行对齐然后计算。如果存在不同的索引，则结果的索引是两个操作数索引的并集。
sr1 = pd.Series([12,23,34], index=['c','a','d'])
sr2 = pd.Series([11,20,10], index=['d','c','a',])
sr1 + sr2
运行结果:
a 33
c 32
d 45
dtype: int64
# 可以通过这种索引对齐直接将两个Series对象进行运算
sr3 = pd.Series([11,20,10,14], index=['d','c','a','b'])
sr1 + sr3
运行结果：
a 33.0
b NaN
c 32.0
d 45.0
dtype: float64
# sr1 和 sr3的索引不一致，所以最终的运行会发现b索引对应的值无法运算，就返回了NaN,一个缺失值
将两个Series对象相加时将缺失值设为0：
sr1 = pd.Series([12,23,34], index=['c','a','d'])
sr3 = pd.Series([11,20,10,14], index=['d','c','a','b'])
sr1.add(sr3,fill_value=0)
运行结果：
a 33.0
b 14.0
c 32.0
d 45.0
dtype: float64
# 将缺失值设为0，所以最后算出来b索引对应的结果为14
灵活的算术方法:add,sub,div,mul
三、DataFrame
DataFrame是一个表格型的数据结构，相当于是一个二维数组，含有一组有序的列。他可以被看做是由Series组成的字典，并且共用一个索引。
3.1创建方式
创建一个DataFrame数组可以有多种方式，其中最为常用的方式就是利用包含等长度列表或Numpy数组的字典来形成DataFrame：
第一种：
pd.DataFrame({'one':[1,2,3,4],'two':[4,3,2,1]})
# 产生的DataFrame会自动为Series分配所索引，并且列会按照排序的顺序排列
运行结果：
one two
0 1 4
1 2 3
2 3 2
3 4 1
> 指定列
可以通过columns参数指定顺序排列
data = pd.DataFrame({'one':[1,2,3,4],'two':[4,3,2,1]})
pd.DataFrame(data,columns=['one','two'])
# 打印结果会按照columns参数指定顺序
第二种：
pd.DataFrame({'one':pd.Series([1,2,3],index=['a','b','c']),'two':pd.Series([1,2,3],index=['b','a','c'])})
运行结果：
one two
a 1 2
b 2 1
c 3 3
以上创建方法简单了解就可以，因为在实际应用当中更多是读数据，不需要自己手动创建
3.2查看数据
常用属性和方法：
- index 获取行索引
- columns 获取列索引
- T 转置
- values 获取值索引
- describe 获取快速统计
one two
a 1 2
b 2 1
c 3 3
# 这样一个数组df
-----------------------------------------------------------------------------
df.index
运行结果：
Index(['a', 'b', 'c'], dtype='object')
----------------------------------------------------------------------------
df.columns
运行结果：
Index(['one', 'two'], dtype='object')
--------------------------------------------------------------------------
df.T
运行结果：
a b c
one 1 2 3
two 2 1 3
-------------------------------------------------------------------------
df.values
运行结果：
array([[1, 2],
[2, 1],
[3, 3]], dtype=int64)
------------------------------------------------------------------------
df.describe()
运行结果：
one two
count 3.0 3.0
mean 2.0 2.0
std 1.0 1.0
min 1.0 1.0
25% 1.5 1.5
50% 2.0 2.0
75% 2.5 2.5
max 3.0 3.0
3.3索引和切片
- DataFrame有行索引和列索引。
- DataFrame同样可以通过标签和位置两种方法进行索引和切片。
DataFrame使用索引切片：
- 方法1：两个中括号，先取列再取行。 df['A'][0]
- 方法2（推荐）：使用loc/iloc属性，一个中括号，逗号隔开，先取行再取列。
- loc属性：解释为标签
- iloc属性：解释为下标
- 向DataFrame对象中写入值时只使用方法2
- 行/列索引部分可以是常规索引、切片、布尔值索引、花式索引任意搭配。（注意：两部分都是花式索引时结果可能与预料的不同）
df = pd.DataFrame({'one':[1,2,3,4], 'two':[5,6,7,8]})
df
| one | two | |
|---|---|---|
| 0 | 1 | 5 |
| 1 | 2 | 6 |
| 2 | 3 | 7 |
| 3 | 4 | 8 |
df['one'].iloc[0] #### 先是获取列 再然后是行
1
df.index #### 获取行索引
RangeIndex(start=0, stop=4, step=1)
df.columns #### 获取列名
Index(['one', 'two'], dtype='object')
df.T
| 0 | 1 | 2 | 3 | |
|---|---|---|---|---|
| one | 1 | 2 | 3 | 4 |
| two | 5 | 6 | 7 | 8 |
df.values
array([[1, 5],
[2, 6],
[3, 7],
[4, 8]])
df.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 |
四、时间对象处理
时间序列类型
- 时间戳：特定时刻
- 固定时期：如2020年1月
- 时间间隔：起始时间-结束时间
Python库：datatime
- date、time、datetime、timedelta
- dt.strftime()
- strptime()
灵活处理时间对象：dateutil包
- dateutil.parser.parse()
import dateutil
dateutil.parser.parse("2019 Jan 2nd") # 这中间的时间格式一定要是英文格式
运行结果:
datetime.datetime(2019, 1, 2, 0, 0)
成组处理时间对象：pandas
- pd.to_datetime(['2018-01-01', '2019-02-02'])
pd.to_datetime(['2018-03-01','2019 Feb 3','08/12-/019'])
运行结果：
DatetimeIndex(['2018-03-01', '2019-02-03', '2019-08-12'], dtype='datetime64[ns]', freq=None) # 产生一个DatetimeIndex对象
# 转换时间索引
ind = pd.to_datetime(['2018-03-01','2019 Feb 3','08/12-/019'])
sr = pd.Series([1,2,3],index=ind)
sr
运行结果：
2018-03-01 1
2019-02-03 2
2019-08-12 3
dtype: int64
通过以上方式就可以将索引转换为时间
补充：
pd.to_datetime(['2018-03-01','2019 Feb 3','08/12-/019']).to_pydatetime()
运行结果：
array([datetime.datetime(2018, 3, 1, 0, 0),
datetime.datetime(2019, 2, 3, 0, 0),
datetime.datetime(2019, 8, 12, 0, 0)], dtype=object)
# 通过to_pydatetime()方法将其转换为array数组
产生时间对象数组：data_range
- start 开始时间
- end 结束时间
- periods 时间长度
- freq 时间频率，默认为'D'，可选H(our),W(eek),B(usiness),S(emi-)M(onth),(min)T(es), S(econd), A(year),…
pd.date_range("2019-1-1","2019-2-2")
运行结果：
DatetimeIndex(['2019-01-01', '2019-01-02', '2019-01-03', '2019-01-04',
'2019-01-05', '2019-01-06', '2019-01-07', '2019-01-08',
'2019-01-09', '2019-01-10', '2019-01-11', '2019-01-12',
'2019-01-13', '2019-01-14', '2019-01-15', '2019-01-16',
'2019-01-17', '2019-01-18', '2019-01-19', '2019-01-20',
'2019-01-21', '2019-01-22', '2019-01-23', '2019-01-24',
'2019-01-25', '2019-01-26', '2019-01-27', '2019-01-28',
'2019-01-29', '2019-01-30', '2019-01-31', '2019-02-01',
'2019-02-02'],
dtype='datetime64[ns]', freq='D')
时间序列
时间序列就是以时间对象为索引的Series或DataFrame。datetime对象作为索引时是存储在DatetimeIndex对象中的。
# 转换时间索引
dt = pd.date_range("2019-01-01","2019-02-02")
a = pd.DataFrame({"num":pd.Series(random.randint(-100,100) for _ in range(30)),"date":dt})
# 先生成一个带有时间数据的DataFrame数组
a.index = pd.to_datetime(a["date"])
# 再通过index修改索引
特殊功能：
- 传入“年”或“年月”作为切片方式
- 传入日期范围作为切片方式
- 丰富的函数支持：resample(), strftime(), ……
- 批量转换为datetime对象：to_pydatetime()
a.resample("3D").mean() # 计算每三天的均值
a.resample("3D").sum() # 计算每三天的和
...
4.1企业中处理数据的方式
#1. 别的同事会给你一个excel文件或者csv文件
#2. 使用pandas读取csv文件
movies = pd.read_csv('./douban_movie.csv') #只需要read_csv函数， 将csv中的所有数据读出
movies
| 名字 | 投票人数 | 类型 | 产地 | 上映时间 | 时长 | 年代 | 评分 | 首映地点 | |
|---|---|---|---|---|---|---|---|---|---|
| 0 | 肖申克的救赎 | 692795.0 | 剧情/犯罪 | 美国 | 1994-09-10 00:00:00 | 142.0 | 1994 | 9.6 | 多伦多电影节 |
| 1 | 控方证人 | 42995.0 | 剧情/悬疑/犯罪 | 美国 | 1957-12-17 00:00:00 | 116.0 | 1957 | 9.5 | 美国 |
| 2 | 美丽人生 | 327855.0 | 剧情/喜剧/爱情 | 意大利 | 1997-12-20 00:00:00 | 116.0 | 1997 | 9.5 | 意大利 |
| 3 | 阿甘正传 | 580897.0 | 剧情/爱情 | 美国 | 1994-06-23 00:00:00 | 142.0 | 1994 | 9.4 | 洛杉矶首映 |
| 4 | 霸王别姬 | 478523.0 | 剧情/爱情/同性 | 中国大陆 | 1993-01-01 00:00:00 | 171.0 | 1993 | 9.4 | 香港 |
| ... | ... | ... | ... | ... | ... | ... | ... | ... | ... |
| 38730 | 神学院 S | 46.0 | Adult | 法国 | 1905-06-05 00:00:00 | 58.0 | 1983 | 8.6 | 美国 |
| 38731 | 1935年 | 57.0 | 喜剧/歌舞 | 美国 | 1935-03-15 00:00:00 | 98.0 | 1935 | 7.6 | 美国 |
| 38732 | 血溅画屏 | 95.0 | 剧情/悬疑/犯罪/武侠/古装 | 中国大陆 | 1905-06-08 00:00:00 | 91.0 | 1986 | 7.1 | 美国 |
| 38733 | 魔窟中的幻想 | 51.0 | 惊悚/恐怖/儿童 | 中国大陆 | 1905-06-08 00:00:00 | 78.0 | 1986 | 8.0 | 美国 |
| 38734 | 列宁格勒围困之星火战役 Блокада: Фильм 2: Ленинградский ме... | 32.0 | 剧情/战争 | 苏联 | 1905-05-30 00:00:00 | 97.0 | 1977 | 6.6 | 美国 |
38735 rows × 9 columns
movies.index
RangeIndex(start=0, stop=38735, step=1)
movies.columns
Index(['名字', '投票人数', '类型', '产地', '上映时间', '时长', '年代', '评分', '首映地点'], dtype='object')
movies.values
array([['肖申克的救赎', 692795.0, '剧情/犯罪', ..., 1994, 9.6, '多伦多电影节'],
['控方证人', 42995.0, '剧情/悬疑/犯罪', ..., 1957, 9.5, '美国'],
['美丽人生 ', 327855.0, '剧情/喜剧/爱情', ..., 1997, 9.5, '意大利'],
...,
['血溅画屏', 95.0, '剧情/悬疑/犯罪/武侠/古装', ..., 1986, 7.1, '美国'],
['魔窟中的幻想', 51.0, '惊悚/恐怖/儿童', ..., 1986, 8.0, '美国'],
['列宁格勒围困之星火战役 Блокада: Фильм 2: Ленинградский метроном. Опе',
32.0, '剧情/战争', ..., 1977, 6.6, '美国']], dtype=object)
movies.describe()
| 投票人数 | 时长 | 年代 | 评分 | |
|---|---|---|---|---|
| count | 38735.000000 | 38735.000000 | 38735.000000 | 38735.000000 |
| mean | 6184.502438 | 89.050975 | 1998.788176 | 6.935678 |
| std | 26142.480865 | 83.335085 | 253.201997 | 1.270113 |
| min | -118.000000 | 1.000000 | 1888.000000 | 2.000000 |
| 25% | 98.000000 | 60.000000 | 1990.000000 | 6.300000 |
| 50% | 341.000000 | 92.000000 | 2005.000000 | 7.100000 |
| 75% | 1739.500000 | 106.000000 | 2010.000000 | 7.800000 |
| max | 692795.000000 | 11500.000000 | 39180.000000 | 9.900000 |
movies.to_csv('./aaaa.csv',index=False) #### 保存数据到一个文件中
pd.read_csv('./aaaa.csv')
| 名字 | 投票人数 | 类型 | 产地 | 上映时间 | 时长 | 年代 | 评分 | 首映地点 | |
|---|---|---|---|---|---|---|---|---|---|
| 0 | 肖申克的救赎 | 692795.0 | 剧情/犯罪 | 美国 | 1994-09-10 00:00:00 | 142.0 | 1994 | 9.6 | 多伦多电影节 |
| 1 | 控方证人 | 42995.0 | 剧情/悬疑/犯罪 | 美国 | 1957-12-17 00:00:00 | 116.0 | 1957 | 9.5 | 美国 |
| 2 | 美丽人生 | 327855.0 | 剧情/喜剧/爱情 | 意大利 | 1997-12-20 00:00:00 | 116.0 | 1997 | 9.5 | 意大利 |
| 3 | 阿甘正传 | 580897.0 | 剧情/爱情 | 美国 | 1994-06-23 00:00:00 | 142.0 | 1994 | 9.4 | 洛杉矶首映 |
| 4 | 霸王别姬 | 478523.0 | 剧情/爱情/同性 | 中国大陆 | 1993-01-01 00:00:00 | 171.0 | 1993 | 9.4 | 香港 |
| ... | ... | ... | ... | ... | ... | ... | ... | ... | ... |
| 38730 | 神学院 S | 46.0 | Adult | 法国 | 1905-06-05 00:00:00 | 58.0 | 1983 | 8.6 | 美国 |
| 38731 | 1935年 | 57.0 | 喜剧/歌舞 | 美国 | 1935-03-15 00:00:00 | 98.0 | 1935 | 7.6 | 美国 |
| 38732 | 血溅画屏 | 95.0 | 剧情/悬疑/犯罪/武侠/古装 | 中国大陆 | 1905-06-08 00:00:00 | 91.0 | 1986 | 7.1 | 美国 |
| 38733 | 魔窟中的幻想 | 51.0 | 惊悚/恐怖/儿童 | 中国大陆 | 1905-06-08 00:00:00 | 78.0 | 1986 | 8.0 | 美国 |
| 38734 | 列宁格勒围困之星火战役 Блокада: Фильм 2: Ленинградский ме... | 32.0 | 剧情/战争 | 苏联 | 1905-05-30 00:00:00 | 97.0 | 1977 | 6.6 | 美国 |
38735 rows × 9 columns
movies.head() #默认显示前5行， head中可以传入行数，查看
| 名字 | 投票人数 | 类型 | 产地 | 上映时间 | 时长 | 年代 | 评分 | 首映地点 | |
|---|---|---|---|---|---|---|---|---|---|
| 0 | 肖申克的救赎 | 692795.0 | 剧情/犯罪 | 美国 | 1994-09-10 00:00:00 | 142.0 | 1994 | 9.6 | 多伦多电影节 |
| 1 | 控方证人 | 42995.0 | 剧情/悬疑/犯罪 | 美国 | 1957-12-17 00:00:00 | 116.0 | 1957 | 9.5 | 美国 |
| 2 | 美丽人生 | 327855.0 | 剧情/喜剧/爱情 | 意大利 | 1997-12-20 00:00:00 | 116.0 | 1997 | 9.5 | 意大利 |
| 3 | 阿甘正传 | 580897.0 | 剧情/爱情 | 美国 | 1994-06-23 00:00:00 | 142.0 | 1994 | 9.4 | 洛杉矶首映 |
| 4 | 霸王别姬 | 478523.0 | 剧情/爱情/同性 | 中国大陆 | 1993-01-01 00:00:00 | 171.0 | 1993 | 9.4 | 香港 |
movies.tail() #默认显示后5行， tail中也可以传入行数查看
| 名字 | 投票人数 | 类型 | 产地 | 上映时间 | 时长 | 年代 | 评分 | 首映地点 | |
|---|---|---|---|---|---|---|---|---|---|
| 38730 | 神学院 S | 46.0 | Adult | 法国 | 1905-06-05 00:00:00 | 58.0 | 1983 | 8.6 | 美国 |
| 38731 | 1935年 | 57.0 | 喜剧/歌舞 | 美国 | 1935-03-15 00:00:00 | 98.0 | 1935 | 7.6 | 美国 |
| 38732 | 血溅画屏 | 95.0 | 剧情/悬疑/犯罪/武侠/古装 | 中国大陆 | 1905-06-08 00:00:00 | 91.0 | 1986 | 7.1 | 美国 |
| 38733 | 魔窟中的幻想 | 51.0 | 惊悚/恐怖/儿童 | 中国大陆 | 1905-06-08 00:00:00 | 78.0 | 1986 | 8.0 | 美国 |
| 38734 | 列宁格勒围困之星火战役 Блокада: Фильм 2: Ленинградский ме... | 32.0 | 剧情/战争 | 苏联 | 1905-05-30 00:00:00 | 97.0 | 1977 | 6.6 | 美国 |
4.2结合matplotlib绘图分析数据
movies1 = movies.groupby('产地').size().sort_values(ascending=False)
location = movies1.index
count = movies1.values
a = []
for i in range(28):
a.append(i)
data = list(count)
labels = list(location)
plt.figure(figsize=(170,60))
plt.tick_params(labelsize=80) #刻度字体大小13
plt.xticks(a,labels)
plt.bar(a,data)
plt.rcParams['font.sans-serif'] = ['Microsoft YaHei']
五、数据分组和聚合
在数据分析当中，我们有时需要将数据拆分，然后在每一个特定的组里进行运算，这些操作通常也是数据分析工作中的重要环节。
本章学习内容：
- 分组(GroupBY机制)
- 聚合(组内应用某个函数)
- apply
- 透视表和交叉表
5.1分组(GroupBY机制)
pandas对象（无论Series、DataFrame还是其他的什么）当中的数据会根据提供的一个或者多个键被拆分为多组，拆分操作实在对象的特定轴上执行的。就比如DataFrame可以在他的行上或者列上进行分组，然后将一个函数应用到各个分组上并产生一个新的值。最后将所有的执行结果合并到最终的结果对象中。
分组键的形式：
- 列表或者数组，长度与待分组的轴一样
- 表示DataFrame某个列名的值。
- 字典或Series，给出待分组轴上的值与分组名之间的对应关系
- 函数，用于处理轴索引或者索引中的各个标签吗
后三种只是快捷方式，最终仍然是为了产生一组用于拆分对象的值。
首先，通过一个很简单的DataFrame数组尝试一下：
df = pd.DataFrame({'key1':['x','x','y','y','x',
'key2':['one','two','one',',two','one'],
'data1':np.random.randn(5),
'data2':np.random.randn(5)})
df
运行结果：
key1 key2 data1 data2
0 x one 0.951762 1.632336
1 x two -0.369843 0.602261
2 y one 1.512005 1.331759
3 y ,two 1.383214 1.025692
4 x one -0.475737 -1.182826
访问data1，并根据key1调用groupby：
f1 = df['data1'].groupby(df['key1'])
f1
运行结果：
<pandas.core.groupby.groupby.SeriesGroupBy object at 0x00000275906596D8>
上述运行是没有进行任何计算的，但是我们想要的中间数据已经拿到了，接下来，就可以调用groupby进行任何计算
f1.mean() # 调用mean函数求出平均值
运行结果：
key1
x 0.106183
y 2.895220
Name: data1, dtype: float64
以上数据经过分组键（一个Series数组）进行了聚合，产生了一个新的Series，索引就是key1列中的唯一值。这些索引的名称就为key1。接下来就尝试一次将多个数组的列表传进来
f2 = df['data1'].groupby([df['key1'],df['key2']])
f2.mean()
运行结果：
key1 key2
x one 0.083878
two 0.872437
y one -0.665888
two -0.144310
Name: data1, dtype: float64
传入多个数据之后会发现，得到的数据具有一个层次化的索引，key1对应的xy;key2对应的one wo.
f2.mean().unstack()
运行结果：
key2 one two
key1
x 0.083878 0.872437
y -0.665888 -0.144310
# 通过unstack方法就可以让索引不堆叠在一起了
补充：
- 1、分组键可以是任意长度的数组
- 2、分组时，对于不是数组数据的列会从结果中排除，例如key1、key2这样的列
- 3、GroupBy的size方法，返回一个含有分组大小的Series
# 以上面的f2测试
f2.size()
运行结果：
key1 key2
x one 2
two 1
y one 1
two 1
Name: data1, dtype: int64
5.2聚合(组内应用某个函数)
聚合是指任何能够从数组产生标量值的数据转换过程。刚才上面的操作会发现使用GroupBy并不会直接得到一个显性的结果，而是一个中间数据，可以通过执行类似mean、count、min等计算得出结果，常见的还有一些:
| 函数名 | 描述 | |
|---|---|---|
| sum | 非NA值的和 | |
| median | 非NA值的算术中位数 | |
| std、var | 无偏（分母为n-1）标准差和方差 | |
| prod | 非NA值的积 | |
| first、last | 第一个和最后一个非NA值 |
自定义聚合函数
不仅可以使用这些常用的聚合运算，还可以自己自定义。
# 使用自定义的聚合函数，需要将其传入aggregate或者agg方法当中
def peak_to_peak(arr):
return arr.max() - arr.min()
f1.aggregate(peak_to_peak)
运行结果：
key1
x 3.378482
y 1.951752
Name: data1, dtype: float64
多函数聚合：
f1.agg(['mean','std'])
运行结果：
mean std
key1
x -0.856065 0.554386
y -0.412916 0.214939
最终得到的列就会以相应的函数命名生成一个DataFrame数组
5.3apply
GroupBy当中自由度最高的方法就是apply，它会将待处理的对象拆分为多个片段，然后各个片段分别调用传入的函数，最后将它们组合到一起。
df.apply(
['func', 'axis=0', 'broadcast=None', 'raw=False', 'reduce=None', 'result_type=None', 'args=()', '**kwds']
func:传入一个自定义函数
axis:函数传入参数当axis=1就会把一行数据作为Series的数据
# 分析欧洲杯和欧洲冠军联赛决赛名单
import pandas as pd
url="https://en.wikipedia.org/wiki/List_of_European_Cup_and_UEFA_Champions_League_finals"
eu_champions=pd.read_html(url) # 获取数据
a1 = eu_champions[2] # 取出决赛名单
a1.columns = a1.loc[0] # 使用第一行的数据替换默认的横向索引
a1.drop(0,inplace=True) # 将第一行的数据删除
a1.drop('#',axis=1,inplace=True) # 将以#为列名的那一列删除
a1.columns=['Season', 'Nation', 'Winners', 'Score', 'Runners_up', 'Runners_up_Nation', 'Venue','Attendance'] # 设置列名
a1.tail() # 查看后五行数据
a1.drop([64,65],inplace=True) # 删除其中的缺失行以及无用行
a1
运行结果：
现在想根据分组选出Attendance列中值最高的三个。
# 先自定义一个函数
def top(df,n=3,column='Attendance'):
return df.sort_values(by=column)[-n:]
top(a1,n=3)
运行结果：
接下来，就对a1分组并且使用apply调用该函数：
a1.groupby('Nation').apply(top)
运行之后会发现，我们通过这个操作将每个国家各个年份时段出席的人数的前三名进行了一个提取。
以上top函数是在DataFrame的各个片段上调用，然后结果又通过pandas.concat组装到一起，并且以分组名称进行了标记。
以上只是基本用法，apply的强大之处就在于传入函数能做什么都由自己说了算，它只是返回一个pandas对象或者标量值就行
5.4分组聚合实例
##读取某一个url网页里面所有的表格数据，直接爬出网页的数据并且以表格的形式显示，方便对数据的分析
res = pd.read_html('https://baike.baidu.com/item/NBA%E6%80%BB%E5%86%A0%E5%86%9B/2173192?fr=aladdin')
champion_res = res[0]
champion_res
| 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
##### 1.将第一行数据变成列名
champion_res.iloc[0]
0 年份
1 比赛日期
2 冠军
3 总比分
4 亚军
5 FMVP
Name: 0, dtype: object
champion_res.columns = champion_res.iloc[0] ### 将第一行的数据赋值给列名
champion_res.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 | 塞拉库斯民族队 | 无 |
#### 2.需要将第一行的数据删掉
champion_res.drop([0], inplace=True)
champion_res
| 年份 | 比赛日期 | 冠军 | 总比分 | 亚军 | 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
#### 1.求每个队获取冠军的次数
#####思路：对冠军球队进行分组 mysql： group by 分组对象
champion_res.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')}
#### 2.对数据进行聚合 mysql: count sum
champion_res.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
#### 3. 对数据进行排序 mysql： order by
champion_res.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
六、其他常用方法
pandas常用方法（适用Series和DataFrame）
- mean(axis=0,skipna=False)
- sum(axis=1)
- sort_index(axis, …, ascending) # 按行或列索引排序
- sort_values(by, axis, ascending) # 按值排序
- apply(func, axis=0) # 将自定义函数应用在各行或者各列上，func可返回标量或者Series
- applymap(func) # 将函数应用在DataFrame各个元素上
- map(func) # 将函数应用在Series各个元素上