python数据处理工具-Pandas笔记

序列与数据框的构造

Pandas模块的核心操作对象就是序列Series和数据框DataFrame序列可以理解为数据集中的一个字段数据框是指含有至少两个字段(或序列)的数据集。

构造序列

可以通过以下几种方式构造：
①通过同质的列表或元组构建
②通过字典构建
③通过Numpy中的一维数组构建
④通过数据框DataFrame中的某一列构建

import numpy as np
import pandas as pd
a1=pd.Series([1,3,5,7])#通过列表创建
a2=pd.Series((1,4,5,9))#通过元组构建
print(a1,'\n',a2)
result
0    1
1    3
2    5
3    7
dtype: int64 0    1
1    4
2    5
3    9
dtype: int64

a3=pd.Series({'A':1,'B':3,'C':5,'D':7})#通过字典创建
print(a3)
#result
A    1
B    3
C    5
D    7

import numpy as np
import pandas as pd
a1=pd.Series([1,3,5,7])
a2=pd.Series((1,4,5,9))
a3=pd.Series({'A':1,'B':3,'C':5,'D':7})#通过字典创建
print(a1[[0,1]])
print(a3[[0,1]])
print(a3[['A','B']])
#result
0    1
1    3
dtype: int64
A    1
B    3
dtype: int64
A    1
B    3
dtype: int64

构造数据框

构造数据框可以采用以下几种方式：
①通过嵌套的列表或者元组构造
②通过字典构造
③通过二维数组构造
④通过外部数据的读取构造

import numpy as np
import pandas as pd
df1=pd.DataFrame([['a',59,False],['b',61,True],['c',90,True]])#通过列表嵌套
df2=pd.DataFrame([('a',59,False),('b',61,True),('c',90,True)])#通过元组嵌套
df3=pd.DataFrame({'代号':['a','b','c'],'分数':[59,61,90],'是否及格':[False,True,True]})#通过字典构造
df4=pd.DataFrame(np.array([['a',59,False],['b',61,True],['c',90,True]]))#通过二维数组构造
print(df1)
print(df2)
print(df3)
print(df4)
#result0   1      2
0  a  59  False
1  b  61   True
2  c  90   True0   1      2
0  a  59  False
1  b  61   True
2  c  90   True代号  分数   是否及格
0  a  59  False
1  b  61   True
2  c  90   True0   1      2
0  a  59  False
1  b  61   True
2  c  90   True

文本文件读取

使用Pandas模块中的read_table函数或者read_csv函数

在这里插入代码片

电子表格Excel的读取

