Python基本的数据结构-序列

序列

Python最基本的数据结构是序列，序列的索引从0开始，最后一个元素的序号为-1，倒数第二个为-2。

序列包括：列表(可变)、元组、字符串、Unicode字符串、buffer对象和xrange对象。

列表和元组的主要区别是列表可以修改，而元组不能。

序列可以包含其他的序列，如下：

>>> jack = ['jack',42]
>>> saint = ['saint',50]
>>> db = [jack,saint]
>>> db
[['jack', 42], ['saint', 50]]

序列的通用操作

有索引、分片、加、乘以及检查某个元素是否属于序列的成员(成员资格)。

索引

可以通过索引获取元素：

>>> greeting = 'Hello'
>>> greeting[0]
'H'
>>> greeting[-1]
'o'

分片

使用分片来访问一定范围内的元素，通过冒号隔开的两个索引实现：

>>> tag = 'Hello,nice to meet you,nice'
>>> tag[0:5]
'Hello'

第一个索引是要提取的第1个元素的编号，包含在分片内；第二个索引不包含在分片内。

>>> numbers = [i for i in range(0,10)]
>>> numbers
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]>>> numbers[1:-1]
[1, 2, 3, 4, 5, 6, 7, 8]
>>> numbers[1:9]
[1, 2, 3, 4, 5, 6, 7, 8]
>>> numbers[1:10]
[1, 2, 3, 4, 5, 6, 7, 8, 9]

这里-1代表的是最后一个元素，等同于[1:9]，且不会包括最后一个元素。
要想包括最后一个元素，必须提供最后一个元素的下一个元素所对应的索引作为边界。索引10指向了第11个元素，这个元素并不存在，但在最后一个元素之后。

那[-3:-1]又会输出什么呢？

>>> numbers[-3:-1]
[7, 8]

输出结果为，从倒数第3个元素到倒数第1个元素。
只要是逆序的(左边的索引比右边的索引晚出现在序列中)，结果就是一个空的序列。

>>> numbers[-2:0]
[]

幸好，如果想得到包括序列结果的元素，只需要将最后一个元素置为空即可：

>>> numbers[1:]
[1, 2, 3, 4, 5, 6, 7, 8, 9]

如果需要复制整个序列，将两个索引都置空：

>>> numbers[:]
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]

分片还可以指定步长,默认是1:

>>> numbers[0::2]
[0, 2, 4, 6, 8]

从开始到结束，步长为2。

步长可以是负数

>>> numbers[8:3:-1]
[8, 7, 6, 5, 4]

表示逆序提取元素。从序列的尾部开始向左提取元素，直到第一个元素。

序列相加

>>> [1,2,3] + [4,5,6]
[1, 2, 3, 4, 5, 6]

相同类型的序列才可以进行相加操作

乘法

>>> 'python' * 3
'pythonpythonpython'

上面会将’python’重复3次。

Python有一个内建值-None。表示什么都没有。结合乘法可以初始化长度为10的空列表：

>>> [None] * 10
[None, None, None, None, None, None, None, None, None, None]

成员资格

使用in运算符检测一个值是否在序列中。返回True或False。

>>> sentence = "have a nice day"
>>> 'have' in sentence
True
>>> 'good' in sentence

长度、最小值和最大值

内建函数len、min和max非常有用。

>>> numbers = [100,32,62]
>>> len(numbers)
3
>>> min(numbers)
32
>>> max(numbers)
100

函数和方法的区别：函数是内置的，可以直接调用。而方法是定义在类中的，需要通过对象访问。

列表

前面的例子中多次使用列表。列表是可变的，有很多有用的方法。

list函数

将其他类型的序列转换为列表。

>>> somelist = list('Hello')
>>> somelist
['H', 'e', 'l', 'l', 'o']
>>> ''.join(somelist) # 将列表转换为字符串
'Hello'

基本的列表操作

赋值

>>> l = list('Hello')
>>> l
['H', 'e', 'l', 'l', 'o']
>>> l[0] = 'Y'
>>> l
['Y', 'e', 'l', 'l', 'o']

删除元素

>>> del l[3]
>>> l
['Y', 'e', 'l', 'o']

如果删除后还想使用该元素，推荐使用方法pop。

['Y', 'e', 'l', 'o']
>>> x = l.pop(1) #可以指定索引
>>> x
'e'
>>> x = l.pop()# 也可以不指定，默认弹出最后一个元素
>>> x
'o'

分片赋值

>>> l
['Y', 'e', 'l', 'o']
>>> l[:2] = list('ok')
>>> l
['o', 'k', 'l', 'o']

可以一次为多个元素赋值。这里是与原序列等长（长度为2）的赋值，还可以与原序列不等长的赋值。

>>> l
['o', 'k', 'l', 'o']
>>> l[2:] = list('isverygood')
>>> l
['o', 'k', 'i', 's', 'v', 'e', 'r', 'y', 'g', 'o', 'o', 'd']

还可以通过分片赋值来删除元素：

>>> l[2:] = []
>>> l
['o', 'k']

列表方法

append
用于在列表末尾增加新的对象：

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

注意，append会直接修改原来的列表，而不是返回一个新列表。

它是属于列表的方法，所以会改变调用它的列表。若是函数，则不会改变原来的列表，而是返回新列表。

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

