python多處理變量

Question

我怎樣才能在同一個項目的另一個進程中使用從一個進程獲得的數據（一個變量）？例如，從下面的代碼中，我想在界面中使用變量「b」來繪製和分析它。謝謝！

import time 
import multiprocessing 
import time 
import os 
import sys 
import matplotlib.animation as animation 
import time 
import libtiepie 
import numpy as np 
import matplotlib.pyplot as plt 
from copy import deepcopy 
from printinfo import * 
from math import* 
import pylab 
import tkinter as tk 
import matplotlib.animation as animation 
from tkinter import* 
from tkinter import ttk 
from matplotlib.backends.backend_tkagg import FigureCanvasTkAgg, NavigationToolbar2TkAgg 
from matplotlib.figure import Figure 
from matplotlib.animation import FuncAnimation 

def calc_square(): 

    k=0 
    fig=plt.figure() 
    while k<3000: 

     # Print library info: 
     print_library_info() 

     # Search for devices: 
     libtiepie.device_list.update() 

     # Try to open an oscilloscope with block measurement support: 
     scp = None 
     for item in libtiepie.device_list: 
      if item.can_open(libtiepie.DEVICETYPE_OSCILLOSCOPE): 
       scp = item.open_oscilloscope() 
       if scp.measure_modes & libtiepie.MM_BLOCK: 
        break 
       else: 
        scp = None 

     if scp: 
      try: 

        # Set measure mode: 
        scp.measure_mode = libtiepie.MM_BLOCK 

        # Set sample frequency: 
        scp.sample_frequency = 5e6 # 1 MHz 

        # Set record length: 
        scp.record_length = 1000 # 15000 samples 

        # Set pre sample ratio: 
        scp.pre_sample_ratio = 0.1 # 0 % 

        # For all channels: 
        for ch in scp.channels: 
         # Enable channel to measure it: 
         ch.enabled = True 

         # Set range: 
         ch.range = 8 # 8 V 

         # Set coupling: 
         ch.coupling = libtiepie.CK_ACV # DC Volt 

        # Set trigger timeout: 
        scp.trigger_time_out = 100e-3 # 100 ms 

        # Disable all channel trigger sources: 
        for ch in scp.channels: 
         ch.trigger.enabled = False 

        # Setup channel trigger: 
        ch = scp.channels[0] # Ch 1 

        # Enable trigger source: 
        ch.trigger.enabled = True 

        # Kind: 
        ch.trigger.kind = libtiepie.TK_RISINGEDGE # Rising edge 

        # Level: 
        ch.trigger.levels[0] = 0.75 # 50 % 

        # Hysteresis: 
        ch.trigger.hystereses[0] = 0.1 # 5 % 

        # Print oscilloscope info: 
        #print_device_info(scp) 

        # Start measurement: 
        scp.start() 

        # Wait for measurement to complete: 
        while not scp.is_data_ready: 
         time.sleep(0.01) # 10 ms delay, to save CPU time 

        # Get data: 
        data = scp.get_data() 

        ax = fig.add_subplot(111) 
        t = np.linspace(0, (scp.record_length/scp.sample_frequency)*1000, scp.record_length) 
        a=deepcopy(data) 
        a=np.transpose(a) 
        b=a[:,0] 
        #ax.plot(t,b) 
        #plt.ion() 
        #plt.show() 
        #plt.pause(0.001) 
        #ax.cla() 

      except Exception as e: 
       print('Exception: ' + e.message) 
       sys.exit(1) 

      # Close oscilloscope: 
      del scp 

     else: 
      print('No oscilloscope available with block measurement support!') 
     k=k+1 

if __name__ == "__main__": 

    p1 = multiprocessing.Process(target=calc_square)  

    p1.start() 
    # p2.start() 
    p1.join() 
    # p2.join() 

Answer 1

從一個進程發送數據到另一個可以使用多隊列，如docs

from multiprocessing import Process, Queue 
q = Queue() 

def function1(q): 
    a = 3434 
    q.put(a) 
def function2(a): 
    c = a**2 
    q.put(c) 
p1 = Process(target=function1, args=(q,)) 
p1.start() 
b = q.get() 
p1.join() 
p2 = Process(target=function2, args=(b,)) 
p2.start() 
c = q.get() 
p2.join() 
print c 

這裏提到的工作example還有的傳遞變量的一個過程到另一個