child_cloth = pd.read_excel(io = r'C:\原U盘\交大\python可视化\第5章 Python数据处理工具--Pandas\第5章 Python数据处理工具--Pandas\data_test02.xlsx', header = None,names = ['Prod_Id','Prod_Name','Prod_Color','Prod_Price'], converters = {0:str})
```pythonProd_Id Prod_Name Prod_Color  Prod_Price
0   00101       儿童裤         黑色         109
1   01123      儿童上衣         红色         229
2   01010       儿童鞋         蓝色         199
3   00100      儿童内衣         灰色         159

数据类型转换及描述统计

读取数据并预览
sec_cars=pd.read_table(r'C:\原U盘\交大\python可视化\第5章 Python数据处理工具--Pandas\第5章 Python数据处理工具--Pandas\sec_cars.csv',sep=',')
print(sec_cars.head())#sec_cars.head()可以实现预览前五行,tail可以看数据的末尾5行信息
print('看下数据的结构：\n',sec_cars.shape)
print('看下数据的类型：\n',sec_cars.dtypes)
resultBrand                        Name  ... Sec_price  New_price
0    众泰    众泰T600 2016款 1.5T 手动 豪华型  ...       6.8      9.42万
1    众泰    众泰Z700 2016款 1.8T 手动 典雅型  ...       8.8     11.92万
2    众泰      大迈X5 2015款 1.5T 手动 豪华型  ...       5.8      8.56万
3    众泰  众泰T600 2017款 1.5T 手动 精英贺岁版  ...       6.2      8.66万
4    众泰    众泰T600 2016款 1.5T 手动 旗舰型  ...       7.0     11.59万
看下数据的结构：(11125, 7)
看下数据的类型：Brand             object
Name              object
Boarding_time     object
Km(W)            float64
Discharge         object
Sec_price        float64
New_price         object
dtype: object

从上面可以看到数据Boarding_time的数据类型不是日期型，并且New_price的类型不是浮点型，需要进行转换

sec_cars.Boarding_time=pd.to_datetime(sec_cars.Boarding_time,format='%Y年%m月')
sec_cars.New_price=sec_cars.New_price.str[:-1].astype('float')#首先通过str方法将该字段转换成字符串，然后通过切片手段，将”万“字剔除，最后运用astype方法，实现数据类型的转换（但是运行起来有误，不知道问题出在哪里）

数值型数据的描述统计

print(sec_cars.describe())Km(W)     Sec_price
count  11125.000000  11125.000000
mean       6.279603     25.671780
std        3.479047     52.797762
min        0.020000      0.650000
25%        4.000000      5.200000
50%        6.000000     10.000000
75%        8.200000     23.800000
max       34.600000    808.000000

离散型数据的统计描述

print(sec_cars.describe(include=['object']))Brand                        Name Discharge New_price
count   11125                       11125     11125     11125
unique    104                        4462        34      1659
top        别克  经典全顺 2010款 柴油 短轴 多功能 中顶 6座        国4        暂无
freq     1347                         126      4296       141

字符和日期数据的处理

完成以下任务：
①更改出生日期birthday和手机号tel两个字段的数据类型

df=pd.read_excel(r'C:\原U盘\交大\python可视化\第5章 Python数据处理工具--Pandas\第5章 Python数据处理工具--Pandas\data_test03.xlsx')
df.birthday=pd.to_datetime(df.birthday,format='%Y/%m/%d')
df.tel=df.tel.astype('str')
print(df.dtypes)
#result
name                  object
gender                object
birthday      datetime64[ns]
start_work    datetime64[ns]
income                 int64
tel                   object
email                 object
other                 object
dtype: object

②根据出生日期birthday和开始日期start_work两个字段新增年龄和工龄两个字段

df['age']=pd.datetime.today().year - df.birthday.dt.year
df['workage']=pd.datetime.today().year - df.start_work.dt.year

③将手机号tel的中间四位隐藏起来

df.tel=df.tel.apply(lambda x:x.replace(x[3:7],'****'))#
#lambda 参数 ：表达式
#lambda函数是匿名的，函数没有名字.lambda具有输入输出，参数就是其输入，供表达式使用，表达式结果为函数的返回结果，即输出。所以使用lambda不需要在表达式中进行返回操作，函数自动将表达式结果返回
# DataFrame.apply(func, axis=0, broadcast=False, raw=False, reduce=None, args=(), **kwds)
# DataFrame.apply()函数会遍历每一个元素，对元素运行指定的 function
print(df.head())name gender   birthday  ...          tel            email                  other
0   赵一      男  1989/8/10  ...  136****1234    zhaoyi@qq.com  {教育：本科，专业：电子商务，爱好：运动}
1   王二      男  1990/10/2  ...  135****2234   wanger@163.com      {教育：大专，专业：汽修，爱好：}
2   张三      女  1987/3/12  ...  135****3330  zhangsan@qq.com   {教育：本科，专业：数学，爱好：打篮球}
3   李四      女  1991/8/16  ...  139****3388   lisi@gmail.com   {教育：硕士，专业：统计学，爱好：唱歌}
4   刘五      女  1992/5/24  ...  178****7890     liuwu@qq.com      {教育：本科，专业：美术，爱好：}

④根据邮箱信息新增邮箱域名字段

df['email_domain']=df.email.apply(lambda x:x.split('@')[1])
#split()可以把一个字符串按照指定的分隔符切分为字符串列表。
#str.split(sep,maxsplit) 其中str表示进行分割的分隔符，sep表示指定分隔符，默认为None,maxsplit表示指定的分割次数，由于返回值是分隔后的字符串列表，所以可以用索引[]
resultname gender   birthday  ...            email                  other email_domain
0   赵一      男  1989/8/10  ...    zhaoyi@qq.com  {教育：本科，专业：电子商务，爱好：运动}       qq.com
1   王二      男  1990/10/2  ...   wanger@163.com      {教育：大专，专业：汽修，爱好：}      163.com
2   张三      女  1987/3/12  ...  zhangsan@qq.com   {教育：本科，专业：数学，爱好：打篮球}       qq.com
3   李四      女  1991/8/16  ...   lisi@gmail.com   {教育：硕士，专业：统计学，爱好：唱歌}    gmail.com
4   刘五      女  1992/5/24  ...     liuwu@qq.com      {教育：本科，专业：美术，爱好：}       qq.com

⑤基于order字段取出每个人员的专业信息

df['profession']=df.other.str.findall('专业：(.*?),')#从other变量中获取人员的专业信息，该问题的解决使用了字符串的正则表达式，不管是字符串‘方法’还是字符串正则，使用前都需要对变量使用一次str方法

⑥删除birthday、start_work、和other变量

df.drop(['birthday','start_work','other'],axis=1,inplace=True)#需要删除数据集中的某些变量，可以使用数据框的drop方法，该方法的第一个参数就是被删除的变量列表，要注意的是，需要将axis参数设置为1，因为默认的drop方法是用来删除数据框中的行记录的。
print(df.head())
resultname gender  income          tel            email email_domain
0   赵一      男   15000  136****1234    zhaoyi@qq.com       qq.com
1   王二      男   12500  135****2234   wanger@163.com      163.com
2   张三      女   18500  135****3330  zhangsan@qq.com       qq.com
3   李四      女   13000  139****3388   lisi@gmail.com    gmail.com
4   刘五      女    8500  178****7890     liuwu@qq.com       qq.com

数据清洗方法

重复观测处理

重复观测就是指行重复的现象

df=pd.read_excel(r'C:\原U盘\交大\python可视化\第5章 Python数据处理工具--Pandas\第5章 Python数据处理工具--Pandas\data_test04.xlsx')
print('分别检验每行是否存在重复的数据：\n',df.duplicated())检测数据集记录是否存在重复，使用duplicated方法，该方法返回的是数据集每一行的检测结果，即10行会返回10个bool值。但是为了得到最直观的结果，使用方法any函数，其表示的是在多个条件判断中，只要有一个为True，则结果就为True
#np.array.any()是或操作，任意一个元素为True，输出为True。
#np.array.all()是与操作，所有元素为True，输出为True。
print('检验是否存在重复的数据：\n',any(df.duplicated()))
#result
分别检验每行是否存在重复的数据：0    False
1    False
2    False
3     True
4    False
5    False
6    False
7    False
8     True
9     True
dtype: bool
检验是否存在重复的数据：True

删除重复项

df.drop_duplicates(inplace=True)
#去除完全重复的行数据：data.drop_duplicates(inplace=True)
#去除某几列重复的行数据：data.drop_duplicates(subset=['A','B'],keep='first',inplace=True)
#subset： 列名，可选，默认为None
#keep： {‘first’, ‘last’, False}, 默认值 ‘first’。first： 保留第一次出现的重复行，删除后面的重复行。last:删除重复项，除了最后一次出现.False： 删除所有重复项。
#inplace:布尔值，默认为False，是否直接在原数据上删除重复项或删除重复项后返回副本。（inplace=True表示直接在原来的DataFrame上删除重复项，而默认值False表示生成一个副本。）

缺失值处理

处理方法一般有3种：删除法，替换法，插补法。删除法一般是观测比例缺失在5%以下时删除观测行，某变量缺失比例非常高时删除缺失变量。替换法一般是用指定的数来替换，连续变量一般使用均值或者中位数来替换，离散变量可以使用众数来替换。插补法一般使用其他非缺失变量或观测来预测缺失值，一般会用回归插补法、K近邻插补法、拉格朗日插补法。

删除法

df=pd.read_excel(r'C:\原U盘\交大\python可视化\第5章 Python数据处理工具--Pandas\第5章 Python数据处理工具--Pandas\data_test05.xlsx')
print('查看是否有缺失观测值：\n',df.isnull())
print('查看是否有缺失观测值：\n',any(df.isnull()))#同样的，使用any函数只返回一个
result
查看是否有缺失观测值：uid  regit_date  gender    age  income
0  False       False   False  False   False
1  False       False   False  False   False
2  False       False   False   True   False
3  False       False   False  False   False
4  False       False    True   True   False
5  False       False   False  False    True
6  False       False   False  False   False
7  False       False   False   True   False
8  False       False   False  False   False
9  False       False   False  False    True
查看是否有缺失观测值：True

python dropna()用法

DataFrame.dropna(axis=0,how=’any’,thresh=None,subset=None,inplace=False)
axis: 默认axis=0。0为按行删除,1为按列删除
how: 默认 ‘any’。 ‘any’指带缺失值的所有行/列;'all’指清除一整行/列都是缺失值的行/列
thresh: int,保留含有int个非nan值的行
subset: 删除特定列中包含缺失值的行或列,
inplace: 默认False，即筛选后的数据存为副本,True表示直接在原数据上更改

记录删除

print(df)
print(df.dropna())dropna并没有设置inplace=True,所以返回来的是复制的删除的结果，并没有改变df原来的数据集。
resultuid regit_date gender   age   income
0  81200457 2016-10-30      M  23.0   6500.0
1  81201135 2016-11-08      M  27.0  10300.0
2  80043782 2016-10-13      F   NaN  13500.0
3  84639281 2017-04-17      M  26.0   6000.0
4  73499801 2016-03-21    NaN   NaN   4500.0
5  72399510 2016-01-18      M  19.0      NaN
6  63881943 2015-10-07      M  21.0  10000.0
7  35442690 2015-04-10      F   NaN   5800.0
8  77638351 2016-07-12      M  25.0  18000.0
9  85200189 2017-05-18      M  22.0      NaNuid regit_date gender   age   income
0  81200457 2016-10-30      M  23.0   6500.0
1  81201135 2016-11-08      M  27.0  10300.0
3  84639281 2017-04-17      M  26.0   6000.0
6  63881943 2015-10-07      M  21.0  10000.0
8  77638351 2016-07-12      M  25.0  18000.0

变量删除

print(df.drop('age',axis=1))#删除多列还是使用数组[]，这里同样返回的是复制的，灭有真正删除原来数据集
resultuid regit_date gender   income
0  81200457 2016-10-30      M   6500.0
1  81201135 2016-11-08      M  10300.0
2  80043782 2016-10-13      F  13500.0
3  84639281 2017-04-17      M   6000.0
4  73499801 2016-03-21    NaN   4500.0
5  72399510 2016-01-18      M      NaN
6  63881943 2015-10-07      M  10000.0
7  35442690 2015-04-10      F   5800.0
8  77638351 2016-07-12      M  18000.0
9  85200189 2017-05-18      M      NaN

替换法

DataFrame.fillna(self, value=None, method=None, axis=None, inplace=False, limit=None, downcast=None, **kwargs)
value:被填充的数据，scalar、dict、Series、DataFrame
method:pad/ffill：用前一个非缺失值去填充该缺失值;backfill/bfill：用下一个非缺失值填充该缺失值;None：指定一个值去替换缺失值（缺省默认这种方式）
inplace：True、False,True为直接修改原对象，False为修改复制的东西，默认是False。
limit参数：限制填充个数
axis:决定修改方向,0表示横向，1表示纵向

#使用method
print(df.fillna(method='ffill'))
resultuid regit_date gender   age   income
0  81200457 2016-10-30      M  23.0   6500.0
1  81201135 2016-11-08      M  27.0  10300.0
2  80043782 2016-10-13      F  27.0  13500.0
3  84639281 2017-04-17      M  26.0   6000.0
4  73499801 2016-03-21      M  26.0   4500.0
5  72399510 2016-01-18      M  19.0   4500.0
6  63881943 2015-10-07      M  21.0  10000.0
7  35442690 2015-04-10      F  21.0   5800.0
8  77638351 2016-07-12      M  25.0  18000.0
9  85200189 2017-05-18      M  22.0  18000.0

print(df.fillna(value={'gender':df.gender.mode()[0],'age':df.age.mean(),'income':df.income.median()}))
#这里mode()表示众数，如果众数不只一个，则使用列表中的第一个，即mode()[0]；mean()表示平均数；median（）表示中位数；
resultuid regit_date gender        age   income
0  81200457 2016-10-30      M  23.000000   6500.0
1  81201135 2016-11-08      M  27.000000  10300.0
2  80043782 2016-10-13      F  23.285714  13500.0
3  84639281 2017-04-17      M  26.000000   6000.0
4  73499801 2016-03-21      M  23.285714   4500.0
5  72399510 2016-01-18      M  19.000000   8250.0
6  63881943 2015-10-07      M  21.000000  10000.0
7  35442690 2015-04-10      F  23.285714   5800.0
8  77638351 2016-07-12      M  25.000000  18000.0
9  85200189 2017-05-18      M  22.000000   8250.0

异常值处理
异常值的检测一般是n个标准差法，适用于数据近似服从正态分布，因为数据分布相对对称，另一种是箱线图判别法，不适用正态分布的时候选用，因为分位数不会受到极端值的影响。
标准差法

sunspots=pd.read_table(r'C:\原U盘\交大\python可视化\第5章 Python数据处理工具--Pandas\第5章 Python数据处理工具--Pandas\sunspots.csv',sep=',')
xbar=sunspots.counts.mean()
xstd=sunspots.counts.std()
# print(sunspots.head())
print('标准差法异常值上限检验：\n',any(sunspots.counts>xbar+2*xstd))
print('标准差法异常值下限检验：\n',any(sunspots.counts<xbar+2*xstd))
result
标准差法异常值上限检验：True
标准差法异常值下限检验：False

箱线检测法

Q1=sunspots.counts.quantile(q=0.25)
Q3=sunspots.counts.quantile(q=0.75)
IQR=Q3-Q1
#quantile是四分位函数，即把数值由小到大排列并分成四等份，处于三个分割点位置的数值就是四分位数，
# (Q1)，又称“较小四分位数”，等于该样本中所有数值由小到大排列后第25%的数字；
# (Q2)，又称“中位数”，等于该样本中所有数值由小到大排列后第50%的数字。
# (Q3)，又称“较大四分位数”，等于该样本中所有数值由小到大排列后第75%的数字。
# IQR，第3四分位数与第1四分位数的差距又称四分位距，即Q3-Q1
print('箱线图法异常值上限检测：\n',any(sunspots.counts>Q3+1.5*IQR))
print('箱线图法异常值上限检测：\n',any(sunspots.counts<Q3-1.5*IQR))

通过以上两种方法可以判定异常值都是超过上限临界值的，则要通过绘制直方图和核密度曲线图用于检测数据是否服从正太分布，再来选择最终的异常值判别方法。
画图

import matplotlib.pyplot as plt
plt.style.use('ggplot')
sunspots.counts.plot(kind='hist',bins=30,normed=True)
sunspots.counts.plot(kind='kde')
plt.show()
#matplotlib.pyplot是使matplotlib像MATLAB一样工作的命令样式函数的集合。每个pyplot功能都会对图形进行一些更改：例如，创建图形，在图形中创建绘图区域，在绘图区域中绘制一些线条，用标签装饰绘图等。
#利用matplotlib绘图设置背景，使用到plt.style.use(),类似的可以设置'bmh','classic'

绘图如下：

从图形来看，由于数据分布形状都是有偏的，并且属于右偏，则需要使用箱线图法来判定异常值，并且使用删除法或者替换法来处理异常值。

#替换法
print('异常值替换前的数据统计特征：\n',sunspots.counts.describe())
UL=Q3+1.5*IQR#找出箱线图中异常值的判别上限
replace_value=sunspots.counts[sunspots.counts<UL].max()#找出作为替换的值
sunspots.counts[sunspots.counts>UL]=replace_value#进行替换
print('异常值替换后的数据统计特征：\n',sunspots.counts.describe())
result
异常值替换前的数据统计特征：count    289.000000
mean      48.613495
std       39.474103
min        0.000000
25%       15.600000
50%       39.000000
75%       68.900000
max      190.200000
Name: counts, dtype: float64
异常值替换后的数据统计特征：count    289.000000
mean      48.066090
std       37.918895
min        0.000000
25%       15.600000
50%       39.000000
75%       68.900000
max      141.700000
Name: counts, dtype: float64

数据子集的获取

Pandas模块种实现数据框子集的获取可以使用iloc、loc、ix三种方法。一般语法表示成iloc[rows_select,cols_select]
iloc:只能通过行号和列号进行数据的筛选，即只能向[rows_select,col_select]指定整数列表，索引方式与数组索引方式类似，从0开始，左闭右开。
loc:可以向[rows_select,col_select]指定具体的行标签和列标签，同时，可以对rows_select指定为具体的筛选条件。
ix:是iloc和loc的混合，可以同时接受变量名和字段的数值索引。

df1 = pd.DataFrame({'name':['张三','李四','王二','丁一','李五'],'gender':['男','女','女','女','男'],'age':[23,26,22,25,27]})
print(df1)
print('iloc使用序列进行挑选:\n',df1.iloc[[1,2,3],[0,2]])
print('loc使用标签进行挑选:\n',df1.loc[[1,2,3],['name','age']])
print('ix使用序列进行挑选:\n',df1.ix[1:3,[0,2]])
resultname gender  age
0   张三      男   23
1   李四      女   26
2   王二      女   22
3   丁一      女   25
4   李五      男   27
iloc使用序列进行挑选:name  age
1   李四   26
2   王二   22
3   丁一   25
loc使用标签进行挑选:name  age
1   李四   26
2   王二   22
3   丁一   25

实际中，一般都是对某些列作条件筛选获取目标数据。

#返回所有男性的姓名和年龄，这里不能使用iloc是因为这个方法没法筛选
print(df1.loc[df1.gender=='男','age'])
print(df1.ix[df1.gender=='男','age'])
result
0    23
4    27

透视表功能

透视表功能函数pivot_table

pd.pivot_table(data,values=None,columns=None,aggfunc='mean',fill_value=None,margins=False,dropna=True,margins_name='All')
data:指定需要构造透视表的数据集
values:指定需要拉入 数值 框的字段列表
index：指定需要拉入 行标签 框的字段列表
columns:指定需要拉入 列标签 框的字段列表
aggfunc:指定数值的统计函数，默认为统计均值，也可以指定numpy模块中的其他统计函数
fill_value：指定一个标量，用于填充缺失值
margins：bool类型参数，是否需要显示行或列的总计值，默认为False
dropna:bool类型参数，是否需要删除整列为缺失的字段，默认为True
margins_name:指定行或列的总计名称，默认为All单个分组变量的均值统计
```python
diamonds=pd.read_table(r'C:\原U盘\交大\python可视化\第5章 Python数据处理工具--Pandas\第5章 Python数据处理工具--Pandas\diamonds.csv',sep=',')
analy1=pd.pivot_table(data=diamonds,index='color',values='price',margins=True,margins_name='总计')
print(analy1)
resultprice
color
D      3169.954096
E      3076.752475
F      3724.886397
G      3999.135671
H      4486.669196
I      5091.874954
J      5323.818020
总计     3932.799722两个分组变量的列联表
analy2=pd.pivot_table(data=diamonds,index='clarity',columns='cut',values='carat',aggfunc=np.size,margins=True,margins_name='总计')#这里需要注意的是统计的是个数，即size，因此values的值可以是数据集中的任意一列，即也可以是depth、table等，但是如果统计的是平均数，那么求的就是value对应的平均数。
analy3=pd.pivot_table(data=diamonds,index='clarity',columns='cut',aggfunc='mean',values='carat',margins=True,margins_name='总计')
print('求个数：\n',analy2)
print('求均值：\n',analy3)
求个数：cut      Fair  Good  Ideal  Premium  Very Good     总计
clarity
I1        210    96    146      205         84    741
IF          9    71   1212      230        268   1790
SI1       408  1560   4282     3575       3240  13065
SI2       466  1081   2598     2949       2100   9194
VS1       170   648   3589     1989       1775   8171
VS2       261   978   5071     3357       2591  12258
VVS1       17   186   2047      616        789   3655
VVS2       69   286   2606      870       1235   5066
总计       1610  4906  21551    13791      12082  53940
求均值：cut          Fair      Good     Ideal   Premium  Very Good        总计
clarity
I1       1.361000  1.203021  1.222671  1.287024   1.281905  1.283846
IF       0.474444  0.616338  0.455041  0.603478   0.618769  0.505123
SI1      0.964632  0.830397  0.801808  0.908601   0.845978  0.850482
SI2      1.203841  1.035227  1.007925  1.144161   1.064338  1.077648
VS1      0.879824  0.757685  0.674714  0.793308   0.733307  0.727158
VS2      0.885249  0.850787  0.670566  0.833774   0.811181  0.763935
VVS1     0.664706  0.502312  0.495960  0.534821   0.494588  0.503321
VVS2     0.691594  0.614930  0.586213  0.654724   0.566389  0.596202
总计       1.046137  0.849185  0.702837  0.891955   0.806381  0.797940

