一、循环设计

1、range()

在 Python 中，for 循环后的 in 跟随一个序列的话，循环每次使用的序列元素，而不是序列的下标。

之前我们已经使用过 range() 来控制 for 循环。现在，我们继续开发 range 的功能，以实现下标对循环的控制：

# range.py
S = 'abcdefghijk'
for i in range(0,len(S),2):
    print S[i]

在该例子中，我们利用 len() 函数和 range() 函数，用 i 作为 S 序列的下标来控制循环。在 range 函数中，分别定义上限，下限和每次循环的步长。这就和 C 语言中的 for 循环相类似了。

2、enumerate()

利用 enumerate() 函数，可以在每次循环中同时得到下标和元素：

S = 'abcdefghijk'
for (index,char) in enumerate(S):
    print index
    print char

实际上，enumerate() 在每次循环中，返回的是一个包含两个元素的定值表(tuple)，两个元素分别赋予 index 和char。

3、zip()

如果你多个等长的序列，然后想要每次循环时从各个序列分别取出一个元素，可以利用 zip() 方便地实现：

ta = [1,2,3]
tb = [9,8,7]
tc = ['a','b','c']
for (a,b,c) in zip(ta,tb,tc):
    print(a,b,c)

每次循环时，从各个序列分别从左到右取出一个元素，合并成一个 tuple，然后 tuple 的元素赋予给 a,b,c 。

zip( ) 函数的功能，就是从多个列表中，依次各取出一个元素。每次取出的(来自不同列表的)元素合成一个元组，合并成的元组放入 zip() 返回的列表中。

zip( ) 函数起到了聚合列表的功能。

我们可以分解聚合后的列表，如下:

ta = [1,2,3]
tb = [9,8,7

# cluster
zipped = zip(ta,tb)
print(zipped)

# decompose
na, nb = zip(*zipped)
print(na, nb)

二、循环对象

1、什么是循环对象

循环对象是这样一个对象，它包含有一个 next() 方法 ( __next__() 方法，在python 3x 中 )， 这个方法的目的是进行到下一个结果，而在结束一系列结果之后，举出 StopIteration 错误。

当一个循环结构（比如 for ）调用循环对象时，它就会每次循环的时候调用 next() 方法，直到 StopIteration 出现，for 循环接收到，就知道循环已经结束，停止调用 next()。

假设我们有一个 test.txt 的文件:

1234
abcd
efg

我们运行一下 python 命令行：

>>>f = open('test.txt')

>>>f.next()

>>>f.next()

...

不断输入 f.next()，直到最后出现 StopIteration 。

open() 返回的实际上是一个循环对象，包含有 next() 方法。而该 next() 方法每次返回的就是新的一行的内容，到达文件结尾时举出 StopIteration。这样，我们相当于手工进行了循环。

自动进行的话，就是：

for line in open('test.txt'):
    print line

在这里，for 结构自动调用 next() 方法，将该方法的返回值赋予给 line。循环知道出现 StopIteration 的时候结束。

相对于序列，用循环对象的好处在于：不用在循环还没有开始的时候，就生成好要使用的元素。所使用的元素可以在循环过程中逐次生成。这样，节省了空间，提高了效率，编程更灵活。

2、迭代器

从技术上来说，循环对象和 for 循环调用之间还有一个中间层，就是要将循环对象转换成迭代器(iterator)。这一转换是通过使用 iter() 函数实现的。但从逻辑层面上，常常可以忽略这一层，所以循环对象和迭代器常常相互指代对方。

3、生成器

生成器(generator)的主要目的是构成一个用户自定义的循环对象。

生成器的编写方法和函数定义类似，只是在 return 的地方改为 yield。生成器中可以有多个 yield。当生成器遇到一个 yield 时，会暂停运行生成器，返回 yield 后面的值。当再次调用生成器的时候，会从刚才暂停的地方继续运行，直到下一个 yield 。生成器自身又构成一个循环器，每次循环使用一个 yield 返回的值。

下面是一个生成器:

def gen():
    a = 100
    yield a
    a = a*8
    yield a
    yield 1000

该生成器共有三个 yield， 如果用作循环器时，会进行三次循环。

for i in gen():
    print i

再考虑如下一个生成器:

def gen():
    for i in range(4):
        yield i

它又可以写成生成器表达式(Generator Expression)：

G = (x for x in range(4))

生成器表达式是生成器的一种简便的编写方式。

4、表推导

表推导(list comprehension)是快速生成表的方法。它的语法简单，很有实用价值。

假设我们生成表 L ：

L = [ ]
for x in range(10):
    L.append(x**2)

以上产生了表 L，但实际上有快捷的写法，也就是表推导的方式:

L = [x**2 for x in range(10)]

这与生成器表达式类似，只不过用的是中括号。

三、函数对象

秉承着一切皆对象的理念，我们再次回头来看函数(function)。函数也是一个对象，具有属性。作为对象，它还可以赋值给其它对象名，或者作为参数传递。

1、lambda 函数

在展开之前，我们先提一下 lambda 函数。可以利用 lambda 函数的语法，定义函数。lambda 例子如下：

func = lambda x,y: x + y
print func(3,4)

lambda 生成一个函数对象。该函数参数为 x,y，返回值为 x+y。函数对象赋给 func。func 的调用与正常函数无异。

以上定义可以写成以下形式：

def func(x, y):
    return x + y

2、函数作为参数传递

函数可以作为一个对象，进行参数传递。函数名(比如 func )即该对象。比如说:

def test(f, a, b):
    print 'test'
    print f(a, b)

test(func, 3, 5)

test 函数的第一个参数f就是一个函数对象。将 func 传递给 f，test 中的 f() 就拥有了 func() 的功能。

我们因此可以提高程序的灵活性。可以使用上面的test函数，带入不同的函数参数。比如:

test((lambda x,y: x**2 + y), 6, 9)

3、map( )函数

map( ) 是 Python 的内置函数。它的第一个参数是一个函数对象。

re = map((lambda x: x+3),[1,3,5,6])

这里，map( ) 有两个参数，一个是 lambda 所定义的函数对象，一个是包含有多个元素的表。map( ) 的功能是将函数对象依次作用于表的每一个元素，每次作用的结果储存于返回的表 re 中。map 通过读入的函数(这里是 lambda 函数)来操作数据（这里“数据”是表中的每一个元素，“操作”是对每个数据加3）。

在 Python 3.X 中，map() 的返回值是一个循环对象。可以利用 list() 函数，将该循环对象转换成表。

如果作为参数的函数对象有多个参数，可使用下面的方式，向 map() 传递函数参数的多个参数：

re = map((lambda x,y: x+y),[1,2,3],[6,7,9])

map( ) 将每次从两个表中分别取出一个元素，带入 lambda 所定义的函数。

4、filter( )函数

filter 函数的第一个参数也是一个函数对象。它也是将作为参数的函数对象作用于多个元素。如果函数对象返回的是 True，则该次的元素被储存于返回的表中。 filter 通过读入的函数来筛选数据。同样，在 Python 3.X 中，filter 返回的不是表，而是循环对象。

filter 函数的使用如下例:

def func(a):
    if a > 100:
        return True
    else:
        return False

print filter(func,[10,56,101,500])

5、reduce( ) 函数

reduce 函数的第一个参数也是函数，但有一个要求，就是这个函数自身能接收两个参数。reduce 可以累进地将函数作用于各个参数。如下例：

print reduce((lambda x,y: x+y),[1,2,5,7,9])

reduce 的第一个参数是 lambda 函数，它接收两个参数 x,y, 返回 x+y。

reduce 将表中的前两个元素(1和2)传递给 lambda 函数，得到3。该返回值(3)将作为 lambda 函数的第一个参数，而表中的下一个元素(5)作为 lambda 函数的第二个参数，进行下一次的对 lambda 函数的调用，得到8。依次调用 lambda 函数，每次 lambda 函数的第一个参数是上一次运算结果，而第二个参数为表中的下一个元素，直到表中没有剩余元素。

上面例子，相当于(((1+2)+5)+7)+9

提醒： reduce() 函数在3.0里面不能直接用的，它被定义在了 functools 包里面，需要引入包。

四、错误处理

1、异常处理

在项目开发中，异常处理是不可或缺的。异常处理帮助人们 debug，通过更加丰富的信息，让人们更容易找到 bug 的所在。异常处理还可以提高程序的容错性。

我们之前在讲循环对象的时候，曾提到一个 StopIteration 的异常，该异常是在循环对象穷尽所有元素时的报错。

我们以它为例，来说明基本的异常处理。

一个包含异常的程序:

re = iter(range(5))
for i in range(100):
    print re.next()
print 'HaHaHaHa'

首先，我们定义了一个循环对象 re，该循环对象将进行5次循环，每次使用序列的一个元素。

在随后的 for 循环中，我们手工调用 next( ) 函数。当循环进行到第6次的时候，re.next() 不会再返回元素，而是抛出 (raise)StopIteration 的异常。整个程序将会中断。

我们可以修改以上异常程序，直到完美的没有 bug。但另一方面，如果我们在写程序的时候，知道这里可能犯错以及可能的犯错类型，我们可以针对该异常类型定义好”应急预案“。

re = iter(range(5))
try:
    for i in range(100):
        print re.next()
except StopIteration:
    print 'here is end ',i

print 'HaHaHaHa'

在 try 程序段中，我们放入容易犯错的部分。我们可以跟上 except，来说明如果在 try 部分的语句发生 StopIteration 时，程序该做的事情。如果没有发生异常，则 except 部分被跳过。

随后，程序将继续运行，而不是彻底中断。

完整的语法结构如下：

try:
    ...
except exception1:
    ...
except exception2:
    ...
except:
    ...
else:
    ...
finally:
    ...

如果 try 中有异常发生时，将执行异常的归属，执行 except。异常层层比较，看是否是 exception1, exception2...，直到找到其归属，执行相应的 except 中的语句。如果 except 后面没有任何参数，那么表示所有的 exception 都交给这段程序处理。比如:

try:
    print(a*2)
except TypeError:
    print("TypeError")
except:
    print("Not Type Error & Error noted")

由于 a 没有定义，所以是 NameError。异常最终被 except: 部分的程序捕捉。

如果无法将异常交给合适的对象，异常将继续向上层抛出，直到被捕捉或者造成主程序报错。比如下面的程序：

def test_func():
    try:
        m = 1/0
    except NameError:
        print("Catch NameError in the sub-function"
try:
    test_func()
except ZeroDivisionError:
    print("Catch error in the main program")

子程序的 try...except... 结构无法处理相应的除以0的错误，所以错误被抛给上层的主程序。

如果 try 中没有异常，那么 except 部分将跳过，执行 else 中的语句。

finally 是无论是否有异常，最后都要做的一些事情。

流程如下:

• try -> 异常 -> except -> finally

• try -> 无异常 -> else -> finally

2、抛出异常

我们也可以自己写一个抛出异常的例子:

print 'Lalala'
raise StopIteration
print 'Hahaha'

这个例子不具备任何实际意义。只是为了说明 raise 语句的作用。

StopIteration 是一个类。抛出异常时，会自动有一个中间环节，就是生成 StopIteration 的一个对象。Python 实际上抛出的，是这个对象。当然，也可以自行生成对象:

raise StopIteration()

五、动态类型

动态类型 (dynamic typing)V 是 Python 另一个重要的核心概念。我们之前说过，Python 的变量 (variable) 不需要声明，而在赋值时，变量可以重新赋值为任意值。这些都与动态类型的概念相关。

1、动态类型

在我们接触的对象中，有一类特殊的对象，是用于存储数据的。常见的该类对象包括各种数字，字符串，表，词典。在 C 语言中，我们称这样一些数据结构为变量。而在 Python 中，这些是对象。

对象是储存在内存中的实体。但我们并不能直接接触到该对象。我们在程序中写的对象名，只是指向这一对象的引用 (reference)。

引用和对象分离，是动态类型的核心。引用可以随时指向一个新的对象：

a = 3
a = 'at'

第一个语句中，3是储存在内存中的一个整数对象。通过赋值，引用 a 指向对象3。

第二个语句中，内存中建立对象‘at’，是一个字符串(string)。引用 a 指向了'at'。此时，对象3不再有引用指向它。Python 会自动将没有引用指向的对象销毁(destruct)，释放相应内存。

(对于小的整数和短字符串，Python 会缓存这些对象，而不是频繁的建立和销毁。)

a = 5
b = a
a = a + 2

再看这个例子。通过前两个句子，我们让 a,b 指向同一个整数对象5( b = a的含义是让引用b指向引用a所指的那一个对象)。但第三个句子实际上对引用a重新赋值，让a指向一个新的对象7。此时 a,b 分别指向不同的对象。我们看到，即使是多个引用指向同一个对象，如果一个引用值发生变化，那么实际上是让这个引用指向一个新的引用，并不影响其他的引用的指向。从效果上看，就是各个引用各自独立，互不影响。

其它数据对象也是如此:

L1 = [1,2,3]
L2 = L1
L1 = 1

但注意以下情况:

L1 = [1,2,3]
L2 = L1
L1[0] = 10
print L2

在该情况下，我们不再对 L1 这一引用赋值，而是对 L1 所指向的表的元素赋值。结果是，L2 也同时发生变化。

原因何在呢？因为 L1，L2 的指向没有发生变化，依然指向那个表。表实际上是包含了多个引用的对象（每个引用是一个元素，比如 L1[0]，L1[1]…, 每个引用指向一个对象，比如1,2,3), 。而 L1[0] = 10这一赋值操作，并不是改变L1的指向，而是对 L1[0], 也就是表对象的一部份(一个元素)，进行操作，所以所有指向该对象的引用都受到影响。

（与之形成对比的是，我们之前的赋值操作都没有对对象自身发生作用，只是改变引用指向。）

列表可以通过引用其元素，改变对象自身(in-place change)。这种对象类型，称为可变数据对象(mutable object)，词典也是这样的数据类型。

而像之前的数字和字符串，不能改变对象本身，只能改变引用的指向，称为不可变数据对象(immutable object)。

我们之前学的元组(tuple)，尽管可以调用引用元素，但不可以赋值，因此不能改变对象自身，所以也算是 immutable object。

2、从动态类型看函数的参数传递

函数的参数传递，本质上传递的是引用。比如说：

def f(x):
    x = 100
    print x

a = 1
f(a)
print a

参数 x 是一个新的引用，指向 a 所指的对象。如果参数是不可变(immutable)的对象，a 和 x 引用之间相互独立。对参数 x 的操作不会影响引用 a。这样的传递类似于 C 语言中的值传递。

如果传递的是可变(mutable)的对象，那么改变函数参数，有可能改变原对象。所有指向原对象的引用都会受影响，编程的时候要对此问题留心。比如说：

def f(x):
    x[0] = 100
    print x
a = [1,2,3]
f(a)
print a

动态类型是 Python 的核心机制之一。可以在应用中慢慢熟悉。