乐趣区

❖ Python OOP 面向对象编程

参考:黑马程序员教程 – Python 基础 面向对象
OOP 三大特性,且三个特性是有顺序的:

封装
继承
多态

封装
指的就是把现实世界的事务,封装、抽象成编程里的对象,包括各种属性和方法。这个一般都很简单,不需要多讲。
唯一要注意的就是:推荐从小往大开始封装、开发类。比如手枪,子弹这两个类,我们需要先定义和开发子弹的所有属性和方法,然后再去开发上一层的手枪。这样的话会很方便。反过来开发手枪的适合,发现写到一半写不下去要到子弹那里写,就很乱了。
继承
子类可以继承父类和父父类的所有属性、方法。
继承格式:
class Parent:
def func1(self):
pass

class Son(Parent):
def func2(self):
func1()
方法改写:子类在不满意时,也可以进行自己的改写父类的属性、方法。其中有两种情况:

Overwrite 覆盖重写父类方法:只需要写一个同名函数即可覆盖。

Extend 扩展父类函数:

第一种方式 (主要):写一个同名函数,并在其中通过 super().func() 引用父类方法。其中 super 是一个 python builtin 特殊类,而 super()即生成一个 super 的实例。在子类中生成 super 实例,会得到父类的引用。
第二种方式(python 2.x 以前使用):写一个同名函数,再通过 ParentName.func(self)引用父类方法。但是不推荐,因为父类名称改变的话所有的子类都要改。

私有不继承:子类能够继承的只是父类的公开内容,但是不包括父类的私有内容。如果要访问的话也可以,但是需要间接的调用父类再用方法调用私有内容。
多继承
Python 中,子类是可以同时有多个父类的:也就是能够同时继承多个父类的所有属性、方法。
继承格式:
class Father:
def func1(self):
pass

class Mother:
def func2(self):
pass

class Son(Father, Mother):
def func3(self):
func1()
func2()
注意:如果多个父类间存在有同名的方法,那么会继承第一个父类的方法。
MRO, Method Resolution Order
查看继承顺序:通过类自带的.__mro__属性(MRO, Method Resolution Order),可以查看这个类的继承顺序。
子类可以直接写 FatherName.func()来调用父级函数。但是当子类用 super().func()时候,python 就会根据 MRO 顺序,由近到远逐次寻找,找到最近的上级则返回。
用上例,如果是多继承的话,那么寻找顺序是:SON -> Father -> Mother -> object。
查看类的内置属性和方法:
dir(className)可以查看内置所有属性方法。
Python 内置的 object 基础类
Python3 开始使用新式的类定义,即默认让所有定义的类都自动继承一个叫 object 的内置基础类。object 基础类定义了很多方便的属性。包括 18 项之多。而旧式的 Python2.x 时代,不继承 object 基础类,自己定义的类就只有__doc__和__module__两样内置属性而已。2.x 时代,如果需要手动继承,如:
class MyClass(object):
pass
多态
多态是指,不同的子类对象调用相同的父类方法,会产生多态多样结果的编程特性。多态的前提是能够继承父类的方法,且能够重写改写父类的方法。
多态的特点:

是调用方法的技巧,而不影响类的内部设计
可以增加代码灵活度

def Father():
def work(self):
do_job()

def do_job(self):
print(‘Farming on the field…’)

def Son(Father):
def do_job(self):
print(‘Programming at an office…’)

# —- Now let’s work —-
Jason = Son()
Jason.work()
以上代码中,同样是 work()函数,且要 do_work()。但是,不同的人调用的是不同的 do_work。Father 调用自己的 do_work,儿子因为自己重写了 do_work,所以调用自己的方法。这就是多态——所继承的方法,不需要再特殊指定谁用什么方法,而对象会自动调用适合自己的方法。
类与实例
Python 中,实例是一个对象,类也是一个对象,一切皆对象。但这也是 Python OOP 中引起很多麻烦的原因。
实例对象非常好理解,也好用,直接用,就不说了。但是类对象就不那么好理解了。
简单说,类对象也是一个标准的对象,有自己的属性和方法,只不过能够像模版一样生成多个实例对象而已。类对象有这两大研究点:

类属性:就是能让所有实例访问和操作的公用厕所

定义类属性:位于 class 的所有方法之外
访问类属性:className.propertyName

类方法:比较难理解,必须用到名为 @classmethod 的装饰器,函数的第一个参数必须是关键字 cls,如同 self。

@classmethod 装饰器:用来告诉解释器这是一个类方法,而不是实例方法。

