脚本之家，脚本语言编程技术及教程分享平台！
分类导航

Python|VBS|Ruby|Lua|perl|VBA|Golang|PowerShell|Erlang|autoit|Dos|bat|

服务器之家 - 脚本之家 - Python - 对pandas中两种数据类型Series和DataFrame的区别详解

对pandas中两种数据类型Series和DataFrame的区别详解

2021-04-18 00:23jolingcome Python

今天小编就为大家分享一篇对pandas中两种数据类型Series和DataFrame的区别详解，具有很好的参考价值，希望对大家有所帮助。一起跟随小编过来看看吧

1. series相当于数组numpy.array类似

?
1
2
3
4
5
6
7
8
9
s1=pd.series([1,2,4,6,7,2])
s2=pd.series([4,3,1,57,8],index=['a','b','c','d','e'])
print s2
obj1=s2.values
# print obj1
obj2=s2.index
# print obj2
# print s2[s2>4]
# print s2['b']

对pandas中两种数据类型Series和DataFrame的区别详解

1.series 它是有索引，如果我们未指定索引，则是以数字自动生成。

下面是一些例子：

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
obj=series([4,7,-5,3])
print obj
#输出结果如下：
# 0  4
# 1  7
# 2  -5
# 3  3
print obj.values #取出它的值
#[ 4 7 -5 3]
print obj.index #取出索引值
#输出结果如下：
# rangeindex(start=0, stop=4, step=1)
obj2=series([4,7,-5,3],index=['d','b','a','c'])
print obj2
#输出结果如下：
# d  4
# b  7
# a  -5
# c  3
#可以通过索引的方式选择series中的单个或一组值
print obj2['a'] #输出结果：-5
print obj2['d'] #输出结是：4

2. series的一些操作

series.order()进行排序，而dataframe则用sort或者sort_index

?
1
print ratings_by_title.order(ascending=false)[:10]

（1）numpy数组运算(根据布尔型数组进行过滤、标量乘法、应用数学函数等)都会保留索引和值之间的链接

?
1
2
3
4
5
6
7
8
9
10
11
print obj2[obj2>0] #取出>0的值
#输出结果如下：
# d  4
# b  7
# c  3
print obj2*2
#输出结果如下：
# d   8
# b  14
# a  -10
# c   6

（2）还可以将series看成是一个定长的有序字典，因为它是索引值到数据值的一个映射。它可以用在许多原来需要字典参数的函数中。

?
1
print 'b' in obj2 #obj2中有索引'b'?若有就返回'true'

（3）如果数据被存在一个python字典中，也可以直接通过这个字典来创建series.

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
sdata={'ohio':35000,'texax':71000,'oregon':16000,'utah':5000}
obj3=series(sdata)
print obj3
#输出结果如下：
# ohio   35000
# oregon  16000
# texax   71000
# utah    5000
#注：如果只传入一个字典，则结果series中的索引就是原字典的键(有序排列)
states=['california','ohio','oregon','texax']
obj4=series(sdata,index=states) #将sdata字典创建series,索引用states来创建
print obj4
#california在sdata中没有相应的值，故是nan缺省值
# california    nan
# ohio     35000.0
# oregon    16000.0
# texax     71000.0

（4）pandas中的isnull和notnull函数可以用于检测缺失数据，series也有类似的方法

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
print pd.isnull(obj4)
#输出结果如下：
# california   true
# ohio     false
# oregon    false
# texax     false
# dtype: bool
print pd.notnull(obj4)
#输出结果如下：
# california  false
# ohio      true
# oregon     true
# texax     true
# dtype: bool
print obj4.isnull() #series的isnull方法
#输出结果如下：
# california   true
# ohio     false
# oregon    false
# texax     false
# dtype: bool

（5）series最重要的一个功能是：它在算术运算中会自动对齐不同索引的数据。

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
print obj3,obj4
# ohio   35000
# oregon  16000
# texax   71000
# utah    5000
# dtype: int64
#
# california    nan
# ohio     35000.0
# oregon    16000.0
# texax     71000.0
# dtype: float64
print obj3+obj4
# california     nan
# ohio      70000.0
# oregon     32000.0
# texax     142000.0
# utah        nan
# dtype: float64

