pandas教程

2018-10-06 本文已影响3人程序员欧阳

起步

pandas是一种Python数据分析的利器，是一个开源的数据分析包，最初是应用于金融数据分析工具而开发出来的，因此pandas为时间序列分析提供了很好的支持。pandas是PyData项目的一部分。

官网：http://pandas.pydata.org/
官方文档：http://pandas.pydata.org/pandas-docs/stable/

安装与导入

安装方式
Python的Anaconda发行版，已经安装好pandas库，不需要另外安装
使用Anaconda界面安装，选择对应的pandas进行勾选安装即可
使用Anaconda命令安装：conda install pandas
使用PyPi安装命令安装：pip install pandas

导入：

from pandas import Series, DataFrame
import pandas as pd

Pandas的数据类型

Pandas基于两种数据类型： series 与 dataframe 。

Series：一种类似于一维数组的对象，是由一组数据(各种NumPy数据类型)以及一组与之相关的数据标签(即索引)组成。仅由一组数据也可产生简单的Series对象。注意：Series中的索引值是可以重复的。
DataFrame：一个表格型的数据结构，包含有一组有序的列，每列可以是不同的值类型(数值、字符串、布尔型等)，DataFrame即有行索引也有列索引，可以被看做是由Series组成的字典。

Series

一个series是一个一维的数据类型，其中每一个元素都有一个标签。类似于Numpy中元素带标签的数组。其中，标签可以是数字或者字符串。

series属性

编号	属性或方法	描述
1	axes	返回行轴标签列表。
2	dtype	返回对象的数据类型(dtype)。
3	empty	如果系列为空，则返回True。
4	ndim	返回底层数据的维数，默认定义：1。
5	size	返回基础数据中的元素数。
6	values	将系列作为ndarray返回。
7	head()	返回前n行。
8	tail()	返回最后n行。

pandas.Series( data, index, dtype, copy)

编号	参数	描述
1	data	数据采取各种形式，如：ndarray，list，constants
2	index	索引值必须是唯一的和散列的，与数据的长度相同。默认np.arange(n)如果没有索引被传递。
3	dtype	dtype用于数据类型。如果没有，将推断数据类型
4	copy	复制数据，默认为false。

创建series方式

通过一维数组方式创建

import numpy as np  
import pandas as pd  

s = pd.Series([1, 2, 5, np.nan, 6, 8])  
print(s)

输出：

0    1.0  
1    2.0  
2    5.0  
3    NaN  
4    6.0  
5    8.0  
dtype: float64

从ndarray创建一个系列

data = np.array(['a','b','c','d'])
ser02 = pd.Series(data)
ser02

#指定索引
data = np.array(['a','b','c','d'])
# ser02 = pd.Series(data,index=[100,101,102,103])
ser02 = pd.Series(data,index=['name','age','sex','address'])
ser02

输出：

0    a
1    b
2    c
3    d
dtype: object

name       a
age        b
sex        c
address    d
dtype: object

从字典创建一个系列

字典(dict)可以作为输入传递，如果没有指定索引，则按排序顺序取得字典键以构造索引。如果传递了索引，索引中与标签对应的数据中的值将被拉出。

data = {'a':1,'b':2,'c':3}
ser03 = pd.Series(data)
ser03

#指定索引
data = {'a':1,'b':2,'c':3}
ser03 = pd.Series(data,index = ['a','b','c','d'])
ser03

#标量创建
ser04 = pd.Series(5,index = [0,1,2,3])
ser04

输出：

a    1
b    2
c    3
dtype: int64

a    1.0
b    2.0
c    3.0
d    NaN
dtype: float64

0    5
1    5
2    5
3    5
dtype: int64

Series值的获取

Series值的获取主要有两种方式：

通过方括号+索引的方式读取对应索引的数据，有可能返回多条数据
通过方括号+下标值的方式读取对应下标值的数据，下标值的取值范围为：[0，len(Series.values))；另外下标值也可以是负数，表示从右往左获取数据

Series获取多个值的方式类似NumPy中的ndarray的切片操作，通过方括号+下标值/索引值+冒号(:)的形式来截取series对象中的一部分数

#引入模块
import pandas as pd
import numpy as np
#检索第一个元素。
ser05 = pd.Series([1,2,3,4,5],index = ['a','b','c','d','e'])
print(ser05[1])
print(ser05['a'])
print(ser05['d'])

输出：

2
1
4

#检索系列中的前三个元素
ser05 = pd.Series([1,2,3,4,5],index = ['a','b','c','d','e'])
#通过索引来获取数据
print(ser05[:3])
print(ser05[::2])
print(ser05[4:2:-1])
#通过标签（下标值）来获取数据
print(ser05['b':'d'])
ser05['a':'d':2]
ser05['e':'c':-1]
ser05[['a','b']]

输出：

a    1
b    2
c    3
dtype: int64
a    1
c    3
e    5
dtype: int64
e    5
d    4
dtype: int64
b    2
c    3
d    4
dtype: int64

a    1
b    2
dtype: int64

Series的运算

#引入模块
import pandas as pd
import numpy as np

series = pd.Series({'a':941,'b':431,'c':9327})
series

#输出大于500的值
series[series>500]

#计算加
series+10

#计算减
series-100

#计算乘
series*10

#两个系列相加
ser01 = pd.Series([1,2,3])
ser02 = pd.Series([4,5,6])
ser01+ser02

#)计算各个元素的指数e的x次方  e 约等于 2.71828
np.exp(series)

np.abs(series)

#sign()计算各个元素的正负号: 1 正数，0：零，-1：负数
np.sign(series)

Series自动对齐

当多个series对象之间进行运算的时候，如果不同series之间具有不同的索引值，那么运算会自动对齐不同索引值的数据，如果某个series没有某个索引值，那么最终结果会赋值为NaN。

#引入模块
import pandas as pd
import numpy as np
serA = pd.Series([1,2,3],index = ['a','b','c'])
serB = pd.Series([4,5,6],index = ['b','c','d'])
print('---------serA+serB---------')
print(serA)
serA+serB

输出：

---------serA+serB---------
a    1
b    2
c    3
dtype: int64

a    NaN
b    6.0
c    8.0
d    NaN
dtype: float64

Series及其索引的name属性

Series对象本身以及索引都具有一个name属性，默认为空，根据需要可以进行赋值操作

1.jpg

DataFrame

一个dataframe是一个二维的表结构。Pandas的dataframe可以存储许多种不同的数据类型，并且每一个坐标轴都有自己的标签。你可以把它想象成一个series的字典项。

dataFrame属性

编号	属性或方法	描述
1	T	转置行和列。
2	axes	返回一个列，行轴标签和列轴标签作为唯一的成员	。
3	dtypes	返回此对象中的数据类型(dtypes)。
4	empty	如果NDFrame完全为空[无项目]，则返回为True; 如果任何轴的长度为0。
5	ndim	轴/数组维度大小。
6	shape	返回表示DataFrame的维度的元组。
7	size	NDFrame中的元素数。
8	values	NDFrame的Numpy表示。
9	head()	返回开头前n行。
10	tail()	返回最后n行。

dataframe创建方式

pandas中的DataFrame可以使用以下构造函数创建

pandas.DataFrame( data, index, columns, dtype, copy)

编号	参数	描述
1	data	数据采取各种形式，如:ndarray，series，map，lists，dict，constant和另一个DataFrame。
2	index	对于行标签，要用于结果帧的索引是可选缺省值np.arrange(n)，如果没有传递索引值。
3	columns	对于列标签，可选的默认语法是 - np.arange(n)。这只有在没有索引传递的情况下才是这样。
4	dtype	每列的数据类型。
5	copy	如果默认值为False，则此命令(或任何它)用于复制数据。

创建一个 DateFrame：

#创建日期索引序列  
dates =pd.date_range('20130101', periods=6)  
print(type(dates))  
#创建Dataframe，其中 index 决定索引序列，columns 决定列名  
df =pd.DataFrame(np.random.randn(6,4), index=dates, columns=list('ABCD'))  
print(df)

输出：

<class 'pandas.core.indexes.datetimes.DatetimeIndex'>  
                   A         B         C         D  
2013-01-01  0.406575 -1.356139  0.188997 -1.308049  
2013-01-02 -0.412154  0.123879  0.907458  0.201024  
2013-01-03  0.576566 -1.875753  1.967512 -1.044405  
2013-01-04  1.116106 -0.796381  0.432589  0.764339  
2013-01-05 -1.851676  0.378964 -0.282481  0.296629  
2013-01-06 -1.051984  0.960433 -1.313190 -0.093666

字典创建 DataFrame

df2 =pd.DataFrame({'A' : 1.,  
   'B': pd.Timestamp('20130102'),  
   'C': pd.Series(1,index=list(range(4)),dtype='float32'),  
   'D': np.array([3]*4,dtype='int32'),  
   'E': pd.Categorical(["test","train","test","train"]),  
   'F':'foo' })  

print(df2)

输出：

     A          B    C  D      E    F  
0  1.0 2013-01-02  1.0  3   test  foo  
1  1.0 2013-01-02  1.0  3  train  foo  
2  1.0 2013-01-02  1.0  3   test  foo  
3  1.0 2013-01-02  1.0  3  train  foo

从列表创建DataFrame

data = [1,2,3,4]
df02 = pd.DataFrame(data)
df02

输出：

从列表字典来创建DataFrame

data = {'Name':['Tom','Jack','Steve'],'Age':[19,18,20]}
# df04 = pd.DataFrame(data)
#指定行索引和列索引
df04 = pd.DataFrame(data,index = ['rank1','rank2','rank3'],columns = ['Name','Age','Sex'])
df04

输出：

    Name    Age     Sex
rank1   Tom     19  NaN
rank2   Jack    18  NaN
rank3   Steve   20  NaN

从字典列表创建数据帧DataFrame

data = [{'a':1,'b':2},{'a':1,'b':2,'c':3}]
# df05 = pd.DataFrame(data)
#传递字典列表指定行索引
# df05 = pd.DataFrame(data,index = ['first','second'])
#传递字典列表指定行索引，列索引
df05 = pd.DataFrame(data,index = ['first','second'],columns = ['a','b','c','d'])
df05

输出：

    a   b   c   d
first   1   2   NaN     NaN
second  1   2   3.0     NaN

从系列的字典来创建DataFrame

data = {
    'one':pd.Series([1,2,3],index = ['a','b','c']),
    'two':pd.Series([1,2,3,4],index = ['a','b','c','d'])
}
df06 = pd.DataFrame(data)
df06

输出：

    one     two
a   1.0     1
b   2.0     2
c   3.0     3
d   NaN     4

dataFrame数据操作

列选择

#直接通过列索引来获取某一列的值
data = {
    'one':pd.Series([1,2,3],index = ['a','b','c']),
    'two':pd.Series([1,2,3,4],index = ['a','b','c','d'])
}
df06 = pd.DataFrame(data)
df06

df06['one']
# df06.one
# df06.ix[:,'one']
# df06.loc[:,'one']
# df06.iloc[:,0]

列添加

data = {
    'one':pd.Series([1,2,3],index = ['a','b','c']),
    'two':pd.Series([1,2,3,4],index = ['a','b','c','d'])
}
df06 = pd.DataFrame(data)
df06['three'] = pd.Series([10,20,30],index = ['a','b','c'])
df06

列修改

#直接通过列名进行修改
df06['three'] = [7,8,9,10]
df06

列删除

data = {
    'one':pd.Series([1,2,3],index = ['a','b','c']),
    'two':pd.Series([1,2,3,4],index = ['a','b','c','d']),
    'three':pd.Series([10,20,30],index = ['a','b','c'])
}
df06 = pd.DataFrame(data)
#使用del删除列
# del(df06['three'])

#使用pop删除
df06.pop('two')
df06

行选择

