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()，他們返回一個對象，列表還是原來的列表，而我們得到了新的對象