Edit conflict - other version:

=Python Programming FAQ= ==一般问题== ===1.1.1 是否有源码级的调试器， 具有breakpoint, single-stepping等功能?===

Edit conflict - your version:

Python Programming FAQ

==1.1 一般问题 ==

• === 1.1.1 是否有源码级的调试器， 具有breakpoint, single-stepping等功能? ===

End of edit conflict

是的。 pdb模块是一个简单却功能强大的命令行模式的python调试器。它是标准python库的一部分, 在库参考手册有关于它的文档。作为一个实例，你也可以使用pdb的代码编写你自己的调试器。 作为标准python发行包的一部分（通常为Tools/scripts/idle），IDLE包含了一个图形界面的调试器。在http://www.python.org/idle/doc/idle2.html#Debugger有IDLE调试器的文档。 另一个Python IDE，PythonWin包含了一个基于pdb的GUI调试器。 Pythonwin 调试器对breakpoints作颜色标记，它还有一些很酷的特性，比如调试非python程序。可以参考http://www.python.org/windows/pythonwin/。最 新版本的PythonWin已作为ActivePython 发行包的一部分(见 http://www.activestate.com/Products/ActivePython/index.html)。 Boa Constructor 是一个使用wxPython的IDE和GUI builder。它提供了可视化的框架创建和操作，一个对象探查器，多种代码视图比如对象浏览器，继承架构，doc string创建的html文档，一个高级调试器，继承帮助和Zope支持。 Eric3 是基于PyQt和Scintilla editing组件的一个IDE。 Pydb是python标准调试器pdb的一个版本, 与DDD (Data Display Debugger, 一个流行的调试器图形界面)一起工作。Pydb 可以在http://packages.debian.org/unstable/devel/pydb.html找到，DDD可以在 http://www.gnu.org/software/ddd找到. 还有很多包含图形界面的商业版本Python IDE。包括: Wing IDE (http://wingide.com) Komodo IDE (http://www.activestate.com/Products/Komodo)

Edit conflict - other version:

===1.1.2 是否有工具可以帮助找到bug或者做静态分析?===

Edit conflict - your version:

• === 1.1.2 是否有工具可以帮助找到bug或者做静态分析? ===

End of edit conflict

是的. PyChecker是一个静态分析器，它可以找出python代码中的bug并对代码的复杂性和风格作出警告。可以在 http://pychecker.sf.net找到它. 另一个工具Pylint 检查一个模块是否满足编码规范，而且支持插件扩展。除了PyChecker能提供的bug检查外，Pylint 还提供额外的特性比如检查代码行长度，变量名是否符合代码规范，声明的接口是否都已实现等。http://www.logilab.org/projects/pylint/documentation 提供了关于Pylint特性的一个完整列表。

Edit conflict - other version:

===1.1.3 如何 由python脚本创建一个单独的二进制文件?===

Edit conflict - your version:

• === 1.1.3 如何 由python脚本创建一个单独的二进制文件? ===

End of edit conflict

如果你只是希望用户运行一个单独的程序而不需要预先下载一个python的发行版，则并不需要将Python代码编译成C代码。有很多工具可以找出程序依赖的模块并将这些模块跟程序绑定 在一起以产生一个单独的执行文件。 其中一种工具就是freeze tool, 它作为Tools/freeze被包含在python的代码树中。它将python字节 码转换成C数组，和一个可将你所有模块嵌入到一个新程序中的编译器，这个编译器跟python模块链接在一起。 它检查import语句，递归地扫描源代码，并查找在标准python路径中的模块和源代码目录中的模块（内建模块）。用python写的模块的字节码随后被转换成C代码（可以通过使用marshal模块转换成代码对象的数组构建器），并产生一个只包含程序确切使用的模块的可自定义配置文件。 最后编译生成的C代码并且链接至余下的的python解释器以产生一个与你的script执行效果完全一样的单独文件。 显然，freeze需要一个C编译器。但也有一些工具并不需要。首先便是Gordon McMillan's installer，它在 http://www.mcmillan-inc.com/install1.html 它工作在Windows, Linux和至少是部分Unix变种上。 另一个便是Thomas Heller的 py2exe (只适用于Windows平台)，它在 http://starship.python.net/crew/theller/py2exe 第三个是Christian Tismer的 SQFREEZE，它将字节码附在一个 特殊的python解释器后面，这个特殊的解释器负责找到这段代码。Python 2.4可能会引入类似的机制。 其它工具包括Fredrik Lundh的 Squeeze 和 Anthony Tuininga的 cx_Freeze.

Edit conflict - other version:

===1.1.4 是否有 关于python程序的代码标准或风格向导?=== 是的。标准库模块要求的代码风格被列在PEP 8. ===1.1.5 程序执行速度太慢，如何改善?===

Edit conflict - your version:

• === 1.1.4 是否有 关于python程序的代码标准或风格向导? ===

是的。标准库模块要求的代码风格被列在PEP 8.

• === 1.1.5 程序执行速度太慢，如何改善? ===

End of edit conflict

