文章图片

?♂? 个人主页: @Flyme awei 个主页
? 作者简介：Python领域新星创作者。
希望大家多多支持一起进步呀！
如果文章对你有帮助的话，欢迎评论点赞收藏加关注

前言

??今天是《CSDN21天学习挑战赛》的第17天
??上一节学习了Python基础语法类和对象
??今天将Python面向三大特征：封装、继承、多态

【Python基础语法|Python面向对象三大特征】活动地址：CSDN21天学习挑战赛

文章目录

• python面向对象三大特征
• 一、封装
• 二、继承
• • 1.方法重写
  • 2.object类
  • 3.多重继承
• 三、多态
• • 1.动态语言与静态语言
• 四、类的特殊属性和方法
• • 1.特殊属性
  • 2.特殊方法
  • • `__len__()`方法和 `__add__()` 方法
    • `__new__`方法
    • `__init__`方法
• 五、变量的赋值操作
• 六、对象的浅拷贝和深拷贝
• • 1.浅拷贝
  • 2.深拷贝
• 七、总结

python面向对象三大特征

封装：将数据（属性）和行为（方法）包装到类对象中。在方法内部对属性进行操作，在类对象的外部调用方法。这样，无需关心方法内部的具体实现细节，从而隔离了复杂度。

继承：子类可以继承父类的属性和方法，提高代码的复用性。

多态：多态就是具有多种形态，即便不知道一个变量所引用的对象是什么类型，仍然可以使用这个变量调用方法。

一、封装

封装：将属性和方法包装到类对象中，在方法内部对属性进行操作，在类对象外部调用方法。

代码实现：

# -*- coding: utf-8 -*- # @File: demo.py # @author: Flyme awei # @email : Flymeawei@163.com # @Time: 2022/8/15 23:27# 封装:提高程序的安全性 # 将属性和方法包装到类对象中 # 在方法内部对属性进行操作，在类对象外部调用方法class Car: def __init__(self, brand): self.brand = brand# 实例属性@staticmethod def start():# 静态方法 print('汽车已启动...')car = Car('奥迪A8') car.start() print(car.brand)

文章图片

如果不希望实例属性在类的外部被使用，可以在前面加上两个下划线"_"

# -*- coding: utf-8 -*- # @File: demo.py # @author: Flyme awei # @email : Flymeawei@163.com # @Time: 2022/8/15 23:27class Student: def __init__(self, name, age): self.name = name self.__age = age# 如果不希望实例属性在类的外部被使用，所以在前面加上两个下划线def show(self): return self.name, self.__age@staticmethod def eat(): print('吃')stu1 = Student('李华', 20) stu1.show()# 调用方法 print(dir(stu1))# 查看对象可以用的属性 print('-------------') print(stu1.name, stu1._Student__age)# 在类外部通过_Student__age访问实例属性self.__age stu1.eat()

文章图片

二、继承

继承:子类可以继承父类的属性和方法，提高代码的复用性。
如果一个对象没有继承任何类，则默认继承object类

语法格式:

class 子类名(父类1，父类2，...): pass

代码实现：

# -*- coding: utf-8 -*- # @File: demo.py # @author: Flyme awei # @email : Flymeawei@163.com # @Time: 2022/8/15 23:27class Person(object): def __init__(self, name, age): self.name = name self.age = agedef info(self): print(self.name, self.age)class Student(Person): def __init__(self, name, age, stu_nb): super(Student, self).__init__(name, age)# 继承父类的属性 self.stu_nb = stu_nb# 新增属性def __str__(self): return self.name, self.age, self.stu_nbclass Teach(Person): def __init__(self, name, age, teach_of_year): super(Teach, self).__init__(name, age) self.teach_of_year = teach_of_yearstudent = Student('张三', 20, '1001')# 创建对象 teacher = Teach('杨老师', 34, 10)student.info() teacher.info() print(student.__str__()) print(student.stu_nb) print(teacher.teach_of_year)

文章图片

1.方法重写

如果子类对继承自己父类的某个属性不满意，可以在子类对其（方法体）进行重新编写。

子类重写后的方法通过 super().方法名() 调用父类中被重写的方法。

# -*- coding: utf-8 -*- # @File: demo.py # @author: Flyme awei # @email : Flymeawei@163.com # @Time: 2022/8/15 23:27# 如果子类对继承自己父类的某个属性不满意，可以在子类对其（方法体）进行重新编写 # 子类重写后的方法通过 super()...方法名() 调用父类中被重写的方法class Person(object): def __init__(self, name, age): self.name = name self.age = agedef info(self): print(self.name, self.age)class Student(Person): def __init__(self, name, age, stu_nb): super(Student, self).__init__(name, age) self.stu_nb = stu_nbdef info(self):# 方法重写 super().info()# 调用父类中方法 print(f'学号:{self.stu_nb}')# f''格式化字符串class Teach(Person): def __init__(self, name, age, teach_of_year): super(Teach, self).__init__(name, age) self.teach_of_year = teach_of_yeardef info(self):# 方法重写 super().info() print('教龄{0}'.format(self.teach_of_year))# 格式化字符串student = Student('张三', 20, '1001') teacher = Teach('杨老师', 34, 10)student.info() print('-----------------') teacher.info()

文章图片

2.object类

# -*- coding: utf-8 -*- # @File: demo.py # @author: Flyme awei # @email : Flymeawei@163.com # @Time: 2022/8/15 23:27''' object 类是所有类的父类，所有类都有object类的属性和方法 内置函数dir（）可以查看指定对象所有属性 Object有一个__str__方法，用于返回一个对于”对象的描述 对应内置函数str（）通常用于print（）方法，帮我们查看对象的信息，所以经常会对__str__进行重写“'''class Student(object): def __init__(self, name, age): self.name = name self.age = agedef __str__(self):# 重写父类object中的方法 return '我的名字是{0}，今年{1}岁了'.format(self.name, self.age)stu = Student('张三', 20) print(dir(stu))# 查看stu这个对象的所有属性和方法 从object类中继承的 print(stu)# 默认调用__str__()这样的方法 输出:我的名字是张三，今年20岁了print(type(stu))# Student类型

文章图片

3.多重继承

一个子类可以有多个“直接父类”，这样，就具备了“多个父类”的特点，通过类的特殊属性__mro__ 可以查看类的组织结构。

定义子类时，必须在其构造函数中调用父类的构造函数

# -*- coding: utf-8 -*- # @File: demo.py # @author: Flyme awei # @email : Flymeawei@163.com # @Time: 2022/8/15 23:27# 多继承 class A(object): passclass B(object): passclass C(A, B): pass

三、多态

多态:多态就是具有多种形态，即便不知道一个变量所引用的对象是什么类型，仍然可以使用这个变量调用方法，在运行过程中根据变量所引用的对象类型，动态决定调用那个对象中的方法。

代码实现：

# -*- coding: utf-8 -*- # @File: demo.py # @author: Flyme awei # @email : Flymeawei@163.com # @Time: 2022/8/15 23:27''' 多态:多态就是具有多种形态，即便不知道一个变量所引用的对象是什么类型，仍然可以使用这个变量调用方法，在运行过程中根据变量所引用的对象类型，动态决定调用那个对象中的方法'''# 动态语言多崇尚鸭子类型，当一只鸟走起来向鸭子，游起来以向鸭子，看起来也像鸭子，那么这只鸟及可以被称为鸭子class Animal(object): def eat(self): print('动物会吃')class Dog(Animal): def eat(self): print('够吃骨头')class Cat(Animal): def eat(self): print('猫吃小鱼')class Person: def eat(self): print('人吃五谷杂粮')# 定义一个函数 def fun(fun1): fun1.eat()# 调用对象的eat()方法if __name__ == '__main__': # 开始调用函数 fun(Animal())# Cat继承了Animal Dog继承了Animal fun(Cat())# Cat 和Dog是重写了父类中的eat方法，调用了自己重写后的内容 fun(Dog())print('------------------') fun(Person())# Person 没有继承关系 但是有eat方法，直接调用eat方法

文章图片

1.动态语言与静态语言

Python是一门动态语言，可以在创建对象后动态的绑定属性和方法，

静态语言和动态语言关于多态的区别：

静态语言实现多态的三个必要条件(Java)
1. 继承
2. 方法重写
3. 父类引用指向子类对象

动态语言：(Python)
动态语言的多态崇尚 “鸭子类型“ 一只鸟走起来像鸭子，游起来像鸭子，那么这只鸟就可以被称为鸭子。在鸭子类型中，不需要关心对象是什么类型，到底是不是鸭子，只关心对象的行为’’’

四、类的特殊属性和方法 1.特殊属性

特殊属性	描述
__dict__	获得类对象或实例对象所绑定的所有属性的方法的字典

# -*- coding: utf-8 -*- # @File: demo.py # @author: Flyme awei # @email : Flymeawei@163.com # @Time: 2022/8/15 23:27# 特殊属性 __dict__ 获得类对象或实例对象所绑定的所有 属性 或 方法 的字典 class A: passclass B: passclass C(A, B): def __init__(self, name, age): # 实例属性 self.name = name self.age = ageif __name__ == '__main__':# 创建C类的对象 x = C('Jack', 20)# x是C类的一个实例对象print(x.__dict__)# 获得实例对象属性的字典 print(C.__dict__)# 获得类对象的属性和方法的字典 print('-----------------')print(x.__class__)# 输出对象所属的类 print(C.__bases__)# C类父类类型的元组(, ) print(C.__base__)# 类的基类离C类最近的父类 print(C.__mro__)# 查看类的层次结构 print(A.__subclasses__())# 子类的列表

