Python进阶06 循环对象
作者:Vamei 出处:http://www.cnblogs.com/vamei 欢迎转载,也请保留这段声明。谢谢!
这一讲的主要目的是为了大家在读Python程序的时候对循环对象有一个基本概念。
循环对象的并不是随着Python的诞生就存在的,但它的发展迅速,特别是Python 3x的时代,循环对象正在成为循环的标准形式。
什么是循环对象
循环对象是这样一个对象,它包含有一个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的时候结束。
相对于序列,用循环对象的好处在于:不用在循环还没有开始的时候,就生成好要使用的元素。所使用的元素可以在循环过程中逐次生成。这样,节省了空间,提高了效率,编程更灵活。
迭代器
从技术上来说,循环对象和for循环调用之间还有一个中间层,就是要将循环对象转换成迭代器(iterator)。这一转换是通过使用iter()函数实现的。但从逻辑层面上,常常可以忽略这一层,所以循环对象和迭代器常常相互指代对方。
生成器
生成器(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))
生成器表达式是生成器的一种简便的编写方式。读者可进一步查阅。
表推导
表推导(list comprehension)是快速生成表的方法。它的语法简单,很有实用价值。
假设我们生成表L:
L = []
for x in range(10):
L.append(x**2)
以上产生了表L,但实际上有快捷的写法,也就是表推导的方式:
L = [x**2 for x in range(10)]
这与生成器表达式类似,只不过用的是中括号。
(表推导的机制实际上是利用循环对象,有兴趣可以查阅。)
练习 下面的表推导会生成什么?
xl = [1,3,5]
yl = [9,12,13]
L = [ x**2 for (x,y) in zip(xl,yl) if y > 10]
总结
循环对象
生成器
表推导
Python进阶07 函数对象
作者:Vamei 出处:http://www.cnblogs.com/vamei 欢迎转载,也请保留这段声明。谢谢!
秉承着一切皆对象的理念,我们再次回头来看函数(function)。函数也是一个对象,具有属性(可以使用dir()查询)。作为对象,它还可以赋值给其它对象名,或者作为参数传递。
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
注意:查阅百度百科得知:Python的lambda函数只能有一个表达式,不能多。
函数作为参数传递
函数可以作为一个对象,进行参数传递。函数名(比如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)
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所定义的函数。
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])
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
根据mmufhy的提醒: reduce()函数在3.0里面不能直接用的,它被定义在了functools包里面,需要引入包,见评论区。
总结
函数是一个对象
用lambda定义函数
map()
filter()
reduce()
Python进阶08 异常处理
作者:Vamei 出处:http://www.cnblogs.com/vamei 欢迎转载,也请保留这段声明。谢谢!
本文特别感谢kylinfish的纠正,相关讨论见留言区。
异常处理
在项目开发中,异常处理是不可或缺的。异常处理帮助人们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
抛出异常
我们也可以自己写一个抛出异常的例子:
print 'Lalala'
raise StopIteration
print 'Hahaha'
这个例子不具备任何实际意义。只是为了说明raise语句的作用。
StopIteration是一个类。抛出异常时,会自动有一个中间环节,就是生成StopIteration的一个对象。Python实际上抛出的,是这个对象。当然,也可以自行生成对象:
raise StopIteration()
总结
try: ... except exception: ... else: ... finally: ...
raise exception
Python进阶09 动态类型
作者:Vamei 出处:http://www.cnblogs.com/vamei 欢迎转载,也请保留这段声明。谢谢!
动态类型(dynamic typing)是Python另一个重要的核心概念。我们之前说过,Python的变量(variable)不需要声明,而在赋值时,变量可以重新赋值为任意值。这些都与动态类型的概念相关。
动态类型
在我们接触的对象中,有一类特殊的对象,是用于存储数据的。常见的该类对象包括各种数字,字符串,表,词典。在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.
从动态类型看函数的参数传递
函数的参数传递,本质上传递的是引用。比如说:
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的核心机制之一。可以在应用中慢慢熟悉。
总结
引用和对象的分离,对象是内存中储存数据的实体,引用指向对象。
可变对象,不可变对象
函数值传递
Python快速教程总结
作者:Vamei 出处:http://www.cnblogs.com/vamei 欢迎转载,也请保留这段声明。谢谢!
到现在为止,Python快速教程就到一段落。谢谢大家的鼓励和支持,特别是对其中错误的包容和指正。
在第一部分,基础部分中,除了一些基础知识,我们着力于建立对象的概念。在第二部分中,我们深入到许多实用并且常用的Python用法。如果只是想了解Python是什么,那么第一部分应该可以给出一个基本概念。加上第二部分的话,我们应该可以有足够的知识读懂Python程序,并编写一些应用。
我会在以后写一些选读性的随笔,以便对教程更进一步补充。
我还在考虑下一步在博客中写什么。Python依然有一个庞大的标准库可以展开。但标准库的讲解离不开对计算机原理和互联网原理的了解,很难以一个快速教程的方式呈现出来。但离开标准库,Python也显得很单薄。一个可能是,先写一个总体纲要,描述一下标准库各个包所包含的内容,以及可能的用途,不知是否可行?
另外,最近看了一些Google Engine和Django的内容,觉得也不错。只可惜自己在这方面经验太浅,不知从何说起。
另一方面,我个人的Python经验也非常有限。希望能多参与到一些项目,以便能积累经验。
总之,休息,休息一下。