总的来说这是个复杂的问题。有很多技巧可以提升python的速度，比如可以考虑用C重写某些部分。 在某些情况下将python转换成C或x86汇编语言是可能的，这意味着您不需要修改代码就可获得速度提升。 Pyrex 可以将稍许改动过的python码转换成C扩展，并可以在很多平台上使用。 Psyco 是一个即时编译器，可将python码转换成x86汇编语言。如果你可以使用它， Psyco 可使关键函数有明显的性能提升。 剩下的问题就是讨论各种可稍许提升python代码速度的技巧。在profile指出某个特定函数是一个经常执行的热点后，除非你明确需要，否则不要应用任何优化措施，优化经常会使代码变得不清晰，您不应该承受这样做所带来的负担（延长的开发时间，更多可能的bug），除非优化结果确实值得你这样做。 Skip Montanaro有一个专门关于提升python代码速度的网页，位于 http://manatee.mojam.com/~skip/python/fastpython.html。 Guido van Rossum 写了关于提升python代码速度的内容，在http://www.python.org/doc/essays/list2str.html。 还有件需要注意的事，那就是函数特别是方法调用的代价相当大；如果你设计了一个有很多小型函数的纯面向对象的接口，而这些函数所做的不过是对实例变量获取或赋值，又或是调用另一个方法，那么你应该考虑使用更直接的方式比如直接存取实例变量。也可参照profile模块（在Library Reference manual中描述)，它 可找出程序哪些部分耗费大多数时间（如果你有耐性的话--profile本身会使程序以数量级的幅度变慢）。 记住很多从其它语言中学到的标准优化方法也可用于python编程。比如，在执行输出时通过使用更大块的写入来减少系统调用会加快程序速度。因此CGI脚本一次性的写入所有输出就会比写入很多次小块输出快得多。 同样的，在适当的情况下使用python的核心特性。比如，通过使用高度优化的C实现，slicing允许程序在解释器的mainloop的一个滴答中，切割list和其它sequence对象。因此 ，为取得同样效果，使用

   1 ---- /!\ '''Edit conflict - other version:''' ----
   2 {{{
   3 #!python
   4 
   5 ---- /!\ '''Edit conflict - your version:''' ----
   6 
   7 ---- /!\ '''End of edit conflict''' ----
   8 L2 = []
   9 for i in range[3]:
  10      L2.append(L1[i])
  11 
  12 ---- /!\ '''Edit conflict - other version:''' ----

就比使用

   1 L2 = list(L1[:3]) # "list" is redundant if L1 is a list.

更短且快得多。 注意，内建函数如map(), zip(), 和friends 在执行一个单独循环的任务时，可被作为一个方便的加速器。比如将两个list配成一对：

   1 >>> zip([1,2,3], [4,5,6])
   2 [(1, 4), (2, 5), (3, 6)]

或在执行一系列的正弦计算时：

   1 >>> map( math.sin, (1,2,3,4))
   2 [0.841470984808, 0.909297426826, 0.14112000806,   -0.756802495308]

Edit conflict - your version:

}}} 就比使用

   1 L2 = list(L1[:3]) # "list" is redundant if L1 is a list.

更短且快得多。 注意，内建函数如map(), zip(), 和friends 在执行一个单独循环的任务时，可被作为一个方便的加速器。比如将两个list配成一对：

   1 >>> zip([1,2,3], [4,5,6])
   2 [(1, 4), (2, 5), (3, 6)]

或在执行一系列的正弦计算时：

   1 >>> map( math.sin, (1,2,3,4))
   2 [0.841470984808, 0.909297426826, 0.14112000806,   -0.756802495308]

End of edit conflict

