Python 面向对象（类，对象，方法，属性，魔术方法）

前言：在讲面向对象之前，我们先将面向过程和面向对象进行一个简单的分析比较，这样我们可以更好的理解与区分，然后我们在详细的讲解面向对象的优势。

        面向过程（Procedure-Oriented Programming，POP）和面向对象（Object-Oriented Programming，OOP）是两种不同的编程范式，它们在编程理念、代码组织方式、可维护性等方面存在明显差异，下面为你详细介绍。

🥇面向过程

概念

面向过程是一种以过程为中心的编程范式，它将一个大的任务分解为一系列的步骤，每个步骤用一个函数来实现，程序的执行流程就是依次调用这些函数。重点在于分析解决问题所需的步骤，然后用函数把这些步骤一步一步实现。

特点

强调功能分解：把一个复杂的问题拆分成多个简单的子问题，每个子问题对应一个函数，函数之间通过参数和返回值进行数据传递和交互。

数据和操作分离：数据和处理数据的函数是分开的，函数可以独立于数据存在，不同的函数可以对相同的数据进行操作。

执行流程明确：程序按照函数调用的顺序依次执行，执行流程清晰，易于理解和调试。

示例

下面是一个使用面向过程编程实现的简单加法程序：

# 定义一个函数用于执行加法操作
def add_numbers(a, b):
    return a + b

# 定义一个函数用于显示结果
def display_result(result):
    print(f"两数相加的结果是: {result}")

# 主程序
num1 = 5
num2 = 3
# 调用加法函数
sum_result = add_numbers(num1, num2)
# 调用显示结果函数
display_result(sum_result)

在这个例子中，我们将加法操作和结果显示操作分别封装在两个函数中，程序的执行流程就是依次调用这些函数，先计算加法，再显示结果。

适用场景

面向过程编程适用于处理简单、规模较小的问题，以及对执行效率要求较高的场景，因为它的执行流程简单直接，没有过多的抽象和封装。例如，一些脚本程序、算法实现等。

🥇面向对象

概念

面向对象是一种以对象为中心的编程范式，它将数据和操作数据的方法封装在一起，形成对象。通过定义类来创建对象，类是对象的模板，描述了对象的属性和行为。对象之间通过消息传递进行交互。

特点

封装：将数据（属性）和操作数据的方法（方法）捆绑在一起，形成一个独立的单元，对外提供统一的接口，隐藏内部实现细节。这样可以提高代码的安全性和可维护性。

继承：一个类可以继承另一个类的属性和方法，被继承的类称为父类（基类），继承的类称为子类（派生类）。继承可以实现代码的复用和扩展，减少代码的重复编写。

多态：不同的对象可以对同一消息做出不同的响应。通过方法重写和接口实现等方式，实现不同对象对相同方法的不同实现，提高代码的灵活性和可扩展性。

示例

下面是一个使用面向对象编程实现的简单加法程序：

class Calculator:
    def __init__(self):
        pass

    def add(self, a, b):
        return a + b

    def display_result(self, result):
        print(f"两数相加的结果是: {result}")

# 创建 Calculator 类的对象
calc = Calculator()
num1 = 5
num2 = 3
# 调用对象的加法方法
sum_result = calc.add(num1, num2)
# 调用对象的显示结果方法
calc.display_result(sum_result)

在这个例子中，我们定义了一个 Calculator 类，将加法操作和结果显示操作封装在类的方法中。通过创建 Calculator 类的对象 calc，调用对象的方法来完成加法和结果显示的操作。

适用场景

面向对象编程适用于处理复杂、规模较大的问题，以及需要高度复用和扩展的场景。例如，大型软件系统、游戏开发、图形用户界面（GUI）编程等。

对比总结（面向过程与面向对象的区别）

编程思想：面向过程关注的是解决问题的步骤和过程，而面向对象关注的是对象及其之间的交互。

