Pandas教程

一. Pandas简介

1.1 概念

Pandas是一款开放源码的BSD许可的Python库，为Python编程语言提供了高性能，易于使用的数据结构和数据分析工具。广泛的领域，包括金融、经济、统计、分析等学术和商业领域，Pandas是基于Numpy的一种工具，该工具是为了解决数据分析任务而创建的，Pandas纳入了大量库和一些标准的数据模型，提供了高效地操作大型数据集所需的工具

1.2 优点

1. 快速高效的DataFrame对象，具有默认和自定义索引
2. 将数据从不同文件格式加载到内存中的数据对象工具
3. 丢失数据的数据对齐和综合处理
4. 集成时间序列功能
5. 基于标签切片，索引和大数据集的子集
6. 可以删除或插入来自数据结构的列
7. 按数据分组进行聚合和转换
8. 高性能合并和数据加入
9. 合并及其他出现在常见数据库（例如基于SQL的）中的关系型运算

1.3 数据类型分类

1. 系列（Series）
2. 数据帧（DataFrame）：被广泛使用，是最重要的数据结构之一
3. 面板（Panel）：很少使用呢

三种数据结构构建在Numpy数组之上，这意味着它们很快。考虑这些数据结构最好的方法是，较高维数据结构是其较低维数据结构的容器，如下：

数据结构	维数	描述
系列	1	1D标记均匀数组，大小不变
数据帧	2	一般2D标记，大小可变的表结构与潜在的异质类型的列
面板	3	一般3D标记，大小可变数组

二. 系列（Series）

2.1 简介

能够保存任何类型的谁（整数、字符串、浮点数和Python对象等）的一维标记数组，轴标签统称为索引

2.2 Series创建

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

参数	说明
data	数据采取各种形式，如：ndarray，list，constants
index	索引值必须是唯一的和散列的，与数据的长度相同
dtype	数据类型，如果没有，将推断数据类型
copy	复制数据，默认为false

创建一个空系列

import pandas as pd
#创建一个空系列
s=pd.Series()

从ndarray创建一个系列：如果数据是ndarray，则传递的索引必须具有相同的长度。如果没有传递索引值，那么默认索引将是范围(n)，其中n是数组的长度

import numpy as np
import pandas as pd
x=np.array([1,2,3,4,5])
s=pd.Series(x)  #不指定index
t=pd.Series(x,index=(10,20,30,40,50)) #指定index
print(s)
print(t)

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

import numpy as np
import pandas as pd
d={'name':'jakiechai','sex':'man','homesite':'beijing'}
s=pd.Series(d) #不传递index
t=pd.Series(d,index=('homesite','name','sex','age'))
print(s)
print(t)

从标量创建一个系列：如果数据是标量值，则必须提供索引，将重复该值以匹配索引的长度

s=pd.Series(5,index=[0,1,2,3,4,5,6])
print(s)

2.2 Series数据访问

从具体有位置的系列中访问数据：系列中的数据可以使用类似于ndarray中的数据来访问

import numpy as np
import pandas as pd
x=np.array([1,2,3,4,5])
s=pd.Series(x,index=[1,2,3,4,5])  #不指定index
print("下标拿：\n",s[1])
print("切片拿：\n",s[2:])  

使用标签检索数据（索引）：一个系列就像一个固定大小的字典，可以通过索引标签获取和设置值

import numpy as np
import pandas as pd
d={'name':'jakiechai','sex':'man','homesite':'beijing'}
s=pd.Series(d) 
print(s['name'])
print(s[['name','sex']])

2.3 系列的基本功能

基本属性

属性	说明
axes	返回行轴标签列表
dtype	返回对象的数据类型
empty	返回系列为空，则返回true
ndim	返回底层数据的维数，默认定义1
size	返回基础数据中的元素数个数
values	将系列作为ndarray返回

s=pd.Series(np.random.randn(5))
print("axes:",s.axes)
print("dtype:",s.dtype)
print("ndim:",s.ndim)
print("size:",s.size)
print('values:',s.values)