在这些情况下，操作速度会很快。 其它的例子包括string对象的 join() 和 split() 方法。例如，如果s1..s7 是大字符串(10K+)那么join([s1,s2,s3,s4,s5,s6,s7])就会比s1+s2+s3+s4+s5+s6+s7快得多, 因为后者会计算很多次子表达式，而join() 则在一次过程中完成所有的复制。对于字符串操作，对字符串对象使用replace() 方法。仅当在没有固定字符串模式时才使用正则表达式。考虑使用字符串格式化操作string % tuple 和 string % dictionary. 确定使用内建方法list.sort() 来排序，参考sorting mini-HOWTO 中关于较高级的使用例子。除非在极特殊的情况下， list.sort()比其它任何技术都要好。 另一个技巧就是"将循环放入函数或方法中" 。例如，假设你有个运行的很慢的程序，而且你使用profiler确定函数ff()占用了很多时间。如果你注意到ff()：

   1 ---- /!\ '''Edit conflict - other version:''' ----
   2 {{{
   3 #!python
   4 
   5 ---- /!\ '''Edit conflict - your version:''' ----
   6 
   7 ---- /!\ '''End of edit conflict''' ----
   8 def ff(x):
   9     ...do something with x computing result...
  10     return result
  11 
  12 ---- /!\ '''Edit conflict - other version:''' ----

常常是在循环中被调用，如:

   1 list = map(ff, oldlist)

或:

   1 ---- /!\ '''Edit conflict - your version:''' ----

常常是在循环中被调用，如:

   1 list = map(ff, oldlist)

或:

   1 ---- /!\ '''End of edit conflict''' ----
   2 for x in sequence:
   3     value = ff(x)
   4     ...do something with value...
   5 
   6 ---- /!\ '''Edit conflict - other version:''' ----

那么你可以通过重写ff()来消除函数的调用开销：

   1 ---- /!\ '''Edit conflict - your version:''' ----

那么你可以通过重写ff()来消除函数的调用开销：

   1 ---- /!\ '''End of edit conflict''' ----
   2 def ffseq(seq):
   3     resultseq = []
   4     for x in seq:
   5         ...do something with x computing result...
   6         resultseq.append(result)
   7     return resultseq
   8 
   9 ---- /!\ '''Edit conflict - other version:''' ----

并重写以上两个例子：

   1 list = ffseq(oldlist)

和

   1 for value in ffseq(sequence):
   2     ...do something with value...

单独的对ff(x)调用被翻译成ffseq([x])[0]，几乎没有额外开销。当然这个技术并不总是合适的，还是其它的方法。 你可以通过将函数或方法的定位结果精确地存储至一个本地变量来获得一些性能提升。一个循环如：

   1 for key in token:
   2     dict[key] = dict.get(key, 0) + 1

每次循环都要定位dict.get。如果这个方法一直不变，可这样实现以获取一个小小的性能提升：

   1 ---- /!\ '''Edit conflict - your version:''' ----

并重写以上两个例子：

   1 list = ffseq(oldlist)

和

   1 for value in ffseq(sequence):
   2     ...do something with value...

单独的对ff(x)调用被翻译成ffseq([x])[0]，几乎没有额外开销。当然这个技术并不总是合适的，还是其它的方法。 你可以通过将函数或方法的定位结果精确地存储至一个本地变量来获得一些性能提升。一个循环如：

   1 for key in token:
   2     dict[key] = dict.get(key, 0) + 1

每次循环都要定位dict.get。如果这个方法一直不变，可这样实现以获取一个小小的性能提升：

   1 ---- /!\ '''End of edit conflict''' ----
   2 dict_get = dict.get  # look up the method once
   3 for key in token:
   4     dict[key] = dict_get(key, 0) + 1
   5 
   6 ---- /!\ '''Edit conflict - other version:''' ----

默认参数可在编译期被一次赋值，而不是在运行期。这只适用于函数或对象在程序执行期间不被改变的情况，比如替换

   1 def degree_sin(deg):
   2     return math.sin(deg * math.pi / 180.0)

为

   1 def degree_sin(deg, factor = math.pi/180.0, sin = math.sin):
   2     return sin(deg * factor)

因为这个技巧对常量变量使用了默认参数，因而需要保证不会传递给用户一个混乱的API。 ==1.2 核心语言== ===1.2.1 如何在一个函数中设置一个全局变量?=== 你是否做过类似的事？

   1 ---- /!\ '''Edit conflict - your version:''' ----

默认参数可在编译期被一次赋值，而不是在运行期。这只适用于函数或对象在程序执行期间不被改变的情况，比如替换

   1 def degree_sin(deg):
   2     return math.sin(deg * math.pi / 180.0)

为

   1 def degree_sin(deg, factor = math.pi/180.0, sin = math.sin):
   2     return sin(deg * factor)

因为这个技巧对常量变量使用了默认参数，因而需要保证不会传递给用户一个混乱的API。

1.2 核心语言

• === 1.2.1 如何在一个函数中设置一个全局变量? ===

你是否做过类似的事？

   1 ---- /!\ '''End of edit conflict''' ----
   2 x = 1 # make a global
   3 
   4 def f():
   5       print x # try to print the global
   6       ...
   7       for j in range(100):
   8            if q>3:
   9               x=4
  10 
  11 ---- /!\ '''Edit conflict - other version:''' ----

任何函数内赋值的变量都是这个函数的local变量。除非它专门声明为global。作为函数体最后一个语句，x被赋值，因此编译器认为x为local变量。而语句 print x 试图 print一个未初始化的local变量，因此会触发 NameError 异常。 解决办法是在函数的开头插入一个明确的global声明。

   1 ---- /!\ '''Edit conflict - your version:''' ----

任何函数内赋值的变量都是这个函数的local变量。除非它专门声明为global。作为函数体最后一个语句，x被赋值，因此编译器认为x为local变量。而语句 print x 试图 print一个未初始化的local变量，因此会触发 NameError 异常。 解决办法是在函数的开头插入一个明确的global声明。

   1 ---- /!\ '''End of edit conflict''' ----
   2 def f():
   3       global x
   4       print x # try to print the global
   5       ...
   6       for j in range(100):
   7            if q>3:
   8               x=4
   9 
  10 ---- /!\ '''Edit conflict - other version:''' ----

在这种情况下，所有对x的引用都是模块名称空间中的x。 ===1.2.2 python中local和global变量的规则是什么?=== 在Python中, 某个变量在一个函数里只是被引用，则认为这个变量是global。如果函数体中变量在某个地方会被赋值，则认为这个变量是local。如果一个global变量在函数体中 被赋予新值，这个变量就会被认为是local，除非你明确地指明其为global。 尽管有些惊讶，我们仍需对其简单地描述一下。一方面，对于被赋值的变量，用关键字 global 是为了防止意想不到的边界效应。另一方面，如果对所有的global引用都需要关键字global，则会不停地使用global关键字。需要在每次引用内建函数或一个import的模块组建时都声明global。global声明 是用来确定边界效应的，而这样混乱的用法会抵消这个作用。 ===1.2.3 如何在模块间共享global变量?=== 在一个单独程序中，各模块间共享信息的标准方法是创建一个特殊的模块（常被命名为config和cfg）。仅需要在你程序中每个模块里import这个config模块。 因为每个模块只有一个实例，这个模块的任何改变将会影响所有的地方。例如:

   1 ---- /!\ '''Edit conflict - your version:''' ----

在这种情况下，所有对x的引用都是模块名称空间中的x。

• === 1.2.2 python中local和global变量的规则是什么? ===

在Python中, 某个变量在一个函数里只是被引用，则认为这个变量是global。如果函数体中变量在某个地方会被赋值，则认为这个变量是local。如果一个global变量在函数体中 被赋予新值，这个变量就会被认为是local，除非你明确地指明其为global。 尽管有些惊讶，我们仍需对其简单地描述一下。一方面，对于被赋值的变量，用关键字 global 是为了防止意想不到的边界效应。另一方面，如果对所有的global引用都需要关键字global，则会不停地使用global关键字。需要在每次引用内建函数或一个import的模块组建时都声明global。global声明 是用来确定边界效应的，而这样混乱的用法会抵消这个作用。

• === 1.2.3 如何在模块间共享global变量? ===

在一个单独程序中，各模块间共享信息的标准方法是创建一个特殊的模块（常被命名为config和cfg）。仅需要在你程序中每个模块里import这个config模块。 因为每个模块只有一个实例，这个模块的任何改变将会影响所有的地方。例如:

   1 ---- /!\ '''End of edit conflict''' ----
   2 config.py:
   3 x = 0   # Default value of the 'x' configuration setting
   4 
   5 mod.py:
   6 import config
   7 config.x = 1
   8 
   9 main.py:
  10 import config
  11 import mod
  12 print config.x
  13 
  14 ---- /!\ '''Edit conflict - other version:''' ----

注意，由于同样的原因，使用模块也是实现Singleton设计模式的基础。 ===1.2.4 什么是import模块的最好方式?===

Edit conflict - your version:

}}} 注意，由于同样的原因，使用模块也是实现Singleton设计模式的基础。

