PyCharm普通模式下如何避免多次重启代码时模块导入耗时？

Absolutely feasible! I’ve fought this exact frustration before—waiting for slow imports every time I tweak a line of code is such a frustrating waste of time. Here’s how you can replicate that Jupyter-style "reload code without restarting the interpreter" workflow right in PyCharm’s regular mode:

1. Use importlib.reload() for Targeted Module Reloads #

The core idea is to separate your slow-to-import dependencies from your editable code. Here’s how to set it up:

• Move all your frequently modified logic into a dedicated module (e.g., my_work.py).
• Create a lightweight runner script (e.g., runner.py) that handles the initial import of slow modules, then reloads your editable code whenever you make changes.

Example runner script:

import importlib
# Import slow modules once here (these won't be reloaded)
import pandas as pd
import tensorflow as tf

# Import your editable module
import my_work

# Reload and run your code whenever you need to test changes
def run_updated_code():
    importlib.reload(my_work)
    my_work.main()  # Call your core function from the module

# Run once initially
run_updated_code()

# For quick re-runs, just call run_updated_code() again in the console

2. Use PyCharm’s Python Console for Persistent Sessions #

PyCharm’s built-in Python Console keeps the interpreter session alive, just like Jupyter’s kernel:

1. Open the Python Console from the bottom toolbar (look for the "Python Console" tab).
2. First, run your initial imports of slow modules once (they’ll stay loaded for the session).
3. Import your editable module, then whenever you make changes to it, run:

   import importlib
   importlib.reload(my_work)
   my_work.main()
   

Pro tip: Save that reload/run code as a PyCharm live template so you can execute it with a single shortcut.

3. Build a Loop-Based Runner for One-Click Re-Runs #

If you prefer a more automated setup, write a runner that waits for your input to re-execute updated code:

import importlib
import my_work
# Import slow modules once here

while True:
    importlib.reload(my_work)
    print("Running updated code...")
    my_work.main()
    print("\nPress Enter to re-run, Ctrl+C to exit")
    input()

Just run this script once, and every time you finish editing your code, press Enter to reload and execute—no more waiting for slow imports.

Important Notes #

• Unreloadable Modules: Some C-based extension modules (e.g., certain low-level libraries) don’t support importlib.reload(). If your slow imports are these, this method won’t help—but most pure-Python modules work perfectly.
• State Management: Reloading a module resets its global variables, just like in Jupyter. If your code relies on persistent state between runs, you’ll need to handle that explicitly (e.g., by storing state outside the module).

内容的提问来源于stack exchange，提问作者Alexey