序列类型的划分：
第一种划分：
- 容器序列：可以存放不同类型的数据，存放的是引用
- list、tuple、collections.deque
- 扁平序列：只能存放一种类型的数据，存放的是值
- str、bytes、bytearray、memoryview、array.array
第二种划分：
- 可变序列：内容可以改变
- list、bytearray、array.array、collections.deque、memoryview
- 不可变序列
- tuple、str、bytes
列表推导同filter和map的比较
- filter和map合起来能做的事情，列表推导也能做，而且还不需要借助难以理解和阅读的lambda表达式
from collections import abc s = 'abcdefg' # 列表推导 l1 = [ord(x) for x in s if ord(x)>99] print(l1) # map返回的是一个map object，它是一个Iterator map_object = map(ord, s) print(isinstance(map_object,abc.Iterator)) # map和filter结合 l2 = list(filter(lambda x: x > 99, map_object)) print(l2)输出：
[100, 101, 102, 103]
True
[100, 101, 102, 103]
生成器表达式
生成器表达式背后遵循了迭代器协议，可以逐个地产出元素，而不是先建立一个完整的列表，然后再把这个列表传递到某个构造函数里。
生成器表达式语法和列表推导差不多，只不过把方括号换成圆括号而已
import array
symbols = 'aeiou'
# 用生成器构造tuple
t = tuple(ord(x) for x in symbols)
print(t)
print('-' * 100)
# 用生成器构造array
a = array.array('I',(ord(x) for x in symbols))
print(a)
print('-' * 100)
# 生成器产生笛卡尔积
colors = ['black','white']
size = ['S','M','L']
for tshirt in ('{0} {1}'.format(c,s) for c in colors for s in size):
print(tshirt)输出：
(97, 101, 105, 111, 117)
----------------------------------------------------------------------------------------------------
array('I', [97, 101, 105, 111, 117])
----------------------------------------------------------------------------------------------------
black S
black M
black L
white S
white M
white L
元组拆包
在一行语句内把元组分别赋值给多个变量
import os
# 元组拆包常规操作
person = ('Alice',20)
name,age = person
print('name is',name,'age is',age)
print('-' * 100)
# 使用“_”占位符
_,filename = os.path.split("D\Program Files\Test.doc")
print('filename =',filename)
print('-' * 100)
# 使用*占位符
address = ('China', 'ZheJiang', 'HangZhou',310000)
_,province,*other,zipcode = address
print('province =',province,', zipcode = ',zipcode)
print('-' * 100)
# 嵌套拆包
numbers = (('one',1),('two',2),('three',3))
for (name, value) in numbers:
print(name,'=',value)输出：
name is Alice age is 20
----------------------------------------------------------------------------------------------------
filename = Test.doc
----------------------------------------------------------------------------------------------------
province = ZheJiang , zipcode = 310000
----------------------------------------------------------------------------------------------------
one = 1
two = 2
three = 3
具名元组
collections.namedtuple是一个工厂函数，它可以用来构建一个带字段名的元组，这个带字段名的元组的行为模式就像一个类
from collections import namedtuple,OrderedDict
# 使用namedtuple定义一个Country类
Country = namedtuple('Country','name_and_abbr area population')
china = Country(('China','CN'),960,13)
print(china)
print('-' * 20,'用.号访问Country类的属性','-' * 20)
# 用.号访问Country类的属性
print('china.population=',china.population)
name,abbr = china.name_and_abbr
print('name='+name,'abbr='+abbr)
print('-' * 20,'用[]访问Country类的属性','-' * 20)
# 也可以用[]访问Country类的属性
print('china[0]=',china[0])
print('-' * 20,'Country类的_fileds方法','-' * 20)
# Country类的_fileds方法返回它的字段
print('Country._filds =',Country._fields)
print('-' * 20,'Country类的_make方法','-' * 20)
# Country类的_make方法构造一个实例
japan1 = Country._make((('Japan','JP'),97.8,1.26))
print(japan1)
# 和调用构造函数效果相同：
japan2 =Country(*(('Japan','JP'),97.8,1.26))
print(japan2)
print('-' * 20,'Country类的_asdict方法','-' * 20)
# Country类的_asdict方法把具名元组以collections.OrderedDict的形式返回
print('china._asdict() is OrderedDict:',isinstance(china._asdict(),OrderedDict))
for name,value in china._asdict().items():
print(name,'=',value)输出：
Country(name_and_abbr=('China', 'CN'), area=960, population=13)
-------------------- 用.号访问Country类的属性 --------------------
china.population= 13
name=China abbr=CN
-------------------- 用[]访问Country类的属性 --------------------
china[0]= ('China', 'CN')
-------------------- Country类的_fileds方法 --------------------
Country._filds = ('name_and_abbr', 'area', 'population')
-------------------- Country类的_make方法 --------------------
Country(name_and_abbr=('Japan', 'JP'), area=97.8, population=1.26)
Country(name_and_abbr=('Japan', 'JP'), area=97.8, population=1.26)
-------------------- Country类的_asdict方法 --------------------
china._asdict() is OrderedDict: True
name_and_abbr = ('China', 'CN')
area = 960
population = 13
切片
在切片和区间操作里不包含区间范围的最后一个元素
l = [10,20,30,40,50,60]
print('l[:2] =',l[:2])
print('l[2:] =',l[2:])输出：
l[:2] = [10, 20]
l[2:] = [30, 40, 50, 60]
使用slice对切片进行命名
people = '''person1 20 175
person2 30 163
person3 25 182 '''
name = slice(0,7)
age = slice(8,10)
height = slice(11,14)
for item in people.split("\n"):
print('name:',item[name])
print('age:',item[age])
print('height:',item[height])
print('-' * 100)输出：
name: person1
age: 20
height: 175
----------------------------------------------------------------------------------------------------
name: person2
age: 30
height: 163
----------------------------------------------------------------------------------------------------
name: person3
age: 25
height: 182
----------------------------------------------------------------------------------------------------
给切片赋值
如果把切片放在赋值语句的左边，或把它作为del操作的对象，我们就可以对序列进行嫁接、切除或就地修改操作
l = list(range(1,11))
print('l:',l)
# 把l的第9和10项替换成100
print('-' * 20,'把l的第9和10项替换成100','-' * 20)
l[8:10] = [100]
print(l)
print('-' * 20,'把l的第1,3,5,7,9项替换成95,96,97,98,99','-' * 20)
# 把l的第1,3,5,7,9项替换成95,96,97,98,99
l[::2] = [95,96,97,98,99]
print(l)
# 删除l的第2,4,6,8项
print('-' * 20,'删除l的第2,4,6,8项','-' * 20)
del l[1::2]
print(l)输出：
l: [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
-------------------- 把l的第9和10项替换成100 --------------------
[1, 2, 3, 4, 5, 6, 7, 8, 100]
-------------------- 把l的第1,3,5,7,9项替换成95,96,97,98,99 --------------------
[95, 2, 96, 4, 97, 6, 98, 8, 99]
-------------------- 删除l的第2,4,6,8项 --------------------
[95, 96, 97, 98, 99]
对序列使用+和*
+和*都是对序列进行拼接，在拼接的过程中，两个被操作的序列都不会被修改，Python会建立一个包含同样类型数据的序列来作为拼接的结果
*操作把一个序列复制几份然后拼接起来，但这里使用浅copy，对于嵌套结构需要当心
def print_split(s):
print('-' * 20, s, '-' * 20)
# 拼接使用浅copy
# 使用基本类型没有影响
print_split('使用基本类型没有影响')
l1 = [1]
print('id of l1[0]:', id(l1[0]))
# 对l1中的元素进行复制，然后拼接
# l是由两个整数构成的list
l = l1 * 2
print(l)
for item in l:
print(id(item))
# 不会影响l[1]
l[0]=2
print(l)
# 使用对象有副作用
print_split('使用对象有副作用')
l2=[['_']]
print('id of l2[0]:',id(l2[0]))
# 对l2中的元素进行复制，然后拼接
# l是由两个list构成的list
l = l2*2
for item in l:
print(id(item))
# 会影响l[1][0]
l[0][0]='a'
print(l)输出：
-------------------- 使用基本类型没有影响 --------------------
id of l1[0]: 140734998434848
[1, 1]
140734998434848
140734998434848
[2, 1]
-------------------- 使用对象有副作用 --------------------
id of l2[0]: 1171703476616
1171703476616
1171703476616
[['a'], ['a']]
建立嵌套列表的一个例子
def print_split(s):
print('-' * 20, s, '-' * 20)
# 建立由列表组成的列表
print_split('建立由列表组成的列表')
# 错误的建立方式：会把相同列表复制三次
print_split('错误的建立方式：会把相同列表复制三次')
board = [['_'] * 3] * 3
print(board)
board[0][0]='a'
print(board)
# 正确的建立嵌套列表方式：
print_split('正确的建立嵌套列表方式')
board = [['_']*3 for i in range(3)]
print(board)
board[0][0]='a'
print(board)输出：
-------------------- 建立由列表组成的列表 --------------------
-------------------- 错误的建立方式：会把相同列表复制三次 --------------------
[['_', '_', '_'], ['_', '_', '_'], ['_', '_', '_']]
[['a', '_', '_'], ['a', '_', '_'], ['a', '_', '_']]
-------------------- 正确的建立嵌套列表方式 --------------------
[['_', '_', '_'], ['_', '_', '_'], ['_', '_', '_']]
[['a', '_', '_'], ['_', '_', '_'], ['_', '_', '_']]
list.sort方法和内置函数sorted
不同点：
list.sort方法就地排序列表，返回None
sorted方法返回一个新建的排好序的列表
相同点：
接受参数相同
reverse：如果被设定为True，序列以降序输出
key：一个只有一个参数的函数，被用在序列里的每一个元素上，所产生的结果将是排序算法依赖的对比关键字
fruits = ['grape','raspberry','apple','banana']
print('sorted(fruits):',sorted(fruits))
# 原列表并未被改变
print('fruits:',fruits)
print('sorted(fruits,reverse=True):',sorted(fruits,reverse=True))
print('sorted(fruits,key=len):',sorted(fruits,key=len))
print('list.sort(fruits):',list.sort(fruits))
# 原列表被改变了
print('fruits:',fruits)输出：
sorted(fruits): ['apple', 'banana', 'grape', 'raspberry']
fruits: ['grape', 'raspberry', 'apple', 'banana']
sorted(fruits,reverse=True): ['raspberry', 'grape', 'banana', 'apple']
sorted(fruits,key=len): ['grape', 'apple', 'banana', 'raspberry']
list.sort(fruits): None
fruits: ['apple', 'banana', 'grape', 'raspberry']
bisect管理已排序的序列
bisect模块包含两个主要函数：bisect和insort，它们都利用二分查找算法来在有序序列中查找或插入元素
bisect函数其实是bisect_right函数的别名，后者还有一个姊妹函数叫bisect_left，它们的区别在于，bisect_left返回的插入位置是序列中所有与插入元素相同的元素的前面，而bisect_right则是后面
与bisect相似，insort有一个变体叫insort_left，差异与bisect和bisect_left相似
from random import randint
from bisect import bisect,insort
l = [randint(0,20) for i in range(10)]
list.sort(l)
print('l:',l)
x = randint(0,20)
print('x:',x)
# 查找插入位置
print('position to insert x:',bisect(l,x))
# 进行插入
insort(l,x)
print('l:',l)输出：（输出随机改变）
l: [7, 8, 9, 12, 13, 13, 14, 17, 18, 18]
x: 2
position to insert x: 0
l: [2, 7, 8, 9, 12, 13, 13, 14, 17, 18, 18]
from bisect import bisect,insort
def grade(score,breakpoints=[60,70,80,90],grades='FDCBA'):
pos = bisect(breakpoints,score)
return grades[pos]
print([grade(score) for score in [33,99,77,70,89,90,100]])输出：['F', 'A', 'C', 'C', 'B', 'A', 'A']
数组
如果我们需要一个只包含数字的列表，那么array.array比list更高效
数组支持所有跟可变序列有关的方法，比如.pop .insert ,extend
另外，数组还提供从文件读取和存入文件的更快的方法：.fromfile 和 .tofile
数组第一个参数是数组存放的元素类型
from array import array
from random import random
# 建立一个double构成的数组，一共10^6个元素
arr = array('d',(random() for i in range(10**6)))
# 把数组放进文件
with open('floats.bin','wb') as fp:
arr.tofile(fp)
# 打印数组最后一个元素
print(arr[-1])
# 新建一个double数组
floats = array('d')
fp = open('floats.bin','rb')
# 从文件读取数据，构造数组
floats.fromfile(fp,10**6)
# 打印数组最后一个元素
print(floats[-1])输出(随机输出)：
0.608500026173036
0.608500026173036
内存视图
memoryview让用户在不复制内容的情况下操作同一个数组的不同切片
能用不同的方式读写同一块内存数据，而且内容字节不会随意移动
from array import array
# 定义一个以两个字节带符号整数构成的数组
num = array('h',[-2,-1,0,1,2])
# 用array构造memoryview
mv2 = memoryview(num)
# memoryview的长度是根据其解析类型来的
print('len(mv):',len(mv2))
# 对元素的解析也是根据其解析类型来的
print('mv[0]:',mv2[0])
# 换一种解析类型，用一个字节来解析
mv1 = mv2.cast('B')
# 打印用一个字节来解析的内容
print(mv1.tolist())
# 把第6个字节替换成00000100，注意，每个字的高低位字节是倒过来显示的
mv1[5] = 4
# 会影响到原先的memoryview
print(mv2.tolist())输出：
len(mv): 5
mv[0]: -2
[254, 255, 255, 255, 0, 0, 1, 0, 2, 0]
[-2, -1, 1024, 1, 2]
双端队列
删除列表的第一个元素之类的操作是很耗时的
collections.deque类是一个线程安全，可以快速从两端添加或者删除元素的数据类型
from collections import deque
# 定义一个长度为10的双端队列
# 用0-9填充
dq = deque(range(10),maxlen=10)
print('dq:',dq)
# rotate参数是正数，右放到左；
dq.rotate(3)
print('dq.rotate(3):',dq)
# rotate参数是负数，左放到右
dq.rotate(-3)
print('dq.rotate(-3):',dq)
# deque可以在两端添加元素，但另一端的元素会被挤出
dq.append(10)
print('deque.append(10):',dq)
dq.appendleft(0)
print('dq.appendleft(0):',dq)
# deque也可以在两端添加可迭代对象
dq.extend([11,12])
print('dq.extend([11,12]):',dq)
# 注意，deque是一个一个添加元素的，所以在左端添加可迭代对象时，顺序是倒过来的
dq.extendleft([1,0])
print('dq.extendleft([1,0]):',dq)
# deque可以在两端删除元素，但不能带参数
a = dq.pop()
print('dq.pop():',a)
print('dq after pop:',dq)
a = dq.popleft()
print('dq.popleft():',a)
print('dq after pop:',dq)输出：
dq: deque([0, 1, 2, 3, 4, 5, 6, 7, 8, 9], maxlen=10)
dq.rotate(3): deque([7, 8, 9, 0, 1, 2, 3, 4, 5, 6], maxlen=10)
dq.rotate(-3): deque([0, 1, 2, 3, 4, 5, 6, 7, 8, 9], maxlen=10)
deque.append(10): deque([1, 2, 3, 4, 5, 6, 7, 8, 9, 10], maxlen=10)
dq.appendleft(0): deque([0, 1, 2, 3, 4, 5, 6, 7, 8, 9], maxlen=10)
dq.extend([11,12]): deque([2, 3, 4, 5, 6, 7, 8, 9, 11, 12], maxlen=10)
dq.extendleft([1,0]): deque([0, 1, 2, 3, 4, 5, 6, 7, 8, 9], maxlen=10)
dq.pop(): 9
dq after pop: deque([0, 1, 2, 3, 4, 5, 6, 7, 8], maxlen=10)
dq.popleft(): 0
dq after pop: deque([1, 2, 3, 4, 5, 6, 7, 8], maxlen=10)
来源：https://www.cnblogs.com/StackNeverOverFlow/p/9819006.html