Python之科学运算Pandas模块

一、Series数列

Series
Series是一种类似与一维数组的对象，由下面两个部分组成：
values：一组数据（ndarray类型）
index：相关的数据索引标签

Series的创建
第一种：由列表或numpy数组创建
列表创建：
Series([1,2,3,4,5],index=['a','b','c','d','e'],name='Hello')
ndarray创建
a1 = np.array([1,2,3,4,5])
Series(a1,index=["a","b","c","d","e"],name='hello')
第二种：由字典创建:不能在使用index.但是依然存在默认索引
注意：数据源必须为一维数据
dict = {'hello':12,'hey':30}
Series(data=dict)

Series的索引
可以使用中括号取单个索引（此时返回的是指定索引的元素），或者中括号里一个列表取多个索引（此时返回的是一个Series类型）。
s1 = Series(data=[1,2,3],index=['a','b','c'])
----> s1[1] 返回的是指定索引的元素
----> s1[[0,1]] 返回的是一个Series类型
显式索引：
使用index中的元素作为索引值，
使用s.loc[]（推荐）:注意，loc中括号中放置的一定是显示索引
----> s1.b
----> s1.loc["b"]
隐式索引
使用.iloc[]（推荐）:iloc中的中括号中必须放置隐式索引
----> s1.iloc[1]

Series切片:隐式索引切片和显示索引切片
显示索引切片:index和loc
s1["a":"c"]根据index切
s1.loc["a":"c"]根据loc切
隐示索引切片：整数索引值和iloc
s1[0:2]根据整数索引值切
s1.iloc[0:2]根据iloc切

Series的基本概念
可以把Series看成一个定长的有序字典
向Series增加一行：相当于给字典增加一组键值对

可以通过shape，size，index,values等得到series的属性

可以使用s.head(n),tail(n)分别查看前n个和后n个值

当索引没有对应的值时，可能出现缺失数据显示NaN（not a number）的情况

可以使用pd.isnull()，pd.notnull()，或s.isnull(),notnull()函数检测缺失数据

 

屏幕快照 2018-11-05 下午8.44.28.png

Series的运算
+ - * /
add()/sub()/mul()/div()
s1.div(s2,fill_value=9)
在运算中自动对齐不同索引的数据，如果索引不对应，则补NaN

二、DataFarme(数据帧)

DataFarme认识
DataFrame是一个【表格型】的数据结构。DataFrame由按一定顺序排列的多列数据组成。设计初衷是将Series的使用场景从一维拓展到多维。DataFrame既有行索引，也有列索引。
行索引：index
列索引：columns
值：values

DataFrame(数据帧)的创建
最常用的方法是传递一个字典来创建。DataFrame以字典的键作为每一【列】的名称，以字典的值（一个数组）作为每一列。
此外，DataFrame会自动加上每一行的索引。
使用字典创建的DataFrame后，则columns参数将不可被使用。
同Series一样，若传入的列与字典的键不匹配，则相应的值为NaN。
使用字典创建DataFarme
dict = {"java":[90,22,66],'python':[12,33,66]}
DataFrame(data=dict,index=['章伞','里斯','魍伍'])
使用ndarray创建DataFrame
DataFrame(data=np.random.randint(0,100,size=(3,6)),index=["one","two","three"],columns=["呵","哈","嘿","嘻","嗨","呜"])

DataFarme属性
DataFrame属性：values、columns、index、shape

DataFrame的索引

对列进行索引
-- 通过类似字典的方式 df['q']
-- 通过属性的方式 df.q
可以将DataFrame的列获取为一个Series。返回的Series拥有原DataFrame相同的索引，且name属性也已经设置好了，就是相应的列名。
--- df["呵"]
--- df.呵
--- df[["呵","哈","嘿"]]
修改列索引
df.columns = ['1','2','3',"4","5","6"]

