## 空匹配只有在它们没有紧挨着前一个匹配时才会被替换掉；‘p’后面的空匹配没被替换
>>> p = re.compile('p*')
>>> p.sub('-', 'abpd')
'-a-b-d-'
## 逆向引用，可以在替换后的字符串中插入原始文本的一部分
## \1 表示匹配到的分组 1，①或者用\g<1>引用分组；②也可以通过 (?P<name>...) 指定分组名，然后通过 \g<name> 来引用匹配到的分组
>>> p = re.compile('section{ ( [^}]* ) }', re.VERBOSE) # 忽略空格
>>> p.sub(r'subsection{\1}', 'section{First} section{Second}')
'subsection{First} subsection{Second}'
## 使用函数作为替换规则；每次调用时，函数会被传入一个 `MatchObject` 的对象作为参数
>>> hex_replace = lambda match: hex(int(match.group()))
>>> p.sub(hex_replace, 'call 65490 for printing, 49152 for user code.')
'call 0xffd2 for printing, 0xc000 for user code.'

# 使用编译标识的另一种方法 (?iLmsux)
>>> re.findall(r"(?i)[a-z]+", "123ABc123Dxc")
['ABc', 'Dxc']
>>> re.findall(r"[a-z]+", "123ABc123Dxc", re.I)
['ABc', 'Dxc']

>>> sum(0.1 for i in range(10)) == 1.0
False
>>> fequal = lambda x, y, places=7: round(abs(x-y), places) == 0
>>> fequal(sum(0.1 for i in range(10)), 1.0)
True
>>> from decimal import Decimal
>>> sum(Decimal('0.1') for i in range(10)) == Decimal('1.0')
True

>>> def mm(arg):
...     if arg is not None:
...         print arg, 'is not None'
...     if arg is None:
...         print arg, 'is None'
...     if arg:
...         print arg, 'is not empty'
...     if not arg:
...         print arg, 'is empty'
... 
>>> mm([])
[] is not None
[] is empty

>>> a = 'Hello'
>>> b = 'Hello'
>>> a is b
True
>>> a == b
True
>>> id(a) == id(b)
True
>>>
>>> c = 'long string'
>>> d = 'long string'
>>> c is d
False
>>> c == d
True
>>> id(c) == id(d)
False

>>> s = '中文'
>>> s; len(s); type(s)
'\xe4\xb8\xad\xe6\x96\x87'
6down
<type 'str'>
>>> us = s.decode('utf-8')
>>> us; len(us); type(us)
u'\u4e2d\u6587'
2
<type 'unicode'>
>>> from __future__ import unicode_literals # Python 3 的特性
>>> s = '中文'; s; len(s)
u'\u4e2d\u6587'
2

>>> s = 'Hello, world!'
>>> s[7] = 'W'
Traceback (most recent call last):
  ...
TypeError: 'str' object does not support item assignment

>>> a, b, c = 'I am God!', 'I am winner!', 'I am the best one!'
>>> x = [a, b, c, a, b, c]  # 使用对象引用，三个字符串
>>> y = ['I am God!', 'I am winner!', 'I am the best one!', 'I am God!', 'I am winner!', 'I am the best one!']  # 至少六个字符串空间

>>> d1 = {'a': 1}
>>> d2 = d1
>>> d2['b'] = 2
>>> d1
{'a': 1, 'b': 2}
>>> d2
{'a': 1, 'b': 2}
>>> id(d1); id(d2)
140710557653544
140710557653544
>>> d2 = {} # 注意对象和引用，我总是搞混 ……
>>> d1
{'a': 1, 'b': 2}
>>> d2
{}
>>> id(d1); id(d2)
140710557653544
140710557663872
>>> 
>>> import copy
>>> d3 = {'a': 1}
>>> d4 = copy.deepcopy(d3)
>>> id(d3); id(d4)
140710557664432
140710557666392
>>> d4['b'] = 2
>>> d4
{'a': 1, 'b': 2}
>>> d3
{'a': 1}

