现如今，Python已经广泛的应用于数据分析、数据挖掘、机器学习等众多科学计算领域。所以既然涉及到科学计算，深入了解Python原生提供的数据结构是很有必要的，这样才能在数据的海洋中游刃有余、得心应手。

一、序列结构

 

首先介绍的数据结构是序列结构，所谓序列，也就是元素顺序是很重要的，不同元素顺序的序列是不同的序列。Python中含有六种内建的序列结构，分别是list、tuple、string、unicode、buffer、xrange。

1.1、list(列表)

list，列表是一种序列，可以看做是一种数组，但不同的于其它语言的是，Python列表中的元素可以是任何数据类型，诸如，数字、字符串等等。

 

下面为创建list结构的几种方式： 

//1.通过中括号括起已知的元素创建list mylist = ['orange', 'apple', 1,2,3.14]; //2.通过中括号创建空list，然后用append()追加动态元素 mylist = []; mylist.append('orange'); //3.通过list()方法创建空list mylist = list();

 

选取list元素的方法：

//通过中括号加下对应下标选取，下标从0开始，-1为倒数第一个元素，以此类推 mylist[0]; mylist[-1];

切片是Python中序列结构独有的一种操作，意思是从序列中选取一个子序列，凡是序列均可切片，list是序列，所以list可以切片。切片方法： 

//通过[begin:end]方式完成切片 mylist = [1,2,3,4,5]; mylist[0:2]; //生成的序列为[1,2,3]

 

list常用方法：

list.append(x)，在列表的末尾添加一个元素。

list.insert(i, x)，在给定的位置插入一个元素，第一个参数是要插入的元素的索引。

list.remove(x)，移除列表中第一个值为 x 的元素，如果没有这样的元素，则抛出异常。

list.clear()，删除列表中所有的元素。

list.index(x)，返回列表中第一个值为 x 的元素的从零开始的索引，如果没有这样的元素，则抛出异常。

list.count(x)，返回元素 x 在列表中出现的次数。

list.reverse()，反转列表中的元素。

 

机器学习 

1.2、tuple(元组)

tuple，元组和列表一样，都以看做是一种数组，元素可以是任何数据类型，甚至可以嵌套。唯一的区别是，元组内的元素一旦创建，是不可修改的，也不可追加。并且元组使用小括号创建，同样元组可切片，切片方法同list。

 

//1.通过小括号括起已知的元素创建tuple mytuple = (1, 3, 'hello!') //2.不可以用append()往tuple追加，因为tuple一旦创建，不可变更

 

获取tuple中的元素：

//和列表一样，通过中括号加下对应下标选取，下标从0开始，-1为倒数第一个元素，以此类推 mytuple[0]; mytuple[-1];

 

1.3、string，unicode，buffer，xrange

这四个也是序列，做科学计算由于不太常用，不做太多介绍。

string可以看成是少量单个字符构成的list，如：

mystring = 'orange'; mylist = ['o','r','a','n','g','e'];

由于string也是序列，所以也可以切片，切片就当做单个字符构成的list切片即可，很多原理类似，不做过多介绍。

 

unicode和string类似，不过可以支持原生unicode编码的序列，如\\u4f60\\u597d。

buffer可以看成大量字符构成的list。

xrange可以看成纯数字构成的list。

科学计算

 

二、散列结构

 

所谓散列结构，区别于上述序列结构，散列结构中，元素顺序是不重要的，顺序不同的散列，还是同一个散列。散列结构有set、dict。

 

2.1、set(集合)

 

set，集合，集合是由不重复元素组成的无序的集，重点是不重复，和数学中的集合类似。无序是散列结构的特点，集合是一种散列结构，所以集合也有无序的特点。

 

创建set的方法：

 

//和list很类似，可对应参考 //1.通过大括号括起已知的元素创建set myset = {'red','blue',2.71}; //2.通过set()方法创建空set，注意不能用{}创建空set，这样创建的是空dict //3.然后用add()添加动态元素，注意不是append myset = set(); myset.add('yellow');

 

Python的set集合可以支持并集，交集，差集，对称差等数学运算：

 

//创建集合a a = set('abracadabra'); //创建集合b b = set('alacazam'); ------------------ print(a) //结果：{'a', 'r', 'b', 'c', 'd'} ------------------ print(a - b); //差集 //结果：{'r', 'd', 'b'} ------------------ print(a | b); //并集 //结果：{'a', 'c', 'r', 'd', 'b', 'm', 'z', 'l'} ------------------ print(a & b); //交集 //结果：{'a', 'c'} ------------------ print(a ^ b); //对称差 //结果：{'r', 'd', 'b', 'm', 'z', 'l'}

set常用方法：

set.remove(x)，移除集合中值为 x 的元素，如果没有这样的元素，则抛出异常。

