信息管理专业Python教程

目錄 1. 介 i. 者序 ii. 作者序 2. 什么要学程 3. 量表式与句 4. 条件行 5. 函数 6. 迭代 7. 字符串 8. 文件 9. 列表 10. 字典 11. 元 12. 正表式 13. 网程 14. Web Services 15. 数据与化言 SQL 16. 数据可化 17. 常任自化理 18. 附 A 19. 附 B 20. 附 C 2

介 Python for Informatics( 中文版 ) 信息管理 Python 教程程初学者, 介如何程, 使用 Python 行数据理与数据可化本旨在透数据探索的, 向学生介程与算思 Python 可比子表格强大的解决工具 Python 是一种易于使用与学的程言, 在 Windows Mac 与 Linux 算机上都可以免取本采用署名 - 非商性使用 - 相同方式共享可形式, 提供各种子格式的免下外, 本配套一免在自学程 (http://www.pythonlearn.com) 中所有内容材料是开放的, 可用于改翻明得益于开源与共享精神, 根据知共享 CC-BY-SA, 由作者授, 本的体中文版翻与开放出版得以利完成翻工作由范, 得到四川大学公共管理学院信息管理合室的大力支持, 胡康林校了本并提出宝意, 信息管理与信息系位本科生参与了部分章的翻与校功翻第 1 3 6 8 9 10 章及附王翻第 2 4 5 7 章范翻第 11-16 章, 稿与定稿由于精力与水平有限, 中翻在所免迎各位者批指正, 我会汲取建, 及行修勘献感志暹正了文中的一些和提出 Gitbook Markdown 法解析介 3

者序翻普遍被出力不好, 次我把翻当成一件情的活来干了本序由 4 个和 1 个明成, 希望能引起相关者的共什么要冠以信息管理之名? Informatics 在中文境下是个神秘的, 有情学信息学等法, 但个名称都不合适国内的情学不是搞的, 信息学是搞通的在信息的世界里, 美的会无不在通俗,Informatics 属于信息管理大范畴, 是信息管理活的高段, 通数据分析与掘, 提供管理与决策有价的信息 ( 即情 ) 信息管理听起来非常有魅惑力从早期一波波的数字化浪潮到当代的大数据, 信息管理无可争地在信息化代革的先, 一直与各型数据 ( 里可信息的体 ) 打交道个的主是数据 ( 信息 ) 的建采集加工与分析利用等什么信息管理要学程? 信息管理离不开信息技, 倒不如各信息技是解决信息管理中的而被明的依据此理, 学程是用技方法与工具来解决信息管理中的具体和提高工作效率看似有道理, 但中程个的学生感到困惑和畏惧, 常常与算机的程混淆重, 学起来既无趣又痛苦什么是 Python? C 言是大多数信息管理开的第一程毋庸置疑, 学 C 言首先从程思想上武装了初学者然而, 信息管理的学生未来并不打算从事程言本身的研究, 更多想要用程工具来解决外, 信息管理程体系里并没有多的程深入程, 程入与用接比薄弱或直接偏向了信息系开 ( 管理信息系方向 ), 学生从 C 言向其他眼花乱的高程言感到困, 致学的成就感普遍不高学了程, 拿着一全国算机等考 C 言, 没有什么意, 用不起来是最大的所在 Python 言的功能全面性与易于学等特点在程言入广泛流行, 近些年可以是深得民心除了言本身的点之外,Python 言非常适合信息管理, 原因在于它的功能性全面渗透到信息管理的各个, 如中介的文本理数据采集数据存与用 Web Services 等主由 Python 做到了很好的知串可以,Python 提供了程学与技用通的一化平台本将 Python 言的解与具体数据管理相合, 在一定程度做到了学会即用, 是目前比少的适合信息管理的程入教材什么要翻本? 开篇也提到是有情的事儿去, 我曾是国内最早一批信息管理与信息系的学生, 在, 我是个的一名教十多年来与个共同成, 自身也了程的种种迷茫与困惑随着信息技的快速化, 教学内容与手段的与俱也得非常必要工作之后, 我看到了 Python 来打通信息管理程学症的可能性, 开始翻各 Python 籍眼前的本人眼前一亮, 我非常同本作者的教学理念, 他的努力信息管理学生能松愉悦地学一功能强大的用型高程言通翻本, 希望更多信息管理的学生能找到程入的匙, 将 Python 作通向数据管理与分析技能养成的一座梁, 少走一些弯路我而言, 更多是在未来的教学中引入 Python 内容, 出适合国内信息管理的数据技能用型程如何本? 者序 4

然本不需要什么技基, 但最好具操作系数据与互网的一些基知本内容分大部分 : 第 1-10 章涵盖 Python 言的基知 ; 第 11-16 章是 Python 在数据管理与分析中的用中的所有示例与代均可免下, 建操作, 手并用收才会更多 12-15 章的程序代相复, 如果感到自学度大, 可先按照中解, 行源代, 出果看效果, 走通之后再回来慢慢研究代工欲善其事必先利其器正如本的副, 希望 Python 能成你学道路上探索信息世界的一把利器致首先要感美国密西根大学信息学院 Charles Severance 教授的慷慨支持, 使得本得以利自由出版技翻不是的文字工作, 心力, 事无巨也以做到不出从目到完成近 3 个月感段以来目提供支持和关心我的所有人, 没有你的鼓励与帮助, 凭我个人无法完成工作, 段令人忘感一路有你! 范四川大学信息管理技系 2015 年 6 月于雪城者序 5

作者序信息管理 Python 教程 : 一本混的开源在学界, 科研人不断被洗的是表或消亡, 从开始造, 做出原始新本不是原始新, 而是像算机科学家一思考 Python ( 以下称思考 Python )(Allen B. Downey, Jeff Elkner 等著 ) 本的一次混 2009 年 12 月, 我在密西根大学准授 SI502- 网程 ( 第五学期开 ), 决定开始写一本重于数据探索, 而不是理解算法与抽象理的 Python 教材我的 SI502 程目是培养学生使用 Python 的生数据理技能我的学生中很少有人打算成算机程序相反, 他的划是理律生物学家学家等他希望在所从事的行中能熟用技我似乎找不到适合的 Python 教材, 重以数据中心的, 因此我决定要写一本我打算利用假期从写本, 所幸, 在放假前三周的教工会上,Atul Prakash 博士我一本思考 Python, 他在那个学期使用本授 Python 程是一本很棒的算机教材, 特点在于篇幅短直白的解以及易于学本的整体已整尽可能快速地解决数据分析, 包括一系列从基到高的可行的数据分析示例与第 2-10 章与思考 Python 内容似, 主要区如下 : 面向数的示例与被面向数据的取代 ; 主的序按照循序原, 从数据理到复的数据分析解决方案 ; 一些主, 例如 try 与 except 整到前面, 作第 3 章条件的部分内容由于函数比抽象, 没有早出, 当需要理程序的复性才予以介几乎所有用定的函数都从第 4 章的例代与中移除了本不会出 1 个第 1 章和第 11-16 章的内容都是全新的, 主要介 Python 的用, 包括一些用于数据分析的 Python 示例, 例如, 搜索与解析的正表式, 算机上任的自化行, 通网索数据, 采集网数据,Web Services 的使用, 解析 XML 与 JSON 数据, 使用化言 SQL 行数据的建与使用等本做出些整的最目是, 从算机角向信息管理角, 涵盖技入程必需的主, 即使的学生并不打算成的程序也会感到有用本感趣的学生想要一步探索的, Alle B. Downey 的思考 Python 由于本的内容存在多重, 学生能从那本中快速掌握更多技程技能与提升算法思考能力外, 本的写作格相似, 完本之后能很容易通思考 Python 思考 Python 本的版所有者 Allen 授我中内容的版做了修改, 将本中保留的他中的内容可从 GNU 自由文档可更最近流行的知共享以相同方式共享 (CC-BY-SA) 一做法符合开放文档可从 GFDJ 到 CC- BY-SA 的 ( 如, 基百科的授方式 ) CC-BY-SA 可保留了最著的版, 同又允新作者直接重用中他得合适的内容我得本是教学料开放的一个典范, 未来的教育而言非常重要感 Alleb B. Downey 和大学出版社做出的前瞻决定, 本可以在开放版下出版希望他我努力的果感到欣慰, 我也希望者我的集体努力感到高我要感 Allen B. Downey 与 Lauren Cowles 在解决本版提供的帮助耐心与指 Charles Severance www.dr-chuck.com Ann Arbor, MI, USA 2013 年 9 月 9 号 Charles Severance 博士是密西根大学信息学院的床副教授 1. 当然, 里出的除外作者序 6

作者序 7

第 1 章什么要学程程是一极具造性和有益的活程的原因很多, 大到生去解决一个困的数据分析, 小到因帮助人解决一个而得快本假定每个人都需要知道怎程, 一旦学会程, 你就会想要用个新技能做些什么了我的日常生活中算机无不在, 大到本, 小到手机些算机可帮助我打理很多事情的私人助理如今的算机硬件从根本上是建在不断回答我提的基上, 即下一步想要做什么? 程序在硬件之上添加了操作系和用程序, 我手中拿到的成品是一个很有用的个人数字助理 (PDA,Personal Digital Assistant), 它能帮我理很多不同的事情算机行速度很快并有大量的内存, 如果我知道了如何与算机通, 告算机想要它接下来做什么, 更好地使用算机很有帮助如果掌握了算机通言, 就能算机根据我的意愿完成一些重复性工作有趣的是, 算机能任并且做得很好的工作就是那些常我人感到无聊令人麻木的事情例如, 本章的前三段, 找出出率最高的是一个, 以及个共出了多少次尽管你能在短内和理解些文字, 但要它行就很痛苦了不是人的大擅解决的算机恰好相反, 很像人一和理解一段文字, 但是行文字并告你出率最高的及其出次数, 算机而言却是非常容易的 : python words.py Enter file:words.txt to 16 个人信息分析助理很快告我, to 在本章前三段中一共出了 16 次事上, 算机擅做人不擅做的事, 就是什么你需要熟掌握一与算机的言一旦学会新言, 你就可以将枯燥的工作指派你的算机搭档了, 留出更多的去做适合你自己的事在种合作关系中, 你的献是才思直力和造力 1.1 新与机本不是程序准的, 程是份非常有前途的工作, 可算是物与精神双丰收他人造有用的的与智能的程序是一新性很强的活你的算机或 PDA 通常安装了来自多不同程序开的各种件, 每一款件都想要吸引你的注意力和趣它尽其所能来足你的需求, 在使用程中你得的用体在某些情况下, 当你了一个件, 个件的开者就会因你的而直接得收益如果将程序看作是程序的新性出, 那么下就是一个更形象的 PDA 模型 : 什么要学程 8

本的写作初衷不是了或者取悦最用, 而是我能更好地理生活中的数据与信息开始学程, 你既是程序, 也是你所写程序的最用当你得了程序的技能, 如果程你感到有新活力的, 到你的想法也会生改, 向他人开程序也不定 1.2 算机硬件架学种向算机指令来开件的言之前, 我需要了解一下算机的成如果拆开你的算机或者手机, 仔察就会以下些件 : 些件的一般定如下 : 中央理器 (Central Processing Unit,CPU) 是解决下一步做什么而存在的件如果算机理速度到 3.0 GHz, 就意味着 CPU 每秒会提 30 次下一步做什么? 你不得不学会如何跟 CPU 如此快速地交与保持同步主存器 (Main Memory) 用来存 CPU 即刻需要的信息主存器的速度几乎与 CPU 不相上下但是, 关算机之后主存器里的信息也就消失了助存器 (Secondary Memory) 也是用来存信息的, 但是它比主存器速度慢很多助存器的点是, 它可以在算机不情况下存信息常助存器包括磁和存存通常用在 U 和便携式音播放器上入出 (Input and Output Devices) 包括屏幕鼠麦克声器以及触摸板等些都是用来与算机行交互的如今大多数算机之建立了网接, 通网取信息我可以将网看成信息存与索速度很慢的一个空, 而且不是那么定从某种意上, 网是速度很慢且并不是那么可靠的助存器些件的工作原理最好是交算机厂商吧里只是了掌握一些, 在程方便提及些件作一名程序, 你的工作就是利用并些源来解决和分析数据作程序, 你主要与 CPU 打交道, 告它下一步做什么有, 你要告 CPU 用主存器助存器网或入出什么要学程 9

你需要成回答 CPU 下一步做什么的人但把你到 5 毫米高, 塞入算机, 你每秒出 3 次命令, 想必会很不舒服所以, 你必提前写好你的指令我把些存下来的指令称程序, 写指令并行的活称之程 1.3 理解程在本其他章中, 我把你培养成一名理解程并具一定程能力的人最后, 你会成一个程序, 也不是的但至少你掌握了如何看待数据 ( 信息 ) 分析, 并开出解决的程序从某种意上来, 程序的养成需要种技能 : 首先, 需要掌握程言 (Python) 本身熟悉和法能准确地拼写新言中的, 并且掌握如何使用新言正确地造句其次, 学会故事在写故事的程中, 通文字和句式的合, 向者思想故事的与能力通写作与反得以提高在程中, 程序即故事, 待解决的即的想法当掌握一种程言 ( 如 Python) 之后, 你会学其他程言, 如 JavaScript 或者 C++, 就会容易多然新的程言有很多不同的和法, 但你已学会解决的技能, 所有程言本上都是相通的 Python 的和句式上手很快, 但要能写出一些的程序来解决一个全新的, 尚需日磨授程就像授写作一先程序行和解, 然后写的程序, 接着逐步写更复的程序当到一定水平, 你就形成了自己的程格, 自然而然地去, 通写程序解决它一旦修到个程度, 程就成一个愉悦且富有造力的程了我从 Python 程序的和起第一次, 一定要耐心学那些的例子 1.4 与句子与人言不同的是,Python 的数量上相当少我称些保留字, 它是 Python 中具有特殊意的于 Python 来, 程序中出的些, 它有且有一个含等下你在程, 你自己定的称量量命名非常自由, 但有一点, 你不能使用 Python 的保留字作量名从某种意上, 我一只狗会使用一些特殊的, 比如坐下停下和拿来跟狗不用些保留字的, 它就会傻傻地看着你, 直到你它出保留字例来, 我希望更多的人通散步来促健康, 而大多数狗听到的可能是, 吧吧散步吧吧是因在狗的言中散步是保留字很多人可能得人和猫之的言没有保留字 1 Python 的保留字如下 : 什么要学程 10

and del from not while as elif global or with assert else if pass yield break except import print class exec in raise continue finally is return def for lambda try 就么多 Python 比狗有素多了当你 try,python 会毫无差地行 try 后章会介些保留字及它的适用合在, 我只关注怎么与 Python ( 就像人跟狗 ) 教 Python 是件有意思的事情, 把想要的用引号括起来就可以了 print 'Hello world!' 就是我写出的第一个法正确的 Python 句以保留字 print 开, 后面跟一个文本字符串, 用引号括起来 1.5 与 Python 我已掌握了 Python 的一个与一个句, 接下来需要了解如何与 Python, 我的新言技能与 Python 之前, 必先在算机上安装 Python 件, 学会如何 Python 本章包含多, 建看 http://www.pythonlearn.com, 网站上有 Python 在 Mac 和 Windows 系上配置和的明和演示当打开端或者命令行窗口, 入 python,python 解析器会以交互模式, 如下所示 : Python 2.6.1 (r261:67515, Jun 24 2010, 21:47:49) [GCC 4.2.1 (Apple Inc. build 5646)] on darwin Type "help", "copyright", "credits" or "license" for more information. >>> >>> 提示符表示 Python 解析器在, 你希望我下一步做什么? Python 已准好与你你需要掌握的是怎 Python 言, 起一个个例子, 你 Python 言最的或句子一无所知, 想要使用宇航的准用 ( 喊 ) 宇航在一个遥的星球登, 着和个星球的居民用以下句 : >>> I come in peace, please take me to your leader File "<stdin>", line 1 I come in peace, please take me to your leader ^ SyntaxError: invalid syntax >>> 事情展好像并不利除非你反迅速, 否个星球的居民可能会拿矛刺向你, 向你吐口水, 然后把你放在火上烤, 当成晚吃掉幸的是, 旅行你了本, 及翻到了一, 再一次 : >>> print 'Hello world!' Hello world! 次看起来效果不, 着与他 : 什么要学程 11

>>> print 'You must be the legendary god that comes from the sky' You must be the legendary god that comes from the sky >>> print 'We have been waiting for you for a long time' We have been waiting for you for a long time >>> print 'Our legend says you will be very tasty with mustard' Our legend says you will be very tasty with mustard >>> print 'We will have a feast tonight unless you say File "<stdin>", line 1 print 'We will have a feast tonight unless you say ^ SyntaxError: EOL while scanning string literal >>> 此, 你意到,Python 然非常复与强大, 但在法上非常挑剔, 并不那么智能中必使用正确的法在某种意上, 当你使用人写的程序,Python 就在你和其他程序之充当中人 Python 是程序写者将行下去的一种方式在完短短几章之后, 你将成 Python 程序中的一, 与你的程序使用者行束与 Python 解析器的第一次之前, 你可能要知道如何正确地与个星球的居民再 : >>> good-bye Traceback (most recent call last): File "<stdin>", line 1, in <module> NameError: name 'good' is not defined >>> if you don't mind, I need to leave File "<stdin>", line 1 if you don't mind, I need to leave ^ SyntaxError: invalid syntax >>> quit() 你会前个提示是不同的由于 if 是保留字,Python 看到保留字会我想些什么, 但句子的法是的跟 Python 再的正确方法是, 在交互模式的提示符 >>> 后入 quit() 猜出个命令可能会花一些, 所以手本可能会派上用 1.6 : 解器与器 Python 是一种高言, 旨在方便地人行写, 算行取与理其他高言包括 :Java C++ PHP Ruby Basic Perl 以及 JavaScript 等 CPU 里的硬件并不能理解任何一种高言 CPU 能理解的言称之机器言机器言非常, 坦白, 写起来非常无聊它全部由 0 和 1 成 : 01010001110100100101010000001111 11100110000011101010010101101101... 然机器言表面看起来很, 只有 0 和 1, 但它的法比 Python 复得多所以, 很少有程序用机器言程相反, 借助各种翻器, 程序可以写像 Python 或 JavaScript 的高言, 些翻器会将程序成机器言, 再交由 CPU 行因机器言依附于算机硬件, 所以不能在不同型硬件之移植使用高言写的程序可以在不同的算机之移植, 通在一台算机上使用不同的器, 或者重新代, 生成一个适合台算机的机器言版本程言的翻器大体可分 :(1) 解器与 (2) 器什么要学程 12

解器取程序所写程序的源代, 解析源代并解指令 Python 是一种解器当交互式行 Python, 入一行 Python 句,Python 就会立即理它, 并做好准我入下一条句 Python 句中有一些地方会告 Python, 你想要 Python 住等下会用到的一些数据就需要数据挑一个名称来住它, 之后就可以通个名称来取的数据了我使用量 (variable) 来代表存的数据 >>> x = 6 >>> print x 6 >>> y = x * 7 >>> print y 42 >>> 在个例子中, 我 Python 住数 6, 并将 6 量 x, 以便后使用了确 Python 已住个数, 使用 print 命令打印量 x 的接下来, 我 Python 取量 x 的并乘以 7, 然后将果新量 y 最后, 打印出当量 y 的当前一次入一行命令,Python 将其一个句序列, 后面的句可以取前面句的数据四句成的段落以一种有的和有意的序写, 就是我写出的第一个的多行程序如上所示, 解器的本是行交互式器需要将整个程序放在一个文件中, 将高次的源代翻成低次的机器言, 然后器将生成的机器言放到一个文件中以便后行如果你使用 Windows 系, 些可行的机器言程序通常有.exe 或.dll 后, 分代表是可行的和可加在 Linux 和 Mac 中没有的后来明确表示文件是否是可行的如果在文本器中打开一个可行文件, 眼望去完全看不 : ^?ELF^A^A^A^@^@^@^@^@^@^@^@^@^B^@^C^@^A^@^@^@\xa0\x82 ^D^H4^@^@^@\x90^]^@^@^@^@^@^@4^@ ^@^G^@(^@$^@!^@^F^@ ^@^@4^@^@^@4\x80^D^H4\x80^D^H\xe0^@^@^@\xe0^@^@^@^E ^@^@^@^D^@^@^@^C^@^@^@^T^A^@^@^T\x81^D^H^T\x81^D^H^S ^@^@^@^S^@^@^@^D^@^@^@^A^@^@^@^A\^D^HQVhT\x83^D^H\xe8... 机器言的写并不容易, 好在借助解器和器, 能使用 Python 或 C 的高言写程序通解器与器的, 你 Python 解器本身有了一些了解那它又是用什么言写的? 是用言写的? 当我入 python, 究竟生了什么? Python 的解器是用 C 言写的你可以 http://www.python.org 网站, 看 Python 解器的源代, 如有你有意愿改造些源代也是可以的 Python 本身就是一个程序, 它被成机器代当你 ( 或硬件供商 ) 在算机上安装了 Python, 是上将一份好的 Python 程序的机器代拷到你的算机系在 Windows 中,Python 可行的机器代很可能位于以下文件中 : C:\Python27\python.exe 要成一名 Python 程序, 你知道些不但在一开始, 花一些解些, 是得的 1.7 写一个程序体 Python 功能的最好方式是在 Python 解析器中入命令, 但不建采用种方式来解决复的什么要学程 13

程, 我在文本器里把 Python 指令写到一个文件里, 个文件称脚本一般而言,Python 脚本以.py 命名尾行脚本, 你必告 Python 解器脚本文件的名称在 Unix 或 Windows 命令窗口中, 你可以入以下代来行 hello.py 脚本文件 : csev$ cat hello.py print 'Hello world!' csev$ python hello.py Hello world! csev$ csev$ 是操作系提示符, cat hello.py 是看 hello.py 文件的内容, 其中包含了字符串打印的一行 Python 程序我用 Python 解器, 告它从 hello.py 文件中取源代, 而不是用命令行交互式行 Python 代你会, 没有必要在 Python 程序文件末尾加上 quit() Python 取源代文件, 到文件末尾它会自己停止 1.8 什么是程序? 程序的基本定是, 完成特定任的一 Python 句序列最的 hello.py 脚本也是一个程序, 不只是一行代的程序了, 没多大作用, 但是从格的定上来, 它是一个 Python 程序考一个可以被程序解决的, 然后用程序来解决它, 可能是理解程序的最方式假, 你想 Facebook 上的帖行社会算方面的研究, 可能感趣的是帖中最常用的是什么你可以打印出些帖, 然后通文本, 从中找最常的, 但需要很而且很容易出通写 Python 程序来快速且准确地理个任, 会比明智, 周末就可以做些其他有趣的事了例来, 以下内容, 是关于一个小丑和一的文本, 找出出次数最多的, 并它出的次数 the clown ran after the car and the car ran into the tent and the tent fell down on the clown and the car 想象一下, 要数百万行文本来完成个任会是怎的情形坦率地, 学 Python, 写一个 Python 程序来的, 要比人工描快得多一个好消息, 我用一个程序解决了在文本文件中找到最常的个我已写好并了个程序在, 我把它交你使用, 就可以省你的一些 name = raw_input('enter file:') handle = open(name, 'r') text = handle.read() words = text.split() counts = dict() for word in words: counts[word] = counts.get(word,0) + 1 bigcount = None bigword = None for word,count in counts.items(): if bigcount is None or count > bigcount: bigword = word bigcount = count print bigword, bigcount 什么要学程 14

你甚至不需要知道 Python 就可以使用个程序你需要通本第 10 章来完全理解所用到的 Python 程技你在是最用, 只需使用个程序, 你就会于它的明, 感如何你脱繁重的手工描你只需入代, 保存成 words.py 文件并行它, 或者也可以从 http://www.pythonlearn.com/code/ 下源个示例充分体了 Python 以及言在你 ( 最用 ) 与我 ( 程序 ) 之扮演的中人角色在安装了 Python 的用算机上,Python 作一种通用言, 我可以交有用的指令序列 ( 即程序 ) 因此, 我并不是跟 Python 交流, 而是通 Python 与其他人交流 1.9 程序的架后章会介深 Python 的句子段落与篇章我将学 Python 的强大功能, 以及如何将些功能合起来建有用的程序程序的造包含一些低次的概念模式些造模式不 Python 程序, 而是每一种程言从机器言到高言的通用成部分入 : 从外部世界取数据, 可以从文件中取数据, 或者从某种感器, 比如麦克或 GPS 取数据在我最初的程序中, 入是用通入数据出 : 将程序的果示在屏幕上, 或保存在一个文件, 或写入一个, 如声器可以播放音或朗文字序行 : 按照脚本中的句序, 一句接一句行条件行 : 根据特定条件行或者跳特定句序列重复行 : 重复行一些句, 通常也会存在一些化重用 : 写好一指令, 它命名, 之后在程序中根据需要可以再次使用些指令些听起来好像很容易, 事上并不是那么就好比, 走路很吧, 把一只脚放在一只脚前面程的就是不断造和合些基本元素, 造用有用的西除了重用模式之外, 上面的程序几乎用到了上面提及的所有模式 1.10 致出的原因在前面与 Python 的中已看到, 我写 Python 代必非常精确, 很小的偏差和都会致 Python 放弃行程序初学者通常,Python 不能容忍犯, 人留下低劣可恨与残忍的印象然 Python 看上去与其他人一, 但它能理解初学者, 只是把种抱怨化督促, 我更好地写程序不要再 Python 老是折磨我了 >>> primt 'Hello world!' File "<stdin>", line 1 primt 'Hello world!' ^ SyntaxError: invalid syntax >>> primt 'Hello world' File "<stdin>", line 1 primt 'Hello world' ^ SyntaxError: invalid syntax >>> I hate you Python! File "<stdin>", line 1 I hate you Python! ^ SyntaxError: invalid syntax >>> if you come out of there, I would teach you a lesson File "<stdin>", line 1 什么要学程 15

if you come out of there, I would teach you a lesson ^ SyntaxError: invalid syntax >>> 与 Python 争没什么好它只是一个工具, 没有情感, 它很高随准你服它的信息看起来很苛刻, 但些信息帮助提供索 Python 看到了你入的内容, 但不明白你入的是什么 Python 更像一只狗, 无条件你, 只能理解很少的关, 用它那甜美的表情 (>>>) 看着你, 等待你入一些它能理解的西当 Python 道 : SyntaxError: invalid syntax, 它只是着尾巴 : 你似乎了什么, 但我不太明白, 你跟我 (>>>) 当程序得越来越复, 你会遇到以下三种型的 : 法 : 是你遇到的第一种, 很容易解决法意味着, 你反了 Python 的法 Python 会尽可能指出一行句中它所困惑不能理解的地方和字符法唯一棘手的是, 有候程序中需要修改的可能位于 Python 所指出困惑的位置前方所以,Python 指出的法位置只是你排的起点 : 是程序没有法前提下, 句序或句关系存在的一个形象例是, 打开水瓶喝口水, 把它放到包里, 走到, 然后再把水瓶盖上 : 是程序的法完美且正确, 但无法到期也就是, 程序完全正确, 但它不能做到你想要它做的事一个的例子, 如果你人指路怎么去一家餐, 如此 : 当你走到有加油站的十字路口, 向左, 走一英里, 你的左手有一座色建筑, 餐就在那儿了很, 你的朋友打来, 他正在一个, 着一个谷圈, 并没有看到餐的志然后, 你 : 你在加油站左是右了? 他 : 完全是按你指示的方向走, 我写到上, 在加油站左, 走一英里然后, 你 : 非常抱歉, 然我的方向指示在法上没, 但其中悲催地包含了一个很小的没有被的于三种,Python 会尽最大努力按照你的要求准确地去行 1.11 学之旅当循序本, 如果初次遇到某些概念不能很好理解, 不要担心小候学, 几年只要能出一些可的喃喃之音, 不是什么花 6 个月的, 从能的展到能表的句子, 再用 5 到 6 年的, 从句子上升到段落, 的展程是正常的再几年就能依据自身趣, 独立写出一篇完整的作文了我希望你能以更快地速度学 Python, 所以有些内容在接下来的几章中会多次涉及到学一新言需要花去吸收和理解, 才能做到用自如全景是由一小的片段拼接起来的我会一再提及一些主, 你看清全景, 可能会致一些混乱由于的体例是性的, 如果你参加一, 推方式是性的, 但不要受此束前后来回翻, 行一些略在没有充分理解之前, 跳有度的内容, 有助于更好的理解程之道通回之前的内容, 或者重做之前做的, 你可能会感收多, 其中些内容可能在你一开始接触得有些解的学第一程言, 通常会有一些得呼雀的刻就像用斧精心雕琢, 一岩石最在你手中成一尊美的雕塑如果有些事看起来特困, 通宵熬夜耗着是没有意的休息一下, 打个, 吃点零食, 向某人 ( 可能是你的狗 ) 下你当下遇到的, 然后, 以全新的眼光回来再看个我保, 一旦你从本中学会了程知, 再回看, 你会程是非常和雅的行, 只是需要花一些去吸收了 1.12 臭虫 : 程序中的什么要学程 16

中央理元 : 所有算机的心我写的件都由它来行, 也称 CPU 或者理器 : 把高言写的程序翻成低言, 后行做好准交互模式 : 在提示符后入命令和表式, 是 Python 解器的一种使用方法解 : 采用一次翻一行的方式来行高言写的程序低言 : 一种旨在便于算机行的程言, 也称机器或言机器代 : 最接近硬件的程言, 可直接由中央理元 (CPU) 行主存器 : 存程序和数据关源后主存器的信息会失解析 : 程序和分析法可移植性 : 程序的一个属性, 即程序可在不同型的算机上行 print 句 : 能 Python 解器在屏幕上示数据的指令解决 : 提出一个, 找到解决方法并形成解决方案的程程序 : 特定算的一指令集提示 : 程序示一个消息, 等待用的入助存器 : 存程序和数据, 源关后数据不会失助存器的速度通常比主存器慢助存器包括磁器 U 中的存等 : 程序本身的含 : 程序的一种程序并未按照程序意愿做事源代 : 程序的高言代 1.13 1.1 算机的助存器的功能是什么? a) 行程序的所有算和 b) 在互网上索网 c) 期存信息, 甚至重之后信息不会失 d) 接收用的入 1.2 什么是程序? 1.3 器和解器有什么区? 1.4 下面个包含了机器代? a) 解器 b) 什么要学程 17

c)python 源文件 d)word 文档 1.5 找出下面代的 : >>> primt 'Hello world!' File "<stdin>", line 1 primt 'Hello world!' ^ SyntaxError: invalid syntax >>> 1.6 行以下 Python 句, 量 X 存于何? x = 123 a) 中央理器 b) 主存器 c) 助存器 d) 入 e) 出 1.7 以下程序会出什么? x = 43 x = x + 1 print x a)43 b)44 c)x+1 d) 出, 因 x = x + 1 在数学上不通 1.8 以人作比, 解以下事物 :(1) 中央理元,(2) 主存器,(3) 助存器,(4) 入和 (5) 出例如, 算机的中央理元相当人体个部位? 1.9 如何解决法? 1. http://xkcd.com/231/ 什么要学程 18

第 2 章量表式与句 2.1 与型是程序的基本成要素, 如一个字母或一个数字目前止, 我接触到的有 1 2 和 Hello,World! 些属于不同的型 :2 是整数, Hello,World! 是字符串 ( 包含一串字母 ) 你 ( 或者解器 ) 可以根据有无引号来判是否是字符串 print 句也可以打印整数入 python 命令解器 python >>> print 4 4 如果不确定一个属于种型, 解器会告你 >>> type('hello, World!') <type 'str'> >>> type(17) <type 'int'> 而易, 字符串属于 str 型, 整数属于 int 型小数点的数字使用浮点 (floating-point) 格式表示, 称 float 型 >>> type(3.2) <type 'float'> 那么, 像 '17' 和 '3.2' 种属于种型呢? 看起来像数字, 但它和字符串一被放在引号里面 >>> type('17') <type 'str'> >>> type('3.2') <type 'str'> 它是字符串入大的数字, 可能会在每三个数字之加一个逗号, 例如,1,000,000 在 Python 中不是一个整数, 但表示是合法的 >>> print 1,000,000 1 0 0 不是我想要的!Python 解器会把 1,000,000 当做一个逗号分隔的数字序列, 它会把三部分依次打印出来, 中用空格分开是我遇到的第一个例子 : 代行不会出任何信息, 但是它并没有做正确的事 2.2 量量表式与句 19

程言最强大的功能之一体在量的操作能力量是一个的引用名称句用来建新量并其 : >>> message = 'And now for something completely different' >>> n = 17 >>> pi = 3.1415926535897931 个例子列了三种不同型的句第一条句将字符串量 message; 第二条句将整数 17 量 n, 第三条句将 π 的近似量 pi 使用打印句出些量的 >>> print n 17 >>> print pi 3.14159265359 量的型就是它所指向的的型 >>> type(message) <type 'str'> >>> type(n) <type 'int'> >>> type(pi) <type 'float'> 2.3 量名与关字程序通常会有意的量名, 通量名直地了解量的用途量名不限度, 可以同包含字母和数字, 但是必以字母开使用大写字母也是合法的, 但使用小写字母会更好 ( 随后会解原因 ) 下划可以出在量名中它常用在含有多个的量名中, 例如,my_name 和 airspeed_of_unladen_swallow 量名可以采用下划开, 但一般要避免命名, 除非是写供他人使用的 Python 代如果使用不合法的量名, 你就会得到一个法 : >>> 76trombones = 'big parade' SyntaxError: invalid syntax >>> more@ = 1000000 SyntaxError: invalid syntax >>> class = 'Advanced Theoretical Zymurgy' SyntaxError: invalid syntax 76trombones 不是合法的量名, 它不是以字母开的 more@ 也是不合法的, 它包含了一个不合法的字符 @ 量名 class 在呢? 原因在于,class 是 Python 的保留关字 Python 解器使用保留关字来程序的, 因此, 保留关字不能用于量名 Python 的 31 个保留关字如下所示 1 : 量表式与句 20

and del from not while as elif global or with assert else if pass yield break except import print class exec in raise continue finally is return def for lambda try 你可以在手存留一份如果解器指出了一个量名不合法, 而你又不知道什么, 那么一下量名是否在个列表里面 2.4 句句是 Python 解器能行的代元我已到个句 :print 和 assignment 在交互模式中入一条句, 解器就会行它并打印出果 ( 如果有果的 ) 程序例如下 : print 1 x = 2 print x 得到以下出果 : 1 2 其中, 句没有出果 2.5 算符和算象算符是表示算的一特殊符号, 例如, 加法与乘法算符操作的称算象 + - * / 和 ** 五个算符分代表加乘除和次方的算, 看如下示例 : 20+32 hour-1 hour*60+minute minute/60 5**2 (5+9)*(15-7) 除算的果可能不是你所期待的 : >>> minute = 59 >>> minute/60 0 minute 的是 59, 在的算中,59 除以 60 是 0.98222, 而不是 0 出种差异的原因在于,Python 行的是地板除法 (floor division) 2 当个算象都是整数, 那么果也是整数地板除法默去掉小数部分, 因此上面的算果是 0 如果个算象都是浮点数, 那么 Python 会行浮点除法, 果就是浮点数 : 量表式与句 21

