自我总结20
目录
组合
什么是组合？
组合指的是一个对象中的属性，是另一个对象
为什么要使用组合？
组合目的和继承一样，为了减少代码冗余
如何使用组合
# 选课系统: 老师类,学生类,老师与学生都有名字,年龄,性别
# 组合实现:
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() # date_obj.tell_birth()
'''
总结:
继承:
类与类的关系,一种什么是什么的关系,子类与父类是从属关系.
组合:
对象与对象的关系,一种什么有什么的关系,一个对象拥有另一个对象.
'''
'''
选课系统需求:
1.学生类,老师类, 学生和老师都有课程属性, 每一门课程都是一个对象.
课程: 课程名字,课程周期,课程价钱
2.学生和老师都有选择课程的功能, 还有打印所有课程的功能.
'''
class People:
def __init__(self, name, age, sex):
self.name = name
self.age = age
self.sex = sex
# 添加一门课程方法
def add_course(self, course_obj):
self.course_list.append(course_obj)
# 打印当前对象中所有课程的课程信息
def tell_all_course(self):
# 拿到当前对象的课程列表,列表中存放的是一个个的课程对象
for course_obj in self.course_list:
# 每一个课程对象调用查看课程信息的方法
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_period, course_price):
# 课程名称\周期\价格
self.course_name = course_name
self.course_period = course_period
self.course_price = course_price
def tell_course_info(self):
print(f'''
课程名称: {self.course_name}
课程周期: {self.course_period}
课程价钱: {self.course_price}
''')
tea1 = Teacher('tank', 17, 'male')
stu1 = Student('张全蛋', 20, 'female')
python_obj = Course('python', 6, 2.0)
linux_obj = Course('linux', 6, 1.0)
# 添加python与linux课程
tea1.add_course(python_obj)
tea1.add_course(linux_obj)
# tea1.course_list[0].tell_course_info()
tea1.tell_all_course()
封装
什么是封装？
封：比如把一个袋子封起来
装：比如把一些东西装到袋子里
封装：把一堆属性(特征与技能)封装到一个对象中
存数据的目的是为了取，对象可以“.”的方式获取属性
比喻：对象就比一个袋子，袋子里面装一堆属性
为什么要封装？
封装的目的是为了方便存取，可以通过对象，属性的方式获取属
如何封装
在类内部，定义一堆属性(特征与技能)
特征：变量--->数据属性
技能：函数--->方法属性
在类内部，定义一堆属性
通过 对象.属性 = 属性值
访问限制机制
什么是访问限制机制？
在类内部定义，凡是以__开头的数据属性与方法属性
都会被python内部隐藏起来，让外部不能 直接 访问类内部的_开头的属性 比如_name = ‘tank’
访问限制机制的目的
一堆隐私的属性不能被外部轻易访问的属性，可以隐藏起来，不被外部直接调用
好处：对重要数据获取的逻辑更加严谨，从而保证数据的安全
隐私属性可以通过封装一个接口，在接口内做业务逻辑的处理，在把数据返回给调用者
注意：在python中，不会强制限制属性的访问，类内部__开头的属性，只是做了一种变形，若想直接访问，调用变形后的名字即可
_类名__属性名
# demo1:
class Foo:
# 数据属性
__name = 'tank'
# 方法属性
def __run(self):
print('running..')
# 接口: 获取数据接口
def get_name(self):
return self.__name
def set_name(self):
self.__name = 'jason_sb'
foo = Foo()
#通过接口访问
res = foo.get_name()
print(res) # tank
'''
class Foo:
__name = 'tank' #-->_类名__属性名
'''
# --> _Foo__name 强制访问python特有
print(foo._Foo__name) # tank
# 修改值接口
foo.set_name()
print(foo.get_name()) # jason_sb
# demo2:
class Teacher:
def __init__(self, name, age, sex):
self.__name = name
self.__age = age
self.__sex = sex
# 接口: 打印用户信息接口
def get_info(self):
# 用户认证
user = input('user: ').strip()
pwd = input('pwd: ').strip()
if user == 'tank' and pwd == '123':
print(f'''
姓名: {self.__name}
年龄: {self.__age}
性别: {self.__sex}
''')
# 接口: 修改用户信息接口
def set_info(self, name, age, sex):
# str1 = 'string' # str('string')
if not isinstance(name, str):
raise TypeError('名字必须要使用字符串')
if not isinstance(age, int):
raise TypeError('年龄必须是数字')
if not isinstance(sex, str):
raise TypeError('性别必须要使用字符串')
self.__name = name
self.__age = age
self.__sex = sex
# demo3: 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
使用它的目的,是将类内部的方法 (def 方法名()) 变成了 (def 方法).
在对象调用某个方法时,将对象.方法()变成对象.方法(看起来想一个普通的数据属性)
如何使用 property
@property
def 类内部的方法(self):
'''
计算人体的bmi: bmi值 = 体重 / (身高 * 身高)
'''
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('jason', 200, 1.6)
# print(p.bmi())
print(p.bmi) # ---> p.bmi()
'''
obj.bmi() == obj.bmi
'''
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中，不会强制要求子类必须遵循父类的一套标准，所以出现了抽象类
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('哼哼哼~~~')
# 猫
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('汪汪汪~~~')
# 正确教材
pig = Pig()
cat = Cat()
dog = Dog()
pig.speak()
cat.speak()
dog.speak()
抽象类：
是什么？
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('汪汪汪~~~')
