07python列表

这篇文章主要介绍列表的一些知识。

函数list

首先需要说明的是，列表与元组、字符串一样都是一种序列，但不同的是列表是可变的，即可修改其内容。

因为不能像修改列表那样修改字符串，所以有些情况下使用字符串来创建列表很有帮助，函数list可以用来创建列表。

>>> list("hello")
["h", "e", "l", "l", "o"]
>>>
>>> "".join(["h", "e", "l", "l", "o"]) 
"hello"

• 注意，可以将任何序列(而不仅仅是字符串)作为list的参数。
• 字符列表也可以转换为字符串，需要用到关键字join。

基本的列表操作

可对列表执行所有标准序列操作，如索引、切片、拼接、相乘，元素检查等，
但是因为列表是可变的，所以列表还有一些特有的修改元素的操作。

• 修改列表：给元素赋值

修改列表可有使用赋值语句，但是需要结合索引使用：

>>> 
>>> x = [1, 2, 3, 4, 5]  
>>> x[1] = "h" 
>>> x
[1, "h", 3, 4, 5]
>>> 

注意，不能给不存在的元素赋值，即索引不能超出list范围

• 删除元素

从列表中删除元素，使用del语句：

>>> 
>>> names = ["Alice", "Beth", "Cecil", "Dee-Dee", "Earl"]
>>> del names[2]
>>> names
["Alice", "Beth", "Dee-Dee", "Earl"]
>>>

• 给切片赋值

序列的切片是一项极其强大的功能，列表中还能够给切片赋值

>> 
>>> name = list("Perl")
>>> name
["P", "e", "r", "l"]
>>> name[2:] = list("ar")
>>> name
["P", "e", "a", "r"]
>>>
>>> name = list("Perl")
>>> name[1:] = list("python") 
>>> name
["P", "p", "y", "t", "h", "o", "n"]
>>> 
>>> numbers = [1, 5]
>>> numbers[1:1] = [2, 3, 4]
>>> numbers
[1, 2, 3, 4, 5]
>>> numbers[1:4] = []  # 等效于 del numbers[1:4] 
>>> numbers
[1, 5]
>>>

可以同时给多个元素赋值，通过切片赋值；
还可以将切片替换为长度与其不同的序列；
使用切片赋值还可以在不替换原有元素的情况下插入新的元素

列表方法

方法是与对象(列表、数、字符串等)联系紧密的函数，调用方法语法为：object.method(arguments).

• append()

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

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

append只能就地修改列表，并不会返回修改后的新列表，而是直接修改旧列表。

关于命名：

1. 不要与python关键字重复，否则会出现无法调用同名关键字函数的情况
2. 做到“见名知意”，例如列表的名称为prices、prices_of_eggs、pricesOfEgges

• clear()

方法clear就地清空列表的内容。

>>> 
>>> lst = [1, 2, 3]
>>> lst.clear() # 等价于赋值语句 lst[:] = []
>>> lst
[]
>>>

• copy()

方法copy复制列表。

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

常规复制只是将另一个表名关联到列表，例如 b = a , 修改 b 的元素值实际上就是修改 a 的元素值

通过 copy复制是通过将 c 关联到 a 的副本创建一个新的列表，修改 c 的元素值不会影响 a 中元素值。此时类似于 a[:] 或 list(a)

• count()

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

>>> 
>>> ["to", "be", "or", "not", "to", "be"].count("to")
2   
>>> 
>>> x = [[1, 2], 1, 1, [2, 1, [1, 2]]]
>>> x.count(1)
2   
>>> x.count([1, 2])
1   
>>> 

• extend()

方法extend能够同时将多个值添加到列表末尾，为此可以将这些值组成的序列作为参数，即可使用一个列表来拓展另一个列表。

>>> 
>>> a = [1, 2, 3] 
>>> b = [4, 5, 6]
>>> a.extend(b) 
>>> a
[1, 2, 3, 4, 5, 6]
>>> a.extend(7,8,9)
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: list.extend() takes exactly one argument (3 given)
>>>
>>> a = [1, 2, 3] 
>>> b = [4, 5, 6]
>>> a + b
[1, 2, 3, 4, 5, 6]
>>> a
[1, 2, 3]
>>>
>>> a = [1, 2, 3] 
>>> b = [4, 5, 6]   
>>> a = a + b # 使用拼接达到extend的效果，但是效率比较低
>>> a
[1, 2, 3, 4, 5, 6]
>>>
>>> a = [1, 2, 3] 
>>> b = [4, 5, 6]
>>> a[len(a):] = b # 切片实现相同的效果，可行，但是可读性不高
>>> a
[1, 2, 3, 4, 5, 6]
>>>

extend方法的使用类似于拼接，但是重要差别是会修改被拓展的序列，而拼接返回的是一个全新的序列。
拼接的原理是使用a和b的副本创建一个新列表，使用拼接达到相同的效果时，拼接的效率比较低，或者使用切片完成。

• index()

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

>>> 
>>> knights = ["We", "are", "the", "knights", "who", "say", "ni"]
>>> knights.index("who")
4
>>> knights.index("herring")
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
ValueError: "herring" is not in list
>>> knights[4]            
"who"
>>>

• insert()

方法insert用于将一个对象插入列表。

