python中lambda函数使用用法,收藏整理的一对Python常用方法和技巧

lambda表明式在python中用的相比较多,也称作匿名函数,系统总计下:

珍藏整理的一对Python常用方法和技艺,整理python技巧

1. 翻盘字符串的二种办法
1.1. 仿照C++中方法, 定义2个空字符串来完结
由此设置一个空字符串, 然后讲参数中的字符串从后往前遍历,
使用字符串的加法合并为新的字符串
复制代码 代码如下:
def reverse(text) :
    str = ”
    index = len(text) – 1
    while index >= 0 :
        str += text[index]
        index -= 1
    return str

1.2. 用到切片法
这一个是Python中的3个特色,
切片可以取负值,这是运用切片的主意,设置步长为-1,那样就落到实处了扭转排序。
复制代码 代码如下:
def reverse_1(text) :
    return text[::-1]

1.3. 使用列表

应用列表的reverse方法,先将text转换为列表,然后经过reverse方法反转,然后在通过join连接为字符串。
复制代码 代码如下:
def reverse_2(text) :
    temp = list(text)
    temp.reverse()
    return ”.join(temp)

2. 使用reduce
使用匿名函数和reduce()
复制代码 代码如下:
def reverse_3(text) :
    return reduce(lambda x, y : y + x, text)
print reverse_3(“Hello”)

3. 遍历字典的三种方法
复制代码 代码如下:
dict={“a”:”apple”,”b”:”banana”,”o”:”orange”}
 
print
“##########dict######################”
for i in dict:
        print “dict[%s]=” % i,dict[i]
 
print
“###########items#####################”
for (k,v) in  dict.items():
        print “dict[%s]=” % k,v
 
print
“###########iteritems#################”
for k,v in dict.iteritems():
        print “dict[%s]=” % k,v
 
print “###########iterkeys,itervalues#######”
for k,v in zip(dict.iterkeys(),dict.itervalues()):
        print “dict[%s]=” % k,v

4. 遍历list的二种方法
复制代码 代码如下:
python中lambda函数使用用法,收藏整理的一对Python常用方法和技巧。for key in lst :
    print key
   
for i in range(len(lst)) :
    print lst[i]
for index, key in enumerate(lst) :
    print key    //index是list的索引

5. 字典排序的艺术
字典依据value的值从大到小的逐条来排序(私下认同从小到排序)。
复制代码 代码如下:
dic = {‘a’:31, ‘bc’:5, ‘c’:3, ‘asd’:4, ‘aa’:74, ‘d’:0}
dict= sorted(dic.iteritems(), key=lambda d:d[1], reverse = True)
print dict
//输出的结果:
[(‘aa’, 74), (‘a’, 31), (‘bc’, 5), (‘asd’, 4), (‘c’, 3), (‘d’, 0)]

