【亚洲必赢官网】Python极度管理,相当管理

不行管理格式:

python十分管理,

十分管理格式:

try:
执行语句壹
raise 自定义相当类型()

except 自定义非凡类型:

进行语句二

except (十分类型1,非常类型贰,……):   #多少个要命类型分别用逗号隔断

实行语句三

【亚洲必赢官网】Python极度管理,相当管理。except Exception:        #万能相配,不回去错误类型!

进行语句四

else:

实践语句伍

finally:

施行语句陆

 

粗略表明:

壹.raise 语句能够自定义报错音信,如上。

二.
raise后的口舌是不会被施行了,因为早已抛出至极,调整流将会跳到卓殊捕捉模块。

  1. except
    语句能够叁个except后带多个可怜,也足以用四个语句捕捉三个十分,分别做不一致管理,如果不通晓具体极度类型,最后可用Exception做万能合营。

四.
except语句捕捉的格外假诺未有爆发,那么except里的语句块是不被施行的。而是推行else里的口舌

  1. 在地点语句中try/except/else/finally所出现的相继必须是try–>except
    X–>except–>else–>finally,即全体的except必须在else和finally此前,else(假使有个别话)必须在finally在此以前,而except
    X必须在except在此之前。不然会出现语法错误。

6.else和finally都以可选的.

七.在下边包车型地铁一体化语句中,else语句的留存必须以except
X可能except语句为前提,倘诺在并未有except语句的try
block中动用else语句会引发语法错误。

 

代码例子:

#!/usr/bin/env python
# -*- coding:utf-8 -*-

class MyError(Exception): #自定义一个异常类MyError,继承父类Exception(异常万能类)
    def __init__(self,message):
        self.message = message
        self.code = 100
    def __str__(self):
        return self.message
try:
    def get_num():
        num = int(input("输入一个偶数>>>:").strip())
        if num % 2 != 0:
            raise MyError("错误信息:你输入的不是一个偶数")  # raise语句会自动触发异常
    get_num()
except MyError as e:        # 匹配自定义异常
    print(e)          #提示错误信息
    print("错误代码:%d"%e.code)      #提示错误代码
except ValueError:           # 匹配自带异常
    print("你输入的不是一个整数")
except Exception:
    print("未知错误!")
else:
    print(">>>:输入正确")
finally:
    print("------不管输入是否有误,都执行------")

