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个以上列表的同位置元素组成元组，元组作为新列表的元素
'''