列表

Python 序列

序列是Python中最基本的数据结构。序列中的每个元素都分配一个数字 - 它的位置，或索引，第一个索引是0，第二个索引是1，依此类推。序列都可以进行的操作包括索引，切片，加，乘，检查成员。
此外，Python已经内置确定序列的长度以及确定最大和最小的元素的方法。列表是最常用的Python数据类型，它可以作为一个方括号内的逗号分隔值出现。列表的数据项不需要具有相同的类型创建一个列表，只要把逗号分隔的不同的数据项使用方括号括起来即可。如下所示：

list1 = ['java','C','C++','Python']

列表元素的查看

Python中列表的正数索引是从0开始（表示第一个元素），之后是往后递加，负数索引是-1（最后一个元素），往前递减。若超出列表中定义的索引则报IndexError错误。

In [10]: list[1]
Out[10]: 'C'

In [11]: list[-1]
Out[11]: 'Python'

列表元素的修改

In [13]: list
Out[13]: ['java', 'C', 'C++', 'Python']

In [14]: list[0]='PHP'

In [15]: list
Out[15]: ['PHP', 'C', 'C++', 'Python']

同理索引也可以使用负数，同时在修改元素时不管使用正数或负数索引一旦超过索引的范围也会出现IndexError的错误。

列表的方法

列表元素的添加

append方法

append() 方法用于在列表末尾添加新的对象。

In [22]: list.append('java')

In [23]: list
Out[23]: ['PHP', 'C', 'C++', 'Python', 'java']

append是在列表的最后增加指定的元素，若想在指定的位置添加元素需要使用insert方法。append的方法的返回值是None。

insert方法

insert() 函数用于将指定对象插入列表的指定位置。

In [24]: list.insert(2,'C#')

In [25]: list
Out[25]: ['PHP', 'C', 'C#', 'C++', 'Python', 'java']

In [26]: list.insert(22222,'JavaScirpt')

In [27]: list
Out[27]: ['PHP', 'C', 'C#', 'C++', 'Python', 'java', 'JavaScirpt']

insert方法中若操作的索引超出范围，如果是正索引等效于append，如果是负索引，则等效于insert(0, object)

extend方法

extend() 函数用于在列表末尾一次性追加另一个序列中的多个值（用新列表扩展原来的列表）。

In [28]: list.extend(['Perl','Ruby'])

In [29]: list
Out[29]: ['PHP', 'C', 'C#', 'C++', 'Python', 'java', 'JavaScirpt', 'Perl', 'Ruby']

批量在列表最后一个元素添加。

列表元素的删除

pop方法

pop() 函数用于移除列表中的一个元素（默认最后一个元素），并且返回该元素的值。

In [30]: list.pop()
Out[30]: 'Ruby'

In [32]: list
Out[32]: ['PHP', 'C', 'C#', 'C++', 'Python', 'java', 'JavaScirpt', 'Perl']

pop后不加索引则删除列表最后一个元素，同时也可以删除指定索引下标的元素，若删除的索引下标超出了列表的范围则会抛出IndexError错误。

remove方法

remove() 函数用于移除列表中某个值的第一个匹配项。

In [38]: list.append('Python')

In [39]: list
Out[39]: ['PHP', 'C', 'C#', 'C++', 'Python', 'java', 'JavaScirpt', 'Perl', 'Python']

In [42]: list.remove('Python')

In [43]: list
Out[43]: ['PHP', 'C', 'C#', 'C++', 'java', 'JavaScirpt', 'Perl', 'Python']

虽然pop和remove都有删除的功能，但是两者还是有一定的区别的。pop 是弹出索引对应的值，remove是删除最左边的一个值。pop针对的是索引，remove针对的是值 。
列表元素的删除除了上面两种方法以外还可以使用del函数进行删除，下面是使用举例。

In [49]: del list[-1]

In [50]: list
Out[50]: ['PHP', 'C', 'C#', 'C++', 'java', 'JavaScirpt', 'Perl']

clear方法

In [54]: list.clear()

In [55]: list
Out[55]: []

使用clear是删除列表中所有的元素，请谨慎使用。

列表元素的查找/统计

index方法

index() 函数用于从列表中找出某个值第一个匹配项的索引位置。

In [33]: list
Out[33]: ['PHP', 'Python', 'C', 'C#', 'C++', 'java', 'JavaScirpt', 'Perl', 'Python']

In [34]: list.index('Python')
Out[34]: 1

In [35]: list.index('Python',1)
Out[35]: 1

In [36]: list.index('Python',2)
Out[36]: 8

In [41]: list.index('Python',2,10)
Out[41]: 8

