zoukankan      html  css  js  c++  java
  • 递归,匿名函数

    # 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())
  • 相关阅读:
    一些常用的库[转载]
    《三国演义》很给力演绎60条职场真理
    保证你现在和未来不失业的10种关键技【转载】
    百度面试题
    百度的一到算法i题
    FindMaxDeep
    csinglelink
    FindLongArray
    byte转hex,hex转byte
    获取异常信息
  • 原文地址:https://www.cnblogs.com/yf18767106368/p/9183438.html
Copyright © 2011-2022 走看看