前言

文章有点标题党，主要是分享一些Python好用的语法糖，用更少的代码实现同样的功能，而且还很优雅。

兵器谱

1. if

python没有三目运算符，我挺苦恼的，比如把两个整数较大的那个复制给一个变量，有三目运算符的语言会这样写：

a = 1
b = 2
c = a > b ? a : b

后来发现Python的if语句可以写成一行完成上述功能：

c = a if a > b else b

1. with

我们通常以如下形式操作文件：

try: f = open('/path/to/file', 'r') 
    print f.read()
finally: 
    if f: 
        f.close()

每次这样写太繁琐，来试试with的威力：

with open('/path/to/file', 'r') as f: 
    print f.read()

代码更佳简洁，并且不必调用f.close()方法。
with利用了上下文管理协议，这玩意说起来太复杂，直接上代码。
自定义一个支持上下文管理协议的类, 类中实现enter方法和exit方法。

class MyWith(object):
    def __enter__(self):
        print "Enter with"
        return self  # 返回对象给as后的变量
    def __exit__(self, exc_type, exc_value, exc_traceback):
        #关闭资源等
        if exc_traceback is None:
            print "Exited without Exception"
            return True
        else:
            print "Exited with Exception" 
            return False
def test_with():
    with MyWith() as my_with:
        print "running my_with"
    print "------分割线-----"
    with MyWith() as my_with:
        print "running before Exception"
        raise Exception
        print "running after Exception"
if __name__ == '__main__':
    test_with()

输出：

Enter with
running my_with
Exited without Exception
------分割线-----
Enter with
running before Exception
Exited with Exception

1. map

大多数的for循环可以用map来代替，用法是：map(func,seq)，对seq中的每个元素进行操作，具体什么操作在func里定义。
我们以前是这么写for循环的：

array = [1, 2, 3]
square_array = []
for i in array:
     square_array.append(i ** 2)

改用map：

array = [1, 2, 3]
square_array = map(lambda i: i ** 2, array)

map的第一个参数是lambda表达式，冒号前面的i作为形参，来自于array中的元素，冒号后面就是要返回的值。
当然你也可以使用列表推导式来代替：

array = [1, 2, 3]
square_array = [i ** 2 for i in array]

1. filter

用法与map类似：filter(func,seq)，对seq中的元素进行过滤，返回符合条件的那些元素。
比如返回array = [1, 2, 3, 4]中的所有奇数：

print filter(lambda i: i % 2, array)

这里是对2取余，返回结果为True的元素。那么什么情况下结果为True？Python里面不为0，None或者null都是True。所以结果就是，偶数是False，奇数是True，返回所有奇数。
列表推导式方案：

print [i for i in array if i % 2 != 0]

1. reduce

用法：reduce(func,seq)，对seq中的每个元素进行func操作，最后汇总返回一个值。

1. 求array = [1, 2, 3]所有元素的和：

```
print reduce(lambda x, y: x + y, array)
```

reduce会先将array里面的头两个数分别作为x和y，求它们的和，然后把它的结果和第三个相加，再把结果和第四个相加，直到最后一个元素。

1. 求array = [1, 2, 3]中的最大值：

print reduce(lambda x, y: x if x > y else y, array)

1. 求strings = ["abc", "abcd", "def"]中"abc"出现的总次数：

print reduce(lambda count, str: count + str.count("abc"), strings, 0)

第三个参数0是count的初始值。

1. eval

执行一个字符串表达式，并返回表达式的值。

print eval("1 + 1")
>> 2

再来个复杂点的：

def init():
     return 1
def func(num):
     return 2
action = {"num": init, "func": func}
expression = 'func(num)'
print eval(expression, action)
>> 2

看不懂就算了，这玩意写起来很飘逸，但是杀敌一千，自损八百。

1. 装饰器
   设计模式的中的装饰器模式还记得吧，可以动态扩展一个类的功能，但是又不会修改这个类的源码，Java IO包大量采用了装饰器模式，我们来看看Python是怎么玩的。
   举个简单的例子吧，在一个函数执行前打日志：

def log(func):
     def wrapper(*args, **kwargs):
         print('call %s()' % func.__name__)
         return func(*args, **kwargs)
     return wrapper

@log
def func():
     print 'do something'

func()

输出：

call func()
do something

1. 生成器

yield是Python核心关键字，不懂生成器，基本上就是把Python当加强版的Shell在用。
迭代是在程序开发中常用的操作，对一个列表进行遍历。可是如果列表数据过多，比如有上亿条，就会遇到问题，因为内存空间有限。生成器应运而生，举个斐波那契数列的例子：

def fib(n):
     a = b = 1
     for i in range(n):
         yield a
         a, b = b, a + b

for i in fib(10):
     print i,

输出：

1 1 2 3 5 8 13 21 34 55

配合send、next函数，生成器可以实现协程的功能：

def func():
     while True:
         n = yield
         print n

gen = func()
print gen.next()
gen.send(2)
gen.send(3)

输出：

None
2
3

调用next函数后，代码执行到yield，因为后面没有任何值，所以打印出来的结果是None，此时代码hold住，让出CPU。调用send(2)后代码恢复执行，将2赋给n然后打印，yield自带next函数功能，代码继续执行到yield，周而复始。通过生成器在单线程的情况下实现了任务调度。

1. for/else

我们经常使用for循环来查找元素，有两个场景会使循环停下来：
1. 元素被找到，触发break。
1. 循环结束。
但是我们并不知道是哪个原因导致循环结束，通常是设置一个标记，元素被找到，改变标记的值。for/else可以很优雅地解决这个问题：

for i in range(10):
 if i > 10:
        print i
 else:
        print("can't find result")