内置函数二: map sorted filter

-----------生活里没有奇迹，大部分的时候奇迹是你自己创造的。

# -------------------------------------------------------------------------#

# sum = lambda a,b:a+b
# svm = sum(10,510)
# print(svm)

# st = ["魔兽世界","吃鸡","阴阳师","地下城与勇士","传奇","王者农药"]

# s1 = lambda st:len(st)

# def func(wert):
#     return len(wert)
#
# s2 =sorted(st,key=func)
# print(s2)

#
# nst =[{'id':1,'name':'alex','age':28},
# {'id':2,'name':'taibai','age':58},
# {'id':3,'name':'taihei','age':18},
# {'id':4,'name':'henhei','age':38}]
#
# #
# f4 = filter(lambda s:nst["age"]>=38,nst)
# print(f4)

# def age_up(nst):
#     return nst['age']
#
# s3 = sorted(nst,key=age_up)
# print(s3)

#
# li = ["沙漏","左耳","盗墓笔记","云天","山楂树之恋","盘"]
#
# li2 = filter(lambda s:len(s)>3,li)
# for i in li2:
#     print(i)

# 给出一个列表
# lst = ["alex_123", "alex_456", "wusir_123", "wusir_456", "alex_789"]
# #
# usr = "alex" # 正确的用户名:
# psw = 123      # 密码:
#
# def fuc(nis):
#     for i in lst:
#         x = i.split("_")[0]
#         y = i.split("_")[1]
#         if x == usr and str(y) ==psw:
#             print("OK")
#     return "验证通过"
#
# map = map(fuc,)
#
#
# import os
#
# def fuc(path):
#     lsi = os.listdir(path)
#     for i in lsi:
#         file_real_path = os.path.join(path,i)
#         if os.path.isdir(file_real_path):
#             print(i)
#             fuc(file_real_path)
#         else:
#             print(i)

# lstx = [4, 56, 178, 253, 625, 1475, 2580, 3574, 15963]

# n = int(input("-->"))
# if n in lstx:
#     print("ok")
# else:
#     print("no")
#
# print(lstx)
#
# l = 0
# r = len(lstx) - 1
#
# n = int(input("-->"))
# while l <= r:
#     if n > lstx[(l + r) // 2]:
#         l = (l + r) // 2 + 1
#     elif n < lstx[(l + r) // 2]:
#         r = (l + r) // 2 - 1
#     else:
#         print('找到了')
#         break
# else:
#     print('没有找到')

# sum = 0
# sum1 = 0
# for i in range(1, 100, 2):
#
#     sum = sum + i
#     sum1 = sum + (i + 2)
# print(sum - sum1)

# -------------------------------[]-------------------------------------#

# 1，整理今天所学内容，整理知识点，整理博客。
'''
    1. 匿名函数
        函数:
            def 函数名(形参):
                函数体(return)

            函数名(实参)

            形参:
                1. 位置参数
                2. 默认值参数
                3. 动态传参
                    *args: 动态接收位置参数
                    **kwargs:  动态接收关键字参数

                位置 > *args > 默认值 > **kwargs

            实参:
                1. 位置参数
                2. 关键字参数
                3. 混合参数

            lambda 参数: 返回值

    2. sorted
        排序
        sorted(Iterable, key, reverse)
    3. filter
        筛选
        filter(function, Iterable)
    4. map
        映射
        map(function, Iterable)
    5. 递归
        自己调用自己
    6. 二分法(递归的应用)
        开头
        结尾
        中间

'''
# ---------------------------------------------------------------------------------#
#
# 2，画好流程图。
#  新增面向对象9个函数
#  新增反射相关4个函数

# ---------------------------------------------------------------------------------#

# ------------------[都完成的,做一下作业（下面题都是用内置函数或者和匿名函数结合做出）：]---------------------#

# 4，用map来处理字符串列表,把列表中所有人都追加"_sb",比方:alex_sb
# name=['oldboy','alex','wusir']
#                 # map把可迭代对象中的每一个元素拿出来交给前面的函数执行. 保留最后的执行结果
# m = map(lambda s: s+"_sb", name)
# for i in m:
#     print(i)

# ---------------------------------------------------------------------------------#
# 5，用map来处理下述l，然后用list得到一个新的列表，列表中每个人的名字都是sb结尾
# l=[{'name':'alex'},{'name':'y'}]
#
# m1 = map(lambda s: s['name']+"_sb", l)
#
# print(list(map(lambda s: s['name']+"_sb", l)))

# ---------------------------------------------------------------------------------#
# 6，用filter来处理,得到股票价格大于20的股票名字
# shares = {
#     'IBM': 36.6,
#     'Lenovo': 23.2,
#     'oldboy': 21.2,
#     'ocean': 10.2,
# }
# #
# #        把后面的可迭代对象中的每一个元素交给前面的函数。 根据函数返回的True或者False。 判断是否保留该元素
#
# print(list(filter(lambda key: shares[key] > 20, shares)))

# print(list(filter(lambda ren: ren['age']>=38, lst)))

# ---------------------------------------------------------------------------------#
# 7,有下面字典，得到购买每只股票的总价格，并放在一个迭代器中。
# 结果：list一下[9110.0, 27161.0,......]  shares * price

# 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.8},
# {'name':'ACME','shares':75,'price':115.65}]

# lis = []
#
# m = map(lambda s:s['shares'] * s['price'],portfolio)
# print(list(m))

# ----->[9110.0, 27161.0, 4218.0, 1111.25, 735.751, 8673.75]

## ---------------------------------------------------------------------------------#
# 8,还是上面的字典，用filter过滤出单价大于100的股票。
# print(list(filter(lambda v:v["price"]>100,portfolio)))

## ---------------------------------------------------------------------------------#
# 9,有下列三种数据类型，

# l1 = [1,2,3,4,5,6]
# l2 = ['oldboy','alex','wusir','太白','日天']
# tu = ('**','***','****','*******')

# # 写代码，最终得到的是（每个元祖第一个元素>2,第三个*至少是4个）
# #[(3, 'wusir', '****'), (4, '太白', '*******')]这样的数据。
# #

# [曲解]
# lsit = [{l1:1,2,3,4,5,6},
# {l2:'oldboy','alex','wusir','太白','日天'},
# {tu:('**','***','****','*******')}]
# print(list(filter(lambda (x,y,z):(x:x>2,l1) and (y:l2[y+2],l2) and (z:tu[z+2],tu),lsit)))
#

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

## ---------------------------------------------------------------------------------#
# 10,有如下数据类型：
l1 = [ {'sales_volumn': 0},
      {'sales_volumn': 108},
      {'sales_volumn': 337},
      {'sales_volumn': 475},
      {'sales_volumn': 396},
      {'sales_volumn': 172},
      {'sales_volumn': 90},
      {'sales_volumn': 58},
      {'sales_volumn': 272},
      {'sales_volumn': 456},
      {'sales_volumn': 440},
      {'sales_volumn': 239}]
# 将l1按照列表中的每个字典的values大小进行排序，形成一个新的列表。
# def fuc(s):
#     return s["dic:dic["age"]"]
# x =sorted(l1,fuc)
print(sorted(l1,key=lambda dic:dic["sales_volumn"]))