【Think Python】Python笔记（十）列表

内置类型之：列表（list）

（一）列表是一个序列

• 与字符串类似，列表是多个值组成的序列；
• 在字符串中，每个值都是字符；
• 在列表中，值可以是任何数据类型；列表中的值称之为元素（element），或者项；

• 创建列表的方式有很多种：

  • 最简单的是用方括号（[]）将元素括起来

  [10, 20, 30, 40]
  ['guo', 'liu', 'wang']
  

  • 一个列表中的元素不一定是相同的类型

  ['guo', 14, 14.0, [10, 20]]
  

  • 一个列表中含有列表称之为嵌套列表
  • 不包含任何元素的列表称之为空列表，可以使用[]创建一个空列表
  • 可以将列表赋值给变量

  >>> cheeses = ['Cheddar', 'Edam', 'Gouda']
  >>> numbers = [1, 2, 3, 4]
  empty = []
  

（二）列表是可变的

• 前面讲的是字符串是不可变的；
• 这里列表是可变的；
• 访问列表中元素的方法与访问字符串中的元素的方法相同；都是使用方括号[]；

>>> numbers = [42, 123]
>>> numbers[1] = 3
>>>numbers
[42, 3]

• 下面是列表的状态图：

• 列表下标的工作原理与字符串下标的工作原理相同：
  • 任何整数表达式都可以作为下标；
  • 当试图读写一个不存在的元素的时候，将会得到一个索引错误（IndexError）；
  • 如果下标是负数，将会从列表的末端进行访问；
• in运算符可以使用：

>>> cheeses = ['Cheddar', 'Edam', 'Gouda']
>>> 'Edam' in cheeses
True
>>> 'Brie' in cheeses
False

（三）遍历列表

• 最常用的遍历方法是for循环，与遍历字符串是相同的

for item in cheeses:
    print(item)

• 如果只是读取列表中的元素，上面的方法是可以的，但是如果想要写入或者更新列表中的元素，需要通过下标进行访问；通常使用两个内置函数的结合：range和len：

for i in range(len(numbers)):
    numbers[i] = number[i] * 2 

• 对空列表执行for循环，将不会执行循环的主体：

for x in []:
    print('this never happen')

• 列表中虽然可以嵌套列表，但是嵌套的列表本身是看做单个元素的：

# 长度为4
['spam', 1, ['Brie', 'Roquefort', 'Pol le Veq'], [1, 2, 3]]

（四）列表操作

+运算符用来拼接多个列表；

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

运算符*用来给定次数地重复一个列表；

>>> [0] * 4
[0, 0, 0, 0]
>>> [1, 2, 3] * 3
[1, 2, 3, 1, 2, 3, 1, 2, 3]

（五）列表切片

>>> t = ['a', 'b', 'c', 'd', 'e', 'f']
>>> t[1:3]
['b', 'c']
>>> t[:4]
['a', 'b', 'c', 'd']
>>> t[3:]
['d', 'e', 'f']

• 如果省略第一个索引，切片将从列表头开始。如果省略第二个索引，切片将会到列表尾结束。 所以如果你两者都省略，切片就是整个列表的一个拷贝。

• 切片运算符放在赋值语句的左边时，可以一次更新多个元素：

>>> t = ['a', 'b', 'c', 'd', 'e', 'f']
>>> t[1:3] = ['x', 'y']
>>> t
['a', 'x', 'y', 'd', 'e', 'f']

（六）列表方法

• append：添加一个元素在列表的末尾：

>>> t = ['a', 'b', 'c']
>>> t.append('d')
>>> t
['a', 'b', 'c', 'd']

• extend：接受一个列表作为参数，并将其中的元素添加到目标列表中：

>>> t1 = ['a', 'b', 'c']
>>> t2 = ['d', 'e']
>>> t1.extend(t2)
>>> t1
['a', 'b', 'c', 'd', 'e']

• sort：将列表中的元素从小到大进行排序：

>>> t = ['d', 'e', 'a', 'c', 'b']
>>> t.sort()
>>> t
['a', 'b', 'c', 'd', 'e']

• 大部分的列表方法都是无返回值的；它们对列表进行修改，然后返回None

（七）映射、筛选和归并

增量赋值语句（augmented assignment statement）：+=;

total += x

等价于：

total = total + x

• python中使用内建函数sum，将列表中的元素加起来：

>>> t = [1, 2, 3]
>>> sum(t)
6

一个像这样的将一系列的元素合并成一个单一值的操作有时称为 归并（reduce）

• 将列表中的元素通过一个函数可以映射组成另外一列表：

def capitalize_all(t):
    res = []
    for s in t:
        res.append(s.capitalize())
    return res

• 从列表中选取一些元素，组成新的列表称之为筛选；

（八）删除元素

• 如果知道所要删除元素的下标，可以使用pop;

>>> t = ['a', 'b', 'c']
>>> x = t.pop(1)
>>> t
['a', 'c']
>>> x
'b'

