Python Large Functions Many Variables (Refactoring)

python

Solution

Without more information, it's hard to know whether this is appropriate or not, but…

An object is a namespace. In particular, you can turn each of those local variables into attributes on an object. For example:

class LargeThing(object):
    def __init__(self):
        self.x = 6
    def large_func(self):
        self.small_func_that_will_increment_x()
        self.small_func()
        # ...
    def small_func_that_will_increment_x(self):
        self.x += 1

Whether the `self.x = 6` belongs in `__init__` or at the start of `large_func`, or whether this is even a good idea, depends on what all those variables actually mean, and how they fit together.

Problem

I have a large function in my script that contains the bulk of the logic of my program. At one point, it used to span ~100 lines which I then tried to refactor into multiple smaller functions. However, I had many local variables that were eventually being modified in the smaller functions, and I needed some way to keep track of them in the scope of the larger function. For instance, it looked like ``` def large_func(): x = 5 ... 100 lines ... ``` to ``` def large_func(): x = 6 small_func_that_will_increment_x() small_func() .... ``` What is a pythonic way to handle this? The two approaches I can think of are: 1) global variables --- will probably get messy as I have many variables 2) using a dict to keep track of them like ``` tracker = { 'field1' : 5 'field2' : 4 } ``` and make modifications on the dict instead. Is there a different way to do this that I might have overlooked?

Original source