一文,让你彻底了解,Python面向对象三大特性

面向对象的三大特性 面向对象编程(Object-Oriented Programming,简称OOP)是当代软件开发中广泛采用的一种编程范式。它以“对象”作为基本单位,强调对象的封装、继承和多态这三大特性,使得代码更加清晰、可维护且易于扩展. 阅读详情

Python面向对象三大特性

封装

封装顾名思义就是:将内部实现包裹起来,对外透明,提供api接口进行调用的机制
含义:对外面隐藏对象的属性和方法,仅提供接口
作用:安全性(通过私有变量改变对外的使用),复用性好

# 封装示例
#!/usr/bin/env python
# -*- coding:utf-8 -*-

class Student(object):
    def __init__(self, name, score):
        # 属性仅前面有两个下划线代表私有变量,外部无法访问,因此我们定义了两个新的方法,
        # 这样可以避免外部通过score乱改分数,仅当我们自己知道接口才可以修改
        self.__name = name
        self.__score = score

    def info(self):
        print('name: %s ; score: %d' % (self.__name,self.__score))

    def getScore(self):
        return self.__score

    def setScore(self, score):
        self.__score = score

stu = Student('Tom',99)
print('修改前分数:',stu.getScore())
stu.info()
stu.setScore(59)
print('修改后分数:',stu.getScore())
stu.info()

继承

继承:即一个派生类(derived class)继承父类(base class)的变量和方法。
面向对象编程有个好处就是代码复用,而其中一种方法就是通过继承机制。继承就是说定义的一个新类,继承现有的类,获得现有类的非私有属性、方法。提到个私有,就是上面提到的那个前面加两个下划线的那个东西,他在外部无法调用,继承他的子类也不能。被继承的那个类称为基类、父类或超类,子类也可以叫做派生类。

单继承

单继承: 子类只继承一个父类

  1. 子类继承父类可以使用父类的方法和属性
  2. 继承的好处:是子类可以复用父类的代码
class Person(object): # Person是object子类, 
    
    def __init__(self):
        self.name = 'zs'
    def show(self):
        print('show')
        
# Teacher类继承于Person类
class Teacher(Person):
    pass
# 继承的调用
teacher = Teacher()  
teacher.name  # zs
teacher.show()  # show
多继承
# 多继承:相当于继承多个父类
class A(object):
    
    def show(self):
        print('A show')
        
class B(object):
    
    def show_info(self):
        print('B')
        
    def show(self):
        print("B show")
# 类C 继承于A,B同时可以使用A,B方法和属性
class C(A,B):
    pass

# 如果多个父类中有相同的方法名,默认调用括号中前面的类
C().show()  # A show
C().show_info()  # B
print(C.mro()) # mro表示类的继承顺序

多态

多态:是指一种事物的多种形态,根据对象类型的不同以不同的方式进行处理。
不同的 子类对象调用 相同的 父类方法,产生 不同的 执行结果,可以增加代码的外部 调用灵活度,都继承了一个父类,并且 都重写的父类的方法,让不同的对象调用相同的方法,会产生不同结果

# 创建一个主类
class Animal(object):
    # 添加属性name
    def __init__(self, name):
        self.name = name

    def run(self):
        pass

    def animalRun(self):
        self.run()

# 继承于Animal
class Cat(Animal):
    def run(self):
        print('cat is running')

# 继承于Animal
class Dog(Animal):
    def run(self):
        print('dog is running')
# 因为有name属性,所以必须传参
d = Dog('lllll')
c = Cat('pppppp')

# 主类调用方法,把对象传进去
Animal.animalRun(c)  # cat is running
Animal.animalRun(d)  # dog is running
Python 面向对象三大特性:封装、继承与多态的深度解析 在 Python 中,可使用abc模块定义抽象基类和抽象方法,来规范子类必须实现的接口,进一步强化多态的约束性。passprint(f"使用信用卡支付 {amount} 元")print(f"使用支付宝支付 {amount} 元")Payment作为抽象基类,定义了抽象方法pay,子类CreditCardPayment和AlipayPayment必须实现pay方法,确保了在支付功能接口上的统一,体现了多态的规范与灵活性。 阅读详情

相关推荐

python面向对象——三大特性

python面向对象——三大特性 1. 引言 Python是面向对象的语言,自然也支持面向对象的三大特性:封装、继承、多态。 因为Python2已经较为古老,所有除非是阐述区别,大部分情况下Python2的经典类在博文中我都会忽略。 2. 继承 继承是一种创新类的方式,在Python中,新建的类可以继承一个或多个父类,父类又可以称为基类或超类,新建的类称为派生类或子类。 Python中的类的继承可分为:单继承和多继承 优点:减少了代码的冗余 实现了代码的重用,子类可以继承父类,并且可以继承多个父类(

星尘博客_优快云镜像 1419

大一第四次培训

继承 类的封装、继承、多态 3 大特性,前面已经详细介绍了 Python 类的封装,本节继续讲解 Python 类的继承机制。 继承机制经常用于创建和现有类功能类似的新类,又或是新类只需要在现有类基础上添加一些成员(属性和方法),但又不想直接将现有类代码复制给新类。也就是说,通过使用继承这种机制,可以轻松实现类的重复使用。 举个例子,假设现有一个 Shape 类,该类的 draw() 方法可以在屏幕上画出指定的形状,现在需要创建一个 Form 类,要求此类不但可以在屏幕上画出指定的形状,还可以计算出所画

weixin_45945399的博客 462

python面向对象三大特性:封装,继承,多态

面向编程三大特性:封装(隐藏),继承,多态。 一. 封装 通过私有属性,私有方法的方式实现封装。 二. 继承 python支持多重继承,一个之类可以继承多个父类。 class 子类类名(父类1,父类2,…): 类体 父类名.__init__(self,参数列表) 1.成员继承:子类继承了父类除构造方法之外的所有成员。 2.方法重写:子类可以重新定义父类中的方法,这样就会覆盖父类中的方法,也称为重写。 通过类的方法**dir()**查看对象属性 重写__str__方法: 用于返回一个对于“

rosefun96的博客 1657

python之三大特性

1、python的三大特性:继承、多态、封装 2、python 没有接口这个概念,接口类,抽象类: 归一化设计. 制定一个规范:凡是继承我类的类,必须有我规定的方法. from abc import ABCMeta,abstractmethod class Payment(metaclass=ABCMeta): # 抽象类(接口类): @abs...

云深海阔专栏 4413

ndnSIM学习笔记(一)

在接下来的一段时间要用ndnSIM来做自己的仿真网络,需要系统的学习相关内容,以下为内容记录。1.安装      1.1核心依赖(必需的)             • python >= 2.6             • libsqlite3             • libcrypto++             • pkg-config             • Boost lib...

gaonjzzz的博客 2987

C# 原生数字孪生的尝试

本文介绍了使用C#实现数字孪生的基本思路。首先从爱普生官网下载机器人3D模型,然后通过Blender创建并导出带动画的FBX模型。在WPF项目中,使用HelixToolkit.SharpDX等插件加载模型,通过Viewport3DX进行3D渲染。关键点是通过动画控制器接收真实设备信号来驱动模型动画,实现物理实体与虚拟模型的同步。文中提供了完整的代码实现,包括模型导入、动画播放控制等核心功能。该方法为构建数字孪生系统提供了一种可行的技术方案。

qq_33529095的博客 1334

python面向对象:三大特性

面向对象的三大特性是指:封装、继承和多态。封装:顾名思义就是将内容封装到某个地方,以后再去调用被封装在某处的内容。继承:即一个派生类(derived class)继承基类(base class)的字段和方法。继承也允许把一个派生类的对象作为一个基类对象对待。例如,有这样一个设计:一个Dog类型的对象派生自Animal类,这是模拟"是一个(is-a)"关系(例图,Dog是一个Animal)。多态:Pyhon不支持Java和C#这一类强类型语言中多态的写法,但它是原生多态,其Python崇尚“鸭子类型”

阿极的博客 1739

Ansys Motor-CAD:概述(EMag、THERM、LAB、MECH)

在这篇博客中,我概述了如何使用 Ansys Motor-CAD 模型、模拟、分析和后处理结果来评估电机性能,并帮助您为您的应用选择优化的电机,并通过电机设计选择实现成本效益和效率。我介绍了各种可用的电机类型、可供选择的物理模块和可配置的多物理选项。E-Mag 物理模块有许多选项卡,涵盖几何创建、材料选择、电磁设置、条件、求解器类型、解决方案模型、耦合设置等的所有设置。热物理模块有许多选项卡,涵盖几何创建、材料选择、热设置、条件、求解器类型、解决方案模型、耦合设置等的所有设置。分析结果的速度相结合。

jkh920184196的博客 1761

python的面向对象与其三大特性(封装、继承、多态全面详解)

提示:文章写完后,目录可以自动生成,如何生成可参考右边的帮助文档 面向对象概述前言知识目标能力目标一、面向对象是什么?二、对象和类1、什么是类?1、类与对象的关系ps:总结三、特别注意面向对象的三个基本特征1.封装2.继承3.多态四、编程练习代码简单演示五、总结 前言 –写下本文的原因是为了加深印象,当然如果大家能从本文有所收获,对我来说就是最大的满足了。(╹▽╹) 知识目标 1、掌握面向过程与面向对象的概念 2、理解面向对象编程思想 3、掌握类和对象的概念 4、掌握面向对象设计基本步骤 能力目标 .

Argonaut_的博客 3172

从零开始:用Xilinx FPGA实现RISC-V单周期CPU(附完整Verilog代码)

本文详细介绍了如何使用Xilinx FPGA从零开始实现RISC-V单周期CPU,包括开发环境搭建、核心架构设计、Verilog代码实现及功能验证。通过实战指南和完整代码示例,帮助开发者掌握RISC-V CPU设计的关键技术,适用于嵌入式系统和定制化计算场景。

weixin_30664051的博客 547

2023-07-04 Fast-Lio论文中公式(6)与BCH公式中近似雅可比公式的一致性推导

将(1)式代入(6)式,就有。

wmorries的博客 480

python类与类的三大特性

类 定义:在 Python 中,类的定义与函数的定义类似,所不同的是,类的定义是使用关键字 “class”。与函数定义相同的是,在定义类时也要使用缩进的形式,以表示缩进的语句属于该类。类的定义形式如下。 与函数定义相同,在使用类之前必须先定义类。类的定义一般放在脚本的头部。在 Python 中也可以在 if 语句的分支或者函数定义中定义类。下面的代码定义了一个 human 类,并定义了相关的属性。 class human: # 定义 human 类 age = 0 # 定义 age.

weixin_45113508的博客 852

BeckHoff <--> ABB 机器手 Profinet 通讯

本文介绍了BeckHoff PLC与ABB机器人通过PROFINET通信的实现方案。主要内容包括:1)通信接口的详细变量定义,涵盖输入/输出信号、设备状态监控、夹爪控制等关键功能位;2)全局数据结构和变量配置说明;3)机器人任务控制程序的实现方法,包括参数校验、任务指令下发和状态监控机制;4)重点分析了任务调度功能块的代码逻辑,涉及慢速模式处理、多参数配置和执行状态判断。该方案通过结构化变量定义和模块化程序设计,实现了PLC对机器人作业的精确控制,为工业自动化系统集成提供了可靠通信范例。

工控智联驿站 1033

Python 面向对象三大特性详解

封装是面向对象编程的一个基本特性,它指的是将数据(属性)和操作数据的方法(函数)封装成一个整体,即类。封装的核心思想是隐藏对象的内部实现细节,只暴露接口让外部通过这些接口与对象交互。这不仅能提高代码的安全性,还能降低系统复杂度。继承是面向对象编程中的一个重要特性,它允许我们创建一个新类,新类可以继承已有类的属性和方法。继承提供了一种机制,让我们可以在不修改现有代码的基础上创建新的功能。通过继承,子类可以复用父类的代码,并且可以在子类中扩展或重写父类的方法。多态是指同一个方法在不同对象上表现出不同的行为。

m0_64881179的博客 2264

【C语言】字符常量详解

字符常量是C语言中处理字符数据的重要工具。通过单引号括起一个字符,我们可以方便地使用字符常量进行字符判断、字符运算和字符串处理等操作。理解字符常量的表示方法、使用场景和ASCII码对应关系,对于编写高效的C语言程序至关重要。

LuckiBit 5023

MATLAB 图像滤波:高通、低通、带通和方向滤波器

在 MATLAB 中,我们可以使用不同类型的滤波器对图像进行处理,包括高通滤波器、低通滤波器、带通滤波器和方向滤波器。通过以上代码示例,我们介绍了 MATLAB 中使用高通滤波器、低通滤波器、带通滤波器和方向滤波器对图像进行滤波的方法。高斯滤波器可以实现带通滤波效果,通过调整滤波器的方差参数可以控制带通滤波器的频率范围。这里的平均滤波器是一种常见的低通滤波器,通过对图像周围的像素进行平均来实现平滑效果。Sobel 滤波器是一种常用的方向滤波器,用于检测图像中的水平和垂直边缘。函数将高通滤波器应用于图像。

