python学习面向对象Day13（P137~~148）

最新推荐文章于 2024-10-14 09:08:48 发布
最新推荐文章于 2024-10-14 09:08:48 发布
阅读量101 收藏
点赞数
分类专栏： Python基础学习笔记--达内B站课程 文章标签： python 学习 开发语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_43838595/article/details/129599462
版权
这篇博客回顾了Python面向对象编程的第12天内容，详细讲解了继承的概念、方法、变量，以及开闭原则和多态。通过实例解析了如何使用继承来设计代码，以及多态在代码中的应用，强调了继承和多态在提高代码复用性和灵活性方面的重要性。
摘要由CSDN通过智能技术生成

b站达内python课学习笔记

P137 Python面向对象-5.1 课程回顾

一、Day12复习

"""
    复习
        View   Model  Controller
        界面    数据    业务逻辑
        变化    载体     变化
"""


class XXController:
    def add_xx(self, a):
        print("Controller 添加了数据", a)


class XXView:
    def __init__(self):
        self.c = XXController()

    def input_xx(self):
        # 需求：调用XXController类中的实例方法add_xx
        self.c.add_xx(100)


v = XXView()
v.input_xx()

P138 Python面向对象-5.2 课后作业解析

一、练习1

在class StudentManagerController类内添加排序函数：

    def order_by_score(self):
        """
            根据成绩，对self.__stu_list进行升序排列
        """
        for r in range(len(self.__stu_list) - 1):
            for c in range(r + 1, len(self.__stu_list)):
                if self.__stu_list[r].score > self.__stu_list[c].score:
                    self.__stu_list[r], self.__stu_list[c] = self.__stu_list[c], self.__stu_list[r]

在class StudentManagerView类内添加函数：

    def __output_student_by_score(self):
        self.__manager.order_by_score()
        self.__output_students(self.__manager.stu_list)

P139 Python面向对象-5.3 继承

一、继承

"""
    继承 -- 方法
        财产：钱不用孩子挣，但是可以花。
        皇位：江山不用孩子打，但是可以坐。
        代码：子类不用写，但是可以用。
"""
'''
# 多个子类在概念上一致的，所以就抽象出一个父类.
# 多个子类的共性，可以提取到父类中.
# 在实际开发过程中：
# 从设计角度讲：先有子，再有父.
# 从编码角度讲：先有父,再有子.
'''

class Person:
    def say(self):
        print("说话")


class Student(Person):
    def study(self):
        print("学习")


class Teacher(Person):
    def teach(self):
        print("讲课")

P140 Python面向对象-5.4 继承的方法

一、继承的方法和父类子类间的关系

class Person:
    def say(self):
        print("说话")


class Student(Person):
    def study(self):
        print("学习")


class Teacher(Person):
    def teach(self):
        print("讲课")

'''
继承的方法
'''
s01 = Student()
# 子类对象可以调用子类成员，也可以调用父类成员.
s01.study()
s01.say()  # 父类成员

p01 = Person()
# 父类对象只可以调用父类成员,不能调用子类成员.
p01.say()

'''
父类和子类间的关系
'''
t01 = Teacher()

# python 内置函数
# 1. 判断对象是否属于一个类型
# "老师对象" 是 一个老师类型
print(isinstance(t01, Teacher))  # True
# "老师对象" 不是 一个学生类型
print(isinstance(t01, Student))  # False
# "老师对象" 是 一个人类型
print(isinstance(t01, Person))  # True

# 2.判断一个类型是否属于另一个类型
# "老师类型" 不是 一个学生类型
print(issubclass(Teacher, Student))  # False
# "老师类型" 是 一个人类型
print(issubclass(Teacher, Person))  # True
# "人类型" 不是 一个老师类型
print(issubclass(Person, Teacher))  # False

练习

"""
    定义父类
        动物（行为：叫）

    定义子类
        狗（行为：跑）
        鸟（行为：飞）

    创建三个类型的对象
    体会：isinstance(对象,类型)
    体会：issubclass(类型,类型)
"""