代码组织：面向过程的代码以函数为中心，函数之间的调用关系构成程序的执行流程；面向对象的代码以类和对象为中心，通过对象之间的消息传递来实现程序的功能。

可维护性和可扩展性：面向过程的代码在处理复杂问题时，随着功能的增加，函数之间的调用关系会变得复杂，导致代码的可维护性和可扩展性降低；面向对象通过封装、继承和多态等特性，可以更好地组织代码，提高代码的可维护性和可扩展性。

🥇面向对象（简化）：

再将面向对象讲的简单一点，打个比方若在某游戏中设计一个乌龟的角色，应该如何来实现呢？使用面向对象的思想会更简单，可以分为如下两个方面进行描述：

1. 从表面特征来描述，例如，绿色的、有 4 条腿、重 10 kg、有外壳等等。
2. 从所具有的的行为来描述，例如，它会爬、会吃东西、会睡觉、会将头和四肢缩到壳里。

如果将乌龟用代码来表示，则其表面特征可以用变量来表示，其行为特征可以通过建立各种函数来表示。参考代码如下所示：

class tortoise:
    bodyColor = "绿色"
    footNum = 4
    weight = 10
    hasShell = True

    #会爬
    def crawl(self):
        print("乌龟会爬")
    #会吃东西
    def eat(self):
        print("乌龟吃东西")
    #会睡觉
    def sleep(self):
        print("乌龟在睡觉")
    #会缩到壳里
    def protect(self):
        print("乌龟缩进了壳里")

因此，从某种程序上，相比较只用变量或只用函数，使用面向对象的思想可以更好地模拟现实生活中的事物。
不仅如此，在 Python 中，所有的变量其实也都是对象，包括整形（int）、浮点型（float）、字符串（str）、列表(list)、元组(tuple)、字典（dict）和集合（set）。以字典（dict）为例，它包含多个函数供我们使用，例如使用 keys() 获取字典中所有的键，使用 values() 获取字典中所有的值，使用 item() 获取字典中所有的键值对，等等。

🥇面向对象中的常用术语：

类：可以理解是一个模板，通过它可以创建出无数个具体实例。比如，前面编写的 tortoise 表示的只是乌龟这个物种，通过它可以创建出无数个实例来代表各种不同特征的乌龟（这一过程又称为类的实例化）。

对象：类并不能直接使用，通过类创建出的实例（又称对象）才能使用。这有点像汽车图纸和汽车的关系，图纸本身（类）并不能为人们使用，通过图纸创建出的一辆辆车（对象）才能使用。

属性：类中的所有变量称为属性。例如，tortoise 这个类中，bodyColor、footNum、weight、hasShell 都是这个类拥有的属性。

方法：类中的所有函数通常称为方法。不过，和函数所有不同的是，类方法至少要包含一个 self 参数（后续会做详细介绍）。例如，tortoise 类中，crawl()、eat()、sleep()、protect() 都是这个类所拥有的方法，类方法无法单独使用，只能和类的对象一起使用。

🥇类与对象的关系和定义：

类是抽象的概念，是对象的模板，它定义了对象的属性和方法；对象是具体的实体，是类的实例，具有类所定义的属性和方法，并且每个对象都有自己独立的状态。类和对象相互依存，类为对象提供了统一的规范，对象则是类的具体体现。

 类与对象的关系：类与对象是抽象与具体、模板与实例的关系。类是对一类事物属性和行为的抽象描述，是创建对象的模板。对象是类的具体实例，依据类创建，有独立状态。类定义通用规则，对象遵循规则并展现具体特征与行为。一个类可以创建多个对象，它们之间是独立的，互相不影响。

类与对象的定义：类是一种用户自定义的数据类型，它由数据和方法组成。数据表示属性，方法表示行为。一个类可以包含多个属性和方法。属性是类的成员变量，可以存储数据。方法是一组操作数据的代码，它们可以实现某些功能或者改变属性的值。类是面向对象编程中的抽象概念，是对具有相同属性和方法的一组对象的描述，如同模板或蓝图，定义了对象应有的特征和行为规范。对象是类的具体实例，基于类创建，有自己独特的属性值，能执行类定义的方法，是类抽象概念的具象体现。

