python中lambda函数使用用法,函数式编程

lambda表达式

  1. 以lambda开头
  2. 紧跟一定的参数(尽管局地话)
  3. 参数后用冒号和表达式主旨隔开
  4. 只是1个表达式,所以,没有return

# 计算一个数字的100倍数
stm = lambda x: 100 * x 

stm(89)

壹 、变量可以针对一个函数

lambda只是贰个表明式,函数体比def不难很多。

lambda表达式

map

  1. 把集合或许列表的因素,每三个要素都遵守一定规则(函数)举行操作,生成七个新的列表或然聚众
  2. map函数是系统提供的具备映射效用的函数,再次来到值是一个迭代目的

def mulTen(n):
    return n*10

l3 = map(mulTen, l1 ) # map类型是一个可迭代的结构,所以可以使用for遍历
for i in l3:
    print(i)

l4 = [i for i in l3]
print(l4)
# 上面列表生成式得到的结果为空——可迭代结果不能用列表生成式

  a = abs

lambda的侧重点是二个表达式,而不是多个代码块。仅仅能在lambda表明式中封装有限的逻辑进去。

  lambda表明式就是能放手到其余表明式当中的匿名函数(闭包)

reduce

  1. 把1个可迭代对象最终归并成1个结实
  2. 对此作为参数的函数要求: 多个参数+重回值

from functools import reduce

# 定义一个操作函数,求和
def myAdd(x,y):
    return x + y

# 对于列表[1,2,3,4,5,6]执行myAdd的reduce操作
rst = reduce( myAdd, [1,2,3,4,5,6] )
print(rst)

贰 、通过调用指向函数的变量可以执行该函数

lambda表明式是起到壹个函数速写的成效。允许在代码内放置三个函数的定义。

意义:

filter

  1. 对一组数据举办过滤,符合条件的数据(使过滤函数再次回到True)会生成2个新的列表并再次回到
  2. 调用格式: filter(f, data), f是过滤函数, data是数额

def isEven(a):
    return a % 2 == 0

l = [3,4,56,3,2,3,4556,67,4,4,3,23455,43]

rst = filter(isEven, l) # 返回的是一个可迭代对象

  a = abs
  a(-10)

大家先来看2个事例:

壹 、可以在表明式当中间接定义三个函数,而不要求将定义函数和表达式分开,这一个函数只是一个目前的函数。
② 、引入了闭包。基本前一周边的帮衬lambda表明式的语言里,不设有不扶助闭包的lambda表明式;从函数式编程的角度来说,协理闭包也是很重点的。

sorted

  1. sorted(data, key,
    reverse),data:排序对象,key:在排序前对每三个因素举行key函数运算,reverse:若True则翻转

a = [-43,23,45,6,-23,2,-4345]

al = sorted(a, key=abs, reverse=True) # 即按照绝对值的倒叙排列

print(al)

③ 、指向函数的变量能够看作参数传递给多少个函数

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

比方在三个里面函数里,对在表面功能域(但不是在全局功能域)的变量举办引用,那么内部函数就被认为是闭包(closure),它使你的lambda表明式从七个普普通通的函数变成了一个带隐藏参数的函数。

重临函数

def myF4( *args):
    def myF5():
        rst = 0
        for n in args:
            rst += n
        return rst
    return myF5

f5 = myF4(1,2,3,4,5,6,7,8,9,0)
# f5的调用方式
f5()

  def add(x,y,f):
    return f(x) + f(y)
  add(-5,-6,abs)

咱俩定义了3个函数叫add,有多个参数,再次回到结果是x+y

创建语法:

闭包(closure)

def count():
    fs = []
    for i in range(1, 4):
        def f():
        return i * i
    fs.append(f)
    return fs


f1, f2, f3 = count()
print(f1(), f2(), f3()) # 结果:9 9 9
  • 以致上述场景的案由是,再次来到函数引用了变量i,
    i并非立时执行,而是等到三个函数都回去的时候才联合采取,此时i已经成为了3,最后调用的时候,都回去的是
    3*3
  • 此题材讲述成:重临闭包时,重临函数无法引用任何循环变量
  • 焚林而猎方案:
    再次创下立2个函数,用该函数的参数绑定循环变量的当下值,无论该循环变量以往怎样改变,已经绑定的函数参数值不再改变

def count():
    def f(j):
        def g():
        return j * j
    return g
    fs = []
    for i in range(1, 4):
        fs.append(f(i))
        return fs


f1, f2, f3 = count()
print(f1(), f2(), f3()) # 结果:1 4 9

四、map()函数

def usuallyAdd2(x, y=2): return x+y

lambda parameters:express

装饰器(Decrator)

