PCS0 如何安装Python

概述

Python是跨平台的动态脚本语言，可以运行在Windows、GNU/Linux、Unix、Mac OS X等多种操作系统上，下面就Python在Windows和GNU/Linux上的安装进行详细介绍。

使用

Windows下安装Python

在Windws下安装Python可以分为如下步骤：

(1) 下载。从这里可以下载到 for Windows x86的Python2.5.2。

(2) 下载完毕后，双击python-2.5.2.msi这个安装包，运行这个安装程序。出现安装提示：“是为所有用户安装Python，还是只为我自己”，在这里使用系统默认选项：Install for all users，也就是为所有用户安装Python，直接点击下一步。

(3) 选择安装目录，Python默认的安装目录是：“C:\Python25”，可以直接使用默认目录安装，也可以安装到不同的目录。这里选择默认安装目录，直接点击Next继续下面的安装。当然读者可以根据需要安装到其他目录。

(4) 接下来，选择的是需要安装的Python组件，使用系统默认选项全部安装，点击Next进入下一步。

(5) 出现进度条了，就表示开始安装Python了，需要等待一小会儿。

(6) 等待结束后，安装程序会提示Python安装完成，点击Finish来即可退出。

这样Windows下的Python安装完毕，在Windows的开始菜单->所有程序中即可找到Python25，启动他即可使用。若想在Windows下的命令行中使用python，则还需要设置Windows的环境变量Path。具体作如下设置：右击“我的电脑”->选择“属性”->选择“高级”->点击“环境变量”，弹出环境变量对话框->在系统变量中，双击“Path”条目，弹出对话框->在变量值中加入路径为“C:\python25;”，注意这边的路径是之前安装Python时选择的安装目录。

打开Windows的命令行，输入python，即可进入Python交互环境。

GNU/Linux下安装Python

一般情况下，无需自己安装Python。因为在大多数GNU/Linux版本中，如Fedora，Ubuntu等，都已经默认安装了Python，但可以根据需要自定义安装Python。下面使用源码编译安装来举个例子。

(1) 下载源码包。这里下载的是Python2.5.2版本的gzip压缩包，读者也可以下载 Python2.5.2版本的bzip2压缩包。

(2) 解压安装包。在终端进入压缩包所在目录，输入命令tar -zxvf Python-2.5.2.tgz (or bzcat Python-2.5.2.tar.bz2 | tar -xf -)，即可完成解压过程。

(3) 进入解压后的python目录，一般先看一下安装说明README，这里详细讲述了Python 2.5.2的相关资源及其网址和各种支持的操作系统下的安装方法。读者可以根据需求适当参考该文档。下面给出Python最普通的安装过程。

(4) ./configure，进行配置。这里有个最常设置的选项是prefix，默认值为/usr/local/lib，设置该选项来指定Python的安装目录，即./configure --prefix=$HOME/python2.5.2，$HOME为用户主目录。

(5) make，编译源码。若这边没出现什么错误即可进入下一步，若有错误的话，则可能有很多原因，比如当前系统缺少某些所需程序或者尚未解决某些依赖关系，这样的话得一步一步找出错误直至解决，才能编译正确。

(6) make install，真正安装。注意，若这里出现权限限制的话，则表明当前用户没有足够权限将Python程序文档文件写入指定的目录，比如说/usr/local/lib等系统目录，这样的话，需要sudo make install，输入密码后即可进行。因为之前设置了prefix为自己用户下的目录，所以直接make install就ok了。等待一段时间后，若没有错误提示就表明已经成功安装Python2.5.2。

(7) 成功安装后，在/home/shengyan/python2.5.2下就是刚刚安装的Python目录。在终端中进入/home/shengyan/python2.5.2目录，输入./python，即可进入Python交互环境，可以看到刚才安装的Python2.5.2。

若想在终端中直接输入python，启动的是Python2.5.2，而不是以前的旧版本，则可以有以下两个方法实现：

  • 方法一，修改环境变量PATH。若仅仅在终端下修改PATH，只对当前终端有效。若想在其他终端中或重启之后还有效的话，则需在用户目录的.bashrc文件末尾加入export PATH="/home/shengyan/python2.5/bin:$PATH"，注销或重启X就可。具体设置PATH的多种方法可参考http://blog.csdn.net/wangyifei0822/archive/2008/05/04/2386076.aspx(精巧地址: http://bit.ly/4ncZ3U)

  • 方法二，上述方法仅对当前用户环境进行设置，若想在系统上，全局使用Python2.5.2，则需以下步骤：

小结

本文详细介绍了在Windows和GNU/Linux下如何安装Python的方法。更多关于Python介绍及其安装可到以下网站查看:

PCS1 交互环境之命令行

概述

Python命令行，又称为Python Shell，是默认的Python交互环境。

使用

进入Python Shell

若在Windows下，假设已经安装好Python了，也设置好相应环境变量。若在GNU/Linux下，通常情况是已经安装好Python了，默认安装在/usr/bin/python下，该路径已经放进你的shell搜索路径中。

打开Windows的命令行或GNU/Linux的终端，输入python，即可进入Python交互式环境。

进入后，可以编写代码，调试，测试及查看相关帮助。若所做工作完成，退出命令行，可以使用Ctrl+z+Enter（Windows下）或Ctrl+D（GNU/Linux下）以0值退出（就是说，没有什么错误，正常退出）。如果这没有起作用，可以输入以下命令退出：“import sys; sys.exit()”。

使用交互环境

进入Python Shell后如上图所示，下面具体介绍如何使用该环境。

Python解释器根据主提示符来执行，主提示符通常标识为三个大于号（“>>> ”）；继续的部分被称为从属提示符，由三个点标识（“... ”）。在第一行之前，解释器打印欢迎信息、版本号和授权提示： 

