Python列表

python包含6中内建的序列：列表、元组、字符串、Unicode字符串、buffer对象、xrange对象。序列的元素也可以是一个序列，这六个序列中列表是比较重要的一个，相比较于元组，我们可以修改列表，但是不能修改元组。

下标

列表的下标也是从0开始，但是我们能够从后面开始访问我们的列表，倒数第一个是-1,倒数第二个是-2,以此类推。

myList = [1,2,3,4]
myList[0]   //1
myList[-1]  //4
myList[-2]  //3

分片

分片写法：myList[起始下标：终止下标：步长]，步长可以省略，默认分片步长为1

实际意义：表示从起始下标开始（包括起始下标），往后每隔一个步长提取一个元素，直到到达终止下标（不包括终止下标），然后将提取出来的元素按照提取顺序组成一个列表返回。

步长可以是负数，如果步长是负数，则表示从起始下标开始（包括起始下标），往前每隔一个步长数提取一个元素，直到到达终止下标（不包括终止下标）。

num = [1,2,3,4,5,6,7,8,9,10]
num[0：3] == [1,2,3]      //包括下标为0的元素，但不包括下标为3的元素
num[:3] == [1,2,3]       //缺省起始下标就默认从0开始
num[-3,-1] == [8,9]      //用负数表示下标
num[-3:]  == [8,9,10]    //缺省结束下标就默认直到列表结束位置
num[0:10:2] == [1,3,5,7,9] //我们指定分片步长为2来代替默认的1,这样就会隔一个取值
num[-1::-2] == [10,8,6,4,2] //步长可以是负数

特别注意的是，起始下标不一定要求都是正数或者都是负数，可以一个是正数一个是负数，正负数只是表示具体下标的两种不同表示法。

num[0] == num[-10]
num[0:3] == num[-10:3]

分片复制

列表的分片赋值是非常强大的，它可以使用与原序列不等长的序列将分片替换掉。

name = list("perl")
name[1:] = list("ython")
name的值现在为['p', 'y', 't', 'h', 'o', 'n']

我们可以利用这个功能来实现元素的删除(功能类似与del name[1:3])：

name = list("abcde")
name[1,3] = []
name的值为['a','b','c']

还可以在不替换任何值的情况下插入一些值：

name = list("ab")
name[1:1] = [1,2,3]
name的值为['a', 1, 2, 3, 'b']

复制整一个列表到另外一个列表中，可以用以下方法，这样得到的y是x的一个副本，改变y的值不会影响x。

y = x[:]

如果直接写y = x,那么x和y指向的是同一个列表，改变其中一个的值，另外一个会随之而改变。

连接

两个列表可以用’+’操作符进行连接，但是不同的序列是不可以进行连接的，比如说列表不能和字符串进行连接

[1,2,3] + [4,5,6] == [1,2,3,4,5,6]
[1,2,3] + "str"     //error

乘法

列表还可以相乘，真是个神奇的东西。

num = [1,2]
num * 2 == [1,2,1,2]

如果我们想创建一个空的列表，但是它又要占领空间，那么我们可以用None，它是python的内建值，确切的说就是什么都没有的意思。

num = [None]
num *= 10
num == [None, None, None, None, None, None, None, None, None, None]

检查成员

判断一个元素是否在序列中，我们可以用 in 操作符。

num = [1,2]
1 in num        //true

in 也可以用来检测一个字符串是否是另一个字符串的子串。

myStr = "abcdef"
"bc" in myStr   //true

长度、最大值和最小值

内建函数len、min、max可以取得列表的长度、最小值、最大值。

num = [2,1,5,6,10,25,6]
len(num) == 7
min(num) == 1
max(num) == 25

// min和max函数也可以有下面这种用法
min(2,1,5,6,10,25,6) == 1
max(2,1,5,6,10,25,6) == 25

列表与字符串的相互转换

我们可以将一个字符串通过list函数转换为列表：list(“hello”)

反之，我们也可以将一个列表组织成字符串：str = ”.join(list),这里的两个单引号的意思是在列表的两个元素之间要添加什么元素进去，空则什么都不添加。

list("hello") == ['h', 'e', 'l', 'l', 'o']
myList = ['h', 'e', 'l', 'l', 'o']
str = ''.join(myList)     //"hello"
str = ' '.join(myList)     //"h e l l o"
str = 'a'.join(myList)     //'haealalao'

添加删除元素

append方法可以在列表的最后添加一个元素。
del可以删除指定位置的元素。

myList = [1,2,3]
list.append(4)      //[1, 2, 3, 4]
del myList[2]       //[1, 2, 4]
del myList[0:2]     //[4]

extend方法与连接的区别

extend方法可以在列表的末尾一次性追加另一个序列中的多个值，也就是说可以用新序列来扩展原有的列表。

a = [1,2,3]
b = [4,5,6]
a.extend(b)     //a == [1,2,3,4,5,6]

extend方法与连接的区别在于：连接不会改变两个序列中的任何一个，它会生成一个新的序列，但是extend会扩展原来的序列。

extend方法的效率优于连接

sort方法与sorted方法的比较

1. sort方法用于在原位置（改变原来的列表）对列表进行排序，没有返回值。
2. sorted方法不改变原来的列表，返回值是一个已排序的列表副本。

x = [2,1,3]
x.sort()            //没有返回值
x == [1,2,3]

x = [2,1,3]
y = x.sort()
y == [1,2,3]
x == [2,1,3]

如果需要按照你自己定义的方法进行排序，那么可以自己实现一个compare(x,y)函数，然后将这个函数作为参数传递给sort或者sorted方法，就可以实现自定义排序了。

sort和sorted方法还有两个可选的参数，一个是key，一个是reverse。

1. key:参数key必须提供一个在排序过程中使用的函数。然而，该函数并不是直接用来确定对象的大小，而是为每一个元素创建一个键，然后所有的元素根据键来排序。如x.sort(key=len)会根据每一个元素的长度进行排序。
2. reverse参数就比较简单，是一个简单的布尔值（True或者False）。如：x.sort(reverse=True)就代表进行反向排序。

其他一些有用的方法

count

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

index

index方法从列表中找出某个值的第一个匹配项的索引位置

a = [1,2,3,4,5,6,1,2,3]
a.index(1) == 0

insert

insert方法将对象插到列表中

a = [1,2,3,4]
a.insert(2,"hello")     //[1,2,"hello",3,4]

pop

pop方法会移除列表中的一个元素（不带参数条件下默认移除最后一个元素），并且返回该元素的值。（pop方法是列表中唯一一个既能修改列表值，又能返回值的方法）

a = [1,2,3,4]
a.pop()  == 4        //a == [1,2,3]
a.pop(1) == 1       //a == [1,3]     

remove

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

a = [1,2,3,4,5,6,1,2,3]
a.remove(1)     //[2,3,4,5,6,1,2,3]