常见内置函数、可迭代对象、迭代器对象、for循环内部原理、异常处理、for循环本质、迭代取值与索引取值的对比

今日学习内容总结

常见内置函数

help()

      查看注释信息

  # help()的使用方法
  help(input)
  '''
  Help on built-in function input in module builtins:

  input(prompt=None, /)
      Read a string from standard input.  The trailing newline is stripped.
      
      The prompt string, if given, is printed to standard output without a
      trailing newline before reading input.
      
      If the user hits EOF (*nix: Ctrl-D, Windows: Ctrl-Z+Return), raise EOFError.
      On *nix systems, readline is used if available.
  '''

id()

      返回一串相当于内存地址的数字

  # id()的使用方法
  print(id('jason'))  # 2184106725816

int()

      类型转换、机制转换

  # 类型转换
  a = '18'
  print(type(int(a)))  # <class 'int'>
  
  # 进制转换
  a = 0b10010  # 二进制
  print(int(a))  # 18

isinstance()

      判断数据类型

  # 原本的判断方式
  print(type('jason') is str)  # True 类型判断，很别扭所以不推荐
  # isinstance()方法
  print(isinstance('jason', str))  # True
  print(isinstance('jason', list))  # False

pow()

      幂指数

  print(pow(2, 2))  # 4

round()

      四舍五入,其中第二个参数控制需要保留几位小数

print(round(10, 1))  # 10
print(round(10.22, 1))  # 10.2
print(round(10.66, 1))  # 10.7

sum()

      求和

  
print(sum([1, 2, 3]))  # 6

可迭代对象

      迭代：我们知道，在Python世界里，一切皆对象。对象根据定义的维度，又可以分为各种不同的类型，比如：文件对象，字符串对象，列表对象。。。等等。迭代其实就是更新换代，每一次迭代的过程都需要依赖于上一次的结果。代码示例：

  # 循环不是迭代，因为循环并不依赖上一次的结果。但是依赖上一次结果的循环，也是迭代
  n = 1
  while True:
      print(n)
      n += 1
  # 迭代取值
  a= [1, 2, 3, 4, 5]
  n = 0
  while n < len(l1):
      print(a[n])
      n += 1 

      可迭代对象与迭代器两者并不是相同的：1.可迭代对象包含迭代器。2.如果一个对象拥有__iter__方法，其是可迭代对象；如果一个对象拥有next方法，其是迭代器。3.定义可迭代对象，必须实现__iter__方法；定义迭代器，必须实现__iter__和next方法。

      哪些数据可以是可迭代对象

      依次列举并尝试调用__iter__方法即可判断是否为可迭代对象。而属于可迭代对象的有：字符串、列表、字典、元组、集合、文件对象。可迭代对象其实就是为了后续迭代取值做准备，提供了不依赖于索引取值的方式。

      iter()与next()，对于可迭代对象，可以使用iter()函数得到这些可迭代对象的迭代器，然后对迭代器使用next()函数来获取下一条数据。（iter()函数调用了可迭代对象的__iter__方法）。代码示例：

  a = [1, 2, 3] # 可迭代对象
  b= iter(a) # list1使用__iter__方法,形成迭代器list1_iter
  print(next(b))  # 1
  print(next(b))  # 2
  print(next(b))  # 3
  next(b)  # StopIteration
  
  #  在使用next()迭代完最后一个元素后，再次调用next就会抛出StopIteration异常，以此来告诉我们所
有元素均迭代完成。

迭代器对象

      迭代器对象，可迭代对象调用__iter__方法之后生成的结果就是迭代器对象。迭代器对象的特征，含有__iter__方法和__next__方法。

      迭代器对象能够极大的节省存储空间。因为迭代器对象相当于是，你需要什么，我给你什么，你不需要我就不给。而迭代器的取值方法，调用__next__方法即可，如果取完了则会直接报错!!!代码示例：

s = 'jason'
res = s.__iter__()  # 将res定义成迭代器对象了，所以接下来使用不会产生新的迭代器对象然后取值
print(res.__iter__().__next__())  # j
print(res.__iter__().__next__())  # a
print(res.__iter__().__next__())  # s
print(res.__iter__().__next__())  # o
print(res.__iter__().__next__())  # n
print(res.__iter__().__next__())  

  '''
  Traceback (most recent call last):
    File "C:/Users/Administrator/Desktop/Typora/day15/day15/teset.py", line 8, in <module>
      print(res.__iter__().__next__())
  StopIteration
  '''

  # 这就是如果取完了再取会报错。