# 对hello函数进行功能扩展,每次执行hello万打印当前时间
import time


def print_time(f):
    def wrapper(*args, **kwargs):
        print("Time: ", time.ctime())
        return f(*args, **kwargs)
    return wrapper


@print_time
def hello3():
    print('我是手动执行的喵||')
    return


if __name__ == '__main__':
    hello3()
    print('*' * 30)
    hello3 = print_time(hello3)
    hello3()
    print('*' * 30)
    f = print_time(hello3)
    f()
    print('*' * 30)

# 结果:
'''
Time:  Sun Aug 26 21:01:18 2018 
我是手动执行的喵||
******************************
Time:  Sun Aug 26 21:01:18 2018
Time:  Sun Aug 26 21:01:18 2018
我是手动执行的喵||
******************************
Time:  Sun Aug 26 21:01:18 2018
Time:  Sun Aug 26 21:01:18 2018
Time:  Sun Aug 26 21:01:18 2018
我是手动执行的喵||
******************************
'''

解说运作结果:

  1. 运行hello3():

    Time: Sun Aug 26 21:01:18 2018
    自个儿是手动执行的喵||

    hello3()使用装饰器,先打印时间,再运转函数内部

  2. 运行print_time(hello3):

    Time: Sun Aug 26 21:01:18 2018
    Time: Sun Aug 26 21:01:18 2018
    自小编是手动执行的喵||

    print_time运转打印时间,重临hello3,再如1

  3. 运行print_time(print_time(hello3)):

    Time: Sun Aug 26 21:01:18 2018
    Time: Sun Aug 26 21:01:18 2018
    Time: Sun Aug 26 21:01:18 2018
    本人是手动执行的喵||

    多加一层,多3个小时

  map()
函数可以为其扩散三个函数以及八个可Iterator的对象,map将使用该函数依次成效于各个Iterator的成分
  
python中lambda函数使用用法,函数式编程。  list1 = [ x for x in range(1,11)]
  def fun(x):
    return x + 1
  list2 = map(fun,list1)

这么些usuallyAdd2的区分在于y有了暗许值

parameters:可选,如果提供,寻常是逗号分隔的变量表达式方式,即地方参数。

五、reduce()函数

假诺接纳lambda怎样彰显吧?

expression:无法包蕴分支或循环(但允许规范表明式),也不可以包涵return(或yield)函数。倘若为元组,则应用圆括号将其含有起来。

  reduce()函数接收二个函数和1个Iterator对象,但接受的函数有八个变量,并一一每趟迭代列表中的三个因素

lambda x, y: x + y

实例(实验环境为Python3.6)

六、filter()函数

lambda x, y=2: x+y

两数求和:

  filter()函数也是一个高阶函数,其有两个参数,分别是函数和可Iterator对象,并将函数依次作用于这几个list的种种成分,依照函数再次来到True和False来对列表举办相关的操作

看一下测试结果:

#lambda
>>>my_lambda = lambda x,y;x+y
#执行
>>>result = my_lambda(1,2)
result=3

  #行使filter()函数来输出1个列表中有所的奇数:
  list1 = [ x for x in range(1,101)]
  def is_odd(x):
    if x % 2 != 0:
      return True
    else:
      return False
  list2 = list(is_odd,list1)

>>> test = lambda x,y=2:x+y
>>> test(3
… )
5
>>> test(5)
7
>>> test(1)
3
>>>

求n的阶乘:

七、sorted()函数

其实lambda就是把参数和再次来到简写,极度便宜

