求知讲堂python+人工智能day8

面向对象基础（中）

相信大家都有这样的经历：我们进入一家商店的时候经常会听到一个喇叭播放说，欢迎光临，当我们出商店的时候也会提醒说欢迎光临，现实中这是通过感应器触发的，但是在程序中我们是如何触发实现呢，这就是我们要介绍的，析构函数

1、析构方法

当一个对象被删除或者被销毁时，python解释器也会默认调用一个方法，这个方法为__del__()方法，也称为析构方法。
程序执行结束自动调用__del__方法，对象被释放后将不会被保存，再次调用的时候会报错

class Animal:
    def __init__(self,name):
        self.name=name
        print('这是一个初始化方法')
        pass
    def __del__(self):
        print('这是析构方法，用来释放内存')
        print('{}对象被释放'.format(self.name))
        pass
    pass
cat=Animal('小花猫')

class Animal:
    def __init__(self,name):
        self.name=name
        print('这是一个初始化方法')
        pass
    def __del__(self):
        print('这是析构方法，用来释放内存')
        print('{}对象被释放'.format(self.name))
        pass
    pass
cat=Animal('小花猫')
# 当程序还在运行的时候不会删除对象，因为不知道还会不会再用到，故del没有执行
input('程序在等待。。。')

添加手动释放

class Animal:
    def __init__(self,name):
        self.name=name
        print('这是一个初始化方法')
        pass
    def __del__(self):
        print('这是析构方法，用来释放内存')
        print('{}对象被释放'.format(self.name))
        pass
    pass
cat=Animal('小花猫')
# 手动释放对象
del cat
# 当程序还在运行的时候不会删除对象，因为不知道还会不会再用到，故del没有执行
input('程序在等待。。。')

从下面的输出结果中，我们可以看出，当我们调用del dog 这条语句时__del__方法被执行了

析构方法小结：

1、当整个程序脚本执行完毕后会自动调用__del__方法
2、当对像被手动销毁时也会自动调用 del 方法
3、析构函数一般用于资源回收，利用__del__方法销毁对象回收内存等资源

2、在python中展现买你洗那个对象的三大特征：

封装、继承和多态

• 封装：指的是把内容封装到某个地方，便于后面的使用；对于封装，其实就是使用初始化构造方法将内容封装到对象中，然后通过对象直接或者self来获取被封装的内容；
• 继承：在现实生活中，继承一般指的是子女继承父辈的财产。和现实生活中的继承是一样的，儿子可以继承父亲的内容【属性和行为】（爸爸有的儿子都有，但是儿子有的爸爸不一定都有）
• 多态：所谓多态：定义时的类型和运行时的类型不一样，此时就成为多态。

2.1 单继承

在面向对象中同样有继承，例如：
猫的方法：喵喵叫、吃、喝
狗的方法：汪汪叫、吃、喝
如果给猫和狗都创建一个类，那么猫和狗的所有方法都要写,如：

class Animal:  # 父类
    def eat(self):
        print('吃饭了')
        pass
    def drink(self):
        pass
    pass
# 子类
class dog(Animal):  # 继承父类
    def wwj(self):
        print('小狗汪汪叫')
        pass
    pass
class cat(Animal):
    def mmj(self):
        print('小猫喵喵叫')
        pass
    pass

# 单继承，只用关注不一样的就行了，一样的就用父类继承过来
d1=dog()
d1.eat()  # 继承了父类的行为
d1.wwj()
c1=cat()
c1.eat()
c1.mmj()

总结：在定义子类时要继承父类，只需要类名后面的小括号()中写上父类的名字，那么父类的属性、方法，会被继承给子类。

2.2 多继承

class shenxian:
    def fly(self):
        print('神仙都会飞')
        pass
    pass
class Monkey:
    def chitao(self):
        print('猴子爱吃桃')
        pass
    pass
class Sunwukong(shenxian,Monkey): # 孙悟空既是神仙又是猴子
    pass
swk=Sunwukong()
swk.fly()
swk.chitao()

同名方法：如果在上面的多继承例子中，如果父类A和父类B中，有一个同名的方法，那么通过子类去调用的时候，调用哪个？

class D():
    def eat(self):
        print('D.eat')
        pass
    pass
class C(D):
    # def eat(self):
    #     print('c.eat')
    #     pass
    pass
