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

Dear 丶 2023-08-17 15:24 247阅读 0赞 
  1. ''''''
  2. '''
  3. 我们在用for ... in ...语句循环时，in后面跟随的对象要求是可迭代对象，
  4. 即可以直接作用于for循环的对象统称为可迭代对象（Iterable），如list、tuple、dict、set、str等。
  5. 可迭代对象是实现了__iter__()方法的对象，而迭代器（Iterator）则是实现了__iter__()和__next__()方法的对象，可以显示地获取下一个元素。
  6. 这种可以被next调用并不断返回下一个值的对象称为迭代器。
  7. 迭代器一定是可迭代对象，反过来则不一定成立。
  8. 用iter()函数可以把list、dict、str等Iterable变成Iterator，
  9. 例如：
  10. bb=[x for x in range(10)]
  11. cc=iter(bb)
  12. cc.next()
  13. 循环变量的值其实可以看着是一次次用next取值的过程，每取一个值，做一次处理。
  14. list等对象用于循环实际上可以看着是用iter()方法产生一个迭代器，然后循环取值。
  16. 生成器（generator）就是一个能返回迭代器的函数，其实就是定义一个迭代算法，可以理解为一个特殊的迭代器。
  17. 调用这个函数就得到一个迭代器，生成器中的yield相当于一个断点，执行到此返回一个值后暂停，从而实现next取值。
  18. '''
  20. """
  21. 什么是迭代器
  22. # 可迭代对象执行内置的__iter__方法得到就是该对象的迭代器对象
  23.     迭代:更新换代(重复)的过程,每次的迭代都必须基于上一次的结果
  24.          迭代器和简单的重复循环的区别：每次迭代与上一次的结果是否有关系
  25.          没关系就是见到那的循环重复，有关系 就是迭代
  26.     迭代器:迭代取值的工具
  28. 为什么要用
  29.     迭代器给你提供了一种 不依赖于索引取值 的方式
  31. 如何用
  32. """
  34. # 不算 因为只是简单的重复
  35. # n = 0
  36. # while True:
  37. #     print(n)
  40. # 重复 + 每次迭代都是基于上一次的结果而来的
  41. # l = [1,2,3,4]
  42. # s = 'hello'
  43. # n = 0
  44. # while n < len(s):
  45. #     print(s[n])
  46. #     n += 1
  47. """
  48. 需要迭代取值的数据类型
  49.     字符串
  50.     列表
  51.     元组
  52.     字典
  53.     集合
  54. """
  57. """
  58. # 可迭代对象
  59. # 只有内置有__iter__方法的都叫做可迭代对象
  60. # 可迭代对象执行内置的__iter__方法得到就是该对象的迭代器对象
  63. 补充:针对双下线开头双下划线结尾的方法
  64. 推荐读:双下+方法名
  66. 基本数据类型中
  67.     是可迭代对象的有
  68.         str list tuple dict set 
  69.         文件对象(执行内置的__iter__之后还是本身 没有任何变化):文件对象本身就是迭代器对象
  71. """
  72. # n = 1                                                    # int
  73. # f = 1.1                                                  # float
  74. # s = 'hello'                                              # str
  75. # l = [1, 2, 34, ]                                         # list
  76. # t = (1, 2, 34)                                           # tuple
  77. # s1 = {1, 2, 3, 4}                                        # set
  78. # d = {'name': 'jason'}                                    # dict
  79. # f1 = open('xxx.txt', 'w', encoding='utf-8')              # 文件句柄
  80. #
  81. # print(s.__len__())  # 简化成了len(s)
  82. #
  83. #
  84. # res = s.__iter__()  # res = iter(s)    字符串可迭代 有__iter__方法
  85. # res1 = l.__iter__()  # res1 = iter(l)  列表可迭代    字符串可迭代 有__iter__方法
  86. # res2 = f1.__iter__()  # res2 = iter(f1)  文件句柄可迭代      字符串可迭代 有__iter__方法
  87. # print(res,res1,res2)
  88. # print(f1)
  96. """
  97. 迭代器对象
  98. # 可迭代对象执行内置的__iter__方法得到就是该对象的迭代器对象
  99.     1.内置有__iter__方法    变成迭代器方法，跟自己原来是一样的  is判断为True
  100.     2.内置有__next__方法    取值方法
  101.     ps: 迭代器一定是可迭代对象
  102.         而可迭代对象不一定是迭代器对象
  103. 迭代器取值的特点
  104.     1.只能往后依次取 不能后退
  105. """
  109. # l = [1,2,3,4]
  110. # # 生成一个迭代器对象
  111. # iter_l = l.__iter__()
  112. #
  113. # # 迭代器取值 调用__next__
  114. # print(iter_l.__next__())      # 1
  115. # print(iter_l.__next__())      # 2
  116. # print(iter_l.__next__())      # 3
  117. # print(iter_l.__next__())      # 4
  118. # # print(iter_l.__next__())  # 如果取完了 直接报错
  121. # d = {'name':'jason','password':'123','hobby':'泡m'}
  122. # # 将可迭代对象d转换成迭代器对象
  123. # iter_d = d.__iter__()    # 直接调用方法    可迭代对象.__iter__() = 迭代器对象
  124. # # 迭代器对象的取值 必须用__next__      可迭代对象.__iter__().__next__()   可以这样从迭代器取值
  125. # d.__iter__().__next__()    # 可迭代对象.__iter__().__next__()   可以这样从迭代器取值
  126. # print(iter_d.__next__())
  127. # print(iter_d.__next__())
  128. # print(iter_d.__next__())
  129. # print(iter_d.__next__())  # 取完了 报错StopIteration
  131. f1 = open('xxx.txt','r',encoding='utf-8')
  132. # 调用f1内置的__iter__方法
  133. # iter_f = f1.__iter__()
  134. # print(iter_f is f1)
  135. """
  136. 迭代器对象无论执行多少次__iter__方法得到的还是迭代器对象本身(******)
  137. """
  138. # print(f1 is f1.__iter__().__iter__().__iter__().__iter__())
  139. """
  140. 问:__iter__方法就是用来帮我们生成迭代器对象
  141. 而文件对象本身就是迭代器对象,为什么还内置有__iter__方法???
  142. 因为迭代器对象也支持for循环，需要这个iter方法，作为可迭代对象，迭代器也是可迭代对象，如果没有这个方法，就迭代器不能for循环了
  143. """
  146. # d = {'name':'jason','password':'123','hobby':'泡m'}
  147. #
  148. # print(d.__iter__().__next__())   # name   因为每一次都调用iter制造了一个新的迭代器，每次取值都是第一次取值
  149. # print(d.__iter__().__next__())   # name   因为每一次都调用iter制造了一个新的迭代器，每次取值都是第一次取值
  150. # print(d.__iter__().__next__())   # name   因为每一次都调用iter制造了一个新的迭代器，每次取值都是第一次取值
  151. #
  152. # iter_d = d.__iter__()
  153. # print(iter_d.__next__())   # name     每次取到的值不一样，是依次取值，这个是因为迭代器是同一个迭代器取值三次
  154. # print(iter_d.__next__())   # password 每次取到的值不一样，是依次取值，这个是因为迭代器是同一个迭代器取值三次
  155. # print(iter_d.__next__())   # hobby    每次取到的值不一样，是依次取值，这个是因为迭代器是同一个迭代器取值三次
  156. # # print(iter_d.__next__())  # 取值结束，超过最大数量 会报错
  158. # # 异常处理
  159. # d = {'name':'jason','password':'123','hobby':'泡m'}     # 定义一个字典
  160. # iter_d = d.__iter__()                                   # 调用方法，将字典这个可迭代对象做成迭代器
  161. # while True:                                             # while循环取值
  162. #     try:                                                # 尝试循环取值
  163. #         print(iter_d.__next__())                        # 打印 用字典的迭代器调用发给发next取值
  164. #     except StopIteration:                               # 如果碰到 报错为 StopIteration
  165. #         # print('老母猪生不动了')
  166. #         break                                           # 退出while循环  不会报错
  167. #
  169. # # 文件句柄循环取值，用异常捕获来使超出取值范围之后不报错   同理上
  170. # f = open('xxx.txt','r',encoding='utf-8')              # 值作文件句柄
  171. # iter_f = f.__iter__()                                 # 将文件句柄这个可迭代对象通过调用iter变成迭代器
  172. # # print(iter_f.__next__())                           # 这样一行行取值，超过取值范围会报错
  173. # # print(iter_f.__next__())
  174. # # print(iter_f.__next__())
  175. # # print(iter_f.__next__())
  176. # # print(iter_f.__next__())
  177. # while True:                                           # while循环取值
  178. #     try:                                                # 尝试循环取值
  179. #         print(iter_f.__next__())                             # 打印 用文件句柄的迭代器调用发给发next取值
  180. #     except StopIteration:                               # 如果碰到 报错为 StopIteration
  181. #         print('老母猪生不动了')                               # 打印字符串
  182. #         break                                                # 退出while循环
  187. """
  188. 迭代器取值的特点
  189.     1.只能往后依次取 不能后退
  190. """
  193. # # for循环本质
  194. # d = {'name': 'jason', 'password': '123', 'hobby': '泡m'}
  195. # # for i in d:
  196. # #     print(i)
  197. # # # for循环后面的in关键 跟的是一个可迭代对象   d是一个可迭代对象
  198. #
  199. # for i in 1:    # TypeError: 'int' object is not iterable   整型不是可迭代对象 in后面需要跟可迭代对象
  200. #     pass
  201. # iter(1)
  202. """
  203. for循环内部的本质
  204.     1.将in后面的对象调用__iter__转换成迭代器对象
  205.     2.调用__next__迭代取值
  206.     3.内部有异常捕获StopIteration,当__next__报这个错 自动结束循环
  207. """
  209. # map  zip  方法都是基于for循环
  210. # l = [1,2,3,4]
  211. # res = map(lambda x:x+1,l)     # map的内部原理就是基于for循环，for循环如上，就是嗲用iter做成迭代器，用next取值
  212. # print(map(lambda x:x+1,l))    # <map object at 0x000001D406758A20>  python3中是一个迭代器
  213. # print(res.__next__())         # 可以通过调用next的方法来取值
  214. # print(res.__next__())
  215. # print(res.__next__())
  218. # l1 = [1, 2, 3, 4, 5]
  219. # l2 = ['a', 'b', 'c']
  220. # print(zip(l1, l2))      # <zip object at 0x000001D406768688>   zip方法是基于for循环，返回的是一个迭代器
  221. # res2 = zip(l1, l2)      # 将迭代器赋值给res2
  222. # print(res2.__next__())  # (1, 'a')    可以通过调用next来取值，zip将依次从不同容器中的取出取值，将他们组成一个元组，返回
  225. """
  226. 可迭代对象:内置有__iter__方法的
  227. 迭代器对象:既内置有__iter__也内置有__next__方法
  229. 迭代取值:
  230.     优点
  231.         1.不依赖于索引取值
  232.         2.内存中永远只占一份空间,不会导致内存溢出
  234.     缺点
  235.         1.不能够获取指定的元素
  236.         2.取完之后会报StopIteration错
  238. """
  241. """
  242. 生成器:用户自定义的迭代器,本质就是迭代器
  243. # 函数内如果有yield关键字,那么加括号执行函数的时候并不会触发函数体代码的运行，加括号运行后会返回一个迭代器
  244. # yield后面跟的值就是调用迭代器__next__方法你能得到的值
  245. # yield既可以返回一个值也可以返回多个值 并且多个值也是按照元组的形式返回
  246. def func():            # 函数内如果有yield关键字,那么加括号执行函数的时候并不会触发函数体代码的运行
  247.     print('first')
  248.     yield  666         # yield后面跟的值就是调用迭代器__next__方法你能得到的值
  249. # g = func()           # 生成器初始化:将函数变成迭代器   g就是迭代器   ，有yield的函数，加括号运行后会返回一个迭代器
  250. # print(g.__next__())  #  可以这样从g这个迭代器中取值
  251. """
  253. # def func():
  254. #     print('first')
  255. #     yield  666  # 函数内如果有yield关键字,那么加括号执行函数的时候并不会触发函数体代码的运行
  256. #     print('second')
  257. #     yield  777
  258. #     print('third')
  259. #     yield  888
  260. #     print('forth')
  261. #     yield              # 暂停在这 会打印 forth None
  262. #     yield              # 暂停在这 会打印 None
  263. # # yield后面跟的值就是调用迭代器__next__方法你能得到的值
  264. # # yield既可以返回一个值也可以返回多个值 并且多个值也是按照元组的形式返回
  265. # g = func()  # 生成器初始化:将函数变成迭代器
  266. # print(g)         # <generator object func at 0x00000246A3EDEFC0>  迭代器地址
  267. # print(g.__next__())   # first 666  print自带换行  打印是两行
  268. # print(g.__next__())   # second 777 print自带换行  打印是两行
  269. # print(g.__next__())   # third 888  print自带换行  打印是两行
  270. # print(g.__next__())   # forth None print自带换行  打印是两行
  271. # print(g.__next__())   # None       print自带换行  打印是两行
  276. # # 内置函数range()
  277. # print(range(1,10))       # 内置函数python给提供的
  278. # # range()的使用
  279. # for i in range(1,10,2):  #  从1开始到10 ，步长为2
  280. #     print(i)             # 结果为 1 3 5 7 9 ，peint自带换行
  282. # # 自己写一个这样的 功能
  283. # def my_range(start,end,step=1):  # 定义函数 有三个形参，其实，结束，步长
  284. #     while start < end:           # while循环，如果开始小于结束
  285. #         yield start              # 则返回 开始值
  286. #         start += step            # 开始值 自增长 步长
  287. #
  288. # for j in my_range(1,100,2):     # 打印从1到100，步长为2，所有奇数，
  289. #     # 开始为1，如果1小于100，返回1，开始值变为1增加步长2，
  290. #     # 开始为3，循环3小于100，则打印3，开始值变为3增加步长2，
  291. #     # 开始为5，继续循环
  292. #     print(j)
  297. # # yield支持外界为其传参
  298. # def dog(name):
  299. #     print('%s 准备开吃'%name)
  300. #     while True:
  301. #         food = yield
  302. #         print('%s 吃了 %s'%(name,food))
  303. # # 当函数内有yield关键字的时候,调用该函数不会执行函数体代码，而是将函数变成生成器
  304. # g = dog('egon')    # 调用函数dog，则返回一个生成器，即将dog变为一个自己定义的迭代器，即生成器，打印字符串egon 准备开吃
  305. # res = g.__next__()       # 必须先将代码运行至yield 才能够为其传值，g就是生成器
  306. # print(res)               # None 调用生成器取值，yield后面没有值返回None
  307. # g.send('狗不理包子')  # 给yield左边的变量传参  触发了__next__方法，
  308. # # 用send发送参数，send给迭代器调用next返回的第一个值赋值'狗不理包子' ，赋值给yield的返回值，然后执行函数中的打印，在循环至yield暂停
  309. # g.send('饺子')
  310. # # 用send发送参数，send给迭代器调用next返回的第一个值赋值'饺子' ，赋值给yield的返回值，然后执行函数中的打印，在循环至yield暂停
  313. """
  314. yield
  315.     1.帮你提供了一种自定义生成器方式
  316.     2.会帮你将函数的运行状态暂停住
  317.     3.可以返回值
  319. 与return之间异同点
  320.     相同点:都可以返回值,并且都可以返回多个
  321.     不同点:
  322.         yield可以返回多次值,而return只能返回一次函数立即结束
  323.         yield还可以接受外部传入的值
  324. """
  328. '''
  329. 列表生成式 和 生成器表达式
  330. '''
  331. # # 列表生成式
  332. # res = [i for i in range(1,10) if i != 4]   # [1, 2, 3, 5, 6, 7, 8, 9]
  333. # print(res)              #   列表生成式生成一个列表 [1, 2, 3, 5, 6, 7, 8, 9]
  335. # 生成器表达式
  336. # res1 = (i for i in range(1,100000000) if i != 4)  # 生成器表达式
  337. # print(res1)    # <generator object <genexpr> at 0x0000023B7FF5EFC0> 生成一个生成器
  338. # print(res1.__next__())     # 1
  339. # print(res1.__next__())     # 2
  340. # print(res1.__next__())     # 3
  341. # print(res1.__next__())     # 4
  342. # print(res1.__next__())     # 5
  343. # print(res1.__next__())     # 6
  344. # print(res1.__next__())     # 7
  345. """
  346. # 生成器不会主动执行任何一行代码
  347. # 必须通过__next__触发代码的运行
  348. """
  352. # # 占内存
  353. # f = open('xxx.txt','r',encoding='utf-8')   #打开文件，做文件句柄
  354. # data = f.read()                    # 读取所有内容到内存
  355. # print(len(data))                   # 打印数据长度
  356. # f.close()                          # 关闭文件
  359. # # 计算文件内字符个数
  360. # with open('xxx.txt','r',encoding='utf-8') as f:   # 只读模式打开一个文件 文件句柄为f
  361. #     # n = 0                                       # 设置变量n = 0
  362. #     # for line in f:                              # 循环取值，从文件句柄中一行行读出内容
  363. #     #     n += len(line)                          # 计算循环取出的一行行的字符长度，即字符个数，累加给n
  364. #     # print(n)                                    # 打印n   可以计算出字符个数
  365. #     g = (len(line) for line in f)               # 三元表达式，循环取出line，交给内置函数len 相当与一下一行行取值
  366. #     # for循环的原理就是将文件句柄f，通过调用用iter做成迭代器，然后可以用next循环取值
  367. #     # print(g.__next__())  # 4     换行符\n也算一个值 文件中有三行，每行三个数字，取值len为4是因为有一个是\n换行符
  368. #     # print(g.__next__())  # 4
  369. #     # print(g.__next__())  # 4
  370. #     print(sum(g))        # 求和函数，g是迭代器，求迭代器中所有值的和，即每一行len结果的和
  371. #     # 如果上面三步取值了，则sum再取就是继续迭代取值后面的，有剩余的值就是剩余的值，没有就是0，最后一行没有换行符
  377. #
  378. # # 案例 ;
  379. #
  380. # def add(n,i):                     # 定义函数 add() 需要两个参数
  381. #     return n+i                      # 返回两个参数相加
  382. # def test():                       # 定义一个函数test()
  383. #     for i in range(4):            # 循环从0123中取值
  384. #         yield i                   # 迭代器每次返回一个值
  385. # g=test()                          # 将函数test变成迭代器g，即test加__iter__，g可以调用next
  386. # # 到此只是生成了一个生成器 g = test()   能给出来的值为（0123），但是没有调用生成器，没有next
  387. # for n in [1,10]:                  #   循环从列表中取值 列表中只有两个值
  388. #     g=(add(n,i) for i in g)
  389. # print(n)  # 10
  390. # res=list(g)
  391. # print(res)    # [20, 21, 22, 23]
  392. """
  393. list的本质时for循环生成器取值，到res=list(g)这一步会执行g生成器中的所有代码
  395. for i in (add(10,i) for i in test()):   # 会执行所有的生成器内部的代码
  396.     add(n,i)
  397. """
  399. '''
  400. 第一步  定义函数 add() 需要两个参数
  401.             返回两个参数相加
  402. 第二步  定义一个函数test()
  403.             循环从0123中取值
  404.             迭代器每次返回一个值
  405. 第三步  g=test()                          # 将函数test变成迭代器g，即test加__iter__，g可以调用next
  406.         # 到此只是生成了一个生成器 g = test()   能给出来的值为（0123），但是没有调用生成器，没有next
  408.         将函数test变成迭代器g，即test加__iter__，g可以调用next，或者被for循环
  409. 第四步  第一次for循环g=(add(n,i) for i in test())
  410.         因为n的取值列表中只有两个值1和10，循环两次，循环到10 结束后 ： n = 10 ，在执行下面的步骤
  411.           g =（add(n,i) for i in test())     第一次循环的结果是一个生成器表达式g（第一次for循环等号左边的g）
  412.         此时第一次for循环 循环两次结束后 ： n = 10 产生的生成器g（第一次for循环等号左边的g）不运行，因为没有next，因为没有运行
  413.         第一次for循环 循环两次循环两次结束后 ： n = 10 中的for i in后面的g（第一次for循环等号右边的g）是test()生成器，自定义的迭代器test()
  414.         并且产生一个名字也是g（第一次for循环等号左边的g）的生成器
  415.         第一次for循环  循环两次结束后 ： n = 10  g=(add(n,i) for i in test())
  416.            g =（add(n,i) for i in test()) 
  417.         第一次循环循环两次结束后 ： n = 10  的结果是一个生成器表达式g（第一次for循环等号左边的g）
  418. 第五步  第二次for循环 循环两次后 结束后 ： n = 10   g（第二次for循环等号右边的g），是第一次for循环的生成器g（第一次for循环等号左边的g），
  419.         会产生一个名字也是g（第二次for循环等号右边的g）的生成器
  420.         第二次for循环  循环两次后 结束后 ： n = 10  g=(add(n,i) for i in (add(n,i) for i in test()))
  421.              g=(add(n,i) for i in (add(n,i) for i in test()))
  422.         因为n的取值列表中只有两个值1和10，循环两次，循环到10，结束后 ： n = 10 在执行下面的步骤，print(n)可以查看到n = 10 
  423.         第二次for循环  循环两次结束后 ： n = 10       g=(add(n,i) for i in (add(n,i) for i in test()))
  424.         现在为止还没调用这个生成器，g就是一个生成器表达式（生成器）
  425. 第六步  接下来执行res = res=list(g)，原理是for循环从生成器g中取值，现在带入n = 10，
  426.         g=(add(10,i) for i in (add(10,i) for i in test()))  当i等于 0 1 2 3 时，g给出的值分别为
  427.         i = 0     g = 10 + (10 + 0)      g = 20
  428.         i = 1     g = 10 + (10 + 1)      g = 21
  429.         i = 2     g = 10 + (10 + 2)      g = 22
  430.         i = 3     g = 10 + (10 + 3)      g = 23
  431. 第七步   列表res = [20, 21, 22, 23]
  432. '''
  435. # 常用内置方法
  436. '''
  437. abs()    # 求绝对值，括号里添加数字(只能加一个)
  438. bin(10)  # 十进制转二进制，括号里写十进制
  439. oct(10)    # 十进制转八进制，括号里写十进制
  440. hex(10)    # 十进制转十六进制，括号里写十进制
  441. int('0b1010',2)    # 其他进制转十进制，括号第一个值写其他进制，第二个参数写第一个值是什么进制要转十进制
  442. bool(1)    #  判断的布尔值,括号里可以写int float str set tuple dict     返回布尔值
  443. bytes(s,encoding='utf-8')    # 将字符串转为bytes类型  返回b开头的二进制
  444. callable(index)    #  判断是否可调用，括号可以写函数名，变量名，返回布尔值
  445. chr(97)    #   查看ASCII码表中第97位对应的字符，括号内写数字   ASCII码表 数字转字符
  446. ord('a')    #  查看ASCII码表中该字符对应的数字，括号内写字符   ASCII码表 字符转数字
  447. dir(l)    #  查看改数据可以用的方法，括号内写数据或者变量名
  448. divmod(101,10)    #  计算第一个数除以第二个数，返回元组，元组第一个值位熵值，第二个位余数，可以用作分页器
  449. format 三种玩法()    # {}占位     {index} 索引      {name} 指名道姓 格式化输出
  450. enumerate() 枚举    # for i,j in enumerate(l,1)：print(i,j)  括号第一个值为列表，第二个值为枚举索引从多少开始，不写默认从0开始
  451. eval()      # 识别字符串中的代码，引号引起来里面的代码， eval不支持逻辑代码,只支持一些简单的python代码
  452. exec()    # 识别字符串中的代码，引号引起来里面的代码， 支持逻辑代码
  453. globals()    # 查看全局名称空间中的现存变量和值，在全局名称空间在局部名称空间都能看到
  454. locals()    #  查看当前局部名称空间中的现存变量和值，在全局就看的是全局一样的，在局部就是看局部
  455. help(login)    #  查看函数注释，括号内写函数名
  456. isinstance(n,list)    #  查看某个数据的数据类型是不是什么类型，第一个参数为数据，第二个参数为数据类型，返回 True 或者False
  457. round(3.4)    #  四舍五入，括号内写数值，返回四舍五入的结果
  458. pow(2,3)      #  算次方，第一个参数为底数，第二个参数为指数，表示2的三次方
  459. '''
  462. """
  463. 面向对象需要学习的方法
  464. classmethod
  465. delattr
  466. getattr
  467. hasattr
  468. issubclass
  469. property
  470. repr
  471. setattr
  472. super
  473. staticmethod
  475. """
  480. # print(abs(-11))  # 求绝对值
  481. # # l = [0,1,0]
  482. # # print(all(l))  # 只要有一个为False就返回False
  483. # # print(any(l))  # 只要有一个位True就返回True
  484. # def index():
  485. #
  486. #     username = '我是局部名称空间里面的username'
  487. #     # print(locals())  # 当前语句在哪个位置 就会返回哪个位置所存储的所有的名字
  488. #     print(globals())  # 无论在哪 查看的都是全局名称空间
  489. # index()
  490. # print(bin(10))
  491. # print(oct(10))
  492. # print(hex(10))
  493. # print(int('0b1010',2))
  496. # print(bool(1.1))
  497. # print(bool((1,)))
  500. # s = 'hello'
  501. # print(s.encode('utf-8'))
  502. # print(bytes(s,encoding='utf-8'))
  504. # 可调用的(可以加括号执行相应功能的)
  505. # l = [1,2,3]
  506. # def index():
  507. #     pass
  508. # print(callable(l))
  509. # print(callable(index))
  515. # print(chr(97))  # 将数字转换成ascii码表对应的字符
  516. # print(ord('a'))  # 将字符按照ascii表转成对应的数字
  518. # dir获取当前对象名称空间里面的名字
  519. # l = [1,2,3]
  520. # print(dir(l))
  521. #
  522. # import test
  523. # print(dir(test))
  524. # print(test.name)
  526. # divmod  分页器
  528. # print(divmod(101,10))
  529. # total_num,more = divmod(900,11)
  530. # if more:
  531. #     total_num += 1
  532. # print('总页数:',total_num)
  534. # # enumerate 枚举
  535. # l = ['a','b']
  536. # for i,j in enumerate(l,1):
  537. #     print(i,j)
  539. # eval  exec
  540. # s ="""
  541. # print('hello baby~')
  542. # x = 1
  543. # y = 2
  544. # print(x + y)
  545. # """
  546. # eval(s)
  547. # exec(s)
  549. # eval不支持逻辑代码,只支持一些简单的python代码
  550. # s1 = """
  551. # print(1 + 2)
  552. # for i in range(10):
  553. #     print(i)
  554. # """
  555. # eval(s1)
  556. # exec(s1)
  559. # name = 'jason'
  560. # s2 = """
  561. # name
  562. # """
  563. # print(eval(s2))
  565. # format 三种玩法
  566. # {}占位
  567. # {index} 索引
  568. # {name} 指名道姓
  570. # print(globals())
  571. # def login():
  572. #     """
  573. #     一起嗨皮
  574. #     :return:
  575. #     """
  576. # print(help(login))
  577. #
  578. # # isinstance 后面统一改方法判断对象是否属于某个数据类型
  579. # n = 1
  580. # print(type(n))
  581. # print(isinstance(n,list))  # 判断对象是否属于某个数据类型
  583. # print(pow(2,3))
  586. # print(round(3.4))

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

发表评论

表情：
评论列表 （有 0 条评论，247人围观）

还没有评论，来说两句吧...

相关阅读