学python的第六天，类和对象，以及单例的实现和异常捕捉

类和对象

封装

把属性和方法封装进类

使用类创建对象，再让对象调用方法

对象方法的细节都被封装在类的内部

类的封装实例：

案例一：小猫吃鱼

 class Cat:
     """这是初始化方法的优化,使用初始化方法传入参数"""
     def __init__(self,new_name):
         print("当创建对象的时候，启动我")
         self.name= new_name
         #启动之后进行赋值
     def eat(self):
         print(f"{self.name}吃鱼")
     def __str__(self):
         return "返回一个字符串"
     def __del__(self):
         print("当删除对象的时候，启动我")
 tom =  Cat("TOM")
 print(tom)
 tom.eat()
 print("在我之后结束的时候自动删除对象，也可以用del tom 直接手动删除")
 del tom

案例二：跑步减肥

小明体重75，跑步会减少0.5，吃东西会增加1.0

person(人-类)	init 输入	run()
name	str 返回体重	eat()
weight

 class Person:
     def __init__(self,n_name,n_weight):
         self.name=n_name
         self.weight=n_weight
     
 ​
     def __str__(self):
         return "我的名字是：%s，我的体重 %.2f公斤" % (self.name,self.weight)
     
     def eat(self):
         self.weight += 1.0
         print(f"吃完之后：{self.weight}")
         
     def run(self):
         self.weight -= 0.5
         print(f"跑完之后：{self.weight}")
 ​
 ​
       
 xiaomin = Person('小明',75)
 xiaomin.run()
 xiaomin.eat()
 print(xiaomin)

案列三：家具摆放

家具类
name	init：name,area
area(占用的大小)	str:返回area

 

 ​
 class HouseItrm:
     def __init__(self,name,area):
         self.name=name
         self.area=area
         
 ​
     def __str__(self):
         return "%s 占地 %.2f 平米"% (self.name,self.area)
 ​
 #创建家具
 bed = HouseItrm("床",4)
 print(bed)
 table = HouseItrm("桌子",2)
 chest = HouseItrm("衣柜",1.5)
 ​
 class House:
     
 ​
     def __init__(self,house_type,area):
         self.house_type=house_type
         self.area=area
         self.free_area=area
         self.list = []
         #房子型号  总面积  剩余面积  家具列表
     
     def __str__(self):
         return ("房子：%s  \n总面积：%.2f [剩余:%.2f]\n家具列表：%s"
                 %(self.house_type,self.area,
                   self.free_area,self.list))
     def add_item(self,item):
         if item.area <= self.free_area:
             self.free_area -= item.area
             self.list.append(item.name)
 ​
 #创建房子
 home = House("两室一厅",60)
 ​
 #添加家具
 home.add_item(bed)
 home.add_item(chest)
 ​
 print(home)

案例四：ak47开枪

两个类相互调用

继承

 

相同的代码不需要重复书写

 ​

 class Animal:
     def eat(self):
         print("吃")
         
 ​
     def run(self):
         print("跑")
 ​
 class Dog(Animal):
     def bark(self):
         print("汪汪汪")
         
 class Xiaotianquan(Dog):
     def bark(self):
         print("吼吼吼")
         super().bark()
     #子类的重写
     #可以用super()调用父类已经存在的函数
 ​
 ​
 wangcai = Dog()
 wangcai.eat()
 ​
 xtq = Xiaotianquan()
 xtq.bark()
 ​
 #继承有关：
 #父类，子类，继承，子类也就是派生，父类就是基类

 ​
 ​

比较有意思的是，子类可以拥有多个父类，称为多继承。

多继承需要注意的是，父类出现了重合方法，应该避免使用多继承。

如果出现了，则一般会调用第一次出现的方法。

可以使用print(xtq.--mro--())查看顺序。

类扩展：类方法和类属性

狗狗吃了几次

 class Animal():
     count=0
     num = 0
     #类属性
     
 ​
     #类方法
     @classmethod
     def show_count(cls):
         print(f"吃了{Animal.count}次")
         
     #静态方法，也就是不修改也不需要参数
     #不访问实例的属性和类的属性
     @staticmethod
     def die():
         print("寿命结束，死亡了")
     
     def __init__(self,name):
         self.name = name
         Animal.num += 1
         #计算动物数量
     
     def eat(self):
         Animal.count += 1 
         print(f"{self.name}吃了{Animal.count}次")
         #计算吃的次数
 ​
 #静态方法不需要创建对象
 Animal.die()
                
 dog=Animal("狗子")
 dog.eat()
 dog.eat()
 Animal.show_count()
 dog01=Animal("123")
 dog02 = Animal("112")
 print(f"{Animal.num}只狗狗")

 

 

 

单例，异常捕捉，

 #单例  只创建一个对象
 class Music(object):
     
 ​
     instance= None
     #记录引用
     
     init_flag = False
     #记录是否初始化过
     
     def __new__(cls,*args,**kwargs):
         
         if cls.instance is None:
             print("创建对象，分配空间")
             cls.instance = super().__new__(cls)
         #分配空间
         return cls.instance
         #返回空间的内存地址。
     
     def __init__(self):
         if Music.init_flag:
             return
         else:
             Music.init_flag=True
             print("播放器启动")
 ​
 mp3=Music()
 print(mp3)
 mp4=Music()
 print(mp3)
 print(mp4)

 

异常捕捉

```python
#异常的捕获,如果异常，执行except
try:
#不能确定是否正确的代码
    a=int(input("整数"))
except:
    #出现错误的后续
    print("出错")
```

  感觉类和对象的玩法很有趣，等学完之后去把自己图书馆实例改一改，上手操作一下。

主要拓展了解了一下python的基础逻辑，类和对象怎么运行，怎么出错。感觉要注意的点不少，但是也不打算强行记忆。等以后

用的时候，通过实践记忆吧。