表之间的合并与连接

合并函数：concat；连接函数：merge；

pd.concat(objs,axis=0,join='outer',join_axes=None,ignore_index=False,keys=None)
objs:指定需要合并的对象，可以是序列，数据框或面板构成的列表
axis:指定数据合并的轴，默认为0，表示合并多个数据的行，如果为1，就表示合并多个数据的列。
join：指定合并的方式，莫认为outer,表示合并所有数据，如果改为inner，表示合并公共部分的数据
join_axes：合并数据后，指定保留的数据轴
ignore_index：bool类型的参数，表示是否忽略原数据集的索引，默认为False,如果设为True，就表示忽略原索引并生成新索引。
keys:为合并后的数据添加新索引，用于区分各个数据部分

df1=pd.DataFrame({'name':['a,','b','c'],'age':[12,13,15],'gender':['男','女','男']})
df2=pd.DataFrame({'name':['x,','y'],'age':[17,13],'gender':['女','男']})
df3=pd.DataFrame({'Name':['x,','y'],'age':[17,13],'gender':['女','男']})
print('变量名称相同时：\n',pd.concat([df1,df2]))
print('变量名称不同时：\n',pd.concat([df1,df3]))
result
变量名称相同时：name  age gender
0   a,   12      男
1    b   13      女
2    c   15      男
0   x,   17      女
1    y   13      男
变量名称不同时：name  age gender Name
0   a,   12      男  NaN
1    b   13      女  NaN
2    c   15      男  NaN
0  NaN   17      女   x,
1  NaN   13      男    y

