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.

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

sorted()

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

　　filter(func,iterable)

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

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

filter()

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

　　map(func, iterable)

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

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

map()

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

　　import functools import reduce

　　reduce(func, iterable)

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

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

reduce()

6、递归

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

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

1 def func(n):
2     if n == 1:
3         return 1
4     return n * func(n - 1)     # 用递归实现阶乘
5 
6 print(func(10))

递归实现阶乘

 

 1 def ck_file(path,ceng):
 2     lst = os.listdir(path)
 3     for i in lst:
 4         file_path = os.path.join(path,i)
 5         if os.path.isdir(file_path):
 6             print("\t" * ceng,i,sep="")     # sep="" 当输入多个值进行打印时, 各个值之间的分隔方式.
 7             ck_file(file_path,ceng + 1)
 8         else:
 9             print("\t" * ceng,i,sep="")
10 
11 ck_file("f:/a",0)

递归实现文件夹的读取

 

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

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

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

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

 1 lst = [4, 56, 178, 253, 625, 1475, 2580, 3574, 15963]
 2 
 3 left = 0
 4 right = len(lst)-1
 5 inp = int(input("输入数字: "))
 6 while left <= right:
 7     mid = (left + right ) // 2
 8     if inp > lst[mid]:
 9         left = mid + 1
10     elif inp < lst[mid]:
11         right = mid - 1
12     else:
13         print("列表中有此数")
14         break
15 else:
16     print("列表中没有此数")

非递归, 非列表切片

　　二: 递归, 非列表切片

 1 lst = [4, 56, 178, 253, 625, 1475, 2580, 3574, 15963]
 2 def ck(n,l,r,lst):
 3     if l > r:
 4         return false
 5     mid = (l + r) // 2
 6     if n > lst[mid]:
 7         l = mid+1
 8         return ck(n,l,r,lst)
 9     elif n < lst[mid]:
10         r = mid-1
11         return ck(n,l,r,lst)
12     else:
13         return true
14 numb = int(input("输入数字: "))
15 print(ck(numb,0,len(lst),lst))

递归, 非列表切片

　　三: 递归, 列表切片

 1 def func(lst,n):
 2     if not lst:
 3         return false
 4     left = 0
 5     right = len(lst)-1
 6     mid = (left + right) // 2
 7     if n > lst[mid]:
 8         lst = lst[mid + 1:]
 9         return func(lst,n)
10     elif n < lst[mid]:
11         lst = lst[ : mid]
12         return func(lst, n)
13     else:
14         return true
15 numb = int(input("输入数字: "))
16 print(func(lst,numb))

递归, 列表切片