（6）series对象本身及其索引都有一个name属性，该属性跟pandas其他的关键功能关系非常密切

?
1
2
3
4
5
6
7
8
9
10
obj4.name='population'
obj4.index.name='state'
print obj4
#输出如下：加上state和name
# state
# california    nan
# ohio     35000.0
# oregon    16000.0
# texax     71000.0
# name: population, dtype: float64

（7）series的索引可以通过赋值的方式就地修改

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
obj2.index=['bob','steven','jeff','ryan']
print obj2
#输出结果如下：
# bob    4
# steven  7
# jeff   -5
# ryan   3
# dtype: int64
obj2['bob']=15
print obj2
#输出结果如下：
# bob    15
# steven   7
# jeff   -5
# ryan    3
# dtype: int64
print obj2['bob'].values #没有这种表示法，报错。因为类似字典取值，直接取键值即可
print obj2.values #查看所有值

3. dataframe相当于有表格，有行表头和列表头

?
1
2
a=pd.dataframe(np.random.rand(4,5),index=list("abcd"),columns=list('abcde'))
print a

对pandas中两种数据类型Series和DataFrame的区别详解

4.dataframe的一些操作

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
#增加列或修改列
a['f']=[1,2,3,4]
a['e']=10
print a
print "======================="
#增加行或修改行
a.ix['d']=10
# print a
s=pd.dataframe(np.random.rand(4,6),index=list('efgh'),columns=list('abcdef'))
a=a.append(s)
print a
print "======================="
#切片
print (a[['b','e']]) #取'b','e'列
print a.loc['a':'d',['a','c','f']] #取'a'-'d'行'a','c','f'列
print "======================="
#减少行或减少列
a=a.drop(['c','d']) #删除'c'行和'd'
print a
a=a.drop('a',axis=1) #删除'a'列,axis=0表示行，axis=1表示列
print a
print "======================="
#缺省值处理
a.iloc[2,3]=none #取第三行第4列值设为none
a.iloc[4,0]=none #取第五行第1列值设为none
print a
a=a.fillna(5) #缺省值处(即nan处填充为5)
print a
#缺省值去行即有缺省值的把这一行都去掉
a.iloc[2,3]=none
a.iloc[4,0]=none
print a
a=a.dropna() #删除缺省值为nan的行
print a
print "======================="
#读取excel,适当改动后，保存到excel中
e1=pd.read_excel('test.xlsx',sheetname='sheet1')
e1.columns=['class','no','name','sex','dormitory','phonenumber']
print(e1)
print(e1.ix[2])
print(e1['class'])
print(e1.sex)
#可将取出的数据处理，处理完后再保存到excel中去
e2=pd.read_excel('test_copy.xlsx',sheetname='sheet1',names='table1',header=none)
e2.columns=['a','b','c','d']
print(e2)
e2.to_excel('test_write.xlsx',header=false,index=false)

(1)构建dataframe 的方法很多，最常用的一种是直接传入一个由等长列表或者numpy数组组成的字典

?
1
2
3
4
5
6
import numpy as np
from numpy import random
import matplotlib.pyplot as plt
from numpy.linalg import inv,qr
from pandas import series,dataframe
import pandas as pd
?
1
2
3
4
5
6
7
8
9
10
11
12
data={'state':['ohio','ohio','ohio','nevada','nevada'],
   'year':[2000,2001,2002,2001,2002],
   'pop':[1.5,1.7,3.6,2.4,2.9]}
frame=dataframe(data)
print frame
#输出的结果如下：
#  pop  state year
# 0 1.5  ohio 2000
# 1 1.7  ohio 2001
# 2 3.6  ohio 2002
# 3 2.4 nevada 2001
# 4 2.9 nevada 2002

（2）如果指定了列序列，则dataframe的列就会按照指定的顺序进行排序