set.isdisjoint(set2)，判断两个集合是否包含相同的元素，如果没有返回 True，否则返回 False。

set.issubset(set2)，判断集合set是否包含于set2

set.issuperset(set2)，判断集合set是否包含set2，issubset与issuperset是一对互逆操作。

 

2.2、dict(字典)

 

dict，字典，字典由键值对组成，具有唯一性，可变性。字典是可变对象但字典的键的唯一的，是不可变对象。理解字典的最好方式，就是将它看做是一个 键 : 值对的集合。

 

创建dict的方法：

//1.通过大括号括起键值对创建dict mydict = {'name':'tom','age':'24'}; //2.通过dict()方法创建dict mydict = dict(name = 'tom',age = 24); //3.通过大括号创建空dict，然后通过中括号添加键值对 mydict = {}; mydict['tel'] = '1300000000';

 

获取dict中的元素：

//需要已经知道键的名称，否则无法获取，除非遍历 mydict.get('tel');

dict常用方法：

dict.copy()，拷贝出一个新的字典。

dict.setdefault({'sex':'man'})，有则查，无则增。

dict.update({'sex':'male'})，有则改，无则增。

dict.pop('tel')，指定删除，参数必须要有需要删除的键。

dict.clear()，清空字典。

dict.keys()，查询字典中所有的键。

dict.values()，查询字典中所有的值。

dict.items()，查询字典中所有的键值对。

以上即为Python自带的数据结构，共分为序列结构和散列结构两大类，序列结构有list、tuple、string、unicode、buffer、xrange，散列结构有set、dict。

简介

Python3基本数据结构有列表（list），元组（tuple），字典（dictionary）和集合（set）四种，结构如下：

list=['Google','Runoob',1997,2000]

tup=('Google','Runoob',1997,2000)

dict={'Name':'Runoob','Age':7,'Class':'First'}

set={'apple','orange','apple','pear','orange','banana'}

以下内容整理自菜鸟教程。

列表

列表是最常用的Python数据类型，它可以作为一个方括号内的逗号分隔值出现。列表的数据项不需要具有相同的类型，创建一个列表，只要把逗号分隔的不同的数据项使用方括号括起来即可。如下所示：

list=['Google','Runoob',1997,2000]

列表索引从0开始。列表可以进行索引，切片，加，乘，检查成员等操作，此外，列表是支持添加，更新，删除等修改操作的。

列表增删改查

list=['Google','Runoob',1997,2000]

print("list[0]:",list1[0])                #下标索引访问

list[2]=2001                                #列表修改

print("修改后的第三个元素为:",list[2])

dellist[2]                                #列表删除

print("删除第三个元素:",list)

打印结果：

list[0]:Google更新后的第三个元素为:2001删除第三个元素:[‘Google’,‘Runoob’,2000]

除了关键字del，列表的删除操作还可以使用列表方法中的list.pop([index=-1])或list.remove(obj)列表的增加操作在列表方法中的list.append(obj)

列表截取与拼接

list=['Google','Runoob',1997,2000]

list_add=['baidu',2001]

print("list[1:3]:",list2[1:3])                #截取1到3位

print("list[-1]:",list2[-1])                #截取倒数第二位

print("list[1:]:",list2[1:])                #截取第一位到最后

print("list+list_add:",list2[1:3])            #拼接

打印结果：

list[1:3]:[‘Runoob’,1997,2000]list[-1]:1997list[1:]:[‘Runoob’,1997,2000]list+list_add：[‘Google’,‘Runoob’,1997,2000,‘baidu’,2001]

列表内置函数

len(list)#列表元素个数

max(list)#返回列表元素最大值

min(list)#返回列表元素最小值

list(seq)#将元组转换为列表

列表内置方法

list.append(obj)#在列表末尾添加新的对象

list.count(obj)#统计某个元素在列表中出现的次数

list.extend(seq)#在列表末尾一次性追加另一个序列中的多个值（用新列表扩展原来的列表）

list.index(obj)#从列表中找出某个值第一个匹配项的索引位置

list.insert(index,obj)#将对象插入列表

list.pop([index=-1])#移除列表中的一个元素（默认最后一个元素），并且返回该元素的值

list.remove(obj)#移除列表中某个值的第一个匹配项

list.reverse()#反向列表中元素

list.sort()#对原列表进行排序

list.clear()#清空列表

list.copy()#复制列表

元组

Python的元组与列表类似，不同之处在于元组的元素不能修改，所以元组是一种不可变容器。元组使用小括号，列表使用方括号。

tup1=('Google','Runoob',1997,2000)#元组

tup2="a","b","c","d";#不需要括号也可以

tup3=();#空元组

#元组中只包含一个元素时，需要在元素后面添加逗号，否则括号会被当作运算符使用：

tup4=(50)#

tup5=(50,)#