基本方法

方法	参数
head()	head()返回前n行数据，默认为5，可以自己设定
tail()	tail()返回最后n行，默认为5，可以自己指定

s=pd.Series(np.random.randn(5))
print(s.head(2))
print(s.tail(2))

文本操作函数	说明
len()	计算字符串长度
lower()	将Series/Index中的字符串转换为小写
upper()	将Series/Index中的字符串转换为大写
swapcase()	变换字母的大小写
title()	转为标题天模式
strip()	帮助从两侧的系列/索引中的每个字符串中删除空格（包括换行符）
split(‘’)	用给定的模式拆分每个字符串
get_dummies()	返回具有单热编码值的数据帧(DataFrame)
cat(sep=‘’)	使用给定的分隔符连接系列/索引元素
contains(pattern)	如果元素中包含子字符串，则返回每个元素的布尔值True，否则为False
replace(a,b)	将值a替换为值b
repeat(value)	重复每个元素指定的次数
count(parttern)	返回模式中每个元素的出现次数
startwith(pattern)	如果系列/索引中的元素以模式开始，则返回true
endwith(parttern)	如果系列/索引中的元素以模式结束，则返回true
find(parttern)	返回模式第一次出现的位置
findall(pattern)	返回模式的所有出现的列表
islower()	检查系列/索引中每个字符串中所有字符是否小写，返回布尔值
isupper()	检查系列/索引中每个字符串中的所有字符是否大写，返回布尔值
isnumeric()	检查系列/索引中每个字符串中的所有字符是否为数字，返回布尔值

s=pd.Series(['    Tom','Willim Rick','John','Alberat',np.nan,'1234','SteveMinsu'])
print("len(）方法:",s.str.len())
print("lower(）方法:",s.str.lower())
print("strip(）方法:",s.str.strip())
print("split(）方法:",s.str.split(" "))
print("cat(）方法:",s.str.cat(sep="-"))

三. 数据帧（DataFrame）

3.1 简介

数据帧可以理解为一张表格，即数据以行和列的表格方式排列，其有如下的功能特点：

1. 潜在的列是不同的类型
2. 大小可变
3. 标记轴（行和列）
4. 可以对行和列执行算术运算

3.2 构造函数

DataFrame(data=None,index=None,columns=None,dtype=None,copy=False)

参数	说明
data	采用各种形式，如:Ndarray，series，map，lists，dict（每一个键值对代表一列），constant和另一个DataFrame对象
index	对于行标签，要用于结果帧的索引是可选缺省值np.arrange(n)
column	对于列标签，可选的默认语法是-np.arange(n)
dtype	每列的数据类型
copy	如果默认值为False，则此命令（或任何它）用于复制数据

创建DataFrame对象

df=pd.DataFrame()  #创建空的DataFrame
print(df)
li=[1,2,3,4,5]
df=pd.DataFrame(li)
print(df)
data=[['sunck',18],['kaige,19'],['huazai',20]]
df=pd.DataFrame(data,columns=['name','age'],dtype='f',index=[1,2,3])
print(df)

3.3 操作DataFrame对象

列操作

data={
    'one': pd.Series([1,2,3],index=['a','b','c']),
    'two': pd.Series([4,5,6,7],index=['a','b','c','d'])
}
df=pd.DataFrame(data)
print(df['one':]) #选择列
df['tree']=pd.Series([9,10,11],index=['a','b','c']) #添加列
del df['one'] #删除列
df.pop('one') #删除列

行操作

data={
    'one': pd.Series([1,2,3],index=['a','b','c']),
    'two': pd.Series([4,5,6,7],index=['a','b','c','d'])
}
df=pd.DataFrame(data)
#1. 行选择
##标签选择loc
print(df.loc['b'])
##按整数位置选择iloc
print(df.iloc[2])
##行切片拿
print(df[2:4])

#2. 添加行
df=df.append(pd.DataFrame([[200,300]],columns=['one','two'],index=['e']))
print(df)

