原始字符串中的反斜杠仍然可以转义引号。看到这个:

>>> print repr(r"aaa\"bbb")
'aaa\\"bbb'

注意，反斜杠和双引号都出现在最后的字符串中。

因此，你不能用反斜杠来结束一个原始字符串:

>>> print repr(r"C:\")
SyntaxError: EOL while scanning string literal
>>> print repr(r"C:\"")
'C:\\"'

这是因为实现原始字符串是为了帮助编写正则表达式，而不是为了编写Windows路径。在Gotcha - Windows文件名中的反斜杠上阅读关于这个的长讨论。

列表理解

列表理解

比较更传统的(不含列表理解):

foo = []
for x in xrange(10):
  if x % 2 == 0:
     foo.append(x)

to:

foo = [x for x in xrange(10) if x % 2 == 0]

懒得初始化字典中的每个字段?没有问题:

在Python > 2.3中:

from collections import defaultdict

Python中<= 2.3:

def defaultdict(type_):
    class Dict(dict):
        def __getitem__(self, key):
            return self.setdefault(key, type_())
    return Dict()

在任何版本中:

d = defaultdict(list)
for stuff in lots_of_stuff:
     d[stuff.name].append(stuff)

更新:

谢谢肯·阿诺德。我重新实现了一个更复杂的defaultdict版本。它的行为应该与标准库中的完全相同。

def defaultdict(default_factory, *args, **kw):                              

    class defaultdict(dict):

        def __missing__(self, key):
            if default_factory is None:
                raise KeyError(key)
            return self.setdefault(key, default_factory())

        def __getitem__(self, key):
            try:
                return dict.__getitem__(self, key)
            except KeyError:
                return self.__missing__(key)

    return defaultdict(*args, **kw)

主要信息:)

import this
# btw look at this module's source :)

De-cyphered:

蒂姆·彼得斯的《Python之禅》 美总比丑好。 显性比隐性好。 简单比复杂好。 复杂胜过复杂。 扁平比嵌套好。 稀疏比密集好。 可读性。 特殊情况并不特别到可以打破规则。 尽管实用性胜过纯洁性。 错误绝不能悄无声息地过去。 除非明确保持沉默。 面对模棱两可，拒绝猜测的诱惑。 应该有一种——最好只有一种——明显的方法来做到这一点。 除非你是荷兰人，否则这种方式一开始可能并不明显。 现在总比没有好。 虽然永远不比现在更好。 如果实现很难解释，那就是一个坏主意。 如果实现很容易解释，这可能是一个好主意。 名称空间是一个非常棒的想法——让我们多做一些吧!

上下文管理器和“with”语句

在PEP 343中引入的上下文管理器是作为一组语句的运行时上下文的对象。

由于该特性使用了新的关键字，它是逐渐引入的:在Python 2.5中通过__future__指令可用。Python 2.6及以上版本(包括Python 3)默认情况下可用。

我经常使用“with”语句，因为我认为这是一个非常有用的结构，下面是一个快速演示:

from __future__ import with_statement

with open('foo.txt', 'w') as f:
    f.write('hello!')

这里在幕后发生的事情是，“with”语句在文件对象上调用特殊的__enter__和__exit__方法。如果with语句体引发任何异常，异常细节也会传递给__exit__，允许在那里进行异常处理。

在这种特殊情况下，这为您做的是，当执行超出with套件的范围时，它保证关闭文件，无论这是正常发生还是抛出异常。它基本上是一种抽象出常见异常处理代码的方法。

其他常见的用例包括线程锁定和数据库事务。

只需少量的工作，线程模块就变得非常容易使用。此装饰器更改函数，使其在自己的线程中运行，返回占位符类实例，而不是常规结果。你可以通过检查placeolder来探测答案。结果或通过调用placeholder.awaitResult()来等待它。

def threadify(function):
    """
    exceptionally simple threading decorator. Just:
    >>> @threadify
    ... def longOperation(result):
    ...     time.sleep(3)
    ...     return result
    >>> A= longOperation("A has finished")
    >>> B= longOperation("B has finished")

    A doesn't have a result yet:
    >>> print A.result
    None

    until we wait for it:
    >>> print A.awaitResult()
    A has finished

    we could also wait manually - half a second more should be enough for B:
    >>> time.sleep(0.5); print B.result
    B has finished
    """
    class thr (threading.Thread,object):
        def __init__(self, *args, **kwargs):
            threading.Thread.__init__ ( self )  
            self.args, self.kwargs = args, kwargs
            self.result = None
            self.start()
        def awaitResult(self):
            self.join()
            return self.result        
        def run(self):
            self.result=function(*self.args, **self.kwargs)
    return thr