У меня есть скрипт python, в котором мне приходится иметь дело со списками, заполненными различными этапами обработки, которые обрабатываются один за другим внешним контроллером. Каждый шаг имеет имя и содержимое , которое интерпретируется контроллером. Порядок обработки определяется позицией списка.
Эти шаги могут выполняться в любой комбинации и в каждой позиции списка. Однако каждый шаг сам по себе может появляться только один раз в каждом списке.
Вот пример двух списков обработки:
from typing import Dict
from typing import List
list_one: List[Dict[str, str]] = [
{"name": "A", "content": "<various data>"}, # 0
{"name": "B", "content": "<various data>"}, # 1
{"name": "C", "content": "<various data>"}, # 2
{"name": "D", "content": "<various data>"}, # 3
{"name": "E", "content": "<various data>"}, # 4
{"name": "F", "content": "<various data>"}, # 5
{"name": "G", "content": "<various data>"}, # 6
{"name": "H", "content": "<various data>"}, # 7
{"name": "I", "content": "<various data>"}, # 8
{"name": "J", "content": "<various data>"}, # 9
{"name": "K", "content": "<various data>"}, # 10
{"name": "L", "content": "<various data>"}, # 11
{"name": "M", "content": "<various data>"}, # 12
{"name": "$$$", "content": "<various data>"}, # 13
{"name": "O", "content": "<various data>"} # 14
]
list_two: List[Dict[str, str]] = [
{"name": "P", "content": "<various_data>"}, # 0
{"name": "$$$", "content": "<various_data>"}, # 1
{"name": "D", "content": "<various_data>"}, # 2
{"name": "E", "content": "<various_data>"}, # 3
{"name": "F", "content": "<various_data>"}, # 4
{"name": "G", "content": "<various_data>"}, # 5
{"name": "H", "content": "<various_data>"}, # 6
]
В настоящее время возникают ситуации, когда у меня есть сравнить различные списки шагов процесса друг с другом. Как правило, это может быть сделано на основе имени шага,
. Для этой цели я предусмотрел два новых объекта списка.
compare_list_one: List[Dict[str, str]]
compare_list_two: List[Dict[str, str]]
Я заполняю первый список копия содержимого Списка 1, после чего я перебираю каждый шаг в списке сравнения 1 и проверяю, есть ли его имя в списке 2. Если это так, я сравниваю его непосредственно с шагом в Списке сравнения 1. Если это так не существует, я установил пустой объект словаря. После этого я вставляю «пропущенные» шаги во второй список (и пустой список в первый список для каждого вставленного шага).
К сожалению, теперь есть «особые условия», с которыми мне приходится иметь дело , Каждый идентификатор шага встречается только один раз в каждом списке, но возможно, что (несмотря на то, что он имеет одно и то же имя), он имеет разные значения в потоке процесса в другой позиции. В этом случае мне не разрешено сравнивать эти два слова друг с другом, и вместо этого мне приходится сравнивать их с пустыми словарями.
Чтобы сделать вещи более сложными, я должен быть в состоянии сделать это сравнение из списка 1 в список 2 а также из списка 2 в список 1.
Ниже приведен пример того, как должен выглядеть «конечный результат» двух списков сравнения для обоих вариантов, чтобы я мог сравнить их друг с другом в более поздний шаг. Выше приведен «особый случай» с именем «$$$». Это происходит почти в начале в одном потоке процессов, во втором потоке почти в конце.
"""
compare_list_one[0] == {"name": "A", ...} # 0 ==> compare_list_two[0] == {}
compare_list_one[1] == {"name": "B", ...} # 1 ==> compare_list_two[1] == {}
compare_list_one[2] == {"name": "C", ...} # 2 ==> compare_list_two[2] == {}
compare_list_one[3] == {} - ==> compare_list_two[3] == {"name": "P", ...} # 0
compare_list_one[4] == {} - ==> compare_list_two[4] == {"name": "$$$", ...} # 1
compare_list_one[5] == {"name": "D", ...} # 3 ==> compare_list_two[5] == {"name": "D", ...} # 2
compare_list_one[6] == {"name": "E", ...} # 4 ==> compare_list_two[6] == {"name": "E", ...} # 3
compare_list_one[7] == {"name": "F", ...} # 5 ==> compare_list_two[7] == {"name": "F", ...} # 4
compare_list_one[8] == {"name": "G", ...} # 6 ==> compare_list_two[8] == {"name": "G", ...} # 5
compare_list_one[9] == {"name": "H", ...} # 7 ==> compare_list_two[9] == {"name": "H", ...} # 6
compare_list_one[10] == {"name": "I", ...} # 8 ==> compare_list_two[10] == {}
compare_list_one[11] == {"name": "J", ...} # 9 ==> compare_list_two[11] == {}
compare_list_one[12] == {"name": "K", ...} # 10 ==> compare_list_two[12] == {}
compare_list_one[13] == {"name": "L", ...} # 11 ==> compare_list_two[13] == {}
compare_list_one[14] == {"name": "M", ...} # 12 ==> compare_list_two[14] == {}
compare_list_one[15] == {"name": "$$$", ...} # 13 ==> compare_list_two[15] == {}
compare_list_one[16] == {"name": "O", ...} # 14 ==> compare_list_two[16] == {}
compare_list_one[0] == {"name": "P", ...} # 0 ==> compare_list_two[0] == {}
compare_list_one[1] == {"name": "$$$", ...} # 1 ==> compare_list_two[1] == {}
compare_list_one[2] == {} ==> compare_list_two[2] == {"name": "A", ...} # 0
compare_list_one[3] == {} ==> compare_list_two[3] == {"name": "B", ...} # 1
compare_list_one[4] == {} ==> compare_list_two[4] == {"name": "C", ...} # 2
compare_list_one[5] == {"name": "D", ...} # 2 ==> compare_list_two[5] == {"name": "D", ...} # 3
compare_list_one[6] == {"name": "E", ...} # 3 ==> compare_list_two[6] == {"name": "E", ...} # 4
compare_list_one[7] == {"name": "F", ...} # 4 ==> compare_list_two[7] == {"name": "F", ...} # 5
compare_list_one[8] == {"name": "G", ...} # 5 ==> compare_list_two[8] == {"name": "G", ...} # 6
compare_list_one[9] == {"name": "H", ...} # 6 ==> compare_list_two[9] == {"name": "H", ...} # 7
compare_list_one[10] == {} ==> compare_list_two[10] == {"name": "I", ...} # 8
compare_list_one[11] == {} ==> compare_list_two[11] == {"name": "J", ...} # 9
compare_list_one[12] == {} ==> compare_list_two[12] == {"name": "K", ...} # 10
compare_list_one[13] == {} ==> compare_list_two[13] == {"name": "L", ...} # 11
compare_list_one[14] == {} ==> compare_list_two[14] == {"name": "M", ...} # 12
compare_list_one[15] == {} ==> compare_list_two[15] == {"name": "$$$", ...} # 13
compare_list_one[16] == {} ==> compare_list_two[16] == {"name": "O", ...} # 14
"""
Создание списков сравнения на основе имен не составляет проблем. Но как я могу эффективно справиться с этими частными случаями? Мне не хватает того, чтобы подумать здесь. Это вообще возможно?