Python面向对象学习整理(二)

这篇具有很好参考价值的文章主要介绍了Python面向对象学习整理(二)。希望对大家有所帮助。如果存在错误或未考虑完全的地方,请大家不吝赐教,您也可以点击"举报违法"按钮提交疑问。

三、使用继承,封装,多态

3.1 使用继承

示例代码如下

class Dog():

    def __init__(self,name,age):
        self.name = name
        self.age = age

    # 定义公共方法
    def bark(self):
        print(f"{self.name} can bark")

class pipi(Dog):

    def play(self):
        print(f"{self.name} 会打滚")

class dandan(Dog):

    def other(self):
        print(f"{self.name} 会杂技")

dog1 = pipi("皮皮",2)
dog2 = dandan("蛋蛋",3)
dog1.play()
dog1.bark() # 调用公共的方法
dog2.other()

我们在上面的代码找那个分别编写了 pipi 类 和 dandan 类,它们分别继承于 Dog 类,因此他们都会具备 Dog 类具有的属性和方法,然后他们也可以拥有他们独有的属性和方法

3.2 方法的覆盖

3.2.1 一般的方法覆盖情况

假设有这种情况,子类和父类拥有同样的方法名,但是我们调用的方法是属于父类的还是子类的呢?我们改一下代码看看。

class Dog():

    def __init__(self,name,age):
        self.name = name
        self.age = age
        
    def bark(self):
        print(f"{self.name} can bark")

    def eat(self):
        print(f"{self.name} 喜欢吃鸡肉")

class pipi(Dog):

    def play(self):
        print(f"{self.name} 会打滚")

    def eat(self):
        print(f"{self.name} 喜欢吃火腿")


dog1 = pipi("皮皮",2)
dog1.eat()

运行结果:

皮皮喜欢吃火腿

所以我们发现,当子类和父类方法同名时,子类方法会覆盖父类的方法。

3.2.2 init 方法覆盖

当子类没有 init 方法的时候,它会直接继承 父类的 init 方法

当子类 定义了 init 方法的时候,在子类的 init() 中调用父类的 init()方法,和上面情况类似,区别就是调用父类 init() 方法的时机

子类定义了 init(),子类__init__() 中没有调用父类的方法,这时候注意,父类的私有属性无法调用,子类调用私有属性的 get 和 set 方法会报错

3.3 封装

封装的核心:封装是隐藏对象中一些不希望被外部访问到的属性或方法

在学习 Java 的过程中,我们进行封装操作的时候,设置属性的访问权限为 private(只在当前类可以访问),所以我们会使用 getter 和 setter 方法来修改属性的值。在 Python 中我们也可以使用 同样的 getter 和 setter 方法

3.3.1 封装程度(**)

class Dog():
# 安全性问题,属性值不能乱改
def init(self,name,age):
# 方式一,换一个属性名保存
self.hidden_name = name
self.hidden_age = age

def getAge(self):
    return self.hidden_age

def setAge(self, age):
    if age < 0 or age > 150:
        raise ValueError('年龄值不合格')
    self.hidden_age = age

虽然我们这样做, 还是不希望 hidden_xx 属性被外部访问,因此使用更高级的封装

3.3.2 封装程度(***)
class Retangle():

    # 内部访问,使用 hidden 任然可以被访问
    # 使用 __作为私有属性,是外部不可以被访问
    def __init__(self,width, height):
        self.__width = width
        self.__height = height

    def setWidth(self,width):
        self.__width = width

    def getWidth(self):
        return self.__width

    def setHeight(self,height):
        self.__height = height

    def getHeight(self):
        return self.__height

我们使用 ‘__’ 作为隐藏属性,使外部不可见,这也是很常用的一种方法,

接下来解释一下 双下划线的作用:

在 Python 中,双下换线是作为隐藏属性而存在的,但它其实还是可以通过方法访问的到的,在 Python 内部当中,双下划线实际上是把 属性换了一个更复杂的方式表示,比 hidden_属性 更复杂,它其实是把 __xxx 替换成了 _类名__属性名 表示。

