可以从一组长度为2的序列构建字典。当你有一个值列表和数组列表时，这非常方便。

>>> dict([ ('foo','bar'),('a',1),('b',2) ])
{'a': 1, 'b': 2, 'foo': 'bar'}

>>> names = ['Bob', 'Marie', 'Alice']
>>> ages = [23, 27, 36]
>>> dict(zip(names, ages))
{'Alice': 36, 'Bob': 23, 'Marie': 27}

获取python正则表达式解析树来调试正则表达式。

正则表达式是python的一个伟大特性，但调试它们可能是一件痛苦的事情，而且正则表达式很容易出错。

幸运的是，python可以通过将未记录的、实验性的隐藏标志re.DEBUG(实际上是128)传递给re.compile来打印正则表达式解析树。

>>> re.compile("^\[font(?:=(?P<size>[-+][0-9]{1,2}))?\](.*?)[/font]",
    re.DEBUG)
at at_beginning
literal 91
literal 102
literal 111
literal 110
literal 116
max_repeat 0 1
  subpattern None
    literal 61
    subpattern 1
      in
        literal 45
        literal 43
      max_repeat 1 2
        in
          range (48, 57)
literal 93
subpattern 2
  min_repeat 0 65535
    any None
in
  literal 47
  literal 102
  literal 111
  literal 110
  literal 116

一旦理解了语法，就可以发现错误。在这里我们可以看到，我忘记转义[/font]中的[]。

当然，你可以将它与任何你想要的标志组合在一起，比如注释正则表达式:

>>> re.compile("""
 ^              # start of a line
 \[font         # the font tag
 (?:=(?P<size>  # optional [font=+size]
 [-+][0-9]{1,2} # size specification
 ))?
 \]             # end of tag
 (.*?)          # text between the tags
 \[/font\]      # end of the tag
 """, re.DEBUG|re.VERBOSE|re.DOTALL)

虽然不是很python化，但可以使用print来写入文件

打印>>outFile， 'I am Being Written'

解释:

这种形式有时被称为 “打印雪佛龙。”在这种形式中， 第一个表达式>后>必须 求值为“类文件”对象， 具体来说，一个对象具有 如上所述编写()方法。 有了这个扩展形式， 随后的表达式被打印到 这个文件对象。如果第一个 表达式的值为None sys。的文件使用Stdout 输出。

** Using sets to reference contents in sets of frozensets**

正如你可能知道的，集合是可变的，因此是不可哈希的，所以如果你想创建一个集合的集合(或使用集合作为字典的键)，使用frozensets是必要的:

>>> fabc = frozenset('abc')
>>> fxyz = frozenset('xyz')
>>> mset = set((fabc, fxyz))
>>> mset
{frozenset({'a', 'c', 'b'}), frozenset({'y', 'x', 'z'})}

然而，仅仅使用普通集合就可以测试成员并删除/丢弃成员:

>>> abc = set('abc')
>>> abc in mset
True
>>> mset.remove(abc)
>>> mset
{frozenset({'y', 'x', 'z'})}

引用Python标准库文档:

注意，__contains__()， remove()和discard()的elem参数 方法可以是一个集合。为了支持搜索等价的frozenset，可以使用 Elem集在搜索过程中临时突变，然后恢复。在 搜索，elem集不应该被读取或改变，因为它没有 拥有有意义的价值。

不幸的是，也许是令人惊讶的是，字典并非如此:

>>> mdict = {fabc:1, fxyz:2}
>>> fabc in mdict
True
>>> abc in mdict
Traceback (most recent call last):
File "<interactive input>", line 1, in <module>
TypeError: unhashable type: 'set'

使用不同的起始索引进行枚举

enumerate在这个答案中已经部分涉及了，但最近我发现了enumerate一个更隐藏的特性，我认为值得单独发表，而不仅仅是评论。

从Python 2.6开始，你可以在第二个参数中指定要枚举的起始索引:

>>> l = ["spam", "ham", "eggs"]
>>> list(enumerate(l))
>>> [(0, "spam"), (1, "ham"), (2, "eggs")]
>>> list(enumerate(l, 1))
>>> [(1, "spam"), (2, "ham"), (3, "eggs")]

我发现它非常有用的一个地方是当我枚举对称矩阵的元素时。由于矩阵是对称的，我可以通过只在上三角形上迭代来节省时间，但在这种情况下，我必须在内部for循环中使用不同的起始索引来正确跟踪行和列的索引:

for ri, row in enumerate(matrix):
    for ci, column in enumerate(matrix[ri:], ri):
        # ci now refers to the proper column index

奇怪的是，enumerate的这种行为在help(enumerate)中没有记录，只有在线文档中有记录。

Doctest:同时进行文档和单元测试。

从Python文档中提取的示例:

def factorial(n):
    """Return the factorial of n, an exact integer >= 0.

    If the result is small enough to fit in an int, return an int.
    Else return a long.

    >>> [factorial(n) for n in range(6)]
    [1, 1, 2, 6, 24, 120]
    >>> factorial(-1)
    Traceback (most recent call last):
        ...
    ValueError: n must be >= 0

    Factorials of floats are OK, but the float must be an exact integer:
    """

    import math
    if not n >= 0:
        raise ValueError("n must be >= 0")
    if math.floor(n) != n:
        raise ValueError("n must be exact integer")
    if n+1 == n:  # catch a value like 1e300
        raise OverflowError("n too large")
    result = 1
    factor = 2
    while factor <= n:
        result *= factor
        factor += 1
    return result

def _test():
    import doctest
    doctest.testmod()    

if __name__ == "__main__":
    _test()