python 内联函数

发布时间：2019-09-16 07:35:53编辑：auto阅读（2355）

python的一些小函数很能提高效率，平时在工作中经常忽视这些内容，而使用很原始粗暴的方法写代码；写了一段时间以后，发现自己的提高很少，要写个小脚本也要纠结半天，跟那些大拿们相差太大；所以要检讨自己，看看自己可以从那方面提高自己的技术能力；




今天首先学习下python的实用小函数：




lamda()  返回一个函数表达式，类似于def，但是比def更轻巧，可以没有名字

add_by_lambda = lambda x,y: x+y
print add_by_lambda(1, 1)

甚至还可以直接在后面追加实参来直接获取返回值，比如lambda x,y : x+y, 1, 1返回结果就是2
-------------------------------------
def add(x,y):
    return x+y
print add(1, 1)




zip()

定义：zip([seql, ...])接受一系列可迭代对象作为参数，将对象中对应的元素打包成一个个tuple（元组），然后返回由这些tuples组成的list（列表）。若传入参数的长度不等，则返回list的长度和参数中长度最短的对象相同。

 1 >>> z1=[1,2,3] 
 2 >>> z2=[4,5,6] 
 3 >>> result=zip(z1,z2)

zip()配合*号操作符,可以将已经zip过的列表对象解压，即将合并的序列拆成多个tuple.

1 >>> zip(*result)
2 [(1, 2, 3), (4, 5, 6)]




与序列有关的内建函数有：sorted()、reversed()、enumerate()、zip()

sorted()和zip()返回一个序列(列表)对象

reversed()、enumerate()返回一个迭代器(类似序列)




http://www.cnblogs.com/BeginMan/archive/2013/03/14/2959447.html




场景：

* 二维矩阵变换（矩阵的行列互换）

a = [[1, 2, 3], [4, 5, 6], [7, 8, 9]] 
zip(*a) 
[(1, 4, 7), (2, 5, 8), (3, 6, 9)]
map(list,zip(*a)) 
[[1, 4, 7], [2, 5, 8], [3, 6, 9]]

* 顺序获取数据

>>> name=('jack','beginman','sony','pcky')
>>> age=(2001,2003,2005,2000)
>>> for a,n in zip(name,age):
    print a,n
输出：
jack 2001
beginman 2003
sony 2005
pcky 2000




zip高级应用：

1.zip打包解包列表和倍数
>>> a = [1, 2, 3]
>>> b = ['a', 'b', 'c']
>>> z = zip(a, b)
>>> z
[(1, 'a'), (2, 'b'), (3, 'c')]
>>> zip(*z)
[(1, 2, 3), ('a', 'b', 'c')]
2. 使用zip合并相邻的列表项
>>> a = [1, 2, 3, 4, 5, 6]
>>> zip(*([iter(a)] * 2))
[(1, 2), (3, 4), (5, 6)]
>>> group_adjacent = lambda a, k: zip(*([iter(a)] * k))
>>> group_adjacent(a, 3)
[(1, 2, 3), (4, 5, 6)]
>>> group_adjacent(a, 2)
[(1, 2), (3, 4), (5, 6)]
>>> group_adjacent(a, 1)
[(1,), (2,), (3,), (4,), (5,), (6,)]
>>> zip(a[::2], a[1::2])
[(1, 2), (3, 4), (5, 6)]
>>> zip(a[::3], a[1::3], a[2::3])
[(1, 2, 3), (4, 5, 6)]
>>> group_adjacent = lambda a, k: zip(*(a[i::k] for i in range(k)))
>>> group_adjacent(a, 3)
[(1, 2, 3), (4, 5, 6)]
>>> group_adjacent(a, 2)
[(1, 2), (3, 4), (5, 6)]
>>> group_adjacent(a, 1)
[(1,), (2,), (3,), (4,), (5,), (6,)]
3.使用zip和iterators生成滑动窗口 (n -grams) 
>>> from itertools import islice
>>> def n_grams(a, n):
...     z = (islice(a, i, None) for i in range(n))
...     return zip(*z)
...
>>> a = [1, 2, 3, 4, 5, 6]
>>> n_grams(a, 3)
[(1, 2, 3), (2, 3, 4), (3, 4, 5), (4, 5, 6)]
>>> n_grams(a, 2)
[(1, 2), (2, 3), (3, 4), (4, 5), (5, 6)]
>>> n_grams(a, 4)
[(1, 2, 3, 4), (2, 3, 4, 5), (3, 4, 5, 6)]
4.使用zip反转字典
>>> m = {'a': 1, 'b': 2, 'c': 3, 'd': 4}
>>> m.items()
[('a', 1), ('c', 3), ('b', 2), ('d', 4)]
>>> zip(m.values(), m.keys())
[(1, 'a'), (3, 'c'), (2, 'b'), (4, 'd')]
>>> mi = dict(zip(m.values(), m.keys()))
>>> mi
{1: 'a', 2: 'b', 3: 'c', 4: 'd'}




