Python【day 14-5】sorted filter map函數應用和練習

  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不一樣的地方
一、map最後獲得的是將普通函數（或者匿名函數）的返回值做爲元素的列表
二、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和列表2和列表3的同位置元素，組成元組，元組做爲新列表的元素
    一一對應-map，  zip
二、且列表1的元素都大於2-filter
三、且列表3的元素至少是4個星-filter

步驟：
一、先普通函數
二、後匿名函數
'''

#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-二、返回值--關鍵點
#     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 ')

'''
方法論小結：
一、用filter函數的時候，先寫普通函數
   函數內是if 條件判斷 + return
二、將普通函數修改一下
    函數內直接返回判斷條件
    return + 條件判斷  造成普通函數2
三、將上述普通函數2的
   參數和返回值  填入匿名函數
上述filter或者map先寫普通函數，而後寫匿名函數的方法就是：
一、不跳步驟
二、寫普通函數的時候，就是在整理思路
   思路明確了，匿名函數只須要翻譯便可

知識點小結：
01返回值--關鍵點1
    filter最終返回的是普通函數（或者匿名函數）的參數（符合條件）組成的迭代器（可轉成列表）
        --filter對參數作了if條件篩選
            能夠return參數
            也能夠return篩選條件（if後的）
    map最後返回的是普通函數（或者匿名函數）的返回值組成的迭代器（可轉成列表）
        --map對參數沒有作if條件篩選，而是作了批量修改或者2個列表的同位置運算等

02運行原理--關鍵點2
    filter是把iterable中的每個元素做爲參數，依次傳遞到自定義函數（匿名函數），
        返回值是普通函數的參數（符合條件的--即對參數進行了條件篩選）組成的迭代器（可轉成列表）
    map是把iterable中的每個元素做爲參數，依次傳遞給自定義函數（匿名函數），
        返回值是普通函數（或者匿名函數）的返回值組成的迭代器（可轉成列表）
        map和filter的區別在於：
          一、map沒有對參數進行if條件篩選，返回參數組成的迭代器（可轉成列表)
          二、而是對參數進行了批量操做（好比：批量增長）
            或者多個列表的同位置元素的相加等運算
            返回的是返回值組成的迭代器（可轉成列表）

03zip函數
    一、zip函數的參數能夠是2個列表，也能夠是2個以上列表（好比3個）
    二、支持2個及2個以上列表的同位置元素組成元組，元組做爲新列表的元素
'''