gumby

python数据结构（DataStructure）

importpandasaspd

importnumpyasnp

asplt

⼀、DataStructure

列表是Python⾃带的数据结构，是⼀个按照定顺序存储对象的数据结构。通常通过索引访问列表，索引从0开始。

(1)修改列表:给列表赋值

x=[1,1,1]

x[1]=2#使⽤索引法给特定位置的元素赋值

x

[1,2,1]

len(x)

3

x[100]=2#注意：不能给不存在的元素赋值，如果列表的长度为2，就不能给索引为100的元素赋值

---------------------------------------------------------------------------

IndexErrorTraceback(mostrecentcalllast)

in()

---->1x[100]=2

IndexError:listassignmentindexoutofrange

x=[None]*101

x[100]=2

len(x)#将x的长度初始化为101

101

（2）删除元素

sample_list=[1,2,3]

delsample_list[2]#删除列表中的元素

sample_list

[1,2]

（3）切⽚

除开可以使⽤索引来访问单个元素外，还可以使⽤切⽚来访问特定范围内的元素，切⽚⽤于提取序列的元素，第⼀个索引是包含在切⽚内，

但第⼆个索引是切⽚后余下的第⼀个元素的编号

sample_list[0:2]#取第⼀个到第⼆个元素

[1,2]

sample_list[1:]#取第⼆个到最后⼀个元素

[2,3]

sample_list[:2]#取第⼀个到第⼆个元素，序列起始于开头，可以省略前⾯的索引

[1,2]

sample_list[-2]#提取列表中倒数第⼆个元素

2

sample_list[-3:-1]#从倒数第三个到倒数第⼀个元素，不包括最后⼀个元素

[1,2]

sample_list[-3:0]#执⾏切⽚操作时，如果第⼀索引指定的元素位于第⼆个索引指定的元素的后⾯（倒数第3个元素位于第⼀个元素的后⾯），结果就为空序列。

[]

sample_list[-2:]#如果切⽚借宿于序列末尾，可以省略第⼆个索引

[2,3]

sample_list[:]#复制整个序列

[1,2,3]

''.join(a)

'hello'

(4)列表⽅法

⽅法是于对象联系紧密的函数，通常采⽤下⾯的调⽤⽅式：

(argument)

append：⽤于将⼀个对象附加到列表末尾

lst=[1,2,3]

(4)

lst

[1,2,3,4]

clear:就地清空列表内容

lst=[1,2,3]

()

lst

[]

copy:复制列表

lst=[1,2,3]

b=lst#常规的复制只是将另⼀个名称关联到列表

b[1]=4

lst

[1,4,3]

lst=[1,2,3]

b=()#不改变lst的值

b[1]=4

lst

[1,2,3]

extend：能够同时将多个值附加到列表末尾

和拼接的区别在于extend会修改被扩展的序列

a=[1,2,3]

b=[4,5,6]

(b)#extend会修改原来的序列

a

[1,2,3,4,5,6]

a=[1,2,3]

b=[4,5,6]

a+b

[1,2,3,4,5,6]

a#拼接不会修改原来的序列

[1,2,3]

a[len(a):]=b#采⽤该⽅式可以得到和extend同样的效果

a

[1,2,3,4,5,6]

index：在列表中查找值第⼀次出现的索引

knights=['We','are','the','knights','who','say','ni']

('who')#搜索单词who，返回其所在的索引

4

knights[4]#搜索索引为4的元素

'who'

inrt：⽤于将⼀个对象插⼊到列表中

numbers=[1,2,3,5,6,7]

(3,'four')#将four插⼊到索引为3的位置中

numbers

[1,2,3,'four',5,6,7]

numbers=[1,2,3,5,6,7]

numbers[3:3]=['four']#可以使⽤切⽚来进⾏相同的操作

numbers

[1,2,3,'four',5,6,7]

pop：从列表中删除⼀个元素（默认情况下删除末尾的元素），并返回该元素

x=[1,2,3]

()#删除末尾的元素

3

x

[1,2]

(0)#删除索引为0的元素

1

x

[2]

x=[1,2,3]

(())

x

[1,2,3]

remove:⽤于删除第⼀个为指定值的元素

x=['to','be','or','not','to','be']

('be')#删除第⼀个be

x

['to','or','not','to','be']

('bee')#当删除⼀个不在list中的元素时会报错

---------------------------------------------------------------------------

