目录

序列

序列是一类基本数据类型(字符串/列表/元组)的统称，这些数据类型都含有一些共同的特性。例如：数据类型对象可以包含有若干个元素，这些元素有序排列，并且可以通过下标索引来访问到其中的一个或几个元素。

序列类型包含了：

• String 字符串
• Tuple 元组
• List 列表

序列的标准操作符

适用于所有序列类型

注意：使用连接操作符( + )来讲两个序列的内容合并，并不是一个最快、最有效的方法。

• 合并字符串类型对象时，建议调用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]: 5

min() 取出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 j

sorted() 序列的排序

接收一个可迭代对象，返回一个有序的列表。

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