如何在 Python 中从另一个文件导入类？

2025 年 1 月 5 日 | 12 分钟阅读

导入类简介

在 Python 编程领域，类是面向对象编程 (OOP) 的基础。它们封装了信息和实用性，实现了高效的代码组织、可重用性以及复杂框架的执行。随着项目复杂性和范围的增加，维护结构良好的代码库变得至关重要。这就是从外部记录中导入类的最常见方式，它成为一种重要的实践。

理解 Python 中的类

在 Python 中，类是创建对象的蓝图。它定义了描述这些对象的属性（特性）和行为（方法）。通过类，开发人员可以建模现实世界的实体并创建这些模型的实例，从而实现完美而有效的代码设计。

导入类对于模块化设计的重要性

增强模块化：将代码分解成更小、独立的单元，促进了模块化。导入类考虑了功能在不同文档中的分发，从而便于维护和理解。

代码可重用性和可扩展性：导入的类可以在项目的不同部分或不同项目中重复使用，从而促进代码可重用性和适应性。

改进可维护性和协作：通过将类分离到不同的文档中，开发人员可以更有效地维护和更新特定部分，从而促进团队成员之间的协作。

Python 中导入类的重要性

结构化代码组织：将类外部化到独立的文档中有助于保持清晰和结构化的代码库，从而便于导航和感知。

通过可重用性提高效率：导入类允许开发人员通过重用现有和清晰定义的功能来避免重复代码。

促进协作：导入类的实践通过促使不同的团队成员同时处理不同的部分来促进协作。

综合指南概述

本指南旨在作为掌握 Python 中导入类的综合资源。它将深入探讨重要的导入标点符号，演示从外部记录中导入类的技术，探索管理类导入的最佳实践，解决常见的挑战和陷阱，并介绍动态类导入的高级方法。

Python 导入基础

Python 的导入系统是访问程序中外部代码、模块和类的途径。理解导入语句及其句子结构的基础知识对于无缝集成外部功能至关重要。

Python 导入语句简介

导入语句概述：讨论 Python 中导入语句的目的和实用性。

导入在隔离设计中的作用：解释导入如何有助于创建度量和有效的代码库。

导入语句的语法和形式

基本导入：详细说明使用 `import module_name` 导入整个模块的语言结构。

带别名的导入：解释使用 `import module_name as pseudonym` 导入时创建别名的标点符号。

导入明确的事物：展示使用 `from module_name import item1, item2` 导入选定事物的语法。

导入所有事物：讨论使用 `from module_name import *` 从模块导入所有事物。

区分导入模块与导入类

导入模块：定义导入整个模块并访问其对象的最常见方式。

导入类：强调如何从模块导入明确的类以实现指定用途。

导入语句的最佳实践

清晰度和意义：强调清晰导入声明对代码清晰度的重要性。

避免歧义：讨论特殊情况导入的陷阱和避免它们的最佳实践。

组织导入语句：建议将导入语句放在脚本或模块的开头以求清晰。

使用导入的模块和类

启动导入的类：演示如何创建导入类的对象以供使用。

访问模块功能：演示从导入的模块访问功能或属性。

Python 的内置模块和 sys.path

标准库：介绍 Python 广泛的标准库以及如何导入它们。

理解 sys.path：解释模块扫描路径的概念，用于查找导入的模块。

创建要导入的类

Python 中的类创建

Python 中的类作为创建具有明确属性和行为的对象的蓝图。该过程涉及定义一个类结构，该结构包含对该数据进行操作的数据和方法。

类创建基础

在 Python 中，类使用 `class` 关键字后跟类名来定义。类通常包括属性（变量）和方法（功能）。

面向对象原则

封装：将数据和方法封装在一个类中，以隔离访问并促进数据完整性。

继承：从现有类获取新类以重用代码和扩展功能。

多态：不同类的对象共享一个共同的接口，从而实现灵活的代码设计。

设计用于导入的类

创建用于导入的类涉及为特定实体或功能开发蓝图。

类定义

我们应该考虑一个建模基本个人信息的 `Individual` 类的示例。

class Individual:
def __init__(self, name, age):
self.name = name
self.age = age
def greet(self):
return f"Hello, my name is {self.name} and I'm {self.age} years old."

封装和模块化

`Individual` 类封装了数据（姓名、年龄）和行为（欢迎策略），确保其功能保留在类中。