上面我们诠释下代码
print dic.iteritems() 得到[(键,值)]的列表。
下一场用sorted方法,通过key这几个参数,钦点排序是根据value,约等于第四个元素d[1的值来排序。reverse
= True表示是亟需扭转的,暗许是从小到大,翻转的话,这就是从大到小。
对字典按键(key)排序:
复制代码 代码如下:
dic = {‘a’:31, ‘bc’:5, ‘c’:3, ‘asd’:4, ‘aa’:74, ‘d’:0}
dict= sorted(dic.iteritems(), key=lambda d:d[0]) #
d[0]代表字典的键
print dict
#sorted中第多少个可选参数为reverse, True表示从大到小排序
#默认reverse = False

6. 子类和父类
子类构造函数调用父类的开始化构造函数
复制代码 代码如下:
class A(object) :
    def __init__(self) :
        print  “testA
class B(A) :
    def __init__(self) :
        A.__init__(self)

子类调用父类的同名函数
复制代码 代码如下:
super().fuleifunction()

7. 更灵敏的参数传递形式
复制代码 代码如下:
func2(a=1, b=2, c=3) #默许参数
func3(*args)         #经受任意数量的参数, 以tuple的不二法门传入
func4(**kargs)       #把参数以键值对字典的花样传播

在变量前增进星号前缀(*),调用时的参数会蕴藏在一个tuple()对象中,赋值给形参。在函数内部,需求对参数进行拍卖时,只要对这个tuple 类型的形参(这里是
args)举行操作就可以了。因而,函数在概念时并不须要指明参数个数,就可以处理任意参数个数的场馆。

复制代码 代码如下:
def calcSum(*args):
    sum = 0
    for i in args:
        sum += i
        print sum
#调用:
calcSum(1,2,3)
calcSum(123,456)
calcSum()
#输出:
6
579
0
#################################
def printAll(**kargs):
    for k in kargs:
    print k, ‘:’, kargs[k]
printAll(a=1, b=2, c=3)
printAll(x=4, y=5)
#输出:
a : 1
澳门葡京备用网址,c : 3
b : 2
y : 5
x : 4

python的中参数能够八种方式举行整合,
在混合使用时,首先要注意函数的写法,必须遵从:

1.带有暗中同意值的形参(arg=)须在无私自认同值的形参(arg)之后
2.元组参数(*args)须在富含专擅认同值的形参(arg=)之后
3.字典参数(**kargs)须在元组参数(*args)之后

在函数被调用时,参数的传递进度为:

1.按顺序把无指定参数的实参赋值给形参
2.把内定参数名称(arg=v)的实参赋值给相应的形参
3.将剩余的无内定参数的实参打包成一个 tuple 传递给元组参数(*args)
4.将余下的钦命参数名的实参打包成叁个 dict 传递给字典参数(**kargs)

  1. lambda 表达式
    lambda 表明式可以当做一种匿名函数
        lambda 表明式的语法格式:
        lambda 参数列表: 表明式   #参数列表周围没有括号,重临值前未曾
    return 关键字,也从没函数名称
    复制代码 代码如下:
    def fn(x):
        return lambda y: x + y
    #调用
    a = fn(2)
    print a(3)
    #输出
    5

分析
: fn(2)调用后, 约等于a = lambda y: 2 + y, 然后a(3)被调用时.
相当于 print lambda y: 2 + 3

  1. 转败为胜字符串的三种方法 1.1. 效仿C++中方法, 定义一个空字符串来已毕通过安装2个…

lambda只是1个表达式,函数体比def简单很多。

Python 提供 3 种内建函数和 lambda 表明式等来支撑函数式编程。

一 、表达式格式

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

匿名函数

Python 允许用 lambda
关键字成立匿名函数。匿名顾名思义就是从未名字,即不须要以规范的情势来声称,比如说,使用
def 加函数名来声称。3个完好的 lambda
“语句”代表了三个表明式,那几个表明式的定义体必须和声明放在同一行。语法如下:

lambda [arg1[, arg2, ... argN]]: expression

参数是可选的,假设利用参数的话,参数经常也会油但是生在表明式中。

瞩目:lambda 表明式重临可调用的函数对象。其实 lambda
表明式本身就是叁个函数,那个函数定义了输入(冒号右侧)和出口(冒号左边),只不过那几个函数没盛名字,不过大家得以把它赋给三个变量。

比如说简单的加法函数。一般大家是那般写的:

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

lambda 表明式这么写:

lambda x, y : x + y

我们可以把 lambda x, y : x + y 赋值给 f ,然后给 f 传参数:

>>> f = lambda x, y : x + y
>>> f
 at 0x10377f320>
>>> f(-10,8)
-2
>>> f(12, 100)
112
>>> f(-33, -22)
-55

可以见到,f
确实是个函数,可以吸收三个参数,并赶回这五个参数的和,等价于上边的 add
函数。

lambda 参数列表:与参数相关的表明式

lambda表达式是起到贰个函数速写的功用。允许在代码内停放二个函数的概念。

行使情况

一 、函数式编程
2、闭包
简短狠毒地了解为闭包就是一个概念在函数内部的函数,闭包使得变量即便脱离了该函数的功用域范围也还可以被访问到。

简述:lambda是重点字,码上就行;参数列表与函数中一致;表明式中用到的参数要求在参数列表中定义;整个表明式组成lambda函数;

咱俩先来看1个例子:

高阶函数

高阶函数英文叫 Higher-order function
。一般函数的输入参数和再次来到值都不得不是变量或常量,假设有个别函数可以接收函数作为其输入参数,大概其再次来到值中隐含函数,那么该函数就是高阶函数。
Python 中有八个内建的用来帮助函数式编程的高阶函数,分别是
filter(),map()

reduce()。

例子:

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

filter()

filter(function, sequence) 再次回到四个 sequence
(种类),再次来到的行列中归纳了输入种类中有所调用 function(item) 后重回值为
true 的成分。

举个栗子:

>>> def f(x): return x % 3 == 0 or x % 5 == 0
...
>>> filter(f, range(2, 25))
[3, 5, 6, 9, 10, 12, 15, 18, 20, 21, 24]

因为 filter() 的输入参数中富含函数 f() ,所以 filter()
是高阶函数。上面的事例中回到 2~24 中能被 3 或 5 整除的数组成的列表。

自然,也可以动用匿名函数 lambda 表达式落成:

>>> filter(lambda x : x % 3 == 0 or x % 5 == 0, range(2, 25))
[3, 5, 6, 9, 10, 12, 15, 18, 20, 21, 24]

或许采用列表生成式:

>>> [x for x in range(2, 25) if x % 3 == 0 or x % 5 == 0]
[3, 5, 6, 9, 10, 12, 15, 18, 20, 21, 24]

(1)lambda x,y:x+y    (输入2个参数x和y,输出2者之和)

作者们定义了三个函数叫add,有多个参数,重临结果是x+y

map()

map() 与 filter()
相似,因为它也能通过函数来处理体系。map()将函数调用“映射”到行列的各种成分上,并赶回2个含有全部重回值的列表。

举个栗子:

>>> def cube(x): return x**3
...
>>> map(cube, range(1,11))

[1, 8, 27, 64, 125, 216, 343, 512, 729, 1000]

地点的例证中,将 1~10 里的种种数分别调用 cube() ,并将重临值(x 的 3次方)放入列表中。

lambda 表达式:

>>> map(lambda x : x**3, range(1, 11))
[1, 8, 27, 64, 125, 216, 343, 512, 729, 1000]

列表生成式:

>>> [x**3 for x in range(1, 11)]
[1, 8, 27, 64, 125, 216, 343, 512, 729, 1000]

注意:map() 也足以处理三个连串。

>>> map(lambda x, y: x + y, [1, 3, 5], [2, 4, 6])
[3, 7, 11]
>>> map(lambda x, y: (x+y, x-y), [1, 3, 5], [2, 4, 6])
[(3, -1), (7, -1), (11, -1)]
>>> map(None, [1, 3, 5], [2, 4, 6])
[(1, 2), (3, 4), (5, 6)]

(2)lambda *args:sum(args)    (输入任意参数,输出那一个参数之和)

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

reduce()

reduce(function, sequence)
重返叁个单值,它是这么构造的:首先以体系的前三个因素调用函数
function,再以重回值和第多个参数调用,依次执行下去。

比如说,以下顺序统计 0 到 5 的平头之和:

>>> def add(x, y): return x+y
...
>>> reduce(add, range(0, 5))
10

实则 reduce() 执行了如下的运算:

((((0+1)+2)+3)+4)   ==>  10

lambda 表达式:

reduce(lambda x, y : x + y, range(0, 5))

② 、应用示范

以此usuallyAdd2的分别在于y有了暗中同意值

偏函数

偏函数化解那样的标题:假若大家有函数是三个参数的,大家希望能固定其中某多少个参数的值(类似于私自认同值)。

举个栗子:

int() 函数能够把字符串转换为整数,当仅传入字符串时,int()
函数默许按十进制转换:

>>> int('11111')
11111

但 int() 函数还提供额外的 base 参数(暗许值为10) 。即使传入 base
参数,就足以做 N 进制的变换:

>>> int('11111',8)
4681
>>> int('11111',base=16)
69905

一旦要转移多量的二进制字符串,每一遍都传开 int(x, base=2)
格外麻烦,于是,我们想到,可以定义一个 int2() 的函数,暗许把 base=2
传进去:

def int2(x, base=2):
    return int(x, base)

这么,大家就足以一本万利地转换二进制了:

>>> int2('1000000')
64
>>> int2('1010101')
85

functools.partial 就是匡助大家创造二个偏函数的,不须要大家和好定义
int2() ,可以间接选取下边的代码创制2个新的函数 int2 :

>>> import functools
>>> int2 = functools.partial(int, base=2)
>>> int2('11111')
31
>>> int2('10000')
16

小结一下,functools.partial
的效果就是,把一个函数的一些参数给一定住(约等于设置暗中认同值),重临1个新的函数,调用这些新函数会更简便易行。

亟需留意的是,上面的新的 int2 函数,仅仅是把 base 参数重新设定默许值为 2
,但也可以在函数调用时传出别的值:

>>> int2('11111',base=10)
11111
>>> int2('11111',base=8)
4681

重整计算了多少个常用的地点,供参考

若果拔取lambda怎么着展现吗?

(1)lambda表明式赋值给变量

lambda x, y: x + y

sum = lambda x,y:x+y

lambda x, y=2: x+y

print sum(2,3)

看一下测试结果:

输出结果3

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

(2)lambda表明式赋值给别的函数,达成函数作用替换

实质上lambda就是把参数和重返简写,极度便利

(3)lambda表明式作为任何函数的再次回到值

利用lambda高效操作列表

(4)lambda函数当做参数传递给别的函数

Python用于援救将函数赋值给变量的二个操作符
暗中同意是回去的,所以不用再加return关键字,不然会报错

例如:filter函数:filter(lambda x:x%3 == 0 ,[1,2,3]) 
过滤后突显钦赐列表[1,2,3,]中能被3整除的数

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

          sorted函数:sorted([1,2,3,4,5,6,7,8,9],key = lambda
x:abs(5-x))   将列表中成分依据距离5以来的条件排序

必要八个参数,第多个是二个处理函数,第三个是3个队列(list,tuple,dict)
map()

 

将系列中的成分通过处理函数处理后赶回1个新的列表
filter()

实质上,依然要多写多练,要不便于忘~

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

 

将连串中的成分通过二个二元函数处理回来三个结实
将方面四个函数和lambda结合使用

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

sorted() 结合lambda对列表举办排序

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

sorted 的用法

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

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

相关文章

发表评论

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

*
*
Website