>>> minute/60.0 0.98333333333333328 2.6 表式表式是量和算符的合本身可以是一个表式, 量亦如此下面都是合法的表式 ( 假量 x 已被 ): 17 x x + 17 如果在交互模式中入一个表式, 解器就会行它并把果打印出来 >>> 1 + 1 2 然而, 在一个程序中, 表式本身并不能做任何事情! 是初学者容易混淆的一点 2.1 在 Python 解器中入下面的句并看果 : 5 x = 5 x + 1 2.7 算序当一个表式中出多个算符, 算序按照一定行于数学算符来,Python 遵照数学算, 先括号再次方接着乘除后加 (PEMDAS) 会帮助你住算序括号有最高算先, 表式按特定序行算括号内的表式先行算, 例如,2 (3-1) 等于 4, (1+1)**(5-2) 等于 8 有候, 括号即便没有改算果, 但可以起来更加方便, 例如,(minute 100) / 60 算的次于括号, 例如,2**1+1 等于 3, 而不是 4,3*1**3 等于 3, 而不是 27 乘法和除法具有相同的先, 高于加法和法例如,2*3-1 等于 5, 而不是 4,6+4/2 等于 8, 而不是 5 相同先的算符按从左到右的序依次算例如,5-3-1 等于 1, 而不是 3 先算 5-3 得到的 2, 然后再 1 当不能确定算序, 通常使用括号来确保既定的算序 2.8 模算模的算象是整数, 得到的是第一个整数与第二个整数相除的余数在 Python 中, 模算符用百分号 (%) 表示, 法与其他算符一致 : >>> quotient = 7 / 3 >>> print quotient 2 >>> remainder = 7 % 3 >>> print remainder 1 量表式与句 22

7 被 3 所除的商是 2, 余数是 1 模算非常用例来, 你可以一个数是否能被一个数整除, 如果 x%y 的果是 0, 那么 x 能被 y 整除外, 模算也可以提取出一个数字最右的数位例来,x%10 可以提取出一个数最右的一位数字 ( 以 10 基数 ) 同理,x%100 可以提取出一个数最右的位数字 2.9 字符串算符加号的算象是字符串, 它会把字符串首尾相里不是数学意上的加号例如 : >>> first = 10 >>> second = 15 >>> print first+second 25 >>> first = '100' >>> second = '150' >>> print first + second 100150 个程序的出果是 100150 2.10 求用入有候我希望取用通入的 Python 提供了一个入函数 raw_input, 用来取入 3 当用个函数, 程序会停行, 等待用的入当用按下回, 程序就恢复行,raw_input 函数以字符串形式返回用入的 >>> input = raw_input() Some silly stuff >>> print input Some silly stuff 从用取入之前, 最好打印一条提示句, 告用可以入些什么在程序停等待用入之前, 你可以在 raw_input 中插入一个字符串来提示用 >>> name = raw_input('what is your name?\n') What is your name? Chuck >>> print name Chuck 提示尾的 \n 表示新开辟一行, 它是一个用于行的特殊字符一来, 用入的位置出在提示句的下面如果希望用入一个整数, 你可以 int() 函数, 将返回的成整数型 : What...is the airspeed velocity of an unladen swallow? 17 >>> int(speed) 17 >>> int(speed) + 5 22 但是, 如果用入的不是数字成的字符串, 那么就会 : 量表式与句 23

>>> speed = raw_input(prompt) What...is the airspeed velocity of an unladen swallow? What do you mean, an African or a European swallow? >>> int(speed) 随后会介如何理 2.11 注当程序得越来越复, 度也随之增大正的程序代很密集, 常会遇到看不段代是做什么的, 或者什么要写解决个, 在程序代中加入自然言明, 解段代的作用, 会是一个不的主意些明称注, 它以 # 号开 : # compute the percentage of the hour that has elapsed percentage = (minute * 100) / 60 上面种情况, 注本身占一行你也可以把它加到一行代的末尾 : percentage = (minute * 100) / 60 # percentage of an hour 从 # 号开始到一行的最后, 都会被忽略掉, 它不会程序生任何影代不著的特征行明, 注非常有用注会帮助代者搞清楚段代的作用注用于代什么写的解, 同有用下面行注明是多余的, 没什么作用 : v = 5 # assign 5 to v 而下面的行注包含了有用的信息 : v = 5 # velocity in meters/second. 清晰易的量名能少注的使用, 但是量名如果太, 就会使复的表式得更加, 所以需要衡利弊 2.12 易的量名只要遵循量命名的, 避免使用保留字, 量的命名是有很多种的程入段, 你在人的程序和写自己的程序, 量的命名可能会感到困惑例如, 下面三个程序上是一的, 但是和理解起来差很大 a = 35.0 b = 12.50 c = a * b print c hours = 35.0 rate = 12.50 pay = hours * rate 量表式与句 24

print pay x1q3z9ahd = 35.0 x1q3z9afd = 12.50 x1q3p9afd = x1q3z9ahd * x1q3z9afd print x1q3p9afd Python 解器三个程序的理方式完全一, 但是于者理解起来差异很大者能快速看的是第二个程序, 是因程序了能代表量取含的量名种量命名法称助量命名法助 4 的意思就是帮助易于的量名, 有助于我住当初建个量是了做什么看起来不, 使用助量命名法是一个好主意, 但可能也会初学者解析与理解代上生面影由于初学者可能没有全 Python 的 31 个保留字, 如果量名中包含太多描述性的, 精心命名的量看上去会像是 Python 言的一部分, 初学者理解上造成干下面行的 Python 代了循循将在第 5 章介, 里猜猜行代的含 : for word in words: print word 行上面的代会生什么?for word in 等几个中些是保留字, 些是量名?Python 能理解的基本含? 初学者很分辨出代中些部分必照抄示例中的, 而些部分是可以自主的下面的代和上面的代上是一的 : for slice in pizza: print slice 通察段代, 初学者可以容易地分辨些是 Python 保留字, 些是程序自己定的量名而易,Python 不能理解 pizza 和 slice 之的差, 上就是一个披可以切成很多如果程序要取数据并在数据中找,pizza 和 slice 是不容易住的量名它作量名会偏离程序的本意不了多久, 你会熟悉最常用的保留字并在程序中注意到它 : for word in words: print word 段 Python 代中 for in print 和 : 加粗示, 程序自己定的量名不加粗很多文本器支持 Python 法, 它会使用不同的色来保留字, 你能方便地区分保留字与量名熟悉一段后, 你就会很快地区分些是保留字, 些是量名 2.13 最容易出的法是不合法的量名, 例如,class 和 yield 是保留字, 或者包含不合法字符的 odd~job 和 US$ 如果量名中存在空格,Python 会它是没有算符的个算象 : >>> bad name = 5 SyntaxError: invalid syntax 法的提示信息提供不了什么帮助最常的信息是 SyntaxError: invalid syntax 和 SyntaxError: invalid token, 量表式与句 25

条都没有提供什么有价的信息最常遇到的行是 use before def;, 个的意思是使用了一个没有的量种情况容易出在量名拼写的情况 : >>> principal = 327.68 >>> interest = principle * rate NameError: name 'principle' is not defined 量名区分大小写, 例如,LaTeX 和 latex 是不一的最容易出的是算序例来,$\dfrac{1}{2π} $ 可能会写成 : >>> 1.0 / 2.0 * pi 个句首先行除法算, 得到的果是 π/2, 然跟 $ \dfrac{1}{2π} $ 不是一回事!Python 并不明白个表式是什么意思种情况下然不会, 但算果是的 2.14 : 量予一个的句接 : 将个算象首尾相接注 : 程序里面包含的信息, 旨在帮助其他程序 ( 或者看源代的人 ) 理解程序, 不会程序的行生任何影求 : 表式行算, 得到一个表式 : 量算符和的合, 表示一个果浮点 : 有小数部分的数地板除法 : 截掉数相除所得果的小数部分的一种除法算整数型 : 代表整数型关字 :Python 解器用来解析程序的保留字量命名不可使用保留字, 例如,if def 与 while 等助法 : 一种助的方法通常使用易的量名来帮助我理解量本身包含的内容模算 : 用百分号 (%) 表示, 求数相除的余数算象 : 算符操作的象算符 : 能行算的一特殊符号, 例如, 加法乘法和字符串接算先 : 一算, 用来定多个算符和算象的表式中算行的次序句 : 包含指令和行的一段代目前止, 我到了句和打印句字符串 : 由字符序列成的数据型型 : 表示一目前止, 我到了整数 (int), 浮点数 (float) 和字符串 (str) 量表式与句 26

: 数据的基本位, 例如, 程序中可以操作的数字或字符串量 : 一个的引用名称 2.15 2.2 使用 raw_input 写一个程序, 提示用入姓名, 然后打印出迎 Enter your name: Chuck Hello Chuck 2.3 写一个程序, 用入工和薪, 然后算出工 Enter Hours: 35 Enter Rate: 2.75 Pay: 96.25 不用担心果是否精确到小数点后位如果需要精确到小数点后位, 可以使用 Python 内置的 round 函数 2.4 行下面的句 : width = 17 height = 12.0 写出以下表式的及的型 1. width/2 2. width/2.0 3. height/3 4. 1 + 2 * 5 使用 Python 解器你的果是否正确 2.5 写一个程序, 用入氏温度, 然后将其化成氏温度, 最后将化后的温度打印出来 1. Python 3.0 中,exec 不再是保留关字,nonlocal 是新的保留关字 2. Python 3.0 中, 做除法的果是浮点数新的算符 // 做整数除法 3. Python 3.0 中, 个函数称 input 4. " 助 " 的有关介, 参 http://en.wikipedia.org/wiki/mnemonic 量表式与句 27

第 3 章条件行 3.1 布表式布表式是具有真或假状的一种表式 == 算符用来比个算象, 若者相等返回 True, 否返回 False: >>> 5 == 5 True >>> 5 == 6 False True 和 False 是布型的个取, 它不是字符串 : >>> type(true) <type 'bool'> >>> type(false) <type 'bool'> == 算符是比算符中的一个, 其他的比算符如下 : x!= y x > y x < y x >= y x <= y x is y x is not y # x is not equal to y # x is greater than y # x is less than y # x is greater than or equal to y # x is less than or equal to y # x is the same as y # x is not the same as y 然你可能很熟悉些算符, 但要注意些 Python 符号并不等同于数学符号一个常的是用等号 (=), 而没有用双等号 (==) 住,= 是算符,== 是比算符不存在 =< 或 => 的算符 3.2 算符算符包括 and( 与 ) or( 或 ) 与 not( 非 ) 三种些算符的与它的英文含相似例如, x > 0 and x < 10 若 x 大于 0 且小于 10, 真若 n%2 == 0 or n%3 == 0 其中有一个条件真, 即个数字能被 2 或 3 整除, 真 not 算符是表示否定的布表式若 x > y 假, 即 x 小于或者等于 y, 那么 not (x > y) 真格, 算符的算象是布表式, 但在 Python 中并不是很格任何非零数字都可看作是真 >>> 17 and True True 种灵活性的存在是有用的, 但也会生一些微妙的困惑除非你清楚自己在做什么, 否不要乱用条件行 28

3.3 条件行了写出有用的程序, 几乎是需要根据条件, 修改程序相的行条件句予我种能力最的条件形式是 if 句 : if x > 0 : print 'x is positive' if 句后的布表式称条件 if 句的末尾用冒号 (:),if 句之后的句要若条件真, 那么的句得以行若条件假, 那么的句就会被跳 if 句与 for 循 1 的函数定具有相同的句由一个以冒号 (:) 束的行和随后的一个代区域成由于包含多行, 的句被称复合句句内没有句的数量限制, 但至少要有一行有候, 空白的句也是有用的, 通常是未写的代留空在种情况下, 使用 pass 句, 表示什么也不做 if x < 0 : pass # need to handle negative values! 如果在 Python 解器里入一个 if 句, 提示符会从三个 > 成三个., 表明正在一个句内, 如下所示 : >>> x = 3 >>> if x < 10:... print 'Small'... Small >>> 3.4 分支行 if 句的第二种形式是行句中存在种可能, 条件决定了行一种法如下 : if x%2 == 0 : print 'x is even' else : print 'x is odd' 若 x 除以 2 的余数 0, x 是偶数, 程序就行第一个 print 句, 示 x is even 若余数不 0, else 之后的第二个 print 条件行 29

句得以行由于条件必真或假, 所以条句中有一条会被行些句称行流程中的分支 3.5 式条件有候存在种以上的可能, 那么就需要个以上的分支式条件可以理种情况 elif 是 else if 的写, 表示又有一个分支将被行 elif 句没有数量限制如果有一个 else 子句, 那它必是最后一个, 但是 else 子句不是必的 if choice == 'a': print 'Bad guess' elif choice == 'b': print 'Good guess' elif choice == 'c': print 'Close, but not correct' 依次每个条件如果第一个假, 就第二个, 以此下去如果其中一个条件真, 行相的分支, 至此句束即使不止一个条件真, 也只行第一个真的分支 3.6 嵌套条件一个条件句也可以嵌套到一个条件句中我可以写出三分条件的例子 : 条件行 30

if x == y: print 'x and y are equal' else: if x < y: print 'x is less than y' else: print 'x is greater than y' 外面的条件句包含了个分支第一条分支包含了一个句第二条分支包含了一个由个分支成的 if 句个分支都是句, 然个分支包含条件句, 但它都是句然句得清晰, 但是嵌套条件是很快速地一般情况下, 是尽量避免使用算符通常提供一种方法来化嵌套条件句例如, 使用个条件改写以下代 : if 0 < x: if x < 10: print 'x is a positive single-digit number.' 当个条件都足,print 句才会行使用 and 算符也能到相同的效果 : if 0 < x and x < 10: print 'x is a positive single-digit number.' 3.7 try 与 except 异常捕之前我看到一段代, 使用 raw_input 和 int 函数取和解析用入的整数由此来的潜在危是 : >>> speed = raw_input(prompt) What...is the airspeed velocity of an unladen swallow? What do you mean, an African or a European swallow? >>> int(speed) ValueError: invalid literal for int() >>> 在 Python 解器中行些句, 提示, 然后会新起一行, 等待下一条句的入如果把段代放在 Python 脚本文件中, 当生, 脚本的行会立即停止在一行, 并返回消息, 之后的句不条件行 31

会被行 inp = raw_input('enter Fahrenheit Temperature:') fahr = float(inp) cel = (fahr - 32.0) * 5.0 / 9.0 print cel 如果我行段代, 入一个无效的, 它会停止行, 并返回一个不友好的信息 : python fahren.py Enter Fahrenheit Temperature:72 22.2222222222 python fahren.py Enter Fahrenheit Temperature:fred Traceback (most recent call last): File "fahren.py", line 2, in <module> fahr = float(inp) ValueError: invalid literal for float(): fred Python 内置了 try/except 条件行, 用来解决意料之中和意料之外的你知道程序可能存在, 希望在生增加一些句, try 和 except 就派上用了如果没有出, 些外的句 (except 句 ) 就会被忽略掉你可以把 Python 的 try 和 except 功能看作是程序的保温度程序重新写如下 : inp = raw_input('enter Fahrenheit Temperature:') try: fahr = float(inp) cel = (fahr - 32.0) * 5.0 / 9.0 print cel except: print 'Please enter a number' Python 首先行 try 句如果一切利, 它就会跳 except 句如果在 try 句里生意外,Python 就会跳出 try 句, 行 except 句 python fahren2.py Enter Fahrenheit Temperature:72 22.2222222222 python fahren2.py Enter Fahrenheit Temperature:fred Please enter a number 用 try 句理异常的行称异常捕个示例中 except 子句打印了一条提示信息一般来, 捕捉到异常, 就是你一个机会去解决它, 或者是再一次, 至少程序能正常束 3.8 表式的短路估当 Python 理如 x > = 2 and (x / y)> 2 的表式, 从左至右行判断根据 and 的含, 如果 x 小于 2, 表式 x>=2 假, 那么整个表式即假, 不管后面的 (x / y)> 2 的判断是真或假当 Python 表式剩余部分的判断没有意了, 它就停止剩余部分的判断在已知表式整体果的情况下停止判断, 称短路估条件行 32

看起来是一个, 短路行来了一种灵活的理方式, 称守者模式如下是 Python 解器中的一段代 : >>> x = 6 >>> y = 2 >>> x >= 2 and (x/y) > 2 True >>> x = 1 >>> y = 0 >>> x >= 2 and (x/y) > 2 False >>> x = 6 >>> y = 0 >>> x >= 2 and (x/y) > 2 Traceback (most recent call last): File "<stdin>", line 1, in <module> ZeroDivisionError: integer division or modulo by zero >>> 第三次算出了由于 y 等于 0,Python 算 (x/y) 出行但是, 第二次算没有出由于表式第一部分 x > = 2 判断假, 所以根据短路, (x / y) 根本没有被行, 所以没有我可以在生之前, 策略性地放置一个守估, 代如下 : >>> x = 1 >>> y = 0 >>> x >= 2 and y!= 0 and (x/y) > 2 False >>> x = 6 >>> y = 0 >>> x >= 2 and y!= 0 and (x/y) > 2 False >>> x >= 2 and (x/y) > 2 and y!= 0 Traceback (most recent call last): File "<stdin>", line 1, in <module> ZeroDivisionError: integer division or modulo by zero >>> 第一个表式中 x > = 2 假, 所以在 and 之前判断就停止了第二个表式中 x > = 2 真, 但 y!= 0 假, 所以 (x/y) 没有机会得到判断第三个表式中 y!= 0 位于 (x/y) 之后, 所以个表式的判断失了第二个表式中 y!= 0 作一个守, 确保 y 不等于 0 只行 (x/y) 3.9 当生,Python 的追踪 (Traceback) 示很多信息, 但有可能消息多, 特是中有很多的情况其中最有用的部分是 : 的型是什么生的位置法通常很容易找到, 但也存在一些陷空格非常棘手, 由于空格和制表符是不可的, 常常会被忽 >>> x = 5 >>> y = 6 File "<stdin>", line 1 y = 6 ^ SyntaxError: invalid syntax 条件行 33

个例子中出在第二行只用了一个空格但是消息指向了 y, 其是一种一般情况下, 信息会示在何被, 但是可能会在所示的代之前, 有候会在前一行行也是如此假用分算信噪比, 公式是 $SNR~{db} = 10 log~{10}(\frac{p~{signal}}{p~{noise}})$,python 代如下 : import math signal_power = 9 noise_power = 10 ratio = signal_power / noise_power decibels = 10 * math.log10(ratio) print decibels 但是当你行段代, 就会收到如下信息 2 : Traceback (most recent call last): File "snr.py", line 5, in? decibels = 10 * math.log10(ratio) OverflowError: math range error 信息示第 5 行出, 但那一行没有了找到真正的, 将 ratio 打印出来可能会有用原来是 ratio 0, 出在第 4 行, 原因是数相除采用的是地板除法 ( 只取整数 ) 解决方法是用浮点数表示信号功率和噪声功率一般情况下, 信息会告你出在, 但个出位置并不准确 3.10 主体 : 复合句中的一句布表式 : 取只有真 (True) 或假 (False) 其中之一的表式分支 : 条件句中可供的一句式条件 : 有多个可分支的条件句比算符 : 算象行比的一种算符, 包括 ==!= > < >=, 和 <= 条件句 : 根据某些条件来控制程序行序的句条件 : 条件句中的布表式, 用来决定行一个分支复合句 : 含有部和主体的一句代部以冒号 (:) 尾代主体相于代部行守模式 : 通外的比来造表式, 充分利用短路行算符 : 合布表式的算符, 包括 and or 和 not 嵌套条件 : 一个条件句作一个条件句的分支追踪 : 正在行的函数列表, 当出异常, 在屏幕上示出来短路 : 在判断表式的程中, 如果 Python 已知道了最果, 会停止, 不会剩余的表式行判断条件行 34

3.11 3.1 重写薪水算公式, 如果工工作超 40 小, 按平常薪水的 1.5 倍支付 Enter Hours: 45 Enter Rate: 10 Pay: 475.0 3.2 用 try 和 except 重写支付程序, 程序可以正常理非数字入的情况, 如果是非数字入, 打印消息并退出程序以下是程序的种行果 : Enter Hours: 20 Enter Rate: nine Error, please enter numeric input Enter Hours: forty Error, please enter numeric input 3.3 写一个程序, 提示分数在 0.0 和 1.0 之如果分数超出个范打印出如果分数在 0.0 和 1.0 之, 使用下面的表格打印分数 : Score Grade >= 0.9 A >= 0.8 B >= 0.7 C >= 0.6 D < 0.6 F Enter score: 0.95 A Enter score: perfect Bad score Enter score: 10.0 Bad score Enter score: 0.75 C Enter score: 0.5 F 重复行个程序, 不同的入 1. 第 4 章介函数, 第 5 章介循 2. Python3.0 中, 不再出消息即使是整数象, 除法算符行的也是浮点除法条件行 35

第 4 章函数 4.1 函数用程中的函数是行算的一个命名句序列当定函数, 需要指定函数名和句序定好之后, 通函数名就可以用函数之前我到一个函数示例 : >>> type(32) <type 'int'> 个函数的名称是 type 括号里面的表式称函数的参数参数可以是一个或量, 作函数的入 type 函数的作用是示参数的型一般而言, 函数取参数, 然后返回果个果称返回 4.2 内置函数 Python 提供了很多重要的内置函数, 不需要我先定就可以使用 Python 开者定了解决常的函数集, 内置在 Python 中, 供我使用 max 函数和 min 函数分求得一个列表中的最大和最小 : >>> max('hello world') 'w' >>> min('hello world') ' ' >>> max 函数告我, 个字符串中最大的字符是 ( w ),min 函数告我个字符串中最小的字符是空格符一个常用的内置函数是 len 函数, 它能返回参数的度如果 len 函数的参数是一个字符串, 那么它返回的是个字符串的字符数 >>> len('hello world') 11 >>> 些函数不可用于字符串, 能操作其他数据型, 后章会涉及到你可以将内置函数比保留字, 例来, 不要使用 max 作量名 4.3 型函数 Python 提供了将一种型成一种型的内置函数在允的情况下,int 函数能把任何其他型的化成整数型, 如果不能就会 : >>> int('32') 32 函数 36

>>> int('hello') ValueError: invalid literal for int(): Hello int 函数能将浮点型成整数型, 但是它不行四舍五入, 只是直接去掉小数部分 : >>> int(3.99999) 3 >>> int(-2.3) -2 float 函数能把整数型和字符串型成浮点型 : >>> float(32) 32.0 >>> float('3.14159') 3.14159 str 函数能把入的参数成字符串型 : >>> str(32) '32' >>> str(3.14159) '3.14159' 4.4 随机数既定入的情况下, 大部分的算机程序每次都会生相同的出, 也就是是板上的事情一般而言, 确定性是好的, 我希望同一个算法生相同的果然而, 有些候我希望算机具不确定性, 比如游就是一个典型例子, 当然有很多其他例子一个程序完全于不确定状, 很做到但是, 有一些方法可以它看起来具有不确定性一种方法是利用算法生随机数随机数并不是真正的随机数, 原因在于它是利用确定的算法算出来的看些数字并不会它和真正的随机数有什么不同随机数模提供了随机数生成的函数, 以下称 random random 函数返回一个介于 0.0-1.0 的随机浮点数 ( 包括 0.0, 但不包括 1.0) 每次用, 你会得到一串的数字例来, 行下面的循句 : import random for i in range(10): x = random.random() print x 程序生成了 10 个介于 0.0-1.0 之但不包括 1.0 的随机数 0.301927091705 0.513787075867 0.319470430881 0.285145917252 0.839069045123 0.322027080731 0.550722110248 函数 37

0.366591677812 0.396981483964 0.838116437404 4.1 行以下程序并察得到的果, 不妨多行几次看看 random 函数只是多随机数函数中的一个 randint 函数入个整数参数, 并返回介于个参数之的整数 ( 包括个参数在内 ) >>> random.randint(5, 10) 5 >>> random.randint(5, 10) 9 取得一中的随机元素, 可以使用下面的程序 : >>> t = [1, 2, 3] >>> random.choice(t) 2 >>> random.choice(t) 3 random 模提供了从分布函数中提取随机的函数, 包括高斯函数指数函数伽函数等 4.5 数学函数 Python 的 math 模提供了很多常的数学函数在使用之前要入相的包 : >>> import math 条句建了一个名 math 的模象如果将个模象打印出来, 就会得到关于它的一些信息 : >>> print math <module 'math' from '/usr/lib/python2.5/lib-dynload/math.so'> 个模象包括了模中定的函数和量了使用其中的函数, 你必指定模名和函数名, 用点隔开, 也就是英文的句号种格式叫做点 (dot notation) >>> ratio = signal_power / noise_power >>> decibels = 10 * math.log10(ratio) >>> radians = 0.7 >>> height = math.sin(radians) 第一个例子是算以 10 底的信噪比的数 math 模提供了 log 函数用来求以 e 底的数第二个例子用了正弦函数量名字出了提示, 除了正弦函数, 有余弦, 正切等其他三函数都采用弧度作参数将度数成弧度的算是除以 360, 然后乘以 2π: >>> degrees = 45 >>> radians = degrees / 360.0 * 2 * math.pi >>> math.sin(radians) 函数 38

0.707106781187 math.pi 表式从 math 模中取得量 pi 的个量是 π 的一个近似, 保留了小数点后 15 位数用你的平面几何知, 与 2 的平方根再除以 2 的果行比, 程序出是否正确 >>> math.sqrt(2) / 2.0 0.707106781187 4.6 定新函数目前止, 我只是使用了 Python 的内置函数, 除此之外也可以自定新函数通定函数名和一句序列来定一个新函数, 然后在行用个函数一旦定了一个函数, 程序中可以重复使用 def print_lyrics(): print "I'm a lumberjack, and I'm okay." print 'I sleep all night and I work all day.' def 是用来定函数的保留关字个函数的名称是 print_lyrics 函数命名与量命名的基本上是一的字母数字以及一些符号是合法的, 但是函数名的第一个字符不能是数字不能使用保留关字命名函数, 也要避免函数名和量名相同函数名后面的空括号表明个函数没有指定参数接下来, 我会定有参数的函数函数定的第一行叫做函数, 剩余的部分叫做函数体函数必以冒号束, 函数体必按照例, 一般 4 个空格函数体可以包括任意数量的句 print 句要出的字符串放在双引号里面引号和双引号作用是一的除了在字符串中也有引号的冲突情况之外, 大多数人会使用引号如果你在 Python 交互模式中定函数, 解器会打印省略号 ( ) 表明函数定没有束 >>> def print_lyrics():... print "I'm a lumberjack, and I'm okay."... print 'I sleep all night and I work all day.'... 函数定的束方式是入一个空行 ( 当然, 在程序文件中不是必的 ) 定函数的同也会建一个和函数名相同的量名 >>> print print_lyrics <function print_lyrics at 0xb7e99e9c> >>> print type(print_lyrics) <type 'function'> print_lyrics 的是一个函数象, 它的型是函数用自定函数与用内置函数的法是一的 : >>> print_lyrics() 函数 39

I'm a lumberjack, and I'm okay. I sleep all night and I work all day. 函数定好之后, 就可以在其他函数中使用例如, 了重复用之前的函数, 你可以写一个 repeat_lyrics 函数 : def repeat_lyrics(): print_lyrics() print_lyrics() 然后用个函数 : >>> repeat_lyrics() I'm a lumberjack, and I'm okay. I sleep all night and I work all day. I'm a lumberjack, and I'm okay. I sleep all night and I work all day. 中歌曲可不是填的 4.7 定与用法将前面的代片段合在一起, 完整的程序如下 : def print_lyrics(): print "I'm a lumberjack, and I'm okay." print 'I sleep all night and I work all day.' def repeat_lyrics(): print_lyrics() print_lyrics() repeat_lyrics() 个程序包含了个自定函数 :print_lyrics 和 repeat_lyrics 函数定会像其他句一行, 但它的作用是新建函数函数体里面的代并没有被行, 直到被用才会行, 函数定是没有出的正如所期望的, 你必在行函数之前定个函数句, 函数在第一次被用之前就定好 4.2 将上面程序的最后一行到最开始, 函数用就出在函数定之前行程序并察出信息 4.3 将函数回底部, 将函数 print_lyrics 定放在函数 repeat_lyrics 后面, 会生什么果? 4.8 行流程了保函数定是在第一次使用之前, 你就必知道句的行序, 称行流程程序一般从第一条句开始行, 从上到下依次序行函数定并不改程序的行序, 但要住, 函数只有被用的才会被行函数用像是是行流程中的一个迂回当遇到要用的函数, 不会接着去行下一句, 而是跳到函数体, 行完函数体里的句, 然后回到才跳出的地方行当你掌握了函数之的用, 就会得很在一个函数中, 程序可能需要行一个函数的句有, 在定新函函数 40

数, 程序可能需要行一个函数! 程序里跳来跳去, 明了什么? 程序有候没必要从看到尾有候按照行流程会你更好地程序 4.9 形式参数与参数我之前到的内置函数需要入参数例如, 用 math.sin 函数需要入一个数作参数有些函数不止有一个参数 : math.pow 函数需要入个参数 : 底数和指数在函数内部, 如果量作参数入, 那么种参数叫做形式参数 ( 称形参 ) 下面的例子是一个自定函数入了一个参数 ( 称参 ): def print_twice(bruce): print bruce print bruce 个函数将一个叫做 bruce 的参去当函数被用, 函数会打印次入的参数个函数适用任何型的 >>> print_twice('spam') Spam Spam >>> print_twice(17) 17 17 >>> print_twice(math.pi) 3.14159265359 3.14159265359 种参数入方式适用于内置函数与自定函数任何型的表式都可以作函数 print_twice 的参数 >>> print_twice('spam '*4) Spam Spam Spam Spam Spam Spam Spam Spam >>> print_twice(math.cos(math.pi)) -1.0-1.0 参数的在函数被用之前就已被算出来了, 因此, 上面的例子中表式 'Spam '*4 和 math.cos(math.pi) 只被算了一次你可以使用量作参数 : >> michael = 'Eric, the half a bee.' >>> print_twice(michael) Eric, the half a bee. Eric, the half a bee. 量 ( 如 michael) 作形参与参 ( 如 bruce) 不同函数的形式参数是什么型的都可以被入, 而参的是确定的,print_twice 函数的返回就是参数 bruce 本身 4.10 返回的函数和空函数函数 41

我使用的有些函数 ( 如 math 函数 ) 有返回由于没有更好的叫法, 我称之有返回的函数其他的一些函数比如 print_twice, 行任但不返回, 种称空函数当用有返回的函数, 大部分候你想要利用返回, 例如, 将它一个量, 也可以作表式的一部分 : x = math.cos(radians) golden = (math.sqrt(5) + 1) / 2 在交互模式中用函数,Python 会示果 >>> math.sqrt(5) 2.2360679774997898 在程序文件中, 如果不把有返回的函数的返回保存在量里的, 返回就会失 math.sqrt(5) 空函数也会在屏幕上出什么或者有其它的用途, 但其本身没有返回如果你着将果一个量, 就会得到一个特殊的 None >>> result = print_twice('bing') Bing Bing >>> print result None None 与字符串 None 是不一的它是一种特殊的并且有自己的型 >>> print type(none) <type 'NoneType'> 使用 return 句从函数中返回果例如, 建一个的函数 addtwo, 将个数相加并且返回一个 def addtwo(a, b): added = a + b return added x = addtwo(3, 5) print x 在文件中行程序,print 句会打印出 8 addtwo 函数被用, 入 3 和 5 个参数有形参 a 和 b 的函数, 分是 3 和 5 个函数将个数相加, 然后将果局部量 added, 最后使用 return 句将算果 x 并打印出来 4.11 什么需要函数? 如果不太明白什么需要花精力把程序分成多个函数, 看如下理由 : 定新函数可以你有机会一句命名, 使得程序易于理解和函数可以消除冗余代, 程序瘦身如果想修改函数, 只需要改一即可将程序分割成多个函数, 逐一, 最后再整合在一起函数 42

精心的函数很多程序而言都会有用一旦建并后, 你就可以重复使用它本其余部分会使用函数定来解一个概念建并正确使用函数的技巧之一是捕捉到一个想法, 例如, 找出列表中的最小随后我会介 min 函数的代, 它将列表的作参数入, 然后返回其中的最小 4.12 制表符和空格通常不可, 致不易, 因此最好一个能自的文本器外, 行程序之前不要忘保存有一些开境可以自保存, 而有一些不行未保存的情况下行的程序和文本器的程序不一如果你重复行相同的程序, 那么会很久确保行的代是文本器中你所看到的代如果不确定, 你可以在程序开加入 print 'hello' 的代再行如果没有看到 hello 出, 那么就没有正确行程序 4.13 算法 : 解决一的一般程参数 : 函数被用入的函数中个会被予相的参数函数体 : 函数定中的一句序列合 : 一个表式作一个表式的一部分, 或者一条句作一条句的一部分确定性 : 在既定入下, 程序每次行都一并返回相同的果点 : 在一个模中用函数, 需要指定模名和函数名, 用句号隔开行流程 : 程序行的句行序返回的函数 : 能返回一个的函数函数 : 行一些有用操作的命名句序列函数不一定有参数, 也不一定返回果函数用 : 行函数的句, 包括函数名和参数列表函数定 : 建新函数的句, 需要指定名称参数和行句函数象 : 通函数定建的函数名就是参引函数象的量函数部 : 函数定的第一行 import 句 : 取模文件并建模象的句模象 :import 句建的一个, 用以提供模中定的数据和代形式参数 : 函数中用来参引入参数的量名随机数 : 看起来像随机数的一串数, 不是由确定的程序生的返回 : 函数的果如果一个函数用作表式来使用, 那么返回就是个表式的函数 43

空函数 : 没有返回的函数 4.14 4.4 Python 中 def 保留关字的作用是什么? a) 它是一个俚, 下面的代太酷了 b) 它表示函数的开始 c) 它表示接下来代的部分会被存 d) b 和 c 都正确 e) 以上都不正确 4.5 下面的 Python 句会打印出什么? def fred(): print "Zap" def jane(): print "ABC" jane() fred() jane() a) Zap ABC jane fred jane b) Zap ABC Zap c) ABC Zap jane d) ABC Zap ABC e) Zap Zap Zap 4.6 重写之前的工算程序, 加班的工按原工的 150% 算建一个 computepay 函数, 包含个参数 hours 和 rate Enter Hours: 45 Enter Rate: 10 Pay: 475.0 4.7 重写之前的分数算程序, 使用 computegrade 函数,score 作参数, 返回一个分等的字符串 Score Grade > 0.9 A > 0.8 B > 0.7 C > 0.6 D <= 0.6 F Program Execution: 函数 44