所以 Python 中的封装一般做到这一步就差不多了


3.3.3 封装程度(******)

使用装饰器把 getter 和 setter 更好的封装

class Person():
    '''
        __xxxx 成为隐藏属性
        __name -> _Person__name

        使用 _xxx 作为私有属性,没有特殊需求,不要修改私有属性
        类一般使用属性或方法不可见可以使用单下划线
    '''
    # 使用一个
    def __init__(self,name):
        self.__name = name

    @property
    def name(self):
        return self.__name

    '''
        setter
        getter 方法更好的使用
        @property,将一个 get 方法,转换为对象属性
        @属性名.setter 讲一个 set 方法,转换为对象属性
        两者缺一不可
    '''

    # setter 方法的的装饰器: @属性名.setter
    @name.setter
    def name(self, name):
        self.__name = name



p = Person('猴赛雷')
p.name = 'aaa' # 使用属性的方式 调用 setter 和 getter
print(p.name)

3.4 多态

多态:它指的是一个声明为 A类型的变量,可能是指 A类型的对象,也可以是 A类型的任何子类对象

class Dog():

    def __init__(self,name,age):
        self.name = name

        if age > 100:
            raise ValueError("狗狗的年龄不可能这么大")
        self.__age = age

    def getAge(self):
        return self.__age

    def setAge(self,age):
        if age > 100:
            raise ValueError ("狗狗的年龄不可能这么大")
        self.__age = age

    # 定义公共方法
    def bark(self):
        print(f"{self.name} can bark")

    def eat(self):
        print(f"{self.name} 喜欢吃鸡肉")

class pipi(Dog):

    def play(self):
        print(f"{self.name} 会打滚")

    def eat(self):
        print(f"{self.name} 喜欢吃火腿")

    # 方法覆盖
    def bark(self):
        print(f"{self.name} 在叫,嘻嘻....")
class dandan(Dog):

    def other(self):
        print(f"{self.name} 会杂技")

def dog_bark(dog):
    if isinstance(dog, Dog):
        dog.bark()

d = Dog("阿拉斯加",3)
dog_bark(d)

d1 = pipi("小皮",2)
dog_bark(d1)

d2 = dandan("蛋蛋",1)
dog_bark(d2)

在上面的代码中,我们定义了一个 dog_bark() 方法,它可以介绍父类的对象,也可以接受子类的对象

使用多态,我们并不需要给每一个 子类定义一个调用 bark() 的方法,pipi_bark(), dandan_bark(),只需要定义一个 dog_bark(), 在调用的时候给它传递对应的子类对象即可。

面向对象三大特点总结

面向对象三大特征

1.封装(把一些重要属性封装起来,防止被查看)文章来源地址https://www.toymoban.com/news/detail-564824.html

  • 确保数据安全
  1. 继承(扩展)
  • 保证对象的访问扩展性
  1. 多态 (满足条件就是某种事务)
  • 保证程序的灵活性

到了这里,关于Python面向对象学习整理(二)的文章就介绍完了。如果您还想了解更多内容,请在右上角搜索TOY模板网以前的文章或继续浏览下面的相关文章,希望大家以后多多支持TOY模板网!

本文来自互联网用户投稿,该文观点仅代表作者本人,不代表本站立场。本站仅提供信息存储空间服务,不拥有所有权,不承担相关法律责任。如若转载,请注明出处: 如若内容造成侵权/违法违规/事实不符,请点击违法举报进行投诉反馈,一经查实,立即删除!

领支付宝红包 赞助服务器费用

