封装

数据角度

将一些基本数据类型复合成一个自定义类型。

  • 将数据与对数据的操作相关联。
  • 代码可读性更高(类是对象的模板)。

行为角度

向类外提供必要的功能,隐藏实现的细节。简化编程,使用者不必了解具体的实现细节,只需要调用对外提供的功能。

可以声明私有成员。

  • 无需向类外提供的成员,可以通过私有化进行屏蔽。
  • 封装可以开放有用的功能,可以帮助同事更容易阅读和使用代码。
  • 做法:命名使用双下划线开头。
  • 本质:障眼法,实际也可以访问。

私有成员的名称被修改为:_类名__成员名,可以通过 __dict__ 属性查看。

1
2
3
4
5
6
7
8
9
10
11
12
13
class MyClass:
def __init__(self, data):
self.__data = data

def __func01(self):
print("func01执行了")

m01 = MyClass(10)
# print(m01.__data) # 无法访问
print(m01._MyClass__data)
print(m01.__dict__) # {'_MyClass__data': 10}
# m01.__func01() # 无法访问
m01._MyClass__func01()

属性@property:

属性可以保护实例变量,限制变量在有效范围内。

1
2
3
4
5
6
7
@property
def 属性名(self):
return self.__属性名

@属性名.setter
def 属性名(self, value):
self.__属性名= value
1
2
3
# 调用
对象.属性名 = 数据
变量 = 对象.属性名

属性的三种形式

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
# 1. 读取属性:限制变量在有效范围内。
class MyClass:
def __init__(self,data):
self.data = data #

@property
def data(self):
return self.__data

@data.setter
def data(self, value):
self.__data = value

m01 = MyClass(10)
print(m01.data)
1
2
3
4
5
6
7
8
9
10
11
12
# 2. 只读属性:为私有变量提供读取功能。
class MyClass:
def __init__(self):
self.__data = 10

@property
def data(self):
return self.__data

m01 = MyClass()
# m01.data = 20# AttributeError: can't set attribute
print(m01.data)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
# 3. 只写属性:比较特殊,需要展开写 property 函数。而且确实很难用得上。
class MyClass:
def __init__(self, data):
self.data = data

# 第一种方法
# data = property()
# @data.setter
# def data(self, value):
# self.__data = value

# 第二种方法
def data(self, value):
self.__data = value

data = property(fset=data) # 这里不放读的函数,就叫只写


m01 = MyClass(10)
print(m01.data) # AttributeError: unreadable attribute
m01.data = 20

继承

继承方法

子类直接拥有父类的方法。也就是说子类放个性,父类放的是子类的个性。

1
2
3
4
5
6
7
8
9
10
11
class 父类:
def 父类方法(self):
方法体

class 子类(父类):
def 子类方法(self):
方法体

儿子 = 子类()
儿子.子类方法()
儿子.父类方法()

内置函数

是一种的判定和的判定,包含成分都算是一种,两个完全相同算作。前者使用下面的内置函数,后者使用 ==

isinstance(对象, 类型):​返回指定对象是否是某个类的对象。

issubclass(类型,类型):返回指定类型是否属于某个类型。

继承数据

子类如果没有构造函数,将自动执行父类的,但如果有构造函数将覆盖父类的。此时必须通过super()函数调用父类的构造函数,以确保父类实例变量被正常创建。

1
2
3
4
class 子类(父类):
def __init__(self,父类参数,子类参数):
super().__init__(参数) # 调用父类构造函数
self.实例变量 = 参数

定义

  1. 概念: 重用现有类的功能,并在此基础上进行扩展。
  2. 说明:子类直接具有父类的成员(共性),还可以扩展新功能。
  • 父类(基类、超类)、子类(派生类)。
  • 父类相对于子类更抽象,范围更宽泛;子类相对于父类更具体,范围更狭小。
  • 单继承:父类只有一个(例如 Java,C#)。
  • 多继承:父类有多个(例如C++,Python)。
  • Object类:任何类都直接或间接继承自 object 类。

多继承

  1. 定义:一个子类继承两个或两个以上的基类,父类中的属性和方法同时被子类继承下来。
  2. 同名方法解析顺序(MRO, Method Resolution Order): 类名.mro() 返回类解析的顺序。
  3. 可以理解为按队列

多态

重写内置函数

  1. 定义:Python中,以双下划线开头、双下划线结尾的是系统定义的成员。我们可以在自定义类中进行重写,从而改变其行为。
    2.__str__ 函数:将对象转换为字符串(对人友好的)

算数运算符

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
class Vector2:
"""
二维向量
"""

def __init__(self, x, y):
self.x = x
self.y = y

def __str__(self):
return "x是:%d,y是:%d" % (self.x, self.y)

def __add__(self, other):
return Vector2(self.x + other.x, self.y + other.y)

v01 = Vector2(1, 2)
v02 = Vector2(2, 3)
print(v01 + v02) # v01.__add__(v02)

复合运算符重载

没有重载 __iadd__ 的时候默认使用 __add__。这里iadd是+=,add是+,两者的区别是+=是在修改,而+是在创建。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
class Vector2:
"""
二维向量
"""

def __init__(self, x, y):
self.x = x
self.y = y

def __str__(self):
return "x是:%d,y是:%d" % (self.x, self.y)

# + 创建新
def __add__(self, other):
return Vector2(self.x + other.x, self.y + other.y)

# += 在原有基础上修改(自定义类属于可变对象)
def __iadd__(self, other):
self.x += other.x
self.y += other.y
return self

v01 = Vector2(1, 2)
v02 = Vector2(2, 3)
print(id(v01))
v01 += v02
print(id(v01))
print(v01)

比较运算重载

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
class Vector2:
"""
二维向量
"""

def __init__(self, x, y):
self.x = x
self.y = y

# 决定相同的依据
def __eq__(self, other):
return self.x == other.x and self.y == other.y

# 决定大小的依据
def __lt__(self, other):
return self.x < other.x


v01 = Vector2(1, 1)
v02 = Vector2(1, 1)
print(v01 == v02) # True 比较两个对象内容(__eq__决定)
print(v01 is v02) # False 比较两个对象地址

list01 = [
Vector2(2, 2),
Vector2(5, 5),
Vector2(3, 3),
Vector2(1, 1),
Vector2(1, 1),
Vector2(4, 4),
]

# 必须重写 eq
print(Vector2(5, 5) in list01)
print(list01.count(Vector2(1, 1)))

# 必须重写 lt
list01.sort()
print(list01)

重写自定义函数

  1. 子类实现了父类中相同的方法(方法名、参数),在调用该方法时,实际执行的是子类的方法。
  2. 快捷键:ctrl + O
  • 在继承的基础上,体现类型的个性(一个行为有不同的实现)。
  • 增强程序灵活性。