Question

我有大约10,000个元素的列表，对于这个列表中的每个元素组合，我有一个数字。我需要在内存中包含所有这些数字和组合，以便通过两种变体调用它：comb(a,b)或comb(b,a)。

但是，我不想在字典或类似的内容中复制值，因为dict[a][b] = dict[b][a]。你能告诉我一个没有重复的数据结构吗？

Answer 1

我建议你选择frozenset。更多文档： https://docs.python.org/2/library/stdtypes.html#frozenset

所以你会有一个词典，其中frozensets将作为键（请注意，你不能使用常规集，因为它是可变的，不能充当字典键）。 Frozenset是无序的，因此它完全符合您的需求。唯一的限制是你不能复制元素 - frozenset是无序的独特元素序列。

所以你的dict看起来像：

pairs = {
frozenset(['a', 'b']): 4
....
}

来电pairs[frozenset(['a', 'b'])]等于pairs[frozenset(['b', 'a'])]

UPD：起初我真的很着急，所以做了一些错别字。现在修复它们:)

Answer 2

注意：我假设列表中的值是唯一的，您可以灵活地使用实际值的索引（或者您已准备好牺牲时间）

如果你真的想节省空间，我建议你使用列表列表来存储每个组合的值。您实际上不需要存储映射（a，b） - ＆gt; X

例如，请考虑清单：

const saveEpic = (action$, store) => {
  // used to control how many we want to take,
  // the rest will be buffered by .zip()
  const requestCount$ = new Rx.BehaviorSubject(1)
    .mergeMap(count => new Array(count));

  return action$.ofType(SAVE)
    .zip(requestCount$, action => action)
    .mergeMap(data =>
      Rx.Observable.from(saveClock(data.id, data.clock))
        .delay(1000)
        .mergeMap(() => saveConfig(data.id, data.config))
        .map(() => ({ type: COMPLETED, id: data.id }))
        // we're ready to take the next one, when available
        .do(() => requestCount$.next(1))
    );
};

假设组合/值对是：

a = [1,2,3,4]

组合/值对的存储将如下所示：

(1,2) -> 2, (1,3) -> 3, (1,4) -> 4, (2,3) -> 5, (2,4) -> 6, (3,4) -> 7

<强>检索：

假设列出且 comb_value 是全局的。（我们将同时干掉代码。）

comb_value = [[2,3,4],[5,6],[7]]

Answer 3

d = {}
d[('a', 'b')] = 12
d[('y', 'z')] = 34

和获取的功能

def fetch(a, b):
    return d.get((a, b)) if (a, b) in d else d.get((b, a), None)

输出：

In [16]:
fetch('b', 'a')
Out[16]:
12

In [17]:
fetch('y', 'z')
Out[17]:
34

In [19]:
fetch('z', 'y')
Out[19]:
34

In [20]:
fetch('m', 'n')

数据结构选择python

3 个答案: