Python基础教程：关于序列操作的方式方法

秒速五厘米 2022-09-04 13:52 81阅读 0赞

序列是指按照位置顺序来存储数据的数据结构，也就是说能通过数值索引进行操作。实际上，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]

注意，序列中保存的是元素的引用地址，所以对于序列中的可变元素，`+ *`时需要注意修改的影响范围：

''' 学习中遇到问题没人解答？小编创建了一个Python学习交流QQ群：531509025 寻找有志同道合的小伙伴，互帮互助,群里还有不错的视频学习教程和PDF电子书！ '''
    >>> 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开始的数值，可以取负数表示从尾部开始取。

例如：

''' 学习中遇到问题没人解答？小编创建了一个Python学习交流QQ群：531509025 寻找有志同道合的小伙伴，互帮互助,群里还有不错的视频学习教程和PDF电子书！ '''
    >>> 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()操作。可变序列无法hash()。

''' 学习中遇到问题没人解答？小编创建了一个Python学习交流QQ群：531509025 寻找有志同道合的小伙伴，互帮互助,群里还有不错的视频学习教程和PDF电子书！ '''
    >>> 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()。

例如：

''' 学习中遇到问题没人解答？小编创建了一个Python学习交流QQ群：531509025 寻找有志同道合的小伙伴，互帮互助,群里还有不错的视频学习教程和PDF电子书！ '''
    >>> 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()。

''' 学习中遇到问题没人解答？小编创建了一个Python学习交流QQ群：531509025 寻找有志同道合的小伙伴，互帮互助,群里还有不错的视频学习教程和PDF电子书！ '''
    >>> 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'}