pandas的数据结构介绍,利用python进行数据分析

作者: 网络编程  发布:2019-09-03

《利用python进行数据分析》读书笔记--第五章 pandas入门,pythonpandas

pandas是本书后续内容的首选库。pandas可以满足以下需求:

  • 具备按轴自动或显式数据对齐功能的数据结构。这可以防止许多由于数据未对齐以及来自不同数据源(索引方式不同)的数据而导致的常见错误。.
  • 集成时间序列功能
  • 既能处理时间序列数据也能处理非时间序列数据的数据结构
  • 数学运算和简约(比如对某个轴求和)可以根据不同的元数据(轴编号)执行
  • 灵活处理缺失数据
  • 合并及其他出现在常见数据库(例如基于SQL的)中的关系型运算

pandas数据结构介绍

两个数据结构:Series和DataFrame。Series是一种类似于以为NumPy数组的对象,它由一组数据(各种NumPy数据类型)和与之相关的一组数据标签(即索引)组成的。可以用index和values分别规定索引和值。如果不规定索引,会自动创建 0 到 N-1 索引。

#-*- encoding:utf-8 -*-
import numpy as np
import pandas as pd
from pandas import Series,DataFrame

#Series可以设置index,有点像字典,用index索引
obj = Series([1,2,3],index=['a','b','c'])
#print obj['a']
#也就是说,可以用字典直接创建Series

dic = dict(key = ['a','b','c'],value = [1,2,3])
dic = Series(dic)
#下面注意可以利用一个字符串更新键值
key1 = ['a','b','c','d']
#注意下面的语句可以将 Series 对象中的值提取出来,不过要知道的字典是不能这么做提取的
dic1 = Series(obj,index = key1)
#print dic
#print dic1
#isnull 和  notnull 是用来检测缺失数据
#print pd.isnull(dic1)
#Series很重要的功能就是按照键值自动对齐功能
dic2 = Series([10,20,30,40],index = ['a','b','c','e'])
#print dic1 + dic2
#name属性,可以起名字
dic1.name = 's1'
dic1.index.name = 'key1'
#Series 的索引可以就地修改
dic1.index = ['x','y','z','w']

DataFrame是一种表格型结构,含有一组有序的列,每一列可以是不同的数据类型。既有行索引,又有列索引,可以被看做由Series组成的字典(使用共同的索引)。跟其他类似的数据结构(比如R中的data.frame),DataFrame面向行和列的操作基本是平衡的。其实,DataFrame中的数据是以一个或者多个二维块存放的(不是列表、字典或者其他)。

#-*- encoding:utf-8 -*-
import numpy as np
import pandas as pd
from pandas import Series,DataFrame

#构建DataFrame可以直接传入等长的列表或Series组成的字典
#不等长会产生错误
data = {'a':[1,2,3],
        'c':[4,5,6],
        'b':[7,8,9]
}
#注意是按照列的名字进行列排序
frame = DataFrame(data)
#print frame
#指定列之后就会按照指定的进行排序
frame = DataFrame(data,columns=['a','c','b'])
print frame
#可以有空列,index是说行名
frame1 = DataFrame(data,columns = ['a','b','c','d'],index = ['one','two','three'])
print frame1
#用字典方式取列数据
print frame['a']
print frame.b
#列数据的修改直接选出来重新赋值即可
#行,可以用行名或者行数来进行选取
print frame1.ix['two']
#为列赋值,如果是Series,规定了index后可以精确赋值
frame1['d'] = Series([100,200,300],index = ['two','one','three'])
print frame1
#删除列用del 函数
del frame1['d']
#警告:通过列名选出来的是Series的视图,并不是副本,可用Series copy方法得到副本

另一种常见的机构是嵌套字典,即字典的字典,这样的机构会默认为外键为列,内列为行。

#-*- encoding:utf-8 -*-
import numpy as np
import pandas as pd
from pandas import Series,DataFrame
#内层字典的键值会被合并、排序以形成最终的索引
pop = {'Nevada':{2001:2.4,2002:2.9},
       'Ohio':{2000:1.5,2001:1.7,2002:3.6}}
frame3 = DataFrame(pop)
#rint frame3
#Dataframe也有行和列有name属性,DataFrame有value属性
frame3.index.name = 'year'
frame3.columns.name = 'state'
print frame3
print frame3.values

下面列出了DataFrame构造函数能够接受的各种数据。

索引对象

