🤵♂️ 个人主页: @Flyme awei 个主页 👨💻 作者简介:Python领域新星创作者。 🐋 希望大家多多支持😘一起进步呀! 📝 如果文章对你有帮助的话,欢迎评论💬点赞👍收藏📂加关注
前言
今天是《CSDN21天学习挑战赛》的第17天 上一节学习了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.__agestu1.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 = 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_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 = 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): 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类父类类型的元组 (<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 = 20b = 100c = 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: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) # <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 = 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 obj def __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的拷贝一般都是浅拷贝,拷贝时,对象包含的子对象内容不拷贝# 因此,源对象与拷贝对象会引用同一个子对象
浅拷贝:创建一个新的对象,但它包含的是对原始对象中包含项的引用(如果用引用的方式修改其中一个对象,另外一个也会修改改变)
哪些是浅拷贝: 完全切片方法; 工厂函数,如list(); 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()函数}
七、总结
面向对象三大特征: 封装:将属性和方法包装到类对象中,在方法内部对属性进行操作,在类对象外部调用方法。 继承:多继承、方法重写 多态:即便不知道一个变量所引用的对象是什么类型,仍然可以使用这个变量调用方法,在运行过程中根据变量所引用的对象类型,动态决定调用那个对象中的方法。 动态语言:关注对象的行为 静态语言:继承、方法重写、父类引用指向子类对象
object类 所有类的父类 new()创建对象 init()初始化对象 str()返回对象的描述