轉換為 dict/type 列表，一個包含字符串列表的字符串列表？

Question

a = ['foo', 'bar', ['can', 'haz']]

希望對每對字符串應用一個函數，替換它們，包括列表中的那些。 例如，

f = lambda k,v: {'key': k, 'val': v}

所以f(a)會變成：

[{'key': 'foo', 'val': 'bar'}, [{'key': 'can', 'val': 'haz'}]]

a上面只有 2 個維度，但我會對k 個維度感興趣。 開始與boltons.iterutils.remap一起破解一些東西，然后才明白用dict或其他f替換每個層次結構級別的所有非列表元素不是它的正確用例......

編輯：另一個例子

# create some random variables, alternative: `locals().update({c: (round(…`
a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u, v, w, x, y, z = tuple(
    (round(abs(random()) ** 10, 4)
     if randint(0, 1) % 2 == 0
     else randint(20, 50)
     if randint(0, 1) % 2 == 0
     else ('foo', 'bar', 'can', 'haz', 'bzr')[randint(0, 4)])
           for c in ascii_lowercase)

l1 = [a, b, c, d, e, f, g, [h, i, j, k],
      l, m, n, [o, p, q, r, [s, t, u, v, w, x, y, z], a, b], c, d, e]

g = lambda k,v: {'{}_key'.format(k): k, '{}_val'.format(k): v}

當有一對彼此相鄰時，它應該對其應用類型構造函數 T，並加入（我有一個add_to函數支持字典、列表等）任何以前直接相鄰的 - 沒有列表 inbetwixt - 否則原始標量應該以與之前相同的層次結構連接到列表中。 這是g(l1)的預期輸出，不包括對變量的評估：

[
    {'a_key': a, 'a_val': b,
     'c_key': c, 'c_val': d,
     'e_key': e, 'e_val': f},
    g,
    [
        {'h_key': h, 'h_val': i,
         'j_key': j, 'j_val': k}
    ],
    {'l_key': l, 'l_val': m},
    n,
    [
        {'o_key': o, 'o_val': p,
         'q_key': q, 'q_val': r},
        [
            {'s_key': s, 's_val': t,
             'u_key': u, 'u_val': v,
             'w_key': w, 'w_val': x,
             'y_key': y, 'y_val': z}
        ],
        {'a_key': a, 'a_val': b}
    ],
    {'c_key': c, 'c_val': d},
    e
]

Answer 1

下面有一堆亂七八糟的東西，但是solution()中的核心算法似乎並沒有那么糟糕。 我不能說我喜歡那里的sentinel ，但是......它讓其他一切都變得整潔。

https://repl.it/@altendky/ChartreuseWeightyRoot-10

import functools
import itertools
import random
import string

import attr
import toolz


@attr.s(frozen=True)
class Example:
    source = attr.ib()
    target = attr.ib()
    group_handler = attr.ib()


def random_example():
    a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u, v, w, x, y, z = tuple(
        (round(abs(random.random()) ** 10, 4)
        if random.randint(0, 1) % 2 == 0
        else random.randint(20, 50)
        if random.randint(0, 1) % 2 == 0
        else ('foo', 'bar', 'can', 'haz', 'bzr')[random.randint(0, 4)])
            for c in string.ascii_lowercase)

    l1 = [a, b, c, d, e, f, g, [h, i, j, k],
        l, m, n, [o, p, q, r, [s, t, u, v, w, x, y, z], a, b], c, d, e]

    auauughhghhhh = [
        {f'{a}_key': a, f'{a}_val': b,
        f'{c}_key': c, f'{c}_val': d,
        f'{e}_key': e, f'{e}_val': f},
        g,
        [
            {f'{h}_key': h, f'{h}_val': i,
            f'{j}_key': j, f'{j}_val': k}
        ],
        {f'{l}_key': l, f'{l}_val': m},
        n,
        [
            {f'{o}_key': o, f'{o}_val': p,
            f'{q}_key': q, f'{q}_val': r},
            [
                {f'{s}_key': s, f'{s}_val': t,
                f'{u}_key': u, f'{u}_val': v,
                f'{w}_key': w, f'{w}_val': x,
                f'{y}_key': y, f'{y}_val': z}
            ],
            {f'{a}_key': a, f'{a}_val': b}
        ],
        {f'{c}_key': c, f'{c}_val': d},
        e
    ]

    g = lambda k,v: {'{}_key'.format(k): k, '{}_val'.format(k): v}

    return Example(
        source=l1,
        target=auauughhghhhh,
        group_handler=functools.partial(process_group, paired_sequence_handler=lambda s: build_dict_by_update(s, g)),
    )


