Python 一些特性总结

Python特殊运用

1、yield

(1) 创建一个生成器函数

def test_yield():
    yield 1
    yield 2
    yield 3

(2)使用next()方法从这个对象中获取中间值

>t = test_yield()
>t.next()
>1
>t.next()
>2
>t.next()
>3
>t.next()
>StopIteration

当生成器没有返回值返回时，则抛出StopIteration异常
(3)迭代

>for item in test_yield():
>    print item
>1
>2
>3

2、with
它在Python 2.6 中正式启用.(Python2.5 尝试性
的引入了with, 并对使用with 作为标识符的应用程序发出这样的警告 - 在Python 2.6 中,with
将会成为关键字. 如果你想在Python 2.5 使用 with 语句, 你必须用from __future__ import
with_statement 来导入它.)

类似try-except-finally , with 语句也是用来简化代码的,这与用try-except 和try-finally
所想达到的目的前后呼应.try-except 和try-finally 的一种特定的配合用法是保证共享的资源的
唯一分配,并在任务结束的时候释放它。然而，with 语句的目的在于从流程图中把 try,except 和

finally 关键字和资源分配释放相关代码统统去掉, 而不是像 try-except-finally 那样仅仅简化代

码使之易用
声明：
with context_expr [as var]
    with_suite

例如：

>with open('hello.txt','r') as f:
>    for line in f:
>        print line

3、 lambda
声明:lambda [arg1[, arg2, ... argN]]: expression
用合适的表达式调用一个lambda 生成一个可以像其他函数一样使用的函数对象。它们可被传入
给其他函数，用额外的引用别名化，作为容器对象以及作为可调用的对象被调用（如果需要的话

，
可以带参数）。当被调用的时候，如过给定相同的参数的话，这些对象会生成一个和相同表达式

等价
的结果。它们和那些返回等价表达式计算值相同的函数是不能区分的。

> a = lambda x, y = 2: x + y
> a(1)
3
>a(1,5)
>6

lambda 表达式运作起来就像一个函数，当被调用时，创建一个框架对象。
也可以直接调用lambda

>(lambda x : x *2)(3)

6
lambda与函数的等价关系

def add(x,y):return x + y == lambda x,y: x+y

4、map()、zip()、filter()、reduce()
a、map()
声明：map(func,seq[,seq,...]) ->
func：为自定义函数，该函数作用于参数seq，如果func值为None，则map()返回
seq组成的tuple，list
(1)对tuple解包

>tuple = (('apple','banana'),('red','blue'),('a',),('b',))
>i = 0
>for a in map(None,tuple):
>    print "tuple[%d]:"%i, "",
>    for x in a:
>        print x, "",
>    print
>    i += 1
tuple[0]: apple banana
tuple[1]: red blue
tuple[2]: a
tuple[3]: b

(2)对list解包

> list = [1,2,3,4]
> for a in map(None,list):
>      print a
1
2
3
4

>def add(x):
>    return x + 2
>for a in map(add,[1,2,3,4]):
>    print a
3
4
5
6

>def add(x,y):
>    return x + y
>for a in map(add,[1,2,3],[3,2,1])
4
4
4

(3)使用lambda

>map(lambda x:x*2,[1,2,3,4])
[2,4,6,8]
>map(lambda x,y:x*y,[1,2,3],[3,2,1])
[3,4,3]

b、zip()
声明：zip([iter,...])
接受一系列可迭代的对象作为参数，将对象中对应的元素打包成一个个tuple（元组），然后返

回由这些tuples组成的list（列表）。若传入参数的长度不等，则返回list的长度和参数中长度最

短的对象相同。利用*号操作符，可以将list unzip（解压）
(1)

>a = [1,2]
>b = [3,4]
>zip(a,b)
[(1,3),(2,4)]
>zip(*zip(a,b))
[(1,2),(3,4)]

c、filter()
声明：filter(func, seq)
filter 函数为已知的序列的每个元素调用给定布尔函数。每个filter 返回的非零（true)值元素添

加到一个列表中。返回的对象是一个从原
始队列中“过滤后”的队列

>list = [1,2,3,4]
>f = filter(lambda x :x > 2, list)
>print f
[3,4]

>b = filter(None, list)
>[1,2,3,4]

d、reduce()
声明：reduce(func,seq[,init])
将二元函数作用于seq 序列的元素，每次携带一对（先前的结果
以及下一个序列元素），连续的将现有的结果和下雨给值作用在获
得的随后的结果上，最后减少我们的序列为一个单一的返回值；如
果初始值init 给定，第一个比较会是init 和第一个序列元素而不
是序列的头两个元素

reduce(func, [1, 2, 3]) = func(func(1, 2), 3)
>reduce(lambda x,y:x*y,[1,2,3]) #((1*2)*3)
>6

>reduce(lambda x,y:x*y, [1,2,3], 10) #((1*2)*3)*10
>60