Enter score: 0.95 A Enter score: perfect Bad score Enter score: 10.0 Bad score Enter score: 0.75 C Enter score: 0.5 F 重复行程序, 每次入不同的来出果函数 45

第 5 章迭代 5.1 更新量句的常模式是量行更新, 量的新依于旧 x = x+1 条句的作用是 : 得到 x 的当前, 加一, 然后将相加果作新予 x 如果更新一个不存在的量, 那么会出是因 Python 在 x 之前, 首先算等号右 : >>> x = x+1 NameError: name 'x' is not defined 在更新量之前, 必初始化, 通常使用的句 : >>> x = 0 >>> x = x+1 通加一操作更新量称增量更新, 一操作称量更新 5.2 while 句算机常用于行一些重复性的任算机来, 行相同或相似的任而不出, 很, 但人就做不好迭代很常,Python 提供了一些功能句, 使任得更加 Python 的一种迭代形式是 while 句下面是一个的例子, 从 5 开始倒数, 然后打印出 Blastoff! n = 5 while n > 0: print n n = n-1 print 'Blastoff!' 几乎可以像英文一, 条 while 句它的作用是 : 当 n 大于 0, 示 n 的, 然后 n 1 当 n 等于 0, 束 while 句, 示 blastoff! 格, while 句的行流程如下 : 1. 算条件表式的, 判断是 True 或 False 2. 如果 False, 束 while 句并行下一条句 3. 如果 True, 行 while 中的句体, 然后返回步 1 此行流程称循行到第三步又返回到部每行一次循体, 称一次迭代上面的循, 我可以它行了五次迭代, 表示循体被行了五次循体会改一个或多个量的因此当条件不足, 循束有一种量在每次循行其都会化, 并控制迭代 46

循什么候束, 种量称迭代量如果没有迭代量, 循就会永行下去, 致无限循 5.3 无限循于程序来, 无限循的有趣例就是洗水的明, 泡沫, 冲洗, 重复就是一个无限循, 没有迭代量来表明什么候束个循上面的倒数例子中, 循的确是束了因 n 的个数是有限的, 我可以看到 n 随着循的行不断小, 最 0 有些情况的循明是无限的, 是因它根本就没有迭代量 5.4 无限循与 break 句有候循行到一半, 你没意到候束循了在种情况下, 你可以写一个无限的循, 然后使用 break 句跳出循下面的代明是一个无限循,while 句的表式是常量 True: n = 10 while True: print n, n = n - 1 print 'Done!' 如果犯了个并且行个代, 你会很快学会如何停止一个正在行的 Python 程, 或者找到算机的关机按由于循部的表式是常量 True, 所以循条件一直都足, 个程序会一直行下去, 直到算机没然是一个不正常的无限循, 我是可以使用种模式来建立有用的循只要将 break 句放循体, 明确退出条件及行当到束条件, 就可以束循例来, 如果想要用直到入 done 束的, 代可以写 : while True: line = raw_input('> ') if line == 'done': break print line print 'Done!' 个循的条件是 True 且不会, 因此循会一直行下去, 直到触 break 句每次行个循, 它都会提示用一个尖括号如果用入 done, 那么 break 句就会束个循否, 个程序会一直提示用行入, 回到部行下面是一个程序行的果演示 : > hello there hello there > finished finished > done Done! while 句的种写法很常你可以在循中的任何位置条件 ( 不局限于部 ), 并且可以主定停止条件 ( 当生什么就停止 ), 而不是被等待判断 ( 一直行直到生什么 ) 迭代 47

5.5 使用 continue 句束迭代有在循的迭代中, 你想要束当前迭代, 立刻行下一迭代在种情况下, 使用 continue 句跳入下一迭代, 无需完成当前迭代的循体下面的循例子不断打印入, 直到用入 done 才会束但是,# 号开的入不会被打印出来 ( 有点像 Python 的注 ) 行一下个加入了 continue 句的新程序 while True: line = raw_input('> ') if line[0] == '#' : continue if line == 'done': break print line print 'Done!' 除了 # 号开的行, 其他所有的行都被打印出来当 continue 句被行, 当前迭代会束, 跳到 while 句的开行下一循, 也就跳了 print 句 5.6 使用 for 句定循有候我需要要遍一西, 例如, 列表, 文件的每一行或是一数字遍一西, 可以用 for 句来造循因 wile 句是地行循, 直到条件 False, 我称其无限循与之不同的是,for 句是已知的数据集合行循, 因此它的迭代次数取决于数据的个数 for 循和 while 循的法相似, 下面是一个 for 句和循体代示例 : friends = ['Joseph', 'Glenn', 'Sally'] for friend in friends: print 'Happy New Year:', friend print 'Done!' 在 Python 法中,friends 量是包含三个字符串的列表 1 for 循遍整个列表, 依次打印每个字符串三个字符, 出果如下所示 : Happy New Year: Joseph Happy New Year: Glenn Happy New Year: Sally Done! 如果用英来解个 for 循, 就不如 while 循的解那么直接你可以把它当做一个朋友名, 那么段代的作用是 : friends 集合中的每个朋友行 for 循体察个 for 循,for 和 in 是 Python 的保留关字,friend 和 friends 是量 for friend in friends: print Happy New Year, friend 具体来,friend 是 for 循的迭代量量 friend 的在每次迭代都会改, 并控制 for 循什么候束个迭代量取得 friends 中存的三个字符串迭代 48

5.7 循模式我常使用 for 循或 while 循来遍列表或文件的内容, 会通来找一数中的最大或最小此循的造方法如下 : 循开始之前初始化一个或多个量在循体中每个数据行算, 可能会改循体中量的循束看最量我会用一数字来展示些循模式的理念和造方法 5.7.1 与求和循例来, 了一个列表的数据个数, for 循写如下 : count = 0 for itervar in [3, 41, 12, 9, 74, 15]: count = count + 1 print 'Count: ', count 循开始之前将量 count 的 0, 然后用一个 for 循来遍数列表迭代量命名 itervar 然我并不在循体中使用它, 但它控制着循, 循体每一个列表行一次在循体中, 列表的每个都会致 count 加一随着循的行,count 就是当前所看到的循一旦束,count 就等于列表中数的个数在循最后, 数落入我手中通造个循, 在循束我得到了想要的一个相似的循求出一数的和 : total = 0 for itervar in [3, 41, 12, 9, 74, 15]: total = total + itervar print 'Total: ', total 在个循中, 我用到了迭代量不是之前循中 count 量加一, 而是在每次循中加上的数字 ( 如 3 41 12 等 ) total 量的作用是求出目前的累在循开始之前, 由于没有遇到任何, 所以 total 是 0 循中会累加,total 最是所有数字的和随着循的行,total 累了列表各的和的量有候被称累加器 (accumulator) 不管循是求和循, 在使用中都不是很有用是因 Python 提供了内置函数 len() 和 sum(), 分算列表元素的个数和列表各的和 5.7.2 最大与最小循找出列表或者序列中的最大, 造如下循 : largest = None print 'Before:', largest for itervar in [3, 41, 12, 9, 74, 15]: if largest is None or itervar > largest : largest = itervar print 'Loop:', itervar, largest 迭代 49

print 'Largest:', largest 程序行果如下 : Before: None Loop: 3 3 Loop: 41 41 Loop: 12 41 Loop: 9 41 Loop: 74 74 Loop: 15 74 Largest: 74 largest 量是目前我看到的最大在循开始之前, 将 largest 常量 None None 是一个特殊的常量, 表示量空在循开始之前, 我没有遇到任何, 所以 largest None 当循开始行, 如果 largest None, 将第一个作目前看到的最大可以看到, 第一迭代中 itervar 的是 3,largest 的是 None, 所以立即将 largest 的 3 第一次迭代之后, 最大就不是 None 了复合表式的第二部分置了触器, itervar 是否大于 largest 如果当前大于 largest, 就会将更大的新予 largest 从程序出可以看出,largest 从 3 41, 然后 74 循束后遍了所有的,largest 已是整个列表中的最大了算最小的代需要做很小改 : smallest = None print 'Before:', smallest for itervar in [3, 41, 12, 9, 74, 15]: if smallest is None or itervar < smallest: smallest = itervar print 'Loop:', itervar, smallest print 'Smallest:', smallest 同的,smallest 在循前循中与循后都是目前看到的最小循束后,smallest 就是整个列表的最小和求和同有 Python 内置函数支持, 比如, 使用 max() 函数和 min() 函数可以不用到循代下面是 Python 内置函数 min() 的化版代 : def min(values): smallest = None for value in values: if smallest is None or value < smallest: smallest = value return smallest 在段代中, 我移除了所有的 print 句, 与 Python 内置函数 min() 基本等价 5.8 当程序越写越, 你就会需要花更多的来代越多意味着犯的机会越大, 藏的也就越多相反, 着将分部分在程序的中位置, 找一可的代, 插入一个 print 句 ( 或者其它可效果的句 ), 然后行程序迭代 50

如果中点出, 那么肯定出在程序的前半部分如果中点没, 就出在程序的后半部分每行一次的, 你就会把代范一半如果代少于 100 行, 行 6 次之后, 就只剩下一行, 理上至少是上, 程序的中位置并不是很明, 也可能没法行行数然后除以 2, 找到精确的中位置代行, 种做法没有意一般做法是, 考程序中容易出的地方, 行你极有可能会出的位置前后, 置点 5.9 累加器 : 循句中用来累果的量数器 : 循句中用来算生次数的量数器初始化 0, 每次需要数, 增加它的量 : 少量的更新初始化 : 随后会更新的量予初始的句增量 : 增加量的更新 ( 通常是加一 ) 无限循 : 止条件无法到或者没有止条件的循迭代 : 通函数用或者循来重复行一句 5.10 5.1 写一个程序, 重复取数据, 直到用入 done 一旦入 done, 打印和个数与平均如果用入的不是数字, 使用 try 和 except 捕异常, 打印信息, 然后跳行循 5.2 写一个程序, 提示用入一数字, 出最大和最小, 不要求平均 1. 第 8 章会介列表迭代 51

第 6 章字符串 6.1 字符串是字符的序列字符串是若干字符的序列你可以用方括号算符逐一每个字符 : >>> fruit = 'banana' >>> letter = fruit[1] 第二条句从 fruit 量中提取索引位置 1 的字符, 并把它予 letter 量方括号里的表式称索引索引可以指向字符序列中你想要的字符, 作用如其名但是并不是你想要的果 : >>> print letter a 大多数人 'banana' 的第一个字符是 b, 而不是 a 但在 Python 中, 索引是从字符串部算起的一个偏移量, 第一个字母的偏移量 0 >>> letter = fruit[0] >>> print letter b 因此,b 是 'banana' 的第零个字母,a 是第一个字母,n 是第二个字母索引可以是任何表式, 包括量与算符在内但是, 索引的必是整数, 否会得到如下信息 : >>> letter = fruit[1.5] TypeError: string indices must be integers 6.2 使用 len 函数得到字符串的度 len 是内置函数, 返回字符串的字符数 : >>> fruit = 'banana' >>> len(fruit) 6 了得到字符串中的最后一个字母, 你可能会做 : 字符串 52

>>> length = len(fruit) >>> last = fruit[length] IndexError: string index out of range IndexError 的依据是字符串 banana 没有与索引 6 的字母既然是从零开始算起, 六个字母的号就是 0 到 5 了得到最后一个字母, length 1 >>> last = fruit[length-1] >>> print last a 一种方法是使用索引, 从字符串尾倒来算表式 fruit[-1] 表示最后一个字母,fruit[-2] 是倒数第二个字母, 以此推 6.3 通循遍字符串按照一次一个字符的方式理一个字符串需要花大量的算通常从字符串部开始, 逐个每个字符, 其行操作, 然后下一个, 直到束种理模式称遍 (traversal) 遍的一种写法是使用 while 循 : index = 0 while index < len(fruit): letter = fruit[index] print letter index = index + 1 个循遍了整个字符串, 每行示一个字母循条件是 index < len(fruit), 当 index 等于字符串度, 循条件假, 那么句体就不会被行字符串最后一个字符的索引是 len(fruit)-1 6.1 写一个 while 循, 从字符串的最后一个字符开始, 反向逐一理, 直到字符串的第一个字符, 一行示一个字母遍的一种写法是用 for 循 : for char in fruit: print char 每一次循中字符串的下一个字符 char 量循下去, 直到没有字符了 6.4 字符串分割字符串的一个片段称切片, 字符切片与字符的方法相似 : >>> s = 'Monty Python' >>> print s[0:5] Monty >>> print s[6:12] Python 算符 [n:m] 返回字符串从第 n 到第 m 之的字符, 包括第一个字符, 但不包括最后一个字符如果忽略第一个索引 ( 冒号之前 ), 切片就从字符串第一个字符开始算如果忽略第二个索引, 切片就算到最后一个字符串 53

字符 : >>> fruit = 'banana' >>> fruit[:3] 'ban' >>> fruit[3:] 'ana' 如果第一个索引大于第二个索引致空字符串, 只会出个引号 : >>> fruit = 'banana' >>> fruit[3:3] " 空字符串不包含字符, 其度 0 除此之外, 它和其它字符串没有差 6.2 假 fruit 是一个字符串, 那么 fruit[:] 表示什么? 6.5 字符串是不可的在句的左使用 [] 算符, 改字符串中的字符例如下 : >>> greeting = 'Hello, world!' >>> greeting[0] = 'J' TypeError: object does not support item assignment 个例子的象是字符串, 数据就是你想要的字符在, 一个象相当于一个, 等下会修正个定数据是序列中的一个出原因在于字符串是不可改的意味着, 你不能改已存在的字符串最好的法是在原字符串基上新建一个字符串 >>> greeting = 'Hello, world!' >>> new_greeting = 'J' + greeting[1:] >>> print new_greeting Jello, world! 个例子将新的首字母与 greeting 的切片接在一起不会原先的字符串造成影 6.6 循与下面的程序了字母 a 在字符串中出的次数 : word = 'banana' count = 0 for letter in word: if letter == 'a': count = count + 1 print count 个程序演示了一种算模式, 称数器量 count 初始 0, 每当一个 a,count 就加一当循停止, 字符串 54

count 就得到了果, 即 a 出的次数 6.3 定一个 count 函数并封装段代, 其行通用化改造, 能接收字符串和字母作参数 6.7 in 算符 in 是一个布算符, 个字符串行比, 如果第一个字符串是第二个字符串的子串, 返回 True >>> 'a' in 'banana' True >>> 'seed' in 'banana' False 6.8 字符串比比算符适用于字符串如何判断个字符串等价 : if word == 'banana': print 'All right, bananas.' 其它比算符适用于字母排序 : if word < 'banana': print 'Your word,' + word + ', comes before banana.' elif word > 'banana': print 'Your word,' + word + ', comes after banana.' else: print 'All right, bananas.' Python 不能像人一, 区分大写字母和小写字母所有的大写字母都在小写字母之前, 因此果如下 : Your word, Pineapple, comes before banana. 解决个的常方法是将字符串成一种准格式, 例如, 在比之前都化小写 6.9 字符串方法字符串是一种 Python 象一个象包括数据 ( 即字符串本身 ) 和方法些方法是内置在象中的有效函数, 可以作用于象的任一例 Python 有一个 dir 函数, 它可以列出象所有可用的方法 type 函数示象的型,dir 函数示的是象可用的方法 >>> stuff = 'Hello world' >>> type(stuff) <type 'str'> >>> dir(stuff) ['capitalize', 'center', 'count', 'decode', 'encode', 'endswith', 'expandtabs', 'find', 'format', 'index', 'isalnum', 'isalpha', 'isdigit', 'islower', 'isspace', 'istitle', 'isupper', 'join', 'ljust', 'lower', 'lstrip', 'partition', 'replace', 'rfind', 'rindex', 'rjust', 'rpartition', 'rsplit', 'rstrip', 'split', 'splitlines', 字符串 55

'startswith', 'strip', 'swapcase', 'title', 'translate', 'upper', 'zfill'] >>> help(str.capitalize) Help on method_descriptor: capitalize(...) S.capitalize() -> string Return a copy of the string S with only its first character capitalized. >>> 当 dir 函数列出些方法, 你就可以用 help 取关于些方法的文档有关字符串方法比全面的文档 http://docs.python.org/library/string.html 用方法与用函数似, 都是入参数, 返回果, 但它的法是不同的用方法的法是, 使用句点作分隔, 在量名后面跟上方法名例如,upper 方法接收一个字符串, 返回一个全部是大写字母的新字符串 : 次不使用 upper(word) 函数, 做 word.upper() 方法 >>> word = 'banana' >>> new_word = word.upper() >>> print new_word BANANA 种点形式指明方法名 upper, 将此方法用于量 word 空的括号表示个方法没有参数召一个方法称用个例子中, 在 word 象上用了 upper 方法例如, 字符串方法 find, 找到字符串中字符的所在位置 : >>> word = 'banana' >>> index = word.find('a') >>> print index 1 在个例子中, 我在 word 象上用 find 方法, 将待找的字母作参数 find 方法不适用字符, 可以用于找子串 : >>> word.find('na') 2 find 方法可以置第二个参数, 从个索引位置开始找 : >>> word.find('na', 3) 4 一个常任是利用 strip 方法移除字符串首尾的空白 ( 包括空格制表符和行符 ) >>> line = ' Here we go ' >>> line.strip() 'Here we go' 字符串 56

像 startswith 的方法返回的是布 >>> line = 'Please have a nice day' >>> line.startswith('please') True >>> line.startswith('p') 你会注意到,startswith 方法大小写敏感, 在之前, 使用 lower 方法将其全部小写字母 >>> line = 'Please have a nice day' >>> line.startswith('p') False >>> line.lower() 'please have a nice day' >>> line.lower().startswith('p') True 最后一个例子中用了 lower 方法, 然后用 startswith 方法小写后的字符串是否以字母 p 开只要留意次序, 我就可以在一个表式上用多种方法 6.4 字符串方法 count 与之前的函数相似 http://docs.python.org/library/string.html, 看个方法的文档, 写一个方法用, a 在 'banana' 中出的次数 6.10 字符串解析通常, 我想要在一个字符串中找它的子串如下是一行化的字符串 : From stephen.marquard@ uct.ac.za Sat Jan 5 09:14:16 2008 我只想抽出子件的第二部分 ( 即 uct.ac.za), 可以通 find 方法和字符串切片来首先, 在字符串中找到 @ 符号的位置其次, 找到 @ 符号之后第一个空格所在的位置最后, 再用字符串切片来提取字符串中我需要的部分 >>> data = 'From stephen.marquard@uct.ac.za Sat Jan 5 09:14:16 2008' >>> atpos = data.find('@') >>> print atpos 21 >>> sppos = data.find(' ',atpos) >>> print sppos 31 >>> host = data[atpos+1:sppos] >>> print host uct.ac.za >>> 里使用的是 find 方法的一种用法, 我能指定 find 方法从何开始找当切分字符串, 我提取的字符是位于 @ 符号之后但不包括空格的字符有关 find 方法的文档, http://docs.python.org/library/string.html 6.11 格式操作符字符串 57

格式操作符 % 可以建字符串, 使用量中存的数据来替代字符串的一部分整数而言,% 是模算符如果第一个操作象是字符串, 那么 % 就是格式操作符第一个操作象是格式字符串, 它包含一个或多个格式化序列, 用来指定第二个操作象的格式最理果是字符串例如, 格式序列 '%d' 表示第二个操作象会被格式化整数型 (d 表示十制 ): >>> camels = 42 >>> '%d' % camels '42' 行的果是字符串 '42', 不要与整数 42 搞混了格式序列可以出在字符串中的任意位置, 所以你可以在一个句中嵌入一个 : >>> camels = 42 >>> 'I have spotted %d camels.' % camels 'I have spotted 42 camels.' 如果字符串中存在多个格式序列, 那么第二个参数必是元每个格式序列与元的元素依次下面的例子使用 '%d' 格式化整数,'%g' 格式化浮点数 ( 不要什么 ),'%s' 格式化字符串 : >>> 'In %d years I have spotted %g %s.' % (3, 0.1, 'camels') 元中元素的数量必与字符串中的格式序列数量一致外, 元素的型也要与格式序列匹配 : >>> '%d %d %d' % (1, 2) TypeError: not enough arguments for format string >>> '%d' % 'dollars' TypeError: illegal argument type for built-in operation 第一个例子中元素的数量不, 第二个例子中元素的格式是的格式算符很强大, 但不那么容易上手如需了解更多, http://docs.python.org/lib/typesseq-strings.html 6.12 程常自己, 里可能出什么的? 或者我的用可能会做怎狂的事情使 ( 看似 ) 完美的程序崩? 是需要期培养的程意例如, 第 5 章迭代中介 while 循的程序示例如下 : while True: line = raw_input('> ') if line[0] == '#' : continue if line == 'done': break print line print 'Done!' 字符串 58

当用入一个空行会生什么 : > hello there hello there > # don't print this > print this! print this! > Traceback (most recent call last): File "copytildone.py", line 3, in <module> if line[0] == '#' : 入空行之前代行正常由于没有第 0 位字符, 我得到了异常信息反种方法可以解决个, 即使一行空, 仍然能保安全行一种方法是使用 startswith 方法, 如果字符串空就返回 False 一种方法是使用守模式, 通一条 if 句行控制, 保第二个表式只有在字符串中至少有一个字符行判断 if len(line) > 0 and line[0] == '#' : 6.13 数器 : 用来的量通常初始化零, 然后累增空字符串 : 不包含字符度零的字符串, 用个引号表示格式操作符 :% 操作符格式字符串和元行操作, 根据特定格式字符串, 元元素行格式化后生成一个字符串格式序列 : 格式字符串中的字符序列, 例如,%d, 它表示一个如何行格式化格式字符串 : 使用了格式操作符的字符串, 它包含了格式序列 : 用来表示条件是否真的布量用 : 方法的召句不可 : 序列的一种属性, 序列中的数据不能被索引 : 用来序列中数据的一个整数, 例如, 表示字符串中一个字符的位置数据 : 序列中的一个方法 : 与象相关的函数, 使用句点来用象 : 量可以引用的西在, 你可以交替使用象或者搜索 : 找到所要找的内容才会停止的一种遍模式序列 : 一个有序集合, 集合中的每个通一个整数索引定位切片 : 根据索引区指定字符串的一部分遍 : 遍序列中的数据, 每个数据行似的操作字符串 59

6.14 6.5 使用以下句存一个字符串 : str = X-DSPAM-Confidence: 0.8475 使用 find 方法和字符串切片, 提取出字符串中冒号后面的部分, 然后使用 float 函数, 将提取出来的字符串浮点数 6.6 http://docs.python.org/lib/string-methods.html, 字符串方法的文档你可能想要拿它操作一下, 以便理解它的工作原理字符串方法中的 strip 和 replace 特有用文档中使用的法可能会使人困惑例如, 在 find(sub[, start[, end]]) 中, 方括号表示可的参数 sub 是必需的,start 是可的 ; 如果包含了 start, 那么 end 就是可的字符串 60

第 7 章文件 7.1 持久性截止目前, 我已学了如何写程序, 通条件行函数和迭代等手段, 与中央理器 CPU 通我的意愿我学了如何在主存器中建与使用数据 CPU 和内存是件工作与行的地方它也是所有算机行思考的大回一下之前的硬件架, 源关后 CPU 与主存器 ( 也就是内存 ) 中的数据就会失之前我学写的 Python 程序作的本章介助存器 ( 也就是文件 ) 源关后助存器里的数据不会借助 U ( 存 ), 我可以把程序从一个系移到一个系首先, 我学文本文件的写里的文本文件是指我在文本器中建的然后, 我会了解如何与数据文件行交互, 例如, 二制文件, 通数据件行写 7.2 打开文件从硬上写文件之前, 必首先打开个文件打开文件需要与操作系行, 它知道文件数据的存位置打开一个文件, 操作系通文件名找到它, 并确定个文件是否存在在下面的例子中, 我打开 mbox.txt 个文件, 它存在你行的 python 程序同一个文件下个示例用来打开 mbox.txt 文件个文件存在你 Python 所在的那个文件从 http://www.py4inf.com/code/mbox.txt 下个文件 >>> fhand = open('mbox.txt') >>> print fhand <open file 'mbox.txt', mode 'r' at 0x1005088b0> 如果文件成功被打开, 操作系会返回一个文件句柄文件句柄并不存文件的数据, 只是一个操作, 用于取数据如果求的文件存在, 你会得到一个句柄并得取文件的相限文件 61

如果文件不存在, 打开失, 出追踪信息, 无法得到文件内容的句柄 >>> fhand = open('stuff.txt') Traceback (most recent call last): File "<stdin>", line 1, in <module> IOError: [Errno 2] No such file or directory: 'stuff.txt' 稍后, 我会使用 try 和 except 更好地理文件打开文件不存在的情况 7.3 文本文件与文本行文本文件可若干文本行的序列, 与 Python 字符串是字符的序列道理相同例来, 以下是一个文本文件示例, 了在一个开源目中开成的件活件交流的整体文件可以从 http://www.py4inf.com/code/mbox.txt 下文件的版可以从 http://www.py4inf.com/code/mbox-short.txt 下文件中包含多条件, 遵守一种准格式以 From 开的行是每一条件第一行, 以 From: 开的行是件的一部分, 注意区分更多信息 http://en.wikipedia.org/wiki/mbox 将文本文件分解成文本行, 一行的束用的字符来表示, 称行符 Python 字符串常量的行符用 \n 表示看起来像个字符, 事上它是一个字符在 Python 解器中入量 stuff,\n 出在字符串中, 使用 print 句可以看到字符串被行符分成了行 >>> stuff = 'Hello\nWorld!' >>> stuff 'Hello\nWorld!' >>> print stuff Hello World! >>> stuff = 'X\nY' >>> print stuff X Y >>> len(stuff) 3 因行符是一个字符, 所以字符串 X\nY 的度是 3 基于以上考, 逐行取文件, 我需要知道每一行的尾都有一个特殊的藏字符, 即行符之, 行符将文本文件分解若干文本行文件 62

7.4 取文本行然文件句柄并不包含文件的数据, 但它可以方便地建一个 for 循, 按行依次取文件 fhand = open('mbox.txt') count = 0 for line in fhand: count = count + 1 print 'Line Count:', count python open.py Line Count: 132045 for 循中文件句柄被当做序列来使用在个示例中,for 循只是地算并出文件的行数个循大致用英可以翻成 : 每遇到文件中的一行 ( 表示文件句柄 ), 将 count 量加一 open 函数如果没能取整个文件, 可能是文件大, 其中包含多个 G 的数据不文件大小,open 句的打开是不的最,for 循取了文件中的数据以 for 循种方式取文件,Python 根据行符将文件数据分成若干文本行 Python 根据行符得一行, 每次迭代中将行符作一行的最后一个字符由于 for 循每次只取一行数据, 因此它能高效地取与出大型文件的文本行, 无需耗尽内存来存数据上面的程序只使用很少的内存就能任意大小文件的文本行, 它先取, 然后, 最后舍弃如果文件大小相于内存容量来很小, 那么就可以把它当做一个字符串, 在文件句柄上使用 read 方法一次性取来 >>> fhand = open('mbox-short.txt') >>> inp = fhand.read() >>> print len(inp) 94626 >>> print inp[:20] From stephen.marquar 在个示例中, mbox-short.txt 整个文件 ( 94626 个字符 ) 直接被入到量 inp 中我使用字符串分割, 打印出量 inp 中存的字符串前 20 个字符以种方式取文件, 所有的文本行和行符被当做一个整体, 作一个大字符串存在 inp 量中住, 只有当算机内存能承文件数据大小的情况下, 才能用种方式打开文件如果文件太大, 内容无法承, 那就需要写一个 for 或 while 循来分取 7.5 搜索文件搜索文件中数据的一种最常方式是通整个文件, 只理符合特定条件的文本行, 其他一概忽略我将文件取与字符串方法合起来, 建的搜索机制例来, 取一个文件并把以 From: 开的行打印出来我可以使用字符串 startwith 方法来符合前要求的行 fhand = open('mbox-short.txt') for line in fhand: if line.startswith('from:') : print line 文件 63

程序行果如下 : From: stephen.marquard@uct.ac.za From: louis@media.berkeley.edu From: zqian@umich.edu From: rjlowe@iupui.edu... 出果正是我想要的以 Form: 开的行, 但是什么会有多余的空行出呢? 是由于不可的行符所致每一行都以行符束, 因此 print 句出的量 line 中的字符串有一个行符,print 出本身会增加一个行符, 所以最就成了空行我可以使用字符串分割来打印出不含最后一个字符的文本行, 不有一个更的法, 使用 rstrip 方法截掉字符串后面的空白符, 程序代如下所示 : fhand = open('mbox-short.txt') for line in fhand: line = line.rstrip() if line.startswith('from:') : print line 程序行果如下 : From: stephen.marquard@uct.ac.za From: louis@media.berkeley.edu From: zqian@umich.edu From: rjlowe@iupui.edu From: zqian@umich.edu From: rjlowe@iupui.edu From: cwen@iupui.edu... 随着文件理程序得越来越复, 你可能会用到 continue 句来写搜索循搜索循的基本思路是找感趣的行, 跳不感趣的行当找到感趣的的文本行, 行相的操作跳不感趣的文本行的循, 代如下所示 : fhand = open('mbox-short.txt') for line in fhand: line = line.rstrip() # Skip 'uninteresting lines' if not line.startswith('from:') : continue # Process our 'interesting' line print line 程序行果是一的可以理解, 不感趣的文本行就是那些不以 From: 开的行, 我使用 continue 跳些行于感趣的文本行, 也就是那些以 From: 开的行, 我行相理我可以使用字符串方法 find 来模文本器的搜索功能, 找到任何一行中出待的字符串由于 find 方法可以找一个字符串在一个字符串中出的次数, 也可以返回字符串的位置或 -1( 表示字符串没有找到 ) 我写一个循, 找到包含 @uct.ac.za 字符串的文本行, 也就是找到来自南非开普敦大学的件 fhand = open('mbox-short.txt') 文件 64

for line in fhand: line = line.rstrip() if line.find('@uct.ac.za') == -1 : continue print line 程序行果如下 : From stephen.marquard@uct.ac.za Sat Jan 5 09:14:16 2008 X-Authentication-Warning: set sender to stephen.marquard@uct.ac.za using -f From: stephen.marquard@uct.ac.za Author: stephen.marquard@uct.ac.za From david.horwitz@uct.ac.za Fri Jan 4 07:02:32 2008 X-Authentication-Warning: set sender to david.horwitz@uct.ac.za using -f From: david.horwitz@uct.ac.za Author: david.horwitz@uct.ac.za... 7.6 用文件名我不希望在理不同文件每次都要修改 python 代一个更号的方法是每次行程序, 用自己入文件名一来, 用就可以将个程序用于不同文件, 无需改 Python 代一个非常的方法可以足以上需求, 使用 raw_input 方法用入文件名, 代如下所示 : fname = raw_input('enter the file name: ') fhand = open(fname) count = 0 for line in fhand: if line.startswith('subject:') : count = count + 1 print 'There were', count, 'subject lines in', fname 从用那里得文件名, 把它予 fname 量, 然后打开的文件在, 我可以不同的文件重复行个程序了 python search6.py Enter the file name: mbox.txt There were 1797 subject lines in mbox.txt python search6.py Enter the file name: mbox-short.txt There were 27 subject lines in mbox-short.txt 入下一小之前, 仔看段程序, 自己 : 可能会出的是什么? 或者友好的用可能会做些什么, 致个精巧的程序会, 的我在用眼中就不那么酷了 7.7 使用 try except 与 open 告你不要看是最后的机会如果用入的不是一个文件名呢? python search6.py Enter the file name: missing.txt Traceback (most recent call last): File "search6.py", line 2, in <module> 文件 65

fhand = open(fname) IOError: [Errno 2] No such file or directory: 'missing.txt' python search6.py Enter the file name: na na boo boo Traceback (most recent call last): File "search6.py", line 2, in <module> fhand = open(fname) IOError: [Errno 2] No such file or directory: 'na na boo boo' 不要笑, 不管是有意是无意, 用做的任何操作都有可能破坏你的程序事上, 件开中有一个重要的部分是量保障 ( 称 QA), 可能由一个人或一个小他的工作就是尽可能破坏程序开的件在用件或程序付薪水之前,QA 的任就是找程序的缺陷可以,QA 是程序的最佳搭档程序出可以用 try/except 快速修复假 open 方法打开文件会出, 那么在 open 方法打开失, 增加一个恢复模式, 代如下 : fname = raw_input('enter the file name: ') try: fhand = open(fname) except: print 'File cannot be opened:', fname exit() count = 0 for line in fhand: if line.startswith('subject:') : count = count + 1 print 'There were', count, 'subject lines in', fname exit 函数会止程序, 个程序永不返回当用 ( 或 QA ) 入不正确的文件名, 我可以捕它并快速行修复 : python search7.py Enter the file name: mbox.txt There were 1797 subject lines in mbox.txt python search7.py Enter the file name: na na boo boo File cannot be opened: na na boo boo open 方法用的保是 Python 程序中 try/except 的典型用法以 Python 方式做事, 我使用 Pythonic 个 (Python 格 ) 上面的例子可称文件打开的 Python 格当更加熟悉 Python 后, 你会常和其他程序, 个效果相同的方案一个更具有 Python 格愈 Python 格化的目的是将程得工程性与性兼我不要程序能正常工作, 要解决方案更加雅 7.8 写入文件了能写入文件, 需要在打开文件使用 w 作第二个参数 >>> fout = open('output.txt', 'w') >>> print fout <open file 'output.txt', mode 'w' at 0xb7eb2410> 如果文件已存在, 以写入模式打开文件, 会除旧数据, 因此慎使用如果文件不存在, 那么会建一个新的文件文件 66

文件句柄象的 write 方法把数据写入文件 >>> line1 = 'This here's the wattle,\n' >>> fout.write(line1) 在束一行, 确保已明确插入了行符 print 句会自加上一个行符, 而 write 方法不会做 >>> line2 = 'the emblem of our land.\n' >>> fout.write(line2) 当文件写入完成, 得关文件, 确保写入物理磁, 断后数据才不会失 >>> fout.close() 以方式打开文件也要得关文件只打开新文件就得有点粗心大意了 Python 会在程序束, 确所有打开的文件被关了当写入文件, 我要文件关行明确声明, 确保万无一失 7.9 写文件, 你可能会遇到空格来的因空格符制表符和行符是藏的, 所以些很 >>> s = '1 2\t 3\n 4' >>> print s 1 2 3 4 内置函数 repr 可以解决它将任一象作参数, 返回象的一个字符串表示字符串中用反斜杠序列代表空白字符 >>> print repr(s) '1 2\t 3\n 4' 很有帮助一个可能遇到的是, 不同的操作系使用不同的字符来表示一行的束一些操作系使用行符 \n, 一些操作系使用返回字符 \r, 有一些操作系者都使用如果在不同的操作系之移文件, 些差异可能会致生大多数操作系都提供格式的用信息和更多疑 http://wikipedia.org/wiki/newline 当然, 你也可以自己写一个 7.10 捕 : 使用 try/except 句防止程序意外中止行符 : 在文件和字符串中表示一行尾的特殊字符 Python 格 : Python 更明确高效工作的程技使用 try 和 except 来恢复失的文件, 是 Python 格的一个典型例文件 67