Python 2.5.1 (r251:54863, Mar  7 2008, 04:10:12) 
[GCC 4.1.3 20070929 (prerelease) (Ubuntu 4.1.2-16ubuntu2)] on linux2
Type "help", "copyright", "credits" or "license" for more information.
>>>

输入多行结构时需要从属提示符了。例如，下面这个 if 语句：

>>> sayhi = True
>>> if sayhi:
...     print 'hi~python!'
... else:
...     print 'say nothing!'
... 
hi~python!

错误处理。若在调试使用过程中，有错误发生时，解释器打印一个错误信息，栈跟踪器及出错位置等，便于修改。 

>>> if sayhi:
...     print 'hi~python!'
... else:
... 
  File "<stdin>", line 4
    
    ^
IndentationError: expected an indented block
>>> import Mysqldb
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
ImportError: No module named Mysqldb
>>>

若在主提示符或附属提示符输入中断符（Control-c，抛出一个 keyboardinterrupt 异常，它可以被try句截获）就会取消当前输入，回到主命令行。

在Python Shell中可以很方便的查看Python文档，包括类型、类库、模块等等的使用资料。这些都是非常有用的。通过help("obj")就可以看到obj的帮助信息，就像系统Shell中的man帮助一样，提供了非常详细的资料。

小结

本文讲述了最基本的Python命令行使用方式，并描述了如何进入、使用、退出交互环境。这是非常简易的，很多情况下可以先在这里做些代码测试，通过后再进行脚本编辑。

PCS2 交互环境之iPython

概述

iPython是一个Python的交互式Shell，比默认的Python Shell好用得多，功能也更强大。她支持语法高亮，自动完成，代码调试，对象自省，支持 Bash Shell 命令，内置了许多很有用的功能和函式等等，非常容易使用。

使用

目前，最新稳定的iPython版本是0.8.4，支持多种操作系统，如GNU/Linux，Unix，Mac OS X，Windows等等，这里详细介绍在GNU/Linux和Windows下的安装过程。其他系统下的安装过程可参见http://ipython.scipy.org/moin/Download(精巧地址: http://bit.ly/1sRzxv)上的具体说明。

Windows下的iPython安装

在Windows下安装iPython可分为以下几步：

(1) 下载ipython-0.8.4.win32-setup.exe和pyreadline-1.5-win32-setup.exe。

(2) 双击运行安装程序，只需经过四步即可完成安装：

  • 显示一些提示信息，直接Next；

    输入Python安装目录及iPython安装位置，因为之前把Python默认安装“C:\Python25\”了，所以这里两个都为默认设置，直接Next。若之前Python不是在“C:\Python25\”需要改变为Python所在目录；

    出现进度条，需等待一会儿，完毕后Next；

    显示完成，成功安装iPython。

(3) 安装pyreadline。直接双击安装，如下图所示：

接下去，只需下一步直至安装完毕即可。

(4) 设置环境变量Path里面加上Python安装目录下面的scripts目录:

(5) 安装完成后，进入Windows命令行，输入ipython，即可以进入iPython交互环境。

GNU/Linux下的iPython安装

(1) 下载 ipython-0.8.4.tar.gz。

(2) 进入终端，输入如下几条命令，分别是解压、进入目录、编译、安装，一切ok的话就顺利安装iPython。 

~$ tar xvzf ipython-0.8.4.tar.gz
~$ cd ipython-0.8.4
~/ipython-0.8.4$ python setup.py build  #这步可以省略
~/ipython-0.8.4$ sudo python setup.py install

(3) 在Ubuntu下，可以通过输入命令sudo apt-get install ipython即可完成安装，非常方便。

使用iPython

在顺利安装好iPython之后，就可以进入该交互环境使用了。下面介绍在GNU/Linux下iPython的使用方式，Windows下也是很类似的。下面内容很多参考自：

非常不错的资料！

进入终端，输入ipython，即可进入如下图所示的iPython交互环境。

注意：若是第一次运行ipython时会自动生成配置目录 $HOME/.ipython，包含了一些配置文件适用于不同的环境：ipythonrc， ipythonrc-math， ipythonrc-numeric， ipythonrc-physics， ipythonrc-pysh， ipythonrc-scipy以及 ipythonrc-tutorial。先可以不用管它，直接使用默认就好了。

在交互环境中，和在Python默认交互环境中一样，编写代码进行调试、测试等等。但比默认Python环境好的几点是：

(1) Magic。iPython有一些"magic"关键字: 

%Exit, %Pprint, %Quit, %alias, %autocall, %autoindent, %automagic,
%bookmark, %cd, %color_info, %colors, %config, %dhist, %dirs, %ed,
%edit, %env, %hist, %logoff, %logon, %logstart, %logstate, %lsmagic,
%macro, %magic, %p, %page, %pdb, %pdef, %pdoc, %pfile, %pinfo, %popd,
%profile, %prun, %psource, %pushd, %pwd, %r, %rehash, %rehashx, %reset,
%run, %runlog, %save, %sc, %sx, %system_verbose, %unalias, %who,
%who_ls, %whos, %xmode

iPython会检查传给它的命令是否包含magic关键字。如果命令是一个magic关键字，iPython就自己来处理。如果不是magic关键字，就交给 Python 去处理。如果automagic打开（默认），不需要在magic关键字前加%符号。相反，如果automagic是关闭的，则%是必须的。在命令提示符下输入命令magic就会显示所有magic关键字列表以及它们的简短的用法说明。良好的文档对于一个软件的任何一部分来说都是重要的，从在线iPython用户手册到内嵌文档（%magic），iPython当然不会在这方面有所缺失。下面介绍些常用的magic函式，如： 

%bg function
    把function放到后台执行，例如: %bg myfunc(x, y, z=1)，之后可以用jobs将其结果取回。myvar = jobs.result(5) 或 myvar = jobs[5].result。另外，jobs.status() 可以查看现有任务的状态。
%ed 或 %edit
    编辑一个文件并执行，如果只编辑不执行，用 ed -x filename 即可。
