欢迎您访问程序员文章站本站旨在为大家提供分享程序员计算机编程知识!
您现在的位置是: 首页  >  IT编程

python迭代器(函数名的应用,新版格式化输出f)

程序员文章站 2022-04-15 17:26:45
1. 内容大纲 1. 函数名的运用 2. 新特性:格式化输出 3. 迭代器: 可迭代对象 获取对象的方法 dir() 判断一个对象是否是可迭代对象 小结 迭代器 迭代器的定义 判断一个对象是否是迭代器 迭代器的取值 可迭代对象如何转化成迭代器 while循环模拟for循环机制 小结 可迭代对象与迭代 ......
  1. 内容大纲

    1. 函数名的运用
    2. 新特性:格式化输出
    3. 迭代器:
      • 可迭代对象
      • 获取对象的方法 dir()
      • 判断一个对象是否是可迭代对象
      • 小结
      • 迭代器
      • 迭代器的定义
      • 判断一个对象是否是迭代器
      • 迭代器的取值
      • 可迭代对象如何转化成迭代器
      • while循环模拟for循环机制
      • 小结
      • 可迭代对象与迭代器的对比
  2. 详细内容:

    1. 函数名的运用:

      函数名的定义和变量的定义几乎一致,在变量的角度,函数名其实就是一个变量,具有变量的功能:可以赋值;但是作为函数名他也有特殊的功能就是加上()就会执行对应的函数,所以我们可以把函数名当做一个特殊的变量。

      1:函数名指向的是函数的内存地址,函数名 + () 就可以执行此函数
       a =1
       a()#typeerror: 'int' object is not callable  不可调用
      
       a = 1
       b = 2
       print(a + b)#3  a与b可以相加,与a,b这两个变量本身无关,与变量指向的对象有关。
      
       def func():
           print(666)
       func()#666  之所以func + () 可以执行,与func (函数名) 指向的内存地址有关。函数的内存地址()才是执行这个函数的关键
       print(func,type(func))#<function func at 0x000001cb29a71e18> <class 'function'>
      
      2:函数名就是变量(函数名可以赋值给其他变量)
       def func():
           print(666)
       f = func   #变量的赋值
       f1 = f
       f2 = f1
       f()#666
       func()#666
       f1()#666
       f2()#666
      
      
       def func():
           print('in func')
       def func1():
           print('in func1')
       func1 = func
       func1()#in func
      
      
      3:函数名可以作为容器类数据类型的元素
       def func1():
           print('in func1')
       def func2():
           print('in func2')
       def func3():
           print('in fnc3')
       l1 = [func1,func2,func3]
       for i in l1:
           i()
      # # in func1
      # # in func2
      # # in fnc3
      
      # #类比:
       a = 1
       b = 2
       c = 3
       l1 = [a,b,c]
       print(l1)#[1, 2, 3]
      
      4;函数名可以作为函数的参数
       def func(a):
           print(a)
           print('in func')
       b = 3
       func(b)
      # # 3
      # # in func
      
      
       def func():
           print('in func')
       def func1(x):
           x()
           print('in func1')
       func1(func)
      # # in func
      # # in func1
      
      5:函数名可以作为函数的返回值
       def func():
           print('in func')
       def func1(x):       # 传参相当于x = func
           print('in func1')
           return x
       ret = func1(func)
       ret()  #相当于func()     # ret, x, func1 都是指向的func1这个函数的内存地址
      # # in func1
      # # in func
      
    2. 新特性:格式化输出

      [1]格式花输出 %s format
      
       name = '太白'
       age = 18
       msg ='我叫%s,今年%s' %(name,age)
       msg1 = '我叫{},今年{}'.format(name,age)
       print(msg)#我叫太白,今年18
       print(msg1)#我叫太白,今年18
      
      
      [2]python3.6之后的新特性:格式化输出 f 或 f :
      
       name = '太白'
       age = 18
       msg = f'我叫{name},今年{age}'
       print(msg)#我叫太白,今年18
      
      (1)可以加任意表达式:
      
       dic = {'name':'alex','age':18}
       msg = f"我叫{dic['name']},今年{dic['age']}"
       print(msg)#我叫alex,今年18
      
       count = 7
       print(f'最终结果是:{count**2}')#最终结果是:49
       name = 'barry'
       msg = f'我的名字是{name.upper()}'
       print(msg)#我的名字是barry
      
       l1 = ['太白金星', 18]
       msg = f'姓名:{l1[0]},年龄:{l1[1]}.'
       print(msg)  # 姓名:太白金星,年龄:18.
      
      (2)结合函数写:可以用函数完成相应的功能,然后将返回值返回到字符串相应的位置
       def _sum(a,b):
           return a + b
       msg = f'最终的结果是:{_sum(10,20)}'
       print(msg)#最终的结果是:30
      
      (3)多行f:
        name = 'barry'
        age = 18
        ajd = 'handsome'
        speaker = f'hi {name}.'\
                  f'you are {age} years old.'\
                  f'you are a {ajd} guy!'
        print(speaker)
      
      (4)其它:
      print(f"{{73}}")  # {73}
      print(f"{{{73}}}")  # {73}
      print(f"{{{{73}}}}")  # {{73}}
      
      注意: ! , : { } ;这些标点不能出现在{} 这里面。
      print(f'{;12}')  # 报错
      # 所以使用lambda 表达式会出现一些问题。
      # 解决方式:可将lambda嵌套在圆括号里面解决此问题。
      x = 5
      print(f'{(lambda x: x*2) (x)}')  # 10

      优点:

      1. 结构更加简化。

      2. 可以结合表达式,函数进行使用。

      3. 效率提升很多。

    3. 迭代器:

      • 可迭代对象:

        字面意思:对象?:python中一切皆对象。一个实实在在存在的值,对象。

        ​ 可迭代?:更新迭代。重复的,循环的一个过程,更新迭代每次都有新的内容,

        ​ 可迭代对象-->可以进行循环更新的一个实实在在值。

        专业角度:可迭代对象--> 内部含有'__iter__'方法的对象,可迭代对象。

        目前学过的可迭代对象:str bytes list tuple dict set range 文件句柄

      • 获取对象的所有方法并且以字符串的形式表现:dir() 会返回一个列表,这个列表中含有该对象的以字符串的形式所有方法名

      • 判断一个对象是否是可迭代对象:

        '__iter__'`  in dir(对象)
        
         s1 = 'asdfghj'
         print(dir(s1))
         print('__iter__' in dir(s1))#true
        
         l1 = [1,2,3]
         print(dir(l1))
         print('__iter__' in dir(l1))#true
        
         b1 = b'wert'
         print(dir(b1))
         print('__iter__' in dir(b1))#true
        
         print('__iter__' in dir(range(10)))#true
        
      • 优缺点:

        • 优点:

          1. 存储的数据直接能打印显示,比较直观。
          2. 拥有的方法比较多,操作方便。
        • 缺点:

          1. 占用内存。

          2. 不能直接通过for循环进行取值,不能直接取值(索引,key除外)。

            • 可迭代对象不能迭代取值(除去索引,key以外)
            • for内部先将可迭代对象转化为迭代器,然后用next对迭代器取值。
      • 迭代器

      • 迭代器的定义

        • 字面意思:更新迭代,器:工具:可更新迭代的工具。
        • 专业角度:内部含有'__iter__'方法并且含有'__next__'方法的对象就是迭代器。
        • 迭代器是这样的对象:实现了无参数的__next__方法,返回序列中的下一个元素,如果没有元素了,那么抛出stopiteration异常.python中的迭代器还实现了__iter__方法,因此迭代器也可以迭代。 出自《流畅的python》
        • 可以判断是否是迭代器:'__iter__' and '__next__' 在不在dir(对象)
      • 判断一个对象是否是迭代器:

        with open('文件1',encoding='utf-8',mode='w') as f1:
            print(('__iter__' in dir(f1)) and ('__next__' in dir(f1)))
        
        目前学过的迭代器:文件句柄
        
         s = 'asdff'
         print('__next__' in dir(s))# false
      • 转化,取值 :

        • 1.可迭代对象转化为迭代器:对可迭代对象操作,形成一个迭代器。str还是str,list还是list

        • 2.对迭代器取值:一个next() 取一个值,少一个next()可以,多一个就会报错.

          • 可迭代对象是不可以一直迭代取值的(除去用索引,切片以及key),但是转化成迭代器就可以了,迭代器是利用__next__()进行取值

          • 迭代器利用next取值:一个next取对应的一个值,如果迭代器里面的值取完了,还要next,那么就报stopiteration的错误。
        s1 = 'asdf'
        obj = iter(s1)  #转化为迭代器
        print(obj)#<str_iterator object at 0x000002216db77828>
        print(next(obj))#a
        print(next(obj))#s
        print(next(obj))#d
        print(next(obj))#f
        
        s1 = 'asdf'
        obj = s1.__iter__()   #转化为迭代器
        print(obj)#<str_iterator object at 0x000001fe307877f0>
        print(obj.__next__())#a
        print(obj.__next__())#s
        print(obj.__next__())#d
        print(obj.__next__())#f
        
        
        l1 = [11,22,33,44,55,66]
        obj = l1.__iter__()
        print(obj)
        print(obj.__next__())  #对迭代器取值
        print(obj.__next__())
        print(obj.__next__())
        print(obj.__next__())
        print(obj.__next__())
        print(obj.__next__())
        
        l1 = [11,22,33,44,55,66]
        obj = iter(l1)
        print(obj)
        print(next(obj))  #对迭代器取
        print(next(obj))
        print(next(obj))
        print(next(obj))
        print(next(obj))
        print(next(obj))
        
        
        #
         l1 = [11,22,33,44,55,66,77,88,99,1010,1111,1212]
         count = 0
         for i in l1:
             if count == 4:
                 break
             else:
                 print(i)
             count += 1
        # # 11
        # # 22
        # # 33
        # # 44
        
         count = 0
         for i in l1:
             if count == 6:
                 break
             else:
                 print(i)
             count += 1
        # # 11
        # # 22
        # # 33
        # # 44
        # # 55
        # # 66
        
        
        
        #迭代器永远会记住取值的位置
         l1 = [11,22,33,44,55,66,77,88,99,1010,1111,1212]
         obj = iter(l1)
         for i in range(4):
             print(next(obj))
        # # 11
        # # 22
        # # 33
        # # 44
        
         for i in range(6):
             print(next(obj))
        # # 55
        # # 66
        # # 77
        # # 88
        # # 99
        # # 1010
        
        
         l1 = [11,22,33,44,55,66,77,88,99,1010,1111,1212]
         for i in l1:
             print(i)
        
        
      • while循环模拟for循环机制【面试经常考】

        将可迭代对象转换成迭代器,然后利用next进行取值,最后利用异常处理处理stopiteration抛出的异常
        l1 = [11,22,33,44,55,66,77,88,99,1111,1133,15652]
        # 将可迭代对象转化成迭代器。
        obj = iter(l1)
        while 1:
            try:
                print(next(obj))
            except stopiteration:
                break
      • 小结:

        • 字面意思:更新迭代,器:工具:可更新迭代的工具。
        • 专业角度:内部含有'__iter__'方法并且含有'__next__'方法的对象就是迭代器。
        • 优点:
          1. 节省内存。
          2. 惰性机制, next一次,取一个值,绝不过多取值。
        • 缺点:
          • 速度慢。
          • 不走回头路。 取值时不走回头路,只能一直向下取值
      • 可迭代对象与迭代器的对比:

        • 可迭代对象:可迭代对象是一个操作方法比较多,比较直观,存储数据相对少(几百万个对象,8g内存是可以承受的)的一个数据集。
        • 应用:当你侧重于对于数据可以灵活处理,并且内存空间足够,将数据集设置为可迭代对象是明确的选择。
        • 迭代器:迭代器是非常节省内存,可以记录取值位置,可以直接通过循环+next方法取值,但是不直观,操作方法比较单一的数据集。
        • 应用:当你的数据量过大,大到足以撑爆你的内存或者你以节省内存为首选因素时,将数据集设置为迭代器是一个不错的选择。
  3. 总结

    1. 格式化输出 ***
    2. 函数名的应用。***
    3. 对比:迭代器是什么? 迭代器的优缺点。可迭代对象转化成迭代器。next取值. ***