面向对象 - 1.软件开发/2.异常处理/3.try...except的详细用法

1.软件开发
 软件的开发其实一整套规范，我们所学的只是其中的一小部分，一个完整的开发过程，需要明确每个阶段的任务，在保证一个阶段正确的前提下再进行下一个阶段的工作，称之为软件工程
 面向对象的软件工程包括下面几个部：
    1 面向对象分析（object oriented analysis ，OOA）
    2 面向对象设计（object oriented design，OOD）
    3 面向对象编程（object oriented programming，OOP）
    4 面向对象测试（object oriented test，OOT）
    5 面向对象维护（object oriendted soft maintenance，OOSM）
#面向对象实战 参考  http://www.cnblogs.com/linhaifeng/articles/7341318.html
#作业：http://www.cnblogs.com/linhaifeng/articles/6182264.html

2.异常处理
1.什么是异常：异常是错误发生的信号，一旦程序出错，并且程序没有处理这个错误，那个就会抛出异常，并且程序的运行随之终止
   --异常的追踪信息 异常类 异常值

2.错误分为两种：
  2.1.语法错误  程序执行前就要立刻改正过来
  2.2.逻辑错误
      1.ValueError         int('aaa')
      2.NameError          name
      3.IndexError         l=[1,2,3]  l[100]
      4.KeyError           d={} d['name']
      5.AttributeError     class Foo:pass  Foo.xxx
      6.ZeroDivisionError  1/0
      7.TypeError          for i in 3:pass