%env
    显示环境变量
%hist 或 %history
    显示历史记录
%macro name n1-n2 n3-n4 ... n5 .. n6 ...
    创建一个名称为 name 的宏，执行 name 就是执行 n1-n2 n3-n4 ... n5 .. n6 ... 这些代码。
%pwd
    显示当前目录
%pycat filename
    用语法高亮显示一个 Python 文件(不用加.py后缀名)
%save filename n1-n2 n3-n4 ... n5 .. n6 ...
    将执行过多代码保存为文件
%time statement
    计算一段代码的执行时间
%timeit statement
    自动选择重复和循环次数计算一段代码的执行时间，太方便了。

(2) iPython中用!表示执行shell命令，用$将Python 的变量转化成 Shell 变量。通过这两个符号，就可以做到和Shell 命令之间的交互，可以非常方便地做许多复杂的工作。比如可以很方便地创建一组目录： 

for i in range(10):
    s = "dir%s" % i
    !mkdir $s

不过写法上还是有一些限制，$ 后面只能跟变量名，不能直接写复杂表达式，$"dir%s"%i 就是错误的写法了，所以要先完全产生 Python 的变量以后再用。例如： 

for i in !ls:
    print i

这样的写法也是错的，可以这样： 

a = !ls
for i in a:
    print i

还有一点需要说明，就是执行普通的 Shell 命令中如果有 $ 的话需要用两个 $。比如原来的echo $PATH现在得写成!echo $$PATH。

(3) Tab自动补全。iPython一个非常强大的功能是tab自动补全。标准Python交互式解释器也可以tab自动补全： 

~$ python
Python 2.5.1 (r251:54863, Mar  7 2008, 04:10:12) 
[GCC 4.1.3 20070929 (prerelease) (Ubuntu 4.1.2-16ubuntu2)] on linux2
Type "help", "copyright", "credits" or "license" for more information.
>>> import rlcompleter, readline
>>> readline.parse_and_bind('tab: complete')
>>> h
hasattr  hash     help     hex

标准Python交互式解释器和iPython都支持“普通”自动补全和菜单补全。

使用自动补全，要先输入一个匹配模型，然后按Tab键。如果是“普通”自动补全模式（默认），Tab后会：

  • 匹配模型按最大匹配展开。
  • 列出所有匹配的结果。

    例如：

    In [1]: import os

In [2]: os.po
os.popen os.popen2 os.popen3 os.popen4

In [2]: os.popen
    输入os.po然后按Tab键，os.po被展开成os.popen（就象在In [2]:提示符显示的那样），并显示os所有以po开头的模块，类和函式，它们是popen，popen2，popen3和popen4。

而菜单补全稍有不同。关闭默认Tab补全，使用菜单补全，需修改配置文件$HOME/.ipython/ipythonrc。 

注释掉：
readline_parse_and_bind tab: complete
取消注释:
readline_parse_and_bind tab: menu-complete

不同于“普通”自动补全的显示当前命令所有匹配列表，菜单补全会随着每按一次Tab键而循环显示匹配列表中的项目。例如：

In [1]: import os

In [2]: os.po

结果是：

In [3]: os.popen

接下来每次按Tab键就会循环显示匹配列表中的其它项目：popen2，popen3，popen4，最后回到po。菜单补全模式下查看所有匹配列表的快捷键是Ctrl-L。

(4) 自省。Python有几个内置的函式用于自省。iPython不仅可以调用所有标准Python函式，对于那些Python shell内置函式同样适用。典型的使用标准Python shell进行自省是使用内置的dir()函式： 

>>> import SimpleXMLRPCServer
>>> dir(SimpleXMLRPCServer.SimpleXMLRPCServer)
['__doc__', '__init__', '__module__', '_dispatch',
'_marshaled_dispatch', 'address_family', 'allow_reuse_address',
'close_request', 'fileno', 'finish_request', 'get_request',
'handle_error', 'handle_request', 'process_request',
'register_function', 'register_instance',
'register_introspection_functions', 'register_multicall_functions',
'request_queue_size', 'serve_forever', 'server_activate', 'server_bind',
'server_close', 'socket_type', 'system_listMethods',
'system_methodHelp', 'system_methodSignature', 'system_multicall',
'verify_request']

因为dir()是一个内置函式，在 iPython中也能很好的使用它们。但是iPython的操作符?和??功能还要强大： 

In [3]: import SimpleXMLRPCServer

In [4]: ? SimpleXMLRPCServer
Base Class:       <type 'module'>
String Form:   <module 'SimpleXMLRPCServer' from '/usr/lib/python2.5/SimpleXMLRPCServer.pyc'>
Namespace:        Interactive
File:             /usr/lib/python2.5/SimpleXMLRPCServer.py
Docstring:
    Simple XML-RPC Server.
    
    This module can be used to create simple XML-RPC servers
    by creating a server and either installing functions, a
    class instance, or by extending the SimpleXMLRPCServer
    class.
    
    It can also be used to handle XML-RPC requests in a CGI
    environment using CGIXMLRPCRequestHandler.
    
    A list of possible usage patterns follows:
    
    1. Install functions:
    
    server = SimpleXMLRPCServer(("localhost", 8000))
    server.register_function(pow)
    server.register_function(lambda x,y: x+y, 'add')
:

?操作符会截断长的字符串。相反，??不会截断长字符串，如果有源代码的话还会以语法高亮形式显示它们。

(5) 历史。当在iPython shell下交互的输入了大量命令，语句等等，就象这样： 

In [1]: a = 1

In [2]: b = 2

In [3]: c = 3

In [4]: d = {}

In [5]: e = []

In [6]: for i in range(20):
   ...:     e.append(i)
   ...:     d[i] = b
   ...:

可以输入命令“hist”快速查看那些已输入的历史记录： 

In [7]: hist
1: a = 1
2: b =2
3: c = 3
4: d = {}
5: e = []
6:
for i in range(20):
    e.append(i)
    d[i] = b
    