• === 1.2.4 什么是import模块的最好方式? ===

End of edit conflict

通常情况下，不要使用from modulename import * 这种格式。这样做会使引入者的namespace混乱。很多人甚至对于那些专门设计用于这种模式的模块都不采用这种方式。被设计成这种模式的模块包括Tkinter, 和 threading. 在一个文件的开头引入模块。这样做使得你的你的代码需要哪些模块变得清晰，并且避免了模块名称是否存在的问题。 在每行只使用一次import使得添加和删除模块import更加容易，但每行多个import则减少屏幕空间的使用。 应该按照以下顺序import模块： 标准库模块 -- 如 sys, os, getopt 等 第三方模块(安装在python的site-packages目录下) -- 如 mx.DateTime, ZODB, PIL.Image, 等。 本地实现模块。 不要使用相对的import。如果你在编写package.sub.m1 模块的代码并想 import package.sub.m2, 不要只是 import m2, 即使这样是合法的。用 from package.sub import m2 代替. 相对的imports会导致模块被初始化两次，并产生奇怪的bug。 有时需要将import语句移到函数或类中来防止import循环。 Gordon McMillan 说: 在两个模块都使用 "import <module>" 格式时是没问题的 。但若第二个模块想要获取第一个模块以外的一个名称("from module import name")且这个import语句位于最 顶层时，则会产生错误 。因为这时第一个模块的名称并不处于有效状态，因为第一个模块正忙于import第二个模块。 在这种情况下，如果第二个模块只是用在一个函数中，那么可以简单地把这个import移入这个函数。当这个import被调用时，第一个模块已经完成了初始化，而第二个模块 则可以完成它的import语句了。 如果某些模块是系统相关的，那么将import移出顶层代码也是必要的。在那种情况下，甚至不可能在文件的顶层import所有的模块。在这种情况下，在对应的系统相关代码中引入这些模块则是个好的选择。 在解决诸如防止import循环或试图减少模块初始化时间等问题，且诸多模块并不需要依赖程序是如何执行的情况下，这种方法尤其有用。如果模块只是被用在某个函数中，你也可以将import移到这个函数中。注意首次import模块会花费较多的时间，但多次地import则几乎不会再花去额外的时间，而只是需要两次的字典查询操作。即使模块名称已经处在scope外，这个模块也很有可能处在sys.modules中。 如果只是某个类的实例使用某个模块，则应该在类的init 方法里import模块并把这个模块赋给一个实例变量以使这个模块在对象的整个生命周期内一直有效（通过这个实例变量）。注意要使import推迟到类的实例化，必须将import放入某个方法中。在类 里所有方法之外的地方放置import语句，仍然会在模块初始化的时候执行import。

Edit conflict - other version:

===1.2.5 如何将某个函数的选项或键值参数传递到另一个函数?=== 在函数的参数列表中使用 * 和 ** ；它将你的位置参数作为一个tuple，将 键值参数作为一个字典。当调用另一个函数时你可以通过使用 * 和 **来传递这些参数：

   1 ---- /!\ '''Edit conflict - your version:''' ----
   2  ===  1.2.5   如何将某个函数的选项或键值参数传递到另一个函数? ===  
   3 在函数的参数列表中使用 * 和 ** ；它将你的位置参数作为一个tuple，将 键值参数作为一个字典。当调用另一个函数时你可以通过使用 * 和 **来传递这些参数：
   4 {{{
   5 #!python
   6 
   7 ---- /!\ '''End of edit conflict''' ----
   8 def f(x, *tup, **kwargs):
   9         ...
  10         kwargs['width']='14.3c'
  11         ...
  12         g(x, *tup, **kwargs)
  13 
  14 ---- /!\ '''Edit conflict - other version:''' ----

如果考虑到比python的2.0更老的版本的特殊情况，使用'apply':

   1 ---- /!\ '''Edit conflict - your version:''' ----

如果考虑到比python的2.0更老的版本的特殊情况，使用'apply':

   1 ---- /!\ '''End of edit conflict''' ----
   2 def f(x, *tup, **kwargs):
   3         ...
   4         kwargs['width']='14.3c'
   5         ...
   6         apply(g, (x,)+tup, kwargs)
   7 
   8 ---- /!\ '''Edit conflict - other version:''' ----

===1.2.6 如何编写一个带有输出参数的函数（传引用调用）?=== 记住在python中参数传递是动过赋值实现的。因为赋值仅是创建一个新的对对象的引用，所以在调用者和被调用者之间没有任何的别名可以使用，因此从本质上说没有传引用调用。但你可以通过一系列的方法来实现这个效果。 对结果传递一个tuple:

   1 ---- /!\ '''Edit conflict - your version:''' ----

• === 1.2.6 如何编写一个带有输出参数的函数（传引用调用）? ===

记住在python中参数传递是动过赋值实现的。因为赋值仅是创建一个新的对对象的引用，所以在调用者和被调用者之间没有任何的别名可以使用，因此从本质上说没有传引用调用。但你可以通过一系列的方法来实现这个效果。 对结果传递一个tuple:

   1 ---- /!\ '''End of edit conflict''' ----
   2 def func2(a, b):
   3     a = 'new-value'        # a and b are local names
   4     b = b + 1              # assigned to new objects
   5     return a, b            # return new values
   6 
   7 x, y = 'old-value', 99
   8 x, y = func2(x, y)
   9 print x, y                 # output: new-value 100
  10 
  11 ---- /!\ '''Edit conflict - other version:''' ----

Edit conflict - your version:

}}}

End of edit conflict

这通常是最清晰的方法。 通过使用global变量。这不是线程安全的，所以不推荐。 传递一个可变对象:

   1 ---- /!\ '''Edit conflict - other version:''' ----
   2 {{{
   3 #!python
   4 
   5 ---- /!\ '''Edit conflict - your version:''' ----
   6 
   7 ---- /!\ '''End of edit conflict''' ----
   8 def func1(a):
   9     a[0] = 'new-value'     # 'a' references a mutable list
  10     a[1] = a[1] + 1        # changes a shared object
  11 
  12 args = ['old-value', 99]
  13 func1(args)
  14 print args[0], args[1]     # output: new-value 100
  15 
  16 ---- /!\ '''Edit conflict - other version:''' ----

传递一个可变字典：

   1 ---- /!\ '''Edit conflict - your version:''' ----

传递一个可变字典：

   1 ---- /!\ '''End of edit conflict''' ----
   2 def func3(args):
   3     args['a'] = 'new-value'     # args is a mutable dictionary
   4     args['b'] = args['b'] + 1   # change it in-place
   5 
   6 args = {'a':' old-value', 'b': 99}
   7 func3(args)
   8 print args['a'], args['b']
   9 
  10 ---- /!\ '''Edit conflict - other version:''' ----

或者是将它绑定在一个类的实例中：

   1 ---- /!\ '''Edit conflict - your version:''' ----

或者是将它绑定在一个类的实例中：

   1 ---- /!\ '''End of edit conflict''' ----
   2 class callByRef:
   3     def __init__(self, **args):
   4         for (key, value) in args.items():
   5             setattr(self, key, value)
   6 
   7 def func4(args):
   8     args.a = 'new-value'        # args is a mutable callByRef
   9     args.b = args.b + 1         # change object in-place
  10 
  11 args = callByRef(a='old-value', b=99)
  12 func4(args)
  13 print args.a, args.b
  14 
  15 ---- /!\ '''Edit conflict - other version:''' ----

但这样会使程序变得复杂，不是个好方法。 你最好的方式还是返回一个包含多个结果的tuple。 ===1.2.7 如何使用python中更高 阶的函数?=== 有两个选择：你可以使用内嵌的方式或使用可调用对象。比如，假设你想定义 linear(a,b)， 它返回计算a*x+b 的函数f(x)。使用内嵌的方法：

   1 ---- /!\ '''Edit conflict - your version:''' ----

但这样会使程序变得复杂，不是个好方法。 你最好的方式还是返回一个包含多个结果的tuple。

• === 1.2.7 如何使用python中更高 阶的函数? ===

有两个选择：你可以使用内嵌的方式或使用可调用对象。比如，假设你想定义 linear(a,b)， 它返回计算a*x+b 的函数f(x)。使用内嵌的方法：

   1 ---- /!\ '''End of edit conflict''' ----
   2 def linear(a,b):
   3     def result(x):
   4         return a*x + b
   5     return result
   6 
   7 ---- /!\ '''Edit conflict - other version:''' ----

或者使用可调用的类:

   1 ---- /!\ '''Edit conflict - your version:''' ----

或者使用可调用的类:

   1 ---- /!\ '''End of edit conflict''' ----
   2 class linear:
   3    def __init__(self, a, b):
   4        self.a, self.b = a,b
   5    def __call__(self, x):
   6        return self.a * x + self.b
   7 
   8 ---- /!\ '''Edit conflict - other version:''' ----

两种方法都是：

   1 taxes = linear(0.3,2)

给出一个可调用对象，taxes(10e6) == 0.3 * 10e6 + 2。 用可调用对象的方法有个缺点，那就是这样做会慢一些且代码也会长一些。但是，注意到一系列的可调用对象可通过继承共享信号。

   1 ---- /!\ '''Edit conflict - your version:''' ----

两种方法都是：

   1 taxes = linear(0.3,2)

给出一个可调用对象，taxes(10e6) == 0.3 * 10e6 + 2。 用可调用对象的方法有个缺点，那就是这样做会慢一些且代码也会长一些。但是，注意到一系列的可调用对象可通过继承共享信号。

   1 ---- /!\ '''End of edit conflict''' ----
   2 class exponential(linear):
   3    # __init__ inherited
   4    def __call__(self, x):
   5        return self.a * (x ** self.b)
   6 
   7 ---- /!\ '''Edit conflict - other version:''' ----

对象可以对若干方法封装状态信息：

   1 ---- /!\ '''Edit conflict - your version:''' ----

对象可以对若干方法封装状态信息：

   1 ---- /!\ '''End of edit conflict''' ----
   2 class counter:
   3     value = 0
   4     def set(self, x): self.value = x
   5     def up(self): self.value=self.value+1
   6     def down(self): self.value=self.value-1
   7 
   8 count = counter()
   9 inc, dec, reset = count.up, count.down, count.set
  10 
  11 ---- /!\ '''Edit conflict - other version:''' ----

这里 inc(), dec() 和 reset() 运性起来就像是一组共享相同计数变量的函数。 ===1.2.8 如何在python中复制一个对象?===

Edit conflict - your version:

}}} 这里 inc(), dec() 和 reset() 运性起来就像是一组共享相同计数变量的函数。