亚洲必赢官网, 分外管理格式: try: 执行语句一raise 自定义优良类型() except 自定义分外类型: 推行语句二 except
(十分类型1,格外类型贰,……

一.语法错误与充裕

(壹)语法错误

Python 的语法错误只怕叫做解析错,是初大方平常遇到的,如下实例:

>>> while True print('Hello world')
  File "<stdin>", line 1, in <module>
    while True print('Hello world')
                   ^
SyntaxError: invalid syntax

其1例子中,函数 print() 被检查到有不当,是它前面缺乏了一个冒号(:)。

语法分析器建议了失误的一行,并且在第3找到的荒谬的任务标志了三个相当小的箭头。

 (2)异常

纵使Python程序的语法是不错的,在运作它的时候,也有异常的大或许产生错误。运转期检查测试到的谬误被称作十分。

大繁多的相当都不会被程序管理,都是错误新闻的款式表今后调节台:

>>> 10 * (1/0)
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
ZeroDivisionError: division by zero
>>> 4 + spam*3
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
NameError: name 'spam' is not defined
>>> '2' + 2
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: Can't convert 'int' object to str implicitly

老大以差异的连串出现,这个品种都看成音信的壹局地打字与印刷出来: 例子中的类型有
ZeroDivisionError,NameError 和 TypeError。

错误消息的先底部分显得了尤其发生的上下文,并以调用栈的花样体现具体音讯。

一.简介 

  Python有三种错误很轻松辨别:语法错误和极度

  语法错误

  错误是指语法可能是逻辑上的。语法错误提醒软件的布局上的一无所长,导致不能够被解释器可能编译器无健康解析或编写翻译

如:

>>> while True:
...     print("a")
... break
  File "<stdin>", line 3
    break
        ^
SyntaxError: invalid syntax

 2.异常

  老大是因先后
出现了错误而在正规调控流以外使用的作为。大大多的可怜都不会被程序管理,都以错误消息的款式显示

  大规模非常

    1. NameError  #品尝访问叁个未申明的变量
    2. ZeroDivisionError  #除数为零
    3. SyntaxError    
      #python解释器语法错误
    4. IndexError    
       #伸手的目录超越体系范围
    5. KeyError      
       #恳请3个不设有的字典关键字
    6. IOError        
      #输入/输出错误
    7. AttributeError
      #尝试访问未知的靶子属性
    8. keyboardInterrupt
       #用户中断试行(^c)
    9. IndentationError  #缩进错误
    10. TypeError  #对项目无效的操作
    11. ValueError    
      #传播无效的参数 
    12. DeprecationWarning
      #至于被弃用的特点警告
    13. ArithmeticError  
       #具备数值总计错误的基类
    14. SystemExit  
      #解释器请求退出
    15. ImportError
      #导入模块/对象退步
    16. MemoryError #内部存款和储蓄器溢出

try:
实践语句一
raise 自定义分外类型()

二.可怜管理

在编写程序的时候,要是大家精通某段代码大概会促成某种相当,而又不愿意程序以仓库追踪的样式终止,那时大家可以根据须求加多
try/except 或者 try/finally
语句(或然它们的整合)进行拍卖。一般的话,有以下使用方式:

try...except...
try...except...else...
try...except...else...finally...
try...except...except...else...finally...
try...finally...

二.检查评定和管理非凡

  格外可透过try语句来检查测试,任何在try语句块里的代码都会被监测,检查有无差别常发生

  try语句首要有三种样式:try-except 和 try-finally

  1个try语句可以对应一个照旧八个except子句,但不得不对应3个finally子句,或是2个try-execpt-finally复合语句

  能够应用try-except语句检验和拍卖分外,也可以增多壹人可选的else子句管理未有探测到非常的实践代码。

  而try-finally只同意检查测试卓殊并做出一些需求的消除工作(无论爆发错误与否),未有任何尤其管理的设备 

 

  try语句根据如下方式专门的学问:

    •   首先,推行try子句(在重中之重字try和严重性字except之间的口舌)
    •   如果未有丰硕产生,忽略except子句,try子句实行后得了。
    •   若是在奉行try子句的历程中生出了要命,那么try子句余下的部分将被忽视。假设这么些的品类和 except
      之后的称谓相符,那么相应的except子句将被施行。最终执行try 语句之后的代码。
    •   要是二个老大未有与其余的except相配,那么那些特别将会传送给上层的try中

  execpt基本语法

try:
    do something
except Exception[,reason]:
    suite_for_exception_Exception

如:

inp = input("num:")
try:
    num = int(inp)
    print(num)
except Exception as e:
    print("转换失败")

  try except
语句还有叁个可选的else子句,假若选用这几个子句,那么必须放在全数的except子句之后.那个子句就要try子句没有生出任何尤其的时候实施。举例:

inp = input("num:")
try:
    num = int(inp)
    print(num)
except Exception as e:
    print("转换失败")
else:
    print("成功")

  带有八个except的try语句

li = []
inp = input("num:")
try:
    num = li[inp]
except IndexError as I:
    print(I)
except Exception as e:
    print(e)

  捕获全数特别

  Exception

li = []
inp = input("num:")
try:
    num = li[inp]
#Exception捕获所有异常
except Exception as e:
    print(e)

  主动触发分外

#主动触发
try:
    print("123")
    raise Exception("error...")
except Exception as e:
    print(e)

  用户自定义相当

  成立三个新的exception类来全体谐和的不得了。相当应该承袭自 Exception
类,大概直接接轨,大概直接接轨

class Foo():
    def __init__(self,name):
        self.Name = name
    def __str__(self):
        return self.Name
obj = Foo("test")
print(obj)

 2 finally子句

  finally子句是随便非凡与否,是还是不是捕捉到都会实行的壹段代码。语法结构

try:
    A
except:
    B
else:
    C
finally:
    D

  无论格外爆发在A,B,C末了都会实行D

 3 try-finally语句

  另一种选拔finally的办法finally单独和try连用,它和try-except分化在于它不是用来捕捉格外的

  它平时用来给保卫安全1致的一言一动而无论是分外是不是产生。finally代码段都将被实施

def change_pwd(username, password):
    """
    用户修改密码
    :param username: 用户名
    :param password: 修改后的密码
    :return: True修改成功,False修改失败
    """
    file_object = open('log')
    try:
        lines=open('log','r').readlines()
        for i in range(len(lines)):
            if username in lines[i]:
                test=lines[i].split('$')[1]
                lines[i]=lines[i].replace(test,password)
                open('log','w').writelines(lines)
                return True
        return False
    finally:
        file_object.close( )

except 自定义十三分类型:

(一)使用 try/except 捕捉万分

try语句依据如下情势行事;

  • 首先,施行try子句(在注重字try和重视字except之间的语句)
  • 假设未有分外发生,忽略except子句,try子句实施后终止。
  • 万一在实践try子句的进程中爆发了老大,那么try子句余下的一对将被忽略。假诺不行的连串和
    except 之后的名号符合,那么相应的except子句将被推行。最终推行 try
    语句之后的代码。
  • 设若一个不行未有与其余的except匹配,那么那么些可怜将会传递给上层的try中。

3个 try
语句也许包蕴几个except子句,分别来管理区别的特定的百般。最八唯有二个分支会被施行。

管理程序将只针对对应的try子句中的至极实行拍卖,而不是别的的 try
的管理程序中的相当。

八个except子句能够而且管理四个可怜,那个特别将被放在七个括号里成为一个元组,比方:

 except (RuntimeError, TypeError, NameError):
        pass

说起底一个except子句能够忽略极度的称呼,它将被当作通配符使用。你能够接纳那种方法打字与印刷四个错误新闻,然后再一次把非凡抛出。

import sys

try:
    f = open('test.txt')
    s = f.readline()
    i = int(s.strip())
except OSError as err:
    print("OS error: {0}".format(err))
except ValueError:
    print("Could not convert data to an integer.")
except:
    print("Unexpected error:", sys.exc_info()[0])
    raise

try except
语句还有二个可选的else子句,借使使用那几个子句,那么必须放在全部的except子句之后。那一个子句将要try子句未有产生别的十分的时候施行。举个例子:

for arg in sys.argv[1:]:
    try:
        f = open(arg, 'r')
    except IOError:
        print('cannot open', arg)
    else:
        print(arg, 'has', len(f.readlines()), 'lines')
        f.close()

使用 else 子句比把装有的口舌都放在 try
子句里面要好,那样能够免止有个别竟然的、而except又未有捕获的老大。

相当管理并不仅管理那些直接产生在try子句中的十分,而且还是能管理子句中调用的函数(乃至直接调用的函数)里抛出的格外。举个例子:

>>> def this_fails():
        x = 1/0

>>> try:
        this_fails()
    except ZeroDivisionError as err:
        print('Handling run-time error:', err)

Handling run-time error: int division or modulo by zero

 3.触发那么些

 1.raise语句

raise语句对所扶助的参数拾叁分心灵手巧,对应到语法上正是援救广大两样的格式,raise一般用法是

 

raise [SomeException,[, args [, traceback]]]

 

 

  • SomeException 触发这一个的名字,借使有它必须是2个字符串,类或实例

 

  • args
     可选的args(比方参数值)来传送给那些,能够是独自的对象只怕目的的元组
  • traceback 可选参数
    (很少使用),当分外接触时新生成1个用以卓殊–符合规律化的追踪记录对象

二.raise语句用法 

raise
exclass  #接触1个不胜,从exclass生成多个实例(不含任何尤其参数)、

raise exclass()  #透过函数调用操作符(function
calloperator:())功效于类名乱贰个新的exclass实例,同样未有参数

