Python是一门面向对象(object oriented programming)的编程语言.

面向对象概述

OOP 思想

接触到任意一个任务，首先想到的是任务这个世界的构成，是由模型构成的。

OO相关的名词

  • OO: 面向对象
  • OOA: 面向对象的分析
  • OOD: 面向对象的设计
  • OOI: 面向对象的实现
  • OOP: 面向对象的编程
  • OOA->OOD->OOI: 面向对象的实现过程

类和对象的概念

  • 类: 抽象名词，代表一个名词，共性的事物
  • 对象：具体的事物，单个个体
  • 类跟对象的关系:
  • 一个具象，代表一类事物的某一个个体
  • 一个抽象，代表的是一大类事物

类中的内容，应该具有两个内容

  • 表明事物的特征，叫属性
  • 表明事物的动作或者功能，称为成员方法(函数)

类的基本实现

类的命名

  • 遵守变量命名的规则
  • 大驼峰（由一个或者多个单词构成，单词首字母大写，单词跟单词直接相连）
  • 尽量避开于系统命名相识的命名

如何声明一个类

  • 必须用class关键字
  • 类由属性和方法构成，其他不允许出现
  • 成员属性可以直接赋值，如果没有值，可以赋None
  • 案例 01.py
class Student():
  	 pass
  zhangsan = Student()
  class PythonStudent():
  #None赋值给值不确定的成员
  name = None
  age = 18
  course = "Python"

  	def doHomework(self):
  		print("开始做作业了")

  lisi = PythonStudent()
  print(lisi.name)
  print(lisi.age)
  print(lisi.course)
  lisi.doHomework()
  print(lisi.__dict__)
  print(PythonStudent.__dict__)

‘’’
#输出结果
None
18
Python
开始做作业了
{}
{‘module’: ‘main’, ‘name’: None, ‘age’: 18, ‘course’: ‘Python’, ‘doHomework’: <function PythonStudent.doHomework at 0x00999CD8>, ‘dict’: <attribute ‘dict’ of ‘PythonStudent’ objects>, ‘weakref’: <attribute ‘weakref’ of ‘PythonStudent’ objects>, ‘doc’: None}
‘’’

实例化类

  • 变量 = 类名() #实例化一个对象

访问对象成员

  • 使用点操作符
    obj.成员属性名称
    obj.成员方法
  • 可以通过默认内置变量检查类和对象的所有成员
  • 对象所有成员检查
  • dict前后各有两个下划线 obj.dict
  • 类所有成员检查
  • dict前后各有两个下划线 class_name.dict

类和对象的成员分析

  • 类和对象都可以存储成员，成员可以归类所有，也可以归对象所有
  • 类存储成员时使用的是与类关联的一个对象
  • 独享存储成员时是存储在当前对象中
  • 对象访问一个成员时，如果对象中没有该成员，尝试访问类中的同名成员，如果对象中有此成员，一定使用对象中的成员
  • 创建对象的时候，类中的成员不会放入对象当中，而是得到一个空对象，没有成员
  • 通过对象对类中成员重新赋值或通过对象添加成员时，对应成员会保存在对象中，而不会修改类成员
  • 案例: 01.py
class A():
  	name = "zhangsan"
  	age = "18"

  #A是类实例
  print(A.name)
  print(A.age)
  print(id(A.name))
  print(id(A.age))
  print("*" * 20)

  #对象实例
  a = A()
  print(A.__dict__)
  print(a.__dict__)
  print(a.name)
  print(a.age)
  print(id(a.name))
  print(id(a.age))
  print("*" * 20)

  a.name = "lisi"
  a.age = 20
  print(a.__dict__)
  print(a.name)
  print(a.age)
  print(id(a.name))
  print(id(a.age))

‘’’
#输出结果
zhangsan
18
13778760
13760960

{‘module’: ‘main’, ‘name’: ‘zhangsan’, ‘age’: ‘18’, ‘dict’: <attribute ‘dict’ of ‘A’ objects>, ‘weakref’: <attribute ‘weakref’ of ‘A’ objects>, ‘doc’: None}
{}
zhangsan
18
13778760
13760960

{‘name’: ‘lisi’, ‘age’: 20}
lisi
20
13637472
269706640
‘’’