• === 1.2.8 如何在python中复制一个对象? ===

End of edit conflict

通常，使用copy.copy() 或 copy.deepcopy() . 并不是所有的对象都可以被复制，但大多数是可以的。 某些对象可以被简单地多的方法复制。字典有个 copy() 方法: newdict = olddict.copy()

序列可以通过slicing来复制:

Edit conflict - other version:

   1 new_l = l[:]

===1.2.9 如何查看某个对象的方法和属性?=== 对于一个用户定义的类的实例x， dir(x) 返回一个按字母排序的列表，其中包含了这个实例的属性和方法，类的属性。 ===1.2.10 如何在运行时查看某个对象的名称?=== 一般来说是不行的，因为实际上对象并没有名称。实质上，赋值经常将一个名称绑定到一个值；对于def 和 class 语句也是一样, 但在那种情况下这个变量是可调用的。考虑一下代码：

   1 ---- /!\ '''Edit conflict - your version:''' ----
   2 {{{
   3 #!python
   4 new_l = l[:]

• === 1.2.9 如何查看某个对象的方法和属性? ===

对于一个用户定义的类的实例x， dir(x) 返回一个按字母排序的列表，其中包含了这个实例的属性和方法，类的属性。

• === 1.2.10 如何在运行时查看某个对象的名称? ===

一般来说是不行的，因为实际上对象并没有名称。实质上，赋值经常将一个名称绑定到一个值；对于def 和 class 语句也是一样, 但在那种情况下这个变量是可调用的。考虑一下代码：

   1 ---- /!\ '''End of edit conflict''' ----
   2 class A:
   3     pass
   4 
   5 B = A
   6 
   7 a = B()
   8 b = a
   9 print b
  10 <__main__.A instance at 016D07CC>
  11 print a
  12 <__main__.A instance at 016D07CC>
  13 
  14 ---- /!\ '''Edit conflict - other version:''' ----

Edit conflict - your version:

}}}

End of edit conflict

理论上这个类有名称：尽管它被绑定到两个名称，通过名称B进行调用，这个新创建的实例仍然被作为是类A的实例。但是，因为两个名称都被绑定到同样的值，因此说这个实例的名称到底是A还是B是不可能的。 一般来说，让你的代码知道特定对象的名称并不是必要的。除非去特意地编写一个自省程序，否则这往往意味着需要改变一下方法。 在comp.lang.python, Fredrik Lundh 曾经给出了一个极好的解答： 就好像在你家走廊发现一只猫，而你想知道它的名字：这只猫（对象）不会告诉你它的名字，它实际上也不在乎 —— 所以唯一的方法就是问你的邻居们（名称空间namespace）…… ....如果你发现它有很多名字或根本就没有名字的话也不要惊讶！

Edit conflict - other version:

===1.2.11 是否有类似C的 "?:" 三元操作符?===

Edit conflict - your version:

• === 1.2.11 是否有类似C的 "?:" 三元操作符? ===

End of edit conflict

没有。在很多情况下你可以用"a and b or c"模拟 a?b:c with , 但这样做有个缺陷：如果b是zero(或 empty, 或 None -- 只要为false) 则c被选择。在很多情况下你可以查看代码以保证这种情况不会发生(例如，因为b是个常数或是一种永远不会为false的类型), 但是通常来书它的确是个问题。 Tim Peters (本人希望是Steve Majewski) 有以下建议: (a and [b] or [c])[0]. 因为 [b] 是一个永远不会为false的列表，所以错误的情况不会发生；然后对整个表达式使用 [0] 来得到想要的b或者c。很难看，但在你重写代码并且使用'if'很不方便的情况下，这种方式是有效的。 最好的方式还是用 if...else 语句。另一种方法就是用一个函数来实现 "?:" 操作符：

   1 ---- /!\ '''Edit conflict - other version:''' ----
   2 {{{
   3 #!python
   4 
   5 ---- /!\ '''Edit conflict - your version:''' ----
   6 
   7 ---- /!\ '''End of edit conflict''' ----
   8 def q(cond,on_true,on_false):
   9     if cond: 
  10         if not isfunction(on_true): return on_true 
  11         else: return apply(on_true)
  12     else:
  13         if not isfunction(on_false): return on_false 
  14         else: return apply(on_false)
  15 
  16 ---- /!\ '''Edit conflict - other version:''' ----

Edit conflict - your version:

}}}

