#单继承
#子类只继承一个父类
class Person:
def say(self,value):
print('say:',value)
def walk(self,value):
print('walk:',value,'km')
#Student类继承Person
class Student(Person):
def study(self,value):
print('study:',value)
#Teacher类继承Person,可以直接调用父类的方法
class Teacher(Person):
def teach(self,value):
print('teacher:',value)
s=Student()
s.say('hello')
s.walk('5')
s.study('python')
#多继承
#父类
class People:
def __init__(self,name,age):
self.name=name
self.age=age
def speak(self):
print(f'{self.name} 说我今年 {self.age} years old.')
#父类
class Speaker:
def __init__(self,name,topic):
self.name=name
self.topic=topic
def speak(self):
print(f'我叫{self.name} ,演讲的题目是{self.topic} ')
#子类，继承People和Speaker
#多继承：当父类中有相同的方法，在子类中调用该方法并且没有显示指定调用哪个父类的方法，python按照父类列表从左到右顺序进行查找，找到第一个
class Sample(People,Speaker):
def __init__(self,name,age,topic):
People.__init__(self,name,age)
Speaker.__init__(self,name,topic)
sample = Sample('zs','20','python')
sample.speak()
#覆盖：子类继承父类，并且子类中定义了和父类相同的方法，当子类实例化后对象调用该方法时，调用的子类方法，而不是父类，这叫覆盖
class A:
def work(self):
print('A work')
class B(A):
def work1(self):
print('B work')
a=A()
a.work()
b=B()
b.work()
#封装：就是将一些属性和方法隐藏，如果需要外部代码访问，可提供接口，使用接口访问隐藏的属性和方法，从而提高代码的安全性和可维护性
#单下划线‘_':属性或方法以'_'开头，表示属性或方法是受保护的，按照约定，外部代码不允许直接访问，只是一个约定，并没有强制规则
#双下划线'__':表示该属性或方法是私有的，
class Myclass:
def __init__(self,value):
self._protected_value = value
self.__private_value = value
myclass = Myclass(20)
#受保护变量不允许直接访问只是口头约定
print(myclass._protected_value)
myclass._protected_value = 40
print(myclass._protected_value)
#私有变量不能直接访问，原因：python将私有变量名修改'_类名'+私有变量名
#print(myclass.__protected_value)
print(myclass._Myclass__private_value)
#如果受保护变量或者私有变量，需要外部代码访问，则可以提供getter和setter访问
class MyclassV1:
def __init__(self,value):
self._protected_value = value
#添加get方法供外部代码访问受保护变量
def get_value(self):
return self._protected_value
#添加set方法供外部代码访问受保护变量
def set_value(self,value):
self._protected_value = value
c=MyclassV1(10)
print(c.get_value())
c.set_value(30)
print(c.get_value())
#@property装饰器，将方法转成属性可以以属性的方式访问
#@property将方法定义为一个只读属性，用来访问受保护变量
#@property和property_name.setter组合使用，可以定义一个可写属性，property_name是@property装饰器将方法转换的属性名
class MyclassV2:
def __init__(self,value):
self.__private_value = value
#@property装饰器将value方法转换成value属性
@property
def value(self):
return self.__private_value
#通过property_name.setter给变量赋值
#方法名和@property修饰的方法名一致
@value.setter
def value(self,value):
self.__private_value = value
c=MyclassV2(10)
print(c.value)
c.value=300
print(c.value)
#多态：同一个方法在不同类中的不同实现，分为静态和动态
#静态多态：方法重载：方法名一样，参数个数不同
class Calculator:
#python不支持直接的方法重载
# def add(self,a,b):
# return a+b
# def add(self,a,b,c):
# return a+b+c
def add(self,a,b,c=0):
return a+b+c
c=Calculator()
print(c.add(3,4))
print(c.add(3,4,5))
#运算符重载
#add运算符重载
class Point:
def __init__(self,x,y):
self.x = x
self.y = y
def __add__(self,other):
return Point(self.x+other.x,self.y+other.y)
def __str__(self):
dic={'x':self.x,'y':self.y}
return f'{dic}'
p1=Point(1,2)
p2=Point(3,4)
p3=p1+p2
print(p3)
#动态多态：通过方法重写
#方法重写：子类重写父类中的方法实现动态多态
class Animal:
def speak(self):
return '通用声音'
class Dog(Animal):
def speak(self):
return '狗叫'
class Cat(Animal):
pass
dog = Dog()
cat = Cat()
print(dog.speak())
print(cat.speak())
#抽象类：
#抽象类不能直接实例化，需要派生类继承，并重写抽象类中的抽象方法
#抽象类需要导入abc模块中ABC和abstrctmethed
from abc import ABC, abstractmethod
#定义抽象类
#抽象类中不是所有的方法都是抽象方法，只有添加@abstreactmethod装饰器的方法是抽象方法
class AbsClass(ABC):
#@abstractmethod:抽象方法装饰器，将方法定义为抽象方法：只有方法声明，没有方法实现，抽象方法需要子类来实现
@abstractmethod
def speak(self):
pass
#定义普通方法，子类可以直接调用，不需要重写
class Dog(AbsClass):
def speak(self):
return 'woof'
class Cat(AbsClass):
def speak(self):
return 'Meow'
dog = Dog()
print(dog.speak())
cat = Cat()
print(cat.speak())
#MRO
class A:
def method(self):
print('A')
class B(A):
def method(self):
print('B')
class C(A):
def method(self):
print('C')
class D(B, C):
def method(self):
print('D')
class E(B,C):
def method(self):
print('E')
class F(D,E):
pass
print(F.__mro__)
#super()
class ClassA:
def add(self,x,y):
return x+y
class ClassB(ClassA):
def add(self,x,y):
print('Class B')
#super()获取父类对象
return x+y
b=ClassB()
b.add(1,2)
print(b.add(1,2))