>>> 
>>> numbers = [1, 2, 3, 5, 6, 7]
>>> numbers.insert(3, "four")
>>> numbers
[1, 2, 3, "four", 5, 6, 7]
>>>
>>> numbers = [1, 2, 3, 5, 6, 7]
>>> numbers[3:3] = "four"   # 这里需要注意的是，插入一个字符串类型的元素到列表中需要写成只有该元素的列表，否则会出现多个元素
>>> numbers
[1, 2, 3, "f", "o", "u", "r", 5, 6, 7]
>>> numbers = [1, 2, 3, 5, 6, 7]
>>> numbers[3:3] = ["four"]  # 于extend一样，可以通过切片的方式实现相同的效果，但是可读性依旧不强  
>>> numbers
[1, 2, 3, "four", 5, 6, 7]
>>>

• pop()

方法pop从列表中删除一个元素(默认为最后一个元素)，并返回该元素。

>>> 
>>> x = [1, 2, 3]
>>> x.pop() 
3
>>> x
[1, 2]
>>> y = x.pop(0)
>>> y
1
>>> x
[2]
>>>
>> x = [1, 2, 3]
>>> x.append(x.pop())
>>> x
[1, 2, 3]
>>>
>>> x = [1, 2, 3]
>>> x.insert(0, x.pop())
>>> x
[3, 1, 2]
>>>
>>> x = [1, 2, 3]  
>>> x.append(x.pop(0))
>>> x
[2, 3, 1]
>>>

注意，pop是唯一既可以修改列表又返回一个非None值的列表方法。

使用pop可实现一种常用的数据结构——栈(stack)。栈就像一叠盘子，可以在上面添加盘子，还可以从上面取走盘子。最后加入的盘子最先取走，即后进先出(LIFO=last in first out)。
还有一种与栈对应的数据结构称为——堆(heap)。堆的概念正好与栈相反，最先放入的盘子最先出去，即先进先出(FIFO=first in first out)。队列是一种堆。

push和pop是大家普遍接受的两种栈操作(加入和取走)的名称。Python中没有提供push，可以使用append代替。方法pop和append的效果正好相反。
要创建先进先出(FIFO)的队列，可以使用insert(0,…)代替append。另外也可以使用append，用pop(0)代替pop()。或使用collections模块中的deque。

• remove()

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

>>> 
>>> x = ["to", "be", "or", "not", "to", "be"]
>>> x.remove("be")
>>> x
["to", "or", "not", "to", "be"]
>>> x.remove("bee") 
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
ValueError: list.remove(x): x not in list
>>>

remove无法删除列表中不存在的元素。
remove是就地修改列表且不返回值的方法之一，不同于pop，它修改列表但是不返回任何值。

• reverse()

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

>>> 
>>> x = [1, 2, 3] 
>>> x.reverse()
>>> x
[3, 2, 1]
>>>
>>> x = [1, 2, 3]
>>> y = reversed(x)
>>> y
<list_reverseiterator object at 0x015514D8>
>>> list(y) 
[3, 2, 1]
>>>

注意reverse修改列表，但是不返回任何值(与remove和sort等方法一样)。

如果要按相反的顺序迭代序列，可以使用函数reversed，这个函数返回的结果是一个迭代器。可以使用list转换为列表。

• sort()

方法sort用于对列表就地排序，会对原来的列表进行修改，而不是返回排序后的列表副本。

>>> 
>>> x = [4, 5, 6, 1, 9 ,0 ,3] 
>>> x.sort()
>>> x
[0, 1, 3, 4, 5, 6, 9]
>>>
>>> x = [4, 5, 6, 1, 9 ,0 ,3]
>>> y = x.sort() # 由于sort修改x且不返回任何值，最终的结果是x经过排序的，所以y是None
>>> print(y) 
None
>>>
>>> x = [4, 5, 6, 1, 9 ,0 ,3]
>>> y = x.copy()
>>> y.sort()
>>> x
[4, 5, 6, 1, 9, 0, 3]
>>> y
[0, 1, 3, 4, 5, 6, 9]
>>>
>>> x = [4, 5, 6, 1, 9 ,0 ,3]
>>> y = sorted(x) # 函数sorted()返回排序后的列表
>>> x
[4, 5, 6, 1, 9, 0, 3]
>>> y
[0, 1, 3, 4, 5, 6, 9]
>>>
>>> sorted("Python")  
["P", "h", "n", "o", "t", "y"]
>>>
>>> 
>>> x = [4, 5, 6, 1, 9 ,0 ,3]
>>> x.sort(reverse=True)  # sort支持可选参数reverse：Ture or False
>>> 
>>> x
[9, 6, 5, 4, 3, 1, 0]
>>> 
>>> x = [4, 5, 6, 1, 9 ,0 ,3]
>>> x.sort(reverse=False)  # sort支持可选参数reverse：Ture or False  
>>> x
[0, 1, 3, 4, 5, 6, 9]
>>>
>>> x = ["aardvark", "abalone", "acme", "add", "aerate"]
>>> x.sort(key=len)  # sort支持可选参数key
>>> x
["add", "acme", "aerate", "abalone", "aardvark"]
>>>

函数sorted()的返回值是排序后的列表，注意sort()无返回值。sorted可以用于任何序列，返回的总是一个倒置的列表。

方法sort接受两个可以选参数：key和reverse，称为关键字参数。同样sorted也支持可选参数key和reverse，此处可以将key设置为一个函数很管用。