递归,匿名函数

Posted 2020-11-17 yf18767106368

# import sys #模块
# sys.getrecursionlimit() #递归最大层数为1000层.
#sys.setrecursionlimit() #修改递归层数

# def foo():#直接调用
#     print("fore you") #执行
#     foo()  #调用函数,当第一遍结束之后才会关闭,第一次调用执行到目前的foo()调用进入第二次调用,
# 而第一的次调用结束但是没有关闭,是继续开着的与第二次调用互相关联
# foo()#调用函数

# def bre():#间接调用
#     print("fore ber")#出现第二个print
#     foo()#第三调用,回归foo()定义内
#
# def foo():
#     print("fare foo " )#出现第一个print,由bre定义内的foo调用回归到这个print进行打印
#     bre()#第二调用
# foo() #第一调用
#整体就像直接调用
# def foo():
#     print("fare foo " )#第一打印
#     print("fore ber")#第二打印
#     foo()#进入调用进行循环
#foo()#调用

# def foo(n):
#     print("from foo",n)
#     foo(n+1) #默认最大循环是1000层左右,超过会自动关闭报错,
# 而递归最大的用处就是在于每一次的循环更加逼近于最终结果,而非无意义的循环
# foo(0)


# age(5) = age(4) + 2 #递推的需求 #根据递推最后一层的结果回溯后的结果为34
# age(4) = age(3) + 2
# age(3) = age(2) + 2
# age(2) = age(1) + 2
# age(1) = 26 #递推最后一层的结果

#age(n) = age(n-1) + 2  #n > 1 #条件的判断
#age(1) = 26            #n = 1
# def age(n):
#     if n == 1:
#         return 26     #获得递推答案后,回溯,得到想要的答案
#     return age(n-1) + 2 #递推下一层
# print(age(5))

# l=[1,[2,[3,[4,[5,[6,[7,[8,[9]]]]]]]]]
# def tell(l):
#     for time in l:#进行for循环出列表
#         if type(time) in list:#用type类型判断time的类型是字符串还是列表,
# 这里第一次取得的是字符串1,后面取得的是列表,通过判断后在列表内可以继续循环
#             tell(time)
#         else:
#             print(time)#是字符串就直接打印
# tell(l)



# nums=[1,3,5,7,11,22,34,55,78,111,115,137,149,246,371]
# def search(search_num,nums):#两个参数,一个是需要判断的值,一个是列表
#     print(nums) #打印每次循环的列表
#     if len(nums) == 0: #判断当列表长度为0的时候结束循环return,表明当前查找的值不在列表内
#         print("notexists")
#         return
#     mid_index=len(nums)//2 #将列表的长度对半整除之后赋值
#     if search_num > nums[mid_index]:#判断预判值是大于中间值
#         #in the right #如果大于中间值
#         nums=nums[mid_index+1:] #那么针对右边的数会再一次对半进行判断,并且赋值
#         search(search_num,nums)#循环执行新的判断
#     elif search_num < nums[mid_index]:#判断预判值是小于中间值
#         #in the left#如果小于中间值
#         nums=nums[:mid_index]#那么针对左边的数会再一次对半进行判断,并且赋值
#         search(search_num,nums)#循环执行新的判断
#     else:
#         print("find it")#直到循环结束后获得由在列表内的值
# search(31,nums)

#lambda 匿名函数,匿名函数不能回车,而是全部都写在一行,x,y:x+y
# res=(lambda x,y:x+y)(1,2) #x,y 是形参,(1,2)是实参,x+y是执行代码块
# print(res)#匿名函数不是这么用
# f=lambda x,y:x+y
# print(f(1,2))#匿名函数也不是这么用



#max min sorted filter map 使用方式
# salaries={
#     ‘egon‘:3000,
#     ‘alex‘:100000000,
#     ‘wupeiqi‘:10000,
#     ‘yuanhao‘:2000
# }

# max的工作原理
#1 首先将可迭代对象变成迭代器对象
#2 res=next(可迭代器对象),将res当作参数传给key指定的函数,然后将该函数的返回值当作判断依据
# def func(k):
#     return salaries[k]#return value
# print(max(salaries,key=func)) #next(iter_s) #显示出来的是key永远不变,能变的是依据什么条件的判断
#‘egon‘, v1=func(‘egon‘)
#‘alex‘, v2=func(‘alex‘)
#‘wupeiqi‘, v3=func(‘wupeiqi‘)
#‘yuanhao‘, v4=func(‘yuanhao‘)

