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是當下十分火爆的編程語言，尤其在人工智慧應用方面。如果有心從事編程方向的工作，最好到專業機構深入學習、多實踐，更貼近市場，這樣更有利於將來的發展。