Question

我有一个包含多个键的python字典，我希望每个键都成为一个二维数组（列表列表），如下所示：

mydict:{'key1':[['l1v1','l1v2'],['l2v1','l2v2']],'key2':[['l1v1','l1v2'],['l2v1','l2v2']]...}

我想要分配的值是形成长字符串的字符。

myStr = 'a_very_very_very_very_very_very_very_long_string.....'

我正在做的是这样的事情：

 i = 0
 for gr in range(2):
     tmp = []
     for ch in range(2):
        tmp.append(myStr[i])
        i += 1
     mydict['key1'].append(tmp)

但是我很确定这不是最有效/优雅/ pythonic的方式，我将不得不为我的字典中的每个键使用时间列表。

你对此有什么建议吗？谢谢！

更新

似乎我自己被误解了，所以我会更详细地解释我想要实现的目标。

首先，字符串是一个二进制字符串，如下所示：

binStr = '1001011001110110011011001101001011001....'

所以在第一次迭代中，我的字典的第一个键将被设置为字符串形状的字符串的前两个字符

'key1':[['1','0']]

然后我的字典的第二个键设置了接下来的两个字符。

'key2':[['0','1']]

依此类推，直到我没有更多的密钥，然后在第二次迭代中，我的密钥将包含字符串中的下两个值，并设置第二个列表，所以我会有这样的东西：

'key1':[['1','0'],['0','1']]
'key2':[['0','1'],['0','0']

我在开始时尝试执行以下操作，但python无法动态使用列表索引分配。

i = 0
for gr in range(2):
   for ch in range(2):
       mydict['key1'][gr][ch] = binStr[i]
       i += 1

Answer 1

你可以这样做：

def a(s):
    d = {}
    for i, c in enumerate(s):
        if not i % 4:
            a = [] 
            d['key%s' % ((i/4) + 1)] = a
        if not i % 2:
            b = []
            a.append(b)
        b.append(c)
    return d

用法：

>>> print a('a_very_very_very_very_very_very_very_long_string.....')
{'key9': [['v', 'e'], ['r', 'y']], 'key8': [['e', 'r'], ['y', '_']], 'key3': 
[['e', 'r'], ['y', '_']], 'key2': [['r', 'y'], ['_', 'v']], 'key1': [['a', '_'],
['v', 'e']], 'key7': [['r', 'y'], ['_', 'v']], 'key6': [['y', '_'], ['v', 'e']],
'key5': [['_', 'v'], ['e', 'r']], 'key4': [['v', 'e'], ['r', 'y']], 'key14':
[['.']], 'key13': [['.', '.'], ['.', '.']], 'key12': [['r', 'i'], ['n', 'g']],
'key11': [['g', '_'], ['s', 't']], 'key10': [['_', 'l'], ['o', 'n']]}

Answer 2

也许不是pythonic，但至少是简单的，是迭代字符串的索引，将字符对附加到列表列表中的相关列表。列表列表最终转换为字典。

number_of_keys = 15

def get_dict(input_string):
    lists = [[] for _ in range(number_of_keys)]
    for i in range(0, len(input_string), 2):
        lists[int(i/2) % number_of_keys].append(list(input_string[i:i+2]))
    return {'key{}'.format(i+1): L for i, L in enumerate(lists)}

或者，您可以使用基于range相关指数的理解。

def get_dict9(input_string):
    return {'key{}'.format(i + 1): 
        [list(input_string[j:j+2]) 
        for j in range(i * 2, len(input_string), number_of_keys * 2)] 
        for i in range(number_of_keys)}

Answer 3

它可能就是我，但我不清楚你要追求的是与键和值的相关性。但是，您可以在列表推导中嵌套for..in语句以产生类似的效果。

同样，这是一个基于不知道你的键和值实际上彼此有什么关系的例子。

>>> mydict = {}
>>> for x in range(0, 4):
...     mydict["key{}".format(x)] = ["l{}v{}".format(x, i) for i in range(0, 3)] 
... 
>>> mydict
{'key3': ['l3v0', 'l3v1', 'l3v2'], 'key2': ['l2v0', 'l2v1', 'l2v2'], 'key1': ['l1v0', 'l1v1', 'l1v2'], 'key0': ['l0v0', 'l0v1', 'l0v2']}
>>>

如果你的值只是迭代了相同的模式，那么它们也可以受制于它们自己的嵌套列表理解。

>>> mydict = {}
>>> for x in range(0, 4):
...     mydict["key{}".format(x)] = ["l{}v{}".format(i, j) for i in (1, 2) for j in (1, 2)]
... 
>>> mydict
{'key3': ['l1v1', 'l1v2', 'l2v1', 'l2v2'], 'key2': ['l1v1', 'l1v2', 'l2v1', 'l2v2'], 'key1': ['l1v1', 'l1v2', 'l2v1', 'l2v2'], 'key0': ['l1v1', 'l1v2', 'l2v1', 'l2v2']}
>>>

这些模式的关键是

["{}{}".format(i, j) for i in my_container for j in my_other_container]

通过这种方式，您可以迭代两个值，并为值的每次迭代创建一对。

您还拥有mydict.fromkeys(keys, values)方法，该方法返回带有所述键值对的dict。不确定它是否仍然像你想要的那样“pythonic”，但是返回类似dict的单行将看起来像

>>> newdict = mydict.fromkeys(["key{}".format(x) for x in range(0, 5)], ["l{}v{}".format(i, j) for i in (1, 2) for j in (3, 4)])
>>> newdict
{'key3': ['l1v3', 'l1v4', 'l2v3', 'l2v4'], 'key2': ['l1v3', 'l1v4', 'l2v3', 'l2v4'], 'key1': ['l1v3', 'l1v4', 'l2v3', 'l2v4'], 'key0': ['l1v3', 'l1v4', 'l2v3', 'l2v4'], 'key4': ['l1v3', 'l1v4', 'l2v3', 'l2v4']}
>>>

在单独的行上分解它会使它更具可读性：

mykeys = ['key{}'.format(x) for x in range(0, 5)]
myvals = ['l{}v{}'.format(i, j) for i in (1, 2) for j in range(1, 2)]
mydict = {}.fromkeys(mykeys, myvals)

编辑：你可以通过几种方式逐步完成你的字符串;再次，使用列表理解，您可以使用：

vals = [myStr[x:x+2] for x in range(0, len(myStr)) if x % 2 == 0]

例如：

>>> mystr = "abcdefghi"
>>> STEP = 2
>>> group = [mystr[x:x+STEP] for x in range(0, len(mystr)) if x % STEP == 0]
>>> group
['ab', 'cd', 'ef', 'gh', 'i']
>>>

请注意，如果字符数不均匀，则会正常失败，如上所示。从本质上讲，STEP可以是您想要提取的任何大小的字符串块。

有效地将值添加到二维数组

3 个答案: