按顺序执行（一个接一个）

这是最简单直接的方式，即先运行完第一个文件的所有代码,然后再运行第二个文件。

方法 1：在命令行中直接运行

这是最基础的方法，打开你的终端（在 Windows 上是 cmd 或 PowerShell，在 macOS 或 Linux 上是 Terminal）,然后使用以下命令：

# 语法
python 文件名1.py
python 文件名2.py
# 示例
# 假设你有两个文件：main.py 和 helper.py
python main.py
python helper.py

优点：

• 简单直观,无需额外代码。
• 两个文件之间是完全隔离的进程,互不影响。

缺点：

• 无法在两个文件之间共享数据（除非通过文件或数据库等外部方式）。
• 如果第一个文件运行时间很长,第二个文件需要等待。

方法 2：在一个文件中导入并调用另一个文件

这种方式允许你在一个文件中控制另一个文件的执行,并且可以共享模块级别的变量和函数。

步骤：

1. 将你希望被“调用”的文件（helper.py）当作一个模块。
2. 在“主”文件（main.py）中导入这个模块。
3. 通过模块名来调用其中的函数或访问变量。

示例代码：

helper.py (被调用的文件)

# 这个文件可以包含一些函数或变量
def greet(name):
    """一个简单的问候函数"""
    print(f"Hello, {name} from helper.py!")
    return "Greeting sent"
# 也可以直接执行一些代码，但要注意，当它被导入时，这部分代码也会运行
print("helper.py module is being imported.")

main.py (主文件)

# 1. 导入 helper 模块
#    Python 会在当前目录下寻找 helper.py 文件
import helper
print("--- Starting main.py ---")
# 2. 调用 helper.py 中定义的函数
result = helper.greet("Alice")
print(f"Main.py received the result: '{result}'")
# 你也可以访问 helper.py 中定义的变量（如果有的话）
# 如果 helper.py 中有 a = 10，你可以这样访问：helper.a
print("--- Finished main.py ---")

如何运行： 你只需要运行主文件 main.py 即可。

python main.py

预期输出：

helper.py module is being imported.
--- Starting main.py ---
Hello, Alice from helper.py!
Main.py received the result: 'Greeting sent'
--- Finished main.py ---

优点：

• 可以在一个程序内控制另一个模块的执行。
• 可以轻松地在两个文件之间共享函数和变量。
• 符合 Python 的模块化编程思想。

缺点：

• 被导入的文件（helper.py）在导入时就会执行其顶层的代码（没有缩进的代码），这可能会带来意外行为，你可以使用 if __name__ == "__main__": 来避免这个问题。

并行/并发执行（同时运行）

如果你希望两个程序同时运行（一个运行服务器，一个运行客户端），或者为了提高性能,你可以使用多线程或多进程。

方法 3：使用 multiprocessing 模块（推荐用于CPU密集型任务）

multiprocessing 模块可以创建独立的进程，每个进程都有自己独立的 Python 解释器和内存空间，非常适合“运行两个文件”这个场景。

示例代码 (runner.py): 这个文件将负责启动并管理另外两个进程。

import multiprocessing
import time
import sys
# 定义一个函数，用来运行指定的 Python 文件
def run_script(script_name):
    """执行一个Python脚本"""
    print(f"[{script_name}] Process started.")
    # 使用 exec 执行另一个文件
    # 注意：exec() 会执行文件内的所有代码
    with open(script_name, 'r', encoding='utf-8') as f:
        exec(f.read())
    print(f"[{script_name}] Process finished.")
if __name__ == "__main__":
    print("Main script started. Launching sub-processes...")
    # 定义要运行的文件列表
    scripts_to_run = ["script1.py", "script2.py"]
    # 创建一个进程池
    processes = []
    for script in scripts_to_run:
        # 创建一个进程
        p = multiprocessing.Process(target=run_script, args=(script,))
        processes.append(p)
        p.start() # 启动进程
    # 等待所有进程完成
    for p in processes:
        p.join()
    print("All sub-processes have finished. Main script exiting.")

你需要另外两个文件：

script1.py

import time
print("Script 1: I am running.")
for i in range(5):
    print(f"Script 1: Count {i}")
    time.sleep(1) # 模拟耗时操作
print("Script 1: I am done.")

script2.py

import time
print("Script 2: I am also running.")
for i in range(3):
    print(f"Script 2: Count {i}")
    time.sleep(1.5) # 模拟耗时操作
print("Script 2: I am done.")

如何运行：

python runner.py

预期输出（两个脚本的输出会交错出现）：

Main script started. Launching sub-processes...
[script1.py] Process started.
Script 1: I am running.
[script2.py] Process started.
Script 2: I am also running.
Script 1: Count 0
Script 2: Count 0
Script 1: Count 1
Script 2: Count 1
Script 1: Count 2
Script 2: Count 2
Script 1: Count 3
Script 2: I am done.
Script 1: Count 4
Script 1: I am done.
All sub-processes have finished. Main script exiting.
[script1.py] Process finished.
[script2.py] Process finished.

优点：

• 真正的并行执行（在多核CPU上）,性能高。
• 进程之间隔离性好,一个进程崩溃不会直接影响另一个。

缺点：

• 进程间通信（IPC）比线程间通信复杂。
• 创建进程的开销比线程大。

方法 4：使用 subprocess 模块（最灵活的方式）

subprocess 模块允许你创建新的进程，连接到它们的输入/输出/错误管道，并获取它们的返回码，这就像在命令行中手动运行命令一样,但可以通过代码控制。

示例代码 (controller.py):

import subprocess
import time
print("Controller: Starting scripts...")
# 使用 Popen 启动进程，它是非阻塞的
# Popen 会立即返回，不会等待子进程结束
p1 = subprocess.Popen(["python", "script1.py"])
p2 = subprocess.Popen(["python", "script2.py"])
print("Controller: Both scripts are running in the background.")
# 等待两个进程都完成
# 你可以分别等待，也可以一起等待
p1.wait()
print("Controller: script1.py has finished.")
p2.wait()
print("Controller: script2.py has finished.")
print("Controller: All done.")

如何运行：

python controller.py

优点：

• 非常灵活,可以模拟命令行的所有操作。
• 可以轻松地与子进程的输入输出进行交互。
• 适合调用外部命令或程序,而不仅仅是Python脚本。

缺点：

• 比多进程模块更底层,需要手动管理进程的生命周期。

总结与选择建议

给你的建议：

• 如果你的任务有明确的先后顺序，并且第二个文件需要用到第一个文件的结果：使用 方法2（模块导入）。
• 如果你的任务是两个独立的、可以同时进行的工作，且你想让它们同时运行：使用 方法3（multiprocessing） 或 方法4（subprocess），对于纯Python代码，multiprocessing 通常更自然。
• 如果你只是想快速运行两个不相关的脚本：直接使用 方法1（命令行顺序执行） 最简单。