#3. 删除行
df.drop(['a','b'])

3.4 数据帧基本属性

属性	说明
T	转置行和列
axes	返回一个列，行轴标签和列轴标签作为唯一的成员
dtypes	返回此对象中的数据类型
empty	如果为空，则返回true否则返回false
ndim	返回维度
shape	返回表示的DataFrame对象中的维度的元组
size	返回元素个数
values	数据以numpy形式返回

data={
    'name': pd.Series(['Tom','James','Ricky','Vin','Steve','Minsu','Jack']),
    'Age':pd.Series([25,26,27,28,45,34,23]),
    'Rating':pd.Series([1,2,3,4,5,6,7])
}
df=pd.DataFrame(data)
print(df)
print("-------------")
print(df.T)
print("-------------")
print(df.axes)
print("-------------")
print(df.dtypes)
print("-------------")
print(df.ndim)
print("-------------")
print(df.shape)
print("-------------")
print(df.size)
print("-------------")
print(df.values)
print("-------------")

四. DataFrame基本使用

4.1 重建索引

重建索引会更改DataFrame的行标签和列标签，重新索引意味着符合数据以匹配特定轴上的一组给定的标签，可以通过索引来实现多个操作：

1. 重新排列现有数据以匹配一组新的索引
2. 在没有标签数据的标签位置插入缺省值标记

API:
reindex(labels=None,index=None,columns=None,axis=None,method=none,copy=True,level=None,fill_value=nan,limit=None,tolerance=None)

用于重构索引

参数	说明
index	行索引
columns	列索引
method	填充模式包括pad/fill(向前填充值)、bfill/backfill(向后填充值)、nearest(从最近的索引值填充)
limit	限制

import numpy as np
import pandas as pd
data={
    'A':pd.date_range(start="2019-01-01",periods=20,freq="D"),
    'X':np.linspace(0,19,num=20),
    'Y':np.random.rand(20),
    'C':np.random.choice(["low","medium","hight"],20).tolist(),
    'D':np.random.normal(100,10,size=(20)).tolist()
}
df=pd.DataFrame(data)
print(df)
#重建索引
df2_reindex=df.reindex(index=(0,2,5),columns=['A','C'])
print(df2_reindex)
df1=pd.DataFrame(np.random.randn(10,3),columns=['A','X','Y'])
df2_reindex=df.reindex_like(df1)
print(df2_reindex)

rename()
允许基于一些映射（字典或系列）或任意函数来重新标记一个轴（rename方法提供了一个inplace命名参数，默认为False，表示在原来基础上拷贝再修改，为True时则直接在原来的对象上修改）

4.2 迭代

pandas对象之间的基本迭代的行为取决于类型。当迭代一个系列时，它被视为数组式，基本迭代产生这些值。其他数据结构，如：DataFrame和Panel，遵循类似的惯例迭代对象的键

迭代列

import numpy as np
import pandas as pd
df=pd.DataFrame(np.random.randn(6,3),columns=['col1','col2','col3'])
for colName in df:
    print(colName)  #迭代列名
    print(df[colName]) #迭代列

迭代行

