在CMD运行Python脚本时，可以通过以下方法结束脚本：使用快捷键Ctrl+C、在代码中使用sys.exit()函数、在代码中使用os._exit()函数。其中，使用快捷键Ctrl+C 是最常见且便捷的方法。这个快捷键会向Python脚本发送一个KeyboardInterrupt信号，强制终止脚本的运行。下面将详细介绍该方法。
当你在CMD（命令提示符）中运行一个Python脚本时，按下Ctrl+C会发送一个中断信号（SIGINT）到正在运行的脚本。这个信号会被Python解释器捕获，并引发一个KeyboardInterrupt异常。如果脚本中没有捕获这个异常，脚本会立即终止。这种方法不需要在脚本中添加额外的代码，非常适合在开发和调试过程中使用。
一、使用快捷键Ctrl+C
在CMD中运行Python脚本时，按下Ctrl+C是最常见的终止方法。当你按下这个组合键时，Python解释器会捕获到一个KeyboardInterrupt信号，并中断当前运行的脚本。
1、发送中断信号
当你按下Ctrl+C时，操作系统会向当前运行的进程发送一个SIGINT信号。Python解释器接收到这个信号后，会触发一个KeyboardInterrupt异常。
try:
while True:
print("Running...")
except KeyboardInterrupt:
print("Script terminated by user")
在上面的例子中，当用户按下Ctrl+C时，程序会捕获到KeyboardInterrupt异常，并执行except块中的代码，打印出“Script terminated by user”。
2、适用场景
Ctrl+C适用于大多数的命令行环境，特别是当你在开发和调试过程中，快速终止一个长时间运行的脚本时，非常方便。它不需要在脚本中添加任何额外的代码，因此不会对代码的可读性和维护性产生任何影响。
二、使用sys.exit()函数
使用sys.exit()函数是另一种常见的方法。这种方法需要在代码中显式调用sys.exit()函数来终止脚本的运行。sys.exit()函数会引发一个SystemExit异常，从而终止脚本的执行。
1、引发SystemExit异常
sys.exit()函数会引发一个SystemExit异常，并终止脚本的运行。你可以在脚本的任意位置调用这个函数，来终止脚本的执行。
import sys
if some_condition:
sys.exit("Exiting script due to some condition")
在上面的例子中，当满足某个条件时，脚本会调用sys.exit()函数，并打印出指定的退出消息，终止脚本的执行。
2、返回值
你可以通过sys.exit()函数的参数，指定脚本的退出状态码。0表示正常退出，其他值表示异常退出。
import sys
sys.exit(0) # 正常退出
sys.exit(1) # 异常退出
这种方法适用于需要在脚本中根据某些条件，显式终止脚本运行的场景。它比Ctrl+C更加灵活，可以在代码中控制退出的时机和原因。
三、使用os._exit()函数
使用os._exit()函数是一种更为低级的终止脚本的方法。os._exit()函数会立即终止当前进程，不会执行任何清理操作，如关闭文件、调用析构函数等。
1、立即终止进程
os._exit()函数会立即终止当前进程，不会执行任何清理操作。因此，它比sys.exit()更加粗暴。
import os
if some_condition:
os._exit(1)
在上面的例子中，当满足某个条件时，脚本会调用os._exit()函数，并立即终止进程。
2、不执行清理操作
与sys.exit()不同，os._exit()不会引发SystemExit异常，因此不会执行任何清理操作。这意味着打开的文件不会被关闭，缓冲区不会被刷新，析构函数不会被调用。
import os
try:
if some_condition:
os._exit(1)
except:
print("This will not be printed")
在上面的例子中，即使有异常处理代码块，也不会执行，因为os._exit()会立即终止进程。
这种方法适用于需要立即终止进程，并且不关心清理操作的场景。它比sys.exit()更加高效，但也更加危险，可能会导致资源泄漏。
四、使用信号处理模块
使用信号处理模块是一种更为高级的终止脚本的方法。你可以使用Python的signal模块，捕获和处理操作系统发送的信号，如SIGINT、SIGTERM等。
1、捕获信号
你可以使用signal.signal()函数，捕获和处理特定的信号，如SIGINT（Ctrl+C）、SIGTERM（终止进程）等。
import signal
import sys
def signal_handler(signal, frame):
print("Received signal:", signal)
sys.exit(0)
signal.signal(signal.SIGINT, signal_handler)
while True:
print("Running...")
在上面的例子中，当用户按下Ctrl+C时，signal_handler函数会被调用，并终止脚本的执行。
2、自定义信号处理函数
你可以自定义信号处理函数，来执行特定的操作，如清理资源、保存状态等。
import signal
import sys
def custom_signal_handler(signal, frame):
print("Cleaning up resources...")
# 执行清理操作
sys.exit(0)
signal.signal(signal.SIGTERM, custom_signal_handler)
while True:
print("Running...")
在上面的例子中，当接收到SIGTERM信号时，custom_signal_handler函数会被调用，执行清理操作，并终止脚本的执行。
这种方法适用于需要捕获和处理特定信号，并在终止脚本前执行清理操作的场景。它比Ctrl+C和sys.exit()更加灵活，可以处理更多的信号类型。
五、使用线程和多进程模块
使用线程和多进程模块是一种更加复杂的终止脚本的方法。你可以使用Python的threading和multiprocessing模块，创建和管理多个线程和进程，并在需要时终止它们。
1、终止线程
你可以使用threading模块，创建和管理多个线程，并在需要时终止它们。
import threading
import time
def worker():
while True:
print("Running...")
time.sleep(1)
thread = threading.Thread(target=worker)
thread.start()
time.sleep(5)
thread.join()
在上面的例子中，主线程会等待5秒钟，然后等待worker线程终止。
2、终止进程
你可以使用multiprocessing模块，创建和管理多个进程，并在需要时终止它们。
import multiprocessing
import time
def worker():
while True:
print("Running...")
time.sleep(1)
process = multiprocessing.Process(target=worker)
process.start()
time.sleep(5)
process.terminate()
在上面的例子中，主进程会等待5秒钟，然后终止worker进程。
这种方法适用于需要创建和管理多个线程和进程，并在需要时终止它们的场景。它比前面的方法更加复杂，但也更加灵活，可以处理更多的并发任务。
六、使用上下文管理器
使用上下文管理器是一种优雅的终止脚本的方法。你可以使用Python的with语句，创建和管理上下文，并在需要时终止脚本。
1、定义上下文管理器
你可以定义一个上下文管理器，来执行特定的操作，如初始化资源、清理资源等。
class MyContext:
def __enter__(self):
print("Entering context")
return self
def __exit__(self, exc_type, exc_value, traceback):
print("Exiting context")
return False
with MyContext():
print("Inside context")
在上面的例子中，当进入上下文时，会执行__enter__方法；当退出上下文时，会执行__exit__方法。
2、使用上下文管理器
你可以使用上下文管理器，来管理资源，并在需要时终止脚本。
import contextlib
@contextlib.contextmanager
def my_context():
try:
print("Entering context")
yield
finally:
print("Exiting context")
with my_context():
print("Inside context")
在上面的例子中，当进入上下文时，会执行try块中的代码；当退出上下文时，会执行finally块中的代码。
这种方法适用于需要管理资源，并在需要时优雅地终止脚本的场景。它比前面的方法更加优雅，但也需要更多的代码和理解。
七、使用atexit模块
使用atexit模块是一种在脚本结束时执行清理操作的方法。你可以使用Python的atexit模块，注册退出函数，并在脚本结束时执行这些函数。
1、注册退出函数
你可以使用atexit.register()函数，注册一个退出函数，并在脚本结束时执行该函数。
import atexit
def cleanup():
print("Cleaning up resources...")
atexit.register(cleanup)
print("Running script...")
在上面的例子中，当脚本结束时，会执行cleanup函数，打印出“Cleaning up resources…”消息。
2、多个退出函数
你可以注册多个退出函数，并按注册的顺序依次执行这些函数。
import atexit
def cleanup1():
print("Cleaning up resources 1...")
def cleanup2():
print("Cleaning up resources 2...")
atexit.register(cleanup1)
atexit.register(cleanup2)
print("Running script...")
在上面的例子中，当脚本结束时，会依次执行cleanup1和cleanup2函数，打印出相应的消息。
这种方法适用于需要在脚本结束时执行清理操作，并且不需要立即终止脚本的场景。它比前面的方法更加简单，但也更加有限，只能在脚本正常结束时执行清理操作。
八、使用信号量
使用信号量是一种控制并发访问共享资源的方法。你可以使用Python的threading.Semaphore类，创建和管理信号量，并在需要时终止脚本。
1、创建信号量
你可以使用threading.Semaphore类，创建一个信号量，并控制并发访问共享资源。
import threading
semaphore = threading.Semaphore(1)
def worker():
semaphore.acquire()
try:
print("Running...")
finally:
semaphore.release()
thread = threading.Thread(target=worker)
thread.start()
在上面的例子中，semaphore信号量控制并发访问共享资源，确保只有一个线程可以访问该资源。
2、释放信号量
你可以在需要时释放信号量，并终止脚本。
import threading
semaphore = threading.Semaphore(1)
def worker():
semaphore.acquire()
try:
print("Running...")
finally:
semaphore.release()
thread = threading.Thread(target=worker)
thread.start()
thread.join()
在上面的例子中，主线程会等待worker线程终止，并释放信号量。
这种方法适用于需要控制并发访问共享资源，并在需要时终止脚本的场景。它比前面的方法更加复杂，但也更加灵活，可以处理更多的并发任务。
九、使用条件变量
使用条件变量是一种同步线程的方法。你可以使用Python的threading.Condition类，创建和管理条件变量，并在需要时终止脚本。
1、创建条件变量
你可以使用threading.Condition类，创建一个条件变量，并控制线程的同步。
import threading
condition = threading.Condition()
def worker():
with condition:
print("Running...")
condition.wait()
thread = threading.Thread(target=worker)
thread.start()
在上面的例子中，condition条件变量控制线程的同步，确保只有一个线程可以访问该资源。
2、通知条件变量
你可以在需要时通知条件变量，并终止脚本。
import threading
condition = threading.Condition()
def worker():
with condition:
print("Running...")
condition.wait()
thread = threading.Thread(target=worker)
thread.start()
with condition:
condition.notify()
thread.join()
在上面的例子中，主线程会通知condition条件变量，并等待worker线程终止。
这种方法适用于需要同步线程，并在需要时终止脚本的场景。它比前面的方法更加复杂，但也更加灵活，可以处理更多的并发任务。
十、使用事件
使用事件是一种线程之间通信的方法。你可以使用Python的threading.Event类，创建和管理事件，并在需要时终止脚本。
1、创建事件
你可以使用threading.Event类，创建一个事件，并控制线程之间的通信。
import threading
event = threading.Event()
def worker():
while not event.is_set():
print("Running...")
event.wait(1)
thread = threading.Thread(target=worker)
thread.start()
在上面的例子中，event事件控制线程之间的通信，确保只有一个线程可以访问该资源。
2、设置事件
你可以在需要时设置事件，并终止脚本。
import threading
event = threading.Event()
def worker():
while not event.is_set():
print("Running...")
event.wait(1)
thread = threading.Thread(target=worker)
thread.start()
event.set()
thread.join()
在上面的例子中，主线程会设置event事件，并等待worker线程终止。
这种方法适用于需要线程之间通信，并在需要时终止脚本的场景。它比前面的方法更加复杂，但也更加灵活，可以处理更多的并发任务。
十一、使用队列
使用队列是一种线程之间通信和同步的方法。你可以使用Python的queue.Queue类，创建和管理队列，并在需要时终止脚本。
1、创建队列
你可以使用queue.Queue类，创建一个队列，并控制线程之间的通信和同步。
import queue
import threading
q = queue.Queue()
def worker():
while True:
item = q.get()
if item is None:
break
print("Processing item:", item)
q.task_done()
thread = threading.Thread(target=worker)
thread.start()
在上面的例子中，q队列控制线程之间的通信和同步，确保只有一个线程可以访问该资源。
2、终止队列
你可以在需要时终止队列，并终止脚本。
import queue
import threading
q = queue.Queue()
def worker():
while True:
item = q.get()
if item is None:
break
print("Processing item:", item)
q.task_done()
thread = threading.Thread(target=worker)
thread.start()
q.put(None)
thread.join()
在上面的例子中，主线程会向队列中放入一个None值，并等待worker线程终止。
这种方法适用于需要线程之间通信和同步，并在需要时终止脚本的场景。它比前面的方法更加复杂，但也更加灵活，可以处理更多的并发任务。
十二、使用定时器
使用定时器是一种在特定时间后执行操作的方法。你可以使用Python的threading.Timer类，创建和管理定时器，并在需要时终止脚本。
1、创建定时器
你可以使用threading.Timer类，创建一个定时器，并在特定时间后执行操作。
import threading
def worker():
print("Running...")
timer = threading.Timer(5, worker)
timer.start()
在上面的例子中，定时器会在5秒钟后执行worker函数。
2、取消定时器
你可以在需要时取消定时器，并终止脚本。
import threading
def worker():
print("Running...")
timer = threading.Timer(5, worker)
timer.start()
timer.cancel()
在上面的例子中，主线程会取消定时器，并终止worker函数的执行。
这种方法适用于需要在特定时间后执行操作，并在需要时终止脚本的场景。它比前面的方法更加简单，但也更加有限，只能在特定时间后执行操作。
总结
在CMD运行Python脚本时，可以通过多种方法终止脚本的运行，包括使用快捷键Ctrl+C、sys.exit()函数、os._exit()函数、信号处理模块、线程和多进程模块、上下文管理器、atexit模块、信号量、条件变量、事件、队列和定时器等。根据具体的需求和
相关问答FAQs：
如何在CMD中查看正在运行的Python脚本？
在CMD中，可以使用命令 tasklist 来查看当前运行的所有进程，包括Python脚本。找到与Python相关的进程，通常会显示为 python.exe，可以通过此信息确认您想要结束的脚本。
如何安全地结束Python脚本的运行？
在CMD窗口中，您可以使用快捷键 Ctrl + C 来安全地结束正在运行的Python脚本。这是推荐的方法，因为它允许Python程序有机会清理资源，并进行必要的终止操作。
如果Python脚本不响应，我该如何强制结束它？
在这种情况下，您可以使用 taskkill 命令来强制结束Python脚本。命令格式为 taskkill /F /IM python.exe。使用此命令时，请注意它将强制关闭所有Python进程，因此请确保没有其他重要的Python脚本正在运行。
