第5章 列表

1、列表和字符串的异同

         相同点：集合类型、序列类型

         不同点：列表可以包含其他元素、列表是可变类型

2、创建列表

        (1)构造函数list创建  (2)方括号[]构造

         为了防止和索引操作符混淆，可以查看方括号内的逗号。

>>> # list函数创建
>>> a=list('Hello')  # 参数可以是字符串，也可以是下章要说的元组
>>> a
['H', 'e', 'l', 'l', 'o']
>>> 
>>> # []创建
>>> b=[1,2,'a',3.14159]
>>> b
[1, 2, 'a', 3.14159]
>>> c=[[1,2,3],['a','b','c']]  # 二维列表
>>> c
[[1, 2, 3], ['a', 'b', 'c']]
>>> 
>>> # 空列表
>>> []
[]

3、索引和分片

        与字符串类似。

    3.1一维列表

>>> myList=[1,'a',3.14159,True]
>>> myList[1]
'a'
>>> myList[-1]
True
>>> myList[:3]
[1, 'a', 3.14159]

    3.2二维列表

>>> a=[[1,3,5],['x','a','n'],[2,'b',3.5]]
>>> a[1]
['x', 'a', 'n']
>>> a[1][2]
'n'
>>> a[0][-1]
5

4、运算符

        在列表上使用加法（+）和乘（*）运算符，得到的结果与在字符串上使用类似。

        比较操作也与字符串类似，从第一个元素开始进行，相同则比较下一个，直到两个元素不同为止。

        运算符in和在字符串中的作用一样，用来检测成员。

>>> myList=[1,2,3]
>>> yourList=['a','b','c']
>>> concatList=myList+yourList
>>> concatList
[1, 2, 3, 'a', 'b', 'c']
>>> 
>>> repList1=myList*3
>>> repList1
[1, 2, 3, 1, 2, 3, 1, 2, 3]
>>> repList2=3*myList
>>> repList2
[1, 2, 3, 1, 2, 3, 1, 2, 3]
>>> 
>>> [1,2,3,4]<[1,2,3,0]
False
>>> [1,2,3,4]<[1,2,3,4,0]
True
>>> 
>>> 1 in myList
True
>>> 1 in yourList
False

5、列表函数

        (1)len（C）返回集合C的长度，即元素的数量

>>> C=[1,2,['a','b']]
>>> len(C)
3

        (2)min（C）返回集合C中的最小元素。如果参数是列表的列表，则只考虑每个列表中的第一个元素。集合C中的元素全是单个元素或全是列表，不能出现混合，否则没意义。

>>> C=[1,3,4,2]
>>> min(C)
1
>>> C=[[2,3],[3,5],[1,2]]
>>> min(C)
[1, 2]
>>> C=[3,2,[1,5],4]
>>> min(C)
2

        (3)max（C）返回集合C中的最大元素。如果参数是列表的列表，则只考虑每个列表中的第一个元素。与min（C）类似。

        (4)sum（L）返回列表L中所有元素总和，元素必须为数字。L中的元素必须是单个元素，不能是列表。

>>> L=[1,2,3,4]
>>> sum(L)
10

6、列表可变性

        字符串不能将特定索引位置的字符变为其他字符。

        列表则相反，是可以改变的。可以创建列表，然后改变特定索引位置的元素。

        可以改变单个元素，也可以一次性改变整个列表（多个元素）分片。唯一需要注意的是，所添加的值必须是集合类型。

        个人总结：改变单个元素，用一般的值赋值即可；改变整个列表（多个元素）则要用集合类型赋值。

>>> myList=[1,2,'a','z']
>>> myList[0]=True
>>> myList
[True, 2, 'a', 'z']
>>> myList[:2]=[27]  # 改变前两个元素为一个元素
>>> myList
[27, 'a', 'z']
>>> myList[:]=[1,2,3,4]  # 改变整个列表
>>> myList
[1, 2, 3, 4]
>>> myList[2:]="abc"  # 改变后两个元素
>>> myList
[1, 2, 'a', 'b', 'c']
>>> myList[:2]=15  # only an iterable

Traceback (most recent call last):
  File "<pyshell#9>", line 1, in <module>
    myList[:2]=15  # only an iterable
TypeError: can only assign an iterable

        由于列表是可变的，可以使用del语句在原处删除某项、某片段或整个列表。

