1 析构方法

class Animal:
    def __init__(self,name):
        self.name=name
        print ('这是构造初始化方法')
    pass
    def __del__(self): #操作对象的释放，一旦对象被释放完毕就不能在调用
        print ('当在某个作用域下，没有被使用的情况下，解析器就会自动调用此函数，释放内存空间')
        print ('这是析构方法')
        print('%s对象被彻底清理，内存空间也释放'%self.name)
    pass
cat=Animal('小花猫')
del cat #手动去清理删除对象，会执行__del__函数
input('程序等待中*********')
# dog=Animal('可爱小狗')

2 单继承

#python中展现面向对象的三大特征：封装、继承、多态
#封装：把内容封装到某个地方，便于后面的使用；
#需要把内容封装到某个地方； 从另外一处去调用被封装的内容；
#对于封装来说，就是使用__init__将内容封装到对象中，然后通过对象或者
#直接self来获取被封装的内容。
#继承：和现实生活中的继承一样，也就是子可以继承父的内容【属性和行为】；
#（父有子有，子有父不一定有）对于面向对象继承，将多个类共有的方法提取到父类中
#子类只需继承父类，不必一一去实现，极大提高效率，减少代码重复编写，精简代码结构，
# class 类名（父类）：
#       """
#       子类就可以继承父类中公共的属性和方法
#       """
#       pass
#
class Animal:
    def eat(self):
        print ('吃饭了')
        pass
    def drink(self):
        pass
class Dog(Animal): #继承Animal父类，此时dog就是子类
    def wwj(self):
        print ('汪汪叫')
        pass
class Cat(Animal):
    def  mmj(self):
        """
        子类独有的实现
        :return:
        """
        print('喵喵叫')
    pass
d1=Dog()
d1.eat()#具备了吃的行为，是继承了父类的行为
c1=Cat()
c1.eat()
c1.mmj()

3 多继承

#多继承
class shenxian:
    def fly(self):
        print("神仙都会飞")
    pass
class Monkey:
    def chitao(self):
        print('猴子喜欢吃桃')
    pass
class Sunwukong(shenxian,Monkey): #即使神仙  同时也是猴子
    pass
swk=Sunwukong()
swk.chitao()
swk.fly()
#问题是当多个父类当中存在相同方法的时候，该去调用哪一个呢
class D(object):
    def eat(self):
        print('D.eat')
        pass
    pass
class C(D):
    def eat(self):
        print('C.eat')
        pass
    pass
class B(D):
    pass
class A(B,C):
    pass
a=A() #创建A的实例
a.eat() #打印出优先找到的eat
print(A.__mro__) #可以显示类的依次继承关系
#在执行eat的方法时 查找方法的顺序是
# 首先到A里面去查找  如果A中没有 则继续的去B类中去查找 如果B中没有
# 则去C中查找 如果C类中没有 则去D类中去查找，如果还是没有找到 就会报错
# A-B-C-D  也是继承的顺序,打印出优先找到的eat

#间接继承
class GrandFather:
    def eat(self):
        print('吃的 方法')
        pass
    pass
class Father(GrandFather):
    def eat(self): #因为父类中已经存在这个的方法 在这里相当于 方法重写【方法覆盖了】
        print('爸爸经常吃海鲜')
    pass

class Son(Father):
    pass

son=Son()
# print(Son.__mro__)
son.eat() #此方法 是从GrandFather继承过来的

4 重写及调用父类

# 所谓重写，就是子类中，有一个和父类相同名字的方法，在子类中的方法会覆盖掉父类中同名的方法
# 为什么要重写， 父类的方法已经不满足子类的需要，那么子类就可以重写父类或者完善父类的方法
class Dog:
    def __init__(self,name,color):
        self.name=name
        self.color=color

    def bark(self):
        print('汪汪叫....')
        pass
    pass
