面向对象编程篇（二）

熊猫Devin

已于 2024-03-27 20:10:23 修改

阅读量804

点赞数 20

分类专栏： python笔记文章标签： python 开发语言

于 2024-03-24 10:56:32 首次发布

本文链接：https://blog.csdn.net/d710055071/article/details/136983903

版权

python笔记专栏收录该内容

92 篇文章 7 订阅

订阅专栏

文章目录

__name__ 属性
__doc__属性
__bases__属性
__module__属性
__class__属性
__init__()函数
__new__()函数
__del__()函数

name 属性

在Python的类定义中，name 属性通常不是用来描述类本身的，而是用来描述类实例的。当我们讨论类的属性时，name 通常指的是类实例的 class.name，它表示实例所属的类的名字。

但是，如果你是在类的定义内部使用 name，并且没有显式地定义它，那么 name 将引用当前类的名字。这是因为在类定义内部，name 是一个内置属性，它表示当前类的名字。

下面是一个简单的例子，展示了如何在类定义中使用 name 属性：

class MyClass:
    def __init__(self):
        print(f"Instance of {self.__class__.__name__} created.")

# 创建 MyClass 的实例
obj = MyClass()

# 输出：Instance of MyClass created.

在这个例子中，当创建 MyClass 的实例时，init 方法内的 self.class.name 会输出 “MyClass”，即实例所属的类的名字。

另外，如果你在类的定义外部想要获取类的名字，你可以直接访问类的 name 属性：

class MyClass:
    pass

print(MyClass.__name__)  # 输出：MyClass

这里，MyClass.name 返回的是字符串 “MyClass”，它表示类的名字。

总结一下，name 属性在类定义中有两种常见的用法：

在类定义内部，name 表示当前类的名字。
在类定义外部，MyClass.name 表示类 MyClass 的名字。

在实例方法中，self.class.name 可以用来获取实例所属类的名字。

doc属性

在Python中，doc 是一个特殊的属性，用于存储类的文档字符串（docstring）。文档字符串是一个位于类、方法或函数定义开头的字符串，通常用于解释这个类、方法或函数的作用和用法。它可以通过在定义之后直接跟上一个被三引号（‘’’ 或 “”"）包围的字符串来设置。

下面是一个简单的例子，展示了如何在类中定义和使用 doc 属性：

class MyClass:
    """这是一个示例类的文档字符串。
    这个类用于演示 __doc__ 属性的用法。
    """

    def __init__(self):
        pass

# 访问类的 __doc__ 属性
print(MyClass.__doc__)

当你运行这段代码时，它会输出类的文档字符串，即：

这是一个示例类的文档字符串。
这个类用于演示 doc 属性的用法。

在类的实例方法中，你也可以通过 self.class.doc 来访问类的文档字符串。

class MyClass:
    """这是一个示例类的文档字符串。"""

    def show_doc(self):
        print(self.__class__.__doc__)

# 创建类的实例并调用方法
obj = MyClass()
obj.show_doc()

这段代码也会输出同样的文档字符串。

doc 属性对于编写文档和提供代码的自我解释非常有用。当你使用像 help() 函数或IDE的自动完成功能时，它们通常会显示这些文档字符串，以帮助开发者理解代码的功能和用法。

请注意，如果你没有为类、方法或函数提供文档字符串，那么 doc 属性的值将是 None。

bases属性

在Python中，bases 是一个类的属性，它返回一个包含类所有基类（父类）的元组。这个属性对于理解类的继承层次结构非常有用。如果一个类没有显式地继承任何基类，那么 bases 将返回一个只包含 object 的元组，因为所有的类都隐式地继承自 object 类（在Python 3中）。

下面是一个简单的例子，展示了如何使用 bases 属性：

class BaseClass:
    pass

class DerivedClass(BaseClass):
    pass

# 查看 BaseClass 的基类
print(BaseClass.__bases__)  # 输出：(<class 'object'>,)

