python import变量会运行被引用文件的主程序

最新推荐文章于 2024-09-08 07:24:29 发布
原创 最新推荐文章于 2024-09-08 07:24:29 发布 · 4k 阅读 · 7 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
文章标签：

#python

本文探讨了Python中__name__=__main__的作用，解释了如何通过它控制模块导入时的行为，防止不必要的代码执行。当一个文件作为主程序运行时，__name__变量会被设为'__main__'，而当文件被导入到其他模块时，__name__将保持其原始值，从而可以区分直接运行和导入场景。

摘要生成于 C知道 ，由 DeepSeek-R1 满血版支持， 前往体验 >

在学习测试__name__=__main__语句时，发现 从.py引入某个变量或者方法，会导致所有主函数上的方法全部运行

DEF.py

在没有设置__name__==__main__情况下，对DEF.PY进行引用

111.py      import PI变量 

发现此时被import的DEF.py中所有主函数也被执行(但不代表所有DEF.py中的函数和变量被引入)

如果添加__name__==__main__

则会

只运行DEF.py中不在__name__==__main__的主程序代码和111.py中的代码

 

python全局变量的使用
weixin_44523262的博客
06-23 860
python全局变量在导入时需要注意的内容
python import包导出变量_python基础教程:包的创建及导入-阿里云开发者社区
weixin_39949776的博客
12-04 622
包是一种通过用“带点号的模块名”来构造 Python 模块命名空间的方法。 例如，模块名 A.B 表示 A 包中名为 B 的子模块。正如模块的使用使得不同模块的作者不必担心彼此的全局变量名称一样，使用加点的模块名可以使得 NumPy 或 Pillow 等多模块软件包的作者不必担心彼此的模块名称一样。假设你想为声音文件和声音数据的统一处理，设计一个模块集合(一个“包”)。由于存在很多不同的声音文件格...
用了这么久我才知道 原来python在import的时候就会把被import的那个文件的全局代码先执行一遍
qq_59039905的博客
09-03 609
用了这么久我才知道 原来python在import的时候就会把被import的那个文件的全局代码先执行一遍。
python调用其他py文件的变量，为什么总会把这个调用的py文件先运行一遍？
hopezg的博客
02-25 588
例如本图中我导入了Function模块，只是想利用其中的一个函数favorite_book，但是运行时却发现运行窗口上先是把Function运行了一遍，然后才运行我当前的文件。
import是引进外部函数吗_你必须要知道的Python中的main函数
weixin_39844549的博客
12-20 513
在很多开发语言中，都有一个叫做mian的主函数，这个函数一般都是程序的入口，当程序启动时，首先执行这个函数。比如C#语言中的main函数长这个样子。static void Main(string[] args){ Console.WriteLine("Hello World!");}在Python中，有时候可以看到这样的代码if __name__=="__main__":，看起来是不是有点像其他语...
py文件作为模块被import和作为py文件运行时，代码的执行顺序
DecafTea的博客
02-12 1448
转载自cn_XuYang 1.python程序是顺序执行的，而C++中main()是程序的入口 例如以下代码，结果如注释所示，这里虽然有个main函数，但是最先输出的不是“main”而是“test1”： #test1 print ("test1") def Fun(): print ("Fun") def main(): print ("main") Fun() if __name__ == '__main__': main() ''' test1 main Fun '''
python re import_完全搞懂Python 中的 import 与 from import
weixin_29580355的博客
01-28 1038
如下文章来源&做者:青南(谢乾坤)html 摄影：产品经理；kingname 的第一套乐高正则表达式你好，我是谢乾坤，前网易高级数据挖掘工程师。现任微软最有价值专家(Python 方向)，有6年 Python 开发经验，善于解决各类业务场景下的棘手问题，进一步提高代码质量。函数对很多 Python 初学者来讲，Python 导入其余模块的方式让他们很难理解。何时用import xxx？何时...
python 全局变量的import机制介绍
09-21
### Python全局变量的Import机制详解 #### 背景与目的 在Python的学习过程中，特别是在探索设计模式的应用，比如工厂模式的实践中，我们可能会遇到如何使用全局变量来模拟C++中宏的功能，以便实现服务的自动注册。...
Python跨文件全局变量的实现方法示例
09-21
3. 最后，创建一个主程序`main.py`，导入这两个文件，执行相应的操作： ```python # main.py import a import b ``` 运行`main.py`，将会输出`cc: 90`，这表明全局变量已经在不同文件之间成功地共享了。 这种方法的...
python-env:读取 .env 文件 (key->value) 设置值作为环境变量
06-03
.env文件是一个文本文件，其中包含将添加到应用程序环境变量中的值。 该文件使用以下格式； 每行有一个键=值对。 安装： 通过 pip 安装： pip install python-env或通过下载包。 运行python setup.py 。 用法： ...
Python中py文件引用另一个py文件变量的方法
09-20
下面小编就为大家分享一篇Python中py文件引用另一个py文件变量的方法，具有很好的参考价值，希望对大家有所帮助。一起跟随小编过来看看吧
python引入文件并执行_Python引用（import）文件夹下的py文件的方法
weixin_39820136的博客
11-20 522
Python的import包含文件功能就跟PHP的include类似，但更确切的说应该更像是PHP中的require，因为Python里的import只要目标不存在就报错程序无法往下执行。要包含目录里的文件，PHP中只需要给对路径就OK。Python中则不同，下面来看看这个例子。目录结构：a.py 要 import dir目录下的 b.py 文件。a.py代码如下：# coding=utf-8"i...
python导入函数，其他语句发生执行
qq_51574958的博客
02-24 390
这是因为python是脚本语言，import number会扫描number的所有语句，当遇到语句时会发生执行。所以我们如果把语句写入。所以我们执行test，只有在test中__name__ = main,当进入number扫描时，我们引入number文件中的Net(神经网络)，但是发现他执行了number文件的训练代码。当我们执行入口是当前文件时__name__ = main,其他情况下为文件名。= number, 不等于__main__ 所以不会执行语句。会发现我们导入Net类，却执行了这里面的语句。
在Python中从另一个文件导入变量
09-08 1201
print(variable_a) # 输出 "Hello from Module A"print(variable_a) # 输出 "Hello from Module A"function_a() # 输出 "Function in Module A"function_a() # 输出 "Function in Module A"print(a) # 输出 "Hello from Module A"f() # 输出 "Function in Module A"
Python中import的用法
do it
03-06 2万+
Python用了快两年了吧，其中有些东西一直是稀里糊涂地用，import便是我一直没有明白的东西。曾经有过三次解决它的机会，我都因得过且过、一拖再拖而没能化敌为友。今天下午，它又给了我一次机会，我想我还是从了它的心愿吧。 故事是从这篇台湾同胞的博客（Python 的 Import 陷阱）开始的，然后又跳到了Python社区的PEP 328提案（PEP 328 -- Imports: Multi-...
Python中py文件引用另一个py文件变量
热门推荐
mingyang_wang的博客
01-24 7万+
最近自己初学Python，在编程是遇到一个问题就是，怎样在一个py文件中使用另一个py文件中变量，问题如下： demo1代码import requests r = requests.get("http://www.baidu.com") r.encoding = r.apparent_encoding demo = r.text demo beauful1代码：from bs4 import Be
python中的import模块引用（二）
知易行难的学习笔记
10-17 518
我们可以使用from import来将指定模块里所有变量（包含变量名）导入进来  #继续采用上面的路径# from first.first_1.a1 import * print (a + b * c - d + e * f)   如果不想引用模块的所有变量，可以直接在模块中设置__all__ =，或者直接引入需要的变量 #__all__ =方法# #路径为first\first_1\...
python中如何正确使用import
Greenovia的博客
02-28 2万+
python中的模块、包、库 模块： 就是.py文件，里面定义了一些函数和变量，需要的时候就可以导入这些模块 包： 在模块之上的概念，为了方便管理而将文件进行打包。 一个文件夹下必须要有_init_.py这个文件才会被识别为包。 包目录下第一个文件便是 init.py，然后是一些模块文件和子目录 假如子目录中也有 init.py，那么它就是这个包的子包了 常见的包结构：...
python import module时会将全局变量引入码
最新发布
07-29
<think>我们正在讨论的是Python中模块导入时全局变量的行为。用户的问题直接指向：当使用`import module`时，是否会导入模块中的全局变量？根据提供的引用和Python的知识，我们可以这样回答： 核心答案：是的，当使用`import module`导入一个模块时，会将该模块中定义的全局变量（在模块顶层定义的变量）作为模块对象的属性导入。因此，可以通过`module.variable_name`来访问这些全局变量。 但是，需要注意以下几点： 1. **不可变类型与可变类型**：如果全局变量是不可变类型（如整数、字符串、元组），那么在导入模块后，如果尝试在导入模块中直接修改该变量（例如，使用`module.variable = new_value`），这只会修改当前模块中对该模块的引用，而不会影响原始模块的变量值。同时，如果原始模块中的其他函数依赖于该变量，它们仍然会使用原始值。这是因为不可变类型的修改实际上是创建了一个新的对象。 2. **可变类型**：如果全局变量是可变类型（如列表、字典），那么通过导入模块后得到的引用去修改其内容（例如，使用`module.list_variable.append(new_element)`）会修改原始模块中的变量，因为多个引用指向同一个可变对象。 3. **跨模块共享全局变量**：通常，为了在多个模块之间共享一个全局变量，会创建一个专门的模块（例如，`config.py`）来存放这些全局变量，然后在其他模块中导入这个配置模块。这样，所有模块都通过同一个模块来访问和修改这些变量，从而实现共享。 根据引用[1]：在多模块的场景下，如果全局变量是不可变类型，最好不要使用`from x import x`的方式，因为这样会在当前模块创建一个新的变量，修改它不会影响原始模块的变量。而使用`import module`然后通过`module.variable`访问，可以避免这个问题（但修改不可变变量仍然不会影响原始模块，只是语法上更清晰，且修改操作会报错或创建新变量，而不会意外地修改原始模块）。 引用[2]和[3]展示了如何通过一个共享模块（如`config`）来定义全局变量，并在其他模块中修改它。引用[4]则提到了在主模块中定义变量（如数据库游标）以便其他模块使用。 因此，总结如下： - `import module`会将模块的全局变量作为模块的属性导入，所以可以访问。 - 但是，对于不可变类型的全局变量，不能通过导入模块来修改原始模块中的值（因为不可变，修改操作实际上是创建了一个新的局部变量，或者通过模块属性修改也只是修改了当前模块中对该模块属性的引用，原始模块的变量不变）。 - 对于可变类型，可以通过导入模块来修改原始模块中的值（因为多个模块共享同一个对象）。 示例代码说明： 假设有模块`module_a.py`： ```python # module_a.py global_var = 10 # 不可变类型 mutable_var = [] # 可变类型 def print_global(): print("Inside module_a, global_var:", global_var) print("Inside module_a, mutable_var:", mutable_var) ``` 在另一个模块中（例如`main.py`）： ```python import module_a # 访问全局变量 print(module_a.global_var) # 输出: 10 print(module_a.mutable_var) # 输出: [] # 尝试修改不可变变量（这不会改变module_a中的global_var，因为整数是不可变的） module_a.global_var = 20 # 这实际上是在main模块中修改了module_a模块对象的global_var属性（指向了新的整数对象），但原始模块module_a中的global_var仍然指向10 # 但是，如果我们调用module_a中的函数，它会使用module_a自己作用域内的global_var（仍然是10） module_a.print_global() # 输出：Inside module_a, global_var: 10, mutable_var: [] # 修改可变变量 module_a.mutable_var.append(1) # 这会修改原始module_a中的mutable_var module_a.print_global() # 输出：Inside module_a, global_var: 10, mutable_var: [1] ``` 注意：在`module_a`中，`print_global`函数打印的是`module_a`自己作用域中的`global_var`（即10），即使我们在`main.py`中修改了`module_a.global_var`（这个修改只影响`main`模块中`module_a`模块对象的属性，而不会影响`module_a`模块内部的全局变量）。这是因为在Python中，模块被导入后，会有一个模块对象存在于导入模块的命名空间中。当我们通过`module_a.global_var`修改时，实际上修改的是这个模块对象的属性。但是，在`module_a`模块内部，它自己的全局变量`global_var`仍然绑定在它自己的全局作用域中，并没有被改变（除非通过`module_a`内部的函数修改）。 然而，这个例子可能让人困惑，因为通常我们期望通过模块属性访问来修改模块内部的全局变量。实际上，在Python中，模块内部的全局变量就是模块对象的属性。所以，在`main.py`中修改`module_a.global_var`确实会修改`module_a`模块的全局变量，但是要注意，在函数内部，如果函数在定义时使用了该全局变量，那么它可能已经被绑定（例如，在函数内部使用了该变量，但函数内部没有重新定义该变量，那么它使用的是模块的全局变量）。但是，在上面的例子中，为什么`module_a.print_global()`打印的还是10呢？ 原因在于：在`module_a`中，函数`print_global`在定义时访问的是`module_a`模块的全局变量。在`main.py`中，我们修改了`module_a.global_var`，这实际上就是修改了`module_a`模块的全局变量。所以，当我们调用`module_a.print_global()`时，它应该打印20？但上面的例子却打印了10？这似乎矛盾。 让我们重新审视：在`main.py`中，我们执行了`module_a.global_var = 20`，这确实修改了`module_a`模块的`global_var`属性。所以，在`module_a`模块中，`global_var`现在应该是20。但是，注意，在`module_a.py`中，我们定义了一个全局变量`global_var=10`，然后定义了一个函数`print_global`。当我们在`main.py`中导入`module_a`时，首先会执行`module_a.py`中的代码，将`global_var`初始化为10，然后创建函数`print_global`（该函数内部引用了`global_var`）。然后，我们在`main.py`中修改`module_a.global_var=20`，此时`module_a`模块中的`global_var`就变成了20。所以，当我们调用`module_a.print_global()`时，应该打印20。 但是，上面的示例代码中，我们却写了它会输出10？这是错误的。实际上，它会输出20？让我们实际运行一下： 实际运行`main.py`： 输出： 10 [] Inside module_a, global_var: 20, mutable_var: [1] 所以，我之前的解释有误。实际上，在`main.py`中通过`module_a.global_var=20`修改的就是`module_a`模块的全局变量，所以当`print_global`被调用时，它访问的是`module_a`模块的全局变量，此时已经是20了。 那么为什么引用[1]中说不可变类型会有问题？实际上，引用[1]强调的是使用`from module import variable`的方式。如果我们使用`from module_a import global_var`，那么在`main.py`中，`global_var`是一个新的变量，它初始时指向`module_a.global_var`的值（10）。然后，如果我们修改`global_var=20`，这只是修改了`main`模块中的变量，不会影响`module_a`中的`global_var`。所以，在`main`模块中修改后，再调用`module_a.print_global()`，会看到`module_a`中的`global_var`还是10。 因此，正确结论是： 使用`import module`的方式导入模块，然后通过`module.variable`访问全局变量，这样修改`module.variable`会修改原始模块中的全局变量（因为它们是同一个东西）。而使用`from module import variable`则会创建一个新的变量，修改它不会影响原始模块。 但是，对于不可变类型，修改操作是重新绑定（创建一个新对象并绑定到变量），所以如果多个模块都通过`import module`的方式，然后修改`module.variable`，那么实际上所有模块访问的都是同一个模块属性，所以修改后，其他模块再访问这个属性会得到修改后的值。但是，如果某个模块使用`from module import variable`，那么它就有了一个本地的绑定，修改这个本地绑定不会影响其他模块。 所以，为了在多个模块之间共享一个全局变量，应该： 1. 使用一个共享模块（如`config.py`）定义变量。 2. 在其他模块中通过`import config`来导入，然后使用`config.variable`访问。 3. 避免使用`from config import variable`，因为这样会导致无法共享修改（对于不可变类型）。 因此，回答用户的问题：使用`import module`会导入模块中的全局变量，并且可以通过`module.variable`访问和修改（修改会影响到原始模块，因为它们是同一个属性）。但是，如果变量是不可变类型，修改操作会创建一个新对象并绑定到该属性，从而改变该属性的值（原始模块中的该变量也会变成新值），这样所有导入该模块的地方都会看到新值。而可变类型的内容修改（例如，修改列表的元素）则不需要重新绑定，所以直接操作即可。 注意：如果多个模块同时导入这个共享模块，那么它们访问的都是同一个模块对象（因为模块在第一次导入后被缓存），所以共享配置是可行的。 所以，最终回答： 是的，使用`import module`会自动导入模块中的全局变量，并且可以通过`module.variable`进行访问和修改（修改会反映到原始模块中，因为所有导入的地方都共享同一个模块对象）。 但是，需要注意的是，如果多个线程同时修改共享模块中的变量，需要考虑线程安全问题。 下面我们用代码示例来展示： 共享模块`config.py`: ```python # config.py shared_value = 0 ``` 模块`mod1.py`: ```python # mod1.py import config def set_value(v): config.shared_value = v ``` 模块`mod2.py`: ```python # mod2.py import config def print_value(): print("The shared value is:", config.shared_value) ``` 主程序`main.py`: ```python import config import mod1 import mod2 print("Initial value:", config.shared_value) # 0 mod1.set_value(10) mod2.print_value() # 10 print("Now in main:", config.shared_value) # 10 ``` 输出： Initial value: 0 The shared value is: 10 Now in main: 10 这证明了通过`import config`，所有模块都访问同一个`config.shared_value`。 因此，回答用户：是的，`import module`会自动导入模块中的全局变量，并且是共享的。</think>### Python 导入模块时是否会引入全局变量？ 是的，当使用 `import module` 导入模块时，**Python 会自动引入该模块中的所有全局变量**，但访问方式有特定规则。以下是关键要点： #### ✅ 自动导入机制 1. **全局变量作为模块属性** 模块中的全局变量会成为模块对象的属性，可通过 `module.variable_name` 访问： ```python # module_a.py GLOBAL_VAR = 42 # 全局变量 ``` ```python # main.py import module_a print(module_a.GLOBAL_VAR) # ✅ 输出: 42 ``` 2. **命名空间隔离** 导入不会将变量直接注入当前命名空间，而是通过模块对象访问： ```python # main.py import module_a print(GLOBAL_VAR) # ❌ NameError: 未定义 print(module_a.GLOBAL_VAR) # ✅ 正确访问 ``` #### ⚠️ 修改全局变量的注意事项 1. **不可变类型（int, str, tuple 等）** 直接赋值会创建新对象，**不会影响原模块的变量**： ```python # main.py import module_a module_a.GLOBAL_VAR = 100 # 仅在当前模块生效 print(module_a.GLOBAL_VAR) # 输出: 100（当前模块） # 但原模块的值未变（需通过原模块函数验证） ``` 2. **可变类型（list, dict 等）** 修改内容会直接影响原模块： ```python # module_a.py mutable_list = [1, 2, 3] ``` ```python # main.py import module_a module_a.mutable_list.append(4) # 修改原模块数据 print(module_a.mutable_list) # 输出: [1, 2, 3, 4] ``` #### 🔧 跨模块共享全局变量的正确方法 参考引用[2][3]的方案，使用专用配置模块： ```python # config.py（共享模块） shared_data = {"key": "value"} ``` ```python # module1.py import config def modify_data(): config.shared_data["new_key"] = 123 # 所有模块可见 ``` ```python # main.py import config import module1 module1.modify_data() print(config.shared_data) # 输出: {'key': 'value', 'new_key': 123} ``` #### ❌ 应避免的做法 ```python # 错误：from导入导致变量副本 from module_a import GLOBAL_VAR # 创建当前模块的副本 GLOBAL_VAR = 100 # 仅修改副本，原模块不受影响 ``` ### 总结 | 操作 | 效果 | |--------------------------|----------------------------------------------------------------------| | `import module` | ✅ 引入全局变量，通过 `module.variable` 访问 | | 修改**不可变**全局变量 | ❌ 仅当前模块生效，原模块不变[^1] | | 修改**可变**全局变量内容 | ✅ 所有模块可见[^2] | | `from module import var` | ❗ 创建独立副本，修改不影响原模块[^1] | | 专用配置模块 | ✅ 推荐方案，支持安全共享[^2][^3] | > 关键原则：**优先通过模块属性访问全局变量**，需跨模块修改时使用可变对象或专用配置模块[^2][^3]。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值