raise exclass,args
#同上,但与此同时提供十二分参数args,能够是1个参数也能够是一个元组

raise exclass,instance  #通超过实际例触发相当,要是实例是exclass的子类实例,那么新监制类型会是子类类型,假设不是也会会是exclass子类,会复制生成新的exclass实例

try:
    正常逻辑
except "Invalid level!":
    触发自定义异常    
else:
    其余代码

#!/usr/bin/python
# -*- coding: UTF-8 -*-

# 定义函数
def myexce( level ):
    if level < 1:
        raise Exception("Invalid level!", level)
        # 触发异常后,后面的代码就不会再执行

try:
    myexec(0)                // 触发异常
except "Invalid level!":
    print 1
else:
    print 2

 

  

推行语句二

(2) finaly子句

finally语句块的内容一般是做一些丧事的拍卖,比方财富自由怎么样的,并且finally语句块是无论怎么样都要进行的,即使在前方的try和except语句块中冒出了return,都现将finally语句推行完再去实施后边的return语句。上面看一个轻巧的事例:

def tryTest():  
    try:  
        den = input("input a number:")  
        x = 1.0/int(den)  
        print x  
        return 1  
    except Exception, e:  
        print e  
        return 0  
    finally:  
        print "this is a finally test"  

result = tryTest()  
print result 

