今日内容回顾7.11

今日内容回顾

常用内置函数

1. 关键字 ：abs（）

   l = -123
   print(abs(l))  # 123
   print(abs(-12.2))  # 12.2
   # 只针对整型及浮点型
   

2. 关键字 ：all（）与any（）

    l = [ 'dd',1,0,True]
    print(all(l))  # False
   # 数据集中所有数据对应的布尔值全部为True 才返回为True 否则就是False
    print(any(l))  # True
   # 数据集所有的数据有一个对应的是True 就返回True 否则就是 False
   

3. 关键字： bin（2）、oct（8）、hex（16）转换相对应的进制数

   bin, 十进制转换为二进制
   oct，十进制转换为八进制
   hex，十进制转换为十六进制
   

4. 关键字：bytes（） 编码。

   l = '我是类型转换'
   print(bytes(l,'utf8'))  
   # b'\xe6\x88\x91\xe6\x98\xaf\xe7\xb1\xbb\xe5\x9e\x8b\xe8\xbd\xac\xe6\x8d\xa2'
   print(str(b'\xe6\x88\x91\xe6\x98\xaf\xe7\xb1\xbb\xe5\x9e\x8b\xe8\xbd\xac\xe6\x8d\xa2','utf8'))  
   # 我是类型转换
   

5. 关键字：callable（）

    name = 'jason'
   def index(): pass
   print(callable(name))  # False
   print(callable(index))  # True
   # 判断当前名字是否可以加括号调用
   

6. 关键字 ：chr() ord()

   print(chr(65))  # A   将数字转换成ASCII编码表所对应的字符
   print(ord('A'))  # 65 将字符转换成ASCII编码表所对应的数字
   # 根据字符编码表ASCII编码表上存在的字符做出相对应的转换。
   

7. 关键字 ：dir（）

   print(dir(123))
   print(dir('123'))
    # 查看某个数据类型能执行的内置方法有哪些。
   

