您的位置:新葡亰496net > 奥门新萄京娱乐场 > 递归函数,递归与二分法

递归函数,递归与二分法

发布时间:2019-09-15 20:06编辑:奥门新萄京娱乐场浏览(89)

    1.lambda佚名函数

      为了化解一部分回顾的要求而规划的一句话函数

    1 #计算n的n次方
    2 def func(n):
    3     return n**n
    4 print(func(10))
    5 
    6 
    7 f = lambda n: n**n
    8 print(f(10))
    

    lambda表示的是无名氏函数,没有必要用def来声称,一句话就能够表明出一个函数

    语法:

      函数名= lambda 参数:返回值

    注意:

      1.函数的参数能够有多少个,七个参数之间用逗号隔离

      2.无名函数不管多复杂,只可以写一行,且逻辑甘休后直接再次回到数据

      3.重回值和常规的函数同样,能够是人忆数据类型

    无名氏函数却非说一定没盛名字,这里前边的变量正是八个函数名,说他是无名氏原因是大家经过__name__查看的时候是尚未名字的,统一都叫lambda,在调用的时候没有何样非常之处,像平常的函数调用就可以.

    python_day_15

    一. lamda无名函数

    参照他事他说加以考察资料:

    一.内置函数

    2.sorted()

    排序函数,回去一个新列表

    语法: sorted(iterable,key=None,reverse=False)

      iterable:可迭代对象

      key:排序准绳(排序函数),在sorted()内部会将可迭代对象中的每三个成分传递给那么些函数的参数,依照函数运算结果开展排序

      reverse:是还是不是是倒叙.True:倒叙,False:正序

    1 lst = [1,5,3,4,6]
    2 lst2 = sorted(lst)
    3 print(lst)        #原列表不会改变
    4 print(lst2)      #返回的新列表是经过排序的
    5 
    6 dic = {1:"A",3:"C",2:"B"}
    7 print(sorted(dic))    #如果是字典,则返回排序过后的key
    

    和函数组合使用:

    1 #根据字符串长度进行排序
    2 lst = ["麻花藤","冈本次郎","中央情报局","狐仙"]
    3 
    4 #计算字符串长度
    5 def func(s):
    6     return len(s)
    7 print(sorted(lst,key=func))
    

    和lambda组合使用:

     1 #根据字符串长度进行排序
     2 lst = ["麻花藤","冈本次郎","中央情报局","狐仙"]
     3 
     4 #计算字符串长度
     5 def func(s):
     6     return len(s)
     7 print(sorted(lst,key=lambda s:len(s)))
     8 
     9 lst = [{"id":1,"name":'alex',"age":18},
    10          {"id":2,"name":'wusir',"age":16} ,
    11          {"id":3,"name":'taibai',"age":17}]
    12 
    13 #按照年龄对学生信息进行排序
    14 print(sorted(lst,key=lambda e:e['age']))
    

    一.明天首要内容

      

    置于函数:

    什什么是放到函数?

    3.filter()

      筛选函数,重返一个迭代器

       语法:filter(function,iterable)

        function:用来筛选的函数.在filter中会自动的把iterable中的成分传递给function.然后基于function重返的True或然False来判定是还是不是保留此项数据

        iterable:可迭代对象

     1 lst = [1,2,3,4,5,6,7]
     2 l1 = filter(lambda x:x%2==0,lst)#筛选所有的偶数
     3 print(l1)
     4 print(list(l1))
     5 
     6 lst = [{"id":1,"name":'alex',"age":18},
     7          {"id":1,"name":'alex',"age":18},
     8          {"id":1,"name":'alex',"age":18}
     9 ]    
    10 fl = filter(ambda e:e['age']>16,lst)#筛选年龄大于16的数据
    11 print(list(fl))
    
    1. lambda 佚名函数
        语法:
        lambda 参数:返回值
        不可能到位复杂的操作

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

      1. map() 映射函数
          1. 函数
          2. 可迭代对象
          5. 递归
        协调调用自个儿.
        def func():
        func()
        func()
        难点:倒霉想.需求找规律. 不好读

      2. 二分法
        掐头结尾取中间. 不停的改观左和右. 直接改换中间. 查询成效非常高

      1. 为了化解一部分简短的供给而设计的一句话函数 

    作⽤域相关:

    哪怕python给你提供的. 拿来直接⽤用的函数,

    4.map()

    映射函数,回到八个迭代器

    语法:map(function,iterable)能够对可迭代对象的每一个要素举办映射,分别去施行function

      总结列表中每种成分的平方,重回新列表

    1 def func(e):
    2     return e*e
    3 mp = map(func,[1,2,3,4,5])
    4 print(mp)
    5 print(list(map))
    

    改写成lambda

    print(list(map(lambda x:x*x,[1,2,3,4,5])))
    

    总结多个列表中一模一样地点的数据的和

    1 lst1 = [1,2,3,4,5]
    2 lst2 = [2,4,6,8,10]
    3 print(list(map(lambda x,y:x y,lst1,lst2)))
    

     

            # 计算n的n次方
            def func(n):
                return n**n 
            print(func(10))
    
            f = lambda n: n**n 
            print(f(10))
    

    locals() 重返当前功能域中的名字

    比方print., input等等. 截⽌止 到python版本3.6.2 python⼀一共提供了了65个内置函数.

    5.递归

      在函数中调用函数本人,就是递归

    1 def func():
    2     print("我是谁")
    3     func()
    4 func()
    

    在python中递归的纵深最大到998

    1 def foo(n):
    2     print(n)
    3     n  = 1
    4     foo(n)
    5 foo(1)
    

    递归的运用:

      咱俩能够使用递回来遍历各类树形结构,比如大家的文书夹系统,能够应用递回来遍历该文件夹中的全部文件

      

     1 import os
     2 
     3 def read(filepath ,n):
     4     files = os.listdir(filepath)#获取到当前文件夹中的所有文件
     5     for fi in files:#遍历文件夹中的文件,这里获取的只是本层文件名
     6         fi_d = os.path.join(filepath,fi)#加入文件夹,获取到文件夹 文件
     7         if os.path.isdir(fi_d):#如果该路径下的文件是文件夹
     8             print("t"*n,fi)
     9             read(fi_d,n 1)#继续进行相同的操作
    10         else:
    11             print("t"*n,fi)#递归出口,最终在这里隐含着return
    12 
    13 #递归遍历目录下所有文件
    14 read("d:/",0)
    
    1. 前⽅⾼能-内置函数⼆

      lambda代表的是匿名函数. 无需用def来声称, 一句话就能够证明出一个函数

    globals() 重回全局成效域中的名字

    她们就是python直接提须求我们的.

    6.二分查找

      二分查找每一遍能够清除掉50%的数额,查找的频率相当高,但是局限性非常大,必需是稳步连串才得以行使二分查找

      需求:查找的队列必得是上行下效体系

     1 #判断n是否在lst中出现,如果出现请返回n所在的位置
     2 #二分查找-----非递归算法
     3 lst = [22,33,44,55,66,77,88,99,101,238,345,456,567,678,789]
     4 n = 567
     5 left = 0
     6 right = len(lst)-1
     7 count = 1
     8 while left <= right:
     9     middle = (left   right) // 2
    10     if n < lst[middle]:
    11         right = middle - 1
    12     elif n > lst[iddle]:
    13         left = middle   1
    14     else:
    15         print(count)
    16         print(middle)
    17         break
    18     count  = 1
    19 else:
    20     print("不存在")
    

    #一般而言递归版本二分法

      每趟右边加1,左侧减1

     1 def func(n,left,right):
     2     if left <= right:
     3         middle = (left   right) // 2
     4         if n < let[middle]:
     5             right = middle -1
     6         elif n > lst[middle]:
     7             left = middle   1
     8         else:
     9             return middle
    10         return func(n,left,right)#这个return必须要加,不然接收到的永远是None
    11     else:
    12         return -1
    13 print(func(567,0,len(lst)-1))
    

    #另类二分法,很难总计地点

      每回从左侧到中路照旧从中路到左手分

     1 def func(lst,target):
     2     left = 0
     3     right = len(lst)-1
     4     if left > right:
     5         print("不在这里")
     6     middle = (left   right) // 2
     7     if target < lst[middle]:
     8         return func(lst[:middle],target)
     9     elif target > lst[middle]:
    10         return func(lst[middle :],target)
    11     else:
    12         print("在这里")
    13 func(lst,567)
    

     

    本节首要内容:

      语法:

    迭代器相关:

    置于函数图

      1. lamda无名函数
      1. sorted()
      1. filter()
      1. map()
      1. 递归函数

         函数名 = lambda 参数: 返回值 

    range() ⽣成数据

    二.无名氏函数

    ⼀. lamda无名函数 为了消除⼀些轻便的急需⽽设计的⼀句话函数

      注意: 1. 函数能够有三个参数,他们参数之间用逗号隔离

    next() 迭代器向下执⾏ ⼀次, 内部实际使用了__next__()⽅法再次回到迭代器的下四个类别

    lamda匿匿名函数 为了了消除⼀一些轻便易行的须要⽽而设计的⼀一句句话函数

    def func(n):
        return n * n
    
    print(func(3))
    a = func
    a(3)
    print(a.__name__)    # 查看函数的函数名
    # lambda 匿名函数
    # x 参数
    #  : 后面是函数体(直接return的内容)
    a = lambda x: x*x   # 一行搞定一个函数. 但是, 不能完成复杂的函数操作
    print(a)
    print(a(6))
    print(a.__name__)
    
    b = lambda x, y: x y
    print(b(1,3))
    print(b.__name__)
    
    # 语法: 变量 = lambda 参数: 返回值
    

          2. 无名氏函数不管多复杂. 只好写一行, 且逻辑甘休后直接再次回到数据

    iter() 获取迭代器, 内部实际应用的是__iter__()方法来赢得迭代器

    语法: 函数名 = lambda 参数: 返回值

    注意:

          3. 重返值和正规的函数同样, 能够是轻便数据类型

    字符串类型代码的执行

     1 # 计算n的n次⽅方  2 def func:     3     return n**n  4 print(func(10)) 5  6  7 f = lambda n: n**n print(f(10))  8 print或者 9 for i in f10     pirnt
    
      1. 函数的参数能够有八个. 多少个参数之间⽤逗号隔开
      1. 无名氏函数不管多复杂. 只好写⼀⾏, 且逻辑甘休后一向回到数据
      1. 重临值和常规的函数⼀样, 能够是不管三七二十一数据类型

      

    eval() 执行字符串类型的代码. 并再次来到最后结果

    注意:

    无名函数而不是说⼀定没闻明字. 那⾥前⾯的变量就是⼀个函数名. 说她是无名原因是大家通 过__name__翻看的时候是没盛名字的. 统⼀都叫lambda. 在调⽤的时候从不什么特别之处. 像正规的函数调⽤就可以

      2. 匿名函数并不是说一定没有名字. 那里前面包车型客车变量正是一个函数名. 说她是佚名原因

    exec() 执行字符串类型的代码

    1. 函数的参数能够有多少个. 多个参数之间⽤用逗号隔开分离

    2. 匿匿名函数不管多复杂. 只可以写⼀一⾏行行, 且逻辑截至后一贯重返数据

    3. 重返值和健康的函数⼀一样, 能够是随意数据类型

    ⼆. sorted() 排序函数.

          是我们经过__name__翻看的时候是从未有过名字的. 统一都叫lambda. 在调用的时候从不

    compile() 将字符串类型的代码变异. 代码对象能够通过exec语句句来执行可能eval()进行求 值

    匿匿名函数并非说⼀一定没盛名字. 那⾥里里前⾯面的变量量正是⼀一个函数名. 说她是匿匿名原因是大家通 过__name__翻开的时候是不曾名字的. 统⼀一都叫lambda. 在调⽤用的时候从不什什么非常之处. 像不奇怪的函数调⽤用就能够

    语法: sorted(Iterable, key=None, reverse=False)

          什么极度之处.像正常的函数调用就能够

    有再次回到值的字符串格局的代码用eval(). 未有重回值的字符串格局的代码用exec(). 一般相当少用 到compile()

    三.排序函数 sorted() 让本身定义排序的条条框框

    Iterable: 可迭代对象 key: 排序准绳(排序函数), 在sorted内部会将可迭代对象中的每⼀个要素传递给这几个函 数的参数. 根据函数运算的结果进⾏排序

     

    输入和出口相关:

    语法: sorted(Iterable, key=None, reverse=False)

    reverse: 是或不是是倒叙. True: 倒叙, False: 正序

    二. sorted()    排序函数. 

    input() 获取客户输入的内容

    Iterable: 可迭代对象

    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)
    

      1. 语法: sorted(Iterable, key=None, reverse=False) 

    print() 打字与印刷输出 内部存储器相关:

    key: 排序准绳, 在sorted内部会将可迭代对象中的每⼀贰个成分传递给那几个函 数的参数. 依照函数运算的结果进⾏行行排序

    三. filter() 筛选函数

        Iterable: 可迭代对象

    hash() 获取到对象的哈希值(int, str, bool, tuple)

    reverse: 是或不是是倒叙. True: 倒叙, False: 正序

    语法: filter(function. Iterable)

        key: 排序准绳(排序函数), 在sorted内部会将可迭代对象中的每一种成分传递

    id() 获取到目的的内部存款和储蓄器地址

    1 lst = [11, 5, 36, 1, 27, 58]2 3 s = sorted  # 默认从小到大排序4 print
    
     1 lst = ["胡一菲", "张伟", "关谷神奇", "曾小贤吕小布", "诺澜"] 2 def func: 3     return len  # 返回长度 4  5 # 执行流程: 6 # 把可迭代对象中的每一项拿出来, 作为参数传递给后面key函数. 7 # 函数返回数字, 根据数字进行排序 8 g = sorted(lst, key=func) 9 g = sorted(lst, key=lambda s: len10 print
    

    function: ⽤来筛选的函数. 在filter中会⾃动的把iterable中的成分传递给function. 然后 依据function重返的True或许False来剖断是不是保留此项数据

          给这一个函 数的参数. 依据函数运算的结果进行排序
        reverse: 是或不是是倒叙. True: 倒叙, False: 正序

    文本操作相关:

    四.筛选函数 filter()

    Iterable: 可迭代对象

            lst = [1,5,3,4,6] 
            lst2 = sorted(lst) 
            print(lst)  # 原列表不会改变 
            print(lst2) # 返回的新列表是经过排序的 
    
    
            dic = {1:'A', 3:'C', 2:'B'} 
            print(sorted(dic))  # 如果是字典. 则返回排序过后的key    
    

    open() 用于口开垦⼀二个文件, 创制一个文书句柄

    语法: filter(function. Iterable)

    lst = [1,2,3,4,5,6,7,8,9]
    
    ll = filter(lambda i:i%2==1, lst)
    #  第一个参数. 函数. 将第二个参数中的每一个元素传给函数. 函数如果返回True, 留下该元素.
    

     

    模块相关:

    function: ⽤用来筛选的函数. 在filter中会⾃自动的把iterable中的成分传递给function. 然后 依据function重回的True只怕False来决断是不是保留留此项数据

    四. map() 映射函数

       2.

    __import__() 用于动态加载类和函数

    Iterable: 可迭代对象

    语法: map(function, iterable)

       和函数组合使用

    赞助: help() 函数用于查看函数或模块用途的详细表明

    1 lst = ['张无忌', '张翠山', '范冰冰', '金毛狮王', '李冰冰']2 3 # 过滤掉姓张的人4 # 把可迭代对象打开 . 把内部元素一个一个的传递给前面的函数. 由这个函数决定此项是否保留5 f = filter(lambda name: not name.startswith('张'), lst)6 7 print('__iter__'in dir  # 可迭代对象8 for el in f:9     print
    

    能够对可迭代对象中的每⼀个成分进⾏映射. 分别取执⾏ function 计算列表中每种成分的平⽅ ,再次回到新列表

            # 根据字符串长度进行排序 
            lst = ["麻花藤", "冈本次郎", "中央情报局", "狐仙"] 
    
            # 计算字符串长度 
            def func(s):
                return len(s) 
            print(sorted(lst, key=func)
    

    调用相关:

    五.映射函数map()

    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))
    

       和lambda组合使用

    callable() 用于检查八个指标是还是不是是可调用的. 假诺回去True, object有不小大概调用战败, 但 要是回到False. 那调用相对不会成功

    语法: map(function, iterable) 能够对可迭代对象中的每⼀贰个成分进⾏行行映射. 分别取执⾏行行 function

    五. 递归 在函数中调⽤函数本⾝. 便是递归,在python中递归的深浅最⼤到997.

            # 根据字符串长度进行排序 
            lst = ["麻花藤", "冈本次郎", "中央情报局", "狐仙"] 
            # 计算字符串长度 
            def func(s):
                return len(s) 
            print(sorted(lst, key=lambda s: len(s)))
    
    
            lst = [{"id":1, "name":'alex', "age":18},
                   {"id":2, "name":'wusir', "age":16},
                   {"id":3, "name":'taibai', "age":17}] 
            # 按照年龄对学生信息进行排序 
            print(sorted(lst, key=lambda e: e['age']))
    

    查阅内置属性:

    1 lst = ['篮球球', '打打台球', '爬荒山', '步']2 g = map(lambda s:'爱好:'  s,lst)3 print
    
    import sys
    sys.setrecursionlimit(10000)    # 可以调整递归深度. 但是不一定能跑到这里
    def func(count):
        print("我是谁,我在哪里" str(count))
        func(count 1)
    func(1)
    
    while 1:
        a = 10
        print("哈哈")
    

     

    dir() 查看对象的停放属性, 方法. 访问的是目的中的__dir__()⽅方法 基础数据类型相关:

    递归的应⽤: 大家得以使⽤递归来遍历各样树形结构, 比方大家的⽂件夹系统. 能够使⽤递归来遍历该 ⽂件夹中的全体⽂件

     

    数字相关:

    # 遍历树形结构
    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("t"*n,el)
                read(fp, n 1)    # 又是文件夹. 继续读取内部的内容 递归入口
            else:
                print("t"*n,el)    # 递归出口
    
    read(filePath, 0)
    

    三. filter()    筛选函数 

    bool() 将给定的数码转变到bool值. 即使不给值. 再次来到False

    六. ⼆分查找

     

    int() 将给定的多寡转变来int值. 要是不给值, 重临0

    ⼆分查找. 每便能够化解掉⼀半的数据. 查找的频率特别⾼. 不过局限性比较⼤. 必得是有 序类别才方可使⽤⼆分查找 供给: 查找的行列必需是有序种类.

        1. 语法: filter(function. Iterable)

    float() 将给定的数目转变来float值. 约等于⼩小数

    1)二分法,非递归版

             function: 用来筛选的函数. 在filter中会自动的把iterable中的成分传递给function.

    complex() 成立三个复数. 第一个参数为实部, 第三个参数为虚部. 也许第二个参数直接 用字符串来汇报复数

    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("不存在")
    

        然后 依照function重回的True或许False来判定是或不是保留此项数据

    进制转变:

    2)普通递归版

             Iterable: 可迭代对象

    bin() 将给的参数调换到二进制

    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) )
    
            lst = [1,2,3,4,5,6,7] 
            ll = filter(lambda x: x%2==0, lst)    # 筛选所有的偶数 
            print(ll)
            print(list(ll)) 
    
    
            lst = [{"id":1, "name":'alex', "age":18},
                   {"id":2, "name":'wusir', "age":16},
                   {"id":3, "name":'taibai', "age":17}] 
            fl = filter(lambda e: e['age'] > 16, lst)   # 筛选年龄大于16的数据 
            print(list(fl))
    

    otc() 将给的参数转变来八进制

    3)另类二分法,很难总计地方.

     

    hex() 将给的参数调换到十六进制

    lst = [11,22,33,44,55,66,77,88,99,123,234,345,456,567,678,789,1111]
    
    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)
    

     

    数学生运动算:

    参考:

    四. map()    映射函数

    abs() 再次回到相对值

    https://www.processon.com/view/link/5b71818ce4b0555b39e10414

     

    divmode() 重临商和余数


      1.  语法: map(function, iterable) 能够对可迭代对象中的每一个要素进行映射.分别取执行     function

    round() 四舍五入

     

       2. 计量列表中每种元素的平方 ,重回新列表 

    pow 求a的b次幂, 借使有几个参数. 则求完次幂后对第八个数取余

     

            def func(e):
                return e*e 
    
    
            mp = map(func, [1, 2, 3, 4, 5]) 
            print(mp) 
            print(list(mp)) 
    

    sum() 求和

    作业: 

     

    min() 求最小值

    4,用map来处理字符串列表,把列表中所有人都变成sb,比方alex_sb
    
    name = ['oldboy','alex','wusir']
    a = map(lambda i:i "_sb",name)
    print(list(a))
    
    5,用map来处理下述l,然后用list得到一个新的列表,列表中每个人的名字都是sb结尾
    
    l=[{'name':'alex'},{'name':'y'}]
    a = map(lambda dic:dic['name']   'sb',l)
    print(list(a))
    
    6,用filter来处理,得到股票价格大于20的股票名字
    
    shares={
           'IBM':36.6,
           'Lenovo':23.2,
          'oldboy':21.2,
        'ocean':10.2,
        }
    
    a = filter(lambda i:shares[i]>20,shares)
    print(list(a))
    
    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}
    ]
    
    a = map(lambda i:i['shares']*i["price"],portfolio)
    print(list(a))
    
    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}
    ]
    
    a = filter(lambda i:i['price']>100,portfolio)
    print(list(a))
    
    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 = ('**','***','****','*******')
    
    a = list(filter(lambda a:a[0]>2 and len(a[2])>=4,zip(l1,l2,tu)))
    print(a)
    
    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}]
    
    a = sorted(l1,key=lambda dic:dic['sales_volumn'])
    print(a)
    

      改写成lambda

    max() 求最大值


        print(list(map(lambda x: x * x, [1, 2, 3, 4, 5])))
    

    和数据结构相关:

     

     

    列列表和元组:

    2018-07-20  15:26:04

      3. 估测计算多个列表中一样地方的数量的和 

    list() 将三个可迭代对象转变到列列表

            # 计算两个列表相同位置的数据的和 
            lst1 = [1, 2, 3, 4, 5] 
            lst2 = [2, 4, 6, 8, 10] 
            print(list(map(lambda x, y: x y, lst1, lst2))) 
    

    tuple() 将四个可迭代对象调换来元组

     

    reversed() 将一个种类列翻转, 重临翻转类别列的迭代器

     

    slice() 列表的切成块

    五. 递归

    字符串相关:

      1. 在函数中调用函数本人.便是递归 

    str() 将数据转载成字符串

            def func():
                print("我是谁")
                func() 
            func()
    

    format() 与实际数额相关, 用于计算各类小数, 精算等

     

    bytes() 把字符串转化成bytes类型

         在python中递归的深度最大到998

    bytearray() 重返三个新字节数组. 那一个数字里的要素是可变的, 而且每一个成分的值得范 围是[0,256)

            def foo(n):
                print(n)
                n  = 1
                foo(n) 
            foo(1)
    

    memoryview() 查看bytes在内部存款和储蓄器中的景况

     

    ord() 输入字符找带字符编码的岗位

      2. 递归的施用: 大家得以行使递回来遍历各样树形结构, 比方大家的文本夹系统. 能够动用

    chr() 输入地方数字搜索相应的字符

          递归来遍历该文件夹中的全部文件.

    ascii() 是ascii码中的重临该值 不是就回到u...

            import os
            wenjianjia='d:py'
            def read(wenjianjia,n):
                files=os.listdir(wenjianjia)#查看py文件夹下的文件
                for i in files: #迭代出各文件,i为文件名不是路径
                    if os.path.isdir(os.path.join(wenjianjia,i)):    #判断是否为文件夹
                        read(os.path.join(wenjianjia,i),n 1)        #如果是文件夹,递归再循环.地柜进口
                    else:
                        print('t'*n,i)         #递归出口
            read(wenjianjia,0)
    

    repr() 再次回到贰个对象的合法表示情势

     

    数量集结:

     

    dict() 创制三个字典

    六.  二分查找

    set() 成立二个集结

      1.  二分查找. 每趟能够消除掉四分之二的数据.  查找的频率相当高. 不过局限性十分的大. 必得是有系列才方可

    frozenset() 创立三个冷冻的会集. 冻结的集结无法进行增多和删除操作

       使用二分查找 

    其它有关:

     

    len() 再次来到二个对象中的成分的个数

            # 判断n是否在lst中出现. 如果出现请返回n所在的位置 
    
            # 二分查找---非递归算法 
            lst = [22, 33, 44, 55, 66, 77, 88, 99, 101, 238, 345, 456, 567, 678, 789] 
            n = 567 
            left = 0 
            right = len(lst) - 1 
            count = 1 
            while left <= right:
                middle = (left   right) // 2
                if n < lst[middle]:
                    right = middle - 1
                elif n > lst[middle]:
                    left = middle   1
                else:
                    print(count)
                    print(middle)
                    break
                count = count   1 
            else:
                print("不存在")
    
    
            # 普通递归版本 二分法 
            def binary_search(n, left, right):
                if left <= right:
                    middle = (left right) // 2
                    if n < lst[middle]:
                        right = middle - 1
                    elif n > lst[middle]:
                        left = middle   1
                    else:
                        return middle
                    return binary_search(n, left, right)# 这个return必须要加. 否则接收到的永远是None.如果第一遍没有找到则需要再次执行函数.
                else:
                    return -1 
            print(binary_search(567, 0, len(lst)-1))
    
    
            # 另类二分法, 很难计算位置. 
            def binary_search(ls, target):
                left = 0
                right = len(ls) - 1
                if left > right:
                    print("不在这里")
                middle = (left   right) // 2
                if target < ls[middle]:
                    return binary_search(ls[:middle], target)
                elif target > ls[middle]:
                    return binary_search(ls[middle 1:], target)
                else:
                    print("在这里") 
            binary_search(lst, 567)    
    

    sorted() 对可迭代对象进行排序操作

      注意:查找的体系必需是有序体系. 

    enumerate() 获取集合的枚举对象

     

    all() 可迭代对象中任何是True, 结果才是True

    any() 可迭代对象中有三个是True, 结果正是True

    zip() 函数用于将可迭代的指标作为参数, 将对象中对应的成分打包成五个个元组, 然 后再次来到由这个元组成的开了表. 假诺各个迭代器的要素个数区别, 则重临列表长度与最短的靶子同样.

    filter() 过滤

    map() 会依照提供的函数对点名类别列做映射

    ⼀. lamda无名函数.

    lambda代表的是无名氏函数. 无需用def来声称, 一句话就能够注解出三个函数

    语法: 函数名 = lambda 参数: 返回值

    瞩目: 1. 函数的参数能够有八个. 几个参数之间用逗号隔开分离

    1. 无名函数不管多复杂. 只好写一行, 且逻辑截至后一直回到数据

    2. 重返值和例行的函数同样, 能够是私行数据类型
      无名函数实际不是说分明没著名字. 那里后面包车型大巴变量就是二个函数名. 说他是无名氏原因是大家通 过__递归函数,递归与二分法。name__翻看的时候是绝非名字的. 统一都叫lambda. 在调用的时候未有怎么极其之处. 像经常的函数调用就可以

    ⼆. sorted()

    排序函数.

    语法: sorted(Iterable, key=None, reverse=False)

    Iterable: 可迭代对象

    key: 排序准则, 在sorted内部会将可迭代对象中的每八个因素传递给这几个函 数的参数. 根据函数运算的结果进行排序

    reverse: 是或不是是倒叙. True: 倒叙, False: 正序

    三. filter()

    筛选函数 语法: filter(function. Iterable)

    function: 用来筛选的函数. 在filter中会自动的把iterable中的元素传递给function. 然后 依照function重临的True恐怕False来决断是或不是保留此项数据

    Iterable: 可迭代对象

    四. map() 映射函数

    语法: map(function, iterable) 能够对可迭代对象中的每贰个要素进行映射. 分别取执行 function

    测算列表中每一个成分的平方 ,重回新列表

    五. 递归 在函数中调用函数本人. 正是递归

    在python中递归的深度最大到998

    递归的接纳: 大家得以使用递回来遍历各样树形结构, 比如我们的文书夹系统. 能够应用递回来遍历该 文件夹中的全体文件

     1 import os  2 def read(filepath, n):     3     files = os.listdir    # 获取到当前文件夹中的所有文件     4     for fi in files:    # 遍历文件夹中的文件, 这里获取的只是本层文件名                     5          fi_d = os.path.join(filepath,fi)  # 加入文件夹 获取到文件夹 文件        6          if os.path.isdir: # 如果该路径下的文件是⽂文件夹            7              print("t"*n, fi)            8              read(fi_d, n 1)     # 继续进行相同的操作         9         else:            10         print("t"*n, fi)   # 递归出口. 最终在这里隐含着return11 #递归遍历⽬目录下所有文件12  read('../old/', 0)       
    

    六. 二分查找

    二分查找. 每一趟能够化解掉四分之二的数据. 查找的频率非常高. 然而局限性非常大. 必得是有 序列才得以使⽤二分查找 需求: 查找的序列必得是板上钉钉列.

    本文由新葡亰496net发布于奥门新萄京娱乐场,转载请注明出处:递归函数,递归与二分法

    关键词: