numpy:处理数值数据 pandas:字符串，时间数据等1、Pandas概述
Pandas是一个强大的分析结构化数据的工具集，基于Numpy构建，提供了高级数据结构和数据操作工作
1、基础是numpy,提供了高效性能矩阵的运算; 2、提供数据清洗功能 3、应用于数据挖掘,数据分析 4、提供了大量能快速便捷地处理数据的额函数和方法2、Pandas数据结构 2.1、Series介绍
Series：是一种一维标记的数据型对象，能够保存任何数据类型（int，str，float，python object），包含了数据标签，称为索引
（1）通过列表创建
# 1、通过list创建 s1 = pd.Series([1,2,3,4,5]) s1
（2）通过数组创建
# 2、通过数组创建 arr1= np.arange(1,6) s2 = pd.Series(arr1) print(s2)
（3）通过字典创建
# 3、通过字典创建
dict = {'name':'李宁','age':18,'class':'三班'}
s3 = pd.Series(dict,index = ['name','age','class','sex'])
s3
（1）空值判断
# isnull和not null检测缺失值 s3.isnull()
（2）获取数据
获取数据方式:索引,下标,标签名
# 1、索引获取数据 print(s3.index) print(s3.values) # 2、下标获取数据 print(s3[1:3]) # 3、标签名获取数据 print(s3['age':'class'])
注意事项
标签切片和下标切片的区别 标签切片:包含末端数据 索引切片:不包含末端数据
（3）索引与数据的对应关系
索引和数据的对应关系不被运算结果影响
（4）name属性
s3.name = "temp" #对象名 s3.index.name = 'values' #对象索引名 s3
Dataframe是一个表格型的数据结构，它含有一组有序的列，每列可以是不同类型的索引值，Dataframe既有行索引也有列索引，它可以被看作是由series组成的字典，数据以二维结构存放
# 数组、列表或元组构成的字典构造Dataframe
data = {'a':[1,2,3,4],
'b':(5,6,7,8),
'c':np.arange(9,13)}
frame = pd.Dataframe(data)
# 相关属性
print(frame.index)
print(frame.columns)
print(frame.values)
1、T转置 2、通过列索引获取列数据(Series类型) 3、增加列数据 4、删除列
import pandas as pd
import numpy as np
df = pd.Dataframe(np.arange(9).reshape(3,3),index = ['a','c','d'],columns=['A','C','B'])
# 1、T转置
df1 = df.T
print(df1)
print("========")
# 2、列索引获取数据
print(df['B'])
print("========")
# 3、增加列数据
df['D']=[1,2,3]
print(df)
# 4、删除列
df.drop('D',axis=1)
1、Series和Dataframe中的索引都是index对象 2、索引对象不可改变,保证数据安全
ps = pd.Series(range(5)) pd = pd.Dataframe(np.arange(9).reshape(3,3),index = ['a','b','c'],columns = ['A','B','C']) type(ps.index)
常见索引类型 :1、Index - 索引 :2、Inet64index - 整数索引 :3、MultiIndex - 层级索引 :4、DatetiemIndex - 时间戳索引4.2、索引基本操作
（1）重新索引
reindex:创建一个符合新索引的新对象
s = pd.Series(np.random.randn(5),index=['a','b','c','d','e']) print(s) s.reindex(['e','b','f','d'])
（2）增
1、在原有数据结构上增加数据 2、在新建数据结构上增加数据
s = pd.Series(np.random.randn(5),index=['a','b','c','d','e']) s['f'] = 100 print(s)
（3）删
1、del:删除,会更改原有结构 2、drop:删除轴上数据,产生新的对象
# 删除 ps = pd.Series(np.random.randn(5),index=['a','b','c','d','e']) del ps['e'] print(ps) ps2 = ps.drop(['a','b']) print(ps2)
import numpy as np import pandas as pd pd = pd.Dataframe(np.random.randn(9).reshape(3,3),columns=['a','b','c']) print(pd) # 删除列 pd1 = pd.drop(['c'],axis=1) print(pd1) # 删除行 pd2 = pd.drop(2) print(pd2)
（4）改
1、修改列:对象.索引，对象.列 2、修改行:标签索引loc
import numpy as np import pandas as pd pd = pd.Dataframe(np.random.randn(9).reshape(3,3),columns=['a','b','c']) print(pd) # 修改列 pd['a'] = 12 pd.b = 22 print(pd) # 修改行 pd.loc[0] = 100 print(pd)
（5）查
1、行索引 2、切片索引:位置切片,标签切片 3、不连续索引
import numpy as np import pandas as pd ps = pd.Series(np.random.randn(5),index=['a','b','c','d','e']) # 行索引 print(ps['a']) # 位置切片索引 print(ps[1:3]) # 标签切片索引,包含终止索引 print(ps['a':'c']) # 不连续索引 print(ps[['a','c']]) # 布尔索引 print(ps[ps>0])
1、loc标签索引:基于标签名的索引 pd.loc[2:3,'a'] 2、iloc位置索引:基于索引编号索引 3、ix标签与位置混合索引:知道就行
import numpy as np import pandas as pd pd = pd.Dataframe(np.random.randn(9).reshape(3,3),index = [7,8,9],columns=['a','b','c']) # 标签索引 - 第一个参数索引行，第二个参数是列 print(pd.loc[7:8,'a']) # 位置索引 - 两个参数,行列 print(pd.iloc[0:2,0:2])
Pandas进行数据运算时，会按照索引进行一一对应，对应后进行相应的算术运算，没有对齐的位置就会用NaN进行填充。
import numpy as np import pandas as pd s1 = pd.Series(np.arange(5),index=['a','b','c','d','e']) s2 = pd.Series(np.arange(5,10),index=['a','b','c','d','e']) print(s1) print(s2) print(s1+s2)
待补充5.3、混合运算
Dataframe和Series混合运算:Series的行索引匹配Dataframe的列索引进行广播运算,index属性可沿列运算
import pandas as pd import numpy as np df = pd.Dataframe(np.arange(9).reshape(3,3),index = ['A','B','C'],columns=['A','B','C']) ds = df.iloc[0] # 行运算,列广播 print(df-ds) # 列运算,行广播 df.sub(ds,axis = 'index')
运算规则:索引匹配运算5.4、函数应用
（1）apply函数
apply:将函数应用到行或列
import pandas as pd import numpy as np df = pd.Dataframe(np.arange(9).reshape(3,3),index = ['A','B','C'],columns=['A','B','C']) f = lambda x:x.max() # 应用在行上,进行列运算 print(df.apply(f)) # 应用在列上，进行行运算 print(df.apply(f,axis=1))
（2）applymap函数
applymap:将函数应用到每个数据
import pandas as pd import numpy as np df = pd.Dataframe(np.arange(9).reshape(3,3),index = ['A','B','C'],columns=['A','B','C']) f = lambda x:x**2 print(df.applymap(f))
（3）排序
索引排序:sort_index(ascending,axis) 按值排序:sort_values(by,sacending,axis)
import pandas as pd import numpy as np df = pd.Dataframe(np.arange(9).reshape(3,3),index = ['B','D','C'],columns=['A','C','B']) # 按行索引排序 print(df.sort_index(ascending=False,axis=1)) # 按列值进行排序 print(df.sort_values(by = 'A'))
（4）唯一值和成员属性
| 函数名称 | 描述 |
|---|---|
| unique | 返回一个Series，用于去重 |
| value_counts | 返回Series，包括元素及其个数 |
| isin | 判断是否存在，返回布尔类型 |
（5）处理缺失值
import pandas as pd import numpy as np df = pd.Dataframe([np.random.randn(3),[1,2,np.nan],[np.nan,4,np.nan]]) # 1、判断是否存在缺失值 print(df.isnull()) # 2、丢弃缺失数据,默认丢弃行 print(df.dropna()) # 3、填充缺失数据 print(df.fillna(-100))
层级索引:在输入索引Index时，输入了由两个子list组成的list，第一个子list是外层索引，第二个list是内层索引。 作用:通过层级索引配合不同等级的一级索引使用，可以将高维数组转化为Series或Dataframe对向形式
import pandas as pd
import numpy as np
ser_obj = pd.Series(np.random.randn(12),index=[
['a', 'a', 'a', 'b', 'b', 'b', 'c', 'c', 'c', 'd', 'd', 'd'],
[0, 1, 2, 0, 1, 2, 0, 1, 2, 0, 1, 2]
])
# 选取子集
'''
根据索引获取数据。因为现在有两层索引，当通过外层索引获取数据的时候，可以直接利用外层索引的标签来获取。
当要通过内层索引获取数据的时候，在list中传入两个元素，前者是表示要选取的外层索引，后者表示要选取的内层索引。
'''
print(ser_obj['a',1])
# 交换内外层
print(ser_obj.swaplevel())
统计计算:默认按列计算
import pandas as pd import numpy as np df = pd.Dataframe(np.arange(32).reshape(8,4)) # 选取 df.sum()
平均数:np.mean() 总和:np.sum() 中位数:np.median() 最大值:np.max() 最小值:np.min() 频次（计数）: np.size() 方差:np.var() 标准差:np.std() 乘积:np.prod() 协方差: np.cov(x, y) 偏度系数(Skewness): skew(x) 峰度系数(Kurtosis): kurt(x) 正态性检验结果: normaltest(np.array(x)) 四分位数:np.quantile(q=[0.25, 0.5, 0.75], interpolation=“linear”) 四分位数:describe() – 显示25%, 50%, 75%位置上的数据 相关系数矩阵(Spearman/ Person/ Kendall)相关系数: x.corr(method=“person”))8、数据读取与存储 8.1、读写文本格式文件
读取csv文件read_csv(file_path or buf,usecols,encoding):file_path：文件路径,usecols:指定读取的列名，encoding:编码
范例
data = pd.read_csv('D:/jupyter_notebook/bfms_w2_out.csv',encoding='utf8')
data.head()
pd.merge:(left, right, how='inner',on=None,left_on=None, right_on=None ) left:合并时左边的Dataframe right:合并时右边的Dataframe how:合并的方式,默认'inner', 'outer', 'left', 'right' on:需要合并的列名,必须两边都有的列名，并以 left 和 right 中的列名的交集作为连接键 left_on: left Dataframe中用作连接键的列 right_on: right Dataframe中用作连接键的列 * 内连接 inner:对两张表都有的键的交集进行联合
import pandas as pd
import numpy as np
left = pd.Dataframe({'key': ['K0', 'K1', 'K2', 'K3'],
'A': ['A0', 'A1', 'A2', 'A3'],
'B': ['B0', 'B1', 'B2', 'B3']})
right = pd.Dataframe({'key': ['K0', 'K1', 'K2', 'K3'],
'C': ['C0', 'C1', 'C2', 'C3'],
'D': ['D0', 'D1', 'D2', 'D3']})
pd.merge(left,right,on='key') #指定连接键key
concat:可指定轴进行横向或者纵向合并
df1 = pd.Dataframe(np.arange(6).reshape(3,2),index=list('abc'),columns=['one','two'])
df2 = pd.Dataframe(np.arange(4).reshape(2,2)+5,index=list('ac'),columns=['three','four'])
print(df1)
print(df2)
pd.concat([df1,df2],axis='columns') #指定axis=1连接
stack:stack函数会将数据从”表格结构“变成”花括号结构“，即将其行索引变成列索引 unstack:unstack函数将数据从”花括号结构“变成”表格结构“，即要将其中一层的列索引变成行索引。
import numpy as np
import pandas as pd
df_obj = pd.Dataframe(np.random.randint(0,10, (5,2)), columns=['data1', 'data2'])
print(df_obj)
print("stack")
stacked = df_obj.stack()
print(stacked)
print("unstack")
# 默认操作内层索引
print(stacked.unstack())
# 通过level指定操作索引的级别
print(stacked.unstack(level=0))