3.异常的种类：
   在python中不同的异常可以用不同的类型（python中统一了类与类型，类型即类）去标识，一个异常标识一种错误
   常见异常：
        AttributeError      试图访问一个对象没有的树形，比如foo.x，但是foo没有属性x
        IOError             输入/输出异常；基本上是无法打开文件
        ImportError         无法引入模块或包；基本上是路径问题或名称错误
        IndentationError    语法错误（的子类） ；代码没有正确对齐
        IndexError          下标索引超出序列边界，比如当x只有三个元素，却试图访问x[5]
        KeyError            试图访问字典里不存在的键
        KeyboardInterrupt   Ctrl+C被按下
        NameError           使用一个还未被赋予对象的变量
        SyntaxError         Python代码非法，代码不能编译(个人认为这是语法错误，写错了）
        TypeError           传入对象类型与要求的不符合
        UnboundLocalError   试图访问一个还未被设置的局部变量，基本上是由于另有一个同名的全局变量，导致你以为正在访问它
        ValueError          传入一个调用者不期望的值，即使值的类型是正确的
    更多异常：
        ArithmeticError
        AssertionError
        AttributeError
        BaseException
        BufferError
        BytesWarning
        DeprecationWarning
        EnvironmentError
        EOFError
        Exception
        FloatingPointError
        FutureWarning
        GeneratorExit
        ImportError
        ImportWarning
        IndentationError
        IndexError
        IOError
        KeyboardInterrupt
        KeyError
        LookupError
        MemoryError
        NameError
        NotImplementedError
        OSError
        OverflowError
        PendingDeprecationWarning
        ReferenceError
        RuntimeError
        RuntimeWarning
        StandardError
        StopIteration
        SyntaxError
        SyntaxWarning
        SystemError
        SystemExit
        TabError
        TypeError
        UnboundLocalError
        UnicodeDecodeError
        UnicodeEncodeError
        UnicodeError
        UnicodeTranslateError
        UnicodeWarning
        UserWarning
        ValueError
        Warning
        ZeroDivisionError

4.异常处理  ---》 （不能让程序出错一点异常 就整个崩溃  需要检测异常 ）
  4.1.对于错误发生的条件 如果是可以预知的 此时应该用if 判断去预防异常.
      age=input('>>:').strip()
      if age.isdigit():    # 发生异常是可预知的 把异常拒掉了
         age=int(age)
  4.2.对于错误发生的条件 如果是不可预知的 此时应该用异常处理机制try...except
      try...except 异常已经出现了 捕捉到 可以让程序继续运行
        try:
            ...
        except StopIteration:
            print('出错了')
        print('--------')

 # print('1')
 # int('asd')
 # print('2')

 # nameasa

 # l=[1,2,3]
 # l[100]

 # d={}
 # d['name']

 # class Foo:
 #     pass
 #
 # Foo.xxx

 # 1/0

 # for i in 3:
 #     pass

 # import time
 # time.sleep(1000)

 # ------------------------------
 # AGE=10
 # age=input('>>:').strip()
 # if age.isdigit():
 #     age=int(age)
 #     if age > AGE:
 #         print('猜大了')

 try:
     f=open('a.txt','r',encoding='utf-8')
     print(next(f),end='')
     print(next(f),end='')
     print(next(f),end='')
     print(next(f),end='')
     print(next(f),end='')
     print(next(f),end='')
     f.close()
 except StopIteration:
     print('出错了')

 print('--------')

3.try...except的详细用法
　　1.异常类只能用来处理指定的异常情况，如果非指定异常则无法处理
　　2.多分支:被检测的代码块抛出的异常有多种可能性，并且我们需要针对每一种异常类型都定制专门的处理逻辑
　　3.万能异常：Exception 被检测的代码块抛出的异常有多种可能性，并且我们针对所有的异常类型都只用一种处理逻辑就可以了，那就使用 Exception
　　4.NameError/IndexError  Exception 联合使用
　　5.其他结构 try...except  else  finally #用来回收资源
　　6.主动触发异常：raise  异常类型（值）
　　7.自定义异常类型 ==》 类型=类
　　8.断言assert  下面的代码 依赖上面的代码 的结果
　　9.使用异常时注意：
　　10.什么情况使用异常呢？

 # 1.异常类只能用来处理指定的异常情况，如果非指定异常则无法处理
 #     s1 = 'hello'
 #     try:
 #         int(s1)
 #     except IndexError as e: # 未捕获到异常，程序直接报错
 #         print e

 # 2.多分支:被检测的代码块抛出的异常有多种可能性，
 # 并且我们需要针对每一种异常类型都定制专门的处理逻辑
 # try:
 #     print('---->1')
 #     # name
 #     print('---->2')
 #     l=[1,2,3]
 #     l[100]
 #     print('---->3')
 #     d={}
 #     # d['name']
 #     print('---->4')
 #
 # except NameError as e:
 #     print('---->',e)
 #
 # except IndexError as e:
 #     print('---->', e)
 #
 # except KeyError as e:
 #     print('---->',e)
 #
 # print('after code')

 # 3.万能异常：Exception 被检测的代码块抛出的异常有多种可能性，
 # 并且我们针对所有的异常类型都只用一种处理逻辑就可以了，那就使用 Exception
 # try:
 #     print('---->1')
 #     # name
 #     print('---->2')
 #     l=[1,2,3]
 #     l[100]
 #     print('---->3')
 #     d={}
 #     # d['name']
 #     print('---->4')
 #
 # except Exception as e:
 #     print('异常发生',e)
 #
 # print('after code')

 # 4.NameError/IndexError  Exception 联合使用
 # try:
 #     print('---->1')
 #     # name
 #     print('---->2')
 #     l=[1,2,3]
 #     # l[100]
 #     print('---->3')
 #     d={}
 #     d['name']
 #     print('---->4')
 #
 # except NameError as e:
 #     print('---->',e)
 #
 # except IndexError as e:
 #     print('---->', e)
 #
 # except Exception as e:
 #     print('统一的处理方式',e)
 #
 # print('after code')

 # 5.其他结构 try...except  else  finally #用来回收资源
 # try:
 #     print('---->1')
 #     # name
 #     print('---->2')
 #     l=[1,2,3]
 #     # l[100]
 #     print('---->3')
 #     d={}
 #     # d['name']
 #     print('---->4')
 #
 # except NameError as e:
 #     print('---->',e)
 #
 # except IndexError as e:
 #     print('---->', e)
 #
 # except Exception as e:
 #     print('统一的处理方式',e)
 #
 # else:
 #     print('在被检测的代码块 没有发生异常时 执行')
 #
 # finally:  # 一般在回收资源 时使用
 #     print('不管被检测的代码块 有没有异常 都执行')
 #
 # print('after code')
 # --------------------------------
 # try:
 #     f=open('a.txt','r',encoding='utf-8')
 #     print(next(f), end='')
 #     print(next(f), end='')
 #     print(next(f), end='')
 #     print(next(f), end='')
 #     print(next(f), end='')
 # except Exception as e:
 #     print('统一的处理方式：',e)
 # finally:
 #     f.close()

 # 6.主动触发异常：raise  异常类型（值）
 # class People:
 #     def __init__(self,name,age):
 #         if not isinstance(name,str):
 #             raise TypeError('名字必须传入str')
 #         if not isinstance(age,int):
 #             raise TypeError('年龄必须传入int')
 #         self.name=name
 #         self.age=age

 # p=People('alice',18)
 # p=People(33,18)
 # p=People('alice','19')

 # 7.自定义异常类型 ==》 类型=类
 # class MyException(BaseException):
 #     def __init__(self,msg):
 #         super(MyException, self).__init__()
 #         self.msg=msg
 #
 #     def __str__(self):
 #         return '<%s>'%self.msg
 #
 # raise MyException('我自己的异常类型') # print(obj)

 # 8.断言assert  下面的代码 依赖上面的代码 的结果
 # info={}
 # info['name']='alice'
 # info['age']=18

 # if 'name' not in info:
 #     raise KeyError('必须有name这个key')
 # if 'age' not in info:
 #     raise KeyError('必须有age这个key')

 # assert ('name' in info) and ('age' in info)
 #
 # if info['name']=='alice' and info['age']>10:
 #     print('welcome')

 # 9.使用异常时注意：
 #    不要这样写 失去了写代码的意义
 #    try:
 #        pass
 #    except Exception:
 #        pass

 # 10.什么情况使用异常呢？
 # 1.错误发生的条件能明确的预知  if
 # 2.错误一定会发生，无法预知它发生的条件,不能让程序奔溃掉 才采用try...except