#-*- encoding:utf-8 -*-
import numpy as np
import pandas as pd
from pandas import Series,DataFrame
#pandas索引对象负责管理轴标签和其他元数据,构建Series和DataFrame时,所用到的任何数组或其他序列的标签都被转换为Index
obj = Series(range(3),index = ['a','b','c'])
index = obj.index
#print index
#索引对象是无法修改的,这非常重要,因为这样才会使得Index对象在多个数据结构之间安全共享
index1 = pd.Index(np.arange(3))
obj2 = Series([1.5,-2.5,0],index = index1)
print obj2.index is index1

#除了长得像数组,Index的功能也类似一个固定大小的集合
print 'Ohio' in frame3.columns
print 2003 in frame3.index

pandas中的Index是一个类,pandas中主要的Index对象(什么时候用到)。

下面是Index的方法与属性,值得注意的是:index并不是数组。

基本功能

下面介绍基本的Series 和 DataFrame 数据处理手段。首先是索引:

#-*- encoding:utf-8 -*-
import numpy as np
import pandas as pd
import matplotlib.pyplot as plt
from pandas import Series,DataFrame

#Series有一个reindex函数,可以将索引重排,以致元素顺序发生变化

obj = Series([1,2,3,4],index=['a','b','c','d'])
#注意这里的reindex并不改变obj的值,得到的是一个“副本”
#fill_value 显然是填充空的index的值
#print obj.reindex(['a','c','d','b','e'],fill_value = 0)
#print obj
obj2 = Series(['red','blue'],index=[0,4])
#method = ffill,意味着前向值填充
obj3 = obj2.reindex(range(6),method='ffill')
#print obj3

#DataFrame 的reindex可以修改行、列或者两个都改
frame = DataFrame(np.arange(9).reshape((3,3)),index = ['a','c','d'],columns = ['Ohio','Texas','California'])
#只是传入一列数,是对行进行reindex,因为...frame的行参数叫index...(我这么猜的)
frame2 = frame.reindex(['a','b','c','d'])
#print frame2
#当传入原来没有的index是,当然返回的是空NaN
#frame3 = frame.reindex(['e'])
#print frame3
states = ['Texas','Utah','California']
#这是对行、列重排
#注意:这里的method是对index 也就是行进行的填充,列是不能填充的(不管method的位置如何)
frame4 = frame.reindex(index = ['a','b','c','d'],columns=states,method = 'ffill')
#print frame4

#使用ix的标签索引功能,重新索引变得比较简洁
print frame.ix[['a','d','c','b'],states]

关于ix,是DataFrame的一个方法,

丢弃指定轴上的项

#-*- encoding:utf-8 -*-
import numpy as np
import pandas as pd
import matplotlib.pyplot as plt
from pandas import Series,DataFrame
#drop函数可以丢弃轴上的列、行值
obj = Series(np.arange(3.),index = ['a','b','c'])
#原Series并不丢弃
obj.drop('b')
#print obj
#注意下面,行可以随意丢弃,列需要加axis = 1
print frame.drop(['a'])
print frame.drop(['Ohio'],axis = 1)

下面说索引、选取和过滤

#-*- encoding:utf-8 -*-
import numpy as np
import pandas as pd
import matplotlib.pyplot as plt
from pandas import Series,DataFrame

obj = Series([1,2,3,4],index=['a','b','c','d'])
frame = DataFrame(np.arange(9).reshape((3,3)),index = ['a','c','d'],columns = ['Ohio','Texas','California'])

#Series切片和索引
#print obj[obj < 2]
#注意:利用标签的切片与python的切片不同,两端都是包含的(有道理)
print obj['b':'c']
#对于DataFrame,列可以直接用名称
print frame['Ohio']
#特殊情况:通过切片和bool型索引,得到的是行(有道理)
print frame[:2]
print frame[frame['Ohio'] != 0]
#下面的方式是对frame所有元素都适用,不是行或者列,下面的得到的是numpy.ndarray类型的数据
print frame[frame < 5],type(frame[frame < 5])
frame[frame < 5] = 0
print frame

#对于DataFrame上的标签索引,用ix进行
print frame.ix[['a','d'],['Ohio','Texas']]
print frame.ix[2] #注意这里默认取行
#注意下面默认取行
print frame.ix[frame.Ohio > 0]
#注意下面的逗号后面是列标
print frame.ix[frame.Ohio > 0,:2]