故此无论如何finally语句块中的代码都被实行了,要是此时finally中有个return语句的话,那么全部函数就能够从finally中的return语句中回到,前边的return语句就没用啊。

except (分外类型1,非凡类型二,……): 
 #多少个要命类型分别用逗号隔断

 三. 抛出分外

Python 使用 raise 语句抛出三个点名的尤其。举例:

>>> raise NameError('HiThere')
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
NameError: HiThere

raise
唯壹的1个参数钦定了要被抛出的百般。它必须是1个要命的实例只怕是异常的类(也正是Exception 的子类)。

借让你只想了解那是或不是抛出了2个特别,并不想去管理它,那么3个简练的 raise
语句就足以另行把它抛出。

>>> try:
        raise NameError('HiThere')
    except NameError:
        print('An exception flew by!')
        raise

An exception flew by!
Traceback (most recent call last):
  File "<stdin>", line 2, in <module>
NameError: HiThere

实行语句三

四. 用户自定义1二分

您能够透过创建三个新的exception类来有所和煦的丰盛。至极应该传承自
Exception 类,或然直接接轨,或许间接接轨,举个例子:

>>> class MyError(Exception):
        def __init__(self, value):
            self.value = value
        def __str__(self):
            return repr(self.value)

>>> try:
        raise MyError(2*2)
    except MyError as e:
        print('My exception occurred, value:', e.value)

My exception occurred, value: 4
>>> raise MyError('oops!')
Traceback (most recent call last):
  File "<stdin>", line 1, in ?
__main__.MyError: 'oops!'

在这几个例子中,类 Exception 默许的 __init__() 被覆盖。

当创立二个模块有异常的大希望抛出四种不一致的十分时,一种日常的做法是为这些承包兴构建一个基础十三分类,然后按照那些基础类为不一致的谬误意况创设区别的子类:

class Error(Exception):
    """Base class for exceptions in this module."""
    pass

class InputError(Error):
    """Exception raised for errors in the input.

    Attributes:
        expression -- input expression in which the error occurred
        message -- explanation of the error
    """

    def __init__(self, expression, message):
        self.expression = expression
        self.message = message

class TransitionError(Error):
    """Raised when an operation attempts a state transition that's not
    allowed.

    Attributes:
        previous -- state at beginning of transition
        next -- attempted new state
        message -- explanation of why the specific transition is not allowed
    """

    def __init__(self, previous, next, message):
        self.previous = previous
        self.next = next
        self.message = message

超越4/8的老大的名字都以”Error”结尾,就跟正规的这一个命名同样。

except Exception:       
#万能合作,不回去错误类型!

施行语句四

else:

举行语句五

finally:

实施语句六

 

简短表明:

一.raise 语句能够自定义报错消息,如上。