相关文章

  • 【Python学习】—面向对象(九)

    类中不仅可以定义属性来记录数据,也可以定义函数,用来记录行为,类中定义的属性(变量)我们称之成员变量,类中定义的行为(函数),我们称之为成员方法。 表示对象本身的意思 只有通过self,成员方法才能访问类的成员变量 self出现在形参列表中,但是不占用参数

    2024年02月08日
    浏览(46)
  • 【python学习】面向对象编程1

    流水线形式 优点:逻辑清晰 (逻辑一步一步的,是一个系统) 缺点:扩展性差 (上一个函数的输出是下一个函数的输入) 对象是什么? Python中一切皆对象 对象:就是特征和技能的结合体。 面向对象编程:定义初一个个鲜明独特的对象,然后通过对象之间的交互编程。 优

    2024年01月22日
    浏览(76)
  • 【python学习】面向对象编程3

    面向过程编程:类似于工厂的流水线。 优点:逻辑清晰; 缺点:扩展性差。 面向对象编程:核心是对象二字,对象是属性和方法的集合体,面向对象编程就是一堆对象交互。 优点:扩展性强; 缺点:逻辑非常乱。 对象:属性和方法的集合体。 类:一系列相同属性和方法的

    2024年01月22日
    浏览(46)
  • Python学习之路-初识面向对象

    面向对象编程(英语:Object-oriented programming,缩写:OOP)是种具有对象概念的编程典范,同时也是一种程序开发的抽象方针。它将对象作为程序的基本单元,将程序和数据封装其中,以提高软件的重用性、灵活性和扩展性,对象里的程序可以访问及经常修改对象相关连的数据。

    2024年01月21日
    浏览(56)
  • Python学习笔记(二十)————面向对象

    (1)面向对象的好处 在日常中,记录数据时往往使用统一的表格,这样就不会使得数据信息格式混乱,同样在程序中的数据组织中,仅仅通过变量来记录会显得混乱不统一。 在程序中是可以做到和生活中那样,设计表格、生产表格、填写表格的组织形式的。 1. 在程序中 设

    2024年02月13日
    浏览(49)
  • Python面向对象编程,实现模块化开发

    面向对象编程(Object Oriented Programming,OOP)是一种编程范式,它将真实世界中的事物抽象成程序中的对象,并通过对象之间的相互作用来完成程序的逻辑。 封装 (Encapsulation) 封装是指把数据和行为结合成一个相对独立的整体,防止程序中其他部分直接访问或修改这个整体,而

    2024年02月05日
    浏览(142)
  • python学习笔记:第七章面向对象

    与java类似,python作为一种面向对象的编程语言,也可以创建自定义的对象和类。 它的特性主要有:继承,封装,多态,方法,属性,超类 两者转换 每个类对应每个对象,下面有类变量 起到封装变量,封装函数,代码的作用 格式 实例化类,给类赋值 在创建对象时,就会被

    2024年02月13日
    浏览(53)
  • Python学习之路-面向对象:三个基本特征

    封装:根据职责将属性和方法封装到一个抽象的类中 继承:实现代码的重用,相同的代码不需要重复的编写 多态:不同的对象调用相同的方法,产生不同的执行结果,增加代码的灵活度 封装是面向对象编程的一大特点,面向对象编程的第一步就是将属性和方法封装到一个抽

    2024年02月02日
    浏览(58)
  • 🔥🔥Java开发者的Python快速进修指南:面向对象进阶

    在上一期中,我们对Python中的对象声明进行了初步介绍。这一期,我们将深入探讨对象继承、组合以及多态这三个核心概念。不过,这里不打算赘述太多理论,因为我们都知道,Python与Java在这些方面的主要区别主要体现在语法上。例如,Python支持多重继承,这意味着一个类可

    2024年02月05日
    浏览(61)
  • 🔥🔥Java开发者的Python快速进修指南:面向对象基础

    当我深入学习了面向对象编程之后,我首先感受到的是代码编写的自由度大幅提升。不同于Java中严格的结构和约束,Python在面向对象的实现中展现出更加灵活和自由的特性。它使用了一些独特的,如self和cls,这些不仅增强了代码的可读性,还提供了对类和实例的明确

    2024年02月05日
    浏览(68)

觉得文章有用就打赏一下文章作者

支付宝扫一扫打赏

博客赞助

微信扫一扫打赏

请作者喝杯咖啡吧~博客赞助

支付宝扫一扫领取红包,优惠每天领

二维码1

领取红包

二维码2

领红包