day15——匿名函數，sorted，filter，map，遞歸，二分法

1. lambda    匿名函數
    語法——lambda 參數:返回值
    __name__:查看函數的名字（查看究竟是誰）


2. sorted()  排序函數
    語法：sorted(iterable, key = 函數名, reverse = False)
    內置函數提供的一個通用的排序方案，sortend（）
    key: 排序方案，sorted函數會把可迭代對象中的每個元素拿出來交給後面的key
         後面的key計算出一個數字（權重），做爲當前這個元素的權重，整個函數根據權重排序
    reverse=True： 默認表示爲正序， reverse=False表示反轉


3. filter()  過濾函數
    語法： filter(function, iterable)

    li = ['sv','sdf','fdf','fdsg','ghfd']
    f = filter(lambda a:a[0] != 's',li)
    for i in f:
        print(i)

        答案：
        fdf
        fdsg
        ghfd


4. map() 映射函數(水桶效應)
    語法： map(function, iterable)
    把後面的可迭代對象中的每個元素傳遞給function，結果就是function的處理結果


5. 遞歸
    函數本身調用本身
    官方最大深度：1000

    
6. 二分法
    核心：掐頭去尾取中間，一次砍一半
    前提條件：有序序列
    能夠提升效率

    兩種算法：常規循環，遞歸循環

day14——做業



4，用map來處理字符串列表,把列表中全部人都變成sb,比方alex_sb

name=['oldboy','alex','wusir']
l = map(lambda a : a +'_sb',name)
print(l)

5，用map來處理下述l，而後用list獲得一個新的列表，列表中每一個人的名字都是sb結尾

l=[{'name':'alex'},{'name':'y'}]
ret = list(map(lambda a:a['name']+'sb', l))
print(ret)

6，用filter來處理,獲得股票價格大於20的股票名字

shares={
       'IBM':36.6,
       'Lenovo':23.2,
   'oldboy':21.2,
    'ocean':10.2,
   }

ret = list(filter(lambda a:shares[a]>20, shares))
print(ret)
for i in ret:
    print(i)

 

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}
]

ret = list(map(lambda x:x['shares'] * x['price'],portfolio))
print(ret)

 

8,仍是上面的字典，用filter過濾出單價大於100的股票。

ret2 = list(filter(lambda a:a['price'] > 100,portfolio))
print(ret2)

9,有下列三種數據類型，

l1 = [1,2,3,4,5,6]
l2 = ['oldboy','alex','wusir','太白','日天']
tu = ('**','***','****','*******')
寫代碼，最終獲得的是（每一個元祖第一個元素>2,第三個*至少是4個。）
   [(3, 'wusir', '****'), (4, '太白', '*******')]這樣的數據。


ret = list(filter(lambda x: x[0] > 2 and len(x[2]) > 3, zip(l1,l2,tu)))
print(ret)

 

10,有以下數據類型：

l1 = [ {'sales_volumn': 0},
        {'sales_volumn': 108},
        {'sales_volumn': 337},
        {'sales_volumn': 475},
        {'sales_volumn': 396},
        {'sales_volumn': 172},
        {'sales_volumn': 9},
        {'sales_volumn': 58},
        {'sales_volumn': 272},
        {'sales_volumn': 456},
        {'sales_volumn': 440},
        {'sales_volumn': 239}]
將l1按照列表中的每一個字典的values大小進行排序，造成一個新的列表。
ret = list(sorted(l1, key = lambda x:x['sales_volumn']))
print(ret)