class B(D):
    # def eat(self):
    #     print('B.eat')
    pass
class A(B,C):
    pass

a=A()
# 在执行eat的时候，查找的顺序是：先A中找，没有，去B中，B有输出，然后中断
a.eat()
print(A.__mro__)  # 查询查找的顺序，也是继承的顺序

前面代码查找顺序为 A->B->C->D, 一旦找到，则寻找过程立即中断，便不会再继续找了，如果都没找到就报错

2.3 继承的传递

在现实中遗产继承，爷爷的遗产可以被父亲继承，儿子可以继承父亲的。这样看来是不是儿子也是有继承到爷爷的遗产。在面向对象中的继承呢？子类是否能继承父类的父类的方法？

案例

看看下面的继承关系，Son类继承Father类，Father类并没有提供eat方法，但是父类又继承了Grandfather类。Son的对象调用eat方法可以正常执行，运行结果得出，Son类也继承了Granderfather类的方法。这就是继承的传递性。

class grandfather:
    def eat(self):
        print('吃饭')
        pass
    pass
class father(grandfather):
    pass
class son(father):
    pass
s=son()
s.eat()
print(son.__mro__)

总结：类的传递过程中，我们把父类又称为基类，子类又称为派生类，父类的属性和方法可以一级一级的传递到子类

2.4 重写父类方法（方法覆盖）

所谓重写，就是子类中，有一个和父类相同名字的方法，在子类中的方法会覆盖掉父类中同名的方法 伪代码示例：

# 重写：父类方法已经不能满足子类的需求，需要重写或完善父类
class Dog:
    def bark(self):
        print('汪汪叫。。。')
        pass
    pass
class keji(Dog):
    def bark(self):  # 属于重写父类方法
        print('像小猫一样叫。')
        pass
    pass
kj=keji()
kj.bark()

2.5 调用父类方法

如果在子类中有一个方法需要父类的功能，并且又要添加新的功能。如果直接重写父类方法，那么就要重复写很多代码。那么这就要调用父类方法

# 重写：父类方法已经不能满足子类的需求，需要重写或完善父类
# 调用：有时候急需要继承有需要完善，就需要我们调用了，因为重写会太繁琐
class Dog:
    def __init__(self,name,color):
        self.name=name
        self.color=color
    def bark(self):
        print('汪汪叫。。。')
        pass
    pass
class keji(Dog):
    def __init__(self,name,color):  # 属于重写父类的方法
        # 针对调用，需要调用父类的函数
        # Dog.__init__(self,name,color)  # 1、手动调用父类的方法，执行完毕就可以具备name和color这两个实例属性了
        super().__init__(name,color)  # 2、自动调用，会自己找到对应的父类self，多个父类的时候会按照顺序查找
        # 扩展其他属性
        self.height=90
        self.weight=20
        pass
    def __str__(self):
        return '{}的颜色是{}，它的身高是{}cm，体重是{}公斤'.format(self.name,self.color,self.height,self.weight)
    def bark(self):  # 属于重写父类方法
        print('像小猫一样叫。')
        pass
    pass
kj=keji('柯基犬','红色')
kj.bark()
print(kj)

2.6 多态：定义时的类型和运行时的类型不一样，此时就成为多态。

两个前提：
继承：必须存在继承关系，必须在父类和子类之间
重写：子类重写父类的方法
多态的优势：
增加程序的灵活性
增加程序的扩展性

class Animal:
    '''
    父类（基类）
    '''
    # 说话的行为
    def say_who(self):
        print('我是一只动物。。。。')
        pass
    pass
class duck(Animal):
    '''
    子类：鸭子类
    '''
    def say_who(self):  # 子类重写父类的方法
        print('我是一只鸭子')
        pass
    pass
class dog(Animal):
    '''
    子类：小狗类
    '''
    def say_who(self):
        print('我是一只小狗')
        pass
    pass
class cat(Animal):
    '''
    子类：小猫类
    '''
    def say_who(self):
        print('我是一只小猫')
        pass
    pass
print('*****重写调用****')
yz=duck()
yz.say_who()
xg=dog()
xg.say_who()
xm=cat()
xm.say_who()
print('********循环调用(多态的优势）****')
# 新增子类更方便
class bird(Animal):
    '''
    子类：小鸟类
    '''
    def say_who(self):
        print('我是一只小鸟')
        pass
    pass
