• 函数的回顾03


    1. 函数名的第一类对象及使用

      # 第一类对象 -- 特殊点
      
      # def func():
      #     print(1)
      # # print(func)
      # a = func
      # a()
      
      
      
      # def func():
      #     print(1)
      #
      # lst = [func,func,func]
      # for i in lst:
      #     i()
      
      
      
      # def func(f):
      #     f()
      # def foo():
      #     print(123)
      # func(foo)
      
      
      
      # def func():
      #     def foo():
      #         print(123)
      #     return foo
      # a = func()
      # a()
      
      # 1.可以当做值被赋值给变量
      # 2.当做元素存放在容器中
      # 3.函数名可以当做函数的参数
      
      # def func(f):
      #     f()
      #
      # def foo():
      #     print("is foo")
      #
      # func(foo)
      
      # 4.函数名可以当做函数的返回值
      
      # def f1():
      #     def f2():
      #         print(1)
      #         def f3():
      #             print(2)
      #         return f2
      #     ret = f2()  # f2 函数的内存地址
      #     return ret  #
      # print(f1())
      
      
    2. f格式化

      # python3.6版本及以上才能够使用
      
      # s = f"你好{'常鑫'}"       # 填充字符串
      # s1 = F"你好{'常鑫'}"
      
      # s1 = f"你还是挺好的{s}" # 填充变量
      # print(s1)
      
      # s1 = f"{35+15}"         # 填充计算公式
      # print(s1)
      
      # a = 10
      # b = 20
      # s1 = f"{a if a>b else b}"  # 填充表达式
      # print(s1)
      
      # s1 = f"{{{{{{'常鑫吃..'}}}}}}"  # 填充大括号
      # print(s1)
      
      # s1 = f"{{}}"
      # print(s1)
      
      
      # s1 = f"{'{}{}{}{}{}'}"
      # print(s1)
      
      # s1 = f"{print(123)}"
      # print(s1)
      
      # def prin(a):
      #     print(a)
      #
      # s1 = f"{prin(123)}"
      # prin(s1)
      
      # def foo():
      #     def func():
      #         a = 1
      #         return a
      #     return func()
      #
      # s1 = f"{foo()}"
      # print(s1)
      
      # lst = [1,3,4,5,6]
      # s1 = f"{lst[0:5]}"
      # print(s1)  # [1,3,4,5,6]
      
      # dic = {"key1":123,"key2":345}
      # s1 = f"{dic['key2']}"
      # print(s1)
      
      # %s,format,f
      
      
    3. 迭代器

      # 迭代:  器:工具
      
      # 可迭代对象
      
      # list,dict,str,set,tuple -- 可迭代对象  使用灵活
      
      # 方式一:
      # list.__iter__()
      # dict.__iter__()
      # str.__iter__()
      # set.__iter__()
      # tuple.__iter__()
      
      # 方法二:
      # 查看源码
      
      # 方法三:
      # print(dir(list))
      
      # 官方声明只要具有__iter__()方法的就是可迭代对象
      
      # 可迭代对象的优点:
          # 1.使用灵活
          # 2.直接查看值
      # 可迭代对象的缺点:
      #   1.消耗内存
      
      # list,tuple,str -- 索引
      # dict -- 键
      # set  -- 直接取值
      
      # 迭代器:
      # 官方声明只要具有__iter__()方法__next__()方法就是迭代器
      # f = open("xxxx","w")
      # f.__iter__()
      # f.__next__()
      
      # lst = [1,2,3,4,6]
      # new_list = lst.__iter__()  #将可迭代对象转换成迭代器
      #
      # new_list.__iter__()
      # new_list.__next__()
      
      # s = "123434"
      # new_s = s.__iter__()       #将可迭代对象转换成迭代器
      # print(new_s)
      # new_s.__iter__()
      # new_s.__next__()
      
      
      # new_s = s.__iter__()       #将可迭代对象转换成迭代器
      # print(new_s)
      # new_s.__iter__()
      # print(new_s.__next__())
      # print(new_s.__next__())
      # print(new_s.__next__())
      
      # s = "12343"               # 更改版for的本质
      # s = [1,2,3,4,5,7]
      # count = len(s)
      # new_s = s.__iter__()
      # while count:
      #     print(new_s.__next__())
      #     count -= 1
      
      
      # print(new_s.__next__())
      # print(new_s.__next__())
      # print(new_s.__next__())
      # print(new_s.__next__())
      # print(new_s.__next__())
      # print(new_s.__next__())
      
      # s = "12345"
      # new_s = s.__iter__()
      # while True:
      #     try:
      #         print(new_s.__next__())   # for真实本质
      #     except StopIteration:
      #         break
      
      
      # except Exception:
      #     print("我是万能的!")
      #     break
      
      
      # 总结:
      #     可迭代对象:
      #         优点:使用灵活,可以直接查看值
      #         缺点:占内存,不能迭代取值
      #
      #     迭代器:
      #         优点:节省内存,惰性机制
      #         缺点:使用不灵活,操作比较繁琐,不能直接查看元素
      
      
      # 迭代器的特性:
      #     1.一次性的(用完就没有了)
      #     2.不能逆行(不能后退)
      #     3.惰性机制(节省内存)
      
      # 什么是可迭代对象:
      #     具有很多私有方法,具有__iter__()方法的就是一个可迭代对象
      
      # 什么是迭代器:
      #     具有__iter__()和__next__()方法的就是迭代器
      
      # 迭代器什么时候使用:当容器中数据量较多的时候使用迭代器
      
    4. 递归

      递归
      # 1.自己调用自己 (不断调用自己本身) -- 死递归
      # 2.有明确的终止条件
      # 满足以上两个才是有效递归
      
      # 递:一直执行直到碰到结束条件
      # 归:从结束条件开始往回退
      
      # 官方声明: 最大层次1000,实际测试 998/997
      
      # def func():
      #     print(123)
      #     func()
      # func()
      
      # def age(n): # 1,2,3
      #     if n == 3:
      #         return "猜对了"
      #     else:
      #         age(n+1)
      # print(age(1))
      
      # def age2(n):
      #     if n == 3:
      #         return "猜对了"
      #
      # def age1(n):
      #     if n == 3:
      #         return "猜对了"
      #     else:
      #         age2(n+1)
      #
      # def age(n):
      #     if n == 3:
      #         return "猜对了"
      #     else:
      #         age1(n+1)
      # age(1)
      
      
      # 1.宝元  18-2-2-2
      # 2.太白  18-2-2
      # 3.wusir 18-2
      # 4.alex  18
      
      # def age(n):
      #     if n == 4:
      #         return 18
      #     else:
      #         return age(n+1)-2
      # print(age(1))
      
      
      # def age4(n):
      #     if n == 4:
      #         return 18
      # def age3(n):
      #     if n == 4: # 问的是不是第四个了
      #         return 18
      #     else:
      #         return age4(n+1)-2
      # def age2(n):
      #     if n == 4:  # 问的是不是第四个了
      #         return 18
      #     else:
      #         return age3(n+1)-2
      # def age1(n):
      #     if n == 4: # 问的是不是第四个了
      #         return 18
      #     else:
      #         return age2(n+1)-2
      # print(age1(1))
      
  • 相关阅读:
    【noi2018】归程
    【USACO06JAN】牛的舞会The Cow Prom
    City Horizon (线段树)
    USACO 2019 January Gold Cow Poetry (结论+dp)
    POJ 2528 Mayor's posters (线段树)
    线段覆盖 (线段树)
    POJ 2892 Tunnel Warfare (线段树)
    NOIP 2017 逛公园 (最短路+dp)
    USACO 2019 February Gold Cow Land (树链剖分)
    CSU 2151 集训难度(线段树)
  • 原文地址:https://www.cnblogs.com/-777/p/11210308.html
Copyright © 2020-2023  润新知