Python 面向对象基础

矫情吗；* 2023-06-01 06:21 165阅读 0赞

一、面向对象概述

如今主流的软件开发思想有两种：一个是面向过程，另一个是面向对象。面向过程出现得较早，典型代表为C语言，开发中小型项目的效率很高，但是很难适用于如今主流的大中型项目开发场景。面向对象则出现得更晚一些，典型代表为Java或C++等语言，更加适合用于大型开发场景。两种开发思想各有长短。

对于面向过程的思想： 需要实现一个功能的时候,看重的是开发的步骤和过程,每一个步骤都需要自己亲力亲为,需要自己编写代码(自己来做)

对于面向对象的思想：当需要实现一个功能的时候,看重的并不是过程和步骤,而是关心谁帮我做这件事(偷懒,找人帮我做)

面向对象的三大特征有：封装性、继承性、多态性。

1.1 面向过程与面向对象

面向过程的程序设计的核心是过程（流水线式思维），过程即解决问题的步骤，面向过程的设计就好比精心设计好一条流水线，考虑周全什么时候处理什么东西。

优点是：极大的降低了写程序的复杂度，只需要顺着要执行的步骤，堆叠代码即可。

缺点是：一套流水线或者流程就是用来解决一个问题，代码牵一发而动全身。

面向对象的程序设计的核心是对象（上帝式思维），要理解对象为何物，必须把自己当成上帝，上帝眼里世间存在的万物皆为对象，不存在的也可以创造出来。

优点是：解决了程序的扩展性。对某一个对象单独修改，会立刻反映到整个体系中，如对游戏中一个人物参数的特征和技能修改都很容易。

缺点：可控性差，无法向面向过程的程序设计流水线式的可以很精准的预测问题的处理流程与结果，面向对象的程序一旦开始就由对象之间的交互解决问题，即便是上帝也无法预测最终结果。于是我们经常看到一个游戏人某一参数的修改极有可能导致阴霸的技能出现，一刀砍死3个人，这个游戏就失去平衡。

面向对象编程可以使程序的维护和扩展变得更简单，并且可以大大提高程序开发效率 ，另外，基于面向对象的程序可以使它人更加容易理解你的代码逻辑，从而使团队开发变得更从容。

二、类与对象

面向对象编程的2个非常重要的概念：类和对象。

我们学习编程语言，就是为了模拟现实世界中的事物，实现信息化来提高工作效率。例如银行的业务系统、超市的结账系统等，都是如此。

面向对象的语言当中，“类”就是用来模拟现实事物的。

那么模拟现实世界的事物通常从两方面模拟：

  • 属性：事物的特征描述信息，用于描述某个特征“是什么”。
  • 行为：事物的能力行动方案，用于说明事物“能做什么”。

类中也有属性、行为两个组成部分，而“对象”是类的具体实例。例如：

  • 类：抽象的，是一张“手机设计图”。
  • 对象：具体的，是一个“真正的手机实例”。

2.1 初识类

python中一切皆为对象，类型的本质就是类。

  1. >>> dict  # 类型dict就是类dict
  2. <class 'dict'>
  3. >>> d=dict(name='eva') #实例化
  4. >>> d.pop('name')  # 向d发一条消息，执行d的方法pop
  5. 'eva'

从上面的例子来看，字典就是一类数据结构，dict就是类，二d则是字典的一个对象，pop则是类中的特征、技能、行为。

在python中，用变量表示特征，用函数表示技能，因而具有相同特征和技能的一类事物就是‘类’，对象是则是这一类事物中具体的一个。

2.2 类的定义

定义一个类，格式如下：

  1. class 类名:
  2.     方法列表

定义一个People类：

  1. 1 # 经典类   python2中才有的
  2.  2 # class People:
  3.  3 #     pass
  4.  4 
  5.  5 
  6.  6 # 新式类   python3中默认都是新式类
  7.  7 class People(object):
  8.  8         
  9.  9     def walk(self):
  10. 10         print("walk....")

说明：

  • 定义类的形式有两种，新式类和经典类，python3中默认都是新式类，python2中有新式类和经典类两种
  • object类是python中所有类的最顶级父类
  • 类名的命名方式按照”大驼峰命名法”
  • walk 是一个实例方法，第一个参数一般是self，表示实例对象本身，当然了可以将self换为其它的名字，其作用是一个变量 这个变量指向了实例对象

2.2.1 对象的创建

python中，可以根据已经定义的类去创建出一个或多个对象。

创建对象的格式为:

  1. 对象名1 = 类名()
  2. 对象名2 = 类名()
  3. 对象名3 = 类名()
  5. 1 class Hero(object):  # 新式类定义形式
  6.  2     """info 是一个实例方法，类对象可以调用实例方法，实例方法的第一个参数一定是self"""
  7.  3     def info(self):
  8.  4         """当对象调用实例方法时，Python会自动将对象本身的引用做为参数，
  9.  5             传递到实例方法的第一个参数self里"""
  10.  6         print(self)
  11.  7         print("self各不同，对象是出处。")
  12.  8 
  13.  9 
  14. 10 # Hero这个类 实例化了一个对象  taidamier(泰达米尔)
  15. 11 h = Hero()
  16. 12 
  17. 13 # 对象调用实例方法info()，执行info()里的代码
  18. 14 # . 表示选择属性或者方法
  19. 15 h.info()
  20. 16 
  21. 17 print(h)  # 打印对象，则默认打印对象在内存的地址，结果等同于info里的print(self)
  22. 18 print(id(h))  # id(h) 则是内存地址的十进制形式表示

2.2.2 __init__实例方法

实例化：类名加括号就是实例化(创建对象)，会自动触发__init__函数的运行，可以用它来为每个实例定制自己的特征

  1. 1 class Hero(object):
  2.  2     """定义了一个英雄类，可以移动和攻击"""
  3.  3     # Python 的类里提供的，两个下划线开始，两个下划线结束的方法，就是魔法方法，__init__()就是一个魔法方法，通常用来做属性初始化 或 赋值 操作。
  4.  4     # 如果类面没有写__init__方法，Python会自动创建，但是不执行任何操作，
  5.  5     # 如果为了能够在完成自己想要的功能，可以自己定义__init__方法，
  6.  6     # 所以一个类里无论自己是否编写__init__方法 一定有__init__方法。
  7.  7 
  8.  8     def __init__(self):
  9.  9         """ 方法，用来做变量初始化 或 赋值 操作，在类实例化对象的时候，会被自动调用"""
  10. 10         self.name = "aa"  # 姓名
  11. 11         self.hp = 2600  # 生命值
  12. 12         self.atk = 450  # 攻击力
  13. 13         self.armor = 200  # 护甲值
  14. 14 
  15. 15     def move(self):
  16. 16         """实例方法"""
  17. 17         print("正在前往事发地点...")
  18. 18 
  19. 19     def attack(self):
  20. 20         """实例方法"""
  21. 21         print("发出了一招强力的普通攻击...")
  22. 22 
  23. 23 
  24. 24 hero = Hero()
  25. 25 print(hero.name)
  26. 26 hero.move()

说明：

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

带参数的__init__方法：

  1. 1 class Person(object):
  2.  2 
  3.  3     def __init__(self, name, age):
  4.  4         self.name = name　　# 实例属性
  5.  5         self.age = age
  6.  6 
  7.  7     def play(self):
  8.  8         print("愉快的玩耍")
  9.  9 
  10. 10     def info(self):
  11. 11         print("姓名：", self.name)     # 在方法内使用self获取对象属性
  12. 12         print("年龄：", self.age)
  13. 13 
  14. 14 
  15. 15 # 实例化对象，参数传递到__init__方法里
  16. 16 p1 = Person("aa", 12)
  17. 17 p1.info()

说明：

  • 通过一个类，可以创建多个对象，就好比 通过一个模具创建多个实体一样
  • __init__(self)中，默认有1个参数名字为self，如果在创建对象时传递了2个实参，那么__init__(self)中出了self作为第一个形参外还需要2个形参，例如__init__(self,x,y)
  • 在类内部获取 属性 和 实例方法，通过self获取
  • 在类外部获取 属性 和 实例方法，通过对象名获取
  • 如果一个类有多个对象，每个对象的属性是各自保存的，都有各自独立的地址
  • 但是实例方法是所有对象共享的，只占用一份内存空间。类会通过self来判断是哪个对象调用了实例方法。

2.2.3 类的属性

  1. 1 class Person:   # 定义一个人类
  2.  2     role = 'person'  # 人的角色属性都是人
  3.  3 
  4.  4     def walk(self):  #人都可以走路，也就是有一个走路方法
  5.  5         print("person is walking...")
  6.  6 
  7.  7 
  8.  8 print(Person.role)  # 查看人的role属性
  9.  9 print(Person.walk)  # 引用人的走路方法，注意，这里不是在调用
  10. 10 
  11. 11 p = Person()
  12. 12 p.role = "aa"
  13. 13 print(p.role)   # 实例属性会屏蔽掉同名的类属性  aa
  14. 14 print(Person.role)   # person

如果需要在类外修改类属性，必须通过类对象去引用然后进行修改。如果通过实例对象去引用，会产生一个同名的实例属性，这种方式修改的是实例属性，不会影响到类属性，并且之后如果通过实例对象去引用该名称的属性，实例属性会强制屏蔽掉类属性，即引用的是实例属性，除非删除了该实例属性。

2.2.4 类属性的补充

  1. 一：我们定义的类的属性到底存到哪里了？有两种方式查看
  4. dir(类名)：查出的是一个名字列表
  5. 类名.__dict__:查出的是一个字典，key为属性名，value为属性值
  7. 二：特殊的类属性
  8. 类名.__name__# 类的名字(字符串)
  9. 类名.__doc__# 类的文档字符串
  10. 类名.__bases__# 类所有父类构成的元组(在讲继承时会讲)
  11. 类名.__dict__# 类的字典属性
  12. 类名.__module__# 类定义所在的模块
  13. 类名.__class__# 实例对应的类(仅新式类中)

2.2.5 对象之间的交互

  1. 1 # egon大战哈士奇
  2.  2 class Person:  # 定义一个人类
  3.  3     role = 'person'  # 人的角色属性都是人
  4.  4 
  5.  5     def __init__(self, name, aggressivity, life_value):
  6.  6         self.name = name  # 每一个角色都有自己的昵称;
  7.  7         self.aggressivity = aggressivity  # 每一个角色都有自己的攻击力;
  8.  8         self.life_value = life_value  # 每一个角色都有自己的生命值;
  9.  9 
  10. 10     def attack(self,dog):
  11. 11         # 人可以攻击狗，这里的狗也是一个对象。
  12. 12         # 人攻击狗，那么狗的生命值就会根据人的攻击力而下降
  13. 13         dog.life_value -= self.aggressivity
  14. 14 
  15. 15 
  16. 16 class Dog:  # 定义一个狗类
  17. 17     role = 'dog'  # 狗的角色属性都是狗
  18. 18 
  19. 19     def __init__(self, name, breed, aggressivity, life_value):
  20. 20         self.name = name  # 每一只狗都有自己的昵称;
  21. 21         self.breed = breed  # 每一只狗都有自己的品种;
  22. 22         self.aggressivity = aggressivity  # 每一只狗都有自己的攻击力;
  23. 23         self.life_value = life_value  # 每一只狗都有自己的生命值;
  24. 24 
  25. 25     def bite(self,people):
  26. 26         # 狗可以咬人，这里的狗也是一个对象。
  27. 27         # 狗咬人，那么人的生命值就会根据狗的攻击力而下降
  28. 28         people.life_value -= self.aggressivity
  29. 29 
  30. 30 
  31. 31 egg = Person('egon',10,1000)  #创造了一个实实在在的人egg
  32. 32 ha2 = Dog('二愣子','哈士奇',10,1000)  #创造了一只实实在在的狗ha2
  33. 33 print(ha2.life_value)         #看看ha2的生命值
  34. 34 egg.attack(ha2)               #egg打了ha2一下
  35. 35 print(ha2.life_value)         #ha2掉了10点血
  37. 1 # 一个简单的例子帮你理解面向对象
  38.  2 from math import pi
  39.  3 
  40.  4 
  41.  5 class Circle:
  42.  6     '''
  43.  7     定义了一个圆形类；
  44.  8     提供计算面积(area)和周长(perimeter)的方法
  45.  9     '''
  46. 10     def __init__(self,radius):
  47. 11         self.radius = radius
  48. 12 
  49. 13     def area(self):
  50. 14         return pi * self.radius * self.radius
  51. 15 
  52. 16     def perimeter(self):
  53. 17         return 2 * pi *self.radius
  54. 18 
  55. 19 
  56. 20 circle = Circle(10)  # 实例化一个圆
  57. 21 area1 = circle.area()  # 计算圆面积
  58. 22 per1 = circle.perimeter()  # 计算圆周长
  59. 23 print(area1, per1)  # 打印圆面积和周长

2.3 类命名空间与对象、实例的命名空间

创建一个类就会创建一个类的名称空间，用来存储类中定义的所有名字，这些名字称为类的属性

而类有两种属性：静态属性和动态属性

  • 静态属性就是直接在类中定义的变量

  • 动态属性就是定义在类中的方法

    1 class Person(object):
    2
    3 role = “person”
    4
    5 def init(self):
    6 pass
    7
    8 def walk(self):
    9 pass
    10
    11
    12 p1 = Person()
    13 p2 = Person()
    14
    15 print(id(Person.role))
    16 print(id(p1.role))
    17 print(id(p2.role))
    18
    19 print(Person.walk)
    20 print(p1.walk)
    21 print(p2.walk)
    22
    23 # 运行结果：
    24 # 2427822463496
    25 # 2427822463496
    26 # 2427822463496
    27 #
    28 # >
    29 # >

说明：

  • 类的数据数据是共享给所有对象使用的
  • 类的动态属性是绑定到所有对象的
  • 创建一个对象/实例就会创建一个对象/实例的名称空间，存放对象/实例的名字，称为对象/实例的属性
  • 如：obj.name会先从obj自己的名称空间里找name，找不到则去类中找，类也找不到就找父类…最后都找不到就抛出异常

2.4 面向对象的组合用法

软件重用的重要方式除了继承之外还有另外一种方式，即：组合

组合指的是，在一个类中以另外一个类的对象作为数据属性，称为类的组合

  1. 1 """
  2.  2 圆环是由两个圆组成的，圆环的面积是外面圆的面积减去内部圆的面积。圆环的周长是内部圆的周长加上外部圆的周长。
  3.  3 这个时候，我们就首先实现一个圆形类，计算一个圆的周长和面积。然后在"环形类"中组合圆形的实例作为自己的属性来用
  4.  4 """
  5.  5 
  6.  6 from math import pi
  7.  7 
  8.  8 
  9.  9 class Circle:
  10. 10     '''
  11. 11     定义了一个圆形类；
  12. 12     提供计算面积(area)和周长(perimeter)的方法
  13. 13     '''
  14. 14     def __init__(self,radius):
  15. 15         self.radius = radius
  16. 16 
  17. 17     def area(self):
  18. 18         return pi * self.radius * self.radius
  19. 19 
  20. 20     def perimeter(self):
  21. 21         return 2 * pi *self.radius
  22. 22 
  23. 23 
  24. 24 circle = Circle(10)  # 实例化一个圆
  25. 25 area1 = circle.area()  # 计算圆面积
  26. 26 per1 = circle.perimeter()  # 计算圆周长
  27. 27 print(area1, per1)  # 打印圆面积和周长
  28. 28 
  29. 29 
  30. 30 class Ring:
  31. 31     '''
  32. 32     定义了一个圆环类
  33. 33     提供圆环的面积和周长的方法
  34. 34     '''
  35. 35     def __init__(self,radius_outside,radius_inside):
  36. 36         self.outsid_circle = Circle(radius_outside)
  37. 37         self.inside_circle = Circle(radius_inside)
  38. 38 
  39. 39     def area(self):
  40. 40         return self.outsid_circle.area() - self.inside_circle.area()
  41. 41 
  42. 42     def perimeter(self):
  43. 43         return self.outsid_circle.perimeter() + self.inside_circle.perimeter()
  44. 44 
  45. 45 
  46. 46 ring = Ring(10, 5)  # 实例化一个环形
  47. 47 print(ring.perimeter())  # 计算环形的周长
  48. 48 print(ring.area())  # 计算环形的面积

用组合的方式建立了类与组合的类之间的关系，它是一种‘有’的关系,比如教授有生日，教授教python课程

  1. 1 class BirthDate:
  2.  2     def __init__(self,year,month,day):
  3.  3         self.year=year
  4.  4         self.month=month
  5.  5         self.day=day
  6.  6 
  7.  7 
  8.  8 class Couse:
  9.  9     def __init__(self,name,price,period):
  10. 10         self.name=name
  11. 11         self.price=price
  12. 12         self.period=period
  13. 13 
  14. 14 
  15. 15 class Teacher:
  16. 16     def __init__(self,name,gender,birth,course):
  17. 17         self.name=name
  18. 18         self.gender=gender
  19. 19         self.birth=birth
  20. 20         self.course=course
  21. 21     
  22. 22 def teach(self):
  23. 23         print('teaching')
  24. 24 
  25. 25 
  26. 26 p1=Teacher('egon','male',
  27. 27             BirthDate('1995','1','27'),
  28. 28             Couse('python','28000','4 months')
  29. 29            )
  30. 30 
  31. 31 
  32. 32 print(p1.birth.year,p1.birth.month,p1.birth.day)
  33. 33 
  34. 34 
  35. 35 print(p1.course.name,p1.course.price,p1.course.period)
  36. 36 '''
  37. 37 运行结果:
  38. 38 27
  39. 39 python 28000 4 months
  40. 40 '''

当类之间有显著不同，并且较小的类是较大的类所需要的组件时，用组合比较好.

三、面向对象的三大特性

3.1 继承

继承是一种创建新类的方式，在python中，新建的类可以继承一个或多个父类，父类又可称为基类或超类，新建的类称为派生类或子类。

Python的继承分为单继承和多继承：

  1. class ParentClass1(object): # 定义父类
  2.     pass
  5. class ParentClass2(object): # 定义父类
  6.     pass
  9. class SubClass1(ParentClass1): # 单继承，基类是ParentClass1，派生类是SubClass
  10.     pass
  13. class SubClass2(ParentClass1,ParentClass2): # python支持多继承，用逗号分隔开多个继承的类
  14.     pass

查看继承：

  1. >>> SubClass1.__bases__ # __bases__则是查看所有继承的父类
  2. (<class '__main__.ParentClass1'>,)
  3. >>> SubClass2.__bases__
  4. (<class '__main__.ParentClass1'>, <class '__main__.ParentClass2'>)

ps：如果没有指定基类，python的类会默认继承object类，object是所有python类的基类，它提供了一些常见方法（如__str__）的实现。

  1. >>> ParentClass1.__bases__
  2. (<class 'object'>,)
  3. >>> ParentClass2.__bases__
  4. (<class 'object'>,)

3.1.1 单继承

  1. 1 # 定义一个Master类
  2.  2 class Master(object):
  3.  3     def __init__(self):
  4.  4         # 属性
  5.  5         self.kongfu = "古法煎饼果子配方"
  6.  6 
  7.  7     # 实例方法
  8.  8     def make_cake(self):
  9.  9         print("按照 <%s> 制作了一份煎饼果子..." % self.kongfu)
  10. 10 
  11. 11 
  12. 12 # 定义Prentice类，继承了 Master，则Prentice是子类，Master是父类。
  13. 13 class Prentice(Master):
  14. 14     # 子类可以继承父类所有的属性和方法，哪怕子类没有自己的属性和方法，也可以使用父类的属性和方法。
  15. 15     pass
  16. 16 
  17. 17 # laoli = Master()
  18. 18 # print(laoli.kongfu)
  19. 19 # laoli.make_cake()
  20. 20 
  21. 21 
  22. 22 damao = Prentice()   # 创建子类实例对象
  23. 23 print(damao.kongfu)  # 子类对象可以直接使用父类的属性
  24. 24 damao.make_cake()    # 子类对象可以直接使用父类的方法

注：虽然子类没有定义__init__方法初始化属性，也没有定义实例方法，但是父类有。所以只要创建子类的对象，就默认执行了那个继承过来的__init__方法

