在Python open读写文件实现脚本

在实际使用open打开相关文件之后一定要记得要调用文件对象的close()的相关方法。比如可以用try/finally语句来确保最后是否能 关闭文件。以下就是文章的相关内容的详细接介绍，望你会有所收获。

file_object = open('thefile.txt')  
try:  
all_the_text = file_object.read( )  
finally:  
file_object.close( ) 

注：不能把open语句放在try块里，因为当打开文件出现异常时，文件对象file_object无法执行close()方法。

读文件

读文本文件

input = open('data', 'r') 

以上的相关代码就是Python open读写文件中实现脚本第二个参数默认为r

input = open('data') 

读二进制文件

input = open('data', 'rb') 

读取所有内容

file_object = open('thefile.txt')  
try:  
all_the_text = file_object.read( )  
finally:  
file_object.close( ) 

读固定字节

file_object = open('abinfile', 'rb')  
try:  
while True:  
chunk = file_object.read(100)  
if not chunk:  
break  
do_something_with(chunk)  
finally:  
file_object.close( ) 

以上就是对Python open读写文件实现脚本相关的内容的部分介绍，望你会有所收获。

北京网站建设公司

Python现在的位子可以说是高高在上，随着微软的开发我们将Python以纳入.Net 的相关平台，而在python中有很多库能被调用以高效的完成工作，我们坚信Python前景会更加强劲发展力。

Python前景

Python在编程领域的占有率一直处于稳步上升之中，根据最新的数据，Python排名第六。前五名分别是Java、C、VB、PHP和C++. 作为一个很年轻的语言，Python的位置已经相当令人振奋了。随着微软将Python纳入.Net 平台，相信Python前景会更加强劲发展。

Python 很可能会成为.Net平台快速开发的主流语言。欲了解这方面情况，请参考Iron Python的相关信息. 著名的搜索引擎 Google 也大量使用Python。更加令人吃惊的是，在Nokia智能手机所采用的Symbian操作系统上，Python成为继C++,Java之后的第三个编 程语言！2006年的Google编程大赛已经将Python作为参赛语言之一，可见Python的影响力之巨大。

Python库

由于设计者和开源社区的共同努力，在python中有大量优秀的库可以被直接调用以高效地完成不同需求的工作。这里列举一些常见常用的库：
Tkinter———— Python默认的图形界面接口。

Tkinter是一个和Tk接口的Python模块，Tkinter库提供了对Tk API的接口，它属于Tcl/Tk的GUI工具组。Tcl/Tk是由John Ousterhout发展的书写和图形设备。Tcl(工具命令语言)是个宏语言，用于简化shell下复杂程序的开发，Tk工具包是和Tcl一起开发的， 目的是为了简化用户接口的设计过程。Tk工具包由许多不同的小部件，如一个按钮、一个滚动条等。通过Tk提供的这些小部件，我们就可快速地进行GUI开 发。

Perl、Scheme等语言也利用Tk库进行GUI开发。Tkinter是跨平台，在各种平台下都能使用。Python Imaging Library(PIL)————python提供强大的图形处理的能力，并提供广泛的图形文件格式支持，该库能进行图形格式的转换、打印和显示。还能进 行一些图形效果的处理，如图形的放大、缩小和旋转等。是Python用户进行图象处理的强有力工具。

Pmw(Python megawidgets)Python超级GUI组件集————一个在python中利用Tkinter模块构建的高级GUI组件，每个Pmw都合并了一 个或多个Tkinter组件，以实现更有用和更复杂的功能。
PyXML———— 用Python解析和处理XML文档的工具包，包中的4DOM是完全相容于W3C DOM规范的。

Python库包含以下内容：

xmlproc: 一个符合规范的XML解析器。

Expat: 一个快速的，非验证的XML解析器。 还有其他

和他同级别的还有 PyHtml PySGML

PyGame———— 用于多媒体开发和游戏软件开发的模块。

PyOpenGL———— 模块封装了“OpenGL应用程序编程接口”，通过该模块python程序员可在程序中集成2D和3D的图形。

NumPy、NumArray和SAGE———— NumArray是Python的一个扩展库，主要用于处理任意维数的固定类型数组，简单说就是一个矩阵库。它的低层代码使用C来编写，所以速度的优势很 明显。NumPy是Numarray的后继者，用来代替NumArray。

SAGE是基于NumPy和其他几个工具所整合成的数学软件包，目标是取代 Magma, Maple, Mathematica和Matlab 这类工具。MySQLdb模块———— 用于连接MySQL数据库。还有用于zope的ZMySQLDA模块，通过它就可在zope中连接mysql数据库。

PyGTK ———— 用于python GUI程序开发的GTK+库。GTK就是用来实现GIMP和Gnome的那个库。有了它，你完全可以自信的尝试自己制造Photoshop

PyQt ———— 用于python的Qt开发库。QT就是实现了KDE环境的那个库，由一系列的模块组成，有qt, qtcanvas, qtgl, qtnetwork, qtsql, qttable, qtui and qtxml，包含有300个类和超过5750个的函数和方法。PyQt还支持一个叫qtext的模块，它包含一个QScintilla库。该库是 Scintillar编辑器类的Qt接口。

