内涵函数二

 

一 lambda 匿名函数(一句话函数)

1 匿名函数的语法:    lambda 参数: 返回值

2 lambda表示的是匿名函数,不需要用def 来声明,一句话就可以声明出一个函数

注意: 1 函数的参数可以有多个,多个参数之间用逗号隔开

         2 匿名函数不管多复杂 只能写一行,且逻辑结束后直接返回数据

        3 返回值和正常的函数一样,可以是任意的类型

3 匿名函数并不是没有名字 ,原因是通过__name__查看的时候是没有名字的,统一都叫lambda

1 def func(n):
2      return n*n    求9的平方
3 ret=func(9)
4 print(ret)
5 
6 结果:81
普通函数求平方

 

1 a=lambda x,y:1,2      因为1,2没有拿括号括起来 所以前面lambda x,y:1 被看作一部分
2 print(a)
3 
4 结果:(<function <lambda> at 0x000001AA9C241E18>, 2)
匿名函数中的面试笔试题

 

1 a=lambda n:n*n
2 ret=a(9)
3 print(ret)
4 
5 结果:81
匿名函数
1 print(func.__name__)  查看函数的名字
2 
3 print(a.__name__)   __name__的值都是<lambda>   所有的匿名函数中的变量的__name__值都统一是lambda
查看函数的名字
1 fn=lambda *args:max(args)
2 print(fn(12,3,4,6,7,88))
3 
4 
5 结果:88
比较两数的大小,返回最大值


 

二 sorted()排序函数

1 排序函数的语法:  sorted(iterable,key,reverse)

    iterable:可迭代对象

    key:排序规则(排序函数),把可迭代对象中的每一个元素教给后面的key函数来执行.得到一个数字(权重),通过这个数字来进行排序

    reverse:是否是倒叙,True:倒叙,False:正序

1 lst=[1,4,66,77,33,25,56]
2 lst.sort()     lst中的方法
3 print(lst)
4 
5 结果:[1,4,25,33,56,66,77]
list中的排序方法
1 lst = ["聊斋", "西游记", "三国演义", "葫芦娃", "水浒传", "年轮", "亮剑"]
2 def func(s):
3      return len(s)
4 
5 l=sorted(lst,key=func)
6 print(l)
7 
8 
9 结果:['聊斋', '年轮', '亮剑', '西游记', '葫芦娃', '水浒传', '三国演义']
排序
 1 lst = [
 2     {'name':"汪峰","age":48},
 3     {"name":"章子怡",'age':38},
 4     {"name":"alex","age":39},
 5     {"name":"wusir","age":32},
 6     {"name":"赵一宁","age":28}
 7     ]
 8 
 9 ll=sorted(lst,key=lambda el:len(el['name'],reverse=True) 按姓名长度从长到短来排序 ,最长的在前面
10 print(ll)
11 
12 
13 结果:
14 [{'name': 'wusir', 'age': 32}, {'name': 'alex', 'age': 39}, {'name': '章子怡', 'age': 38}, {'name': '赵一宁', 'age': 28}, {'name': '汪峰', 'age': 48}]
字典中姓名按长度来排序

 

三 filter()过滤函数

1 过滤函数的语法:filter(function,iterable)

    function:用来筛选的函数,把可迭代对象中的每一个元素交给前面的函数进行筛选,函数返回True或者False

   iterable:可迭代对象

 

 1 lst = ["张无忌", "张铁林", "赵一宁", "石可心","马大帅"]   取不是姓张的
 2 s=[]
 3 def func(lst):
 4       if el[0]=='张':
 5           pass
 6       else:
 7           s.append(el)
 8 func(lst)
 9 print(s)
10 
11 
12 结果:['赵一宁', '石可心', '马大帅']
按姓进行筛选(用普通函数)

 

 1 lst = ["张无忌", "张铁林", "赵一宁", "石可心","马大帅"]
 2 f=filter(lambda el:el[0]!=张,lst)   
 3 print(f)                  获取到的是地址:    <filter object at 0x000002A7DE1295F8>
 4 
 5 print("__iter__"in dir(f))    判断是否可以进行可迭代
 6 
 7 for e in f:
 8      print(e)
 9 
10 
11 
12 结果:
13 赵一宁
14 石可心
15 马大帅
按姓进行筛选

 

 1 lst = [
 2 #     {"name":"汪峰", "score":48},
 3 #     {"name":"章子怡", "score":39},
 4 #     {"name":"赵一宁","score":97},
 5 #     {"name":"石可心","score":90}
 6 # ]
 7 
 8 f=filter (lambda el: el['score']<60,lst)    小于60分的
 9 print(list(f))         把过滤掉的放到list列表中  因为list中是可迭代对象 里面有__iter__
10 
11 结果:[{'name': '汪峰', 'score': 48}, {'name': '章子怡', 'score': 39}]
字典中过滤

 

 

四 map()映射函数

1 映射函数的语法:map(function,iterable)

2 把可迭代对象中的数据交给前面的函数进行执行,返回值就是map的处理结果

1 # lst = [1,4,7,2,5,8]
2 ll=[]
3 for i in lst:
4     ll.append(i**2)
5 print(ll)
6 
7 
8 结果:[1, 16, 49, 4, 25, 64]
普通for算法 计算列表中每个数字的平方
1 lst = [1,4,7,2,5,8]
2 m=map(lambda el:el**2,lst)
3 print(list(m)
4 
5 
6 结果:[1, 16, 49, 4, 25, 64]
7 
8 
9 print("__iter__" in dir(m))   判断是否可迭代
映射函数中的算列表中每个数字的平方

分而治之:map(fun1,map(fun2,map(func3,lst)))

1 lst1 = [1, 3, 5, 7,21]
2 lst2 = [2, 4, 6, 8, 10]
3 # 水桶效应
4 m=map(lambda x,y:x+y,lst1,lst2)
5 print(list(m))
水桶效应

 

五 递归 :函数自己调用自己

最大深度:1000 到不了1000就停了

 1 counnt =1
 2 def func():
 3      global count
 4      print("alex很帅",count)
 5     count =count+1
 6     func()
 7 func()
 8 
 9 结果:
10 alex是很帅的  1
11 alex是很帅的 995
12 alex是很帅的 996
13 alex是很帅的 997
14 alex是很帅的 998Traceback (most recent call last):
15 
16 结果只能算到998 ,因为递归的深度最大是1000 不会到1000
递归函数
 1 import os
 2 # def func(filepath, n): # d:/sylar/
 3 #     # 1,打开这个文件夹
 4 #     files = os.listdir(filepath)
 5 #     # 2. 拿到每一个文件名
 6 #     for file in files:  # 文件名
 7 #         # 3. 获取到路径
 8 #         f_d = os.path.join(filepath, file) # d:/sylar/文件名/
 9 #         # 4. 判断是否是文件夹
10 #         if os.path.isdir(f_d):
11 #             # 5. 如果是文件夹. 继续再来一遍
12 #             print("\t"*n, file,":") # 打印文件名
13 #             func(f_d, n + 1)
14 #         else:   #  不是文件夹. 普通文件
15   print("\t"*n, file)
16 #
17 # func("d:/sylar",0)
递归函数打开文件

 

六 二分法

核心:掐头去尾取中间 一次砍掉一半

两种算法:常规循环,递归循环

1 lst = [22, 33, 44, 55, 66, 77, 88, 99, 101 , 238 , 345 , 456 , 567 , 678 , 789 ]
2 n=79   查找79在不在列表中
3 
4 for el in lst:
5      if el==n:
6          print("找到了")
7 else:
8    print("没有")
二分法
 1 lst = [22, 33, 44, 55, 66, 77, 88, 99, 101 , 238 , 345 , 456 , 567 , 678 , 789]
 2 def func(n,left,right):
 3      if left <=right:
 4          mid=(left+right)//2
 5      if n >lst[mid]:
 6          left =mid+1
 7          return func(n,left,right)    递归 递归的入口
 8      elif n <lst[mid]:
 9          right = mid - 1
10             # 深坑. 函数的返回值返回给调用者
11             return func(n, left, right)    # 递归
12      elif n == lst[mid]:
13             print("找到了")
14             return mid
15             # return  # 通过return返回. 终止递归
16       else:
17         print("没有这个数") # 递归的出口
18         return -1 # 1, 索引+ 2, 什么都不返回, None
19 # 找66, 左边界:0,  右边界是:len(lst) - 1
20 ret = func(70, 0, len(lst) - 1)
21 print(ret) # 不是None
二分法查找

 

posted @ 2018-08-15 18:00  茉莉花M  阅读(212)  评论(0)  编辑  收藏  举报