欢迎您访问程序员文章站本站旨在为大家提供分享程序员计算机编程知识!
您现在的位置是: 首页  >  IT编程

Python【day 14-5】sorted filter map函数应用和练习

程序员文章站 2023-02-06 20:33:03
1 '''''' 2 ''' 3 内置函数或者和匿名函数结合输出 4 4,用map来处理字符串列表,把列表中所有人都变成sb,比方alex_sb 5 name=[‘oldboy’,'alex','wusir'] 6 7 5,用map来处理下述l,然后用list得到一个新的列表,列表中每个人的名字都是... ......
  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个以上列表的同位置元素组成元组,元组作为新列表的元素
'''