下面是常用的索引选项:

算术运算和数据对齐

#pandas 有一个重要的功能就是能够根据索引自动对齐,其中索引不重合的部分值为NaN
s1 = Series([1,2,3],['a','b','c'])
s2 = Series([4,5,6],['b','c','d'])
#print s1 + s2
df1 = DataFrame(np.arange(12.).reshape(3,4),columns=list('abcd'))
df2 = DataFrame(np.arange(20.).reshape(4,5),columns=list('abcde'))
#print df1 + df2
#使用add方法,并传入填充值,注意下面的fill_value函数是先对应填充再进行加和,而不是加和得到NaN之后再填充
#print df1.add(df2,fill_value = 1000)
#df1.reindex(columns = df2.columns,fill_value=0)

除了add之外,还有其他的方法:

DataFrame和Series之间的运算

#下面看一下DataFrame和Series之间的计算过程
arr = DataFrame(np.arange(12.).reshape((3,4)),columns = list('abcd'))
#下面的结果标明,就是按行分别相减即可,叫做 broadcasting
#注意:默认情况下,DataFrame和Series的计算会将Series的索引匹配到DataFrame的列,然后进行计算,再沿着行一直向下广播
#注意:下面的式子中,如果写arr - arr[0]是错的,因为只有标签索引函数ix后面加数字才表示行
print arr - arr.ix[0]
Series2 = Series(range(3),index = list('cdf'))
#按照规则,在不匹配的列会形成NaN值
print arr + Series2
#如果想匹配行且在列上广播,需要用到算术运算方法
Series3 = arr['d']
#axis就是希望匹配的轴
print arr.sub(Series3,axis = 0)

下面是函数应用和映射

#-*- encoding:utf-8 -*-
import numpy as np
import pandas as pd
import matplotlib.pyplot as plt
from pandas import Series,DataFrame

#NumPy的元素级数组方法也适用于pandas对象
frame = DataFrame(np.random.randn(4,3),columns = list('abc'),index = ['Ut','Oh','Te','Or'])
print frame
#下面是求绝对值:
#print np.abs(frame)
#另一种常见的做法是:将一个函数应用到行或者列上,用apply方法,与R语言类似
fun = lambda x:x.max() - x.min()
#默认是应用在每一列上
print frame.apply(fun)
#下面是应用在列上
print frame.apply(fun,axis = 1)
#很多统计函数根本不用apply,直接调用方法就可以了
print frame.sum()
#除了标量值之外,apply函数后面还可以接返回多个值组成的的Series的函数,有没有很漂亮?
def f(x):
    return Series([x.min(),x.max()],index = ['min','max'])
#print frame.apply(f)
#元素级的python函数也是可以用的,但是要使用applymap函数
format = lambda x: '%.2f' % x
print frame.applymap(format)
#之所以要用applymap是因为Series有一个应用于元素级函数的map方法??
#这里的map很有用
print frame['b'].map(format)

排序与排名

#-*- encoding:utf-8 -*-
import numpy as np
import pandas as pd
import matplotlib.pyplot as plt
from pandas import Series,DataFrame
#用sort_index函数对行、列的索引进行排序
obj = Series(range(4),index = ['d','a','b','c'])
print obj.sort_index()

frame = DataFrame(np.arange(8).reshape((2,4)),index = ['three','one'],columns = ['d','a','b','c'])
#默认是对行 “索引” 进行排序,如果对列 “索引” 进行排序,axis = 1 即可
print frame.sort_index()
print frame.sort_index(axis = 1)
print frame.sort_index(axis = 1,ascending = False)

#如果对值进行排序,用的是order函数,注意所有的缺失值会放到最后(如果有的话)
print obj.order()
#numpy中的sort也可以用来排序
print np.sort(obj)
#如果相对DataFrame的值进行排序,函数还是sort_index,只不过后面需要加一个参数by
frame = DataFrame({'b':[4,7,-3,2],'a':[0,1,0,1]})
print frame.sort_index(by = ['a','b'])

#rank函数返回从小到大排序的下标,对于平级的数,rank是通过“为各组分配一个平均排名”的方式破坏评级关系
#下标从1开始
obj = Series([7,-5,7,4,2,0,4])
print obj.rank()
#而numpy中的argsort函数比较奇怪,返回的是把数据进行排序之后,按照值得顺序对应的下标,下标从0开始
print np.argsort(obj)
 #打印结果为:1,5,4,3,6,0,2 按照这个下标顺序恰好可以得到从小打到的值,见下面
print obj[np.argsort(obj)]
#rank函数中有一个method选项,用来规定下标的方式

print obj.rank(method = 'first',ascending=False)
print obj.rank(method = 'max',ascending=False)
print obj.rank(method = 'min',ascending=False)

#对于DataFrame,rank函数默认把每一列排好并返回坐标
print frame.rank()
print frame.rank(axis = 1)

带有重复值的轴索引

#-*- encoding:utf-8 -*-
import numpy as np
import pandas as pd
import matplotlib.pyplot as plt
from pandas import Series,DataFrame

#虽然pandas的很多函数(如reindex)要求标签唯一,但是并不具有强制性
obj = Series(range(5),index = list('aabbc'))
print obj
#索引是否唯一用is_unique看是否唯一
print obj.index.is_unique
#对于重复值的索引,选取的话返回一个Series,唯一的索引返回一个标量
print obj['a']
#对于DataFrame也是如此
df = DataFrame(np.random.randn(4,3),index = list('aabb'))
print df
print df.ix['b']
#####自己导入数据的时候数据处理之前可以做一下index唯一性等,自己创建DataFrame注意不能这样

汇总和计算描述统计

#-*- encoding:utf-8 -*-
import numpy as np
import os
import pandas as pd
from pandas import Series,DataFrame
import matplotlib.pyplot as plt
import time

#pandas 对象拥有一组常用的数学和统计方法,大部分属于简约统计,用于从Series中提取一个值,或者   从DataFrame中提取一列或者一行Series
#注意:与NumPy数组相比,这些函数都是基于没有缺失数据的建设构建的,也就是说:这些函数会自动忽略缺失值。
df = DataFrame([[1.4,np.nan],[7.1,-4.5],[np.nan,np.nan],[0.75,-1.3]],index = list('abcd'),columns=['one','two'])
print df.sum()
print df.sum(axis = 1)
#下面是一些函数,idxmin 和 idmax 返回的是达到最小或者最大的索引
print df.idxmin()
print df.idxmin(axis=1)
#关于累积型的函数
print df.cumsum()
#describe函数,与R语言中的describe函数基本相同
print df.describe()
#对于非数值型的数据,看看下面的结果

obj = Series(['c','a','a','b','d'] * 4)
print obj.describe()
'''
结果为:
count     20
unique     4
top        a
freq       8
其中,freq是指字母出现的最高频率
'''

#-*- encoding:utf-8 -*-
import numpy as np
import os
import pandas as pd
from pandas import Series,DataFrame
import matplotlib.pyplot as plt
import time

#下面看一下cummin函数
#注意:这里的cummin函数是截止到目前为止的最小值,而不是加和以后的最小值
frame = DataFrame([[1,2,3,4],[5,6,7,8],[-10,11,12,-13]],index = list('abc'),columns = ['one','two','three','four'])
print frame.cummin()
print frame

>>>

   one  two  three  four
a    1    2      3     4
b    1    2      3     4
c  -10    2      3   -13
   one  two  three  four
a    1    2      3     4
b    5    6      7     8
c  -10   11     12   -13

pandas入门,pythonpandas pandas是本书后续内容的首选库。pandas可以满足以下需求: 具备按轴自动...

pandas的数据结构介绍

要使用pandas,你首先就得熟悉它的两个主要数据结构:Series和DataFrame。虽然它们并不能解决所有问题,但它们为大多数应用提供了一种可靠的、易于使用的基础。

In [1]: from pandas import Series,DataFrame

In [2]: import pandas as pd

In [3]: import numpy as np

Series

Series是一种类似于一维数组的对象,它由一组数据(各种NumPy数据类型)以及一组与之相关的数据标签(即索引)组成。仅由一组数据即可产生最简单的Series。

In [4]: obj=Series([5,8,-6,2])

In [5]: obj
Out[5]: 
0 5
1 8
2 -6
3 2
dtype: int64

Series的字符串表现形式为:索引在左边,值在右边。由于我们没有为数据指定索引,于是会自动创建一个0到N1(N为数据的长度)的整数型索引。你可以通过Series 的values和index属性获取其数组表示形式和索引对象。

In [6]: obj.values
Out[6]: array([ 5, 8, -6, 2], dtype=int64)

In [7]: obj.index
Out[7]: RangeIndex(start=0, stop=4, step=1)

希望所创建的Series带有一个可以对各个数据点进行标记的索引

In [8]: obj2=Series([4,8,-6,3],index=['d','a','b','c'])

In [9]: obj2
Out[9]: 
d 4
a 8
b -6
c 3
dtype: int64

与普通NumPy数组相比,你可以通过索引的方式选取Series中的单个或一组值

In [10]: obj2['b']
Out[10]: -6

In [11]: obj2['d']=9

In [12]: obj2[['c','a','d']]
Out[12]: 
c 3
a 8
d 9
dtype: int64

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

In [13]: obj2
Out[13]: 
d 9
a 8
b -6
c 3
dtype: int64

In [14]: obj2[obj2>0]
Out[14]: 
d 9
a 8
c 3
dtype: int64

In [15]: obj2*3
Out[15]: 
d 27
a 24
b -18
c 9
dtype: int64

In [16]: np.exp(obj2)
Out[16]: 
d 8103.083928
a 2980.957987
b 0.002479
c 20.085537
dtype: float64

可以将Series看成是一个定长的有序字典,因为它是索引值到数据值的一个映射。它可以用在许多原本需要字典参数的函数中。

In [17]: 'b' in obj2
Out[17]: True

In [18]: 'k' in obj2
Out[18]: False

如果数据被存放在一个Python字典中,也可以直接通过这个字典来创建Series

In [19]: sdata = {'Ohio': 35000, 'Texas': 71000, 'Oregon': 16000, 'Utah': 5000}

In [20]: obj3=Series(sdata)

In [21]: obj3
Out[21]: 
Ohio 35000
Oregon 16000
Texas 71000
Utah 5000
dtype: int64

如果只传入一个字典,则结果Series中的索引就是原字典的键(有序排列)

In [22]: states = ['California', 'Ohio', 'Oregon', 'Texas']

In [23]: obj4 = Series(sdata, index=states)

In [24]: obj4
Out[24]: 
California NaN
Ohio 35000.0
Oregon 16000.0
Texas 71000.0
dtype: float64

sdata中跟states索引相匹配的那3个值会被找出来并放到相应的位置上,但由于"California"所对应的sdata值找不到,所以其结果就为NaN(即“非数字”(not a number),在pandas中,它用于表示缺失或NA值)。我将使用缺失(missing)或NA表示缺失数据。pandas的isnull和notnull函数可用于检测缺失数据

In [25]: pd.isnull(obj4)
Out[25]: 
California True
Ohio False
Oregon False
Texas False
dtype: bool

In [26]: pd.notnull(obj4)
Out[26]: 
California False
Ohio True
Oregon True
Texas True
dtype: bool

In [27]: obj4.isnull()
Out[27]: 
California True
Ohio False
Oregon False
Texas False
dtype: bool

Series最重要的一个功能是:它在算术运算中会自动对齐不同索引的数据。

In [28]: obj3
Out[28]: 
Ohio 35000
Oregon 16000
Texas 71000
Utah 5000
dtype: int64

In [29]: obj4
Out[29]: 
California NaN
Ohio 35000.0
Oregon 16000.0
Texas 71000.0
dtype: float64

In [30]: obj3+obj4
Out[30]: 
California NaN
Ohio 70000.0
Oregon 32000.0
Texas 142000.0
Utah NaN
dtype: float64

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

In [31]: obj4.name = 'population'

In [32]: obj4.index.name = 'state'

In [33]: obj4
Out[33]: 
state
California NaN
Ohio 35000.0
Oregon 16000.0
Texas 71000.0
Name: population, dtype: float64

In [34]: obj
Out[34]: 
0 5
1 8
2 -6
3 2
dtype: int64

Series的索引可以通过赋值的方式就地修改

In [35]: obj.index = ['Bob', 'Steve', 'Jeff', 'Ryan']

In [36]: obj
Out[36]: 
Bob 5
Steve 8
Jeff -6
Ryan 2
dtype: int64

DataFrame

DataFrame是一个表格型的数据结构,它含有一组有序的列,每列可以是不同的值类型(数值、字符串、布尔值等)。DataFrame既有行索引也有列索引,它可以被看做由Series组成的字典(共用同一个索引)。DataFrame中的数据是以一个或多个二维块存放的(而不是列表、字典或别的一维数据结构)。
注意: 虽然DataFrame是以二维结构保存数据的,但你仍然可以轻松地将其表示为更高维度的数据。

