python中的组合

什么是组合：组合指的是一个对象中，包含另一个对象。

为什么要用组合：减少代码冗余

如何使用组合：

# 实现组合
​
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}
        ''')
​
​
s1 = Teacher('wanglu', 18, 'female')
d1 = Date(1997, 1, 29)
s1.d1 = d1
d1.tell_birth()
print(s1.d1.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_info(self):
        # 从当前对象中课程列表中取出所有课程对象
        for course_obj in self.course_list:
            course_obj.tell_course_info()
​
​
# 学生类
class Student(People):
    def __init__(self, name, age, sex):
        super().__init__(name, age, sex)
        self.course_list = []
​
​
# 老师类
class Teacher(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}
        ''')
​
​
# 创建学生对象
s1 = Student('wanglu', 19, 'female')
​
​
# 创建课程对象
c1 = Course('python', 66666, 6)
c2 = Course('go', 7777, 2)
​
# 当前学生添加了课程对象
# 添加python课程
s1.add_course(c1)
# 添加go语言
s1.add_course(c2)
​
# 当前学生打印所有课程信息
s1.tell_all_course_info()

访问限制

什么是访问限制机制：

凡是在类内定义的属性或方法，都会被限制，外部不能直接访问，该属性原型

ps：看着像将该属性或方法隐藏起来了

python特有的：

注意：凡是在类内部定义__开头的属性或方法，都会变形为，

_类名__属性/方法。

为什么要有访问限制：

比如：将一些隐私的数据，隐藏起来，不让外部轻易获取。

接口：

可以将一对数据封装成一个借口，可以让用户调用接口，

并且通过相应的逻辑，最后再将数据返回给用户。

class User:
    # __开头的属性
    __name = 'wanglu'
    __age = 19
    __sex = 'male'
    __ID = '2745140829'
    __bal = 131415926
    def __init__(self, name, age, sex):
        self.__name = name
        self.__age = age
        self.__sex = sex
        # 校验接口，获取用户数据
    def parse_user(self, username, password):
        if username == 'wanglu_jam' and password == '123':
            print(f'''
            通过验证，获取用户信息
            用户名：{self.__name}
            用户年龄：{self.__age}
            用户性别：{self.__sex}
            身份ID{self.__ID}
            用户资产：{self.__bal}
            ''')
        else:
            print('校验失败')
​
    # __开头的方法
    def __run(self):
        print('wanglu is lovely...')
​
obj = User('wanglu', 19, 'famale')
obj.parse_user('wanglu_jam', '123')
​
print(obj._User__name)

封装介绍

'''
夺命三问:
    1.什么是封装？
        封: 比如将一个袋子，封起来。
        装: 比如将一堆小猫、小狗和jason装在袋子里。
        # 对象 ---> 相当于一个袋子
        封装指的是可以将一堆属性和方法，封装到对象中。
​
        PS: 对象就好比一个 “袋子/容器”，可以存放一对属性和方法。
        PS: 存不是目的，目的是为了取，可以通过 “对象.” 的方式获取属性或方法。
​
    2.为什么要封装？
        可以通过 “对象.” 的方式 “存放/获取” 属性或方法。
        对象拥有 "." 的机制。
        方便数据的存取。
​
    3.如何封装？
        class User:
            x = 10
            def func():
                pass
        obj = User()
        obj.y = 20
        obj ---> x, func, y

 

原文地址：https://www.cnblogs.com/zhangjinyi97/p/11944595.html