[2022.7.11]python常见内置函数及迭代器对象

学习内容目录

• 常见内置函数

• 可迭代对象

• 迭代器对象

• for循环内部原理

  今日内容详细

  常见内置函数

  内置函数：内存于内置空间里 全局可以任意分布由python解释器提前定义好的 直接可以调用的 其功能非常的便捷 好用 可以大大增高写代码的效率

  1.abs()  # 求绝对值
  print(abs(-1312))  # 1312
  "绝对值为正数"
  
  2.all()  # 作用是判断容器内所有的数据值的布尔值是否都为True 
  print(all((1,23,24,3243,54,6546,)))  # True
  print(all((1,23,24,3243,54,6546,0)))  # False 
  print(all((1,23,24,3243,54,6546,{})))  # False
  print(all((1,23,24,3243,54,6546,[])))  # False
  "容器内的每个数据值的布尔值都为 True 结果才为True 只要有一个不为 True 结果都为 False "
  
  3.any()  # 容器内只要有一个数据值的布尔值为 Ture 结果就为 True
  print(any([23,123,4324,354,54]))  # True
  
  4.bin() oct() hex()  # 十进制的转换为其他进制 bin() 二进制 oct() 八进制 hex() 十六进制
  print(bin(100))  # 0b1100100
  print(oct(100))  # 0o144
  print(hex(100))  # 0x64
  
  5.int()  # 类型转换 把其他进制转换为 十进制
  print(int(0b1100100))  # 100 二进制
  print(int(0o144))  # 100 八进制
  print(int(0x64))  # 100 十六进制
  
  6.bytes()  # 类型转换
  res = bytes('为什么', 'utf8')
  print(res)  # b'\xe4\xb8\xba\xe4\xbb\x80\xe4\xb9\x88'
  print(str(res, 'utf8'))  # 为什么
  "bytes 为字节 （涉及到字符编号）把字符串转换为字符编码 也就是计算机可以看懂语言 想转换回来 用字符串类型转换一下就可以了"
  
  7.callable()  # 判断变量加括号是否就可以直接调用了  call 在IT专业名词中的翻译是  调用 + () 加括号执行
  def func():
      print('from func')
  func()  # from func
  
  print(callable(func))  # True
  "上述func为 True 可调用"
  l1 = 'jaosn'
  print(callable(l1))  # False
  " 上述l1 为 False 不可调用 "
  
  8.chr() ord()  # 依据字符编号ASCII码表 实现字符与数字的转换
  print(chr(65))  # A    65-90
  print(chr(97))  # a    97-122
  print(ord('A'))  # 65
  print(ord('a'))  # 97
  
  9.divmod()  # 获取除法后的整数与余数
  print(divmod(10,2))  # (5, 0)  5 是整数 0是余数
  print(divmod(801,4))  # (200, 1)
  10.enumerate()  # 枚举  可以循环打印出数据值并且对应的索引值
  l1 = ['a','b','c','d']
  for i,b in enumerate(l1,1):  # 这里的1 作为索引值可以自定义
      print(i,b)  # 1 a 2 b 3 c 4 d
      
  11.eval() exec()  # 能够识别字符串中的python代码
  res = 'print213'
  print(eval(res))  # 213 eval 能够识别简单的代码
  exec()  # 可以识别复杂结构的代码
  res = "for i in range(20):print(i)"
  exec(res)  # 1 2 3...19
  
  12.hash()  # 返回一串随机数字（哈希值）
  print(hash('make'))  # -433113546
  print(hash('哈哈'))  # 1055926052
  
  13.help()  # 查看帮助信息
  help(input)  # 可以查看到具体的使用方法
  
  14.isinstance()  # 判断数据类型是否属于某个类型的方法
  print(isinstance('jaosn',str))  # True
  print(isinstance('jason',int))  # False
  
  15.pow()  # 幂指数
  print(pow(3,2))  # 9
  
  16.round()  # 用来判定数据值四舍五入的
  print(round(12,3))  # 12  
  print(round(10.5))  # 10 结果不准确 
  "python 对数字运算不敏感"
  

  可迭代对象

  1.迭代的含义

  ​ 迭代就是就是更新换代 每次的更新都以上一个"版本"为基础

  1.2 代码演示：
  while True:
      print(123)
  """不属于迭代  因为每次更新都没有基于上次"版本"为基础"""
  a = 0
  while a < 10:
      print(a)
      a += 1
  """属于迭代 因为每次更新都基于上一次"版本"为基础"""
  1.3 如何判断可迭代对象
  """
  	只要能点出来__iter__方法的都叫可迭代对象
  	__xxx__ 凡是有双下划线开头 双下划线结尾的 这种类型的内置方法 统一读成为双下
  """
  
  分类下以往学习的数据类型 哪些属于可迭代对象
  那些不属于可迭代对象：
  
  # 可迭代对象
  str  # 字符串是可迭代对象
  list  # 列表是可迭代对象
  dict  # 字典是可迭代对象
  tuple  # 元组是可迭代对象
  set  # 集合是可迭代对象
  f = open(r'文件路径','r',encoding='utf8')  # 文件对象是可迭代对象
  
  # 不属于可迭代对象：
  int  # 整型不是可迭代对象
  float  # 浮点型不是可迭代对象
  bool  # 布尔值不是可迭代对象
  def index():  # 函数名不是可迭代对
      
  总结：能够支持for循环的都是可迭代对象
  

  迭代器对象

  作用：
  如果没有迭代器对象 我们取值只能依赖索引取值的方式 并且索引取值在取值方面是不完善的 有了迭代器对象的存在 才能对 字典 集合 这些无序类型进行循环取值 让取值变的更加的方便 完善

  1.如何判断是否 为迭代器对象

  ​ 用点的方式 点出来 内置有__iter__和__next__的对象都成为迭代器对象

  2.可迭代对象与迭代器对象的关系

  ​ 可迭代对象调用__iter__方式之后就变成了迭代器对象

  ​ 迭代器对象调用__iter__方式无论多少次 都是迭代器对象本身 因为本来就已从可迭代对象变身成为迭代器对象了

  3.迭代器对象迭代取值

  res = 'make'.__iter__()
  print(res.__next__())  # m
  print(res.__next__())  # a
  print(res.__next__())  # m
  print(res.__next__())  # e
  print(res.__next__())  # 没有值了 直接报错
  
  d = {'name':'make', 'age':18}
  res = a.__iter__()  # 迭代器对象
  print(res.__next__())  # name
  print(res.__next__())  # age
  
  l1 = [23,3,2,354,3554,645]
  # 循环打印出列表里的所有数据值
  res = l1.__iter__()  # 先将列表变成迭代器对象 方便后期调用
  count = 0  # 设定一个计时器 等于 0
  while count< len(l1):  # 计时器小于列表数据值总和
      print(res.__next__())  # 用__netx__调用
      count += 1  # 计时器每循环一次加一
  

  4.迭代器补充说明

  4.1迭代器反复使用
  l1 = [23,3,2,354,3554,645]
  # print(l1.__iter__().__next__())  # 23
  # print(l1.__iter__().__next__())  # 23
  # print(l1.__iter__().__next__())  # 23
  # print(l1.__iter__().__next__())  # 23
  # print(l1.__iter__().__next__())  # 23
  # print(l1.__iter__().__next__())  # 23
  
  """此结果是每次都产生一个新的迭代器对象"""
  
  
  l1 = [23,3,2,354,3554,645]
  res = l1.__iter__()  
  print(res.__iter__().__next__())  # 23
  print(res.__iter__().__next__())  # 3
  print(res.__iter__().__next__())  # 2
  print(res.__iter__().__next__())  # 354
  print(res.__iter__().__next__())  # 3554
  """ 先定义好迭代器对象 每次都使用一个迭代器对象"""
  
  
  4.2 每次写__iter__ 可以简写为iter()
  		 __netx__ 简写为netx()
  4.3迭代器对象特殊的地方
  	无论是可迭代对象 还是迭代器对象 内部情况 外部都是无法看到的 可以帮您去储存庞大数据 需要的时候可以随时用 大大的帮你节省了内存  类似于百宝箱 多啦a梦的口袋 需要的时候可以帮你造出来
      
  

  for循环的本质

  for循环的语法结构
  	for 变量名 in 可迭代对象：
      	循环体代码
  1.for循环会自动把 in 后面的数据 调用 __iter__()变成迭代器对象
  2.然后每次循环都调用__netx__()的方式去取值
  3.循环到最后没有值的时候 会自动结束 不会报错