filter()

filter函数接受两个参数，func和list，而经过过滤后返回一个list，其中func函数对象只能有一个传入参数。原理便是根据列表list中所有元素作为参数传递给函数func，返回可以令func返回真的元素的列表，如果func为None，那么会使用默认的Python内置的identity函数直接判断元素的True or False。

例如：

a = [1,2,3,4,5,6,7]  
b=filter(lambda x:x>2, a)  
print b
#过滤奇数集
a = [1,2,3,4,5,6,7]  
b=filter(lambda x:x%2, a)  
print b




map()

map函数是一个很强大的一个映射函数，其传入两个参数，一个是func，一个是list，而功效便是func作用于给定序列的每个元素，并用一个列表来提供返回值。例如：

a=[0,1,2,3,4,5,6,7]  
map(lambda x:x+3, a)
a=[1,2,3]  
b=[4,5,6]  
map(lambda x,y:x+y, a,b) 
[5,7,9] 

#my_map函数实现
def my_map(func, *args):  
       return [ func(arg) for arg in args ]




reduce()

reduce函数传入参数为func和list，其遍历list元素，并调用func函数实现累积，具体效果便是：




reduce(f, [x1, x2, x3, x4]) = f ( f ( f ( x1, x2 ), x3 ), x4 )




使用范例如下：




#str to int

def str2int(s):  

       return reduce(lambda x,y: x*10+y, map(int, s))







妙用集锦： http://devopstarter.info/pythonkai-fa-zhi-mapreduce/

#两个list，取(x - y) + (y - x)

x=[{'a': 1, 'b': 2}, {'c': 3}, {'d': 4}]  

y=[{'a': 1}, {'c': 3}, {'e': 5}]

filter(lambda z: (x+y).count(z)<2, (x+y)) 

 

#flatten out nested sublist

#result: [ 1, 2, 3, 4, 5 ]

import operator  

reduce( operator.concat, [ [ 1, 2 ], [ 3, 4 ], [ ], [ 5 ] ], [ ] )  




#多项式求和

import operator  

def evaluate (a, x):  

       xi = map( lambda i: x**i, range( 0, len(a)))

       axi = map(operator.mul, a, xi)

       return reduce( operator.add, axi, 0 )

       

#数据库SQL

reduce( max, map( Camera.pixels, filter(  

        lambda c: c.brand() == "Nikon", cameras ) ) )




#maybe equals

SELECT max(pixels)  

FROM cameras  

WHERE brand = “Nikon”




#There.

#cameras is a sequence

#where clause is a filter

#pixels is a map

#max is a reduce




#一行并发

import urllib2  

from multiprocessing.dummy import Pool as ThreadPool




urls = [  

           'http://www.python.org',

           'http://www.google.com',

           'http://www.baidu.com',

           'http://www.python.org/community/',

           'http://www.saltstack.com'

           ]




#pool = ThreadPool()

pool = ThreadPool(4) # Sets the pool size to 4




result = pool.map(urllib2.urlopen, urls)  

pool.close()  

pool.join()  




int()    转数字 int('0')

str()    转字符串str(2)

lower()  转小写lower(Windows)

upper()  转大写upper(Linux)

iter(）

list.count('aaa') 统计aaa在列表中出现的次数

关键字：