Python 列表

　　1，list函数

　　因为字符串不能像列表一样被修改，所以有时候根据字符串创建列表会很有用。list函数可以实现这个操作：

In [1]: list('Hello')
Out[1]: ['H', 'e', 'l', 'l', 'o']

　　提示：可以用''.join(somelist)将一个由字符组成的列表转换为字符串。注意是字符。可以用str()函数转换成字符。

　　2，基本的列表操作

　　　　（1）、改变列表：元素赋值

　　　　　　改变列表很容易。但我们并不会用x=2这样的语句进行赋值，而是使用索引标记来为某个特定的、位置明确的元素赋值，如x[1]=2。

In [2]: x = [1, 1, 1]

In [3]: x[1]=2

In [4]: x
Out[4]: [1, 2, 1]

　　　　　　注意：不能为一个位置不存在的元素进行赋值。如果的列表长度为2,那么不能为索引为100的元素进行赋值。如果要那样做，就必须创建一个长度为101（或者更长）的列表。

　　　　（2）、删除元素

　　　　　　用del语句即可。

　　　　（3）、分片赋值

　　　　　　分片是一个非常强大的特性，分片赋值操作则更加显现它的强大。

In [5]: name = list('Perl')

In [6]: name
Out[6]: ['P', 'e', 'r', 'l']

In [7]: name[2:] = list('ar')

In [8]: name
Out[8]: ['P', 'e', 'a', 'r']

　　　　　　使用分片赋值是，还可以使用与原序列不等长的序列将分片替换：

In [9]: name = list('Perl')

In [10]: name[1:] = list('ython')

In [11]: name
Out[11]: ['P', 'y', 't', 'h', 'o', 'n']

　　　　　　分片赋值语句可以在不需要替换任何原有元素的情况下插入新的元素：

In [12]: numbers = [1,5]

In [13]: numbers[1:1] = [2,3,4]

In [14]: numbers
Out[14]: [1, 2, 3, 4, 5]

　　　　　　这个程序只是“替换”了一个空的分片，因此实际上的操作是插入了一个序列。以此类推，通过分片赋值来删除元素也是可行的。

In [17]: numbers[1:4]=[]

In [18]: numbers
Out[18]: [1, 5]

In [19]: 

　　3，列表方法

　　　　（1）、append

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

In [19]: lst = [1,2,3]

In [20]: lst.append(4)

In [21]: lst
Out[21]: [1, 2, 3, 4]

　　　　（2）、count

　　　　　　count方法统计某个元素在列表中出现的次数：

In [22]: ['to','be','or','not','to','be'].count('to')
Out[22]: 2

　　　　（3）、extend

　　　　　　extend方法可以在列表的末尾一次性追加另一个序列中的多个值。换句话说，可以用新列表扩展原有的列表：

In [23]: a = [1,2,3]

In [24]: b = [4,5,6]

In [25]: a.extend(b)

In [26]: a
Out[26]: [1, 2, 3, 4, 5, 6]

　　　　　　这个操作看起来很像连接操作，两者最主要区别在于：extend方法修改了扩展的序列（在这个例子中，就是a）。而原始的连接操作则不然，它会返回一个全新的列表：

In [27]: a = [1,2,3]

In [28]: b = [4,5,6]

In [29]: a+b
Out[29]: [1, 2, 3, 4, 5, 6]

In [30]: a
Out[30]: [1, 2, 3]

　　　　　　可以看到被连接的列表与之前例子中被扩展的列表是一样的，但是这一次它并没有被修改。这是因为原始的连接操作创建了一个包含了a和b的副本的新列表。如果使用a=a+b这样的操作，效率会比extend方法低。当然也可以用分片赋值来实现相同的效果。

　　　　（4）、index

　　　　　　index方法用于从列表中找出某个值第一个匹配项的索引位置。当没有找到时会因为一个ValueError异常。

　　　　（5）、insert

　　　　　　insert方法用于将对象插入到列表中：

In [31]: numbers = [1,2,3,5,6,7]

In [32]: numbers.insert(3,'four')

In [33]: numbers
Out[33]: [1, 2, 3, 'four', 5, 6, 7]

　　　　　　与extend方法一样，insert方法也可以用分片赋值来实现。

In [34]: numbers = [1,2,3,5,6,7]

In [35]: numbers[3:3] = 'four'

In [36]: numbers
Out[36]: [1, 2, 3, 'f', 'o', 'u', 'r', 5, 6, 7]

　　　　（6）、pop

