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))

输出：

二、映射（字典）

映射中的每个元素都有一个名字，如你所知，这个名字专业的名称叫键。字典（也叫散列表）是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/