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)