>>> myList=[1,'a',3.14159,True]
>>> del myList[1] # 删除索引为1的元素
>>> myList
[1, 3.14159, True]
>>> del myList[1:] #　删除索引从１开始的片段
>>> myList
[1]
>>> del myList  # 删除整个列表
>>> myList

Traceback (most recent call last):
  File "<pyshell#6>", line 1, in <module>
    myList
NameError: name 'myList' is not defined

7、列表方法

        (1)不修改列表的方法

        index（x）返回列表中与x值相等的第一个元素的索引。找不到则报错

        count（x）返回列表中x出现的次数。如果列表中不包含x，返回0。

        (2)修改列表的方法

        append（x）在列表的末尾添加元素。集合也可以作为单个元素进行添加。

        pop（）删除列表末尾的元素，并返回此元素。如果指定索引值，则a.pop(anindex)将删除该索引位置的元素并返回该项。

        extend（C）需要一个集合作为参数。将此参数集合中的每个元素添加到列表的末尾，从而扩展列表。

        insert（i，x）在指定位置插入元素。第一个参数是元素的索引（元素插入前的索引）。

        remove（x）删除列表中第一个值为x的元素。如果没有对应的项，将出错。

        sort（）将列表中元素进行排序。如果要对列表的列表排序，则只考虑每个列表的首元素。

        reverse（）将列表中的元素反向排列。

>>> aList=[1,12,5,8]
>>> aList.append(17)  # 列表末尾添加元素17
>>> aList
[1, 12, 5, 8, 17]
>>> anotherList=[20,2]
>>> aList.extend(anotherList)  # 添加列表anotherList中的每个元素到列表aList中
>>> aList
[1, 12, 5, 8, 17, 20, 2]
>>> aList.insert(3,'a')  # 在列表中索引为3的地方插入字符a，后面的元素一次后移
>>> aList
[1, 12, 5, 'a', 8, 17, 20, 2]
>>> aList.remove(8)  # 删除列表中第一个值为8的元素
>>> aList
[1, 12, 5, 'a', 17, 20, 2]
>>> aList.pop() # 删除列表末尾的元素，并返回此元素
2
>>> aList
[1, 12, 5, 'a', 17, 20]
>>> aList.index(17)  # 返回列表中与值17相等的第一个元素的索引
4
>>> aList.count(5)  # 返回列表中5出现的次数
1
>>> aList.sort()  #　升序
>>> aList
[1, 5, 12, 17, 20, 'a']
>>> aList.reverse()  # 降序
>>> aList
['a', 20, 17, 12, 5, 1]

8、range、split和多重赋值

>>> result="this is a test".split() # 字符串分裂成列表(split函数默认为空格分割)
>>> result
['this', 'is', 'a', 'test']
>>> rangeList=range(-5,5) # range函数生成列表
>>> rangeList
[-5, -4, -3, -2, -1, 0, 1, 2, 3, 4]
>>> element1,element2,element3=[1,2,3] # 使用列表实现多重赋值
>>> element1
1
>>> element2
2
>>> element3
3
>>> field1,field2,field3="python is great".split()
>>> field1
'python'
>>> field2
'is'
>>> field3
'great'

9、使用join在列表和字符串之间转换

        join方法以字符串列表作为参数，并作为分隔符使用主调对象，将每个元素放置到新的字符串中。

>>> ":".join(['a','b','c'])  # 冒号作为分隔符
'a:b:c'
>>> "".join(['a','b','c'])  # 无分隔符
'abc'

10、sorted函数

        sort方法只能应用于列表上，如果要对字符串排序还要进行和列表之间的转换。

        sorted函数（不是方法，而是函数）将对任意集合类型进行排序。

>>> myList=[27,56,4,16]
>>> sorted(myList)
[4, 16, 27, 56]
>>> myStr="Hi mom"
>>> sorted(myStr)
[' ', 'H', 'i', 'm', 'm', 'o']

11、可变对象及其引用

        列表是可变的，列表内容能修改。下面复述以下几点：

        (1)变量名关联有值时才存在，如：x=5

        (2)变量名没有关联到特定的类型

        (3)变量创建后即与特定的Python对象相关联（对象具有类型）

        (4)Python维护命名空间，其中变量名与对象关联

        变量名“引用”对象，在Python中，引用是用命名空间来实现的，命名空间维护变量和对象之间的引用关系。

        接下来用图示方式给出例子。

        不可变对象：

 

        接下来考虑可变对象的操作有什么不同之处：