PyMedia ———— 用于多媒体操作的python模块。它提供了丰富而简单的接口用于多媒体处理(wav, mp3, ogg, avi, divx, dvd, cdda etc)。可在Windows和Linux平台下使用。

以上就是对Python前景与Python库相关的内容的介绍，望你会有所收获。

北京网站设计

Python显示 UTF-8中文文本对于大多数初学者来说是一件比较头疼的事情。不过，相信大家在了解了以下代码示例后，可以充分的掌握这一应用技术。那么接下来就让我们 一起来看看相关的操作技巧吧。

在掌握Python显示UTF-8中文文本这一技巧之前，首先让我们一起来看看Python语言的优点之处。

简单————Python是一种代表简单主义思想的语言。阅读一个良好的Python程序就感觉像是在读英语一样，尽管这个英语的要求非常严 格！Python的这种伪代码本质是它最大的优点之一。它使你能够专注于解决问题而不是去搞明白语言本身。

易学————就如同你即将看到的一样，Python极其容易上手。前面已经提到了，Python有极其简单的语法。

免费、开源————Python是FLOSS（自由/开放源码软件）之一。简单地说，你可以自由地发布这个软件的拷贝、阅读它的源代码、对它做改 动、把它的一部分用于新的自由软件中。FLOSS是基于一个团体分享知识的概念。这是为什么Python如此优秀的原因之一——它是由一群希望看到一个更 加优秀的Python的人创造并经常改进着的。

高层语言————当你用Python语言编写程序的时候，你无需考虑诸如如何管理你的程序使用的内存一类的底层细节。

可移植性————由于它的开源本质，Python已经被移植在许多平台上（经过改动使它能够工作在不同平台上）。如果你小心地避免使用依赖于系统的 特性，那么你的所有Python程序无需修改就可以在下述任何平台上面运行。这些平台包括Linux、Windows、FreeBSD、 Macintosh、Solaris、OS/2、Amiga、AROS、AS/400、BeOS、OS/390、z/OS、Palm OS、QNX、VMS、Psion、Acom RISC OS、VxWorks、PlayStation、Sharp Zaurus、Windows CE甚至还有PocketPC和Symbian！

解释性————这一点需要一些解释。一个用编译性语言比如C或C++写的程序可以从源文件（即C或C++语言）转换到一个你的计算机使用的语言（二 进制代码，即0和1）。这个过程通过编译器和不同的标记、选项完成。当你运行你的程序的时候，连接/转载器软件把你的程序从硬盘复制到内存中并且运行。而 Python语言写的程序不需要编译成二进制代码。你可以直接从源代码 运行 程序。在计算机内部，Python解释器把源代码转换成称为字节码的中间形式，然后再把它翻译成计算机使用的机器语言并运行。事实上，由于你不再需要担心 如何编译程序，如何确保连接转载正确的库等等，所有这一切使得使用Python更加简单。由于你只需要把你的Python程序拷贝到另外一台计算机上，它 就可以工作了，这也使得你的Python程序更加易于移植。

面向对象————Python既支持面向过程的编程也支持面向对象的编程。在“面向过程”的语言中，程序是由过程或仅仅是可重用代码的函数构建起来 的。在“面向对象”的语言中，程序是由数据和功能组合而成的对象构建起来的。与其他主要的语言如C++和Java相比，Python以一种非常强大又简单 的方式实现面向对象编程。

可扩展性————如果你需要你的一段关键代码运行得更快或者希望某些算法不公开，你可以把你的部分程序用C或C++编写，然后在你的Python程 序中使用它们。

可嵌入性————你可以把Python嵌入你的C/C++程序，从而向你的程序用户提供脚本功能。

丰富的库————Python标准库确实很庞大。它可以帮助你处理各种工作，包括正则表达式、文档生成、单元测试、线程、数据库、网页浏览器、 CGI、FTP、电子邮件、XML、XML-RPC、HTML、WAV文件、密码系统、GUI（图形用户界面）、Tk和其他与系统有关的操作。记住，只要 安装了Python，所有这些功能都是可用的。这被称作Python的“功能齐全”理念。除了标准库以外，还有许多其他高质量的库，如wxPython、 Twisted和Python图像库等等。

概括————Python确实是一种十分精彩又强大的语言。它合理地结合了高性能与使得编写程序简单有趣的特色。

Python显示UTF-8中文文本代码示例：

#!/usr/bin/env Python  
#coding=utf-8  
import sys  
reload(sys)   
sys.setdefaultencoding('utf8')  
def ConvertCN(s):  
return s.encode('gb18030')   
def PrintFile(filename):  
f = file(filename, 'r')  
for f_line in f.readlines():  
print ConvertCN(f_line)   
f.close()  
if __name__ == "__main__":   
PrintFile('1.txt')  
print ConvertCN("\n****** 按任意键退出! ******")  
sys.stdin.readline() 

以上就是我们为大家介绍的有关Python显示UTF-8中文文本的操作方法。

北京网站建设

