Python封装、继承和多态_python 中是否类没有显式扩展超类,则在默认情

Python 语言在设计之初，就定位为一门面向对象的编程语言，“Python 中一切皆对象”。同时，Python 也支持面向对象的三大特征：封装、继承和多态。

一、封装

封装（Encapsulation），即在设计类时，刻意地将一些属性和方法隐藏在类的内部，这样在使用此类时，将无法直接以“类对象.属性名”（或者“类对象.方法名(参数)”）的形式调用这些属性（或方法），而只能用未隐藏的类方法间接操作这些隐藏的属性和方法。

类的封装机制保证了类内部数据结构的完整性，提高了程序的可维护性，还可以提高代码的复用性。

1、Python类如何进行封装

Python 没有提供 public、private 这些修饰符，为了实现类的封装，而是采取了下面的方法：

• 默认情况下，Python 类中的变量和方法都是公有的，它们的名称前都没有下划线（_）；
• 如果以单下划线“_”开头，则是类属性或者类方法；
• 如果以双下划线“__”开头，则是私有变量或者私有方法。

注意：

• Python 类中还有以双下划线开头和结尾的类方法（例如类的构造函数__init__(self)），这些都是 Python 内部定义的，用于 Python 内部调用。我们自己定义类属性或者类方法时，不要使用这种格式。

示例代码如下：

class MyClass:

    def setname(self, name):
        if len(name) < 3:
            raise ValueError('名称长度必须大于3！')
        self.__name = name

    def getname(self):
        return self.__name

    # 为 name 配置 setter 和 getter 方法
    name = property(getname, setname)

    age = None

    # 定义公有方法
    def m1(self):
        # 调用私有方法
        print("m1 调用私有方法：", self.__privateM1())
        return 'hello MyClass'

    # 定义个私有方法
    def __privateM1(self):
        print(self.name, self.age)


obj = MyClass()

obj.name = "赵子龙"
obj.age = 18
print(obj.getname())
print(obj.age)
print("---------")
print(obj.m1())
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

二、继承

Python 支持类的单继承和多继承。

• 实现继承的类称为子类，被继承的类称为父类（也可称为基类、超类）。
• 类继承父类时，只需在定义子类时，将父类（可以是多个）放在子类之后的圆括号里即可。
• 如果该类没有显式指定继承自哪个类，则默认继承 object 类（object 类是 Python 中所有类的父类，即要么是直接父类，要么是间接父类）。

1、单继承

子类（派生类）的定义语法如下：

class DerivedClassName(BaseClassName):
    <statement-1>
    .
    .
    .
    <statement-N>
1
2
3
4
5
6

• 子类（DerivedClassName类）会继承父类（BaseClassName基类）的属性和方法（包括私有的）。

示例代码如下：

class People:
    # 定义基本属性
    name = ''
    age = 0
    # 定义私有属性,私有属性在类外部无法直接进行访问
    __weight = 0

    # 定义构造方法
    def __init__(self, n, a, w):
        self.name = n
        self.age = a
        self.__weight = w

    def speak(self):
        print("%s 说: 我 %d 岁。" % (self.name, self.age))


# 单继承示例
class Student(People):
    grade = ''

    def __init__(self, n, a, w, g):
        # 调用父类的构函
        People.__init__(self, n, a, w)
        self.grade = g

    # 重写父类的方法
    def speak(self):
        print("%s 说: 我 %d 岁，职业：%s" % (self.name, self.age, self.grade))

s = Student('赵云',18,60.0,"小学生")
s.speak() # 赵云 说: 我 18 岁，职业：王者
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

2、多继承

Python支持多继承形式。多继承的类定义语法如下：

class DerivedClassName(Base1, Base2, Base3):
    <statement-1>
    .
    .
    .
    <statement-N>
1
2
3
4
5
6

使用多继承经常需要面临的问题是，多个父类中包含同名的类方法，而在子类使用时未指定重写该方法时。注意圆括号中父类的顺序。即方法在子类中未找到时，从左到右查找父类中是否包含方法。

示例代码如下：

# 类定义
class People:
    # 定义基本属性
    name = ''
    age = 0
    # 定义私有属性,私有属性在类外部无法直接进行访问
    __weight = 0

    # 定义构造方法
    def __init__(self, n, a, w):
        self.name = n
        self.age = a
        self.__weight = w

    def speak(self):
        print("%s 说: 我 %d 岁。" % (self.name, self.age))


# 单继承
class Student(People):
    grade = ''

    def __init__(self, n, a, w, g):
        # supper调用父类的构造方法，无需手动给 self 传值
        super().__init__(n, a, w)
        self.grade = g

    # 覆写父类的方法
    def speak(self):
        print("%s 说: 我 %d 岁，职业：%s" % (self.name, self.age, self.grade))


