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.  li61 = filter(lambda x:x[-1]>20,shares.items())
  10.  print(list(li61))  #[('IBM', 36.6), ('Lenovo', 23.2), ('oldboy', 21.2)]
  11.  print('----------------------1')
  12.  
  13.  def func62(items1):
  14.      if items1[1] >20:
  15.          return items1   #返回的是参数，键值对
  16.  li62 = filter(func62,shares.items())  #shares.items()的每一个元素都是键值对
  17.  print(list(li62)) #[('IBM', 36.6), ('Lenovo', 23.2), ('oldboy', 21.2)]
  18.  #最后返回的是键值对，组成的列表
  19.  print('----------------------2')
  20.  
  21.  def func621(items1):
  22.      return items1[1] >20   #返回的是参数，键值对
  23.  li621 = filter(func621,shares.items())  #shares.items()的每一个元素都是键值对
  24.  print(list(li621)) #[('IBM', 36.6), ('Lenovo', 23.2), ('oldboy', 21.2)]
  25.  #最后返回的是键值对，组成的列表
  26.  print('----------------------2-2')
  27.  '''
  28.  分析过程1：
  29.  1 遍历循环字典.items()后，每一个元素都是键值对元组,而不是key，在这里--关键点
  30.  2 把每一个键值对元组依次作为参数items1传入
  31.  3 当字典的值items1[1]大于20的时候
  32.  4 将字典的items1(即参数)返回，而不是字典的key返回
  33.  5 最后返回的是满足条件的items1（键值对元组）组成的列表
  34.  '''
  35.  
  36.  li63 = filter(lambda k:shares[k]>20,shares)
  37.  print(list(li63)) #['IBM', 'Lenovo', 'oldboy']
  38.  print('----------------------3')
  39.  '''
  40.  分析过程2：
  41.  1 遍历循环字典后，每一个元素都是key,而不是键值对，在这里--关键点
  42.  2 把每一个key依次作为参数k传入
  43.  3 当字典的值share[k]大于20的时候
  44.  4 将字典的k返回，而不是字典的键值对返回
  45.  5 最后返回的是满足条件的key组成的列表
  46.  '''
  47.  
  48.  for i in shares:
  49.      print(i)  #这个i是字典的key，而不是键值对
  50.  # IBM
  51.  # Lenovo
  52.  # oldboy
  53.  # ocean
  54.  print('----------------------3-1')
  55.  
  56.  for i in shares.items():
  57.      print(i)  #这个i是字典的key，而不是键值对
  58.  # ('IBM', 36.6)
  59.  # ('Lenovo', 23.2)
  60.  # ('oldboy', 21.2)
  61.  # ('ocean', 10.2)
  62.  print('----------------------3-2')
  63.  
  64.  def func64(key):
  65.      if shares[key]>20:
  66.          return key   #返回的是字典的key，而不是字典的键值对
  67.  li64 = filter(func64,shares)
  68.  print(list(li64)) #['IBM', 'Lenovo', 'oldboy']
  69.  #最后返回的是满足条件的key组成的列表
  70.  print('----------------------4')
  71.  
  72.  def func65(key):
  73.      return shares[key]>20  #返回的是字典的key，而不是字典的键值对 关键点
  74.  li65 = filter(func65,shares)
  75.  print(list(li65)) #['IBM', 'Lenovo', 'oldboy']
  76.  print('----------------------5')
  77.  
  78.  '''
  79.  小结：
  80.  filter函数+匿名函数，当iterable是字典的时候
  81.  it1 = filter(lambda k:dic1[k]>20,dic1)
  82.  print(list(it1))  #传入的参数是key，返回的就是key组成的列表
  83.  
  84.  it2 = filter(lambda items1:items1[-1]>20,dic1.items())
  85.  print(list(it2))  #传入的参数是item（键值对元组），返回的就是键值对元组组成的列表
  86.  
  87.  上述两个的区别
  88.  1 前者返回的是符合条件（字典的value-dic1[k]大于20）的字典key，组成的列表
  89.      ['IBM', 'Lenovo', 'oldboy']
  90.  2 后者返回的是符合条件（字典的value-items[1]大于20）的字典的items（键值对元组），组成的列表
  91.      [('IBM', 36.6), ('Lenovo', 23.2), ('oldboy', 21.2)]
  92.  
  93.  '''
  1. # 7,有下面字典，得到购买每只股票的总价格，并放在一个迭代器中。
  2. # 结果：list一下[9110.0, 27161.0,......]
  3. portfolio = [
  4.   {'name': 'IBM', 'shares': 100, 'price': 91.1},
  5.     {'name': 'AAPL', 'shares': 50, 'price': 543.22},
  6.     {'name': 'FB', 'shares': 200, 'price': 21.09},
  7.     {'name': 'HPQ', 'shares': 35, 'price': 31.75},
  8.     {'name': 'YHOO', 'shares': 45, 'price': 16.35},
  9. {'name': 'ACME', 'shares': 75, 'price': 115.65}]
  10.  
  11. #方法1 普通函数
  12. def func1(dic1):
  13.     return dic1['shares'] * dic1['price']
  14.  
  15. # func1(portfolio)
  16. it1 = map(func1,portfolio)
  17. print(list(it1))  #[9110.0, 27161.0, 4218.0, 1111.25, 735.7500000000001, 8673.75]
  18. print('------------------1 map+普通函数')
  19. '''
  20. 分析过程：
  21. 1 portfolio是列表，列表的每一个元素是字典
  22. 2 把字典作为普通函数的参数，依次传入，将股票价格*股票数量=股票总价值 作为元素返回
  23. 3 最后得到股票总价值作为元素的列表
  24. 注意：map和filter不同的地方
  25. 1、map最后得到的是将普通函数（或者匿名函数）的返回值作为元素的列表
  26. 2、filter最后得到的是普通函数（或者匿名函数）的参数（参数经过了筛选，返回的是True）作为元素的列表
  27. '''
  28.  
  29. #方法2 匿名函数
  30. it2 = map(lambda dic1:dic1['shares'] * dic1['price'],portfolio)
  31. print(list(it2))
  32. #[9110.0, 27161.0, 4218.0, 1111.25, 735.7500000000001, 8673.75]
  33. print('------------------2 map+匿名函数')
  34.  
  35. '''
  36. 方法论小结：
  37. 当匿名函数一下子写不出来的时候，就需要先写出普通函数（写普通函数的过程就是在整理思路）
  38.    然后，将普通函数的参数和返回值，填入匿名函数即可，匿名函数就写出来了
  39. '''
  1. # 9,有下列三种数据类型
  2. #     l1 = [1,2,3,4,5,6]
  3. #     l2 = ['oldboy','alex','wusir','太白','日天']
  4. #     tu = ('**','***','****','*******')
  5. # 写代码，最终得到的是（每个元组第一个元素>2,第三个*至少是4个）
  6. #     [(3, 'wusir', '****'), (4, '太白', '*******')]这样的数据。
  7.  
  8. l1 = [1,2,3,4,5,6]
  9. l2 = ['oldboy','alex','wusir','太白','日天']
  10. tu = ('**','***','****','*******')
  11.  
  12. '''
  13. 思路
  14. 1、列表1和列表2和列表3的同位置元素，组成元组，元组作为新列表的元素
  15.     一一对应-map，  zip
  16. 2、且列表1的元素都大于2-filter
  17. 3、且列表3的元素至少是4个星-filter
  18.  
  19. 步骤：
  20. 1、先普通函数
  21. 2、后匿名函数
  22. '''
  23.  
  24. #1 3个列表的同位置元素组成的元组--zip
  25. print(list(zip(l1,l2)))
  26. #[(1, 'oldboy'), (2, 'alex'), (3, 'wusir'), (4, '太白'), (5, '日天')]
  27. li3 = list(zip(l1,l2,tu))  #zip支持3个参数
  28. print(li3)
  29. #[(1, 'oldboy', '**'), (2, 'alex', '***'), (3, 'wusir', '****'), (4, '太白', '*******')]
  30. print('------------------------------0 ')
  31.  
  32. #方法1 普通函数1
  33. def func4(tu1):
  34.     if tu1[0] > 2 and len(tu1[-1]) >=4: #条件判断
  35.         #元组的第一个元素大于2，元组的最后一个元素的长度大于等于4
  36.         return tu1
  37. it4 = filter(func4,li3) #这里列表的每一个元素都是一个元组
  38. #将列表的每一个元素作为参数，依次传递到普通函数，进过条件筛选后，返回符合条件的参数组成的迭代器
  39. li4 = list(it4) #迭代器转成列表
  40. print(li4) #[(3, 'wusir', '****'), (4, '太白', '*******')]
  41. print('------------------------------1 filter+普通函数1 ')
  42.  
  43. #方法2 普通函数2
  44. def func6(tu1):
  45.     return tu1[0] > 2 and len(tu1[-1]) >=4
  46.     #把上面方法1的条件，作为返回值（实际上，返回的是符合筛选条件的参数组成的迭代器）
  47. it6 = filter(func6,li3)
  48. li6 = list(it6) #迭代器转成列表
  49. print(li6) #[(3, 'wusir', '****'), (4, '太白', '*******')]
  50. print('------------------------------2 filter+普通函数2 ')
  51.  
  52. # 1-2、返回值--关键点
  53. #     filter最终返回的是普通函数（或者匿名函数）的参数（符合条件）组成的迭代器（可转成列表）
  54. #     map最后返回的是普通函数（或者匿名函数）的返回值组成的迭代器（可转成列表）
  55.  
  56. #方法3 匿名函数
  57. it5 = filter(lambda tu1:tu1[0] > 2 and len(tu1[-1]) >=4,li3)
  58. # 把上述方法2中 普通函数的参数和返回值 填入匿名函数的冒号前后
  59. li5 = list(it5) #迭代器转成列表
  60. print(li5) #[(3, 'wusir', '****'), (4, '太白', '*******')]
  61. print('------------------------------3 filter+匿名函数1 ')
  62.  
  63. '''
  64. 方法论小结：
  65. 1、用filter函数的时候，先写普通函数
  66.    函数内是if 条件判断 + return
  67. 2、将普通函数修改一下
  68.     函数内直接返回判断条件
  69.     return + 条件判断  形成普通函数2
  70. 3、将上述普通函数2的
  71.    参数和返回值  填入匿名函数
  72. 上述filter或者map先写普通函数，然后写匿名函数的方法就是：
  73. 1、不跳步骤
  74. 2、写普通函数的时候，就是在整理思路
  75.    思路明确了，匿名函数只需要翻译即可
  76.  
  77. 知识点小结：
  78. 01返回值--关键点1
  79.     filter最终返回的是普通函数（或者匿名函数）的参数（符合条件）组成的迭代器（可转成列表）
  80.         --filter对参数做了if条件筛选
  81.             可以return参数
  82.             也可以return筛选条件（if后的）
  83.     map最后返回的是普通函数（或者匿名函数）的返回值组成的迭代器（可转成列表）
  84.         --map对参数没有做if条件筛选，而是做了批量修改或者2个列表的同位置运算等
  85.  
  86. 02运行原理--关键点2
  87.     filter是把iterable中的每一个元素作为参数，依次传递到自定义函数（匿名函数），
  88.         返回值是普通函数的参数（符合条件的--即对参数进行了条件筛选）组成的迭代器（可转成列表）
  89.     map是把iterable中的每一个元素作为参数，依次传递给自定义函数（匿名函数），
  90.         返回值是普通函数（或者匿名函数）的返回值组成的迭代器（可转成列表）
  91.         map和filter的区别在于：
  92.           1、map没有对参数进行if条件筛选，返回参数组成的迭代器（可转成列表)
  93.           2、而是对参数进行了批量操作（比如：批量增加）
  94.             或者多个列表的同位置元素的相加等运算
  95.             返回的是返回值组成的迭代器（可转成列表）
  96.  
  97. 03zip函数
  98.     1、zip函数的参数可以是2个列表，也可以是2个以上列表（比如3个）
  99.     2、支持2个及2个以上列表的同位置元素组成元组，元组作为新列表的元素
  100. '''