data = {
    'one':pd.Series([1,2,3],index = ['a','b','c']),
    'two':pd.Series([1,2,3,4],index = ['a','b','c','d']),
    'three':pd.Series([10,20,30],index = ['a','b','c'])
}
df06 = pd.DataFrame(data)
df06

#可以通过将行标签传递给loc函数或者ix函数来选择行
# df06.loc['a']
df06.loc[:,'two']
# df06.ix['a']

# 按整数位置选择
# 可以通过将整数位置传递给iloc函数来选择行。参考以下示例代码 -
df06.iloc[2]

# 行切片
# 可以使用:运算符选择多行。参考以下示例代码 -
df06[2:4]

行添加

# df06.ix['e'] = [22,33,444]
df06.loc['e'] = [22,33,444]
df06

# 添加加行
# 使用append()函数将新行添加到DataFrame。 此功能将附加行结束。
#创建一行数据
# data2 = pd.DataFrame([{'one':22,'two':33,'three':44}],index = ['e'])
data2 = pd.DataFrame([[22,33,44]],columns = ['one','two','three'],index = ['f'])
# data2 
df06 = df06.append(data2)
df06

行删除

df06 = df06.drop('e')
df06

pandas基本功能

将文件数据导入Pandas

通过pandas提供的read_xxx相关的函数可以读取文件中的数据，并形成DataFrame,常用的数据读取方法为：read_csv，主要可以读取文本类型的数据

df =pd.read_csv("Counts.csv", header=0)
df.head()

选择/切片

df[‘column_name’] ，df[row_start_index, row_end_index] 选取指定整列数据

df['name']   # 选取一列，成一个series   
df[['name']]  # 选取一列，成为一个dataframe     
df[['name','gender']] #选取多列，多列名字要放在list里    
df[0:]  #第0行及之后的行，相当于df的全部数据，注意冒号是必须的    
df[:2]  #第2行之前的数据（不含第2行）    
df[0:1] #第0行    
df[1:3] #第1行到第2行（不含第3行）    
df[-1:] #最后一行    
df[-3:-1] #倒数第3行到倒数第1行（不包含最后1行即倒数第1行，这里有点烦躁，因为从前数时从第0行开始，从后数就是-1行开始，毕竟没有-0）

loc，在知道列名字的情况下，df.loc[index,column] 选取指定行，列的数据

# df.loc[index, column_name],选取指定行和列的数据    
df.loc[0,'name'] # 'Snow'    
df.loc[0:2, ['name','age']]          #选取第0行到第2行，name列和age列的数据, 注意这里的行选取是包含下标的。    
df.loc[[2,3],['name','age']]         #选取指定的第2行和第3行，name和age列的数据    
df.loc[df['gender']=='M','name']     #选取gender列是M，name列的数据    
df.loc[df['gender']=='M',['name','age']] #选取gender列是M，name和age列的数据

iloc，在column name特别长或者index是时间序列等各种不方便输入的情况下，可以用iloc (i = index), iloc完全用数字来定位 iloc[row_index, column_index]

