Python: Function pipeline with multiple return/input values, or use OOP? Best Practices?

Question

I have a 'processing' function and a 'serializing' function. Currently the processor returns 4 different types of data structures to be serialized in different ways.

Looking for the best practise on what to do here.

def process(input):
   ...
   return a,b,c,d

def serialize(a,b,c):
   ...
   # Different serialization patterns for each of a-c.

a,b,c,d = process(input)
serialize(a,b,c)
go_on_to_do_other_things(d)

That feels janky. Should I instead use a class where a,b,c,d are member variables?

class VeryImportantDataProcessor:
   def process(self,input):
      self.a = ...
      self.b = ...
      ...

   def serialize(self):
      s3.write(self.a)
      convoluted_serialize(self.b)
      ...

vipd = VeryImportantDataProcessor()
vipd.process(input)
vipd.serialize()

Keen to hear your thoughts on what is best here!

Note after processing and serializing, the code goes on to use variable d for further unrelated shenanigans. Not sure if that changes anything.

Answer 1

I'm not exactly clear on what you are trying to do but like you, I start wondering if there is a better way if a method has many parameters or returns a tuple of more than 2 elements.

Classes in Python are great for encapsulating complexity (I never use them for polymorphism)

I think it aides in understanding if you have classes that wrap the data. In addition this object can change without having to rewrite methods and the method return tuple unpacking.

Something like

class DataStreams:
    def __init__(self, z, y, z):
        ...
        
        
class ProcessOuput:
    def __init__(self...):
        ...

Then a method method:

def process(data_streams) -> ProcessOutputs:

As far as the serialization is concerned I would model it after the standard json module.

I'd also make sure that there were multiple sterilizers for distinct types if necessary, i.e. I wouldn't expect a serializer to return a tuple.