Python 序列

本文章总结了董付国老师的Pthon程序设计(第2版)书的内容，仅供个人学习使用，如有侵权，立刻删除     by：mfdy


文章链接：mfdy’s blog: Python 序列


CSDN目录：https://blog.csdn.net/mofadiyu/article/details/

2.1 列表

2.1.1 列表的创建与删除

a_list = ['a', 'b', 'mpilgrim', 'z', 'example'] a_list = [] # 创建空列表 

或者是用list()函数将元组、range对象、字符串或者其他类型的可迭代对象类型的数据转换为列表，例如：

讯享网a_list = list((3, 5, 7, 9, 11)) # [3, 5, 7, 9, 11] list(range(1, 10, 2)) # [1, 3, 5, 7, 9] print(list('hello world')) # ['h', 'e', 'l', 'l', 'o', ' ', 'w', 'o', 'r', 'l', 'd'] x =list() # 创建空列表 

当不再使用时，使用del命令删除整个列表，如果列表对象所指向的值不再有其他对象指向，同时删除该值

del a_list >>> a_list Traceback (most recent call last): File "<pyshell#6>", line 1, in <module> a_list NameError: name 'a_list' is not defined 

2.1.2 列表元素的增加

1. 可以使用 + 运算符添加，但是其实这个是重新创建一个列表，并将元素复制过来

讯享网aList = [3, 4, 5] aList = aList + [7] >>> aList [3, 4, 5 ,7] 

2. 使用列表对象的append()方法，再不改变列表在内存中的首地址情况下修改列表，推荐方法

aList.append(9) >>> aList [3, 4, 5, 7 ,9] 

Python 采用的是基于值的自动内存管理方式，当为对象修改值得时候，是使变量直接指向新的值，适用于所有类型的变量

讯享网a = [1, 2, 3] >>> id(a)  a = [1, 2] >>> id(a)  

但如果是通过修改下标来修改序列中元素的值或者通过可变序列对象自身提供的方法来增加和删除元素的时候，序列对象在内存中的起始地址是不变的，仅仅是被修改的元素地址发生变化

a = [1, 2, 4] b = [1, 2, 3] >>> a == b False >>> id(a) == id(b) False >>> id(a[0]) == id(b[0]) True >>> id(a)  a[0] = 5 >>> id(a)  

3. extend(): 将另一个迭代对象的所有元素添加至该列表对象的尾部

讯享网a = [1, 2, 3] >>> id(a)  a.extend([7, 8, 9]) >>> a [1, 2, 3, 7, 8, 9] >>> id(a)  

4. insert(i, j): 在列表的第i个位置插入j元素

aList.insert(3, 6) >>> aList [1, 2, 3, 6, 4] 

5. 使用乘法来扩展列表，将列表与整数相乘，生成一个新的列表，但是只是引用已有对象，当修改其中的一个值的时候，相关引用都会被修改

讯享网aList = [1, 2, 3] bList = aList >>> id(aList) == id(bList) True aList = aList * 2 >>> aList [1, 2, 3, 1, 2, 3] >>> id(aList) == id(bList) False x = [[asd] * 2] * 2 >>> x [[asd, asd], [asd, asd]] x = [1, 2, 3] * 3 x[0][0] = 5 >>> x [[5, 2, 3], [5, 2, 3], [5, 2, 3]] 

2.1.3 列表元素的删除

1. 使用del命令删除列表或者列表中的指定位置上的元素

aList = [1, 2, 3, 4, 5] del aList[0] >>> aList [2, 3, 4, 5] del aList >>> aList Traceback (most recent call last): File "<pyshell#6>", line 1, in <module> a_list NameError: name 'a_list' is not defined 

2. pop(): 删除并返回指定位置的元素，没有则默认为最后一个，如果超出范围则抛回异常

讯享网aList = list((1, 2, 3, 4, 5)) aList.pop(1) aList.pop() >>> aList [1, 3, 4] 

3. remove(): 删除首次出现的指定元素，不存在则返回异常

aList = [1, 2, 3, 2, 4] aList.remove(2) >>> aList [1, 3, 2, 4] 

2.1.4 列表元素访问与计数