>>> def foo(a, b=[]):
...     b.append(a)
...     print '{0:#x} -> {1}'.format(id(b), b)
... 
>>> foo(1, [])   # 还挺正常的
0x7fd42d897ea8 -> [1]
>>> foo(2, [])
0x7fd42d897ea8 -> [2]
>>> l = [3]      # 这里因为 l 是全局可变对象，参见下面<传值还是传引用>
>>> foo(4, l)
0x7fd42d897e18 -> [3, 4]
>>> foo(5, l)
0x7fd42d897e18 -> [3, 4, 5]
>>> l
[3, 4, 5]
>>> foo(6)      # 使用默认参数值
0x7fd42d883998 -> [6]
>>> foo(7)
0x7fd42d883998 -> [6, 7]   # 仅仅被评估一次
>>> # 改进一下，不再使用可变对象作为默认参数值。
>>> def bar(a, b=None):
...     if b == None: b = []
...     b.append(a)
...     print '{0:#x} -> {1}'.format(id(b), b)
... 
>>> bar(1)
0x7fd42d897ea8 -> [1]
>>> bar(2)
0x7fd42d897ea8 -> [2]   # 仅仅被评估一次

>>> ######################## 可变对象传引用
>>> def foo(lst):
...     lst.append('NEW')
...     return lst
... 
>>> lst = [1, 2, 3]
>>> id(lst)
140492465764760
>>> new_lst = foo(lst)
>>> id(new_lst)
140492465764760
>>> new_lst
[1, 2, 3, 'NEW']
>>> lst
[1, 2, 3, 'NEW']
>>> ######################## 可变对象传引用？？？？？
>>> def foo(lst):
...     lst = ['NEW', '???']
...     return lst
... 
>>> lst = [1, 2, 3]
>>> id(lst)
140492465847904
>>> new_lst = foo(lst)
>>> id(new_lst)
140492465848120
>>> new_lst
['NEW', '???']
>>> lst
[1, 2, 3]

>>> class Test:
...     def __str__(self):
...         return '__str__'
...     def __repr__(self):
...         return '__repr__'
... 
>>> 'str: {0!s}'.format(Test())       ## 调用了 str()
'str: __str__'
>>> 'repr: {key!r}'.format(key=Test())      ## 调用了 repr()
'repr: __repr__'
>>> '{2}, {1}, {0}'.format(*args)     ## 解包，list，dict
'3, 2, 1'
>>> import os; 'OS name: {.name}'.format(os)   ## 访问属性
'OS name: posix'
>>> 'One:{lst[0]}, Two:{lst[1]}, Three:{lst[2]}'.format(lst=[1, 2, 3])  ## 访问索引
'One:1, Two:2, Three:3'
>>> '[{0:<10}][{1:*^20}][{2:>10}]'.format('left', 'center|fill', 'right')   ## 对齐，填充
'[left      ][****center|fill*****][     right]'
>>> 'int:{0:d}, hex:{0:x}, oct:{0:o}, bin:{0:b}'.format(23) ## 进制转换
'int:23, hex:17, oct:27, bin:10111'
>>> 'int:{0:d}, hex:{0:#x}, oct:{0:#o}, bin:{0:#b}'.format(23) ## 显示前缀
'int:23, hex:0x17, oct:0o27, bin:0b10111'
>>> '{:,}'.format(1234567890)   ## 把‘,’作为千位分隔符
'1,234,567,890'
>>> import datetime; 'Now: {0:%Y-%m-%d %H:%M:%S}'.format(datetime.datetime.now())  ##格式化时间
'Now: 2015-01-10 21:04:42'

>>> import json; data = {u'status': u'OK', u'count': 2, u'results': [{u'age': 27, u'name': u'Oz', u'lactose_intolerant': True}, {u'age': 29, u'name': u'Joe', u'lactose_intolerant': False}]}
>>> print json.dumps(data)
{"status": "OK", "count": 2, "results": [{"age": 27, "name": "Oz", "lactose_intolerant": true}, {"age": 29, "name": "Joe", "lactose_intolerant": false}]}
>>> print json.dumps(data, indent=2)
{
  "status": "OK", 
  "count": 2, 
  "results": [
    {
      "age": 27, 
      "name": "Oz", 
      "lactose_intolerant": true
    }, 
    {
      "age": 29, 
      "name": "Joe", 
      "lactose_intolerant": false
    }
  ]
}

# 一种有用形式，读取文件，直到readline()返回空字符串为止
with open('mydata.txt') as fp:
    for line in iter(fp.readline, ''):
        process_line(line)

