一、组合
什么是组合？
组合指的是一个对象中，包含另一个或多个对象
为什么要用组合？
减少代码冗余，提高程序的可扩展性
如何使用组合？
class People:
def __init__(self,name,age,sex):
self.name = name
self.age = age
self.sex = 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}
''')
stu1 = Student('baohan',18,'male')
date_obj = Date(2001,6,23)
#学生对象中包含一个自定义日期对象
stu1.date_obj = date_obj
# print(stu1.date_obj.year, stu1.date_obj.month, stu1.date_obj.day)
stu1.date_obj.tell_birth()练习需求:
选课系统:
1.有学生、老师类，学生与老师有属性 “名字、年龄、性别、课程列表”，
2.方法: 老师与学生可以添加课程， 打印学习/教授课程。
3.课程对象:
- 属性:
- 课程名字
- 课程价格
- 课程周期
- 方法:
- 打印当前课程信息
-
# 组合实现
class People:
def __init__(self,name,age,sex):
self.name = name
self.age = age
self.sex = sex
#添加课程
def add_course(self,course_obj): #self --->stu1
self.course_list.append(course_obj) #self --->stu1 [python_obj,go_obj
#打印当前对象中课程列表的所有课程信息
# --->打印所有课程
def tell_all_course_info(self): #self --->stu1
#从当前对象中课程列表中取出所有的课程对象
# self.course_list == [python_obj, go_obj]
for course_obj in self.course_list:
# 1.course_obj ---> python_obj
# 2.course_obj ---> go_obj
#通过课程对象，打印课程信息方法
# python_obj.tell_course_info(), go_obj.tell_course_info()
course_obj.tell_course_info()
class Teacher(People):
def __init__(self,name,age,sex):
super().__init__(name,age,sex)
#为当前对象添加课程列表属性 ---> []
self.course_list = []
class Student(People):
def __init__(self,name,age,sex):
super().__init__(name,age,sex)
#为当前对象添加课程列表属性 ---> []
self.course_list = []
#定义一个课程类，课程有：课程名称，课程价格，课程周期
class Course:
def __init__(self,course_name,course_price,course_time):
self.course_name = course_name
self.course_price = course_price
self.course_time = course_time
#定义打印课程方法：只打印当前课程信息
def tell_course_info(self):
print(f'''
======课程信息======
课程名称：{self.course_name}
课程价格：{self.course_price}
课程周期：{self.course_time}
''')
#学生对象 属性: name,age,sex,course_list 方法: add_course,tell_all_course_info
stu1 = Student('baohan',18,'male')
#课程对象；属性: course_name,course_price,course_time 方法: tell_course_info
python_obj = Course('python',20000,6)
go_obj =Course('go',28888,8)
#学生对象调用父类的添加课程功能
stu1.add_course(python_obj)
stu1.add_course(go_obj)
# 学生调用打印 学生课程列表中所有课程的信息
stu1.tell_all_course_info()总结：
- 继承：是类与类的关系，子类继承父类的属性/方法，子类与父类是一种“从属”的关系
- 组合：组合是对象与对象的关系，一个对象包含另一个或多个对象
二、封装
2.1 什么是封装
封：比如将一个袋子，封起来。
装：比如将一堆东西装在袋子里。
封装指的是可以将一堆属性和方法，封装到对象中。
ps：
- 对象就好比一个“袋子/容器”，可以存放一堆属性和方法
- 存不是目的，存的目的是为了取，可以通过"对象."的方式获取属性或方法
2.2 为什么要封装？
封装不是单纯意义的隐藏
1：封装数据：主要原因是：保护私隐，明确区分内外。将数据隐藏起来这不是目的。隐藏起来然后对外提供操作该数据的接口，然后我们可以在接口附加上对该数据操作的限制，以此完成对数据属性操作的严格控制。
2：封装方法：目的是隔离复杂度
封装方法举例：
电视机本身是一个黑盒子，隐藏了所有细节，但是一定会对外提供了一堆按钮，这些按钮也正是接口的概念，所以说，封装并不是单纯意义的隐藏！！！
快门就是傻瓜相机为傻瓜们提供的方法，该方法将内部复杂的照相功能都隐藏起来了
提示：在编程语言里，对外提供的接口（接口可理解为了一个入口），可以是函数，称为接口函数，这与接口的概念还不一样，接口代表一组接口函数的集合体。
2.3 如何封装?
class User:
x = 10
def func()
pass
obj = User()
obj.y = 20
#obj ---> x , func, y三、访问限制机制
3.1 什么是访问限制机制？
凡是在类内部定义的以__开头的属性或方法名，都会被限制，外部不能“直接访问”该原型。需要注意的是，这种机制也并没有真正意义上限制我们从外部直接访问属性，知道了类名和属性名就可以拼出名字：_类名__属性，然后就可以访问了，即这种操作并不是严格意义上的限制外部访问，仅仅只是一种语法意义上的变形，主要用来限制外部的直接访问。
注意：凡是在类内部定义 __方法的属性和方法，都会变形为_类名__属性/方法
3.2 为什么要有访问限制机制？
可以将一些隐私的数据隐藏起来，不让外部轻易获取（设置成私有的）。
接口：可以将一对数据封装成一个接口，可以让用户调用接口，并且通过相应的逻辑，最后再将数据返回给用户。
3.3 如何实现访问限制机制？
其实这仅仅这只是一种变形操作，且仅仅只在类定义阶段发生变形
类中所有双下划线开头的名称如__x都会在类定义时自动变形成：_类名__x的形式：
class User:
#__开头的属性
__name = 'tank' #__name 变形为 ---> _类名__name
#__开头的方法
def __run(self):
print('tank is runing...')
#print(User.__name) #报错
obj = User()
print(obj._User__name)在继承中，父类如果不想让子类覆盖自己的方法，可以将方法定义为私有的，如下：
#正常情况
>>> class A:
... def fa(self):
... print('from A')
... def test(self):
... self.fa()
...
>>> class B(A):
... def fa(self):
... print('from B')
...
>>> obj = B()
>>> obj.test() # b.test --- >B---->A----> b.fa()----> b 是 B 的对象，在 B 里找 fa
from B
#把fa定义成私有的，即__fa
>>> class A:
... def __fa(self): #在定义时就变形为_A__fa
... print('from A')
... def test(self):
... self.__fa()# 在定义的时候就变形了，self.__fa() 变成：self._A__fa()
...
>>> class B(A):
... def __fa(self): # _B__fa
... print('from B')
...
>>> b=B()
>>> b.test() # b.test --- >B没有---->找A的test----> b.fa()----> b._A__fa 找的A的 __fa
from A 例：
class User:
# 开头的属性
__name = 'tank' # __name变形为 ---》 _类名__name
__age = 17
__sex = 'male'
# 校验接口，获取用户信息
def par_user(self, username, password):
if username == 'tank' and password == '123':
print(f'''
通过验证，获取用户信息。
用户名: {self.__name}
用户年龄: {self.__age}
用户性别: {self.__sex}
''')
else:
print('校验失败,无法查询用户信息')
#__开头的方法
def __run(self):
print('tank is running..')
obj = User()
obj.par_user('tank','123')
四、property
4.1、什么是property?
是一个python内置的装饰器，可以装饰在类内部的方法上。
可以将该方法 ----> 对象.方法() ----> 对象.方法
4.2 为什么要用property?
ps:
1.在某些场景下，调用的方法只是用来获取计算后的某个值。
2.目的是为了迷惑调用者把调用的方法误以为是属性。
4.3 如何使用？
class User:
def __init__(self,name,weight,height):
self.__name = name
self.weight = weight
self.height = height
#获取BMI指数的方法
@property
def bmi(self):
return self.weight/(self.height**2)
user_obj = User('baohan',50,1.67)
#user_obj.bmi 此时就不用加括号了，让别人看起来就像执行了属性一样
print(user_obj.bmi)# 需求: 计算人体 bmi 指数
# 体重 / 身高的平方
class User:
def __init__(self,name,weight,height):
self.__name = name
self.weight = weight
self.height = height
#获取BMI指数的方法
@property
def bmi(self):
return self.weight/(self.height**2)
#了解：设置被property装饰后的方法
@property
def name(self):
return self.__name
#注意：需要修改的方法名字要与被property装饰器后的方法一样
@name.setter
def name(self,value):
self.__name = value
user_obj = User('baohan',50,1.67)
#user_obj.bmi 此时就不用加括号了，让别人看起来就像执行了属性一样
print(user_obj.name)
user_obj.name ='gaogao'
print(user_obj.name)# 需求: 计算人体 bmi 指数
# 体重 / 身高的平方
class User:
def __init__(self,name,weight,height):
self.__name = name
self.weight = weight
self.height = height
#获取BMI指数的方法
@property
def bmi(self):
return self.weight/(self.height**2)
#了解：设置被property装饰后的方法
@property
def name(self):
return self.__name
#注意：需要修改的方法名字要与被property装饰器后的方法一样
@name.setter
def name(self,value):
self.__name = value
@name.deleter
def name(self): #删除属性
del self.__name
user_obj = User('baohan',50,1.67)
#print(user_obj.bmi)
del user_obj.name
# print(user_obj.name)