CODEWITHSUNDEEP
pythonargumentsglobal-variablesparameter-passing
cadolphs
cadolphs

Reputation: 9647

Avoiding global variables but also too many function arguments (Python)

Let's say I have a python module that has a lot of functions that rely on each other, processing each others results. There's lots of cohesion.

That means I'll be passing back and forth a lot of arguments. Either that, or I'd be using global variables.

What are best practices to deal with such a situation if? Things that come to mind would be replacing those parameters with dictionaries. But I don't necessarily like how that changes the function signature to something less expressive. Or I can wrap everything into a class. But that feels like I'm cheating and using "pseudo"-global variables?

I'm asking specifically for how to deal with this in Python but I understand that many of those things would apply to other languages as well.

I don't have a specific code example right, it's just something that came to mind when I was thinking about this issue.

Examples could be: You have a function that calculates something. In the process, a lot of auxiliary stuff is calculated. Your processing routines need access to this auxiliary stuff, and you don't want to just re-compute it.

Upvotes: 8

Views: 2470

Answers (2)

TextGeek
TextGeek

Reputation: 1247

As RobertB said, an object seems the clearest way. Could be as simple as:

class myInfo:
    def __init__(self, x=0.0, y=0.0):
        self.x = x
        self.y = y
        self.dist = self.messWithDist()

    def messWithDist(self):
        self.dist = math.sqrt(self.x*self.x + self.y*self.y)

blob = myInfo(3,4)
blob.messWithDist()
print(blob.dist)
blob.x = 5
blob.y = 7
blob.messWithDist()
print(blob.dist)

If some of the functions shouldn't really be part of such an object, you can just define them as (non-member, independent) functions, and pass the blob as one parameter. For example, by un-indenting the def of messWithDist, then calling as messWithDist(blob) instead of blob.messWithDist().

-s

Upvotes: 0

RobertB
RobertB

Reputation: 1929

This is a very generic question so it is hard to be specific. What you seem to be describing is a bunch of inter-related functions that share data. That pattern is usually implemented as an Object.

Instead of a bunch of functions, create a class with a lot of methods. For the common data, use attributes. Set the attributes, then call the methods. The methods can refer to the attributes without them being explicitly passed as parameters.

Upvotes: 7

Related Questions