获取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中有一个常见的习惯用法，即通过以下划线开头的名称来表示不打算成为类外部API一部分的方法和其他类成员。这很方便，在实践中效果很好，但它给人一种错误的印象，即Python不支持私有代码和/或数据的真正封装。事实上，Python会自动为您提供词法闭包，这使得在真正需要的情况下以更加防弹的方式封装数据变得非常容易。下面是一个使用这种技术的类的例子:

class MyClass(object):
  def __init__(self):

    privateData = {}

    self.publicData = 123

    def privateMethod(k):
      print privateData[k] + self.publicData

    def privilegedMethod():
      privateData['foo'] = "hello "
      privateMethod('foo')

    self.privilegedMethod = privilegedMethod

  def publicMethod(self):
    print self.publicData

这里有一个使用它的人为的例子:

>>> obj = MyClass()
>>> obj.publicMethod()
123
>>> obj.publicData = 'World'
>>> obj.publicMethod()
World
>>> obj.privilegedMethod()
hello World
>>> obj.privateMethod()
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
AttributeError: 'MyClass' object has no attribute 'privateMethod'
>>> obj.privateData
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
AttributeError: 'MyClass' object has no attribute 'privateData'

关键是privateMethod和privateData根本不是obj的属性，所以它们不能从外部访问，也不会出现在dir()或类似的文件中。它们是构造函数中的局部变量，在__init__之外完全不可访问。然而，由于闭包的魔力，它们实际上是与它们关联的对象具有相同生命周期的每个实例变量，尽管除了(在本例中)调用privilegedMethod之外没有办法从外部访问它们。通常这种非常严格的封装是多余的，但有时它确实可以非常方便地保持API或名称空间的干净。

在Python 2中。在X中，拥有可变私有状态的唯一方法是使用可变对象(例如本例中的dict)。很多人都说这有多烦人。Python 3。x将通过引入PEP 3104中描述的nonlocal关键字来消除此限制。

** 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'

条件赋值

x = 3 if (y == 1) else 2

正如它听起来的那样:“如果y是1，则赋3给x，否则赋2给x”。注意，括号不是必需的，但是为了可读性，我喜欢它们。如果你有更复杂的东西，你也可以把它串起来:

x = 3 if (y == 1) else 2 if (y == -1) else 1

虽然在某种程度上，这有点太过分了。

注意，你可以使用if…任何表达式中的Else。例如:

(func1 if y == 1 else func2)(arg1, arg2) 

这里，如果y = 1调用func1，否则调用func2。在这两种情况下，对应的函数将调用参数arg1和arg2。

类似地，以下也成立:

x = (class1 if y == 1 else class2)(arg1, arg2)

其中class1和class2是两个类。

进口反重力

嵌套函数参数重绑定

def create_printers(n):
    for i in xrange(n):
        def printer(i=i): # Doesn't work without the i=i
            print i
        yield printer