# 使用 tornado.options.parse_config_file 时必须先 define 的一种解决方式
# 来自 https://bitbucket.org/felinx/poweredsites/src/6040f8cf119ca530c9359275f3beaf63d5fc441d/poweredsites/libs/utils.py?at=default
def _parse_config_file(path):
    config = {}
    execfile(path, config, config)
    for name in config:
        if name in options:
            options[name].set(config[name])
        else:
            define(name, default=config[name])

>>> # 找出一个序列中的偶数并将它们乘以3
>>> def even_filter(nums):
...     return filter(lambda x: x%2==0, nums)
... 
>>> def multiply_by_three(nums):
...     return map(lambda x: x*3, nums)
... 
>>> def convert_to_string(nums):
...     return map(lambda x: 'The number: %s' % x, nums)
... 
>>> def pipeline_func(data, fns):
...     return reduce(lambda a, x: x(a), fns, data)
... 
>>> def print_result(pipeline):
...     for each in pipeline:
...         print each
... 
>>> print_result(pipeline_func(range(1, 11), (even_filter, multiply_by_three, convert_to_string)))
The number: 6
The number: 12
The number: 18
The number: 24
The number: 30

>>> def f(a, b, c):
...     print 'a={}, b={}, c={}'.format(a, b, c)
...
>>> f(1, 2, 3)
a=1, b=2, c=3
>>> import functools
>>> ff = functools.partial(f, a=1, c=3); ff(2) # (1)不能跳着固定
Traceback (most recent call last):
  ...
TypeError: f() got multiple values for keyword argument 'a'
>>> ff = functools.partial(f, b=2, c=3); ff(1) # (1)
a=1, b=2, c=3
>>> ff = functools.partial(f, 1, c=3); ff(2) # (2)
a=1, b=2, c=3
>>> ff = functools.partial(f, 1); ff(2, 3) # (2)
a=1, b=2, c=3

>>> class A(object):
...     def __init__(self, x):
...         self.x = x
...     def __getattr__(self, name):
...         print "get: ", name
...         return self.__dict__.get(name)
...     def __setattr__(self, name, value):
...         print "set: ", name, value
...         self.__dict__[name] = value
...     def __delattr__(self, name):
...         print "del: ", name
...         self.__dict__.pop(name, None)
...     def __getattribute__(self, name):
...         print "attribute: ", name
...         return object.__getattribute__(self, name)
...
>>> a = A(10)       # __init__ 里面的 self.x=x 会被 __setattr__ 捕获
set:  x 10
attribute:  __dict__
>>> a.x             # 访问已存在的字段，仅被 __getattribute__捕获
attribute:  x
10
>>> a.y = 20        # 创建新字段，被 __setattr__ 捕获
set:  y 20
attribute:  __dict__
>>> a.z             # 访问不存在字段，被 __getattr__ 捕获
attribute:  z
get:  z
attribute:  __dict__
>>> del a.y         # 删除字段，被 __delattr__ 捕获
del:  y
attribute:  __dict__

class Dict(dict):

    def __init__(self, **kwargs):
        # super(Dict, self).__init__(**kwargs) 仅用于新式类
        dict.__init__(self, **kwargs)

    def __setattr__(self, key, value):
        self[key] = value

    def __getattr__(self, key):
        # If want to catch 'KeyError' raise 'AttributeError',  
        # '__missing__()' must raise 'KeyError' or remove `__missing__()`.
        return self[key]

    def __delattr__(self, key):
        self.pop(key, None)

    def __missing__(self, key):
        # Raise a error or
        return None

if __name__ == '__main__':
    d = Dict(a=1, b=2)
    print d             # {'a': 1, 'b': 2}
    print d['a']        # 1
    print d.a           # 1
    del d.a
    print d             # {'b': 2}
  　print d['c']　　　　　# None
    print d.c           # None

class D(object):
    def __init__(self, **kwargs):
        self._data = kwargs
    def __getitem__(self, key):
        return self._data.get(key)
    def __setitem__(self, key, value):
        self._data[key] = value
    def __delitem__(self, key):
        self._data.pop(key, None)
    def __contains__(self, key):
        return key in self._data.keys()
    def __repr__(self):
        return '{0!r}'.format(self._data)
    __str__ = __repr__