类的定义：

在Python中，我们可以有两种类的定义方式：Python2（经典类）和 Python3（新式类）

经典类：不由任意内置类型派生出的类，称之为经典类

class 类名:
     # 属性
     # ⽅法

新式类

class 类名(object):
     # 属性
     # ⽅法

实例：基本语法

class Person(object):
     # 属性
     # ⽅法（函数）
     def eat(self):
         print('吃零⻝')
     def drink(self):
         print('喝可乐')

类的实例化（创建对象）：

类的实例化就是把抽象的事务具体为现实世界中的实体。

类的实例化就是通过类得到对象！

类只是对象的一种规范，类本身基本上什么都做不了，必须利用类得到对象，这个过程就叫作类的实例化！

# 基本语法
# 对象名 = 类名()
# 1、定义⼀个类
class Person(object):
     # 定义相关⽅法
     def eat(self):
         print('吃零⻝')
     def drink(self):
         print('喝可乐')
 
# 2、实例化对象
p1 = Person()
# 3、调⽤类中的⽅法
p1.eat()
p1.drink()
p2 = Person()

输出结果：

注意：在其他的编程语言中，类的实例化一般是通过new关键字实例化生成的，但是在Python中，我们不需要new关键字，只需要类名＋()括号就代表类的实例。

类是一个抽象概念，在定义时，其并不会真正的占用计算机的内存空间。但是对象是一个具体的事务，所以其要占用计算机的内存空间。

 🥇类中的self关键字：

定义

self 是一个约定俗成的参数名，在 Python 类的实例方法中，它作为第一个参数出现。它代表类的实例对象本身，当调用实例方法时，Python 会自动将调用该方法的对象作为第一个参数传递给 self。

作用

访问实例属性

在类的方法中，可以使用 self 来访问和修改实例对象的属性。实例属性是每个对象独有的数据，通过 self 可以确保操作的是当前对象的属性。

class Person:
    def __init__(self, name, age):
        # 初始化实例属性
        self.name = name
        self.age = age

    def introduce(self):
        # 使用 self 访问实例属性
        print(f"我叫 {self.name}，今年 {self.age} 岁。")

# 创建 Person 类的实例
p = Person("张三", 25)
p.introduce()  # 输出: 我叫 张三，今年 25 岁。

 在上述代码中，__init__ 方法通过 self.name 和 self.age 初始化了实例对象的属性，introduce 方法通过 self.name 和 self.age 访问了这些属性。

调用实例方法

在类的一个实例方法中，可以使用 self 来调用该对象的其他实例方法。

class Calculator:
    def __init__(self, num):
        self.num = num

    def square(self):
        return self.num ** 2

    def double_square(self):
        # 使用 self 调用 square 方法
        return 2 * self.square()

# 创建 Calculator 类的实例
calc = Calculator(5)
result = calc.double_square()
print(result)  # 输出: 50

在
double_square 方法中，通过
self.square() 调用了
square 方法。

注意事项

命名约定

虽然 self 只是一个约定俗成的名称，并不是 Python 的关键字，但建议始终使用 self 作为实例方法的第一个参数名，这样可以提高代码的可读性和可维护性，让其他开发者更容易理解代码的含义。

自动传递

当调用实例方法时，不需要手动传递 self 参数，Python 会自动将调用该方法的对象作为 self 参数传递给方法。

🥇对象的属性添加与获取：

属性的基本概念：

在Python中，任何一个对象都应该由两部分组成：属性 + 方法

属性即是特征，比如：

人的姓名、年龄、身高、体重…都是对象的属性。

车的品牌、型号、颜色、载重量…都是对象的属性。

对象属性既可以在类外面添加和获取，也能在类里面添加和获取。

在类的外面添加属性和获取属性：

在 Python 里，类的实例对象可以动态地添加属性，也就是在类定义之外为实例对象赋予新的属性。只需使用实例对象名，后跟点号（.）和新属性名，再通过赋值语句给该属性赋一个值即可。

示例代码：

# 定义一个简单的类
class Person:
    def __init__(self, name):
        self.name = name

# 创建一个 Person 类的实例
person = Person("Alice")

# 在类的外面添加属性
person.age = 25
person.gender = "Female"

# 获取属性
print(f"Name: {person.name}")
print(f"Age: {person.age}")
print(f"Gender: {person.gender}")

代码解释

1. 定义类 Person：在这个类中，有一个 __init__ 方法，它在创建实例时被调用，会将传入的 name 参数赋值给实例的 name 属性。
2. 创建实例：创建了一个 Person 类的实例 person，并传入名字 "Alice"。
3. 添加属性：在类的外面，通过 person.age = 25 和 person.gender = "Female" 分别为 person 实例添加了 age 和 gender 属性。
4. 获取属性：使用 print 函数，通过 person.name、person.age 和 person.gender 获取并打印这些属性的值。

注意事项

这种动态添加属性的方式只对当前实例对象有效，不会影响类的其他实例。

如果尝试访问一个不存在的属性，会引发 AttributeError 异常。因此，在访问属性之前，最好先检查属性是否存在，可以使用 hasattr() 函数进行判断。

在类的内部获取外部定义的属性：

代码示例：

# 1、定义⼀个Person类
class Person():
     def speak(self):
         print(f'我的名字：{self.name}，我的年龄：{self.age}，我的住址：{self.address}')
# 2、实例化Person类，⽣成p1对象
p1 = Person()
# 3、添加属性
p1.name = '孙悟空'
p1.age = 500
p1.address = '花果⼭⽔帘洞'
# 4、调⽤speak⽅法
p1.speak()

🥇魔术方法：

魔术方法的基本概念：

在 Python 里，魔术方法（Magic Methods）也被叫做特殊方法（Special Methods），它们是一类具有特殊命名规则的方法，名字以双下划线 __ 开头和结尾，例如 __init__、__str__ 等。这些方法在特定的场景下会被 Python 解释器自动调用，无需手动调用，能让开发者实现一些特殊的功能，极大增强了类的功能和灵活性。

__init__() 当实例化对象时，其会自动被触发（被调用）

__del__() 当手工删除对象或对象被销毁时，其会自动被触发（被调用）

基本概念要点

1. 命名规则：双下划线开头和结尾是魔术方法的显著标识，这一命名方式是 Python 的约定，用于区分普通方法。
2. 自动调用：Python 解释器会在特定操作发生时自动调用相应的魔术方法，而非像普通方法那样需要手动调用。
3. 增强类的功能：借助实现不同的魔术方法，能够让自定义类模拟内置类型的行为，或者实现特定的操作。

 🥇__init__() 方法(初始化方法或构造方法)

基本概念

__init__() 方法在创建类的实例时会被 Python 解释器自动调用，主要用于对实例对象进行初始化操作，即给实例对象的属性赋初始值。该方法定义在类的内部，其名称固定为 __init__，并且第一个参数必须是 self，它代表类的实例对象本身。

语法结构

class ClassName:
    def __init__(self, parameter1, parameter2, ...):
        # 初始化操作
        self.attribute1 = parameter1
        self.attribute2 = parameter2
        ...

代码示例

class Person:
    def __init__(self, name, age):
        # 将传入的 name 参数赋值给实例的 name 属性
        self.name = name
        # 将传入的 age 参数赋值给实例的 age 属性
        self.age = age

    def introduce(self):
        # 打印实例的 name 和 age 属性
        print(f"我叫 {self.name}，今年 {self.age} 岁。")

# 创建 Person 类的实例，同时传入初始化参数
p1 = Person("Alice", 25)
# 调用实例的 introduce 方法
p1.introduce()

在上述代码中：

1. 定义了一个 Person 类，其中包含 __init__ 方法和 introduce 方法。
2. __init__ 方法接收两个参数 name 和 age，并将它们分别赋值给实例的 name 和 age 属性。
3. 创建 Person 类的实例 p1 时，传入了 "Alice" 和 25 作为初始化参数，__init__ 方法会自动被调用，将这两个值赋给 p1 的 name 和 age 属性。
4. 调用 p1 的 introduce 方法，打印出实例的 name 和 age 属性信息。

注意事项

self 参数：__init__ 方法的第一个参数必须是 self，这是 Python 的规定。当创建实例时，Python 会自动将实例对象作为第一个参数传递给 __init__ 方法。

可选参数：__init__ 方法的参数可以是可选的，即可以为参数设置默认值。

🥇__str__() 方法

基本概念

__str__() 方法是对象的字符串表示方法，当使用内置的 str() 函数将对象转换为字符串，或者使用 print() 函数打印对象时，Python 解释器会自动调用该对象的 __str__() 方法。如果类中没有定义 __str__() 方法，Python 会使用默认的字符串表示，通常是类名和对象的内存地址。

语法结构

class ClassName:
    def __str__(self):
        # 返回对象的字符串表示
        return "对象的字符串描述"

代码示例

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

    def __str__(self):
        # 返回对象的字符串表示
        return f"Point(x={self.x}, y={self.y})"

# 创建 Point 类的实例
p = Point(3, 4)

# 直接打印对象
print(p)  # 输出: Point(x=3, y=4)

在这个示例中，Point 类定义了 __str__() 方法，该方法返回一个格式化字符串，包含对象的 x 和 y 属性值。当使用 print() 函数打印 p 对象时，Python 解释器会自动调用 __str__() 方法，并将返回的字符串输出，这样的输出对用户来说更加直观和易读。

使用场景

调试和日志记录：在调试代码或记录日志时，__str__() 方法可以提供对象的关键信息，方便开发者快速了解对象的状态。

用户交互：当需要向用户展示对象的信息时，__str__() 方法可以返回一个友好的字符串，提升用户体验。

🥇__del__() 方法（删除方法或析构方法）

基本概念

__del__() 方法会在对象的引用计数降为 0 且即将被垃圾回收机制销毁时自动调用。它的主要用途是在对象被销毁前执行一些清理工作，像关闭文件、释放网络连接、释放数据库连接等资源。

语法结构

class ClassName:
    def __del__(self):
        # 执行清理操作的代码
        print("对象即将被销毁，执行清理操作")

示例代码

class Person():
     # 构造函数__init__
     def __init__(self, name, age):
         self.name = name
         self.age = age
 
     # 析构⽅法__del__
     def __del__(self):
         print(f'{self}对象已经被删除')
# 实例化对象
p1 = Person('⽩⻣精', 100)
# 删除对象p1
del p1

注意事项

引用计数和垃圾回收机制

Python 使用引用计数来跟踪对象的引用情况，当对象的引用计数降为 0 时，对象就会被标记为可回收。不过，垃圾回收机制并不是实时运行的，所以 __del__ 方法的调用时机可能会有延迟。

总结：

__init__() ：初始化方法或者称之为“构造函数”，在对象初始化时执行，其主要作用就是在对象初 始化时，对对象进行初始化操作（如赋予属性）

__str__() ：对象字符串方法，当我们在类的外部，使用print方法输出对象时被触发，其主要功就

是对对象进行打印输出操作，要求方法必须使用return返回字符串格式的数据。

__del__() ：删除方法或者称之为“析构方法”，在对象被删除时触发（调用del删除对象或文件执行 结束后），其主要作用就是适用于关闭文件、关闭数据库连接等等。

                 好啦面向对象的基础讲到这里，下一篇就开始讲面向对象的三大特征

作者：花菜会噎住