标签：递归 input iter 保留 大小 执行 reverse usr 形参
-----------生活里没有奇迹，大部分的时候奇迹是你自己创造的。
# -------------------------------------------------------------------------#
# sum = lambda a,b:a+b
# svm = sum(10,510)
# print(svm)
# st = ["魔兽世界","吃鸡","阴阳师","地下城与勇士","传奇","王者农药"]
# s1 = lambda st:len(st)
# def func(wert):
# return len(wert)
#
# s2 =sorted(st,key=func)
# print(s2)
#
# nst =[{‘id‘:1,‘name‘:‘alex‘,‘age‘:28},
# {‘id‘:2,‘name‘:‘taibai‘,‘age‘:58},
# {‘id‘:3,‘name‘:‘taihei‘,‘age‘:18},
# {‘id‘:4,‘name‘:‘henhei‘,‘age‘:38}]
#
# #
# f4 = filter(lambda s:nst["age"]>=38,nst)
# print(f4)
# def age_up(nst):
# return nst[‘age‘]
#
# s3 = sorted(nst,key=age_up)
# print(s3)
#
# li = ["沙漏","左耳","盗墓笔记","云天","山楂树之恋","盘"]
#
# li2 = filter(lambda s:len(s)>3,li)
# for i in li2:
# print(i)
# 给出一个列表
# lst = ["alex_123", "alex_456", "wusir_123", "wusir_456", "alex_789"]
# #
# usr = "alex" # 正确的用户名:
# psw = 123 # 密码:
#
# def fuc(nis):
# for i in lst:
# x = i.split("_")[0]
# y = i.split("_")[1]
# if x == usr and str(y) ==psw:
# print("OK")
# return "验证通过"
#
# map = map(fuc,)
#
#
# import os
#
# def fuc(path):
# lsi = os.listdir(path)
# for i in lsi:
# file_real_path = os.path.join(path,i)
# if os.path.isdir(file_real_path):
# print(i)
# fuc(file_real_path)
# else:
# print(i)
# lstx = [4, 56, 178, 253, 625, 1475, 2580, 3574, 15963]
# n = int(input("-->"))
# if n in lstx:
# print("ok")
# else:
# print("no")
#
# print(lstx)
#
# l = 0
# r = len(lstx) - 1
#
# n = int(input("-->"))
# while l <= r:
# if n > lstx[(l + r) // 2]:
# l = (l + r) // 2 + 1
# elif n < lstx[(l + r) // 2]:
# r = (l + r) // 2 - 1
# else:
# print(‘找到了‘)
# break
# else:
# print(‘没有找到‘)
# sum = 0
# sum1 = 0
# for i in range(1, 100, 2):
#
# sum = sum + i
# sum1 = sum + (i + 2)
# print(sum - sum1)
# -------------------------------[]-------------------------------------#
# 1，整理今天所学内容，整理知识点，整理博客。
‘‘‘
1. 匿名函数
函数:
def 函数名(形参):
函数体(return)
函数名(实参)
形参:
1. 位置参数
2. 默认值参数
3. 动态传参
*args: 动态接收位置参数
**kwargs: 动态接收关键字参数
位置 > *args > 默认值 > **kwargs
实参:
1. 位置参数
2. 关键字参数
3. 混合参数
lambda 参数: 返回值
2. sorted
排序
sorted(Iterable, key, reverse)
3. filter
筛选
filter(function, Iterable)
4. map
映射
map(function, Iterable)
5. 递归
自己调用自己
6. 二分法(递归的应用)
开头
结尾
中间
‘‘‘
# ---------------------------------------------------------------------------------#
#
# 2，画好流程图。
# 新增面向对象9个函数
# 新增反射相关4个函数
# ---------------------------------------------------------------------------------#
# ------------------[都完成的,做一下作业（下面题都是用内置函数或者和匿名函数结合做出）：]---------------------#
# 4，用map来处理字符串列表,把列表中所有人都追加"_sb",比方:alex_sb
# name=[‘oldboy‘,‘alex‘,‘wusir‘]
# # map把可迭代对象中的每一个元素拿出来交给前面的函数执行. 保留最后的执行结果
# m = map(lambda s: s+"_sb", name)
# for i in m:
# print(i)
# ---------------------------------------------------------------------------------#
# 5，用map来处理下述l，然后用list得到一个新的列表，列表中每个人的名字都是sb结尾
# l=[{‘name‘:‘alex‘},{‘name‘:‘y‘}]
#
# m1 = map(lambda s: s[‘name‘]+"_sb", l)
#
# print(list(map(lambda s: s[‘name‘]+"_sb", l)))
# ---------------------------------------------------------------------------------#
# 6，用filter来处理,得到股票价格大于20的股票名字
# shares = {
# ‘IBM‘: 36.6,
# ‘Lenovo‘: 23.2,
# ‘oldboy‘: 21.2,
# ‘ocean‘: 10.2,
# }
# #
# # 把后面的可迭代对象中的每一个元素交给前面的函数。 根据函数返回的True或者False。 判断是否保留该元素
#
# print(list(filter(lambda key: shares[key] > 20, shares)))
# print(list(filter(lambda ren: ren[‘age‘]>=38, lst)))
# ---------------------------------------------------------------------------------#
# 7,有下面字典，得到购买每只股票的总价格，并放在一个迭代器中。
# 结果：list一下[9110.0, 27161.0,......] shares * price
# 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.8},
# {‘name‘:‘ACME‘,‘shares‘:75,‘price‘:115.65}]
# lis = []
#
# m = map(lambda s:s[‘shares‘] * s[‘price‘],portfolio)
# print(list(m))
# ----->[9110.0, 27161.0, 4218.0, 1111.25, 735.751, 8673.75]
## ---------------------------------------------------------------------------------#
# 8,还是上面的字典，用filter过滤出单价大于100的股票。
# print(list(filter(lambda v:v["price"]>100,portfolio)))
## ---------------------------------------------------------------------------------#
# 9,有下列三种数据类型，
# l1 = [1,2,3,4,5,6]
# l2 = [‘oldboy‘,‘alex‘,‘wusir‘,‘太白‘,‘日天‘]
# tu = (‘**‘,‘***‘,‘****‘,‘*******‘)
# # 写代码，最终得到的是（每个元祖第一个元素>2,第三个*至少是4个）
# #[(3, ‘wusir‘, ‘****‘), (4, ‘太白‘, ‘*******‘)]这样的数据。
# #
# [曲解]
# lsit = [{l1:1,2,3,4,5,6},
# {l2:‘oldboy‘,‘alex‘,‘wusir‘,‘太白‘,‘日天‘},
# {tu:(‘**‘,‘***‘,‘****‘,‘*******‘)}]
# print(list(filter(lambda (x,y,z):(x:x>2,l1) and (y:l2[y+2],l2) and (z:tu[z+2],tu),lsit)))
#
# [正解]
# m = filter(lambda x: x[0] > 2 and len(x[2]) > 3, zip(l1, l2, tu))
# print(list(m))
## ---------------------------------------------------------------------------------#
# 10,有如下数据类型：
l1 = [ {‘sales_volumn‘: 0},
{‘sales_volumn‘: 108},
{‘sales_volumn‘: 337},
{‘sales_volumn‘: 475},
{‘sales_volumn‘: 396},
{‘sales_volumn‘: 172},
{‘sales_volumn‘: 90},
{‘sales_volumn‘: 58},
{‘sales_volumn‘: 272},
{‘sales_volumn‘: 456},
{‘sales_volumn‘: 440},
{‘sales_volumn‘: 239}]
# 将l1按照列表中的每个字典的values大小进行排序，形成一个新的列表。
# def fuc(s):
# return s["dic:dic["age"]"]
# x =sorted(l1,fuc)
print(sorted(l1,key=lambda dic:dic["sales_volumn"]))
标签：递归 input iter 保留 大小 执行 reverse usr 形参
原文地址：https://www.cnblogs.com/dealdwong2018/p/9912083.html
