- 1、
- ① Series、DataFrame 内部方法基本相同，许多DataFrame的方法Series同样适用；ndarray中的方法大多
- 也能用于 Series与Dataframe
- ② pandas的参考网址： Index — pandas 1.4.2 documentation
- 2、本章的英文词汇：Series 系列、列 ； DataFrame 数据帧、数据表 ；
目录
一、pandas简介
1、pandas的导入方式：
2、pandas的数据类型：
二、Series的操作方式
1、Series的增删改查
（1）Series 的创建与添加行数据：
（2）Series删除数据：
（3）Series数据修改：
（4）Series 常用方法 与 属性查看/ 赋值：
2、Series 取值（切片、索引）
3、Series 的运算方法
4、Series 缺省值的检测
5、Series 常用的方法：
三、DataFrame 的操作方式
1、DataFrame 的 创建和增删改查：
（1）DataFrame的创建
（2）DataFrame 增加数据：
（2）DataFrame 删除数据：
del方法
（3）修改与参看数据
2、缺省值的检测与处理方式：
（1）缺省值的检测：
（2）DataFrame 、Seies缺省值的处理：
3、DataFrame、Series修改数据类型
四、pandas的基本功能：
1、数据文件读取/文本数据读取与文本存储：
2、数学函数与对齐方式：
（1）数学统计函数：
（2） 相关系数和协方差 .cov( ) 、 .corr()
（3）unique、value_counts、isin：
(4)DataFrame去重：
3、层次索引：
4、排序：
（1）索引排序 .sort_index()
（2）值排序 .sort_values()
（3）.rank()
5、时间序列：
6、数据合并：
（1）表合并 pd.merge()
（2）表堆叠 pd.concat（）
7、分组聚合groupby
（1）.groupby()
（2）groupby() 对象批量变换DataFrame
（3）groupby() 分组聚合
（4） 利用agg函数对 groupy 对象多列各类聚合
（5） 将 分组的 groupby 对象转化为 {key：DataFrame} 数据类型
（6）.value_counts() 分组统计排序函数
8、.apply()用法：
（2）.apply（）例题：
3、.agg()函数的用法
一、pandas简介
1、pandas的导入方式：
import numpy as np
import pandas as pd
from pandas import DataFrame,Series2、pandas的数据类型：
- 特点：① pandas中主要有两种数据结构，分别是：Series和DataFrame
- ② Series 的索引是可以重复的，他可以有多种数据类型【但是如果仅仅有整
- 形、浮点型的数据时，Series往往会将所有的数值转化为float】，Series int 数
- 据类型默认为int64，而numpy int数据类型默认为int32。
- DataFrame 可以有多个数据类型，ndarray也只能有一种数据类型。
- ③ Series相当于一维字典，DataFrame相当于二维或多维字典（）
- ，因此字典的操作方式大多可以用。
- ④ DataFrame 如果是用 二维数组创建的，它Series存储 是以行为单位，若为二维字典创建，
- 它Series存储 是以 列为单位
两种数据类型：
Series：是由一组数据(各种NumPy数据类型 或 python序列、字典)以及一组与之相关的数
据标签(即索引)组成，相当于 一维字典。
DataFrame：DataFrame它是一个二维结构，即有行索引也有列索引，每列可以是不同的值
类型(数值、字符串 、布尔型等)，可以看做是由 Series所组成的二维或多维字典。
二、Series的操作方式
1、Series的增删改查
（1）Series 的创建与添加行数据：
- 特点：① 创建时可以指定 Series的 数据类型dtype 和 索引index列表
- ② 通过一维数组，python序列、字典
1、通过python 序列 与 numpy 一维数据创建
================================ 单层索引
ser1=pd.Series([28,29,27,29,29],index=["张三","李四","王五","赵六","田七"],dtype='int') ---- 使用列表进行创建
================================ 多层索引（level）
ser1=pd.Series([28,29,27,29,29],index=[['工人','职工','农民','职工','农民'],["张三","李四","王五","赵六","田七"]],dtype='int')
================================
2、通过字典创建
ser2=pd.Series({"1号线":2000,"3号线":2500,"4号线":2400,"5号线":900}) ------ 字典的key作为Series的index
=========================================== 添加行数据 ==============================
特点：类似于字典，赋值键值对 添加行数据
ser2['牛六'] = 40
（2）Series删除数据：
- 特点：类似于字典
1）第一种： del 对象名['索引名']
特点：删除的是原数据，删除后的数据无法访问
ser2=pd.Series({"1号线":2000,"3号线":2500,"4号线":2400,"5号线":900})
del ser2['1号线']2）第二种： 对象名.pop('索引名')
特点：删除原数据，并返回删除值
ser2=pd.Series({"1号线":2000,"3号线":2500,"4号线":2400,"5号线":900})
ser2.pop('3号线') ---------- 删除原数据，并返回删除值（3）Series数据修改：
通过索引直接赋值修改
（4）Series 常用方法 与 属性查看/ 赋值：
- 特点：Series 、ndarray、DataFrame 中的属性是可以赋值的
ser2=pd.Series({"1号线":2000,"3号线":2500,"4号线":2400,"5号线":900})
>>>>>>>>>>
ser2.dtype ---------- 查看数据类型（DataFrame没有该属性，但可以查看DataFrame每一列的Series数据类型）
ser2.index ---------- 获取Series 的索引,结果是list（他也通过赋值列表进行修改index）
ser2.values ---------- 获取Series 所有的值（一维数组）
ser2.name="地铁线路实时人数" ---------- 给整个series 命名
ser2.index.name="地铁线路" ---------- 给整个Series的索引列命名
ser2.empty --------- 判断是否全为空（空为True），返回值是bool，可以用于 if 语句中
例：
person=pd.Series({})
if person.empty:
print("有内鬼,终止交易")
else:
print(person.values)
ser2.ndim --------- 返回维度的整数
ser2.size --------- 返回大小
===========================================================================
axes 返回行轴标签列表 类似 index 外层多了一个列表
print(ser2.axes) --- [Index(['1号线', '3号线', '4号线', '5号线'], dtype='object')]
print(ser2.index) --- Index(['1号线', '3号线', '4号线', '5号线'], dtype='object')
=============================== head(n) tail(n) 前几行,最后几行 ====================
scores=pd.Series(np.random.randint(0,100,20))
print(scores)
scores.sort_values(ascending=False).head(10) #取前10名2、Series 取值（切片、索引）
- 特点：① ndarray、Series、DataFrame 均支持 bool索引
ser2=pd.Series({"1号线":2000,"3号线":2500,"4号线":2400,"5号线":900})
print(ser2)
=============================== 1、通过 index 取值 ---------- 通过index取值时切片 是闭区间
ser2['1号线'] ---------------- 索引取值
ser2[['1号线','4号线','5号线']] ----------- 同时取多个值，注意：要加上 []
ser2['1号线':"4号线"] ----------- 切片取值
=================================2、通过下标取值 ---------- 通过下标 取值时切片 是 前闭后开区间
ser2[0] --------- 取出下标为0的值
ser2[[0,2,3]] --------- 取下标为 0,2,3 的数据
ser2[0:2] --------- 前闭后开区间
================= 注意:如果出现了同名索引
ser3=pd.Series([10,30,39,184,14,451],index=['a','b','a','c','d','e'])
print(ser3)
ser3['a'] ----------- 如果出现同名索引会全都取出来
ser3['a':'d'] ----------- 切片会报错,因为不知道从哪个a开始截取
ser3['b':"d"]
======================================= bool 索引 ==================================
ser2[ser2>2000] -------------- ndarray、Series、DataFrame 均支持 bool索引3、Series 的运算方法
- 特点：① 类似于 ndarray ，元素级操作
- ② 两个Series 数据运算时根据 index 自动对齐运算 ，不相同的 index 用NaN填充
ser2=pd.Series({"1号线":2000,"3号线":2500,"4号线":2400,"5号线":900})
ser2.name="20号地铁情况"
----------------------
ser2+500
ser2+ser2
ser2[ser2>2000]
========================== 运算 根据index自动对齐（不存在的index用NaN填充）
ser4=pd.Series({"1号线":2398,"2号线":3000,"3号线":3100,"4号线":2000})
ser4.name='21号地铁情况'
print(ser4)
ser5=ser2+ser4
========================== 判断是否为NaN 值，返回为 bool数组
pd.isnull() pd.notnull() #判断是否是 NaN 值
ser5[np.isnan(ser5)] ----------- numpy 内部方法
ser5[~pd.isnull(ser5)] ----------- pandas 内部方法, ~ 表示 非
pd.notnull(ser5)
4、Series 缺省值的检测
- 特点：① ~ 在Series和DataFrame 中的 bool索引与 numpy相同，代表 取反。
5、Series 常用的方法：
- Series 的方法与DataFrame的方法类似，大多数方法通用
三、DataFrame 的操作方式
- 特点： ① DataFrame 相当于 由 Series 所组成的字典，每一列/行 都是 Series 数据
- ② DataFrame 没有 dtype属性，但可以查看DataFrame每一列的Series数据的 dtype属性
1、DataFrame 的 创建和增删改查：
df.columns、df.index、df.values ------ df 的 三个属性（1）DataFrame的创建
1） 代码：
============================ 通过 二维数组创建 ========================
# 创建
# pd.DataFrame(data,index,columns) index 行索引 columns 列索引
person_info=pd.DataFrame([
['男',12,'175cm','60kg'],
['女',18,'170cm','50kg'],
['男',30,'178cm','80kg'],
],index=['吕鹏',"刘亦菲","刘德华"],columns=['性别','年龄','身高','体重'])
person_info
============================= 通过字典创建 ============================
如果使用字典创建,字典外层的key会被当成 列索引, 里层的key当成行索引
person_info1=pd.DataFrame({
"吕鹏":{"性别":"男","年龄":12,"身高":"175cm","体重":"60kg"},
"刘亦菲":{"性别":"女","年龄":18,"身高":"172cm","体重":"50kg"},
"刘德华":{"性别":"男","年龄":40,"身高":"175cm","体重":"65kg"},
})
---------------------------------
person_info1=pd.DataFrame({
"吕鹏":['男',12,'170cm','54kg'],
"刘亦菲":['女',20,'170cm','54kg'],
"刘德华":['男',30,'170cm','54kg'],
},index=['性别',"年龄",'身高',"体重"])
person_info1- 2） 实例：重置索引
（2）DataFrame 增加数据：
1）增加列数据：
df1 = pd.DataFrame(np.random.randint(1,15,(8,8)),index=list('abcdefgh'),columns=list('ABCDEFGH'))
print(df1)
df1['J'] = 10 --------------- 添加 J 列并赋值整列的值为 10
df1['K'] = [1,2,3,4,5,6,7,8] ------------- 添加 K 列 并赋值列表的值
print(df1)2）增加行数据：
- 注意： DataFrame默认索引为 列索引，行索引要用 . loc 方法
df1 = pd.DataFrame(np.random.randint(1,15,(8,8)),index=list('abcdefgh'),columns=list('ABCDEFGH'))
print(df1)
df1.loc['j'] = 20
print(df1)2) 插入 一列数据 .insert
target_df.insert( 索引idx, 列名 , 数据)
注意:这个操作会改变原始的 df 数据
例:
aa = target_df.insert(0,'name','liu')
print(target_df) ----- target_df 已经插入了数据
print(aa) ----- None3) 插入一行数据
思想:
第一步: 用 索引切开 df 要插入行的位置,行添加数据
第二步: merge concat 将 df 进行合并（2）DataFrame 删除数据：
源数据
date | spring | summer | autumn | winter |
2000 | 12.2338809 | 16.90730113 | 15.69238313 | 14.08596223 |
2001 | 12.84748057 | 16.75046873 | 14.51406637 | 13.5037456 |
2002 | 13.558175 | 17.2033926 | 15.6999475 | 13.23365247 |
2003 | 12.6547247 | 16.89491533 | 15.6614647 | 12.84347867 |
2004 | 13.2537298 | 17.04696657 | 15.20905377 | 14.3647912 |
2005 | 13.4443049 | 16.7459822 | 16.62218797 | 11.61082257 |
2006 | 13.50569567 | 16.83357857 | 15.4979282 | 12.19934363 |
2007 | 13.48852623 | 16.66773283 | 15.81701437 | 13.7438216 |
2008 | 13.1515319 | 16.48650693 | 15.72957287 | 12.93233587 |
2009 | 13.45771543 | 16.63923783 | 18.26017997 | 12.65315943 |
2010 | 13.1945485 | 16.7286889 | 15.42635267 | 13.8833583 |
2011 | 14.34779417 | 16.68942103 | 14.17658043 | 12.36654197 |
2012 | 13.6050867 | 17.13056773 | 14.71796777 | 13.29255243 |
2013 | 13.02790787 | 17.38619343 | 16.20345497 | 13.18612133 |
2014 | 12.74668163 | 16.54428687 | 14.7367682 | 12.87065125 |
2015 | 13.465904 | 16.50612317 | 12.44243663 | 11.0181384 |
season | spring | summer | autumn | winter |
slope | 0.0379691374 | -0.01164689167 | -0.07913844113 | -0.07765274553 |
1、del 删除：删除原数据且不可访问
2、pop() 删除：返回值是删除的列，删除原数据
3、drop(labels= ,axis=) 删除：默认是行删除，源数据不变，可以通过inplace参数改变源数据删除行
In [1]:
import numpy as np
import pandas as pd
odata = pd.read_csv('example.csv')
odata
Out[1]:
date spring summer autumn winter
0 2000 12.2338809 16.9073011333 15.6923831333 14.0859622333
1 2001 12.8474805667 16.7504687333 14.5140663667 13.5037456
2 2002 13.558175 17.2033926 15.6999475 13.2336524667
3 2003 12.6547247 16.8949153333 15.6614647 12.8434786667
4 2004 13.2537298 17.0469665667 15.2090537667 14.3647912
5 2005 13.4443049 16.7459822 16.6221879667 11.6108225667
6 2006 13.5056956667 16.8335785667 15.4979282 12.1993436333
7 2007 13.4885262333 16.6677328333 15.8170143667 13.7438216
8 2008 13.1515319 16.4865069333 15.7295728667 12.9323358667
9 2009 13.4577154333 16.6392378333 18.2601799667 12.6531594333
10 2010 13.1945485 16.7286889 15.4263526667 13.8833583
11 2011 14.3477941667 16.6894210333 14.1765804333 12.3665419667
12 2012 13.6050867 17.1305677333 14.7179677667 13.2925524333
13 2013 13.0279078667 17.3861934333 16.2034549667 13.1861213333
14 2014 12.7466816333 16.5442868667 14.7367682 12.8706512467
15 2015 13.465904 16.5061231667 12.4424366333 11.0181384
16 season spring summer autumn winter
17 slope 0.037969137402 -0.0116468916667 -0.0791384411275 -0.0776527455294 想要删除最后两行
.drop()方法如果不设置参数inplace=True，则只能在生成的新数据块中实现删除效果，而不能删除原有数据块的相应行。
In [2]:
data = odata.drop([16,17])
odata
Out[2]:
date spring summer autumn winter
0 2000 12.2338809 16.9073011333 15.6923831333 14.0859622333
1 2001 12.8474805667 16.7504687333 14.5140663667 13.5037456
2 2002 13.558175 17.2033926 15.6999475 13.2336524667
3 2003 12.6547247 16.8949153333 15.6614647 12.8434786667
4 2004 13.2537298 17.0469665667 15.2090537667 14.3647912
5 2005 13.4443049 16.7459822 16.6221879667 11.6108225667
6 2006 13.5056956667 16.8335785667 15.4979282 12.1993436333
7 2007 13.4885262333 16.6677328333 15.8170143667 13.7438216
8 2008 13.1515319 16.4865069333 15.7295728667 12.9323358667
9 2009 13.4577154333 16.6392378333 18.2601799667 12.6531594333
10 2010 13.1945485 16.7286889 15.4263526667 13.8833583
11 2011 14.3477941667 16.6894210333 14.1765804333 12.3665419667
12 2012 13.6050867 17.1305677333 14.7179677667 13.2925524333
13 2013 13.0279078667 17.3861934333 16.2034549667 13.1861213333
14 2014 12.7466816333 16.5442868667 14.7367682 12.8706512467
15 2015 13.465904 16.5061231667 12.4424366333 11.0181384
16 season spring summer autumn winter
17 slope 0.037969137402 -0.0116468916667 -0.0791384411275 -0.0776527455294
In [3]:
data
Out[3]:
date spring summer autumn winter
0 2000 12.2338809 16.9073011333 15.6923831333 14.0859622333
1 2001 12.8474805667 16.7504687333 14.5140663667 13.5037456
2 2002 13.558175 17.2033926 15.6999475 13.2336524667
3 2003 12.6547247 16.8949153333 15.6614647 12.8434786667
4 2004 13.2537298 17.0469665667 15.2090537667 14.3647912
5 2005 13.4443049 16.7459822 16.6221879667 11.6108225667
6 2006 13.5056956667 16.8335785667 15.4979282 12.1993436333
7 2007 13.4885262333 16.6677328333 15.8170143667 13.7438216
8 2008 13.1515319 16.4865069333 15.7295728667 12.9323358667
9 2009 13.4577154333 16.6392378333 18.2601799667 12.6531594333
10 2010 13.1945485 16.7286889 15.4263526667 13.8833583
11 2011 14.3477941667 16.6894210333 14.1765804333 12.3665419667
12 2012 13.6050867 17.1305677333 14.7179677667 13.2925524333
13 2013 13.0279078667 17.3861934333 16.2034549667 13.1861213333
14 2014 12.7466816333 16.5442868667 14.7367682 12.8706512467
15 2015 13.465904 16.5061231667 12.4424366333 11.0181384如果inplace=True则原有数据块的相应行被删除
In [4]:
odata.drop(odata.index[[16,17]],inplace=True)
odata
Out[4]:
date spring summer autumn winter
0 2000 12.2338809 16.9073011333 15.6923831333 14.0859622333
1 2001 12.8474805667 16.7504687333 14.5140663667 13.5037456
2 2002 13.558175 17.2033926 15.6999475 13.2336524667
3 2003 12.6547247 16.8949153333 15.6614647 12.8434786667
4 2004 13.2537298 17.0469665667 15.2090537667 14.3647912
5 2005 13.4443049 16.7459822 16.6221879667 11.6108225667
6 2006 13.5056956667 16.8335785667 15.4979282 12.1993436333
7 2007 13.4885262333 16.6677328333 15.8170143667 13.7438216
8 2008 13.1515319 16.4865069333 15.7295728667 12.9323358667
9 2009 13.4577154333 16.6392378333 18.2601799667 12.6531594333
10 2010 13.1945485 16.7286889 15.4263526667 13.8833583
11 2011 14.3477941667 16.6894210333 14.1765804333 12.3665419667
12 2012 13.6050867 17.1305677333 14.7179677667 13.2925524333
13 2013 13.0279078667 17.3861934333 16.2034549667 13.1861213333
14 2014 12.7466816333 16.5442868667 14.7367682 12.8706512467
15 2015 13.465904 16.5061231667 12.4424366333 11.0181384删除列
del方法
In [5]:
del odata['date']
odata
Out[5]:
spring summer autumn winter
0 12.2338809 16.9073011333 15.6923831333 14.0859622333
1 12.8474805667 16.7504687333 14.5140663667 13.5037456
2 13.558175 17.2033926 15.6999475 13.2336524667
3 12.6547247 16.8949153333 15.6614647 12.8434786667
4 13.2537298 17.0469665667 15.2090537667 14.3647912
5 13.4443049 16.7459822 16.6221879667 11.6108225667
6 13.5056956667 16.8335785667 15.4979282 12.1993436333
7 13.4885262333 16.6677328333 15.8170143667 13.7438216
8 13.1515319 16.4865069333 15.7295728667 12.9323358667
9 13.4577154333 16.6392378333 18.2601799667 12.6531594333
10 13.1945485 16.7286889 15.4263526667 13.8833583
11 14.3477941667 16.6894210333 14.1765804333 12.3665419667
12 13.6050867 17.1305677333 14.7179677667 13.2925524333
13 13.0279078667 17.3861934333 16.2034549667 13.1861213333
14 12.7466816333 16.5442868667 14.7367682 12.8706512467
15 13.465904 16.5061231667 12.4424366333 11.0181384.pop()方法
.pop方法可以将所选列从原数据块中弹出，原数据块不再保留该列
In [6]:
spring = odata.pop('spring')
spring
Out[6]:
0 12.2338809
1 12.8474805667
2 13.558175
3 12.6547247
4 13.2537298
5 13.4443049
6 13.5056956667
7 13.4885262333
8 13.1515319
9 13.4577154333
10 13.1945485
11 14.3477941667
12 13.6050867
13 13.0279078667
14 12.7466816333
15 13.465904
Name: spring, dtype: object
In [7]:
odata
Out[7]:
summer autumn winter
0 16.9073011333 15.6923831333 14.0859622333
1 16.7504687333 14.5140663667 13.5037456
2 17.2033926 15.6999475 13.2336524667
3 16.8949153333 15.6614647 12.8434786667
4 17.0469665667 15.2090537667 14.3647912
5 16.7459822 16.6221879667 11.6108225667
6 16.8335785667 15.4979282 12.1993436333
7 16.6677328333 15.8170143667 13.7438216
8 16.4865069333 15.7295728667 12.9323358667
9 16.6392378333 18.2601799667 12.6531594333
10 16.7286889 15.4263526667 13.8833583
11 16.6894210333 14.1765804333 12.3665419667
12 17.1305677333 14.7179677667 13.2925524333
13 17.3861934333 16.2034549667 13.1861213333
14 16.5442868667 14.7367682 12.8706512467
15 16.5061231667 12.4424366333 11.0181384.drop()方法
drop方法既可以保留原数据块中的所选列，也可以删除，这取决于参数inplace
In [8]:
withoutSummer = odata.drop(['summer'],axis=1)
withoutSummer
Out[8]:
autumn winter
0 15.6923831333 14.0859622333
1 14.5140663667 13.5037456
2 15.6999475 13.2336524667
3 15.6614647 12.8434786667
4 15.2090537667 14.3647912
5 16.6221879667 11.6108225667
6 15.4979282 12.1993436333
7 15.8170143667 13.7438216
8 15.7295728667 12.9323358667
9 18.2601799667 12.6531594333
10 15.4263526667 13.8833583
11 14.1765804333 12.3665419667
12 14.7179677667 13.2925524333
13 16.2034549667 13.1861213333
14 14.7367682 12.8706512467
15 12.4424366333 11.0181384
In [9]:
odata
Out[9]:
summer autumn winter
0 16.9073011333 15.6923831333 14.0859622333
1 16.7504687333 14.5140663667 13.5037456
2 17.2033926 15.6999475 13.2336524667
3 16.8949153333 15.6614647 12.8434786667
4 17.0469665667 15.2090537667 14.3647912
5 16.7459822 16.6221879667 11.6108225667
6 16.8335785667 15.4979282 12.1993436333
7 16.6677328333 15.8170143667 13.7438216
8 16.4865069333 15.7295728667 12.9323358667
9 16.6392378333 18.2601799667 12.6531594333
10 16.7286889 15.4263526667 13.8833583
11 16.6894210333 14.1765804333 12.3665419667
12 17.1305677333 14.7179677667 13.2925524333
13 17.3861934333 16.2034549667 13.1861213333
14 16.5442868667 14.7367682 12.8706512467
15 16.5061231667 12.4424366333 11.0181384当inplace=True时.drop()执行内部删除，不返回任何值，原数据发生改变
In [10]:
withoutWinter = odata.drop(['winter'],axis=1,inplace=True)
type(withoutWinter)
Out[10]:
NoneType
In [11]:
odata
Out[11]:
summer autumne
0 16.9073011333 15.6923831333
1 16.7504687333 14.5140663667
2 17.2033926 15.6999475
3 16.8949153333 15.6614647
4 17.0469665667 15.2090537667
5 16.7459822 16.6221879667
6 16.8335785667 15.4979282
7 16.6677328333 15.8170143667
8 16.4865069333 15.7295728667
9 16.6392378333 18.2601799667
10 16.7286889 15.4263526667
11 16.6894210333 14.1765804333
12 17.1305677333 14.7179677667
13 17.3861934333 16.2034549667
14 16.5442868667 14.7367682
15 16.5061231667 12.4424366333总结，不论是行删除还是列删除，也不论是原数据删除，还是输出新变量删除，.drop()的方法都能达到目的，为了方便好记，熟练操作，所以应该尽量多使用.drop()方法
2）删除行数据： .drop() （ 默认删除行，可以通过axis = 1 删除列 ）
df1 = pd.DataFrame(np.random.randint(1,15,(8,8)),index=list('abcdefgh'),columns=list('ABCDEFGH'))
print(df1)
print(df1.drop("d")) ------------ 返回值是删除后的数据
print(df1.drop(['a','b','e'])) ------------ 删除 多行，原数据不变
print(df1.drop(['a':'e'])) ------------- 报错， .drop()不能执行索引
print(df1) ------------ 原数据不变
========================= 批量删除行 ===========
print(df1.drop(df1.loc['a':'e'].index)) ------------- 批量删除行（3）修改与参看数据
Pandas DataFrame的loc、iloc、ix和at/iat浅析 ----------- DataFrame 查看数据规范，不推荐其他查询方式
- 需要注意的是：.loc 或者 .iloc 如果取出dataframe一列或者一行数据，取得的数据的数据类型是Series，但是如果使用的是bool索引，即使取得的数据是一行或者一列，他的数据类型依然是dataframe，例如：
import pandas as pd
import numpy as np
df = pd.DataFrame(np.arange(12).reshape(3,4),columns=list('ABCD'),index=list('abc'))
print(df)
print(df["A"],type(df["A"]))
print(df.loc[:,"A"],type(df.loc[:,"A"]))
print(df.loc["a"],type(df.loc["a"]))
print(df.iloc[:,0],type(df.iloc[:,0]))
print('\n注意看下面的数据类型：\n')
print(df[df["B"]==1],type(df[df["B"]==1]))- 那么如何使用 .loc 或者 .iloc 如果取出dataframe一列或者一行数据是 DataFrame呢？【方法：仅仅多加一个 [ ] 即可】
print(df.loc[["a"]],type(df.loc[["a"]])) # 多加一个 [ ] ，返回的数据类型是 DataFramedataframe 快捷查看几行数据或者数据描述 API
df.head(n) -------- 查看前 n 行，默认为 5
df.tail(n) -------- 查看后 n 行，默认为 5
df.info() -------- 查看df信息
df.describe() -------- 快速统计dfdf1 = pd.DataFrame(np.random.randint(1,15,(8,8)),index=list('abcdefgh'),columns=list('ABCDEFGH'))
1、查看数据：
1.1 查看列数据：
print(df1['A']) --------- 查看A列数据
print(df1[ ['A','B','D']]) -------- 查看 多列 数据
print(df1['A':'D']) -------- 报错，不能直接切片
print(df1.loc[:,'A':'D') -------- 用 .loc 方法切片
print(df1.loc[:,['A','D']) -------- 与 ndarray相似，要加 [ ]
1.2 查看行数据：
print(df1.loc['a']) --------- .loc 方法 一个参数时表示 行数据
print(df1.loc[['a','d']] --------- 查看 a d 行
print(df1.loc[['a','d'],'B'] --------- 查看 a d 并且 B的内容（两个参数时表示 行列数据
pirnt(df1.loc[:800,:] --------- 查看前800行的数据
1.3 .iloc[] -------- 用下标进行索引
df1.iloc[:,0:2] --------- 取前两列的所有数据
2、修改数据：
修改数据的原理：类似于字典，DataFrame直接 赋值 即可修改
df1['A'] = 100 -------- 修改A列的数据全为100
df1['A'] = np.arange(8) -------- 修改A列 的数据为该数组
df1.loc['a'] = 100 -------- 修改a行的数据为 100
df1.loc[['a','c'],"B"] --------修改 a、c行 B列的数据为1002、缺省值的检测与处理方式：
（1）缺省值的检测：
DataFrame 与 Series 的检测方式相同
（2）DataFrame 、Seies缺省值的处理：
1）.dropna( )
用法：df或series对象.dropna( )
dropna ------- 根据标签的值中是否存在缺失数据对轴标签进行过滤(删除), 可以通过阈值 how = ? 的调节对缺失值的容忍度============ .dropna(axis = ,how= ,inplace= ) 删除 包含 NaN 值的行(axis 表示删除的轴 某认为行0轴，how表示阈值默认为any，
inplace=True表示删除操作后保存到源文件中，即没有返回值，原数据改变
# 当axis为0的时候，是对行数据进行处理/删除
# 当axis为1的时候，是对列数据进行处理/删除
# 当how为'any'的时候，表示只要有任何一个值为nan，则对应的行或者列全部删除
# 当how为'all'的时候，要求行或者列所有值均为nan的时候才进行删除操作。
# 当inplace为True的时候，表示直接在对象上进行删除，也就是原始对象直接修改了。没有返回值。
# 当inplace为False的时候，表示返回一个新的对象，在新对象上删除，原始对象不变。
1、user_info.dropna() ------------------ 删除包含nan值的行（一个也要删除）
2、user_info.dropna(how = 'all') ------------------ 删除 全部为 nan值的行
问题：过滤某一列为 NaN的行
df1[~df1['B'].isnull()] ------------ 利用bool 索引过滤掉 B列为NaN值的行数据2） .fillna( )
- 用法：df或series对象.fillna( )
fillna | 用指定值或者插值的方式填充缺失数据，比如: ffill或者bfill |
user_info.fillna("*") ------ 填充所有的nan值 为 * 号
user_info.fillna({"name":"Tom","age":18,"sex":"m",'sg':"170cm"}) ----- fillna里面写字典, 字典的key对应DataFrame的列，即不同列用不同值替换
user_info.fillna(method="ffill") ------ ffill：上一行数据填充，若上一行也为NaN值，则寻找更上一行数据，若所有行为空，那么还是nan
user_info.fillna(method="bfill") 向后填充
user_info.fillna(method='ffill',axis=1) # 使用上一列填充3） .replace( )
user_info.replace({'w':'m'}) ----------- 替换功能,字典的key是原值 字典的value是替换成的值
user_info = user_info.replace({np.nan:666}) ----------- replace（）原数据不变，因此需要重新赋值修改4）利用sklearn中的API Imputer
from sklearn.preprocessing import Imputer
#空值的处理
X = X.replace("?", np.NAN)
# 使用Imputer给定缺省值，默认的是以mean
# 对于缺省值，进行数据填充；默认是以列/特征的均值填充
imputer = Imputer(missing_values="NaN")
X = imputer.fit_transform(X, Y)3、DataFrame、Series修改数据类型
.astype() 修改 数据类型，需要重新赋值
.to_numeric() 方法 ----- 将其他类型转化为 数字
把电影评分中的异常数据填充为所有评分的平均值
filmData['scores'] = filmData['scores'].replace({'暂无评分':np.nan}).astype('float64') --- replace() 原数据不变,需要重新赋值, .astype() >>> 修改数据类型
filmData['filmLong'] = filmData['filmLong'].astype('float64')四、pandas的基本功能：
数据文件读取/文本数据读取与文本存储：
- 特点： ① pandas提供的read_xxx相关的函数可以读取文件中的数据，并形成DataFrame,常用的
- 数据读取方法为：read_csv( )、read_json( )、read_excel( )，主要可以读取文本类型的数据。
用法：pd.read_csv('文件路径',sep='分割符'（可以传正则表达式） ,delimter= ,header= ,names= ,index_col= )
-----------------------------------------------------------------------------------
scores=pd.read_csv("./file/stu_score.csv",names=['班级',"学号","语文","数学","英语"])
-----------------------------------------------------------------------------------
sep ---------- 指定分隔符，默认为 ‘ ，’
header ----------- 是否将第一行数据作为 列名，例：header = None
names ----------- 接收参数是一个序列，定义 数据的 列名（而通过pd.DataFrame()创建的数据用的用的是 .columns=序列 定义列名的）
===================================================================================
.info()方法
print(scores.info()) ----------------- 获取信息
index ------- 控制是否保存行索引
Index — pandas 1.4.2 documentation ----------- pandas to_csv、to_excel ... API
2、数学函数与对齐方式：
（1）数学统计函数：
- 特点：① NaN不会参数函数的计算
idxmin idxmax 找到最大值或者最小值的 索引
scores.loc[scores.loc[:,"语文":"英语"].idxmin()] ------- 找到最低分的人
scores[scores['语文']==88] ------ bool索引，找到语文成绩考88分的人
（2） 相关系数和协方差 .cov( ) 、 .corr()
ages=pd.Series(range(12,21))
heights=pd.Series([130,135,142,150,160,162,164,166,168])
ages.cov(heights) ---------- 协方差
ages.corr(heights) --------- 相关系数、value_counts、isin：
- 特点：① .unique() 方法用于获取Series中的唯一值数组(去重数据后的数组)，注意：对象是 Series
- ② .value_counts() 方法返回一个包含值和该值出现次数的Series对象,次序按照出现的频率
- 由高到低排序 ，注意：他的对象是Series，DataFrame只能 取某一列
scores['班级'].unique()
----------------------------------------------------------------------------------
value_counts() 值计数
scores['语文'].value_counts() ------------------- value_counts() 自带分组总计效果
----------------------------------------------------------------------------------
isin() 成员资格，取出AI11班和AI12班的学生信息
scores[(scores['班级']=="AI11")|(scores['班级']=="AI12")]
scores[scores['班级'].isin(["AI11",'AI12'])]
(4)DataFrame去重：
1、判断DataFrame重复
df1.duplicated() # 返回值是一个 bool 类型的 Series
2、DataFrame去重
df1.drop_duplicates() # 返回值是一个按所有列去重后的 DataFrame
df1.drop_duplicates('k1') # 按照 k1 列进行去重，返回值是去重后的 DataFrame3、层次索引：
- 索引的顺序可能会打乱
- 行索引有高维度多层的时候使用 df.loc[("A","a"),("A","b")] ,:]可以索引多层行索引
代码：
# 2017 年 苹果 220t 橘子 280t 香蕉 110t
# 2018 年 苹果 300t 橘子 90t
chl=pd.DataFrame([
[220,280,110],
[300,90]
],index=[2017,2018],columns=['苹果','橘子','香蕉'])
print(chl)
chl.mean(axis=1)
chl.stack().swaplevel().sort_index(level=0)
info=pd.Series([220,280,110,300,90],index=[[2017,2017,2017,2018,2018],['苹果','橘子','香蕉','苹果','橘子']])
print(info)
info[2017,'苹果']
info[:,'苹果']
info.mean(level=1) # level 是索引层次
info.unstack(level=1) # 把层次索引改为列索引 level写n就是把第n层作为 列索引4、排序：
（1）索引排序 .sort_index()
（2）值排序 .sort_values()
--------值排序 sort_values() ----- DataFrame不能整体排序，需要 by其中的一列，Series可以直接排序，不需要by参数
df1.sort_values(by=['E','C']) -----------通过E列排序,如果有相同的,通过C列排序
df1.sort_values(by=['E',"C"],ascending=[True,False])--------- 通过E列升序,C列降序
df1.sort_values(by='e',axis=1) ------- 通过e行排序（3）.rank()
- 特点：rank中的method有五种种方法，默认是 average（平均值）；
- Pandas | rank()函数
DataFrame.rank(axis=0, method='average', numeric_only=None, na_option='keep', ascending=True, pct=False)
功能：计算沿着轴的数值数据（1到n）。 等值的排名是这些值的排名的平均值。返回从小到大排序的下标。
参数：axis : {0 or ‘index’, 1 or ‘columns’}, 默认值0 按照哪个轴进行排序
method : {‘average’, ‘min’, ‘max’, ‘first’} 默认值 average
average ：在相等分组中，为各个值分配平均排名
min ：使用整个分组的最小排名
max ：使用整个分组的最大排名
first ： 按值在原始数据中的出现顺序分配排名
dense：
numeric_only : boolean, 默认值 None 仅包含float，int和boolean数据。 仅对DataFrame或Panel对象有效
na_option : {‘keep’, ‘top’, ‘bottom’}
keep：将NA值保留在原来的位置
top ： 如果升序，将NA值排名第一
bottom ：如果降序，将NA值排名第一
ascending : boolean, 默认值 True
True 为升序排名 False为降序排名
pct : boolean, 默认值 False
计算数据的百分比等级
返回 ：ranks : 与调用者类型相同
# rank() 排名
print(df1)
df1.rank(method="min") # first 第一个出现的名次较高5、时间序列：
6、数据合并：
merge()
merge() 表合并
pd.merge(stu,scores,left_on='stu_id',right_on="stu_num",how='inner')
pd.merge(stu,scores,how='inner',on='stu_id')
pd.merge(stu,scores,left_index=True,right_index=True).concat（）
# concat() 堆叠
stu=pd.read_csv("./file/merge_stu_name.csv",index_col='stu_id')
print(stu)
stu1=pd.read_csv("./file/merge_stu_name1.csv",index_col='stu_id')
print(stu1)
pd.concat([stu,stu1],sort=True,join='inner',axis=1) # axis=0 垂直方向堆叠 axis=1 水平方向堆叠7、分组聚合groupby
（1）.groupby()
（2）groupby() 对象批量变换DataFrame
groupby_res = processed_data_table.groupby(by=["学科"], axis=0)
groupby_res ---- <pandas.core.groupby.generic.DataFrameGroupBy object at 0x0000000008E1D7F0>
# 因此 groupby 返回值是一个迭代对象，想要查看有两种方式
① for 循环，详情见下文
② 对分组的结果进行批量变换，利用 apply 方法，将迭代对象转化为DataFrame
groupby_res.apply(lambda x: x)
（3）groupby() 分组聚合
# groupby() 分组
scores
# for i in scores.groupby("班级"):
# print(i)
# print("-"*30)
# scores.loc[:,['班级','语文','数学','英语']].groupby('班级').min()
# job51.groupby("工作地址")["职位名"].count().sort_values(ascending=False)
# apply() 对series 或者 DataFrame 应用操作
ser1=pd.Series(np.arange(10))
ser1
# ser1.apply(lambda x:x+10)
# 对 Series 进行apply的时候,是把 Series的每一个元素 传到方法里,运算并且返回
# def f1(x):
# if x%2==0:
# return "偶数"
# else:
# return "奇数"
# ser1.apply(f1)
# 对DataFrame 进行 apply操作的时候 每次传入的是 DataFrame的 列,如果设置axis=1 每次传入的是一行
df2=pd.DataFrame(np.random.randint(1,10,[5,5]),index=list('abcde'),columns=list("ABCDE"))
print(df2)
# df2.apply(lambda x: x.max(),axis=1)
def f2(x,num):
return x.max()+num
# df2.apply(f2,args=(10,))
df2.apply(f2,num=10) # 版本不同的话,这两种方式,有可能只能使用其中的一种（4） 利用agg函数对 groupy 对象多列各类聚合
# 分组差别化统计
groupy_obj.agg({"姓名": 'count', "成绩": 'mean'}) # 对分组对象 ‘姓名列’进行count统计，‘成绩’列进行mean统计# 对于分组对象，按照分组的值进行 标准化
# 对每个成绩进行对应学科的标准差标准化
groupy_obj = df1.groupy('学科')
groupby_obj["成绩"].apply(lambda x: (x-x.mean())/ x.std() )（5） 将 分组的 groupby 对象转化为 {key：DataFrame} 数据类型
a = dict(tuple(content_df.groupby(by=['一级标签'])))value_counts() 分组统计排序函数
作用：对Series数据进行值统计，并且按照从大到小排列
本质：内部对Series进行groupby操作，然后每一组数据用counts函数，最后用orderby函数进行排序
8、.apply()用法：
- 特点：① 相当于for循环
- ② Series 的apply每次循环一个数据，DataFrame的apply每次循环是DataFrame的一个列的数据
- 但apply函数中，0轴表示传入列（返回列），
- 1轴表示传入行（返回行）
- ----------- 利用这个特点，我们可以将多列Series 转化str后 拼接为一列
参数：
# 根据参数func对数据进行处理，处理结果作为DataFrame的内部数据存在(行或者列存在),
# 具体处理行数据还是列数据，根据参数axis决定，当为0的时候，处理列数据，返回也是列数据，当为1的，处理行数据，返回也是行数据
DataFrame.apply(func, axis=0, broadcast=False, raw=False, reduce=None, args=(), **kwds)
用法：
X = df.apply(func = lambda row: format_time(row),axis=1) ----- axis=1 ，每次传入 df 的一个行例：
# apply() 对series 或者 DataFrame 应用操作
ser1=pd.Series(np.arange(10))
ser1
# ser1.apply(lambda x:x+10)
# 对 Series 进行apply的时候,是把 Series的每一个元素 传到方法里,运算并且返回
# def f1(x):
# if x%2==0:
# return "偶数"
# else:
# return "奇数"
# ser1.apply(f1)
# 对DataFrame 进行 apply操作的时候 每次传入的是 DataFrame的 列,如果设置axis=1 每次传入的是一行
df2=pd.DataFrame(np.random.randint(1,10,[5,5]),index=list('abcde'),columns=list("ABCDE"))
print(df2)
# df2.apply(lambda x: x.max(),axis=1)
def f2(x,num):
return x.max()+num
# df2.apply(f2,args=(10,))
df2.apply(f2,num=10) # 版本不同的话,这两种方式,有可能只能使用其中的一种（2）.apply（）例题：
例题一：
a1=pd.read_csv("./file/apply1.csv",index_col=0)
print(a1)
a1["E"].apply(lambda x:pd.Series(x.split("-")))
============================== 第二种=================================
apply1_new = apply1['E']
def maketime(one):
return list(time.strptime(one,'%Y-%m-%d')[0:3])
apply11 = apply1_new.apply(maketime)
DataFrame(list(apply11)) # DataFrame 不能转换 多层的元组3、.agg()函数的用法
pandas.DataFrame.agg — pandas 1.4.2 documentation
apply 函数会对iter对象中有一个元素进行 ‘操作’ 并进行返回
agg 函数以对DataFrame中 指定一个或多个列 进行 ‘批量合并操作’# 整列合并计算
processed_data_table.agg({"成绩": np.mean, "星座": 'mode'})df = pd.DataFrame([[1, 2, 3],
[4, 5, 6],
[7, 8, 9],
[np.nan, np.nan, np.nan]],
columns=['A', 'B', 'C'])
Aggregate these functions over the rows.
df.agg(['sum', 'min'])
A B C
sum 12.0 15.0 18.0
min 1.0 2.0 3.0
Different aggregations per column.
df.agg({'A' : ['sum', 'min'], 'B' : ['min', 'max']})
A B
max NaN 8.0
min 1.0 2.0
sum 12.0 NaN
Aggregate over the columns.
df.agg("mean", axis="columns")
0 2.0
1 5.0
2 8.0
3 NaN
dtype: float64本文章为转载内容，我们尊重原作者对文章享有的著作权。如有内容错误或侵权问题，欢迎原作者联系我们进行内容更正或删除文章。
