python 的几个小函数
filter、map、reduce、lambda、yield
有了它们,最大的好处是程序更简洁;没有它们,程序也可以用别的方式实现,只不过麻烦一些罢了。所以,还是能用则用之吧。
lambda
lambda函数,是一个只用一行就能解决问题的函数,听着是多么诱人呀。看下面的例子:
>>> def add(x): #定义一个函数,将输入的变量增加3,然后返回增加之后的值
... x +=3
... return x
...
>>> numbers = range(10)
>>> numbers
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9] #有这样一个list,想让每个数字增加3,然后输出到一个新的list中
>>> new_numbers = []
>>> for i in numbers:
... new_numbers.append(add(i)) #调用add()函数,并append到list中
...
>>> new_numbers
[3, 4, 5, 6, 7, 8, 9, 10, 11, 12]
在这个例子中,add()只是一个中间操作。当然,上面的例子完全可以用别的方式实现。比如:
>>> new_numbers = [ i+3 for i in numbers ]
>>> new_numbers
[3, 4, 5, 6, 7, 8, 9, 10, 11, 12]
首先说明,这种列表解析的方式是非常非常好的。
但是,我们偏偏要用lambda这个函数替代add(x),如果看官和我一样这么偏执,就可以:
>>> lam = lambda x:x+3
>>> n2 = []
>>> for i in numbers:
... n2.append(lam(i))
...
>>> n2
[3, 4, 5, 6, 7, 8, 9, 10, 11, 12]
这里的lam就相当于add(x),请看官对应一下,这一行lambda x:x+3就完成add(x)的三行(还是两行?),特别是最后返回值。还可以写这样的例子:
>>> g = lambda x,y:x+y #x+y,并返回结果
>>> g(3,4)
7
>>> (lambda x:x**2)(4) #返回4的平方
16
通过上面例子,总结一下lambda函数的使用方法:
•在lambda后面直接跟变量
•变量后面是冒号
•冒号后面是表达式,表达式计算结果就是本函数的返回值
为了简明扼要,用一个式子表示是必要的:
lambda arg1, arg2, ...argN : expression using arguments
要特别提醒看官:虽然lambda 函数可以接收任意多个参数 (包括可选参数) 并且返回单个表达式的值,但是lambda 函数不能包含命令,包含的表达式不能超过一个。不要试图向 lambda 函数中塞入太多的东西;如果你需要更复杂的东西,应该定义一个普通函数,然后想让它多长就多长。
就lambda而言,它并没有给程序带来性能上的提升,它带来的是代码的简洁。比如,要打印一个list,里面依次是某个数字的1次方,二次方,三次方,四次方。用lambda可以这样做:
>>> lamb = [ lambda x:x,lambda x:x**2,lambda x:x**3,lambda x:x**4 ]
>>> for i in lamb:
... print i(3),
...
3 9 27 81
lambda做为一个单行的函数,在编程实践中,可以选择使用。根据我的经验,尽量少用,因为它或许更多地是为减少单行函数的定义而存在的。
map
先看一个例子,还是上面讲述lambda的时候第一个例子,用map也能够实现:
>>> numbers
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9] #把列表中每一项都加3
>>> map(add,numbers) #add(x)是上面讲述的那个函数,但是这里只引用函数名称即可
[3, 4, 5, 6, 7, 8, 9, 10, 11, 12]
>>> map(lambda x: x+3,numbers) #用lambda当然可以啦
[3, 4, 5, 6, 7, 8, 9, 10, 11, 12]
map()是python的一个内置函数,它的基本样式是:map(func, seq),func是一个函数,seq是一个序列对象。在执行的时候,序列对象中的每个元素,按照从左到右的顺序,依次被取出来,并塞入到func那个函数里面,并将func的返回值依次存到一个list中。
在应用中,map的所能实现的,也可以用别的方式实现。比如:
>>> items = [1,2,3,4,5]
>>> squared = []
>>> for i in items:
... squared.append(i**2)
...
>>> squared
[1, 4, 9, 16, 25]
>>> def sqr(x): return x**2
...
>>> map(sqr,items)
[1, 4, 9, 16, 25]
>>> map(lambda x: x**2,items)
[1, 4, 9, 16, 25]
>>> [ x**2 for x in items ] #这个我最喜欢了,一般情况下速度足够快,而且可读性强
[1, 4, 9, 16, 25]
条条大路通罗马,以上方法,在编程中,自己根据需要来选用啦。
在以上感性认识的基础上,在来浏览有关map()的官方说明,能够更明白一些。
map(function, iterable, ...)
Apply function to every item of iterable and return a list of the results. If additional iterable arguments are passed, function must take that many arguments and is applied to the items from all iterables in parallel. If one iterable is shorter than another it is assumed to be extended with None items. If function is None, the identity function is assumed; if there are multiple arguments, map() returns a list consisting of tuples containing the corresponding items from all iterables (a kind of transpose operation). The iterable arguments may be a sequence or any iterable object; the result is always a list.
理解要点:
•对iterable中的每个元素,依次应用function的方法(函数)(这本质上就是一个for循环)。
•将所有结果返回一个list。
•如果参数很多,则对么个参数并行执行function。
例如
>>> lst1 = [1,2,3,4,5]
>>> lst2 = [6,7,8,9,0]
>>> map(lambda x,y: x+y, lst1,lst2) #将两个列表中的对应项加起来,并返回一个结果列表
[7, 9, 11, 13, 5]
请看官注意了,上面这个例子如果用for循环来写,还不是很难,如果扩展一下,下面的例子用for来改写,就要小心了:代码如下:
>>> lst1 = [1,2,3,4,5]
>>> lst2 = [6,7,8,9,0]
>>> lst3 = [7,8,9,2,1]
>>> map(lambda x,y,z: x+y+z, lst1,lst2,lst3)
[14, 17, 20, 15, 6]这才显示出map的简洁优雅。
reduce忍不住还得来点废话。不知道看官是不是听说过MapReduc,如果没有,那么Hadoop呢?如果还没有,就google一下。下面是我从维基百科上抄下来的,共赏之。
MapReduce是Google提出的一个软件架构,用于大规模数据集(大于1TB)的并行运算。概念“Map(映射)”和“Reduce(化简)”,及他们的主要思想,都是从函数式编程语言借来的,还有从矢量编程语言借来的特性。
不用管是不是看懂,总之又可以用开头的思想意淫一下了,原来今天要鼓捣的这个reduce还跟大数据有关呀。不管怎么样,你有梦一般的感觉就行。
reduce
回到现实,清醒一下,继续敲代码:
>>> reduce(lambda x,y: x+y,[1,2,3,4,5])
15
还记得map是怎么运算的吗?忘了?看代码:
>>> list1 = [1,2,3,4,5,6,7,8,9]
>>> list2 = [9,8,7,6,5,4,3,2,1]
>>> map(lambda x,y: x+y, list1,list2)
[10, 10, 10, 10, 10, 10, 10, 10, 10]
看官对比一下,就知道两个的区别了。原来map是上下运算,reduce是横着逐个元素进行运算。
权威的解释来自官网:reduce(function, iterable[, initializer])
Apply function of two arguments cumulatively to the items of iterable, from left to right, so as to reduce the iterable to a single value. For example, reduce(lambda x, y: x+y, [1, 2, 3, 4, 5]) calculates ((((1+2)+3)+4)+5). The left argument, x, is the accumulated value and the right argument, y, is the update value from the iterable. If the optional initializer is present, it is placed before the items of the iterable in the calculation, and serves as a default when the iterable is empty. If initializer is not given and iterable contains only one item, the first item is returned. Roughly equivalent to:
代码:
def reduce(function, iterable, initializer=None):
it = iter(iterable)
if initializer is None:
try:
initializer = next(it)
except StopIteration:
raise TypeError('reduce() of empty sequence with no initial value')
accum_value = initializer
for x in it:
accum_value = function(accum_value, x)
return accum_value
如果用我们熟悉的for循环来做上面reduce的事情,可以这样来做:
代码:
>>> lst = range(1,6)
>>> lst
[1, 2, 3, 4, 5]
>>> r = 0
>>> for i in range(len(lst)):
... r += lst[i]
...
>>> r
15
for普世的,reduce是简洁的。
为了锻炼思维,看这么一个问题,有两个list,a = [3,9,8,5,2],b=[1,4,9,2,6],计算:a[0]b[0]+a1b1+...的结果。
代码如下:
>>> a
[3, 9, 8, 5, 2]
>>> b
[1, 4, 9, 2, 6]
>>> zip(a,b) #复习一下zip,下面的方法中要用到
[(3, 1), (9, 4), (8, 9), (5, 2), (2, 6)]
>>> sum(x*y for x,y in zip(a,b)) #解析后直接求和
133
>>> new_list = [x*y for x,y in zip(a,b)] #可以看做是上面方法的分布实施
>>> #这样解析也可以:new_tuple = (x*y for x,y in zip(a,b))
>>> new_list
[3, 36, 72, 10, 12]
>>> sum(new_list) #或者:sum(new_tuple)
133
>>> reduce(lambda sum,(x,y): sum+x*y,zip(a,b),0) #这个方法是在耍酷呢吗?
133
>>> from operator import add,mul #耍酷的方法也不止一个
>>> reduce(add,map(mul,a,b))
133
>>> reduce(lambda x,y: x+y, map(lambda x,y: x*y, a,b)) #map,reduce,lambda都齐全了,更酷吗?
133
filter
filter的中文含义是“过滤器”,在python中,它就是起到了过滤器的作用。首先看官方说明:
filter(function, iterable)
Construct a list from those elements of iterable for which function returns true. iterable may be either a sequence, a container which supports iteration, or an iterator. If iterable is a string or a tuple, the result also has that type; otherwise it is always a list. If function is None, the identity function is assumed, that is, all elements of iterable that are false are removed.
Note that filter(function, iterable) is equivalent to [item for item in iterable if function(item)] if function is not None and [item for item in iterable if item] if function is None.
这次真的不翻译了(好像以往也没有怎么翻译呀),而且也不解释要点了。请列位务必自己阅读上面的文字,并且理解其含义。英语,无论怎么强调都是不过分的,哪怕是做乞丐,说两句英语,没准还可以讨到英镑美元呢。
通过下面代码体会:
>>> numbers = range(-5,5)
>>> numbers
[-5, -4, -3, -2, -1, 0, 1, 2, 3, 4]
>>> filter(lambda x: x>0, numbers)
[1, 2, 3, 4]
>>> [x for x in numbers if x>0] #与上面那句等效
[1, 2, 3, 4]
>>> filter(lambda c: c!='i', 'qiwsir') #能不能对应上面文档说明那句话呢?
'qwsr' #“If iterable is a string or a tuple, the result also has that type;”
至此,用两此介绍了几个小函数,这些函数在对程序的性能提高上,并没有显著或者稳定预期,但是,在代码的简洁上,是有目共睹的。有时候是可以用来秀一秀,彰显python的优雅和自己耍酷。
转:http://www.jb51.net/article/56024.htm
*************************************************************************************************************************
自己应用的例子,实现插入数据库多条记录
if __name__=="__main__":
threadname =['baidu200','baidu200','baidu200','baidu200','baidu200','baidu200']
timeinterval = ['200','201','202','203','204','205']
responseduration = ['300','301','302','303','304','305']
averageduration = ['400','401','402','403','404','405']
hitspersecond = ['500','501','502','503','504','505']
tps = ['600','601','602','603','604','605']
do_number =[3,3,3,3,3,3]
print "datas:",datas
print "11111"
conn=MySQLdb.connect(host='10.154.156.224',user='root',passwd='scpsql',db='scp',port=3306)
cursor = conn.cursor()
print "2222"
sql = "insert into service_chartdata (jmetertask_id,test_name,threadname,timeinterval,responseduration,averageduration,hitspersecond,tps,do_number) values (%s,%s,%s,%s,%s,%s,%s,%s,%s)"
try:
print "3333"
cursor.executemany(sql,datas)
except Exception as e:
print "mysql insert error"
finally:
cursor.close()
conn.commit()
conn.close()
**************************************************************************************************************************
map 和lambda 应用
>>> list1 = [1,'ww',2]
>>> list2 = [2,'rr',8]
>>> map(lambda x,y : (x,y),list1,list2)
[(1, 2), ('ww', 'rr'), (2, 8)]
相关推荐
Python提供了如map、filter、reduce等高阶函数,以及`lambda`表达式来支持函数式编程。`lambda`表达式允许我们快速定义匿名函数,通常用于简短的、一次性的函数定义。 **yield**关键字在Python中用于创建生成器...
python是支持多种范型的语言,可以进行所谓函数式编程,其突出体现在有这么几个函数: filter、map、reduce、lambda、yield lambda >>> g = lambda x,y:x+y #x+y,并返回结果 >>> g(3,4) 7 >>> (lambda x:x**2)(4) #...
- 掌握匿名函数(lambda)的使用方法。 - 深入理解高阶函数的概念,并熟练运用常见的高阶函数如`map()`, `filter()`, `reduce()`等。 - 掌握装饰器的基本概念及其使用方法。 #### 10.1 迭代器和生成器 ##### ...
在这个实验中,我们学习并实践了几个关键的函数式编程概念,如lambda表达式、map()、filter()、reduce()函数,以及递归函数和迭代器。 1. **Lambda表达式**:Lambda表达式是Python中定义小型匿名函数的方式,通常...
利用这些高阶函数可以实现诸如 `map`、`filter` 和 `reduce` 这样的功能,极大地提高了代码的灵活性和可读性。 - **Map 函数**:`map` 函数可以将一个函数应用于一个可迭代对象的每个元素,并返回一个新的列表。...
6. Map, Filter 和 Reduce: * Map 是一个高阶函数,它可以将一个函数应用于每个元素 * Filter 是一个高阶函数,它可以将一个函数应用于每个元素,并返回符合条件的元素 * Reduce 是一个高阶函数,它可以将一个...
它通常与lambda表达式一起使用,如`filter(lambda x: x % 2 == 0, [1, 2, 3, 4, 5])`将返回偶数 `[2, 4]`。 3. **reduce() 函数**:reduce()函数是functools模块的一部分,它对序列执行累积操作,将序列中的元素...
1. 函数式编程:Python支持函数式编程风格,允许使用lambda表达式、map、filter和reduce等函数。例如,lambda函数可以快速创建简单的匿名函数,map函数用于将一个函数应用到序列的所有元素上,而filter则根据条件...
2. **函数**:熟悉函数的创建、调用和参数传递,了解匿名函数(lambda表达式)和高阶函数(如map、filter、reduce)。深入理解作用域(全局和局部变量)、闭包以及装饰器的概念和应用。 3. **类与对象**:理解面向...
- 包括高阶函数、闭包、lambda表达式、map()、filter()、reduce()等特性。例如,使用`map()`和`lambda`将列表中的所有元素平方: ```python numbers = [1, 2, 3, 4] squared = list(map(lambda x: x**2, numbers...
函数式编程是Python的一个强大特性,它强调使用函数作为一等公民,允许将函数作为参数传递、返回,以及使用高阶函数(如map、filter、reduce)对数据进行操作。例如,我们可以使用`map()`函数将一个函数应用于列表的...
- 高阶函数(如map、filter、reduce、lambda) - 匿名函数(lambda) - 内置函数(如len、type、sorted等) - 自定义模块的创建和导入 8. **面向对象编程**: - 类的定义和实例化 - 属性和方法 - 封装、继承...
#### 四、Map,Filter和Reduce 这三个函数是Python标准库中的高级函数,用于对列表或其他可迭代对象进行转换和聚合操作。 1. **Map**: 对序列中的每一个元素应用一个函数。 2. **Filter**: 从序列中筛选出满足条件...
1. 高阶函数:如`map()`, `filter()`, `reduce()`,它们可以接受其他函数作为参数,返回一个新的函数或处理后的结果。 2. lambda表达式:简洁的匿名函数,适用于快速定义单行、小型的函数。 3. map函数:将一个函数...
Python内置了许多功能性编程工具,如`map()`, `filter()`, `reduce()` 和 `lambda` 函数等。 1. **map()** 函数:`map()` 接受一个函数和一个或多个可迭代对象,将函数依次应用到每个元素上,并返回一个新的迭代器...
Python还有几个内置的高阶函数,如`map()`、`filter()`和`reduce()`,它们允许我们对序列进行操作。例如,`map()`函数可以将一个函数应用到序列的所有元素上: ```python numbers = [1, 2, 3, 4] squared = list(map...
1. **函数式编程**:使用map、filter、reduce等函数,以及lambda表达式和高阶函数。 2. **装饰器**:理解装饰器的工作原理,以及如何编写和使用装饰器来增强函数功能。 3. **生成器**:介绍迭代器和生成器的概念,...
4. **函数式编程**:Python支持丰富的函数式编程特性,如map、filter、reduce和lambda函数。源码可能涵盖这些工具的使用以及如何结合高阶函数实现函数组合和函数式数据处理。 5. **装饰器**:装饰器是Python中强大...