题目难度不大，都是针对字符串的操作，逻辑比较简单，灵活在对不同语言、语法的掌握程度。（原文分别在：1，2。）

看了大家用C++、C#、Java等语言的实现，总感觉 牛刀杀鸡太麻烦，有兴趣的朋友可以自己写写看或者直接看原文的网友回复。我最近一段时间Python写的比较多，读到这些题目时候，就有一种跃跃欲试的冲 动。因为我知道用Perl，Python,Ruby等动态语言来做这类题目，会是非常理想的。后来我做了这两道题目，结果也令人满意，代码之简洁保持在所 有答案的前列。

先看第一题Python解答：

输出结 果：

a,2
c,2
b,2
e,1
d,1
g,1
f,1

Python的四行 代码分别做了dictionary的声明，赋值，字符串的遍历，以及高效拼接。

如果还没有看出它的简洁和强大的话，请看第二题的解法：

输出结 果：

0┊低┊举┊疑┊床┊静
9┊头┊头┊似┊前┊夜
0┊思┊望┊地 ┊明┊思
1┊故┊明┊上┊月┊
3┊乡┊月┊霜┊光┊李
1┊。┊，┊。┊，┊白

这题如果用C#等 实现，代码要在20行以上。下面我简单介绍一下这几行代码：

第3行，在Python里面二维“数组”通过嵌套list来实现，这里初始化 一个6行6列的二维数组；

第7行，我们把“矩阵”顺时针旋转了90度（行列置换，并且对置换后的行首尾对调-这里的::-1就是用来置 换一个list的trick）；

最后一行，我们把数组里的每行中元素，每行之间分别用两个不同字符拼接起来。join方法以及 for..in..语句在python中是相当常见的用法。

通过这两题，我们看到Python在处理字符串时候的十分灵活方便，虽然一 种语言的好坏不应完全靠是否简洁来衡量，但对于我个人而言，Python是目前我用过的最好的语言。而且对于趣味题来说，这不就是我们解题的趣味所在吗？

级别： 中级

Michael Galpin, 开发人员, eBay

2008 年 9 月 01 日

进 军社会软件是为应用程序增值的好方法。使用社会网络可以更轻松地获得并聚合数据，从而创建富有革新精神的新 Web 应用程序。但是，仍然必须处理创建可伸缩 Web 应用程序的所有常见问题。现在，使用 Google App Engine (GAE) 也可以简化工作。使用 GAE，可以不必考虑管理应用服务器池的所有事务。您不必担心存储大量静态内容和动态数据。相反，您可以将精力集中在创建优秀的 mashup 上。本文是共分三部分的系列文章 “使用 Eclipse 在 Google App Engine 上创建 mashup” 的第一部分，将了解如何开始开发 GAE 应用程序，以及如何使用 Eclipse 简化 GAE 开发。

关于本系列

在本系列中，将了解如何开始使用 Google App Engine (GAE)。在第 1 部分中，将了解如何设置开发环境，以便可以开始创建运行在 GAE 上的应用程序。了解如何使用 Eclipse 简化应用程序的开发和调试。在第 2 部分中，将使用 Eclipse 构建一个 Ajax mashup 并将其部署到 GAE 中。最后，在第 3 部分中，通过为应用程序创建 RESTful Web 服务返回到生态系统，这样其他人就可以使用它创建自己的 mashup。

GAE 是创建 Web 应用程序的平台。使用它的最重要的先决条件是具备 Python 知识，因为要在 GAE 中使用 Python 作为编程语言（目前为 Python V2.5.2）。对于本系列，具备一些典型的 Web 开发技能将会有帮助（例如，HTML、JavaScript 和 CSS 知识）。要针对 GAE 进行开发，需要下载三个软件包。

Eclipse Classic

我 使用的是 Eclipse Classic V3.3.2。更新的版本也可以使用。

Google App Engine SDK

阅 读 GAE 站点中的官方文档并查找下载 SDK 的链接。

PyDev

使 用更新站点 http://pydev.sourceforge.net/updates/ 从 Eclipse 内下载 PyDev，它可以将 Eclipse 转换为一个 Python IDE。

下面详细讨论了后两个软件包的安装。如果您刚开始使用 Eclipse，请参阅 参 考资料 获得入门。

设置 GAE

如果曾经花大量时间开发过 Web 应用程序，则很可能在想要开始使用新应用程序堆栈时习惯下载库、Web 服务器和数据库。有时，可以将所有这些包绑定到优秀的安装程序中，从而可以更轻松地使用所有活动部分。一切就绪后，通常需要进行更多的设置，才能正常使用 所喜爱的开发环境。幸运的是，使用 GAE 时不会遇到这种情况。让我们看看如何设置它以及如何将它和 Eclipse 结合起来。

设置 GAE 首先需要做的是下载 SDK，可用于 Microsoft® Windows®、Mac OS X 和 Linux®。对于 Windows 和 Mac OS X，SDK 是以安装程序出现的，不但要在系统中安装 SDK，而且要在路径中放置几个关键的可执行脚本以便使用。图 1 显示了 SDK 的目录结构图。
图 1. GAE SDK 目录结构

在根目录中，您应当会看到两个 Python 脚本：appcfg.py 和 dev_appserver.py。dev_appserver.py 脚本用于启动开发应用服务器。没有独立安装，也不需要为开发和测试应用程序进行部署。当您准备好将应用程序部署到 GAE 中时，将使用 appcfg.py 脚本。

您可以在 Google 目录中查找构成 GAE 平台基础的所有 API。您将不可避免地使用和扩展该目录中的类。因此，如果需要运行 GAE 应用程序代码，则需要知道该目录，因为需要了解应用程序代码所使用的 API。作为示例，让我们看一看如何设置用于开发 GAE 代码的 Eclipse。

设置 Eclipse

Eclipse 被称为开发 Java™ 编程语言应用程序的首要 IDE。但是，它不但适用于 Java 开发人员，而且还可以用于许多其他语言，包括 C++、PHP、Ruby 和 Python。实际上，有多个 Eclipse 插件可用于将 Eclipse 转换为 Python IDE。这些插件中最常见的是 PyDev。可以使用更新站点 http://pydev.sourceforge.net/updates/ 从 Eclipse 中安装该插件。

安装 PyDev 之后，需要配置它。打开 Eclipse 并转到 Preferences > PyDev。
图 2. 配置 PyDev

您需要把 Python 安装位置告诉 PyDev。转到 Interpreter > Python 并单击 New，如上所示。只需浏览到 Python V2.5+ 安装，然后 Eclipse 应当会执行剩余操作。单击 OK，然后您将准备好从 Eclipse 中开发 Python。

创建应用程序

首先在 Eclipse 中创建一个新 PyDev。通过选择 Windows > Open Perspective > Other 并从可用透视图列表中选择 PyDev 切换到 PyDev 透视图。
图 3. 打开 PyDev 透视图

现在应当能够通过选择 File > New > PyDev Project 创建新应用程序。在本例中，我们将为源代码创建一个单独的 src 文件夹，但这是可选的并且主要取决于个人习惯。到目前为止，所做的一切都是在 Eclipse 上进行的一般的 Python 开发。现在将开始执行一些特定于 GAE 的操作。

GAE 模板项目

GAE 项目的布局十分简单；只有一个没有子目录的目录。一定有三个文件：app.yaml、index.yaml 和 main.py。下面显示了第一个文件 app.yaml。
清单 1. app.yaml

application: aggrogator
version: 1
runtime: python
api_version: 1

handlers:
- url: .*
  script: main.py

这是 GAE 应用程序的主要配置文件。该文件中的大部分内容只需要设置一次，例如应用程序名称、版本和构建该应用程序所使用的 GAE API 的版本。需要更多处理的部分是 handlers 部分。这是 HTTP 请求 URL 和项目中的 Python 脚本之间的映射。在以上情况下，我们将把所有内容都映射到同一个 main.py 脚本中。该文件随后可以执行额外的路径以将 URL 与方法匹配在一起。

另一个 YAML 文件 index.yaml 用于帮助 GAE 高效地获取数据。实际上，即使没有这样一个文件也没有关系，因为如果遗漏了该文件，GAE 也会为您生成一个。现在无需对该文件进行任何操作，清单 2 显示了一个空的 index.yaml。
清单 2. index.yaml

indexes:

# AUTOGENERATED

# This index.yaml is automatically updated whenever the dev_appserver
# detects that a new type of query is run.  if you want to manage the
# index.yaml file manually, remove the above marker line (the line
# saying "# AUTOGENERATED").  If you want to manage some indexes
# manually, move them above the marker line.  The index.yaml file is
# automatically uploaded to the admin console when you next deploy
# your application using appcfg.py.

最后，我们将接触到应用程序的核心：main.py 脚本。实际上您可以给该脚本任意命名，只要它是与 app.yaml 同步的。通常都使用 main.py 名称，因此我们在这里也使用这个名称。在查看该文件之前，让我们先描述一下编写的应用程序的类型。

aggroGator

我们的应用程序名为 aggroGator。它将允许用户关联已经使用的各项 Web 服务。然后将从这些服务中获取数据提要并按时间顺序聚集这些数据提要。对于我们的应用程序，将使用常见的 FeedParser 库来解析提要。还将通过 Google 使用 GAE 的内置身份管理，因此无需编写自己的注册/登录/退出特性。用户将只使用 Google 身份进行登录。记住这一切之后，让我们看一看 main.py。
清单 3. main.py

def main():
  application = webapp.WSGIApplication(
                                       [('/', MainPage),
                                        ('/add', AddService)],
                                       debug=True)
  wsgiref.handlers.CGIHandler().run(application)

if __name__ == "__main__":
  main()

因此这实际上只是脚本的主要方法。该方法所做的是设置更多路径。在这种情况下，它将把 “/” 的请求发送到名为 MainPage 的类中，并把 “/add” 的请求发送到名为 AddService 的类中。现在让我们看一看 MainPage 类。
清单 4. MainPage