文章图片

2.特殊方法

特殊方法	描述
__len__()	通过重写 __len__()方法，让内置函数len()的参数可以是自定义类型
__add__()	通过重写__add__()方法，可以让自定义对象具有+的功能
__new__()	用于创建对象
__init__()	对创建的对象进行初始化

__len__()方法和 __add__() 方法

# -*- coding: utf-8 -*- # @File: demo.py # @author: Flyme awei # @email : Flymeawei@163.com # @Time: 2022/8/15 23:27# 1.特殊方法__add__() # 通过重写 __add__()方法，可以使自定义对象具有 “+” 的功能 a = 20 b = 100 c = a + b# 两个整数类型的对象的相加操作 d = a.__add__(b) print(c) print(d)class Student: sex = '女'# 类属性def __init__(self, name):# 初始化方法 self.name = namedef __add__(self, other):# 重写 __add__()方法 可以使自定义对象具有 “+” 的功能 return self.name + other.namedef __len__(self):# 重写 __len__方法 让自定义函数len()的参数可以是自定义类型 return len(self.name)stu1 = Student('Jack') stu2 = Student('李四') s = stu1 + stu2# 实现了两个对象的加法运算（因为在Student类中 编写__add__()特殊的方法） print(s)# 2.特殊方法__len__() # 通过重写__len__()方法，让自定义函数len()的参数可以是自定义类型 lst = [11, 22, 33, 44] print(len(lst))# len是内置函数，可以计算列表的一个长度 print(lst.__len__())# 特殊方法 print(len(stu1))

文章图片

__new__方法

# -*- coding: utf-8 -*- # @File: demo.py # @author: Flyme awei # @email : Flymeawei@163.com # @Time: 2022/8/15 23:27class Person(object): def __new__(cls, *args, **kwargs):# 创建对象 print('__new__()方法被调用执行了，cls的id值为{0}'.format(id(cls))) obj = super().__new__(cls)# 创建对象 obj print(f'创建对象(obj)的id值为:{id(obj)}') print(Person)# print(obj)# <__main__.Person object at 0x000001C8B13D9CA0> return objdef __init__(self, name, age):# 对对象的属性进行初始化 print(f'__init__()被调用执行了，self的id值为{id(self)}') self.nane = name self.age = ageif __name__ == '__main__': print(f'object这个类对象的id为:{id(object)}') print(f'Person这个类对象的id为:{id(Person)}')# 创建Person类的实例对象 p1 = Person('张三', 20)print(f'p1这个Person类的实例对象的id为{id(p1)}')

文章图片

__init__方法

# -*- coding: utf-8 -*- # @File: demo.py # @author: Flyme awei # @email : Flymeawei@163.com # @Time: 2022/8/15 23:27class Person(object): def __new__(cls, *args, **kwargs):# 创建对象 print('__new__()方法被调用执行了，cls的id值为{0}'.format(id(cls))) obj = super().__new__(cls)# 创建对象 obj print(f'创建对象(obj)的id值为:{id(obj)}') return objdef __init__(self, name, age):# 对对象的属性进行初始化 print(f'__init__()被调用执行了，self的id值为{id(self)}') self.nane = name self.age = ageprint(f'object这个类对象的id为:{id(object)}') print(f'Person这个类对象的id为:{id(Person)}')# 创建Person类的实例对象 p1 = Person('张三', 20) print(f'p1这个Person类的实例对象的id为{id(p1)}')

文章图片

五、变量的赋值操作

只是多生成了一个变量，实际上还是指向同一个对象

# -*- coding: utf-8 -*- # author : Flyme awei # 开发时间: 2022/7/1 15:32class CPU: passclass Disk: passclass Computer: def __init__(self, cpu, disk):# 给对象的实例属性进行初始化 self.cpu = cpu self.disk = disk# 变量的赋值 cp1 = Computer(cpu='CPU', disk='DISK')# 创建CPU类的实例对象 cp2 = cp1 # 变量的赋值,一个对象的实例采用两个变量存储，实际上还是指向一个对象 print(cp1, id(cp1)) print(cp2, id(cp2))

文章图片

赋值（=），就是创建了对象的一个新的引用，修改其中任意一个变量都会影响到另一个。
六、对象的浅拷贝和深拷贝 1.浅拷贝

Python拷贝一般都是浅拷贝，拷贝时，对象包含的子对象内容不拷贝，因此，源对象与拷贝对象会引用同一个子对象。

