pandas学习

import pandas as pd
import numpy as np
from pandas import Series, DataFrame
import pandas_datareader.data as web
#Series是一种类似于一维数组的对象，它由一组数据（各种NumPy数据类型）以及一组与之相关的数据标签（即索引）组成。仅由一组数据即可产生最简单的Series：
# obj2 = pd.Series([4, 7, -5, 3], index=['d', 'b', 'a', 'c'])
# print(obj2)
# print(np.exp(obj2))
# print('b' in obj2)

# sdata = {'Ohio': 35000, 'Texas': 71000, 'Oregon': 16000, 'Utah': 5000}
# obj3=pd.Series(sdata)
# print(obj3)

#dataframe
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,index=[1,2,3,4,5,6])
print(frame.iloc(1))
print(frame.head())
#如果指定了列序列，则DataFrame的列就会按照指定顺序进行排列：
pd.DataFrame(data, columns=['year', 'state', 'pop'])
#DataFrame查找行
print(frame.loc[2])
#删除列
del frame["pop"]
print(frame.head())
#如果嵌套字典传给DataFrame，pandas就会被解释为：外层字典的键作为列，内层键则作为行索引：
pop = {'Nevada': {2001: 2.4, 2002: 2.9},
       'Ohio': {2000: 1.5, 2001: 1.7, 2002: 3.6}}
frame3 = pd.DataFrame(pop)
print(frame3)
#可以设置index，且允许重复值、不可变
obj = pd.Series(range(3), index=['a', 'b', 'b'])
print(obj)


#重新索引
#pandas对象的一个重要方法是reindex，其作用是创建一个新对象，它的数据符合新的索引
obj = pd.Series([4.5, 7.2, -5.3, 3.6], index=['d', 'b', 'a', 'c'])
#用该Series的reindex将会根据新索引进行重排。如果某个索引值当前不存在，就引入缺失值
obj2 = obj.reindex(['a', 'b', 'c', 'd', 'e'])
print(obj2)

#借助DataFrame，reindex可以修改（行）索引和列。只传递一个序列时，会重新索引结果的行
frame = pd.DataFrame(np.arange(9).reshape((3, 3)),
index = ['a', 'c', 'd'],
 columns = ['Ohio', 'Texas','California'])
frame2 = frame.reindex(['a', 'b', 'c', 'd'])
print(frame2)

#去掉某一行
obj = pd.Series(np.arange(5.), index=['a', 'b', 'c', 'd', 'e'])
new_obj=obj.drop(['a','b'])
print(new_obj)
data = pd.DataFrame(np.arange(16).reshape((4, 4)),
                       index=['Ohio', 'Colorado', 'Utah', 'New York'],
                   columns=['one', 'two', 'three', 'four'])
#通过传递axis=1或axis='columns'可以删除列的值
new_obj1=data.drop("Ohio")
new_obj2=data.drop("four",axis=1)
print(new_obj1,new_obj2)


#pandas最重要的一个功能是，它可以对不同索引的对象进行算术运算。在将对象相加时，如果存在不同的索引对，则结果的索引就是该索引对的并集。对于有数据库经验的用户，这就像在索引标签上进行自动外连接。看一个简单的例子：
s1 = pd.Series([7.3, -2.5, 3.4, 1.5], index=['a', 'c', 'd', 'e'])
s2 = pd.Series([-2.1, 3.6, -1.5, 4, 3.1],index=['a', 'c', 'e', 'f', 'g'])
print(s1 + s2)

df1 = pd.DataFrame(np.arange(9.).reshape((3, 3)), columns=list('bcd'),
                   index=['Ohio', 'Texas', 'Colorado'])
df2 = pd.DataFrame(np.arange(12.).reshape((4, 3)), columns=list('bde'),
                   index=['Utah', 'Ohio', 'Texas', 'Oregon'])
print(df1 + df2)

#默认情况下，DataFrame和Series之间的算术运算会将Series的索引匹配到DataFrame的列，然后沿着行一直向下广播
#如果你希望匹配行且在列上广播，则必须使用算术运算方法。
frame = pd.DataFrame(np.arange(12.).reshape((4, 3)),
                    columns=list('bde'),
                       index=['Utah', 'Ohio', 'Texas', 'Oregon'])
series = frame.iloc[0]
series3 = frame['d']
frame.sub(series3, axis='index')#行运算
print(frame)


#对数据集排序
obj = pd.Series(range(4), index=['d', 'a', 'b', 'c'])
print(obj.sort_index())
#dataframe可根据行或列排序
frame = pd.DataFrame(np.arange(8).reshape((2, 4)),
                      index=['three', 'one'],
                      columns=['d', 'a', 'b', 'c'])
print(frame.sort_index())#行
print(frame.sort_index(axis=1))#列
print(frame.sort_index(axis=1, ascending=False))#ascending=false是降序排序
print(frame.sort_values(by="a"))#对值排序


#汇总和计算描述统计
df = pd.DataFrame([[1.4, np.nan], [7.1, -4.5],
                   [np.nan, np.nan], [0.75, -1.3]],
                  index=['a', 'b', 'c', 'd'],
                  columns=['one', 'two'])
print(df.sum())#返回每一列的和,NA值会自动被排除
print(df.sum(axis=1))#返回每一行的和,NA值会自动被排除
print(df.count())#返回非NA值的个数




#相关系数和协方差
#DataFrame的corr和cov方法将以DataFrame的形式分别返回完整的相关系数或协方差矩阵
print(df.corr())
print(df.cov())
#利用DataFrame的corrwith方法，你可以计算其列或行跟另一个Series或DataFrame之间的相关系数。传入一个Series将会返回一个相关系数值Series（针对各列进行计算）：
print(df.corrwith(df["one"]))


#第一个函数是unique，它可以得到Series中的唯一值数组：
obj = pd.Series(['c', 'a', 'd', 'a', 'a', 'b', 'b', 'c', 'c'])
uniques = obj.unique()
print(uniques)
print(obj.value_counts())#返回各个值出现的频率，且按值频率降序排序