函数的迭代器

13. 关键字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())			
    

    2. 可以修改全局变量

       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
    解释器认为：如果你在局部作用域对一个变量进行修改了，你在局部作用域已经定义好这个变量了。
    

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

    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,]
    

15. 函数名的应用

    函数名是一个特殊的变量

    函数名是一个变量

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

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

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

    # 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()()
    

16. 格式化输出

    不区分大小写

    加入表达式

    特殊字符不能放

     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,}')
    

17. 可迭代对象

    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
    #