精华内容
下载资源
问答
  • 面向对象 概述 面向过程 ​ 1. 分析出解决问题的步骤,然后逐步实现。 ​ 例如:婚礼筹办 ​ – 发请柬(选照片、措词、制作) ​ – 宴席(场地、找厨师、准备桌椅餐具、计划菜品、购买食材) ​ – 婚礼...

    面向对象

    概述

    面向过程

    ​ 1. 分析出解决问题的步骤,然后逐步实现。

    ​ 例如:婚礼筹办

    ​ – 发请柬(选照片、措词、制作)

    ​ – 宴席(场地、找厨师、准备桌椅餐具、计划菜品、购买食材)

    ​ – 婚礼仪式(定婚礼仪式流程、请主持人)

    ​ 2. 公式:程序 = 算法 + 数据结构

    ​ 3. 优点:所有环节、细节自己掌控。

    ​ 4. 缺点:考虑所有细节,工作量大。

    面向对象

    ​ 1. 找出解决问题的人,然后分配职责。

    ​ 例如:婚礼筹办

    ​ – 发请柬:找摄影公司(拍照片、制作请柬)

    ​ – 宴席:找酒店(告诉对方标准、数量、挑选菜品)

    ​ – 婚礼仪式:找婚庆公司(对方提供司仪、制定流程、提供设备、帮助执行)

    ​ 2. 公式:程序 = 对象 + 交互

    ​ 3. 优点

    ​ (1) 思想层面:

    ​ – 可模拟现实情景,更接近于人类思维。

    ​ – 有利于梳理归纳、分析解决问题。

    ​ (2) 技术层面:

    ​ – 高复用:对重复的代码进行封装,提高开发效率。

    ​ – 高扩展:增加新的功能,不修改以前的代码。

    ​ – 高维护:代码可读性好,逻辑清晰,结构规整。

    ​ 4. 缺点:学习曲线陡峭。

    类和对象

    语法

    定义类

    ​ 1. 代码

    ​ class 类名:

    ​ “””文档说明”””

    ​ def init(self,参数列表):

    ​ self.实例变量 = 参数

    ​ 方法成员

    ​ 2. 说明

    ​ – 类名所有单词首字母大写.

    ​ – init 也叫构造函数,创建对象时被调用,也可以省略。

    ​ – self 变量绑定的是被创建的对象,名称可以随意。

    创建对象(实例化)

    ​ 变量 = 类名(参数列表)

    实例成员

    实例变量

    ​ 1. 语法

    ​ (1) 定义:对象.变量名

    ​ (2) 调用:对象.变量名

    ​ 2. 说明

    ​ (1) 首次通过对象赋值为创建,再次赋值为修改.

    ​ w01 = Wife()

    ​ w01.name = “丽丽”

    ​ w01.name = “莉莉”

    ​ (2) 通常在构造函数(init)中创建。

    ​ w01 = Wife(“丽丽”,24)

    ​ print(w01.name)

    ​ (3) 每个对象存储一份,通过对象地址访问。

    ​ 3. 作用:描述某个对象的数据。

    ​ 4. dict:对象的属性,用于存储自身实例变量的字典。

    实例方法

    ​ 1. 语法

    ​ (1) 定义: def 方法名称(self, 参数列表):

    ​ 方法体

    ​ (2) 调用: 对象地址.实例方法名(参数列表)

    ​ 不建议通过类名访问实例方法

    ​ 2. 说明

    ​ (1) 至少有一个形参,第一个参数绑定调用这个方法的对象,一般命名为"self"。

    ​ (2) 无论创建多少对象,方法只有一份,并且被所有对象共享。

    ​ 3. 作用:表示对象行为。

    类成员

    类变量

    ​ 1. 语法

    ​ (1) 定义:在类中,方法外定义变量。

    ​ class 类名:

    ​ 变量名 = 表达式

    ​ (2) 调用:类名.变量名

    				不建议通过对象访问类变量
    

    ​ 2. 说明

    ​ (1) 存储在类中。

    ​ (2) 只有一份,被所有对象共享。

    ​ 3. 作用:描述所有对象的共有数据。

    类方法

    ​ 1. 语法

    ​ (1) 定义:

    			@classmethod
    
    				def 方法名称(cls,参数列表):
    

    ​ 方法体

    ​ (2) 调用:类名.方法名(参数列表)

    				不建议通过对象访问类方法
    

    ​ 2. 说明

    ​ (1) 至少有一个形参,第一个形参用于绑定类,一般命名为’cls’

    ​ (2) 使用@classmethod修饰的目的是调用类方法时可以隐式传递类。

    ​ (3) 类方法中不能访问实例成员,实例方法中可以访问类成员。

    ​ 3. 作用:操作类变量。

    静态方法

    ​ 1. 语法

    ​ (1) 定义:

    		 	@staticmethod
    
    			def 方法名称(参数列表):
    

    ​ 方法体

    ​ (2) 调用:类名.方法名(参数列表)

    				不建议通过对象访问静态方法
    

    ​ 2. 说明

    ​ (1) 使用@ staticmethod修饰的目的是该方法不需要隐式传参数。

    ​ (2) 静态方法不能访问实例成员和类成员

    ​ 3. 作用:定义常用的工具函数。

    三大特征

    封装

    数据角度

    ​ 1. 定义:

    ​ 将一些基本数据类型复合成一个自定义类型。

    ​ 2. 优势:

    ​ 将数据与对数据的操作相关联。

    ​ 代码可读性更高(类是对象的模板)。

    行为角度

    ​ \1. 定义:

    ​ 向类外提供必要的功能,隐藏实现的细节。

    ​ \2. 优势:

    ​ 简化编程,使用者不必了解具体的实现细节,只需要调用对外提供的功能。

    ​ \3. 私有成员:

    ​ (1) 作用:无需向类外提供的成员,可以通过私有化进行屏蔽。

    ​ (2) 做法:命名使用双下划线开头。

    ​ (3) 本质:障眼法,实际也可以访问。

    ​ 私有成员的名称被修改为:_类名__成员名,可以通过_dict_属性或dir函数查看。

    ​ \4. 属性@property:

    ​ 将方法的使用方式像操作变量一样方便,从而保护实例变量。

    ​ (1) 定义:

    ​ @property

    ​ def 属性名(self):

    ​ return self.__属性名

    ​ @属性名.setter

    ​ def 属性名(self, value):

    ​ self.__属性名= value

    ​ (2) 调用:

    ​ 对象.属性名 = 数据

    ​ 变量 = 对象.属性名

    ​ (3) 说明:

    ​ 通常两个公开的属性,保护一个私有的变量。

    						@property 负责读取,@属性名.setter 负责写入
    
    						只写:属性名= property(None, 写入方法名)
    
    设计角度

    ​ 1. 定义:

    ​ (1) 分而治之

    ​ 将一个大的需求分解为许多类,每个类处理一个独立的功能。

    ​ (2) 变则疏之

    ​ 变化的地方独立封装,避免影响其他类。

    ​ (3) 高 内 聚

    ​ 类中各个方法都在完成一项任务(单一职责的类)。

    ​ (4) 低 耦 合

    ​ 类与类的关联性与依赖度要低(每个类独立),让一个类的改变,尽少影响其他类。

    ​ 2. 优势:

    ​ 便于分工,便于复用,可扩展性强。

    继承

    语法角度
    继承方法

    ​ 1. 代码:

    ​ class 父类:

    ​ def 父类方法(self):

    ​ 方法体

    ​ class 子类(父类):

    ​ def 子类方法(self):

    ​ 方法体

    ​ 儿子 = 子类()

    ​ 儿子.子类方法()

    ​ 儿子.父类方法()

    ​ 2. 说明:

    ​ 子类直接拥有父类的方法.

    内置函数

    ​ isinstance(对象, 类型)

    ​ 返回指定对象是否是某个类的对象。

    ​ issubclass(类型,类型)

    ​ 返回指定类型是否属于某个类型。

    继承数据

    ​ 1. 代码

    ​ class 子类(父类):

    			def __init__(self,参数列表):
    

    ​ super().init(参数列表)

    ​ self.自身实例变量 = 参数

    ​ 2. 说明

    ​ 子类如果没有构造函数,将自动执行父类的,但如果有构造函数将覆盖父类的。此时必须通 过super()函数调用父类的构造函数,以确保父类实例变量被正常创建。

    定义

    ​ 重用现有类的功能,并在此基础上进行扩展。

    ​ 说明:子类直接具有父类的成员(共性),还可以扩展新功能。

    优点

    ​ 一种代码复用的方式。

    缺点

    ​ 耦合度高:父类的变化,直接影响子类。

    设计角度
    定义

    ​ 将相关类的共性进行抽象,统一概念,隔离变化。

    适用性

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

    相关概念

    ​ 父类(基类、超类)、子类(派生类)。

    ​ 父类相对于子类更抽象,范围更宽泛;子类相对于父类更具体,范围更狭小。

    ​ 单继承:父类只有一个(例如 Java,C#)。

    ​ 多继承:父类有多个(例如C++,Python)。

    ​ Object类:任何类都直接或间接继承自 object 类。

    多继承

    ​ 一个子类继承两个或两个以上的基类,父类中的属性和方法同时被子类继承下来。

    同名方法的解析顺序(MRO, Method Resolution Order):

    类自身 --> 父类继承列表(由左至右)–> 再上层父类

    				  A
    
    				 / \
    
    				 /  \
    

    ​ B C

    				\  /
    
    				 \ /
    
    				 D 
    

    多态

    设计角度
    定义

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

    作用

    ​ 1. 在继承的基础上,体现类型的个性化(一个行为有不同的实现)。

    ​ 2. 增强程序扩展性,体现开闭原则。

    语法角度
    重写

    ​ 子类实现了父类中相同的方法(方法名、参数)。

    ​ 在调用该方法时,实际执行的是子类的方法。

    快捷键

    ​ Ctrl + O

    内置可重写函数

    ​ Python中,以双下划线开头、双下划线结尾的是系统定义的成员。我们可以在自定义类中进行重写,从而改变其行为。

    ​ 转换字符串

    ​ __str__函数:将对象转换为字符串(对人友好的)

    ​ __repr__函数:将对象转换为字符串(解释器可识别的)

    运算符重载

    ​ 定义:让自定义的类生成的对象(实例)能够使用运算符进行操作。

    ​ 算数运算符重载

    ​ [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-YuA1pwoy-1600478064757)(C:\Users\Administrator\AppData\Roaming\Typora\typora-user-images\image-20200827154846816.png)]

    ​ 复合运算符重载

    ​ [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-l9ZvZYyr-1600478064759)(C:\Users\Administrator\AppData\Roaming\Typora\typora-user-images\image-20200827154907785.png)]

    ​ 比较运算符重载

    ​ [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-8kx1s446-1600478064762)(C:\Users\Administrator\AppData\Roaming\Typora\typora-user-images\image-20200827154920224.png)]

    设计原则

    开-闭原则(目标、总的指导思想)

    ​ ****O****pen ****C****losed ****P****rinciple

    ​ 对扩展开放,对修改关闭。

    ​ 增加新功能,不改变原有代码

    类的单一职责(一个类的定义)

    ​ ****S****ingle ****R****esponsibility ****P****rinciple

    ​ 一个类有且只有一个改变它的原因。

    依赖倒置(依赖抽象)

    ​ ****D****ependency ****I****nversion ****P****rinciple

    ​ 客户端代码(调用的类)尽量依赖(使用)抽象。

    ​ 抽象不应该依赖细节,细节应该依赖抽象。

    组合复用原则(复用的最佳实践)

    ​ Composite Reuse Principle

    ​ 如果仅仅为了代码复用优先选择组合复用,而非继承复用。

    ​ 组合的耦合性相对继承低。

    里氏替换(继承后的重写,指导继承的设计)

    ​ ****L****iskov ****S****ubstitution ****P****rinciple

    ​ 父类出现的地方可以被子类替换,在替换后依然保持原功能。

    ​ 子类要拥有父类的所有功能。

    ​ 子类在重写父类方法时,尽量选择扩展重写,防止改变了功能。

    迪米特法则(类与类的交互原则

    ​ Law of Demeter

    ​ 不要和陌生人说话。

    ​ 类与类交互时,在满足功能要求的基础上,传递的数据量越少越好。因为这样可能降低耦合度。
    置(依赖抽象)

    ​ ****D****ependency ****I****nversion ****P****rinciple

    ​ 客户端代码(调用的类)尽量依赖(使用)抽象。

    ​ 抽象不应该依赖细节,细节应该依赖抽象。

    组合复用原则(复用的最佳实践)

    ​ Composite Reuse Principle

    ​ 如果仅仅为了代码复用优先选择组合复用,而非继承复用。

    ​ 组合的耦合性相对继承低。

    里氏替换(继承后的重写,指导继承的设计)

    ​ ****L****iskov ****S****ubstitution ****P****rinciple

    ​ 父类出现的地方可以被子类替换,在替换后依然保持原功能。

    ​ 子类要拥有父类的所有功能。

    ​ 子类在重写父类方法时,尽量选择扩展重写,防止改变了功能。

    迪米特法则(类与类的交互原则

    ​ Law of Demeter

    ​ 不要和陌生人说话。

    ​ 类与类交互时,在满足功能要求的基础上,传递的数据量越少越好。因为这样可能降低耦合度。

    展开全文
  • Python 面向对象编程思想:从四个方面来理解1. 宽泛的面向对象的概念 举例说明面向过程:做一件事情,从头到尾,每一个细节都要关注,重点在于过程面向对象:做一件事情,用对象去做,不关心细节和过程,万物皆对象


    从四个方面来聊面向对象

    1. 宽泛的面向对象的概念 举例说明

    面向过程:做一件事情,从头到尾,每一个细节都要关注,重点在于过程
    	从西安到北京:西安-郑州-武汉-邯郸-邢台-北京
    
    面向对象:做一件事情,用对象去做,不关心细节和过程,万物皆对象
    	从西安到北京: 坐动车到北京
    

    2. python中面向对象

    有类:描述一类事物,一个抽象的概念,比如:人、动物、水果
    有对象:是类的具象化比如:张三、李四、猫、狗
    	特征(属性)
    	功能行为(方法) 
    

    元类-类-对象

    3. python中面向对象的三大特征:

    3.1 封装:面向对象编程的第一步----->将 属性和方法 封装到一个抽象的 类 中
    外界使用 类 创建 对象,然后让 对象 调用方法
    对象方法的细节 都被 封装 在 类的内部
    
    3.2 继承:子类可以拥有父类的属性和方法(减少代码的书写,提高代码的阅读性)

    单继承
    代码的传递性:孙子类中可以使用爷爷类型的方法
    多继承
    一个子类可以继承多个父类
    特点:子类拥有所有父类的属性和方法

    方法重写:
    	概念:在子类中书写和父类同名的方法
    	特点:在类中调用方法,如果在子类中找到,直接执行子类中的方法
                如果子类中没有找到这个方法,去父类中找,找到了就调用父类中的方法,
                如果父类中没有找到,则报错
    私有方法和属性:
    	语法格式:
    		def __函数名(self):
    
    		def __init__(self):
    			self.__money = "自己猜"
    	特点:
    		不允许被外界访问,只能自己使用
    		如果外界必须访问,那么可以提供一个公共的方法,访问私有属性 
    
    3.3 多态:一个对象的多种形态(一父多子)
    作用:增强代码的灵活性、提高代码的扩展性
    条件:继承、方法的重写
    

    4. 面向对象编程的设计

    继承体系设计 有什么类 什么属性 封装到什么方法中去
    比如:门 锁  人 ,把开门关门的方法 封装在谁的类之中?
        封装在门的类之中,(谁拥有数据谁就拥有操作数据的权利)而人相当于一个main方法 
        调用时:拿到门对象,调用门的开关门方法
    
    展开全文
  • 编程语言的大家族中,从C语言的思想是面向过程,随着软件业务越来越复制,功能越来越强大,之后主流的编程语言几乎都是面向对象的设计思想,这样做的好处就是提高了代码的复用性 举一个简单的栗子: 比如我们去...

    面向对象与面向过程

    在编程语言的大家族中,从C语言的思想是面向过程,随着软件业务越来越复制,功能越来越强大,之后主流的编程语言几乎都是面向对象的设计思想,这样做的好处就是提高了代码的复用性
    举一个简单的栗子:

    比如我们去饭店吃饭,我们直接点完菜等待菜上桌就行了,还需要关注后厨是怎么做这道菜的吗?不可能吧,是不是

    类和对象

    1.类

    类是抽象的,在使用的时候通常会找到这个类的一个具体的存在,使用这个具体的存在。一个类可以找到多个对象
    在这里插入图片描述

    2.对象

    某一个具体事物的存在 ,在现实世界中可以是看得见摸得着的。可以是直接使用的
    在这里插入图片描述

    3.类和对象的关系

    类就是创建对象的模板

    4.区分类和对象

    奔驰汽车 类
    奔驰smart 类 
    张三的那辆奔驰smart 对象
    狗 类
    大黄狗 类 
    李四家那只大黄狗 对象 
    水果 类
    苹果 类 
    红苹果 类 红富士苹果 类 
    我嘴里吃了一半的苹果 对象
    

    5.类的构成

    类(Class) 由3个部分构成

    • 类的名称:类名
    • 类的属性:一组数据
    • 类的方法:允许对进行操作的方法 (行为)

    类的定义

    定义一个类,格式如下:

    class 类名:
        方法列表
    

    demo:

    # 定义类
    class Car:
        # 方法
        def getCarInfo(self):
            print('车轮子个数:%d, 颜色%s'%(self.wheelNum, self.color))
    
        def move(self):
            print("车正在移动...")
    

    说明:

    定义类时有2种:新式类和经典类,上面的Car为经典类,如果是Car(object)则为新式类
    类名 的命名规则按照"大驼峰"

    创建对象

    python中,可以根据已经定义的类去创建出一个个对象
    创建对象的格式为:

    对象名 = 类名()
    

    demo:

      # 定义类
    class Car:
        # 移动
        def move(self):
            print('车在奔跑...')
    
        # 鸣笛
        def toot(self):
            print("车在鸣笛...嘟嘟..")
    
    
    # 创建一个对象,并用变量BMW来保存它的引用
    BMW = Car()
    BMW.color = '黑色'
    BMW.wheelNum = 4 #轮子数量
    BMW.move()
    BMW.toot()
    print(BMW.color)
    print(BMW.wheelNum)
    

    分析:
    在这里插入图片描述

    总结:

    (1)BMW = Car(),这样就产生了一个Car的实例对象,此时也可以通过实例对象BMW来访问属性或者方法
    (2)第一次使用BMW.color = '黑色’表示给BMW这个对象添加属性,如果后面再次出现BMW.color = xxx表示对属性进行修改
    (3)BMW是一个对象,它拥有属性(数据)和方法(函数)
    (4)当创建一个对象时,就是用一个模子,来制造一个实物

    init()方法

    1.使用方式

    def 类名:
        #初始化函数,用来完成一些默认的设定
        def __init__():
            pass
    

    2.init()方法的调用

    # 定义汽车类
    class Car:
    
        def __init__(self):
            self.wheelNum = 4
            self.color = '蓝色'
    
        def move(self):
            print('车在跑,目标:夏威夷')
    
    # 创建对象
    BMW = Car()
    
    print('车的颜色为:%s'%BMW.color)
    print('车轮胎数量为:%d'%BMW.wheelNum)
    

    在这里插入图片描述
    总结:
    当创建Car对象后,在没有调用__init__()方法的前提下,BMW就默认拥有了2个属性wheelNum和color,原因是__init__()方法是在创建对象后,就立刻被默认调用了

    3.__init__方法传参

    # 定义汽车类
    class Car:
    
        def __init__(self, newWheelNum, newColor):
            self.wheelNum = newWheelNum
            self.color = newColor
    
        def move(self):
            print('车在跑,目标:夏威夷')
    
    # 创建对象
    BMW = Car(4, 'green')
    
    print('车的颜色为:%s'%BMW.color)
    print('车轮子数量为:%d'%BMW.wheelNum)
    

    在这里插入图片描述
    总结:

    1. init()方法,在创建一个对象时默认被调用,不需要手动调用
    2. init(self)中,默认有1个参数名字为self,如果在创建对象时传递了2个实参,那么__init__(self)中出了self作为第一个形参外还需要2个形参,例如__init__(self,x,y)
    3. init(self)中的self参数,不需要开发者传递,python解释器会自动把当前的对象引用传递进去

    str方法

    1.str方法的定义

    class Car:
    
        def __init__(self, newWheelNum, newColor):
            self.wheelNum = newWheelNum
            self.color = newColor
    
        def __str__(self):
            msg = "嘿。。。我的颜色是" + self.color + "我有" + int(self.wheelNum) + "个轮胎..."
            return msg
    
        def move(self):
            print('车在跑,目标:夏威夷')
    
    
    BMW = Car(4, "白色")
    print(BMW)
    

    在这里插入图片描述
    总结:

    1. 在python中方法名如果是__xxxx__()的,那么就有特殊的功能,因此叫做“魔法”方法
    2. 当使用print输出对象的时候,只要自己定义了__str__(self)方法,那么就会打印从在这个方法中return的数据

    self的理解

    # 定义一个类
    class Animal:
    
        # 方法
        def __init__(self, name):
            self.name = name
    
        def printName(self):
            print('名字为:%s'%self.name)
    
    # 定义一个函数
    def myPrint(animal):
        animal.printName()
    
    
    dog1 = Animal('西西')
    myPrint(dog1)
    
    dog2 = Animal('北北')
    myPrint(dog2)
    

    运行结果:
    在这里插入图片描述
    总结:

    1. 所谓的self,可以理解为自己
    2. 可以把self当做C++中类里面的this指针一样理解,就是对象自身的意思
    3. 某个对象调用其方法时,python解释器会把这个对象作为第一个参数传递给self,所以开发者只需要传递后面的参数即可
    展开全文
  • 面向对象以及面向过程二.对象的进化以及类的产生1.类的定义2.实例属性和实例方法3.类对象和类方法4.静态方法5.垃圾回收机制 一.面向对象以及面向过程 例如用洗衣机洗衣服: 面向对象:1.人使用洗衣机 2.洗衣机洗...


    一.面向对象以及面向过程

    在这里插入图片描述
    例如用洗衣机洗衣服:
    面向对象:1.人使用洗衣机 2.洗衣机洗衣服
    面向过程:1.人插电路板 2.人设置洗衣机的程序 3.人加洗衣粉 4.开始洗衣服
    在这里插入图片描述
    在这里插入图片描述
    在这里插入图片描述
    在这里插入图片描述

    二.对象的进化以及类的产生

    随着编程面临的问题越来越复杂,编程语言本身也在进化,从主要处理简单数据开始,
    随着数据变多进化“数组”; 数据类型变复杂,进化出了“结构体”; 处理数据的方式逻辑变复杂,进化出了“对象”
    在这里插入图片描述
    在这里插入图片描述

    1.类的定义

    在这里插入图片描述
    对象是类的具体实体,一般称为“类的实例”。类看做“饼干模具”,对象就是根据这个“模具”制造出的“饼干”。
    从一个类创建对象时,每个对象会共享这个类的行为(类中定义的方法),但会有自己的属性值(不共享状态)。更具体一点:“方法代码是共享的,属性数据不共享”。
    在这里插入图片描述
    在这里插入图片描述

    在这里插入图片描述
    在这里插入图片描述
    定义类之后,栈创建一个类对象。通过类名(参数)调用构造函数实例化类对象时,首先用__new__()创建实例对象,然后根据传入参数调用__init__()构造函数,为实例对象赋值。实例方法的源代码保存在类对象中,通过实例.类方法()调用时再去找类对象中的代码。

    2.实例属性和实例方法

    在这里插入图片描述
    实例属性在__init__()构造函数下进行定义赋值,一般是传入的参数。在本类的其他实例方法中可以调用修改。

    注意: __ init__()第一个参数必须为self

    在这里插入图片描述
    在这里插入图片描述
    dir(obj)获得实例对象所有的属性方法,obj.dict 获得对象的 属性字典

    3.类对象和类方法

    在这里插入图片描述
    在这里插入图片描述
    在这里插入图片描述
    类属性在实例中可以访问,但无法修改
    在这里插入图片描述
    在这里插入图片描述
    在这里插入图片描述
    实例也可以使用类的方法,但是类不能用实例方法

    4.静态方法

    在这里插入图片描述

    5.垃圾回收机制

    在这里插入图片描述
    第一次是p2,调用了__del__,第二次是p1,因为程序结束p1没有被引用。

    在这里插入图片描述
    在这里插入图片描述
    在这里插入图片描述

    6.私有属性和私有方法

    在这里插入图片描述

    class Human:
        __eyes = 2#私有类属性
        __nose = 1
        def __init__(self,name,school,age):
            self.name = name
            self.__school = school#私有实例属性
            self.__age = age
        def say_name(self):
            print("我的名字是{0}".format(self.name))
        def __say_age(self):
            print("我的年龄是",self.__age)
            self.say_name()
        def say_school(self):
            print("我的学校是:",self.__school)#内部可以直接调用私有属性
    
    wsq = Human("WSQ","CQU",24)
    wsq.say_name()
    wsq._Human__nose#实例._类__私有属性(方法)调用
    wsq._Human__say_age()
    print(dir(wsq))
    
    
    我的名字是WSQ
    我的年龄是 24
    我的名字是WSQ
    ['_Human__age', '_Human__eyes', '_Human__nose', '_Human__say_age', '_Human__school', '__class__', '__delattr__', '__dict__', '__dir__', '__doc__', '__eq__', '__format__', '__ge__', '__getattribute__', '__gt__', '__hash__', '__init__', '__init_subclass__', '__le__', '__lt__', '__module__', '__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__setattr__', '__sizeof__', '__str__', '__subclasshook__', '__weakref__', 'name', 'say_name', 'say_school']
    

    在这里插入图片描述
    在这里插入图片描述
    在这里插入图片描述

    在这里插入图片描述
    不想让属性直接被用户更改,所以私有化属性,然后用装饰器@property可以通过直接调用方法,最后想对属性的读写操作做一个判断。所以采用get set方法。

    在这里插入图片描述

    展开全文
  • 面向对象编程 类和对象的理解 飞机实例化的程序 面向对象的形式 ​self __init__ 面向对象编程 面向过程(顺序) 打酱油机器人 100元 买酱油 功能1:收钱 功能2:过马路,看红绿灯 功能3:交钱拿零钱 ...
  • 本套视频教程致力于深入讲解Python语言的面向对象编程思想,通过丰富、强大的代码示例为学员循序渐进地讲解如何编写高质量的Python代码。通过实际的例子对Python中面向对象编程的理念进行介绍。针对所有可用于和...
  • 面向对象编程思想 面向对象的编程核心是对象,在理解对象为何物时,必须把自己当作上帝,因为在上帝眼中世间存在的万物皆为对象,不存在的也可以创造出来。对象是特征和技能的结合,其中特征和技能分别对应对象的...
  • 尽管网上有许多关于Python面向对像的编程介绍,小编我看完后总觉得不是很满意,也不过瘾,所以决定自己亲自动手写篇文章,帮你理解Python面向对象编程的基本概念和核心思想。本文内含很多实例代码,以帮助新手更好...
  • Python面向对象编程

    2020-07-20 18:14:42
    Python面向对象编程26. 面向对象编程 26. 面向对象编程 面向对象编程——Object Oriented Programming,简称OOP,是一种程序设计思想。OOP把对象作为程序的基本单元,一个对象包含了数据和操作数据的函数。 面向过程...
  • 原文地址https://blog.csdn.net/weixin_42134789/article/details/80194788 ... 类(Class)与对象(Object) # 创建一个学生类 class Student: # 定义学生属性,初...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 1,754
精华内容 701
关键字:

python面向对象编程思想

python 订阅