>>>n=5
>>>reduce(lambda x,y:x*y, range(1,n+1)
120

  sorted()函数可以看成排序

行使lambda高效操作列表

把lambda 作为重回表明式

  sorted(可遍历对象)
  sorted(可遍历对象, key=abs ) #循途守辙各种成分的abs举办排序
  sorted(可遍历对象, key=abs , reverse = True)
#安份守己各种元素的abs进行排序并且反转

Python用于辅助将函数赋值给变量的贰个操作符
暗许是回去的,所以并非再加return关键字,不然会报错

>>> b=lambda x:lambda y:x+y
>>>a=b(3)
>>>a(2)
5
>>>(b(2))(2)
4

八 、函数的回来与闭包

result = lambda x: x * x
result(2) # return 4
map()/filter()/reduce()

 

  函数也足以看成值重返

急需多个参数,第1个是一个处理函数,第四个是一个行列(list,tuple,dict)
map()

内建函数:(map,reduce,filter,sorted)

  闭包是函数式编程中函数作为第3等平民的一种集体措施

将种类中的成分通过处理函数处理后归来一个新的列表
filter()

map()函数接收五个参数,一个是函数,二个是种类,map将盛传的函数依次功效到行列的种种成分,并把结果作为新的list重临

  def welcome(welcome_str):
    def say_hello(user_name):
      return welcome_str + user_name
    return say_hello

将系列中的成分通过函数过滤后回到1个新的列表
reduce()

(python3.6)

  say_hello_fun = welcome(“你好”)
  str = say_hello_fun(“CQ”)
  print(str)

将连串中的成分通过2个二元函数处理回来二个结出
将上边八个函数和lambda结合使用

>>> list(map(lambda x:x*x,[1,2,3,4,5,6,7,8,9]))
[1, 4, 9, 16, 25, 36, 49, 64, 81]

⑨ 、创设闭包时的规范

li = [1, 2, 3, 4, 5]
# 系列中的每一种成分加1
map(lambda x: x+1, li) # [2,3,4,5,6]
 
# 再次回到体系中的偶数
filter(lambda x: x % 2 == 0, li) # [2, 4]
 
# 重返全部因素相乘的结果
reduce(lambda x, y: x *澳门葡京备用网址, y, li) # 1*2*3*4*5 = 120

澳门葡京备用网址 1

  闭包必须有内嵌函数
  内嵌函数要求引用该嵌套函数上拔尖namespace中的变量
  闭包函数必须回到内嵌函数

sorted() 结合lambda对列表进行排序

reduce()把3个函数成效在三个行列[x1, x2,
x3…]上,那些函数必须接受七个参数,reduce把结果一而再和体系的下一个要素做累积总括,其成效就是:

⑩ 、闭包函数中的执行和调用难题

sorted 用于列表的排序,比列表自带的愈益智能
有七个列表,每一个列表中都有三个字典([{},{}])需要将多个这么的列表合并后依照时间排序,
八个列表中的时间以便可以通过json输出已经由时间格式转变为字符串格式.字段名为
sort_time 以后将他们按照倒序排列

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

  第2步:通过最外称函数获取内嵌函数
  第壹步:通过社团内嵌函数参数来得到重返的履行结果

sorted 的用法

例如上边的求阶乘的代码。

十① 、匿名函数

sorted(iterable, cmp=None, key=None, reverse=False) –> new sorted
list terable:是可迭代类型;
cmp:用于比较的函数,相比什么由key决定,有暗中同意值,迭代聚集中的一项;
key:用列表成分的某部属性和函数进行作为紧要字,有暗许值,迭代集合中的一项;
reverse:排序规则. reverse = True 只怕 reverse = False,有暗许值。 *
再次回到值:是二个由此排序的可迭代类型,与iterable一样。
sorted()结合lambda对可迭代类型用sort_time排序

字符串str也是三个行列,我们得以写3个吧str转换来int的函数:(python3.6)

  Python中通过lambda提供了对匿名函数的支撑

sorted(data, key=lambda d: d[‘sort_time’], reverse=True)

>>> def char2num(s):
...     return {'0': 0, '1': 1, '2': 2, '3': 3, '4': 4, '5': 5, '6': 6, '7': 7, '8': 8, '9': 9}[s]
...
>>> from functools import reduce
>>> reduce(lambda x,y:x*10+y,map(char2num,'13579'))
13579

  lambda 参数 : 参数加入的表明式

filter()函数接收一个函数
f 和壹个list,那些函数 f 的功能是对每种元素举办判断,重回 True或
False,filter()依照判断结果机关过滤掉不符合条件的因素,再次回到由符合条件成分构成的新list。

  lambda表明式只好有一句表明式,并且一向将该表明式的实施结果重返,而不用书写return语句

 写一个从list[1,2,3,4,5,6]中剔除偶数,保留奇数的程序(Python3.6)

  lambda表明式可以一贯赋值给五个变量,再经过变量来构造函数来落成调用

>>> list(filter(lambda x:x%2==1,[1,2,3,4,5,6]))
... 
[1, 3, 5]

  fun = lambda x : x * x 
  fun(5)

排序函数 sorted()和list.sort[]

十二、装饰器

 python中,具体到对list举行排序的法门有俩,五个是list自带的sort方法,这几个是一贯对list举办操作,唯有list才含有的艺术;此外一个是内建函数sorted方法,可以对全部可迭代的目的开展排序操作,在真相上,list的排序和内建函数sorted的排序是大半的,连参数都大概是一致的

  装饰器是在不损坏原有函数功效基础上,为函数新增成效的一种体制

 首要的差别在于,list的sort方法重临的是对已经存在的列表进行操作,而内建函数sorted方法再次回到的是3个新的list,而不是在原来的根基上进展的操作。

  def test1(fun):
    def test2(*k,**kv):
      print(“now”,fun.__name__,”is run”):
      return fun(*k)
    return test2

>>> help(sorted)
Help on built-in function sorted in module builtins:

sorted(iterable, key=None, reverse=False)
    Return a new list containing all items from the iterable in ascending order.

    A custom key function can be supplied to customize the sort order, and the
    reverse flag can be set to request the result in descending order.

  @test1
  def test(user_name):
    print(“Hello,”,user_name)

Python3中去除了cmp内置函数,同时sorted等函数也去除了cmp关键字,添加key关键字 

  test(“CQ”) #此处是调用执行

使用sorted()方法和list.sort()方法进行排序
elements=[(2,12,"A"),(1,11,"N"),(1,3,"L"),(2,4,"B")]
>>> sorted(elements)
[(1, 3, 'L'), (1, 11, 'N'), (2, 4, 'B'), (2, 12, 'A')]

根据elements每个元组后两项进行排序,e表示列表中每个三元组元素
在表达式是元组,且lambda为一个函数的参数时,lambda表达式的圆括号是必需的
>>> elements.sort(key=lambda e:(e[1],e[2]))
>>> elements
[(1, 3, 'L'), (2, 4, 'B'), (1, 11, 'N'), (2, 12, 'A')]

分片方式得到同样的效果
>>> elements.sort(key=lambda e:e[1:3])
>>> elements
[(1, 3, 'L'), (2, 4, 'B'), (1, 11, 'N'), (2, 12, 'A')]

>>> elements.sort(key=lambda e:(e[2].lower(),e[1]))
以下两种方法等价,都可以通过调用area(5,3),结果相同
>>> area=lambda b,h:0.5*b*h
>>> def area(b,h):
    return 0.5*b*h

十三、偏函数

闭包(不难介绍一下闭包)

  通过偏函数,可以便宜的新建八个函数,并使其原函数参数有固定的暗中同意值

在3个里面函数中,对表面功能域的变量举办引用,(并且一般外部函数的重临值为其中函数),那么内部函数就被认为是闭包,举个栗子(以1个类似棋盘游戏的例证来评释。如果棋盘大小为50*50,左上角为坐标系原点(0,0),作者索要贰个函数,接收一个参数,分别为主旋律(direction),步长(step),该函数控制棋子的移位。
那里须求表明的是,每一次活动的起源都是上次活动为止的顶峰。):

  import functools
  int2 = functools.partial(int,base=2)
  int2(‘1000’)

>>> origin=[0,0]
>>> def create(pos=origin):
… def go(direction,step):
… new_x=pos[0]+direction[0]*step
… new_y=pos[1]+direction[1]*step
… pos[0]=new_x
… pos[1]=new_y
… return pos
… return go

>>> player = create()
>>> print(player([1,0],10))
[10, 0]
>>> print(player([0,1],20))
[10, 20]
>>> print(player([-1,0],10))
[0, 20]

  functools.partial(原函数,原函数的暗中认同值)

>>>print(‘player:’,player)

 

function: <function create.<locals>.go at 0x02F94660>

 

>>> print(‘function:’,go)
Traceback (most recent call last):
File “<stdin>”, line 1, in <module>
NameError: name ‘go’ is not defined
>>> print(‘function:’,create)
function: <function create at 0x02E4D540>

  

注意:

 

  • 闭包不能修改外部函数的一些变量
  • python循环中不包括域的概念
  • 闭包可以保存当前的运行环境

  

 

  

#
>>> def outerFunc():
...     x = 0
...     def innerFunc():
...             x = 1
...             print('inner x:',x)
...     print('outer x before call inner:',x)
...     innerFunc()
...     print('outer x after call inner:',x)
...
>>>
>>> outerFunc()
outer x before call inner: 0
inner x: 1
outer x after call inner: 0
>>>
#按照正常的理解下面的程序应该输入0,2,4,对吧? 但实际输出的是4,4,4,循环在Python中没有遇到概念,flist在向列表中添加func的时候,并没有保存i的值而当执行f(2)的时候才去取,这时候循环已经结束,i的值是2,所以结果都是4
>>> flist = []>>> for i in range(3):
...     def func(x):
...             return x*i
...     flist.append(func)
...
>>> for f in flist:
...     print(f(2))
...
4
4
4
#修改方案
>>> flist = []
>>> for i in range(3):
...     def makefunc(i):
...             def func(x):
...                     return x*i
...             return func
...     flist.append(makefunc(i))
...
>>> for f in flist:
...     print(f(2))
...
0
2
4
>>>
#(f是一个函数 序列) 在func外面再定义一个makefunc函数,func形成闭包

 

 

*  
  
*

 

相关文章

发表评论

电子邮件地址不会被公开。 必填项已用*标注

*
*
Website