示例用例

例如，`Individual` 类可以表示社交网络应用程序中的个人，封装客户端信息和交互。

类文件的结构

文件命名约定

包含类的记录的命名对于清晰度和一致性至关重要。遵循命名约定对于轻松识别和导入至关重要。

有意义的命名

以其包含的类命名记录，例如 `person.py` 用于 `Individual` 类，确保快速识别类文档的用途。

使用下划线或连字符

考虑遵循 Python 的记录命名约定，使用下划线 (`person_info.py`) 或连字符 (`individual-info.py`) 以提高可读性。

类文件组织

整理类文件中的内容有助于更好地理解和维护代码库。

清晰的文档

包含描述类、其目的、属性和方法的注释或文档字符串。这有助于一眼看出类的功能。

# person.py
class Individual:
"""A class addressing a person with essential individual information."""
def __init__(self, name, age):
self.name = name
self.age = age
def greet(self):
"""Produces a customized greeting."""
return f"Hello, my name is {self.name} and I'm {self.age} years old."

代码的逻辑分组

逻辑地安排类结构，确保相关的方法和属性组合在一起，从而提高可理解性。

模块级语句

将任何模块级语句（例如导入、全局常量）正确放置在文档中，确保它们在类定义之前，以实现清晰的分隔。

实现和代码结构

类属性和方法

在类中定义属性（姓名、年龄）和方法（`__init__`、`greet`）封装了与 `Individual` 相关的数据和功能。

构造函数方法

`__init__` 方法在启动时初始化对象的州。它接收参数来设置起始属性值。

其他方法和功能

包含其他方法以扩展类的功能，遵循将相关功能保留在类中的原则。

将类保存到单独的文件中

单独文件存储的优点

将 `Individual` 类保存在其专用文档 (`person.py`) 中，可保持代码隔离，并可轻松导入到其他 Python 内容或模块中。

文件位置和导入

确保类文件 (`person.py`) 位于 Python 解释器可访问的目录中，以便顺利导入。

示例代码演示

为了更好地理解为导入而设计的类的执行和结构，我们应该考虑一个更详细的 `Individual` 类及其记录关联的演示。

py 文件结构

# person.py
class Individual:
    def __init__(self, name, age):
        self.name = name
        self.age = age
    def greet(self):
        return f"Hello, my name is {self.name} and I'm {self.age} years old."
# Extra functionalities can be added here

类解释

Person 类：此类包含个人的基本信息。

属性：`__init__` 方法为每个 `Individual` 对象初始化名称和年龄属性。

greet() 方法：`greet()` 方法使用个人的姓名和年龄返回个性化问候语。

已创建类的重要性

`Individual` 类作为可以导入到其他 Python 内容或模块中的基本实体。其结构良好的设计和封装考虑了

跨项目的可重用性

通过将 `Individual` 类保存在不同的记录 (`person.py`) 中，它变得可以在不同的项目中重用。任何需要与个人相关功能的 Python 脚本都可以简单地导入此类。

模块化代码组织

不同的类记录结构增强了代码组织，促进了特定的设计原则。它将 `Individual` 实体分离，使代码库更具可操作性且更易于导航。

可伸缩性和可扩展性

随着项目的进展，可以轻松地将额外功能和方法集成到 `Individual` 类中，而不会影响代码库的其他部分。这种可扩展性确保了类适应不断变化的需求。

从另一个文件导入类

从外部记录中导入类可以在 Python 内容或模块中利用其功能。理解导入类的语法和方法对于无缝地结合外部功能至关重要。

导入类的详细解释

类导入的基本语言结构

使用 `import`：导入包含理想类的整个模块。

使用 `from`：直接导入明确的类，而无需每次都提及模块名称。

导入特定类

使用 `import`：从另一个文件/模块导入类的句子结构。

使用 `from`：直接导入特定类，无需使用模块名限定。

使用代码片段和示例进行演示

从不同的记录中导入类

导入解释：展示如何使用 import 语句导入类，在访问类时包含模块名。

`from ... import` 解释：说明如何直接导入类，在访问类时省略模块名。

使用导入的类

启动：概述创建导入类的对象。

访问类策略和特性：演示如何使用方法和访问导入类的属性。

为导入的类使用别名

导入期间分配假名

带别名的导入：清晰解释如何为导入的类分配假名，以求简洁并避免命名冲突。

关联导入的示例

应用假名：提供代码示例，演示在导入类时使用假名以求清晰和简洁。

使用导入的类管理命名空间

命名空间影响和目标

避免命名空间冲突：强调使用新颖名称的重要性，以防止在导入不同类时发生冲突。

命名空间管理最佳实践

特定导入：强调只导入重要类以保持干净的命名空间。

导入类的最佳实践

组织导入语句

将导入放在开头：强调将导入声明放在脚本或模块开头以求清晰的惯例。

避免通配符导入

反对通配符的理由：讨论为什么不鼓励使用通配符导入（`from module import *`），因为它会污染命名空间。

示例

使用别名导入类

# person.py (Module containing the Person class)
class Person:
    def __init__(self, name, age):
        self.name = name
        self.age = age
    def greet(self):
        return f"Hello, my name is {self.name} and I am {self.age} years old."
# main.py (Using the imported Person class with an alias)
from person import Person as P
# Creating a Person object using the alias
alice = P("Alice", 30)
print(alice.greet())

输出

Hello, my name is Alice and I am 30 years old.

说明

`person.py`

类定义

在 `person.py` 中定义一个 `person` 类。
包含一个 `__init__` 方法，用于使用姓名和年龄初始化 `Individual` 对象。
提供一个 `greet` 方法，根据姓名和年龄生成个性化问候语。

`main.py`

导入语句

将 `Individual` 类从 `individual` 模块导入为 `P`。

对象创建

使用别名 `P` 创建一个名为 `alice` 的 `Individual` 对象。

为姓名和年龄分别传递参数“Alice”和 30。

方法调用

在 `alice` 对象上调用 `greet` 方法。

示例 2

相对导入

# my_package/
# ├── __init__.py
# ├── parent_module.py
# └── child_module.py
# parent_module.py (Sibling modules within my_package directory)
from .child_module import ChildClass  # Relative import
class ParentClass:
    def __init__(self):
        self.child = ChildClass()
# child_module.py
class ChildClass:
    def __init__(self):
        pass
# main.py (Outside the my_package directory)
from my_package.parent_module import ParentClass  # Absolute import
# Using the ParentClass and its relation to ChildClass via relative import
parent = ParentClass()
print(parent.child)  # This will print the memory location of the child object

输出

<my_package.child_module.ChildClass object at 0x...>

说明

`parent_module.py`

相对导入

使用相对导入 (`from .child_module import ChildClass`) 从 `kin` 模块 `child_module.py` 导入 `ChildClass`。

ParentClass 定义

定义一个带 `__init__` 方法的 `ParentClass`。

在 `__init__` 方法中将 `ChildClass` 对象启动为 `self.child`。

`child_module.py`

ChildClass 定义

在此模型中定义一个没有特定功能 `ChildClass`。

`main.py`（在 `my_package` 索引之外）

绝对导入

使用绝对导入 (`from my_package.parent_module import ParentClass`) 从 `my_package` 索引中的 `parent_module` 导入 `ParentClass`。

使用类

创建一个名为 `parent` 的 `ParentClass` 实例。

访问 `parent` 对象的 `youngster` 质量。

示例 3

处理循环依赖

# module_a.py
import module_b  # Import inside functions to avoid circular imports
def func():
    from module_b import something
    print("Calling func() from module_a")
    something()  # Use 'something' here
# module_b.py
import module_a
def something():
    print("Inside something() from module_b")
module_a.func()  # Call the function after the import to avoid circularity

输出

Calling func() from module_a
Inside something() from module_b

说明

`module_a.py`

导入 `module_b`

在顶层导入 `module_b`，以便在其功能中使用其内容。

`func()` 定义

在 `module_a` 中定义一个功能 `func()`。

在 `func()` 内部，使用本地导入语句从 `module_b` 导入一些内容。

调用 `something()` 并打印一条消息，指示 `func()` 的执行。

`module_b.py`

导入 `module_a`

导入 `module_a`。

`something()` 定义

在 `module_b` 中定义一个功能 `something()`。

打印一条消息，指示 `something()` 的执行。

执行流程

`module_a.py` 导入 `module_b`，定义 `func()`，它导入并调用 `module_b` 中的 `something()`。

`module_b.py` 导入 `module_a`。

