在知乎上看到的问题——python有哪些优雅的代码实现。
下面的代码大概也算不上优雅。
一下代码在python3中实现
更多内容可见：http://book.pythontips.com/en/latest/args_and_kwargs.html
lambda函数的使用
lambda，又称匿名函数。当我们在传入函数时，有些时候，不需要显式地定义函数，直接传入匿名函数更方便。
比如命名一个普通的函数：
def f(x):
return x * x
在这里，f为函数名，x是函数的参数,x*x则是函数的返回结果。
我们可以换成lambda的形式则是：
>>> lambda x : x*x
<function <lambda> at 0x7fa2d1298048>
>>> f = lambda x : x*x
>>> f(3)
9
lambda函数有一个限制就是函数中只能有一个表达式（事例中的x*x），该表达式的结果即是返回值。当然这个表达式可以用下面的一些技巧写的更“优雅”一些。
其中lambda函数返回是一个对象，其实在python中，绝大部分的都是对象，函数也是对象。所以我们能将lambda函数赋给其它对象（事例中的f)。但是不建议这么做。一般使用lambda表达式时要注意：
１.逻辑简单，切忌在一个lambda表达式中做出很复杂的逻辑，这么做可能感觉逼格很高但是代码的可读性会变得非常差。
２.一次性使用，就像上面所说的不建议使用f = lambda x:....的形式
map,reduce,filter函数的使用
map()函数接收两个参数，一个是函数，一个是Iterable，map将传入的函数依次作用到序列的每个元素，并把结果作为新的Iterator返回。
比如我们有一个函数f(x)=x2，要把这个函数作用在一个list [1, 2, 3, 4, 5, 6, 7, 8, 9]上，就可以用map()实现如下：
>>> def f(x):
... return x * x
...
>>> r = map(f, [1, 2, 3, 4, 5, 6, 7, 8, 9])
>>> list(r)
[1, 4, 9, 16, 25, 36, 49, 64, 81]
其中注意，传进map()的第一个参数是 f 而不是f(),其中f表示的是f函数对象本身而f（）则是对函数f的调用。
map()作为高阶函数，事实上它把运算规则抽象了，因此，我们不但可以计算简单的f(x)=x2，还可以计算任意复杂的函数，比如，把这个list所有数字转为字符串：
>>> list(map(str, [1, 2, 3, 4, 5, 6, 7, 8, 9]))
['1', '2', '3', '4', '5', '6', '7', '8', '9']
当然，map()中还可以传入lambda表达式：
>>> list(map(lambda x: x*x,range(10)))
[0, 1, 4, 9, 16, 25, 36, 49, 64, 81]
或者再结合一下：
>>> list(map(lambda x: str(x*x),range(10)))
['0', '1', '4', '9', '16', '25', '36', '49', '64', '81']
再看reduce的用法。reduce把一个函数作用在一个序列[x1, x2, x3, ...]上，这个函数必须接收两个参数，reduce把结果继续和序列的下一个元素做累积计算，其效果就是：
reduce(f, [x1, x2, x3, x4]) = f(f(f(x1, x2), x3), x4)
比方说对一个序列求和，就可以用reduce实现：
>>> from functools import reduce
>>> reduce(lambda x,y:x+y,[1,2,3,4])
10
Python内建的filter()函数用于过滤序列。
和map()类似，filter()也接收一个函数和一个序列。和map()不同的是，filter()把传入的函数依次作用于每个元素，然后根据返回值是True还是False决定保留还是丢弃该元素。
例如返回一个list中的奇数：
>>> list(filter(lambda x:x % 2 == 1,range(10)))
[1, 3, 5, 7, 9]
列表推导
列表推导，又称列表生成式，即List Comprehensions，是Python内置的非常简单却强大的可以用来创建list的生成式。
举个例子，要生成list [0,1, 2, 3, 4, 5, 6, 7, 8, 9]可以用list(range(10))：
>>> list(range(10))
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
在python2中有点区别，python2中的range()直接生产列表而python3中生产的是一个range对象，需要通过list或者[]来生成。
>>> [x for x in range(10)]
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
或者进阶一点点：
>>> [x*x for x in range(10)]
[0, 1, 4, 9, 16, 25, 36, 49, 64, 81]
>>> [str(x) for x in range(10)]
['0', '1', '2', '3', '4', '5', '6', '7', '8', '9']
>>> L = ['Hello', 'World', 'IBM', 'Apple']
>>> [s.lower() for s in L]
['hello', 'world', 'ibm', 'apple']感觉它的写法有点想lambda表达式。
然后其中也可以多几层的嵌套：
>>> [m + n for m in 'ABC' for n in 'XYZ']
['AX', 'AY', 'AZ', 'BX', 'BY', 'BZ', 'CX', 'CY', 'CZ']
三层和三层以上的循环就很少用到了。
yield和generator生成器
简单地讲，yield 的作用就是把一个函数变成一个 generator。
例如使用yield生成裴波那契数列：
def fab(max):
n, a, b = 0, 0, 1
while n < max:
yield b
# print b
a, b = b, a + b
n = n + 1
>>> for n in fab(5):
... print n
...
1
1
2
3
5
使用yield的好处在于，它返回的是一个generator生成器。类似于python3中的range()和python2中的xrange()。带有 yield 的函数不再是一个普通函数，Python 解释器会将其视为一个 generator，调用 fab(5) 不会执行 fab 函数，而是返回一个 iterable 对象！在 for 循环执行时，每次循环都会执行 fab 函数内部的代码，执行到 yield b 时，fab 函数就返回一个迭代值，下次迭代时，代码从 yield b 的下一条语句继续执行，而函数的本地变量看起来和上次中断执行前是完全一样的，于是函数继续执行，直到再次遇到 yield。
因为返回的是一个生成器，所以可以使用next()方法进行访问：
>>> f = fab(5)
>>> next(f)
1
>>> next(f)
1
>>> next(f)
2
>>> next(f)
3
>>> next(f)
5
generator生成器，前面我们看了列表推导，使用[]进行生成，其中把[]换成()，就创建了一个generator：
>>> L = [x * x for x in range(10)]
>>> L
[0, 1, 4, 9, 16, 25, 36, 49, 64, 81]
>>> g = (x * x for x in range(10))
>>> g
<generator object <genexpr> at 0x7fd2264607d8>
L是一个list，而g是一个generator。其中generator是可迭代的。
装饰器
装饰器（Decorator），当我们希望为函数增加功能，但是却不想修改原函数又或者没有权限修改原函数的时候，就需要用到装饰器了。
比如我们有一个函数：
def func():
print("I have a dream!")
func() I have a dream!
是的，我有一个梦想！现在我们想要知道我什么时候有一个梦想，就是我们需要在执行函数的时候打印时间。那么：
'''定义一个装饰器'''
def log_time(func):
def wrapper(*args, **kw):
print("run %s() and time is :" % func.__name__+str(datetime.datetime.now()))
return func(*args,**kw)
return wrapper @log_time
def func():
print("I have a dream!") func()
输出：
run func() and time is :2016-10-10 14:26:08.296495
I have a dream!
本质上，decorator就是一个返回函数的高阶函数。其中，我们给log_tim()传入一个参数，这个参数是一个函数对象，并且返回一个函数对象。然后在其中定义了wrapper()，这两个参数并没有意义，只是为了说明这里面可以传入任意类型的参数。
然后用＠语法将其放在函数定义处。其相当于：
func = log_time(func)
由于log_time()是一个decorator，返回一个函数，所以，原来的func()函数仍然存在，只是现在同名的func变量指向了新的函数，于是调用func()将执行新函数，即在log_time()函数中返回的wrapper()函数。
在使用装饰器时请注意：
用decorator修饰一个函数得到另一个函数时，原来的那个函数依然是逻辑中心，而decorator所增加的只是相对外围的功能，不能那个什么宾那个什么主。
即使去掉装饰器，整个函数的逻辑仍需完整、清晰。
欢迎多来访问博客：http://liqiongyu.com/blog
微信公众号：