Python学习笔记：序列

系统管理员 2023-07-05 14:43 1阅读 0赞

### 文章目录 ###

*   *  1 通用的序列操作
     *   *  1.1 索引
         *  1.2 切片
         *   *  1.2.1 简写
             *  1.2.2 步长
         *  1.3 序列相加
         *  1.4 乘法
         *  1.5 成员资格
         *  1.6 长度、最大值和最小值
     *  2 列表
     *   *  2.1 赋值元素
         *  2.2 删除元素
         *  2.3 切片赋值
         *  2.4 列表方法
         *   *  2.4.1 append
             *  2.4.2 clear
             *  2.4.3 copy
             *  2.4.4 count
             *  2.4.5 extend
             *  2.4.6 index
             *  2.4.7 insert
             *  2.4.8 pop
             *  2.4.9 remove
             *  2.4.10 reverse
             *  2.4.11 sort
     *  3 元组
     *  4 总结

在Python中内置了多种序列，其中最常用的两种：列表\[\]和元组()。  
列表和元组的主要不同在于：列表是可以修改的，而元组不可以。这意味着列表适用于 需要中途添加元素的情形，而元组适用出于某种考虑需要禁止 修改序列的情形。

## 1 通用的序列操作 ##

### 1.1 索引 ###

序列中所有元素都有编号，并从0开始递增。而编号通常被称为**索引**。  
你可以使用索引来获取元素，如：

>>> a = 'hello world'
    >>> a[0]
    'h'

当使用负数索引时，Python将从右（最后一个元素）开始往左数，因此-1是最后一个元素的位置：

>>> a[-1]
    'd'

### 1.2 切片 ###

使用两个索引，并用冒号分隔的方式来访问特定范围内的元素，称为**切片**。  
其中，第一个索引是包含的的第一个元素的编号，第二个索引是切片后余下的第一个元素的编号，类似数学区间 \[x, y) 的概念。

>>> n = [1,2,3,4,5,6,7,8,9,10]
    
    >>> n[0:1]
    [1]
    
    >>> n[7:9]
    [8, 9]
    
    >>> n[-3:-1]
    [8, 9]

但如果第一个索引指定的元素位于第二个索引指定的元素后面，结果就为空序列。

>>> n[-3:0]
    []

#### 1.2.1 简写 ####

如果切片结束于序列末尾，可省略第二个索引

>>> n[3:]
    [4, 5, 6, 7, 8, 9, 10]

如果切片始于序列开头，可省略第一个索引

>>> n[:3]
    [1, 2, 3]

如果要复制整个序列，可将两个索引都省略

>>> n[:]
    [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]

#### 1.2.2 步长 ####

执行切片操作时，通常会省略另一个参数：**步长**。  
在普通切片中，步长为1：

>>> n[::1]
    [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]

步长为2时，将从起点和终点之间每隔一个元素提取一个元素

>>> n[::2]
    [1, 3, 5, 7, 9]

注意：步长不能为0，否则无法想前移动，但可以为负数，即从右向左提取元素

>>> n[::0]
    Traceback (most recent call last):
      File "<stdin>", line 1, in <module>
    ValueError: slice step cannot be zero
    
    >>> n[::-2]
    [10, 8, 6, 4, 2]

### 1.3 序列相加 ###

可使用加法运算符来拼接序列，但不能拼接不同类型的序列。

>>> [1,2,3,4] + [5,6,7,8]
    [1, 2, 3, 4, 5, 6, 7, 8]
    
    >>> 'hello' + 'world'
    'helloworld'
    
    >>> 'hello' + [5,6,7,8]
    Traceback (most recent call last):
      File "<stdin>", line 1, in <module>
    TypeError: can only concatenate str (not "list") to str

### 1.4 乘法 ###

将序列与数x相乘是，将重复这个序列x次来创建一个新序列

>>> [12] * 12
    [12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12]
    
    >>> 'python' * 5
    'pythonpythonpythonpythonpython'

### 1.5 成员资格 ###

要检查特定的值是否包含在序列中，可使用运算符in，检查是否满足指定的条件，并返回相应的值：满足时返回True，不满足返回False。

>>> s = 'hello world'
    >>> 'h' in s
    True
    >>> 'L' in s
    False
    >>> 'H' in s
    False

### 1.6 长度、最大值和最小值 ###

内置函数len返回序列包含的元素个数，而max和min分别返回序列中最大和最小的元素。

>>> n  =  [100, 34, 886]
    >>> len(n)
    3
    >>> max(n)
    886
    >>> min(n)
    34

## 2 列表 ##

列表是最常用的Python数据类型，它可以作为一个方括号内的逗号分隔值出现。可使用list函数可以将一个序列作为参数，并将其转换为元组：

>>> list('hello')
    ['h', 'e', 'l', 'l', 'o']

对列表执行的所有标准序列操作，如索引，切片等，但列表还可以被修改。

### 2.1 赋值元素 ###

只需要用普通的赋值语句，就能修改列表中的元素

>>> x = [1, 1, 1]
    >>> x[1] = 2
    >>> x
    [1, 2, 1]

### 2.2 删除元素 ###

使用del语句即可删除列表中的元素

>>> del x[2]
    >>> x
    [1, 2]

### 2.3 切片赋值 ###

