函数(六)

内容概要

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

常见内置函数2

    # 1.help()  查看注释信息
    #help(len)

    # 2.id()  返回一串相当于内存地址的数字
    print(id('Tom'))  # 1972274127624

    # 3.int()  类型转换、机制转换

    # 4.isinstance()  判断数据类型
    # print(type('jason') is str)  # 类型判断 别扭的很 不推荐
    print(isinstance('jason', str))  # True
    print(isinstance('jason', int))  # False

    # 5.pow()  幂指数
    print(pow(4,2))  # 16

    # 6.round()  四舍五入
    # print(round(11, 1))  # 第二个参数控制需要保留几位小数部分
    print(round(11.54))  # 12
    print(round(11.45, 1))  # 11.4
    print(round(11.54, 2))  # 11.54

    # 7.sum()求和
    print(sum([11,22,33,3,2,1]))  # 72

可迭代对象

    就是在原有的基础上再加上新的功能，本质就是进行更新换代 
    每一次迭代的过程都需要依赖于上一次的结果
    '例如：游戏的的版本更新 病毒的变异都可以称为迭代'

    # 单纯的循环 不是迭代
    import time
    while True:
        print(123)
        time.sleep(0.1)

    # 属于迭代 每次循环都基于上一次的结果进行加一
    n = 1
    while True:
        print(n)
        n += 1

    内置有__iter__方法的都可以称之为是可迭代对象
      """
      1.简单理解就是数据可以通过点的方式点出来__iter__
      2.__iter__该类代码的读法>>>:双下iter方法
      	千万不要读成杠杠iter杠杠、杠杠iter
      """

哪些数据是可迭代对象

    依次列举并尝试调用__iter__方法即可!!!

    # 属于可迭代对象的有:
        字符串、列表、字典、元组、集合、文件对象
    """
    可迭代对象其实就是为了后续迭代取值做准备
        提供了不依赖于索引取值的方式
    """

迭代器对象

    可迭代对象调用__iter__方法之后生成的结果就是迭代器对象

    含有__iter__方法和__next__方法

    迭代器对象能够极大的节省存储空间

    '''
       eg:类似于哆啦A梦的口袋 不用的时候就是一个口袋的面积 
          用的时候可以从中取出很多数据
          类似于工厂车间 你需要什么我就立刻造什么 你不需要我就不造 节省资源
    '''

    调用__next__方法即可 如果取完了则会直接报错!!!

    ps:开辟了一种不需要索引取值的方式(for循环底层依据的就是迭代器对象)
    '''有了迭代器对象才出现了针对字典和集合的迭代取值操作'''

迭代器对象补充说明

    # 1.有很多双下方法其实都有简便写法 但不是全部
      """
      __方法名__  等价  方法名()
          最为常见的两个是
              __iter__    iter()
              __next__    next()
      """
      print(s.__iter__())
      可写成>>> print(iter(s))

      print(s.__len__())
      可写成>>> print(len(s))

      # 2.有一些可迭代对象本身也是迭代器对象>>>:文件对象

      # 3.可迭代对象调用一次__iter__方法编程迭代器对象  如果继续调用 结果还是迭代器对象本身

for循环的内部原理

    '''需求:不依赖于for循环 完成对列表元素的取值'''
    lt = [1, 2, 3, 4, 5]

    res = lt.__iter__()
    n = 0
    while n < len(lt):
        print(res.__next__())
        n += 1
    """
    for循环底层原理
        for 变量名 in 可迭代对象:
            循环体代码
    1.会将in后面的数据调用__iter__()变成迭代器对象
        为什么文件对象也可以for循环 因为本身就是迭代器对象 再次调用不变
    2.针对产生的迭代器对象依次调用__next__()方法迭代取值
    3.当值取完之后 会自动处理报错并退出循环
    """

异常处理

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

    Traceback (most recent call last):
      File "D:/PyWork/Py基础/day7/草稿.py", line 5, in 
        res = l.__iter__()
    NameError: name 'l' is not defined

    1.line关键字所在的一行
      	用于提示你代码哪一行出错了 点击前面的蓝色字体可以直接定位
        '''如果报错的信息很长 一般最后一个才是'''

    2.NameError错误的类型
      	代码的报错也可以分为很多类型

    3.name 'name' is not defined
      	具体的报错原因(就是解决报错的答案)

异常的分类及类型

    '''异常的分类'''

    1.语法异常
      	不被允许的 如果出现了必须立刻改正
        	eg:if分支结构都不会写...
            	if 1, while :,...

    2.逻辑异常
    	可以允许的 如果出现了尽快修改即可
      	eg:代码动态获取到了一个字符串类型的数据但是调用了列表的内置方法
          name = 'jason'
  	  print(name.append())

  '''异常的类型(有很多 不一一列举)'''
    print(name)  # NameError     名字错误
    l1 = [11, 22, 33]
    print(l1[100])  # IndexError 索引错误
    d = {'name':'jason'}
    print(d['age'])  # KeyError  键错误
    int('jason')  # ValueError   值错误

异常处理办法

    '''
    正常情况下代码出错会直接导致程序的中断停止运行，
    但有时候针对可能出错的代码我们自己可以提前写代码
    来进行处理 避免程序停止
    '''
    # 基本语法
        try:
          可能会出错的代码
        except 错误的类型1 as e:  # e指代的就是错误的提示信息
          针对性的处理措施
        except 错误的类型2 as e:  # e指代的就是错误的提示信息
        ...

    '''万能异常:常见的报错都可以照单全收'''

    #很多时候可能自己都不知道会报什么类型的错误
      try:
        可能会出错的代码
      except Exception as e:  
        统一的处理措施

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

    # 其他处理方法

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

    2.结合finally使用
    无论try检测的代码是否有异常 最后都会执行finally子代码
    try:
        name
    except Exception as e:
      print(e)
    finally:
        print('错了啊！')  # 无论try检测的代码是否有异常 最后都会执行finally子代码

      3.全部整合到一起使用
      try:
          name
      except Exception as e:
          print(e)
      else:
          print('没报错 好极了')
      finally:
          print('管你错不错 都执行')
    
      4.断言(了解中的了解)
    	name = 'jason'
    	assert isinstance(name,str)
 
      5.主动报错(需要掌握)
    	raise NameError('No zuo no die!!!')  # NameError: No zuo no die!!!

      '''由于是主动报错 所以可以非常明确的知道错误的类型'''
        

for循环的本质

    # 利用while与异常捕获 实现for循环的功能
    info = {'name': 'jason', 'age': 18, 'pwd': 123}
    # 1.先转换成迭代器对象
    # res  = info.__iter__()
    res = iter(info)
    # 2.迭代取值
    while True:
        # print(res.__next__())
        try:
            print(next(res))
        except StopIteration as e:
            # 结束while循环
            break

索引取值与迭代取值对比

    1.索引取值
    	优势:可以反复获取相同的元素 并且没有固定的方向
      劣势:只能支持有序的容器类型 无序的无法取值兼容性没有迭代取值高
     
    2.迭代取值
    	优势:兼容所有的容器类型
      劣势:取值的顺序永远都是从左往右 并且无法重复获取 去完就完了
      # 真正底层的迭代取值后续可能很少用 一般都是for循环代替
    
    """
    迭代器里面的东西是固定的 每取一个就会少一个 去完就空了
    """