class MainPage(webapp.RequestHandler):
  def get(self):
    user = users.get_current_user()

    if users.get_current_user():
      url = users.create_logout_url(self.request.uri)
      url_linktext = 'Logout'
    else:
      url = users.create_login_url(self.request.uri)
      url_linktext = 'Login'

    updates = []
    account = None
    if user:
        account_query = Account.all()
        account_query.filter('user = ', users.get_current_user())
        result_set = account_query.fetch(1)
        if len(result_set) > 0:
            account = account_query.fetch(1)[0]

        if account:
            updates = []
            for service in account.dynamic_properties():
                url = getattr(account, service)
                feed = GenericFeed(url, service)
                updates.extend(feed.entries())
        else:
            account = Account()
            account.user = user
            account.put()
        updates.sort(key=attrgetter('timestamp'), reverse=True)

    template_values = {
      'account': account,
      'updates': updates,
      'url': url,
      'url_linktext': url_linktext,
      }

    path = os.path.join(os.path.dirname(__file__), 'index.html')
    self.response.out.write(template.render(path, template_values))

该类执行了很多操作，因为它是应用程序的主要控制器。首先需要注意的是它只有 get 方法。那意味着它只支持 HTTP GET 请求。对 “/” 执行 POST 将导致错误。接下来，它将检查身份。users 类是来自 GAE SDK 的 API。它将利用 Google 的身份管理。我们将使用它检查用户是否已登录。如果用户已登录，就会知道用户的身份（其 Google ID）。然后创建登录链接或者退出链接，这取决于他是否已登录。如果没有登录，则只显示登录链接；否则，继续查找帐户。下面是已经编写的另一个类：
清单 5. Account 类

class Account(db.Expando):
    user = db.UserProperty()

该类将利用 Google 的数据存储 API（Google 的著名 Bigtable 数据库）。Account 实体拥有 User 属性并且是 Expando Model。这将允许我们创建动态属性 — 用于每项服务的 URL。对于每项服务，将使用 GenericFeed 类检索条目列表，如下所示：
清单 6. GenericFeed 类

class GenericFeed:
    def __init__(self, url, name):
        self.url = url
        self.name = name
    def entries(self):
        result = urlfetch.fetch(self.url)
        updates = []
        if result.status_code == 200:
            feed = feedparser.parse(result.content)
            for entry in feed['entries']:
                x = Entry()
                x.service = self.name
                x.title = entry['title']
                x.link = entry['link']
                if entry.summary:
                    x.content = entry.summary
                else:
                    x.content = entry['title']
                x.timestamp = entry.updated_parsed
                updates.append(x)
        return updates

这是使用 FeedParser 库的类。在使用该库之前，我们将使用另外一个 GAE API：urlfetch 类。该类将允许 HTTP 请求，但只是 80 端口和 443 端口（用于安全请求）。只使用它对存储的 URL 执行 HTTP GET，然后将结果传递给 FeedParser 库。接着创建 Entry 类的实例，如下所示：
清单 7. Entry 类

class Entry:
    def __init__(self=None, title=None, link=None, timestamp=None,
content=None, service=None):
        self.title = title
        self.link = link
        self.content = content
        self.service = service
        self.timestamp = timestamp
    def printTime(self):
        return strftime('%B %d,%Y at %I:%M:%S %p',self.timestamp)

该类几乎只是一个简单的数据结构。它惟一的逻辑是拥有一个输出时间戳的方法。GenericFeed 类将返回与该用户相关的每项服务的 Entry 实例列表。然后按降序根据时间戳排序 Entries（第 一个是最新的 Entry）。返回到 MainPage，然后将若干个对象、用户的 Account、 排序后的 Entries 列表及登录/退出链接传递给模板。GAE 使用的模板系统类似于常见的 Python 框架 Django 所使用的模板系统。在本例中，将把数据传递给名为 index.html 的模板。
清单 8. index.html 模板

<html>
  <body>
    <a href="{{ url }}">{{ url_linktext }}</a>
    <ol>
     {% for update in updates %}
      <li>
       From {{update.service}}:
       <a href="{{update.link}}">{{update.content}}</a>
       posted at: {{update.printTime}}
      </li>
     {% endfor %}
    </ol>
    {% if account %}
     <form action="/add" method="post">
      <label for="service">Service: </label>
      <select name="service">
       <option>twitter</option>
       <option>del.icio.us</option>
       <option>last.fm</option>
       <option>YouTube</option>
      </select><br/>
      <label for="username">Username: </label>
      <input type="text" name="username"/>
      <input type="submit" value="Add"/>
     </form>
    {% endif %}
  </body>
</html>

这是一个简单的模板。它大部分只是 HTML，其中带有几个动态部分。首先，它将创建相应的登录/退出链接。接下来，它将遍历条目列表以将其显示给用户。最后，如果用户已登录，则创建允许用 户添加服务的表单。该表单将对 /add URL 执行 HTTP POST。如清单 3 所示，该请求将被发送到 AddService 控制器类中。
清单 9. AddService 控制器

