在上一章中提到，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()完全相同，返回的是最小值。