8. 关键字：divmod （）

   print(divmod(600, 25))  # (24, 0)
   print(divmod(599, 25))  # (23, 24)
   print(divmod(601, 25))  # (24, 1)
   print(599//25) # 23
   print(599%25) # 24
    print(601//25)  # 24
   print(601%25)  # 1
   # 相当于我们学的数学运算中的取整 取余的结合。
   
   # 可以使用在网站分页制作上。
   def a(x, y):    # 粗略的分页器
       k,l = divmod(x, y)
       print(k)  # 20
       print(l)  # 1
       if l:
           k += 1
       print(f'制作网页需要{k}页')  # 制作网页需要21页
   # a(601,30)  
   

9. 关键字： enumerate()

   dict1 = {}
   list1 = ['a','b','c',]
   res  =enumerate(list1)
   print(list(res))
   # [(0, 'a'), (1, 'b'), (2, 'c')]
   for x,y in enumerate(list1,start=1):  # 不写start 默认从0开始
       dict1[x] = y
   print(dict1)  # {1: 'a', 2: 'b', 3: 'c'}
   # 对于一个可迭代的对象 enumerate将其组成一个索引序列，利用它可以同时获得索引和值
   

10. 关键字 ：eval exec （）

    # 能够识别字符串中的python代码
    print('print("我是谁")')  # print("我是谁")
    eval('print("我是谁")')  # 我是谁  eval只能识别简单一点的
    exec('print("我是谁")')  # 我是谁  exec 可以识别逻辑复杂一点的
    

11. 关键字： globals（）

    print(globals())
    # 查看局部名称空间可用的内置函数
    

12. 关键字: isinstance

    print(isinstance('123', int))  # False
    print(isinstance('123', str))  # True
    #判断某个数据是不是你所想的类型 返回结果True 或False
    

13. 关键字 ：pow()

    print(pow(10,3))  # 1000
    print(10**3)  # 1000#
    # 求幂次方和数学运算中的**一样
    

14. 关键字 ：round （）

    print(round(3.3,)) # 3
    print(round(3.3,1)) #  3.3 参数2 控制几位
    # 四舍五入
    

可迭代对象

• 什么是迭代

  迭代就是更新换代，每次迭代都是基于上一次的结果。

  # 代码演示
  count = 0
    while n < 10:
          print(n)
          n += 1
  

• 如和判断是否是可迭代对象

  """
  	内置有__iner__方法的都叫做可迭代对象
  什么是内置
  		通过句点符号直接能够点出来的都叫内置
  
  __xxx__ 针对双下划线开头和结尾的方法统一读作双下xxx
  
  """
  
  	 # int  # 整型不是可迭代对象
      # float  # 浮点型不是可迭代对象
      # str  # 字符串是可迭代对象
      # list  # 列表是可迭代对象
      # dict  # 字典是可迭代对象
      # tuple  # 元组是可迭代对象
      # set  # 集合是可迭代对象
      # bool  # 布尔值不是可迭代对象
      # def index():  # 函数名不是可迭代对象
      #     print()
      # f = open(r'01 考题讲解.py','r',encoding='utf8')  # 文件对象是可迭代对象
  """
  可迭代对象
  		字符串、列表、字典、元组、集合、文件
  		文件本身就是迭代器对象
  不可迭代对象
  		整型、浮点型、布尔值、函数名
  
  可迭代对象能够支持for循环
  
  """
  

迭代器对象

• 迭代器对象作用

  迭代器对象给我们提供了一种不依赖于索引取值的方式

  正式因为有迭代器对象的存在，我们才能对字典、集合等这些无序类型循环取值

• 如何判断迭代器对象

  内置有__ iter __ 和 __ next __ 的对象都称为迭代器对象

• 可迭代对象与迭代器对象的关系

  可迭代对象在调用 __ iter __方法之后都会被转换为迭代器对象

  迭代器对象在调用__ iter __方法之后无论调用多少次还是迭代器本身

• 迭代器对象迭代取值

  res = 'jason'.__iter__()  # res已经是迭代器对象
  print(res.__next__())  # j
  print(res.__next__())  # a
  print(res.__next__())  # s
  print(res.__next__())  # o
  print(res.__next__())  # n
  print(res.__next__())  # 没有了直接报错
  
  d1 = {'name':'jason','pwd':123} 
  res = d1.__iter__()
  print(res.__next__())
  print(res.__next__())
  
  l1 = [11, 22, 33, 44, 55, 66, 77, 88]
  # 需求:不使用for循环 依次打印出列表中所有的数据值
  # 1.先将列表变成迭代器对象
  res = l1.__iter__()
  # 2.定义一个计数器
  count = 0
  # 3.编写while循环
  while count < len(l1):
      print(res.__next__())
      count += 1
  

• 迭代器反复使用

  1. 当一个可迭代对象每次重复调用__ iter __ 和 __ next __的时候都是在可迭代对象本身产生了一个新的迭代器对象

     # 每次都是产生了一个新的迭代器对象,
     l = [11, 22, 33, 44]
     # print(l.__iter__().__next__())  # 11  
     # print(l.__iter__().__next__())  # 11
     # print(l.__iter__().__next__())  # 11
     # print(l.__iter__().__next__())  # 11
     
     

  2. 当一个迭代器对象在重复调用__ iter __ 和 __ next __的时候都是在迭代器对象本身产生了一个新的迭代器对象

     # 每次使用的都是一个迭代器对象
     l = [11, 22, 33, 44]
     res = l.__iter__()
     print(res.__iter__().__next__())  # 11 
     print(res.__iter__().__next__())  # 22
     print(res.__iter__().__next__())  # 33
     print(res.__iter__().__next__())  # 44
     

  3. 针对双下的简写方法

     res = l.__iter__()  
     iter(l)
     # 可以简写iter(l)
     res.__next__() 
     next(res1)
     # 可以简写next(res1)
     

  4. 迭代器对象的特殊地方

     可迭代对象、迭代器对象，通过打印操作无法直接看出内部数据的情况

     这就是他们的特殊之处，相当于是一个工厂你要一个数据它临时帮你造一个数据

     这个时候他们能够帮你节省内存空间。

for循环的本质

语法结构

​ for 变量名 in 可迭代对象：

​ for循环体代码

​ for循环在运行时的低层原理

​ 1. for会自动将in后面的数据调用 __ iter __ 方法改变为迭代器对象

​ 2. 之后每次循环调用 __ next __ ()取值

​ 3.最后 __ next __ 会报错 for 循环能够直接自动处理报错改正常结束！！！