Two Class instances in Python not different
Question: I'm working on another data acquisition project, which has turned into an
object oriented programming question. In “main” at the bottom of my code I
make two instances of the Object DAQInput. When I wrote this, I thought my
method .getData would refer to the taskHandle of the particular instance, but
it does not. When I run, the code does the getData task with the first handle
twice, so clearly I don’t really understand object oriented programming in
Python. I’m sorry this code will not run without PyDAQmx and a National
Instruments board attached.

    
    
    from PyDAQmx import *
    import numpy
    
    class DAQInput:
        # Declare variables passed by reference
        taskHandle = TaskHandle()
        read = int32()
        data = numpy.zeros((10000,),dtype=numpy.float64)
        sumi = [0,0,0,0,0,0,0,0,0,0]
    
        def __init__(self, num_data, num_chan, channel, high, low):
            """ This is init function that opens the channel"""
            #Get the passed variables
            self.num_data = num_data
            self.channel = channel
            self.high = high
            self.low = low
            self.num_chan = num_chan
    
            # Create a task and configure a channel
            DAQmxCreateTask(b"",byref(self.taskHandle))
            DAQmxCreateAIThrmcplChan(self.taskHandle, self.channel, b"",
                                     self.low, self.high,
                                     DAQmx_Val_DegC,
                                     DAQmx_Val_J_Type_TC,
                                     DAQmx_Val_BuiltIn, 0, None)
            # Start the task
            DAQmxStartTask(self.taskHandle)
    
        def getData(self):
            """ This function gets the data from the board and calculates the average"""
            print(self.taskHandle)
            DAQmxReadAnalogF64(self.taskHandle, self.num_data, 10,
                               DAQmx_Val_GroupByChannel, self.data, 10000,
                               byref(self.read), None)
    
            # Calculate the average of the values in data (could be several channels)
            i = self.read.value
            for j in range(self.num_chan):
                self.sumi[j] = numpy.sum(self.data[j*i:(j+1)*i])/self.read.value
    
            return self.sumi
    
        def killTask(self):
            """ This function kills the tasks"""
            # If the task is still alive kill it
            if self.taskHandle != 0:
                DAQmxStopTask(self.taskHandle)
                DAQmxClearTask(self.taskHandle)
    
    if __name__ == '__main__':
        myDaq1 = DAQInput(1, 4, b"cDAQ1Mod1/ai0:3", 200.0, 10.0)
        myDaq2 = DAQInput(1, 4, b"cDAQ1Mod2/ai0:3", 200.0, 10.0)
        result = myDaq1.getData()
        print (result[0:4])
    
        result2 = myDaq2.getData()
        print (result2[0:4])
    
        myDaq1.killTask()
        myDaq2.killTask()
    


Answer: These variables:

    
    
    class DAQInput:
        # Declare variables passed by reference
        taskHandle = TaskHandle()
        read = int32()
        data = numpy.zeros((10000,),dtype=numpy.float64)
        sumi = [0,0,0,0,0,0,0,0,0,0]
    

Are class variables. They belong to the class itself and are shared among
instances of the class (i.e. if you modify `self.data` in `Instance1`,
`Instace2`'s `self.data` is modified as well).

If you want them to be instance variables, define them in `__init__`.

