在类方法中将实例变量作为参数传递？

Question

I'm trying to refactor a very repetitive section of code.

I have a class that has two instance variables that get updated:

class Alerter(object):

    'Sends email regarding information about unmapped positions and trades'

    def __init__(self, job):
        self.job = job
        self.unmappedPositions = None
        self.unmappedTrades = None

After my code going through some methods, it creates a table and updates self.unmappedPositions and self.unmappedTrades :

def load_positions(self, filename):
    unmapped_positions_table = etl.fromcsv(filename)
    if 'positions' in filename:
        return self.add_to_unmapped_positions(unmapped_positions_table)
    else:
        return self.add_to_unmapped_trades(unmapped_positions_table)

So I have two functions that essentially do the same thing:

def add_to_unmapped_trades(self, table):
    if self.unmappedTrades:
        Logger.info("Adding to unmapped")
        self.unmappedTrades = self.unmappedTrades.cat(
            table).cache()
    else:
        Logger.info("Making new unmapped")
        self.unmappedTrades = table
    Logger.info("Data added to unmapped")
    return self.unmappedTrades

And:

def add_to_unmapped_positions(self, table):
    if self.unmappedPositions:
        Logger.info("Adding to unmapped")
        self.unmappedPositions = self.unmappedPositions.cat(
            table).cache()
    else:
        Logger.info("Making new unmapped")
        self.unmappedPositions = table
    Logger.info("Data added to unmapped")
    return self.unmappedPositions

I tried making it one method so that it just passes in a third argument and then figures out what to update. The third argument being the intialized variable, either self.unmappedPositions or self.unmappedTrades . However, that doesn't seem to work. Any other suggestions?

Answer 1

It looks like you've had the key insight that you can write this function independent of any particular storage:

def add_to_unmapped(unmapped, table):
    if unmapped:
        Logger.info("Adding to unmapped")
        unmapped = unmapped.cat(table).cache()
    else:
        Logger.info("Making new unmapped")
        unmapped = table
    Logger.info("Data added to unmapped")
    return unmapped

This is actually good practice on its own. For instance, you can write unit tests for it, or if you have two tables (as you do) you can just write the implementation for it once.

If you consider what, abstractly, your two add_to_unmapped_* functions do, they:

1. Compute the new table;
2. Save the new table in the object; and
3. Return the new table.

We've now separated out step 1, and you can refactor the wrappers:

class Alerter:
    def add_to_unmapped_trades(self, table):
        self.unmappedTrades = add_to_unmapped(self.unmappedTrades, table)
        return self.unmappedTrades