if __name__ == '__main__':
    d = D(a=1, b=2)
    print d          # {'a': 1, 'b': 2}
    print d['a']     # 1
    d['a'] = 10
    print d['a']     # 10
    del d['a']
    print d          # {'b': 2}

import abc


class Test(object):  # Py3: object 换成 metaclass=abc.ABCMeta

    __metaclass__ = abc.ABCMeta

    @classmethod
    def __subclasshook__(cls, sub_cls):
        if cls is Test:
            for super_cls in sub_cls.__mro__:  # __mro__ 仅在新式类下有效
                if 'test' in super_cls.__dict__:
                    return True
        return NotImplemented


class OneTest(object):

    def test(self):
        pass


class TwoTest(object):
    pass


if __name__ == '__main__':
    print(isinstance(OneTest(), Test))  # True
    print(isinstance(TwoTest(), Test))  # False

>>> class Mm(object):
...      def __init__(self):
...          self.same = '__dict__'
...      def same(self):
...          print 'non-data'
... 
>>> m = Mm()
>>> m.__dict__
{'same': '__dict__'}
>>> m.same
'__dict__'
>>> m.same() # 实例函数是 non-data descripter，优先级不如实例字典
Traceback (most recent call last):
  ...
TypeError: 'str' object is not callable

>>> class Name(object):
...     @property
...     def name(self):
...         print 'Get:'
...         return self._name
...     @name.setter
...     def name(self, value):
...         print 'Set: ', value
...         self._name = value
...     @name.deleter
...     def name(self):
...         print 'Del: name'
...         del self._name
... 
>>> n = Name()
>>> n.name = 'Damnever'
Set: Damnever
>>> n.name
Get:
'Damnever'
>>> del n.name
Del: name
>>> n.name
Get:
Traceback (most recent call last):
  ...
AttributeError: 'Name' object has no attribute '_name'

class MyClass(object):

    class_field = 'class field'

    def __init__(self):
        self.instance_field = 'instance_field'

    def instance_method(*args):
        print 'bound method args:', args
        print 'I can get:', args[0].instance_field

    @staticmethod
    def static_method(*args):
        print 'staticmethod args:', args

    @classmethod
    def class_method(*args):
        print 'classmethod args:', args
        print 'I can get:', args[0].class_field
        # print 'cm call static method:', args[0].static_method('sm')
        # print 'cm call bound method:', args[0]().instance_method()

if __name__ == '__main__':
    obj = MyClass()
    print '** Call classmethod:'
    obj.class_method()
    MyClass.class_method()
    print '** call staticmethod:'
    obj.static_method()
    MyClass.static_method()
    print '** call boundmethod:'
    obj.instance_method()

>>> ## 使用 type() 动态创建类
>>> def fn(self):
...     print 'dynamic'
...
>>> Foo = type('Foo', (object,), dict(foo_say=fn))
>>> Foo().foo_say()
dynamic
>>> type(Foo); type(Foo())
<type 'type'>
<class '__main__.Foo'>
>>> ## 使用元类来定制类
>>> class MyMetaclass(type):
...     def __new__(cls, name, bases, attrs):
...         # do sth.
...         return type.__new__(cls, name, bases, attrs)
... 
>>> class MyClass(object):
...     __metaclass__ = MyMetaclass # 指定元类
... 
>>> type(MyClass); type(MyClass())
<class '__main__.MyMetaclass'>
<class '__main__.MyClass'>

>>> class MyContext(object):
...     def __init__(self, text):
...         self._text = text
...     def __enter__(self):
...         print 'ENTER:', self.__class__.__name__
...         return self
...     def __exit__(self, exc_type, exc_val, exc_tb):
...         print 'EXIT:', self.__class__.__name__
...     def say(self):
...         print '%s say: %s' % (self.__class__.__name__, self._text)
... 
>>> with MyContext('Hello!') as mc:
...     mc.say()
... 
ENTER: MyContext
MyContext say: Hello!
EXIT: MyContext

>>> import contextlib
>>> with open('readfile', 'r') as reader,\
...         open('writefile', 'w') as writer:
...     writer.write(reader.read())
... 
>>> with contextlib.nested(open('readfile', 'r'), open('writefile', 'r'))\
...         as (reader, writer):
...     print writer.read(), reader.read()
... 
contextlib.nested
contextlib.nested