对行进行索引
使用.loc[]加index来进行行索引
使用.iloc[]加整数来进行行索引
同样返回一个Series，index为原来的columns。
--- df.loc["one"]
--- df.loc[["one","two"]]
--- df.loc["one":"three"]
--- df["one":"three"]
--- df["one":"three"]["嘿"]
修改行索引
--- df.index = [1,2,3]

对元素索引的方法
行索引在前，列索引在后
--- df.loc["one"]["哈"]
--- df.iloc[0]["哈"]

DataFrame的列删除
df.drop("列名",axio=1,inplace=True)

DataFarme的切片
--- df.loc["one":"three","呵":"嘿"]
--- df.loc["one":"two"][["呵","呜"]]
--- df.loc["one":"two",["呵","呜","哈"]]
--- df.loc[["one"],["呵","呜","哈"]]

DataFrame的运算
同Series一样:
在运算中自动对齐不同索引的数据
如果索引不对应，则补NaN

处理丢失数据
有两种丢失数据：None、np.nan(NaN)
None是Python自带的，其类型为python object。因此，None不能参与到任何计算中。
np.nan是浮点类型，能参与到计算中。但计算的结果总是NaN。

pandas中None与np.nan都视作np.nan

pandas处理空值操作
isnull(). 判断函数
notnull() 判断函数
dropna(): 过滤丢失数据
df.dropna() 可以选择过滤的是行还是列（默认为行）:axis中0表示行，1表示的列
fillna(): 填充丢失数据
很多时候将空值全都dropna()掉是不现实的，所以需要用fillna()填充空值。
df.fillna(value=100) 或者 df.fillna(method="ffill",axis=0)
method 控制填充的方式，可以选择前向填充还是后向填充

DataFrame的数据过滤
df.query(expr, inplace=False, **kwargs)，可以指定一个字符串形式的筛选条件 逻辑与& 或 | ==

df.shift() 该函数主要的功能就是使数据框中数据整体移动
df.shift(1)

三、创建多层列索引

隐式构造
最常见的方法是给DataFrame构造函数的index或者columns参数传递两个或更多的数组
df = DataFrame(data=np.random.randint(80,100,size=(2,4)),index=['tom','jay'],columns=[['qz','qz','qm','qm'],['chinese','math','chinese','math']])

显示构造pd.MultiIndex.from_
使用数组方式
创建了一个索引对象，该索引对象为二层索引
indexObj = pd.MultiIndex.from_arrays([['qz','qz','qm','qm'],['chinese','math','chinese','math']])
创建DF对象
DataFrame(data=np.random.randint(80,100,size=(2,4)),index=['tom','jar'],columns=indexObj)

 

屏幕快照 2018-11-05 下午10.00.20.png

使用product方式

最简单，推荐使用
col=pd.MultiIndex.from_product([['qizhong','qimo'], ['chinese','math']])
创建DF对象
df = DataFrame(data=np.random.randint(10,100,size=(2,4)),index=['tom','jay'], columns=col)

 

屏幕快照 2018-11-05 下午10.05.06.png

多层行索引
除了列索引，行索引也能用上述同样的方法创建多层行索引

多层索引对象的索引与切片操作
注意在对行索引的时候，若一级行索引还有多个，对二级行索引会遇到问题！也就是说，无法直接对二级索引进行索引，必须让二级索引变成一级索引后才能对其进行索引！

总结：
访问一列或多列 直接用中括号[columnname] 、[[columname1,columnname2...]]
访问一行或多行 .loc[indexname]
访问某一个元素 .loc[indexname,columnname]
行切片 .loc[index1:index2]
列切片 .loc[:,column1:column2]

聚合操作
所谓的聚合操作：平均数，方差，最大值，最小值……
使用value_counts()函数，统计列中各个元素出现次数
使用unique()函数查看一列中有哪些元素

四、pandas的拼接操作(类似数据库的联表)