切片赋值的方式，可以同时给多个元素赋值

>>> name = list('Li')
    >>> name
    ['L', 'i']
    >>> name[1:] = list('ang')
    >>> name
    ['L', 'a', 'n', 'g']

使用切片赋值，还可在不替换原有元素的情况下插入新元素

>>> n = [1,5]
    >>> n[1:1] = [2,3,4]
    >>> n
    [1, 2, 3, 4, 5]

当然也可以反过来删除切片

>>> n =  [1, 2, 3, 4, 5]
    >>> n[1:4] = []
    >>> n
    [1, 5]

### 2.4 列表方法 ###

#### 2.4.1 append ####

方法append用于将一个对象附加到列表末尾

>>> n = [1, 2, 3]
    >>> n.append(4)
    >>> n
    [1, 2, 3, 4]

#### 2.4.2 clear ####

方法clear清空列表的内容

>>> n = [1, 2, 3]
    >>> n.clear()
    >>> n
    []

#### 2.4.3 copy ####

常规复制，只是将两一个名称关联到列表

>>> a  = [1, 2, 3]
    >>> b = a
    >>> b[1] = 4
    >>> a
    [1, 4, 3]

要让a和b指向不同的列表，就必须将b关联到a的副本

>>> a = [1, 2, 3]
    >>> b = a.copy()
    >>> b[1] = 4
    >>> b
    [1, 4, 3]
    >>> a
    [1, 2, 3]

#### 2.4.4 count ####

方法count计算指定的元素在列表中出现了多少次。

>>> x = [[1, 2], 2, 1, 1, [1, 2]]
    >>> x.count(2)
    1
    >>> x.count([1, 2])
    2

#### 2.4.5 extend ####

方法extend让你能够同时将多个值附加到列表末尾，为此可将这些值组成的序列作为参数提供给extend。换言之，可使用一个列表扩展另一个列表。

>>> a = [1, 2, 3]
    >>> b = [4, 5, 6]
    >>> a.extend(b)
    >>> a
    [1, 2, 3, 4, 5, 6]
    >>> b
    [4, 5, 6]

与拼接不同，extend修改了被扩展的序列，而在常规拼接中，返回的是一个全新的序列

>>> a = [1, 2, 3]
    >>> b = [4, 5, 6]
    >>> a + b
    [1, 2, 3, 4, 5, 6]
    >>> a
    [1, 2, 3]

#### 2.4.6 index ####

方法index在列表中查找指定值第一次出现的索引

>>> n = [1,2,3,3,4]
    >>> n.index(2)
    1
    >>> n.index(3)
    2
    >>> n.index(5)
    Traceback (most recent call last):
      File "<stdin>", line 1, in <module>
    ValueError: 5 is not in list

搜索5时，发生了异常，因为列表中根本不包含5

#### 2.4.7 insert ####

方法insert用于将一个对相关插入列表

>>> n = [1, 2, 3, 4, 5]
    >>> n.insert(3, 'four')
    >>> n
    [1, 2, 3, 'four', 4, 5]

#### 2.4.8 pop ####

方法pop从列表中删除一个元素（默认为最后一个元素），并返回这个元素。使用pop可实现栈（stack）

>>> n = [1, 2, 3]
    >>> n.pop()
    3
    >>> n
    [1, 2]
    >>> n.pop(0)
    1
    >>> n
    [2]

*pop是唯一即修改列表又返回一个非None值的列表方法*

#### 2.4.9 remove ####

方法remove用于删除第一个所指定值的元素

>>> x = [1, 2 ,3, 2, 4, 5]
    >>> x.remove(2)
    >>> x
    [1, 3, 2, 4, 5]
    >>> x.remove(2)
    >>> x
    [1, 3, 4, 5]
    >>> x.remove(6)
    Traceback (most recent call last):
      File "<stdin>", line 1, in <module>
    ValueError: list.remove(x): x not in list

#### 2.4.10 reverse ####

方法reverse按相反的顺序排列列表中的元素。

>>> x =  [1, 2, 3]
    >>> x.reverse()
    >>> x
    [3, 2, 1]

#### 2.4.11 sort ####

方法sort用于对列表就地排序（由小到大）。就地排序意味着对原来的列表进行修改，使其元素按顺序排列，而不是返回排序后的列表的副本。

>>> x = [1, 2, 4, 3, 6, 5]
    >>> x.sort()
    >>> x
    [1, 2, 3, 4, 5, 6]

如果要将元素按照相反的顺序排列，可以先使用sort方法，在调用方法reverse，或者使用reverse参数

>>> x = [1, 2, 4, 3, 6, 5]
    >>> x.sort(reverse=True)
    >>> x
    [6, 5, 4, 3, 2, 1]

方法sort还有一个可选参数是key。参数key类似于参数cmp，主要是用来进行比较的元素，只有一个参数，具体的函数的参数就是取自于可迭代对象中，指定可迭代对象中的一个元素来进行排序。  
如，按照长度排序：

>>> x = ['ad', 'abcd', 'abc']
    >>> x.sort(key=len)
    >>> x
    ['ad', 'abc', 'abcd']

## 3 元组 ##

与列表一样，元组也是序列，唯一的差别在于元组是不能修改的。元组的语法很简单，只要将一些值用逗号分隔，就能自动创建一个元组。