def process_group(group, paired_sequence_handler):
    processed_group = []

    if len(group) == 0:
        return processed_group

    odd = (len(group) % 2) != 0
    raw_pairs = group[:-1] if odd else group
    pairs = toolz.partition_all(2, raw_pairs)
    result = paired_sequence_handler(pairs)

    processed_group.append(result)

    if odd:
        processed_group.append(group[-1])

    return processed_group


def build_dict_by_update(sequence, pair_handler):
    result = {}
    for pair in sequence:
        result.update(pair_handler(*pair))

    return result


examples = [
    Example(
        source=['foo', 'bar', ['can', 'haz']],
        target=[{'key': 'foo', 'val': 'bar'}, [{'key': 'can', 'val': 'haz'}]],
        group_handler=functools.partial(process_group, paired_sequence_handler=lambda s: build_dict_by_update(s, lambda k,v: {'key': k, 'val': v})),
    ),
    random_example(),
]


def solution(source, group_handler):
    built = []
    group = []

    sentinel = object()

    for value in itertools.chain(source, [sentinel]):
        if not isinstance(value, list) and value is not sentinel:
            group.append(value)
            continue

        built.extend(group_handler(group))
        group = []

        if value is sentinel:
            break

        result = solution(
            source=value,
            group_handler=group_handler,
        )
        built.append(result)

    return built



for example in examples:
    result = solution(
        source=example.source,
        group_handler=example.group_handler,
    )

    succeeded = result == example.target

    print('?', succeeded)

    if not succeeded:
        print('?  ', example.target)
        print('?  ', result)

Answer 2

您將需要遞歸以支持未定義數量的級別。

假設您的級別在每個級別的列表中始終有 2 或 3 個項目，遞歸函數可能如下所示：

a = ['foo', 'bar', ['can', 'haz']]

def f(a):
    k,v,b,*_ = a+[None]
    result = [{"key":k,"val":v}]
    if b: result.append(f(b))
    return result

輸出：

print(f(a))

# [{'key': 'foo', 'val': 'bar'}, [{'key': 'can', 'val': 'haz'}]]


b = ['foo', 'bar', ['can', 'haz', ['boo','yah',['dino','dog']]]]
print(f(b))
[
  {'key': 'foo', 'val': 'bar'},
  [
     {'key': 'can', 'val': 'haz'},
     [
        {'key': 'boo', 'val': 'yah'},
        [
          {'key': 'dino', 'val': 'dog'}
        ]
     ]
  ]
]

Answer 3

假設每個列表的連續內容始終是鍵值對或列表：

a = ['foo', 'bar', ['can', 'haz']]

def f(a):
  itr = iter(a)
  return [f(a) if isinstance(x, list) else {'key': x, 'val': next(itr)} for x in itr]

# >>> f(a)
# [{'key': 'foo', 'val': 'bar'}, [{'key': 'can', 'val': 'haz'}]]

---

更新：

好吧，我必須說這讓我有點頭疼，但由於這是一個有趣的問題，而且是學習新事物的好機會，所以就在這里。
已經做了你想要的究竟是什么¹和A功能，因為你有一個遞歸操作的一些問題：

使用您的精確函數和輸入，我得到RecursionError: maximum recursion depth exceeded while calling a Python object

它沒有遞歸地做到這一點。 我確定這不是最終的解決方案，但它有效：

from functools import reduce
import operator

def traverse(lst):
  stack = [lst]
  res = [[]]

  substack = stack[0]
  subres = res[0]

  depth = 0

  while stack:
    if substack:
      if isinstance(substack[0], list):
        substack = substack[0]
        subres.append([])
        subres = subres[-1]
        depth += 1
      else:
        if len(substack) > 1 and not isinstance(substack[1], list):
            subres.append({'key': substack.pop(0), 'val': substack.pop(0)})
        else:
          subres.append(substack.pop(0))
    else:
        substack = reduce(operator.getitem, [0] * depth, stack)
        subres = reduce(operator.getitem, [-1] * depth, res)
        depth -= 1
        substack.pop(0)

  return res[0]

現場演示

_{1. 如果您僅將列表列表傳遞給函數，我不確定您應該如何知道輸出示例中 dict 鍵的確切前置名稱，所以我將把它留給您。}