7: _ip.magic("hist ")

要去掉历史记录中的序号（这里是1至7），使用命令“hist -n”: 

In [8]: hist -n
a = 1
b =2
c = 3
d = {}
e = []
for i in range(20):
    e.append(i)
    d[i] = b
    
_ip.magic("hist ")
_ip.magic("hist -n")

这样就可方便的将代码复制到一个文本编辑器中。要在历史记录中搜索，可以先输入一个匹配模型，然后按Ctrl-P。找到一个匹配后，继续按Ctrl-P会向后搜索再上一个匹配，Ctrl-N则是向前搜索最近的匹配。

(6) 编辑。当在Python提示符下试验一个想法时，经常需要通过编辑器修改源代码（甚至是反复修改）。在iPython下输入edit就会根据环境变量$ EDITOR调用相应的编辑器。如果$EDITOR为空，则会调用vi（Unix）或记事本（Windows）。要回到iPython提示符，直接退出编辑器即可。如果是保存并退出编辑器，输入编辑器的代码会在当前名字空间下被自动执行。如果不想这样，使用edit -x。如果要再次编辑上次最后编辑的代码，使用edit -p。在上一个特性里，提到使用hist -n可以很容易的将代码拷贝到编辑器。一个更简单的方法是edit加Python列表的切片（slice）语法。假定hist输出如下： 

In [29]: hist
1 : a = 1
2 : b = 2
3 : c = 3
4 : d = {}
5 : e = []
6 :
for i in range(20):
e.append(i)
d[i] = b

7 : %hist

现在要将第4，5，6句代码导出到编辑器，只要输入： 

edit 4:7

(7) Debugger接口。iPython 的另一特性是它与Python debugger的接口。在iPython Shell下输入magic关键字pdb就会在产生一个异常时开关自动debugging功能。在自动pdb呼叫启用的情况下，当Python遇到一个未处理的异常时Python debugger就会自动启动。在debugger中的当前行就是异常发生的那一行。iPython的作者说有时候当他需要在某行代码处debug时，他会在开始debug的地方放一个表达式1/0。启用pdb，在iPython中运行代码。当解释器处理到1/0那一行时，就会产生一个 ZeroDivisionError异常，然后他就在指定的代码处被带到一个debugging session中了。

(8) 运行。有时候在一个交互式Shell中时，如果可以运行某个源文件中的内容将会很有用。运行magic关键字run带一个源文件名就可以在iPython解释器中运行一个文件了（例如run <源文件> <运行源文件所需参数>）。参数主要有以下这些：

  • -n 阻止运行源文件代码时__name__变量被设为"__main__"。这会防止if __name__ == "__main__":块中的代码被执行;

  • -i 源文件在就当前iPython的名字空间下运行而不是在一个新的名字空间中。如果你需要源代码可以使用在交互式session中定义的变量就会很有用。
  • -p 使用Python的profiler模块运行并分析源代码。使用该选项代码不会运行在当前名字空间。

(9) 宏。宏允许用户为一段代码定义一个名字，这样可在以后使用这个名字来运行这段代码。就象在magic关键字edit中提到的，列表切片法也适用于宏定义。假设有一个历史记录如下： 

In [3]: hist
1: l = []
2:
for i in l:
print i

可以这样来定义一个宏： 

In [4]: macro print_l 2
Macro `print_l` created. To execute, type its name (without quotes).
Macro contents:
for i in l:
print i

运行宏： 

In [5]: print_l
------> print_l()

在这里，列表l是空的，所以没有东西被输出。但这其实是一个很强大的功能，赋予列表l某些实际值，再次运行宏就会看到不同的结果： 

In [7]: l = range(5)

In [8]: print_l
------> print_l()
0
1
2
3
4

当运行一个宏时就好象你重新输入了一遍包含在宏print_l中的代码。它还可以使用新定义的变量l。由于Python语法中没有宏结构（也许永远也不会有），在一个交互式shell中它更显得是一个有用的特性。

(10) 环境（Profiles）。就象早前提到的那样，iPython安装了多个配置文件用于不同的环境。配置文件的命名规则是ipythonrc-。要使用特定的配置启动iPython，需要这样： 

ipython -p

一个创建自己环境的方法是在$HOME/.ipython目录下创建一个iPython配置文件，名字就叫做ipythonrc-，这里是你想要的环境的名字。如果同时进行好几个项目，而这些项目又用到互不相同的特殊的库，这时候每个项目都有自己的环境就很有用了。也可以为每个项目建立一个配置文件，然后在每个配置文件中import该项目中经常用到的模块。

(11) 使用操作系统的Shell。使用默认的iPython配置文件，有几个Unix Shell命令（当然，是在Unix系统上），cd，pwd和ls都能象在bash下一样工作。运行其它的shell命令需要在命令前加!或!!。使用magic关键字%sc和%sx可以捕捉shell命令的输出。pysh环境可以被用来替换掉shell。使用-p pysh参数启动的iPython，可以接受并执行用户$PATH中的所有命令，同时还可以使用所有的Python模块，Python关键字和内置函式。例如，想要创建500个目录，命名规则是从d_0_d到d_499_d，可以使用-p pysh启动iPython，然后就象这样： 

[~/ttt]|1> for i in range(500):
                      |.>     mkdir d_${i}_d
                      |.>

这就会创建500个目录： 

[~/ttt]|2> ls -d d* | wc -l
500

注意这里混合了Python的range函式和Unix的mkdir命令。注意，虽然ipython -p pysh提供了一个强大的shell替代品，但它缺少正确的job控制。在运行某个很耗时的任务时按下Ctrl-z将会停止iPython session而不是那个子进程。

最后，退出iPython。输入Ctrl-D（会要求你确认），也可以输入Exit或Quit（注意大小写）退出而不需要确认。

小结