量保 : 件品整体量保的一个人或一个 QA 任包括品与, 一般在件布之前行文本文件 : 保存在永久存介 ( 如硬 ) 的字符序列 7.11 7.1 写一个程序, 取一个文件, 以大写方式逐行打印出文件内容程序行果如下所示 : python shout.py Enter a file name: mbox-short.txt FROM STEPHEN.MARQUARD@UCT.AC.ZA SAT JAN 5 09:14:16 2008 RETURN-PATH: <POSTMASTER@COLLAB.SAKAIPROJECT.ORG> RECEIVED: FROM MURDER (MAIL.UMICH.EDU [141.211.14.90]) BY FRANKENSTEIN.MAIL.UMICH.EDU (CYRUS V2.3.8) WITH LMTPA; SAT, 05 JAN 2008 09:14:16-0500 你可以从 http://www.py4inf.com/code/mbox-short.txt 下文本文件 7.2 写一个程序, 用入文件名, 然后取文件, 按行的形式 j 行看 X-DSPAM-Confidence: 0.8475 遇到以 X-DSPAM-Confidence: 开的行, 提取行中的浮点数行数, 算些行的件信度文件取束后, 打印件平均信度 Enter the file name: mbox.txt Average spam confidence: 0.894128046745 Enter the file name: mbox-short.txt Average spam confidence: 0.750718518519 用 mbox.txt 和 mbox-short.txt 个文件你的代 7.3 有候, 程序感到无聊或是想找点子, 他会在程序里加入彩蛋 ( 无害的代 ) (http://en.wikipedia.org/wiki/easter_egg_(media)) 修改上面的程序, 当用入 na na boo boo, 打印一些有趣的消息不管文件是否存在, 程序都能正常行下面是程序行本 : python egg.py Enter the file name: mbox.txt There were 1797 subject lines in mbox.txt python egg.py Enter the file name: missing.tyxt File cannot be opened: missing.tyxt python egg.py Enter the file name: na na boo boo NA NA BOO BOO TO YOU - You have been punk'd! 不鼓励你在程序里加入彩蛋, 里只用作文件 68

第 8 章列表 8.1 列表即序列与字符串似, 列表是由若干成的序列字符串中的是字符 ; 列表中的可以是任何型列表中的称元素或数据列表的建方法有好几种, 其中最的是用方括号 [] 将元素括起来 : [10, 20, 30, 40] ['crunchy frog', 'ram bladder', 'lark vomit'] 第一个例子是由四个整数成的列表, 第二个例子是由三个字符串成的列表列表的元素不要求是同一型的下面的列表包含一个字符串, 一个浮点数, 一个整数, 以及一个列表 : ['spam', 2.0, 5, [10, 20]] 一个列表作一个列表的元素称列表嵌套不含任何元素的列表称空列表, 使用空的方括号 ([]) 建一个空列表正如你可能期望的, 可以把列表量 : >>> cheeses = ['Cheddar', 'Edam', 'Gouda'] >>> numbers = [17, 123] >>> empty = [] >>> print cheeses, numbers, empty ['Cheddar', 'Edam', 'Gouda'] [17, 123] [] 8.2 列表是可的列表元素的与字符串中字符的法是一的, 使用方括号操作符方括号内的表式指定索引位置注意, 索引从 0 开始 : >>> print cheeses[0] Cheddar 与字符串不同, 列表是可的你可以改列表中元素的序, 或者列表中的元素重新当括号算符出在句的左, 就可以列表中指定的元素 >>> numbers = [17, 123] >>> numbers[1] = 5 >>> print numbers [17, 5] numbers 列表的第二个元素之前是 123, 在是 5 列表 69

可以理解, 列表是索引与元素之的一种关系种关系称映射, 每一个索引一个元素列表与字符串的索引用法相同 : 任何整数表式都可作索引写一个不存在的元素, 你会得到 IndexError 索引提示如果索引, 表示从列表的尾部算起 in 算符也适用于列表 : >>> cheeses = ['Cheddar', 'Edam', 'Gouda'] >>> 'Edam' in cheeses True >>> 'Brie' in cheeses False 8.3 列表的遍遍列表元素最常用的方法是使用 for 循遍法与字符串遍相同 : for cheese in cheeses: print cheese 如果只需遍列表的元素, 个方法就足了但如果想写入或更新元素, 就需要索引一个常方法是 range 函数和 len 函数的合使用 : for i in range(len(numbers)): numbers[i] = numbers[i] * 2 个循可以遍并更新列表的每个元素 len 函数返回列表中的元素个数 range 函数返回一个索引列表 ( 取从 0 到 n- 1), 其中 n 是列表的度 i 行循, 得到下一个元素的索引函数体中的句使用 i 取元素的旧, 然后它予新于空列表来,for 循不会行函数体 for x in empty: print 'This never happens.' 尽管一个列表可以包含一个列表, 但被包含的列表只能被看作一个元素以下列表的度 4: ['spam', 1, ['Brie', 'Roquefort', 'Pol le Veq'], [1, 2, 3]] 8.4 列表的操作 + 算符接多个列表 : >>> a = [1, 2, 3] >>> b = [4, 5, 6] >>> c = a + b 列表 70

>>> print c [1, 2, 3, 4, 5, 6] 似地, * 算符列表行定次数的重复 : >>> [0] * 4 [0, 0, 0, 0] >>> [1, 2, 3] * 3 [1, 2, 3, 1, 2, 3, 1, 2, 3] 第一个例子将列表 [0] 重复了四次, 第二个例子将列表 [1,2,3] 重复了三次 8.5 列表的分割切片操作也适用于列表 : >>> t = ['a', 'b', 'c', 'd', 'e', 'f'] >>> t[1:3] ['b', 'c'] >>> t[:4] ['a', 'b', 'c', 'd'] >>> t[3:] ['d', 'e', 'f'] 如果省略第一个索引, 切片将从列表部开始 ; 如果省略第二个索引, 切片将理到列表的末尾如果个索引参数都被省略, 将会得到整个列表 >>> t[:] ['a', 'b', 'c', 'd', 'e', 'f'] 由于列表是可的, 在行列表折拉和截断等操作之前, 最好保留一份列表的副本句左的切片操作可以更新多个元素 : >>> t = ['a', 'b', 'c', 'd', 'e', 'f'] >>> t[1:3] = ['x', 'y'] >>> print t ['a', 'x', 'y', 'd', 'e', 'f'] 8.6 列表的操作方法 Python 提供了一些操作列表方法例如, 使用 append 在列表尾部添加一个新元素 >>> t = ['a', 'b', 'c'] >>> t.append('d') >>> print t ['a', 'b', 'c', 'd'] extend 可以将列表作参数, 并把一个列表的所有元素添加到一个列表的尾部 >>> t1 = ['a', 'b', 'c'] 列表 71

>>> t2 = ['d', 'e'] >>> t1.extend(t2) >>> print t1 ['a', 'b', 'c', 'd', 'e'] 个示例中 t2 没有生改 sort 可以将列表元素从低到高排序 >>> t = ['d', 'c', 'e', 'b', 'a'] >>> t.sort() >>> print t ['a', 'b', 'c', 'd', 'e'] 大多数列表方法是没有返回的, 它会修改列表, 但返回 None 如果你不小心写了下面的句 t = t.sort(), 得到的 t 不是你所期的排序 8.7 除元素除列表元素的方法有好几种如果知道元素的索引位置, 使用 pop 方法行除 : >>> t = ['a', 'b', 'c'] >>> x = t.pop(1) >>> print t ['a', 'c'] >>> print x b 上面的程序使用 pop 修改了列表, 打印出了被除的元素如果没有指定索引位置,pop 会除并返回最后一个元素如果无需返回除的元素, 可以直接使用 del 操作符 >>> t = ['a', 'b', 'c'] >>> del t[1] >>> print t ['a', 'c'] 如果只知道要除的元素, 但不知道它的索引位置, 可以使用 remove 方法 : >>> t = ['a', 'b', 'c'] >>> t.remove('b') >>> print t ['a', 'c'] remove 方法返回 None 当需要除多个元素, 可以根据切片索引, 使用 del 来 : >>> t = ['a', 'b', 'c', 'd', 'e', 'f'] >>> del t[1:5] >>> print t ['a', 'f'] 列表 72

一般, 切片会除个索引位置之的所有元素, 上切片不会除第二个索引参数所的元素 8.8 列表与函数列表有多内嵌函数可用来遍, 无需写循代 : >>> nums = [3, 41, 12, 9, 74, 15] >>> print len(nums) 6 >>> print max(nums) 74 >>> print min(nums) 3 >>> print sum(nums) 154 >>> print sum(nums)/len(nums) 25 当列表元素数字,sum() 函数才会起作用其他函数如 max() len() 等字符串列表和其他可行比的数据型才会起作用我重写先前算数字列表平均的程序用入一个列表, 程序出列表的平均首先, 不使用列表算平均的程序如下 : total = 0 count = 0 while ( True ) : inp = raw_input('enter a number: ') if inp == 'done' : break value = float(inp) total = total + value count = count + 1 average = total / count print 'Average:', average 在个程序中, 不断提示用入数据, 我使用 count 和 sum 个量来数个数以及求和我只需下用入的数据, 在循束后, 利用内嵌的函数算和和个数 numlist = list() while ( True ) : inp = raw_input('enter a number: ') if inp == 'done' : break value = float(inp) numlist.append(value) average = sum(numlist) / len(numlist) print 'Average:', average 在循开始之前, 首先建立一个空列表, 每得到一个数据, 就把它添加到列表的尾部在程序最后, 只需将列表中数据的和除以列表的度, 就可以求出平均 8.9 列表与字符串字符串是字符的序列, 而列表是一系列的序列字符列表与字符串是不同的我可利用 list 方法, 把字符串成字符列表 : 列表 73

>>> s = 'spam' >>> t = list(s) >>> print t ['s', 'p', 'a', 'm'] 由于 list 是一个内置函数, 避免使用 list 作量名者也会避免使用 l 作量名, 因容易和数字 1 搞混, 也就是什么 t 作量名的原因 list 函数将一个字符串化成一些独的字母如果想把一个字符串分成独的, 使用 split 函数 : >>> s = 'pining for the fjords' >>> t = s.split() >>> print t ['pining', 'for', 'the', 'fjords'] >>> print t[2] the 一旦使用 split 函数将字符串分解成由成的序列, 你就可以利用索引操作符 ( 方括号 ) 来列表中的特定了 split 函数有一个可参数, 称分隔符 (delimiter) 它可以指定特定字符作之的界限以下示例将字符 - 作分隔符 : join 函数与 split 函数的作用相反它使用字符串列表, 把列表元素接起来 join 是字符串方法, 所以必指定分隔符, 将列表作参数 >>> t = ['pining', 'for', 'the', 'fjords'] >>> delimiter = ' ' >>> delimiter.join(t) 'pining for the fjords' 在个例子中, 分隔符是一个空格所以 join 函数会在个之加一个空格如要接字符串无需隔, 可以使用空字符串 ('') 作分隔符 8.10 行解析 From stephen.marquard@uct.ac.za Sat Jan 5 09:14:16 2008 split 方法理此非常有效先写一个小程序, 找到以 from 开的句子, 然后把些句子分解, 最后出句子中的第三个 : fhand = open('mbox-short.txt') for line in fhand: line = line.rstrip() if not line.startswith('from ') : continue words = line.split() print words[2] 我也可以通在 If 句的同一行放置 continue, 作 if 句的化形式从作用上,if 函数的种化形式与 continue 在下一行的形式是一的程序行果如下 : 列表 74

Sat Fri Fri Fri... 后章会介更复的行文本提取技, 以及如何分解文本行, 从中找到我所需要的准确信息 8.11 象与行以下句 : a = 'banana' b = 'banana' a 和 b 都指向一个字符串, 但它所指向的是不是同一个字符串呢? 存在以下种情况 : 一种情况是,a 和 b 指向具有相同的个不同象一种情况是, 它指向同一个象到底属于一种情况, 使用 is 算符 ; >>> a = 'banana' >>> b = 'banana' >>> a is b True 在个例子中,Python 只建了一个象,a 和 b 都指向它如果建个列表就会得到个象 : >>> a = [1, 2, 3] >>> b = [1, 2, 3] >>> a is b False 种情况下, 因它有相同的元素, 我可以个列表是等价的, 但不能它是同一个它不是相同的象当然, 如果个象是同一个, 那它肯定是等价的, 反之不成立截止目前, 我在交替使用象和更的提法是, 象有当行句 a = [1,2,3],a 会指向一个列表象个列表象的是一个特定元素序列此, 如果有外一个列表与它的元素相同, 那只能它有相同的 8.12 名引用如果 a 指向一个象, 当行 b=a 后, 个量都将指向同一个象 : >>> a = [1, 2, 3] >>> b = a 列表 75

>>> b is a True 量与象之的关系称引用在个例子中, 同一个象有个引用有多个引用的象就会有多个名称, 种象称作象被予了名如果名化的象是可的, 那么一个名的化, 将会影到其他名的引用 >>> b[0] = 17 >>> print a [17, 2, 3] 尽管一行是有用的, 但也容易造成一般而言, 可的象最好不要使用名像字符串不可象来, 名并不会造成很大如下所示 : a = 'banana' b = 'banana' a 和 b 是否指向同一个字符串, 几乎没差 8.13 列表参数当把一个列表一个函数, 函数就会得到列表的一个引用如果个函数改了一个列表参数, 用者会知道个化例如,delete_head 除了列表的第一个元素 : def delete_head(t): del t[0] 下面是它的用法 : >>> letters = ['a', 'b', 'c'] >>> delete_head(letters) >>> print letters ['b', 'c'] 上述参数 t 与量 letters 是同一个象的名区分修改列表与新建列表的操作, 是非常重要的例如, 下面的示例中,append 方法修改了列表, 而 + 算符新建了一个列表 : >>> t1 = [1, 2] >>> t2 = t1.append(3) >>> print t1 [1, 2, 3] >>> print t2 None >>> t3 = t1 + [3] >>> print t3 [1, 2, 3] >>> t2 is t3 False 列表 76

在写列表的修改函数, 种区得非常重要例如, 下面的函数就并没有到除列表元素的目的 : def bad_delete_head(t): t = t[1:] # WRONG! 切片操作会新建一个列表, 句将 t 作列表的引用但于之前作参数的列表来没有任何影一种可行的法是写一个函数, 建并且返回一个新列表例如,tail 函数会返回一个新的列表, 其包含除第一个元素之外的其他所有元素 def tail(t): return t[1:] 个函数并不会改原始列表以下是它的用法 : >>> letters = ['a', 'b', 'c'] >>> rest = tail(letters) >>> print rest ['b', 'c'] 8.1 写 chop 函数, 移除列表的元素和尾元素, 并返回 None 然后, 写 middle 函数, 移除列表的元素和尾元素, 返回一个新列表 8.14 列表及其他可象的不慎使用, 可能会造成的下面是一些常陷以及如何避免的方法 : 1) 大多数列表的方法会修改参数并返回 None, 与字符串的方法是相同字符串的方法通常会返回一个新字符串, 并不会改原始的字符串如果你如下的字符串代的写方式 : word = word.strip() 那你有可能写出如下的列表代 : t = t.sort() # WRONG! 因 sort 函数返回 None, 所以接下来予量 t 会行失使用列表的方法和操作符之前, 你仔文档, 然后在 Python 的交互模式中列表与其他序列 ( 如字符串 ) 共同有的方法和操作文档位于 http://docs.python.org/lib/typesseq.html 可序列独有的方法与操作文档位于 http://docs.python.org/lib/typesseq-mutable.html 2) 持并养成一种写列表的部分是由于多种方式都可以到相同目的造成的比如, 除列表元素的方法有 pop remove del 甚至分片等列表 77

若添加一个元素, 你也可以使用 append 方法或 + 算符不要忘, 下面的写法是正确的 : t.append(x) t = t + [x] 而下面的写法是的 : t.append([x]) t = t.append(x) t + [x] t = t + x # WRONG! # WRONG! # WRONG! # WRONG! 在 Python 交互模式中逐一, 确保自己搞清楚了有, 上面例子中只有最后一个会造成行, 其他三个可以行, 只不没有按照我的期行 3) 保留列表副本, 避免直接引用如果使用像 sort 会改参数的方法, 要保留原始列表, 复制一份列表副本 orig = t[:] t.sort() 在个例子中, 你也可以使用列表内置的 sorted 函数个函数会返回一个排序后的新列表, 而不会改原始列表在种情况下, 避免将 sorted 用于量命名 4) 列表切片与文件当取和解析文件, 可能有一些入会破坏我的程序写一个程序来取文件, 行大海式找, 打开守模式是很有必要的我重温之前的行取程序, 找出以 From 开的行中包含的星期 : From stephen.marquard@uct.ac.za Sat Jan 5 09:14:16 2008 由于我将一行分解成了一个个, 可以使用 startwith 函数, 只需看每一行的第一个, 就可以决定它是否符合要求外, 可以使用 continue 来跳不是以 From 开的文本行, 代如下所示 : fhand = open('mbox-short.txt') for line in fhand: words = line.split() if words[0]!= 'From' : continue print words[2] 看起来更了, 甚至都不需要行 rstrip 来除文件末尾的行符但就真得更好了? python search8.py Sat Traceback (most recent call last): File "search8.py", line 5, in <module> if words[0]!= 'From' : continue IndexError: list index out of range 列表 78

个程序会部分行成功, 我可以利地把第一个符合要求的行的第一个出, 但随后程序会中止, 出一个追踪里出了? 到底是什么的混乱数据, 使得看似雅灵活的 Python 程序出? 你也会真, 陷入深深的思考, 或求他人帮助最快捷和有效的方法是, 添加一个 print 句添加句的最佳位置在程序出那一行之前, 有可能打印出致出的数据然个方法会出大量的行, 但至少可以快速找到解决的一些索因此, 我在第五句前面添加了一条打印量 words 的句我甚至加了一个 Debug: 前, 做是了与其他正常的出区分开来 for line in fhand: words = line.split() print 'Debug:', words if words[0]!= 'From' : continue print words[2] 行个程序, 屏幕会出大量式出在出的末尾, 我只需要看出和追踪信息, 便可知道在追踪模之前生了什么 Debug: ['X-DSPAM-Confidence:', '0.8475'] Debug: ['X-DSPAM-Probability:', '0.0000'] Debug: [] Traceback (most recent call last): File "search9.py", line 6, in <module> if words[0]!= 'From' : continue IndexError: list index out of range 每一个行都会出列表, 些是文本行行分解后得到的当程序出, 列表空 [], 在文本器中打开文件, 内容示如下 : X-DSPAM-Result: Innocent X-DSPAM-Processed: Sat Jan 5 09:14:16 2008 X-DSPAM-Confidence: 0.8475 X-DSPAM-Probability: 0.0000 Details: http://source.sakaiproject.org/viewsvn/?view=rev&rev=39772 程序遇到了一个空行, 原来在里很然, 空行里是没有的我在写代怎么就没有考到个呢? 当程序着空行的第一个 (word[0]) 行 From 匹配, 由于没有找到, 所以就出索引范超出的在第五行添加守代, 避免不存在第一个的空行行比, 个位置是最好的有多方法来守个代, 我会在看第一个之前, 个数 : fhand = open('mbox-short.txt') count = 0 for line in fhand: words = line.split() # print 'Debug:', words if len(words) == 0 : continue if words[0]!= 'From' : continue print words[2] 首先, 我注掉用于的 print 句, 不要直接除它做可以修改失不必再重新然后, 我添加一个守句, 是否存在空, 如果有的, 使用 continue 句跳到文件的下一行里使用了个 continue 句, 出我感趣并希望理的文本行集合没有的行不是我想要的, 所以跳到下一行不是以 From 开的行也不符合要求, 所以跳列表 79

修改后的程序能成功行, 也它就是正确的了守句确有效地避免了空行, 但那也不, 当我写程序的候, 程我必常思考那里可能出了 8.2 找出以上程序中一行仍然没有得到有效守你也可以着建一个致程序行失的文本文件, 然后修改程序, 以确保每一行都得到了相的守, 确保程序能正确理你建的文本文件 8.3 重写上例中的守句使用复合表式, 在 if 句中使用 and 算符 8.15 名 : 个或多个量指向同一个象的情形分隔符 : 用来确定字符串如何被分割的字符或子字符串元素 : 列表 ( 或其他序列 ) 中的一个, 也称数据等价 : 有相同的同一性 : 同一个象, 可以推断出等价列表 : 一系列的序列列表遍 : 按序依次列表中的元素嵌套列表 : 一个列表作一个列表的一个元素存在引用 : 量与其取之的关 8.16 8.4 从 http://www.py4inf.com/code/romeo.txt 下一个文本文件写一个程序, 打开 romeo.txt 文件, 按行取每一行使用 split 函数, 将其分解成一系列的列表于每一个, 它是否已存在于列表之中, 若未出在列表中, 把它添加来程序行束, 按字母序出最的清 Enter file: romeo.txt ['Arise', 'But', 'It', 'Juliet', 'Who', 'already', 'and', 'breaks', 'east', 'envious', 'fair', 'grief', 'is', 'kill', 'light', 'moon', 'pale', 'sick', 'soft', 'sun', 'the', 'through', 'what', 'window', 'with', 'yonder'] 8.5 写一个程序, 取箱数据, 当遇到一个以 From 开的文本行, 使用 split 函数将行子分解成我需要抽取 From 开的行中第二个, 即信人 From stephen.marquard@uct.ac.za Sat Jan 5 09:14:16 2008 解析以 From 开的行, 打印出每行中第二个, 可以信人数, 在尾出数下面是程序行果的部分出 : 列表 80

python fromcount.py Enter a file name: mbox-short.txt stephen.marquard@uct.ac.za louis@media.berkeley.edu zqian@umich.edu [...some output removed...] ray@media.berkeley.edu cwen@iupui.edu cwen@iupui.edu cwen@iupui.edu There were 27 lines in the file with From as the first word 8.6 改写前面那个提示用入数据, 并在用入 done 后, 出最大与最小的程序写一个程序, 使用列表存用入的数据, 在循束后, 利用 max() 和 min() 函数分算出最大和最小 Enter a number: 6 Enter a number: 2 Enter a number: 9 Enter a number: 3 Enter a number: 5 Enter a number: done Maximum: 9.0 Minimum: 2.0 列表 81

第 9 章字典字典很像列表, 但更通用列表中的索引位置必整数, 而字典中索引几乎可以是任意型字典可看作是索引 ( 里称 ) 的集合与的集合之存在的一种映射每个一个, 与之的关系称之, 有也称数据例来, 我建一个英 - 西班牙字典, 其中与都是字符串 dict 函数可以建一个空字典注意, 由于 dict 是一个内置函数名称, 不能把它用作量名 >>> eng2sp = dict() >>> print eng2sp {} 大括号 {} 表示一个空字典你可以使用方括号向字典里添加数据 >>> eng2sp['one'] = 'uno' 行句建了一个从 one 到 uno 映射的字典如果再次打印个字典, 我会看到一个, 与之用冒号隔开 >>> print eng2sp {'one': 'uno'} 字典的入形式与出形式是一的例来, 你可以建一个包含三个数据的字典 : >>> eng2sp = {'one': 'uno', 'two': 'dos', 'three': 'tres'} 但是, 如果你直接打印 eng2sp, 其果会出人意料 : >>> print eng2sp {'one': 'uno', 'three': 'tres', 'two': 'dos'} 出的序生了改事上, 如果你在算机上入个字典, 得到的出果跟上面的序可能也不一一般而言, 字典的序往往是不可的即便如此, 不会造成什么因字典并不是用整数来索引的, 而是采用来找的 >>> print eng2sp['two'] 'dos' two 的是 dos, 与字典的序无关如果找的不在字典里, 你会得到一个异常提示 : >>> print eng2sp['four'] 字典 82

KeyError: 'four' len 函数也适用于字典, 它会返回字典中的个数 >>> len(eng2sp) 3 in 操作符也适用于字典, 它会告知你找的西是否作存在于字典中, 但不能是否是作出很好的判断 >>> 'one' in eng2sp True >>> 'uno' in eng2sp False 了判断要找的西是否作存在于字典中, 使用 values 方法, 它会返回字典中所有的一个列表, 然后使用 in 操作符作出判断 >>> vals = eng2sp.values() >>> 'uno' in vals True 列表与字典的 in 操作符算法上是有差的在列表中,Python 采用性搜索策略, 搜索与列表度成正比在字典中, Python 采用了一种很有效的哈希表算法种算法不管字典里面有多少数据, 花上几乎没有什么差此不述哈希表的原理, 更多相关知 http://wikipedia.org/wiki/hash_table 9.1 写一个程序, 取 words.txt 文件中的, 将它作存在字典中此不需要关心的然后, 使用 in 操作符快速判断某一字符串是否存在于字典中 9.1 字典作数器假定一个字符串, 你想要知道其中每个字符出的次数, 以下几种方式可供 : 1. 建 26 个量, 分字母表中每个字母出的次数然后, 遍字符串, 每遇到一个字母, 相的数量加 1, 或可以采用一个式条件来 2. 建一个包含 26 个元素的列表然后, 使用 Python 内置的 ord 函数, 将每一个字符成数字, 把个数字作索引存入列表, 再增加相的数量 3. 建一个以字符, 其出次数作的字典首次遇到一个字符, 将其作一个数据添加到字典里之后, 遇到字典里已存在的数据, 就其加 1 以上方法都了相同的算果, 但每种方法的算策略各不相同行算的一种方式称 (implementation) 有些方式于其他方式例来, 字典的一个点在于, 我不必事先知道字符串中出了些字母, 只需确会出的字母分配空就好了下面是一段示例代 : word = 'brontosaurus' d = dict() for c in word: if c not in d: d[c] = 1 字典 83

else: d[c] = d[c] + 1 print d 我可以有效地算出直方直方是关于数器 ( 次 ) 的用 for 循遍字符串每次循, 如果字符 c 不在字典中, 我就建一个字典, 以 c, 初始 1( 表示个字母至此出了一次 ) 如果 c 已存在于字典中, 只需将 d[c] 加 1 即可程序行果如下 : {'a': 1, 'b': 1, 'o': 2, 'n': 1, 's': 2, 'r': 2, 'u': 2, 't': 1} 直方表示字母 a 和 b 分出了一次, c 出了次, 后面的含似, 不再述字典有一个 get 方法, 方法有一个和一个默如果出在字典中, 那么它会返回此的如果不在字典中, 返回事先定的默示例程序如下 : >>> counts = { 'chuck' : 1, 'annie' : 42, 'jan': 100} >>> print counts.get('jan', 0) 100 >>> print counts.get('tim', 0) 0 我使用 get 方法可以把直方循写得更因 get 方法自理了不在字典中的情况的, 代的 4 条句可至 1 条, 可以去掉 if 句 word = 'brontosaurus' d = dict() for c in word: d[c] = d.get(c,0) + 1 print d 使用 get 方法化数循的做法已成 Python 中的一种普遍做法, 本后章会多次用到因此, 你仔体会一下,if 条件和 in 操作的循与 get 方法的循之的区者可以同的目的, 但是后者更加 9.2 字典与文件字典的常用法之一是面文字的文本文件行首先, 我从密欧与朱叶中抽取一段的文本, 参照 http://shakespeare.mit.edu/tragedy/romeoandjuliet/romeo_juliet.2.2.html 由于开始接触, 我使用不包含点符号的化后的短文本随后会介包含点符号的文本理方法 But soft what light through yonder window breaks It is the east and Juliet is the sun Arise fair sun and kill the envious moon Who is already sick and pale with grief 写一个 Python 程序, 取上述文件的每一行, 并将每一行分解由成的一个列表然后, 遍每个, 使用字典来每个的出次数你可以看到, 段程序包含个 for 循, 外部循用来取文件中每一行, 内部循迭代出行的每一个就是所字典 84

的嵌套循, 其中一个外部循, 一个内部循由于外部循每迭代一次, 内部循都会行它全部的迭代基于一点, 我内部循比外部循迭代地更快个嵌套循的合确保了入文件的每一行的每个都会被到 fname = raw_input('enter the file name: ') try: fhand = open(fname) except: print 'File cannot be opened:', fname exit() counts = dict() for line in fhand: words = line.split() for word in words: if word not in counts: counts[word] = 1 else: counts[word] += 1 print counts 行程序, 生成一个包含全部数的原始文件, 出没有排序的哈希序列 romeo.txt 文件可在 http://www.py4inf.com/code/romeo.txt 得 python count1.py Enter the file name: romeo.txt {'and': 3, 'envious': 1, 'already': 1, 'fair': 1, 'is': 3, 'through': 1, 'pale': 1, 'yonder': 1, 'what': 1, 'sun': 2, 'Who': 1, 'But': 1, 'moon': 1, 'window': 1, 'sick': 1, 'east': 1, 'breaks': 1, 'grief': 1, 'with': 1, 'light': 1, 'It': 1, 'Arise': 1, 'kill': 1, 'the': 3, 'soft': 1, 'Juliet': 1} 通字典找到出最多的及其次数, 并不是那么方便因此, 我需要增加一些 Python 代, 以便出更有用的信息 9.3 循与字典如果在 for 句中把字典看做一个待循的序列, 它会遍字典中的每一个下面的循出每一个及其的 : counts = { 'chuck' : 1, 'annie' : 42, 'jan': 100} for key in counts: print key, counts[key] 程序行果如下 : jan 100 chuck 1 annie 42 再次强, 字典中的是没有固定序的我可以将种模式用到之前介的循的各种常用方法例如, 如果想要找到字典中所有大于 10 的, 程序代如下 : 字典 85

counts = { 'chuck' : 1, 'annie' : 42, 'jan': 100} for key in counts: if counts[key] > 10 : print key, counts[key] for 循是通字典的行迭代因此, 我必使用索引操作符来索相的程序行的出果如下 : jan 100 annie 42 我只看到了大于 10 的如果按照字母序出字典中的, 首先使用字典象的 keys 方法, 将所有的放入一个列表然后, 个列表行排序, 排序后的列表行迭代依照字母序, 通每个出的 : counts = { 'chuck' : 1, 'annie' : 42, 'jan': 100} lst = counts.keys() print lst lst.sort() for key in lst: print key, counts[key] 程序行的出果如下 : ['jan', 'chuck', 'annie'] annie 42 chuck 1 jan 100 首先, 通 keys 方法得到了包含的未排序的列表然后, 通 for 循得到有序的 9.4 高文本解析上面示例程序用到的 romeo.txt 文件是我手除所有点符号之后得到的尽可能化的文本的文本会包含大量点符号, 如下所示 : But, soft! what light through yonder window breaks? It is the east, and Juliet is the sun. Arise, fair sun, and kill the envious moon, Who is already sick and pale with grief, Python 的 split 函数可以空格, 把看作是由空格分隔开来的元, 所以, soft 和 soft! 会被不同的, 分它建一个字典由于文本中存在大写, who 和 Who 也是不同的, 分行通字符串的 lower punctuation 与 translate 方法可以解决上述其中 translate 是最精的方法以下是 translate 的明文档 : string.translate(s, table[, deletechars]) 首先, 从 s 中除 deletechars 参数 ( 如果存在的 ) 指定的所有字符, 然后使用 table 参数来翻字符 table 是一个 256 个字符的字符串, 用来翻每个字符, 并按照序数行索引如果 table 是 None, 只会行字符除步字典 86

里不指定 table 参数, 用 deletechars 参数来除所有点符号 Python 甚至可以告我, 点符号包括些字符 : >>> import string >>> string.punctuation '!"#$%&\'()*+,-./:;<=>?@[\\]^_`{ }~' 我程序做出如下修改 : import string # New Code fname = raw_input('enter the file name: ') try: fhand = open(fname) except: print 'File cannot be opened:', fname exit() counts = dict() for line in fhand: line = line.translate(none, string.punctuation) line = line.lower() words = line.split() for word in words: if word not in counts: counts[word] = 1 else: counts[word] += 1 # New Code # New Code print counts 我使用 translate 方法除了所有的点符号, 并将每一行中的字母小写程序主体并未生改注意, Python2.5 及早期版本中,translate 方法不接受 None 作第一个参数, 因此使用下面的代来用方法 : print a.translate(string.maketrans(' ',' '), string.punctuation 得一些 Python 的和像 Python 一思考, 不 Python 多常数据分析内置了解决方案随着学的深入, 通大量的示例代和技文档的, 你会知道去里找人是否用 Python 已解决了此, 从而一些你的工作以程序行的部分出果如下 : Enter the file name: romeo-full.txt {'swearst': 1, 'all': 6, 'afeard': 1, 'leave': 2, 'these': 2, 'kinsmen': 2, 'what': 11, 'thinkst': 1, 'love': 24, 'cloak': 1, a': 24, 'orchard': 2, 'light': 5, 'lovers': 2, 'romeo': 40, 'maiden': 1, 'whiteupturned': 1, 'juliet': 32, 'gentleman': 1, 'it': 22, 'leans': 1, 'canst': 1, 'having': 1,...} 看些出仍然很事, Python 来帮助我找到具体要找到的信息要做到一点, 我需要学 Python 的元在学元会使用个例子 9.5 当需要理更大的数据集, 手工出与数据得不那么了以下是大数据集的一些建 : 少入 : 尽可能地少数据量的大小例如, 程序取一个文本文件, 前十行, 或者最小的示例你可以文件本身, 或者修改程序, 它只取文件的前 n 行后一种方式更好一些字典 87

当出, 通不断地小 n 来确定的位置当找到并正后, 再不断增大 n 摘要与型 : 不要整个数据集行出和, 可以考先出数据的摘要例如, 字典的数据个数, 或数字列表的数行的一个常原因是数据型不正确此, 通常出个的型就可以解决了写自程序 : 有通写代来自例如, 需要算数字列表的平均数, 你可以个果是不是于列表的最大与最小之种称, 它会出些果是完全不符合的一种是比种不同算的果, 它是否一致种称一致性工整化出果 : 的出果行格式化, 有助于再次强, 在程序架上花些心思能有效少的花 9.6 字典 : 一及其的映射哈希表 :Python 字典的算法哈希函数 : 使用哈希表来算字典中的位置的函数直方 : 一数器 : 行算的一种方法数据 : 的一种法 : 字典中的第一部分象 : 从到的映射关系表找 : 字典的一种操作, 根据找到的嵌套循 : 一个循内部包括一个或多个循外部循每行一次, 内部循会全部行一遍 : 字典中的第二部分象里所的比之前提到的取更加指 9.7 9.2 写一个程序, 按照接收的星期件行分首先, 找出以 From 开的文本行, 然后, 取出符合条件的每一行中的第三个, 使用一个数器一周中每一天件被接收的次数在程序的末尾, 出字典的内容 ( 不要求次序 ) Sample Line: From stephen.marquard@uct.ac.za Sat Jan 5 09:14:16 2008 Sample Execution: python dow.py Enter a file name: mbox-short.txt {'Fri': 20, 'Thu': 6, 'Sat': 1} 9.3 写一个程序, 取件日志, 使用字典来建一个直方, 每个箱出的件数量, 然后出字典字典 88

Enter file name: mbox-short.txt {'gopal.ramasammycook@gmail.com': 1, 'louis@media.berkeley.edu': 3, 'cwen@iupui.edu': 5, 'antranig@caret.cam.ac.uk': 1, 'rjlowe@iupui.edu': 2, 'gsilver@umich.edu': 3, 'david.horwitz@uct.ac.za': 4, 'wagnermr@iupui.edu': 1, 'zqian@umich.edu': 4, 'stephen.marquard@uct.ac.za': 2, 'ray@media.berkeley.edu': 1} 9.4 在上述程序中添加代, 从文件中找出的件最多取完所有数据并且建立字典之后, 使用最大循 ( 5.7.2) 字典行遍, 找出的件最多, 并出他的件数 Enter a file name: mbox-short.txt cwen@iupui.edu 5 Enter a file name: mbox.txt zqian@umich.edu 195 9.5 写一个程序, 件送者的域名, 而不是件送者的件地址在程序的末尾, 出字典的内容 python schoolcount.py Enter a file name: mbox-short.txt {'media.berkeley.edu': 4, 'uct.ac.za': 6, 'umich.edu': 7, 'gmail.com': 1, 'caret.cam.ac.uk': 1, 'iupui.edu': 8} 字典 89

第 10 章元 10.1 元是不可的元 1 是由若干成的一个序列, 与列表非常相似元中存的可以是任何数据型并有整数型索引元的一个重要特征是不可的元可以行比和使用哈希算法, 我可以其行排序, 在 Python 字典中, 使用元作 >>> t = 'a', 'b', 'c', 'd', 'e' 元用括号括起来, 然不是必需的, 但可以帮助我在 Python 代中快速出些是元 >>> t = ('a', 'b', 'c', 'd', 'e') 建个元素的元, 必在末尾加一个逗号 >>> t1 = ('a',) >>> type(t1) <type 'tuple'> 如果没有逗号,Python 会将 (' a ') 作一个字符串理 : >>> t2 = ('a') >>> type(t2) <type 'str'> 造元的一种方法是, 使用内置函数 tuple 如果不参数,tuple 函数会建一个空元 : >>> t = tuple() >>> print t () 如果参数是一个序列 ( 字符串列表或元 ),tuple 函数的用果是生一个包含序列元素的元 : >>> t = tuple('lupins') >>> print t ('l', 'u', 'p', 'i', 'n', 's') 由于 tuple 是造器的名称, 避免将其用作量名大部分的列表操作符也适用于元方括号索引一个元素 : >>> t = ('a', 'b', 'c', 'd', 'e') >>> print t[0] 'a' 切片操作符一元素元 90

>>> print t[1:3] ('b', 'c') 但是, 如果修改元中的元素, 会得到一个 : >>> t[0] = 'A' TypeError: object doesn't support item assignment 不能修改元的元素, 但可以用一个元替当前元 : >>> t = ('A',) + t[1:] >>> print t ('A', 'b', 'c', 'd', 'e') 10.2 元的比比算符适用于元和其它序列,Python 从每个序列的第一个元素开始比如果它相等, 比下一个元素, 以此推, 直到找到不同的元素找到不同元素之后, 随后的元素就不再考了 ( 即便它真得很大 ) >>> (0, 1, 2) < (0, 3, 4) True >>> (0, 1, 2000000) < (0, 3, 4) True 元中 sort 函数正是个工作原理它首先第一个元素排序, 如果第一个元素相同, 按第二个元素排序, 以此推一特性使其有一种 DSU 模式 : 修 (Decorate): 修 : 在序列的元素之前放置一个或多个排序, 排序 (Sort): 使用 Python 内置函数 sort 行排序, 去修 (Undecorate): 提取出序列中已排序的元素例来, 有一, 它行由到短的排序 : txt = 'but soft what light in yonder window breaks' words = txt.split() t = list() for word in words: t.append((len(word), word)) t.sort(reverse=true) res = list() for length, word in t: res.append(word) print res 第一个循建了一个元, 每个元包括及度, 度在前, 在后 sort 函数行比, 首先比度, 如果度相等, 比元中的第二个元素关字参数 reverse=true 指定 sort 函数按照倒序排列元 91

第二个循遍了元, 建了一个按照度降序排列的列表五个按照反向字母序排序, 所以 what 出在 soft 之前程序出果如下 : ['yonder', 'window', 'breaks', 'light', 'what', 'soft', 'but', 'in'] 当然, 一行文字被 Python 列表, 并按照度降序排列之后, 它就失去了原有的歌意味 2 10.3 元的 Python 言的一个独特句法特征是, 元可以出在句的左当左是一个序列, 一次可以多个量在本例中, 一个列表 ( 序列 ) 包含个元素使用一行句, 将第一个元素和第二个元素分予量 x 和量 y >>> m = [ 'have', 'fun' ] >>> x, y = m >>> x 'have' >>> y 'fun' >>> 不是魔法,Python 会大致翻元的法, 如下所示 : 3 >>> m = [ 'have', 'fun' ] >>> x = m[0] >>> y = m[1] >>> x 'have' >>> y 'fun' >>> 从文体上看, 在句左使用元, 我忽略了括号, 以下是有效的等价法 : >>> m = [ 'have', 'fun' ] >>> (x, y) = m >>> x 'have' >>> y 'fun' >>> 元有一个特巧妙的用途, 可以在一条句中交个量的 : >>> a, b = b, a 条句都是元, 左是量元, 右是表式元右的每个分予左的每个量右的所有表式在之前行左的量个数与右的个数必相同 : 元 92

>>> a, b = 1, 2, 3 ValueError: too many values to unpack 更普遍的情况是, 右可以是任何型的序列, 如字符串列表或元例如, 将件地址拆分成用名与域名的程序代如下 : >>> addr = 'monty@python.org' >>> uname, domain = addr.split('@') split 的返回是包含个元素的列表第一个元素是 uname, 第二个元素是 domain >>> print uname monty >>> print domain python.org 10.4 字典与元元有 items 方法, 方法返回元列表, 每个元是一个 4 >>> d = {'a':10, 'b':1, 'c':22} >>> t = d.items() >>> print t [('a', 10), ('c', 22), ('b', 1)] 如果是字典的, 其中的数据是没有特定序的由于元列表本身是一个列表, 元之可以行比, 以及元列表行排序将字典化元列表, 可以根据字典行排序, 并出字典的内容 >>> d = {'a':10, 'b':1, 'c':22} >>> t = d.items() >>> t [('a', 10), ('c', 22), ('b', 1)] >>> t.sort() >>> t [('a', 10), ('b', 1), ('c', 22)] 新的列表根据以字母升序排列 10.5 通字典行多个将 items 方法元与 for 循合起来, 你可以有一个良好的代模式, 使用循就可以遍字典中的与 for key, val in d.items(): print val, key 个循中存在个迭代量由于 items 返回一个元列表, 量 key 和 val 通字典的行迭代, 而得到循中的每次迭代都会使得 key 和 value 被予下一个字典 ( 仍然以哈希序 ) 元 93

此循的出果如下 : 10 a 22 c 1 b 再次强, 是哈希序, 也就是没有特定序将种方法合, 按照每个中的来排序, 出字典的内容要做到一点, 首先建一个元列表, 其中每个元 (value, key) 通 items 方法得到 (key, value) 元列表此, 我想要根据 value 排序, 而不是 key (value, key) 元列表一旦生成, 排序就得了, 按照反向次序列表排序, 出已排序的新列表 >>> d = {'a':10, 'b':1, 'c':22} >>> l = list() >>> for key, val in d.items() :... l.append( (val, key) )... >>> l [(10, 'a'), (22, 'c'), (1, 'b')] >>> l.sort(reverse=true) >>> l [(22, 'c'), (10, 'a'), (1, 'b')] >>> 建元列表要非常慎, 确保每个元的第一个元素是, 就能元列表行排序, 得所需的字典内容, 字典已按行排序 10.6 高回看看前面介的程序, 文本取自密欧于朱叶的第二幕第二在, 我充个程序, 出文本中出次数最多的前十个, 代如下所示 : import string fhand = open('romeo-full.txt') counts = dict() for line in fhand: line = line.translate(none, string.punctuation) line = line.lower() words = line.split() for word in words: if word not in counts: counts[word] = 1 else: counts[word] += 1 # Sort the dictionary by value lst = list() for key, val in counts.items(): lst.append( (val, key) ) lst.sort(reverse=true) for key, val in lst[:10] : print key, val 程序的第一部分取文件, 算出文档中每个出的次数, 将及其出次数放入字典中部分程序不做修改之前出量 count 的之后, 程序就束了, 里我建一个 (val, key) 元列表, 按照逆序列表行排序元 94

由于元中是第一个元素, 所以它被用于比如果多个元有相同的, 接下来元的第二个元素 ( ) 因此, 如果相同, 元将按照的字母序行排序在程序末尾, 我写了一个 for 循, 多个的迭代, 通列表切片操作 (lst[:10]), 迭代出前十个高至此, 程序的出看上去符合我想要的分析果 61 i 42 and 40 romeo 34 to 34 the 32 thou 32 juliet 30 that 29 my 24 thee 事上, 如此复的数据解析与分析只需 19 行易于理解的 Python 代就解决了就是 Python 言用于信息分析的明智依据之一 10.7 在字典中使用作元元可以使用哈希算法排序, 但列表不可以如果我想在字典中建一个合, 那么必使用元作假建一个号簿, 包含姓名与号的关系, 那么就会用到合若已定了量 last first 与 number, 字典句如下 : directory[last,first] = number 方括号里的表式是一个元在 for 循中使用元来遍个字典 for last, first in directory: print first, last, directory[last,first] 个循遍了 directory 中的, 里的是元它每个元的元素予量 last 和 first, 然后打印出姓名与的号 10.8 序列 : 字符串列表与元哦, 么多! 此的重点是元列表, 但本章几乎所有示例都可以用于列表的列表, 元的元以及列表的元避免列多, 有方便称序列的序列在多情况下, 不同型的序列 ( 字符串列表与元 ) 之可以互使用既然, 什么要一种序列而不用其他序列? 外, 如何合适的序列呢? 从最明的字符串起, 由于字符串元素只能是字符, 所以它比其他序列的局限性更大外, 字符串是不可改的如果需要在字符串中修改字符, 而不是新建一个字符串, 那么可能需要使用字符列表列表比元更常, 主要是因列表是可的以下情况可能更适合元 : 某些情况下, 例如 return 句, 它建元的法比建列表的要一些情况下, 可能列表更合适元 95

如果使用序列作字典的, 那么必使用不可型, 如元或字符串如果将序列作参数函数, 那么使用元会少由于名来意外情况的可能因元是不可的, 所以没有 sort 和 reverse 可以修改已有列表的方法然而,Python 提供了内建函数 sorted 与 reversed, 将任一序列作参数入, 之后返回一个元素相同但次序不同的新序列 10.9 列表字典与元通常被称数据本章中我到了复合数据, 例如, 元列表, 以元列表的字典复合数据是有用的, 但容易出形状, 即由于数据的型大小或成出所致, 亦或写代由于忘数据型致出例来, 如果列表包含一个整数, 出一个不在列表里的其他整数, 就不起作用程序, 如果遇到困, 可以以下四种方法 : : 代, 仔, 代是否按照你的意愿行行 : 通修改代行, 行不同版本的代通常, 程序在正确的地方示了正确的西, 那么程序而易, 但有候得花些来建程序的支架沉思 : 花一些去思考! 型究竟是什么? 法行或? 从消息或程序出中能得到什么信息? 什么的型会致你正遇到的? 在出之前, 最后一次你做了什么? 回退 : 某些候最好的法是回退, 撤最近的修改, 退回到程序可以正常工作和你能理解的状之后开始重建程新手有会陷在些活之中, 忘其他事情每种活都有自身的故障模式例来, 如果程序存在入, 只要不是概念上的解, 代就可以解决如果不明白程序做了什么, 即使 100 遍也看不到, 因就在你的袋里行可以提供帮助, 特是一些小型的然而, 如果你没有思考或仔代就行, 那么可能会陷入一种随机游走程模式, 也就是通随机修改, 直到程序正确行毫无疑, 随机游走程会花很你必花去思考就像一科学你至少有一个关于的假如果存在个或更多可能, 着考用去消除其中之一休息一下有助于思考与人交也一如果你向其他人 ( 甚至是自己 ) 解, 有在完之前, 你就找到答案了但是, 如果太多或修复的代于大和复, 即使最好的技也无于事有最好的是以退, 程序行化, 直到你能掌控和理解的程度程新手往往不愿意回退, 因他无法忍受除代 ( 即使它是的 ) 如果你自己写的代感不, 在除代之前复制一份到一个文件中之后, 你就能每次粘回来一小部分代找到度大的需要行沉思以及而后退等步如果你陷入其中一种, 其他的 10.10 可比的 : 相同型的之行比, 包括大于小于或等于可行比的型可以放在列表中, 并可以排序数据 : 相关的集合, 常形式有列表字典元等元 96

DSU: 修 - 排序 - 去修的写, 包括建元列表排序与抽取部分果的一种模式聚集 : 装参数元的操作可哈希的 : 有哈希函数的型不可型, 如整数浮点数和字符串, 都可以使用哈希函数 ; 可型, 如列表与字典, 不可以使用哈希函数散布 : 将序列参数列表的操作数据的形状 : 数据的型大小与成的概要例 : 包含一个元素的列表 ( 或其他序列 ) 元 : 不可的元序列元 : 右是序列, 左是量元右通后, 将其中的元素予左的量 10.11 10.1 修改之前的程序 : 取与解析出以 From 开的行, 取出符合条件的行中的箱使用字典出每个人的件数当所有的数据取完, 从字典中建一个元 (count, email) 列表, 然后列表行反向排序, 打印出提交最多的用 Sample Line: From stephen.marquard@uct.ac.za Sat Jan 5 09:14:16 2008 Enter a file name: mbox-short.txt cwen@iupui.edu 5 Enter a file name: mbox.txt zqian@umich.edu 195 10.2 出每条消息在一天中的小分布从以 From 开的行中, 找出字符串, 根据冒号将其分解每个小的次数行累, 按行打印出数, 并按照小行排序, 程序行果如下所示 : Sample Execution: python timeofday.py Enter a file name: mbox-short.txt 04 3 06 1 07 1 09 2 10 3 11 6 14 1 15 2 16 4 17 2 18 1 19 1 10.3 写一个程序, 取一个文件, 按照率降序打印出字母个程序将所有入化成小写, 只字母 a-z, 不空格数字点符号以及其他 a-z 之外的字符使用不同种的文本片段, 察不同言之的差异将果与 http://wikipedia.org/wiki/letter_frequencies 上的表行比 1. 有趣的事 : 元的命名取决于序列的度, 如一元 (single) 二元 (double) 三元 (triple,) 四元 (quadruple) 五元 (quintuple) 六元 (sextuple) 七元 (septuple) 等元 97

2. 者注 : 此句出自莎士比的密欧与朱叶原文 "But, soft! what light through yonder window breaks? ", 本作者略作修改, 将 through 改 in 3. Python 不做字面上的法翻如果你使用 Python 的字典行言翻, 无法得到想要的果 4. Python 3.0 中的用法有些差异元 98

第 11 章正表式至此, 我已学会如何取文件, 找模式与提取感趣的文本行片段文本行提取的方法, 包括字符串方法 ( 如 split 与 find) 列表与字符串切片等文本搜索与抽取是常任 Python 有非常强大的快速有效理此任的正表式正表式功能强大, 比复, 其法需要一些来熟悉, 所以本并没有早提及正表式几乎就是一关于字符串搜索与解析的小型程言事上, 整本都是正表式主展开本章介正表式基, 有关正表式更多信息, 参以下网址 : http://en.wikipedia.org/wiki/regular_expression http://docs.python.org/library/re.html 正表式在使用之前必先入到程序中正表式最的用法是 search() 函数搜索函数的用法如下程序所示 : import re hand = open('mbox-short.txt') for line in hand: line = line.rstrip() if re.search('from:', line) : print line 打开文件, 循每一行, 使用正表式的 search() 函数, 打印出包含字符串 "From:" 的文本行个程序其并没有正表式的真正力,line.find() 函数可以更容易地相同的果正表式的强大之体于, 可以在搜索字符串中添加特定字符, 以更精确的字符串文本行的匹配控制通在正表式中添加特定字符, 写很少代就可以复的匹配与抽取例如, 正表式的 ^ 符号匹配一行的开始我修改一下上面的程序, 匹配 From: 开的文本行 import re hand = open('mbox-short.txt') for line in hand: line = line.rstrip() if re.search('^from:', line) : print line 好了, 就做到匹配 From: 开的文本行仍然是一个非常的例子, 字符串的 startswith() 函数同可以之所以解, 目的是介正表式的理念, 包含特定行字符, 予文本匹配更多的控制 11.1 正表式的字符匹配多特定字符可以帮助我写非常强大的正表式最常用的特定字符是句点, 它可以匹配所有字符在下面的例子中, 正表式 "F..m:" 会匹配配 From: "Fxxm" F12m 或 "Fl@m" 正表式的句点可以匹配任意字符 import re hand = open('mbox-short.txt') for line in hand: line = line.rstrip() 正表式 99

if re.search('^f..m:', line) : print line * 和 + 表示一个字符可以重复任意次数, 在造正表式合种能力特有用些特定字符用来代替个字符, 星号匹配零或多个字符, 加号匹配一个或多个字符一步少代, 以下示例使用重复的通配符 : import re hand = open('mbox-short.txt') for line in hand: line = line.rstrip() if re.search('^from:.+@', line) : print line 搜索字符串 ^From:.+@ 会成功匹配以 From: 开, 之后一个或多个字符, 以 @ 尾的文本行果匹配如下所示 : From: stephen.marquard @uct.ac.za 可以理解,.+ 通配符匹配了冒号与 @ 之的所有字符 From:.+ @ 有候, 加号与星号可能会用力猛例如下面的字符串匹配,".+" 将其外推, 直到最后一个 @ From: stephen.marquard@uct.ac.za, csev@umich.edu, and cwen @iupui.edu 通添加其他字符, 星号和加号不要如此婪地匹配, 是可以做到的情参关婪行的文档 11.2 使用正表式抽取数据在 Python 中抽取字符串的数据, 用到的是 findall() 函数通正表式的匹配, 抽取所有符合的子字符串以下示例从格式无关的任何文本行中抽取似子件地址的文本 From stephen.marquard@uct.ac.za Sat Jan 5 09:14:16 2008 Return-Path: <postmaster@collab.sakaiproject.org> for <source@collab.sakaiproject.org>; Received: (from apache@localhost) Author: stephen.marquard@uct.ac.za 我不想每个文本行型写代, 每个文本行都分割和切片一次以下程序使用 findall() 找到文本中的子件地址, 从每一行抽取一个或多个子件地址 import re s = 'Hello from csev@umich.edu to cwen@iupui.edu about the meeting @2PM' lst = re.findall('\s+@\s+', s) print lst findall() 函数搜索第二个参数的字符串, 返回一个包含形如子件地址字符串的列表我使用字符序列来匹配非空字符 (\S) 正表式 100

程序行果如下 : ['csev@umich.edu', 'cwen@iupui.edu'] 解一下个正表式, 我找至少含有一个非空字符的子字符串, 之后是 @, 然后再是至少一个或多个非空字符 \S+ 匹配尽可能多个非空字符就是正表式中的婪匹配正表式会匹配个子件地址, 但不会匹配 @2PM, 原因是 @ 之前没有非空字符在程序中使用个正表式, 取文件的所有行, 然后打印出所有似子件地址的果, 如下所示 : import re hand = open('mbox-short.txt') for line in hand: line = line.rstrip() x = re.findall('\s+@\s+', line) if len(x) > 0 : print x 取每一行, 抽取与正表式匹配的所有字符串由于 findall() 返回的是列表, 我看下返回的列表不零, 打印出来的每行至少包含一个子件地址 mbox.txt 行程序, 得到如下果 : ['wagnermr@iupui.edu'] ['cwen@iupui.edu'] ['<postmaster@collab.sakaiproject.org>'] ['<200801032122.m03LMFo4005148@nakamura.uits.iupui.edu>'] ['<source@collab.sakaiproject.org>;'] ['<source@collab.sakaiproject.org>;'] ['<source@collab.sakaiproject.org>;'] ['apache@localhost]'] ['source@collab.sakaiproject.org;'] 一些子地址的开或尾包含了不正确的字符, 如 < 或 ; 里声明一下, 需要以字母或数字开和尾的字符串部分要做到一点, 我使用正表式的一个功能, 使用方括号列多个可接受的匹配字符在某种意上, \S 匹配的是非空字符的集合在, 我更清楚一些字符匹配的本了下面是新的正表式 : [a-za-z0-9]\s*@\s*[a-za-z] 看起来有点复, 你在明白正表式什么被称一的言了解一下个正表式, 找以一种子字符串, 以小写字母大写字母或数字开 [a-za-z0-9], 之后是零个或多个非空字符 \S, 然后是 @, 再是零个或多个非空字符 \S, 最后是一个大写或小写字母注意, 我从加号到星号, 再到零个或多个非空字符 [a-za-z0-9] 本身就是一个非空字符住, 星号和加号直接作用于它左的个字符如果在程序中使用个正表式, 数据会得干一些 : import re hand = open('mbox-short.txt') for line in hand: line = line.rstrip() x = re.findall('[a-za-z0-9]\s*@\s*[a-za-z]', line) 正表式 101

if len(x) > 0 : print x... ['wagnermr@iupui.edu'] ['cwen@iupui.edu'] ['postmaster@collab.sakaiproject.org'] ['200801032122.m03LMFo4005148@nakamura.uits.iupui.edu'] ['source@collab.sakaiproject.org'] ['source@collab.sakaiproject.org'] ['source@collab.sakaiproject.org'] ['apache@localhost'] 注意到 source@collab.sakaiproject.org 一行, 正表式消除了字符串尾 ( > ) 尾的个字母原因是我在正表式末尾追加了 [a-za-z], 要求正表式解析器找到的字符串必以字母尾因此, 当出 sakaiproject.org>;, 它会止步于匹配找到的最后一个字母, 里 g 是最后一个符合要求的字符匹配要注意的是, 程序的果是一个 Python 列表, 每个字符串是一个元素 11.3 将搜索与抽取合如果我想要找到以 X- 开的文本行, 如下所示 : X-DSPAM-Confidence: 0.8475 X-DSPAM-Probability: 0.0000 我不需要文本行中的浮点数, 需要符合以上法的文本行数使用下面的正表式来挑出符合要求的文本行 : ^X-.*: [0-9.]+ 解一下, 文本以 X- 开, 之后是零个或多个字符.*, 然后是一个冒号和一个空格空格之后是一个或多个字符, 可以是一个数字 (0-9) 或一个句点 [0-9.]+ 需要注意的是, 方括号中的句点匹配的是句点本身, 也就是, 它在方括号内不是通配符是一个非常的表式, 我感趣的文本匹配如下所示 : import re hand = open('mbox-short.txt') for line in hand: line = line.rstrip() if re.search('^x\s*: [0-9.]+', line) : print line 行个程序, 的数据保留如下内容 : X-DSPAM-Confidence: 0.8475 X-DSPAM-Probability: 0.0000 X-DSPAM-Confidence: 0.6178 X-DSPAM-Probability: 0.0000 在, 我要解决抽取数的, 使用 split 方法然使用 split 很, 我里使用正表式的一个功能, 搜索与解析同行正表式 102

括号是正表式的一个特殊字符在正表式中添加括号, 括号的内容将在匹配被忽略但是, 在 findall() 函数中括号表示的是匹配括号内的整个表式在抽取与正表式匹配的子字符串部分,findall() 函数适用, 修改之后的程序代如下 : import re hand = open('mbox-short.txt') for line in hand: line = line.rstrip() x = re.findall('^x\s*: ([0-9.]+)', line) if len(x) > 0 : print x 与 search() 函数不同, 我在正表式中添加括号来表示浮点数, 指明我只需要 findall() 函数找出匹配到的字符串的浮点数程序行果如下 : ['0.8475'] ['0.0000'] ['0.6178'] ['0.0000'] ['0.6961'] ['0.0000'] 数字仍然是存在列表中, 需要把字符串浮点数里重展示正表式可以同行搜索与抽取的功能如果文件包含如下形式的文本行, 使用种方法的一个例子如下 : Details: http://source.sakaiproject.org/viewsvn/?view=rev&rev=39772 如果想要抽取所有的修号 ( 每一行末尾的整数 ), 程序代如下 : import re hand = open('mbox-short.txt') for line in hand: line = line.rstrip() x = re.findall('^details:.*rev=([0-9]+)', line) if len(x) > 0: print x 解一下个正表式, 以 Details: 开, 之后是任意字符.*, 然后是 rev=, 最后是零或多个数字我只需要文本行最后的整数, 所以用括号把 [0-9]+ 括起来程序行果如下 : ['39772'] ['39771'] ['39770'] ['39769']... 住, [0-9]+ 是婪的, 在抽取些数字之前, 它匹配尽可能多的符合条件的字符串个婪行是得 5 位数字的原因所在正表式行了前后展, 直到它在开或尾遇到一个非数字才停止匹配正表式 103

在, 我可以使用正表式重做之前的件消息中的提取文本内容如下 : From stephen.marquard@uct.ac.za Sat Jan 5 09:14:16 2008 此抽取每一行中当天的小之前的做法是用 split 次第一次, 文本行分解, 取出第五个, 将其再次用冒号分解最后, 取出我需要的前个字符然做到了目, 但在代写缺乏一定灵活性, 前提是文本需要良好的格式化如果增加足的或一大的 try/except 代, 确保程序在遇到格式不正确的文本行不会出, 代会增到 10-15 行, 那就不太好了使用下面的正表式可以更容易地做到一点 : ^From.* [0-9][0-9]: 解一下个正表式, 以 From 开 ( 注意空格 ), 之后是任意多个字符.*, 然后空一格, 接着是 2 位数字 [0-9][0-9], 最后是一个冒号的定符合之前想要找的内容了只取出小数, 使用 findall() 方法, 在位数字上加括号, 正表式如下 : ^From.* ([0-9][0-9]): 程序代如下 : import re hand = open('mbox-short.txt') for line in hand: line = line.rstrip() x = re.findall('^from.* ([0-9][0-9]):', line) if len(x) > 0 : print x 程序行果如下 : ['09'] ['18'] ['16'] ['15']... 11.4 字符由于在正表式中使用特殊字符来匹配一行的开与尾, 或指定通配符, 那么需要一种方法来保些特殊字符本身的指代性, 例如匹配 $ 与 ^ 符号本身通在字符前使用反斜杠作前可以松解决个例如, 使用以下正表式找出金数 import re x = 'We just received $10.00 for cookies.' y = re.findall('\$[0-9.]+',x) 由于 $ 符号之前有一个反斜杠, 它上匹配的是美元符号本身, 不是匹配一行的尾, 正表式的其他部分匹配一个或多个数字和句点注意, 方括号内, 字符没有特殊性因此,[0-9.] 表示数字和句点方括号之外, 句点是一个通配符, 正表式 104

匹配任意字符在方括号之内, 句点就代表它本身 11.5 小然本章只触及了正表式的皮毛, 但我已正表式言有所了解包含特殊字符的搜索字符串能按照意愿, 建正表式来定匹配的字符和想要抽取的内容以下是一些特殊字符和字符序列 : ^ 匹配文本行的开 $ 匹配文本行的尾. 匹配任一字符 ( 一个通配符 ) \s 匹配一个空白字符 \S 匹配一个非空字符 ( 与 \s 相反 ) * 用于前接字符, 表示前接字符的零个或多个匹配 *? 用于前接字符, 以非婪模式, 表示前接字符的零个或多个匹配 + 用于前接字符, 表示前接字符的一个或多个匹配 +? 用于前接字符, 以非婪模式, 表示前接字符的一个或多个匹配 [aeiou] 匹配指定字符集中的一个字符里只能是 a e i o 或 u, 不接受其他字符 [a-z0-9] 使用号指定字符区里表示一个字符, 必是小写字母或数字 [^A-Za-z] 第一个字符是 ^, 它表示反向里匹配除了大小写字符之外的其他任意字符 ( ) 在正表式中添加括号, 括号内容会失匹配功能, 但在 findall() 中可以用于抽取特定部分的字符串, 而不是整个字符串 \b 匹配空字符串, 用于的首尾 \B 匹配空字符串, 但不能用于的首尾 \d 匹配任意十制数字, 等价于 [0-9] \D 匹配任意非数字字符, 等价于 0-9 11.6 Unix 用福利自 20 世 60 年以后,Unix 操作系内置了文件搜索的正表式功能它几乎在所有程言中通用, 只是上有所差事上,Unix 内置了一个命令行工具, 称 grep(generalized Regular Expression Parser, 通用正表式解析器 ), 可以本章 search() 在示例中的相同作用如果使用 Mac 或 Linux 操作系, 你可以在命令行窗口中行以下句 $ grep '^From:' mbox-short.txt From: stephen.marquard@uct.ac.za From: louis@media.berkeley.edu From: zqian@umich.edu From: rjlowe@iupui.edu 正表式 105

![Alt text](./1434462994117.png) 条命令告 grep, 示 mbox-short.txt 文件中以 From: 开的字符串如果使用 grep 命令和 grep 的文档, 你会 Python 支持的正表式与 grep 支持的正表式存在一些微差例如,grep 不支持非空字符 \S, 所以需要使用稍微复一点的集合符号 [^ ], 表示匹配非空格的任意字符 11.7 Python 包含一些明了的内置文档, 有助于快速掌握和特定方法的确确切名称些文档可以在 Python 解析器的交互模式下看 >>> help() Welcome to Python 2.6! This is the online help utility. If this is your first time using Python, you should definitely check out the tutorial on the Internet at http://docs.python.org/tutorial/. Enter the name of any module, keyword, or topic to get help on writing Python programs and using Python modules. To quit this help utility and return to the interpreter, just type "quit". To get a list of available modules, keywords, or topics, type "modules", "keywords", or "topics". Each module also comes with a one-line summary of what it does; to list the modules whose summaries contain a given word such as "spam", type "modules spam". help> modules 如果你知道需要使用的模名称, 使用 dir() 命令找个模的方法, 如下所示 : >>> import re >>> dir(re) [.. 'compile', 'copy_reg', 'error', 'escape', 'findall', 'finditer', 'match', 'purge', 'search', 'split', 'sre_compile', 'sre_parse', 'sub', 'subn', 'sys', 'template'] 你也可以使用 dir 命令来找特定方法的一小部分文档 >>> help (re.search) Help on function search in module re: search(pattern, string, flags=0) Scan through string looking for a match to the pattern, returning a match object, or None if no match was found. >>> 然内置的文档不尽, 但在急需或没有网器和搜索引擎的情况下用 11.8 脆弱代 : 当入数据是一种特定格式, 如果格式上有一点偏差, 代很容易出由于容易出, 种代被称脆弱代婪匹配 : 正表式中 + 和 * 采用外向展, 匹配最大可能的字符串正表式 106

grep: 在大多数 Unix 操作系中可以使用的命令, 搜索文本文件, 通正表式一行行行匹配命令的全称是通用正表式解析器 (Generalized Regular Expression Parser) 正表式 : 表复搜索字符串的言正表式可能包含特定字符串, 指明搜索只匹配开或尾, 以及其他多似的功能通配符 : 匹配任意字符的特殊字符例如, 在正表式中, 句点是一个通配符 11.9 11.1 写一段程序, 模 Unix 中 grep 命令的操作要求用入一个正表式, 出正表式匹配的文本行数 $ python grep.py Enter a regular expression: ^Author mbox.txt had 1798 lines that matched ^Author $ python grep.py Enter a regular expression: ^Xmbox.txt had 14368 lines that matched ^X- $ python grep.py Enter a regular expression: java$ mbox.txt had 4218 lines that matched java$ 11.2 写一个程序, 找以下形式的文本行使用正表式的 findall() 函数抽取每一行中的数字, 算并出数字的平均 Enter file:mbox.txt 38549.7949721 Enter file:mbox-short.txt 39756.9259259 正表式 107

第 12 章网程然中多示例重于取文件和索文件中的数据, 而如今的互网上有丰富的信息来源, 得考在内在本章中, 我装成一个网器, 使用超文本 (HyperText Transport Protocol, HTTP) 索网, 取面数据并行解析 12.1 超文本 HTTP 网了整个网, 其本身非常由于 Python 内置了 sockets, 在 Python 程序中建立网接, 通些套接字索数据, 得非常容易套接字很像文件不同的是它提供了个程序之的双向接, 在一个套接字上可以同取和写入如果你在套接字的一端写内容, 套接字会把数据送一端的用程序如果从套接字取, 将得到一个程序送的数据然而, 当套接字一端没有送任何数据, 如果你取套接字, 果就只能等待如果套接字端的程序都在等待数据, 而不送任何数据, 它就会僵持下去程序的一个重要成部分是与互网的通, 即具某种是一精确的集合, 决定了先后, 做些什么, 消息如何, 以及下一步来送等从某种意上, 套接字端的个程序像是在跳舞, 确保不会到方的脚趾已有大量文档介网超文本原文如下 : http://www.w3.org/protocols/rfc2616/rfc2616.txt 个文档包含 179, 内容复尽如果你感趣, 完它如果是翻看 RFC2616 的第 36 左右, 你会找到 GET 求的法如果仔, 你会是从网服器求文档, 与 http://www.py4inf.com 服器的 80 端口建立接, 然后送表的一行 GET http://www.py4inf.com/code/romeo.txt HTTP/1.0 第二个参数是我求的网, 随后我送一个空白行网服器将文档的一些部信息和文档内容之后的空白行 12.2 世界上最的网器解 HTTP 工作原理的最方法, 也就是写一段非常的 Python 程序与网服器建立接, 遵循 HTTP, 向服器求文档并示出来 import socket mysock = socket.socket(socket.af_inet, socket.sock_stream) mysock.connect(('www.py4inf.com', 80)) mysock.send('get http://www.py4inf.com/code/romeo.txt HTTP/1.0\n\n') while True: data = mysock.recv(512) if ( len(data) < 1 ) : break print data mysock.close() 网程 108