关于self

  • self在对象的方法中表示当前对象本身，如果通过对象调用一个方法，那么该对象会自动传入该方法的第一个参数中.
  • self并不是关键字，只是一个用于接收对象的普通参数，理论上可以用任何一个普通变量名代替
  • 方法中有self 形参的方法成为非绑定类的方法，可以通过对象访问，没有self的是绑定类的方法，只能通过类访问
  • 使用类访问绑定类的方法时，如果类方法中需要访问当前类的成员，可以通过__class__.成员名来访问.
class A():
	name = "dana"
  	age = 18
  	def say(self):
  		self.name = "cainiao"
  		self.age = 20
  		print(self.name)
  		print(self.age)
  		#通过__class__来访问类中的变量
  		print(__class__.name)
  		print(__class__.age)

  	def sayA():
  		print("I am in sayA")
  		#通过__class__来访问类中的变量
  		print(__class__.name)
  		print(__class__.age)

  a = A()
  a.say()
  A.sayA()

‘’’
#输出结果
cainiao
20
dana
18
I am in sayA
dana
18
‘’’

class Teacher():
  	name = "dana"
  	age = 30

  	def __init__(self):
  		self.name = "cainiao"
  		self.age = 18

  	def say(self):
  		print(self.name)
  		print(self.age)

  class B():
  	name = "haizi"
  	age = 5

  a = Teacher()

  #此时，系统会默认把a作为第一个参数传入函数
  a.say()

  #此时,self被a替代
  Teacher.say(a)

  #同样可以把Teacher作为参数传入
  Teacher.say(Teacher)

  #此时，传入的是实例B，因为B具有name和age的属性，所以不会报错
  Teacher.say(B)

  #以上代码，利用了鸭子模型

‘’’
#输出结果
cainiao
18
cainiao
18
dana
30
haizi
5
‘’’

面向对象的三大特征

  • 封装
  • 继承
  • 多态

封装

  • 封装就是对对象的成员进行访问限制
  • 封装的三个级别
  • 公开 public
  • 受保护的 protected
  • 私有的 private
  • public, protected, private不是关键字
  • 判断对象的位置
  • 对象内部
  • 对象外部
  • 子类中
  • 私有
  • 私有成员是最高级别的封装，只能在当前类或对象中访问
  • 在成员前面添加两个下划线__即可
  • 受保护的 protected
  • 受保护的成员只能在当前类和子类中访问
  • 在成员前面添加一个下划线_即可
  • 公有的 public
  • 没有任何限制

继承

  • 继承为了减少重复代码，提高效率
  • 继承常用的名词:
  • 被继承的类称为父类，基类, 超类
  • 继承的类称为子类
  • super使用
  • super不是关键字，而是一个类
  • super的作用是获取MRO列表中的第一个类
  • super于父类没有直接任何实质性关系，但通过super可以调用到父类
  • super使用两个方法，常见在构造函数中调用父类构造函数
  • 单继承和多继承
  • 单继承: 每个类只能继承一个类
  • 多继承: 每个类可以继承多个类
  • 单继承和多继承优缺点
  • 单继承
  • 传承有序，逻辑清晰，语法简单，隐患少
  • 功能不能无限扩展，只能在当前唯一的继承链中扩展
  • 多继承
  • 优点: 类的功能扩展方便
  • 缺点: 继承关系混乱
  • 菱形继承/钻石继承问题
  • 多个子类继承自同一父类，这些子类又被同一个子类继承，于是继承关系图形成一个菱形图谱。
  • 关于多继承的MRO
  • MRO就是多继承中，用于保存继承顺序的一个列表
  • python本身采用C3算法来对多继承的菱形继承进行计算的结果
  • MRO列表的计算原则
  • 子类永远在父类面前
  • 如果有多个父类，则根据继承语法中括号内类的书写顺序存放
  • 如果多个子类继承同一父类，则孙子类根据括号填写顺序找到直接爷爷类
  • 构造函数
  • 构造函数在对象实例化的时候自动调用，一般做些初始化的工作
  • 如果函数没有构造函数，则按照MRO顺序，往上查找父类构造函数，直到找到为止。
  • 调用父类构造函数可以通过[父类名.init()]或者[super().__init()]调用
class A ():
    pass
class B ():
    def __init__(self, name):
        print("I am B init")
        print(name)
