0

我不确定我所问的是否可能，但如果是的话，对于特定的应用程序会很方便。我正在为一个实验建立一个试验列表，其中一个目标可以完全匹配一个素数，或者它可以是一种特定方式的不匹配，它与目标保持一定的关系。更明确地说，我所有的刺激都属于 3 级分类法，形式如下：

H = {
    'A1':{
        'B1':{
            'C1':[],'C2':[],'C3':[] },
        'B2':{
            'C1':[],'C2':[],'C3':[] },
        'B3':{
            'C1':[],'C2':[],'C3':[] }
    },
    'A2':{
        'B1':{
            'C1':[],'C2':[],'C3':[] },
        'B2':{
            'C1':[],'C2':[],'C3':[] },
        'B3':{
            'C1':[],'C2':[],'C3':[] }
    }
}

“树”底部的每个列表都是一组特定的刺激。如果素数和目标匹配，那很简单。如果他们不这样做，我想从同一个 B 组下的不同 C 组中随机抽取，无需替换。

我的预期解决方案是利用（我认为）python 如何处理引用并制作一个临时列表，我可以从中弹出（）一个刺激。因此，如果试验不一致，并且质数来自 H[A1][B1][C1]，我想从列表中弹出（）：

tempList = H[A1][B1][C2] + H[A1][B1][C3]

但是，大概是因为我附加了两个列表，对字典中列表的引用被破坏了，所以如果我从临时列表中删除一个同义词，它不会反映在字典中。有没有办法保持参考？谢谢！

编辑：这个玩具示例不能按预期工作：

>>> d = {'A':[1,2,3],'B':[4,5,6]}
>>> l = d['A'] + d['B']
>>> l
[1, 2, 3, 4, 5, 6]
>>> l.pop(2)
3
>>> l
[1, 2, 4, 5, 6]
>>> d
{'A': [1, 2, 3], 'B': [4, 5, 6]}
4

2 回答 2

7

创建一个新类，该类H在初始化程序中获取子列表的路径，并覆盖__*item__()，这样底层列表将受到影响。

编辑：

部分示例：

class listxer(object):
  def __init__(self, structure, paths):
    self.structure = structure
    self.paths = paths

  def _descend(self, path):
    return reduce(lambda x,y: x[y], path, self.structure)

  def __len__(self):
    return sum(len(self._descend(path)) for path in self.paths)

  def __getitem__(self, item):
    if item < 0:
      raise ValueError('negative indices not supported!')
    for path in self.paths:
      cur = self._descend(path)
      if item > len(cur):
        item -= len(cur)
        continue
      else:
        return cur[item]
    else:
      raise IndexError('list index out of range')

H = [[[1, 2], [3, 4, 5]]]

mystruct = listxer(H, ((0, 0), (0, 1)))
print len(mystruct)
print mystruct[3]
于 2012-04-13T18:19:34.833 回答
1

虽然我很难给出一个专门的解决方案，但我会尽量给你下划线问题的答案

给定两个列表 A 和 B，如何生成列表 C 使得

如果 C = A + B

改变 C 最终会改变 A 或 B。

举个例子

我创建了两个列表 A 和 B，它们本身就是数字列表。

>>> A=[[i] for i in range(0,10)]
>>> B=[[i] for i in range(10,20)]

然后我把它们加起来。

>>> C=A+B

现在，如果我改变它的任何元素，C要么改变A要么B

>>> C[1][0]=-1
>>> C
[[0], [-1], [2], [3], [4], [5], [6], [7], [8], [9], [10], [11], [12], [13], [14], [15], [16], [17], [18], [19]]
>>> A
[[0], [-1], [2], [3], [4], [5], [6], [7], [8], [9]]
>>> C[11][0]=-1
>>> C
[[0], [-1], [2], [3], [4], [5], [6], [7], [8], [9], [10], [-1], [12], [13], [14], [15], [16], [17], [18], [19]]
>>> B
[[10], [-1], [12], [13], [14], [15], [16], [17], [18], [19]]
>>>
于 2012-04-13T18:28:58.877 回答