cls 参数:

类属性与实例属性
这是 Python OOP 中困扰很多人的特点。但是其实不难理解,总结如下:
class MyClass:
# 在这个位置定义的,叫类属性。== 等同于其它语言的“静态属性”
# 这是每个实例共有的公用属性,相当于宿舍的公用洗澡间
count = 0

def __init__(self):
# 用 self. 定义的,叫实例属性,是每个实例只自己所有的属性,selfish
self.name = “Jason”
访问类属性的方法有两种:

ClassName.propertyName:推荐,直接用类名访问类属性。

Instance.propertyName:不推荐用实例名访问类属性,因为如果需要写入操作,那么这种方法只会给自己添加一个实例属性,而不会影响类属性。

动态添加类属性
方法一:
>>> MyClass.newAttribute = ‘I am a class attribute’
>>> print(MyClass.newAttribute)
‘I am a class attribute’
方法二:装饰器
# Customized decorator for classproperty
class classproperty(object):
def __init__(self, getter):
self.getter= getter
def __get__(self, instance, owner):
return self.getter(owner)

class MyClass:
@classproperty
def newAttribute(cls):
return ‘I am a class attribute.’

>>> print(MyClass.newAttribute)
‘I am a class attribute’
之所以把方法封装为一个类属性,是因为我们有时候需要根据其它类属性来定制这个类属性。而一般情况下,我们没法在类属性定义的时候获得当前的类或类中其它的属性。
类方法
类方法如同类属性,是属于全类的方法,但是(推荐)只用来访问类属性。
类方法:比较难理解,必须用到名为 @classmethod 的装饰器,函数的第一个参数必须是关键字 cls,如同 self。

@classmethod 装饰器:用来告诉解释器这是一个类方法,而不是实例方法。

cls 参数:如同 self,用来指代当前的类。

注意:@classmethod 和 cls 都是关键字,不能改。
代码:
class MyClass:
# 定义一个“类属性”
count = 0

# 这里开始定义“类方法”
@classmethod
def func(cls):
print(cls.count)
类静态方法
类中的 staticmethod 装饰器同样是 python 基础类 object 的一个用于包装、装饰的方法。一旦在类方法前放上装饰器 @staticmethod,方法就会转换为一个静态方法。静态方法就是一个非常独立的方法:既不访问实例的信息,也不访问类的信息。
代码:
class MyClass:
# 定义一个“类属性”
count = 0

# 这里开始定义“类方法”
@staticmethod
def func():
pass
Property 属性
类中的 property 装饰器,也是 python 基础类 object 的一个用于包装、装饰的方法。一旦类方法前放上装饰器 @property,方法就会转换为一个类属性。很多时候把方法伪装成属性,是非常方便的。
class MyClass:
# 这里开始定义由方法转换为“类属性”
@property
def name(self):
return “Jason”

c = MyClass()
print(c.name)
在继承 object 基础类的情况下,python 给出了三种类属性装饰,对应三种操作:

读取:@property

写入:@name.setter

删除:@name.deleter

也就是说,当你读取类属性 my_name 的时候,会调用被 @property 修饰的方法;当你修改 my_name 当时候,会调用被 @my_name.setter 修饰的方法;当你删除这个属性时,会调用被 @my_name.deleter 修饰的方法。
注意:

其中 @property, @*.setter, @*.deleter,这是固定的名字,不能改。
三种操作所修饰的三个函数,必须都是同一个名字:即“类属性”名。

代码:
class MyClass:
# 这里开始定义由方法转换为“类属性”
@property
def name(self):
return “Jason”

@name.setter
def name(self, value):
self.name = value

@name.deleter
def name(self):
del “Jason”

c = MyClass()

print(c.name) # READ
c.name = “Brown” # SET
del c.name # DELETE
property 属性的应用
很多 OOP 语言,针对 property 属性,一般操作是:一个私有属性,配合两个公有方法。如:
class MyClass:
def __init__(self):
self.__name = “Jason”

def get_name(self):
return self.__name

def set_name(self, value):
self.__name = value

c = MyClass()

# 开始调用
c.set_name(“Brownee”)
print(c.get_name() )
在 Python 下,可以利用装饰器改为以下代码,极大方便调用的过程:
class MyClass:
def __init__(self):
self.__name = “Jason”

@property
def name(self):
return self.__name

@name.setter
def name(self, value):
self.__name = value

c = MyClass()

# 开始调用
c.name = “Brownee”
print(c.name)

退出移动版