1、序列中元素的索引：

　　第一個元素索引是0，第二個是1，依次遞增
　　最后一個元素索引是-1，倒數第二個是-2，依次遞減

2、序列(Sequence)的種類:

　　列表（list）、元組(tuple)、字符串(string）、Unicode 字符串、buffer對象、xrange對象

3、列表和元組的區別：列表可以進行修改，但是元組不行

4、tuple常作為字典的鍵

5、序列都可以進行以下操作：

　　索引(indexing)、分片(sliceing)、加(adding)、乘（multiplying）、以及檢查元素是否屬于序列（in）、最大值(max)、最小值(min)、長度(len)、迭代器(iterator)等操作

6、序列中也可以包含其他的序列

7、索引

　　7.1、第一個元素的索引是0，第二個是1，依次遞增；最后一個元素的索引是-1，倒數第二個是-2，依次遞減

　　7.2、對于序列可以直接進行索引，而不是一定非要通過變量進行索引，如："Hello"[0],得到H

　　7.3、如果一個函數返回一個序列，可直接對結果進行索引而得到指定的元素

8、分片

　　訪問一定范圍內的元素

　　[start:end:step]：從start索引開始，每隔step個元素取一個元素，但是不包括end元素

　　[start:end]:從start索引開始，每隔1個元素取一個元素，但是不包括end元素

　　[start:]:從start索引開始取到結尾，每隔1個元素取一個元素

　　[:end]：從0開始，每隔1個元素取一個元素，但是不包括end元素

　　[:]：取所有元素

　　[::step]：從0開始取到結尾，每隔step個元素取一個元素

　　[:end:step]：從0開始，每隔step個元素取一個元素，取到end前一個元素

　　[start::step]:從start開始，取到結尾，步長step

　　[start:start]:取得start元素

　　8.1、step > 0 從前往后取；step < 0 從后往前取;step 不能為0

9、相同類型的序列才能相加，第二個序列追加到第一個序列后面,生成新的序列副本

　　a = [1,2,3,4,5]

　　b = [4,5,6,7,8]

　　a + b的結果是：[1, 2, 3, 4, 5, 4, 5, 6, 7, 8]；a、b的內容不發生改變

10、序列乘以一個數字N，大小擴展為現在N倍，內容重復N倍，如：

　　a = [1,2,3,4,5]

　　a * 5的結果是：[1, 2, 3, 4, 5, 1, 2, 3, 4, 5, 1, 2, 3, 4, 5, 1, 2, 3, 4, 5, 1, 2, 3, 4, 5]；a的內容不發生改變

11、可以使用in運算符一個對象是否屬于一個序列，返回True或者False，例如：

　　element1 = 1

　　element2 = 'c'

　　element3 = "LLO"

　　sequence1 = [1,2,3,4,5]

　　sequence2 = "abcdefg"

　　sequence3 = "HELLOWORLD"

　　--------

　　>>> element1 in sequence1
　　True

　　>>> element2 in sequence2
　　True

　　#下面這個操作在2.3以上的版本才支持

　　>>> element3 in sequence3
　　True

12、求最大值、最小值、長度的函數分別是：max()、min()、len()

13、列表

　　13.1、list函數適用于所有的類型的序列，而不僅僅是字符串：lst = list("Helloworld")

　　13.2、"".join(lst)將lst轉換為字符串

　　13.3、元素賦值：x=[1,2,3,4,5],x[0] = 5;要賦值的元素必須存在，否則報錯；賦值之后將修改指定的元素

　　13.4、刪除元素：names=["alice","beth","ceil","dee-dee","earl"];del names[2]；刪除指定下標的元素；刪除之后將影響列表元素

　　13.5、分片賦值：name = list("perl")

　　　　>>> name = list("perl")
　　>>> name
　　　　['p', 'e', 'r', 'l']
　　>>> name[2:] = "ar"
　　>>> name
　　　　['p', 'e', 'a', 'r']
　　>>> name[2:] = "HELLO WORLD"
　　>>> name
　　　　['p', 'e', 'H', 'E', 'L', 'L', 'O', ' ', 'W', 'O', 'R', 'L', 'D']
　　>>> name[1:1] = list("12345")
　　>>> name
　　　　['p', '1', '2', '3', '4', '5', 'e', 'H', 'E', 'L', 'L', 'O', ' ', 'W', 'O', 'R', 'L', 'D']
　　>>> name[5:] = []
　　>>> name
　　　　['p', '1', '2', '3', '4']

　　13.6、列表方法：對象.方法(參數)

　　　　13.6.1、append():在列表末尾添加元素你，會修改調用者并且直接返回

　　　　　　>>> a = list("12345")
　　　　　　>>> a
　　　　　　['1', '2', '3', '4', '5']
　　　　　　>>> a.append(6)
　　　　　　>>> a
　　　　　　['1', '2', '3', '4', '5', 6]

　　　　13.6.2、count()：返回列表的指定元素的個數

　　　　　　>>> a = list("HelloWorld")
　　　　　　>>> a.count('l')
　　　　　　3

　　　　13.6.3、extend()：追加一個列表到調用者的后面并修改調用者內容

　　　　　　>>> a = list("Hello ")
　　　　　　>>> b = list("World")
　　　　　　>>> a.extend(b)
　　　　　　>>> a
　　　　　　['H', 'e', 'l', 'l', 'o', ' ', 'W', 'o', 'r', 'l', 'd']

　　　　13.6.4、index():指定元素在list中第一次出現的索引，如果元素不存在，會出現錯誤

　　　　　　>>> a = list("Hello")
　　　　　　>>> a.index("l")
　　　　　　2

　　　　13.6.5、insert()：插入對象到列表中

　　　　　　>>> a = list("Hello")
　　　　　　>>> a.insert(3,"XINYE")
　　　　　　>>> a
　　　　　　['H', 'e', 'l', 'XINYE', 'l', 'o']

　　　　13.6.6、pop()：默認彈出最后一個元素，指定一個參數時，刪除指定索引的元素，并返回

　　　　　　>>> a = list("Hello")
　　　　　　>>> a.pop()
　　　　　　'o'
　　　　　　>>> a.pop(1)
　　　　　　'e'
　　　　　　>>> a
　　　　　　['H', 'l', 'l']

　　　　　　pop()方法是唯一一個能修改列表并且返回列表元素的方法

　　　　13.6.7、常見的數據結構：棧

　　　　　　FIFO：First Input First Output,先入先出：入棧――insert(0,元素)；出棧――pop()

　　　　　　LIFO:Last Input First Output，后入先出：入棧――append();出棧――pop(0)

　　　　13.6.8、remove()：刪除列表中第一個匹配項，會修改調用者，但沒有返回值，如果刪除的元素不存在，則會報錯

　　　　　　>>> a = list("HelloWorld")
　　　　　　>>> a
　　　　　　['H', 'e', 'l', 'l', 'o', 'W', 'o', 'r', 'l', 'd']
　　　　　　>>> a.remove("a")
　　　　　　Traceback (most recent call last):
? 　　　　　　File " ", line 1, in
　　　　　　ValueError: list.remove(x): x not in list
　　　　　　>>> a.remove("e")
　　　　　　>>> a
　　　　　　['H', 'l', 'l', 'o', 'W', 'o', 'r', 'l', 'd']

　　　　13.6.9、reverse():反向存放列表，會修改調用者

　　　　　　>>> a = list("Hello")
　　　　　　>>> a.reverse()
　　　　　　>>> a
　　　　　　['o', 'l', 'l', 'e', 'H']

　　　　13.6.10、reversed()函數：反向存儲序列,生成副本，不會修改參數內容，但是不會返回列表，而是返回迭代器，使用list()函數可以把迭代器轉化為list:list(reversed(list))

　　　　　　>>> a = list("Hello")
　　　　　　>>> reversed(a)

　　　　　　>>> a
　　　　　　['H', 'e', 'l', 'l', 'o']
　　　　　　>>> list(reversed(a))
　　　　　　['o', 'l', 'l', 'e', 'H']

　　13.6.11、sort():改變被排序里誒包，但是不會返回值

　　　　>>> a = [4,6,2,1,7,9]
　　　　>>> a.sort()
　　　　>>> a
　　　　[1, 2, 4, 6, 7, 9]

　　如果不想改變a的內容，只想得到一個副本的排序結果，則需要先生成一個a的副本，然后對這個副本進行排序(副本的生成不能直接賦值哦，因為賦值實際上引用的是同一個對象，只能按照以下的方式)：

　　　　>>> a = list("hello world")
　　　　>>> b = a[:]
　　　　>>> b.sort()
　　　　>>> a
　　　　['h', 'e', 'l', 'l', 'o', ' ', 'w', 'o', 'r', 'l', 'd']
　　　　>>> b
　　　　[' ', 'd', 'e', 'h', 'l', 'l', 'l', 'o', 'o', 'r', 'w']

　　13.6.12、sorted()函數：不修改參數的內容，返回排序的副本

　　　　>>> a = list("hello world")
　　　　>>> b = sorted(a)
　　　　>>> a
　　　　['h', 'e', 'l', 'l', 'o', ' ', 'w', 'o', 'r', 'l', 'd']
　　　　>>> b
　　　　[' ', 'd', 'e', 'h', 'l', 'l', 'l', 'o', 'o', 'r', 'w']

　　13.6.13、高級排序：按照特定的方式進行排序

　　　　a.按照compare(x,y)的形式自定義一個函數進行排序，這個自定義函數在x y的時候返回1；

　　　　默認的系統提供了一個cmp的函數，用來進行排序，遵循在x y的時候返回1的規則(3.0以上不再支持這個內置函數)

　　　　b.sort方法支持兩個可選參數key和reverse

　　　　key制定一個排序的函數和cmp類似，但是這個函數并不會直接用來確定對象的大小，而是為每一個元素創建一個鍵，然后根據鍵來排序，例如要按照元素的長度來進行排序，則可以使用len函數來指定

　　　　　　r = ["aardvark","abalone","acme","add","aerate"]

　　　　　　r.sort(key=len)

　　　　　　排序之后r的內容為：['add', 'acme', 'aerate', 'abalone', 'aardvark']

　　　　reverse的值為True或者False，來指明是否進行反序排列

　　　　　　>>> x = [2,8,4,6,5,7,9]
　　　　　　>>> x.sort(reverse=True)
　　　　　　>>> x
　　　　　　[9, 8, 7, 6, 5, 4, 2]

　　以上這些都可以通過sorted()函數進行替換

14、元組：不可改變的序列。如果用逗號分隔開一些值就創建了一個元組，一般都用圓括號括起來

　　>>> 1,2,3,4,5
　　(1, 2, 3, 4, 5)
　　>>> a = 1,2,3
　　>>> a
　　(1, 2, 3)
　　>>> a = (1,)
　　>>> a
　　(1,)

如果想要創建一個非空元組，必須使用逗號，哪怕只有一個元素；若要創建空的元組，則直接使用一個()

tuple([1,2,3]）、tuple("123")、tuple((1,2,3))把其他的序列轉換為元組

元組可以作為映射的鍵，但是list卻不行，這個也是元組的主要應用場合