Das deutsche Python-Forum

Code: Alles auswählen

class Datenspeicher:
    def __init__(self):
        self._value=0   # Initialwert
        
    def get(self):
        return(self._value)
    def put(self, value):
        self._value=value
        
speicher1 = Datenspeicher()
speicher2 = Datenspeicher()

Code: Alles auswählen

class Example():
    __instance=None
    
    def __init__(self):
        ...
    def __call__(self):
        ...

Code: Alles auswählen

class Singleton:

    class __impl:
          ....

Code: Alles auswählen

EINSTELLUNG_A = 12
EINSTELLUNG_B = "foo"

def mein_programm():
    for x in xrange(EINSTELLUNG_A):
        ...

Code: Alles auswählen

class Config(object):
    EINSTELLUNG_A = 12
    EINSTELLUNG_B = "foo"

def mein_programm(cfg):
    for x in xrange(cfg.EINSTELLUNG_A):
        ...

if __name__ == "__main__":
    cfg=Config()
    mein_programm(cfg)

Code: Alles auswählen

import numpy as np
import matplotlib
matplotlib.use('TkAgg')
from matplotlib.backends.backend_tkagg import FigureCanvasTkAgg, NavigationToolbar2TkAgg
from matplotlib.backend_bases import key_press_handler
from matplotlib.figure import Figure
import matplotlib.animation as animation

from matplotlib import pyplot as plt
import random

import time

try:
    import tkinter as tk
except:
    import Tkinter as tk

class FIFOBuffer(object):
    """
    A circular FIFO buffer implemented on top of numpy.
    """
    __instance=None
    
    def __init__(self, shape, dtype=np.float32, filled=False):
        self._cache = np.zeros(shape, dtype)
        self._values = np.zeros(shape, dtype)
        self.shape = shape
        self._cached=True
        if filled:
            self._ind = self.shape[0]
        else:
            self._ind = 0
            self._cached = False
    
    def add(self, value):
        """
        Add a value to the buffer.
        """
        ind = self._ind % self.shape[0]
        self._values[ind] = value
        self._ind += 1
        self._cached = False
        
    def array(self):
        """
        Returns a numpy array containing the last stored values.
        """
        if self._ind < self.shape[0]:
            return self._values[:self._ind]
        if not self._cached:
            ind = self._ind % self.shape[0]
            self._cache[:self.shape[0] - ind] = self._values[ind:]
            self._cache[self.shape[0] - ind:] = self._values[:ind]
            self._cached = True
        return self._cache
    
    def __len__(self):
        return min(self._ind, self.shape[0])

def create_data(channels, container):
    for i in range (0, channels):
        container[i].add(random.random()*10)

def print_data(channels, container):
    for i in range (0, channels):
        print (container[i].array())
        
class PlotDisplay(tk.Frame):
    def __init__(self, master, channels, data, style_args, refreshtime=100):
        # tk.Frame.__self__(self, master=master)
        self._master = master
        self._data = data
        self._styleargs = style_args
        self._refreshtime = refreshtime
        self._channels = channels
        self._fig = Figure()
        #self._fig = plt.Figure()
        #plt.ion()
        self._plot1 = self._fig.add_subplot(111)
                    
        self._canvas = FigureCanvasTkAgg(self._fig, master=self._master)
        self._canvas.show()
        self._canvas._tkcanvas.pack()
        print ("in plotdisplayinit")
        
        self._init_plot()
        
    def _init_plot(self):
        print ("in initplot")
        for i in range (0, self._channels):
            print (self._data[i].array())
            # plt.plot(self._data[i].array(), self._styleargs[i])
            self._plot1.plot(self._data[i].array(), self._styleargs[i])

    def refresh_plot(self):
        print ("in refresh_plot")
        create_data(self._channels, self._data)
        print_data (self._channels, self._data)

def main ():

    root = tk.Tk()    
    
    def do_exit():
        root.quit()
        root.destroy()
        
      
    plotframe = tk.Frame(master=root)
    buttonframe = tk.Frame(master=root)
    
    exit_button = tk.Button (buttonframe, text=" Beenden ", width=21, command=do_exit)
    exit_button.pack()
    
    refresh_button = tk.Button (buttonframe, text = " Refresh display ", width=21)
    refresh_button.pack()
    
    buttonframe.grid(row=0, column=2)
    plotframe.grid(row=0, column=1)
    
    style_args=['g-x', 'b*-', 'g','y--','r','b']
    channels=6
    values = 10
    maxdata=channels*values
    print ("Maxdata ---> %s" %str(maxdata))


    # init data_container
    data_container=[]
    for i in range (0,channels):
        data_container.append( FIFOBuffer(shape=[(values)], dtype=np.float16, filled=True) )
        

    create_data(channels, data_container)
    create_data(channels, data_container)
    create_data(channels, data_container)
    create_data(channels, data_container)
        
    display = PlotDisplay (plotframe, channels, data_container, style_args)
    refresh_button['command']=display.refresh_plot
    
    
    """  
    fig = plt.Figure()
    for i in range (0, channels):
        plt.plot(data_container[i].array(), style_args[i])
    plt.show() 
    """
    
    root.mainloop()
    
    print ("... PRG_end ...")
    

if __name__ == "__main__":
    main ()

Code: Alles auswählen

import threading

class ThreadsafeData(object):
    def __init__(self, initial_value=None):
        self._value = initial_value
        self._lock = threading.Lock()

    def get(self):
        with self._lock:
            return self._value

    def set(self, value):
        with self._lock:
            self._value = value