经过本文对iPython的特性及其基本的使用方法的介绍，已经充分感受到iPython的强大功能了吧！那么，就把她作为一个有利的工具帮助我们开发吧！对于进一步的配置和更多的用途，有兴趣的同学可以在网络上发掘更丰富的资料。

Contents

  1. PCS3 交互环境之winpy
    1. 概述
    2. 使用
    3. 小结

PCS3 交互环境之winpy

概述

ActivePython是标准的Python发行版，在Windows，GNU/Linux ，Mac OS X等等都能使用。

使用

这里只介绍ActivePython在Windows下的安装：

(1) 下载ActivePython.

(2) 双击安装文件，运行安装程序。该过程和很多软件在Windows下的安装很类似，在这里就不描述了。主要注意的地方是在ActivePython安装时需选对Python路径（这表示事先得安装好Python），其他都可以默认。

(3) 安装完毕。打开ActivePython的PythonWin，可以看到如下的界面：

其中包含的一个交互界面，其使用方式和Python默认环境非常类似。具体可参考PCS1。

小结

ActivePython是一个不错的Python编辑器和运行调试工具。界面比较简单，但功能对于初学者来说已经足够了。

PCS4 常用自省

概述

自省，简单来说是自我检查。Python提供这个强大的功能，方便程序员查看各个对象的信息。常用自省函式有help()、dir()、type()、id()等等。

使用

help()

用来查看很多Python自带帮助文档信息，可以使用help()。 

~$ ipython
Python 2.5.2 (r252:60911, May  7 2008, 15:19:09) 
Type "copyright", "credits" or "license" for more information.

IPython 0.8.2 -- An enhanced Interactive Python.
?         -> Introduction and overview of IPython's features.
%quickref -> Quick reference.
help      -> Python's own help system.
object?   -> Details about 'object'. ?object also works, ?? prints more.

In [1]: help("str")

In [2]: import pygments

In [3]: help("pygments")

如上所示，可以在Python交互环境中，输入help("obj")后即可看到obj的帮助信息。就像bash中man随机帮助页一样。另外，也可以直接help()，进入帮助实用程序。如下： 

In [4]: help()

Welcome to Python 2.5!  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://www.python.org/doc/tut/.

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> keywords

Here is a list of the Python keywords.  Enter any keyword to get more help.

and                 elif                if                  print
as                  else                import              raise
assert              except              in                  return
break               exec                is                  try
class               finally             lambda              while
continue            for                 not                 with
def                 from                or                  yield
del                 global              pass

dir()

可以列出对象的所有属性。 

In [6]: import os

