эффективное чтение файла(ов)

Одна большая проблема заключается в том, что вы читаете файл за один раз, используя readlines. Это потребует загрузки ВСЕХ в память за один раз. Я сомневаюсь, что у вас есть столько памяти.

Пытаться:

with open(filename) as fh:
    out.write(fh.readline()) # ticker
    for line in fh: #iterate through lines 'lazily', reading as you go.
        c = line.split(',')

код стиля для начала. Это должно очень помочь. Здесь, в контексте:

# make compound with cell activity (to a target) list first

if os.path.exists(filename):
    with open(filename) as fh:
        out.write(fh.readline()) # ticker
        for line in fh:
            cols = line.split(',')
            if cols[17] == " Cell ":
                cell_comp_id.append(cols[3])

синтаксис with open(...) as — это очень распространенная идиома Python, которая автоматически обрабатывает закрытие файла, когда вы заканчиваете блок with или если есть ошибка. Очень полезный.

наборы

Следующее, как вы предлагаете, лучше использовать sets.

Вам не нужно каждый раз заново создавать набор, вы можете просто обновить его, чтобы добавить элементы. Вот пример кода set (написан в стиле интерпретатора python, >>> в начале означает, что это строка для ввода — на самом деле не вводите бит >>>!):

>>> my_set = set()
>>> my_set
set()

>>> my_set.update([1,2,3])
>>> my_set
set([1,2,3])

>>> my_set.update(["this","is","stuff"])
>>> my_set
set([1,2,3,"this","is","stuff"])

>>> my_set.add('apricot')
>>> my_set
set([1,2,3,"this","is","stuff","apricot"])

>>> my_set.remove("is")
>>> my_set
set([1,2,3,"this","stuff","apricot"])

поэтому вы можете добавлять элементы и удалять их из набора, не создавая новый набор с нуля (что вы делаете каждый раз с битом cell_comp_id=list(set(cell_comp_id)).

Вы также можете получить различия, пересечения и т. д.:

>>> set(['a','b','c','d']) & set(['c','d','e','f'])
set(['c','d'])

>>> set([1,2,3]) | set([3,4,5])
set([1,2,3,4,5])

Дополнительную информацию см. в документах.

Итак, давайте попробуем что-то вроде:

cells = set()
enzymes = set()
biochemicals = set()

with open(filename) as fh:
    out.write(fh.readline()) #ticker
    for line in fh:
        cols = line.split(',')
        row_id = cols[3]
        row_category = cols[17]

        if row_category == ' Cell ':
            cells.add(row_id)
        elif row_category == ' Biochemical ':
            biochemicals.add(row_id)
        elif row_category == ' Enzyme ':
            enzymes.add(row_id)

Теперь у вас есть наборы клеток, биохимических веществ и ферментов. Вам нужно только их поперечное сечение, поэтому:

cells_and_enzymes = cells & enzymes
cells_and_biochemicals = cells & biochemicals

Затем вы можете снова просмотреть все файлы и просто проверить, есть ли row_id (или c[3]) в одном из этих списков, и если да, распечатать его.

На самом деле вы можете объединить эти два списка еще больше:

cells_with_enz_or_bio = cells_and_enzymes | cells_and_biochemicals

которые были бы клетками, у которых есть ферменты или биохимические вещества.

Итак, когда вы просматриваете файлы во второй раз, вы можете сделать:

if row_id in cells_with_enz_or_bio:
    out.write(line)

после всего этого?

Простого использования этих предложений может быть достаточно, чтобы помочь вам. Однако вы все еще храните в памяти целые наборы клеток, биохимических веществ и ферментов. И вы по-прежнему просматриваете файлы дважды.

Итак, есть два способа потенциально ускорить его, оставаясь при этом с одним процессом Python. Я не знаю, сколько памяти у вас есть. Если вам не хватает памяти, это может немного замедлить работу.

уменьшая наборы, как мы идем.

Если у вас есть миллион записей, и 800 000 из них являются парными (имеют запись клетки и биохимическую запись), то к тому времени, когда вы дойдете до конца списка, вы будете хранить 800 000 идентификаторов в наборах. Чтобы уменьшить использование памяти, как только мы определили, что хотим вывести запись, мы можем сохранить эту информацию (которую мы хотим напечатать запись) в файл на диске и прекратить хранить ее в памяти. Затем мы могли бы прочитать этот список позже, чтобы выяснить, какие записи нужно напечатать.

Поскольку это увеличивает дисковый ввод-вывод, это может быть медленнее. Но если у вас заканчивается память, это может уменьшить подкачку и, таким образом, ускорить работу. Трудно сказать.

with open('to_output.tmp','a') as to_output:
    for a in App:
        # ... do your reading thing into the sets ...

        if row_id in cells and (row_id in biochemicals or row_id in enzymes):
            to_output.write('%s,' % row_id)
            cells.remove(row_id)
            biochemicals.remove(row_id)
            enzymes.remove(row_id)

после того как вы прочитали все файлы, у вас теперь есть файл (to_output.tmp), который содержит все идентификаторы, которые вы хотите сохранить. Итак, вы можете прочитать это обратно в python:

with open('to_output.tmp') as ids_file:
    ids_to_keep = set(ids_file.read().split(','))

что означает, что вы можете затем при втором прогоне файлов просто сказать:

if row_id in ids_to_keep:
    out.write(line)

используя dict вместо наборов:

Если у вас много памяти, вы можете обойти все это и использовать dicts для хранения данных, что позволит вам просматривать файлы только один раз, а не использовать наборы вообще.

cells = {}
enzymes = {}
biochemicals = {}

with open(filename) as fh:
    out.write(fh.readline()) #ticker
    for line in fh:
        cols = line.split(',')
        row_id = cols[3]
        row_category = cols[17]

        if row_category == ' Cell ':
            cells[row_id] = line
        elif row_category == ' Biochemical ':
            biochemicals[row_id] = line
        elif row_category == ' Enzyme ':
            enzymes[row_id] = line

        if row_id in cells and row_id in biochemicals:
            out.write(cells[row_id])
            out.write(biochemicals[row_id])
            if row_id in enzymes:
                out.write(enzymes[row_id])
        elif row_id in cells and row_id in enzymes:
            out.write(cells[row_id])
            out.write(enzymes[row_id])

Проблема с этим методом заключается в том, что если какие-либо строки дублируются, он запутается.

Если вы уверены, что входные записи уникальны и что они любые содержат ферментные или биохимические записи, но не оба, вы можете легко добавить del cells[row_id] и соответствующие другие, чтобы удалить строки из словарей после того, как вы распечатал их, что уменьшило бы использование памяти.

Надеюсь, это поможет :-)