>>> def print_list(lst):
...     def func():
...         print lst
...     return func
...
>>> lst = [1, 2]
>>> g = print_list(lst)
>>> g()　　##　已经离开创建环境
[1, 2]
>>> ## lst.append(3)时，g()内部的引用和z仍然指向一个变量，而lst=[1]之后，两者就不再指向一个变量了。
>>> lst.append(3)
>>> g()
[1, 2, 3]
>>> lst = [1]  ## lst 已经是一个新的对象了
>>> g()
[1, 2, 3]
>>> g.__closure__ ;  g.func_closure
(<cell at 0x7ffd5fda7248: list object at 0x7ffd5fdaa680>,)
(<cell at 0x7ffd5fda7248: list object at 0x7ffd5fdaa680>,)
>>> print [str(c.cell_contents) for c in g.__closure__]
['[1, 2, 3]']
>>> def dump_closure(f):
...     if hasattr(f, '__closure__') and f.__closure__ is not None:
...         print '- Dumping function closure for %s:' % f.__name__
...         for i, c in enumerate(f.__closure__):
...             print '-- cell %d = %s' % (i, c.cell_contents)
...     else:
...         print '- %s has no closure!' % f.__name__
...
>>> dump_closure(g)
- Dumping function closure for func:
-- cell 0 = [1, 2, 3]

>>> def create_multipliers():
...     return [lambda x: i*x for i in range(5)] # 列表解析
... 
>>> for multiplier in create_multipliers():
...     print multiplier(2)
... 
8
8
8
8
8
>>> ## 在上面的代码中，当任一返回函数被调用的时候，i的值是在它被调用时的周围作用域中查找（到那时，循环已经结束了，所以i已经被赋予了它最终的值4）。
>>> def create_multipliers():
...     return [lambda x, i=i: i*x for i in range(5)]
... 
>>> for multiplier in create_multipliers():
...     print multiplier(2)
... 
0
2
4
6
8

@dec2
@dec1(arg)
def func(*args, **kwargs):
    pass
# 等价于
def func(*args, **kwargs):
    pass
func = dec2( dec1(arg)(func) )

>>> import functools
>>> def memo(func):
...     cache = {}
...     miss = object()
...     @functools.wraps(func)
...     def wrapper(*args):
...         result = cache.get(args, miss)
...         if result is miss:
...             result = func(*args)
...             cache[args] = result
...         return result
...     return wrapper
... 
>>> @memo
... def fib(n):
...     if n < 2: return n
...     return fib(n - 1) + fib(n - 2)
... 
>>> fib(2);  fib(5)
1
5

>>> g1 = [x*x for x in range(3)]
>>> g1
[0, 1, 4]
>>> g2 = (x*x for x in range(3)) # 这里变成了一个生成器
>>> print g2
<generator object <genexpr> at 0x7f45d219cd20>
>>> ########## 一个比较常见的用途是读取文件 ##########
>>> def read_file(fpath, block_size=1024):
...     with open(fpath, 'rb') as f:
...         while 1:
...             block = f.read(block_size)
...             if block:
...                 yield block
...             else:
...                 return
...
>>> for block in read_file('apt-get'):
...     print len(block)
... 
1024
397

>>> class MyIteration(object):
...      def __init__(self, sequence):
...          self._seq = sequence
...          self._count = len(sequence)
...      def __iter__(self):
...          return self
...      def next(self):
...          if self._count:
...             self._count -= 1
...             return self._seq[-self._count-1]
...          raise StopIteration
... 
>>> mi = MyIteration(range(4))
>>> for each in mi:
...     print each
... 
0
1
2
3

>>> def gen():
...     r = ''
...     for n in range(5):
...         print 'GEN:', r
...         try:  # 可以使用 try/finally
...             r = yield n
...         finally:
...             print '** generator exit'
... 
>>> g = gen()
>>> g.send('') # 开启生成器必须发送 None，其余都不行
Traceback (most recent call last):
  ...
TypeError: can't send non-None value to a just-started generator
>>> g.next() # 或 next(g) 或 g.send(None)
GEN: 
0
>>> g.send('hi, gen')
GEN: hi, gen
1
>>> g.throw(GeneratorExit) # g.close()也会执行finally块，不报异常(被pass)
** generator exit
Traceback (most recent call last):
  ...