pd.merge(left,right,how='inner',on=None,left_on=None,right_on=None,left_index=False,right_index=False,sort=False,suffixes=('_x','_y'))
left:指定需要连接的主表
right：指定需要连接到的辅表
how：指定连接方式，莫认为inner连接，还有其他选项如左连接left,右连接right和外链接outer
on：指定连接两张表的共同字段
left_on:指定主表中需要连接的共同字段
right_on:指定辅表中需要连接的共同字段
left_index:bool类型参数，是否将主表中的行索引用作表连接的共同字段，默认为False
right_index:bool类型参数，是否将辅表中的行索引用作表连接的共同字段，默认为False
sort:bool类型参数，是否对连接后的数据按照共同字段排序，莫认为False
suffixes:如果数据连接的结果中存在重叠的变量名，使用各自的前缀进行区分
该函数缺点在于merge函数每次只能连接两个表。

df1=pd.DataFrame({'name':['a,','b','c'],'Age':[12,13,15],'gender':['男','女','男']})
df2=pd.DataFrame({'name':['x,','y'],'age':[17,13],'gender':['女','男']})
df3=pd.DataFrame({'Name':['x,','y'],'age':[17,13],'gender':['女','男']})
print('outer连接:\n',pd.merge(df1,df2,how='outer',left_on='Name',right_on='name',))
print('inner连接:\n',pd.merge(df1,df2,how='inner',left_on='Name',right_on='name',))
print('left连接:\n',pd.merge(df1,df2,how='left',left_on='Name',right_on='name',))
print('right连接:\n',pd.merge(df1,df2,how='right',left_on='Name',right_on='name',))
outer连接:Name   age gender name  light
0    a  12.0      男    a   21.0
1    b  13.0      女    b   14.0
2    c  15.0      男  NaN    NaN
3  NaN   NaN    NaN    x   17.0
4  NaN   NaN    NaN    y   13.0
inner连接:Name  age gender name  light
0    a   12      男    a     21
1    b   13      女    b     14
left连接:Name  age gender name  light
0    a   12      男    a   21.0
1    b   13      女    b   14.0
2    c   15      男  NaN    NaN
right连接:Name   age gender name  light
0  NaN   NaN    NaN    x     17
1  NaN   NaN    NaN    y     13
2    a  12.0      男    a     21
3    b  13.0      女    b     14
a1对应的outer连接，然后再把a1与df3 outer连接：
print('将a1与outer连接：\n',pd.merge(a1,df3,how='outer')),这里由于a1里面有name这个字段，df3里面也有这个字段，因此不用指定左边和右边的字段，系统会自动对应上
result
将a1与outer连接：Name   age gender name  light   户籍
0    a  12.0      男    a   21.0   山东
1    b  13.0      女    b   14.0  NaN
2    c  15.0      男  NaN    NaN  NaN
3  NaN   NaN    NaN    x   17.0   江苏
4  NaN   NaN    NaN    y   13.0   河南

