python第二阶段

第一章 面向对象

1. 初识面向对象

1.1 类和对象

class 类名：
	类代码....

class 类名：
属性1 = 值1		# 类属性：所有的对象共有的属性
属性2 = 值2
....

类.属性   # 访问类属性

变量 = 类() 	 # 通过对象访问类属性
变量.属性

# 对象就是一个拥有属性和方法的实体

类.属性 = 值  # 修改类属性
del 类.属性   # 删除类属性
类.__dict__   # 查看类属性

1.2 初始化

class A：
	def __init__(self,属性名1，属性名2,....):
        self.属性名1 = 属性名1
        self.属性名2 = 属性名2

# 初始化方法作用：完成实例属性初始化
# self：对象本身     self.name拿到该属性的值

class Phone：
	def __init__(self,name,width,hight):
        self.name = name
        self.width = width
        self.hight = hight 

1.3 实例化

class A:
    def __init__(self,属性名1，属性名2,....):
        self.属性名1 = 属性名1
        self.属性名2 = 属性名2	
        
    def desc(self):
        .....

class Phone：
	def __init__(self,name,width,hight):
        self.name = name
        self.width = width
        self.hight = hight

	def info(self):
        print(f"品牌：{self.name}，尺寸：{self.width}*{self.hight}")

i = Phone("HUAWEI",27.2,10.6)
i.info()
______________________________________
品牌：HUAWEI，尺寸：27.2*10.6

进程已结束,退出代码0

1.4 案例总结

class Students：	 # 定义 Students 类
	name = "学生"	# 类属性 

	def __init__(self,name,age,sex):  # 初始化方法
        self.name = name
        self.age = age
        self.sex = sex

	def func1(self):  	# 实例化方法
        print("实例化方法func1")
        
	def func2(self):
        print("实例化方法func2")

stu_1 = Students('wzh',19,'man')   # 实例化对象stu_1
stu_2 = Students('gqq',19,'woman') # 实例化对象stu_2

print(Students.name)  # 打印 Students 类属性  -> 学生

print(stu_1.name)	# 打印 stu_1 对象属性  -> wzh
print(stu_2.name)   # 打印 stu_2 对象属性  -> gqq

print(Students.__dict__) # 查看 Students 类属性

print(stu_1.__dict__)	# 查看 stu_1 对象属性
print(stu_2.__dict__)	# 查看 stu_2 对象属性

___________________________________________________
学生
wzh
gqq
{'__module__': '__main__', 'name': '学生', '__init__': <function Students.__init__ at 0x000001C5FB1DE9E0>, 'func1': <function Students.func1 at 0x000001C5FB1DF010>, 'fun2': <function Students.fun2 at 0x000001C5FB1DEB00>, '__dict__': <attribute '__dict__' of 'Students' objects>, '__weakref__': <attribute '__weakref__' of 'Students' objects>, '__doc__': None}
{'name': 'wzh', 'age': 19, 'sex': 'man'}
{'name': 'gqq', 'age': 19, 'sex': 'woman'}

进程已结束,退出代码0

2. 面向对象三大特征

2.1 封装

1）基本概念

# 封装就是把功能代码及数据封装到某个地方，需要时再进行调用，提高程序的安全性和代码的复用性
# 也就是把属性及方法放入类中，通过类来调用
class Student:  # 定义类
    # 类文档
    """			
      @dep_info 系部归属信息
      @class_info 班级信息
    """

    def __init__(self, name, clas, dep):  # 初始化方法
        self.name = name
        self.clas = clas
        self.dep = dep

    def dep_info(self):  # 实例化方法
        print(f"{self.name}属于{self.dep}")

    def class_info(self):
        print(f"{self.name}在{self.clas}班")


# print(Student.__doc__)  # .__doc__可用于输出类文档