3.1.2 多继承

  1. 1 class Master(object):
  2.  2     def __init__(self):
  3.  3         self.kongfu = "古法煎饼果子配方"  # 实例变量，属性
  4.  4 
  5.  5     def make_cake(self):                    # 实例方法，方法
  6.  6         print("[古法] 按照 <%s> 制作了一份煎饼果子..." % self.kongfu)
  7.  7 
  8.  8     def dayandai(self):
  9.  9         print("师傅的大烟袋..")
  10. 10 
  11. 11 
  12. 12 class School(object):
  13. 13     def __init__(self):
  14. 14         self.kongfu = "现代煎饼果子配方"
  15. 15 
  16. 16     def make_cake(self):
  17. 17         print("[现代] 按照 <%s> 制作了一份煎饼果子..." % self.kongfu)
  18. 18 
  19. 19     def xiaoyandai(self):
  20. 20         print("学校的小烟袋..")
  21. 21 
  22. 22 
  23. 23 # class Prentice(School, Master):  # 多继承，继承了多个父类（School在前）
  24. 24 #     pass
  25. 25 
  26. 26 # damao = Prentice()
  27. 27 # print(damao.kongfu)
  28. 28 # damao.make_cake()
  29. 29 # damao.dayandai()
  30. 30 # damao.xiaoyandai()
  31. 31 
  32. 32 
  33. 33 class Prentice(Master, School):  # 多继承，继承了多个父类（Master在前）
  34. 34     pass
  35. 35 
  36. 36 
  37. 37 damao = Prentice()
  38. 38 print(damao.kongfu)  # 执行Master的属性
  39. 39 damao.make_cake()  # 执行Master的实例方法
  40. 40 
  41. 41 # 子类的魔法属性__mro__决定了属性和方法的查找顺序
  42. 42 print(Prentice.__mro__)
  43. 43 
  44. 44 damao.dayandai()  # 不重名不受影响
  45. 45 damao.xiaoyandai()

说明：

  • 多继承可以继承多个父类，也继承了所有父类的属性和方法
  • 注意：如果多个父类中有同名的 属性和方法，则默认使用第一个父类的属性和方法（根据类的魔法属性mro的顺序来查找）
  • 多个父类中，不重名的属性和方法，不会有任何影响。

Python2中多继承中的问题：

1077055-20190917153405662-735087184.png

  1. class A(object):
  2.     def test(self):
  3.         print('from A')
  6. class B(A):
  7.     def test(self):
  8.         print('from B')
  11. class C(A):
  12.     def test(self):
  13.         print('from C')
  16. class D(B):
  17.     def test(self):
  18.         print('from D')
  21. class E(C):
  22.     def test(self):
  23.         print('from E')
  26. class F(D,E):
  27.     # def test(self):
  28.     #     print('from F')
  29.     pass
  30. f1=F()
  31. f1.test()
  32. print(F.__mro__) #只有新式才有这个属性可以查看线性列表，经典类没有这个属性
  35. #新式类继承顺序:F->D->B->E->C->A
  36. #经典类继承顺序:F->D->B->A->E->C
  37. #python3中统一都是新式类
  38. #pyhon2中才分新式类与经典类

Python的继承原理：对于你定义的每一个类，python会计算出一个方法解析顺序(MRO)列表，这个MRO列表就是一个简单的所有基类的线性顺序列表。

3.1.3 派生

3.1.3.1子类重写父类的同名属性和方法
  1. 1 class Master(object):
  2.  2     
  3.  3     def __init__(self):
  4.  4         self.kongfu = "古法煎饼果子配方" 
  5.  5 
  6.  6     def make_cake(self): 
  7.  7         print("[古法] 按照 <%s> 制作了一份煎饼果子..." % self.kongfu)
  8.  8 
  9.  9 
  10. 10 class School(object):
  11. 11     def __init__(self): 12 self.kongfu = "现代煎饼果子配方" 13 14 def make_cake(self): 15 print("[现代] 按照 <%s> 制作了一份煎饼果子..." % self.kongfu) 16 17 18 class Prentice(School, Master): # 多继承，继承了多个父类 19 20 def __init__(self): 21 self.kongfu = "猫氏煎饼果子配方" 22 23 def make_cake(self): 24 print("[猫氏] 按照 <%s> 制作了一份煎饼果子..." % self.kongfu) 25 26 27 # 如果子类和父类的方法名和属性名相同，则默认使用子类的 28 # 叫 子类重写父类的同名方法和属性 29 damao = Prentice() 30 print(damao.kongfu) # 子类和父类有同名属性，则默认使用子类的 31 damao.make_cake() # 子类和父类有同名方法，则默认使用子类的 32 33 # 子类的魔法属性__mro__决定了属性和方法的查找顺序 34 print(Prentice.__mro__)
3.1.3.2 子类调用父类的同名方法和属性
  1. 1 class Master(object):
  2.  2     def __init__(self):
  3.  3         self.kongfu = "古法煎饼果子配方"  # 实例变量，属性
  4.  4 
  5.  5     def make_cake(self):                    # 实例方法，方法
  6.  6         print("[古法] 按照 <%s> 制作了一份煎饼果子..." % self.kongfu)
  7.  7 
  8.  8 
  9.  9 class School(object):
  10. 10     def __init__(self):
  11. 11         self.kongfu = "现代煎饼果子配方"
  12. 12 
  13. 13     def make_cake(self):
  14. 14         print("[现代] 按照 <%s> 制作了一份煎饼果子..." % self.kongfu)
  15. 15 
  16. 16 
  17. 17 class Prentice(School, Master):  # 多继承，继承了多个父类
  18. 18 
  19. 19     def __init__(self):
  20. 20         self.kongfu = "猫氏煎饼果子配方"
  21. 21 
  22. 22     def make_cake(self):
  23. 23         print("执行子类的__init__方法前，self.kongfu属性：%s" % self.kongfu)
  24. 24         self.__init__() # 执行本类的__init__方法，做属性初始化 self.kongfu = "猫氏...."
  25. 25         print("执行子类的__init__方法前，self.kongfu属性：%s" % self.kongfu)
  26. 26         print("[猫氏] 按照 <%s> 制作了一份煎饼果子..." % self.kongfu)
  27. 27 
  28. 28     # 调用父类方法格式：父类类名.父类方法(self)
  29. 29     def make_old_cake(self):
  30. 30         # 不推荐这样访问父类的实例属性，相当于创建了一个新的父类对象
  31. 31         # print("直接调用Master类的kongfu属性：%s" % Master().kongfu)
  32. 32 
  33. 33         # 可以通过执行Master类的__init__方法，来修改self的属性值
  34. 34         print("执行Master类的__init__方法前，self.kongfu属性：%s" % self.kongfu)
  35. 35         Master.__init__(self) # 调用了父类Master的__init__方法 self.kongfu = "古法...."
  36. 36         print("执行Master类的__init__方法后，self.kongfu属性：%s" % self.kongfu)
  37. 37         Master.make_cake(self) # 调用父类Master的实例方法
  38. 38 
  39. 39     def make_new_cake(self):
  40. 40         # 不推荐这样访问类的实例属性，相当于创建了一个新的父类对象
  41. 41         # print("直接调用School类的kongfu属性：%s" % School().kongfu)
  42. 42 
  43. 43         # 可以通过执行School类的__init__方法，来修改self的属性值
  44. 44         print("执行School类的__init__方法前，self.kongfu属性：%s" % self.kongfu)
  45. 45         School.__init__(self)  # 调用了父类School的__init__方法 self.kongfu = "现代...."
  46. 46         print("执行School类的__init__方法后，self.kongfu属性：%s" % self.kongfu)
  47. 47         School.make_cake(self)  # 调用父类School的实例方法
  48. 48 
  49. 49 
  50. 50 # 实例化对象，自动执行子类的__init__方法
  51. 51 damao = Prentice()
  52. 52 
  53. 53 damao.make_cake() # 调用子类的方法（默认重写了父类的同名方法）
  54. 54 
  55. 55 print("--" * 10)
  56. 56 damao.make_old_cake() # 进入实例方法去调用父类Master的方法
  57. 57 
  58. 58 print("--" * 10)
  59. 59 damao.make_new_cake() # 进入实例方法去调用父类School的方法
  60. 60 
  61. 61 print("--" * 10)
  62. 62 damao.make_cake()  # 调用本类的实例方法
