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 npimport pandas as pdfrom pandas import DataFrame,Series
2、的数据类型：
两种数据类型：
：是由一组数据(各种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+500ser2+ser2ser2[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 列并赋值整列的值为 10df1['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'] = 20print(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 npimport pandas as pdodata = http://www.kingceram.com/post/pd.read_csv('example.csv')odataOut[1]:datespringsummerautumnwinter0200012.233880916.907301133315.692383133314.08596223331200112.847480566716.750468733314.514066366713.50374562200213.55817517.203392615.699947513.23365246673200312.654724716.894915333315.661464712.84347866674200413.253729817.046966566715.209053766714.36479125200513.444304916.745982216.622187966711.61082256676200613.505695666716.833578566715.497928212.19934363337200713.488526233316.667732833315.817014366713.74382168200813.151531916.486506933315.729572866712.93233586679200913.457715433316.639237833318.260179966712.653159433310201013.194548516.728688915.426352666713.883358311201114.347794166716.689421033314.176580433312.366541966712201213.605086717.130567733314.717967766713.292552433313201313.027907866717.386193433316.203454966713.186121333314201412.746681633316.544286866714.736768212.870651246715201513.46590416.506123166712.442436633311.018138416seasonspringsummerautumnwinter17slope0.037969137402-0.0116468916667-0.0791384411275-0.0776527455294想要删除最后两行
.drop()方法如果不设置参数=True，则只能在生成的新数据块中实现删除效果，而不能删除原有数据块的相应行 。
In [2]:data = http://www.kingceram.com/post/odata.drop([16,17])odataOut[2]:datespringsummerautumnwinter0200012.233880916.907301133315.692383133314.08596223331200112.847480566716.750468733314.514066366713.50374562200213.55817517.203392615.699947513.23365246673200312.654724716.894915333315.661464712.84347866674200413.253729817.046966566715.209053766714.36479125200513.444304916.745982216.622187966711.61082256676200613.505695666716.833578566715.497928212.19934363337200713.488526233316.667732833315.817014366713.74382168200813.151531916.486506933315.729572866712.93233586679200913.457715433316.639237833318.260179966712.653159433310201013.194548516.728688915.426352666713.883358311201114.347794166716.689421033314.176580433312.366541966712201213.605086717.130567733314.717967766713.292552433313201313.027907866717.386193433316.203454966713.186121333314201412.746681633316.544286866714.736768212.870651246715201513.46590416.506123166712.442436633311.018138416seasonspringsummerautumnwinter17slope0.037969137402-0.0116468916667-0.0791384411275-0.0776527455294In [3]:dataOut[3]:datespringsummerautumnwinter0200012.233880916.907301133315.692383133314.08596223331200112.847480566716.750468733314.514066366713.50374562200213.55817517.203392615.699947513.23365246673200312.654724716.894915333315.661464712.84347866674200413.253729817.046966566715.209053766714.36479125200513.444304916.745982216.622187966711.61082256676200613.505695666716.833578566715.497928212.19934363337200713.488526233316.667732833315.817014366713.74382168200813.151531916.486506933315.729572866712.93233586679200913.457715433316.639237833318.260179966712.653159433310201013.194548516.728688915.426352666713.883358311201114.347794166716.689421033314.176580433312.366541966712201213.605086717.130567733314.717967766713.292552433313201313.027907866717.386193433316.203454966713.186121333314201412.746681633316.544286866714.736768212.870651246715201513.46590416.506123166712.442436633311.0181384如果=True则原有数据块的相应行被删除
In [4]:odata.drop(odata.index[[16,17]],inplace=True)odataOut[4]:datespringsummerautumnwinter0200012.233880916.907301133315.692383133314.08596223331200112.847480566716.750468733314.514066366713.50374562200213.55817517.203392615.699947513.23365246673200312.654724716.894915333315.661464712.84347866674200413.253729817.046966566715.209053766714.36479125200513.444304916.745982216.622187966711.61082256676200613.505695666716.833578566715.497928212.19934363337200713.488526233316.667732833315.817014366713.74382168200813.151531916.486506933315.729572866712.93233586679200913.457715433316.639237833318.260179966712.653159433310201013.194548516.728688915.426352666713.883358311201114.347794166716.689421033314.176580433312.366541966712201213.605086717.130567733314.717967766713.292552433313201313.027907866717.386193433316.203454966713.186121333314201412.746681633316.544286866714.736768212.870651246715201513.46590416.506123166712.442436633311.0181384删除列
del方法
In [5]:del odata['date']odataOut[5]:springsummerautumnwinter012.233880916.907301133315.692383133314.0859622333112.847480566716.750468733314.514066366713.5037456213.55817517.203392615.699947513.2336524667312.654724716.894915333315.661464712.8434786667413.253729817.046966566715.209053766714.3647912513.444304916.745982216.622187966711.6108225667613.505695666716.833578566715.497928212.1993436333713.488526233316.667732833315.817014366713.7438216813.151531916.486506933315.729572866712.9323358667913.457715433316.639237833318.260179966712.65315943331013.194548516.728688915.426352666713.88335831114.347794166716.689421033314.176580433312.36654196671213.605086717.130567733314.717967766713.29255243331313.027907866717.386193433316.203454966713.18612133331412.746681633316.544286866714.736768212.87065124671513.46590416.506123166712.442436633311.0181384.pop()方法
.pop方法可以将所选列从原数据块中弹出，原数据块不再保留该列
In [6]:spring = odata.pop('spring')springOut[6]:012.2338809112.8474805667213.558175312.6547247413.2537298513.4443049613.5056956667713.4885262333813.1515319913.45771543331013.19454851114.34779416671213.60508671313.02790786671412.74668163331513.465904Name: spring, dtype: objectIn [7]:odataOut[7]:summerautumnwinter016.907301133315.692383133314.0859622333116.750468733314.514066366713.5037456217.203392615.699947513.2336524667316.894915333315.661464712.8434786667417.046966566715.209053766714.3647912516.745982216.622187966711.6108225667616.833578566715.497928212.1993436333716.667732833315.817014366713.7438216816.486506933315.729572866712.9323358667916.639237833318.260179966712.65315943331016.728688915.426352666713.88335831116.689421033314.176580433312.36654196671217.130567733314.717967766713.29255243331317.386193433316.203454966713.18612133331416.544286866714.736768212.87065124671516.506123166712.442436633311.0181384.drop()方法
drop方法既可以保留原数据块中的所选列，也可以删除，这取决于参数
In [8]:withoutSummer = odata.drop(['summer'],axis=1)withoutSummerOut[8]:autumnwinter015.692383133314.0859622333114.514066366713.5037456215.699947513.2336524667315.661464712.8434786667415.209053766714.3647912516.622187966711.6108225667615.497928212.1993436333715.817014366713.7438216815.729572866712.9323358667918.260179966712.65315943331015.426352666713.88335831114.176580433312.36654196671214.717967766713.29255243331316.203454966713.18612133331414.736768212.87065124671512.442436633311.0181384In [9]:odataOut[9]:summerautumnwinter016.907301133315.692383133314.0859622333116.750468733314.514066366713.5037456217.203392615.699947513.2336524667316.894915333315.661464712.8434786667417.046966566715.209053766714.3647912516.745982216.622187966711.6108225667616.833578566715.497928212.1993436333716.667732833315.817014366713.7438216816.486506933315.729572866712.9323358667916.639237833318.260179966712.65315943331016.728688915.426352666713.88335831116.689421033314.176580433312.36654196671217.130567733314.717967766713.29255243331317.386193433316.203454966713.18612133331416.544286866714.736768212.87065124671516.506123166712.442436633311.0181384当=True时.drop()执行内部删除，不返回任何值，原数据发生改变
In [10]:withoutWinter = odata.drop(['winter'],axis=1,inplace=True)type(withoutWinter)Out[10]:NoneTypeIn [11]:odataOut[11]:summerautumne016.907301133315.6923831333116.750468733314.5140663667217.203392615.6999475316.894915333315.6614647417.046966566715.2090537667516.745982216.6221879667616.833578566715.4979282716.667732833315.8170143667816.486506933315.7295728667916.639237833318.26017996671016.728688915.42635266671116.689421033314.17658043331217.130567733314.71796776671317.386193433316.20345496671416.544286866714.73676821516.506123166712.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 pdimport 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 行，默认为 5df.tail(n)-------- 查看后 n 行，默认为 5df.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列的数据为1002、缺省值的检测与处理方式：（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值，则寻找更上一行数据，若所有行为空，那么还是nanuser_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）数学统计函数：
idxminidxmax找到最大值或者最小值的 索引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橘子 90tchl=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 方法，将迭代对象转化为DataFramegroupby_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'})【数据分析pandas库 一python进阶】
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'])ABCsum12.015.018.0min1.02.03.0Different aggregations per column.df.agg({'A' : ['sum', 'min'], 'B' : ['min', 'max']})ABmaxNaN8.0min1.02.0sum12.0NaNAggregate over the columns.df.agg("mean", axis="columns")02.015.028.03NaNdtype: float64- DBMS MySQL 数据库安装教程图文详解
- Day.js :一个只有2KB的处理时间和日期的 JavaScript 库
- 何时使用基于CRDT的数据库
- 小波系数、小波方差、小波模、小波模平方 【数字信号分析】小波变换气象数据分析【
- 四 python数据分析新手入门课程学习——探索性数据分析（多因子）（来源：慕
- 当面试官问到：《MySQL数据库的锁机制》该如何拿分？
- “前浪”数据仓库和大数据平台，到“后浪”数据中台的演变史
- 数据库复习笔记----关系数据库
- 湖南大学数据库实验二
- 【Android -- 开源库】数据解析 Gson 的基本使用