1. python中子进程发送信号父进程怎么互发信号
ubuntu下，也就是linux下，通常会用kill -事件编号实现。 你查一下LINUX下的事件就明白了。 kill进程号 实现上是发了一个信号给指定的进程。 在python里，也可以加载事件处理模块，处理来自其它程序发过来的信号， 当然你可以用KILL工具发信号...
2. 用Python做一个信号分析处理软件
做信号处理，开源的着名软件是scilab，octave等，用C写的
用python写的，比较少，速度慢，做信号处理不好。
如果用他调用信号处理的库，做一些前期或后期的处理工作，还是又有优势的。
3. Python的pywavelet如何实现 matlab的小波算法系数重构的信号，matlab算法如下
我也在找这个问题，pywt.upcoef可以实现python里小波的一层分解重构，但多层分解以后，再重构数据就不对了，你知道结果答案了么，已经过去一年
4. python 一个进程可以注册多个信号么
可以
信号的概念
信号（signal）-- 进程之间通讯的方式，是一种软件中断。一个进程一旦接收到信号就会打断原来的程序执行流程来处理信号。
几个常用信号:
SIGINT 终止进程 中断进程 (control+c)
SIGTERM 终止进程 软件终止信号
SIGKILL 终止进程 杀死进程
SIGALRM 闹钟信号
进程结束信号 SIGTERM和SIGKILL的区别
SIGTERM比较友好，进程能捕捉这个信号，根据您的需要来关闭程序。在关闭程序之前，您可以结束打开的记录文件和完成正在做的任务。在某些情况下，假如进程正在进行作业而且不能中断，那么进程可以忽略这个SIGTERM信号。
对于SIGKILL信号，进程是不能忽略的。这是一个 “我不管您在做什么,立刻停止”的信号。假如您发送SIGKILL信号给进程，Linux就将进程停止在那里。
发送信号一般有两种原因:
1(被动式) 内核检测到一个系统事件.例如子进程退出会像父进程发送SIGCHLD信号.键盘按下control+c会发送SIGINT信号
2(主动式) 通过系统调用kill来向指定进程发送信号
linux操作系统提供的信号
[100003@oss235 myppt]$ kill -l
1) SIGHUP 2) SIGINT 3) SIGQUIT 4) SIGILL
5) SIGTRAP 6) SIGABRT 7) SIGBUS 8) SIGFPE
9) SIGKILL 10) SIGUSR1 11) SIGSEGV 12) SIGUSR2
13) SIGPIPE 14) SIGALRM 15) SIGTERM 16) SIGSTKFLT
17) SIGCHLD 18) SIGCONT 19) SIGSTOP 20) SIGTSTP
21) SIGTTIN 22) SIGTTOU 23) SIGURG 24) SIGXCPU
25) SIGXFSZ 26) SIGVTALRM 27) SIGPROF 28) SIGWINCH
29) SIGIO 30) SIGPWR 31) SIGSYS 34) SIGRTMIN
35) SIGRTMIN+1 36) SIGRTMIN+2 37) SIGRTMIN+3 38) SIGRTMIN+4
39) SIGRTMIN+5 40) SIGRTMIN+6 41) SIGRTMIN+7 42) SIGRTMIN+8
43) SIGRTMIN+9 44) SIGRTMIN+10 45) SIGRTMIN+11 46) SIGRTMIN+12
47) SIGRTMIN+13 48) SIGRTMIN+14 49) SIGRTMIN+15 50) SIGRTMAX-14
51) SIGRTMAX-13 52) SIGRTMAX-12 53) SIGRTMAX-11 54) SIGRTMAX-10
55) SIGRTMAX-9 56) SIGRTMAX-8 57) SIGRTMAX-7 58) SIGRTMAX-6
59) SIGRTMAX-5 60) SIGRTMAX-4 61) SIGRTMAX-3 62) SIGRTMAX-2
63) SIGRTMAX-1 64) SIGRTMAX
Python提供的信号
Python 2.4.3 (#1, Jun 11 2009, 14:09:58)
[GCC 4.1.2 20080704 (Red Hat 4.1.2-44)] on linux2
Type "help", "right", "credits" or "license" for more information.
>>> import signal
>>> dir(signal)
['NSIG', 'SIGABRT', 'SIGALRM', 'SIGBUS', 'SIGCHLD', 'SIGCLD', 'SIGCONT', 'SIGFPE', 'SIGHUP', 'SIGILL', 'SIGINT', 'SIGIO', 'SIGIOT', 'SIGKILL', 'SIGPIPE', 'SIGPOLL', 'SIGPROF', 'SIGPWR', 'SIGQUIT', 'SIGRTMAX', 'SIGRTMIN', 'SIGSEGV', 'SIGSTOP', 'SIGSYS', 'SIGTERM', 'SIGTRAP', 'SIGTSTP', 'SIGTTIN', 'SIGTTOU', 'SIGURG', 'SIGUSR1', 'SIGUSR2', 'SIGVTALRM', 'SIGWINCH', 'SIGXCPU', 'SIGXFSZ', 'SIG_DFL', 'SIG_IGN', '__doc__', '__name__', 'alarm', 'default_int_handler', 'getsignal', 'pause', 'signal']
操作系统规定了进程收到信号以后的默认行为
但是，我们可以通过绑定信号处理函数来修改进程收到信号以后的行为
有两个信号是不可更改的SIGTOP和SIGKILL
绑定信号处理函数
import os
import signal
from time import sleep
def onsignal_term(a,b):
print '收到SIGTERM信号'
#这里是绑定信号处理函数，将SIGTERM绑定在函数onsignal_term上面
signal.signal(signal.SIGTERM,onsignal_term)
def onsignal_usr1(a,b):
print '收到SIGUSR1信号'
#这里是绑定信号处理函数，将SIGUSR1绑定在函数onsignal_term上面
signal.signal(signal.SIGUSR1,onsignal_usr1)
while 1:
print '我的进程id是',os.getpid()
sleep(10)
运行该程序。然后通过另外一个进程来发送信号。
发送信号
发送信号的代码如下：
import os
import signal
#发送信号，16175是前面那个绑定信号处理函数的pid，需要自行修改
os.kill(16175,signal.SIGTERM)
#发送信号，16175是前面那个绑定信号处理函数的pid，需要自行修改
os.kill(16175,signal.SIGUSR1)
SIGCHLD信号
然后显示一个子进程结束后自动向父进程发送SIGCHLD信号的例子。
'''''''
子进程结束会向父进程发送SIGCHLD信号
'''
import os
import signal
from time import sleep
def onsigchld(a,b):
print '收到子进程结束信号'
signal.signal(signal.SIGCHLD,onsigchld)
pid = os.fork()
if pid == 0:
print '我是子进程,pid是',os.getpid()
sleep(2)
else:
print '我是父进程,pid是',os.getpid()
os.wait() #等待子进程结束
使用信号需要特别注意的地方：
如果一个进程收到一个SIGUSR1信号，然后执行信号绑定函数，第二个SIGUSR2信号又来了，第一个信号没有被处理完毕的话，第二个信号就会丢弃。
所以，尽量不要在多线程中使用信号。
这个不妥，测试没发现有信号丢失
例子演示：
接收信号的程序，你会发现如果有另外一端使用多线程向这个进程发送信号，会遗漏一些信号。
import os
import signal
from time import sleep
import Queue
QCOUNT = Queue.Queue() #初始化队列
def onsigchld(a,b):
'''''''收到信号后向队列中插入一个数字1'''
print '收到SIGUSR1信号'
sleep(2)
QCOUNT.put(1) #向队列中写入
def exithanddle(s,e):
raise SystemExit('收到终止命令,退出程序')
signal.signal(signal.SIGUSR1,onsigchld) #绑定信号处理函数
signal.signal(signal.SIGINT,exithanddle) #当按下Ctrl + C 终止进程
while 1:
print '我的pid是',os.getpid()
print '现在队列中元素的个数是',QCOUNT.qsize()
sleep(2)
多线程发信号端的程序：
'''''''
使用多线程向另外一个进程发送信号
'''
import threading
import os
import signal
def sensr1():
print '发送信号'
#这里的进程id需要写前一个程序实际运行的pid
os.kill(17788, signal.SIGUSR1)
WORKER = []
#开启6个线程
for i in range(1, 7):
threadinstance = threading.Thread(target = sensr1)
WORKER.append(threadinstance)
for i in WORKER:
i.start()
for i in WORKER:
i.join()
print '主线程完成'
内容补充：
Alarms 是一个特殊信号类型，它可以让程序要求系统经过一段时间对自己发送通知。os 标准模块中指出，它可用于避免无限制阻塞 I/O 操作或其它系统调用。
像下面例子，原本程序睡眠 10 后才打印出print 'After :', time.ctime()，但是由于 signal.alarm(2)，所以 2 秒后就执行了打印。
import signal
import time
def receive_alarm(signum, stack):
print 'Alarm :', time.ctime()
# Call receive_alarm in 2 seconds
signal.signal(signal.SIGALRM, receive_alarm)
signal.alarm(2)
print 'Before:', time.ctime()
time.sleep(10)
print 'After :', time.ctime()
注意Signal只有主线程才能接收信号，像下面例子，print 'Done waiting' 语句打印不出来，如果不调用 signal.alarm(2) ，程序将永远阻塞
import signal
import threading
import os
import time
def signal_handler(num, stack):
print 'Received signal %d in %s' % \
(num, threading.currentThread().name)
signal.signal(signal.SIGUSR1, signal_handler)
def wait_for_signal():
print 'Waiting for signal in', threading.currentThread().name
signal.pause()
print 'Done waiting'
# Start a thread that will not receive the signal
receiver = threading.Thread(target=wait_for_signal, name='receiver')
receiver.start()
time.sleep(0.1)
def send_signal():
print 'Sending signal in', threading.currentThread().name
os.kill(os.getpid(), signal.SIGUSR1)
sender = threading.Thread(target=send_signal, name='sender')
sender.start()
sender.join()
# Wait for the thread to see the signal (not going to happen!)
print 'Waiting for', receiver.name
signal.alarm(2)
receiver.join()
还有一点需要注意的是，虽然 alarms 类信号可以在任何线程中调用，但是只能在主线程中接收，像下面例子即使子线程 use_alarm 中调用 signal.alarm(1) ，但是不起作用 ：
import signal
import time
import threading
def signal_handler(num, stack):
print time.ctime(), 'Alarm in', threading.currentThread().name
signal.signal(signal.SIGALRM, signal_handler)
def use_alarm():
t_name = threading.currentThread().name
print time.ctime(), 'Setting alarm in', t_name
signal.alarm(1)
print time.ctime(), 'Sleeping in', t_name
time.sleep(3)
print time.ctime(), 'Done with sleep in', t_name
# Start a thread that will not receive the signal
alarm_thread = threading.Thread(target=use_alarm,
name='alarm_thread')
alarm_thread.start()
time.sleep(0.1)
# Wait for the thread to see the signal (not going to happen!)
print time.ctime(), 'Waiting for', alarm_thread.name
alarm_thread.join()
print time.ctime(), 'Exiting normally'
5. python 怎么让程序接受ctrl + c终止信号
花了一天时间用python为服务写了个压力测试。很简单，多线程向服务器发请求。但写完之后发现如果中途想停下来，按Ctrl+C达不到效果，自然想到要用信号处理函数捕捉信号，使线程都停下来，问题解决的方法请往下看：
复制代码代码如下:
#!/bin/env python
# -*- coding: utf-8 -*-
#filename: peartest.py
import threading, signal
is_exit = False
def doStress(i, cc):
global is_exit
idx = i
while not is_exit:
if (idx < 10000000):
print "thread[%d]: idx=%d"%(i, idx)
idx = idx + cc
else:
break
print "thread[%d] complete."%i
def handler(signum, frame):
global is_exit
is_exit = True
print "receive a signal %d, is_exit = %d"%(signum, is_exit)
if __name__ == "__main__":
signal.signal(signal.SIGINT, handler)
signal.signal(signal.SIGTERM, handler)
cc = 5
for i in range(cc):
t = threading.Thread(target=doStress, args=(i,cc))
t.start()
上面是一个模拟程序，并不真正向服务发送请求，而代之以在一千万以内，每个线程每隔并发数个（cc个）打印一个整数。很明显，当所有线程都完成自己的任务后，进程会正常退出。但如果我们中途想退出（试想一个压力测试程序，在中途已经发现了问题，需要停止测试），该肿么办？你当然可以用ps查找到进程号，然后kill -9杀掉，但这样太繁琐了，捕捉Ctrl+C是最自然的想法。上面示例程序中已经捕捉了这个信号，并修改全局变量is_exit，线程中会检测这个变量，及时退出。
但事实上这个程序并不work，当你按下Ctrl+C时，程序照常运行，并无任何响应。网上搜了一些资料，明白是python的子线程如果不是daemon的话，主线程是不能响应任何中断的。但设为daemon后主线程会随之退出，接着整个进程很快就退出了，所以还需要在主线程中检测各个子线程的状态，直到所有子线程退出后自己才退出，因此上例29行之后的代码可以修改为：
复制代码代码如下:
threads=[]
for i in range(cc):
t = threading.Thread(target=doStress, args=(i, cc))
t.setDaemon(True)
threads.append(t)
t.start()
for i in range(cc):
threads[i].join()
重新试一下，问题依然没有解决，进程还是没有响应Ctrl+C，这是因为join()函数同样会waiting在一个锁上，使主线程无法捕获信号。因此继续修改，调用线程的isAlive()函数判断线程是否完成：
复制代码代码如下:
while 1:
alive = False
for i in range(cc):
alive = alive or threads[i].isAlive()
if not alive:
break
这样修改后，程序完全按照预想运行了：可以顺利的打印每个线程应该打印的所有数字，也可以中途用Ctrl+C终结整个进程。完整的代码如下：
复制代码代码如下:
#!/bin/env python
# -*- coding: utf-8 -*-
#filename: peartest.py
import threading, signal
is_exit = False
def doStress(i, cc):
global is_exit
idx = i
while not is_exit:
if (idx < 10000000):
print "thread[%d]: idx=%d"%(i, idx)
idx = idx + cc
else:
break
if is_exit:
print "receive a signal to exit, thread[%d] stop."%i
else:
print "thread[%d] complete."%i
def handler(signum, frame):
global is_exit
is_exit = True
print "receive a signal %d, is_exit = %d"%(signum, is_exit)
if __name__ == "__main__":
signal.signal(signal.SIGINT, handler)
signal.signal(signal.SIGTERM, handler)
cc = 5
threads = []
for i in range(cc):
t = threading.Thread(target=doStress, args=(i,cc))
t.setDaemon(True)
threads.append(t)
t.start()
while 1:
alive = False
for i in range(cc):
alive = alive or threads[i].isAlive()
if not alive:
break
其实，如果用python写一个服务，也需要这样，因为负责服务的那个线程是永远在那里接收请求的，不会退出，而如果你想用Ctrl+C杀死整个服务，跟上面的压力测试程序是一个道理。总结一下，python多线程中要响应Ctrl+C的信号以杀死整个进程，需要：
1.把所有子线程设为Daemon；
2.使用isAlive()函数判断所有子线程是否完成，而不是在主线程中用join()函数等待完成；
3.写一个响应Ctrl+C信号的函数，修改全局变量，使得各子线程能够检测到，并正常退出。
6. Python 数字信号处理程序实现求解
数字信号处理是把信号用数字或符号表示成序列，通过计算机或通用（专用）信号处理设备，用数值计算方法进行各种处理，达到提取有用信息便于应用的目的。例如：滤波、检测、变换、增强、估计、识别、参数提取、频谱分析等。
一般地讲，数字信号处理涉及三个步骤：
⑴模数转换(A/D转换)：把模拟信号变成数字信号，是一个对自变量和幅值同时进行离散化的过程，基本的理论保证是采样定理。
⑵数字信号处理(DSP)：包括变换域分析(如频域变换)、数字滤波、识别、合成等。
⑶数模转换(D/A转换)：把经过处理的数字信号还原为模拟信号。通常，这一步并不是必须的。 作为DSP的成功例子有很多，如医用CT断层成像扫描仪的发明。它是利用生物体的各个部位对X射线吸收率不同的现象，并利用各个方向扫描的投影数据再构造出检测体剖面图的仪器。这种仪器中fft(快速傅里叶变换)起到了快速计算的作用。以后相继研制出的还有：采用正电子的CT机和基于核磁共振的CT机等仪器，它们为医学领域作出了很大的贡献。
信号处理的目的是：削弱信号中的多余内容；滤出混杂的噪声和干扰；或者将信号变换成容易处理、传输、分析与识别的形式，以便后续的其它处理。 下面的示意图说明了信号处理的概念。
7. Python如何做离散信号分析
numpy里面挺多相关的函数，基础的傅里叶之类的都有
8. python线程如何捕获中断信号
import threadtext = Nonedef get_input(): global text text = raw_input()def main(): while True: print "running" if text != None: breakthread.start_new_thread(get_input,())main()
global全局变量吧？看看上面这段代码是我常用的套路，main()是一个无限循环一直输出running，如果你按下回车让get_input()线程里的text变成不是None了，那么main()就断了，希望对你有帮助
9. python 怎么查看signal
信号（signal）--进程之间通讯的方式，是一种软件中断。一个进程一旦接受到信号就会打断原来的程序执行流程来处理信号。
几个常用信号:
SIGINT 终止进程 中断进程 (control+c)
SIGTERM 终止进程 软件终止信号
SIGKILL 终止进程 杀死进程
SIGALRM 闹钟信号
进程结束信号 SIGTERM和SIGKILL的区别
SIGTERM比较友好，进程能捕捉这个信号，根据您的需要来关闭程序。在关闭程序之前，您可以结束打开的记录文件和完成正在做的任务。在某些情况下，假如进程正在进行作业而且不能中断，那么进程可以忽略这个SIGTERM信号。
对于SIGKILL信号，进程是不能忽略的。这是一个 “我不管您在做什么,立刻停止”的信号。假如您发送SIGKILL信号给进程，Linux就将进程停止在那里。
发送信号一般有两种原因:
1(被动式) 内核检测到一个系统事件.例如子进程退出会像父进程发送SIGCHLD信号.键盘按下control+c会发送SIGINT信号
2(主动式) 通过系统调用kill来向指定进程发送信号
补充：
POSIX.1中列出的信号：
信号 值 处理动作 发出信号的原因
----------------------------------------------------------------------
SIGHUP 1 A 终端挂起或者控制进程终止
SIGINT 2 A 键盘中断（如break键被按下）
SIGQUIT 3 C 键盘的退出键被按下
SIGILL 4 C 非法指令
SIGABRT 6 C 由abort(3)发出的退出指令
SIGFPE 8 C 浮点异常
SIGKILL 9 AEF Kill信号
SIGSEGV 11 C 无效的内存引用
SIGPIPE 13 A 管道破裂: 写一个没有读端口的管道
SIGALRM 14 A 由alarm(2)发出的信号
SIGTERM 15 A 终止信号
SIGUSR1 30,10,16 A 用户自定义信号1
SIGUSR2 31,12,17 A 用户自定义信号2
SIGCHLD 20,17,18 B 子进程结束信号
SIGCONT 19,18,25 进程继续（曾被停止的进程）
SIGSTOP 17,19,23 DEF 终止进程
SIGTSTP 18,20,24 D 控制终端（tty）上按下停止键
SIGTTIN 21,21,26 D 后台进程企图从控制终端读
SIGTTOU 22,22,27 D 后台进程企图从控制终端写
处理动作一项中的字母含义如下:
A 缺省的动作是终止进程
B 缺省的动作是忽略此信号
C 缺省的动作是终止进程并进行内核映像转储（mp core）
D 缺省的动作是停止进程
E 信号不能被捕获
F 信号不能被忽略
键盘和shell的交互：
Ctrl-c Kill foreground process 常用 ;送SIGINT信号，默认进程会结束，但是进程自己可以重定义收到这个信号的行为。
Ctrl-z Suspend foreground process;送SIGSTOP信号，进程只是被停止，再送SIGCONT信号，进程继续运行。
Ctrl-d Terminate input, or exit shell 常用 有时也会使程序退出，例如没有参数的cat命令，从终端读一行显示一行，知道Ctrl+D终结输入并终结进程;不是发送信号，而是表示一个特殊的二进制值，表示 EOF。
Ctrl-s Suspend output
Ctrl-q Resume output
Ctrl-o Discard output
Ctrl-l Clear screen
控制字符都是可以用(stty命令)更改的。可以用stty -a看看终端配置。
有些信号不能被屏蔽，比如中断，还应该有杀死进程的信号，要不然内核怎么做操作系统中的老大。实际上，SIGKILL和SIGSTOP信号是不能被屏蔽或阻止的，他们的默认动作总是会被执行的
10. 怎么用python(树莓派)获取bluetooth的信号强度rssi
python是当下十分火爆的编程语言，尤其在人工智能应用方面。如果有心从事编程方向的工作，最好到专业机构深入学习、多实践，更贴近市场，这样更有利于将来的发展。