for循环内部原理

      1.会将in后面的数据调用__iter__()变成迭代器对象。(文件对象也可以for循环 因为本身就是迭代器对象 再次调用不变)2.针对产生的迭代器对象依次调用__next__()方法迭代取值。3.当值取完之后 会自动处理报错并退出循环。代码示例：

  # 不依赖于for循环,完成对列表元素的取值
  a = [1, 2, 4, 3, 5, 6]

  res = a.__iter__()
  n = 0
  while n < len(a):
      print(res.__next__())
      n += 1

  # 当值取完之后 会自动处理报错并退出循环
  res = a.__iter__()
  while True:
      print(res.__next__())  # StopIteration

异常处理

异常简介

      异常，就是代码运行出现错误。异常会导致程序立刻停止。是我们以后在编程过程中需要极力避免的情况(异常的外号:bug)

      异常信息的组成部分

  '''
  Traceback (most recent call last):
  # 报错
    File "/Users/jiboyuan/PycharmProjects/day16/05 异常处理.py", line 3, in <module>
      name
  NameError: name 'name' is not defined
  '''

    1.line关键字所在的一行
  	用于提示你代码哪一行出错了 点击前面的蓝色字体可以直接定位。如果报错的信息很长 一般最后一个才是
    2.NameError错误的类型
    	代码的报错也可以分为很多类型
    3.name 'name' is not defined
    	具体的报错原因(就是解决报错的答案)
  

      异常的分类

      异常的分类分别是：1.语法异常。这是不被允许出现的，如果出现了必须立刻改正。2.逻辑异常。可以允许出现的，如果出现了尽快修改即可。

      异常的类型

错误类型	详情
AttributeError	试图访问一个对象没有的树形，比如foo.x，但是foo没有属性x
IOError	输入/输出异常；基本上是无法打开文件
ImportError	无法引入模块或包；基本上是路径问题或名称错误
IndentationError	语法错误（的子类） ；代码没有正确对齐
IndexError	下标索引超出序列边界，比如当x只有三个元素，却试图访问x[5]
KeyError	试图访问字典里不存在的键
KeyboardInterrupt	Ctrl+C被按下
TypeError	传入对象类型与要求的不符合
ValueError	传入一个调用者不期望的值，即使值的类型是正确的

异常处理实操

      异常处理可以使用try和except来解决。基本语法结构：

  try:
  可能出错的语句
  except 错误类型 as e: (错误类型必须具体例如：IndexError等也可以写Exception出错时执行语句,e代表错误提示信息,Exception代表统一错误类型)
  else:
  没出错时执行的语句

      异常处理使用尊则：1.被检测的代码越少越好。2.能尽量少用就尽量少用

异常处理了解

      1.结合else使用：

  # 当try检测的代码没有发生异常，正常运行完毕之后执行else的子代码
  try:
    可能会出错的代码
  except Exception as e:  # 检测异常走except子代码
    统一的处理措施
  else:  # # 检测无异常走else子代码
    可能会出错的代码没有出错 最后走else子代码

      2.结合finally使用：

  # 无论try检测的代码是否有异常,最后都会执行finally子代码
  try:
    可能会出错的代码
  except Exception as e:  # 检测异常走except子代码
    统一的处理措施
  else:  # # 检测无异常走else子代码
    可能会出错的代码没有出错 最后走else子代码
    finally:
    无论try检测的代码是否有异常 最后都会执行finally子代码

  # 这也是else与finally的整合使用

      3.断言(了解中的了解)：

    name = 'jason'
    assert isinstance(name,str)

       4.主动报错(需要掌握)：

  raise NameError('不爽 就要作!!!')
  # 由于是主动报错,所以可以非常明确的知道错误的类型

for循环本质

      利用while与异常捕获 实现for循环的功能

  a = [1, 2, 3, 4]
  # 1.先转换成迭代器对象
  # res  = info.__iter__()
  res = iter(a)
  # 2.迭代取值
  while True:
      # print(res.__next__())
      try:
          print(next(res))
      except StopIteration as e:
          # 结束while循环
          break
  # 这样在我们知道报错的类型就可以加以相应的处理措施，就不会报错了。

迭代取值与索引取值的对比

      1.索引取值：优势，可以反复获取相同的元素 并且没有固定的方向。劣势，只能支持有序的容器类型 无序的无法取值兼容性没有迭代取值高。

      2.迭代取值：优势:兼容所有的容器类型。劣势，取值的顺序永远都是从左往右，并且无法重复获取，去完就完了。