通过上面的例子看出直接查找元素所对应的索引很容易理解，但是要是在指定的索引位置查找需要说明一下：若后面只是一个数字则以此数字为第一个索引进行查询，返回从此索引之后最近的一个匹配元素索引的索引值。若没有则返回ValueError 的错误。同时我们还可以指定区间，例如list('example',start,stop)，则表示包含start，不包含stop的元素。

count

count() 方法用于统计某个元素在列表中出现的次数。

In [44]: list.count('Python')
Out[44]: 2

In [45]: list.count('C')
Out[45]: 1

In [46]: list.count('c')
Out[46]: 0

count方法是统计元素在列表出现的次数，若统计的元素在列表中没有出现则输出是0.

列表元素的修改

sort

sort() 函数用于对原列表进行排序，如果指定参数，则使用比较函数指定的比较函数。

In [49]: list
Out[49]: ['PHP', 'Python', 'C', 'C#', 'C++', 'java', 'JavaScirpt', 'Perl', 'Python']

In [50]: list.sort()

In [51]: list
Out[51]: ['C', 'C#', 'C++', 'JavaScirpt', 'PHP', 'Perl', 'Python', 'Python', 'java']

In [53]: list.sort(reverse=True)

In [54]: list
Out[54]: ['java', 'Python', 'Python', 'Perl', 'PHP', 'JavaScirpt', 'C++', 'C#', 'C']

通过sort可以以ASCII码进行正序排序，若想倒序可以用reverse=True参数。

reverse

reverse() 函数用于反向列表中元素。

In [76]: list
Out[76]: ['java', 'Python', 'Python', 'Perl', 'PHP', 'JavaScirpt', 'C++', 'C#', 'C']

In [77]: list.reverse()

In [78]: list
Out[78]: ['C', 'C#', 'C++', 'JavaScirpt', 'PHP', 'Perl', 'Python', 'Python', 'java']

In [79]: list.reverse()

In [80]: list
Out[80]: ['java', 'Python', 'Python', 'Perl', 'PHP', 'JavaScirpt', 'C++', 'C#', 'C']

reverse只是反向修改列表的内容，并不进行排序，这个需要注意。

其他方法

copy

In [87]: lst = [2,4,5,2,4,5]

In [88]: lst2 = lst

In [89]: lst2.remove(2)

In [90]: lst2
Out[90]: [4, 5, 2, 4, 5]

In [91]: lst
Out[91]: [4, 5, 2, 4, 5]

In [92]: id(lst)
Out[92]: 140691016809864

In [93]: id(lst2)
Out[93]: 140691016809864

直接通过赋值的方法将列表的值复制到新列表中这么操作由于两个指向同一个内存所以两者其实就像是Linux系统中硬链接一样。若想得到不同的内存空间可以使用copy方法。

In [99]: lst
Out[99]: [4, 5, 2, 4, 5]

In [100]: lst3 = lst.copy()

In [101]: lst3
Out[101]: [4, 5, 2, 4, 5]

In [102]: lst3.remove(5)

In [103]: lst3
Out[103]: [4, 2, 4, 5]

In [104]: lst
Out[104]: [4, 5, 2, 4, 5]

In [105]: id(lst3)
Out[105]: 140691016808904

In [106]: id(lst)
Out[106]: 140691016809864

列表函数

len()

len() 方法返回列表元素个数。

In [116]: list
Out[116]: ['java', 'Python', 'Perl', 'PHP', 'JavaScirpt', 'Python', 'C++', 'C#']

In [117]: len(list)
Out[117]: 8

max()

max() 方法返回列表元素中的最大值。

In [118]: max(list)
Out[118]: 'java'

min()

min() 方法返回列表元素中的最小值。

In [119]: min(list)
Out[119]: 'C#'

列表的切片

常规使用

Python的切片非常灵活，使用的格式是lst[start:end:step]，其中start是起始的索引，包含此索引的元素，end是最后一个索引，不包含此元素，step是跳过的索引下标。下面就具体使用进行举例：

In [2]: lst1
Out[2]: [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]

In [3]: lst1[2:5]
Out[3]: [2, 3, 4]

In [4]: lst1[5:2]
Out[4]: []

In [5]: lst1[-4:-2]
Out[5]: [6, 7]

In [6]: lst1[-2:-4]
Out[6]: []

上面可以看出step是可以省略的，默认是1，同时若从左往右切片， start要小于end。若start大于end则返回一个空列表。

In [7]: lst1[4:2222]
Out[7]: [4, 5, 6, 7, 8, 9]

In [8]: lst1[-11111:2]
Out[8]: [0, 1]

In [9]: lst1[-11111:222222]
Out[9]: [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]

In [10]: lst1[-11111:]
Out[10]: [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]

In [11]: lst1[:22222]
Out[11]: [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]

In [12]: lst1[:]
Out[12]: [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]