首先, 程序与服器 http://www.py4inf.com 在 80 端口建立一个接, 个程序扮演了网器的角色 HTTP 要求, 必送 GET 命令, 并在后面跟一个空白行送空白行之后, 我写一个循, 从套接字中接收 512 个字符的数据片段, 并打印出些数据, 直到没有数据可以入, 即 recv() 返回一个空字符串程序行果如下 : HTTP/1.1 200 OK Date: Sun, 14 Mar 2010 23:52:41 GMT Server: Apache Last-Modified: Tue, 29 Dec 2009 01:31:22 GMT ETag: "143c1b33-a7-4b395bea" Accept-Ranges: bytes Content-Length: 167 Connection: close Content-Type: text/plain But soft what light through yonder window breaks It is the east and Juliet is the sun Arise fair sun and kill the envious moon Who is already sick and pale with grief 程序一开始出的是网服器送的文档描述的部信息例如,Content-Type 部指明文档是一个普通文本文档 (text/plain) 服器送了部信息之后, 添加一个空白行表示部信息送完, 然后送的 romeo.txt 文件数据示例展示了如何通套接字建立低的网接套接字用于网服器件服器以及其他多型服器的通找到描述的文档, 写代, 根据送和取数据, 要做的就么多了由于最常用的是 HTTP( 即 Web),Python HTTP 了的来支持网文档数据的取 12.3 通 HTTP 索像在以上示例中, 我取了一个包含行符的普通文本文件, 程序行地拷数据并示出来接下来, 我使用 HTTP 写一个似的程序, 用来索片在一个字符串中累数据, 截取部信息, 然后将片数据保存到一个文件中, 程序代如下 : import socket import time mysock = socket.socket(socket.af_inet, socket.sock_stream) mysock.connect(('www.py4inf.com', 80)) mysock.send('get http://www.py4inf.com/cover.jpg HTTP/1.0\n\n') count = 0 网程 109

picture = ""; while True: data = mysock.recv(5120) if ( len(data) < 1 ) : break # time.sleep(0.25) count = count + len(data) print len(data),count picture = picture + data mysock.close() # Look for the end of the header (2 CRLF) pos = picture.find("\r\n\r\n"); print 'Header length',pos print picture[:pos] # Skip past the header and save the picture data picture = picture[pos+4:] fhand = open("stuff.jpg","wb") fhand.write(picture); fhand.close() 程序行果如下 : $ python urljpeg.py 2920 2920 1460 4380 1460 5840 1460 7300... 1460 62780 1460 64240 2920 67160 1460 68620 1681 70301 Header length 240 HTTP/1.1 200 OK Date: Sat, 02 Nov 2013 02:15:07 GMT Server: Apache Last-Modified: Sat, 02 Nov 2013 02:01:26 GMT ETag: "19c141-111a9-4ea280f8354b8" Accept-Ranges: bytes Content-Length: 70057 Connection: close Content-Type: image/jpeg 个 url,content-type 部指明文档本身是一个像 (img/jpeg) 程序行完之后, 使用像器打开 stuff.jpg 文件看像数据程序行中用了 recv() 函数, 每次不会得到 5120 个字符用 recv(), 通网, 我从网服器得更多字符串在个示例中, 每一次得 1460 或 2920 个字符, 求上限是 5120 个字符网速不同会致不同的果要注意的是, 最后一次用 recv(), 在数据流束得到 1681 个字, 再下一个 recv() 用得零度的字符串就是告我, 服器已在套接字末尾用了 close(), 没有更多数据可送了把 time.sleep() 前面的注去掉, 可以随后的用一来, 每次相隔 1/4 秒, 服器我靠前, 送更多的数据程序的延隔行如下所示 : $ python urljpeg.py 1460 1460 5120 6580 5120 11700... 5120 62900 5120 68020 2281 70301 Header length 240 网程 110

HTTP/1.1 200 OK Date: Sat, 02 Nov 2013 02:22:04 GMT Server: Apache Last-Modified: Sat, 02 Nov 2013 02:01:26 GMT ETag: "19c141-111a9-4ea280f8354b8" Accept-Ranges: bytes Content-Length: 70057 Connection: close Content-Type: image/jpeg 次行中除了第一次和最后一次 recv() 用, 每次求新数据都会得到 5120 个字符服器生成的 send() 求与程序生成的 recv() 求之存在一个冲区当程序行延求, 在某些点上, 服器可能会在套接字中填冲区, 并强制停, 直到程序开始清空存区送用或接收用的停行被称流量控制 12.4 使用 urllib 索网与通 HTTP 套接字手送与取数据相比,Python 中有一种更的解决方法, 使用 urllib 使用 urllib, 你可以将网看成一个文件只需指明需要索的网,urllib 会理所有 HTPP 和部使用 urllib 取 romeo.txt 文件的代如下 : import urllib fhand = urllib.urlopen('http://www.py4inf.com/code/romeo.txt') for line in fhand: print line.strip() 网通 urllib.urlopen 打开后, 我就可以把它当成一个文件, 使用 for 循来取程序行, 我看到文件内容的出然部信息仍然会送, 但是 urllib 代会理部, 送我的是文件内容 But soft what light through yonder window breaks It is the east and Juliet is the sun Arise fair sun and kill the envious moon Who is already sick and pale with grief 了演示明, 我写一个程序来取 romeo.txt 的数据, 算文件中每个的率, 代如下所示 : import urllib counts = dict() fhand = urllib.urlopen('http://www.py4inf.com/code/romeo.txt') for line in fhand: words = line.split() for word in words: counts[word] = counts.get(word,0) + 1 print counts 同地, 一旦打开了网, 我就可以把它当做一个本地文件行取 12.5 解析 HTML 和 Web 抓取 Python 的 urllib 常用法之一是网抓取网抓取是写一个程序, 装成网器, 索网, 然后在些面中根据网程 111

模式数据例来, 搜索引擎 ( 如 Google) 会看网的源代, 抽取接到其他面的超接, 然后索些面, 抽取超接, 如此往复下去使用种技,Google 爬虫几乎遍了网上的所有面 Google 使用面接的次来明一个具体面的重要性, 在搜索果中表明面排位的高低 12.6 使用正表式解析 HTML HTML 解析的一个方法是使用正表式行重复搜索, 根据特定模式, 抽取出与之匹配的子字符串以下是一个的网 : <h1>the First Page</h1> <p> If you like, you can switch to the <a href="http://www.dr-chuck.com/page2.htm"> Second Page</a>. </p> 我造一个符合法的正表式, 匹配和抽取以上网文本中的超接, 正表式如下所示 : href="http://.+?" 个正表式找以 ref="http:// 开的字符串, 之后是一个或多个字符.+?, 最后是一个双引号.+? 表示以非婪方式行匹配, 而不是婪方式非婪匹配找到最小可能匹配的字符串, 婪匹配找到最大可能匹配的字符串正表式中的括号表示, 我需要精确匹配的字符串, 程序代如下 : import urllib import re url = raw_input('enter - ') html = urllib.urlopen(url).read() links = re.findall('href="(http://.*?)"', html) for link in links: print link 正表式的 findall 方法返回正表式匹配到的字符串列表, 返回双引号之的超接文本程序行果如下 : python urlregex.py Enter - http://www.dr-chuck.com/page1.htm http://www.dr-chuck.com/page2.htm python urlregex.py Enter - http://www.py4inf.com/book.htm http://www.greenteapress.com/thinkpython/thinkpython.html http://allendowney.com/ http://www.py4inf.com/code http://www.lib.umich.edu/espresso-book-machine http://www.py4inf.com/py4inf-slides.zip 如果 HTML 网是良的和可的, 正表式会理地很漂亮但是, 由于存在大量破坏性的 HTML 网, 你可能会, 使用正表式的解决方案可能会一些有效接或中止于坏数据强大的 HTML 解析可以解决个网程 112

12.7 使用 BeautifulSoup 解析 HTML 已有多 Python 可以帮助你解析 HTML 与抽取面中的数据每个 Python 都有缺点, 根据需要行例来看, 我使用 BeautifulSoup 来解析一些 HTML 入和抽取接从 http://www.crummy.com 网站下和安装 BeautifulSoup 代你可以下和安装 BeautifulSoup, 或地将 BeautifulSoup.py 放在你的程序文件下 HTML 与 XML 看起来很像, 有一些网被精心造 XML 一般而言, 大多数 HTML 会被 XML 解析器是格式不正确而整体拒, 致解析失 BeautifulSoup 极大容忍了 HTML 的缺陷, 依然你能易抽取所需的数据我使用 urllib 取面, 然后根据抽取 href 属性的内容 import urllib from BeautifulSoup import * url = raw_input('enter - ') html = urllib.urlopen(url).read() soup = BeautifulSoup(html) # Retrieve all of the anchor tags tags = soup('a') for tag in tags: print tag.get('href', None) 程序提示入一个网址, 然后打开网, 取与数据到 BeautifulSoup 解析器, 接下来, 索所有的, 打印出每个的 href 属性内容 python urllinks.py Enter - http://www.dr-chuck.com/page1.htm http://www.dr-chuck.com/page2.htm python urllinks.py Enter - http://www.py4inf.com/book.htm http://www.greenteapress.com/thinkpython/thinkpython.html http://allendowney.com/ http://www.si502.com/ http://www.lib.umich.edu/espresso-book-machine http://www.py4inf.com/code http://www.pythonlearn.com/ 使用 BeautifulSoup 取出每个的不同部分, 代如下 : import urllib from BeautifulSoup import * url = raw_input('enter - ') html = urllib.urlopen(url).read() soup = BeautifulSoup(html) # Retrieve all of the anchor tags tags = soup('a') for tag in tags: # Look at the parts of a tag print 'TAG:',tag print 'URL:',tag.get('href', None) print 'Content:',tag.contents[0] print 'Attrs:',tag.attrs 程序行果如下 : 网程 113

python urllink2.py Enter - http://www.dr-chuck.com/page1.htm TAG: <a href="http://www.dr-chuck.com/page2.htm"> Second Page</a> URL: http://www.dr-chuck.com/page2.htm Content: [u'\nsecond Page'] Attrs: [(u'href', u'http://www.dr-chuck.com/page2.htm')] 些例子揭开了 BeautifulSoup 解析 HTML 功能的冰山一角更多内容 http://www.crummy.com 文档与示例 12.8 使用 urllib 取二制文件有, 你需要索非文本 ( 二制 ) 文件, 如像或文件些文件的数据直接打印出是没有用的, 但可以通 urllib 将 URL 指向的文件保存在本地硬模式打开 URL, 使用 read 方法下整个文档内容, 将其存入一个字符串量 ( 如 img), 然后将量内容写入本地文件程序代如下 : img = urllib.urlopen('http://www.py4inf.com/cover.jpg').read() fhand = open('cover.jpg', 'w') fhand.write(img) fhand.close() 程序通网取所有数据, 将它存在算机内存的 img 量中, 然后打开文件 cover.jpg, 将数据写入到硬中如果文件大小小于算机内存容量, 个程序将会成功行然而, 如果是一个大型音或文件, 当算机耗尽内存, 个程序可能会崩或行极慢了避免耗尽内存, 我以区 ( 或冲区 ) 索数据, 在索下一个区前将当前区写入磁一来, 程序就可以取任意大小的文件, 无需担心耗尽算机的全部内存 import urllib img = urllib.urlopen('http://www.py4inf.com/cover.jpg') fhand = open('cover.jpg', 'w') size = 0 while True: info = img.read(100000) if len(info) < 1 : break size = size + len(info) fhand.write(info) print size,'characters copied.' fhand.close() 在个示例中, 每次取 100,000 个字符, 从网索下一批 100,000 个字符数据之前, 先将些字符写入 cover.jpg 文件程序行果如下 : python curl2.py 568248 characters copied. 如果是 Unix 或 Mac 算机, 你可以使用操作系内置命令来行个操作 : curl -O http://www.py4inf.com/cover.jpg 网程 114

curl 命令是 copy URL 的写, 个例子文件命名 curl1.py 和 curl2.py, 可以从 http://www.py4inf.com/code 下它了 culr 命令相似的功能 curl3.py 示例程序以更高效的方式完成二制文件的写, 种模式可能你自己写程序有所帮助 12.9 BeautifulSoup: 一个用于 HTML 文档解析与数据抽取的 Python 它能理大多数在器中通常被忽略的, 存在缺陷的 HTML BeautifulSoup 代 http:// 从 www.crummy.com 网站下端口 : 当与服器建立套接字接, 服器告用程序行通所采用的数字例如, 网流量通常使用 80 端口, 子件流量使用 25 端口抓取 : 把程序装成网器, 索网, 找网中的内容通常, 程序会根据一个网中的接找到下一个网, 网网或社交网的遍套接字 : 个用程序之的网接, 彼此可以送与接收数据爬虫 : 网搜索引擎的索面, 然后从面所有接再次起索, 如此往复下去, 直到它索到网上的几乎所有面些面将用于建索引, 供搜索之用 12.10 12.1 修改套接字程序 socket1.py, 提示用入 URL, 它可以取任何网你可以使用 split( / ) 拆分 URL, 抽取出套接字 connect 用的主机名使用 try 和 except 增加, 理用入不恰当的网址或不存在的 URL 种情况 12.2 修改套接字程序, 接收到的字符数与 3000 个字符之后未示的文本程序索整个文档, 字符数并示在文档尾 12.3 使用 urllib 重复之前的 :(1) 从 URL 中索文档 ;(2) 示 3000 个字符 ;(3) 文档的字符数里不必担心部信息, 只示文档内容中前 3000 个字符即可 12.4 修改 ulrlinks.py 程序, 索到的 HTML 文档抽取和段落 (p), 在程序出中示段落数量不要示段落文本, 段落数在网和复网上程序 12.5 ( ) 修改 socket 程序, 使其只示部和空行之后的索数据住,recv 是按照字符 ( 包括行及所有 ) 而非行来接收的网程 115

第 13 章 Web Services 掌握了通 HTTP 写文档索与解析程序之后, 接下来我自己建的文档, 开一种其他用程序可用的文档服, 就不是一件很苦的事情了里的文档不是示在网器中的 HTML 网网数据交包括种常格式 : 可展言 XML(eXtensible Markup Language) 和 JSON(JavaScript Object Notation) XML 已使用很, 适合于交文档型的数据当程序彼此之只需要交字典列表或其他内部信息, 一般会使用 JSON 接下来分介种格式 13.1 可展言 XML XML 与 HTML 看起非常像, 但 XML 比 HTML 的化程度更高下面是一个 XML 文档示例 : <person> <name>chuck</name> <phone type="intl"> +1 734 303 4456 </phone> <email hide="yes"/> </person> 通常可以把 XML 文档想象成一个, 有助于理解示例中是 person, 其他是它的子点, 如 phone 13.2 XML 解析下面是一个的示例程序, XML 文件行解析, 从中提取一些数据元素 : import xml.etree.elementtree as ET data = "' <person> <name>chuck</name> <phone type="intl"> +1 734 303 4456 </phone> <email hide="yes"/> </person>"' tree = ET.fromstring(data) print 'Name:',tree.find('name').text print 'Attr:',tree.find('email').get('hide') 用 fromstring 将 XML 的字符串表示一 XML 点当 XML 被一, 我就有一系列方法来抽取 XML 中的数据片段 Web Services 116

使用 find 函数 XML 行搜索, 索出匹配特定的点每个点包含一些文本, 一些属性 ( 例如藏的 ) 以及一些子点每个点都可以成点的点 Name: Chuck Attr: yes XML 解析器, 例如 ElementTree, 可以理多 XML 有效性, 我无需操心 XML 法就可以抽取需要的 XML 数据片段由于示例的 XML 于, 体不出一 13.3 点循通常,XML 会有多个点, 我需要写一个循来理所有点下面的程序使用循找出 user 点 : import xml.etree.elementtree as ET input = "' <stuff> <users> <user x="2"> <id>001</id> <name>chuck</name> </user> <user x="7"> <id>009</id> <name>brent</name> </user> </users> </stuff>"' stuff = ET.fromstring(input) lst = stuff.findall('users/user') print 'User count:', len(lst) for item in lst: print 'Name', item.find('name').text print 'Id', item.find('id').text print 'Attribute', item.get('x') 使用 Python 列表来表示 XML 中 user 的子, findall 方法索个列表然后, 写一个循, 索出每一个 user 点, 打印出 name 和 id 的文本元素, 以及 user 点的 x 属性 User count: 2 Name Chuck Id 001 Attribute 2 Name Brent Id 009 Attribute 7 13.4 JavaScript 象 - JSON JSON 格式的灵感来自于 JavaScript 言的象与数格式 Python 的出早于 JavaScript,Python 的字典与列表法 JSON 言有一定影所以,JSON 格式可 Python 列表与字典的合上面的 XML 示例使用 JSON 格式来表示, 如下代所示, 者大致等价 : { "name" : "Chuck", Web Services 117

"phone" : { "type" : "intl", "number" : "+1 734 303 4456" }, "email" : { "hide" : "yes" } } 你会注意到一些差异首先,XML 中 phone 有一个 intl 属性, 在 JSON 里理成外,XML 的 person 没有了, 取而代之的是一大括号由于 JSON 比 XML 功能少, 所以 JSON 的比 XML 但是,JSON 的在于, 它直接映射成字典与列表的合几乎所有程言与 Python 的字典和列表都存在某种程度上的等价关系, 所以 JSON 是个作用程序之非常合适的数据交格式与 XML 相比,JSON 相, 正迅速成用程序之数据交格式的不二 13.5 JSON 解析通字典 ( 象 ) 与列表的嵌套来造我需要的 JSON 个示例中用的列表由集合成 ( 也就是一个字典 ) 因此, 我有了一个字典列表在下面的程序中, 我使用内置的 json 来解析 JSON, 取其中的数据仔比等价的 XML 数据和上面的代, 有一点必提前知,JSON 的少我最得到的列表包含用信息, 每个用的信息是集合 JSON 的点是格式, 缺点是自描述能力不强 import json input = "' [ { "id" : "001", "x" : "2", "name" : "Chuck" }, { "id" : "009", "x" : "7", "name" : "Brent" } ]"' info = json.loads(input) print 'User count:', len(info) for item in info: print 'Name', item['name'] print 'Id', item['id'] print 'Attribute', item['x'] 从解析后的 JSON 与 XML 分抽取数据的段代行比, 你会 json.loads() 得到一个 Python 列表, 通 for 循行遍, 列表的每个数据是一个 Python 字典, 其中使用了 Python 索引操作符来抽取每个用的各个字 JSON 解析后, 我就得到了原生的 Python 象与由于返回的数据就是的原生 Python, 就没必要使用 JSON 深入解析 JSON 了程序行果如下, 与上面的 XML 版本几乎相同 User count: 2 Name Chuck Id 001 Attribute 2 Name Brent Web Services 118

Id 009 Attribute 7 之,Web Service 的行展是从 XML 向 JSON 由于 JSON 足, 能直接映射到程言已有的原生数据,JSON 的使用解析与数据抽取得更但是,XML 比 JSON 在自我描述方面更强, 因此在某些用程序中 XML 仍然有一定例如, 大多数文字理器内部存文档采用 XML 而不是 JSON 13.6 用程接口 API 我已学了通超文本 HTTP 在用程序之交数据, 了解了使用 XML 与 JSON 在些用程序之送与接收复数据的表示方法下一步是使用些技在用程序之定与合同用程序之合同的一般名称是用程序接口或 APIs 当我使用一个 API, 用程序通常会提供一可供其他用程序使用的服用程序布的 APIs( 即 ) 在服必遵守当我开始建自己的用程序, 功能上要能其他用程序提供的服, 种方式称面向服的架 SOA(Service- Oriented Architecture) SOA 方式是用程序使用其他用程序服的称非 SOA 方式是用程序作一独立的程序, 自身包含程序行中所需的所有代互网用中存在多 SOA 例我可以在一个网站上完成旅行机票与酒店定以及租等一系列活酒店数据没有存在航空公司的算机上相反, 航空公司的算机与酒店的算机服合同, 索酒店数据, 并呈用当用使用航空公司的网站了一家酒店, 航空公司的网站使用酒店系的 Web Service 来完成当涉及整个交易的信用卡支付, 仍然会有其他算机参与到个程面向服的架有多点, 其中包括 :(1) 数据始只存在一, 酒店情况来特重要, 我不希望出多次提交 ;(2) 数据的有者能置数据的使用基于些点,SOA 系必精心, 以到具良好的性能与足用的需求用程序通网布一可用的 API 服, 我称之 Web Services 13.7 Google 地理 Web Service Google 的 Web Service 非常秀, 我能充分利用其大的地理信息数据我可以向 Google 的地理 API 提交如 Ann Arbor, MI 的地理搜索字符串 Google 会根据搜索字符串返回最佳猜, 在地上告我想找的地方以及附近的地性建筑地理服是免的, 但有次数限制, 不能在商用程序中无限制使用如果有一些数据, 其中被者在自 Web Services 119

由格式的入框中入了一个地址, 你就可以使用个 API 清洗些数据, 效果会很不当使用似 Google 地理 API 的免 API, 你需要遵守些源的使用定如果有太多用用 API,Google 会关或大幅度免服通服的在文档了解使用方法不, 个操作非常, 可以直接在器中, 在地址入如下 URL: http://maps.googleapis.com/maps/api/geocode/json?sensor=false &address=ann+arbor%2c+mi 粘到器之前, 确保是原始的 URL, 移除 URL 中的任何空格下面是一个用程序, 提示用入一个搜索字符串, 用 Google 的地理 API, 从返回的 JSON 中抽取信息 import urllib import json serviceurl = 'http://maps.googleapis.com/maps/api/geocode/json?' while True: address = raw_input('enter location: ') if len(address) < 1 : break url = serviceurl + urllib.urlencode({'sensor':'false', 'address': address}) print 'Retrieving', url uh = urllib.urlopen(url) data = uh.read() print 'Retrieved',len(data),'characters' try: js = json.loads(str(data)) except: js = None if 'status' not in js or js['status']!= 'OK': print '==== Failure To Retrieve ====' print data continue print json.dumps(js, indent=4) lat = js["results"][0]["geometry"]["location"]["lat"] lng = js["results"][0]["geometry"]["location"]["lng"] print 'lat',lat,'lng',lng location = js['results'][0]['formatted_address'] print location 程序取入的搜索字符串, 将其作合适的参数, 建 URL, 使用 urllib 从 Google 地理 API 索文本内容与固定的网不同, 里得到的数据取决于送的参数与 Google 服器中存的地理数据一旦取到 JSON 数据, 我使用 json 其行解析, 做一些以确保收到良好的数据, 然后抽取我需要的数据程序行果如下 ( 下面只展示了返回的部分 JSON 数据 ): $ python geojson.py Enter location: Ann Arbor, MI Retrieving http://maps.googleapis.com/maps/api/ geocode/json?sensor=false&address=ann+arbor%2c+mi Retrieved 1669 characters { "status": "OK", "results": [ { "geometry": { "location_type": "APPROXIMATE", "location": { Web Services 120

"lat": 42.2808256, "lng": -83.7430378 } }, "address_components": [ { "long_name": "Ann Arbor", "types": [ "locality", "political" ], "short_name": "Ann Arbor" } ], "formatted_address": "Ann Arbor, MI, USA", "types": [ "locality", "political" ] } ] } lat 42.2808256 lng -83.7430378 Ann Arbor, MI, USA Enter location: 你可以下 http://www.py4inf.com/code/geojson.py 和 http://www.py4inf.com/code/geoxml.py 个文件, 搞清楚 Google 地理 API 的 JSON 与 XML 之的差 13.8 安全与 API 用法通常情况下, 你需要某种型的 API 密才能服提供者的 API 的初衷是服提供者想要知道在使用他的服, 以及每个用的使用情况可能他提供免服, 但会根据服次收, 或者在特定段限制个体用的求数量在一些情况中, 你一旦得到 API 密, 在用 API 只需将密作 POST 数据的一部分, 或者作 URL 的一个参数在一些情况中, 服提供者了增加求来源的保性, 他希望你使用共享密与密方式送加密的名信息互网中名求普遍采用 OAuth 技有关 OAuth http://www.oauth.net 随着 Twitter API 越来越有价,Twitter 从免公开的 API 向每个 API 求需要 OAuth 名得幸的是, 多方便的 OAuth 可以免使用你可以不必技范和从零写 OAuth 的程些的复性与丰富程度不一 OAuth 网站提供各种 OAuth 信息下面一段示例程序需要从 http://www.py4inf.com/code 下三个文件 twurl.py hidden.py oauth.py 和 twitter1.py, 把它放在一个文件下了能使用些程序, 需要一个 Twitter 号, 你的 Python 代作 Twitter 的一个用得以授, 建 key secret token 与 token secret 通修改 hidden.py, 将四个字符串予文件中合适的量 def auth() : return { "consumer_key" : "h7l...gng", "consumer_secret" : "dnk...7q", "token_key" : "101...GI", "token_secret" : "H0yM...Bo" } Twitter 的 Web Service 通 URL, 如下所示 : https://api.twitter.com/1.1/statuses/user_timeline.json 所有的安全信息添加完之后, 完整的 URL 如下 : Web Services 121

https://api.twitter.com/1.1/statuses/user_timeline.json?count=2 &oauth_version=1.0&oauth_token=101...sgi&screen_name=drchuck &oauth_nonce=09239679&oauth_timestamp=1380395644 &oauth_signature=rlk...bod&oauth_consumer_key=h7lu...gng &oauth_signature_method=hmac-sha1 如果想了解 OAuth 安全需求的各种参数含, OAuth 技范个程序 Twitter, 藏了文件 oauth.py 与 twurl.py 中所有复我只需置 hidden.py 中的加密信息, 然后把求的 URL 送 twurl.augment() 函数, 代会帮我添加 URL 需要的所有参数程序 (twitter1.py) 索了特定 Twitter 用的, 以 JSON 格式返回一个字符串我打印出字符串前 250 个字符 import urllib import twurl TWITTER_URL='https://api.twitter.com/1.1/statuses/user_timeline.json' while True: print " acct = raw_input('enter Twitter Account:') if ( len(acct) < 1 ) : break url = twurl.augment(twitter_url, {'screen_name': acct, 'count': '2'} ) print 'Retrieving', url connection = urllib.urlopen(url) data = connection.read() print data[:250] headers = connection.info().dict # print headers print 'Remaining', headers['x-rate-limit-remaining'] 程序行果如下 : Enter Twitter Account:drchuck Retrieving https://api.twitter.com/1.1/... [{"created_at":"sat Sep 28 17:30:25 +0000 2013"," id":384007200990982144,"id_str":"384007200990982144", "text":"rt @fixpert: See how the Dutch handle traffic intersections: http:\/\/t.co\/tiivwtehj4\n#brilliant", "source":"web","truncated":false,"in_rep Remaining 178 Enter Twitter Account:fixpert Retrieving https://api.twitter.com/1.1/... [{"created_at":"sat Sep 28 18:03:56 +0000 2013", "id":384015634108919808,"id_str":"384015634108919808", "text":"3 months after my freak bocce ball accident, my wedding ring fits again! :)\n\nhttps:\/\/t.co\/2xmhpx7kgx", "source":"web","truncated":false, Remaining 177 Enter Twitter Account: Twitter 返回数据的同, 返回了 HTTP 部中求的元数据特殊的部 x-rate-limit-remaining 表明, 在短切断之前我能起的求数量, 就可以知道每次 API 求中剩余的索次数在下面例子中, 我索一个用的 Twitter 朋友, 解析返回的 JSON, 抽取朋友信息在解析和 4 格的工整打印之后出 JSON 文件当需要抽取更多字段, 出的数据可供我解 import urllib import twurl import json Web Services 122

TWITTER_URL = 'https://api.twitter.com/1.1/friends/list.json' while True: print " acct = raw_input('enter Twitter Account:') if ( len(acct) < 1 ) : break url = twurl.augment(twitter_url, {'screen_name': acct, 'count': '5'} ) print 'Retrieving', url connection = urllib.urlopen(url) data = connection.read() headers = connection.info().dict print 'Remaining', headers['x-rate-limit-remaining'] js = json.loads(data) print json.dumps(js, indent=4) for u in js['users'] : print u['screen_name'] s = u['status']['text'] print ' ',s[:50] 由于 JSON 是 Python 列表与字典的嵌套集合, 我可以合使用索引操作与 for 循操作, 使用很少的 Python 代遍返回的数据程序行果如下 ( 方便面示, 一些数据被 ): Enter Twitter Account:drchuck Retrieving https://api.twitter.com/1.1/friends... Remaining 14 { "next_cursor": 1444171224491980205, "users": [ { "id": 662433, "followers_count": 28725, "status": { "text": "@jazzychad I just bought one..", "created_at": "Fri Sep 20 08:36:34 +0000 2013", "retweeted": false, }, "location": "San Francisco, California", "screen_name": "leahculver", "name": "Leah Culver", }, { "id": 40426722, "followers_count": 2635, "status": { "text": "RT @WSJ: Big employers like Google...", "created_at": "Sat Sep 28 19:36:37 +0000 2013", }, "location": "Victoria Canada", "screen_name": "_valeriei", "name": "Valerie Irvine", ], "next_cursor_str": "1444171224491980205" } leahculver @jazzychad I just bought one.. _valeriei RT @WSJ: Big employers like Google, AT&T are h ericbollens RT @lukew: sneak peek: my LONG take on the good &a halherzog Learning Objects is 10. We had a cake with the LO, scweeker @DeviceLabDC love it! Now where so I get that "etc Enter Twitter Account: Web Services 123

在出的最后, 我看到 for 循取了 Twitter 号 drchuck 的 5 位新近朋友, 打印出每位朋友的最近状返回的 JSON 中有更多数据可用此外, 如果仔看程序出, 你会, 特定号的找到他的朋友与在一个段的求数量有不同的限制些安全的 API 密 Twitter 有充分信心, 他知道在使用他的 API 以及数据使用情况限制我可以做一些的个人数据索, 但不能用于建每天有百万 API 数据的品 13.9 API: 用程序接口用程序之的合同, 定了个用件之交互的模式 ElementTree: 用于解析 XML 数据的 Python 内置 JSON:JavaScript Object Notation 基于 JavaScript 象法的化数据格式 REST: 表述性状移一种 Web Service 格, 通 HTTP 提供用程序的源 SOA: 面向服的架用程序由跨网接的件成 XML: 可展言化数据格式 13.10 13.1 修改 http://www.py4inf.com/code/geojson.py 或 http://www.py4inf.com/code/geoxml.py 文件, 从索到的数据中打印出 2 位字符的国家代添加, 确保国家代不存在的异常理当程序正常工作了, 搜索 Atlantic Ocean, 程序可以理不属于任何国家的地理位置 Web Services 124

第 14 章数据与化言 SQL 14.1 什么是数据数据是的存数据的文件从个意上, 大多数数据的方式与字典似, 数据与之的映射数据与字典的最大区在于, 数据存在磁 ( 或其他永久存器 ) 上, 程序行束后数据会永久存在正是由于数据存在永久存上, 它能存的数据多于字典字典受到算机内存大小的限制与字典似, 数据件被快速保留插入的与的数据, 即使是大量数据的情况亦如此数据件通添加的数据建索引来性能, 算机可以快速跳到特定数据广泛用的数据系包括 Oracle MySQL Microsoft SQL Server PostgreSQL 和 SQLite 本关注 SQLite, 因它是一个非常通用的数据, 而且已内建在 Python SQLite 被嵌入到其他用程序, 提供用程序内的数据支持例如,Firefox 器把 SQLite 数据作内部使用, 其他很多品也做 http://sqlite.org/ SQLite 非常适合信息科学中的一些数据理, 比如本章介的 Twitter 爬虫用 14.2 数据概念初次接触数据, 可将其多个工作表的子表格数据的主要数据包括表行与列在关系型数据中, 表行与列的定关系元与属性本章将使用非化 14.3 SQLite 管理器 (Firefox 插件 ) 本章重点使用 Python SQLite 数据文件行操作, 多操作可以用 SQLite 数据管理器 ( 一个 Firefox 插件 ) 更方便地完成免下地址如下 : https://addons.mozilla.org/en-us/firefox/addon/sqlite-manager/ 使用 Firefox 器可以在数据中松建表插入数据数据以及行的 SQL 从某种意上, 在文本文件的理方面, 数据管理器与文本器似如果要文本文件行少量修改操作, 你可以在文本器中打开它, 并根据需要修改如果要文本文件行大量修改, 通常需要写一个的 Python 程序似的, 数据同存在相同的模式在数据管理器中行一些操作, 在 Python 中可以方便地理一些复操作 14.4 建一数据的表数据与化言 SQL 125

与 Python 的列表与字典相比, 数据需要更多的定 1 建一个数据的表, 我必根据每一列存的数据情况, 先在数据中定表的每一列名称和数据型数据件知道了每一列的数据型, 根据特定数据型, 它可以最有效的数据存与索方法以下网址介了 SQLite 支持的各种数据型 : http://www.sqlite.org/datatypes.html 一开始就定好数据可能不是很方便, 但是做的好是, 当数据包含大量数据可以提供快速的数据以下代建了一个数据文件和有列的 Tracks 表 import sqlite3 conn = sqlite3.connect('music.sqlite3') cur = conn.cursor() cur.execute('drop TABLE IF EXISTS Tracks ') cur.execute('create TABLE Tracks (title TEXT, plays INTEGER)') conn.close() connect 操作建立了与当前目中 music.sqlite3 数据文件的接如果文件不存在, 建它之所以称接, 因数据有存在独的数据服器上, 与我行的用程序不在同一个服器上在个示例中, 数据作一个本地文件, 与 Python 代在同一个目下游 (cursor) 似一个文件句柄, 可以数据中的数据行操作当理文本文件,cursor() 的用与 open() 方法相似当有个游, 我使用 execute() 方法, 开始数据的内容行命令数据命令使用的言, 在多数据厂商中已准化, 用只需学一种数据言即可数据言称化言, 称 SQL http://en.wikipedia.org/wiki/sql 在个例子中, 我数据行条 SQL 命令按照例, 我用大写示 SQL 关, 其他部分如表和列名示小写如果 Track 表已存在, 第一条 SQL 命令就移除 Tracks 表一做法可以我反复行相同的程序来建 Tracks 表, 而不会致不需要注意的是,DROP TABLE 命令会除表以及数据中表的所有内容, 也就是没有撤的可能 cur.execute('drop TABLE IF EXISTS Tracks ') 第二条命令建 Tracks 表, 包括文本型的 title 列与整数型的 plays 列数据与化言 SQL 126

