组合
什么是组合
组合指的是一个对象中的属性，该属性的值指向的是另一个对象。
组合的作用
组合的目的和继承一样，为了减少代码冗余
如何使用组合
class People:
def __init__(self,name,age,sex):
self.name=name
self.age=age
self.sex=sex
class Teacher(People):
def __init__(self,name,age,sex):
super().__init__(name,age,sex)
class Student(People):
def __init__(self,name,age,sex):
super().__init__(name,age,sex)
class Date:
def __init__(self,year,month,day):
self.year=year
self.month=month
self.day=day
def tell_birth(self):
print(f'''
===出生年月日===
年：{self.year}
月：{self.month}
日：{self.day}''')
tea1=Teacher('tank',17,'male')
date_obj=Date(2002,1,1)
tea1.date=date_obj#将date对象赋值到tea1对象的date属性中
tea1.date.tell_birth()
'''
===出生年月日===
年：2002
月：1
日：1'''
总结
继承
类与类的关系，一种什么是什么的关系，子类与父类是从属关系。
组合
对象与对象的关系，一种什么有什么的关系，一个对象拥有另一个对象
封装
什么是封装
比喻：
封：比如把一个袋子封起来
装：比如把一堆小猫小狗装到袋子类
封装指的是把一堆属性封装到一个对象中
存数据的目的是为了取，对象可以“.”的方式获取属性
比喻：
对象就好比一个袋子，袋子里面装着一堆属性
为什么封装
封装的目的是为了方便存取，可以通过对象.属性的方式获取属性
如何封装
特征：变量---》数据属性
技能：函数---》方法属性
在类内部，定义一堆属性
通过对象.属性=属性值
访问限制机制
什么是访问限制机制
在类内部定义，凡是以__开头的数据属性与方法属性，都会被python内部隐藏起来，让外部不能直接访问类内部的__开头的属性，比如：__name='tank'
访问限制机制的目的
一堆隐私的属性与不能被外部轻易访问的属性，可以隐藏起来，不被外部直接调用
好处：
对重要数据获取的逻辑更加严谨，进而保证了数据的安全。
接口：
隐私属性可以通过封装一个接口，在接口内做业务逻辑的处理，再把数据返回给调用者
注意：
在python中，不会强制限制属性的访问，在类内部__开头的属性，只是做了一种变形，若想直接访问，调用变形后的名字即可。
class Foo:
__name='tank'#-->_类名__属性名
class Foo:
__name='tank'
def __run(self):
print('running....')
def get_name(self):
return self.__name
def set_name(self):
self.__name='jason'
foo=Foo()
print(foo.get_name())#tank
print(foo._Foo__name)#tank
foo.set_name()
print(foo.get_name())#jason
class ATM:
def __insert_card(self):
print('插卡')
def __input_pwd(self):
print('密码验证')
def withdraw(self):
self.__input_pwd()
self.__insert_card()
atm=ATM()
atm.withdraw()
'''
密码验证
插卡'''
property
什么是property
python内置的装饰器，主要是给类内部的方法使用
为什么要用property
使用它的目的，是将类内部的方法def 方法名()变成了def 方法名。
在对象调用某个方法时，将对象.方法（）变成对象.方法（看起来像一个普通的数据属性）
如何使用property
@property
class People:
def __init__(self,name,weight,height):
self.name=name
self.weight=weight
self.height=height
@property
def bmi(self):
return self.weight/(self.height*self.height)
p=People('name',200,1.8)
print(p.bmi)#61.72839506172839
# 注意：不能对被装饰的方法属性修改
#了解 若真的通过此方法修改属性，可以通过另一种方式修改
class People:
def __init__(self,name,weight,height):
self.name=name
self.weight=weight
self.height=height
@property
def bmi(self):
return self.weight/(self.height*self.height)
@property
def get_name(self):
return self.name
@get_name.setter
def set_name(self,val):
self.name=val
@get_name.deleter
def del_name(self):
del self.name
p=People('jason',200,1.8)
print(p.get_name)#jason
p.set_name='bank'
print(p.get_name)#bank
del p.del_name#删除name这个属性
print(p.get_name)
多态
什么是多态
多态指的是同一种事物的多种形态。
多态的目的
多态也称之为多态性，在程序中继承就是多态的表现形式
多态的目的就是为了，让多种不同类型的对象，在使用相同功能的情况下，调用同一个名字的方法名
父类：定义一套统一的标准
子类：遵循父类统一的标准
多态的最终目的：统一子类编写的规范，为了让使用者更方便调用相同功能的方法
如何实现
class Animal:
def eat(self):
pass
def drink(self):
pass
def speak(self):
pass
class Pig(Animal):
def eat(self):
print('猪仔吃点')
pass
def drink(self):
pass
def speak(self):
print('哼哼哼')
pass
class Cat(Animal):
def eat(self):
print('猫吃点')
pass
def drink(self):
pass
def speak(self):
print('喵喵喵喵')
pass
pig=Pig()
cat=Cat()
pig.speak()#哼哼哼
cat.speak()#喵喵喵喵
抽象类
什么是抽象类
abc模块 abstract_class
目的
强制子类必须遵循父类的一套标准
如何使用
import abc
class Animal(metaclass=abc.ABCMeta):
# 吃
@abc.abstractmethod
def eat(self):
pass
# 喝
@abc.abstractmethod
def drink(self):
pass
# 叫
@abc.abstractmethod
def speak(self):
pass
# 猪
class Pig(Animal):
# 吃
def eat(self):
print('猪在吃饭')
pass
# 喝
def drink(self):
pass
def speak(self):
print('哼哼哼~~~')
# 派生
def run(self):
pass
鸭子类型
什么是鸭子类型
在不知道当前对象是何物的情况下,但是你长得像鸭子,那么你就是鸭子类型.在python中,不推荐使用抽象类强制限制子类的定义,但是推荐类都遵循鸭子类型.
继承：
耦合性太高，程序的可扩展性差
鸭子类型：
耦合性低，程序的可扩展性强
多态炫技
# 猪
class Pig:
# 吃
def eat(self):
print('猪在吃饭')
pass
# 喝
def drink(self):
pass
def speak(self):
print('哼哼哼~~~')
# 猫
class Cat:
# 吃
def eat(self):
print('猫在吃饭')
pass
# 喝
def drink(self):
pass
def speak(self):
print('喵喵喵~~')
# 狗
class Dog:
# 吃
def eat(self):
print('狗在吃饭')
pass
# 喝
def drink(self):
pass
def speak(self):
print('汪汪汪~~~')
dog = Dog()
cat = Cat()
pig = Pig()
def BARK(animal):
animal.speak()
BARK(dog)
BARK(cat)
BARK(pig)