ValueErrorTraceback(mostrecentcalllast)

in()

---->('bee')

ValueError:(x):xnotinlist

rever:按相反的顺序排序列表中的元素

x=[1,2,3]

e()

x

[3,2,1]

sort:⽤于对列表就地排序

x=[4,6,2,1,7,9]

y=()#因为sort修改x是不反悔任何值额，最终的结果是x经过排序的，⽽y只包含none

print(y)#返回结果

None

x

[1,2,4,6,7,9]

###正确的⽅法

x=[4,6,2,1,7,9]

y=()#将x关联到y中

()

x

[4,6,2,1,7,9]

y

[1,2,4,6,7,9]

###法⼆：

x=[4,6,2,1,7,9]

y=sorted(x)#sorted()函数返回值

x

[4,6,2,1,7,9]

y

[1,2,4,6,7,9]

sorted('python')

['h','n','o','p','t','y']

x=[4,6,2,1,7,9]

(rever=True)#先对x进⾏排序再反转

x

[9,7,6,4,2,1]

集合跟數學中的集合是相同的概念，集合中國沒有重複的元素，並且元素之間沒有順序

t([1,2,3,2])#返回{1,2,3},利⽤t

a={1,2,3,2}#或者使⽤花括号

a

{1,2,3}

0xAF

175

x={}#default为dict

type(x)#可以使⽤type来查看

dict

x={"name":"cookie","age":12}#当有key值时表⽰dict

x

{'age':12,'name':'cookie'}

x={12,13,12,45}#当不存在key值时表⽰是dict

x

{12,13,45}

type(x)

t

元组由不能改变的元素组成，你可以像操作列表⼀样通过索引访问单个元素或者通过切⽚来访问多个元素）

（1）创建⼀个tuplle

1,2,3#tuple的语法很简单，只要讲⼀些值⽤逗号分隔开就能创建⼀个元组

(1,2,3)

(1,2,3)#或者使⽤圆括号

(1,2,3)

()#空元组⽤不包含任何内容的元括号表⽰

()

42

42

42,#虽然只有⼀个值，当后⾯也要加上逗号，表⽰创建的为元组

(42,)

（2）使⽤list创建tuple

tuple([1,2,3])

(1,2,3)

tuple('abc')

('a','b','c')

tuple((1,2,3))#如果参数本⾝已经是元组，则原封不动返回它

(1,2,3)

（3）tuple的访问

sample_tuple=(1,3,2)

sample_tuple[0]#访问tuple中的第⼀个元素

1

sample_tuple[0]=100#报错，因为元组中的元素时不能改变的

---------------------------------------------------------------------------

TypeErrorTraceback(mostrecentcalllast)

in()

---->1sample_tuple[0]=100#报错，因为元组中的元素时不能改变的

TypeError:'tuple'objectdoesnotsupportitemassignment

字典是有⼀个或多个键值对组成的列表。每个键与其值之间⽤冒号(:)分隔，项之间⽤逗号分隔，⽽整个字典放在花括号中。

(1)创建Dict

items=[('name','Gumby'),('age',42)]

items

[('name','Gumby'),('age',42)]

d=dict(items)#使⽤dict函数从其他映射或键-值对序列创建字典

d

{'age':42,'name':'Gumby'}

d['name']

'Gumby'

d=dict(name='Gumby',age=42)#使⽤dict函数时⽤等号

d

{'age':42,'name':'Gumby'}

d={age:42,name:'Gumby'}#key值要⽤引号括起来

---------------------------------------------------------------------------

NameErrorTraceback(mostrecentcalllast)

in()

---->1d={age:42,name:'Gumby'}

NameError:name'age'isnotdefined

d={'age':42,'name':'Gumby'}

d

{'age':42,'name':'Gumby'}

(2)dict的基本操作

x={}

x[42]='Foobar'#dict允许将⼀个值付给⼀个空字典的键42，⽽list则不允许这种操作

x

{42:'Foobar'}

len(x)#求字典包含的项数

1

delx[42]#删除x中key值为42的值

x

{}

sample_dict={'name':'daniel','age':27}

sample_dict['name']#字典中的值可以通过键进⾏访问

'daniel'

{'name':'cookie','scores':[12,30,20]}#键值对中的值可以是字符、字符串、数字、其它对象，⽐如列表等。

{'name':'cookie','scores':[12,30,20]}

（3）将字符串格式设置功能应⽤于字典

