匿名函数、生成式、三元运算

匿名函数,关键字lambda,后接参数,然后是功能代码,整体返回结果

#匿名函数lambda

fun = lambda x, y : x+y
print(fun(2,3), type(fun))

输出结果:

5 <class ‘function‘>

列表生成式,通过在[ ]中通过...for...in...快速生成数字列表

#列表生成式

list = [x for x in range(5)]
print(list)

输出结果:

[0, 1, 2, 3, 4]

生成器,通过在( )里面通过...for...in...生成

#生成器
gen = (x for x in range(5))
print(type(gen), next(gen))
#next()函数是生成器中用于取下一个值的

输出结果:

<class ‘generator‘> 0

三元运算,通过if条件,分隔三个部分Ture if 条件 else False

# 三元运算)
# 条件为真结果 if 条件 else 条件为假结果
def fun(x, y):
    return x -y if x > y else y-x

print(fun(2, 3))
print(fun(5, 2))

输出结果:

1
3

原文地址:http://blog.51cto.com/10412806/2095120

时间: 2024-08-29 17:00:27

匿名函数、生成式、三元运算的相关文章

python之路(sed,函数,三元运算)

python之路(sed,函数,三元运算) 一.sed集合 1.set无序,不重复序列 2.创建 1 se = {11,22,33,33,44} 2 list() #只要是一个类加上()自动执行 list __init__ 3 list = [11,22] 4 5 s1 = set(list) 6 print(s1) 7 8 #创建集合 9 s1 = {11,22} 10 s2 = set('可循环的') 11 12 #操作集合 13 s = set() 14 print(s) 15 s.add

参数-匿名函数-生成式-生成器-装饰器

1.函数的参数 参数类型:关于函数的参数,我们经常在一些代码中会发现 def(*args,**kwargs)的表现形式,其中定义的分别是元组和字典: *args -- tuple(1,) **kwargs -- dict("k":"v") 例如: fun(*args,**kwargs ) fun(1,2,3,4,5,a=10,b=40 ) 我们也可以简单的定义一个函数的参数: def add(*args): total = 0 for i in args: tota

匿名函数与三元表达式

一.匿名函数 匿名函数就是没有名字的函数 特点:有名字的值能多次使用,多次访问:没有名字的值,只能临时使用一次,用完就没有了 匿名函数与有名函数: 关键字为lambda:参数不需要括号,并且支持所有类型的参数:名称空间与作用域关系完全相同:函数中不能写return,会自动将执行结果返回: 函数中只能有一个表达式,且不能换行 匿名函数什么时候去用:当函数的函数体只有一行表达式且只使用一次时,就可以作为匿名函数,更多的是与内置函数的使用 lambda x,y,z=1:x+y+z   #与函数有相同的

8-[函数]-嵌套函数,匿名函数,高阶函数,递归函数

1.嵌套函数 (1)多层函数套用 name = "Alex" def change_name(): name = "Alex2" def change_name2(): name = "Alex3" print("第3层打印", name) change_name2() # 调用内层函数 print("第2层打印", name) change_name() print("最外层打印",

python自动化测试之函数(匿名函数lambda和三目运算等(高级用法))

''' 匿名函数: lambda ''' def Add(a,b): print(a+b) Add(2,3) per = lambda a,b:a+b print(per(2,3)) ''' 三目运算 ''' a = 20 print("True") if a >10 else print("False") ''' 匿名函数+三目运算 ''' login = lambda username,password:print('登录成功') if username

十一、函数递归,算法二分法,三元表达式,列表字典生成式,匿名函数,内置函数

一.函数递归: 函数的递归:函数在调用阶段直接或间接的又调用自身 递归分为两个阶段 1.回溯:就是一次次重复的过程,这个重复的过程必须建立在每一次重复问题的复杂度都应该下降 直到有一个最终的结束条件 2.递推:一次次往回推导的过程 3.递归函数在运行过程中一定要有出口,否则会无限循环下去 # 1.求4以内的和: def sum_numbers(num): if num == 1: return 1 return num + sum_numbers(num - 1) # 递归特点:函数内部自己调用

装饰器的补充(叠加多个装饰器,有参装饰器,三元表达式,生成式,匿名函数)

1,叠加多个装饰器 1),加载顺序(outter函数的调用顺序):自下而上 2),执行顺序(wrapper函数的执行顺序):自上而下 def outter1(func1): #func1=wrapper2的内存地址 print('加载了outter1') def wrapper1(*args,**kwargs): print('执行了wrapper1') res1=func1(*args,**kwargs) return res1 return wrapper1 def outter2(func

递归/匿名函数/三元表达式/列表生成式/字典生成式/二分算法

让在下揭开尔等的面纱,一探究竟:) >>>递归: 递归是一个往复的过程,也就是由两个过程组成,一个是计算过程,一个是将值层层返回的过程,递归的奇妙之处,就在于自身调用自身,然后,过程遵循由复杂到简单,最终满足相应条件后,退出,返回结果.说了一大堆,不过直接上代码: test_list = [1,[2,[3,[4,[5,[6,[7,[8,[9,[10,[11,[12,[13,[14,]]]]]]]]]]]]]] res = 0 def sum_list(test_list, res): f

函数的递归,二分法,三元表达式,列表生成式,字典生成式,匿名函数,内置方法

1 递归函数 函数在调用阶段,直接或间接的调用了自身 递归函数不应该一直递归下去,我们不考虑它到底循环多少次,我们只考虑它的结束条件 递归函数分为两个阶段 1 回溯:就是一次次重复的过程,这个重复的过程,每一次都应该比上一次简单 2 地推:一次次往回推导的过程 2 二分法 可以在一个有序的序列,快速的查找一个元素: b = [1,2,3,4,5,6] a = 3 def func(l,n): if not l: return ret = len(l) // 2 if n > l[ret]: li