from pandas import Series,DataFrame
import pandas as pd
import numpy as np
# Series 由numpy数据和数据标签组成,默认整形索引0->N-1
#创建方法:列表,ndarray,字典
#属性:values,index(可就地修改,若添加新索引,相应值为NAN),name,index.name
#检查缺失值:isnull,notnull,返回bool类型的Series对象
#访问:index索引
#计算:numpy数组计算(自动给对齐索引数据)
obj=Series(np.array([1,2,3]))
print(obj)
print(obj.values,type(obj.values))
print(obj.index,type(obj.index))
obj2=Series(np.array([1,2,3,4]),index=['a','b','c','d'])
print(obj2)
print(obj2.index)
obj2.index=['w','a','s','d']#就地修改索引
print(obj2)
obj2.index=['a','b','c','d']
print(obj2)
#与字典的联系:Series相当于有序字典
heros={'Thor':1000,"Iron man":666,"Hulk":321}
obj3=Series(heros)
print(obj3)
print("Thor" in obj3,"Me" in obj3)
obj4=Series(heros,index=['Thor','Hulk','Loki'])
print(obj4)
#检测缺失值
print(pd.isnull(obj4))
print(pd.notnull(obj4))
#数据的存取与字典类似,通过个别数据标签或数据标签列表
print(obj2['a'])
obj2['a']=100
print(obj2[['c','b','a']])
print(obj2[3])#也可通过默认的整数index
#数组运算:与numpy的相关运算相同,保留标签
#自动对齐索引数据进行运算
print(obj2[obj2>1.5]*2)
obj5=Series(np.array([2,3,4,5]),index=['b','c','d','e'])
print(obj2)
print(obj5)
print(obj2*obj5)
#Series的name属性
obj4.name="Heros"
obj4.index.name="Hero name"
print(obj4)
#Dataframe:表格型,Series组成的字典
#创建Dataframe:等长列表或numpy数组组成的字典或二维ndarray;可用columns指定列顺序,index指定索引
#找不到的列和行设为nan,或嵌套字典
#可获取一列作为一个Series对象,name就是相应的column,索引与原DataFrame相同
#也可以直接为某一列赋值:标量,等长ndarray,Series(自动匹配索引),布尔list
#属性:columns,index,value
#索引对象:Index(immutable,不可修改)
#pandas对象的重要方法:reindex(如果对DataFrame只传入一个序列则会重新索引行)
#丢弃指定轴上的项;drop(Series:直接写删掉的索引列表,DataFrame:利用axis)
#索引:iloc,loc
data={'name':['peter','tony','mark','Dave'],'age':[15,12,16,94],'sex':[1,0,1,1]}
obj=DataFrame(data)
print(obj)
obj2=DataFrame(data,columns=['name','age','sex','salary'],index=['one','two','three','four'])
print(obj2)
obj2.index=[1,2,3,4]
print(obj2)
#访问行列数据
print(obj2.name,obj2['age'])
print(obj2.iloc[2])
#修改列的值:数组,列表 or Series
#数组或列表要符合长度
obj2.salary=[100,100,100,200]
print(obj2)
obj2.salary=np.arange(4)*100
print(obj2)
#Series对应索引
s=Series(np.arange(4)*100,index=[2,3,1,4])
obj2.salary=s
print(obj2)
#为不存在的列赋值会出现新列
obj2.high=obj2.salary>150
print(obj2)
del obj2.high
#嵌套字典(外层键作为列,内层键作为索引)
data={'name':{'one':'Peter','Two':"Tony"},'age':{'Two':"40",'three':"1000"}}
obj=DataFrame(data)
print(obj)
print(obj.T)
#嵌套字典会对索引进行排序,可指定索引
obj=DataFrame(data,index=['one','Two'])
print(obj)
obj.columns.name='attri'
obj.index.name='index'
print(obj)
#索引对象(不可修改)
index=pd.Index(np.arange(4))
obj=pd.Series(np.arange(4)*10,index=index)
print(obj)
index[1]=100
#方法与属性
"""
append 连接另一个Index对象,产生一个新的Index
diff 计算差集,并得到一个Index
intersection 计算交集
union 计算并集
isin 计算一个指示各值是否都包含在参数集合中的布尔型数组
delete 删除索引i处的元素,并得到新的Index
drop 删除传入的值,并得到新的Index
insert 将元素插入到索引i处,并得到新的Index
is_monotonic 当各元素均大于等于前一个元素时,返回True
isunique Index没有重复值时,返回True
unique 计算Index中唯一值的数组
"""
#reindex
obj=Series(np.arange(5),index=['a','b','c','d','e'])
obj2=obj.reindex(['e','b','a','c','d'])
print(obj)
print(obj2)
obj2=obj.reindex(['e','b','a','c','f'],fill_value=100)
print(obj2)
obj=Series(['one','two','three'],index=[1,3,5])
#前向填充
obj2=obj.reindex(np.arange(1,7),method='ffill')
print(obj2)
obj2=obj.reindex(np.arange(1,7),method='pad')
print(obj2)
#后向填充
obj2=obj.reindex(np.arange(1,7),method='bfill')
print(obj2)
obj2=obj.reindex(np.arange(0,6),method='bfill')
print(obj2)
obj2=obj.reindex(np.arange(0,6),method='backfill')
print(obj2)
#可用于时间序列的插值处理
#同样适用于DataFrame
obj3=pd.DataFrame(np.arange(9).reshape((3,3)),index=['row1','row2','row3'],columns=['col1','col2','col3'])
print(obj3)
obj4=obj3.reindex(index=['row2','row4','row1','row5'],columns=['col1','col4','col3','col5','col2','col6'],method='ffill')
print(obj4)
#drop
obj3=pd.DataFrame(np.arange(9).reshape((3,3)),index=['row1','row2','row3'],columns=['col1','col2','col3'])
print(obj3)
obj4=obj3.drop('row1')#删除行
print(obj4)
obj5=obj3.reindex(index=['row2','row1','row3'])
obj5=obj5.drop(['row1','row3'])#删除行
print(obj5)
obj6=obj3.drop('col2',axis=1)#删除列
print(obj6)
obj7=obj3.drop(['col1','col3'],axis=1).drop('row2',axis=0)#同时操作
print(obj7)
#Series的索引与numpy类似
obj=Series(np.arange(4),index=['a','b','c','d'])
print(obj)
print(obj[1],'\n',obj[1:3],'\n',obj[[1,3]])#默认整数序号
print(obj['a'],'\n',obj[['a','c']],'\n',obj['a':'d'])#索引切片(包含最后一个)
print(obj[obj>2.5])#布尔数组
print(obj>2.5,type(obj>2.5))
#DataFrame
data=DataFrame(np.arange(9).reshape((3,3)),index=['r1','r2','r3'],columns=['c1','c2','c3'])
print(data)
print(data[['c3','c1']])#选取列
print(data[0:2])#整数索引选取行
print(data[data['c2']>1.5])#一维布尔数组选取行
print(data>5)#二维布尔数全选
print(data[data>5])
data[data>5]=1.2
print(data)
#利用索引标签,选取行与列的子集
#iloc只接受整数,布尔(基于位置)
print(data.iloc[list(data.c1>1.2),0:2])
#loc:基于标签
print(data.loc[['r1','r2'],['c1','c3']])
#ix:0.20之后不建议使用,最新版直接没有这个attribute
print(data.ix['r1','c1'])
#基本功能
# Series:
#它可以对不同索引的对象进行算术运算。在将对象相加时, 如果存在不同的索引对,则结果的索引就是该索引对的并集。
#自动的数据对齐操作在不重叠的索引处引入na值。缺失值会在算术运算过程中传播。
s1=Series(np.arange(4),index=['a','b','c','d'])
s2=Series(np.arange(1,5),index=['b','c','d','e'])
print(s1+s2)
#DataFrame
#对于DataFrame,对齐操作会同时发生在行和列上
d1=DataFrame(np.arange(9).reshape(3,3),index=list('abc'),columns=list('ABC'))
d2=DataFrame(np.arange(1,10).reshape(3,3),index=list('bcd'),columns=list('BCD'))
print(d1+d2)
#为了处理出现nan的情况,将缺失值填补上(用法同reindex的fill_value)
print(d1.add(d2.iloc[0:2,0:2],fill_value=0))
#DataFrame与Series之间的运算(广播机制)
# 默认情况下,DataFrame和Series之间的算术运算会将Series的索引匹配到DataFrame的列,然后沿着行一直向下广播.
d3=d1.add(d2.iloc[0:2,0:2],fill_value=0)
s=d3.loc['a',:]
print(d3-s)
#如果某个索引值在DataFrame的列或Series的索引中找不到,则参与运算的两个对象就会被重新索引以形成并集:
s2=Series([1,2,3],index=list('BDE'))
print(d3+s2)#只会在两者都有的索引上进行运算
#排序和排名
#根据条件对数据集排序(sorting)也是一种重要的内置运算。要对行或列索引进行排序 (按字典顺序),可使用sort_index方法,它将返回一个已排序的新对象:
print(s.sort_index())
print(d3.sort_index(axis=1))
print(d3.sort_index(axis=0,ascending=False))
#若要按值对Series,DataFrame进行排序,可使用其order方法:
a=Series(np.random.randint(0,10,size=4),index=list('abcd'))
print(a)
print(a.sort_values())
print(d3.sort_values(by='A',ascending=False))
#排名(ranking)跟排序关系密切,且它会增设一个排名值(从1开始,一直到数组中有 效数据的数量)。它跟numpy.argsort产生的间接排序索引差不多,只不过它可以根据某种规则破坏平级关系。Series和DataFrame的rank方法:默认情况下,rank是通过“为各组分配一个平均排名”的方式破坏平级关系的:
#Series.rank(axis=0,method='average',numeric_only=None,na_option='keep',ascending=True/非零值,pct=False)
s=Series(np.random.randint(0,10,size=15))
print(s,'\n',s.rank(ascending=False))
#method:average(相等分组中用平均排名),min(相等分组中用最小排名)
#max(相等分组中用最大排名) first(按值在原始数据中的出现顺序分配排名)
print(s.rank(ascending=False,method='min'))
print(s.rank(ascending=False,method='max'))
print(s.rank(ascending=False,method='first'))
#对于DataFrame只需添加axis确定排名的轴即可
print(d3,'\n',d3.rank(axis=0))
#带有重复值的轴索引,索引的is_unique属性验证是否是唯一的
s=Series(np.arange(9),index=list('aaabbbccc'))
print(s,'\n',s['a'])
print(s.index.is_unique)
#汇总和计算描述统计
#pandas对象拥有一组常用的数学和统计方法。它们大部分都属于约简和汇总统计,用于从Series中提取的个值(如sum或mean)或从DataFrame的行或列中提取一个Series。跟 对应的NumPy数组方法相比,它们都是基于没有缺失数据的假设而构建的
#mean方法
"""
选项 说明
axis 约简的轴。DataFrame的行用0,列用1
skipna 排除缺失值,默认值为True
level 如果轴是层次化索引的(即Multiindex),则根据level分
组约简
"""
print(d3)
print(d3.mean(axis=1,skipna=True))
print(d3.min(axis=1,skipna=True))
print(d3.max(axis=1,skipna=True))
print(d3.sum(axis=1,skipna=True))
#有些方法(如idxmin和idxmax)返回的是间接统计(比如达到最小值或最大值的索引):
print(d3.idxmax(axis=1))
print(d3.idxmin(axis=0))
print(d3)
#累计求和型计算
print(d3.cumsum(axis=1))
print(d3.cumsum(axis=0))
#描述型计算
print(d3.describe())
"""
方法 说明
count 非NA值的数量
describe 针对Series或各DataFrame列计算汇总统计
min,max 计算最小值和最大值
argmin,argmax 计算能够获取到最小值和最大值的索引位置
idxmin,idxmax 计算能够获取到最小值和最大值的索引值
quantile 计算样本的分位数(0到 1)
sum 值的总和
mean 值的平均数
media 值的算术中位数(50%分位数)
mad 根据平均值计算平均绝对离差
var 样本值的方差
std 样本值的标准差
skew 样本值的偏度(三阶矩)
kurt 样本值的峰度(四阶矩)
cumsum 样本值的累计和
cummin,cummax 样本值的累计最大值和累计最小
cumprod 样本值的累计积
diff 计算一阶差分(对时间序列很有用)
pct_change 计算百分数变化
"""
#有些汇总统计(如相关系数和协方差)是通过参数对计算出来的
data=DataFrame(np.random.randint(1,10,size=(10,10)),index=list('abcdefghij'),columns=list('ABCDEFGHIJ'))
print(data)
#Series的corr方法用于计算两个Series中重叠的、非NA的、按索引对齐的值的相关系 数。与此类似,cov用干计算协方差
print('A与B的相关系数:',data.A.corr(data.B))
print('A与B的协方差:',data.A.cov(data.B))
print('协方差矩阵:\n',data.cov())
print('相关系数矩阵:\n',data.corr())
#利用DataFrame的corrwith方法,可以计算其列或行跟另一个Series或DataFrame之间的相关系数。传入一个Series将会返回一个相关系数值Series (针对各列进行计算)
print(data.corrwith(data.A))
#传入一个DataFrame则会计算按列名配对的相关系数
#传入axis=1即可按行进行计算。无论如何,在计算相关系数之前,所有的数据项都会按标签对齐。
#唯一值、值计数、成员资格方法
"""
方法 说明
isin 计算一个表示“Series各值是否包含于
传入的值序列中”的布尔型数组
unique 计算Series中的唯一值数组,按发现
. 的顺序返回
value_counts 返回一个Series,其索引为唯一值,其
值为频率,按计数值降序排列
"""
obj=Series(['c','a','d','a','a','b','b','c','c'])
uniques = obj.unique();print(sorted(uniques))
print(obj.value_counts())
#为了便于査看,结果Series是按值频率降序排列的。value_counts还是一个顶级pandas方法,可用于任何数组或序列:
print(pd.value_counts(obj.values, sort=True))
mask=obj.isin(['b','c'])
print(mask,'\n',obj[mask])
#处理缺失值
"""
方法 说明
dropna 根据各标签的值中是否存在缺失数据对轴标
签进行过滤,可通过阈值调节对缺失值的容
忍度
fillna 用指定值或插值方法(如ffill或bfill)填充缺
失数据
isnull 返回一个含有布尔值的对象,这些布尔值表
示哪些值是缺失值/NA,该对象的类型与源
类型一样
notnull isnull 的否定式
"""
from numpy import nan as NA
data=Series([1,2,NA,4,NA,5,6])
print(data.dropna())
print(data[pd.notnull(data)])#等价形式
#对于DataFrame对象,dropna默认丢弃任何含有缺失值的行
frame=DataFrame(np.array([[1,2,NA],[2,NA,3],[4,5,6],[9,20,29]]),index=list('abcd'),columns=list('ABC'))
print(frame)
print(frame.dropna())
#传入how=‘all’将只丢弃全为NA的那些行,axis=1则丢弃列
print(frame.dropna(how='all',axis=1))
print(frame.dropna(how='any',axis=1))
print(frame.dropna(thresh=3))#对每行非nan数据数量的最低要求为thres,小于thres的行会被删除掉
#填充缺失数据
#若不想滤除缺失数据(有可能会丢弃跟它有关的其他数据),而是希望通过其他方式填补那些“空洞”。对于大多数情况而言,fillna方法是最主要的函数。通过一个常数调用fillna就会将缺失值替换为那个常数值:
print(frame)
print(frame.fillna(0))#原数据不变,返回新对象
frame.fillna({1:1.2,2:1.5})
print(frame)#原数据不变
#fillna默认会返回新对象,但也可以对现有对象进行就地修改:
frame.fillna(0,inplace=True)
print(frame)
#对reindex有效的那些插值方法也可用于fillna:
frame.iloc[0:2,1]=np.nan
print(frame)
print(frame.fillna(method='bfill'))
print(frame.fillna(method='bfill',axis=1))
print(frame.fillna(method='bfill',limit=1))
"""
参数 说明
value 用于填充缺失值的标量值或字典对象
method 插值方式。如果函数调用时未指定其他参数
的话,默认为“ffill”
axis 待填充的轴,默认axis=0
inplace 修改调用者对象而不产生副本
limit (对于前向和后向填充)可以连续填充的最
大数量
"""
#层次化索引
#层次化索引(hierarchical indexing)是pandas的一项重要功能,它能在一个轴上拥 有多个(两个以上)索引级别。抽象点说,它使能以低维度形式处理高维度数据。 先来看一个简单的例子:创建一个Series,并用一个由列表或数组组成的列表作为索引
data = Series(np.random.randn(10),
index=[['a','a','a','b','b','b','c','c','d','d'],
[1, 2, 3, 1, 2, 3, 1, 2, 2, 3]])
data
print(data['b':'c'])
print(data[['b','d']])
print(data['a',1])
print(data[:,1])
#可通过其unstack方法被重新安排到一个DataFrame中
print(data)
data1=data.unstack()
print(data1,type(data1))
data2=data1.stack()
print(data2)
#对于一个DataFrame,每条轴都可以有分层索引:
frame = DataFrame(np.arange(12).reshape((4, 3)),
index=[['a','a','b','b'], [1, 2, 1, 2]],
columns=[['Ohio','Ohio','Colorado'],
['Green','Red','Green']])
print(frame)
print(frame.unstack())
frame.index.names = ['key1','key2']
frame.columns.names = ['state', 'color']
frame
frame['Ohio']
frame['Ohio','Green']
只看了一些最基础的操作,道阻且长。