pandas的拼接分为两种：
级联：pd.concat, pd.append
合并：pd.merge, pd.join

----级联

pandas使用pd.concat级联函数，与np.concatenate函数类似，只是多了一些参数：
objs 级联的对象
axis=0 轴向
keys:列表，列表元素表示的是进行级联的df的一个名称
join='outer' / 'inner':表示的是级联的方式，outer会将所有的项进行级联（忽略匹配和不匹配），而inner只会将匹配的项级联到一起，不匹配的不级联
ignore_index=False

匹配级联
df1 = DataFrame(data=np.random.randint(0,100,size=(3,3)),index=['a','b','c'],columns=['A','B','C'])
pd.concat([df1,df1],axis=0)
不匹配级联
不匹配指的是级联的维度的索引不一致。例如纵向级联时列索引不一致，横向级联时行索引不一致
不匹配级联有2种连接方式：
外连接：补NaN（默认模式）
内连接：只连接匹配的项
df1 = DataFrame(data=np.random.randint(0,100,size=(3,3)),index=['a','b','c'],columns=['A','B','C'])
df2 = DataFrame(data=np.random.randint(0,100,size=(3,3)),index=['a','c','d'],columns=['A','C','D'])
外链接：pd.concat([df1,df2],axis=1,join="outer")
内链接：pd.concat([df1,df2],axis=0,join="inner")
内链接指定keys：pd.concat([df1,df2],axis=1,join="inner",keys=['AAA','BBB'])

df.append()函数级联
由于在后面级联的使用非常普遍，因此有一个函数append专门用于在后面添加
df1.append(df2)

----合并

使用pd.merge()合并
merge与concat的区别在于，merge需要依据某一共同的列来进行合并
使用pd.merge()合并时，会自动根据两者相同column名称的那一列，作为key来进行合并。
注意每一列元素的顺序不要求一致

参数
how：out取并集 inner取交集
on：当有多列相同的时候，可以使用on来指定使用那一列进行合并，on的值为一个列表
一对一合并
df1 = DataFrame({'employee':['Bob','Jake','Lisa'],'group':['Accounting','Engineering','Engineering'],})
df2 = DataFrame({'employee':['Lisa','Bob','Jake'],'hire_date':[2004,2008,2012],})
merge合并：pd.merge(df1,df2)
多对一合并
df3 = DataFrame({'employee':['Lisa','Jake'],'group':['Accounting','Engineering'],'hire_date':[2004,2016]})
df4 = DataFrame({'group':['Accounting','Engineering','Engineering'],'supervisor':['Carly','Guido','Steve']})
pd.merge(df3,df4)
多对多合并
略

key的规范化使用
当列冲突时，即有多个列名称相同时，需要使用on=来指定哪一个列作为key，配合suffixes指定冲突列名。
pd.merge(df1,df2,on="group",suffixes=('_甲','乙'),how="outer")

注意：当两张表没有可进行连接的列时，可使用left_on和right_on手动指定merge中左右两边的哪一列列作为连接的列

内合并与外合并:
外合并outer：取并集，补NaN
内合并inner：取交集，保留两者都有的key

五、pandas数据处理

1、检测重复行 duplicated()
　　使用duplicated()函数检测重复的行，返回元素为布尔类型的Series对象，每个元素对应一行，如果该行不是第一次出现，则元素为True
keep参数：指定保留哪一重复的行数据
True 重复的行

2.删除重复行 drop_duplicates()
　　使用drop_duplicates()函数删除重复的行
　　drop_duplicates(keep='first/last'/False)

2. 映射:指定替换
　　replace()函数：替换元素
　　使用replace()函数，对values进行映射操作

