数据准备：
加载
组装：
合并：pandas.mege()
拼接:pandas.concat()
组合:pandas.DataFrame.combine_first()
变形
删除
合并：
1.根据列合并
没有指定根据那一列合并
import numpy as np
import pandas as pd
frame1 = pd.DataFrame( {'id': ['ball','pencil','pen','mug','ashtray'],
'price':[12.33,11.44,33.21,13.23,33.62]})
frame2 = pd.DataFrame({'id':['pencil','pencil','ball','pen'],
'color':['white','red','red','black']})
pd.merge(frame1,frame2)
不指定索引合并为空：
#*-* coding=utf-8 *-*
import numpy as np
import pandas as pd
frame1 = pd.DataFrame({'id': ['ball','pencil','pen','mug','ashtray'],
'color':['white','red','red','black','green'],
'brand':['OMG','ABC','ABC','PDD','PDD'] })
frame2 = pd.DataFrame({'id':['pencil','pencil','ball','pen'],
'brand':['OMG','PDD','ABC','PDD']})
pd.merge(frame1,frame2)
指定索引合并：
pd.merge(frame1,frame2,on='id')
pd.merge(frame1,frame2,on='brand')
假如两个DataFrame基准列的名称不一致,该怎样进行合并呢?
可以用 left_on和right_on选项指定第一个和第二个DataFrame的基准列。
frame1.columns = ['brand','sid']
pd.merge(frame1,frame2,left_on='id',right_on='sid')
merge()函数默认执行的是内连接操作;上述结果中的键是由交叉操作得到的。
其他选项有左连接、右连接和外连接。
外连接把所有的键整合到一起,其效果相当于左连接和右连接的效果之和。连接类型用how选项指定。
frame2.columns = ['brand','id']
pd.merge(frame1,frame2,on='id',how='outer')
pd.merge(frame1,frame2,on='id',how='left')
pd.merge(frame1,frame2,on='id',how='right')
要合并多个键，可以把键以列表的形式赋值给on
pd.merge(frame1,frame2,on=['id','brand'],how='outer')
2.根据索引合并
有时,合并操作不是用DataFrame的列而是用索引作为键。把left_index和right_index选项
的值置为True,将其激活,就可将其作为合并DataFrame的基准。
pd.merge(frame1, frame2, right_index=True, left_index=True)
DataFrame对象的join函数更适合于根据索引进行合并。
还可以用它合并多个索引相同或索引相同但列却不一致的DataFrame对象(列名称不能重合，否则报错)
frame2.columns = ['brand2','id2']
frame1.join(frame2)
2.拼接：
NumPy的 concatenate()函数就是用于数组的拼接操作。
pandas库以及它的 Series和DataFrame等数据结构实现了带编号的轴,它可以进一步扩展数组
拼接功能。 pandas的concat()函数实现了按轴拼接的功能。
ser1 = pd.Series(np.random.rand(4),index=[1,2,3,4])
ser2 = pd.Series(np.random.rand(4),index=[5,6,7,8])
pd.concat([ser1,ser2])
concat()函数默认按照axis=0这条轴拼接数据,返回Series对象。如果指定axis=1,返回结果
将是 Dataframe对象。
pd.concat([ser1,ser2],axis=1)
结果中无重合数据,因而刚执行的其实是外连接操作。把join选项置为'inner',可执行内
连接操作。
pd.concat([ser1,ser2],axis=1,join='inner')(有问题)
假如你想在用于拼接的轴上创建等级索引,就需要借助keys选项来完成。
pd.concat([ser1,ser2],keys=[1,2])
按照axis=1拼接 Series对象,所指定的键变为拼接后得到的 Data Frame对象各列的名称。
pd.concat([ser1,ser2],axis=1，keys=[1,2])
DataFrame对象的拼接方法与之相同。
组合：
combine first(函数可以用来组合 Series对象,同时对齐数据。
ser1 = pd.Series(np.random.rand(5),index=[1,2,3,4,5])
ser2 = pd.Series(np.random.rand(4),index=[2,4,5,6])
ser1.combine_first(ser2)
ser2.combine_first(ser1)
如果你想进行部分合并,仅指定要合并的部分即可。
ser1[:3].combine_first(ser2[:3])
轴向旋转：
1.按等级索引旋转
轴向旋转有两个基础操作。
入栈( stacking):旋转数据结构,把列转换为行。
出栈( unstacking):把行转换为列。
对DataFrame对象应用stack()函数,会把列转换为行,从而得到一个Series对象
frame1 = pd.DataFrame(np.arange(9).reshape (3, 3),
index=['white', 'black','red',],
columns=['ball','pen', 'pencil'])
frame1.stack()
unstack()函数,可以重建之前的Dataframe对象,从而可以以数据透视表的形式来展示 Series对象中的等级索引结构。
ser = frame1.stack()
ser.unstack()
2.从“长”格式向“宽”格式旋转
pivot()函数,它以用作键的一列或多列作为参数。能够把长格式DataFrame转换为宽格式
删除：
frame1 = pd.DataFrame(np.arange(9).reshape (3, 3),
index=['white', 'black','red',],
columns=['ball','pen', 'pencil'])
删除一列
del frame1['ball']
删除多列：
frame1.drop('red')
3.数据转换
删除重复元素：
Data frame对象的duplicated()函数可用来检测重复的行,返回元素为布尔型的Series对象。
每个元素对应一行,如果该行与其他行重复(也就是说该行不是第一次出现),则元素为True;如果跟前面不重复,则元素就为 False。
dframe = pd.DataFrame({'color':['white','white','red','red','white'],
'value':[2,1,3,3,2]})
dframe.duplicated()
留下重复的行：
dframe[dframe.duplicated()]
删掉重复的行：
drop_duplicates()函数实现了删除功能,该函数返回的是删除重复行后的DataFrame对象。
dframe.drop_duplicates()
映射：
映射关系无非就是创建一个映射关系列表,把元素跟一个特定的标签或字符串绑定起来。最好的就是字典。
1.用映射替换元素
把映射关系字典的值替换：
frame = pd.DataFrame( {'id': ['ball','pencil','pen','mug','ashtray'],
'color':['white','rosso','verde','black','yellow'],
'price':[12.33,11.44,33.21,13.23,33.62]})
new = {
'rosso':'red',
'verde':'green'
}
frame.replace(new)
把NaN替换：
ser = pd.Series([1,3,np.nan,4,6,np.nan,3])
ser.replace(np.nan,0)
2.用映射添加元素
frame = pd.DataFrame({'id':['pencil','pencil','ball','pen'],
'brand':['OMG','PDD','ABC','PDD']})
price = {
'pencil':'12.33',
'pencil':'11.44',
'ball':'33.21',
'pen':'13.23',}
frame['price'] = frame['id'].map(price)
3.重命名轴索引
pandas的rename()函数,以表示映射关系的字典对象作为参数,替换轴的索引标签。
reindex = {
0:'first',
1:'second',
2:'third',
3:'fourth'}
frame.rename(reindex)
修改列：
recolumns = {id = 'object'}
frame.rename(index=reindex,columns=recolumns)
对于只有单个元素要替换的最简单情况,可以对传入的参数做进一步限定,而无需把多个变量都写出来,也避免产生多次赋值操作.
frame.rename(index={1:'first'},columns={'id':'object'})
rename()函数返回一个经过改动的新 Data frame对象,但原DataFrame对象仍保持不变。如果要改变调用函数的对象本身,可使用 inplace选项,并将其值置为True。
frame.rename(,columns={'id':'object'},inplace=True)
4.离散化和面元划分:
有时,要处理的大量数据为连续型的。为了便于分析它们,需要把数据打散为几个类别,例如把（仪器）读数的取值范围划分为一个个小区间,统计每个区间的元素数量或其他统计量。
另外一种情况是,对总体做出精确的测量,得到了大量个体。这种情况下,为了便于数据分析,也需要把元素分成几个类别,然后分别分析每个类别的个体数量及其他统计量。
已知实验数据的范围为0-100,因而我们可以把数据范围均分,比如分为四部分,也就是四个面元（bin）。第一个面元包含0-25的值,第二个为26~50,第三个为51~75,最后一个为76~100。
result = [22,45,78,46,87,8,44,45,16,76,18,34,19]
用pandas划分面元之前,首先要定义一个数组,存储用于面元划分的各数值。
bins=[0,25,50,75,100]
然后,对results数组应用cut()函数,同时传入bins变量作为参数。
cat= pd.cut(results, bins)
cut()函数返回的对象为Categorical1（类别型）类型,可以将其看作一个字符串数组,其元素为面元的名称。该对象内部的levels数组为不同内部类别的名称,labels数组的元素数量跟results数组（也就是说,划分成各面元的数组）相同,labels数组的各数字表示results元素所属的面元。
cat.levels(没有)
cat.labels
若想指定每个面元的出现次数,即每个类别有多少个元素,可使用value_counts()函数
pd.value_counts(cat)
可以用字符串数组指定面元的名称,把它赋给cut()函数的1abels选项,然后用该函数创建categorical对象。
bin_names =['unlikely', 'less likely, 'likely','highly likely']
cat= pd.cut(results, bins,labels=bin_names)
若不指定面元的各界限,而只传入一个整数作为参数,cut()函数就会按照指定的数字,把数组元素的取值范围划分为相应的几部分。
cat= pd.cut(results, 5)
qcut():这个函数直接把样本分成五个面元。用cut()函数划分得到的面元,每个面元的个体数量不同,具体跟数据样例的分布相关。
而qcut()函数能够保证每个面元的个体数相同,但每个面元的区间大小不等。
qcat = pd.qcut(results, 5)
异常值检测和过滤
randfrmme = pd.DataFrame(np.random.rand(1000,3))
describe()函数查看每一列的描述性统计量
randfrmme.describe()
std()函数就可以求得 Data Frame对象每一列的标准差。
5.排序：
numpy. random. permutation()函数排序：
用permutation()函数创建一个包含04(顺序随机)这五个整数的数组。将按照这个数
组元素的顺序为Dataframe对象的行排序。
对 Data frame对象的所有行应用take()函数,把新的次序传给它。
nframe = pd.DataFrame(np.arange(25).reshape(5,5))
new_order = np.random.permutation(5)
nframe.take(new_order)
还可以只对DataFrame对象的一部分进行排序操作。它将生成一个数组,只包含特定索引范围的数据
new_order = [4,3,2]
nframe.take(new_order)
随机取样:
sample = np.random.randint(0,len(nframe),size=3)
nframe.take(sample)
6.字符串处理：
1.内置的字符串处理方法：
split()
strip()
join()
index()
find()
count()
replace()
2.正则
7.数据聚合：
1.GroupBy:
Group By过程及其工作原理。
Group By通常指的是它的内部机制SPLIT-APPLY-COMBⅠNE（分组-用函数处理合并结果）过程。它的操作模式由三个阶段组成,每个阶段可以用一种操作来准确地表示。
1.分组:将数据集分成多个组
2.用函数处理:用函数处理每一组
3.合并:把不同组得到的结果合并起来
分组阶段,根据给定标准,把Series或 Data Frame等数据结构中的数据分为几个不同的组,分组标准常与索引或某一列具体的元素相关。用SQL的行话来说,作为分组标准的这一列被称作键。进一步来说,如果你处理的是Dataframe等二维对象,分组标准可以既应用于行(axis=0),也应用于列(axis=1)。
第二个阶段也称作“用函数处理”,使用函数处理或者执行由函数定义的计算,为每组数据生成单一的值。
最后一步为合并,把来自每一组的结果汇集到一起,合并成一个新对象。
2.实例：
groupby()函数
frame = pd.DataFrame({'color':['white','red', 'green','red','green'],
'object':['pen','pencil','pencil','pen','pen'],
'price1':[5.56,4.20,1.30,0.56,2.75],
'price2':[4.75,4.12,1.60,0.75,3.15]})
使用 color列的组标签,计算price列的均值,方法有多种。例如,可以先获取到price1列,然后再调用groupby()函数,用参数指定 color这一列。
group= frame['price1'].groupby( frame['color'])
刚执行的操作其实没有进行任何计算,它只是把计算需要的所有信息放到了一起。你刚进行的操作其实就是分组操作,把含有相同颜色的行分到同一个组里。
GroupBy对象的 groups属性,我们来详细看一下 DataFrame各行的分组情况。
group.groups
group.mean()
group.sum()
3.等级分组
还可以用多列,也就是使用多个键,按照等级关系分组。
ggroup= frame['price1'].groupby([frame['color'],frame['object']])
ggroup.groups
ggroup.sum()
可以按照多列数据或整个Dataframe把数据分为几组。如果不想重复多次使用GroupBy对象,最方便的方法是一次就把所有的分组依据和计算方法都指定好,而无需定义任何中间变量。
group= frame[['price1','price2']].groupby( frame['color']).mean()
frame.groupby(frame['color']).mean()
8.组迭代
GroupBy对象还支持迭代操作,它可以生成一系列由各组名称及其数据部分组成的元组。
for name,group in frame.groupby('color'):
print(name)
print(group)
1.链式转换
用函数进行计算或执行其他操作时,不管各组是怎么得到的以及选取标准是什么,最终结果不是 Series(如果只选择一列数据)就是Dataframe数据结构,它们保留了索引系统和列名称。
frame['price1'].groupby( frame['color']).mean()
frame.groupby(frame['color'])['price1'].mean()
(frame.groupby(frame['color']).mean()).['price1']
此外,执行聚合操作后,某些列的名称可能存在表意不明确的现象。这时,在列名称前加上描述操作类型的前缀很有用。注意,添加前缀而不是完全替换名称,这样可以便于跟踪聚合数据的源数据。如果你采用的是链式转换过程（DataFrame之间存在生成关系）,而又需要保留和源数据的对应关系,就可以使用这种方法。
frame.groupby(frame['color']).mean().add_prefix('mean_')
2.分组函数
quantile()函数计算分位数。
group = frame.groupby('color')
group['price'].quantile(0.6)
还可以自定义聚合函数。定义好函数后,将其作为参数传给agg()函数
def range(series):
return series.max() - serise.min()
group['price1'].agg(range)
可以对整个DataFrame对象应用agg()函数。
group.agg(range)
还可以同时使用多个聚合函数,把存放有表示聚合操作类型的数组传给agg()函数
group['price1']agg(['mean', 'std', 'range'])
9.高级数据聚合
transform()和apply()函数,它们可以用来执行多种甚至是非常复杂的组操作。
frame= pd.DataFrame({'color': ['white','red','green','red','green']
'price1':[5.56,4.20,1.30,0.56,2.75],
'price2':[4.75,4.12,1.60,0.75,3.15]})
sums = frame.groupby('color').sum().add_prefix('tot_')
merge(frame,sums,left_on='color',right_index=True)
可以用merge()函数把聚合操作的计算结果添加到Dataframe对象的每一行。实际上,你也可以用transform()方法实现这种操作。该函数执行聚合操作的方式跟前面讲过的相同,但它还可
以根据 DataFrame对象每一行的关键字显示聚合结果。
sums = frame.groupby('color').transfrom(np.sum).add_prefix('tot_')
appy()函数则适用于执行更为一般的GroupBy操作。这个方法完全实现了SPLIT-APPLY-COMBINE机制。它把对象分为几部分后,再用函数处理每一部分,各步骤之间用链式方法连接在一起
frame= DataFrame({'color': ['white', 'black', 'white', 'white', 'black', 'black',]
'status': ['up','up','down','down','down','up'],
'value1':[12.33,14,55,22,34,27.84,23.40,18,33],
'value2':[11.23,31,80,29.99,31,18,18.25,22,44]})
frame.groupby(['color','status']).apply(lambda x: x.max())
frame.rename(index=reindex, columns=recolumn)
temp=date_range(1/1/2015, periods=10, freq= 'H')
timeseries= Series(np.random.rand(10),index=temp)
imetable= DataFrame({'date': temp,'value1':np.random.rand(10),
'value2': np.random.rand(10)})
timetable['cat']=['up','down','left','left','up','up','down','right','right','up']