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