　　　　　　pop方法会移除列表中的一个元素（默认是最后一个），并且返回该元素的值：

In [37]: x = [1,2,3]

In [39]: x.pop()
Out[39]: 3

  In [40]: x.pop(0)
  Out[40]: 1

　　　　　　注意：pop方法是唯一一个既能修改列表又返回元素值（除了None）的列表方法。

　　　　　　使用pop方法可以实现栈。入栈可以用append方法。如果要实现队列的话，要用pop(0)来代替pop()

　　　　（6）、remove

　　　　　　remove方法用于移除列表中某个值的第一个匹配项。

　　　　（7）、reverse

　　　　　　reverse方法将列表中的元素反向存放。

　　　　（8）、sort

　　　　　　sort方法用于在原位置对列表进行排序。在“原位置排序”意味着改变原来的列表，从而让其中的元素能按一定的顺序排列，而不是简单地返回一个已排序的列表副本。

In [41]: x = [4,6,3,1,5]

In [42]: x.sort()

In [43]: x
Out[43]: [1, 3, 4, 5, 6]

　　　　　　当需要一个排好序的列表副本，同时又保留原有列表不变的时候，问题就出现了。为了实现这个功能，我们自然而然就想到了如下的做法（实际上是错误的）：

In [44]: x = [4,6,3,1,5]

In [45]: y = x.sort() #Don't do this

In [46]: print y
None

　　　　　　因为sort方法修改了x却返回了空值，那么最后得到的是已排序的x以及值为None的y。实现这个功能的正确方法是先把x的副本赋值给y，然后对y排序。

In [47]: x = [4,6,3,1,5]

In [48]: y = x[:]

In [49]: y.sort()

In [50]: y
Out[50]: [1, 3, 4, 5, 6]

In [51]: x
Out[51]: [4, 6, 3, 1, 5]

　　　　　　调用x[:]得到的是包含了x所有元素的分片，这是一种很有效率的复制整个列表的方法。不要用y=x这样的赋值方式，因为这样做就让x和y都指向同一个列表了。

In [52]: x = [4,6,3,1,5]

In [53]: y = x

In [54]: y.sort()

In [55]: y
Out[55]: [1, 3, 4, 5, 6]

In [56]: x
Out[56]: [1, 3, 4, 5, 6]

　　　　　　另一种获取已排列的列表副本的方法是，使用sorted函数

In [52]: x = [4,6,3,1,5]

In [59]: y = sorted(x)

In [60]: y
Out[60]: [1, 3, 4, 5, 6]

In [61]: x
Out[61]: [4, 6, 3, 1, 5]

　　　　　　　这个函数可以用于任何序列/，却总返回一个列表。

In [62]: sorted('Python')
Out[62]: ['P', 'h', 'n', 'o', 't', 'y']　　

　　　　（10）、高级排序

　　　　　　如果希望元素能按照特定的方式进行排序，那么可以通过compare(x,y)的形式自定义比较函数。compare(x,y)函数会在x < y时返回负数，在x > y时返回正数，如果x == y则返回0。定义好该函数后，就可以提供给sort方法做为参数了。内建cmp函数提供比较函数的实现方式。下面演示降序排列。

In [63]: def compare(x, y):
   ....:     if x > y: return -1
   ....:     if x < y: return 1
   ....:     if x == y: return 0
   ....: 

In [64]: x = [4, 6 ,3, 1, 5]

In [65]: x.sort(compare)

In [66]: x
Out[66]: [6, 5, 4, 3, 1]

　　　　　　sort方法有另外两个可选的参数——key和reverse。如果要使用它们，那么要通过名字来指定（关键字参数）。参数key与cmp类似——必须提供一个在排序过程中使用的函数。然而，该函数并不是直接用来确定对象大小，而是为每个元素创建一个键，然后所有元素根据键来排序。因此，如果要根据元素的长度来进行排序，那么可以使用len作为键函数：

In [67]: x = ['aardvark','abalone','acme','add','aerate']

In [68]: x.sort(key=len)

In [69]: x
Out[69]: ['add', 'acme', 'aerate', 'abalone', 'aardvark']

　　　　　　另一个关键字参数reverse是简单的布尔值（True或False）用来指明列表是否要进行反向排序：

In [70]: x = [4,6,3,1,5]

In [71]: x.sort(reverse=True)

In [72]: x
Out[72]: [6, 5, 4, 3, 1]

　　　　　　cmp，key，reverse参数都可以用于sorted函数。大多数情况下，为cmp或key提供自定义函数是非常有用的。