python 面向对象三大特征详解

目录
  • 一、面向对象三大特征介绍
    • 1、封装(隐藏)
    • 2、继承
    • 3、多态
  • 二、继承
    • 1、语法格式
    • 2、类成员的继承和重写
    • 3、super()获得父类定义
    • 4、设计模式_工厂模式实现
  • 5、设计模式_单例模式实现
  • 总结

一、面向对象三大特征介绍

Python 是面向对象的语言,也支持面向对象编程的三大特性:继承、封装(隐藏)、多态。

1、封装(隐藏)

隐藏对象的属性和实现细节,只对外提供必要的方法。

通过“私有属性、私有方法”的方式,实现“封装”。Python 追求简洁的语法

2、继承

继承可以让子类具有父类的特性,提高了代码的重用性。从设计上是一种增量进化,原有父类设计不变的情况下,可以增加新的功能,或者改进已有的算法。

3、多态

多态是指同一个方法调用由于对象不同会产生不同的行为。生活中这样的例子比比皆是:同样是休息方法,人不同休息方法不同。张三休息是睡觉,李四休息是玩游戏,程序员休息是“敲几行代码”。

二、继承

继承是面向对象程序设计的重要特征,也是实现“代码复用”的重要手段。
如果一个新类继承自一个设计好的类,就直接具备了已有类的特征,就大大降低了工作
难度。已有的类,我们称为“父类或者基类”,新的类,我们称为“子类或者派生类”。

1、语法格式

Python 支持多重继承,一个子类可以继承多个父类。继承的语法格式如下:

class 子类类名(父类 1[,父类 2,...]):

类体:如果在类定义中没有指定父类,则默认父类是 object 类。也就是说,object 是所有类的父类,里面定义了一些所有类共有的默认实现,比如:__new__()。

定义子类时,必须在其构造函数中调用父类的构造函数。调用格式如下:

父类名.__init__(self, 参数列表)

class Person:
    def __init__(self,name,age):
        self.name = name
        self.__age = age
    def say_age(self):
        print("年龄是:",self.__age)
class Student(Person):
    def __init__(self,name,age,grade):
        self.grade = grade
        Person.__init__(self,name,age)
# 构造函数中包含调用父类构造函数。根据需要,不是必须。 子类并不会自动调用父类的__init__(),我
# 们必须显式的调用它。
if __name__ == '__main__':
    s=Student('诸葛',18,1)
    s.say_age()

2、类成员的继承和重写

1. 成员继承:子类继承了父类除构造方法之外的所有成员。

2. 方法重写:子类可以重新定义父类中的方法,这样就会覆盖父类的方法,也称为“重写”

class Person:
    def __init__(self,name,age):
        self.name = name
        self.__age = age
    def say_age(self):
        print("年龄是:",self.__age)
class Student(Person):
    def __init__(self,name,age,grade):
        self.grade = grade
        Person.__init__(self,name,age)
    def say_age(self):
        print(self.name,"的年龄是:",self.age)
# 构造函数中包含调用父类构造函数。根据需要,不是必须。 子类并不会自动调用父类的__init__(),我
# 们必须显式的调用它。
if __name__ == '__main__':
    s=Student('诸葛',18,1)
    s.say_age()

3、super()获得父类定义

在子类中,如果想要获得父类的方法时,我们可以通过 super()来做。

super()代表父类的定义,不是父类对象。

class A:
    def say(self):
        print("A: ",self)
        print("say AAA")
class B(A):
    def say(self):
        #A.say(self) 调用父类的 say 方法
        super().say() #通过 super()调用父类的方法
        print("say BBB")
if __name__ =="__main__:
    b = B()
    b.say()

4、设计模式_工厂模式实现

工厂模式实现了创建者和调用者的分离,使用专门的工厂类将选择实现类、创建对象进行统一的管理和控制。

class CarFactory:
    def createCar(self,brand):
        if brand == "1":
            return one()
        elif brand == "2":
            return two()
        elif brand == '3':
            return three()
        else:
            return "未知品牌,无法创建"
class one:
    pass
class two:
    pass
class three:
    pass
factory = CarFactory()
c1 = factory.createCar("1")
c2 = factory.createCar("2")
print(c1)
print(c2)

5、设计模式_单例模式实现

单例模式(Singleton Pattern)的核心作用是确保一个类只有一个实例,并且提供一个访问该实例的全局访问点。

单例模式只生成一个实例对象,减少了对系统资源的开销。当一个对象的产生需要比较多的资源,如读取配置文件、产生其他依赖对象时,可以产生一个“单例对象”,然后永久驻留内存中,从而极大的降低开销。

class One:
    __obj = None   #  用于存储这个单例
    __init_flag = True
    def __new__(cls, *args, **kwargs):
         # 指的是One这个类里面的  类属性
         if cls.__obj == None:
               # object 是类的默认父类
             cls.__obj = object.__new__(cls)
         return cls.__obj
    def __init__(self,name):
        if One.__init_flag:
            print( "init....")
            self.name = name
            One.__init_flag = False