phonebook={'Beth':'9102','Alice':'2341','Cecil':'3258'}

phonebook

{'Alice':'2341','Beth':'9102','Cecil':'3258'}

"Cecil'sphonenumberis{Cecil}.".format_map(phonebook)

"Cecil'sphonenumberis3258."

(4)字典⽅法

clear：删除所有的字典项，这种操作时就地执⾏的，因此什么都不会反悔

d={}

d['name']='Gumby'

d['age']=42

d

{'age':42,'name':'Gumby'}

returned_value=()

d

{}

print(returned_value)#操作就地进⾏，且不返回任何值

None

copy：返回⼀个新字典

浅复制，当替换副本中的值时，原件不收影响

x={'urname':'admin','machines':['foo','bar','baz']}

y=()

y['urname']='mlh'

y['machines'].remove('bar')

y

{'machines':['foo','baz'],'urname':'mlh'}

x

{'machines':['foo','baz'],'urname':'admin'}

深复制，同时复制值及其包含的所有值

fromcopyimportdeepcopy

d={}

d['names']=['Alfred','Bertrand']

d

{'names':['Alfred','Bertrand']}

c=()#浅复制

dc=deepcopy(d)#深复制

d['names'].append('Clive')

c

{'names':['Alfred','Bertrand','Clive']}

dc

{'names':['Alfred','Bertrand']}

fromkeys:创建⼀个新字典，其中包含指定的键，且每个键对应的值都是None

{}.fromkeys(['name','age'])#先创建⼀个字典，再对其调⽤⽅法fromkeys来创建另⼀个字典

{'age':None,'name':None}

ys(['name','age'])#直接对dict调⽤⽅法fromkeys

{'age':None,'name':None}

ys(['name','age'],'(unknown)')#可以提供特定的值

{'age':'(unknown)','name':'(unknown)'}

get：⽅法get为访问字典提供了宽松的环境，如果您试图访问dict中没有的item，将会引发错误

d={}

print(d['name'])#访问dict中没有的item会引发错误

---------------------------------------------------------------------------

KeyErrorTraceback(mostrecentcalllast)

in()

---->1print(d['name'])

KeyError:'name'

print(('name'))#使⽤get访问不存在的key时，没有引发异常，⽽是返回None

None

('name','N/A')#可以指定默认的返回值

'N/A'

d['name']='Eric'

('name')#如果dict中包含指定的key，则get的作⽤和普通的字典查找⼀样

'Eric'

items:返回⼀个包含所有字典项的列表，其中每个元素都为（key，value）形式

d={'title':'pythonwebsite','url':'','spam':0}

()#返回值属于⼀种名为字典视图的特殊数据类型

dict_items([('title','pythonwebsite'),('url',''),('spam',0)])

it=()

len(it)#确定dict的长度

3

('spam',0)init#执⾏成员资格检查

True

d['spam']=1

('spam',0)init#视图的⼀个优点是不复制，它始终是底层字典的反映

Fal

d['spam']=0

('spam',0)init

True

keys：返回⼀个字典视图，其中包括指定字典中的键

()#返回dict中的keys

dict_keys(['title','url','spam'])

pop：⽤于获取与指定键相关联的值，并将该键-值从字典中删除

d={'x':1,'y':2}

('x')

1

d

{'y':2}

(1)#参数为dict中的key

---------------------------------------------------------------------------

KeyErrorTraceback(mostrecentcalllast)

in()

---->(1)

KeyError:1

popitem:类似于，但弹出列表中的最后⼀个元素，⽽popitem随机弹出⼀个字典项，因

为字典项的顺序是不确定的，它没有最后⼀个元素的概念。

d={'title':'pythonwebsite','url':'','spam':0}

m()#随机第删除⼀个item

('spam',0)

d

{'title':'pythonwebsite','url':''}

tdefault：类似get，因为它也获取与指定键相关联的值，但除此之外，tdefault还在字典不包含指

定的键时，在字典中添加指定的key-value对

d={}

ault('name','N/A')#如果指定的key不存在，则返回指定的value并相应地更新dict

'N/A'

d

{'name':'N/A'}

d['name']='Gumby'

ault('name','N/A')#如果指定的key存在，则返回其value，并保持dict不变

'Gumby'

d

{'name':'Gumby'}

d={}

print(ault('name'))#和get⼀样，value是可选的，如果没有指定，默认为None

None

d

{'name':None}