End of edit conflict

在大多数情况下，你会直接传递b和c: q(a,b,c)。为防止在不合适的情况下计算 b 或者 c，用一个lambda函数封装它们，例如：q(a,lambda: b, lambda: c)。 为什么python没有if-then-else表达式。有几个回答： 很多语言在没有这个的情况下也工作得很好；它会减少可读代码的数量；还没有足够多的python风格的语法；通过对标准库的搜索，发现几乎没有这种情况：通过使用 if-then-else 表达式让代码的可读性更好。 在 2002年, PEP 308 提交了若干语法建议，整个社区对此进行了一次非决定性的投票。很多人喜欢某个语法而反对另外的语法；投票结果表明，很多人宁愿没有三元操作符，也不愿意创建一种新的令人讨厌的语法，。

Edit conflict - other version:

===1.2.12 能不能在python中编写复杂的行程序?=== 是的。这经常发生在将lambda嵌入到lambda的情况，根据 Ulf Bartelt，有以下三个例子:

   1 ---- /!\ '''Edit conflict - your version:''' ----
   2  ===  1.2.12   能不能在python中编写复杂的行程序? ===  
   3 是的。这经常发生在将lambda嵌入到lambda的情况，根据 Ulf Bartelt，有以下三个例子:
   4 {{{
   5 #!python
   6 
   7 ---- /!\ '''End of edit conflict''' ----
   8 # Primes < 1000
   9 print filter(None,map(lambda y:y*reduce(lambda x,y:x*y!=0,
  10 map(lambda x,y=y:y%x,range(2,int(pow(y,0.5)+1))),1),range(2,1000)))
  11 
  12 # First 10 Fibonacci numbers
  13 print map(lambda x,f=lambda x,f:(x<=1) or (f(x-1,f)+f(x-2,f)): f(x,f),
  14 range(10))
  15 
  16 # Mandelbrot set
  17 print (lambda Ru,Ro,Iu,Io,IM,Sx,Sy:reduce(lambda x,y:x+y,map(lambda y,
  18 Iu=Iu,Io=Io,Ru=Ru,Ro=Ro,Sy=Sy,L=lambda yc,Iu=Iu,Io=Io,Ru=Ru,Ro=Ro,i=IM,
  19 Sx=Sx,Sy=Sy:reduce(lambda x,y:x+y,map(lambda x,xc=Ru,yc=yc,Ru=Ru,Ro=Ro,
  20 i=i,Sx=Sx,F=lambda xc,yc,x,y,k,f=lambda xc,yc,x,y,k,f:(k<=0)or (x*x+y*y
  21 >=4.0) or 1+f(xc,yc,x*x-y*y+xc,2.0*x*y+yc,k-1,f):f(xc,yc,x,y,k,f):chr(
  22 64+F(Ru+x*(Ro-Ru)/Sx,yc,0,0,i)),range(Sx))):L(Iu+y*(Io-Iu)/Sy),range(Sy
  23 ))))(-2.1, 0.7, -1.2, 1.2, 30, 80, 24)
  24 #    \___ ___  \___ ___  |   |   |__ lines on screen
  25 #        V          V      |   |______ columns on screen
  26 #        |          |      |__________ maximum of "iterations"
  27 #        |          |_________________ range on y axis
  28 #        |____________________________ range on x axis
  29 
  30 ---- /!\ '''Edit conflict - other version:''' ----

小朋友不要在家里尝试这个！ ==1.3 数字和字符串== ===1.3.1 如何指定十六进制和八进制整数?=== 要指定一个八进制数字，在八进制之前加个0。例如，将a设置成八进制的10，输入：

   1 ---- /!\ '''Edit conflict - your version:''' ----

小朋友不要在家里尝试这个！

1.3 数字和字符串

• === 1.3.1 如何指定十六进制和八进制整数? ===

要指定一个八进制数字，在八进制之前加个0。例如，将a设置成八进制的10，输入：

   1 ---- /!\ '''End of edit conflict''' ----
   2 >>> a = 010
   3 >>> a
   4 8
   5 
   6 ---- /!\ '''Edit conflict - other version:''' ----

十六进制也很简单。在十六进制前加个0x。十六进制数可以大写也可以小写。比如，在python解释器中:

   1 ---- /!\ '''Edit conflict - your version:''' ----

十六进制也很简单。在十六进制前加个0x。十六进制数可以大写也可以小写。比如，在python解释器中:

   1 ---- /!\ '''End of edit conflict''' ----
   2 >>> a = 0xa5
   3 >>> a
   4 165
   5 >>> b = 0XB2
   6 >>> b
   7 178
   8 
   9 ---- /!\ '''Edit conflict - other version:''' ----

===1.3.2 为什么 -22 / 10 返回 -3?=== 这是因为 i%j 跟 j 为同样类型。如果你想那样，且又想：

   1 i == (i/j)*j + (i%j)

那么整数除法就必须返回一个浮点值。C也有这个要求，编译器截断i/j，并使i的类型和i%j一样。 在实际应用中， i%j 的j是负数的可能性很小。当j是正数时，多数情况（实际上是所有情况）下i%j >= 0是很有用的。 如果现在是10点，那么200小时以前是多少？ -190 % 12 == 2 是正确的，而-190 % 12 == -10 则是个bug。 ===1.3.3 如何将一个字符串转换成数字?===

Edit conflict - your version:

}}}

