Python模块间导入变量的常见方式有三种：import module、from module import name和from module import 。最推荐使用import module形式，它通过模块名访问变量，避免命名冲突；from module import name可直接使用变量名，但可能引发覆盖问题；不建议使用from module import ，因其易导致命名空间混乱。导入的是对象引用而非副本，修改可变对象（如列表、字典）会影响原模块，而不可变对象（如数字、字符串）的修改仅在局部生效。为避免命名冲突，应优先使用模块前缀导入或as别名机制；对于循环引用，需重构代码、提取公共依赖或采用延迟导入等策略，确保模块间依赖清晰合理。
Python的模块化设计，无疑是其强大之处。当我们在一个模块中需要用到另一个模块里定义的变量时，最直接、也最常见的方法就是利用
import
在Python中，从一个模块导入另一个模块的变量，核心在于
import
最常见的做法有两种：
导入整个模块，然后通过模块名访问变量。
立即学习“Python免费学习笔记（深入）”；
# module_a.py my_variable = "Hello from Module A" another_number = 123 # module_b.py import module_a print(module_a.my_variable) # 输出: Hello from Module A print(module_a.another_number) # 输出: 123
这种方式的好处是清晰明了，你知道变量来自哪个模块，有效避免了命名冲突。
从模块中直接导入特定的变量。
# module_a.py my_variable = "Hello from Module A" another_number = 123 # module_b.py from module_a import my_variable, another_number print(my_variable) # 输出: Hello from Module A print(another_number) # 输出: 123
这种方式让你可以直接使用变量名，代码看起来更简洁。但如果导入的变量名与当前模块中已有的变量名冲突，就会覆盖掉当前模块的变量。
还有一种不推荐的做法是
from module_a import *
当我们谈论Python模块间导入变量，实际上主要就是围绕
import
首先，最基础且最推荐的，是
import module_name
module_name.variable_name
# settings.py
DEBUG = True
DATABASE_URL = "sqlite:///db.sqlite3"
ADMIN_EMAIL = "admin@example.com"
# main.py
import settings
print(f"Debug mode: {settings.DEBUG}")
print(f"Database URL: {settings.DATABASE_URL}")这种方式的优点在于，它提供了明确的命名空间，一眼就能看出
DEBUG
settings
其次，是
from module_name import variable_name
# constants.py
PI = 3.14159
GRAVITY = 9.81
# calculations.py
from constants import PI, GRAVITY
radius = 5
area = PI * (radius ** 2)
print(f"Area: {area}")这种方法让代码看起来更简洁，特别是当你只需要模块中少数几个变量时。但缺点也很明显，如果
constants
PI
calculations
as
from constants import PI as circle_pi
最后，就是
from module_name import *
# utils.py def add(a, b): return a + b VERSION = "1.0" _internal_var = "hidden" # 不会被导入 # app.py from utils import * print(add(2, 3)) # 输出: 5 print(VERSION) # 输出: 1.0 # print(_internal_var) # 会报错 NameError
我个人强烈不推荐在生产代码中使用
from module import *
*
这是一个非常关键的问题，也是很多Python初学者容易混淆的地方。在Python中，变量本质上是“名字”，它们绑定到内存中的“对象”。当你从一个模块导入变量时，你导入的不是变量的值的副本，而是对那个对象的引用。这意味着，导入的变量和原始模块中的变量，都指向内存中的同一个对象。
理解这一点，需要区分Python中对象的可变性（mutable）和不可变性（immutable）。
不可变对象（Immutable Objects）：例如数字（int, float）、字符串（str）、元组（tuple）。当你修改一个不可变对象时，实际上是创建了一个新的对象，并将变量名重新绑定到这个新对象上。
# module_a.py
my_number = 10
my_string = "original"
# module_b.py
from module_a import my_number, my_string
print(f"Before modification (module_b): number={my_number}, string={my_string}")
# 尝试修改 my_number 和 my_string
my_number = 20 # 实际上是 module_b 中的 my_number 重新绑定到新对象 20
my_string += "_modified" # 实际上是 module_b 中的 my_string 重新绑定到新字符串对象
print(f"After modification (module_b): number={my_number}, string={my_string}")
# 验证 module_a 中的变量是否改变
# 假设在 module_b 中能访问 module_a 的原始变量，但通常需要重新导入或通过其他方式验证
# 为了演示，我们直接在 module_a 中打印如果你在
module_b
module_a
module_a.my_number
10
module_a.my_string
"original"
my_number = 20
module_b
20
module_b
my_number
module_a
my_number
10
可变对象（Mutable Objects）：例如列表（list）、字典（dict）、集合（set），以及自定义的类实例。当你修改一个可变对象时，你是在修改对象本身的内容，而不是创建新对象。由于导入的变量和原始模块的变量都指向同一个对象，所以对其中一个的修改会影响到另一个。
# module_a.py
my_list = [1, 2, 3]
my_dict = {"a": 1, "b": 2}
# module_b.py
from module_a import my_list, my_dict
print(f"Before modification (module_b): list={my_list}, dict={my_dict}")
my_list.append(4) # 修改列表对象本身
my_dict["c"] = 3 # 修改字典对象本身
print(f"After modification (module_b): list={my_list}, dict={my_dict}")
# 如果在 module_a 中再次访问 my_list 和 my_dict，它们的值会是：
# my_list = [1, 2, 3, 4]
# my_dict = {"a": 1, "b": 2, "c": 3}在这种情况下，
module_a
my_list
my_dict
import copy; my_list_copy = copy.deepcopy(my_list)
总的来说，理解Python的引用机制和对象的不可变性/可变性是编写健壮代码的基础。当你导入一个变量时，请记住你拿到的是一个引用，对可变对象的修改将是全局可见的。
模块化编程的优势在于解耦和复用，但如果处理不当，也可能引入一些棘手的问题，比如命名冲突和循环引用。这些问题虽然看起来不同，但都指向了模块间依赖管理的重要性。
避免命名冲突：
命名冲突发生在两个或更多个模块中定义了同名变量（或函数、类），并且这些同名实体被导入到同一个命名空间时。
使用 import module_name
module_name.variable_name
# config.py
PORT = 8000
# network.py
PORT = 9000
# app.py
import config
import network
print(f"Config port: {config.PORT}") # 输出: Config port: 8000
print(f"Network port: {network.PORT}") # 输出: Network port: 9000这种方式虽然每次访问变量时多敲几个字符，但带来的清晰度和安全性是值得的。
使用 as
from ... import ...
as
# module_a.py
value = 100
# module_b.py
value = 200
# main.py
from module_a import value as a_value
from module_b import value as b_value
print(f"Value from A: {a_value}") # 输出: Value from A: 100
print(f"Value from B: {b_value}") # 输出: Value from B: 200这提供了一种灵活的解决方案，让你在保持代码简洁的同时，也能避免冲突。
*避免使用 `from module import `：** 我前面已经强调过，这种“通配符”导入是命名冲突的温床。它会将所有公共名称一股脑地导入当前命名空间，如果其中有与当前模块或已导入模块冲突的名称，就可能导致意想不到的覆盖。在任何严肃的项目中，都应该避免这种做法。
避免循环引用问题：
循环引用（Circular Import）是Python模块化设计中一个比较隐蔽且令人头疼的问题。它发生在模块A导入模块B，同时模块B又导入模块A时。当Python解释器尝试加载这样的模块时，会陷入一个未完成的加载状态，导致某个模块在被完全定义之前就被引用，从而引发
AttributeError
# module_a.py
import module_b
def func_a():
print("Inside func_a")
module_b.func_b()
# module_b.py
import module_a # 这里会出问题
def func_b():
print("Inside func_b")
# module_a.func_a() # 如果这里调用，可能导致未定义错误当你尝试运行
module_a.py
module_b.py
module_a
import module_b
module_b
import module_a
module_a
module_b
module_a
解决循环引用，通常需要重新审视你的模块设计，这往往是模块职责不清或依赖关系混乱的信号。
重构代码，解耦模块： 这是最根本的解决方案。如果两个模块互相依赖，很可能意味着它们承担了过多的职责，或者它们之间存在一个共同的、可以被提取到第三个独立模块中的依赖。
延迟导入（Lazy Import）： 在某些特定情况下，如果循环依赖无法通过重构完全消除，可以考虑将导入语句放在函数内部。这样，模块只有在函数被调用时才会被导入，从而推迟了依赖的解析。
# module_a.py
def func_a():
import module_b # 延迟导入
print("Inside func_a")
module_b.func_b()
# module_b.py
def func_b():
import module_a # 延迟导入
print("Inside func_b")
# module_a.func_a() # 避免在这里直接调用，否则仍然可能导致循环调用这种方法虽然能解决循环导入的问题，但会稍微牺牲代码的可读性，并且可能会在运行时才暴露问题，而不是在模块加载时。所以，它通常被视为一种权宜之计，而非最佳实践。
使用类型提示（Type Hinting）的字符串引用： 在Python 3.7+版本中，对于类型提示，你可以使用字符串字面量来引用尚未完全加载的类型，这在处理循环引用时非常有用，因为它只在运行时解析类型。但这主要用于类型提示，而不是直接导入变量。
我个人的经验是，循环引用往往是代码设计“味道”不好的一个强信号。与其寻找巧妙的规避方法，不如花时间重新梳理模块间的职责和依赖关系。一个清晰、合理的模块结构，不仅能避免这类问题，还能让代码更易于理解、测试和维护。
以上就是python中怎么在一个模块中导入另一个模块的变量_Python模块间变量导入方法的详细内容，更多请关注php中文网其它相关文章！
python怎么学习？python怎么入门？python在哪学？python怎么学才快？不用担心，这里为大家提供了python速学教程(入门到精通)，有需要的小伙伴保存下载就能学习啦！
Copyright 2014-2025 https://www.php.cn/ All Rights Reserved | php.cn | 湘ICP备2023035733号
495
收藏
