类：面向对象
-
面向对象三大特性：继承 多态 封装
-
类：
- 每个实例化的对象都封装了类中相同的属性和方法，类是一个相似功能的结合体，
- 对象：类名加()就是一个对象，类中的属性就是变量
-
实例化：当执行类名加括号时就是实例化的过程
- 实例：就是将对象赋值给变量
-
面向对象编程，函数式编程，统称面向过程式编程
-
面向过程式编程好处：
-
优点：出色的完成你之前布置的所有需求
-
缺点：但凡更改或者增加一条需求，可能整个项目都会随之改变
-
类的结构：
-
类的调用：
-
class Student: #构建学生类 daily = '学习' #变量在类中称为： 属性，静态属性 ， 静态字段 enamination = '考试' def work(self): #函数在类中称为：方法，动态方法， 动态属性 print('每天要上课') def homework(self): print('家庭作业') #类名的角度调用类中的属性: Student.cloth = "校服" #增 del Student.cloth #删 Student.enamination = "不考试" #改 print(Student.enamination) #查 Student.work(44) #工作中不使用
-
self 方法传值：
-
#实例化对象时发生三件事： # 1.在内存中创建一个对象空间 # 2.类名()自动执行__init__方法，并将这个对象空间（参数作为实参）传给self参数 # 3.执行__init__方法里面的代码,给对象空间封装其属性 #self 就是类中方法的第一个位置参数， #如果通过对象执行此方法，解释器就自动将此对象空间当做实参传给，self #约定俗称：类中的方法，第一个参数一般都设置成self class Student: #构建学生类，开启一个空间 daily = '学习' #静态属性，类的属性 enamination = '考试' def __init__(self,name,aex,hobby): #双下方法 self接受的是obj实例化对象，封装属性 self.name = name #name = '海洋' self.aex = aex self.hobby = hobby def work(self,color): #动态方法，类的方法 self.color = color print(f"{self.name}每天要上课'") #利用self对象空间，调用name属性 def homework(self): print('家庭作业') # haiyang = Student('海洋',18,'台球') #开辟一个haiyang空间，将参数传给self.name # junli = Student('俊丽',18,'吃') # print(haiyang.__dict__) # print(junli.__dict__) #在任何地方都可以给对象封装属性 haiyang = Student('海洋',18,'台球') #haiyang对象 实例化，空间中存放着类指针 haiyang.work("黑色") #可以在动态方法中添加属性 print(haiyang.__dict__) #不可以在实例化里面修改静态属性 # haiyang = Student('海洋',18,'台球') # haiyang.daily = "dada" #不能修改，这样写没有修改类中的静态属性，而是在自己空间中添加 # print(haiyang.daily) #只能查看，不能修改类中的静态方法 #obj = Student() #实例化时开启一个空间，类名() 这是一个实例化过程，实例化一个对象 # obj.age = '29' #增 # del obj.haha #删 # obj.sex = '女' #改 # print(obj.n) #查看单个属性 # print(obj.__dict__) #查看全部属性，返回字典
-
类添加属性和静态属性不可修改：
-
class A: address = "哒哒" def __init__(self,name): self.name = name def func(self): if self.name == 'aa': self.skins = "海洋" def func1(self): print(self.__dict__) A.aaa = "俊丽" #在外面封装属性 # obj = A("aa") # respons = input("输入1进行修改") # if respons == "1": # obj.dudu = "海洋" #在内部封装属性 # obj = A("aa") # obj.func() # print(obj.__dict__) obj = A('aa') A.func1(obj) print(A.__dict__) def obj.address #单项不可逆 #对象与对象之间互相独立 #对象如果查询一个属性：对象空间---->类空间---->父类空间 #类查询一个属性：类空间----->父类空间
-
依赖关系：
-
#类与类之间，将一个类的类名或者对象传给另一个类的方法中（当实参传） class Elephant: #大象类 def __init__(self,name): self.name = name def open(self,ref1): print(f"大象{self.name}默念三声：开门") ref1.open_door() def close(self,ref1): print(f"大象{self.name}默念三声：关门") ref1.close_door() class Refrigerator: #冰箱类 def __init__(self,name): self.name = name def open_door(self): print(f'{self.name}冰箱门被打开了') def close_door(self): print(f'{self.name}冰箱门被关上了') haiyang = Elephant('海洋') ref = Refrigerator('海尔') haiyang.open(ref) haiyang.close(ref)
-
组合关系：
-
#将一个类的对象封装成另一个类的对象的属性 #一个类的方法只能有此类的对象去调用‘ #一个类的方法的第一个self只接受此类的对象 class Boy: def __init__(self,name): #双下方法，自动执行，封装属性 self.name = name def meet(self,girl_friend = None): self.girl_friend = girl_friend def have_diner(self): #self = wu对象空间 if self.girl_friend: print(f"{self.name}请{self.girl_friend.name}一起吃饭") self.girl_friend.co(self) #等同于flower.co,将self传给co self else: print(f"一人吃饭") class Girl: def __init__(self,name,age): self.name = name self.age = age def co(self,boy_friend): #self = flower print(f"{boy_friend.name}和{self.name}一起溜达") haiyang = Boy('海洋') flower = Girl('俊丽',18) haiyang.meet(flower) #给meet传flower haiyang.have_diner()
-
依赖和组合：
-
class Game(): # 英雄类 def __init__(self, name, ad, hp): self.name = name self.ad = ad self.hp = hp def eauit_weapon(self, wea): # wea == great_sword self.weapon = wea # 组合：给盖伦这个对象封装了一个为wrapon属性 class Weapon: # 武器类 def __init__(self, name, ad): self.name = name self.ad = ad def weapon_attack(self, p1, p2): p2.hp = p2.hp - self.ad print(f"{p1.name}利用{self.name}给了{p2.name}一下,{p2.name}还剩{p2.hp}滴血") gailun = Game('盖伦', 10, 100) # 实例化人物 jianhao = Game('赵信', 20, 90) great_sword = Weapon('大宝剑', 30) # 实例化武器 spear = Weapon('红缨枪', 40) gailun.eauit_weapon(great_sword) # 依赖关系 gailun.weapon.weapon_attack(gailun, jianhao) # 给组合传参
继承：
-
继承，子类继承父类的属性和方法,实现代码的重用，减少代码的编写
-
继承：
-
优点：
- 节省代码，增强耦合性，代码规范
-
缺点：
-
类的耦合性继承要少用
-
可读性差，拍错难，容易出现意料之外的错误
-
-
-
单继承：
-
子类以及对象可以调用父类的属性或者方法,不能增删改
-
子类中如果有此属性，不找父类
-
super方法：用于调用父类
-
class Animal: live = "生命" def __init__(self,name,age,sex): self.name = name self.age = age self.sex = sex def eat(self): # print(self) print("动物吃饭") class Person(Animal): def __init__(self,name,age,sex,hobby): #方法1 #调用Animal的双下方法 #Animal.__init__(self,name,age,sex) #方法2 #super方法，可以不写()，默认(Person, self) super(Person, self).__init__(name,age,sex) self.hobby = hobby def eat(self): print("人类吃法") super().eat() #调用父类方法 p1 = Person("海洋",18,'男','台球') print(p1.__dict__) p1.eat() #调用子类eat方法
-
-
多继承：
-
python2.2之前：都是经典类，
-
python2.2至python2.7之间存在两种类型：经典类，新式类
-
python3 只有新式类 默认继承 class A(object)
-
经典类：基类不继承object，
- 遵循深度优先原则
- 深入的规则是从左至右，从左边一直找到最底层，在从最底层一层一层往回找
-
新式类：基类必须继承object
- 遵循mro算法，mro依赖于c3算法
-
-
多继承示例和算法：
-
class God: #神仙 def __init__(self,name): self.name = name def fly(self): print("会飞") def climb(self): print("神仙也要爬树") class Monkey: #猴子 def __init__(self,sex): self.sex = sex def climb(self): print('爬树') class Monkey_Sun(God,Monkey): #悟空 pass sun = Monkey_Sun print(Monkey_Sun.mro()) #mor查看多继承继承顺序！ -
super 多继承
-
#super（S，self） 严格按照，self从属于类的mro的执行顺序，执行类的下一位 #示例1： class A: def f1(self): print("in A") class Foo(A): def f1(self): super(Foo,self).f1() #FOO下一个类Bar print("in Foo") class Bar(A): def f1(self): print("in Bar") class Info(Foo,Bar): def f1(self): super(Info,self).f1() #Info属于第一个类，每次找下一个类,下个是Foo print("in info f1") obj = Info() obj.f1() #示例2： class A: def f1(self): print("in A") class Foo(A): def f1(self): super(Foo,self).f1() print("in Foo") class Bar(A): def f1(self): print("in Bar") class Info(Foo,Bar): def f1(self): super(Foo,self).f1() print("in info f1") obj = Info() obj.f1()
-
MRO算法，C3算法：
-
class O: pass class D(O): pass class E(O): pass class F(O): pass class B(D,E): pass class C(E,F): pass class A(B,C): pass #取第一个表头匹配表尾，不相同取出，如果相同，匹配下一个列表的表头 #例子[C,E,F,O] = 表头[C] 表尾[E,F,O] #只能拿表头匹配 """ mro(A) = mro(A(B,C)) 原式 = [A] + merge(mro(B),mro(C),[B,C]) mro(B) = mro(B(D,E)) = [B] + merge(mro(D),mro(E),[D,E]) #多继承 = [B] + merge([D,O],[E,O],[D,E]) #单继承,O都是单继承 = [B,D] + merge([O],[E,O],[E]) #取出D之后，删除D = [B,D,E,O] mro(C) = mro(C(E,F)) = [C] + merge(mro(E),mro(F),[E,F]) = [C] + merge([E,O]),[F,O],[E,F]) = [C,E] + merge([O]),[F,O],[F]) = [C,E,F,O] mro(A) = mro(A(B,C)) 原式 = [A] + merge([B,D,E,O],[C,E,F,O],[B,C]) = [A,B] + merge([D,E,O],[C,E,F,O],[C]) = [A,B,D] + merge([E,O],[C,E,F,O],[C]) = [A,B,D,C] + merge([E,O],[E,F,O]) = [A,B,D,C,E] + merge([O],[F,O]) = [A,B,D,C,E,F,O] """
-
封装：
-
将一些 数据属性和方法封装起来，还可以取出来，就是封装
-
将你的数据放到列表里面也是封装，这是数据层面的
-
常用的代码段放到函数里面，这是语句层面封装
-
而类是一种更高级的封装，他可以将这两种封装在一起
-
广义：
- 把属性和方法装起来，外面不能直接调用了，要通过类的名字来调用
-
狭义：
- 把属性和方法藏起来，外面不能调用，只能在类的内部调用
多态：
-
python：默认支持多态
- 同一个对象，多种形态，A=1 A=“ad”
- 一个类表现出多种形态，当你定义一个苹果支付类和微信支付类，他们同属于支付类，可以在支付类中定义双下方法属性
-
鸭子类型：
- python中 你看起来像鸭子，你就是鸭子
- A,B两个类，没有任何关系，独立两个，但是里面的功能相似，所以python一般会将类似于A,B两个类里面的相似功能让其命名相同
- A,B虽然无关系，但是很默契的制定了一个规范，让你使用更方便
类的约束：
- 类的约束是一个开发规范，约束他的所有子类必须实现和他同名的方法，不同名抛出错误
- 作用：
- 在重要的逻辑，与用户数据相关等核心部分，我们要进行约束，避免此类错误
-
第一种约束（常用）：主动抛异常
-
#在父类中定义个pay方法，主动抛出异常，如果子类中没有定义pay方法，会寻找父类 #即会报错，python推荐的一种约束方式 class Payment: #主动报错 def pay(self,money): #约定俗称，定义一种规范，子类要定义pay方法 raise Exception('子类必须定义此方法') class Alipay(Payment): def pay(self,money): print(f"利用支付宝支付了{money}") class Wechatpay(Payment): def fuqian(self,money): print(f"利用微信支付了{money}") #支付 def pay(obj,money): obj.pay(money) obj1 = Alipay() #调用支付宝支付 pay(obj1,100) obj2 = Wechatpay() #调用微信支付 pay(obj2,200) -
第二种约束：实例化对象时报错，严谨
-
#利用抽象类的概念：基类如上设置，子类如果没有定义pay方法，在实例化对象时报错 from abc import ABCMeta,abstractclassmethod class Payment(metaclass=ABCMeta): #约束子类必须要有pay方法 @abstractclassmethod def pay(self,money): pass class Alipay(Payment): def pay(self,money): print(f"利用支付宝支付了{money}") class Wechatpay(Payment): def fuqian(self,money): print(f"利用微信支付了{money}") #支付 def pay(obj,money): obj.pay(money) obj1 = Alipay() obj2 = Wechatpay() #调用微信 pay(obj1,100) pay(obj2,200)
反射：
-
通过字符串形式，反射类中的属性和方法
-
反射的四个函数：
-
hasattr(obj,"字符串") #判断字符串是否存在类中 getattr(obj,"字符串") #进行反射调用字符串（属性或者方法） setattr(obj,"字符串") #添加属性 delattr(obj,"字符串") #删除属性
-
实例角度反射：
-
class A: static_field = "静态属性" def __init__(self,name,age): self.name = name self.age = age def func(self): print("in A func") obj = A("海洋",18) if hasattr(obj,"static_field"): #判断boj对象是否有static_field print(getattr(obj,"static_field")) if hasattr(obj,"func"): #判断hasttr是否有函数 getattr(obj,"func")() #执行对象内的方法 # print(getattr(obj,"name",None)) #没有属性，可以自定义设置返回值 # setattr(obj,"hobby",'台球') #* 添加一个属性 # print(getattr(obj,"hobby")) # # delattr(obj,"hobby") #* 删除一个属性 # print(getattr(obj,"hobby"))
-
类的角度反射：
-
class A: static_field = "静态属性" def __init__(self,name,age): self.name = name self.age = age def func(self): print(self) print(self.name) print("in A func") # print(hasattr(A,"static_field")) # print(getattr(A,"static_field")) obj = A("海洋",18) getattr(A,"func")(obj)
-
脚本角度：
-
def func1(): print("in func1") def func2(): print("in func2") def func3(): print("in func3") class B: static = "B类" import sys this_moudles = sys.modules[__name__] #将__name__加入modules，获取当前脚本对象 getattr(this_moudles,"func1")() #调用函数 cls = getattr(this_moudles,"B") #获取到B，在进行实例化，调用 obj = cls() print(obj.static)
-
类的反射：
-
import sys class Auth: function_list = [("login","请登录"), ("register","请注册"),("exit","退出")] def login(self): print("登录函数") def register(self): print("注册函数") def exit(self): print("退出函数") while 1: obj = Auth() for num,option in enumerate(obj.function_list,1): print(num,option[1]) func_name = int(input("请输入选择：").strip()) if hasattr(obj,obj.function_list[func_name-1][0]): getattr(obj,obj.function_list[func_name-1][0])()
单例模式：
-
一个类只能实例化一个对象，无论你实例化多少次，内存中都只有一个对象，节省内存
-
主要是实例化对象，执行类中的方法
-
#单例模式：(面试必考) #一个类只能实例化一个对象，无论你实例化多少次，内存中都只有一个对象，节省内存 #这个类的对象不是个性化的，主要是实例化对象之后去执行类中的方法 class A: __instance = None def __new__(cls, *args, **kwargs): if not cls.__instance: #如果为反的话 obj1 = object.__new__(cls) #调用object __new__方法封装类名 cls.__instance = obj1 #object1对象 return obj1 else: return cls.__instance obj = A() obj1 = A() print(obj,obj1) #传参示例： class Baby: __instance = None def __new__(cls, *args, **kwargs): if cls.__instance is None: cls.__instance = object.__new__(cls) #object=super,找父类__new__ object类中的new可以创建空间 Baby = cls return cls.__instance def __init__(self,cloth,pants): #self = b1 self.cloth = cloth self.pants = pants b1 = Baby('黑衣服','黑裤子') b2 = Baby('白衣服','白裤子') print(b1.__dict__) print(b2.__dict__)
类的成员：
-
方法：
-
__ 将属性和方法变成私有
-
@classmethod ： 调用类名
-
@staticmethod： 变成普通函数
-
@property ： 将方法变成属性
-
私有：
- 私有静态属性，私有对象方法属性：
- 类的外部都不可调用，只能在类中调用，适用于安全加密方式可以设置成私有（假私有）
-
#公有静态属性： class B: school_name = "海洋" __haha = "haha" class A(B): class_name = "python" __junli = "1" #私有静态属性：外部不可访问 def func(self): print(self.__junli) #只能在类的内部可以访问 print(self.__haha) obj = A() print(obj.func()) #私有对象属性： class B: def __init__(self,weight): self.__weight = weight class A(B): def __init__(self,name,age,weight): super().__init__(weight) #super要放在最上面 self.name = name self.__age = age def func(self): print(self.__age) #类的外部不能访问，只可以内部调用 print(self.__weight) #私有属性，父类中也不可调用 obj = A("海洋",18,120) print(obj.func()) #python中的所有私有成员：就是在私有成员前面加上_类名而已 #不建议这样去访问 class A: __junli = "1" print(A._A__junli)
@classmethod：调用类名
-
#定义一个学生类，统计学生个数 class Student: sum = 0 def __init__(self,name): self.name = name self.count() @classmethod #类方法：由类名直接调用的方法，他会自动将类名传给cls def count(cls): cls.sum = cls.sum + 1 #使用类名是可以修改静态方法中的sum @classmethod def get_num(cls): return cls.sum haiyang = Student("海洋") junli = Student("俊丽") print(Student.get_num()) #类名调用
@staticmethod：变成普通函数
-
#静态方法：不依赖类，也不依赖于对象，他就是一个普通的函数 #他就是一个普通的函数放置于类中结构更加清晰与合理 class A: def func(self): print(111) @classmethod def a_func(cls): #接受的是类名 print(cls) @staticmethod def static_func(a): #普通函数 print(f"静态方法{a}") A.static_func(222) #调用函数 obj = A() #实例化调用也可以 obj.static_func(222)
@property ：将方法变成属性
-
#测试人体体脂 #我们要让bmi方法，伪装成属性，虽然在代码级别没有什么提升，但是看起来更合理 class Bmi: def __init__(self,name,weight,height): self.name = name self.weight = weight self.height = height @property #将方法转为属性 def bmi(self): return self.weight / self.height**2 tb = Bmi("海洋",120,1.80) print(tb.bmi) #调用属性 #@property 方法变成属性，修改和删除不常用 class Foo: def __init__(self,name): self.name = name @property def aaa(self): #设置属性是名称要唯一，setter和deleter不能return print('get时候执行我') @aaa.setter def aaa(self,v): print(f"修改的时候执行我{v}") @aaa.deleter def aaa(self): print("删除时候执行我") obj = Foo("海洋") obj.aaa = "俊丽" #调用被@aaa.setter装饰的函数，并且将"俊丽"传给v del obj.aaa #删除 print(obj.aaa) #原属性aaa没有被修改
isinstance：判断对象与类的关系
-
class A: pass class B(A): pass class C(B): pass obj = B() print(isinstance(obj,B)) #前面是对象，判断OBJ是否是是由B类（B的派生类）实例化的对象 print(isinstance(obj,A)) # print(isinstance(obj,C)) #
issubclass:
-
class A: #父类，也叫基类 pass class B(A): pass class C(B): pass print(issubclass(C,B)) #判断C是否是B的子类，子类也叫派生类 print(issubclass(C,A))
Iterable：判断类可迭代和元类
-
from collections import Iterable #判断是否可迭代 from collections import Iterator #判断迭代器 s1 = "sadaada" #class str(Iterable): # l1 = [1,2,3] # print(type(s1)) #判断对象从属于哪个类，一切皆对象 # print(type(l1)) print(isinstance(s1,Iterable)) #判断是否是可迭代对象，从继承角度 #type 元类 python中一切皆对象，一个类也是一个对象 #那么一个类肯定是由类实例化出来的 #python中你创建的所有类，以及大部分str list等等，这些类都是从type元类实例化得来的 # python中继承object都是新式类： # object也是有type元类实例化得来的 #而type类还是object子类，这种关系比较神奇无法使用python代码表述
types:
-
#函数与方法区别 #函数：全都是显性传参 #方法：存在隐性传参 #java里面就是有方法，c++中都是函数 from types import FunctionType #判断函数 from types import MethodType #判断方法 def func(): pass class A: def func(self): pass @staticmethod def f(self): pass print(isinstance(func,FunctionType)) #判断是否是函数 print(isinstance(func,MethodType)) print(isinstance(A.func,FunctionType)) #类名调用func 是一个函数 print(isinstance(A.func,MethodType)) obj = A() print(isinstance(obj.func,FunctionType)) print(isinstance(obj.func,MethodType)) #通过对象调用是方法 obj = A() print(isinstance(obj.f,FunctionType)) #通过对象调用静态方法是函数 print(isinstance(obj.f,MethodType))
双下方法：
-
双下方法触发条件：
-
__new__: 在实例化时候触发，触发优先级比__init__高，单例模式使用 __len__: len(obj) len对象时候触发 __str__: str(obj)或者格式化输入时候触发 __call__: 实例化对象后触发，call优先级比__init__方法低
-
-
__new__方法： -
#开辟一个空间 class A: def __init__(self): print("in init") def __new__(cls, *args, **kwargs): #cls = A类名 print("in new") object1 = object.__new__(cls) #2.利用object类的new产生一个空间 return object1 #3.将这个对象空间返回给A() obj = A() #1.先触发__new__并且将类名自动传给cls
-
__len__方法： -
#一个对象值所以可以使用len函数，是这个对象从属于类中有__len__方法 class A: def __init__(self,name,age,hobby): self.name = name self.age = age self.hobby = hobby def __len__(self): print("执行了__len__方法") return len(self.__dict__) obj = A("海洋",18,"台球") ret = len(obj) #触发A类中的__len__方法，ret返回10 print(ret) -
__str__方法： -
class Student: def __init__(self,name,age,sex): self.name = name self.age = age self.sex = sex def __str__(self): return f"{self.name}{self.age}{self.sex}" #str优先级高 # def __repr__(self): #跟str双下方法一样 # return f"{self.name}{self.age}{self.sex}" obj = Student("海洋",18,"男") obj1 = Student("俊丽",18,"女") # # print(str(obj)) #会触发 # print(obj) #打印一个实例就会触发__str__ # print(obj1) print(f"此对象为{obj}") #格式化输出也会触发 -
__call__方法： -
# 对象call ，类加（）触发 class A: def __init__(self): self.a = 1 print(111) def __call__(self, *args, **kwargs): print(222) obj = A() #实例化触发 obj() -
__enter__和__exit__方法： -
#对一个对象类似于进行with语句上下文管理，必须要在类当中定义__enter__和__exit__ class A: def __init__(self,text): self.text = text def __enter__(self): self.text = self.text + "您来了" #1 return self def __exit__(self, exc_type, exc_val, exc_tb): self.text = self.text + "这就走了" # with A("大爷") as f1: #2 print(f1.text) print(f1.text) #4
-
#__eq__ 对象比较是触发 #__del__ 析构方法，手动垃圾挥手 #__item__ 对一个对象，执行字典的操作，执行item #__iter__ 将一个对象设置成一个可迭代对象，for循环取值或者list
异常处理：
-
一旦程序出现异常，异常处理会及时捕捉你的错误，不至于使你的程序崩溃
-
异常处理不能经常使用：耗费性能，有些错误是需要分流使用的，代码的可读性变差
-
关键的节点时候使用
-
单分支：
-
try: l1 = [1,2,3,4,5] print(l1[6]) except IndexError as e: #当索引报错后，后面的就不会再走了 print("索引错误") print(111)
-
多分支和分流：
-
try: l1 = [1,2,3,4,5] print(l1[6]) dic = {1:2,'a':'b'} print(dic[3]) num = input("请输入序号：") int(num) except IndexError as e: #当索引报错后，后面的就不会再走了 print("索引错误") except KeyError as e: print('没有此键') except ValueError as e: print("转化错误") print(111) #程序分流 dic = { 1:666, 2:333, 3:555 } while 1: try: num = input("请输入序号：") int(num) print(dic[int(num)]) except KeyError as e: print(f'选项超出范围，请重新输入{e}') #e是将错误打印出来 except ValueError as e: print(f"请输入数字{e}")
-
万能异常：
-
# 万能异常 # 什么时候使用万能异常，什么时候使用多分支？ # 如果你只是想把整个异常全部处理掉，让程序继续执行，就用万能异常 # 如果出现了异常，你是想根据不同的异常执行不同的逻辑流程，你要采取多分支 dic = { 1:666, 2:333, 3:555 } try: num = input("请输入序号：") int(num) print(dic[int(num)]) except Exception as e: #代表所有错误，全部捕获 print(e) print(111)
-
万能异常加分流：
-
dic = { 1:666, 2:333, 3:555 } while 1: try: num = input("请输入序号：") int(num) print(dic[int(num)]) except KeyError as e: print('选项超出范围，请重新输入') except ValueError as e: print("请输入数字") except Exception: #以上异常没有pass掉 pass
-
异常处理其他成员：无异常时候执行
-
dic = { 1:666, 2:333, 3:555 } try: num = input("请输入序号：") int(num) print(dic[int(num)]) except KeyError as e: print("选项超出范围，重新输入") except Exception: pass else: #以上无异常执行else语句，否则不执行else语句 print(666)
-
finally：在出现错误前执行此语句
-
#使用场景，文件读写，数据库连接 try: int("a") finally: #finally: 在出错误前执行此语句 print(777) def func(): #函数结束前执行finally try: a = 1 b = 2 return a + b finally: print(666) print(func())
-
raise/assert：主动抛出异常
-
raise Exception("主动抛出异常") assert #断言：可以添加条件加判断 assert 1 == 2 print(11)
-
自定义异常（了解）
-
class Connection(BaseException): def __init__(self,msg): self.msg=msg raise Connection("触发了连接异常")