【Python】面向对象

Python 前端之家
前端之家收集整理的这篇文章主要介绍了【Python】面向对象，前端之家小编觉得挺不错的，现在分享给大家，也给大家做个参考。

面向对象基础

一. 理解面向对象

面向对象是一种抽象化的编程思想，很多编程语言中都有的一种思想。
例如：洗⾐服
思考：⼏种途径可以完成洗⾐服？
答： 手洗 和 机洗。
手洗：找盆 - 放⽔ - 加洗⾐粉 - 浸泡 - 搓洗 - 拧⼲⽔ - 倒⽔ - 漂洗N次 - 拧⼲ - 晾晒。
机洗：打开洗⾐机 - 放⾐服 - 加洗⾐粉 - 按下开始按钮 - 晾晒。

思考：对比两种洗⾐服途径，同学们发现了什么？
答：机洗更简单
思考：机洗，只需要找到一台洗⾐机，加入简单操作就可以完成洗⾐服的工作，而不需要关心洗⾐机内部发生了什么事情。

总结：面向对象就是将编程当成是一个事物，对外界来说，事物是直接使用的，不用去管他内部的情况。而编程就是设置事物能够做什么事。

二. 类和对象

思考：洗⾐机洗⾐服描述过程中，洗⾐机其实就是一个事物，即对象，洗⾐机对象哪来的呢？
答：洗⾐机是由工⼚工人制作出来。

思考：工⼚工人怎么制作出的洗⾐机？
答：工人根据设计师设计的功能图纸制作洗⾐机。

总结：图纸 → 洗⾐机 → 洗⾐服。

在面向对象编程过程中，有两个重要组成部分：类 和 对象。
类和对象的关系：用类去创建一个对象。

2.1 理解类和对象

2.1.1 类

类是对一系列具有相同特征和行为的事物的统称，是一个抽象的概念，不是真实存在的事物。

类比如是制造洗⾐机时要用到的图纸，也就是说类是用来创建对象。

2.1.2 对象

对象是类创建出来的真实存在的事物，例如：洗⾐机。

注意：开发中，先有类，再有对象。

2.2 面向对象实现方法

2.2.1 定义类

Python2中类分为：经典类 和 新式类

语法

  1. class 类名():
  2.     代码
  3.     ......

注意：类名要满足标识符命名规则，同时遵循大驼峰命名习惯。

体验

  1. class Washer():
  2.     def wash(self):
  3.         print('我会洗⾐服')

拓展：经典类
不由任意内置类型派生出的类，称之为经典类

  1. class 类名:
  2.     代码
  3.     ......

2.2.2 创建对象

对象又名实例。

语法

  1. 对象名 = 类名()

体验

  1. # 创建对象
  2. haier1 = Washer()
  3. # <__main__.Washer object at 0x0000018B7B224240>
  4. print(haier1)
  5. # haier对象调用实例方法
  6. haier1.wash()

注意：创建对象的过程也叫实例化对象。

2.2.3 self

self指的是调用该函数的对象。

  1. # 1. 定义类
  2. class Washer():
  3.     def wash(self):
  4.         print('我会洗⾐服')
  5.         # <__main__.Washer object at 0x0000024BA2B34240>
  6.         print(self)
  8. # 2. 创建对象
  9. haier1 = Washer()
  10. # <__main__.Washer object at 0x0000018B7B224240>
  11. print(haier1)
  12. # haier1对象调用实例方法
  13. haier1.wash()
  15. haier2 = Washer()
  16. # <__main__.Washer object at 0x0000022005857EF0>
  17. print(haier2)

注意：打印对象和self得到的结果是一致的，都是当前对象的内存中存储地址。

三. 添加和获取对象属性

属性即是特征，比如：洗⾐机的宽度、高度、重量...
对象属性既可以在类外面添加和获取，也能在类里面添加和获取。

3.1 类外面添加对象属性

语法

  1. 对象名.属性名 = 值

体验

  1. haier1.width = 500
  2. haier1.height = 800

3.2 类外面获取对象属性

语法

  1. 对象名.属性名

体验

  1. print(f'haier1洗⾐机的宽度是{haier1.width}')
  2. print(f'haier1洗⾐机的高度是{haier1.height}')

3.3 类里面获取对象属性

