函数的迭代器

函数的迭代器

1. 关键字global，nonlocal

   例：

   ​ count = 0
   ​ def func():
   ​ count += 1
   ​ func()

   在函数中对不能直接对全局变量进行修改

   报错：UnboundLocalError: local variable 'count' referenced before assignment
   解释器认为：如果你在局部作用域对一个变量进行修改了，你在局部作用域已经定义好这个变量了。

   global(剪切):在局部作用域中声明一个全局变量,

   ​ 可以修改全局变量

   def fun():
       global name
       name=1
       print(globais())
       print(locals())
       name+=1
       print(globals())
   fun()
   print(name)
   print(globals())            

   1. 可以修改全局变量

      count=0
      def fun():
       global count
       count+=1
      print(count)
      fun()
      print(count)

   nonlocal(复制)可以对父级作用域的变量进行修改，并且在当前作用域创建（复制）一份此变量

   ​ 不能对全局变量进行操作

   def fun():
       count=0
       def inner():
           nonlocal count
           count+=1
           print(count)
           print(locals())
       inner()
       print(locals)
   fun()
   UnboundLocalError: local variable 'count' referenced before assignment
   解释器认为：如果你在局部作用域对一个变量进行修改了，你在局部作用域已经定义好这个变量了。

2. 默认参数的坑（必考）

   def func(a,b=False):
   #     print(a)
   #     print(b)
   # func(1,True)
   # 当你的默认参数如果是可变的数据类型，你要小心了。
   
   # def func(a,l=[]):
   #     l.append(a)
   #     return l
   # print(func(1))  # [1,]
   # print(func(2))  # [2,]
   # print(func(3))  # [3,]

3. 函数名的应用

   函数名是一个特殊的变量

   函数名是一个变量

   函数名可以作为容器类类型的变量

   函数名可以作为函数的实参

   函数名可以作为函数的返回值

   # a = 1
   # b = 2
   # c = a + b
   # print(c)
   # 函数名是一个特殊的变量。
   # def func():
   #     print(666)
   #
   # print(func)  # func = <function func at 0x00000000003F1EA0>
   # 1,函数名指向的是函数的内存地址,加上()就执行这个函数。
   # func()
   
   # 2函数名是一个变量。
   # age1 = 12
   # age2 = age1
   # age3 = age2
   # print(age3)
   # def func():
   #     print(666)
   #
   # f1 = func
   # f2 = f1
   # f2()
   # f1()
   
   # 3. 函数名可以作为容器类类型的元素。
   # a = 1
   # b = 2
   # c = 3
   # l = [a,b,c]
   # print(l)
   
   # def func1():
   #     print('in func1')
   #
   # def func2():
   #     print('in func2')
   #
   # def func3():
   #     print('in func3')
   #
   # l = [func1, func2, func3]
   # # print(l)
   # for i in l:
   #     i()
   
   # 4. 函数名可以作为函数的实参。
   
   # a = 1
   # def func(argv):
   #     print(argv)
   # func(a)
   
   # def func1():
   #     print('in func1')
   #
   # def func2(argv):
   #     argv()
   #     print('in func2')
   #
   # func2(func1)
   
   # 5. 函数名可以作为函数的返回值。
   
   # b = 666
   #
   # def func1():
   #     print('in func1')
   #
   # def func2(argv):
   #     print('in func2')
   #     return argv
   # ret = func2(b)
   # print(ret)
   
   
   
   # def func1():
   #     print('in func1')
   #
   # def func2(argv):
   #     # argv = func1 : function 43543
   #     print('in func2')
   #     return argv
   # ret = func2(func1)  # func1 : function 43543
   # ret()
   
   # def wrapper():
   #
   #     def inner():
   #         print(666)
   #     return inner
   # # ret = wrapper()
   # # ret()
   # wrapper()()

4. 格式化输出

   不区分大小写

   加入表达式

   特殊字符不能放

    1,不区分大小写
   # num = input('>>>')
   # s = F'python{num}'
   # print(s)
   
   # 可以加入表达式
   
   # s1 = 'alex'
   # s2 = f'我的名字{s1.upper()}'
   # print(s2)
   
   # l1 = ['太白', 18, 176]
   # s1 = f'我的名字{l1[0]}，我的年龄{l1[1]}，我的身高{l1[2]}'
   # print(s1)
   
   # 可以结合函数
   # def func(a,b):
   #     return a + b
   
   # s1 = f'最终的结果{func(1,3)}'
   # print(s1)
   
   # 不能放一些特殊的字符 ! , : { } ;
   # print(f"替换结果{{{73}}}")
   # print(f'{12,}')

