在上一章中提到，Python中提到的“序列”，通常指的是三種數據類型：string（字符串）、list（列表）、tuple（元組）。在本章依舊先對每種類型做一個基本的瞭解，再介紹一些操作符和函數。本章所介紹的是針對三種類型的一些共性操作，各個類型的獨特特性將再之後的章節中涉及。
6.1 序列對象
Python中序列對象的特點是由一組有序的元素排列而成，並且可以通過起始爲0的下標偏移量訪問到任意一個元素。
>>> str1 = 'abc'
>>> str1[1]
'b'
>>> list1 = [9, 'a', 0.2]
>>> list1[3] ##數組訪問越界
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
IndexError: list index out of range
6.1.1 字符串
Python3.x中，字符串類型有兩種：str和bytes，定義字符串的時候採用無前綴或前綴u代表str類型，採用前綴b代表bytes類型
#Python 3.6.5
>>> s1 = "abc"
>>> s2 = u"abc"
>>> s3 = b"abc"
>>> type(s1)
<class 'str'>
>>> type(s2)
<class 'str'>
>>> type(s3)
<class 'bytes'>
Python3中，str類型以字符爲單位進行處理，保存的是Unicode編碼的字符或字符串，每個字符用字符本身或者字符的Unicode編碼來表示都可以，但打印時都是打印字符本身。
>>> s1 = '中文'
>>> s2 = '\u4e2d\u6587' #‘中文'的unicode編碼
>>> s1 == s2
True
>>> s2
'中文'
bytes字符串以字節爲單位進行處理，組成形式必須是十六進制數，或者ASCII字符。bytes字符串實際上保存的是具體字符的二進制編碼，至於編碼表示怎樣的字符，則是由具體的編碼格式而定。
利用encode()和decode()函數，可以實現str和bytes的轉換
>>> s1 = '中文'
>>> b1 = s1.encode('utf-8') #b1是bytes形式, 保存的是'中文'的utf-8編碼
>>> b1
b'\xe4\xb8\xad\xe6\x96\x87'
>>> b1.decode('utf-8') #用utf-8對b1解碼
'中文'
字符串可以利用下標訪問到任何一個字符，但是字符串中的任意一個字符都不能修改，因此字符串是一種不可變對象。
>>> s = '123'
>>> s[0]
'1'
>>> s[0] = 9 #修改字符會報錯
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
TypeError: 'str' object does not support item assignment
方便起見，在之後詳細演示字符串時都會利用無前綴的字符串，相應的操作都可以運用到有前綴的字符串中。
6.1.2 列表（list）
字符串是一種保存一段字符或字節的序列，列表則是一個可以保存任意對象的序列，利用[]或工廠方法list創建
>>> l1 = ['abc', 123, 4.98, ['j', 'k']]
>>> l1
['abc', 123, 4.98, ['j', 'k']]
>>> l2 = list('123456')
>>> l2
['1', '2', '3', '4', '5', '6']
與字符串不同的是，list是一種可變對象，在創建之後仍然可以修改、添加、刪除其中的元素。
修改：可以直接利用下標
>>> l1 = ['abc', 123, 4.98, ['j', 'k']]
>>> l1[1] = 'ok'
>>> l1
['abc', 'ok', 4.98, ['j', 'k']]
添加，用insert(index, obj)函數在指定位置添加，或者利用append()函數在末尾添加
>>> l1 = [1, 'a', 'abc']
>>> l1.insert(2, 3) #在下標2的位置插入3
>>> l1
[1, 'a', 3, 'abc']
>>> l1.append('last') #末尾加入'last'
>>> l1
[1, 'a', 3, 'abc', 'last']
刪除，用pop(i)在指定位置刪除元素
>>> l1 = [1, 'a', 'abc']
>>> l1.pop(2) #在下標2的位置插入3
>>> l1
[1, 'a']
或者利用remove(obj)刪除指定元素，使用這個方法必須事先確定序列中有該元素，否則會拋出異常
>>> l1 = [1, 'a', 'abc']
>>> l1.remove(1)
>>> l1
['a', 'abc']
>>> l1.remove(2)
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
ValueError: list.remove(x): x not in list
6.1.3 元組（tuple）
tuple與list非常類似，區別在於tuple是不可變對象，因此內部的元素不能修改、添加或刪除。元組利用()或工廠方法tuple來創建
>>> t1 = (1, 'a', 'abc')
>>> t1
(1, 'a', 'abc')
>>> t2 = tuple('123')
>>> t2
('1', '2', '3')
6.2 針對序列對象的操作符
6.2.1、連接操作符（+）
利用+可以將多個相同類型的序列做連接：
>>> s1 = "123"
>>> s2 = "456"
>>> s1 + s2
'123456'
>>> l1 = ['5', 7, 'abc']
>>> l2 = ['12345', 'opq']
>>> l3 = ['1', 2]
>>> l1 + l2 + l3
['5', 7, 'abc', '12345', 'opq', '1', 2]
每一次連接運算+實際上都會生成一個新的對象，多個序列連加的過程中也就會產生許多的新對象，因此對於多個字符串連接的操作，可以利用join()方法來代替：
>>> l1 = ['a', 'b', 'cd', 'efg'] #可以把需要連接
>>> ''.join(l1)
'abcdefg'
>>> '-'.join(l1)
'a-b-cd-efg'
對於列表(list)而言，可以使用extend()方法完成連接，並且不會創建新的對象
>>> l1 = [1, 'a', 3]
>>> l1.extend([4, 'b'])
>>> l1
[1, 'a', 3, 4, 'b']
注意不要與append()方法混淆，使用append()會將傳入的任何對象都當作最後一個元素加入到列表中：
>>> l1 = [1, 'a', 3]
>>> l1.append([4, 'b'])
>>> l1
[1, 'a', 3, [4, 'b']]
6.2.2、重複操作符
重複操作符*可以返回一個包含多個原序列對象拷貝的新對象
>>> "abc" * 3
'abcabcabc'
6.2.3、切片（[]，[:], [::]）
利用下標[index]可以訪問序列中的任意一個元素，這種簡單的用方括號加一個下標的方式也是一種切片操作。更進一步，如果想“切”序列中的某一部分，可以利用[:]和[::]來實現。
[starting_index:ending_index] 可以用於訪問起始索引到結束索引的元素，注意不會包括結束索引的元素。
>>> l = [1, 2, 3, 4]
>>> l[1:3]
[2, 3] #不會包括索引位置爲3的元素4
起始索引和結束索引可以省略，分別表示從起始位置索引和索引到末尾
>>> l = [1, 2, 3, 4]
>>> l[:3]
[1, 2, 3]
>>> l[1:]
[2, 3, 4]
>>> l[:]
>>>[1, 2, 3, 4]
還可以採用負向索引，例如[-1]就代表取倒數第一個元素，[-3]代表倒數第三個
>>> l = [1, 2, 3, 4]
>>> l[-3:3]
[2, 3]
>>> l[-4:-2]
[1, 2]
>>> l[-4:]
[1, 2, 3, 4]
注意無論使用正向還是反向索引，切片取元素的方向都是正向的。換言之，如果ending_index<=starting_index，肯定是取不到任何元素的。
>>> l = [1, 2, 3, 4]
>>> l[3:2]
[]
>>> l[-2:-4]
[]
還可以利用[starting_index:ending_index:step] 的形式，每隔一定步長step 取一個元素，例如：
>>> l = [1, 2, 3, 4, 5, 6]
>>>> l[1:4:2]
[2, 4]
>>> l[::2]
[1, 3, 5]
>>> l[::3]
[1, 4]
將step 設爲負數，就可以實現反向取元素：
>>> l = [1, 2, 3, 4, 5, 6]
>>> l[::-2]
[6, 4, 2]
6.3 一些內置函數
6.3.1 類型轉換
str()，list()，tuple()，可以分別將傳入的對象轉換爲字符串，列表，元組。
str()可以傳入任意的obj對象，並且輸出對象的字符串形式，例如：
>>> l = [1, 2, 3, 4, 5, 6]
>>> str(l)
'[1, 2, 3, 4, 5, 6]'
list()，tuple()可以傳入任意的可迭代對象，可迭代對象除了容器對象外，還包括文件對象、管道對象等等。輸出的形式一般就是將可迭代對象中包含的每一個對象拆分，分別放入list或tuple。
>>> s = "123"
>>> list(s)
['1', '2', '3']
>>> l = [1, 2, 3, 4, 5, 6]
>>> tuple(l)
(1, 2, 3, 4, 5, 6)
>>> d = {'Michael': 95, 'Bob': 75, 'Tracy': 85}
>>> list(d)
['Bob', 'Michael', 'Tracy'] #對於dict對象，實際上是對d.keys()的淺拷貝
6.3.2 可操作內建函數
以下介紹幾個可操作內建函數
1、len(seq)
返回seq序列的長度
2、reversed(seq)
返回一個反轉序列的迭代器
注：list對象有一個reverse方法，可以反轉原list：
>>> l = [1,2,3]
>>> id(l)
4353355720
>>> l.reverse()
>>> id(l)
4353355720
>>> l
[3, 2, 1]
3、sum(iterable, start=0)
返回可迭代對象iterable內元素的和，start指定初始相加的參數，缺省值爲0。
>>> l = [3, 2, 1]
>>> sum(l) #執行的是0+3+2+1
6
>>> l2 = ['1', '2']
>>> sum(l2) #會報錯，因爲0不能與直接字符相加
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
TypeError: unsupported operand type(s) for +: 'int' and 'str'
>>> sum(a,'0') #即使將初始值設爲字符，也會報錯
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
TypeError: sum() can't sum strings [use ''.join(seq) instead]
4、reduce(function, iterable, initializer = 0)
reduce() 方法會對可迭代對象iterable中元素進行累積。function是具體累積操作的函數，initializer指定初始參數，默認爲0
可以利用reduce()方法實現之前的sum()方法：
>>>from functools import reduce #python3之後，需要從fucntools模塊中導入
>>>def add(x, y) : # 兩數相加
... return x + y
...
>>> reduce(add, [1,2,3,4,5]) # 計算列表和：1+2+3+4+5
15
>>> reduce(lambda x, y: x+y, [1,2,3,4,5]) # 使用 lambda 匿名函數
15
>>> import operator
>>> reduce(operator.add, [1,2,3,4,5]) # 使用operator模塊中的方法代替lambda函式也是常用的一種操作
15
5、zip(iterable)
zip()方法將可迭代的對象iterable作爲參數，將對象中對應的元素打包成一個個元組，然後返回由這些元組組成的列表**（python3返回迭代器）**。
>>> a = [1,2,3]
>>> b = [4,5,6]
>>> c = [4,5,6,7,8]
>>> zipped = zip(a,b) # 返回一個對象
>>> zipped
<zip object at 0x103abc288> #返回迭代器
>>> list(zipped) # list() 轉換爲列表
[(1, 4), (2, 5), (3, 6)]
>>> list(zip(a,c)) # 元素個數與最短的列表一致
[(1, 4), (2, 5), (3, 6)]
>>> a1, a2 = zip(*zip(a,b)) # 與 zip 相反，zip(*) 可理解爲解壓，返回二維矩陣式
>>> list(a1)
[1, 2, 3]
>>> list(a2)
[4, 5, 6]
>>>
6、enumerate(iterable, start=0)
該方法用於將一個可迭代對象組合爲一個索引序列，同時列出數據和數據下標，返回的是一個enumerate對象，同時也是這個索引序列對應的迭代器一般用在 for 循環當中，可以同時獲取元素和對應下標
>>>seasons = ['Spring', 'Summer', 'Fall', 'Winter']
>>> list(enumerate(seasons))
[(0, 'Spring'), (1, 'Summer'), (2, 'Fall'), (3, 'Winter')]
>>>seq = ['one', 'two', 'three']
>>> for i, element in enumerate(seq): #利用for獲取迭代器內元素
... print i, element
...
0 one
1 two
2 three
7、sorted(iterable, cmp = None, key = None, reverse = False)
sorted()方法可以對可迭代對象iterable進行排序，並返回排序後的新對象，排序規則可以利用func和key兩個參數指定，默認都爲None，reverse默認爲False，一般代表升序排列
最簡單的用法，返回一個列表的升序排列：
>>> l = [1, 3, 9, 0]
>>> sorted(l)
[0, 1, 3, 9]
cmp是一個比較的函數，該函數具有兩個參數，參數的值都是從可迭代對象中取出，此函數必須遵守的規則爲，大於則返回1，小於則返回-1，等於則返回0。也就是說如果cmp = func(x, y)，x,y此時代表可迭代對象中的任意兩個元素，那麼：
- 如果func返回-1，那麼x排在y前面
- 如果func返回0，那麼x，y相對位置不變
- 如果func返回1，那麼x排在y後面
舉例而言：
>>> L=[('b',2),('a',1),('c',3),('d',4)]
>>> sorted(L, cmp=lambda x,y:cmp(x[1],y[1])) # 利用cmp函數
[('a', 1), ('b', 2), ('c', 3), ('d', 4)]
lambda函式中，x, y列表L中的代表任意兩個元組對象，因爲對於cmp(x[1],y[1])來說，x[1]<y[1]返回-1，相等時返回0，x[1]>y[1]返回1，因此恰好可以實現按每個元組中的數字大小進行升序排序。
同樣的實現也可以利用key參數，直接指明按元組對象中的哪個元素進行排序
>>> sorted(L, key=lambda x:x[1]) # 利用key
[('a', 1), ('b', 2), ('c', 3), ('d', 4)]
相比起來，cmp參數肯定更加靈活。
注：list自帶一個sort()方法，該方法會改變原有的list對象，語法是： list.sort(cmp=None, key=None, reverse=False) cmp和key參數的含義與sorted()方法中相同
>>> aList = [123, 'Google', 'Runoob', 'Taobao', 'Facebook'];
>>> aList.sort();
>>> aList
[123, 'Facebook', 'Google', 'Runoob', 'Taobao']
8、max()
max(iterable, key = None)可以返回可迭代對象iterable中的最大元素，key參數的用法與sorted()中的key參數十分相似
>>> L=[('b',2),('a',1),('c',3),('d',4)]
>>> max(L, key=lambda x:x[1]) # 利用key
('d', 4)
也可以直接用max(arg0, arg1…)返回參數列表中的最大值
9、min()
min()的用法與max()完全相同，返回的是最小值。