Задача №12
Реализовать разбор двоичного формата данных. Данные начинаются с сигнатуры 0xf2 0x4a 0x56 0x4d 0x51
, за которой следует
структура A. Порядок байт: от старшего к младшему. Адреса указаны в виде смещений от начала данных. В решении предлагается использовать
модуль struct.
Структура A:
Поле | Описание |
---|---|
1 | int8 |
2 | Структура B |
3 | float |
Структура B:
Поле | Описание |
---|---|
1 | Размер (uint32) и адрес (uint32) массива адресов (uint32) структур C |
2 | Размер (uint16) и адрес (uint16) массива структур D |
3 | Адрес (uint16) структуры E |
4 | int8 |
Структура C:
Поле | Описание |
---|---|
1 | uint64 |
2 | int8 |
Структура D:
Поле | Описание |
---|---|
1 | int32 |
2 | uint16 |
Структура E:
Поле | Описание |
---|---|
1 | Массив float, размер 7 |
2 | int8 |
3 | Размер (uint16) и адрес (uint32) массива uint64 |
Ниже показаны примеры разбора двоичного формата.
Пример 1
Двоичные данные:
b"\xf2JVMQz\x00\x00\x00\x02\x00\x00\x00+\x00\x05\x003\x00a'?nd\x1fa\x00\xc9"
(b'\xd0\xbf_CO\x15\xe1}\x1c\xd8K\x15uq|\x00\x00\x00\x19\x00\x00\x00" '
b'\xf7p\x03\xa5<\x83\x9d`\x8d8\x93\xf6\x81\x14K\xe8#_\xf6\xe5\x81\xbb\x01q'
b'Z\x08k\xd1I!\xaf\xbd\x1eO!\x84\xc3BZ,\x02\xb2\xa6+\xac\xbe\xbe\xd4'
b'\xa7\xbfj\xac\xc4\xbf\x0f\xb3\xc9>\x7fH\x00?\x0c\xd9\xe1\xbf\x0f\xa1+\xbe$w'
b'\xab\xad\x00\x02\x00\x00\x00Q')
Результат разбора:
'A1': 122,
{'A2': {'B1': [{'C1': 6989808520080081743, 'C2': 21},
'C1': 16248174745920828785, 'C2': 124}],
{'B2': [{'D1': 553086979, 'D2': 42300},
'D1': -2086838131, 'D2': 14483},
{'D1': -159312821, 'D2': 59427},
{'D1': 1610016129, 'D2': 47873},
{'D1': 1901725803, 'D2': 53577}],
{'B3': {'E1': [-0.37271615862846375,
-0.916698694229126,
-0.5613370537757874,
0.249298095703125,
0.550199568271637,
-0.5610529780387878,
-0.16061274707317352],
'E2': -83,
'E3': [2427366662050251971, 4781182344505994156]},
'B4': 39},
'A3': 0.931215226650238}
Пример 2
Двоичные данные:
b'\xf2JVMQ\xff\x00\x00\x00\x03\x00\x00\x004\x00\x04\x00@\x00h\xc9>,\xcd'
(b'\x9em\xf4jVo@\xb5P\xfce\xb1uW+\xf8\x11\xe7\x04 +\x08\xe1\xad+\x15\xc3\xc3'
b'\x00\x00\x00\x19\x00\x00\x00"\x00\x00\x00+\xa3w`\x18~\x9d#\xcb\x185p\xc8'
b'1\x13\xd6\x16e\xa0=)x\x13\x89^\xa4\x84\x80\x84\xbdq\x86\xd2"`O\xebV\x8d!\xe5'
b'\xbd\x95\xd6H>\xb8\xcd\xd2?N(e>\xd4\xc7\xe1?\x00QF\xbfS\x16\xfa?Y\xa5 '
b'\xc5\x00\x02\x00\x00\x00X')
Результат разбора:
'A1': -1,
{'A2': {'B1': [{'C1': 7923074563917788496, 'C2': -4},
'C1': 7327767085968789991, 'C2': 4},
{'C1': 2317956198578197955, 'C2': -61}],
{'B2': [{'D1': -1552457704, 'D2': 32413},
'D1': 600512565, 'D2': 28872},
{'D1': 823383574, 'D2': 26016},
{'D1': 1026127891, 'D2': 35166}],
{'B3': {'E1': [-0.07316261529922485,
0.36094528436660767,
0.8053038716316223,
0.415587455034256,
0.5012401342391968,
-0.8245693445205688,
0.8501758575439453],
'E2': -59,
'E3': [11854741426748360402, 2477067667241771493]},
'B4': -55},
'A3': 0.16875311732292175}
Задача №12
Реализовать разбор двоичного формата данных. Данные начинаются с сигнатуры 0x52 0x49 0x55 0x8b
, за которой следует структура
A. Порядок байт: от старшего к младшему. Адреса указаны в виде смещений от начала данных. В решении предлагается использовать модуль
struct.
Структура A:
Поле | Описание |
---|---|
1 | Размер (uint16) и адрес (uint32) массива структур B |
2 | int64 |
3 | Массив адресов (uint32) структур C, размер 4 |
4 | uint64 |
5 | int16 |
6 | uint16 |
7 | double |
8 | Адрес (uint32) структуры D |
Структура B:
Поле | Описание |
---|---|
1 | Массив char, размер 5 |
2 | uint16 |
Структура C:
Поле | Описание |
---|---|
1 | Размер (uint32) и адрес (uint32) массива int8 |
2 | double |
3 | int32 |
4 | int8 |
5 | uint8 |
6 | int8 |
Структура D:
Поле | Описание |
---|---|
1 | double |
2 | int64 |
3 | int16 |
4 | int32 |
5 | uint8 |
Ниже показаны примеры разбора двоичного формата.
Пример 1
Двоичные данные:
b'RIU\x8b\x00\x03\x00\x00\x00:\x06\x18\x9eK\xcd\xb7P\x1e\x00\x00\x00Q\x00\x00'
(b'\x00k\x00\x00\x00\x84\x00\x00\x00\x9e\xb7\xf3\xf3a\xb1\xb59\x82O\x08'
b'\xa3\x84?\xd4\x16\x19J*\xd5\xb4\x00\x00\x00\xb5cnocpQ\xeasobpuc#zlju'
b'v\xde[\x0c8\x00\x00\x00\x02\x00\x00\x00O\xbf\xcd\x9e\x81\x92\xf6\xf3'
b'\xb8\xeb\xcc\xcaT\xdb~7-0\x17\x00\x00\x00\x03\x00\x00\x00h\xbf'
b'\xab\xd5\x80\xdbm\xf2\x00T\xe7\xc1\x19\xde\x04?E\xbd\x00\x00\x00\x02'
b'\x00\x00\x00\x82?\xdd3\x96U\x81\x14X\xb0\xaf8\xab\xb0\xd0\x8b\x96'
b'\xc9\xe5\x00\x00\x00\x03\x00\x00\x00\x9b?\xcc\x8a9\xd8\x0f\xa0\x10\x11\xe5'
b'J\t \xf9^\xbf\xec\xba\x11\x05m\xc9\xeeT\x93\x1d\xfbucR\xf9\x0f!\x89'
b'\xa6s\x9e\x18')
Результат разбора:
'A1': [{'B1': 'cnocp', 'B2': 20970},
{'B1': 'sobpu', 'B2': 25379},
{'B1': 'zljuv', 'B2': 56923}],
{'A2': 439275012079702046,
'A3': [{'C1': [12, 56],
'C2': -0.23139972377785312,
'C3': -338900396,
'C4': -37,
'C5': 126,
'C6': 55},
'C1': [45, 48, 23],
{'C2': -0.054363276277374695,
'C3': 1424474393,
'C4': -34,
'C5': 4,
'C6': 63},
'C1': [69, -67],
{'C2': 0.45627363538762244,
'C3': -1330693973,
'C4': -80,
'C5': 208,
'C6': -117},
'C1': [-106, -55, -27],
{'C2': 0.2229683213220146,
'C3': 300239369,
'C4': 32,
'C5': 249,
'C6': 94}],
'A4': 13255205729200322946,
'A5': 20232,
'A6': 41860,
'A7': 0.3138488029756801,
'A8': {'D1': -0.8977131944687338,
'D2': 6094247686605853433,
'D3': 3873,
'D4': -1985580130,
'D5': 24}}
Пример 2
Двоичные данные:
b'RIU\x8b\x00\x03\x00\x00\x00:0\xe9\x13\x02b(\xf4h\x00\x00\x00S\x00\x00'
(b'\x00n\x00\x00\x00\x88\x00\x00\x00\xa1\xbd_\xf4\xb1~\xeb.\\\xe9\xd6'
b't\xa2\xbf\xab\x1f\x10s\x95\xfb\x80\x00\x00\x00\xb8uhgip\xb0\x0eitenu\xa5\x8e'
b'xinbt\x8c\x82\x7fDp\x93\x00\x00\x00\x04\x00\x00\x00O\xbf\xea>)\x7fv4X['
b'\xeanI\x02\xd5\xe6\xdc\t\x08\xda\x00\x00\x00\x04\x00\x00\x00j?\xe9'
b'\xba\n\xd6/\xf0x\xf6$\xf2p\xecY\xdc\xdc\x11S\x00\x00\x00\x03\x00\x00\x00\x85'
b'\xbf\xe8\xed:z\x94\xccL\x16$?5\x1d\x9c\x17\xc1\x1b\x00\x00\x00'
b'\x02\x00\x00\x00\x9f?\xe1\xfc\xbbsd$b\xb1\x0b1\xbc\xf4\x05N\xbf\xe1\xa6\xaf'
b'\xbb\x9e\xee\x84\xea\xc1\x02\x87\xca\xf2\xba\xbc\x97\x98t\xc3z\xb7\x14')
Результат разбора:
'A1': [{'B1': 'uhgip', 'B2': 45070},
{'B1': 'itenu', 'B2': 42382},
{'B1': 'xinbt', 'B2': 35970}],
{'A2': 3524369084351837288,
'A3': [{'C1': [127, 68, 112, -109],
'C2': -0.820088147114471,
'C3': 1542090313,
'C4': 2,
'C5': 213,
'C6': -26},
'C1': [-36, 9, 8, -38],
{'C2': 0.8039602454514485,
'C3': -165350800,
'C4': -20,
'C5': 89,
'C6': -36},
'C1': [-36, 17, 83],
{'C2': -0.7789585489430322,
'C3': 371474229,
'C4': 29,
'C5': 156,
'C6': 23},
'C1': [-63, 27],
{'C2': 0.562101102231406,
'C3': -1324666436,
'C4': -12,
'C5': 5,
'C6': 78}],
'A4': 13645894439131623004,
'A5': -5674,
'A6': 29858,
'A7': -0.05297137652359307,
'A8': {'D1': -0.5515974678487088,
'D2': -1530939616080512324,
'D3': -26728,
'D4': 1958967991,
'D5': 20}}
Задача №12
Реализовать разбор двоичного формата данных. Данные начинаются с сигнатуры 0x58 0x49 0x58
, за которой следует структура A.
Порядок байт: от младшего к старшему. Адреса указаны в виде смещений от начала данных. В решении предлагается использовать модуль
struct.
Структура A:
Поле | Описание |
---|---|
1 | Структура B |
2 | uint16 |
3 | Массив адресов (uint32) структур C, размер 2 |
4 | float |
5 | Массив char, размер 6 |
6 | Массив int16, размер 7 |
7 | uint8 |
Структура B:
Поле | Описание |
---|---|
1 | uint8 |
2 | Размер (uint32) и адрес (uint32) массива uint8 |
Структура C:
Поле | Описание |
---|---|
1 | uint64 |
2 | uint64 |
3 | Адрес (uint32) структуры D |
4 | double |
Структура D:
Поле | Описание |
---|---|
1 | uint8 |
2 | int64 |
3 | uint32 |
4 | uint8 |
Ниже показаны примеры разбора двоичного формата.
Пример 1
Двоичные данные:
b'XIX\x7f\x03\x00\x00\x00/\x00\x00\x00Gs@\x00\x00\x00j\x00\x00\x00=\xb3\xc2>dx'
(b'lxwe\xa1J\x1b`\x9e=\xc2\xa7\xd6\xf7\x87f^u\xb8\xbd\xd5i\x06\xc3\xe44Q\xf5'
b'Q\xba\x130\xed\xa2p\xf1\xba\x8b\x9c\xe5}x\x16\xf0d\x97\xfb\x07\x91\xb1\x82G'
b'2\x00\x00\x00\xc8\x81g\xae\x9eK\xc4\xbf\x95=\xf6m\x8d\xa8\nM\xb2\xe5\x98\xa0'
b'\xa96\xec[1uh\xed\xc0\xaa]\x1a\nY\xd7\x1dv\x7f\\\x00\x00\x00`\x15'
b'\x02\xa2,\x8d\xc2\xbf')
Результат разбора:
'A1': {'B1': 127, 'B2': [189, 213, 105]},
{'A2': 29511,
'A3': [{'C1': 17300147500708826042,
'C2': 5152876160127571812,
'C3': {'D1': 6,
'D2': 1421538746460071107,
'D3': 1889725744,
'D4': 241},
'C4': -0.15855773464046607},
'C1': 12304095214874745836,
{'C2': 9184561300817713757,
'C3': {'D1': 149,
'D2': -5598807042708081091,
'D3': 2845874405,
'D4': 54},
'C4': -0.14493329916528364}],
'A4': 0.3802737295627594,
'A5': 'dxlxwe',
'A6': [19105, 24603, 15774, -22590, -2090, 26247, 30046],
'A7': 184}
Пример 2
Двоичные данные:
b"XIXg\x03\x00\x00\x00/\x00\x00\x00\x1e'@\x00\x00\x00j\x00\x00\x00\xff\xee"
(b'\x17=cqtqip\x82\r0\x94\x18Q\xe1\xfa\xc9H\x07\x93\x89:\xfd@\x81\xbc\xa6\xd6'
b'6\x0e\x95\xd1W\xfao\xd8L@86R\xcf\x7fA\xf2\x84\x14=\xc34416\xf7G5'
b'2\x00\x00\x00pL3\x08\xa86\xbd\xbf\xfdU\xad~\xa0Q\xce\x94y\x95\x90G#\x8d}r'
b'Paa\x06 \x89h\xda\xc2q\xbex\xa6\xc5\\\x00\x00\x00\xe4\xbe=\xe5\xf6\xba'
b'\xd7\xbf')
Результат разбора:
'A1': {'B1': 103, 'B2': [64, 129, 188]},
{'A2': 10014,
'A3': [{'C1': 4401288911863664466,
'C2': 3839309019482436803,
'C3': {'D1': 166,
'D2': 8068858240048182998,
'D3': 943738072,
'D4': 54},
'C4': -0.1141152400989982},
'C1': 9880904597765124733,
{'C2': 14242203630953486952,
'C3': {'D1': 253,
'D2': 8760854025122786645,
'D3': 591892629,
'D4': 141},
'C4': -0.370786403530458}],
'A4': 0.037093158811330795,
'A5': 'cqtqip',
'A6': [3458, -27600, 20760, -1311, 18633, -27897, 14985],
'A7': 253}
Задача №12
Реализовать разбор двоичного формата данных. Данные начинаются с сигнатуры 0x4a 0x4f 0x4a 0x44 0x1a
, за которой следует
структура A. Порядок байт: от старшего к младшему. Адреса указаны в виде смещений от начала данных. В решении предлагается использовать
модуль struct.
Структура A:
Поле | Описание |
---|---|
1 | Структура B |
2 | Адрес (uint16) структуры C |
3 | uint32 |
4 | Размер (uint32) и адрес (uint16) массива uint32 |
5 | Структура E |
6 | uint16 |
7 | uint32 |
8 | uint32 |
Структура B:
Поле | Описание |
---|---|
1 | float |
2 | uint32 |
3 | int64 |
4 | int64 |
Структура C:
Поле | Описание |
---|---|
1 | double |
2 | int16 |
3 | int64 |
4 | Массив структур D, размер 5 |
5 | Размер (uint16) и адрес (uint32) массива uint8 |
Структура D:
Поле | Описание |
---|---|
1 | Массив int16, размер 2 |
2 | int8 |
3 | Размер (uint16) и адрес (uint16) массива uint16 |
Структура E:
Поле | Описание |
---|---|
1 | int32 |
2 | int16 |
Ниже показаны примеры разбора двоичного формата.
Пример 1
Двоичные данные:
b'JOJD\x1a?\x18\xa1\xdbu~\x83Qf\xbf\xf2$\x0c\xdf\xbeK\xee=\xa3G,\xef\xbe'
(b'\xdc\x00e\x14\x1c\x01o\x00\x00\x00\x03\x00\xaa\xbb\r\xe9\x9fA\xe3)m\x11Lm'
b'\x9c\xfc>\xc7\xbb\xc3@z\xf5v\n\x88)\x90\xed\xcb\xb7\xb0\xbfs\x80\xf0j\xc1'
b'\xe2\x87\t\r\xde\xf5 \x84}rD\xca\x17\x8cC\xb5\xaf\xfe\xcc!u\x9d\x9e\xa8'
b'&?\xef\xe3\x86^y\xce\xa4.\xb8\xb3\xcf\n\x9aj\xbf\xd7J\xf8.\xb1\xfdt'
b'\x00\x05\x009\x82n\x7f~\xd1\x00\x05\x00C\x8b\xb5?\x9e\x12\x00\x02'
b'\x00M\xfc\x83p\n\xfb\x00\x03\x00Q\xeb\x90\xdb\\\xc9\x00\x04\x00W'
b'\x00\x06\x00\x00\x00_\x12\xbad\xf7\xb5\xd91\x88}\xcd\x0e\xed')
Результат разбора:
'A1': {'B1': 0.5962197184562683,
{'B2': 1971225425,
'B3': 7403902549069119051,
'B4': -1279687193011437860},
'A2': {'C1': 0.9965240330916072,
'C2': 11960,
'C3': -5490157762409146550,
'C4': [{'D1': [-2002, -19971],
'D2': 116,
'D3': [49984, 31477, 30218, 34857, 37101]},
'D1': [-32146, 32638],
{'D2': -47,
'D3': [52151, 45247, 29568, 61546, 49634]},
'D1': [-29771, 16286], 'D2': 18, 'D3': [34569, 3550]},
{'D1': [-893, 28682], 'D2': -5, 'D3': [62752, 33917, 29252]},
{'D1': [-5232, -9380],
{'D2': -55,
'D3': [51735, 35907, 46511, 65228]}],
'C5': [33, 117, 157, 158, 168, 38]},
'A3': 337379695,
'A4': [314205431, 3050910088, 2110590701],
'A5': {'E1': -1156716129, 'E2': 16867},
'A6': 10605,
'A7': 290221468,
'A8': 4231972795}
Пример 2
Двоичные данные:
b'JOJD\x1a>\x04[\x80\xf8g\xca\xd1\x90\xc6\xb8v\xb9\x9d}\x91+=R)\x14\xa2\x1f'
(b'\xc1\x00V\xdf\\F\xf7\x00\x00\x00\x02\x00\x9b\x94\x94\t<\xd9Ur\x1a\xac\xd85'
b'n\x9bK\x9el\x1e\xdf\xd3\tL.\x8b\x8c\x9f\x0556Afw\xd2\x89\x9d\x80h\xaaL\xb4'
b"K\xfb\x82\xf3\xd0'?\xea\xdb\x94\xa5\x8a\\\xf8\x14\xfa\x01\x97\x017GO\x8c\x18"
b'\xb2\xeb\xe3R\xe6\x00\x02\x009:U-\xaf\x86\x00\x03\x00=} >\xd2\x94\x00'
b'\x02\x00C\x0b\x95\xb2\x076\x00\x03\x00G\xc6\x8d\x9ax\x02\x00\x03\x00'
b'M\x00\x03\x00\x00\x00S0\x8b2\x03\xaf\xb9\xf54')
Результат разбора:
'A1': {'B1': 0.1292552947998047,
{'B2': 4167551697,
'B3': -8014515666799460975,
'B4': 3115736853603557313},
'A2': {'C1': 0.8393042786800882,
'C2': 5370,
'C3': 114561652452461592,
'C4': [{'D1': [-19733, -7342], 'D2': -26, 'D3': [7903, 54025]},
'D1': [14933, 11695], 'D2': -122, 'D3': [19502, 35724, 40709]},
{'D1': [32032, 16082], 'D2': -108, 'D3': [13622, 16742]},
{'D1': [2965, -19961], 'D2': 54, 'D3': [30674, 35229, 32872]},
{'D1': [-14707, -25992], 'D2': 2, 'D3': [43596, 46155, 64386]}],
{'C5': [243, 208, 39]},
'A3': 3747366647,
'A4': [814428675, 2948199732],
'A5': {'E1': -1802237636, 'E2': -9899},
'A6': 29210,
'A7': 2899850606,
'A8': 2605424236}
Задача №12
Реализовать разбор двоичного формата данных. Данные начинаются с сигнатуры 0x46 0x47 0x47 0x54
, за которой следует структура
A. Порядок байт: от старшего к младшему. Адреса указаны в виде смещений от начала данных. В решении предлагается использовать модуль
struct.
Структура A:
Поле | Описание |
---|---|
1 | Структура B |
2 | int8 |
3 | uint64 |
Структура B:
Поле | Описание |
---|---|
1 | Адрес (uint32) структуры C |
2 | Массив int8, размер 6 |
Структура C:
Поле | Описание |
---|---|
1 | double |
2 | Массив адресов (uint16) структур D, размер 8 |
3 | int16 |
4 | Структура E |
5 | int64 |
Структура D:
Поле | Описание |
---|---|
1 | uint8 |
2 | Массив int8, размер 2 |
3 | float |
Структура E:
Поле | Описание |
---|---|
1 | Массив uint8, размер 6 |
2 | int16 |
3 | int32 |
4 | int32 |
5 | int32 |
6 | uint16 |
7 | double |
Ниже показаны примеры разбора двоичного формата.
Пример 1
Двоичные данные:
b'FGGT\x00\x00\x00O\xd1\xb9-\xfb\x83+\x7f\xc2j\x0c\x85TV\x8c6\x90'
(b'\x90\xba\xbf\x1di\xce\xb09\xaf\xbf|n\x1f\xc5g\x7f\xbe\xf7\xb0\x1bK@\xf5\xbe'
b'\xae\xba\xa8\xab\x00\xdc\xbe\xdb\x00\x05\x0f\xcel\xbe\xd4\xc4'
b'\xe9\xf6\x9b\x07>\x1d\xd5\x857\xa4\r?5\x96\xd6\xbf\xe2\x80\xf1jG\xaa\x94\x00'
b'\x17\x00\x1e\x00%\x00,\x003\x00:\x00A\x00HLTu1te\x9d\xcc\xb8\x99\x87\x05U'
b'\x82\xe5\x10\xe2Y5_\x8c:-\xa3\xbf\xc5:\x86\xfc\xcb\x9b(\x83\xfd\xb3\x06\xbb'
b'\xb2\x9dG')
Результат разбора:
'A1': {'B1': {'C1': -0.5782401157169539,
{'C2': [{'D1': 144, 'D2': [-112, -70], 'D3': -0.6148957014083862},
'D1': 176, 'D2': [57, -81], 'D3': -0.986055314540863},
{'D1': 197, 'D2': [103, 127], 'D3': -0.48376545310020447},
{'D1': 75, 'D2': [64, -11], 'D3': -0.34126782417297363},
{'D1': 171, 'D2': [0, -36], 'D3': -0.42773452401161194},
{'D1': 15, 'D2': [-50, 108], 'D3': -0.41556480526924133},
{'D1': 246, 'D2': [-101, 7], 'D3': 0.1541348248720169},
{'D1': 55, 'D2': [-92, 13], 'D3': 0.7093328237533569}],
{'C3': 19540,
'C4': {'E1': [117, 49, 116, 101, 157, 204],
'E2': -18279,
'E3': -2029693566,
'E4': -451878311,
'E5': 895454266,
'E6': 11683,
'E7': -0.1658486112930515},
'C5': -8935789244132975289},
'B2': [-47, -71, 45, -5, -125, 43]},
'A2': 127,
'A3': 14009023357674490934}
Пример 2
Двоичные данные:
b'FGGT\x00\x00\x00O+\x04\x97\x08\x0b\x1ey\xad~\xe4\xd5\xd5\xd9\xcf\x03e'
(b'\xa6\x85?)\xdbi^\xfa\xdd>\xb9\x94\xdez\x95(?_\xe8\x17E\xd4\x91\xbd'
b'\xf8\xe9\x83\xfb\xcd\x95\xbe\xa2=\x88\xc7s\xdb?I\xa4\x15\xf8\xa0\x85'
b'\xbe\xecxm\xf6\x16\x82\xbf0\x07r?\xd2k\xb8(\xf48D\x00\x17\x00\x1e\x00'
b'%\x00,\x003\x00:\x00A\x00Hb\xc1\x06hL\x08\xd7\x07\x13\xaf\xa7x\x15'
b'\x0f\xa6\xe3\x94W\xe8c\xa7\xf3iz?\xe0\x8c>\xac\xfa,4\xb5\xc9G\xa3\x8d'
b'\x13\xf2\x0f')
Результат разбора:
'A1': {'B1': {'C1': 0.2878246688786741,
{'C2': [{'D1': 101, 'D2': [-90, -123], 'D3': 0.6635041832923889},
'D1': 94, 'D2': [-6, -35], 'D3': 0.36246389150619507},
{'D1': 122, 'D2': [-107, 40], 'D3': 0.8746351599693298},
{'D1': 69, 'D2': [-44, -111], 'D3': -0.12153913825750351},
{'D1': 251, 'D2': [-51, -107], 'D3': -0.316875696182251},
{'D1': 199, 'D2': [115, -37], 'D3': 0.7876599431037903},
{'D1': 248,
{'D2': [-96, -123],
'D3': -0.46185627579689026},
'D1': 246, 'D2': [22, -126], 'D3': -0.6876136064529419}],
{'C3': 25281,
'C4': {'E1': [6, 104, 76, 8, 215, 7],
'E2': 5039,
'E3': -1485302513,
'E4': -1495034793,
'E5': -396122125,
'E6': 27002,
'E7': 0.51711972984902},
'C5': -5347664314753617393},
'B2': [43, 4, -105, 8, 11, 30]},
'A2': 121,
'A3': 12501681222694063875}
Задача №12
Реализовать разбор двоичного формата данных. Данные начинаются с сигнатуры 0x5a 0x4b 0x58 0x48
, за которой следует структура
A. Порядок байт: от младшего к старшему. Адреса указаны в виде смещений от начала данных. В решении предлагается использовать модуль
struct.
Структура A:
Поле | Описание |
---|---|
1 | Массив структур B, размер 6 |
2 | Массив char, размер 8 |
3 | int8 |
4 | Адрес (uint32) структуры C |
5 | int16 |
6 | int32 |
7 | Размер (uint32) и адрес (uint16) массива int32 |
Структура B:
Поле | Описание |
---|---|
1 | int32 |
2 | uint8 |
Структура C:
Поле | Описание |
---|---|
1 | Адрес (uint32) структуры D |
2 | uint32 |
3 | double |
Структура D:
Поле | Описание |
---|---|
1 | Размер (uint16) и адрес (uint32) массива uint32 |
2 | uint16 |
Ниже показаны примеры разбора двоичного формата.
Пример 1
Двоичные данные:
b'ZKXH0~R-U\xee\xfcK\xc0\xd5\x1fIZ\xb0/\n\xd5o\xd9\xe7\x92\x93\x0eG'
(b'\x1a\x0c\xac\x7f#\xefjuplhtxg0K\x00\x00\x00,\x89\x89\x80$"\x02\x00\x00'
b'\x00[\x00\xf2Ab\x88\xa4\xd3:I\x02\x00;\x00\x00\x00\xb5dC\x00\x00\x00r'
b'd\xf0k\x0e\xe30\xb5\x9aI\xed\xbf8\xe45:\xed\nK\xd4')
Результат разбора:
'A1': [{'B1': 760380976, 'B2': 85},
{'B1': -1068761874, 'B2': 213},
{'B1': -1336260321, 'B2': 47},
{'B1': -646982390, 'B2': 231},
{'B1': 1192137618, 'B2': 26},
{'B1': 595569676, 'B2': 239}],
{'A2': 'juplhtxg',
'A3': 48,
'A4': {'C1': {'D1': [2288140786, 1228592036], 'D2': 25781},
'C2': 1810916466,
'C3': -0.9152349032293345},
'A5': -30420,
'A6': 572817545,
'A7': [976610360, -733279507]}
Пример 2
Двоичные данные:
b'ZKXHf\x82\x07\xd2w\xdeg\xc1\xe2W\xc4\xaf5)\xf6\xf2\x96\xbb\xa1\x83'
(b'\x1d\xa4\xe9\x99\xc9\x15\xc5!hhzjdxnsej\tO\x00\x00\x008#\xb2i\x81'
b'=\x02\x00\x00\x00_\x00UE\x86x\xf9\xb0\x169\x11\x0eO\x9e\x03\x00;\x00\x00'
b'\x00?\xe6G\x00\x00\x00\xa8bS\xfa\x80\x816U\xcd\x8b\xa3\xbf\x98'
b'\x10\xcd\xa1\x1e\x80\xb3\xb6')
Результат разбора:
'A1': [{'B1': -771259802, 'B2': 119},
{'B1': -490641442, 'B2': 87},
{'B1': 691384260, 'B2': 246},
{'B1': -1581541646, 'B2': 131},
{'B1': -1712741347, 'B2': 201},
{'B1': 1747043605, 'B2': 104}],
{'A2': 'zjdxnsej',
'A3': 9,
'A4': {'C1': {'D1': [2022065493, 957788409, 2655981073], 'D2': 58943},
'C2': 4199768744,
'C3': -0.03817598023602198},
'A5': 9016,
'A6': 1031891378,
'A7': [-1580396392, -1229750242]}
Задача №12
Реализовать разбор двоичного формата данных. Данные начинаются с сигнатуры 0x49 0x47 0x55 0x4b 0x23
, за которой следует
структура A. Порядок байт: от старшего к младшему. Адреса указаны в виде смещений от начала данных. В решении предлагается использовать
модуль struct.
Структура A:
Поле | Описание |
---|---|
1 | int8 |
2 | Структура B |
3 | double |
4 | Адрес (uint16) структуры D |
5 | uint8 |
6 | Адрес (uint16) структуры E |
7 | uint8 |
Структура B:
Поле | Описание |
---|---|
1 | uint8 |
2 | uint32 |
3 | uint32 |
4 | double |
5 | Массив структур C, размер 3 |
6 | int8 |
7 | uint16 |
Структура C:
Поле | Описание |
---|---|
1 | int16 |
2 | uint8 |
Структура D:
Поле | Описание |
---|---|
1 | Массив char, размер 7 |
2 | Размер (uint32) и адрес (uint16) массива int16 |
3 | uint32 |
Структура E:
Поле | Описание |
---|---|
1 | int16 |
2 | Размер (uint32) и адрес (uint32) массива uint16 |
3 | int64 |
4 | uint8 |
5 | uint32 |
6 | Массив uint32, размер 4 |
Ниже показаны примеры разбора двоичного формата.
Пример 1
Двоичные данные:
b'IGUK#\x14\xfa\xfc\x97\xb0U\xc5v\xf7\x97\xbf\xd8kh\x80\x9b\xda\x9c\x1b'
(b'\x109\xa9-\nf\xe2\x11\x17B(\xbf\xa9\xdb\xb0\x89\xa1\xcd\xc0\x0052\x00J'
b'\xc0\x88\xe9DYnlpbuok\x00\x00\x00\x02\x001\xda\x1e\x00\x1fc\xb8\\\xf4\x92d'
b'\x00\x00\x00\x02\x00\x00\x00FBa%kB\x8a\x80\xf4\xba\x04\xc0{6e\xd14'
b'>\xe6\x1e\xfb\xf2\xdf<\x1f\xbf\xf4\x90A\x1e')
Результат разбора:
'A1': 20,
{'A2': {'B1': 250,
'B2': 4237799509,
'B3': 3312908183,
'B4': -0.38155567702725945,
'B5': [{'C1': 6928, 'C2': 57},
'C1': -22227, 'C2': 10},
{'C1': 26338, 'C2': 17}],
{'B6': 23,
'B7': 16936},
'A3': -0.050504223633562884,
'A4': {'D1': 'nlpbuok', 'D2': [-30487, 17497], 'D3': 3659399199},
'A5': 50,
'A6': {'E1': -28060,
'E2': [25528, 23796],
'E3': 4783145421852279028,
'E4': 186,
'E5': 79723318,
'E6': [1708209214, 3860790258, 3745259455, 4103094558]},
'A7': 192}
Пример 2
Двоичные данные:
b'IGUK#\x7f\xfa\x8f\t\x14\xf2\x88\x08>\xa9\xbf\xae\xae\xa2P\x08 @\xbb'
(b'\x9e\xd5)J\x0f\xfa7\xab\x0eH\x0b\xbf\xc6\x1a\xcdPy\xe6 \x009\xf8\x00N'
b'\xb6\x17\x04.K\xab\xc3\xb6\x0begjwqla\x00\x00\x00\x04\x001S\x82\x00\xcb=\xa4'
b'\xab`\x95V\x00\x00\x00\x02\x00\x00\x00J\xc5\xa0\xc9\xdf\x90\xfb\xffH'
b'\xa0CG\x8a;\x04\x7f\x14+\xeb\xc7"\x8e\x8fj.+P\x81\x0e\xc9')
Результат разбора:
'A1': 127,
{'A2': {'B1': 250,
'B2': 2399737074,
'B3': 2282241705,
'B4': -0.05992610194158532,
'B5': [{'C1': -17506, 'C2': 213},
'C1': 10570, 'C2': 15},
{'C1': -1481, 'C2': 171}],
{'B6': 14,
'B7': 18443},
'A3': -0.17269293241024375,
'A4': {'D1': 'egjwqla', 'D2': [5892, 11851, -21565, -18933], 'D3': 1401028811},
'A5': 248,
'A6': {'E1': -27306,
'E2': [15780, 43872],
'E3': -4206140089916719288,
'E4': 160,
'E5': 1128761915,
'E6': [75437099, 3955696270, 2406100523, 1350635209]},
'A7': 182}
Задача №12
Реализовать разбор двоичного формата данных. Данные начинаются с сигнатуры 0x44 0x55 0x45 0x60
, за которой следует структура
A. Порядок байт: от старшего к младшему. Адреса указаны в виде смещений от начала данных. В решении предлагается использовать модуль
struct.
Структура A:
Поле | Описание |
---|---|
1 | Адрес (uint32) структуры B |
2 | int64 |
3 | Размер (uint16) и адрес (uint32) массива адресов (uint16) структур C |
4 | uint64 |
5 | Размер (uint16) и адрес (uint32) массива структур D |
6 | Структура E |
Структура B:
Поле | Описание |
---|---|
1 | int64 |
2 | int8 |
3 | uint32 |
4 | int64 |
Структура C:
Поле | Описание |
---|---|
1 | Массив char, размер 4 |
2 | int16 |
Структура D:
Поле | Описание |
---|---|
1 | float |
2 | uint16 |
Структура E:
Поле | Описание |
---|---|
1 | uint16 |
2 | Размер (uint32) и адрес (uint32) массива uint8 |
3 | uint8 |
Ниже показаны примеры разбора двоичного формата.
Пример 1
Двоичные данные:
b'DUE`\x00\x00\x00/\x98\xa3\xf96\xc6\x856\x85\x00\x02\x00\x00\x00P`&'
(b'\xbc\xd5V\xa4\xc2\r\x00\x03\x00\x00\x00T{\x95\x00\x00\x00\x02\x00\x00'
b'\x00f\xa4\xdc\x98}O\xafG\xd3\xb0\xdaF,\x88!\xcd\xe5\x94\x98&O\x0b\x81hoth'
b'\x84\x93gvpk\x0f\x0e\x00D\x00J\xbd\x1a\x16\x19=\x08>\x1c\x9d\x0c\x92\x84'
b'?RM\x16\xd3\x93\xeaw')
Результат разбора:
'A1': {'B1': -2551151407708777552,
{'B2': -38,
'B3': 1177323553,
'B4': -3610316145068930175},
'A2': -7447835345086499195,
'A3': [{'C1': 'hoth', 'C2': -31597}, {'C1': 'gvpk', 'C2': 3854}],
'A4': 6928432701223780877,
'A5': [{'D1': -0.0376187302172184, 'D2': 15624},
'D1': 0.15294283628463745, 'D2': 37508},
{'D1': 0.8214887380599976, 'D2': 54163}],
{'A6': {'E1': 31637, 'E2': [234, 119], 'E3': 164}}
Пример 2
Двоичные данные:
b'DUE`\x00\x00\x00/\xecCD\x87\xeeI\x97N\x00\x03\x00\x00\x00V\xc9\xdd\x8bS\x7fM'
(b'\xc4\xb1\x00\x03\x00\x00\x00\\P\xf9\x00\x00\x00\x02\x00\x00\x00ne\xef'
b'\x97w\xb3hak\xea\xfcQ[\xca\xed\xbd\xae02\xbfp\xbd}weil\x9a\xf9lqzkr\x82txjo'
b'P\xb1\x00D\x00J\x00P\xbf[u5\x11\xae\xbf\x1fQ\xa0\xe7\x0c>\x8d\x8c\x93'
b'\xb7\r9\xb0')
Результат разбора:
'A1': {'B1': -1182344764727399446,
{'B2': -4,
'B3': 1364970221,
'B4': -4778829160075182723},
'A2': -1422217706709870770,
'A3': [{'C1': 'weil', 'C2': -25863},
'C1': 'lqzk', 'C2': 29314},
{'C1': 'txjo', 'C2': 20657}],
{'A4': 14545935562210919601,
'A5': [{'D1': -0.8572571873664856, 'D2': 4526},
'D1': -0.6223392486572266, 'D2': 59148},
{'D1': 0.276463121175766, 'D2': 46861}],
{'A6': {'E1': 20729, 'E2': [57, 176], 'E3': 101}}
Задача №12
Реализовать разбор двоичного формата данных. Данные начинаются с сигнатуры 0x44 0x41 0x42 0x22
, за которой следует структура
A. Порядок байт: от младшего к старшему. Адреса указаны в виде смещений от начала данных. В решении предлагается использовать модуль
struct.
Структура A:
Поле | Описание |
---|---|
1 | float |
2 | Структура B |
3 | Структура E |
4 | int64 |
5 | Размер (uint16) и адрес (uint16) массива float |
6 | uint16 |
7 | int64 |
8 | int8 |
Структура B:
Поле | Описание |
---|---|
1 | Размер (uint32) и адрес (uint32) массива char |
2 | Размер (uint32) и адрес (uint16) массива структур C |
3 | int8 |
4 | Структура D |
5 | uint32 |
6 | int32 |
Структура C:
Поле | Описание |
---|---|
1 | float |
2 | int8 |
3 | int64 |
4 | int64 |
Структура D:
Поле | Описание |
---|---|
1 | float |
2 | uint32 |
3 | uint32 |
Структура E:
Поле | Описание |
---|---|
1 | Адрес (uint32) структуры F |
2 | int32 |
3 | uint32 |
Структура F:
Поле | Описание |
---|---|
1 | int64 |
2 | Массив float, размер 2 |
3 | int32 |
4 | Размер (uint16) и адрес (uint32) массива uint32 |
5 | int32 |
Ниже показаны примеры разбора двоичного формата.
Пример 1
Двоичные данные:
b'DAB"\xda\xb7D\xbf\x03\x00\x00\x00N\x00\x00\x00\x02\x00\x00\x00Q\x00\xaeO'
(b'\x0b\xb2\xbe\xc33 ;P]z\xdf\x08\xc60\x8c\x8f\xc9\x1e\x84\x87\x00\x00\x00e'
b'\xa8\xdc\xad\xb9\xb9\xc7\x10(\x8d\xd7\xa2\x9a\x1b\xeb\x81\x02\x00\xa5\x00j'
b"s@\xf2UMwt3{\x81vaw'\x17\xde>_\xed\x01,L\xe6\x10>I\xb1\x91\xfc:\x84?"
b']\xb8\x1f=b\xbf\x1b\x87Fb\xee\xbb\xd7\xb4\x9f\x84Kvc\x9f\xac\x91\x81\xe6'
b'\xce<\xd9\x90 \xa0U\xb0\xd5\x06\xa0\xa5/;u\xb2\xc8@\xe1\x9b\xb2\x1f\xbf\xfc'
b'JP\xbf?0%\x96\x03\x00{\x00\x00\x00\xa4\xf5\x01\x90\x05\xae\xa5\xbe\xc2\xac\\'
b'\xbf')
Результат разбора:
'A1': -0.7684303522109985,
{'A2': {'B1': 'vaw',
'B2': [{'C1': 0.43377038836479187,
'C2': 95,
'C3': 5277674394631274989,
'C4': -5161899760738856527},
'C1': -0.8837451338768005,
{'C2': 27,
'C3': -6938683923712817529,
'C4': -9110310770625328252}],
'B3': -82,
'B4': {'D1': -0.3477425277233124, 'D2': 991966147, 'D3': 3749338448},
'B5': 2352006664,
'B6': -2078357105},
'A3': {'E1': {'F1': -2215550347869737051,
'F2': [-0.6238190531730652, -0.8136441707611084],
'F3': -1775947713,
'F4': [3644640998, 1436557456, 2684802480],
'F5': -1878919772},
'E2': -1378047899,
'E3': 281524665},
'A4': -9085137472318894808,
'A5': [-0.32359328866004944, -0.8620110750198364],
'A6': 29546,
'A7': 8877567346224788032,
'A8': -127}
Пример 2
Двоичные данные:
b'DAB"[\x01\xcd\xbd\x04\x00\x00\x00N\x00\x00\x00\x02\x00\x00\x00R\x00\x00\xdb'
(b'\\v?\xe5n\x8e\tA\xf69f\xe8 <y\x17\xac#\xad\x88\x00\x00\x00U\xac\xc6\x04\x99'
b'\xf5 \x00\xe0\n\xe9KN\xf1E\x9a\x02\x00\xa6\x00\xd2\xff$\xfa\nEzY\x8bz7hu'
b'gw\x015\x16\xbf]\xfe\x99\x1c\xde\x9eL Ega\x8f\xabP4\xb7\x0b6A\xa3>\r{kY\xb9'
b'0\xc6\xef\x7f\xc0\xed\x1b\xb3JBF\xf2\x01\x9a1\x94<\xd3\x9b\x1efc\x9bH'
b'es\xca\xbdu\x18v\xff\xc0\xdf\xda<f\t@?\xce2w/\x03\x00|\x00\x00\x00\x12S'
b'\xc0\xa76\xba\x88>"\x94\r\xbe')
Результат разбора:
'A1': -0.10010024160146713,
{'A2': {'B1': 'hugw',
'B2': [{'C1': -0.5867462754249573,
'C2': 93,
'C3': 4981065433086728702,
'C4': 844200976235585895},
'C1': 0.3188568949699402,
{'C2': 13,
'C3': 9218804874821069691,
'C4': -989030179561280064}],
'B3': 0,
'B4': {'D1': 0.9623543620109558, 'D2': 160329445, 'D3': 1715074625},
'B5': 2033983720,
'B6': -1390171113},
'A3': {'E1': {'F1': -38816652811668635,
'F2': [0.02671802043914795, 0.7501434087753296],
'F3': 796340942,
'F4': [2486278657, 513528636, 1218143078],
'F5': -1480568046},
'E2': 80129109,
'E3': 2160025},
'A4': -7330187499892307232,
'A5': [0.26704567670822144, -0.1382603943347931],
'A6': 65490,
'A7': 8830249876069218852,
'A8': 55}
Задача №12
Реализовать разбор двоичного формата данных. Данные начинаются с сигнатуры 0x4d 0x5a 0x46 0x57
, за которой следует структура
A. Порядок байт: от старшего к младшему. Адреса указаны в виде смещений от начала данных. В решении предлагается использовать модуль
struct.
Структура A:
Поле | Описание |
---|---|
1 | Размер (uint32) и адрес (uint16) массива char |
2 | Адрес (uint32) структуры B |
3 | Структура D |
4 | int8 |
5 | int32 |
Структура B:
Поле | Описание |
---|---|
1 | int64 |
2 | uint16 |
3 | uint64 |
4 | Массив адресов (uint16) структур C, размер 3 |
Структура C:
Поле | Описание |
---|---|
1 | Размер (uint32) и адрес (uint16) массива int32 |
2 | int8 |
Структура D:
Поле | Описание |
---|---|
1 | uint32 |
2 | int16 |
3 | Размер (uint32) и адрес (uint32) массива uint32 |
4 | double |
Ниже показаны примеры разбора двоичного формата.
Пример 1
Двоичные данные:
b'MZFW\x00\x00\x00\x02\x00)\x00\x00\x00XF\x19\t_\xda^\x00\x00\x00\x03'
(b'\x00\x00\x00p\xbf\xcb\xfd\x14\xef\x06 h\x17*\xffP\x8fia3%y\x82\xfc'
b'\x04\x07\xd2\x00\x00\x00\x02\x00+K\xb3\xcc\xb3\xd8\xb8\xc9\x95_\x00\x00'
b'\x00\x02\x00:\x10\x15k(\x12D}\x891\x00\x00\x00\x02\x00I^\xc1\x8f\xbb\x99'
b'\x0c\x04\x94yU\xac\xa8\xc3\xea3C\xdbh$\x003\x00B\x00QU\xb0\x04\xb3'
b'\xdb\x18l\xf3\x1a\xceDk')
Результат разбора:
'A1': 'ia',
{'A2': {'B1': -4499171236713819015,
'B2': 21932,
'B3': 12160820924733155364,
'B4': [{'C1': [858093954, -66844718], 'C2': 75},
'C1': [-1278430248, -1194748577], 'C2': 16},
{'C1': [359344146, 1149077809], 'C2': 94}]},
{'A3': {'D1': 1176045919,
'D2': -9634,
'D3': [1437598899, 3675811059, 449725547],
'D4': -0.21866094275560788},
'A4': 23,
'A5': 721375375}
Пример 2
Двоичные данные:
b'MZFW\x00\x00\x00\x03\x00)\x00\x00\x00Y\x10\xa52\xcf\xb4\xe0\x00\x00\x00\x06'
(b'\x00\x00\x00q\xbf\xce\xaf8\xd8\x1cA \xd2\xbd\xbc/\x87zstD\x909\x97\xdd#$\xef'
b'\x00\x00\x00\x02\x00,u\x17^Wn\xdd|/?\x00\x00\x00\x02\x00;t:\x9c'
b'\xe5\x96\xc1\x94\xec3\x00\x00\x00\x02\x00J#\xbe\x80\xd6U\x8c\xbd\xb4'
b'\xab\xf1\xc9\xc6 G\xd3\x12{\x17\xf1\x004\x00C\x00R\xc7\x8c\x17w\xa8\xb7\xf9'
b'\xccd\x96\x88\x17\x9b\xf62\xef;\x02|\xa2\xe2\xe5D\x92')
Результат разбора:
'A1': 'zst',
{'A2': {'B1': -4719536746562472789,
'B2': 61897,
'B3': 14276489790638200817,
'B4': [{'C1': [1150302615, -584899345], 'C2': 117},
'C1': [392058734, -579064001], 'C2': 116},
{'C1': [983360918, -1047204813], 'C2': 35}]},
{'A3': {'D1': 279261903,
'D2': -19232,
'D3': [3347847031,
2830629324,
1687586839,
2616603375,
990018722,
3806676114],
'D4': -0.23972235252632235},
'A4': -46,
'A5': -1111740537}
Задача №12
Реализовать разбор двоичного формата данных. Данные начинаются с сигнатуры 0x55 0x57 0x59 0x55
, за которой следует структура
A. Порядок байт: от младшего к старшему. Адреса указаны в виде смещений от начала данных. В решении предлагается использовать модуль
struct.
Структура A:
Поле | Описание |
---|---|
1 | int16 |
2 | Адрес (uint32) структуры B |
3 | Структура C |
4 | int16 |
5 | uint64 |
6 | Размер (uint32) и адрес (uint16) массива адресов (uint16) структур D |
Структура B:
Поле | Описание |
---|---|
1 | uint64 |
2 | Размер (uint32) и адрес (uint32) массива char |
Структура C:
Поле | Описание |
---|---|
1 | uint8 |
2 | uint8 |
3 | float |
4 | int8 |
5 | float |
6 | uint64 |
7 | Массив char, размер 6 |
Структура D:
Поле | Описание |
---|---|
1 | Размер (uint16) и адрес (uint16) массива int8 |
2 | Массив int16, размер 8 |
3 | int64 |
Ниже показаны примеры разбора двоичного формата.
Пример 1
Двоичные данные:
b'UWYU\x0c\\6\x00\x00\x009;\xae\x8c\n>\xbdp.\x90=\xcb\xcd\xa6e\x0fZ\xf1\x9bpra'
(b'bou(\x8b,\xe8\x1aZ\xf3\xfa\x8a\xb2\x03\x00\x00\x00\xa5\x00stq{\x12'
b'\\C\x1e\xf8 ]\x03\x00\x00\x003\x00\x00\x00\x1f\x03\xee\x9e\x04\x00'
b"F\x00\xa6\xb9\xa1\xb5\xb6'\xe4\xb6%\xa0\xf4\x00 \x0e\xf1\x81H\xa9"
b'\x19\xb1\xef\xb5\x90\xb3\xde\x92mV\x04\x00f\x00\xa9\x12\xaeg\xb3\xc1'
b'\xd1|\x92\x01\x19g=\xd3\r\x1c\xdb\x82\x95\xd9^\x86\x8f5\xcd\xa6'
b'\xfc\x03\x00\x86\x00\xa4\xbax\x10$\xe1\xf9-}\x02h\xf3\x8f\xb9H6Y\x96\x0b'
b'\xca5\xfae\xf2J\x00j\x00\x89\x00')
Результат разбора:
'A1': 23564,
{'A2': {'B1': 6710636253644853883, 'B2': 'stq'},
'A3': {'C1': 57,
'C2': 59,
'C3': 0.13530227541923523,
'C4': -67,
'C5': 0.07040107250213623,
'C6': 11236861567442537931,
'C7': 'prabou'},
'A4': -29912,
'A5': 12865371208632952876,
'A6': [{'D1': [31, 3, -18, -98],
'D2': [-18010, -19039, 10166, -18716, -24539, 244, 3616, -32271],
'D3': -5507702303201056440},
'D1': [-34, -110, 109, 86],
{'D2': [4777, 26542, -15949, 31953, 402, 26393, -11459, 7181],
'D3': 3859451147615306459},
'D1': [-51, -90, -4],
{'D2': [-17756, 4216, -7900, 11769, 637, -3224, -18033, 13896],
'D3': -980102234953247143}]}
Пример 2
Двоичные данные:
b'UWYUJ\xaf5\x00\x00\x00\xe2\x8c\\\x0cy\xbf\x1bGT\xb9\xbe\xac\xa5='
(b'\xd2\xf5\x9f\x9d\xe1hcygsu<\xb32\x1c\x12\x18C\x87\xcfM\x02\x00\x00'
b'\x00\x87\x00bb\x084\x04\x95\x90\xd0F\xd1\x02\x00\x00\x003\x00\x00'
b'\x009\xdb\x9fg\x88\x05\x00E\x00x\x1a\x0b\xad\xa1\x81\x15\x1db/b\xd4Z\xd9'
b'\x81\xa47\xed\xc8\x99\x13j`V\x8ar`\x9e\xb2\x05\x00f\x00\xa6o\xef\xf4+d~k\xa4'
b'\xec\xc3\xb8U\xaf6q7\xb0w\x00x\xf6\xe67J\x00k\x00')
Результат разбора:
'A1': -20662,
{'A2': {'B1': 15079969721690633224, 'B2': 'bb'},
'A3': {'C1': 226,
'C2': 140,
'C3': -0.9728448390960693,
'C4': 27,
'C5': -0.3619711101055145,
'C6': 16257326108020417964,
'C7': 'hcygsu'},
'A4': -19652,
'A5': 5606848783335955506,
'A6': [{'D1': [57, -37, -97, 103, -120],
'D2': [6776, -21237, -32351, 7445, 12130, -11166, -9894, -23423],
'D3': 6224091317443030327},
'D1': [-118, 114, 96, -98, -78],
{'D2': [28582, -2833, 25643, 27518, -4956, -18237, -20651, 28982],
'D3': 4028177911993839671}]}
Задача №12
Реализовать разбор двоичного формата данных. Данные начинаются с сигнатуры 0xa 0x44 0x5a 0x55 0x54
, за которой следует
структура A. Порядок байт: от старшего к младшему. Адреса указаны в виде смещений от начала данных. В решении предлагается использовать
модуль struct.
Структура A:
Поле | Описание |
---|---|
1 | Адрес (uint16) структуры B |
2 | Массив int16, размер 5 |
Структура B:
Поле | Описание |
---|---|
1 | int16 |
2 | int32 |
3 | Массив char, размер 3 |
4 | float |
5 | Массив структур C, размер 2 |
6 | Структура D |
7 | int64 |
Структура C:
Поле | Описание |
---|---|
1 | uint32 |
2 | uint16 |
3 | double |
4 | int32 |
5 | int64 |
Структура D:
Поле | Описание |
---|---|
1 | int32 |
2 | uint8 |
3 | double |
4 | int8 |
5 | float |
6 | Массив int8, размер 4 |
7 | uint16 |
Ниже показаны примеры разбора двоичного формата.
Пример 1
Двоичные данные:
b'\nDZUT\x00\x11\x82\xf3\x0e\r\x90EM={dZ~L\xdfT6fpd\xbf\x197\x17y\x16'
(b'\x96\x94\xa0\x1a\xbf\xdf#\xe0-Z\x04(\xc9\xa14@\xa7+\xed\x12G\xcaA\r'
b'\x9c\xf5\xc5\xf6yD\xbf\xca\xc7\xe5\x04\xc5\x7f8\xde\xf0\x10\xe4\xfc\x93'
b'\xdeo\xf4\xc1z\xbf\xdb\xe0Zp\x9e?\xc6\xa4\xc3\xed\xff\x80\xb0D'
b'\xbd\x9d\xa4\xfe\xfd\x0f\xdf\xe5\xa5\xc98a;\x185\xbb\x1d\xfc')
Результат разбора:
'A1': {'B1': 23166,
{'B2': 1289704502,
'B3': 'fpd',
'B4': -0.5984968543052673,
'B5': [{'C1': 2031523476,
'C2': 40986,
'C3': -0.48656467846746176,
'C4': -912182208,
'C5': -6400761782607396595},
'C1': 2633352694,
{'C2': 31044,
'C3': -0.20922529919607213,
'C4': -554692380,
'C5': -246608982146188609}],
'B6': {'D1': -606053776,
'D2': 158,
'D3': 0.17690323945044417,
'D4': 68,
'D5': -0.07697485387325287,
'D6': [-3, 15, -33, -27],
'D7': 42441},
'B7': 4062593314031607292},
'A2': [-32013, 3597, -28603, 19773, 31588]}
Пример 2
Двоичные данные:
b'\nDZUT\x00\x11\x81A\x19}\x9fRBv\xecR>\xcd\xd7e=\xa2tcm>\xcd8\xa0\xe3\x1a'
(b'\xfb\xee}\x15?\xc8\x8b\x1b\x87\xcc"x\xce\xae \xb3\xf8\xad\xadM9%I\xc7'
b'\x9c\xc6\xb5:f\x9a?\xe4T\xf0\\\xb2\xf7\xa0^x\xb8\xcfQ,\rlJ\x9b\xa6h\xc0\xc3'
b'\xd8\xe4\xa0\xbf\xb38\xcc\x93c\x13 \xc4>\x17\xc8C\xb7\xef\xb6Fa\xe9\x83\xc2'
b'\x9e\x06\x95\xfb\\\t')
Результат разбора:
'A1': {'B1': 16077,
{'B2': -681230942,
'B3': 'tcm',
'B4': 0.40082263946533203,
'B5': [{'C1': 3810196462,
'C2': 32021,
'C3': 0.1917452252457854,
'C4': -827449165,
'C5': -527575034149647929},
'C1': 2630268218,
{'C2': 26266,
'C3': 0.6353685198334809,
'C4': 1584969935,
'C5': 5849064774806775400}],
'B6': {'D1': -1060906780,
'D2': 160,
'D3': -0.07508543585124672,
'D4': -60,
'D5': 0.148224875330925,
'D6': [-73, -17, -74, 70],
'D7': 25065},
'B7': -8952419358135854071},
'A2': [-32447, 6525, -24750, 17014, -5038]}
Задача №12
Реализовать разбор двоичного формата данных. Данные начинаются с сигнатуры 0x44 0x4c 0x54 0x89
, за которой следует структура
A. Порядок байт: от старшего к младшему. Адреса указаны в виде смещений от начала данных. В решении предлагается использовать модуль
struct.
Структура A:
Поле | Описание |
---|---|
1 | Размер (uint16) и адрес (uint16) массива адресов (uint16) структур B |
2 | uint8 |
3 | Структура C |
4 | Массив int32, размер 5 |
Структура B:
Поле | Описание |
---|---|
1 | uint32 |
2 | int8 |
Структура C:
Поле | Описание |
---|---|
1 | Адрес (uint16) структуры D |
2 | Адрес (uint16) структуры F |
3 | double |
4 | uint64 |
Структура D:
Поле | Описание |
---|---|
1 | Массив int8, размер 6 |
2 | Адрес (uint16) структуры E |
3 | float |
4 | int32 |
Структура E:
Поле | Описание |
---|---|
1 | uint64 |
2 | double |
3 | int32 |
4 | uint8 |
Структура F:
Поле | Описание |
---|---|
1 | Массив uint32, размер 2 |
2 | int64 |
3 | int16 |
4 | Массив int8, размер 6 |
5 | uint8 |
Ниже показаны примеры разбора двоичного формата.
Пример 1
Двоичные данные:
b'DLT\x89\x00\x02\x00;\x9e\x00T\x00d?\x91\xe5\xafB\x1b\xef\x80\xe4\x902'
(b" \xb6\x1fP\xd9\xd4\x14\xd9\x12;\x06\x0fx{\xd7q\xb6X\xf7^\x16'>u"
b'\xd4\x16\xba\x90\xeb\x80K\x10^\xa10\x001\x006\x88\x84\xe6\xb6\x1a'
b'\xa0\x14\x1b\xbf\xdd\xed\x00\x0fY\x1et:\xff\xe0\xe4\x1a\x8c\x85\\}_>\x00?'
b'\xbeA\xb8I_G\xc9Q\xbb\xc3\x1d\x08\xee>p\xb0w\x98l\x8d\x13\x90\xb7\xfb'
b'\xe2\xc4;\xea\xc7F\x10Xb')
Результат разбора:
'A1': [{'B1': 381325547, 'B2': -128}, {'B1': 1259364001, 'B2': 48}],
{'A2': 158,
'A3': {'C1': {'D1': [-116, -123, 92, 125, 95, 62],
'D2': {'E1': 9837241155889140763,
'E2': -0.4675903463253015,
'E3': 989847780,
'E4': 26},
'D3': -0.18917955458164215,
'D4': 1598540113},
'C2': {'F1': [3150126344, 3997069488],
'F2': 8617757240147884027,
'F3': -7484,
'F4': [59, -22, -57, 70, 16, 88],
'F5': 98},
'C3': 0.017477739725094477,
'C4': 16469718953369751769},
'A4': [-736831214, 990252920, 2077716918, 1492606486, 658404820]}
Пример 2
Двоичные данные:
b'DLT\x89\x00\x02\x00;H\x00T\x00d?\xe6\xa0\xde\x8a\x98\x95&{\x89\x89j\x1e\x1bb'
(b'a\xb5w\xe1\x86\x0cC\x8a\x95\x19\xc70\xdc\x8dh\x01to9T$\x0e%|\x89\xc0\\\x06'
b'\x05*\x04\x001\x006A\xab8\xff\x04\\rH\xbf\xdd\x9f\x19\x95\x04a8\xb7'
b'\xed\x85\x8c\xfa\xb8\xa5/\x1d\x0b\xee\x00?\xbf?[\xbc\xb0\x0f&\xa7\xb06fY'
b'\x93\x8c\xbb\x01\xc7\xde\x06\xf7\x13"\xc3\xb7\xd21%\xc5}Ms!\x91')
Результат разбора:
'A1': [{'B1': 237337737, 'B2': -64}, {'B1': 1543898410, 'B2': 4}],
{'A2': 72,
'A3': {'C1': {'D1': [-72, -91, 47, 29, 11, -18],
'D2': {'E1': 4731938501423821384,
'E2': -0.46283568909122463,
'E3': -1209170548,
'E4': 250},
'D3': -0.7474935054779053,
'D4': -1341184345},
'C2': {'F1': [2956355161, 2475473665],
'F2': -4044787757084392521,
'F3': -11727,
'F4': [37, -59, 125, 77, 115, 33],
'F5': 145},
'C3': 0.7071373660043363,
'C4': 8901797227339145825},
'A4': [-1250434682, 205752981, 432484572, -1922563724, 1866028068]}
Задача №12
Реализовать разбор двоичного формата данных. Данные начинаются с сигнатуры 0xc9 0x46 0x41 0x46
, за которой следует структура
A. Порядок байт: от младшего к старшему. Адреса указаны в виде смещений от начала данных. В решении предлагается использовать модуль
struct.
Структура A:
Поле | Описание |
---|---|
1 | Размер (uint32) и адрес (uint16) массива char |
2 | float |
3 | Адрес (uint16) структуры B |
4 | double |
5 | Адрес (uint32) структуры D |
Структура B:
Поле | Описание |
---|---|
1 | int8 |
2 | Размер (uint32) и адрес (uint32) массива структур C |
3 | Размер (uint16) и адрес (uint32) массива int32 |
4 | Массив int16, размер 3 |
Структура C:
Поле | Описание |
---|---|
1 | double |
2 | int16 |
Структура D:
Поле | Описание |
---|---|
1 | double |
2 | uint16 |
3 | uint16 |
4 | float |
5 | int8 |
6 | uint16 |
7 | Размер (uint16) и адрес (uint32) массива float |
Ниже показаны примеры разбора двоичного формата.
Пример 1
Двоичные данные:
b'\xc9FAF\x02\x00\x00\x00\x1c\x00\xba\x17^\xbfF\x00\x1a\xbe\xe9\x06'
(b'\xac\xff\xe0?o\x00\x00\x00kj\x94p\xdat1i\xd6\xbf\xd8\xe2\xf0\t`k'
b'\x01\xf9\xd2?,e\x8c\xb0\xa2\xba2[\xd1\x11\x1e2\xaa\xfe\xb6Q\x8dey\xf5'
b'h\xa3\xb9\x02\x00\x00\x00\x1e\x00\x00\x00\x05\x002\x00\x00\x00\x9f\x03\x19'
b'r \xdb]*%?w\xdeG\xbf\x08B{\xbd2\xb4f=\x0f7T\xbd\xbe\x01d\xee\xc4O\xec? '
b'Z\x82\x0c\x1b\xb9\x00\xbf\xd9PR\x05\x00[\x00\x00\x00')
Результат разбора:
'A1': 'kj',
{'A2': -0.8675495386123657,
'A3': {'B1': -71,
'B2': [{'C1': -0.35017048274472384, 'C2': -7464},
'C1': 0.29644809232573177, 'C2': 25900}],
{'B3': [-1163743092, 298933042, -22400482, 1703760310, -1553402503],
'B4': [927, 29209, -9440]},
'A4': 0.531209958555283,
'A5': {'D1': 0.8847374588076986,
'D2': 23072,
'D3': 3202,
'D4': -0.5028244853019714,
'D5': -39,
'D6': 21072,
'D7': [0.6451776623725891,
-0.7807382941246033,
-0.0613422691822052,
0.05632419139146805,
-0.05181032046675682]}}
Пример 2
Двоичные данные:
b'\xc9FAF\x02\x00\x00\x00\x1c\x00I\x1bR\xbf>\x00\xcc\xadp\xcb\xdc\x1d\xe8?'
(b'g\x00\x00\x00cq\x807\x04\xc6\xc7\x7f\xeb\xbf\xc9\xa0\xd6i.n\x18&\xe7?'
b'\x9fG\xa7\xd6\x00c\x1b\x93dU\xedX\xd6,\xd5\x02\x00\x00\x00\x1e'
b"\x00\x00\x00\x03\x002\x00\x00\x00nI\xc0'\xbe\xb4\xc9\x0e\x19?x5\xd7\xbe["
b'\xc6\x0e?\x1b\xd6{?n\x1c\xb0>\xc0\x1dj\xaf\x9dt\x95?I{\xc0\xcap\x03L?='
b'Wz\x05\x00S\x00\x00\x00')
Результат разбора:
'A1': 'cq',
{'A2': -0.8207288384437561,
'A3': {'B1': -43,
'B2': [{'C1': -0.8593481891164032, 'C2': -24375},
'C1': 0.7234003211954654, 'C2': 18335}],
{'B3': [1660999335, 1432654619, 752244973],
'B4': [18798, 10176, -19266]},
'A4': 0.7536453221741168,
'A5': {'D1': 0.020952667075588627,
'D2': 31561,
'D3': 51904,
'D4': 0.7969274520874023,
'D5': 61,
'D6': 31319,
'D7': [0.5978818535804749,
-0.4203298091888428,
0.5577141642570496,
0.9837357401847839,
0.34396690130233765]}}
Задача №12
Реализовать разбор двоичного формата данных. Данные начинаются с сигнатуры 0x56 0x58 0x4a
, за которой следует структура A.
Порядок байт: от младшего к старшему. Адреса указаны в виде смещений от начала данных. В решении предлагается использовать модуль
struct.
Структура A:
Поле | Описание |
---|---|
1 | Массив адресов (uint32) структур B, размер 3 |
2 | int8 |
3 | Размер (uint32) и адрес (uint16) массива char |
4 | Структура C |
5 | Адрес (uint32) структуры D |
6 | Массив uint8, размер 3 |
Структура B:
Поле | Описание |
---|---|
1 | float |
2 | uint16 |
3 | double |
4 | int8 |
5 | uint32 |
6 | Размер (uint32) и адрес (uint32) массива char |
7 | int16 |
Структура C:
Поле | Описание |
---|---|
1 | float |
2 | uint32 |
3 | uint32 |
4 | int16 |
5 | uint16 |
6 | double |
7 | int16 |
Структура D:
Поле | Описание |
---|---|
1 | int32 |
2 | uint32 |
3 | float |
4 | int64 |
5 | int64 |
Ниже показаны примеры разбора двоичного формата.
Пример 1
Двоичные данные:
b'VXJ<\x00\x00\x00\\\x00\x00\x00{\x00\x00\x00\x02\x03\x00\x00\x00'
(b'\x98\x00\x84\xe8\xf3\xbe\xf3\x8d\xa4.O5\x13I<\xcf$6`\xa7\xce\xc9"\xdc'
b'\xcc?}\xc2\x9b\x00\x00\x00\xed6\x04ktyxo\xc4\xd5\xe2\xbd\xf4\xf7TV'
b'(\x95\x01\xf7\xe7?6\xbfK\xff\xdb\x05\x00\x00\x007\x00\x00\x00\xce0hub'
b'5\xf3\x18?\x19\\\xe4\xc4\x83=i\xe9\xef?\x95\x1fS\xf3H\x03\x00\x00\x00Y'
b"\x00\x00\x00\xac\xeauu]\xcb\xed\xbe\x90\xf9\xc0B\xb6\x13'|\xe1?\xbdo\xf4"
b'\xf4j\x02\x00\x00\x00y\x00\x00\x00g;zty_U\x02 J\xd3\x00\xcc\x9a\x99(?\x88'
b'-Vr\xeb\xd7\xec\xdaO4\xcbP\xdc\xb5\xf7\xc8')
Результат разбора:
'A1': [{'B1': -0.11075928807258606,
{'B2': 63476,
'B3': 0.7489021218522773,
'B4': 54,
'B5': 3690941375,
'B6': 'ktyxo',
'B7': 12494},
'B1': 0.5974610447883606,
{'B2': 23577,
'B3': 0.9972425652942118,
'B4': -107,
'B5': 1223906079,
'B6': 'hub',
'B7': -5460},
'B1': -0.4644421637058258,
{'B2': 63888,
'B3': 0.5464053521155492,
'B4': -67,
'B5': 1794438255,
'B6': 'uu',
'B7': 15207}],
'A2': 2,
'A3': 'zty',
'A4': {'C1': -0.4763833284378052,
'C2': 782536179,
'C3': 1225995599,
'C4': -12484,
'C5': 13860,
'C6': 0.22546801427716456,
'C7': -15747},
'A5': {'D1': 537023839,
'D2': 3422606154,
'D3': 0.6585937738418579,
'D4': -2671523072702009976,
'D5': -3965500989023505329},
'A6': [237, 54, 4]}
Пример 2
Двоичные данные:
b'VXJ9\x00\x00\x00Z\x00\x00\x00~\x00\x00\x00\x15\x07\x00\x00\x00\x9b\x00\n\x07'
(b'\x7f\xbf\x7fjj\xb2\x7f\xc1\xc3FD\xd4\x85\xd2\xf6xp\xf5\xf71\xe7?\x9ae'
b'\xa2\x00\x00\x00g\xc9\xebla\x00\x9c)\xbf\x8fy"y\x80\xc6\x83F\xe6\xbfX'
b'\x1e\xb3-\x9d\x02\x00\x00\x007\x00\x00\x00\xd4\x9eevmk\x90\x88\x16?\xdbz'
b'\xfc\xecW\xe9\xc8\xe0\xd1?7=$\xb6Q\x04\x00\x00\x00V\x00\x00\x00<\xd0zpjad'
b'mp\x8e}S?\x07\xfc|X<\xb1\x19\xa2\xe2?M_\xca@\xe8\x07\x00\x00\x00w\x00\x00'
b'\x00\xe2\xfaplugmke\x81{\r\xe7\x01\x80\xb2}\x18\xfb\xc4>=\xaaQ|n\xad\n\xdbjv'
b'C]%r4\xa8')
Результат разбора:
'A1': [{'B1': -0.66253662109375,
{'B2': 31119,
'B3': -0.6961077572812295,
'B4': 88,
'B5': 2637017886,
'B6': 'la',
'B7': -24876},
'B1': 0.5880212783813477,
{'B2': 31451,
'B3': 0.2793447760338521,
'B4': 55,
'B5': 1370891325,
'B6': 'evmk',
'B7': -12228},
'B1': 0.8261345624923706,
{'B2': 64519,
'B3': 0.5822876416812188,
'B4': 77,
'B5': 3896560223,
'B6': 'zpjadmp',
'B7': -1310}],
'A2': 21,
'A3': 'plugmke',
'A4': {'C1': -0.9962011575698853,
'C2': 2993318527,
'C3': 1187234175,
'C4': -11196,
'C5': 53893,
'C6': 0.7248496812569829,
'C7': 26010},
'A5': {'D1': -418546815,
'D2': 2108850177,
'D3': 0.38472819328308105,
'D4': -2663125539592492483,
'D5': -6326306071744645526},
'A6': [103, 201, 235]}
Задача №12
Реализовать разбор двоичного формата данных. Данные начинаются с сигнатуры 0x4f 0x56 0x55 0x54 0xaf
, за которой следует
структура A. Порядок байт: от старшего к младшему. Адреса указаны в виде смещений от начала данных. В решении предлагается использовать
модуль struct.
Структура A:
Поле | Описание |
---|---|
1 | Структура B |
2 | uint16 |
3 | int32 |
4 | int32 |
5 | Массив float, размер 5 |
Структура B:
Поле | Описание |
---|---|
1 | Массив структур C, размер 5 |
2 | int8 |
3 | double |
4 | Массив uint16, размер 3 |
5 | uint16 |
Структура C:
Поле | Описание |
---|---|
1 | Структура D |
2 | Массив float, размер 4 |
3 | int8 |
Структура D:
Поле | Описание |
---|---|
1 | uint16 |
2 | uint8 |
Ниже показаны примеры разбора двоичного формата.
Пример 1
Двоичные данные:
b'OVUT\xaft\x1d\xd9\xbd\x88\x05\xa4>\xdc\xcf\x96>\xcfu\xad>o\x9e\x9e'
(b'\x1c\xa4J\xc9\xbf\x14\xe2)>\xe0{\x95\xbf_\xd5?\xbf\r\x1c BkW\xf9'
b'\xbfI\xa1\xe4>\x89\x13/>\xc8\xd4T\xbf\x06\xb6H\xf1\x1cA\xa9\xbf/\xdfL'
b'\xbf{\x96\xa3\xbf_\xda\xd8>D\xa827\x98\x14\x9e\xbd`\x00\xa8>\xe8\xfcm>\xc2<I'
b'\xbfiT\xcavy?\xd2\xb1Wf2\xbf\x18P\x97\xf0\x7fv#}[\xe4t\x82\x82\x11\xac'
b'\xc6\x8d\rF?\x1e\x8aY?>\xfb\x14\xbeD\xe7\xc5?\x10N\xdd\xbe\xf3\xad\xc2')
Результат разбора:
'A1': {'B1': [{'C1': {'D1': 29725, 'D2': 217},
{'C2': [-0.06641700863838196,
0.4312712550163269,
0.4051946699619293,
0.23400351405143738],
'C3': 28},
'C1': {'D1': 42058, 'D2': 201},
{'C2': [-0.5815759301185608,
0.4384428560733795,
-0.8743476271629333,
-0.5512104034423828],
'C3': 66},
'C1': {'D1': 27479, 'D2': 249},
{'C2': [-0.7876265048980713,
0.26772448420524597,
0.39224493503570557,
-0.5262188911437988],
'C3': -15},
'C1': {'D1': 7233, 'D2': 169},
{'C2': [-0.6870009899139404,
-0.9827672839164734,
-0.8744330406188965,
0.1920478641986847],
'C3': 55},
'C1': {'D1': 38932, 'D2': 158},
{'C2': [-0.05468812584877014,
0.45505085587501526,
0.3793661892414093,
-0.9114500284194946],
'C3': 118}],
'B2': 121,
'B3': 0.292074060252149,
'B4': [20631, 61567, 30243],
'B5': 32091},
'A2': 58484,
'A3': -2105405012,
'A4': -963834554,
'A5': [0.61929851770401,
0.746018648147583,
-0.19229038059711456,
0.5637033581733704,
-0.47593504190444946]}
Пример 2
Двоичные данные:
b'OVUT\xaf\xf7x\x8a\xbe7\x02C>\x9fY\xdb?X\x073>\xe5\x95\xaa0H\xd2d?nJ\xa8'
(b'\xbe\x89"\xf4\xbe\xac+0\xbf2\x94\x1d;\x8eUA?O\xae\xf3=R\xfeJ\xbe~\x1c,'
b"\xbf,<\xc8j\x86Tu\xbe\xac\xef\x19=\xa7\xbeu>\xd7\xd1\x9a>[\xe4+\x13'\x9c\x93"
b'\xbe\xb5\x08C\xbd\x82u\x0e?Q\xd6\xfe>\x81\x98x\xbd9\xbf\xec\xdf\xa3\xd5\x0b'
b'\xb5\x0e\xcf\x9a\x9b9\xd6\xa9\x01\\\xb7\x1d\xcc\xef\x10\x02\xa6\x86\x05\xb4'
b'\xbfD<[=\xed\xe4\x01\xbeH\x9dR>&\xea\xc8>v\xab\xe1')
Результат разбора:
'A1': {'B1': [{'C1': {'D1': 63352, 'D2': 138},
{'C2': [-0.17871956527233124,
0.31123241782188416,
0.843859851360321,
0.44840747117996216],
'C3': 48},
'C1': {'D1': 18642, 'D2': 100},
{'C2': [0.9308266639709473,
-0.2678447961807251,
-0.33626699447631836,
-0.6975725293159485],
'C3': 59},
'C1': {'D1': 36437, 'D2': 65},
{'C2': [0.8112632632255554,
0.051512040197849274,
-0.24815434217453003,
-0.6728024482727051],
'C3': 106},
'C1': {'D1': 34388, 'D2': 117},
{'C2': [-0.33776167035102844,
0.08190623670816422,
0.42152100801467896,
0.21473757922649384],
'C3': 19},
'C1': {'D1': 10140, 'D2': 147},
{'C2': [-0.35357865691185,
-0.06369982659816742,
0.819686770439148,
0.2531163692474365],
'C3': -67}],
'B2': 57,
'B3': -0.9022998009728853,
'B4': [53146, 39737, 54953],
'B5': 348},
'A2': 46877,
'A3': -856748030,
'A4': -1501166156,
'A5': [-0.7665459513664246,
0.11615753918886185,
-0.19591262936592102,
0.16300499439239502,
0.2408900409936905]}
Задача №12
Реализовать разбор двоичного формата данных. Данные начинаются с сигнатуры 0x4d 0x41 0x54
, за которой следует структура A.
Порядок байт: от старшего к младшему. Адреса указаны в виде смещений от начала данных. В решении предлагается использовать модуль
struct.
Структура A:
Поле | Описание |
---|---|
1 | double |
2 | Структура B |
3 | Массив структур C, размер 2 |
4 | Массив uint32, размер 8 |
Структура B:
Поле | Описание |
---|---|
1 | Размер (uint32) и адрес (uint16) массива char |
2 | float |
Структура C:
Поле | Описание |
---|---|
1 | Адрес (uint16) структуры D |
2 | double |
3 | Размер (uint16) и адрес (uint16) массива int8 |
4 | uint16 |
Структура D:
Поле | Описание |
---|---|
1 | int16 |
2 | int32 |
3 | double |
4 | uint64 |
5 | uint64 |
6 | uint32 |
7 | int16 |
8 | Размер (uint32) и адрес (uint16) массива int8 |
Ниже показаны примеры разбора двоичного формата.
Пример 1
Двоичные данные:
b'MAT?\xe3\x9a%\x1f\x0e)\x88\x00\x00\x00\x04\x00U\xbe\xa2\xdd\xab\x00[\xbf'
(b'\xe5s9\x9a\xa1\x99\x90\x00\x02\x00\x85\x16t\x00\x89?\xa4\x11q\xee'
b'\x92j\x00\x00\x02\x00\xb3\x99;h4\xa2\xf1\x08\xab\x17\x869\xc8\xdc'
b'Y\xec\xdd\x05\x87P\x1d\xf5\xe1VoJ\x8d\xb5\x16\xc7\xc6q9R\xaadbcfqA\x17'
b'\xfb\x1ck\xce\x93?\xec\x03\xc5/\xbf\xc2.\xad\xda\xe8]\x97\xa3)\xf4\x85\xe3\\'
b'u\xfa\x7fvo\x1d."\x9e 0\x00\x00\x00\x02\x00Y\xfb\x1bwg\xae\xae\x14\xd1@\x11?'
b'\xcdSV\xc2\x9du\xd8X/n\xb6a\x19o5\x9f\x01V4\xcf\xb3\xa9\x87\x9f*f\x8a\x02'
b'\xd8\x00\x00\x00\x02\x00\x87l\xae')
Результат разбора:
'A1': 0.6125665289448969,
{'A2': {'B1': 'dbcf', 'B2': -0.31809744238853455},
'A3': [{'C1': {'D1': 6139,
'D2': 476827283,
'D3': 0.8754602367972149,
'D4': 12527580802158111220,
'D5': 9647656488541320815,
'D6': 489562782,
'D7': 8240,
'D8': [113, 65]},
'C2': -0.6703155536786642,
'C3': [-5, 27],
'C4': 5748},
'C1': {'D1': -20818,
{'D2': 349257745,
'D3': 0.22910580160798477,
'D4': 6354419328835219253,
'D5': 11457533711830198663,
'D6': 2670356106,
'D7': 728,
'D8': [119, 103]},
'C2': 0.03919559514288906,
'C3': [108, -82],
'C4': 39227}],
'A4': [1748280049,
145430406,
969464921,
3973907847,
1344140769,
1450134157,
3038169030,
1899582122]}
Пример 2
Двоичные данные:
b'MAT\xbf\xde\x98\x89!\xe6\x98\x84\x00\x00\x00\x05\x00U\xbe\x05\x17\xf6\x00]?'
(b'\xab<\x14\xf9l\x19\xc0\x00\x02\x00\x87\xee\xac\x00\x8c?\xb0:C\x1f'
b"h\x8a\x80\x00\x02\x00\xb6\xfa\xb6}\x84+\xe4\xc6\x96l\n's\xe9v\x15\xdb\x1f"
b'\x87\xf7\xe0\x95v\xda\xabC&y0\x92\x9e\x01}\xe0Oxnkht\x04\xab%\x1f\xad\xae'
b'I\x95\x02\xbf\xef\xf4AtS8\x0eW8\xc4\x83d+\xfc\xeb\x13\\\x14JG\xf5\xc7Y\x1c'
b's\xa6\xa4\xb4\xaf\x00\x00\x00\x03\x00Z\x1aDXH\x80p)\x87\xa7\xae\xdb\xbf\xea'
b'A\xc4:;\xee,y\x17\xe1,R\x85f\x84\xef\xa9\x9dU$Cb\xba\xc2\x00\xcb\xe1uj'
b'\x00\x00\x00\x03\x00\x89\x8c\x9e')
Результат разбора:
'A1': -0.4780600386678844,
{'A2': {'B1': 'xnkht', 'B2': -0.12997421622276306},
'A3': [{'C1': {'D1': 8109,
'D2': -1370909438,
'D3': -0.9985663673376182,
'D4': 6284989348595891435,
'D5': 1395012293845436249,
'D6': 477341348,
'D7': -19281,
'D8': [4, -85, 37]},
'C2': 0.053192763754896344,
'C3': [26, 68],
'C4': 61100},
'C1': {'D1': 28713,
{'D2': -2019053861,
'D3': -0.8205281388649772,
'D4': 8725690383532910212,
'D5': 17269507235135054522,
'D6': 3254832097,
'D7': 30058,
'D8': [88, 72, -128]},
'C2': 0.0633890105896544,
'C3': [-116, -98],
'C4': 64182}],
'A4': [2105813988,
3331746826,
661907830,
366681991,
4158690678,
3668656934,
2033226398,
25026639]}
Задача №12
Реализовать разбор двоичного формата данных. Данные начинаются с сигнатуры 0xbc 0x4d 0x54 0x4b 0x45
, за которой следует
структура A. Порядок байт: от младшего к старшему. Адреса указаны в виде смещений от начала данных. В решении предлагается использовать
модуль struct.
Структура A:
Поле | Описание |
---|---|
1 | int64 |
2 | Размер (uint16) и адрес (uint16) массива адресов (uint16) структур B |
3 | uint32 |
4 | Структура C |
5 | Размер (uint16) и адрес (uint16) массива uint8 |
6 | uint8 |
Структура B:
Поле | Описание |
---|---|
1 | uint16 |
2 | uint8 |
Структура C:
Поле | Описание |
---|---|
1 | Размер (uint32) и адрес (uint32) массива char |
2 | int32 |
3 | Структура D |
Структура D:
Поле | Описание |
---|---|
1 | int64 |
2 | double |
3 | Массив float, размер 7 |
Ниже показаны примеры разбора двоичного формата.
Пример 1
Двоичные данные:
b'\xbcMTKE\xae\xc5@F:\xd8\xd7\xfd\x03\x00[\x008\xf6\xb3\xc3\x02\x00\x00'
(b'\x00a\x00\x00\x00W\xc7.\xafu8\xbao}\xe1\xe2\xe0\x12e\x0f\xf2+1\xe7'
b'\xbf\x82B\x19>u\xfcj\xbe\t=\x18?\xa5[\xac=\xf8\xf2\xf7=\x103_'
b'\xbf\x9f\x98\xd7>\x07\x00c\x00*\x89i\xd37\xd23\xd3\x81\xbdR\x00U\x00X'
b'\x00ap\xfd\xf6\xdd\x97\xe9\xb1\xf9')
Результат разбора:
'A1': -155417917322639954,
{'A2': [{'B1': 27017, 'B2': 211},
'B1': 53815, 'B2': 51},
{'B1': 33235, 'B2': 189}],
{'A3': 3283351096,
'A4': {'C1': 'ap',
'C2': -1355888809,
'C3': {'D1': -2241981735615448971,
'D2': -0.7247524001824408,
'D3': [0.14966776967048645,
-0.22947867214679718,
0.5946813225746155,
0.08415917307138443,
0.12106889486312866,
-0.8718729019165039,
0.42108628153800964]}},
'A5': [253, 246, 221, 151, 233, 177, 249],
'A6': 42}
Пример 2
Двоичные данные:
b'\xbcMTKE\xd6\xf4\x17\xf3\x19\x13L:\x02\x00X\x00\x8fT\x07\x02\x02\x00\x00'
(b'\x00\\\x00\x00\x00\xfe\xfdC\x8e\xba\x1c\xf7\xb7\x06NP\xc26\xd5\x8e'
b'\xb2\xc6\xf4\xef?&\x97\xc4>\xa0\xc5f?\x9e\xf0d?p\xff\xb2>\xd1\xba-'
b'>\n\xf2\x81\xbedZ??\x04\x00^\x00\x16L\xfcv\x11\xe3\xe7R\x00U\x00wd\x02\xd4'
b'\xbb\x10')
Результат разбора:
'A1': 4200753554603373782,
{'A2': [{'B1': 64588, 'B2': 118}, {'B1': 58129, 'B2': 231}],
'A3': 34034831,
'A4': {'C1': 'wd',
'C2': -1908146690,
'C3': {'D1': -4444967041451483974,
'D2': 0.9986299025974066,
'D3': [0.3839656710624695,
0.9014530181884766,
0.8942965269088745,
0.34960508346557617,
0.16965796053409576,
-0.2537997364997864,
0.7474730014801025]}},
'A5': [2, 212, 187, 16],
'A6': 22}
Задача №12
Реализовать разбор двоичного формата данных. Данные начинаются с сигнатуры 0xae 0x46 0x47 0x4b
, за которой следует структура
A. Порядок байт: от младшего к старшему. Адреса указаны в виде смещений от начала данных. В решении предлагается использовать модуль
struct.
Структура A:
Поле | Описание |
---|---|
1 | float |
2 | Размер (uint32) и адрес (uint32) массива char |
3 | Структура B |
4 | Размер (uint16) и адрес (uint16) массива uint8 |
5 | int16 |
Структура B:
Поле | Описание |
---|---|
1 | Массив структур C, размер 6 |
2 | Адрес (uint16) структуры D |
3 | int16 |
Структура C:
Поле | Описание |
---|---|
1 | uint64 |
2 | int8 |
Структура D:
Поле | Описание |
---|---|
1 | Размер (uint16) и адрес (uint16) массива int16 |
2 | double |
Ниже показаны примеры разбора двоичного формата.
Пример 1
Двоичные данные:
b'\xaeFGK\xd7b-\xbf\x03\x00\x00\x00P\x00\x00\x00\xe3\xcf\xc4h\xb7\x14H\x19'
(b'`/)\x0e\x9c\x04\xd5\xdc|\xc3J\x8f\x1e\xe6\xb0\xd8\x9c\x84\xd3\xfb'
b'\xa0\xb7\x94\x8b\x13\x11\xf2\xd6\x19\xf4Y\xa2y\x00\xd9\xd7\x8f\x1e\x01d'
b'\xd4\x0b\x88 \r\xfcY\x00(\xe2\x03\x00e\x00\x90\xcdeig\xc9VLU\xac'
b'\xa3\x03\x00S\x00p]\x026\xe4\x8a\xe9\xbf+\xc6:')
Результат разбора:
'A1': -0.6772894263267517,
{'A2': 'eig',
'A3': {'B1': [{'C1': 1821728827240665059, 'C2': 96},
'C1': 8997300371354167599, 'C2': -61},
{'C1': 9555750763659956042, 'C2': -45},
{'C1': 17442744321999085819, 'C2': -42},
{'C1': 15553463310515565593, 'C2': -113},
{'C1': 945905506137145630, 'C2': -4}],
{'B2': {'D1': [22217, 21836, -23636], 'D2': -0.7982045225971159},
'B3': -7640},
'A4': [43, 198, 58],
'A5': -12912}
Пример 2
Двоичные данные:
b'\xaeFGK\xf9\xb5\x0e\xbf\x03\x00\x00\x00P\x00\x00\x00\xd9\xa3<\xf6'
(b'\xab\xea\xfc\x8b#0\x11\x946\xbd\xf8\xb1\xe8y\x15Dp\x9d\xcaRfH \x93'
b"\xf7\x8f\xc3\xeb2y\xa6I'a\xd7\x17\xd0t\x01\x8d\xe7\x82&\xd5\xc9i\xbf\xa7"
b'\\OW\x00\x90\xb0\x03\x00c\x00\xf3\xd8kvp(\x06\xe9\xaa\x02\x00S\x00\xf0'
b'+L\x11\xcah\xd2?\xa4i+')
Результат разбора:
'A1': -0.5574641823768616,
{'A2': 'kvp',
'A3': {'B1': [{'C1': 10087195289694544857, 'C2': 35},
'C1': 16767456379225248048, 'C2': 121},
{'C1': 5216948248533550101, 'C2': 32},
{'C1': 11995675070657722259, 'C2': 73},
{'C1': 10160530671426560295, 'C2': -25},
{'C1': 6676515433678710402, 'C2': 79}],
{'B2': {'D1': [1576, -21783], 'D2': 0.28764583291257306},
'B3': -20336},
'A4': [164, 105, 43],
'A5': -9997}
Задача №12
Реализовать разбор двоичного формата данных. Данные начинаются с сигнатуры 0x41 0x5a 0x49 0x5c
, за которой следует структура
A. Порядок байт: от младшего к старшему. Адреса указаны в виде смещений от начала данных. В решении предлагается использовать модуль
struct.
Структура A:
Поле | Описание |
---|---|
1 | Размер (uint32) и адрес (uint32) массива char |
2 | int16 |
3 | float |
4 | int32 |
5 | Структура B |
6 | uint64 |
Структура B:
Поле | Описание |
---|---|
1 | int8 |
2 | Массив адресов (uint16) структур C, размер 7 |
3 | Размер (uint16) и адрес (uint32) массива float |
4 | Массив int8, размер 2 |
5 | double |
6 | int16 |
7 | Структура D |
8 | double |
Структура C:
Поле | Описание |
---|---|
1 | int8 |
2 | float |
Структура D:
Поле | Описание |
---|---|
1 | uint32 |
2 | int32 |
3 | uint16 |
4 | uint64 |
5 | int16 |
6 | int16 |
7 | int64 |
8 | uint8 |
Ниже показаны примеры разбора двоичного формата.
Пример 1
Двоичные данные:
b'AZI\\\x04\x00\x00\x00f\x00\x00\x00U <E\xda=\xad?\x90\xf4\x1aj\x00o\x00t'
(b'\x00y\x00~\x00\x83\x00\x88\x00\x06\x00\x8d\x00\x00\x00\x9dF\xb2\x89*'
b'\x90\xef\t\xef\xbf\xd0I\xdf\x84\r\xf8\xb6q\x02\x8e\xb8)\xbb2\xe0=Dt\x92'
b'\xd8\x00\x0b\xc8\x82\\\x15\xb6\x02\xad\x86\xdf\x7fK\xc8x\xee\r\xc8\xf2'
b'\xe1?K^\x16\xc4[\xc8|{umcp\t\x12\x8e\x00>\x99\xb0\xcd\xbf\xbdJ\xd1y\xdb'
b'\xbe\xca\xd6\xdc\xd9\xbdmo\xbc\r?=#\x15\xbb=\x85(\xdc9?\t\xe6W?k\xf5$?|\xcdI'
b'\xbfx\xb1\x06\xbf0\x19"?}\x80\xe6\xbd')
Результат разбора:
'A1': 'umcp',
{'A2': 8277,
'A3': 0.10657736659049988,
'A4': -191873107,
'A5': {'B1': 26,
'B2': [{'C1': 9, 'C2': 0.12554195523262024},
'C1': -103, 'C2': -0.09365403652191162},
{'C1': 74, 'C2': -0.4286637604236603},
{'C1': -54, 'C2': -0.10637824237346649},
{'C1': 109, 'C2': 0.5536565184593201},
{'C1': 61, 'C2': 0.09134890884160995},
{'C1': -123, 'C2': 0.726015567779541}],
{'B3': [0.843353807926178,
0.6443697810173035,
-0.7882916927337646,
-0.5261454582214355,
0.6331968307495117,
-0.11254975944757462],
'B4': [-99, 70],
'B5': -0.9699628654237158,
'B6': 18896,
'B7': {'D1': 4161635551,
'D2': -1912442442,
'D3': 10680,
'D4': 15605663495236891323,
'D5': 2816,
'D6': -32056,
'D7': 9214231440256275804,
'D8': 75},
'B8': 0.5608864090061383},
'A6': 8898207260234636875}
Пример 2
Двоичные данные:
b"AZI\\\x02\x00\x00\x00f\x00\x00\x00\x7f\t'3\xc9>\xdc\xdb'\xa5\xdeh\x00m\x00r"
(b'\x00w\x00|\x00\x81\x00\x86\x00\x06\x00\x8b\x00\x00\x00[UTq-\x80*]\xec'
b'\xbf+\xa1\xa4\xf0\x95\xca,\x1au0IWo\x04g\xe4\x1bX\xcf\xade\xbe\xfa\xf1M)\x96'
b'\x1c\xd8\x15\x9f\xb9\xee\xc8\x9et2E\x1e\xd3\xbf/\xe6\x95\xa8\x156;8ug'
b'A\xe6\xf6\x10\xbf\xa3\x1e\xb8\x9b>\x9bP\x8dA>\x92\xe7\xefO\xbf\xb5nEH'
b'?\x97\xa9W4>T73\xbe\xbe\xd0\x9f\x90<\xd4\x95\xf2>\x14\x9fj\xbf k\xf7\xbe\x8e'
b'@\xcd\xbe\x0c-\x96>')
Результат разбора:
'A1': 'ug',
{'A2': 2431,
'A3': 0.39296838641166687,
'A4': -1524114468,
'A5': {'B1': -34,
'B2': [{'C1': 65, 'C2': -0.5662673711776733},
'C1': -93, 'C2': 0.30413907766342163},
{'C1': -101, 'C2': 0.18901562690734863},
{'C1': -110, 'C2': -0.8122543692588806},
{'C1': -75, 'C2': 0.7823094129562378},
{'C1': -105, 'C2': 0.17611564695835114},
{'C1': 84, 'C2': -0.3714844882488251}],
{'B3': [0.017654329538345337,
0.47379934787750244,
-0.916489839553833,
-0.48323917388916016,
-0.40088313817977905,
0.2933124303817749],
'B4': [91, 85],
'B5': -0.8863728049723627,
'B6': -24277,
'B7': {'D1': 3398824100,
'D2': 812980780,
'D3': 22345,
'D4': 12524325965559956591,
'D5': -16795,
'D6': -3590,
'D7': -5071310637459166899,
'D8': 238},
'B8': -0.2987225525598487},
'A6': 4051891756400502319}
Задача №12
Реализовать разбор двоичного формата данных. Данные начинаются с сигнатуры 0xd7 0x53 0x47 0x44 0x45
, за которой следует
структура A. Порядок байт: от младшего к старшему. Адреса указаны в виде смещений от начала данных. В решении предлагается использовать
модуль struct.
Структура A:
Поле | Описание |
---|---|
1 | Массив структур B, размер 2 |
2 | Структура E |
Структура B:
Поле | Описание |
---|---|
1 | double |
2 | Адрес (uint16) структуры C |
3 | uint16 |
Структура C:
Поле | Описание |
---|---|
1 | int32 |
2 | Структура D |
3 | int16 |
4 | float |
5 | Массив uint8, размер 3 |
Структура D:
Поле | Описание |
---|---|
1 | Размер (uint32) и адрес (uint32) массива int32 |
2 | int8 |
Структура E:
Поле | Описание |
---|---|
1 | int16 |
2 | Массив int16, размер 7 |
3 | float |
4 | uint64 |
Ниже показаны примеры разбора двоичного формата.
Пример 1
Двоичные данные:
b'\xd7SGDE\x96\xfe\x94\x9a\xee\xd7\xed\xbfA\x00\x82\xe4@b\x83\xbb \xd3\xbf'
(b"?_\x00\xe6\x1eJ\xa0\xfe\x7f\xfd\x99\xcb#\x97t\xdf'\xf2\xfd\x80\x18\xf1\xaf["
b'\xbf}q\xec\xd9\xe3\xb5\xcfJ\x02\xd5\xccm\xa1\xea\xd2\xc6\x8cL\x0c'
b'\x0f\x02\x00\x00\x009\x00\x00\x00l\xda\xc5\xd2U!?\xff\xd9Y:8\xc4\xff\x19'
b'\x01\xfe\x1d\xe8\x83lm\x02\x00\x00\x00W\x00\x00\x00\xad0\xdcm\xb8'
b'\xdf\xbe\x13\x89\xd2')
Результат разбора:
'A1': [{'B1': -0.9326088923625828,
{'B2': {'C1': 252464268,
'C2': {'D1': [1842140418, -959255903], 'D2': 108},
'C3': -14886,
'C4': 0.6302157640457153,
'C5': [255, 217, 89]},
'B3': 58498},
'B1': 0.12431530549964354,
{'B2': {'C1': 1835828200,
'C2': {'D1': [-3917766, 503185689], 'D2': -83},
'C3': -9168,
'C4': -0.43695393204689026,
'C5': [19, 137, 210]},
'B3': 7910}],
'A2': {'E1': -24502,
'E2': [32766, -26115, 9163, 29847, 10207, -526, 6272],
'E3': -0.8581534028053284,
'E4': 5390727269204128125}}
Пример 2
Двоичные данные:
b'\xd7SGDE~,\xc5j\xa2W\xe0?A\x00v\n>;\xd5T\xd0\xda\xe0?c\x009\x912\rs'
(b'\xff\xac\x83\xa2\xb5\xe9w\x84l\xf8\xee\x873\xfdnL\xbf/\xe46q\x13,\xef'
b'\x15\xdb\xc7f\x0eW<D\x86\xb93r\xb7\x02\x00\x00\x009\x00\x00\x00h\xc2\xa5'
b'\xc6\xdde\xbf\xe5]\x97Y&r\xff\xd5 t6\x07J\xe2\xc7\xd2K"\xd7\x03\x00\x00\x00W'
b'\x00\x00\x00\xedq\x10)\x8aj\xbf3\xd2z')
Результат разбора:
'A1': [{'B1': 0.5106975636821429,
{'B2': {'C1': -1217252423,
'C2': {'D1': [241616859, -2042348457], 'D2': 104},
'C3': -23102,
'C4': -0.897915244102478,
'C5': [229, 93, 151]},
'B3': 2678},
'B1': 0.5267106682675615,
{'B2': {'C1': -685618222,
'C2': {'D1': [-9296295, 913580245, -941471225], 'D2': -19},
'C3': 4209,
'C4': -0.9161706566810608,
'C5': [51, 210, 122]},
'B3': 37177}],
'A2': {'E1': 3378,
'E2': [-141, -31828, -19038, 30697, 27780, -4360, 13191],
'E3': -0.7985685467720032,
'E4': 1580530456245756975}}
Задача №12
Реализовать разбор двоичного формата данных. Данные начинаются с сигнатуры 0x23 0x4e 0x4a 0x52
, за которой следует структура
A. Порядок байт: от младшего к старшему. Адреса указаны в виде смещений от начала данных. В решении предлагается использовать модуль
struct.
Структура A:
Поле | Описание |
---|---|
1 | Размер (uint16) и адрес (uint32) массива адресов (uint32) структур B |
2 | Размер (uint32) и адрес (uint16) массива uint16 |
3 | Адрес (uint16) структуры C |
4 | Адрес (uint16) структуры D |
Структура B:
Поле | Описание |
---|---|
1 | Размер (uint32) и адрес (uint16) массива char |
2 | uint64 |
3 | int8 |
4 | Размер (uint32) и адрес (uint16) массива int16 |
5 | double |
6 | uint16 |
Структура C:
Поле | Описание |
---|---|
1 | int8 |
2 | float |
3 | Размер (uint32) и адрес (uint32) массива int16 |
Структура D:
Поле | Описание |
---|---|
1 | int16 |
2 | double |
Ниже показаны примеры разбора двоичного формата.
Пример 1
Двоичные данные:
b'#NJR\x03\x00\xa0\x00\x00\x00\x07\x00\x00\x00\xac\x00\xbe\x00\xcb\x00evg\xc4'
(b'\x87\x9bn\xd9\xed\x18\xf5,\xa3\xc0\x83\x98y\x03\x00\x00\x00\x14\x00\xa6'
b'\xd8\x16 \xbe\xe3"\xd7 \x07\x00\x00\x00\x17\x00\xd4\xe0,F&@\xe0\xbf\xe5\x00'
b'nb\x86\xc9\x89k\xf9-G\xda\x83\x9dqV\xa3\xf2\x02\x00\x00\x00D\x00b\xdaG#\xfde'
b'c,\x0f\x07\x00\x00\x00F\x00\x805\xa7L&~\xb7?<\x1cojcp\xdf\x8e\xc6;\x16'
b'6\xd7\xf9\x036\x04\x00\x00\x00s\x00\x12!\xb8uDC\x93\n"\x05\x00\x00\x00'
b'w\x00(WD\xd1\x04\x85\xc8\xbf\xb1?%\x00\x00\x00T\x00\x00\x00\x81\x00\x00\x00'
b'\xdc\x90\r\x103\xe6\xbf3n\xbf,\x91A\x1b\xb9\xee\xda\xd7\x14\x8c\xf7\xee>\x02'
b'\x00\x00\x00\xba\x00\x00\x00i\xf8\xd8@\x08\x91BZ\xd4\xbf')
Результат разбора:
'A1': [{'B1': 'evg',
{'B2': 15502203273084328102,
'B3': 32,
'B4': [-30780, 28315, -4647, -2792, -23764, -31808, 31128],
'B5': -0.5078307505237043,
'B6': 229},
'B1': 'nb',
{'B2': 3198512298256226914,
'B3': 15,
'B4': [-13946, 27529, 11769, -9657, -25213, 22129, -3421],
'B5': 0.09176864024558107,
'B6': 7228},
'B1': 'ojcp',
{'B2': 762026723267584274,
'B3': 34,
'B4': [-28961, 15302, 13846, -1577, 13827],
'B5': -0.1915594121753028,
'B6': 16305}],
'A2': [37084, 4109, 58931, 13247, 49006, 37164, 6977],
'A3': {'C1': 20, 'C2': 0.466732382774353, 'C3': [-4423, -10278]},
'A4': {'D1': -1943, 'D2': -0.31800903476051934}}
Пример 2
Двоичные данные:
b'#NJR\x02\x00q\x00\x00\x00\x03\x00\x00\x00y\x00\x83\x00\x90\x00mpmefu~\x1a'
(b'\xf9#\xc6\xf9_\x97\x9a\t\xc0\x02\xe1\x05\x00\x00\x00\x14\x00\x8f{\x8a'
b'\xee\xa5\xec\x15\xf5q\x07\x00\x00\x00\x19\x00\xa8\xff\xb4\x05\\\xac\xd8?'
b',\x10ww\x95\xdc\x99\n\x1cC\x1e\x8d\xe3\x8d\x02\x00\x00\x00F\x00\xbe0]\x9d'
b"\xa3\xc9\xa0c\xbf\x05\x00\x00\x00H\x00\xb4|\xe7\xac\x84v\xd6?7Z'\x00\x00"
b'\x00R\x00\x00\x00\x19\xb2\xf6\x18\xa9\xd9\x17\xc1\x83-\x90|\xa8B\xbf'
b'\x02\x00\x00\x00\x7f\x00\x00\x00\xd9\x0c\x12\xa5\x0c\xb8\xbcg\xed?')
Результат разбора:
'A1': [{'B1': 'mpmef',
{'B2': 17660281711219080079,
'B3': 113,
'B4': [32373, -1766, -14813, 24569, -25961, -16375, -7934],
'B5': 0.3855199866993595,
'B6': 4140},
'B1': 'ww',
{'B2': 7178959510585553086,
'B3': -65,
'B4': [-9067, 2713, 17180, -29410, -29213],
'B5': 0.3509837807195695,
'B6': 23095}],
'A2': [45593, 6390, 55721],
'A3': {'C1': -112, 'C2': -0.7603833675384521, 'C3': [-16105, 11651]},
'A4': {'D1': 3289, 'D2': 0.9189132303919527}}
Задача №12
Реализовать разбор двоичного формата данных. Данные начинаются с сигнатуры 0x47 0x57 0x42 0x55
, за которой следует структура
A. Порядок байт: от младшего к старшему. Адреса указаны в виде смещений от начала данных. В решении предлагается использовать модуль
struct.
Структура A:
Поле | Описание |
---|---|
1 | int16 |
2 | int32 |
3 | int8 |
4 | Размер (uint32) и адрес (uint32) массива адресов (uint32) структур B |
5 | Структура D |
Структура B:
Поле | Описание |
---|---|
1 | Структура C |
2 | Массив char, размер 5 |
3 | int64 |
4 | uint8 |
5 | uint8 |
Структура C:
Поле | Описание |
---|---|
1 | double |
2 | int32 |
3 | uint16 |
Структура D:
Поле | Описание |
---|---|
1 | Массив float, размер 7 |
2 | Адрес (uint32) структуры E |
3 | uint32 |
Структура E:
Поле | Описание |
---|---|
1 | uint16 |
2 | Размер (uint32) и адрес (uint16) массива int32 |
Ниже показаны примеры разбора двоичного формата.
Пример 1
Двоичные данные:
b'GWBU\x87S#\xb7\xbb\xcaa\x02\x00\x00\x00q\x00\x00\x00n\x9f$\xbf\xe9'
(b'%\x0f\xbf\x98\xe9\t?c\x85\x03?\x1a\x8a)?\x8d9T?\x1e\xb3\x1f\xbf\x81'
b'\x00\x00\x00\xa8u\xc9A\xc0wDi%5\xa9?\xe4\xf4S\x7fE\x98ncncz|\xbc\xfa\r"\n'
b'\x03\xe2\x16\xd3\x8a\xba\xef\xde=\xea\xe7\xbfk]\t\xa0\x02\xf9xqimj\x81'
b'\x9c%\x8b\xde\xf8\xff(e\x937\x00\x00\x00T\x00\x00\x00\xc6\xa7oS\xac\x9f\x91'
b'\x8c1\xea\x02\x00\x00\x00y\x00')
Результат разбора:
'A1': 21383,
{'A2': -893667549,
'A3': 97,
'A4': [{'B1': {'C1': 0.049233597850828925, 'C2': 2136208612, 'C3': 38981},
'B2': 'ncncz',
'B3': -2160872254828004228,
'B4': 22,
'B5': 211},
'B1': {'C1': -0.7473439554431291, 'C2': -1609998997, 'C3': 63746},
{'B2': 'xqimj',
'B3': 2954353515279260801,
'B4': 101,
'B5': 147}],
'A5': {'D1': [-0.6430577039718628,
-0.5591722130775452,
0.5387206077575684,
0.5137540698051453,
0.6622635126113892,
0.8290031552314758,
-0.6238268613815308],
'D2': {'E1': 59953, 'E2': [1399826374, -1936613460]},
'D3': 1103721896}}
Пример 2
Двоичные данные:
b'GWBU\xb2|Wy\x02[|\x02\x00\x00\x00q\x00\x00\x00\x0f\x14p>6\x88a\xbe\x99'
(b'\\O\xbf\xdd\xceH\xbf\x18\x8d8?\xb6\xe7z?\x04\x91\x10?\x81\x00\x00\x00\xc7'
b"\x98\xf8(H\xd6\xce'^r\xef?\x1e\xc6?gnGsfpdpT\xdb|\x94\xbdWPJ\x06\xcb"
b'l\x92\x1b\xcf\xa3\xa5\xdb\xbf\x10^l\xabH\xacsbhgiR\x00\x81\x17\x01'
b'\x02\xdb\xf8W\xe77\x00\x00\x00T\x00\x00\x00\xf7l\x82\xb6\xc1\xd3\xed'
b'*\x1a\x10\x02\x00\x00\x00y\x00')
Результат разбора:
'A1': 31922,
{'A2': 1526888791,
'A3': 124,
'A4': [{'B1': {'C1': 0.9827109124659694, 'C2': 1732232734, 'C3': 18286},
'B2': 'sfpdp',
'B3': 5354876428695165780,
'B4': 6,
'B5': 203},
'B1': {'C1': -0.4319848558937227, 'C2': -1418961392, 'C3': 44104},
{'B2': 'sbhgi',
'B3': -514815528691236782,
'B4': 87,
'B5': 231}],
'A5': {'D1': [0.2344515174627304,
-0.22024616599082947,
-0.8100066781044006,
-0.7844064831733704,
0.7209029197692871,
0.9800981283187866,
0.5647127628326416],
'D2': {'E1': 4122, 'E2': [-1232966409, 720229313]},
'D3': 687380679}}
Задача №12
Реализовать разбор двоичного формата данных. Данные начинаются с сигнатуры 0xd9 0x4c 0x57 0x57 0x58
, за которой следует
структура A. Порядок байт: от старшего к младшему. Адреса указаны в виде смещений от начала данных. В решении предлагается использовать
модуль struct.
Структура A:
Поле | Описание |
---|---|
1 | Массив адресов (uint16) структур B, размер 3 |
2 | float |
3 | Размер (uint32) и адрес (uint16) массива uint64 |
4 | uint16 |
5 | uint16 |
Структура B:
Поле | Описание |
---|---|
1 | int16 |
2 | Размер (uint32) и адрес (uint16) массива char |
3 | Структура C |
4 | int32 |
5 | Адрес (uint32) структуры D |
6 | Массив uint8, размер 5 |
7 | uint16 |
8 | int8 |
Структура C:
Поле | Описание |
---|---|
1 | uint16 |
2 | uint32 |
3 | float |
4 | uint16 |
Структура D:
Поле | Описание |
---|---|
1 | uint16 |
2 | uint8 |
Ниже показаны примеры разбора двоичного формата.
Пример 1
Двоичные данные:
b'\xd9LWWX\x00 \x00J\x00v\xbfL\x83M\x00\x00\x00\x03\x00\x9a\xa0\x8a\n\xc4etu'
(b'l\xc5\xda\x81^w\x00\x00\x00\x04\x00\x19J-@\xea\xd4\x7f>V-cB\xdb'
b'\xf6\\\xe6\xbc\x00\x00\x00\x1d\x18\xbe\x81\xb9u*\xf9\xcatko\x1e\xa1\x07\xdei'
b'\x00\x00\x00\x03\x00D\x1e\x88\xa59\xbb\xcb?t\xc2\x93\xad\xf9\x8c\x9c'
b'\xb3\x1e\x00\x00\x00G\xa7\x98\x82\xc1\n\xe2;\xebrmkxo\xfci\x12%o'
b'\x00\x00\x00\x05\x00n(\xd1\xa1\xa8H9\xbfV\xb6\x01:\xb6m6e\x14\x00\x00'
b'\x00sy\xedKh\x94G[\x03\x1a\x8e\xb3\xeb\x0277\xce\xb3t\xd9_\xaaAj\x06\x1ae'
b'9\x08\xea\x96\xaa\xa0')
Результат разбора:
'A1': [{'B1': 24183,
{'B2': 'etul',
'B3': {'C1': 18989,
'C2': 1089131647,
'C3': 0.20915751159191132,
'C4': 17115},
'B4': -161683780,
'B5': {'D1': 50650, 'D2': 129},
'B6': [24, 190, 129, 185, 117],
'B7': 11001,
'B8': -54},
'B1': -8599,
{'B2': 'tko',
'B3': {'C1': 7816,
'C2': 2772024267,
'C3': 0.956093966960907,
'C4': 44537},
'B4': -1935887586,
'B5': {'D1': 7841, 'D2': 7},
'B6': [167, 152, 130, 193, 10],
'B7': 57915,
'B8': -21},
'B1': 9583,
{'B2': 'rmkxo',
'B3': {'C1': 10449,
'C2': 2712160313,
'C3': -0.8387146592140198,
'C4': 15030},
'B4': 1832281364,
'B5': {'D1': 64617, 'D2': 18},
'B6': [121, 237, 75, 104, 148],
'B7': 18267,
'B8': 3}],
'A2': -0.7988784909248352,
'A3': [1913664713614899150, 12931199434989070854, 1901989128092166816],
'A4': 41098,
'A5': 2756}
Пример 2
Двоичные данные:
b'\xd9LWWX\x00\x1f\x00K\x00t=\xf8}:\x00\x00\x00\x03\x00\x98\xfb\r\xb5\xe5tfr'
(b'\x8cw\x97=\xe7\x00\x00\x00\x03\x00\x19\xed\x1aR\xb5\xddd?A\\\x0fv\x1c\xfe'
b'\xec`\x8b\x00\x00\x00\x1c\xfdd\t\x9c\xb6\x9d0\x1cajioi\xcf\xff\xd4\xcb'
b"\x19\x00\x00\x00\x05\x00C\xfc\x86 [\x05\xca\xbf.Q\xf29'\xda\x91f=\x00"
b'\x00\x00H\xe8\xd9\xbc\xb5\x18\x03\xab\xacpi\xe3\xb4>\xa0\xd6\x00\x00'
b'\x00\x02\x00o\x1d`ZY\x16@\xbe\xbe\xda\xf1)\xca.\x9bI\xc5\x00\x00\x00qKDH\x92'
b"\x1d\xed+\xdb\x12\xd0\x9c\xbcFw\xac!'[>\xaa\xbe\xcc\xe1\xee\xbd\x95kL"
b'*\xb3\xf1\x15')
Результат разбора:
'A1': [{'B1': 15847,
{'B2': 'tfr',
'B3': {'C1': 60698,
'C2': 1387650404,
'C3': 0.7553109526634216,
'C4': 30236},
'B4': -18063221,
'B5': {'D1': 35959, 'D2': 151},
'B6': [253, 100, 9, 156, 182],
'B7': 40240,
'B8': 28},
'B1': -13543,
{'B2': 'ajioi',
'B3': {'C1': 64646,
'C2': 542836170,
'C3': -0.6809378862380981,
'C4': 14631},
'B4': -628005315,
'B5': {'D1': 53247, 'D2': 212},
'B6': [232, 217, 188, 181, 24],
'B7': 939,
'B8': -84},
'B1': -24362,
{'B2': 'pi',
'B3': {'C1': 7520,
'C2': 1515787840,
'C3': -0.37276414036750793,
'C4': 10698},
'B4': 781928901,
'B5': {'D1': 58292, 'D2': 62},
'B6': [75, 68, 72, 146, 29],
'B7': 60715,
'B8': -37}],
'A2': 0.12133260071277618,
'A3': [1355755820288551969, 2835929293426319854, 13660943019576389909],
'A4': 64269,
'A5': 46565}
Задача №12
Реализовать разбор двоичного формата данных. Данные начинаются с сигнатуры 0xba 0x52 0x43 0x4b
, за которой следует структура
A. Порядок байт: от младшего к старшему. Адреса указаны в виде смещений от начала данных. В решении предлагается использовать модуль
struct.
Структура A:
Поле | Описание |
---|---|
1 | Массив char, размер 3 |
2 | int64 |
3 | float |
4 | Адрес (uint16) структуры B |
5 | int32 |
6 | Массив float, размер 6 |
7 | double |
Структура B:
Поле | Описание |
---|---|
1 | int8 |
2 | Размер (uint16) и адрес (uint16) массива структур C |
3 | double |
4 | uint8 |
5 | int16 |
6 | Массив int32, размер 8 |
7 | Адрес (uint32) структуры D |
Структура C:
Поле | Описание |
---|---|
1 | uint8 |
2 | int64 |
Структура D:
Поле | Описание |
---|---|
1 | int32 |
2 | int64 |
Ниже показаны примеры разбора двоичного формата.
Пример 1
Двоичные данные:
b'\xbaRCKqcq\xa5\xb9>k\xcdz\xa70O\x9b\xae>W\x002\xdd{\xec\xdf;\xb4'
(b'\xbdq\xb2\x9a\xbe\x17$\x08?\xf8s\x0b?\xcaoo?6 N\xbf$\xf8\x90\xf9\x12\xa5\xe3'
b'?\x16\x83rXs\xcc\x97\xdcV)\x86\x04F\rI\x95\xb9\xee\xdd\xdd\x18\x04\x05'
b"\x81\x95z]\x0b;G\xcb\x02\x009\x00\xc2d\x8bQ,\xcf\xe7\xbf\x10'\x19\xb6"
b'\x05\xa4\xd9\xb7\xec\xf2\x9aA\x85f\xc5r\r\xf3yQr@i\x85\xae[\x0b6'
b'T\xaa\xea\x9d\xa2\x85aK\x00\x00\x00')
Результат разбора:
'A1': 'qcq',
{'A2': 3505905857617377701,
'A3': 0.3410286605358124,
'A4': {'B1': -53,
'B2': [{'C1': 22, 'C2': 6259044486502445699},
'C1': 41, 'C2': -1244799681003387770}],
{'B3': -0.7440396874109398,
'B4': 16,
'B5': 6439,
'B6': [-643562058,
-1695355721,
-983136959,
2045971826,
1765831249,
190557829,
-357936074,
1636147869],
'B7': {'D1': 68738525, 'D2': 5132708696435294469}},
'A5': -327426766,
'A6': [-0.08800482004880905,
-0.3021426498889923,
0.5318006873130798,
0.5447382926940918,
0.9352995157241821,
-0.8051789999008179],
'A7': 0.6139006494847803}
Пример 2
Двоичные данные:
b'\xbaRCKaqd:t\xabk\xe2\xec\xf2d\x06jr\xbfr\x00\x98\xf7\xe8\xb1`\xd7\x99'
(b'>\x86\xf5\xac\xbc\x01\x94\x18\xbf\xb98\x93<\xf8U1?L\xc7\xb7>J\x99\xc1'
b'\xf4%\xb7\xee?\xd4\xc4\xb82\x86\xde\xb0A9\x07@f\xa6!m\x19gz\x04\xefm\\\xdf'
b'\n\xcc\x1c\x13\r;\xf1h\x8c\xf1\xff=u\xfaY\x04\x9d\xa0a\xb2\xe8\xac.hfa\x07A'
b'\xb24\xf7\xa81:#\x05\x009\x00PWEc\x93\xf0\xbd\xbf.\xf5}\xca\xf0'
b'\x86\xd7\xe2\xcau\xf1\xfb\xd5\xc9\xa6\x89\xd5\x11g\xd4\x88\xb6\x04\nP'
b'\xe9\x11\xc4g_Xt\xb1\x1auf\x00\x00\x00')
Результат разбора:
'A1': 'aqd',
{'A2': 7274136805369934906,
'A3': -0.9469302892684937,
'A4': {'B1': 35,
'B2': [{'C1': 212, 'C2': 4125773203428784324},
'C1': 7, 'C2': 8820046351735088704},
{'C1': 4, 'C2': 1377199933137645039},
{'C1': 13, 'C2': 8448189888924807483},
{'C1': 250, 'C2': -5987339572212857767}],
{'B3': -0.11695214437108103,
'B4': 46,
'B5': 32245,
'B6': [-679022390,
-243938590,
-1496721925,
1729222025,
79071444,
300503050,
1482647492,
1964683636],
'B7': {'D1': 1634101294, 'D2': 4193318507753128199}},
'A5': -1310132328,
'A6': [0.30047130584716797,
-0.021113168448209763,
-0.5960083603858948,
0.017971383407711983,
0.6927180290222168,
0.3589423894882202],
'A7': 0.9598569660563865}
Задача №12
Реализовать разбор двоичного формата данных. Данные начинаются с сигнатуры 0x47 0x52 0x52 0x4c
, за которой следует структура
A. Порядок байт: от младшего к старшему. Адреса указаны в виде смещений от начала данных. В решении предлагается использовать модуль
struct.
Структура A:
Поле | Описание |
---|---|
1 | int16 |
2 | Структура B |
3 | Массив char, размер 2 |
4 | uint8 |
5 | Адрес (uint16) структуры D |
6 | uint8 |
7 | uint64 |
Структура B:
Поле | Описание |
---|---|
1 | Массив char, размер 4 |
2 | uint8 |
3 | uint8 |
4 | uint32 |
5 | double |
6 | uint8 |
7 | int32 |
8 | Размер (uint16) и адрес (uint32) массива адресов (uint16) структур C |
Структура C:
Поле | Описание |
---|---|
1 | int8 |
2 | uint16 |
3 | uint8 |
4 | int32 |
Структура D:
Поле | Описание |
---|---|
1 | Размер (uint16) и адрес (uint32) массива uint16 |
2 | float |
Ниже показаны примеры разбора двоичного формата.
Пример 1
Двоичные данные:
b'GRRL\xd5jvhnv\x10\xc6Z\x0b\xa6ET\xa4\xe9\xe3\x06\x16\xe2\xbf\x91\xdf\x98\xb6'
(b'\n\x05\x00Y\x00\x00\x00fbmi\x00\x92\xd6y\xe1\x82Y\xf9\xc8\xce\xe5\xe9\x8c'
b'\xf8o\x80\xc4TG\xa1\xfa\xe9\xf8I\xe3g\xcd2=\xfd\x1c\xdd\xf0CM\x0c\xde'
b'\xd4\\\xd0\xa2\x8eRV\x12\x81k.\xb7\x9e1\x009\x00A\x00I\x00Q\x00#'
b'\xd8\xde\xd0A\x93\x03\x00c\x00\x00\x00`+4\xbf')
Результат разбора:
'A1': 27349,
{'A2': {'B1': 'vhnv',
'B2': 16,
'B3': 198,
'B4': 1168509786,
'B5': -0.5651888324183667,
'B6': 145,
'B7': 179738847,
'B8': [{'C1': -27, 'C2': 36073, 'C3': 248, 'C4': 1422164079},
'C1': 71, 'C2': 64161, 'C3': 233, 'C4': 1742948856},
{'C1': -51, 'C2': 15666, 'C3': 253, 'C4': 1139858716},
{'C1': 77, 'C2': 56844, 'C3': 212, 'C4': -1901932452},
{'C1': 82, 'C2': 4694, 'C3': 129, 'C4': -1632162197}]},
{'A3': 'fb',
'A4': 109,
'A5': {'D1': [55331, 53470, 37697], 'D2': -0.7037868499755859},
'A6': 146,
'A7': 14900433529998506454}
Пример 2
Двоичные данные:
b'GRRL\xb2\xf8mykq\xb6w\x13\xfc\xaeNjt\xbfk6\xbc\xef\xbf\x01\xa0\xb2\x8c'
(b'\xa4\x04\x00Q\x00\x00\x00js\xaf_\x00\xa0\x86p\xe6\xb4\x86\r\xa4\x18\xa9m\x93'
b'\xa67\x91\xe2\x1df\xc5\x1e=\x89\xcbA\xe0\x10\xde^]\x84\x99\x82\x85O\xe4&'
b'\x06?!\xeb`1\x009\x00A\x00I\x00]G\xc6\xb3\x06\x07\x03\x00Y\x00\x00'
b'\x00\xa4\x89g?')
Результат разбора:
'A1': -1870,
{'A2': {'B1': 'mykq',
'B2': 182,
'B3': 119,
'B4': 1320090643,
'B5': -0.9917251686525905,
'B6': 1,
'B7': -1534283104,
'B8': [{'C1': -87, 'C2': 37741, 'C3': 166, 'C4': 501387575},
'C1': 102, 'C2': 7877, 'C3': 61, 'C4': -532558967},
{'C1': 16, 'C2': 24286, 'C3': 93, 'C4': -2055038588},
{'C1': 79, 'C2': 9956, 'C3': 6, 'C4': 1626022207}]},
{'A3': 'js',
'A4': 175,
'A5': {'D1': [18269, 46022, 1798], 'D2': 0.9044439792633057},
'A6': 160,
'A7': 1775559025302597766}
Задача №12
Реализовать разбор двоичного формата данных. Данные начинаются с сигнатуры 0xc7 0x44 0x4b 0x50 0x46
, за которой следует
структура A. Порядок байт: от старшего к младшему. Адреса указаны в виде смещений от начала данных. В решении предлагается использовать
модуль struct.
Структура A:
Поле | Описание |
---|---|
1 | Массив структур B, размер 2 |
2 | int8 |
3 | Адрес (uint16) структуры C |
4 | int64 |
Структура B:
Поле | Описание |
---|---|
1 | float |
2 | uint16 |
Структура C:
Поле | Описание |
---|---|
1 | int8 |
2 | int32 |
3 | uint64 |
4 | float |
5 | int64 |
6 | Структура D |
7 | float |
Структура D:
Поле | Описание |
---|---|
1 | Массив int32, размер 5 |
2 | uint8 |
3 | double |
4 | Массив uint32, размер 3 |
5 | int16 |
6 | Массив int64, размер 2 |
7 | Размер (uint16) и адрес (uint16) массива uint64 |
8 | uint16 |
Ниже показаны примеры разбора двоичного формата.
Пример 1
Двоичные данные:
b'\xc7DKPF\xbe\xd0\x80\xce\xaf\r\xbf_\xc3yj?\xbd\x00,\x1f\xa1\x95\x04\xa6"c&'
(b'\x1b\xdb\xee\x8b\x1b6Q@\xa7\xcb\xb2\xa5\xee\xb2\xbb;\x93\xd0V\x18\xe5nQ\xa7'
b'\x88u\r\xc1\x9a\xbd\x8b\xeftc\xaf\x8e\xb9z8\xdd\x14\xdb\xe6\xa6'
b'\xba\xda\x16\x1dT\xee\x8d\x1b\xd8#\x91\xf0\x0c*\x8cl\xd1\xbd?u\xa0<YN'
b'\x0b\x00\xed\x97\x7f\xa8\xa1\xe8\xddD\x01&\xbdJp\xa2T\x17\x08\x07{D\xc7\xaf'
b'\xa6\xb1d\xb3/\xd8\xf9S\x00\x02\x00\x1c\xe9W?\x1b\xb6\xf8')
Результат разбора:
'A1': [{'B1': -0.40723270177841187, 'B2': 44813},
{'B1': -0.8740764260292053, 'B2': 27199}],
{'A2': -67,
'A3': {'C1': -109,
'C2': -799663899,
'C3': 7949319021806862746,
'C4': -0.06832781434059143,
'C5': 7183116857949871380,
'C6': {'D1': [-605641030, -636084908, -292742184, 596766732, 713845969],
'D2': 189,
'D3': 0.005279765832599592,
'D4': [3986128808, 2716392772, 19316042],
'D5': 28834,
'D6': [6059320651876190127, -6435251671771055789],
'D7': [2007460340148097344, 12090954050350267195],
'D8': 59735},
'C7': 0.6082606315612793},
'A4': 2279266733625860902}
Пример 2
Двоичные данные:
b'\xc7DKPF?9\x06\x87\xf7Z\xbf%\x8b\xf7\x94J\x8f\x00,\x12\xd6\xd31\x9a\x0c\xd6^'
(b"\xc1\xc62\xb2\xe0\xc7+\xcd:\x1c\xd7\xcb\xa5y\xd5Ahp\xf6h\xcfi\xbe'"
b'\xde\x8d-\xc7\xdf=\x97*(4\x06nBK\xf4\xd4\xb38\xad\xad\xad\x17{\xe8Q\x0c\xa0a'
b'-\xb1:\xb6\x1aT\xab\xac6\x82?\xdc\xc9s\xa3\x84\xaf\xa4\xb2CfI}l,&\xd0\x92'
b'\x11\x04\xcd\xc6\xaa\x11\xbd\xef\nDF\x0e\xab\x9d\x97\xa0\xdb^D_'
b'\x00\x02\x00\x1c\xf0\xc2>\n\nN')
Результат разбора:
'A1': [{'B1': 0.7227558493614197, 'B2': 63322},
{'B1': -0.646666944026947, 'B2': 37962}],
{'A2': -113,
'A3': {'C1': 104,
'C2': 1895196879,
'C3': 7619571456362268639,
'C4': 0.073810875415802,
'C5': 3748804970853749939,
'C6': {'D1': [950906285, 393996369, 211837229, -1321552358, 1420536886],
'D2': 130,
'D3': 0.44979563683113555,
'D4': [2990761545, 2104241190, 3499233540],
'D5': -12858,
'D6': [-6191959178290641394, -6080537204749351841],
'D7': [13962903438565518285, 4187459023202276673],
'D8': 61634},
'C7': 0.13480493426322937},
'A4': 1357504547690174046}
Задача №12
Реализовать разбор двоичного формата данных. Данные начинаются с сигнатуры 0x48 0x43 0x54 0xeb
, за которой следует структура
A. Порядок байт: от старшего к младшему. Адреса указаны в виде смещений от начала данных. В решении предлагается использовать модуль
struct.
Структура A:
Поле | Описание |
---|---|
1 | Массив адресов (uint16) структур B, размер 3 |
2 | Структура C |
Структура B:
Поле | Описание |
---|---|
1 | int8 |
2 | Размер (uint16) и адрес (uint32) массива char |
Структура C:
Поле | Описание |
---|---|
1 | Структура D |
2 | uint16 |
Структура D:
Поле | Описание |
---|---|
1 | int64 |
2 | Размер (uint32) и адрес (uint16) массива double |
3 | Массив uint64, размер 3 |
4 | int16 |
5 | uint64 |
6 | Массив int32, размер 7 |
7 | int64 |
Ниже показаны примеры разбора двоичного формата.
Пример 1
Двоичные данные:
b'HCT\xeb\x00c\x00m\x00w\xd5\xcb?\rV\x1ex@\x00\x00\x00\x02\x00~\x0f\x0e\xeb`'
(b'\x86\x02\xc6\x8f\x86\x95\xce\xe8\xc9\xbe\x1b\x9f/\xf3\xe7\xd9\x0cXH8'
b'\x88\xc4\x86\xaf\xb9\\l\xce\xf8Q=\xc5\xd6>\x8a\xe2q\xbc\xa82\xc3"\xa7\xab'
b'\xc3Da\x05r\x1f\xbb[,\xb4\x02+u\xc1\x84d\x0c\xb9\xc6\xdc\xc4\xb8\xee\xd8'
b'jbk\x1f\x00\x03\x00\x00\x00`egm]\x00\x03\x00\x00\x00jngqU\x00\x03\x00\x00'
b'\x00t?\xdf\x9cF\xc2\xc1\x8b|?\xe6\xf0\xf6N\x142r')
Результат разбора:
'A1': [{'B1': 31, 'B2': 'jbk'},
{'B1': 93, 'B2': 'egm'},
{'B1': 85, 'B2': 'ngq'}],
{'A2': {'C1': {'D1': -3041267796846675904,
'D2': [0.4939133550562287, 0.7169143223741925],
'D3': [1085063360040584847,
9697884871824645023,
3455360258524334136],
'D4': -30524,
'D5': 9705179528620341329,
'D6': [1036375614,
-1964871236,
-1473068254,
-1481915580,
1627746847,
-1151652684,
36402625],
'D7': -8906980170987158344},
'C2': 61144}}
Пример 2
Двоичные данные:
b'HCT\xeb\x00b\x00l\x00u$\x86\x0e\x19e\x17\x15\xe7\x00\x00\x00\x08\x00|'
(b'\xf5\x0c9\xd6\xb3\xba\xb0\xc2\xf2\xcc\x9fDe\xbcxk\xeb3+;\t\x19\xac\xe8'
b'\x0c\x856\x90\xc2\x15X9\xad$3\xc0\xbaJ\xee\xd9w\x0f3\xa3\x1c\x15\xb0\xcc'
b'hz\n\x96o+3\xb5\xd3\xb8\xe9h\x15\xd5\x99\xd34\x00\xa6\x9d\xbdB\xbf\xf9'
b'qk\x85\x00\x02\x00\x00\x00`kas\xfe\x00\x03\x00\x00\x00ivp\x7f\x00\x02'
b'\x00\x00\x00s?\xeb<\xdd3R\x17\x98\xbf\xc2\x93\xa9\x1b\xc8<\x08\xbf\xd7P`'
b'\x7f\x1a\xf2x\xbf\xca\x97\xcb\xdf\xc9\xfe\x00\xbf\xaf\x07k\x0b\xe3\xad@'
b'?\xd1\x91\x10G}"(\xbf\xdc\xe0j\xf0\xb5J\xd0\xbf\xee8\xa7\xe6\xf1\xa3\xb0')
Результат разбора:
'A1': [{'B1': -123, 'B2': 'qk'},
{'B1': -2, 'B2': 'kas'},
{'B1': 127, 'B2': 'vp'}],
{'A2': {'C1': {'D1': 2631806534477616615,
'D2': [0.8511796953541646,
-0.14513124329138827,
-0.36428081905959386,
-0.20775745799254253,
-0.060603470994318176,
0.27447897893265116,
-0.45119737154634,
-0.9444159994719623],
'D3': [17657551833314013378,
17495533768540977259,
16947937355281050856],
'D4': 3205,
'D5': 3931855871624719652,
'D6': [868268618,
-287738097,
866327573,
-1328781190,
177631019,
867554232,
-379054635],
'D7': -7362483788420629182},
'C2': 49145}}
Задача №12
Реализовать разбор двоичного формата данных. Данные начинаются с сигнатуры 0x4a 0x52 0x42 0x55
, за которой следует структура
A. Порядок байт: от старшего к младшему. Адреса указаны в виде смещений от начала данных. В решении предлагается использовать модуль
struct.
Структура A:
Поле | Описание |
---|---|
1 | int16 |
2 | Адрес (uint32) структуры B |
3 | Адрес (uint16) структуры E |
4 | int16 |
Структура B:
Поле | Описание |
---|---|
1 | int16 |
2 | uint8 |
3 | float |
4 | float |
5 | Структура C |
6 | int32 |
7 | int16 |
8 | uint8 |
Структура C:
Поле | Описание |
---|---|
1 | float |
2 | Размер (uint16) и адрес (uint32) массива структур D |
3 | uint16 |
4 | uint32 |
Структура D:
Поле | Описание |
---|---|
1 | double |
2 | Размер (uint32) и адрес (uint32) массива float |
3 | int8 |
4 | uint8 |
5 | int32 |
Структура E:
Поле | Описание |
---|---|
1 | Размер (uint16) и адрес (uint16) массива int8 |
2 | uint8 |
3 | uint32 |
4 | int16 |
5 | Массив uint32, размер 3 |
Ниже показаны примеры разбора двоичного формата.
Пример 1
Двоичные данные:
b'JRBU\xb5\x1d\x00\x00\x00R\x00x\xfa\xb2>\xd2\xc3\xd1\xbe\xec\xe1\r\xbfo'
(b'\x1aR?\x1b\xb2<\xbd\x96\x83\xb1>\x89\x93\xe0\xbf\xefh\xach_\x11P\x00\x00'
b'\x00\x02\x00\x00\x00\x0e\xa1\xc6\xd1:\x911\xbf\xcb\xb6\x19\x1b\xb4=\x18'
b'\x00\x00\x00\x04\x00\x00\x00\x16\xe1C \x8f\xf2@\xaf\xc4\xb3\xbfh]X\xbfdY'
b'\xec>\xd5\x95\xdb\x00\x02\x00\x00\x00&<1\x05q\xcb9yoz\x8b\xa3\n\x1b'
b"'\xa5\xa4\x19\x00\x04\x00t\xadIso\x82\xcb\x18n\x96\xc2\x84m\xd3:to\xa4f3")
Результат разбора:
'A1': -19171,
{'A2': {'B1': -20540,
'B2': 179,
'B3': -0.9076743125915527,
'B4': -0.8919970989227295,
'B5': {'C1': 0.41715893149375916,
'C2': [{'D1': -0.9815275228980145,
'D2': [0.4116502106189728, -0.4626545011997223],
'D3': -95,
'D4': 198,
'D5': -784690895},
'D1': -0.21649469235169572,
{'D2': [-0.9339953660964966,
0.6081883907318115,
-0.07349336892366409,
0.2687063217163086],
'D3': -31,
'D4': 67,
'D5': 546304576}],
'C3': 15409,
'C4': 91343673},
'B6': 2037349003,
'B7': -23798,
'B8': 27},
'A3': {'E1': [39, -91, -92, 25],
'E2': 173,
'E3': 1232301954,
'E4': -13544,
'E5': [1855373956, 1842559604, 1873045043]},
'A4': -1358}
Пример 2
Двоичные данные:
b'JRBU\xb7\x1b\x00\x00\x00R\x00z\xae\xd6\xbf`\x95\xaa\xbc\xdd\x03/\xbb\xde'
(b'\x16\x04\xbfw,\x7f\xbfL\x88\xb4?>\xbbB\xbf\xd8\xfe\xd8\x9b\xd8T<\x00\x00'
b'\x00\x03\x00\x00\x00\x0e\xd7\xf1B\x86Z\x9c?\xdf"G\xb4\x1b\xd0\x9c'
b'\x00\x00\x00\x03\x00\x00\x00\x1a\xb5\xb2\xd0\xdan\xdf`\xb7\xb0\xbdX\x14'
b'\xc9>bc4\xbe:\xe0\xc3\x00\x02\x00\x00\x00&\xadi\xec\xf8\xd0C\xe8\xd4\xb9'
b'qs8\xe4\x0ec\xdf\x9bj\xce\x00\x06\x00t7\xd4\x0c\xf8\xcc\x99\xd5\xfe:\x84'
b'\xf4Z\xa60\x03u\xe4\r\x8d')
Результат разбора:
'A1': -18661,
{'A2': {'B1': 24759,
'B2': 176,
'B3': -0.052754197269678116,
'B4': 0.22108155488967896,
'B5': {'C1': -0.1824980229139328,
'C2': [{'D1': -0.39055457324258547,
'D2': [-0.8772836923599243,
-0.026979057118296623,
-0.006777526810765266],
'D3': -41,
'D4': 241,
'D5': 1116101276},
'D1': 0.4864672907708696,
{'D2': [-0.9655227065086365,
-0.7989609241485596,
0.7450448274612427],
'D3': -75,
'D4': 178,
'D5': -790991137}],
'C3': 44393,
'C4': 3975729219},
'B6': -388712079,
'B7': 29496,
'B8': 228},
'A3': {'E1': [14, 99, -33, -101, 106, -50],
'E2': 55,
'E3': 3557619916,
'E4': -26155,
'E5': [4265247988, 1520840707, 1977879949]},
'A4': -20778}
Задача №12
Реализовать разбор двоичного формата данных. Данные начинаются с сигнатуры 0x52 0x4a 0x56 0x42
, за которой следует структура
A. Порядок байт: от старшего к младшему. Адреса указаны в виде смещений от начала данных. В решении предлагается использовать модуль
struct.
Структура A:
Поле | Описание |
---|---|
1 | Структура B |
2 | Размер (uint16) и адрес (uint32) массива адресов (uint32) структур E |
3 | float |
4 | Массив char, размер 2 |
5 | uint32 |
6 | double |
7 | int64 |
8 | Структура F |
Структура B:
Поле | Описание |
---|---|
1 | uint8 |
2 | Адрес (uint16) структуры C |
3 | double |
4 | Размер (uint16) и адрес (uint32) массива char |
Структура C:
Поле | Описание |
---|---|
1 | uint8 |
2 | Адрес (uint16) структуры D |
3 | uint16 |
4 | int16 |
Структура D:
Поле | Описание |
---|---|
1 | int32 |
2 | uint32 |
3 | uint32 |
Структура E:
Поле | Описание |
---|---|
1 | uint16 |
2 | uint16 |
Структура F:
Поле | Описание |
---|---|
1 | Массив int16, размер 7 |
2 | int32 |
3 | Размер (uint16) и адрес (uint32) массива uint8 |
Ниже показаны примеры разбора двоичного формата.
Пример 1
Двоичные данные:
b'RJVB\xb2\x00Y\xbf\xda\xdfK\x16\xdae\x1c\x00\x05\x00\x00\x00`\x00\x02\x00'
(b'\x00\x00m?azfbiQ(J\x99\xbf\xc5\xbfI\x99\xb1z\xe8JlwW\xc3E\x82'
b'\x11\xf5\xd2\x02\xb9\x87\xd2qx\x16\x86\x1d p\xc1\x17W\xf2\xcd\x00'
b'\x06\x00\x00\x00ujb\xaf\xd6O\x08~\xc3}x\xaf\xd4\x7f\x00M*\xda\xbb\x8dhljl'
b'jNrr\x08w\x80\xe0=\x00\x00\x00e\x00\x00\x00if\xaf\xc8\xf2\xd60')
Результат разбора:
'A1': {'B1': 178,
{'B2': {'C1': 127,
'C2': {'D1': 1784852438, 'D2': 1325956803, 'D3': 2105061332},
'C3': 10970,
'C4': -17523},
'B3': -0.4198787425207955,
'B4': 'hljlj'},
'A2': [{'E1': 20082, 'E2': 29192}, {'E1': 30592, 'E2': 57405}],
'A3': 0.8807739019393921,
'A4': 'bi',
'A5': 1361595033,
'A6': -0.1699001312690236,
'A7': 5362792475113390609,
'A8': {'F1': [-2606, 697, -30766, 29048, 5766, 7456, 28865],
'F2': 391639757,
'F3': [102, 175, 200, 242, 214, 48]}}
Пример 2
Двоичные данные:
b'RJVBt\x00Y?\xab\xab\xb00|\xc4\xc0\x00\x03\x00\x00\x00`\x00\x02\x00'
(b'\x00\x00k\xbfo\x8a\x9cfuR(\x9b\xf7?\xdd\xf7\xf2\x94\x85T\xb4\x1d\x18\xf5'
b'\xcaI\xad\xadM\x9c\x8f\xb4\xf1\xe6\xe0Y|r\x88jpF\xb3l\x82\xaa\x8d\x00'
b'\x02\x00\x00\x00sR\xfb\x83\x13\xaf\xf7\xde0\xd8\xeb\x87\xdcg\x00M\x88};]'
b"ezl\xe9\xc3\xb7\xe1'%\xc0\x1c\x00\x00\x00c\x00\x00\x00g)\xd8")
Результат разбора:
'A1': {'B1': 116,
{'B2': {'C1': 103,
'C2': {'D1': 1392214803, 'D2': 2952257072, 'D3': 3639314396},
'C3': 34941,
'C4': 15197},
'B3': 0.0540442523182576,
'B4': 'ezl'},
'A2': [{'E1': 59843, 'E2': 47073}, {'E1': 10021, 'E2': 49180}],
'A3': -0.93570876121521,
'A4': 'fu',
'A5': 1378393079,
'A6': 0.4682585192106885,
'A7': 2096695875709283661,
'A8': {'F1': [-25457, -19215, -6432, 22908, 29320, 27248, 18099],
'F2': 1820502669,
'F3': [41, 216]}}
Задача №12
Реализовать разбор двоичного формата данных. Данные начинаются с сигнатуры 0x4c 0x5a 0x42
, за которой следует структура A.
Порядок байт: от старшего к младшему. Адреса указаны в виде смещений от начала данных. В решении предлагается использовать модуль
struct.
Структура A:
Поле | Описание |
---|---|
1 | uint8 |
2 | Размер (uint32) и адрес (uint16) массива char |
3 | int8 |
4 | int32 |
5 | int16 |
6 | Структура B |
7 | int8 |
Структура B:
Поле | Описание |
---|---|
1 | uint64 |
2 | double |
3 | Размер (uint32) и адрес (uint32) массива структур C |
4 | Структура D |
5 | int32 |
6 | int32 |
Структура C:
Поле | Описание |
---|---|
1 | uint16 |
2 | int32 |
3 | uint16 |
4 | uint32 |
Структура D:
Поле | Описание |
---|---|
1 | Размер (uint32) и адрес (uint32) массива uint16 |
2 | uint32 |
3 | Массив int8, размер 5 |
4 | double |
5 | int8 |
Ниже показаны примеры разбора двоичного формата.
Пример 1
Двоичные данные:
b'LZB\xd5\x00\x00\x00\x04\x00L\x93\x18$\x97\xdfAF.\x8c\xf27\xab\xb0\xfb'
(b'\xdb?\xd6\xa2?\xa5\xeb\xefH\x00\x00\x00\x02\x00\x00\x00P\x00\x00\x00'
b'\x03\x00\x00\x00hH\xb3e}\x93\x1f$\x02\xdd\xbf\xe5t\r\xcd\x89\x8d\xac\x9d\xc4'
b'\x9a\xae\xc4\x19\xef\x07\x1c\x89ulld\x1e\x03\x11c\xd1\xe1\x15r\x85\xedF\x8e'
b'\x1a\x1b\xa7BA,{@\x11\xfe\xb4ZoK^T\xfa\xea')
Результат разбора:
'A1': 213,
{'A2': 'ulld',
'A3': -109,
'A4': 405051359,
'A5': 16710,
'A6': {'B1': 3354322143401802715,
'B2': 0.3536528702095336,
'B3': [{'C1': 7683, 'C2': 291754465, 'C3': 5490, 'C4': 2246919822},
'C1': 6683, 'C2': -1488830164, 'C3': 31552, 'C4': 301904986}],
{'B4': {'D1': [28491, 24148, 64234],
'D2': 1219716477,
'D3': [-109, 31, 36, 2, -35],
'D4': -0.670416737976145,
'D5': -99},
'B5': -996495676,
'B6': 435095324},
'A7': -119}
Пример 2
Двоичные данные:
b'LZB7\x00\x00\x00\x02\x00L\xdeFCE\xbd\xad\x9bY\xbe\xa2g\xfe\xa5\xdd'
(b'\x83?\xaa\x82FB\xf2\xd6`\x00\x00\x00\x02\x00\x00\x00N\x00\x00\x00'
b'\x05\x00\x00\x00f\xaa/\xd5\xc1\x84r\xe2:p\xbf\xed|Hw\xbc9\xf0d\x04d\xc97E'
b"\xce\xe1'\x15pp\x96\xdcH[6)\x8d\xd9\xf94\x05\xcd\xb1vz\\\xff\xa4 8\x1e\xaf"
b'y\xe9W\xe9\xf0 \x9d\x99\x91/\x17*')
Результат разбора:
'A1': 55,
{'A2': 'pp',
'A3': -34,
'A4': 1178813885,
'A5': -21093,
'A6': {'B1': 6466784682488225155,
'B2': 0.051775165245470545,
'B3': [{'C1': 38620, 'C2': 1213937193, 'C3': 36313, 'C4': 4180936141},
'C1': 45430, 'C2': 2052915108, 'C3': 8248, 'C4': 514816489}],
{'B4': {'D1': [22505, 61472, 40345, 37167, 5930],
'D2': 2855261633,
'D3': [-124, 114, -30, 58, 112],
'D4': -0.9214212740496901,
'D5': 100},
'B5': 73713975,
'B6': 1171185959},
'A7': 21}
Задача №12
Реализовать разбор двоичного формата данных. Данные начинаются с сигнатуры 0xa9 0x5a 0x42 0x5a 0x47
, за которой следует
структура A. Порядок байт: от старшего к младшему. Адреса указаны в виде смещений от начала данных. В решении предлагается использовать
модуль struct.
Структура A:
Поле | Описание |
---|---|
1 | uint16 |
2 | int16 |
3 | Адрес (uint32) структуры B |
4 | Размер (uint32) и адрес (uint32) массива адресов (uint32) структур E |
5 | double |
6 | uint8 |
7 | uint8 |
8 | Структура F |
Структура B:
Поле | Описание |
---|---|
1 | Структура C |
2 | Массив char, размер 3 |
Структура C:
Поле | Описание |
---|---|
1 | Адрес (uint32) структуры D |
2 | Размер (uint16) и адрес (uint32) массива char |
3 | double |
Структура D:
Поле | Описание |
---|---|
1 | uint32 |
2 | uint32 |
3 | uint64 |
4 | int32 |
Структура E:
Поле | Описание |
---|---|
1 | float |
2 | float |
3 | uint32 |
4 | Размер (uint32) и адрес (uint16) массива int8 |
Структура F:
Поле | Описание |
---|---|
1 | int16 |
2 | float |
Ниже показаны примеры разбора двоичного формата.
Пример 1
Двоичные данные:
b'\xa9ZBZGV\xb8\x14\xcf\x00\x00\x00;\x00\x00\x00\x03\x00\x00\x00'
(b'\x8e\xbf\xc0\xac\xa4d\x1bo\xb0@\x1dx\xa7?\x00\x95s\xbf\x88\x88\x024U9'
b'<\x17F\x90\x0b\xf8\xef\xddk\x11*\xff=lt\x00\x00\x00%\x00\x02\x00\x00\x00'
b'9\xbf\xe5\xb5H*X\xc3\x12qjr\x87\xdbE\xbf\x07Cr>\x94\x1e\xf2#E\xd6\xd0\x00'
b'\x00\x00\x03\x00P\xb2\xf1>)\xae\xf4?\x13+\xbd\r\x0c\x87K\x00\x00\x00\x02\x00'
b'e\xd2\xb8\x92>\xd6\x06\x1f?N\x87\xa0\xd3\x8d\x08?\x00\x00\x00\x03'
b'\x00y\x00\x00\x00S\x00\x00\x00g\x00\x00\x00|')
Результат разбора:
'A1': 22200,
{'A2': 5327,
'A3': {'B1': {'C1': {'D1': 3213395970,
'D2': 878000444,
'D3': 1677186292337597803,
'D4': 288030525},
'C2': 'lt',
'C3': -0.6783791377148154},
'B2': 'qjr'},
'A4': [{'E1': -0.5283728837966919,
'E2': 0.2892985939979553,
'E3': 591779536,
'E4': [-121, -37, 69]},
'E1': 0.16570645570755005,
{'E2': 0.57488614320755,
'E3': 218924875,
'E4': [-78, -15]},
'E1': 0.4180154502391815,
{'E2': 0.8067569732666016,
'E3': 3549235263,
'E4': [-46, -72, -110]}],
'A5': -0.13026862037702136,
'A6': 64,
'A7': 29,
'A8': {'F1': 30887, 'F2': 0.5022804141044617}}
Пример 2
Двоичные данные:
b'\xa9ZBZG\xa5_\x7f\xcf\x00\x00\x00?\x00\x00\x00\x03\x00\x00\x00\x92?\xe9b'
(b'\x9f\x18%H\x06x\xb0\x13Y\xbe\xf9\xb1\xfc\x86?\x99\xc5I\xc3e<~\xd8\x12'
b'\x1d\x7f\xec\x01.+\x81\x85\xd2vxlhjt\x00\x00\x00%\x00\x06\x00\x00\x00'
b'9\xbf\xd6|y76\xea\xfcgmv\xe4\xfd\xf6\xbf:7\xb6\xbfY9l\xfe0\xf6\x89\x00'
b'\x00\x00\x03\x00T\xe9\xbe:\xbf.\xad\x04?\x0ee=\xa0r*\xd3\x00\x00\x00\x03'
b'\x00i\xd8\xa6\xbe_\x8e~>\xe7X\xe3&dX\xe1\x00\x00\x00\x02\x00~\x00\x00'
b'\x00W\x00\x00\x00l\x00\x00\x00\x80')
Результат разбора:
'A1': 42335,
{'A2': 32719,
'A3': {'B1': {'C1': {'D1': 2252315077,
'D2': 1237542204,
'D3': 9140075361657946414,
'D4': 729908690},
'C2': 'vxlhjt',
'C3': -0.3513472594456031},
'B2': 'gmv'},
'A4': [{'E1': -0.7274125814437866,
'E2': -0.8485324382781982,
'E3': 4264621705,
'E4': [-28, -3, -10]},
'E1': -0.6823275089263916,
{'E2': 0.5562322735786438,
'E3': 2691836627,
'E4': [-23, -66, 58]},
'E1': -0.21831700205802917,
{'E2': 0.451850026845932,
'E3': 644110561,
'E4': [-40, -90]}],
'A5': 0.7932887527078953,
'A6': 120,
'A7': 176,
'A8': {'F1': 4953, 'F2': -0.48768603801727295}}
Задача №12
Реализовать разбор двоичного формата данных. Данные начинаются с сигнатуры 0x4c 0x52 0x4b 0x5a 0x56
, за которой следует
структура A. Порядок байт: от старшего к младшему. Адреса указаны в виде смещений от начала данных. В решении предлагается использовать
модуль struct.
Структура A:
Поле | Описание |
---|---|
1 | float |
2 | Структура B |
3 | Адрес (uint32) структуры D |
4 | uint32 |
5 | float |
6 | uint32 |
Структура B:
Поле | Описание |
---|---|
1 | Массив char, размер 2 |
2 | uint32 |
3 | Размер (uint16) и адрес (uint32) массива адресов (uint32) структур C |
4 | int64 |
5 | uint16 |
Структура C:
Поле | Описание |
---|---|
1 | Размер (uint32) и адрес (uint16) массива uint16 |
2 | int64 |
3 | uint8 |
Структура D:
Поле | Описание |
---|---|
1 | Массив int16, размер 7 |
2 | uint64 |
Ниже показаны примеры разбора двоичного формата.
Пример 1
Двоичные данные:
b'LRKZV?fy\x82iy[BY\x8a\x00\x02\x00\x00\x00U\xd7*B1I)\xae\xc6*\xbc\x00'
(b'\x00\x00]\xe5\x1f\xa3\x8f\xbf+\xe98\xdc<\xb7\xb6\xfa\x04\x9a\x98\x00'
b'\x00\x00\x02\x00/\xe7\xfa\xc6\x87p\x9azt\xb3\x9dT\x1fW\x00\x00\x00\x02\x00B'
b"D\xdc`&\x87$\xb0\x89\x10\x00\x00\x003\x00\x00\x00FT\xadn\xaaw\x8e'%(\xda\xb4"
b'pt\xdd\x18H\x9dfq\xbc\x0b!')
Результат разбора:
'A1': 0.9002915620803833,
{'A2': {'B1': 'iy',
'B2': 1531074954,
'B3': [{'C1': [64004, 39576], 'C2': -1730852821758477708, 'C3': 179},
'C1': [40276, 8023], 'C2': 4961946608047796361, 'C3': 16}],
{'B4': -2942466627084898618,
'B5': 10940},
'A3': {'D1': [21677, 28330, 30606, 10021, 10458, -19344, 29917],
'D2': 1749821518553811745},
'A4': 3844055951,
'A5': -0.6715273857116699,
'A6': 3694966710}
Пример 2
Двоичные данные:
b'LRKZV\xbe(\xab\x06ik4\\\x92/\x00\x02\x00\x00\x00]FQ\x97\xbb\x1e\xe1\xb5'
(b'\xf5\xe2L\x00\x00\x00e\x0bu\xfbf>\xb2F\xfa \r:\xaf\xf7\xf3\xb9\x14g'
b'@\x00\xe2\x00\x00\x00\x04\x00/\xa6_"\xbb\x9a!\xfa\xd9\x8c\xf2\x98'
b'\xcf\xbcn\xc1\xff\xc4\x00\x00\x00\x04\x00FFB|\xbb\x9e\xaeG@\xce\x00\x00\x00'
b'7\x00\x00\x00N\xc5\xd5?\x1b\x1b\x89\\n\xa6{ZU:\xa9\xcb\xe6\xda\xd9.'
b'\xf5\xdc7')
Результат разбора:
'A1': -0.16471490263938904,
{'A2': {'B1': 'ik',
'B2': 878481967,
'B3': [{'C1': [63475, 47380, 26432, 226],
'C2': -6458405151485855015,
'C3': 140},
'C1': [62104, 53180, 28353, 65476],
{'C2': 5062746076380809024,
'C3': 206}],
'B4': 5066997885701305845,
'B5': 57932},
'A3': {'D1': [-14891, 16155, 7049, 23662, -22917, 23125, 15017],
'D2': 14692671460673444919},
'A4': 192281446,
'A5': 0.3481977581977844,
'A6': 537737903}
Задача №12
Реализовать разбор двоичного формата данных. Данные начинаются с сигнатуры 0x44 0x43 0x4d 0x85
, за которой следует структура
A. Порядок байт: от младшего к старшему. Адреса указаны в виде смещений от начала данных. В решении предлагается использовать модуль
struct.
Структура A:
Поле | Описание |
---|---|
1 | Адрес (uint32) структуры B |
2 | uint16 |
3 | Структура D |
4 | uint16 |
5 | float |
6 | uint16 |
Структура B:
Поле | Описание |
---|---|
1 | Массив int16, размер 3 |
2 | double |
3 | Массив структур C, размер 6 |
4 | uint32 |
Структура C:
Поле | Описание |
---|---|
1 | int16 |
2 | uint64 |
3 | uint8 |
4 | int8 |
Структура D:
Поле | Описание |
---|---|
1 | uint8 |
2 | Адрес (uint32) структуры E |
3 | Массив int8, размер 6 |
4 | double |
Структура E:
Поле | Описание |
---|---|
1 | uint64 |
2 | int32 |
3 | Размер (uint32) и адрес (uint32) массива int16 |
Ниже показаны примеры разбора двоичного формата.
Пример 1
Двоичные данные:
b'DCM\x85%\x00\x00\x00n|T\x87\x00\x00\x009\xc3\x1c\x92\xaa\x93\x00\x1e\xc5'
(b'\x8a\xb5\xb8\xcb?~\xc8\xd0\xe76?\xbe\x95Z\xe6B\xe0zT(ks\x13\xf0'
b'\xd7\xec\xbf\xd1J\xfaZ\xf1\xcc\xfe\x97\x9a\xf3<\xb9\xb0%5\xdb\x7f$\x92$\x86'
b'\xe9\xbbJ"{\x87\xd9C\xf1\xc1\x00\xfd.)\x0e\xe9~_\xb8d\xc5\xeb-\x0f#\xea\xae)'
b"\xdbE\xbaS'\x15\x05\x0f\xe0,,:3\xbc\xacp0\x19m\xc2\xf6\xe2\xf9\x0ef\x15Z\xc5"
b'\xd1*\xa1e=\xec\x1a\x9003\t\\\n\xc1\x18\x81\x82~?\x04\x00\x00\x00\x7f'
b'\x00\x00\x00')
Результат разбора:
'A1': {'B1': [-6566, -8126, 21626],
{'B2': -0.9013595943355073,
'B3': [{'C1': 19153, 'C2': 17553509618245786362, 'C3': 60, 'C4': -71},
'C1': 9648, 'C2': 16827177267812621109, 'C3': 187, 'C4': 74},
{'C1': 31522, 'C2': 3385863327828924807, 'C3': 41, 'C4': 14},
{'C1': 32489, 'C2': 2526288406630414431, 'C3': 234, 'C4': -82},
{'C1': -9431, 'C2': 16145128777558768197, 'C3': 44, 'C4': 44},
{'C1': 13114, 'C2': 17780894233766440124, 'C3': 226, 'C4': -7}],
{'B4': 1511351822},
'A2': 31854,
'A3': {'D1': 84,
'D2': {'E1': 1783718317823045776,
'E2': 1065255553,
'E3': [-11835, -24278, 15717, 6892]},
'D3': [57, -61, 28, -110, -86, -109],
'D4': 0.21657437587622042},
'A4': 51326,
'A5': 0.7144746780395508,
'A6': 38334}
Пример 2
Двоичные данные:
b'DCM\x85%\x00\x00\x00\xfd\xe9\x85\x83\x00\x00\x00\x01\xafKMz>L\x92R'
(b'\xe8\x1e\x07\xe9?\x1e\xa6\xc8\xafd?>\x1fy\xe8_t\x0c\n$ug\xcc\xc9'
b'\x7f\xe2?\xaap\x1e\xda\xe4M?\xb6\xf9\x81\xc9\xa3Sf\x9f\x90D\x11*\xc0\xf6'
b'\xb0\x99\xd7\xd9\xbdV\xf0-\xd1\xf4\x0cw\x94\x82\x19To\x84\x8a\xc0'
b"\xa5\xe1\xafU~\x12\x8e\xf6\xd6\x98\xd8\x1e\xf0\xfd\xce\x8d\xb1Y>'"
b'r\x06\xcd\xc0_\x82;D;\xd0;_\xbbj\x86\xbdN\xdd\x16\xd0Z\xd3_,\xb4\x02\x87W'
b',\x87\x02\x02\x00\x00\x00\x7f\x00\x00\x00')
Результат разбора:
'A1': {'B1': [-6023, 29791, 2572],
{'B2': 0.5780991546886622,
'B3': [{'C1': 28842, 'C2': 9365717283099695646, 'C3': 201, 'C4': -93},
'C1': 26195, 'C2': 12751590681857003679, 'C3': 153, 'C4': -41},
{'C1': -16935, 'C2': 10698033685462904918, 'C3': 130, 'C4': 25},
{'C1': 28500, 'C2': 9103375605482687108, 'C3': 18, 'C4': -114},
{'C1': -10506, 'C2': 12794109706480048280, 'C3': 89, 'C4': 62},
{'C1': 29223, 'C2': 4270603777792331014, 'C3': 208, 'C4': 59}],
{'B4': 2255141727},
'A2': 59901,
'A3': {'D1': 133,
'D2': {'E1': 9728536247752940240, 'E2': 42413143, 'E3': [20157, 5853]},
'D3': [1, -81, 75, 77, 122, 62],
'D4': 0.7821192300367072},
'A4': 42526,
'A5': 0.8933072090148926,
'A6': 7998}
Задача №12
Реализовать разбор двоичного формата данных. Данные начинаются с сигнатуры 0xea 0x45 0x4c 0x55 0x45
, за которой следует
структура A. Порядок байт: от старшего к младшему. Адреса указаны в виде смещений от начала данных. В решении предлагается использовать
модуль struct.
Структура A:
Поле | Описание |
---|---|
1 | Структура B |
2 | uint8 |
3 | Массив char, размер 8 |
4 | uint8 |
5 | Структура C |
6 | int64 |
7 | uint8 |
8 | int64 |
Структура B:
Поле | Описание |
---|---|
1 | int8 |
2 | uint16 |
3 | uint64 |
4 | uint16 |
5 | float |
Структура C:
Поле | Описание |
---|---|
1 | Размер (uint32) и адрес (uint32) массива адресов (uint32) структур D |
2 | Массив int32, размер 2 |
3 | uint8 |
4 | float |
Структура D:
Поле | Описание |
---|---|
1 | uint32 |
2 | Массив uint32, размер 4 |
3 | float |
Ниже показаны примеры разбора двоичного формата.
Пример 1
Двоичные данные:
b'\xeaELUE3d\xde\xea\xba\xcc\x7f\xd2\xef\xfc\x172\xe0?9\xda\xc5Pjqxmjwiz['
(b'\x00\x00\x00\x02\x00\x00\x00v\x9d\xe0;\xf9\xa8\xef\xc6\xf4\x0e>>\x0b'
b"\x9f\x96'C\x0b\xcbS\x06\xb9\xcc\x9c\x05\x86o\xd8\xeaMu\x02\xf1\xe5g\xc6\xda"
b'\xa8\x8e\xe9k\x18\x00\x94\x87\xa5\t;M\x90A>\xa8U\x8dD\xd7>\xba\xff\xf8'
b'i\x947]\xfa\xef\xa0J\x00(\xa8$3\xca?|\xb0=\x00\x00\x00F\x00\x00\x00^')
Результат разбора:
'A1': {'B1': 51,
{'B2': 25822,
'B3': 16914056199915174935,
'B4': 13024,
'B5': 0.7259944081306458},
'A2': 80,
'A3': 'jqxmjwiz',
'A4': 91,
'A5': {'C1': [{'D1': 49407335,
'D2': [3336218766, 3916109824, 2491917577, 994938945],
'D3': 0.3287777006626129},
'D1': 1154956986,
{'D2': [4294470036, 928905967, 2689204264, 2820944842],
'D3': 0.9870641827583313}],
'C2': [-1646248967, -1460680972],
'C3': 14,
'C4': 0.1855912059545517},
'A6': -7627053725993728327,
'A7': 204,
'A8': -7204204213970514571}
Пример 2
Двоичные данные:
b'\xeaELUE\xcc\x90\x94pp \xc9\xb2\xb0\xc3\x1d\xb9!?D\xba\x86\xb7mvnmdpmo\xa4'
(b'\x00\x00\x00\x02\x00\x00\x00vN`uq}x\xed\xa6e\xbd\xf6\x96?b\x16\x0c'
b'\xa9\x13\xcc\xfc\x86\x97\xb7Z\xf1\xf9S18%-\x01`\x18\xfaT\xda1\xear\xe4\xf5Vi'
b"\x06\x93\x85'\xed\xf8?Ps\xb8\x97*\x97\x1e\x1cr\xd1\x8dwk\x17\x94\xd5\xca"
b'\xe2\x94>\x80\x87Q?{\xcc\xe1\x00\x00\x00F\x00\x00\x00^')
Результат разбора:
'A1': {'B1': -52,
{'B2': 37012,
'B3': 8102011780297966365,
'B4': 47393,
'B5': 0.7684711217880249},
'A2': 183,
'A3': 'mvnmdpmo',
'A4': 164,
'A5': {'C1': [{'D1': 755064856,
'D2': [4199864881, 3933398261, 1449723539, 2233986552],
'D3': 0.8142657279968262},
'D1': 2536150814,
{'D2': [477286797, 2003507092, 3586843284, 1048610641],
'D3': 0.9835949540138245}],
'C2': [1314944369, 2105077158],
'C3': 101,
'C4': -0.12040375918149948},
'A6': 7067850585525779590,
'A7': 151,
'A8': -5234605563719895003}
Задача №12
Реализовать разбор двоичного формата данных. Данные начинаются с сигнатуры 0x46 0x52 0x55 0x57 0x57
, за которой следует
структура A. Порядок байт: от старшего к младшему. Адреса указаны в виде смещений от начала данных. В решении предлагается использовать
модуль struct.
Структура A:
Поле | Описание |
---|---|
1 | float |
2 | uint8 |
3 | uint32 |
4 | Структура B |
Структура B:
Поле | Описание |
---|---|
1 | Размер (uint16) и адрес (uint32) массива адресов (uint16) структур C |
2 | Адрес (uint16) структуры D |
Структура C:
Поле | Описание |
---|---|
1 | int16 |
2 | int16 |
3 | float |
4 | uint8 |
5 | Массив int8, размер 2 |
6 | float |
7 | int64 |
8 | Массив int16, размер 5 |
Структура D:
Поле | Описание |
---|---|
1 | uint64 |
2 | uint64 |
3 | int8 |
4 | Массив int16, размер 7 |
5 | int16 |
6 | uint64 |
7 | int64 |
Ниже показаны примеры разбора двоичного формата.
Пример 1
Двоичные данные:
b'FRUWW?p\xe8,\x02n%+\x8c\x00\x02\x00\x00\x00X\x00\\`\x89XZ>R\xe02\xb7\x8ae>tI'
(b'n\xadx\x8dA\xe3\xeb\x81\xa7\xa0S\x9b\xcd\x9dyhV\xe8\xbd)\x86\xca\xdc>'
b'\xe5\xb3\xac\xaf\x99m\xbfS\x8bu\xf7\x07\x85PSR1\x9c\xf3\x10kP\xef\xb5'
b'\x96m\xfa\x8d\x00\x16\x007\xe6\xca\x85\x02\x06\x7f\x01\xda\x84h\x10\xed'
b'c\x1d\xfd\x10#\xedVP\xb1\xafXp]\x15\x86\xbb*\xcbW\xb8\xe4\x88\x01\x16'
b"\x827\xc7*n.X\xdb\x8e:'\xa4E")
Результат разбора:
'A1': 0.9410426616668701,
{'A2': 2,
'A3': 1847929740,
'A4': {'B1': [{'C1': 24713,
'C2': 22618,
'C3': 0.2059333622455597,
'C4': 183,
'C5': [-118, 101],
'C6': 0.23856136202812195,
'C7': -5946847993806487129,
'C8': [-24493, -25651, -25223, 26710, -5955]},
'C1': 10630,
{'C2': -13604,
'C3': 0.44863641262054443,
'C4': 175,
'C5': [-103, 109],
'C6': -0.8263466954231262,
'C7': -646401441462603364,
'C8': [-3312, 27472, -4171, -27027, -1395]}],
'B2': {'D1': 16630250817764393434,
'D2': 9540894422340599056,
'D3': 35,
'D4': [-4778, 20657, -20648, 28765, 5510, -17622, -13481],
'D5': -18204,
'D6': 9800139012672268910,
'D7': 3339660527602738245}}}
Пример 2
Двоичные данные:
b'FRUWW?-\xde|\x18b\x95\x1a\x0e\x00\x03\x00\x00\x00y\x00\x7fs\xd4v\xc4\xbfj'
(b'\xd0\xec\xa3\xf5\x00\xbfOj\x811C\xd2\xa9\x94:\xe3\xfbl\xb0v\x00+\xeb\x8d'
b"rXg\xbf\xdco\x0e?V'$\xc8\xe5\xcc>\x8f\xdd\x98ObL\xc2E\xda\xe8\xdd\xd3s"
b' RY\xf0\xb4\xe4\xd8\x89#\x1cU\x1c>\xfc"g\xc7=\x93\xbfG\xe6\xe6\xc0'
b'\xb7\x0c\xb78\xb2\xed\xf4\xa7%\x9d+\xde\xd8!\x0b\xb6\x01\x00\x16\x00'
b'7\x00X\xde\x19~\x00\xdb\xa8\x03\x05@E\xfbb\xc4\xa4;\x92X\x10k\xbe\xb1'
b'Q\x08\x04\xf2\xef\x84\x83#\xd5B\xba\xee@t\xe3\x94\x89Y\x19f?&qY\xc4/,Z')
Результат разбора:
'A1': 0.6791760921478271,
{'A2': 24,
'A3': 1653938702,
'A4': {'B1': [{'C1': 29652,
'C2': 30404,
'C3': -0.917250394821167,
'C4': 163,
'C5': [-11, 0],
'C6': -0.810218870639801,
'C7': 3549912557076276219,
'C8': [27824, 30208, 11243, -29326, 22631]},
'C1': -16420,
{'C2': 28430,
'C3': 0.8365347385406494,
'C4': 200,
'C5': [-27, -52],
'C6': 0.2809875011444092,
'C7': 5720218873993291997,
'C8': [-11405, 8274, 23024, -19228, -10103]},
'C1': 8988,
{'C2': 21788,
'C3': 0.49244996905326843,
'C4': 199,
'C5': [61, -109],
'C6': -0.7808669805526733,
'C7': -4560162116619538956,
'C8': [-22747, -25301, -8488, 8459, -18943]}],
'B2': {'D1': 16003961292988089093,
'D2': 4631384193444887442,
'D3': 88,
'D4': [4203, -16719, 20744, 1266, -4220, -31965, -10942],
'D5': -17682,
'D6': 4644587342824806758,
'D7': 4550449103861918810}}}
Задача №12
Реализовать разбор двоичного формата данных. Данные начинаются с сигнатуры 0x4b 0x50 0x52 0x64
, за которой следует структура
A. Порядок байт: от старшего к младшему. Адреса указаны в виде смещений от начала данных. В решении предлагается использовать модуль
struct.
Структура A:
Поле | Описание |
---|---|
1 | int32 |
2 | Размер (uint32) и адрес (uint16) массива адресов (uint32) структур B |
3 | Адрес (uint16) структуры C |
4 | double |
5 | Размер (uint32) и адрес (uint32) массива int64 |
Структура B:
Поле | Описание |
---|---|
1 | uint16 |
2 | uint8 |
Структура C:
Поле | Описание |
---|---|
1 | Структура D |
2 | int64 |
3 | Массив float, размер 8 |
4 | float |
Структура D:
Поле | Описание |
---|---|
1 | Размер (uint16) и адрес (uint32) массива uint16 |
2 | Массив int8, размер 7 |
Ниже показаны примеры разбора двоичного формата.
Пример 1
Двоичные данные:
b'KPRd\x8b\xc4\xcb\xe3\x00\x00\x00\x08\x008\x00\\?\xe43\x1a\x9fF\xdd\x06'
(b'\x00\x00\x00\x03\x00\x00\x00\x95\x93<\xc3\x8a\xfd\xde\x0f\xb9\x03(j\x17'
b'x\xed\xeb\xfe\x8f#\xb5\xc5\xdb\xf5\xcd\x1e\x00\x00\x00 \x00\x00\x00#'
b'\x00\x00\x00&\x00\x00\x00)\x00\x00\x00,\x00\x00\x00/\x00\x00\x002'
b'\x00\x00\x0056\xa0&\x1a\x00\x02\x00\x00\x00X\xcc|&[:7\xad\tb&'
b'\xf3\xa3\x05\xe0\xd4\xbe+[\x8d?\x0f@\xc5\xbf\\\xbcB\xbe\x87\xbf\xa9\xbe\xaau'
b'\xc7?4\x7f\xfa?:ZS\xbef\xb9\x10\xbd\xaa\x86\x84\xdd\xf0^&x\x1b\x806\xf0\r-'
b'\xf2\xb19\xdb\x1e\xe5\x19\xe5d\x17;K\x8b')
Результат разбора:
'A1': -1950037021,
{'A2': [{'B1': 37692, 'B2': 195},
'B1': 35581, 'B2': 222},
{'B1': 4025, 'B2': 3},
{'B1': 10346, 'B2': 23},
{'B1': 30957, 'B2': 235},
{'B1': 65167, 'B2': 35},
{'B1': 46533, 'B2': 219},
{'B1': 62925, 'B2': 30}],
{'A3': {'C1': {'D1': [13984, 9754], 'D2': [-52, 124, 38, 91, 58, 55, -83]},
'C2': 676145721912975572,
'C3': [-0.1673414260149002,
0.5595820546150208,
-0.8622475862503052,
-0.26513412594795227,
-0.3329298198223114,
0.7050777673721313,
0.7279407382011414,
-0.22531533241271973],
'C4': -0.08326438069343567},
'A4': 0.6312382803797909,
'A5': [-2454358277600083914, -1149211809530914018, -1938265946557035637]}
Пример 2
Двоичные данные:
b'KPRdj\x18I\xf6\x00\x00\x00\x02\x00&\x002\xbf\xd1\xa1\xe4?\x9f\x82\x94'
(b'\x00\x00\x00\x03\x00\x00\x00k\xd3\xc3\x1ay\x92\xdf\x00\x00\x00 \x00\x00'
b'\x00#QP\x93\xbd\x00\x02\x00\x00\x00.\x1b\x979G\xb6;\xe6I4\x94\xe3j'
b'\xca\x86\xdb\xbf,WK;\xbe\xd0\xbf>M>5\xbf$\x0eG?i\x11\r\xbf9\xb4\xe6='
b'\xd0\x01\xff\xbfE\x07>\xbd~\x07\xad{\x07.AVXcE\x9e8\xf9\x04\x1a'
b'\xf2\x97\x81\xb1\xdc\xe6Q\x96>\xbcl')
Результат разбора:
'A1': 1779976694,
{'A2': [{'B1': 54211, 'B2': 26}, {'B1': 31122, 'B2': 223}],
'A3': {'C1': {'D1': [20816, 37821], 'D2': [27, -105, 57, 71, -74, 59, -26]},
'C2': 5275004768027838171,
'C3': [-0.6732069849967957,
0.005823224317282438,
0.20043261349201202,
-0.640842854976654,
0.9104164242744446,
-0.7254165410995483,
0.10156630724668503,
-0.7696417570114136],
'C4': -0.06201903894543648},
'A4': -0.2755060788459016,
'A5': [8865105249658495813, -7045607820993849471, -5630372196032529300]}
Задача №12
Реализовать разбор двоичного формата данных. Данные начинаются с сигнатуры 0xf3 0x57 0x55 0x57
, за которой следует структура
A. Порядок байт: от младшего к старшему. Адреса указаны в виде смещений от начала данных. В решении предлагается использовать модуль
struct.
Структура A:
Поле | Описание |
---|---|
1 | uint8 |
2 | int16 |
3 | Структура B |
4 | int8 |
5 | int16 |
6 | Адрес (uint32) структуры D |
Структура B:
Поле | Описание |
---|---|
1 | int8 |
2 | Массив char, размер 8 |
3 | Структура C |
4 | uint8 |
Структура C:
Поле | Описание |
---|---|
1 | uint16 |
2 | float |
Структура D:
Поле | Описание |
---|---|
1 | uint16 |
2 | double |
3 | uint32 |
4 | int32 |
5 | Размер (uint32) и адрес (uint32) массива адресов (uint16) структур E |
6 | Массив float, размер 4 |
7 | Массив int8, размер 2 |
8 | int64 |
Структура E:
Поле | Описание |
---|---|
1 | int16 |
2 | float |
Ниже показаны примеры разбора двоичного формата.
Пример 1
Двоичные данные:
b'\xf3WUW8\xe1\\\x14ufffnouy,\x17\x84Z9?\x8b\x11\x96\x0b>\x00\x00\x00\x13\x14'
(b'\x02\xa8!?\xb9\x02\x9a\n\x89\xbe\x89\t\xb3i\x9f\xbe\x1a\x03\x15\xa7'
b'\xa7\xbd\x1e\x00$\x00*\x000\x00S\x0cHi\xa5g\xb6U\xd6\xbf?\x11\x1e?t<e\xc3'
b'\x04\x00\x00\x006\x00\x00\x00J\xa4\x92>\xb0$\xbb\xbeh\xd7\x91>D\xd5d?'
b'\x92\xfc9\xd8W\xde\xefTl\x9e')
Результат разбора:
'A1': 56,
{'A2': 23777,
'A3': {'B1': 20,
'B2': 'ufffnouy',
'B3': {'C1': 5932, 'C2': 0.7240374088287354},
'B4': 139},
'A4': 17,
'A5': 2966,
'A6': {'D1': 3155,
'D2': -0.3489814769906343,
'D3': 1058935103,
'D4': -1016775564,
'D5': [{'E1': 5139, 'E2': 0.6314698457717896},
'E1': 697, 'E2': -0.2676590085029602},
{'E1': 2441, 'E2': -0.31135329604148865},
{'E1': 794, 'E2': -0.08186165243387222}],
{'D6': [0.2864096760749817,
-0.36551427841186523,
0.28484654426574707,
0.8938791751861572],
'D7': [-110, -4],
'D8': -7031151529027971015}}
Пример 2
Двоичные данные:
b'\xf3WUWl\xc8\xddZqvfdviud\x94\x89\xfa\xc31?\xfb\xce\x97B>\x00'
(b'\x00\x00\x9d\xaf\x03d\xe1\xbe3~\xde\xe3\xee>\x10\x9a\x1f\xca\xf5>\xab;\xbdl'
b'1\xbf\x1e\x00$\x00*\x000\x00\xa8\x11\x18-O=\x8eZ\xc9?\x08vP\xea\xd4w\x12\xa2'
b'\x04\x00\x00\x006\x00\x00\x00u\x8d{\xbf\x8f\xd5:?\x95\xf9/?\x80\xbc\xa4\xbe'
b'\xc3\xbb\x03iY[4\x97\xa3\xbf')
Результат разбора:
'A1': 108,
{'A2': -8760,
'A3': {'B1': 90,
'B2': 'qvfdviud',
'B3': {'C1': 35220, 'C2': 0.6943966150283813},
'B4': 251},
'A4': -50,
'A5': 17047,
'A6': {'D1': 4520,
'D2': 0.1980760382997253,
'D3': 3931141640,
'D4': -1575847980,
'D5': [{'E1': -20579, 'E2': -0.44021615386009216},
'E1': 32307, 'E2': 0.4665822386741638},
{'E1': -26096, 'E2': 0.4800576865673065},
{'E1': 15275, 'E2': -0.6930654644966125}],
{'D6': [-0.9826272130012512,
0.7298211455345154,
0.687402069568634,
-0.3217506408691406],
'D7': [-61, -69],
'D8': -4637696940134799101}}
Задача №12
Реализовать разбор двоичного формата данных. Данные начинаются с сигнатуры 0x47 0x51 0x4e 0xa0
, за которой следует структура
A. Порядок байт: от младшего к старшему. Адреса указаны в виде смещений от начала данных. В решении предлагается использовать модуль
struct.
Структура A:
Поле | Описание |
---|---|
1 | int8 |
2 | Структура B |
3 | Массив int8, размер 3 |
Структура B:
Поле | Описание |
---|---|
1 | Массив структур C, размер 4 |
2 | Структура D |
3 | Структура E |
4 | uint16 |
Структура C:
Поле | Описание |
---|---|
1 | Размер (uint32) и адрес (uint32) массива int16 |
2 | uint16 |
3 | uint32 |
Структура D:
Поле | Описание |
---|---|
1 | int16 |
2 | Массив int16, размер 8 |
3 | int16 |
Структура E:
Поле | Описание |
---|---|
1 | uint8 |
2 | double |
Ниже показаны примеры разбора двоичного формата.
Пример 1
Двоичные данные:
b'GQN\xa0\xe1\x02\x00\x00\x00_\x00\x00\x00\x80\x08\x12B\xaa\n\x04\x00\x00\x00c'
(b'\x00\x00\x000\xbc\x86r\x07\x80\x05\x00\x00\x00k\x00\x00\x00\xb1\xd9S'
b'\x867\x9d\x04\x00\x00\x00u\x00\x00\x00\x92\xf2\x84\xfbh=\xce\x1e{'
b'\x11\xb7\xd3\xe7\x83\xef\xdc>\x9f\xec\xf8\xe2h:\x93\xf7A\xb8\xa4\xca'
b'\xafS\x9c\x87\xd1?/\xb9+\xaf\xbcW\x08\xa1!;u[\xa4[&\xbb\xd4\xd8o$\xf9j'
b'\x10\x99\x0f\x81\xf0x\x87*~\x1d\xf4\x1f@')
Результат разбора:
'A1': -31,
{'A2': {'B1': [{'C1': [2135, 8609], 'C2': 2176, 'C3': 178930194},
'C1': [30011, -23461, 9819, -11077],
{'C2': 48176,
'C3': 2147971718},
'C1': [28632, -1756, 4202, 3993, -3967],
{'C2': 55729,
'C3': 2637661779},
'C1': [-30856, 32298, -3043, 16415],
{'C2': 62098,
'C3': 1030290308}],
'B2': {'D1': 7886,
'D2': [4475,
-11337,
-31769,
-8977,
-24770,
-1812,
26850,
-27846],
'D3': 16887},
'B3': {'E1': 184, 'E2': 0.2739020173313895},
'B4': 47407},
'A3': [43, -81, -68]}
Пример 2
Двоичные данные:
b'GQN\xa0\x14\x03\x00\x00\x00_\x00\x00\x00\x11\xe4/|\xf2\xbb\x05\x00\x00\x00e'
(b'\x00\x00\x00\xdd\x9ekM\xd6\xf1\x04\x00\x00\x00o\x00\x00\x00\x06\xaf\xbc'
b'\xbbS\x80\x02\x00\x00\x00w\x00\x00\x00\xc3aY\xb1\xb2\xd3db\xb62!9\x0e'
b'*3\xeb\xbf#b\xe0\xaf\xaa\x0eD\xcc\x95\xc6\xbe\xc3\xaa\x06\xdd\xa7'
b'\xe0\xbf\xb5\x05\xfc\x07|\xc21\xa2s\xc7)hw\x88\x00\xf7\x1a\x14\xe6\xe3[E'
b'Y\xbb\xa3[\xc28\x05\x84\x81(\xb1')
Результат разбора:
'A1': 20,
{'A2': {'B1': [{'C1': [12738, 29602, 10695], 'C2': 58385, 'C3': 3153230895},
'C1': [30568, 136, 6903, -6636, 23523],
{'C2': 40669,
'C3': 4057353579},
'C1': [22853, -23621, -15781, 1336],
{'C2': 44806,
'C3': 2152971196},
'C1': [-32380, -20184], 'C2': 25027, 'C3': 3551703385}],
{'B2': {'D1': 25188,
'D2': [12982, 14625, 10766, -5325, 9151, -8094, -21841, 17422],
'D3': -27188},
'B3': {'E1': 198, 'E2': -0.5204911356178099},
'B4': 1461},
'A3': [-4, 7, 124]}
Задача №12
Реализовать разбор двоичного формата данных. Данные начинаются с сигнатуры 0xe7 0x4e 0x50 0x4d 0x42
, за которой следует
структура A. Порядок байт: от младшего к старшему. Адреса указаны в виде смещений от начала данных. В решении предлагается использовать
модуль struct.
Структура A:
Поле | Описание |
---|---|
1 | int64 |
2 | Адрес (uint16) структуры B |
3 | Структура C |
4 | Структура E |
5 | uint64 |
6 | uint64 |
Структура B:
Поле | Описание |
---|---|
1 | uint16 |
2 | uint32 |
3 | Массив char, размер 3 |
4 | uint16 |
Структура C:
Поле | Описание |
---|---|
1 | uint16 |
2 | uint64 |
3 | uint16 |
4 | Размер (uint16) и адрес (uint16) массива структур D |
5 | int8 |
6 | int64 |
7 | int64 |
Структура D:
Поле | Описание |
---|---|
1 | int64 |
2 | uint64 |
3 | int8 |
4 | int32 |
5 | float |
Структура E:
Поле | Описание |
---|---|
1 | Структура F |
2 | Массив uint16, размер 5 |
3 | uint16 |
4 | uint64 |
5 | int8 |
Структура F:
Поле | Описание |
---|---|
1 | Массив uint16, размер 2 |
2 | uint32 |
3 | float |
4 | uint32 |
Ниже показаны примеры разбора двоичного формата.
Пример 1
Двоичные данные:
b'\xe7NPMB\xc6WA\xbc\x11\x13\xd1#e\x00+\x88\xd0\x8d\xa6\x955A\xbb\xea\x1c4\x02'
(b'\x00p\x00~\xc2\x89\x83\xa2xJ\xd6\x02T\xe3=\xef>`\xfc\xe8@\xa7B\x92'
b"\x96\xc0g\xee\xac\xc5\x08\xbf\xa3\x8af1\xca\x14\xcbw\\S'\xe4'\xc4\xa9."
b'T\xda\xf6\n\x9dE)H\xdb\xc7\x1dK\x9d\x00\xec\xa2\x87\nXziQ\xdf6%5\x0b\xed'
b'\xeb\xacmxwz\xf1BPb6t\xa6"\x900_\xcd\xd8\xd4\xb9=\xa3\x1e\x7f\xc0\x19\x8c'
b"\x82\xb5\xcfS\xbf\xddD\x86%\x1d\x12\x0bD'\xba\xffW\x02?\xa3\x9d\x82_\x9a"
b'\x96 \xcf\xaa\x06?')
Результат разбора:
'A1': 2580865028353775558,
{'A2': {'B1': 2869, 'B2': 1840049133, 'B3': 'xwz', 'B4': 17137},
'A3': {'C1': 34859,
'C2': 16914184523919822288,
'C3': 13340,
'C4': [{'D1': 3499335008776512080,
'D2': 2207676110690897247,
'D3': 127,
'D4': -2104747584,
'D5': -0.8273881077766418},
'D1': 4903032535715824861,
{'D2': 11358991964457384487,
'D3': -126,
'D4': 546740831,
'D5': 0.5260438323020935}],
'C5': 126,
'C6': 204432715074996674,
'C7': -1658344739361135788},
'A4': {'E1': {'F1': [42816, 37442],
'F2': 3999776918,
'F3': -0.5342662334442139,
'F4': 828803747},
'E2': [5322, 30667, 21340, 58407, 50215],
'E3': 11945,
'E4': 5199763785572080212,
'E5': -37},
'A5': 9773633628730498503,
'A6': 2681576168900679690}
Пример 2
Двоичные данные:
b'\xe7NPMB\xa12T\xe1=9\xb5\xc6e\x005vW\xdah\x95\xf4B\xfb\xe4\x14H\x02'
(b'\x00p\x00m:\xc6\xfd&\x0e?\xfcA}~\x12\xc1\xe0\xe1QU\xc1\xd3!\x12'
b'\x8d\xd4\xea\xd0\x9d\x89z\xbf\x0f*BH3(\xc8\xd4\xfe\x93\xce\xef\xfew\xe0Q'
b'\xaa\xcb@\x1fs\xff\xfd\xa0\x9f%H8\xa8\xa1\xc7\xfa@\xde\x04\x82\xeb(%\xeb'
b'b\xcb7s\xea\xa0\x15ecl\xdf\xae\xa2\xcc\xbc\xa6n\xdd\n\xd5\xe0H\x99\xe4'
b';*q\x8bG\xc0\x1a\x94\xc9\xad\xca\xcb>\xf7`\xf8~o\x9coJ9\x84\x99CN\xc5u'
b'8b\x80\x0690?\x17^\xbf')
Результат разбора:
'A1': -4128330545479011679,
{'A2': {'B1': 14283, 'B2': 362867315, 'B3': 'ecl', 'B4': 44767},
'A3': {'C1': 30261,
'C2': 16499855278048074327,
'C3': 18452,
'C4': [{'D1': -3095418326550262622,
'D2': 10047858680366975200,
'D3': 71,
'D4': -913040704,
'D5': 0.39803066849708557},
'D1': 5363677683907059959,
{'D2': 4068374778331366457,
'D3': 98,
'D4': 809043584,
'D5': -0.8675422072410583}],
'C5': 109,
'C6': 4754744636612658746,
'C7': 6147943321765576317},
'A4': {'E1': {'F1': [54209, 4641],
'F2': 3505050765,
'F3': -0.9786623120307922,
'F4': 1212295695},
'E2': [10291, 54472, 37886, 61390, 30718],
'E3': 20960,
'E4': 11600709085086927786,
'E5': -97},
'A5': 4682274259730974757,
'A6': 7127831692924028126}