python常见的数据结构
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 + tup2 print(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() #使用字典替换 #exampel var = '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. s 7. 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])
输出
H
2
345
索引从0（从左向右）开始，所有序列可通过这种方式进行索引。神奇的是，索引可以从最后一个位置（从右向左）开始，编号是-1：
str1='Hello' nums=[1,2,3,4] t1=(123,234,345) print (str1[-1]) print (nums[-2]) print (t1[-3])
输出：
o
3
123
（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]) #步长为2 print (nums[0:10:3]) #步长为3 ##print (nums[0:10:0]) #步长为0 print (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+num1
TypeError: cannot concatenate 'str' and 'list' objects
（4）乘法
print [None]*10 str1='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, in <module> print str1*num1 TypeError: 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)
输出：
False
True
True
（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))
输出：
5
o
H
5
123
1
二、映射（字典）
映射中的每个元素都有一个名字，如你所知，这个名字专业的名称叫键。字典（也叫散列表）是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 namedtuple Point=namedtuple('point', ['x','y']) p=Point(1,2) print(p.x) #1 print(p.y) #2 print(p) #point(x=1,y=2)
(2) deque([iterable[, maxlen]])
队列：先进先出
import queue Q=queue.Queue() Q.put(10) Q.put(5) Q.put(6) print(Q) #<queue.Queue object at 0x0000000001DCA198> print(Q.get()) print(Q.get()) print(Q.get()) print(Q.get()) #阻塞 print(Q.qsize()) #查看大小
双端队列，可以快速的从另外一侧追加和推出对象
from collections import deque q=deque([1,2]) q.append('a')#从后面放数据 q.appendleft('b')#从前面放数据 q.insert(1,3) print(q.pop())#从后面取数据 #a print(q.popleft())#从前面取数据 #b print(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 defaultdict dd = 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/78909224
2. 作者：Jeff Wong
出处：http://jeffwongishandsome.cnblogs.com/
