python：OOP概念

OOP是面向对象编程（Object-oriented programming ）范式的缩写。它被定义为一种使用“对象”概念的编程模型，这些对象是指具有状态和行为的真实世界实体。

Python是一种支持面向对象编程的编程语言。这使得创建和使用类与对象变得更加简单。

Python - OOP概念

在现实世界中，我们处理和操作的对象，如学生、员工、发票、汽车等，不仅仅是数据，也不仅仅是功能，而是两者的结合。

属性（Attributes）

每个属性都将有一个与之相关的值。属性等同于数据。

行为（Behavior）

行为用来处理与对象相关联的属性，行为等同于功能。

面向对象最重要的特性是将属性及其功能定义为一个称为类的统一单元。它作为所有具有相似属性和行为的对象的蓝图。

在面向对象编程中，类定义了其对象具有哪些属性以及这些对象的行为方式，而对象则是该类的一个实例。

OOP理念

面向对象编程具有以下特征：

• 类（Class）
• 对象（Object）
• 封装（Encapsulation）
• 继承（Inheritance）
• 多态（Polymorphism）

类和对象

类是用户定义的对象原型，对象是指某一类的一个实例。

示例：

# 定义一个类
class Phone:
    # 构造器
    def __init__(self, price):
        self.price = price

    # 方法
    def description(self):
        return f'手机的价格是：{self.price}元'

# 创建一个手机对象
obj = Phone(2999)
print(obj.description())

输出：

封装

类的数据成员仅供类内部定义的方法处理，而类的方法则可以从类的外部上下文访问。因此，对象数据对类外部的环境是隐藏的。类的方法封装了对象数据，以防止对其未经授权的访问。

下面示例中，利用封装的概念设置手机的价格：

# 定义一个类
class Phone:
    # 构造器
    def __init__(self):
        self.__price = 2999

    # 方法
    def description(self):
        return f'手机的价格是：{self.__price}元'

    def set_price(self, price):
        self.__price = price

# 创建一个手机对象
obj = Phone()
print(obj.description())

# 直接修改价格，不生效
obj.__price = 3000
print(obj.description())

# 通过setter方法修改价格
obj.set_price(3000)
print(obj.description())

输出：

继承

面向对象编程（OOP）的软件建模方法允许在现有类的基础上进行扩展，以构建新的类，而不是从零开始构建。在OOP术语中，现有的类称为基类或父类，而新类则称为子类或派生类。

子类从父类继承数据定义和方法，这便于重用已有的特性。子类还可以添加一些更多的定义或重写基类的功能。

可以使用 issubclass() 或 isinstance() 函数来检查两个类以及实例之间的关系：

• issubclass(sub, sup) 布尔函数会在给定的子类 sub 确实是超类 sup 的子类时返回True。
• isinstance(obj, Class) 布尔函数在 obj 是 Class 类的一个实例或者是 Class 类的子类的一个实例时返回True。

继承的语法

派生类的声明方式与其父类非常相似，不过，在类名之后会给出要继承的基类列表：

class 子类名(父类名1[, 父类名2, ...]):
	# 内容

示例

# 定义父类
class Parent:
    score = 100

    def __init__(self):
        print('调用了父类的构造器')

    def parent_method(self):
        print('调用了父类的方法')

    def set_score(self, score):
        Parent.score = score

    def get_score(self):
        print(f'父类中score的值为：{Parent.score}')


# 定义子类
class Child(Parent):
    def __init__(self):
        print('调用了子类的构造器')

    def child_method(self):
        print(f'调用了子类的方法')


# 实例化子类
child = Child()
# 调用子类的方法
child.child_method()
# 调用父类的方法
child.parent_method()
# 调用父类的方法
child.set_score(200)
# 调用父类的方法
child.get_score()

输出：

多重继承示例

同样地，你可以通过如下方式让一个类从多个父类派生：

class A:
    pass

class B:
    pass

class C(A, B):
    pass

多态（Polymorphism）

多态性意思是有多种形式。在面向对象编程（OOP）中，当每个子类重写了父类的方法时，就出现了多态性。

你总是可以重写父类的方法。重写父类方法的一个原因是你可能希望在子类中拥有特殊或不同的功能。

示例

在这个例子中，子类重写了父类的方法。

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


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


# 实例化子类
child = Child()
# 调用了子类重写的方法
child.my_method()

输出：