update：使⽤⼀个字典中的item更新另外⼀个dict

d={'title':'pythonwebsite',

'url':'',

'changed':'Mar1422:09:15MET2016'}

x={'title':'pythonlanguagewebsite'}

(x)#更新d中的title项

d

{'changed':'Mar1422:09:15MET2016',

'title':'pythonlanguagewebsite',

'url':''}

values：返回⼀个由dict中的value组成的字典视图

d={}

d[1]=1

d[2]=2

d[3]=3

d[4]=1

()

dict_values([1,2,3,1])

d

{1:1,2:2,3:3,4:1}

array是numpy模块提供的⼀种⼀维或者多维数组，当利⽤机器学习进⾏模型训练时，我们通常会把数据集转换成array传递给算法进⾏训

练

（1）数组的形式

([1,2,3])

array([1,2,3])

([[3,4,3],[3,4,5]])#返回⼀个2*3的多维数组/矩阵

array([[3,4,3],

[3,4,5]])

sample_array=([1,2,3])

sample_array

array([1,2,3])

（2）数组的基本统计量

sample_()#返回array中的最⼩值1

1

sample_()#返回array中的最⼤值

3

sample_()#返回数组中的均值

2.0

sample_()#求和

6

sample_()#标准差

0.8726

sample_#返回数组的形状为

(3,)

sample_((3,1))#改变数组的形状

sample_array

array([[1],

[2],

[3]])

sample_array.T#得到数组的转置

array([[1,2,3]])

([1,2])*2#对数组进⾏加减乘除

array([2,4])

([1,2])*([1,2])#数组的乘法

array([1,4])

ries是pandas模块提供的⼀种以为的数组，它类似numpy中国的Array,但是有⼀些特殊的功能，pandas的数据结构都会包含索引，索

引可以是数字，也可以是字符

sample_ries=([1,1,3],index=['a','b','c'])

sample__counts()#统计每个ries中每个值出现的次数

12

31

dtype:int64

（1）处理数据

sample_()

array([1,3],dtype=int64)

sample_()

sample_()

sample_()

sample_be()

sample_()

sample__duplicates()

a1

b1

c3

dtype:int64

（2）ries还提供了很多函数计算统计量

sample_()

sample_is()

sample_()

sample_()

sample_()

sample_()

sample_()

ame

DataFrame是⼀种极为强⼤的数据结构。除了具备Series的功能和结构以外，还提供了更多的数据处理、分析相关的函数和功能。

sample_df=ame({'name':['daniel','cookie','cookie'],

"score":[90,80,100]})

sample_[sample_df['name']=='cookie','score']

sample_y('name').mean()

score

name

cookie90

daniel90

⼆、readdata

1、TextFile

_csv(filename,p=',',header='infer',index_col=None,u_cols=None)

2、Excel

_excel(filename,sheetname=0,header=0,skiprows=Fal,

index_col=None,u_cols=None)

3、Databa

_sql(query,connection)##通常我们需要提供⼀个连接字符串给这个函数去连接相应的数据库。mysql+pymysql://data_viewer:test@localhost/test?

chart=utf8

---------------------------------------------------------------------------

NameErrorTraceback(mostrecentcalllast)

in()

---->_sql(query,connection)##通常我们需要提供⼀个连接字符串给这个函数去连接相应的数据库。

mysql+pymysql://data_viewer:test@localhost/test?chart=utf8

NameError:name'query'isnotdefined

三、KnowYourData

当通过pandas将数据读取到DataFrame后，⾸先可以查看数据的⼀些性质。假设df是⼀个DataFrame，通过下⾯的命令可以查看数据的

基本状况。

df=ame({'name':['daniel','cookie','cookie'],

"score":[90,80,100]})

1.查看数据的基本情况

（1）查看具体分布

()#查看前N条记录，默认是5条

namescore

0daniel90

1cookie80

2cookie100

(2)#随机查看2条记录

namescore

0daniel90

1cookie80

()#查看数据的数据类型和空值情况。

RangeIndex:3entries,0to2

Datacolumns(total2columns):

name3non-nullobject

score3non-nullint64

dtypes:int64(1),object(1)

memoryusage:128.0+bytes

be()#查看数据的基本统计值。

score

count3.0

mean90.0

std10.0

min80.0

25%85.0

50%90.0

75%95.0

max100.0

()#查看数据之间的相关系数。

score

score1.0

（2）查看数据缺失情况

