Python【day 14-5】sorted filter map函数应用和练习

''''''
'''
内置函数或者和匿名函数结合输出
4，用map来处理字符串列表,把列表中所有人都变成sb,比方alex_sb
    name=[‘oldboy’,'alex','wusir']

5，用map来处理下述l，然后用list得到一个新的列表，列表中每个人的名字都是sb结尾
    l=[{'name':'alex'},{'name':'y'}]

6，用filter来处理,得到股票价格大于20的股票名字
shares={
       'IBM':36.6,
       'Lenovo':23.2,
      'oldboy':21.2,
    'ocean':10.2,
    }

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

8,还是上面的字典，用filter过滤出单价大于100的股票。

9,有下列三种数据类型，
    l1 = [1,2,3,4,5,6]
    l2 = ['oldboy','alex','wusir','太白','日天']
    tu = ('**','***','****','*******')
写代码，最终得到的是（每个元祖第一个元素>2,第三个*至少是4个）
    [(3, 'wusir', '****'), (4, '太白', '*******')]这样的数据。

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大小进行排序，形成一个新的列表。
'''

# 4，用map来处理字符串列表,把列表中所有人都变成sb,比方alex_sb
#     name=[‘oldboy’,'alex','wusir']
name=['oldboy','alex','wusir']
li2 = map(lambda x:x+'_sb',name)
print(li2)
print(list(li2)) #['oldboy_sb', 'alex_sb', 'wusir_sb']
print('----------------------------------4')

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

# 8,还是上面的字典，用filter过滤出单价大于100的股票。
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}]

li8 = filter(lambda dic:dic['price']>100,portfolio)
print(li8)
print(list(li8))
#[{'name': 'AAPL', 'shares': 50, 'price': 543.22}, {'name': 'ACME', 'shares': 75, 'price': 115.65}]
print('----------------------------------8')

# 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大小进行排序，形成一个新的列表。
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}]
li10 = sorted(l1,key=lambda dic:dic['sales_volumn'],reverse = False)
print(li10)
#[{'sales_volumn': 0}, {'sales_volumn': 9}, {'sales_volumn': 58}, {'sales_volumn': 108},
#  {'sales_volumn': 172}, {'sales_volumn': 239}, {'sales_volumn': 272}, {'sales_volumn': 337},
#  {'sales_volumn': 396}, {'sales_volumn': 440}, {'sales_volumn': 456}, {'sales_volumn': 475}]
print('----------------------------------9')

# 6，用filter来处理,得到股票价格大于20的股票名字
shares={
       'IBM':36.6,
       'Lenovo':23.2,
      'oldboy':21.2,
    'ocean':10.2,
    }


li61 = filter(lambda x:x[-1]>20,shares.items())
print(list(li61))  #[('IBM', 36.6), ('Lenovo', 23.2), ('oldboy', 21.2)]
print('----------------------1')

def func62(items1):
    if items1[1] >20:
        return items1   #返回的是参数，键值对
li62 = filter(func62,shares.items())  #shares.items()的每一个元素都是键值对
print(list(li62)) #[('IBM', 36.6), ('Lenovo', 23.2), ('oldboy', 21.2)]
#最后返回的是键值对，组成的列表
print('----------------------2')

def func621(items1):
    return items1[1] >20   #返回的是参数，键值对
li621 = filter(func621,shares.items())  #shares.items()的每一个元素都是键值对
print(list(li621)) #[('IBM', 36.6), ('Lenovo', 23.2), ('oldboy', 21.2)]
#最后返回的是键值对，组成的列表
print('----------------------2-2')
'''
分析过程1：
1 遍历循环字典.items()后，每一个元素都是键值对元组,而不是key，在这里--关键点
2 把每一个键值对元组依次作为参数items1传入
3 当字典的值items1[1]大于20的时候
4 将字典的items1(即参数)返回，而不是字典的key返回
5 最后返回的是满足条件的items1（键值对元组）组成的列表
'''

li63 = filter(lambda k:shares[k]>20,shares)
print(list(li63)) #['IBM', 'Lenovo', 'oldboy']
print('----------------------3')
'''
分析过程2：
1 遍历循环字典后，每一个元素都是key,而不是键值对，在这里--关键点
2 把每一个key依次作为参数k传入
3 当字典的值share[k]大于20的时候
4 将字典的k返回，而不是字典的键值对返回
5 最后返回的是满足条件的key组成的列表
'''

for i in shares:
    print(i)  #这个i是字典的key，而不是键值对
# IBM
# Lenovo
# oldboy
# ocean
print('----------------------3-1')

for i in shares.items():
    print(i)  #这个i是字典的key，而不是键值对
# ('IBM', 36.6)
# ('Lenovo', 23.2)
# ('oldboy', 21.2)
# ('ocean', 10.2)
print('----------------------3-2')

def func64(key):
    if shares[key]>20:
        return key   #返回的是字典的key，而不是字典的键值对
li64 = filter(func64,shares)
print(list(li64)) #['IBM', 'Lenovo', 'oldboy']
#最后返回的是满足条件的key组成的列表
print('----------------------4')

def func65(key):
    return shares[key]>20  #返回的是字典的key，而不是字典的键值对 关键点
li65 = filter(func65,shares)
print(list(li65)) #['IBM', 'Lenovo', 'oldboy']
print('----------------------5')

'''
小结：
filter函数+匿名函数，当iterable是字典的时候
it1 = filter(lambda k:dic1[k]>20,dic1)
print(list(it1))  #传入的参数是key，返回的就是key组成的列表

it2 = filter(lambda items1:items1[-1]>20,dic1.items())
print(list(it2))  #传入的参数是item（键值对元组），返回的就是键值对元组组成的列表

上述两个的区别
1 前者返回的是符合条件（字典的value-dic1[k]大于20）的字典key，组成的列表
    ['IBM', 'Lenovo', 'oldboy']
2 后者返回的是符合条件（字典的value-items[1]大于20）的字典的items（键值对元组），组成的列表
    [('IBM', 36.6), ('Lenovo', 23.2), ('oldboy', 21.2)]

'''

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