Python3学习笔记06-循环设计、循环对象、函数对象、错误处理、动态类型
2016-06-09 00:00
991 查看
摘要: 本节我们学习Python的循环设计、循环对象、函数对象、错误处理、动态类型
##一、循环设计
在上一节,我们已经讨论了Python基本的循环语法。这一节,我们将接触更加灵活的循环方式。
###1、range()
在Python中,for循环后的in跟随一个序列的话,循环每次使用的序列元素,而不是序列的下标。
之前我们已经使用过** range() **来控制for循环。现在,我们继续开发range的功能,以实现下标对循环的控制:
在该例子中,我们利用 len() 函数和 range() 函数,用 i 作为 S 序列的下标来控制循环。在range函数中,分别定义上限,下限和每次循环的步长。这就和C语言中的for循环相类似了。
###2、enumerate()
利用enumerate()[b]函数,可以在每次循环中同时得到下标和元素[/b]:
实际上,enumerate()在每次循环中,返回的是一个包含两个元素的定值表(tuple),两个元素分别赋予index和char。
###3、zip()
如果你多个等长的序列,然后想要每次循环时从各个序列分别取出一个元素,可以利用**zip()**方便地实现:
每次循环时,从各个序列分别从左到右取出一个元素,合并成一个tuple,然后tuple的元素赋予给a,b,c 。
zip()[b]函数的功能,就是从多个列表中,依次各取出一个元素[/b]。每次取出的(来自不同列表的)元素合成一个元组,合并成的元组放入zip()返回的列表中。zip()函数起到了聚合列表的功能。
我们可以分解聚合后的列表,如下:
##二、循环对象
这一讲的主要目的是为了大家在读Python程序的时候对循环对象有一个基本概念。
循环对象的并不是随着Python的诞生就存在的,但它的发展迅速,特别是Python 3x的时代,循环对象正在成为循环的标准形式。
###1、什么是循环对象
循环对象是这样一个对象,它包含有一个**next()**方法 ( [b]next()[/b] 方法,在python 3x中 ), 这个方法的目的是进行到下一个结果,而在结束一系列结果之后,举出StopIteration错误。
当一个循环结构(比如for)调用循环对象时,它就会每次循环的时候调用next()方法,直到StopIteration出现,for循环接收到,就知道循环已经结束,停止调用next()。
假设我们有一个test.txt的文件:
我们运行一下python命令行:
不断输入f.next(),直到最后出现StopIteration 。
open()返回的实际上是一个循环对象,包含有next()方法。而该next()方法每次返回的就是新的一行的内容,到达文件结尾时举出StopIteration。这样,我们相当于手工进行了循环。
自动进行的话,就是:
在这里,for结构自动调用next()方法,将该方法的返回值赋予给line。循环知道出现StopIteration的时候结束。
相对于序列,用循环对象的好处在于:不用在循环还没有开始的时候,就生成好要使用的元素。所使用的元素可以在循环过程中逐次生成。这样,节省了空间,提高了效率,编程更灵活。
###2、迭代器
从技术上来说,循环对象和for循环调用之间还有一个中间层,就是要将循环对象转换成迭代器(iterator)。这一转换是通过使用iter()函数实现的。但从逻辑层面上,常常可以忽略这一层,所以循环对象和迭代器常常相互指代对方。
###3、生成器
生成器(generator)[b]的主要目的是构成一个用户自定义的循环对象[/b]。
生成器的编写方法和函数定义类似,只是在return的地方改为yield。生成器中可以有多个yield。当生成器遇到一个yield时,会暂停运行生成器,返回yield后面的值。当再次调用生成器的时候,会从刚才暂停的地方继续运行,直到下一个yield。生成器自身又构成一个循环器,每次循环使用一个yield返回的值。
下面是一个生成器:
循环中使用生成器:
该生成器共有三个yield, 如果用作循环器时,会进行三次循环。
再考虑如下一个生成器:
它又可以写成生成器表达式(Generator Expression):
生成器表达式是生成器的一种简便的编写方式。读者可进一步查阅。
###4、表推导
**表推导(list comprehension)**是快速生成表的方法。它的语法简单,很有实用价值。
假设我们生成表 L :
以上产生了表L,但实际上有快捷的写法,也就是表推导的方式:
L = [x**2 for x in range(10)]
这与生成器表达式类似,只不过用的是中括号。
(表推导的机制实际上是利用循环对象,有兴趣可以查阅。)
##三、函数对象
秉承着一切皆对象的理念,我们再次回头来看函数(function)。函数也是一个对象,具有属性(可以使用dir()查询)。作为对象,它还可以赋值给其它对象名,或者作为参数传递。
###1、lambda函数
在展开之前,我们先提一下lambda函数。可以利用lambda函数的语法,定义函数。lambda例子如下:
lambda生成一个函数对象。该函数参数为x,y,返回值为x+y。函数对象赋给func。func的调用与正常函数无异。
以上定义可以写成以下形式:
###2、函数作为参数传递
函数可以作为一个对象,进行参数传递。函数名(比如func)即该对象。比如说:
test函数的第一个参数f就是一个函数对象。将func传递给f,test中的f()就拥有了func()的功能。
我们因此可以提高程序的灵活性。可以使用上面的test函数,带入不同的函数参数。比如:
###3、map()函数
map()[b]是Python的内置函数。它的第一个参数[/b]是一个函数对象。
这里,map()有两个参数,一个是lambda所定义的函数对象,一个是包含有多个元素的表。map()[b]的功能是将函数对象依次作用于表的每一个元素,每次作用的结果储存于返回的表re中[/b]。map通过读入的函数(这里是lambda函数)来操作数据(这里“数据”是表中的每一个元素,“操作”是对每个数据加3)。
在Python 3.X中,map()的返回值是一个循环对象。可以利用list()函数,将该循环对象转换成表。
如果作为参数的函数对象有多个参数,可使用下面的方式,向map()传递函数参数的多个参数:
map()将每次从两个表中分别取出一个元素,带入lambda所定义的函数。
###4、filter()函数
filter函数的第一个参数也是一个函数对象。它也是将作为参数的函数对象作用于多个元素。如果函数对象返回的是True,则该次的元素被储存于返回的表中。 filter通过读入的函数来筛选数据。同样,在Python 3.X中,filter返回的不是表,而是循环对象。
filter函数的使用如下例:
###5、reduce()函数
reduce函数的第一个参数也是函数,但有一个要求,就是这个函数自身能接收两个参数。reduce可以累进地将函数作用于各个参数。如下例:
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,该循环对象将进行5次循环,每次使用序列的一个元素。
输出结果可以看出:iter()输出的为地址。
在随后的for循环中,我们手工调用next()函数。当循环进行到第6次的时候,re.next()不会再返回元素,而是抛出(raise)StopIteration的异常。整个程序将会中断。
我们可以修改以上异常程序,直到完美的没有bug。但另一方面,如果我们在写程序的时候,知道这里可能犯错以及可能的犯错类型,我们可以针对该异常类型定义好”应急预案“。
在try程序段中,我们放入容易犯错的部分。我们可以跟上except,来说明如果在try部分的语句发生StopIteration时,程序该做的事情。如果没有发生异常,则except部分被跳过。
随后,程序将继续运行,而不是彻底中断。
完整的语法结构如下:
如果try中有异常发生时,将执行异常的归属,执行except。异常层层比较,看是否是exception1, exception2...,直到找到其归属,执行相应的except中的语句。如果except后面没有任何参数,那么表示所有的exception都交给这段程序处理。比如:
由于a没有定义,所以是NameError。异常最终被except:部分的程序捕捉。
如果无法将异常交给合适的对象,异常将继续向上层抛出,直到被捕捉或者造成主程序报错。比如下面的程序:
子程序的try...except...结构无法处理相应的除以0的错误,所以错误被抛给上层的主程序。
如果try中没有异常,那么except部分将跳过,执行else中的语句。
finally是无论是否有异常,最后都要做的一些事情。
流程如下:
try->异常->except->finally
try->无异常->else->finally
###2、抛出异常
我们也可以自己写一个抛出异常的例子:
这个例子不具备任何实际意义。只是为了说明raise语句的作用。
StopIteration是一个类。抛出异常时,会自动有一个中间环节,就是生成StopIteration的一个对象。Python实际上抛出的,是这个对象。当然,也可以自行生成对象:
##五、动态类型
动态类型(dynamic typing)[b]是Python另一个重要的核心概念[/b]。我们之前说过,Python的变量(variable)不需要声明,而在赋值时,变量可以重新赋值为任意值。这些都与动态类型的概念相关。
###1、动态类型
在我们接触的对象中,有一类特殊的对象,是用于存储数据的。常见的该类对象包括各种数字,字符串,表,词典。在C语言中,我们称这样一些数据结构为变量。而在Python中,这些是对象。
对象是储存在内存中的实体。但我们并不能直接接触到该对象。我们在程序中写的对象名,只是指向这一对象的引用(reference)。
引用和对象分离,是动态类型的核心。引用可以随时指向一个新的对象:
第一个语句中,3是储存在内存中的一个整数对象。通过赋值,引用a指向对象3。
第二个语句中,内存中建立对象‘at’,是一个字符串(string)。引用a指向了'at'。此时,对象3不再有引用指向它。Python会自动将没有引用指向的对象销毁(destruct),释放相应内存。
(对于小的整数和短字符串,Python会缓存这些对象,而不是频繁的建立和销毁。)
再看这个例子。通过前两个句子,我们让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、从动态类型看函数的参数传递
函数的参数传递,本质上传递的是引用。比如说:
参数x是一个新的引用,指向a所指的对象。如果参数是不可变(immutable)的对象,a和x引用之间相互独立。对参数x的操作不会影响引用a。这样的传递类似于C语言中的值传递。
如果传递的是可变(mutable)的对象,那么改变函数参数,有可能改变原对象。所有指向原对象的引用都会受影响,编程的时候要对此问题留心。比如说:
动态类型是Python的核心机制之一。可以在应用中慢慢熟悉。
动态类型注意两点即可:
不可变对象 数字,字符串,元组为值传递
可变对象:字典,表,为引用传递,即为C中的指针变量。
注:本Python学习笔记是按照Vamei的博客教程来学习的,如有兴趣可以参考Vamei Python快速开发博文
##一、循环设计
在上一节,我们已经讨论了Python基本的循环语法。这一节,我们将接触更加灵活的循环方式。
###1、range()
在Python中,for循环后的in跟随一个序列的话,循环每次使用的序列元素,而不是序列的下标。
之前我们已经使用过** range() **来控制for循环。现在,我们继续开发range的功能,以实现下标对循环的控制:
S = 'abcdefghijk' for i in range(0,len(S),2): print S[i]
在该例子中,我们利用 len() 函数和 range() 函数,用 i 作为 S 序列的下标来控制循环。在range函数中,分别定义上限,下限和每次循环的步长。这就和C语言中的for循环相类似了。
###2、enumerate()
利用enumerate()[b]函数,可以在每次循环中同时得到下标和元素[/b]:
S = 'abcdefghijk' for (index,char) in enumerate(S): print index print char ... 0 a 1 b 2 c 3 d ...
实际上,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) ... (1, 9, 'a') (2, 8, 'b') (3, 7, 'c')
每次循环时,从各个序列分别从左到右取出一个元素,合并成一个tuple,然后tuple的元素赋予给a,b,c 。
zip()[b]函数的功能,就是从多个列表中,依次各取出一个元素[/b]。每次取出的(来自不同列表的)元素合成一个元组,合并成的元组放入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)
##二、循环对象
这一讲的主要目的是为了大家在读Python程序的时候对循环对象有一个基本概念。
循环对象的并不是随着Python的诞生就存在的,但它的发展迅速,特别是Python 3x的时代,循环对象正在成为循环的标准形式。
###1、什么是循环对象
循环对象是这样一个对象,它包含有一个**next()**方法 ( [b]next()[/b] 方法,在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)[b]的主要目的是构成一个用户自定义的循环对象[/b]。
生成器的编写方法和函数定义类似,只是在return的地方改为yield。生成器中可以有多个yield。当生成器遇到一个yield时,会暂停运行生成器,返回yield后面的值。当再次调用生成器的时候,会从刚才暂停的地方继续运行,直到下一个yield。生成器自身又构成一个循环器,每次循环使用一个yield返回的值。
下面是一个生成器:
def gen(): a = 100 yield a a = a*8 yield a yield 1000
循环中使用生成器:
for i in gen(): print i
该生成器共有三个yield, 如果用作循环器时,会进行三次循环。
再考虑如下一个生成器:
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)。函数也是一个对象,具有属性(可以使用dir()查询)。作为对象,它还可以赋值给其它对象名,或者作为参数传递。
###1、lambda函数
在展开之前,我们先提一下lambda函数。可以利用lambda函数的语法,定义函数。lambda例子如下:
func = lambda x,y: x + y print func(3,4) 7
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()[b]是Python的内置函数。它的第一个参数[/b]是一个函数对象。
re = map((lambda x: x+3),[1,3,5,6])
这里,map()有两个参数,一个是lambda所定义的函数对象,一个是包含有多个元素的表。map()[b]的功能是将函数对象依次作用于表的每一个元素,每次作用的结果储存于返回的表re中[/b]。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次循环,每次使用序列的一个元素。
输出结果可以看出:iter()输出的为地址。
在随后的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)[b]是Python另一个重要的核心概念[/b]。我们之前说过,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的核心机制之一。可以在应用中慢慢熟悉。
动态类型注意两点即可:
不可变对象 数字,字符串,元组为值传递
可变对象:字典,表,为引用传递,即为C中的指针变量。
注:本Python学习笔记是按照Vamei的博客教程来学习的,如有兴趣可以参考Vamei Python快速开发博文
相关文章推荐
- Python动态类型的学习---引用的理解
- Python3写爬虫(四)多线程实现数据爬取
- 垃圾邮件过滤器 python简单实现
- 下载并遍历 names.txt 文件,输出长度最长的回文人名。
- install and upgrade scrapy
- Scrapy的架构介绍
- Centos6 编译安装Python
- 使用Python生成Excel格式的图片
- 让Python文件也可以当bat文件运行
- [Python]推算数独
- Python中zip()函数用法举例
- Python中map()函数浅析
- Python将excel导入到mysql中
- Python在CAM软件Genesis2000中的应用
- 使用Shiboken为C++和Qt库创建Python绑定
- FREEBASIC 编译可被python调用的dll函数示例
- Python 七步捉虫法