Python【day 14-5】sorted filter map函数应用和练习的更多相关文章

  1. 小学生都能学会的python(<lamda匿名函数,sorted(),filter(),map(),递归函数>)

    小学生都能学会的python(<<lamda匿名函数,sorted(),filter(),map(),递归函数,二分法>> 1. lambda 匿名函数 lambda 参数: ...

  2. Python【day 14-4】sorted filter map+递归文件夹+二分法查找

    def func(x): #普通函数 return x*x ret1 = func(10) #匿名函数 f = lambda x:x*x # 匿名函数写法: 匿名函数名=lambda 参数:返回值 ' ...

  3. 内置函数 lambda sorted filter map 递归

    一 lambda 匿名函数 为了解决一些简单的需求而设计的一句话函数 # 计算 n 的 n次方 def func(n): return n**n print(func(10)) f = lambda ...

  4. 匿名函数 sorted() filter() map() 递归函数

    一. lambda() 匿名函数   说白了,从字面理解匿名函数就是看不见的函数,那么他的看不见表现在哪里呢? 其实就是在查询的时候他们的类型都是lambda的类型所以叫匿名,只要是用匿名函数写的大家 ...

  5. Python_Mix*匿名函数,sorted,filter,map,递归函数,二分法查找

    lambda匿名函数(函数名统一都叫lambda) 为了解决简单的需求而设计的一句话函数 语法: lambda 参数 返回值 n = lambda a,b: max(a,b) ret = n(9,4) ...

  6. python基础之lambda,sort,filter,map,递归函数的运用

    内容梗概:1. lamda 匿名函数2. sorted()3. filter()4. map()5. 递归函数 1.lambda 形式: lambda 参数:返回值 f = lambda x,y: x ...

  7. sorted&filter&map

    python里列表的sort和内置的sorted函数,都可以进行排序,列表的sort方法是在原有的列表上进行排序,sorted是会返回一个新的对象 persons = [ {'name': '小明', ...

  8. Day14--Python--函数二,lambda,sorted,filter,map,递归,二分法

    今日主要内容:1. lambda 匿名函数 lambda 参数: 返回值-------------------------------------def square(x): return x**2 ...

  9. Python高级特性: 函数编程 lambda, filter,map,reduce

    一.概述 Python是一门多范式的编程语言,它同时支持过程式.面向对象和函数式的编程范式.因此,在Python中提供了很多符合 函数式编程 风格的特性和工具. 以下是对 Python中的函数式编程 ...

随机推荐

  1. Googleplaystore数据分析

    本次所用到的数据分析工具:numpy.pandas.matplotlib.seaborn 一.分析目的 假如接下来需要开发一款APP,想了解开发什么类型的APP会更受欢迎,此次分析可以对下一步计划进行 ...

  2. win7怎么使用远程桌面连接（win10类似，同样适用）

     win7使用远程桌面比mac要简单多了,只需在桌面点击“开始”,找到并打开“附件”,点击“远程桌面连接”即可   mac使用远程桌面连接:https://www.cnblogs.com/tu-071 ...

  3. PHP 将某个http地址的远程图片下载到本地的某个目录

    代码: function getImage($url,$save_dir='',$filename='',$type=0){ if(trim($url)==''){ return array('fil ...

  4. 38条技巧优化PHP代码，来复习总结下吧

    1.如果一个方法能被静态,那就声明他为静态的,速度可提高1/4; 2.echo的效率高于print,因为echo没有返回值,print返回一个整型; 3.在循环之前设置循环的最大次数,而非在在循环中; ...

  5. Java题库——Chapter6 一维数组

    1)What is the representation of the third element in an array called a? 1) _______ A)a(3) B) a(2) C) ...

  6. 【xmind】 使用 Java 生成思维导图

    前言 在日常的工作与学习中,我们经常会使用思维导图这个工具,来把抽象而又无形的思考转换成有形并且具体的图像,是理清思路,梳理逻辑的一大神器. 准确的说,思维导图并不是一个具体的工具,而是一种方法.是道 ...

  7. audio标签以及audio对象

    一.audio标签 简单语法 <audio src="音频链接"></audio> 属性 属性 值 描述 autoplay 如果出现该属性,则音频在就绪后马 ...

  8. JAVAEE学期总结

         声明:除第一张思维导图为博主所制作,其他思维导图皆来自网络,若侵权,望告知,必删除.                                                      ...

  9. 【Gradle】自定义Android Gradle工程

    自定义Android Gradle工程 defaultConfig默认配置 defaultConfig是Android对象中的一个配置项,负责定义所有的默认配置.一个基本的defaultConfig配 ...

  10. xBIM 综合使用案例与 ASP.NET MVC 集成（一）

    XbimWebUI是一个Javascript库,可用于BIM模型的Web表示.它使用WebGL并且独立于任何第三方WebGL框架.查看器的数据格式为WexBIM.不能直接加载IFC文件. 一.将IFC ...