3.1.3.3 多层继承
  1. 1 class Master(object):
  2.  2     def __init__(self):
  3.  3         self.kongfu = "古法煎饼果子配方"  
  4.  4 
  5.  5     def make_cake(self):
  6.  6         print("[古法] 按照 <%s> 制作了一份煎饼果子..." % self.kongfu)
  7.  7 
  8.  8 
  9.  9 class School(object):
  10. 10     def __init__(self):
  11. 11         self.kongfu = "现代煎饼果子配方"
  12. 12 
  13. 13     def make_cake(self):
  14. 14         print("[现代] 按照 <%s> 制作了一份煎饼果子..." % self.kongfu)
  15. 15 
  16. 16 
  17. 17 class Prentice(School, Master):  # 多继承，继承了多个父类
  18. 18     
  19. 19     def __init__(self):
  20. 20         self.kongfu = "猫氏煎饼果子配方"
  21. 21         self.money = 10000  # 亿美金
  22. 22 
  23. 23     def make_cake(self):
  24. 24         self.__init__()  # 执行本类的__init__方法，做属性初始化 self.kongfu = "猫氏...."
  25. 25         print("[猫氏] 按照 <%s> 制作了一份煎饼果子..." % self.kongfu)
  26. 26 
  27. 27     # 调用父类方法格式：父类类名.父类方法(self)
  28. 28     def make_old_cake(self):
  29. 29         Master.__init__(self)  # 调用了父类Master的__init__方法 self.kongfu = "古法...."
  30. 30         Master.make_cake(self)  # 调用了父类Master的实例方法
  31. 31 
  32. 32     def make_new_cake(self):
  33. 33         School.__init__(self)  # 调用了父类School的__init__方法 self.kongfu = "现代...."
  34. 34         School.make_cake(self)  # 调用父类School的实例方法，
  35. 35 
  36. 36 
  37. 37 class PrenticePrentice(Prentice): # 多层继承
  38. 38     pass
  39. 39 
  40. 40 
  41. 41 pp = PrenticePrentice()
  42. 42 pp.make_cake()  # 调用父类的实例方法
  43. 43 pp.make_new_cake() 
  44. 44 pp.make_old_cake()
  45. 45 
  46. 46 print(pp.money)
3.1.3.4 super的使用
  1. 1 class Master(object):
  2.  2     def __init__(self):
  3.  3         self.kongfu = "古法煎饼果子配方"  # 实例变量，属性
  4.  4 
  5.  5     def make_cake(self):  # 实例方法，方法
  6.  6         print("[古法] 按照 <%s> 制作了一份煎饼果子..." % self.kongfu)
  7.  7 
  8.  8 
  9.  9 # 父类是 Master类
  10. 10 class School(Master):
  11. 11     
  12. 12     def __init__(self):
  13. 13         self.kongfu = "现代煎饼果子配方"
  14. 14 
  15. 15     def make_cake(self):
  16. 16         print("[现代] 按照 <%s> 制作了一份煎饼果子..." % self.kongfu)
  17. 17         super().__init__()  # 执行父类的构造方法
  18. 18         super().make_cake()  # 执行父类的实例方法
  19. 19 
  20. 20 
  21. 21 # 父类是 School 和 Master
  22. 22 class Prentice(School, Master):  # 多继承，继承了多个父类
  23. 23     
  24. 24     def __init__(self):
  25. 25         self.kongfu = "猫氏煎饼果子配方"
  26. 26 
  27. 27     def make_cake(self):
  28. 28         self.__init__()  # 执行本类的__init__方法，做属性初始化 self.kongfu = "猫氏...."
  29. 29         print("[猫氏] 按照 <%s> 制作了一份煎饼果子..." % self.kongfu)
  30. 30 
  31. 31     def make_all_cake(self):
  32. 32         # 方式1. 指定执行父类的方法（代码臃肿）
  33. 33         # School.__init__(self)
  34. 34         # School.make_cake(self)
  35. 35         #
  36. 36         # Master.__init__(self)
  37. 37         # Master.make_cake(self)
  38. 38         #
  39. 39         # self.__init__()
  40. 40         # self.make_cake()
  41. 41 
  42. 42         # 方法2. super() 带参数版本，只支持新式类
  43. 43         # super(Prentice, self).__init__() # 执行父类的 __init__方法 
  44. 44         # super(Prentice, self).make_cake()
  45. 45         # self.make_cake()
  46. 46 
  47. 47         # 方法3. super()的简化版，只支持新式类
  48. 48         super().__init__()  # 执行父类的 __init__方法 
  49. 49         super().make_cake()  # 执行父类的 实例方法
  50. 50         self.make_cake()  # 执行本类的实例方法
  51. 51 
  52. 52 
  53. 53 damao = Prentice()
  54. 54 damao.make_cake()
  55. 55 damao.make_all_cake()
  56. 56 
  57. 57 # print(Prentice.__mro__)

注意：如果继承了多个父类，且父类都有同名方法，则默认只执行第一个父类的(同名方法只执行一次，目前super()不支持执行多个父类的同名方法)，super时python2.3版本以上才出现的。

3.1.4 抽象类

什么是抽象类

与java一样，python也有抽象类的概念但是同样需要借助模块实现，抽象类是一个特殊的类，它的特殊之处在于只能被继承，不能被实例化

为什么要有抽象类

如果说类是从一堆对象中抽取相同的内容而来的，那么抽象类就是从一堆类中抽取相同的内容而来的，内容包括数据属性和函数属性。

从设计角度去看，如果类是从现实对象抽象而来的，那么抽象类就是基于类抽象而来的。

从实现角度来看，抽象类与普通类的不同之处在于：抽象类中有抽象方法，该类不能被实例化，只能被继承，且子类必须实现抽象方法。

代码实现：

  1. 1 # 一切皆文件
  2.  2 import abc  # 利用abc模块实现抽象类
  3.  3 
  4.  4 
  5.  5 class All_file(metaclass=abc.ABCMeta):
  6.  6     all_type = 'file'
  7.  7 
  8.  8     @abc.abstractmethod  # 定义抽象方法，无需实现功能
  9.  9     def read(self):
  10. 10         '子类必须定义读功能'
  11. 11         pass
  12. 12 
  13. 13     @abc.abstractmethod # 定义抽象方法，无需实现功能
  14. 14     def write(self):
  15. 15         '子类必须定义写功能'
  16. 16         pass
  17. 17 
  18. 18 
  19. 19 # class Txt(All_file):
  20. 20 #     pass
  21. 21 #
  22. 22 # t1=Txt() # 报错,子类没有定义抽象方法
  23. 23 
  24. 24 
  25. 25 class Txt(All_file): # 子类继承抽象类，但是必须定义read和write方法
  26. 26     def read(self):
  27. 27         print('文本数据的读取方法')
  28. 28 
  29. 29     def write(self):
  30. 30         print('文本数据的读取方法')
  31. 31 
  32. 32 
  33. 33 class Sata(All_file):  # 子类继承抽象类，但是必须定义read和write方法
  34. 34     def read(self):
  35. 35         print('硬盘数据的读取方法')
  36. 36 
  37. 37     def write(self):
  38. 38         print('硬盘数据的读取方法')
  39. 39 
  40. 40 
  41. 41 class Process(All_file): # 子类继承抽象类，但是必须定义read和write方法
  42. 42     def read(self):
  43. 43         print('进程数据的读取方法')
  44. 44 
  45. 45     def write(self):
  46. 46         print('进程数据的读取方法')
  47. 47 
  48. 48 
  49. 49 wenbenwenjian=Txt()
  50. 50 
  51. 51 
  52. 52 yingpanwenjian=Sata()
  53. 53 
  54. 54 
  55. 55 jinchengwenjian=Process()
  56. 56 
  57. 57 
  58. 58 # 这样大家都是被归一化了,也就是一切皆文件的思想
  59. 59 wenbenwenjian.read()
  60. 60 yingpanwenjian.write()
  61. 61 jinchengwenjian.read()
  62. 62 
  63. 63 
  64. 64 print(wenbenwenjian.all_type)
  65. 65 print(yingpanwenjian.all_type)
  66. 66 print(jinchengwenjian.all_type)

3.2 封装

封装的意义：

  • 将属性和方法放到一起做为一个整体，然后通过实例化对象来处理；
  • 隐藏内部实现细节，只需要和对象及其属性和方法交互就可以了；
  • 对类的属性和方法增加 访问权限控制。

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

  • 类的私有属性 和 私有方法，都不能通过对象直接访问，但是可以在本类内部访问；
  • 类的私有属性 和 私有方法，都不会被子类继承，子类也无法访问；
  • 私有属性 和 私有方法 往往用来处理类的内部事情，不通过对象处理，起到安全作用。

3.2.1 私有变量

  1. 1 # 其实这仅仅这是一种变形操作
  2.  2 # 类中所有双下划线开头的名称如__x都会自动变形成：_类名__x的形式：
  3.  3 
  4.  4 
  5.  5 class A:
  6.  6     __N=0  # 类的数据属性就应该是共享的,但是语法上是可以把类的数据属性设置成私有的如__N,会变形为_A__N
  7.  7     def __init__(self):
  8.  8         self.__X=10     # 变形为self._A__X
  9.  9 
  10. 10     def __foo(self):     # 变形为_A__foo
  11. 11         print('from A')
  12. 12 
  13. 13     def bar(self):
  14. 14         self.__foo()     # 只有在类内部才可以通过__foo的形式访问到.
  15. 15 
  16. 16 
  17. 17 # A._A__N是可以访问到的，即这种操作并不是严格意义上的限制外部访问，仅仅只是一种语法意义上的变形

这种自动变形的特点：
1.类中定义的__x只能在内部使用，如self.__x，引用的就是变形的结果。
2.这种变形其实正是针对外部的变形，在外部是无法通过__x这个名字访问到的。
3.在子类定义的__x不会覆盖在父类定义的__x，因为子类中变形成了：_子类名__x,而父类中变形成了：_父类名__x，即双下滑线开头的属性在继承给子类时，子类是无法覆盖的。

这种变形需要注意的问题是：
1.这种机制也并没有真正意义上限制我们从外部直接访问属性，知道了类名和属性名就可以拼出名字：_类名__属性，然后就可以访问了，如a._A__N
2.变形的过程只在类的内部生效,在定义后的赋值操作，不会变形。

1077055-20190917160458490-580916241.png

3.2.2 私有方法

  1. 1 class Master(object):
  2.  2     def __init__(self):
  3.  3         self.kongfu = "古法煎饼果子配方" 
  4.  4     def make_cake(self):          
  5.  5         print("[古法] 按照 <%s> 制作了一份煎饼果子..." % self.kongfu)
  6.  6 
  7.  7 class Prentice(School, Master):
  8.  8     def __init__(self):
  9.  9         self.kongfu = "猫氏煎饼果子配方"
  10. 10         # 私有属性，可以在类内部通过self调用，但不能通过对象访问
  11. 11         self.__money = 10000  
  12. 12 
  13. 13     # 私有方法，可以在类内部通过self调用，但不能通过对象访问
  14. 14     def __print_info(self):
  15. 15         print(self.kongfu)
  16. 16         print(self.__money)
  17. 17 
  18. 18     def make_cake(self):
  19. 19         self.__init__()
  20. 20         print("[猫氏] 按照 <%s> 制作了一份煎饼果子..." % self.kongfu)
  21. 21 
  22. 22     def make_old_cake(self):
  23. 23         Master.__init__(self) 
  24. 24         Master.make_cake(self)
  25. 25 
  26. 26 
  27. 27     def make_new_cake(self):
  28. 28         School.__init__(self) 
  29. 29         School.make_cake(self)
  30. 30 
  31. 31 class PrenticePrentice(Prentice):
  32. 32     pass
  33. 33 
  34. 34 
  35. 35 damao = Prentice()
  36. 36 # 对象不能访问私有权限的属性和方法
  37. 37 # print(damao.__money)
  38. 38 # damao.__print_info()
  39. 39 
  40. 40 
  41. 41 pp = PrenticePrentice()
  42. 42 # 子类不能继承父类私有权限的属性和方法
  43. 43 print(pp.__money) 
  44. 44 pp.__print_info()

3.2.3 封装与扩展性

封装在于明确区分内外，使得类实现者可以修改封装内的东西而不影响外部调用者的代码；而外部使用者只知道一个接口(函数)，只要接口（函数）名、参数不变，使用者的代码永远无需改变。这就提供一个良好的合作基础——或者说，只要接口这个基础约定不变，则代码改变不足为虑。

  1. 1 # 类的设计者
  2.  2 class Room:
  3.  3     def __init__(self,name,owner,width,length,high):
  4.  4         self.name=name
  5.  5         self.owner=owner
  6.  6         self.__width=width
  7.  7         self.__length=length
  8.  8         self.__high=high
  9.  9 
  10. 10     def tell_area(self): # 对外提供的接口，隐藏了内部的实现细节，此时我们想求的是面积
  11. 11         return self.__width * self.__length
  12. 12 
  13. 13 
  14. 14 #使用者
  15. 15 >>> r1=Room('卧室','egon',20,20,20)
  16. 16 >>> r1.tell_area() #使用者调用接口tell_area
  17. 17 
  18. 18 
  19. 19 
  20. 20 
  21. 21 #类的设计者，轻松的扩展了功能，而类的使用者完全不需要改变自己的代码
  22. 22 class Room:
  23. 23     def __init__(self,name,owner,width,length,high):
  24. 24         self.name=name
  25. 25         self.owner=owner
  26. 26         self.__width=width
  27. 27         self.__length=length
  28. 28         self.__high=high
  29. 29 
  30. 30     def tell_area(self): #对外提供的接口，隐藏内部实现，此时我们想求的是体积,内部逻辑变了,只需求修该下列一行就可以很简答的实现,而且外部调用感知不到,仍然使用该方法，但是功能已经变了
  31. 31         return self.__width * self.__length * self.__high
  32. 32 
  33. 33 
  34. 34 #对于仍然在使用tell_area接口的人来说，根本无需改动自己的代码，就可以用上新功能
  35. 35 >>> r1.tell_area()

