可迭代对象迭代器对象生成器表达式生成器yield函数

Dear 丶 2023-08-17 15:24 113阅读 0赞

''''''
    '''
    我们在用for ... in ...语句循环时，in后面跟随的对象要求是可迭代对象，
    即可以直接作用于for循环的对象统称为可迭代对象（Iterable），如list、tuple、dict、set、str等。
    可迭代对象是实现了__iter__()方法的对象，而迭代器（Iterator）则是实现了__iter__()和__next__()方法的对象，可以显示地获取下一个元素。
    这种可以被next调用并不断返回下一个值的对象称为迭代器。
    迭代器一定是可迭代对象，反过来则不一定成立。
    用iter()函数可以把list、dict、str等Iterable变成Iterator，
    例如：
    bb=[x for x in range(10)]
    cc=iter(bb)
    cc.next()
    循环变量的值其实可以看着是一次次用next取值的过程，每取一个值，做一次处理。
    list等对象用于循环实际上可以看着是用iter()方法产生一个迭代器，然后循环取值。
    
    生成器（generator）就是一个能返回迭代器的函数，其实就是定义一个迭代算法，可以理解为一个特殊的迭代器。
    调用这个函数就得到一个迭代器，生成器中的yield相当于一个断点，执行到此返回一个值后暂停，从而实现next取值。
    '''
    
    """
    什么是迭代器
    # 可迭代对象执行内置的__iter__方法得到就是该对象的迭代器对象
        迭代:更新换代(重复)的过程,每次的迭代都必须基于上一次的结果
             迭代器和简单的重复循环的区别：每次迭代与上一次的结果是否有关系
             没关系就是见到那的循环重复，有关系 就是迭代
        迭代器:迭代取值的工具
    
    为什么要用
        迭代器给你提供了一种 不依赖于索引取值 的方式
    
    如何用
    """
    
    # 不算 因为只是简单的重复
    # n = 0
    # while True:
    #     print(n)
    
    
    # 重复 + 每次迭代都是基于上一次的结果而来的
    # l = [1,2,3,4]
    # s = 'hello'
    # n = 0
    # while n < len(s):
    #     print(s[n])
    #     n += 1
    """
    需要迭代取值的数据类型
        字符串
        列表
        元组
        字典
        集合
    """
    
    
    """
    # 可迭代对象
    # 只有内置有__iter__方法的都叫做可迭代对象
    # 可迭代对象执行内置的__iter__方法得到就是该对象的迭代器对象
    
    
    补充:针对双下线开头双下划线结尾的方法
    推荐读:双下+方法名
    
    基本数据类型中
        是可迭代对象的有
            str list tuple dict set 
            文件对象(执行内置的__iter__之后还是本身 没有任何变化):文件对象本身就是迭代器对象
    
    """
    # n = 1                                                    # int
    # f = 1.1                                                  # float
    # s = 'hello'                                              # str
    # l = [1, 2, 34, ]                                         # list
    # t = (1, 2, 34)                                           # tuple
    # s1 = {1, 2, 3, 4}                                        # set
    # d = {'name': 'jason'}                                    # dict
    # f1 = open('xxx.txt', 'w', encoding='utf-8')              # 文件句柄
    #
    # print(s.__len__())  # 简化成了len(s)
    #
    #
    # res = s.__iter__()  # res = iter(s)    字符串可迭代 有__iter__方法
    # res1 = l.__iter__()  # res1 = iter(l)  列表可迭代    字符串可迭代 有__iter__方法
    # res2 = f1.__iter__()  # res2 = iter(f1)  文件句柄可迭代      字符串可迭代 有__iter__方法
    # print(res,res1,res2)
    # print(f1)
    
    
    
    
    
    
    
    """
    迭代器对象
    # 可迭代对象执行内置的__iter__方法得到就是该对象的迭代器对象
        1.内置有__iter__方法    变成迭代器方法，跟自己原来是一样的  is判断为True
        2.内置有__next__方法    取值方法
        ps: 迭代器一定是可迭代对象
            而可迭代对象不一定是迭代器对象
    迭代器取值的特点
        1.只能往后依次取 不能后退
    """
    
    
    
    # l = [1,2,3,4]
    # # 生成一个迭代器对象
    # iter_l = l.__iter__()
    #
    # # 迭代器取值 调用__next__
    # print(iter_l.__next__())      # 1
    # print(iter_l.__next__())      # 2
    # print(iter_l.__next__())      # 3
    # print(iter_l.__next__())      # 4
    # # print(iter_l.__next__())  # 如果取完了 直接报错
    
    
    # d = {'name':'jason','password':'123','hobby':'泡m'}
    # # 将可迭代对象d转换成迭代器对象
    # iter_d = d.__iter__()    # 直接调用方法    可迭代对象.__iter__() = 迭代器对象
    # # 迭代器对象的取值 必须用__next__      可迭代对象.__iter__().__next__()   可以这样从迭代器取值
    # d.__iter__().__next__()    # 可迭代对象.__iter__().__next__()   可以这样从迭代器取值
    # print(iter_d.__next__())
    # print(iter_d.__next__())
    # print(iter_d.__next__())
    # print(iter_d.__next__())  # 取完了 报错StopIteration
    
    f1 = open('xxx.txt','r',encoding='utf-8')
    # 调用f1内置的__iter__方法
    # iter_f = f1.__iter__()
    # print(iter_f is f1)
    """
    迭代器对象无论执行多少次__iter__方法得到的还是迭代器对象本身(******)
    """
    # print(f1 is f1.__iter__().__iter__().__iter__().__iter__())
    """
    问:__iter__方法就是用来帮我们生成迭代器对象
    而文件对象本身就是迭代器对象,为什么还内置有__iter__方法???
    因为迭代器对象也支持for循环，需要这个iter方法，作为可迭代对象，迭代器也是可迭代对象，如果没有这个方法，就迭代器不能for循环了
    """
    
    
    # d = {'name':'jason','password':'123','hobby':'泡m'}
    #
    # print(d.__iter__().__next__())   # name   因为每一次都调用iter制造了一个新的迭代器，每次取值都是第一次取值
    # print(d.__iter__().__next__())   # name   因为每一次都调用iter制造了一个新的迭代器，每次取值都是第一次取值
    # print(d.__iter__().__next__())   # name   因为每一次都调用iter制造了一个新的迭代器，每次取值都是第一次取值
    #
    # iter_d = d.__iter__()
    # print(iter_d.__next__())   # name     每次取到的值不一样，是依次取值，这个是因为迭代器是同一个迭代器取值三次
    # print(iter_d.__next__())   # password 每次取到的值不一样，是依次取值，这个是因为迭代器是同一个迭代器取值三次
    # print(iter_d.__next__())   # hobby    每次取到的值不一样，是依次取值，这个是因为迭代器是同一个迭代器取值三次
    # # print(iter_d.__next__())  # 取值结束，超过最大数量 会报错
    
    # # 异常处理
    # d = {'name':'jason','password':'123','hobby':'泡m'}     # 定义一个字典
    # iter_d = d.__iter__()                                   # 调用方法，将字典这个可迭代对象做成迭代器
    # while True:                                             # while循环取值
    #     try:                                                # 尝试循环取值
    #         print(iter_d.__next__())                        # 打印 用字典的迭代器调用发给发next取值
    #     except StopIteration:                               # 如果碰到 报错为 StopIteration
    #         # print('老母猪生不动了')
    #         break                                           # 退出while循环  不会报错
    #
    
    # # 文件句柄循环取值，用异常捕获来使超出取值范围之后不报错   同理上
    # f = open('xxx.txt','r',encoding='utf-8')              # 值作文件句柄
    # iter_f = f.__iter__()                                 # 将文件句柄这个可迭代对象通过调用iter变成迭代器
    # # print(iter_f.__next__())                           # 这样一行行取值，超过取值范围会报错
    # # print(iter_f.__next__())
    # # print(iter_f.__next__())
    # # print(iter_f.__next__())
    # # print(iter_f.__next__())
    # while True:                                           # while循环取值
    #     try:                                                # 尝试循环取值
    #         print(iter_f.__next__())                             # 打印 用文件句柄的迭代器调用发给发next取值
    #     except StopIteration:                               # 如果碰到 报错为 StopIteration
    #         print('老母猪生不动了')                               # 打印字符串
    #         break                                                # 退出while循环
    
    
    
    
    """
    迭代器取值的特点
        1.只能往后依次取 不能后退
    """
    
    
    # # for循环本质
    # d = {'name': 'jason', 'password': '123', 'hobby': '泡m'}
    # # for i in d:
    # #     print(i)
    # # # for循环后面的in关键 跟的是一个可迭代对象   d是一个可迭代对象
    #
    # for i in 1:    # TypeError: 'int' object is not iterable   整型不是可迭代对象 in后面需要跟可迭代对象
    #     pass
    # iter(1)
    """
    for循环内部的本质
        1.将in后面的对象调用__iter__转换成迭代器对象
        2.调用__next__迭代取值
        3.内部有异常捕获StopIteration,当__next__报这个错 自动结束循环
    """
    
    # map  zip  方法都是基于for循环
    # l = [1,2,3,4]
    # res = map(lambda x:x+1,l)     # map的内部原理就是基于for循环，for循环如上，就是嗲用iter做成迭代器，用next取值
    # print(map(lambda x:x+1,l))    # <map object at 0x000001D406758A20>  python3中是一个迭代器
    # print(res.__next__())         # 可以通过调用next的方法来取值
    # print(res.__next__())
    # print(res.__next__())
    
    
    # l1 = [1, 2, 3, 4, 5]
    # l2 = ['a', 'b', 'c']
    # print(zip(l1, l2))      # <zip object at 0x000001D406768688>   zip方法是基于for循环，返回的是一个迭代器
    # res2 = zip(l1, l2)      # 将迭代器赋值给res2
    # print(res2.__next__())  # (1, 'a')    可以通过调用next来取值，zip将依次从不同容器中的取出取值，将他们组成一个元组，返回
    
    
    """
    可迭代对象:内置有__iter__方法的
    迭代器对象:既内置有__iter__也内置有__next__方法
    
    迭代取值:
        优点
            1.不依赖于索引取值
            2.内存中永远只占一份空间,不会导致内存溢出
    
        缺点
            1.不能够获取指定的元素
            2.取完之后会报StopIteration错
    
    """
    
    
    """
    生成器:用户自定义的迭代器,本质就是迭代器
    # 函数内如果有yield关键字,那么加括号执行函数的时候并不会触发函数体代码的运行，加括号运行后会返回一个迭代器
    # yield后面跟的值就是调用迭代器__next__方法你能得到的值
    # yield既可以返回一个值也可以返回多个值 并且多个值也是按照元组的形式返回
    def func():            # 函数内如果有yield关键字,那么加括号执行函数的时候并不会触发函数体代码的运行
        print('first')
        yield  666         # yield后面跟的值就是调用迭代器__next__方法你能得到的值
    # g = func()           # 生成器初始化:将函数变成迭代器   g就是迭代器   ，有yield的函数，加括号运行后会返回一个迭代器
    # print(g.__next__())  #  可以这样从g这个迭代器中取值
    """
    
    # def func():
    #     print('first')
    #     yield  666  # 函数内如果有yield关键字,那么加括号执行函数的时候并不会触发函数体代码的运行
    #     print('second')
    #     yield  777
    #     print('third')
    #     yield  888
    #     print('forth')
    #     yield              # 暂停在这 会打印 forth None
    #     yield              # 暂停在这 会打印 None
    # # yield后面跟的值就是调用迭代器__next__方法你能得到的值
    # # yield既可以返回一个值也可以返回多个值 并且多个值也是按照元组的形式返回
    # g = func()  # 生成器初始化:将函数变成迭代器
    # print(g)         # <generator object func at 0x00000246A3EDEFC0>  迭代器地址
    # print(g.__next__())   # first 666  print自带换行  打印是两行
    # print(g.__next__())   # second 777 print自带换行  打印是两行
    # print(g.__next__())   # third 888  print自带换行  打印是两行
    # print(g.__next__())   # forth None print自带换行  打印是两行
    # print(g.__next__())   # None       print自带换行  打印是两行
    
    
    
    
    # # 内置函数range()
    # print(range(1,10))       # 内置函数python给提供的
    # # range()的使用
    # for i in range(1,10,2):  #  从1开始到10 ，步长为2
    #     print(i)             # 结果为 1 3 5 7 9 ，peint自带换行
    
    # # 自己写一个这样的 功能
    # def my_range(start,end,step=1):  # 定义函数 有三个形参，其实，结束，步长
    #     while start < end:           # while循环，如果开始小于结束
    #         yield start              # 则返回 开始值
    #         start += step            # 开始值 自增长 步长
    #
    # for j in my_range(1,100,2):     # 打印从1到100，步长为2，所有奇数，
    #     # 开始为1，如果1小于100，返回1，开始值变为1增加步长2，
    #     # 开始为3，循环3小于100，则打印3，开始值变为3增加步长2，
    #     # 开始为5，继续循环
    #     print(j)
    
    
    
    
    # # yield支持外界为其传参
    # def dog(name):
    #     print('%s 准备开吃'%name)
    #     while True:
    #         food = yield
    #         print('%s 吃了 %s'%(name,food))
    # # 当函数内有yield关键字的时候,调用该函数不会执行函数体代码，而是将函数变成生成器
    # g = dog('egon')    # 调用函数dog，则返回一个生成器，即将dog变为一个自己定义的迭代器，即生成器，打印字符串egon 准备开吃
    # res = g.__next__()       # 必须先将代码运行至yield 才能够为其传值，g就是生成器
    # print(res)               # None 调用生成器取值，yield后面没有值返回None
    # g.send('狗不理包子')  # 给yield左边的变量传参  触发了__next__方法，
    # # 用send发送参数，send给迭代器调用next返回的第一个值赋值'狗不理包子' ，赋值给yield的返回值，然后执行函数中的打印，在循环至yield暂停
    # g.send('饺子')
    # # 用send发送参数，send给迭代器调用next返回的第一个值赋值'饺子' ，赋值给yield的返回值，然后执行函数中的打印，在循环至yield暂停
    
    
    """
    yield
        1.帮你提供了一种自定义生成器方式
        2.会帮你将函数的运行状态暂停住
        3.可以返回值
    
    与return之间异同点
        相同点:都可以返回值,并且都可以返回多个
        不同点:
            yield可以返回多次值,而return只能返回一次函数立即结束
            yield还可以接受外部传入的值
    """
    
    
    
    '''
    列表生成式 和 生成器表达式
    '''
    # # 列表生成式
    # res = [i for i in range(1,10) if i != 4]   # [1, 2, 3, 5, 6, 7, 8, 9]
    # print(res)              #   列表生成式生成一个列表 [1, 2, 3, 5, 6, 7, 8, 9]
    
    # 生成器表达式
    # res1 = (i for i in range(1,100000000) if i != 4)  # 生成器表达式
    # print(res1)    # <generator object <genexpr> at 0x0000023B7FF5EFC0> 生成一个生成器
    # print(res1.__next__())     # 1
    # print(res1.__next__())     # 2
    # print(res1.__next__())     # 3
    # print(res1.__next__())     # 4
    # print(res1.__next__())     # 5
    # print(res1.__next__())     # 6
    # print(res1.__next__())     # 7
    """
    # 生成器不会主动执行任何一行代码
    # 必须通过__next__触发代码的运行
    """
    
    
    
    # # 占内存
    # f = open('xxx.txt','r',encoding='utf-8')   #打开文件，做文件句柄
    # data = f.read()                    # 读取所有内容到内存
    # print(len(data))                   # 打印数据长度
    # f.close()                          # 关闭文件
    
    
    # # 计算文件内字符个数
    # with open('xxx.txt','r',encoding='utf-8') as f:   # 只读模式打开一个文件 文件句柄为f
    #     # n = 0                                       # 设置变量n = 0
    #     # for line in f:                              # 循环取值，从文件句柄中一行行读出内容
    #     #     n += len(line)                          # 计算循环取出的一行行的字符长度，即字符个数，累加给n
    #     # print(n)                                    # 打印n   可以计算出字符个数
    #     g = (len(line) for line in f)               # 三元表达式，循环取出line，交给内置函数len 相当与一下一行行取值
    #     # for循环的原理就是将文件句柄f，通过调用用iter做成迭代器，然后可以用next循环取值
    #     # print(g.__next__())  # 4     换行符\n也算一个值 文件中有三行，每行三个数字，取值len为4是因为有一个是\n换行符
    #     # print(g.__next__())  # 4
    #     # print(g.__next__())  # 4
    #     print(sum(g))        # 求和函数，g是迭代器，求迭代器中所有值的和，即每一行len结果的和
    #     # 如果上面三步取值了，则sum再取就是继续迭代取值后面的，有剩余的值就是剩余的值，没有就是0，最后一行没有换行符
    
    
    
    
    
    #
    # # 案例 ;
    #
    # def add(n,i):                     # 定义函数 add() 需要两个参数
    #     return n+i                      # 返回两个参数相加
    # def test():                       # 定义一个函数test()
    #     for i in range(4):            # 循环从0123中取值
    #         yield i                   # 迭代器每次返回一个值
    # g=test()                          # 将函数test变成迭代器g，即test加__iter__，g可以调用next
    # # 到此只是生成了一个生成器 g = test()   能给出来的值为（0123），但是没有调用生成器，没有next
    # for n in [1,10]:                  #   循环从列表中取值 列表中只有两个值
    #     g=(add(n,i) for i in g)
    # print(n)  # 10
    # res=list(g)
    # print(res)    # [20, 21, 22, 23]
    """
    list的本质时for循环生成器取值，到res=list(g)这一步会执行g生成器中的所有代码
    
    for i in (add(10,i) for i in test()):   # 会执行所有的生成器内部的代码
        add(n,i)
    """
    
    '''
    第一步  定义函数 add() 需要两个参数
                返回两个参数相加
    第二步  定义一个函数test()
                循环从0123中取值
                迭代器每次返回一个值
    第三步  g=test()                          # 将函数test变成迭代器g，即test加__iter__，g可以调用next
            # 到此只是生成了一个生成器 g = test()   能给出来的值为（0123），但是没有调用生成器，没有next
    
            将函数test变成迭代器g，即test加__iter__，g可以调用next，或者被for循环
    第四步  第一次for循环g=(add(n,i) for i in test())
            因为n的取值列表中只有两个值1和10，循环两次，循环到10 结束后 ： n = 10 ，在执行下面的步骤
              g =（add(n,i) for i in test())     第一次循环的结果是一个生成器表达式g（第一次for循环等号左边的g）
            此时第一次for循环 循环两次结束后 ： n = 10 产生的生成器g（第一次for循环等号左边的g）不运行，因为没有next，因为没有运行
            第一次for循环 循环两次循环两次结束后 ： n = 10 中的for i in后面的g（第一次for循环等号右边的g）是test()生成器，自定义的迭代器test()
            并且产生一个名字也是g（第一次for循环等号左边的g）的生成器
            第一次for循环  循环两次结束后 ： n = 10  g=(add(n,i) for i in test())
               g =（add(n,i) for i in test()) 
            第一次循环循环两次结束后 ： n = 10  的结果是一个生成器表达式g（第一次for循环等号左边的g）
    第五步  第二次for循环 循环两次后 结束后 ： n = 10   g（第二次for循环等号右边的g），是第一次for循环的生成器g（第一次for循环等号左边的g），
            会产生一个名字也是g（第二次for循环等号右边的g）的生成器
            第二次for循环  循环两次后 结束后 ： n = 10  g=(add(n,i) for i in (add(n,i) for i in test()))
                 g=(add(n,i) for i in (add(n,i) for i in test()))
            因为n的取值列表中只有两个值1和10，循环两次，循环到10，结束后 ： n = 10 在执行下面的步骤，print(n)可以查看到n = 10 
            第二次for循环  循环两次结束后 ： n = 10       g=(add(n,i) for i in (add(n,i) for i in test()))
            现在为止还没调用这个生成器，g就是一个生成器表达式（生成器）
    第六步  接下来执行res = res=list(g)，原理是for循环从生成器g中取值，现在带入n = 10，
            g=(add(10,i) for i in (add(10,i) for i in test()))  当i等于 0 1 2 3 时，g给出的值分别为
            i = 0     g = 10 + (10 + 0)      g = 20
            i = 1     g = 10 + (10 + 1)      g = 21
            i = 2     g = 10 + (10 + 2)      g = 22
            i = 3     g = 10 + (10 + 3)      g = 23
    第七步   列表res = [20, 21, 22, 23]
    '''
    
    
    # 常用内置方法
    '''
    abs()    # 求绝对值，括号里添加数字(只能加一个)
    bin(10)  # 十进制转二进制，括号里写十进制
    oct(10)    # 十进制转八进制，括号里写十进制
    hex(10)    # 十进制转十六进制，括号里写十进制
    int('0b1010',2)    # 其他进制转十进制，括号第一个值写其他进制，第二个参数写第一个值是什么进制要转十进制
    bool(1)    #  判断的布尔值,括号里可以写int float str set tuple dict     返回布尔值
    bytes(s,encoding='utf-8')    # 将字符串转为bytes类型  返回b开头的二进制
    callable(index)    #  判断是否可调用，括号可以写函数名，变量名，返回布尔值
    chr(97)    #   查看ASCII码表中第97位对应的字符，括号内写数字   ASCII码表 数字转字符
    ord('a')    #  查看ASCII码表中该字符对应的数字，括号内写字符   ASCII码表 字符转数字
    dir(l)    #  查看改数据可以用的方法，括号内写数据或者变量名
    divmod(101,10)    #  计算第一个数除以第二个数，返回元组，元组第一个值位熵值，第二个位余数，可以用作分页器
    format 三种玩法()    # {}占位     {index} 索引      {name} 指名道姓 格式化输出
    enumerate() 枚举    # for i,j in enumerate(l,1)：print(i,j)  括号第一个值为列表，第二个值为枚举索引从多少开始，不写默认从0开始
    eval()      # 识别字符串中的代码，引号引起来里面的代码， eval不支持逻辑代码,只支持一些简单的python代码
    exec()    # 识别字符串中的代码，引号引起来里面的代码， 支持逻辑代码
    globals()    # 查看全局名称空间中的现存变量和值，在全局名称空间在局部名称空间都能看到
    locals()    #  查看当前局部名称空间中的现存变量和值，在全局就看的是全局一样的，在局部就是看局部
    help(login)    #  查看函数注释，括号内写函数名
    isinstance(n,list)    #  查看某个数据的数据类型是不是什么类型，第一个参数为数据，第二个参数为数据类型，返回 True 或者False
    round(3.4)    #  四舍五入，括号内写数值，返回四舍五入的结果
    pow(2,3)      #  算次方，第一个参数为底数，第二个参数为指数，表示2的三次方
    '''
    
    
    """
    面向对象需要学习的方法
    classmethod
    delattr
    getattr
    hasattr
    issubclass
    property
    repr
    setattr
    super
    staticmethod
    
    """
    
    
    
    
    # print(abs(-11))  # 求绝对值
    # # l = [0,1,0]
    # # print(all(l))  # 只要有一个为False就返回False
    # # print(any(l))  # 只要有一个位True就返回True
    # def index():
    #
    #     username = '我是局部名称空间里面的username'
    #     # print(locals())  # 当前语句在哪个位置 就会返回哪个位置所存储的所有的名字
    #     print(globals())  # 无论在哪 查看的都是全局名称空间
    # index()
    # print(bin(10))
    # print(oct(10))
    # print(hex(10))
    # print(int('0b1010',2))
    
    
    # print(bool(1.1))
    # print(bool((1,)))
    
    
    # s = 'hello'
    # print(s.encode('utf-8'))
    # print(bytes(s,encoding='utf-8'))
    
    # 可调用的(可以加括号执行相应功能的)
    # l = [1,2,3]
    # def index():
    #     pass
    # print(callable(l))
    # print(callable(index))
    
    
    
    
    
    # print(chr(97))  # 将数字转换成ascii码表对应的字符
    # print(ord('a'))  # 将字符按照ascii表转成对应的数字
    
    # dir获取当前对象名称空间里面的名字
    # l = [1,2,3]
    # print(dir(l))
    #
    # import test
    # print(dir(test))
    # print(test.name)
    
    # divmod  分页器
    
    # print(divmod(101,10))
    # total_num,more = divmod(900,11)
    # if more:
    #     total_num += 1
    # print('总页数:',total_num)
    
    # # enumerate 枚举
    # l = ['a','b']
    # for i,j in enumerate(l,1):
    #     print(i,j)
    
    # eval  exec
    # s ="""
    # print('hello baby~')
    # x = 1
    # y = 2
    # print(x + y)
    # """
    # eval(s)
    # exec(s)
    
    # eval不支持逻辑代码,只支持一些简单的python代码
    # s1 = """
    # print(1 + 2)
    # for i in range(10):
    #     print(i)
    # """
    # eval(s1)
    # exec(s1)
    
    
    # name = 'jason'
    # s2 = """
    # name
    # """
    # print(eval(s2))
    
    # format 三种玩法
    # {}占位
    # {index} 索引
    # {name} 指名道姓
    
    # print(globals())
    # def login():
    #     """
    #     一起嗨皮
    #     :return:
    #     """
    # print(help(login))
    #
    # # isinstance 后面统一改方法判断对象是否属于某个数据类型
    # n = 1
    # print(type(n))
    # print(isinstance(n,list))  # 判断对象是否属于某个数据类型
    
    # print(pow(2,3))
    
    
    # print(round(3.4))

转载于:https://www.cnblogs.com/xiaozhenpy/p/11220585.html