1.序列：成员有序排列，并且可以通过下标偏移量访问到他的一个或者几个成员，包括字符串（普通字符串和unicode字符串），列表和元组类型
2.序列类型都是有着相同的访问模式，他的每一个元素可以通过指定一个偏移量的方式得到，而多个元素可以通过切片操作的的方式一次得到。
3.序列类型的操作符
seq[index]:获取小标为index的元素
seq[ind1:ind2]:获取下标从ind1到ind2之间的元素集合 ，不包括ind2
seq*epr:序列重复epr次
seq1+seq2:连接两个序列 ,这两个序列是相同类型，推荐使用 seq.extend(seq2),更加快和有效，这个函数没有返回值
obj in seq: 判断object是否包含在seq中
#coding:utf-8
b=[1,2,3,4,5]
print b[1]
print b[1:3]
print b*2
c=[11,12,13,14]
print b+c
print (2 in b)
print "--------"
b.extend(c)
print b
结果：
2
[2, 3]
[1, 2, 3, 4, 5, 1, 2, 3, 4, 5]
[1, 2, 3, 4, 5, 11, 12, 13, 14]
True
-------------
[1, 2, 3, 4, 5, 11, 12, 13, 14]**切片索引：
seq[start:end:step]:步长索引，当step=-1是，表示对该列表进行翻转
print b
print b[::-1] #翻转
结果：
[1, 2, 3, 4, 5, 11, 12, 13, 14]
[14, 13, 12, 11, 5, 4, 3, 2, 1] 4.序列本身就内含了迭代的概念，for循环可以遍历所有的可迭代类型。
for i in b:
print "i=%d"%i, #,号表示不换行
结果：
i=1 i=2 i=3 i=4 i=5 i=11 i=12 i=13 i=145.内建函数list(),str(),tuple()被用作在各种序列类型之间的转换，这些转换实际上是工厂函数将对象作为参数，并将其内容（浅）拷贝到新生成的对象中。
list(iter):吧可迭代对象转化为列表
str(obj):吧obj对象转换为字符串
unicode(obj):把对象转换成unicode字符串
tuple(iter):把一个可迭代对象转换成一个元组对象
**python中不简单的把一个对象转换成另一个对象，因为一旦一个python对象建立我们就不能更改其身份和类型
6.列表常用的函数：
*len(),reversed()和sum()函数只能接受序列类型对象作为参数
①、enumerate(iter):接受一个可迭代对象作为参数，返回一个enumerate对象，该对象由iter每个元素的index值和item值组成的元组
a=[33,12,45,66,34,55]
for index,value in enumerate(a):
print "a[%d]=%d"%(index,value),
结果：
a[0]=33 a[1]=12 a[2]=45 a[3]=66 a[4]=34 a[5]=55②、len(seq):返回seq的长度
③、max(iter,key=None):返回iter中的最大值，如果指定了key，这个key必须是一个可以传给sort（）方法的，用于比较回调函数
④、min(iter.key=None):
⑤、reversed(seq):
⑥、sorted(iter,func=None,key=None,reverse=False):
⑦、sum(seq,init=0):
⑧、zip([iter0,iter1,iter2...]):返回一个列表，其中第一个元素是iter0[0],iter1[0]...构成的一个元组，第二个元素为iter0[1],iter1[1]...构成的一个元组，如果这几个序列的长度不同，取最小的长度为统一长度
>>> seq=[2,5,1,7,4,8]
>>> len(seq)
6
>>> max(seq)
8
>>> min(seq)
1
>>> reversed(seq)
<listreverseiterator object at 0x00000000030E29E8>
>>> print reversed(seq)
<listreverseiterator object at 0x00000000030E2390>
>>> print [i for i in reversed(seq)]
[8, 4, 7, 1, 5, 2]
>>> sorted(seq)
[1, 2, 4, 5, 7, 8]
>>> seq2=[2,4,5,6,7,8]
>>> zip(seq,seq2)
[(2, 2), (5, 4), (1, 5), (7, 6), (4, 7), (8, 8)]
>>>
>>> seq2=[2,4,5,6,7]
>>> zip(seq,seq2) #长度不一样
[(2, 2), (5, 4), (1, 5), (7, 6), (4, 7)]7.列表更新，既可以使用在等号左边指定一个索引或者索引范围的方式来更新一个或者几个元素，也可以用append（）方法来追加元素到列表
>>> seq=[1,2,3,4,5]
>>> seq[1]=1
>>> seq
[1, 1, 3, 4, 5]
>>> seq.append(10)
>>> seq
[1, 1, 3, 4, 5, 10]8.删除列表中的元素，如果你确切知道要删除的元素的索引，则可以用del seq[index],或者使用seq.remove(value)来删除元素，如果你想删除整个列表，你可以用del seq删除整个列表
>>> seq
[1, 1, 3, 4, 5, 10]
>>> seq
[1, 1, 3, 4, 5, 10]
>>> del seq[1]
>>> seq
[1, 3, 4, 5, 10]
>>> seq.remove(4)
>>> seq
[1, 3, 5, 10]
>>> del seq #删除整个列表
>>> seq
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
NameError: name 'seq' is not defined对于remove（）函数，如果列表中有多个相同的元素，那么
>>> seq=[1,2,1,2,3,4,5]
>>> seq.remove(1)
>>> seq
[2, 1, 2, 3, 4, 5] #删除第一个9.我们可以将多个相同类型的对象连接到一起，常常使用连接操作符+
当然我们可以用extend()方法来代替连接操作符，使用extend()的优点是实际上是把新列表添加到原有列表中，而不是像+一样新建一个列表
>>> seq1=[1,2,3,4]
>>> seq2=[5,6,7,8,9]
>>> seq3=seq1+seq2 #使用+号连接符
>>> seq3
[1, 2, 3, 4, 5, 6, 7, 8, 9]
>>> id(seq1)
49953928L
>>> id(seq2)
49952712L
>>> id(seq3)
49954056L使用extend（）
>>> seq1.extend(seq2)
>>> seq1
[1, 2, 3, 4, 5, 6, 7, 8, 9]
>>> id(seq1)
49953928L
>>> id(seq2)
49952712Lenumrate(iterable [,start]): 返回迭代器元素的 索引 和 值
>>> seq1
[1, 2, 3, 4, 5, 6, 7, 8, 9]
>>> [(index,value) for index,value in enumerate(seq1)]
[(0, 1), (1, 2), (2, 3), (3, 4), (4, 5), (5, 6), (6, 7), (7, 8), (8, 9)]10.列表类型的内建函数
>>> seq=[1,2,3,4,5,6,7]
>>> seq.count(1) #返回一个对象obj=1在在列表中出现的次数
1
>>> seq.index(3) #返回一个对象obj=3在列表的索引
2
>>> seq.index(3,1,2) #返回一个对象obj=3在索引1到2之间（不包括1和2）的对应的索引，没有就出现异常
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
ValueError: 3 is not in list
>>> seq.index(3,1,4)#返回一个对象obj=3在索引1到4之间（不包括1和4）的对应的索引，没有就出现异常
2
>>> seq.insert(2,100) #在列表索引为2的地方插入100
>>> seq
[1, 2, 100, 3, 4, 5, 6, 7]
>>>
>>> seq.pop(2) #删除并返回指定位置的对象
100
>>> seq
[1, 2, 3, 4, 5, 6, 7]
>>>注意：在使用可变对象的方法如list.sort(),list.extend(),list.reserse()的时候，这些操作会在列表的原地执行，也就是说现有列表内容会改变，但是没有返回值，
而内建函数resersed(),sorted()，他们返回一个对象，列表还是原来的列表，而我们得到了新的对象