python函数--global,nonlocal ,新格式化输出,迭代器

1. ## 今日内容大纲

   1. global nonlocal
   2. 函数名的运用
   3. 新特性：格式化输出
   4. 迭代器：
      + 可迭代对象
      + 获取对象的方法
      + 判断一个对象是否是可迭代对象
      + 小结
      + 迭代器
      + 迭代器的定义
      + 判断一个对象是否是迭代器
      + 迭代器的取值
      + 可迭代对象如何转化成迭代器
      + while循环模拟for循环机制
      + 小结
      + 可迭代对象与迭代器的对比


  

   

   

3. ## 今日内容

   1. global nonlocal

      + 补充：

        默认参数的陷阱

        ```python
        # 默认参数的陷阱：
        # def func(name,sex=‘男‘):
        #     print(name)
        #     print(sex)
        # func(‘alex‘)
        
        # 陷阱只针对于默认参数是可变的数据类型：
        # def func(name,alist=[]):
        #     alist.append(name)
        #     return alist
        #
        # ret1 = func(‘alex‘)
        # print(ret1,id(ret1))  # [‘alex‘]
        # ret2 = func(‘太白金星‘)
        # print(ret2,id(ret2))  # [‘太白金星‘]
        
        # 如果你的默认参数指向的是可变的数据类型，那么你无论调用多少次这个默认参数，都是同一个。
        
        # def func(a, list=[]):
        #     list.append(a)
        #     return list
        # print(func(10,))  # [10,]
        # print(func(20,[]))  # [20,]
        # print(func(100,))  # [10,100]
        # l1 = []
        # l1.append(10)
        # print(l1)
        # l2 = []
        # l2.append(20)
        # print(l2)
        # l1.append(100)
        # print(l1)
        #
        # def func(a, list= []):
        #     list.append(a)
        #     return list
        # ret1 = func(10,)  # ret = [10,]
        # ret2 = func(20,[])  # [20,]
        # ret3 = func(100,)  # ret3 = [10,100]
        # print(ret1)  # [10,]  [10,100]
        # print(ret2)  # 20,]  [20,]
        # print(ret3)  # [10,100]  [10,100]
        
        ```

        局部作用域的坑：

        ```python
        # 默认参数的陷阱：
        # def func(name,sex=‘男‘):
        #     print(name)
        #     print(sex)
        # func(‘alex‘)
        
        # 陷阱只针对于默认参数是可变的数据类型：
        # def func(name,alist=[]):
        #     alist.append(name)
        #     return alist
        #
        # ret1 = func(‘alex‘)
        # print(ret1,id(ret1))  # [‘alex‘]
        # ret2 = func(‘太白金星‘)
        # print(ret2,id(ret2))  # [‘太白金星‘]
        
        # 如果你的默认参数指向的是可变的数据类型，那么你无论调用多少次这个默认参数，都是同一个。
        
        # def func(a, list=[]):
        #     list.append(a)
        #     return list
        # print(func(10,))  # [10,]
        # print(func(20,[]))  # [20,]
        # print(func(100,))  # [10,100]
        # l1 = []
        # l1.append(10)
        # print(l1)
        # l2 = []
        # l2.append(20)
        # print(l2)
        # l1.append(100)
        # print(l1)
        #
        # def func(a, list= []):
        #     list.append(a)
        #     return list
        # ret1 = func(10,)  # ret = [10,]
        # ret2 = func(20,[])  # [20,]
        # ret3 = func(100,)  # ret3 = [10,100]
        # print(ret1)  # [10,]  [10,100]
        # print(ret2)  # 20,]  [20,]
        # print(ret3)  # [10,100]  [10,100]
        
        ```

        global nonlocal

        ```python
        global
        1, 在局部作用域声明一个全局变量。
        name = ‘alex‘
        
        def func():
            global name
            name = ‘太白金星‘
            # print(name)
        func()
        print(name)
        
        
        def func():
            global name
            name = ‘太白金星‘
        # print(name)
        print(globals())
        func()
        # print(name)
        print(globals())
        
        2. 修改一个全局变量
        count = 1
        def func():
            # print(count)
            global count
            count += 1
        print(count)
        func()
        print(count)
        
        
        nonlocal
        
        1. 不能够操作全局变量。
        count = 1
        def func():
            nonlocal count
            count += 1
        func()
        2. 局部作用域：内层函数对外层函数的局部变量进行修改。
        
        def wrapper():
            count = 1
            def inner():
                nonlocal count
                count += 1
            print(count)
            inner()
            print(count)
        wrapper()
        ```

        

   2. 函数名的运用

      ```python
      # def func():
      #     print(666)
      #
      # # func()
      # # 1. 函数名指向的是函数的内存地址。
      # # 函数名 + ()就可以执行次函数。
      # # a = 1
      # # a()
      # # func()
      # # a = {‘name‘: ‘alex‘}
      # # b = {‘age‘ : 18}
      # # a = 1
      # # b = 2
      # # print(a + b)
      # print(func,type(func))  # <function func at 0x000001BA864E1D08>
      # func()
      
      # 2, 函数名就是变量。
      # def func():
      #     print(666)
      
      # a = 2
      # b = a
      # c = b
      # print(c)
      # f = func
      # f1 = f
      # f2 = f1
      # f()
      # func()
      # f1()
      # f2()
      #
      # def func():
      #     print(‘in func‘)
      #
      # def func1():
      #     print(‘in func1‘)
      #
      # func1 = func
      # func1()
      # a = 1
      # b = 2
      # a = b
      # print(a)
      
      # 3. 函数名可以作为容器类数据类型的元素
      
      # def func1():
      #     print(‘in func1‘)
      #
      # def func2():
      #     print(‘in func2‘)
      #
      # def func3():
      #     print(‘in func3‘)
      # # a = 1
      # # b = 2
      # # c = 3
      # # l1 = [a,b,c]
      # # print(l1)
      # l1 = [func1,func2,func3]
      # for i in l1:
      #     i()
      
      # 4. 函数名可以作为函数的参数
      
      # def func(a):
      #     print(a)
      #     print(‘in func‘)
      # b = 3
      # func(b)
      # print(func)
      
      # def func():
      #     print(‘in func‘)
      #
      # def func1(x):
      #     x()  # func()
      #     print(‘in func1‘)
      #
      # func1(func)
      
      # 5. 函数名可以作为函数的返回值
      def func():
          print(‘in func‘)
      
      def func1(x): # x = func
          print(‘in func1‘)
          return x
      
      ret = func1(func)  # func
      ret()  # func()
      
      ```

      

   3. 新特性：格式化输出

      ```python
      # %s format
      # name = ‘太白‘
      # age = 18
      # msg = ‘我叫%s,今年%s‘ %(name,age)
      # msg1 = ‘我叫{},今年{}‘.format(name,age)
      
      # 新特性：格式化输出
      # name = ‘太白‘
      # age = 18
      # msg = f‘我叫{name},今年{age}‘
      # print(msg)
      
      # 可以加表达式
      # dic = {‘name‘:‘alex‘,‘age‘: 73}
      # msg = f‘我叫{dic["name"]},今年{dic["age"]}‘
      # print(msg)
      
      # count = 7
      # print(f‘最终结果：{count**2}‘)
      # name = ‘barry‘
      # msg = f‘我的名字是{name.upper()}‘
      # print(msg)
      
      # 结合函数写：
      def _sum(a,b):
          return a + b
      
      msg = f‘最终的结果是：{_sum(10,20)}‘
      print(msg)
      # ! , : { } ;这些标点不能出现在{} 这里面。
      
      ```

      优点：

      1. 结构更加简化。

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

      3. 效率提升很多。

         

   4. 迭代器：

      - 可迭代对象

        字面意思：对象？python中一切皆对象。一个实实在在存在的值，对象。

        可迭代？：更新迭代。重复的，循环的一个过程，更新迭代每次都有新的内容，

        可以进行循环更新的一个实实在在值。

        专业角度：可迭代对象？ 内部含有`‘__iter__‘`方法的对象，可迭代对象。

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

      - 获取对象的所有方法并且以字符串的形式表现：dir()

      - 判断一个对象是否是可迭代对象

        ```
        s1 = ‘fjdskl‘
        # l1 = [1,2,3]
        # # print(dir(s1))
        # print(dir((l1)))
        # print(‘__iter__‘ in dir(s1))
        # print(‘__iter__‘ in dir(range(10)))
        ```

      - 小结

        - 字面意思：可以进行循环更新的一个实实在在值。

        - 专业角度： 内部含有`‘__iter__‘`方法的对象，可迭代对象。

        - 判断一个对象是不是可迭代对象： `‘__iter__‘`  in dir(对象)

        - str list tuple dict set range 

        - 优点：

          1. 存储的数据直接能显示，比较直观。
          2. 拥有的方法比较多，操作方便。

        - 缺点：

          1. 占用内存。

          2. 不能直接通过for循环，不能直接取值（索引，key）。

             

      - 迭代器

      - 迭代器的定义

        - 字面意思：更新迭代，器：工具：可更新迭代的工具。
        - 专业角度：内部含有`‘__iter__‘`方法并且含有`‘__next__‘`方法的对象就是迭代器。
        - 可以判断是否是迭代器：`‘__iter__‘` and `‘__next__‘` 在不在dir(对象)

      - 判断一个对象是否是迭代器  

        ```python
        with open(‘文件1‘,encoding=‘utf-8‘,mode=‘w‘) as f1:
            print((‘__iter__‘ in dir(f1)) and (‘__next__‘ in dir(f1)))
        ```

        

      - 迭代器的取值  

        ```python
        s1 = ‘fjdag‘
        obj = iter(s1)  # s1.__iter__()
        # print(obj)
        # print(next(obj)) # print(obj.__next__())
        # print(next(obj)) # print(obj.__next__())
        # print(next(obj)) # print(obj.__next__())
        # print(next(obj)) # print(obj.__next__())
        # print(next(obj)) # print(obj.__next__())
        # print(next(obj)) # print(obj.__next__())
        
        # l1 = [11,22,33,44,55,66]
        # obj = iter(l1)
        # print(next(obj))
        # print(next(obj))
        # print(next(obj))
        # print(next(obj))
        # print(next(obj))
        # print(next(obj))
        
        
        ```

        

      - 可迭代对象如何转化成迭代器

        `iter([1,2,3])`

      - while循环模拟for循环机制

        ```python
        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方法取值，但是不直观，操作方法比较单一的数据集。
        -  当你的数据量过大，大到足以撑爆你的内存或者你以节省内存为首选因素时，将数据集设置为迭代器是一个不错的选择。

4. ## 今日总结

   1. 默认参数的坑，作用域的坑  ***
   2. 格式化输出 ***
   3. 函数名的应用。***
   4. 对比：迭代器是什么？ 迭代器的优缺点。可迭代对象转化成迭代器。next取值.  ***

1. 可迭代对象：
+ 可以更新迭代的实实在在值。
+ 内部含有`‘__iter__‘`方法的。
+ str list tuple dict set range
+ 优点：操作方法多，操作灵活，直观，
+ 缺点：占用内存。
2. 迭代器：
+ 可以更新迭代的一个工具（数据结构）。
+ 内部含有`‘__iter__‘``且含有__next__方法的`的。
+ 文件句柄。
+ 优点：节省内存。惰性机制。
+ 缺点：不直观，速度相对慢，操作方法单一，不走回头。

3. 格式化输出。
4. 函数名的应用。
5. 默认参数可变的数据类型坑。作用域的坑。