python摸爬滚打之day14----内置函数,递归函数

1、匿名函数

　用一句话实现的简单函数.

　　ret = lambda x : x ** 2      即 函数名 = lambda 形参 : 返回值

　　print(ret(5))  ----> 25

2、sorted()  ----> 排序函数

　　sorted(iterable, key=func,reverse=False)

　　　　将可迭代对象的每一个元素传递给func, 然后根据func的返回值进行排序, reverse默认为False.

 lst = [ {'id':1,'name':'alex','age':28},
         {'id':2,'name':'taibai','age':58},
         {'id':3,'name':'taihei','age':18},
         {'id':4,'name':'henhei','age':38}]
 ret = sorted(lst,key=lambda x: x["age"])    #按年龄排序
 print(ret)

sorted()

　　max()  ----> 寻找最大值

　　max(iterable, key=func)

　　　　将可迭代对象的每一个元素传递给func, 根据lambda函数给出的规则进行寻找最大值.

 dic = [
     {"name":"小明","age":135},
     {"name":"芳华","age":216},
     {"name":"罗密欧","age":98},
     {"name":"韩梅梅","age":385},
     {"name":"朱丽叶","age":226},
 ]

 print(max(dic,key=lambda i:i["age"]))       # {'name': '韩梅梅', 'age': 385}

max()

3、filter()  ----> 筛选函数

　　filter(func,iterable)

　　　　将可迭代对象的每一个元素传递给func, 然后根据func的返回值对可迭代对象的元素进行处理, 筛选出返回值为True的元素, filter结果是一个filter对象(迭代器), 用list().

 lst = [ {'id':1,'name':'alex','age':28},
         {'id':2,'name':'taibai','age':58},
         {'id':3,'name':'taihei','age':18},
         {'id':4,'name':'henhei','age':38}]
 print(list(filter(lambda x: x["age"] > 20, lst)))   # 将年龄超过20岁的筛除

 # [{'id': 1, 'name': 'alex', 'age': 28},
 #  {'id': 2, 'name': 'taibai', 'age': 58},
 #  {'id': 4, 'name': 'henhei', 'age': 38}]

filter()

4、map()  ----> 映射函数

　　map(func, iterable)

　　　　将可迭代对象的每一个元素传递给func,  进行统一操作, 并返回一个新列表. map结果是一个map对象(迭代器), 用list().

 lst = [ {'id':1,'name':'alex','age':28},
         {'id':2,'name':'taibai','age':58},
         {'id':3,'name':'taihei','age':18},
         {'id':4,'name':'henhei','age':38}]
 print(list(map(lambda x: x["age"] - 5,lst)))    # 执行结果是一个新列表

 # [23, 53, 13, 33]

map()

5、reduce()  ----> 累积函数

　　import functools import reduce

　　reduce(func, iterable)

　　　　将可迭代对象的前后两个参数传给func, 进行函数操作, 然后将前后两个参数运算得到的结果作为第一个参数, 列表的后一个参数作为第二个参数, 继续往复func的操作, 得到的是一个具体的结果.

 print(reduce(lambda x,y: x + y,range(1,10),100))
 # 100作为起始值

 #

reduce()

6、递归

　　即 自身调用自身. 递归的最大递归深度为1000次, 但是永远达不到1000.

　　注意: 函数在函数体内部调用自身时, 也会创建一个新的名称空间, 递归次数越多, 则占据的空间内存就越大, 能不用递归就不用递归. 所以函数体内一定要有return 返回值, 不然拿到的结果为(None).

 def func(n):
     if n == 1:
         return 1
     return n * func(n - 1)     # 用递归实现阶乘

 print(func(10))

递归实现阶乘

 def ck_file(path,ceng):
     lst = os.listdir(path)
     for i in lst:
         file_path = os.path.join(path,i)
         if os.path.isdir(file_path):
             print("\t" * ceng,i,sep="")     # sep="" 当输入多个值进行打印时, 各个值之间的分隔方式.
             ck_file(file_path,ceng + 1)
         else:
             print("\t" * ceng,i,sep="")

 ck_file("F:/a",0)

递归实现文件夹的读取

7、用二分法实现查找某元素(重中之重)

　　优点 : 效率会非常高, 每次能够排除掉一半的数据.

　　缺点 : 前提是列表为有序列表.

　　一: 普通,非递归,非列表切片

 lst = [4, 56, 178, 253, 625, 1475, 2580, 3574, 15963]

 left = 0
 right = len(lst)-1
 inp = int(input("输入数字: "))
 while left <= right:
     mid = (left + right ) // 2
     if inp > lst[mid]:
         left = mid + 1
     elif inp < lst[mid]:
         right = mid - 1
     else:
         print("列表中有此数")
         break
 else:
     print("列表中没有此数")

非递归, 非列表切片

　　二: 递归, 非列表切片

 lst = [4, 56, 178, 253, 625, 1475, 2580, 3574, 15963]
 def ck(n,l,r,lst):
     if l > r:
         return False
     mid = (l + r) // 2
     if n > lst[mid]:
         l = mid+1
         return ck(n,l,r,lst)
     elif n < lst[mid]:
         r = mid-1
         return ck(n,l,r,lst)
     else:
         return True
 numb = int(input("输入数字: "))
 print(ck(numb,0,len(lst),lst))

递归, 非列表切片

　　三: 递归, 列表切片

 def func(lst,n):
     if not lst:
         return False
     left = 0
     right = len(lst)-1
     mid = (left + right) // 2
     if n > lst[mid]:
         lst = lst[mid + 1:]
         return func(lst,n)
     elif n < lst[mid]:
         lst = lst[ : mid]
         return func(lst, n)
     else:
         return True
 numb = int(input("输入数字: "))
 print(func(lst,numb))

递归, 列表切片