cur.execute('create TABLE Tracks (title TEXT, plays INTEGER)') 在, 我已建好 Tracks 表, 接下来使用 SQL 的 INSERT 操作, 向表中添加一些数据我再次与数据建立接, 得游 (cursor) 通游行 SQL 命令 SQL 的 INSERT 命令表明所使用的表, 通列字段来定新列,(title, plays) 后面跟 VALUES 具体的列, 从而生一个新行我指定 (?,?), 表示通第二个参数的一个元 ( My Way, 15) 来, 最后用 execute() 方法 import sqlite3 conn = sqlite3.connect('music.sqlite3') cur = conn.cursor() cur.execute('insert INTO Tracks (title, plays) VALUES (?,? )', ( 'Thunderstruck', 20 ) ) cur.execute('insert INTO Tracks (title, plays) VALUES (?,? )', ( 'My Way', 15 ) ) conn.commit() print 'Tracks:' cur.execute('select title, plays FROM Tracks') for row in cur : print row cur.execute('delete FROM Tracks WHERE plays < 100') conn.commit() cur.close() 首先, 我向表中插入行, 使用 commit() 提交命令将数据写入数据文件然后, 我用 SELECT 命令索插入表中的行 SELECT 命令首先指定 (title, plays) 列, 之后是数据索的来源表行 SELECT 句后, 游可以我用 for 句行循了提高效率, 当行 SELECT 句, 游并不会从数据中取所有数据相反, 数据是在 for 循按需取程序行果如下 : Tracks: (u'thunderstruck', 20) (u'my Way', 15) for 循找到行, 每一行是一个 Python 元, 其中第一个是歌曲名称 (title), 第二个是播放次数 (plays) 不用担心,title 字符串以 u 开明字符串使用 Unicode, 即能存非拉丁字符集在程序末尾, 我行 SQL 的 DELETE 命令, 除才建的行, 以便可以反复行个程序 DELETE 命令使用了 WHERE 子句, 用来表一个条件, SQL 命令在数据中只条件匹配的行行操作在本示例中, 条件用于所有行, 因此我可以清空表, 反复行程序在 DELETE 命令行后, 使用 commit() 提交命令将数据从数据中除 14.5 化言 SQL 小数据与化言 SQL 127

至此, 我在 Python 示例中使用了化言, 介了一些 SQL 命令的基本知本介 SQL 言, 要介 SQL 法然数据行中存在多数据厂商, 但化言 SQL 的准化使得不同厂商之的数据系可以行数据互通与移植关系型数据由表行与列成列的常字段型包括文本数与日期数据当建表, 需要指明列的名称与字段型 : CREATE TABLE Tracks (title TEXT, plays INTEGER) 使用 SQL 的 INSERT 命令向表中插入一行 : INSERT INTO Tracks (title, plays) VALUES ('My Way', 15) INSERT 句指定表的名称, 之后是想要插入新行的字段 ( 列 ) 的列表, 然后是 VALUES 关及其后面每个字段的列表 SQL 的 SELECT 命令从数据中索行与列 SELECT 句指定想要索的列,WHERE 子句用于出符合条件的行外, 可的 ORDER BY 子句控制返回的行的示序 SELECT * FROM Tracks WHERE title = 'My Way' * 星号表示从数据返回 WHERE 子句匹配到的行的所有列注意, 与 Python 不同的是,SQL 的 WHERE 子句使用一个等号表示相等, 而不是个等号 WHERE 子句的其他操作符包括 < > <= >= 和!=, 以及 AND OR 与括号, 些可用于写表式根据一个字段返回的行行排序的如下 : SELECT title,plays FROM Tracks ORDER BY title 要移除行, 需要在 SQL 的 DELETE 句增加一个 WHERE 子句 WHERE 子句决定些行可被除 : DELETE FROM Tracks WHERE title = 'My Way' 在一个表中可以用 SQL 的 UPDATE 句一行或多行的一个列或多列行更新 UPDATE Tracks SET plays = 16 WHERE title = 'My Way' UPDATE 句先指明待更新的表, 在 SET 关之后置修改的字段及其取, 然后可以用 WHERE 子句 ( 可的 ) 要更新的行一个 UPDATE 句会修改 WHERE 子句匹配到的所有行, 若不指定 WHERE 子句, 它将更新表中所有的行以上是数据建与的四个基本 SQL 命令 (INSERT SELECT UPDATE 和 DELETE) 14.6 使用数据爬取 Twitter 数据与化言 SQL 128

