blocks|key|4127322|text|您没有注册信号处理程序。试试下面的方法。它似乎工作得相当可靠。我认为罕见的例外是在Python注册脚本的处理程序之前捕获信号。请注意，“当用户按下中断键时”，才应该引发KeyboardInterrupt。我认为它在显式(例如，通过kill)+SIGINT中工作的事实是一个实现上的意外。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|4127323|import+signal

def+quit_gracefully(*args):
++++print+'quitting+loop'
++++exit(0);

if+__name__+==+"__main__":
++++signal.signal(signal.SIGINT,+quit_gracefully)

++++try:
++++++++print+'starting+loop'
++++++++while+True:
++++++++++++pass
++++except+KeyboardInterrupt:
++++++++quit_gracefully()|code-block|syntax|javascript|4127324|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

You're not registering a signal handler. Try the below. It seems to work fairly reliably. I think the rare exception is when it catches the signal before Python registers the script's handler. Note that KeyboardInterrupt is only supposed to be raised, "when the user hits the interrupt key". I think the fact that it works for a explicit (e.g. via kill) SIGINT at all is an accident of implementation.

<pre><code>import signal

def quit_gracefully(*args):
 print 'quitting loop'
 exit(0);

if __name__ == "__main__":
 signal.signal(signal.SIGINT, quit_gracefully)

 try:
 print 'starting loop'
 while True:
 pass
 except KeyboardInterrupt:
 quit_gracefully()
</code></pre>

blocks|key|18418|text|我同意Matthew+Flaschen的观点；问题出在python，当它不是从交互式shell调用时，它显然不会向SIGINT注册KeyboardInterrupt异常。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|18419|当然，没有什么可以阻止您这样注册您的信号处理程序：|18420|def+signal_handler(signum,+frame):
++++raise+KeyboardInterrupt,+"Signal+handler"|code-block|syntax|javascript|18421|entityMap^0|0|0|0^^$0|@$1|2|3|4|5|6|7|K|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|L|8|@]|9|@]|A|$]]|$1|D|3|E|5|F|7|M|8|@]|9|@]|A|$G|H]]|$1|I|3|-4|5|6|7|N|8|@]|9|@]|A|$]]]|J|$]]

I agree with Matthew Flaschen; the problem is with python, which apparently doesn't register the KeyboardInterrupt exception with SIGINT when it's not called from an interactive shell.

Of course, nothing prevents you from registering your signal handler like this:

<pre><code>def signal_handler(signum, frame):
 raise KeyboardInterrupt, "Signal handler"
</code></pre>

blocks|key|1318612|text|当你用&在后台运行命令时，SIGINT将被忽略。以下是man+bash的相关部分：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1318613|1318614|运行的非内置命令将信号处理程序设置为外壳从其父命令继承的值。当作业控制无效时，除了这些继承的处理程序外，异步命令还会忽略SIGINT和SIGQUIT。作为命令替换结果运行的命令忽略键盘生成的作业控制信号SIGTTIN、SIGTTOU和SIGTSTP。|blockquote|1318615|1318616|1318617|我认为你需要像Matthew评论的那样显式地设置signal+handler。|1318618|script+kill.sh也有一个问题。因为loop.py被发送到后台，所以不能保证kill在python+loop.py之后运行。|1318619|#!+/bin/bash
python+loop.py+&
PID=$!
#
#+NEED+TO+WAIT+ON+EXISTENCE+OF+python+loop.py+PROCESS+HERE.
#
echo+"sending+SIGINT+to+process+$PID"
kill+-SIGINT+$PID|code-block|syntax|javascript|1318620|entityMap^0|0|0|0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|S|8|@]|9|@]|A|$]]|$1|B|3|-4|5|6|7|T|8|@]|9|@]|A|$]]|$1|C|3|D|5|E|7|U|8|@]|9|@]|A|$]]|$1|F|3|-4|5|6|7|V|8|@]|9|@]|A|$]]|$1|G|3|-4|5|6|7|W|8|@]|9|@]|A|$]]|$1|H|3|I|5|6|7|X|8|@]|9|@]|A|$]]|$1|J|3|K|5|6|7|Y|8|@]|9|@]|A|$]]|$1|L|3|M|5|N|7|Z|8|@]|9|@]|A|$O|P]]|$1|Q|3|-4|5|6|7|10|8|@]|9|@]|A|$]]]|R|$]]

When you run command in background with &amp;, SIGINT will be ignored.
Here's the relevant section of man bash:

<blockquote>
 Non-builtin commands run by bash have signal handlers set to the values inherited by the shell from
 its parent. When job control is not in effect, asynchronous commands ignore SIGINT and SIGQUIT in
 addition to these inherited handlers. Commands run as a result of command substitution ignore the
 keyboard-generated job control signals SIGTTIN, SIGTTOU, and SIGTSTP.
</blockquote>

I think you need to set signal handler explicitly as Matthew commented.

The script kill.sh also have a problem. Since loop.py is sent to background, there's no guarantee that kill runs after python loop.py. 

<pre><code>#! /bin/bash
python loop.py &amp;
PID=$!
#
# NEED TO WAIT ON EXISTENCE OF python loop.py PROCESS HERE.
#
echo "sending SIGINT to process $PID"
kill -SIGINT $PID
</code></pre>

blocks|key|18171|text|除了@matthew-flaschen的回答之外，您还可以在bash脚本中使用exec来有效地替换正在打开的进程的作用域：|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|18172|#!/bin/bash
exec+python+loop.py+&
PID=$!
sleep+5++#+waiting+for+the+python+process+to+come+up

echo+"sending+SIGINT+to+process+$PID"
kill+-SIGINT+$PID|code-block|syntax|javascript|18173|entityMap^0|13|4|0|0^^$0|@$1|2|3|4|5|6|7|M|8|@$9|N|A|O|B|C]]|D|@]|E|$]]|$1|F|3|G|5|H|7|P|8|@]|D|@]|E|$I|J]]|$1|K|3|-4|5|6|7|Q|8|@]|D|@]|E|$]]]|L|$]]

In addition to @matthew-flaschen's answer, you can use <code>exec</code> in the bash script to effectively replace the scope to the process being opened:

<pre><code>#!/bin/bash
exec python loop.py &amp;
PID=$!
sleep 5 # waiting for the python process to come up

echo "sending SIGINT to process $PID"
kill -SIGINT $PID
</code></pre>

blocks|key|4127466|text|尝试了@Steen的方法，但很遗憾，它显然不能坚持Mac。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|4127467|另一种解决方案与上面的方案基本相同，但更一般，如果SIGINT被忽略，则只需重新安装默认处理程序：|offset|length|style|CODE|4127468|def+_ensure_sigint_handler():
++++#+On+Mac,+even+using+`exec+<cmd>`+in+`bash`+still+yields+an+ignored+SIGINT.
++++sig+=+signal.getsignal(signal.SIGINT)
++++if+signal.getsignal(signal.SIGINT)+==+signal.SIG_IGN:
++++++++signal.signal(signal.SIGINT,+signal.default_int_handler)
#+...
_ensure_sigint_handler()|code-block|syntax|javascript|4127469|entityMap^0|0|P|6|0|0^^$0|@$1|2|3|4|5|6|7|O|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|P|8|@$D|Q|E|R|F|G]]|9|@]|A|$]]|$1|H|3|I|5|J|7|S|8|@]|9|@]|A|$K|L]]|$1|M|3|-4|5|6|7|T|8|@]|9|@]|A|$]]]|N|$]]

Tried @Steen's approach, but alas, it does not apparently hold on Mac.

Another solution, pretty much the same as the above but a little more general, is to just re-install the default handler if <code>SIGINT</code> is being ignored:

<pre><code>def _ensure_sigint_handler():
 # On Mac, even using `exec &lt;cmd&gt;` in `bash` still yields an ignored SIGINT.
 sig = signal.getsignal(signal.SIGINT)
 if signal.getsignal(signal.SIGINT) == signal.SIG_IGN:
 signal.signal(signal.SIGINT, signal.default_int_handler)
# ...
_ensure_sigint_handler()
</code></pre>

I want to launch a background Python job from a bash script and then gracefully kill it with SIGINT. This works fine from the shell, but I can't seem to get it to work in a script.

loop.py:

<pre><code>#! /usr/bin/env python
if __name__ == "__main__":
 try:
 print 'starting loop'
 while True:
 pass
 except KeyboardInterrupt:
 print 'quitting loop'
</code></pre>

From the shell I can interrupt it:

<pre><code>$ python loop.py &amp;
[1] 15420
starting loop
$ kill -SIGINT 15420
quitting loop
[1]+ Done python loop.py
</code></pre>

kill.sh:

<pre><code>#! /bin/bash
python loop.py &amp;
PID=$!
echo "sending SIGINT to process $PID"
kill -SIGINT $PID
</code></pre>

But from a script I can't:

<pre><code>$ ./kill.sh 
starting loop
sending SIGINT to process 15452
$ ps ax | grep loop.py | grep -v grep
15452 pts/3 R 0:08 python loop.py
</code></pre>

And, if it's been launched from a script I can no longer kill it from the shell:

<pre><code>$ kill -SIGINT 15452
$ ps ax | grep loop.py | grep -v grep
15452 pts/3 R 0:34 python loop.py
</code></pre>

I'm assuming I'm missing some fine point of bash job control.

How to send a SIGINT to Python from a bash script?

翻译质量差，导致语言生硬或混乱。

没有提供实际的解决方法或示例。

解答不清晰，无法理解或解决问题。

页面排版不美观，阅读体验差。

文章

问答

视频

学习中心

腾讯云实验室

直播

竞赛

腾讯云代码分析专区

腾讯iOA零信任安全管理系统专区

腾讯云架构师技术同盟交流圈

腾讯云数据库专区

腾讯云顾问专区

腾讯云原生专区

腾讯混元专区

腾讯云TCE专区

腾讯云Lighthouse专区

腾讯云HAI专区

腾讯云Edgeone专区

腾讯云存储专区

腾讯云智能专区

腾讯轻联专区 

腾讯云开发专区

TAPD专区

腾讯轻量云游戏服专区

腾讯云最具价值专家

腾讯云架构师技术同盟

腾讯云创作之星

腾讯云开发者先锋

腾讯云代码助手

云原生构建

TAPD 敏捷项目管理

Cloud Studio

SDK中心

API中心

命令行工具

涵盖代码开发、场景应用、自动测试全流程，助你从零构建专属AI助手

一站式MCP教程库，解锁AI应用新玩法

我想从bash脚本启动一个后台Python作业，然后使用SIGINT优雅地终止它。这在shell中工作得很好，但是我似乎无法在脚本中让它工作。loop.py：#! /usr/bin/env pythonif __name__ == "__main__":    try:        print 'starting l...

问如何从bash脚本向Python发送SIGINT？
EN

Stack Overflow用户

社区

活动

圈层

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问如何从bash脚本向Python发送SIGINT？EN