# -*- coding: utf-8 -*- # author : Flyme awei # 开发时间: 2022/7/1 15:32import copyclass CPU: passclass Disk: passclass Computer: def __init__(self, cpu, disk):# 给对象的实例属性进行初始化 self.cpu = cpu self.disk = diskcpu = CPU()# 创建一个 CPU 类的实例对象 disk = Disk()# 创建一个Disk 类对象 computer = Computer(cpu, disk)# 创建一个Computer类的实例对象# 浅拷贝 print(cpu) print(disk) computer2 = copy.copy(computer)# 子对象不拷贝 print(computer, computer.cpu, computer.disk) print(computer2, computer2.cpu, computer2.disk)# 类的浅拷贝: # Python的拷贝一般都是浅拷贝，拷贝时，对象包含的子对象内容不拷贝 # 因此，源对象与拷贝对象会引用同一个子对象

文章图片

浅拷贝：创建一个新的对象，但它包含的是对原始对象中包含项的引用
（如果用引用的方式修改其中一个对象，另外一个也会修改改变）

哪些是浅拷贝：

1. 完全切片方法；
2. 工厂函数，如list()；
3. copy模块的copy()函数。

2.深拷贝

使用copy模块的deepcopy函数，递归拷贝对象中包含的子对象，源对象和拷贝对象所有的子对象也不相同。

# -*- coding: utf-8 -*- # author : Flyme awei # 开发时间: 2022/7/1 15:32import copyclass CPU: passclass Disk: passclass Computer: def __init__(self, cpu, disk):# 给对象的实例属性进行初始化 self.cpu = cpu self.disk = diskcpu = CPU()# 创建一个 CPU 对象 disk = Disk()# 创建一个硬盘类对象 computer = Computer(cpu, disk)# 创建一个计算机类对象# 深拷贝 computer1 = copy.deepcopy(computer) print(computer, computer.cpu, computer.disk) print(computer1, computer1.cpu, computer1.disk)# 类的深拷贝 # 使用copy模块的deepcopy函数，递归拷贝对象中包含的子对象 # 源对象和拷贝对象所有的子对象也不同

文章图片

深拷贝：创建一个新的对象，并且递归的复制它所包含的对象。

修改其中一个，另外一个不会改变。因此，新对象和原对象没有任何关联。
例如：{copy模块的deepcopy()函数}

七、总结

面向对象三大特征：

1. 封装：将属性和方法包装到类对象中，在方法内部对属性进行操作，在类对象外部调用方法。
2. 继承：多继承、方法重写
3. 多态：即便不知道一个变量所引用的对象是什么类型，仍然可以使用这个变量调用方法，在运行过程中根据变量所引用的对象类型，动态决定调用那个对象中的方法。

• 动态语言：关注对象的行为
• 静态语言：继承、方法重写、父类引用指向子类对象

object类

1. 所有类的父类
2. __new__()创建对象
3. __init__()初始化对象
4. __str__()返回对象的描述

?

推荐阅读

• 

  梳妆台摆放有哪些风水要注意 风水学梳妆台摆放
• 

  老松下变频空调质量怎么样1.5匹,实际上与普通无异
• 

  李时珍巧释鸡屎丸子
• 

  程序员分析流程图,HAZOP分析流程图
• 

  支付宝健康果怎么领取_支付宝领取健康果图文方法介绍
• 

  2022武汉欢乐谷万圣节是几号到几号结束
• 

  尼康D700怎么拍月亮 尼康d7200怎么拍月亮
• 

  大象怎么画
• 

  如何有效治疗肩周炎？
• 

  redis在java中的用法 redis纯java实现
• 

  Linux 怎么修改最大文件打开数量（）
• 

  一吐乌气是什么意思
• 

  grafana
• 

  跨境电商财务会计是干什么的啊 跨境电商财务会计是干什么的，跨境电商财务会计是干什么的工作
• 

  cpu冷头是什么，cpu冷头进出水孔怎么区分
• 

  杭州哪家公立医院医美最好 杭州哪个整形好
• 

  快乐玻璃杯第270关怎么过 快乐玻璃杯第270关攻略
• 

  分析师|分析师：iPhone 13在中国预购量已经接近600万大关，超级周期将持续到2022年
• 

  时延估计方法的分析
• 

  芝麻油菜——润肠排毒补血明目

• Python闲谈|python 玩玩乐 - moviepy 剪辑视频变成 gif 图
• python编程高阶|python文件打包成exe
• python编程高阶|用Python写一个计算器
• java|你不知道的 java 对象序列化的秘密
• android|Kotlin Sealed Class
• Python全能工程师2022版完结含文档源码
• 目标检测|目标检测损失函数
• python|利用Python制作证件照
• Python|Python 证件照换背景色（蓝底-＞白底，蓝底-＞红底）！