GeneratorExit
>>> g.send('Hello, gen?') # 生成器已经被异常终止
Traceback (most recent call last):
  ...
StopIteration

>>> cnt = collections.Counter()
>>> for word in ['red', 'blue', 'red', 'green', 'blue', 'blue']:
...     cnt[word] += 1
...
>>> cnt
Counter({'blue': 3, 'red': 2, 'green': 1})
>>> dict(cnt)
{'blue': 3, 'green': 1, 'red': 2}
>>> list(collections.Counter(a=4, b=2, c=3, d=0).elements()) # element 将其展开
['a', 'a', 'a', 'a', 'c', 'c', 'c', 'b', 'b']
>>> collections.Counter('aaabbbbcccccdddddd').most_common(2) # most_common 返回出现最多的 n 个元素及其个数
[('d', 6), ('c', 5)]

>>> Point = collections.namedtuple('Point', ['x', 'y'])
>>> p = Point(1, 2)
>>> p.x
1
>>> p.y
2
>>> p.x, p.y
(1, 2)
>>> isinstance(p, Point)
True
>>> isinstance(p, tuple)
True
>>> t = [11, 22]
>>> Point._make(t)
Point(x=11, y=22)

>>> q = collections.deque(range(5))
>>> q.append(5)  # deque([0, 1, 2, 3, 4, 5])
>>> q.appendleft(-1)  # deque([-1, 0, 1, 2, 3, 4, 5])
>>> q.extend(range(2))  # deque([-1, 0, 1, 2, 3, 4, 5, 0, 1])
>>> q.count(1)
2
>>> q.extendleft(range(2,4))  # deque([3, 2, -1, 0, 1, 2, 3, 4, 5, 0, 1])
>>> q.pop(); q
1 deque([3, 2, -1, 0, 1, 2, 3, 4, 5, 0])
>>> q.popleft(); q
3 deque([2, -1, 0, 1, 2, 3, 4, 5, 0])
>>> q.remove(-1)  # deque([2, 0, 1, 2, 3, 4, 5, 0])
>>> q.reverse()  # deque([0, 5, 4, 3, 2, 1, 0, 2])
>>> q.rotate(1)  # deque([2, 0, 5, 4, 3, 2, 1, 0])

>>> s = [('yellow', 1), ('blue', 2), ('yellow', 3), ('blue', 4), ('red', 1)]
>>> d = collections.defaultdict(list)  # 传入的参数为 dict 值的缺省类型，可以是函数
>>> for k, v in s:
...     d[k].append(v) # == d.setdefault(k, []).append(v) 前提 d = {}
...
>>> d.items()
[('blue', [2, 4]), ('red', [1]), ('yellow', [1, 3])]
>>> d['black']
[]

>>> od = collections.OrderedDict()
>>> od['a'] = 1; od['b'] = 2; od['c'] = 3; od
OrderedDict([('a', 1), ('b', 2), ('c', 3)])
>>> collections.OrderedDict(sorted({'banana': 3, 'apple':4, 'pear': 1, 'orange': 2}.items(), key=lambda t: t[1]))
OrderedDict([('pear', 1), ('orange', 2), ('banana', 3), ('apple', 4)])
>>> od.popitem(); od.popitem(); od.popitem() # LIFO
('c', 3) ('b', 2) ('a', 1)

class LRU(object):

    def __init__(self, capacity):
        self._count = 0  # or len(self._cache.keys()), which is slow way
        self._capacity = capacity
        self._cache = collections.OrderedDict()

    def get(self, key):
        if key in self._cache:
            value = self._cache.pop(key)
            self._count -= 1
            self.set(key, value)
        return self._cache.get(key, -1)

    def set(self, key, value):
        if key in self._cache:
            self._cache.pop(key)
        elif self._count < self._capacity:
            self._count += 1
        else:
            self._cache.popitem(False)  # FIFO
        self._cache[key] = value