df.iloc[0,0]        #第0行第0列的数据，'Snow'    
df.iloc[1,2]        #第1行第2列的数据，32    
df.iloc[[1,3],0:2]  #第1行和第3行，从第0列到第2列（不包含第2列）的数据    
df.iloc[1:3,[1,2]   #第1行到第3行（不包含第3行），第1列和第2列的数据

索引汇总

# 选择单独的一列，返回 Serires，与 df.A 效果相当。
df['A']

# 位置切片
df[0:3]

# 索引切片
df['20130102':'20130104']

#　通过标签选择
df.loc[dates[0]]

# 对多个轴同时通过标签进行选择
df.loc[:,['A','B']]

# 获得某一个单元的数据
df.loc[dates[0],'A']
# 或者
df.at[dates[0],'A']#　速度更快的做法

# 通过位置进行选择
df.iloc[3]

# 切片
df.iloc[3:5,0:2]

# 列表选择
df.iloc[[1,2,4],[0,2]]

# 获得某一个单元的数据
df.iloc[1,1]
# 或者
df.iat[1,1]# 更快的做法

# 布尔索引
df[df.A > 0]

# 获得大于零的项的数值
df[df > 0]

# isin 过滤
df2[df2['E'].isin(['two','four'])]

赋值（缺省值NaN处理方法）

于DataFrame/Series中的NaN一般采取的方式为删除对应的列/行或者填充一个默认值

1.jpg

# 新增一列，根据索引排列
s1 =pd.Series([1,2,3,4,5,6], index=pd.date_range('20130102', periods=6))
df['F']=s1

# 缺省项
# 在 pandas 中使用 np.nan 作为缺省项的值。
df1 =df.reindex(index=dates[0:4], columns=list(df.columns)+['E'])
df1.loc[dates[0]:dates[1],'E']=1

# 删除所有带有缺省项的行
df1.dropna(how='any')

# 填充缺省项
df1.fillna(value=5)

# 获得缺省项的布尔掩码
pd.isnull(df1)

算数运算

两个dataframe 矩阵相加、相减、相乘、相除，会对两个矩阵行索引（包括行索引名称和行索引值）和列索引相同的两个对应元素做运算。

观察操作

# 观察开头的数据
df.head()

# 观察末尾的数据
df.tail(3)

# 显示索引
df.index

# 显示列
df.columns

# 显示底层 numpy 结构
df.values

# DataFrame 的基本统计学属性预览
df.describe()
"""
  A  B  C  D
count 6.000000 6.000000 6.000000 6.000000 #数量
mean 0.073711 -0.431125 -0.687758 -0.233103 #平均值
std 0.843157 0.922818 0.779887 0.973118 #标准差
min -0.861849 -2.104569 -1.509059 -1.135632 #最小值
25% -0.611510 -0.600794 -1.368714 -1.076610 #正态分布 25%
50% 0.022070 -0.228039 -0.767252 -0.386188 #正态分布 50%
75% 0.658444 0.041933 -0.034326 0.461706 #正态分布 75%
max 1.212112 0.567020 0.276232 1.071804 #最大值
"""

# 转置
df.T

# 根据某一轴的索引进行排序
df.sort_index(axis=1, ascending=False)

# 根据某一列的数值进行排序
df.sort(columns='B')

统计

count                      非NA值的数量
describe                  针对Series或各DataFrame列计算汇总统计
min,max                 计算最小值和最大值
argmin,argmax        计算能够获取到最小值和最大值的索引位置（整数)
idxmin,idxmax         计算能够获取到最小值和最大值的索引值
quantile                   计算样本的分位数（0到 1） 
sum                        值的总和
mean                      值的平均数， a.mean() 默认对每一列的数据求平均值；若加上参数a.mean(1)则对每一行求平均值
media                      值的算术中位数（50%分位数)
mad                         根据平均值计算平均绝对离差
var                          样本值的方差 
std                        样本值的标准差
skew                     样本值的偏度（三阶矩）
kurt                       样本值的峰度（四阶矩）
cumsum                 样本值的累计和
cummin,cummax    样本值的累计最大值和累计最小
cumprod                样本值的累计积
diff                        计算一阶差分（对时间序列很有用) 
pct_change            计算百分数变化

# 求平均值
df.mean()
"""
A -0.004474
B -0.383981
C -0.687758
D 5.000000
F 3.000000
dtype: float64
"""

# 指定轴上的平均值
df.mean(1)

# 不同维度的 pandas 对象也可以做运算，它会自动进行对应，shift 用来做对齐操作。
s = pd.Series([1,3,5,np.nan,6,8], index=dates).shift(2)
"""
2013-01-01NaN
2013-01-02NaN
2013-01-031
2013-01-043
2013-01-055
2013-01-06NaN
Freq: D, dtype: float64
"""