Метод, который я использовал для быстрой работы с большими файлами в Python, заключается в использовании многопроцессорной библиотеки, чтобы разбить файл на большие куски и обрабатывать эти куски параллельно в рабочих подпроцессах.

Вот общий алгоритм:

1. В зависимости от объема доступной памяти в системе, которая будет запускать этот сценарий, решите, какую часть файла вы можете позволить себе прочитать в память за один раз. Цель состоит в том, чтобы сделать фрагменты настолько большими, насколько это возможно, не вызывая перераспределения.

2. Передайте имя файла и начальную/конечную позиции фрагмента подпроцессам, каждый из которых откроет файл, прочитает и обработает свои разделы файла и вернет свои результаты.

В частности, мне нравится использовать многопроцессорный пул, затем создавать список позиций начала/остановки фрагмента, а затем использовать pool.map(). Это будет заблокировано до тех пор, пока все не закончатся, и результаты каждого подпроцесса будут доступны, если вы поймаете возвращаемое значение из вызова карты.

Например, вы можете сделать что-то подобное в своих подпроцессах:

# assume we have passed in a byte position to start and end at, and a file name:

with open("fi_name", 'r') as fi:
    fi.seek(chunk_start)
    chunk = fi.readlines(chunk_end - chunk_start)

retriever = operator.itemgetter(3, 17) # extracts only the elements we want
APPIDs = {}

for line in chunk:

    ID, category = retriever(line.split())
    try:
        APPIDs[ID].append(category) # we've seen this ID before, add category to its list
    except KeyError:
        APPIDs[ID] = [category] # we haven't seen this ID before - make an entry

# APPIDs entries will look like this:
# 
# <APPID> : [list of categories]

return APPIDs

В вашем основном процессе вы должны получить все возвращенные словари и устранить дубликаты или перекрытия, а затем вывести что-то вроде этого:

for ID, categories in APPIDs.iteritems():
    if ('Cell' in categories) and ('Biochemical' in categories or 'Enzyme' in categories):
         # print or whatever

Пара замечаний/оговорок:

• Обратите внимание на нагрузку на жесткий диск/SSD/где бы ни находились ваши данные. Если ваш текущий метод уже максимально использует свою пропускную способность, вы, вероятно, не увидите никаких улучшений производительности от этого. Вместо этого вы можете попробовать реализовать тот же алгоритм с поточностью.
• Если вы получаете большую нагрузку на жесткий диск, которая НЕ связана с перегрузкой памяти, вы также можете уменьшить количество одновременных подпроцессов, которые вы разрешаете в пуле. Это приведет к меньшему количеству запросов на чтение к диску, но при этом будет использоваться по-настоящему параллельная обработка.
• Ищите закономерности во входных данных, которые вы можете использовать. Например, если вы можете полагаться на то, что совпадающие APPID будут находиться рядом друг с другом, вы можете фактически выполнять все свои сравнения в подпроцессах и позволить вашему основному процессу зависать до тех пор, пока не придет время объединить структуры данных подпроцесса.

TL;DR

Разбейте файл на фрагменты и обрабатывайте их параллельно с помощью библиотеки многопроцессорной обработки.