Series替换操作replace()
单值替换
　　普通替换
　　s.replace(to_replace=2,value='two',inplace=True)
　　字典替换(推荐）
　　s.replace(to_replace={2:'two'},inplace=True)
多值替换
　　列表替换
　　s.replace(to_replace=[1,5],value=['one','five'])
　　字典替换（推荐）
　　s.replace(to_replace={3:'three',4:'four'},inplace=True)
参数
　　to_replace:被替换的元素
　　method：对指定的值使用相邻的值填充替换
　　limit：设定填充次数

DataFrame替换操作
单值替换
　　普通替换： 替换所有符合要求的元素,没有要替换的值也不会报错:
　　df.replace(to_replace=64,value='aaa')
　　按列指定单值替换： to_replace={列标签：替换值} ,value='value'
　　df.replace(to_replace={2:85},value='eight')
多值替换
　　列表替换: to_replace=[] value=[]
　　df.replace(to_replace=[9,0],value=['a','b'])
　　字典替换（推荐） to_replace={to_replace:value,to_replace:value}
　　df.replace(to_replace={1:"one",30:"thirty"})
注意：DataFrame中，无法使用method和limit参数

3. map()函数：新建一列
　　map是Series的一个函数
　　map()可以映射新一列数据
　　map()中可以使用lambd表达式
　　map()中可以使用方法，可以是自定义的方法
注意 map()中不能使用sum之类的函数，for循环
df = DataFrame(data=[['zhangsan',1000,'sale'],['lisi',2000,'dev'],['wangwu',3333,'dev']],columns=['name','salary','dep'])
增加名为e_name列：
df['e_name'] = df['name'].map({'lisi':'Tony','zhangsan':'Tom','wangwu':'Jerry'})

map当做一种运算工具，至于执行何种运算，是由map函数的参数决定的
（参数：lambda，函数）
-- 使用自定义函数
　　def func():
　　　　...
　　　　return xxx
　　df['salary'].map(func)
-- 使用lambda表达式
　　df['salary'].map(lamada x:x..)

注意：并不是任何形式的函数都可以作为map的参数。只有当一个函数具有一个参数且有返回值，那么该函数才可以作为map的参数。

4. 使用聚合操作对数据异常值检测和过滤
使用df.std()函数可以求得DataFrame对象每一列的标准差
此处不再做详细解读

5. 排序
--使用sort_value()排序
d f.sort_values(by="列名",axis=0,ascending=False)
-- 使用.take()函数排序
take()函数接受一个索引列表，用数字表示,使得df根据列表中索引的顺序进行排序
df.take([1,2,0],axis=0)

 

屏幕快照 2018-11-06 下午8.14.29.png

-- 可以借助np.random.permutation()函数随机排序
np.random.permutation(x)可以生成x个从0-(x-1)的随机数列
arr = np.random.permutation(4)
df.take(arr,axis=1)
随机抽样：当DataFrame规模足够大时，直接使用np.random.permutation(x)函数，就配合take()函数实现随机抽样

6.数据分类处理【重点】
数据聚合是数据处理的最后一步，通常是要使每一个数组生成一个单一的数值。

数据分类处理：
　　分组：先把数据分为几组
　　用函数处理：为不同组的数据应用不同的函数以转换数据
　　合并：把不同组得到的结果合并起来
数据分类处理的核心：
　　groupby()函数
　　groups属性查看分组情况
分组后的聚合操作：分组后的成员中可以被进行运算的值会进行运算，不能被运算的值不进行运算

unstack()与reset_index()对比：
针对多列分组情况，使用unstack(level=1)将上面所得分组数据指定的索引变成列索引。

 

屏幕快照 2018-11-07 下午4.05.50.png

把索引变成列,Series.reset_index()

 

屏幕快照 2018-11-07 下午4.16.23.png

pandas数据读取和写入：

1.pandas提供了一些用于将表格型数据读取为DataFrame对象的函数，期中read_csv和read_table这两个使用最多。
2.使用read_csv读取url获取网络上的数据
3.通过to_excel(path)、to_sql("sql语句",conn)等方式将数据写入对应的文件或数据库