官方手册:
序列简介
序列是指按照位置顺序来存储数据的数据结构, 也就是说能通过数值索引进行操作. 实际上, python 对序列的解释是: 只要类型对象中重载了__len__()和__getitem__(), 且它们的整数参数从 0 开始, 就表示这个类型满足序列协议, 是一个序列类型.
python 有三种基本的序列类型: 列表, 元组和 range 对象. 当然, 还有特别定制的序列类型: str 和 binary data.
序列类型又分为可变序列和不可变序列. 可变序列表示可以原处修改的序列, 不可变序列意味着不允许原处修改. 例如, 列表是可变序列, 字符串是不可变序列.
可变对象和不可变对象的含义, 参见 python 可变对象和不可变对象的解释.
序列的通用操作
下面这些操作是序列通用的, 无论是可变, 不可变序列. 但通用并不意味着所有序列都支持这些操作, 有些特殊的序列因为某些原因不支持某些操作也是合理的.
1. 测试元素是否存在
x in S 和 x not in S, 返回 True 或 False. 例如:
- >>> 'a' in "abcd"
- True
- >>> 'aa' in "abcd"
- False
- >>> 'ab' in "abcd"
- True
- >>> 3 in [1,2,3,4]
- True
2. 加法和乘法符号
S1 + S2 或 S * N 或 N * S, 其中 S1 和 S2 是同一种序列类型, N 表示序列的重复次数.
例如:
- >>> [1,2] + [3,4]
- [1, 2, 3, 4]
- >>> [1,2] * 3
- [1, 2, 1, 2, 1, 2]
- >>> 3 * [1, 2]
- [1, 2, 1, 2, 1, 2]
注意, 序列中保存的是元素的引用地址, 所以对于序列中的可变元素,+ * 时需要注意修改的影响范围:
- >>> L = [1,2,3,4]
- >>> L1 = [['a'],['b']]
- >>> L0 = L + L1
- >>> L0
- [1, 2, 3, 4, ['a'], ['b']]
- >>> L1[0][0] = "aa"
- >>> L0
- [1, 2, 3, 4, ['aa'], ['b']]
上面修改 "a" 为 "aa" 也会影响到 + 的结果 L0, 因为 ['a'] 是一个可变对象. 同样对于 * 的重复操作, 也是拷贝引用:
- >>> L = []
- >>> L1 = [L] * 3
- >>> L1
- [[], [], []]
- >>> L.append(3)
- >>> L1
- [[3], [3], [3]]
3.len(),max()和 min()函数
len()返回序列的元素个数, 也就是序列的长度. min()和 max()分别返回序列中最小, 最大的元素.
- >>> len(L), min(L), max(L)
- (4, 'a', 'd')
4. 找出元素在序列中出现的次数 count()
- >>> s="hello world"
- >>> s.count("h"),s.count("o")
- (1, 2)
5. 索引取元素
S[i],i 为从 0 开始的数值, 可以取负数表示从尾部开始取.
例如:
- >>> L
- ['a', 'b', 'c', 'd']
- >>> L[0]
- 'a'
- >>> L[1]
- 'b'
- >>> L[-1]
- 'd'
负数的 i 等价于 len(S)+i 作为索引. 例如, len(S) = 3, i = -1, 表示取最后一个元素, 也就是 index=2 的元素.
6. 分片
分片操作用于从序列中取出子序列, 它会创建新的内存块来保存取出来的序列对象.
S[i:j]: 从索引位 i 取到索引位 j, 不包括 j
S[i:]: 从索引位 i 开始取到最结尾
S[:j]: 从最开头取到索引位 j, 不包括 j
S[:]: 从头取到尾, 相当于拷贝了序列, 但得到的是新序列
S[i:j:k]:k 表示取元素时的步进间隔, 默认为 1, 表示每个元素都取, 如果为 2, 则表示取一个跳过一个
分片的区间是左闭右开的, 所以不会包括 j 的索引位. i 和 j 可以是负数, 负数表示从尾部开始计算索引位. 例如,-1 表示最后一个元素,-2 表示倒数第二个元素.
特别地, 如果 i = j, 则表示找到序列中的这个位置, 但因为切片长度位 0, 所以返回空.
例如:
- >>> s = "hello world"
- >>> len(s)
- 11
- >>> s[0:6]
- 'hello'
- >>> s[:6]
- 'hello'
- >>> s[6:10] # 不包括 index=10
- 'worl'
- >>> s[6:11] # 所以用大于 10 的结束位
- 'world'
- >>> s[6:]
- 'world'
- >>> s[6:-1]
- 'worl'
- >>> s[:] # 拷贝序列得到副本
- 'hello world'
- >>> s[::1] # 步进为 1, 默认的
- 'hello world'
- >>> s[::2] # 每次跳过一个元素
- 'hlowrd'
- >>> s[1:1] # 找到 index=1 的位置
- ''
7. 找出第一个元素的位置 index()
index(x,i,j)表示从序列中搜索元素 x 并返回第一次出现的 x 的位置, 如果给定了 i, 则表示从索引位 i 开始搜索, 给定了 j 则表示最多搜索到索引位为 j 的位置.
如果找不到元素, 将报错. i 和 j 可以是负数, 但无论它们是正数还是负数, 都是搜索的开始和结束位.
- >>> s="hello world"
- >>> s.index("o")
- 4
- >>> s.index("o",1,-1)
- 4
- >>> s.index("o",-5) # 从倒数第 5 个元素开始搜索
- 7
- >>> s.index("a") # 搜索不到时报错
- Traceback (most recent call last):
- File "<stdin>", line 1, in <module>
- ValueError: substring not found
不可变序列的操作
相比可变序列, 不可变序列的唯一操作是可以支持内置的 hash()操作. 可变序列无法 hahs().
- >>> hash("asd")
- -2014632507
- >>> hash((1,23))
- 1320437575
- >>> hash([1,23])
- Traceback (most recent call last):
- File "<stdin>", line 1, in <module>
- TypeError: unhashable type: 'list'
能够 hash 的不可变序列, 意味着能作为 dict 的 key, 能保存到 set 或 frozenset 中.
可变序列的操作
s[i] = x,s[i:j] = t 将序列中的元素替换成 x 或可迭代对象 t
s[i:j:K] = t 将序列中的元素替换成可迭代对象 t,t 的长度必须和 s[i:j:k]的长度一样
del s[i],del s[i:j]删除序列中的元素, 等价于 s[i] = [],s[i:j] = []
del s[i:j:k]删除序列中的某些元素, k 为步进值
s.remove(x): 移除第一次出现的元素 x
s.clear()表示清空序列中的所有元素, 等价于 del s[:]
s.pop([i])表示移除序列 s 中的第 i 个元素并返回这个元素, 中括号表示可选, 如果没有参数, 默认移除最后一个元素
s.append(x)向序列的尾部追加元素 x, 等价于
s[len(s):len(s)] = [x]
s.extend(t)或 s += t 表示将 t 扩展到序列 s 的尾部, 等价于
s[len(s):len(s)] = t
s.insert(i,x)表示将 x 插入到序列中的 i 索引位置处, 等价于 s[i:i] = [x]
s *= n 表示将序列 n 的元素重复 n 次追加到 s 的尾部
s.copy()表示拷贝序列得到一个新的序列副本, 等价于 s[:]
s.reverse()原地反转序列 s, 为了节约内存空间, 所以是原地反转, 不会返回反转后的序列
对于序列, 还有一个内置函数 reversed(SEQ). 与之对应的, 还有一个内置函数 sorted(), 但它操作的对象是可迭代对象, 并不一定总是序列.
示例 1: 序列元素赋值
- >>> L = ['aa','bb','cc','dd','ee','ff']
- >>> L1 = [1,2,3,4]
- >>> L[0] = "a"
- >>> L
- ['a', 'bb', 'cc', 'dd', 'ee', 'ff']
- >>> L[1:2] = L1
- >>> L
- ['a', 1, 2, 3, 4, 'cc', 'dd', 'ee', 'ff']
- >>> L[::2] = [1,2,3,4,5]
- >>> L
- [1, 1, 2, 3, 3, 'cc', 4, 'ee', 5]
示例 2: 删除元素
删除相关操作有 del,remove(),pop(),clear().
例如:
- >>> L = ['aa','bb','cc','dd','ee','ff']
- >>> del L[1]
- >>> L
- ['aa', 'cc', 'dd', 'ee', 'ff']
- >>> del L[1:2]
- >>> L
- ['aa', 'dd', 'ee', 'ff']
- >>> del L[::2]
- >>> L
- ['dd', 'ff']
- >>> L = ['aa','bb','cc','dd','ee','ff']
- >>> L.remove('aa')
- >>> L
- ['bb', 'cc', 'dd', 'ee', 'ff']
- >>> L.pop()
- 'ff'
- >>> L
- ['bb', 'cc', 'dd', 'ee']
- >>> L.pop(2)
- 'dd'
- >>> L
- ['bb', 'cc', 'ee']
- >>> L.clear()
- >>> L
- []
示例 3: 添加元素
相关操作有 append(),extend(),insert(),s *= n.
例如:
- >>> L = ['aa', 'bb', 'cc', 'dd', 'ee']
- >>> L1 = [1,2,3,4]
- >>> L.append("ff")
- >>> L
- ['aa', 'bb', 'cc', 'dd', 'ee', 'ff']
- >>> L.insert(1,"a")
- >>> L
- ['aa', 'a', 'bb', 'cc', 'dd', 'ee', 'ff']
- >>> L.extend(L1)
- >>> L
- ['aa', 'a', 'bb', 'cc', 'dd', 'ee', 'ff', 1, 2, 3, 4]
- >>> L1 * 2
- [1, 2, 3, 4, 1, 2, 3, 4]
示例 4: 其它操作
拷贝序列 copy(), 反转序列 reverse().
- >>> L = ['aa', 'bb', 'cc', 'dd', 'ee']
- >>> L1 = L.copy()
- >>> L1
- ['aa', 'bb', 'cc', 'dd', 'ee']
- >>> L.reverse()
- >>> L
- ['ee', 'dd', 'cc', 'bb', 'aa']
还有一个可用于序列的内置函数 reversed(), 它反转序列, 并返回可迭代对象. 所以, 如果要将它展现出来, 需要构建容器. 例如:
- >>> L = ['aa', 'bb', 'cc', 'dd', 'ee']
- >>> list(reversed(L))
- ['ee', 'dd', 'cc', 'bb', 'aa']
- >>> set(reversed(L))
- {
- 'aa', 'bb', 'ee', 'cc', 'dd'
- }
来源: https://www.cnblogs.com/f-ck-need-u/p/10144798.html