python全栈开发-前方高能-内置函数2
python_day_15
一.今日主要内容
1. lambda 匿名函数
语法:
lambda 参数:返回值
不能完成复杂的操作
2. sorted() 函数
排序.
1. 可迭代对象
2. key=函数. 排序规则
3. reverse. 是否倒序
3. filter() 函数
过滤
1. 函数, 返回True或False
2. 可迭代对象
4. map() 映射函数
1. 函数
2. 可迭代对象
5. 递归
自己调用自己.
def func():
func()
func()
难点:不好想.需要找规律. 不好读
6. 二分法
掐头结尾取中间. 不停的改变左和右. 间接改变中间. 查询效率非常高
14. 前⽅⾼能-内置函数⼆
本节主要内容:
- 1. lamda匿名函数
- 2. sorted()
- 3. filter()
- 4. map()
- 5. 递归函数
⼀. 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 参数: 返回值
注意:
- 1. 函数的参数可以有多个. 多个参数之间⽤逗号隔开
- 2. 匿名函数不管多复杂. 只能写⼀⾏, 且逻辑结束后直接返回数据
- 3. 返回值和正常的函数⼀样, 可以是任意数据类型
匿名函数并不是说⼀定没有名字. 这⾥前⾯的变量就是⼀个函数名. 说他是匿名原因是我们通 过__name__查看的时候是没有名字的. 统⼀都叫lambda. 在调⽤的时候没有什么特别之处. 像正常的函数调⽤即可
⼆. sorted() 排序函数.
语法: sorted(Iterable, key=None, reverse=False)
Iterable: 可迭代对象 key: 排序规则(排序函数), 在sorted内部会将可迭代对象中的每⼀个元素传递给这个函 数的参数. 根据函数运算的结果进⾏排序
reverse: 是否是倒叙. True: 倒叙, False: 正序
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)
三. filter() 筛选函数
语法: filter(function. Iterable)
function: ⽤来筛选的函数. 在filter中会⾃动的把iterable中的元素传递给function. 然后 根据function返回的True或者False来判断是否保留此项数据
Iterable: 可迭代对象
lst = [1,2,3,4,5,6,7,8,9] ll = filter(lambda i:i%2==1, lst) # 第一个参数. 函数. 将第二个参数中的每一个元素传给函数. 函数如果返回True, 留下该元素.
四. map() 映射函数
语法: map(function, iterable)
可以对可迭代对象中的每⼀个元素进⾏映射. 分别取执⾏ function 计算列表中每个元素的平⽅ ,返回新列表
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))
五. 递归 在函数中调⽤函数本⾝. 就是递归,在python中递归的深度最⼤到997.
import sys sys.setrecursionlimit(10000) # 可以调整递归深度. 但是不一定能跑到这里 def func(count): print("我是谁,我在哪里"+str(count)) func(count+1) func(1) while 1: a = 10 print("哈哈")
递归的应⽤: 我们可以使⽤递归来遍历各种树形结构, 比如我们的⽂件夹系统. 可以使⽤递归来遍历该 ⽂件夹中的所有⽂件
# 遍历树形结构 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)
六. ⼆分查找
⼆分查找. 每次能够排除掉⼀半的数据. 查找的效率非常⾼. 但是局限性比较⼤. 必须是有 序序列才可以使⽤⼆分查找 要求: 查找的序列必须是有序序列.
1)二分法,非递归版
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("不存在")
2)普通递归版
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) )
3)另类二分法,很难计算位置.
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)
参考:
https://www.processon.com/mindmap/5b506a16e4b0edb750e17387
作业:
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)
2018-07-20 15:26:04