class Animal:
    def shout(self):
        print("喊叫")


class Bird(Animal):
    def fly(self):
        print("飞")


class Dog(Animal):
    def run(self):
        print("跑")


animal = Animal()
bird = Bird()
dog = Dog()
print(isinstance(animal, Bird))
print(isinstance(dog, Animal))

print(issubclass(Animal, Bird))
print(issubclass(Dog, Animal))

P141 Python面向对象-5.5 继承的变量

一、继承的变量

"""
    继承 -- 变量
"""


class Person:
    def __init__(self, name):
        self.name = name


"""
class Student(Person):
    # 子类若没有构造函数，使用父类的.
    pass

s01 = Student()
print(s01.name)
"""


class Student(Person):
    # 子类若具有构造函数，则必须先调用父类构造函数。
    def __init__(self, name, score):
        super().__init__(name)
        self.score = score


p01 = Person("李四")
print(p01.name)

s01 = Student("张三", 100)
print(s01.score)
print(s01.name)

内存图

在这里插入图片描述

练习

"""
    定义父类
        车（数据：品牌,速度）

    定义子类
        电动车（数据：电池容量,充电功率）

    创建两个对象
    画出内存图.
"""
class Car:
    """
        车
    """
    def __init__(self,brand,speed):
        self.brand = brand
        self.speed = speed

class Electrocar(Car):
    """
        电动车
    """
    def __init__(self,brand,speed,battery_capacity,charging_power):
        super().__init__(brand,speed)
        self.battery_capacity = battery_capacity
        self.charging_power = charging_power


c01 = Car("奔驰",230)
print(c01.brand)

e01 = Electrocar("比亚迪",120,15000,220)
print(e01.brand)
print(e01.charging_power)

P142 Python面向对象-5.6 继承的设计01

一、面向对象设计原则：开-闭原则

Open Closed Principle
对扩展开放，对修改关闭。
增加新功能，不改变原有代码。

示例代码


# 需求：老张开车去东北
# 变化：    坐飞机
#          坐火车
#          骑车
#          ...
'''
# 违反了开闭原则：
#  如果增加火车，需要增加"火车类",再修改人类中的go_to方法.
'''
class Person:
    def __init__(self, name):
        self.name = name

    def go_to(self, vehicle, str_position):

        # 如果是汽车
        if type(vehicle) == Car:
            vehicle.run(str_position)
        # 否则如果是飞机
        elif type(vehicle) == Airplane:
            vehicle.flay(str_position)


class Car:
    def run(self, str_position):
        print("汽车开到", str_position)


class Airplane:
    def flay(self, str_position):
        print("飞机飞到", str_position)


p01 = Person("老张")
c01 = Car()
a01 = Airplane()
p01.go_to(c01, "东北")
p01.go_to(a01, "东北")
示意图

在这里插入图片描述

P143 Python面向对象-5.7 继承的设计,多态

一、面向对象设计原则

1、类的单一职责（一个类的定义）

Single Responsibility Principle
一个类有且只有一个改变它的原因。

2、依赖倒置（依赖抽象）

Dependency Inversion Principle
客户端代码(调用的类)尽量依赖(使用)抽象的组件。
抽象的是稳定的。实现是多变的。

二、依赖倒置原则更替上述示意图

在这里插入图片描述

三、多态

父类的同一种动作或者行为，在不同的子类上有不同的实现。

用多态改进之前的代码，使其满足开闭原则

# 需求：老张开车去东北
# 变化：    坐飞机
#          坐火车
#          骑车
#          ...

class Vehicle:
    """
        交通工具,代表所有具体的交通工具(火车/飞机..)
        继承：隔离子类变化,将子类的共性(坐/飞..)提取到父类(运输)中.
    """

    def transport(self, str_position):
        # 因为父类太过于抽象，所以写不出方法体.
        pass


# 客户端代码，用交通工具。
class Person:
    def __init__(self, name):
        self.name = name

    def go_to(self, vehicle, str_position):
        # 多态：调用父，执行子.
        # 调用的是交通工具的运输方法
        # 执行的是飞机的运输方法或者汽车的运输方法
        vehicle.transport(str_position)


