国产精品99久久久久久久久,欧美在线亚洲一区,亚洲少妇在线

python的对象与名字�l�定�Q��{��_��此文甚好,�U�字部分为经典说明）

Jeff-Chen — Mon, 17 Apr 2006 11:27:00 GMT

python的对象与名字�l�定�Q��{��_��此文甚好�Q?/a>

�q�是一个再��单不�q�的赋��D��句，即便是才开始学习编�E�的新手也能脱口而出它的含义 -- “设�|�变量i的��gؓ1”�?/p>

i = 2

“将变量i的值改�?”，当看到接下来�q�行代码�Ӟ��你脑��中肯定会立��x�Q现这��L��念头�?/p>

�q�难道会有问题嘛�Q�这��单单的一行赋��D��句其实包含了python中的三个重要概念�Q�名字、绑定和对象�?br />python对赋��D��句作��Z��自己的定义：
“符��D��句是用来��名字绑定（或重新绑定）到某个对象的操作�Q�而且它也可用来修改可变对象的属性或
对象中所包含的成员。�?/p>

名字�l�定到对象这个概念在python中随处可见，可以说是python的最基本而且最重要的概念之一。如�?br />没有很好理解�q�一点，一些意想不到的�l�果��׃��在您的代码中悄然出现�?/p>

先来看一个简单例子：

>>> a = {'g':1}
>>> b = a*4
>>> print b
[{'g': 1}, {'g': 1}, {'g': 1}, {'g': 1}]
>>> b[0]['g'] = 2
>>> print b

��Z��意料嘛？��h��慢看完这��文章�?/p>

1. 对象
“万物皆对象�?Everything is object)�Q�这是python�q�种面向对象语言所倡导的理��c��在我们熟悉的C++中，1只是一个整型数�Q�而不是一个对象。但在python中，1却是一个实实在在的对象�Q�您可以用dir(1)来显�C�它的属性�?/p>

在python中，所有对象都有下面三个特征：
* 唯一的标识码(identity)
* �c�d��
* 内容�Q�或�U�Cؓ��|��

一旦对象被创徏�Q�它的标识码��׃��允许更改。对象的标识码可以有内徏函数id()获取�Q�它是一个整型数。您可以��它惌��对象在内存中的地址�Q�其实在目前的实��C��标识码也��是该对象的内存地址�?/p>

>>> class c1:
pass
...
>>> obj = c1()
>>> obj
<__main__.c1 instance at 0x00AC0738>
>>> id(obj)
11274040

换算一下，11274040��是十六�q�制�?x00AC0738�?/p>

>>> id(1)
7957136

�q�就是前面提到的1�q�个对象的标识码�Q�也��是它在内存中的地址�?/font>

当用is操作�W�比较两个对象时�Q�就是在比较它们的标识码。更��切地说�Q�is操作�W�是在判断两个对象是否是同一个对象�?br />>>> [1] is [1]
其结果是False�Q�是因�ؓ�q�是两个不同的对象，存储在内存中的不同地斏V�?/font>

>>> [1] == [1]
其结果是True�Q�是因�ؓ�q�两个不同的对象有着相同的倹{�?/font>

与对象的标识码类��|��对象的类型也是不可更改的。可以用内徏函数type()取得对象的类型�?/p>

有的对象的值是可以改变的，�q�类对象叫作可变对象�Q�而另外一些对象在创徏后其值是不可改变的（�?�q�个对象�Q�，�q�类对象叫作恒定对象。对象的可变性是由它的类型决定的�Q�比如数值型(number)、字�W�串�?string)以及序列�?tuple)的对象是恒定对象�Q�而字典型(dictionary)和列表型(list)的对象是可变对象�?/p>

除了上面提到的三个特征外�Q�一个对象可能：
* 没有或者拥有多个方�?br /> * 没有或者有多个名字

2. 名字
名字是对一个对象的�U�呼�Q�一个对象可以只有一个名字，也可以没有名字或取多个名字。但对象自己却不知道有多��名字，叫什么，只有名字本��n知道它所指向的是个什么对象。给对象取一个名字的操作叫作命名�Q�python��赋��D��句认为是一个命名操作（或者称为名字绑定）�?/p>

名字在一定的名字�I�间内有效，而且唯一�Q�不可能在同一个名字空间内有两个或更多的对象取同一名字�?/p>

让我们再来看看本��的�W�一个例子：i = 1。在python中，它有如下两个含义�Q?br /> * 创徏一个��gؓ1的整型对�?br /> * "i"是指向该整型对象的名字（而且它是一个引用）

3. �l�定
如上所讲的�Q�绑定就是将一个对象与一个名字联�p��v来。更��切地讲�Q�就是增加该对象的引用计数。众所周知�Q�C++中一大问题就是内存泄�?-- 卛_��态分配的内存没有能够回收�Q�而解册��一问题的利器之一��是引用计数。python��采用了�q�一技术实现其垃圾回收机制�?br />
python中的所有对象都有引用计数�?/p>

i=i+1

* �q�创��Z��一个新的对象，其��gؓi+1�?br />* "i"�q�个名字指向了该新徏的对象，该对象的引用计数加一�Q��?i"以前所指向的老对象的
引用计数减一�?br />* "i"所指向的老对象的值�ƈ没有改变�?br />* �q�就是�ؓ什么在python中没�?+�?-�q�样的单目运��符的一个原因�?/p>

