python 内置函数和表达式

对于简单的函数来说，可以使用类似于三元运算来表示，即: lambda表达式

格式： lambda [arg1[, arg2, ... argN]]: expression

先来看看三元表达式

#普通的条件语句

if  1  == 1:

    name = "budongshu"

else:

    name = "yangchi"

#三元表达式

name = "budongshu" if 1 == 1 else   "yangchi"

正式登场lambda表达式

#普通的函数

def func(arg):

    return arg + 1

result = func(250)

print "result  =  ", result

#lambda表达式

my_lambda = lambda arg: arg + 1

print "result = ",my_lambda(250)

上面的方法，都实现了结果为 251 这个功能

lambda也允许使用默认值和使用变长参数

lambda x,y = 2: x + y

lambda *z: z

调用lambda函数

>>> a  = lambda x, y = 2: x + y

>>> a(1,3)

4

>>> b = lambda *z: z

>>> b(10,"budongshu")

(10, 'budongshu')

python的内置函数 -----map() ,reduce() , filter()

下面这些函数，来结合lambda，效果更强劲

1 ，map 函数

格式： map(func,seq1[,seq2...])

python函数式编程中，map()函数式将func作用于序列的每个元素，对每个元素进行操作，最终获取新的序列

>>> print map( lambda x: x + 3,range(6))                #map函数

[3, 4, 5, 6, 7, 8]

>>> print [x + 3 for x in range(6) ]                    #列表解析也可以做到

[3, 4, 5, 6, 7, 8]

那么我们什么时候使用map函数呢

原来，当序列多于一个时，map可以并行地对每个序列执行

>>> print map( lambda x,y: x*y,[1,2,3],[4,5,6])        #一对一的进行乘法运算 ，返回一个新的列表

[4, 10, 18]

>>> print map( lambda x,y: (x*y,x+y),[1,2,3],[4,5,6])  #同时运行加法和乘法 ，并把和，积 存在一个元组里，

[(4, 5), (10, 7), (18, 9)]

>>> print map(None,[1,2,3],[4,5,6])                    #func为None的时候  ，把相同位置的元素存在一个元组里

[(1, 4), (2, 5), (3, 6)]

需要注意的是，不同长度的多个序列时是无法执行map函数的，会出现类型错误。

2 ，reduce 函数

格式: reduce(func, seq[,init])

对于序列内的所有元素进行累计操作

>>> li = [11,22,33]

>>> print reduce(lambda x,y:x + y,li)

66

3 , filter 函数

格式：filter( func, seq)

该内建函数的作用相当于一个筛子。func函数是一个布尔函数 , filter()调用这个布尔函数，将每个序列中的元素依次过一遍筛子，

选出使func返回值是Ture的元素的序列。

举个栗子

>>> li = [11,22,33]

>>> print  filter( lambda x: x>22 , li )

[33]

再举个栗子

假设我这里有一些学生的成绩，现在要筛选出[80-90]区间的成绩，下面的栗子使用不同的方法进行实现

scores  = [55,90,80,83,11,99.100,79]

def score_filter( score):

    return score >= 80 and score < 90 

#普通方法

filtered_score  = []

for i in scores:

    if scores_filter(i):

        filtered_score,append(i)

#filter()方法

print filter( score_filter,scores )     

#列表解析 list comprehension方法

print [score for score in scores if score >=80 and score < 90]

yield 生成器

一、迭代器(iterator)

在介绍yield前有必要先说明下Python中的迭代器(iterator)和生成器(constructor)。

在Python中，for循环可以用于Python中的任何类型，包括列表、元祖等等，实际上，for循环可用于任何“可迭代对象”，

这其实就是迭代器，迭代器是一个实现了迭代器协议的对象，Python中的迭代器协议就是有next方法的对象会前进到下一结果，

而在一系列结果的末尾是，则会引发StopIteration。任何这类的对象在Python中都可以用for循环或其他遍历工具迭代，

迭代工具内部会在每次迭代时调用next方法，并且捕捉StopIteration异常来确定何时离开。