元组增删改查

元组不能修改和增加，元组的访问与列表相同，元组同样可以使用del关键字，但是作用是删除整个元组。

tup=('Google','Runoob',1997,2000)

deltup;

print("删除后的元组tup:")

print(tup)

打印结果：删除后的元组tup:Traceback(mostrecentcalllast):File“test.py”,line8,inprint(tup)NameError:name‘tup’isnotdefined

元组截取与拼接

与列表相同

元组内置函数

len(list)#元组元素个数

max(list)#返回元组元素最大值

min(list)#返回元组元素最小值

list(seq)#将列表转换为元组

字典

字典是另一种可变容器模型，且可存储任意类型对象。字典的每个键值(key=>value)对用冒号(:)分割，每个对之间用逗号(,)分割，整个字典包括在花括号({})中。字典中键必须是唯一的，但值则不必。值可以取任何数据类型，但键必须是不可变的，如字符串，数字或元组。一个简单的字典实例：

dict={'Name':'Runoob','Age':7,'Class':'First'}

字典增删改查

dict={'Name':'Runoob','Age':7,'Class':'First'}

print("dict['Name']:",dict['Name'])#需要按照键值访问

print("dict['Alice']:",dict['Alice'])#如果用字典里没有的键访问数据，会出现KeyError:'Alice'

dict['Age']=8#修改键Age的值

deldict['Name']#删除键'Name'

dict.clear()#清空字典

deldict#删除字典

字典内置函数

len(dict)#计算字典元素个数，即键的总数

str(dict)#输出字典，以可打印的字符串表示

type(variable)#返回输入的变量类型，如果变量是字典就返回字典类型

字典内置方法

radiansdict.clear()#删除字典内所有元素

radiansdict.copy()#返回一个字典的浅复制

radiansdict.fromkeys()#创建一个新字典，以序列seq中元素做字典的键，val为字典所有键对应的初始值

radiansdict.get(key,default=None)#返回指定键的值，如果值不在字典中返回default值

keyindict#如果键在字典dict里返回true，否则返回false

radiansdict.items()#以列表返回可遍历的(键,值)元组数组

radiansdict.keys()#返回一个迭代器，可以使用list()来转换为列表

radiansdict.setdefault(key,default=None)#和get()类似,但如果键不存在于字典中，将会添加键并将值设为default

radiansdict.update(dict2)#把字典dict2的键/值对更新到dict里

radiansdict.values()#返回一个迭代器，可以使用list()来转换为列表

pop(key[,default])#删除字典给定键key所对应的值，返回值为被删除的值。key值必须给出。否则，返回default值。

popitem()#随机返回并删除字典中的最后一对键和值。

集合

集合（set）是一个无序的不重复元素序列，集合是可变类型。可以使用大括号{}或者set()函数创建集合，注意：创建一个空集合必须用set()而不是{}，因为{}是用来创建一个空字典。

>>>basket={'apple','orange','apple','pear','orange','banana'}

>>>print(basket)#集合的不重复性

{'orange','banana','pear','apple'}

集合增删改查

basket={'apple','orange','apple','pear','orange','banana'}

print(basket[1])        #错误，集合是无序的

'orange'inbasket#快速判断元素是否在集合内

由于集合的无序性，没有修改操作，集合的添加、删除操作使用集合内置方法完成。

集合间运算

>>>a=set('abracadabra')

>>>b=set('alacazam')

>>>a

{'a','r','b','c','d'}

>>>a-b#集合a中包含而集合b中不包含的元素

{'r','d','b'}

>>>a|b#集合a或b中包含的所有元素

{'a','c','r','d','b','m','z','l'}

>>>a&b#集合a和b中都包含了的元素

{'a','c'}

>>>a^b#不同时包含于a和b的元素

{'r','d','b','m','z','l'}

集合内置方法

set.add()    #为集合添加元素

set.clear()    #移除集合中的所有元素

set.copy()    #拷贝一个集合

set.difference()    #返回多个集合的差集

set.difference_update()    #移除集合中的元素，该元素在指定的集合也存在。

set.discard()    #删除集合中指定的元素

set.intersection()    #返回集合的交集

set.intersection_update()    #返回集合的交集。

set.isdisjoint()    #判断两个集合是否包含相同的元素，如果没有返回True，否则返回False。

set.issubset()    #判断指定集合是否为该方法参数集合的子集。

set.issuperset()    #判断该方法的参数集合是否为指定集合的子集

set.pop()    #随机移除元素

set.remove()    #移除指定元素

set.symmetric_difference()    #返回两个集合中不重复的元素集合。

set.symmetric_difference_update()#移除当前集合中在另外一个指定集合相同的元素，并将另外一个指定集合中不同的元素插入到当前集合中。

set.union()    #返回两个集合的并集

set.update()    #给集合添加元素