t()#product将数组中的元素连乘，shape求数据框的形状，求数据框中值的个数

12

().sum().sum()#先对每⼀列求和，再对每⼀⾏求和

0

().sum().sum()/t()#查看数据总体的缺失程度

0.0

e(old,new[,max])replace()⽅法把字符串中的old（旧字符串）替换成new(新字符串)，如果指定第三个参数max，则替换不

超过max次。

().replace(Fal,True).sum()#将df中的Fal值替换成True

age4

count4

name4

dtype:int64

().sum()/().replace(Fal,True).sum()#查看每个变量的缺失程度

name0.0

score0.0

dtype:float64

（3）分组

y('state').mean()#以state进⾏分组，返回每组的均值

y(['state','city']).mean()#以state和city进⾏分组，返回每组的均值

sData

通常我们的数据中会有⼀些缺失值，异常值需要处理，以及⼀些数据需要清理，整理格式，编码等。Pandas提供了很多有⽤的函数。

（1）丢弃缺失值

#删除所有包含缺失值的⾏

()

#删除所有包含缺失值的列

(axis=1)

（2）处理重复值

_duplicates(subt=None,keep='first',inplace=Fal)参数这个drop_duplicate⽅法是对DataFrame格式的数据，

去除特定列下⾯的重复⾏。返回DataFrame格式的数据。subt:columnlabelorquenceoflabels,optional⽤来指定特定的列，

默认所有列keep:{‘first’,‘last’,Fal},default‘first’，默认保留第⼀次出现的项删除重复项并保留第⼀次出现的项inplace:

boolean,defaultFal，默认在原有数据上修改是直接在原来数据上修改还是保留⼀个副本

#删除重复的⾏

_duplicates()

（3）处理缺失值

#以0填充所有缺失值

(0)

#以空值所在列的下⼀个值进⾏填充，如果下⼀个值也是空值，则不填充

(method='bfill',axis=0)#pad(ffill)orbackfill(bfill)，⽤前⾯⼀个数值填充还是后⾯⼀个数值填充

agecountname

02080daniel

1390cookie

227100derrick

326200renee

（4）利⽤apply函数清理数据

#假设数据中的name都是以firstname-lastname的形式存储，想要分理出firstname可以利⽤匿名函数

(lambdarow:str(row['name']).split('-')[0],axis=1)#对每⼀⾏使⽤函数

0daniel

1cookie

2derrick

3renee

dtype:object

#对于复杂的处理过程可以编写函数

defprocess_zipcode(zipcode):

ifzipcode:

new_zip=str(zipcode).strip().split('-')

iflen(new_zip)==3:

returnnew_zip[-1]

eliflen(new_zip)==2:

returnnew_zip[-1]

el:

returnnew_zip[0]

el:

return

(lambdarow:process_zipcode(row['zipcode']),axis=1)

（5）⽣成虚拟变量

#将df中的⾮数字的变量转换为以dummy_为前缀的虚拟变量

_dummies(df,prefix='dummy',prefix_p='_')

sualization

Pandas的DataFrame提供了matplotlib数据可视化包的接⼝，可以⼗分⽅便的直接通过DataFrame对象进⾏数据可视化。

df=ame({

'name':['daniel','cookie','derrick','renee'],

'age':[20,3,27,26],

'count':[80,90,100,200],

})

()#默认做出DataFrame中数值型变量的折线图

<._bplotat0x28d3c850fd0>

(kind='bar',x='age',y='count')#BarPlot

<._bplotat0x28d3a0b9748>

(kind='hist',x='age')#Histogram

<._bplotat0x28d3a0fe8d0>

(kind='box',x='age')#BoxPlot

<._bplotat0x28d3a1bc898>

(kind='scatter',x='age',y='count')#ScatterPlot

<._bplotat0x28d3a265278>

ata

当我们处理完数据后，就需要将数据写⼊⽂件或者数据库进⾏存储。Pandas提供了⼀下很⽅便的函数完成这些⼯作。

#将数据框存储为，并且不保存索引，并⽤utf8进⾏编码

_csv('',index=Fal,encoding='uft8')

#将数据写⼊的test表格，不保存索引，并⽤utf8进⾏编码

_excel('',index=Fal,encoding='utf8',sheet_name='test')

#将数据写⼊数据库中的test表，如果test表存在，就在现有的表中插⼊这些数据，不保存索引

_sql('test',conn,if_exists='append',index=Fal)