day21总结

其他 2019-10-11 15:24:00 阅读次数: 0

目录

组合

1.什么是组合?
组合指的是一个对象中的属性,是另一个对象.
2.为什么要使用组合?
组合目的和继承一样, 为了减少代码冗余.
3.如何使用组合:

# 选课系统: 老师类,学生类,老师与学生都有名字,年龄,性别
# class People:
#     def __init__(self, name, age, sex, year, month, day):
#         self.name = name
#         self.age = age
#         self.sex = sex
#         self.year = year
#         self.month = month
#         self.day = day
#
#     def tell_birth(self):
#         print(f'''
#         === 出生年月日 ===
#         年: {self.year}
#         月: {self.month}
#         日: {self.day}
#         ''')
#
#
# class Teacher(People):
#     def __init__(self, name, age, sex, year, month, day):
#         super().__init__(name, age, sex,  year, month, day)
#
#
# class Student(People):
#     def __init__(self, name, age, sex,  year, month, day):
#         super().__init__(name, age, sex,  year, month, day)
#
#
# tea1 = Teacher('tank', 17, 'male', 2002, 1, 1)
# tea1.tell_birth()
#
# stu1 = Student('大壮壮', 69, 'female', 1950, 11, 11)
# stu1.tell_birth()


# 组合实现:
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)
# date_obj.tell_birth()
# 将date对象赋值到tea1对象的date属性中
tea1.date = date_obj
tea1.date.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()

封装

1.什么是封装?
比喻:
封: 比如把一个袋子封起来.
装: 比如把一堆小猫,小狗,nick装到袋子里.
封装指的是把一堆属性(特征与技能)封装到一个对象中.
存数据的目的是为了取, 对象可以"."的方式获取属性.
比喻: 对象就好比一个袋子, 袋子里面装一堆属性.
2.为什么要封装?
封装的目的为了方便存取,可以通过对象.属性的方式获取属性.
3.如何封装
特征: 变量 ---> 数据属性
技能: 函数 ---> 方法属性
在类内部,定义一堆属性(特征与技能).
通过 对象.属性 = 属性值

访问限制机制

1.什么是访问限制机制?
在类内部定义, 凡是以__开头的数据属性与方法属性,
都会被python内部隐藏起来,让外部不能"直接"访问类内部的__开头的属性.
比如: __name = 'tank'
2.访问限制机制的目的?
一堆隐私的属性与不能被外部轻易访问的属性, 可以隐藏起来,不被外部直接调用.
好处:
对重要数据获取的逻辑更加严谨, 进而保证了数据的安全.
接口: 隐私属性可以通过封装一个接口,在接口内做业务逻辑的处理,再把数据返回给调用者.
注意: 在python中,不会强制限制属性的访问,类内部__开头的属性,只是做了一种变形.
若想直接访问, 调用变形后的名字即可.
class Foo:
__name = 'tank' # ---> _类名__属性名

# # 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()
# # print(foo.__name)
# # res = foo.get_name()
# # print(res)
# # print(foo._Foo__name)  # --> _Foo__name
# foo.set_name()
# print(foo.get_name())



# 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
#
#
# tea1 = Teacher('tank', 17, 'male')
# # tea1.get_info()
# tea1.set_info('jason_sb', 101, 'female')
# tea1.get_info()


# 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

1.什么是property
python内置的装饰器, 主要是给类内部的方法使用.
2.为什么要用property
使用它的目的,是将类内部的方法 (def 方法名()) 变成了 (def 方法).
在对象调用某个方法时,将对象.方法()变成对象.方法(看起来想一个普通的数据属性)
3.如何使用property
@property

'''
计算人体的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)

    # 了解
    @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.bmi())  # 打印动词,看起来不合理
# print(p.bmi)  # ---> p.bmi()

# 注意: 不能对被装饰过的方法属性修改.
# p.bmi = 18


# 了解: 若真要通过此方法修改属性,可以通过另一种方式修改.
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)

多态

1.什么是多态?
多态指的是同一种事物的多种形态.
2.多态的目的:
多态也称之为多态性, 在程序中继承就是多态的表现形式.
多态的目的是为了, 让多种不同类型的对象, 在使用相同功能的情况下,调用同一个名字的方法名.
父类: 定义一套统一的标准.
子类: 遵循父类统一的标准.
多态的最终目的: 统一子类编写的规范, 为了让使用者更方便调用相同功能的方法.
3.如何实现:
- 继承
注意: 在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()


# 反面教材
# 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 jiao(self):
#         print('哼哼哼~~~')
#
#
# # 猫
# class Cat:
#     # 吃
#     def eat(self):
#         print('猫在吃饭')
#         pass
#
#     # 喝
#     def drink(self):
#         pass
#
#     def han(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()

抽象类

1.是什么?
abc模块 abstract_class
2.使用的目的?
强制子类必须遵循父类的一套标准.
3.如何使用
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()

鸭子类型

1.什么是鸭子类型?
在不知道当前对象是何物的情况下,但是你长得像鸭子,那么你就是鸭子类型.
在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))

猜你喜欢

转载自www.cnblogs.com/zhm-cyt/p/11654322.html
今日推荐
基于大语言模型的开源知识库问答系统 MaxKB GitHub Star 数量突破 5,000 个！
美国拟限制 AI 大模型出口中国和俄罗斯
苹果将与 OpenAI 达成协议，将 ChatGPT 应用于 iPhone
openKylin 社区生态委员会第六次会议圆满召开
阿里云正式发布通义千问 2.5
Python 3.13 发布首个 Beta：实验性自由线程模式和 JIT、改进交互式解释器
Stack Overflow 拿我的代码去训练 AI 大模型，还封了我的账号
Pop!_OS 的 COSMIC 桌面完成 App Store 上架工作
《2024 年一季度互联网投融资运行情况》研究报告
报告：Django 仍然是 74% 开发者的首选
15 年前上了“FFmpeg 耻辱柱”，今天他还得谢谢咱——腾讯QQPlayer一雪前耻？
TIOBE 5 月榜单：Fortran “复活”进入 Top 10
周排行
记一下去大梅沙的准备（2018-05-26）
Spring 注解 事务
基于HTTP协议的客户端缓存
阿里云rds 备份和还原
[PHP] 几个拖慢 PHP 程序/API 运行速度的点
python 代码风格------------PEP8规则
js控制json生成菜单——自制菜单（一）
将字符串: 'k:1|k1:2|k2:3|k3:4 ' ,处理成 python 字典: {'k':1, 'k1':2, ...}
微信小程序转支付宝小程序
Qt551.窗口滚动条
每日归档
更多
2024-05-13(18)
2024-05-12(0)
2024-05-11(38)
2024-05-10(38)
2024-05-09(35)
2024-05-08(42)
2024-05-07(14)
2024-05-06(40)
2024-05-05(0)
2024-05-04(7)

代码天地 © 2018 codetd.com

境外服务器   最新电视剧2022