python进阶（数据分析pandas库 一）
2、本章的英文词汇： 系列、列 ； 数据帧、数据表 ；
目录
一、简介
1、的导入方式：
2、的数据类型：
二、的操作方式
1、的增删改查
（1） 的创建与添加行数据：
（2）删除数据：
（3）数据修改：
（4） 常用方法 与 属性查看/ 赋值：
2、 取值（切片、索引）
3、 的运算方法
4、 缺省值的检测
5、 常用的方法：
三、 的操作方式
1、 的 创建和增删改查：
（1）的创建
（2） 增加数据：
（2） 删除数据：
del方法
（3）修改与参看数据
2、缺省值的检测与处理方式：
（1）缺省值的检测：
（2） 、Seies缺省值的处理：
3、、修改数据类型
四、的基本功能：
1、数据文件读取/文本数据读取与文本存储：
2、数学函数与对齐方式：
（1）数学统计函数：
（2）相关系数和协方差 .cov( ) 、 .corr()
（3）、、isin：
(4)去重：
3、层次索引：
4、排序：
（1）索引排序 .()
（2）值排序 .()
（3）.rank()
5、时间序列：
6、数据合并：
（1）表合并 pd.merge()
（2）表堆叠pd.（）
7、分组聚合
（1）.()
（2）()对象批量变换
（3）()分组聚合
（4） 利用agg函数对 对象多列各类聚合
（5） 将 分组的 对象转化为 {key：} 数据类型
（6）.() 分组统计排序函数
8、.apply()用法：
（2）.apply（）例题：
3、.agg()函数的用法
一、简介 1、的导入方式：
import numpy as np
import pandas as pd
from pandas import DataFrame,Series2、的数据类型：
两种数据类型：
：是由一组数据(各种NumPy数据类型 或 序列、字典)以及一组与之相关的数
据标签(即索引)组成，相当于 一维字典。
：它是一个二维结构，即有行索引也有列索引，每列可以是不同的值
类型(数值、字符串、布尔型等)，可以看做是由 所组成的二维或多维字典。
二、的操作方式 1、的增删改查 （1） 的创建与添加行数据：
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）删除数据：
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）数据修改：
通过索引直接赋值修改
（4） 常用方法 与 属性查看/ 赋值：
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、 取值（切片、索引）
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、 的运算方法
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、 缺省值的检测 1、 的 创建和增删改查：
df.columns、df.index、df.values ------ df 的 三个属性（1）的创建
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） 增加数据：
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）增加行数据：
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) 插入 一列数据 .
target_df.insert( 索引idx, 列名 , 数据)注意:这个操作会改变原始的 df 数据
例:
aa = target_df.insert(0,'name','liu')
print(target_df) ----- target_df 已经插入了数据
print(aa) ----- None
3) 插入一行数据
思想:第一步: 用 索引切开 df 要插入行的位置,行添加数据 第二步: merge concat 将 df 进行合并（2） 删除数据：
源数据
2000
12.
16.
15.
14.
2001
12.
16.
14.
13.
2002
13.
17.
15.
13.
2003
12.
16.
15.
12.
2004
13.
17.
15.
14.
2005
13.
16.
16.
11.
2006
13.
16.
15.
12.
2007
13.
16.
15.
13.
2008
13.
16.
15.
12.
2009
13.
16.
18.
12.
2010
13.
16.
15.
13.
2011
14.
16.
14.
12.
2012
13.
17.
14.
13.
2013
13.
17.
16.
13.
2014
12.
16.
14.
12.
2015
13.
16.
12.
11.
slope
0.
-0.
-0.
-0.
1、del 删除：删除原数据且不可访问
2、pop() 删除：返回值是删除的列，删除原数据
3、drop(labels= ,axis=) 删除：默认是行删除，源数据不变，可以通过inplace参数改变源数据删除行
In [1]:
import numpy as np
import pandas as pdodata = pd.read_csv('example.csv')
odataOut[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()方法如果不设置参数=True，则只能在生成的新数据块中实现删除效果，而不能删除原有数据块的相应行。
In [2]:
data = odata.drop([16,17])
odataOut[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.0776527455294In [3]:
dataOut[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如果=True则原有数据块的相应行被删除
In [4]:
odata.drop(odata.index[[16,17]],inplace=True)
odataOut[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']
odataOut[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')
springOut[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: objectIn [7]:
odataOut[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方法既可以保留原数据块中的所选列，也可以删除，这取决于参数
In [8]:
withoutSummer = odata.drop(['summer'],axis=1)
withoutSummerOut[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.0181384In [9]:
odataOut[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当=True时.drop()执行内部删除，不返回任何值，原数据发生改变
In [10]:
withoutWinter = odata.drop(['winter'],axis=1,inplace=True)
type(withoutWinter)Out[10]:
NoneTypeIn [11]:
odataOut[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）修改与参看数据
的loc、iloc、ix和at/iat浅析 ----------- 查看数据规范，不推荐其他查询方式
import pandas as pd
import numpy as npdf = 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]))print(df.loc[["a"]],type(df.loc[["a"]])) # 多加一个 [ ] ，返回的数据类型是 DataFrame快捷查看几行数据或者数据描述 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列的数据全为100df1['A'] = np.arange(8) -------- 修改A列 的数据为该数组df1.loc['a'] = 100 -------- 修改a行的数据为 100df1.loc[['a','c'],"B"] --------修改 a、c行 B列的数据为100
2、缺省值的检测与处理方式： （1）缺省值的检测：
与 的检测方式相同
（2） 、Seies缺省值的处理：
1）.( )
用法：df或对象.( )
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） .( )
用指定值或者插值的方式填充缺失数据，比如: 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） .( )
user_info.replace({'w':'m'}) ----------- 替换功能,字典的key是原值 字典的value是替换成的值
user_info = user_info.replace({np.nan:666}) ----------- replace（）原数据不变，因此需要重新赋值修改4）利用中的API
from sklearn.preprocessing import Imputer#空值的处理
X = X.replace("?", np.NAN)
# 使用Imputer给定缺省值，默认的是以mean
# 对于缺省值，进行数据填充；默认是以列/特征的均值填充
imputer = Imputer(missing_values="NaN")
X = imputer.fit_transform(X, Y)3、、修改数据类型
.() 修改 数据类型，需要重新赋值
.() 方法 ----- 将其他类型转化为 数字
把电影评分中的异常数据填充为所有评分的平均值
filmData['scores'] = filmData['scores'].replace({'暂无评分':np.nan}).astype('float64') --- replace() 原数据不变,需要重新赋值, .astype() >>> 修改数据类型
filmData['filmLong'] = filmData['filmLong'].astype('float64')
四、的基本功能： 1、数据文件读取/文本数据读取与文本存储：
用法：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 — 1.4.2 ----------- 、 ... API
2、数学函数与对齐方式： （1）数学统计函数：
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) --------- 相关系数（3）、、isin：
scores['班级'].unique()
----------------------------------------------------------------------------------
value_counts() 值计数
scores['语文'].value_counts() ------------------- value_counts() 自带分组总计效果
----------------------------------------------------------------------------------
isin() 成员资格，取出AI11班和AI12班的学生信息
scores[(scores['班级']=="AI11")|(scores['班级']=="AI12")]
scores[scores['班级'].isin(["AI11",'AI12'])](4)去重：
1、判断DataFrame重复df1.duplicated() # 返回值是一个 bool 类型的 Series2、DataFrame去重df1.drop_duplicates() # 返回值是一个按所有列去重后的 DataFramedf1.drop_duplicates('k1') # 按照 k1 列进行去重，返回值是去重后的 DataFrame3、层次索引：
() stack() () 交换索引时索引的顺序可能会打乱行索引有高维度多层的时候使用 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）索引排序 .()
（2）值排序 .()
--------值排序 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()
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’} 默认值 averageaverage ：在相等分组中，为各个值分配平均排名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, 默认值 TrueTrue 为升序排名 False为降序排名pct : boolean, 默认值 False计算数据的百分比等级返回 ：ranks : 与调用者类型相同# rank() 排名
print(df1)
df1.rank(method="min") # first 第一个出现的名次较高 5、时间序列：
6、数据合并： （1）表合并 pd.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)（2）表堆叠pd.（）
# 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、分组聚合 （1）.()
（2）()对象批量变换
groupby_res = processed_data_table.groupby(by=["学科"], axis=0)
groupby_res ---- # 因此 groupby 返回值是一个迭代对象，想要查看有两种方式① for 循环，详情见下文② 对分组的结果进行批量变换，利用 apply 方法，将迭代对象转化为DataFrame
groupby_res.apply(lambda x: x)
（3）()分组聚合
# 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_obj.agg({"姓名": 'count', "成绩": 'mean'}) # 对分组对象 ‘姓名列’进行count统计，‘成绩’列进行mean统计# 对于分组对象，按照分组的值进行 标准化# 对每个成绩进行对应学科的标准差标准化
groupy_obj = df1.groupy('学科')
groupby_obj["成绩"].apply(lambda x: (x-x.mean())/ x.std() )（5） 将 分组的 对象转化为 {key：} 数据类型
a = dict(tuple(content_df.groupby(by=['一级标签'])))（6）.() 分组统计排序函数
作用：对Series数据进行值统计，并且按照从大到小排列
本质：内部对Series进行groupby操作，然后每一组数据用counts函数，最后用orderby函数进行排序进阶（数据分析库 一）_自学AI的鲨鱼儿的博客-CSDN博客 ----------- 第四章第二小节（()用法）
8、.apply()用法：
参数：
# 根据参数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()函数的用法
..agg — 1.4.2
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