# print(max(salaries,key=lambda k:salaries[k]))#因为只用一次,以后不用,所以用匿名函数lambda 形参(字典的ket):字典[key]=value

# print(min(salaries,key=lambda k:salaries[k]))

# l=[10,1,3,-9,22]
# l1=sorted(l,reverse=False)#False从小到大的排序
# print(l1)
#
# l2=sorted(l,reverse=True)#True从大到小的排序
# print(l2)

# print(sorted(salaries,key=lambda k:salaries[k],reverse=True)) #收入从大到小的顺序排列


# map的工作原理
#1 首先将可迭代对象变成迭代器对象
#2 res=next(可迭代器对象),将res当作参数传给第一个参数指定的函数,然后将该函数的返回值当作map的结果之一
# names=[‘yy‘,‘qq‘,‘pp‘,‘dd‘]
# aaa=map(lambda x:x+"_SB",names) #为所有对象加上后缀并成为迭代器
# print(aaa) #打印可以看出是形成迭代器
# print(list(aaa))#用列表方式可以看到其内容

# print([name+"_SB" for name in names])

# filter的工作原理
#1 首先将可迭代对象变成迭代器对象
#2 res=next(可迭代器对象),将res当作参数传给第一个参数指定的函数,然后filter会判断函数的返回值的真假,如果为真则留下res
# names=[‘aaSB‘,‘dd‘,‘bbSB‘,‘ccSB‘]
#
# print([name for name in names if name.endswith(‘SB‘)])
#
# aaa=filter(lambda x:x.endswith(‘SB‘),names) #按照制定后缀结尾,filter判断函数返回值是否为真,如果为真就留下,
# # 不是就删除.也是迭代器形式,通过list列表来查看
# print(aaa)
# print(list(aaa))

# 掌握
# res=‘你好‘.encode(‘utf-8‘)
# print(res)
#
# res=bytes(‘你好‘,encoding=‘utf-8‘)
# print(res)

# 参考ASCII表将数字转成对应的字符
# print(chr(65))
# print(chr(90))
# 参考ASCII表将字符转成对应的数字
# print(ord(‘A‘))

# print(divmod(10,3))


# l=[‘a‘,‘b‘,‘c‘]
# for item in enumerate(l):
#     print(item)

# l=‘[1,2,3]‘
# l1=eval(l)
# print(l1,type(l1))
# print(l1[0])

# with open(‘a.txt‘,encoding=‘utf-8‘) as f:
#     data=f.read()
#     print(data,type(data))
#     dic=eval(data)
#     print(dic[‘sex‘])

# print(pow(3,2,2)) # (3 ** 2) % 2

# print(round(3.3))

# print(sum(range(101)))


module=input(‘请输入你要导入的模块名>>: ‘).strip() #module=‘asdfsadf‘
m=__import__(module)
print(m.time())


# 面向对象里的重点
# classmethod
# staticmethod
# property
#
# delattr
# hasattr
# getattr
# setattr
#
# isinstance
# issubclass
#
# object
#
# super


# 了解
# print(abs(-13))
# print(all([1,2,3,]))
# print(all([]))

# print(any([0,None,‘‘,1]))
# print(any([0,None,‘‘,0]))
# print(any([]))

# print(bin(3)) #11
# print(oct(9)) #11
# print(hex(17)) #11

# print(callable(len))

# import time
# print(dir(time)) #列举出所有:time.名字


# s=frozenset({1,2,3}) # 不可变集合
# s1=set({1,2,3}) # 可变集合

# a=1111111111111111111111111111111111111111111111
# # print(globals())
# # print(locals())
# def func():
#     x=222222222
#     # print(globals())
#     print(locals())
# func()

# hash([1,2,3])

# def func():
#     """
#     文档注释
#     :return:
#     """
#     pass
#
# print(help(func))

# l=[‘a‘,‘b‘,‘c‘,‘d‘,‘e‘]
# s=slice(1,4,2)
# print(l[1:4:2])
# print(l[s])

# print(vars())