通过在导入语句之后调用 `module_a.func()` 来缓解循环导入。

高级导入实践

导入钩子

理解导入钩子

导入钩子的解释，允许自定义 Python 中的导入行为。
强调它们在捕获和修改导入周期中的作用。

实施自定义导入钩子

演示自定义导入钩子的创建，以处理独特的导入要求。
示例说明如何注册和使用自定义导入钩子。

`importlib` 模块

`importlib` 简介

`importlib` 模块概述，提供用于自动导入任务的实用程序。

解释其在自动执行导入相关功能中的作用。

`importlib` 的使用

演示 `importlib` 功能用于动态导入操作的示例。

表示 `importlib` 促进动态模块堆叠的情况。

动态导入

动态导入策略

解释动态导入，允许根据运行时条件导入模块。
强调根据客户端信息或配置以强力方式堆叠模块的用例。

动态导入的实例

演示动态导入有利的情况，例如模块框架或有条件堆叠。
代码示例演示如何根据运行时变量或条件有条件地导入模块。

高级导入优化

导入时间分析和增强

检查 Python 应用程序中分析和增强导入时间的技术。
通过优化和惰性堆叠进一步提高导入性能的技术。

导入缓存和模块重载

导入缓存系统概述及其对执行的影响。
模块重载技术及其含义的解释。

命名空间管理和导入最佳实践

命名空间和模块级扩展

理解 Python 中的命名空间

命名空间作为标识符容器的解释及其在组织 Python 名称中的作用。

模块级扩展

讨论模块中标识符的范围以及命名空间如何在模块级别建立。

封装和隔离

Python 中的封装

强调封装的概念，强调类和模块中代码的关联。
讨论封装如何支持信息隐藏和维护干净的连接点。

模块化原则

解释模块化原则，将代码分解为更小、更合理的组件。
强调隔离对代码组织、可重用性和维护的优势。

导入关联的最佳实践

组织导入语句

在 Python 脚本和模块中组织导入声明的最佳实践。
讨论将导入放在记录开头以求清晰和实用性的重要性。

避免通配符导入

解释通配符导入 (`from module import *`) 的缺点并建议不要使用它们。
强调明确导入对代码透明度的重要性。

导入大型项目

处理大型代码库中的导入

在大型 Python 项目中管理导入和命名空间的策略。
跨不同模块或包组织导入的策略，以实现更好的代码组织。

导入优化方法

优化大型项目中的导入的高级策略，包括惰性堆叠和导入缓存。
用于识别和解决导入相关性能瓶颈的分析工具和方法。

下一主题如何使用 pandas 将 excel 文件导入 python

如何在 Python 中从另一个文件导入类？

导入类简介

Python 导入基础

创建要导入的类

已创建类的重要性

模块化代码组织

可伸缩性和可扩展性

从另一个文件导入类

导入类的详细解释

使用代码片段和示例进行演示

为导入的类使用别名

使用导入的类管理命名空间

导入类的最佳实践

示例

高级导入实践

高级导入优化

命名空间管理和导入最佳实践

联系信息

关注我们

教程

面试题

在线编译器

Python

Java

.Net Framework

AI, ML and Data Science

Cloud Technology

B.Tech and MCA

Web Technology

PHP

Software Testing

Technical Interview

Java Interview

Python

Web Interview

Database Interview

B.Tech / MCA

Important Interview

Software Testing Interview

Company Interviews

Online Compilers

Multiple Choice Questions

其他

如何在 Python 中从另一个文件导入类？

导入类简介

Python 导入基础

创建要导入的类

已创建类的重要性

模块化代码组织

可伸缩性和可扩展性

从另一个文件导入类

导入类的详细解释

使用代码片段和示例进行演示

为导入的类使用别名

使用导入的类管理命名空间

导入类的最佳实践

示例

高级导入实践

高级导入优化

命名空间管理和导入最佳实践

相关帖子

Python HTTP认证

如何从GitHub仓库安装Python包

Python中的Wavio模块

3个示例展示Python Altair不仅仅是一个数据可视化库

Python String removeprefix() 方法

5个常见的Python错误及避免方法

在Python中将语音转换为文本，将文本转换为语音

如何为Python函数设置默认参数值

Python tempfile模块

Python Dictionary update()方法

订阅 Tpoint Tech

联系信息

关注我们

教程

面试题

在线编译器