在 stackoverflow 上看到有一个讨论 Hidden features of Python 很有意思，因此将上面的问题和答案收集起来，以便以后查阅。

拆分函数参数

你可以通过使用 * 和 ** 来拆分一个作为函数参数的元组、列表或者字典。

def draw_point(x, y):
    print x, y

point_foo = ('a', 'b')
point_list = [5, 4]
point_bar = {'y': 3, 'x': 2}

draw_point(*point_foo)    #a b
draw_point(*point_list)    #5 4
draw_point(**point_bar)    #2 3

可以注意一下上述代码中 print x, y 的用法哦。

连环比较运算符

>>> x = 5
>>> 1 < x < 10
True
>>> 10 < x < 20
False
>>> x < 10 < x*10 < 100
True
>>> 10 > x <= 9
True
>>> 5 == x > 4
True
>>> True > 4
False

你有可能会认为先执行 1 < x，返回 True，然后比较 True < 10，返回 True。然而并不是这样的（上述逻辑对于代码的最后两个例子不成立）。连环比较运算符其实是将 1 < x < 10 转化成 1 < x and x < 10，将 x < 10 < x*10 < 100 转化成 x < 10 and 10 < x * 10 and x*10 < 100。

修饰符

修饰符允许将一个函数或者方法封装到另一个可以添加功能、修改参数或者结果等的函数中。修饰符需要写在函数定义的上一行，并且以 @ 开头。

下面的例子介绍了 print_args 修饰符在调用被修饰函数（write函数）之前，打印了被修饰函数的参数：

>>> def print_args(function):
...     def wrapper(*args, **kwargs):
...         print 'Arguments:', args, kwargs
...         return function(*args, **kwargs)
...     return wrapper
...
>>> @print_args
... def write(text):
...     print text
...
>>> write('foo')
Arguments: ('foo',) {}
foo

这部分还没看懂，留到以后再研究。

小心可变的默认参数

下面例子的意图是：当不带参数调用函数时，打印一个默认的列表 [1]。但是结果并没有达到预期：

>>> def foo(x=[]):
...     x.append(1)
...     print x
...
>>> foo()
[1]
>>> foo()
[1, 1]
>>> foo()
[1, 1, 1]

为了达到默认参数的作用，应该这样做：

>>> def foo(x=None):
...     if x is None:
...         x = []
...     x.append(1)
...     print x
...
>>> foo()
[1]
>>> foo()
[1]
>>> foo([2,1,'a'])
[2, 1, 'a', 1]
>>> foo()
[1]

或者

>>> def foo(x=None):
...     x = x or []
...     x.append(1)
...     print x
...
>>> foo()
[1]
>>> foo()
[1]
>>> foo([2,1,'a'])
[2, 1, 'a', 1]
>>> foo()
[1]

描述符（Descriptors）

当你使用小圆点来访问一个成员时（例如，x.y），Python 首先会在实例字典中查找该成员。如果找不到，会继续在类字典中查找。如果在类字典中找到，并且该对象实现了描述符的协议，而不是仅仅返回成员，那么 Python 会执行它。一个描述符是指任何实现了 __get__、__set__ 和 __delete__ 方法的类。

下面使用描述符来实现自己的 property 类：

class Property(object):
    def __init__(self, fget):
        self.fget = fget

    def __get__(self, obj, type):
        if obj is None:
            return self
        return self.fget(obj)

接下来，你就可以像使用内置的 property() 一样使用上面的类：

class MyClass(object):
    @Property
    def foo(self):
        return "Foo!"

这一部分我也没搞懂，详细的可以参考 How-To Guide for Descriptors。

enumerate

将一个可迭代对象包进 enumerate 中，它会输出索引和对应的项。例如：

>>> a = ['a', 'b', 'c', 'd', 'e']
>>> for index, item in enumerate(a): print index, item
...
0 a
1 b
2 c
3 d
4 e
>>> b = ('a', 'b', 'c', 'd', 'e')
>>> for index, item in enumerate(b): print index, item
...
0 a
1 b
2 c
3 d
4 e