# 查看 DerivedClass 的基类
print(DerivedClass.__bases__)  # 输出：(<class 'BaseClass'>,)

在这个例子中，BaseClass 没有显式地继承任何类，因此它的 bases 属性返回了包含 object 的元组。DerivedClass 继承自 BaseClass，因此它的 bases 属性返回了包含 BaseClass 的元组。

bases 属性通常用于元类编程和类反射，在这些情况下，你可能需要查看或修改一个类的继承层次结构。然而，在普通的类定义和使用中，你很少需要直接访问这个属性。

请注意，bases 是一个只读属性，你不能直接修改它来改变一个类的继承层次结构。如果你需要改变类的继承关系，你应该通过修改类定义来实现。

module属性

在Python中，__module__属性是一个内置的类属性，它表示类定义所在的模块的名字。这个属性通常用于反射和调试，帮助开发者确定类是从哪个模块加载的。

当类是在主程序（即脚本的顶层，不是在一个函数或方法内部）中定义时，__module__属性的值通常是"main"，表示这个类是在主模块中定义的。如果类是在一个导入的模块中定义的，那么__module__属性的值将是那个模块的名字。

下面是一个简单的例子，展示了__module__属性的用法：

假设我们有两个Python文件，module_a.py和module_b.py。

module_a.py的内容如下：

class MyClass:
    pass

module_b.py的内容如下：

import module_a

def show_module():
    print(module_a.MyClass.__module__)

show_module()

当我们运行module_b.py时，输出将是：

module_a

这表明MyClass类是在module_a模块中定义的。

如果我们直接在module_a.py中运行以下代码：

print(MyClass.__module__)

输出将会是：

__main__

这表示MyClass是在主模块中定义的，即直接在module_a.py脚本中定义的。

__module__属性在动态加载和实例化类时特别有用，特别是当你需要基于类的名字来查找和加载类时。例如，使用globals()或locals()函数结合__module__属性，你可以获取到定义类的模块的全局变量字典，进而从那里获取类对象。

请注意，__module__属性是由Python解释器自动设置的，通常不需要你手动去修改它。

class属性

在Python中，class 是一个实例属性，它指向实例所属的类。对于类对象本身，class 属性则指向其元类（metaclass）。

元类主要用于控制类的创建行为，它们通常用于实现如抽象基类、类装饰器、类属性继承等高级功能。大多数情况下，你不需要直接使用元类，除非你正在进行一些底层的Python编程或框架开发。

对于类实例来说，class 属性允许你查询或修改实例所属的类。然而，通常不建议直接修改实例的 class 属性，因为这可能会导致不可预见的行为和错误。

下面是一个简单的例子，展示了如何使用 class 属性：

class MyClass:
    pass

# 创建一个 MyClass 的实例
obj = MyClass()

# 使用 __class__ 属性来查看实例所属的类
print(obj.__class__)  # 输出: <class '__main__.MyClass'>

# 对于类对象本身，__class__ 指向其元类
print(MyClass.__class__)  # 输出: <class 'type'>

# 验证 obj 的类确实是 MyClass
print(obj.__class__ is MyClass)  # 输出: True

# 尝试修改 obj 的 __class__ 属性（不推荐这样做）
# obj.__class__ = AnotherClass
# 这通常会导致错误或不可预见的行为

在上面的例子中，我们创建了一个名为 MyClass 的类，并创建了一个该类的实例 obj。通过 obj.class，我们可以确认 obj 是 MyClass 的一个实例。同时，通过 MyClass.class，我们可以看到 MyClass 的元类是 type。

记住，虽然 class 属性是可访问的，但在大多数情况下，你应该避免修改它，除非你非常清楚修改它的后果。在Python中，类的继承、实例的方法和属性查找等行为都是基于 class 属性的，因此直接修改它可能会导致程序的行为变得不可预测。

init()函数

在Python中，init() 是一个特殊的方法，被称为类的构造函数或初始化方法。这个方法在创建类的新实例时自动调用，用于初始化实例的属性或执行其他必要的设置。