3.2.4 property属性

property是一种特殊的属性，访问它时会执行一段功能（函数）然后返回值

  1. 1 class People:
  2.  2     def __init__(self,name,weight,height):
  3.  3         self.name=name
  4.  4         self.weight=weight
  5.  5         self.height=height
  6.  6 
  7.  7     @property
  8.  8     def bmi(self):
  9.  9         return self.weight / (self.height**2)
  10. 10 
  11. 11 p1=People('egon',75,1.85)
  12. 12 print(p1.bmi)
  14. 1 # 例二：圆的周长和面积
  15.  2 import math
  16.  3 
  17.  4 class Circle:
  18.  5     def __init__(self,radius): #圆的半径radius
  19.  6         self.radius=radius
  20.  7 
  21.  8     @property
  22.  9     def area(self):
  23. 10         return math.pi * self.radius**2 #计算面积
  24. 11 
  25. 12     @property
  26. 13     def perimeter(self):
  27. 14         return 2*math.pi*self.radius #计算周长
  28. 15 
  29. 16 c=Circle(10)
  30. 17 print(c.radius)
  31. 18 print(c.area) #可以向访问数据属性一样去访问area,会触发一个函数的执行,动态计算出一个值
  32. 19 print(c.perimeter) #同上
  33. 20 '''
  34. 21 输出结果:
  35. 22 314.1592653589793
  36. 23 62.83185307179586
  37. 24 '''

为什么要用property

将一个类的函数定义成特性以后，对象再去使用的时候obj.name,根本无法察觉自己的name是执行了一个函数然后计算出来的，这种特性的使用方式遵循了统一访问的原则。

一个静态属性property本质就是实现了get，set，delete三种方法：

  1. 1 class Foo:　　# 方式一
  2.  2     @property
  3.  3     def AAA(self):
  4.  4         print('get的时候运行我啊')
  5.  5 
  6.  6 
  7.  7     @AAA.setter
  8.  8     def AAA(self,value):
  9.  9         print('set的时候运行我啊')
  10. 10 
  11. 11 
  12. 12     @AAA.deleter
  13. 13     def AAA(self):
  14. 14         print('delete的时候运行我啊')
  15. 15 
  16. 16 
  17. 17 #只有在属性AAA定义property后才能定义AAA.setter,AAA.deleter
  18. 18 f1=Foo()
  19. 19 f1.AAA
  20. 20 f1.AAA='aaa'
  21. 21 del f1.AAA
  23. 1 # 方式二
  24.  2 class Foo:
  25.  3     def get_AAA(self):
  26.  4         print('get的时候运行我啊')
  27.  5 
  28.  6 
  29.  7     def set_AAA(self,value):
  30.  8         print('set的时候运行我啊')
  31.  9 
  32. 10 
  33. 11     def delete_AAA(self):
  34. 12         print('delete的时候运行我啊')
  35. 13     AAA=property(get_AAA,set_AAA,delete_AAA) #内置property三个参数与get,set,delete一一对应
  36. 14 
  37. 15 
  38. 16 f1=Foo()
  39. 17 f1.AAA
  40. 18 f1.AAA='aaa'
  41. 19 del f1.AAA
  43. 1 class Goods:
  44.  2 
  45.  3 
  46.  4     def __init__(self):
  47.  5         # 原价
  48.  6         self.original_price = 100
  49.  7         # 折扣
  50.  8         self.discount = 0.8
  51.  9 
  52. 10 
  53. 11     @property
  54. 12     def price(self):
  55. 13         # 实际价格 = 原价 * 折扣
  56. 14         new_price = self.original_price * self.discount
  57. 15         return new_price
  58. 16 
  59. 17 
  60. 18     @price.setter
  61. 19     def price(self, value):
  62. 20         self.original_price = value
  63. 21 
  64. 22 
  65. 23     @price.deleter
  66. 24     def price(self):
  67. 25         del self.original_price
  68. 26 
  69. 27 
  70. 28 
  71. 29 
  72. 30 obj = Goods()
  73. 31 obj.price         # 获取商品价格
  74. 32 obj.price = 200   # 修改商品原价
  75. 33 print(obj.price)
  76. 34 del obj.price     # 删除商品原价

3.2.5 classmethod

classmethod 类方法的装饰器 内置函数

使用类名调用，默认传类名作为第一个参数

不用对象命名空间中的内容，而用到了类命名空间中的变量(静态属性)，或者类方法和静态方法

  1. 1 class Classmethod_Demo():
  2.  2     role = 'dog'
  3.  3 
  4.  4 
  5.  5     @classmethod
  6.  6     def func(cls):
  7.  7         print(cls.role)
  8.  8 
  9.  9 
  10. 10 Classmethod_Demo.func()

3.2.6 staticmethod

staticmethod 静态方法的装饰器 内置函数

如果一个类里面的方法，既不需要用到self中的资源，也不用cls中的资源

相当于一个普通的函数

但是你由于某种原因，还要把这个方法放在类中，这个时候，就将这个方法变成静态方法

某种原因：

你完全想用面向对象编程，所有的函数都必须写到类里

某个功能确确实实是这个类的方法，但是没有用到和这个类有关系的资源

  1. 1 class Staticmethod_Demo():
  2.  2     role = 'dog'
  3.  3 
  4.  4 
  5.  5     @staticmethod
  6.  6     def func():
  7.  7         print("当普通方法用")
  8.  8 
  9.  9 
  10. 10 Staticmethod_Demo.func()

3.3 多态

在需要使用父类对象的地方,也可以使用子类对象, 这种情况就叫多态.

比如, 在函数中,我需要调用 某一个父类对象的方法, 那么我们也可以在这个地方调用子类对象的方法.

如何使用多态：

　　1.子类继承父类

　　2.子类重写父类中的方法

　　3.通过对象调用这个方法

  1. 1     # 定义父类
  2.  2     class Father:
  3.  3         def cure(self):
  4.  4             print("父亲给病人治病...")
  5.  5 
  6.  6 
  7.  7     # 定义子类继承父类
  8.  8     class Son(Father):
  9.  9         # 重写父类中的方法
  10. 10         def cure(self):
  11. 11             print("儿子给病人治病...")
  12. 12 
  13. 13 
  14. 14     # 定义函数,在里面 调用 医生的cure函数
  15. 15     def call_cure(doctor):
  16. 16 
  17. 17         # 调用医生治病的方法
  18. 18         doctor.cure()
  19. 19 
  20. 20 
  21. 21     # 创建父类对象
  22. 22     father = Father()
  23. 23     # 调用函数,把父类对象传递函数
  24. 24     call_cure(father)
  25. 25 
  26. 26 
  27. 27     # 创建子类对象
  28. 28     son = Son()
  29. 29     # 调用函数,把子类对象传递函数
  30. 30     call_cure(son)