>>> list1=[1,2,3]
>>> list1
[1, 2, 3]
>>> list2=list1
>>> list2
[1, 2, 3]
>>> list1 is list2  # 引用同一对象
True
>>> list1.append(27)
>>> list1
[1, 2, 3, 27]
>>> list2  # list2也跟着改变
[1, 2, 3, 27]

        如果希望复制列表，可以采用字符串分片（[:]，从头到尾复制）。复制分片是创建列表的副本。明确地说，创建副本意味着Python将创建一个新的对象副本，因此这种修改不会影响其他对象。

>>> list1=[1,2,3]
>>> list1
[1, 2, 3]
>>> list2=list1[:]  # 字符串分片复制
>>> list2
[1, 2, 3]
>>> list1 is list2  # 不是引用同一对象
False
>>> list1.append(27)
>>> list1
[1, 2, 3, 27]
>>> list2  # list2不跟着改变
[1, 2, 3]

         当列表自身作为一个元素进行追加时，将出现无穷递归的情况。所以对自身的引用置于列表的末尾。这意味着该列表无限次重复引用自身。

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

        深拷贝与浅拷贝：

        拷贝意味着什么？在Python，拷贝就是为对象添加新的名字。

>>> list1=[1,2,3]
>>> list2=[5,6,7]
>>> list1.append(list2)
>>> list1
[1, 2, 3, [5, 6, 7]]
>>> list3=list2
>>> list3
[5, 6, 7]
>>> list2 is list3
True
>>> list3[2]=88
>>> list3
[5, 6, 88]
>>> list2
[5, 6, 88]
>>> list1  # list1跟着变化
[1, 2, 3, [5, 6, 88]]

        解释：

        浅拷贝：只复制引用，不复制对象本身的情况

        深拷贝：要复制内容，而不是简单复制引用

        可变与不可变：

        再次考虑对可变对象操作带来的后果。当变量引用不可变对象时，使用该变量的任何操作（连接、替换、去除等）都将创建新对象，而不会改变引用的对象。与此相反，变量引用可变对象时，或者可能创建新的对象，或者改变被引用的对象本身，这取决于进行的是何种操作。如，L=[1,2,3]，L=L+[9]和L.append（9）得到的结果都是列表[1,2,3,9]。然而，前面创建了一个新对象，后者却没有。

12、列表解析

        列表解析是用紧凑的方式来构造列表。它起源于数学集合符号。列表解析至少需要包含两个部分，但三个部分是比较常见的：

[expression for-clausecondition]

        (1)例如，要得到0—20的偶数列表，可以使用range来生成0—20的数字，然后检查用2除的余数部分（i%2==0），以判定数字是否为偶数。再将每个满足条件的元素收集到列表中。

>>> [i for i in range(20) if i%2==0]
[0, 2, 4, 6, 8, 10, 12, 14, 16, 18]

        当然，该技术不仅限于数字。接下来创建单词中所包含的元音列表，如下所示：

>>> word="solidarity"
>>> vowels="aeiou"  # 元音字母组成的字符串
>>> [v for v in word if v in vowels]
['o', 'i', 'a', 'i']

        (2)还可以从多个序列中，采用复杂条件来得到列表。例如，假设要生成的数字对（认为是笛卡尔坐标对），x在0—3的范围内，y在0-4的范围内，仅当x>y。通过限制x为偶数可以进一步限制数字对。

>>> [(x,y) for x in range(3) for y in range(4) if x>y]
[(1, 0), (2, 0), (2, 1)]
>>> [(x,y) for x in range(3) for y in range(4) if x>y and x%2==0] # 限制x为偶数
[(2, 0), (2, 1)]

        (3)列表解析能用于转换。例如，对于包含字母和数字的字符串，希望得到只有数字的列表，需要将其中的字符数字转换为整数，而忽略掉所有的字母。可以如下所示的方法实现。

>>> someString="John Doe,874 Main Sr.,East Lansing,MI,48823"
>>> [int(c) for c in someString if c.isdigit()]
[8, 7, 4, 4, 8, 8, 2, 3]

        列表解析的完整规则是：表达式后跟for从句，然后跟0或多个if或for从句。

 

 

参考文献：

1、《Python入门经典》