分组聚合

groupby方法及aggregate方法
groupby函数主要的作用是进行数据的分组以及分组后的组内运算,
函数表达式：DataFrame.groupby([‘属性1’，‘属性2’])
aggregate(函数 / lambda表达式 / 函数列表 / 字典)，即aggregate可以传入函数、lambda、函数列表及字典，这里传入的是字典。

grouped=diamonds.groupby(['color','cut'])
result=grouped.aggregate({'color':np.size,'carat':np.min,'price':np.mean})#传入字典
print(result)
result.rename(columns={'color':'counts','carat':'min_weight','price':'avg_price'},inplace=True)#对数据框架的列重新命名
print(result)
resultcolor  carat        price
color cut
D     Fair         163   0.25  4291.061350Good         662   0.23  3405.382175Ideal       2834   0.20  2629.094566Premium     1603   0.20  3631.292576Very Good   1513   0.23  3470.467284
E     Fair         224   0.22  3682.312500Good         933   0.23  3423.644159Ideal       3903   0.20  2597.550090Premium     2337   0.20  3538.914420Very Good   2400   0.20  3214.652083counts  min_weight    avg_price
color cut
D     Fair          163        0.25  4291.061350Good          662        0.23  3405.382175Ideal        2834        0.20  2629.094566Premium      1603        0.20  3631.292576Very Good    1513        0.23  3470.467284
E     Fair          224        0.22  3682.312500Good          933        0.23  3423.644159Ideal        3903        0.20  2597.550090Premium      2337        0.20  3538.914420Very Good    2400        0.20  3214.652083

同时，color与cut变成了行索引，如果想要将两个行索引变成数据框的变量名，可以使用数据框的reset_index方法

c1=result.reset_index(inplace=True)
print(c1)

使用的方法