zoukankan      html  css  js  c++  java
  • 匿名函数,映射函数。

      1. lambda 匿名函数
      语法:
        lambda 参数:返回值
          不能完成复杂的操作

     1 def func(n):
     2     return n * n
     3 
     4 print(func(3))
     5 a = func
     6 a(3)
     7 print(a.__name__)    # 查看函数的函数名
     8 # lambda 匿名函数
     9 # x 参数
    10 #  : 后面是函数体(直接return的内容)
    11 a = lambda x: x*x   # 一行搞定一个函数. 但是, 不能完成复杂的函数操作
    12 print(a)
    13 print(a(6))
    14 print(a.__name__)
    15 
    16 b = lambda x, y: x+y
    17 print(b(1,3))
    18 print(b.__name__)
    19 
    20 # 语法: 变量 = lambda 参数: 返回值

    2. sorted() 函数
      排序.
        1. 可迭代对象
        2. key=函数. 排序规则
        3. reverse. 是否倒序
        3. filter() 函数
      过滤
        1. 函数, 返回True或False
        2. 可迭代对象

    # lst = [5,7,6,12,1,13,9,18,5]
    # # lst.sort()  # sort是list里面的一个方法
    # # print(lst)
    #
    # ll = sorted(lst, reverse=True) # 内置函数. 返回给你一个新列表  新列表是被排序的
    # print(ll)
    
    
    # 给列表排序. 根据字符串的长度进行排序
    lst = ["大阳哥a", "尼古拉斯aa", "赵四aaa", "刘能a", "广坤aaaaaa", "谢大脚a"]
    #
    # def func(s):
    #     return s.count('a') #  返回数字
    #
    # ll = sorted(lst, key=lambda s:s.count('a')) # 内部. 把可迭代对象中的每一个元素传递给func
    # print(ll)
    #
    # lst = [
    #         {'id':1, 'name':'alex', 'age':18},
    #         {'id':2, 'name':'taibai', 'age':58},
    #         {'id':3, 'name':'wusir', 'age':38},
    #         {'id':4, 'name':'ritian', 'age':48},
    #         {'id':5, 'name':'女神', 'age':18}
    #        ]
    #
    # ll = sorted(lst, key=lambda dic:dic['age'], reverse=True)
    # print(ll)
    # def func(i):    # 判断奇数
    #     return i % 2 == 1
    lst = [1,2,3,4,5,6,7,8,9]
    
    ll = filter(lambda i:i%2==1, lst)
    #  第一个参数. 函数. 将第二个参数中的每一个元素传给函数. 函数如果返回True, 留下该元素.
    # print("__iter__" in dir(ll))
    # print("__next__" in dir(ll))
    # print(list(ll))
    
    # lst = [
    #         {'id':1, 'name':'alex', 'age':18},
    #         {'id':2, 'name':'taibai', 'age':58},
    #         {'id':3, 'name':'wusir', 'age':38},
    #         {'id':4, 'name':'ritian', 'age':48},
    #         {'id':5, 'name':'女神', 'age':18}
    #        ]
    #
    # print(list(filter(lambda dic: dic['age']>40, lst)))

    4. map() 映射函数
        1. 函数
        2. 可迭代对象
        5. 递归

    # lst = [1,2,3,4,5,6,7,8,9,0,23,23,4,52,35,234,234,234,234,234,23,4]
    # it = map(lambda i: i * i, lst) # 把可迭代对象中的每一个元素传递给前面的函数进行处理. 处理的结果会返回成迭代器
    # print(list(it))
    
    
    # lst1 = [ 1, 2, 3, 4, 5]
    # lst2 = [ 2, 4, 6, 8]
    # print(list(map(lambda x, y:x+y, lst1, lst2))) # 如果函数中有多个参数. 后面对应的列表要一一对应
    # import sys
    # sys.setrecursionlimit(10000)    # 可以调整递归深度. 但是不一定能跑到这里
    # def func(count):
    #     print("我是谁,我在哪里"+str(count))
    #     func(count+1)
    # func(1)
    
    # while 1:
    #     a = 10
    #     print("哈哈")
    
    # 遍历树形结构
    # import  os
    # filePath = "d:sylarpython_workspace"
    #
    # def read(filePath, n):
    #     it = os.listdir(filePath)   # 打开文件夹
    #     for el in it:
    #         #  拿到路径
    #         fp = os.path.join(filePath, el) # 获取到绝对路径
    #         if os.path.isdir(fp):   # 判断是否是文件夹
    #             print("	"*n,el)
    #             read(fp, n+1)    # 又是文件夹. 继续读取内部的内容 递归入口
    #         else:
    #             print("	"*n,el)    # 递归出口
    #
    # read(filePath, 0)

    自己调用自己.
        def func():
        func()
        func()
      难点:不好想.需要找规律. 不好读

    6. 二分法
      掐头结尾取中间. 不停的改变左和右. 间接改变中间. 查询效率非常高

    # lst = [11,22,33,44,55,66,77,88,99,123,234,345,456,567,678,789,1111]
    # n = 567
    # left = 0
    # right = len(lst) - 1
    # count = 1
    # while left <= right:
    #     middle = (left + right) // 2
    #     if n > lst[middle]:
    #         left = middle + 1
    #     elif n < lst[middle]:
    #         right = middle - 1
    #     else:
    #         print(count)
    #         print("存在")
    #         print(middle)
    #         break
    #     count = count + 1
    # else:
    #     print("不存在")
    lst = [11,22,33,44,55,66,77,88,99,123,234,345,456,567,678,789,1111]
    
    def binary_search(left, right, n):
        middle = (left + right)//2
        if left > right:
            return -1
        if n > lst[middle]:
            left = middle + 1
        elif n < lst[middle]:
            right = middle - 1
        else:
            return middle
        return binary_search(left, right, n)
    print(binary_search(0, len(lst)-1, 65) )
    
    
    def binary_search(lst, n):
        left = 0
        right = len(lst) - 1
        middle = (left + right) // 2
        if right <= 0:
            print("没找到")
            return
        if n > lst[middle]:
            lst = lst[middle+1:]
        elif n < lst[middle]:
            lst = lst[:middle]
        else:
            print("找到了")
            return
        binary_search(lst, n)
    binary_search(lst, 65)

     

  • 相关阅读:
    spring Boot 学习(四、Spring Boot与任务)
    spring Boot 学习(三、Spring Boot与检索)
    spring Boot 学习(二、Spring Boot与缓存)
    spring Boot 学习(一、Spring Boot与缓存)
    Java程序员必了解的JVM原理以及虚拟机的运行过程
    springcolud 的学习(四)服务治理. Eureka
    springcolud 的学习(二).SpringCloud微服务框架
    springcolud 的学习(二).微服务架构的介绍
    Oracle DECODE函数的用法详解
    C#读取excl(兼容office多种版本)
  • 原文地址:https://www.cnblogs.com/songhuasheng/p/9342467.html
Copyright © 2011-2022 走看看