pop修改列表，并返回被移除的元素。如果你不提供下标，它将移除并返回最后一个元素；

• 如果不需要所要删除的元素，可以使用del：

>>> t = ['a', 'b', 'c']
>>> del t[1]
>>> t
['a', 'c']

• 如果知道要删除的元素，但是不知道下标，可以使用remove；

>>> t = ['a', 'b', 'c']
>>> t.remove('b')
>>> t
['a', 'c']

• 需要删除多个元素，可以使用切片索引结合del;

>>> t = ['a', 'b', 'c', 'd', 'e', 'f']
>>> del t[1:5]
>>> t
['a', 'f']

（九）列表和字符串

• 字符串是字符的序列；
• 列表是值的序列；
• 但是一个字符组成的列表不等于字符串；

• 可以使用list将一个字符串转换为字符的列表：

>>> s = 'spam'
>>> t = list(s)
>>> t
['s', 'p', 'a', 'm']

• 可以使用split方法来将一个字符串分割成一些单词：

>>> s = 'this is an apple'
>>> t = s.split()
>>> t
['this', 'is', 'an', 'apple']

这个函数默认分隔使用空格，可以提供一个分隔符的可选参数，指定拿哪一个字符作为单词之间的界限

>>> s = 'spam-spam-spam'
>>> t = s.split('-')
>>> t
['spam', 'spam', 'spam']

• join和split的功能相反，它将一个字符串列表的元素拼接起来；join是一个字符串方法，所以要在分隔符上年调用它，并传入列表作为参数：

>>> t = ['this', 'is', 'an', 'apple']
>>> delimiter = ' '
>>> s = delimiter.join(t)
>>> s
'this is an apple'

（十）对象和值

• 一个例子：

  • 对于字符串：

  >>> a = 'banana'
  >>> b = 'banana'
  >>> a is b
  True
  

  • 对于列表：

  >>> a = [1, 2, 3]
  >>> b = [1, 2, 3]
  >>> a is b
  False
  

  • 查看两个变量是不是同一个对象，使用is运算符；
  • 在后面的列表的例子中，我们称之为相等（equivalent），但是并不是相同（identical），因为这两个并不是同一个对象；
  • 如果两个对象是相同的，则必然是相等的；

（十一）别名

如果 a 指向一个对象，然后你赋值 b = a ，那么两个变量指向同一个对象：

>>> a = [1, 2, 3]
>>> b = a
>>> b is a
True

• 变量和对象之间的关联称之为引用（reference），上面的例子中，有两个对同一对象的引用；
• 当一个对象有多个引用的时候，则称这个对象是有别名的(aliased)；
• 如果一个有别名的对象是可变的，则对一个别名的改变会影响到其他的别名：

>>> b[0] = 42
>>> a
[42, 2, 3]

• 这种很有用，但是容易导致错误；通常对于可变对象避免使用别名；

（十二）列表参数

当列表作为参数的时候，实际上传进函数的是一个引用；因此，函数中对于列表的修改，会在函数的调用者中体现；

def delete_head(t):
    del t[0]

>>> letters = ['a', 'b', 'c']
>>> delete_head(letters)
>>> letters
['b', 'c']

• 参数t和letters是同一个对象的别名：

• 注意修改列表和创建列表之间的区别：如append方法是修改一个列表，而+是创建一个新的列表

>>> t1 = [1, 2]
>>> t2 = t1.append(3)
>>> t1
[1, 2, 3]
>>> t2
None

>>> t3 = t1 + [4]
>>> t1
[1, 2, 3]
>>> t3
[1, 2, 3, 4]
>>> t1

• 可以看出：+创建了一个新的列表，但是对原来的列表并没有影响 ；

• 切片操作，是创建了新的列表；

（十三）调试

粗心地使用列表会导致长时间的调试；下面是一些常见的陷阱以及避免的方法：

（1）大多数的列表方法会对参数进行修改，返回None；这个是和字符串相反的，字符串方法大多数保留原始字符串并返回一个新的字符串；

• 对于字符串：

word = word.strip()

• 对于列表：【错误】

t = t.sort()

因为 sort 返回 None ，所以你的下一个对 t 执行的操作很可能会失败

（2）选择一种写法，坚持下去

• 列表的问题是有太多的方法可以做相同的事情，比如删除可以使用pop, del, remove,甚至可以切片操作；
• 要增加一个元素可以使用append或者使用+运算符；

• 下面是正确的

t.append(x)
t = t + [x]
t += [x]

• 下面的是错误的

t.append([x])          # 错误！
t = t.append(x)        # 错误！
t + [x]                # 错误！
t = t + x              # 错误！

（3）通过创建拷贝来避免别名

>>> t = [3, 1, 2]
>>> t2 = t[:]
>>> t2.sort()
>>> t
[3, 1, 2]
>>> t2
[1, 2, 3]

• 上面的例子中还可以使用下面的方法：

>>> t2 = sorted(t)
>>> t
[3, 1, 2]
>>> t2
[1, 2, 3]