stu_1 = Student("小明", 90, "信息技术工程系")  # 实例化对象
stu_1.class_info()  # 方法调用
stu_1.dep_info()
_________________________________________________________________
小明在90班
小明属于信息技术工程系

进程已结束,退出代码0

2）私有方法&私有属性

在类中定义一些数据或功能不希望被外部访问或操作，故将功能或数据进行隐藏

class StuInfo:
      """
    学生体检信息....
       @identity_info 学生身份信息
       @__body 体检信息
    """
    def __init__(self,name,clas,height,weight):
        self.name = name
        self.clas = clas
        self.__height = height  # __. 私有属性
        self.__weight = weight  

	def identity_info(self):
        print(f"{self.name}属于{self.clas}班")

	def __body(self):  # __ 私有方法
        print(f"{self.clas}班{self.name}同学，身高{self.__height},体重{self.__weight}")

stu_1 = StuInfo("小明",209,180,120)
print(stu_1.__height)  # 直接访问私有属性 --> 报错
stu1.__body()  # 直接访问私有方法 --> 报错
_______________________________________________________________
AttributeError: 'StuInfo' object has no attribute '__height'  # 报错：不能直接访问私有方法
AttributeError: 'StuInfo' object has no attribute '__body' # 报错：不能直接访问私有方法

class StuInfo:
      """
    学生体检信息....
       @identity_info 学生身份信息
       @__body 体检信息
       @get_body 获取体检信息
    """
    def __init__(self,name,clas,height,weight):
        self.name = name
        self.clas = clas
        self.__height = height  # __. 私有属性
        self.__weight = weight  

	def identity_info(self):
        print(f"{self.name}属于{self.clas}班")

	def __body(self):  # __ 私有方法
        print(f"{self.clas}班{self.name}同学，身高{self.__height},体重{self.__weight}")

	def get_body(self):	 # 在类中编写公有方法获取私有方法值
        return self.__body()
    
stu_1 = StuInfo("小明",209,180,120)
stu_1.get_body()  # 调用公有方法
_____________________________________________________________
小明	身高：180	体重：120

进程已结束,退出代码0

3) 语法糖@property

作用：可以让方法像属性名一样调用，被装饰的方法名会像属性名被调用必须跟隐藏属性名一致

@.setter 设置属性值

@.deleter 删除属性值

class StuInfo:  # 定义类
    def __init__(self, name):  # 初始化方法
        self.__name = name

    @property  # 被装饰的方法名会作为属性名（必须跟隐藏属性名一致）
    def name(self):
        return self.__name

    @name.setter  # 装饰设置属性值的方法
    def name(self, value):
        self.__name = value
        print(f"更改值为:{value}...")

    @name.deleter  # 装饰删除属性值的方法
    def name(self):
        print(f"删除值:{self.name}...")
        del self.__name


s1 = StuInfo("小明")  # 实例化对象
print(s1.name)  # 被property装饰的方法名可以作为属性名调用

s1.name = "小林"  # 设置新的name值，会触发被@.setter装饰的方法
del s1.name  # 删除name值，会触发被@.deleter装饰的方法
__________________________________________________________
小明
更改值为:小林...
删除值:小林...

4）案例

"""
   利用类完成一个简易的计算器
   1、属性为两位参与计算的数字
   2、实现加减乘除的四种计算方法
"""
class Calculator:
    def __init__(self,num_1,operator,num_2):
        self.num_1 = num_1
        self.num_2 = num_2
        self.operator = operator

    def add(self):
        print(self.num_1 + self.num_2)
    def sub(self):
        print(self.num_1 - self.num_2)
    def mult(self):
        print(self.num_1 * self.num_2)
    def divs(self):
        print(self.num_1 / self.num_2)

    def operation(self):
        if self.operator == "+":
            return self.add()
        elif self.operator == "-":
            return self.sub()
        elif self.operator == "*":
            return self.mult()
        elif self.operator == "/":
            return self.divs()
s1 = Calculator(1,"+",2)
s1.operation()
________________________________________
3

进程已结束,退出代码0

"""
    1 , 定义一个人类
    2 , 人物属性 : 性别 , 身高 , 体重, 健康度 ...
    3 , 方法1 : 跑步 : 体重减少0.5 , 健康度增加 0.01
    4 , 方法2 : 走路 : 体重减少0.01
    5 , 方法3 : 吃饭 : 体重增加0.8 , 健康度增加 0.05
    6 , 方法4 : 睡懒觉 : 体重增加2， 健康度增加 2
"""
"""
    1 , 定义一个人类
    2 , 人物属性 : 性别 , 身高 , 体重, 健康度 ...
    3 , 方法1 : 跑步 : 体重减少0.5 , 健康度增加 0.01
    4 , 方法2 : 走路 : 体重减少0.01
    5 , 方法3 : 吃饭 : 体重增加0.8 , 健康度增加 0.05
    6 , 方法4 : 睡懒觉 : 体重增加2， 健康度增加 2
"""
class Human:
    def __init__(self,sex,height,weight,health):
        self.sex = sex
        self.height = height
        self.weight = weight
        self.health = health

    def runing(self):
        print("跑步，体重减少0.5，健康度+0.01")
        self.weight -= 0.5
        self.health += 0.01
        print(f"当前身高：{self.health},体重：{self.weight},健康度：{self.health}")

    def walk(self):
        print("走路，体重减少0.01")
        self.weight -= 0.01
        print(f"当前身高：{self.health},体重：{self.weight},健康度：{self.health}")

    def eat(self):
        print("吃饭，体重+0.8，健康度+0.05")
        self.weight += 0.8
        self.health += 0.05
        print(f"当前身高：{self.health},体重：{self.weight},健康度：{self.health}")

    def sleep(self):
        print("睡觉，体重+2，健康度+2")
        self.weight += 2
        self.health += 2
        print(f"当前身高：{self.health},体重：{self.weight},健康度：{self.health}")

h1 = Human("男",180,92,10)
h1.eat()
h1.sleep()
_____________________________________________
吃饭，体重+0.8，健康度+0.05
当前身高：10.05,体重：92.8,健康度：10.05
睡觉，体重+2，健康度+2
当前身高：12.05,体重：94.8,健康度：12.05

进程已结束,退出代码0

"""
 1 , 定义一个宠物类
    2 , 设置宠物的公共属性(类属性)
    3 , 设置宠物的初始化属性
    4 , 宠物的几个方法
"""
class Pet:
    typee = "狗"
    def __init__(self,name,age,color):
        self.name = name
        self.age = age
        self.color = color

    def host(self):
        print(f"这只{self.color}色的宠物{self.typee}名叫{self.name}，在家里睡觉")

dog = Pet("大黄",5,"金黄色")
dog.host()
_________________________________
这只金黄色色的宠物狗名叫大黄，在家里睡觉

进程已结束,退出代码0

四 , 说一下对self的理解	对象本身
五 , 对象在查找属性的顺序
六 , 类名定义的要求	大驼峰命名法
七 , (判断题) 类中__init__在类没有实例化的前提下 , 该方法不会执行 [√]
八 ，面向对象中如何让一个属性或者方法变为私有		.__

2.2 继承

1) 基本概念

# 子类继承父类，被继承的类叫父类，子类继承父类的方法和属性
# 作用： 解决重复类代码造成的冗余；在Python3中所有的类默认继承于object（基类、超类）；父类的私有属性和私有方法无法继承

class Father:  # 定义一个父类
    def __init__(self):
        self.name = "父亲"
        self.Manny = "一百万"

    def func(self):
        print("家产...")


class Son(Father):  # 定义一个子类，继承于父类 -> 子类(父类)
    pass


s1 = Son()  # 实例化子类对象
print(s1.Manny)  # 继承父类属性 -> 一百万
s1.func()  # 继承父类方法 -> 家产
________________________________________________________
一百万
家产...

# 进程已结束,退出代码0

2）重写

# 在子类中重写父类方法，实例对象就会直接访问自己的实例属性和实例方法，不再使用父类,
# 相当于在不修改源代码的前提下将父类代码覆盖更新了
# 先有继承，继承之后才能重写
class Father:
    def __init__(self):
        self.name = "父亲"
        self.manny = "一百万"

    def func(self):
        print("家产....")

class Son(Father):
    def __init__(self):
    	self.manny = "两千块钱"	# 重写父类属性
    def func(self):
        print("自主创业....") # 重写父类方法

s1 = Son()
s1.func()			# 重写后不再使用父类方法 -> 自主创业
print(s1.manny)		# 重写后不再使用父类属性 -> 两千块钱
_______________________________________________________
自主创业....
两千块钱

进程已结束,退出代码0

3）super( )语法

# super() 用于保留父类方法或者属性 
class Father:
    def __init__(self):
        self.name = "父亲"
        self.manny = "一百万"

    def func(self):
        print("家产....")


class Son(Father):
    def __init__(self):
        super().__init__()  # 保留父类init属性
        self.manny = "两千块钱"  # 重写父类属性

    def func(self):
        super().func()  # 保留父类func方法
        print("自主创业....")  # 重写父类方法


s1 = Son()
s1.func()  # 重写后不再使用父类方法 -> 自主创业
print(s1.manny)  # 重写后不再使用父类属性 -> 两千块钱
_____________________________________________________
家产....
自主创业....
两千块钱

进程已结束,退出代码0

# 不使用super语法也可以直接将父类方法传递进子类
class Father:
    def __init__(self):
        self.name = "父亲"
        self.manny = "一百万"

    def func(self):
        print("家产....")


class Son(Father):
    def __init__(self):
        super().__init__()  # 保留父类init属性
        self.manny = "两千块钱"  # 重写父类属性

    def func(self):
        # super().func()  # 使用super()保留父类func方法
        Father.func(self) # 父类方法直接传进子类
        print("自主创业....")  # 重写父类方法



s1 = Son()
s1.func()  # 重写后不再使用父类方法 -> 自主创业
print(s1.manny)  # 重写后不再使用父类属性 -> 两千块钱
_____________________________________________________
家产....
自主创业....
两千块钱

进程已结束,退出代码0

4) 属性查找顺序

对象寻找属性  ->  自身属性  ->  所在类的属性  ->  父类
对象寻找方法  ->  所在类中的方法  ->  父类

5）多层继承

class A:
    def __init__(self):
        self.manny = 1000
    def func(self):
        pass

class B(A):
    pass

class C(B):
    pass

test = C()
print(test.manny)
____________________________
1000

进程已结束,退出代码0

6） 多继承

# 一个子类继承多个父类；先调用谁就输出谁
class F1:
    def func(self):
        print("-- 1 --")
class F2:
    def func(self):
        print("-- 2 --")

class S1(F1,F2):
    pass
class S2(F2,F1):
    pass

test1 = F1()
test1.func()	# 先调用F1类 -> F1.func(self)

print("-"*30)

test2 = F2()	# 先调用F2类 -> F2.func(self)
test2.func()
______________________________
-- 1 --
------------------------------
-- 2 --

进程已结束,退出代码0

7）扩展

查看继承顺序   类名.__mro__
查看所有父类（返回元组,若无父类继承即返回object）  类名.__bases__
查看一个父类	类名.__base__

2.3 多态

# 不同的对象调用同一个方法，返回不同的结果
# 多态需满足的条件：必须有类继承；子类必须重写父类方法
# 方法满足即为多态
class F1:
    def __init__(self,massg):
        self.massg = "-- 1 --"
    def func(self):
        print(self.massg)

