Python的Pandas库学习查找笔记

pandas的总结，Ctrl+F 自行查找

注：s1默认为一个自创的Series，p1默认为一个自创的DataFrame

转置
s1.T

应用函数
p1.apply()
p1.applymap() #将函数应用到每个数据上

映射转换

data[‘class1’] = data[‘food’].map(lambda x: meat[x.lower()])

多值替换

p1.replace([ , ], )
p1.replace([ , ],[ , ])/.replace({ : , : }) #多值替换多值

p1.stack() #将dataframe转为层索引的Series，会过滤缺失值
p1.unstack() #将层索引的series转为dataframe
p1.unstack(0) #转换为内外索引
p1.unstack(‘姓名’) #指定为行索引

分组聚合:

p1.groupby(‘fruit’,as_index=) #分组
p1.groupby(映射,axis=)
p1.groupby(len) #通过函数进行分组
dict(list(df1.groupby(by=‘fruit’)))[‘apple’] #选取任意数据块

p1.groupby(‘fruit’).mean() #聚合运算

离散化和面元划分：

ages = [20, 22, 25, 27, 21, 23, 37, 31, 61, 45, 41, 32,200]
bins = [18,25,35,60,100]
names = [‘青年’,‘年轻人’,‘中年’,‘老年’]
pd.cut（ages,bins,labels=names)

data = array([0.39302272, 0.37501868, 0.73290263, 0.72603369, 0.51909771,
0.8885823 , 0.59003575, 0.41662262, 0.59955758, 0.94268471,
0.88929748, 0.59120833, 0.06724884, 0.89613064, 0.4654646 ,
0.43226392, 0.56076426, 0.71689009, 0.63592251, 0.3099695 ])
pd.cut(data,4,precision=2) #将区间分成四份，保留两位小数

pd.qcut(data,[0,0.1,0.6]) #将数量按比例分

合并列表：

pd.merge(left,right,how=‘inner’,on=Nne,right_on=None,left_on=left)
参数:
left:合并时左边的DataFrame
right:合并时右边的DataFrame
how:合并的方式,默认’inner’, ‘outer’, ‘left’, ‘right’
内连接 inner:对两张表都有的键的交集进行联合
全连接 outer：对两者表的都有的键的并集进行联合
左连接 left：对所有左表的键进行联合
右连接 right：对所有右表的键进行联合
on:需要合并的列名,必须两边都有的列名，并以 left 和 right 中的列名的交集作为连接键
left_on: left Dataframe中用作连接键的列
right_on: right Dataframe中用作连接键的列
right_index=True/False 按索引链接
suffixes=（’’,’’) 自定义重复的列名的后缀

pd.concat([p1,p2],sort=,join=,keys=)
‘’’
参数:
sort 是否索引排序
join 默认为外连接’outer’ 。内连接’inner’
keys 自定义外层索引名称
‘’’
p1.join(p2,how=‘outer’)

检查：

s1.isnull()/s1.notnull() #检查是否为缺失值
s1.dumplicated() #检查是否又重复数据
p1.str.contains(’’) #检查是否包含
p1.is_unique() #检查是否唯一

索引:

s1.values #查看值
s1.index #查看索引
s1.columns #查看行标签
s1.index = [] #修改索引
s1.columns = [] #修改行标签

p1.loc[] #标签索引
p1.iloc[] #位置索引
s1[0]
s1[‘age’] #标签/数字索引选取
s1[[1,2]] #选取多个
s1[1:3] #切片选取
s1[::2]
s1[s1>1] #布尔索引
p1.[‘A’][‘a’]
p1.A
s1.str[:5] #取出每个元素的前五个字符