二.
raise后的说话是不会被实施了,因为已经抛出特别,调控流将会跳到拾分捕捉模块。

  1. except
    语句能够一个except后带三个要命,也能够用八个语句捕捉七个可怜,分别做差别管理,要是不晓得具体格外类型,最终可用Exception做万能相配。

4.
except语句捕捉的丰裕借使未有发出,那么except里的语句块是不被实践的。而是推行else里的说话

  1. 在上边语句中try/except/else/finally所出现的相继必须是try–>except
    X–>except–>else–>finally,即具备的except必须在else和finally以前,else(如若有的话)必须在finally以前,而except
    X必须在except以前。否则会并发语法错误。

陆.else和finally都是可选的.

七.在上头的完好语句中,else语句的存在必须以except
X只怕except语句为前提,假使在尚未except语句的try
block中选择else语句会吸引语法错误。

 

代码例子:

#!/usr/bin/env python
# -*- coding:utf-8 -*-

class MyError(Exception): #自定义一个异常类MyError,继承父类Exception(异常万能类)
    def __init__(self,message):
        self.message = message
        self.code = 100
    def __str__(self):
        return self.message
try:
    def get_num():
        num = int(input("输入一个偶数>>>:").strip())
        if num % 2 != 0:
            raise MyError("错误信息:你输入的不是一个偶数")  # raise语句会自动触发异常
    get_num()
except MyError as e:        # 匹配自定义异常
    print(e)          #提示错误信息
    print("错误代码:%d"%e.code)      #提示错误代码
except ValueError:           # 匹配自带异常
    print("你输入的不是一个整数")
except Exception:
    print("未知错误!")
else:
    print(">>>:输入正确")
finally:
    print("------不管输入是否有误,都执行------")

python所有标准异常类
异常名称 描述
BaseException 所有异常的基类
SystemExit 解释器请求退出
KeyboardInterrupt 用户中断执行(通常是输入^C)
Exception 常规错误的基类
StopIteration 迭代器没有更多的值
GeneratorExit 生成器(generator)发生异常来通知退出
SystemExit Python 解释器请求退出
StandardError 所有的内建标准异常的基类
ArithmeticError 所有数值计算错误的基类
FloatingPointError 浮点计算错误
OverflowError 数值运算超出最大限制
ZeroDivisionError 除(或取模)零 (所有数据类型)
AssertionError 断言语句失败
AttributeError 对象没有这个属性
EOFError 没有内建输入,到达EOF 标记
EnvironmentError 操作系统错误的基类
IOError 输入/输出操作失败
OSError 操作系统错误
WindowsError 系统调用失败
ImportError 导入模块/对象失败
KeyboardInterrupt 用户中断执行(通常是输入^C)
LookupError 无效数据查询的基类
IndexError 序列中没有没有此索引(index)
KeyError 映射中没有这个键
MemoryError 内存溢出错误(对于Python 解释器不是致命的)
NameError 未声明/初始化对象 (没有属性)
UnboundLocalError 访问未初始化的本地变量
ReferenceError 弱引用(Weak reference)试图访问已经垃圾回收了的对象
RuntimeError 一般的运行时错误
NotImplementedError 尚未实现的方法
SyntaxError Python 语法错误
IndentationError 缩进错误
TabError Tab 和空格混用
SystemError 一般的解释器系统错误
TypeError 对类型无效的操作
ValueError 传入无效的参数
UnicodeError Unicode 相关的错误
UnicodeDecodeError Unicode 解码时的错误
UnicodeEncodeError Unicode 编码时错误
UnicodeTranslateError Unicode 转换时错误
Warning 警告的基类
DeprecationWarning 关于被弃用的特征的警告
FutureWarning 关于构造将来语义会有改变的警告
OverflowWarning 旧的关于自动提升为长整型(long)的警告
PendingDeprecationWarning 关于特性将会被废弃的警告
RuntimeWarning 可疑的运行时行为(runtime behavior)的警告
SyntaxWarning 可疑的语法的警告
UserWarning 用户代码生成的警告
网站地图xml地图