class S(F1):    # 继承
    def __init__(self):
        self.massg = "-- 2 --"
    def func(self): # 子类重写父类方法
        print(f"重写方法{self.massg}")

test = S()
test.func()
________________________________________
重写方法-- 2 --

进程已结束,退出代码0

2.4 综合案例

一、饭店点餐付款
    1、定义一个饭店类
	属性：名字 ， 菜单 ， 金额  余额
	方法：点餐 ， 付款[取款需要判断余额是否足够]

    2、定义一个自己的饭店
	继承了饭店类中的所有属性以及方法

    3、定义一个某团
	这个某团继承了第一个饭店所有属性以及方法
	 ， 付款需要收取打包费 ， 打包费5元。


二、车
    1、基础汽车类
	属性：
	方法：跑  播放音乐 

    2、轿车
	继承与基础汽车类
	属性：
	方法：电动座椅  电动车窗

    3、超跑
	继承与轿车类
	属性：
	方法：马力加强   

    4、空中飞车
	继承与超跑类
	属性：
	方法：空中飞行

3. 内置方法、绑定方法

3.1绑定与非绑定

1）类方法 @classmethod

由@classmethod装饰，被装饰的类方法在多次实例化中拥有记忆功能，由类方法操作类属性，因为类方法无法通过self去查找对象的实例属性。

class Test:
    _count = 0   # 类属性
    def __init__(self,name):
        self.name = name
        Test.add_count()  # 调用类方法：类名.方法名   先调用再定义

    @classmethod  # 被装饰的类方法在多次实例化后会有记忆功能
    def add_count(cls):    # cls指向类
        cls._count += 1
        print(cls._count)
        
test1 = Test(1)  # 第一次实例化
test1.add_count()
print("-"*5)
test2 = Test(2)  # 第二次实例化
test2.add_count()
print("-"*5)
test3 = Test(3)  # 第三次实例化
test3.add_count()
__________________________________________________
1
2
-----
3
4
-----
5
6

进程已结束,退出代码0

2）静态方法 @staticmethod

通过装饰器@staticmethod进行装饰，没有cls、self参数，没有任何绑定；相当于定义在类外面的函数，只是为了方便管理常用的方法（函数），放在类中统一管理；静态方法不访问类成员（类方法，类属性）和实例成员（实例属性，实例方法）；常用于定义工具方法。

• • • 类无法调用实例方法
    • 实例可以调用类方法、静态方法、实例方法
    • 类和实例都可以调用静态方法

import time
class A:
    @staticmethod
    def now_date():
        print(f"{time.strftime('%Y-%m-%d')}")

t1 = A()
t1.now_date()   # 实例和类都可以调用静态方法
A.now_date()
__________________________________________________
2023-04-15
2023-04-15

进程已结束,退出代码0

3）类型检查

issubclass(B,A) 
	————————————————————————
    	检查是否被继承，返回bool值；
		检查B是否继承于A
        True  --> B(A)
    	False --> B没有继承于A 

isinstance(a,A)
	————————————————————————
    	检查对象是否属于该类；
    	检查对象a是否属于A类
    	True  --> 属于
    	False --> 不属于

3.2 内置方法

1）信息格式化方法

__str__ 该方法可以直接打印对象，拿到自定义对象描述

__repr__ 返回对象自定义描述，是在交互模式下使用的

• 当 str 和 repr 方法同时存在时，只会执行str

class A:
    def __repr__(self):
        return "A 的自定义描述...."
    def __str__(self):
        return "str方法 的自定义描述...."

a = A()
print(a)
_________________________________
str方法 的自定义描述....

进程已结束,退出代码0

2）析构方法 del

__del__ 当系统检测到对象被销毁时，触发执行的内容

class A:
    def __init__(self,data):
        self.data = data

    def __del__(self):
        print(f"数据信息：{self.data}被执行删除....")

test = A("massg")
del test
_________________________________
数据信息：massg被执行删除....

进程已结束,退出代码0