3.1 引用计数
对象的引用计数在下列情况下会增加�Q?br /> * 赋值操�?br /> * 在一个容器（列表�Q�序列，字典�{�等�Q�中包含该对�?/p>

对象的引用计数在下列情况下会减少�Q?br /> * ��d��了当前的名字�I�间�Q�该名字�I�间中的本地名字都会被销毁）
* 对象的一个名字被�l�定到另外一个对�?br /> * 对象从包含它的容器中�U�除
* 名字被显�C�地用del销毁（如：del i�Q?/p>

当对象的引用计数降到0后，该对象就会被销毁，其所占的内存也就得以回收�?/p>

4. 名字�l�定所带来的一些奇特现�?/p>

�?.1�Q?br />>>> li1 = [7, 8, 9, 10]
>>> li2 = li1
>>> li1[1] = 16
>>> print li2
[7, 16, 9, 10]

注解�Q�这里li1与li2都指向同一个列表对象[7, 8, 9, 10]�Q�“li[1] = 16”是改变该列表中的第2个元素，所以通过li2时同样会看到�q�一改动�?/p>

�?.2�Q?br />>>> b = [{'g':1}]*4
>>> print b
[{'g': 1}, {'g': 1}, {'g': 1}, {'g': 1}]
>>> b[0]['g'] = 2
>>> print b
[{'g': 2}, {'g': 2}, {'g': 2}, {'g': 2}]

�?.3�Q?br /> >>> b = [{'g':1}] + [{'g':1}] + [{'g':1}] + [{'g':1}]
>>> print b
[{'g': 1}, {'g': 1}, {'g': 1}, {'g': 1}]
>>> b[0]['g'] = 2
>>> print b
[{'g': 2}, {'g': 1}, {'g': 1}, {'g': 1}]

注解�Q�在有的python书中讲到乘法�W�号�Q?�Q�就相当于几个加法的重复�Q�即认�ؓ�?.2应该�?.3的结果一致�?br /> 其实不然。例4.2中的b�q�个列表中的每一个元素{'g': 1}其实都是同一个对象，可以用id(b[n])�q�行验证。而例4.3中则是四个不同的对象。我们可以采用名字绑定的�Ҏ��消除�q�一歧义�Q?/font>

>>> a = {'g' : 1}
>>> b = [a]*4
>>> b[0]['g'] = 2
>>> print b
[{'g': 2}, {'g': 2}, {'g': 2}, {'g': 2}]
>>> print a
{'g': 2}

>>> a = {'g' : 1}
>>> b = [a] + [a] + [a] + [a]
>>> b[0]['g'] = 2
>>> print b
[{'g': 2}, {'g': 2}, {'g': 2}, {'g': 2}]
>>> print a
{'g': 2}

不过对于恒定对象而言�Q��?”和�q�箋加法的效果一栗��比如，b=[1] * 4 ��q��同于 b=[1]+[1]+[1]+[1]�?/p>

5. 函数的传参问�?br /> 函数的参��C��递也是一个名字与对象的绑定过�E�，而且是绑定到另外一个名字空��_��卛_��C��内部的名字空��_��。python对赋��D��句的独特看法又会对函数的传递造成什么媄响呢�Q?/p>

5.1 传��|��传址�Q?br /> 在学习C++的时候我们都知道有两�U�参��C��递方式：传值和传址。而在python中所有的参数传递都是引用传递（pass reference�Q�，也就是传址。这是由于名字是对象的一个引用这一python的特性而自然得来的�Q�在函数体内部对某一外部可变对象作了修改肯定会将其改变带到函��C��外。让我们来看看下�?br />�q�个例子�Q?/p>

�?.1
>>> a = [1, 2, 3]
>>> def foo(par):
... par[1] = 10
...
>>> foo(a)
>>> print a
[1, 10, 3]

因此�Q�在python中，我们应该抛开传递参数这�U�概念，时刻牢记函数的调用参数是��对象用另外一个名字空间的名字�l�定。在函数中，不过是用了另外一个名字，但还是对�q�同一个对象进行操作�?/p>

5.2 �~�省参数
使用�~�省参数�Q�是我们喜爱的一�U�作法。这可以在调用该函数时节省不��的击键�ơ数�Q�而且代码也显得更加简�z�。更重要的是它从某种意义上体��C��q�个函数设计的初街��?br /> 但是python中的�~�省参数�Q�却隐藏着一个玄机，初学者肯定会在上面栽跟头�Q�而且�q�个错误非常隐秘。先看看下面�q�个例子�Q?/p>

�?.2
>>> def foo(par=[]):
... par.append(0)
... print par
...
>>> foo() # �W�一�ơ调�?br />[0]
>>> foo() # �W�二�ơ调�?br />[0, 0]

��Z��什么问题？�q�个参数par好像�c�M��与C中的静态变量，累计了以前的�l�果。是�q�样吗？当然不是�Q�这都是“对象、名字、绑定”这些思想惹的“祸”。“万物皆对象”，�q�记得吗�Q�这里，函数foo当然也是一个对象，可以�U�C��为函数对象（与一般的对象没什么不同）。先来看看这个对象有些什么属性�?/p>

>>> dir(foo)
['__call__', '__class__', '__delattr__', '__dict__', '__doc__', '__get__', '__getattribute__', '__hash__', '__init__', '__module__', '__name__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__setattr__', '__str__', 'func_closure', 'func_code', 'func_defaults', 'func_dict', 'func_doc', 'func_globals', 'func_name']

单从名字上看�Q�“func_defaults”很可能与缺省参数有养I��看看它的倹{�?/p>

>>> foo.func_defaults          # 昄��q�个属性的内容
([0, 0],)
>>> foo()                      # �W�三�ơ调�?br />[0, 0, 0]
>>> foo.func_defaults          # 再来看看�q�个属�?br />([0, 0, 0],)

果不其然�Q�就是这个序列对象（tuple)包含了所有的�~�省参数。验证一下：

>>> def fooM(par1, def1=1, def2=[], def3='str'): # 定义一个有多个�~�省参数的函�?br />... def2.append(0)
... print par1, def1, def2, def3
...
>>> fooM.func_defaults
(1, [], 'str')

在函数定义中有几个缺省参敎ͼ�func_defaults中就会包括几个对象，暂且�U�C��为缺省参数对象（如上列中�?�Q�[]�?str'�Q�。这些缺省参数对象的生命周期与函数对象相同，从函��C��用def定义开始，直到其消亡（如用del�Q�。所以即便是在这些函数没有被调用的时候，但只要定义了�Q�缺省参数对象就会一直存在�?/p>

前面讲过�Q�函数调用的�q�程��是对象在另外一个名字空间的�l�定�q�程。当在每�ơ函数调用时�Q�如果没有传递�Q何参数给�q�个�~�省参数�Q�那么这个缺省参数的名字��׃��l�定到在func_defaults中一个对应的�~�省参数对象上�?br />>>> fooM(2)
函数fooM内的名字def1��׃��l�定到func_defaults中的�W�一个对象，def2�l�定到第二个�Q�def3则是�W�三个�?br />所以我们看到在函数foo中出现的累加现象�Q�就是由于par�l�定到缺省参数对象上�Q�而且它是一个可变对象（列表�Q�，par.append(0)��׃��每次改变�q�个�~�省参数对象的内宏V�?/p>

��函数foo改进一下，可能会更�Ҏ��帮助理解�Q?br />>>> def foo(par=[]):
... print id(par)                  # 查看该对象的标识�?br />... par.append(0)
... print par
...
>>> foo.func_defaults                  # �~�省参数对象的初始�?br />([],)
>>> id(foo.func_defaults[0])           # 查看�W�一个缺省参数对象的标识�?br />11279792                               # 你的�l�果可能会不�?br />>>> foo()
11279792                               # 证明par�l�定的对象就是第一个缺省参数对�?br />[0]
>>> foo()
11279792                               # 依旧�l�定到第一个缺省参数对�?br />[0, 0]                                 # 该对象的值发生了变化
>>> b=[1]
>>> id(b)
11279952
>>> foo(b)                             # 不��用缺省参�?br />11279952                               # 名字par所�l�定的对象与外部名字b所�l�定的是同一个对�?br />[1, 0]
>>> foo.func_defaults
([0, 0],)                              # �~�省参数对象�q�在那里�Q�而且值�ƈ没有发生变化
>>> foo()
11279792                               # 名字par又绑定到�~�省参数对象�?br />([0, 0, 0],)

��Z��预防此类“问题”的发生�Q�python��采用下列�Ҏ��Q?br />>>> def foo(par=[]):
... if par is None:
... par = []
... par.append(0)
... print par

使用None作�ؓ哨兵�Q�以判断是否有参��C��入，如果没有�Q�就新创��Z��个新的列表对象，而不是绑定到�~�省
参数对象上�?/p>

6.�ȝ��
* python是一�U�纯�_�的面向对象语言�?br /> * 赋��D��句是名字和对象的�l�定�q�程�?br /> * 函数的传参是对象��C��同名字空间的�l�定�?/p>

7.参考资�?br /> * 《Dive Into Python》，Mark Pilgrim�Q?a >http://diveintopython.org, 2003�?br /> * 《Python Objects》，Fredrik Lundh�Q?a >http://www.effbot.org/zone/python-objects.htm�?br /> * 《An Introduction to Python》，David M. Beazley�Q?a >http://systems.cs.uchicago.edu/~beazley/tutorial/beazley_intro_python/intropy.pdf�?br /> * 从Python官方�|�站�Q?a >http://www.python.org�Q�上可以了解到所有关于Python的知识�?br />

posted on 2005-06-25 10:41 I love linux 阅读(670) 评论(2) �~�辑收藏收藏�?65Key 所属分�c? Python

re: python的对象与名字�l�定�Q��{��_��此文甚好�Q?2005-12-28 16:43 jarodzz

因此�Q�在python中，我们应该抛开传递参数这�U�概念，时刻牢记函数的调用参数是��对象用另外一个名字空间的名字�l�定。在函数中，不过是用了另外一个名字，但还是对�q�同一个对象进行操作�?

def foolyou(a):
a=a+1

if __name__=='__main__':
b=1
foolyou(b)
print b

what is b now? 回复

re: python的对象与名字�l�定�Q��{��_��此文甚好�Q?a name="Post">2006-01-04 16:15 asdf_asdf

a=a+1 已经是另一�?引用"�?
>>> def foolyou(a):
print id(a)
a=a+1
print id(a)

>>> b
1
>>> foolyou(b)
148479408
148479396
>>> id(b)
148479408 回复

Jeff-Chen 2006-04-17 19:27 发表评论

The most classical topic for Python novices

Jeff-Chen — Sun, 16 Apr 2006 08:58:00 GMT

摘要: Python 101 -- Introduction to Python Python 101 -- Introduction to Python ... 阅读全文

Jeff-Chen 2006-04-16 16:58 发表评论

Jeff-Chen — Sat, 15 Apr 2006 05:13:00 GMT

Note One �Q?Lists Comprehensions
[3*x for x in vec if x > 3]
[x*y for x in vec1 for y in vec2]
......
there expression can used to instead the functional programming tools such as map() ,filter(),reduce()..

Note Two : Some functions in the modules often be made used of
1.strip() : Return a copy of the string s with leading and trailing whitespace removed.
>>> test_str = '   I Love Python '
>>> string.strip(test_str)
'I Love Pyhon'    Note that : whitespace at the two side of the string were removed ,but it did not worked on the whitespace between string!
2. str() : can convert the format like int ,long , float ... into string format
>>> num_1 = 3.14
>>> num_2 = 0.618
>>> str(num_1) , str(num_2)
'3.14' '0.618'
3.dict()
dict() -> new empty dictionary.
dict(mapping) -> new dictionary initialized from a mapping object's
    (key, value) pairs.
dict(seq) -> new dictionary initialized as if via:
    d = {}
    for k, v in seq:
        d[k] = v
dict(**kwargs) -> new dictionary initialized with the name=value pairs
    in the keyword argument list. For example: dict(one=1, two=2)

e.g
dict([('sape', 4139), ('guido', 4127), ('jack', 4098)])
dict([(x, x**2) for x in (2, 4, 6)])
dict(sape=4139, guido=4127, jack=4098)

4. enumerate()
Return an enumerate object. iterable must be an other object that supports
iteration. The enumerate object yields pairs containing a count (from
zero) and a value yielded by the iterable argument. enumerate is useful
for obtaining an indexed list: (0, seq[0]), (1, seq[1]), (2, seq[2]), ...
Code show:
>>> for i, v in enumerate(['tic', 'tac', 'toe']):
...     print i, v
...
0 tic
1 tac
2 toe

5 zip()
Return an enumerate object. iterable must be an other object that supports
iteration. The enumerate object yields pairs containing a count (from
zero) and a value yielded by the iterable argument. enumerate is useful
for obtaining an indexed list: (0, seq[0]), (1, seq[1]), (2, seq[2]), ...
Code Show:

>>> questions = ['name', 'quest', 'favorite color']
>>> answers = ['lancelot', 'the holy grail', 'blue']
>>> for q, a in zip(questions, answers):
...     print 'What is your %s?  It is %s.' % (q, a)
...	
What is your name?  It is lancelot.
What is your quest?  It is the holy grail.
What is your favorite color?  It is blue.

6.sorted()
Code Show:

>>> basket = ['apple', 'orange', 'apple', 'pear', 'orange', 'banana']
>>> for f in sorted(set(basket)):
...     print f
... 	
apple
banana
orange
pear

to be continued......

Note Three : simple statements

7 The yield statement

yield_stmt

::=

"yield" expression_list

The yield statement is only used when defining a generator function, and is only used in the body of the generator function. Using a yield statement in a function definition is sufficient to cause that definition to create a generator function instead of a normal function.

When a generator function is called, it returns an iterator known as a generator iterator, or more commonly, a generator. The body of the generator function is executed by calling the generator's next() method repeatedly until it raises an exception.

When a yield statement is executed, the state of the generator is frozen and the value of expression_list is returned to next()'s caller. By ``frozen'' we mean that all local state is retained, including the current bindings of local variables, the instruction pointer, and the internal evaluation stack: enough information is saved so that the next time next() is invoked, the function can proceed exactly as if the yield statement were just another external call.

The yield statement is not allowed in the try clause of a try ... finally construct. The difficulty is that there's no guarantee the generator will ever be resumed, hence no guarantee that the finally block will ever get executed.

Note: In Python 2.2, the yield statement is only allowed when the generators feature has been enabled. It will always be enabled in Python 2.3. This __future__ import statement can be used to enable the feature:

from __future__ import generators

8 The raise statement

raise_stmt

::=

"raise" [expression ["," expression ["," expression]]]

If no expressions are present, raise re-raises the last exception that was active in the current scope. If no exception is active in the current scope, a TypeError exception is raised indicating that this is an error (if running under IDLE, a Queue.Empty exception is raised instead).

Otherwise, raise evaluates the expressions to get three objects, using None as the value of omitted expressions. The first two objects are used to determine the type and value of the exception.

If the first object is an instance, the type of the exception is the class of the instance, the instance itself is the value, and the second object must be None.

If the first object is a class, it becomes the type of the exception. The second object is used to determine the exception value: If it is an instance of the class, the instance becomes the exception value. If the second object is a tuple, it is used as the argument list for the class constructor; if it is None, an empty argument list is used, and any other object is treated as a single argument to the constructor. The instance so created by calling the constructor is used as the exception value.

If a third object is present and not None, it must be a traceback object (see section 3.2), and it is substituted instead of the current location as the place where the exception occurred. If the third object is present and not a traceback object or None, a TypeError exception is raised. The three-expression form of raise is useful to re-raise an exception transparently in an except clause, but raise with no expressions should be preferred if the exception to be re-raised was the most recently active exception in the current scope.

Note Four : Compound Statements

9 The try statement

The try statement specifies exception handlers and/or cleanup code for a group of statements:

try_stmt	::=	try_exc_stmt \| try_fin_stmt
try_exc_stmt	::=	"try" ":" suite
		`("except" [expression ["," target]] ":" suite)+`
		`["else" ":" suite]`
try_fin_stmt	::=	"try" ":" suite "finally" ":" suite

There are two forms of try statement: try...except and try...finally. These forms cannot be mixed (but they can be nested in each other).

The try...except form specifies one or more exception handlers (the except clauses). When no exception occurs in the try clause, no exception handler is executed. When an exception occurs in the try suite, a search for an exception handler is started. This search inspects the except clauses in turn until one is found that matches the exception. An expression-less except clause, if present, must be last; it matches any exception. For an except clause with an expression, that expression is evaluated, and the clause matches the exception if the resulting object is ``compatible'' with the exception. An object is compatible with an exception if it is either the object that identifies the exception, or (for exceptions that are classes) it is a base class of the exception, or it is a tuple containing an item that is compatible with the exception. Note that the object identities must match, i.e. it must be the same object, not just an object with the same value.

If no except clause matches the exception, the search for an exception handler continues in the surrounding code and on the invocation stack.

If the evaluation of an expression in the header of an except clause raises an exception, the original search for a handler is canceled and a search starts for the new exception in the surrounding code and on the call stack (it is treated as if the entire try statement raised the exception).

When a matching except clause is found, the exception's parameter is assigned to the target specified in that except clause, if present, and the except clause's suite is executed. All except clauses must have an executable block. When the end of this block is reached, execution continues normally after the entire try statement. (This means that if two nested handlers exist for the same exception, and the exception occurs in the try clause of the inner handler, the outer handler will not handle the exception.)

Before an except clause's suite is executed, details about the exception are assigned to three variables in the sys module: sys.exc_type receives the object identifying the exception; sys.exc_value receives the exception's parameter; sys.exc_traceback receives a traceback object (see section 3.2) identifying the point in the program where the exception occurred. These details are also available through the sys.exc_info() function, which returns a tuple (exc_type, exc_value, exc_traceback). Use of the corresponding variables is deprecated in favor of this function, since their use is unsafe in a threaded program. As of Python 1.5, the variables are restored to their previous values (before the call) when returning from a function that handled an exception.

The optional else clause is executed if and when control flows off the end of the try clause.^7.1 Exceptions in the else clause are not handled by the preceding except clauses.

The try...finally form specifies a `cleanup' handler. The try clause is executed. When no exception occurs, the finally clause is executed. When an exception occurs in the try clause, the exception is temporarily saved, the finally clause is executed, and then the saved exception is re-raised. If the finally clause raises another exception or executes a return or break statement, the saved exception is lost. A continue statement is illegal in the finally clause. (The reason is a problem with the current implementation - this restriction may be lifted in the future). The exception information is not available to the program during execution of the finally clause.

When a return, break or continue statement is executed in the try suite of a try...finally statement, the finally clause is also executed `on the way out.' A continue statement is illegal in the finally clause. (The reason is a problem with the current implementation -- this restriction may be lifted in the future).

Jeff-Chen 2006-04-15 13:13 发表评论

Serious Recommend:Python Documentation Tips and Tricks

Jeff-Chen — Fri, 14 Apr 2006 05:27:00 GMT

Error convertoring HTML to XHTML: System.ArgumentException: Cannot have ']]>' inside an XML CDATA block. at System.Xml.XmlTextWriter.WriteCData(String text) at System.Xml.XmlWriter.WriteNode(XmlReader reader, Boolean defattr) at FreeTextBoxControls.Support.Formatter.HtmlToXhtml(String input)

Jeff-Chen 2006-04-14 13:27 发表评论

无法在eclipse中更新pydev�Q�供遇到此类问题的朋友参考）

Jeff-Chen — Fri, 14 Apr 2006 04:00:00 GMT

头疼了很�?eclipse中无法正常更新pydev。我又回头检查，域名是正��的�Q�但是还是出现错误�?br />想了很久�Q�在�\|�上到处扑օ�于此�c�问题的文章�Q�但是收获不大，可以说几乎找不到之类文章�?br />�q�运的事 �Q�我正在��L��其他插�g时候和察看其他python开发工��L��时候，无意中点��Z��IBM 的下面这个页面�?br />��时我就恍然大悟�Q�才发现无法更新的原因：因�ؓ公司的封掉了几个端口�Q�防止��用非工作范围内的�׃��软�g或其他的聊天软�g�Q?br />而eclipse的更新模式基于基于FTP模式的�?br />当然�q�是造成无法更新的原因之一�Q�可能还有其他原因但是我没想刎ͼ�也没遇见�q��?br /> quote: 下蝲�Ҏ��Q�FTP、HTTP 和下载助�?/span>

IBM developerWorks 提供了三�U�下载方法：FTP、HTTP 以及用于大文件下载的下蝲助手�Q?Download Director�Q�。大多数情况下，FTP 要比 HTTP 更可靠，�q�可�~�短下蝲旉��。最新的��览器在�q�行 FTP 下蝲时会昄��旉��估计和传输速度。在有些情况下，��览器还可以�l�传中断�?FTP 下蝲。要利用 FTP 的这�U�方便性，在��?HTTP 下蝲之前首先��试一�?FTP 下蝲方式�?/p>

如果您��?FTP �I�过防火墙下载时遇到了问题，再试�?HTTP 下蝲。虽然��?HTTP 方式�q�行大文件下载时不如 FTP 可靠�Q�但 Internet Explorer 5.01 及以上版本有时能够恢复中断的 HTTP 下蝲。HTTP 下蝲能够�I�过防火墙，因�ؓ它��用了端口�?80 来进行数据传输。以下下载行为和错误可能是遇��C��防火墙问题：

临近�l�束但又没有完成时下载突然停止�?
每次在同一地方停止下蝲�?
错误 400 表示代理加蝲��p�|�?
出现一条消息表明文件类型未扑ֈ��?
出现一条消息表明页面已�l�移走�?

Jeff-Chen 2006-04-14 12:00 发表评论

Jeff-Chen — Fri, 14 Apr 2006 03:34:00 GMT

�?Eclipse �?Ant �q�行 Python 开�?/h1>
�?Eclipse IDE �?Apache Ant 构徏工具�q�行 Python 开�?/p>

文档选项

未显�C�需�?JavaScript 的文档选项

��此��作为电子邮件发�?/font>

最新推�?/td>

Java 应用开发源动力 �Q?下蝲免费软�g�Q�快速启动开�?/font>

�U�别: 初��

Ron Smith , 负责�?br />

2004 �q?6 �?01 �?/p>

Python 是一�U�非常灵�z�d��大的动态脚本编�E�语�a��Q�具有完整的面向对象�Ҏ��。众多的支持者指出，Python 语言与其他语�a�相比能更快更有效地表辑և�他们的意图。但是从 Java 技术™ �?Microsoft�] .NET 刚刚转到 Python 的�h会发玎ͼ�功能丰富而精致的 IDE 和开发工具都不见了。那些开发�h员可以从他们熟悉�?Java 开发工具中扑ֈ�解决�Ҏ��。本文着重介�l�了如何使用��Z�� Java 技术的��行开发工�?Eclipse �?Ant �q�行 Python 开发�?/blockquote>
��?/font>

多年以来�Q?Java 语言�?Python 阵营之间一直存在大量的异花授粉现象。在�q�方面作出突��率的可能�?Jython。这是一个纯�_�用 Java 实现�?Python �q�行时环境。按照这一说法�Q�您��研�I�如何用 Eclipse IDE �?Ant 构徏与部�|�工具实�?Python 开发。Eclipse �?Ant 是非常流行的工具�Q�它们特性丰富、可扩展性强、而且开放源代码�Q�Python 也具有相同的品质。PyDev �?PyAntTasks 分别�?Eclipse �?Ant 的扩展，有了它们��可能用�q�些 Java 工具开�?Python。本文从下蝲安装所需的工具与扩展开始讲赗��ؓ了解释如何在 Python 开发中使用 Eclipse �?Ant�Q�我��用实际�?Python 代码例子��d�� RSS 资源�?

本文不会涉及 Eclipse、Ant、Python 的细节。有兌��些话题的深入讨论�Q�请参阅参考资�?/font> 一节中的链接�?

Python 支持情况

本文用到的��Y仉��?CPython 2.3 下测试过。除了几个异常情况之外，应该也能�?Jython 中运行。特别需要指出，PyDev 调试器目前不支持 Jython。另一个区别是通过 Jython 执行的脚本在�?PyDev 中运行之后就转入交互模式�Q�这样就必须手动杀歅R��PyDev �~�辑器与 Jython 的源代码兼容�Q�Python Ant ��d��?py-doc ��d��之外也和 Jython 兼容�?

回页�?/font>

使用 Eclipse �q�行 Python 开�?/font>

Eclipse 概述

Eclipse 是一�?Java 技术集成开发环境，�?IBM 开发，�q�开攑օ�源代码。它�?IBM 商业软�g WebSphere Application Development 环境以及其他多种工具的基��。Eclipse 的开发社区非常活跃，他们不仅开�?Eclipse 本��n�Q�还开发大量的插�g�?Eclipse 使用。有�?Eclispe �?Eclipse 插�g�?Web 站点�Q�请参阅参考资�?/font> 一节中的链接。尽��从传统上讲 Eclipse 是一�U?Java 开发工��P��但是一些插件的存在使得�?Eclipse 中开发其他语�a�的程序成为可能，�?C/C++、Python �?Perl�?

�?Eclipse 中，源代码被�l�织到项目（project�Q�中。项目可以加载、卸载和导入。Eclipse 用户界面的结构划分�ؓ视图�Q�View�Q�与�~�辑器（Editor�Q�。视图与�~�辑器的例子包括�Q�源代码大纲视图、Java 源代码编辑器、Python 源代码编辑器和文件系�l�导航视图。Eclipse 用户界面中最关键的隐含概念就�?视角�Q�perspective�Q?/i>。视角是通常在执行某�U�类型活动时一起��用的一�l�视图。Eclipse 中的标准视角包括�Q�Debug、Java Browsing、Java、Java Type Hierarchy、Plug-in Development、CVS Repository Exploring、Resource �?Install/Update。目前还不存在单独的 Python 视角。在�q�行 Python 开发时�Q�我通常使用 Resource 视角�?Debug 视角�?

安装 PyDev

首先�Q�从 Eclipse Web 站点上下�?Eclipse�Q�请参阅参考资�?/font> 一节中的链接）�Q��ƈ�Ҏ��您的�q�_��Q�按照下面的安装指南安装 Eclipse�Q?

Eclipse 的更新机制�� PyDev 插�g的安装更加容易。从 Eclipse 中选择 Help > Software Updates > Update Manager�Q�启�?Install/Update 视角。在左下角的 Feature Updates 视图中，��?PyDev 插�g更新站点作�ؓ新的 Site Bookmark ��d��到“Sites to Visit”文件夹下。Eclipse �?PyDev 更新站点 URL �?http://pydev.sf.net/updates/。现在，Feature Updates �~�辑器中应该昄��出“PyDev”这一�Ҏ��。在 Feature Updates �~�辑器中�Q�展开 PyDev > Other�Q�选择其中昄��?PyDev �Ҏ��（臛_��应该�?0.4.1�Q�。然后选择 “Install Now”安装该�Ҏ��。Eclipse ��下�?PyDev 插�g�Q��ƈ��其安装�?Eclipse 中�?

导入样例��目

��问本��目中��用的样例代码�Q�可先下�?zip 文�g�Q�请参阅参考资�?/font>一节）�Q�在文�g�pȝ��中展开�?zip 文�g�Q�然后将其中的项目导�?Eclipse。导入项目的�Ҏ��是先切换�?Resource 视角�Q�选择 File > Import�Q�再选择“Existing Project into Workspace”，然后选择您展开 zip 文�g的位�|�。这�Ӟ��Navigator 视图中应该出�?feedParserTest ��目�?

样例��目中已�l�包含了 Fead Parser 通用资源解析库，该库�?Python 开放源代码许可协议发布。有�?Feed Parser ��目 Web �|�站的链接，请参�?参考资�?/font> 一节�?

回页�?/font>

PyDev 漫游

现在开始学习如何通过已导入的��目了解 PyDev 的特性。PyDev 正处于开发过�E�中�Q�但已经是非帔R��效的 Python 开发环境。现在的 PyDev 主要包括以下�Ҏ��：

包含 Python 语法高亮昄��Ҏ��的 Python �~�辑器�?

�q�行 Python 语法分析�Q��ƈ�?Python �~�辑器和 Tasks 视图中高亮显�C�错误�?

可将制表�W��{换成�I�格的选项�?

Outline 视图昄��导入的库、类以及函数�?

�l�端视图中的 Python 堆栈跟踪信息可超链接到源代码中�?

源代码内部的��链接；同一模块内的导入和函数调用可通过��链接进行导航�?

�?Navigator 视图中运�?Python 脚本的能力�?

调试器支持断炏V��代码单步执行以及显�C�变量的倹{�?

PyDev 选项�H�口

通过 Window > Preferences�Q��ƈ选择 PyDev�Q�请参阅�?1�Q�，便可讉K�� PyDev 选项。第一�l�选项可以改变 PyDev 在源代码中处理制表符的方式，�q�可以改变语法元素的颜色�?

�?1. PyDev 选项�H�口

讄�� Python 解释�?/font>

PyDev Debug 选项可以选择 Python 解释器，供执�?Python 代码时��用。如�?PyDev 无法扑ֈ� Python 解释器，或者想使用别的解释器，可在此设�|�（请参阅图 2�Q��?

�?2. PyDev Debug 选项

处理源代�?/font>

我的大部�?Python 工作都是�?Resource 视角中完成的。��用方法是先切换到 Resource 视角�Q�然后在左上角的 Navigator 视图中双�?feedParserTest/src/feedparserTest/FeedparserTest.py 文�g。Python �~�辑器打开该文�Ӟ��?Python 语法�q�行解析�Q�完成设�|�颜色和语法��查的工作�Q�请参阅�?3�Q��?

�?3. Python �~�辑�?/b>

如果源代码中有�Q何错误，则显�C�在右下角的 Tasks 视图中显�C�出来。双�?Tasks 视图中的错误�Q�便可找到那条讨厌的代码行�?

Outline 视图在左下角�Q�其中用一�U�便于浏览的�l�构昄��出当前正在编辑的文�g。导入的库、类、函数全都显�C�出来，通过双击 Outline 视图中的��目�Q�便可以实现��D��。PyDev 在编�?Python 文�g的过�E�中寚w��q�行预先解析的工作，同时更新 Outline 视图�Q�执行语法检查，�q�用不同颜色昄��语法元素�?

�~�辑器的�Ҏ�?/font>

PyDev 0.4 版在 Python 源代码编辑器中�ؓ函数和导入库加入了超链接的特性。如果在��过某项导入或函数调用（必须�?PYTHONPATH 目录中）的同时按�?Control 键，PyDev ��p��昄��Z��个超链接�Q�这��h��可以在导入库或函数的源代码之间导航。请注意�Q��ؓ了在您自��q��源代码中跨模块��用该�Ҏ��（从一个模块链接到另一个模块）�Q�必��M��?PYTHONPATH 环境变量�Q�在其中加入�q�些模块�Q�这�?PyDev ��可以找到它们了�?

��Z��已经开始将一些优异的源代码编辑特性加入最新版本的 PyDev 中，其中��包括代码块注释与取消注释，以及代码左右�U�M��Q�请参阅�?4�Q��?

�?4. PyDev �~�辑器的其他�Ҏ�?/b>

�q�行 Python 脚本

如果不能执行代码�Q�那�?IDE 也不是太有用。�ؓ执行 Python 代码�Q�可�?Navigator 视图中选择 feedparser.py 文�g�Q�用右键点击�Q�然后选择 Python > Run。随后会昄�� Python 的启动配�|�窗口（请参阅图 5�Q��?

�?5. Python 启动配置

Python 启动配置�H�口中可以定义脚本执行的当前目录�Q�传递给脚本的参敎ͼ�以及用哪一�?Python 解释器运行脚本。feedparser.py 以一�?RSS URL 作�ؓ参数�Q�所以可在参数字�D�中填入 URL�Q�如 http://www.ibm.com/developerworks/news/dw_dwtp.rss。其余的�~�省定义��可以了�Q�所以单�?Run�?

脚本执行时输��Z��息显�C�在 Console �H�口中。如果有错误出现�Q�Console �H�口中将昄��堆栈跟踪信息�Q�其中的每一行都可以通过��链接找�?Python 源代码�?

Python 调试�?/font>

Python 调试器是最�q�才加入 PyDev 插�g中的。要使用调试器，可在 Python �~�辑器中想中断的代码行的左侧点击�Q�设�|�断炏V��在�?6 中，我在 feedparser.py �?1830 行处讄��了断炏V��然后在 Navigator 视图中选择�q�个 Python 模块�Q�点��d��键，选择“Python > Debug...”。这时将昄��与前面相似的一个启动配�|�窗口。点�?Debug �q�入 Debug 视角�Q�同时启动调试器�?

�?6. Python 调试�?/b>

左上角的 Debug 视图昄��当前正在执行的进�E�和�U�程�Q�右上角�?Variables 视图昄��当前�q�行域中的所有变量，Python �~�辑器会昄��调试器目前停在哪条语句上�Q�同时所有的输出信息都显�C�Z�� Console 视图中。调试器可以通过 Debug 视图底部的按钮或 Run 菜单�q�行控制�?

其他 Eclipse �Ҏ�?/font>

Eclipse 及其插�g�q�具备很多其他的�Ҏ��，可应用于 Python 开发中�Q�如 XML �~�辑器、UML �~�辑器（不过大多数是�?Java 代码��Z��心）�Q�还有资源控制方面的插�g。目�?Eclipse 插�g站点上列出的插�g几乎�?500 个（请参�?参考资�?/font> 一节中的相关链接）。我��着重介�l�一个对很多 Python 开发�h员都特别有用的插�Ӟ��Eclipse 发行版中已经包括�?CVS 插�g�Q�不�q�不会讨论细节内宏V�?

Eclipse 中包括特性丰富的集成 CVS�Q?/p>

支持 SSH、pserver、ext �{�连接方法�?

基本 CVS 命��o的支持：��出项目、提交变更、更新、向.cvsignore 中增加文件或模式�{�等�?

文�g合�ƈ查看�?

在源代码控制中实现对文�g不同之处的比较�?

��目同步�Q��ƈ用资料库昄��出删除和新增的内宏V�?

�q�可以通过提供其他插�g来支持其他源代码控制�pȝ��Q�如 ClearCase、Subversion、Visual SourceSafe �{��?

回页�?/font>

�?Eclipse 中��?Python 的交互式 shell

Python 解释器支�?Python 代码的交互式执行。这�U�方式对于调试一�D�代码是非常有用的，因�ؓ不用把代码放�q?Python 脚本中�ƈ执行脚本了。同�Ӟ��Python 解释器的交互模式可以很容易地集成�?Eclipse 中�?

要增加对 Python 交互式执行的支持�Q�可通过 Run > External Tools > External Tools 增加一�?External Tool 启动�E�序。这时将打开 External Tool 启动�E�序配置�H�口。在 Configurations 列表中选择“Program”，然后点击“New”创��Z��个新的配�|�。将该配�|�命名�ؓ诸如 "pythonInteractive" 之类�Q�然后设�|?Location�Q��o其指向您�?Python 解释器，接着�Q�将 "-i" 作�ؓ唯一的参��C��递进来（请参阅图 7�Q��?

�?Common 选项卡下�Q�选中复选框�Q��该配�|�在 External Tools 收藏夹菜单中昄��出来�?

�?7. Python 交互方式配置

要运行刚刚在 Eclipse 中创建的启动器，可选择 Run > External Tools > pythonInterpreter。Python 解释器的输出昄��?Console 视图中。Console 中可输入 Python 命��o�q�执行，��像从命令行中执�?Python 一栗��ؓ导入�q�在交互模式下��用模块，您需要将模块的位�|�增加到 PYTHONPATH 环境变量中�?

�?Eclipse Console 中执�?Python 与用命��o行执行的不同之处在于�Q�无法启用命令历史特性（通过向上和向下的方向键实玎ͼ��Q�因�?Eclipse Console 会自��p��释这些键�?

回页�?/font>

�?Python 开发中使用 Ant

Python 会在它需要的时候自动编译模块。这意味着 Python 开发�h员通常不必昑ּ�地对模块�q�行�~�辑。即便如此，有时候手工编�?Python 代码�q�是很有用的�Q�同�Ӟ��构徏和部�|�过�E�中�q�有很多其他斚w��的内容可以自动化实现。这也正是构建工��L��用武之地�?

我将着重介�l�来�?Java �~�程世界中的 Apache Ant�Q�这个工具可大量应用�?Python 开发中。Apache Ant �?Java �~�程领域内事实上的标准构建工兗��它更加��M��Q�与 Java 技术结合得更好�Q�可用于替代其他的构建工兗��Ant 可以在支�?Java �~�程语言的�Q何一�U��^��C��q�行。尽��我们需要的大多数构建特�?Ant 都已�l�提供了�Q�但如果要将 Ant 用做 Python 构徏工具�Q�还是需要有一些关键的�?Python 相关的特性。我已经开发了若干定制�?Ant 插�g�Q�用 Ant 的行话讲叫做 task�Q�，可提供构�?Python 旉��要的特定�?Python 的特性�?

Ant �?XML 作�ؓ描述构徏的格式。build 文�g�l�织为需要执行的目标。每一个目标都可能依赖于其他的目标。Ant ��根据您所��h��执行的目标，以及一�l�依赖目标，来执行�Q何需要的目标。每一个目标都可能包含��L��数量�?Ant ��d��Q�而由 Ant ��d��实际执行目标的工作。Ant 有很多内�|�的��d��Q�可以完成诸如编�?Java 代码、生成文��、操�U�|��件和目录�Q�同时第三方又提供了很多附加的�Q务�?

安装 Python Ant �?/font>

我将通过�?feedparser ��目创徏构徏脚本来介�l?Ant 构徏脚本�?Python Ant ��d��的基��知识。�ؓ了��?Python Ant ��d��Q�您需要下载�ƈ安装包含�q�些��d��?Java 库。首先，�?参考资�?/font> 一节中列出�?URL 中下�?Python Ant ��d��库（pyAntTasks.jar�Q�。然后，��?JAR 文�g拯��?Eclipse �?Ant 插�g下的 lib 目录中。这应该�?Eclipse 安装目录下�Ş�?plugins/org.apache.ant_1.5.3 的子目录�?

Python Ant ��d��库拷贝完毕之后，必须�?Eclipse 中启用库。选择 Window > Preferences�Q�然后选择 Ant > Runtime。将 Ant Home Entries 展开�Q�其中可看到 Eclipse 使用的库�Q�JAR 文�g�Q�列表。选择�?Add JAR”，然后�?Eclipse Ant 插�g�?lib 目录中选择 Python Ant JAR 文�g�Q�就可以��刚刚拷贝的 Python Ant JAR 文�g加入库列表中�Q�请参阅�?8�Q��?

�?8. �?classpath 中加�?Python Ant ��d��

您现在应该能够创建和�q�行包含 Python ��d��?Ant 构徏脚本了。下面进入构��本内部！

创徏构徏脚本

我将逐步介绍如何创徏一个简单的 Python 构徏脚本�Q�请参阅清单 1�Q�。完整的构徏脚本 build.xml 可从 feedParserTest ��目的顶层目录中扑ֈ��?

清单 1. 用于�~�译 Python 源代码的构徏脚本片断

先介�l�一个只�~�译 Python 样例代码的构��本�?lt;project> 标签��L��构徏脚本的根标签�?lt;taskdef> 标签声明在整个构��本中使用�?Python ��d��。在构徏脚本的底部，可以定义 compile 目标。目标元素内部是 compile �q�行期间执行的�Q务。特别的�?py-compile ��d��Q�它负责�?src 目录开始，�~�译所有的 Python 代码。该��d��会递归遍历所有的子目录，�q�编译所有的 Python 模块。脚本中没有采用��?src 目录��编码到调用之处的方式，而是在构��本中定义了称�?src.dir 的属性。然后，在需要��用这个目录名的时候，��可以通过 ${src.dir} 来引用�?

要运行构��本，可从 Eclipse 中打开它。Eclipse ��h��内置�?Ant 构徏脚本�~�辑和浏览功能。Outline 视图可以昄��出构��本的�l�构。在 Navigator 视图中，选择该构��本，用右键点击，然后选择“Run Ant...”。选择 compile 目标�Q�然后点几Z��Run”。构��本执行过�E�中的输��Z��息应该显�C�在 Console 视图中，表示�q�行成功�?

Python 脚本执行��d��

接下来将向构��本中加入新的目标�Q�用于执�?Python 脚本�Q�请参阅清单 2�Q�。在本例中，可以��?RSS URL 作�ؓ参数来执�?feedparser.py 脚本�?

清单 2. �q�行 feedparser 脚本的构��本片�?/b>

上面的目标以 RSS URL 为唯一的参数来执行 feedparser.py 脚本。该目标声明��Z��赖于 compile 目标�Q�所以后者将首先执行。实际上�q�一步�ƈ不是很必要，因�ؓ Python 会根据需要自动编译源代码。如果您执行 run.feedparser 目标�Q�就会运�?feedparser.py 脚本�Q�同时将 RSS 的内容输出到 Console 中�?

Python 文��d��

Python �?API 文��~�制机制�?Java 技术中�?JavaDoc �pȝ��c�M��Q�称�?PyDoc。在构徏脚本中加入清�?3 中列出的如下 XML 片断�Q�可为所有的 Python 模块生成 PyDoc�?

清单 3. 用于生成 PyDoc 的构��本片�?/b>

1: 2: 3: 4: 5: 6: 7: 8: 9: 10: 11: 12: 13:

从对上述 pydoc 目标的解析可看出�Q�第 7 行声明了目标名称�Q��ƈ指出它依赖于 init �?compile 目标。这意味着在运�?pydoc 目标之前�Q�Ant 必须保证 init �?compile 目标已经�q�行�Q�如果没有，则首先运行这两个目标�?

pydoc 目标所依赖�?init 目标在第 3 至第 5 行定义�?init 目标仅仅创徏了一个存�?PyDoc API 文��文�g的目录。如前所�q�ͼ�要�ؓ所生成文��的保存位�|�定义一个属性，名�ؓ pydoc.dir�?

�W?8 行开始是 py-doc ��d��。如前所�q�ͼ�您传入生�?pydoc �q�程中所使用�?PYTHONPATH �?destdir 属性告�?py-doc ��d��生成的 HTML 文��输出��C��处�?

�W?9 至第 11 行定义了在生成文��的�q�程中应该处理哪�?Python 源文件。文仉��?Ant 脚本中通用的结构，可用于定义所操作的一�l�文件。这是一�U�很强大的特性，它��您能够通过名字模式、布��逻辑和文件属性来选择所要操作的文�g。Ant 文��中有�q�方面的完整描述。本例中递归选择了“src”目录下的所有文件�?

Python 单元��试��d��

Python 中具有标准的单元��试框架�Q�从 Python 2.3 开始。在 Python 2.2 中这只是可选模块）�Q�与 Java jUnit 框架十分�c�M��。测试用例的�l�构�?jUnit 采用相同的方式。每一个待��试的类和模块通常都具有自��q��试�c�R��测试类中包含测试装�|�（fixture�Q�，它们�?setUp 函数中初始化。每一个测试都�~�写为测试类中的一个独立的��试函数。unittest 框架会在��试函数之间循环往复，先调�?setUp 、再��试函数、然后清除（ tearDown �Q�测试函数。请参阅清单 4 中的样例�?

清单 4. Python 单元��试模块

import unittest from pprint import pprint import feedparser class FeedparserTest(unittest.TestCase): """ A test class for the feedparser module. """ def setUp(self): """ set up data used in the tests. setUp is called before each test function execution. """ self.developerWorksUrl = "testData/developerworks.rss" def testParse09Rss(self): """ Test a successful run of the parse function for a 0.91 RSS feed. """ print "FeedparserTest.testParse09RSS()" result = feedparser.parse(self.developerWorksUrl) pprint(result) self.assertEqual(0, result['bozo']) self.assert_(result is not None) channel = result['channel'] self.assert_(channel is not None) chanDesc = channel['description'] self.assertEqual(u'The latest content from IBM developerWorks', chanDesc) items = result['items'] self.assert_(items is not None) self.assert_(len(items)> 3) firstItem = items[0] title = firstItem['title'] self.assertEqual(u'Build installation packages with solution installation and deployment technologies', title) def tearDown(self): """ tear down any data used in tests tearDown is called after each test function execution. """ pass if __name__ == '__main__': unittest.main()

上述清单是实�?feedparser 模块基本��试功能的测试类。完整的��试�c�见 feedParserTest ��目下的 src/feedparserTest/FeedparserTest.py�?setUp 函数负责准备整个��试�q�程中需要��用的��试装置�Q�在本例中只有测试用�?RSS 文�g的目录，��试函数��对其进行解析�?testParse09Rss 是真正的��试函数。这个函数调�?feedparser.parse 函数�Q�传递测试用�?RSS 文�g�Q�输��析结果，�q��过 TestCase �cȝ�� assert 函数执行基本的检查统作。如果�Q�?assert 的求值结果不是真�Q�或是在执行�q�程中抛��Z�Q何异常，unittest ��׃��报告一�ơ测试失败或错误。最后的两行负责在这个测试类内部�q�行��试�Q�方法是直接�q�行该模块即可�?

要独立运行该��试�c�，可以按前面所说的相同方式�q�行 FeedparserTest.py 模块。在 Eclipse Navigator 视图中选择 FeedparserTest.py�Q�然后通过 Python > Run �q�行。此时显�C�启动配�|�窗口。除 Base 目录之外�Q�其他都保持�~�省值即可。Base 目录必须�?feedParserTest ��目的目录，�q�样才能在当前目录下扑ֈ� RSS 文�g�Q�testData/developerworks.rss�Q�。修�?base 目录的设�|�，然后点击“Run”。输��Z��息显�C�在 Console 上�?

您也许希望我们编写的所有单元测试都能够作�ؓ构徏的一部分自动执行。将下面清单 5 所�C�的构徏片断加入构徏脚本便可实现�?

清单 5. 执行单元��试的构��本片�?/b>

1: 2: 3: 4: 5: 6: 7:

�W�一行是目标声明�Q�这与其他的脚本相同。第 2 至第 6 行调�?py-test ��d��。这部分代码��在“src”目录下查找所有以“Test.py”结��所有文�Ӟ��q�运行所有测试�?PYTHONPATH 讄��为“src”，��试执行的当前工作目录就是当前目录（�?’）�?

�q�行目标的方法是先运行构��本，再选择执行“tests”目标。该目标��运行所有以“Test.py”结��试用例�Q�本例中仅有 FeadparserTest.py�?

回页�?/font>

�l�束�?/font>

Eclipse �?PyDev 插�g的结合，以及 Apache Ant �?Python Ant ��d��一起��用，可以�?Python 开发提供完全集成的开发环境和构徏/部��v工具。这些工具尚在开发过�E�中�Q�因此要�l�常查看是否有更斎ͼ�如果您觉得特别希望看到某�U�特性，可以卯��v袖管自力更生�?

回页�?/font>

参考资�?

您可以参阅本文在 developerWorks 全球站点上的英文原文.

下蝲本文�?样例�E�序与源代码�?

讉K�� Eclipse Web 站点获取 Eclipse 下蝲文�g�?Eclipse 文��?

Eclipse Plug-ins Web 站点中包含数以百计的商业和开放源代码插�g�Q�可供在 Eclipse 中安装�?

Apache Ant Web 站点上有 Ant 下蝲和有�?Ant 的文��?

要获�?Python 的下载和相关信息�Q�请参阅 Python Web 站点�?

PyDev SourceForge ��目站点提供了下载、文��和用户论坛�?

Python Ant tasks Web 站点包含最新版本的 Python Ant ��d��?

Feed Parser 是用 Python 实现的通用资源解析器，可从 Feed Parser Web 站点上找到�?

Python in a Nutshell �Q�O'Reilly & Associates�Q?003�Q�，作�?Alex Martelli�Q�是优秀�?Python 语言参考手册�?

�?developerWorks�?开放源代码��目专区中可以找到更�?�?Eclipse 用户撰写的文�?/font>。也可以参看 alphaWorks上最新的 Eclipse 技术下�?/font>�?

�?Developer Bookstore 的开放源代码��Z��Q�可以找到数百本开放源代码打折书籍�Q�其中包括几�?Eclipse�?Struts 应用�E�序开�?/font> 斚w��的图书�?

通过 developerWorks Subscription用最新的 IBM 工具和中间�g开发及��试您的应用�E�序�Q�您可以获得包括��Z�� Eclipse �?WebSphere、DB2、Lotus、Rational、Tivoli 在内�?IBM 软�g�Q�同时还有可使用 12 个月的��Y件许可，省钱��出您的惌��?

下蝲 developerWorks Subscription �_�N��品的免费试用版，�q�些产品可运行于 Linux 上，包括 WebSphere Studio Site Developer、WebSphere SDK for Web services、WebSphere Application Server、DB2 Universal Database Personal Developers Edition、Tivoli Access Manager 以及 Lotus Domino Server。下载链接在 developerWorks �?Speed-start your Linux app区。想更快开始么�Q�请自己讉K��产品使用文��和技术支持�?

回页�?/font>

关于作�?/font>

Ron Smith �?RPS Technologies, Inc 的创始�h。这是一家��Y件开发与软�g��N��公司�Q�总部位于芝加哥地区。Ron Smith 为客��h��供基�?J2EE 的企业应用程序发斚w��的咨询，同时也在 RPS Technologies 内部开发��Y件��品。可以通过 ron.smith@rpstechnologies.net�?Ron 联系�?

Jeff-Chen 2006-04-14 11:34 发表评论

Jeff-Chen — Thu, 13 Apr 2006 13:49:00 GMT

Note One�Q�about sequences and lists

序列是不可变列表。一旦创��Z��一个序列就不能以�Q何方式改变它�?/font>

�?1.21. 定义序列
>>> t = ("a", "b", "mpilgrim", "z", "example")
>>> t
('a', 'b', 'mpilgrim', 'z', 'example')
>>> t[0]
'a'
>>> t[-1]
'example'
>>> t[1:3]
('b', 'mpilgrim')

序列的定义同列表的定义方式相同，除了整个元素集是用小括号包围的而不是方括号�?/font>

序列的元素象列表一��h��定义的次序进行排序。序列的索引象列表一样从0开始，所以一个非�I�序列的�W�一个元素��L�� t[0]�?/font>

负数索引象列表一样从序列��N��开始计数�?/font>

分片也可以��用，��p��列表一栗��注意当分割一个列表时�Q�会得到一个新的列表；当分割一个序列时�Q�会得到一个新的序列�?/font>

�?1.22. 序列没有�Ҏ��

>>> t
('a', 'b', 'mpilgrim', 'z', 'example')
>>> t.append("new")
Traceback (innermost last):
File "", line 1, in ?
AttributeError: 'tuple' object has no attribute 'append'
>>> t.remove("z")
Traceback (innermost last):
File "", line 1, in ?
AttributeError: 'tuple' object has no attribute 'remove'
>>> t.index("example")
Traceback (innermost last):
File "", line 1, in ?
AttributeError: 'tuple' object has no attribute 'index'
>>>"z" in t
1

你不能向序列增加元素。序列没�?append �?extend �Ҏ��?/font>

你不能从序列中除掉元素。序列没�?remove �?tt> pop �Ҏ��?/font>

你不能在序列中查扑օ�素。序列没�?index �Ҏ��?/font>

然而，你可以��?in 来看一看是否一个元素存在于序列�?/font>�?/font>

那么序列有什么好处呢�Q?/font>

序列比列表操作速度快。如果你定义了一个值集合常量，�q�且唯一要用它做的是不断地遍历它�Q��用序列代替列表�?/font>

记得我说�q?/font> 字典关键�?/font> 可以是整敎ͼ�字符串和“几�U�其它的�c�d��”吗�Q�序列就是那些类型之一。序列可以在字典中被用作关键字，但是列表不行�?sup>[2]

序列用在字符串格式化�Q�这一�Ҏ��们会很快看到�?

Note Two : Mapping in the Lists

列表映射介绍
>>>  li = [1, 9, 8, 4]
>>>  [elem*2 for elem in li]
[2, 18, 16, 8]
>>>  li
[1, 9, 8, 4]

��Z��对这一�Ҏ��一个感性认识，从右向左看它�?li 是一个将要映��的列表。Python循环遍历 li 一�ơ一个元素，临时��每个元素的��D��l�变�?elem。然后Python使用函数 elem*2 �Q�接着��结果追加到�q�回列表中�?/font>

�?font color="#ff0000">意列表映��不改变被映��的列表�?/font>

Note Three :好东西 lambda 函数

Python支持一�U�有��的语法�Q�它允许你快速定义单行的最��函数。这些叫�?lambda 的函数是从Lisp中借用来的�Q�可以被用在��M��需要函数的地方�?/font>

��Z��历史的原因，lambda 函数的语法与通常的函数有些细微的不同�?/font>

�?2.20. lambda 函数介绍
>>> def f(x):
...     return x*2
...
>>> f(3)
6
>>> g = lambda x: x*2
>>> g(3)
6
>>> (lambda x: x*2)(3)
6

�q�是一个通常的函数声明，��管以前你可能没有看到过定义在交互式�H�口中的函数。这�?... 说明它是一个多行的交互语句。只要在�W�一行的后面敲入回�R�Q�Python IDE会让你接着输入命��o�?/font>

�q�是一�?lambda 函数�Q�它完成同上面普通函数相同的事情。注意这里的��短的语法�Q�没有小括号�Q?return 是默认的�Q��ƈ且函数没有名字，只有��它赋值给变量的变量名�?/font>

你甚臛_��以不��?lambda 函数赋值给一个变量而��用它。这不是举世无双的东西，它只是展�C�Z�� lambda 函数只是一个内联函数�?/font>

��M��Q?lambda 函数是一个可以接收�Q意多个参�?包括可选参�?/font> )�q�且�q�回单个表达式值的函数�?lambda 函数不能包含命��o�Q�它们所包含的表辑ּ�不能��过一个。不要试囑֐� lambda 函数中塞入太多的东西�Q�如果你需要更复杂的东西，应该定义一个普通函敎ͼ�然后惌��它多长就多长�?/font>

lambda 函数是风格问题。不一定非要��用它们，��M��能够使用它们的地方，都可以定义一个分��ȝ��普通的函数�Q�用它来替换。我��它们用在需要封装特�D�的�Q�非重用的代码上�Q�用许多��的一行函��C��会弄乱我的代码�?/font>

�?2.21. �?in apihelper.py 中的 lambda 函数
processFunc = collapse and (lambda s: " ".join(s.split())) or (lambda s: s)

��Z��q�里有几件事情需要注意。首先，我们使用�? and-or 技巧的��单�Ş式，没问题，因�ؓ一�?lambda 函数在一个布��环境下 ��Mؓ真�?�q��ƈ不意味着 lambda 函数不能�q�回假倹{��函数本�w��L��为真�Q�它的返回值可以�ؓ��M��倹{�?

�W�二�Q�我们��用了 split 函数没带参数。你已经看到�q�它�?/font> 1个或2个参�?/font> 的��用，但是不带参数它按�I�白�q�行分割�?/font>

�?2.22. split 不带参数
>>>s = "this   is\na\ttest"
>>>print s
this   is
a test
>>>print s.split()
['this', 'is', 'a', 'test']
>>>print   " ".join(s.split())
'this is a test'

�q�是一个多行字�W�串�Q�通过转义字符的定义代替了三重引号 �?\n 是一个回车； \t 是一个制表符�?/font>

split 不带参数按空白进行分剌Ӏ�所以三个空��|��一个回车，和一个制表符都是一��L��?/font>

你可以将�I�白�l�一化，通过分割一个字�W�串�Q�然后用单个�I�格作�ؓ分隔�W�将光��新接��h��。这��是 help 函数所做的�Q�将多行文��字符串合�q�成单行�?/font>

那么 help 函数到底用这�?lambda 函数�Q?split 函数�Q�和 and-or 技巧做了什么呢�Q?

�?2.23. ��函数赋�l�一个变�?/font>

processFunc = collapse and (lambda s: " ".join(s.split())) or (lambda s: s)

processFunc 现在是一个函敎ͼ�但它为哪一个函数要�?collapse 变量的倹{��如�?collapse 为真�Q?processFunc(string) ��压�~�空白；否则�Q?tt>processFunc(string) ��返回未改变的参数�?

在一个不很徏壮的语言实现它，象VB�Q�你��可能创��Z��个函敎ͼ�它接收一个字�W�串和一�?collapse 参数�Q��用一�?if 语句来判断是否要压羃�I�白或不压羃�Q�然后返回相应的倹{��这��h��率低�Q�因为函数将不得不处理每�U�可能性；每次你调用它�Q�它��不得不在给��Z��所惌��的东西之前，判断是否要压�~�空白。在Python中，你可以将那种判断逻辑拿到函数外面�Q�而定义一个裁减过�?lambda 函数来给出确切的(�q�且唯一)你想要的。这样做更有效率�Q�更漂亮�Q��ƈ且更��导致那些��o��厌的(哦，惛_��那些参数��头�?的错误�?br />

Jeff-Chen 2006-04-13 21:49 发表评论

Jeff-Chen — Thu, 13 Apr 2006 11:45:00 GMT
Subsections

11.1 Output Formatting

11.2 Templating

11.3 Working with Binary Data Record Layouts

11.4 Multi-threading

11.5 Logging

11.6 Weak References

11.7 Tools for Working with Lists

11.8 Decimal Floating Point Arithmetic

11. Brief Tour of the Standard Library - Part II

This second tour covers more advanced modules that support professional programming needs. These modules rarely occur in small scripts.

11.1 Output Formatting

The repr module provides an version of repr() for abbreviated displays of large or deeply nested containers:

>>> import repr >>> repr.repr(set('supercalifragilisticexpialidocious')) "set(['a', 'c', 'd', 'e', 'f', 'g', ...])"

The pprint module offers more sophisticated control over printing both built-in and user defined objects in a way that is readable by the interpreter. When the result is longer than one line, the ``pretty printer'' adds line breaks and indentation to more clearly reveal data structure:

>>> import pprint >>> t = [[[['black', 'cyan'], 'white', ['green', 'red']], [['magenta', ... 'yellow'], 'blue']]] ... >>> pprint.pprint(t, width=30) [[[['black', 'cyan'], 'white', ['green', 'red']], [['magenta', 'yellow'], 'blue']]]

The textwrap module formats paragraphs of text to fit a given screen width:

>>> import textwrap >>> doc = """The wrap() method is just like fill() except that it returns ... a list of strings instead of one big string with newlines to separate ... the wrapped lines.""" ... >>> print textwrap.fill(doc, width=40) The wrap() method is just like fill() except that it returns a list of strings instead of one big string with newlines to separate the wrapped lines.

The locale module accesses a database of culture specific data formats. The grouping attribute of locale's format function provides a direct way of formatting numbers with group separators:

>>> import locale >>> locale.setlocale(locale.LC_ALL, 'English_United States.1252') 'English_United States.1252' >>> conv = locale.localeconv() # get a mapping of conventions >>> x = 1234567.8 >>> locale.format("%d", x, grouping=True) '1,234,567' >>> locale.format("%s%.*f", (conv['currency_symbol'], ... conv['frac_digits'], x), grouping=True) '$1,234,567.80'

11.2 Templating

The string module includes a versatile Template class with a simplified syntax suitable for editing by end-users. This allows users to customize their applications without having to alter the application.

The format uses placeholder names formed by "$" with valid Python identifiers (alphanumeric characters and underscores). Surrounding the placeholder with braces allows it to be followed by more alphanumeric letters with no intervening spaces. Writing "$$" creates a single escaped "$":

>>> from string import Template >>> t = Template('${village}folk send $$10 to $cause.') >>> t.substitute(village='Nottingham', cause='the ditch fund') 'Nottinghamfolk send $10 to the ditch fund.'

The substitute method raises a KeyError when a placeholder is not supplied in a dictionary or a keyword argument. For mail-merge style applications, user supplied data may be incomplete and the safe_substitute method may be more appropriate -- it will leave placeholders unchanged if data is missing:

>>> t = Template('Return the $item to $owner.') >>> d = dict(item='unladen swallow') >>> t.substitute(d) Traceback (most recent call last): . . . KeyError: 'owner' >>> t.safe_substitute(d) 'Return the unladen swallow to $owner.'

Template subclasses can specify a custom delimiter. For example, a batch renaming utility for a photo browser may elect to use percent signs for placeholders such as the current date, image sequence number, or file format:

>>> import time, os.path >>> photofiles = ['img_1074.jpg', 'img_1076.jpg', 'img_1077.jpg'] >>> class BatchRename(Template): ... delimiter = '%' >>> fmt = raw_input('Enter rename style (%d-date %n-seqnum %f-format): ') Enter rename style (%d-date %n-seqnum %f-format): Ashley_%n%f >>> t = BatchRename(fmt) >>> date = time.strftime('%d%b%y') >>> for i, filename in enumerate(photofiles): ... base, ext = os.path.splitext(filename) ... newname = t.substitute(d=date, n=i, f=ext) ... print '%s --> %s' % (filename, newname) img_1074.jpg --> Ashley_0.jpg img_1076.jpg --> Ashley_1.jpg img_1077.jpg --> Ashley_2.jpg

Another application for templating is separating program logic from the details of multiple output formats. This makes it possible to substitute custom templates for XML files, plain text reports, and HTML web reports.

11.3 Working with Binary Data Record Layouts

The struct module provides pack() and unpack() functions for working with variable length binary record formats. The following example shows how to loop through header information in a ZIP file (with pack codes "H" and "L" representing two and four byte unsigned numbers respectively):

import struct data = open('myfile.zip', 'rb').read() start = 0 for i in range(3): # show the first 3 file headers start += 14 fields = struct.unpack('LLLHH', data[start:start+16]) crc32, comp_size, uncomp_size, filenamesize, extra_size = fields start += 16 filename = data[start:start+filenamesize] start += filenamesize extra = data[start:start+extra_size] print filename, hex(crc32), comp_size, uncomp_size start += extra_size + comp_size # skip to the next header

11.4 Multi-threading

Threading is a technique for decoupling tasks which are not sequentially dependent. Threads can be used to improve the responsiveness of applications that accept user input while other tasks run in the background. A related use case is running I/O in parallel with computations in another thread.

The following code shows how the high level threading module can run tasks in background while the main program continues to run:

import threading, zipfile class AsyncZip(threading.Thread): def __init__(self, infile, outfile): threading.Thread.__init__(self) self.infile = infile self.outfile = outfile def run(self): f = zipfile.ZipFile(self.outfile, 'w', zipfile.ZIP_DEFLATED) f.write(self.infile) f.close() print 'Finished background zip of: ', self.infile background = AsyncZip('mydata.txt', 'myarchive.zip') background.start() print 'The main program continues to run in foreground.' background.join() # Wait for the background task to finish print 'Main program waited until background was done.'

The principal challenge of multi-threaded applications is coordinating threads that share data or other resources. To that end, the threading module provides a number of synchronization primitives including locks, events, condition variables, and semaphores.

While those tools are powerful, minor design errors can result in problems that are difficult to reproduce. So, the preferred approach to task coordination is to concentrate all access to a resource in a single thread and then use the Queue module to feed that thread with requests from other threads. Applications using Queue objects for inter-thread communication and coordination are easier to design, more readable, and more reliable.

11.5 Logging

The logging module offers a full featured and flexible logging system. At its simplest, log messages are sent to a file or to sys.stderr:

import logging logging.debug('Debugging information') logging.info('Informational message') logging.warning('Warning:config file %s not found', 'server.conf') logging.error('Error occurred') logging.critical('Critical error -- shutting down')

This produces the following output:

WARNING:root:Warning:config file server.conf not found ERROR:root:Error occurred CRITICAL:root:Critical error -- shutting down

By default, informational and debugging messages are suppressed and the output is sent to standard error. Other output options include routing messages through email, datagrams, sockets, or to an HTTP Server. New filters can select different routing based on message priority: DEBUG, INFO, WARNING, ERROR, and CRITICAL.

The logging system can be configured directly from Python or can be loaded from a user editable configuration file for customized logging without altering the application.

11.6 Weak References

Python does automatic memory management (reference counting for most objects and garbage collection to eliminate cycles). The memory is freed shortly after the last reference to it has been eliminated.

This approach works fine for most applications but occasionally there is a need to track objects only as long as they are being used by something else. Unfortunately, just tracking them creates a reference that makes them permanent. The weakref module provides tools for tracking objects without creating a reference. When the object is no longer needed, it is automatically removed from a weakref table and a callback is triggered for weakref objects. Typical applications include caching objects that are expensive to create:

>>> import weakref, gc >>> class A: ... def __init__(self, value): ... self.value = value ... def __repr__(self): ... return str(self.value) ... >>> a = A(10) # create a reference >>> d = weakref.WeakValueDictionary() >>> d['primary'] = a # does not create a reference >>> d['primary'] # fetch the object if it is still alive 10 >>> del a # remove the one reference >>> gc.collect() # run garbage collection right away 0 >>> d['primary'] # entry was automatically removed Traceback (most recent call last): File "", line 1, in -toplevel- d['primary'] # entry was automatically removed File "C:/PY24/lib/weakref.py", line 46, in __getitem__ o = self.data[key]() KeyError: 'primary'

11.7 Tools for Working with Lists

Many data structure needs can be met with the built-in list type. However, sometimes there is a need for alternative implementations with different performance trade-offs.

The array module provides an array() object that is like a list that stores only homogenous data but stores it more compactly. The following example shows an array of numbers stored as two byte unsigned binary numbers (typecode "H") rather than the usual 16 bytes per entry for regular lists of python int objects:

>>> from array import array >>> a = array('H', [4000, 10, 700, 22222]) >>> sum(a) 26932 >>> a[1:3] array('H', [10, 700])

The collections module provides a deque() object that is like a list with faster appends and pops from the left side but slower lookups in the middle. These objects are well suited for implementing queues and breadth first tree searches:

>>> from collections import deque >>> d = deque(["task1", "task2", "task3"]) >>> d.append("task4") >>> print "Handling", d.popleft() Handling task1 unsearched = deque([starting_node]) def breadth_first_search(unsearched): node = unsearched.popleft() for m in gen_moves(node): if is_goal(m): return m unsearched.append(m)

In addition to alternative list implementations, the library also offers other tools such as the bisect module with functions for manipulating sorted lists:

>>> import bisect >>> scores = [(100, 'perl'), (200, 'tcl'), (400, 'lua'), (500, 'python')] >>> bisect.insort(scores, (300, 'ruby')) >>> scores [(100, 'perl'), (200, 'tcl'), (300, 'ruby'), (400, 'lua'), (500, 'python')]

The heapq module provides functions for implementing heaps based on regular lists. The lowest valued entry is always kept at position zero. This is useful for applications which repeatedly access the smallest element but do not want to run a full list sort:

>>> from heapq import heapify, heappop, heappush >>> data = [1, 3, 5, 7, 9, 2, 4, 6, 8, 0] >>> heapify(data) # rearrange the list into heap order >>> heappush(data, -5) # add a new entry >>> [heappop(data) for i in range(3)] # fetch the three smallest entries [-5, 0, 1]

11.8 Decimal Floating Point Arithmetic

The decimal module offers a Decimal datatype for decimal floating point arithmetic. Compared to the built-in float implementation of binary floating point, the new class is especially helpful for financial applications and other uses which require exact decimal representation, control over precision, control over rounding to meet legal or regulatory requirements, tracking of significant decimal places, or for applications where the user expects the results to match calculations done by hand.

For example, calculating a 5% tax on a 70 cent phone charge gives different results in decimal floating point and binary floating point. The difference becomes significant if the results are rounded to the nearest cent:

>>> from decimal import * >>> Decimal('0.70') * Decimal('1.05') Decimal("0.7350") >>> .70 * 1.05 0.73499999999999999

The Decimal result keeps a trailing zero, automatically inferring four place significance from multiplicands with two place significance. Decimal reproduces mathematics as done by hand and avoids issues that can arise when binary floating point cannot exactly represent decimal quantities.

Exact representation enables the Decimal class to perform modulo calculations and equality tests that are unsuitable for binary floating point:

>>> Decimal('1.00') % Decimal('.10') Decimal("0.00") >>> 1.00 % 0.10 0.09999999999999995 >>> sum([Decimal('0.1')]*10) == Decimal('1.0') True >>> sum([0.1]*10) == 1.0 False

The decimal module provides arithmetic with as much precision as needed:

>>> getcontext().prec = 36 >>> Decimal(1) / Decimal(7) Decimal("0.142857142857142857142857142857142857")

Jeff-Chen 2006-04-13 19:45 发表评论

Jeff-Chen — Thu, 13 Apr 2006 11:43:00 GMT
Subsections

10.1 Operating System Interface

10.2 File Wildcards

10.3 Command Line Arguments

10.4 Error Output Redirection and Program Termination

10.5 String Pattern Matching

10.6 Mathematics

10.7 Internet Access

10.8 Dates and Times

10.9 Data Compression

10.10 Performance Measurement

10.11 Quality Control

10.12 Batteries Included

10. Brief Tour of the Standard Library

10.1 Operating System Interface

The os module provides dozens of functions for interacting with the operating system:

>>> import os >>> os.system('time 0:02') 0 >>> os.getcwd() # Return the current working directory 'C:\\Python24' >>> os.chdir('/server/accesslogs')

Be sure to use the "import os" style instead of "from os import *". This will keep os.open() from shadowing the builtin open() function which operates much differently.

The builtin dir() and help() functions are useful as interactive aids for working with large modules like os:

>>> import os >>> dir(os) >>> help(os)

For daily file and directory management tasks, the shutil module provides a higher level interface that is easier to use:

>>> import shutil >>> shutil.copyfile('data.db', 'archive.db') >>> shutil.move('/build/executables', 'installdir')

10.2 File Wildcards

The glob module provides a function for making file lists from directory wildcard searches:

>>> import glob >>> glob.glob('*.py') ['primes.py', 'random.py', 'quote.py']

10.3 Command Line Arguments

Common utility scripts often need to process command line arguments. These arguments are stored in the sys module's argv attribute as a list. For instance the following output results from running "python demo.py one two three" at the command line:

>>> import sys >>> print sys.argv ['demo.py', 'one', 'two', 'three']

The getopt module processes sys.argv using the conventions of the Unixgetopt() function. More powerful and flexible command line processing is provided by the optparse module.

10.4 Error Output Redirection and Program Termination

The sys module also has attributes for stdin, stdout, and stderr. The latter is useful for emitting warnings and error messages to make them visible even when stdout has been redirected:

>>> sys.stderr.write('Warning, log file not found starting a new one\n') Warning, log file not found starting a new one

The most direct way to terminate a script is to use "sys.exit()".

10.5 String Pattern Matching

The re module provides regular expression tools for advanced string processing. For complex matching and manipulation, regular expressions offer succinct, optimized solutions:

>>> import re >>> re.findall(r'\bf[a-z]*', 'which foot or hand fell fastest') ['foot', 'fell', 'fastest'] >>> re.sub(r'(\b[a-z]+) \1', r'\1', 'cat in the the hat') 'cat in the hat'

When only simple capabilities are needed, string methods are preferred because they are easier to read and debug:

>>> 'tea for too'.replace('too', 'two') 'tea for two'

10.6 Mathematics

The math module gives access to the underlying C library functions for floating point math:

>>> import math >>> math.cos(math.pi / 4.0) 0.70710678118654757 >>> math.log(1024, 2) 10.0

The random module provides tools for making random selections:

>>> import random >>> random.choice(['apple', 'pear', 'banana']) 'apple' >>> random.sample(xrange(100), 10) # sampling without replacement [30, 83, 16, 4, 8, 81, 41, 50, 18, 33] >>> random.random() # random float 0.17970987693706186 >>> random.randrange(6) # random integer chosen from range(6) 4

10.7 Internet Access

There are a number of modules for accessing the internet and processing internet protocols. Two of the simplest are urllib2 for retrieving data from urls and smtplib for sending mail:

>>> import urllib2 >>> for line in urllib2.urlopen('http://tycho.usno.navy.mil/cgi-bin/timer.pl'): ... if 'EST' in line: # look for Eastern Standard Time ... print line
Nov. 25, 09:43:32 PM EST >>> import smtplib >>> server = smtplib.SMTP('localhost') >>> server.sendmail('soothsayer@example.org', 'jcaesar@example.org', """To: jcaesar@example.org From: soothsayer@example.org Beware the Ides of March. """) >>> server.quit()

10.8 Dates and Times

The datetime module supplies classes for manipulating dates and times in both simple and complex ways. While date and time arithmetic is supported, the focus of the implementation is on efficient member extraction for output formatting and manipulation. The module also supports objects that are time zone aware.

# dates are easily constructed and formatted >>> from datetime import date >>> now = date.today() >>> now datetime.date(2003, 12, 2) >>> now.strftime("%m-%d-%y. %d %b %Y is a %A on the %d day of %B.") '12-02-03. 02 Dec 2003 is a Tuesday on the 02 day of December.' # dates support calendar arithmetic >>> birthday = date(1964, 7, 31) >>> age = now - birthday >>> age.days 14368

10.9 Data Compression

Common data archiving and compression formats are directly supported by modules including: zlib, gzip, bz2, zipfile, and tarfile.

>>> import zlib >>> s = 'witch which has which witches wrist watch' >>> len(s) 41 >>> t = zlib.compress(s) >>> len(t) 37 >>> zlib.decompress(t) 'witch which has which witches wrist watch' >>> zlib.crc32(s) 226805979

10.10 Performance Measurement

Some Python users develop a deep interest in knowing the relative performance of different approaches to the same problem. Python provides a measurement tool that answers those questions immediately.

For example, it may be tempting to use the tuple packing and unpacking feature instead of the traditional approach to swapping arguments. The timeit module quickly demonstrates a modest performance advantage:

>>> from timeit import Timer >>> Timer('t=a; a=b; b=t', 'a=1; b=2').timeit() 0.57535828626024577 >>> Timer('a,b = b,a', 'a=1; b=2').timeit() 0.54962537085770791

In contrast to timeit's fine level of granularity, the profile and pstats modules provide tools for identifying time critical sections in larger blocks of code.

10.11 Quality Control

One approach for developing high quality software is to write tests for each function as it is developed and to run those tests frequently during the development process.

The doctest module provides a tool for scanning a module and validating tests embedded in a program's docstrings. Test construction is as simple as cutting-and-pasting a typical call along with its results into the docstring. This improves the documentation by providing the user with an example and it allows the doctest module to make sure the code remains true to the documentation:

def average(values): """Computes the arithmetic mean of a list of numbers. >>> print average([20, 30, 70]) 40.0 """ return sum(values, 0.0) / len(values) import doctest doctest.testmod() # automatically validate the embedded tests

The unittest module is not as effortless as the doctest module, but it allows a more comprehensive set of tests to be maintained in a separate file:

import unittest class TestStatisticalFunctions(unittest.TestCase): def test_average(self): self.assertEqual(average([20, 30, 70]), 40.0) self.assertEqual(round(average([1, 5, 7]), 1), 4.3) self.assertRaises(ZeroDivisionError, average, []) self.assertRaises(TypeError, average, 20, 30, 70) unittest.main() # Calling from the command line invokes all tests

10.12 Batteries Included

Python has a ``batteries included'' philosophy. This is best seen through the sophisticated and robust capabilities of its larger packages. For example:

The xmlrpclib and SimpleXMLRPCServer modules make implementing remote procedure calls into an almost trivial task. Despite the names, no direct knowledge or handling of XML is needed.

The email package is a library for managing email messages, including MIME and other RFC 2822-based message documents. Unlike smtplib and poplib which actually send and receive messages, the email package has a complete toolset for building or decoding complex message structures (including attachments) and for implementing internet encoding and header protocols.

The xml.dom and xml.sax packages provide robust support for parsing this popular data interchange format. Likewise, the csv module supports direct reads and writes in a common database format. Together, these modules and packages greatly simplify data interchange between python applications and other tools.

Internationalization is supported by a number of modules including gettext, locale, and the codecs package.

Jeff-Chen 2006-04-13 19:43 发表评论

Jeff-Chen — Thu, 13 Apr 2006 03:26:00 GMT

Python Reading Notes : (2006-4-13)
Note One : the powerful Lists
Using Lists as Stacks

To add an item to the top of the stack, use append() ,To retrieve an item from the top of the stack, use pop() without an explicit index. For example:
>>> stack = [3, 4, 5]
>>> stack.append(6)
>>> stack.append(7)
>>> stack
[3, 4, 5, 6, 7]
>>> stack.pop()
7
>>> stack
[3, 4, 5, 6]
>>> stack.pop()
6
>>> stack.pop()
5
>>> stack
[3, 4]

Using Lists as Queues

To add an item to the back of the queue, use append() To retrieve an item from the front of the queue, use pop() with 0 as the index. For example:
>>> queue = ["Eric", "John", "Michael"]
>>> queue.append("Terry")           # Terry arrives
>>> queue.append("Graham")          # Graham arrives
>>> queue.pop(0)
'Eric'
>>> queue.pop(0)
'John'
>>> queue
['Michael', 'Terry', 'Graham']

Note Two :about Tuples (distinguish between string type and tuples tpye,especially zero or only one items contained in a tuples )

A special problem is the construction of tuples containing 0 or 1 items: the syntax has some extra quirks to accommodate these. Empty tuples are constructed by an empty pair of parentheses; a tuple with one item is constructed by following a value with a comma (it is not sufficient to enclose a single value in parentheses). Ugly, but effective. For example:
>>> empty = ()
>>> singleton = 'hello',    # <-- note trailing comma
>>> len(empty)
0
>>> len(singleton)
1
>>> singleton
('hello',)

but if you write a statement like this :
>>> singleton = 'hello'          # it means that you define or construct a string type,not a tuples
>>> singleton
'hello'

Jeff-Chen 2006-04-13 11:26 发表评论

Jeff-Chen — Thu, 13 Apr 2006 02:50:00 GMT
Python Reading Notes (2006-4-13)

Note One�Q�about list (wow! so powerful)

Assignment to slices is also possible, and this can even change the size of the list,but you can not do that in the string type:
>>> # Replace some items:
... a[0:2] = [1, 12]
>>> a
[1, 12, 123, 1234]
>>> # Remove some:
... a[0:2] = []
>>> a
[123, 1234]
>>> # Insert some:
... a[1:1] = ['bletch', 'xyzzy']
>>> a
[123, 'bletch', 'xyzzy', 1234]
>>> a[:0] = a     # Insert (a copy of) itself at the beginning
>>> a
[123, 'bletch', 'xyzzy', 1234, 123, 'bletch', 'xyzzy', 1234]

It is possible to nest lists (create lists containing other lists), for example:
>>> q = [2, 3]
>>> p = [1, q, 4]
>>> len(p)
3
>>> p[1]
[2, 3]
>>> p[1][0]
2
>>> p[1].append('xtra')
>>> p
[1, [2, 3, 'xtra'], 4]
>>> q
[2, 3, 'xtra']

Note Two : about for statement
It is not safe to modify the sequence being iterated over in the loop (this can only happen for mutable sequence types, such as lists). If you need to modify the list you are iterating over (for example, to duplicate selected items) you must iterate over a copy. The slice notation makes this particularly convenient:

valid statements: it will work normally
>>> for x in a[:]: # make a slice copy of the entire list
...       if len(x) > 6:
...           a.insert(0, x)
...
>>> a
['defenestrate', 'cat', 'window', 'defenestrate']
invalid statement: you prompt will die
>>> for x in a : # make a slice copy of the entire list
...       if len(x) > 6:
...          a.insert(0, x)
...
Note that: in the first statement the first row ,the for statement ues 'a[:] ' ,it means that to make a slice of it;but in the second statement,the for statement ues 'a' directly ,so cause a bad result

Note Three: Compare for efficiency

str_test = []
# method one :
str_test.append('attach')
#method two:
str_test = str_test + ['attach']

The Two method above has the same function ,but the more efficient one is the first one

Note Four :about Defining Functions
Form 1:Default Argument Values
The default value is evaluated only once.
def f(a, L=[]):
    L.append(a)
    return L

print f(1)
print f(2)
print f(3)
This will print
[1] [1, 2] [1, 2, 3]
If you don't want the default to be shared between subsequent calls, you can write the function like this instead:
def f(a, L=None): if L is None: L = [] L.append(a) return L

Form 2 : Keyword Arguments
When a final formal parameter of the form **name is present, it receives a dictionary containing all keyword arguments except
for those corresponding to a formal parameter. This may be combined with a formal parameter of the form *name (described in
the next subsection) which receives a tuple containing the positional arguments beyond the formal parameter list. (*name must
occur before **name) For example, if we define a function like this:
def cheeseshop(kind, *arguments, **keywords): print "-- Do you have any", kind, '?' print "-- I'm sorry, we're all out of", kind for arg in arguments: print arg print '-'*40
keys = keywords.keys() keys.sort() for kw in keys: print kw, ':', keywords[kw]
It could be called like this:
cheeseshop('Limburger', "It's very runny, sir.", "It's really very, VERY runny, sir.", client='John Cleese', shopkeeper='Michael Palin', sketch='Cheese Shop Sketch')
and of course it would print:
-- Do you have any Limburger ? -- I'm sorry, we're all out of Limburger It's very runny, sir. It's really very, VERY runny, sir. ---------------------------------------- client : John Cleese shopkeeper : Michael Palin sketch : Cheese Shop Sketch
Note that the sort() method of the list of keyword argument names is called before printing the contents of the keywords
dictionary; if this is not done, the order in which the arguments are printed is undefined.

Jeff-Chen 2006-04-13 10:50 发表评论

Jeff-Chen — Wed, 12 Apr 2006 11:00:00 GMT
Python��M��W�记( 2006-4-12 )�Q?/font>

Note One   : about integer and long integer
There are four types of numeric literals: plain integers, long integers, floating point numbers, and imaginary numbers. There are no complex literals (complex numbers can be formed by adding a real number and an imaginary number).
Note that numeric literals do not include a sign; a phrase like -1 is actually an expression composed of the unary operator `-' and the literal 1

Note Two   : about operators
The comparison operators <> and != are alternate spellings of the same operator. != is the preferred spelling; <> is obsolescent.

Note Three: about delimiters
The following printing ASCII characters are not used in Python. Their occurrence outside string literals and comments is an unconditional error: $       ?

Note Four : about Sequences
Sequences also support slicing: a[i:j] selects all items with index k such that i <= k < j When used as an expression, a slice is a sequence of the same type. This implies that the index set is renumbered so that it starts at 0. Some sequences also support ``extended slicing'' with a third ``step'' parameter: a[i:j:k] selects all items of a with index x where x = i +n*k , n >= 0  and i <= x < j.

Note Five   : about Primary Prompt
In interactive mode, the last printed expression is assigned to the variable _. This means that when you are using Python as a desk calculator, it is somewhat easier to continue calculations, for example:

>>> tax = 12.5 / 100
>>> price = 100.50
>>> price * tax
12.5625
>>> price + _
113.0625
>>> round(_, 2)
113.06
>>>

This variable should be treated as read-only by the user. Don't explicitly assign a value to it -- you would create an independent local variable with the same name masking the built-in variable with its magic behavior.

Jeff-Chen 2006-04-12 19:00 发表评论

初识 python!

Jeff-Chen — Wed, 12 Apr 2006 10:14:00 GMT

与python�W�一�ơ亲密接�?
在网上搜集了很多资料和浏览了python的很多相��x��章，它给我的��M��感觉是在文本处理上的高效和语�a��?人性化",
面�D个例子来说明我�ؓ什么觉�?人性化":

1. Reason One :  长整型无长度限制�Q�除了电脑硬件的限制
Although both lower case "l" and upper case "L" are allowed as suffix for long integers, it is strongly recommended to always use "L", since the letter "l" looks too much like the digit "1".
Plain integer literals that are above the largest representable plain integer (e.g., 2147483647 when using 32-bit arithmetic) are accepted as if they were long integers instead. There is no limit for long integer literals apart from what can be stored in available memory. Some examples of plain integer literals (first row) and long integer literals (second and third rows):
7      2147483647                                      0177
3L    79228162514264337593543950336L    0377L   0x100000000L
       79228162514264337593543950336                 0xdeadbeef

2. Reason Two : (quote) 一个python��tip�Q�交换两个变量的��|��而且不��用第三个变量�Q?
>>> a,b = 1,2
>>> a,b = b,a
>>> a,b
(2, 1)
>>>

3.Reason Three:
它是用C语言开发的�Q�但是效率比起C语言也差了多��，当然没C快啦�Q�但是他里面的很多函数非常方便，功能比C强大很多�?br />4.Reason Four :　
最让�h兴奋的原因就是BitComet��是它开发出来的�?br />
他避免了很多初学�E�序设计时常常出现的问题�Q�尽��对于大多数人来说都是几乎不会发生的�Q�但是从�q�点可以看出它对它的用户是傻瓜开始的。因为傻瓜才会犯哪些错误�Q?br />


Jeff-Chen 2006-04-12 18:14 发表评论


		Ron Smith �?RPS Technologies, Inc 的创始�h。这是一家��Y件开发与软�g��N��公司�Q�总部位于芝加哥地区。Ron Smith 为客��h��供基�?J2EE 的企业应用程序发斚w��的咨询，同时也在 RPS Technologies 内部开发��Y件��品。可以通过 ron.smith@rpstechnologies.net�?Ron 联系�?

	序列的定义同列表的定义方式相同，除了整个元素集是用小括号包围的而不是方括号�?/font>
	序列的元素象列表一��h��定义的次序进行排序。序列的索引象列表一样从0开始，所以一个非�I�序列的�W�一个元素��L�� `t[0]`�?/font>
	负数索引象列表一样从序列��N��开始计数�?/font>
	分片也可以��用，��p��列表一栗��注意当分割一个列表时�Q�会得到一个新的列表；当分割一个序列时�Q�会得到一个新的序列�?/font>

	你不能向序列增加元素。序列没�?`append` �?`extend` �Ҏ��?/font>
	你不能从序列中除掉元素。序列没�?`remove` �?tt> pop �Ҏ��?/font>
	你不能在序列中查扑օ�素。序列没�?`index` �Ҏ��?/font>
	然而，你可以��?`in` 来看一看是否一个元素存在于序列�?/font>�?/font>

	��Z��对这一�Ҏ��一个感性认识，从右向左看它�?`li` 是一个将要映��的列表。Python循环遍历 `li` 一�ơ一个元素，临时��每个元素的��D��l�变�?`elem`。然后Python使用函数 `elem*2` �Q�接着��结果追加到�q�回列表中�?/font>
	�?font color="#ff0000">意列表映��不改变被映��的列表�?/font>

	�q�是一个通常的函数声明，��管以前你可能没有看到过定义在交互式�H�口中的函数。这�?... 说明它是一个多行的交互语句。只要在�W�一行的后面敲入回�R�Q�Python IDE会让你接着输入命��o�?/font>
	�q�是一�?`lambda` 函数�Q�它完成同上面普通函数相同的事情。注意这里的��短的语法�Q�没有小括号�Q?`return` 是默认的�Q��ƈ且函数没有名字，只有��它赋值给变量的变量名�?/font>
	你甚臛_��以不��?`lambda` 函数赋值给一个变量而��用它。这不是举世无双的东西，它只是展�C�Z�� lambda 函数只是一个内联函数�?/font>


	`lambda` 函数是风格问题。不一定非要��用它们，��M��能够使用它们的地方，都可以定义一个分��ȝ��普通的函数�Q�用它来替换。我��它们用在需要封装特�D�的�Q�非重用的代码上�Q�用许多��的一行函��C��会弄乱我的代码�?/font>

	�q�是一个多行字�W�串�Q�通过转义字符的定义代替了三重引号 �?`\n` 是一个回车； `\t` 是一个制表符�?/font>
	`split` 不带参数按空白进行分剌Ӏ�所以三个空��\|��一个回车，和一个制表符都是一��L��?/font>
	你可以将�I�白�l�一化，通过分割一个字�W�串�Q�然后用单个�I�格作�ؓ分隔�W�将光��新接��h��。这��是 `help` 函数所做的�Q�将多行文��字符串合�q�成单行�?/font>

国产精品99久久久久久久久,欧美在线亚洲一区,亚洲少妇在线

python的对象与名字�l�定�Q��{��_��此文甚好,�U�字部分为经典说明）

python的对象与名字�l�定�Q��{��_��此文甚好�Q?/a>

评论

re: python的对象与名字�l�定�Q��{��_��此文甚好�Q?2005-12-28 16:43 jarodzz

re: python的对象与名字�l�定�Q��{��_��此文甚好�Q?a name="Post">2006-01-04 16:15 asdf_asdf

The most classical topic for Python novices

Serious Recommend:Python Documentation Tips and Tricks

无法在eclipse中更新pydev�Q�供遇到此类问题的朋友参考）

�?Eclipse �?Ant �q�行 Python 开�?/h1> �?Eclipse IDE �?Apache Ant 构徏工具�q�行 Python 开�?/p>

11. Brief Tour of the Standard Library - Part II

11.1 Output Formatting

11.2 Templating

11.3 Working with Binary Data Record Layouts

11.4 Multi-threading

11.5 Logging

11.6 Weak References

11.7 Tools for Working with Lists

11.8 Decimal Floating Point Arithmetic

10. Brief Tour of the Standard Library

10.1 Operating System Interface

10.2 File Wildcards

10.3 Command Line Arguments

10.4 Error Output Redirection and Program Termination

10.5 String Pattern Matching

10.6 Mathematics

10.7 Internet Access

10.8 Dates and Times

10.9 Data Compression

10.10 Performance Measurement

10.11 Quality Control

10.12 Batteries Included

初识 python!

�?Eclipse �?Ant �q�行 Python 开�?/h1>
�?Eclipse IDE �?Apache Ant 构徏工具�q�行 Python 开�?/p>