# 对不同维度的 pandas 对象进行减法操作
df.sub(s, axis='index')
"""
   A B C D F
2013-01-01NaN NaN NaN NaN NaN
2013-01-02NaN NaN NaN NaN NaN
2013-01-03-1.861849-3.104569-1.49492941
2013-01-04-2.278445-3.706771-4.03957520
2013-01-05-5.424972-4.432980-4.7237680-1
2013-01-06NaN NaN NaN NaN NaN
"""

函数应用

# 累加
df.apply(np.cumsum)

直方图

s =pd.Series(np.random.randint(0,7, size=10))
s.value_counts()
"""
4 5
6 2
2 2
1 1
dtype: int64
String Methods
"""

字符处理

s =pd.Series(['A','B','C','Aaba','Baca', np.nan,'CABA','dog','cat'])
s.str.lower()
"""
0 a
1 b
2 c
3 aaba
4 baca
5 NaN
6 caba
7 dog
8 cat
dtype: object
"""

合并

使用 concat() 连接 pandas 对象:

df =pd.DataFrame(np.random.randn(10,4))
"""
  0  1  2  3
0 -0.548702 1.467327 -1.015962 -0.483075
1 1.637550 -1.217659 -0.291519 -1.745505
2 -0.263952 0.991460 -0.919069 0.266046
3 -0.709661 1.669052 1.037882 -1.705775
4 -0.919854 -0.042379 1.247642 -0.009920
5 0.290213 0.495767 0.362949 1.548106
6 -1.131345 -0.089329 0.337863 -0.945867
7 -0.932132 1.956030 0.017587 -0.016692
8 -0.575247 0.254161 -1.143704 0.215897
9 1.193555 -0.077118 -0.408530 -0.862495
"""

pieces =[df[:3], df[3:7], df[7:]]
pd.concat(pieces)
"""
  0  1  2  3
0 -0.548702 1.467327 -1.015962 -0.483075
1 1.637550 -1.217659 -0.291519 -1.745505
2 -0.263952 0.991460 -0.919069 0.266046
3 -0.709661 1.669052 1.037882 -1.705775
4 -0.919854 -0.042379 1.247642 -0.009920
5 0.290213 0.495767 0.362949 1.548106
6 -1.131345 -0.089329 0.337863 -0.945867
7 -0.932132 1.956030 0.017587 -0.016692
8 -0.575247 0.254161 -1.143704 0.215897
9 1.193555 -0.077118 -0.408530 -0.862495
"""

join 合并：

left =pd.DataFrame({'key': ['foo','foo'],'lval': [1,2]})
right =pd.DataFrame({'key': ['foo','foo'],'rval': [4,5]})
pd.merge(left, right, on='key')
"""
 key lval rval
0 foo 1 4
1 foo 1 5
2 foo 2 4
3 foo 2 5
"""

追加

在 dataframe 数据后追加行

df =pd.DataFrame(np.random.randn(8,4), columns=['A','B','C','D'])
s =df.iloc[3]
df.append(s, ignore_index=True)

分组

分组常常意味着可能包含以下的几种的操作中一个或多个

依据一些标准分离数据
对组单独地应用函数
将结果合并到一个数据结构中

df =pd.DataFrame({'A': ['foo','bar','foo','bar','foo','bar','foo','foo'],  
                  'B': ['one','one','two','three','two','two','one','three'],  
                  'C': np.random.randn(8),  
                  'D': np.random.randn(8)})  
print('源数据集：\n',df)  

df1 = df.groupby('A').sum()  
print('A分组：\n',df1)  

df2 = df.groupby(['A','B']).sum()  
print('AB分组：\n',df2)

输出结果

源数据集：  
      A      B         C         D  
0  foo    one  0.423062 -0.813870  
1  bar    one -1.058636 -0.943536  
2  foo    two -0.843569 -0.611338  
3  bar  three  0.933234 -1.425916  
4  foo    two -1.145840  0.643593  
5  bar    two  1.057359 -1.049414  
6  foo    one -0.387183  1.056451  
7  foo  three  1.923139 -1.184541  
A分组：  
             C         D  
A                        
bar  0.931957 -3.418865  
foo -0.030391 -0.909705  
AB分组：  
                   C         D  
