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 = namedef 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())

二、继承

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

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

1、单继承

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

class DerivedClassName(BaseClassName):<statement-1>...<statement-N>

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

示例代码如下：

class People:# 定义基本属性name = ''age = 0# 定义私有属性,私有属性在类外部无法直接进行访问__weight = 0# 定义构造方法def __init__(self, n, a, w):self.name = nself.age = aself.__weight = wdef 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 岁，职业：王者

2、多继承

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

class DerivedClassName(Base1, Base2, Base3):<statement-1>...<statement-N>

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

示例代码如下：

# 类定义
class People:# 定义基本属性name = ''age = 0# 定义私有属性,私有属性在类外部无法直接进行访问__weight = 0# 定义构造方法def __init__(self, n, a, w):self.name = nself.age = aself.__weight = wdef 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 = profdef speakProf(self):print("职业段位：{} ".format(self.prof))# 多重继承
class Game(Student, Profession):gameName = ''def __init__(self, gameName, name, age, weight, g, prof):self.gameName = gameNameprint("欢迎进入 {}".format(self.gameName))# 类名调用父类的构造方法，需手动给 self 传值Student.__init__(self, name, age, weight, g)Profession.__init__(self, prof)obj = Game("王者荣耀", "赵子龙", 18, 60.5, "小学生", "王者")
obj.speak()  # 方法名同，默认调用的是在括号中参数位置排前父类的方法
obj.speakProf()

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

super().__init__(...)

3、方法重写

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

示例代码如下：

class Parent:  # 定义父类def myMethod(self):print('调用父类方法')class Child(Parent):  # 定义子类def myMethod(self):print('调用子类方法')c = Child()  # 子类实例
c.myMethod()  # 子类调用重写方法
Parent.myMethod(c) # 用父类名调用父类方法

三、多态

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

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

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()

四、枚举类

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

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

注意：

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

1、创建枚举类

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

from enum import Enumclass SexEnum(Enum):# 指定value值,通常从 1 开始male = 1female = 2other = 3

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

from enum import Enum# 创建一个枚举类
SexEnum = Enum("SexEnum", ('male', 'female', 'other'))

2、访问枚举类成员

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

print(SexEnum.male)
print(SexEnum['female'])
print(SexEnum(3))sex = SexEnum.male
print(sex.name, "--", sex.value)

（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)

3、@unique 装饰器

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

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

#引入 unique
from enum import Enum, unique# 创建一个枚举类，添加 unique 装饰器
@unique
class SexEnum(Enum):# 指定value值,通常从 1 开始male = 1female = 2other = 3

– 求知若饥，虚心若愚。