• === 1.3.2 为什么 -22 / 10 返回 -3? ===

这是因为 i%j 跟 j 为同样类型。如果你想那样，且又想：

   1 i == (i/j)*j + (i%j)

那么整数除法就必须返回一个浮点值。C也有这个要求，编译器截断i/j，并使i的类型和i%j一样。 在实际应用中， i%j 的j是负数的可能性很小。当j是正数时，多数情况（实际上是所有情况）下i%j >= 0是很有用的。 如果现在是10点，那么200小时以前是多少？ -190 % 12 == 2 是正确的，而-190 % 12 == -10 则是个bug。

• === 1.3.3 如何将一个字符串转换成数字? ===

End of edit conflict

对于整数，使用内建的 int() 类型构造器, 例如 int('144') == 144。类似的，float() 转换成浮点数，例如 float('144') == 144.0。 默认的，这些数字被解释成十进制，所以 int('0144') == 144 而 int('0x144') 则抛出ValueError异常。 int(string, base) 提供了第二个参数来指定类型，所以 int('0x144', 16) == 324。 如果base被指定为0，则会按python的规则来解释：开头为一个 '0' 表示八进制，而 '0x' 表示十六进制。 如果你只是将字符串转换成数字，不用使用内建函数 eval()。eval()会慢很多并 有安全风险：某人传递给python一个表达式，可能会有意想不到的边界效应。例如，某人传递 import('os').system("rm -rf $HOME") 会清除掉你的home目录。 eval() 也能将数字解释成为python表达式，所以 eval('09') 会给出一个语法错误，因为python将开头为'0'的数字认为是八进制(base 8)。

Edit conflict - other version:

===1.3.4 如何将数字转换成字符串?=== 比如，数字144转换成字符串 '144', 使用内建函数 str()。 如果想用八进制或十六进制表示，使用内建函数hex() 或 oct()。对于格式化，使用 % operator ，比如，"%04d" % 144 为 '0144' ， "%.3f" % (1/3.0) 为 '0.333'。更多细节查看库参考手册。 ===1.3.5 如何在字符串的特定位置进行修改?=== 不能，因为字符串是不可改的。如果你确实需要一个具有这个能力的对象，将字符串转换成列表或使用数组模块：

   1 ---- /!\ '''Edit conflict - your version:''' ----
   2  ===  1.3.4   如何将数字转换成字符串? ===  
   3 比如，数字144转换成字符串 '144', 使用内建函数 str()。 如果想用八进制或十六进制表示，使用内建函数hex() 或 oct()。对于格式化，使用 % operator ，比如，"%04d" % 144 为 '0144' ， "%.3f" % (1/3.0) 为 '0.333'。更多细节查看库参考手册。
   4  ===  1.3.5   如何在字符串的特定位置进行修改? ===  
   5 不能，因为字符串是不可改的。如果你确实需要一个具有这个能力的对象，将字符串转换成列表或使用数组模块：
   6 {{{
   7 #!python
   8 
   9 ---- /!\ '''End of edit conflict''' ----
  10 >>> s = "Hello, world"
  11 >>> a = list(s)
  12 >>> print a
  13 ['H', 'e', 'l', 'l', 'o', ',', ' ', 'w', 'o', 'r', 'l', 'd']
  14 >>> a[7:] = list("there!")
  15 >>> ''.join(a)
  16 'Hello, there!'
  17 
  18 >>> import array
  19 >>> a = array.array('c', s)
  20 >>> print a
  21 array('c', 'Hello, world')
  22 >>> a[0] = 'y' ; print a
  23 array('c', 'yello world')
  24 >>> a.tostring()
  25 'yello, world'
  26 
  27 ---- /!\ '''Edit conflict - other version:''' ----

===1.3.6 如何使用字符串来调用函数/方法?=== 这里有几种方式： 最好的一种就是使用字典将字符串映射到函数。这种方法的最大好处就是字符串不用匹配函数的名称。这也是模拟case construct的主要方式：

   1 ---- /!\ '''Edit conflict - your version:''' ----

• === 1.3.6 如何使用字符串来调用函数/方法? ===

这里有几种方式： 最好的一种就是使用字典将字符串映射到函数。这种方法的最大好处就是字符串不用匹配函数的名称。这也是模拟case construct的主要方式：

   1 ---- /!\ '''End of edit conflict''' ----
   2 def a():
   3     pass
   4 
   5 def b():
   6     pass
   7 
   8 dispatch = {'go': a, 'stop': b}  # Note lack of parens for funcs
   9 
  10 dispatch[get_input()]()  # Note trailing parens to call function
  11 
  12 ---- /!\ '''Edit conflict - other version:''' ----

使用内建函数getattr():

   1 import foo
   2 getattr(foo, 'bar')()

注意，getattr()可工作于任何对象，包括类，类实例，模块等。 这种方法被用在标准库中的若干地方，就像：

   1 ---- /!\ '''Edit conflict - your version:''' ----

使用内建函数getattr():

   1 import foo
   2 getattr(foo, 'bar')()

注意，getattr()可工作于任何对象，包括类，类实例，模块等。 这种方法被用在标准库中的若干地方，就像：

   1 ---- /!\ '''End of edit conflict''' ----
   2 class Foo:
   3     def do_foo(self):
   4         ...
   5 
   6     def do_bar(self):
   7         ...
   8 
   9  f = getattr(foo_instance, 'do_' + opname)
  10  f()
  11 
  12 ---- /!\ '''Edit conflict - other version:''' ----