15 内置函数 匿名函数 sorted()排序函数 filter()筛选函数 map()映射函数 递归函数 二分法查找

主要内容:

1.　匿名函数lambda():  lambda表示的是匿名函数. 不需要用def来声明, ⼀句话就可以声明出一个函数.

　　a:  语法:lambda   参数:返回值     (不能完成复杂的操作.)

a = lambda n : n* n
print(a(5))              #结果25  一行搞定一个函数. 但是, 不能完成复杂的函数操作
print(a.__name__)        #查看函数的函数名

　　b.__name__可以查看函数的名(当函数名难用肉眼看到时)

def func(n):
    return n * n
print(func(3))
a = func
a(3)
print(a.__name__)    # 查看函数的函数名

2. 排序函数:sorted()

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

　　　　iterable:　可迭代对象

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

　　　　reverse:是否是倒叙,ture,倒叙;　　false:正序

lst = [2,4,23,1,4,57,89,34]
lst.sort()                      #升序
print(lst)
ll = sorted(lst,reverse=True)   #倒叙,.内置函数,返给你一个新列表,新列表是被排序的.
print(ll)

　　b,例题.根据字符串中a的个数进行排序

　　　　和函数组合使用

lst = ["大阳哥a", "尼古拉斯aa", "赵四aaa", "刘能a", "广坤aaaaaa", "谢大脚a"]
def func(s):
    return s.count('a')
ll = sorted(lst,key=func)    #将可迭代对象中的每一个元素传递给函数的参数,根据函数的运算结果进行排序
print(ll)

　　　　和lambda组合使用

lst = ["大阳哥a", "尼古拉斯aa", "赵四aaa", "刘能a", "广坤aaaaaa", "谢大脚a"]
ll = sorted(lst, key=lambda s:s.count('a'))
print(ll)

　　c,例题2:对年龄进行排序

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']> 30,reverse=True)       #不写reverse默认是升序,谢了reverse=ture是倒叙.
print(ll)

3. 筛选函数filter()

　　a:　语法:filter(function,  iterable)

　　　   第一个参数. 函数. 将第二个参数中的每一个元素传给函数. 函数如果返回True, 留下该元素.

　　b.　例题:筛选列表中的所有奇数

def func(i):
    return i % 2 == 1    #判断是奇数
lst = [1,2,3,4,5,6,7,8,9]
ll = filter(func, lst)
# print('__iter__'in dir(ll))    #ture
# print('__next__'in dir(ll))    #ture  说明返回值是迭代器.
print(list(ll))

　　　　结合lambal函数

lst = [1,2,33,4,5,6,7,89]
ll = filter(lambda i :i % 2 == 1,lst)
print(list(ll))         #[1, 33, 5, 7, 89]

　　c. 例题2,筛选列表年龄大于34的学生信息

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 = filter(lambda dic: dic['age']>34,lst)
print(list(ll))

　　　　结果:

[{'id': 2, 'name': 'taibai', 'age': 58}, {'id': 3, 'name': 'wusir', 'age': 38}, {'id': 4, 'name': 'ritian', 'age': 48}]

4.  映射函数:map()

　　a:语法:map(function,iterable)   把可迭代对象中的每一个元素传递给前面的函数进行处理. 处理的结果会返回成迭代器

　　b:例题1,计算列表中每个元素的平方,返回新列表.

lst = [1,2,3,4,3,3,45,34,2,4,24,90]
ll = map(lambda i : i * i,lst)  #把可迭代对象中的每一个元素传递给前面的函数进行处理. 处理的结果会返回成迭代器
print(list(ll))       #[1, 4, 9, 16, 9, 9, 2025, 1156, 4, 16, 576, 8100]

　　c:可以计算两个列表中相同位置的数据的和

lst1 = [1,3,5,7,9]
lst2 = [0,2,4,6,8]
ll = map(lambda x, y:x + y,lst1,lst2)   #lambda参数可以有多个,多个参数之间用,号隔开.
print(list(ll))

5.  递归

　　a:  在函数中调用函数本身,就是递归.

def func():
    print('haokun')
    func()
func()

　　b:  在python中递归的最大深度997,递归的的深度可以改变,但是不一定能达到你所设定的值.

def func(count):
    print('好困'+str(count))
    count = count + 1
    func(count)
func(1)

　　　　调整递归的深度

import sys
sys.setrecursionlimit(10000)    # 可以调整递归深度. 但是不一定能跑到这里
def func(count):
    print("我是谁,我在哪里"+str(count))
    func(count+1)
func(1)

　　c:  递归的应用:遍历树形结构

import  os
filePath = "d:\sylar\python_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)

6.  二分法查找:

　　有三种方法:纯算法,递归,切割

　　a:  纯算法:

lst = [1,3,5,7,9,11,13,15,16]
left = 0
right = len(lst) - 1
n = 13
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('找到了')
        print(middle)
        print("计算%s次" % count)
        break
    count = count + 1
else:
    print('不存在')

　　b:  递归

lst = [1,3,5,7,9,11,13,15,16]
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,13))

　　c:  切割

lst = [1,3,5,7,9,11,13,15,16]
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, 13)