p1.reset_index() #返回初始索引
pd.take([])
p1.reindex([],axis=)
p1.reindex(columns=[]) #自定义排序行/列索引
p1.set_index([’ ‘,’ ']，inplace=,drop=False/True) #添加索引，drop:是否去掉要添加列表

p1.sort_index(axis=1) #排序索引
p1.sort_values(by=‘A’,axis=)#按值排序

p1.swaplevel() #交换内外层索引
s1.idxmax() #最大值索引
p1.index.map() #映射重命名索引

p1.rename(index={},columns={},inplace=) #映射重命名索引

data  =		date 	  class values values1
			0 	2018-11-22 	a  	5  	4
			1 	2018-11-22 	b  	3  	5
			2 	2018-11-23 	b  	2  	6
			3 	2018-11-23 	c  	6  	8
			4 	2018-11-24 	c  	1  	9

df3.pivot('date','class','values')   #p1.pivot(列索引，行索引，值)

>>> 		 class 	a 		b 		c
		date 			
		2018-11-22 	5.0 	3.0 	NaN
		2018-11-23 	NaN 	2.0 	6.0
		2018-11-24 	NaN 	NaN 	1.0

增加：

p1.append( ,ignore_index=False/True) #增加
p1.insert(1,‘F’,[0,0,0])
p1.insert(位置,索引名,值) #插入

删除：

del p1[‘A’]
p1.drop( ,axis=0,inplace=False)
p1.drop(columns=[‘A’])
p1.dropna(inplace=,how=‘all’/‘any’/thresh=) #删除缺失值,thresh=2去掉又两个及以上的nna行
p1.drop_dumplicates(,keep=‘last’/‘frist’) #检查是够用重复数据，keep保留第一个或最后一个重复的值
p1.fillna({}/method=,limit=) #填充缺失数据，
p1.finall({1:2,2:0.9}) 索引为1的列填充2，索引为2的列填充0.9
p1.fillna(method=‘ffill’/‘bfill’，limit=2) 填充上/下一个单元格的值,第一行则无法填充，限制每单元格值填充最多2个，其余为nan

运算：

p1 + p2 #按照对应的标签索引运算
p1.add( ,fill_value=) #将所有NAN值填充为指定的数字进行运算
p1.rdiv(,axis=) #除以
p1.sub(,axis=) #乘
arr - arr[0]
p1 - s1
p1.sum(，axis=,skipna=False) #默认列求和,skipna参数取消将NAN值设为0
p1.cumsum() #向下累计求和
p1.describe() #汇总统计
p1.values_counts(p1) #统计各小组元素及个数

读取文件：

pd.read_csv(’’) #读取csv文件
pd.read_excel(’’) #读取excel文件
pd.read_table(’’,sep=’,’) #读取文件，sep设置分隔符
‘’’
参数:
encoding
sep 分隔符
header 用作列名的行号。默认为0（第一行），如果没有header行就设置为None
index_col 用作行索引的列编号或列明。可以是单个名称/数字或多个组成的列表（层次化索引）
names 用于结果的列名列标，结合header=None
usecols 指定读取的列名
skiprows 需要忽略的行数，或需要跳过的行号列表（从0开始）
na_calues 一组用于替换NA的值
nrows 需要读取的行数（从文件开始处算起）
iterator 返回一个TextParse以便逐块读取文件
chunksize 文件块的大小（用于迭代）
skip_footer 需要忽略的行数
‘’’

写入文件：

p1.to_csv(’’)
‘’’
参数：
file_path 保存文件路径，默认None
columns 是否表里某列数据 默认None
index 是否保留行索引 默认True
np_rep 指定字符串来代替空值 默认
mode 默认’w’ 追加’a’
‘’’

数据库交互：

from sqlalchemy import create_engine
	#初始化数据库连接
	#用户名root 密码   端口 3306  数据库 db2
	engine = create_engine('mysql+pymysql://root:@localhost:3306/db2')
	#查询语句
	sql = '''
		select * from class;
	'''
	#两个参数   sql语句  数据库连接
	df = pd.read_sql(sql,engine)
	
	#新建
	df = pd.DataFrame({'id':[1,2,3,4],'num':[34,56,78,90]})
	df = pd.read_csv('ex1.csv')
	# #写入到数据库
	df.to_sql('df2',engine,index=False)

字符串操作：

字符串方法：

count                #返回子串在字符串中出现的次数
endswish/startswish  #如果字符串以某个后结尾/前缀开头，则返回True
join                 #将字符串作用链接其他字符串序列的分隔符
index                #如果在字符串中找到字串，则返回字串第一个字符串所在的位置，否则报错
find                 #找到输出第一个索引，没找到输出-1
rfind                #输出最后一个索引
replace
strip、rstrip、lstrip
split
lower、upper
ljust、rjust         #用空格（或其他字符）填充字符串的空白测

Pandas字符串函数：

	cat          #实现元素级的字符串连接操作，可指定分隔符
	count        #返回表示个字符串是否含有指定模式的布尔型数组
	extract      #使用带分组的正则表达式从字符串Series提取一个或多个字符串，结果是一个	DataFrame，每组有一列
	endswish/startswish
	findall      #计算各字符串的模式列表
	fet          #获取各元素的第i个字符
	isalnum      str.alnum
	isalpha      str.isalpha
	isdecimal    str.isdecimal
	isdigit      str.isdigit
	islower      str.islower
	isupper      str.isupper
	join
	len
	lower,upper
	match
	pad
	center
	repeat
	repleace
	slice         #对Series中的各个字符串进行子串截取
	split\rsplit\lsplit

正则表达式方法：

	findall、finditer    #返回字符串中所有非重叠匹配模式。findall返回的事所有模式组成的列表，而finditer则通过要给迭代器逐个返回
	match                #从字符串起始位置匹配模式，返回皮匹配到的对象或None
	serach               #匹配任意位置
	split
	sub、subn            #代替所有个（sub）或前n个（subn）	
	'''

时间序列基础：

from datetime import datetime
#获取当前时间
datetime.now()
->>>datetime.datetime(2019, 12, 6, 15, 32, 21, 470948)

#选取指定日期类型
t1.yeat,t1.day
->>>(2019, 6)

#时间运算
datetime(2008,6,25) -datetime.now()
->>>datetime.timedelta(days=-4182, seconds=30458, microseconds=529052)

from datetime import timedelta
#时间增量
timedelta(days=0, seconds=0, microseconds=0, milliseconds=0, minutes=0, hours=0, weeks=0)

timedelta(12) #12day

#字符串转为datetime
str(datetime(2011,1,3)
parse(‘2011-1-3’)
parse(‘3/1/2011’,dayfirst=True)
#按str指定格式转为datetime
datetime.strptime(‘2011,1,3’,’%Y-%m-%d’)

#datetime转为字符串
datetime(2011,1,3).strftime(’%Y-%m-%d’)
#str数组转为datetime类型索引
pd.to_datetime([‘2011,1,3’,‘2011,1,2’…])

#时间索引选取
ts = 2011-01-02 0.986092
2011-01-05 1.136382
2011-01-27 -0.207809
2011-01-08 -0.104722
2011-01-10 -0.744944
2011-01-12 0.926367
dtype: float64
ts[‘2011-01-02’]
ts[‘1/10/2011’]
ts[‘20110110’]
stamp = ts.index[2],ts[stamp]
ts1[‘2011’]
ts1[‘2001-01’]
ts[‘1/02/2011’:‘1/12/2011’]
ts[ts.index > datetime(2011,1,6)]

#生成日期范围
pd.date_range(start=None,end=None,periods=None,freq=‘D’)
pd.date_range(‘2012-04-01’,‘2012-06-01’)

#频率和日期偏移量
from pandas.tseries.offsets import Hour,Minute
Hour(4) #4个小时
ts.shitft(2/-2,freq=’’) #将数据上下移动2个单元
ts.shift(2,freq=‘M’) # 将日期索引往后移动两个月

#重采样：将时间序列从一个频率转化为另一个频率进行处理的过程，将高频率数据转化为低频率数据为降采样，低频率转化为高频率为升采样
#降采样
ts.resample(‘M’).sum() #计算每月数据加和
ts.resample(‘10D’).count() #计算每10天数据个数
#升采样
ts.resample(‘D’).safreq() #展开的数据为NAN
ts.resample(‘D’).safreq().ffill() #填充NAN