3）构造方法 new

__new__ 内置的静态方法，主要用于给实例对象分配内存空间

Python解释器在得到这个方法返回对象引用之后，将这个引用作为第一个参数传递给init方法；new方法比init方法执行要早一些。

注意：如果new方法没有返回这个对象的引用，Python解释器就找不到这个对象，所以new方法必须有返回值

class A: 
     def __new__(cls,*args,**kwargs):
         """
         new方法用于分配对象的内存空间
         在init方法之前执行
         必须有返回值
         """
         instance = super().__new__(cls)
         return instance

# 使用重写new方法可以完成单例
# 单例：在类中只能实例化一个；节省内存,减少资源消耗
class A:
    __instance = None
    def __new__(cls,*args,**kwargs):
        if cls._instance is None:  # 判断类属性是否为第一次实例化
            # 如果不为None即表示第二次实例化，就直接return
            cls._instance = super().__new__(cls) # 调用父类（super默认继承object）
    	return cls._instance

4）call 方法

# 重写call方法可以让对象像函数一样调用
class A:
    def __init__(self,name,age):
        self.name = name
        self.age = age

    def __call__(self, *args, **kwargs):
        self.name = args[0]     # 取到name值
        print("runing \"call\"....") #打印提示

test = A("张三",19)   # 实例化传入“张三”
print(test.name)
test('里斯')  # call方法，让对象像函数一样调用；通过传参更改name值为“里斯”
print(test.name) 
__________________________________
张三
runing "call"....
里斯

进程已结束,退出代码0

class A:
    def __init__(self,func):
        self.func = func
    def __call__(self, *args, **kwargs):
        print("runing call...")
        self.func()

@A  # 通过call方法实现类的装饰器
def test():
    print("teat A...")

test()  # 调用函数
___________________________________
runing call...
teat A...

进程已结束,退出代码0

5）上下文管理协议

上下文管理协议就是with语句，为了使对象兼容with语句，必须在这个对象的类中声明__enter__()和__exit__()方法；

使用上下文管理，可以自动的操作（创建/获取/释放）资源，如文件操作、数据库连接;

无需再使用try...execpet...去处理异常，如果__exit__()返回值为True，异常就会被清空，使得with后的语句正常执行。

class MyFile:
    def __init__(self,file_name,mode='r',my_en='utf-8'):
        self.file_name = file_name
        self.mode = mode
        self.my_en = my_en
        self.file_obj = None # 用于存储文件打开的对象

    def __enter__(self):    # 上下文管理协议
        print("running enter...")
        self.file_obj = open(self.file_name,self.mode,encoding=self.my_en)
        return self.file_obj    # 最终到达 as f

    def __exit__(self, exc_type, exc_val, exc_tb):
        """
    	with语句中代码块出现异常，导致后续代码无法执行
        :param exc_type: 异常类型
        :param exc_val: 异常值
        :param exc_tb: 回溯对象
        :return:
        """
        self.file_obj.close()  # 文件关闭
        print(f"{self.file_name} close...")

with MyFile('a.txt',"r",my_en='utf-8') as f:    # with 对象，会触发对象的__enter__方法
    print(f.read())
    # with方法结束后会触发__exit__方法
____________________________________________
running enter...
1122334				# a.txt的文件内容
a.txt close...

进程已结束,退出代码0

4.反射、异常处理

4.1 反射

反射：通过字符串形式进行对象的属性及方法

对象反射

• getattr：获取指定对象的属性及方法
• setattr：设置对象属性
• hasattr：判断对象是否具有该属性
• delattr：删除对象属性

class A():
    def __init__(self,name):
        self.name = name
    def func(self):
        pass

a = A('gqq')

# getattr('对象','对象属性','默认值')
test = getattr(a,'name') # 获取指定对象的属性
test = getattr(a,'age',13) # 当属性值不存在时输出默认值，避免报错
print(test)

