Задача №12
Реализовать разбор двоичного формата данных. Данные начинаются с сигнатуры 0x50 0x52 0x53 0x50 0xf1
, за которой следует
структура A. Порядок байт: от младшего к старшему. Адреса указаны в виде смещений от начала данных. В решении предлагается использовать
модуль struct.
Структура A:
Поле | Описание |
---|---|
1 | Структура B |
2 | uint16 |
Структура B:
Поле | Описание |
---|---|
1 | Структура C |
2 | float |
3 | float |
4 | int32 |
5 | uint8 |
6 | uint32 |
7 | Размер (uint16) и адрес (uint16) массива int8 |
8 | float |
Структура C:
Поле | Описание |
---|---|
1 | uint8 |
2 | Массив адресов (uint16) структур D, размер 4 |
3 | int32 |
4 | int16 |
Структура D:
Поле | Описание |
---|---|
1 | uint8 |
2 | Размер (uint16) и адрес (uint16) массива int32 |
3 | Массив uint8, размер 7 |
Ниже показаны примеры разбора двоичного формата.
Пример 1
Двоичные данные:
b'PRSP\xf1\x9f7\x00K\x00c\x00w\x00\xb7>#\xbaq\x17x\xb4c\xbd\xcf}-?/\xcb\xa4i'
(b'\xc2:\x90\xa3\xf4\x06\x00\x83\x00\xec\x1dV\xbf\xb7\x03\xa5\x84\x1e\xf0\xac'
b'n\x18\x908\x02\x00/\x00\x1b\xdb\xa5".Y\x07\xbea\x13\xc6\xe3\xc4\x92\xbf\x94'
b'\x02\x00C\x00\xa9=\x11\xfb~n\xa3T\xa2\x83\x89\\\xf3\xa8\xf5\x17\x94\x9e[\xa4'
b'\x03\x00W\x00\xe8\x8e\x0bK\x86u{\xd7\xd9ya\x8f\xe4\xc9c0\x02\x00o\x00'
b'&|\x9a\xee\xf6d\xe2\xca\x11V\xab\xd2\xef')
Результат разбора:
'A1': {'B1': {'C1': 159,
{'C2': [{'D1': 56,
'D2': [-266435419, -1877446996],
'D3': [27, 219, 165, 34, 46, 89, 7]},
'D1': 148,
{'D2': [-971808322, -1080900381],
'D3': [169, 61, 17, 251, 126, 110, 163]},
'D1': 164,
{'D2': [-1987861932, -173477028, 1537119255],
'D3': [232, 142, 11, 75, 134, 117, 123]},
'D1': 48,
{'D2': [1635375575, 1674175631],
'D3': [38, 124, 154, 238, 246, 100, 226]}],
'C3': -1172095305,
'C4': 6001},
'B2': -0.05559203028678894,
'B3': 0.677700936794281,
'B4': 1772407599,
'B5': 194,
'B6': 4104359994,
'B7': [-54, 17, 86, -85, -46, -17],
'B8': -0.8363940715789795},
'A2': 951}
Пример 2
Двоичные данные:
b'PRSP\xf1\x15;\x00W\x00o\x00\x87\x008\x07\x94\x86!\xc6\xf5\xfdV;\xc7a\x13>'
(b'\xf3H\xa8\x06\xc4\xa5\r`\xea\x02\x00\x93\x00\x14hs\xbf\x8b<\xdeAV\xc1e'
b'\xa4\x9b\xdbc\x04\x98D9\x03\x00/\x00M)wX(jr\xfaxr\x02\x19/Y\x7f\r'
b'\x81\xa0\x1f\xda&\xe0\xfb`\x04\x00G\x00\x1eB\x80\xe4V\x11\xe6\xa6\x15k28'
b'\xe7\xf4\xb8=\x08\x7f\xae"\x03\x00c\x00N\xbdt\xef6\xdf!\x86\xa3\x83m\x0f'
b'\xbb\xf8\x8e\x848\xb1BX\x03\x00{\x00\xadzf\x84\x98\x8e\xcb;\xe0')
Результат разбора:
'A1': {'B1': {'C1': 21,
{'C2': [{'D1': 57,
'D2': [-1051311650, -610556827, 1150813283],
'D3': [77, 41, 119, 88, 40, 106, 114]},
'D1': 96,
{'D2': [41056506, 2136551193, 530612493, -69196070],
'D3': [30, 66, 128, 228, 86, 17, 230]},
'D1': 34,
{'D2': [845878694, -1191909576, -1367406531],
'D3': [78, 189, 116, 239, 54, 223, 33]},
'D1': 88,
{'D2': [1837343622, -1896301809, 1118910596],
'D3': [173, 122, 102, 132, 152, 142, 203]}],
'C3': -2037119176,
'C4': -14815},
'B2': 0.003280517878010869,
'B3': 0.1439276784658432,
'B4': 111692019,
'B5': 196,
'B6': 3932163493,
'B7': [59, -32],
'B8': -0.9508068561553955},
'A2': 15499}
Задача №12
Реализовать разбор двоичного формата данных. Данные начинаются с сигнатуры 0x1e 0x4e 0x5a 0x4e
, за которой следует структура
A. Порядок байт: от старшего к младшему. Адреса указаны в виде смещений от начала данных. В решении предлагается использовать модуль
struct.
Структура A:
Поле | Описание |
---|---|
1 | int64 |
2 | Адрес (uint16) структуры B |
3 | float |
4 | Размер (uint32) и адрес (uint16) массива адресов (uint16) структур C |
5 | Массив uint32, размер 4 |
6 | Размер (uint16) и адрес (uint32) массива char |
7 | int8 |
8 | Адрес (uint32) структуры D |
Структура B:
Поле | Описание |
---|---|
1 | uint32 |
2 | int16 |
3 | float |
4 | uint64 |
5 | int16 |
Структура C:
Поле | Описание |
---|---|
1 | uint16 |
2 | int32 |
Структура D:
Поле | Описание |
---|---|
1 | double |
2 | Массив int32, размер 3 |
3 | int8 |
Ниже показаны примеры разбора двоичного формата.
Пример 1
Двоичные данные:
b'\x1eNZNF\x17\xf7\x03E\x82(m\x003\xbd\xeb\x89J\x00\x00\x00\x06\x00k'
(b'\x03e\xa6\xd7u\xd2\xe3~\x0fT9-{)q\x83\x00\x02\x00\x00\x00w\x84\x00'
b'\x00\x00y\xee\n!t\x11\xa5\xbe\xcb\x1c\x02{L5Z>*r\t\xc4\xe6\xb8\xb8\x86h\xf1'
b'\xad\x100\x8a\xb6\xa9=\x1f\x95<<N+\x0fy\xab0\xeb\x8eJ\xf8\x1b\x10u[*\xf6\x90'
b'i\xb2\x04\x00G\x00M\x00S\x00Y\x00_\x00ecp?\xe7pl\x01\x96\xc2JU\xfc\xe8'
b'\xbb\xc0]\x83\xee\x02\xcc\x18\xb54')
Результат разбора:
'A1': 5050777100542421101,
{'A2': {'B1': 3993641332,
'B2': 4517,
'B3': -0.3966980576515198,
'B4': 8884534826601443849,
'B5': -15130},
'A3': -0.11500795185565948,
'A4': [{'C1': 47288, 'C2': -2039942739},
'C1': 4144, 'C2': -1967740611},
{'C1': 8085, 'C2': 1010585131},
{'C1': 3961, 'C2': -1422857330},
{'C1': 19192, 'C2': 454063451},
{'C1': 10998, 'C2': -1872121340}],
{'A5': [56993495, 1976755070, 257177901, 2066313603],
'A6': 'cp',
'A7': -124,
'A8': {'D1': 0.7324733763726468,
'D2': [1442638011, -1067613202, 46930101],
'D3': 52}}
Пример 2
Двоичные данные:
b'\x1eNZN\\f\xb05q\x90F\xa9\x003\xbd\xa1\x90\xfb\x00\x00\x00\x06\x00k'
(b'4\xfa\x9d\xb6\x1f\xa2\xdd\x8e\xa2|\t\xe1\x019\x07\x84\x00\x02\x00\x00'
b'\x00w4\x00\x00\x00y\xfcn\xc1O\x93"?yzsB\xed\t\x99V\xac\xfft\x96\x08\xa1'
b'\t<\xa9\xfdPL\xb4b\xfe\xb15#O\x9e\xd9\x8d<e\xf2f\x99\xf5\x9aF\x1f\xd7\xaeP'
b'\x12W\x08\xe4\x16\xb8\x82\x00G\x00M\x00S\x00Y\x00_\x00egk\xbf\xdc\x13'
b'\xa0\x12\xfd\xb0p(\xac\xf7\xcd\xa71\xf6kk\xb3\xafC\x85')
Результат разбора:
'A1': 6658202842698892969,
{'A2': {'B1': 4235116879,
'B2': -27870,
'B3': 0.9745246767997742,
'B4': 4822521330172493684,
'B5': -27128},
'A3': -0.07888980954885483,
'A4': [{'C1': 41225, 'C2': 1017773392},
'C1': 19636, 'C2': 1660858677},
{'C1': 9039, 'C2': -1629909700},
{'C1': 26098, 'C2': 1721365914},
{'C1': 17951, 'C2': -676442094},
{'C1': 22280, 'C2': -468273022}],
{'A5': [888839606, 530767246, 2726037985, 20514692],
'A6': 'gk',
'A7': 52,
'A8': {'D1': -0.43869783262812856,
'D2': [682424269, -1489897877, 1806937923],
'D3': -123}}
Задача №12
Реализовать разбор двоичного формата данных. Данные начинаются с сигнатуры 0x4c 0x4c 0x4e 0x51 0xec
, за которой следует
структура A. Порядок байт: от младшего к старшему. Адреса указаны в виде смещений от начала данных. В решении предлагается использовать
модуль struct.
Структура A:
Поле | Описание |
---|---|
1 | int16 |
2 | int32 |
3 | Адрес (uint16) структуры B |
4 | int8 |
Структура B:
Поле | Описание |
---|---|
1 | Структура C |
2 | int8 |
3 | uint16 |
4 | Массив uint32, размер 3 |
5 | uint8 |
6 | uint64 |
Структура C:
Поле | Описание |
---|---|
1 | Массив структур D, размер 2 |
2 | int8 |
3 | uint16 |
Структура D:
Поле | Описание |
---|---|
1 | Массив uint8, размер 8 |
2 | int32 |
3 | int16 |
4 | Размер (uint16) и адрес (uint16) массива int16 |
Ниже показаны примеры разбора двоичного формата.
Пример 1
Двоичные данные:
b'LLNQ\xec\xd7\xc0\x12\xd3\x97\x00\x18\x00ULvw\x9b\x19\xc6p\xe0\xe5\xde;$\xaac'
(b'%BH\x07|\x14b\xd4\x10\x06\x02\x00\x0e\x00V\xbc\xf49\x14\x81\xcf7op\xc02\x0cs'
b"\x03\x00\x12\x00^\xec\x939\x7f\xe1\x9d&3\x14'\x04\x0e\xa2\x8a\xc7B\xec5\x18"
b"\xbaf'\xb6Ti\x16")
Результат разбора:
'A1': -16169,
{'A2': 9949970,
'A3': {'B1': {'C1': [{'D1': [59, 36, 170, 99, 37, 66, 72, 7],
'D2': -731769732,
'D3': 1552,
'D4': [30284, -25737]},
'D1': [86, 188, 244, 57, 20, 129, 207, 55],
{'D2': 851472495,
'D3': 29452,
'D4': [-14823, -8080, -8475]}],
'C2': 94,
'C3': 37868},
'B2': 57,
'B3': 57727,
'B4': [338896541, 2718827559, 3963799434],
'B5': 53,
'B6': 1614915082710858264},
'A4': 85}
Пример 2
Двоичные данные:
b'LLNQ\xecX\x87]\x14s/\x1a\x00\xcb\xff\x10\x89\x08\xa3a\xb3\x15m\xa4'
(b'\xe1\xbd\xdfZ\xc4\xbe\xe4\x95\xca\xca\xc3\x940\xca\x0bB\x03\x00\x0e\x00'
b'J\x02\xd8\xffRK\x94\x10v3\xfe\xe7\x1a\x9d\x03\x00\x14\x00\x8c\xcfpB\xa3A'
b'\x05\xdb\x1e\x8fs\x807\xff3\xba\x0f\x8box\x13\xf4\x15q\x1d\xb3\x90')
Результат разбора:
'A1': -30888,
{'A2': 796071005,
'A3': {'B1': {'C1': [{'D1': [223, 90, 196, 190, 228, 149, 202, 202],
'D2': -902785853,
'D3': 16907,
'D4': [4351, 2185, 24995]},
'D1': [74, 2, 216, 255, 82, 75, 148, 16],
{'D2': -402771082,
'D3': -25318,
'D4': [5555, -23443, -16927]}],
'C2': -116,
'C3': 28879},
'B2': 66,
'B3': 16803,
'B4': [2401164037, 4281827443, 2333063731],
'B5': 111,
'B6': 10426709933829657464},
'A4': -53}
Задача №12
Реализовать разбор двоичного формата данных. Данные начинаются с сигнатуры 0xfa 0x51 0x52 0x42 0x48
, за которой следует
структура A. Порядок байт: от младшего к старшему. Адреса указаны в виде смещений от начала данных. В решении предлагается использовать
модуль struct.
Структура A:
Поле | Описание |
---|---|
1 | int8 |
2 | int8 |
3 | Размер (uint16) и адрес (uint16) массива структур B |
4 | uint64 |
5 | Структура C |
6 | uint16 |
7 | Структура E |
Структура B:
Поле | Описание |
---|---|
1 | int32 |
2 | uint8 |
3 | Массив char, размер 3 |
Структура C:
Поле | Описание |
---|---|
1 | int8 |
2 | int8 |
3 | Адрес (uint16) структуры D |
4 | uint16 |
Структура D:
Поле | Описание |
---|---|
1 | int32 |
2 | int32 |
3 | double |
4 | int16 |
5 | Массив int64, размер 7 |
6 | uint8 |
7 | uint16 |
8 | double |
Структура E:
Поле | Описание |
---|---|
1 | int8 |
2 | int16 |
3 | Массив uint8, размер 4 |
4 | uint8 |
5 | uint64 |
6 | int64 |
7 | uint16 |
Ниже показаны примеры разбора двоичного формата.
Пример 1
Двоичные данные:
b'\xfaQRBH\xe1r\x03\x005\x00\x1f\x08\n~e\x8a\xdcJ\xca\xb7M\x00,\xf6*\xff\xb3'
(b'N\xf7\xf4\x8f8\xa7{O\xa7I\x9f\x15\x0e<\xcd\t\xd7+T\x93\x11\xc8\x87x'
b'\xc1\xb33\xb8\xc8LdggB.&t|xey\xcc\x17\xdfA\rsif\x85\t\xe9^\x84\x19N'
b'\xa3\x903\x17\x14\xdb>\xbc?\x92o&\xdb\x97w\xa2\xe1^\x05\xff\x8d\xc6\x81\xe1'
b'\xb0\x9b\xfe%\x11\x9c/\x1ar\xc9$\xf1cG\x11\xc4\x84\xfd\xfd1\xf6^\xc6\xed'
b'\xd1.6\x8c\x9e\x9b\x08 \x94\xf4\x1aU\x81s\xdf\xa7\x8bl\x08H\xf7\n\xaa#'
b'\xec\x81\x0eU\xe2?')
Результат разбора:
'A1': -31,
{'A2': 114,
'A3': [{'B1': -927452237, 'B2': 76, 'B3': 'dgg'},
'B1': 1948659266, 'B2': 124, 'B3': 'xey'},
{'B1': 1105139660, 'B2': 13, 'B3': 'sif'}],
{'A4': 5394338622193928223,
'A5': {'C1': -54,
'C2': -73,
'C3': {'D1': 1592330629,
'D2': -1555162748,
'D3': 0.11033410301679525,
'D4': 28562,
'D5': [386994705907833638,
-100292084094300673,
2650775312477720869,
-144813635367640079,
3904288746142365233,
1942340204607807116,
607013602912862549],
'D6': 72,
'D7': 2807,
'D8': 0.5728828942820787},
'C4': 63020},
'A6': 65322,
'A7': {'E1': -77,
'E2': -2226,
'E3': [244, 143, 56, 167],
'E4': 123,
'E5': 14788710762407372623,
'E6': -8662654558777125111,
'E7': 49528}}
Пример 2
Двоичные данные:
b'\xfaQRBHt\xed\x02\x005\x00F\xc3\x9f\x86\xcf\xbe\x15\x1d\xdf\x8dE\x00W'
(b'\x0c\x7f\xdb\xc3\xecV\x13\x08\x99\x1c\x8d9\xdcj\xe6\xd5\xa3\x0e\xcb\x04'
b"\xd9T-\xbay\xda9>\x82:\x82\xa4\x96\x9fvaw\xd2\xd1\xb8'\xf5fed\xd2(\xd8"
b"_\xcc\xfb\x8e\xa7\x1a\xb7=\xac'\x8d\xe1\xbfS\x86\x0b]\x19\x90d"
b'\xa9\x9d\xbc\xbc\x8dNZr|\x13\xcc\xb6\xbc\x17\x1d\xab\xbc>\xb7\xe6\xaa*\xa7L'
b"\x19\x02\x92\x82\xda\x15\x95\x9d\x8c\xfesM'N`\xb8^\x9aX\xd2\xbe\xa5\xcdd"
b'\tkhD\xeb\xe5\xe4n\xab]\x9dK\xed\xbf')
Результат разбора:
'A1': 116,
{'A2': -19,
'A3': [{'B1': -1767603654, 'B2': 159, 'B3': 'vaw'},
'B1': 666423762, 'B2': 245, 'B3': 'fed'}],
{'A4': 2095791000136958790,
'A5': {'C1': -33,
'C2': -115,
'C3': {'D1': 1608001746,
'D2': -1483801652,
'D3': -0.5484808315356731,
'D4': -31149,
'D5': [-4855538573856121589,
-3741510034831536708,
-5242545473099154250,
-7925744577205851418,
8358272566885210754,
6384519567733827405,
7524117931004116690],
'D6': 68,
'D7': 58859,
'D8': -0.9154803113446772},
'C4': 3159},
'A6': 56191,
'A7': {'E1': -61,
'E2': 22252,
'E3': [19, 8, 153, 28],
'E4': 141,
'E5': 14631812378462444601,
'E6': 4168778245616228612,
'E7': 33342}}
Задача №12
Реализовать разбор двоичного формата данных. Данные начинаются с сигнатуры 0x4e 0x54 0x4b 0x51
, за которой следует структура
A. Порядок байт: от младшего к старшему. Адреса указаны в виде смещений от начала данных. В решении предлагается использовать модуль
struct.
Структура A:
Поле | Описание |
---|---|
1 | Адрес (uint16) структуры B |
2 | float |
3 | Размер (uint32) и адрес (uint16) массива int32 |
4 | int32 |
5 | Адрес (uint32) структуры D |
6 | uint8 |
7 | Массив uint16, размер 4 |
Структура B:
Поле | Описание |
---|---|
1 | Размер (uint16) и адрес (uint32) массива int8 |
2 | double |
3 | float |
4 | Размер (uint32) и адрес (uint16) массива адресов (uint32) структур C |
Структура C:
Поле | Описание |
---|---|
1 | Массив uint32, размер 3 |
2 | uint64 |
3 | uint16 |
4 | uint32 |
Структура D:
Поле | Описание |
---|---|
1 | uint32 |
2 | int8 |
3 | float |
Ниже показаны примеры разбора двоичного формата.
Пример 1
Двоичные данные:
b'NTKQc\x00\xc0\xbc1\xbf\x04\x00\x00\x00{\x00.\xe0\xd6\xa7\x8b\x00\x00\x00'
(b'$\x8b:\x1dZ\x07b\x0f\xcf8\x97\x81q\xe3\xc0e\xf9\x10(Og\xd8#\xf58O+.'
b'\x1b\x05\x1c\x07j\xfc\xea\xa9(\xc4\x92\xd4\xae \xf4\xf3gQ\x88J\x87\x16X~'
b"\x0e\xffZj\xdb\xf5\xee\x13\xde.\xc7G\x04\x00\xc3'\x00\x00\x00A"
b'\x00\x00\x00\x06\x00!\x00\x00\x00\xc0\xe4\x0f\xf1\x07\xe9\xbd\xbf\xd2\x1fi'
b'\xbf\x02\x00\x00\x00[\x003\x1e\x9ep-3!3\xa2k\x85\xbd\x83\xc2=L\xc2F\xe5s\xa4'
b'\x81\xba6?')
Результат разбора:
'A1': {'B1': [56, -105, -127, 113, -29, -64],
{'B2': -0.11683702121071615,
'B3': -0.9106417894363403,
'B4': [{'C1': [672201061, 601384783, 726612213],
'C2': 16932525277773634350,
'C3': 10409,
'C4': 2933166788},
'C1': [1744040992, 2269808721, 243161110],
{'C2': 16002396640693082879,
'C3': 50990,
'C4': 3271558215}]},
'A2': -0.6942863464355469,
'A3': [1889410611, 857813805, -1115329630, 1279115907],
'A4': -1479090130,
'A5': {'D1': 1944405698, 'D2': -92, 'D3': 0.713783323764801},
'A6': 36,
'A7': [14987, 23069, 25095, 53007]}
Пример 2
Двоичные данные:
b'NTKQc\x00-\x8a1?\x02\x00\x00\x00{\x00\xf1\xf1\xae\xde\x83\x00\x00\x00'
(b'-\xf3\x19\xdf5\x0bV\xe7M!#\xd0@\xbeNF\xd3/>\x9b\xdd\xeeF\x7f[\x89\xafc'
b'\x95?\x85?Ef\x1aCRPp\xece`1\x04\x0fN\xdc\xf7\xcf\x8f(\x94g\xc1\xfd\xcb'
b"\xd7\x9eRGPq\x92\xbc*\xf2\xfc'\x00\x00\x00A\x00\x00\x00\x06\x00!\x00\x00"
b'\x00@\xba\xc2\t\x80\x8b\xe5\xbf\xc3\xbb\x9f\xbe\x02\x00\x00\x00[\x00J!j\xfdW'
b"\xb1\x8c'\x97\xd7\xd3oGx\xcf\x91\xbd")
Результат разбора:
'A1': {'B1': [33, 35, -48, 64, -66, 78],
{'B2': -0.6732788267743857,
'B3': -0.31197938323020935,
'B4': [{'C1': [1043321670, 1190059419, 2945014655],
'C2': 1902284031731406179,
'C3': 21059,
'C4': 1709994064},
'C1': [251933024, 3489127502, 1737762959],
{'C2': 5784683088559472065,
'C3': 37489,
'C4': 4243729084}]},
'A2': 0.6935146450996399,
'A3': [-43376310, 663531863],
'A4': -558960143,
'A5': {'D1': 1876154263, 'D2': 71, 'D3': -0.07119649648666382},
'A6': 45,
'A7': [6643, 13791, 22027, 19943]}
Задача №12
Реализовать разбор двоичного формата данных. Данные начинаются с сигнатуры 0x53 0x4e 0x44 0x4c
, за которой следует структура
A. Порядок байт: от старшего к младшему. Адреса указаны в виде смещений от начала данных. В решении предлагается использовать модуль
struct.
Структура A:
Поле | Описание |
---|---|
1 | Структура B |
2 | Размер (uint32) и адрес (uint16) массива char |
3 | int64 |
4 | uint32 |
5 | int32 |
6 | Размер (uint16) и адрес (uint16) массива адресов (uint32) структур D |
7 | Адрес (uint32) структуры F |
8 | Массив uint16, размер 5 |
Структура B:
Поле | Описание |
---|---|
1 | double |
2 | float |
3 | Адрес (uint16) структуры C |
4 | uint32 |
Структура C:
Поле | Описание |
---|---|
1 | int8 |
2 | int8 |
3 | int64 |
4 | int64 |
Структура D:
Поле | Описание |
---|---|
1 | int16 |
2 | uint16 |
3 | int16 |
4 | Структура E |
5 | uint8 |
Структура E:
Поле | Описание |
---|---|
1 | Массив int64, размер 3 |
2 | uint32 |
Структура F:
Поле | Описание |
---|---|
1 | uint32 |
2 | int8 |
Ниже показаны примеры разбора двоичного формата.
Пример 1
Двоичные данные:
b'SNDL?\xe4\x0b\xcb\xac\x0e\x02\x98\xbfh\xf4\xc6\x00>Y\xb7\xbd\x9f\x00\x00'
(b'\x00\x02\x00P1\x96\x03\x00\xfd7Z\xc8\x1a$\xa2\x13\xe6q\xd8p\x00\x02\x00\x98'
b'\x00\x00\x00\xa0*[.U}\xc8\xf0\x82D\xc4\xc0\x8d\\f\x87\xac\xe1y\x87\xc1'
b"%\xaf\xa3\xa5\xcd\x82O\x82rn\x85\x0b\x95\xf8\xc5\x84'\xc4\x88\xcc\xe5@\x89#"
b'\xacL\xf4K\xd8\x8d\x8ew\x83\x12\xfc?\xc8\xdb\x83\xd6/\xf0TM\xa6\xf6&\xb6'
b'\xcd\x84=\xda\x86\x1c\x91\x96\xf8P\xb8\x12\xa0\xd3\xa3\xf78S\x7f\x01'
b'\xa8\xbcr\x97\x93I#\x1f\xf4\xf9\xe7\xa6\x00\x00\x00R\x00\x00\x00uG\xfd\x14|'
b'W')
Результат разбора:
'A1': {'B1': 0.626439891857518,
{'B2': -0.9099849462509155,
'B3': {'C1': -64,
'C2': -115,
'C3': 6658158275700819905,
'C4': 2715569032840499074},
'B4': 1505213855},
'A2': 'rn',
'A3': 3573046657148213960,
'A4': 438608403,
'A5': -428746640,
'A6': [{'D1': -31477,
'D2': 38392,
'D3': -14972,
'D4': {'E1': [2865565676515395875,
-6031177194363056521,
-9001855354277231658],
'E2': 804279373},
'D5': 166},
'D1': -2522,
{'D2': 46797,
'D3': -31683,
'D4': {'E1': [-2700439514933342024,
1342305390137201535,
119552590480623907],
'E2': 536148455},
'D5': 166}],
'A7': {'F1': 1207768188, 'F2': 87},
'A8': [10843, 11861, 32200, 61570, 17604]}
Пример 2
Двоичные данные:
b'SNDL\xbf\xb5\xbe\x1fR\xb2\x1aP\xbf\t\x80T\x00>\xda\x82\xa6\xd0\x00\x00'
(b"\x00\x04\x00P\x91\xf6d\xc4'q\xcbt\xb0\x95\xa0\x1c\xb7k\xf0C\x00\x02\x00\x9a"
b"\x00\x00\x00\xa2k\x06\xab\xed\xabiZ\x1d\x876\xd1\x97'SV\x01\x94#\xecM"
b'Y+\xbc\xd0\xf3\xa9.\xf1wusi\xa85n\x18\xce\xb0\xeeS{\xfb\xc5\xe7.v\x1d\x9a'
b't\xf3QXKQT\x1e\xb7\x15\xbd{\x93B-\x17U\xd9\xff\x1dZ\xa5\xfeWp\x0e\xb6>'
b'\xe5\x1d\xe9\xd8\x1f\xe8\xcbDx:\xddfa-A\xc1\xd3\xab\x00\x9dI\x1b\x04\xab'
b'Q<\x00\x00\x00T\x00\x00\x00wm\xe7~B\xd8')
Результат разбора:
'A1': {'B1': -0.08493228691995935,
{'B2': -0.5371143817901611,
'B3': {'C1': -47,
'C2': -105,
'C3': 2833703155326512205,
'C4': 6425436899001315057},
'B4': 3665995472},
'A2': 'wusi',
'A3': -7929039300301042828,
'A4': 2962595868,
'A5': -1217662909,
'A6': [{'D1': -22475,
'D2': 28184,
'D3': -12624,
'D4': {'E1': [-1273537948328448394,
2133145961903967057,
6061483452488454978],
'E2': 756504025},
'D5': 255},
'D1': 7514,
{'D2': 42494,
'D3': 22384,
'D4': {'E1': [1060103916062627871,
-1672167553463654815,
3261100720044154185],
'E2': 453290833},
'D5': 60}],
'A7': {'F1': 1843887682, 'F2': -40},
'A8': [27398, 44013, 43881, 23069, 34614]}
Задача №12
Реализовать разбор двоичного формата данных. Данные начинаются с сигнатуры 0x77 0x56 0x4f 0x4a
, за которой следует структура
A. Порядок байт: от старшего к младшему. Адреса указаны в виде смещений от начала данных. В решении предлагается использовать модуль
struct.
Структура A:
Поле | Описание |
---|---|
1 | Структура B |
2 | Адрес (uint16) структуры D |
3 | uint64 |
4 | Массив int32, размер 3 |
5 | int16 |
Структура B:
Поле | Описание |
---|---|
1 | Размер (uint16) и адрес (uint16) массива структур C |
2 | uint16 |
Структура C:
Поле | Описание |
---|---|
1 | int64 |
2 | int16 |
3 | Массив float, размер 8 |
4 | int8 |
5 | uint16 |
Структура D:
Поле | Описание |
---|---|
1 | Массив int8, размер 4 |
2 | int8 |
3 | int8 |
Ниже показаны примеры разбора двоичного формата.
Пример 1
Двоичные данные:
b'wVOJ\x00\x02\x00"\xb1\xa6\x00|N\xc2M?Y>\xb2\xb4-/\xcc9\xd7I&\x15:M\xea\xb8'
(b'}\xd7=\x9d\x91\x9c\xaa`\xdbC(E=\xa0\x04\xf2?k\x9a\x06?p\x8bA\xbf\x18\xf4\xf6'
b'\xbe\xa4\x13=??<\xec\xbeqT\xc4\xbf|\xd6\xad\n\xfe?\x80\xf6\xa6\x06\x14'
b'&\x1dW\x9f`\xbd-rC?\x04\xa2\x98>\x9b\x06M\xbf\x1f\x13\xc3>\xbc\xa9\xa3>(\xc8'
b'\\?v%M?`$\x07F\x00!\x06n\x1a\xba:\x88')
Результат разбора:
'A1': {'B1': [{'C1': 4439864909716577091,
{'C2': 10309,
'C3': [0.0781344324350357,
0.9203189611434937,
0.9396248459815979,
-0.5974878072738647,
-0.3204592764377594,
0.747023344039917,
-0.2356749176979065,
-0.9876506924629211],
'C4': 10,
'C5': 65087},
'C1': -9153946647545897641,
{'C2': -24736,
'C3': [-0.04234529659152031,
0.5181059837341309,
0.30278244614601135,
-0.6213952898979187,
0.36848172545433044,
0.16482681035995483,
0.9615066647529602,
0.8755497336387634],
'C4': 70,
'C5': 33}],
'B2': 45478},
'A2': {'D1': [6, 110, 26, -70], 'D2': 58, 'D3': -120},
'A3': 5675183414915805876,
'A4': [758107193, -683071979, 978184888],
'A5': 32215}
Пример 2
Двоичные данные:
b'wVOJ\x00\x02\x00"*C\x00|\xb1\x08}\xc8a\xd4\x8e\xd5\xda\xfb~\x08'
(b"\x9f\x10\x93'\xb7p\x94\x172H=Z\xfa\x07FX\xacm\xac\x85\xbedq\xe4?V\x18j"
b'>\xca\xacw>\xc4T\xba?41\xf1\xbfV\xb1\xd5?\x04\xf4r>1\xf1r/\xb3\xa6D'
b'\x05\xf6\x98\xda\x96K\xaa\x1e\xe6?\x1e\xf3h\xbf\x06HU\xbe\x94\x94'
b'_\xbf\x18\xcd ?3\xfas>r\xdf\xe1\xbf9\x8f\xe6\xbfa\x91\xae\xe1\x05\xd9d\x95R]'
b"\xef'")
Результат разбора:
'A1': {'B1': [{'C1': 4421120893369494637,
{'C2': -21371,
'C3': [-0.22309070825576782,
0.8363100290298462,
0.39584705233573914,
0.3834589123725891,
0.7038870453834534,
-0.8386510014533997,
0.5193549394607544,
0.17377260327339172],
'C4': 47,
'C5': 45990},
'C1': 4901594905825397674,
{'C2': 7910,
'C3': [0.6209015846252441,
-0.5245411992073059,
-0.29019448161125183,
-0.5968799591064453,
0.7030403017997742,
0.237182155251503,
-0.7248519659042358,
-0.8811291456222534],
'C4': -31,
'C5': 1497}],
'B2': 10819},
'A2': {'D1': [100, -107, 82, 93], 'D2': -17, 'D3': 39},
'A3': 12756584244115181269,
'A4': [-621052408, -1626303705, -1217358825],
'A5': 12872}
Задача №12
Реализовать разбор двоичного формата данных. Данные начинаются с сигнатуры 0x53 0x59 0x54 0x59 0xa5
, за которой следует
структура A. Порядок байт: от старшего к младшему. Адреса указаны в виде смещений от начала данных. В решении предлагается использовать
модуль struct.
Структура A:
Поле | Описание |
---|---|
1 | Адрес (uint32) структуры B |
2 | int8 |
3 | uint8 |
4 | Размер (uint16) и адрес (uint16) массива int8 |
5 | Размер (uint16) и адрес (uint16) массива uint8 |
Структура B:
Поле | Описание |
---|---|
1 | int16 |
2 | Структура C |
Структура C:
Поле | Описание |
---|---|
1 | Размер (uint16) и адрес (uint16) массива структур D |
2 | double |
Структура D:
Поле | Описание |
---|---|
1 | int64 |
2 | uint16 |
3 | uint16 |
4 | Массив int8, размер 2 |
Ниже показаны примеры разбора двоичного формата.
Пример 1
Двоичные данные:
b'SYTY\xa5\x00\x00\x00=\x08\x8a\x00\x03\x00K\x00\x02\x00N\xa4\xc0\x86\x17\x13'
(b'\x99&`\xa6WV)s\xe2E\xd3\xd5\xc2\xf0\xc9\x97!\xdf~\xb3c>\xb0O\xc85\xb9\xdb'
b'\xc3\x95$E\x03\x98\xe3\x95C\x83\xb0\x00\x03\x00\x13\xbf\xa6\\\x97\xda'
b'*\xf3\x80\xd6\xe2\xb9`\xfc')
Результат разбора:
'A1': {'B1': -31824,
{'B2': {'C1': [{'D1': -6575108022289750432,
'D2': 42583,
'D3': 22057,
'D4': [115, -30]},
'D1': 5031600241943090977,
{'D2': 57214,
'D3': 45923,
'D4': [62, -80]},
'D1': 5748903996710688036,
{'D2': 17667,
'D3': 39139,
'D4': [-107, 67]}],
'C2': -0.04367517984562763}},
'A2': 8,
'A3': 138,
'A4': [-42, -30, -71],
'A5': [96, 252]}
Пример 2
Двоичные данные:
b"SYTY\xa5\x00\x00\x00/\xedy\x00\x05\x00=\x00\x02\x00B Dm\x13\x17Z'9#"
(b'\x1c\x85\xd8\x8aZ\xb2\x066\xe9\\\x81\xa5\x90E\x8c\x08\x0f:\xf0\xc6'
b'\xf9\x00\x02\x00\x13\xbf\xca\xa9\xbf\xcaf\x96\xb8\xdd\xd1\x94\x9dE\xec(')
Результат разбора:
'A1': {'B1': -14599,
{'B2': {'C1': [{'D1': 2325103236393609017,
'D2': 8988,
'D3': 34264,
'D4': [-118, 90]},
'D1': -5618743109190834800,
{'D2': 17804,
'D3': 2063,
'D4': [58, -16]}],
'C2': -0.20830533392761708}},
'A2': -19,
'A3': 121,
'A4': [-35, -47, -108, -99, 69],
'A5': [236, 40]}
Задача №12
Реализовать разбор двоичного формата данных. Данные начинаются с сигнатуры 0x47 0x53 0x4d 0xf9
, за которой следует структура
A. Порядок байт: от младшего к старшему. Адреса указаны в виде смещений от начала данных. В решении предлагается использовать модуль
struct.
Структура A:
Поле | Описание |
---|---|
1 | Адрес (uint16) структуры B |
2 | Размер (uint32) и адрес (uint32) массива float |
3 | uint32 |
4 | uint8 |
Структура B:
Поле | Описание |
---|---|
1 | Размер (uint32) и адрес (uint16) массива структур C |
2 | Размер (uint16) и адрес (uint32) массива char |
3 | int16 |
4 | float |
5 | uint16 |
6 | uint8 |
7 | int16 |
8 | Адрес (uint32) структуры D |
Структура C:
Поле | Описание |
---|---|
1 | int8 |
2 | uint16 |
3 | float |
Структура D:
Поле | Описание |
---|---|
1 | int32 |
2 | double |
3 | Массив uint64, размер 3 |
4 | double |
5 | uint16 |
6 | int8 |
7 | int8 |
8 | uint16 |
Ниже показаны примеры разбора двоичного формата.
Пример 1
Двоичные данные:
b'GSM\xf9j\x00\x04\x00\x00\x00\x85\x00\x00\x00\xe4\xa2\xea\xa1\x0fh'
(b'\xce%\x07\x8c6>C\xa8\x9f\x88\xf2]?1\xc5\xdf\x94\x17j?_\xa9c\xd0\xfd\x00\xbf7'
b"\xd8O\xd5:k\xbfkbZJ\x19\x99\xa8'\xca\xed\xf8\xf6\xe7?\xe6\x13\x10\xef"
b"\xb0\xd4!;\xdd\xec0~KL\xdc\xcf'BF\xd1\xdb\x93\n\xffd\x0c\x08O\xb5\x1f\xe4?"
b'\x08\xf27V\xd9\x0c\x05\x00\x00\x00\x13\x00\x02\x006\x00\x00\x00\x19\xb1'
b'\xa7\xe8\xe2>\x8e\x1a\xe1S\xd78\x00\x00\x00$\xc0\x0e?\x04\xfe|?Ph\xf8=u\xf8g'
b'\xbf')
Результат разбора:
'A1': {'B1': [{'C1': 104, 'C2': 9678, 'C3': 0.17826853692531586},
{'C1': 67, 'C2': 40872, 'C3': 0.8669819831848145},
{'C1': 49, 'C2': 57285, 'C3': 0.9144222736358643},
{'C1': 95, 'C2': 25513, 'C3': -0.5038728713989258},
{'C1': 55, 'C2': 20440, 'C3': -0.9188664555549622}],
{'B2': 'kb',
'B3': -20199,
'B4': 0.44318124651908875,
'B5': 6798,
'B6': 225,
'B7': -10413,
'B8': {'D1': -1726395814,
'D2': 0.7488979954080053,
'D3': [4260920578859340774,
14977930347850820829,
18377663801756893735],
'D4': 0.6288706344206614,
'D5': 61960,
'D6': 55,
'D7': 86,
'D8': 3289}},
'A2': [0.5576193332672119,
0.9882509708404541,
0.12129271030426025,
-0.9061349034309387],
'A3': 2716508900,
'A4': 15}
Пример 2
Двоичные данные:
b'GSM\xf9X\x00\x05\x00\x00\x00s\x00\x00\x00\x96=\xd4\x9f\x80p\xefC\xcb-'
(b'|\xbe\xc3z\xb0j7G\xbflrkaf(\xb5\x03\x99\xbem\xb3\x183q\xe1\xbf\x941'
b'8\xc1\xd5\xa7\xdb\x8fs/(\xd2e\x9a\x8e\xab\xab \x9d\xda[\x99<p\x08\\'
b'\xaf\x87-3\xcc\xbfvc\x14FK_\x02\x00\x00\x00\x13\x00\x05\x00!\x00\x00\x00'
b"L'\xcae\xe9=Di7\xce\xe2&\x00\x00\x00\xef\x1di\xbf\xcf#\x02\xbe\\"
b'\xb9\x18\xbfh\xfb\xfd=k\xcc\x83>')
Результат разбора:
'A1': {'B1': [{'C1': 112, 'C2': 17391, 'C3': -0.24626843631267548},
{'C1': -61, 'C2': 45178, 'C3': -0.7781893014907837}],
{'B2': 'lrkaf',
'B3': 10060,
'B4': 0.11396367847919464,
'B5': 26948,
'B6': 55,
'B7': -7474,
'B8': {'D1': -1727810264,
'D2': -0.5450683100165674,
'D3': [10366063503834886548,
12361987789286813555,
8087507650639372459],
'D4': -0.22031182408565564,
'D5': 25462,
'D6': 20,
'D7': 70,
'D8': 24395}},
'A2': [-0.9106130003929138,
-0.127089723944664,
-0.5965783596038818,
0.12401467561721802,
0.2574189603328705],
'A3': 2681486742,
'A4': 128}
Задача №12
Реализовать разбор двоичного формата данных. Данные начинаются с сигнатуры 0x51 0x55 0x53
, за которой следует структура A.
Порядок байт: от старшего к младшему. Адреса указаны в виде смещений от начала данных. В решении предлагается использовать модуль
struct.
Структура A:
Поле | Описание |
---|---|
1 | uint8 |
2 | int16 |
3 | uint16 |
4 | Размер (uint16) и адрес (uint32) массива char |
5 | Массив структур B, размер 3 |
6 | int64 |
7 | uint16 |
8 | Адрес (uint32) структуры C |
Структура B:
Поле | Описание |
---|---|
1 | int8 |
2 | int16 |
Структура C:
Поле | Описание |
---|---|
1 | Размер (uint16) и адрес (uint32) массива uint32 |
2 | Размер (uint16) и адрес (uint32) массива int16 |
3 | uint32 |
4 | double |
5 | float |
6 | uint32 |
7 | Структура D |
8 | uint16 |
Структура D:
Поле | Описание |
---|---|
1 | int16 |
2 | Размер (uint32) и адрес (uint16) массива uint32 |
3 | int32 |
4 | uint16 |
5 | double |
6 | int8 |
Ниже показаны примеры разбора двоичного формата.
Пример 1
Двоичные данные:
b'QUSx9\xfb\x10S\x00\x02\x00\x00\x00%\xe9p\xc3\xb3\xe0\x9e\x8b\xcbT_'
(b"[\xee\x8a\xaf\xa6'\x11\x81L\x00\x00\x00Mqg,W\x1b\x02?M9\xce\x84V\xaa\r_"
b',\xb9o\xa9@%\x1a\x14\xb4\xb3\xecc\x154\xddk\x8a\x89\xe5@\x95\x95\xce='
b"\xac\x00\x04\x00\x00\x00'\x00\x05\x00\x00\x007\xadu\xcae\xbf\xdd\xb9*.0D"
b'\x9c\xbf\x11-\xab\x93\xdf\xd8\x95\x87\x02\x00\x00\x00\x03\x00A\xfd\x16J'
b'\x01(\xb6\xbf\xed-B\xe7x"Z\x17\xc2\x92')
Результат разбора:
'A1': 120,
{'A2': 14843,
'A3': 4179,
'A4': 'qg',
'A5': [{'B1': -23, 'B2': 28867},
'B1': -77, 'B2': -8034},
{'B1': -117, 'B2': -13484}],
{'A6': 6871347935903622929,
'A7': 33100,
'A8': {'C1': [743906050, 1062025678, 2220272141, 1596766575],
'C2': [-22208, 9498, 5300, -19476, 25365],
'C3': 2910177893,
'C4': -0.4644265605030087,
'C5': -0.5671030879020691,
'C6': 2480920725,
'C7': {'D1': -30974,
'D2': [886926218, 2313502869, 2513321388],
'D3': -48870911,
'D4': 10422,
'D5': -0.9117750664600621,
'D6': 23},
'C8': 49810}}
Пример 2
Двоичные данные:
b'QUS@\x15]\x1f>\x00\x08\x00\x00\x00%\xba\xb1u\x07q\xe4\x1f\xd7\xe7\xa8LD\x0ff'
(b'\xdbE-z\xb9\x00\x00\x00Yphudoxin\xf5\xa4\x14\xbc\x9c\xa8lZ\xb2\xdaU'
b"J\xa8b\xc6\xe8\x13FV\x9b\xb5\x9a\xf89'_B \xae\x88s\xb2\\od\x1c\x183M"
b'\xd3\x03\xc9}\xda\x00\x04\x00\x00\x00-\x00\x04\x00\x00\x00=2\xa7i\xd5?\xedf'
b'*\xd6^W\xec>\xbe\xf7q\xd0\xc6\x02\x85\xb9:\x00\x00\x00\x05\x00Ek\n\x8b'
b'\x97\x8c\x1a?\xdc\x85\xe8^\xf9\xf5(\x9a\xe1\xbf')
Результат разбора:
'A1': 64,
{'A2': 5469,
'A3': 7998,
'A4': 'phudoxin',
'A5': [{'B1': -70, 'B2': -20107},
'B1': 7, 'B2': 29156},
{'B1': 31, 'B2': -10265}],
{'A6': -6319601344166804179,
'A7': 31417,
'A8': {'C1': [4121171132, 2628283482, 3000653130, 2825045736],
'C2': [4934, 22171, -19046, -1991],
'C3': 849832405,
'C4': 0.9187215983281454,
'C5': 0.37298157811164856,
'C6': 3502637701,
'C7': {'D1': -18118,
'D2': [660554272, 2928178098, 1550803996, 406015443, 63536602],
'D3': 1795853207,
'D4': 35866,
'D5': 0.4456730773452642,
'D6': -102},
'C8': 57791}}
Задача №12
Реализовать разбор двоичного формата данных. Данные начинаются с сигнатуры 0x47 0x54 0x41 0x51
, за которой следует структура
A. Порядок байт: от старшего к младшему. Адреса указаны в виде смещений от начала данных. В решении предлагается использовать модуль
struct.
Структура A:
Поле | Описание |
---|---|
1 | Массив структур B, размер 2 |
2 | int64 |
3 | Адрес (uint32) структуры C |
4 | int8 |
5 | Структура D |
Структура B:
Поле | Описание |
---|---|
1 | float |
2 | int64 |
3 | double |
Структура C:
Поле | Описание |
---|---|
1 | int16 |
2 | int8 |
Структура D:
Поле | Описание |
---|---|
1 | int32 |
2 | int64 |
3 | Структура E |
4 | Размер (uint16) и адрес (uint32) массива uint16 |
5 | int64 |
6 | uint64 |
7 | int32 |
8 | Массив uint8, размер 3 |
Структура E:
Поле | Описание |
---|---|
1 | int64 |
2 | int64 |
3 | int64 |
4 | Массив uint16, размер 2 |
5 | uint32 |
Ниже показаны примеры разбора двоичного формата.
Пример 1
Двоичные данные:
b'GTAQ\xbd\xba\x97%\xe9\xc9`X3/\x02:\xbf\xed\\\x86\x95c\x84D\xbem\xa3\xd6'
(b'\xc4\xd0\x1f"\x7fH\xef(?\xe2B\xb3t1\xa0\x8c\xa3}i^\x0b\xd9\xf1p'
b'\x00\x00\x00\x82>s\xc5\xae\xf1F2\x1fw\x04\xf3o\xe2_>\x98\xdb\x02\x81d'
b'\x8a\x8d7>&\x02\x1eC\xb8\xf7\xe9\x00\x81\x9di<3T(\xd5\xfd\xd3\x1a\xb8'
b'\xc9\x00\x04\x00\x00\x00\x85\xfd\xc5\x97?!O\xcdVSG\xb4O\x84\xe6\x11\x999'
b'\xd0\x1d\x19\t\xfa\x00\x97\x9d\xa7\x9b\xf0~\xa0\x8fP\xbfB')
Результат разбора:
'A1': [{'B1': -0.09110859781503677,
{'B2': -1600642260621393350,
'B3': -0.9175446431874055},
'B1': -0.23207029700279236,
{'B2': -4264874614095024344,
'B3': 0.5706422109042406}],
'A2': -6666056020791791248,
'A3': {'C1': -26723, 'C2': -89},
'A4': 62,
'A5': {'D1': 1942335217,
'D2': 5058139927535120354,
'D3': {'E1': 6863090948566508682,
'E2': -8271073857677409352,
'E3': -582934120076067789,
'E4': [21544, 54781],
'E5': 3541743817},
'D4': [39920, 32416, 36688, 48962],
'D5': -160555914304172714,
'D6': 6000963282119561625,
'D7': 969940249,
'D8': [9, 250, 0]}}
Пример 2
Двоичные данные:
b"GTAQ\xbfr\nj)(\xc2e,\xdak\x1c\xbf\xec,)S'\x95\x10\xbf^Z\x0c\xda\xc0\xbb\xee"
(b'\xd0\xe8\n}?\xe9\x81\xd0\xfd\x9aSp\xd0\x9f!\xc8\xe2\xc3}\xe8\x00\x00\x00\x82'
b'Pz\xc6l1\xb0=B\x12\x16\xc1\x9a\x8b\xb9;sj\xc1\x9c\xdei\x10/[,\xa5p\x94'
b'}\xa5\xdb\xe1\xf2\x10r\xaf\x13n \xaf\xbb+\xd6;\x93\x00\x03\x00\x00\x00\x854'
b'\x87b\xdd\xb5N\xcf\xc2I\x86\x9c\xa0\xf4\xce\x83\x17\xb0\x03R\xf8b'
b'\x19\xa7m\xe1w\xd1\xa4$\xc8G\xcd')
Результат разбора:
'A1': [{'B1': -0.9454714059829712,
{'B2': 2965834094423468828,
'B3': -0.8803907989610327},
'B1': -0.8685615062713623,
{'B2': -2683938743531337091,
'B3': 0.7970967248134979}],
'A2': -3413972845841908248,
'A3': {'C1': 28129, 'C2': 119},
'A4': 80,
'A5': {'D1': 2059824177,
'D2': -5747364903996253557,
'D3': {'E1': -5099355250714943895,
'E2': 1166251075824555133,
'E3': -6495349607777521901,
'E4': [28192, 44987],
'E5': 735460243},
'D4': [53668, 9416, 18381],
'D5': 3785102716197326786,
'D6': 5298094226763842327,
'D7': -1341959432,
'D8': [98, 25, 167]}}
Задача №12
Реализовать разбор двоичного формата данных. Данные начинаются с сигнатуры 0x55 0x44 0x56 0x49 0x9c
, за которой следует
структура A. Порядок байт: от младшего к старшему. Адреса указаны в виде смещений от начала данных. В решении предлагается использовать
модуль struct.
Структура A:
Поле | Описание |
---|---|
1 | Массив char, размер 8 |
2 | int16 |
3 | Адрес (uint16) структуры B |
Структура B:
Поле | Описание |
---|---|
1 | int8 |
2 | Массив адресов (uint16) структур C, размер 8 |
3 | Структура D |
4 | int64 |
5 | uint32 |
6 | Массив int64, размер 2 |
7 | Размер (uint16) и адрес (uint16) массива int8 |
Структура C:
Поле | Описание |
---|---|
1 | uint32 |
2 | int16 |
Структура D:
Поле | Описание |
---|---|
1 | double |
2 | Массив float, размер 7 |
3 | double |
4 | uint64 |
Ниже показаны примеры разбора двоичного формата.
Пример 1
Двоичные данные:
b'UDVI\x9cfrhfffaaRgF\x00A\xa4g\xddE\xa8\x05ty\x8f/c\xad\x8d>\x1azy\xec'
(b'\xe5\xba\xf3[:|\xb3\xe2\x0f!\xa1Xk\xcdA\xb3k\x08}\xc9\xff\t<\xcaq&W\xac'
b'\x14\xfe\xde\x05\xa3\x05\x0f\x11\x00\x17\x00\x1d\x00#\x00)\x00/\x005'
b'\x00;\x00\x90\xd4\xaaG<\xbc\xea?+\x04x<\x88\x1f\x16?\xe0e\x06\xbe:'
b'V\xac\xbe\xb1\xc8\xc8>\x1f\xac\x98\xbe]l\x95>\x98\xac4[Q\xca\xcb?G'
b'\xfc\xa6\xad\xee\xfd\xee\x9f\x11%\xca\xc7af\x84\xea\xa9\x17\xef\x86\x85'
b',>6\xe2\x05b\xacV/\x12\x89A\xa3\xb3\xbb\x05\x00A\x00')
Результат разбора:
'A1': 'frhfffaa',
{'A2': 26450,
'A3': {'B1': 15,
'B2': [{'C1': 3714556993, 'C2': -22459},
'C1': 2407101445, 'C2': 25391},
{'C1': 440307117, 'C2': 31098},
{'C1': 4089112044, 'C2': 14939},
{'C1': 266515324, 'C2': -24287},
{'C1': 1103981400, 'C2': 27571},
{'C1': 4291394824, 'C2': 15369},
{'C1': 1462137290, 'C2': 5292}],
{'B3': {'D1': 0.835477962470252,
'D2': [0.015137712471187115,
0.586418628692627,
-0.13124799728393555,
-0.336595356464386,
0.3921561539173126,
-0.298188179731369,
0.29184237122535706],
'D3': 0.21711174920469456,
'D4': 11524427698045123655},
'B4': -1547999801758833391,
'B5': 2263816105,
'B6': [-6025246882337510267, -4921410465917948074],
'B7': [-2, -34, 5, -93, 5]}}
Пример 2
Двоичные данные:
b'UDVI\x9ckulrlcie\x97]E\x00\x02\xab\x06\xd7K9\x99\x9fF\xc7\x84g\xa8\xac\x1c'
(b'\x18\xa7*\xde\xc1\x04\xff\x0f\x11\xf0,\xaeN^\xf9\x89\xa6\xab\x9e\x86'
b'\x03\x18c\xba\xd4\xf7E\x1e\x91\x14\xfa)\xe1\xc9O&\x0cp\x11\x00'
b'\x17\x00\x1d\x00#\x00)\x00/\x005\x00;\x00\xe65t\x8a\xb0u\xea\xbf\x7f| \xbeIw'
b'K?g\x98G\xbf0E\x18\xbfI::?\xd5\xe2\xb9\xbey\x0e\x1f\xbf\xf4\xaf\xc9!F#'
b'\xef\xbf\xd7-\xc4\x1ca\xf1\xd9> C\x84\xc4\xcb\xd2\xeawtK\x10\x83\xd8\xdf'
b'cI\x0e\x05J^\x80\n\xfa_\xd3\xd3\x8b\x98\x04\x00A\x00')
Результат разбора:
'A1': 'kulrlcie',
{'A2': 23959,
'A3': {'B1': 112,
'B2': [{'C1': 3607538434, 'C2': 14667},
'C1': 3343294361, 'C2': 26500},
{'C1': 404532392, 'C2': 10919},
{'C1': 4278501854, 'C2': 4367},
{'C1': 1320037616, 'C2': -1698},
{'C1': 2662049417, 'C2': 902},
{'C1': 3568984856, 'C2': 17911},
{'C1': 4195651870, 'C2': -7895}],
{'B3': {'D1': -0.8268664077929173,
'D2': [-0.15672491490840912,
0.7947888970375061,
-0.7796692252159119,
-0.5948057174682617,
0.7274518609046936,
-0.3630587160587311,
-0.6213145852088928],
'D3': -0.9730559024733325,
'D4': 4528916299694484951},
'B4': 8640950607680914208,
'B5': 2198883188,
'B6': [6794248546760777688, -7454631853379941760],
'B7': [-55, 79, 38, 12]}}
Задача №12
Реализовать разбор двоичного формата данных. Данные начинаются с сигнатуры 0x49 0x50 0x4e 0xd8
, за которой следует структура
A. Порядок байт: от младшего к старшему. Адреса указаны в виде смещений от начала данных. В решении предлагается использовать модуль
struct.
Структура A:
Поле | Описание |
---|---|
1 | int8 |
2 | uint64 |
3 | int8 |
4 | Размер (uint16) и адрес (uint32) массива char |
5 | int8 |
6 | Адрес (uint16) структуры B |
Структура B:
Поле | Описание |
---|---|
1 | int32 |
2 | float |
3 | int64 |
4 | Размер (uint32) и адрес (uint32) массива адресов (uint32) структур C |
5 | Структура D |
Структура C:
Поле | Описание |
---|---|
1 | Размер (uint16) и адрес (uint16) массива uint8 |
2 | int8 |
3 | Размер (uint32) и адрес (uint16) массива int8 |
4 | int64 |
Структура D:
Поле | Описание |
---|---|
1 | uint32 |
2 | uint8 |
3 | int16 |
4 | Размер (uint32) и адрес (uint32) массива uint8 |
Ниже показаны примеры разбора двоичного формата.
Пример 1
Двоичные данные:
b'IPN\xd8H\x03\xca~\txFm\x99\x8d\x02\x00\x17\x00\x00\x00>T\x00qxQR\xa8'
(b'\x12\x02\x00\x19\x00F\x02\x00\x00\x00\x1b\x00\xb3$?c\xdb\xe9i\x84'
b'b\x10\xb2\x96\x02\x000\x00\x9c\x02\x00\x00\x002\x00\x1dye{\x14\xf7z6\x1d'
b"\x00\x00\x004\x00\x00\x00\x1cOH%\\\x11\xf5)\x17\xe29\x01\xbe\xd8i'\xb6"
b'\x0b>\x92\x8e\x02\x00\x00\x00G\x00\x00\x00\x1e\x03\x9d\xb2\xa0\xe1\r\x05'
b'\x00\x00\x00O\x00\x00\x00')
Результат разбора:
'A1': 72,
{'A2': 11055570141633759747,
'A3': -115,
'A4': 'qx',
'A5': 62,
'A6': {'B1': 388625681,
'B2': -0.12619736790657043,
'B3': -8173402153702430248,
'B4': [{'C1': [81, 82],
'C2': 70,
'C3': [-88, 18],
'C4': -8905329659676253005},
'C1': [98, 16],
{'C2': -100,
'C3': [-78, -106],
'C4': 3925721692548462877}],
'B5': {'D1': 2996634398,
'D2': 160,
'D3': 3553,
'D4': [28, 79, 72, 37, 92]}}}
Пример 2
Двоичные данные:
b'IPN\xd8\x14P\x81\x082\xbc\x85\x94\xf7\x86\x02\x00\x17\x00\x00\x00\x15T\x00i'
(b'l\xee\x8d\xf2\x83\x02\x00\x19\x000\x02\x00\x00\x00\x1b\x00\x06\xb49\xc7'
b'8 \x03\xc4\xc1\x96\xb5\xfe.3\x02\x000\x00\xdb\x04\x00\x00\x002\x00\x14\xf5<'
b'G\xec\xe9`\xd1\x1d\x00\x00\x006\x00\x00\x00\x06\xd3o\xf6\x00s\r\xc5\x15\xb6>'
b'V\xdf;\xb6+\xae\xb5\xf8\x02\x00\x00\x00I\x00\x00\x00W\xa3\x184'
b'\xf2\xd7\xb4\x03\x00\x00\x00Q\x00\x00\x00')
Результат разбора:
'A1': 20,
{'A2': 17840031067261141328,
'A3': -122,
'A4': 'il',
'A5': 21,
'A6': {'B1': 225640694,
'B2': 0.3556348383426666,
'B3': -525322278754590890,
'B4': [{'C1': [238, 141],
'C2': 48,
'C3': [-14, -125],
'C4': -4322575789112839162},
'C1': [193, 150],
{'C2': -37,
'C3': [-75, -2, 46, 51],
'C4': -3359428121001659116}],
'B5': {'D1': 874029911, 'D2': 242, 'D3': -19241, 'D4': [6, 211, 111]}}}
Задача №12
Реализовать разбор двоичного формата данных. Данные начинаются с сигнатуры 0x50 0x4b 0x56
, за которой следует структура A.
Порядок байт: от младшего к старшему. Адреса указаны в виде смещений от начала данных. В решении предлагается использовать модуль
struct.
Структура A:
Поле | Описание |
---|---|
1 | Адрес (uint32) структуры B |
2 | Массив uint8, размер 2 |
3 | float |
Структура B:
Поле | Описание |
---|---|
1 | Адрес (uint32) структуры C |
2 | uint32 |
3 | Массив структур D, размер 2 |
4 | Адрес (uint16) структуры E |
5 | float |
Структура C:
Поле | Описание |
---|---|
1 | Размер (uint16) и адрес (uint32) массива int64 |
2 | float |
3 | int32 |
4 | float |
Структура D:
Поле | Описание |
---|---|
1 | Массив int16, размер 2 |
2 | int32 |
3 | uint16 |
Структура E:
Поле | Описание |
---|---|
1 | Размер (uint32) и адрес (uint32) массива uint64 |
2 | uint64 |
Ниже показаны примеры разбора двоичного формата.
Пример 1
Двоичные данные:
b'PKVw\x00\x00\x00\xd6\x96b\xf8 >\xb1\x19Q\xf6\xfe\xe4\xa43\x91\xdc\xed'
(b'2\xc51\xf2Y}\xadju\xcb2\xc3s\x03\x00\r\x00\x00\x00\xdd\xec4\xbf,9Q!\xb2'
b'\x12H?\xc5\xe9\xf5 e=X\xaa\xed\xe2S\x8eP\xf2\x95\xc1\xf3\n\x11\x07\x81'
b'@\x9d\xd7\xa0\x8d\xd9\xac~~\x8c\xc5$`m\x8ee\xa3VVd\x81J\xe8#\xd7\x8c\xaa\x06'
b'\x00\x00\x007\x00\x00\x00\xd4B\xd8\x08\x8c\xfc}9%\x00\x00\x00\xcb'
b'\x10\x9c\x95n\x8d\xb8a\x0f\xc0\xd4}\x15\x02\xe8\xe6 0\x00Y#\xe3\xdc\xcdg'
b'\x00\x11\t\xcb\xbe')
Результат разбора:
'A1': {'B1': {'C1': [3721350975820208561,
{6481297536772332689,
8341566784249965949],
'C2': -0.7067392468452454,
'C3': 558971180,
'C4': 0.781535267829895},
'B2': 2510033099,
'B3': [{'D1': [-29330, 25016], 'D2': 2111094799, 'D3': 533},
'D1': [-6424, 12320], 'D2': -484222720, 'D3': 52700}],
{'B4': {'E1': [12274628288952265157,
13949321848649147117,
15536645212411595507,
14234891604742213024,
6221339591835476004,
12289434032408265060],
'E2': 4142744910624735956},
'B5': -0.39655354619026184},
'A2': [214, 150],
'A3': 0.157197505235672}
Пример 2
Двоичные данные:
b'PKVo\x00\x00\x00\xcb`\x02\xf5>\xbf\xd4\xd4\xf1\x10G\xaf\xb4\xde\x11\xbf\xde'
(b'\x0f\x7f\xe7\\\xffR\xd0\x00\xe0\x9a\x96\xb4M\x03\x00\r\x00\x00\x00\x11'
b'\x9b\xe5\xbeI\rTad9d?h\xe6\x80\xf3\x89\xf1n\xd4\xcd\xd4\x86\x0e\xb5'
b'\x0fY\xf6)\xc6\xda\xd7X\x90\xd84>\xb7B\x98\x97\xa1\xa4\x8aWL\xf7\xe7\xdb'
b'\xda!3\x05\x00\x00\x007\x00\x00\x00D\x8e9\x8d\xc2!f\xd9%\x00\x00\x00w'
b'\x12\x01\xdd\x88i\x89\x9cI,\xc2!\xeb\xdb\xef\xd1\xa9\xa2\x03\xf9\xa3'
b'\x04\x05\xef_\x00\xefpF\xbf')
Результат разбора:
'A1': {'B1': {'C1': [-2399099981719808812,
{-45907363267428591,
5599265828655648850],
'C2': -0.44844868779182434,
'C3': 1632898377,
'C4': 0.89150071144104},
'B2': 3707834999,
'B3': [{'D1': [27016, -25463], 'D2': 566373449, 'D3': 56299},
'D1': [-11793, -23895], 'D2': 77854979, 'D3': 61189}],
{'B4': {'E1': [15307437758277019240,
17751236676564735181,
3807952196194715177,
9990287545881245502,
3684466608190213207],
'E2': 15665245473331580484},
'B5': -0.7751607298851013},
'A2': [203, 96],
'A3': -0.745926022529602}
Задача №12
Реализовать разбор двоичного формата данных. Данные начинаются с сигнатуры 0x15 0x53 0x46 0x48 0x49
, за которой следует
структура A. Порядок байт: от старшего к младшему. Адреса указаны в виде смещений от начала данных. В решении предлагается использовать
модуль struct.
Структура A:
Поле | Описание |
---|---|
1 | float |
2 | Структура B |
Структура B:
Поле | Описание |
---|---|
1 | Структура C |
2 | Массив char, размер 8 |
3 | Массив структур D, размер 2 |
4 | uint32 |
5 | int16 |
6 | int64 |
Структура C:
Поле | Описание |
---|---|
1 | int8 |
2 | int64 |
3 | uint8 |
Структура D:
Поле | Описание |
---|---|
1 | Массив float, размер 7 |
2 | Размер (uint16) и адрес (uint16) массива int8 |
3 | int64 |
4 | uint16 |
5 | int32 |
6 | int16 |
7 | uint8 |
Ниже показаны примеры разбора двоичного формата.
Пример 1
Двоичные данные:
b'\x15SFHI\xbfe\xf2\xd6\x0b\xdb\xcd\x96k\xa3\xb3\x06\xee\x9djzwwmjnf>'
(b'\xb8\x9c\xfa?*\xf5\xd1\xbf1\xdd\x1d\xbe\x99\t\xd7?~v1?\x1c-\xba?K\xdcM\x00'
b'\x03\x00\x8b\x19\\\xfd\xbbqv\xe2O\xfeEX\xb9\x82\x0b a\xef\xbf\x1b\xc7\xfb'
b'=\xf9 \xf6\xbf\n\xb0g\xbf\x1e\x07\xb4\xbfX\x92\n>`gs\xbc\xc6\x87\xc7'
b'\x00\x03\x00\x8e\x89GlP\x88\xd8;\x11om\x9d\xa3\x88=\x03\xfaA\xdc\xe7<LBmB'
b'\x0e\xd7\xbc\xe6T~o\x01\xe9\x03c\xed\xc2')
Результат разбора:
'A1': -0.8982366323471069,
{'A2': {'B1': {'C1': 11, 'C2': -2608263220125563154, 'C3': 157},
'B2': 'jzwwmjnf',
'B3': [{'D1': [0.3605726361274719,
0.6678133606910706,
-0.694780170917511,
-0.2989031970500946,
0.993990957736969,
0.6100727319717407,
0.7963302731513977],
'D2': [1, -23, 3],
'D3': 1827614530309907023,
'D4': 65093,
'D5': 1488552459,
'D6': 8289,
'D7': 239},
'D1': [-0.6085202097892761,
{0.12164489924907684,
-0.5417541861534119,
-0.6173050403594971,
-0.8459783792495728,
0.21914462745189667,
-0.02423466555774212],
'D2': [99, -19, -62],
'D3': -8554749874017912047,
'D4': 28525,
'D5': -1650227139,
'D6': 1018,
'D7': 65}],
'B4': 3706141772,
'B5': 17005,
'B6': 4759979062495313519}}
Пример 2
Двоичные данные:
b'\x15SFHI?C\x06\xc6\xce\xf2\xa2\x92lp\x9d\x8c\x9d\x99ozedtsgk?,\xa1\x8f>'
(b'\xd4\x02\x93\xbf]\xfc9\xbdi\x83\x1a\xbf\\Y\xcc\xbfi+\x87\xbf&\xc1\x88\x00'
b'\x02\x00\x8bg]fM\xc1\xc9\x8b\xce\xa55 \xec\xcb\xc6\xa8`,\xbe\x9c\xe7\xb9'
b'?F\xf3=>\x8bo\xc7\xbfm\x1f\x0f\xbf\x15z\xf7\xbe\x9a\x94\xcb\xbf4 \xc7'
b'\x00\x03\x00\x8d\x18\x92s\x19\xac\xf8\xdfHpC\xf7Yf\x97\x9c0\x01\x88d\x06'
b'\xa3\xf8UA\x99pW\x1f^z\xd9\x02nq\x96 ')
Результат разбора:
'A1': 0.7618221044540405,
{'A2': {'B1': {'C1': -50, 'C2': -963046375860368227, 'C3': 153},
'B2': 'ozedtsgk',
'B3': [{'D1': [0.6743401885032654,
0.4140821397304535,
-0.8671298623085022,
-0.05700979381799698,
-0.8607451915740967,
-0.9108204245567322,
-0.651390552520752],
'D2': [2, 110],
'D3': 7448221842890394574,
'D4': 42293,
'D5': 552389574,
'D6': -22432,
'D7': 44},
'D1': [-0.3064554035663605,
{0.7771490216255188,
0.2723371684551239,
-0.9262551665306091,
-0.5839075446128845,
-0.3019164502620697,
-0.7036251425743103],
'D2': [113, -106, 32],
'D3': 1770604157623394120,
'D4': 28739,
'D5': -145135977,
'D6': -25552,
'D7': 1}],
'B4': 2288256675,
'B5': -1963,
'B6': 4726932803392797401}}
Задача №12
Реализовать разбор двоичного формата данных. Данные начинаются с сигнатуры 0x4d 0x4e 0x4e 0x4f
, за которой следует структура
A. Порядок байт: от старшего к младшему. Адреса указаны в виде смещений от начала данных. В решении предлагается использовать модуль
struct.
Структура A:
Поле | Описание |
---|---|
1 | int32 |
2 | uint64 |
3 | Адрес (uint16) структуры B |
4 | Структура E |
5 | int32 |
6 | uint16 |
7 | uint8 |
Структура B:
Поле | Описание |
---|---|
1 | uint16 |
2 | Размер (uint16) и адрес (uint32) массива char |
3 | int32 |
4 | int16 |
5 | Массив структур C, размер 4 |
6 | Структура D |
7 | int64 |
Структура C:
Поле | Описание |
---|---|
1 | uint16 |
2 | int16 |
3 | int64 |
Структура D:
Поле | Описание |
---|---|
1 | uint16 |
2 | Массив uint8, размер 5 |
3 | float |
4 | uint16 |
5 | int16 |
6 | uint32 |
7 | int8 |
8 | uint16 |
Структура E:
Поле | Описание |
---|---|
1 | Массив float, размер 8 |
2 | uint32 |
3 | int16 |
4 | int8 |
Ниже показаны примеры разбора двоичного формата.
Пример 1
Двоичные данные:
b"MNNO\xfe~)\xc4fmW'\xae[\xec\xd7\x00C>\xbf\x1a\xc1?[\xf95?%U\x9d\xbd\xe9"
(b'\x12\xa3\xbeb\xc1\x1c>\xf1\xa1\xf7>\xa1\x0bb>\xe7d\xd8\xbc\xe3\x0b\x0f!k'
b'9;\xd2\xf1S\xd7s\x87jck\xd9\x0c\x00\x03\x00\x00\x00@4\x99\xdajB;q\x85\xc9'
b'\xf2\xcb$\x08\xf7\xc2\xd6l\x9b\xa8\xea\x97}\xc2j\x94_\xed{<\xf0u\xe95'
b'`\x1d>\xc5K%\xcc0@+5\xd4\xc6\x15\xec\xff\xd63\x0b_\xd5\xb0VLp\xe9IV'
b'?\x0e\xb0\xa2J+"\x90\xeb@\xca\x99T\xb9w[e\xbc\x14rK\xee\xd5')
Результат разбора:
'A1': -25286204,
{'A2': 7380651192270712023,
'A3': {'B1': 55564,
'B2': 'jck',
'B3': 882498154,
'B4': 16955,
'B5': [{'C1': 29061, 'C2': -13838, 'C3': -3808909524629820261},
'C1': 43242, 'C2': -26755, 'C3': -4437571343093121808},
{'C1': 30185, 'C2': 13664, 'C3': 2107338602203328576},
{'C1': 11061, 'C2': -11066, 'C3': 1579918864744669141}],
{'B6': {'D1': 45142,
'D2': [76, 112, 233, 73, 86],
'D3': 0.5573827028274536,
'D4': 18987,
'D5': 8848,
'D6': 3946891929,
'D7': 84,
'D8': 47479},
'B7': 6585876826102165205},
'A4': {'E1': [0.3732509911060333,
0.8592713475227356,
0.6458376049995422,
-0.11380507797002792,
-0.22143977880477905,
0.471938818693161,
0.31453996896743774,
0.45194125175476074],
'E2': 3168996111,
'E3': 8555,
'E4': 57},
'A5': 1003680083,
'A6': 55155,
'A7': 135}
Пример 2
Двоичные данные:
b'MNNO\xae$8\xfd\x8du\xc6\x02a\xa0\x0e\xfe\x00C?ln\xd1\xbf)\xf0\xb1?\\'
(b"\xc1\xed\xbeOB\x91\xbf\x00\xa8'\xbe\xbeB\x0c\xbfa\x89\xdc?B\tE\xb5\x02"
b'I\xba>(\xeb\x0b\xcb\xe0\xee\x8e\xb5\x0ftxr.F\x00\x03\x00\x00\x00@a'
b'\xf7\x14\xd03\x7f\xde\x9d\xa2\xde.\x88\xe3\x1c\x8av\xae]i\x0f3G\xd7\x8e\x95'
b'j\xf8/\xe9\xd1\xd1\xc3\xf0O\xd8?\xd6\x8e\x06o6\x039\xaa\x05\xae\x81MF'
b"\xcfP\xd1\xf1\xd4\xb4!\xa05E\xae\xb6\xbf\x1a b';P2\xe3\xfb;ACjP\x83"
b'\xf43\xf4y\xc8\\\x15')
Результат разбора:
'A1': -1373357827,
{'A2': 10193271045153099518,
'A3': {'B1': 11846,
'B2': 'txr',
'B3': 1643582672,
'B4': 13183,
'B5': [{'C1': 56989, 'C2': -23842, 'C3': 3353179634298957405},
'C1': 26895, 'C2': 13127, 'C3': -2914227622199170607},
{'C1': 53699, 'C2': -4017, 'C3': -2864334932502694397},
{'C1': 14762, 'C2': 1454, 'C3': -9129563013382016556}],
{'B6': {'D1': 46113,
'D2': [160, 53, 69, 174, 182],
'D3': -0.602056622505188,
'D4': 10043,
'D5': 20530,
'D6': 3824892737,
'D7': 67,
'D8': 27216},
'B7': -8938462235315381227},
'A4': {'E1': [0.9235659241676331,
-0.6638289093971252,
0.8623340725898743,
-0.20240236818790436,
-0.5025658011436462,
-0.37159764766693115,
-0.8810098171234131,
0.757953941822052],
'E2': 3036826042,
'E3': 15912,
'E4': -21},
'A5': 197910766,
'A6': 36533,
'A7': 15}
Задача №12
Реализовать разбор двоичного формата данных. Данные начинаются с сигнатуры 0xa9 0x48 0x4e 0x51 0x4c
, за которой следует
структура A. Порядок байт: от младшего к старшему. Адреса указаны в виде смещений от начала данных. В решении предлагается использовать
модуль struct.
Структура A:
Поле | Описание |
---|---|
1 | Структура B |
2 | int32 |
3 | int16 |
4 | int16 |
5 | Адрес (uint16) структуры C |
6 | Структура E |
7 | uint8 |
8 | Массив int8, размер 4 |
Структура B:
Поле | Описание |
---|---|
1 | Размер (uint16) и адрес (uint32) массива char |
2 | int64 |
Структура C:
Поле | Описание |
---|---|
1 | int16 |
2 | float |
3 | Массив адресов (uint16) структур D, размер 3 |
Структура D:
Поле | Описание |
---|---|
1 | uint64 |
2 | int32 |
Структура E:
Поле | Описание |
---|---|
1 | int16 |
2 | Структура F |
Структура F:
Поле | Описание |
---|---|
1 | int64 |
2 | int16 |
3 | Размер (uint32) и адрес (uint32) массива uint32 |
4 | float |
5 | Массив uint64, размер 3 |
Ниже показаны примеры разбора двоичного формата.
Пример 1
Двоичные данные:
b'\xa9HNQL\x06\x00R\x00\x00\x00@\xaem\x12`\xa2\xf0\x13x\xa9\x168:"\xee\x96|'
(b'\x00~\x03\xc8\xf8\xf2\x14\xf3\xa2\xb1\x9e\xf9\x00\x02\x00\x00'
b'\x00\x88\x00\x00\x00\x81\x05-\xbf+\x14P,,m7\xf8\x04C\xeb*rk\x02\xbeJah'
b'\xa5\xfdq\x8f\x9b\x03\xd855jtfojxo\xe0\xf5/\x00\x1b-\xf0P\xdd\x9c\xfa\x1d'
b'\xae\x0f\x9c\xd0\xecI\xa1\xa9V*\x9e\x9d\xf4\xca\x96\xe8\x052\x15;'
b'\xc7/\x1f\xf3V\x063\x7f)\xbeX\x00d\x00p\x005\x9d\x9dfsk4\xe1')
Результат разбора:
'A1': {'B1': 'tfojxo', 'B2': 1436826814640926272},
{'A2': 941009272,
'A3': 8762,
'A4': -26898,
'A5': {'C1': 1622,
'C2': -0.16552428901195526,
'C3': [{'D1': 5832211111435302368, 'D2': 502963421},
'D1': 12223132145121234862, 'D2': -1650578858},
{'D1': 4257364023707093748, 'D2': -216059961}]},
{'A6': {'E1': 894,
'E2': {'F1': -7011643979926931256,
'F2': 249,
'F3': [1721605429, 3778308979],
'F4': -0.6758652329444885,
'F5': [17885884481614648363,
13691623955250234116,
11209303331764199754]}},
'A7': 3,
'A8': [-40, 53, 53, 106]}
Пример 2
Двоичные данные:
b"\xa9HNQL\x07\x00R\x00\x00\x00),\xfa\xa0\xc1\x0b,\xbco>\xdc2\xb5\xb52'}"
(b'\x00\x85$\xe6\xa1b\xa1\rSP&\xd4\n\x02\x00\x00\x00\x89\x00\x00\x00\xe8\x869'
b'\xbe\xf8\xef\x184\x89N\x8f\xa4A\xe2\x7f\xc8\x85\xce\x06\x00.\xc8\x03'
b'\xe4\xbbF\xbc\xba\xfco\xfe\xbd]shpszgj5\xe9\xfd)\x16(\xd9\xc6\xad\xe9\x01'
b'\x94\xec\xc9\xe7\xbau\xc9R\x1d\xebv\x87\x18\x13\xb2\x08\n\n\xbe\x8e'
b'B\x1c\x9f%\\\x0c\xec\xadH!\xbeY\x00e\x00q\x00\xc0{\xe5\xb6\xbe\xa0\xd2\x95')
Результат разбора:
'A1': {'B1': 'shpszgj', 'B2': -4887518569346487255},
{'A2': 853294703,
'A3': -19019,
'A4': 10034,
'A5': {'C1': -5108,
'C2': -0.15750379860401154,
'C3': [{'D1': 14328527765114841397, 'D2': -1811813971},
'D1': 2112972682674293228, 'D2': 411530987},
{'D1': 4795979603523449363, 'D2': 1545969436}]},
{'A6': {'E1': 9349,
'E2': {'F1': 2760797889585390054,
'F2': 2772,
'F3': [3068492736, 2513608894],
'F4': -0.18117868900299072,
'F5': [11857782695081340920,
1915923850060353,
13455707559474481198]}},
'A7': 252,
'A8': [111, -2, -67, 93]}
Задача №12
Реализовать разбор двоичного формата данных. Данные начинаются с сигнатуры 0x43 0x4e 0x53 0x43 0x36
, за которой следует
структура A. Порядок байт: от старшего к младшему. Адреса указаны в виде смещений от начала данных. В решении предлагается использовать
модуль struct.
Структура A:
Поле | Описание |
---|---|
1 | Размер (uint32) и адрес (uint16) массива структур B |
2 | uint32 |
3 | Массив char, размер 2 |
4 | Адрес (uint32) структуры D |
5 | uint32 |
Структура B:
Поле | Описание |
---|---|
1 | float |
2 | Структура C |
3 | uint64 |
Структура C:
Поле | Описание |
---|---|
1 | uint32 |
2 | Массив uint32, размер 3 |
3 | uint64 |
Структура D:
Поле | Описание |
---|---|
1 | float |
2 | uint64 |
3 | Размер (uint16) и адрес (uint32) массива uint32 |
4 | int32 |
5 | int8 |
6 | Размер (uint16) и адрес (uint32) массива int16 |
Ниже показаны примеры разбора двоичного формата.
Пример 1
Двоичные данные:
b'CNSC6\x00\x00\x00\x02\x00\x19\x82\x9bd\x19fv\x00\x00\x00\x852\xa2\xed'
(b'\xc9?y\xeaA\x8c\x99\xd1x_\xb5\xc4\x12\xa1\x1c\x96G\xb7\xb8;{\xf0\xe2=b\xb8vK'
b'?\xd8\xdb\xf1\x96\xc4\x8e\xc3\xda?J"\xef\xbc\x90\x19C,z1\x92\x151\x01'
b't\x8d\xc6\xa4\xd3o\x88\x91\\\x0e\xc1\xb4c\xbf\xf2}i\xa7\xfa\xe3X\x04\xd47'
b';!\x98\x06N\xc3\x11\x0f\r#$\x11$>m\xff\x19Al|\x17\x93B\x03\xcd\x921T'
b'\x01\x15e\xcf$\xbe\x04\xf1\x1d\x14\xc0Z\xac\x13\xab\xcd\xa0\x00\x07\x00'
b'\x00\x00a\x18\xb1\xa4@\x9d\x00\x04\x00\x00\x00}')
Результат разбора:
'A1': [{'B1': 0.9762306809425354,
{'B2': {'C1': 2358890872,
'C2': [1605747730, 2703005255, 3082304379],
'C3': 17357503408050162495},
'B3': 15626348961937146842},
'B1': 0.7895955443382263,
{'B2': {'C1': 3163560259,
'C2': [746205586, 355533172, 2378605779],
'C3': 8036833359613244515},
'B3': 13831255298351489880}],
'A2': 2191221785,
'A3': 'fv',
'A4': {'D1': -0.12982602417469025,
'D2': 1495294771397905824,
'D3': [81016635,
563611214,
3272675085,
589566244,
1047396121,
1097628695,
2470577101],
'D4': 414295104,
'D5': -99,
'D6': [-28111, 21505, 5477, -12508]},
'A5': 849538505}
Пример 2
Двоичные данные:
b'CNSC6\x00\x00\x00\x02\x00\x19f\xf0\\\xf0jp\x00\x00\x00\x81\x04i\x07'
(b'#\xbe\x99\x8e\xb0\xfcU\xb0\xc8\x8c\xd9\xb9I\x08n8V\xc8\x19\x80\x03\xb1>O'
b'\xa5\xd8\x17\xbd\xf6\xda\x8e\x06\xf4\x85\xe7\xc0\xef?&\x11\x87%F\xdf'
b'\xc3\xf2\xcf"\xd1l\x14q\x13\x84\x16\xba#U\\l\xe2\x83\xb7\xcf\x02\xe0\xd7\x06'
b'\x1a\xe7X\x9d\xcb\x9b_\xa1\x98\x88\xeb*\xc5?\xf4\xa1\xe6l\xfeH9\x17\xd8\xaf'
b"\xd34\xd3\x83\x00d\x18'\xa0d\x7f:n\xbfmM9&\xc9\x10\xc2y\x14\xd5L\x00\x06\x00"
b'\x00\x00a\x06\x93\x8d\xcb\xeb\x00\x04\x00\x00\x00y')
Результат разбора:
'A1': [{'B1': -0.29991674423217773,
{'B2': {'C1': 4233474248,
'C2': [2363078985, 141441110, 3357114371],
'C3': 12771733166982938102},
'B3': 15748532594249548015},
'B1': 0.6487049460411072,
{'B2': {'C1': 625401795,
'C2': [4073661137, 1813278995, 2216081955],
'C3': 6150910911209524994},
'B3': 16201424897108909515}],
'A2': 1727028464,
'A3': 'jp',
'A4': {'D1': -0.9269595742225647,
'D2': 2794783471201211724,
'D3': [2606735768,
2297113285,
1072996838,
1828603961,
400076755,
886276864],
'D4': 110333387,
'D5': -21,
'D6': [25624, 10144, 25727, 14958]},
'A5': 73991971}
Задача №12
Реализовать разбор двоичного формата данных. Данные начинаются с сигнатуры 0xd6 0x4f 0x50 0x41 0x4c
, за которой следует
структура A. Порядок байт: от старшего к младшему. Адреса указаны в виде смещений от начала данных. В решении предлагается использовать
модуль struct.
Структура A:
Поле | Описание |
---|---|
1 | int64 |
2 | uint64 |
3 | Массив char, размер 2 |
4 | uint32 |
5 | int16 |
6 | Структура B |
7 | Массив int32, размер 3 |
Структура B:
Поле | Описание |
---|---|
1 | Размер (uint32) и адрес (uint32) массива адресов (uint32) структур C |
2 | uint32 |
3 | Размер (uint16) и адрес (uint16) массива uint8 |
4 | Структура D |
Структура C:
Поле | Описание |
---|---|
1 | uint32 |
2 | uint64 |
3 | int32 |
Структура D:
Поле | Описание |
---|---|
1 | uint16 |
2 | int64 |
3 | int32 |
4 | int32 |
5 | int64 |
6 | Массив uint32, размер 3 |
7 | uint32 |
Ниже показаны примеры разбора двоичного формата.
Пример 1
Двоичные данные:
b'\xd6OPAL\x9eub\x86\xc4\x87W\xaf\xa3\xbf|\xa4Eo\x0c7ht\xe7G\xcb\xd1\x93'
(b'T\x00\x00\x00\x02\x00\x00\x00\x83v\xd3\x14-\x00\x04\x00\x8b\xaaq\xe1k#\x81l'
b'3j$<\x07DgR\xc4px\xf5\x0ei\x0f\x9eP\xb8\x18\xc2m\xbc\x0e\xcde6SZ'
b'\xf1\xcd\xe6/\xc2\x18\xe2\xc4\xdc2c\xef^\xf6\x01.0\xcc\xddV\x19A\x89\xd7'
b'\xd0\xb0\rn\x87GZ\x83A\xef\x99\x92\xfe|,`SF\xbdzr\xf6\xc5\xc8'
b'\xfa\x12\xde\x00\x00\x00c\x00\x00\x00s\xd4\x02\xa5?')
Результат разбора:
'A1': -7028603312479447121,
{'A2': 11799286593715375159,
'A3': 'ht',
'A4': 3880242129,
'A5': -27820,
'A6': {'B1': [{'C1': 1444495753,
'C2': 15551123085045745498,
'C3': -2092830823},
'C1': 2466151468, 'C2': 6940969230325184197, 'C3': -923135266}],
{'B2': 1993544749,
'B3': [212, 2, 165, 63],
'B4': {'D1': 43633,
'D2': -2203628553894663644,
'D3': 1007109223,
'D4': 1388605560,
'D5': -788577368941742056,
'D6': [3261971470, 3445962323, 1525796326],
'D7': 801249506}},
'A7': [-992202141, -278989311, 774950109]}
Пример 2
Двоичные данные:
b'\xd6OPALC\xd3\x9c\x04\x86\x95\x91\x1e\xbc\xf5n\x99\xa0\x14\x1d$vm\xea'
(b'\xe7\xecm\xbd\x03\x00\x00\x00\x02\x00\x00\x00\x83\xce\xe7^\x1c\x00\x04\x00'
b'\x8biB\x8d\xef\x94\xbfI\xca\xedw~`e\x91\xe6\xc2ea~\xc3\x83\xa96'
b"\xea\xa6\xd7\x0b\x19\xe5!\x11\xe5Ja\x85\xa2'5\x8d\x1b7$E\x90N\x90y\x14`o\x87"
b'6x\x0f\x1c\xf3\x11\x1c\r\xb3\xed\x1a\xd0\xe7E\x05D\xdb\x08\xce\xab'
b'\x8db\xe8\xe1u\xe8\x80\xf2\x07(\x92l[\x94\xc9\x00\x00\x00c\x00\x00\x00s\x07'
b'h\xb6\x96')
Результат разбора:
'A1': 4887421563878871326,
{'A2': 13615910654519287076,
'A3': 'vm',
'A4': 3941067885,
'A5': -17149,
'A6': {'B1': [{'C1': 485691676, 'C2': 987393442754020613, 'C3': 1155205326},
'C1': 2878169832,
{'C2': 16246146871322945682,
'C3': 1817941193}],
'B2': 3471269404,
'B3': [7, 104, 182, 150],
'B4': {'D1': 26946,
'D2': -8219187245630165641,
'D3': 2120246673,
'D4': -423467679,
'D5': 9134289232031557335,
'D6': [186246433, 300239457, 2241996597],
'D7': 2367371044}},
'A7': [1167085200, 2031378543, -2026473457]}
Задача №12
Реализовать разбор двоичного формата данных. Данные начинаются с сигнатуры 0x59 0x46 0x4d 0xe2
, за которой следует структура
A. Порядок байт: от старшего к младшему. Адреса указаны в виде смещений от начала данных. В решении предлагается использовать модуль
struct.
Структура A:
Поле | Описание |
---|---|
1 | Адрес (uint16) структуры B |
2 | Адрес (uint16) структуры F |
3 | uint32 |
4 | int32 |
5 | Массив uint32, размер 2 |
6 | int16 |
Структура B:
Поле | Описание |
---|---|
1 | uint16 |
2 | Адрес (uint16) структуры C |
3 | Адрес (uint32) структуры E |
Структура C:
Поле | Описание |
---|---|
1 | float |
2 | Размер (uint32) и адрес (uint16) массива адресов (uint32) структур D |
Структура D:
Поле | Описание |
---|---|
1 | Размер (uint32) и адрес (uint32) массива float |
2 | int16 |
3 | uint16 |
4 | Размер (uint16) и адрес (uint32) массива uint32 |
Структура E:
Поле | Описание |
---|---|
1 | uint8 |
2 | uint32 |
Структура F:
Поле | Описание |
---|---|
1 | double |
2 | int8 |
Ниже показаны примеры разбора двоичного формата.
Пример 1
Двоичные данные:
b'YFM\xe2\x00y\x00\x81\x0b\x15\xb6\xc1\xd5\xf7\x03k*\xc8\xdc\xf5)\x9e\xee\xd8'
(b'ja?6\x02\xae?+\x9a\n\xf8\x07\xa9\x88Z\xa0\x18K\x00\x00\x00\x02\x00\x00'
b'\x00\x1a\x01\x01;\xa7\x00\x02\x00\x00\x00"\xbf\x06m\xc0?"\x0b\xce'
b'\xde3\x13\x9ej0\n\x11\x87\xbe\xc1\x1c\x00\x00\x00\x02\x00\x00\x00<\x813\xf0n'
b'\x00\x03\x00\x00\x00D\x00\x00\x00*\x00\x00\x00P<)\xc0<\x00\x00\x00\x02\x00b'
b'\xd4l\tI\x89\x8c\xf1\x00j\x00\x00\x00t\xbf\xe6\xa5\t\xc4_\x01T\xcc')
Результат разбора:
'A1': {'B1': 36081,
{'B2': {'C1': 0.010360773652791977,
'C2': [{'D1': [0.7109783887863159, 0.6703191995620728],
'D2': 257,
'D3': 15271,
'D4': [4161251720, 1520441419]},
'D1': [-0.5251121520996094, 0.6329926252365112],
{'D2': -32461,
'D3': 61550,
'D4': [3727889310, 1781533201, 2277425436]}]},
'B3': {'E1': 212, 'E2': 1812547977}},
'A2': {'F1': -0.7076462588666268, 'F2': -52},
'A3': 185972417,
'A4': -705232021,
'A5': [717806837, 698281688],
'A6': 27233}
Пример 2
Двоичные данные:
b'YFM\xe2\x00}\x00\x85\\~7\xe8\x0e\xc1"\xcc\xa0\xa1\xfaP\x1f\xe1P\x92'
(b'\x03\x89\xbe\xd7\x9d\x0b\xbd\xeb\x1dj\\|\x94\xaf\xec\xaa/w\xcb\xa2/\x9dB\x00'
b'+\x13\x00\x00\x00\x02\x00\x00\x00\x1a\x97\xd45\x10\x00\x04\x00\x00\x00"'
b'\xbfI\xe5\xee>\xf8\x17w h\xdcN\xd4\x1b\xf2\x88\x00\x00\x00\x02\x00\x00\x00D'
b'A\x8c\xa5\xec\x00\x02\x00\x00\x00L\x00\x00\x002\x00\x00\x00T\xbe\xb2'
b'\xdaB\x00\x00\x00\x02\x00f\x97<\xed\xde\x9b\xa5D\x00n\x00\x00\x00'
b'x\xbf\xd9\x01v\x13\xd0\xe1@?')
Результат разбора:
'A1': {'B1': 42308,
{'B2': {'C1': -0.3493214249610901,
'C2': [{'D1': [-0.4211200177669525, -0.11480219662189484],
'D2': -26668,
'D3': 13584,
'D4': [1551668399, 3970576247, 3416403869, 1107307283]},
'D1': [-0.788664698600769, 0.4845540225505829],
{'D2': 16780,
'D3': 42476,
'D4': [543743054, 3558601352]}]},
'B3': {'E1': 151, 'E2': 1022221979}},
'A2': {'F1': -0.3907141870036135, 'F2': 63},
'A3': 1551775720,
'A4': 247538380,
'A5': [2694969936, 534859922],
'A6': 905}
Задача №12
Реализовать разбор двоичного формата данных. Данные начинаются с сигнатуры 0x4d 0x47 0x4b
, за которой следует структура A.
Порядок байт: от младшего к старшему. Адреса указаны в виде смещений от начала данных. В решении предлагается использовать модуль
struct.
Структура A:
Поле | Описание |
---|---|
1 | Массив адресов (uint32) структур B, размер 5 |
2 | Массив char, размер 6 |
3 | uint8 |
4 | uint64 |
5 | Структура C |
6 | Адрес (uint32) структуры D |
Структура B:
Поле | Описание |
---|---|
1 | int8 |
2 | int8 |
3 | uint64 |
Структура C:
Поле | Описание |
---|---|
1 | Размер (uint32) и адрес (uint16) массива uint64 |
2 | double |
3 | Размер (uint32) и адрес (uint32) массива float |
4 | int64 |
Структура D:
Поле | Описание |
---|---|
1 | float |
2 | Массив int64, размер 3 |
3 | uint32 |
4 | int32 |
Ниже показаны примеры разбора двоичного формата.
Пример 1
Двоичные данные:
b'MGKH\x00\x00\x00R\x00\x00\x00\\\x00\x00\x00f\x00\x00\x00p\x00\x00\x00wkhdz'
(b'u\x82\xcf7\xf1\x95\xdcj\xb1\x8b\x03\x00\x00\x00z\x00@q\xf3\x82G.\xc7\xbf'
b'\x02\x00\x00\x00\x92\x00\x00\x00+eK\xa2(\xf9\xe6\xfc\x9a\x00\x00\x00'
b'\xce\xc1,\xb94p\xedp\xff\xcf\x9cH\xc7\xe2\x87@\xcd\xb8\x03\x0c'
b'\x87\xeb\xfd\xc8\xd4\xc5\xb8\xdbC\x1b-\xf5;~u(\xe6\xcb\xda\xe5Uh\xa5\xab'
b'Z\x8f\xe2+\x122\xad\xdf\x137\xb1e\xb5\xd2\xa3\xa7\x95\xc6\x9b\xd1'
b'\xbb\xeb\x17\x00Y\x1e\xa3\xd3\xb1U\x9e\xaa\xca\xbe6\x93\x89\xbe\xa5i%\xbf\nq'
b'o\xb1\xf7h\x1bl \xb5\xb0\xc4w\x11\x11\xf9\xa9X\x17\xb3\x95gQ\xa8\x1aSe}\x875'
b')\xae')
Результат разбора:
'A1': [{'B1': -50, 'B2': -63, 'B3': 14987822250004363564},
{'B1': -100, 'B2': 72, 'B3': 865738745075720903},
{'B1': -121, 'B2': -21, 'B3': 1964655449103190269},
{'B1': 45, 'B2': -11, 'B3': 16562774768990125627},
{'B1': 85, 'B2': 104, 'B3': 3607994503544875941}],
{'A2': 'wkhdzu',
'A3': 130,
'A4': 10065944137790732239,
'A5': {'C1': [15183153530557161389, 16986400886539790243, 6174949261643939863],
'C2': -0.18109983343209457,
'C3': [-0.39583295583724976, -0.2687012553215027],
'C4': -223217178591402709},
'A6': {'D1': -0.6461432576179504,
'D2': [7789935393510486282, -499598877562718944, -6318154909571655511],
'D3': 2103792410,
'D4': -1373031033}}
Пример 2
Двоичные данные:
b'MGKH\x00\x00\x00R\x00\x00\x00\\\x00\x00\x00f\x00\x00\x00p\x00\x00\x00uoqkb'
(b'y\xb7=V\xe2CT.@\x1b\x03\x00\x00\x00z\x00\xa0R\xfa\xeb]\xe0\xc6\xbf'
b'\x02\x00\x00\x00\x92\x00\x00\x00\xc8\x90\x99\xa8\x997\xfb2\x9a\x00\x00\x00'
b'\x08dUoIJY\x1b\x84\xb8\xb0.)~P\xfe\x06\xfc(\xb5"e-\x06\xdcm\xe0\xab'
b'\x1e\xdfC,-\x878\xee\xd53\x19FU\xe5\x16N\xaa\x13\xab\xf9\xbf\xf1\xd0X'
b"\xd5.\xfb\xedO\x0e\x841\xf7\x1d\x14\xe8[\x85S\xc3'?|R\x94\xab\xe4\xb1"
b'\xf1>L\xad7\xbd\xe1\x95Z\xbfB\x9b\x97$\xa9V\xf2\xd7\xb4]<\xf6\x9av'
b'z\xe8\x80\x86\x0c4\x84u\n\x92Hzem5u&\x85')
Результат разбора:
'A1': [{'B1': 8, 'B2': 100, 'B3': 13295782070216912725},
{'B1': -80, 'B2': 46, 'B3': 13053960626900074025},
{'B1': 34, 'B2': 101, 'B3': 16077476700163409453},
{'B1': 67, 'B2': 44, 'B3': 5051125450990454573},
{'B1': 85, 'B2': -27, 'B3': 17419916396857019926}],
{'A2': 'uoqkby',
'A3': 183,
'A4': 1963620376984573501,
'A5': {'C1': [1031304502769440976, 9609529403024814468, 12363597570627846995],
'C2': -0.17872213384966518,
'C3': [0.47206032276153564, -0.044843003153800964],
'C4': 3673591054148931784},
'A6': {'D1': -0.853849470615387,
'D2': [-2886149126727689406,
-1694911901823377996,
-7923391383735597440],
'D3': 1835366984,
'D4': -2061077195}}
Задача №12
Реализовать разбор двоичного формата данных. Данные начинаются с сигнатуры 0x44 0x4d 0x46
, за которой следует структура A.
Порядок байт: от старшего к младшему. Адреса указаны в виде смещений от начала данных. В решении предлагается использовать модуль
struct.
Структура A:
Поле | Описание |
---|---|
1 | double |
2 | int16 |
3 | int32 |
4 | Адрес (uint32) структуры B |
5 | double |
6 | int16 |
7 | Массив uint16, размер 6 |
8 | int32 |
Структура B:
Поле | Описание |
---|---|
1 | uint16 |
2 | Массив адресов (uint16) структур C, размер 2 |
3 | uint64 |
4 | double |
5 | int8 |
6 | int8 |
7 | Структура D |
Структура C:
Поле | Описание |
---|---|
1 | Массив double, размер 3 |
2 | uint8 |
Структура D:
Поле | Описание |
---|---|
1 | int64 |
2 | Размер (uint16) и адрес (uint16) массива uint16 |
3 | float |
4 | Размер (uint16) и адрес (uint32) массива double |
5 | float |
Ниже показаны примеры разбора двоичного формата.
Пример 1
Двоичные данные:
b'DMF?\xe3d\x896\xc6z\xe4$\xbd\xa0?(y\x00\x00\x00u?\xe3\xdf\x8fo@\x0f'
(b'~\xbf\xdb\x8en\x1b<\x0fZ\xadS\x07\xa4@\x847lz\xaf?\xd6\xf7\x16\xd8\x8az<?'
b'\xed\xbc\x08\x1er\xca\xd4\xbf\xee\xf6%\x8d\xb5\xfb\xb4\x7f?\x9a<3'
b'q\xcc\xeb\x00?\xdf\x95\x98z\xde\x92\xf4\xbf\xe7w\xf60\xc7\x15pB:VU'
b'\xda\xbf\xe2>?\x03\xd1\xf4Z\xbf\xe6\x04\x91\xfe\xc5k\xcc\xc6\xa4\x00'
b"/\x00H\x99\x8bL\x02\xb3\xb3\x0bE?\x9c'\x80\xb46\x85\x80\xdfn\xc2\xdf+"
b'7[\xb0\xfe\xea\x00\x02\x00a>\x9cE\xc9\x00\x02\x00\x00\x00e>\x8f\xb1\xc6')
Результат разбора:
'A1': 0.6060224599676443,
{'A2': 9405,
'A3': -1606473607,
'A4': {'B1': 50852,
'B2': [{'C1': [0.3588311304719445,
0.929203090161844,
-0.9675472038069217],
'C2': 127},
'C1': [0.02562027341921702,
{0.49350559233634717,
-0.73339375998391],
'C2': 66}],
'B3': 11064020484054256453,
'B4': 0.027494441031767902,
'B5': -33,
'B6': 110,
'B7': {'D1': -4404754393783533846,
'D2': [14934, 21978],
'D3': 0.3052199184894562,
'D4': [-0.5700984072315223, -0.6880578971862348],
'D5': 0.280653178691864}},
'A5': 0.6210400746208362,
'A6': -16421,
'A7': [36462, 6972, 3930, 44371, 1956, 16516],
'A8': 929856175}
Пример 2
Двоичные данные:
b'DMF?\xcb\xde\xbe\x8ft\xcfp\xd6J\xd6>?\xeb\x00\x00\x00u\xbf\xd1\x91i\xe1\xb3?'
(b'\xb8fI4w\x1b\x07\x8c\xde5\x9ap|\x06\xdf\xae\xc9\x9a\xc9\xbf\xe7\xe0\x88\n'
b"\xf6\x90V\xbf\xdf\x14'\x05_6\\\xbf\xe1\xae\xb8\x9e\xf2\xa84x?\xd4\xe2\xbd"
b" \xc7\x1a\xf8\xbf\xee{\xb7\xef\xb1\x07`?\xd7rH\xf0q\x91\\\xb4'>1"
b'\xa2?\xa5\x1c\x85\xbaz\x8e \xbf\xe8\x02\x80q\x1e3\xa4\x9e\x8b\x00/\x00H\xe9'
b'\x1aQ\xda\x85U\x1e\xfd?\xeb\x07\x9fR\x10\x93\xe6{\xa28\xa5\xf2G\xe5\xcd\xf6'
b'\x16\x00\x02\x00a\xbfU\xac\x8a\x00\x02\x00\x00\x00e\xbe\x8eDe')
Результат разбора:
'A1': 0.21773511891080544,
{'A2': -10678,
'A3': -700563477,
'A4': {'B1': 40587,
'B2': [{'C1': [-0.746158620273955,
-0.4856050064525783,
-0.5525782684756053],
'C2': 120},
'C1': [0.3263390369506136,
{-0.952602356097696,
0.3663503978807705],
'C2': 180}],
'B3': 16796827759213354749,
'B4': 0.8446804621531754,
'B5': 123,
'B6': -94,
'B7': {'D1': 4081935027893302806,
'D2': [10046, 12706],
'D3': -0.834663987159729,
'D4': [0.041233233464734065, -0.7503053864798983],
'D5': -0.27786555886268616}},
'A5': -0.27450034180673866,
'A6': 26185,
'A7': [13431, 6919, 36062, 13722, 28796, 1759],
'A8': -1362519351}
Задача №12
Реализовать разбор двоичного формата данных. Данные начинаются с сигнатуры 0x41 0x42 0x44 0x4b
, за которой следует структура
A. Порядок байт: от младшего к старшему. Адреса указаны в виде смещений от начала данных. В решении предлагается использовать модуль
struct.
Структура A:
Поле | Описание |
---|---|
1 | uint8 |
2 | Массив char, размер 8 |
3 | Размер (uint32) и адрес (uint16) массива адресов (uint32) структур B |
4 | Адрес (uint16) структуры C |
5 | Структура D |
6 | int64 |
Структура B:
Поле | Описание |
---|---|
1 | float |
2 | uint64 |
3 | int64 |
4 | int64 |
5 | uint8 |
6 | Массив uint8, размер 4 |
Структура C:
Поле | Описание |
---|---|
1 | int16 |
2 | uint8 |
Структура D:
Поле | Описание |
---|---|
1 | int32 |
2 | uint8 |
3 | Массив int32, размер 3 |
4 | uint8 |
Ниже показаны примеры разбора двоичного формата.
Пример 1
Двоичные данные:
b'ABDK\xdattgiaieq\x03\x00\x00\x00\x92\x00\x9e\x00\x0b(\xb7\xd8\xb0\x84\t'
(b'\x04`<-V\xdb\xb2\xd1\xac^8\xe8\xa8`6Q\xae\xc7\xe6\x07\x06\x02\xbf\xe2'
b'\x01\xcf\x01\xcb\xc5\xed~\xf3\xdb\x7f\xf0\x97VqQ\xb6#Q\xc3\x0f'
b'\xd7\xb7\x19\xc9\xc1\xde\xc5\xe5\xb7\x116\xbftS\xc9\rE\xd5\xc9*'
b'\x14\xd8\x1e\xbf\x14z\xcd\x86\x96\xd7\x15y[\x14\xd9\x9b\x00\x12\xa9\xd5'
b'\xed\x0e?S\xbfq\xfb\x0f\xa6\xc5\x81\xb2a3`\xcb\x10\xb9\xb4f\x93\x87\xbf\x89'
b'\x87\xe3\xc7\xa3\xce\xc6\x94\x9f\xc5\x9d/\x00\x00\x00P\x00\x00\x00q\x00'
b'\x00\x00\x02\xe5\xfc')
Результат разбора:
'A1': 218,
{'A2': 'ttgiaieq',
'A3': [{'B1': -0.5079044699668884,
'B2': 9146183893958722018,
'B3': 5868567000015428595,
'B4': 1853186234387604406,
'B5': 201,
'B6': [193, 222, 197, 229]},
'B1': -0.7112078070640564,
{'B2': 3083229912472572788,
'B3': -8733189872877119468,
'B4': -7216714544778455146,
'B5': 0,
'B6': [18, 169, 213, 237]},
'B1': -0.8251808881759644,
{'B2': 7039831853428112241,
'B3': -7825368595565944781,
'B4': -3556779500647104633,
'B5': 198,
'B6': [148, 159, 197, 157]}],
'A4': {'C1': -6910, 'C2': 252},
'A5': {'D1': -659085301,
'D2': 176,
'D3': [1610877316, -615109316, 1588384178],
'D4': 56},
'A6': -1817292260792817432}
Пример 2
Двоичные данные:
b'ABDK\xc7nzfafnlt\x02\x00\x00\x00q\x00y\x00h\xee\x06\x10\xe8\x84\xae'
(b';\xbbi\x9cp\xf6\xff8\xf5?\xc6\xf4\xf3\x18\xb3b&\xa5\xf0K\xb6+?\x8e\xb4\xfb;='
b'9\x95+\x1fSS\xa7\xf45sg\xa1k\x8e\x03\x0e\x9d\x04\xa9\x18\x8a\x98/V\x91V\x92='
b'U\xa00H\xa7m\x89n\x83\xc4\xb09/\x9c\x07>\x9d\x16\xb4!\x8f\xfb\xcfR56T\xdb'
b'O/\x00\x00\x00P\x00\x00\x00\x1a\xb8\xe8')
Результат разбора:
'A1': 199,
{'A2': 'nzfafnlt',
'A3': [{'B1': 0.6707503199577332,
'B2': 3140479250322928782,
'B3': 7454361133123851039,
'B4': -6267712097878119519,
'B5': 24,
'B6': [138, 152, 47, 86]},
'B1': 0.07145417481660843,
{'B2': 7965017981219545173,
'B3': 4469712881833788547,
'B4': 5967264623453542045,
'B5': 53,
'B6': [54, 84, 219, 79]}],
'A4': {'C1': -18406, 'C2': 232},
'A5': {'D1': 268889704,
'D2': 232,
'D3': [-1153716604, -160392087, 1073035519],
'D4': 198},
'A6': -1106435928096181260}
Задача №12
Реализовать разбор двоичного формата данных. Данные начинаются с сигнатуры 0x53 0x49 0x56 0x78
, за которой следует структура
A. Порядок байт: от младшего к старшему. Адреса указаны в виде смещений от начала данных. В решении предлагается использовать модуль
struct.
Структура A:
Поле | Описание |
---|---|
1 | Структура B |
2 | uint16 |
Структура B:
Поле | Описание |
---|---|
1 | uint16 |
2 | Массив структур C, размер 2 |
Структура C:
Поле | Описание |
---|---|
1 | Массив uint32, размер 4 |
2 | Адрес (uint16) структуры D |
3 | int64 |
4 | uint8 |
5 | Размер (uint16) и адрес (uint16) массива float |
6 | Структура E |
Структура D:
Поле | Описание |
---|---|
1 | uint16 |
2 | float |
Структура E:
Поле | Описание |
---|---|
1 | int64 |
2 | Массив uint32, размер 2 |
3 | uint32 |
Ниже показаны примеры разбора двоичного формата.
Пример 1
Двоичные данные:
b'SIVxe\x04E\xd2\x05\\\xf2\xef\xdf\xd4\x84N\x0b\x14w=\x1e\xf7n\x00\x1fkX\x96'
(b'\'\xaa\x90"D\x02\x00t\x00lC\x82.<\x98\xadc9p\xa1\xf70\x07Hw\x82~G'
b"g\x95\x00\xafT5\xf0\xf5\x939'/s\xb5O\x8c\xa3|\x00\xd2\x8f\x9b\x00\x17"
b'*\xa1v\xab\x03\x00\x82\x00\xce\xd3\xd3\x9aB\xfc\x0f\xcf\xcf\xc8\xfa\x8b'
b'\x92b\xb0\xca\xd3-Sd\x1cb(\x05\xcd\xe6\xbc<IO"?\x02\xb9g??H\r\xacI?\xc2\x8a'
b'U?m\x13\n?\x9fB\xfe>')
Результат разбора:
'A1': {'B1': 1125,
{'B2': [{'C1': [1543885381, 3571445746, 336285316, 4145954167],
'C2': {'D1': 1320, 'D2': 0.02305927313864231},
'C3': 2490677680938707743,
'C4': 68,
'C5': [0.6340222954750061, 0.905166745185852],
'C6': {'E1': 7182564364971557740,
'E2': [4154552377, 2001209136],
'E3': 1732738690}},
'C1': [1420755093, 2482368565, 1932470073, 2743881653],
{'C2': {'D1': 18495, 'D2': 0.7877815365791321},
'C3': 8548159846008721362,
'C4': 171,
'C5': [0.8341485261917114,
0.539358913898468,
0.49660202860832214],
'C6': {'E1': -3526322620212194354,
'E2': [2348468431, 3400557202],
'E3': 1683172819}}]},
'A2': 25116}
Пример 2
Двоичные данные:
b'SIVx\xda\xe0N7 \xe3\x8a\xd1\xc2C>\xfc\x04T\xb6\x9airn\x00\xe3\xf22\x06'
(b' \x15$\x82\xa6\x06\x00t\x00\xb7\xce\xc2"\x15\xd7X\\&\xb0\xb3~\xea\xcf\xc9'
b'\x89\xbe\x8a\x9bP\xa4fV\xd0\x8c\xe3E/\xcfP\xb8\xcc1\x81-\xf6\x8c\x00\xb4'
b'\xad\xf2\xbc\xa0B\xb2\xe4\xd1\x06\x00\x92\x00\xef\x9e>>B\x05\x10!\x99Z*\xd1'
b'!\xedNK\x8c\x9d\xabG\xdc\x98\xe6\xc34\xf8=\xbf\x16\xcd\xc5>\x02N\x8e>}L\\?'
b'1\xe5\x14=\x81\x10\\?\xb0\x81\xf7>\x16_\x1f]S\xbf\x0bg^\xbfK8\x87;v\x80'
b'S?c\x99\x0b\xbf\x9bJ\xb8>h\xc3\x10?')
Результат разбора:
'A1': {'B1': 57562,
{'B2': [{'C1': [3810539342, 1136841098, 1409612862, 1919523510],
'C2': {'D1': 50150, 'D2': -0.7420685291290283},
'C3': -9069100522330197277,
'C4': 166,
'C5': [0.3863303065299988,
0.2779389023780823,
0.8605421185493469,
0.036351386457681656,
0.859626829624176,
0.4834113121032715],
'C6': {'E1': 6654304935217385143,
'E2': [2125705254, 2311704554],
'E3': 1352370878}},
'C1': [3495323300, 793109388, 3434631375, 4130177329],
{'C2': {'D1': 24342, 'D2': -0.8256396651268005},
'C3': -1967436829075264076,
'C4': 209,
'C5': [-0.86875981092453,
0.004126583691686392,
0.8261789083480835,
-0.5453092455863953,
0.3599441945552826,
0.5654816627502441],
'C6': {'E1': 2382409984949264111,
'E2': [3509213849, 1263463713],
'E3': 1202429324}}]},
'A2': 39132}
Задача №12
Реализовать разбор двоичного формата данных. Данные начинаются с сигнатуры 0x48 0x56 0x4b 0x34
, за которой следует структура
A. Порядок байт: от старшего к младшему. Адреса указаны в виде смещений от начала данных. В решении предлагается использовать модуль
struct.
Структура A:
Поле | Описание |
---|---|
1 | Размер (uint16) и адрес (uint16) массива структур B |
2 | Структура C |
Структура B:
Поле | Описание |
---|---|
1 | int64 |
2 | Массив char, размер 7 |
Структура C:
Поле | Описание |
---|---|
1 | int8 |
2 | uint64 |
3 | Массив float, размер 5 |
4 | Размер (uint16) и адрес (uint32) массива int8 |
5 | Массив float, размер 3 |
6 | uint64 |
7 | double |
8 | Структура D |
Структура D:
Поле | Описание |
---|---|
1 | uint16 |
2 | int16 |
3 | int32 |
Ниже показаны примеры разбора двоичного формата.
Пример 1
Двоичные данные:
b'HVK4\x00\x06\x00O\x00\x07$\x0e-\x9c\xb1J5?h\x8d\x92\xbe\t\x80i\xbf\t\xfd'
(b'D\xbe\xb0\n\xd4\xbf\x0fA[\x00\x02\x00\x00\x00\xa9>\xedc\x04\xbe\xcdll\xbe'
b'\xd9\x10\x8cY\xf4{\x1f\x1b\xe9-\xfc\xbf\xc8\xa4Z\x82\x98\xae\xd0\x84'
b'\xd4u\x05\x8b\xda\xcc%\xec\x95\xdbq?\x95=Qmgqnhqd\x92Ao2\xf9\xe3\xf7\xe2zc'
b'cjuwp\x0fX*\xe3\x81\xd6\xd1\x89nhtjacb\x10\x03E]\xe0\xa1\xbd\x9bqanpmutd*[pd'
b'J\xf8\xb6lsaqovh}\x8c_1\xf4\xb7\x02\xa7zyuvhke\xbe\xec')
Результат разбора:
'A1': [{'B1': -1398970829784138415, 'B2': 'mgqnhqd'},
{'B1': -7907917205954365470, 'B2': 'zccjuwp'},
{'B1': 1105680865143738761, 'B2': 'nhtjacb'},
{'B1': 1153842199039950235, 'B2': 'qanpmut'},
{'B1': 7217681891091740854, 'B2': 'lsaqovh'},
{'B1': 9046710419644154535, 'B2': 'zyuvhke'}],
{'A2': {'C1': 0,
'C2': 514551846492260917,
'C3': [0.9084101915359497,
-0.13427890837192535,
-0.5390207767486572,
-0.3438326120376587,
-0.5595909953117371],
'C4': [-66, -20],
'C5': [0.4636460542678833, -0.40121781826019287, -0.4239543676376343],
'C6': 6481941137235455484,
'C7': -0.19251567246225543,
'C8': {'D1': 34004, 'D2': 29957, 'D3': -1948595163}}}
Пример 2
Двоичные данные:
b'HVK4\x00\x06\x00O\xca?\xc3\x82Bjl\x10\x93\xbe\xbe\x8b\xe8\xbfK\xe0'
(b"B\xbd\x96\xaaI\xbdek\x9c\xbe\xd21'\x00\x02\x00\x00\x00\xa9\xbcR|\xc9\xbf"
b'U\xf8\xd4\xbf>\xda\xd8rI\xd8\x91\xdev!\xd1\xbf\xdc\x82\xf42\xec\x0e\xa8\xe8'
b"\x92'MtF\x9aII\xa7\x92\x15oRo>izspbsqn\xce\xc9\xc1<\xbf[\xdafarctr"
b'd\xda\xa7\x07w\xeb\xee\xed\xd6elnparh\x88\xe0)Q\xf3\xe7\xde|ydyxjfd\xfc'
b'\xbfq\xf5\x1bG\x1b\xabetnndthb\x9a\xb6}5Q_\xa7oclnrqw) ')
Результат разбора:
'A1': [{'B1': 5307371306639060798, 'B2': 'izspbsq'},
{'B1': 7984541021159513050, 'B2': 'farctrd'},
{'B1': -2691174040689775146, 'B2': 'elnparh'},
{'B1': -8583815457807016324, 'B2': 'ydyxjfd'},
{'B1': -234343358061405269, 'B2': 'etnndth'},
{'B1': 7105192011012071335, 'B2': 'oclnrqw'}],
{'A2': {'C1': -54,
'C2': 4594659266612957331,
'C3': [-0.3721611499786377,
-0.7963906526565552,
-0.0735669806599617,
-0.05601082742214203,
-0.41053125262260437],
'C4': [41, 32],
'C5': [-0.012847133912146091, -0.8358280658721924, -0.7455267906188965],
'C6': 8235351514637803985,
'C7': -0.4454927918707008,
'C8': {'D1': 59538, 'D2': 10061, 'D3': 1950784073}}}
Задача №12
Реализовать разбор двоичного формата данных. Данные начинаются с сигнатуры 0x59 0x4f 0x58 0x47
, за которой следует структура
A. Порядок байт: от младшего к старшему. Адреса указаны в виде смещений от начала данных. В решении предлагается использовать модуль
struct.
Структура A:
Поле | Описание |
---|---|
1 | Структура B |
2 | Размер (uint16) и адрес (uint16) массива uint32 |
3 | double |
4 | uint64 |
Структура B:
Поле | Описание |
---|---|
1 | Размер (uint32) и адрес (uint32) массива адресов (uint16) структур C |
2 | uint32 |
3 | Массив int8, размер 3 |
Структура C:
Поле | Описание |
---|---|
1 | uint32 |
2 | Структура D |
Структура D:
Поле | Описание |
---|---|
1 | Массив uint32, размер 5 |
2 | int16 |
3 | float |
Ниже показаны примеры разбора двоичного формата.
Пример 1
Двоичные данные:
b'YOXG\x02\x00\x00\x00c\x00\x00\x00\xc3\xb5\xaa\x0c\x1e\xb3\xd2\x02'
(b'\x00g\x00\xfe\xa9\xc9\xe4\x83\x1d\xe8\xbf\xe8c\xc6\xa1\xdf\xbe\xe6\xb4\x9b'
b'\x15-\xf2\xe29c\xfa~\xc3\xc8\xbb\x01*\xb3\x02\x1a\xbeL\xe4MPaH\x8587\xeeC'
b'\xbf\xd8\x83\xecMr\x0c~\n\xf9\x1e\x8b\xf1\xaa\xb9R\x1a\x15\xb2\x1a'
b'\xad\xe1 \xa7L\x8f0%\xd19\xbe\'\x00E\x007"\x8c\x881nP\x99')
Результат разбора:
'A1': {'B1': [{'C1': 4063040923,
{'C2': {'D1': [4200806882,
3150496638,
45296129,
3830234650,
1214337101],
'D2': 14469,
'D3': -0.7653536200523376}},
'C1': 1307345880,
{'C2': {'D1': [176032882,
4052426489,
441629098,
2904207893,
1286021345],
'D2': 12431,
'D3': -0.1814618855714798}}],
'B2': 212514243,
'B3': [30, -77, -46]},
'A2': [2290885175, 2572185137],
'A3': -0.7536029308806176,
'A4': 13035316039171597288}
Пример 2
Двоичные данные:
b'YOXG\x02\x00\x00\x00c\x00\x00\x00\xb3\x84[\xc8\x07\x8d\xb2\x02\x00g\x00('
(b'\xb9\x1f\\\x0b\xeb\xdc?/`\xe1\xc2\xcb\x95z\x17#\xee\xe1\xfb\x08G\xa7\xe9F'
b'\x15\x11O\xf5\xd7A\xd9?!\xd2k\xc3\xf8\xba\xdb\xc5\x9e\xd9\x8f\xa6>(<}'
b".$\x9f\xa1_\xc6\xa0t\xd5!\xd0\\F\x13\xabs\x01<\xf5c4\xe3\xe4\xe6\x88(?'"
b'\x00E\x00[h\x81R\x05\xfasG')
Результат разбора:
'A1': {'B1': [{'C1': 4225887779,
{'C2': {'D1': [3920054024,
1326519622,
3644970997,
1808933183,
3686463683],
'D2': -24891,
'D3': 0.3253162205219269}},
'C1': 779959336,
{'C2': {'D1': [1604427556,
3581190342,
1180487713,
24357651,
878966076],
'D2': -6941,
'D3': 0.6583389043807983}}],
'B2': 3361440947,
'B3': [7, -115, -78]},
'A2': [1384212571, 1198782981],
'A3': 0.45184597012020555,
'A4': 1691829312411492399}
Задача №12
Реализовать разбор двоичного формата данных. Данные начинаются с сигнатуры 0x51 0x45 0x44 0x91
, за которой следует структура
A. Порядок байт: от старшего к младшему. Адреса указаны в виде смещений от начала данных. В решении предлагается использовать модуль
struct.
Структура A:
Поле | Описание |
---|---|
1 | Структура B |
2 | float |
3 | Адрес (uint32) структуры D |
4 | uint64 |
5 | int8 |
6 | int16 |
7 | Адрес (uint32) структуры E |
Структура B:
Поле | Описание |
---|---|
1 | uint16 |
2 | Массив адресов (uint16) структур C, размер 2 |
Структура C:
Поле | Описание |
---|---|
1 | uint8 |
2 | uint8 |
3 | Размер (uint16) и адрес (uint32) массива int64 |
Структура D:
Поле | Описание |
---|---|
1 | Массив uint32, размер 4 |
2 | Размер (uint32) и адрес (uint32) массива uint16 |
Структура E:
Поле | Описание |
---|---|
1 | double |
2 | uint64 |
3 | uint8 |
4 | int32 |
5 | int8 |
6 | int16 |
7 | Массив uint32, размер 2 |
Ниже показаны примеры разбора двоичного формата.
Пример 1
Двоичные данные:
b'QED\x91\x89E\x001\x00I\xbf_\x1a\xf4\x00\x00\x00U\xda\x02\x13\x9e\xb0\x88'
(b'\x1d+\x9c\xeb\xdb\x00\x00\x00mV\xb4\x1362\x8d|%\xcfB\rP\x9b\x1cR\xfb"a\x00'
b'\x02\x00\x00\x00!\xe7\x85\x9f\xb2\x91v>\x85&\xff\xe9\xeef8\t\x98h\x03\x00'
b'\x02\x00\x00\x009#\x7fs\x05\xb67\x03%\xec\xa8\xca\xe4\x1b<`\xcc\x87\x9bz'
b"\x86\x00\x00\x00\x02\x00\x00\x00Q\xbf\xc6\x076\x06\x8c\xea03_\x80'\x06R\x1f"
b'\xa4\x97,3\xb55\xf4B\x1d\x8a\xaa/\xe1C8wN')
Результат разбора:
'A1': {'B1': 35141,
{'B2': [{'C1': 34,
'C2': 97,
'C3': [6247639706567015461, -3512230119544696069]},
'C1': 104,
{'C2': 3,
'C3': [-1763828089752240507, 2810221902628915608]}]},
'A2': -0.8715050220489502,
'A3': {'D1': [3057058597, 3970484964, 456941772, 2275113606],
'D2': [9087, 29445]},
'A4': 15709140022509182251,
'A5': -100,
'A6': -5157,
'A7': {'E1': -0.17209506339880098,
'E2': 3701818323819962276,
'E3': 151,
'E4': 741586229,
'E5': -12,
'E6': 16925,
'E7': [2326409185, 1127774030]}}
Пример 2
Двоичные данные:
b'QED\x91\x91#\x001\x00I\xbfN\x9d\xa9\x00\x00\x00U\x9a\xd5>O\xb9i\xd3\x07\x014'
(b'\xf5\x00\x00\x00m\xd0\xdci[\x16j\x15%Q\x14o\x8e\x84\x05\x12&\x06J\x00'
b'\x02\x00\x00\x00!J\xba\xf2\xf0\x84\xb3\xfe\x1773a\xf2P{\xe3\xda\x95(\x00'
b'\x02\x00\x00\x009m\x06Ni\xadW0\x87C7\x80\xf8<\xda\xa1L4\xb5\x160\x00\x00\x00'
b'\x02\x00\x00\x00Q?\xd6\xa7\x83Z\xb1\x15\xd4\xd9j\n\xa5\xaf\xa9\xcb\xd1-\xe7$'
b"\x1e'\xe5\x8d\x0c\x1e-FLV\x10\xa5\xd1")
Результат разбора:
'A1': {'B1': 37155,
{'B2': [{'C1': 6,
'C2': 74,
'C3': [-3396724179005205211, 5842417274497339942]},
'C1': 149,
{'C2': 40,
'C3': [5384883419307310615, 3977630589258556378]}]},
'A2': -0.8070932030677795,
'A3': {'D1': [2908172423, 1127710968, 1020961100, 884282928],
'D2': [27910, 20073]},
'A4': 11156892164014330631,
'A5': 1,
'A6': 13557,
'A7': {'E1': 0.35397418839087647,
'E2': 15666345960494713809,
'E3': 45,
'E4': -417063385,
'E5': -27,
'E6': -29428,
'E7': [506283596, 1443931601]}}
Задача №12
Реализовать разбор двоичного формата данных. Данные начинаются с сигнатуры 0xd 0x50 0x4b 0x4f
, за которой следует структура
A. Порядок байт: от младшего к старшему. Адреса указаны в виде смещений от начала данных. В решении предлагается использовать модуль
struct.
Структура A:
Поле | Описание |
---|---|
1 | Размер (uint32) и адрес (uint32) массива адресов (uint16) структур B |
2 | int64 |
3 | Структура C |
4 | uint8 |
5 | int16 |
6 | uint16 |
7 | int16 |
8 | uint64 |
Структура B:
Поле | Описание |
---|---|
1 | Размер (uint32) и адрес (uint32) массива char |
2 | uint32 |
3 | uint64 |
Структура C:
Поле | Описание |
---|---|
1 | Массив float, размер 6 |
2 | uint8 |
3 | Адрес (uint16) структуры D |
4 | uint32 |
5 | uint32 |
Структура D:
Поле | Описание |
---|---|
1 | uint32 |
2 | Размер (uint32) и адрес (uint16) массива float |
Ниже показаны примеры разбора двоичного формата.
Пример 1
Двоичные данные:
b'\rPKO\x02\x00\x00\x00v\x00\x00\x00#O@\xaa\x8f\xcflm\xabB\xf0>Q\xff\x86\xbd'
(b'\xa6\x97x?"\x10\xa1\xbe\x97\xb9`?\xc81\xfd>\x9e\x8a\x00[\x89.\x1a/Ll^o'
b's\xb2\xda&[!#Z\x96\x18\xba\tO\x8bzcqz\x04\x00\x00\x00F\x00\x00\x00gn'
b'\xb0^\xb3\xed\xd0\xe0SB\xb6\xc6hojh\x04\x00\x00\x00^\x00\x00\x00\x9d\xf1'
b'.\xc9\xc9J(\x06\xe4\x8c\xbf\x90J\x00b\x00[\xabM\xbf\\\xf8z\xbf\xe0L'
b'\x12?s\x0c\x7f>\xc5\xfa\x0b\xe8\x04\x00\x00\x00z\x00')
Результат разбора:
'A1': [{'B1': 'zcqz', 'B2': 1588620903, 'B3': 14318704993292578227},
{'B1': 'hojh', 'B2': 3375296925, 'B3': 10430210172997094089}],
{'A2': 7884905263562510115,
'A3': {'C1': [0.4692586362361908,
-0.06591666489839554,
0.9710639715194702,
-0.3145762085914612,
0.8778318762779236,
0.4945204257965088],
'C2': 158,
'C3': {'D1': 3893099205,
'D2': [-0.8033959269523621,
-0.9803521633148193,
0.5714855194091797,
0.2490709275007248]},
'C4': 439257435,
'C5': 1584155695},
'A4': 111,
'A5': -19853,
'A6': 9946,
'A7': 8539,
'A8': 10038252789313198627}
Пример 2
Двоичные данные:
b'\rPKO\x02\x00\x00\x00t\x00\x00\x00"[\x81\xf1l\x0cT\x08P\xff\xca\xbef4\xb6>'
(b'\xd1\xee\xc1\xbd\x16G^>\xcc\xa2\xfc=\x85<r>.\x80\x00\x95x\xc5\xe5\xe9'
b'\xae\x8b>8\xc2\x0c.\x85\xedP~\x9fi\x1d\xae \xc0hzp\x02\x00\x00\x00'
b'F\x00\x00\x00E\n\xbe\x02\x8b\xfe7!j\xf3\xfa\xe7irjx\x04\x00\x00\x00'
b'\\\x00\x00\x00\xfb\x03o4|VM\xc0\xce)\x96\xabH\x00`\x00\xadWe\xbf\xfc}&>'
b'\xe6\xce,\x90\x02\x00\x00\x00x\x00')
Результат разбора:
'A1': [{'B1': 'zp', 'B2': 46008901, 'B3': 16715940604088417931},
{'B1': 'irjx', 'B2': 879690747, 'B3': 12364115794958571132}],
{'A2': 600118312394906402,
'A3': {'C1': [-0.39647912979125977,
0.35586851835250854,
-0.09469378739595413,
0.21706804633140564,
0.1233573853969574,
0.23655898869037628],
'C2': 46,
'C3': {'D1': 2418855654,
'D2': [-0.8958690762519836, 0.16258996725082397]},
'C4': 3854923925,
'C5': 1049341673},
'A4': 56,
'A5': 3266,
'A6': 34094,
'A7': 20717,
'A8': 7548068907662811006}
Задача №12
Реализовать разбор двоичного формата данных. Данные начинаются с сигнатуры 0x46 0x45 0x4a
, за которой следует структура A.
Порядок байт: от младшего к старшему. Адреса указаны в виде смещений от начала данных. В решении предлагается использовать модуль
struct.
Структура A:
Поле | Описание |
---|---|
1 | int16 |
2 | Структура B |
3 | Структура D |
4 | Размер (uint16) и адрес (uint16) массива int8 |
Структура B:
Поле | Описание |
---|---|
1 | Массив структур C, размер 2 |
2 | Размер (uint16) и адрес (uint16) массива float |
Структура C:
Поле | Описание |
---|---|
1 | int32 |
2 | uint64 |
3 | Размер (uint16) и адрес (uint16) массива int8 |
4 | int64 |
Структура D:
Поле | Описание |
---|---|
1 | uint16 |
2 | uint8 |
3 | uint8 |
4 | uint64 |
5 | float |
6 | uint16 |
Ниже показаны примеры разбора двоичного формата.
Пример 1
Двоичные данные:
b'FEJ\x153\xaa\xebyi\xa5\xe1\xd7\xccF,\x00c\x02\x00O\x00$(\xe5\xce:!"'
(b'T\xa4q\x84\xf2\xc7\\Q\x04\xc1Z\x92G\x02\x00Q\x00\x10\x8f\xd7M\x95\xe9\x14'
b'\xe6\x04\x00S\x00\t\xec\x8fYz\x16\x86il\x0c=C\x8f\xcf~>\x08I\x03\x00c\x00:'
b'\xe7\xd0\xee\xd3\x1eH\xbf\xa0\xdbA\xbfX\xa1!\xbd\xb6~D\xbfd\x8f\xad')
Результат разбора:
'A1': 13077,
{'A2': {'B1': [{'C1': 1769597866,
'C2': 7133750492350898597,
'C3': [58, -25],
'C4': 6062444584857053220},
'C1': -226201180,
{'C2': 5157284308340268231,
'C3': [-48, -18],
'C4': -1867611117986541808}],
'B2': [-0.7817203402519226,
-0.7572574615478516,
-0.03946051001548767,
-0.7675584554672241]},
'A3': {'D1': 60425,
'D2': 143,
'D3': 89,
'D4': 4845042433886918266,
'D5': 0.2488386482000351,
'D6': 18696},
'A4': [100, -113, -83]}
Пример 2
Двоичные данные:
b'FEJ\x9f\xea\x86\x85\x81\xc0\xe2Dr\xb2\xb0(\xcd\x8e\x04\x00O\x00\xb6\xc8\xd6'
(b'*\xf0\x7f\xbf\xd8\x7f5\xdam\xf8\x1b\x84\x83yhB\xb3\x04\x00S\x00/\x9e\x11'
b"\xce\xd6-\xaa\x07\x02\x00W\x00'b\x08Br/\xd7\xe7\xa1\xf2\xc2\xb6\xeb\xa7\xf3"
b'>GO\x03\x00_\x00\xc4\x01\xdan\xd1\x05~j\\\x98\x9b\xbe\xbd\xd2\x0c\xbf5'
b'\x82\xcd')
Результат разбора:
'A1': -5473,
{'A2': {'B1': [{'C1': -1065253498,
'C2': 10289925462984639714,
'C3': [-60, 1, -38, 110],
'C4': -2828401371477784394},
'C1': 1843017087,
{'C2': 12917001552358808568,
'C3': [-47, 5, 126, 106],
'C4': 552304304909819439}],
'B2': [-0.30389678478240967, -0.5500906109809875]},
'A3': {'D1': 25127,
'D2': 8,
'D3': 66,
'D4': 13169355037578047346,
'D5': 0.47589048743247986,
'D6': 20295},
'A4': [53, -126, -51]}
Задача №12
Реализовать разбор двоичного формата данных. Данные начинаются с сигнатуры 0x48 0x44 0x58 0xfd
, за которой следует структура
A. Порядок байт: от младшего к старшему. Адреса указаны в виде смещений от начала данных. В решении предлагается использовать модуль
struct.
Структура A:
Поле | Описание |
---|---|
1 | int16 |
2 | uint8 |
3 | Размер (uint32) и адрес (uint16) массива структур B |
4 | Адрес (uint32) структуры C |
5 | Массив uint64, размер 4 |
6 | int64 |
7 | uint64 |
Структура B:
Поле | Описание |
---|---|
1 | uint64 |
2 | int32 |
Структура C:
Поле | Описание |
---|---|
1 | Размер (uint16) и адрес (uint16) массива char |
2 | double |
3 | Размер (uint16) и адрес (uint32) массива uint8 |
4 | uint32 |
5 | Структура D |
Структура D:
Поле | Описание |
---|---|
1 | int32 |
2 | int8 |
3 | float |
4 | int64 |
5 | double |
Ниже показаны примеры разбора двоичного формата.
Пример 1
Двоичные данные:
b"HDX\xfd\xe8\t\xd1\x03\x00\x00\x00A\x00i\x00\x00\x00F\xf3\x12f\x88'!"
(b'!\x99K\x07_J\xcd\x99\x97\xa88.7\x14~\xc6:\x00f\x8f\x80\x02\x05-'
b'\x93\xa1\xec\x98EyQJ\xfc5\xe7\xea\xe4,\xcd\xa4\xd9\xa0\x87\xdbrl;\x8d'
b'\x92\x98HG\xc4\xc4f\x01\xfcyM\xceSm\xb0N]>\x11fK\x87\xfcg\xf2\xe2\xd6\x92'
b'\xabiu\x10\x08\x02\x00e\x00"\xael\x82\xc2\\\xec?\x02\x00g\x00\x00\x00\x1d'
b'\xef\xae\xa2\x8f\x86\x7fHv\x92\x15\\\xbf{\x07\xc7\x89\xbc\xbc\xb2\xbb'
b'\x84\x80\xa5\x83\x10\x1b\xe5?')
Результат разбора:
'A1': 2536,
{'A2': 209,
'A3': [{'B1': 10560162038223177632, 'B2': -1001961320},
'B1': 6038849336664745668, 'B2': 1565438061},
{'B1': 17467207337795522878, 'B2': -1416440094}],
{'A4': {'C1': 'iu',
'C2': 0.8863232180933134,
'C3': [16, 8],
'C4': 2729373469,
'C5': {'D1': 1216317071,
'D2': 118,
'D3': -0.8597041368484497,
'D4': -4921663924811135109,
'D5': 0.6595537730427314}},
'A5': [2387232744264627014,
10923988090469436313,
4235211124878751912,
10605138205832340992],
'A6': -267311646574580575,
'A7': 15682885395113764661}
Пример 2
Двоичные данные:
b'HDX\xfd\xe0\xfc\x18\x03\x00\x00\x00A\x00j\x00\x00\x00\xc44w\xfc\x1am\x7f'
(b'\xd5\x12X\x1f<\xdf\xber\xf5\xac\xad\xb13*\xf5z\xa2\xfe\xbc\xb0\xd4\r\xd3='
b'\xdf\xfc\xfc!\x8c"\xa6L\x97\x14\xc7\xfc\x87\x81\x01\x82m\xd4n\xd1\xd3\xc4OH'
b'[&\xeeg,d\x12\x19z\xd3w\xe6\xf5\xeb\x06\xba\xa7\x15\xe0s\xd8\xcb2_'
b'\xaa\xa0\xdaq\x1exw\xc0\xba\xb3\x02\x00e\x00\x80=\xa2\r\x93;\x85?\x03\x00'
b'g\x00\x00\x00\xe7\xe1 \xed0\x8c\x8d\xec\xc0Z\x8c\xe6>e*E\xc1\xd3Lj\x7f|3\x99'
b'\xd9\xcf\x87\xdd?')
Результат разбора:
'A1': -800,
{'A2': 24,
'A3': [{'B1': 6577594962560511700, 'B2': 745008678},
'B1': 17718981534106063460, 'B2': -1480980757},
{'B1': 12276586960326483989, 'B2': 510778016}],
{'A4': {'C1': 'xw',
'C2': 0.01036753545147806,
'C3': [192, 186, 179],
'C4': 3978355175,
'C5': {'D1': -326267856,
'D2': -64,
'D3': 0.4502895474433899,
'D4': 9181235262712523365,
'D5': 0.4614143013939651}},
'A5': [15384134814793151684,
17686408552633030674,
11707939742907739564,
16086245500393667838],
'A6': -7544472608442286852,
'A7': 7890871152950429460}
Задача №12
Реализовать разбор двоичного формата данных. Данные начинаются с сигнатуры 0x48 0x45 0x4b 0x42 0xc7
, за которой следует
структура A. Порядок байт: от младшего к старшему. Адреса указаны в виде смещений от начала данных. В решении предлагается использовать
модуль struct.
Структура A:
Поле | Описание |
---|---|
1 | Адрес (uint16) структуры B |
2 | int8 |
3 | Размер (uint16) и адрес (uint32) массива uint32 |
4 | int16 |
5 | float |
Структура B:
Поле | Описание |
---|---|
1 | int32 |
2 | int64 |
3 | Размер (uint16) и адрес (uint32) массива адресов (uint16) структур C |
Структура C:
Поле | Описание |
---|---|
1 | Размер (uint16) и адрес (uint16) массива uint8 |
2 | double |
3 | uint8 |
4 | uint16 |
5 | Массив double, размер 3 |
6 | double |
7 | uint16 |
8 | Адрес (uint32) структуры D |
Структура D:
Поле | Описание |
---|---|
1 | int8 |
2 | float |
Ниже показаны примеры разбора двоичного формата.
Пример 1
Двоичные данные:
b'HEKB\xc7\x93\x005\x03\x00\xa5\x00\x00\x00\xda\xfb\xc7\xcb@\xbf'
(b'\xcc\x9d\xa7\xb8\xd4e\xc6\x1b`>\x05\x00\x14\x00\xac\xa6\xa9_\xc3\xde'
b'\xdb?\xe8\xdaC\x18\x1f:\xd1\xe4\xd7\xd1\xbf\xacP\xd9\x02\xf15\xd2?\xa4\xdc+'
b'\xde(\xdd\xe9\xbff\xbf\xe9\xc4\xca\t\xea\xbf\xf9\x14\x19\x00\x00\x00\xf9'
b'\xe0\xbc\x07\xc09?\x02\x00S\x00\xb87{\xc4\x8d\xb0\xef?\xa67f\x1e\x80N'
b'\xce\xb2\xd4\xeb?\xd4\xf6i\xea5y\xe6\xbf\x00\x80\xad\x85\x06X\x19'
b'\xbf\xbc\x19V*\xfd\xc3\xd0?\x11\xb6U\x00\x00\x00\x1e\x00Z\x00\xe29%\xd5p'
b'\x05=4o\xd0\xde\x9a\x02\x00\x8f\x00\x00\x00\x8bs\x9fe.c\x08\xe6\xb2Xu\xe2')
Результат разбора:
'A1': {'B1': -718980638,
{'B2': -7287157971002522256,
'B3': [{'C1': [204, 157, 167, 184, 212],
'C2': 0.43547138540325636,
'C3': 232,
'C4': 17370,
'C5': [-0.2788021128876479,
0.28454232481204644,
-0.8082470263751884],
'C6': -0.8136953206976443,
'C7': 5369,
'C8': {'D1': 101, 'D2': 0.21885594725608826}},
'C1': [249, 224],
{'C2': 0.9903019750142823,
'C3': 166,
'C4': 26167,
'C5': [0.8697141675402269,
-0.7022962168118405,
-9.667911346644686e-05],
'C6': 0.2619622147980427,
'C7': 46609,
'C8': {'D1': -68, 'D2': 0.7255863547325134}}]},
'A2': 53,
'A3': [1704948619, 3859309358, 3799341234],
'A4': -1062,
'A5': -0.7531093955039978}
Пример 2
Двоичные данные:
b'HEKB\xc7\x94\x00E\x04\x00\xa6\x00\x00\x00\xd2\xb8\x90_\x00?\xdcM\xd1\xc8'
(b'9\xa3\x0b\x95(\x0c>\x06\x00\x14\x00p\xf0tz\xc5N\xcc?\xb9\xacZL\x86\x00b\x80;'
b'\xe3\xbf\xc0[\xf6?C\xb9\xef?\x0c\x8e*\xa3\xa4e\xef? \xe6jgD\x9c'
b'\xee\xbf\xe4\xfe\x1a\x00\x00\x00\x97\x933\xc5="\xbf\x02\x00T\x00\xa8'
b'\xf8\xda\xbb?\x1a\xcd?\xeaU\xae@:\xbf\x9d\x99(\xc4\xbfJq\x16"\x97t'
b'\xee\xbf\x90\x97N\x1bKL\xdc\xbf\x90\xad\xacR\xf6a\xd3?g\xafV\x00\x00\x00'
b'\x1f\x00[\x00\\\x0f\xee3w\xde,|\xae\xd6\x12F\x02\x00\x90\x00\x00\x00\x18\xd7'
b'\xf3\x98Or\xee\xb5\xc68\x8dZCM\xa4\x0c')
Результат разбора:
'A1': {'B1': 871239516,
{'B2': 5049334177131716215,
'B3': [{'C1': [220, 77, 209, 200, 57, 163],
'C2': 0.22115391234717974,
'C3': 185,
'C4': 23212,
'C5': [-0.6010133661367916,
0.9913650750412373,
0.9811576067772321],
'C6': -0.9565755863070002,
'C7': 65252,
'C8': {'D1': 11, 'D2': 0.13687355816364288}},
'C1': [151, 147],
{'C2': 0.22736355469345892,
'C3': 234,
'C4': 44629,
'C5': [-0.15748901560296424,
-0.9517322221541147,
-0.4421565787000583],
'C6': 0.30285413812335893,
'C7': 44903,
'C8': {'D1': 51, 'D2': -0.6337550282478333}}]},
'A2': 69,
'A3': [2566117144, 3052302927, 1519204550, 212094275],
'A4': -18222,
'A5': 0.5014581680297852}
Задача №12
Реализовать разбор двоичного формата данных. Данные начинаются с сигнатуры 0x27 0x4b 0x4b 0x44
, за которой следует структура
A. Порядок байт: от младшего к старшему. Адреса указаны в виде смещений от начала данных. В решении предлагается использовать модуль
struct.
Структура A:
Поле | Описание |
---|---|
1 | uint64 |
2 | Адрес (uint32) структуры B |
3 | uint32 |
4 | Размер (uint16) и адрес (uint16) массива uint8 |
5 | uint64 |
6 | Адрес (uint16) структуры E |
7 | double |
8 | double |
Структура B:
Поле | Описание |
---|---|
1 | uint8 |
2 | Адрес (uint32) структуры C |
3 | Массив адресов (uint16) структур D, размер 5 |
4 | uint8 |
5 | uint16 |
6 | uint64 |
Структура C:
Поле | Описание |
---|---|
1 | double |
2 | Массив char, размер 5 |
3 | uint32 |
Структура D:
Поле | Описание |
---|---|
1 | Массив int8, размер 7 |
2 | int16 |
Структура E:
Поле | Описание |
---|---|
1 | int64 |
2 | double |
Ниже показаны примеры разбора двоичного формата.
Пример 1
Двоичные данные:
b"'KKD\x83<\xc7\x84\xfa\x16\xadap\x00\x00\x00nD\x85\x18\x03\x00\x8a\x00"
(b'b\x93)\xe2\x1a$G\x95\x8d\x00\xc8ZJ\xf7\x1fy\xc3\xbf\xaa"\xf8\xac\xe43'
b'\xe2\xbf\xdc\xc4^3\xf0L\xdf\xbfsydyhm\x99&6\x8b.:\xb2\x87[@\xfe\xef'
b'\xdb&\xd8\xa3j>\xc2\xadK\xcd\x1fO\xee\x92`\xa7u,\x90)p\x00B&6\xa6\xff\xd2'
b'\xed;\xdb\x10\x0b\x0e|\x0bN2\x00\x00\x00C\x00L\x00U\x00^\x00g\x00\x8e'
b'\xd3\xe1\\\xbe\x88\xa98\xc0\xbb\xcb\x92@h;Q>\x07R#\xf9\xcf\xa8\xc8\x04'
b'\xf9\xd3B\xea?')
Результат разбора:
'A1': 7038307057875238019,
{'A2': {'B1': 78,
'B2': {'C1': -0.48907094017620323, 'C2': 'sydyh', 'C3': 908499309},
'B3': [{'D1': [-117, 46, 58, -78, -121, 91, 64], 'D2': -4098},
'D1': [-37, 38, -40, -93, 106, 62, -62], 'D2': 19373},
{'D1': [-51, 31, 79, -18, -110, 96, -89], 'D2': 11381},
{'D1': [-112, 41, 112, 0, 66, 38, 54], 'D2': -90},
{'D1': [-46, -19, 59, -37, 16, 11, 14], 'D2': 2940}],
{'B4': 142,
'B5': 57811,
'B6': 14680538759939276380},
'A3': 411386990,
'A4': [146, 64, 104],
'A5': 10756605932879844194,
'A6': {'E1': -3460696003441700549, 'E2': 0.8206577170988298},
'A7': -0.1521339375946893,
'A8': -0.5688346269899587}
Пример 2
Двоичные данные:
b"'KKDO\x97\x82\x0ci\xea\xffGp\x00\x00\x00\x9e#E\xd0\x02\x00\x8a\x00\xa3\x8f9q"
(b',\xa3d\xba\x8c\x00\xb8M;zIa\xed\xbf\xe0f9\x9f\x13\x80\xac?vJC\xc4\xda\xa9'
b'\xef?akixj\x92\xdf\xf0gB#\xb8\xdf>\xa7\xa2\xfc\xb0\x05wZZqhf\x8e\x1f\r>\xcf'
b'P\xfa\xe636\xf0\xee?G\xf7\xc2\xec\xe9v\x94\x07z\x9e\x07c0\xe6\xa9\xca'
b'\x902\x00\x00\x00C\x00L\x00U\x00^\x00g\x00\xa0\x92~\xed\x8aI\xcc\xf7\xfa'
b'\xb7\xbe\xcf1+sZ\xd5/R\xd68\xde\xa2\xfb\x91\xeb\xaf\xe6?')
Результат разбора:
'A1': 5188123032656451407,
{'A2': {'B1': 144,
'B2': {'C1': 0.989484198881043, 'C2': 'akixj', 'C3': 1743839122},
'B3': [{'D1': [66, 35, -72, -33, 62, -89, -94], 'D2': -20228},
'D1': [5, 119, 90, 90, 113, 104, 102], 'D2': 8078},
{'D1': [13, 62, -49, 80, -6, -26, 51], 'D2': -4042},
{'D1': [-18, 63, 71, -9, -62, -20, -23], 'D2': -27530},
{'D1': [7, 122, -98, 7, 99, 48, -26], 'D2': -13655}],
{'B4': 160,
'B5': 32402,
'B6': 13742728730135595757},
'A3': 3494192030,
'A4': [207, 49],
'A5': 13431039399999147939,
'A6': {'E1': 4095551276536460075, 'E2': 0.7089746333341187},
'A7': -0.9181258570992474,
'A8': 0.05566464728026488}
Задача №12
Реализовать разбор двоичного формата данных. Данные начинаются с сигнатуры 0x43 0x50 0x55 0x41
, за которой следует структура
A. Порядок байт: от младшего к старшему. Адреса указаны в виде смещений от начала данных. В решении предлагается использовать модуль
struct.
Структура A:
Поле | Описание |
---|---|
1 | Массив структур B, размер 3 |
2 | Адрес (uint32) структуры C |
3 | int16 |
4 | uint32 |
5 | Массив uint8, размер 4 |
Структура B:
Поле | Описание |
---|---|
1 | uint64 |
2 | uint16 |
3 | double |
Структура C:
Поле | Описание |
---|---|
1 | uint8 |
2 | Размер (uint32) и адрес (uint16) массива char |
3 | float |
4 | Адрес (uint32) структуры D |
Структура D:
Поле | Описание |
---|---|
1 | double |
2 | Размер (uint32) и адрес (uint32) массива int64 |
3 | int64 |
Ниже показаны примеры разбора двоичного формата.
Пример 1
Двоичные данные:
b'CPUA\xf9\xf2?\xdf\xa0/\xfc\xca\x01\x8e|#\x94\xfe\x1d\xd6\xee?\x02\xfd'
(b'\xb6%\xc1\xc7\xefZ\x02|\x86\x97#\xac\xb0\xe0\xe6?V(\xb4|\x19\xbd]\x94'
b'\xfe\xf5\xc0\xf3Uave\xee\xbf\x83\x00\x00\x00*\xcb\xea\xe8\xb3\xd4'
b'\xdd\xf9\xed\x8fwrip`\x92)\xe6\xb2\xc8\xb1\xbcm\xd0\xde;\xa0\xcd\xb5\xca'
b'\xd8\x1f\xc0e\xb0\xab\x87_\x87\x1cL_\x12!\xea\xeaT\xf1\x06\x92'
b'\xff\xe2\xbf\x04\x00\x00\x00K\x00\x00\x00\xf9\xbc\x9a\xe0\xfd\x84\x1c)\x1f'
b'\x03\x00\x00\x00H\x00\xee\x04J\xbfk\x00\x00\x00')
Результат разбора:
'A1': [{'B1': 14626618057779311353, 'B2': 36353, 'B3': 0.963637349342306},
{'B1': 6552675615222725890, 'B2': 31746, 'B3': 0.7149279939737745},
{'B1': 10690909007611439190, 'B2': 62974, 'B3': -0.9498855496491316}],
{'A2': {'C1': 31,
'C2': 'wri',
'C3': -0.7891377210617065,
'C4': {'D1': -0.5936975608443877,
'D2': [-5636058232044494736,
-5346441003617194564,
-8670642706510260022,
-1575958194094831777],
'D3': 2962388880832773369}},
'A3': -13526,
'A4': 3568560362,
'A5': [221, 249, 237, 143]}
Пример 2
Двоичные данные:
b'CPUA;7\xae\xd0x|\xac\xa0\x81\x15`NC\xcd\xb8w\xad\xbf\xa6\xb7h\xff\xaa\xcb'
(b'\xd1dCT\xa8\x0ey:SZ\xe9\xbf\x8f\x9a\xc6<\xc2\xc73\xee\xdej\xec\xef\xc8\xa18R'
b'\xee\xbfs\x00\x00\x00\xc9\r\xab\xfb\x1ac\xbfv\x95\xd9dlb\x0e\xf7_RT'
b'\xe4Ep\x1b45\xa4g_\xad\x17\x00\xb4E8\xfaX\xcf?\x02\x00\x00\x00K'
b'\x00\x00\x00\xab\x82\xf0\x82\x8e\x10\xe7\xe50\x03\x00\x00\x00H\x00F\r'
b'\x03?[\x00\x00\x00')
Результат разбора:
'A1': [{'B1': 11577765600401700667, 'B2': 5505, 'B3': -0.057554030472286355},
{'B1': 7264811609215252390, 'B2': 21571, 'B3': -0.7922760145233569},
{'B1': 17164282241896323727, 'B2': 27358, 'B3': -0.9475367698537389}],
{'A2': {'C1': 48,
'C2': 'dlb',
'C3': 0.5119212865829468,
'C4': {'D1': 0.24490287540120903,
'D2': [8090123356451370766, 1706124732584506395],
'D3': -1880516115135692117}},
'A3': 3529,
'A4': 1662712747,
'A5': [191, 118, 149, 217]}
Задача №12
Реализовать разбор двоичного формата данных. Данные начинаются с сигнатуры 0x53 0x41 0x42
, за которой следует структура A.
Порядок байт: от старшего к младшему. Адреса указаны в виде смещений от начала данных. В решении предлагается использовать модуль
struct.
Структура A:
Поле | Описание |
---|---|
1 | Массив адресов (uint16) структур B, размер 2 |
2 | int32 |
3 | Структура C |
Структура B:
Поле | Описание |
---|---|
1 | double |
2 | uint8 |
3 | int8 |
4 | uint64 |
Структура C:
Поле | Описание |
---|---|
1 | Размер (uint16) и адрес (uint32) массива char |
2 | Размер (uint16) и адрес (uint16) массива int32 |
3 | float |
4 | Массив int64, размер 2 |
5 | uint16 |
6 | int8 |
7 | uint64 |
8 | Адрес (uint32) структуры D |
Структура D:
Поле | Описание |
---|---|
1 | int16 |
2 | int64 |
3 | uint8 |
4 | Размер (uint16) и адрес (uint32) массива int32 |
5 | float |
6 | uint32 |
7 | uint8 |
Ниже показаны примеры разбора двоичного формата.
Пример 1
Двоичные данные:
b'SAB\x008\x00J\xc8\xb0N>\x00\x03\x00\x00\x00\\\x00\x02\x00_\xbd\x1b\x12'
(b'\x85\xbc\xfa\xf54\x1da`\xa3\xc1V!\x9f{\n2\x9a\r\x0f>U%K\xccs\xfd\xbe\xaf'
b"\x00\x00\x00o?\xd9\x9e\xd4\xaeD\x8ct\xba\xcc>\x9d\xfd\x1d'\x94"
b'\xb1\x13\xbf\xb4\x06\x82\xcc1`\xc0\xfa/\xc8\x06\xd4/MW\x17wisn\xdf<R\xbd\x8c'
b'\xa9\xa1\xd4\xa2\xdc\xec\xf9\xa57\xfd\xa8?x\x81\xbbH\xca*!\x8e'
b'\xf7\x1c\x00\x02\x00\x00\x00g\xbe^\x05\xd4f}\x0bG\xc3')
Результат разбора:
'A1': [{'B1': 0.40031926172577603,
{'B2': 186,
'B3': -52,
'B4': 4512040703355040019},
'B1': -0.07822434888055607,
{'B2': 250,
'B3': 47,
'B4': 14413440957071955831}],
'A2': -927969730,
'A3': {'C1': 'isn',
'C2': [-549694787, -1935040044],
'C3': -0.03785945847630501,
'C4': [-4829278046221410141, -4515384607544560998],
'C5': 3343,
'C6': 62,
'C7': 6135393408853589679,
'C8': {'D1': 16248,
'D2': -9098598589044519177,
'D3': 28,
'D4': [-1562579719, -1523057240],
'D5': -0.21681910753250122,
'D6': 1719470919,
'D7': 195}}}
Пример 2
Двоичные данные:
b'SAB\x008\x00Ji@{6\x00\x02\x00\x00\x00\\\x00\x02\x00^\xbfh0\x98\xf2S\x14'
(b'\xe7$C\xfa\x15\xc9\n\xa1\xf6nY\x83\x1a][R]u\xec\xb5\x1f\xaej\xd3'
b'\x00\x00\x00n?\xda\xfa=p\xcd\xcb\xec\x9a\xfdj\x98\n\xed8\xbb\x18\xe2?\x90'
b'j)Lm\xd8\x00\xa6\x07"\xc0@G\x80\xd0<\xb8xn\x18\x04F@\xf4z\xd8C\x05\xf7'
b'\xaf\xd8\xe3(\xcd\xe2\x1dx<\xad\x1c\xdba5\r\xf3\xd2\x00\x02\x00\x00\x00f\xbe'
b'\xb2\xc1\x9c\xca\xe68L\x84')
Результат разбора:
'A1': [{'B1': 0.4215234376526371,
{'B2': 154,
'B3': -3,
'B4': 7680901178455693538},
'B1': 0.016029973306523004,
{'B2': 166,
'B3': 7,
'B4': 2504072068665982136}],
'A2': 1765833526,
'A3': {'C1': 'xn',
'C2': [402933312, -193275837],
'C3': -0.9069914817810059,
'C4': [-985420910485571051, -3960174842533543142],
'C5': 23899,
'C6': 82,
'C7': 6734549080467204819,
'C8': {'D1': 7544,
'D2': 4372182541800902131,
'D3': 210,
'D4': [100118488, -483865118],
'D5': -0.34913337230682373,
'D6': 3404085324,
'D7': 132}}}
Задача №12
Реализовать разбор двоичного формата данных. Данные начинаются с сигнатуры 0x55 0x4e 0x53 0x4e 0xfe
, за которой следует
структура A. Порядок байт: от младшего к старшему. Адреса указаны в виде смещений от начала данных. В решении предлагается использовать
модуль struct.
Структура A:
Поле | Описание |
---|---|
1 | Размер (uint16) и адрес (uint16) массива адресов (uint16) структур B |
2 | Адрес (uint32) структуры C |
Структура B:
Поле | Описание |
---|---|
1 | Массив char, размер 5 |
2 | uint16 |
Структура C:
Поле | Описание |
---|---|
1 | int8 |
2 | Структура D |
Структура D:
Поле | Описание |
---|---|
1 | uint64 |
2 | Массив float, размер 5 |
3 | uint16 |
4 | int8 |
5 | Массив uint16, размер 6 |
6 | Размер (uint16) и адрес (uint16) массива int8 |
Ниже показаны примеры разбора двоичного формата.
Пример 1
Двоичные данные:
b'UNSN\xfe\x02\x00\x1b\x00$\x00\x00\x00mnmnb=\x0fjzexjv\x03\r\x00\x14\x00Y'
(b'\xf7\xb2\x8b\xf7\x00\xcf\x83\xbf/\x92\xc67\xa6|1\x85\xba\xfc9\x17\xbfU5A'
b'\xbf@\xb4A>`\xd4\xd5\xbeB\xed\x06[X\xf8]\xe59\xe16s\xce\xfe\xfe'
b'\x05\x00\x1f\x00')
Результат разбора:
'A1': [{'B1': 'mnmnb', 'B2': 3901}, {'B1': 'jzexj', 'B2': 886}],
{'A2': {'C1': 0,
'C2': {'D1': 11977260065183728591,
'D2': [-0.0010161842219531536,
-0.5907285213470459,
-0.7547200322151184,
0.1891641616821289,
-0.4176359176635742],
'D3': 60738,
'D4': 6,
'D5': [22619, 24056, 14821, 14049, 52851, 65278],
'D6': [89, -9, -78, -117, -9]}}}
Пример 2
Двоичные данные:
b'UNSN\xfe\x02\x00\x1b\x00%\x00\x00\x00xpabu\x13}hazsuuf\r\x00\x14\x00\xa6'
(b'\xc1_ \xd9\xb8\xbb\x10D\x8c@\xceT\x07l\xd5/h?\xf5CW\xbf\xc0.\x81\xbe\x1e\xe6'
b'o?\xcf\xbc|?3CM\xf7\x90\xa0`Ta\xc7H\x8c7\xf5\xa5\x06\x00\x1f\x00')
Результат разбора:
'A1': [{'B1': 'xpabu', 'B2': 32019}, {'B1': 'hazsu', 'B2': 26229}],
{'A2': {'C1': -69,
'C2': {'D1': 7784283725756122128,
'D2': [0.9069798588752747,
-0.8408806920051575,
-0.25230979919433594,
0.9371050596237183,
0.9872559905052185],
'D3': 17203,
'D4': 77,
'D5': [37111, 24736, 24916, 18631, 14220, 42485],
'D6': [-90, -63, 95, 32, -39, -72]}}}
Задача №12
Реализовать разбор двоичного формата данных. Данные начинаются с сигнатуры 0x48 0x41 0x51
, за которой следует структура A.
Порядок байт: от младшего к старшему. Адреса указаны в виде смещений от начала данных. В решении предлагается использовать модуль
struct.
Структура A:
Поле | Описание |
---|---|
1 | uint64 |
2 | uint32 |
3 | Размер (uint16) и адрес (uint32) массива структур B |
4 | Структура C |
Структура B:
Поле | Описание |
---|---|
1 | uint32 |
2 | int8 |
3 | int8 |
Структура C:
Поле | Описание |
---|---|
1 | Размер (uint32) и адрес (uint16) массива char |
2 | Размер (uint32) и адрес (uint16) массива int8 |
3 | Адрес (uint16) структуры D |
4 | int8 |
5 | uint32 |
6 | int32 |
7 | Размер (uint32) и адрес (uint32) массива uint8 |
8 | int16 |
Структура D:
Поле | Описание |
---|---|
1 | Массив int16, размер 7 |
2 | int32 |
3 | int8 |
4 | double |
5 | int64 |
6 | uint16 |
Ниже показаны примеры разбора двоичного формата.
Пример 1
Двоичные данные:
b'HAQ\r\x87Q.5\xec(\xc1\x98\x9f\xd8\xb8\x03\x006\x00\x00\x00\x03\x00\x00'
(b'\x00H\x00\x04\x00\x00\x00K\x00O\x00q\x13\xac6\xba\xcd\xd0J@\x04\x00\x00\x00'
b't\x00\x00\x00\\\xebV\xce\x12\x84h\x08\x81t!\x0c\x9fO&u\xd9\x7fAdmug\xe3'
b'\x96j\xda\xc2O\x07s\nzI9\x1e\xe309\xa4\xf4\x0f\x85\xbe\x1a\xa9\xc8\x00'
b'\xa1\x0e\xa7\n\xd1?\xe1\x1eu\x8c#\xb0\x1f\xff\xde\xf9f\xd5\xcd]')
Результат разбора:
'A1': 13918634361543034637,
{'A2': 3101204376,
'A3': [{'B1': 2215824982, 'B2': 104, 'B3': 8},
'B1': 203519105, 'B2': -97, 'B3': 79},
{'B1': 2144957734, 'B2': 65, 'B3': 100}],
{'A4': {'C1': 'mug',
'C2': [-29, -106, 106, -38],
'C3': {'D1': [20418, 29447, 31242, 14665, -7394, 14640, -2908],
'D2': 448693519,
'D3': -87,
'D4': 0.2662751810894517,
'D5': -63138203033067807,
'D6': 63966},
'C4': 113,
'C5': 3124145171,
'C6': 1078644941,
'C7': [102, 213, 205, 93],
'C8': -5284}}
Пример 2
Двоичные данные:
b'HAQ\x7f\xfc~\xfcg\xd4R\xfd\xb6\x13}\xa2\x03\x006\x00\x00\x00\x02\x00\x00'
(b'\x00H\x00\x03\x00\x00\x00J\x00M\x00\\:(\x8aYTh\xa8n\x02\x00\x00\x00'
b'r\x00\x00\x00\x8f\x98\x94\x88\x8d\x04,\xafx(\x97\xf9\xf0\xe3\x1cM'
b'\xe6u\xa1\xe9hrU\xcas\xcd\xf9\xcf\xfa\x0c\xbc8<t\x1a.\xf5\xa3\x8a\xc9'
b'\x8bm\xaa8l1\xea\x8bBL\xda\xbf$N\xac\xd4Leg\x90\xc8\x9c\xe7\xf2')
Результат разбора:
'A1': 18253885782768942207,
{'A2': 2726106038,
'A3': [{'B1': 76384404, 'B2': 44, 'B3': -81},
'B1': 4187433080, 'B2': -16, 'B3': -29},
{'B1': 1978027292, 'B2': -95, 'B3': -23}],
{'A4': {'C1': 'hr',
'C2': [85, -54, 115],
'C3': {'D1': [-1587, -1329, -17396, 15416, 6772, -2770, -30045],
'D2': -1435661367,
'D3': 56,
'D4': -0.41090453780704794,
'D5': -8041347228986749404,
'D6': 40136},
'C4': 92,
'C5': 1502226490,
'C6': 1856530516,
'C7': [231, 242],
'C8': -26481}}
Задача №12
Реализовать разбор двоичного формата данных. Данные начинаются с сигнатуры 0x48 0x43 0x4d 0x55
, за которой следует структура
A. Порядок байт: от младшего к старшему. Адреса указаны в виде смещений от начала данных. В решении предлагается использовать модуль
struct.
Структура A:
Поле | Описание |
---|---|
1 | Размер (uint32) и адрес (uint16) массива адресов (uint32) структур B |
2 | Структура C |
3 | Размер (uint16) и адрес (uint16) массива uint32 |
4 | double |
5 | double |
6 | Адрес (uint16) структуры D |
Структура B:
Поле | Описание |
---|---|
1 | int8 |
2 | int64 |
Структура C:
Поле | Описание |
---|---|
1 | Размер (uint16) и адрес (uint16) массива char |
2 | float |
3 | uint32 |
4 | int32 |
5 | Массив uint8, размер 5 |
6 | int16 |
Структура D:
Поле | Описание |
---|---|
1 | float |
2 | int8 |
3 | double |
4 | Размер (uint32) и адрес (uint32) массива uint8 |
5 | uint64 |
6 | int32 |
Ниже показаны примеры разбора двоичного формата.
Пример 1
Двоичные данные:
b'HCMU\x02\x00\x00\x00I\x00\x02\x00Q\x00\xbf\x93\xe5\xbex\xc5A]\x84\xb8'
(b'\x00\x95\x80\x972\x1eEY\xf3\x02\x00S\x00`\xe4;h\xac$\xb7\xbf\x14W\xfa)3D\xeb'
b'\xbf^\x00\xee\xf0\n\xdb.\xd4\xdd\xfbP*a\t3R\xafo\xa7\x047\x00\x00'
b'\x00@\x00\x00\x00jy\xc1,\xb8\xd3\xcc\xaf\x95!\xb7\x87\x94\xcdFn\xbf-h'
b'\xa2\xfa\xa1\xd4\xc6\xe9?\x03\x00\x00\x00[\x00\x00\x00\xfe\xed\xe0\xeb\xa5'
b'Y\xed}~G\xb6D')
Результат разбора:
'A1': [{'B1': -18, 'B2': 5835501645577521904},
{'B1': 42, 'B2': 335359496051427681}],
{'A2': {'C1': 'jy',
'C2': -0.4483928382396698,
'C3': 1564591480,
'C4': -1795114876,
'C5': [128, 151, 50, 30, 69],
'C6': -3239},
'A3': [3552062657, 563457996],
'A4': -0.09040334267400985,
'A5': -0.8520751781349838,
'A6': {'D1': -0.930767834186554,
'D2': 45,
'D3': 0.8055213130620134,
'D4': [183, 135, 148],
'D5': 9074007393383280126,
'D6': 1152796542}}
Пример 2
Двоичные данные:
b'HCMU\x02\x00\x00\x00I\x00\x04\x00Q\x00\xfa\xd9N\xbdg\xea\xfa)\xfe\xfa'
(b'i\xb1\x1dM\x07\xe6\xc1\x05O\x02\x00U\x00`\xcc\x9cy\xcaY\xc6\xbfn\x1e\x9c'
b'\xbf\xf9\x13\xe1?_\x00\xaa\xef"\xfag\x1d\x17\x15>\x9a\xa4E<\xe3\xa9\xc7\x83'
b'\x1f7\x00\x00\x00@\x00\x00\x00derd\xcdL\xe0\x93S\xfc\xfe<\xeadU,\r=\xa1'
b'\x10\x89\x91\x1ct\xda\xec\xbf\x02\x00\x00\x00]\x00\x00\x00\xde\x14\xbf\x89'
b'V\xde\xb3p\xa5\x0c\xb7l')
Результат разбора:
'A1': [{'B1': -86, 'B2': 4473507219928392431},
{'B1': -102, 'B2': 2270878169600640420}],
{'A2': {'C1': 'derd',
'C2': -0.05050084739923477,
'C3': 704309863,
'C4': -1318454530,
'C5': [29, 77, 7, 230, 193],
'C6': 20229},
'A3': [2480950477, 1023343699],
'A4': -0.17461520135984454,
'A5': 0.5336884252910303,
'A6': {'D1': 0.034466106444597244,
'D2': -95,
'D3': -0.9016666944483251,
'D4': [234, 100],
'D5': 8121079016338691294,
'D6': 1823935653}}
Задача №12
Реализовать разбор двоичного формата данных. Данные начинаются с сигнатуры 0x80 0x43 0x54 0x59 0x55
, за которой следует
структура A. Порядок байт: от младшего к старшему. Адреса указаны в виде смещений от начала данных. В решении предлагается использовать
модуль struct.
Структура A:
Поле | Описание |
---|---|
1 | int8 |
2 | int32 |
3 | Адрес (uint16) структуры B |
4 | uint32 |
5 | uint64 |
6 | Структура E |
7 | uint16 |
Структура B:
Поле | Описание |
---|---|
1 | uint32 |
2 | uint64 |
3 | Адрес (uint32) структуры C |
4 | uint32 |
5 | uint32 |
Структура C:
Поле | Описание |
---|---|
1 | uint8 |
2 | double |
3 | Размер (uint16) и адрес (uint16) массива адресов (uint32) структур D |
4 | Массив float, размер 3 |
Структура D:
Поле | Описание |
---|---|
1 | uint32 |
2 | Массив int16, размер 7 |
Структура E:
Поле | Описание |
---|---|
1 | int32 |
2 | Размер (uint32) и адрес (uint32) массива uint8 |
3 | Размер (uint32) и адрес (uint32) массива int64 |
4 | uint32 |
5 | uint16 |
Ниже показаны примеры разбора двоичного формата.
Пример 1
Двоичные данные:
b'\x80CTYU\xe9\xb7d\xce\xa6y\x00pR\x0boY\xba\x89y\xd2\xab\xc9DVrZC'
(b'\x02\x00\x00\x00\x91\x00\x00\x00\x02\x00\x00\x00\x93\x00\x00\x00'
b'\xab`\xc3\xa4\xf5g\xee\xfc\xfb\x95\xdd\xb6\xc2\x08K\x9b\xdf\xfa,\xb6'
b'O\xde\xebH\x08%D0\x82\x02\x04Dg\n3B\\7C2M\xc1w\xb14\x00\x00\x00F\x00\x00\x00'
b'\x8c\xb8$\xcbM\xdf!\xcb\xbf\x02\x00X\x00\xdd\xbb\xcc>w\x84\x7f\xbf\x17\xe8%'
b'\xbfqg2,\x01 \xd6\xeb7L\xd2f`\x00\x00\x00\x08\xb2\x99sz\xc1Z\x94o\xc2\xcc'
b'\x90[4\xd9\xb6\xc4Y\x98I\x12\x12\x0bm-\xfb')
Результат разбора:
'A1': -23,
{'A2': -1496423241,
'A3': {'B1': 741500785,
'B2': 7409068140041478145,
'B3': {'C1': 140,
'C2': -0.2119711999751297,
'C3': [{'D1': 3067975163,
'D2': [2242, -25781, -1313, -18900, -8625, 18667, 9480]},
'D1': 42086468,
{'D2': [17412,
2663,
16947,
14172,
12867,
-16051,
-20105]}],
'C4': [0.39987078309059143,
-0.9981150031089783,
-0.6480726599693298]},
'B4': 1939452424,
'B5': 2488975738},
'A4': 1863012976,
'A5': 4956681785368492633,
'A6': {'E1': 1130000982,
'E2': [111, 194],
'E3': [6468496008813449420, -347501701922403944],
'E4': 2764267691,
'E5': 26613},
'A7': 64750}
Пример 2
Двоичные данные:
b"\x80CTYUD\xce\x86\\\xa5y\x00)\xa5;\xe8\xa2'\x13\xb8OL\xbb8\xfd\\Rd"
(b'\x05\x00\x00\x00\x91\x00\x00\x00\x04\x00\x00\x00\x96\x00\x00\x00'
b"\xb3\xd0\x9e\x03\xc8\x99\xe9g\x0c\xe3m\xf8\x1a\xc7\x8b\xe1\x8b'q\xaa"
b'\xae?\xbdg\xd0\x8e\x92k\xc5\xbb>\xe4\xf7\xe2[\x01\xa9\xac\x03^W\xeb\xecO'
b'4\x00\x00\x00F\x00\x00\x00\x06`S\xd1\x93n\xe4\xd1?\x02\x00X\x00\xda!\x7f'
b'?T\xa3{?\xdeJ.>\xbc,\x94\xb7\xb8\xb2R\xee7!Z\x91`\x00\x00\x00\r\xf0\xae'
b'\x1a\xb5\x04\xe6Y;Z\xf01\x87B]v\x9c\xcd\x8bl\xad\xd9\x1d\x81\x8f\xbez'
b'\xfd2.\xe1x\xfd\x81\x8e7\x9f\x9c\x18\xd3\xa0\xd6\xdd\x1a\x1b')
Результат разбора:
'A1': 68,
{'A2': -1520662834,
'A3': {'B1': 3079941308,
'B2': 10473720407508824760,
'B3': {'C1': 6,
'C2': 0.27956737933464204,
'C3': [{'D1': 4167951116,
'D2': [-14566,
-7797,
10123,
-21903,
16302,
26557,
-28976]},
'D1': 3150277522,
{'D2': [-7106, -7433, 347, -21335, 24067, -5289, 20460]}],
'C4': [0.9966102838516235,
0.9829609394073486,
0.17020747065544128]},
'B4': 447672333,
'B5': 1508246709},
'A4': 3896223017,
'A5': 4087944992043247522,
'A6': {'E1': 1683119357,
'E2': [59, 90, 240, 49, 135],
'E3': [-5950227292453708478,
3674227829874171353,
-6973948809005440722,
1953117302309460124],
'E4': 60739763,
'E5': 39368},
'A7': 26601}
Задача №12
Реализовать разбор двоичного формата данных. Данные начинаются с сигнатуры 0x4e 0x4a 0x4a
, за которой следует структура A.
Порядок байт: от старшего к младшему. Адреса указаны в виде смещений от начала данных. В решении предлагается использовать модуль
struct.
Структура A:
Поле | Описание |
---|---|
1 | Структура B |
2 | Адрес (uint32) структуры C |
3 | int8 |
4 | uint32 |
5 | Размер (uint32) и адрес (uint32) массива структур D |
6 | Размер (uint16) и адрес (uint16) массива int64 |
Структура B:
Поле | Описание |
---|---|
1 | Размер (uint16) и адрес (uint32) массива char |
2 | Размер (uint16) и адрес (uint16) массива char |
3 | int16 |
Структура C:
Поле | Описание |
---|---|
1 | uint32 |
2 | uint64 |
Структура D:
Поле | Описание |
---|---|
1 | float |
2 | uint16 |
3 | uint16 |
4 | Размер (uint16) и адрес (uint32) массива int32 |
5 | float |
Ниже показаны примеры разбора двоичного формата.
Пример 1
Двоичные данные:
b'NJJ\x00\x02\x00\x00\x00$\x00\x04\x00&~b\x00\x00\x00*_\xcd\x16,I'
(b'\x00\x00\x00\x03\x00\x00\x00R\x00\x02\x00\x88tfxrmk1c\xe8\xa3\x189\xa8w\xcey'
b's\xbdU0\x16:\xc1\x1dL7\x14\xefzE\xd9\xf2\xa6\xbeS\x83C\xd1\xe3\x10'
b'\xda\xd6\xfa\x9b\xeb\x9a\xbe\xe3\x9c\xc2\x84\x8bV\x8e\x00\x02\x00\x00\x006'
b'>V\xa6H>_"Gt\x8d[\xb8\x00\x03\x00\x00\x00>>\xf3\x07\x8d>T\x9a\x0c\x90E'
b'\xb5s\x00\x02\x00\x00\x00J\xbe\xf9\\\xe4GP\\\xda\xfdy\xf8V3e\xf3\xa4'
b'g]\x91\xa8')
Результат разбора:
'A1': {'B1': 'tf', 'B2': 'xrmk', 'B3': 32354},
{'A2': {'C1': 828631203, 'C2': 1745611563101418429},
'A3': 95,
'A4': 3440782409,
'A5': [{'D1': -0.4445553421974182,
'D2': 33931,
'D3': 22158,
'D4': [1429214778, -1055044553],
'D5': 0.2096186876296997},
'D1': 0.217904195189476,
{'D2': 29837,
'D3': 23480,
'D4': [351238725, -638409026, 1401111505],
'D5': 0.4746669828891754},
'D1': 0.20761889219284058,
{'D2': 36933,
'D3': 46451,
'D4': [-485434666, -90444902],
'D5': -0.4870368242263794}],
'A6': [5138709270454990934, 3703634156016472488]}
Пример 2
Двоичные данные:
b'NJJ\x00\x02\x00\x00\x00$\x00\x03\x00&\xa9L\x00\x00\x00)\xb8\xe9\xfa\xcc\x8b'
(b"\x00\x00\x00\x03\x00\x00\x00Y\x00\x02\x00\x8fovyxw'\xfak\xf5!\x88y0\x02OY"
b'4ZS\\\x14\xc4o`\xca\x89\x9a\xee\x84nniuA\xbc\xd3c\x9d \x11\xc5\xff3\x1c'
b'.\xfb\xf4\x85\xc8\x17\xf4\xf1\xb7\xbf<\xd9Pq*M\x02\x00\x03\x00\x00\x005>'
b'd\x1fB>\x96\xb5{\xbd\xdc\xb6\x99\x00\x03\x00\x00\x00A?hG\x04>\x80\r\x05Q{d'
b'\xdc\x00\x03\x00\x00\x00M>\xf3\x1d\xe8\xbd\xb4\x0b\xf3\x98{\xbc$\x7f'
b'\xe3\xc6\x7f\x9aaF_')
Результат разбора:
'A1': {'B1': 'ov', 'B2': 'yxw', 'B3': -22196},
{'A2': {'C1': 670723061, 'C2': 2416314447188416820},
'A3': -72,
'A4': 3925527691,
'A5': [{'D1': -0.7376909255981445,
'D2': 28970,
'D3': 19714,
'D4': [1515412500, -999333686, -1986335100],
'D5': 0.22277548909187317},
'D1': 0.29435333609580994,
{'D2': 48604,
'D3': 46745,
'D4': [1852729717, 1102893923, -1658842683],
'D5': 0.9073336124420166},
'D1': 0.2500993311405182,
{'D2': 20859,
'D3': 25820,
'D4': [-13427666, -67861048, 401928631],
'D5': 0.4748375415802002}],
'A6': [-4777180163870049244, 9215427513883379295]}
Задача №12
Реализовать разбор двоичного формата данных. Данные начинаются с сигнатуры 0xc9 0x57 0x58 0x57 0x48
, за которой следует
структура A. Порядок байт: от старшего к младшему. Адреса указаны в виде смещений от начала данных. В решении предлагается использовать
модуль struct.
Структура A:
Поле | Описание |
---|---|
1 | Размер (uint16) и адрес (uint32) массива структур B |
2 | Адрес (uint32) структуры C |
3 | int8 |
Структура B:
Поле | Описание |
---|---|
1 | int8 |
2 | int8 |
3 | int16 |
Структура C:
Поле | Описание |
---|---|
1 | int16 |
2 | double |
3 | Адрес (uint32) структуры D |
4 | Массив int8, размер 8 |
Структура D:
Поле | Описание |
---|---|
1 | Размер (uint32) и адрес (uint16) массива uint8 |
2 | Адрес (uint16) структуры E |
3 | double |
4 | Структура F |
5 | double |
Структура E:
Поле | Описание |
---|---|
1 | int16 |
2 | Массив uint16, размер 8 |
3 | int16 |
4 | uint8 |
Структура F:
Поле | Описание |
---|---|
1 | int8 |
2 | Массив uint32, размер 7 |
Ниже показаны примеры разбора двоичного формата.
Пример 1
Двоичные данные:
b'\xc9WXWH\x00\x03\x00\x00\x00\x10\x00\x00\x00n\x05\xfe\x99\x8c\x11\xbc)\x9b-'
(b'P!(\xb0fl\xfbY0j\r$\x11\xabQ\x07\xca\xd8\tB\xc5|YciT\xe4<g\n\xcd\xa2'
b'\x89\x00\x00\x00\x08\x00\x1c\x00$?\xdd\xe5\xc5\xa5\xe6~\xe4\x1f\xfc\xaf'
b'5\xdem\x939<%\xa2\x8a\x0f\r\xa4\x97\xc2\xb3\x05\x02\xe6\x86\xf9\x92\xabMd'
b"\xdc\x01?\xdd#`?\xf9\xdb8\xa9\x04\xbf\xe7\x07J!4_ \x00\x00\x009'\xb4\x95\x0c"
b'\x14\xa9\xef*')
Результат разбора:
'A1': [{'B1': -2, 'B2': -103, 'B3': -29679},
{'B1': -68, 'B2': 41, 'B3': -25811},
{'B1': 80, 'B2': 33, 'B3': 10416}],
{'A2': {'C1': -22268,
'C2': -0.7196398399855504,
'C3': {'D1': [102, 108, 251, 89, 48, 106, 13, 36],
'D2': {'E1': 4523,
'E2': [20743,
51928,
2370,
50556,
22883,
26964,
58428,
26378],
'E3': -12894,
'E4': 137},
'D3': 0.46714917374809617,
'D4': {'F1': 31,
'F2': [4239341022,
1838364988,
631409167,
228890562,
3003450086,
2264502955,
1298455553]},
'D5': 0.45528417823463796},
'C4': [39, -76, -107, 12, 20, -87, -17, 42]},
'A3': 5}
Пример 2
Двоичные данные:
b'\xc9WXWH\x00\x04\x00\x00\x00\x10\x00\x00\x00n\xcd\x14\xd0\xbba\xce=\xdd\xe1'
(b'6\x982\xe8F\x9c\xb4\xbb\xa5\x83\x97x)fH\x14\x85\x84\x9bO\xc9\xe6\x88E'
b'B\x834\x10\xdf\xe8\x03\xf1|\x00\x00\x00\x04\x00 \x00$?\xd7U\xa4\x1ej\x99'
b' \x86\x18\x811P\xaf@#\xf8\x8a+6pt5\x91\x12l\xcf\xea4\n\xe8\x88\x9b\xcd\xe0'
b'Vn?\xdc\xbaT\x94\xee\x8e\x00\xac\x0e?\xd0\xab\xcd%\n\xe2\xc0\x00\x00\x009'
b'\x1c\x81\xb1\xb6\xd6\x87\x84\x8e')
Результат разбора:
'A1': [{'B1': 20, 'B2': -48, 'B3': -17567},
{'B1': -50, 'B2': 61, 'B3': -8735},
{'B1': 54, 'B2': -104, 'B3': 13032},
{'B1': 70, 'B2': -100, 'B3': -19269}],
{'A2': {'C1': -21490,
'C2': 0.2604859220260032,
'C3': {'D1': [165, 131, 151, 120],
'D2': {'E1': 10598,
'E2': [18452,
34180,
39759,
51686,
34885,
17027,
13328,
57320],
'E3': 1009,
'E4': 124},
'D3': 0.3646021172557017,
'D4': {'F1': -122,
'F2': [411119952,
2940216312,
2318087792,
1949667602,
1825565236,
183011483,
3454031470]},
'D5': 0.44887270492674247},
'C4': [28, -127, -79, -74, -42, -121, -124, -114]},
'A3': -51}