Python 列表

列表

列表是python中最具灵活性的有序集合对象类型。

主要属性

• 任意对象的有序集合
• 通过便宜读取
• 可变长度，异构以及任意嵌套
• 属于可变序列的分类              序列操作在列表与字符串中的工作方式相同。唯一区别是：当应用于字符串上的合并和分片这样的操作应用于列表时，返回新的列表。
• 对象引用数组               

常用操作

在制定位置插入元素

>>> l = [1, 2, 3, 4]
>>> l.insert(1,2)
>>> l
[1, 2, 2, 3, 4]
>>> l.insert(3, 10)
>>> l
[1, 2, 2, 10, 3, 4]
>>> l.insert(3, [1,2])
>>> l
[1, 2, 2, [1, 2], 10, 3, 4]
>>> l.insert(3, 'e')
>>> l
[1, 2, 2, 'e', [1, 2], 10, 3, 4]

找出某一项的位置

>>> l
[1, 2, 2, 'e', [1, 2], 10, 3, 4]
>>> l.index(1)
0
>>> l.index(10)
5
>>> l.index(2)
1

排序

>>> l = [2, 5, 3, 9, 4]
>>> l.sort()
>>> l
[2, 3, 4, 5, 9]

反转

>>> l.reverse()
>>> l
[9, 5, 4, 3, 2]

移除

>>> l.remove(2)
>>> l
[9, 5, 4, 3]

列表解析

>>> list(map(ord, 'spam'))
[115, 112, 97, 109]

 列表的“+”操作和字符串中的一样，然而值得重视的是“+”两边必须是相同类型的序列，否则运行时会出现类型错误。除非，你进行类型转换：

>>> str([1, 2]) + '34'
'[1, 2]34'
>>> [1, 2] + list('34')
[1, 2, '3', '4']

列表迭代和解析

>>> for x in [1, 2, 3]:
    print(x, end = ' ')

    
1 2 3 

内置函数map 对序列中的各项应用一个函数并把结果手机到一个新的额列表中：

>>> list(map(abs, [-1, -2, 0, 1, 2]))
[1, 2, 0, 1, 2]

>>> l = ['spam', 'spam', 'spam']
>>> l[0:2] = ['eat', 'more']
>>> l
['eat', 'more', 'spam']

上一个例子是分片赋值，可以分为两部来理解：

1. 删除。删除等号左边制定的分片。
2. 插入。将包含在等号右边对象中的片段插入旧分片被删除的位置。

这有助于理解为什么插入元素的数目不需要与删除的数目相匹配。

L.append(x) 与L+[x] 的结果类似，不同的是，前者会原地修改L，而后者会生成新的列表。

sort 方法

sort方法是使用Python标准的比较检验作为默认值，而且以递增的顺序进行排序。

我们可以通过传入关键字参数来修改排序行为——这是指定按名称传递的函数调用中特殊的“name=value"语法，常常用来给定配置选项。在排序中，key参数给出了一个耽搁的参数的函数，它返回在排序中使用的值，reverse参数允许排序按照降序而不是升序进行：

>>> L = ['abc', 'ABD', 'aBe']
>>> L.sort()
>>> L
['ABD', 'aBe', 'abc']
>>> L.sort(key = str.lower)               #lower，以最后一个字母为准
>>> L
['abc', 'ABD', 'aBe']
>>> L.sort(key = str.lower, reverse=True)      #reverse=True，倒序

>>> L ['aBe', 'ABD', 'abc']

在Python2.6中，不同类型的对象也是可以进行比较的。——语言在不同类型之中都定义了一个固定的顺序。在Python3.0之后的版本中，不同类型的排序会引发一个异常，不再支持拥有不同类型的内容的列表使用sort().

注意：append和sort原处修改相关的列表对象，而结果并没有返回列表。

一部分原因是这样的限制，排序也在最近的Python中可以作为内置函数使用了，它可以排序任何集合，并且针对结果返回一个新的列表：

>>> L = ['abc', 'ABD', 'aBe']
>>> sorted(L, key = str.lower, reverse = True)
['aBe', 'ABD', 'abc']
>>> L = ['abc', 'ABD', 'aBe']
>>> sorted([x.lower() for x in L], reverse=True)
['abe', 'abd', 'abc']

reverse可原地反转列表，extend和pop 方法分别能够在末端插入多个元素、删除一个元素。也有一个reversed内置函数，像sorted一样工作，但是，它必须包装在一个list调用中，因为它是一个迭代器：

>>> L = [1, 2, 3, 4]
>>> L.reverse()
>>> L
[4, 3, 2, 1]
>>> list(reversed(L))
[1, 2, 3, 4]

在某些类型的应用程序中，往往会把这里用到的列表pop方法和append方法联用，来实现快速的后进后出堆栈结构。列白哦的末端作为堆栈的顶端。

pop方法也能够接受某一个即将删除并返回的元素的偏移（默认值为最后一个元素）。

>>> L = ['spam', 'eggs', 'ham']
>>> L.pop(1)
'eggs'
>>> L
['spam', 'ham']

可以通过将空列表赋值给分片来删除列表片段。

>>> L = [1, 4, 5, 10]
>>> L[1:3] = []
>>> L
[1, 10]

将空列表赋值给一个索引只会在指定的位置存储空列表的引用，而不是删除：

>>> L = [1, 4, 5, 10]
>>> L[1] = []
>>> L
[1, [], 5, 10]

更多方法还是需要参考Python手册、Python的dir和help函数， 《Python Pocket Reference》。