# -------以上是架构师完成的--以下是程序员完成的-----
class Car(Vehicle):
    def transport(self, str_position):
        print("汽车开到", str_position)


class Airplane(Vehicle):
    def transport(self, str_position):
        print("飞机飞到", str_position)


p01 = Person("老张")
c01 = Car()
a01 = Airplane()
p01.go_to(c01, "东北")
p01.go_to(a01, "东北")

P144~145 Python面向对象-5.8&5.9 习题练习01&02

一、练习1

"""
    手雷炸了，可能伤害敌人/玩家的生命.
             还可能伤害未知事物(鸭子.房子....)
    要求：增加了新事物，不影响手雷。
    体会：继承的作用
         多态的体现
         设计原则
            开闭原则
            单一职责
            依赖倒置
    画出设计图
    15:35
"""


class Granade:
    def __init__(self, atk):
        self.atk = atk

    def explode(self, damage_target):
        # 如果传入的不是子类，则报错.
        if not isinstance(damage_target, Damageable):
            raise ValueError("不是Damageable的子类")

        print("爆炸")
        # 多态:
        # 调用父类代表(玩家/敌人.....)的可以受伤者.
        # 执类行子(具体玩家/敌人.....)
        damage_target.damage(self.atk)


class Damageable:
    """
        可以受伤
        继承:统一多个子类的概念，隔离变化。
    """

    def damage(self, value):
        # 如果子类不重写，则异常。
        raise NotImplementedError()


# ------------------------------
class Player(Damageable):
    def __init__(self, hp):
        self.hp = hp

    def damage(self, value):
        self.hp -= value
        print("玩家受伤啦")
        print("碎屏")


class Enemy(Damageable):
    def __init__(self, hp):
        self.hp = hp

    def damage2(self, value):
        self.hp -= value
        print("敌人受伤喽")
        print("头顶爆字")


g01 = Granade(100)
e01 = Enemy(200)
p01 = Player(300)
g01.explode(p01)

示意图

在这里插入图片描述

P146 Python面向对象-5.10 习题练习03

一、练习1

"""
    定义图形管理器类
        1. 管理所有图形
        2. 提供计算所有图形总面积的方法

    具体图形:
        圆形(pi × r ** 2)
        矩形(长*宽)
        ...

    测试：
        创建1个圆形对象，1个矩形对象，添加到图形管理器中.
        调用图形管理器的计算面积方法，输出结果。

    要求：增加新图形，不修改图形管理器的代码.
    体会：面向对象三大特征：
            封装/继承/多态
         面向对象设计原则：
            开闭/单一/倒置

"""


class GraphicManager:
    def __init__(self):
        self.__graphics = []

    def add_graphic(self, graphic):
        if isinstance(graphic, Graphic):
            self.__graphics.append(graphic)
        else:
            raise ValueError()

    def get_total_area(self):
        total_area = 0
        # 遍历图形列表，累加每个图形的面积
        for item in self.__graphics:
            # 多态：
            # 调用的是图形
            # 执行的是圆形/矩形...
            total_area += item.calculate_area()
        return total_area

class Graphic:
    def calculate_area(self):
        # 如果子类不重写，则异常.
        raise NotImplementedError()
#-----------------------------------
class Circle(Graphic):
    def __init__(self,radius):
        self.radius = radius

    def calculate_area(self):
        return 3.14 * self.radius **2


class Rectanlge(Graphic):
    def __init__(self,length,width):
        self.lenght = length
        self.width = width


    def calculate_area(self):
        return self.lenght *  self.width


c01 = Circle(5)
r01 = Rectanlge(10,20)
manager = GraphicManager()
manager.add_graphic(c01)
manager.add_graphic(r01)
re = manager.get_total_area()
print(re)

示意图

在这里插入图片描述

P147 Python面向对象-5.11 类与类的关系

一、类与类的关系