在本中, 我写一个的爬虫程序, 通 Twitter 号采集数据, 然后建立数据注意 : 慎行个程序, 不要抓取太多数据或行程序, 会致你的 Twitter 号被封任何型的爬虫程序都面一个, 它需要能被停止和重多次, 你也不想失已取到的数据你不希望是在一开始重数据索, 因此把索到的数据存起来, 爬虫程序能份, 并在它离开的地方索我通索一个用的 Twitter 朋友及他的状, 循朋友列表, 向数据添加每个朋友的信息, 以后索当理了一个用的 Twitter 朋友, 我登数据, 索朋友中的一个重复个操作, 挑一个未的用, 索他的用列表, 添加列表中没有的朋友, 以下次我也追踪数据中特定朋友的出次数, 以此看人气情况通存已知号的列表, 不是否索个号, 数据中号的人气情况已存在算机磁, 停止或重程序多少次都没关系个程序有些复, 它基于前面的 Twitter API 程序代 Twitter 爬虫程序源代如下 : import urllib import twurl import json import sqlite3 TWITTER_URL = 'https://api.twitter.com/1.1/friends/list.json' conn = sqlite3.connect('spider.sqlite3') cur = conn.cursor() cur.execute("' CREATE TABLE IF NOT EXISTS Twitter (name TEXT, retrieved INTEGER, friends INTEGER)"') while True: acct = raw_input('enter a Twitter account, or quit: ') if ( acct == 'quit' ) : break if ( len(acct) < 1 ) : cur.execute('select name FROM Twitter WHERE retrieved = 0 LIMIT 1') try: acct = cur.fetchone()[0] except: print 'No unretrieved Twitter accounts found' continue url = twurl.augment(twitter_url, {'screen_name': acct, 'count': '20'} ) print 'Retrieving', url connection = urllib.urlopen(url) data = connection.read() headers = connection.info().dict # print 'Remaining', headers['x-rate-limit-remaining'] js = json.loads(data) # print json.dumps(js, indent=4) cur.execute('update Twitter SET retrieved=1 WHERE name =?', (acct, ) ) countnew = 0 countold = 0 for u in js['users'] : friend = u['screen_name'] print friend cur.execute('select friends FROM Twitter WHERE name =? LIMIT 1', (friend, ) ) try: count = cur.fetchone()[0] cur.execute('update Twitter SET friends =? WHERE name =?', (count+1, friend) ) countold = countold + 1 except: 数据与化言 SQL 129

cur.execute("'insert INTO Twitter (name, retrieved, friends) VALUES (?, 0, 1 )"', ( friend, ) ) countnew = countnew + 1 print 'New accounts=',countnew,' revisited=',countold conn.commit() cur.close() 数据存在于 spider.sqlite3 文件中, 包括一个 Twitter 表 Twitter 表的每一行包括号名是否索个号的朋友以及个号被加好友的次数在程序的主循中, 提示用入一个 Twitter 号名或退出程序如果用入一个 Twitter 号, 程序就索朋友列表和用状, 如果数据中没有个朋友, 添加去如果朋友已存在于列表中, 我 friends 字段加一当用按下回, 在数据中找下一个未索的 Twitter 号, 索号的朋友与状, 把添加他到数据, 或更新它, 增加 friends 字段的当取到朋友列表与状, 我返回的 JSON 中所有的 user 数据行循, 索每个用的 screen_name 然后, 使用 SELECT 句 screen_name 是否已存到数据中了如果存在的, 索朋友数 (friends 字段 ) countnew = 0 countold = 0 for u in js['users'] : friend = u['screen_name'] print friend cur.execute('select friends FROM Twitter WHERE name =? LIMIT 1', (friend, ) ) try: count = cur.fetchone()[0] cur.execute('update Twitter SET friends =? WHERE name =?', (count+1, friend) ) countold = countold + 1 except: cur.execute("'insert INTO Twitter (name, retrieved, friends) VALUES (?, 0, 1 )"', ( friend, ) ) countnew = countnew + 1 print 'New accounts=',countnew,' revisited=',countold conn.commit() 当游行 SELECT 句, 我必索表的行用 for 句来, 由于只索了一行 (LIMIT 1), 我使用 fetchone() 方法取第一 ( 也是唯一 ) 行, 就是 SELECT 操作的果由于 fetchone() 以元返回行, 即使有一个字段也是如此我用 [0] 取出元的第一个, 得到量 count 的当前朋友数如果取成功, 我使用 SQL 的 UPDATE 句和 WHERE 子句, 匹配到的朋友号所在行的 friends 列加一注意, SQL 句中有个占位符 ( 即号 ), execute() 的第二个参数是元素元, 其中的会替 SQL 的占位符如果 try 区的代失效, 可能是因 SELECT 句的 WHERE name =? 子句没有匹配到在 except 区, 我使用 SQL 的 INSERT 句, 向表中添加朋友的 screen_name, 外一个指示符表示我没有取到 screen_name, 将朋友数 0 第一次行程序, 入一个 Twitter 号, 程序行果如下 : Enter a Twitter account, or quit: drchuck Retrieving http://api.twitter.com/1.1/friends... New accounts= 20 revisited= 0 Enter a Twitter account, or quit: quit 由于是第一次行个程序, 数据是空的, 我建了一个数据文件 spider.sqlite3, 向数据添加一 Twitter 表然后取一些朋友, 将他的信息存到之前空的数据中数据与化言 SQL 130

此, 我想要写一个的数据出程序, 用来看 spider.sqlites3 文件 : import sqlite3 conn = sqlite3.connect('spider.sqlite3') cur = conn.cursor() cur.execute('select * FROM Twitter') count = 0 for row in cur : print row count = count + 1 print count, 'rows.' cur.close() 如果再次行 Twitter 爬虫程序, 程序行果如下 : (u'opencontent', 0, 1) (u'lhawthorn', 0, 1) (u'steve_coppin', 0, 1) (u'davidkocher', 0, 1) (u'hrheingold', 0, 1)... 20 rows. 我看到每个 screen_name 有一行, 没有取字段本身的数据, 数据中每人有一个朋友在, 在数据里可以看到第一个 Twitter 号 (drchuck) 的朋友已取到我再次行个程序, 只需按下回, 不用再入 Twitter 号, 程序就会索下一个未理号的朋友信息 Enter a Twitter account, or quit: Retrieving http://api.twitter.com/1.1/friends... New accounts= 18 revisited= 2 Enter a Twitter account, or quit: Retrieving http://api.twitter.com/1.1/friends... New accounts= 17 revisited= 3 Enter a Twitter account, or quit: quit 由于我按下了回 ( 即没有指定 Twitter 号 ), 行下面的代 : if ( len(acct) < 1 ) : cur.execute('select name FROM Twitter WHERE retrieved = 0 LIMIT 1') try: acct = cur.fetchone()[0] except: print 'No unretrieved twitter accounts found' continue 我使用 SQL 的 SELECT 句取第一个用的名称 (LIMIT 1), 但用的是否字段是 0 我在 try/except 区中使用 fetchone()[0] 模式, 从索到的数据中抽取 screen_name, 或是得到一个消息和循份如果成功取到一个未理的 screen_name, 索数据的程序代如下 : url = twurl.augment(twitter_url, {'screen_name': acct, 'count': '20'} ) print 'Retrieving', url connection = urllib.urlopen(url) data = connection.read() js = json.loads(data) cur.execute('update Twitter SET retrieved=1 WHERE name =?', (acct, ) ) 数据与化言 SQL 131

一旦成功取数据, 我使用 UPDATE 句置 retrieved 列 1, 表示已完成号的朋友索保了不会重复索相同的数据, 理行, 最形成 Twitter 朋友网如果我行 friend 程序, 按次回, 索下一个未被的朋友的朋友, 然后行 dumping 程序, 程序出果如下 : (u'opencontent', 1, 1) (u'lhawthorn', 1, 1) (u'steve_coppin', 0, 1) (u'davidkocher', 0, 1) (u'hrheingold', 0, 1)... (u'cnxorg', 0, 2) (u'knoop', 0, 1) (u'kthanos', 0, 2) (u'lecturetools', 0, 1)... 55 rows. 由此可, 我正确了已的 lhawthorn 和 opencontent 个号的信息外,cnxorg 和 kthanos 已有了粉由于已索了三个用 (drchuck opencontent 与 lhawthorn) 的朋友, 表中已有 55 行每次行程序与按下回, 它会下一个未的号 ( 里的下一个号是 steve_coppin), 取他的朋友, 他, 循 steve_coppin 的每一位朋友, 将他添加到数据如果他已存在于数据, 更新他的朋友数由于程序的数据全部存在数据的磁上, 爬虫活可以被任意多次停或, 数据都不会失 14.7 基数据建模关系型数据的真正力在于, 建多个表以及表接将用数据分解多个表并确立个表的关系, 一程称数据建模示表与表关系的文档称数据模型数据建模是相复的技能, 本介最基的关系型数据建模数据建模的更多, 以下基面 : http://en.wikipedia.org/wiki/relational_model 我来看 Twitter 爬虫程序, 不一个用的朋友数, 我希望得到所有的入关系, 即找到特定号的所有粉的列表由于每个人都可能会有多粉, 所以不能添加一列到 Twitter 表因此, 我新建一个表来跟踪朋友下面是新建表的一种方法 : CREATE TABLE Pals (from_friend TEXT, to_friend TEXT) 每当遇到 drchuck 的一个粉, 我向表中插入一行 : INSERT INTO Pals (from_friend,to_friend) VALUES ('drchuck', 'lhawthorn') 当理了 drchuck 的 20 个朋友的 Twitter 消息源 (feed), 我插入 drchuck 作第一参数的 20 条, 个字符串在数据重复出了多次重复的字符串数据破坏了数据范化的最佳践数据范化指相同的字符串数据在数据只能存在一如果需要数据出多次, 要数据建一个数字, 通引用的数据在用中, 字符串比整数在算机磁与内存上占用更多空, 理器也需要更多行比和排序如果有几百数据与化言 SQL 132

条数据, 那么存与理器耗并没什么但当数据中包括百万用, 以及可能的一朋友接, 尽可能快速描数据就得非常重要了我把 Twitter 号存在 People 表, 而不是之前示例的 Twitter 表 People 表用外的一列来存与 Twitter 用的行数相关的数 SQLite 的 INTEGER PRIMARY KEY 一特殊的数据列型能插入的任一行自增加新建 People 表, 包括一个外的 id 列 : CREATE TABLE People (id INTEGER PRIMARY KEY, name TEXT UNIQUE, retrieved INTEGER) 注意, 我不再 People 表每一行的朋友数当 INTEGER PRIMARY KEY 作 id 列的字段型, 表明我希望 SQLite 来管理列, 在插入一行自予唯一的数我添加了关 UNIQUE, 表示不允 SQLite 个行插入相同的与之前建的 Pals 表不同, 我建了一个 Follows 表, 包括 from_id 和 to_id 个整数列, 以及一个表束, 表中 from_id 和 to_id 必唯一, 即不能在数据中插入重复的行 CREATE TABLE Follows (from_id INTEGER, to_id INTEGER, UNIQUE(from_id, to_id) ) 向表中添加 UNIQUE 子句, 当插入, 我要求数据强制行一套在程序中建些的方便性稍后会明些避免我犯, 并化了一些代写从本上,Follows 表的建是建了一个关系, 一个用是其他人的粉, 将其表示成一个数, 代表与他系的用, 以及关系的方向 14.8 多表程我使用之前的个表主和引用来重做 Twitter 爬虫程序新版本的程序代如下 : import urllib import twurl import json import sqlite3 TWITTER_URL = 'https://api.twitter.com/1.1/friends/list.json' conn = sqlite3.connect('friends.sqlitesqlite3') 数据与化言 SQL 133

cur = conn.cursor() cur.execute("'create TABLE IF NOT EXISTS People (id INTEGER PRIMARY KEY, name TEXT UNIQUE, retrieved INTEGER)"') cur.execute("'create TABLE IF NOT EXISTS Follows (from_id INTEGER, to_id INTEGER, UNIQUE(from_id, to_id))"') while True: acct = raw_input('enter a Twitter account, or quit: ') if ( acct == 'quit' ) : break if ( len(acct) < 1 ) : cur.execute("'select id, name FROM People WHERE retrieved = 0 LIMIT 1"') try: (id, acct) = cur.fetchone() except: print 'No unretrieved Twitter accounts found' continue else: cur.execute('select id FROM People WHERE name =? LIMIT 1', (acct, ) ) try: id = cur.fetchone()[0] except: cur.execute("'insert OR IGNORE INTO People (name, retrieved) VALUES (?, 0)"', ( acct, ) ) conn.commit() if cur.rowcount!= 1 : print 'Error inserting account:',acct continue id = cur.lastrowid url = twurl.augment(twitter_url, {'screen_name': acct, 'count': '20'} ) print 'Retrieving account', acct connection = urllib.urlopen(url) data = connection.read() headers = connection.info().dict print 'Remaining', headers['x-rate-limit-remaining'] js = json.loads(data) # print json.dumps(js, indent=4) cur.execute('update People SET retrieved=1 WHERE name =?', (acct, ) ) countnew = 0 countold = 0 for u in js['users'] : friend = u['screen_name'] print friend cur.execute('select id FROM People WHERE name =? LIMIT 1', (friend, ) ) try: friend_id = cur.fetchone()[0] countold = countold + 1 except: cur.execute("'insert OR IGNORE INTO People (name, retrieved) VALUES (?, 0)"', ( friend, ) ) conn.commit() if cur.rowcount!= 1 : print 'Error inserting account:',friend continue friend_id = cur.lastrowid countnew = countnew + 1 cur.execute("'insert OR IGNORE INTO Follows (from_id, to_id) VALUES (?,?)"', (id, friend_id) ) print 'New accounts=',countnew,' revisited=',countold conn.commit() cur.close() 个程序得有些复了, 介了通整数接表格的使用模式基本模式如下 : 1. 建有主与束的表 2. 当一个用 ( 即号名称 ) 有一个, 我需要用的 id 根据 People 表中是否有用,(1) 找 People 表数据与化言 SQL 134

中的用, 取用的 id, 或 (2) 向 People 表添加用, 新增行添加 id 3. 插入一行, 表示粉关系以下依次介每一个步 14.8.1 数据表束表, 我告数据系强制行一些些帮助我避免出, 不要把的数据写入表中建表的代如下 : cur.execute("'create TABLE IF NOT EXISTS People (id INTEGER PRIMARY KEY, name TEXT UNIQUE, retrieved INTEGER)"') cur.execute("'create TABLE IF NOT EXISTS Follows (from_id INTEGER, to_id INTEGER, UNIQUE(from_id, to_id))"') 我定 People 表中的 name 列必是唯一的 (UNIQUE) 同, 定 Follows 表每一行个数字的合必唯一些束避免了多次添加同一个关系以下代体了些束的 : cur.execute("'insert OR IGNORE INTO People (name, retrieved) VALUES (?, 0)"', ( friend, ) ) 我在 INSERT 句中添加 OR IGNORE 子句, 表示如果有一个 INSERT 反了 name 必唯一的, 那么数据将忽略个 INSERT 数据束作一个安全网, 确保我不会在无意中犯同地, 以下代确保不会重复添加同一个 Follows 关系 cur.execute("'insert OR IGNORE INTO Follows (from_id, to_id) VALUES (?,?)"', (id, friend_id) ) 同地, 如果反了 Follows 行的唯一性束, 只需告数据忽略 INSERT 即可 14.8.2 索与插入一条当提示用入一个 Twitter 号, 如果号已存在, 我必找到它的 id 如果 People 表中没有号, 我必插入一条, 并得到插入行的 id 是一个很常的模式, 在前面的程序中用到 2 次当我从已取的 Twitter 的 JSON 数据中取 user 点的 screen_name, 本代演示了如何索一个朋友号的 id 随着数据的累, 用号可能已存在于数据中我需要先使用 SELECT 句, People 表中号是或否存在如果 try 部分一切展利 2, 我使用 fetchone() 取, 然后索返回的元的第一个 ( 也是唯一 ) 元素, 将其存 friend_id 如果 SELECT 行失,fetchone()[0] 也会失, 然后控制跳到 except 部分 friend = u['screen_name'] cur.execute('select id FROM People WHERE name =? LIMIT 1', (friend, ) ) try: friend_id = cur.fetchone()[0] countold = countold + 1 数据与化言 SQL 135

except: cur.execute("'insert OR IGNORE INTO People (name, retrieved) VALUES (?, 0)"', ( friend, ) ) conn.commit() if cur.rowcount!= 1 : print 'Error inserting account:',friend continue friend_id = cur.lastrowid countnew = countnew + 1 如果以 except 代束, 意味着, 没有, 必插入新行我使用 INSERT OR IGNORE 是避免出, 然后用 commit() 来强制数据提交行更新当写入完成后, 我通 cur.rowcount 有多少行受到影由于我插入一个行, 如果受影行的数字不是 1, 那么将致如果 INSERT 行成功, 我通 cur.lastrowid 找出数据新建行予的 id 列 14.8.3 存朋友关系一旦知道了 JSON 数据中 Twitter 用与朋友的, 在 Follows 表中插入个就是件的事情了, 程序代如下 : cur.execute('insert OR IGNORE INTO Follows (from_id, to_id) VALUES (?,?)', (id, friend_id) ) 注意, 根据表格建的唯一性束, 避免了重复插入同一个关系, 然后在 INSERT 句中添加 OR IGNORE 程序行果如下所示 : Enter a Twitter account, or quit: No unretrieved Twitter accounts found Enter a Twitter account, or quit: drchuck Retrieving http://api.twitter.com/1.1/friends... New accounts= 20 revisited= 0 Enter a Twitter account, or quit: Retrieving http://api.twitter.com/1.1/friends... New accounts= 17 revisited= 3 Enter a Twitter account, or quit: Retrieving http://api.twitter.com/1.1/friends... New accounts= 17 revisited= 3 Enter a Twitter account, or quit: quit 从 drchuck 号开始, 程序自取下个号, 并添加到数据当程序行完成后, 以下是 People 和 Follows 表的几行 : People: (1, u'drchuck', 1) (2, u'opencontent', 1) (3, u'lhawthorn', 1) (4, u'steve_coppin', 0) (5, u'davidkocher', 0) 55 rows. Follows: (1, 2) (1, 3) (1, 4) (1, 5) (1, 6) 60 rows. 可以看出,People 表中的 id name 与 visited 字段, 关系 Follows 表尾的数字在 People 表中, 我看到前三个用已被数据与化言 SQL 136

, 他的数据已被取 Follows 表的数据表明,drchuck( 用 1) 是所示前五行的用的朋友是由于我取和存的第一个数据是 drchuck 的 Twitter 朋友如果打印出 Follows 表的更多行, 就会看到用 2 和用 3 的朋友 14.9 的三种型在我已开始建数据模型了, 将数据放入多个关表中, 使用来接些表中的行我需要知道一些有关的数据模型中一般存在三种型的是真世界中可以索行的在示例数据模型中,name 字段是一个它是用的屏幕名称, 在程序中通 name 字段多次索用的行你会, 一个添加 UNIQUE 束, 是有道理的由于是我从外部世界如何索表中的一行, 允表中存在相同的多行没有多大意主通常是由数据自予的一个数字它外部程序而言没有意, 用于把来自不同表的行接在一起当我索表中的行, 通常搜索主是最快的由于主是整数, 占用极少的存空, 能快速行比与排序在示例数据模型中,id 字段是主外通常是指向不同表中相关行的主的一个数示例数据模型中的外是 from_id 我使用一些命名例, 比如主名 id, 那么将 _id 后添加到外的名称中 14.10 使用 JSON 取数据我已了解了数据范化原, 将数据分成个表, 通主和外将个表接起来, 然后通 SELECT 将跨表格的数据装在一起 SQL 使用接 (JOIN) 子句把表重新接在 JOIN 子句中可以指定用以接表之行的字段下面是有 JOIN 子句的 SELECT 句示例 : SELECT * FROM Follows JOIN People ON Follows.from_id = People.id WHERE People.id = 1 JOIN 子句表示, 从 Follows 与 People 个表中所有字段 ON 子句表示, 个表怎被接在一起取 People 表的行, 然后将 Follows 表的 from_id 字段与 People 表的 id 字段相同的行附加在后面接的果是建了一个相当的元行 (meta-rows), 包括 People 表的字段与 Follows 表中匹配的字段由于 People 表的 id 字段与 Follows 表中的 from_id 字段之存在多个匹配,JOIN 会每一个匹配到的行建一个元行, 根据需要重复数据数据与化言 SQL 137

多表数据的 Twitter 爬虫程序多次行的代如下 : import sqlite3 conn = sqlite3.connect('spider.sqlite3') cur = conn.cursor() cur.execute('select * FROM People') count = 0 print 'People:' for row in cur : if count < 5: print row count = count + 1 print count, 'rows.' cur.execute('select * FROM Follows') count = 0 print 'Follows:' for row in cur : if count < 5: print row count = count + 1 print count, 'rows.' cur.execute("'select * FROM Follows JOIN People ON Follows.from_id = People.id WHERE People.id = 2"') count = 0 print 'Connections for id=2:' for row in cur : if count < 5: print row count = count + 1 print count, 'rows.' cur.close() 在个程序中, 我首先整体出 People 与 Follows 表, 然后出接表的数据子集程序出果如下 : python twjoin.py People: (1, u'drchuck', 1) (2, u'opencontent', 1) (3, u'lhawthorn', 1) (4, u'steve_coppin', 0) (5, u'davidkocher', 0) 55 rows. Follows: (1, 2) (1, 3) (1, 4) (1, 5) (1, 6) 60 rows. Connections for id=2: (2, 1, 1, u'drchuck', 1) (2, 28, 28, u'cnxorg', 0) (2, 30, 30, u'kthanos', 0) (2, 102, 102, u'somethinggirl', 0) (2, 103, 103, u'ja_pac', 0) 20 rows. 可以看出,People 与 Follows 表的列和 JOIN 子句的 SELECT 句行后得到的果行最后一次中我找到 opencontent ( 即 People.id=2) 的朋友号在最后一次的每个元行中, 前列来自 Follows 表, 之后是 People 表 5 个列中的 3 个接后的每个元行中第 2 列 (Follows.to_id) 匹配第 3 列 (People.id) 数据与化言 SQL 138

14.11 小本章全面介了 Python 中数据的基本使用方法与 Python 字典或平面文件相比, 写代来使用数据存数据更加复除非你的用程序确需要数据功能, 否不要易使用数据的使用在于 :(1) 用程序需要在大量数据中随机更新一小部分数据 ;(2) 数据量很大, 无法用字典来存, 而且需要重复索信息 ;(3) 在期行程中希望停止或重, 数据可以得以保留, 并在下次行从中止你可以建表的数据, 以足多种用需求但是, 大多数都需要多个表与跨表的行之的接 / 关系表建接, 需要行周全, 遵循数据范化原, 恰当地用数据能力数据的使用机主要需要理大量数据, 有效的数据建模程序能快速行, 把握住一点很重要 14.12 一个常的 Python 程序开模式是与 SQLite 数据建立系, 行 Python 程序, 使用 SQLite 数据器看果个器可以快速程序是否正常行由于 SQLite 在同一刻会防止个程序同一数据的修改例如, 如果在器中打开数据, 修改数据, 在尚未按下保存按, 器会定数据文件, 以防止其他程序文件具体而言, 如果数据文件被定, 你的 Python 程序将不能个文件一个解决方法是, 在 Python 数据之前, 关数据器或使用器的文件菜来关数据可以避免数据定致的 Python 代行失 14.13 属性 : 元的一个更常的提法是列或字段束 : 告知数据在表中的字段或行上行一个常的束是保特定字段上无重复 ( 即所有必唯一 ) 游 : 行数据的 SQL 命令, 并从数据中取数据游似于网接中的套接字或文件取的文件句柄数据器 : 一种无需写程序, 直接与数据接并行操作的件外 : 指向一个表中行的主的数外建立了不同表中行之的关系索引 : 向表中插入行, 数据件由于需要而生的外数据, 目的是提高速度 : 外部世界用来索特定行的例如, 在用信息表中用的子件地址是不的用数据候范化 : 数据模型要保无重复的数据每个数据只存在数据的一个位置, 其他地方用外来引用主 : 每一行指定的数, 用于当前表中的行与一个表中的行之建立引用关系数据的默配置会自插入的行予主关系 : 数据中包含元与属性的一区域更典型的提法是表元 : 数据中表的一个数据条目, 包含一属性更典型的提法是行 1. 上,SQLite 在列中存的数据型具一定灵活性, 但本章中格定数据型, 做些概念也能适用于其他数据系 ( 如 MySQL) 2. 一般来, 以如果一切利开的, 你会需要使用 try/except 数据与化言 SQL 139

第 15 章数据可化至此, 我了 Python 言, 学了 Python 的基本用法网接, 以及使用数据操作数据等知本章介三个完整的用程序, 将之前学到的知整合起来, 数据行管理与可化你可以使用些程序代来解决每个用程序是一个 ZIP 文件, 可以下和解到本地算机上行 15.1 根据地理数据建 Google 地用个目使用 Google 的地理 API 来清洗用入的大学地名, 然后将些数据示在 Google 地上从以下地址下用程序 : http://www.py4inf.com/code/geodata.zip 首先要解决的是, 免的 Google 地理 API 每天的求数量有一定限制如果数据多, 可能需要在程中多次停止与重里, 我把分解成个段第一段, 按行入 where.data 文件中的数据, 通 Google 取地理信息, 将其存在 geodata.sqlite 数据在每个用入的地名使用地理 API 之前, 我需要下入的行是否有数据存在数据具有本地存功能, 可以地理数据行存, 就无需向 Google 重复求同一数据移除 geodata.sqlite 文件之后, 你可以任何候重个程行 geoload.py 程序, 依次入 where.data 文件的每一行, 数据在数据是否存在若不存在, 用地理 API 取数据, 将其存在数据中下面是数据已有一些数据的情况, 程序行果如下 : Found in database Northeastern University Found in database University of Hong Kong,... Found in database Technion Found in database Viswakarma Institute, Pune, India Found in database UMD Found in database Tufts University Resolving Monash University Retrieving http://maps.googleapis.com/maps/api/ geocode/json?sensor=false&address=monash+university Retrieved 2063 characters { "results" : [ {u'status': u'ok', u'results':... } 数据可化 140

Resolving Kokshetau Institute of Economics and Management Retrieving http://maps.googleapis.com/maps/api/ geocode/json?sensor=false&address=kokshetau+inst... Retrieved 1749 characters { "results" : [ {u'status': u'ok', u'results':... }... 前 5 个地名已存在于数据中, 所以它被跳程序会描到未索的地名, 然后开始取数据 geoload.py 可以随停止, 有一个数器用来控制每次行中地理 API 的用上限由于 where.data 只包括几百个数据, 所以无需置日限制如果数据量很大, 需要几天的多次行才能取所有的地理数据, 种情况下就需要置限制了入一些数据到 geodata.sqlite 之后, 你可以使用 geodump.py 程序数据行可化此程序会取数据, 将地名度度成可行的 JavaScript 代形式, 写入 where.js 文件 geodump.py 行果如下 : Northeastern University,... Boston, MA 02115, USA 42.3396998-71.08975 Bradley University, 1501... Peoria, IL 61625, USA 40.6963857-89.6160811... Technion, Viazman 87, Kesalsaba, 32000, Israel 32.7775 35.0216667 Monash University Clayton... VIC 3800, Australia -37.9152113 145.134682 Kokshetau, Kazakhstan 53.2833333 69.3833333... 12 records written to where.js Open where.html to view the data in a browser where.html 文件包含了 Google 地可化所需的 HTML 与 JavaScript 代它入 where.js 文件中的最新数据, 将其可化 where.js 文件格式如下 : mydata = [ [42.3396998,-71.08975, 'Northeastern Uni... Boston, MA 02115'], [40.6963857,-89.6160811, 'Bradley University,... Peoria, IL 61625, USA'], [32.7775,35.0216667, 'Technion, Viazman 87, Kesalsaba, 32000, Israel'],... ]; 个 JavaScript 量是一个包含列表的列表 JavaScript 列表常量的法与 Python 非常相似, 你不会感到陌生在器中打开 where.html 来看地鼠浮在地点上可以看到地理 API 的用入的地名如果打开 where.html 文件看不到数据, 你可能需要器的 JavaScript 或在开者控制台行排 15.2 网与互可化个用程序了搜索引擎的一些功能首先, 爬取一部分网集合, 然后了一个 Google 的 PageRank 算法化版, 确定些面具有高接度, 最后, 在个小网中面等与接度行可化下和解个用程序 : http://www.py4inf.com/code/pagerank.zip 数据可化 141

首先,spider.py 程序爬取一个网站, 将网站的面存到 spider.sqlite 数据, 面之的接移除 spider.sqlite 文件之后, 你可以随再次行 spider.py Enter web url or enter: http://www.dr-chuck.com/ ['http://www.dr-chuck.com'] How many pages:2 1 http://www.dr-chuck.com/ 12 2 http://www.dr-chuck.com/csev-blog/ 57 How many pages: 在程序行中, 我告知它爬取一个网站, 索个面如果你重程序, 可以它爬取更多面, 它不会重复爬取数据已有的面程序重会随机索未爬取的面, 然后从那里开始因此,spider.py 程序的每一次行都是累式的 Enter web url or enter: http://www.dr-chuck.com/ ['http://www.dr-chuck.com'] How many pages:3 3 http://www.dr-chuck.com/csev-blog 57 4 http://www.dr-chuck.com/dr-chuck/resume/speaking.htm 1 5 http://www.dr-chuck.com/dr-chuck/resume/index.htm 13 How many pages: 同一个数据中可以有多个起点, 在程序中称网爬虫程序随机网中未的接, 作下一个网行爬取如果要出 spider.sqlite 文件内容,spdump.py 程序行果如下 : (5, None, 1.0, 3, u'http://www.dr-chuck.com/csev-blog') (3, None, 1.0, 4, u'http://www.dr-chuck.com/dr-chuck/resume/speaking.htm') (1, None, 1.0, 2, u'http://www.dr-chuck.com/csev-blog/') (1, None, 1.0, 5, u'http://www.dr-chuck.com/dr-chuck/resume/index.htm') 4 rows. 以上示了入的数目旧的面排名新的面排名面 id 和面的 url spdumpy 程序只示至少有一个入的面当数据里已保留一些面数据之后, 行 sprank.py 程序来面排名你只需指定面排名的迭代次数即可 How many iterations:2 1 0.546848992536 2 0.226714939664 [(1, 0.559), (2, 0.659), (3, 0.985), (4, 2.135), (5, 0.659)] 再次出数据, 看面排名的更新情况 : 数据可化 142

(5, 1.0, 0.985, 3, u'http://www.dr-chuck.com/csev-blog') (3, 1.0, 2.135, 4, u'http://www.dr-chuck.com/dr-chuck/resume/speaking.htm') (1, 1.0, 0.659, 2, u'http://www.dr-chuck.com/csev-blog/') (1, 1.0, 0.659, 5, u'http://www.dr-chuck.com/dr-chuck/resume/index.htm') 4 rows. sprank.py 可以行多次, 它会在每次行化面排名你可以行几次 sprank.py, 然后用 spider.py 爬取一些面, 再行 sprank.py 来收网排名搜索引擎一般会同行爬取程序与排名程序如果在没有重新爬取网的情况下再次算网排名, 你可以用 sprest.py 程序重置, 然后重 sprank.py How many iterations:50 1 0.546848992536 2 0.226714939664 3 0.0659516187242 4 0.0244199333 5 0.0102096489546 6 0.00610244329379... 42 0.000109076928206 43 9.91987599002e-05 44 9.02151706798e-05 45 8.20451504471e-05 46 7.46150183837e-05 47 6.7857770908e-05 48 6.17124694224e-05 49 5.61236959327e-05 50 5.10410499467e-05 [(512, 0.0296), (1, 12.79), (2, 28.93), (3, 6.808), (4, 13.46)] 于 PageRank 算法的每次迭代, 它会打印出每个面排名的平均化网在初始状非常不均衡, 是由于个面排名在迭代程中化很大一些迭代之后, 面排名开始收了行 prank.py 足之后, 网排名就会相定如果想要网排名中当前靠前的面行可化, 行 spjson.py 程序, 取数据, 将最高接面的数据 JSON 格式, 可以在网器中看效果 Creating JSON output on spider.json... How many nodes? 30 Open force.html in a browser to view the visualization 在网器中打开 force.html 来看此数据是一个自布局的包含点与接的网你可以点和拖拽任一点, 也可以双点, 看点的 URL 如果重新行其他工具, 重新行 spjson.py, 在器中点刷新, 示 spider.json 得到的新数据 15.3 件数据可化到里, 你得 mbox-short.txt 与 mbox.txt 个数据文件下面我将深入分析些子件数据在世界中, 有你需要从服器下件数据, 可能要花相当, 数据可能会存在不一致, 充和需要做大量清洗与整工作本介的程序是截至目前最复的, 从服器下近 1 个 G 大小的数据, 然后其可化数据可化 143

下用程序代 : http://www.py4inf.com/code/gmane.zip 里使用 http://www.gmane.org 的免子件列表档服由于服提供了子件活的档, 数据量高且可搜索, 所以在开源目中非常流行它的数据 API 政策也比松, 没有限制, 但不要度使用, 取你需要的数据即可你可以在下面的网中 gmane 的条款与条件 : http://gmane.org/export.php 使用 gmane.org 数据需要考, 在服和行任, 有添加延, 一点非常重要不要用免服, 避免累及他人使用件爬取 Sakai 子件数据, 可能会生 1 个 G 的数据, 行需要花几天下的包里有一个 README.txt 文件, 提供如何下一个已爬取的 content.sqlite 副本的操作指南, 无需花 5 天行程序来爬取数据 contet.sqlite 包含了主要的 Sakai 子件料如果下了先爬行好的内容, 你仍然可以行个爬取程, 以取最新的消息第一步是爬取 gmane 档在 gmane.py 中基 URL 是硬的, 被硬 Sakai 开者列表通修改基 URL 可以爬取其他档如果修改了基 URL, 确保除 content.sqlite 文件 gmane.py 文件作一个任的存型爬虫, 有条不紊行, 每秒索一条件信息, 避免被 gmane 封掉它把所有数据存在数据, 根据需要可以多次中断和重数据下可能需要花几个小因此, 程序行中可能需要重几次 gmane.py 程序取到 Sakai 开者列表最后 5 条消息如下所示 : How many messages:10 http://download.gmane.org/gmane.comp.cms.sakai.devel/51410/51411 9460 nealcaidin@sakaifoundation.org 2013-04-05 re: [building... http://download.gmane.org/gmane.comp.cms.sakai.devel/51411/51412 3379 samuelgutierrezjimenez@gmail.com 2013-04-06 re: [building... http://download.gmane.org/gmane.comp.cms.sakai.devel/51412/51413 9903 da1@vt.edu 2013-04-05 [building sakai] melete 2.9 oracle... http://download.gmane.org/gmane.comp.cms.sakai.devel/51413/51414 349265 m.shedid@elraed-it.com 2013-04-07 [building sakai]... http://download.gmane.org/gmane.comp.cms.sakai.devel/51414/51415 3481 samuelgutierrezjimenez@gmail.com 2013-04-07 re:... http://download.gmane.org/gmane.comp.cms.sakai.devel/51415/51416 0 Does not start with From 数据可化 144

程序描 content.sqlite, 从 1 开始, 直到找到未被爬取的消息的序号, 然后开始爬取那条消息直到爬取到需要的消息序号或者到一个不符合消息格式的面, 程序止有候,gmane.org 的消息可能不全, 可能是管理被除了或消息被弄了如果爬虫停止, 可能是它碰到一条失的消息打开 SQLite 管理器, 添加一个失的 id, 其他字段留空, 然后重 gmane.py 爬取程就可以了些空消息在下段理会被忽略一旦爬取了所有消息并将它存在 content.sqlite, 你可以再次行 gmane.py 来取件列表上新布的消息听来不 content.sqlite 的数据缺乏有效的数据模型和未被, 得相当原始做是有意的, 它可以你在 SQLite 管理器中看 content.sqlite, 在爬取程中如果想要个数据行, 可不是个好主意, 效率会非常低第二段是行 gmodel.py 程序程序从 content.sqlite 入原始数据, 行数据清理与建模, 生成 index.sqlite 文件由于了和正文,index.sqlite 比 content.sqlite 文件体一般要小十倍每次行 gmodel.py, 它都会除和重建 index.sqlite, 允整参数和 content.sqlite 里的映射表, 从而控制数据清洗程以下是 gmodel.py 的行情况示例每理 250 条件消息之后打印一行, 可以察到一些程序行情况程序会行一段, 期理近 1 个 G 的子件数据 Loaded allsenders 1588 and mapping 28 dns mapping 1 1 2005-12-08T23:34:30-06:00 ggolden22@mac.com 251 2005-12-22T10:03:20-08:00 tpamsler@ucdavis.edu 501 2006-01-12T11:17:34-05:00 lance@indiana.edu 751 2006-01-24T11:13:28-08:00 vrajgopalan@ucmerced.edu... gmodel.py 程序主要是行一些数据清理任域名.com.org.edu 和.net 被截断成 2, 其他域名被分 3 因此,si.umich.edu 理 umich.edu,caret.cam.ac.uk 理 cam.ac.uk 外, 子件地址全部小写一些 @gmane.org 地址, 如下所示 : arwhyte-63axycvo3tyhxe+lvdladg@public.gmane.org 的件地址如果与料中的真子件地址匹配, 就会被真地址 content.sqlite 数据包括个表, 允域名与个人子件 ( 可能会生化 ) 之行映射例如, 在 Sakai 开者列表中,Steve Githens 由于更了工作, 使用以下子件地址 : s-githens@northwestern.edu sgithens@cam.ac.uk swgithen@mtu.edu 我在 contente.sqlite 的 Mapping 表中添加条数据, gmodel.py 就可以将 3 个子件地址映射一个地址 : s-githens@northwestern.edu -> swgithen@mtu.edu sgithens@cam.ac.uk -> swgithen@mtu.edu 如果多个 DNS 名需要映射到一个 DNS 上, 你也可以在 DNSMapping 表中做似添加如下映射添加到 Sakai 数据中 : iupui.edu -> indiana.edu 数据可化 145

, 所有印第安大学的校号就可以集中跟踪了反复行 gmodel.py 来看数据, 通添加映射数据更加干程序一旦完成, 你会得到一个子件的索引版本, 即 index.sqlite 个数据文件用于数据分析非常快首先, 做个的数据分析 : 送件最多? 和个送件最多? 使用 gbasic.py : How many to dump? 5 Loaded messages= 51330 subjects= 25033 senders= 1584 Top 5 Email list participants steve.swinsburg@gmail.com 2657 azeckoski@unicon.net 1742 ieb@tfd.co.uk 1591 csev@umich.edu 1304 david.horwitz@uct.ac.za 1184 Top 5 Email list organizations gmail.com 7339 umich.edu 6243 uct.ac.za 2451 indiana.edu 2258 unicon.net 2055 注意, 与 gmane.py 和 gmodel.py 相比,gbasic.py 理数据非常快然它都在相同的数据上工作, 但 gbasic.py 使用 index.sqlite 中和范化的数据如果有大量数据需要管理, 本示例用程序采用的多步理可能多用了一些开, 但在数据探索与可化省了大量 gword.py 了主行的可化 : Range of counts: 33229 129 Output written to gword.js gword.py 行后生成 gword.js 文件, 通 gword.htm 行可化, 生成一个似本开的云第二个可化用 gline.py 生成它算了一段内某的子件参与情况 Loaded messages= 51330 subjects= 25033 senders= 1584 Top 10 Oranizations ['gmail.com', 'umich.edu', 'uct.ac.za', 'indiana.edu', 'unicon.net', 'tfd.co.uk', 'berkeley.edu', 'longsight.com', 'stanford.edu', 'ox.ac.uk'] Output written to gline.js gline.py 行后生成 gline.js 文件, 通 gline.htm 行可化数据可化 146

以上是一个相复的高用程序, 具一些数据索清洗与可化功能数据可化 147

第 16 章常任自化理我已学了从文件网 Web Services 和数据中取数据 Python 可以遍算机的所有目和文件, 并取些文件本章中写的程序会描算机, 每个文件行某些操作文件被到目中, 也称文件的 Python 脚本既能快速解决任, 也能目或整个算机上成百上千的文件使用 os.walk 和 for 循遍目中的所有目与文件与 open 方法循取文件内容套接字通写循取网接中的内容以及 urllib 打开网取所有内容等的原理似 16.1 文件名与路径每个行中的程序有一个当前目, 作大多数操作的默目例如, 当打开一个文件行取,Python 会在当前目下找个文件 os( 代表 operating system, 操作系 ) 模提供文件与目的操作功能 os.getcwd 返回当前目的名称 : >>> import os >>> cwd = os.getcwd() >>> print cwd /Users/csev cwd 代表当前工作目个示例程序的行果是 /Users/csev, 是用 csev 的当前目似 cwd 的字符串表示的是路径相路径从当前目开始, 路径从文件系的目开始我看到的路径都是文件名, 因此它是相于当前目的找到一个文件的路径, 使用 os.path.abspath: >>> os.path.abspath('memo.txt') '/Users/csev/memo.txt' os.path.exists 文件或目是否存在 : >>> os.path.exists('memo.txt') True 如果存在,os.path.isdir 它是否是一个目 : >>> os.path.isdir('memo.txt') False >>> os.path.isdir('music') True 同地,os.path.isfile 它是否是一个文件 os.listdir 根据指定目, 返回其下的文件与子目的列表 >>> os.listdir(cwd) 常任自化理 148

['music', 'photos', 'memo.txt'] 16.2 示例 : 清理照片目以前我写一个似 Flickr 的件, 可以从手机上接收照片, 并把它存在服器上我写个件 Flickr 未出, 当 Flickr 出后, 我仍然在使用个程序, 用来保留原始照片我会在彩信和子件行送一条的文本描述我将些消息存在一个文本文件中, 放置在照片文件所在的目下根据照片拍的月年日和来目以下是照片及其描述的命名示例 :./2006/03/24-03-06_2018002.jpg./2006/03/24-03-06_2018002.txt 七年之后, 我有了多照片和些年我更手机, 从消息中抽取的代有会失效, 服器上出了一些无用的数据我想要遍些文件, 找出些文本文件是真正的, 些是信息, 然后除些信息首先, 点出子文件下有多少文本文件, 行以下程序 : import os count = 0 for (dirname, dirs, files) in os.walk('.'): for filename in files: if filename.endswith('.txt') : count = count + 1 print 'Files:', count python txtcount.py Files: 1917 段代的关是 Python 的 os.walk 当用 os.walk, 指定一个起始目, 它会式遍所有的子目. 表示当前目, 从此往下找当它每遇到一个目, 我将得到 for 循内元的三个第一个是当前目名, 第二个是当前目的子目列表, 第三个是当前目的文件列表没必要依次看每个子目事上, 通 os.walk 来每个文件如果想要看每个文件, 写一个的 for 循来看当前目下的每个文件如果文件以.txt 尾, 我就看个文件, 并整个目中以.txt 后的文件数目一旦知道了有多少文件以.txt 尾, 接下来要自判断文件的好坏因此, 我一个的程序, 打印出文件及其大小 : import os from os.path import join for (dirname, dirs, files) in os.walk('.'): for filename in files: if filename.endswith('.txt') : thefile = os.path.join(dirname,filename) print os.path.getsize(thefile), thefile 在, 不要文件数, 我使用 os.path.join 建一个文件名, 将目中的文件名与目名接在一起里使用 os.path.join, 而不是用字符串接做的原因在于 :Windows 上使用反斜杠 (\) 来造文件路径,Linux 和 Mac 上使用正斜杠 (/) 来造文件路径 os.path.join 知道如何理一差异, 能当前行的操作系, 据此适合的接因此, 相同的 Python 代在 Windows 和 Unix 系上都能行一旦得到了有目路径的完整文件名, 使用 os.path.getsize 取文件大小, 并打印出, 程序行果如下 : 常任自化理 149

python txtsize.py... 18./2006/03/24-03-06_2303002.txt 22./2006/03/25-03-06_1340001.txt 22./2006/03/25-03-06_2034001.txt... 2565./2005/09/28-09-05_1043004.txt 2565./2005/09/28-09-05_1141002.txt... 2578./2006/03/27-03-06_1618001.txt 2578./2006/03/28-03-06_2109001.txt 2578./2006/03/29-03-06_1355001.txt... 一下程序出, 我注意到有一些文件很短, 有些文件非常大, 有一些相同大小的文件 (2578 和 2565) 当打开一些大文件, 我它除了一些通用的 HTML 之外, 其他什么都没有那些 HTML 从我的 T-Moblie 手机送的消息 <html>... <head> <title>t-mobile</title> 跳个文件, 它看起来没有包含有用的信息, 随后我可能做除理在除些文件之前, 我写一个程序, 找多余一行的文件, 并示文件的内容不要被 2578 或 2565 字符度的文件所干, 因我已知道些文件没有包含有用信息程序代如下 : import os from os.path import join for (dirname, dirs, files) in os.walk('.'): for filename in files: if filename.endswith('.txt') : thefile = os.path.join(dirname,filename) size = os.path.getsize(thefile) if size == 2578 or size == 2565: continue fhand = open(thefile,'r') lines = list() for line in fhand: lines.append(line) fhand.close() if len(lines) > 1: print len(lines), thefile print lines[:4] 我使用 continue 跳个大小不正确的文件, 然后打开其他文件, 将取到文件的内容放到一个 Python 列表中如果文件多余一行, 打印出文件的行数和前三行内容一来, 程序掉个大小不正确的文件假所有行的文件是正确的, 那么我得到一些符合要求的数据 : python txtcheck.py 3./2004/03/22-03-04_2015.txt ['Little horse rider\r\n', '\r\n', '\r'] 2./2004/11/30-11-04_1834001.txt ['Testing 123.\n', '\n'] 3./2007/09/15-09-07_074202_03.txt ['\r\n', '\r\n', 'Sent from my iphone\r\n'] 3./2007/09/19-09-07_124857_01.txt ['\r\n', '\r\n', 'Sent from my iphone\r\n'] 3./2007/09/20-09-07_115617_01.txt 常任自化理 150

但是, 文件中是存在一个或多个令人疼的模式 : 有一些三行文件, 包含个空行, 之后跟一行文字自我的 iphone, 的数据仍然存在因此, 个情况修改程序如下 : lines = list() for line in fhand: lines.append(line) if len(lines) == 3 and lines[2].startswith('sent from my iphone'): continue if len(lines) > 1: print len(lines), thefile print lines[:4] 如果是三行文件, 程序其行 ; 如果第三行以特定内容开始, 跳它在行个程序, 我看到有 4 个多行文件, 但些文件看起来是合理的 : python txtcheck2.py 3./2004/03/22-03-04_2015.txt ['Little horse rider\r\n', '\r\n', '\r'] 2./2004/11/30-11-04_1834001.txt ['Testing 123.\n', '\n'] 2./2006/03/17-03-06_1806001.txt ['On the road again...\r\n', '\r\n'] 2./2006/03/24-03-06_1740001.txt ['On the road again...\r\n', '\r\n'] 程序的整体模式, 通接受或拒文件, 果行清理一旦找到坏模式, 使用 continue 跳不符合要求的文件代行修正, 找到更多不符合要求的文件模式在, 我准除些文件里反下, 不打印出剩下的好文件, 而是打印出那些不符合要求准除的文件 import os from os.path import join for (dirname, dirs, files) in os.walk('.'): for filename in files: if filename.endswith('.txt') : thefile = os.path.join(dirname,filename) size = os.path.getsize(thefile) if size == 2578 or size == 2565: print 'T-Mobile:',thefile continue fhand = open(thefile,'r') lines = list() for line in fhand: lines.append(line) fhand.close() if len(lines) == 3 and lines[2].startswith('sent from my iphone'): print 'iphone:', thefile 我得到了一个待除的候文件列表, 明白了什么些文件会被除程序行果如下 : python txtcheck3.py... T-Mobile:./2006/05/31-05-06_1540001.txt T-Mobile:./2006/05/31-05-06_1648001.txt iphone:./2007/09/15-09-07_074202_03.txt iphone:./2007/09/15-09-07_144641_01.txt iphone:./2007/09/19-09-07_124857_01.txt... 常任自化理 151

我可以些文件, 确保没有在不意引入致程序束, 或是由于致一些文件被抓当我待除的列表感到意, 程序做出如下修改 : if size == 2578 or size == 2565: print 'T-Mobile:',thefile os.remove(thefile) continue... if len(lines) == 3 and lines[2].startswith('sent from my iphone'): print 'iphone:', thefile os.remove(thefile) continue 在个版本的程序中, 我不打印出文件, 使用 os.remove 移除不符合要求的文件 python txtdelete.py T-Mobile:./2005/01/02-01-05_1356001.txt T-Mobile:./2005/01/02-01-05_1858001.txt... 出于目的, 再行一遍程序, 次不会出任何果, 是因不符合要求的文件已被移除了如果再次行 txtcount.py,899 个不符合要求的文件会被移除 python txtcount.py Files: 1018 在本中, 我遵循一定理步首先, 使用 Python 遍目和文件来找模式 ; 然后, 我在 Python 的帮助下, 确定目中些内容需要行清理, 一旦找到些文件符合要求, 出些文件没有用 ; 最后, 使用 Python 行清理, 除那些没有用的文件需要解决的可能非常, 可能需要看文件名, 或逐个入文件, 找文件中存在的模式有, 你需要取所有文件, 修改其中一些文件当掌握了 os.walk 与其他 os 用工具之后, 些操作会得非常 16.3 命令行参数前面章中的很多程序都使用 raw_input 文件名的入, 从文件取数据整个数据理程如下 : name = raw_input('enter file:') handle = open(name, 'r') text = handle.read()... 个程序做一些化, 在 Python, 通命令行取得文件名行 Python 程序, 提示如下 : python words.py Enter file: mbox-short.txt... 我可以在 Python 文件后面附加其他字符串, 在 Python 程序中些命令行参数下面的程序演示了从命令行取参数 : 常任自化理 152

import sys print 'Count:', len(sys.argv) print 'Type:', type(sys.argv) for arg in sys.argv: print 'Argument:', arg sys.argv 的内容是一个字符串列表, 其中第一个字符串是 Python 程序的名称,Python 文件之后其他字符串是命令行参数下面的程序从命令行取了几个参数 : python argtest.py hello there Count: 3 Type: <type 'list'> Argument: argtest.py Argument: hello Argument: there 三个参数作三元列表到程序中列表的第一个元素是文件名 (argtest.py), 文件名之后的其他个是命令行参数我重写个程序来取文件, 从命令行参数得文件名, 程序代如下 : import sys name = sys.argv[1] handle = open(name, 'r') text = handle.read() print name, 'is', len(text), 'bytes' 我把第二个命令行参数作文件名, 在 [0] 跳之前的程序名打开文件并取文件内容的代如下所示 : python argfile.py mbox-short.txt mbox-short.txt is 94626 bytes 使用命令行参数作入, 使得 Python 程序更易于重用特是有一个或个字符串入的情况有用 16.4 管道大多数操作系提供命令行界面, 也被称 Shell Shell 通常提供文件系航与用的命令例如, 在 Unix 中,cd 命令更改目,ls 示目的内容, 入如 Firefox 来网器从 Shell 可以任何程序, 也可以通 Python 的管道 (pipe) 来程序管道是用来表示正在行的程的一个象例如,Unix 的命令 1 ls l 通常以格式示当前目的内容你可以用 os.open 来 ls 命令 : >>> cmd = 'ls -l' >>> fp = os.popen(cmd) 参数是包含 Shell 命令的字符串返回是一个文件指, 个程就像是打开一个文件通 ls 程,readline 每次取一行, 或使用 read 方法一次性得到全部内容 : >>> res = fp.read() 常任自化理 153

完成之后, 像关文件一关管道 : >>> stat = fp.close() >>> print stat None 返回是 ls 程的最状 None 表示正常束, 没有出 16.5 路径 : 从目开始, 文件或目所在的位置无是否在当前工作目, 都可以到文件或目校 : 参哈希算法 (hashing) 校个来自于数据的需求, 当数据在网上送或写入到份介后再行取的程中, 数据是否存在被改的可能当数据写入或送, 送系会算出校, 一并送出去当数据入和收到, 接收系会根据接收到的数据, 重新算校, 与送来的校行比如果校不匹配, 那么就会数据在程中被改了命令行参数 :Python 文件名之后命令行中的参数当前工作目 : 当前你所在的目在大多数系的命令行界面, 使用 cd 命令更改工作目在 Python 中, 使用文件名打开文件, 并没有指定路径信息, 文件必在当前行程序的工作目下哈希算法 : 取潜在的大量数据, 数据生成一个唯一的校最佳的哈希函数只生很少的冲突里的冲突是指哈希函数个不同的数据流, 生相同的哈希 MD5 SHA1 和 SHA256 是常用的哈希算法管道 : 与正在行的程序行接的通道通管道, 你可以写程序来送数据其他程序, 或从其他程序接收数据管道与套接字似, 但是管道只能用于同一台算机上程序之的接, 也就是不能通网行接相路径 : 相于当前的工作目, 文件或目所在的位置 shell: 操作系的命令行界面在一些操作系中称端程序在命令行界面中, 入一条命令和参数, 然后按下回来行条命令遍 : 整个目子目以及子目的子目, 直到到所有的目称之遍目 16.6 16.1: 大量 MP3 文件集合中可能存在相同歌曲的多个副本, 存于不同的目或者以不同的文件命名个的目是找到重复的 MP3 文件 1. 写一个程序, 遍一个文件及其子文件中的所有以.mp3 后尾的文件, 并列出相同大小的一文件提示 : 使用字典, 字典的是从 os.path.getsize 得到的文件大小, 字典的是文件名与路径名的合每遇到一个文件, 其是否与已知文件的大小相同如果大小相同, 得到一个重复大小的文件, 打印文件大小与个文件的名称 ( 一个来自哈希, 一个是你正在看的文件 ) 2. 修改之前的程序, 用哈希或校算法看重复内容的文件例如,MD5(Message-Digest algorithm 5, 消息摘要算法第五版 ) 接受任意度的消息, 返回一个 128 位的校不同内容的个文件返回相同校的可能性非常小 MD5 的具体内容 http://wikipedia.org/wiki/md5 以下代片段打开一个文件, 入内容, 算校 import hashlib... fhand = open(thefile,'r') data = fhand.read() fhand.close() checksum = hashlib.md5(data).hexdigest() 常任自化理 154

新建一个字典, 包含校作, 文件名作当算了校, 它就作字典的存在, 有个文件内容重复, 因此打印出字典中的文件和才的文件在像文件的文件下行程序, 果如下所示 :./2004/11/15-11-04_0923001.jpg./2004/11/15-11-04_1016001.jpg./2005/06/28-06-05_1500001.jpg./2005/06/28-06-05_1502001.jpg./2006/08/11-08-06_205948_01.jpg./2006/08/12-08-06_155318_02.jpg 很然, 我重复提交了相同的照片, 没有及除之前的拷 1. 当使用管道与操作系命令 ( 如 ls), 有一点很重要, 了解正在使用的操作系型, 使用管道打开操作系支持的命令常任自化理 155

附 A Windows 平台上的 Python 程本附介在 Windows 上行 Python 的一系列步你可以采用多种方法做到一点, 但是一种事情保持的方法首先, 你需要安装一个程序用的器不要使用事本或微的 Word 字理件来 Python 程序程序必是平面的文本文件, 因此你需要的是一个擅文本文件的器我在 Windows 平台上推荐 NotePad++, 从以下网址下与安装 : http://sourceforge.net/projects/notepad-plus/files/ 从 www.python.org 网站下 Python 2 的最新版本 http://www.python.org/download/releases/2.7.5/ 安装好 Python 之后, 算机上会出似的新文件 C:\Python27 新建一个 Python 程序, 从开始菜行 NotePad++, 采用.py 后保存文件个中, 在桌面建一个 py4inf 文件文件名越短越好, 不要在文件和文件名中留空格写第一个 Python 程序如下 : print 'Hello Chuck' 里你能做的就是修改成你自己的名字将程序文件保存在 Desktop\py4inf\prog1.py 在命令行行程序,Windows 不同版本的操作有些差 Windows Vista 与 Windows-7: 按下开始按, 在命令搜索窗口入 command 一, 然后按回 Windows-XP: 按下开始按, 然后点行, 在框入 cmd, 然后点 OK 此出一个文本窗口, 并提示当前所在的文件 Windows Vista 与 Windows-7 的文件位置是 :C:\Users\csev Windows XP 的文件位置是 :C:\Documents and Settings\csev 就是你的主目在我需要入才保存 Python 程序的文件, 使用以下命令 : C:\Users\csev\> cd Desktop C:\Users\csev\Desktop> cd py4inf 然后入 C:\Users\csev\Desktop\py4inf> dir 列出当前文件下的所有文件当入 dir 命令后, 你看到 prog1.py 文件了行个程序, 只需在命令行入文件名, 然后按回 C:\Users\csev\Desktop\py4inf> prog1.py Hello Chuck C:\Users\csev\Desktop\py4inf> 附 A 156

你可以在 NotePad++ 里写文件, 保存它然后, 切到命令行窗口, 在命令行提示符, 入文件名再次行程序如果你被命令行窗口搞混了, 没关系, 关它再打开一个即可提示 : 在命令行使用向上箭可以回和行之前入的命令外, 建在 NotePad++ 的偏好置中将 Tab 字符置 4 个空格将省大量由于致的花 Python 程序与行的更多信息, 参 http://www.py4inf.com 附 A 157

附 B Mac 平台上的 Python 程本附介在 Mac 上行 Python 的系列步由于 Mac 操作系已包含了 Python, 所以只需学如何 Python 文件和在端窗口行 Python 程序在 Python 程序与行的多方法中, 是我找到的一种非常的方法首先, 需要安装一个程序用的文本器不要使用 TextEdit 或微的 Word 字理件来程序程序必是平的文本文件, 因此你需要的是一个善于文本文件的器我在 Mac 平台上推荐 TextWrangler, 从以下网址下与安装 : http://www.barebones.com/products/textwrangler/ 新建一个 Python 程序, 从用文件中行 TextWrangler 写第一个 Python 程序 : print 'Hello Chuck' 里你能做的就是修改成你自己的名字将程序文件保存在桌面, 命名 py4inf 文件名越短越好, 不要在文件和文件名中留空格在端窗口行程序最的方法是点屏幕后上角的 Spotlight ( 放大 ), 入 terminal ( 也可入中文端 ) 端窗口就是你的主目在端窗口入 pwd 命令看当前目 67-194-80-15:~ csev$ pwd /Users/csev 67-194-80-15:~ csev$ 必在包含 Python 程序的文件下行程序我使用 cd 命令移到一个新的文件, 然后用 ls 命令列出文件下的文件 67-194-80-15:~ csev$ cd Desktop 67-194-80-15:Desktop csev$ cd py4inf 67-194-80-15:py4inf csev$ ls prog1.py 67-194-80-15:py4inf csev$ 在命令提示符, 只需入 python 命令来行程序, 后面跟程序文件名, 然后按回 67-194-80-15:py4inf csev$ python prog1.py Hello Chuck 67-194-80-15:py4inf csev$ 在 TextWrangler Python 程序文件, 保存它, 然后切到命令行窗口, 在命令行提示符, 入文件名再次行程序提示 : 在命令行使用向上箭可以回和行之前入的命令外, 建在 TextWrangler 的偏好置中将 Tab 字符置 4 个空格将省大量由于致的花附 B 158

Python 程序与行的更多信息, 参 http://www.py4inf.com 附 B 159

附 C 献信息管理 Python 教程献者名 Bruce Shields 了早期稿,Sarah Hegge, Steven Cherry, Sarah Kathleen Barbarow, Andrea Parker, Radaphat Chongthammakun, Megan Hixon, Kirby Urner, Sarah Kathleen Barbrow, Katie Kujala, Noah Botimer, Emily Alinder, Mark Thompson-Kular, James Perry, Eric Hofer, Eytan Adar, Peter Robinson, Deborah J. Nelson, Jonathan C. Anthony, Eden Rassette, Jeannette Schroeder, Justin Feezell, Chuanqi Li, Gerald Gordinier, Gavin Thomas Strassel, Ryan Clement, Alissa Talley, Caitlin Holman, Yong-Mi Kim, Karen Stover, Cherie Edmonds, Maria Seiferle, Romer Kristi D. Aranas (RK), Grant Boyer, Hedemarrie Dussan, 思考 Python 序思考 Python 怪史 (Allen B. Downey) 1999 年 1 月我准授一 Java 程入程我已三遍, 但令我很沮程的失比例太高, 即便是成功的学生也感不好, 整体的成就感非常低我之一是教材它都是大部, 介了太多不必要的 Java, 并没有出足多的如何程的高水平的引学生都体到陷效 : 他一开始得容易, 循序, 然后到第五章左右就脱了学生得到很多新内容度太快了, 我得用学期剩下的收拾残局在第一次之前的周, 我决定写一本我自己的我的目是 : 保持短学生 10 比 50 的效果要好慎使用我尽量少用行, 在第一次使用每个行定循序避免陷, 我将最困的主分解成一系列小的步注于程, 而不是程言我只解 Java 有用的最小子集, 其他不涉及我需要一个名, 一起, 想出了像算机科学家一思考么一个名字第一个版本非常粗糙, 但是起作用了学生真得去了, 他能充分理解我在堂上花授的复主, 有趣的主和最重要的部分留他下去我使用 GNU 自由文档可布本, 允用复制修改和分本接下来生的事情是最酷的部分一位弗吉尼州的高中老 Jeff Elkner 改了我的, 把它改成 Python 言他我一份稿, 我通自己的来学 Python, 是多么不常的体啊 Jeff 和我修了本, 加入了 Chris Meyers 的一个案例研究 2001 年我是以 GNU 自由文档布了像算机科学家一思考 : 学 Python 通茶出版社, 我出版了本, 开始在 Amazon.com 和大学店出售茶出版社出版的其他籍 http://greenteapress.com 2003 年我开始在奥林学院教, 第一次授 Python 与 Java 的比是人的学生扎更少, 学到更多, 开了更多有趣的目, 体而言趣更多在去 5 年里, 我不断修本, 和改一些示例, 增加内容, 特是 2008 年我开始了一个重大版本修, 与此同大学出版社一位系我, 出版此新版表出趣多好的机! 我希望你能喜本, 它能帮助你学程与思考, 至少有那么一点点像算机科学家附 C 160

思考 Python 致 (Allen B. Downey) 首先也是最重要的, 我要感 Jeff Elkner, 他将我的 Java 翻成 Python 版本, 促使个目得以, 也我到了自己最喜的言我也要感 Chris Meyers, 他献了像算机科学家一思考的若干内容我要感自由件基金会提出的 GNU 自由文档可, 我与 Jeff 和 Chris 共事成可能我要感像算机科学家一思考的 Lulu 网任我要感所有参与到本早期版本写的学生, 所有提交勘与建的献者名字示在附中我要感我的妻子 Lisa 本的付出, 有茶出版社和其他所有提供帮助的人 Allen B. Downey Needham MA Allen Downey 是富克林. 奥林工程学院算机科学副教授思考 Python 献者名在去几年, 有 100 多位眼光敏有想法的者出建和提交勘他个目的献与情, 成最大的帮助每个人的献参思考 Python 正文 Lloyd Hugh Allen, Yvon Boulianne, Fred Bremmer, Jonah Cohen, Michael Conlon, Benoit Girard, Courtney Gleason and Katherine Smith, Lee Harr, James Kaylin, David Kershaw, Eddie Lam, Man-Yong Lee, David Mayo, Chris McAloon, Matthew J. Moelter, Simon Dicon Montford, John Ouzts, Kevin Parks, David Pool, Michael Schmitt, Robin Shaw, Paul Sleigh, Craig T. Snydal, Ian Thomas, Keith Verheyden, Peter Winstanley, Chris Wrobel, Moshe Zadka, Christoph Zwerschke, James Mayer, Hayden McAfee, Angel Arnal, Tauhidul Hoque and Lex Berezhny, Dr. Michele Alzetta, Andy Mitchell, Kalin Harvey, Christopher P. Smith, David Hutchins, Gregor Lingl, Julie Peters, Florin Oprina, D. J. Webre, Ken, Ivo Wever, Curtis Yanko, Ben Logan, Jason Armstrong, Louis Cordier, Brian Cain, Rob Black, Jean-Philippe Rey at Ecole Centrale Paris, Jason Mader at George Washington University made a number Jan Gundtofte-Bruun, Abel David and Alexis Dinno, Charles Thayer, Roger Sperberg, Sam Bull, Andrew Cheung, C. Corey Capel, Alessandra, Wim Champagne, Douglas Wright, Jared Spindor, Lin Peiheng, Ray Hagtvedt, Torsten Hübsch, Inga Petuhhov, Arne Babenhauserheide, Mark E. Casida, Scott Tyler, Gordon Shephard, Andrew Turner, Adam Hobart, Daryl Hammond and Sarah Zimmerman, George Sass, Brian Bingham, Leah Engelbert-Fenton, Joe Funke, Chao-chao Chen, Jeff Paine, Lubos Pintes, Gregg Lind and Abigail Heithoff, Max Hailperin, Chotipat Pornavalai, Stanislaw Antol, Eric Pashman, Miguel Azevedo, Jianhua Liu, Nick King, Martin Zuther, Adam Zimmerman, Ratnakar Tiwari, Anurag Goel, Kelli Kratzer, Mark Griffiths, Roydan Ongie, Patryk Wolowiec, Mark Chonofsky, Russell Coleman, Wei Huang, Karen Barber, Nam Nguyen, Stéphane Morin, and Paul Stoop. 附 C 161