# setattr('对象','对象属性','默认值')
setattr(a,'sex',None)   # 设置对象属性
print(a.sex)

# hasattr(对象,'对象属性')  判断对象是否具有该属性，返回bool值
print(hasattr(a,'sex'))     # True存在   False不存在

# delattr(对象,'对象属性') 删除对象属性
delattr(a,'sex')
______________________________
13
None
True

进程已结束,退出代码0

4.2 异常

当检测到一个错误时，Python解释器无法执行，并返回一些错误提示。

1）异常的捕获

1. 捕获常规异常

try:
    可能发生错误的代码
except：
	出现异常时执行的代码

# r模式打开一个不存在的文件 => 报错
with open("E:\desk\py.txt","r",encoding="UTF-8") as f:
    f.read()
    
——————————————————————————————————————————————
Traceback (most recent call last):
  File "E:\python\NewProject\case\case_error.py", line 2, in <module>
    with open("E:\desk\py.txt","r",encoding="UTF-8") as f:
FileNotFoundError: [Errno 2] No such file or directory: 'E:\\desk\\py.txt'

进程已结束,退出代码1

# 抛出异常 => 不报错
try:
    f = open("E:\desk\py.txt", "r", encoding="UTF-8")
except:
    print("发现异常，目标不存在，应改为‘w’模式")
    f =  open("E:\desk\py.txt", "w", encoding="UTF-8")
    
——————————————————————————————————————————————
发现异常，目标不存在，应改为‘w’模式

进程已结束,退出代码0

1. 捕获指定异常

try:
    print(name)		
except NameError as 别名:   # 只能捕获NameError异常，出现其他异常会报错
    print("变量未定义")

-----------------
	· 如果尝试执行的代码的异常类型和要捕获的异常类型不一致，则无法捕获异常。
    · 一般try下方只放一行尝试执行的代码。

3. 捕获多个异常

try:
    .....
except(多个异常类型...):		# 使用元组形式进行书写
    .....

try:
    f = open("E:\desk\py.txt", "r", encoding="UTF-8")
except (NameError,FileNotFoundError,TypeError):		# 未正确设置捕获异常类型，将无法捕获异常
    print("异常....")

1. 捕获所有异常

try:
    .....
except Exception as 别名:
    .....

try:
    f = open("E:\desk\py.txt", "r", encoding="UTF-8")
except Exception:
    print("异常....")

try:
    a = 1/0
    
except Exception as e:
    print("有异常.....")
    print(e)

——————————————————————————————————————————
有异常.....
division by zero

进程已结束,退出代码0

2）异常else

无异常时执行的代码

try:
    .....
except Exception as 别名:
    .....
else: 
    无异常时执行

try:
    print("1234567")
except Exception:
    print("发现异常....")
else:
    print("执行完毕！未发现异常")

————————————————————————————————————————
1234567
执行完毕！未发现异常

进程已结束,退出代码0

3）异常finally

无论是否异常都要执行的代码

try:
    ......
except Exception:
    print("异常....")
else:
    print("执行完毕！未发现异常")
finally:
    ......   # 无论是否异常都要执行的代码

try:
    f = open("E:\desk\py.txt", "r", encoding="UTF-8")
except Exception:
    print("出现异常....")
    f = open("E:\desk\py.txt", "w", encoding="UTF-8")
else:
    print("执行完毕！未发现异常")
finally:
    f.close()   # 无论是否异常都关闭文件

4）异常的传递

当函数 func01 发生异常，并且没有捕获处理这个异常的时候，异常会传递到函数 func02，当 func02 也没有捕获处理这个异常时，main 函数会捕获这个异常，当所有函数都没有捕获异常的时候，程序就会报错。

# 定义一个有异常的函数
def fx_1():
    print("NO.1 start")
    sum = 1/0 # 编写一条异常代码，而导致整个函数异常
    print("NO.1 stop")

    # 定义一个无异常的函数，调用异常的函数