5. 可迭代对象

   1. 可迭代对象

      字面意思分析：可以重复的迭代的实实在在的东西。

      list,dict(keys(),values(),items()),tuple,str,set,range, 文件句柄（待定）

      专业角度: 内部含有'__iter__'方法的对象，就是可迭代对象。

      内置函数：dir() print(dir(str))

      判断一个对象是否是可迭代对象： print('iter' in dir(str))

      优点：

      1. 直观。
      2. 操作方法较多。

      缺点：

      1. 占内存。
      2. 不能迭代取值（索引，字典的key）。

   2. 迭代器

      字面意思：可以重复迭代的工具。

      专业角度： 内部含有'__iter__'并且含有"__next__"方法的对象，就是迭代器

      可迭代对象转化成迭代器：

      l1 = [1, 2, 3, 4, 5]
      # 内置函数iter()
      obj = iter(l1)

      # 迭代器可以迭代取值。利用next()进行取值
      l1 = [1, 2, 3, 4, 5]
      # 内置函数iter()
      obj = iter(l1)
      # print(obj)
      print(next(obj))
      print(next(obj))
      print(next(obj))
      print(next(obj))
      print(next(obj))
      print(next(obj))

      迭代器优点：

      1. 非常节省内存。
      2. 惰性机制。

      迭代器缺点：

      1. 不直观。
      2. 操作不灵活。
      3. 效率相对低。

      特性：

      l1 = [22, 33, 44, 55, 66, 77]
      obj = iter(l1)
      
      for i in range(3):
          print(next(obj))
      
      for i in range(2):
          print(next(obj))

      利用while循环，模拟for循环内部循环可迭代对象的机制。

      1. 先要将可迭代对象转化成迭代器。
      2. 利用next对迭代器进行取值。
      3. 利用异常处理try一下防止报错。

   3. 可迭代对象与迭代器的对比

      可迭代对象：可迭代对象是一个操作比较灵活，直观，效率相对高，但是比较占用内存的数据集。

      迭代器：迭代器是一个非常节省内存，满足惰性机制，但是效率相对低，操作不灵活的数据集。

    str
   # list
   # 内置函数：dir()
   # print(dir(str))
   # 判断一个对象是否是可迭代对象：
   # print('__iter__' in dir(str))
   [1,2,3]
   # {'name': 'alex'}
   # 'fdskjalfd'
   
   # 迭代器：
   # with open('调试',encoding='utf-8',mode='w') as f1:
   # #     print(f1)
   
   # print(zip('fdsa','fdsagdfsg'))  # <zip object at 0x00000000029B1D88>
   
   # 可迭代对象转化成迭代器：
   # l1 = [1, 2, 3, 4, 5]
   # # 内置函数iter()
   # obj = iter(l1)  # l1.__iter__()
   # print(obj)  # <list_iterator object at 0x0000000001DEA2E8>
   
   # 迭代器可以迭代取值。利用next()进行取值
   l1 = [1, 2, 3, 4, 5]
   # 内置函数iter()
   obj = iter(l1)
   # print(obj)
   # print(next(obj))
   # print(next(obj))
   # print(next(obj))
   # print(next(obj))
   # print(next(obj))
   # print(next(obj))
   
   # 迭代器一条路走到底，不走回头（记录位置）。
   
   l1 = [22, 33, 44, 55, 66, 77]
   obj = iter(l1)
   
   for i in range(3):
       print(next(obj))
   
   for i in range(2):
       print(next(obj))
   
   # 迭代器：
   
   # 利用while循环，模拟for循环内部循环可迭代对象的机制。
   #1，先要将可迭代对象转化成迭代器。
   #2. 利用next对迭代器进行取值。
   #3. 利用异常处理try一下防止报错。
   # try:
   #     l1 = [1,]
   #     # l1[::2]
   #     l1[100]
   #     # IndexError
   # except IndexError:
   #      pass
   # StopIteration
   # s = 'gkffdsa;lfkdsk;lafkds;laldgjfd'
   # obj = iter(s)
   # while 1:
   #     try:
   #         print(next(obj))
   #     except StopIteration:
   #         break
   #

posted on 2019-06-19 20:10  七橼77 阅读( ...) 评论( ...) 编辑 收藏

转载于:https://www.cnblogs.com/-777/p/11054284.html