1 '''''' 2 ''' 3 内置函数或者和匿名函数结合输出 4 4，用map来处理字符串列表,把列表中所有人都变成sb,比方alex_sb 5 name=[‘oldboy’,'alex','wusir'] 6 7 5，用map来处理下述l，然后用list得到一个新的列表，列表中每个人的名字都是sb结尾 8 l=[{'name':'alex'},{'name':'y'}] 9 10 6，用filter来处理,得到股票价格大于20的股票名字 11 shares={ 12 'IBM':36.6, 13 'Lenovo':23.2, 14 'oldboy':21.2, 15 'ocean':10.2, 16 } 17 18 7,有下面字典，得到购买每只股票的总价格，并放在一个迭代器中。 19 结果：list一下[9110.0, 27161.0,......] 20 portfolio = [ 21 {'name': 'IBM', 'shares': 100, 'price': 91.1}, 22 {'name': 'AAPL', 'shares': 50, 'price': 543.22}, 23 {'name': 'FB', 'shares': 200, 'price': 21.09}, 24 {'name': 'HPQ', 'shares': 35, 'price': 31.75}, 25 {'name': 'YHOO', 'shares': 45, 'price': 16.35}, 26 {'name': 'ACME', 'shares': 75, 'price': 115.65}] 27 28 8,还是上面的字典，用filter过滤出单价大于100的股票。 29 30 9,有下列三种数据类型， 31 l1 = [1,2,3,4,5,6] 32 l2 = ['oldboy','alex','wusir','太白','日天'] 33 tu = ('**','***','****','*******') 34 写代码，最终得到的是（每个元祖第一个元素>2,第三个*至少是4个） 35 [(3, 'wusir', '****'), (4, '太白', '*******')]这样的数据。 36 37 10,有如下数据类型： 38 l1 = [ {'sales_volumn': 0}, 39 {'sales_volumn': 108}, 40 {'sales_volumn': 337}, 41 {'sales_volumn': 475}, 42 {'sales_volumn': 396}, 43 {'sales_volumn': 172}, 44 {'sales_volumn': 9}, 45 {'sales_volumn': 58}, 46 {'sales_volumn': 272}, 47 {'sales_volumn': 456}, 48 {'sales_volumn': 440}, 49 {'sales_volumn': 239}] 50 将l1按照列表中的每个字典的values大小进行排序，形成一个新的列表。 51 ''' 52 53 # 4，用map来处理字符串列表,把列表中所有人都变成sb,比方alex_sb 54 # name=[‘oldboy’,'alex','wusir'] 55 name=['oldboy','alex','wusir'] 56 li2 = map(lambda x:x+'_sb',name) 57 print(li2) 58 print(list(li2)) #['oldboy_sb', 'alex_sb', 'wusir_sb'] 59 print('----------------------------------4') 60 61 # 5，用map来处理下述l，然后用list得到一个新的列表，列表中每个人的名字都是sb结尾 62 # l=[{'name':'alex'},{'name':'y'}] 63 l=[{'name':'alex'},{'name':'y'}] 64 li5 = map(lambda dic:dic['name']+'sb',l) 65 print(li5) 66 print(list(li5)) 67 print('----------------------------------5') 68 69 # 8,还是上面的字典，用filter过滤出单价大于100的股票。 70 portfolio = [ 71 {'name': 'IBM', 'shares': 100, 'price': 91.1}, 72 {'name': 'AAPL', 'shares': 50, 'price': 543.22}, 73 {'name': 'FB', 'shares': 200, 'price': 21.09}, 74 {'name': 'HPQ', 'shares': 35, 'price': 31.75}, 75 {'name': 'YHOO', 'shares': 45, 'price': 16.35}, 76 {'name': 'ACME', 'shares': 75, 'price': 115.65}] 77 78 li8 = filter(lambda dic:dic['price']>100,portfolio) 79 print(li8) 80 print(list(li8)) 81 #[{'name': 'AAPL', 'shares': 50, 'price': 543.22}, {'name': 'ACME', 'shares': 75, 'price': 115.65}] 82 print('----------------------------------8') 83 84 # 10,有如下数据类型： 85 # l1 = [ {'sales_volumn': 0}, 86 # {'sales_volumn': 108}, 87 # {'sales_volumn': 337}, 88 # {'sales_volumn': 475}, 89 # {'sales_volumn': 396}, 90 # {'sales_volumn': 172}, 91 # {'sales_volumn': 9}, 92 # {'sales_volumn': 58}, 93 # {'sales_volumn': 272}, 94 # {'sales_volumn': 456}, 95 # {'sales_volumn': 440}, 96 # {'sales_volumn': 239}] 97 # 将l1按照列表中的每个字典的values大小进行排序，形成一个新的列表。 98 l1 = [ {'sales_volumn': 0}, 99 {'sales_volumn': 108}, 100 {'sales_volumn': 337}, 101 {'sales_volumn': 475}, 102 {'sales_volumn': 396}, 103 {'sales_volumn': 172}, 104 {'sales_volumn': 9}, 105 {'sales_volumn': 58}, 106 {'sales_volumn': 272}, 107 {'sales_volumn': 456}, 108 {'sales_volumn': 440}, 109 {'sales_volumn': 239}] 110 li10 = sorted(l1,key=lambda dic:dic['sales_volumn'],reverse = False) 111 print(li10) 112 #[{'sales_volumn': 0}, {'sales_volumn': 9}, {'sales_volumn': 58}, {'sales_volumn': 108}, 113 # {'sales_volumn': 172}, {'sales_volumn': 239}, {'sales_volumn': 272}, {'sales_volumn': 337}, 114 # {'sales_volumn': 396}, {'sales_volumn': 440}, {'sales_volumn': 456}, {'sales_volumn': 475}] 115 print('----------------------------------9')
1 # 6，用filter来处理,得到股票价格大于20的股票名字 2 shares={ 3 'IBM':36.6, 4 'Lenovo':23.2, 5 'oldboy':21.2, 6 'ocean':10.2, 7 } 8 9 10 li61 = filter(lambda x:x[-1]>20,shares.items()) 11 print(list(li61)) #[('IBM', 36.6), ('Lenovo', 23.2), ('oldboy', 21.2)] 12 print('----------------------1') 13 14 def func62(items1): 15 if items1[1] >20: 16 return items1 #返回的是参数，键值对 17 li62 = filter(func62,shares.items()) #shares.items()的每一个元素都是键值对 18 print(list(li62)) #[('IBM', 36.6), ('Lenovo', 23.2), ('oldboy', 21.2)] 19 #最后返回的是键值对，组成的列表 20 print('----------------------2') 21 22 def func621(items1): 23 return items1[1] >20 #返回的是参数，键值对 24 li621 = filter(func621,shares.items()) #shares.items()的每一个元素都是键值对 25 print(list(li621)) #[('IBM', 36.6), ('Lenovo', 23.2), ('oldboy', 21.2)] 26 #最后返回的是键值对，组成的列表 27 print('----------------------2-2') 28 ''' 29 分析过程1： 30 1 遍历循环字典.items()后，每一个元素都是键值对元组,而不是key，在这里--关键点 31 2 把每一个键值对元组依次作为参数items1传入 32 3 当字典的值items1[1]大于20的时候 33 4 将字典的items1(即参数)返回，而不是字典的key返回 34 5 最后返回的是满足条件的items1（键值对元组）组成的列表 35 ''' 36 37 li63 = filter(lambda k:shares[k]>20,shares) 38 print(list(li63)) #['IBM', 'Lenovo', 'oldboy'] 39 print('----------------------3') 40 ''' 41 分析过程2： 42 1 遍历循环字典后，每一个元素都是key,而不是键值对，在这里--关键点 43 2 把每一个key依次作为参数k传入 44 3 当字典的值share[k]大于20的时候 45 4 将字典的k返回，而不是字典的键值对返回 46 5 最后返回的是满足条件的key组成的列表 47 ''' 48 49 for i in shares: 50 print(i) #这个i是字典的key，而不是键值对 51 # IBM 52 # Lenovo 53 # oldboy 54 # ocean 55 print('----------------------3-1') 56 57 for i in shares.items(): 58 print(i) #这个i是字典的key，而不是键值对 59 # ('IBM', 36.6) 60 # ('Lenovo', 23.2) 61 # ('oldboy', 21.2) 62 # ('ocean', 10.2) 63 print('----------------------3-2') 64 65 def func64(key): 66 if shares[key]>20: 67 return key #返回的是字典的key，而不是字典的键值对 68 li64 = filter(func64,shares) 69 print(list(li64)) #['IBM', 'Lenovo', 'oldboy'] 70 #最后返回的是满足条件的key组成的列表 71 print('----------------------4') 72 73 def func65(key): 74 return shares[key]>20 #返回的是字典的key，而不是字典的键值对 关键点 75 li65 = filter(func65,shares) 76 print(list(li65)) #['IBM', 'Lenovo', 'oldboy'] 77 print('----------------------5') 78 79 ''' 80 小结： 81 filter函数+匿名函数，当iterable是字典的时候 82 it1 = filter(lambda k:dic1[k]>20,dic1) 83 print(list(it1)) #传入的参数是key，返回的就是key组成的列表 84 85 it2 = filter(lambda items1:items1[-1]>20,dic1.items()) 86 print(list(it2)) #传入的参数是item（键值对元组），返回的就是键值对元组组成的列表 87 88 上述两个的区别 89 1 前者返回的是符合条件（字典的value-dic1[k]大于20）的字典key，组成的列表 90 ['IBM', 'Lenovo', 'oldboy'] 91 2 后者返回的是符合条件（字典的value-items[1]大于20）的字典的items（键值对元组），组成的列表 92 [('IBM', 36.6), ('Lenovo', 23.2), ('oldboy', 21.2)] 93 94 '''
# 7,有下面字典，得到购买每只股票的总价格，并放在一个迭代器中。 # 结果：list一下[9110.0, 27161.0,......] portfolio = [ {'name': 'IBM', 'shares': 100, 'price': 91.1}, {'name': 'AAPL', 'shares': 50, 'price': 543.22}, {'name': 'FB', 'shares': 200, 'price': 21.09}, {'name': 'HPQ', 'shares': 35, 'price': 31.75}, {'name': 'YHOO', 'shares': 45, 'price': 16.35}, {'name': 'ACME', 'shares': 75, 'price': 115.65}] #方法1 普通函数 def func1(dic1): return dic1['shares'] * dic1['price'] # func1(portfolio) it1 = map(func1,portfolio) print(list(it1)) #[9110.0, 27161.0, 4218.0, 1111.25, 735.7500000000001, 8673.75] print('------------------1 map+普通函数') ''' 分析过程： 1 portfolio是列表，列表的每一个元素是字典 2 把字典作为普通函数的参数，依次传入，将股票价格*股票数量=股票总价值 作为元素返回 3 最后得到股票总价值作为元素的列表 注意：map和filter不同的地方 1、map最后得到的是将普通函数（或者匿名函数）的返回值作为元素的列表 2、filter最后得到的是普通函数（或者匿名函数）的参数（参数经过了筛选，返回的是True）作为元素的列表 ''' #方法2 匿名函数 it2 = map(lambda dic1:dic1['shares'] * dic1['price'],portfolio) print(list(it2)) #[9110.0, 27161.0, 4218.0, 1111.25, 735.7500000000001, 8673.75] print('------------------2 map+匿名函数') ''' 方法论小结： 当匿名函数一下子写不出来的时候，就需要先写出普通函数（写普通函数的过程就是在整理思路） 然后，将普通函数的参数和返回值，填入匿名函数即可，匿名函数就写出来了 '''
# 9,有下列三种数据类型 # l1 = [1,2,3,4,5,6] # l2 = ['oldboy','alex','wusir','太白','日天'] # tu = ('**','***','****','*******') # 写代码，最终得到的是（每个元组第一个元素>2,第三个*至少是4个） # [(3, 'wusir', '****'), (4, '太白', '*******')]这样的数据。 l1 = [1,2,3,4,5,6] l2 = ['oldboy','alex','wusir','太白','日天'] tu = ('**','***','****','*******') ''' 思路 1、列表1和列表2和列表3的同位置元素，组成元组，元组作为新列表的元素 一一对应-map， zip 2、且列表1的元素都大于2-filter 3、且列表3的元素至少是4个星-filter 步骤： 1、先普通函数 2、后匿名函数 ''' #1 3个列表的同位置元素组成的元组--zip print(list(zip(l1,l2))) #[(1, 'oldboy'), (2, 'alex'), (3, 'wusir'), (4, '太白'), (5, '日天')] li3 = list(zip(l1,l2,tu)) #zip支持3个参数 print(li3) #[(1, 'oldboy', '**'), (2, 'alex', '***'), (3, 'wusir', '****'), (4, '太白', '*******')] print('------------------------------0 ') #方法1 普通函数1 def func4(tu1): if tu1[0] > 2 and len(tu1[-1]) >=4: #条件判断 #元组的第一个元素大于2，元组的最后一个元素的长度大于等于4 return tu1 it4 = filter(func4,li3) #这里列表的每一个元素都是一个元组 #将列表的每一个元素作为参数，依次传递到普通函数，进过条件筛选后，返回符合条件的参数组成的迭代器 li4 = list(it4) #迭代器转成列表 print(li4) #[(3, 'wusir', '****'), (4, '太白', '*******')] print('------------------------------1 filter+普通函数1 ') #方法2 普通函数2 def func6(tu1): return tu1[0] > 2 and len(tu1[-1]) >=4 #把上面方法1的条件，作为返回值（实际上，返回的是符合筛选条件的参数组成的迭代器） it6 = filter(func6,li3) li6 = list(it6) #迭代器转成列表 print(li6) #[(3, 'wusir', '****'), (4, '太白', '*******')] print('------------------------------2 filter+普通函数2 ') # 1-2、返回值--关键点 # filter最终返回的是普通函数（或者匿名函数）的参数（符合条件）组成的迭代器（可转成列表） # map最后返回的是普通函数（或者匿名函数）的返回值组成的迭代器（可转成列表） #方法3 匿名函数 it5 = filter(lambda tu1:tu1[0] > 2 and len(tu1[-1]) >=4,li3) # 把上述方法2中 普通函数的参数和返回值 填入匿名函数的冒号前后 li5 = list(it5) #迭代器转成列表 print(li5) #[(3, 'wusir', '****'), (4, '太白', '*******')] print('------------------------------3 filter+匿名函数1 ') ''' 方法论小结： 1、用filter函数的时候，先写普通函数 函数内是if 条件判断 + return 2、将普通函数修改一下 函数内直接返回判断条件 return + 条件判断 形成普通函数2 3、将上述普通函数2的 参数和返回值 填入匿名函数 上述filter或者map先写普通函数，然后写匿名函数的方法就是： 1、不跳步骤 2、写普通函数的时候，就是在整理思路 思路明确了，匿名函数只需要翻译即可 知识点小结： 01返回值--关键点1 filter最终返回的是普通函数（或者匿名函数）的参数（符合条件）组成的迭代器（可转成列表） --filter对参数做了if条件筛选 可以return参数 也可以return筛选条件（if后的） map最后返回的是普通函数（或者匿名函数）的返回值组成的迭代器（可转成列表） --map对参数没有做if条件筛选，而是做了批量修改或者2个列表的同位置运算等 02运行原理--关键点2 filter是把iterable中的每一个元素作为参数，依次传递到自定义函数（匿名函数）， 返回值是普通函数的参数（符合条件的--即对参数进行了条件筛选）组成的迭代器（可转成列表） map是把iterable中的每一个元素作为参数，依次传递给自定义函数（匿名函数）， 返回值是普通函数（或者匿名函数）的返回值组成的迭代器（可转成列表） map和filter的区别在于： 1、map没有对参数进行if条件筛选，返回参数组成的迭代器（可转成列表) 2、而是对参数进行了批量操作（比如：批量增加） 或者多个列表的同位置元素的相加等运算 返回的是返回值组成的迭代器（可转成列表） 03zip函数 1、zip函数的参数可以是2个列表，也可以是2个以上列表（比如3个） 2、支持2个及2个以上列表的同位置元素组成元组，元组作为新列表的元素 '''