# clock: 返回当前进程消耗的CPU时间 (秒)。
# sleep: 暂停进程 (秒,可以是小小数,以便设置毫秒、微秒级暂停)。
>>> time.clock()
0.027975
>>> time.sleep(1)
# strftime: 将 struct_time 格式化为字符串。
# strptime: 将字符串格式化为 struct_time。
# %H 24小时制, %l 12小时制, %a/%A 简化（完整星期名称）, %b/%B 简peakhell化（完整本地月份名称）
>>> time.strftime("%Y-%m-%d %H:%M:%S", time.localtime(time.time()))
'2014-09-28 17:44:28'
# timezone: 与 UTC 的时差
# tzname: 当前时区名称
>>> time.timezone / 3600
-8
>>> time.tzname      # 北京时间, China Standard Time
('CST', 'CST')

# 创建 md5 加密对象
>>> m = hashlib.md5()
# 加密文本，可追加
>>> m.update("Nobody inspects")
>>> m.update(" the spammish repetition")
>>> print m.hexdigest()
bb649c83dd1ea5c9d9dec9a18df0ffe9
# new(name, string='') 第一个参数为OpenSSL库中存在的函数名
>>> hashlib.new("md5", "Nobody inspects the spammish repetition").hexdigest()
'bb649c83dd1ea5c9d9dec9a18df0ffe9'
# sha1 加密
>>> hashlib.sha1('Nobody inspects the spammish repetition').hexdigest()
'531b07a0f5b66477a21742d2827176264f4bbfe2'

# 创建一个新的 hmac 对象，new(key[, msg[, digestmod]])
>>> m1 = hmac.new("MyKey", "I'm young.")
# 输出被 hmac 加密后的十六进制数据。digest()非十六进制
>>> print m1.hexdigest()
c83ac1cac45ba92b2f6629bee67fb953peakhell
# 用新字符串来更新 hmac
>>> m1.update("I'm old.")
>>> print m1.hexdigest()
3ee16436c0621a5d46fc8f3a4eb1d27e
# update(a); update(b) == update(a + b)
>>> m2 = hmac.new("MyKey")
>>> m2.update("I'm young."); m.update("I'm old.")
>>> print m2.hexdigest()
3ee16436c0621a5d46fc8f3a4eb1d27e
# 拷贝一个 hmac 的副本
>>> m3 = m2.copy()
>>> print m3.hexdigest()
3ee16436c0621a5d46fc8f3a4eb1d27e
>>> print hmac.new("MyKey", "I'm young.I'mold.").hexdigest()
aa0fb38cbe017bdb388fbfb9f9da1645

>>> m = md5.new()
>>> m.update("Hello,")
>>> m.update(" world!")
>>> m.hexdigest()
'6cd3556deb0da54bca060b4c39479839'
>>> md5.new("Hello, world!").hexdigest()
'6cd3556deb0da54bca060b4c39479839'
>>> md5.md5("Hello, world!").hexdigest()
'6cd3556deb0da54bca060b4c39479839'

>>> s = sha.new()
>>> s.update("Hello,")
>>> s.update(" world!")
>>> s.hexdigest()
'943a702d06f34599aee1f8da8ef9f7296031d699'
>>> sha.new("Hello, world!").hexdigest()
'943a702d06f34599aee1f8da8ef9f7296031d699'

# Neither of these calls raises an exception, but the results are not valid JSON 【Infinity, -Infinity, NaN】
>>> json.dumps(float('-inf'))
'-Infinity'
>>> json.dumps(float('nan'))
'NaN'
# Same when deserializing
>>> json.loads('-Infinity')
-inf
>>> json.loads('NaN')
nan
# 一个 json 对象里定义的名字必须是无二的
>>> json.loads('{"x":1, "x":2, "x": 3}')
{u'x': 3}
# dump()/load() 可传入文件对象

>>> base64.b64encode('Hello, world!')
'SGVsbG8sIHdvcmxkIQ=='
>>> base64.b64decode('SGVsbG8sIHdvcmxkIQ==')
'Hello, world!'

>>> base64.b64encode('i\xb7\x1d\xfb\xef\xff')
'abcd++//'
>>> base64.urlsafe_b64encode('i\xb7\x1d\xfb\xef\xff')
'abcd--__'
>>> base64.urlsafe_b64decode('abcd--__')
'i\xb7\x1d\xfb\xef\xff'