1077055-20190917161925832-633823227.png

多态的好处：

给call_cure(doctor)函数传递哪个对象,在它里面就会调用哪个对象的cure()方法,也就是说在它里面既可以调用son对象的cure()方法,也能调用father对象的cure()方法,当然了也可以在它里面调用Father类其它子类对象的cure()方法,这样可以让call_cure(doctor)函数变得更加灵活,额外增加了它的功能,提高了它的扩展性.

鸭子类型

逗比时刻：

　　Python崇尚鸭子类型，即‘如果看起来像、叫声像而且走起路来像鸭子，那么它就是鸭子’

python程序员通常根据这种行为来编写程序。例如，如果想编写现有对象的自定义版本，可以继承该对象

也可以创建一个外观和行为像，但与它无任何关系的全新对象，后者通常用于保存程序组件的松耦合度。

四、面向对象的软件开发

面向对象的软件工程包括下面几个部：

1.面向对象分析（object oriented analysis ，OOA）

软件工程中的系统分析阶段，要求分析员和用户结合在一起，对用户的需求做出精确的分析和明确的表述，从大的方面解析软件系统应该做什么，而不是怎么去做。面向对象的分析要按照面向对象的概念和方法，在对任务的分析中，从客观存在的事物和事物之间的关系，归纳出有关的对象（对象的‘特征’和‘技能’）以及对象之间的联系，并将具有相同属性和行为的对象用一个类class来标识。

建立一个能反映这是工作情况的需求模型，此时的模型是粗略的。

2 面向对象设计（object oriented design，OOD）

根据面向对象分析阶段形成的需求模型，对每一部分分别进行具体的设计。

首先是类的设计，类的设计可能包含多个层次（利用继承与派生机制）。然后以这些类为基础提出程序设计的思路和方法，包括对算法的设计。

在设计阶段并不牵涉任何一门具体的计算机语言，而是用一种更通用的描述工具（如伪代码或流程图）来描述

3 面向对象编程（object oriented programming，OOP）

根据面向对象设计的结果，选择一种计算机语言把它写成程序，可以是python

4 面向对象测试（object oriented test，OOT）

在写好程序后交给用户使用前，必须对程序进行严格的测试，测试的目的是发现程序中的错误并修正它。

面向对的测试是用面向对象的方法进行测试，以类作为测试的基本单元。

5 面向对象维护（object oriendted soft maintenance，OOSM）

正如对任何产品都需要进行售后服务和维护一样，软件在使用时也会出现一些问题，或者软件商想改进软件的性能，这就需要修改程序。

由于使用了面向对象的方法开发程序，使用程序的维护比较容易。

因为对象的封装性，修改一个对象对其他的对象影响很小，利用面向对象的方法维护程序，大大提高了软件维护的效率，可扩展性高。

面向对象的常用术语

抽象/实现

抽象指对现实世界问题和实体的本质表现,行为和特征建模,建立一个相关的子集,可以用于 绘程序结构,从而实现这种模型。抽象不仅包括这种模型的数据属性,还定义了这些数据的接口。

对某种抽象的实现就是对此数据及与之相关接口的现实化(realization)。现实化这个过程对于客户 程序应当是透明而且无关的。

封装/接口

封装描述了对数据/信息进行隐藏的观念,它对数据属性提供接口和访问函数。通过任何客户端直接对数据的访问,无视接口,与封装性都是背道而驰的,除非程序员允许这些操作。作为实现的 一部分,客户端根本就不需要知道在封装之后,数据属性是如何组织的。在Python中,所有的类属性都是公开的,但名字可能被“混淆”了,以阻止未经授权的访问,但仅此而已,再没有其他预防措施了。这就需要在设计时,对数据提供相应的接口,以免客户程序通过不规范的操作来存取封装的数据属性。

注意：封装绝不是等于“把不想让别人看到、以后可能修改的东西用private隐藏起来”

真正的封装是，经过深入的思考，做出良好的抽象，给出“完整且最小”的接口，并使得内部细节可以对外透明

（注意：对外透明的意思是，外部调用者可以顺利的得到自己想要的任何功能，完全意识不到内部细节的存在）

合成

合成扩充了对类的描述,使得多个不同的类合成为一个大的类,来解决现实问题。合成 描述了 一个异常复杂的系统,比如一个类由其它类组成,更小的组件也可能是其它的类,数据属性及行为, 所有这些合在一起,彼此是“有一个”的关系。

派生/继承/继承结构

派生描述了子类衍生出新的特性,新类保留已存类类型中所有需要的数据和行为,但允许修改或者其它的自定义操作,都不会修改原类的定义。

继承描述了子类属性从祖先类继承这样一种方式

继承结构表示多“代”派生,可以述成一个“族谱”,连续的子类,与祖先类都有关系。

泛化/特化

基于继承

泛化表示所有子类与其父类及祖先类有一样的特点。

特化描述所有子类的自定义,也就是,什么属性让它与其祖先类不同。

多态与多态性

多态指的是同一种事物的多种状态：水这种事物有多种不同的状态：冰，水蒸气

多态性的概念指出了对象如何通过他们共同的属性和动作来操作及访问,而不需考虑他们具体的类。

冰，水蒸气，都继承于水，它们都有一个同名的方法就是变成云，但是冰.变云(),与水蒸气.变云()是截然不同的过程，虽然调用的方法都一样

自省/反射

自省也称作反射，这个性质展示了某对象是如何在运行期取得自身信息的。如果传一个对象给你,你可以查出它有什么能力,这是一项强大的特性。如果Python不支持某种形式的自省功能,dir和type内建函数,将很难正常工作。还有那些特殊属性,像__dict__,__name__及__doc__

转载于:https://www.cnblogs.com/fengyuhao/p/11505085.html

发表评论

表情：
评论列表 （有 0 条评论，165人围观）

还没有评论，来说两句吧...

相关阅读

    相关 python面向对象基础

    python面向对象基础 什么是面向对象编程？ 面向对象编程是一种程序设计的范式，它把程序当做不同对象的相互调用，是对现实世界建立的一种对象模型。 面向对象编程

    傷城~傷城~/ 0 赞/ 88 阅读

    相关 Python 面向对象基础

    一、面向对象概述 如今主流的软件开发思想有两种：一个是面向过程，另一个是面向对象。面向过程出现得较早，典型代表为C语言，开发中小型项目的效率很高，但是很难适用于如今主流的

    矫情吗；*矫情吗；*/ 0 赞/ 166 阅读

    相关 Python3面向对象基础

    Python是一种面向对象的脚本语言，所以它也提供了面向对象编程的所有基本特征：允许多继承的类继承机制、派生类可以重写它父类的任何方法、一个方法可以调用父类中同名的方法、对象可

    缺乏、安全感缺乏、安全感/ 0 赞/ 453 阅读