In [7]: dir(os)
Out[7]: 
['EX_CANTCREAT',
 'EX_CONFIG',
 'EX_DATAERR',
 'EX_IOERR',
 'EX_NOHOST',
 'EX_NOINPUT',
......

type()

返回对象的类型。 

In [8]: type(os)
Out[8]: <type 'module'>

id()

返回对象的 "唯一序号"。其中，对于引用对象来说，返回的是被引用对象的id()。 

In [29]: a = 'abc'

In [30]: b = a

In [31]: id(a)
Out[31]: 137472992

In [32]: id(b)
Out[32]: 137472992

hasattr()和getattr()

分别是判断对象是否有某个属性及获得某个属性值。 

In [35]: hasattr(a, 'split')
Out[35]: True

In [36]: getattr(a, 'split')
Out[36]: <built-in method split of str object at 0x831abe0>

callable()

判断对象是否可以被调用。 

In [37]: callable(a)
Out[37]: False

In [38]: callable(a.split)
Out[38]: True

isinstance()

可以确认某个变量是否某种类型。 

In [44]: isinstance(a, str)
Out[44]: True

In [45]: isinstance(a, int)
Out[45]: False

小结

以上这些都是常用的自身方法，还有其他的可参见相关资源:

PCS5 Python脚本文件

概述

脚本一般都是以文本形式存在的文件。它不经过像C语言那样编译成二进制文件执行，而是由特定解释器对脚本解释执行，所以只要系统上有相应的解释器就可以做到跨平台。Python脚本比较特殊的是，在直接执行Python脚本时是解释执行，但若该脚本中导入了另一个模块时，这个模块会产生.pyc字节码文件。

使用

以下是一个普通Python脚本文件，实现合并多个html为可用文本。 

   1 #!/usr/bin/python
   2 # -*- coding: utf-8 -*-
   3 
   4 """ Html To Text
   5 @author: lizzie
   6 @contract: [email protected]
   7 @see: ...
   8 @version:0.1
   9 """
  10 import os
  11 from html2text import *
  12 import chardet
  13 import sys
  14 
  15 reload(sys)
  16 sys.setdefaultencoding('utf8')
  17 
  18 YAHOO_DIR = 'J:\\yahoo_data\\'
  19 YAHOO_TXT = YAHOO_DIR+ 'txt\\all.txt'
  20 
  21 def html_to_txt():
  22     """将多个html文件合并为一个txt文件，统一编码为utf-8 or ascii
  23     """
  24     ft = open(YAHOO_TXT, 'w')
  25     start = 1
  26     while 1:
  27         filename = YAHOO_DIR+ str(start) + '.html'
  28         if os.path.isfile(filename):
  29             fp = open(filename, 'r')
  30             htmltxt = ''.join(fp.readlines())
  31             if not htmltxt or not len(htmltxt):
  32                 continue
  33             fp.close()
  34 
  35             codedetect = chardet.detect(htmltxt)["encoding"]                            #检测得到修改之前的编码方式
  36             print codedetect
  37             if not codedetect in ['utf-8', 'ascii']:
  38                 htmltxt = unicode(htmltxt, codedetect).encode('utf-8')
  39                 codedetect = chardet.detect(htmltxt)["encoding"]                        #检测得到修改之后的编码方式
  40                 print 'change', codedetect
  41 
  42             ft.write(html2txt(htmltxt))
  43             print 'Success change html to txt %s' % start
  44             start += 1
  45         else:
  46             break
  47     ft.close()
  48 
  49 if __name__ == '__main__':
  50     html_to_txt()

接下来依次介绍Python脚本的各个部分：

#!/usr/bin/python这句话表示该脚本文件用哪个解释器来执行，这边是Python解释器。另一种写法是#!/usr/bin/env python，两种写法是有区别的。

# -*- coding: utf-8 -*-指定字符编码方式。有关字符编码方式和字符集的相关知识参见PCS6和以下这个链接

import os表示导入os模块。from html2text import *、import chardet、import sys同样是导入相应模块。这里的html2txt实现了将某个html文件去除html标签，提取可用信息，转变成纯文本。

定义全局变量。全局变量通常用大写字母来标识。

定义函式。其中:表示函式开始，函式内利用缩进体现块与块之间的不同。#后表示注释。

最后调用函式执行。

执行脚本。在命令行中输入python pcs-5-1.py就可以执行。

小结

Python脚本文件的结构是非常清晰的，很容易掌握。

PCS6 Python与中文

概述

中文编码总是个大问题。不过Python可以完美的支持中文，不管你的字符编码是GB2312，GBK 或者UTF-8。在这里，不准备讲述有关ASCII/Unicode编码和中文编码问题，这两部分内容可以分别参考:

上的描述。下面介绍Python中的中文编码问题。

使用

Python中文编码转换，主要有以下四个对象来处理字符串转换操作等。 

class str(basestring)
 |  str(object) -> string
 |  
 |  Return a nice string representation of the object.
 |  If the argument is a string, the return value is the same object.
......
class unicode(basestring)
 |  unicode(string [, encoding[, errors]]) -> object
 |  
 |  Create a new Unicode object from the given encoded string.
 |  encoding defaults to the current default string encoding.
 |  errors can be 'strict', 'replace' or 'ignore' and defaults to 'strict'.
......
encode(...)
    S.encode([encoding[,errors]]) -> object
    
    Encodes S using the codec registered for encoding. encoding defaults
    to the default encoding. errors may be given to set a different error
    handling scheme. Default is 'strict' meaning that encoding errors raise
    a UnicodeEncodeError. Other possible values are 'ignore', 'replace' and
    'xmlcharrefreplace' as well as any other name registered with
    codecs.register_error that is able to handle UnicodeEncodeErrors.
decode(...)
    S.decode([encoding[,errors]]) -> object
    
    Decodes S using the codec registered for encoding. encoding defaults
    to the default encoding. errors may be given to set a different error
    handling scheme. Default is 'strict' meaning that encoding errors raise
    a UnicodeDecodeError. Other possible values are 'ignore' and 'replace'
    as well as any other name registerd with codecs.register_error that is
    able to handle UnicodeDecodeErrors.

str表示将某对象转换成字符串表示。

unicode表示将某个字符串按照某个编码方式转换为一unicode对象，unicode是内部编码，世界上所有字符的统一编码集，即每个字符都有唯一的二进制表示，可以在http://www.unicode.org/上查到某个字符的unicode码。

在Python 中，如果要正确显示中文字符，简单做法就是把字符串先转化为unicode，然后再由unicode 对象转化成任意其他你的系统可以显示你的编码。如果你的操作系统是GNU/Linux的，只能正确显示UTF-8，而你要显示的文本是从一个Windows系统下过来的GB2312编码的，那么你要做的就是将GB2312转化成unicode,然后由unicode转化成UTF-8，就可以正确显示了。 

In [26]: f = open('test')

In [27]: line = f.readline()

In [28]: uline = unicode(line, 'gb2312')

In [29]: uline
Out[29]: u'lines: 0.838643\n'

In [30]: u8line = uline.encode('utf-8')

In [31]: u8line
Out[31]: 'lines: 0.838643\n'

encode将对象按照指定编码进行编码

decode将对象按照指定编码进行解码。 

In [6]: s = "你好"

In [7]: s.decode("gbk")
Out[7]: u'\u6d63\u72b2\u30bd'

In [8]: s.decode("gbk").encode("utf-8")
Out[8]: '\xe6\xb5\xa3\xe7\x8a\xb2\xe3\x82\xbd'

# 或者
In [12]: s = "你好"

In [13]: unicode(s, "gbk")
Out[13]: u'\u6d63\u72b2\u30bd'

In [14]: unicode(s, "gbk").encode("utf-8")
Out[14]: '\xe6\xb5\xa3\xe7\x8a\xb2\xe3\x82\xbd'

小结

字符编码是个比较绕人的问题，因为世界上有太多不同的编码方式，如果全世界统一用一个字符集和一种编码实现方式，那么就不会有这么多问题了，但这是不可能的。有关字符编码的知识还可以在下面的链接中找到更多:

PCS7 Python编码规范

概述

本文参考自 Python 增进提案仓库 008 号文件的倡议.

在这简要叙述一下各个要点。

使用

Python 八荣八耻

以动手实践为荣 , 以只看不练为耻;
以打印日志为荣 , 以单步跟踪为耻;
以空格缩进为荣 , 以制表缩进为耻;
以单元测试为荣 , 以人工测试为耻;

以模块复用为荣 , 以复制粘贴为耻;
以多态应用为荣 , 以分支判断为耻;
以Pythonic为荣 , 以冗余拖沓为耻;
以总结分享为荣 , 以跪求其解为耻;

这首诗出自于

非常简明的指出了学习Python的多个注意点。

一致性的建议

愚蠢得使用一致性是无知的妖怪(A Foolish Consistency is the Hobgoblin of Little Minds)。这里的一致性主要是指一个项目内的一致性和一个模块或函式内的一致性，相对于前者而言，后者更为重要。但最重要的是:知道何时会不一致。当出现不一致时，运用自己的最佳判断，看看别的例子，然后决定怎样看起来更好。

代码的布局

缩进

建议使用Emacs的Python-mode默认值：4个空格一个缩进层次。对于确实古老的代码，若不希望产生混乱，可以继续使用8空格的制表符。在Emacs的Python-mode中会自动发现文件中主要的缩进层次，依此设定缩进参数。如果使用其他的编辑器，如vim、gedit、ulipad等，非常建议设置为4个空格为一个缩进层次。

制表符还是空格

永远不要混用制表符和空格，因为如果混用了，虽然在编辑环境中显示两条语句为同一缩进层次，但因为制表符和空格的不同导致Python解释为两个不同的层次。

最流行的Python缩进方式是仅使用空格，其次是仅使用制表符。若一定要混合使用制表符和空格，可以将其转换成仅使用空格。如在Emacs中，选中整个缓冲区，按ESC-x去除制表符。或者在调用Python命令行解释器时使用-t选项，可对代码中不合法得混合制表符和空格发出警告，使用-tt时警告将变成错误，这些选项是被高度推荐的。但是强烈推荐仅使用空格而不是制表符。

行的最大长度

有许多设备被限制在每行80字符，窗口也限制在80个字符，因此，建议将所有行限制在最大79字符(Emacs准确得将行限制为长80字符)。

对顺序排放的大块文本(文档字符串或注释)，推荐将长度限制在72字符。折叠长行的首选方法是使用Pyhon支持的圆括号，方括号或花括号内的行延续。如果需要，可以在表达式周围增加一对额外的圆括号，但是使用反斜杠看起来会更好，比如下面这个例子:

   1         class Rectangle(Blob):
   2                 def __init__(self, width, height,
   3                              color='black', emphasis=None, highlight=0):
   4                         if width == 0 and height == 0 and \
                           color == 'red' and emphasis == 'strong' or \
                           highlight > 100:
   5                                 raise ValueError, "sorry, you lose"
   6                         if width == 0 and height == 0 and (color == 'red' or
   7                                                            emphasis is None):
   8                                 raise ValueError, "I don't think so"
   9                         Blob.__init__(self, width, height,
  10                                       color, emphasis, highlight)

空行

用两行空行分割顶层函式和类的定义，类内方法的定义用单个空行分割。

额外的空行可被用于分割一组相关函式。在一组相关的单句中间可以省略空行。

当空行用于分割方法的定义时，在'class'行和第一个方法定义之间也要有一个空行。

在函式中使用空行时，请谨慎的用于表示一个逻辑段落。Python接受contol-L(即^L)换页符作为空格；Emacs(和一些打印工具) 视这个字符为页面分割符，因此在文件中，可以用他们来作为相关片段分页。

导入

通常应该在单独的行中导入，例如： 

No:  import sys, os
Yes: import sys
        import os

但是这样也是可以的：

   1 from types import StringType, ListType

Imports 通常被放置在文件的顶部，仅在模块注释和文档字符串之后，在模块的全局变量和常量之前。Imports应该有顺序地成组安放，顺序依次为：标准库的导入、 相关的主包的导入、特定应用的导入。同时建议在每组导入之间放置一个空行。

对于内部包的导入是不推荐使用相对路径导入，而对所有导入都要使用包的绝对路径。

从一个包含类的模块中导入类时，通常可以写成这样： 

   1 from MyClass import MyClass
   2 from foo.bar.YourClass import YourClass

如果这样写导致了本地名字冲突，那么就这样写：

   1 import MyClass
   2 import foo.bar.YourClass

即可以使用MyClass.MyClass和foo.bar.YourClass.YourClass这种写法。

空格

建议不要在以下地方出现空格：

  • 紧挨着圆括号,方括号和花括号的,如:spam( ham[ 1 ], { eggs: 2 } )要始终将它写成spam(ham[1], {eggs: 2})
  • 紧贴在逗号,分号或冒号前的,如:if x == 4 : print x , y ; x , y = y , x要始终将它写成if x == 4: print x, y; x, y = y, x
  • 紧贴着函式调用的参数列表前开式括号(open parenthesis )的,如spam (1).要始终将它写成spam(1)
  • 紧贴在索引或切片开始的开式括号前的,如:dict ['key'] = list [index]要始终将它写成dict['key'] = list[index]

在赋值(或其它)运算符周围的用于和其它并排的一个以上的空格,如: 

   1 x             = 1
   2 y             = 2
   3 long_variable = 3

要始终将它写成 

   1 x = 1
   2 y = 2
   3 long_variable = 3

始终在这些二元运算符两边放置一个空格:赋值(=), 比较(==, <, >, !=, <>, <=,>=, in, not in, is, is not), 布尔运算 (and, or, not).

在算术运算符周围插入空格. 始终保持二元运算符两边空格的一致.

不要在用于指定关键字参数或默认参数值的'='号周围使用空格

不要将多条语句写在同一行上，如： 

No:  if foo == 'blah': do_blah_thing()
Yes: if foo == 'blah':
            do_blah_thing()
No:  do_one(); do_two(); do_three()
Yes: do_one()
     do_two()
     do_three()

文档化

为所有公共模块,函式,类和方法编写文档字符串.文档字符串对非公开的方法不是必要的,但你应该有一个描述这个方法做什么的注释.

多行文档字符串结尾的""" 应该单独成行,例如: 

"""Return a foobang
Optional plotz says to frobnicate the bizbaz first.
"""

对单行的文档字符串,结尾的"""在同一行也可以.

版本注记

如果要将RCS或CVS的杂项包含在你的源文件中,按如下做: 

   1 __version__ = "$Revision: 1.4 $"
   2 # $Source: E:/cvsroot/python_doc/pep8.txt,v $

对于CVS的服务器工作标记更应该在代码段中明确出它的使用，如： 

在文档的最开始的版权声明后应加入如下版本标记：
# 文件：$id$
# 版本： $Revision$
这样的标记在提交给配置管理服务器后，会自动适配成为相应的字符串，如：
# 文件：$Id: ussp.py,v 1.22 2004/07/21 04:47:41 hd Exp $
# 版本： $Revision: 1.4 $

这些应该包含在模块的文档字符串之后,所有代码之前,上下用一个空行分割.

命名约定

以下的命名风格是众所周知的:

  • b (单个小写字母)
  • B (单个大写字母)
  • 小写串 如:getname
  • 带下划的小写串 如:_getname
  • 大写串 如:GETNAME
  • 带下划的大写串 如:_GETNAME

  • CapitalizedWords(首字母大写单词串)

  • mixedCase (混合大小写串)
  • Capitalized_Words_With_Underscores(带下划线的首字母大写串)

另外,以下用下划线作前导或结尾的特殊形式是被公认的(这些通常可以和任何习惯使用):

  • _single_leading_underscore(以一个下划线作前导): 弱的"内部使用(internal use)"标志.例如,"from M import *"不会导入以下划线开头的对象.

  • single_trailing_underscore_(以一个下划线结尾): 用于避免与Python关键词的冲突,例如"Tkinter.Toplevel(master, class_='ClassName')".

  • __double_leading_underscore(双下划线): 从Python 1.4起为类私有名.

  • __double_leading_and_trailing_underscore__: 特殊的(magic) 对象或属性,存在于用户控制的(user-controlled)名字空间, 例如:__init__, __import__ 或 __file__. 有时它们被用户定义, 用于触发某个特殊行为(magic behavior)(例如:运算符重载); 有时被构造器(infrastructure)插入,以便自己使用或为了调试. 因此,在未来的版本中,构造器(也可定义为Python解释器和标准库) 可能打算建立自己的魔法属性列表,用户代码通常应该限制将这种约定作为己用. 欲成为构造器的一部分的用户代码可以在下滑线中结合使用短前缀,例如：__bobo_magic_attr__.

应避免的名字: 永远不要用字符l(小写字母el(就是读音,下同)),O(大写字母oh),或I(大写字母eye)作为单字符的变量名. 在某些字体中,这些字符不能与数字1和0分开.当想要使用l时，用L代替它.

模块名: 模块应该是不含下划线的,简短的,小写的名字. 因为模块名被映射到文件名, 有些文件系统大小写不敏感并且截短长名字, 模块名被选为相当短是重要的---这在Unix上不是问题, 但当代码传到Mac 或Windows上就可能是个问题了. Python包应该是不含下划线的,简短的,全小写的名字.

类名:几乎没有例外，类名总是使用首字母大写单词串(CapWords)的约定.

异常名:如果模块对所有情况定义了单个异常,它通常被叫做"error"或"Error". 似乎内建的模块使用"error"(例如:os.error), 而Python模块通常用"Error" (例如: xdrlib.Error).

全局变量名:一般全部大写字母命名。

函式名:函式名应该为小写,可能用下划线风格单词以增加可读性.

方法名和实例变量:这段大体上和函式相同:通常使用小写单词,必要时用下划线分隔增加可读性. 使用一个前导下划线仅用于不打算作为类的公共接口的内部方法和实例变量. Python不强制要求这样; 它取决于程序员是否遵守这个约定. 使用两个前导下划线以表示类私有的名字. Python将这些名字和类名连接在一起:如果类Foo有一个属性名为 __a, 它不能以Foo.__a访问. 通常,双前导下划线应该只用来避免与类(为可以子类化所设计)中的属性发生名字冲突.

继承的设计:始终要确定一个类中的方法和实例变量是否要被公开. 通常,永远不要将数据变量公开,除非你实现的本质上只是记录. 人们总是更喜欢给类提供一个函式的接口作为替换. 同样,确定你的属性是否应为私有的.私有与非公有的区别在于: 前者永远不会被用在一个派生类中,而后者可能会. 私有属性必须有两个前导下划线,无后置下划线. 非公有属性必须有一个前导下划线,无后置下划线. 公共属性没有前导和后置下划线,除非它们与保留字冲突, 在此情况下,单个后置下划线比前置或混乱的拼写要好, 例如:class_优于klass.

其他建议

像None之类的单值进行比较,应该永远用:is或is not来做. 当你本意是if x is not None时,对写成if x要小心，例如当你测试一个默认为None的变量或参数是否被设置为其它值时. 这个其它值可能是一个在布尔上下文中为假的值!

基于类的异常总是好过基于字符串的异常. 模块和包应该定义它们自己的域内特定的基异常类, 基类应该是内建的Exception类的子类. 还始终包含一个类的文档字符串.例如: 

   1 class MessageError(Exception):
   2         """Base class for errors in the email package."""

使用字符串方法代替字符串模块,除非必须向后兼容Python 2.0以前的版本. 字符串方法总是非常快,而且和unicode字符串共用同样的API(应用程序接口)

在检查前缀或后缀时避免对字符串进行切片. 用startswith()和endswith()代替, 因为它们是明确的并且错误更少. 例如: 

No:  if foo[:3] == 'bar':
Yes: if foo.startswith('bar'):

对象类型的比较应该始终用isinstance()代替直接比较类型.例如:

No:  if type(obj) is type(1):
Yes: if isinstance(obj, int):

检查一个对象是否是字符串时,紧记它也可能是unicode字符串! 在Python 2.3, str和unicode有公共的基类,basestring,所以你可以这样做: 

   1 if isinstance(obj, basestring):

对序列,(字符串(strings),列表(lists),元组(tuples)), 使用空列表是false这个事实,因此if not seq或if seq比 if len(seq)或if not len(seq)好.

书写字符串文字时不要依赖于有意义的后置空格. 这种后置空格在视觉上是不可辨别的,并且有些编辑器会将它们修整掉.

不要用 == 来比较布尔型的值以确定是True或False。 

No:  if greeting == True:
Yes: if greeting:
No:  if greeting == True:
Yes: if greeting: