python 进阶
来源:互联网 发布:java 线程中断机制 编辑:程序博客网 时间:2024/06/05 10:18
Python基础介绍了基本概念,特别是对象和类。
进阶教程对基础教程的进一步拓展,说明Python的细节。希望在进阶教程之后,你对Python有一个更全面的认识。
一、词典
之前我们说了,列表是Python里的一个类。一个特定的表,比如说nl = [1,3,8],就是这个类的一个对象。我们可以调用这个对象的一些方法,比如 nl.append(15)。 我们要介绍一个新的类,词典 (dictionary)。与列表相似,词典也可以储存多个元素。这种储存多个元素的对象称为容器(container)。
1、基本概念
常见的创建词典的方法:
>>>dic = {'tom':11, 'sam':57,'lily':100}>>>print type(dic)
词典和表类似的地方,是包含有多个元素,每个元素以逗号分隔。但词典的元素包含有两部分,键和值,常见的是以字符串来表示键,也可以使用数字或者真值来表示键(不可变的对象可以作为键)。值可以是任意对象。键和值两者一一对应。
比如上面的例子中,‘tom’对应11,'sam对应57,'lily'对应100
与表不同的是,词典的元素没有顺序。你不能通过下标引用元素。词典是通过键来引用。
>>>print dic['tom']>>>dic['tom'] = 30>>>print dic
构建一个新的空的词典:
>>>dic = {}>>>print dic
在词典中增添一个新元素的方法:
>>>dic['lilei'] = 99>>>print dic
这里,我们引用一个新的键,并赋予它对应的值。
2、词典元素的循环调用
dic = {'lilei': 90, 'lily': 100, 'sam': 57, 'tom': 90}for key in dic: print dic[key]
在循环中,dict的每个键,被提取出来,赋予给key变量。
通过print的结果,我们可以再次确认,dic中的元素是没有顺序的。
3、词典的常用方法
>>>print dic.keys() # 返回dic所有的键>>>print dic.values() # 返回dic所有的值>>>print dic.items() # 返回dic所有的元素(键值对)>>>dic.clear() # 清空dic,dict变为{}
另外有一个很常用的用法:
>>>del dic['tom'] # 删除 dic 的‘tom’元素
del是Python中保留的关键字,用于删除对象。
与表类似,你可以用len()查询词典中的元素总数。
>>>print len(dic)
二、文本文件的输入输出
Python具有基本的文本文件读写功能。Python的标准库提供有更丰富的读写功能。
文本文件的读写主要通过open()所构建的文件对象来实现。
1、创建文件对象
我们打开一个文件,并使用一个对象来表示该文件:
对象名 = open(文件名,模式)
最常用的模式有:
- r 打开只读文件,该文件必须存在。
- r+ 打开可读写的文件,该文件必须存在。
- w 打开只写文件,若文件存在则文件长度清为0,即该文件内容会消失。若文件不存在则建立该文件。
- w+ 打开可读写文件,若文件存在则文件长度清为零,即该文件内容会消失。若文件不存在则建立该文件。
- a 以附加的方式打开只写文件。若文件不存在,则会建立该文件,如果文件存在,写入的数据会被加到文件尾,即文件原先的内容会被保留。
- a+ 以附加方式打开可读写的文件。若文件不存在,则会建立该文件,如果文件存在,写入的数据会被加到文件尾后,即文件原先的内容会被保留。
- 上述的形态字符串都可以再加一个b字符,如rb、w+b或ab+等组合,加入b 字符用来告诉函数库打开的文件为二进制文件,而非纯文字文件。
比如:
>>>f = open("test.txt","r")
2、文件对象的方法
读取:
content = f.read(N) # 读取N bytes的数据content = f.readline() # 读取一行content = f.readlines() # 读取所有行,储存在列表中,每个元素是一行。
写入:
f.write('I like apple!\n') # 将'I like apple'写入文件并换行
关闭文件:
f.close() # 不要忘记关闭文件
三、模块
我们之前看到了函数和对象。从本质上来说,它们都是为了更好的组织已经有的程序,以方便重复利用。
模块(module)也是为了同样的目的。在Python中,一个.py文件就构成一个模块。通过模块,你可以调用其它文件中的程序。
1、引入模块
我们先写一个first.py文件,内容如下:
def laugh(): print 'HaHaHaHa'
再写一个second.py,并引入first中的程序:
import first #将first文件引入for i in range(10): first.laugh()
在second.py中,我们使用了first.py中定义的laugh()函数。
引入模块后,可以通过 模块.对象 的方式来调用引入模块中的某个对象。上面例子中,first为引入的模块,laugh()是我们所引入的对象。
Python中还有其它的引入方式:
import a as b # 引入模块a,并将模块a重命名为bfrom a import function1 # 从模块a中引入function1对象。调用a中对象时,我们不用再说明模块,即直接使用function1,而不是a.function1。from a import * # 从模块a中引入所有对象。调用a中对象时,我们不用再说明模块,即直接使用对象,而不是a.对象。
这些引用方式,可以方便后面的程序书写。
2、搜索路径
Python会在以下路径中搜索它想要寻找的模块:
程序所在的文件夹
操作系统环境变量PYTHONPATH所包含的路径
标准库的安装路径
如果你有自定义的模块,或者下载的模块,可以根据情况放在相应的路径,以便Python可以找到。
3、模块包
可以将功能相似的模块放在同一个文件夹(比如说this_dir)中,构成一个模块包。通过
import this_dir.module
引入this_dir文件夹中的module模块。
该文件夹中必须包含一个 __init__.py 的文件,提醒Python,该文件夹为一个模块包。__init__.py 可以是一个空文件。
四、函数的参数传递
我们已经接触过函数(function)的参数(arguments)传递。当时我们根据位置,传递对应的参数。我们将接触更多的参数传递方式。
回忆一下位置传递:
def f(a,b,c): return a+b+cprint(f(1,2,3))
在调用 f 时,1,2,3根据位置分别传递给了a,b,c。
1、关键字传递
有些情况下,用位置传递会感觉比较死板。关键字(keyword)传递是根据每个参数的名字传递参数。关键字并不用遵守位置的对应关系。依然沿用上面f的定义,更改调用方式:
print(f(c=3,b=2,a=1))
关键字传递可以和位置传递混用。但位置参数要出现在关键字参数之前:
print(f(1,c=3,b=2))
2、参数默认值
在定义函数的时候,使用形如a=19的方式,可以给参数赋予默认值(default)。如果该参数最终没有被传递值,将使用该默认值。
def f(a,b,c=10): return a+b+cprint(f(3,2))print(f(3,2,1))
在第一次调用函数f时, 我们并没有足够的值,c没有被赋值,c将使用默认值10.
第二次调用函数的时候,c被赋值为1,不再使用默认值。
3、包裹传递
在定义函数时,我们有时候并不知道调用的时候会传递多少个参数。这时候,包裹(packing)位置参数,或者包裹关键字参数,来进行参数传递,会非常有用。
下面是包裹位置传递的例子:
def func(*name): print type(name) print namefunc(1,4,6)func(5,6,7,1,2,3)
两次调用,尽管参数个数不同,都基于同一个func定义。在func的参数表中,所有的参数被name收集,根据位置合并成一个元组(tuple),这就是包裹位置传递。
为了提醒Python参数,name是包裹位置传递所用的元组名,在定义func时,在name前加*号。
下面是包裹关键字传递的例子:
def func(**dict): print type(dict) print dictfunc(a=1,b=9)func(m=2,n=1,c=11)
与上面一个例子类似,dict是一个字典,收集所有的关键字,传递给函数func。为了提醒Python,参数dict是包裹关键字传递所用的字典,在dict前加 * *。
包裹传递的关键在于定义函数时,在相应元组或字典前加 * 或 * * 。
4、解包裹
* 和 **,也可以在调用的时候使用,即解包裹(unpacking), 下面为例:
def func(a,b,c): print a,b,cargs = (1,3,4)func(*args)
在这个例子中,所谓的解包裹,就是在传递tuple时,让tuple的每一个元素对应一个位置参数。在调用func时使用 * ,是为了提醒Python:我想要把args拆成分散的三个元素,分别传递给a,b,c。(设想一下在调用func时,args前面没有 * 会是什么后果?)
相应的,也存在对词典的解包裹,使用相同的func定义,然后:
dict = {'a':1,'b':2,'c':3}func(**dict)
在传递词典dict时,让词典的每个键值对作为一个关键字传递给func。
5、混合
在定义或者调用参数时,参数的几种传递方式可以混合。但在过程中要小心前后顺序。基本原则是:先位置,再关键字,再包裹位置,再包裹关键字,并且根据上面所说的原理细细分辨。
一、循环设计
在“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()函数,可以在每次循环中同时得到下标和元素:
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]# clusterzipped = zip(ta,tb)print(zipped)# decomposena, nb = zip(*zipped)print(na, nb)
二、循环对象
这一讲的主要目的是为了大家在读Python程序的时候对循环对象有一个基本概念。
循环对象的并不是随着Python的诞生就存在的,但它的发展迅速,特别是Python 3x的时代,循环对象正在成为循环的标准形式。
1、什么是循环对象
循环对象是这样一个对象,它包含有一个next()方法 ( __next__() 方法,在python 3x中 ), 这个方法的目的是进行到下一个结果,而在结束一系列结果之后,举出StopIteration错误。
当一个循环结构(比如for)调用循环对象时,它就会每次循环的时候调用next()方法,直到StopIteration出现,for循环接收到,就知道循环已经结束,停止调用next()。
假设我们有一个test.txt的文件:
1234abcdefg
我们运行一下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)。函数也是一个对象,具有属性(可以使用dir()查询)。作为对象,它还可以赋值给其它对象名,或者作为参数传递。
1、lambda函数
在展开之前,我们先提一下lambda函数。可以利用lambda函数的语法,定义函数。lambda例子如下:
func = lambda x,y: x + yprint 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 Falseprint 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 ',iprint '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 StopIterationprint 'Hahaha'
这个例子不具备任何实际意义。只是为了说明raise语句的作用。
StopIteration是一个类。抛出异常时,会自动有一个中间环节,就是生成StopIteration的一个对象。Python实际上抛出的,是这个对象。当然,也可以自行生成对象:
raise StopIteration()
五、动态类型
动态类型(dynamic typing)是Python另一个重要的核心概念。我们之前说过,Python的变量(variable)不需要声明,而在赋值时,变量可以重新赋值为任意值。这些都与动态类型的概念相关。
1、动态类型
在我们接触的对象中,有一类特殊的对象,是用于存储数据的。常见的该类对象包括各种数字,字符串,表,词典。在C语言中,我们称这样一些数据结构为变量。而在Python中,这些是对象。
对象是储存在内存中的实体。但我们并不能直接接触到该对象。我们在程序中写的对象名,只是指向这一对象的引用(reference)。
引用和对象分离,是动态类型的核心。引用可以随时指向一个新的对象:
a = 3a = 'at'
第一个语句中,3是储存在内存中的一个整数对象。通过赋值,引用a指向对象3。
第二个语句中,内存中建立对象‘at’,是一个字符串(string)。引用a指向了'at'。此时,对象3不再有引用指向它。Python会自动将没有引用指向的对象销毁(destruct),释放相应内存。
(对于小的整数和短字符串,Python会缓存这些对象,而不是频繁的建立和销毁。)
a = 5b = aa = a + 2
再看这个例子。通过前两个句子,我们让a,b指向同一个整数对象5( b = a的含义是让引用b指向引用a所指的那一个对象)。但第三个句子实际上对引用a重新赋值,让a指向一个新的对象7。此时a,b分别指向不同的对象。我们看到,即使是多个引用指向同一个对象,如果一个引用值发生变化,那么实际上是让这个引用指向一个新的引用,并不影响其他的引用的指向。从效果上看,就是各个引用各自独立,互不影响。
其它数据对象也是如此:
L1 = [1,2,3]L2 = L1L1 = 1
但注意以下情况:
L1 = [1,2,3]L2 = L1L1[0] = 10print 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 xa = 1f(a)print a
参数x是一个新的引用,指向a所指的对象。如果参数是不可变(immutable)的对象,a和x引用之间相互独立。对参数x的操作不会影响引用a。这样的传递类似于C语言中的值传递。
如果传递的是可变(mutable)的对象,那么改变函数参数,有可能改变原对象。所有指向原对象的引用都会受影响,编程的时候要对此问题留心。比如说:
def f(x): x[0] = 100 print xa = [1,2,3]f(a)print a
动态类型是Python的核心机制之一。可以在应用中慢慢熟悉。
- Python进阶
- Python进阶
- Python 进阶
- Python进阶
- Python进阶
- Python -- 进阶
- python进阶
- python进阶
- python 进阶
- Python进阶
- python 进阶
- 【Python】进阶
- python 进阶
- Python进阶
- Python进阶
- python进阶
- python进阶
- Python进阶
- JS中Null与Undefined的区别
- css随笔
- Android学习规划指南
- [图像] 二值图像的位置、朝向与投影
- HDU3681 Prison Break(DP)
- python 进阶
- jquery实现锚点跳转
- Android基础--------广播
- Linux启动提示Kernel panic - not syncing: Attempted to kill init解决办法
- Mybatis-generator工具的使用
- SQL不同服务器数据库之间的数据操作整理(完整版)
- Spring Boot教程 - 2. Spring Boot提供的特性
- 关于服务被挖矿程序minerd入侵解决方法
- Adroid中Toast自定义显示时间