pandas汇总笔记
1 #构造Series
2 obj = Series([4,7,-5,3]) #不添加索引时，自动生成索引从0开始
3 obj1 = Series([4,7,-5,3],index=['a','b','c','d']) #添加索引时，Seires使用添加的索引
4 obj.values:#显示添加的元素值,数值类型为np.array
5 obj.index #显示索引，类似np.arange
6
7 #利用python中的字典构建Series
8 sdata = {'Ohio': 35000, 'Texas': 71000, 'Oregon': 16000, 'Utah': 5000}
9 obj3 = Series(sdata)
10
11 #对已有Series索引进行修改，生成新的Series
12 states = ['California', 'Ohio', 'Oregon', 'Texas']
13 obj4 = Series(sdata,index=states) #由于原Series索引中没有California，所以生成的新的Series中的California对应的值为Nan
1 #Series元素增删改查 2 #查找单个元素,按照索引查找 3 obj1['a'] 4 #查找多个元素 5 obj1[['a','b','c']]# 索引值为列表 6 #boo按l值查找 7 obj1[obj2 > 0] 8 #修改/增加数值 9 obj1['b'] = 6 #直接赋值修改或增加元素 10 obj2 * 2 #Series元素级操作，修改所有的元素值 11 #删除操作 12 del obj2['b'] #直接删除元素
1 #判断元素是否在序列中 2 ‘b’ in obj1 #类似字典 ，判断key是否在字段中 3 #判断元素是否为控制 4 #方式一： 5 obj4.isnull()#使用对象方法调用，返回一个bool型Series 6 #方式二： 7 pd.isnull(obj4) #pd.notnull()#使用pandas内置的函数 8 #给Series添加name 9 obj4.name = 'population' 10 #给索引添加name 11 obj4.index.name = 'state'importpandas as pd
#生成DataFrame#利用python中的字典生成data = {'state': ['Ohio', 'Ohio', 'Ohio', 'Nevada', 'Nevada', 'Nevada'], 'year': [2000, 2001, 2002, 2001, 2002, 2003], 'pop': [1.5, 1.7, 3.6, 2.4, 2.9, 3.2]}frame = pd.DataFrame(data) #行索引值默认为0开始计数，列索引为year,pop,state，输出顺序不固定#显示DataFrame中的前几行frame.head(6)#显示前6行#固定列输出的顺序pd.DataFrame(data,columns=['year','pop','state']) #表格会按照year,pop,state列顺序输出#固定行索引和列索引名称frame2 = pd.DataFrame(data, columns=['year', 'state', 'pop', 'debt'], index=['one', 'two', 'three', 'four', 'five', 'six'])#行索引和列索引固定生成DataFrame,其中debt列由于原数据中没有，该列全部显示为Nanpop = {'Nevada': {2001: 2.4, 2002: 2.9}, 'Ohio': {2000: 1.5, 2001: 1.7, 2002: 3.6}}frame3 = pd.DataFrame(pop) #字典中已经定义了行索引和列索引pd.DataFrame(pop, index=[2001, 2002, 2003]) #固定DataFrame中行索引的顺序#利用已有的DataFrame 生成DataFramepdata = {'Ohio': frame3['Ohio'][:-1], 'Nevada': frame3['Nevada'][:2]} #利用到了切片pd.DataFrame(pdata)#转置frame3.T#列索引frame2.columns#行索引frame2.index#查找一列元素的方法#方式一frame2['state']#方式二：frame2.year#方式三：frame.loc['state']#给类赋值方法frame2['debt'] = 16.5 #debt列所有数值均为16.5frame2['debt'] = np.arange(6.) #debt列数值为从0-5val = pd.Series([-1.2, -1.5, -1.7], index=['two', 'four', 'five'])frame2['debt'= = val #使用Series给DataFrame的列赋值，未赋值的索引对应的值为Nan#新增一列frame2['eastern'] = frame2.state == 'Ohio' #新增一个bool值列，根据state列的值是否为‘Ohio’判断#删除列del frame2['eastern']#设置行索引和列索引的名称frame3.index.name = 'year'frame3.columns.name = 'state'#DataFrame的值frame3.values #是一个np.array数组#pandas索引操作#1.获取索引obj = pd.Series(range(3), index=['a', 'b', 'c'])index= obj.index #获取序列索引labels = pd.Indext(range(3)) #使用pd.Index建立索引obj2 = pd.Series([1.5, -2.5, 0], index=labels)obj2.index is labels #True#2.判断索引中是否包含某元素‘a’ in obj.indexpop = {'Nevada': {2001: 2.4, 2002: 2.9},'Ohio': {2000: 1.5, 2001: 1.7, 2002: 3.6}}frame3 = pd.DataFrame(pop)'Ohio' in frame3.columns'2001' in frame3.index#3.索引值可以重复dup_labels = pd.Index(['foo', 'foo', 'bar', 'bar'])#pandas 重要的函数#1.reindex #重新索引obj = pd.Series([4.5, 7.2, -5.3, 3.6], index=['d', 'b', 'a', 'c'])obj2 = obj.reindex(['a', 'b', 'c', 'd', 'e']) #e 对应的元素为Nan,按照重新定义的索引顺序显示obj3 = pd.Series(['blue', 'purple', 'yellow'], index=[0, 2, 4])obj3.reindex(range(6), method='ffill') #对于空的索引1,3,5的值根据前值填充,bfill向后填充frame = pd.DataFrame(np.arange(9).reshape((3, 3)), index=['a', 'c', 'd'], columns=['Ohio', 'Texas', 'California'])frame2 = frame.reindex(['a','b','c','d']) #b行为空,增加新行states = ['Texas', 'Utah', 'California']frame.reindex(columns=states) #增加新列Utah,列值为Nanframe.loc[['a','b','c','d'],states] #选择所有的行和states所对应的列#2.drop删除元素obj = pd.Series(np.arange(5.), index=['a', 'b', 'c', 'd', 'e'])new_obj = obj.drop('c') #根据索引删除元素data = pd.DataFrame(np.arange(16).reshape((4, 4)), index=['Ohio', 'Colorado', 'Utah', 'New York'], columns=['one', 'two', 'three', 'four'])data.drop(['Colorado', 'Ohio']) #删除Colorado和Ohio行data.drop('two',axis=1) #删除一列data.drop(['two','three'],axis=columns) #删除两列#3.选择和筛选元素obj = pd.Series(np.arange(4.), index=['a', 'b', 'c', 'd'])obj['b'] #根据索引选择元素obj[1]#根据下标位置选择元素obj[2:4]#根据下标位置切片选择元素obj['b':'c']#根据索引值切片选择元素obj[['a','c','d']]#根据多个索引值选择元素obj[[1,3]]#根据下标位置跳跃选择元素obj[obj<2]]#根据bool值选择元素，obj<2生成与obj相同长度的bool序列obj['b':'c'] = 5#赋值操作data = pd.DataFrame(np.arange(16).reshape((4, 4)), index=['Ohio', 'Colorado', 'Utah', 'New York'], columns=['one', 'two', 'three', 'four'])data['two'] #选择一列data[['two','three']] #选择多列data[:2] #切片代表选择前两行data[data['three'] > 5] #选择three列中所有的大于5的行data<5 #生成一个与data行列数相同的bool#DataFramedata[data<5] = 0 #根据条件对DataFrame赋值#使用loc和iloc选择元素data.loc['Colorado',['one','two']] #第一个元素代表行，第二个元素代表列，多个用列表标示data.iloc[2, [3, 0, 1]] #第一个数值代表行数，第二个数值代表列数，多个用列表标示data.loc[:'Utah', 'two'] data.iloc[:, :3][data.three > 5] #两次筛选，第一次筛选出前3列，第二次筛选出three列中待遇5的所有行1.pandas.DataFrame加减运算，遇Nan结果全部为Nan
df1.add(df2,fill_value=0) #出现Nan值填充为0
2.pandas.DataFrame和pandas.Series运算，如无指定按行运算，DataFrame的每一行分别与Seires进行运算
frame = pd.DataFrame(np.arange(12.).reshape((4, 3)),
columns=list('bde'),
index=['Utah', 'Ohio', 'Texas', 'Oregon'])
series3 = frame['d']
frame.sub(series3, axis='index') #指定运算的为按照列进行运算
3.pandas运算
#apply（f,axis=0）:，对一行或一列元素使用函数f(abs,sum)
#applymap: 对每一个DataFrame元素实施运算
#map:对每一个Series元素进行运算
#pandas排序
4.按照索引进行排序
obj.sort_index(axis=0，ascending=True) #按照行索引排序,升序
obj.sort_index(axis=1，ascending=False)#按照列索引排序,降序
5.按照值进行排序
obj.sort_values(axis=1) #按照值进行排序
obj.sort_values(by='a')#按照DataFrame的a列进行排序
obj.sort_values（by= ['a','b'])#按照DataFrame的a列排序，a列相同的按照b列排序
6.按照值进行排序，返回值对应的顺序
obj.rank() #相同值的按照平均值
obj.rank(axis= 0，method='first'，ascending=False)#遇到相同值时第一个排在前面，按照行进行排序,降序
7、判断索引值是否重复
obj.index.is_unique
8.统计计算
obj.sum()#所有元素相加
obj.sum（axis=1）#所有行元素相加
obj.cumsum()#累加
obj.descirbe()#描述Series或DataFrame的基本信息
obj.A.corr(obj.B)#求A,B列两列的相关系数
obj.A.cov(obj.B)#求A,B两列的协方差
8.去除重复值
obj.unique()
9.统计值的个数
obj.value_counts()
pd.value_counts(obj,sort=False)
10.判断是否包含在一个列表中
obj.isin(['a','b'])#生成一个boo类型的相同结构Series或DataFrame
11.获取索引位置
to_match = pd.Series(['c', 'a', 'b', 'b', 'c', 'a'])
unique_vals = pd.Series(['c', 'b', 'a'])
pd.Index(unique_vals).get_indexer(to_match) #get_indexer获取索引位置array([0, 2, 1, 1, 0, 2], dtype=int64)
一、处理空值
1、判断是否为控制
obj.isnull()判断对象中的元素是否为空，如果为空返回True,否则返回False
obj.notnul()判读对象中元素是否为空，如果为空返回False,否则返回True
2、删除空值
Seriesobj.dropna() 将序列中的空值删除
Seriesobj[Seriesobj.notnull()] 同上
DataFrameobj.dropna() 将df中包含空值的行全部删除
DataFrameobj[DataFrameobj.notnull()] 同上
DataFrameobj.dropna(how='all'|'any',axis=1|0,thresh=num) #all标示如果全部为空值则删除该行，any代表有一个就删除该行，不写how默认为any;axis代表判断行还是列,thresh代表空值个数为num的行
def dropna(self, axis=0, how='any', thresh=None, subset=None,inplace=False):Return object with labels on given axis omitted where alternately any or all of the data are missing
Parameters ----------
axis : {0 or 'index', 1 or 'columns'}, or tuple/list thereof Pass tuple or list to drop on multiple axes
how : {'any', 'all'} * any : if any NA values are present, drop that label * all : if all values are NA, drop that label
thresh : int, default None int value : require that many non-NA values
subset : array-like Labels along other axis to consider, e.g. if you are dropping rows these would be a list of columns to include
inplace : boolean, default False If True, do operation inplace and return None.
3、填充空值
df.fillna(value=None, method=None, axis=None, inplace=False, limit=None, downcast=None, **kwargs)
value:代表替换的值
inplace:代表是否将原来的df替换掉，默认为False即返回的是view
method = ffill| bfill 根据前值替换后来的nan,或根据后值替换
limit:限制向前或向后填充的个数
二、处理重复数据
1.判断是否重复
obj.duplicated() #如果该行与某一行数据完全一致，则为重复，返回一个相同行数的bool序列
2.删除重复值
obj.drop_duplicated() #默认删除完全相同的行
drop_duplicates(self, subset=None, keep='first', inplace=False):
subset :如['a']代表a列中的重复值全部被删除
keep:保留第一个值，参数为first,last
inplace:是否替换原来的df,默认为False
三、使用函数处理数据
1.大小写转换
df.str.lower() #所有字母转换为小写
df.str.upper() #所有字母转换为答谢
2、数据匹配转换
Seriesobj.map(self, arg, na_action=None):
arg:可以是Series,dict,function;
Series:与序列的索引相匹配，返回对应的序列的值
dict:与字典的键相匹配，返回对应的值
function:将函数作用于每一个元素，返回对应的值;可以使用lambda:x 函数
na_action：None不考虑Nan值，ignore：不管是否与为Nan，直接计算
3、数据替换
data.replace(to_replace=None, value=None, inplace=False, limit=None, regex=False, method='pad', axis=None)
to_replace:可以是字符串、数值、列表、正则表达式、字典、序列或者None
value:被替换值，可以为列表必须与to_replace列表长度一致，字典（字典对应的键将被替换为值）
regex :True代表to_replace用正则表达式标示
method:pad:全部替换
一、重命名索引值
DataFrameobj.rename(index=None, columns=None, **kwargs)
index=字典：索引与字典键相同的将被替换为值；函数名：对行索引执行函数
columns同index
inplace:True|False:是否替换原先的df
另一种方式：
df.index|columns = [ 列表] #直接替换为一个列表，列表长度与索引长度一致
df.index|columns = df.index|columns.map(Function) #对索引值使用函数进行转换
二、离散数据分组
1、普通分组:cut
cats = pd.cut(x, bins, right=True, labels=None, retbins=False, precision=3, include_lowest=False)
Return indices of half-open bins to which each value of `x` belongs.
x:必须是一维数据或series等arraylike对象
bins:整数：将x按照取值范围整分为相等的取值区间
序列：按照序列区间分隔x
right:True代表包含右边界，Fasle标示包含左边界
labels:被切分的值将不再以区间标示，而是替换为labels，labels的长度应该和取值区间个数一致
retbins :True返回区分的区间数组，Fasle不返回
priecison:区间取值的小数点个数
注意：如果x没有在bins的取值范围内，则返回Nan
cats.code:返回一个数组，代表x在bins出现的顺序
cats.categories:返回分组区间
pd.value_counts(cats)：返回分组的统计结果
2、等分:qcut
cats = pd.qcut(x, q, labels=None, retbins=False, precision=3, duplicates='raise')
q：整数：根据x的长度，将x等分为q份
：区间：代表等分的比例区间如【0,0.25,0.5,0.75,1】
三、检测和过滤极端值
DataFrameobj.describe():输出df对应的描述信息
df[(np.abs(df)>3).any(1)]:输出有数值大于3的df中的所有行
data[np.abs(data) > 3] = np.sign(data) * 3 ：np.sign（data）:针对每个元素如果大于0则结果为1,等于0结果为0,小于0结果为-1；将绝对值大于3的值转换为+3或-3
四、随机序列和抽样
1、sampler = np.random.permutation（x）
x:整数：代表随机生成一个np.arange(x)
序列：代表将给序列的顺序随机打乱
2.DataFrameobj.take(sampler)
按照sampler对DataFrameobj的行索引进行排序，sampler的长度必须和DataFrameobj的行索引index长度一致
3.DataFrameobj.sample(n=3)
随机取出DataFrameobj的三行
注意：n的值可以大于DataFrameobj的length，超过的将重复从DataFrameobj的行中取值
五、生成虚拟变量：又称虚设变量、名义变量或哑变量，是量化了的质变量，通常取值为0或1
pd.get_dummies(data, prefix=None, prefix_sep='_', dummy_na=False, columns=None, sparse=False, drop_first=False)
目的：将一个分类变量转变为一个虚拟矩阵，数值变量不转换。
data:可以是array,Series，DataFrame,
prefix:是否增加前缀
prefix_sep：与前缀之间的分隔符，默认为下划线
dummy_na：False:忽略Nan值，True,将Nan值单独作为一列标示。
注意:
df[columnname]:标示一个Series
df[[columnname]]:标示一个DataFrame
DataFrame可以用join函数进行拼接，而Series则不行
六。df拼接：join
df.join(other, on=None, how='left', lsuffix='', rsuffix='', sort=False)
将df 和other按列合并，
on:None代表是按照索引index进行匹配合并
columnsname:按照列进行合并，other列表需要将columnsname设置为索引set_index(columnsname)
how:left,right,outer,join:类似数据库操作
lsuffix:代表如果df和other有重名的columnname，则增加后缀在df
rsuffix:代表如果df和other有重名的columnname，则增加后缀在other
七、操作字符串
1.是否包含
obj.str.contains('str1'): 返回一个bool类型，如果包含str1返回True,否则返回False
2.查找
obj.str.findall(pattern,flags=re.IGNORECASE)
pattern:正则表达式
flags:是否忽略大小写
obj.str.match(pattern,flags=re.IGNORECASE)
返回一个bool数值
3.切片
obj.str[:5] #字符串前5个
obj.str.get(4)#获取第4个字符
obj.str[4] #获取第四个字符
一、多级索引
1、Series多级索引示例：
data = pd.Series(np.random.randn(9),index=[['a', 'a', 'a', 'b', 'b', 'c', 'c', 'd', 'd'],[1, 2, 3, 1, 3, 1, 2, 2, 3]])
a 1 -0.204708 2 0.478943 3 -0.519439 b 1 -0.555730 3 1.965781 c 1 1.393406 2 0.092908 d 2 0.281746 3 0.769023
2、将两级索引转换为一级索引形式的DataFrame
data.unstack()
3、将一个二维表格转换为高级索引Series
obj.stack()
4、DataFrame多级索引示例
frame = pd.DataFrame(np.arange(12).reshape((4, 3)),index=[['a', 'a', 'b', 'b'], [1, 2, 1, 2]],columns=[['Ohio', 'Ohio', 'Colorado'],['Green', 'Red', 'Green']])
5、给索引添加名称
frame.index.names = ['key1', 'key2'] #一级行索引名称为key1,二级行索引名称为key2
frame.columns.names=['state', 'color'] #一级列索引名称为state,二级列索引名称为color
6、索引互换位置
frame.swaplevel(i=-2, j=-1, axis=0)
#适用于两级索引的位置互换，i和j可以传入int,或者String(索引名称），axis=0：代表行索引互换，axis=1代表列索引位置互换
7、索引排序
frame.sort_index(axis=0, level=None, ascending=True, inplace=False, kind='quicksort', na_position='last', sort_remaining=True, by=None)
axis:对行索引还是列索引进行排序
level:对第几级别索引进行排序
ascending:升序还是降序
inplace:view还是inplace
8、将列索引设置为行索引
frame.set_index(keys, drop=True, append=False, inplace=False, verify_integrity=False)
keys:列标签或列标签列表
drop:删除已经作为行标签的keys对应的列
append:是否将keys添加到现有的index后面
9、将多级行索引变为列索引
frame.reset_index()
二、数据表合并
1.merge
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'), copy=True, indicator=False)
left:左边表格
right:右边表格
how:inner:取交集，outer:并集；left:参照左边表格行，right:参照右边表格行
on:当left和right有相同的列名时，默认按照相同的列名进行合并，可以指定一个列表，当表格中有两个以上相同的列名时。
left_on和right_on:分别指定左边表格参照列和右边表格参照列，适用于参照列名称不一致的情况。可以为列表，对应的对方表格中也必须是列表或多级索引。
suffixes：是否添加后缀，如果left和right有相同的列名时添加后缀
left_index和right_index:当使用列名匹配索引时使用。是left_on和right_on的特殊情况。
2.join
left.join(right, on=None, how='left', lsuffix='', rsuffix='', sort=False)
join是merge的一种特殊形式.所有功能可以用merge来实现。
#默认left和right 以相同的索引连接
#on：可以指定相同的列名或列名组成的元祖或列表
#how:同merge
#lsuffix和rsuffix代表相同列名添加的后缀
3.concatnate连接
pd.concat(objs, axis=0, join='outer', join_axes=None, ignore_index=False, keys=None, levels=None, names=None, verify_integrity=False, copy=True)
功能：沿着设定的轴线连接两个表格
objs:需要连接的对象序列，用列表标示
axis:沿着index或者columns
join:outer,inner
join_axes:指定连接的索引列表，形式为[[ ]],用于代替join的inner或者outer
keys:通常为一个列表，构造一个高级索引，keys作为指定obj的高级索引，通常和objs个数一致。
names:指定高级索引对应的名称
ignore_index:是否忽略索引，默认为Fasle,合并过程中各自保留原来的索引值，True:使用新的索引从0到n-1
4、重叠数据的合并
where(condition, [x, y]):例：np.where(pd.isnull(a),a,b)
condition：arraylike,bool;
x,y：arraylike,与condition长度一致，如果为真返回x,否则y,
obj1.combine_first(obj2):如果obj1对应位置有数据（不为nan）使用obj1的数据，否则使用obj2的数据
一、重命名索引值
DataFrameobj.rename(index=None, columns=None, **kwargs)
index=字典：索引与字典键相同的将被替换为值；函数名：对行索引执行函数
columns同index
inplace:True|False:是否替换原先的df
另一种方式：
df.index|columns = [ 列表] #直接替换为一个列表，列表长度与索引长度一致
df.index|columns = df.index|columns.map(Function) #对索引值使用函数进行转换
二、离散数据分组
1、普通分组:cut
cats = pd.cut(x, bins, right=True, labels=None, retbins=False, precision=3, include_lowest=False)
Return indices of half-open bins to which each value of `x` belongs.
x:必须是一维数据或series等arraylike对象
bins:整数：将x按照取值范围整分为相等的取值区间
序列：按照序列区间分隔x
right:True代表包含右边界，Fasle标示包含左边界
labels:被切分的值将不再以区间标示，而是替换为labels，labels的长度应该和取值区间个数一致
retbins :True返回区分的区间数组，Fasle不返回
priecison:区间取值的小数点个数
注意：如果x没有在bins的取值范围内，则返回Nan
cats.code:返回一个数组，代表x在bins出现的顺序
cats.categories:返回分组区间
pd.value_counts(cats)：返回分组的统计结果
2、等分:qcut
cats = pd.qcut(x, q, labels=None, retbins=False, precision=3, duplicates='raise')
q：整数：根据x的长度，将x等分为q份
：区间：代表等分的比例区间如【0,0.25,0.5,0.75,1】
三、检测和过滤极端值
DataFrameobj.describe():输出df对应的描述信息
df[(np.abs(df)>3).any(1)]:输出有数值大于3的df中的所有行
data[np.abs(data) > 3] = np.sign(data) * 3 ：np.sign（data）:针对每个元素如果大于0则结果为1,等于0结果为0,小于0结果为-1；将绝对值大于3的值转换为+3或-3
四、随机序列和抽样
1、sampler = np.random.permutation（x）
x:整数：代表随机生成一个np.arange(x)
序列：代表将给序列的顺序随机打乱
2.DataFrameobj.take(sampler)
按照sampler对DataFrameobj的行索引进行排序，sampler的长度必须和DataFrameobj的行索引index长度一致
3.DataFrameobj.sample(n=3)
随机取出DataFrameobj的三行
注意：n的值可以大于DataFrameobj的length，超过的将重复从DataFrameobj的行中取值
五、生成虚拟变量：又称虚设变量、名义变量或哑变量，是量化了的质变量，通常取值为0或1
pd.get_dummies(data, prefix=None, prefix_sep='_', dummy_na=False, columns=None, sparse=False, drop_first=False)
目的：将一个分类变量转变为一个虚拟矩阵，数值变量不转换。
data:可以是array,Series，DataFrame,
prefix:是否增加前缀
prefix_sep：与前缀之间的分隔符，默认为下划线
dummy_na：False:忽略Nan值，True,将Nan值单独作为一列标示。
注意:
df[columnname]:标示一个Series
df[[columnname]]:标示一个DataFrame
DataFrame可以用join函数进行拼接，而Series则不行
六。df拼接：join
df.join(other, on=None, how='left', lsuffix='', rsuffix='', sort=False)
将df 和other按列合并，
on:None代表是按照索引index进行匹配合并
columnsname:按照列进行合并，other列表需要将columnsname设置为索引set_index(columnsname)
how:left,right,outer,join:类似数据库操作
lsuffix:代表如果df和other有重名的columnname，则增加后缀在df
rsuffix:代表如果df和other有重名的columnname，则增加后缀在other
七、操作字符串
1.是否包含
obj.str.contains('str1'): 返回一个bool类型，如果包含str1返回True,否则返回False
2.查找
obj.str.findall(pattern,flags=re.IGNORECASE)
pattern:正则表达式
flags:是否忽略大小写
obj.str.match(pattern,flags=re.IGNORECASE)
返回一个bool数值
3.切片
obj.str[:5] #字符串前5个
obj.str.get(4)#获取第4个字符
obj.str[4] #获取第四个字符
一、多级索引
1、Series多级索引示例：
data = pd.Series(np.random.randn(9),index=[['a', 'a', 'a', 'b', 'b', 'c', 'c', 'd', 'd'],[1, 2, 3, 1, 3, 1, 2, 2, 3]])
a 1 -0.204708 2 0.478943 3 -0.519439 b 1 -0.555730 3 1.965781 c 1 1.393406 2 0.092908 d 2 0.281746 3 0.769023
2、将两级索引转换为一级索引形式的DataFrame
data.unstack()
3、将一个二维表格转换为高级索引Series
obj.stack()
4、DataFrame多级索引示例
frame = pd.DataFrame(np.arange(12).reshape((4, 3)),index=[['a', 'a', 'b', 'b'], [1, 2, 1, 2]],columns=[['Ohio', 'Ohio', 'Colorado'],['Green', 'Red', 'Green']])
5、给索引添加名称
frame.index.names = ['key1', 'key2'] #一级行索引名称为key1,二级行索引名称为key2
frame.columns.names=['state', 'color'] #一级列索引名称为state,二级列索引名称为color
6、索引互换位置
frame.swaplevel(i=-2, j=-1, axis=0)
#适用于两级索引的位置互换，i和j可以传入int,或者String(索引名称），axis=0：代表行索引互换，axis=1代表列索引位置互换
7、索引排序
frame.sort_index(axis=0, level=None, ascending=True, inplace=False, kind='quicksort', na_position='last', sort_remaining=True, by=None)
axis:对行索引还是列索引进行排序
level:对第几级别索引进行排序
ascending:升序还是降序
inplace:view还是inplace
8、将列索引设置为行索引
frame.set_index(keys, drop=True, append=False, inplace=False, verify_integrity=False)
keys:列标签或列标签列表
drop:删除已经作为行标签的keys对应的列
append:是否将keys添加到现有的index后面
9、将多级行索引变为列索引
frame.reset_index()
二、数据表合并
1.merge
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'), copy=True, indicator=False)
left:左边表格
right:右边表格
how:inner:取交集，outer:并集；left:参照左边表格行，right:参照右边表格行
on:当left和right有相同的列名时，默认按照相同的列名进行合并，可以指定一个列表，当表格中有两个以上相同的列名时。
left_on和right_on:分别指定左边表格参照列和右边表格参照列，适用于参照列名称不一致的情况。可以为列表，对应的对方表格中也必须是列表或多级索引。
suffixes：是否添加后缀，如果left和right有相同的列名时添加后缀
left_index和right_index:当使用列名匹配索引时使用。是left_on和right_on的特殊情况。
2.join
left.join(right, on=None, how='left', lsuffix='', rsuffix='', sort=False)
join是merge的一种特殊形式.所有功能可以用merge来实现。
#默认left和right 以相同的索引连接
#on：可以指定相同的列名或列名组成的元祖或列表
#how:同merge
#lsuffix和rsuffix代表相同列名添加的后缀
3.concatnate连接
pd.concat(objs, axis=0, join='outer', join_axes=None, ignore_index=False, keys=None, levels=None, names=None, verify_integrity=False, copy=True)
功能：沿着设定的轴线连接两个表格
objs:需要连接的对象序列，用列表标示
axis:沿着index或者columns
join:outer,inner
join_axes:指定连接的索引列表，形式为[[ ]],用于代替join的inner或者outer
keys:通常为一个列表，构造一个高级索引，keys作为指定obj的高级索引，通常和objs个数一致。
names:指定高级索引对应的名称
ignore_index:是否忽略索引，默认为Fasle,合并过程中各自保留原来的索引值，True:使用新的索引从0到n-1
4、重叠数据的合并
where(condition, [x, y]):例：np.where(pd.isnull(a),a,b)
condition：arraylike,bool;
x,y：arraylike,与condition长度一致，如果为真返回x,否则y,
obj1.combine_first(obj2):如果obj1对应位置有数据（不为nan）使用obj1的数据，否则使用obj2的数据
一、数据转置
1.索引转置
obj.stack(level='levelname|levelnum'',drop_na=False)
obj.unstack(level='levelname|levelnum',dropna=False)
2.列转置为索引
obj.pivot(index=None, columns=None, values=None)
index:string ,列名作为索引
columns:string,列名作为列
values:列名作为值
3、索引转为列变量
pd.melt(frame, id_vars=None, value_vars=None, var_name=None, value_name='value', col_level=None)
frame:DataFrame
id_vars:作为索引列,通常为非数据列
value_vars:作为变量列，通常为数据列
var_name:变量列名称，如果为None则为variable
value_name:默认为value
一、分组
1.groupby
obj.groupby(by=None, axis=0, level=None, as_index=True, sort=True, group_keys=True, squeeze=False, **kwargs)
# 返回一个pandas分组可迭代对象，包含（name,group）两个要素，可以是否for循环迭代输出
by:fuction:计算obj的index进行分组；
str|strs:使用obj的columns进行分组
dict|Series：key和索引相匹配，使用vlues进行分组
axis:0|1代表按照行还是列进行分组
level:levelnum|levelname,适用于多级索引情况下，按照指定的索引进行分组
as_index:True使用分组标签作为索引，不作为索引，而是作为一列，类似于excel数据透视表中的填充行。
sort：保留原来行的顺序
group_keys:True当调用apply时保留分组名称，False不保留分组的名称
# grouped数据可以使用列名【‘列名’】来去除该列数据然后再对该列进行聚类分析计算
二、聚类
grouped.quantile(0.9):寻找九分位
grouped.count():统计分组的个数
grouped.sum()：对分组数据进行求和
grouped.mean()：对分组数据进行平均值
grouped.describe():对分组数据进行简单统计描述
grouped.agg(functon):对分组数据按照function进行聚类，function可以是一个列表，代表使用多种方法进行聚类分析计算，列名为function名称；
如果想用其他 名称替换function的名称做为列名，可以使用列表+元组，（altername,functionname）;示例：grouped['tip_pct', 'total_bill'].agg([('Durchschnitt', 'mean'), ('Abweichung', np.var)])
如果想对不同的列使用不同的方法，可以使用字典的形式，{列名：【func1,func2】}示例：grouped.agg({'tip_pct' : ['min', 'max', 'mean', 'std'],'size' : 'sum'})
grouped.apply(function,args):适用于有参数的function,可以将function的参数作为apply的参数传入，或者使用lambda函数。agg应用于无参数函数如min,max,count,np.var等聚合函数
agg和apply的区别：agg聚合只不过是分组运算的其中一种而已。它是数据转换的一个特例，也就是说，它接受能够将一维数组简化为标量值的函数。apply更普遍如排序，分组，计算，聚合。
一、结合离散数据分隔使用
对离散数据进行切割后，然后作为分组依据。
obj.groupby(pd.cut(obj['a'],4)
二、分组统计应用示例
1.用统计值填充
data.groupby(group_key).apply(lambda g: g.fillna(g.mean())) #使用平均值填充该组的缺失值
2.用固定值进行填充
fill_values = {'East': 0.5, 'West': -1}
fill_func = lambda g: g.fillna(fill_values[g.name])
data.groupby(group_key).apply(fill_func)
3.用于分组随机抽样
def draw(deck, n=5):return deck.sample(n) #对一副牌随机抽取n张，deck是一个Series，索引为花色和name,value为值
get_suit = lambda card: card[-1] #获取牌的花色
deck.groupby(get_suit, group_keys=False).apply(draw, n=2) #按照花色分组并随机抽取2张扑克
4.分组计算权重平均值
grouped.apply(lambda g: np.average(g['data'], weights=g['weights'])) #按照权重计算分组的平均值
5.分组计算相关系数
get_year = lambda x: x.year #取得年度
by_year = rets.groupby(get_year)#按年分组
by_year.apply(lambda g: g['AAPL'].corr(g['MSFT']))#计算按年分组的相关系数
三、数据透视表(pivot_table)
obj.pivot_table(values=None, index=None, columns=None, aggfunc='mean', fill_value=None, margins=False, dropna=True, margins_name='All')
values:需要聚合的数据列
index:需要聚合的索引列，可以是列表，标示多个索引会生成多级索引
columns:需要聚合的列索引，可以是列表，会生成多级索引
aggfunc:默认为平均值，也可以选择一个函数列表，计算多个聚合数据
dropna:True 忽略nan值
fill_value:缺失数据填充
margins:True添加合计行和合计列数据（all），False则不添加
margins_name:默认合计行、合计列名称为all
四、跨表组合
pd.crosstab(index, columns, values=None, rownames=None, colnames=None, aggfunc=None, margins=False, dropna=True, normalize=False)
index:行索引
columns:列索引
values:值
rownames:行索引名称，与行索引个数相同
colnames:列索引名称，与列索引个数相同
margins:是否添加all汇总数据
aggfunc:汇总函数
一、创建时间序列
1.使用pd.to_datetime
datestrs = ['2011-07-06 12:00:00', '2011-08-06 00:00:00']
pd.to_datetime(arg, errors='raise', dayfirst=False, yearfirst=False, utc=None, box=True, format=None, exact=True, unit=None, infer_datetime_format=False, origin='unix')
arg:整数，浮点、字符串、datetime，列表，元组，1维数组，Seires
errors:raise:转换出错时报错，coerce:转换出错时为NaT,ignore:不转换，仍旧为原始输入
dayfirst:是否以天为开始
yearfirst:是否以年为开始
utc:返回utc时间
box:True:返回DatetimeIndex，False:返回一个ndarray of values
format:字符串的格式
exact:是否严格匹配format
unit:计算距离开始时间的现实格式，默认为ns,可以ms
infer_datetime_format:快速转换
origin:开始时间
2.使用pd.daterange:f
#返回一个固定频率的时间序列
pd.date_range(start=None, end=None, periods=None, freq='D', tz=None, normalize=False, name=None, closed=None, **kwargs)
start:字符串或者是时间,时间序列的开始
end:字符串或者是时间,时间序列的结尾
periods:整数，时间序列出现的期数
freq:时间频率，默认为天‘D’,可以是小时‘H’,‘3H’,'Y,'M‘等
tz:字符串，时区名称如：asia/hongkong
name:返回时间序列的名称
normalize：是否转换为标准的0点开始
3.非固定频率时间序列转换为固定时间序列
ts.resample(rule, how=None, axis=0, fill_method=None, closed=None, label=None, convention='start', kind=None, loffset=None, limit=None, base=0, on=None, level=None)
#返回的是一个分组的数据
rule:字符串，转换的频率，‘D’，‘A-DEC’
axis:转换的轴，默认为0
fill_method:ffill,bfill
closed:left,right:开闭区间
label:left,right
convention:‘start’开始，‘end’:结束
on:选择列
kind:period表示时期序列，timestamp代表时间搓序列
resample()+特殊方法
#ohlc#查询股票价格
obj.resample('year').ohlc()
#asfreq()
obj.resample('D').asfreq()#转换为按天列示的df
#ffill
obj.resample('D).ffill() #转换为按天列示的df,并且向前填充
#
二、时间序列操作
1.时间序列类型
ts.index:DatetimeIndex
ts.index.dtype:dtype('<M8[ns]')
ts.index[0]:Timestamp
2.时间序列索引选择
选取一个值
ts['1/10/2011']
ts['20110110']
ts['2011-01-10']
都指向同一个值
选取多个值：
选取固定区间
ts['2011']:会选择整个2011年度的所有值作为返回
ts['2011-5']：会选择2011年5月的所有值作为返回
自定义区间：
ts[datetime(2011,5,1):]:选择5月1日之后的所有值作为返回
ts:['20110501','2011-7-2']选择2011年5月1日到2011年7月2日之间的值作为返回
使用函数截取：
ts.truncate(before=None, after=None, axis=None, copy=True)
before:在*之前
after:在*之后
copy:True:返回一个copy，否则返回一个veiw
DataFrame时间截取：
df.loc['2011-5']:截取五月份的所有数据
#时间序列可以重复
df.index.is_unique()：判读索引是否重复
#按照重复的时期分组
df.groupby(level=0):按照时间序列分组
3.时间序列的计算
偏移：shift
ts.shift(periods=1,freq=None,axis=0)
periods:偏移数量
freq:取None时代表value的偏移，为固定频率时代表时间序列的偏移距离
from pandas.tseries.offsets import Day,Minute,Hour,MonthEnd
datetime.datetime.now()+3*Day()：向后三天
now+MonthEnd（） =月底时间 相当于：MonthEnd().rollforward(now)
now+MonthEnd(2):下月底时间 相当于MonthEnde().rollback(now)
MonthEnd可以将当月所有的日期转换为最后一天，用于分组求当月的聚合
结果等于：ts.resample('M').mean()
4.时区设置和转换
#时间序列未指定时区前是没有时区的
ts_utc = ts.tz_localize('UTC'):设置时区为UTC
ts_New_York = ts_utc.tz_convert('America/New_York'):转换utc时间为纽约时间
时区转换并没有改变其value值
ts_utc.value == ts_New_York.value
#不同时区间时间序列的操作，会首先都转换为UTC时间然后再进行操作
三、时期的操作
1.时期及时期序列的生成
p = pd.Period('2007',freq='A-DEC')：以每年的12月份为结束，代表2007年
rng = pd.period_range(start,end,freq='M')，代表月度时期序列
2.时期的转换
p = pd.Period('2007', freq='A-DEC')
p代表2007年度
p_q = pd.Period('2007Q4',freq='Q-jun')
p_q:代表第四季度：
p_m = p.asfreq('M',how='start')
p转换为2017年1月
p-y = p_m.asfreq('A-JUN')：
月度转换为年度，需要指定年度结束时间
p_d = p_m.asfreq('B','s')
月度转换为日期，为该月的开始时间
p_t = p_d.asfreq('T','s')
天转换为时间
p.to_timestamp() #转换为时间错
#时间搓转换为时期
p.to_period('M') #转换为月度
#转换为时期序列
pd.PeriodIndex(year=data.year, quarter=data.quarter,freq='Q-DEC')
一、分类
1.使用转换函数：astype('category')
df['fruit'] = df['fruit'].astype('category')
2.直接创建分组
方式一：
my_categories = pd.Categorical(['foo', 'bar', 'baz', 'foo', 'bar'])
方式二：
categories = ['foo', 'bar', 'baz']
codes = [0, 1, 2, 0, 0, 1]
my_cats_2 = pd.Categorical.from_codes(codes, categories，ordered=True)
二、分类计算
category在计算过程中会有更好的表现。
cat_s.cat.codes ：分类的编码，用数字表示分类数据
cat_s.cat.categories：分的类别
cat_s.cat.set_categories:重新设定分类标准
actual_categories = ['a', 'b', 'c', 'd', 'e']
cat_s2 = cat_s.cat.set_categories(actual_categories)
cat_s.value_counts()：统计值的个数
cat_s3 = cat_s[cat_s.isin(['a', 'b'])] ：分类筛选
cat_s3.cat.remove_unused_categories()：删除无用的分类
pd.get_dummies(cat_s)：创建分类虚拟矩阵
三、group.transform(Function)
#作用：分组数据每一个数据都显示运行的结果。如求平均值，则每组的每个值都显示平均值
四、时间序列分组
方式一：
df.set_index('time').resample('5min').count()
方式二：
time_key = pd.TimeGrouper('5min')
resampled = (df2.set_index('time').groupby(['key', time_key]).sum())
五、连续的方法操作
方式一：
result = (load_data()[lambda x: x.col2 < 0].assign(col1_demeaned=lambda x: x.col1 - x.col1.mean()).groupby('key').col1_demeaned.std())
可以使用【lambda函数筛选行】和assign增加赋值列来减少中间的环节
方式二：pip函数：将上一个计算结果传入下一个pip中
def group_demean(df, by, cols):
result = df.copy()
g = df.groupby(by)
for c in cols:
result[c] = df[c] - g[c].transform('mean')
return result
result = (df[df.col1 < 0].pipe(group_demean, ['key1', 'key2'], ['col1']))
#pandas索引操作#1.获取索引obj = pd.Series(range(3), index=['a', 'b', 'c'])index= obj.index #获取序列索引labels = pd.Indext(range(3)) #使用pd.Index建立索引obj2 = pd.Series([1.5, -2.5, 0], index=labels)obj2.index is labels #True#2.判断索引中是否包含某元素‘a’ in obj.indexpop = {'Nevada': {2001: 2.4, 2002: 2.9},'Ohio': {2000: 1.5, 2001: 1.7, 2002: 3.6}}frame3 = pd.DataFrame(pop)'Ohio' in frame3.columns'2001' in frame3.index#3.索引值可以重复dup_labels = pd.Index(['foo', 'foo', 'bar', 'bar']) |
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
|
#pandas 重要的函数#1.reindex #重新索引obj = pd.Series([4.5, 7.2, -5.3, 3.6], index=['d', 'b', 'a', 'c'])obj2 = obj.reindex(['a', 'b', 'c', 'd', 'e']) #e 对应的元素为Nan,按照重新定义的索引顺序显示obj3 = pd.Series(['blue', 'purple', 'yellow'], index=[0, 2, 4])obj3.reindex(range(6), method='ffill') #对于空的索引1,3,5的值根据前值填充,bfill向后填充frame = pd.DataFrame(np.arange(9).reshape((3, 3)), index=['a', 'c', 'd'], columns=['Ohio', 'Texas', 'California'])frame2 = frame.reindex(['a','b','c','d']) #b行为空,增加新行states = ['Texas', 'Utah', 'California']frame.reindex(columns=states) #增加新列Utah,列值为Nanframe.loc[['a','b','c','d'],states] #选择所有的行和states所对应的列#2.drop删除元素obj = pd.Series(np.arange(5.), index=['a', 'b', 'c', 'd', 'e'])new_obj = obj.drop('c') #根据索引删除元素data = pd.DataFrame(np.arange(16).reshape((4, 4)), index=['Ohio', 'Colorado', 'Utah', 'New York'], columns=['one', 'two', 'three', 'four'])data.drop(['Colorado', 'Ohio']) #删除Colorado和Ohio行data.drop('two',axis=1) #删除一列data.drop(['two','three'],axis=columns) #删除两列#3.选择和筛选元素obj = pd.Series(np.arange(4.), index=['a', 'b', 'c', 'd'])obj['b'] #根据索引选择元素obj[1]#根据下标位置选择元素obj[2:4]#根据下标位置切片选择元素obj['b':'c']#根据索引值切片选择元素obj[['a','c','d']]#根据多个索引值选择元素obj[[1,3]]#根据下标位置跳跃选择元素obj[obj<2]]#根据bool值选择元素，obj<2生成与obj相同长度的bool序列obj['b':'c'] = 5#赋值操作data = pd.DataFrame(np.arange(16).reshape((4, 4)), index=['Ohio', 'Colorado', 'Utah', 'New York'], columns=['one', 'two', 'three', 'four'])data['two'] #选择一列data[['two','three']] #选择多列data[:2] #切片代表选择前两行data[data['three'] > 5] #选择three列中所有的大于5的行data<5 #生成一个与data行列数相同的bool#DataFramedata[data<5] = 0 #根据条件对DataFrame赋值#使用loc和iloc选择元素data.loc['Colorado',['one','two']] #第一个元素代表行，第二个元素代表列，多个用列表标示data.iloc[2, [3, 0, 1]] #第一个数值代表行数，第二个数值代表列数，多个用列表标示data.loc[:'Utah', 'two'] data.iloc[:, :3][data.three > 5] #两次筛选，第一次筛选出前3列，第二次筛选出three列中待遇5的所有行 |
浙公网安备 33010602011771号