方法	说明
iteritems()	迭代(key, value)对
iterrows()	将行迭代为(索引，系列）对
itertuples()	以namedtuples的形式迭代

iteritems()
将每个列作为键，将值与值作为键和列值迭代为series对象

import numpy as np
import pandas as pd
df=pd.DataFrame(np.random.randn(6,3),columns=['col1','col2','col3'])
for key,value in df.iteritems():
    print(key)
    print(value)
    print("------------")

iterrows()
返回迭代器，产生每个索引值以及保护每行数据的序列

import numpy as np
import pandas as pd
df=pd.DataFrame(np.random.randn(6,3),columns=['col1','col2','col3'])
for index,row in df.iterrows():
    print(index)
    print(row)
    print("----------")

itertuples()

for row in df.itertuples():
    print(row,row[0]) #得到的是元组
    print("---------")

注意：不要尝试在迭代时修改任何对象。迭代是用于读取的，迭代器返回原始对象（视图）的副本，因此更改将不会反映在原始对象上（而是原始对象的一个副本）

4.3 排序

pandas有两种排序方法，它们分别是按标签和按实际值

按标签排序

sort_index(axis=0,leve=None,ascending=True,inplace=False,kind='quicksort',na_position='last',sort_remainding=True,by=None)

参数	说明
axis	值为0逐行排序，值为1逐列排序
ascending	值为True升序排序
inplace	是否真正改变原对象
kind	排序算法，默认使用快排序

df=pd.DataFrame(np.random.randn(10,2),columns=['col1','col2'],index=[1,4,2,5,6,8,9,10,12,56])
print(df)
sorterdf=df.sort_index()
sorterdf

按值排序

sort_values(by,axis=0,ascending=True,inplace=False,kind='quiksort',na_position='last')

参数	说明
by	使用要与其排序的Data Frame的名称

df=pd.DataFrame(np.random.randn(10,2),columns=['col1','col2'],index=[1,4,2,5,6,8,9,10,12,56])
print(df)
sorteddf=df.sort_values(by='col1')
sorteddf

4.4 层次化索引

1. 多层次行索引

隐式构造

s=pd.Series(np.random.rand(4),index=[['a','b','c','d'],[1,2,1,2]])
s2=pd.DataFrame(s,columns=['one'])
s2

显示构造

mindex=pd.MultiIndex.from_arrays([['a','a','b','b'],[1,2,1,2]]) #数组方式创建
mindex2=pd.MultiIndex.from_tuples([("a",1),("a",2),("b",1),("b",2)]) #元组
mindex3=pd.MultiIndex.from_product([["a","b"],[1,2]]) #product创建
s=pd.Series(np.random.rand(4),index=[['a','a','b','b'],[1,2,1,2]])
df=pd.DataFrame(s,index=mindex)
print("数组创建：\n",df)
df=pd.DataFrame(s,index=mindex)
print("元组创建：\n",df)
df=pd.DataFrame(s,index=mindex)
print("product创建：\n",df)

2. 操作索引

方法	说明
stack()	将列索引变为行索引
unstack()	将行索引变为列索引

score=np.random.randint(0,150,(3,10))
mindex=pd.MultiIndex.from_product([list("ABCDE"),['期中','期末']])
df=pd.DataFrame(data=score,index=["python",'java','c'],columns=mindex)
print(df.stack(level=0)) #将第一层的行索引变为列索引
print(df.unstack())

五. 函数

5.1 描述性统计信息函数

函数	描述
count()	非空观测数量
sum()	所有值之和
mean()	所有值的平均值
median()	所有值的中位数
mode()	值的模值
std()	值的标准偏差
min()	所有值中的最小值
max()	所有值中的最大值
abs()	绝对值
prod()	数组元素的乘积
cumsum()	累计总和
cumprod()	累计乘积

5.2 汇总数据

describe()函数是用来计算有关DataFrame列的统计信息的摘要

data={
    "name":pd.Series(['A','B','C','D','E']),
    'age':pd.Series([30,28,45,12,55]),
    'rating':pd.Series([4.32,5.34,1.23,2.33,6.33])
}
df=pd.DataFrame(data)
print(df)
df.describe()

5.3 统计函数

函数	描述
pct_change()	系列，DataFrame和Panel都有pct_change()函数。此函数将每个元素与其前一个元素进行比较，并计算变化百分比
cov()	协方差适用于系列数据，Series对象有一个方法cov用来计算序列对象之间的协方差。Na将自动被排除。当应用于DataFrame时，协方差方法计算所有列之间的协方差(cov)值
corr()	相关性显示了任何两个数值（系列）之间的线性关系，有多种方法来计算pearson(默认)，spearman和kendall之间的相关性
rank()	数据排名为元素数组中的每个元素生成排名。在关系的情况下，分配平均等级