init() 方法通常接受 self 作为其第一个参数，self 代表类的实例本身。除了 self 之外，init() 还可以接受其他参数，这些参数在创建实例时由用户传递。

下面是一个简单的例子，展示了如何在Python类中使用 init() 方法来初始化实例属性：

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

# 创建Person类的实例
person1 = Person("Alice", 30)

# 访问实例属性
print(person1.name)  # 输出: Alice
print(person1.age)   # 输出: 30

在这个例子中，Person 类有一个 init() 方法，它接受两个参数：name 和 age。当创建 Person 类的实例时，这些参数的值被传递给 init() 方法，然后方法将这些值赋给实例的 name 和 age 属性。

init() 方法允许你在创建对象时设置对象的初始状态。这对于确保对象在使用前具有合理的默认状态或根据用户提供的参数进行配置非常有用。

你也可以在 init() 方法中执行其他初始化任务，比如调用其他方法、设置其他属性、进行必要的计算等。

请注意，init() 方法的名称是固定的，包括前后的双下划线。这是Python的约定，用于标识特殊方法。如果你在自己的代码中尝试定义一个不同名称的方法，它不会被视为类的构造函数。

new()函数

在Python中，new() 是一个静态方法，用于创建一个新的实例对象。它通常在创建对象时首先被调用，负责返回新创建的对象实例。new() 的主要作用是控制实例的创建过程，包括分配内存空间等低级操作。

在大多数情况下，你不需要自己定义 new() 方法，因为Python的内置机制会自动为你处理实例的创建。然而，在某些特殊情况下，如实现单例模式、自定义元类（metaclass）或者控制实例的创建过程时，你可能需要重写 new() 方法。

下面是一个简单的例子，展示了如何使用 new() 方法来控制实例的创建：

class Singleton:
    _instance = None

    def __new__(cls, *args, **kwargs):
        if not cls._instance:
            cls._instance = super(Singleton, cls).__new__(cls)
        return cls._instance

# 创建Singleton类的实例
instance1 = Singleton()
instance2 = Singleton()

# 检查是否创建了两个不同的实例
print(instance1 is instance2)  # 输出: True

在这个例子中，Singleton 类通过重写 new() 方法实现了单例模式，确保无论多少次尝试创建 Singleton 的实例，都只会返回一个相同的实例。

需要注意的是，new() 方法在调用时会接收类本身（通常命名为 cls）作为第一个参数，而不是实例对象（self）。这是因为 new() 方法在实例创建之前被调用，所以此时还没有实例对象可用。

另外，new() 和 init() 方法经常一起使用来创建和初始化对象。new() 负责创建实例并返回该实例，而 init() 负责初始化该实例的属性。通常情况下，你不需要重写 new()，除非你需要进行一些特殊的实例创建控制。大多数情况下，只需重写 init() 方法就足够了。

del()函数

在Python中，del()是一个特殊的方法，被称为析构函数或删除方法。这个方法在对象的引用计数减少到0时调用，也就是说，当对象不再被引用，且垃圾回收机制准备回收其占用的内存时，del()方法会被自动执行。它允许你在对象被销毁之前执行一些清理操作，如关闭文件、释放网络资源等。

需要注意的是，Python的垃圾回收机制并不保证__del__()方法会在对象被销毁时立即调用。实际上，Python的垃圾回收机制会尽可能地延迟对象的销毁，以优化内存使用。因此，del()方法的行为并不是完全可预测的，通常不推荐在一般的编程中使用这个方法。

下面是一个简单的例子，展示了如何在Python类中使用__del__()方法：

class MyClass:
    def __init__(self, name):
        self.name = name
        print(f"Object {self.name} created.")

    def __del__(self):
        print(f"Object {self.name} destroyed.")

# 创建MyClass的实例
obj = MyClass("example")

# 删除obj的引用，触发__del__()方法
del obj

# 输出可能如下，但请注意__del__()的调用不是立即的
# Object example created.
# Object example destroyed.