语法

  1. self.属性名

体验

  1. # 定义类
  2. class Washer():
  3.     def print_info(self):
  4.         # 类里面获取实例属性
  5.         print(f'haier1洗⾐机的宽度是{self.width}')
  6.         print(f'haier1洗⾐机的高度是{self.height}')
  8. # 创建对象
  9. haier1 = Washer()
  11. # 添加实例属性
  12. haier1.width = 500
  13. haier1.height = 800
  15. haier1.print_info()

四. 魔法方法

在Python中， __xx__() 的函数叫做魔法方法，指的是具有特殊功能的函数。

4.1 __init__()

4.1.1 体验__init__()

思考：洗⾐机的宽度高度是与生俱来的属性，可不可以在生产过程中就赋予这些属性呢？
答：理应如此。

__init__() 方法的作用：初始化对象。

  1. class Washer():
  2.  
  3.     # 定义初始化功能的函数
  4.     def __init__(self):
  5.         # 添加实例属性
  6.         self.width = 500
  7.         self.height = 800
  8.     
  9.     def print_info(self):
  10.         # 类里面调用实例属性
  11.       print(f'洗⾐机的宽度是{self.width},高度是{self.height}')
  13. haier1 = Washer()
  14. haier1.print_info()

注意：

  • __init__() 方法，在创建一个对象时默认被调用，不需要手动调用
  • __init__(self) 中的self参数，不需要开发者传递，python解释器会自动把当前的对象引用传递过去。

4.1.2 带参数的__init__()

思考：一个类可以创建多个对象，如何对不同的对象设置不同的初始化属性呢？
答：传参数。

  1. class Washer():
  2.     def __init__(self,width,height):
  3.         self.width = width
  4.         self.height = height
  6.     def print_info(self):
  7.         print(f'洗⾐机的宽度是{self.width}')
  8.         print(f'洗⾐机的高度是{self.height}')
  10. haier1 = Washer(10,20)
  11. haier1.print_info()
  13. haier2 = Washer(30,40)
  14. haier2.print_info()

4.2 __str__()

当使用print输出对象的时候，默认打印对象的内存地址。如果类定义了 __str__ 方法，那么就会打印从在这个方法中 return 的数据。

  1. class Washer():
  2.     def __init__(self,height):
  3.         self.width = width
  4.         self.height = height
  6.     def __str__(self):
  7.         return '这是海尔洗⾐机的说明书'
  9. haier1 = Washer(10,20)
  10. # 这是海尔洗⾐机的说明书
  11. print(haier1)

4.3 __del__()

当删除对象时，python解释器也会默认调用 __del__() 方法。

  1. class Washer():
  2.     def __init__(self,height):
  3.         self.width = width
  4.         self.height = height
  5.     
  6.     def __del__(self):
  7.         print(f'{self}对象已经被删除')
  9. haier1 = Washer(10,20)
  11. # <__main__.Washer object at 0x0000026118223278>对象已经被删除
  12. del haier1

五. 综合应用

5.1 烤地⽠

5.1.1 需求

需求主线：

  1. 被烤的时间和对应的地⽠状态：
    0-3分钟：生的
    3-5分钟：半生不熟
    5-8分钟：熟的
    超过8分钟：烤糊了
  2. 添加的调料：
    用户可以按自己的意愿添加调料

5.1.2 步骤分析

需求涉及一个事物： 地⽠，故案例涉及一个类：地⽠类。

5.1.2.1 定义类
5.1.2.2 创建对象，调用相关实例方法

5.1.3 代码实现

5.1.3.1 定义类

地⽠属性
定义地⽠初始化属性，后期根据程序推进更新实例属性

  1. class SweetPotato():
  2.     def __init__(self):
  3.         # 被烤的时间
  4.         self.cook_time = 0
  5.         # 地⽠的状态
  6.         self.cook_static = '生的'
  7.         # 调料列表
  8.         self.condiments = []
5.1.3.2 定义烤地⽠方法
  1. class SweetPotato():
  2.     ......
  3.     
  4.     def cook(self,time):
  5.         """烤地⽠的方法"""
  6.         self.cook_time += time
  7.         if 0 <= self.cook_time < 3:
  8.             self.cook_static = '生的'
  9.         elif 3 <= self.cook_time < 5:
  10.             self.cook_static = '半生不熟'
  11.         elif 5 <= self.cook_time < 8:
  12.             self.cook_static = '熟了'
  13.         elif self.cook_time >= 8:
  14.             self.cook_static = '烤糊了'