class AddService(webapp.RequestHandler):
    def post(self):
        # check if user already exists
        account_query = Account.all()
        account_query.filter('user = ', users.get_current_user())
        result_set = account_query.fetch(1)
        if len(result_set) > 0:
            account = account_query.fetch(1)[0]
        else :
            account = Account()
            account.user = users.get_current_user()
        service = self.request.get('service')
        username = self.request.get('username')
        if service == 'twitter':
            service = 'http://twitter.com/statuses/user_timeline/'+username+'.rss'
            account.twitter = service
        if service =='del.icio.us':
            service = 'http://del.icio.us/rss/' + username
            account.del_icio_us = service
        if service == 'last.fm':
            service = 'http://ws.audioscrobbler.com/1.0/user/'+username+
                                              '/recenttracks.rss'
            account.last_fm = service
        if service == 'YouTube':
            service = 'http://www.youtube.com/rss/user/'+username+'/videos.rss'
            account.you_tube = service
        account.put()
        self.redirect('/')

该类将查找用户的帐户。然后根据使用的服务创建相应的 URL。使用 Expando 属性把该 URL 添加到帐户的服务中，并且把所有内容保存回 Bigtable 中。最后，重定向到 MainPage。

现在已经看过应用程序的所有代码，并且已经准备好运行。但是如何运行？Eclipse 将再次帮您轻松运行。

在本地进行测试

GAE SDK 将提供在本地运行项目的命令行工具。但是，我们希望利用 Eclipse，因此需要从 Eclipse 中运行所有内容。这将允许我们调试应用程序，稍后我们将看到。运行应用程序的第一步是编辑项目的 PYTHONPATH。完成 此操作的最简单方法是在项目上右键单击并选择 Properties。这将打开项目属性。
图 4. 项目属性

正如您所见，需要在左侧菜单中选择 PyDev – PYTHONPATH。然后需要 选择 Add source folder 并浏览到 GAE SDK 的安装位置。该位置将根据 OS 的不同而有所变化，并且可以自定义。对于 Windows，默认值（由安装程序设定）为 C:\Program Files\Google\AppEngine，而对于 OS X，默认值为 /usr/local/google_appengine。如果位于 Linux 中或者下载了 ZIP 而不是特定于 OS 的安装程序，请选择放置 SDK 的位置。可以是任意位置，但是需要让 Eclipse 知道该位置。该位置将称为 $APP_ENGINE_HOME。

现在，运行项目还需要做最后一件事：需要为它创建一个 Run 配置文件。为此，选择 Run > Open Run 对话框。
图 5. Run 对话框

该 Run 配置文件被称为 aggroGator。在 Main Module 下，浏览到 $APP_ENGINE_HOME 并选择 dev_appserver.py 脚本。这是模拟 GAE 生产环境的 Python 应用服务器。接下来，转到 Arguments 选项卡，如图 6 所示。
图 6. Arguments 选项卡

在 Program arguments 框中，输入 ${project_loc}/src。Eclipse 变量 ${project_loc} 仅指向当前项目的物理位置。需要将应用程序目录传递给 dev_appserver.py 脚本，因而传递给 /src。如果不把代码放到 src 目录中，则需要相应地调整实参。

现在已经准备好运行应用程序。如果单击 Run，则应当会在 Eclipse 控制台中看到清单 10 中的输出。
清单 10. 控制台输出

INFO     2008-06-08 05:00:29,236 appcfg.py] Server: appengine.google.com
INFO     2008-06-08 05:00:29,283 appcfg.py] Checking for updates to the SDK.
WARNING  2008-06-08 05:00:29,581 datastore_file_stub.py] Could not read datastore data
 from /var/folders/oo/ooKE4ln2HqC9exSMWxwprk+++TI/-Tmp-/dev_appserver.datastore
WARNING  2008-06-08 05:00:29,582 datastore_file_stub.py] Could not read datastore data
 from /var/folders/oo/ooKE4ln2HqC9exSMWxwprk+++TI/-Tmp-/dev_appserver.datastore.history
INFO     2008-06-08 05:00:29,606 dev_appserver_main.py] Running application aggrogator
 on port 8080: http://localhost:8080

注意，这段代码说明应用程序运行在 http://localhost:8080。在浏览器中转到该 URL 并尝试一下，如下所示：
图 7. aggroGator 欢迎屏幕

单击 Login 将显示图 8。
图 8. 登录屏幕

很明显，这是模拟的登录屏幕。您可以使用任意一个电子邮件地址，因为这不会实际访问 Google 身份验证服务。实际上，test@example.com 可以正常工作。登录后即可以开始添加服务。
图 9. 添加服务

现在可以通过添加服务开始玩转应用程序。如果返回到清单 8 的 AddService 控制器，各项服务提要的 URL 都是被硬编码到该类中。当然，这一切可以在将来改变，并且可能得到错误。这时有调试器会方便得多。让我们看一看如何将 Eclipse 调试器与 GAE 项目结合使用。

调试

使用诸如 Eclipse 之类的 IDE 的主要优点是更易于调试应用程序，甚至复杂的 Web 应用程序。首先需要为 GAE 项目做的是创建 Debug 配置文件。该配置文件类似于 Run 配置文件，因此只需选择项目并单击 Run > Open Debug 对话框。
图 10. Debug 对话框