if __name__=='__main__':
    a = One( "aa")
    print(a)
    b = One( "bb")
    print(b)

总结

本篇文章就到这里了,希望能够给你带来帮助,也希望您能够多多关注我们的更多内容!

(0)

相关推荐

  • 基于python生成器封装的协程类

    自从python2.2提供了yield关键字之后,python的生成器的很大一部分用途就是可以用来构建协同程序,能够将函数挂起返回中间值并能从上次离开的地方继续执行.python2.5的时候,这种生成器更加接近完全的协程,因为提供了将值和异常传递回到一个继续执行的函数中,当等待生成器的时候,生成器能返回控制. python提供的生成器设施: yield:能够将自己挂起,并提供一个返回值给等待方 send:唤起一个被挂起的生成器,并能够传递一个参数,可以在生成器中抛出异常 next:本质上相当于s

  • python的继承详解

    目录 1.单继承:子类只继承一个父类 2.多继承:子类继承多个父类 3.子类重写父类的同名属性和方法 4.子类调用父类同名属性和方法 5. 6.调用父类方法super() 总结 1.单继承:子类只继承一个父类 举例:煎饼果子老师傅在煎饼果子界摸爬滚打几十年,拥有一身精湛的煎饼果子技术, 并总结了一套"古法煎饼果子配方". 可是老师傅年迈已久, 在嗝屁之前希望把自己的配方传承下去,于是老师傅把配方传给他的徒弟大猫... 虽然子类没有定义__init__方法初始化属性,也没有定义实例方法,

  • Python 面向对象之封装、继承、多态操作实例分析

    本文实例讲述了Python 面向对象之封装.继承.多态操作.分享给大家供大家参考,具体如下: 封装.继承.多态 是面向对象的3大特性 为啥要封装 好处 在使用面向过程编程时,当需要对数据处理时,需要考虑用哪个模板中哪个函数来进行操作,但是当用面向对象编程时,因为已经将数据存储到了这个独立的空间中,这个独立的空间(即对象)中通过一个特殊的变量(class)能够获取到类(模板),而且这个类中的方法是有一定数量的,与此类无关的将不会出现在本类中,因此需要对数据处理时,可以很快速的定位到需要的方法是谁

  • Python 面向对象编程的三大特性之继承

    目录 Python  面向对象编程的三大特性之继承 一.继承 1.继承的实际栗子 2.继承的好处 3.继承的使用场景 4.继承有几种? 5.Python 中继承的简单语法 二.不使用继承.使用继承的区别 1.需求背景 2.不使用继承 2.使用继承 三.继承的传递性 1.什么是传递性 四.继承和抽象 1.继承的重点 Python  面向对象编程的三大特性之继承 一.继承 继承也是面向对象编程三大特性之一 继承是类与类的一种关系 定义一个新的 class 时,可以从某个现有的 class 继承 新的

  • python excel和yaml文件的读取封装

    excel import os import xlrd PATH = lambda p: os.path.abspath( os.path.join(os.path.dirname(__file__), p) ) class ExcelData: def __init__(self, file, sheet="sheet1", title=True): # 判断文件存在不存在 if os.path.isfile(PATH(file)): self.file = PATH(file) s

  • Python面向对象封装继承和多态示例讲解

    面向对象的三大特征:封装,继承,多态 1.封装: 提高程序的安全性 将数据(属性)和行为(方法)包装到类对象中,在方法内部对属性进行对象的外部调用方法. 这样无需关心内部的具体实现. 在python中没有专门的修饰符用于属性的私有,如果属性不希望被访问,前面使用两个下划线 2.继承: 提高代码的复用性 3.提高程序的可拓展性和可 维护性. 1. 封装 我们来看看私有方式的使用: # 作者:互联网老辛 # 开发时间:2021/4/4/0004 22:11 class Student: def __

  • python 面向对象三大特征详解

    目录 一.面向对象三大特征介绍 1.封装(隐藏) 2.继承 3.多态 二.继承 1.语法格式 2.类成员的继承和重写 3.super()获得父类定义 4.设计模式_工厂模式实现 5.设计模式_单例模式实现 总结 一.面向对象三大特征介绍 Python 是面向对象的语言,也支持面向对象编程的三大特性:继承.封装(隐藏).多态. 1.封装(隐藏) 隐藏对象的属性和实现细节,只对外提供必要的方法. 通过"私有属性.私有方法"的方式,实现"封装".Python 追求简洁的语

  • Python面向对象三大特征 封装、继承、多态

    目录 1.封装 1.1 私有属性和私有方法 2.继承 2.1 方法的重写 2.2 在子类方法中调用父类方法 2.3 多继承 2.4 新式类和经典类 3.多态 1.封装 封装: 根据 职责 将 属性 和 方法 封装到一个 抽象的类 中将数据(属性)和行为(方法)包装到类对象中.在方法内部对属性进行操作,在类对象的外部调用方法.这样无需关心方法 内部的具体实现,从而隔离了复杂度 封装是面向对象编程的一大特点 面向对象编程的第一步.将属性和方法封装到一个抽象的类中 外界使用类创建对象,然后让对象调用方

  • Python面向对象之模块详解

    目录 1.1 导入模块 1.1.1 import 模块名 1.1.2 from 模块名 import 功能名 1.1.3 from -import* 1.1.4 as 定义别名 1.2 制作模块 1.2.1 定义模块 1.2.2 测试模块 1.2.3 外部调用 1.3 模块定位顺序 1.4 all 总结 1.1 导入模块 import 模块名 form 模块名import 功能名 form 模块名 import * import 模块名 as 别名 import 模块名 import 功能名 a

  • javascript面向对象三大特征之多态实例详解

    本文实例讲述了javascript面向对象三大特征之多态.分享给大家供大家参考,具体如下: 多态 从某种意义上来说,多态是面向对象中重要的一部分,也是实施继承的主要目的. 一个实例可以拥有多个类型,它既可以是这种类型,也可以是那种类型,这种多种状态被称为类的多态. 多态的表现形式很多,其中继承和重载都是多态的表现形式. --整理自<jQuery开发从入门到精通> 继承 继承本身是多态的一种实现.详情请参考前面一篇:https://www.jb51.net/article/166097.htm

  • javascript面向对象三大特征之继承实例详解

    本文实例讲述了javascript面向对象三大特征之继承.分享给大家供大家参考,具体如下: 继承 在JavaScript中的继承的实质就是子代可以拥有父代公开的一些属性和方法,在js编程时,我们一般将相同的属性放到父类中,然后在子类定义自己独特的属性,这样的好处是减少代码重复.继承是面向对象的基础,是代码重用的一种重要机制. --此文整理自 <jQuery 开发从入门到精通> ,这是本好书,讲的很详细,建议购买阅读. 继承的作用 实现继承的主要作用是: ① 子类实例可以共享超类属性和方法. ②

  • javascript面向对象三大特征之封装实例详解

    本文实例讲述了javascript面向对象三大特征之封装.分享给大家供大家参考,具体如下: 封装 封装(Encapsulation):就是把对象内部数据和操作细节进行隐藏.很多面向对象语言都支持封装特性,提供关键字如private来隐藏某些属性和方法.要想访问被封装对象中的数据,只能使用对象专门提供的对外接口,这个接口一般为方法.调用该方法能够获取对象内部数据. 在JavaScript语言中没有提供专门的信息封装关键字,不过可以使用闭包来创建,只允许从对象内部访问的方法和属性.另外,接口也是数据

  • 对python sklearn one-hot编码详解

    one-hot编码的作用 使用one-hot编码,将离散特征的取值扩展到了欧式空间,离散特征的某个取值就对应欧式空间的某个点 将离散特征通过one-hot编码映射到欧式空间,是因为,在回归,分类,聚类等机器学习算法中,特征之间距离的计算或相似度的计算是非常重要的,而我们常用的距离或相似度的计算都是在欧式空间的相似度计算,计算余弦相似性,基于的就是欧式空间. sklearn的一个例子 from sklearn import preprocessing enc = preprocessing.One

  • Python locust工具使用详解

    今年负责部门的人员培养工作,最近在部门内部分享和讲解了locust这个工具,今天再博客园记录下培训细节.相信你看完博客,一定可以上手locust这个性能测试框架了. 一.简介 1.优势 locust是python语言开发的一款的开源的的性能测试框架,他比jmeter更加的轻量级,主要是通过协程(gevent)的方式去实现并发,通过协程的方式可以大幅提高单机的并发能力,同时避免系统级的资源调度.locust具有开源性.分布式.支持高并发,支持webUI的操作方式. 2.劣势 locust的图表功能

  • python机器学习之线性回归详解

    一.python机器学习–线性回归 线性回归是最简单的机器学习模型,其形式简单,易于实现,同时也是很多机器学习模型的基础. 对于一个给定的训练集数据,线性回归的目的就是找到一个与这些数据最吻合的线性函数. 二.OLS线性回归 2.1 Ordinary Least Squares 最小二乘法 一般情况下,线性回归假设模型为下,其中w为模型参数 线性回归模型通常使用MSE(均方误差)作为损失函数,假设有m个样本,均方损失函数为:(所有实例预测值与实际值误差平方的均值) 由于模型的训练目标为找到使得损

  • Python MNIST手写体识别详解与试练

    [人工智能项目]MNIST手写体识别实验及分析 1.实验内容简述 1.1 实验环境 本实验采用的软硬件实验环境如表所示: 在Windows操作系统下,采用基于Tensorflow的Keras的深度学习框架,对MNIST进行训练和测试. 采用keras的深度学习框架,keras是一个专为简单的神经网络组装而设计的Python库,具有大量预先包装的网络类型,包括二维和三维风格的卷积网络.短期和长期的网络以及更广泛的一般网络.使用keras构建网络是直接的,keras在其Api设计中使用的语义是面向层

随机推荐