In [13]: lst1[4:len(lst1)]
Out[13]: [4, 5, 6, 7, 8, 9]

从上面可以看出，start 超出索引范围从0开始，end 超出索引范围到len(lst) 结束。同时省略start则索引也是从0开始，省略end则索引到en(lst) 结束。若全部省略则返回整个列表。

In [15]: lst1[2:10:2]
Out[15]: [2, 4, 6, 8]

In [18]: lst1[-2:-10:-2]
Out[18]: [8, 6, 4, 2]

当step是正数时从前往后数则start小于end，当step是负数时候从后往前数则start大于end。否则会返回空列表。

In [32]: lst1
Out[32]: [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]

In [33]: lst1[::2]
Out[33]: [0, 2, 4, 6, 8]

In [34]: lst1[::-2]
Out[34]: [9, 7, 5, 3, 1]

In [36]: lst1[2::-2]
Out[36]: [2, 0]

In [37]: lst1[:2:-2]
Out[37]: [9, 7, 5, 3]

上面是通过省略start、end、step中任意一个得到的结果，可以发现切片使用很灵活，需要多练习才能掌握好这个强大的功能。

深入学习

In [55]: lst1
Out[55]: [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]

In [56]: lst1[::2][::-1]
Out[56]: [8, 6, 4, 2, 0]

上面过对切片后的列表在进行一次切片也是一个小技巧。

In [61]: lst1
Out[61]: [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]

In [62]: lst1[3:5]=['x','y']

In [63]: lst1
Out[63]: [0, 1, 2, 'x', 'y', 5, 6, 7, 8, 9]

In [64]: lst1=list(range(0,10))

In [66]: lst1[3:5]=['x','y','z']

In [67]: lst1
Out[67]: [0, 1, 2, 'x', 'y', 'z', 5, 6, 7, 8, 9]

In [68]: lst1=list(range(0,10))

In [69]: lst1[3:5]=['x']

In [70]: lst1
Out[70]: [0, 1, 2, 'x', 5, 6, 7, 8, 9]

对切片复制，会替换切片原来的元素。

In [73]: lst1
Out[73]: [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]

In [74]: lst1[3:7:2]
Out[74]: [3, 5]

In [76]: lst1[3:7:2]=['x','y']

In [77]: lst1
Out[77]: [0, 1, 2, 'x', 4, 'y', 6, 7, 8, 9]

对于切片后连续的元素我们进行赋值时没有强制的语法，而多切片后的元素不是连续的则我们进行赋值时赋值的个数必须和切片后的元素个数一致，若不一致则报ValueError的错误。

列表的封包和解包

In [1]: head,*tail=list(range(0,10))

In [2]: head
Out[2]: 0

In [3]: tail
Out[3]: [1, 2, 3, 4, 5, 6, 7, 8, 9]

上面是基本的解包操作，head是取得第一个元素，剩下的元素全部分给tail。

In [12]: head,*tail=[2]

In [13]: tail
Out[13]: []

我们的解包变量有两个而列表中数据只有一个的时候，第二个会是一个空列表。

In [16]: head,*min,tail=list(range(0,10))

In [17]: min
Out[17]: [1, 2, 3, 4, 5, 6, 7, 8]

例子。

In [20]: lst1
Out[20]: [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]

In [21]: a,b,_,_,c,*_,d=lst1

In [22]: a
Out[22]: 0

In [23]: b
Out[23]: 1

In [24]: c
Out[24]: 4

In [25]: d
Out[25]: 9

_符号是丢弃一个元素，而*_符号是丢弃多个元素。

In [28]: lst2=[1,[2,3,4,5],6]

In [29]: _,(a,*_,c),d=lst2

In [30]: a
Out[30]: 2

In [31]: c
Out[31]: 5

In [32]: d
Out[32]: 6

In [42]: lst3=(1,2,[3,4,5],6,7)

In [43]: _,a,(b,*_,),*_,c=lst3

In [44]: a
Out[44]: 2

In [45]: b
Out[45]: 3

In [46]: c

针对复杂的列表我们也可以解包进行操作。

列表的成员运算

通过下面的一个例子说明一下列表成员运算符的使用：

In [41]: lst2
Out[41]: [3, 4, 5, 3, 6, 3, 4, 8, 5]

In [42]: new_list=[]

In [44]: for i in lst2:
                if i not in new_list:
                    new_list.append(i)

In [45]: new_list
Out[45]: [3, 4, 5, 6, 8]

In [48]: 2 in lst2
Out[48]: False

In [49]: 3 in lst2
Out[49]: True

通过上面的例子可以将一个列表中重复的元素给去除，注意if 语句中使用的in是成员运算，而for 语句中的in 不是成员运算。同是成员运算取得的结果是布尔值这个需要注意。