Eclipse 将智能地把默认值设为先前创建的 Run 运行设置。无需修改，并且只需单击 Debug。 查看 Eclipse 控制台，并且应当会看到类似于清单 11 的一些输出。
清单 11. 调试输出

pydev debugger: warning: psyco not available for debugger speedups
pydev debugger: starting
INFO     2008-06-08 05:18:37,704 appcfg.py] Server: appengine.google.com
INFO     2008-06-08 05:18:37,755 appcfg.py] Checking for updates to the SDK.
INFO     2008-06-08 05:18:38,196 dev_appserver_main.py] Running application aggrogator
 on port 8080: http://localhost:8080

前两行显示 pydev 调试器的输出。现在可以在项目中设置断点并且开始调试。在图 11 中，我们将调试 AddService 控制器。
图 11. 调试 AddService

现在可以开始逐步调试代码并检查变量。如果任何一项服务发生更改，或者需要添加新服务，这将使您可以轻松地找到并修复错 误。

结束语

在本文中，很快就实现了一个完整的应用程序。Google App Engine SDK 已经安装并且与 Eclipse 连接在一起。这将允许我们快速编写、测试和调试代码。我们了解了 GAE 项目中的许多关键概念，包括 URL 路由、通过 URL 获取与外部站点进行交互、使用演示模板以及使用 Bigtable。我们的应用程序已经准备好部署到 GAE 中，将在第 2 部分中了解这些内容。

北京网站设计

作者：Martijn Faassen

译者：赖勇浩（http://blog.csdn.net/lanphaday）

原文地址：http://faassen.n–tree.net/blog/view/weblog/2005/08/06/0

注：Martijn 是 Zope 领域的专家，他为 Zope 系列产品做了许多开发工作，也开发了 lxml 等 多个开源产品。你可以在这里了解一下他的信息http://www.zope.org/Members/faassen。 这篇文章写于 2005 年，虽然有少部分内容（主要是例子）看起来已经有些过时，但即便是在今天，它的中心思想依然有极高的 指导意义。

这是几个月前在 EuroPython 邮件列表（主要用来组织和计划 EuroPython 会 议的邮件列表）出现的问题。这是一个非常有意思的问题，我看到这个词被无数次地使用，但鲜有人尝试解释它的含义。在这条线索之后，许多不同的人，包括我自 己，都给出了自己的答案。现在我把我的答案放到博客上，并且润色了一下，希望它能对您有所增益。

Pythonnic 是一 个模糊的概念，尽管没有“智能”或“生命”那么模糊，但当你尝试定义它们的时候，就像去抓住一条滑溜溜的泥鳅一样无从下手。可是虽然它们难以定义，然而并 不意味着它们没用，因为事实上人们其实极善于利用混乱的定义。Pythonic 有点像“Python惯 用法”的意味，现在让我们来聊聊它真正的含义。

随着时间的推移，Python语言不断演进，社区不断成长，涌现了许多关于如何正确地使用 Python 的 ideas。一方面 Python 语言推荐使用大量的惯用法来 完成任务（“完成任务的唯一方法”），另一方面，社区不断演变的新的惯用法的又反过来影响了语言的进化，以更好地支持惯用法。比如新进入的字典的 .get() 方法，它把 has_key() 和元素存取两个操作组合为一个操作，从中可以看出这种进化。

惯用法往往不能直接从其它编程语言移植过来。如下文是实现对一个序列里的每个元素执行一个操作的 C 语言实 现：

for (i=0; i < mylist_length; i++) {

do_something(mylist[i]);

}

直接的等效 Python 代码是这样的：

i = 0

while i < mylist_length:

do_something(mylist[i])

i += 1

这段代码能够完成工作，但并不 Pythonic，它并不是 Python 语言推荐的惯用法。让我们来改进一下。典型的 Python 惯用法是用内置的 range() 函数生成所有的序列下标：

for i in range(mylist_length):

do_something(mylist[i])

其实这种实现也并不 Pythonic，接下来大家看看语言推荐的实现方式，真正 Pythonic 实现：

for element in mylist:

do_something(element)

“如何直接传递或改变引用”是comp.lang.python 的“月经贴”，但在只有赋值（import、class、def 等语句也可视为赋值）的 Python 中这是不可能的。这种需求通常是因为想让函数返回多个值，用 C 或者许多其它编程语言的方法是给这个函数传入引用或指针：

void foo(int* a, float* b) {

*a = 3;

*b = 5.5;

}

…

int alpha;

int beta;

foo(&alpha, &beta);

在 Python 中可以用很囧很恶心的方法来实现：通过给函数传递序列参数来返回结果。写出来的代码可能像这样：

def foo(a, b):

a[0] = 3

b[0] = 5.5

alpha = [0]

beta = [0]

foo(alpha, beta)

alpha = alpha[0]

beta = beta[0]

显然这是毫无 Pythonic 可言的实现。Python 中让函数返回多个值的惯用法与此迥异，得益于元组和元组解包，它 看起来也要漂亮得多：

def foo():

return 3, 5.5

alpha, beta = foo()