?
1
2
3
4
5
6
7
8
9
frame1=dataframe(data,columns=['year','state','pop'])
print frame1
#输出的结果如下：
#  year  state pop
# 0 2000  ohio 1.5
# 1 2001  ohio 1.7
# 2 2002  ohio 3.6
# 3 2001 nevada 2.4
# 4 2002 nevada 2.9

（3）跟series一样，如果传入的列在数据中找不到，就会产生na值

?
1
2
3
4
5
6
7
8
9
10
11
12
13
frame2=dataframe(data,columns=['year','state','pop','debt'],
         index=['one','two','three','four','five']) #column列的索引，index是行的索引
print frame2
#输出的结果如下：
#    year  state pop debt
# one  2000  ohio 1.5 nan
# two  2001  ohio 1.7 nan
# three 2002  ohio 3.6 nan
# four  2001 nevada 2.4 nan
# five  2002 nevada 2.9 nan
print frame2.columns #输出列的索引
#输出结果如下：
# index([u'year', u'state', u'pop', u'debt'], dtype='object')

（4）类似字典标记的方式或属性的方式，可以将dataframe的列获取为一个series.

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
print frame2['state'] #取出列索引为state的列的数据
#输出结果如下：
# one    ohio
# two    ohio
# three   ohio
# four   nevada
# five   nevada
# name: state, dtype: object
print frame2.year
#输出结果如下：
# one   2000
# two   2001
# three  2002
# four   2001
# five   2002
# name: year, dtype: int64

（5）返回的series拥有原dataframe相同的索引，且其name属性也已经被相应地设置好了。行也可以通过位置或名称的方式进行获取

比如用索引字段ix,ix是取行的索引

?
1
2
3
4
5
6
7
print frame2.ix['three']
#输出的结果如下：
# year   2002
# state  ohio
# pop    3.6
# debt   nan
# name: three, dtype: object

（6）可以通过赋值的方式进行修改。

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
# frame2['debt']=16.5 #debt列全为16.5
# print frame2
#输出结果如下：
#    year  state pop debt
# one  2000  ohio 1.5 16.5
# two  2001  ohio 1.7 16.5
# three 2002  ohio 3.6 16.5
# four  2001 nevada 2.4 16.5
# five  2002 nevada 2.9 16.5
#将列表或数组赋值给某个列时，其长度必须跟dataframe的长度相匹配。
#如果赋值的是一个series,就会精确匹配dataframe的索引，所有的空位都将被填上缺失值。
frame2['debt']=np.arange(5.)
print frame2
#输出结果如下：
#    year  state pop debt
# one  2000  ohio 1.5  0.0
# two  2001  ohio 1.7  1.0
# three 2002  ohio 3.6  2.0
# four  2001 nevada 2.4  3.0
# five  2002 nevada 2.9  4.0
#赋值一个series
val=series([-1.2,-1.5,-1.7],index=['two','four','five'])
frame2['debt']=val
print frame2
#输出结果如下：不在index中的索引的值都赋了nan
#    year  state pop debt
# one  2000  ohio 1.5  nan
# two  2001  ohio 1.7 -1.2
# three 2002  ohio 3.6  nan
# four  2001 nevada 2.4 -1.5
# five  2002 nevada 2.9 -1.7
#为不存在的列赋值会创建出一个新列。关键字del用于删除列。
frame2['eastern']=frame2.state=='ohio' #没有eastern列，固会自动增加一列
#frame2.state=='ohio'如果等于则返回true,否则返回false
print frame2
#    year  state pop debt eastern
# one  2000  ohio 1.5  nan   true
# two  2001  ohio 1.7 -1.2   true
# three 2002  ohio 3.6  nan   true
# four  2001 nevada 2.4 -1.5  false
# five  2002 nevada 2.9 -1.7  false
del frame2['eastern'] #删除eastern列
print frame2
#返回结果如下：
#    year  state pop debt
# one  2000  ohio 1.5  nan
# two  2001  ohio 1.7 -1.2
# three 2002  ohio 3.6  nan
# four  2001 nevada 2.4 -1.5
# five  2002 nevada 2.9 -1.7
print frame2.columns #查看frame2的列
#输出结果如下：index([u'year', u'state', u'pop', u'debt'], dtype='object')

