关键词：
🤵♂️ 个人主页: @Flyme awei 个主页
👨💻 作者简介：Python领域新星创作者。
🐋 希望大家多多支持😘一起进步呀！
📝 如果文章对你有帮助的话，欢迎评论💬点赞👍收藏📂加关注
前言
今天是《CSDN21天学习挑战赛》的第17天
上一节学习了Python基础语法类和对象
今天将Python面向三大特征：封装、继承、多态
活动地址：CSDN21天学习挑战赛
文章目录
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:27
class 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:27
class Person(object):
def __init__(self, name, age):
self.name = name
self.age = age
def 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_nb
class Teach(Person):
def __init__(self, name, age, teach_of_year):
super(Teach, self).__init__(name, age)
self.teach_of_year = teach_of_year
student = 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 = age
def 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 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_year
def 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 = age
def __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)) # <class '__main__.Student'> 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):
pass
class B(object):
pass
class 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:
pass
class B:
pass
class C(A, B):
def __init__(self, name, age):
# 实例属性
self.name = name
self.age = age
if __name__ == '__main__':
# 创建C类的对象
x = C('Jack', 20) # x是C类的一个实例对象
print(x.__dict__) # 获得实例对象属性的字典
print(C.__dict__) # 获得类对象的属性和方法的字典
print('-----------------')
print(x.__class__) # 输出对象所属的类
print(C.__bases__) # C类父类类型的元组 (<class '__main__.A'>, <class '__main__.B'>)
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 = name
def __add__(self, other): # 重写 __add__()方法 可以使自定义对象具有 “+” 的功能
return self.name + other.name
def __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:27
class 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) # <class '__main__.Person'>
print(obj) # <__main__.Person object at 0x000001C8B13D9CA0>
return obj
def __init__(self, name, age): # 对对象的属性进行初始化
print(f'__init__()被调用执行了，self的id值为id(self)')
self.nane = name
self.age = age
if __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:27
class 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 obj
def __init__(self, name, age): # 对对象的属性进行初始化
print(f'__init__()被调用执行了，self的id值为id(self)')
self.nane = name
self.age = age
print(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:32
class CPU:
pass
class Disk:
pass
class 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:32
import copy
class CPU:
pass
class Disk:
pass
class Computer:
def __init__(self, cpu, disk): # 给对象的实例属性进行初始化
self.cpu = cpu
self.disk = disk
cpu = 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的拷贝一般都是浅拷贝，拷贝时，对象包含的子对象内容不拷贝
# 因此，源对象与拷贝对象会引用同一个子对象
浅拷贝：创建一个新的对象，但它包含的是对原始对象中包含项的引用
（如果用引用的方式修改其中一个对象，另外一个也会修改改变）
哪些是浅拷贝：
- 完全切片方法；
- 工厂函数，如
list()；copy模块的copy()函数。
2.深拷贝
使用
copy模块的deepcopy函数，递归拷贝对象中包含的子对象，源对象和拷贝对象所有的子对象也不相同。
# -*- coding: utf-8 -*-
# author : Flyme awei
# 开发时间: 2022/7/1 15:32
import copy
class CPU:
pass
class Disk:
pass
class Computer:
def __init__(self, cpu, disk): # 给对象的实例属性进行初始化
self.cpu = cpu
self.disk = disk
cpu = CPU() # 创建一个 CPU 对象
disk = Disk() # 创建一个硬盘类对象
computer = Computer(cpu, disk) # 创建一个计算机类对象
# 深拷贝
computer1 = copy.deepcopy(computer)
print(computer, computer.cpu, computer.disk)
print(computer1面向对象三大特征(代码片段)
面向对象三大特征：封装、继承、多态继承是多态的前提，如果没有继承，就没有多态。封装性在Java当中的体现：方法就是一种封装关键字private也是一种封装（一旦使用了private进行修饰，那么本类当中仍然可以随意访问。但是... 查看详情
面向对象三大特征之多态(代码片段)
面向对象的三大特征:封装、继承、多态。今天重点来看一下“多态”。封装 指一种将抽象性函式接口的实现细节部份包装、隐藏起来的方法。将属性或方法进行封装，防止外部程序随机访问，加强代码的安全性。继承&n... 查看详情
java面向对象三大特征之继承和多态(代码片段)
...转型多态代码案例总结前言 上一篇博客我们介绍了Java面向对象思想以及三大特征之一的封装。本文将介绍面向对象三大特征的剩下两个特征——继承和多态，我个人认为继承和多态是三个特征中比较重要且理解起来稍有... 查看详情
面向对象的三大特征,用一个整体表示?(代码片段)
1.三个类和一个函数来表达,这个面向对象的三大特征#封装继承多态整体写的方法classAnimal:defdong(self):#封装print(‘动物在动‘)defchi(self):print(‘动物在吃‘)classCat(Animal):#继承def__init__(self,maose,pinzhong,nianling,xingbie):self.maose=maoseself.pin 查看详情
面向对象的三大特征(代码片段)
面向对象的三大特征特性一：封装什么是封装？封装的特点封装的使用特征二：继承什么是继承关于继承的注意事项：继承的特点：继承的使用重写，重载构造器特征三：多态实现条件：实现原理... 查看详情
面向对象的三大特征:继承封装多态(代码片段)
面向对象:面向对象专注于由谁来解决这个过程,而调用者无需关注对象实现的细节编程特点:出现了一个个的类,从类中拿到对象,通过对象直接解决问题类:具有一系列相同属性(特征)和方法(行为)的个体的集合称为类 ... 查看详情
面向对象的三大特征之一：继承(代码片段)
继承：面向对象的编程带来的主要好处之一是代码的重用，实现这种重用的方法之一是通过继承机制。继承完全可以理解成类之间的类型和子类型关系。需要注意的地方：继承语法 class 派生类名（基类名）：//..... 查看详情
面向对象的三大特征之一：封装(代码片段)
封装：每个对象都包含它能进行操作所需要的所有信息，这个特性就是封装，因此对象不必依赖其他对象来完成自己的操作。这样的方法和属性包装在类中，通过类的实例来实现。classA:__x=1def__init__(self,name,age):self.name=nameself.age=a... 查看详情
java面向对象三大基本特征(代码片段)
...意事项：4.多态4.1多态思想4.2 多态中的转型如何理解面向对象？简单的说就是把事物和操作事物的方法汇集到一起，形成一个相互依赖的整体。下面我们来了解面向对象的基础知识1.类和对象1.1概念 查看详情
golang如何体现面向对象三大特征之多态？(代码片段)
...多态数组基本介绍变量（实例）具有多种形态。面向对象的三大特征，在Go语言，多态特征是通过接口实现的。可以按照统一的接口来调用不同的实现。这时接口变量就呈现不同的形态。快速入门在前面的Usb接口... 查看详情
谈面向对象的三大特征
...对象直接解决问题。 应用：Java PHP c++ c# Python 面向对象的三大特征：继承 封装 多态 分别了解继承、封装、多态 ↓↓↓一、继承 1、子类继承父类，使用extends关键字。 代码示 查看详情
面向对象的三大特征，封装继承多态的个人理解以及代码分析(代码片段)
面向过程：我们以前使用的是面向过程编程，你需要清除每个实现步骤，每个步骤每行代码都要仔仔细细的编写， 不知道过程就找不到结果，找到实现过程就可以得到实现结果。 例如：我们在外打工租房子... 查看详情
面向对象（1三大特征；2六大原则）(代码片段)
目录一、面向对象的概述：二、封装：1、封装概述2、封装原则3、封装好处4、封装坏处5、封装代码展示三、继承：1、概念：2、实现格式：3、特点：4、好处：5、弊端：6、应用场景7、继承中变量... 查看详情
从人的视角谈一谈面向对象的封装特征(代码片段)
文章目录面向对象三大特征封装private关键字——实现类封装访问器方法和更改器方法包——类的集合导入包从人的角度理解包不加访问权限——实现包封装总结在上一篇文章中，我们了解了面向对象的基础内容，这一篇... 查看详情
golang如何体现面向对象三大特征之封装？(代码片段)
...的好处golang如何体现封装封装的实现基本介绍Golang仍然有面向对象编程的继承、封装和多态的特性，只是实现的方法和其它OOP语言不一样，下面我们来看看Golang是如何实现封装的。封装介绍封装（encapsulation）就是... 查看详情
python笔记——面向对象的细节(代码片段)
...备的特征，只是不同语言在实现上会有所不同。那么python是怎么实现这三个特征的呢？咱这就来唠唠。封装封装是为了提高程序的安全性将数据（属性）和行为（方法）包装到类对象中。在方法内部对属性... 查看详情
python笔记——面向对象的细节(代码片段)
...备的特征，只是不同语言在实现上会有所不同。那么python是怎么实现这三个特征的呢？咱这就来唠唠。封装封装是为了提高程序的安全性将数据（属性）和行为（方法）包装到类对象中。在方法内部对属性... 查看详情
c++面向对象三大特征封装继承和多态知识总结(代码片段)
面向对象三大特征：封装，继承，多态；一、封装：该公开的就公开话，该私有的就隐藏掉，主要是由public，private实现；作用是便于分工和分模块，防止不必要的扩展；二、继承：... 查看详情