Разобрать строку с трехуровневым разделителем в словарь

В основном я взял ответ Кайла и сделал его более удобным для будущего:

def dictelem(input):   
    parts   = input.split('&')
    listing = [part.split('=') for part in parts]

    result = {}
    for entry in listing:
        head, tail = entry[0], ''.join(entry[1:])
        if ':' in tail:
            entries = tail.split(',')
            result.update({ head : dict(e.split(':') for e in entries) })
        else:
            result.update({head: tail})

    return result

Вот двухстрочный, который делает то, что, как я думаю, вы хотите:

dictelem = lambda x: x if ':' not in x[1] else [x[0],dict(y.split(':') for y in x[1].split(','))]
a = dict(dictelem(x.split('=')) for x in input.split('&'))

Могу ли я взять гладкую двухуровневую команду разбора разграничения, которую я нашел:

requestDict = dict(line.split('=') for line in clientRequest.split('&'))

и добавить к нему третий уровень для обработки и сохранения словарей 2-го уровня?

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

Например, что должно произойти с 'PC'? Вы хотите превратить это в {'PC': None}? Или, может быть, set {'PC'}? Или list ['PC']? Или просто оставить в покое? Вы должны решить и написать логику для этого, и попытка написать это в виде выражения сделает ваше решение очень трудным для чтения.

Итак, давайте поместим эту логику в отдельную функцию:

def parseCommasAndColons(s):
    bits = [bit.split(':') for bit in s.split(',')]
    try:
        return dict(bits)
    except ValueError:
        return bits

Это вернет dict, например {'ip': '192.168.10.10', 'deviceid': '1234', 'optdata': '75BCD15'} или {'AMT-Cam': 'avatar'}, для случаев, когда внутри каждого компонента, разделенного запятыми, есть двоеточие, и list, например ['1342177342'], для случаев, когда ни один из них не имеет двоеточия.

Даже это может быть слишком умно; Я мог бы сделать проверку «это в формате словаря» более явной, вместо того, чтобы просто пытаться преобразовать список списков и посмотреть, что произойдет.

В любом случае, как бы вы вернули это в исходное понимание?

Ну, вы хотите вызвать его по значению в line.split('='). Итак, давайте добавим для этого функцию:

def parseCommasAndColonsForValue(keyvalue):
    if len(keyvalue) == 2:
        return keyvalue[0], parseCommasAndColons(keyvalue[1])
    else:
        return keyvalue

requestDict = dict(parseCommasAndColonsForValue(line.split('=')) 
                   for line in clientRequest.split('&'))

И последнее: если вам не нужно работать на более старых версиях Python, вам не следует часто вызывать dict в выражении генератора. Если его можно переписать как понимание словаря, оно почти наверняка будет более ясным, а если его нельзя переписать как понимание словаря, то, вероятно, оно не должно быть однострочным выражением в первую очередь.

Конечно, разбиение выражений на отдельные выражения, превращение некоторых из них в операторы или даже функции и присвоение им имен делает ваш код длиннее, но это не обязательно означает, что он хуже. Около половины Дзен Питона (import this) посвящено объяснению почему. Или одна цитата из Гвидо: «Python — это плохой язык для гольфа, и это намеренно».

Если вы действительно хотите знать, как это будет выглядеть, давайте разобьем его на два шага:

>>> {k: [bit2.split(':') for bit2 in v.split(',')] for k, v in (bit.split('=') for bit in s.split('&'))}
{'clientid': [['b59694bf-c7c1-4a3a-8cd5-6dad69f4abb0']],
 'junketid': [['1342177342']],
 'keyid': [['987654321']],
 'md': [['AMT-Cam', 'avatar']],
 'mk': [['PC']],
 'playbackmode': [['st']],
 'sessionid': [['']],
 'userdata': [['ip', '192.168.10.10'],
              ['deviceid', '1234'],
              ['optdata', '75BCD15']],
 'ver': [['6']],
 'version': [['6.7.8.9012']]}

Это иллюстрирует, почему вы не можете просто добавить вызов dict для внутреннего уровня, потому что большинство этих вещей на самом деле не словари, потому что в них нет двоеточий. Если бы вы изменили это, то это было бы просто так:

{k: dict(bit2.split(':') for bit2 in v.split(',')) for k, v in (bit.split('=') for bit in s.split('&'))}

Я не думаю, что это очень читабельно, и я сомневаюсь, что большинство программистов на Python справятся. Прочитать его через 6 месяцев и попытаться понять, что я имел в виду, потребовало бы гораздо больше усилий, чем его написание.

И пытаться его отлаживать будет не весело. Что произойдет, если вы запустите это на своем входе с отсутствующими двоеточиями? ValueError: dictionary update sequence element #0 has length 1; 2 is required. Какая последовательность? Без понятия. Вы должны разбить его шаг за шагом, чтобы увидеть, что не работает. Это не весело.

Итак, надеюсь, это иллюстрирует, почему вы не хотите этого делать.