def fx_2():
    print("NO.2 start")
    fx_1()    # 调用异常函数，导致整个函数异常
    print("NO.2 stop")

def main():
    try:
        fx_2()
    except Exception as a:
        print("异常:{a}")

main()	# 最终异常函数fx_1的异常会被逐级传递至main(),在main函数中处理异常	
________________________________________________
NO.2 start
NO.1 start
异常division by zero

进程已结束,退出代码0

5）自定义异常

# raise Exception("异常信息...")
money = int(input("存入金额"))

if money >= 50:
    print("存入成功")
else:
    raise Exception("低于最小存入金额，存入失败")
____________________________________________________
存入金额2
Traceback (most recent call last):
  File "E:\python\ZZT\gaoJie\D5.py", line 35, in <module>
    raise Exception("低于最小存入金额，存入失败")
Exception: 低于最小存入金额，存入失败

进程已结束,退出代码1

4.3 断言 Assert

# 会返回一个AssertionError异常错误
# assert 表达式 异常信息		# 当表达式为False时输出异常信息
assert 3 > 5, "错误！" 
________________________________________
Traceback (most recent call last):
  File "E:\python\ZZT\gaoJie\D5.py", line 30, in <module>
    assert 3 > 5, "错误！"  
AssertionError: 错误！

进程已结束,退出代码1

try:
    assert 3 > 5, "错误！"  # 当表达式为False时返回异常内容
except Exception as e:
    print(e)    # 打印异常信息
________________________________________
错误！

进程已结束,退出代码0

5.案例总结

一，填空题

1. 简述面向对象中__new__和__init__区别
new执行比init早

2.Python中的self是什么？



3.列出几种魔法方法并简要介绍用途



4.什么是对象方法，类方法，静态方法？

5. 如何理解类属性和实例属性

二，代码题

1.问题一：以下的代码的输出将是什么? 说出你的答案并解释。
class Fu:
    x = 1

class Son(Fu):
    pass

class Child2(Fu):
    pass

print(Fu.x, Son.x, Child2.x)     
Son.x = 2
print(Fu.x, Son.x, Child2.x)  
Fu.x = 3
print(Fu.x, Son.x, Child2.x) 

2.士兵和枪
    需求：
    1）士兵阿尔法有一把AK47
    2）士兵可以开火(士兵开火扣动的是扳机)
    3）枪能够发射子弹(把子弹发射出去)
    4）枪能够装填子弹 --增加子弹的数量
3.多态练习 主人Master:请好友吃饭，陪好友玩 好友Friend: 中国朋友：吃饺子，表演太极拳 
美国朋友：吃披萨，踢足球 试用程序模拟

4.定义一个音乐类，它有歌名、歌手、时长、风格等属性，
以及播放、暂停、收藏等方法。创建一个音乐类的实例对象，
并给它赋予合适的属性值，然后调用它的方法进行操作。


5.定义一个学生类，它有姓名、学号、班级、成绩等属性，
以及打印个人信息、计算平均分、判断是否及格等方法。创建一个学生类的实例对象，并给它赋予合适的属性值，然后调用它的方法进行操作。

6.定义一个银行账户类，它有账号、余额、密码等属性，
以及存款、取款、转账、修改密码等方法。创建一个银行账户类的实例对象，并给它赋予合适的属性值，然后调用它的方法进行操作。

7.定义一个汽车类，它有品牌、型号、颜色、价格等属性，
以及启动、停止、加速、减速等方法。然后定义一个电动汽车类，继承自汽车类，并添加自己特有的属性和方法。创建一个电动汽车类的实例对象，并调用它的各种属性和方法。

8.定义一个图书类，它有书名、作者、出版社、价格等属性，
以及打印书籍信息、修改价格等方法。创建一个图书类的实例对象，并给它赋予合适的属性值，然后调用它的方法进行操作