• 迭代器 递归 格式化


    函数第一类对象及使用

    1. 可以当做值被赋值给变量

      def func():
          print(1)
      a = func
      print(a)
      print(func)
      
      输出的结果:   你犯浑的原因在于,不敢判断 func函数是不用运行的
      <function func at 0x105d58e18>
      <function func at 0x105d58e18>
      
    2. 当做元素存放在容器中

    def func():
        print(1)
    lst = [func,func,func]
    print(lst)
    for i in lst:
         i()       #这就是相当于 func()   函数调用
    #
    
    [<function func at 0x10f49be18>, <function func at 0x10f49be18>, <function func at 0x10f49be18>]
    1
    1
    1
    

    3.函数名当做函数的参数

    def func(f):
        print(f)    #调用的 foo 的内存地址
    def foo():      #没有调用  不用执行
        print(233)
    func(foo)
    
    #结果
    <function foo at 0x1016642f0>
    

    4.函数名可以当作函数的返回值

    def func():
        def foo():
            print(233)
        return foo      #返回给 func foo的内存地址
    print(func())              
    
    #<function func.<locals>.foo at 0x10e0c92f0>
    

    加一个判断

    def f1():
        def f2():
            print(1)
            def f3():
                print(123)
            return f2       #这里返回的是 f2 的内存地址,
        ret = f2()
        return ret          #所以这里的内存地址
    print(f1())
    

    f—格式化

    %s 和 format 都可以 f

    s = f"你好{'常鑫'}"  #填充字符串
    s1 =F"你好{'常鑫'}"
    print(s,s1)
    
    s ="123"
    s = f"你好{s}"    #可以存放变量
    print(s)
    
    s = f"你好{17+12}"   #填充计算公式
    print(s)
    
    a = 10
    b = 20
    s = f"你好{a if a > b else b}"     #填充三元运算符
    print(s)
    #你好  20
    
    s1 = f"{{{{'常鑫'}}}}"  #两个大括号是一个
    print(s1)
    
    s1 = f"{print(1233)}"    #后面可以是函数   这个有疑惑,需要解决一下
    print(s1)
    
    # 1233
    # None
    
    def foo():
        def func():
            a = 1
            return a
        return func()
    s1 = f"{foo()}"     #现在看这个程序已经没有啥问题
    print(s1)
    
    #  1     
    
    lst = [1,2,3,4,5,6,7,8]
    s = f"{lst[:5]}"
    print(s)
    #  [1, 2, 3, 4, 5]
    
    dic = {"key":1,"key2":2}
    s1 = f"{dic['key']}"
    print(s1)
    #  1
    

    迭代器

    当容器中数据量较大的时候使用迭代器,入文件句柄

    迭代器优点:节省内存,惰性机制

    迭代器缺点:使用不灵活,操作繁琐,不能直接查看所有值

    迭代器的特性:

    • 一次性的
    • 不能逆行
    • 惰性机制(要一个一个给,不要就不给) -----节省内存

    器:工具

    可迭代对象————list ,dict,str,set,tuple

    具有很多私有方法,具有_iter_ 方法的就是一个可迭代对象,使用灵活

    可迭代对象不一定是迭代器,但是迭代对象一定是可迭代对象.

    查看是否是可迭代对象的方法

    list.__iter__()
    str.__iter__()
    dic.__iter__()
    tuple.__iter__()
    set.__iter__()
    

    方法二

    看源码

    方法三 :dir

    print(dir(list))

    方法四

    官方声明只具有__iter__方法就是可迭代对象

    可迭代对象的优点:

    1.使用灵活

    2.直接查看值

    可迭代对象的缺点:

    消耗内存

    取值方式:

    list ,tuple,str --索引

    dict--键

    set--直接取值

    for

    迭代器: iter()将可迭代对象转化乘迭代器

    官方声明只要具有__iter__方法__next__就是迭代器

    基于上一个停留的位置进行取值

    s = "152132"
    news_s = s.__iter__()   #将可迭代对象转化为迭代器
    print(news_s)
    print(news_s.__next__())
    print(news_s.__next__())
    print(news_s.__next__())
    print(news_s.__next__())
    print(news_s.__next__())
    
    #
    1
    5
    2
    1
    3
    

    for 循环原理

    s = "12332"
    new_s = s.__iter__()
    while True:
        try:
            print(new_s.__next__())
        except StopIteration:  # 捕获错误
            break
    
    s = "12332"
    new_s = s.__iter__()
    while True:
        try:
            print(new_s.__next__())
        except Exception:  # 万能异常捕获
            break
    

    递归

    自己学习---学会百度

    递归条件:1.自己调用自己(官方话,不断调用自己本身)

    2.要有明确的终止条件

    满足以上两个才是有效递归

    递:一直执行到带结束条件

    归:从结束条件往回退

    官方声明最大层次1000,实际测试998/997 可以修改

    def age(n):
        if n == 4:
            return 18
        else :
            return age(n+1)-2
    print(age(1))
    
  • 相关阅读:
    MFC中L, _T(),TEXT,_TEXT区别以及含义
    Qt5完美解决 界面显示中文乱码
    TCP三次握手四次挥手详解
    TCP 长连接与短连接的区别
    Servlet 生命周期、工作原理
    Java反射的三种实现方式
    apache httpclient 4.5 兼容 http https
    mysql千万级大数据SQL查询优化
    Java String字符串补0或空格
    mysql存储过程
  • 原文地址:https://www.cnblogs.com/hualibokeyuan/p/11209957.html
Copyright © 2020-2023  润新知