python 11 函数名 迭代器

  1. 今日内容大纲

    1. global nonlocal
    2. 函数名的运用
    3. 新特性:格式化输出
    4. 迭代器:
      • 可迭代对象
      • 获取对象的方法
      • 判断一个对象是否是可迭代对象
      • 小结
      • 迭代器
      • 迭代器的定义
      • 判断一个对象是否是迭代器
      • 迭代器的取值
      • 可迭代对象如何转化成迭代器
      • while循环模拟for循环机制
      • 小结
      • 可迭代对象与迭代器的对比
  2. 昨日内容回顾以及作业讲解

    1. 函数的参数:

      1. 实参角度:位置参数,关键字参数,混合参数。
      2. 形参角度:位置参数,默认参数,仅限关键字参数,万能参数。
      3. 形参角度参数顺序:位置参数,*args, 默认参数,仅限关键字参数,**kwargs.
    2. *的魔性用法:
      • 函数的定义时:代表聚合。
      • 函数的调用时:代表打散。
    3. python中存在三个空间:
      • 内置名称空间:存储的内置函数:print,input.......
      • 全局名称空间:py文件,存放的是py文件(除去函数,类内部的)的变量,函数名与函数的内存地址的关系。
      • 局部名称空间:存放的函数内部的变量与值的对应关系。
    4. 加载顺序:内置名称空间,全局名称空间, 局部名称空间(执行函数时)。
    5. 取值顺序:就近原则。LEGB.
      1. 局部作用域只能引用全局变量,不能修改。

        name = 'alex'
        def func():
           name = name + 'sb'
    6. 作用域:
      • 全局作用域:内置名称空间 + 全局名称空间。
      • 局部作用域:局部名称空间。
    7. 函数的嵌套
    8. globals() locals()
  3. 今日内容

    1. global nonlocal

      • 补充:

        默认参数的陷阱

        # 默认参数的陷阱:
        # 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]
        

        局部作用域的坑:

        # count = 1
        # def func():
        #     count += 1
        #     print(count)
        # func()
        
        # 在函数中,如果你定义了一个变量,但是在定义这个变量之前对其引用了,那么解释器认为:语法问题。
        # 你应该在使用之前先定义。
        # count = 1
        # def func():
        #     print(count)
        #     count = 3
        # func()
        
        # print(name)

        global nonlocal

        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. 函数名的运用
      # 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. 新特性:格式化输出
      # %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 文件句柄 其中只有文件句柄是迭代器,可以用__iter__ in dir()先判断是否可迭代,这些都为True,但是用__next__ in dir()时,只有文件句柄为True,但是可以将可迭代对象转化为迭代器,手动循环,下面有解释

      • 获取对象的所有方法并且以字符串的形式表现: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(对象)
      • 判断一个对象是否是迭代器
        with open('文件1',encoding='utf-8',mode='w') as f1:
            print(('__iter__' in dir(f1)) and ('__next__' in dir(f1)))
      • 迭代器的取值
        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循环机制
        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取值. ***
  5. 明日内容

原文地址:https://www.cnblogs.com/miseryGOD/p/10857907.html

时间: 2024-11-05 04:51:54

python 11 函数名 迭代器的相关文章

11.Python初窥门径(函数名,可迭代对象,迭代器)

Python(函数名,可迭代对象,迭代器) 一.默认参数的坑 # 比较特殊,正常来说临时空间执行结束后应该删除,但在这里不是. def func(a,l=[]): l.append(a) return l print(func(1)) # [1] print(func(2)) # [1,2] print(func(3)) # [1,2,3] 二.函数名的应用 函数名指向的是函数的内存地址,加上()就执行这个函数 def func(args): return args print(func) #

python之函数名,闭包、迭代器

一.函数名的运用(第一类对象) 函数名是一个变量,但它是一个特殊的变量,与括号配合可以执行函数的变量. 1,函数名的内存地址: def func(): print("呵呵") print(func) # 结果为:<function func at 0x00000000029299D8> 打印出func的内存地址 2,函数名可以赋值给其他变量: def func(): print("呵呵") a = func # 把函数当成一个变量赋值给另一个变量 a()

第十二天-函数名 迭代器

# 函数名的应用:# 函数名命名与变量相同# 函数名就是变量名,一个特殊的变量,与括号配合可以执行函数的变量,函数名存储的是函数的内存地址 # 函数名的内存地址 1 def func(): 2 print("哈哈") 3 4 print(func) # 打印结果:<function func at 0x000002BA13C199D8> 5 # 直接使用函数名得到的是函数名的内存地址 # 函数名可赋值给变量 1 def func(): 2 print("呵呵&qu

函数名 迭代器 任意表达式 插入表达式 等操作

函数名的作用 1.函数名的内存地址 def func(): print("呵呵") print(func) 结果: <function func at 0x1101e4ea0> 2.函数名可以赋值给其他变量 def func(): print("呵呵") print(func) a = func # 把函数当成一个值赋值给另一个变量 a() # 函数调用 func() 结果: 呵呵 <function func at 0x0000025089261

python动态函数名的研究

所谓动态函数名,就是使用时完全不知道是叫什么名字,可以由用户输入那种. 一般人习惯性会想到eval或exec, 但是众所周知,这样的写法不安全而且容易引起问题,而且不pythonic.而且使用时必须把函数定义写在动态函数名调用之前. def _phyCPU(): print "ok" values = ["_phyCPU"]#, "_proCPU", "_cpuModel"] for value in values: eval

python notice8 函数名应用和闭包

一.函数名的应用 函数名是一个特殊的变量,函数名配合括号(函数名())可以执行函数. 1.函数名的内存地址. def func(): print("呵呵") print(func) 结果: <function func at 0x1101e4ea0> 2.函数名可以赋值给其他变量,该变量配合括号即可调用函数. def func(): print("呵呵") a = func a() # 相当于调用func() 3.可以作为list的元素,for循环调用.

Python基础——函数的迭代器和生成器

等待更新…………………… 后面再写 原文地址:https://www.cnblogs.com/mashangsir/p/11330235.html

python之路---11 第一类对象 函数名 闭包 迭代器

二十九. 1.函数名的运用    ①函数名是?个变量, 但它是?个特殊的变量, 与括号配合可以执?函数的变量 ②函数名是一个内存地址    ③ 函数名可以赋值给其他变量         ④函数名可以当做容器类的元素     ⑤函数名可以当做函数的参数     ⑥函数名可以作为函数的返回值 2.闭包 闭包就是内层函数, 对外层函数(非全局)的变量的引?. 标准的闭包   ①优点:1).可以保护变量不受侵害 2),保持一个变量常驻内存 ②    .__closure__    查看是否是闭包 返回

python函数名的应用、闭包和迭代器

一.函数名的应用(第一类对象) 函数名是一个变量,但它是一个特殊的变量,与括号配合可以执行函数变量. 1.函数名的内存地址 def func(): print("哈哈") print(func) #<function func at 0x000002750A7998C8> 2.函数名可以赋值给其他变量 def func(): print("哈哈") print(func) a = func #把函数当成一个变量赋值给另一个变量 a() #函数调用 fun