Python中常见的数据结构可以统称为容器。序列（如列表和元组）、映射（如字典）以及集合（set）是三类主要的容器。
线性数据结构分类：栈(stack)--先进后出、 队列(queue)-先进先出、双端队列(deque)、链表(LinkedList)
一、序列（列表、元组和字符串）
序列中的每个元素都有自己的编号。Python中有6种内建的序列。其中列表和元组是最常见的类型。其他包括字符串、Unicode字符串、buffer对象和xrange对象。下面重点介绍下列表、元组和字符串。
1、列表
列表是可变的，这是它区别于字符串和元组的最重要的特点，一句话概括即：列表可以修改，而字符串和元组不能。
可变数据类型 列表、字典、集合 不可哈希 集合里存的元素必须是不可变的数据类型，无序，不重复(去重)不可变数据类型 元组、数字、字符串 可哈希
(1) 列表操作包含以下函数
cmp(list1, list2)：比较两个列表的元素
len(list)：列表元素个数 max(list)：返回列表元素最大值 min(list)：返回列表元素最小值 list(seq)：将元组转换为列表(2) 列表操作包含以下方法
list.append(obj)：在列表末尾添加新的对象
list.count(obj)：统计某个元素在列表中出现的次数 list.extend(seq)：在列表末尾一次性追加另一个序列中的多个值（用新列表扩展原来的列表） list.index(obj)：从列表中找出某个值第一个匹配项的索引位置 list.insert(index, obj)：将对象插入列表 list.pop(obj=list[-1])：移除列表中的一个元素（默认最后一个元素），并且返回该元素的值 list.remove(obj)：移除列表中某个值的第一个匹配项 list.reverse()：反向列表中元素 list.sort([func])：对原列表进行排序(3) copy()与deepcopy()的区别
对于不可变的对象来说(数字，字符串，元组)，深浅拷贝没有区别
深复制，即将被复制对象完全再复制一遍作为独立的新个体单独存在。所以改变原有被复制对象不会对已经复制出来的新对象产生影响。 等于赋值，并不会产生一个独立的对象单独存在，他只是将原有的数据块打上一个新标签，所以当其中一个标签被改变的时候，数据块就会发生变化，另一个标签也会随之改变。 浅复制要分两种情况进行讨论： 1）当浅复制的值是不可变对象（数值，字符串，元组）时和“等于赋值”的情况一样，对象的id值与浅复制原来的值相同。 2）当浅复制的值是可变对象（列表和元组）时会产生一个“不是那么独立的对象”存在。有两种情况： 第一种情况：复制的对象中无复杂子对象，原来值的改变并不会影响浅复制的值，同时浅复制的值改变也并不会影响原来的值。 原来值的id值与浅复制原来的值不同。 第二种情况：复制的对象中有 复杂 子对象 （例如列表中的一个子元素是一个列表），如果不改变其中复杂子对象， 浅复制的值改变并不会影响原来的值。 但是改变原来的值 中的复杂子对象的值 会影响浅复制的值。2、元组
Python的元组与列表类似，不同之处在于元组的元素不能修改。元组使用小括号，列表使用方括号。元组创建很简单，只需要在括号中添加元素，并使用逗号隔开即可。
(1) 元组操作包含以下函数
cmp(list1, list2)：比较两个元组的元素
len(list)：元组元素个数max(list)：返回元组元素最大值min(list)：返回元组元素最小值tuple(seq)：将列表转换为元组(2) 修改元组
元组中的元素值是不允许修改的，但我们可以对元组进行连接组合，如下实例:
#!/usr/bin/python# -*- coding: UTF-8 -*- tup1 = (12, 34.56)tup2 = ('abc', 'xyz') # 以下修改元组元素操作是非法的。# tup1[0] = 100 # 创建一个新的元组tup3 = tup1 + tup2print(tup3) (3) 删除元组
元组中的元素值是不允许删除的，但我们可以使用del语句来删除整个元组
注意：只含一个值的元组，必须加个逗号（,）；
3、字符串
字符串是 Python 中最常用的数据类型。我们可以使用引号('或")来创建字符串。创建字符串很简单，只要为变量分配一个值即可
'strs'.capitalize() #首字母大写'strs'.title() #每个单词首字母大写'strs'.upper() #每个字母变为大写'strs'.lower() #每个字母变为小写'strs'.swapcase() #大小写互换'strs'.count() #计算指定字符串或字符出现的次数'strs'.find() #根据指定的字符获取该字符在字符串中第一次出现的索引位置(找不到索引返回-1)'strs'.index() #根据指定的字符获取该字符在字符串中第一次出现的索引位置(找不到索引返回一个异常错误)'strs'.startswith() #检测字符串是否以指定字符开头'strs'.endswith() #检测字符串是否以指定字符结尾'strs'.isupper() #检测字符串是否都为大写字母'strs'.islower() #检测字符串是否都为小写字母'strs'.istitle() #检测字符串是否都为单词首字母大写'strs'.isalnum() #检测字符串是否只由字母和数字字符组成'strs'.isalpha() #检测字符串是否只由字母字符(含中文字符)组成'strs'.isdigit() #检测字符串是否只由十进制数字字符组成'strs'.isnumeric() #检测字符串是否以数字字符组成'strs'.isdecimal() #检测字符串是否以数字字符组成'strs'.isspace() #检测字符串是否由空白字符组成'strs'.split() #使用指定字符，将字符串进行切割并装入列表'strs'.splitlines() #使用回车字符，切割字符串并装入列表中'strs'.join(['a','b','c']) #将容器中的字符串使用指定字符拼接成一个字符串'strs'.zfill() #使用0填充字符串，参数为填充后的总位数'strs'.center() #用指定字符，将字符串居中填充到指定长度，参数(长度,使用的字符)'strs'.ljust() #用指定字符，将字符串左对齐填充到指定长度，参数(长度,使用的字符)'strs'.rjust() #用指定字符，将字符串右对齐填充到指定长度，参数(长度,使用的字符)'strs'.strip() #去掉字符串中，两侧指定重复的字符(如果不指定字符，则删除空格)'strs'.lstrip() #去掉字符串中，左侧指定重复的字符(如果不指定字符，则删除空格)'strs'.rjust() #去掉字符串中，右侧指定重复的字符(如果不指定字符，则删除空格)#替换字符串中的字符'strs'.maketrans() #制作字典'strs'.translate() #使用字典替换#exampelvar = 'wiz good guy,wiz super cool'flag = ''.maketrans('wiz','wwr')res = var.translate(flag) (1) Python字符串格式化--format()方法
1.简单运用
字符串类型格式化采用format()方法，基本使用格式是：
<模板字符串>.format(<逗号分隔的参数>)
调用format()方法后会返回一个新的字符串，参数从0 开始编号。
"{}：计算机{}的CPU 占用率为{}%。".format("2016-12-31","PYTHON",10)Out[10]: '2016-12-31：计算机PYTHON的CPU 占用率为10%。' format()方法可以非常方便地连接不同类型的变量或内容，如果需要输出大括号，采用{
{表示{，}}表示}，例如：1. "{}{}{}".format("圆周率是",3.1415926,"...")2. Out[11]: '圆周率是3.1415926...'3. "圆周率{ { {1}{2}}}是{0}".format("无理数",3.1415926,"...")4. Out[12]: '圆周率{3.1415926...}是无理数'5. s="圆周率{ { {1}{2}}}是{0}" #大括号本身是字符串的一部分6. s7. Out[14]: '圆周率{ { {1}{2}}}是{0}'8. s.format("无理数",3.1415926,"...") #当调用format()时解析大括号9. Out[15]: '圆周率{3.1415926...}是无理数' 2. 格式控制信息
format()方法中<模板字符串>的槽除了包括参数序号，还可以包括格式控制信息。此时，槽的内部样式如下：
{<参数序号>: <格式控制标记>}
其中，<格式控制标记>用来控制参数显示时的格式，包括：<填充><对齐><宽度>,<.精度><类型>6 个字段，这些字段都是可选的，可以组合使用，逐一介绍如下。
<宽度>
指当前槽的设定输出字符宽度，如果该槽对应的format()参数长度比<宽度>设定值大，则使用参数实际长度。如果该值的实际位数小于指定宽度，则位数将被默认以空格字符补充。
<对齐>
指参数在<宽度>内输出时的对齐方式，分别使用<、>和^三个符号表示左对齐、右对齐和居中对齐。
<填充>
指<宽度>内除了参数外的字符采用什么方式表示，默认采用空格，可以通过<填充>更换。
1. s = "PYTHON"2. "{0:30}".format(s)3. Out[17]: 'PYTHON '4. "{0:>30}".format(s)5. Out[18]: ' PYTHON'6. "{0:*^30}".format(s)7. Out[19]: '************PYTHON************'8. "{0:-^30}".format(s)9. Out[20]: '------------PYTHON------------'10."{0:3}".format(s)11.Out[21]: 'PYTHON' 逗号（，）
<格式控制标记>中逗号（，）用于显示数字的千位分隔符，例如：
1. "{0:-^20,}".format(1234567890)2. Out[24]: '---1,234,567,890----'3. "{0:-^20}".format(1234567890) #对比输出4. Out[25]: '-----1234567890-----'5. "{0:-^20,}".format(12345.67890)6. Out[26]: '----12,345.6789-----' <.精度>
表示两个含义，由小数点（.）开头。对于浮点数，精度表示小数部分输出的有效位数。对于字符串，精度表示输出的最大长度。
1. "{0:.2f}".format(12345.67890)2. Out[29]: '12345.68'3. "{0:H^20.3f}".format(12345.67890)4. Out[30]: 'HHHHH12345.679HHHHHH'5. "{0:.4}".format("PYTHON")6. Out[31]: 'PYTH' <类型>
表示输出整数和浮点数类型的格式规则。对于整数类型，输出格式包括6 种：
- b: 输出整数的二进制方式；
- c: 输出整数对应的 Unicode 字符；
- d: 输出整数的十进制方式；
- o: 输出整数的八进制方式；
- x: 输出整数的小写十六进制方式；
- X: 输出整数的大写十六进制方式；
1. "{0:b},{0:c},{0:d},{0:o},{0:x},{0:X}".format(425)2. Out[32]: '110101001,Ʃ,425,651,1a9,1A9' 对于浮点数类型，输出格式包括4 种：
- e: 输出浮点数对应的小写字母 e 的指数形式；
- E: 输出浮点数对应的大写字母 E 的指数形式；
- f: 输出浮点数的标准浮点形式；
- %: 输出浮点数的百分形式。
浮点数输出时尽量使用<.精度>表示小数部分的宽度，有助于更好控制输出格式。
1. "{0:e},{0:E},{0:f},{0:%}".format(3.14)2. Out[33]: '3.140000e+00,3.140000E+00,3.140000,314.000000%'3. "{0:.2e},{0:.2E},{0:.2f},{0:.2%}".format(3.14)4. Out[34]: '3.14e+00,3.14E+00,3.14,314.00%' 4、通用序列操作（方法）
从列表、元组以及字符串可以“抽象”出序列的一些公共通用方法（不是你想像中的CRUD），这些操作包括：索引（indexing）、分片（sliceing）、加（adding）、乘（multiplying）以及检查某个元素是否属于序列的成员。除此之外，还有计算序列长度、最大最小元素等内置函数。
（1）索引
str1='Hello'nums=[1,2,3,4]t1=(123,234,345)print (str1[0])print (nums[1])print (t1[2])
输出
H2345
索引从0（从左向右）开始，所有序列可通过这种方式进行索引。神奇的是，索引可以从最后一个位置（从右向左）开始，编号是-1：
str1='Hello'nums=[1,2,3,4]t1=(123,234,345)print (str1[-1])print (nums[-2])print (t1[-3])
输出：
o3123
（2）分片
分片操作用来访问一定范围内的元素。分片通过冒号相隔的两个索引来实现：
nums=range(10)print (nums)print (nums[1:5])print (nums[6:10])print (nums[1:])print (nums[-3:-1])print (nums[-3:]) #包括序列结尾的元素，置空最后一个索引print (nums[:]) #复制整个序列
输出：
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9][1, 2, 3, 4][6, 7, 8, 9][1, 2, 3, 4, 5, 6, 7, 8, 9][7, 8][7, 8, 9]
不同的步长，有不同的输出：
nums=range(10)print (nums)print (nums[0:10]) #默认步长为1 等价于nums[1:5：1]print (nums[0:10:2]) #步长为2print (nums[0:10:3]) #步长为3 ##print (nums[0:10:0]) #步长为0print (nums[0:10:-2]) #步长为-2
输出：
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9][0, 1, 2, 3, 4, 5, 6, 7, 8, 9][0, 2, 4, 6, 8][0, 3, 6, 9][]
（3）序列相加
str1='Hello'str2=' world'print (str1+str2)num1=[1,2,3]num2=[2,3,4]print (num1+num2)print (str1+num1)
输出：
Hello world[1, 2, 3, 2, 3, 4]
Traceback (most recent call last):
File "F:\Python\test.py", line 7, in <module> print str1+num1TypeError: cannot concatenate 'str' and 'list' objects（4）乘法
print [None]*10str1='Hello'print (str1*2)num1=[1,2]print (num1*2)print (str1*num1)
输出：
[None, None, None, None, None, None, None, None, None, None]HelloHello[1, 2, 1, 2]Traceback (most recent call last): File "F:\Python\test.py", line 5, inprint str1*num1TypeError: can't multiply sequence by non-int of type 'list'
（5）成员资格
in运算符会用来检查一个对象是否为某个序列（或者其他类型）的成员（即元素）：
str1='Hello'print ('h' in str1)print ('H' in str1)num1=[1,2]print (1 in num1) 输出：
FalseTrueTrue
（6）长度、最大最小值
通过内建函数len、max和min可以返回序列中所包含元素的数量、最大和最小元素。
str1='Hello'print (len(str1))print (max(str1))print (min(str1))num1=[1,2,1,4,123]print (len(num1))print (max(num1))print (min(num1))
输出：
5oH51231
二、映射（字典）
映射中的每个元素都有一个名字，如你所知，这个名字专业的名称叫键。字典（也叫散列表）是Python中唯一内建的映射类型。
字典的键可以是数字、字符串或者是元组，键必须唯一。在Python中，数字、字符串和元组都被设计成不可变类型，而常见的列表以及集合（set）都是可变的，所以列表和集合不能作为字典的键。键可以为任何不可变类型，这正是Python中的字典最强大的地方。
字典的方法(可能需要重新整理)
| 函数 | 说明 |
| D | 代表字典对象 |
| D.clear() | 清空字典 |
| D.pop(key) | 移除键，同时返回此键所对应的值 |
| D.copy() | 返回字典D的副本,只复制一层(浅拷贝) |
| D.update(D2) | 将字典 D2 合并到D中，如果键相同，则此键的值取D2的值作为新值 |
| D.get(key, default) | 返回键key所对应的值,如果没有此键，则返回default |
| D.keys() | 返回可迭代的 dict_keys 集合对象 |
| D.values() | 返回可迭代的 dict_values 值对象 |
| D.items() | 返回可迭代的 dict_items 对象 |
三、集合
集合（Set）在Python 2.3引入，通常使用较新版Python可直接创建，如下所示：
strs=set(['jeff','wong','cnblogs'])nums=set(range(10))
看上去，集合就是由序列（或者其他可迭代的对象）构建的。集合的几个重要特点和方法如下：
(1) 固定集合构造(创建)函数 frozenset
| 函数 | 说明 |
| frozenset() | 创建一个空的固定集合对象 |
| frozenset(iterable) | 用可迭代对象创建一个新的固定集合对象 |
(2) 集合构造(创建)函数 set
| 函数 | 说明 |
| set() | 创建一个空的集合对象(不能用{}来创建空集合) |
| set(iterable) | 用可迭代对象创建一个新的集合对象 |
(3) Python3 集合中常用的方法
| 方法 | 意义 |
| S.add(e) | 在集合中添加一个新的元素e；如果元素已经存在，则不添加 |
| S.remove(e) | 从集合中删除一个元素，如果元素不存在于集合中，则会产生一个KeyError错误 |
| S.discard(e) | 从集合S中移除一个元素e,在元素e不存在时什么都不做; |
| S.clear() | 清空集合内的所有元素 |
| S.copy() | 将集合进行一次浅拷贝 |
| S.pop() | 从集合S中删除一个随机元素;如果此集合为空，则引发KeyError异常 |
| S.update(s2) | 用 S与s2得到的全集更新变量S |
| S.difference(s2) | 用S - s2 运算，返回存在于在S中，但不在s2中的所有元素的集合 |
| S.difference_update(s2) | 等同于 S = S - s2 |
| S.intersection(s2) | 等同于 S & s2 |
| S.intersection_update(s2) | 等同于S = S & s2 |
| S.isdisjoint(s2) | 如果S与s2交集为空返回True,非空则返回False |
| S.issubset(s2) | 如果S与s2交集为非空返回True,空则返回False |
| S.issuperset(...) | 如果S为s2的子集返回True,否则返回False |
| S.symmetric_difference(s2) | 返回对称补集,等同于 S ^ s2 |
| S.symmetric_difference_update(s2) | 用 S 与 s2 的对称补集更新 S |
| S.union(s2) | 生成 S 与 s2的全集 |
四、栈、队列
堆栈：先进后出
队列：先进先出 FIFO(1) namedTuple(typename, fields)
from collections import namedtuplePoint=namedtuple('point', ['x','y'])p=Point(1,2)print(p.x) #1print(p.y) #2print(p) #point(x=1,y=2) (2) deque([iterable[, maxlen]])
队列：先进先出
import queueQ=queue.Queue()Q.put(10)Q.put(5)Q.put(6)print(Q) #print(Q.get())print(Q.get())print(Q.get())print(Q.get()) #阻塞print(Q.qsize()) #查看大小
双端队列，可以快速的从另外一侧追加和推出对象
from collections import dequeq=deque([1,2])q.append('a')#从后面放数据q.appendleft('b')#从前面放数据q.insert(1,3)print(q.pop())#从后面取数据 #aprint(q.popleft())#从前面取数据 #bprint(q) #deque([3, 1, 2]) (3) OrderedDict([items])
>>> from collections import OrderedDict>>> d = dict([('a', 1), ('b', 2), ('c', 3)])>>> d # dict的Key是无序的{ 'a': 1, 'c': 3, 'b': 2}>>> od = OrderedDict([('a', 1), ('b', 2), ('c', 3)])>>> od # OrderedDict的Key是有序的OrderedDict([('a', 1), ('b', 2), ('c', 3)]) (4) defaultdict([default_factory[, ...]])
from collections import defaultdictdd = defaultdict(lambda: 'N/A')dd['key1'] = 'abc'print(dd['key1'])# key1存在print(dd['key2'])# key2不存在，返回默认值6. Counter([iterable-or-mapping])c = Counter('abcdeabcdabcaba')print c输出：Counter({ 'a': 5, 'b': 4, 'c': 3, 'd': 2, 'e': 1})
参考链接
1. 作者：wiz_333
出处：https://blog.csdn.net/wizblack/article/details/789092242. 作者：
出处：