（7）另一种常见的数据形式是嵌套字典(也就是字典的字典)

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
pop={'nevada':{2001:2.4,2002:2.9},
   'ohio':{2000:1.5,2001:1.7,2002:3.6}}
frame3=dataframe(pop)
print frame3
#输出的结果如下：
#    nevada ohio
# 2000   nan  1.5
# 2001   2.4  1.7
# 2002   2.9  3.6
#可以对frame进行转置
print frame3.t
#输出结果如下：
#     2000 2001 2002
# nevada  nan  2.4  2.9
# ohio   1.5  1.7  3.6
print dataframe(pop,index=[2001,2002,2003])
#输出结果如下：
#    nevada ohio
# 2001   2.4  1.7
# 2002   2.9  3.6
# 2003   nan  nan
pdata={'ohio':frame3['ohio'][:-1],
    'nevada':frame3['nevada'][:2]}
print dataframe(pdata)
#输出结果如下：
#    nevada ohio
# 2000   nan  1.5
# 2001   2.4  1.7

可以输入给dataframe构造器的数据：

?
1
2
3
4
5
6
7
8
9
10
11
12
二维ndarray          数据矩阵，还可以传入行标和列标
由数组、列表或元组组成的字典  每个序列会变成dataframe的一列，所有序列的长度必须相同
numpy的结构化/记录数组   类似于“由数组组成的字典”
由series组成的字典   每个series会成为一列。如果没显式指定索引，由各series的索引会被合
     并成结果的行索引
由字典组成的字典   各内层字典会成为一列。键会被合并成结果的行索引，跟“由series组成的字典”
     的情况一样
字典或series的列表   各项将会成为dataframe的一行。字典键或series索引的并集将会成为dataframe
     的列标
由列表或元组组成的列表   类似于“二维ndarray”
另一个dataframe   该dataframe的索引将会被沿用，除非显式指定了其它索引
numpy的maskedarray   类似于"二维ndarray"的情况，只是掩码值在结果dataframe会变成na/缺失值
?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
#如果设置了dataframe的index和columns的name属性，则这些信息也会被显示出来：
frame3.index.name='year';
frame3.columns.name='state'
print frame3
#输出结果如下：
# state nevada ohio
# year
# 2000   nan  1.5
# 2001   2.4  1.7
# 2002   2.9  3.6
#跟series一样，values属性也会以二维ndarray的形式返回dataframe中的数据：
print frame3.values
# [[ nan 1.5]
# [ 2.4 1.7]
# [ 2.9 3.6]]
#如果dataframe各列的数据类型不同，则值数组的数据类型就会选用能兼容所有列的数据类型
print frame2.values
# [[2000 'ohio' 1.5 nan]
# [2001 'ohio' 1.7 -1.2]
# [2002 'ohio' 3.6 nan]
# [2001 'nevada' 2.4 -1.5]
# [2002 'nevada' 2.9 -1.7]]

以上这篇对pandas中两种数据类型series和dataframe的区别详解就是小编分享给大家的全部内容了，希望能给大家一个参考，也希望大家多多支持服务器之家。

原文链接：https://blog.csdn.net/u012474716/article/details/78550391

  • pandas
  • dataframe
  • series

    • 延伸 · 阅读

    精彩推荐
    最近更新
    编辑推荐
    阅读排行
    热门标签
    2048 　 6006 　 contextlib 　 SLOTS 　 MELIAE 　 FEEDPARSER 　 暂存 　 持久性管理 　 pickle模块 　 THREADING 　 reduce 　 nignx 　 装饰器 　 函数式编程 　 兔子毒药 　 监控文件 　 流量监控 　 Web框架 　 办公工具 　 PIL库 　 高斯模糊 　 wxPython 　 import 　 自定义模块 　 Python开发 　 元类 　 metaclass 　 魔术方法 　 DNSPod 　 动态解析域名 　
    © 2019-2023 脚本之家 | 服务器之家(www.zzvips.com)旗下站点 版权所有关于我们联系我们版权申明网站地图