可以使用下标直接访问，如果不存在则抛出异常

讯享网aList = [1, 2, 3, 4, 5, 6] >>> aList[3] 4 >>> aList[10] Traceback (most recent call last): File "<stdin>", line 1, in <module> IndexError: list index out of range 

aList = [3, 1, 1, 2] >>> aList.count(1) 2 >>> aList.index(1) 1 

2.1.5 成员资格判断

1. count(): 大于0成立
2. in 关键词

讯享网aList = [1, 2, 3, 4, 5] bList =['a', 'b', 'c', 'd'] cList = [[1], [2], [3]] >>> 3 in aList True >>> [3] in cList True >>> (1, 'a') in zip(aList, bList) True 

★2.1.6 切片操作

切片使用2个冒号分隔的3个数字来完成： [x:y:z]
 x表示切片开始的位置，默认为0
 y表示切片截止的为，默认为列表长度
 z表示切片的步长，默认为1

aList = [1, 2, 3, 4, 5, 7, 9, 11] >>> aList[::] [1, 2, 3, 4, 5, 7, 9, 11] >>> aList[::-1] [11, 9, 7, 5, 4, 3, 2, 1] >>> aList[1::2] [2, 4, 7, 11] >>> aList[1:100:2] [2, 4, 7, 11] >>> aLIst[100:] [] 

注意：切片操作在程序中书写时如果要更改，则需要进行赋值操作

讯享网aList = [1, 2, 3, 4, 5, 7, 9, 11] aList[1::2] print(aList) aList = aList[1::2] print(aList) # 输出内容 [1, 2, 3, 4, 5, 7, 9, 11] [2, 4, 7, 11] 

可以使用切片原地地址修改列表内容

讯享网

aList = [3, 5, 7] # 在尾部追加元素 aList[len(aList):] = [9] >>> aList [3, 5, 7, 9] # 替换前3个元素 aList[:3] = [1, 2, 3] >>> aList [1, 2, 3, 9] # 删除前3个元素 aList[:3] = [] >>> aList [9] # 生成0-9的十个数 aList = list(range(10)) >>> aList [0, 1, 2, 3, 4, 5, 6, 7, 8, 9] # 替换偶数位置上的元素 aList[::2] = [0] * 5 >>> aList [0, 1, 0, 3, 0, 5, 0, 7, 0, 9] # 切片不连续，两个元素个数必须一样多 aList[::2] = [0] * 3 line 13, in <module> aList[::2] = [0]*3 ValueError: attempt to assign sequence of size 3 to extended slice of size 5 # del指令删除元素 aList = [3,5,7,9,11] #删除前3个元素 del aList[:3] #删除偶数位置上的元素 del aList[::2] 

切片返回的是列表元素的浅复制
 浅复制即把原列表所有元素的引用都复制到新列表中，如果只包含数字等基本元素或者元组、字符串这样的不可变类型的数据，进行修改操作不影响原列表
 如果原列表中包含列表等可变数据类型，修改任何一个都会影响到另一个

讯享网aList = [1, 2, 3] bList = aList[::] >>> aList == bList True >>> aList is bList False >>> id(aList) == id(bList) False bList[1] = 8 >>> bList [3, 8, 7] >>> aList [3, 5, 7] aList = [[1, 2], [3, 4], [5, 6]] bList = aList[::] >>> id(aList) == id(bList) False aList[0][0] = 8; >>> aList [[8, 2], [3, 4], [5, 6]] >>> bList [[8, 2], [3, 4], [5, 6]] 

2.1.7 列表排序

1. sort(): 进行原地址排序，为自身进行更改，不需要赋值操作

import random aList = [1, 2, 3, 4, 5, 6, 11, 12, 13] # 将序列的所有元素进行随机排序 random.shuffle(aList) >>> aList [13, 5, 12, 3, 2, 6, 4, 11, 1] # 升序排序 aList.sort() # 降序排列 aList.sort(reverse = True) >>> aList [13, 12, 11, 6, 5, 4, 3, 2, 1] # 按转化成字符串的长度排序 aList.sort(key = lambda x:len(str(x))) [6, 5, 4, 3, 2, 1, 13, 12, 11] 

