python3--面向对象内置方法例子,python异常处理
python3--面向对象内置方法例子,python异常处理
from collections import namedtuple
Card = namedtuple('Card', ['ranks', 'suits'])
class FranchDeck:
ranks = [str(n) for n in range(2,11)] + list('JQKA') # 列表推导式生成纸牌所有的个数[2-A]
suits = ['红心', '方板', '梅花', '黑桃'] # 设置纸牌的花
def __init__(self):
self._cards = [Card(rank, suit) for rank in FranchDeck.ranks # self._cards = [所有的纸牌],得到一个所有纸牌的列表
for suit in FranchDeck.suits]
# for ranks in FranchDeck.ranks:
# for suit in FranchDeck.suit:
# Card(rank, suit) 等于 上面的写法
def __len__(self):
return len(self._cards)
def __getitem__(self, item): # 抽取一张牌
return self._cards[item]
deck = FranchDeck()
print(deck[0])
print(deck[51])
from random import choice
print(choice(deck))
print(choice(deck))执行结果
Card(ranks='2', suits='红心')
Card(ranks='A', suits='黑桃')
Card(ranks='10', suits='梅花')
Card(ranks='5', suits='红心')
from collections import namedtuple
Card = namedtuple('Card', ['ranks', 'suits'])
class FranchDeck:
ranks = [str(n) for n in range(2,11)] + list('JQKA')
suits = ['红心','方板','梅花','黑桃']
def __init__(self):
self._cards = [Card(rank,suit) for rank in FranchDeck.ranks
for suit in FranchDeck.suits]
def __len__(self):
return len(self._cards)
def __getitem__(self, item):
return self._cards[item]
def __setitem__(self, key, value):
self._cards[key] = value
deck = FranchDeck()
print(deck[0])
from random import choice
print(choice(deck))
print(choice(deck))
from random import shuffle
shuffle(deck)
print(deck[:5])执行结果
Card(ranks='2', suits='红心')
Card(ranks='6', suits='黑桃')
Card(ranks='10', suits='黑桃')
[Card(ranks='7', suits='红心'), Card(ranks='9', suits='方板'), Card(ranks='K', suits='方板'), Card(ranks='10', suits='方板'), Card(ranks='5', suits='梅花')]
python异常处理
异常和错误
程序中难免出现错误，而错误分成两种
1 语法错误(这种错误，根本过不了python解释器的语法检测，必须在程序执行前就改正)
错误语法示例:
if
错误语法示例:
def test： (中文的：)
pass
错误语法示例:
print(haha
2. 逻辑错误
用户输入不完整(比如输入为空)或者输入非法(输入的不是数字)
num = input('>>>')
int(num)
无法完成计算
res1 = 1/0
res2 = 1+'str'
什么是异常
异常就是程序运行时发生错误的信号，在python中，错误触发的异常如下:
python中的异常种类
在python中不同的异常可以用不同的类型（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异常处理
什么是异常？
异常发生之后
异常之后的代码就不执行了
什么是异常处理？
python解释器检测到错误，触发异常（也允许程序员自己触发异常）
程序员编写特定的代码，专门用来捕捉这个异常（这段代码与程序逻辑无关，与异常处理有关）
如果捕捉成功则进入另外一个处理分支，执行你为其定制的逻辑，使程序不会崩溃，这就是异常处理
为什么要进行异常处理？
python解析器去执行程序，检测到了一个错误时，触发异常，异常触发后且没被处理的情况下，程序就在当前异常处终止，后面的代码不会运行，谁会去用一个运行着突然就崩溃的软件。
所以你必须提供一种异常处理机制来增强你程序的健壮性与容错性
如何进行异常处理?
首先须知，异常是由程序的错误引起的，语法上的错误跟异常处理无关，必须在程序运行前就修正
1:使用if判断
num1=input('>>: ') #输入一个字符串试试
int(num1)
num1=input('>>: ') #输入一个字符串试试
if num1.isdigit():
int(num1) #我们的正统程序放到了这里,其余的都属于异常处理范畴
elif num1.isspace():
print('输入的是空格,就执行我这里的逻辑')
elif len(num1) == 0:
print('输入的是空,就执行我这里的逻辑')
else:
print('其他情情况,执行我这里的逻辑')总结：
1.if判断式的异常处理只能针对某一段代码，对于不同的代码段的相同类型的错误你需要写重复的if来进行处理。
2.在你的程序中频繁的写与程序本身无关，与异常处理有关的if，会使得你的代码可读性极其的差
def test():
print('test running')
choice_dic={
'1':test
}
while True:
choice=input('>>: ').strip()
if not choice or choice not in choice_dic:continue # 这便是一种异常处理机制啊
choice_dic[choice]()python为每一种异常定制了一个类型，然后提供了一种特定的语法结构用来进行异常处理
基本语法
try:
被检测的代码块
except 异常类型：
try中一旦检测到异常，就执行这个位置的逻辑
例子1：
try:
name
dic = {}
dic['k']
class A:pass
a = A()
a.name
l = []
l[5]
import ab
except NameError: # name下面的代码，就不执行了
print('遇到name error错误了')输出结果
遇到name error错误了
异常类只能用来处理指定的异常情况，如果非指定异常则无法处理
例2：
s1 = 'hello'
try:
int(s1)
except IndexError as e: # 捕获的异常不匹配，还是会报错
print(e)执行结果
ValueError: invalid literal for int() with base 10: 'hello'
多分支异常处理
try:
dic = {}
dic['k']
class A:pass
a = A()
a.name
l = []
l[5]
import ab
except NameError:
print('遇到name error错误了')
except ValueError:
print('遇到value error错误了')
except KeyError:
print('遇到key error错误了')执行结果
遇到key error错误了
如果可能性有很多，分支写不过来呢？
万能异常：在python的异常中，有一个万能异常：Exception,他可以捕获任意异常,即
s1 = 'hello'
try:
int(s1)
except Exception as e:
print(e)执行结果
invalid literal for int() with base 10: 'hello'
万能异常有缺点，出现异常，不知道，错误处在哪里(提示的不够明确！)
怎么改善呢？
l = ['创建老师', '创建学校']
while True:
try:
for num, item in enumerate(l, 1):
print(num, item)
index = int(input('num :'))
print(l[index-1])
break
except ValueError:
print('请输入一个数字.')
except IndexError:
print('你输入的数字不在选择范围内')
except Exception as e: # 万能异常必须在单分支异常的后面，否则单分支异常不能触发
print(e)执行结果
万能异常，必须在单分支异常的后面
异常的其它机构，语句
例1
try:
name
except NameError:
print('触发了name error')
else:
print('执行else里的语句了')执行结果
触发了name error
例2
try:
name = 10
except NameError:
print('触发了name error')
else:
print('执行else里的语句了')执行结果
执行else里的语句了
总结：try...except...else 语法的意思：没有捕获到异常，就执行else语句，也就是说except和else是互相排斥的
实例:模拟转账
try:
print('扣第一个人的钱') #第一个条件
print('给第二个人加钱') #第二个条件
except NameError:
print('触发了 name error')
else:
print('转账成功') # 没有发生错误，则转账成功执行结果
扣第一个人的钱
给第二个人加钱
转账成功
但凡用到else,必须要有except，用到except，不一定有else
finally
finally 执行了try中的代码，不管是否触发了错误，都会执行finally中的代码
try:
name
except NameError:
print('name error')
else:
print('success')
finally: # 不管
print('finally')执行结果
name error
finally
finally的使用场景
函数的应用场景
def func():
try:
return 1 # 即使遇到return,也会执行finally,就是这么执着
finally:
print('finally')
func()执行结果
finally
文件操作的应用场景
f = open('file')
try:
print('操作文件')
finally: # 不管上面操作文件是否报错，都会执行f.close()这个动作
f.close()装饰器的应用场景
import time
def wrapper(func):
def inner(*args, **kwargs):
try:
start = time.time()
return func(*args, **kwargs) #return之前，会执行finally的代码，等finally代码执行之后，在return
finally:
end = time.time()
print(end - start)
return inner
@wrapper
def func():
time.sleep(1)
func()结果
1.000748872756958
try和finally可以直接连用
try只有4种情景
try...except... try中的代码遇到异常，就执行except中的代码
try...except...else... try中的代码遇到异常，就执行except中的代码，没遇到异常就执行else中的代码
try...except...else...finally... try中的代码遇到异常，就执行except中的代码，没遇到异常就执行else中的代码，无论 如何都执行finally中的代码
try...finally 不能处理异常了，但是无论是否发生异常，都会执行finally中的代码
raise
主动触发异常
应用场景
class Payment:
def pay(self, money):
raise NotImplementedError('没有实现pay方法')
class Alipay(Payment):
def pay(self, money):
print('支付宝支付了{}元'.format(money))
class Wechatpay(Payment):
def fuqian(self, money): # 子类没有实现规定的pay方法
print('微信支付了{}元'.format(money))
def pay(obj,money):
obj.pay(money)
we = Wechatpay()
pay(we, 10) # 调用就会报错执行结果
NotImplementedError: 没有实现pay方法
修改代码再次执行
class Payment:
def pay(self, money):
raise NotImplementedError('没有实现pay方法')
class Alipay(Payment):
def pay(self, money):
print('支付宝支付了{}元'.format(money))
class Wechatpay(Payment):
def pay(self, money): # 子类没有实现规定的pay方法
print('微信支付了{}元'.format(money))
def pay(obj,money):
obj.pay(money)
we = Wechatpay()
pay(we, 10) # 调用就会报错输出结果
微信支付了10元
主动触发的异常也可以捕获到
class EvaException(BaseException):
def __init__(self, msg):
self.msg = msg
def __str__(self):
return self.msg
# raise EvaException('错误的内容')
try:
raise EvaException('错误的内容')
except EvaException as e:
print(e)执行结果
错误的内容
主动触发异常
class EvaException(BaseException):
def __init__(self, msg):
self.msg = msg
def __str__(self):
return self.msg
raise EvaException('错误的内容')执行结果
__main__.EvaException: 错误的内容
assert 断言：相当于if
assert 1 == 2
print(123)
print(456)执行结果
AssertionError
assert程序没有满足条件，下面的代码都不执行,它和if的功能类似，但是if它不会报错，断言会报错，如果if判断的条件过多，就需要用到断言。
断言用一个非常果决的场景，如果不满足，后面的代码都不执行(也可以捕获，但是没有人这么做)
try..except的方式比较if的方式的好处
try..except这种异常处理机制就是取代if那种方式，让你的程序在不牺牲可读性的前提下增强健壮性和容错性
异常处理中为每一个异常定制了异常类型（python中统一了类与类型，类型即类），对于同一种异常，一个except就可以捕捉到，可以同时处理多段代码的异常（无需‘写多个if判断式’）减少了代码，增强了可读性
使用try..except的方式
1：把错误处理和真正的工作分开来
2：代码更易组织，更清晰，复杂的工作任务更容易实现；
3：毫无疑问，更安全了，不至于由于一些小的疏忽而使程序意外崩溃了；
什么时候用异常处理
try...except应该尽量少用，因为它本身就是你附加给你的程序的一种异常处理的逻辑，与你的主要的工作是没有关系的
这种东西加的多了，会导致你的代码可读性变差，只有在有些异常无法预知的情况下，才应该加上try...except，其他的逻辑错误应该尽量修正