class kejiquan(Dog):
    def __init__(self,name,color):#属于重写父类的方法
        #争对这种需求  我们就需要去调用父类的函数了
        # Dog.__init__(self,name,color) #手动调用  调用父类的方法了 执行完毕就可以具备name,color这两个实例属性了\
        super().__init__(name,color) #super是自动找到父类 进而调用方法, 假设继承了多个父类，那么会按照顺序逐个去找 然后在调用
        # 拓展其他的属性
        self.height=90
        self.weight=20
        pass
    def __str__(self):
        return '{}的颜色会{} 它的身高是{}cm 体重是:{}'.format(self.name,self.color,self.height,self.weight
                                                  )
    def bark(self): #属于重写类的方法
        super().bark() #自动找到父类，并调用父类的方法
        print('叫的跟神一样')
        print(self.name)
    pass

kj=kejiquan('柯基犬','红色')
kj.bark()
print(kj)

5 多态

#案例演示
class Animal:
    """
    父类【基类】
    """
    def say_who(self):
        print('我是一个动物......')
        pass
    pass
class Duck(Animal):
    """
    鸭子类【子类】派生类
    """
    def say_who(self):
        """
        在这里重写父类的方法
        :return:
        """
        print('我是一只漂亮的鸭子')
        pass
    pass
class Dog(Animal):
    """
    小狗类【子类】派生类
    """
    def say_who(self):
        print('我是一只哈巴狗')
        pass
    pass
def commonInvoke(obj):
    """
    统一调用的方法
    :param obj: 对象的实例
    :return:
    """
    obj.say_who()
# duck1=Duck()
# duck1.say_who()
# dog1=Dog()
# dog1.say_who()
listobj=[Duck(),Dog()]
for item in listobj:
    commonInvoke(item)
#多态可以增加程序的灵活性、扩展性

6 类属性和实例属性

# 属性：实例属性和类属性
# 类属性：类对象所拥有的属性
class Student:
    name='李明'#属于类属性 就是student类对象所有
    def __init__(self,age):
        self.age=age
        pass
    pass
Student.name='小花'#类对象的属性所有权属于类
lm=Student(18)
print(lm.name)#通过实例对象访问类属性
print(lm.age)
print("----------------------通过类对象student访问name————————")
print(Student.name)
# print(Student.age)#不能通过类对象访问实例属性（类名.属性）
#小结
#类属于可通过类对象和实例对象共同访问
#实例属性只能由实例对象所访问
xh=Student(28)
xh.name='小溪'#实例对象不能修改类属性，但可以重写类属性
print(xh.name)
xh.name='小花' #实例对象不能修改类属性
print(xh.age)

7类方法和静态方法

class People:
    country='China'
    #类方法用classmethod 进行修饰
    @classmethod
    def get_country(cls):
        return cls.country  #访问类属性
        pass
    @classmethod
    def change_country(cls,data):
        cls.country=data#修改类属性的值，在类方法中
    pass
    @staticmethod #静态方法不需要参数
    def getData():  #通过类对象去引用
        return People.country
    pass
    @staticmethod
    def add(x,y):
        return (x+y)
    pass
print(People.add(10,56))
print(People.getData())
# print(People.get_country())#通过类对象直接引用
# p=People()
# print('实例对象%s'%p.get_country())
# People.change_country('英国')
# print(People.get_country())

#为什么使用静态方法
#静态方法存放逻辑性的代码，本身和类及实例对象没有交互，
#不涉及类方法和属性的操作
#数据能够得到有效的充分利用
#demo 返回当前系统时间
import  time #引入第三方的时间模块
class TimeTest:
    def __init__(self,hour,min,second):
        self.hour=hour
        self.min=min
        self.second=second
    @staticmethod
    def showTime():
        return time.strftime("%H:%M:%S",time.localtime())
        pass
    pass
print(TimeTest.showTime())


#从方法定义的形式：类方法（@classmethod修饰）的第一个参数是类对象cls，进而 引用类对象的属性和方法
#实例方法的第一个参数必须是self，通过self可以去引用类属性或实例属性
#优先级：实例>类
#静态方法(@staticmethod)不需定义额外的参数，若是要引用属性的话，可通过类对象或实例对象去引用即可