泛化

子类与父类的关系，概念的复用，耦合度最高；
B类泛化A类，意味B类是A类的一种；
做法：B类继承A类

关联(聚合/组合)

部分与整体的关系，功能的复用，变化影响一个类；
A与B关联，意味着B是A的一部分；
做法：在A类中包含B类型成员。

依赖

合作关系，一种相对松散的协作，变化影响一个方法；
A类依赖B类，意味A类的某些功能靠B类实现；
做法：B类型作为A类中方法的参数，并不是A的成员。

二、设计原则：组合复用原则（复用的最佳实践）

Composite Reuse Principle
如果仅仅为了代码复用优先选择组合复用，而非继承复用。
组合的耦合性相对继承低。

举例示意图

在这里插入图片描述

P148 Python面向对象-5.12 作业及总结

一、继承

语法

  1. 代码
    class 子类(父类):
    def init(self,参数列表):
    super().init(参数列表)
    self.自身实例变量 = 参数
  2. 说明
    – 子类拥有父类的所有成员。
    – 子类如果没有构造函数，将自动执行父类的，但如果有构造函数将覆盖父类的。此时必须通过super()函数调用父类的构造函数，以确保父类属性被正常创建。

定义

  1. 重用现有类的功能与概念，并在此基础上进行扩展。
  2. 说明：
    – 子类直接具有父类的成员（共性），还可以扩展新功能。
    – 事物具有一定的层次、渊源，继承可以统一概念。
    例如：公司组织架构
    老板
    行政中心 营销中心 技术中心
    人力资源 行政部 销售部 策划部 研发部 产品部

优点

  1. 一种代码复用的方式。
  2. 以层次化的方式管理类。

缺点

耦合度高

作用

隔离客户端代码与功能的实现方式。

适用性

多个类在概念上是一致的，且需要进行统一的处理。

二、多态

定义

父类的同一种动作或者行为，在不同的子类上有不同的实现。

作用

  1. 继承将相关概念的共性进行抽象，多态在共性的基础上，体现类型的个性化（一个行为有不同的实现）。
  2. 增强程序扩展性，体现开闭原则。

重写

子类实现了父类中相同的方法（方法名、参数），在调用该方法时，实际调用的是子类的方法。

