Pnadas学习笔记

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']

只看了一些最基础的操作，道阻且长。