class C (B):
    def __init__(self, name):
        #通过父类名.init调用父类构造函数
        B.__init__(self, name)
        print("I am C init")

class D (B):
    def __init__(self, name):
        #通过super调用父类构造函数,python 3.0以后，下面两种写法都可以
        super().__init__(name)
        super(D, self).__init__(name)
        print("I am D init")

c = C ("I am C")
'''
输出结果:
I am B init
I am C
I am C init
'''
d = D ("I am D")
'''
输出结果:
I am B init
I am D
I am B init
I am D
I am D init
'''

多态

  • 同一对象在不同状态下有不同的状态出现
  • 多态不是一种语法，是一种设计思想
  • 多态性：一种调用方式，不同的执行效果
  • 多态： 同一事物的多种形态，动物分为人类、狗类、猪类
  • 多态和多态性
  • Mixin设计
  • 主要采用多继承方式对类进行扩展
  • 我们使用多继承语法来实现Mixin
  • 使用Mixin实现多继承的时候非常小心
  • 首先他必须表示某一单一功能，而不是某个物品
  • 职责必须单一，如有多个功能，则写多个Mixin
  • Mixin不能依赖子类实现
  • 子类即使没有继承这个Mixin类，也能照样工作，只是缺少类某个功能
  • 优点:
  • 使用Mixin可以在不对类进行修改的情况下，扩展功能
  • 可以方便地组织维护不同功能的组件的划分
  • 可以根据需要任意调整功能类的组合
  • 可以避免创建很多新的类，导致类的继承混乱
#Minxin相关实例
class Person():
    def eat(self):
        print("EATING")
    def sleep(self):
        print("SLEEPING")

#只有teach功能
class TeacherMixin():
    def teach(self):
        print("TEACHING")

#只有study功能
class StudentMixin():
    def study(self):
        print("STUDING")

class Tutor(Person, TeacherMixin, StudentMixin):
    pass

t = Tutor()
print(Tutor.__mro__)
print(t.__dict__)
print(Tutor.__dict__)
'''
输出结果:
(<class '__main__.Tutor'>, <class '__main__.Person'>, <class '__main__.TeacherMixin'>, <class '__main__.StudentMixin'>, <class 'object'>)
{}
{'__module__': '__main__', '__doc__': None}
'''

类相关函数

  • issubclass: 检测一个类是否是另一个类的子类
#issubclass 实例,前面参数是子类名,后面参数是父类名
class A():
    pass

class B (A):
    pass

print(issubclass(B, A))
print(issubclass(A, object))
'''
输出结果:
True
True
'''
  • isinstance: 检测一个类是否是另一个类的实例
#isinstance实例，前面参数是实例，后面参数是类名
class A():
    pass

class B (A):
    pass

a = A()
print(isinstance(a, A))
print(isinstance(a, B))
'''
输出结果:
True
False
'''
  • hasattr: 检测一个对象是否有成员xxx
# hasattr实例
class C ():
    name ='test'
    pass
c = C ()
print(hasattr(c, 'name'))
print(hasattr(c, 'age'))
'''
True
False
'''
  • getattr: get attribute
  • setattr: set attribute
  • delattr: delete attribute
  • dir: 获取对象的成员列表
# dir实例
class C ():
    name ='test'
    pass
c = C ()
print(dir(C))
print(dir(c))
'''
['__class__', '__delattr__', '__dict__', '__dir__', '__doc__', '__eq__', '__format__', '__ge__', '__getattribute__', '__gt__', '__hash__', '__init__', '__init_subclass__', '__le__', '__lt__', '__module__', '__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__setattr__', '__sizeof__', '__str__', '__subclasshook__', '__weakref__', 'name']
['__class__', '__delattr__', '__dict__', '__dir__', '__doc__', '__eq__', '__format__', '__ge__', '__getattribute__', '__gt__', '__hash__', '__init__', '__init_subclass__', '__le__', '__lt__', '__module__', '__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__setattr__', '__sizeof__', '__str__', '__subclasshook__', '__weakref__', 'name']
'''
#help 案例
help(setattr)
'''
输出:
Help on built-in function setattr in module builtins:

setattr(obj, name, value, /)
    Sets the named attribute on the given object to the specified value.
    
    setattr(x, 'y', v) is equivalent to ``x.y = v''
'''