Pandas是一款开放源码的BSD许可的Python库,为Python编程语言提供了高性能,易于使用的数据结构和数据分析工具。广泛的领域,包括金融、经济、统计、分析等学术和商业领域,Pandas是基于Numpy的一种工具,该工具是为了解决数据分析任务而创建的,Pandas纳入了大量库和一些标准的数据模型,提供了高效地操作大型数据集所需的工具
三种数据结构构建在Numpy数组之上,这意味着它们很快。考虑这些数据结构最好的方法是,较高维数据结构是其较低维数据结构的容器,如下:
数据结构 | 维数 | 描述 |
---|---|---|
系列 | 1 | 1D标记均匀数组,大小不变 |
数据帧 | 2 | 一般2D标记,大小可变的表结构与潜在的异质类型的列 |
面板 | 3 | 一般3D标记,大小可变数组 |
能够保存任何类型的谁(整数、字符串、浮点数和Python对象等)的一维标记数组,轴标签统称为索引
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)
从具体有位置的系列中访问数据:系列中的数据可以使用类似于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']])
基本属性
属性 | 说明 |
---|---|
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(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)
列操作
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'])
属性 | 说明 |
---|---|
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的行标签和列标签,重新索引意味着符合数据以匹配特定轴上的一组给定的标签,可以通过索引来实现多个操作:
- 重新排列现有数据以匹配一组新的索引
- 在没有标签数据的标签位置插入缺省值标记
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时则直接在原来的对象上修改)
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("----------")
for row in df.itertuples():
print(row,row[0]) #得到的是元组
print("---------")
注意:不要尝试在迭代时修改任何对象。迭代是用于读取的,迭代器返回原始对象(视图)的副本,因此更改将不会反映在原始对象上(而是原始对象的一个副本)
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
隐式构造
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)
方法 | 说明 |
---|---|
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())
函数 | 描述 |
---|---|
count() | 非空观测数量 |
sum() | 所有值之和 |
mean() | 所有值的平均值 |
median() | 所有值的中位数 |
mode() | 值的模值 |
std() | 值的标准偏差 |
min() | 所有值中的最小值 |
max() | 所有值中的最大值 |
abs() | 绝对值 |
prod() | 数组元素的乘积 |
cumsum() | 累计总和 |
cumprod() | 累计乘积 |
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()
函数 | 描述 |
---|---|
pct_change() | 系列,DataFrame和Panel都有pct_change()函数。此函数将每个元素与其前一个元素进行比较,并计算变化百分比 |
cov() | 协方差适用于系列数据,Series对象有一个方法cov用来计算序列对象之间的协方差。Na将自动被排除。当应用于DataFrame时,协方差方法计算所有列之间的协方差(cov)值 |
corr() | 相关性显示了任何两个数值(系列)之间的线性关系,有多种方法来计算pearson(默认),spearman和kendall之间的相关性 |
rank() | 数据排名为元素数组中的每个元素生成排名。在关系的情况下,分配平均等级 |