def commmon(obj):
    '''
    统一调用的方法
    :param obj: 对象的实例
    :return:
    '''
    obj.say_who()
listobj=[duck(),dog(),cat(),bird()]
for i in listobj:
    '''
    循环调用函数
    '''
    commmon(i)

2.6 属性：类属性和实例属性

类属性：就是类对象所拥有的属性，它被所有类对象的实例对象所共有，类对象和实例对象可以访问
实例属性：实例对象所拥有的属性，只能通过实例对象访问
所有实例对象的类对象指针指向同一类对象。实例属性在每个实例中独有一份，而类属性是所有实例对象共有一份

class student:
    name='黎明'  # 属于类属性，student所有
    def __init__(self,age):
        self.age=age   # 实例属性
        pass
    pass
lm=student(18)
print(lm.name)  #通过实例对象访问类属性
print(lm.age) # 通过实例对象访问实例属性
print('************通过类对象 student 访问name类属性***')
print(student.name)
print('************通过类对象 student 访问age实例类属性（报错）****')
# print(student.age)

修改类属性

class student:
    name='黎明'  # 属于类属性，student所有
    def __init__(self,age):
        self.age=age   # 实例属性
        pass
    pass
lm=student(18)
print(lm.name)  #通过实例对象访问类属性
lm.name='刘德华' # 通过实例对象不能修改类属性，只是新生成一个实例属性而已
print(lm.name)
print(lm.age) # 通过实例对象访问实例属性
print('*****xh的信息******')
xh=student(18)
print(xh.name)  #通过实例对象访问类属性
print('************通过类对象修改类属性xh的信息***')
student.name='刘德华'
xh=student(18)
print(xh.name)  #通过实例对象访问类属性

类属性的所有权归类对象所有，所以只能通过类对象来修改，不能通过实例对象修改。

2.7 类方法和静态方法

类方法：
类对象所拥有的方法，需要用装饰器@classmethod来标识其为类方法，对于类方法，第一个参数必须是类对象，一般以cls作为第一个参数，类方法可以通过类对象，实例对象调用
类方法主要可以对类属性进行访问、修改
类方法的第一个参数是类对象cls，通过cls引用的类对象的属性和方法

class people:
    country='china'
    @classmethod  # 标识符标识后，实例方法就变成类方法就归类对象所有，而不是实例所有
    def get_country(cls):  # 不标识的时候是实例方法，标识一下就变成类方法,cls也可以换其他的表示
        return  cls.country  # 类方法访问类属性
        pass
    @classmethod
    def change_country(cls,country):
        cls.country=country #通过类方法修改类属性
        pass
    pass

print(people.get_country())  # 通过类对象引用
p=people()  # 创建实例对象
print('实例方法访问类对象{}'.format(p.get_country()))
print('****修改后的信息********')
people.change_country('英国')
print(people.get_country())  # 通过类对象引用

静态方法：

• 类对象所拥有的方法，需要用@staticmethod来表示静态方法，静态方法不需要任何参数（也可以穿参数，一般不传)
• 由于静态方法主要来存放逻辑性的代码，本身和类记忆实例对象没有交互。也就是说，在静态方法中，不会涉及类中的方法和属性的操作，数据资源能够得到有效的充分利用。

class people:
    country='china'
    @classmethod  # 标识符标识后，实例方法就变成类方法就归类对象所有，而不是实例所有
    def get_country(cls):  # 不标识的时候是实例方法，标识一下就变成类方法,cls也可以换其他的表示
        return  cls.country  # 类方法访问类属性
        pass
    @classmethod
    def change_country(cls,country):
        cls.country=country #通过类方法修改类属性
        pass
    @staticmethod
    def getdata():
        return people.country
        pass


print('******类对象调用*****')
print(people.get_country())
print('******实例对象调用*****')
p=people()
print(p.get_country())  # 一般情况下，静态方法不会让实例对象访问，占资源

# demo 返回当前的系统时间
import time
class timetest:
    def __init__(self,hour,min,second):
        self.hour=hour
        self.min=min
        self.second=second
        pass
    pass
    @staticmethod  # 这个功能是独立的
    def showtime():
        return time.strftime('%H:%M:%S',time.localtime())  
    pass
pass

print(timetest.showtime())  #静态方法中引用类属性的话，必须通过类对象来引用。