>>> l = [1,2,3,1,1,1]
>>> l.count(1)
4

extend
也会修改原列表
在列表的末尾一次性追加另一个序列中的多个值。可以用新列表扩展原来的列表：

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

和连接操作的区别

这个操作和连接操作(+)很像，但是区别是连接操作不会修改原列表，而是返回一个新的列表：

>>> a = [1,2,3]
>>> a + b
[1, 2, 3, 4, 5, 6]
>>> a
[1, 2, 3]

和append函数的区别
我们看一下代码就知道了：

>>> a = [1,2,3]
>>> b = [4,5,6]
>>> a.append(b)
>>> a
[1, 2, 3, [4, 5, 6]]

append把b当成一个列表对象加到列表a的末尾,而extend把b中所有元素添加到原列表末尾。

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

>>> a
[1, 2, 3]
>>> a.index(1)
0
>>> a.index(2)
1

注意该方法若是找不到匹配项，会抛出异常。

insert
将对象插入到列表中：

>>> a
[1, 2, 3]
>>> a.insert(1,5)#在索引1位置插入5，剩下的元素后移
>>> a
[1, 5, 2, 3]

注意，这里的操作对象为“对象”。比如，如下：

>>> a.insert(1,[1,2])
>>> a
[1, [1, 2], 5, 2, 3]

移除列表的一个元素(默认是最后一个)，并返回该元素的值:

>>> a
[1, [1, 2], 5, 2, 3]
>>> a = [1,2,3]
>>> a.pop()
3
>>> a
[1, 2]
>>> a.pop(0)
1

pop方法是唯一一个既能修改列表又返回元素值的列表方法

使用append和pop可以实现stack

remove
移除列表中某个值的第一个匹配项：

>>> a = list('hi,nice')
>>> a
['h', 'i', ',', 'n', 'i', 'c', 'e']
>>> a.remove('i')
>>> a
['h', ',', 'n', 'i', 'c', 'e']

reverse
将列表中的元素反向存放:

>>> a = [1,2,3]
>>> a.reverse()
>>> a
[3, 2, 1]

sort
用于在原位置对列表进行排序，会修改原来的列表。

>>> a
[3, 2, 1]
>>> a.sort()
>>> a
[1, 2, 3]

再次总结，一般方法都会修改原列表，而函数不会，函数会返回新列表。

如果想要一个排好序的副本，同时又保留原有列表不变的时候。
注意，sort函数修改原列表而不会返回一个新列表，下面的用法是错误的：

>>> a = [3,1,2]
>>> b = a.sort() #不要这么做
>>> a
[1, 2, 3]
>>> print b
None

正确的做法是这样：

>>> a = [3,1,2]
>>> b = a[:] #把a的副本赋值给b
>>> b.sort()
>>> b
[1, 2, 3]
>>> a
[3, 1, 2]

还有一个函数可以获取已排序的列表副本-sorted函数

>>> a = [3,1,2]
>>> b = sorted(a)
>>> b
[1, 2, 3]
>>> a
[3, 1, 2]

可以通过compare(x,y)的形式自定义比较函数：x<y返回负数；x=y返回0；x>y返回整数。

Python提供了一个内建的比较函数cmp

>>> cmp(1,3)
-1
>>> cmp(1,0)
1

比较函数可以作为sort方法的参数：

>>> a
[3, 1, 2]
>>> a.sort(cmp)
>>> a
[1, 2, 3]

sort方法还有两个可选参数：key和reverse。如果要使用这两个可选参数，那么就要通过名字来指定。(下面会有例子)

参数key和参数cmp类似-必须提供一个在排序过程中使用的函数。
如果要根据元素的长度进行排序，那么可以使用len作为key函数：

>>> a = ['hello','saint','jack','zhang']
>>> a.sort(key=len)
>>> a
['jack', 'hello', 'saint', 'zhang']

reverse是布尔值(True,False)，默认为False。

指定True来进行从大到小排序：

>>> a = [3,1,2]
>>> a.sort(reverse=True)
>>> a
[3, 2, 1]

元组:不可变序列

字符串也是不可变的

简单的创建元组方法:

>>> 1,2,3
(1, 2, 3)

元组大部分时候是通过圆括号括起来的，如下是创建空元祖：

>>> ()
()

创建只包含一个值的元组：

>>> 1,
(1,)  # 是元组！>>> (1)  # 这个不是元组
1

元组的分片还是元组：

>>> x = 1,2,3
>>> x[1] # 通过索引访问
2
>>> x
(1, 2, 3)
>>> x[0:2]
(1, 2)
>>> 3*(5,) #元组的乘法
(5, 5, 5)

tuple函数

和list函数功能类似，以一个序列作为参数并把它转换为元组：

>>> tuple('hello')
('h', 'e', 'l', 'l', 'o')
>>> tuple([1,2,3])
(1, 2, 3)

元组的意义

元组可以在映射(和集合的成员)中当作键使用(因为元组的不可变性)，而列表不行
元组作为很多内建函数和方法的返回值(还是因为不可变性，如果返回列表，那么使用这个返回值的人可能会不小心修改了这个列表，除非你希望是可以修改的)

一般来说，列表可能更能满足对序列的所有需求。