目录
序列
序列是一类基本数据类型(字符串/列表/元组)的统称，这些数据类型都含有一些共同的特性。例如：数据类型对象可以包含有若干个元素，这些元素有序排列，并且可以通过下标索引来访问到其中的一个或几个元素。
序列类型包含了：
- String 字符串
- Tuple 元组
- List 列表
序列的标准操作符
适用于所有序列类型
| 序列操作符 | 作用 |
|---|---|
切片操作符1( [] ) seqName[number] |
获取序列中索引为 Number 的元素 |
切片操作符2( [:]/[::] ) seqName[num1:num2] |
获取索引从 num1 到 num2 之间的元素集合 |
重复操作符(*) seqName * copies_int |
将序列的内容重复 conpies_int(必须为标准整型) 次 ==> Return 一个新的包含有份原序列拷贝的序列对象 |
连接操作符( | ) seq1 + seq2 |
把序列 seq1 和序列 seq2(必须与 seq1 是相同的基本数据类型) 连接起来 ==> Return 一个包含有 seq1 和 seq2 的内容的新序列 |
成员关系操作符( in/not in ) obj in/not in seq |
判断obj元素是否被包含在seq中 ==> Return True/False |
注意：使用连接操作符( + )来讲两个序列的内容合并，并不是一个最快、最有效的方法。
- 合并字符串类型对象时，建议调用
join()函数，会更加节省内存。 - 合并列表类型对象时，建议使用列表类型的内建的
extend()函数，但是注意这个函数会将原来的列表对象改变，而且可变类型对象的extend()函数没有返回值。
当然，用什么方法最好还得看具体情况了。
切片操作符[]/[:]/[::]
序列允许通过下标的方式来获得某一个元素，或者通过指定下标范围来获得一组序列的元素，这种访问序列的方式被称之为切片。
方式一：[] 获取序列的某个元素
- 索引偏移量为正值：范围为0 <= index <= len(seqName)-1
- 索引偏移量为负值：范围为-len(seqName) <= index <= -1
正负索引的区别在于：正索引以序列的开始为起点，负索引以序列的结束为起点。
NOTE：len() 是序列类型的内建函数，可以获取序列的长度，即元素的个数。
注意：
1. 使用 [] 方式时，index的取值不能超出范围，否则会报错IndexError
2. 索引值是从0开始的
方式二：[:] 获取序列的某一组元素
seqName[starting_index:ending_index-1] #获取由starting_index开始至ending_index结束之间的元素注意：
1. 使用 [:] 方式时，index的取值可以超出范围而不会报错。
2. 索引值是从0开始的
In [23]: alist = [1,2,3,4,5]
In [24]: alist[:100] #ending_index超出了范围，但仍然没有报错；start_index的缺省值 == 0，ending_index的缺省值为len(seqName)
Out[24]: [1, 2, 3, 4, 5]方式三：[::] 步长索引
序列的最后一个切片操作是扩展的步长切片操作，即，第三个索引值。
步长：在获取的切片子序列的基础上，按照一定的步进来获取元素。
EXAMPLE1：每隔一位获取一个元素
In [48]: aStr = 'abcdefghijk'
In [49]: aStr[::2]
Out[49]: 'acegik'EXAMPLE2：将序列内容反转
In [50]: aStr[::-1]
Out[50]: 'kjihgfedcba'一个例子
有一个字符串，我们想通过一个循环的形式去显示，并且每显示一次我们就把位于最后的一个字符砍掉。
In [53]: aStr = 'abcdefghijk'
In [54]: range(-1,-len(aStr),-1)
Out[54]: [-1, -2, -3, -4, -5, -6, -7, -8, -9, -10]
In [56]: for i in [None]+range(-1,-len(aStr),-1):
...: print aStr[:i]
...:
abcdefghijk
abcdefghij
abcdefghi
abcdefgh
abcdefg
abcdef
abcde
abcd
abc
ab
a
当然，如果我们把上例中的 String 变成 List 或 Tuple 之后，这个小技巧将会非常实用。
NOTE：
1. range() 是数字列表生成器，也支持步进操作 。
2. 为了第一次 Print 能够将 String 完全打印，需要使用aStr[:None]
3. 倒序删除元素aStr[:-index]
4. Python 中的 for 循环可以遍历所有的可迭代类型对象
range() 用法: range() 函数常用于生成一个 List 数据类型对象， EG.
In [1]: range(1,10)
Out[1]: [1, 2, 3, 4, 5, 6, 7, 8, 9]一些使用技巧：
range(1,10,2) 当参数是全正数时，按从小到大排列
range(-1,-10,-2) 当参数全是负数时，按从大到小排列
In [3]: range(-1,-10,-2)
Out[3]: [-1, -3, -5, -7, -9]List[:-1] 从后往前删除元素
In [5]: range(-1,-10,-2)[:-1]
Out[5]: [-1, -3, -5, -7]
In [7]: range(1,10,2)[:-1]
Out[7]: [1, 3, 5, 7]字符串的连接
字符串可以使用 “+” 号来进行连接，但实际上还有一种更加快、更省内存的连接方式 —— join()
EXAMPLE:
In [10]: ''.join(['my name',' is jmilk'])
Out[10]: 'my name is jmilk'序列的功能函数
注意：下列函数中的len()/reversed()/sum()只能接受序列类型参数，其他的功能函数除了可以接收序列类型参数外，还能够接收所有的可迭代对象。我们在学习一个函数时，先使用 help() 来查看函数的帮助文档，帮助文档中会明确的指出该函数能够接收的参数类型。
可迭代对象包含下面4种：
1. 序列类型 List、String 、Tuple。
2. 非序列类型dict、file。
3. 自定义的任何包含__iter__()或__getitem__()方法的类迭代器。
4. Iterable(迭代器)，函数形参中包含iterable，表示可以传递迭代器类型实参。
迭代：迭代是重复反馈过程的活动，每一次对过程的重复称为一次”迭代”，而每一次迭代得到的结果会作为下一次迭代的初始值。Python 中迭代的概念是由序列、迭代器、其他支持迭代操作的对象中泛化而来的。
enumerate() 枚举出序列对象的元素
enumerate(sequence[,start = 0]) 接收一个可迭代对象作为参数，返回一个enumerate对象(是一个迭代器，由索引号和元素合并为一个元素而组成的元组)。[,start = 0]参数可以指定索引的起始位置。
In [22]: aStr = 'jmilkfan'
In [23]: enumerate(aStr)
Out[23]: <enumerate at 0x35d1550> #返回一个enumerate对象，是一个迭代器
In [25]: for i,j in enumerate(aStr):
...: print "%s : %s" % (i,j)
...:
0 : j
1 : m
2 : i
3 : l
4 : k
5 : f
6 : a
7 : n
len() 获取序列对象的长度
只接受序列类型参数
序列对象的长度，即序列对象元素的个数
In [39]: name = 'Jmilk'
In [40]: len(name)
Out[40]: 5min() 取出sequence中的最小值
In [28]: aStr
Out[28]: 'jmilkfan'
In [29]: min(aStr)
Out[29]: 'a'
若元素是String类型的化会转换为ASCII码计算后再比较。
max() 取出sequence中的最大值
类似min()函数
In [30]: max(aStr)
Out[30]: 'n'reversed() 返回一个逆序访问的迭代器
只接受序列类型对象参数
reversed(sequence) -> reverse iterator over values of the sequence
In [31]: aStr
Out[31]: 'jmilkfan'
In [32]: reversed(aStr)
Out[32]: <reversed at 0x36d4ed0>
In [34]: for i in reversed(aStr):
...: print i,
...:
n a f k l i m jsorted() 序列的排序
接收一个可迭代对象，返回一个有序的列表。
sorted(iterable, cmp=None, key=None, reverse=False) –> new sorted list
- iterable：接收一个可迭代对象
- cmp(x,y)：指定一个定制的，能够比较两个接收参数 x, y 的函数，默认为None。
- key(x)：指定一个接收一个参数的函数，用作在每个元素中提取一个关键值作为比较值，缺省为 None 表示比较每个元素。
- reverse：False 为默认值表示正序排列，True 为逆序排列。
注意1：没有__getitem__()的对象，如：Int类型是不能调用 key 和 cmp 函数的。
注意2：在Python中有许多内建的函数能够接受指定一个定制的函数，如：map()、filter()、reduce()、包括sorted等，这种时候使用 lambda 匿名函数将会非常的方便。
排序效率：key /reverse > cmp 。因为 cmp 函数会进行多次的两两比较，而 key/reverse 对每个输入记录只会被调用一次。
Key函数：以第二个关键字为比较值排序
In [205]: li = [('a',3),('b',2),('c',1)]
In [208]: sorted(li,key = lambda keyword:keyword[1]) #选择li[][1] ==> (3,2,1)作为比较的关键词
Out[208]: [('c', 1), ('b', 2), ('a', 3)]cmp函数：以第二个关键字为比较值排序
In [213]: sorted(li,cmp = lambda x,y:cmp(x[1],y[1])) #会进入多次的两两(1,2)/(1,3)/(2,3)比较
Out[213]: [('c', 1), ('b', 2), ('a', 3)]reverse：逆序排列
In [216]: sorted(li,lambda z,x:cmp(z[1],x[1]),reverse=True)
Out[216]: [('a', 3), ('b', 2), ('c', 1)]sum() 计算序列中的各项元素和
sum() 只接受序列类型对象，但是不支持元素为String或Char类型的序列。
sum(sequence[, start]) -> value
[, start]：可以指定累加的starting index。
In [59]: num = [1,2,3,4]
In [60]: str = 'My name is Jmilk'
In [61]: sum(num)
Out[61]: 10
In [62]: sum(str)
---------------------------------------------------------------------------
TypeError Traceback (most recent call last)
<ipython-input-62-3a5f0824550a> in <module>()
----> 1 sum(str)
TypeError: unsupported operand type(s) for +: 'int' and 'str'zip 混合两个序列对象
将两个序列对象中索引相同的两个元素结合成元组，并以这些元组作为返回的新列表的一个元素。
In [54]: aList
Out[54]: ['my', 'name', 'is', 'Jmilk']
In [55]: name
Out[55]: 'Jmilk'
In [56]: zip(name,aList)
Out[56]: [('J', 'my'), ('m', 'name'), ('i', 'is'), ('l', 'Jmilk')]all() 检测sequence中各项元素是否均为True
全 True 则 True，反正为 False 。
In [63]: num = [1,2,3,'']
In [64]: all(num)
Out[64]: False
In [65]: num = [1,2,3,True]
In [66]: all(num)
Out[66]: True注意：所以的空值序列对象都是False
any() 检测序列中的任意元素是否为True
有 True 则 True 。
In [67]: num = [1,2,3,'']
In [68]: any(num)
Out[68]: True相关阅读：