Python系列 10 线性容器序列（list）

列表

Python中的列表（list）是最常用的数据类型之一。

Python中的列表可以存储任意类型的数据，这与其他语言中的数组（array）不同。

被存入列表中的内容可称之为元素（element）或者数据项（data item）亦或是值（value）。

虽然Python列表支持存储任意类型的数据项，但不建议这么做，事实上这么做的概率也很低。

列表特性

列表特性如下：

1. 列表属于线性容器序列
2. 列表属于可变类型，即对象本身的属性会根据外部变化而变化，例如长度
3. 列表底层由顺序存储组成，而顺序存储是线性结构的一种

基本声明

以下是使用类实例化的形式进行对象声明：

lst = list((1, 2, 3, 4, 5))
print("value : %r\ntype : %r" % (lst, type(lst)))

# value : [1, 2, 3, 4, 5]
# type : <class 'list'>

也可以选择使用更方便的字面量形式进行对象声明，利用[]对数据项进行包裹，并且使用逗号将数据项之间进行分割：

lst = [1, 2, 3, 4, 5]
print("value : %r\ntype : %r" % (lst, type(lst)))

# value : [1, 2, 3, 4, 5]
# type : <class 'list'>

多维列表

当一个列表中嵌套另一个列表，该列表就可以称为多维列表。

如下，定义一个2维列表：

lst = [1, 2, ["三","四"]]
print("value : %r\ntype : %r" % (lst, type(lst)))

# value : [1, 2, ['三', '四']]
# type : <class 'list'>

续行操作

在Python中，列表中的数据项如果过多，可能会导致整个列表太长，太长的列表是不符合PEP8规范的。

• 每行最大的字符数不可超过79，文档字符或者注释每行不可超过72

Python虽然提供了续行符\，但是在列表中可以忽略续行符，如下所示：

lst = [
    1,
    2,
    3,
    4,
    5
]
print("value : %r\ntype : %r" % (lst, type(lst)))

# value : [1, 2, 3, 4, 5]
# type : <class 'list'>

类型转换

列表支持与布尔型、字符串、元组、以及集合类型进行类型转换：

lst = [1, 2, 3]
bLi = bool(lst)
strLi = str(lst)
tupLi = tuple(lst)
setLi = set(lst)

print("value : %r\ntype : %r" % (bLi, type(bLi)))
print("value : %r\ntype : %r" % (strLi, type(strLi)))
print("value : %r\ntype : %r" % (tupLi, type(tupLi)))
print("value : %r\ntype : %r" % (setLi, type(setLi)))

# value : True
# type : <class 'bool'>
# value : '[1, 2, 3]'
# type : <class 'str'>
# value : (1, 2, 3)
# type : <class 'tuple'>
# value : {1, 2, 3}
# type : <class 'set'>

如果一个2维列表遵循一定的规律，那么也可以将其转换为字典类型：

lst = [["k1", "v1"], ["k2", "v2"], ["k3", "v3"]]
dictList = dict(lst)

print("value : %r\ntype : %r" % (dictList, type(dictList)))

# value : {'k1': 'v1', 'k2': 'v2', 'k3': 'v3'}
# type : <class 'dict'>

四则运算

列表支持与元组，列表进行加法运算：

• +：合并2个列表并生成新列表：

  lst1 = [1, 2, 3]
  lst2 = [4, 5, 6]
  newLi = lst1 + lst2
  print(newLi)
  
  # [1, 2, 3, 4, 5, 6]
  

• +=：扩展已有列表，相当于extend()方法：

  oldLi = [1, 2, 3]
  newLi = [4, 5, 6]
  oldLi += newLi
  print(oldLi)
  
  # [1, 2, 3, 4, 5, 6]
  

列表支持与数字进行乘法运算：

• *：生成一个重复旧列表数据项的新列表：

  oldLi = [1, 2, 3]
  newLi = oldLi * 3
  print(newLi)
  
  # [1, 2, 3, 1, 2, 3, 1, 2, 3]
  

• *=：扩展已有列表，将已有列表的数据项进行重复添加：

  oldLi = [1, 2, 3]
  oldLi *= 3
  print(oldLi)
  
  # [1, 2, 3, 1, 2, 3, 1, 2, 3]
  

索引切片

索引的概念

列表底层是以一种连续的顺序结构存储数据项，故可以使用索引（index）对数据项进行获取、删除、截取、替换等操作。

----------------------------|
| A | B | C | D | E | F | G |
----------------------------|
| 0 | 1 | 2 | 3 | 4 | 5 | 6 |
|-7 |-6 |-5 |-4 |-3 |-2 |-1 |

正向索引都是从0开始，负向索引都是从-1开始。

enumerate()

我们以一个内置函数enumerate()来举例，该函数返回一个迭代器，将其转换为list()后可以查看数据项以及正向索引：

lst = ["A", "B", "C", "D", "E", "F", "G"]
print(list(enumerate(lst)))

# [(0, 'A'), (1, 'B'), (2, 'C'), (3, 'D'), (4, 'E'), (5, 'F'), (6, 'G')]

更多的关于enumerate()函数的妙用，将会放在循环章节中进行探讨。

slice()

slice()函数有三个参数：

• start：索引开始的位置

• stop：索引结束的位置

• step：步长间距，默认为1

  如果为正数代表正取，如果为负数代表倒取

  如果为1代表连续取，如果为2代表隔一个取一个，以此类推

使用方法如下示例，先使用slice()确定截取数据项的范围，然后再使用列表的[]操作形式取出指定范围的数据项。

注意：所有的切片都是顾头不顾尾：

lst = ["A", "B", "C", "D", "E", "F", "G"]

# 取出A
# 释义：从0开始取，取1个，步长为0
s = slice(0, 1, None)
print(lst[s])

# ['A']

[::]形式

使用slice()函数会比较繁琐，直接使用[::]形式进行切片会比较简单。

签名如下：

[start:stop:step]

参数描述和slice()相同，当某一参数不设置时可省略前面的参数。

增删改截操作演示：

>>> # 获取第2个数据项
>>> lst = ["A", "B", "C", "D", "E", "F", "G"]
>>> lst[1]
'B'
>>> # 删除第3个数据项
>>> del lst[2]
>>> lst
['A', 'B', 'D', 'E', 'F', 'G']
>>> # 从第1个数据项开始向后替换2个数据项，替换内容为123
>>> lst[0:3] = 1,2,3
>>> lst
[1, 2, 3, 'E', 'F', 'G']
>>> # 从第1个数据项开始获取2个数据项
>>> lst[0:3]
[1, 2, 3]
>>> # 试图访问一个超出索引之外的数据项，将引发异常
>>> lst[100]
IndexError: lstst index out of range

需要注意的是，如果使用[:]则会创建一个新的列表，再将原有列表中的数据项全部引用至新的列表中，类似于浅拷贝的概念。

如下所示：

lst1 = ["A", "B", "C", "D", "E", "F", "G"]
lst2 = lst1[:]

print("value : %r\naddr : %r" % (lst1, id(lst1)))
print("value : %r\naddr : %r" % (lst2, id(lst2)))

# value