Ŀ¼
组合指的是一个对象中的属性，该属性的值指向的是另一个对象。
组合的目的和继承一样，为了减少代码冗余
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内部隐藏起来，让外部不能直接访问类内部的__开头的属性
一堆隐私的属性与不能被外部轻易访问的属性，可以隐藏起来，不被外部直接调用
好处：
对重要数据获取的逻辑更加严谨，进而保证了数据的安全。
接口：
隐私属性可以通过封装一个接口，在接口内做业务逻辑的处理，再把数据返回给调用者
注意：
在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
python内置的装饰器，主要是给类内部的方法使用
使用它的目的，是将类内部的方法def 方法名()变成了def 方法名。
在对象调用某个方法时，将对象.方法（）变成对象.方法
@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('pig eat') pass def drink(self): pass def speak(self): print('pig speak') pass class Cat(Animal): def eat(self): print('cat eat') pass def drink(self): pass def speak(self): print('cat speak') 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('pig eat') pass # 喝 def drink(self): pass def speak(self): print('pig speak') # 派生 def run(self): pass 在不知道当前对象是何物的情况下,但是你长得像鸭子,那么你就是鸭子类型.在python中,不推荐使用抽象类强制限制子类的定义,但是推荐类都遵循鸭子类型.
继承：
耦合性太高，程序的可扩展性差
鸭子类型：
耦合性低，程序的可扩展性强
# 猪 class Pig: # 吃 def eat(self): print('pig eat') pass # 喝 def drink(self): pass def speak(self): print('pig speak') # 猫 class Cat: # 吃 def eat(self): print('cat eat') pass # 喝 def drink(self): pass def speak(self): print('cat speak') # 狗 class Dog: # 吃 def eat(self): print('dog eat') pass # 喝 def drink(self): pass def speak(self): print('dog speak') dog = Dog() cat = Cat() pig = Pig() def BARK(animal): animal.speak() BARK(dog) BARK(cat) BARK(pig) 来源：博客园
作者：KONNE
链接：https://www.cnblogs.com/lyyblog0715/p/11657985.html