# 职业类
class Profession():
    prof = ''

    def __init__(self, prof):
        self.prof = prof

    def speakProf(self):
        print("职业段位：{} ".format(self.prof))


# 多重继承
class Game(Student, Profession):
    gameName = ''

    def __init__(self, gameName, name, age, weight, g, prof):
        self.gameName = gameName
        print("欢迎进入 {}".format(self.gameName))
        # 类名调用父类的构造方法，需手动给 self 传值
        Student.__init__(self, name, age, weight, g)
        Profession.__init__(self, prof)


obj = Game("王者荣耀", "赵子龙", 18, 60.5, "小学生", "王者")
obj.speak()  # 方法名同，默认调用的是在括号中参数位置排前父类的方法
obj.speakProf()
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
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58

super() 函数是用于调用父类的一个方法。推荐大家使用这种格式：

super().__init__(...)
1

3、方法重写

方法重写，方法又称覆盖，是指如果父类方法的功能不能满足子类的需求时，子类可以对已有方法的内部实现进行修改。

示例代码如下：

class Parent:  # 定义父类
    def myMethod(self):
        print('调用父类方法')


class Child(Parent):  # 定义子类
    def myMethod(self):
        print('调用子类方法')


c = Child()  # 子类实例
c.myMethod()  # 子类调用重写方法
Parent.myMethod(c) # 用父类名调用父类方法
1
2
3
4
5
6
7
8
9
10
11
12
13

三、多态

多态：就是同一种行为对不同的子类[对象]有不同的行为表现。

要想实现多态，必须满足两个前提条件：

1. 继承：多态一定是发生在子类和父类之间
2. 重写：子类重写了父类的方法

示例代码如下：

class CLanguage:
    def say(self):
        print("调用的是 Clanguage 类的say方法")
class CPython(CLanguage):
    def say(self):
        print("调用的是 CPython 类的say方法")
class CLinux(CLanguage):
    def say(self):
        print("调用的是 CLinux 类的say方法")

a = CLanguage()
a.say()
a = CPython()
a.say()
a = CLinux()
a.say()
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

四、枚举类

Python 3.4 中新增加了 Enum 枚举类。对于某些实例化对象个数固定的类，可以用枚举类来定义。

枚举类的每个成员都由 2 部分组成，分别为 name 和 value，其中 name 属性值为该枚举值的变量名（如 red），value 代表该枚举值的序号（序号通常从 1 开始）。

注意：

• 枚举类不能用来实例化对象，但这并不妨碍我们访问枚举类中的成员。
• 枚举类成员之间不能比较大小，但可以用 == 或者 is 进行比较是否相等。
• 枚举类中各个成员的值，不能在类的外部做任何修改。

1、创建枚举类

（1）通过继承 Enum 类的方法创建枚举类

from enum import Enum

class SexEnum(Enum):
    # 指定value值,通常从 1 开始
    male = 1
    female = 2
    other = 3
1
2
3
4
5
6
7

（2）使用 Enum() 函数创建枚举类

from enum import Enum

# 创建一个枚举类
SexEnum = Enum("SexEnum", ('male', 'female', 'other'))
1
2
3
4

2、访问枚举类成员

（1）访问枚举成员的 3 种方式

print(SexEnum.male)
print(SexEnum['female'])
print(SexEnum(3))

sex = SexEnum.male
print(sex.name, "--", sex.value)
1
2
3
4
5
6

（2）遍历枚举类中所有成员的 2 种方式：

• 遍历枚举类
• 遍历 __members__ 属性

枚举类提供了一个 __members__ 属性，该属性是一个包含枚举类中所有成员的字典，通过遍历该属性，可以访问枚举类中的所有成员。

# 遍历枚举类
for sex in SexEnum:
    print(sex.name, "--", sex.value)

print("--------")
# 遍历 __members__ 属性
for name, member in SexEnum.__members__.items():
    print(name, "->", member)
1
2
3
4
5
6
7
8

3、@unique 装饰器

枚举类中各个成员必须保证 name 互不相同，但 value 可以相同。value 相同时，对于程序会有一定的问题，开发中一般不推荐 value 相同。

Python 提供了 @unique 装饰器，这样当枚举类中出现相同值的成员时，程序会报 ValueError 错误。

#引入 unique
from enum import Enum, unique

# 创建一个枚举类，添加 unique 装饰器
@unique
class SexEnum(Enum):
    # 指定value值,通常从 1 开始
    male = 1
    female = 2
    other = 3
1
2
3
4
5
6
7
8
9
10

– 求知若饥，虚心若愚。