存儲用於調用函數Python的數據

Question

我有一個項目，我通過一個"cleans"它們的特定函數運行多個數據。

清潔功能如下：Misc.py

def clean(my_data)
    sys.stdout.write("Cleaning genes...\n")

    synonyms = FileIO("raw_data/input_data", 3, header=False).openSynonyms()
    clean_genes = {}

    for g in data:
        if g in synonyms:
            # Found a data point which appears in the synonym list.
            #print synonyms[g]
            for synonym in synonyms[g]:
                if synonym in data:
                    del data[synonym]
                    clean_data[g] = synonym
                    sys.stdout.write("\t%s is also known as %s\n" % (g, clean_data[g]))
    return data

FileIO是我打開文件的自定義類。

我的問題是，在整個程序的生命周期中會多次調用此函數。 我想要實現的是不必每次都讀取input_data，因為它每次都是相同的。 我知道我可以返回它，並以這種方式將其作為參數傳遞：

def clean(my_data, synonyms = None) 
    if synonyms == None:
       ...
    else
       ...

但是，還有另一種更好看的方法嗎？

我的文件結構如下：

lib
    Misc.py
    FileIO.py
    __init__.py
    ...
raw_data
runme.py

從runme.py ，我from lib import *執行此操作並調用我所做的所有函數。

是否有一種pythonic方式來解決這個問題？ 就像功能的“記憶”一樣

編輯：此行： synonyms = FileIO("raw_data/input_data", 3, header=False).openSynonyms() collections.OrderedDict()從input_data返回collections.OrderedDict()並使用第3列作為字典的鍵。

以下數據集的字典：

column1    column2    key    data
  ...        ...      A      B|E|Z
  ...        ...      B      F|W
  ...        ...      C      G|P
  ...

看起來像這樣：

OrderedDict([('A',['B','E','Z']), ('B',['F','W']), ('C',['G','P'])])

這告訴我的腳本A也被稱為B,E,Z 。 B為F,W 。 等等...

所以這些是同義詞。 因為，同義詞列表在代碼的整個生命周期中永遠不會改變。 我想只閱讀一次，然后重復使用它。

Answer 1

使用帶__call__運算符的類。 您可以調用此類的對象，並在對象中的調用之間存儲數據。 一些數據可能最好由構造函數保存。 你用這種方式制作的被稱為“仿函數”或“可調用對象”。

例：

class Incrementer:
    def __init__ (self, increment):
        self.increment = increment

    def __call__ (self, number):
        return self.increment + number

incrementerBy1 = Incrementer (1)

incrementerBy2 = Incrementer (2)

print (incrementerBy1 (3))
print (incrementerBy2 (3))

輸出：

4
5

[編輯]

請注意，您可以將@Tagc的答案與我的答案結合起來，以創建您正在尋找的內容：具有內置內存的“功能”。

將您的類命名為Clean而不是DataCleaner ，並將實例命名為clean 。 將方法命名為__call__而不是clean 。

Answer 2

就像功能的“記憶”一樣

中途重新發現面向對象的編程。

將數據清理邏輯封裝在類中，例如DataCleaner 。 使其成為實例在實例化時讀取同義詞數據，然后將該信息作為其狀態的一部分保留。 讓類公開一個對數據進行操作的clean方法：

class FileIO(object):
    def __init__(self, file_path, some_num, header):
        pass

    def openSynonyms(self):
        return []

class DataCleaner(object):
    def __init__(self, synonym_file):
        self.synonyms = FileIO(synonym_file, 3, header=False).openSynonyms()

    def clean(self, data):
        for g in data:
            if g in self.synonyms:
                # ...
                pass

if __name__ == '__main__':
    dataCleaner = DataCleaner('raw_data/input_file')
    dataCleaner.clean('some data here')
    dataCleaner.clean('some more data here')

作為未來可能的優化，您可以擴展此方法以使用工廠方法創建DataCleaner實例，該實例可以根據提供的同義詞文件緩存實例（因此您不需要每次對同一文件進行昂貴的重新計算） 。

Answer 3

我認為最簡單的方法是用另一個為函數提供本地synonyms的函數來裝飾你的“ clean ” _{（雙關語）}函數。 這是iamo更干凈，比創建另一個自定義類更簡潔，但仍然允許您在需要時（工廠函數）輕松更改“input_data”文件：

def defineSynonyms(datafile):
    def wrap(func):
        def wrapped(*args, **kwargs):
            kwargs['synonyms'] = FileIO(datafile, 3, header=False).openSynonyms()
            return func(*args, **kwargs)
        return wrapped
    return wrap

@defineSynonyms("raw_data/input_data")
def clean(my_data, synonyms={}):
    # do stuff with synonyms and my_data...
    pass