构建DataFrame的办法有很多,最常用的一种是直接传入一个由等长列表或NumPy数组组成的字典。

In [37]: data = {'state': ['Ohio', 'Ohio', 'Ohio', 'Nevada', 'Nevada'],
    ...:         'year': [2000, 2001, 2002, 2001, 2002],
    ...:         'pop': [1.5, 1.7, 3.6, 2.4, 2.9]}

In [38]: frame=DataFrame(data)

结果DataFrame会自动加上索引(跟Series一样),且全部列会被有序排列

In [39]: frame
Out[39]: 
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

如果指定了列序列,则DataFrame的列就会按照指定顺序进行排序

In [40]: DataFrame(data, columns=['year', 'state', 'pop'])
Out[40]: 
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

In [41]: frame2 = DataFrame(data, columns=['year', 'state', 'pop', 'debt'],
    ...:                       index=['one', 'two', 'three', 'four', 'five'])

跟Series一样,如果传入的列在数据中找不到,就会产生NA值

In [42]: frame2
Out[42]: 
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

In [43]: frame2.columns
Out[43]: Index(['year', 'state', 'pop', 'debt'], dtype='object')

通过类似字典标记的方式或属性的方式,可以将DataFrame的列获取为一个Series

In [44]: frame2['state']
Out[44]: 
one Ohio
two Ohio
three Ohio
four Nevada
five Nevada
Name: state, dtype: object

In [45]: frame2.year
Out[45]: 
one 2000
two 2001
three 2002
four 2001
five 2002
Name: year, dtype: int64

注意,返回的Series拥有原DataFrame相同的索引,且其name属性也已经被相应地设置好了。行也可以通过位置或名称的方式进行获取,比如用索引字段ix(被舍弃使用),可以使用loc

In [46]: frame2.ix['three']
C:ProgramDataAnaconda3libsite-packagesipykernel_launcher.py:1: DeprecationWarning: 
.ix is deprecated. Please use
.loc for label based indexing or
.iloc for positional indexing