A   B                          
bar one   -1.058636 -0.943536  
    three  0.933234 -1.425916  
    two    1.057359 -1.049414  
foo one    0.035879  0.242581  
    three  1.923139 -1.184541  
    two   -1.989409  0.032255

分组时，组内运算
代表运算的字符串包括‘sum’、‘mean’、‘min’、‘max’、‘count’

pd3 = pd3.groupby('a').agg('sum').reset_index()

或者自定义函数

# # 或自定义函数不需要参数，则x是serise，如果x有自定参数，则x为DataFrame  
def funname(x,name):  
    print(name)  
    print(type(x),'\n',x)  
    return 2  

pd3 = pd3.groupby('a').agg(funname,'aaa').reset_index()

数据透视表

df =pd.DataFrame({'A': ['one','one','two','three']*3,
   'B': ['A','B','C']*4,
   'C': ['foo','foo','foo','bar','bar','bar']*2,
   'D': np.random.randn(12),
   'E': np.random.randn(12)})

# 生成数据透视表
pd.pivot_table(df, values='D', index=['A','B'], columns=['C'])
"""
C  bar foo
A B  
one A -0.773723 1.418757
 B -0.029716 -1.879024
 C -1.146178 0.314665
three A 1.006160 NaN
 B NaN -1.035018
 C 0.648740 NaN
two A NaN 0.100900
 B -1.170653 NaN
 C NaN 0.536826
"""

时间序列

pandas 拥有既简单又强大的频率变换重新采样功能，下面的例子从 1次/秒转换到了 1次/5分钟：

rng =pd.date_range('1/1/2012', periods=100, freq='S')
ts =pd.Series(np.random.randint(0,500,len(rng)), index=rng)
ts.resample('5Min', how='sum')
"""
2012-01-01 25083
Freq: 5T, dtype: int32
"""

# 本地化时区表示
rng =pd.date_range('3/6/2012 00:00', periods=5, freq='D')
ts =pd.Series(np.random.randn(len(rng)), rng)
"""
2012-03-06 0.464000
2012-03-07 0.227371
2012-03-08 -0.496922
2012-03-09 0.306389
2012-03-10 -2.290613
Freq: D, dtype: float64
"""

ts_utc =ts.tz_localize('UTC')
"""
2012-03-06 00:00:00+00:00 0.464000
2012-03-07 00:00:00+00:00 0.227371
2012-03-08 00:00:00+00:00 -0.496922
2012-03-09 00:00:00+00:00 0.306389
2012-03-10 00:00:00+00:00 -2.290613
Freq: D, dtype: float64
"""

# 转换为周期
ps =ts.to_period()

# 转换为时间戳
ps.to_timestamp()

分类

df =pd.DataFrame({"id":[1,2,3,4,5,6],"raw_grade":['a','b','b','a','a','e']})

# 将 raw_grades 转换成 Categoricals 类型
df["grade"]=df["raw_grade"].astype("category")
df["grade"]
"""
0 a
1 b
2 b
3 a
4 a
5 e
Name: grade, dtype: category
Categories (3, object): [a, b, e]
"""

# 重命名分类
df["grade"]=df["grade"].cat.set_categories(["very bad","bad","medium","good","very good"])

# 根据分类的顺序对数据进行排序
df.sort("grade")
"""
 id raw_grade  grade
5 6   e very bad
1 2   b  good
2 3   b  good
0 1   a very good
3 4   a very good
4 5   a very good
"""

作图

ts =pd.Series(np.random.randn(1000), index=pd.date_range('1/1/2000', periods=1000))
ts =ts.cumsum()
ts.plot()

数据IO

# 从 csv 文件读取数据
pd.read_csv('foo.csv')

# 保存到 csv 文件
df.to_csv('foo.csv')

# 读取 excel 文件
pd.read_excel('foo.xlsx','Sheet1', index_col=None, na_values=['NA'])

# 保存到 excel 文件
df.to_excel('foo.xlsx', sheet_name='Sheet1')