1 ，对比一下range和xrange的区别

>>> print range(10)

[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]

>>> print xrange(10)

xrange(10)

>>>

如上述代码所示， range会在内存中创建所有指定的数字，而xrange不会立即创建，

只有在迭代循环的时候，才会去建立每个数组

2 , 文件操作的 read 和 xreadlinex 的的区别

read会读取所有内容到内存

xreadlines则只有在循环迭代时才获取

二、生成器(constructor)

生成器函数在Python中与迭代器协议的概念联系在一起。简而言之，包含yield语句的函数会被特地编译成生成器。

当函数被调用时，他们返回一个生成器对象，这个对象支持迭代器接口。函数也许会有个return语句，但它的作用

是用来yield产生值的。不像一般的函数会生成值后退出，生成器函数在生成值后会自动挂起并暂停他们的执行和状态，

他的本地变量将保存状态信息，这些信息在函数恢复时将再度有效

>>> def g(n):

...     for i in range(n):

...             yield i ** 2

...

>>> for i in g(5):

...     print i,":",

...

0 : 1 : 4 : 9 : 16 :

>>> t = g(n)

Traceback (most recent call last):

  File "<stdin>", line 1, in <module>

NameError: name 'n' is not defined

>>> t = g(5)

>>> t.next()

0

>>> t.next()

1

>>> t.next()

4

>>> t.next()

9

>>> t.next()

16

>>> t.next()

Traceback (most recent call last):

  File "<stdin>", line 1, in <module>

StopIteration

在运行完5次next之后，生成器抛出了一个StopIteration异常，迭代终止。

再来看一个yield生成器的例子：

def  new_range(num):

    temp = -1

    while True:

        temp = temp + 1

        if temp >= num:

            return

        else:

            yield temp

y = new_range(10)

for i in y:

    print i

扩展一下下

冒泡算法

需求：请按照从小到大对列表 [13, 22, 6, 99, 11] 进行排序

思路：相邻两个值进行比较，将较大的值放在右侧，依次比较！

分析: 每次循环的时候，都是用其中一个数跟其他的数进行比较，经过比较，找到此次循环最大的数，放在右侧，

但此列表中有五个数,需要依次比较出4个大的数放在右侧，而每次寻找到一个最大数后，下次在进行比较的时候，

就可以忽略之前已经比较出来最大的数，所以就下面这个例子需要经过四个循环，每次循环的比较次数减掉一个，

最后每次最小的数就自动在最左侧了

#!/usr/bin/env python 

li = [13, 22, 6, 99, 11]

for m in range(4):

    if  li[m] > li[m+1]:

        temp = li[m+1]

        li[m+1] = li[m]

        li[m] = temp

print li

for m in range(4):

    if  li[m] > li[m+1]:

        temp = li[m+1]

        li[m+1] = li[m]

        li[m] = temp

print li

for m in range(4):

    if  li[m] > li[m+1]:

        temp = li[m+1]

        li[m+1] = li[m]

        li[m] = temp

print li

for m in range(4):

    if  li[m] > li[m+1]:

        temp = li[m+1]

        li[m+1] = li[m]

        li[m] = temp

print li

经过分析代码如下：

#!/usr/bin/env python 

#coding:utf-8

li = [13, 22, 6, 99, 11]

for i in range(1,len(li)):                   #循环四次

    for m in range(len(li)-i):              #每次循环次数减掉一个              

        if li[m] > li[m+1]:

            temp = li[m+1]

            li[m+1] = li[m]

            li[m] = temp

print li

递归函数

利用函数编写如下数列：

斐波那契数列指的是这样一个数列 0, 1, 1, 2, 3, 5, 8, 13, 21, 34, 55, 89, 144, 233，377，610，987，1597，2584，4181，6765，10946，17711，28657，46368

def func(arg1,arg2):

    if arg1 == 0:

        print arg1, arg2

    arg3 = arg1 + arg2

    print arg3

    func(arg2, arg3)

func(0,1)

来自为知笔记(Wiz)