See the documentation here:
http://pandas.pydata.org/pandas-docs/stable/indexing.html#deprecate_ix
"""Entry point for launching an IPython kernel.
Out[46]: 
year 2002
state Ohio
pop 3.6
debt NaN
Name: three, dtype: object

In [47]: frame2.loc['three']
Out[47]: 
year 2002
state Ohio
pop 3.6
debt NaN
Name: three, dtype: object

列可以通过赋值的方式进行修改。例如,我们可以给那个空的"debt"列赋上一个标量值或一组值

In [48]: frame2['debt'] = 18.5

In [49]: frame2
Out[49]: 
year state pop debt
one 2000 Ohio 1.5 18.5
two 2001 Ohio 1.7 18.5
three 2002 Ohio 3.6 18.5
four 2001 Nevada 2.4 18.5
five 2002 Nevada 2.9 18.5

In [50]: frame2['debt'] = np.arange(5.)

In [51]: frame2
Out[51]: 
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

将列表或数组赋值给某个列时,其长度必须跟DataFrame的长度相匹配。如果赋值的是一个Series,就会精确匹配DataFrame的索引,所有的空位都将被填上缺失值

In [52]: val = Series([-1.2, -1.5, -1.7], index=['two', 'four', 'five'])

In [53]: frame2['debt']=val

In [54]: frame2
Out[54]: 
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用于删除列

In [55]: frame2['eastern'] = frame2.state == 'Ohio'

In [56]: frame2
Out[56]: 
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

In [57]: del frame2['eastern']

In [58]: frame2.columns
Out[58]: Index(['year', 'state', 'pop', 'debt'], dtype='object')

警告: 通过索引方式返回的列只是相应数据的视图而已,并不是副本。因此,对返回的Series所做的任何就地修改全都会反映到源DataFrame上。通过Series的copy方法即可显式地复制列。
另一种常见的数据形式是嵌套字典(也就是字典的字典),如果将它传给DataFrame,它就会被解释为:外层字典的键作为列,内层键则作为行索引。

In [64]: pop = {'Nevada': {2001: 2.4, 2002: 2.9},'Ohio': {2000: 1.5, 2001: 1.7, 2002: 3.6}}
In [65]: frame3=DataFrame(pop)
In [66]: frame3
Out[66]: 
Nevada Ohio
2000 NaN 1.5
2001 2.4 1.7
2002 2.9 3.6

对该结果进行转置

In [67]: frame3.T
Out[67]: 
2000 2001 2002
Nevada NaN 2.4 2.9
Ohio 1.5 1.7 3.6

内层字典的键会被合并、排序以形成最终的索引。如果显式指定了索引,则不会这样

In [68]: DataFrame(pop, index=[2001, 2002, 2003])
Out[68]: 
Nevada Ohio
2001 2.4 1.7
2002 2.9 3.6
2003 NaN NaN

由Series组成的字典差不多也是一样的用法

In [69]: pdata = {'Ohio': frame3['Ohio'][:-1],'Nevada': frame3['Nevada'][:2]}

In [70]: DataFrame(pdata)
Out[70]: 
Nevada Ohio
2000 NaN 1.5
2001 2.4 1.7

表5-1列出了DataFrame构造函数所能接受的各种数据

图片 1

如果设置了DataFrame的index和columns的name属性,则这些信息也会被显示出来

In [71]: frame3.index.name = 'year'; frame3.columns.name = 'state'
In [72]: frame3
Out[72]: 
state Nevada Ohio
year 
2000 NaN 1.5
2001 2.4 1.7
2002 2.9 3.6

跟Series一样,values属性也会以二维ndarray的形式返回DataFrame中的数据

In [73]: frame3.values
Out[73]: 
array([[ nan, 1.5],
[ 2.4, 1.7],
[ 2.9, 3.6]])

如果DataFrame各列的数据类型不同,则值数组的数据类型就会选用能兼容所有列的数据类型

In [74]: frame2.values
Out[74]: 
array([[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]], dtype=object)

索引对象
pandas的索引对象负责管理轴标签和其他元数据(比如轴名称等)。构建Series或DataFrame时,所用到的任何数组或其他序列的标签都会被转换成一个Index:

In [75]: obj = Series(range(3), index=['a', 'b', 'c'])

In [76]: obj
Out[76]: 
a 0
b 1
c 2
dtype: int32

In [77]: index=obj.index

In [78]: index
Out[78]: Index(['a', 'b', 'c'], dtype='object')

In [79]: index[1:]
Out[79]: Index(['b', 'c'], dtype='object')

Index对象是不可修改的(immutable),因此用户不能对其进行修改

In [80]: index[1]='d'
---------------------------------------------------------------------------
TypeError Traceback (most recent call last)
<ipython-input-80-d3f90986bdb1> in <module>()
----> 1 index[1]='d'

C:ProgramDataAnaconda3libsite-packagespandascoreindexesbase.py in __setitem__(self, key, value)
1618 
1619 def __setitem__(self, key, value):
-> 1620 raise TypeError("Index does not support mutable operations")
1621 
1622 def __getitem__(self, key):

TypeError: Index does not support mutable operations

不可修改性非常重要,因为这样才能使Index对象在多个数据结构之间安全共享

In [81]: index = pd.index(np.arange(3))
---------------------------------------------------------------------------
AttributeError Traceback (most recent call last)
<ipython-input-81-5eb0f1ff3872> in <module>()
----> 1 index = pd.index(np.arange(3))

AttributeError: module 'pandas' has no attribute 'index'

In [82]: index = pd.Index(np.arange(3))

In [83]: index
Out[83]: Int64Index([0, 1, 2], dtype='int64')

In [84]: obj2 = Series([1.5, -3.5, 0], index=index)

In [85]: obj2
Out[85]: 
0 1.5
1 -3.5
2 0.0
dtype: float64

In [86]: obj2.index is index
Out[86]: True

表5-2列出了pandas库中内置的Index类

图片 2

除了长得像数组,Index的功能也类似一个固定大小的集合

In [87]: frame3
Out[87]: 
state Nevada Ohio
year 
2000 NaN 1.5
2001 2.4 1.7
2002 2.9 3.6

In [88]: 'Ohio' in frame3.columns
Out[88]: True

In [89]: 2003 in frame3.index
Out[89]: False

每个索引都有一些方法和属性,它们可用于设置逻辑并回答有关该索引所包含的数据的常见问题。表5-3列出了这些函数。

图片 3

pandas数据结构的按照书本上进行练习,通过练习操作,可以更好的懂着这些基本的数据结构。

本文由王中王开奖结果发布于网络编程,转载请注明出处:pandas的数据结构介绍,利用python进行数据分析

关键词:

上一篇:推荐系统,集体智慧编程推荐
下一篇:没有了