python 基础篇 15 内置函数和匿名函数
------------------------>>>>>>>>>>>>>>>内置函数<<<<<<<<<<<<<<<<<<<<----------------------------------------
内置函数
我们一起来看看python里的内置函数。什么是内置函数？就是Python给你提供的，拿来直接用的函数，比如print，input等等。截止到python版本3.6.2，现在python一共为我们提供了68个内置函数。它们就是python提供给你直接可以拿来使用的所有函数。这些函数有些我们已经用过了，有些我们还没用到过，还有一些是被封印了，必须等我们学了新知识才能解开封印的。那今天我们就一起来认识一下python的内置函数。这么多函数，我们该从何学起呢？
1.1作用域相关
locals ：函数会以字典的类型返回当前位置的全部局部变量。
globals：函数以字典的类型返回全部全局变量。
1 a = 1 2 b = 2 3 print(locals()) 4 print(globals()) 5 # 这两个一样，因为是在全局执行的。 6 7 ########################## 8 9 def func(argv): 10 c = 2 11 print(locals()) 12 print(globals()) 13 func(3) 14 15 #这两个不一样，locals() {'argv': 3, 'c': 2} 16 #globals() {'__doc__': None, '__builtins__': <module 'builtins' (built-in)>, '__cached__': None, '__loader__': <_frozen_importlib_external.SourceFileLoader object at 0x0000024409148978>, '__spec__': None, '__file__': 'D:/lnh.python/.../内置函数.py', 'func': <function func at 0x0000024408CF90D0>, '__name__': '__main__', '__package__': None}
1.2其他相关
1.2.1 字符串类型代码的执行 eval，exec，complie
eval：执行字符串类型的代码，并返回最终结果。
1 eval('2 + 2') # 4 2 3 4 n=81 5 eval("n + 4") # 85 6 7 8 eval('print(666)') # 666
exec:执行字符串类型的代码。
1 s = ''' 2 for i in [1,2,3]: 3 print(i) 4 ''' 5 exec(s)
compile:将字符串类型的代码编译。代码对象能够通过exec语句来执行或者eval()进行求值。
1 ''' 2 参数说明： 3 4 1. 参数source：字符串或者AST（Abstract Syntax Trees）对象。即需要动态执行的代码段。 5 6 2. 参数 filename：代码文件名称，如果不是从文件读取代码则传递一些可辨认的值。当传入了source参数时，filename参数传入空字符即可。 7 8 3. 参数model：指定编译代码的种类，可以指定为 ‘exec’,’eval’,’single’。当source中包含流程语句时，model应指定为‘exec’；当source中只包含一个简单的求值表达式，model应指定为‘eval’；当source中包含了交互式命令语句，model应指定为'single'。 9 ''' 10 >>> #流程语句使用exec 11 >>> code1 = 'for i in range(0,10): print (i)' 12 >>> compile1 = compile(code1,'','exec') 13 >>> exec (compile1) 14 15 16 >>> #简单求值表达式用eval 17 >>> code2 = '1 + 2 + 3 + 4' 18 >>> compile2 = compile(code2,'','eval') 19 >>> eval(compile2) 20 21 22 >>> #交互语句用single 23 >>> code3 = 'name = input("please input your name:")' 24 >>> compile3 = compile(code3,'','single') 25 >>> name #执行前name变量不存在 26 Traceback (most recent call last): 27 File "<pyshell#29>", line 1, in <module> 28 name 29 NameError: name 'name' is not defined 30 >>> exec(compile3) #执行时显示交互命令，提示输入 31 please input your name:'pythoner' 32 >>> name #执行后name变量有值 33 "'pythoner'"
有返回值的字符串形式的代码用eval，没有返回值的字符串形式的代码用exec，一般不用compile。
1.2.2 输入输出相关 input，print
input:函数接受一个标准输入数据，返回为 string 类型。
print:打印输出。
1 ''' 源码分析 2 def print(self, *args, sep=' ', end='\n', file=None): # known special case of print 3 """ 4 print(value, ..., sep=' ', end='\n', file=sys.stdout, flush=False) 5 file: 默认是输出到屏幕，如果设置为文件句柄，输出到文件 6 sep: 打印多个值之间的分隔符，默认为空格 7 end: 每一次打印的结尾，默认为换行符 8 flush: 立即把内容输出到流文件，不作缓存 9 """ 10 ''' 11 12 print(111,222,333,sep='*') # 111*222*333 13 14 print(111,end='') 15 print(222) #两行的结果 111222 16 17 f = open('log','w',encoding='utf-8') 18 print('写入文件',file=f,flush=True)
1.2.3内存相关 hash id
hash：获取一个对象（可哈希对象：int，str，Bool，tuple）的哈希值。
1 print(hash(12322)) 2 print(hash('123')) 3 print(hash('arg')) 4 print(hash('alex')) 5 print(hash(True)) 6 print(hash(False)) 7 print(hash((1,2,3))) 8 9 ''' 10 12322 11 -2996001552409009098 12 -4637515981888139739 13 2311495795356652852 14 1 15 0 16 2528502973977326415 17 '''
id:用于获取对象的内存地址。
1 print(id(123)) # 1674055952 2 print(id('abc')) # 2033192957072
1.2.3文件操作相关
open：函数用于打开一个文件，创建一个 file 对象，相关的方法才可以调用它进行读写。
1.2.4模块相关__import__
__import__：函数用于动态加载类和函数 。
1.2.5帮助
help：函数用于查看函数或模块用途的详细说明。
1 print(help(list)) 2 Help on class list in module builtins: 3 4 class list(object) 5 | list() -> new empty list 6 | list(iterable) -> new list initialized from iterable's items 7 | 8 | Methods defined here: 9 | 10 | __add__(self, value, /) 11 | Return self+value. 12 | 13 | __contains__(self, key, /) 14 | Return key in self. 15 | 16 | __delitem__(self, key, /) 17 | Delete self[key]. 18 | 19 | __eq__(self, value, /) 20 | Return self==value. 21 | 22 | __ge__(self, value, /) 23 | Return self>=value. 24 | 25 | __getattribute__(self, name, /) 26 | Return getattr(self, name). 27 | 28 | __getitem__(...) 29 | x.__getitem__(y) <==> x[y] 30 | 31 | __gt__(self, value, /) 32 | Return self>value. 33 | 34 | __iadd__(self, value, /) 35 | Implement self+=value. 36 | 37 | __imul__(self, value, /) 38 | Implement self*=value. 39 | 40 | __init__(self, /, *args, **kwargs) 41 | Initialize self. See help(type(self)) for accurate signature. 42 | 43 | __iter__(self, /) 44 | Implement iter(self). 45 | 46 | __le__(self, value, /) 47 | Return self<=value. 48 | 49 | __len__(self, /) 50 | Return len(self). 51 | 52 | __lt__(self, value, /) 53 | Return self<value. 54 | 55 | __mul__(self, value, /) 56 | Return self*value.n 57 | 58 | __ne__(self, value, /) 59 | Return self!=value. 60 | 61 | __new__(*args, **kwargs) from builtins.type 62 | Create and return a new object. See help(type) for accurate signature. 63 | 64 | __repr__(self, /) 65 | Return repr(self). 66 | 67 | __reversed__(...) 68 | L.__reversed__() -- return a reverse iterator over the list 69 | 70 | __rmul__(self, value, /) 71 | Return self*value. 72 | 73 | __setitem__(self, key, value, /) 74 | Set self[key] to value. 75 | 76 | __sizeof__(...) 77 | L.__sizeof__() -- size of L in memory, in bytes 78 | 79 | append(...) 80 | L.append(object) -> None -- append object to end 81 | 82 | clear(...) 83 | L.clear() -> None -- remove all items from L 84 | 85 | copy(...) 86 | L.copy() -> list -- a shallow copy of L 87 | 88 | count(...) 89 | L.count(value) -> integer -- return number of occurrences of value 90 | 91 | extend(...) 92 | L.extend(iterable) -> None -- extend list by appending elements from the iterable 93 | 94 | index(...) 95 | L.index(value, [start, [stop]]) -> integer -- return first index of value. 96 | Raises ValueError if the value is not present. 97 | 98 | insert(...) 99 | L.insert(index, object) -- insert object before index 100 | 101 | pop(...) 102 | L.pop([index]) -> item -- remove and return item at index (default last). 103 | Raises IndexError if list is empty or index is out of range. 104 | 105 | remove(...) 106 | L.remove(value) -> None -- remove first occurrence of value. 107 | Raises ValueError if the value is not present. 108 | 109 | reverse(...) 110 | L.reverse() -- reverse *IN PLACE* 111 | 112 | sort(...) 113 | L.sort(key=None, reverse=False) -> None -- stable sort *IN PLACE* 114 | 115 | ---------------------------------------------------------------------- 116 | Data and other attributes defined here: 117 | 118 | __hash__ = None 119 120 None 121 122 Process finished with exit code 0
1.2.6调用相关
callable：函数用于检查一个对象是否是可调用的。如果返回True，object仍然可能调用失败；但如果返回False，调用对象ojbect绝对不会成功。
1 >>>callable(0) 2 False 3 >>> callable("runoob") 4 False 5 6 >>> def add(a, b): 7 ... return a + b 8 ... 9 >>> callable(add) # 函数返回 True 10 True 11 >>> class A: # 类 12 ... def method(self): 13 ... return 0 14 ... 15 >>> callable(A) # 类返回 True 16 True 17 >>> a = A() 18 >>> callable(a) # 没有实现 __call__, 返回 False 19 False 20 >>> class B: 21 ... def __call__(self): 22 ... return 0 23 ... 24 >>> callable(B) 25 True 26 >>> b = B() 27 >>> callable(b) # 实现 __call__, 返回 True
1.2.7查看内置属性
dir：函数不带参数时，返回当前范围内的变量、方法和定义的类型列表；带参数时，返回参数的属性、方法列表。如果参数包含方法__dir__()，该方法将被调用。
如果参数不包含__dir__()，该方法将最大限度地收集参数信息。
1 >>>dir() # 获得当前模块的属性列表 2 ['__builtins__', '__doc__', '__name__', '__package__', 'arr', 'myslice'] 3 >>> dir([ ]) # 查看列表的方法 4 ['__add__', '__class__', '__contains__', '__delattr__', '__delitem__', '__delslice__', '__doc__', '__eq__', '__format__', '__ge__', '__getattribute__', '__getitem__', '__getslice__', '__gt__', '__hash__', '__iadd__', '__imul__', '__init__', '__iter__', '__le__', '__len__', '__lt__', '__mul__', '__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__reversed__', '__rmul__', '__setattr__', '__setitem__', '__setslice__', '__sizeof__', '__str__', '__subclasshook__', 'append', 'count', 'extend', 'index', 'insert', 'pop', 'remove', 'reverse', 'sort']
1.3 迭代器生成器相关
range：函数可创建一个整数对象，一般用在 for 循环中。
next：内部实际使用了__next__方法，返回迭代器的下一个项目。
1 # 首先获得Iterator对象: 2 it = iter([1, 2, 3, 4, 5]) 3 # 循环: 4 while True: 5 try: 6 # 获得下一个值: 7 x = next(it) 8 print(x) 9 except StopIteration: 10 # 遇到StopIteration就退出循环 11 break
iter：函数用来生成迭代器（讲一个可迭代对象，生成迭代器）。
1 from collections import Iterable 2 from collections import Iterator 3 l = [1,2,3] 4 print(isinstance(l,Iterable)) # True 5 print(isinstance(l,Iterator)) # False 6 7 l1 = iter(l) 8 print(isinstance(l1,Iterable)) # True 9 print(isinstance(l1,Iterator)) # True
1.4 基础数据类型相关
1.4.1数字相关（14）
数据类型（4）：
bool ：用于将给定参数转换为布尔类型，如果没有参数，返回 False。
int：函数用于将一个字符串或数字转换为整型。
1 print(int()) # 0 2 3 print(int('12')) # 12 4 5 print(int(3.6)) # 3 6 7 print(int('0100',base=2)) # 将2进制的 0100 转化成十进制。结果为 4
float：函数用于将整数和字符串转换成浮点数。
complex：函数用于创建一个值为 real + imag * j 的复数或者转化一个字符串或数为复数。如果第一个参数为字符串，则不需要指定第二个参数。。
1 >>>complex(1, 2) 2 (1 + 2j) 3 4 >>> complex(1) # 数字 5 (1 + 0j) 6 7 >>> complex("1") # 当做字符串处理 8 (1 + 0j) 9 10 # 注意：这个地方在"+"号两边不能有空格，也就是不能写成"1 + 2j"，应该是"1+2j"，否则会报错 11 >>> complex("1+2j") 12 (1 + 2j)
进制转换（3）：
bin：将十进制转换成二进制并返回。
oct：将十进制转化成八进制字符串并返回。
hex：将十进制转化成十六进制字符串并返回。
1 print(bin(10),type(bin(10))) # 0b1010 <class 'str'> 2 print(oct(10),type(oct(10))) # 0o12 <class 'str'> 3 print(hex(10),type(hex(10))) # 0xa <class 'str'>
数学运算（7）：
abs：函数返回数字的绝对值。
divmod：计算除数与被除数的结果，返回一个包含商和余数的元组(a // b, a % b)。
round：保留浮点数的小数位数，默认保留整数。
pow：求x**y次幂。（三个参数为x**y的结果对z取余）
1 print(abs(-5)) # 5 2 3 print(divmod(7,2)) # (3, 1) 4 5 print(round(7/3,2)) # 2.33 6 print(round(7/3)) # 2 7 print(round(3.32567,3)) # 3.326 8 9 print(pow(2,3)) # 两个参数为2**3次幂 10 print(pow(2,3,3)) # 三个参数为2**3次幂，对3取余。
sum：对可迭代对象进行求和计算（可设置初始值）。
min：返回可迭代对象的最小值（可加key，key为函数名，通过函数的规则，返回最小值）。
max：返回可迭代对象的最大值（可加key，key为函数名，通过函数的规则，返回最大值）。
1 print(sum([1,2,3])) 2 print(sum((1,2,3),100)) 3 4 print(min([1,2,3])) # 返回此序列最小值 5 6 ret = min([1,2,-5,],key=abs) # 按照绝对值的大小，返回此序列最小值 7 print(ret) 8 9 dic = {'a':3,'b':2,'c':1} 10 print(min(dic,key=lambda x:dic[x])) 11 # x为dic的key，lambda的返回值（即dic的值进行比较）返回最小的值对应的键 12 13 14 print(max([1,2,3])) # 返回此序列最大值 15 16 ret = max([1,2,-5,],key=abs) # 按照绝对值的大小，返回此序列最大值 17 print(ret) 18 19 dic = {'a':3,'b':2,'c':1} 20 print(max(dic,key=lambda x:dic[x])) 21 # x为dic的key，lambda的返回值（即dic的值进行比较）返回最大的值对应的键
1.4.2和数据结构相关（24）
列表和元祖（2）
list：将一个可迭代对象转化成列表（如果是字典，默认将key作为列表的元素）。
tuple：将一个可迭代对象转化成元祖（如果是字典，默认将key作为元祖的元素）。
1 l = list((1,2,3)) 2 print(l) 3 4 l = list({1,2,3}) 5 print(l) 6 7 l = list({'k1':1,'k2':2}) 8 print(l) 9 10 tu = tuple((1,2,3)) 11 print(tu) 12 13 tu = tuple([1,2,3]) 14 print(tu) 15 16 tu = tuple({'k1':1,'k2':2}) 17 print(tu)
相关内置函数（2）
reversed：将一个序列翻转，并返回此翻转序列的迭代器。
slice：构造一个切片对象，用于列表的切片。
1 ite = reversed(['a',2,3,'c',4,2]) 2 for i in ite: 3 print(i) 4 5 li = ['a','b','c','d','e','f','g'] 6 sli_obj = slice(3) 7 print(li[sli_obj]) 8 9 sli_obj = slice(0,7,2) 10 print(li[sli_obj])
字符串相关（9）
str：将数据转化成字符串。
format:与具体数据相关，用于计算各种小数，精算等。
1 #字符串可以提供的参数,指定对齐方式，<是左对齐， >是右对齐，^是居中对齐 2 print(format('test', '<20')) 3 print(format('test', '>20')) 4 print(format('test', '^20')) 5 6 #整形数值可以提供的参数有 'b' 'c' 'd' 'o' 'x' 'X' 'n' None 7 >>> format(3,'b') #转换成二进制 8 '11' 9 >>> format(97,'c') #转换unicode成字符 10 'a' 11 >>> format(11,'d') #转换成10进制 12 '11' 13 >>> format(11,'o') #转换成8进制 14 '13' 15 >>> format(11,'x') #转换成16进制 小写字母表示 16 'b' 17 >>> format(11,'X') #转换成16进制 大写字母表示 18 'B' 19 >>> format(11,'n') #和d一样 20 '11' 21 >>> format(11) #默认和d一样 22 '11' 23 24 #浮点数可以提供的参数有 'e' 'E' 'f' 'F' 'g' 'G' 'n' '%' None 25 >>> format(314159267,'e') #科学计数法，默认保留6位小数 26 '3.141593e+08' 27 >>> format(314159267,'0.2e') #科学计数法，指定保留2位小数 28 '3.14e+08' 29 >>> format(314159267,'0.2E') #科学计数法，指定保留2位小数，采用大写E表示 30 '3.14E+08' 31 >>> format(314159267,'f') #小数点计数法，默认保留6位小数 32 '314159267.000000' 33 >>> format(3.14159267000,'f') #小数点计数法，默认保留6位小数 34 '3.141593' 35 >>> format(3.14159267000,'0.8f') #小数点计数法，指定保留8位小数 36 '3.14159267' 37 >>> format(3.14159267000,'0.10f') #小数点计数法，指定保留10位小数 38 '3.1415926700' 39 >>> format(3.14e+1000000,'F') #小数点计数法，无穷大转换成大小字母 40 'INF' 41 42 #g的格式化比较特殊，假设p为格式中指定的保留小数位数，先尝试采用科学计数法格式化，得到幂指数exp，如果-4<=exp<p，则采用小数计数法，并保留p-1-exp位小数，否则按小数计数法计数，并按p-1保留小数位数 43 >>> format(0.00003141566,'.1g') #p=1,exp=-5 ==》 -4<=exp<p不成立，按科学计数法计数，保留0位小数点 44 '3e-05' 45 >>> format(0.00003141566,'.2g') #p=1,exp=-5 ==》 -4<=exp<p不成立，按科学计数法计数，保留1位小数点 46 '3.1e-05' 47 >>> format(0.00003141566,'.3g') #p=1,exp=-5 ==》 -4<=exp<p不成立，按科学计数法计数，保留2位小数点 48 '3.14e-05' 49 >>> format(0.00003141566,'.3G') #p=1,exp=-5 ==》 -4<=exp<p不成立，按科学计数法计数，保留0位小数点，E使用大写 50 '3.14E-05' 51 >>> format(3.1415926777,'.1g') #p=1,exp=0 ==》 -4<=exp<p成立，按小数计数法计数，保留0位小数点 52 '3' 53 >>> format(3.1415926777,'.2g') #p=1,exp=0 ==》 -4<=exp<p成立，按小数计数法计数，保留1位小数点 54 '3.1' 55 >>> format(3.1415926777,'.3g') #p=1,exp=0 ==》 -4<=exp<p成立，按小数计数法计数，保留2位小数点 56 '3.14' 57 >>> format(0.00003141566,'.1n') #和g相同 58 '3e-05' 59 >>> format(0.00003141566,'.3n') #和g相同 60 '3.14e-05' 61 >>> format(0.00003141566) #和g相同 62 '3.141566e-05'
bytes：用于不同编码之间的转化。
1 # s = '你好' 2 # bs = s.encode('utf-8') 3 # print(bs) 4 # s1 = bs.decode('utf-8') 5 # print(s1) 6 # bs = bytes(s,encoding='utf-8') 7 # print(bs) 8 # b = '你好'.encode('gbk') 9 # b1 = b.decode('gbk') 10 # print(b1.encode('utf-8'))
bytearry：返回一个新字节数组。这个数组里的元素是可变的，并且每个元素的值范围: 0 <= x < 256。
1 ret = bytearray('alex',encoding='utf-8') 2 print(id(ret)) 3 print(ret) 4 print(ret[0]) 5 ret[0] = 65 6 print(ret) 7 print(id(ret))
memoryview
1 ret = memoryview(bytes('你好',encoding='utf-8')) 2 print(len(ret)) 3 print(ret) 4 print(bytes(ret[:3]).decode('utf-8')) 5 print(bytes(ret[3:]).decode('utf-8'))
ord:输入字符找该字符编码的位置
chr:输入位置数字找出其对应的字符
ascii:是ascii码中的返回该值，不是就返回/u...
1 # ord 输入字符找该字符编码的位置 2 # print(ord('a')) 3 # print(ord('中')) 4 5 # chr 输入位置数字找出其对应的字符 6 # print(chr(97)) 7 # print(chr(20013)) 8 9 # 是ascii码中的返回该值，不是就返回/u... 10 # print(ascii('a')) 11 # print(ascii('中'))
repr:返回一个对象的string形式（原形毕露）。
1 # %r 原封不动的写出来 2 # name = 'taibai' 3 # print('我叫%r'%name) 4 5 # repr 原形毕露 6 print(repr('{"name":"alex"}')) 7 print('{"name":"alex"}')
数据集合（3）
dict：创建一个字典。
set：创建一个集合。
frozenset：返回一个冻结的集合，冻结后集合不能再添加或删除任何元素。
相关内置函数（8）
len:返回一个对象中元素的个数。
sorted：对所有可迭代的对象进行排序操作。
1 L = [('a', 1), ('c', 3), ('d', 4),('b', 2), ] 2 sorted(L, key=lambda x:x[1]) # 利用key 3 [('a', 1), ('b', 2), ('c', 3), ('d', 4)] 4 5 6 students = [('john', 'A', 15), ('jane', 'B', 12), ('dave', 'B', 10)] 7 sorted(students, key=lambda s: s[2]) # 按年龄排序 8 [('dave', 'B', 10), ('jane', 'B', 12), ('john', 'A', 15)] 9 10 sorted(students, key=lambda s: s[2], reverse=True) # 按降序 11 [('john', 'A', 15), ('jane', 'B', 12), ('dave', 'B', 10)]
enumerate:枚举，返回一个枚举对象。
1 print(enumerate([1,2,3])) 2 for i in enumerate([1,2,3]): 3 print(i) 4 for i in enumerate([1,2,3],100): 5 print(i)
all：可迭代对象中，全都是True才是True
any：可迭代对象中，有一个True 就是True
1 # all 可迭代对象中，全都是True才是True 2 # any 可迭代对象中，有一个True 就是True 3 # print(all([1,2,True,0])) 4 # print(any([1,'',0]))
zip：函数用于将可迭代的对象作为参数，将对象中对应的元素打包成一个个元组，然后返回由这些元组组成的列表。
如果各个迭代器的元素个数不一致，则返回列表长度与最短的对象相同。
1 l1 = [1,2,3,] 2 l2 = ['a','b','c',5] 3 l3 = ('*','**',(1,2,3)) 4 for i in zip(l1,l2,l3): 5 print(i)
filter：过滤·。
1 #filter 过滤 通过你的函数，过滤一个可迭代对象，返回的是True 2 #类似于[i for i in range(10) if i > 3] 3 # def func(x):return x%2 == 0 4 # ret = filter(func,[1,2,3,4,5,6,7]) 5 # print(ret) 6 # for i in ret: 7 # print(i)
map:会根据提供的函数对指定序列做映射。
1 >>>def square(x) : # 计算平方数 2 ... return x ** 2 3 ... 4 >>> map(square, [1,2,3,4,5]) # 计算列表各个元素的平方 5 [1, 4, 9, 16, 25] 6 >>> map(lambda x: x ** 2, [1, 2, 3, 4, 5]) # 使用 lambda 匿名函数 7 [1, 4, 9, 16, 25] 8 9 # 提供了两个列表，对相同位置的列表数据进行相加 10 >>> map(lambda x, y: x + y, [1, 3, 5, 7, 9], [2, 4, 6, 8, 10]) 11 [3, 7, 11, 15, 19]
匿名函数
匿名函数：为了解决那些功能很简单的需求而设计的一句话函数。
#这段代码 def calc(n): return n**n print(calc(10)) #换成匿名函数 calc = lambda n:n**n print(calc(10))
我们可以看出，匿名函数并不是真的不能有名字。
匿名函数的调用和正常的调用也没有什么分别。 就是 函数名(参数) 就可以了～～～
匿名函数与内置函数举例：
1 l=[3,2,100,999,213,1111,31121,333] 2 print(max(l)) 3 4 dic={'k1':10,'k2':100,'k3':30} 5 6 7 print(max(dic)) 8 print(dic[max(dic,key=lambda k:dic[k])])
1 res = map(lambda x:x**2,[1,5,7,4,8]) 2 for i in res: 3 print(i)
1 res = filter(lambda x:x>10,[5,8,11,9,15]) 2 for i in res: 3 print(i)
