Как лучше всего хранить установленные данные в Python?

В наборах нет ключей. Элемент является ключ.

Если вы думаете, что вам нужны ключи, у вас есть сопоставление. Более или менее по определению.

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

Вы говорите о таком словаре?

{ 'id1': [ ('description1a', 'type1'), ('description1b','type1') ], 
  'id2': [ ('description2', 'type2') ],
...
}

Конечно, это кажется минимальным. ID представлены только один раз.

Возможно, у вас есть что-то подобное?

{ 'id1': ( ('description1a', 'description1b' ), 'type1' ),
  'id2': ( ('description2',), 'type2' ),
...
}

Не уверен, что можно найти что-то более компактное, если не прибегать к использованию модуля struct.

Как насчет использования словаря {id: (description, id_type)}? Или словарь {(id, id_type): description}, если (id, id_type) является ключом.

Наборы в Python реализованы с помощью хеш-таблиц. В более ранних версиях они фактически были реализованы с помощью наборов, но это изменило AFAIK. Единственное, что вы сохраняете, используя набор, - это размер указателя для каждой записи (указателя на значение).

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

class ProteinTuple(tuple):
     def __new__(cls, m1, m2, m3):
         return tuple.__new__(cls, (m1, m2, m3))

     def __hash__(self):
         return hash(self[0])

Имейте в виду, что в этом случае вы платите за дополнительный вызов функции __hash__, потому что в противном случае это был бы метод C.

Я бы обратился к предложениям Константина, вынул идентификатор из кортежа и посмотрел, насколько это помогает.

Я предполагаю, что проблема, которую вы пытаетесь решить, сокращая объем используемой памяти, - это ограничение адресного пространства вашего процесса. Кроме того, вы ищете структуру данных, которая позволяет вам быстро вставлять и последовательно считывать данные.

Используйте меньше структур, кроме строк (str)

Вы задаетесь вопросом, как структурировать данные в одном процессе, чтобы использовать меньше памяти. Единственный канонический ответ на этот вопрос (если вам все еще нужен ассоциативный поиск), используйте как можно меньше других структур, кроме строк Python (str, а не unicode). Хеш (словарь) python довольно эффективно хранит ссылки на ваши строки (это не реализация b-дерева).

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

Альтернативное решение

Я бы предложил другое решение, которое не связано с изменением структуры данных на что-то, что сложнее вставить или интерпретировать.

• Разделите информацию на несколько процессов, каждый из которых будет содержать любую удобную для этого структуру данных.
• Реализуйте межпроцессное взаимодействие с сокетами, чтобы процессы могли полностью находиться на других машинах.
• Попробуйте разделить свои данные, чтобы минимизировать взаимодействие между процессами (ввод-вывод выполняется очень медленно по сравнению с циклами процессора).

Преимущество описываемого мною подхода состоит в том, что

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

Существует множество пакетов и подходов к распределенной обработке, некоторые из которых

• Линда
• обработка

Это все еще неясно, но похоже, что у вас есть несколько списков [(id, description, type) ...]

Идентификаторы уникальны в пределах списка и согласованы между списками.

Вы хотите создать UNION: единый список, в котором каждый идентификатор встречается один раз, возможно, с несколькими описаниями.

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

Это может быть (если я правильно угадаю) стандартная операция «слияния» из нескольких источников.

source1.sort()
source2.sort()
result= []
while len(source1) > 0 or len(source2) > 0:
    if len(source1) == 0:
        result.append( source2.pop(0) )
    elif len(source2) == 0:
        result.append( source1.pop(0) )
    elif source1[0][0] < source2[0][0]:
        result.append( source1.pop(0) )
    elif source2[0][0] < source1[0][0]:
        result.append( source2.pop(0) )
    else:
        # keys are equal
        result.append( source1.pop(0) )
        # check for source2, to see if the description is different.

Это объединяет два списка путем сортировки и слияния. Нет сопоставления, нет хеша.

Если вы выполняете n-way слияние с удалением дубликатов, возможно, вы ищете следующее.

Этот генератор объединит любое количество источников. Каждый источник должен быть последовательностью. Ключ должен находиться в позиции 0. Это дает объединенную последовательность по одному элементу за раз.

def merge( *sources ):
    keyPos= 0
    for s in sources:
        s.sort()
    while any( [len(s)>0 for s in sources] ):
        topEnum= enumerate([ s[0][keyPos] if len(s) > 0 else None for s in sources ])
        top= [ t for t in topEnum if t[1] is not None ]
        top.sort( key=lambda a:a[1] )
        src, key = top[0]
        #print src, key
        yield sources[ src ].pop(0)

Этот генератор удаляет дубликаты из последовательности.

def unique( sequence ):
    keyPos= 0
    seqIter= iter(sequence)
    curr= seqIter.next()
    for next in seqIter:
        if next[keyPos] == curr[keyPos]:
            # might want to create a sub-list of matches
            continue
        yield curr
        curr= next
    yield curr

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

for u in unique( merge( source1, source2, source3, ... ) ):
    print u

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