weixin_43838595
关注
专栏目录
python学习面向对象Day12（P127~~136）
weixin_43838595的博客
03-14 107
在 StudentManagerController 类里面添加删除学生的实例函数，如下。在 StudentManagerController 类里面添加修改学生的实例函数，如下。在 StudentManagerView 类里面添加 根据编号删除学生 的实例函数，如下。在 StudentManagerView 类里面添加 根据编号修改学生 的实例函数，如下。界面视图对象 数据模型对象 逻辑控制对象。界面视图类：负责处理界面逻辑，比如显示菜单，获取输入，显示结果等。
python学习基础篇Day02（P11~~23）
weixin_43838595的博客
03-05 475
关联一个对象的标识符（对象的内存地址）
Python中面向对象（学习笔记）
热门推荐
南枝向暖北枝寒
06-15 2万+
文章目录一、面向过程与面向对象简述面向过程编程面向对象编程二、类和对象类对象（实例）类和对象的关系三、类的定义四、类中的成员类属性实例函数（对象函数，成员函数）实例函数和普通函数的区别关于self创建对象（实例化对象）调用类中的实例函数动态绑定属性和限制绑定动态绑定属性限定绑定内存中的对象构造函数工作原理给 `__init__()` 设置参数析构函数1. 将对象定义为全局变量，程序执行完毕，对象自动被销毁2. 将对象定义为局部变量,当指定的函数执行完毕，则对象随着会被自动销毁3. 强制销毁对象，什么时候de
Day10 Python面向对象编程学习笔记10
MoreDeepStudy的博客
03-21 254
不同方法对不同类型地属性的访问权限 一般来说，访问权限的规律同类对象、实例对象的访问规律相同。类属性可以通过类方法来访问，也可以通过实例方法来访问；实例属性就在只能通过实例方法来访问；而对于静态方法从其本身的设计上来说就不允许访问任何的类型地属性，但也有特殊的办法来访问（如下面代码） class Person: age=10 de...
Day9 Python面向对象编程学习笔记9（静态方法）
MoreDeepStudy的博客
03-21 193
对于静态方法来说，它不需要传给它任何的第一个参数，实例或者是类都可以使用它。 class Person @staticmethod #静态方法的装饰器（与类方法的装饰器类似） def jingtaifangfa(): print("这是一个静态方法") p=Person() func=Person.jingtaifangfa Person.jingtaifangfa() fun...
Day 13 Python面向对象
H1912Aliyanyan的博客
12-30 462
封装的意义： 1：将属性和方法放到一起做为一个整体，然后通过实例化对象来处理； 2：隐藏内部实现细节，只需要和对象及其属性和方法交互就可以了； 3：对类的属性和方法增加 访问权限控制。 私有权限：在属性名和方法名 前面 加上两个下划线 __ 1：类的私有属性 和 私有方法，都不能通过对象直接访问，但是可以在本类内部访问； 2：类的私有属性 和 私有方法，都不会被子类继承，子类也无法访问； 3：私有属性 和 私有方法...
python面向对象的优点_python面向对象和面向过程介绍与区别
weixin_39859819的博客
11-23 802
一、面向对象和面向过程的区别：a.面向过程：1）根据业务逻辑从上到下写代码2）开发思路是将数据和函数按照执行的逻辑顺序组织在一起3）分开考虑数据与函数定义性文字：面向对象编程(Object Oriented Programming-OOP) 是一种解决软件复用的设计和编程方法。这种方法把软件系统中相近相似的操作逻辑和操作应用数据、状态,以类的型式描述出来, 以对象实例的形式在软件系统中复用,以达到...
Python复习 Day6 面向对象编程（二）
weixin_45492364的博客
04-26 1717
"""1、定义一个类求三条边构成的三角形周长和面积① 验证三条边能否构成三角② 计算周长、面积""""""三角形"""# 三条边a,b,c"""验证是否构成三角形""""""只读a"""@property"""只读b"""@property"""只读c"""@property@a.setter@b.setter@c.setterprint('三角形周长: %d' % int(self._a + self._b + self._c))
day01 python面向对象
weixin_47641251的博客
01-22 761
支持多继承，如果有不同的父类名，但有相同的方法，遵从先到先得的顺序，先继 承挨得近的父类及其父类的父类；# 类中的方法是所有对象共享的，只占用一份内存空间，方法被调用时会通过self来判断是哪个对象调用了实例方法。类内部通过定义函数方法去访问实例对象的私有属性，也可定义函数方法去调用实例对象的私有 方法。# 如果有多个对象，每个对象的属性是各自保存的，都有各自独立的地址。实例对象的私有方法：只能在类的内部调用 ，不能在类的外部调用。
python 面向对象属性_Python面向对象之属性
weixin_39657825的博客
11-30 83
属性的定义和调用1,定义时,在普通方法的基础上添加@property装饰器2,定义时,属性仅有一个self参数3,调用时,无需括号vim day7-8.py#!/usr/bin/python# -*- coding:utf-8 -*-class Pager():def __init__(self,current_page):self.current_page = current_page ...
python学习面向对象Day10（P107~~115）
weixin_43838595的博客
03-13 149
不建议在创建实例变量后，直接 变量名.xxx来创建xxx变量，如下面的s01.name和s01.sex。下面代码中，left()和right()函数独立于类Vectors，是面向过程的思维。(1) 至少有一个形参，第一个参数绑定调用这个方法的对象,一般命名为"self"。不建议通过实例变量访问类成员，如下面的print(s01.count)(2) 无论创建多少对象，方法只有一份，并且被所有对象共享。(2) 调用： 对象地址.实例方法名(参数列表)(2) 调用：类名.方法名(参数列表)
python学习面向对象Day09（P96~~106）
weixin_43838595的博客
03-11 168
分析出解决问题的步骤，然后逐步实现。例如：婚礼筹办– 发请柬（选照片、措词、制作）– 宴席（场地、找厨师、准备桌椅餐具、计划菜品、购买食材）– 婚礼仪式（定婚礼仪式流程、请主持人）公式：程序 = 算法 + 数据结构优点：所有环节、细节自己掌控。缺点：考虑所有细节，工作量大。代码class 类名:“””文档说明”””definit(self,参数列表):self.实例变量 = 参数。
day15Python中 的函数以及面向对象
Mr_ShanXingWei的博客
06-21 489
一 、Python中函数 函数的作用 提高代码的复用性 提高开发效率 减少维护代码维护量 2.定义函数格式 Def 函数名(): 代码 3.函数调用： 通过 函数名() 调用 4.函数的参数 定义：为了让一个函数更通用 例： #函数名里定义两个参数 def func(a,b): # 此参数为 形参 # 定义方法 c = a+b print(c) #调用时添加具体值 func(3,6) # 调用的参数为 实参 5.缺省参数 定义：在形
python之面向对象
CSDNwg的博客
01-03 417
python面向对象，类对象、实例对象底层内存解析，三大特性封装、继承、多态的实现
【人工智能学习之PaddleOCR快速上手】
Jiagym的博客
10-12 1277
在配置文件中，可以设置组建模型、优化器、损失函数、模型前后处理的参数，PaddleOCR从配置文件中读取到这些参数，进而组建出完整的训练流程，完成模型训练，在需要对模型进行优化的时，可以通过修改配置文件中的参数完成配置，使用简单且方便修改。而 L2 正则化中，添加正则化项的目的在于减少参数平方的总和。准确检测的标准是检测框与标注框的IOU大于某个阈值，正确识别的检测框中的文本与标注的文本相同。如果缺少带标注的数据，或者不想投入研发成本，建议直接调用开放的API，开放的API覆盖了目前比较常见的一些垂类。
Python 使用 Jarvis 算法或包装的凸包（Convex Hull using Jarvis’ Algorithm or Wrapping）
最新发布
csdn_aspnet的专栏
10-14 1162
例如，当输入 (0, 3), (0, 0), (0, 1), (3, 0), (3, 3) 时，它产生 (0, 3) (0, 0) (3, 0) (3, 3) 的输出；当输入 (0, 3), (0, 1), (0, 0), (3, 0), (3, 3) 时，输出为 (0, 3) (0, 1) (0, 0) (3, 0) (3, 3)。下一个点被选为在逆时针方向上领先于所有其他点的点，即，如果对于任何其他点 r，我们有“orientation(p, q, r) = 逆时针”，则下一个点是 q。
有趣的开源项目——Taipy(构建Python数据和AI Web应用程序)
Soul丶君的博客
10-11 910
Taipy 是专为数据科学家和机器学习工程师设计的，用于构建数据与 AI Web 应用程序的工具。⭐️ 使构建生产就绪的 Web 应用程序成为可能。⭐️ 无需学习新的语言，仅需 Python。⭐️ 专注于数据和 AI 算法，而不用担心开发和部署的复杂性。
Backend - Java 基础
是萝卜干呀的博客
10-11 842
知识量决定了未来能走多远
【python入门到精通专题】8.装饰器
情不知所起一往而深
10-13 771
什么是property属性？一种用起来像是使用的实例属性一样的特殊属性，可以对应于某个方法。class Foo:pass# 定义property属性@propertypassfoo_obj.func() # 调用实例方法foo_obj.prop # 调用property属性@propertyreturn 100定义时，在实例方法的基础上添加 @property 装饰器；并且仅有一个self参数调用时，无需括号。
Python面向对象编程入门指南
"Python 面向对象编程的入门介绍，包括类、类对象、实例对象、属性和方法的概念，以及属性的使用示例" 在Python编程中，面向对象编程是一种重要的编程范式，它允许我们将数据和操作这些数据的函数封装在一起，形成...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值