Python 2.7教程 5020次阅读 这是小白的Python新手教程。 Python是一种计算机程序设计语言。你可能已经听说过很多种流行的编程语言,比如非常难学的C语言,非常流行 的Java语言,适合初学者的Basic语言,适合网页编程的JavaScript语言等等。 那Python是一种什么语言? 首先,我们普及一下编程语言的基础知识。用任何编程语言来开发程序,都是为了让计算机干活,比如下载一个MP 3,编写一个文档等等,而计算机干活的CPU只认识机器指令,所以,尽管不同的编程语言差异极大,最后都得“翻 译”成CPU可以执行的机器指令。而不同的编程语言,干同一个活,编写的代码量,差距也很大。 比如,完成同一个任务,C语言要写1000行代码,Java只需要写100行,而Python可能只要20行。 所以Python是一种相当高级的语言。 你也许会问,代码少还不好?代码少的代价是运行速度慢,C程序运行1秒钟,Java程序可能需要2秒,而Python程 序可能就需要10秒。 那是不是越低级的程序越难学,越高级的程序越简单?表面上来说,是的,但是,在非常高的抽象计算中,高级的P ython程序设计也是非常难学的,所以,高级程序语言不等于简单。 但是,对于初学者和完成普通任务,Python语言是非常简单易用的。连Google都在大规模使用Python,你就不用担 心学了会没用。 用Python可以做什么?可以做日常任务,比如自动备份你的MP3;可以做网站,很多著名的网站包括YouTube就是 Python写的;可以做网络游戏的后台,很多在线游戏的后台都是Python开发的。总之就是能干很多很多事啦。 Python当然也有不能干的事情,比如写操作系统,这个只能用C语言写;写手机应用,只能用Objective­C(针对iPh one)和Java(针对Android);写3D游戏,最好用C或C++。 如果你是小白用户,满足以下条件: 会使用电脑,但从来没写过程序; 还记得初中数学学的方程式和一点点代数知识; 想从编程小白变成专业的软件架构师; 每天能抽出半个小时学习。 不要再犹豫了,这个教程就是为你准备的! 准备好了吗? 关于作者 廖雪峰,十年软件开发经验,业余产品经理,精通Java/Python/Ruby/Visual Basic/Objective C等,对开源框架有深 入研究,著有《Spring 2.0核心技术与最佳实践》一书,多个业余开源项目托管在GitHub,欢迎微博交流: 您的鼓励是作者写作最大的动力 如果您认为本网站的教程质量不错,读后觉得收获很大,预期工资涨幅能超过30%,不妨小额赞助我一下,让我有 动力继续写出高质量的教程: Python简介 481次阅读 Python是著名的“龟叔”Guido van Rossum在1989年圣诞节期间,为了打发无聊的圣诞节而编写的一个编程语言。 现在,全世界差不多有600多种编程语言,但流行的编程语言也就那么20来种。如果你听说过TIOBE排行榜,你就 能知道编程语言的大致流行程度。这是最近10年最常用的10种编程语言的变化图: 总的来说,这几种编程语言各有千秋。C语言是可以用来编写操作系统的贴近硬件的语言,所以,C语言适合开发那 些追求运行速度、充分发挥硬件性能的程序。而Python是用来编写应用程序的高级编程语言。 当你用一种语言开始作真正的软件开发时,你除了编写代码外,还需要很多基本的已经写好的现成的东西,来帮助 你加快开发进度。比如说,要编写一个电子邮件客户端,如果先从最底层开始编写网络协议相关的代码,那估计一 年半载也开发不出来。高级编程语言通常都会提供一个比较完善的基础代码库,让你能直接调用,比如,针对电子 邮件协议的SMTP库,针对桌面环境的GUI库,在这些已有的代码库的基础上开发,一个电子邮件客户端几天就能开 发出来。 Python就为我们提供了非常完善的基础代码库,覆盖了网络、文件、GUI、数据库、文本等大量内容,被形象地称 作“内置电池(batteries included)”。用Python开发,许多功能不必从零编写,直接使用现成的即可。 除了内置的库外,Python还有大量的第三方库,也就是别人开发的,供你直接使用的东西。当然,如果你开发的代 码通过很好的封装,也可以作为第三方库给别人使用。 许多大型网站就是用Python开发的,例如YouTube、Instagram,还有国内的豆瓣。很多大公司,包括Google、Ya hoo等,甚至NASA(美国航空航天局)都大量地使用Python。 龟叔给Python的定位是“优雅”、“明确”、“简单”,所以Python程序看上去总是简单易懂,初学者学Python,不但入门 容易,而且将来深入下去,可以编写那些非常非常复杂的程序。 总的来说,Python的哲学就是简单优雅,尽量写容易看明白的代码,尽量写少的代码。如果一个资深程序员向你炫 耀他写的晦涩难懂、动不动就几万行的代码,你可以尽情地嘲笑他。 那Python适合开发哪些类型的应用呢? 首选是网络应用,包括网站、后台服务等等; 其次是许多日常需要的小工具,包括系统管理员需要的脚本任务等等; 另外就是把其他语言开发的程序再包装起来,方便使用。 最后说说Python的缺点。 任何编程语言都有缺点,Python也不例外。优点说过了,那Python有哪些缺点呢? 第一个缺点就是运行速度慢,和C程序相比非常慢,因为Python是解释型语言,你的代码在执行时会一行一行地翻 译成CPU能理解的机器码,这个翻译过程非常耗时,所以很慢。而C程序是运行前直接编译成CPU能执行的机器 码,所以非常快。 但是大量的应用程序不需要这么快的运行速度,因为用户根本感觉不出来。例如开发一个下载MP3的网络应用程 序,C程序的运行时间需要0.001秒,而Python程序的运行时间需要0.1秒,慢了100倍,但由于网络更慢,需要等待 1秒,你想,用户能感觉到1.001秒和1.1秒的区别吗?这就好比F1赛车和普通的出租车在北京三环路上行驶的道理一 样,虽然F1赛车理论时速高达400公里,但由于三环路堵车的时速只有20公里,因此,作为乘客,你感觉的时速永 远是20公里。 第二个缺点就是代码不能加密。如果要发布你的Python程序,实际上就是发布源代码,这一点跟C语言不同,C语言 不用发布源代码,只需要把编译后的机器码(也就是你在Windows上常见的xxx.exe文件)发布出去。要从机器码反 推出C代码是不可能的,所以,凡是编译型的语言,都没有这个问题,而解释型的语言,则必须把源码发布出去。 这个缺点仅限于你要编写的软件需要卖给别人挣钱的时候。好消息是目前的互联网时代,靠卖软件授权的商业模式 越来越少了,靠网站和移动应用卖服务的模式越来越多了,后一种模式不需要把源码给别人。 再说了,现在如火如荼的开源运动和互联网自由开放的精神是一致的,互联网上有无数非常优秀的像Linux一样的开 源代码,我们千万不要高估自己写的代码真的有非常大的“商业价值”。那些大公司的代码不愿意开放的更重要的原因 是代码写得太烂了,一旦开源,就没人敢用他们的产品了。 当然,Python还有其他若干小缺点,请自行忽略,就不一一列举了。 您的鼓励是作者写作最大的动力 如果您认为本网站的教程质量不错,读后觉得收获很大,预期工资涨幅能超过30%,不妨小额赞助我一下,让我有 动力继续写出高质量的教程: 安装Python 407次阅读 因为Python是跨平台的,它可以运行在Windows、Mac和各种Linux/Unix系统上。在Windows上写Python程序,放 到Linux上也是能够运行的。 要开始学习Python编程,首先就得把Python安装到你的电脑里。安装后,你会得到Python解释器(就是负责运行Py thon程序的),一个命令行交互环境,还有一个简单的集成开发环境。 2.x还是3.x 目前,Python有两个版本,一个是2.x版,一个是3.x版,这两个版本是不兼容的,因为现在Python正在朝着3.x版本 进化,在进化过程中,大量的针对2.x版本的代码要修改后才能运行,所以,目前有许多第三方库还暂时无法在3.x上 使用。 为了保证你的程序能用到大量的第三方库,我们的教程仍以2.x版本为基础,确切地说,是2.7版本。请确保你的电脑 上安装的Python版本是2.7.x,这样,你才能无痛学习这个教程。 在Mac上安装Python 如果你正在使用Mac,系统是OS X 10.8或者最新的10.9 Mavericks,恭喜你,系统自带了Python 2.7。如果你的系 统版本低于10.8,请自行备份系统并免费升级到最新的10.9,就可以获得Python 2.7。 查看系统版本的办法是点击左上角的苹果图标,选择“关于本机”: 在Linux上安装Python 如果你正在使用Linux,那我可以假定你有Linux系统管理经验,自行安装Python 2.7应该没有问题,否则,请换回W indows系统。 对于大量的目前仍在使用Windows的同学,如果短期内没有打算换Mac,就可以继续阅读以下内容。 在Windows上安装Python 首先,从Python的官方网站www.python.org下载最新的2.7.9版本,地址是这个: http://www.python.org/ftp/python/2.7.9/python­2.7.9.msi 然后,运行下载的MSI安装包,在选择安装组件的一步时,勾上所有的组件: 特别要注意选上 pip 和 Add python.exe to Path ,然后一路点“Next”即可完成安装。 默认会安装到 C:\Python27 目录下,然后打开命令提示符窗口,敲入python后,会出现两种情况: 情况一: 看到上面的画面,就说明Python安装成功! 你看到提示符 >>> 就表示我们已经在Python交互式环境中了,可以输入任何Python代码,回车后会立刻得到执行结 果。现在,输入 exit() 并回车,就可以退出Python交互式环境(直接关掉命令行窗口也可以!)。 情况二:得到一个错误: ‘python’不是内部或外部命令,也不是可运行的程序或批处理文件。 这是因为Windows会根据一个 Path 的环境变量设定的路径去查找 python.exe ,如果没找到,就会报错。如果在安 这是因为Windows会根据一个 Path 的环境变量设定的路径去查找 python.exe ,如果没找到,就会报错。如果在安 装时漏掉了勾选 Add python.exe to Path ,那就要手动把 python.exe 所在的路径 C:\Python27 添加到Path中。 如果你不知道怎么修改环境变量,建议把Python安装程序重新运行一遍,记得勾上 Add python.exe to Path 。 小结 学会如何把Python安装到计算机中,并且熟练打开和退出Python交互式环境。 您的鼓励是作者写作最大的动力 如果您认为本网站的教程质量不错,读后觉得收获很大,预期工资涨幅能超过30%,不妨小额赞助我一下,让我有 动力继续写出高质量的教程: Python解释器 331次阅读 当我们编写Python代码时,我们得到的是一个包含Python代码的以 .py 为扩展名的文本文件。要运行代码,就需要 Python解释器去执行 .py 文件。 由于整个Python语言从规范到解释器都是开源的,所以理论上,只要水平够高,任何人都可以编写Python解释器来 执行Python代码(当然难度很大)。事实上,确实存在多种Python解释器。 CPython 当我们从Python官方网站下载并安装好Python 2.7后,我们就直接获得了一个官方版本的解释器:CPython。这个 解释器是用C语言开发的,所以叫CPython。在命令行下运行 python 就是启动CPython解释器。 CPython是使用最广的Python解释器。教程的所有代码也都在CPython下执行。 IPython IPython是基于CPython之上的一个交互式解释器,也就是说,IPython只是在交互方式上有所增强,但是执行Pytho n代码的功能和CPython是完全一样的。好比很多国产浏览器虽然外观不同,但内核其实都是调用了IE。 CPython用 >>> 作为提示符,而IPython用 In [序号]: 作为提示符。 PyPy PyPy是另一个Python解释器,它的目标是执行速度。PyPy采用JIT技术,对Python代码进行动态编译(注意不是解 释),所以可以显著提高Python代码的执行速度。 绝大部分Python代码都可以在PyPy下运行,但是PyPy和CPython有一些是不同的,这就导致相同的Python代码在两 种解释器下执行可能会有不同的结果。如果你的代码要放到PyPy下执行,就需要了解PyPy和CPython的不同点。 Jython Jython是运行在Java平台上的Python解释器,可以直接把Python代码编译成Java字节码执行。 IronPython IronPython和Jython类似,只不过IronPython是运行在微软.Net平台上的Python解释器,可以直接把Python代码编 译成.Net的字节码。 小结 Python的解释器很多,但使用最广泛的还是CPython。如果要和Java或.Net平台交互,最好的办法不是用Jython或Ir onPython,而是通过网络调用来交互,确保各程序之间的独立性。 本教程的所有代码只确保在CPython 2.7版本下运行。请务必在本地安装CPython(也就是从Python官方网站下载的 安装程序)。 此外,教程还内嵌一个IPython的Web版本,用来在浏览器内练习执行一些Python代码。要注意两者功能一样,输入 的代码一样,但是提示符有所不同。另外,不是所有代码都能在Web版本的IPython中执行,出于安全原因,很多操 作(比如文件操作)是受限的,所以有些代码必须在本地环境执行代码。 您的鼓励是作者写作最大的动力 如果您认为本网站的教程质量不错,读后觉得收获很大,预期工资涨幅能超过30%,不妨小额赞助我一下,让我有 动力继续写出高质量的教程: 第一个Python程序 322次阅读 现在,了解了如何启动和退出Python的交互式环境,我们就可以正式开始编写Python代码了。 在写代码之前,请千万不要用“复制”­“粘贴”把代码从页面粘贴到你自己的电脑上。写程序也讲究一个感觉,你需要一 个字母一个字母地把代码自己敲进去,在敲代码的过程中,初学者经常会敲错代码,所以,你需要仔细地检查、对 照,才能以最快的速度掌握如何写程序。 在交互式环境的提示符 >>> 下,直接输入代码,按回车,就可以立刻得到代码执行结果。现在,试试输 入 100+200 ,看看计算结果是不是300: >>> 100+200 300 很简单吧,任何有效的数学计算都可以算出来。 如果要让Python打印出指定的文字,可以用 print 语句,然后把希望打印的文字用单引号或者双引号括起来,但不 能混用单引号和双引号: >>> print 'hello, world' hello, world 这种用单引号或者双引号括起来的文本在程序中叫字符串,今后我们还会经常遇到。 最后,用 exit() 退出Python,我们的第一个Python程序完成!唯一的缺憾是没有保存下来,下次运行时还要再输 最后,用 exit() 退出Python,我们的第一个Python程序完成!唯一的缺憾是没有保存下来,下次运行时还要再输 入一遍代码。 小结 在Python交互式命令行下,可以直接输入代码,然后执行,并立刻得到结果。 您的鼓励是作者写作最大的动力 如果您认为本网站的教程质量不错,读后觉得收获很大,预期工资涨幅能超过30%,不妨小额赞助我一下,让我有 动力继续写出高质量的教程: 使用文本编辑器 382次阅读 在Python的交互式命令行写程序,好处是一下就能得到结果,坏处是没法保存,下次还想运行的时候,还得再敲一 遍。 所以,实际开发的时候,我们总是使用一个文本编辑器来写代码,写完了,保存为一个文件,这样,程序就可以反 复运行了。 现在,我们就把上次的 'hello, world' 程序用文本编辑器写出来,保存下来。 那么问题来了:文本编辑器到底哪家强? 推荐两款文本编辑器: 一个是Sublime Text,免费使用,但是不付费会弹出提示框: 一个是Notepad++,免费使用,有中文界面: 请注意,用哪个都行,但是绝对不能用Word和Windows自带的记事本。Word保存的不是纯文本文件,而记事本会 自作聪明地在文件开始的地方加上几个特殊字符(UTF­8 BOM),结果会导致程序运行出现莫名其妙的错误。 安装好文本编辑器后,输入以下代码: print 'hello, world' 注意 print 前面不要有任何空格。然后,选择一个目录,例如 C:\Workspace ,把文件保存为 hello.py ,就可以打 开命令行窗口,把当前目录切换到 hello.py 所在目录,就可以运行这个程序了: C:\Workspace>python hello.py hello, world 也可以保存为别的名字,比如 abc.py ,但是必须要以 .py 结尾,其他的都不行。此外,文件名只能是英文字母、数 字和下划线的组合。 如果当前目录下没有 hello.py 这个文件,运行 python hello.py 就会报错: python hello.py python: can't open file 'hello.py': [Errno 2] No such file or directory 报错的意思就是,无法打开 hello.py 这个文件,因为文件不存在。这个时候,就要检查一下当前目录下是否有这个 文件了。 文件了。 请注意区分命令行模式和Python交互模式: 看到类似 C:\> 是在Windows提供的命令行模式,看到 >>> 是在Python交互式环境下。 在命令行模式下,可以执行 python 进入Python交互式环境,也可以执行 python hello.py 运行一个 .py 文件,但是 在Python交互式环境下,只能输入Python代码执行。 直接运行py文件 还有同学问,能不能像.exe文件那样直接运行 .py 文件呢?在Windows上是不行的,但是,在Mac和Linux上是可以 的,方法是在 .py 文件的第一行加上: #!/usr/bin/env python 然后,通过命令: $ chmod a+x hello.py 就可以直接运行 hello.py 了,比如在Mac下运行: 小结 用文本编辑器写Python程序,然后保存为后缀为 .py 的文件,就可以用Python直接运行这个程序了。 Python的交互模式和直接运行 .py 文件有什么区别呢? 直接输入 python 进入交互模式,相当于启动了Python解释器,但是等待你一行一行地输入源代码,每输入一行就执 行一行。 直接运行 .py 文件相当于启动了Python解释器,然后一次性把 .py 文件的源代码给执行了,你是没有机会输入源代 码的。 用Python开发程序,完全可以一边在文本编辑器里写代码,一边开一个交互式命令窗口,在写代码的过程中,把部 分代码粘到命令行去验证,事半功倍!前提是得有个27'的超大显示器! 您的鼓励是作者写作最大的动力 如果您认为本网站的教程质量不错,读后觉得收获很大,预期工资涨幅能超过30%,不妨小额赞助我一下,让我有 动力继续写出高质量的教程: 输入和输出 346次阅读 输出 用 print 加上字符串,就可以向屏幕上输出指定的文字。比如输出 'hello, world' ,用代码实现如下: >>> print 'hello, world' print 语句也可以跟上多个字符串,用逗号“,”隔开,就可以连成一串输出: >>> print 'The quick brown fox', 'jumps over', 'the lazy dog' The quick brown fox jumps over the lazy dog print 会依次打印每个字符串,遇到逗号“,”会输出一个空格,因此,输出的字符串是这样拼起来的: print 也可以打印整数,或者计算结果: >>> print 300 300 >>> print 100 + 200 300 因此,我们可以把计算 100 + 200 的结果打印得更漂亮一点: >>> print '100 + 200 =', 100 + 200 100 + 200 = 300 注意,对于 100 + 200 ,Python解释器自动计算出结果 300 ,但是,'100 + 200 ='是字符串而非数学公式,Python 把它视为字符串,请自行解释上述打印结果。 输入 现在,你已经可以用 print 输出你想要的结果了。但是,如果要让用户从电脑输入一些字符怎么办?Python提供了 一个 raw_input ,可以让用户输入字符串,并存放到一个变量里。比如输入用户的名字: >>> name = raw_input() Michael 当你输入 name = raw_input() 并按下回车后,Python交互式命令行就在等待你的输入了。这时,你可以输入任意字 符,然后按回车后完成输入。 输入完成后,不会有任何提示,Python交互式命令行又回到 >>> 状态了。那我们刚才输入的内容到哪去了?答案是 存放到 name 变量里了。可以直接输入 name 查看变量内容: >>> name 'Michael' 什么是变量?请回忆初中数学所学的代数基础知识: 设正方形的边长为 a ,则正方形的面积为 a x a 。把边长 a 看做一个变量,我们就可以根据 a 的值计算正方形的面 积,比如: 若a=2,则面积为a x a = 2 x 2 = 4; 若a=3.5,则面积为a x a = 3.5 x 3.5 = 12.25。 在计算机程序中,变量不仅可以为整数或浮点数,还可以是字符串,因此, name 作为一个变量就是一个字符串。 要打印出 name 变量的内容,除了直接写 name 然后按回车外,还可以用 print 语句: >>> print name Michael 有了输入和输出,我们就可以把上次打印 'hello, world' 的程序改成有点意义的程序了: name = raw_input() print 'hello,', name 运行上面的程序,第一行代码会让用户输入任意字符作为自己的名字,然后存入 name 变量中;第二行代码会根据用 户的名字向用户说 hello ,比如输入 Michael : C:\Workspace> python hello.py Michael hello, Michael 但是程序运行的时候,没有任何提示信息告诉用户:“嘿,赶紧输入你的名字”,这样显得很不友好。幸 好, raw_input 可以让你显示一个字符串来提示用户,于是我们把代码改成: name = raw_input('please enter your name: ') print 'hello,', name 再次运行这个程序,你会发现,程序一运行,会首先打印出 please enter your name: ,这样,用户就可以根据提 示,输入名字后,得到 hello, xxx 的输出: C:\Workspace> python hello.py please enter your name: Michael hello, Michael 每次运行该程序,根据用户输入的不同,输出结果也会不同。 在命令行下,输入和输出就是这么简单。 小结 任何计算机程序都是为了执行一个特定的任务,有了输入,用户才能告诉计算机程序所需的信息,有了输出,程序 运行后才能告诉用户任务的结果。 输入是Input,输出是Output,因此,我们把输入输出统称为Input/Output,或者简写为IO。 raw_input 和 print 是在命令行下面最基本的输入和输出,但是,用户也可以通过其他更高级的图形界面完成输入 和输出,比如,在网页上的一个文本框输入自己的名字,点击“确定”后在网页上看到输出信息。 您的鼓励是作者写作最大的动力 如果您认为本网站的教程质量不错,读后觉得收获很大,预期工资涨幅能超过30%,不妨小额赞助我一下,让我有 动力继续写出高质量的教程: Python基础 205次阅读 Python是一种计算机编程语言。计算机编程语言和我们日常使用的自然语言有所不同,最大的区别就是,自然语言 在不同的语境下有不同的理解,而计算机要根据编程语言执行任务,就必须保证编程语言写出的程序决不能有歧 义,所以,任何一种编程语言都有自己的一套语法,编译器或者解释器就是负责把符合语法的程序代码转换成CPU 能够执行的机器码,然后执行。Python也不例外。 Python的语法比较简单,采用缩进方式,写出来的代码就像下面的样子: # print absolute value of an integer: a = 100 if a >= 0: print a else: print -a 以 # 开头的语句是注释,注释是给人看的,可以是任意内容,解释器会忽略掉注释。其他每一行都是一个语句,当 语句以冒号“:”结尾时,缩进的语句视为代码块。 缩进有利有弊。好处是强迫你写出格式化的代码,但没有规定缩进是几个空格还是Tab。按照约定俗成的管理,应该 始终坚持使用4个空格的缩进。 缩进的另一个好处是强迫你写出缩进较少的代码,你会倾向于把一段很长的代码拆分成若干函数,从而得到缩进较 少的代码。 缩进的坏处就是“复制-粘贴”功能失效了,这是最坑爹的地方。当你重构代码时,粘贴过去的代码必须重新检查缩进 是否正确。此外,IDE很难像格式化Java代码那样格式化Python代码。 最后,请务必注意,Python程序是大小写敏感的,如果写错了大小写,程序会报错。 您的鼓励是作者写作最大的动力 如果您认为本网站的教程质量不错,读后觉得收获很大,预期工资涨幅能超过30%,不妨小额赞助我一下,让我有 动力继续写出高质量的教程: 数据类型和变量 343次阅读 数据类型 计算机顾名思义就是可以做数学计算的机器,因此,计算机程序理所当然地可以处理各种数值。但是,计算机能处 理的远不止数值,还可以处理文本、图形、音频、视频、网页等各种各样的数据,不同的数据,需要定义不同的数 据类型。在Python中,能够直接处理的数据类型有以下几种: 整数 Python可以处理任意大小的整数,当然包括负整数,在程序中的表示方法和数学上的写法一模一样,例 Python可以处理任意大小的整数,当然包括负整数,在程序中的表示方法和数学上的写法一模一样,例 如: 1 , 100 , ‐8080 , 0 ,等等。 计算机由于使用二进制,所以,有时候用十六进制表示整数比较方便,十六进制用 0x 前缀和0­9,a­f表示,例 如: 0xff00 , 0xa5b4c3d2 ,等等。 浮点数 浮点数也就是小数,之所以称为浮点数,是因为按照科学记数法表示时,一个浮点数的小数点位置是可变的,比 如,1.23x10 和12.3x10 是相等的。浮点数可以用数学写法,如 1.23 , 3.14 , ‐9.01 ,等等。但是对于很大或很 小的浮点数,就必须用科学计数法表示,把10用e替代,1.23x10 就是 1.23e9 ,或者 12.3e8 ,0.000012可以写 成 1.2e‐5 ,等等。 整数和浮点数在计算机内部存储的方式是不同的,整数运算永远是精确的(除法难道也是精确的?是的!),而浮 点数运算则可能会有四舍五入的误差。 字符串 字符串是以''或""括起来的任意文本,比如 'abc' , "xyz" 等等。请注意,''或""本身只是一种表示方式,不是字符串 的一部分,因此,字符串 'abc' 只有 a , b , c 这3个字符。如果 ' 本身也是一个字符,那就可以用""括起来,比 如 "I'm OK" 包含的字符是 I , ' , m ,空格, O , K 这6个字符。 如果字符串内部既包含 ' 又包含 " 怎么办?可以用转义字符 \ 来标识,比如: 'I\'m \"OK\"!' 表示的字符串内容是: I'm "OK"! 转义字符 \ 可以转义很多字符,比如 \n 表示换行, \t 表示制表符,字符 \ 本身也要转义,所以 \\ 表示的字符就 是 \ ,可以在Python的交互式命令行用print打印字符串看看: >>> print 'I\'m ok.' I'm ok. >>> print 'I\'m learning\nPython.' I'm learning Python. >>> print '\\\n\\' \ \ 如果字符串里面有很多字符都需要转义,就需要加很多 \ ,为了简化,Python还允许用 r'' 表示 '' 内部的字符串 默认不转义,可以自己试试: >>> print '\\\t\\' \ \ >>> print r'\\\t\\' \\\t\\ 如果字符串内部有很多换行,用 \n 写在一行里不好阅读,为了简化,Python允许用 '''...''' 的格式表示多行内 9 8 9 如果字符串内部有很多换行,用 \n 写在一行里不好阅读,为了简化,Python允许用 '''...''' 的格式表示多行内 容,可以自己试试: >>> print '''line1 ... line2 ... line3''' line1 line2 line3 上面是在交互式命令行内输入,如果写成程序,就是: print '''line1 line2 line3''' 多行字符串 '''...''' 还可以在前面加上 r 使用,请自行测试。 布尔值 布尔值和布尔代数的表示完全一致,一个布尔值只有 True 、 False 两种值,要么是 True ,要么是 False ,在Pyth on中,可以直接用 True 、 False 表示布尔值(请注意大小写),也可以通过布尔运算计算出来: >>> True True >>> False False >>> 3 > 2 True >>> 3 > 5 False 布尔值可以用 and 、 or 和 not 运算。 and 运算是与运算,只有所有都为 True , and 运算结果才是 True : >>> True and True True >>> True and False False >>> False and False False or 运算是或运算,只要其中有一个为 True , or 运算结果就是 True : >>> True or True True >>> True or False True >>> False or False False not 运算是非运算,它是一个单目运算符,把 True 变成 False , False 变成 True : >>> not True False >>> not False True 布尔值经常用在条件判断中,比如: if age >= 18: print 'adult' else: print 'teenager' 空值 空值是Python里一个特殊的值,用 None 表示。 None 不能理解为 0 ,因为 0 是有意义的,而 None 是一个特殊的空 值。 此外,Python还提供了列表、字典等多种数据类型,还允许创建自定义数据类型,我们后面会继续讲到。 变量 变量的概念基本上和初中代数的方程变量是一致的,只是在计算机程序中,变量不仅可以是数字,还可以是任意数 据类型。 变量在程序中就是用一个变量名表示了,变量名必须是大小写英文、数字和 _ 的组合,且不能用数字开头,比如: a = 1 变量 a 是一个整数。 t_007 = 'T007' 变量 t_007 是一个字符串。 Answer = True 变量 Answer 是一个布尔值 True 。 在Python中,等号 = 是赋值语句,可以把任意数据类型赋值给变量,同一个变量可以反复赋值,而且可以是不同类 型的变量,例如: a = 123 # a是整数 print a a = 'ABC' # a变为字符串 print a 这种变量本身类型不固定的语言称之为动态语言,与之对应的是静态语言。静态语言在定义变量时必须指定变量类 型,如果赋值的时候类型不匹配,就会报错。例如Java是静态语言,赋值语句如下(// 表示注释): int a = 123; // a是整数类型变量 a = "ABC"; // 错误:不能把字符串赋给整型变量 和静态语言相比,动态语言更灵活,就是这个原因。 请不要把赋值语句的等号等同于数学的等号。比如下面的代码: x = 10 x = x + 2 如果从数学上理解 x = x + 2 那无论如何是不成立的,在程序中,赋值语句先计算右侧的表达式 x + 2 ,得到结 果 12 ,再赋给变量 x 。由于 x 之前的值是 10 ,重新赋值后, x 的值变成 12 。 最后,理解变量在计算机内存中的表示也非常重要。当我们写: a = 'ABC' 时,Python解释器干了两件事情: 1.  在内存中创建了一个 'ABC' 的字符串; 2.  在内存中创建了一个名为 a 的变量,并把它指向 'ABC' 。 也可以把一个变量 a 赋值给另一个变量 b ,这个操作实际上是把变量 b 指向变量 a 所指向的数据,例如下面的代 码: a = 'ABC' b = a a = 'XYZ' print b 最后一行打印出变量 b 的内容到底是 'ABC' 呢还是 'XYZ' ?如果从数学意义上理解,就会错误地得出 b 和 a 相 同,也应该是 'XYZ' ,但实际上 b 的值是 'ABC' ,让我们一行一行地执行代码,就可以看到到底发生了什么事: 执行 a = 'ABC' ,解释器创建了字符串 'ABC' 和变量 a ,并把 a 指向 'ABC' : 执行 b = a ,解释器创建了变量 b ,并把 b 指向 a 指向的字符串 'ABC' : 执行 a = 'XYZ' ,解释器创建了字符串'XYZ',并把 a 的指向改为 'XYZ' ,但 b 并没有更改: 所以,最后打印变量 b 的结果自然是 'ABC' 了。 常量 所谓常量就是不能变的变量,比如常用的数学常数π就是一个常量。在Python中,通常用全部大写的变量名表示常 量: PI = 3.14159265359 但事实上 PI 仍然是一个变量,Python根本没有任何机制保证 PI 不会被改变,所以,用全部大写的变量名表示常量 只是一个习惯上的用法,如果你一定要改变变量 PI 的值,也没人能拦住你。 最后解释一下整数的除法为什么也是精确的,可以试试: >>> 10 / 3 3 你没有看错,整数除法永远是整数,即使除不尽。要做精确的除法,只需把其中一个整数换成浮点数做除法就可 以: >>> 10.0 / 3 3.3333333333333335 因为整数除法只取结果的整数部分,所以Python还提供一个余数运算,可以得到两个整数相除的余数: >>> 10 % 3 1 无论整数做除法还是取余数,结果永远是整数,所以,整数运算结果永远是精确的。 小结 Python支持多种数据类型,在计算机内部,可以把任何数据都看成一个“对象”,而变量就是在程序中用来指向这些 数据对象的,对变量赋值就是把数据和变量给关联起来。 您的鼓励是作者写作最大的动力 如果您认为本网站的教程质量不错,读后觉得收获很大,预期工资涨幅能超过30%,不妨小额赞助我一下,让我有 动力继续写出高质量的教程: 字符串和编码 335次阅读 字符编码 我们已经讲过了,字符串也是一种数据类型,但是,字符串比较特殊的是还有一个编码问题。 因为计算机只能处理数字,如果要处理文本,就必须先把文本转换为数字才能处理。最早的计算机在设计时采用8个 比特(bit)作为一个字节(byte),所以,一个字节能表示的最大的整数就是255(二进制11111111=十进制25 5),如果要表示更大的整数,就必须用更多的字节。比如两个字节可以表示的最大整数是 65535 ,4个字节可以表 示的最大整数是 4294967295 。 由于计算机是美国人发明的,因此,最早只有127个字母被编码到计算机里,也就是大小写英文字母、数字和一些符 号,这个编码表被称为 ASCII 编码,比如大写字母 A 的编码是 65 ,小写字母 z 的编码是 122 。 但是要处理中文显然一个字节是不够的,至少需要两个字节,而且还不能和ASCII编码冲突,所以,中国制定 了 GB2312 编码,用来把中文编进去。 你可以想得到的是,全世界有上百种语言,日本把日文编到 Shift_JIS 里,韩国把韩文编到 Euc‐kr 里,各国有各国 的标准,就会不可避免地出现冲突,结果就是,在多语言混合的文本中,显示出来会有乱码。 因此,Unicode应运而生。Unicode把所有语言都统一到一套编码里,这样就不会再有乱码问题了。 Unicode标准也在不断发展,但最常用的是用两个字节表示一个字符(如果要用到非常偏僻的字符,就需要4个字 节)。现代操作系统和大多数编程语言都直接支持Unicode。 现在,捋一捋ASCII编码和Unicode编码的区别:ASCII编码是1个字节,而Unicode编码通常是2个字节。 字母 A 用ASCII编码是十进制的 65 ,二进制的 01000001 ; 字符 0 用ASCII编码是十进制的 48 ,二进制的 00110000 ,注意字符 '0' 和整数 0 是不同的; 汉字 中 已经超出了ASCII编码的范围,用Unicode编码是十进制的 20013 ,二进制的 01001110 00101101 。 你可以猜测,如果把ASCII编码的 A 用Unicode编码,只需要在前面补0就可以,因此, A 的Unicode编码 是 00000000 01000001 。 新的问题又出现了:如果统一成Unicode编码,乱码问题从此消失了。但是,如果你写的文本基本上全部是英文的 话,用Unicode编码比ASCII编码需要多一倍的存储空间,在存储和传输上就十分不划算。 所以,本着节约的精神,又出现了把Unicode编码转化为“可变长编码”的 UTF‐8 编码。UTF­8编码把一个Unicode字 符根据不同的数字大小编码成1­6个字节,常用的英文字母被编码成1个字节,汉字通常是3个字节,只有很生僻的字 符根据不同的数字大小编码成1­6个字节,常用的英文字母被编码成1个字节,汉字通常是3个字节,只有很生僻的字 符才会被编码成4­6个字节。如果你要传输的文本包含大量英文字符,用UTF­8编码就能节省空间: 字符 ASCII Unicode UTF­8 A 01000001 00000000 01000001 01000001 中 x 01001110 00101101 11100100 10111000 10101101 从上面的表格还可以发现,UTF­8编码有一个额外的好处,就是ASCII编码实际上可以被看成是UTF­8编码的一部 分,所以,大量只支持ASCII编码的历史遗留软件可以在UTF­8编码下继续工作。 搞清楚了ASCII、Unicode和UTF­8的关系,我们就可以总结一下现在计算机系统通用的字符编码工作方式: 在计算机内存中,统一使用Unicode编码,当需要保存到硬盘或者需要传输的时候,就转换为UTF­8编码。 用记事本编辑的时候,从文件读取的UTF­8字符被转换为Unicode字符到内存里,编辑完成后,保存的时候再把Unic ode转换为UTF­8保存到文件: 浏览网页的时候,服务器会把动态生成的Unicode内容转换为UTF­8再传输到浏览器: 所以你看到很多网页的源码上会有类似 的信息,表示该网页正是用的UTF­8编码。 Python的字符串 搞清楚了令人头疼的字符编码问题后,我们再来研究Python对Unicode的支持。 搞清楚了令人头疼的字符编码问题后,我们再来研究Python对Unicode的支持。 因为Python的诞生比Unicode标准发布的时间还要早,所以最早的Python只支持ASCII编码,普通的字符串 'ABC' 在 Python内部都是ASCII编码的。Python提供了ord()和chr()函数,可以把字母和对应的数字相互转换: >>> ord('A') 65 >>> chr(65) 'A' Python在后来添加了对Unicode的支持,以Unicode表示的字符串用 u'...' 表示,比如: >>> print u'中文' 中文 >>> u'中' u'\u4e2d' 写 u'中' 和 u'\u4e2d' 是一样的, \u 后面是十六进制的Unicode码。因此, u'A' 和 u'\u0041' 也是一样的。 两种字符串如何相互转换?字符串 'xxx' 虽然是ASCII编码,但也可以看成是UTF­8编码,而 u'xxx' 则只能是Unico de编码。 把 u'xxx' 转换为UTF­8编码的 'xxx' 用 encode('utf‐8') 方法: >>> u'ABC'.encode('utf-8') 'ABC' >>> u'中文'.encode('utf-8') '\xe4\xb8\xad\xe6\x96\x87' 英文字符转换后表示的UTF­8的值和Unicode值相等(但占用的存储空间不同),而中文字符转换后1个Unicode字 符将变为3个UTF­8字符,你看到的 \xe4 就是其中一个字节,因为它的值是 228 ,没有对应的字母可以显示,所以 以十六进制显示字节的数值。 len() 函数可以返回字符串的长度: >>> len(u'ABC') 3 >>> len('ABC') 3 >>> len(u'中文') 2 >>> len('\xe4\xb8\xad\xe6\x96\x87') 6 反过来,把UTF­8编码表示的字符串 'xxx' 转换为Unicode字符串 u'xxx' 用 decode('utf‐8') 方法: >>> 'abc'.decode('utf-8') u'abc' >>> '\xe4\xb8\xad\xe6\x96\x87'.decode('utf-8') u'\u4e2d\u6587' >>> print '\xe4\xb8\xad\xe6\x96\x87'.decode('utf-8') 中文 由于Python源代码也是一个文本文件,所以,当你的源代码中包含中文的时候,在保存源代码时,就需要务必指定 由于Python源代码也是一个文本文件,所以,当你的源代码中包含中文的时候,在保存源代码时,就需要务必指定 保存为UTF­8编码。当Python解释器读取源代码时,为了让它按UTF­8编码读取,我们通常在文件开头写上这两 行: #!/usr/bin/env python # -*- coding: utf-8 -*- 第一行注释是为了告诉Linux/OS X系统,这是一个Python可执行程序,Windows系统会忽略这个注释; 第二行注释是为了告诉Python解释器,按照UTF­8编码读取源代码,否则,你在源代码中写的中文输出可能会有乱 码。 如果你使用Notepad++进行编辑,除了要加上 # ‐*‐ coding: utf‐8 ‐*‐ 外,中文字符串必须是Unicode字符串: 申明了UTF­8编码并不意味着你的 .py 文件就是UTF­8编码的,必须并且要确保Notepad++正在使用UTF­8 without  BOM编码: 如果 .py 文件本身使用UTF­8编码,并且也申明了 # ‐*‐ coding: utf‐8 ‐*‐ ,打开命令提示符测试就可以正常显示 中文: 格式化 最后一个常见的问题是如何输出格式化的字符串。我们经常会输出类 似 '亲爱的xxx你好!你xx月的话费是xx,余额是xx' 之类的字符串,而xxx的内容都是根据变量变化的,所以,需要一种 简便的格式化字符串的方式。 在Python中,采用的格式化方式和C语言是一致的,用 % 实现,举例如下: >>> 'Hello, %s' % 'world' 'Hello, world' >>> 'Hi, %s, you have $%d.' % ('Michael', 1000000) 'Hi, Michael, you have $1000000.' 你可能猜到了, % 运算符就是用来格式化字符串的。在字符串内部, %s 表示用字符串替换, %d 表示用整数替 换,有几个 %? 占位符,后面就跟几个变量或者值,顺序要对应好。如果只有一个 %? ,括号可以省略。 常见的占位符有: %d 整数 %f 浮点数 %s 字符串 %x 十六进制整数 其中,格式化整数和浮点数还可以指定是否补0和整数与小数的位数: >>> '%2d-%02d' % (3, 1) ' 3-01' >>> '%.2f' % 3.1415926 '3.14' 如果你不太确定应该用什么, %s 永远起作用,它会把任何数据类型转换为字符串: >>> 'Age: %s. Gender: %s' % (25, True) 'Age: 25. Gender: True' 对于Unicode字符串,用法完全一样,但最好确保替换的字符串也是Unicode字符串: >>> u'Hi, %s' % u'Michael' u'Hi, Michael' 有些时候,字符串里面的 % 是一个普通字符怎么办?这个时候就需要转义,用 %% 来表示一个 % : >>> 'growth rate: %d %%' % 7 'growth rate: 7 %' 小结 由于历史遗留问题,Python 2.x版本虽然支持Unicode,但在语法上需要 'xxx' 和 u'xxx' 两种字符串表示方式。 Python当然也支持其他编码方式,比如把Unicode编码成GB2312: >>> u'中文'.encode('gb2312') '\xd6\xd0\xce\xc4' 但这种方式纯属自找麻烦,如果没有特殊业务要求,请牢记仅使用Unicode和UTF­8这两种编码方式。 在Python 3.x版本中,把 'xxx' 和 u'xxx' 统一成Unicode编码,即写不写前缀 u 都是一样的,而以字节形式表示的 字符串则必须加上 b 前缀: b'xxx' 。 格式化字符串的时候,可以用Python的交互式命令行测试,方便快捷。 您的鼓励是作者写作最大的动力 如果您认为本网站的教程质量不错,读后觉得收获很大,预期工资涨幅能超过30%,不妨小额赞助我一下,让我有 动力继续写出高质量的教程: 使用list和tuple 325次阅读 list Python内置的一种数据类型是列表:list。list是一种有序的集合,可以随时添加和删除其中的元素。 比如,列出班里所有同学的名字,就可以用一个list表示: >>> classmates = ['Michael', 'Bob', 'Tracy'] >>> classmates ['Michael', 'Bob', 'Tracy'] 变量 classmates 就是一个list。用 len() 函数可以获得list元素的个数: >>> len(classmates) 3 用索引来访问list中每一个位置的元素,记得索引是从 0 开始的: >>> classmates[0] 'Michael' >>> classmates[1] 'Bob' >>> classmates[2] 'Tracy' >>> classmates[3] Traceback (most recent call last): File "", line 1, in IndexError: list index out of range 当索引超出了范围时,Python会报一个IndexError错误,所以,要确保索引不要越界,记得最后一个元素的索引 是 len(classmates) ‐ 1 。 如果要取最后一个元素,除了计算索引位置外,还可以用 ‐1 做索引,直接获取最后一个元素: >>> classmates[-1] 'Tracy' 以此类推,可以获取倒数第2个、倒数第3个: >>> classmates[-2] 'Bob' >>> classmates[-3] 'Michael' >>> classmates[-4] Traceback (most recent call last): File "", line 1, in IndexError: list index out of range 当然,倒数第4个就越界了。 list是一个可变的有序表,所以,可以往list中追加元素到末尾: >>> classmates.append('Adam') >>> classmates ['Michael', 'Bob', 'Tracy', 'Adam'] 也可以把元素插入到指定的位置,比如索引号为 1 的位置: >>> classmates.insert(1, 'Jack') >>> classmates ['Michael', 'Jack', 'Bob', 'Tracy', 'Adam'] 要删除list末尾的元素,用 pop() 方法: >>> classmates.pop() 'Adam' >>> classmates ['Michael', 'Jack', 'Bob', 'Tracy'] 要删除指定位置的元素,用 pop(i) 方法,其中 i 是索引位置: >>> classmates.pop(1) 'Jack' >>> classmates ['Michael', 'Bob', 'Tracy'] 要把某个元素替换成别的元素,可以直接赋值给对应的索引位置: >>> classmates[1] = 'Sarah' >>> classmates ['Michael', 'Sarah', 'Tracy'] list里面的元素的数据类型也可以不同,比如: >>> L = ['Apple', 123, True] list元素也可以是另一个list,比如: >>> s = ['python', 'java', ['asp', 'php'], 'scheme'] >>> len(s) 4 要注意 s 只有4个元素,其中 s[2] 又是一个list,如果拆开写就更容易理解了: >>> p = ['asp', 'php'] >>> s = ['python', 'java', p, 'scheme'] 要拿到 'php' 可以写 p[1] 或者 s[2][1] ,因此 s 可以看成是一个二维数组,类似的还有三维、四维……数组,不 过很少用到。 如果一个list中一个元素也没有,就是一个空的list,它的长度为0: >>> L = [] >>> len(L) 0 tuple 另一种有序列表叫元组:tuple。tuple和list非常类似,但是tuple一旦初始化就不能修改,比如同样是列出同学的名 字: >>> classmates = ('Michael', 'Bob', 'Tracy') 现在,classmates这个tuple不能变了,它也没有append(),insert()这样的方法。其他获取元素的方法和list是一样 的,你可以正常地使用 classmates[0] , classmates[‐1] ,但不能赋值成另外的元素。 不可变的tuple有什么意义?因为tuple不可变,所以代码更安全。如果可能,能用tuple代替list就尽量用tuple。 tuple的陷阱:当你定义一个tuple时,在定义的时候,tuple的元素就必须被确定下来,比如: >>> t = (1, 2) >>> t (1, 2) 如果要定义一个空的tuple,可以写成 () : >>> t = () >>> t () 但是,要定义一个只有1个元素的tuple,如果你这么定义: >>> t = (1) >>> t 1 定义的不是tuple,是 1 这个数!这是因为括号 () 既可以表示tuple,又可以表示数学公式中的小括号,这就产生了 歧义,因此,Python规定,这种情况下,按小括号进行计算,计算结果自然是 1 。 所以,只有1个元素的tuple定义时必须加一个逗号 , ,来消除歧义: >>> t = (1,) >>> t (1,) Python在显示只有1个元素的tuple时,也会加一个逗号 , ,以免你误解成数学计算意义上的括号。 最后来看一个“可变的”tuple: >>> t = ('a', 'b', ['A', 'B']) >>> t[2][0] = 'X' >>> t[2][1] = 'Y' >>> t ('a', 'b', ['X', 'Y']) 这个tuple定义的时候有3个元素,分别是 'a' , 'b' 和一个list。不是说tuple一旦定义后就不可变了吗?怎么后来又 变了? 别急,我们先看看定义的时候tuple包含的3个元素: 当我们把list的元素 'A' 和 'B' 修改为 'X' 和 'Y' 后,tuple变为: 表面上看,tuple的元素确实变了,但其实变的不是tuple的元素,而是list的元素。tuple一开始指向的list并没有改成 别的list,所以,tuple所谓的“不变”是说,tuple的每个元素,指向永远不变。即指向 'a' ,就不能改成指向 'b' ,指 向一个list,就不能改成指向其他对象,但指向的这个list本身是可变的! 理解了“指向不变”后,要创建一个内容也不变的tuple怎么做?那就必须保证tuple的每一个元素本身也不能变。 小结 list和tuple是Python内置的有序集合,一个可变,一个不可变。根据需要来选择使用它们。 您的鼓励是作者写作最大的动力 您的鼓励是作者写作最大的动力 如果您认为本网站的教程质量不错,读后觉得收获很大,预期工资涨幅能超过30%,不妨小额赞助我一下,让我有 动力继续写出高质量的教程: 条件判断和循环 277次阅读 条件判断 计算机之所以能做很多自动化的任务,因为它可以自己做条件判断。 比如,输入用户年龄,根据年龄打印不同的内容,在Python程序中,用 if 语句实现: age = 20 if age >= 18: print 'your age is', age print 'adult' 根据Python的缩进规则,如果 if 语句判断是 True ,就把缩进的两行print语句执行了,否则,什么也不做。 也可以给 if 添加一个 else 语句,意思是,如果 if 判断是 False ,不要执行 if 的内容,去把 else 执行了: age = 3 if age >= 18: print 'your age is', age print 'adult' else: print 'your age is', age print 'teenager' 注意不要少写了冒号 : 。 当然上面的判断是很粗略的,完全可以用 elif 做更细致的判断: age = 3 if age >= 18: print 'adult' elif age >= 6: print 'teenager' else: print 'kid' elif 是 else if 的缩写,完全可以有多个 elif ,所以 if 语句的完整形式就是: if <条件判断1>: <执行1> elif <条件判断2>: <执行2> elif <条件判断3>: elif <条件判断3>: <执行3> else: <执行4> if 语句执行有个特点,它是从上往下判断,如果在某个判断上是 True ,把该判断对应的语句执行后,就忽略掉剩 下的 elif 和 else ,所以,请测试并解释为什么下面的程序打印的是 teenager : age = 20 if age >= 6: print 'teenager' elif age >= 18: print 'adult' else: print 'kid' if 判断条件还可以简写,比如写: if x: print 'True' 只要 x 是非零数值、非空字符串、非空list等,就判断为 True ,否则为 False 。 循环 Python的循环有两种,一种是for...in循环,依次把list或tuple中的每个元素迭代出来,看例子: names = ['Michael', 'Bob', 'Tracy'] for name in names: print name 执行这段代码,会依次打印 names 的每一个元素: Michael Bob Tracy 所以 for x in ... 循环就是把每个元素代入变量 x ,然后执行缩进块的语句。 再比如我们想计算1­10的整数之和,可以用一个 sum 变量做累加: sum = 0 for x in [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]: sum = sum + x print sum 如果要计算1­100的整数之和,从1写到100有点困难,幸好Python提供一个range()函数,可以生成一个整数序 列,比如range(5)生成的序列是从0开始小于5的整数: >>> range(5) >>> range(5) [0, 1, 2, 3, 4] range(101)就可以生成0­100的整数序列,计算如下: sum = 0 for x in range(101): sum = sum + x print sum 请自行运行上述代码,看看结果是不是当年高斯同学心算出的5050。 第二种循环是while循环,只要条件满足,就不断循环,条件不满足时退出循环。比如我们要计算100以内所有奇数 之和,可以用while循环实现: sum = 0 n = 99 while n > 0: sum = sum + n n = n - 2 print sum 在循环内部变量 n 不断自减,直到变为 ‐1 时,不再满足while条件,循环退出。 再议raw_input 最后看一个有问题的条件判断。很多同学会用 raw_input() 读取用户的输入,这样可以自己输入,程序运行得更有 意思: birth = raw_input('birth: ') if birth < 2000: print '00前' else: print '00后' 输入 1982 ,结果却显示 00后 ,这么简单的判断Python也能搞错? 当然不是Python的问题,在Python的交互式命令行下打印 birth 看看: >>> birth '1982' >>> '1982' < 2000 False >>> 1982 < 2000 True 原因找到了!原来从 raw_input() 读取的内容永远以字符串的形式返回,把字符串和整数比较就不会得到期待的结 果,必须先用 int() 把字符串转换为我们想要的整型: birth = int(raw_input('birth: ')) 再次运行,就可以得到正确地结果。但是,如果输入 abc 呢?又会得到一个错误信息: Traceback (most recent call last): ... ValueError: invalid literal for int() with base 10: 'abc' 原来 int() 发现一个字符串并不是合法的数字时就会报错,程序就退出了。 如何检查并捕获程序运行期的错误呢?后面的错误和调试会讲到。 小结 条件判断可以让计算机自己做选择,Python的if...elif...else很灵活。 循环是让计算机做重复任务的有效的方法,有些时候,如果代码写得有问题,会让程序陷入“死循环”,也就是永远循 环下去。这时可以用 Ctrl+C 退出程序,或者强制结束Python进程。 请试写一个死循环程序。 您的鼓励是作者写作最大的动力 如果您认为本网站的教程质量不错,读后觉得收获很大,预期工资涨幅能超过30%,不妨小额赞助我一下,让我有 动力继续写出高质量的教程: 使用dict和set 262次阅读 dict Python内置了字典:dict的支持,dict全称dictionary,在其他语言中也称为map,使用键­值(key­value)存储,具 有极快的查找速度。 举个例子,假设要根据同学的名字查找对应的成绩,如果用list实现,需要两个list: 举个例子,假设要根据同学的名字查找对应的成绩,如果用list实现,需要两个list: names = ['Michael', 'Bob', 'Tracy'] scores = [95, 75, 85] 给定一个名字,要查找对应的成绩,就先要在names中找到对应的位置,再从scores取出对应的成绩,list越长,耗 时越长。 如果用dict实现,只需要一个“名字”­“成绩”的对照表,直接根据名字查找成绩,无论这个表有多大,查找速度都不会 变慢。用Python写一个dict如下: >>> d = {'Michael': 95, 'Bob': 75, 'Tracy': 85} >>> d['Michael'] 95 为什么dict查找速度这么快?因为dict的实现原理和查字典是一样的。假设字典包含了1万个汉字,我们要查某一个 字,一个办法是把字典从第一页往后翻,直到找到我们想要的字为止,这种方法就是在list中查找元素的方法,list越 大,查找越慢。 第二种方法是先在字典的索引表里(比如部首表)查这个字对应的页码,然后直接翻到该页,找到这个字,无论找 哪个字,这种查找速度都非常快,不会随着字典大小的增加而变慢。 dict就是第二种实现方式,给定一个名字,比如 'Michael' ,dict在内部就可以直接计算出 Michael 对应的存放成绩 的“页码”,也就是 95 这个数字存放的内存地址,直接取出来,所以速度非常快。 你可以猜到,这种key­value存储方式,在放进去的时候,必须根据key算出value的存放位置,这样,取的时候才能 根据key直接拿到value。 把数据放入dict的方法,除了初始化时指定外,还可以通过key放入: >>> d['Adam'] = 67 >>> d['Adam'] 67 由于一个key只能对应一个value,所以,多次对一个key放入value,后面的值会把前面的值冲掉: >>> d['Jack'] = 90 >>> d['Jack'] 90 >>> d['Jack'] = 88 >>> d['Jack'] 88 如果key不存在,dict就会报错: >>> d['Thomas'] Traceback (most recent call last): File "", line 1, in KeyError: 'Thomas' 要避免key不存在的错误,有两种办法,一是通过 in 判断key是否存在: >>> 'Thomas' in d False 二是通过dict提供的get方法,如果key不存在,可以返回None,或者自己指定的value: >>> d.get('Thomas') >>> d.get('Thomas', -1) -1 注意:返回None的时候Python的交互式命令行不显示结果。 要删除一个key,用 pop(key) 方法,对应的value也会从dict中删除: >>> d.pop('Bob') 75 >>> d {'Michael': 95, 'Tracy': 85} 请务必注意,dict内部存放的顺序和key放入的顺序是没有关系的。 和list比较,dict有以下几个特点: 1.  查找和插入的速度极快,不会随着key的增加而增加; 2.  需要占用大量的内存,内存浪费多。 而list相反: 1.  查找和插入的时间随着元素的增加而增加; 2.  占用空间小,浪费内存很少。 所以,dict是用空间来换取时间的一种方法。 dict可以用在需要高速查找的很多地方,在Python代码中几乎无处不在,正确使用dict非常重要,需要牢记的第一条 就是dict的key必须是不可变对象。 这是因为dict根据key来计算value的存储位置,如果每次计算相同的key得出的结果不同,那dict内部就完全混乱 了。这个通过key计算位置的算法称为哈希算法(Hash)。 要保证hash的正确性,作为key的对象就不能变。在Python中,字符串、整数等都是不可变的,因此,可以放心地 作为key。而list是可变的,就不能作为key: >>> key = [1, 2, 3] >>> d[key] = 'a list' Traceback (most recent call last): File "", line 1, in TypeError: unhashable type: 'list' set set和dict类似,也是一组key的集合,但不存储value。由于key不能重复,所以,在set中,没有重复的key。 要创建一个set,需要提供一个list作为输入集合: 要创建一个set,需要提供一个list作为输入集合: >>> s = set([1, 2, 3]) >>> s set([1, 2, 3]) 注意,传入的参数 [1, 2, 3] 是一个list,而显示的 set([1, 2, 3]) 只是告诉你这个set内部有1,2,3这3个元 素,显示的[]不表示这是一个list。 重复元素在set中自动被过滤: >>> s = set([1, 1, 2, 2, 3, 3]) >>> s set([1, 2, 3]) 通过 add(key) 方法可以添加元素到set中,可以重复添加,但不会有效果: >>> s.add(4) >>> s set([1, 2, 3, 4]) >>> s.add(4) >>> s set([1, 2, 3, 4]) 通过 remove(key) 方法可以删除元素: >>> s.remove(4) >>> s set([1, 2, 3]) set可以看成数学意义上的无序和无重复元素的集合,因此,两个set可以做数学意义上的交集、并集等操作: >>> s1 = set([1, 2, 3]) >>> s2 = set([2, 3, 4]) >>> s1 & s2 set([2, 3]) >>> s1 | s2 set([1, 2, 3, 4]) set和dict的唯一区别仅在于没有存储对应的value,但是,set的原理和dict一样,所以,同样不可以放入可变对 象,因为无法判断两个可变对象是否相等,也就无法保证set内部“不会有重复元素”。试试把list放入set,看看是否会 报错。 再议不可变对象 上面我们讲了,str是不变对象,而list是可变对象。 对于可变对象,比如list,对list进行操作,list内部的内容是会变化的,比如: >>> a = ['c', 'b', 'a'] >>> a.sort() >>> a ['a', 'b', 'c'] 而对于不可变对象,比如str,对str进行操作呢: >>> a = 'abc' >>> a.replace('a', 'A') 'Abc' >>> a 'abc' 虽然字符串有个 replace() 方法,也确实变出了 'Abc' ,但变量 a 最后仍是 'abc' ,应该怎么理解呢? 我们先把代码改成下面这样: >>> a = 'abc' >>> b = a.replace('a', 'A') >>> b 'Abc' >>> a 'abc' 要始终牢记的是, a 是变量,而 'abc' 才是字符串对象!有些时候,我们经常说,对象 a 的内容是 'abc' ,但其实 是指, a 本身是一个变量,它指向的对象的内容才是 'abc' : 当我们调用 a.replace('a', 'A') 时,实际上调用方法 replace 是作用在字符串对象 'abc' 上的,而这个方法虽然名 字叫 replace ,但却没有改变字符串 'abc' 的内容。相反, replace 方法创建了一个新字符串 'Abc' 并返回,如果 我们用变量 b 指向该新字符串,就容易理解了,变量 a 仍指向原有的字符串 'abc' ,但变量 b 却指向新字符 串 'Abc' 了: 所以,对于不变对象来说,调用对象自身的任意方法,也不会改变该对象自身的内容。相反,这些方法会创建新的 对象并返回,这样,就保证了不可变对象本身永远是不可变的。 小结 使用key­value存储结构的dict在Python中非常有用,选择不可变对象作为key很重要,最常用的key是字符串。 tuple虽然是不变对象,但试试把 (1, 2, 3) 和 (1, [2, 3]) 放入dict或set中,并解释结果。 您的鼓励是作者写作最大的动力 如果您认为本网站的教程质量不错,读后觉得收获很大,预期工资涨幅能超过30%,不妨小额赞助我一下,让我有 动力继续写出高质量的教程: 函数 114次阅读 我们知道圆的面积计算公式为: S = πr 当我们知道半径 r 的值时,就可以根据公式计算出面积。假设我们需要计算3个不同大小的圆的面积: r1 = 12.34 r2 = 9.08 r3 = 73.1 s1 = 3.14 * r1 * r1 s2 = 3.14 * r2 * r2 s3 = 3.14 * r3 * r3 当代码出现有规律的重复的时候,你就需要当心了,每次写 3.14 * x * x 不仅很麻烦,而且,如果要把 3.14 改 成 3.14159265359 的时候,得全部替换。 有了函数,我们就不再每次写 s = 3.14 * x * x ,而是写成更有意义的函数调用 s = area_of_circle(x) ,而函 数 area_of_circle 本身只需要写一次,就可以多次调用。 基本上所有的高级语言都支持函数,Python也不例外。Python不但能非常灵活地定义函数,而且本身内置了很多有 用的函数,可以直接调用。 抽象 抽象是数学中非常常见的概念。举个例子: 计算数列的和,比如: 1 + 2 + 3 + ... + 100 ,写起来十分不方便,于是数学家发明了求和符号∑,可以 把 1 + 2 + 3 + ... + 100 记作: 100 ∑n n=1 这种抽象记法非常强大,因为我们看到∑就可以理解成求和,而不是还原成低级的加法运算。 而且,这种抽象记法是可扩展的,比如: 100 ∑(n +1) n=1 2 2 还原成加法运算就变成了: (1 x 1 + 1) + (2 x 2 + 1) + (3 x 3 + 1) + ... + (100 x 100 + 1) 可见,借助抽象,我们才能不关心底层的具体计算过程,而直接在更高的层次上思考问题。 写计算机程序也是一样,函数就是最基本的一种代码抽象的方式。 您的鼓励是作者写作最大的动力 如果您认为本网站的教程质量不错,读后觉得收获很大,预期工资涨幅能超过30%,不妨小额赞助我一下,让我有 动力继续写出高质量的教程: 调用函数 186次阅读 Python内置了很多有用的函数,我们可以直接调用。 要调用一个函数,需要知道函数的名称和参数,比如求绝对值的函数 abs ,只有一个参数。可以直接从Python的官 方网站查看文档: http://docs.python.org/2/library/functions.html#abs 也可以在交互式命令行通过 help(abs) 查看 abs 函数的帮助信息。 调用 abs 函数: >>> abs(100) 100 >>> abs(-20) 20 >>> abs(12.34) 12.34 调用函数的时候,如果传入的参数数量不对,会报 TypeError 的错误,并且Python会明确地告诉你:abs()有且仅有 1个参数,但给出了两个: >>> abs(1, 2) Traceback (most recent call last): File "", line 1, in TypeError: abs() takes exactly one argument (2 given) 如果传入的参数数量是对的,但参数类型不能被函数所接受,也会报 TypeError 的错误,并且给出错误信息:str是 错误的参数类型: >>> abs('a') Traceback (most recent call last): File "", line 1, in TypeError: bad operand type for abs(): 'str' TypeError: bad operand type for abs(): 'str' 而比较函数 cmp(x, y) 就需要两个参数,如果 xy ,返回 1 : >>> cmp(1, 2) -1 >>> cmp(2, 1) 1 >>> cmp(3, 3) 0 数据类型转换 Python内置的常用函数还包括数据类型转换函数,比如 int() 函数可以把其他数据类型转换为整数: >>> int('123') 123 >>> int(12.34) 12 >>> float('12.34') 12.34 >>> str(1.23) '1.23' >>> unicode(100) u'100' >>> bool(1) True >>> bool('') False 函数名其实就是指向一个函数对象的引用,完全可以把函数名赋给一个变量,相当于给这个函数起了一个“别名”: >>> a = abs # 变量a指向abs函数 >>> a(-1) # 所以也可以通过a调用abs函数 1 小结 调用Python的函数,需要根据函数定义,传入正确的参数。如果函数调用出错,一定要学会看错误信息,所以英文 很重要! 您的鼓励是作者写作最大的动力 如果您认为本网站的教程质量不错,读后觉得收获很大,预期工资涨幅能超过30%,不妨小额赞助我一下,让我有 动力继续写出高质量的教程: 定义函数 197次阅读 在Python中,定义一个函数要使用 def 语句,依次写出函数名、括号、括号中的参数和冒号 : ,然后,在缩进块中 编写函数体,函数的返回值用 return 语句返回。 我们以自定义一个求绝对值的 my_abs 函数为例: def my_abs(x): if x >= 0: return x else: return -x 请自行测试并调用 my_abs 看看返回结果是否正确。 请注意,函数体内部的语句在执行时,一旦执行到 return 时,函数就执行完毕,并将结果返回。因此,函数内部通 过条件判断和循环可以实现非常复杂的逻辑。 如果没有 return 语句,函数执行完毕后也会返回结果,只是结果为 None 。 return None 可以简写为 return 。 空函数 如果想定义一个什么事也不做的空函数,可以用 pass 语句: def nop(): pass pass 语句什么都不做,那有什么用?实际上 pass 可以用来作为占位符,比如现在还没想好怎么写函数的代码,就 可以先放一个 pass ,让代码能运行起来。 pass 还可以用在其他语句里,比如: if age >= 18: pass 缺少了 pass ,代码运行就会有语法错误。 参数检查 调用函数时,如果参数个数不对,Python解释器会自动检查出来,并抛出 TypeError : >>> my_abs(1, 2) Traceback (most recent call last): File "", line 1, in TypeError: my_abs() takes exactly 1 argument (2 given) 但是如果参数类型不对,Python解释器就无法帮我们检查。试试 my_abs 和内置函数 abs 的差别: >>> my_abs('A') >>> my_abs('A') 'A' >>> abs('A') Traceback (most recent call last): File "", line 1, in TypeError: bad operand type for abs(): 'str' 当传入了不恰当的参数时,内置函数 abs 会检查出参数错误,而我们定义的 my_abs 没有参数检查,所以,这个函数 定义不够完善。 让我们修改一下 my_abs 的定义,对参数类型做检查,只允许整数和浮点数类型的参数。数据类型检查可以用内置函 数 isinstance 实现: def my_abs(x): if not isinstance(x, (int, float)): raise TypeError('bad operand type') if x >= 0: return x else: return -x 添加了参数检查后,如果传入错误的参数类型,函数就可以抛出一个错误: >>> my_abs('A') Traceback (most recent call last): File "", line 1, in File "", line 3, in my_abs TypeError: bad operand type 错误和异常处理将在后续讲到。 返回多个值 函数可以返回多个值吗?答案是肯定的。 比如在游戏中经常需要从一个点移动到另一个点,给出坐标、位移和角度,就可以计算出新的新的坐标: import math def move(x, y, step, angle=0): nx = x + step * math.cos(angle) ny = y - step * math.sin(angle) return nx, ny 这样我们就可以同时获得返回值: >>> x, y = move(100, 100, 60, math.pi / 6) >>> print x, y 151.961524227 70.0 但其实这只是一种假象,Python函数返回的仍然是单一值: >>> r = move(100, 100, 60, math.pi / 6) >>> print r (151.96152422706632, 70.0) 原来返回值是一个tuple!但是,在语法上,返回一个tuple可以省略括号,而多个变量可以同时接收一个tuple,按位 置赋给对应的值,所以,Python的函数返回多值其实就是返回一个tuple,但写起来更方便。 小结 定义函数时,需要确定函数名和参数个数; 如果有必要,可以先对参数的数据类型做检查; 函数体内部可以用 return 随时返回函数结果; 函数执行完毕也没有 return 语句时,自动 return None 。 函数可以同时返回多个值,但其实就是一个tuple。 您的鼓励是作者写作最大的动力 如果您认为本网站的教程质量不错,读后觉得收获很大,预期工资涨幅能超过30%,不妨小额赞助我一下,让我有 动力继续写出高质量的教程: 函数的参数 254次阅读 定义函数的时候,我们把参数的名字和位置确定下来,函数的接口定义就完成了。对于函数的调用者来说,只需要 知道如何传递正确的参数,以及函数将返回什么样的值就够了,函数内部的复杂逻辑被封装起来,调用者无需了 解。 Python的函数定义非常简单,但灵活度却非常大。除了正常定义的必选参数外,还可以使用默认参数、可变参数和 关键字参数,使得函数定义出来的接口,不但能处理复杂的参数,还可以简化调用者的代码。 默认参数 我们仍以具体的例子来说明如何定义函数的默认参数。先写一个计算x 的函数: def power(x): return x * x 当我们调用 power 函数时,必须传入有且仅有的一个参数 x : >>> power(5) 25 >>> power(15) 225 2 现在,如果我们要计算x 怎么办?可以再定义一个 power3 函数,但是如果要计算x 、x ……怎么办?我们不可能定 义无限多个函数。 你也许想到了,可以把 power(x) 修改为 power(x, n) ,用来计算x ,说干就干: def power(x, n): s = 1 while n > 0: n = n - 1 s = s * x return s 对于这个修改后的 power 函数,可以计算任意n次方: >>> power(5, 2) 25 >>> power(5, 3) 125 但是,旧的调用代码失败了,原因是我们增加了一个参数,导致旧的代码无法正常调用: >>> power(5) Traceback (most recent call last): File "", line 1, in TypeError: power() takes exactly 2 arguments (1 given) 这个时候,默认参数就排上用场了。由于我们经常计算x ,所以,完全可以把第二个参数n的默认值设定为2: def power(x, n=2): s = 1 while n > 0: n = n - 1 s = s * x return s 这样,当我们调用 power(5) 时,相当于调用 power(5, 2) : >>> power(5) 25 >>> power(5, 2) 25 而对于 n > 2 的其他情况,就必须明确地传入n,比如 power(5, 3) 。 从上面的例子可以看出,默认参数可以简化函数的调用。设置默认参数时,有几点要注意: 一是必选参数在前,默认参数在后,否则Python的解释器会报错(思考一下为什么默认参数不能放在必选参数前 面); 二是如何设置默认参数。 3 4 5 n 2 当函数有多个参数时,把变化大的参数放前面,变化小的参数放后面。变化小的参数就可以作为默认参数。 使用默认参数有什么好处?最大的好处是能降低调用函数的难度。 举个例子,我们写个一年级小学生注册的函数,需要传入 name 和 gender 两个参数: def enroll(name, gender): print 'name:', name print 'gender:', gender 这样,调用 enroll() 函数只需要传入两个参数: >>> enroll('Sarah', 'F') name: Sarah gender: F 如果要继续传入年龄、城市等信息怎么办?这样会使得调用函数的复杂度大大增加。 我们可以把年龄和城市设为默认参数: def enroll(name, gender, age=6, city='Beijing'): print 'name:', name print 'gender:', gender print 'age:', age print 'city:', city 这样,大多数学生注册时不需要提供年龄和城市,只提供必须的两个参数: >>> enroll('Sarah', 'F') Student: name: Sarah gender: F age: 6 city: Beijing 只有与默认参数不符的学生才需要提供额外的信息: enroll('Bob', 'M', 7) enroll('Adam', 'M', city='Tianjin') 可见,默认参数降低了函数调用的难度,而一旦需要更复杂的调用时,又可以传递更多的参数来实现。无论是简单 调用还是复杂调用,函数只需要定义一个。 有多个默认参数时,调用的时候,既可以按顺序提供默认参数,比如调用 enroll('Bob', 'M', 7) ,意思是,除 了 name , gender 这两个参数外,最后1个参数应用在参数 age 上, city 参数由于没有提供,仍然使用默认值。 也可以不按顺序提供部分默认参数。当不按顺序提供部分默认参数时,需要把参数名写上。比如调 用 enroll('Adam', 'M', city='Tianjin') ,意思是, city 参数用传进去的值,其他默认参数继续使用默认值。 默认参数很有用,但使用不当,也会掉坑里。默认参数有个最大的坑,演示如下: 先定义一个函数,传入一个list,添加一个 END 再返回: def add_end(L=[]): L.append('END') return L 当你正常调用时,结果似乎不错: >>> add_end([1, 2, 3]) [1, 2, 3, 'END'] >>> add_end(['x', 'y', 'z']) ['x', 'y', 'z', 'END'] 当你使用默认参数调用时,一开始结果也是对的: >>> add_end() ['END'] 但是,再次调用 add_end() 时,结果就不对了: >>> add_end() ['END', 'END'] >>> add_end() ['END', 'END', 'END'] 很多初学者很疑惑,默认参数是 [] ,但是函数似乎每次都“记住了”上次添加了 'END' 后的list。 原因解释如下: Python函数在定义的时候,默认参数 L 的值就被计算出来了,即 [] ,因为默认参数 L 也是一个变量,它指向对 象 [] ,每次调用该函数,如果改变了 L 的内容,则下次调用时,默认参数的内容就变了,不再是函数定义时 的 [] 了。 所以,定义默认参数要牢记一点:默认参数必须指向不变对象! 要修改上面的例子,我们可以用 None 这个不变对象来实现: def add_end(L=None): if L is None: L = [] L.append('END') return L 现在,无论调用多少次,都不会有问题: >>> add_end() ['END'] >>> add_end() ['END'] 为什么要设计str、None这样的不变对象呢?因为不变对象一旦创建,对象内部的数据就不能修改,这样就减少了由 于修改数据导致的错误。此外,由于对象不变,多任务环境下同时读取对象不需要加锁,同时读一点问题都没 有。我们在编写程序时,如果可以设计一个不变对象,那就尽量设计成不变对象。 可变参数 在Python函数中,还可以定义可变参数。顾名思义,可变参数就是传入的参数个数是可变的,可以是1个、2个到任 意个,还可以是0个。 我们以数学题为例子,给定一组数字a,b,c……,请计算a  + b  + c  + ……。 要定义出这个函数,我们必须确定输入的参数。由于参数个数不确定,我们首先想到可以把a,b,c……作为一个lis t或tuple传进来,这样,函数可以定义如下: def calc(numbers): sum = 0 for n in numbers: sum = sum + n * n return sum 但是调用的时候,需要先组装出一个list或tuple: >>> calc([1, 2, 3]) 14 >>> calc((1, 3, 5, 7)) 84 如果利用可变参数,调用函数的方式可以简化成这样: >>> calc(1, 2, 3) 14 >>> calc(1, 3, 5, 7) 84 所以,我们把函数的参数改为可变参数: def calc(*numbers): sum = 0 for n in numbers: sum = sum + n * n return sum 定义可变参数和定义list或tuple参数相比,仅仅在参数前面加了一个 * 号。在函数内部,参数 numbers 接收到的是一 个tuple,因此,函数代码完全不变。但是,调用该函数时,可以传入任意个参数,包括0个参数: >>> calc(1, 2) 5 >>> calc() 0 如果已经有一个list或者tuple,要调用一个可变参数怎么办?可以这样做: 2 2 2 如果已经有一个list或者tuple,要调用一个可变参数怎么办?可以这样做: >>> nums = [1, 2, 3] >>> calc(nums[0], nums[1], nums[2]) 14 这种写法当然是可行的,问题是太繁琐,所以Python允许你在list或tuple前面加一个 * 号,把list或tuple的元素变成 可变参数传进去: >>> nums = [1, 2, 3] >>> calc(*nums) 14 这种写法相当有用,而且很常见。 关键字参数 可变参数允许你传入0个或任意个参数,这些可变参数在函数调用时自动组装为一个tuple。而关键字参数允许你传入 0个或任意个含参数名的参数,这些关键字参数在函数内部自动组装为一个dict。请看示例: def person(name, age, **kw): print 'name:', name, 'age:', age, 'other:', kw 函数 person 除了必选参数 name 和 age 外,还接受关键字参数 kw 。在调用该函数时,可以只传入必选参数: >>> person('Michael', 30) name: Michael age: 30 other: {} 也可以传入任意个数的关键字参数: >>> person('Bob', 35, city='Beijing') name: Bob age: 35 other: {'city': 'Beijing'} >>> person('Adam', 45, gender='M', job='Engineer') name: Adam age: 45 other: {'gender': 'M', 'job': 'Engineer'} 关键字参数有什么用?它可以扩展函数的功能。比如,在 person 函数里,我们保证能接收到 name 和 age 这两个参 数,但是,如果调用者愿意提供更多的参数,我们也能收到。试想你正在做一个用户注册的功能,除了用户名和年 龄是必填项外,其他都是可选项,利用关键字参数来定义这个函数就能满足注册的需求。 和可变参数类似,也可以先组装出一个dict,然后,把该dict转换为关键字参数传进去: >>> kw = {'city': 'Beijing', 'job': 'Engineer'} >>> person('Jack', 24, city=kw['city'], job=kw['job']) name: Jack age: 24 other: {'city': 'Beijing', 'job': 'Engineer'} 当然,上面复杂的调用可以用简化的写法: >>> kw = {'city': 'Beijing', 'job': 'Engineer'} >>> person('Jack', 24, **kw) name: Jack age: 24 other: {'city': 'Beijing', 'job': 'Engineer'} name: Jack age: 24 other: {'city': 'Beijing', 'job': 'Engineer'} 参数组合 在Python中定义函数,可以用必选参数、默认参数、可变参数和关键字参数,这4种参数都可以一起使用,或者只用 其中某些,但是请注意,参数定义的顺序必须是:必选参数、默认参数、可变参数和关键字参数。 比如定义一个函数,包含上述4种参数: def func(a, b, c=0, *args, **kw): print 'a =', a, 'b =', b, 'c =', c, 'args =', args, 'kw =', kw 在函数调用的时候,Python解释器自动按照参数位置和参数名把对应的参数传进去。 >>> func(1, 2) a = 1 b = 2 c = 0 args = () kw = {} >>> func(1, 2, c=3) a = 1 b = 2 c = 3 args = () kw = {} >>> func(1, 2, 3, 'a', 'b') a = 1 b = 2 c = 3 args = ('a', 'b') kw = {} >>> func(1, 2, 3, 'a', 'b', x=99) a = 1 b = 2 c = 3 args = ('a', 'b') kw = {'x': 99} 最神奇的是通过一个tuple和dict,你也可以调用该函数: >>> args = (1, 2, 3, 4) >>> kw = {'x': 99} >>> func(*args, **kw) a = 1 b = 2 c = 3 args = (4,) kw = {'x': 99} 所以,对于任意函数,都可以通过类似 func(*args, **kw) 的形式调用它,无论它的参数是如何定义的。 小结 Python的函数具有非常灵活的参数形态,既可以实现简单的调用,又可以传入非常复杂的参数。 默认参数一定要用不可变对象,如果是可变对象,运行会有逻辑错误! 要注意定义可变参数和关键字参数的语法: *args 是可变参数,args接收的是一个tuple; **kw 是关键字参数,kw接收的是一个dict。 以及调用函数时如何传入可变参数和关键字参数的语法: 可变参数既可以直接传入: func(1, 2, 3) ,又可以先组装list或tuple,再通过 *args 传入: func(*(1, 2, 3)) ; 关键字参数既可以直接传入: func(a=1, b=2) ,又可以先组装dict,再通过 **kw 传 入: func(**{'a': 1, 'b': 2}) 。 使用 *args 和 **kw 是Python的习惯写法,当然也可以用其他参数名,但最好使用习惯用法。 使用 *args 和 **kw 是Python的习惯写法,当然也可以用其他参数名,但最好使用习惯用法。 您的鼓励是作者写作最大的动力 如果您认为本网站的教程质量不错,读后觉得收获很大,预期工资涨幅能超过30%,不妨小额赞助我一下,让我有 动力继续写出高质量的教程: 递归函数 134次阅读 在函数内部,可以调用其他函数。如果一个函数在内部调用自身本身,这个函数就是递归函数。 举个例子,我们来计算阶乘 n! = 1 x 2 x 3 x ... x n ,用函数 fact(n) 表示,可以看出: fact(n) = n! = 1 x 2 x 3 x ... x (n­1) x n = (n­1)! x n = fact(n­1) x n 所以, fact(n) 可以表示为 n x fact(n‐1) ,只有n=1时需要特殊处理。 于是, fact(n) 用递归的方式写出来就是: def fact(n): if n==1: return 1 return n * fact(n - 1) 上面就是一个递归函数。可以试试: >>> fact(1) 1 >>> fact(5) 120 >>> fact(100) 933262154439441526816992388562667004907159682643816214685929638952175999932299156089414639761565182862536979208272 23758251185210916864000000000000000000000000L 如果我们计算 fact(5) ,可以根据函数定义看到计算过程如下: ===> fact(5) ===> 5 * fact(4) ===> 5 * (4 * fact(3)) ===> 5 * (4 * (3 * fact(2))) ===> 5 * (4 * (3 * (2 * fact(1)))) ===> 5 * (4 * (3 * (2 * 1))) ===> 5 * (4 * (3 * 2)) ===> 5 * (4 * 6) ===> 5 * 24 ===> 120 递归函数的优点是定义简单,逻辑清晰。理论上,所有的递归函数都可以写成循环的方式,但循环的逻辑不如递归 清晰。 清晰。 使用递归函数需要注意防止栈溢出。在计算机中,函数调用是通过栈(stack)这种数据结构实现的,每当进入一个 函数调用,栈就会加一层栈帧,每当函数返回,栈就会减一层栈帧。由于栈的大小不是无限的,所以,递归调用的 次数过多,会导致栈溢出。可以试试 fact(1000) : >>> fact(1000) Traceback (most recent call last): File "", line 1, in File "", line 4, in fact ... File "", line 4, in fact RuntimeError: maximum recursion depth exceeded 解决递归调用栈溢出的方法是通过尾递归优化,事实上尾递归和循环的效果是一样的,所以,把循环看成是一种特 殊的尾递归函数也是可以的。 尾递归是指,在函数返回的时候,调用自身本身,并且,return语句不能包含表达式。这样,编译器或者解释器就可 以把尾递归做优化,使递归本身无论调用多少次,都只占用一个栈帧,不会出现栈溢出的情况。 上面的 fact(n) 函数由于 return n * fact(n ‐ 1) 引入了乘法表达式,所以就不是尾递归了。要改成尾递归方 式,需要多一点代码,主要是要把每一步的乘积传入到递归函数中: def fact(n): return fact_iter(n, 1) def fact_iter(num, product): if num == 1: return product return fact_iter(num - 1, num * product) 可以看到, return fact_iter(num ‐ 1, num * product) 仅返回递归函数本身, num ‐ 1 和 num * product 在函数调 用前就会被计算,不影响函数调用。 fact(5) 对应的 fact_iter(5, 1) 的调用如下: ===> fact_iter(5, 1) ===> fact_iter(4, 5) ===> fact_iter(3, 20) ===> fact_iter(2, 60) ===> fact_iter(1, 120) ===> 120 尾递归调用时,如果做了优化,栈不会增长,因此,无论多少次调用也不会导致栈溢出。 遗憾的是,大多数编程语言没有针对尾递归做优化,Python解释器也没有做优化,所以,即使把上面的 fact(n) 函 数改成尾递归方式,也会导致栈溢出。 小结 使用递归函数的优点是逻辑简单清晰,缺点是过深的调用会导致栈溢出。 针对尾递归优化的语言可以通过尾递归防止栈溢出。尾递归事实上和循环是等价的,没有循环语句的编程语言只能 通过尾递归实现循环。 Python标准的解释器没有针对尾递归做优化,任何递归函数都存在栈溢出的问题。 您的鼓励是作者写作最大的动力 如果您认为本网站的教程质量不错,读后觉得收获很大,预期工资涨幅能超过30%,不妨小额赞助我一下,让我有 动力继续写出高质量的教程: 高级特性 85次阅读 掌握了Python的数据类型、语句和函数,基本上就可以编写出很多有用的程序了。 比如构造一个 1, 3, 5, 7, ..., 99 的列表,可以通过循环实现: L = [] n = 1 while n <= 99: L.append(n) n = n + 2 取list的前一半的元素,也可以通过循环实现。 但是在Python中,代码不是越多越好,而是越少越好。代码不是越复杂越好,而是越简单越好。 基于这一思想,我们来介绍Python中非常有用的高级特性,一行代码能实现的功能,决不写5行代码。 您的鼓励是作者写作最大的动力 如果您认为本网站的教程质量不错,读后觉得收获很大,预期工资涨幅能超过30%,不妨小额赞助我一下,让我有 动力继续写出高质量的教程: 切片 151次阅读 取一个list或tuple的部分元素是非常常见的操作。比如,一个list如下: >>> L = ['Michael', 'Sarah', 'Tracy', 'Bob', 'Jack'] 取前3个元素,应该怎么做? 笨办法: >>> [L[0], L[1], L[2]] ['Michael', 'Sarah', 'Tracy'] ['Michael', 'Sarah', 'Tracy'] 之所以是笨办法是因为扩展一下,取前N个元素就没辙了。 取前N个元素,也就是索引为0­(N­1)的元素,可以用循环: >>> r = [] >>> n = 3 >>> for i in range(n): ... r.append(L[i]) ... >>> r ['Michael', 'Sarah', 'Tracy'] 对这种经常取指定索引范围的操作,用循环十分繁琐,因此,Python提供了切片(Slice)操作符,能大大简化这种 操作。 对应上面的问题,取前3个元素,用一行代码就可以完成切片: >>> L[0:3] ['Michael', 'Sarah', 'Tracy'] L[0:3] 表示,从索引0开始取,直到索引3为止,但不包括索引3。即索引0,1,2,正好是3个元素。 如果第一个索引是0,还可以省略: >>> L[:3] ['Michael', 'Sarah', 'Tracy'] 也可以从索引1开始,取出2个元素出来: >>> L[1:3] ['Sarah', 'Tracy'] 类似的,既然Python支持 L[‐1] 取倒数第一个元素,那么它同样支持倒数切片,试试: >>> L[-2:] ['Bob', 'Jack'] >>> L[-2:-1] ['Bob'] 记住倒数第一个元素的索引是 ‐1 。 切片操作十分有用。我们先创建一个0­99的数列: >>> L = range(100) >>> L [0, 1, 2, 3, ..., 99] 可以通过切片轻松取出某一段数列。比如前10个数: >>> L[:10] [0, 1, 2, 3, 4, 5, 6, 7, 8, 9] 后10个数: >>> L[-10:] [90, 91, 92, 93, 94, 95, 96, 97, 98, 99] 前11­20个数: >>> L[10:20] [10, 11, 12, 13, 14, 15, 16, 17, 18, 19] 前10个数,每两个取一个: >>> L[:10:2] [0, 2, 4, 6, 8] 所有数,每5个取一个: >>> L[::5] [0, 5, 10, 15, 20, 25, 30, 35, 40, 45, 50, 55, 60, 65, 70, 75, 80, 85, 90, 95] 甚至什么都不写,只写 [:] 就可以原样复制一个list: >>> L[:] [0, 1, 2, 3, ..., 99] tuple也是一种list,唯一区别是tuple不可变。因此,tuple也可以用切片操作,只是操作的结果仍是tuple: >>> (0, 1, 2, 3, 4, 5)[:3] (0, 1, 2) 字符串 'xxx' 或Unicode字符串 u'xxx' 也可以看成是一种list,每个元素就是一个字符。因此,字符串也可以用切片 操作,只是操作结果仍是字符串: >>> 'ABCDEFG'[:3] 'ABC' >>> 'ABCDEFG'[::2] 'ACEG' 在很多编程语言中,针对字符串提供了很多各种截取函数,其实目的就是对字符串切片。Python没有针对字符串的 截取函数,只需要切片一个操作就可以完成,非常简单。 小结 有了切片操作,很多地方循环就不再需要了。Python的切片非常灵活,一行代码就可以实现很多行循环才能完成的 有了切片操作,很多地方循环就不再需要了。Python的切片非常灵活,一行代码就可以实现很多行循环才能完成的 操作。 您的鼓励是作者写作最大的动力 如果您认为本网站的教程质量不错,读后觉得收获很大,预期工资涨幅能超过30%,不妨小额赞助我一下,让我有 动力继续写出高质量的教程: 迭代 131次阅读 如果给定一个list或tuple,我们可以通过 for 循环来遍历这个list或tuple,这种遍历我们称为迭代(Iteration)。 在Python中,迭代是通过 for ... in 来完成的,而很多语言比如C或者Java,迭代list是通过下标完成的,比如Java 代码: for (i=0; i>> d = {'a': 1, 'b': 2, 'c': 3} >>> for key in d: ... print key ... a c b 因为dict的存储不是按照list的方式顺序排列,所以,迭代出的结果顺序很可能不一样。 默认情况下,dict迭代的是key。如果要迭代value,可以用 for value in d.itervalues() ,如果要同时迭代key和va lue,可以用 for k, v in d.iteritems() 。 由于字符串也是可迭代对象,因此,也可以作用于 for 循环: >>> for ch in 'ABC': ... print ch ... A B C 所以,当我们使用 for 循环时,只要作用于一个可迭代对象, for 循环就可以正常运行,而我们不太关心该对象究 竟是list还是其他数据类型。 竟是list还是其他数据类型。 那么,如何判断一个对象是可迭代对象呢?方法是通过collections模块的Iterable类型判断: >>> from collections import Iterable >>> isinstance('abc', Iterable) # str是否可迭代 True >>> isinstance([1,2,3], Iterable) # list是否可迭代 True >>> isinstance(123, Iterable) # 整数是否可迭代 False 最后一个小问题,如果要对list实现类似Java那样的下标循环怎么办?Python内置的 enumerate 函数可以把一个list变 成索引­元素对,这样就可以在 for 循环中同时迭代索引和元素本身: >>> for i, value in enumerate(['A', 'B', 'C']): ... print i, value ... 0 A 1 B 2 C 上面的 for 循环里,同时引用了两个变量,在Python里是很常见的,比如下面的代码: >>> for x, y in [(1, 1), (2, 4), (3, 9)]: ... print x, y ... 1 1 2 4 3 9 小结 任何可迭代对象都可以作用于 for 循环,包括我们自定义的数据类型,只要符合迭代条件,就可以使用 for 循环。 您的鼓励是作者写作最大的动力 如果您认为本网站的教程质量不错,读后觉得收获很大,预期工资涨幅能超过30%,不妨小额赞助我一下,让我有 动力继续写出高质量的教程: 列表生成式 152次阅读 列表生成式即List Comprehensions,是Python内置的非常简单却强大的可以用来创建list的生成式。 举个例子,要生成list  [1, 2, 3, 4, 5, 6, 7, 8, 9, 10] 可以用 range(1, 11) : >>> range(1, 11) [1, 2, 3, 4, 5, 6, 7, 8, 9, 10] 但如果要生成 [1x1, 2x2, 3x3, ..., 10x10] 怎么做?方法一是循环: >>> L = [] >>> for x in range(1, 11): ... L.append(x * x) ... >>> L [1, 4, 9, 16, 25, 36, 49, 64, 81, 100] 但是循环太繁琐,而列表生成式则可以用一行语句代替循环生成上面的list: >>> [x * x for x in range(1, 11)] [1, 4, 9, 16, 25, 36, 49, 64, 81, 100] 写列表生成式时,把要生成的元素 x * x 放到前面,后面跟 for 循环,就可以把list创建出来,十分有用,多写几 次,很快就可以熟悉这种语法。 for循环后面还可以加上if判断,这样我们就可以筛选出仅偶数的平方: >>> [x * x for x in range(1, 11) if x % 2 == 0] [4, 16, 36, 64, 100] 还可以使用两层循环,可以生成全排列: >>> [m + n for m in 'ABC' for n in 'XYZ'] ['AX', 'AY', 'AZ', 'BX', 'BY', 'BZ', 'CX', 'CY', 'CZ'] 三层和三层以上的循环就很少用到了。 运用列表生成式,可以写出非常简洁的代码。例如,列出当前目录下的所有文件和目录名,可以通过一行代码实 现: >>> import os # 导入os模块,模块的概念后面讲到 >>> [d for d in os.listdir('.')] # os.listdir可以列出文件和目录 ['.emacs.d', '.ssh', '.Trash', 'Adlm', 'Applications', 'Desktop', 'Documents', 'Downloads', 'Library', 'Movies', 'Music', 'Pictures', 'Public', 'VirtualBox VMs', 'Workspace', 'XCode'] for 循环其实可以同时使用两个甚至多个变量,比如 dict 的 iteritems() 可以同时迭代key和value: >>> d = {'x': 'A', 'y': 'B', 'z': 'C' } >>> for k, v in d.iteritems(): ... print k, '=', v ... y = B x = A z = C 因此,列表生成式也可以使用两个变量来生成list: 因此,列表生成式也可以使用两个变量来生成list: >>> d = {'x': 'A', 'y': 'B', 'z': 'C' } >>> [k + '=' + v for k, v in d.iteritems()] ['y=B', 'x=A', 'z=C'] 最后把一个list中所有的字符串变成小写: >>> L = ['Hello', 'World', 'IBM', 'Apple'] >>> [s.lower() for s in L] ['hello', 'world', 'ibm', 'apple'] 小结 运用列表生成式,可以快速生成list,可以通过一个list推导出另一个list,而代码却十分简洁。 思考:如果list中既包含字符串,又包含整数,由于非字符串类型没有 lower() 方法,所以列表生成式会报错: >>> L = ['Hello', 'World', 18, 'Apple', None] >>> [s.lower() for s in L] Traceback (most recent call last): File "", line 1, in AttributeError: 'int' object has no attribute 'lower' 使用内建的 isinstance 函数可以判断一个变量是不是字符串: >>> x = 'abc' >>> y = 123 >>> isinstance(x, str) True >>> isinstance(y, str) False 请修改列表生成式,通过添加 if 语句保证列表生成式能正确地执行。 您的鼓励是作者写作最大的动力 如果您认为本网站的教程质量不错,读后觉得收获很大,预期工资涨幅能超过30%,不妨小额赞助我一下,让我有 动力继续写出高质量的教程: 生成器 128次阅读 通过列表生成式,我们可以直接创建一个列表。但是,受到内存限制,列表容量肯定是有限的。而且,创建一个包 含100万个元素的列表,不仅占用很大的存储空间,如果我们仅仅需要访问前面几个元素,那后面绝大多数元素占用 的空间都白白浪费了。 所以,如果列表元素可以按照某种算法推算出来,那我们是否可以在循环的过程中不断推算出后续的元素呢?这样 所以,如果列表元素可以按照某种算法推算出来,那我们是否可以在循环的过程中不断推算出后续的元素呢?这样 就不必创建完整的list,从而节省大量的空间。在Python中,这种一边循环一边计算的机制,称为生成器(Generato r)。 要创建一个generator,有很多种方法。第一种方法很简单,只要把一个列表生成式的 [] 改成 () ,就创建了一个g enerator: >>> L = [x * x for x in range(10)] >>> L [0, 1, 4, 9, 16, 25, 36, 49, 64, 81] >>> g = (x * x for x in range(10)) >>> g at 0x104feab40> 创建 L 和 g 的区别仅在于最外层的 [] 和 () , L 是一个list,而 g 是一个generator。 我们可以直接打印出list的每一个元素,但我们怎么打印出generator的每一个元素呢? 如果要一个一个打印出来,可以通过generator的 next() 方法: >>> g.next() 0 >>> g.next() 1 >>> g.next() 4 >>> g.next() 9 >>> g.next() 16 >>> g.next() 25 >>> g.next() 36 >>> g.next() 49 >>> g.next() 64 >>> g.next() 81 >>> g.next() Traceback (most recent call last): File "", line 1, in StopIteration 我们讲过,generator保存的是算法,每次调用 next() ,就计算出下一个元素的值,直到计算到最后一个元素,没 有更多的元素时,抛出StopIteration的错误。 当然,上面这种不断调用 next() 方法实在是太变态了,正确的方法是使用 for 循环,因为generator也是可迭代对 象: >>> g = (x * x for x in range(10)) >>> for n in g: ... print n ... ... 0 1 4 9 16 25 36 49 64 81 所以,我们创建了一个generator后,基本上永远不会调用 next() 方法,而是通过 for 循环来迭代它。 generator非常强大。如果推算的算法比较复杂,用类似列表生成式的 for 循环无法实现的时候,还可以用函数来实 现。 比如,著名的斐波拉契数列(Fibonacci),除第一个和第二个数外,任意一个数都可由前两个数相加得到: 1, 1, 2, 3, 5, 8, 13, 21, 34, ... 斐波拉契数列用列表生成式写不出来,但是,用函数把它打印出来却很容易: def fib(max): n, a, b = 0, 0, 1 while n < max: print b a, b = b, a + b n = n + 1 上面的函数可以输出斐波那契数列的前N个数: >>> fib(6) 1 1 2 3 5 8 仔细观察,可以看出, fib 函数实际上是定义了斐波拉契数列的推算规则,可以从第一个元素开始,推算出后续任 意的元素,这种逻辑其实非常类似generator。 也就是说,上面的函数和generator仅一步之遥。要把 fib 函数变成generator,只需要把 print b 改为 yield b 就 可以了: def fib(max): n, a, b = 0, 0, 1 while n < max: yield b a, b = b, a + b n = n + 1 这就是定义generator的另一种方法。如果一个函数定义中包含 yield 关键字,那么这个函数就不再是一个普通函 数,而是一个generator: >>> fib(6) 这里,最难理解的就是generator和函数的执行流程不一样。函数是顺序执行,遇到return语句或者最后一行函数语 句就返回。而变成generator的函数,在每次调用 next() 的时候执行,遇到 yield 语句返回,再次执行时从上次返 回的 yield 语句处继续执行。 举个简单的例子,定义一个generator,依次返回数字1,3,5: >>> def odd(): ... print 'step 1' ... yield 1 ... print 'step 2' ... yield 3 ... print 'step 3' ... yield 5 ... >>> o = odd() >>> o.next() step 1 1 >>> o.next() step 2 3 >>> o.next() step 3 5 >>> o.next() Traceback (most recent call last): File "", line 1, in StopIteration 可以看到, odd 不是普通函数,而是generator,在执行过程中,遇到 yield 就中断,下次又继续执行。执行3 次 yield 后,已经没有 yield 可以执行了,所以,第4次调用 next() 就报错。 回到 fib 的例子,我们在循环过程中不断调用 yield ,就会不断中断。当然要给循环设置一个条件来退出循环,不 然就会产生一个无限数列出来。 同样的,把函数改成generator后,我们基本上从来不会用 next() 来调用它,而是直接使用 for 循环来迭代: >>> for n in fib(6): ... print n ... 1 1 2 3 5 8 小结 generator是非常强大的工具,在Python中,可以简单地把列表生成式改成generator,也可以通过函数实现复杂逻 辑的generator。 要理解generator的工作原理,它是在 for 循环的过程中不断计算出下一个元素,并在适当的条件结束 for 循环。对 于函数改成的generator来说,遇到return语句或者执行到函数体最后一行语句,就是结束generator的指令, for 循 环随之结束。 您的鼓励是作者写作最大的动力 如果您认为本网站的教程质量不错,读后觉得收获很大,预期工资涨幅能超过30%,不妨小额赞助我一下,让我有 动力继续写出高质量的教程: 函数式编程 92次阅读 函数是Python内建支持的一种封装,我们通过把大段代码拆成函数,通过一层一层的函数调用,就可以把复杂任务 分解成简单的任务,这种分解可以称之为面向过程的程序设计。函数就是面向过程的程序设计的基本单元。 而函数式编程(请注意多了一个“式”字)——Functional Programming,虽然也可以归结到面向过程的程序设 计,但其思想更接近数学计算。 我们首先要搞明白计算机(Computer)和计算(Compute)的概念。 在计算机的层次上,CPU执行的是加减乘除的指令代码,以及各种条件判断和跳转指令,所以,汇编语言是最贴近 计算机的语言。 而计算则指数学意义上的计算,越是抽象的计算,离计算机硬件越远。 对应到编程语言,就是越低级的语言,越贴近计算机,抽象程度低,执行效率高,比如C语言;越高级的语言,越贴 近计算,抽象程度高,执行效率低,比如Lisp语言。 函数式编程就是一种抽象程度很高的编程范式,纯粹的函数式编程语言编写的函数没有变量,因此,任意一个函 数,只要输入是确定的,输出就是确定的,这种纯函数我们称之为没有副作用。而允许使用变量的程序设计语 言,由于函数内部的变量状态不确定,同样的输入,可能得到不同的输出,因此,这种函数是有副作用的。 函数式编程的一个特点就是,允许把函数本身作为参数传入另一个函数,还允许返回一个函数! Python对函数式编程提供部分支持。由于Python允许使用变量,因此,Python不是纯函数式编程语言。 您的鼓励是作者写作最大的动力 如果您认为本网站的教程质量不错,读后觉得收获很大,预期工资涨幅能超过30%,不妨小额赞助我一下,让我有 动力继续写出高质量的教程: 高阶函数 103次阅读 103次阅读 高阶函数英文叫Higher­order function。什么是高阶函数?我们以实际代码为例子,一步一步深入概念。 变量可以指向函数 以Python内置的求绝对值的函数 abs() 为例,调用该函数用以下代码: >>> abs(-10) 10 但是,如果只写 abs 呢? >>> abs 可见, abs(‐10) 是函数调用,而 abs 是函数本身。 要获得函数调用结果,我们可以把结果赋值给变量: >>> x = abs(-10) >>> x 10 但是,如果把函数本身赋值给变量呢? >>> f = abs >>> f 结论:函数本身也可以赋值给变量,即:变量可以指向函数。 如果一个变量指向了一个函数,那么,可否通过该变量来调用这个函数?用代码验证一下: >>> f = abs >>> f(-10) 10 成功!说明变量 f 现在已经指向了 abs 函数本身。 函数名也是变量 那么函数名是什么呢?函数名其实就是指向函数的变量!对于 abs() 这个函数,完全可以把函数名 abs 看成变 量,它指向一个可以计算绝对值的函数! 如果把 abs 指向其他对象,会有什么情况发生? >>> abs = 10 >>> abs(-10) >>> abs(-10) Traceback (most recent call last): File "", line 1, in TypeError: 'int' object is not callable 把 abs 指向 10 后,就无法通过 abs(‐10) 调用该函数了!因为 abs 这个变量已经不指向求绝对值函数了! 当然实际代码绝对不能这么写,这里是为了说明函数名也是变量。要恢复 abs 函数,请重启Python交互环境。 注:由于 abs 函数实际上是定义在 __builtin__ 模块中的,所以要让修改 abs 变量的指向在其它模块也生效,要 用 __builtin__.abs = 10 。 传入函数 既然变量可以指向函数,函数的参数能接收变量,那么一个函数就可以接收另一个函数作为参数,这种函数就称之 为高阶函数。 一个最简单的高阶函数: def add(x, y, f): return f(x) + f(y) 当我们调用 add(‐5, 6, abs) 时,参数 x , y 和 f 分别接收 ‐5 , 6 和 abs ,根据函数定义,我们可以推导计算过 程为: x ==> -5 y ==> 6 f ==> abs f(x) + f(y) ==> abs(-5) + abs(6) ==> 11 用代码验证一下: >>> add(-5, 6, abs) 11 编写高阶函数,就是让函数的参数能够接收别的函数。 小结 把函数作为参数传入,这样的函数称为高阶函数,函数式编程就是指这种高度抽象的编程范式。 您的鼓励是作者写作最大的动力 如果您认为本网站的教程质量不错,读后觉得收获很大,预期工资涨幅能超过30%,不妨小额赞助我一下,让我有 动力继续写出高质量的教程: map/reduce 127次阅读 Python内建了 map() 和 reduce() 函数。 如果你读过Google的那篇大名鼎鼎的论文“MapReduce: Simplified Data Processing on Large Clusters”,你就能大 概明白map/reduce的概念。 我们先看map。 map() 函数接收两个参数,一个是函数,一个是序列, map 将传入的函数依次作用到序列的每个元 素,并把结果作为新的list返回。 举例说明,比如我们有一个函数f(x)=x ,要把这个函数作用在一个list  [1, 2, 3, 4, 5, 6, 7, 8, 9] 上,就可以 用 map() 实现如下: 现在,我们用Python代码实现: >>> def f(x): ... return x * x ... >>> map(f, [1, 2, 3, 4, 5, 6, 7, 8, 9]) [1, 4, 9, 16, 25, 36, 49, 64, 81] map() 传入的第一个参数是 f ,即函数对象本身。 你可能会想,不需要 map() 函数,写一个循环,也可以计算出结果: L = [] for n in [1, 2, 3, 4, 5, 6, 7, 8, 9]: L.append(f(n)) print L 的确可以,但是,从上面的循环代码,能一眼看明白“把f(x)作用在list的每一个元素并把结果生成一个新的list”吗? 所以, map() 作为高阶函数,事实上它把运算规则抽象了,因此,我们不但可以计算简单的f(x)=x ,还可以计算任 意复杂的函数,比如,把这个list所有数字转为字符串: >>> map(str, [1, 2, 3, 4, 5, 6, 7, 8, 9]) ['1', '2', '3', '4', '5', '6', '7', '8', '9'] 只需要一行代码。 2 2 再看reduce的用法。reduce把一个函数作用在一个序列[x1, x2, x3...]上,这个函数必须接收两个参数,reduce把结 果继续和序列的下一个元素做累积计算,其效果就是: reduce(f, [x1, x2, x3, x4]) = f(f(f(x1, x2), x3), x4) 比方说对一个序列求和,就可以用reduce实现: >>> def add(x, y): ... return x + y ... >>> reduce(add, [1, 3, 5, 7, 9]) 25 当然求和运算可以直接用Python内建函数 sum() ,没必要动用reduce。 但是如果要把序列 [1, 3, 5, 7, 9] 变换成整数13579,reduce就可以派上用场: >>> def fn(x, y): ... return x * 10 + y ... >>> reduce(fn, [1, 3, 5, 7, 9]) 13579 这个例子本身没多大用处,但是,如果考虑到字符串 str 也是一个序列,对上面的例子稍加改动,配合 map() ,我 们就可以写出把 str 转换为 int 的函数: >>> def fn(x, y): ... return x * 10 + y ... >>> def char2num(s): ... return {'0': 0, '1': 1, '2': 2, '3': 3, '4': 4, '5': 5, '6': 6, '7': 7, '8': 8, '9': 9}[s] ... >>> reduce(fn, map(char2num, '13579')) 13579 整理成一个 str2int 的函数就是: def str2int(s): def fn(x, y): return x * 10 + y def char2num(s): return {'0': 0, '1': 1, '2': 2, '3': 3, '4': 4, '5': 5, '6': 6, '7': 7, '8': 8, '9': 9}[s] return reduce(fn, map(char2num, s)) 还可以用lambda函数进一步简化成: def char2num(s): return {'0': 0, '1': 1, '2': 2, '3': 3, '4': 4, '5': 5, '6': 6, '7': 7, '8': 8, '9': 9}[s] def str2int(s): return reduce(lambda x,y: x*10+y, map(char2num, s)) 也就是说,假设Python没有提供 int() 函数,你完全可以自己写一个把字符串转化为整数的函数,而且只需要几行 代码! lambda函数的用法在后面介绍。 练习 利用 map() 函数,把用户输入的不规范的英文名字,变为首字母大写,其他小写的规范名字。输 入: ['adam', 'LISA', 'barT'] ,输出: ['Adam', 'Lisa', 'Bart'] 。 Python提供的 sum() 函数可以接受一个list并求和,请编写一个 prod() 函数,可以接受一个list并利用 reduce() 求 积。 您的鼓励是作者写作最大的动力 如果您认为本网站的教程质量不错,读后觉得收获很大,预期工资涨幅能超过30%,不妨小额赞助我一下,让我有 动力继续写出高质量的教程: filter 74次阅读 Python内建的 filter() 函数用于过滤序列。 和 map() 类似, filter() 也接收一个函数和一个序列。和 map() 不同的时, filter() 把传入的函数依次作用于每 个元素,然后根据返回值是 True 还是 False 决定保留还是丢弃该元素。 例如,在一个list中,删掉偶数,只保留奇数,可以这么写: def is_odd(n): return n % 2 == 1 filter(is_odd, [1, 2, 4, 5, 6, 9, 10, 15]) # 结果: [1, 5, 9, 15] 把一个序列中的空字符串删掉,可以这么写: def not_empty(s): return s and s.strip() filter(not_empty, ['A', '', 'B', None, 'C', ' ']) # 结果: ['A', 'B', 'C'] 可见用 filter() 这个高阶函数,关键在于正确实现一个“筛选”函数。 练习 请尝试用 filter() 删除1~100的素数。 您的鼓励是作者写作最大的动力 如果您认为本网站的教程质量不错,读后觉得收获很大,预期工资涨幅能超过30%,不妨小额赞助我一下,让我有 动力继续写出高质量的教程: sorted 64次阅读 排序算法 排序也是在程序中经常用到的算法。无论使用冒泡排序还是快速排序,排序的核心是比较两个元素的大小。如果是 数字,我们可以直接比较,但如果是字符串或者两个dict呢?直接比较数学上的大小是没有意义的,因此,比较的过 程必须通过函数抽象出来。通常规定,对于两个元素 x 和 y ,如果认为 x < y ,则返回 ‐1 ,如果认为 x == y ,则 返回 0 ,如果认为 x > y ,则返回 1 ,这样,排序算法就不用关心具体的比较过程,而是根据比较结果直接排序。 Python内置的 sorted() 函数就可以对list进行排序: >>> sorted([36, 5, 12, 9, 21]) [5, 9, 12, 21, 36] 此外, sorted() 函数也是一个高阶函数,它还可以接收一个比较函数来实现自定义的排序。比如,如果要倒序排 序,我们就可以自定义一个 reversed_cmp 函数: def reversed_cmp(x, y): if x > y: return -1 if x < y: return 1 return 0 传入自定义的比较函数 reversed_cmp ,就可以实现倒序排序: >>> sorted([36, 5, 12, 9, 21], reversed_cmp) [36, 21, 12, 9, 5] 我们再看一个字符串排序的例子: >>> sorted(['bob', 'about', 'Zoo', 'Credit']) ['Credit', 'Zoo', 'about', 'bob'] 默认情况下,对字符串排序,是按照ASCII的大小比较的,由于 'Z' < 'a' ,结果,大写字母 Z 会排在小写字母 a 的前面。 现在,我们提出排序应该忽略大小写,按照字母序排序。要实现这个算法,不必对现有代码大加改动,只要我们能 定义出忽略大小写的比较算法就可以: def cmp_ignore_case(s1, s2): u1 = s1.upper() u2 = s2.upper() if u1 < u2: return -1 if u1 > u2: return 1 return 0 忽略大小写来比较两个字符串,实际上就是先把字符串都变成大写(或者都变成小写),再比较。 这样,我们给 sorted 传入上述比较函数,即可实现忽略大小写的排序: >>> sorted(['bob', 'about', 'Zoo', 'Credit'], cmp_ignore_case) ['about', 'bob', 'Credit', 'Zoo'] 从上述例子可以看出,高阶函数的抽象能力是非常强大的,而且,核心代码可以保持得非常简洁。 您的鼓励是作者写作最大的动力 如果您认为本网站的教程质量不错,读后觉得收获很大,预期工资涨幅能超过30%,不妨小额赞助我一下,让我有 动力继续写出高质量的教程: 返回函数 86次阅读 函数作为返回值 高阶函数除了可以接受函数作为参数外,还可以把函数作为结果值返回。 我们来实现一个可变参数的求和。通常情况下,求和的函数是这样定义的: def calc_sum(*args): ax = 0 for n in args: ax = ax + n return ax 但是,如果不需要立刻求和,而是在后面的代码中,根据需要再计算怎么办?可以不返回求和的结果,而是返回求 和的函数! def lazy_sum(*args): def sum(): ax = 0 for n in args: ax = ax + n return ax return sum 当我们调用 lazy_sum() 时,返回的并不是求和结果,而是求和函数: >>> f = lazy_sum(1, 3, 5, 7, 9) >>> f 调用函数 f 时,才真正计算求和的结果: >>> f() 25 在这个例子中,我们在函数 lazy_sum 中又定义了函数 sum ,并且,内部函数 sum 可以引用外部函数 lazy_sum 的参 数和局部变量,当 lazy_sum 返回函数 sum 时,相关参数和变量都保存在返回的函数中,这种称为“闭包(Closur e)”的程序结构拥有极大的威力。 请再注意一点,当我们调用 lazy_sum() 时,每次调用都会返回一个新的函数,即使传入相同的参数: >>> f1 = lazy_sum(1, 3, 5, 7, 9) >>> f2 = lazy_sum(1, 3, 5, 7, 9) >>> f2 = lazy_sum(1, 3, 5, 7, 9) >>> f1==f2 False f1() 和 f2() 的调用结果互不影响。 闭包 注意到返回的函数在其定义内部引用了局部变量 args ,所以,当一个函数返回了一个函数后,其内部的局部变量还 被新函数引用,所以,闭包用起来简单,实现起来可不容易。 另一个需要注意的问题是,返回的函数并没有立刻执行,而是直到调用了 f() 才执行。我们来看一个例子: def count(): fs = [] for i in range(1, 4): def f(): return i*i fs.append(f) return fs f1, f2, f3 = count() 在上面的例子中,每次循环,都创建了一个新的函数,然后,把创建的3个函数都返回了。 你可能认为调用 f1() , f2() 和 f3() 结果应该是 1 , 4 , 9 ,但实际结果是: >>> f1() 9 >>> f2() 9 >>> f3() 9 全部都是 9 !原因就在于返回的函数引用了变量 i ,但它并非立刻执行。等到3个函数都返回时,它们所引用的变 量 i 已经变成了3,因此最终结果为 9 。 返回闭包时牢记的一点就是:返回函数不要引用任何循环变量,或者后续会发生变化的变量。 如果一定要引用循环变量怎么办?方法是再创建一个函数,用该函数的参数绑定循环变量当前的值,无论该循环变 量后续如何更改,已绑定到函数参数的值不变: >>> def count(): ... fs = [] ... for i in range(1, 4): ... def f(j): ... def g(): ... return j*j ... return g ... fs.append(f(i)) ... return fs ... >>> f1, f2, f3 = count() >>> f1() >>> f1() 1 >>> f2() 4 >>> f3() 9 缺点是代码较长,可利用lambda函数缩短代码。 您的鼓励是作者写作最大的动力 如果您认为本网站的教程质量不错,读后觉得收获很大,预期工资涨幅能超过30%,不妨小额赞助我一下,让我有 动力继续写出高质量的教程: 匿名函数 62次阅读 当我们在传入函数时,有些时候,不需要显式地定义函数,直接传入匿名函数更方便。 在Python中,对匿名函数提供了有限支持。还是以 map() 函数为例,计算f(x)=x 时,除了定义一个 f(x) 的函数 外,还可以直接传入匿名函数: >>> map(lambda x: x * x, [1, 2, 3, 4, 5, 6, 7, 8, 9]) [1, 4, 9, 16, 25, 36, 49, 64, 81] 通过对比可以看出,匿名函数 lambda x: x * x 实际上就是: def f(x): return x * x 关键字 lambda 表示匿名函数,冒号前面的 x 表示函数参数。 匿名函数有个限制,就是只能有一个表达式,不用写 return ,返回值就是该表达式的结果。 用匿名函数有个好处,因为函数没有名字,不必担心函数名冲突。此外,匿名函数也是一个函数对象,也可以把匿 名函数赋值给一个变量,再利用变量来调用该函数: >>> f = lambda x: x * x >>> f at 0x10453d7d0> >>> f(5) 25 同样,也可以把匿名函数作为返回值返回,比如: def build(x, y): return lambda: x * x + y * y 小结 Python对匿名函数的支持有限,只有一些简单的情况下可以使用匿名函数。 您的鼓励是作者写作最大的动力 如果您认为本网站的教程质量不错,读后觉得收获很大,预期工资涨幅能超过30%,不妨小额赞助我一下,让我有 动力继续写出高质量的教程: 装饰器 125次阅读 2 由于函数也是一个对象,而且函数对象可以被赋值给变量,所以,通过变量也能调用该函数。 >>> def now(): ... print '2013-12-25' ... >>> f = now >>> f() 2013-12-25 函数对象有一个 __name__ 属性,可以拿到函数的名字: >>> now.__name__ 'now' >>> f.__name__ 'now' 现在,假设我们要增强 now() 函数的功能,比如,在函数调用前后自动打印日志,但又不希望修改 now() 函数的定 义,这种在代码运行期间动态增加功能的方式,称之为“装饰器”(Decorator)。 本质上,decorator就是一个返回函数的高阶函数。所以,我们要定义一个能打印日志的decorator,可以定义如下: def log(func): def wrapper(*args, **kw): print 'call %s():' % func.__name__ return func(*args, **kw) return wrapper 观察上面的 log ,因为它是一个decorator,所以接受一个函数作为参数,并返回一个函数。我们要借助Python 的@语法,把decorator置于函数的定义处: @log def now(): print '2013-12-25' 调用 now() 函数,不仅会运行 now() 函数本身,还会在运行 now() 函数前打印一行日志: >>> now() call now(): 2013-12-25 把 @log 放到 now() 函数的定义处,相当于执行了语句: now = log(now) 由于 log() 是一个decorator,返回一个函数,所以,原来的 now() 函数仍然存在,只是现在同名的now变量指向了 新的函数,于是调用 now() 将执行新函数,即在 log() 函数中返回的 wrapper() 函数。 wrapper() 函数的参数定义是 (*args, **kw) ,因此, wrapper() 函数可以接受任意参数的调用。在 wrapper() 函数 内,首先打印日志,再紧接着调用原始函数。 如果decorator本身需要传入参数,那就需要编写一个返回decorator的高阶函数,写出来会更复杂。比如,要自定义 log的文本: def log(text): def decorator(func): def wrapper(*args, **kw): print '%s %s():' % (text, func.__name__) return func(*args, **kw) return wrapper return decorator 这个3层嵌套的decorator用法如下: @log('execute') def now(): print '2013-12-25' 执行结果如下: >>> now() execute now(): 2013-12-25 和两层嵌套的decorator相比,3层嵌套的效果是这样的: >>> now = log('execute')(now) 我们来剖析上面的语句,首先执行 log('execute') ,返回的是 decorator 函数,再调用返回的函数,参数是 now 函 数,返回值最终是 wrapper 函数。 以上两种decorator的定义都没有问题,但还差最后一步。因为我们讲了函数也是对象,它有 __name__ 等属性,但 你去看经过decorator装饰之后的函数,它们的 __name__ 已经从原来的 'now' 变成了 'wrapper' : >>> now.__name__ 'wrapper' 因为返回的那个 wrapper() 函数名字就是 'wrapper' ,所以,需要把原始函数的 __name__ 等属性复制 到 wrapper() 函数中,否则,有些依赖函数签名的代码执行就会出错。 不需要编写 wrapper.__name__ = func.__name__ 这样的代码,Python内置的 functools.wraps 就是干这个事的,所 以,一个完整的decorator的写法如下: import functools def log(func): @functools.wraps(func) def wrapper(*args, **kw): print 'call %s():' % func.__name__ return func(*args, **kw) return wrapper return wrapper 或者针对带参数的decorator: import functools def log(text): def decorator(func): @functools.wraps(func) def wrapper(*args, **kw): print '%s %s():' % (text, func.__name__) return func(*args, **kw) return wrapper return decorator import functools 是导入 functools 模块。模块的概念稍候讲解。现在,只需记住在定义 wrapper() 的前面加 上 @functools.wraps(func) 即可。 小结 在面向对象(OOP)的设计模式中,decorator被称为装饰模式。OOP的装饰模式需要通过继承和组合来实现,而P ython除了能支持OOP的decorator外,直接从语法层次支持decorator。Python的decorator可以用函数实现,也可 以用类实现。 decorator可以增强函数的功能,定义起来虽然有点复杂,但使用起来非常灵活和方便。 请编写一个decorator,能在函数调用的前后打印出 'begin call' 和 'end call' 的日志。 再思考一下能否写出一个 @log 的decorator,使它既支持: @log def f(): pass 又支持: @log('execute') def f(): pass 您的鼓励是作者写作最大的动力 如果您认为本网站的教程质量不错,读后觉得收获很大,预期工资涨幅能超过30%,不妨小额赞助我一下,让我有 动力继续写出高质量的教程: 偏函数 64次阅读 Python的 functools 模块提供了很多有用的功能,其中一个就是偏函数(Partial function)。要注意,这里的偏函 数和数学意义上的偏函数不一样。 在介绍函数参数的时候,我们讲到,通过设定参数的默认值,可以降低函数调用的难度。而偏函数也可以做到这一 点。举例如下: int() 函数可以把字符串转换为整数,当仅传入字符串时, int() 函数默认按十进制转换: >>> int('12345') 12345 但 int() 函数还提供额外的 base 参数,默认值为 10 。如果传入 base 参数,就可以做N进制的转换: >>> int('12345', base=8) 5349 >>> int('12345', 16) 74565 假设要转换大量的二进制字符串,每次都传入 int(x, base=2) 非常麻烦,于是,我们想到,可以定义一 个 int2() 的函数,默认把 base=2 传进去: def int2(x, base=2): return int(x, base) 这样,我们转换二进制就非常方便了: >>> int2('1000000') 64 >>> int2('1010101') 85 functools.partial 就是帮助我们创建一个偏函数的,不需要我们自己定义 int2() ,可以直接使用下面的代码创建 一个新的函数 int2 : >>> import functools >>> int2 = functools.partial(int, base=2) >>> int2('1000000') 64 >>> int2('1010101') 85 所以,简单总结 functools.partial 的作用就是,把一个函数的某些参数给固定住(也就是设置默认值),返回一个 新的函数,调用这个新函数会更简单。 注意到上面的新的 int2 函数,仅仅是把 base 参数重新设定默认值为 2 ,但也可以在函数调用时传入其他值: >>> int2('1000000', base=10) 1000000 最后,创建偏函数时,实际上可以接收函数对象、 *args 和 **kw 这3个参数,当传入: 最后,创建偏函数时,实际上可以接收函数对象、 *args 和 **kw 这3个参数,当传入: int2 = functools.partial(int, base=2) 实际上固定了int()函数的关键字参数 base ,也就是: int2('10010') 相当于: kw = { base: 2 } int('10010', **kw) 当传入: max2 = functools.partial(max, 10) 实际上会把 10 作为 *args 的一部分自动加到左边,也就是: max2(5, 6, 7) 相当于: args = (10, 5, 6, 7) max(*args) 结果为 10 。 小结 当函数的参数个数太多,需要简化时,使用 functools.partial 可以创建一个新的函数,这个新函数可以固定住原函 数的部分参数,从而在调用时更简单。 您的鼓励是作者写作最大的动力 如果您认为本网站的教程质量不错,读后觉得收获很大,预期工资涨幅能超过30%,不妨小额赞助我一下,让我有 动力继续写出高质量的教程: 模块 75次阅读 在计算机程序的开发过程中,随着程序代码越写越多,在一个文件里代码就会越来越长,越来越不容易维护。 为了编写可维护的代码,我们把很多函数分组,分别放到不同的文件里,这样,每个文件包含的代码就相对较 少,很多编程语言都采用这种组织代码的方式。在Python中,一个.py文件就称之为一个模块(Module)。 使用模块有什么好处? 最大的好处是大大提高了代码的可维护性。其次,编写代码不必从零开始。当一个模块编写完毕,就可以被其他地 方引用。我们在编写程序的时候,也经常引用其他模块,包括Python内置的模块和来自第三方的模块。 使用模块还可以避免函数名和变量名冲突。相同名字的函数和变量完全可以分别存在不同的模块中,因此,我们自 己在编写模块时,不必考虑名字会与其他模块冲突。但是也要注意,尽量不要与内置函数名字冲突。点这里查看Pyt hon的所有内置函数。 你也许还想到,如果不同的人编写的模块名相同怎么办?为了避免模块名冲突,Python又引入了按目录来组织模块 的方法,称为包(Package)。 举个例子,一个 abc.py 的文件就是一个名字叫 abc 的模块,一个 xyz.py 的文件就是一个名字叫 xyz 的模块。 现在,假设我们的 abc 和 xyz 这两个模块名字与其他模块冲突了,于是我们可以通过包来组织模块,避免冲突。方 法是选择一个顶层包名,比如 mycompany ,按照如下目录存放: 引入了包以后,只要顶层的包名不与别人冲突,那所有模块都不会与别人冲突。现在, abc.py 模块的名字就变成 了 mycompany.abc ,类似的, xyz.py 的模块名变成了 mycompany.xyz 。 请注意,每一个包目录下面都会有一个 __init__.py 的文件,这个文件是必须存在的,否则,Python就把这个目录 当成普通目录,而不是一个包。 __init__.py 可以是空文件,也可以有Python代码,因为 __init__.py 本身就是一 个模块,而它的模块名就是 mycompany 。 类似的,可以有多级目录,组成多级层次的包结构。比如如下的目录结构: 文件 www.py 的模块名就是 mycompany.web.www ,两个文件 utils.py 的模块名分别是 mycompany.utils 和 mycompany.web.utils 。 mycompany.web 也是一个模块,请指出该模块对应的.py文件。 您的鼓励是作者写作最大的动力 如果您认为本网站的教程质量不错,读后觉得收获很大,预期工资涨幅能超过30%,不妨小额赞助我一下,让我有 动力继续写出高质量的教程: 使用模块 116次阅读 Python本身就内置了很多非常有用的模块,只要安装完毕,这些模块就可以立刻使用。 我们以内建的 sys 模块为例,编写一个 hello 的模块: #!/usr/bin/env python # -*- coding: utf-8 -*- ' a test module ' __author__ = 'Michael Liao' import sys def test(): args = sys.argv if len(args)==1: print 'Hello, world!' elif len(args)==2: print 'Hello, %s!' % args[1] else: print 'Too many arguments!' if __name__=='__main__': test() 第1行和第2行是标准注释,第1行注释可以让这个 hello.py 文件直接在Unix/Linux/Mac上运行,第2行注释表示.py 第1行和第2行是标准注释,第1行注释可以让这个 hello.py 文件直接在Unix/Linux/Mac上运行,第2行注释表示.py 文件本身使用标准UTF­8编码; 第4行是一个字符串,表示模块的文档注释,任何模块代码的第一个字符串都被视为模块的文档注释; 第6行使用 __author__ 变量把作者写进去,这样当你公开源代码后别人就可以瞻仰你的大名; 以上就是Python模块的标准文件模板,当然也可以全部删掉不写,但是,按标准办事肯定没错。 后面开始就是真正的代码部分。 你可能注意到了,使用 sys 模块的第一步,就是导入该模块: import sys 导入 sys 模块后,我们就有了变量 sys 指向该模块,利用 sys 这个变量,就可以访问 sys 模块的所有功能。 sys 模块有一个 argv 变量,用list存储了命令行的所有参数。 argv 至少有一个元素,因为第一个参数永远是该.py 文件的名称,例如: 运行 python hello.py 获得的 sys.argv 就是 ['hello.py'] ; 运行 python hello.py Michael 获得的 sys.argv 就是 ['hello.py', 'Michael] 。 最后,注意到这两行代码: if __name__=='__main__': test() 当我们在命令行运行 hello 模块文件时,Python解释器把一个特殊变量 __name__ 置为 __main__ ,而如果在其他地 方导入该 hello 模块时, if 判断将失败,因此,这种 if 测试可以让一个模块通过命令行运行时执行一些额外的代 码,最常见的就是运行测试。 我们可以用命令行运行 hello.py 看看效果: $ python hello.py Hello, world! $ python hello.py Michael Hello, Michael! 如果启动Python交互环境,再导入 hello 模块: $ python Python 2.7.5 (default, Aug 25 2013, 00:04:04) [GCC 4.2.1 Compatible Apple LLVM 5.0 (clang-500.0.68)] on darwin Type "help", "copyright", "credits" or "license" for more information. >>> import hello >>> 导入时,没有打印 Hello, word! ,因为没有执行 test() 函数。 调用 hello.test() 时,才能打印出 Hello, word! : >>> hello.test() Hello, world! 别名 导入模块时,还可以使用别名,这样,可以在运行时根据当前环境选择最合适的模块。比如Python标准库一般会提 供 StringIO 和 cStringIO 两个库,这两个库的接口和功能是一样的,但是 cStringIO 是C写的,速度更快,所 以,你会经常看到这样的写法: try: import cStringIO as StringIO except ImportError: # 导入失败会捕获到ImportError import StringIO 这样就可以优先导入 cStringIO 。如果有些平台不提供 cStringIO ,还可以降级使用 StringIO 。导入 cStringIO 时,用 import ... as ... 指定了别名 StringIO ,因此,后续代码引用 StringIO 即可正常工作。 还有类似 simplejson 这样的库,在Python 2.6之前是独立的第三方库,从2.6开始内置,所以,会有这样的写法: try: import json # python >= 2.6 except ImportError: import simplejson as json # python <= 2.5 由于Python是动态语言,函数签名一致接口就一样,因此,无论导入哪个模块后续代码都能正常工作。 作用域 在一个模块中,我们可能会定义很多函数和变量,但有的函数和变量我们希望给别人使用,有的函数和变量我们希 望仅仅在模块内部使用。在Python中,是通过 _ 前缀来实现的。 正常的函数和变量名是公开的(public),可以被直接引用,比如: abc , x123 , PI 等; 类似 __xxx__ 这样的变量是特殊变量,可以被直接引用,但是有特殊用途,比如上面的 __author__ , __name__ 就 是特殊变量, hello 模块定义的文档注释也可以用特殊变量 __doc__ 访问,我们自己的变量一般不要用这种变量 名; 类似 _xxx 和 __xxx 这样的函数或变量就是非公开的(private),不应该被直接引用,比如 _abc , __abc 等; 之所以我们说,private函数和变量“不应该”被直接引用,而不是“不能”被直接引用,是因为Python并没有一种方法可 以完全限制访问private函数或变量,但是,从编程习惯上不应该引用private函数或变量。 private函数或变量不应该被别人引用,那它们有什么用呢?请看例子: def _private_1(name): return 'Hello, %s' % name def _private_2(name): return 'Hi, %s' % name def greeting(name): if len(name) > 3: return _private_1(name) else: return _private_2(name) 我们在模块里公开 greeting() 函数,而把内部逻辑用private函数隐藏起来了,这样,调用 greeting() 函数不用关 心内部的private函数细节,这也是一种非常有用的代码封装和抽象的方法,即: 外部不需要引用的函数全部定义成private,只有外部需要引用的函数才定义为public。 您的鼓励是作者写作最大的动力 如果您认为本网站的教程质量不错,读后觉得收获很大,预期工资涨幅能超过30%,不妨小额赞助我一下,让我有 动力继续写出高质量的教程: 安装第三方模块 111次阅读 在Python中,安装第三方模块,是通过setuptools这个工具完成的。Python有两个封装了setuptools的包管理工 具: easy_install 和 pip 。目前官方推荐使用 pip 。 如果你正在使用Mac或Linux,安装pip本身这个步骤就可以跳过了。 如果你正在使用Windows,请参考安装Python一节的内容,确保安装时勾选了 pip 和 Add python.exe to Path 。 在命令提示符窗口下尝试运行 pip ,如果Windows提示未找到命令,可以重新运行安装程序添加 pip 。 现在,让我们来安装一个第三方库——Python Imaging Library,这是Python下非常强大的处理图像的工具库。一般 来说,第三方库都会在Python官方的pypi.python.org网站注册,要安装一个第三方库,必须先知道该库的名称,可 以在官网或者pypi上搜索,比如Python Imaging Library的名称叫PIL,因此,安装Python Imaging Library的命令就 是: pip install PIL 耐心等待下载并安装后,就可以使用PIL了。 有了PIL,处理图片易如反掌。随便找个图片生成缩略图: >>> import Image >>> im = Image.open('test.png') >>> print im.format, im.size, im.mode PNG (400, 300) RGB >>> im.thumbnail((200, 100)) >>> im.save('thumb.jpg', 'JPEG') 其他常用的第三方库还有MySQL的驱动: MySQL‐python ,用于科学计算的NumPy库: numpy ,用于生成文本的模 板工具 Jinja2 ,等等。 模块搜索路径 当我们试图加载一个模块时,Python会在指定的路径下搜索对应的.py文件,如果找不到,就会报错: >>> import mymodule Traceback (most recent call last): File "", line 1, in ImportError: No module named mymodule 默认情况下,Python解释器会搜索当前目录、所有已安装的内置模块和第三方模块,搜索路径存放在 sys 模块 的 path 变量中: >>> import sys >>> sys.path ['', '/Library/Python/2.7/site-packages/pycrypto-2.6.1-py2.7-macosx-10.9-intel.egg', '/Library/Python/2.7/site-pac kages/PIL-1.1.7-py2.7-macosx-10.9-intel.egg', ...] 如果我们要添加自己的搜索目录,有两种方法: 一是直接修改 sys.path ,添加要搜索的目录: >>> import sys >>> sys.path.append('/Users/michael/my_py_scripts') 这种方法是在运行时修改,运行结束后失效。 第二种方法是设置环境变量 PYTHONPATH ,该环境变量的内容会被自动添加到模块搜索路径中。设置方式与设置Path 环境变量类似。注意只需要添加你自己的搜索路径,Python自己本身的搜索路径不受影响。 您的鼓励是作者写作最大的动力 如果您认为本网站的教程质量不错,读后觉得收获很大,预期工资涨幅能超过30%,不妨小额赞助我一下,让我有 动力继续写出高质量的教程: 使用__future__ 74次阅读 Python的每个新版本都会增加一些新的功能,或者对原来的功能作一些改动。有些改动是不兼容旧版本的,也就是 在当前版本运行正常的代码,到下一个版本运行就可能不正常了。 从Python 2.7到Python 3.x就有不兼容的一些改动,比如2.x里的字符串用 'xxx' 表示str,Unicode字符串 用 u'xxx' 表示unicode,而在3.x中,所有字符串都被视为unicode,因此,写 u'xxx' 和 'xxx' 是完全一致的,而在 2.x中以 'xxx' 表示的str就必须写成 b'xxx' ,以此表示“二进制字符串”。 要直接把代码升级到3.x是比较冒进的,因为有大量的改动需要测试。相反,可以在2.7版本中先在一部分代码中测试 一些3.x的特性,如果没有问题,再移植到3.x不迟。 Python提供了 __future__ 模块,把下一个新版本的特性导入到当前版本,于是我们就可以在当前版本中测试一些新 Python提供了 __future__ 模块,把下一个新版本的特性导入到当前版本,于是我们就可以在当前版本中测试一些新 版本的特性。举例说明如下: 为了适应Python 3.x的新的字符串的表示方法,在2.7版本的代码中,可以通过 unicode_literals 来使用Python 3.x 的新的语法: # still running on Python 2.7 from __future__ import unicode_literals print '\'xxx\' is unicode?', isinstance('xxx', unicode) print 'u\'xxx\' is unicode?', isinstance(u'xxx', unicode) print '\'xxx\' is str?', isinstance('xxx', str) print 'b\'xxx\' is str?', isinstance(b'xxx', str) 注意到上面的代码仍然在Python 2.7下运行,但结果显示去掉前缀 u 的 'a string' 仍是一个unicode,而加上前 缀 b 的 b'a string' 才变成了str: $ python task.py 'xxx' is unicode? True u'xxx' is unicode? True 'xxx' is str? False b'xxx' is str? True 类似的情况还有除法运算。在Python 2.x中,对于除法有两种情况,如果是整数相除,结果仍是整数,余数会被扔 掉,这种除法叫“地板除”: >>> 10 / 3 3 要做精确除法,必须把其中一个数变成浮点数: >>> 10.0 / 3 3.3333333333333335 而在Python 3.x中,所有的除法都是精确除法,地板除用 // 表示: $ python3 Python 3.3.2 (default, Jan 22 2014, 09:54:40) [GCC 4.2.1 Compatible Apple LLVM 5.0 (clang-500.2.79)] on darwin Type "help", "copyright", "credits" or "license" for more information. >>> 10 / 3 3.3333333333333335 >>> 10 // 3 3 如果你想在Python 2.7的代码中直接使用Python 3.x的除法,可以通过 __future__ 模块的 division 实现: from __future__ import division print '10 / 3 =', 10 / 3 print '10.0 / 3 =', 10.0 / 3 print '10 // 3 =', 10 // 3 结果如下: 10 / 3 = 3.33333333333 10.0 / 3 = 3.33333333333 10 // 3 = 3 小结 由于Python是由社区推动的开源并且免费的开发语言,不受商业公司控制,因此,Python的改进往往比较激进,不 兼容的情况时有发生。Python为了确保你能顺利过渡到新版本,特别提供了 __future__ 模块,让你在旧的版本中试 验新版本的一些特性。 您的鼓励是作者写作最大的动力 如果您认为本网站的教程质量不错,读后觉得收获很大,预期工资涨幅能超过30%,不妨小额赞助我一下,让我有 动力继续写出高质量的教程: 面向对象编程 97次阅读 面向对象编程——Object Oriented Programming,简称OOP,是一种程序设计思想。OOP把对象作为程序的基本 单元,一个对象包含了数据和操作数据的函数。 面向过程的程序设计把计算机程序视为一系列的命令集合,即一组函数的顺序执行。为了简化程序设计,面向过程 把函数继续切分为子函数,即把大块函数通过切割成小块函数来降低系统的复杂度。 而面向对象的程序设计把计算机程序视为一组对象的集合,而每个对象都可以接收其他对象发过来的消息,并处理 这些消息,计算机程序的执行就是一系列消息在各个对象之间传递。 在Python中,所有数据类型都可以视为对象,当然也可以自定义对象。自定义的对象数据类型就是面向对象中的 类(Class)的概念。 我们以一个例子来说明面向过程和面向对象在程序流程上的不同之处。 假设我们要处理学生的成绩表,为了表示一个学生的成绩,面向过程的程序可以用一个dict表示: std1 = { 'name': 'Michael', 'score': 98 } std2 = { 'name': 'Bob', 'score': 81 } 而处理学生成绩可以通过函数实现,比如打印学生的成绩: def print_score(std): print '%s: %s' % (std['name'], std['score']) 如果采用面向对象的程序设计思想,我们首选思考的不是程序的执行流程,而是 Student 这种数据类型应该被视为 如果采用面向对象的程序设计思想,我们首选思考的不是程序的执行流程,而是 Student 这种数据类型应该被视为 一个对象,这个对象拥有 name 和 score 这两个属性(Property)。如果要打印一个学生的成绩,首先必须创建出这 个学生对应的对象,然后,给对象发一个 print_score 消息,让对象自己把自己的数据打印出来。 class Student(object): def __init__(self, name, score): self.name = name self.score = score def print_score(self): print '%s: %s' % (self.name, self.score) 给对象发消息实际上就是调用对象对应的关联函数,我们称之为对象的方法(Method)。面向对象的程序写出来就 像这样: bart = Student('Bart Simpson', 59) lisa = Student('Lisa Simpson', 87) bart.print_score() lisa.print_score() 面向对象的设计思想是从自然界中来的,因为在自然界中,类(Class)和实例(Instance)的概念是很自然的。Cl ass是一种抽象概念,比如我们定义的Class——Student,是指学生这个概念,而实例(Instance)则是一个个具体 的Student,比如,Bart Simpson和Lisa Simpson是两个具体的Student: 所以,面向对象的设计思想是抽象出Class,根据Class创建Instance。 面向对象的抽象程度又比函数要高,因为一个Class既包含数据,又包含操作数据的方法。 小结 数据封装、继承和多态是面向对象的三大特点,我们后面会详细讲解。 您的鼓励是作者写作最大的动力 如果您认为本网站的教程质量不错,读后觉得收获很大,预期工资涨幅能超过30%,不妨小额赞助我一下,让我有 动力继续写出高质量的教程: 类和实例 167次阅读 面向对象最重要的概念就是类(Class)和实例(Instance),必须牢记类是抽象的模板,比如Student类,而实例 是根据类创建出来的一个个具体的“对象”,每个对象都拥有相同的方法,但各自的数据可能不同。 仍以Student类为例,在Python中,定义类是通过 class 关键字: class Student(object): pass class 后面紧接着是类名,即 Student ,类名通常是大写开头的单词,紧接着是 (object) ,表示该类是从哪个类继 承下来的,继承的概念我们后面再讲,通常,如果没有合适的继承类,就使用 object 类,这是所有类最终都会继承 的类。 定义好了 Student 类,就可以根据 Student 类创建出 Student 的实例,创建实例是通过类名+()实现的: >>> bart = Student() >>> bart <__main__.Student object at 0x10a67a590> >>> Student 可以看到,变量 bart 指向的就是一个Student的object,后面的 0x10a67a590 是内存地址,每个object的地址都不一 样,而 Student 本身则是一个类。 可以自由地给一个实例变量绑定属性,比如,给实例 bart 绑定一个 name 属性: >>> bart.name = 'Bart Simpson' >>> bart.name 'Bart Simpson' 由于类可以起到模板的作用,因此,可以在创建实例的时候,把一些我们认为必须绑定的属性强制填写进去。通过 定义一个特殊的 __init__ 方法,在创建实例的时候,就把 name , score 等属性绑上去: class Student(object): def __init__(self, name, score): self.name = name self.score = score 注意到 __init__ 方法的第一个参数永远是 self ,表示创建的实例本身,因此,在 __init__ 方法内部,就可以把各 种属性绑定到 self ,因为 self 就指向创建的实例本身。 有了 __init__ 方法,在创建实例的时候,就不能传入空的参数了,必须传入与 __init__ 方法匹配的参数,但 self 不需要传,Python解释器自己会把实例变量传进去: >>> bart = Student('Bart Simpson', 59) >>> bart.name 'Bart Simpson' >>> bart.score 59 和普通的函数相比,在类中定义的函数只有一点不同,就是第一个参数永远是实例变量 self ,并且,调用时,不用 传递该参数。除此之外,类的方法和普通函数没有什么区别,所以,你仍然可以用默认参数、可变参数和关键字参 数。 数据封装 面向对象编程的一个重要特点就是数据封装。在上面的 Student 类中,每个实例就拥有各自的 name 和 score 这些数 据。我们可以通过函数来访问这些数据,比如打印一个学生的成绩: 据。我们可以通过函数来访问这些数据,比如打印一个学生的成绩: >>> def print_score(std): ... print '%s: %s' % (std.name, std.score) ... >>> print_score(bart) Bart Simpson: 59 但是,既然 Student 实例本身就拥有这些数据,要访问这些数据,就没有必要从外面的函数去访问,可以直接 在 Student 类的内部定义访问数据的函数,这样,就把“数据”给封装起来了。这些封装数据的函数是和 Student 类本 身是关联起来的,我们称之为类的方法: class Student(object): def __init__(self, name, score): self.name = name self.score = score def print_score(self): print '%s: %s' % (self.name, self.score) 要定义一个方法,除了第一个参数是 self 外,其他和普通函数一样。要调用一个方法,只需要在实例变量上直接调 用,除了 self 不用传递,其他参数正常传入: >>> bart.print_score() Bart Simpson: 59 这样一来,我们从外部看 Student 类,就只需要知道,创建实例需要给出 name 和 score ,而如何打印,都是 在 Student 类的内部定义的,这些数据和逻辑被“封装”起来了,调用很容易,但却不用知道内部实现的细节。 封装的另一个好处是可以给 Student 类增加新的方法,比如 get_grade : class Student(object): ... def get_grade(self): if self.score >= 90: return 'A' elif self.score >= 60: return 'B' else: return 'C' 同样的, get_grade 方法可以直接在实例变量上调用,不需要知道内部实现细节: >>> bart.get_grade() 'C' 小结 类是创建实例的模板,而实例则是一个一个具体的对象,各个实例拥有的数据都互相独立,互不影响; 类是创建实例的模板,而实例则是一个一个具体的对象,各个实例拥有的数据都互相独立,互不影响; 方法就是与实例绑定的函数,和普通函数不同,方法可以直接访问实例的数据; 通过在实例上调用方法,我们就直接操作了对象内部的数据,但无需知道方法内部的实现细节。 和静态语言不同,Python允许对实例变量绑定任何数据,也就是说,对于两个实例变量,虽然它们都是同一个类的 不同实例,但拥有的变量名称都可能不同: >>> bart = Student('Bart Simpson', 59) >>> lisa = Student('Lisa Simpson', 87) >>> bart.age = 8 >>> bart.age 8 >>> lisa.age Traceback (most recent call last): File "", line 1, in AttributeError: 'Student' object has no attribute 'age' 您的鼓励是作者写作最大的动力 如果您认为本网站的教程质量不错,读后觉得收获很大,预期工资涨幅能超过30%,不妨小额赞助我一下,让我有 动力继续写出高质量的教程: 访问限制 88次阅读 在Class内部,可以有属性和方法,而外部代码可以通过直接调用实例变量的方法来操作数据,这样,就隐藏了内部 的复杂逻辑。 但是,从前面Student类的定义来看,外部代码还是可以自由地修改一个实例的 name 、 score 属性: >>> bart = Student('Bart Simpson', 98) >>> bart.score 98 >>> bart.score = 59 >>> bart.score 59 如果要让内部属性不被外部访问,可以把属性的名称前加上两个下划线 __ ,在Python中,实例的变量名如果 以 __ 开头,就变成了一个私有变量(private),只有内部可以访问,外部不能访问,所以,我们把Student类改一 改: class Student(object): def __init__(self, name, score): self.__name = name self.__score = score def print_score(self): print '%s: %s' % (self.__name, self.__score) 改完后,对于外部代码来说,没什么变动,但是已经无法从外部访问 实例变量.__name 和 实例变量.__score 了: >>> bart = Student('Bart Simpson', 98) >>> bart.__name Traceback (most recent call last): File "", line 1, in AttributeError: 'Student' object has no attribute '__name' 这样就确保了外部代码不能随意修改对象内部的状态,这样通过访问限制的保护,代码更加健壮。 但是如果外部代码要获取name和score怎么办?可以给Student类增加 get_name 和 get_score 这样的方法: class Student(object): ... def get_name(self): return self.__name def get_score(self): return self.__score 如果又要允许外部代码修改score怎么办?可以给Student类增加 set_score 方法: class Student(object): ... def set_score(self, score): self.__score = score 你也许会问,原先那种直接通过 bart.score = 59 也可以修改啊,为什么要定义一个方法大费周折?因为在方法 中,可以对参数做检查,避免传入无效的参数: class Student(object): ... def set_score(self, score): if 0 <= score <= 100: self.__score = score else: raise ValueError('bad score') 需要注意的是,在Python中,变量名类似 __xxx__ 的,也就是以双下划线开头,并且以双下划线结尾的,是特殊变 量,特殊变量是可以直接访问的,不是private变量,所以,不能用 __name__ 、 __score__ 这样的变量名。 有些时候,你会看到以一个下划线开头的实例变量名,比如 _name ,这样的实例变量外部是可以访问的,但是,按 照约定俗成的规定,当你看到这样的变量时,意思就是,“虽然我可以被访问,但是,请把我视为私有变量,不要随 意访问”。 双下划线开头的实例变量是不是一定不能从外部访问呢?其实也不是。不能直接访问 __name 是因为Python解释器对 外把 __name 变量改成了 _Student__name ,所以,仍然可以通过 _Student__name 来访问 __name 变量: 外把 __name 变量改成了 _Student__name ,所以,仍然可以通过 _Student__name 来访问 __name 变量: >>> bart._Student__name 'Bart Simpson' 但是强烈建议你不要这么干,因为不同版本的Python解释器可能会把 __name 改成不同的变量名。 总的来说就是,Python本身没有任何机制阻止你干坏事,一切全靠自觉。 您的鼓励是作者写作最大的动力 如果您认为本网站的教程质量不错,读后觉得收获很大,预期工资涨幅能超过30%,不妨小额赞助我一下,让我有 动力继续写出高质量的教程: 继承和多态 80次阅读 在OOP程序设计中,当我们定义一个class的时候,可以从某个现有的class继承,新的class称为子类(Subclas s),而被继承的class称为基类、父类或超类(Base class、Super class)。 比如,我们已经编写了一个名为 Animal 的class,有一个 run() 方法可以直接打印: class Animal(object): def run(self): print 'Animal is running...' 当我们需要编写Dog和Cat类时,就可以直接从Animal类继承: class Dog(Animal): pass class Cat(Animal): pass 对于Dog来说,Animal就是它的父类,对于Animal来说,Dog就是它的子类。Cat和Dog类似。 继承有什么好处?最大的好处是子类获得了父类的全部功能。由于Animial实现了 run() 方法,因此,Dog和Cat作为 它的子类,什么事也没干,就自动拥有了 run() 方法: dog = Dog() dog.run() cat = Cat() cat.run() 运行结果如下: Animal is running... Animal is running... Animal is running... 当然,也可以对子类增加一些方法,比如Dog类: class Dog(Animal): def run(self): print 'Dog is running...' def eat(self): print 'Eating meat...' 继承的第二个好处需要我们对代码做一点改进。你看到了,无论是Dog还是Cat,它们 run() 的时候,显示的都 是 Animal is running... ,符合逻辑的做法是分别显示 Dog is running... 和 Cat is running... ,因此,对Dog和 Cat类改进如下: class Dog(Animal): def run(self): print 'Dog is running...' class Cat(Animal): def run(self): print 'Cat is running...' 再次运行,结果如下: Dog is running... Cat is running... 当子类和父类都存在相同的 run() 方法时,我们说,子类的 run() 覆盖了父类的 run() ,在代码运行的时候,总是 会调用子类的 run() 。这样,我们就获得了继承的另一个好处:多态。 要理解什么是多态,我们首先要对数据类型再作一点说明。当我们定义一个class的时候,我们实际上就定义了一种 数据类型。我们定义的数据类型和Python自带的数据类型,比如str、list、dict没什么两样: a = list() # a是list类型 b = Animal() # b是Animal类型 c = Dog() # c是Dog类型 判断一个变量是否是某个类型可以用 isinstance() 判断: >>> isinstance(a, list) True >>> isinstance(b, Animal) True >>> isinstance(c, Dog) True 看来a、b、c确实对应着list、Animal、Dog这3种类型。 但是等等,试试: >>> isinstance(c, Animal) True 看来c不仅仅是Dog,c还是Animal! 不过仔细想想,这是有道理的,因为Dog是从Animal继承下来的,当我们创建了一个Dog的实例 c 时,我们认为 c 的数据类型是Dog没错,但 c 同时也是Animal也没错,Dog本来就是Animal的一种! 所以,在继承关系中,如果一个实例的数据类型是某个子类,那它的数据类型也可以被看做是父类。但是,反过来 就不行: >>> b = Animal() >>> isinstance(b, Dog) False Dog可以看成Animal,但Animal不可以看成Dog。 要理解多态的好处,我们还需要再编写一个函数,这个函数接受一个Animal类型的变量: def run_twice(animal): animal.run() animal.run() 当我们传入Animal的实例时, run_twice() 就打印出: >>> run_twice(Animal()) Animal is running... Animal is running... 当我们传入Dog的实例时, run_twice() 就打印出: >>> run_twice(Dog()) Dog is running... Dog is running... 当我们传入Cat的实例时, run_twice() 就打印出: >>> run_twice(Cat()) Cat is running... Cat is running... 看上去没啥意思,但是仔细想想,现在,如果我们再定义一个Tortoise类型,也从Animal派生: class Tortoise(Animal): def run(self): print 'Tortoise is running slowly...' 当我们调用run_twice()时,传入Tortoise的实例: >>> run_twice(Tortoise()) Tortoise is running slowly... Tortoise is running slowly... 你会发现,新增一个Animal的子类,不必对run_twice()做任何修改,实际上,任何依赖Animal作为参数的函数或者 方法都可以不加修改地正常运行,原因就在于多态。 多态的好处就是,当我们需要传入Dog、Cat、Tortoise……时,我们只需要接收Animal类型就可以了,因为Dog、C at、Tortoise……都是Animal类型,然后,按照Animal类型进行操作即可。由于Animal类型有 run() 方法,因 此,传入的任意类型,只要是Animal类或者子类,就会自动调用实际类型的 run() 方法,这就是多态的意思: 对于一个变量,我们只需要知道它是Animal类型,无需确切地知道它的子类型,就可以放心地调用 run() 方法,而 具体调用的 run() 方法是作用在Animal、Dog、Cat还是Tortoise对象上,由运行时该对象的确切类型决定,这就是 多态真正的威力:调用方只管调用,不管细节,而当我们新增一种Animal的子类时,只要确保 run() 方法编写正 确,不用管原来的代码是如何调用的。这就是著名的“开闭”原则: 对扩展开放:允许新增Animal子类; 对修改封闭:不需要修改依赖Animal类型的 run_twice() 等函数。 继承还可以一级一级地继承下来,就好比从爷爷到爸爸、再到儿子这样的关系。而任何类,最终都可以追溯到根类o bject,这些继承关系看上去就像一颗倒着的树。比如如下的继承树: 小结 继承可以把父类的所有功能都直接拿过来,这样就不必重零做起,子类只需要新增自己特有的方法,也可以把父类 不适合的方法覆盖重写; 有了继承,才能有多态。在调用类实例方法的时候,尽量把变量视作父类类型,这样,所有子类类型都可以正常被 接收; 旧的方式定义Python类允许不从object类继承,但这种编程方式已经严重不推荐使用。任何时候,如果没有合适的 旧的方式定义Python类允许不从object类继承,但这种编程方式已经严重不推荐使用。任何时候,如果没有合适的 类可以继承,就继承自object类。 您的鼓励是作者写作最大的动力 如果您认为本网站的教程质量不错,读后觉得收获很大,预期工资涨幅能超过30%,不妨小额赞助我一下,让我有 动力继续写出高质量的教程: 获取对象信息 50次阅读 当我们拿到一个对象的引用时,如何知道这个对象是什么类型、有哪些方法呢? 使用type() 首先,我们来判断对象类型,使用 type() 函数: 基本类型都可以用 type() 判断: >>> type(123) >>> type('str') >>> type(None) 如果一个变量指向函数或者类,也可以用 type() 判断: >>> type(abs) >>> type(a) 但是 type() 函数返回的是什么类型呢?它返回type类型。如果我们要在 if 语句中判断,就需要比较两个变量的typ e类型是否相同: >>> type(123)==type(456) True >>> type('abc')==type('123') True >>> type('abc')==type(123) False 但是这种写法太麻烦,Python把每种type类型都定义好了常量,放在 types 模块里,使用之前,需要先导入: >>> import types >>> type('abc')==types.StringType True >>> type(u'abc')==types.UnicodeType True >>> type([])==types.ListType True >>> type(str)==types.TypeType True 最后注意到有一种类型就叫 TypeType ,所有类型本身的类型就是 TypeType ,比如: >>> type(int)==type(str)==types.TypeType True 使用isinstance() 对于class的继承关系来说,使用type()就很不方便。我们要判断class的类型,可以使用 isinstance() 函数。 我们回顾上次的例子,如果继承关系是: object -> Animal -> Dog -> Husky 那么, isinstance() 就可以告诉我们,一个对象是否是某种类型。先创建3种类型的对象: >>> a = Animal() >>> d = Dog() >>> h = Husky() 然后,判断: >>> isinstance(h, Husky) True 没有问题,因为 h 变量指向的就是Husky对象。 再判断: >>> isinstance(h, Dog) True h 虽然自身是Husky类型,但由于Husky是从Dog继承下来的,所以, h 也还是Dog类型。换句话 说, isinstance() 判断的是一个对象是否是该类型本身,或者位于该类型的父继承链上。 因此,我们可以确信, h 还是Animal类型: >>> isinstance(h, Animal) True 同理,实际类型是Dog的 d 也是Animal类型: >>> isinstance(d, Dog) and isinstance(d, Animal) >>> isinstance(d, Dog) and isinstance(d, Animal) True 但是, d 不是Husky类型: >>> isinstance(d, Husky) False 能用 type() 判断的基本类型也可以用 isinstance() 判断: >>> isinstance('a', str) True >>> isinstance(u'a', unicode) True >>> isinstance('a', unicode) False 并且还可以判断一个变量是否是某些类型中的一种,比如下面的代码就可以判断是否是str或者unicode: >>> isinstance('a', (str, unicode)) True >>> isinstance(u'a', (str, unicode)) True 由于 str 和 unicode 都是从 basestring 继承下来的,所以,还可以把上面的代码简化为: >>> isinstance(u'a', basestring) True 使用dir() 如果要获得一个对象的所有属性和方法,可以使用 dir() 函数,它返回一个包含字符串的list,比如,获得一个str对 象的所有属性和方法: >>> dir('ABC') ['__add__', '__class__', '__contains__', '__delattr__', '__doc__', '__eq__', '__format__', '__ge__', '__getattribu te__', '__getitem__', '__getnewargs__', '__getslice__', '__gt__', '__hash__', '__init__', '__le__', '__len__', '__lt__', '__mod__', '__mul__', '__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__rmod__', '__rmu l__', '__setattr__', '__sizeof__', '__str__', '__subclasshook__', '_formatter_field_name_split', '_formatter_parse r', 'capitalize', 'center', 'count', 'decode', 'encode', 'endswith', 'expandtabs', 'find', 'format', 'index', 'isa lnum', 'isalpha', 'isdigit', 'islower', 'isspace', 'istitle', 'isupper', 'join', 'ljust', 'lower', 'lstrip', 'part ition', 'replace', 'rfind', 'rindex', 'rjust', 'rpartition', 'rsplit', 'rstrip', 'split', 'splitlines', 'startswit h', 'strip', 'swapcase', 'title', 'translate', 'upper', 'zfill'] 类似 __xxx__ 的属性和方法在Python中都是有特殊用途的,比如 __len__ 方法返回长度。在Python中,如果你调 用 len() 函数试图获取一个对象的长度,实际上,在 len() 函数内部,它自动去调用该对象的 __len__() 方法,所 以,下面的代码是等价的: >>> len('ABC') 3 3 >>> 'ABC'.__len__() 3 我们自己写的类,如果也想用 len(myObj) 的话,就自己写一个 __len__() 方法: >>> class MyObject(object): ... def __len__(self): ... return 100 ... >>> obj = MyObject() >>> len(obj) 100 剩下的都是普通属性或方法,比如 lower() 返回小写的字符串: >>> 'ABC'.lower() 'abc' 仅仅把属性和方法列出来是不够的,配合 getattr() 、 setattr() 以及 hasattr() ,我们可以直接操作一个对象的 状态: >>> class MyObject(object): ... def __init__(self): ... self.x = 9 ... def power(self): ... return self.x * self.x ... >>> obj = MyObject() 紧接着,可以测试该对象的属性: >>> hasattr(obj, 'x') # 有属性'x'吗? True >>> obj.x 9 >>> hasattr(obj, 'y') # 有属性'y'吗? False >>> setattr(obj, 'y', 19) # 设置一个属性'y' >>> hasattr(obj, 'y') # 有属性'y'吗? True >>> getattr(obj, 'y') # 获取属性'y' 19 >>> obj.y # 获取属性'y' 19 如果试图获取不存在的属性,会抛出AttributeError的错误: >>> getattr(obj, 'z') # 获取属性'z' Traceback (most recent call last): File "", line 1, in AttributeError: 'MyObject' object has no attribute 'z' 可以传入一个default参数,如果属性不存在,就返回默认值: >>> getattr(obj, 'z', 404) # 获取属性'z',如果不存在,返回默认值404 404 也可以获得对象的方法: >>> hasattr(obj, 'power') # 有属性'power'吗? True >>> getattr(obj, 'power') # 获取属性'power' > >>> fn = getattr(obj, 'power') # 获取属性'power'并赋值到变量fn >>> fn # fn指向obj.power > >>> fn() # 调用fn()与调用obj.power()是一样的 81 小结 通过内置的一系列函数,我们可以对任意一个Python对象进行剖析,拿到其内部的数据。要注意的是,只有在不知 道对象信息的时候,我们才会去获取对象信息。如果可以直接写: sum = obj.x + obj.y 就不要写: sum = getattr(obj, 'x') + getattr(obj, 'y') 一个正确的用法的例子如下: def readImage(fp): if hasattr(fp, 'read'): return readData(fp) return None 假设我们希望从文件流fp中读取图像,我们首先要判断该fp对象是否存在read方法,如果存在,则该对象是一个 流,如果不存在,则无法读取。 hasattr() 就派上了用场。 请注意,在Python这类动态语言中,有 read() 方法,不代表该fp对象就是一个文件流,它也可能是网络流,也可能 是内存中的一个字节流,但只要 read() 方法返回的是有效的图像数据,就不影响读取图像的功能。 您的鼓励是作者写作最大的动力 如果您认为本网站的教程质量不错,读后觉得收获很大,预期工资涨幅能超过30%,不妨小额赞助我一下,让我有 动力继续写出高质量的教程: 面向对象高级编程 32次阅读 数据封装、继承和多态只是面向对象程序设计中最基础的3个概念。在Python中,面向对象还有很多高级特性,允许 我们写出非常强大的功能。 我们会讨论多重继承、定制类、元类等概念。 您的鼓励是作者写作最大的动力 如果您认为本网站的教程质量不错,读后觉得收获很大,预期工资涨幅能超过30%,不妨小额赞助我一下,让我有 动力继续写出高质量的教程: 使用__slots__ 84次阅读 正常情况下,当我们定义了一个class,创建了一个class的实例后,我们可以给该实例绑定任何属性和方法,这就是 动态语言的灵活性。先定义class: >>> class Student(object): ... pass ... 然后,尝试给实例绑定一个属性: >>> s = Student() >>> s.name = 'Michael' # 动态给实例绑定一个属性 >>> print s.name Michael 还可以尝试给实例绑定一个方法: >>> def set_age(self, age): # 定义一个函数作为实例方法 ... self.age = age ... >>> from types import MethodType >>> s.set_age = MethodType(set_age, s, Student) # 给实例绑定一个方法 >>> s.set_age(25) # 调用实例方法 >>> s.age # 测试结果 25 但是,给一个实例绑定的方法,对另一个实例是不起作用的: >>> s2 = Student() # 创建新的实例 >>> s2.set_age(25) # 尝试调用方法 Traceback (most recent call last): File "", line 1, in File "", line 1, in AttributeError: 'Student' object has no attribute 'set_age' 为了给所有实例都绑定方法,可以给class绑定方法: >>> def set_score(self, score): ... self.score = score ... >>> Student.set_score = MethodType(set_score, None, Student) 给class绑定方法后,所有实例均可调用: >>> s.set_score(100) >>> s.score 100 >>> s2.set_score(99) >>> s2.score 99 通常情况下,上面的 set_score 方法可以直接定义在class中,但动态绑定允许我们在程序运行的过程中动态给class 加上功能,这在静态语言中很难实现。 使用__slots__ 但是,如果我们想要限制class的属性怎么办?比如,只允许对Student实例添加 name 和 age 属性。 为了达到限制的目的,Python允许在定义class的时候,定义一个特殊的 __slots__ 变量,来限制该class能添加的属 性: >>> class Student(object): ... __slots__ = ('name', 'age') # 用tuple定义允许绑定的属性名称 ... 然后,我们试试: >>> s = Student() # 创建新的实例 >>> s.name = 'Michael' # 绑定属性'name' >>> s.age = 25 # 绑定属性'age' >>> s.score = 99 # 绑定属性'score' Traceback (most recent call last): File "", line 1, in AttributeError: 'Student' object has no attribute 'score' 由于 'score' 没有被放到 __slots__ 中,所以不能绑定 score 属性,试图绑定 score 将得到AttributeError的错误。 使用 __slots__ 要注意, __slots__ 定义的属性仅对当前类起作用,对继承的子类是不起作用的: >>> class GraduateStudent(Student): ... pass ... >>> g = GraduateStudent() >>> g.score = 9999 除非在子类中也定义 __slots__ ,这样,子类允许定义的属性就是自身的 __slots__ 加上父类的 __slots__ 。 您的鼓励是作者写作最大的动力 如果您认为本网站的教程质量不错,读后觉得收获很大,预期工资涨幅能超过30%,不妨小额赞助我一下,让我有 动力继续写出高质量的教程: 使用@property 70次阅读 在绑定属性时,如果我们直接把属性暴露出去,虽然写起来很简单,但是,没办法检查参数,导致可以把成绩随便 改: s = Student() s.score = 9999 这显然不合逻辑。为了限制score的范围,可以通过一个 set_score() 方法来设置成绩,再通过一个 get_score() 来 获取成绩,这样,在 set_score() 方法里,就可以检查参数: class Student(object): def get_score(self): return self._score def set_score(self, value): if not isinstance(value, int): raise ValueError('score must be an integer!') if value < 0 or value > 100: raise ValueError('score must between 0 ~ 100!') self._score = value 现在,对任意的Student实例进行操作,就不能随心所欲地设置score了: >>> s = Student() >>> s.set_score(60) # ok! >>> s.get_score() 60 >>> s.set_score(9999) Traceback (most recent call last): ... ValueError: score must between 0 ~ 100! 但是,上面的调用方法又略显复杂,没有直接用属性这么直接简单。 有没有既能检查参数,又可以用类似属性这样简单的方式来访问类的变量呢?对于追求完美的Python程序员来 说,这是必须要做到的! 还记得装饰器(decorator)可以给函数动态加上功能吗?对于类的方法,装饰器一样起作用。Python内置 的 @property 装饰器就是负责把一个方法变成属性调用的: class Student(object): @property def score(self): return self._score @score.setter def score(self, value): if not isinstance(value, int): raise ValueError('score must be an integer!') if value < 0 or value > 100: raise ValueError('score must between 0 ~ 100!') self._score = value @property 的实现比较复杂,我们先考察如何使用。把一个getter方法变成属性,只需要加上 @property 就可以 了,此时, @property 本身又创建了另一个装饰器 @score.setter ,负责把一个setter方法变成属性赋值,于是,我 们就拥有一个可控的属性操作: >>> s = Student() >>> s.score = 60 # OK,实际转化为s.set_score(60) >>> s.score # OK,实际转化为s.get_score() 60 >>> s.score = 9999 Traceback (most recent call last): ... ValueError: score must between 0 ~ 100! 注意到这个神奇的 @property ,我们在对实例属性操作的时候,就知道该属性很可能不是直接暴露的,而是通过gett er和setter方法来实现的。 还可以定义只读属性,只定义getter方法,不定义setter方法就是一个只读属性: class Student(object): @property def birth(self): return self._birth @birth.setter def birth(self, value): self._birth = value @property def age(self): return 2014 - self._birth 上面的 birth 是可读写属性,而 age 就是一个只读属性,因为 age 可以根据 birth 和当前时间计算出来。 小结 小结 @property 广泛应用在类的定义中,可以让调用者写出简短的代码,同时保证对参数进行必要的检查,这样,程序 运行时就减少了出错的可能性。 您的鼓励是作者写作最大的动力 如果您认为本网站的教程质量不错,读后觉得收获很大,预期工资涨幅能超过30%,不妨小额赞助我一下,让我有 动力继续写出高质量的教程: 多重继承 36次阅读 继承是面向对象编程的一个重要的方式,因为通过继承,子类就可以扩展父类的功能。 回忆一下 Animal 类层次的设计,假设我们要实现以下4种动物: Dog ­ 狗狗; Bat ­ 蝙蝠; Parrot ­ 鹦鹉; Ostrich ­ 鸵鸟。 如果按照哺乳动物和鸟类归类,我们可以设计出这样的类的层次: 但是如果按照“能跑”和“能飞”来归类,我们就应该设计出这样的类的层次: 如果要把上面的两种分类都包含进来,我们就得设计更多的层次: 哺乳类:能跑的哺乳类,能飞的哺乳类; 鸟类:能跑的鸟类,能飞的鸟类。 这么一来,类的层次就复杂了: 如果要再增加“宠物类”和“非宠物类”,这么搞下去,类的数量会呈指数增长,很明显这样设计是不行的。 正确的做法是采用多重继承。首先,主要的类层次仍按照哺乳类和鸟类设计: class Animal(object): pass # 大类: class Mammal(Animal): pass class Bird(Animal): pass # 各种动物: class Dog(Mammal): pass class Bat(Mammal): class Bat(Mammal): pass class Parrot(Bird): pass class Ostrich(Bird): pass 现在,我们要给动物再加上 Runnable 和 Flyable 的功能,只需要先定义好 Runnable 和 Flyable 的类: class Runnable(object): def run(self): print('Running...') class Flyable(object): def fly(self): print('Flying...') 对于需要 Runnable 功能的动物,就多继承一个 Runnable ,例如 Dog : class Dog(Mammal, Runnable): pass 对于需要 Flyable 功能的动物,就多继承一个 Flyable ,例如 Bat : class Bat(Mammal, Flyable): pass 通过多重继承,一个子类就可以同时获得多个父类的所有功能。 Mixin 在设计类的继承关系时,通常,主线都是单一继承下来的,例如, Ostrich 继承自 Bird 。但是,如果需要“混入”额 外的功能,通过多重继承就可以实现,比如,让 Ostrich 除了继承自 Bird 外,再同时继承 Runnable 。这种设计通 常称之为Mixin。 为了更好地看出继承关系,我们把 Runnable 和 Flyable 改为 RunnableMixin 和 FlyableMixin 。类似的,你还可以定 义出肉食动物 CarnivorousMixin 和植食动物 HerbivoresMixin ,让某个动物同时拥有好几个Mixin: class Dog(Mammal, RunnableMixin, CarnivorousMixin): pass Mixin的目的就是给一个类增加多个功能,这样,在设计类的时候,我们优先考虑通过多重继承来组合多个Mixin的功 能,而不是设计多层次的复杂的继承关系。 Python自带的很多库也使用了Mixin。举个例子,Python自带了 TCPServer 和 UDPServer 这两类网络服务,而要同时 服务多个用户就必须使用多进程或多线程模型,这两种模型由 ForkingMixin 和 ThreadingMixin 提供。通过组合,我 们就可以创造出合适的服务来。 比如,编写一个多进程模式的TCP服务,定义如下: class MyTCPServer(TCPServer, ForkingMixin): pass 编写一个多线程模式的UDP服务,定义如下: class MyUDPServer(UDPServer, ThreadingMixin): pass 如果你打算搞一个更先进的协程模型,可以编写一个 CoroutineMixin : class MyTCPServer(TCPServer, CoroutineMixin): pass 这样一来,我们不需要复杂而庞大的继承链,只要选择组合不同的类的功能,就可以快速构造出所需的子类。 小结 由于Python允许使用多重继承,因此,Mixin就是一种常见的设计。 只允许单一继承的语言(如Java)不能使用Mixin的设计。 您的鼓励是作者写作最大的动力 如果您认为本网站的教程质量不错,读后觉得收获很大,预期工资涨幅能超过30%,不妨小额赞助我一下,让我有 动力继续写出高质量的教程: 定制类 60次阅读 看到类似 __slots__ 这种形如 __xxx__ 的变量或者函数名就要注意,这些在Python中是有特殊用途的。 __slots__ 我们已经知道怎么用了, __len__() 方法我们也知道是为了能让class作用于 len() 函数。 除此之外,Python的class中还有许多这样有特殊用途的函数,可以帮助我们定制类。 __str__ 我们先定义一个 Student 类,打印一个实例: >>> class Student(object): ... def __init__(self, name): ... self.name = name ... >>> print Student('Michael') <__main__.Student object at 0x109afb190> 打印出一堆 <__main__.Student object at 0x109afb190> ,不好看。 怎么才能打印得好看呢?只需要定义好 __str__() 方法,返回一个好看的字符串就可以了: >>> class Student(object): ... def __init__(self, name): ... self.name = name ... def __str__(self): ... return 'Student object (name: %s)' % self.name ... >>> print Student('Michael') Student object (name: Michael) 这样打印出来的实例,不但好看,而且容易看出实例内部重要的数据。 但是细心的朋友会发现直接敲变量不用 print ,打印出来的实例还是不好看: >>> s = Student('Michael') >>> s <__main__.Student object at 0x109afb310> 这是因为直接显示变量调用的不是 __str__() ,而是 __repr__() ,两者的区别是 __str__() 返回用户看到的字符 串,而 __repr__() 返回程序开发者看到的字符串,也就是说, __repr__() 是为调试服务的。 解决办法是再定义一个 __repr__() 。但是通常 __str__() 和 __repr__() 代码都是一样的,所以,有个偷懒的写 法: class Student(object): def __init__(self, name): self.name = name def __str__(self): return 'Student object (name=%s)' % self.name __repr__ = __str__ __iter__ 如果一个类想被用于 for ... in 循环,类似list或tuple那样,就必须实现一个 __iter__() 方法,该方法返回一个迭 代对象,然后,Python的for循环就会不断调用该迭代对象的 next() 方法拿到循环的下一个值,直到遇到StopIterati on错误时退出循环。 我们以斐波那契数列为例,写一个Fib类,可以作用于for循环: class Fib(object): def __init__(self): self.a, self.b = 0, 1 # 初始化两个计数器a,b def __iter__(self): return self # 实例本身就是迭代对象,故返回自己 def next(self): self.a, self.b = self.b, self.a + self.b # 计算下一个值 if self.a > 100000: # 退出循环的条件 if self.a > 100000: # 退出循环的条件 raise StopIteration(); return self.a # 返回下一个值 现在,试试把Fib实例作用于for循环: >>> for n in Fib(): ... print n ... 1 1 2 3 5 ... 46368 75025 __getitem__ Fib实例虽然能作用于for循环,看起来和list有点像,但是,把它当成list来使用还是不行,比如,取第5个元素: >>> Fib()[5] Traceback (most recent call last): File "", line 1, in TypeError: 'Fib' object does not support indexing 要表现得像list那样按照下标取出元素,需要实现 __getitem__() 方法: class Fib(object): def __getitem__(self, n): a, b = 1, 1 for x in range(n): a, b = b, a + b return a 现在,就可以按下标访问数列的任意一项了: >>> f = Fib() >>> f[0] 1 >>> f[1] 1 >>> f[2] 2 >>> f[3] 3 >>> f[10] 89 >>> f[100] 573147844013817084101 但是list有个神奇的切片方法: >>> range(100)[5:10] [5, 6, 7, 8, 9] 对于Fib却报错。原因是 __getitem__() 传入的参数可能是一个int,也可能是一个切片对象 slice ,所以要做判断: class Fib(object): def __getitem__(self, n): if isinstance(n, int): a, b = 1, 1 for x in range(n): a, b = b, a + b return a if isinstance(n, slice): start = n.start stop = n.stop a, b = 1, 1 L = [] for x in range(stop): if x >= start: L.append(a) a, b = b, a + b return L 现在试试Fib的切片: >>> f = Fib() >>> f[0:5] [1, 1, 2, 3, 5] >>> f[:10] [1, 1, 2, 3, 5, 8, 13, 21, 34, 55] 但是没有对step参数作处理: >>> f[:10:2] [1, 1, 2, 3, 5, 8, 13, 21, 34, 55, 89] 也没有对负数作处理,所以,要正确实现一个 __getitem__() 还是有很多工作要做的。 此外,如果把对象看成 dict , __getitem__() 的参数也可能是一个可以作key的object,例如 str 。 与之对应的是 __setitem__() 方法,把对象视作list或dict来对集合赋值。最后,还有一个 __delitem__() 方法,用于 删除某个元素。 总之,通过上面的方法,我们自己定义的类表现得和Python自带的list、tuple、dict没什么区别,这完全归功于动态 语言的“鸭子类型”,不需要强制继承某个接口。 __getattr__ 正常情况下,当我们调用类的方法或属性时,如果不存在,就会报错。比如定义 Student 类: class Student(object): def __init__(self): self.name = 'Michael' 调用 name 属性,没问题,但是,调用不存在的 score 属性,就有问题了: >>> s = Student() >>> print s.name Michael >>> print s.score Traceback (most recent call last): ... AttributeError: 'Student' object has no attribute 'score' 错误信息很清楚地告诉我们,没有找到 score 这个attribute。 要避免这个错误,除了可以加上一个 score 属性外,Python还有另一个机制,那就是写一个 __getattr__() 方 法,动态返回一个属性。修改如下: class Student(object): def __init__(self): self.name = 'Michael' def __getattr__(self, attr): if attr=='score': return 99 当调用不存在的属性时,比如 score ,Python解释器会试图调用 __getattr__(self, 'score') 来尝试获得属性,这 样,我们就有机会返回 score 的值: >>> s = Student() >>> s.name 'Michael' >>> s.score 99 返回函数也是完全可以的: class Student(object): def __getattr__(self, attr): if attr=='age': return lambda: 25 只是调用方式要变为: >>> s.age() 25 注意,只有在没有找到属性的情况下,才调用 __getattr__ ,已有的属性,比如 name ,不会在 __getattr__ 中查 找。 此外,注意到任意调用如 s.abc 都会返回 None ,这是因为我们定义的 __getattr__ 默认返回就是 None 。要让class 只响应特定的几个属性,我们就要按照约定,抛出 AttributeError 的错误: class Student(object): def __getattr__(self, attr): if attr=='age': return lambda: 25 raise AttributeError('\'Student\' object has no attribute \'%s\'' % attr) 这实际上可以把一个类的所有属性和方法调用全部动态化处理了,不需要任何特殊手段。 这种完全动态调用的特性有什么实际作用呢?作用就是,可以针对完全动态的情况作调用。 举个例子: 现在很多网站都搞REST API,比如新浪微博、豆瓣啥的,调用API的URL类似: http://api.server/user/friends http://api.server/user/timeline/list 如果要写SDK,给每个URL对应的API都写一个方法,那得累死,而且,API一旦改动,SDK也要改。 利用完全动态的 __getattr__ ,我们可以写出一个链式调用: class Chain(object): def __init__(self, path=''): self._path = path def __getattr__(self, path): return Chain('%s/%s' % (self._path, path)) def __str__(self): return self._path 试试: >>> Chain().status.user.timeline.list '/status/user/timeline/list' 这样,无论API怎么变,SDK都可以根据URL实现完全动态的调用,而且,不随API的增加而改变! 还有些REST API会把参数放到URL中,比如GitHub的API: GET /users/:user/repos 调用时,需要把 :user 替换为实际用户名。如果我们能写出这样的链式调用: Chain().users('michael').repos 就可以非常方便地调用API了。有兴趣的童鞋可以试试写出来。 __call__ 一个对象实例可以有自己的属性和方法,当我们调用实例方法时,我们用 instance.method() 来调用。能不能直接在 实例本身上调用呢?类似 instance() ?在Python中,答案是肯定的。 任何类,只需要定义一个 __call__() 方法,就可以直接对实例进行调用。请看示例: class Student(object): def __init__(self, name): self.name = name def __call__(self): print('My name is %s.' % self.name) 调用方式如下: >>> s = Student('Michael') >>> s() My name is Michael. __call__() 还可以定义参数。对实例进行直接调用就好比对一个函数进行调用一样,所以你完全可以把对象看成函 数,把函数看成对象,因为这两者之间本来就没啥根本的区别。 如果你把对象看成函数,那么函数本身其实也可以在运行期动态创建出来,因为类的实例都是运行期创建出来 的,这么一来,我们就模糊了对象和函数的界限。 那么,怎么判断一个变量是对象还是函数呢?其实,更多的时候,我们需要判断一个对象是否能被调用,能被调用 的对象就是一个 Callable 对象,比如函数和我们上面定义的带有 __call()__ 的类实例: >>> callable(Student()) True >>> callable(max) True >>> callable([1, 2, 3]) False >>> callable(None) False >>> callable('string') False 通过 callable() 函数,我们就可以判断一个对象是否是“可调用”对象。 小结 Python的class允许定义许多定制方法,可以让我们非常方便地生成特定的类。 Python的class允许定义许多定制方法,可以让我们非常方便地生成特定的类。 本节介绍的是最常用的几个定制方法,还有很多可定制的方法,请参考Python的官方文档。 您的鼓励是作者写作最大的动力 如果您认为本网站的教程质量不错,读后觉得收获很大,预期工资涨幅能超过30%,不妨小额赞助我一下,让我有 动力继续写出高质量的教程: 使用元类 64次阅读 type() 动态语言和静态语言最大的不同,就是函数和类的定义,不是编译时定义的,而是运行时动态创建的。 比方说我们要定义一个 Hello 的class,就写一个 hello.py 模块: class Hello(object): def hello(self, name='world'): print('Hello, %s.' % name) 当Python解释器载入 hello 模块时,就会依次执行该模块的所有语句,执行结果就是动态创建出一个 Hello 的class 对象,测试如下: >>> from hello import Hello >>> h = Hello() >>> h.hello() Hello, world. >>> print(type(Hello)) >>> print(type(h)) type() 函数可以查看一个类型或变量的类型, Hello 是一个class,它的类型就是 type ,而 h 是一个实例,它的类 型就是class  Hello 。 我们说class的定义是运行时动态创建的,而创建class的方法就是使用 type() 函数。 type() 函数既可以返回一个对象的类型,又可以创建出新的类型,比如,我们可以通过 type() 函数创建出 Hello 类,而无需通过 class Hello(object)... 的定义: >>> def fn(self, name='world'): # 先定义函数 ... print('Hello, %s.' % name) ... >>> Hello = type('Hello', (object,), dict(hello=fn)) # 创建Hello class >>> h = Hello() >>> h.hello() Hello, world. >>> print(type(Hello)) >>> print(type(Hello)) >>> print(type(h)) 要创建一个class对象, type() 函数依次传入3个参数: 1.  class的名称; 2.  继承的父类集合,注意Python支持多重继承,如果只有一个父类,别忘了tuple的单元素写法; 3.  class的方法名称与函数绑定,这里我们把函数 fn 绑定到方法名 hello 上。 通过 type() 函数创建的类和直接写class是完全一样的,因为Python解释器遇到class定义时,仅仅是扫描一下class 定义的语法,然后调用 type() 函数创建出class。 正常情况下,我们都用 class Xxx... 来定义类,但是, type() 函数也允许我们动态创建出类来,也就是说,动态 语言本身支持运行期动态创建类,这和静态语言有非常大的不同,要在静态语言运行期创建类,必须构造源代码字 符串再调用编译器,或者借助一些工具生成字节码实现,本质上都是动态编译,会非常复杂。 metaclass 除了使用 type() 动态创建类以外,要控制类的创建行为,还可以使用metaclass。 metaclass,直译为元类,简单的解释就是: 当我们定义了类以后,就可以根据这个类创建出实例,所以:先定义类,然后创建实例。 但是如果我们想创建出类呢?那就必须根据metaclass创建出类,所以:先定义metaclass,然后创建类。 连接起来就是:先定义metaclass,就可以创建类,最后创建实例。 所以,metaclass允许你创建类或者修改类。换句话说,你可以把类看成是metaclass创建出来的“实例”。 metaclass是Python面向对象里最难理解,也是最难使用的魔术代码。正常情况下,你不会碰到需要使用metaclass 的情况,所以,以下内容看不懂也没关系,因为基本上你不会用到。 我们先看一个简单的例子,这个metaclass可以给我们自定义的MyList增加一个 add 方法: 定义 ListMetaclass ,按照默认习惯,metaclass的类名总是以Metaclass结尾,以便清楚地表示这是一个metaclas s: # metaclass是创建类,所以必须从`type`类型派生: class ListMetaclass(type): def __new__(cls, name, bases, attrs): attrs['add'] = lambda self, value: self.append(value) return type.__new__(cls, name, bases, attrs) class MyList(list): __metaclass__ = ListMetaclass # 指示使用ListMetaclass来定制类 当我们写下 __metaclass__ = ListMetaclass 语句时,魔术就生效了,它指示Python解释器在创建 MyList 时,要通 过 ListMetaclass.__new__() 来创建,在此,我们可以修改类的定义,比如,加上新的方法,然后,返回修改后的定 义。 __new__() 方法接收到的参数依次是: __new__() 方法接收到的参数依次是: 1.  当前准备创建的类的对象; 2.  类的名字; 3.  类继承的父类集合; 4.  类的方法集合。 测试一下 MyList 是否可以调用 add() 方法: >>> L = MyList() >>> L.add(1) >>> L [1] 而普通的 list 没有 add() 方法: >>> l = list() >>> l.add(1) Traceback (most recent call last): File "", line 1, in AttributeError: 'list' object has no attribute 'add' 动态修改有什么意义?直接在 MyList 定义中写上 add() 方法不是更简单吗?正常情况下,确实应该直接写,通过m etaclass修改纯属变态。 但是,总会遇到需要通过metaclass修改类定义的。ORM就是一个典型的例子。 ORM全称“Object Relational Mapping”,即对象­关系映射,就是把关系数据库的一行映射为一个对象,也就是一个 类对应一个表,这样,写代码更简单,不用直接操作SQL语句。 要编写一个ORM框架,所有的类都只能动态定义,因为只有使用者才能根据表的结构定义出对应的类来。 让我们来尝试编写一个ORM框架。 编写底层模块的第一步,就是先把调用接口写出来。比如,使用者如果使用这个ORM框架,想定义一个 User 类来 操作对应的数据库表 User ,我们期待他写出这样的代码: class User(Model): # 定义类的属性到列的映射: id = IntegerField('id') name = StringField('username') email = StringField('email') password = StringField('password') # 创建一个实例: u = User(id=12345, name='Michael', email='test@orm.org', password='my-pwd') # 保存到数据库: u.save() 其中,父类 Model 和属性类型 StringField 、 IntegerField 是由ORM框架提供的,剩下的魔术方法比如 save() 全 部由metaclass自动完成。虽然metaclass的编写会比较复杂,但ORM的使用者用起来却异常简单。 现在,我们就按上面的接口来实现该ORM。 首先来定义 Field 类,它负责保存数据库表的字段名和字段类型: class Field(object): def __init__(self, name, column_type): self.name = name self.column_type = column_type def __str__(self): return '<%s:%s>' % (self.__class__.__name__, self.name) 在 Field 的基础上,进一步定义各种类型的 Field ,比如 StringField , IntegerField 等等: class StringField(Field): def __init__(self, name): super(StringField, self).__init__(name, 'varchar(100)') class IntegerField(Field): def __init__(self, name): super(IntegerField, self).__init__(name, 'bigint') 下一步,就是编写最复杂的 ModelMetaclass 了: class ModelMetaclass(type): def __new__(cls, name, bases, attrs): if name=='Model': return type.__new__(cls, name, bases, attrs) mappings = dict() for k, v in attrs.iteritems(): if isinstance(v, Field): print('Found mapping: %s==>%s' % (k, v)) mappings[k] = v for k in mappings.iterkeys(): attrs.pop(k) attrs['__table__'] = name # 假设表名和类名一致 attrs['__mappings__'] = mappings # 保存属性和列的映射关系 return type.__new__(cls, name, bases, attrs) 以及基类 Model : class Model(dict): __metaclass__ = ModelMetaclass def __init__(self, **kw): super(Model, self).__init__(**kw) def __getattr__(self, key): try: return self[key] except KeyError: raise AttributeError(r"'Model' object has no attribute '%s'" % key) def __setattr__(self, key, value): self[key] = value def save(self): fields = [] params = [] args = [] for k, v in self.__mappings__.iteritems(): fields.append(v.name) params.append('?') args.append(getattr(self, k, None)) sql = 'insert into %s (%s) values (%s)' % (self.__table__, ','.join(fields), ','.join(params)) print('SQL: %s' % sql) print('ARGS: %s' % str(args)) 当用户定义一个 class User(Model) 时,Python解释器首先在当前类 User 的定义中查找 __metaclass__ ,如果没有 找到,就继续在父类 Model 中查找 __metaclass__ ,找到了,就使用 Model 中定义 的 __metaclass__ 的 ModelMetaclass 来创建 User 类,也就是说,metaclass可以隐式地继承到子类,但子类自己却 感觉不到。 在 ModelMetaclass 中,一共做了几件事情: 1.  排除掉对 Model 类的修改; 2.  在当前类(比如 User )中查找定义的类的所有属性,如果找到一个Field属性,就把它保存到一 个 __mappings__ 的dict中,同时从类属性中删除该Field属性,否则,容易造成运行时错误; 3.  把表名保存到 __table__ 中,这里简化为表名默认为类名。 在 Model 类中,就可以定义各种操作数据库的方法,比如 save() , delete() , find() , update 等等。 我们实现了 save() 方法,把一个实例保存到数据库中。因为有表名,属性到字段的映射和属性值的集合,就可以构 造出 INSERT 语句。 编写代码试试: u = User(id=12345, name='Michael', email='test@orm.org', password='my-pwd') u.save() 输出如下: Found model: User Found mapping: email ==> Found mapping: password ==> Found mapping: id ==> Found mapping: name ==> SQL: insert into User (password,email,username,uid) values (?,?,?,?) ARGS: ['my-pwd', 'test@orm.org', 'Michael', 12345] 可以看到, save() 方法已经打印出了可执行的SQL语句,以及参数列表,只需要真正连接到数据库,执行该SQL语 句,就可以完成真正的功能。 不到100行代码,我们就通过metaclass实现了一个精简的ORM框架,完整的代码从这里下载: https://github.com/michaelliao/learn­python/blob/master/metaclass/simple_orm.py 最后解释一下类属性和实例属性。直接在class中定义的是类属性: class Student(object): name = 'Student' 实例属性必须通过实例来绑定,比如 self.name = 'xxx' 。来测试一下: >>> # 创建实例s: >>> s = Student() >>> # 打印name属性,因为实例并没有name属性,所以会继续查找class的name属性: >>> print(s.name) Student >>> # 这和调用Student.name是一样的: >>> print(Student.name) Student >>> # 给实例绑定name属性: >>> s.name = 'Michael' >>> # 由于实例属性优先级比类属性高,因此,它会屏蔽掉类的name属性: >>> print(s.name) Michael >>> # 但是类属性并未消失,用Student.name仍然可以访问: >>> print(Student.name) Student >>> # 如果删除实例的name属性: >>> del s.name >>> # 再次调用s.name,由于实例的name属性没有找到,类的name属性就显示出来了: >>> print(s.name) Student 因此,在编写程序的时候,千万不要把实例属性和类属性使用相同的名字。 在我们编写的ORM中, ModelMetaclass 会删除掉User类的所有类属性,目的就是避免造成混淆。 您的鼓励是作者写作最大的动力 如果您认为本网站的教程质量不错,读后觉得收获很大,预期工资涨幅能超过30%,不妨小额赞助我一下,让我有 动力继续写出高质量的教程: 错误、调试和测试 18次阅读 在程序运行过程中,总会遇到各种各样的错误。 有的错误是程序编写有问题造成的,比如本来应该输出整数结果输出了字符串,这种错误我们通常称之为bug,bug 是必须修复的。 有的错误是用户输入造成的,比如让用户输入email地址,结果得到一个空字符串,这种错误可以通过检查用户输入 来做相应的处理。 还有一类错误是完全无法在程序运行过程中预测的,比如写入文件的时候,磁盘满了,写不进去了,或者从网络抓 取数据,网络突然断掉了。这类错误也称为异常,在程序中通常是必须处理的,否则,程序会因为各种问题终止并 退出。 Python内置了一套异常处理机制,来帮助我们进行错误处理。 此外,我们也需要跟踪程序的执行,查看变量的值是否正确,这个过程称为调试。Python的pdb可以让我们以单步 方式执行代码。 最后,编写测试也很重要。有了良好的测试,就可以在程序修改后反复运行,确保程序输出符合我们编写的测试。 您的鼓励是作者写作最大的动力 如果您认为本网站的教程质量不错,读后觉得收获很大,预期工资涨幅能超过30%,不妨小额赞助我一下,让我有 动力继续写出高质量的教程: 错误处理 59次阅读 在程序运行的过程中,如果发生了错误,可以事先约定返回一个错误代码,这样,就可以知道是否有错,以及出错 的原因。在操作系统提供的调用中,返回错误码非常常见。比如打开文件的函数 open() ,成功时返回文件描述 符(就是一个整数),出错时返回 ‐1 。 用错误码来表示是否出错十分不便,因为函数本身应该返回的正常结果和错误码混在一起,造成调用者必须用大量 的代码来判断是否出错: def foo(): r = some_function() if r==(-1): return (-1) # do something return r def bar(): r = foo() if r==(-1): print 'Error' else: pass 一旦出错,还要一级一级上报,直到某个函数可以处理该错误(比如,给用户输出一个错误信息)。 所以高级语言通常都内置了一套 try...except...finally... 的错误处理机制,Python也不例外。 try 让我们用一个例子来看看 try 的机制: try: print 'try...' r = 10 / 0 print 'result:', r except ZeroDivisionError, e: print 'except:', e finally: print 'finally...' print 'END' 当我们认为某些代码可能会出错时,就可以用 try 来运行这段代码,如果执行出错,则后续代码不会继续执行,而 是直接跳转至错误处理代码,即 except 语句块,执行完 except 后,如果有 finally 语句块,则执行 finally 语句 块,至此,执行完毕。 上面的代码在计算 10 / 0 时会产生一个除法运算错误: try... except: integer division or modulo by zero finally... END 从输出可以看到,当错误发生时,后续语句 print 'result:', r 不会被执行, except 由于捕获 到 ZeroDivisionError ,因此被执行。最后, finally 语句被执行。然后,程序继续按照流程往下走。 如果把除数 0 改成 2 ,则执行结果如下: try... result: 5 finally... END 由于没有错误发生,所以 except 语句块不会被执行,但是 finally 如果有,则一定会被执行(可以没有 finally 语 句)。 你还可以猜测,错误应该有很多种类,如果发生了不同类型的错误,应该由不同的 except 语句块处理。没错,可以 有多个 except 来捕获不同类型的错误: try: print 'try...' r = 10 / int('a') print 'result:', r except ValueError, e: print 'ValueError:', e except ZeroDivisionError, e: print 'ZeroDivisionError:', e finally: print 'finally...' print 'END' int() 函数可能会抛出 ValueError ,所以我们用一个 except 捕获 ValueError ,用另一个 except 捕 获 ZeroDivisionError 。 此外,如果没有错误发生,可以在 except 语句块后面加一个 else ,当没有错误发生时,会自动执行 else 语句: try: print 'try...' r = 10 / int('a') print 'result:', r except ValueError, e: print 'ValueError:', e except ZeroDivisionError, e: print 'ZeroDivisionError:', e else: print 'no error!' finally: print 'finally...' print 'END' Python的错误其实也是class,所有的错误类型都继承自 BaseException ,所以在使用 except 时需要注意的是,它 不但捕获该类型的错误,还把其子类也“一网打尽”。比如: try: foo() except StandardError, e: print 'StandardError' except ValueError, e: print 'ValueError' 第二个 except 永远也捕获不到 ValueError ,因为 ValueError 是 StandardError 的子类,如果有,也被第一 个 except 给捕获了。 Python所有的错误都是从 BaseException 类派生的,常见的错误类型和继承关系看这里: https://docs.python.org/2/library/exceptions.html#exception­hierarchy 使用 try...except 捕获错误还有一个巨大的好处,就是可以跨越多层调用,比如函数 main() 调 用 foo() , foo() 调用 bar() ,结果 bar() 出错了,这时,只要 main() 捕获到了,就可以处理: def foo(s): return 10 / int(s) def bar(s): return foo(s) * 2 def main(): try: bar('0') except StandardError, e: print 'Error!' finally: print 'finally...' 也就是说,不需要在每个可能出错的地方去捕获错误,只要在合适的层次去捕获错误就可以了。这样一来,就大大 减少了写 try...except...finally 的麻烦。 调用堆栈 如果错误没有被捕获,它就会一直往上抛,最后被Python解释器捕获,打印一个错误信息,然后程序退出。来看 看 err.py : # err.py: def foo(s): return 10 / int(s) def bar(s): return foo(s) * 2 def main(): bar('0') main() 执行,结果如下: $ python err.py Traceback (most recent call last): File "err.py", line 11, in main() File "err.py", line 9, in main bar('0') File "err.py", line 6, in bar return foo(s) * 2 File "err.py", line 3, in foo return 10 / int(s) ZeroDivisionError: integer division or modulo by zero 出错并不可怕,可怕的是不知道哪里出错了。解读错误信息是定位错误的关键。我们从上往下可以看到整个错误的 调用函数链: 错误信息第1行: Traceback (most recent call last): 告诉我们这是错误的跟踪信息。 第2行: File "err.py", line 11, in main() 调用 main() 出错了,在代码文件 err.py 的第11行代码,但原因是第9行: File "err.py", line 9, in main bar('0') 调用 bar('0') 出错了,在代码文件 err.py 的第9行代码,但原因是第6行: File "err.py", line 6, in bar return foo(s) * 2 原因是 return foo(s) * 2 这个语句出错了,但这还不是最终原因,继续往下看: File "err.py", line 3, in foo return 10 / int(s) 原因是 return 10 / int(s) 这个语句出错了,这是错误产生的源头,因为下面打印了: ZeroDivisionError: integer division or modulo by zero 根据错误类型 ZeroDivisionError ,我们判断, int(s) 本身并没有出错,但是 int(s) 返回 0 ,在计算 10 / 0 时出 错,至此,找到错误源头。 记录错误 如果不捕获错误,自然可以让Python解释器来打印出错误堆栈,但程序也被结束了。既然我们能捕获错误,就可以 把错误堆栈打印出来,然后分析错误原因,同时,让程序继续执行下去。 Python内置的 logging 模块可以非常容易地记录错误信息: # err.py import logging def foo(s): return 10 / int(s) def bar(s): return foo(s) * 2 def main(): try: bar('0') except StandardError, e: logging.exception(e) main() print 'END' print 'END' 同样是出错,但程序打印完错误信息后会继续执行,并正常退出: $ python err.py ERROR:root:integer division or modulo by zero Traceback (most recent call last): File "err.py", line 12, in main bar('0') File "err.py", line 8, in bar return foo(s) * 2 File "err.py", line 5, in foo return 10 / int(s) ZeroDivisionError: integer division or modulo by zero END 通过配置, logging 还可以把错误记录到日志文件里,方便事后排查。 抛出错误 因为错误是class,捕获一个错误就是捕获到该class的一个实例。因此,错误并不是凭空产生的,而是有意创建并抛 出的。Python的内置函数会抛出很多类型的错误,我们自己编写的函数也可以抛出错误。 如果要抛出错误,首先根据需要,可以定义一个错误的class,选择好继承关系,然后,用 raise 语句抛出一个错误 的实例: # err.py class FooError(StandardError): pass def foo(s): n = int(s) if n==0: raise FooError('invalid value: %s' % s) return 10 / n 执行,可以最后跟踪到我们自己定义的错误: $ python err.py Traceback (most recent call last): ... __main__.FooError: invalid value: 0 只有在必要的时候才定义我们自己的错误类型。如果可以选择Python已有的内置的错误类型(比如ValueError,Typ eError),尽量使用Python内置的错误类型。 最后,我们来看另一种错误处理的方式: # err.py def foo(s): n = int(s) return 10 / n def bar(s): try: return foo(s) * 2 except StandardError, e: print 'Error!' raise def main(): bar('0') main() 在 bar() 函数中,我们明明已经捕获了错误,但是,打印一个 Error! 后,又把错误通过 raise 语句抛出去了,这不 有病么? 其实这种错误处理方式不但没病,而且相当常见。捕获错误目的只是记录一下,便于后续追踪。但是,由于当前函 数不知道应该怎么处理该错误,所以,最恰当的方式是继续往上抛,让顶层调用者去处理。 raise 语句如果不带参数,就会把当前错误原样抛出。此外,在 except 中 raise 一个Error,还可以把一种类型的 错误转化成另一种类型: try: 10 / 0 except ZeroDivisionError: raise ValueError('input error!') 只要是合理的转换逻辑就可以,但是,决不应该把一个 IOError 转换成毫不相干的 ValueError 。 小结 Python内置的 try...except...finally 用来处理错误十分方便。出错时,会分析错误信息并定位错误发生的代码位 置才是最关键的。 程序也可以主动抛出错误,让调用者来处理相应的错误。但是,应该在文档中写清楚可能会抛出哪些错误,以及错 误产生的原因。 您的鼓励是作者写作最大的动力 如果您认为本网站的教程质量不错,读后觉得收获很大,预期工资涨幅能超过30%,不妨小额赞助我一下,让我有 动力继续写出高质量的教程: 调试 40次阅读 程序能一次写完并正常运行的概率很小,基本不超过1%。总会有各种各样的bug需要修正。有的bug很简单,看看 错误信息就知道,有的bug很复杂,我们需要知道出错时,哪些变量的值是正确的,哪些变量的值是错误的,因 此,需要一整套调试程序的手段来修复bug。 第一种方法简单直接粗暴有效,就是用 print 把可能有问题的变量打印出来看看: 第一种方法简单直接粗暴有效,就是用 print 把可能有问题的变量打印出来看看: # err.py def foo(s): n = int(s) print '>>> n = %d' % n return 10 / n def main(): foo('0') main() 执行后在输出中查找打印的变量值: $ python err.py >>> n = 0 Traceback (most recent call last): ... ZeroDivisionError: integer division or modulo by zero 用 print 最大的坏处是将来还得删掉它,想想程序里到处都是 print ,运行结果也会包含很多垃圾信息。所以,我 们又有第二种方法。 断言 凡是用 print 来辅助查看的地方,都可以用断言(assert)来替代: # err.py def foo(s): n = int(s) assert n != 0, 'n is zero!' return 10 / n def main(): foo('0') assert 的意思是,表达式 n != 0 应该是 True ,否则,后面的代码就会出错。 如果断言失败, assert 语句本身就会抛出 AssertionError : $ python err.py Traceback (most recent call last): ... AssertionError: n is zero! 程序中如果到处充斥着 assert ,和 print 相比也好不到哪去。不过,启动Python解释器时可以用 ‐O 参数来关 闭 assert : $ python -O err.py Traceback (most recent call last): ... ... ZeroDivisionError: integer division or modulo by zero 关闭后,你可以把所有的 assert 语句当成 pass 来看。 logging 把 print 替换为 logging 是第3种方式,和 assert 比, logging 不会抛出错误,而且可以输出到文件: # err.py import logging s = '0' n = int(s) logging.info('n = %d' % n) print 10 / n logging.info() 就可以输出一段文本。运行,发现除了 ZeroDivisionError ,没有任何信息。怎么回事? 别急,在 import logging 之后添加一行配置再试试: import logging logging.basicConfig(level=logging.INFO) 看到输出了: $ python err.py INFO:root:n = 0 Traceback (most recent call last): File "err.py", line 8, in print 10 / n ZeroDivisionError: integer division or modulo by zero 这就是 logging 的好处,它允许你指定记录信息的级别,有 debug , info , warning , error 等几个级别,当我们 指定 level=INFO 时, logging.debug 就不起作用了。同理,指定 level=WARNING 后, debug 和 info 就不起作用 了。这样一来,你可以放心地输出不同级别的信息,也不用删除,最后统一控制输出哪个级别的信息。 logging 的另一个好处是通过简单的配置,一条语句可以同时输出到不同的地方,比如console和文件。 pdb 第4种方式是启动Python的调试器pdb,让程序以单步方式运行,可以随时查看运行状态。我们先准备好程序: # err.py s = '0' n = int(s) print 10 / n 然后启动: $ python -m pdb err.py $ python -m pdb err.py > /Users/michael/Github/sicp/err.py(2)() -> s = '0' 以参数 ‐m pdb 启动后,pdb定位到下一步要执行的代码 ‐> s = '0' 。输入命令 l 来查看代码: (Pdb) l 1 # err.py 2 -> s = '0' 3 n = int(s) 4 print 10 / n [EOF] 输入命令 n 可以单步执行代码: (Pdb) n > /Users/michael/Github/sicp/err.py(3)() -> n = int(s) (Pdb) n > /Users/michael/Github/sicp/err.py(4)() -> print 10 / n 任何时候都可以输入命令 p 变量名 来查看变量: (Pdb) p s '0' (Pdb) p n 0 输入命令 q 结束调试,退出程序: (Pdb) n ZeroDivisionError: 'integer division or modulo by zero' > /Users/michael/Github/sicp/err.py(4)() -> print 10 / n (Pdb) q 这种通过pdb在命令行调试的方法理论上是万能的,但实在是太麻烦了,如果有一千行代码,要运行到第999行得敲 多少命令啊。还好,我们还有另一种调试方法。 pdb.set_trace() 这个方法也是用pdb,但是不需要单步执行,我们只需要 import pdb ,然后,在可能出错的地方放一 个 pdb.set_trace() ,就可以设置一个断点: # err.py import pdb s = '0' n = int(s) pdb.set_trace() # 运行到这里会自动暂停 pdb.set_trace() # 运行到这里会自动暂停 print 10 / n 运行代码,程序会自动在 pdb.set_trace() 暂停并进入pdb调试环境,可以用命令 p 查看变量,或者用命令 c 继续 运行: $ python err.py > /Users/michael/Github/sicp/err.py(7)() -> print 10 / n (Pdb) p n 0 (Pdb) c Traceback (most recent call last): File "err.py", line 7, in print 10 / n ZeroDivisionError: integer division or modulo by zero 这个方式比直接启动pdb单步调试效率要高很多,但也高不到哪去。 IDE 如果要比较爽地设置断点、单步执行,就需要一个支持调试功能的IDE。目前比较好的Python IDE有PyCharm: http://www.jetbrains.com/pycharm/ 另外,Eclipse加上pydev插件也可以调试Python程序。 小结 写程序最痛苦的事情莫过于调试,程序往往会以你意想不到的流程来运行,你期待执行的语句其实根本没有执 行,这时候,就需要调试了。 虽然用IDE调试起来比较方便,但是最后你会发现,logging才是终极武器。 您的鼓励是作者写作最大的动力 如果您认为本网站的教程质量不错,读后觉得收获很大,预期工资涨幅能超过30%,不妨小额赞助我一下,让我有 动力继续写出高质量的教程: 单元测试 21次阅读 如果你听说过“测试驱动开发”(TDD:Test­Driven Development),单元测试就不陌生。 单元测试是用来对一个模块、一个函数或者一个类来进行正确性检验的测试工作。 比如对函数 abs() ,我们可以编写出以下几个测试用例: 1.  输入正数,比如 1 、 1.2 、 0.99 ,期待返回值与输入相同; 2.  输入负数,比如 ‐1 、 ‐1.2 、 ‐0.99 ,期待返回值与输入相反; 3.  输入 0 ,期待返回 0 ; 4.  输入非数值类型,比如 None 、 [] 、 {} ,期待抛出 TypeError 。 把上面的测试用例放到一个测试模块里,就是一个完整的单元测试。 如果单元测试通过,说明我们测试的这个函数能够正常工作。如果单元测试不通过,要么函数有bug,要么测试条件 输入不正确,总之,需要修复使单元测试能够通过。 单元测试通过后有什么意义呢?如果我们对 abs() 函数代码做了修改,只需要再跑一遍单元测试,如果通过,说明 我们的修改不会对 abs() 函数原有的行为造成影响,如果测试不通过,说明我们的修改与原有行为不一致,要么修 改代码,要么修改测试。 这种以测试为驱动的开发模式最大的好处就是确保一个程序模块的行为符合我们设计的测试用例。在将来修改的时 候,可以极大程度地保证该模块行为仍然是正确的。 我们来编写一个 Dict 类,这个类的行为和 dict 一致,但是可以通过属性来访问,用起来就像下面这样: >>> d = Dict(a=1, b=2) >>> d['a'] 1 >>> d.a 1 mydict.py 代码如下: class Dict(dict): def __init__(self, **kw): super(Dict, self).__init__(**kw) def __getattr__(self, key): try: return self[key] except KeyError: raise AttributeError(r"'Dict' object has no attribute '%s'" % key) def __setattr__(self, key, value): self[key] = value 为了编写单元测试,我们需要引入Python自带的 unittest 模块,编写 mydict_test.py 如下: import unittest from mydict import Dict class TestDict(unittest.TestCase): def test_init(self): d = Dict(a=1, b='test') self.assertEquals(d.a, 1) self.assertEquals(d.b, 'test') self.assertEquals(d.b, 'test') self.assertTrue(isinstance(d, dict)) def test_key(self): d = Dict() d['key'] = 'value' self.assertEquals(d.key, 'value') def test_attr(self): d = Dict() d.key = 'value' self.assertTrue('key' in d) self.assertEquals(d['key'], 'value') def test_keyerror(self): d = Dict() with self.assertRaises(KeyError): value = d['empty'] def test_attrerror(self): d = Dict() with self.assertRaises(AttributeError): value = d.empty 编写单元测试时,我们需要编写一个测试类,从 unittest.TestCase 继承。 以 test 开头的方法就是测试方法,不以 test 开头的方法不被认为是测试方法,测试的时候不会被执行。 对每一类测试都需要编写一个 test_xxx() 方法。由于 unittest.TestCase 提供了很多内置的条件判断,我们只需要 调用这些方法就可以断言输出是否是我们所期望的。最常用的断言就是 assertEquals() : self.assertEquals(abs(-1), 1) # 断言函数返回的结果与1相等 另一种重要的断言就是期待抛出指定类型的Error,比如通过 d['empty'] 访问不存在的key时,断言会抛 出 KeyError : with self.assertRaises(KeyError): value = d['empty'] 而通过 d.empty 访问不存在的key时,我们期待抛出 AttributeError : with self.assertRaises(AttributeError): value = d.empty 运行单元测试 一旦编写好单元测试,我们就可以运行单元测试。最简单的运行方式是在 mydict_test.py 的最后加上两行代码: if __name__ == '__main__': unittest.main() 这样就可以把 mydict_test.py 当做正常的python脚本运行: 这样就可以把 mydict_test.py 当做正常的python脚本运行: $ python mydict_test.py 另一种更常见的方法是在命令行通过参数 ‐m unittest 直接运行单元测试: $ python -m unittest mydict_test ..... ---------------------------------------------------------------------- Ran 5 tests in 0.000s OK 这是推荐的做法,因为这样可以一次批量运行很多单元测试,并且,有很多工具可以自动来运行这些单元测试。 setUp与tearDown 可以在单元测试中编写两个特殊的 setUp() 和 tearDown() 方法。这两个方法会分别在每调用一个测试方法的前后分 别被执行。 setUp() 和 tearDown() 方法有什么用呢?设想你的测试需要启动一个数据库,这时,就可以在 setUp() 方法中连接 数据库,在 tearDown() 方法中关闭数据库,这样,不必在每个测试方法中重复相同的代码: class TestDict(unittest.TestCase): def setUp(self): print 'setUp...' def tearDown(self): print 'tearDown...' 可以再次运行测试看看每个测试方法调用前后是否会打印出 setUp... 和 tearDown... 。 小结 单元测试可以有效地测试某个程序模块的行为,是未来重构代码的信心保证。 单元测试的测试用例要覆盖常用的输入组合、边界条件和异常。 单元测试代码要非常简单,如果测试代码太复杂,那么测试代码本身就可能有bug。 单元测试通过了并不意味着程序就没有bug了,但是不通过程序肯定有bug。 您的鼓励是作者写作最大的动力 如果您认为本网站的教程质量不错,读后觉得收获很大,预期工资涨幅能超过30%,不妨小额赞助我一下,让我有 动力继续写出高质量的教程: 文档测试 2次阅读 如果你经常阅读Python的官方文档,可以看到很多文档都有示例代码。比如re模块就带了很多示例代码: >>> import re >>> m = re.search('(?<=abc)def', 'abcdef') >>> m.group(0) 'def' 可以把这些示例代码在Python的交互式环境下输入并执行,结果与文档中的示例代码显示的一致。 这些代码与其他说明可以写在注释中,然后,由一些工具来自动生成文档。既然这些代码本身就可以粘贴出来直接 运行,那么,可不可以自动执行写在注释中的这些代码呢? 答案是肯定的。 当我们编写注释时,如果写上这样的注释: def abs(n): ''' Function to get absolute value of number. Example: >>> abs(1) 1 >>> abs(-1) 1 >>> abs(0) 0 ''' return n if n >= 0 else (-n) 无疑更明确地告诉函数的调用者该函数的期望输入和输出。 并且,Python内置的“文档测试”(doctest)模块可以直接提取注释中的代码并执行测试。 doctest严格按照Python交互式命令行的输入和输出来判断测试结果是否正确。只有测试异常的时候,可以用 ... 表 示中间一大段烦人的输出。 让我们用doctest来测试上次编写的 Dict 类: class Dict(dict): ''' Simple dict but also support access as x.y style. >>> d1 = Dict() >>> d1['x'] = 100 >>> d1.x 100 >>> d1.y = 200 >>> d1['y'] 200 200 >>> d2 = Dict(a=1, b=2, c='3') >>> d2.c '3' >>> d2['empty'] Traceback (most recent call last): ... KeyError: 'empty' >>> d2.empty Traceback (most recent call last): ... AttributeError: 'Dict' object has no attribute 'empty' ''' def __init__(self, **kw): super(Dict, self).__init__(**kw) def __getattr__(self, key): try: return self[key] except KeyError: raise AttributeError(r"'Dict' object has no attribute '%s'" % key) def __setattr__(self, key, value): self[key] = value if __name__=='__main__': import doctest doctest.testmod() 运行 python mydict.py : $ python mydict.py 什么输出也没有。这说明我们编写的doctest运行都是正确的。如果程序有问题,比如把 __getattr__() 方法注释 掉,再运行就会报错: $ python mydict.py ********************************************************************** File "mydict.py", line 7, in __main__.Dict Failed example: d1.x Exception raised: Traceback (most recent call last): ... AttributeError: 'Dict' object has no attribute 'x' ********************************************************************** File "mydict.py", line 13, in __main__.Dict Failed example: d2.c Exception raised: Traceback (most recent call last): ... AttributeError: 'Dict' object has no attribute 'c' ********************************************************************** 注意到最后两行代码。当模块正常导入时,doctest不会被执行。只有在命令行运行时,才执行doctest。所以,不必 担心doctest会在非测试环境下执行。 小结 doctest非常有用,不但可以用来测试,还可以直接作为示例代码。通过某些文档生成工具,就可以自动把包含docte st的注释提取出来。用户看文档的时候,同时也看到了doctest。 您的鼓励是作者写作最大的动力 如果您认为本网站的教程质量不错,读后觉得收获很大,预期工资涨幅能超过30%,不妨小额赞助我一下,让我有 动力继续写出高质量的教程: IO编程 32次阅读 IO在计算机中指Input/Output,也就是输入和输出。由于程序和运行时数据是在内存中驻留,由CPU这个超快的计算 核心来执行,涉及到数据交换的地方,通常是磁盘、网络等,就需要IO接口。 比如你打开浏览器,访问新浪首页,浏览器这个程序就需要通过网络IO获取新浪的网页。浏览器首先会发送数据给 新浪服务器,告诉它我想要首页的HTML,这个动作是往外发数据,叫Output,随后新浪服务器把网页发过来,这 个动作是从外面接收数据,叫Input。所以,通常,程序完成IO操作会有Input和Output两个数据流。当然也有只用一 个的情况,比如,从磁盘读取文件到内存,就只有Input操作,反过来,把数据写到磁盘文件里,就只是一个Output 操作。 IO编程中,Stream(流)是一个很重要的概念,可以把流想象成一个水管,数据就是水管里的水,但是只能单向流 动。Input Stream就是数据从外面(磁盘、网络)流进内存,Output Stream就是数据从内存流到外面去。对于浏览 网页来说,浏览器和新浪服务器之间至少需要建立两根水管,才可以既能发数据,又能收数据。 由于CPU和内存的速度远远高于外设的速度,所以,在IO编程中,就存在速度严重不匹配的问题。举个例子来 说,比如要把100M的数据写入磁盘,CPU输出100M的数据只需要0.01秒,可是磁盘要接收这100M数据可能需要1 0秒,怎么办呢?有两种办法: 第一种是CPU等着,也就是程序暂停执行后续代码,等100M的数据在10秒后写入磁盘,再接着往下执行,这种模式 称为同步IO; 另一种方法是CPU不等待,只是告诉磁盘,“您老慢慢写,不着急,我接着干别的事去了”,于是,后续代码可以立刻 接着执行,这种模式称为异步IO。 同步和异步的区别就在于是否等待IO执行的结果。好比你去麦当劳点餐,你说“来个汉堡”,服务员告诉你,对不 起,汉堡要现做,需要等5分钟,于是你站在收银台前面等了5分钟,拿到汉堡再去逛商场,这是同步IO。 你说“来个汉堡”,服务员告诉你,汉堡需要等5分钟,你可以先去逛商场,等做好了,我们再通知你,这样你可以立 刻去干别的事情(逛商场),这是异步IO。 很明显,使用异步IO来编写程序性能会远远高于同步IO,但是异步IO的缺点是编程模型复杂。想想看,你得知道什 么时候通知你“汉堡做好了”,而通知你的方法也各不相同。如果是服务员跑过来找到你,这是回调模式,如果服务员 发短信通知你,你就得不停地检查手机,这是轮询模式。总之,异步IO的复杂度远远高于同步IO。 操作IO的能力都是由操作系统提供的,每一种编程语言都会把操作系统提供的低级C接口封装起来方便使用,Pytho n也不例外。我们后面会详细讨论Python的IO编程接口。 注意,本章的IO编程都是同步模式,异步IO由于复杂度太高,后续涉及到服务器端程序开发时我们再讨论。 您的鼓励是作者写作最大的动力 如果您认为本网站的教程质量不错,读后觉得收获很大,预期工资涨幅能超过30%,不妨小额赞助我一下,让我有 动力继续写出高质量的教程: 文件读写 89次阅读 读写文件是最常见的IO操作。Python内置了读写文件的函数,用法和C是兼容的。 读写文件前,我们先必须了解一下,在磁盘上读写文件的功能都是由操作系统提供的,现代操作系统不允许普通的 程序直接操作磁盘,所以,读写文件就是请求操作系统打开一个文件对象(通常称为文件描述符),然后,通过操 作系统提供的接口从这个文件对象中读取数据(读文件),或者把数据写入这个文件对象(写文件)。 读文件 要以读文件的模式打开一个文件对象,使用Python内置的 open() 函数,传入文件名和标示符: >>> f = open('/Users/michael/test.txt', 'r') 标示符'r'表示读,这样,我们就成功地打开了一个文件。 如果文件不存在, open() 函数就会抛出一个 IOError 的错误,并且给出错误码和详细的信息告诉你文件不存在: >>> f=open('/Users/michael/notfound.txt', 'r') Traceback (most recent call last): File "", line 1, in IOError: [Errno 2] No such file or directory: '/Users/michael/notfound.txt' 如果文件打开成功,接下来,调用 read() 方法可以一次读取文件的全部内容,Python把内容读到内存,用一 个 str 对象表示: >>> f.read() 'Hello, world!' 最后一步是调用 close() 方法关闭文件。文件使用完毕后必须关闭,因为文件对象会占用操作系统的资源,并且操 作系统同一时间能打开的文件数量也是有限的: >>> f.close() 由于文件读写时都有可能产生 IOError ,一旦出错,后面的 f.close() 就不会调用。所以,为了保证无论是否出错 都能正确地关闭文件,我们可以使用 try ... finally 来实现: try: f = open('/path/to/file', 'r') print f.read() finally: if f: f.close() 但是每次都这么写实在太繁琐,所以,Python引入了 with 语句来自动帮我们调用 close() 方法: with open('/path/to/file', 'r') as f: print f.read() 这和前面的 try ... finally 是一样的,但是代码更佳简洁,并且不必调用 f.close() 方法。 调用 read() 会一次性读取文件的全部内容,如果文件有10G,内存就爆了,所以,要保险起见,可以反复调 用 read(size) 方法,每次最多读取size个字节的内容。另外,调用 readline() 可以每次读取一行内容,调 用 readlines() 一次读取所有内容并按行返回 list 。因此,要根据需要决定怎么调用。 如果文件很小, read() 一次性读取最方便;如果不能确定文件大小,反复调用 read(size) 比较保险;如果是配置 文件,调用 readlines() 最方便: for line in f.readlines(): print(line.strip()) # 把末尾的'\n'删掉 file­like Object 像 open() 函数返回的这种有个 read() 方法的对象,在Python中统称为file­like Object。除了file外,还可以是内存 的字节流,网络流,自定义流等等。file­like Object不要求从特定类继承,只要写个 read() 方法就行。 StringIO 就是在内存中创建的file­like Object,常用作临时缓冲。 二进制文件 前面讲的默认都是读取文本文件,并且是ASCII编码的文本文件。要读取二进制文件,比如图片、视频等 等,用 'rb' 模式打开文件即可: >>> f = open('/Users/michael/test.jpg', 'rb') >>> f.read() '\xff\xd8\xff\xe1\x00\x18Exif\x00\x00...' # 十六进制表示的字节 字符编码 要读取非ASCII编码的文本文件,就必须以二进制模式打开,再解码。比如GBK编码的文件: >>> f = open('/Users/michael/gbk.txt', 'rb') >>> u = f.read().decode('gbk') >>> u u'\u6d4b\u8bd5' >>> print u 测试 如果每次都这么手动转换编码嫌麻烦(写程序怕麻烦是好事,不怕麻烦就会写出又长又难懂又没法维护的代码),P ython还提供了一个 codecs 模块帮我们在读文件时自动转换编码,直接读出unicode: import codecs with codecs.open('/Users/michael/gbk.txt', 'r', 'gbk') as f: f.read() # u'\u6d4b\u8bd5' 写文件 写文件和读文件是一样的,唯一区别是调用 open() 函数时,传入标识符 'w' 或者 'wb' 表示写文本文件或写二进制 文件: >>> f = open('/Users/michael/test.txt', 'w') >>> f.write('Hello, world!') >>> f.close() 你可以反复调用 write() 来写入文件,但是务必要调用 f.close() 来关闭文件。当我们写文件时,操作系统往往不 会立刻把数据写入磁盘,而是放到内存缓存起来,空闲的时候再慢慢写入。只有调用 close() 方法时,操作系统才 保证把没有写入的数据全部写入磁盘。忘记调用 close() 的后果是数据可能只写了一部分到磁盘,剩下的丢失 了。所以,还是用 with 语句来得保险: with open('/Users/michael/test.txt', 'w') as f: f.write('Hello, world!') 要写入特定编码的文本文件,请效仿 codecs 的示例,写入unicode,由 codecs 自动转换成指定编码。 小结 在Python中,文件读写是通过 open() 函数打开的文件对象完成的。使用 with 语句操作文件IO是个好习惯。 您的鼓励是作者写作最大的动力 如果您认为本网站的教程质量不错,读后觉得收获很大,预期工资涨幅能超过30%,不妨小额赞助我一下,让我有 动力继续写出高质量的教程: 操作文件和目录 39次阅读 如果我们要操作文件、目录,可以在命令行下面输入操作系统提供的各种命令来完成。比如 dir 、 cp 等命令。 如果要在Python程序中执行这些目录和文件的操作怎么办?其实操作系统提供的命令只是简单地调用了操作系统提 供的接口函数,Python内置的 os 模块也可以直接调用操作系统提供的接口函数。 打开Python交互式命令行,我们来看看如何使用 os 模块的基本功能: >>> import os >>> os.name # 操作系统名字 'posix' 如果是 posix ,说明系统是 Linux 、 Unix 或 Mac OS X ,如果是 nt ,就是 Windows 系统。 要获取详细的系统信息,可以调用 uname() 函数: >>> os.uname() ('Darwin', 'iMac.local', '13.3.0', 'Darwin Kernel Version 13.3.0: Tue Jun 3 21:27:35 PDT 2014; root:xnu-2422.11 0.17~1/RELEASE_X86_64', 'x86_64') 注意 uname() 函数在Windows上不提供,也就是说,os模块的某些函数是跟操作系统相关的。 环境变量 在操作系统中定义的环境变量,全部保存在 os.environ 这个 dict 中,可以直接查看: >>> os.environ {'VERSIONER_PYTHON_PREFER_32_BIT': 'no', 'TERM_PROGRAM_VERSION': '326', 'LOGNAME': 'michael', 'USER': 'michael', 'PATH': '/usr/bin:/bin:/usr/sbin:/sbin:/usr/local/bin:/opt/X11/bin:/usr/local/mysql/bin', ...} 要获取某个环境变量的值,可以调用 os.getenv() 函数: >>> os.getenv('PATH') '/usr/bin:/bin:/usr/sbin:/sbin:/usr/local/bin:/opt/X11/bin:/usr/local/mysql/bin' 操作文件和目录 操作文件和目录的函数一部分放在 os 模块中,一部分放在 os.path 模块中,这一点要注意一下。查看、创建和删除 目录可以这么调用: # 查看当前目录的绝对路径: >>> os.path.abspath('.') '/Users/michael' # 在某个目录下创建一个新目录, # 首先把新目录的完整路径表示出来: >>> os.path.join('/Users/michael', 'testdir') '/Users/michael/testdir' # 然后创建一个目录: >>> os.mkdir('/Users/michael/testdir') # 删掉一个目录: >>> os.rmdir('/Users/michael/testdir') 把两个路径合成一个时,不要直接拼字符串,而要通过 os.path.join() 函数,这样可以正确处理不同操作系统的路 径分隔符。在Linux/Unix/Mac下, os.path.join() 返回这样的字符串: part-1/part-2 而Windows下会返回这样的字符串: part-1\part-2 同样的道理,要拆分路径时,也不要直接去拆字符串,而要通过 os.path.split() 函数,这样可以把一个路径拆分为 两部分,后一部分总是最后级别的目录或文件名: >>> os.path.split('/Users/michael/testdir/file.txt') ('/Users/michael/testdir', 'file.txt') os.path.splitext() 可以直接让你得到文件扩展名,很多时候非常方便: >>> os.path.splitext('/path/to/file.txt') ('/path/to/file', '.txt') 这些合并、拆分路径的函数并不要求目录和文件要真实存在,它们只对字符串进行操作。 文件操作使用下面的函数。假定当前目录下有一个 test.txt 文件: # 对文件重命名: >>> os.rename('test.txt', 'test.py') # 删掉文件: >>> os.remove('test.py') 但是复制文件的函数居然在 os 模块中不存在!原因是复制文件并非由操作系统提供的系统调用。理论上讲,我们通 过上一节的读写文件可以完成文件复制,只不过要多写很多代码。 幸运的是 shutil 模块提供了 copyfile() 的函数,你还可以在 shutil 模块中找到很多实用函数,它们可以看做 是 os 模块的补充。 最后看看如何利用Python的特性来过滤文件。比如我们要列出当前目录下的所有目录,只需要一行代码: >>> [x for x in os.listdir('.') if os.path.isdir(x)] ['.lein', '.local', '.m2', '.npm', '.ssh', '.Trash', '.vim', 'Adlm', 'Applications', 'Desktop', ...] 要列出所有的 .py 文件,也只需一行代码: >>> [x for x in os.listdir('.') if os.path.isfile(x) and os.path.splitext(x)[1]=='.py'] ['apis.py', 'config.py', 'models.py', 'pymonitor.py', 'test_db.py', 'urls.py', 'wsgiapp.py'] 是不是非常简洁? 小结 Python的 os 模块封装了操作系统的目录和文件操作,要注意这些函数有的在 os 模块中,有的在 os.path 模块中。 练习:编写一个 search(s) 的函数,能在当前目录以及当前目录的所有子目录下查找文件名包含指定字符串的文 件,并打印出完整路径: $ python search.py test unit_test.log py/test.py py/test_os.py my/logs/unit-test-result.txt 您的鼓励是作者写作最大的动力 如果您认为本网站的教程质量不错,读后觉得收获很大,预期工资涨幅能超过30%,不妨小额赞助我一下,让我有 动力继续写出高质量的教程: 序列化 序列化 53次阅读 在程序运行的过程中,所有的变量都是在内存中,比如,定义一个dict: d = dict(name='Bob', age=20, score=88) 可以随时修改变量,比如把 name 改成 'Bill' ,但是一旦程序结束,变量所占用的内存就被操作系统全部回收。如 果没有把修改后的 'Bill' 存储到磁盘上,下次重新运行程序,变量又被初始化为 'Bob' 。 我们把变量从内存中变成可存储或传输的过程称之为序列化,在Python中叫pickling,在其他语言中也被称之为seria lization,marshalling,flattening等等,都是一个意思。 序列化之后,就可以把序列化后的内容写入磁盘,或者通过网络传输到别的机器上。 反过来,把变量内容从序列化的对象重新读到内存里称之为反序列化,即unpickling。 Python提供两个模块来实现序列化: cPickle 和 pickle 。这两个模块功能是一样的,区别在于 cPickle 是C语言写 的,速度快, pickle 是纯Python写的,速度慢,跟 cStringIO 和 StringIO 一个道理。用的时候,先尝试导 入 cPickle ,如果失败,再导入 pickle : try: import cPickle as pickle except ImportError: import pickle 首先,我们尝试把一个对象序列化并写入文件: >>> d = dict(name='Bob', age=20, score=88) >>> pickle.dumps(d) "(dp0\nS'age'\np1\nI20\nsS'score'\np2\nI88\nsS'name'\np3\nS'Bob'\np4\ns." pickle.dumps() 方法把任意对象序列化成一个str,然后,就可以把这个str写入文件。或者用另一个方 法 pickle.dump() 直接把对象序列化后写入一个file­like Object: >>> f = open('dump.txt', 'wb') >>> pickle.dump(d, f) >>> f.close() 看看写入的 dump.txt 文件,一堆乱七八糟的内容,这些都是Python保存的对象内部信息。 当我们要把对象从磁盘读到内存时,可以先把内容读到一个 str ,然后用 pickle.loads() 方法反序列化出对象,也 可以直接用 pickle.load() 方法从一个 file‐like Object 中直接反序列化出对象。我们打开另一个Python命令行来 反序列化刚才保存的对象: >>> f = open('dump.txt', 'rb') >>> d = pickle.load(f) >>> f.close() >>> d {'age': 20, 'score': 88, 'name': 'Bob'} {'age': 20, 'score': 88, 'name': 'Bob'} 变量的内容又回来了! 当然,这个变量和原来的变量是完全不相干的对象,它们只是内容相同而已。 Pickle的问题和所有其他编程语言特有的序列化问题一样,就是它只能用于Python,并且可能不同版本的Python彼 此都不兼容,因此,只能用Pickle保存那些不重要的数据,不能成功地反序列化也没关系。 JSON 如果我们要在不同的编程语言之间传递对象,就必须把对象序列化为标准格式,比如XML,但更好的方法是序列化 为JSON,因为JSON表示出来就是一个字符串,可以被所有语言读取,也可以方便地存储到磁盘或者通过网络传 输。JSON不仅是标准格式,并且比XML更快,而且可以直接在Web页面中读取,非常方便。 JSON表示的对象就是标准的JavaScript语言的对象,JSON和Python内置的数据类型对应如下: JSON类型 Python类型 {} dict [] list "string" 'str'或u'unicode' 1234.56 int或float true/false True/False null None Python内置的 json 模块提供了非常完善的Python对象到JSON格式的转换。我们先看看如何把Python对象变成一个 JSON: >>> import json >>> d = dict(name='Bob', age=20, score=88) >>> json.dumps(d) '{"age": 20, "score": 88, "name": "Bob"}' dumps() 方法返回一个 str ,内容就是标准的JSON。类似的, dump() 方法可以直接把JSON写入一 个 file‐like Object 。 要把JSON反序列化为Python对象,用 loads() 或者对应的 load() 方法,前者把JSON的字符串反序列化,后者 从 file‐like Object 中读取字符串并反序列化: >>> json_str = '{"age": 20, "score": 88, "name": "Bob"}' >>> json.loads(json_str) {u'age': 20, u'score': 88, u'name': u'Bob'} 有一点需要注意,就是反序列化得到的所有字符串对象默认都是 unicode 而不是 str 。由于JSON标准规定JSON编 码是UTF­8,所以我们总是能正确地在Python的 str 或 unicode 与JSON的字符串之间转换。 JSON进阶 Python的 dict 对象可以直接序列化为JSON的 {} ,不过,很多时候,我们更喜欢用 class 表示对象,比如定 义 Student 类,然后序列化: 义 Student 类,然后序列化: import json class Student(object): def __init__(self, name, age, score): self.name = name self.age = age self.score = score s = Student('Bob', 20, 88) print(json.dumps(s)) 运行代码,毫不留情地得到一个 TypeError : Traceback (most recent call last): ... TypeError: <__main__.Student object at 0x10aabef50> is not JSON serializable 错误的原因是 Student 对象不是一个可序列化为JSON的对象。 如果连 class 的实例对象都无法序列化为JSON,这肯定不合理! 别急,我们仔细看看 dumps() 方法的参数列表,可以发现,除了第一个必须的 obj 参数外, dumps() 方法还提供了 一大堆的可选参数: https://docs.python.org/2/library/json.html#json.dumps 这些可选参数就是让我们来定制JSON序列化。前面的代码之所以无法把 Student 类实例序列化为JSON,是因为默 认情况下, dumps() 方法不知道如何将 Student 实例变为一个JSON的 {} 对象。 可选参数 default 就是把任意一个对象变成一个可序列为JSON的对象,我们只需要为 Student 专门写一个转换函 数,再把函数传进去即可: def student2dict(std): return { 'name': std.name, 'age': std.age, 'score': std.score } print(json.dumps(s, default=student2dict)) 这样, Student 实例首先被 student2dict() 函数转换成 dict ,然后再被顺利序列化为JSON。 不过,下次如果遇到一个 Teacher 类的实例,照样无法序列化为JSON。我们可以偷个懒,把任意 class 的实例变 为 dict : print(json.dumps(s, default=lambda obj: obj.__dict__)) 因为通常 class 的实例都有一个 __dict__ 属性,它就是一个 dict ,用来存储实例变量。也有少数例外,比如定义 了 __slots__ 的class。 同样的道理,如果我们要把JSON反序列化为一个 Student 对象实例, loads() 方法首先转换出一个 dict 对象,然 后,我们传入的 object_hook 函数负责把 dict 转换为 Student 实例: def dict2student(d): return Student(d['name'], d['age'], d['score']) json_str = '{"age": 20, "score": 88, "name": "Bob"}' print(json.loads(json_str, object_hook=dict2student)) 运行结果如下: <__main__.Student object at 0x10cd3c190> 打印出的是反序列化的 Student 实例对象。 小结 Python语言特定的序列化模块是 pickle ,但如果要把序列化搞得更通用、更符合Web标准,就可以使用 json 模 块。 json 模块的 dumps() 和 loads() 函数是定义得非常好的接口的典范。当我们使用时,只需要传入一个必须的参 数。但是,当默认的序列化或反序列机制不满足我们的要求时,我们又可以传入更多的参数来定制序列化或反序列 化的规则,既做到了接口简单易用,又做到了充分的扩展性和灵活性。 您的鼓励是作者写作最大的动力 如果您认为本网站的教程质量不错,读后觉得收获很大,预期工资涨幅能超过30%,不妨小额赞助我一下,让我有 动力继续写出高质量的教程: 进程和线程 33次阅读 很多同学都听说过,现代操作系统比如Mac OS X,UNIX,Linux,Windows等,都是支持“多任务”的操作系统。 什么叫“多任务”呢?简单地说,就是操作系统可以同时运行多个任务。打个比方,你一边在用浏览器上网,一边在听 MP3,一边在用Word赶作业,这就是多任务,至少同时有3个任务正在运行。还有很多任务悄悄地在后台同时运行 着,只是桌面上没有显示而已。 现在,多核CPU已经非常普及了,但是,即使过去的单核CPU,也可以执行多任务。由于CPU执行代码都是顺序执 行的,那么,单核CPU是怎么执行多任务的呢? 答案就是操作系统轮流让各个任务交替执行,任务1执行0.01秒,切换到任务2,任务2执行0.01秒,再切换到任务 3,执行0.01秒……这样反复执行下去。表面上看,每个任务都是交替执行的,但是,由于CPU的执行速度实在是太 快了,我们感觉就像所有任务都在同时执行一样。 真正的并行执行多任务只能在多核CPU上实现,但是,由于任务数量远远多于CPU的核心数量,所以,操作系统也 会自动把很多任务轮流调度到每个核心上执行。 对于操作系统来说,一个任务就是一个进程(Process),比如打开一个浏览器就是启动一个浏览器进程,打开一个 记事本就启动了一个记事本进程,打开两个记事本就启动了两个记事本进程,打开一个Word就启动了一个Word进 程。 有些进程还不止同时干一件事,比如Word,它可以同时进行打字、拼写检查、打印等事情。在一个进程内部,要同 时干多件事,就需要同时运行多个“子任务”,我们把进程内的这些“子任务”称为线程(Thread)。 由于每个进程至少要干一件事,所以,一个进程至少有一个线程。当然,像Word这种复杂的进程可以有多个线 程,多个线程可以同时执行,多线程的执行方式和多进程是一样的,也是由操作系统在多个线程之间快速切换,让 每个线程都短暂地交替运行,看起来就像同时执行一样。当然,真正地同时执行多线程需要多核CPU才可能实现。 我们前面编写的所有的Python程序,都是执行单任务的进程,也就是只有一个线程。如果我们要同时执行多个任务 怎么办? 有两种解决方案: 一种是启动多个进程,每个进程虽然只有一个线程,但多个进程可以一块执行多个任务。 还有一种方法是启动一个进程,在一个进程内启动多个线程,这样,多个线程也可以一块执行多个任务。 当然还有第三种方法,就是启动多个进程,每个进程再启动多个线程,这样同时执行的任务就更多了,当然这种模 型更复杂,实际很少采用。 总结一下就是,多任务的实现有3种方式: 多进程模式; 多线程模式; 多进程+多线程模式。 同时执行多个任务通常各个任务之间并不是没有关联的,而是需要相互通信和协调,有时,任务1必须暂停等待任务 2完成后才能继续执行,有时,任务3和任务4又不能同时执行,所以,多进程和多线程的程序的复杂度要远远高于我 们前面写的单进程单线程的程序。 因为复杂度高,调试困难,所以,不是迫不得已,我们也不想编写多任务。但是,有很多时候,没有多任务还真不 行。想想在电脑上看电影,就必须由一个线程播放视频,另一个线程播放音频,否则,单线程实现的话就只能先把 视频播放完再播放音频,或者先把音频播放完再播放视频,这显然是不行的。 Python既支持多进程,又支持多线程,我们会讨论如何编写这两种多任务程序。 小结 线程是最小的执行单元,而进程由至少一个线程组成。如何调度进程和线程,完全由操作系统决定,程序自己不能 决定什么时候执行,执行多长时间。 多进程和多线程的程序涉及到同步、数据共享的问题,编写起来更复杂。 您的鼓励是作者写作最大的动力 如果您认为本网站的教程质量不错,读后觉得收获很大,预期工资涨幅能超过30%,不妨小额赞助我一下,让我有 动力继续写出高质量的教程: 多进程 96次阅读 要让Python程序实现多进程(multiprocessing),我们先了解操作系统的相关知识。 Unix/Linux操作系统提供了一个 fork() 系统调用,它非常特殊。普通的函数调用,调用一次,返回一次,但 是 fork() 调用一次,返回两次,因为操作系统自动把当前进程(称为父进程)复制了一份(称为子进程),然 后,分别在父进程和子进程内返回。 子进程永远返回 0 ,而父进程返回子进程的ID。这样做的理由是,一个父进程可以fork出很多子进程,所以,父进 程要记下每个子进程的ID,而子进程只需要调用 getppid() 就可以拿到父进程的ID。 Python的 os 模块封装了常见的系统调用,其中就包括 fork ,可以在Python程序中轻松创建子进程: # multiprocessing.py import os print 'Process (%s) start...' % os.getpid() pid = os.fork() if pid==0: print 'I am child process (%s) and my parent is %s.' % (os.getpid(), os.getppid()) else: print 'I (%s) just created a child process (%s).' % (os.getpid(), pid) 运行结果如下: Process (876) start... I (876) just created a child process (877). I am child process (877) and my parent is 876. 由于Windows没有 fork 调用,上面的代码在Windows上无法运行。由于Mac系统是基于BSD(Unix的一种)内 核,所以,在Mac下运行是没有问题的,推荐大家用Mac学Python! 有了 fork 调用,一个进程在接到新任务时就可以复制出一个子进程来处理新任务,常见的Apache服务器就是由父 进程监听端口,每当有新的http请求时,就fork出子进程来处理新的http请求。 multiprocessing 如果你打算编写多进程的服务程序,Unix/Linux无疑是正确的选择。由于Windows没有 fork 调用,难道在Windows 上无法用Python编写多进程的程序? 由于Python是跨平台的,自然也应该提供一个跨平台的多进程支持。 multiprocessing 模块就是跨平台版本的多进 程模块。 multiprocessing 模块提供了一个 Process 类来代表一个进程对象,下面的例子演示了启动一个子进程并等待其结 束: from multiprocessing import Process import os # 子进程要执行的代码 def run_proc(name): def run_proc(name): print 'Run child process %s (%s)...' % (name, os.getpid()) if __name__=='__main__': print 'Parent process %s.' % os.getpid() p = Process(target=run_proc, args=('test',)) print 'Process will start.' p.start() p.join() print 'Process end.' 执行结果如下: Parent process 928. Process will start. Run child process test (929)... Process end. 创建子进程时,只需要传入一个执行函数和函数的参数,创建一个 Process 实例,用 start() 方法启动,这样创建 进程比 fork() 还要简单。 join() 方法可以等待子进程结束后再继续往下运行,通常用于进程间的同步。 Pool 如果要启动大量的子进程,可以用进程池的方式批量创建子进程: from multiprocessing import Pool import os, time, random def long_time_task(name): print 'Run task %s (%s)...' % (name, os.getpid()) start = time.time() time.sleep(random.random() * 3) end = time.time() print 'Task %s runs %0.2f seconds.' % (name, (end - start)) if __name__=='__main__': print 'Parent process %s.' % os.getpid() p = Pool() for i in range(5): p.apply_async(long_time_task, args=(i,)) print 'Waiting for all subprocesses done...' p.close() p.join() print 'All subprocesses done.' 执行结果如下: Parent process 669. Waiting for all subprocesses done... Run task 0 (671)... Run task 1 (672)... Run task 2 (673)... Run task 2 (673)... Run task 3 (674)... Task 2 runs 0.14 seconds. Run task 4 (673)... Task 1 runs 0.27 seconds. Task 3 runs 0.86 seconds. Task 0 runs 1.41 seconds. Task 4 runs 1.91 seconds. All subprocesses done. 代码解读: 对 Pool 对象调用 join() 方法会等待所有子进程执行完毕,调用 join() 之前必须先调用 close() ,调用 close() 之 后就不能继续添加新的 Process 了。 请注意输出的结果,task  0 , 1 , 2 , 3 是立刻执行的,而task  4 要等待前面某个task完成后才执行,这是因 为 Pool 的默认大小在我的电脑上是4,因此,最多同时执行4个进程。这是 Pool 有意设计的限制,并不是操作系统 的限制。如果改成: p = Pool(5) 就可以同时跑5个进程。 由于 Pool 的默认大小是CPU的核数,如果你不幸拥有8核CPU,你要提交至少9个子进程才能看到上面的等待效 果。 进程间通信 Process 之间肯定是需要通信的,操作系统提供了很多机制来实现进程间的通信。Python的 multiprocessing 模块 包装了底层的机制,提供了 Queue 、 Pipes 等多种方式来交换数据。 我们以 Queue 为例,在父进程中创建两个子进程,一个往 Queue 里写数据,一个从 Queue 里读数据: from multiprocessing import Process, Queue import os, time, random # 写数据进程执行的代码: def write(q): for value in ['A', 'B', 'C']: print 'Put %s to queue...' % value q.put(value) time.sleep(random.random()) # 读数据进程执行的代码: def read(q): while True: value = q.get(True) print 'Get %s from queue.' % value if __name__=='__main__': # 父进程创建Queue,并传给各个子进程: q = Queue() pw = Process(target=write, args=(q,)) pr = Process(target=read, args=(q,)) pr = Process(target=read, args=(q,)) # 启动子进程pw,写入: pw.start() # 启动子进程pr,读取: pr.start() # 等待pw结束: pw.join() # pr进程里是死循环,无法等待其结束,只能强行终止: pr.terminate() 运行结果如下: Put A to queue... Get A from queue. Put B to queue... Get B from queue. Put C to queue... Get C from queue. 在Unix/Linux下, multiprocessing 模块封装了 fork() 调用,使我们不需要关注 fork() 的细节。由于Windows没 有 fork 调用,因此, multiprocessing 需要“模拟”出 fork 的效果,父进程所有Python对象都必须通过pickle序列化 再传到子进程去,所有,如果 multiprocessing 在Windows下调用失败了,要先考虑是不是pickle失败了。 小结 在Unix/Linux下,可以使用 fork() 调用实现多进程。 要实现跨平台的多进程,可以使用 multiprocessing 模块。 进程间通信是通过 Queue 、 Pipes 等实现的。 您的鼓励是作者写作最大的动力 如果您认为本网站的教程质量不错,读后觉得收获很大,预期工资涨幅能超过30%,不妨小额赞助我一下,让我有 动力继续写出高质量的教程: 多线程 67次阅读 多任务可以由多进程完成,也可以由一个进程内的多线程完成。 我们前面提到了进程是由若干线程组成的,一个进程至少有一个线程。 由于线程是操作系统直接支持的执行单元,因此,高级语言通常都内置多线程的支持,Python也不例外,并且,Pyt hon的线程是真正的Posix Thread,而不是模拟出来的线程。 Python的标准库提供了两个模块: thread 和 threading , thread 是低级模块, threading 是高级模块,对 thread 进行了封装。绝大多数情况下,我们只需要使用 threading 这个高级模块。 启动一个线程就是把一个函数传入并创建 Thread 实例,然后调用 start() 开始执行: import time, threading # 新线程执行的代码: def loop(): print 'thread %s is running...' % threading.current_thread().name n = 0 while n < 5: n = n + 1 print 'thread %s >>> %s' % (threading.current_thread().name, n) time.sleep(1) print 'thread %s ended.' % threading.current_thread().name print 'thread %s is running...' % threading.current_thread().name t = threading.Thread(target=loop, name='LoopThread') t.start() t.join() print 'thread %s ended.' % threading.current_thread().name 执行结果如下: thread MainThread is running... thread LoopThread is running... thread LoopThread >>> 1 thread LoopThread >>> 2 thread LoopThread >>> 3 thread LoopThread >>> 4 thread LoopThread >>> 5 thread LoopThread ended. thread MainThread ended. 由于任何进程默认就会启动一个线程,我们把该线程称为主线程,主线程又可以启动新的线程,Python 的 threading 模块有个 current_thread() 函数,它永远返回当前线程的实例。主线程实例的名字叫 MainThread ,子 线程的名字在创建时指定,我们用 LoopThread 命名子线程。名字仅仅在打印时用来显示,完全没有其他意义,如果 不起名字Python就自动给线程命名为 Thread‐1 , Thread‐2 …… Lock 多线程和多进程最大的不同在于,多进程中,同一个变量,各自有一份拷贝存在于每个进程中,互不影响,而多线 程中,所有变量都由所有线程共享,所以,任何一个变量都可以被任何一个线程修改,因此,线程之间共享数据最 大的危险在于多个线程同时改一个变量,把内容给改乱了。 来看看多个线程同时操作一个变量怎么把内容给改乱了: import time, threading # 假定这是你的银行存款: balance = 0 def change_it(n): # 先存后取,结果应该为0: global balance balance = balance + n balance = balance + n balance = balance - n def run_thread(n): for i in range(100000): change_it(n) t1 = threading.Thread(target=run_thread, args=(5,)) t2 = threading.Thread(target=run_thread, args=(8,)) t1.start() t2.start() t1.join() t2.join() print balance 我们定义了一个共享变量 balance ,初始值为 0 ,并且启动两个线程,先存后取,理论上结果应该为 0 ,但是,由 于线程的调度是由操作系统决定的,当t1、t2交替执行时,只要循环次数足够多, balance 的结果就不一定是 0 了。 原因是因为高级语言的一条语句在CPU执行时是若干条语句,即使一个简单的计算: balance = balance + n 也分两步: 1.  计算 balance + n ,存入临时变量中; 2.  将临时变量的值赋给 balance 。 也就是可以看成: x = balance + n balance = x 由于x是局部变量,两个线程各自都有自己的x,当代码正常执行时: 初始值 balance = 0 t1: x1 = balance + 5 # x1 = 0 + 5 = 5 t1: balance = x1 # balance = 5 t1: x1 = balance - 5 # x1 = 5 - 5 = 0 t1: balance = x1 # balance = 0 t2: x2 = balance + 8 # x2 = 0 + 8 = 8 t2: balance = x2 # balance = 8 t2: x2 = balance - 8 # x2 = 8 - 8 = 0 t2: balance = x2 # balance = 0 结果 balance = 0 但是t1和t2是交替运行的,如果操作系统以下面的顺序执行t1、t2: 初始值 balance = 0 t1: x1 = balance + 5 # x1 = 0 + 5 = 5 t2: x2 = balance + 8 # x2 = 0 + 8 = 8 t2: balance = x2 # balance = 8 t1: balance = x1 # balance = 5 t1: x1 = balance - 5 # x1 = 5 - 5 = 0 t1: balance = x1 # balance = 0 t2: x2 = balance - 5 # x2 = 0 - 5 = -5 t2: balance = x2 # balance = -5 结果 balance = -5 究其原因,是因为修改 balance 需要多条语句,而执行这几条语句时,线程可能中断,从而导致多个线程把同一个 对象的内容改乱了。 两个线程同时一存一取,就可能导致余额不对,你肯定不希望你的银行存款莫名其妙地变成了负数,所以,我们必 须确保一个线程在修改 balance 的时候,别的线程一定不能改。 如果我们要确保 balance 计算正确,就要给 change_it() 上一把锁,当某个线程开始执行 change_it() 时,我们 说,该线程因为获得了锁,因此其他线程不能同时执行 change_it() ,只能等待,直到锁被释放后,获得该锁以后 才能改。由于锁只有一个,无论多少线程,同一时刻最多只有一个线程持有该锁,所以,不会造成修改的冲突。创 建一个锁就是通过 threading.Lock() 来实现: balance = 0 lock = threading.Lock() def run_thread(n): for i in range(100000): # 先要获取锁: lock.acquire() try: # 放心地改吧: change_it(n) finally: # 改完了一定要释放锁: lock.release() 当多个线程同时执行 lock.acquire() 时,只有一个线程能成功地获取锁,然后继续执行代码,其他线程就继续等待 直到获得锁为止。 获得锁的线程用完后一定要释放锁,否则那些苦苦等待锁的线程将永远等待下去,成为死线程。所以我们 用 try...finally 来确保锁一定会被释放。 锁的好处就是确保了某段关键代码只能由一个线程从头到尾完整地执行,坏处当然也很多,首先是阻止了多线程并 发执行,包含锁的某段代码实际上只能以单线程模式执行,效率就大大地下降了。其次,由于可以存在多个锁,不 同的线程持有不同的锁,并试图获取对方持有的锁时,可能会造成死锁,导致多个线程全部挂起,既不能执行,也 无法结束,只能靠操作系统强制终止。 多核CPU 如果你不幸拥有一个多核CPU,你肯定在想,多核应该可以同时执行多个线程。 如果写一个死循环的话,会出现什么情况呢? 打开Mac OS X的Activity Monitor,或者Windows的Task Manager,都可以监控某个进程的CPU使用率。 我们可以监控到一个死循环线程会100%占用一个CPU。 如果有两个死循环线程,在多核CPU中,可以监控到会占用200%的CPU,也就是占用两个CPU核心。 要想把N核CPU的核心全部跑满,就必须启动N个死循环线程。 试试用Python写个死循环: import threading, multiprocessing def loop(): x = 0 while True: x = x ^ 1 for i in range(multiprocessing.cpu_count()): t = threading.Thread(target=loop) t.start() 启动与CPU核心数量相同的N个线程,在4核CPU上可以监控到CPU占用率仅有160%,也就是使用不到两核。 即使启动100个线程,使用率也就170%左右,仍然不到两核。 但是用C、C++或Java来改写相同的死循环,直接可以把全部核心跑满,4核就跑到400%,8核就跑到800%,为什 么Python不行呢? 因为Python的线程虽然是真正的线程,但解释器执行代码时,有一个GIL锁:Global Interpreter Lock,任何Python 线程执行前,必须先获得GIL锁,然后,每执行100条字节码,解释器就自动释放GIL锁,让别的线程有机会执 行。这个GIL全局锁实际上把所有线程的执行代码都给上了锁,所以,多线程在Python中只能交替执行,即使100个 线程跑在100核CPU上,也只能用到1个核。 GIL是Python解释器设计的历史遗留问题,通常我们用的解释器是官方实现的CPython,要真正利用多核,除非重写 一个不带GIL的解释器。 所以,在Python中,可以使用多线程,但不要指望能有效利用多核。如果一定要通过多线程利用多核,那只能通过 C扩展来实现,不过这样就失去了Python简单易用的特点。 不过,也不用过于担心,Python虽然不能利用多线程实现多核任务,但可以通过多进程实现多核任务。多个Python 进程有各自独立的GIL锁,互不影响。 小结 多线程编程,模型复杂,容易发生冲突,必须用锁加以隔离,同时,又要小心死锁的发生。 Python解释器由于设计时有GIL全局锁,导致了多线程无法利用多核。多线程的并发在Python中就是一个美丽的 梦。 您的鼓励是作者写作最大的动力 如果您认为本网站的教程质量不错,读后觉得收获很大,预期工资涨幅能超过30%,不妨小额赞助我一下,让我有 动力继续写出高质量的教程: ThreadLocal 12次阅读 在多线程环境下,每个线程都有自己的数据。一个线程使用自己的局部变量比使用全局变量好,因为局部变量只有 线程自己能看见,不会影响其他线程,而全局变量的修改必须加锁。 但是局部变量也有问题,就是在函数调用的时候,传递起来很麻烦: def process_student(name): std = Student(name) # std是局部变量,但是每个函数都要用它,因此必须传进去: do_task_1(std) do_task_2(std) def do_task_1(std): do_subtask_1(std) do_subtask_2(std) def do_task_2(std): do_subtask_2(std) do_subtask_2(std) 每个函数一层一层调用都这么传参数那还得了?用全局变量?也不行,因为每个线程处理不同的 Student 对象,不 能共享。 如果用一个全局 dict 存放所有的 Student 对象,然后以 thread 自身作为 key 获得线程对应的 Student 对象如何? global_dict = {} def std_thread(name): std = Student(name) # 把std放到全局变量global_dict中: global_dict[threading.current_thread()] = std do_task_1() do_task_2() def do_task_1(): # 不传入std,而是根据当前线程查找: std = global_dict[threading.current_thread()] ... def do_task_2(): # 任何函数都可以查找出当前线程的std变量: std = global_dict[threading.current_thread()] ... 这种方式理论上是可行的,它最大的优点是消除了 std 对象在每层函数中的传递问题,但是,每个函数获取 std 的 代码有点丑。 代码有点丑。 有没有更简单的方式? ThreadLocal 应运而生,不用查找 dict , ThreadLocal 帮你自动做这件事: import threading # 创建全局ThreadLocal对象: local_school = threading.local() def process_student(): print 'Hello, %s (in %s)' % (local_school.student, threading.current_thread().name) def process_thread(name): # 绑定ThreadLocal的student: local_school.student = name process_student() t1 = threading.Thread(target= process_thread, args=('Alice',), name='Thread-A') t2 = threading.Thread(target= process_thread, args=('Bob',), name='Thread-B') t1.start() t2.start() t1.join() t2.join() 执行结果: Hello, Alice (in Thread-A) Hello, Bob (in Thread-B) 全局变量 local_school 就是一个 ThreadLocal 对象,每个 Thread 对它都可以读写 student 属性,但互不影响。你 可以把 local_school 看成全局变量,但每个属性如 local_school.student 都是线程的局部变量,可以任意读写而互 不干扰,也不用管理锁的问题, ThreadLocal 内部会处理。 可以理解为全局变量 local_school 是一个 dict ,不但可以用 local_school.student ,还可以绑定其他变 量,如 local_school.teacher 等等。 ThreadLocal 最常用的地方就是为每个线程绑定一个数据库连接,HTTP请求,用户身份信息等,这样一个线程的所 有调用到的处理函数都可以非常方便地访问这些资源。 您的鼓励是作者写作最大的动力 如果您认为本网站的教程质量不错,读后觉得收获很大,预期工资涨幅能超过30%,不妨小额赞助我一下,让我有 动力继续写出高质量的教程: 进程 vs. 线程 8次阅读 我们介绍了多进程和多线程,这是实现多任务最常用的两种方式。现在,我们来讨论一下这两种方式的优缺点。 首先,要实现多任务,通常我们会设计Master­Worker模式,Master负责分配任务,Worker负责执行任务,因 此,多任务环境下,通常是一个Master,多个Worker。 如果用多进程实现Master­Worker,主进程就是Master,其他进程就是Worker。 如果用多线程实现Master­Worker,主线程就是Master,其他线程就是Worker。 多进程模式最大的优点就是稳定性高,因为一个子进程崩溃了,不会影响主进程和其他子进程。(当然主进程挂了 所有进程就全挂了,但是Master进程只负责分配任务,挂掉的概率低)著名的Apache最早就是采用多进程模式。 多进程模式的缺点是创建进程的代价大,在Unix/Linux系统下,用 fork 调用还行,在Windows下创建进程开销巨 大。另外,操作系统能同时运行的进程数也是有限的,在内存和CPU的限制下,如果有几千个进程同时运行,操作 系统连调度都会成问题。 多线程模式通常比多进程快一点,但是也快不到哪去,而且,多线程模式致命的缺点就是任何一个线程挂掉都可能 直接造成整个进程崩溃,因为所有线程共享进程的内存。在Windows上,如果一个线程执行的代码出了问题,你经 常可以看到这样的提示:“该程序执行了非法操作,即将关闭”,其实往往是某个线程出了问题,但是操作系统会强制 结束整个进程。 在Windows下,多线程的效率比多进程要高,所以微软的IIS服务器默认采用多线程模式。由于多线程存在稳定性的 问题,IIS的稳定性就不如Apache。为了缓解这个问题,IIS和Apache现在又有多进程+多线程的混合模式,真是把 问题越搞越复杂。 线程切换 无论是多进程还是多线程,只要数量一多,效率肯定上不去,为什么呢? 我们打个比方,假设你不幸正在准备中考,每天晚上需要做语文、数学、英语、物理、化学这5科的作业,每项作业 耗时1小时。 如果你先花1小时做语文作业,做完了,再花1小时做数学作业,这样,依次全部做完,一共花5小时,这种方式称为 单任务模型,或者批处理任务模型。 假设你打算切换到多任务模型,可以先做1分钟语文,再切换到数学作业,做1分钟,再切换到英语,以此类推,只 要切换速度足够快,这种方式就和单核CPU执行多任务是一样的了,以幼儿园小朋友的眼光来看,你就正在同时写5 科作业。 但是,切换作业是有代价的,比如从语文切到数学,要先收拾桌子上的语文书本、钢笔(这叫保存现场),然 后,打开数学课本、找出圆规直尺(这叫准备新环境),才能开始做数学作业。操作系统在切换进程或者线程时也 是一样的,它需要先保存当前执行的现场环境(CPU寄存器状态、内存页等),然后,把新任务的执行环境准备 好(恢复上次的寄存器状态,切换内存页等),才能开始执行。这个切换过程虽然很快,但是也需要耗费时间。如 果有几千个任务同时进行,操作系统可能就主要忙着切换任务,根本没有多少时间去执行任务了,这种情况最常见 的就是硬盘狂响,点窗口无反应,系统处于假死状态。 所以,多任务一旦多到一个限度,就会消耗掉系统所有的资源,结果效率急剧下降,所有任务都做不好。 计算密集型 vs. IO密集型 是否采用多任务的第二个考虑是任务的类型。我们可以把任务分为计算密集型和IO密集型。 计算密集型任务的特点是要进行大量的计算,消耗CPU资源,比如计算圆周率、对视频进行高清解码等等,全靠CP U的运算能力。这种计算密集型任务虽然也可以用多任务完成,但是任务越多,花在任务切换的时间就越多,CPU执 行任务的效率就越低,所以,要最高效地利用CPU,计算密集型任务同时进行的数量应当等于CPU的核心数。 行任务的效率就越低,所以,要最高效地利用CPU,计算密集型任务同时进行的数量应当等于CPU的核心数。 计算密集型任务由于主要消耗CPU资源,因此,代码运行效率至关重要。Python这样的脚本语言运行效率很低,完 全不适合计算密集型任务。对于计算密集型任务,最好用C语言编写。 第二种任务的类型是IO密集型,涉及到网络、磁盘IO的任务都是IO密集型任务,这类任务的特点是CPU消耗很 少,任务的大部分时间都在等待IO操作完成(因为IO的速度远远低于CPU和内存的速度)。对于IO密集型任务,任 务越多,CPU效率越高,但也有一个限度。常见的大部分任务都是IO密集型任务,比如Web应用。 IO密集型任务执行期间,99%的时间都花在IO上,花在CPU上的时间很少,因此,用运行速度极快的C语言替换用P ython这样运行速度极低的脚本语言,完全无法提升运行效率。对于IO密集型任务,最合适的语言就是开发效率最 高(代码量最少)的语言,脚本语言是首选,C语言最差。 异步IO 考虑到CPU和IO之间巨大的速度差异,一个任务在执行的过程中大部分时间都在等待IO操作,单进程单线程模型会 导致别的任务无法并行执行,因此,我们才需要多进程模型或者多线程模型来支持多任务并发执行。 现代操作系统对IO操作已经做了巨大的改进,最大的特点就是支持异步IO。如果充分利用操作系统提供的异步IO支 持,就可以用单进程单线程模型来执行多任务,这种全新的模型称为事件驱动模型,Nginx就是支持异步IO的Web服 务器,它在单核CPU上采用单进程模型就可以高效地支持多任务。在多核CPU上,可以运行多个进程(数量与CPU 核心数相同),充分利用多核CPU。由于系统总的进程数量十分有限,因此操作系统调度非常高效。用异步IO编程 模型来实现多任务是一个主要的趋势。 对应到Python语言,单进程的异步编程模型称为协程,有了协程的支持,就可以基于事件驱动编写高效的多任务程 序。我们会在后面讨论如何编写协程。 您的鼓励是作者写作最大的动力 如果您认为本网站的教程质量不错,读后觉得收获很大,预期工资涨幅能超过30%,不妨小额赞助我一下,让我有 动力继续写出高质量的教程: 分布式进程 13次阅读 在Thread和Process中,应当优选Process,因为Process更稳定,而且,Process可以分布到多台机器上,而Threa d最多只能分布到同一台机器的多个CPU上。 Python的 multiprocessing 模块不但支持多进程,其中 managers 子模块还支持把多进程分布到多台机器上。一个服 务进程可以作为调度者,将任务分布到其他多个进程中,依靠网络通信。由于 managers 模块封装很好,不必了解网 络通信的细节,就可以很容易地编写分布式多进程程序。 举个例子:如果我们已经有一个通过 Queue 通信的多进程程序在同一台机器上运行,现在,由于处理任务的进程任 务繁重,希望把发送任务的进程和处理任务的进程分布到两台机器上。怎么用分布式进程实现? 原有的 Queue 可以继续使用,但是,通过 managers 模块把 Queue 通过网络暴露出去,就可以让其他机器的进程访 问 Queue 了。 我们先看服务进程,服务进程负责启动 Queue ,把 Queue 注册到网络上,然后往 Queue 里面写入任务: # taskmanager.py import random, time, Queue from multiprocessing.managers import BaseManager # 发送任务的队列: task_queue = Queue.Queue() # 接收结果的队列: result_queue = Queue.Queue() # 从BaseManager继承的QueueManager: class QueueManager(BaseManager): pass # 把两个Queue都注册到网络上, callable参数关联了Queue对象: QueueManager.register('get_task_queue', callable=lambda: task_queue) QueueManager.register('get_result_queue', callable=lambda: result_queue) # 绑定端口5000, 设置验证码'abc': manager = QueueManager(address=('', 5000), authkey='abc') # 启动Queue: manager.start() # 获得通过网络访问的Queue对象: task = manager.get_task_queue() result = manager.get_result_queue() # 放几个任务进去: for i in range(10): n = random.randint(0, 10000) print('Put task %d...' % n) task.put(n) # 从result队列读取结果: print('Try get results...') for i in range(10): r = result.get(timeout=10) print('Result: %s' % r) # 关闭: manager.shutdown() 请注意,当我们在一台机器上写多进程程序时,创建的 Queue 可以直接拿来用,但是,在分布式多进程环境下,添 加任务到 Queue 不可以直接对原始的 task_queue 进行操作,那样就绕过了 QueueManager 的封装,必须通 过 manager.get_task_queue() 获得的 Queue 接口添加。 然后,在另一台机器上启动任务进程(本机上启动也可以): # taskworker.py import time, sys, Queue from multiprocessing.managers import BaseManager # 创建类似的QueueManager: class QueueManager(BaseManager): pass # 由于这个QueueManager只从网络上获取Queue,所以注册时只提供名字: QueueManager.register('get_task_queue') QueueManager.register('get_result_queue') # 连接到服务器,也就是运行taskmanager.py的机器: server_addr = '127.0.0.1' print('Connect to server %s...' % server_addr) # 端口和验证码注意保持与taskmanager.py设置的完全一致: m = QueueManager(address=(server_addr, 5000), authkey='abc') # 从网络连接: m.connect() # 获取Queue的对象: task = m.get_task_queue() result = m.get_result_queue() # 从task队列取任务,并把结果写入result队列: for i in range(10): try: n = task.get(timeout=1) print('run task %d * %d...' % (n, n)) r = '%d * %d = %d' % (n, n, n*n) time.sleep(1) result.put(r) except Queue.Empty: print('task queue is empty.') # 处理结束: print('worker exit.') 任务进程要通过网络连接到服务进程,所以要指定服务进程的IP。 现在,可以试试分布式进程的工作效果了。先启动 taskmanager.py 服务进程: $ python taskmanager.py Put task 3411... Put task 1605... Put task 1398... Put task 4729... Put task 5300... Put task 7471... Put task 68... Put task 4219... Put task 339... Put task 7866... Try get results... taskmanager进程发送完任务后,开始等待 result 队列的结果。现在启动 taskworker.py 进程: $ python taskworker.py 127.0.0.1 Connect to server 127.0.0.1... run task 3411 * 3411... run task 1605 * 1605... run task 1398 * 1398... run task 4729 * 4729... run task 5300 * 5300... run task 7471 * 7471... run task 68 * 68... run task 4219 * 4219... run task 339 * 339... run task 7866 * 7866... run task 7866 * 7866... worker exit. taskworker进程结束,在taskmanager进程中会继续打印出结果: Result: 3411 * 3411 = 11634921 Result: 1605 * 1605 = 2576025 Result: 1398 * 1398 = 1954404 Result: 4729 * 4729 = 22363441 Result: 5300 * 5300 = 28090000 Result: 7471 * 7471 = 55815841 Result: 68 * 68 = 4624 Result: 4219 * 4219 = 17799961 Result: 339 * 339 = 114921 Result: 7866 * 7866 = 61873956 这个简单的Manager/Worker模型有什么用?其实这就是一个简单但真正的分布式计算,把代码稍加改造,启动多个 worker,就可以把任务分布到几台甚至几十台机器上,比如把计算 n*n 的代码换成发送邮件,就实现了邮件队列的 异步发送。 Queue对象存储在哪?注意到 taskworker.py 中根本没有创建Queue的代码,所以,Queue对象存储 在 taskmanager.py 进程中: 而 Queue 之所以能通过网络访问,就是通过 QueueManager 实现的。由于 QueueManager 管理的不止一个 Queue ,所 以,要给每个 Queue 的网络调用接口起个名字,比如 get_task_queue 。 authkey 有什么用?这是为了保证两台机器正常通信,不被其他机器恶意干扰。如果 taskworker.py 的 authkey 和 taskmanager.py 的 authkey 不一致,肯定连接不上。 小结 Python的分布式进程接口简单,封装良好,适合需要把繁重任务分布到多台机器的环境下。 注意Queue的作用是用来传递任务和接收结果,每个任务的描述数据量要尽量小。比如发送一个处理日志文件的任 注意Queue的作用是用来传递任务和接收结果,每个任务的描述数据量要尽量小。比如发送一个处理日志文件的任 务,就不要发送几百兆的日志文件本身,而是发送日志文件存放的完整路径,由Worker进程再去共享的磁盘上读取 文件。 您的鼓励是作者写作最大的动力 如果您认为本网站的教程质量不错,读后觉得收获很大,预期工资涨幅能超过30%,不妨小额赞助我一下,让我有 动力继续写出高质量的教程: 正则表达式 55次阅读 字符串是编程时涉及到的最多的一种数据结构,对字符串进行操作的需求几乎无处不在。比如判断一个字符串是否 是合法的Email地址,虽然可以编程提取 @ 前后的子串,再分别判断是否是单词和域名,但这样做不但麻烦,而且代 码难以复用。 正则表达式是一种用来匹配字符串的强有力的武器。它的设计思想是用一种描述性的语言来给字符串定义一个规 则,凡是符合规则的字符串,我们就认为它“匹配”了,否则,该字符串就是不合法的。 所以我们判断一个字符串是否是合法的Email的方法是: 1.  创建一个匹配Email的正则表达式; 2.  用该正则表达式去匹配用户的输入来判断是否合法。 因为正则表达式也是用字符串表示的,所以,我们要首先了解如何用字符来描述字符。 在正则表达式中,如果直接给出字符,就是精确匹配。用 \d 可以匹配一个数字, \w 可以匹配一个字母或数字,所 以: '00\d' 可以匹配 '007' ,但无法匹配 '00A' ; '\d\d\d' 可以匹配 '010' ; '\w\w\d' 可以匹配 'py3' ; . 可以匹配任意字符,所以: 'py.' 可以匹配 'pyc' 、 'pyo' 、 'py!' 等等。 要匹配变长的字符,在正则表达式中,用 * 表示任意个字符(包括0个),用 + 表示至少一个字符,用 ? 表示0个或 1个字符,用 {n} 表示n个字符,用 {n,m} 表示n­m个字符: 来看一个复杂的例子: \d{3}\s+\d{3,8} 。 我们来从左到右解读一下: 1.  \d{3} 表示匹配3个数字,例如 '010' ; 2.  \s 可以匹配一个空格(也包括Tab等空白符),所以 \s+ 表示至少有一个空格,例如匹配 ' ' , ' ' 等; 3.  \d{3,8} 表示3­8个数字,例如 '1234567' 。 综合起来,上面的正则表达式可以匹配以任意个空格隔开的带区号的电话号码。 如果要匹配 '010‐12345' 这样的号码呢?由于 '‐' 是特殊字符,在正则表达式中,要用 '\' 转义,所以,上面的正 则是 \d{3}\‐\d{3,8} 。 但是,仍然无法匹配 '010 ‐ 12345' ,因为带有空格。所以我们需要更复杂的匹配方式。 进阶 要做更精确地匹配,可以用 [] 表示范围,比如: [0‐9a‐zA‐Z\_] 可以匹配一个数字、字母或者下划线; [0‐9a‐zA‐Z\_]+ 可以匹配至少由一个数字、字母或者下划线组成的字符串,比 如 'a100' , '0_Z' , 'Py3000' 等等; [a‐zA‐Z\_][0‐9a‐zA‐Z\_]* 可以匹配由字母或下划线开头,后接任意个由一个数字、字母或者下划线组成的字 符串,也就是Python合法的变量; [a‐zA‐Z\_][0‐9a‐zA‐Z\_]{0, 19} 更精确地限制了变量的长度是1­20个字符(前面1个字符+后面最多19个字 符)。 A|B 可以匹配A或B,所以 [P|p]ython 可以匹配 'Python' 或者 'python' 。 ^ 表示行的开头, ^\d 表示必须以数字开头。 $ 表示行的结束, \d$ 表示必须以数字结束。 你可能注意到了, py 也可以匹配 'python' ,但是加上 ^py$ 就变成了整行匹配,就只能匹配 'py' 了。 re模块 有了准备知识,我们就可以在Python中使用正则表达式了。Python提供 re 模块,包含所有正则表达式的功能。由 于Python的字符串本身也用 \ 转义,所以要特别注意: s = 'ABC\\-001' # Python的字符串 # 对应的正则表达式字符串变成: # 'ABC\-001' 因此我们强烈建议使用Python的 r 前缀,就不用考虑转义的问题了: s = r'ABC\-001' # Python的字符串 # 对应的正则表达式字符串不变: # 'ABC\-001' 先看看如何判断正则表达式是否匹配: >>> import re >>> re.match(r'^\d{3}\-\d{3,8}$', '010-12345') <_sre.SRE_Match object at 0x1026e18b8> >>> re.match(r'^\d{3}\-\d{3,8}$', '010 12345') >>> re.match(r'^\d{3}\-\d{3,8}$', '010 12345') >>> match() 方法判断是否匹配,如果匹配成功,返回一个 Match 对象,否则返回 None 。常见的判断方法就是: test = '用户输入的字符串' if re.match(r'正则表达式', test): print 'ok' else: print 'failed' 切分字符串 用正则表达式切分字符串比用固定的字符更灵活,请看正常的切分代码: >>> 'a b c'.split(' ') ['a', 'b', '', '', 'c'] 嗯,无法识别连续的空格,用正则表达式试试: >>> re.split(r'\s+', 'a b c') ['a', 'b', 'c'] 无论多少个空格都可以正常分割。加入 , 试试: >>> re.split(r'[\s\,]+', 'a,b, c d') ['a', 'b', 'c', 'd'] 再加入 ; 试试: >>> re.split(r'[\s\,\;]+', 'a,b;; c d') ['a', 'b', 'c', 'd'] 如果用户输入了一组标签,下次记得用正则表达式来把不规范的输入转化成正确的数组。 分组 除了简单地判断是否匹配之外,正则表达式还有提取子串的强大功能。用 () 表示的就是要提取的分组(Grou p)。比如: ^(\d{3})‐(\d{3,8})$ 分别定义了两个组,可以直接从匹配的字符串中提取出区号和本地号码: >>> m = re.match(r'^(\d{3})-(\d{3,8})$', '010-12345') >>> m <_sre.SRE_Match object at 0x1026fb3e8> >>> m.group(0) '010-12345' >>> m.group(1) '010' >>> m.group(2) >>> m.group(2) '12345' 如果正则表达式中定义了组,就可以在 Match 对象上用 group() 方法提取出子串来。 注意到 group(0) 永远是原始字符串, group(1) 、 group(2) ……表示第1、2、……个子串。 提取子串非常有用。来看一个更凶残的例子: >>> t = '19:05:30' >>> m = re.match(r'^(0[0-9]|1[0-9]|2[0-3]|[0-9])\:(0[0-9]|1[0-9]|2[0-9]|3[0-9]|4[0-9]|5[0-9]|[0-9])\:(0[0-9]|1[0- 9]|2[0-9]|3[0-9]|4[0-9]|5[0-9]|[0-9])$', t) >>> m.groups() ('19', '05', '30') 这个正则表达式可以直接识别合法的时间。但是有些时候,用正则表达式也无法做到完全验证,比如识别日期: '^(0[1-9]|1[0-2]|[0-9])-(0[1-9]|1[0-9]|2[0-9]|3[0-1]|[0-9])$' 对于 '2‐30' , '4‐31' 这样的非法日期,用正则还是识别不了,或者说写出来非常困难,这时就需要程序配合识别 了。 贪婪匹配 最后需要特别指出的是,正则匹配默认是贪婪匹配,也就是匹配尽可能多的字符。举例如下,匹配出数字后面 的 0 : >>> re.match(r'^(\d+)(0*)$', '102300').groups() ('102300', '') 由于 \d+ 采用贪婪匹配,直接把后面的 0 全部匹配了,结果 0* 只能匹配空字符串了。 必须让 \d+ 采用非贪婪匹配(也就是尽可能少匹配),才能把后面的 0 匹配出来,加个 ? 就可以让 \d+ 采用非贪婪 匹配: >>> re.match(r'^(\d+?)(0*)$', '102300').groups() ('1023', '00') 编译 当我们在Python中使用正则表达式时,re模块内部会干两件事情: 1.  编译正则表达式,如果正则表达式的字符串本身不合法,会报错; 2.  用编译后的正则表达式去匹配字符串。 如果一个正则表达式要重复使用几千次,出于效率的考虑,我们可以预编译该正则表达式,接下来重复使用时就不 需要编译这个步骤了,直接匹配: >>> import re # 编译: # 编译: >>> re_telephone = re.compile(r'^(\d{3})-(\d{3,8})$') # 使用: >>> re_telephone.match('010-12345').groups() ('010', '12345') >>> re_telephone.match('010-8086').groups() ('010', '8086') 编译后生成Regular Expression对象,由于该对象自己包含了正则表达式,所以调用对应的方法时不用给出正则字 符串。 小结 正则表达式非常强大,要在短短的一节里讲完是不可能的。要讲清楚正则的所有内容,可以写一本厚厚的书了。如 果你经常遇到正则表达式的问题,你可能需要一本正则表达式的参考书。 请尝试写一个验证Email地址的正则表达式。版本一应该可以验证出类似的Email: someone@gmail.com bill.gates@microsoft.com 版本二可以验证并提取出带名字的Email地址: tom@voyager.org 您的鼓励是作者写作最大的动力 如果您认为本网站的教程质量不错,读后觉得收获很大,预期工资涨幅能超过30%,不妨小额赞助我一下,让我有 动力继续写出高质量的教程: 常用内建模块 101次阅读 Python之所以自称“batteries included”,就是因为内置了许多非常有用的模块,无需额外安装和配置,即可直接使 用。 本章将介绍一些常用的内建模块。 您的鼓励是作者写作最大的动力 如果您认为本网站的教程质量不错,读后觉得收获很大,预期工资涨幅能超过30%,不妨小额赞助我一下,让我有 动力继续写出高质量的教程: collections 21次阅读 collections是Python内建的一个集合模块,提供了许多有用的集合类。 namedtuple 我们知道 tuple 可以表示不变集合,例如,一个点的二维坐标就可以表示成: >>> p = (1, 2) 但是,看到 (1, 2) ,很难看出这个 tuple 是用来表示一个坐标的。 定义一个class又小题大做了,这时, namedtuple 就派上了用场: >>> from collections import namedtuple >>> Point = namedtuple('Point', ['x', 'y']) >>> p = Point(1, 2) >>> p.x 1 >>> p.y 2 namedtuple 是一个函数,它用来创建一个自定义的 tuple 对象,并且规定了 tuple 元素的个数,并可以用属性而不 是索引来引用 tuple 的某个元素。 这样一来,我们用 namedtuple 可以很方便地定义一种数据类型,它具备tuple的不变性,又可以根据属性来引用,使 用十分方便。 可以验证创建的 Point 对象是 tuple 的一种子类: >>> isinstance(p, Point) True >>> isinstance(p, tuple) True 类似的,如果要用坐标和半径表示一个圆,也可以用 namedtuple 定义: # namedtuple('名称', [属性list]): Circle = namedtuple('Circle', ['x', 'y', 'r']) deque 使用 list 存储数据时,按索引访问元素很快,但是插入和删除元素就很慢了,因为 list 是线性存储,数据量大的 时候,插入和删除效率很低。 deque是为了高效实现插入和删除操作的双向列表,适合用于队列和栈: >>> from collections import deque >>> q = deque(['a', 'b', 'c']) >>> q.append('x') >>> q.appendleft('y') >>> q.appendleft('y') >>> q deque(['y', 'a', 'b', 'c', 'x']) deque 除了实现list的 append() 和 pop() 外,还支持 appendleft() 和 popleft() ,这样就可以非常高效地往头部添 加或删除元素。 defaultdict 使用 dict 时,如果引用的Key不存在,就会抛出 KeyError 。如果希望key不存在时,返回一个默认值,就可以 用 defaultdict : >>> from collections import defaultdict >>> dd = defaultdict(lambda: 'N/A') >>> dd['key1'] = 'abc' >>> dd['key1'] # key1存在 'abc' >>> dd['key2'] # key2不存在,返回默认值 'N/A' 注意默认值是调用函数返回的,而函数在创建 defaultdict 对象时传入。 除了在Key不存在时返回默认值, defaultdict 的其他行为跟 dict 是完全一样的。 OrderedDict 使用 dict 时,Key是无序的。在对 dict 做迭代时,我们无法确定Key的顺序。 如果要保持Key的顺序,可以用 OrderedDict : >>> from collections import OrderedDict >>> d = dict([('a', 1), ('b', 2), ('c', 3)]) >>> d # dict的Key是无序的 {'a': 1, 'c': 3, 'b': 2} >>> od = OrderedDict([('a', 1), ('b', 2), ('c', 3)]) >>> od # OrderedDict的Key是有序的 OrderedDict([('a', 1), ('b', 2), ('c', 3)]) 注意, OrderedDict 的Key会按照插入的顺序排列,不是Key本身排序: >>> od = OrderedDict() >>> od['z'] = 1 >>> od['y'] = 2 >>> od['x'] = 3 >>> od.keys() # 按照插入的Key的顺序返回 ['z', 'y', 'x'] OrderedDict 可以实现一个FIFO(先进先出)的dict,当容量超出限制时,先删除最早添加的Key: from collections import OrderedDict class LastUpdatedOrderedDict(OrderedDict): class LastUpdatedOrderedDict(OrderedDict): def __init__(self, capacity): super(LastUpdatedOrderedDict, self).__init__() self._capacity = capacity def __setitem__(self, key, value): containsKey = 1 if key in self else 0 if len(self) - containsKey >= self._capacity: last = self.popitem(last=False) print 'remove:', last if containsKey: del self[key] print 'set:', (key, value) else: print 'add:', (key, value) OrderedDict.__setitem__(self, key, value) Counter Counter 是一个简单的计数器,例如,统计字符出现的个数: >>> from collections import Counter >>> c = Counter() >>> for ch in 'programming': ... c[ch] = c[ch] + 1 ... >>> c Counter({'g': 2, 'm': 2, 'r': 2, 'a': 1, 'i': 1, 'o': 1, 'n': 1, 'p': 1}) Counter 实际上也是 dict 的一个子类,上面的结果可以看出,字符 'g' 、 'm' 、 'r' 各出现了两次,其他字符各 出现了一次。 小结 collections 模块提供了一些有用的集合类,可以根据需要选用。 您的鼓励是作者写作最大的动力 如果您认为本网站的教程质量不错,读后觉得收获很大,预期工资涨幅能超过30%,不妨小额赞助我一下,让我有 动力继续写出高质量的教程: base64 19次阅读 Base64是一种用64个字符来表示任意二进制数据的方法。 用记事本打开 exe 、 jpg 、 pdf 这些文件时,我们都会看到一大堆乱码,因为二进制文件包含很多无法显示和打印 的字符,所以,如果要让记事本这样的文本处理软件能处理二进制数据,就需要一个二进制到字符串的转换方法。B ase64是一种最常见的二进制编码方法。 ase64是一种最常见的二进制编码方法。 Base64的原理很简单,首先,准备一个包含64个字符的数组: ['A', 'B', 'C', ... 'a', 'b', 'c', ... '0', '1', ... '+', '/'] 然后,对二进制数据进行处理,每3个字节一组,一共是 3x8=24 bit,划为4组,每组正好6个bit: 这样我们得到4个数字作为索引,然后查表,获得相应的4个字符,就是编码后的字符串。 所以,Base64编码会把3字节的二进制数据编码为4字节的文本数据,长度增加33%,好处是编码后的文本数据可以 在邮件正文、网页等直接显示。 如果要编码的二进制数据不是3的倍数,最后会剩下1个或2个字节怎么办?Base64用 \x00 字节在末尾补足后,再在 编码的末尾加上1个或2个 = 号,表示补了多少字节,解码的时候,会自动去掉。 Python内置的 base64 可以直接进行base64的编解码: >>> import base64 >>> base64.b64encode('binary\x00string') 'YmluYXJ5AHN0cmluZw==' >>> base64.b64decode('YmluYXJ5AHN0cmluZw==') 'binary\x00string' 由于标准的Base64编码后可能出现字符 + 和 / ,在URL中就不能直接作为参数,所以又有一种"url safe"的base64 编码,其实就是把字符 + 和 / 分别变成 ‐ 和 _ : >>> base64.b64encode('i\xb7\x1d\xfb\xef\xff') 'abcd++//' >>> base64.urlsafe_b64encode('i\xb7\x1d\xfb\xef\xff') 'abcd--__' >>> base64.urlsafe_b64decode('abcd--__') 'i\xb7\x1d\xfb\xef\xff' 还可以自己定义64个字符的排列顺序,这样就可以自定义Base64编码,不过,通常情况下完全没有必要。 Base64是一种通过查表的编码方法,不能用于加密,即使使用自定义的编码表也不行。 Base64适用于小段内容的编码,比如数字证书签名、Cookie的内容等。 由于 = 字符也可能出现在Base64编码中,但 = 用在URL、Cookie里面会造成歧义,所以,很多Base64编码后会 把 = 去掉: # 标准Base64: 'abcd' -> 'YWJjZA==' # 自动去掉=: 'abcd' -> 'YWJjZA' 去掉 = 后怎么解码呢?因为Base64是把3个字节变为4个字节,所以,Base64编码的长度永远是4的倍数,因此,需 要加上 = 把Base64字符串的长度变为4的倍数,就可以正常解码了。 请写一个能处理去掉 = 的base64解码函数: >>> base64.b64decode('YWJjZA==') 'abcd' >>> base64.b64decode('YWJjZA') Traceback (most recent call last): ... TypeError: Incorrect padding >>> safe_b64decode('YWJjZA') 'abcd' 小结 Base64是一种任意二进制到文本字符串的编码方法,常用于在URL、Cookie、网页中传输少量二进制数据。 您的鼓励是作者写作最大的动力 如果您认为本网站的教程质量不错,读后觉得收获很大,预期工资涨幅能超过30%,不妨小额赞助我一下,让我有 动力继续写出高质量的教程: struct 13次阅读 准确地讲,Python没有专门处理字节的数据类型。但由于 str 既是字符串,又可以表示字节,所以,字节数组=st r。而在C语言中,我们可以很方便地用struct、union来处理字节,以及字节和int,float的转换。 在Python中,比方说要把一个32位无符号整数变成字节,也就是4个长度的str,你得配合位运算符这么写: >>> n = 10240099 >>> b1 = chr((n & 0xff000000) >> 24) >>> b2 = chr((n & 0xff0000) >> 16) >>> b3 = chr((n & 0xff00) >> 8) >>> b4 = chr(n & 0xff) >>> s = b1 + b2 + b3 + b4 >>> s '\x00\x9c@c' 非常麻烦。如果换成浮点数就无能为力了。 好在Python提供了一个 struct 模块来解决 str 和其他二进制数据类型的转换。 struct 的 pack 函数把任意数据类型变成字符串: struct 的 pack 函数把任意数据类型变成字符串: >>> import struct >>> struct.pack('>I', 10240099) '\x00\x9c@c' pack 的第一个参数是处理指令, '>I' 的意思是: > 表示字节顺序是big­endian,也就是网络序, I 表示4字节无符号整数。 后面的参数个数要和处理指令一致。 unpack 把 str 变成相应的数据类型: >>> struct.unpack('>IH', '\xf0\xf0\xf0\xf0\x80\x80') (4042322160, 32896) 根据 >IH 的说明,后面的 str 依次变为 I :4字节无符号整数和 H :2字节无符号整数。 所以,尽管Python不适合编写底层操作字节流的代码,但在对性能要求不高的地方,利用 struct 就方便多了。 struct 模块定义的数据类型可以参考Python官方文档: https://docs.python.org/2/library/struct.html#format­characters Windows的位图文件(.bmp)是一种非常简单的文件格式,我们来用 struct 分析一下。 首先找一个bmp文件,没有的话用“画图”画一个。 读入前30个字节来分析: >>> s = '\x42\x4d\x38\x8c\x0a\x00\x00\x00\x00\x00\x36\x00\x00\x00\x28\x00\x00\x00\x80\x02\x00\x00\x68\x01\x00\x0 0\x01\x00\x18\x00' BMP格式采用小端方式存储数据,文件头的结构按顺序如下: 两个字节: 'BM' 表示Windows位图, 'BA' 表示OS/2位图; 一个4字节整数:表示位图大小; 一个4字节整数:保留位,始终为0; 一个4字节整数:实际图像的偏移量; 一个4字节整数:Header的字节数; 一个4字节整数:图像宽度; 一个4字节整数:图像高度; 一个2字节整数:始终为1; 一个2字节整数:颜色数。 所以,组合起来用 unpack 读取: >>> struct.unpack('>> import itertools >>> natuals = itertools.count(1) >>> for n in natuals: ... print n ... 1 2 3 ... 因为 count() 会创建一个无限的迭代器,所以上述代码会打印出自然数序列,根本停不下来,只能按 Ctrl+C 退出。 cycle() 会把传入的一个序列无限重复下去: >>> import itertools >>> cs = itertools.cycle('ABC') # 注意字符串也是序列的一种 >>> for c in cs: ... print c ... 'A' 'B' 'C' 'A' 'B' 'C' ... 同样停不下来。 repeat() 负责把一个元素无限重复下去,不过如果提供第二个参数就可以限定重复次数: repeat() 负责把一个元素无限重复下去,不过如果提供第二个参数就可以限定重复次数: >>> ns = itertools.repeat('A', 10) >>> for n in ns: ... print n ... 打印10次'A' 无限序列只有在 for 迭代时才会无限地迭代下去,如果只是创建了一个迭代对象,它不会事先把无限个元素生成出 来,事实上也不可能在内存中创建无限多个元素。 无限序列虽然可以无限迭代下去,但是通常我们会通过 takewhile() 等函数根据条件判断来截取出一个有限的序 列: >>> natuals = itertools.count(1) >>> ns = itertools.takewhile(lambda x: x <= 10, natuals) >>> for n in ns: ... print n ... 打印出1到10 itertools 提供的几个迭代器操作函数更加有用: chain() chain() 可以把一组迭代对象串联起来,形成一个更大的迭代器: for c in chain('ABC', 'XYZ'): print c # 迭代效果:'A' 'B' 'C' 'X' 'Y' 'Z' groupby() groupby() 把迭代器中相邻的重复元素挑出来放在一起: >>> for key, group in itertools.groupby('AAABBBCCAAA'): ... print key, list(group) # 为什么这里要用list()函数呢? ... A ['A', 'A', 'A'] B ['B', 'B', 'B'] C ['C', 'C'] A ['A', 'A', 'A'] 实际上挑选规则是通过函数完成的,只要作用于函数的两个元素返回的值相等,这两个元素就被认为是在一组 的,而函数返回值作为组的key。如果我们要忽略大小写分组,就可以让元素 'A' 和 'a' 都返回相同的key: >>> for key, group in itertools.groupby('AaaBBbcCAAa', lambda c: c.upper()): ... print key, list(group) ... A ['A', 'a', 'a'] B ['B', 'B', 'b'] B ['B', 'B', 'b'] C ['c', 'C'] A ['A', 'A', 'a'] imap() imap() 和 map() 的区别在于, imap() 可以作用于无穷序列,并且,如果两个序列的长度不一致,以短的那个为 准。 >>> for x in itertools.imap(lambda x, y: x * y, [10, 20, 30], itertools.count(1)): ... print x ... 10 40 90 注意 imap() 返回一个迭代对象,而 map() 返回list。当你调用 map() 时,已经计算完毕: >>> r = map(lambda x: x*x, [1, 2, 3]) >>> r # r已经计算出来了 [1, 4, 9] 当你调用 imap() 时,并没有进行任何计算: >>> r = itertools.imap(lambda x: x*x, [1, 2, 3]) >>> r # r只是一个迭代对象 必须用 for 循环对 r 进行迭代,才会在每次循环过程中计算出下一个元素: >>> for x in r: ... print x ... 1 4 9 这说明 imap() 实现了“惰性计算”,也就是在需要获得结果的时候才计算。类似 imap() 这样能够实现惰性计算的函 数就可以处理无限序列: >>> r = itertools.imap(lambda x: x*x, itertools.count(1)) >>> for n in itertools.takewhile(lambda x: x<100, r): ... print n ... 结果是什么? 如果把 imap() 换成 map() 去处理无限序列会有什么结果? >>> r = map(lambda x: x*x, itertools.count(1)) 结果是什么? ifilter() 不用多说了, ifilter() 就是 filter() 的惰性实现。 小结 itertools 模块提供的全部是处理迭代功能的函数,它们的返回值不是list,而是迭代对象,只有用 for 循环迭代的 时候才真正计算。 您的鼓励是作者写作最大的动力 如果您认为本网站的教程质量不错,读后觉得收获很大,预期工资涨幅能超过30%,不妨小额赞助我一下,让我有 动力继续写出高质量的教程: XML 4次阅读 XML虽然比JSON复杂,在Web中应用也不如以前多了,不过仍有很多地方在用,所以,有必要了解如何操作XM L。 DOM vs SAX 操作XML有两种方法:DOM和SAX。DOM会把整个XML读入内存,解析为树,因此占用内存大,解析慢,优点是可 以任意遍历树的节点。SAX是流模式,边读边解析,占用内存小,解析快,缺点是我们需要自己处理事件。 正常情况下,优先考虑SAX,因为DOM实在太占内存。 在Python中使用SAX解析XML非常简洁,通常我们关心的事件是 start_element , end_element 和 char_data ,准 备好这3个函数,然后就可以解析xml了。 举个例子,当SAX解析器读到一个节点时: python 会产生3个事件: 1.  start_element事件,在读取 时; 2.  char_data事件,在读取 python 时; 3.  end_element事件,在读取 时。 用代码实验一下: from xml.parsers.expat import ParserCreate class DefaultSaxHandler(object): def start_element(self, name, attrs): print('sax:start_element: %s, attrs: %s' % (name, str(attrs))) def end_element(self, name): print('sax:end_element: %s' % name) def char_data(self, text): print('sax:char_data: %s' % text) xml = r'''
  1. Python
  2. Ruby
''' handler = DefaultSaxHandler() parser = ParserCreate() parser.returns_unicode = True parser.StartElementHandler = handler.start_element parser.EndElementHandler = handler.end_element parser.CharacterDataHandler = handler.char_data parser.Parse(xml) 当设置 returns_unicode 为True时,返回的所有element名称和char_data都是unicode,处理国际化更方便。 需要注意的是读取一大段字符串时, CharacterDataHandler 可能被多次调用,所以需要自己保存起 来,在 EndElementHandler 里面再合并。 除了解析XML外,如何生成XML呢?99%的情况下需要生成的XML结构都是非常简单的,因此,最简单也是最有效 的生成XML的方法是拼接字符串: L = [] L.append(r'') L.append(r'') L.append(encode('some & data')) L.append(r'') return ''.join(L) 如果要生成复杂的XML呢?建议你不要用XML,改成JSON。 小结 解析XML时,注意找出自己感兴趣的节点,响应事件时,把节点数据保存起来。解析完毕后,就可以处理数据。 练习一下解析Yahoo的XML格式的天气预报,获取当天和最近几天的天气: http://weather.yahooapis.com/forecastrss?u=c&w=2151330 参数 w 是城市代码,要查询某个城市代码,可以在weather.yahoo.com搜索城市,浏览器地址栏的URL就包含城市 代码。 您的鼓励是作者写作最大的动力 您的鼓励是作者写作最大的动力 如果您认为本网站的教程质量不错,读后觉得收获很大,预期工资涨幅能超过30%,不妨小额赞助我一下,让我有 动力继续写出高质量的教程: HTMLParser 14次阅读 如果我们要编写一个搜索引擎,第一步是用爬虫把目标网站的页面抓下来,第二步就是解析该HTML页面,看看里面 的内容到底是新闻、图片还是视频。 假设第一步已经完成了,第二步应该如何解析HTML呢? HTML本质上是XML的子集,但是HTML的语法没有XML那么严格,所以不能用标准的DOM或SAX来解析HTML。 好在Python提供了HTMLParser来非常方便地解析HTML,只需简单几行代码: from HTMLParser import HTMLParser from htmlentitydefs import name2codepoint class MyHTMLParser(HTMLParser): def handle_starttag(self, tag, attrs): print('<%s>' % tag) def handle_endtag(self, tag): print('' % tag) def handle_startendtag(self, tag, attrs): print('<%s/>' % tag) def handle_data(self, data): print('data') def handle_comment(self, data): print('') def handle_entityref(self, name): print('&%s;' % name) def handle_charref(self, name): print('&#%s;' % name) parser = MyHTMLParser() parser.feed('

Some html tutorial...
END

') feed() 方法可以多次调用,也就是不一定一次把整个HTML字符串都塞进去,可以一部分一部分塞进去。 特殊字符有两种,一种是英文表示的   ,一种是数字表示的 Ӓ ,这两种字符都可以通过Parser解析出 来。 小结 小结 找一个网页,例如https://www.python.org/events/python­events/,用浏览器查看源码并复制,然后尝试解析一下H TML,输出Python官网发布的会议时间、名称和地点。 您的鼓励是作者写作最大的动力 如果您认为本网站的教程质量不错,读后觉得收获很大,预期工资涨幅能超过30%,不妨小额赞助我一下,让我有 动力继续写出高质量的教程: 常用第三方模块 100次阅读 除了内建的模块外,Python还有大量的第三方模块。 基本上,所有的第三方模块都会在PyPI ­ the Python Package Index上注册,只要找到对应的模块名字,即可用eas y_install或者pip安装。 本章介绍常用的第三方模块。 您的鼓励是作者写作最大的动力 如果您认为本网站的教程质量不错,读后觉得收获很大,预期工资涨幅能超过30%,不妨小额赞助我一下,让我有 动力继续写出高质量的教程: PIL 28次阅读 PIL:Python Imaging Library,已经是Python平台事实上的图像处理标准库了。PIL功能非常强大,但API却非常简 单易用。 安装PIL 在Debian/Ubuntu Linux下直接通过apt安装: $ sudo apt-get install python-imaging Mac和其他版本的Linux可以直接使用easy_install或pip安装,安装前需要把编译环境装好: $ sudo easy_install PIL 如果安装失败,根据提示先把缺失的包(比如openjpeg)装上。 Windows平台就去PIL官方网站下载exe安装包。 操作图像 来看看最常见的图像缩放操作,只需三四行代码: import Image # 打开一个jpg图像文件,注意路径要改成你自己的: im = Image.open('/Users/michael/test.jpg') # 获得图像尺寸: w, h = im.size # 缩放到50%: im.thumbnail((w//2, h//2)) # 把缩放后的图像用jpeg格式保存: im.save('/Users/michael/thumbnail.jpg', 'jpeg') 其他功能如切片、旋转、滤镜、输出文字、调色板等一应俱全。 比如,模糊效果也只需几行代码: import Image, ImageFilter im = Image.open('/Users/michael/test.jpg') im2 = im.filter(ImageFilter.BLUR) im2.save('/Users/michael/blur.jpg', 'jpeg') 效果如下: PIL的 ImageDraw 提供了一系列绘图方法,让我们可以直接绘图。比如要生成字母验证码图片: import Image, ImageDraw, ImageFont, ImageFilter import random # 随机字母: def rndChar(): return chr(random.randint(65, 90)) # 随机颜色1: def rndColor(): return (random.randint(64, 255), random.randint(64, 255), random.randint(64, 255)) # 随机颜色2: def rndColor2(): return (random.randint(32, 127), random.randint(32, 127), random.randint(32, 127)) # 240 x 60: width = 60 * 4 height = 60 image = Image.new('RGB', (width, height), (255, 255, 255)) # 创建Font对象: font = ImageFont.truetype('Arial.ttf', 36) # 创建Draw对象: draw = ImageDraw.Draw(image) # 填充每个像素: for x in range(width): for y in range(height): draw.point((x, y), fill=rndColor()) # 输出文字: for t in range(4): draw.text((60 * t + 10, 10), rndChar(), font=font, fill=rndColor2()) # 模糊: image = image.filter(ImageFilter.BLUR) image.save('code.jpg', 'jpeg'); 我们用随机颜色填充背景,再画上文字,最后对图像进行模糊,得到验证码图片如下: 如果运行的时候报错: IOError: cannot open resource 这是因为PIL无法定位到字体文件的位置,可以根据操作系统提供绝对路径,比如: '/Library/Fonts/Arial.ttf' 要详细了解PIL的强大功能,请请参考PIL官方文档: http://effbot.org/imagingbook/ 您的鼓励是作者写作最大的动力 如果您认为本网站的教程质量不错,读后觉得收获很大,预期工资涨幅能超过30%,不妨小额赞助我一下,让我有 动力继续写出高质量的教程: 图形界面 77次阅读 Python支持多种图形界面的第三方库,包括: Tk wxWidgets Qt GTK 等等。 但是Python自带的库是支持Tk的Tkinter,使用Tkinter,无需安装任何包,就可以直接使用。本章简单介绍如何使用 Tkinter进行GUI编程。 Tkinter 我们来梳理一下概念: 我们编写的Python代码会调用内置的Tkinter,Tkinter封装了访问Tk的接口; Tk是一个图形库,支持多个操作系统,使用Tcl语言开发; Tk会调用操作系统提供的本地GUI接口,完成最终的GUI。 所以,我们的代码只需要调用Tkinter提供的接口就可以了。 第一个GUI程序 使用Tkinter十分简单,我们来编写一个GUI版本的“Hello, world!”。 第一步是导入Tkinter包的所有内容: from Tkinter import * 第二步是从 Frame 派生一个 Application 类,这是所有Widget的父容器: class Application(Frame): def __init__(self, master=None): Frame.__init__(self, master) self.pack() self.createWidgets() def createWidgets(self): self.helloLabel = Label(self, text='Hello, world!') self.helloLabel.pack() self.quitButton = Button(self, text='Quit', command=self.quit) self.quitButton.pack() 在GUI中,每个Button、Label、输入框等,都是一个Widget。Frame则是可以容纳其他Widget的Widget,所有的Wi dget组合起来就是一棵树。 dget组合起来就是一棵树。 pack() 方法把Widget加入到父容器中,并实现布局。 pack() 是最简单的布局, grid() 可以实现更复杂的布局。 在 createWidgets() 方法中,我们创建一个 Label 和一个 Button ,当Button被点击时,触发 self.quit() 使程序退 出。 第三步,实例化 Application ,并启动消息循环: app = Application() # 设置窗口标题: app.master.title('Hello World') # 主消息循环: app.mainloop() GUI程序的主线程负责监听来自操作系统的消息,并依次处理每一条消息。因此,如果消息处理非常耗时,就需要在 新线程中处理。 运行这个GUI程序,可以看到下面的窗口: 点击“Quit”按钮或者窗口的“x”结束程序。 输入文本 我们再对这个GUI程序改进一下,加入一个文本框,让用户可以输入文本,然后点按钮后,弹出消息对话框。 from Tkinter import * import tkMessageBox class Application(Frame): def __init__(self, master=None): Frame.__init__(self, master) self.pack() self.createWidgets() def createWidgets(self): self.nameInput = Entry(self) self.nameInput.pack() self.alertButton = Button(self, text='Hello', command=self.hello) self.alertButton.pack() def hello(self): name = self.nameInput.get() or 'world' tkMessageBox.showinfo('Message', 'Hello, %s' % name) 当用户点击按钮时,触发 hello() ,通过 self.nameInput.get() 获得用户输入的文本后,使 用 tkMessageBox.showinfo() 可以弹出消息对话框。 程序运行结果如下: 小结 Python内置的Tkinter可以满足基本的GUI程序的要求,如果是非常复杂的GUI程序,建议用操作系统原生支持的语 言和库来编写。 源码参考:https://github.com/michaelliao/learn­python/tree/master/gui 您的鼓励是作者写作最大的动力 如果您认为本网站的教程质量不错,读后觉得收获很大,预期工资涨幅能超过30%,不妨小额赞助我一下,让我有 动力继续写出高质量的教程: 网络编程 23次阅读 自从互联网诞生以来,现在基本上所有的程序都是网络程序,很少有单机版的程序了。 计算机网络就是把各个计算机连接到一起,让网络中的计算机可以互相通信。网络编程就是如何在程序中实现两台 计算机的通信。 举个例子,当你使用浏览器访问新浪网时,你的计算机就和新浪的某台服务器通过互联网连接起来了,然后,新浪 的服务器把网页内容作为数据通过互联网传输到你的电脑上。 由于你的电脑上可能不止浏览器,还有QQ、Skype、Dropbox、邮件客户端等,不同的程序连接的别的计算机也会 不同,所以,更确切地说,网络通信是两台计算机上的两个进程之间的通信。比如,浏览器进程和新浪服务器上的 某个Web服务进程在通信,而QQ进程是和腾讯的某个服务器上的某个进程在通信。 网络编程对所有开发语言都是一样的,Python也不例外。用Python进行网络编程,就是在Python程序本身这个进程 内,连接别的服务器进程的通信端口进行通信。 本章我们将详细介绍Python网络编程的概念和最主要的两种网络类型的编程。 您的鼓励是作者写作最大的动力 如果您认为本网站的教程质量不错,读后觉得收获很大,预期工资涨幅能超过30%,不妨小额赞助我一下,让我有 动力继续写出高质量的教程: TCP/IP简介 36次阅读 虽然大家现在对互联网很熟悉,但是计算机网络的出现比互联网要早很多。 计算机为了联网,就必须规定通信协议,早期的计算机网络,都是由各厂商自己规定一套协议,IBM、Apple和Micr osoft都有各自的网络协议,互不兼容,这就好比一群人有的说英语,有的说中文,有的说德语,说同一种语言的人 可以交流,不同的语言之间就不行了。 为了把全世界的所有不同类型的计算机都连接起来,就必须规定一套全球通用的协议,为了实现互联网这个目 标,互联网协议簇(Internet Protocol Suite)就是通用协议标准。Internet是由inter和net两个单词组合起来的,原 标,互联网协议簇(Internet Protocol Suite)就是通用协议标准。Internet是由inter和net两个单词组合起来的,原 意就是连接“网络”的网络,有了Internet,任何私有网络,只要支持这个协议,就可以联入互联网。 因为互联网协议包含了上百种协议标准,但是最重要的两个协议是TCP和IP协议,所以,大家把互联网的协议简称T CP/IP协议。 通信的时候,双方必须知道对方的标识,好比发邮件必须知道对方的邮件地址。互联网上每个计算机的唯一标识就 是IP地址,类似123.123.123.123。如果一台计算机同时接入到两个或更多的网络,比如路由器,它就会有两个或多 个IP地址,所以,IP地址对应的实际上是计算机的网络接口,通常是网卡。 IP协议负责把数据从一台计算机通过网络发送到另一台计算机。数据被分割成一小块一小块,然后通过IP包发送出 去。由于互联网链路复杂,两台计算机之间经常有多条线路,因此,路由器就负责决定如何把一个IP包转发出去。I P包的特点是按块发送,途径多个路由,但不保证能到达,也不保证顺序到达。 TCP协议则是建立在IP协议之上的。TCP协议负责在两台计算机之间建立可靠连接,保证数据包按顺序到达。TCP 协议会通过握手建立连接,然后,对每个IP包编号,确保对方按顺序收到,如果包丢掉了,就自动重发。 许多常用的更高级的协议都是建立在TCP协议基础上的,比如用于浏览器的HTTP协议、发送邮件的SMTP协议等。 一个IP包除了包含要传输的数据外,还包含源IP地址和目标IP地址,源端口和目标端口。 端口有什么作用?在两台计算机通信时,只发IP地址是不够的,因为同一台计算机上跑着多个网络程序。一个IP包 来了之后,到底是交给浏览器还是QQ,就需要端口号来区分。每个网络程序都向操作系统申请唯一的端口号,这 样,两个进程在两台计算机之间建立网络连接就需要各自的IP地址和各自的端口号。 一个进程也可能同时与多个计算机建立链接,因此它会申请很多端口。 了解了TCP/IP协议的基本概念,IP地址和端口的概念,我们就可以开始进行网络编程了。 您的鼓励是作者写作最大的动力 如果您认为本网站的教程质量不错,读后觉得收获很大,预期工资涨幅能超过30%,不妨小额赞助我一下,让我有 动力继续写出高质量的教程: TCP编程 46次阅读 Socket是网络编程的一个抽象概念。通常我们用一个Socket表示“打开了一个网络链接”,而打开一个Socket需要知 道目标计算机的IP地址和端口号,再指定协议类型即可。 客户端 大多数连接都是可靠的TCP连接。创建TCP连接时,主动发起连接的叫客户端,被动响应连接的叫服务器。 举个例子,当我们在浏览器中访问新浪时,我们自己的计算机就是客户端,浏览器会主动向新浪的服务器发起连 接。如果一切顺利,新浪的服务器接受了我们的连接,一个TCP连接就建立起来的,后面的通信就是发送网页内容 了。 所以,我们要创建一个基于TCP连接的Socket,可以这样做: # 导入socket库: import socket # 创建一个socket: s = socket.socket(socket.AF_INET, socket.SOCK_STREAM) # 建立连接: s.connect(('www.sina.com.cn', 80)) 创建 Socket 时, AF_INET 指定使用IPv4协议,如果要用更先进的IPv6,就指定为 AF_INET6 。 SOCK_STREAM 指定使 用面向流的TCP协议,这样,一个 Socket 对象就创建成功,但是还没有建立连接。 客户端要主动发起TCP连接,必须知道服务器的IP地址和端口号。新浪网站的IP地址可以用域名 www.sina.com.cn 自 动转换到IP地址,但是怎么知道新浪服务器的端口号呢? 答案是作为服务器,提供什么样的服务,端口号就必须固定下来。由于我们想要访问网页,因此新浪提供网页服务 的服务器必须把端口号固定在 80 端口,因为 80 端口是Web服务的标准端口。其他服务都有对应的标准端口号,例 如SMTP服务是25端口,FTP服务是21端口,等等。端口号小于1024的是Internet标准服务的端口,端口号大于102 4的,可以任意使用。 因此,我们连接新浪服务器的代码如下: s.connect(('www.sina.com.cn', 80)) 注意参数是一个tuple,包含地址和端口号。 建立TCP连接后,我们就可以向新浪服务器发送请求,要求返回首页的内容: # 发送数据: s.send('GET / HTTP/1.1\r\nHost: www.sina.com.cn\r\nConnection: close\r\n\r\n') TCP连接创建的是双向通道,双方都可以同时给对方发数据。但是谁先发谁后发,怎么协调,要根据具体的协议来 决定。例如,HTTP协议规定客户端必须先发请求给服务器,服务器收到后才发数据给客户端。 发送的文本格式必须符合HTTP标准,如果格式没问题,接下来就可以接收新浪服务器返回的数据了: # 接收数据: buffer = [] while True: # 每次最多接收1k字节: # 每次最多接收1k字节: d = s.recv(1024) if d: buffer.append(d) else: break data = ''.join(buffer) 接收数据时,调用 recv(max) 方法,一次最多接收指定的字节数,因此,在一个while循环中反复接收,直 到 recv() 返回空数据,表示接收完毕,退出循环。 当我们接收完数据后,调用 close() 方法关闭Socket,这样,一次完整的网络通信就结束了: # 关闭连接: s.close() 接收到的数据包括HTTP头和网页本身,我们只需要把HTTP头和网页分离一下,把HTTP头打印出来,网页内容保 存到文件: header, html = data.split('\r\n\r\n', 1) print header # 把接收的数据写入文件: with open('sina.html', 'wb') as f: f.write(html) 现在,只需要在浏览器中打开这个 sina.html 文件,就可以看到新浪的首页了。 服务器 和客户端编程相比,服务器编程就要复杂一些。 服务器进程首先要绑定一个端口并监听来自其他客户端的连接。如果某个客户端连接过来了,服务器就与该客户端 建立Socket连接,随后的通信就靠这个Socket连接了。 所以,服务器会打开固定端口(比如80)监听,每来一个客户端连接,就创建该Socket连接。由于服务器会有大量 来自客户端的连接,所以,服务器要能够区分一个Socket连接是和哪个客户端绑定的。一个Socket依赖4项:服务器 地址、服务器端口、客户端地址、客户端端口来唯一确定一个Socket。 但是服务器还需要同时响应多个客户端的请求,所以,每个连接都需要一个新的进程或者新的线程来处理,否 则,服务器一次就只能服务一个客户端了。 我们来编写一个简单的服务器程序,它接收客户端连接,把客户端发过来的字符串加上 Hello 再发回去。 首先,创建一个基于IPv4和TCP协议的Socket: s = socket.socket(socket.AF_INET, socket.SOCK_STREAM) 然后,我们要绑定监听的地址和端口。服务器可能有多块网卡,可以绑定到某一块网卡的IP地址上,也可以 用 0.0.0.0 绑定到所有的网络地址,还可以用 127.0.0.1 绑定到本机地址。 127.0.0.1 是一个特殊的IP地址,表示 本机地址,如果绑定到这个地址,客户端必须同时在本机运行才能连接,也就是说,外部的计算机无法连接进来。 端口号需要预先指定。因为我们写的这个服务不是标准服务,所以用 9999 这个端口号。请注意,小于 1024 的端口 端口号需要预先指定。因为我们写的这个服务不是标准服务,所以用 9999 这个端口号。请注意,小于 1024 的端口 号必须要有管理员权限才能绑定: # 监听端口: s.bind(('127.0.0.1', 9999)) 紧接着,调用 listen() 方法开始监听端口,传入的参数指定等待连接的最大数量: s.listen(5) print 'Waiting for connection...' 接下来,服务器程序通过一个永久循环来接受来自客户端的连接, accept() 会等待并返回一个客户端的连接: while True: # 接受一个新连接: sock, addr = s.accept() # 创建新线程来处理TCP连接: t = threading.Thread(target=tcplink, args=(sock, addr)) t.start() 每个连接都必须创建新线程(或进程)来处理,否则,单线程在处理连接的过程中,无法接受其他客户端的连接: def tcplink(sock, addr): print 'Accept new connection from %s:%s...' % addr sock.send('Welcome!') while True: data = sock.recv(1024) time.sleep(1) if data == 'exit' or not data: break sock.send('Hello, %s!' % data) sock.close() print 'Connection from %s:%s closed.' % addr 连接建立后,服务器首先发一条欢迎消息,然后等待客户端数据,并加上 Hello 再发送给客户端。如果客户端发送 了 exit 字符串,就直接关闭连接。 要测试这个服务器程序,我们还需要编写一个客户端程序: s = socket.socket(socket.AF_INET, socket.SOCK_STREAM) # 建立连接: s.connect(('127.0.0.1', 9999)) # 接收欢迎消息: print s.recv(1024) for data in ['Michael', 'Tracy', 'Sarah']: # 发送数据: s.send(data) print s.recv(1024) s.send('exit') s.close() 我们需要打开两个命令行窗口,一个运行服务器程序,另一个运行客户端程序,就可以看到效果了: 我们需要打开两个命令行窗口,一个运行服务器程序,另一个运行客户端程序,就可以看到效果了: 需要注意的是,客户端程序运行完毕就退出了,而服务器程序会永远运行下去,必须按Ctrl+C退出程序。 小结 用TCP协议进行Socket编程在Python中十分简单,对于客户端,要主动连接服务器的IP和指定端口,对于服务 器,要首先监听指定端口,然后,对每一个新的连接,创建一个线程或进程来处理。通常,服务器程序会无限运行 下去。 同一个端口,被一个Socket绑定了以后,就不能被别的Socket绑定了。 源码参考:https://github.com/michaelliao/learn­python/tree/master/socket 您的鼓励是作者写作最大的动力 如果您认为本网站的教程质量不错,读后觉得收获很大,预期工资涨幅能超过30%,不妨小额赞助我一下,让我有 动力继续写出高质量的教程: UDP编程 98次阅读 TCP是建立可靠连接,并且通信双方都可以以流的形式发送数据。相对TCP,UDP则是面向无连接的协议。 使用UDP协议时,不需要建立连接,只需要知道对方的IP地址和端口号,就可以直接发数据包。但是,能不能到达 就不知道了。 虽然用UDP传输数据不可靠,但它的优点是和TCP比,速度快,对于不要求可靠到达的数据,就可以使用UDP协 议。 我们来看看如何通过UDP协议传输数据。和TCP类似,使用UDP的通信双方也分为客户端和服务器。服务器首先需 要绑定端口: 要绑定端口: s = socket.socket(socket.AF_INET, socket.SOCK_DGRAM) # 绑定端口: s.bind(('127.0.0.1', 9999)) 创建Socket时, SOCK_DGRAM 指定了这个Socket的类型是UDP。绑定端口和TCP一样,但是不需要调用 listen() 方 法,而是直接接收来自任何客户端的数据: print 'Bind UDP on 9999...' while True: # 接收数据: data, addr = s.recvfrom(1024) print 'Received from %s:%s.' % addr s.sendto('Hello, %s!' % data, addr) recvfrom() 方法返回数据和客户端的地址与端口,这样,服务器收到数据后,直接调用 sendto() 就可以把数据用U DP发给客户端。 注意这里省掉了多线程,因为这个例子很简单。 客户端使用UDP时,首先仍然创建基于UDP的Socket,然后,不需要调用 connect() ,直接通过 sendto() 给服务器 发数据: s = socket.socket(socket.AF_INET, socket.SOCK_DGRAM) for data in ['Michael', 'Tracy', 'Sarah']: # 发送数据: s.sendto(data, ('127.0.0.1', 9999)) # 接收数据: print s.recv(1024) s.close() 从服务器接收数据仍然调用 recv() 方法。 仍然用两个命令行分别启动服务器和客户端测试,结果如下: 小结 UDP的使用与TCP类似,但是不需要建立连接。此外,服务器绑定UDP端口和TCP端口互不冲突,也就是说,UDP 的9999端口与TCP的9999端口可以各自绑定。 源码参考:https://github.com/michaelliao/learn­python/tree/master/socket 您的鼓励是作者写作最大的动力 如果您认为本网站的教程质量不错,读后觉得收获很大,预期工资涨幅能超过30%,不妨小额赞助我一下,让我有 动力继续写出高质量的教程: 电子邮件 69次阅读 Email的历史比Web还要久远,直到现在,Email也是互联网上应用非常广泛的服务。 几乎所有的编程语言都支持发送和接收电子邮件,但是,先等等,在我们开始编写代码之前,有必要搞清楚电子邮 件是如何在互联网上运作的。 我们来看看传统邮件是如何运作的。假设你现在在北京,要给一个香港的朋友发一封信,怎么做呢? 首先你得写好信,装进信封,写上地址,贴上邮票,然后就近找个邮局,把信仍进去。 信件会从就近的小邮局转运到大邮局,再从大邮局往别的城市发,比如先发到天津,再走海运到达香港,也可能走 京九线到香港,但是你不用关心具体路线,你只需要知道一件事,就是信件走得很慢,至少要几天时间。 信件到达香港的某个邮局,也不会直接送到朋友的家里,因为邮局的叔叔是很聪明的,他怕你的朋友不在家,一趟 一趟地白跑,所以,信件会投递到你的朋友的邮箱里,邮箱可能在公寓的一层,或者家门口,直到你的朋友回家的 时候检查邮箱,发现信件后,就可以取到邮件了。 电子邮件的流程基本上也是按上面的方式运作的,只不过速度不是按天算,而是按秒算。 现在我们回到电子邮件,假设我们自己的电子邮件地址是 me@163.com ,对方的电子邮件地址 是 friend@sina.com (注意地址都是虚构的哈),现在我们用 Outlook 或者 Foxmail 之类的软件写好邮件,填上对 方的Email地址,点“发送”,电子邮件就发出去了。这些电子邮件软件被称为MUA:Mail User Agent——邮件用户代 理。 Email从MUA发出去,不是直接到达对方电脑,而是发到MTA:Mail Transfer Agent——邮件传输代理,就是那些E mail服务提供商,比如网易、新浪等等。由于我们自己的电子邮件是 163.com ,所以,Email首先被投递到网易提供 的MTA,再由网易的MTA发到对方服务商,也就是新浪的MTA。这个过程中间可能还会经过别的MTA,但是我们不 关心具体路线,我们只关心速度。 Email到达新浪的MTA后,由于对方使用的是 @sina.com 的邮箱,因此,新浪的MTA会把Email投递到邮件的最终目 的地MDA:Mail Delivery Agent——邮件投递代理。Email到达MDA后,就静静地躺在新浪的某个服务器上,存放在 某个文件或特殊的数据库里,我们将这个长期保存邮件的地方称之为电子邮箱。 同普通邮件类似,Email不会直接到达对方的电脑,因为对方电脑不一定开机,开机也不一定联网。对方要取到邮 同普通邮件类似,Email不会直接到达对方的电脑,因为对方电脑不一定开机,开机也不一定联网。对方要取到邮 件,必须通过MUA从MDA上把邮件取到自己的电脑上。 所以,一封电子邮件的旅程就是: 发件人 -> MUA -> MTA -> MTA -> 若干个MTA -> MDA <- MUA <- 收件人 有了上述基本概念,要编写程序来发送和接收邮件,本质上就是: 1.  编写MUA把邮件发到MTA; 2.  编写MUA从MDA上收邮件。 发邮件时,MUA和MTA使用的协议就是SMTP:Simple Mail Transfer Protocol,后面的MTA到另一个MTA也是用S MTP协议。 收邮件时,MUA和MDA使用的协议有两种:POP:Post Office Protocol,目前版本是3,俗称POP3;IMAP:Intern et Message Access Protocol,目前版本是4,优点是不但能取邮件,还可以直接操作MDA上存储的邮件,比如从收 件箱移到垃圾箱,等等。 邮件客户端软件在发邮件时,会让你先配置SMTP服务器,也就是你要发到哪个MTA上。假设你正在使用163的邮 箱,你就不能直接发到新浪的MTA上,因为它只服务新浪的用户,所以,你得填163提供的SMTP服务器地 址: smtp.163.com ,为了证明你是163的用户,SMTP服务器还要求你填写邮箱地址和邮箱口令,这样,MUA才能 正常地把Email通过SMTP协议发送到MTA。 类似的,从MDA收邮件时,MDA服务器也要求验证你的邮箱口令,确保不会有人冒充你收取你的邮件,所以,Outl ook之类的邮件客户端会要求你填写POP3或IMAP服务器地址、邮箱地址和口令,这样,MUA才能顺利地通过POP 或IMAP协议从MDA取到邮件。 在使用Python收发邮件前,请先准备好至少两个电子邮件,如 xxx@163.com , xxx@sina.com , xxx@qq.com 等,注 意两个邮箱不要用同一家邮件服务商。 您的鼓励是作者写作最大的动力 如果您认为本网站的教程质量不错,读后觉得收获很大,预期工资涨幅能超过30%,不妨小额赞助我一下,让我有 动力继续写出高质量的教程: SMTP发送邮件 26次阅读 SMTP是发送邮件的协议,Python内置对SMTP的支持,可以发送纯文本邮件、HTML邮件以及带附件的邮件。 Python对SMTP支持有 smtplib 和 email 两个模块, email 负责构造邮件, smtplib 负责发送邮件。 首先,我们来构造一个最简单的纯文本邮件: from email.mime.text import MIMEText msg = MIMEText('hello, send by Python...', 'plain', 'utf-8') 注意到构造 MIMEText 对象时,第一个参数就是邮件正文,第二个参数是MIME的subtype,传入 'plain' ,最终的M IME就是 'text/plain' ,最后一定要用 utf‐8 编码保证多语言兼容性。 IME就是 'text/plain' ,最后一定要用 utf‐8 编码保证多语言兼容性。 然后,通过SMTP发出去: # 输入Email地址和口令: from_addr = raw_input('From: ') password = raw_input('Password: ') # 输入SMTP服务器地址: smtp_server = raw_input('SMTP server: ') # 输入收件人地址: to_addr = raw_input('To: ') import smtplib server = smtplib.SMTP(smtp_server, 25) # SMTP协议默认端口是25 server.set_debuglevel(1) server.login(from_addr, password) server.sendmail(from_addr, [to_addr], msg.as_string()) server.quit() 我们用 set_debuglevel(1) 就可以打印出和SMTP服务器交互的所有信息。SMTP协议就是简单的文本命令和响 应。 login() 方法用来登录SMTP服务器, sendmail() 方法就是发邮件,由于可以一次发给多个人,所以传入一 个 list ,邮件正文是一个 str , as_string() 把 MIMEText 对象变成 str 。 如果一切顺利,就可以在收件人信箱中收到我们刚发送的Email: 仔细观察,发现如下问题: 1.  邮件没有主题; 2.  收件人的名字没有显示为友好的名字,比如 Mr Green  ; 3.  明明收到了邮件,却提示不在收件人中。 这是因为邮件主题、如何显示发件人、收件人等信息并不是通过SMTP协议发给MTA,而是包含在发给MTA的文本 中的,所以,我们必须把 From 、 To 和 Subject 添加到 MIMEText 中,才是一封完整的邮件: # -*- coding: utf-8 -*- from email import encoders from email.header import Header from email.mime.text import MIMEText from email.utils import parseaddr, formataddr import smtplib def _format_addr(s): name, addr = parseaddr(s) return formataddr(( \ return formataddr(( \ Header(name, 'utf-8').encode(), \ addr.encode('utf-8') if isinstance(addr, unicode) else addr)) from_addr = raw_input('From: ') password = raw_input('Password: ') to_addr = raw_input('To: ') smtp_server = raw_input('SMTP server: ') msg = MIMEText('hello, send by Python...', 'plain', 'utf-8') msg['From'] = _format_addr(u'Python爱好者 <%s>' % from_addr) msg['To'] = _format_addr(u'管理员 <%s>' % to_addr) msg['Subject'] = Header(u'来自SMTP的问候……', 'utf-8').encode() server = smtplib.SMTP(smtp_server, 25) server.set_debuglevel(1) server.login(from_addr, password) server.sendmail(from_addr, [to_addr], msg.as_string()) server.quit() 我们编写了一个函数 _format_addr() 来格式化一个邮件地址。注意不能简单地传入 name  ,因 为如果包含中文,需要通过 Header 对象进行编码。 msg['To'] 接收的是字符串而不是list,如果有多个邮件地址,用 , 分隔即可。 再发送一遍邮件,就可以在收件人邮箱中看到正确的标题、发件人和收件人: 你看到的收件人的名字很可能不是我们传入的 管理员 ,因为很多邮件服务商在显示邮件时,会把收件人名字自动替 换为用户注册的名字,但是其他收件人名字的显示不受影响。 如果我们查看Email的原始内容,可以看到如下经过编码的邮件头: From: =?utf-8?b?UHl0aG9u54ix5aW96ICF?= To: =?utf-8?b?566h55CG5ZGY?= Subject: =?utf-8?b?5p2l6IeqU01UUOeahOmXruWAmeKApuKApg==?= 这就是经过 Header 对象编码的文本,包含utf­8编码信息和Base64编码的文本。如果我们自己来手动构造这样的编 码文本,显然比较复杂。 发送HTML邮件 如果我们要发送HTML邮件,而不是普通的纯文本文件怎么办?方法很简单,在构造 MIMEText 对象时,把HTML字 符串传进去,再把第二个参数由 plain 变为 html 就可以了: msg = MIMEText('

Hello

' + '

send by Python...

' + '

send by Python...

' + '', 'html', 'utf-8') 再发送一遍邮件,你将看到以HTML显示的邮件: 发送附件 如果Email中要加上附件怎么办?带附件的邮件可以看做包含若干部分的邮件:文本和各个附件本身,所以,可以构 造一个 MIMEMultipart 对象代表邮件本身,然后往里面加上一个 MIMEText 作为邮件正文,再继续往里面加上表示附 件的 MIMEBase 对象即可: # 邮件对象: msg = MIMEMultipart() msg['From'] = _format_addr(u'Python爱好者 <%s>' % from_addr) msg['To'] = _format_addr(u'管理员 <%s>' % to_addr) msg['Subject'] = Header(u'来自SMTP的问候……', 'utf-8').encode() # 邮件正文是MIMEText: msg.attach(MIMEText('send with file...', 'plain', 'utf-8')) # 添加附件就是加上一个MIMEBase,从本地读取一个图片: with open('/Users/michael/Downloads/test.png', 'rb') as f: # 设置附件的MIME和文件名,这里是png类型: mime = MIMEBase('image', 'png', filename='test.png') # 加上必要的头信息: mime.add_header('Content-Disposition', 'attachment', filename='test.png') mime.add_header('Content-ID', '<0>') mime.add_header('X-Attachment-Id', '0') # 把附件的内容读进来: mime.set_payload(f.read()) # 用Base64编码: encoders.encode_base64(mime) # 添加到MIMEMultipart: msg.attach(mime) 然后,按正常发送流程把 msg (注意类型已变为 MIMEMultipart )发送出去,就可以收到如下带附件的邮件: 发送图片 如果要把一个图片嵌入到邮件正文中怎么做?直接在HTML邮件中链接图片地址行不行?答案是,大部分邮件服务商 都会自动屏蔽带有外链的图片,因为不知道这些链接是否指向恶意网站。 要把图片嵌入到邮件正文中,我们只需按照发送附件的方式,先把邮件作为附件添加进去,然后,在HTML中通过引 用 src="cid:0" 就可以把附件作为图片嵌入了。如果有多个图片,给它们依次编号,然后引用不同的 cid:x 即可。 把上面代码加入 MIMEMultipart 的 MIMEText 从 plain 改为 html ,然后在适当的位置引用图片: msg.attach(MIMEText('

Hello

' + '

' + '', 'html', 'utf-8')) 再次发送,就可以看到图片直接嵌入到邮件正文的效果: 同时支持HTML和Plain格式 如果我们发送HTML邮件,收件人通过浏览器或者Outlook之类的软件是可以正常浏览邮件内容的,但是,如果收件 人使用的设备太古老,查看不了HTML邮件怎么办? 办法是在发送HTML的同时再附加一个纯文本,如果收件人无法查看HTML格式的邮件,就可以自动降级查看纯文本 邮件。 利用 MIMEMultipart 就可以组合一个HTML和Plain,要注意指定subtype是 alternative : msg = MIMEMultipart('alternative') msg['From'] = ... msg['To'] = ... msg['Subject'] = ... msg.attach(MIMEText('hello', 'plain', 'utf-8')) msg.attach(MIMEText('

Hello

', 'html', 'utf-8')) # 正常发送msg对象... 加密SMTP 使用标准的25端口连接SMTP服务器时,使用的是明文传输,发送邮件的整个过程可能会被窃听。要更安全地发送 邮件,可以加密SMTP会话,实际上就是先创建SSL安全连接,然后再使用SMTP协议发送邮件。 某些邮件服务商,例如Gmail,提供的SMTP服务必须要加密传输。我们来看看如何通过Gmail提供的安全SMTP发 送邮件。 必须知道,Gmail的SMTP端口是587,因此,修改代码如下: smtp_server = 'smtp.gmail.com' smtp_port = 587 server = smtplib.SMTP(smtp_server, smtp_port) server.starttls() # 剩下的代码和前面的一模一样: server.set_debuglevel(1) ... 只需要在创建 SMTP 对象后,立刻调用 starttls() 方法,就创建了安全连接。后面的代码和前面的发送邮件代码完 全一样。 如果因为网络问题无法连接Gmail的SMTP服务器,请相信我们的代码是没有问题的,你需要对你的网络设置做必要 的调整。 小结 使用Python的smtplib发送邮件十分简单,只要掌握了各种邮件类型的构造方法,正确设置好邮件头,就可以顺利发 使用Python的smtplib发送邮件十分简单,只要掌握了各种邮件类型的构造方法,正确设置好邮件头,就可以顺利发 出。 构造一个邮件对象就是一个 Messag 对象,如果构造一个 MIMEText 对象,就表示一个文本邮件对象,如果构造一 个 MIMEImage 对象,就表示一个作为附件的图片,要把多个对象组合起来,就用 MIMEMultipart 对象,而 MIMEBase 可以表示任何对象。它们的继承关系如下: Message +- MIMEBase +- MIMEMultipart +- MIMENonMultipart +- MIMEMessage +- MIMEText +- MIMEImage 这种嵌套关系就可以构造出任意复杂的邮件。你可以通过email.mime文档查看它们所在的包以及详细的用法。 源码参考: https://github.com/michaelliao/learn­python/tree/master/email 您的鼓励是作者写作最大的动力 如果您认为本网站的教程质量不错,读后觉得收获很大,预期工资涨幅能超过30%,不妨小额赞助我一下,让我有 动力继续写出高质量的教程: POP3收取邮件 86次阅读 SMTP用于发送邮件,如果要收取邮件呢? 收取邮件就是编写一个MUA作为客户端,从MDA把邮件获取到用户的电脑或者手机上。收取邮件最常用的协议是P OP协议,目前版本号是3,俗称POP3。 Python内置一个 poplib 模块,实现了POP3协议,可以直接用来收邮件。 注意到POP3协议收取的不是一个已经可以阅读的邮件本身,而是邮件的原始文本,这和SMTP协议很像,SMTP发 送的也是经过编码后的一大段文本。 要把POP3收取的文本变成可以阅读的邮件,还需要用 email 模块提供的各种类来解析原始文本,变成可阅读的邮件 对象。 所以,收取邮件分两步: 第一步:用 poplib 把邮件的原始文本下载到本地; 第二部:用 email 解析原始文本,还原为邮件对象。 通过POP3下载邮件 POP3协议本身很简单,以下面的代码为例,我们来获取最新的一封邮件内容: POP3协议本身很简单,以下面的代码为例,我们来获取最新的一封邮件内容: import poplib # 输入邮件地址, 口令和POP3服务器地址: email = raw_input('Email: ') password = raw_input('Password: ') pop3_server = raw_input('POP3 server: ') # 连接到POP3服务器: server = poplib.POP3(pop3_server) # 可以打开或关闭调试信息: # server.set_debuglevel(1) # 可选:打印POP3服务器的欢迎文字: print(server.getwelcome()) # 身份认证: server.user(email) server.pass_(password) # stat()返回邮件数量和占用空间: print('Messages: %s. Size: %s' % server.stat()) # list()返回所有邮件的编号: resp, mails, octets = server.list() # 可以查看返回的列表类似['1 82923', '2 2184', ...] print(mails) # 获取最新一封邮件, 注意索引号从1开始: index = len(mails) resp, lines, octets = server.retr(index) # lines存储了邮件的原始文本的每一行, # 可以获得整个邮件的原始文本: msg_content = '\r\n'.join(lines) # 稍后解析出邮件: msg = Parser().parsestr(msg_content) # 可以根据邮件索引号直接从服务器删除邮件: # server.dele(index) # 关闭连接: server.quit() 用POP3获取邮件其实很简单,要获取所有邮件,只需要循环使用 retr() 把每一封邮件内容拿到即可。真正麻烦的 是把邮件的原始内容解析为可以阅读的邮件对象。 解析邮件 解析邮件的过程和上一节构造邮件正好相反,因此,先导入必要的模块: import email from email.parser import Parser from email.header import decode_header from email.utils import parseaddr 只需要一行代码就可以把邮件内容解析为 Message 对象: msg = Parser().parsestr(msg_content) 但是这个 Message 对象本身可能是一个 MIMEMultipart 对象,即包含嵌套的其他 MIMEBase 对象,嵌套可能还不止一 但是这个 Message 对象本身可能是一个 MIMEMultipart 对象,即包含嵌套的其他 MIMEBase 对象,嵌套可能还不止一 层。 所以我们要递归地打印出 Message 对象的层次结构: # indent用于缩进显示: def print_info(msg, indent=0): if indent == 0: # 邮件的From, To, Subject存在于根对象上: for header in ['From', 'To', 'Subject']: value = msg.get(header, '') if value: if header=='Subject': # 需要解码Subject字符串: value = decode_str(value) else: # 需要解码Email地址: hdr, addr = parseaddr(value) name = decode_str(hdr) value = u'%s <%s>' % (name, addr) print('%s%s: %s' % (' ' * indent, header, value)) if (msg.is_multipart()): # 如果邮件对象是一个MIMEMultipart, # get_payload()返回list,包含所有的子对象: parts = msg.get_payload() for n, part in enumerate(parts): print('%spart %s' % (' ' * indent, n)) print('%s--------------------' % (' ' * indent)) # 递归打印每一个子对象: print_info(part, indent + 1) else: # 邮件对象不是一个MIMEMultipart, # 就根据content_type判断: content_type = msg.get_content_type() if content_type=='text/plain' or content_type=='text/html': # 纯文本或HTML内容: content = msg.get_payload(decode=True) # 要检测文本编码: charset = guess_charset(msg) if charset: content = content.decode(charset) print('%sText: %s' % (' ' * indent, content + '...')) else: # 不是文本,作为附件处理: print('%sAttachment: %s' % (' ' * indent, content_type)) 邮件的Subject或者Email中包含的名字都是经过编码后的str,要正常显示,就必须decode: def decode_str(s): value, charset = decode_header(s)[0] if charset: value = value.decode(charset) return value decode_header() 返回一个list,因为像 Cc 、 Bcc 这样的字段可能包含多个邮件地址,所以解析出来的会有多个元 decode_header() 返回一个list,因为像 Cc 、 Bcc 这样的字段可能包含多个邮件地址,所以解析出来的会有多个元 素。上面的代码我们偷了个懒,只取了第一个元素。 文本邮件的内容也是str,还需要检测编码,否则,非UTF­8编码的邮件都无法正常显示: def guess_charset(msg): # 先从msg对象获取编码: charset = msg.get_charset() if charset is None: # 如果获取不到,再从Content-Type字段获取: content_type = msg.get('Content-Type', '').lower() pos = content_type.find('charset=') if pos >= 0: charset = content_type[pos + 8:].strip() return charset 把上面的代码整理好,我们就可以来试试收取一封邮件。先往自己的邮箱发一封邮件,然后用浏览器登录邮箱,看 看邮件收到没,如果收到了,我们就来用Python程序把它收到本地: 运行程序,结果如下: +OK Welcome to coremail Mail Pop3 Server (163coms[...]) Messages: 126. Size: 27228317 From: Test To: Python爱好者 Subject: 用POP3收取邮件 part 0 -------------------- part 0 -------------------- Text: Python可以使用POP3收取邮件……... part 1 -------------------- Text: Python可以使用POP3收取邮件……... part 1 -------------------- Attachment: application/octet-stream 我们从打印的结构可以看出,这封邮件是一个 MIMEMultipart ,它包含两部分:第一部分又是一 个 MIMEMultipart ,第二部分是一个附件。而内嵌的 MIMEMultipart 是一个 alternative 类型,它包含一个纯文本格 式的 MIMEText 和一个HTML格式的 MIMEText 。 小结 用Python的 poplib 模块收取邮件分两步:第一步是用POP3协议把邮件获取到本地,第二步是用 email 模块把原始 邮件解析为 Message 对象,然后,用适当的形式把邮件内容展示给用户即可。 源码参考: https://github.com/michaelliao/learn­python/tree/master/email 您的鼓励是作者写作最大的动力 如果您认为本网站的教程质量不错,读后觉得收获很大,预期工资涨幅能超过30%,不妨小额赞助我一下,让我有 动力继续写出高质量的教程: 访问数据库 95次阅读 程序运行的时候,数据都是在内存中的。当程序终止的时候,通常都需要将数据保存到磁盘上,无论是保存到本地 磁盘,还是通过网络保存到服务器上,最终都会将数据写入磁盘文件。 而如何定义数据的存储格式就是一个大问题。如果我们自己来定义存储格式,比如保存一个班级所有学生的成绩 单: 名字 成绩 Michael 99 Bob 85 Bart 59 Lisa 87 你可以用一个文本文件保存,一行保存一个学生,用 , 隔开: Michael,99 Bob,85 Bart,59 Lisa,87 你还可以用JSON格式保存,也是文本文件: [ {"name":"Michael","score":99}, {"name":"Bob","score":85}, {"name":"Bart","score":59}, {"name":"Lisa","score":87} ] 你还可以定义各种保存格式,但是问题来了: 存储和读取需要自己实现,JSON还是标准,自己定义的格式就各式各样了; 存储和读取需要自己实现,JSON还是标准,自己定义的格式就各式各样了; 不能做快速查询,只有把数据全部读到内存中才能自己遍历,但有时候数据的大小远远超过了内存(比如蓝光电 影,40GB的数据),根本无法全部读入内存。 为了便于程序保存和读取数据,而且,能直接通过条件快速查询到指定的数据,就出现了数据库(Database)这种 专门用于集中存储和查询的软件。 数据库软件诞生的历史非常久远,早在1950年数据库就诞生了。经历了网状数据库,层次数据库,我们现在广泛使 用的关系数据库是20世纪70年代基于关系模型的基础上诞生的。 关系模型有一套复杂的数学理论,但是从概念上是十分容易理解的。举个学校的例子: 假设某个XX省YY市ZZ县第一实验小学有3个年级,要表示出这3个年级,可以在Excel中用一个表格画出来: 每个年级又有若干个班级,要把所有班级表示出来,可以在Excel中再画一个表格: 这两个表格有个映射关系,就是根据Grade_ID可以在班级表中查找到对应的所有班级: 也就是Grade表的每一行对应Class表的多行,在关系数据库中,这种基于表(Table)的一对多的关系就是关系数 据库的基础。 根据某个年级的ID就可以查找所有班级的行,这种查询语句在关系数据库中称为SQL语句,可以写成: SELECT * FROM classes WHERE grade_id = '1'; 结果也是一个表: ---------+----------+---------- grade_id | class_id | name ---------+----------+---------- 1 | 11 | 一年级一班 ---------+----------+---------- 1 | 12 | 一年级二班 ---------+----------+---------- 1 | 13 | 一年级三班 ---------+----------+---------- 类似的,Class表的一行记录又可以关联到Student表的多行记录: 由于本教程不涉及到关系数据库的详细内容,如果你想从零学习关系数据库和基本的SQL语句,推荐Coursera课 程: 英文:https://www.coursera.org/course/db 中文:http://c.open.163.com/coursera/courseIntro.htm?cid=12 NoSQL 你也许还听说过NoSQL数据库,很多NoSQL宣传其速度和规模远远超过关系数据库,所以很多同学觉得有了NoSQ L是否就不需要SQL了呢?千万不要被他们忽悠了,连SQL都不明白怎么可能搞明白NoSQL呢? 数据库类别 既然我们要使用关系数据库,就必须选择一个关系数据库。目前广泛使用的关系数据库也就这么几种: 付费的商用数据库: Oracle,典型的高富帅; SQL Server,微软自家产品,Windows定制专款; DB2,IBM的产品,听起来挺高端; Sybase,曾经跟微软是好基友,后来关系破裂,现在家境惨淡。 这些数据库都是不开源而且付费的,最大的好处是花了钱出了问题可以找厂家解决,不过在Web的世界里,常常需 要部署成千上万的数据库服务器,当然不能把大把大把的银子扔给厂家,所以,无论是Google、Facebook,还是国 内的BAT,无一例外都选择了免费的开源数据库: MySQL,大家都在用,一般错不了; PostgreSQL,学术气息有点重,其实挺不错,但知名度没有MySQL高; sqlite,嵌入式数据库,适合桌面和移动应用。 作为Python开发工程师,选择哪个免费数据库呢?当然是MySQL。因为MySQL普及率最高,出了错,可以很容易 找到解决方法。而且,围绕MySQL有一大堆监控和运维的工具,安装和使用很方便。 为了能继续后面的学习,你需要从MySQL官方网站下载并安装MySQL Community Server 5.6,这个版本是免费 的,其他高级版本是要收钱的(请放心,收钱的功能我们用不上)。 您的鼓励是作者写作最大的动力 如果您认为本网站的教程质量不错,读后觉得收获很大,预期工资涨幅能超过30%,不妨小额赞助我一下,让我有 动力继续写出高质量的教程: 使用SQLite 12次阅读 SQLite是一种嵌入式数据库,它的数据库就是一个文件。由于SQLite本身是C写的,而且体积很小,所以,经常被 集成到各种应用程序中,甚至在iOS和Android的App中都可以集成。 Python就内置了SQLite3,所以,在Python中使用SQLite,不需要安装任何东西,直接使用。 在使用SQLite前,我们先要搞清楚几个概念: 表是数据库中存放关系数据的集合,一个数据库里面通常都包含多个表,比如学生的表,班级的表,学校的表,等 等。表和表之间通过外键关联。 要操作关系数据库,首先需要连接到数据库,一个数据库连接称为Connection; 连接到数据库后,需要打开游标,称之为Cursor,通过Cursor执行SQL语句,然后,获得执行结果。 Python定义了一套操作数据库的API接口,任何数据库要连接到Python,只需要提供符合Python标准的数据库驱动 即可。 由于SQLite的驱动内置在Python标准库中,所以我们可以直接来操作SQLite数据库。 我们在Python交互式命令行实践一下: # 导入SQLite驱动: >>> import sqlite3 # 连接到SQLite数据库 # 数据库文件是test.db # 如果文件不存在,会自动在当前目录创建: # 如果文件不存在,会自动在当前目录创建: >>> conn = sqlite3.connect('test.db') # 创建一个Cursor: >>> cursor = conn.cursor() # 执行一条SQL语句,创建user表: >>> cursor.execute('create table user (id varchar(20) primary key, name varchar(20))') # 继续执行一条SQL语句,插入一条记录: >>> cursor.execute('insert into user (id, name) values (\'1\', \'Michael\')') # 通过rowcount获得插入的行数: >>> cursor.rowcount 1 # 关闭Cursor: >>> cursor.close() # 提交事务: >>> conn.commit() # 关闭Connection: >>> conn.close() 我们再试试查询记录: >>> conn = sqlite3.connect('test.db') >>> cursor = conn.cursor() # 执行查询语句: >>> cursor.execute('select * from user where id=?', '1') # 获得查询结果集: >>> values = cursor.fetchall() >>> values [(u'1', u'Michael')] >>> cursor.close() >>> conn.close() 使用Python的DB­API时,只要搞清楚Connection和Cursor对象,打开后一定记得关闭,就可以放心地使用。 使用Cursor对象执行 insert , update , delete 语句时,执行结果由 rowcount 返回影响的行数,就可以拿到执行 结果。 使用Cursor对象执行 select 语句时,通过 featchall() 可以拿到结果集。结果集是一个list,每个元素都是一个tupl e,对应一行记录。 如果SQL语句带有参数,那么需要把参数按照位置传递给 execute() 方法,有几个 ? 占位符就必须对应几个参 数,例如: cursor.execute('select * from user where id=?', '1') SQLite支持常见的标准SQL语句以及几种常见的数据类型。具体文档请参阅SQLite官方网站。 小结 在Python中操作数据库时,要先导入数据库对应的驱动,然后,通过Connection对象和Cursor对象操作数据。 要确保打开的Connection对象和Cursor对象都正确地被关闭,否则,资源就会泄露。 要确保打开的Connection对象和Cursor对象都正确地被关闭,否则,资源就会泄露。 如何才能确保出错的情况下也关闭掉Connection对象和Cursor对象呢?请回忆 try:...except:...finally:... 的用 法。 您的鼓励是作者写作最大的动力 如果您认为本网站的教程质量不错,读后觉得收获很大,预期工资涨幅能超过30%,不妨小额赞助我一下,让我有 动力继续写出高质量的教程: 使用MySQL 55次阅读 MySQL是Web世界中使用最广泛的数据库服务器。SQLite的特点是轻量级、可嵌入,但不能承受高并发访问,适合 桌面和移动应用。而MySQL是为服务器端设计的数据库,能承受高并发访问,同时占用的内存也远远大于SQLite。 此外,MySQL内部有多种数据库引擎,最常用的引擎是支持数据库事务的InnoDB。 安装MySQL 可以直接从MySQL官方网站下载最新的Community Server 5.6.x版本。MySQL是跨平台的,选择对应的平台下载安 装文件,安装即可。 安装时,MySQL会提示输入 root 用户的口令,请务必记清楚。如果怕记不住,就把口令设置为 password 。 在Windows上,安装时请选择 UTF‐8 编码,以便正确地处理中文。 在Mac或Linux上,需要编辑MySQL的配置文件,把数据库默认的编码全部改为UTF­8。MySQL的配置文件默认存 放在 /etc/my.cnf 或者 /etc/mysql/my.cnf : [client] default-character-set = utf8 [mysqld] default-storage-engine = INNODB character-set-server = utf8 collation-server = utf8_general_ci 重启MySQL后,可以通过MySQL的客户端命令行检查编码: $ mysql -u root -p Enter password: Welcome to the MySQL monitor... ... mysql> show variables like '%char%'; +--------------------------+--------------------------------------------------------+ | Variable_name | Value | +--------------------------+--------------------------------------------------------+ | character_set_client | utf8 | | character_set_connection | utf8 | | character_set_database | utf8 | | character_set_filesystem | binary | | character_set_results | utf8 | | character_set_server | utf8 | | character_set_system | utf8 | | character_sets_dir | /usr/local/mysql-5.1.65-osx10.6-x86_64/share/charsets/ | +--------------------------+--------------------------------------------------------+ 8 rows in set (0.00 sec) 看到 utf8 字样就表示编码设置正确。 安装MySQL驱动 由于MySQL服务器以独立的进程运行,并通过网络对外服务,所以,需要支持Python的MySQL驱动来连接到MySQ L服务器。 目前,有两个MySQL驱动: mysql­connector­python:是MySQL官方的纯Python驱动; MySQL­python:是封装了MySQL C驱动的Python驱动。 可以把两个都装上,使用的时候再决定用哪个: $ easy_install mysql-connector-python $ easy_install MySQL-python 我们以mysql­connector­python为例,演示如何连接到MySQL服务器的test数据库: # 导入MySQL驱动: >>> import mysql.connector # 注意把password设为你的root口令: >>> conn = mysql.connector.connect(user='root', password='password', database='test', use_unicode=True) >>> cursor = conn.cursor() # 创建user表: >>> cursor.execute('create table user (id varchar(20) primary key, name varchar(20))') # 插入一行记录,注意MySQL的占位符是%s: >>> cursor.execute('insert into user (id, name) values (%s, %s)', ['1', 'Michael']) >>> cursor.rowcount 1 # 提交事务: >>> conn.commit() >>> cursor.close() # 运行查询: >>> cursor = conn.cursor() >>> cursor.execute('select * from user where id = %s', '1') >>> values = cursor.fetchall() >>> values [(u'1', u'Michael')] # 关闭Cursor和Connection: >>> cursor.close() True >>> conn.close() 由于Python的DB­API定义都是通用的,所以,操作MySQL的数据库代码和SQLite类似。 小结 MySQL的SQL占位符是 %s ; 通常我们在连接MySQL时传入 use_unicode=True ,让MySQL的DB­API始终返回Unicode。 您的鼓励是作者写作最大的动力 如果您认为本网站的教程质量不错,读后觉得收获很大,预期工资涨幅能超过30%,不妨小额赞助我一下,让我有 动力继续写出高质量的教程: 使用SQLAlchemy 7次阅读 数据库表是一个二维表,包含多行多列。把一个表的内容用Python的数据结构表示出来的话,可以用一个list表示多 行,list的每一个元素是tuple,表示一行记录,比如,包含 id 和 name 的 user 表: [ ('1', 'Michael'), ('2', 'Bob'), ('3', 'Adam') ] Python的DB­API返回的数据结构就是像上面这样表示的。 但是用tuple表示一行很难看出表的结构。如果把一个tuple用class实例来表示,就可以更容易地看出表的结构来: class User(object): def __init__(self, id, name): self.id = id self.name = name [ User('1', 'Michael'), User('2', 'Bob'), User('3', 'Adam') ] 这就是传说中的ORM技术:Object­Relational Mapping,把关系数据库的表结构映射到对象上。是不是很简单? 但是由谁来做这个转换呢?所以ORM框架应运而生。 在Python中,最有名的ORM框架是SQLAlchemy。我们来看看SQLAlchemy的用法。 首先通过easy_install或者pip安装SQLAlchemy: $ easy_install sqlalchemy 然后,利用上次我们在MySQL的test数据库中创建的 user 表,用SQLAlchemy来试试: 第一步,导入SQLAlchemy,并初始化DBSession: # 导入: from sqlalchemy import Column, String, create_engine from sqlalchemy.orm import sessionmaker from sqlalchemy.ext.declarative import declarative_base # 创建对象的基类: Base = declarative_base() # 定义User对象: class User(Base): # 表的名字: __tablename__ = 'user' # 表的结构: id = Column(String(20), primary_key=True) name = Column(String(20)) # 初始化数据库连接: engine = create_engine('mysql+mysqlconnector://root:password@localhost:3306/test') # 创建DBSession类型: DBSession = sessionmaker(bind=engine) 以上代码完成SQLAlchemy的初始化和具体每个表的class定义。如果有多个表,就继续定义其他class,例如Schoo l: class School(Base): __tablename__ = 'school' id = ... name = ... create_engine() 用来初始化数据库连接。SQLAlchemy用一个字符串表示连接信息: '数据库类型+数据库驱动名称://用户名:口令@机器地址:端口号/数据库名' 你只需要根据需要替换掉用户名、口令等信息即可。 下面,我们看看如何向数据库表中添加一行记录。 由于有了ORM,我们向数据库表中添加一行记录,可以视为添加一个 User 对象: # 创建session对象: session = DBSession() # 创建新User对象: new_user = User(id='5', name='Bob') # 添加到session: session.add(new_user) # 提交即保存到数据库: session.commit() # 关闭session: session.close() 可见,关键是获取session,然后把对象添加到session,最后提交并关闭。Session对象可视为当前数据库连接。 如何从数据库表中查询数据呢?有了ORM,查询出来的可以不再是tuple,而是 User 对象。SQLAlchemy提供的查 询接口如下: # 创建Session: session = DBSession() # 创建Query查询,filter是where条件,最后调用one()返回唯一行,如果调用all()则返回所有行: user = session.query(User).filter(User.id=='5').one() # 打印类型和对象的name属性: print 'type:', type(user) print 'name:', user.name # 关闭Session: session.close() 运行结果如下: type: name: Bob 可见,ORM就是把数据库表的行与相应的对象建立关联,互相转换。 由于关系数据库的多个表还可以用外键实现一对多、多对多等关联,相应地,ORM框架也可以提供两个对象之间的 一对多、多对多等功能。 例如,如果一个User拥有多个Book,就可以定义一对多关系如下: class User(Base): __tablename__ = 'user' id = Column(String(20), primary_key=True) name = Column(String(20)) # 一对多: books = relationship('Book') class Book(Base): __tablename__ = 'book' id = Column(String(20), primary_key=True) name = Column(String(20)) # “多”的一方的book表是通过外键关联到user表的: user_id = Column(String(20), ForeignKey('user.id')) 当我们查询一个User对象时,该对象的books属性将返回一个包含若干个Book对象的list。 小结 ORM框架的作用就是把数据库表的一行记录与一个对象互相做自动转换。 ORM框架的作用就是把数据库表的一行记录与一个对象互相做自动转换。 正确使用ORM的前提是了解关系数据库的原理。 您的鼓励是作者写作最大的动力 如果您认为本网站的教程质量不错,读后觉得收获很大,预期工资涨幅能超过30%,不妨小额赞助我一下,让我有 动力继续写出高质量的教程: Web开发 7次阅读 最早的软件都是运行在大型机上的,软件使用者通过“哑终端”登陆到大型机上去运行软件。后来随着PC机的兴 起,软件开始主要运行在桌面上,而数据库这样的软件运行在服务器端,这种Client/Server模式简称CS架构。 随着互联网的兴起,人们发现,CS架构不适合Web,最大的原因是Web应用程序的修改和升级非常迅速,而CS架 构需要每个客户端逐个升级桌面App,因此,Browser/Server模式开始流行,简称BS架构。 在BS架构下,客户端只需要浏览器,应用程序的逻辑和数据都存储在服务器端。浏览器只需要请求服务器,获取We b页面,并把Web页面展示给用户即可。 当然,Web页面也具有极强的交互性。由于Web页面是用HTML编写的,而HTML具备超强的表现力,并且,服务器 端升级后,客户端无需任何部署就可以使用到新的版本,因此,BS架构迅速流行起来。 今天,除了重量级的软件如Office,Photoshop等,大部分软件都以Web形式提供。比如,新浪提供的新闻、博 客、微博等服务,均是Web应用。 Web应用开发可以说是目前软件开发中最重要的部分。Web开发也经历了好几个阶段: 1.  静态Web页面:由文本编辑器直接编辑并生成静态的HTML页面,如果要修改Web页面的内容,就需要再次编 辑HTML源文件,早期的互联网Web页面就是静态的; 2.  CGI:由于静态Web页面无法与用户交互,比如用户填写了一个注册表单,静态Web页面就无法处理。要处理 用户发送的动态数据,出现了Common Gateway Interface,简称CGI,用C/C++编写。 3.  ASP/JSP/PHP:由于Web应用特点是修改频繁,用C/C++这样的低级语言非常不适合Web开发,而脚本语言由 于开发效率高,与HTML结合紧密,因此,迅速取代了CGI模式。ASP是微软推出的用VBScript脚本编程的Web 开发技术,而JSP用Java来编写脚本,PHP本身则是开源的脚本语言。 4.  MVC:为了解决直接用脚本语言嵌入HTML导致的可维护性差的问题,Web应用也引入了Model­View­Controll er的模式,来简化Web开发。ASP发展为ASP.Net,JSP和PHP也有一大堆MVC框架。 目前,Web开发技术仍在快速发展中,异步开发、新的MVVM前端技术层出不穷。 Python的诞生历史比Web还要早,由于Python是一种解释型的脚本语言,开发效率高,所以非常适合用来做Web开 发。 Python有上百种Web开发框架,有很多成熟的模板技术,选择Python开发Web应用,不但开发效率高,而且运行速 度快。 本章我们会详细讨论Python Web开发技术。 您的鼓励是作者写作最大的动力 如果您认为本网站的教程质量不错,读后觉得收获很大,预期工资涨幅能超过30%,不妨小额赞助我一下,让我有 动力继续写出高质量的教程: HTTP协议简介 19次阅读 在Web应用中,服务器把网页传给浏览器,实际上就是把网页的HTML代码发送给浏览器,让浏览器显示出来。而 浏览器和服务器之间的传输协议是HTTP,所以: HTML是一种用来定义网页的文本,会HTML,就可以编写网页; HTTP是在网络上传输HTML的协议,用于浏览器和服务器的通信。 在举例子之前,我们需要安装Google的Chrome浏览器。 为什么要使用Chrome浏览器而不是IE呢?因为IE实在是太慢了,并且,IE对于开发和调试Web应用程序完全是一点 用也没有。 我们需要在浏览器很方便地调试我们的Web应用,而Chrome提供了一套完整地调试工具,非常适合Web开发。 安装好Chrome浏览器后,打开Chrome,在菜单中选择“视图”,“开发者”,“开发者工具”,就可以显示开发者工具: Elements 显示网页的结构, Network 显示浏览器和服务器的通信。我们点 Network ,确保第一个小红灯亮着,Chro me就会记录所有浏览器和服务器之间的通信: 当我们在地址栏输入 www.sina.com.cn 时,浏览器将显示新浪的首页。在这个过程中,浏览器都干了哪些事情呢?通 过 Network 的记录,我们就可以知道。在 Network 中,定位到第一条记录,点击,右侧将显 示 Request Headers ,点击右侧的 view source ,我们就可以看到浏览器发给新浪服务器的请求: 示 Request Headers ,点击右侧的 view source ,我们就可以看到浏览器发给新浪服务器的请求: 最主要的头两行分析如下,第一行: GET / HTTP/1.1 GET 表示一个读取请求,将从服务器获得网页数据, / 表示URL的路径,URL总是以 / 开头, / 就表示首页,最后 的 HTTP/1.1 指示采用的HTTP协议版本是1.1。目前HTTP协议的版本就是1.1,但是大部分服务器也支持1.0版 本,主要区别在于1.1版本允许多个HTTP请求复用一个TCP连接,以加快传输速度。 从第二行开始,每一行都类似于 Xxx: abcdefg : Host: www.sina.com.cn 表示请求的域名是 www.sina.com.cn 。如果一台服务器有多个网站,服务器就需要通过 Host 来区分浏览器请求的是 哪个网站。 继续往下找到 Response Headers ,点击 view source ,显示服务器返回的原始响应数据: HTTP响应分为Header和Body两部分(Body是可选项),我们在 Network 中看到的Header最重要的几行如下: 200 OK 200 表示一个成功的响应,后面的 OK 是说明。失败的响应有 404 Not Found :网页不存 在, 500 Internal Server Error :服务器内部出错,等等。 Content-Type: text/html Content‐Type 指示响应的内容,这里是 text/html 表示HTML网页。请注意,浏览器就是依靠 Content‐Type 来判断 响应的内容是网页还是图片,是视频还是音乐。浏览器并不靠URL来判断响应的内容,所以,即使URL 是 http://example.com/abc.jpg ,它也不一定就是图片。 HTTP响应的Body就是HTML源码,我们在菜单栏选择“视图”,“开发者”,“查看网页源码”就可以在浏览器中直接查 看HTML源码: 当浏览器读取到新浪首页的HTML源码后,它会解析HTML,显示页面,然后,根据HTML里面的各种链接,再发送 HTTP请求给新浪服务器,拿到相应的图片、视频、Flash、JavaScript脚本、CSS等各种资源,最终显示出一个完 整的页面。所以我们在 Network 下面能看到很多额外的HTTP请求。 HTTP请求 跟踪了新浪的首页,我们来总结一下HTTP请求的流程: 步骤1:浏览器首先向服务器发送HTTP请求,请求包括: 方法:GET还是POST,GET仅请求资源,POST会附带用户数据; 路径:/full/url/path; 域名:由Host头指定:Host: www.sina.com.cn 以及其他相关的Header; 如果是POST,那么请求还包括一个Body,包含用户数据。 步骤2:服务器向浏览器返回HTTP响应,响应包括: 步骤2:服务器向浏览器返回HTTP响应,响应包括: 响应代码:200表示成功,3xx表示重定向,4xx表示客户端发送的请求有错误,5xx表示服务器端处理时发生了错 误; 响应类型:由Content­Type指定; 以及其他相关的Header; 通常服务器的HTTP响应会携带内容,也就是有一个Body,包含响应的内容,网页的HTML源码就在Body中。 步骤3:如果浏览器还需要继续向服务器请求其他资源,比如图片,就再次发出HTTP请求,重复步骤1、2。 Web采用的HTTP协议采用了非常简单的请求­响应模式,从而大大简化了开发。当我们编写一个页面时,我们只需 要在HTTP请求中把HTML发送出去,不需要考虑如何附带图片、视频等,浏览器如果需要请求图片和视频,它会发 送另一个HTTP请求,因此,一个HTTP请求只处理一个资源。 HTTP协议同时具备极强的扩展性,虽然浏览器请求的是 http://www.sina.com.cn/ 的首页,但是新浪在HTML中可 以链入其他服务器的资源,比 如 ,从而将请求压力分散到各个 服务器上,并且,一个站点可以链接到其他站点,无数个站点互相链接起来,就形成了World Wide Web,简称WW W。 HTTP格式 每个HTTP请求和响应都遵循相同的格式,一个HTTP包含Header和Body两部分,其中Body是可选的。 HTTP协议是一种文本协议,所以,它的格式也非常简单。HTTP GET请求的格式: GET /path HTTP/1.1 Header1: Value1 Header2: Value2 Header3: Value3 每个Header一行一个,换行符是 \r\n 。 HTTP POST请求的格式: POST /path HTTP/1.1 Header1: Value1 Header2: Value2 Header3: Value3 body data goes here... 当遇到连续两个 \r\n 时,Header部分结束,后面的数据全部是Body。 HTTP响应的格式: 200 OK Header1: Value1 Header2: Value2 Header3: Value3 body data goes here... HTTP响应如果包含body,也是通过 \r\n\r\n 来分隔的。请再次注意,Body的数据类型由 Content‐Type 头来确 定,如果是网页,Body就是文本,如果是图片,Body就是图片的二进制数据。 当存在 Content‐Encoding 时,Body数据是被压缩的,最常见的压缩方式是gzip,所以,看 到 Content‐Encoding: gzip 时,需要将Body数据先解压缩,才能得到真正的数据。压缩的目的在于减少Body的大 小,加快网络传输。 要详细了解HTTP协议,推荐“HTTP: The Definitive Guide”一书,非常不错,有中文译本: HTTP权威指南 您的鼓励是作者写作最大的动力 如果您认为本网站的教程质量不错,读后觉得收获很大,预期工资涨幅能超过30%,不妨小额赞助我一下,让我有 动力继续写出高质量的教程: HTML简介 19次阅读 网页就是HTML?这么理解大概没错。因为网页中不但包含文字,还有图片、视频、Flash小游戏,有复杂的排 版、动画效果,所以,HTML定义了一套语法规则,来告诉浏览器如何把一个丰富多彩的页面显示出来。 HTML长什么样?上次我们看了新浪首页的HTML源码,如果仔细数数,竟然有6000多行! 所以,学HTML,就不要指望从新浪入手了。我们来看看最简单的HTML长什么样: Hello

Hello, world!

可以用文本编辑器编写HTML,然后保存为 hello.html ,双击或者把文件拖到浏览器中,就可以看到效果: HTML文档就是一系列的Tag组成,最外层的Tag是 。规范的HTML也包 含 ... 和 ... (注意不要和HTTP的Header、Body搞混了),由于HTML是富文档模 型,所以,还有一系列的Tag用来表示链接、图片、表格、表单等等。 CSS简介 CSS是Cascading Style Sheets(层叠样式表)的简称,CSS用来控制HTML里的所有元素如何展现,比如,给标题 元素

加一个样式,变成48号字体,灰色,带阴影: Hello

Hello, world!

效果如下: JavaScript简介 JavaScript虽然名称有个Java,但它和Java真的一点关系没有。JavaScript是为了让HTML具有交互性而作为脚本语 言添加的,JavaScript既可以内嵌到HTML中,也可以从外部链接到HTML中。如果我们希望当用户点击标题时把标 题变成红色,就必须通过JavaScript来实现: Hello

Hello, world!

效果如下: 小结 如果要学习Web开发,首先要对HTML、CSS和JavaScript作一定的了解。HTML定义了页面的内容,CSS来控制页 面元素的样式,而JavaScript负责页面的交互逻辑。 讲解HTML、CSS和JavaScript就可以写3本书,对于优秀的Web开发人员来说,精通HTML、CSS和JavaScript是必 须的,这里推荐一个在线学习网站w3schools: http://www.w3schools.com/ 以及一个对应的中文版本: http://www.w3school.com.cn/ 当我们用Python或者其他语言开发Web应用时,我们就是要在服务器端动态创建出HTML,这样,浏览器就会向不 同的用户显示出不同的Web页面。 您的鼓励是作者写作最大的动力 如果您认为本网站的教程质量不错,读后觉得收获很大,预期工资涨幅能超过30%,不妨小额赞助我一下,让我有 动力继续写出高质量的教程: WSGI接口 26次阅读 了解了HTTP协议和HTML文档,我们其实就明白了一个Web应用的本质就是: 1.  浏览器发送一个HTTP请求; 2.  服务器收到请求,生成一个HTML文档; 3.  服务器把HTML文档作为HTTP响应的Body发送给浏览器; 4.  浏览器收到HTTP响应,从HTTP Body取出HTML文档并显示。 所以,最简单的Web应用就是先把HTML用文件保存好,用一个现成的HTTP服务器软件,接收用户请求,从文件中 读取HTML,返回。Apache、Nginx、Lighttpd等这些常见的静态服务器就是干这件事情的。 如果要动态生成HTML,就需要把上述步骤自己来实现。不过,接受HTTP请求、解析HTTP请求、发送HTTP响应都 是苦力活,如果我们自己来写这些底层代码,还没开始写动态HTML呢,就得花个把月去读HTTP规范。 正确的做法是底层代码由专门的服务器软件实现,我们用Python专注于生成HTML文档。因为我们不希望接触到TC P连接、HTTP原始请求和响应格式,所以,需要一个统一的接口,让我们专心用Python编写Web业务。 这个接口就是WSGI:Web Server Gateway Interface。 WSGI接口定义非常简单,它只要求Web开发者实现一个函数,就可以响应HTTP请求。我们来看一个最简单的Web 版本的“Hello, web!”: def application(environ, start_response): start_response('200 OK', [('Content-Type', 'text/html')]) return '

Hello, web!

' return '

Hello, web!

' 上面的 application() 函数就是符合WSGI标准的一个HTTP处理函数,它接收两个参数: environ:一个包含所有HTTP请求信息的 dict 对象; start_response:一个发送HTTP响应的函数。 在 application() 函数中,调用: start_response('200 OK', [('Content-Type', 'text/html')]) 就发送了HTTP响应的Header,注意Header只能发送一次,也就是只能调用一次 start_response() 函 数。 start_response() 函数接收两个参数,一个是HTTP响应码,一个是一组 list 表示的HTTP Header,每个Hea der用一个包含两个 str 的 tuple 表示。 通常情况下,都应该把 Content‐Type 头发送给浏览器。其他很多常用的HTTP Header也应该发送。 然后,函数的返回值 '

Hello, web!

' 将作为HTTP响应的Body发送给浏览器。 有了WSGI,我们关心的就是如何从 environ 这个 dict 对象拿到HTTP请求信息,然后构造HTML,通 过 start_response() 发送Header,最后返回Body。 整个 application() 函数本身没有涉及到任何解析HTTP的部分,也就是说,底层代码不需要我们自己编写,我们只 负责在更高层次上考虑如何响应请求就可以了。 不过,等等,这个 application() 函数怎么调用?如果我们自己调用,两个参数 environ 和 start_response 我们没 法提供,返回的 str 也没法发给浏览器。 所以 application() 函数必须由WSGI服务器来调用。有很多符合WSGI规范的服务器,我们可以挑选一个来用。但 是现在,我们只想尽快测试一下我们编写的 application() 函数真的可以把HTML输出到浏览器,所以,要赶紧找一 个最简单的WSGI服务器,把我们的Web应用程序跑起来。 好消息是Python内置了一个WSGI服务器,这个模块叫wsgiref,它是用纯Python编写的WSGI服务器的参考实现。所 谓“参考实现”是指该实现完全符合WSGI标准,但是不考虑任何运行效率,仅供开发和测试使用。 运行WSGI服务 我们先编写 hello.py ,实现Web应用程序的WSGI处理函数: # hello.py def application(environ, start_response): start_response('200 OK', [('Content-Type', 'text/html')]) return '

Hello, web!

' 然后,再编写一个 server.py ,负责启动WSGI服务器,加载 application() 函数: # server.py # 从wsgiref模块导入: from wsgiref.simple_server import make_server # 导入我们自己编写的application函数: from hello import application # 创建一个服务器,IP地址为空,端口是8000,处理函数是application: httpd = make_server('', 8000, application) print "Serving HTTP on port 8000..." # 开始监听HTTP请求: httpd.serve_forever() 确保以上两个文件在同一个目录下,然后在命令行输入 python server.py 来启动WSGI服务器: 注意:如果 8000 端口已被其他程序占用,启动将失败,请修改成其他端口。 启动成功后,打开浏览器,输入 http://localhost:8000/ ,就可以看到结果了: 在命令行可以看到wsgiref打印的log信息: 按 Ctrl+C 终止服务器。 如果你觉得这个Web应用太简单了,可以稍微改造一下,从 environ 里读取 PATH_INFO ,这样可以显示更加动态的 内容: # hello.py def application(environ, start_response): start_response('200 OK', [('Content-Type', 'text/html')]) return '

Hello, %s!

' % (environ['PATH_INFO'][1:] or 'web') 你可以在地址栏输入用户名作为URL的一部分,将返回 Hello, xxx! : 是不是有点Web App的感觉了? 小结 无论多么复杂的Web应用程序,入口都是一个WSGI处理函数。HTTP请求的所有输入信息都可以通过 environ 获 得,HTTP响应的输出都可以通过 start_response() 加上函数返回值作为Body。 复杂的Web应用程序,光靠一个WSGI函数来处理还是太底层了,我们需要在WSGI之上再抽象出Web框架,进一步 简化Web开发。 您的鼓励是作者写作最大的动力 如果您认为本网站的教程质量不错,读后觉得收获很大,预期工资涨幅能超过30%,不妨小额赞助我一下,让我有 动力继续写出高质量的教程: 使用Web框架 36次阅读 了解了WSGI框架,我们发现:其实一个Web App,就是写一个WSGI的处理函数,针对每个HTTP请求进行响应。 但是如何处理HTTP请求不是问题,问题是如何处理100个不同的URL。 每一个URL可以对应GET和POST请求,当然还有PUT、DELETE等请求,但是我们通常只考虑最常见的GET和POS T请求。 一个最简单的想法是从 environ 变量里取出HTTP请求的信息,然后逐个判断: def application(environ, start_response): method = environ['REQUEST_METHOD'] path = environ['PATH_INFO'] if method=='GET' and path=='/': return handle_home(environ, start_response) if method=='POST' and path='/signin': return handle_signin(environ, start_response) ... 只是这么写下去代码是肯定没法维护了。 代码这么写没法维护的原因是因为WSGI提供的接口虽然比HTTP接口高级了不少,但和Web App的处理逻辑比,还 是比较低级,我们需要在WSGI接口之上能进一步抽象,让我们专注于用一个函数处理一个URL,至于URL到函数的 映射,就交给Web框架来做。 映射,就交给Web框架来做。 由于用Python开发一个Web框架十分容易,所以Python有上百个开源的Web框架。这里我们先不讨论各种Web框架 的优缺点,直接选择一个比较流行的Web框架——Flask来使用。 用Flask编写Web App比WSGI接口简单(这不是废话么,要是比WSGI还复杂,用框架干嘛?),我们先 用 easy_install 或者 pip 安装Flask: $ easy_install flask 然后写一个 app.py ,处理3个URL,分别是: GET / :首页,返回 Home ; GET /signin :登录页,显示登录表单; POST /signin :处理登录表单,显示登录结果。 注意噢,同一个URL /signin 分别有GET和POST两种请求,映射到两个处理函数中。 Flask通过Python的装饰器在内部自动地把URL和函数给关联起来,所以,我们写出来的代码就像这样: from flask import Flask from flask import request app = Flask(__name__) @app.route('/', methods=['GET', 'POST']) def home(): return '

Home

' @app.route('/signin', methods=['GET']) def signin_form(): return '''

''' @app.route('/signin', methods=['POST']) def signin(): # 需要从request对象读取表单内容: if request.form['username']=='admin' and request.form['password']=='password': return '

Hello, admin!

' return '

Bad username or password.

' if __name__ == '__main__': app.run() 运行 python app.py ,Flask自带的Server在端口 5000 上监听: $ python app.py * Running on http://127.0.0.1:5000/ 打开浏览器,输入首页地址 http://localhost:5000/ : 打开浏览器,输入首页地址 http://localhost:5000/ : 首页显示正确! 再在浏览器地址栏输入 http://localhost:5000/signin ,会显示登录表单: 输入预设的用户名 admin 和口令 password ,登录成功: 输入其他错误的用户名和口令,登录失败: 实际的Web App应该拿到用户名和口令后,去数据库查询再比对,来判断用户是否能登录成功。 除了Flask,常见的Python Web框架还有: Django:全能型Web框架; web.py:一个小巧的Web框架; Bottle:和Flask类似的Web框架; Tornado:Facebook的开源异步Web框架。 当然了,因为开发Python的Web框架也不是什么难事,我们后面也会自己开发一个Web框架。 小结 小结 有了Web框架,我们在编写Web应用时,注意力就从WSGI处理函数转移到URL+对应的处理函数,这样,编写Web  App就更加简单了。 在编写URL处理函数时,除了配置URL外,从HTTP请求拿到用户数据也是非常重要的。Web框架都提供了自己的A PI来实现这些功能。Flask通过 request.form['name'] 来获取表单的内容。 您的鼓励是作者写作最大的动力 如果您认为本网站的教程质量不错,读后觉得收获很大,预期工资涨幅能超过30%,不妨小额赞助我一下,让我有 动力继续写出高质量的教程: 使用模板 15次阅读 Web框架把我们从WSGI中拯救出来了。现在,我们只需要不断地编写函数,带上URL,就可以继续Web App的开 发了。 但是,Web App不仅仅是处理逻辑,展示给用户的页面也非常重要。在函数中返回一个包含HTML的字符串,简单 的页面还可以,但是,想想新浪首页的6000多行的HTML,你确信能在Python的字符串中正确地写出来么?反正我 是做不到。 俗话说得好,不懂前端的Python工程师不是好的产品经理。有Web开发经验的同学都明白,Web App最复杂的部分 就在HTML页面。HTML不仅要正确,还要通过CSS美化,再加上复杂的JavaScript脚本来实现各种交互和动画效 果。总之,生成HTML页面的难度很大。 由于在Python代码里拼字符串是不现实的,所以,模板技术出现了。 使用模板,我们需要预先准备一个HTML文档,这个HTML文档不是普通的HTML,而是嵌入了一些变量和指令,然 后,根据我们传入的数据,替换后,得到最终的HTML,发送给用户: 这就是传说中的MVC:Model­View­Controller,中文名“模型­视图­控制器”。 Python处理URL的函数就是C:Controller,Controller负责业务逻辑,比如检查用户名是否存在,取出用户信息等 等; 包含变量 {{ name }} 的模板就是V:View,View负责显示逻辑,通过简单地替换一些变量,View最终输出的就是用 户看到的HTML。 MVC中的Model在哪?Model是用来传给View的,这样View在替换变量的时候,就可以从Model中取出相应的数 据。 上面的例子中,Model就是一个 dict : { 'name': 'Michael' } 只是因为Python支持关键字参数,很多Web框架允许传入关键字参数,然后,在框架内部组装出一个 dict 作为Mo del。 现在,我们把上次直接输出字符串作为HTML的例子用高端大气上档次的MVC模式改写一下: from flask import Flask, request, render_template app = Flask(__name__) @app.route('/', methods=['GET', 'POST']) def home(): return render_template('home.html') @app.route('/signin', methods=['GET']) def signin_form(): return render_template('form.html') @app.route('/signin', methods=['POST']) def signin(): username = request.form['username'] password = request.form['password'] if username=='admin' and password=='password': return render_template('signin-ok.html', username=username) return render_template('form.html', message='Bad username or password', username=username) if __name__ == '__main__': app.run() Flask通过 render_template() 函数来实现模板的渲染。和Web框架类似,Python的模板也有很多种。Flask默认支 持的模板是jinja2,所以我们先直接安装jinja2: $ easy_install jinja2 然后,开始编写jinja2模板: home.html 用来显示首页的模板: 用来显示首页的模板: Home

Home

form.html 用来显示登录表单的模板: Please Sign In {% if message %}

{{ message }}

{% endif %}
Please sign in:

signin­ok.html 登录成功的模板: Welcome, {{ username }}

Welcome, {{ username }}!

登录失败的模板呢?我们在 form.html 中加了一点条件判断,把 form.html 重用为登录失败的模板。 最后,一定要把模板放到正确的 templates 目录下, templates 和 app.py 在同级目录下: 启动 python app.py ,看看使用模板的页面效果: 通过MVC,我们在Python代码中处理M:Model和C:Controller,而V:View是通过模板处理的,这样,我们就成 功地把Python代码和HTML代码最大限度地分离了。 使用模板的另一大好处是,模板改起来很方便,而且,改完保存后,刷新浏览器就能看到最新的效果,这对于调试H TML、CSS和JavaScript的前端工程师来说实在是太重要了。 在Jinja2模板中,我们用 {{ name }} 表示一个需要替换的变量。很多时候,还需要循环、条件判断等指令语句,在Ji nja2中,用 {% ... %} 表示指令。 比如循环输出页码: {% for i in page_list %} {{ i }} {% endfor %} 如果 page_list 是一个list: [1, 2, 3, 4, 5] ,上面的模板将输出5个超链接。 除了Jinja2,常见的模板还有: Mako:用 <% ... %> 和 ${xxx} 的一个模板; Cheetah:也是用 <% ... %> 和 ${xxx} 的一个模板; Django:Django是一站式框架,内置一个用 {% ... %} 和 {{ xxx }} 的模板。 小结 有了MVC,我们就分离了Python代码和HTML代码。HTML代码全部放到模板里,写起来更有效率。 您的鼓励是作者写作最大的动力 如果您认为本网站的教程质量不错,读后觉得收获很大,预期工资涨幅能超过30%,不妨小额赞助我一下,让我有 动力继续写出高质量的教程: 协程 17次阅读 协程,又称微线程,纤程。英文名Coroutine。 协程的概念很早就提出来了,但直到最近几年才在某些语言(如Lua)中得到广泛应用。 子程序,或者称为函数,在所有语言中都是层级调用,比如A调用B,B在执行过程中又调用了C,C执行完毕返 回,B执行完毕返回,最后是A执行完毕。 所以子程序调用是通过栈实现的,一个线程就是执行一个子程序。 子程序调用总是一个入口,一次返回,调用顺序是明确的。而协程的调用和子程序不同。 协程看上去也是子程序,但执行过程中,在子程序内部可中断,然后转而执行别的子程序,在适当的时候再返回来 接着执行。 注意,在一个子程序中中断,去执行其他子程序,不是函数调用,有点类似CPU的中断。比如子程序A、B: def A(): print '1' print '2' print '3' def B(): print 'x' print 'y' print 'z' 假设由协程执行,在执行A的过程中,可以随时中断,去执行B,B也可能在执行过程中中断再去执行A,结果可能 是: 1 2 x y 3 z 但是在A中是没有调用B的,所以协程的调用比函数调用理解起来要难一些。 看起来A、B的执行有点像多线程,但协程的特点在于是一个线程执行,那和多线程比,协程有何优势? 最大的优势就是协程极高的执行效率。因为子程序切换不是线程切换,而是由程序自身控制,因此,没有线程切换 的开销,和多线程比,线程数量越多,协程的性能优势就越明显。 第二大优势就是不需要多线程的锁机制,因为只有一个线程,也不存在同时写变量冲突,在协程中控制共享资源不 加锁,只需要判断状态就好了,所以执行效率比多线程高很多。 因为协程是一个线程执行,那怎么利用多核CPU呢?最简单的方法是多进程+协程,既充分利用多核,又充分发挥协 程的高效率,可获得极高的性能。 Python对协程的支持还非常有限,用在generator中的yield可以一定程度上实现协程。虽然支持不完全,但已经可以 发挥相当大的威力了。 来看例子: 传统的生产者­消费者模型是一个线程写消息,一个线程取消息,通过锁机制控制队列和等待,但一不小心就可能死 锁。 如果改用协程,生产者生产消息后,直接通过yield跳转到消费者开始执行,待消费者执行完毕后,切换回生产者继 续生产,效率极高: import time def consumer(): r = '' while True: n = yield r if not n: return print('[CONSUMER] Consuming %s...' % n) time.sleep(1) r = '200 OK' def produce(c): c.next() n = 0 while n < 5: n = n + 1 print('[PRODUCER] Producing %s...' % n) r = c.send(n) print('[PRODUCER] Consumer return: %s' % r) c.close() if __name__=='__main__': c = consumer() produce(c) 执行结果: [PRODUCER] Producing 1... [CONSUMER] Consuming 1... [PRODUCER] Consumer return: 200 OK [PRODUCER] Producing 2... [CONSUMER] Consuming 2... [PRODUCER] Consumer return: 200 OK [PRODUCER] Producing 3... [CONSUMER] Consuming 3... [PRODUCER] Consumer return: 200 OK [PRODUCER] Producing 4... [PRODUCER] Producing 4... [CONSUMER] Consuming 4... [PRODUCER] Consumer return: 200 OK [PRODUCER] Producing 5... [CONSUMER] Consuming 5... [PRODUCER] Consumer return: 200 OK 注意到consumer函数是一个generator(生成器),把一个consumer传入produce后: 1.  首先调用c.next()启动生成器; 2.  然后,一旦生产了东西,通过c.send(n)切换到consumer执行; 3.  consumer通过yield拿到消息,处理,又通过yield把结果传回; 4.  produce拿到consumer处理的结果,继续生产下一条消息; 5.  produce决定不生产了,通过c.close()关闭consumer,整个过程结束。 整个流程无锁,由一个线程执行,produce和consumer协作完成任务,所以称为“协程”,而非线程的抢占式多任 务。 最后套用Donald Knuth的一句话总结协程的特点: “子程序就是协程的一种特例。” 您的鼓励是作者写作最大的动力 如果您认为本网站的教程质量不错,读后觉得收获很大,预期工资涨幅能超过30%,不妨小额赞助我一下,让我有 动力继续写出高质量的教程: gevent 35次阅读 Python通过 yield 提供了对协程的基本支持,但是不完全。而第三方的gevent为Python提供了比较完善的协程支 持。 gevent是第三方库,通过greenlet实现协程,其基本思想是: 当一个greenlet遇到IO操作时,比如访问网络,就自动切换到其他的greenlet,等到IO操作完成,再在适当的时候切 换回来继续执行。由于IO操作非常耗时,经常使程序处于等待状态,有了gevent为我们自动切换协程,就保证总有g reenlet在运行,而不是等待IO。 由于切换是在IO操作时自动完成,所以gevent需要修改Python自带的一些标准库,这一过程在启动时通过monkey p atch完成: from gevent import monkey; monkey.patch_socket() import gevent def f(n): for i in range(n): print gevent.getcurrent(), i print gevent.getcurrent(), i g1 = gevent.spawn(f, 5) g2 = gevent.spawn(f, 5) g3 = gevent.spawn(f, 5) g1.join() g2.join() g3.join() 运行结果: 0 1 2 3 4 0 1 2 3 4 0 1 2 3 4 可以看到,3个greenlet是依次运行而不是交替运行。 要让greenlet交替运行,可以通过 gevent.sleep() 交出控制权: def f(n): for i in range(n): print gevent.getcurrent(), i gevent.sleep(0) 执行结果: 0 0 0 1 1 1 2 2 2 3 3 3 4 4 4 3个greenlet交替运行, 把循环次数改为500000,让它们的运行时间长一点,然后在操作系统的进程管理器中看,线程数只有1个。 当然,实际代码里,我们不会用 gevent.sleep() 去切换协程,而是在执行到IO操作时,gevent自动切换,代码如 下: from gevent import monkey; monkey.patch_all() import gevent import urllib2 def f(url): print('GET: %s' % url) resp = urllib2.urlopen(url) data = resp.read() print('%d bytes received from %s.' % (len(data), url)) gevent.joinall([ gevent.spawn(f, 'https://www.python.org/'), gevent.spawn(f, 'https://www.yahoo.com/'), gevent.spawn(f, 'https://github.com/'), ]) 运行结果: GET: https://www.python.org/ GET: https://www.yahoo.com/ GET: https://github.com/ 45661 bytes received from https://www.python.org/. 14823 bytes received from https://github.com/. 304034 bytes received from https://www.yahoo.com/. 从结果看,3个网络操作是并发执行的,而且结束顺序不同,但只有一个线程。 小结 使用gevent,可以获得极高的并发性能,但gevent只能在Unix/Linux下运行,在Windows下不保证正常安装和运 行。 由于gevent是基于IO切换的协程,所以最神奇的是,我们编写的Web App代码,不需要引入gevent的包,也不需要 改任何代码,仅仅在部署的时候,用一个支持gevent的WSGI服务器,立刻就获得了数倍的性能提升。具体部署方式 可以参考后续“实战”­“部署Web App”一节。 您的鼓励是作者写作最大的动力 如果您认为本网站的教程质量不错,读后觉得收获很大,预期工资涨幅能超过30%,不妨小额赞助我一下,让我有 动力继续写出高质量的教程: 实战 98次阅读 98次阅读 看完了教程,是不是有这么一种感觉:看的时候觉得很简单,照着教程敲代码也没啥大问题。 于是准备开始独立写代码,就发现不知道从哪开始下手了。 这种情况是完全正常的。好比学写作文,学的时候觉得简单,写的时候就无从下笔了。 虽然这个教程是面向小白的零基础Python教程,但是我们的目标不是学到60分,而是学到90分。 所以,用Python写一个真正的Web App吧! 目标 我们设定的实战目标是一个Blog网站,包含日志、用户和评论3大部分。 很多童鞋会想,这是不是太简单了? 比如webpy.org上就提供了一个Blog的例子,目测也就100行代码。 但是,这样的页面: 你拿得出手么? 我们要写出用户真正看得上眼的页面,首页长得像这样: 评论区: 还有极其强大的后台管理页面: 是不是一下子变得高端大气上档次了? 项目名称 必须是高端大气上档次的名称,命名为 awesome‐python‐webapp 。 项目计划 项目计划开发周期为16天。每天,你需要完成教程中的内容。如果你觉得编写代码难度实在太大,可以参考一下当 天在GitHub上的代码。 第N天的代码在 https://github.com/michaelliao/awesome‐python‐webapp/tree/day‐N 上。比如第1天就是: https://github.com/michaelliao/awesome­python­webapp/tree/day­01 以此类推。 要预览 awesome‐python‐webapp 的最终页面效果,请猛击: awesome.liaoxuefeng.com 您的鼓励是作者写作最大的动力 如果您认为本网站的教程质量不错,读后觉得收获很大,预期工资涨幅能超过30%,不妨小额赞助我一下,让我有 动力继续写出高质量的教程: Day 1 ­ 搭建开发环境 180次阅读 搭建开发环境 首先,确认系统安装的Python版本是2.7.x: $ python --version Python 2.7.5 然后,安装开发Web App需要的第三方库: 前端模板引擎jinja2: $ easy_install jinja2 MySQL 5.x数据库,从官方网站下载并安装,安装完毕后,请务必牢记root口令。为避免遗忘口令,建议直接把root 口令设置为 password ; MySQL的Python驱动程序mysql­connector­python: $ easy_install mysql-connector-python 项目结构 选择一个工作目录,然后,我们建立如下的目录结构: awesome-python-webapp/ <-- 根目录 | +- backup/ <-- 备份目录 | +- conf/ <-- 配置文件 | +- dist/ <-- 打包目录 | +- www/ <-- Web目录,存放.py文件 | | | +- static/ <-- 存放静态文件 | | | +- templates/ <-- 存放模板文件 | +- LICENSE <-- 代码LICENSE 创建好项目的目录结构后,建议同时建立Git仓库并同步至GitHub,保证代码修改的安全。 要了解Git和GitHub的用法,请移步Git教程。 开发工具 自备,推荐用Sublime Text。 您的鼓励是作者写作最大的动力 如果您认为本网站的教程质量不错,读后觉得收获很大,预期工资涨幅能超过30%,不妨小额赞助我一下,让我有 动力继续写出高质量的教程: Day 2 ­ 编写数据库模块 151次阅读 在一个Web App中,所有数据,包括用户信息、发布的日志、评论等,都存储在数据库中。在awesome­python­ap p中,我们选择MySQL作为数据库。 Web App里面有很多地方都要访问数据库。访问数据库需要创建数据库连接、游标对象,然后执行SQL语句,最后 处理异常,清理资源。这些访问数据库的代码如果分散到各个函数中,势必无法维护,也不利于代码复用。 此外,在一个Web App中,有多个用户会同时访问,系统以多进程或多线程模式来处理每个用户的请求。假设以多 线程为例,每个线程在访问数据库时,都必须创建仅属于自身的连接,对别的线程不可见,否则,就会造成数据库 操作混乱。 所以,我们还要创建一个简单可靠的数据库访问模型,在一个线程中,能既安全又简单地操作数据库。 为什么不选择SQLAlchemy?SQLAlchemy太庞大,过度地面向对象设计导致API太复杂。 所以我们决定自己设计一个封装基本的SELECT、INSERT、UPDATE和DELETE操作的db模块: transwarp.db 。 设计db接口 设计底层模块的原则是,根据上层调用者设计简单易用的API接口,然后,实现模块内部代码。 假设 transwarp.db 模块已经编写完毕,我们希望以这样的方式来调用它: 首先,初始化数据库连接信息,通过 create_engine() 函数: from transwarp import db db.create_engine(user='root', password='password', database='test', host='127.0.0.1', port=3306) 然后,就可以直接操作SQL了。 如果需要做一个查询,可以直接调用 select() 方法,返回的是list,每一个元素是用dict表示的对应的行: users = db.select('select * from user') # users => # [ # { "id": 1, "name": "Michael"}, # { "id": 2, "name": "Bob"}, # { "id": 3, "name": "Adam"} # ] 如果要执行INSERT、UPDATE或DELETE操作,执行 update() 方法,返回受影响的行数: n = db.update('insert into user(id, name) values(?, ?)', 4, 'Jack') update() 函数签名为: update(sql, *args) 统一用 ? 作为占位符,并传入可变参数来绑定,从根本上避免SQL注入攻击。 每个 select() 或 update() 调用,都隐含地自动打开并关闭了数据库连接,这样,上层调用者就完全不必关心数据 库底层连接。 但是,如果要在一个数据库连接里执行多个SQL语句怎么办?我们用一个with语句实现: with db.connection(): db.select('...') db.update('...') db.update('...') db.update('...') 如果要在一个数据库事务中执行多个SQL语句怎么办?我们还是用一个with语句实现: with db.transaction(): db.select('...') db.update('...') db.update('...') 实现db模块 由于模块是全局对象,模块变量是全局唯一变量,所以,有两个重要的模块变量: # db.py # 数据库引擎对象: class _Engine(object): def __init__(self, connect): self._connect = connect def connect(self): return self._connect() engine = None # 持有数据库连接的上下文对象: class _DbCtx(threading.local): def __init__(self): self.connection = None self.transactions = 0 def is_init(self): return not self.connection is None def init(self): self.connection = _LasyConnection() self.transactions = 0 def cleanup(self): self.connection.cleanup() self.connection = None def cursor(self): return self.connection.cursor() _db_ctx = _DbCtx() 由于 _db_ctx 是 threadlocal 对象,所以,它持有的数据库连接对于每个线程看到的都是不一样的。任何一个线程 都无法访问到其他线程持有的数据库连接。 有了这两个全局变量,我们继续实现数据库连接的上下文,目的是自动获取和释放连接: class _ConnectionCtx(object): def __enter__(self): def __enter__(self): global _db_ctx self.should_cleanup = False if not _db_ctx.is_init(): _db_ctx.init() self.should_cleanup = True return self def __exit__(self, exctype, excvalue, traceback): global _db_ctx if self.should_cleanup: _db_ctx.cleanup() def connection(): return _ConnectionCtx() 定义了 __enter__() 和 __exit__() 的对象可以用于with语句,确保任何情况下 __exit__() 方法可以被调用。 把 _ConnectionCtx 的作用域作用到一个函数调用上,可以这么写: with connection(): do_some_db_operation() 但是更简单的写法是写个@decorator: @with_connection def do_some_db_operation(): pass 这样,我们实现 select() 、 update() 方法就更简单了: @with_connection def select(sql, *args): pass @with_connection def update(sql, *args): pass 注意到Connection对象是存储在 _DbCtx 这个 threadlocal 对象里的,因此,嵌套使用 with connection() 也没有问 题。 _DbCtx 永远检测当前是否已存在Connection,如果存在,直接使用,如果不存在,则打开一个新的Connectio n。 对于transaction也是类似的, with transaction() 定义了一个数据库事务: with db.transaction(): db.select('...') db.update('...') db.update('...') 函数作用域的事务也有一个简化的@decorator: @with_transaction def do_in_transaction(): pass 事务也可以嵌套,内层事务会自动合并到外层事务中,这种事务模型足够满足99%的需求。 事务嵌套比Connection嵌套复杂一点,因为事务嵌套需要计数,每遇到一层嵌套就+1,离开一层嵌套就­1,最后到0 时提交事务: class _TransactionCtx(object): def __enter__(self): global _db_ctx self.should_close_conn = False if not _db_ctx.is_init(): _db_ctx.init() self.should_close_conn = True _db_ctx.transactions = _db_ctx.transactions + 1 return self def __exit__(self, exctype, excvalue, traceback): global _db_ctx _db_ctx.transactions = _db_ctx.transactions - 1 try: if _db_ctx.transactions==0: if exctype is None: self.commit() else: self.rollback() finally: if self.should_close_conn: _db_ctx.cleanup() def commit(self): global _db_ctx try: _db_ctx.connection.commit() except: _db_ctx.connection.rollback() raise def rollback(self): global _db_ctx _db_ctx.connection.rollback() 最后,把 select() 和 update() 方法实现了,db模块就完成了。 您的鼓励是作者写作最大的动力 如果您认为本网站的教程质量不错,读后觉得收获很大,预期工资涨幅能超过30%,不妨小额赞助我一下,让我有 动力继续写出高质量的教程: Day 3 ­ 编写ORM Day 3 ­ 编写ORM 61次阅读 有了db模块,操作数据库直接写SQL就很方便。但是,我们还缺少ORM。如果有了ORM,就可以用类似这样的语 句获取User对象: user = User.get('123') 而不是写SQL然后再转换成User对象: u = db.select_one('select * from users where id=?', '123') user = User(**u) 所以我们开始编写ORM模块: transwarp.orm 。 设计ORM接口 和设计db模块类似,设计ORM也是从上层调用者角度来设计。 我们先考虑如何定义一个User对象,然后把数据库表 users 和它关联起来。 from transwarp.orm import Model, StringField, IntegerField class User(Model): __table__ = 'users' id = IntegerField(primary_key=True) name = StringField() 注意到定义在 User 类中的 __table__ 、 id 和 name 是类的属性,不是实例的属性。所以,在类级别上定义的属性 用来描述 User 对象和表的映射关系,而实例属性必须通过 __init__() 方法去初始化,所以两者互不干扰: # 创建实例: user = User(id=123, name='Michael') # 存入数据库: user.insert() 实现ORM模块 有了定义,我们就可以开始实现ORM模块。 首先要定义的是所有ORM映射的基类 Model : class Model(dict): __metaclass__ = ModelMetaclass def __init__(self, **kw): super(Model, self).__init__(**kw) def __getattr__(self, key): try: try: return self[key] except KeyError: raise AttributeError(r"'Dict' object has no attribute '%s'" % key) def __setattr__(self, key, value): self[key] = value Model 从 dict 继承,所以具备所有 dict 的功能,同时又实现了特殊方法 __getattr__() 和 __setattr__() ,所以 又可以像引用普通字段那样写: >>> user['id'] 123 >>> user.id 123 Model 只是一个基类,如何将具体的子类如 User 的映射信息读取出来呢?答案就是通过metaclas s: ModelMetaclass : class ModelMetaclass(type): def __new__(cls, name, bases, attrs): mapping = ... # 读取cls的Field字段 primary_key = ... # 查找primary_key字段 __table__ = cls.__talbe__ # 读取cls的__table__字段 # 给cls增加一些字段: attrs['__mapping__'] = mapping attrs['__primary_key__'] = __primary_key__ attrs['__table__'] = __table__ return type.__new__(cls, name, bases, attrs) 这样,任何继承自 Model 的类(比如 User ),会自动通过 ModelMetaclass 扫描映射关系,并存储到自身的class 中。 然后,我们往 Model 类添加class方法,就可以让所有子类调用class方法: class Model(dict): ... @classmethod def get(cls, pk): d = db.select_one('select * from %s where %s=?' % (cls.__table__, cls.__primary_key__.name), pk) return cls(**d) if d else None User 类就可以通过类方法实现主键查找: user = User.get('123') 往 Model 类添加实例方法,就可以让所有子类调用实例方法: class Model(dict): ... def insert(self): params = {} for k, v in self.__mappings__.iteritems(): params[v.name] = getattr(self, k) db.insert(self.__table__, **params) return self 这样,就可以把一个 User 实例存入数据库: user = User(id=123, name='Michael') user.insert() 最后一步是完善ORM,对于查找,我们可以实现以下方法: find_first() find_all() find_by() 对于count,可以实现: count_all() count_by() 以及 update() 和 delete() 方法。 最后看看我们实现的ORM模块一共多少行代码?加上注释和doctest才仅仅300多行。用Python写一个ORM是不是 很容易呢? 您的鼓励是作者写作最大的动力 如果您认为本网站的教程质量不错,读后觉得收获很大,预期工资涨幅能超过30%,不妨小额赞助我一下,让我有 动力继续写出高质量的教程: Day 4 ­ 编写Model 9次阅读 有了ORM,我们就可以把Web App需要的3个表用 Model 表示出来: import time, uuid from transwarp.db import next_id from transwarp.orm import Model, StringField, BooleanField, FloatField, TextField class User(Model): __table__ = 'users' __table__ = 'users' id = StringField(primary_key=True, default=next_id, ddl='varchar(50)') email = StringField(updatable=False, ddl='varchar(50)') password = StringField(ddl='varchar(50)') admin = BooleanField() name = StringField(ddl='varchar(50)') image = StringField(ddl='varchar(500)') created_at = FloatField(updatable=False, default=time.time) class Blog(Model): __table__ = 'blogs' id = StringField(primary_key=True, default=next_id, ddl='varchar(50)') user_id = StringField(updatable=False, ddl='varchar(50)') user_name = StringField(ddl='varchar(50)') user_image = StringField(ddl='varchar(500)') name = StringField(ddl='varchar(50)') summary = StringField(ddl='varchar(200)') content = TextField() created_at = FloatField(updatable=False, default=time.time) class Comment(Model): __table__ = 'comments' id = StringField(primary_key=True, default=next_id, ddl='varchar(50)') blog_id = StringField(updatable=False, ddl='varchar(50)') user_id = StringField(updatable=False, ddl='varchar(50)') user_name = StringField(ddl='varchar(50)') user_image = StringField(ddl='varchar(500)') content = TextField() created_at = FloatField(updatable=False, default=time.time) 在编写ORM时,给一个Field增加一个 default 参数可以让ORM自己填入缺省值,非常方便。并且,缺省值可以作 为函数对象传入,在调用 insert() 时自动计算。 例如,主键 id 的缺省值是函数 next_id ,创建时间 created_at 的缺省值是函数 time.time ,可以自动设置当前日 期和时间。 日期和时间用 float 类型存储在数据库中,而不是 datetime 类型,这么做的好处是不必关心数据库的时区以及时区 转换问题,排序非常简单,显示的时候,只需要做一个 float 到 str 的转换,也非常容易。 初始化数据库表 如果表的数量很少,可以手写创建表的SQL脚本: -- schema.sql drop database if exists awesome; create database awesome; use awesome; grant select, insert, update, delete on awesome.* to 'www-data'@'localhost' identified by 'www-data'; grant select, insert, update, delete on awesome.* to 'www-data'@'localhost' identified by 'www-data'; create table users ( `id` varchar(50) not null, `email` varchar(50) not null, `password` varchar(50) not null, `admin` bool not null, `name` varchar(50) not null, `image` varchar(500) not null, `created_at` real not null, unique key `idx_email` (`email`), key `idx_created_at` (`created_at`), primary key (`id`) ) engine=innodb default charset=utf8; create table blogs ( `id` varchar(50) not null, `user_id` varchar(50) not null, `user_name` varchar(50) not null, `user_image` varchar(500) not null, `name` varchar(50) not null, `summary` varchar(200) not null, `content` mediumtext not null, `created_at` real not null, key `idx_created_at` (`created_at`), primary key (`id`) ) engine=innodb default charset=utf8; create table comments ( `id` varchar(50) not null, `blog_id` varchar(50) not null, `user_id` varchar(50) not null, `user_name` varchar(50) not null, `user_image` varchar(500) not null, `content` mediumtext not null, `created_at` real not null, key `idx_created_at` (`created_at`), primary key (`id`) ) engine=innodb default charset=utf8; 如果表的数量很多,可以从 Model 对象直接通过脚本自动生成SQL脚本,使用更简单。 把SQL脚本放到MySQL命令行里执行: $ mysql -u root -p < schema.sql 我们就完成了数据库表的初始化。 编写数据访问代码 接下来,就可以真正开始编写代码操作对象了。比如,对于 User 对象,我们就可以做如下操作: # test_db.py from models import User, Blog, Comment from models import User, Blog, Comment from transwarp import db db.create_engine(user='www-data', password='www-data', database='awesome') u = User(name='Test', email='test@example.com', password='1234567890', image='about:blank') u.insert() print 'new user id:', u.id u1 = User.find_first('where email=?', 'test@example.com') print 'find user\'s name:', u1.name u1.delete() u2 = User.find_first('where email=?', 'test@example.com') print 'find user:', u2 可以在MySQL客户端命令行查询,看看数据是不是正常存储到MySQL里面了。 您的鼓励是作者写作最大的动力 如果您认为本网站的教程质量不错,读后觉得收获很大,预期工资涨幅能超过30%,不妨小额赞助我一下,让我有 动力继续写出高质量的教程: Day 5 ­ 编写Web框架 27次阅读 在正式开始Web开发前,我们需要编写一个Web框架。 为什么不选择一个现成的Web框架而是自己从头开发呢?我们来考察一下现有的流行的Web框架: Django:一站式开发框架,但不利于定制化; web.py:使用类而不是更简单的函数来处理URL,并且URL映射是单独配置的; Flask:使用@decorator的URL路由不错,但框架对应用程序的代码入侵太强; bottle:缺少根据URL模式进行拦截的功能,不利于做权限检查。 所以,我们综合几种框架的优点,设计一个简单、灵活、入侵性极小的Web框架。 设计Web框架 一个简单的URL框架应该允许以@decorator方式直接把URL映射到函数上: # 首页: @get('/') def index(): return '

Index page

' return '

Index page

' # 带参数的URL: @get('/user/:id') def show_user(id): user = User.get(id) return 'hello, %s' % user.name 有没有@decorator不改变函数行为,也就是说,Web框架的API入侵性很小,你可以直接测试函 数 show_user(id) 而不需要启动Web服务器。 函数可以返回 str 、 unicode 以及 iterator ,这些数据可以直接作为字符串返回给浏览器。 其次,Web框架要支持URL拦截器,这样,我们就可以根据URL做权限检查: @interceptor('/manage/') def check_manage_url(next): if current_user.isAdmin(): return next() else: raise seeother('/signin') 拦截器接受一个 next 函数,这样,一个拦截器可以决定调用 next() 继续处理请求还是直接返回。 为了支持MVC,Web框架需要支持模板,但是我们不限定使用哪一种模板,可以选择jinja2,也可以选择mako、Ch eetah等等。 要统一模板的接口,函数可以返回 dict 并配合@view来渲染模板: @view('index.html') @get('/') def index(): return dict(blogs=get_recent_blogs(), user=get_current_user()) 如果需要从form表单或者URL的querystring获取用户输入的数据,就需要访问 request 对象,如果要设置特定的Co ntent­Type、设置Cookie等,就需要访问 response 对象。 request 和 response 对象应该从一个唯一的ThreadLocal 中获取: @get('/test') def test(): input_data = ctx.request.input() ctx.response.content_type = 'text/plain' ctx.response.set_cookie('name', 'value', expires=3600) return 'result' 最后,如果需要重定向、或者返回一个HTTP错误码,最好的方法是直接抛出异常,例如,重定向到登陆页: raise seeother('/signin') 返回404错误: raise notfound() raise notfound() 基于以上接口,我们就可以实现Web框架了。 实现Web框架 最基本的几个对象如下: # transwarp/web.py # 全局ThreadLocal对象: ctx = threading.local() # HTTP错误类: class HttpError(Exception): pass # request对象: class Request(object): # 根据key返回value: def get(self, key, default=None): pass # 返回key-value的dict: def input(self): pass # 返回URL的path: @property def path_info(self): pass # 返回HTTP Headers: @property def headers(self): pass # 根据key返回Cookie value: def cookie(self, name, default=None): pass # response对象: class Response(object): # 设置header: def set_header(self, key, value): pass # 设置Cookie: def set_cookie(self, name, value, max_age=None, expires=None, path='/'): pass # 设置status: @property def status(self): pass @status.setter @status.setter def status(self, value): pass # 定义GET: def get(path): pass # 定义POST: def post(path): pass # 定义模板: def view(path): pass # 定义拦截器: def interceptor(pattern): pass # 定义模板引擎: class TemplateEngine(object): def __call__(self, path, model): pass # 缺省使用jinja2: class Jinja2TemplateEngine(TemplateEngine): def __init__(self, templ_dir, **kw): from jinja2 import Environment, FileSystemLoader self._env = Environment(loader=FileSystemLoader(templ_dir), **kw) def __call__(self, path, model): return self._env.get_template(path).render(**model).encode('utf-8') 把上面的定义填充完毕,我们就只剩下一件事情:定义全局 WSGIApplication 的类,实现WSGI接口,然后,通过配 置启动,就完成了整个Web框架的工作。 设计 WSGIApplication 要充分考虑开发模式(Development Mode)和产品模式(Production Mode)的区分。在产 品模式下, WSGIApplication 需要直接提供WSGI接口给服务器,让服务器调用该接口,而在开发模式下,我们更希 望能通过 app.run() 直接启动服务器进行开发调试: wsgi = WSGIApplication() if __name__ == '__main__': wsgi.run() else: application = wsgi.get_wsgi_application() 因此, WSGIApplication 定义如下: class WSGIApplication(object): def __init__(self, document_root=None, **kw): pass # 添加一个URL定义: def add_url(self, func): def add_url(self, func): pass # 添加一个Interceptor定义: def add_interceptor(self, func): pass # 设置TemplateEngine: @property def template_engine(self): pass @template_engine.setter def template_engine(self, engine): pass # 返回WSGI处理函数: def get_wsgi_application(self): def wsgi(env, start_response): pass return wsgi # 开发模式下直接启动服务器: def run(self, port=9000, host='127.0.0.1'): from wsgiref.simple_server import make_server server = make_server(host, port, self.get_wsgi_application()) server.serve_forever() 把 WSGIApplication 类填充完毕,我们就得到了一个完整的Web框架。 您的鼓励是作者写作最大的动力 如果您认为本网站的教程质量不错,读后觉得收获很大,预期工资涨幅能超过30%,不妨小额赞助我一下,让我有 动力继续写出高质量的教程: Day 6 ­ 添加配置文件 3次阅读 有了Web框架和ORM框架,我们就可以开始装配App了。 通常,一个Web App在运行时都需要读取配置文件,比如数据库的用户名、口令等,在不同的环境中运行时,Web  App可以通过读取不同的配置文件来获得正确的配置。 由于Python本身语法简单,完全可以直接用Python源代码来实现配置,而不需要再解析一个单独的 .properties 或 者 .yaml 等配置文件。 默认的配置文件应该完全符合本地开发环境,这样,无需任何设置,就可以立刻启动服务器。 我们把默认的配置文件命名为 config_default.py : # config_default.py configs = { 'db': { 'host': '127.0.0.1', 'port': 3306, 'user': 'www-data', 'password': 'www-data', 'database': 'awesome' }, 'session': { 'secret': 'AwEsOmE' } } 上述配置文件简单明了。但是,如果要部署到服务器时,通常需要修改数据库的host等信息,直接修 改 config_default.py 不是一个好办法,更好的方法是编写一个 config_override.py ,用来覆盖某些默认设置: # config_override.py configs = { 'db': { 'host': '192.168.0.100' } } 把 config_default.py 作为开发环境的标准配置,把 config_override.py 作为生产环境的标准配置,我们就可以既 方便地在本地开发,又可以随时把应用部署到服务器上。 应用程序读取配置文件需要优先从 config_override.py 读取。为了简化读取配置文件,可以把所有配置读取到统一 的 config.py 中: # config.py configs = config_default.configs try: import config_override configs = merge(configs, config_override.configs) except ImportError: pass 这样,我们就完成了App的配置。 您的鼓励是作者写作最大的动力 如果您认为本网站的教程质量不错,读后觉得收获很大,预期工资涨幅能超过30%,不妨小额赞助我一下,让我有 动力继续写出高质量的教程: Day 7 ­ 编写MVC 11次阅读 现在,ORM框架、Web框架和配置都已就绪,我们可以开始编写一个最简单的MVC,把它们全部启动起来。 通过Web框架的@decorator和ORM框架的Model支持,可以很容易地编写一个处理首页URL的函数: # urls.py from transwarp.web import get, view from models import User, Blog, Comment @view('test_users.html') @get('/') def test_users(): users = User.find_all() return dict(users=users) @view 指定的模板文件是 test_users.html ,所以我们在模板的根目录 templates 下创建 test_users.html : Test users - Awesome Python Webapp

All users

{% for u in users %}

{{ u.name }} / {{ u.email }}

{% endfor %} 接下来,我们创建一个Web App的启动文件 wsgiapp.py ,负责初始化数据库、初始化Web框架,然后加 载 urls.py ,最后启动Web服务: # wsgiapp.py import logging; logging.basicConfig(level=logging.INFO) import os from transwarp import db from transwarp.web import WSGIApplication, Jinja2TemplateEngine from config import configs # 初始化数据库: db.create_engine(**configs.db) # 创建一个WSGIApplication: wsgi = WSGIApplication(os.path.dirname(os.path.abspath(__file__))) # 初始化jinja2模板引擎: template_engine = Jinja2TemplateEngine(os.path.join(os.path.dirname(os.path.abspath(__file__)), 'templates')) wsgi.template_engine = template_engine # 加载带有@get/@post的URL处理函数: import urls wsgi.add_module(urls) wsgi.add_module(urls) # 在9000端口上启动本地测试服务器: if __name__ == '__main__': wsgi.run(9000) 如果一切顺利,可以用命令行启动Web服务器: $ python wsgiapp.py 然后,在浏览器中访问 http://localhost:9000/ 。 如果数据库的 users 表什么内容也没有,你就无法在浏览器中看到循环输出的内容。可以自己在MySQL的命令行里 给 users 表添加几条记录,然后再访问: 您的鼓励是作者写作最大的动力 如果您认为本网站的教程质量不错,读后觉得收获很大,预期工资涨幅能超过30%,不妨小额赞助我一下,让我有 动力继续写出高质量的教程: Day 8 ­ 构建前端 9次阅读 虽然我们跑通了一个最简单的MVC,但是页面效果肯定不会让人满意。 对于复杂的HTML前端页面来说,我们需要一套基础的CSS框架来完成页面布局和基本样式。另外,jQuery作为操作 DOM的JavaScript库也必不可少。 从零开始写CSS不如直接从一个已有的功能完善的CSS框架开始。有很多CSS框架可供选择。我们这次选择uikit这个 强大的CSS框架。它具备完善的响应式布局,漂亮的UI,以及丰富的HTML组件,让我们能轻松设计出美观而简洁的 页面。 可以从uikit首页下载打包的资源文件。 所有的静态资源文件我们统一放到 www/static 目录下,并按照类别归类: 所有的静态资源文件我们统一放到 www/static 目录下,并按照类别归类: static/ +- css/ | +- addons/ | | +- uikit.addons.min.css | | +- uikit.almost-flat.addons.min.css | | +- uikit.gradient.addons.min.css | +- awesome.css | +- uikit.almost-flat.addons.min.css | +- uikit.gradient.addons.min.css | +- uikit.min.css +- fonts/ | +- fontawesome-webfont.eot | +- fontawesome-webfont.ttf | +- fontawesome-webfont.woff | +- FontAwesome.otf +- js/ +- awesome.js +- html5.js +- jquery.min.js +- uikit.min.js 由于前端页面肯定不止首页一个页面,每个页面都有相同的页眉和页脚。如果每个页面都是独立的HTML模板,那么 我们在修改页眉和页脚的时候,就需要把每个模板都改一遍,这显然是没有效率的。 常见的模板引擎已经考虑到了页面上重复的HTML部分的复用问题。有的模板通过include把页面拆成三部分: <% include file="inc_header.html" %> <% include file="index_body.html" %> <% include file="inc_footer.html" %> 这样,相同的部分 inc_header.html 和 inc_footer.html 就可以共享。 但是include方法不利于页面整体结构的维护。jinjia2的模板还有另一种“继承”方式,实现模板的复用更简单。 “继承”模板的方式是通过编写一个“父模板”,在父模板中定义一些可替换的block(块)。然后,编写多个“子模 板”,每个子模板都可以只替换父模板定义的block。比如,定义一个最简单的父模板: {% block title%} 这里定义了一个名为title的block {% endblock %} {% block content %} 这里定义了一个名为content的block {% endblock %} 对于子模板 a.html ,只需要把父模板的 title 和 content 替换掉: {% extends 'base.html' %} {% extends 'base.html' %} {% block title %} A {% endblock %} {% block content %}

Chapter A

blablabla...

{% endblock %} 对于子模板 b.html ,如法炮制: {% extends 'base.html' %} {% block title %} B {% endblock %} {% block content %}

Chapter B

  • list 1
  • list 2
{% endblock %} 这样,一旦定义好父模板的整体布局和CSS样式,编写子模板就会非常容易。 让我们通过uikit这个CSS框架来完成父模板 __base__.html 的编写: {% block meta %}{% endblock %} {% block title %} ? {% endblock %} - Awesome Python Webapp {% block beforehead %}{% endblock %}
{% block content %} {% endblock %}

Powered by Awesome Python Webapp. Copyright © 2014. [Manage]

www.liaoxuefeng.com. All rights reser ved.

__base__.html 定义的几个block作用如下: 用于子页面定义一些meta,例如rss feed: {% block meta %} ... {% endblock %} 覆盖页面的标题: {% block title %} ... {% endblock %} 子页面可以在标签关闭前插入JavaScript代码: {% block beforehead %} ... {% endblock %} 子页面的content布局和内容: {% block content %} ... {% endblock %} 我们把首页改造一下,从 __base__.html 继承一个 blogs.html : {% extends '__base__.html' %} {% block title %}日志{% endblock %} {% block content %}
{% for blog in blogs %}
{% endfor %}
{% endblock %} 相应地,首页URL的处理函数更新如下: @view('blogs.html') @get('/') def index(): blogs = Blog.find_all() # 查找登陆用户: user = User.find_first('where email=?', 'admin@example.com') return dict(blogs=blogs, user=user) 往MySQL的 blogs 表中手动插入一些数据,我们就可以看到一个真正的首页了。但是Blog的创建日期显示的是一个 浮点数,因为它是由这段模板渲染出来的: 解决方法是通过jinja2的filter(过滤器),把一个浮点数转换成日期字符串。我们来编写一个 datetime 的filter,在模 板里用法如下: filter需要在初始化jinja2时设置。修改 wsgiapp.py 相关代码如下: # wsgiapp.py: ... # 定义datetime_filter,输入是t,输出是unicode字符串: def datetime_filter(t): delta = int(time.time() - t) if delta < 60: return u'1分钟前' if delta < 3600: return u'%s分钟前' % (delta // 60) if delta < 86400: return u'%s小时前' % (delta // 3600) if delta < 604800: return u'%s天前' % (delta // 86400) dt = datetime.fromtimestamp(t) return u'%s年%s月%s日' % (dt.year, dt.month, dt.day) template_engine = Jinja2TemplateEngine(os.path.join(os.path.dirname(os.path.abspath(__file__)), 'templates')) # 把filter添加到jinjia2,filter名称为datetime,filter本身是一个函数对象: template_engine.add_filter('datetime', datetime_filter) wsgi.template_engine = template_engine 现在,完善的首页显示如下: 您的鼓励是作者写作最大的动力 如果您认为本网站的教程质量不错,读后觉得收获很大,预期工资涨幅能超过30%,不妨小额赞助我一下,让我有 动力继续写出高质量的教程: Day 9 ­ 编写API 12次阅读 自从Roy Fielding博士在2000年他的博士论文中提出REST(Representational State Transfer)风格的软件架构模 式后,REST就基本上迅速取代了复杂而笨重的SOAP,成为Web API的标准了。 什么是Web API呢? 如果我们想要获取一篇Blog,输入 http://localhost:9000/blog/123 ,就可以看到id为 123 的Blog页面,但这个结果 是HTML页面,它同时混合包含了Blog的数据和Blog的展示两个部分。对于用户来说,阅读起来没有问题,但是,如 果机器读取,就很难从HTML中解析出Blog的数据。 如果一个URL返回的不是HTML,而是机器能直接解析的数据,这个URL就可以看成是一个Web API。比如,读 取 http://localhost:9000/api/blogs/123 ,如果能直接返回Blog的数据,那么机器就可以直接读取。 REST就是一种设计API的模式。最常用的数据格式是JSON。由于JSON能直接被JavaScript读取,所以,以JSON 格式编写的REST风格的API具有简单、易读、易用的特点。 编写API有什么好处呢?由于API就是把Web App的功能全部封装了,所以,通过API操作数据,可以极大地把前端 和后端的代码隔离,使得后端代码易于测试,前端代码编写更简单。 和后端的代码隔离,使得后端代码易于测试,前端代码编写更简单。 一个API也是一个URL的处理函数,我们希望能直接通过一个 @api 来把函数变成JSON格式的REST API,这样,获 取注册用户可以用一个API实现如下: @api @get('/api/users') def api_get_users(): users = User.find_by('order by created_at desc') # 把用户的口令隐藏掉: for u in users: u.password = '******' return dict(users=users) 所以, @api 这个decorator只要编写好了,就可以把任意的URL处理函数变成API调用。 新建一个 apis.py ,编写 @api 负责把函数的返回结果序列化为JSON: def api(func): @functools.wraps(func) def _wrapper(*args, **kw): try: r = json.dumps(func(*args, **kw)) except APIError, e: r = json.dumps(dict(error=e.error, data=e.data, message=e.message)) except Exception, e: r = json.dumps(dict(error='internalerror', data=e.__class__.__name__, message=e.message)) ctx.response.content_type = 'application/json' return r return _wrapper @api 需要对Error进行处理。我们定义一个 APIError ,这种Error是指API调用时发生了逻辑错误(比如用户不存 在),其他的Error视为Bug,返回的错误代码为 internalerror 。 客户端调用API时,必须通过错误代码来区分API调用是否成功。错误代码是用来告诉调用者出错的原因。很多API用 一个整数表示错误码,这种方式很难维护错误码,客户端拿到错误码还需要查表得知错误信息。更好的方式是用字 符串表示错误代码,不需要看文档也能猜到错误原因。 可以在浏览器直接测试API,例如,输入 http://localhost:9000/api/users ,就可以看到返回的JSON: 您的鼓励是作者写作最大的动力 如果您认为本网站的教程质量不错,读后觉得收获很大,预期工资涨幅能超过30%,不妨小额赞助我一下,让我有 动力继续写出高质量的教程: Day 10 ­ 用户注册和登录 26次阅读 用户管理是绝大部分Web网站都需要解决的问题。用户管理涉及到用户注册和登录。 用户注册相对简单,我们可以先通过API把用户注册这个功能实现了: _RE_MD5 = re.compile(r'^[0-9a-f]{32}$') @api @post('/api/users') def register_user(): i = ctx.request.input(name='', email='', password='') name = i.name.strip() email = i.email.strip().lower() password = i.password if not name: raise APIValueError('name') if not email or not _RE_EMAIL.match(email): raise APIValueError('email') if not password or not _RE_MD5.match(password): raise APIValueError('password') user = User.find_first('where email=?', email) if user: raise APIError('register:failed', 'email', 'Email is already in use.') user = User(name=name, email=email, password=password, image='http://www.gravatar.com/avatar/%s?d=mm&s=120' % hashlib.md5(email).hexdigest()) user.insert() return user 注意用户口令是客户端传递的经过MD5计算后的32位Hash字符串,所以服务器端并不知道用户的原始口令。 接下来可以创建一个注册页面,让用户填写注册表单,然后,提交数据到注册用户的API: {% extends '__base__.html' %} {% block title %}注册{% endblock %} {% block beforehead %} {% endblock %} {% block content %}

欢迎注册!

{% endblock %} 这样我们就把用户注册的功能完成了: 用户登录比用户注册复杂。由于HTTP协议是一种无状态协议,而服务器要跟踪用户状态,就只能通过cookie实 现。大多数Web框架提供了Session功能来封装保存用户状态的cookie。 Session的优点是简单易用,可以直接从Session中取出用户登录信息。 Session的缺点是服务器需要在内存中维护一个映射表来存储用户登录信息,如果有两台以上服务器,就需要对Sess ion做集群,因此,使用Session的Web App很难扩展。 我们采用直接读取cookie的方式来验证用户登录,每次用户访问任意URL,都会对cookie进行验证,这种方式的好 处是保证服务器处理任意的URL都是无状态的,可以扩展到多台服务器。 由于登录成功后是由服务器生成一个cookie发送给浏览器,所以,要保证这个cookie不会被客户端伪造出来。 实现防伪造cookie的关键是通过一个单向算法(例如MD5),举例如下: 当用户输入了正确的口令登录成功后,服务器可以从数据库取到用户的id,并按照如下方式计算出一个字符串: "用户id" + "过期时间" + MD5("用户id" + "用户口令" + "过期时间" + "SecretKey") 当浏览器发送cookie到服务器端后,服务器可以拿到的信息包括: 用户id 过期时间 MD5值 如果未到过期时间,服务器就根据用户id查找用户口令,并计算: MD5("用户id" + "用户口令" + "过期时间" + "SecretKey") 并与浏览器cookie中的MD5进行比较,如果相等,则说明用户已登录,否则,cookie就是伪造的。 这个算法的关键在于MD5是一种单向算法,即可以通过原始字符串计算出MD5,但无法通过MD5反推出原始字符 串。 所以登录API可以实现如下: @api @post('/api/authenticate') def authenticate(): i = ctx.request.input() email = i.email.strip().lower() password = i.password user = User.find_first('where email=?', email) if user is None: raise APIError('auth:failed', 'email', 'Invalid email.') elif user.password != password: raise APIError('auth:failed', 'password', 'Invalid password.') max_age = 604800 cookie = make_signed_cookie(user.id, user.password, max_age) ctx.response.set_cookie(_COOKIE_NAME, cookie, max_age=max_age) user.password = '******' return user # 计算加密cookie: def make_signed_cookie(id, password, max_age): expires = str(int(time.time() + max_age)) L = [id, expires, hashlib.md5('%s-%s-%s-%s' % (id, password, expires, _COOKIE_KEY)).hexdigest()] return '-'.join(L) 对于每个URL处理函数,如果我们都去写解析cookie的代码,那会导致代码重复很多次。 利用拦截器在处理URL之前,把cookie解析出来,并将登录用户绑定到 ctx.request 对象上,这样,后续的URL处 理函数就可以直接拿到登录用户: @interceptor('/') def user_interceptor(next): user = None cookie = ctx.request.cookies.get(_COOKIE_NAME) if cookie: user = parse_signed_cookie(cookie) user = parse_signed_cookie(cookie) ctx.request.user = user return next() # 解密cookie: def parse_signed_cookie(cookie_str): try: L = cookie_str.split('-') if len(L) != 3: return None id, expires, md5 = L if int(expires) < time.time(): return None user = User.get(id) if user is None: return None if md5 != hashlib.md5('%s-%s-%s-%s' % (id, user.password, expires, _COOKIE_KEY)).hexdigest(): return None return user except: return None 这样,我们就完成了用户注册和登录的功能。 您的鼓励是作者写作最大的动力 如果您认为本网站的教程质量不错,读后觉得收获很大,预期工资涨幅能超过30%,不妨小额赞助我一下,让我有 动力继续写出高质量的教程: Day 11 ­ 编写日志创建页 65次阅读 在Web开发中,后端代码写起来其实是相当容易的。 例如,我们编写一个REST API,用于创建一个Blog: @api @post('/api/blogs') def api_create_blog(): i = ctx.request.input(name='', summary='', content='') name = i.name.strip() summary = i.summary.strip() content = i.content.strip() if not name: raise APIValueError('name', 'name cannot be empty.') if not summary: raise APIValueError('summary', 'summary cannot be empty.') if not content: raise APIValueError('content', 'content cannot be empty.') user = ctx.request.user blog = Blog(user_id=user.id, user_name=user.name, name=name, summary=summary, content=content) blog.insert() blog.insert() return blog 编写后端Python代码不但很简单,而且非常容易测试,上面的API: api_create_blog() 本身只是一个普通函数。 Web开发真正困难的地方在于编写前端页面。前端页面需要混合HTML、CSS和JavaScript,如果对这三者没有深入 地掌握,编写的前端页面将很快难以维护。 更大的问题在于,前端页面通常是动态页面,也就是说,前端页面往往是由后端代码生成的。 生成前端页面最早的方式是拼接字符串: s = '' + title + '' + body + '' 显然这种方式完全不具备可维护性。所以有第二种模板方式: {{ title }} {{ body }} ASP、JSP、PHP等都是用这种模板方式生成前端页面。 如果在页面上大量使用JavaScript(事实上大部分页面都会),模板方式仍然会导致JavaScript代码与后端代码绑得 非常紧密,以至于难以维护。其根本原因在于负责显示的HTML DOM模型与负责数据和交互的JavaScript代码没有 分割清楚。 要编写可维护的前端代码绝非易事。和后端结合的MVC模式已经无法满足复杂页面逻辑的需要了,所以,新的MVV M:Model View ViewModel模式应运而生。 MVVM最早由微软提出来,它借鉴了桌面应用程序的MVC思想,在前端页面中,把Model用纯JavaScript对象表示: View是纯HTML:
由于Model表示数据,View负责显示,两者做到了最大限度的分离。 把Model和View关联起来的就是ViewModel。ViewModel负责把Model的数据同步到View显示出来,还负责把View 的修改同步回Model。 ViewModel如何编写?需要用JavaScript编写一个通用的ViewModel,这样,就可以复用整个MVVM模型了。 好消息是已有许多成熟的MVVM框架,例如AngularJS,KnockoutJS等。我们选择Vue这个简单易用的MVVM框架来 实现创建Blog的页面 templates/manage_blog_edit.html : {% extends '__base__.html' %} {% block title %}编辑日志{% endblock %} {% block beforehead %} {% endblock %} {% block content %}
{% endblock %} 初始化Vue时,我们指定3个参数: el:根据选择器查找绑定的View,这里是 #form‐blog ,就是id为 form‐blog 的DOM,对应的是一个
标签; data:JavaScript对象表示的Model,我们初始化为 { name: '', summary: '', content: ''} ; methods:View可以触发的JavaScript函数, submit 就是提交表单时触发的函数。 接下来,我们在 标签中,用几个简单的 v‐model ,就可以让Vue把Model和View关联起来: Form表单通过 把提交表单的事件关联到 submit 方法。 需要特别注意的是,在MVVM中,Model和View是双向绑定的。如果我们在Form中修改了文本框的值,可以在Mod el中立刻拿到新的值。试试在表单中输入文本,然后在Chrome浏览器中打开JavaScript控制台,可以通过 vm.name 访问单个属性,或者通过 vm.$data 访问整个Model: 如果我们在JavaScript逻辑中修改了Model,这个修改会立刻反映到View上。试试在JavaScript控制台输 入 vm.name = 'MVVM简介' ,可以看到文本框的内容自动被同步了: 双向绑定是MVVM框架最大的作用。借助于MVVM,我们把复杂的显示逻辑交给框架完成。由于后端编写了独立的R EST API,所以,前端用AJAX提交表单非常容易,前后端分离得非常彻底。 您的鼓励是作者写作最大的动力 如果您认为本网站的教程质量不错,读后觉得收获很大,预期工资涨幅能超过30%,不妨小额赞助我一下,让我有 动力继续写出高质量的教程: Day 12 ­ 编写日志列表页 66次阅读 MVVM模式不但可用于Form表单,在复杂的管理页面中也能大显身手。例如,分页显示Blog的功能,我们先把后端 代码写出来: 在 apis.py 中定义一个 Page 类用于存储分页信息: class Page(object): def __init__(self, item_count, page_index=1, page_size=10): self.item_count = item_count self.page_size = page_size self.page_count = item_count // page_size + (1 if item_count % page_size > 0 else 0) if (item_count == 0) or (page_index < 1) or (page_index > self.page_count): self.offset = 0 self.limit = 0 self.page_index = 1 else: self.page_index = page_index self.offset = self.page_size * (page_index - 1) self.limit = self.page_size self.has_next = self.page_index < self.page_count self.has_previous = self.page_index > 1 在 urls.py 中实现API: def _get_blogs_by_page(): total = Blog.count_all() page = Page(total, _get_page_index()) blogs = Blog.find_by('order by created_at desc limit ?,?', page.offset, page.limit) return blogs, page @api @get('/api/blogs') def api_get_blogs(): blogs, page = _get_blogs_by_page() return dict(blogs=blogs, page=page) 返回模板页面: @view('manage_blog_list.html') @get('/manage/blogs') def manage_blogs(): return dict(page_index=_get_page_index(), user=ctx.request.user) 模板页面首先通过API: GET /api/blogs?page=? 拿到Model: { "page": { "has_next": true, "page_index": 1, "page_count": 2, "has_previous": false, "item_count": 12 }, "blogs": [...] } 然后,通过Vue初始化MVVM: View的容器是 #div‐blogs ,包含一个table,我们用 v‐repeat 可以把Model的数组 blogs 直接变成多行的 : 往Model的blogs数组中增加一个Blog元素,table就神奇地增加了一行;把blogs数组的某个元素删除,table就神奇 地减少了一行。所有复杂的Model­View的映射逻辑全部由MVVM框架完成,我们只需要在HTML中写上 v‐repeat 指 令,就什么都不用管了。 可以把 v‐repeat="blog: blogs" 看成循环代码,所以,可以在一个 内部引用循环变量 blog 。 v‐text 和 v‐attr 指令分别用于生成文本和DOM节点属性。 完整的Blog列表页如下: 您的鼓励是作者写作最大的动力 如果您认为本网站的教程质量不错,读后觉得收获很大,预期工资涨幅能超过30%,不妨小额赞助我一下,让我有 动力继续写出高质量的教程: Day 13 ­ 提升开发效率 71次阅读 现在,我们已经把一个Web App的框架完全搭建好了,从后端的API到前端的MVVM,流程已经跑通了。 在继续工作前,注意到每次修改Python代码,都必须在命令行先Ctrl­C停止服务器,再重启,改动才能生效。 在开发阶段,每天都要修改、保存几十次代码,每次保存都手动来这么一下非常麻烦,严重地降低了我们的开发效 率。有没有办法让服务器检测到代码修改后自动重新加载呢? Django的开发环境在Debug模式下就可以做到自动重新加载,如果我们编写的服务器也能实现这个功能,就能大大 提升开发效率。 可惜的是,Django没把这个功能独立出来,不用Django就享受不到,怎么办? 其实Python本身提供了重新载入模块的功能,但不是所有模块都能被重新载入。另一种思路是检测 www 目录下的代 码改动,一旦有改动,就自动重启服务器。 按照这个思路,我们可以编写一个辅助程序 pymonitor.py ,让它启动 wsgiapp.py ,并时刻监控 www 目录下的代码 改动,有改动时,先把当前 wsgiapp.py 进程杀掉,再重启,就完成了服务器进程的自动重启。 要监控目录文件的变化,我们也无需自己手动定时扫描,Python的第三方库 watchdog 可以利用操作系统的API来监 控目录文件的变化,并发送通知。我们先用 easy_install 安装: $ easy_install watchdog 利用 watchdog 接收文件变化的通知,如果是 .py 文件,就自动重启 wsgiapp.py 进程。 利用Python自带的 subprocess 实现进程的启动和终止,并把输入输出重定向到当前进程的输入输出中: #!/usr/bin/env python import os, sys, time, subprocess from watchdog.observers import Observer from watchdog.events import FileSystemEventHandler def log(s): print '[Monitor] %s' % s class MyFileSystemEventHander(FileSystemEventHandler): def __init__(self, fn): super(MyFileSystemEventHander, self).__init__() self.restart = fn def on_any_event(self, event): if event.src_path.endswith('.py'): log('Python source file changed: %s' % event.src_path) self.restart() command = ['echo', 'ok'] process = None def kill_process(): global process if process: log('Kill process [%s]...' % process.pid) process.kill() process.wait() log('Process ended with code %s.' % process.returncode) process = None def start_process(): global process, command log('Start process %s...' % ' '.join(command)) process = subprocess.Popen(command, stdin=sys.stdin, stdout=sys.stdout, stderr=sys.stderr) def restart_process(): kill_process() start_process() def start_watch(path, callback): observer = Observer() observer = Observer() observer.schedule(MyFileSystemEventHander(restart_process), path, recursive=True) observer.start() log('Watching directory %s...' % path) start_process() try: while True: time.sleep(0.5) except KeyboardInterrupt: observer.stop() observer.join() if __name__ == '__main__': argv = sys.argv[1:] if not argv: print('Usage: ./pymonitor your-script.py') exit(0) if argv[0]!='python': argv.insert(0, 'python') command = argv path = os.path.abspath('.') start_watch(path, None) 一共50行左右的代码,就实现了Debug模式的自动重新加载。用下面的命令启动服务器: $ python pymonitor.py wsgiapp.py 或者给 pymonitor.py 加上可执行权限,启动服务器: $ ./pymonitor.py wsgiapp.py 在编辑器中打开一个py文件,修改后保存,看看命令行输出,是不是自动重启了服务器: $ ./pymonitor.py wsgiapp.py [Monitor] Watching directory /Users/michael/Github/awesome-python-webapp/www... [Monitor] Start process python wsgiapp.py... ... INFO:root:application (/Users/michael/Github/awesome-python-webapp/www) will start at 0.0.0.0:9000... [Monitor] Python source file changed: /Users/michael/Github/awesome-python-webapp/www/apis.py [Monitor] Kill process [2747]... [Monitor] Process ended with code -9. [Monitor] Start process python wsgiapp.py... ... INFO:root:application (/Users/michael/Github/awesome-python-webapp/www) will start at 0.0.0.0:9000... 现在,只要一保存代码,就可以刷新浏览器看到效果,大大提升了开发效率。 您的鼓励是作者写作最大的动力 如果您认为本网站的教程质量不错,读后觉得收获很大,预期工资涨幅能超过30%,不妨小额赞助我一下,让我有 动力继续写出高质量的教程: Day 14 ­ 完成Web App 17次阅读 在Web App框架和基本流程跑通后,剩下的工作全部是体力活了:在Debug开发模式下完成后端所有API、前端所有 页面。我们需要做的事情包括: 对URL /manage/ 进行拦截,检查当前用户是否是管理员身份: @interceptor('/manage/') def manage_interceptor(next): user = ctx.request.user if user and user.admin: return next() raise seeother('/signin') 后端API包括: 获取日志:GET /api/blogs 创建日志:POST /api/blogs 修改日志:POST /api/blogs/:blog_id 删除日志:POST /api/blogs/:blog_id/delete 获取评论:GET /api/comments 创建评论:POST /api/blogs/:blog_id/comments 删除评论:POST /api/comments/:comment_id/delete 创建新用户:POST /api/users 获取用户:GET /api/users 管理页面包括: 评论列表页:GET /manage/comments 日志列表页:GET /manage/blogs 创建日志页:GET /manage/blogs/create 修改日志页:GET /manage/blogs/ 用户列表页:GET /manage/users 用户浏览页面包括: 注册页:GET /register 登录页:GET /signin 注销页:GET /signout 注销页:GET /signout 首页:GET / 日志详情页:GET /blog/:blog_id 把所有的功能实现,我们第一个Web App就宣告完成! 您的鼓励是作者写作最大的动力 如果您认为本网站的教程质量不错,读后觉得收获很大,预期工资涨幅能超过30%,不妨小额赞助我一下,让我有 动力继续写出高质量的教程: Day 15 ­ 部署Web App 8次阅读 作为一个合格的开发者,在本地环境下完成开发还远远不够,我们需要把Web App部署到远程服务器上,这样,广 大用户才能访问到网站。 很多做开发的同学把部署这件事情看成是运维同学的工作,这种看法是完全错误的。首先,最近流行DevOps理 念,就是说,开发和运维要变成一个整体。其次,运维的难度,其实跟开发质量有很大的关系。代码写得垃圾,运 维再好也架不住天天挂掉。最后,DevOps理念需要把运维、监控等功能融入到开发中。你想服务器升级时不中断用 户服务?那就得在开发时考虑到这一点。 下面,我们就来把awesome­python­webapp部署到Linux服务器。 搭建Linux服务器 要部署到Linux,首先得有一台Linux服务器。要在公网上体验的同学,可以在Amazon的AWS申请一台EC2虚拟 机(免费使用1年),或者使用国内的一些云服务器,一般都提供Ubuntu Server的镜像。想在本地部署的同学,请 安装虚拟机,推荐使用VirtualBox。 我们选择的Linux服务器版本是Ubuntu Server 12.04 LTS,原因是apt太简单了。如果你准备使用其他Linux版 本,也没有问题。 Linux安装完成后,请确保ssh服务正在运行,否则,需要通过apt安装: $ sudo apt-get install openssh-server 有了ssh服务,就可以从本地连接到服务器上。建议把公钥复制到服务器端用户的 .ssh/authorized_keys 中,这 样,就可以通过证书实现无密码连接。 部署方式 在本地开发时,我们可以用Python自带的WSGI服务器,但是,在服务器上,显然不能用自带的这个开发版服务 器。可以选择的WSGI服务器很多,我们选gunicorn:它用类似Nginx的Master­Worker模式,同时可以提供gevent 的支持,不用修改代码,就能获得极高的性能。 此外,我们还需要一个高性能Web服务器,这里选择Nginx,它可以处理静态资源,同时作为反向代理把动态请求交 给gunicorn处理。gunicorn负责调用我们的Python代码,这个模型如下: 给gunicorn处理。gunicorn负责调用我们的Python代码,这个模型如下: Nginx负责分发请求: 在服务器端,我们需要定义好部署的目录结构: / +- srv/ +- awesome/ <-- Web App根目录 +- www/ <-- 存放Python源码 | +- static/ <-- 存放静态资源文件 +- log/ <-- 存放log 在服务器上部署,要考虑到新版本如果运行不正常,需要回退到旧版本时怎么办。每次用新的代码覆盖掉旧的文件 是不行的,需要一个类似版本控制的机制。由于Linux系统提供了软链接功能,所以,我们把 www 作为一个软链 接,它指向哪个目录,哪个目录就是当前运行的版本: 而Nginx和gunicorn的配置文件只需要指向 www 目录即可。 Nginx可以作为服务进程直接启动,但gunicorn还不行,所以,Supervisor登场!Supervisor是一个管理进程的工 具,可以随系统启动而启动服务,它还时刻监控服务进程,如果服务进程意外退出,Supervisor可以自动重启服 务。 总结一下我们需要用到的服务有: Nginx:高性能Web服务器+负责反向代理; gunicorn:高性能WSGI服务器; gevent:把Python同步代码变成异步协程的库; Supervisor:监控服务进程的工具; MySQL:数据库服务。 在Linux服务器上用apt可以直接安装上述服务: $ sudo apt-get install nginx gunicorn python-gevent supervisor mysql-server 然后,再把我们自己的Web App用到的Python库安装了: $ sudo apt-get install python-jinja2 python-mysql.connector 在服务器上创建目录 /srv/awesome/ 以及相应的子目录。 在服务器上初始化MySQL数据库,把数据库初始化脚本 schema.sql 复制到服务器上执行: $ mysql -u root -p < schema.sql 服务器端准备就绪。 部署 用FTP还是SCP还是rsync复制文件?如果你需要手动复制,用一次两次还行,一天如果部署50次不但慢、效率 低,而且容易出错。 正确的部署方式是使用工具配合脚本完成自动化部署。Fabric就是一个自动化部署工具。由于Fabric是用Python开 发的,所以,部署脚本也是用Python来编写,非常方便! 要用Fabric部署,需要在本机(是开发机器,不是Linux服务器)安装Fabric: $ easy_install fabric Linux服务器上不需要安装Fabric,Fabric使用SSH直接登录服务器并执行部署命令。 下一步是编写部署脚本。Fabric的部署脚本叫 fabfile.py ,我们把它放到 awesome‐python‐webapp 的目录 下,与 www 目录平级: awesome-python-webapp/ +- fabfile.py +- www/ +- ... Fabric的脚本编写很简单,首先导入Fabric的API,设置部署时的变量: # fabfile.py import os, re from datetime import datetime # 导入Fabric API: from fabric.api import * # 服务器登录用户名: env.user = 'michael' # sudo用户为root: env.sudo_user = 'root' # 服务器地址,可以有多个,依次部署: env.hosts = ['192.168.0.3'] # 服务器MySQL用户名和口令: db_user = 'www-data' db_password = 'www-data' 然后,每个Python函数都是一个任务。我们先编写一个打包的任务: _TAR_FILE = 'dist-awesome.tar.gz' def build(): includes = ['static', 'templates', 'transwarp', 'favicon.ico', '*.py'] excludes = ['test', '.*', '*.pyc', '*.pyo'] local('rm -f dist/%s' % _TAR_FILE) with lcd(os.path.join(os.path.abspath('.'), 'www')): cmd = ['tar', '--dereference', '-czvf', '../dist/%s' % _TAR_FILE] cmd.extend(['--exclude=\'%s\'' % ex for ex in excludes]) cmd.extend(includes) local(' '.join(cmd)) Fabric提供 local('...') 来运行本地命令, with lcd(path) 可以把当前命令的目录设定为 lcd() 指定的目录,注意 Fabric只能运行命令行命令,Windows下可能需要Cgywin环境。 在 awesome‐python‐webapp 目录下运行: $ fab build 看看是否在 dist 目录下创建了 dist‐awesome.tar.gz 的文件。 打包后,我们就可以继续编写 deploy 任务,把打包文件上传至服务器,解压,重置 www 软链接,重启相关服务: _REMOTE_TMP_TAR = '/tmp/%s' % _TAR_FILE _REMOTE_BASE_DIR = '/srv/awesome' def deploy(): newdir = 'www-%s' % datetime.now().strftime('%y-%m-%d_%H.%M.%S') # 删除已有的tar文件: run('rm -f %s' % _REMOTE_TMP_TAR) # 上传新的tar文件: put('dist/%s' % _TAR_FILE, _REMOTE_TMP_TAR) # 创建新目录: with cd(_REMOTE_BASE_DIR): sudo('mkdir %s' % newdir) # 解压到新目录: with cd('%s/%s' % (_REMOTE_BASE_DIR, newdir)): sudo('tar -xzvf %s' % _REMOTE_TMP_TAR) # 重置软链接: with cd(_REMOTE_BASE_DIR): sudo('rm -f www') sudo('ln -s %s www' % newdir) sudo('chown www-data:www-data www') sudo('chown -R www-data:www-data %s' % newdir) # 重启Python服务和nginx服务器: with settings(warn_only=True): sudo('supervisorctl stop awesome') sudo('supervisorctl start awesome') sudo('/etc/init.d/nginx reload') 注意 run() 函数执行的命令是在服务器上运行, with cd(path) 和 with lcd(path) 类似,把当前目录在服务器端设 置为 cd() 指定的目录。如果一个命令需要sudo权限,就不能用 run() ,而是用 sudo() 来执行。 配置Supervisor 上面让Supervisor重启gunicorn的命令会失败,因为我们还没有配置Supervisor呢。 编写一个Supervisor的配置文件 awesome.conf ,存放到 /etc/supervisor/conf.d/ 目录下: [program:awesome] command = /usr/bin/gunicorn --bind 127.0.0.1:9000 --workers 1 --worker-class gevent wsgiapp:application directory = /srv/awesome/www user = www-data startsecs = 3 redirect_stderr = true stdout_logfile_maxbytes = 50MB stdout_logfile_maxbytes = 50MB stdout_logfile_backups = 10 stdout_logfile = /srv/awesome/log/app.log 配置文件通过 [program:awesome] 指定服务名为 awesome , command 指定启动gunicorn的命令行,设定gunicorn的启 动端口为9000,WSGI处理函数入口为 wsgiapp:application 。 然后重启Supervisor后,就可以随时启动和停止Supervisor管理的服务了: $ sudo supervisorctl reload $ sudo supervisorctl start awesome $ sudo supervisorctl status awesome RUNNING pid 1401, uptime 5:01:34 配置Nginx Supervisor只负责运行gunicorn,我们还需要配置Nginx。把配置文件 awesome 放 到 /etc/nginx/sites‐available/ 目录下: server { listen 80; # 监听80端口 root /srv/awesome/www; access_log /srv/awesome/log/access_log; error_log /srv/awesome/log/error_log; # server_name awesome.liaoxuefeng.com; # 配置域名 # 处理静态文件/favicon.ico: location /favicon.ico { root /srv/awesome/www; } # 处理静态资源: location ~ ^\/static\/.*$ { root /srv/awesome/www; } # 动态请求转发到9000端口(gunicorn): location / { proxy_pass http://127.0.0.1:9000; proxy_set_header X-Real-IP $remote_addr; proxy_set_header Host $host; proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for; } } 然后在 /etc/nginx/sites‐enabled/ 目录下创建软链接: $ pwd /etc/nginx/sites-enabled $ sudo ln -s /etc/nginx/sites-available/awesome . 让Nginx重新加载配置文件,不出意外,我们的 awesome‐python‐webapp 应该正常运行: $ sudo /etc/init.d/nginx reload 如果有任何错误,都可以在 /srv/awesome/log 下查找Nginx和App本身的log。如果Supervisor启动时报错,可以 在 /var/log/supervisor 下查看Supervisor的log。 如果一切顺利,你可以在浏览器中访问Linux服务器上的 awesome‐python‐webapp 了: 如果在开发环境更新了代码,只需要在命令行执行: $ fab build $ fab deploy 自动部署完成!刷新浏览器就可以看到服务器代码更新后的效果。 友情链接 嫌国外网速慢的童鞋请移步网易和搜狐的镜像站点: http://mirrors.163.com/ http://mirrors.sohu.com/ 您的鼓励是作者写作最大的动力 如果您认为本网站的教程质量不错,读后觉得收获很大,预期工资涨幅能超过30%,不妨小额赞助我一下,让我有 动力继续写出高质量的教程: 动力继续写出高质量的教程: Day 16 ­ 编写移动App 58次阅读 网站部署上线后,还缺点啥呢? 在移动互联网浪潮席卷而来的今天,一个网站没有上线移动App,出门根本不好意思跟人打招呼。 所以, awesome‐python‐webapp 必须得有一个移动App版本! 开发iPhone版本 我们首先来看看如何开发iPhone App。前置条件:一台Mac电脑,安装XCode和最新的iOS SDK。 在使用MVVM编写前端页面时,我们就能感受到,用REST API封装网站后台的功能,不但能清晰地分离前端页面和 后台逻辑,现在这个好处更加明显,移动App也可以通过REST API从后端拿到数据。 我们来设计一个简化版的iPhone App,包含两个屏幕:列出最新日志和阅读日志的详细内容: 只需要调用API: /api/blogs 。 在XCode中完成App编写: 由于我们的教程是Python,关于如何开发iOS,请移步Develop Apps for iOS。 点击下载iOS App源码。 如何编写Android App?这个当成作业了。 您的鼓励是作者写作最大的动力 如果您认为本网站的教程质量不错,读后觉得收获很大,预期工资涨幅能超过30%,不妨小额赞助我一下,让我有 动力继续写出高质量的教程: 期末总结 70次阅读 终于到了期末总结的时刻了! 经过一段时间的学习,相信你对Python已经初步掌握。一开始,可能觉得Python上手很容易,可是越往后学,会越 困难,有的时候,发现理解不了代码,这时,不妨停下来思考一下,先把概念搞清楚,代码自然就明白了。 Python非常适合初学者用来进入计算机编程领域。Python属于非常高级的语言,掌握了这门高级语言,就对计算机 编程的核心思想——抽象有了初步理解。如果希望继续深入学习计算机编程,可以学习C、JavaScript、Lisp等不同 类型的语言,只有多掌握不同领域的语言,有比较才更有收获。 谢谢学习! 您的鼓励是作者写作最大的动力 如果您认为本网站的教程质量不错,读后觉得收获很大,预期工资涨幅能超过30%,不妨小额赞助我一下,让我有 动力继续写出高质量的教程:
还剩297页未读

继续阅读

下载pdf到电脑,查找使用更方便

pdf的实际排版效果,会与网站的显示效果略有不同!!

需要 10 金币 [ 分享pdf获得金币 ] 0 人已下载

下载pdf

pdf贡献者

ericaz

贡献于2017-03-31

下载需要 10 金币 [金币充值 ]
亲,您也可以通过 分享原创pdf 来获得金币奖励!
下载pdf