CyberSparkZ的博客 1396

python面向对象的三大特性

python面向对象的三大特性前言一、封装(隐藏)二、继承三、多态 前言 Python是面向对象的语言,也支持面向对象编程的三大特性:封装(隐藏)、继承、多态。 一、封装(隐藏) 隐藏对象的属性和实现细节,只对外提供必要的方法。相当于将"细节封装起来",只对外暴露“相关调用方法”。通过私有属性、私有方法的方式实现封装。 Python追求简洁的语法,没有严格的语法级别的"访问控制符",更多的是依靠程序员的自觉实现。 二、继承 如果一个新类继承自一个设计好的类,就直接具备了已有类的特征,就大大降低了工作难度,已

weixin_54787921的博客 1191

jre9下载 jdk9

(Java SE Runtime Environment 9.0) 9.0u175 官方最新版 【x86|x64】

Python面向对象——三大特性

面向对象编程(OOP)的三大特性是封装、继承和多态。这些特性共同构成了OOP的基础,使得软件设计更加灵活、可维护和可扩展。

qq_65307874的博客 4828

深度学习工具包 DeepLearningToolbox

深度学习工具包Deprecation notice.-----This toolbox is outdated and no longer maintained.There are much better tools available for deep learning than this toolbox, e.g. [Theano](http://deeplearning.net/software/theano/), [torch](http://torch.ch/) or [tensorflow](http://www.tensorflow.org/)I would suggest you use one of the tools mentioned above rather than use this toolbox.Best, Rasmus.DeepLearnToolbox================A Matlab toolbox for Deep Learning.Deep Learning is a new subfield of machine learning that focuses on learning deep hierarchical models of data.It is inspired by the human brain's apparent deep (layered, hierarchical) architecture.A good overview of the theory of Deep Learning theory is[Learning Deep Architectures for AI](http://www.iro.umontreal.ca/~bengioy/papers/ftml_book.pdf)For a more informal introduction, see the following videos by Geoffrey Hinton and Andrew Ng.* [The Next Generation of Neural Networks](http://www.youtube.com/watch?v=AyzOUbkUf3M) (Hinton, 2007)* [Recent Developments in Deep Learning](http://www.youtube.com/watch?v=VdIURAu1-aU) (Hinton, 2010)* [Unsupervised Feature Learning and Deep Learning](http://www.youtube.com/watch?v=ZmNOAtZIgIk) (Ng, 2011)If you use this toolbox in your research please cite [Prediction as a candidate for learning deep hierarchical models of data](http://www2.imm.dtu.dk/pubdb/views/publication_details.php?id=6284)```@MASTERSTHESIS\{IMM2012-06284, author = "R. B. Palm", title = "Prediction as a candidate for learning deep hierarchical models of data", year = "2012",}```Contact: rasmusbergpalm at gmail dot comDirectories included in the toolbox-----------------------------------`NN/` - A library for Feedforward Backpropagation Neural Networks`CNN/` - A library for Convolutional Neural Networks`DBN/` - A library for Deep Belief Networks`SAE/` - A library for Stacked Auto-Encoders`CAE/` - A library for Convolutional Auto-Encoders`util/` - Utility functions used by the libraries`data/` - Data used by the examples`tests/` - unit tests to verify toolbox is workingFor references on each library check REFS.mdSetup-----1. Download.2. addpath(genpath('DeepLearnToolbox'));Example: Deep Belief Network---------------------```matlabfunction test_example_DBNload mnist_uint8;train_x = double(train_x) / 255;test_x = double(test_x) / 255;train_y = double(train_y);test_y = double(test_y);%% ex1 train a 100 hidden unit RBM and visualize its weightsrand('state',0)dbn.sizes = [100];opts.numepochs = 1;opts.batchsize = 100;opts.momentum = 0;opts.alpha = 1;dbn = dbnsetup(dbn, train_x, opts);dbn = dbntrain(dbn, train_x, opts);figure; visualize(dbn.rbm{1}.W'); % Visualize the RBM weights%% ex2 train a 100-100 hidden unit DBN and use its weights to initialize a NNrand('state',0)%train dbndbn.sizes = [100 100];opts.numepochs = 1;opts.batchsize = 100;opts.momentum = 0;opts.alpha = 1;dbn = dbnsetup(dbn, train_x, opts);dbn = dbntrain(dbn, train_x, opts);%unfold dbn to nnnn = dbnunfoldtonn(dbn, 10);nn.activation_function = 'sigm';%train nnopts.numepochs = 1;opts.batchsize = 100;nn = nntrain(nn, train_x, train_y, opts);[er, bad] = nntest(nn, test_x, test_y);assert(er < 0.10, 'Too big error');```Example: Stacked Auto-Encoders---------------------```matlabfunction test_example_SAEload mnist_uint8;train_x = double(train_x)/255;test_x = double(test_x)/255;train_y = double(train_y);test_y = double(test_y);%% ex1 train a 100 hidden unit SDAE and use it to initialize a FFNN% Setup and train a stacked denoising autoencoder (SDAE)rand('state',0)sae = saesetup([784 100]);sae.ae{1}.activation_function = 'sigm';sae.ae{1}.learningRate = 1;sae.ae{1}.inputZeroMaskedFraction = 0.5;opts.numepochs = 1;opts.batchsize = 100;sae = saetrain(sae, train_x, opts);visualize(sae.ae{1}.W{1}(:,2:end)')% Use the SDAE to initialize a FFNNnn = nnsetup([784 100 10]);nn.activation_function = 'sigm';nn.learningRate = 1;nn.W{1} = sae.ae{1}.W{1};% Train the FFNNopts.numepochs = 1;opts.batchsize = 100;nn = nntrain(nn, train_x, train_y, opts);[er, bad] = nntest(nn, test_x, test_y);assert(er < 0.16, 'Too big error');```Example: Convolutional Neural Nets---------------------```matlabfunction test_example_CNNload mnist_uint8;train_x = double(reshape(train_x',28,28,60000))/255;test_x = double(reshape(test_x',28,28,10000))/255;train_y = double(train_y');test_y = double(test_y');%% ex1 Train a 6c-2s-12c-2s Convolutional neural network %will run 1 epoch in about 200 second and get around 11% error. %With 100 epochs you'll get around 1.2% errorrand('state',0)cnn.layers = { struct('type', 'i') %input layer struct('type', 'c', 'outputmaps', 6, 'kernelsize', 5) %convolution layer struct('type', 's', 'scale', 2) %sub sampling layer struct('type', 'c', 'outputmaps', 12, 'kernelsize', 5) %convolution layer struct('type', 's', 'scale', 2) %subsampling layer};cnn = cnnsetup(cnn, train_x, train_y);opts.alpha = 1;opts.batchsize = 50;opts.numepochs = 1;cnn = cnntrain(cnn, train_x, train_y, opts);[er, bad] = cnntest(cnn, test_x, test_y);%plot mean squared errorfigure; plot(cnn.rL);assert(er<0.12, 'Too big error');```Example: Neural Networks---------------------```matlabfunction test_example_NNload mnist_uint8;train_x = double(train_x) / 255;test_x = double(test_x) / 255;train_y = double(train_y);test_y = double(test_y);% normalize[train_x, mu, sigma] = zscore(train_x);test_x = normalize(test_x, mu, sigma);%% ex1 vanilla neural netrand('state',0)nn = nnsetup([784 100 10]);opts.numepochs = 1; % Number of full sweeps through dataopts.batchsize = 100; % Take a mean gradient step over this many samples[nn, L] = nntrain(nn, train_x, train_y, opts);[er, bad] = nntest(nn, test_x, test_y);assert(er < 0.08, 'Too big error');%% ex2 neural net with L2 weight decayrand('state',0)nn = nnsetup([784 100 10]);nn.weightPenaltyL2 = 1e-4; % L2 weight decayopts.numepochs = 1; % Number of full sweeps through dataopts.batchsize = 100; % Take a mean gradient step over this many samplesnn = nntrain(nn, train_x, train_y, opts);[er, bad] = nntest(nn, test_x, test_y);assert(er < 0.1, 'Too big error');%% ex3 neural net with dropoutrand('state',0)nn = nnsetup([784 100 10]);nn.dropoutFraction = 0.5; % Dropout fraction opts.numepochs = 1; % Number of full sweeps through dataopts.batchsize = 100; % Take a mean gradient step over this many samplesnn = nntrain(nn, train_x, train_y, opts);[er, bad] = nntest(nn, test_x, test_y);assert(er < 0.1, 'Too big error');%% ex4 neural net with sigmoid activation functionrand('state',0)nn = nnsetup([784 100 10]);nn.activation_function = 'sigm'; % Sigmoid activation functionnn.learningRate = 1; % Sigm require a lower learning rateopts.numepochs = 1; % Number of full sweeps through dataopts.batchsize = 100; % Take a mean gradient step over this many samplesnn = nntrain(nn, train_x, train_y, opts);[er, bad] = nntest(nn, test_x, test_y);assert(er < 0.1, 'Too big error');%% ex5 plotting functionalityrand('state',0)nn = nnsetup([784 20 10]);opts.numepochs = 5; % Number of full sweeps through datann.output = 'softmax'; % use softmax outputopts.batchsize = 1000; % Take a mean gradient step over this many samplesopts.plot = 1; % enable plottingnn = nntrain(nn, train_x, train_y, opts);[er, bad] = nntest(nn, test_x, test_y);assert(er < 0.1, 'Too big error');%% ex6 neural net with sigmoid activation and plotting of validation and training error% split training data into training and validation datavx = train_x(1:10000,:);tx = train_x(10001:end,:);vy = train_y(1:10000,:);ty = train_y(10001:end,:);rand('state',0)nn = nnsetup([784 20 10]); nn.output = 'softmax'; % use softmax outputopts.numepochs = 5; % Number of full sweeps through dataopts.batchsize = 1000; % Take a mean gradient step over this many samplesopts.plot = 1; % enable plottingnn = nntrain(nn, tx, ty, opts, vx, vy); % nntrain takes validation set as last two arguments (optionally)[er, bad] = nntest(nn, test_x, test_y);assert(er < 0.1, 'Too big error');```[![Bitdeli Badge](https://d2weczhvl823v0.cloudfront.net/rasmusbergpalm/deeplearntoolbox/trend.png)](https://bitdeli.com/free "Bitdeli Badge")

Outlook Express 6 (OE6) for Win7/Win8/Win10

英文版 Outlook Express6.0, 兼容Win7/Win10/WinXP,解压就可用。

python系列之面向对象的三大特性

本文介绍了Python面向对象编程的三大特性:封装、继承和多态。在封装部分,通过咖啡机案例展示了私有属性和@property装饰器的使用;在继承部分,以动物家族为例说明类继承和super()函数的使用;在多态部分,演示了不同子类对同一方法的不同实现。文章采用生活化比喻,如将封装比作自动咖啡机、继承比作家族传承,使抽象概念更易理解。每个特性都配有完整代码示例和实际应用场景,帮助读者掌握面向对象编程的核心思想与实践技巧。

weixin_54679968的博客 880

jdk-8u144-linux-x64.tar.gz.

该资源为搭建Linux系统Java环境用,资源的后缀为tar.gz格式的压缩包

Python面向对象三大特性解析

Python面向对象编程三大特性解析 本文深入解析Python面向对象编程的三大核心特性: 1️⃣ 封装:通过私有属性(__前缀)和方法实现数据隐藏,提供公共接口(getter/setter)访问,提高安全性和复用性 2️⃣ 继承:支持单继承和多继承,子类可重写父类方法,通过super()调用父类方法,方法解析顺序(MRO)决定继承链 3️⃣ 多态:基于继承和方法重写实现,Python特有的"鸭子类型"不强制要求继承关系 文章还详细介绍了类属性(共享)与对象属性(独立)的区别,以及类方法

lyx3313696759的博客 1017

Python学习——面向对象三大特性

大家好,今天跟大家介绍面向对象的三大特性:封装,继承和多态。 一、封装 顾名思义就是将内容封装到某个地方,以后再去调用被封装在某处的内容。 所以,在使用面向对象的封装特性时,需要: 1)将内容封装到某处 2)从某处调用被封装的内容 第一步,将内容封装到某处 self 是一个形式参数,当执行 passat = Car(‘passat’, 250000 ) 时,self 等于passat;当执行 f...

sinat_40631989的博客 1509

python面向对象的三大特性:封装,继承,多态

我们接下来来聊聊Python代码中的“继承”:类是用来描述现实世界中同一组事务的共有特性的抽象模型,但是类也有上下级和范围之分,比如:生物 => 动物 => 哺乳动物 => 灵长型动物 => 人类 => 黄种人从哲学上说,就是共性与个性之间的关系,比如:白马和马!所以,我们在OOP代码中,也一样要体现出类与类之间的共性与个性关系,这里就需要通过类的继承来体现。简单来说,如果一个类A使用了另一个类B的成员(属性和方法),我们就可以说A类继承了B类,同时这也体现了OOP中==代码重用的特性==!

qq_55451220的博客 2824

【Python面试】 说说Python面向对象三大特性?

往期面试题:【Python面试】谈谈对 Python 和其他语言的区别?​Python常见面试题:说说Python解释器种类以及特点?说说4种常用编码的区别?废话不多说,开始今天的题目:...

小詹学python的博客 782

Python入门12:面向对象的三大特征与高级特性详解

继承是面向对象编程的另一个重要特征。它允许一个类(子类)继承另一个类(父类)的属性和方法,从而实现代码的重用和扩展。继承几个基本概念:1、继承:⼀个类从另⼀个已有的类获得其成员的相关特性,就叫作继承!2、派⽣:从⼀个已有的类产⽣⼀个新的类,称为派⽣!很显然,继承和派⽣其实就是从不同的⽅向来描述的相同的概念⽽已,本质上是⼀样的!3、⽗类:也叫作基类,就是指已有被继承的类!4、⼦类:也叫作派⽣类或扩展类5、扩展:在⼦类中增加⼀些⾃⼰特有的特性,就叫作扩展,没有扩展,继承也就没有意义了!

m0_74488469的博客 1480

python面向对象三大特性

python面向对象三大特性 继承,封装,多态 1.封装 体现在两个方面: 将同一类方法封装到了一个类中 将数据封装到对象中,在实例化对象时,可以通过__init__初始化方法在对象中封装一些数据,便于以后使用 2.继承 子类继承父类中的方法和类变量(不是拷贝一份,父类还是属于父类,子类可以继承而已) 父类又称基类 子类又称派生类 class Base: def func(self): print("base") #Son继承Base class Son(Base):

m0_46926492的博客 969
上一篇: 使用Python实现Excel办公自动化
下一篇: Python os模块,常用操作
code-hua
博客等级 码龄7年 2粉丝 25原创
评论
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明:

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

余额充值