2. sorted(): 排序并返回新列表

讯享网aList = [13, 5, 12, 3, 2, 6, 4, 11, 1] aList = sorted(aList) >>> aList [1, 2, 3, 4, 5, 6, 11, 12, 13] aList = sorted(aList, reverse = True) >>> aList [13, 12, 11, 6, 5, 4, 3, 2, 1] 

3. reverse(): 将函数自身翻转，不需要赋值

aList = [6, 5, 4, 3, 2, 1, 13, 12, 11] aList.reverse() >>> aList [11, 12, 13, 1, 2, 3, 4, 5, 6] 

4. reversed(): 翻转并返回迭代对象

讯享网aList = [11, 12, 13, 1, 2, 3, 4, 5, 6] # 返回reversed对象 bList = reversed(aList) >>> bList <list_reverseiterator object at 0x0000011BE35B86D8> # 把reversed对象转换成列表 bList = list(bList) >>> bList [6, 5, 4, 3, 2, 1, 13, 12, 11] for i in bList: print(i, end=' ') # 没有输出内容 # 重新创建reversed对象 bList = reversed(aList) for i in bList: print(i, end=' ') 6 5 4 3 2 1 13 12 11 

reversed（）返回的是一个迭代器对象，只能进行一次循环遍历。显示一次所包含的值！

2.1.8 列表常用内置函数

# sum() # sum()函数的start参数默认为0 >>> sum(range(1, 11)) 55 # 指定start参数为5，等价于5+sum(range(1,11)) >>> sum(range(1, 11), 5) 60 #这个操作占用空间较大，慎用 >>> sum([[1, 2], [3], [4]], []) [1, 2, 3, 4] # zip() aList = [1, 2, 3] bList = [4, 5, 6] cList = zip(a, b) # 返回zip对象 >>> cList <zip object at 0x000000000> # 把zip对象转换成列表 >>> list(cList) [(1, 4), (2, 5), (3, 6)] # enumerate() for item in enumerate('abcdef'): print(item) (0, 'a') (1, 'b') (2, 'c') (3, 'd') (4, 'e') (5, 'f') 

2.1.9 列表推导式

讯享网aList = [x * x for x in range(10)] 

等价于

aList = [] for x in range(10): aList.append(x*x) 

也等价于

讯享网aList = list(map(lambda x: x*x, range(10))) 

例：阿凡提与国王比赛下棋，国王说要是自己输了的话阿凡提想要什么他都可以拿得出来。阿凡提说那就要点米吧，棋盘一共64个小格子，在第一个格子里放1粒米，第二个格子里放2粒米，第三个格子里放4粒米，第四个格子里放8粒米，以此类推，后面每个格子里的米都是前一个格子里的2倍，一直把64个格子都放满。需要多少粒米呢？

print(sum([2i for i in range(64)])) 

例1. 使用列表推导式实现嵌套列表的平铺

讯享网vec = [[1, 2, 3], [4, 5, 6], [7, 8, 9]] aList = [num for elem in vec for num in elem] >>> aList [1, 2, 3, 4, 5, 6, 7, 8, 9] 

相当于

vec = [[1, 2, 3], [4, 5, 6], [7, 8, 9]] result = [] for elem in vec: for num in elem: result.append(num) >>> result [1, 2, 3, 4, 5, 6, 7, 8, 9] # 或者 vec = [[1, 2, 3], [4, 5, 6], [7, 8, 9]] result = sum(vec, []) >>> result [1, 2, 3, 4, 5, 6, 7, 8, 9] # chain()可以把一组迭代对象串联起来，形成一个更大的迭代器 vec = [[1, 2, 3], [4, 5, 6], [7, 8, 9]] from itertools import chain result = list(chain(*vec)) >>> result [1, 2, 3, 4, 5, 6, 7, 8, 9] 

例2. 列出当前文件夹下所有Python源文件

讯享网>>> import os >>> [filename for filename in os.listdir('.') if filename.endswith(('.py', '.pyw'))] 

例3. 过滤不符合条件的元素

>>> aList = [-1,-4,6,7.5,-2.3,9,-11] >>> [i for i in aList if i>0] [6, 7.5, 9]