在经验老到的 Python 程序员看来，不够 Pythonic 的代码往往看 起来古怪而且累赘，过于冗余也难以理解。因为它使用冗长的代码代替常见的、公认的、简短的惯用法来实现预期效果。更甚于此的是在语言支持正确的惯用法之 后，非推荐的代码通常执行起来更慢。

Pythonic 就是以 清晰、可读的惯用法应用Python 理念和数据结构。举个例子，应该多使用动态类型，在无必要之处引入静态类型就走向了另一 端。另外也要避免使用经验丰富的 Python 程序员不熟悉的方式去完成任务（即遵循最小惊奇原则）。

Pythonic 一词也 能够适用于底层的惯用法。一个 Pythonic 的库或框架能使程序员更加容易、更加自然地学会利用它来完成任务。如果用 Python 编写的库或框架迫使程序员编写累赘的或不推荐的代码，那么可以说它并不Pythonic。也许 可能是为了使这个库更加方便、易懂，而没有应用 Python 的一些理念，如类等，那也是不 Pythonic 的。类定义应当尽可能地实现信息隐藏，虽然 Python 的许多操作都只作“宽松限制”（通常由程序员在属 性的前面加上一个下划线来暗示这是私有成员），但也要做得像 Java 那样严格。

当然，当规模很大的时候，它是否 Pythonic 就极具争议性了。这里给出一些参考条款：如减少冗余，Python 的库与 APIs 都倾向于小型化和轻量化（相对于 java 程序库而言）。重 量级的、API过于细化的的Python 库并不 Pythonic。 比如 W3C XML DOM API，尽管它的 Python 实现已经颇有时日，但大家并不认为它 Pythonic。 有些人认为它是 Java 式的，虽然也有许多 Java 程序员认为并不如此。

一个Pythonic的框架不会对已经用惯用法完成的东西重复发明轮子，而且它也遵循常用的 Python 惯例。

当然，问题是构建框架时肯定会不可能避免地引入一些你不熟悉的模式和方法。Zope2 是我极为熟悉的一个框 架，它也是一个引入了许多完成工作的特定的方法（如 Acquisition）的例子，这些方法往往什么地方都用不到，因此许 多经验丰富的 Python 程序员认为它并不 Pythonic。

创建 Pythonic 的框架极其困难，什么理念更酷、更符合语言习惯对此毫无帮助，事实上这些年来优秀的 Python 代码的特性也在不断演化。比如现在认为像 generators、sets、unicode strings 和 datetime 之类的特性尤为 Pythonic。Zope2 的历史悠久，它从1997年开始开发，你不能把不够 Pythonic 归咎于 它，甚至考虑到这么多年来它控制得如此之好，更应该感谢它。

关于 Pythonicness 的新趋势的一个例子是Python 的包和模块 结构日益规范化。新的代码库如 Twisted、Zope3 和 PyPy 等 或多或少都跟随了这样的潮流：

• 包和模块的命名采用小写，单数形式，而且短小。
• 包通常仅仅作为命名空间，如只包含空的 __init__.py 文件。

在我写库（如 lxml）的时候也遵循了这样的惯例。

因为更多人认为一个 Python 程序员容易学习的功能不那么强大的框架比一个需要大量时间来学习的强大系 统更为 pythonic。所以有时我认为宣称软件不够 Pythonic 不公平，甚至可能会因 此而掩盖了该软件积极的一面。

最后，作为什么是 Pythonic 的扩充材料，可以尝试一下在 Python 解 释器里执行如下语句：

北京网站建设

#!/usr/local/bin/python

import httplib
import sys
import re
from HTMLParser import HTMLParser

class miniHTMLParser( HTMLParser ):

  viewedQueue = []
  instQueue = []

  def get_next_link( self ):
    if self.instQueue == []:
      return ''
    else:
      return self.instQueue.pop(0)

  def gethtmlfile( self, site, page ):
    try:
      httpconn = httplib.HTTPConnection(site)
      httpconn.request("GET", page)
      resp = httpconn.getresponse()
      resppage = resp.read()
    except:
      resppage = ""

    return resppage

  def handle_starttag( self, tag, attrs ):
    if tag == 'a':
      newstr = str(attrs[0][1])
      if re.search('http', newstr) == None:
        if re.search('mailto', newstr) == None:
          if re.search('htm', newstr) != None:
            if (newstr in self.viewedQueue) == False:
              print "  adding", newstr
              self.instQueue.append( newstr )
              self.viewedQueue.append( newstr )
          else:
            print "  ignoring", newstr
        else:
          print "  ignoring", newstr
      else:
        print "  ignoring", newstr

def main():

  if sys.argv[1] == '':
    print "usage is ./minispider.py site link"
    sys.exit(2)

  mySpider = miniHTMLParser()

  link = sys.argv[2]

  while link != '':

    print "\nChecking link ", link

    # Get the file from the site and link
    retfile = mySpider.gethtmlfile( sys.argv[1], link )

    # Feed the file into the HTML parser
    mySpider.feed(retfile)

    # Search the retfile here

    # Get the next link in level traversal order
    link = mySpider.get_next_link()

  mySpider.close()

  print "\ndone\n"

if __name__ == "__main__":
  main()

北京网站建设