Python之pandas 基础篇
以下语句是在pycharm中进行演示，复制到pycharm中运行可直接查看运行结果
#pandas 的数据结构介绍
#1.Series(由一组数据，各种Numpy数据类型）和一组索引组成：
import pandas as pd
import numpy as np
obj=pd.Series([4,7,-5,3])
print(obj)
#1.1Values和index属性：
print(obj.values)
print(obj.index)
#1.2给所创建的Series带有一个可以对各个数据点进行标记的索引：
obj2=pd.Series([4,7,-5,3],index=["d","b","a","c"])
print(obj2)
#与普通Numpy数组相比，可以通过索引的方式选取Series中的单个或一组数值
print(obj2["a"])
print(obj2[["c","a","d"]])
#可将Series看成时一个定长的有序字典，它是在索引值到数据值的一个映射（它可以用在许多原本需要字典参数的函数中），可通过字典直接创建
print('b'in obj2)
sdate={"ohio":3500,"Texas":7100,"Utah":500}
obj3=pd.Series(sdate)
print(obj3)
sdates=["calnia","ohie","orange"]
obj4=pd.Series(obj3,index=sdates)
print(obj4)
#如果只传入一个字典，则Series中的索引就是原字典中的键，Series最重要的一个功能是在算运算中自动对齐不同索引的数据
print(obj3)
print(obj4)
print(obj3+obj4)
#Series对象本身及其索引都有一name属性
obj4.name="population"
obj4.index.name="state"
print(obj4)
#Series的索引可以通过赋值的方式就地修改：
obj.index=["Bob","Steve","Jeff","Ryya"]
print(obj)
#2.DataFranme 是一个表格型的数据结构，既有行索引也有列索引.DataFrame中面向行和列的操作基本是平衡的。DataFrame的数据是以一个或多个二维快
#存放的,用层次化索引，将其表示为更高维度的数据，构建numpy,直接传入一个由等长列表或Numpy组成的字典
data={"state":["ohio","ohio","nevada","nebada"]}
data={"state":["ohio","ohio","ohio","nevada","nebada"],"year":[2000,2001,2002,2001,2002], "pop":[1.5,1.7,3.6,2.4,2.9]}
print(pd.DataFrame(dwata))
#2.1和Series一样，如果传入的列载数据中找不到，就会产生NA值
frame2=pd.DataFrame(data,columns=["year","state","pop","debt"],
index=["one","two","three","four","five"])
print(frame2)
print(frame2.columns)
#2.2可以通过赋值的方式进行修改
frame2["debt"]=[16.5,12,13,14,12]
print(frame2)
#2.3通过类似字典标记的方式或属性的方式，可以将DataFrame 的列获取为一个Series
print(frame2["state"])
print(frame2.state)
#2.4行也可以通过位置或名称的方式进行获取，比如用索引字段ix,将列表或者数组赋值给某一个列时，其长度必须跟DataFrame的长度相匹配。如果赋值的是一个Series,就会精确匹配Dataframe的索引，所有的空位都将被填上缺失值
val=pd.Series([-1.2,-1.5,-1.7],index=["two","four","five"])
frame2["debt"]=val
print(frame2)
print(frame2.columns)
#2.5对结果进行转置
print(frame2.T)
#2.6索引对象 pandas的索引对象，管理轴标签和其他元数据（如周名称，构建Series或Dataframe时，所用到的任何数组或其他序列的标签都会被转换成一个index,且index对象是不可修改的
obj=pd.Series(range(3),index=["a","b","c"])
index=obj.index
print(index)
print(index[1:])
print(obj)
#2.7index的功能类似一个固定大小的集合
print(frame2)
print("year" in frame2.columns)
print("one" in frame2.index)
#3基本功能 方法reindex:创建一个适应新索引的新对象
obj=pd.Series([4.5,7.2,-5.3,3.6],index=["d","b","a","c"])
print(obj)
obj2=obj.reindex(["q","b","c","d","e"])
print(obj2)
#调用该Series的reindex将会根据新索引进行重排。如果某个索引值当前不存在，将会引入缺失值
obj=obj.reindex(["q","b","c","d","e"],fill_value=0)
print(obj)
#对于时间序列这样的有序数据，重新索引时可能需要做一些差值处理
obj3=pd.Series(["blue","purple","yellow"],index=[0,2,4])
print(obj3.reindex(range(6),method="ffill"))
#对于Dataframe,reindex可以修改行，列索引，或两个都修改，如果仅传入一列，则会重新索引行：
frame=pd.DataFrame(np.arange(9).reshape(3,3),index=["a","c","d"],columns=["ohio","texa","california"])
print(frame)
frame2=frame.reindex(["a","b","c","d"])
print(frame2)
#使用columns关键字可重新索引列：
states=["texas","Utah","california"]
print(frame.reindex(columns=states))
#同时对行。列进行索引
print(frame.reindex(index=["1","2","3","4"],method="ffill",columns=states.sort()))
#丢弃指定轴上的项,drop方法返回的是一个指定轴上删除了指定值的新对象
obj=pd.Series(np.arange(5),index=["q","b","c","d","e"])
new_obj=obj.drop("c")
print(new_obj)
#对于DataFrame,可以删除任意轴上的索引值
data=pd.DataFrame(np.arange(16).reshape((4,4)),index=["ohio","corhioal","uthd","new_yor"],columns=["one","two","three","four"])
print(data)
print(data.drop(["ohio","corhioal"]))
print(data.drop(["one","two"],axis=1))
#3.2索引 选取和过滤 Series索引的工作方式类似于Numpy数组的索引，但Series的索引值不只是整数
obj=pd.Series(np.arange(4.),index=["a","b","c","d"])
print(obj)
print(obj["b"])
print(obj[1])
print(obj[[1,3]])
print(obj[obj<2])
#利用标签的切片运算，其包含闭区间（与普通p'y't'on的切片运算不同)
print(obj["b":"c"])
obj["b":"c"]=5
print(obj)
#对Dataframe进行索引就是获取一个列或多个列
data=pd.DataFrame(np.arange(16).reshape((4,4)),index=["ohio","corhioal","uthd","new_yor"],columns=["one","two","three","four"])
print(data["two"])
print(data[["one","two"]])
#这种索引方式的特殊情况：通过切片或者布尔型数组选取行
print(data[:2])
print(data[data["three"]>5])
#另一种用法就是通过布尔型Dataframe进行索引（在语法上更像ndarray)
print(data<5)
data[data<5]=0
print(data)
#3.2算术运算和数据对齐
#pandas最重要的一个功能是对不同索引的对象进行算术运算，对不同的索引对，取并集
a1=pd.Series([7.3,-2.5,3.4,1.5],index=["a","b","c","d"])
a2=pd.Series([7.3,-2.5,3.4,1.5],index=["a","b","c","g"])
print(a1+a2)
#自动的数据对齐操作在不重叠的索引出引入了NA值，即乙方有的索引，另一方没有，运算后该处索引的值为缺失值，对Dataframe，对齐操作会同事发生在行和列上
#3.3在算术方法中填充值 对运算后的NA值处填充一个特殊值（比如0）
df1=pd.DataFrame(np.arange(12).reshape((3,4)),columns=list("abcd"))
df2=pd.DataFrame(np.arange(20).reshape((4,5)),columns=list("abcde"))
print(df1.add(df2,fill_value=0))
#否则e列都是NAN值，类似在对Series和Dataframe重新索引时，也可以指定一个填充值
print(df1.reindex(columns=df2.columns,fill_value=0))
#用这几个特定字的，叫算数方法：add/sub/div/mul,即 加减除乘
#3.4 Dataframe和Series之间的运算 计算一个二维数组与其某行之间的差
arr=np.arange(12.).reshape((3,4))
print(arr-arr[0])
#这个叫广播，下面的每行都做这个运算，默认情况下，Dataframe和Series之间的算术运算也会将Series的索引匹配到Dataframe的列，然后沿着行一直向下广播
#函数的应用和映射 numpy的ufuncs 可用于操作pandas对象，以abs为例：
frame=pd.DataFrame(np.random.randn(4,3),columns=list("bde"),index=["ohio","corhioal","uthd","new_yor"])
print(np.abs(frame))
#Dataframe的apply方法：将函数应用到各列或行所形成的一列数组上
f=lambda x:x.max()-x.min()
frame.apply(f)
print(frame.apply(f))
print(frame.apply(f,axis=1))
#许多最常见到的数据统计功能都被封装为Dataframe的方法，无需使用apply,除标量值外，传递给apply的函数还可以返回由多个值组成的Series
def f(x):
return pd.Series([x.min(),x.max()],index=["min","max"])
print(frame.apply(f))
#用applymap得到frame中各个浮点值的格式化字符串
format=lambda x: "%.2f"%x
print(frame.applymap(format))
#Series有一个用于应用元素级函数的map方法
print(frame["e"].map(format))
#4排序和排名
#sort_index方法：返回一个已排序的新对象
obj=pd.Series(range(4),index=list("dabc"))
print(obj.sort_index())
#对于Dataframe，可以根据任意一个轴上的索引进行排序
frame=pd.DataFrame(np.arange(8).reshape((2,4)),index=["three","one"],columns=list("dabc"))
print(frame)
print(frame.sort_index())
print(frame.sort_index(axis=1,ascending=True))
#默认是按升序排列
#对Series 进行排序，可用方法sort_values(),在排序时任何缺失值默认都会被放到Series末尾
obj=pd.Series([4,7,-3,2])
print(obj.sort_values())
#DataFrame上，用by根据列的值进行排序：
frame=pd.DataFrame({"b":[4,7,-3,2],"a":[0,1,0,1]})
print(frame)
print(frame.sort_index(by="b"))
print(frame.sort_values(by="b"))
#根据多个列进行排序
print(frame.sort_values(by=["a","b"]))
#rank方法： 默认情况下，rank是通过"为各组分配一个平均排名"的方式破坏平级关系
obj=pd.Series([-7,5,4,5,0,4])
print(obj.rank())
#根据值在原数据中出现的顺序给出排名：
print(obj.rank(method="first",ascending=True))
#Dataframe可以在行或列上计算排名：
frame=pd.DataFrame({"b":[4.3,7,-3,2],"a":[0,1,0,1],"c":[-2,5,8,10]})
print(frame)
print(frame.rank(axis=1))
#带有重复值的轴索引 虽然许多pandas函数都要求标签唯一（如reindex),但这不是强制的，带有重复索引的index
obj=pd.Series(range(5),index=list("aabbc"))
print(obj)
print(obj.index.is_unique)
print(obj["a"])
#索引的is_unique属性可以判断它的值是否唯一，带有重复索引的Dataframe
df=pd.DataFrame(np.random.randn(4,3),index=list("aabb"))
print(df)
#在pandas 中，dataframe.ix[i}和dataframe.iloc[i]都可以选取dataframe中第i行数据，ix可以通过行号和行标签进行索引，而iloc只能通过行号索引，即ix可以看成是iloc以及loc的综合
#（loc 在index 的标签上进行索引，范围包含start和end,iloc在index的位置上进行索引，不包含end,ix在index的标签上索引，索引不到就在index的位置上索引若index非全整数，不包含end)
#汇总和计算描述统计
#pandas对象拥有一组常用的数学和统计方法，用于从series中提取单个值，或从Dataframe的行或列中提取一个Series,跟numpy数组方法相比，他们都是基于没有缺失数据的假设而构建的
df=pd.DataFrame([[1.4,np.nan],[7.1,-4.5],[np.nan,np.nan],[0.75,-1.3]],index=list("abcd"),columns=["one","two"])
print(df)
print(df.sum)
print(df.sum(axis=1))
#有关na的值会自动被排除，通过skipna选择可以禁用该功能（df.sum(axis=1,skipna=False)
#一次性产生多个统计结果
print(df.describe())
#4.1相关系数和协方差（Series和Dataframe corr方法：相关系数 cov方法：协方差）
#Dataframe的corrwith方法计算其列或行跟另一个Series或dataframe之间的相关系数，传入一个DATAframe计算按列名配对的相关系数，传入axis=1即可按行进行计算
#唯一值，值计算以及成员资格 从一维Series的值中抽取信息 unique函数：得到Series中的唯一值数组
obj=pd.Series(list("aaaabbbbcddshg"))
print(obj.unique())
#value_counts用于计算一个Series中各值出现的频率
print(obj.value_counts())
print(pd.value_counts(obj.values,sort=False))
#isin 用于判断矢量化集合的成员资格，可用于选取Series或Dataframe
mask=obj.isin(["b","c"])
print(mask)
print(obj[mask])
#处理缺失数据 opandas 的设计终极目标之一就是让缺失数据的处理任务尽量放松，pandas使用浮点值nan(not a number)表示浮点和非浮点数组中的缺失数据。它只是一个便于被检测出来的标牌机而已，pythonne内置的none值也会当作NA处理
#4.2过滤缺失数据 对于一个Series ,dropna返回一个仅含非空数据和索引值的series;
from numpy import nan as NA
data=pd.Series([1,NA,3.5,NA,7])
print(data.dropna())
#通过布尔索引也可以达到此目标
print(data[data.notnull()])
#对于dataframe对象，dropna默认丢死任何含有缺失值的行
data=pd.DataFrame([[1,6.3,3],[1,NA,2,NA],[NA,NA,NA,NA]])
print(data.dropna)
#填充缺失数据 fillna方法：通过一个常熟调用dillna就会将缺失值替换为那个常数
print(df.fillna(0))
#另外可以用fillna 实现许多别的功能，比如传入Series 的平均值或者中位数
data=pd.Series([1,NA,3.5,NA,7])
print(data.fillna(data.mean()))
#层次化索引 在一个轴上用多个（2个以上）索引级别，即以较低维度形式处理高维度数据,multilndex索引Series格式话输出形式：
data=pd.Series(np.random.randn(10),index=[list("aaabbbccdd"),[1,2,3,1,2,3,1,2,3,2]])
print(data)
#选取数据子集
print(data["b"])
print(data.loc[["b","d"]])
#在内层中进行选取
print(data[:,2])
#层次化索引在数据重塑和基于分组的操作中很重要，比如说上面的数据可以通过其unstack方法被重新安排到一个新的Dataframe，它的逆运算是stack
print(data.unstack())
print(data.unstack().stack)
#对于一个dataframe，每条轴都可以有分层索引
frame=pd.DataFrame(np.arange(12).reshape((4,3)),index=[list("aabb"),[1,2,1,2]],columns=[["tom","tom","jack"],["ab","ac","ad"]])
print(frame)
#各层都可以有名字，，注意不要将索引名称跟轴标签混合在一起
frame.index.names={"key1","key2"}
print(frame)
#有了分布的列索引可以轻松选取列分组
#重排分级顺序 重新调整某条轴上各级的顺序，或根据指定级别上的值对数据进行排序 swaplevel:接受两个级别编号或名称，返回一个互换了级别的新对象，数据不发生改变
print(frame.swaplevel("key1","key2"))
#sortlevel：根据单个级别中值对数据进行排序（得到最终结果是有序的）
#4.5根据级别会哦在那个统计 level 选项：用于指定在某条轴上的求和级别 如下面所示，分别根据行或列上的级别来对行，对列进行求和
print(frame.sum(level="key2"))
#4.6使用dataframe的列 将dataframe的一个或多个列当作行索引来用，或将行索引变成dataframe的列
frame=pd.DataFrame({"a":range(7),"b":range(7,0,-1),"c":["one","one","one","two","two","two","two"],"d":[0,1,2,0,1,2,3]})
print(frame)
frame2=frame.set_index(["c","d"])
print(frame2)
#set_index函数：将其一个或多个列转换成行索引，并创建一个新的Dataframe 默认情况下那些列会从dataframe中移除，也可以将其保留下来
print(frame.set_index(["c","d"],drop=False))
#reset_index:将层次化索引的级别转移到列里面（（和set_index相反）
print(frame2.reset_index())