>>> x = uuid.UUID('{00010203-0405-0607-0809-0a0b0c0d0e0f}')
>>> str(x)
'00010203-0405-0607-0809-0a0b0c0d0e0f'
>>> x.bytes
'\x00\x01\x02\x03\x04\x05\x06\x07\x08\t\n\x0b\x0c\r\x0e\x0f'
>>> print uuid.UUID(bytes=x.bytes)
00010203-0405-0607-0809-0a0b0c0d0e0f
>>> print uuid.uuid1()
292b1924-4c96-11e4-8413-000c298861ee
>>> print uuid.uuid3(uuid.NAMESPACE_DNS, 'python.org')
6fa459ea-ee8a-3ca4-894e-db77e160355e
>>> print uuid.uuid4()
1e31baf7-cb01-4e22-b18a-2f830ee6f4d8
>>> print uuid.uuid4().hex
e17366f236084bdc8ed46ee5cdaddbe4
>>> print uuid.uuid5(uuid.NAMESPACE_DNS, 'python.org')
886313e1-3b8a-5372-9b90-0c9aee199e5d

Message          # 继承关系 #
    MIMEBase
        MIMEMultipart
        MIMENonMultipart
            MIMEMessage
            MIMEText
            MIMEImage

>>> c = Cookie.SimpleCookie()
>>> c['number'] = 80; c['number'].value
'80'
>>> c['string'] = 'eight'; c['string'].value
'eight'
>>> print c   #  print c.output() 与其一样
Set-Cookie: number=80
Set-Cookie: string=eight
>>> c = Cookie.SimpleCookie()
>>> c['rocky'] = 'road'
>>> c['rocky']['path'] = '/cookie'
>>> print c.output(attrs=[], header='Cookie:') # attrs 若设置为空，只显示第一个；header 设置开始字符
Cookie: rocky=road
>>> print c.output(attrs=['rocky', 'path'], header='Cookie:')
Cookie:  rocky=road; Path=/cookie
>>> c = Cookie.SimpleCookie()
>>> c.load("chips=ahoy; vienna=finger") # 将字符串转化成 Morsel 形式
>>> print c
Set-Cookie: chips=ahoy
Set-Cookie: vienna=finger
>>>c.lear() # 清除存储的 cookie 数据

>>> doc = urllib.urlopen("http://www.baidu.com/")
>>> print doc.info()
...<消息报头>...
>>> doc.info().getheader('Content-Type')
'text/html; charset=utf-8'

 >>> urllib.urlencode({"name": ["user", "user2"], "age": 20})
'age=20&name=%5B%27user%27%2C+%27user2%27%5D'
>>> urllib.urlencode({"name": ["user", "user2"], "age": 20}, False)
'age=20&name=%5B%27user%27%2C+%27user2%27%5D'
>>> urllib.urlencode({"name": ["user", "user2"], "age": 20}, True)
'age=20&name=user&name=user2'

 >>> urllib.pathname2url("D:\home\lastd\Documents")
'D%3A%5Chome%5Clastd%5CDocuments' # 不再被解析成路径

 >>> urllib.url2pathname("D%3A%5Chome%5Clastd%5CDocuments")
'D:\\home\\lastd\\Documents'   # \ 被转义, 同 /

>>> hh = urllib2.HTTPHandler(debuglevel = 1)
>>> opener = urllib2.build_opener(hh)
>>> opener.open("http://www.baidu.com/")

# 设置本地变量，执行函数
{% set *x* = *y* %}
{% apply *function* %} ... {% end %}    # 有待研究
# 转义
{% autoescape *function* %}
{% raw *expr* %}
# 注释
{% comment ... %}
# 外部文件
{% extends *filename* %}
{% block *name* %} ... {% end %}
{% include *filename* %}
{% module *expr* %}    # 渲染 UIModule
# 导入
{% from *x* import *y* %}  # 和 Python语句一样, 有待研究
{% import *module* %}
# 流程控制
{% for *var* in *expr* %} ... {% end %}
{% if *condition* %} ... {% elif *condition* %} ... {% else %} ... {% end %}
{% while *condition* %} ... {% end %}
{% try %} ... {% except %} ... {% else %} ... {% finally %} ... {% end %}
```一杯
默认提供了一些方法: escape(), url_escape(), json_encode(), squeeze().
可以添加任意自命名的方法 (在 tornado.web.RquestHandler 里, 可重写 get_template_namespace):
```Python
# Python code
def add(x ,y):
       return x + y
tornado.template.execute(add = add)
# the template
{{ add(1, 2) }}