5.1.3.3 书写str魔法方法，用于输出对象状态
  1. class SweetPotato():
  2.     ......
  3.     def __str__(self):
  4.     return f'这个地⽠烤了{self.cook_time}分钟,状态是{self.cook_static}'
5.1.3.4 创建对象，测试实例属性和实例方法
  1. digua1 = SweetPotato()
  2. print(digua1)
  3. digua1.cook(2)
  4. print(digua1)
5.1.3.5 定义添加调料方法，并调用该实例方法
  1. class SweetPotato():
  2.     ......
  4.     def add_condiments(self,condiment):
  5.         """添加调料"""
  6.         self.condiments.append(condiment)
  8.     def __str__(self):
  9.         return f'这个地⽠烤了{self.cook_time}分钟,状态是{self.cook_static},添加的调料有{self.condiments}'
  10.  
  11. digua1 = SweetPotato()
  12. print(digua1)
  14. digua1.cook(2)
  15. digua1.add_condiments('酱油')
  16. print(digua1)
  18. digua1.cook(2)
  19. digua1.add_condiments('辣椒面儿')
  20. print(digua1)
  22. digua1.cook(2)
  23. print(digua1)
  25. digua1.cook(2)
  26. print(digua1)

5.1.4 代码总览

  1. # 定义类
  2. class SweetPotato():
  3.     def __init__(self):
  4.         # 被烤的时间
  5.         self.cook_time = 0
  6.         # 地⽠的状态
  7.         self.cook_static = '生的'
  8.         # 调料列表
  9.         self.condiments = []
  11.     def cook(self,time):
  12.         """烤地⽠的方法"""
  13.         self.cook_time += time
  14.         if 0 <= self.cook_time < 3:
  15.             self.cook_static = '生的'
  16.         elif 3 <= self.cook_time < 5:
  17.             self.cook_static = '半生不熟'
  18.         elif 5 <= self.cook_time < 8:
  19.             self.cook_static = '熟了'
  20.         elif self.cook_time >= 8:
  21.             self.cook_static = '烤糊了'
  23.     def add_condiments(self,添加的调料有{self.condiments}'
  24.         
  25. digua1 = SweetPotato()
  26. print(digua1)
  28. digua1.cook(2)
  29. digua1.add_condiments('酱油')
  30. print(digua1)
  32. digua1.cook(2)
  33. digua1.add_condiments('辣椒面儿')
  34. print(digua1)
  36. digua1.cook(2)
  37. print(digua1)
  39. digua1.cook(2)
  40. print(digua1)

5.2 搬家具

5.2.1 需求

将小于房子剩余面积的家具摆放到房子中

5.2.2 步骤分析

需求涉及两个事物：房子 和 家具，故被案例涉及两个类：房子类 和 家具类。

5.2.2.1 定义类
  • 房子类
    • 实例属性
      • 房子地理位置
      • 房子占地面积
      • 房子剩余面积
      • 房子内家具列表
    • 实例方法
      • 容纳家具
    • 显示房屋信息
  • 家具类
    • 家具名称
    • 家具占地面积
5.2.2.2 创建对象并调用相关方法

5.2.3 代码实现

5.2.3.1 定义类

家具类

  1. class Furniture():
  2.     def __init__(self,name,area):
  3.         # 家具名字
  4.         self.name = name
  5.         # 家具占地面积
  6.         self.area = area

房子类

  1. class Home():
  2.     def __init__(self,address,area):
  3.         # 地理位置
  4.         self.address = address
  5.         # 房屋面积
  6.         self.area = area
  7.         # 剩余面积
  8.         self.free_area = area
  9.         # 家具列表
  10.         self.furniture = []
  12.     def __str__(self):
  13.         return f'房子坐落于{self.address},占地面积{self.area},剩余面积{self.free_area},家具有{self.furniture}'
  15.     def add_furniture(self,item):
  16.         """容纳家具"""
  17.         if self.free_area >= item.area:
  18.             self.furniture.append(item.name)
  19.             # 家具搬入后，房屋剩余面积 = 之前剩余面积 - 该家具面积
  20.             self.free_area -= item.area
  21.         else:
  22.             print('家具太大，剩余面积不足，无法容纳')
5.2.3.2 创建对象并调用实例属性和方法
  1. bed = Furniture('双人床',6)
  2. jia1 = Home('北京',1200)
  3. print(jia1)
  5. jia1.add_furniture(bed)
  6. print(jia1)
  8. sofa = Furniture('沙发',10)
  9. jia1.add_furniture(sofa)
  10. print(jia1)
  12. ball = Furniture('篮球场',1500)
  13. jia1.add_furniture(ball)
  14. print(jia1)

面向对象-继承

一. 继承的概念

生活中的继承，一般指的是子女继承⽗辈的财产。

拓展1：经典类或旧式类
不由任意内置类型派生出的类，称之为经典类。

  1. class 类名:
  2.     代码
  3.     ......

拓展2：新式类

  1. class 类名(object):
  2.     代码

Python面向对象的继承指的是多个类之间的所属关系，即子类默认继承⽗类的所有属性和方法，具体如下：

  1. # ⽗类A
  2. class A(object):
  3.     def __init__(self):
  4.         self.num = 1
  5.     def info_print(self):
  6.         print(self.num)
  8. # 子类B
  9. class B(A):
  10.     pass
  12. result = B()
  13. result.info_print() # 1

在Python中，所有类默认继承object类，object类是顶级类或基类；其他子类叫做派生类。

二. 单继承

故事主线：一个煎饼果子⽼师傅，在煎饼果子界摸爬滚打多年，研发了一套精湛的摊煎饼果子的技术。师⽗要把这套技术传授给他的唯一的最得意的徒弟。

分析：徒弟是不是要继承师⽗的所有技术？

  1. # 1. 师⽗类
  2. class Master(object):
  3.     def __init__(self):
  4.         self.kongfu = '[古法煎饼果子配方]'
  5.     
  6.     def make_cake(self):
  7.         print(f'运用{self.kongfu}制作煎饼果子')
  8.  
  9. # 2. 徒弟类
  10. class Prentice(Master):
  11.     pass
  13. # 3. 创建对象daqiu
  14. daqiu = Prentice()
  15. # 4. 对象访问实例属性
  16. print(daqiu.kongfu) 
  18. # 5. 对象调用实例方法
  19. daqiu.make_cake()

三. 多继承

故事推进：daqiu是个爱学习的好孩子，想学习更多的煎饼果子技术，于是，在百度搜索到程序员，报班学习煎饼果子技术。

所谓多继承意思就是一个类同时继承了多个⽗类。

  1. class Master(object):
  2.     def __init__(self):
  3.         self.kongfu = '[古法煎饼果子配方]'
  5.     def make_cake(self):
  6.         print(f'运用{self.kongfu}制作煎饼果子')
  8. # 创建学校类
  9. class School(object):
  10.     def __init__(self):
  11.         self.kongfu = '[⿊⻢煎饼果子配方]'
  13.     def make_cake(self):
  14.         print(f'运用{self.kongfu}制作煎饼果子')
  16. class Prentice(School,Master):
  17.    pass
  19. daqiu = Prentice()
  20. print(daqiu.kongfu)
  21. daqiu.make_cake()

注意：当一个类有多个⽗类的时候，默认使用第一个⽗类的同名属性和方法。

四. 子类重写⽗类同名方法和属性

故事：daqiu掌握了师⽗和培训的技术后，自己潜心钻研出自己的独门配方的一套全新的煎饼果子技术。

  1. class Master(object):
  2.     def __init__(self):
  3.         self.kongfu = '[古法煎饼果子配方]'
  4.     
  5.     def make_cake(self):
  6.         print(f'运用{self.kongfu}制作煎饼果子')
  8. class School(object):
  9.     def __init__(self):
  10.         self.kongfu = '[⿊⻢煎饼果子配方]'
  11.     
  12.     def make_cake(self):
  13.         print(f'运用{self.kongfu}制作煎饼果子')
  15. # 独创配方
  16. class Prentice(School,Master):
  17.      def __init__(self):
  18.         self.kongfu = '[独创煎饼果子配方]'
  19.  
  20.     def make_cake(self):
  21.         print(f'运用{self.kongfu}制作煎饼果子')
  23. daqiu = Prentice()
  24. print(daqiu.kongfu)
  25. daqiu.make_cake()
  27. print(Prentice.__mro__)

子类和⽗类具有同名属性和方法，默认使用子类的同名属性和方法。

五. 子类调用⽗类的同名方法和属性

故事：很多顾客都希望也能吃到古法和⿊⻢的技术的煎饼果子。

  1. class Master(object):
  2.     def __init__(self):
  3.         self.kongfu = '[古法煎饼果子配方]'
  4.     
  5.     def make_cake(self):
  6.     print(f'运用{self.kongfu}制作煎饼果子')
  8. class School(object):
  9.     def __init__(self):
  10.         self.kongfu = '[⿊⻢煎饼果子配方]'
  11.     
  12.     def make_cake(self):
  13.         print(f'运用{self.kongfu}制作煎饼果子')
  15. class Prentice(School,Master):
  16.     def __init__(self):
  17.         self.kongfu = '[独创煎饼果子配方]'
  18.     
  19.     def make_cake(self):
  20.         # 如果是先调用了⽗类的属性和方法，⽗类属性会覆盖子类属性，故在调用属性前，先调用自己子类的初始化
  21.         self.__init__()
  22.         print(f'运用{self.kongfu}制作煎饼果子')
  23.  
  24.     # 调用⽗类方法，但是为保证调用到的也是⽗类的属性，必须在调用方法前调用⽗类的初始化
  25.     def make_master_cake(self):
  26.         Master.__init__(self)
  27.         Master.make_cake(self)
  28.  
  29.     def make_school_cake(self):
  30.         School.__init__(self)
  31.         School.make_cake(self)
  33. daqiu = Prentice()
  35. daqiu.make_cake()
  37. daqiu.make_master_cake()
  39. daqiu.make_school_cake()
  41. daqiu.make_cake()

六. 多层继承

故事：N年后，daqiu⽼了，想要把所有技术传承给自己的徒弟。

  1. class Master(object):
  2.     def __init__(self):
  3.         self.kongfu = '[古法煎饼果子配方]'
  4.     
  5.     def make_cake(self):
  6.         print(f'运用{self.kongfu}制作煎饼果子')
  8. class School(object):
  9.     def __init__(self):
  10.         self.kongfu = '[⿊⻢煎饼果子配方]'
  11.     
  12.     def make_cake(self):
  13.         print(f'运用{self.kongfu}制作煎饼果子')
  15. class Prentice(School,Master):
  16.     def __init__(self):
  17.         self.kongfu = '[独创煎饼果子配方]'
  18.  
  19.     def make_cake(self):
  20.         self.__init__()
  21.         print(f'运用{self.kongfu}制作煎饼果子')
  22.  
  23.     def make_master_cake(self):
  24.         Master.__init__(self)
  25.         Master.make_cake(self)
  26.  
  27.     def make_school_cake(self):
  28.         School.__init__(self)
  29.         School.make_cake(self)
  31. # 徒孙类
  32. class Tusun(Prentice):
  33.     pass
  35. xiaoqiu = Tusun()
  37. xiaoqiu.make_cake()
  39. xiaoqiu.make_school_cake()
  41. xiaoqiu.make_master_cake()

七. super()调用⽗类方法

  1. class Master(object):
  2.     def __init__(self):
  3.         self.kongfu = '[古法煎饼果子配方]'
  4.     
  5.     def make_cake(self):
  6.         print(f'运用{self.kongfu}制作煎饼果子')
  8. class School(Master):
  9.     def __init__(self):
  10.         self.kongfu = '[⿊⻢煎饼果子配方]'
  11.  
  12.     def make_cake(self):
  13.         print(f'运用{self.kongfu}制作煎饼果子')
  14.         # 方法2.1
  15.         # super(School,self).__init__()
  16.         # super(School,self).make_cake()
  17.         
  18.         # 方法2.2
  19.         super().__init__()
  20.         super().make_cake()
  22. class Prentice(School):
  23.     def __init__(self):
  24.         self.kongfu = '[独创煎饼果子技术]'
  25.     
  26.     def make_cake(self):
  27.         self.__init__()
  28.         print(f'运用{self.kongfu}制作煎饼果子')
  29.  
  30.     # 子类调用⽗类的同名方法和属性：把⽗类的同名属性和方法再次封装
  31.     def make_master_cake(self):
  32.         Master.__init__(self)
  33.         Master.make_cake(self)
  34.  
  35.     def make_school_cake(self):
  36.         School.__init__(self)
  37.         School.make_cake(self)
  38.  
  39.     # 一次性调用⽗类的同名属性和方法
  40.     def make_old_cake(self):
  41.         # 方法一：代码冗余；⽗类类名如果变化，这里代码需要频繁修改
  42.         # Master.__init__(self)
  43.         # Master.make_cake(self)
  44.         # School.__init__(self)
  45.         # School.make_cake(self)
  46.         # 方法二: super()
  47.         # 方法2.1 super(当前类名,self).函数()
  48.         # super(Prentice,self).__init__()
  49.         # super(Prentice,self).make_cake()
  50.         # 方法2.2 super().函数()
  51.         super().__init__()
  52.         super().make_cake()
  54. daqiu = Prentice()
  56. daqiu.make_old_cake()

注意：使用super() 可以自动查找⽗类。调用顺序遵循 __mro__ 类属性的顺序。比较适合单继承使用。

八. 私有权限

8.1 定义私有属性和方法

在Python中，可以为实例属性和方法设置私有权限，即设置某个实例属性或实例方法不继承给子类。

故事：daqiu把技术传承给徒弟的同时，不想把自己的钱(2000000个亿)继承给徒弟，这个时候就要为 钱 这个实例属性设置私有权限。

设置私有权限的方法：在属性名和方法名 前面 加上两个下划线 __。

  1. class Master(object):
  2.     def __init__(self):
  3.         self.kongfu = '[古法煎饼果子配方]'
  4.  
  5.     def make_cake(self):
  6.         print(f'运用{self.kongfu}制作煎饼果子')
  8. class School(object):
  9.     def __init__(self):
  10.         self.kongfu = '[⿊⻢煎饼果子配方]'
  11.     def make_cake(self):
  12.         print(f'运用{self.kongfu}制作煎饼果子')
  14. class Prentice(School,Master):
  15.     def __init__(self):
  16.         self.kongfu = '[独创煎饼果子配方]'
  17.         # 定义私有属性
  18.         self.__money = 2000000
  19.     
  20.     # 定义私有方法
  21.     def __info_print(self):
  22.         print(self.kongfu)
  23.         print(self.__money)
  24.  
  25.     def make_cake(self):
  26.         self.__init__()
  27.         print(f'运用{self.kongfu}制作煎饼果子')
  28.  
  29.     def make_master_cake(self):
  30.         Master.__init__(self)
  31.         Master.make_cake(self)
  32.  
  33.     def make_school_cake(self):
  34.     School.__init__(self)
  35.     School.make_cake(self)
  37. # 徒孙类
  38. class Tusun(Prentice):
  39.     pass
  41. daqiu = Prentice()
  42. # 对象不能访问私有属性和私有方法
  43. # print(daqiu.__money)
  44. # daqiu.__info_print()
  46. xiaoqiu = Tusun()
  47. # 子类无法继承⽗类的私有属性和私有方法
  48. # print(xiaoqiu.__money) # 无法访问实例属性__money
  49. # xiaoqiu.__info_print()

注意：私有属性和私有方法只能在类里面访问和修改。

8.2 获取和修改私有属性值

在Python中，一般定义函数名 get_xx 用来获取私有属性，定义 set_xx 用来修改私有属性值。

  1. class Master(object):
  2.     def __init__(self):
  3.         self.kongfu = '[古法煎饼果子配方]'
  4.     
  5.     def make_cake(self):
  6.         print(f'运用{self.kongfu}制作煎饼果子')
  8. class School(object): 
  9.     def __init__(self):
  10.         self.kongfu = '[⿊⻢煎饼果子配方]'
  11.  
  12.     def make_cake(self):
  13.         print(f'运用{self.kongfu}制作煎饼果子')
  15. class Prentice(School,Master):
  16.     def __init__(self):
  17.         self.kongfu = '[独创煎饼果子配方]'
  18.         self.__money = 2000000
  19.     
  20.     # 获取私有属性
  21.     def get_money(self):
  22.         return self.__money
  23.     
  24.     # 修改私有属性
  25.     def set_money(self):
  26.         self.__money = 500
  27.  
  28.     def __info_print(self):
  29.         print(self.kongfu)
  30.         print(self.__money)
  31.     
  32.     def make_cake(self):
  33.         self.__init__()
  34.         print(f'运用{self.kongfu}制作煎饼果子')
  36.     def make_master_cake(self):
  37.         Master.__init__(self)
  38.         Master.make_cake(self)
  39.     
  40.     def make_school_cake(self):
  41.         School.__init__(self)
  42.         School.make_cake(self)
  43.     
  44. # 徒孙类
  45. class Tusun(Prentice):
  46.     pass
  48. daqiu = Prentice()
  50. xiaoqiu = Tusun()
  51. # 调用get_money函数获取私有属性money的值
  52. print(xiaoqiu.get_money())
  53. # 调用set_money函数修改私有属性money的值
  54. xiaoqiu.set_money()
  55. print(xiaoqiu.get_money())

面向对象-其他

一. 面向对象三大特性

二. 多态

2.1 了解多态

多态指的是一类事物有多种形态，（一个抽象类有多个子类，因而多态的概念依赖于继承）。

  • 定义：多态是一种使用对象的方式，子类重写⽗类方法，调用不同子类对象的相同⽗类方法，可以产生不同的执行结果
  • 好处：调用灵活，有了多态，更容易编写出通用的代码，做出通用的编程，以适应需求的不断变化！
  • 实现步骤：
    • 定义⽗类，并提供公共方法
    • 定义子类，并重写⽗类方法
    • 传递子类对象给调用者，可以看到不同子类执行效果不同

2.2 体验多态

  1. class Dog(object):
  2.     def work(self): # ⽗类提供统一的方法，哪怕是空方法
  3.         print('指哪打哪...')
  5. class ArmyDog(Dog): # 继承Dog类
  6.     def work(self): # 子类重写⽗类同名方法
  7.         print('追击敌人...')
  9. class DrugDog(Dog):
  10.     def work(self):
  11.         print('追查毒品...')
  13. class Person(object):
  14.     def work_with_dog(self,dog): # 传入不同的对象，执行不同的代码，即不同的work函数
  15.         dog.work()
  17. ad = ArmyDog()
  18. dd = DrugDog()
  20. daqiu = Person()
  21. daqiu.work_with_dog(ad)
  22. daqiu.work_with_dog(dd)

三. 类属性和实例属性

3.1 类属性

3.1.1 设置和访问类属性

  • 类属性就是 类对象 所拥有的属性，它被 该类的所有实例对象 所共有。
  • 类属性可以使用 类对象 或 实例对象 访问。
  1. class Dog(object):
  2.     tooth = 10
  4. wangcai = Dog()
  5. xiaohei = Dog()
  7. print(Dog.tooth) # 10
  8. print(wangcai.tooth) # 10
  9. print(xiaohei.tooth) # 10

类属性的优点

  • 类的实例 记录的某项数据 始终保持一致时，则定义类属性。
  • 实例属性 要求 每个对象 为其 单独开辟一份内存空间 来记录数据，而 类属性 为全类所共有，仅占用一份内存，更加节省内存空间。

3.1.2 修改类属性

类属性只能通过类对象修改，不能通过实例对象修改，如果通过实例对象修改类属性，表示的是创建了一个实例属性。

  1. class Dog(object):
  2.     tooth = 10
  4. wangcai = Dog()
  5. xiaohei = Dog()
  7. # 修改类属性
  8. Dog.tooth = 12
  9. print(Dog.tooth) # 12
  10. print(wangcai.tooth) # 12
  11. print(xiaohei.tooth) # 12
  13. # 不能通过对象修改属性，如果这样操作，实则是创建了一个实例属性
  14. wangcai.tooth = 20
  15. print(Dog.tooth) # 12
  16. print(wangcai.tooth) # 20
  17. print(xiaohei.tooth) # 12

3.2 实例属性

  1. class Dog(object):
  2.     def __init__(self):
  3.         self.age = 5
  4.     def info_print(self):
  5.         print(self.age)
  7. wangcai = Dog()
  8. print(wangcai.age) # 5
  9. # print(Dog.age) # 报错：实例属性不能通过类访问
  10. wangcai.info_print() # 5

四. 类方法和静态方法

4.1 类方法

4.1.1 类方法特点

  • 第一个形参是类对象的方法
  • 需要用装饰器 @classmethod 来标识其为类方法，对于类方法，第一个参数必须是类对象，一般以 cls 作为第一个参数。

4.1.2 类方法使用场景

  1. class Dog(object):
  2.     __tooth = 10
  3.     
  4.     @classmethod
  5.     def get_tooth(cls):
  6.         return cls.__tooth
  8. wangcai = Dog()
  9. result = wangcai.get_tooth()
  10. print(result) # 10

4.2 静态方法

4.2.1 静态方法特点

  • 需要通过装饰器 @staticmethod 来进行修饰，静态方法既不需要传递类对象也不需要传递实例对象（形参没有self/cls）。
  • 静态方法 也能够通过 实例对象 和 类对象 去访问。

4.2.2 静态方法使用场景

  • 当方法中 既不需要使用实例对象(如实例对象，实例属性)，也不需要使用类对象 (如类属性、类方法、创建实例等)时，定义静态方法
  • 取消不需要的参数传递，有利于 减少不必要的内存占用和性能消耗
  1. class Dog(object):
  2.     @staticmethod
  3.     def info_print():
  4.         print('这是一个狗类，用于创建狗实例....')
  6. wangcai = Dog()
  7. # 静态方法既可以使用对象访问又可以使用类访问
  8. wangcai.info_print()
  9. Dog.info_print()

猜你在找的Python相关文章

爬虫实战：探索XPath爬虫技巧之热榜新闻
在这篇文章中，我们深入学习了XPath作为一种常见的网络爬虫技巧。XPath是一种用于定位和选...
谁说后端不能画出美丽的动图？让我来给大家拜个年！
祝福大家龙年快乐！愿你们的生活像龙一样充满力量和勇气，愿你们在新的一年里，追逐梦想，...
爬虫实战：从网页到本地，如何轻松实现小说离线阅读
今天在爬虫实战中，除了正常爬取网页数据外，我们还添加了一个下载功能，主要任务是爬取小...
爬虫实战+数据分析：全国消费支出分析及未来预测
完美收官，本文是爬虫实战的最后一章了，所以尽管本文着重呈现爬虫实战，但其中有一大部分...
Java开发者的Python进修指南：JSON利器之官方json库、demjson和orjson的实用指南
JSON是一种流行的数据传输格式，Python中有多种处理JSON的方式。官方的json库是最常用的，...
使用Python的turtle模块绘制美丽的樱花树
通过本文的学习和实践，我们掌握了使用Python的turtle模块来创作樱花树图画的技巧，这个过...
利用大型语言模型轻松打造浪漫时刻
在这篇文章中，我们介绍了如何利用大型语言模型为情人节营造难忘的氛围。通过上传图片并进...
成为一个合格程序员所必备的三种常见LeetCode排序算法
排序算法是一种通过特定的算法因式将一组或多组数据按照既定模式进行重新排序的方法。通过...
5分钟上手Python爬虫：从干饭开始，轻松掌握技巧
本文的重点在于引导读者如何初步掌握爬虫技术。初步掌握爬虫技术并不难，但是在实际操作中...
AI实用指南：5分钟搭建你自己的LLM聊天应用
本文介绍了如何快速搭建一个基于大型语言模型（LLM）的混元聊天应用。强调了开发速度的重要...
PHPJavaJava SEPythonC#C&C++RubyVBasp.NetGoPerlnettyDjangoDelphiJsp.NET CoreSpringFlaskSpringbootSpringMVCLuaLaravelMybatisAspGroovyThinkPHPYiiswoole
文件时间pythonm相等性PHP Warning时间问题问题解决pcntl_signal采样点wav模块动态文本调用频率限制对外暴露多个访问请求更新数据表模型结构type()方法比较速度手写体sobel算子保存模型Image类nn.Conv2dpytorch1.0kaggleDCGAN交并比range()用法打印模型反卷积卷积