组合
什么是组合
组合指的是一个对象中的属性,是另一个对象
为什么要使用组合
减少代码冗余
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 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',14,'male')
date_obj = Date(2005,1,1)
# date_obj.tell_birth()
# 将date对象赋值到tea1对象的date属性中
tea1.date = date_obj
总结:
继承: 类与类的关系,一种什么是什么的关系,子类与父类是从属关系
组合: 对象与对象的关系,一种什么有什么的关系,一个对象拥有另一个对象
封装
什么是封装
比喻:
封: 比如把一个袋子封起来
装: 比如把一堆小猫小狗装到袋子里
封装指的是把一堆属性(特征与技能)封装到一个对象中
存数据的目的是为了取,对象可以'.' 的方式获取属性
比喻: 对象就好比一个袋子,袋子里面装一堆属性
为什么要封装
封装的目的是为了方便存取,可以通过对象.属性方式获取属性
如何封装
特征: 变量 ---> 数据属性
技能: 函数 ---> 方法属性
在类内部,定义一堆属性(特性与技能).
通过 对象.属性 = 属性值
访问限制机制
什么是访问限制机制
在类内部定义,凡事以__开头的数据属性与方法属性,都会被隐藏起来
外部不能直接访问类内部的属性
比如: __name = ‘tank’
访问限制机制的目的
一堆隐私的属性与不能被外部轻易访问的属性,可以影藏起来,不被外部直接调用
好处:
对重要数据获取的逻辑更加严谨,进而保证了数据的安全
接口 : 隐私属性可以通过封装一个接口,在接口内做业务逻辑的处理,再
把数据返回给调用者
注意 : 在python中,不会强制限制属性的访问,类内部__开头的属性,只是做了一次变形
若想直接访问,调用变形
class Foo:
__name = 'tank' # --> __类名__属性名
# 例如:ATM
class ATM:
# 1.插卡
def __insert_card(self):
print('插卡')
pass
# 2.输入密码
def __input_pwd(self):
print('密码验证')
pass
# 3.输入取款金额
def __input_money(self):
print('输入金额')
pass
# 4.开始吐钱
def __get_money(self):
print('执行吐钱')
pass
# 5.打印账单
def __print_flow(self):
print('打印账单')
pass
# 取钱直接接口
def withdraw(self):
self.__insert_card()
self.__input_pwd()
self.__input_money()
self.__get_money()
self.__print_flow()
print('取款程序执行完毕!')
atm = ATM()
atm.withdraw()
property
什么是property
python内置的装饰器,主要是给类内部的方法使用.
为什么要用property
使用它的目的,是将类内部的方法
如何使用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)
# 了解
@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.6)
注意: 不能对被装饰过的方法属性修改
了解: 若真要改通过此方法修改属性,可以用另一种方式修改
print(p.get_name)
p.set_name = 'tank'
print(p.get_name)
# p.del_name()
# print(p.get_name)
del p.del_name
print(p.get_name)
多态
什么是多态
多态指的是同一种事物的多种形态
多态的目的
多态也称之为多态性,在程序中继承就是多态的表现形式
多态的目的是为了,让多种不同类型的对象,在使用相同功能的情况下,调用同一个名字的方法名
父类: 定义一套统一的标准
子类: 遵循父类统一的标准
多态的最终目的: 统一子类编写的规范,为了让使用者更方便调用相同功能的方法
如何实现
继承
注意: 在python中,不会强制要求子类必须遵守父类的一套标准,所以出现了抽象类
抽象类
是什么
abc模块 abstract_class
使用的目的
强制子类必须遵守父类的一套标准
如何使用
import abc
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
pig = Pig()
鸭子类型
什么是鸭子类型
在不知道对象是何物的情况下,但是你长得像鸭子,那么你就是鸭子类型
鸭子在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('汪汪汪~~~')
继承:
耦合性高,扩展性差
鸭子类型:
耦合度低,程序的可扩展性强
多态炫技操作
# 猪
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)
str1 = '1234'
list1 = [1, 2, 3]
print(str1.__len__())
print(list1.__len__())
def LEN(d):
return d.__len__()
print(LEN(str1))
print(LEN(list1))
print(len(str1))
print(len(list1))