Задача №12
Реализовать разбор двоичного формата данных. Данные начинаются с сигнатуры 0x54 0x56 0x4d
, за которой следует структура A.
Порядок байт: от младшего к старшему. Адреса указаны в виде смещений от начала данных. В решении предлагается использовать модуль
struct.
Структура A:
Поле | Описание |
---|---|
1 | Структура B |
2 | uint16 |
3 | int64 |
4 | int64 |
5 | uint32 |
6 | Размер (uint16) и адрес (uint16) массива char |
7 | Массив double, размер 4 |
8 | int16 |
Структура B:
Поле | Описание |
---|---|
1 | float |
2 | Адрес (uint16) структуры C |
Структура C:
Поле | Описание |
---|---|
1 | Массив структур D, размер 3 |
2 | uint64 |
3 | Размер (uint16) и адрес (uint32) массива int16 |
4 | float |
5 | int64 |
Структура D:
Поле | Описание |
---|---|
1 | uint32 |
2 | float |
3 | uint8 |
4 | uint32 |
5 | uint32 |
Ниже показаны примеры разбора двоичного формата.
Пример 1
Двоичные данные:
b'TVMXZ\x1d\xbfK\x00\xc3\x02\xafK\xed\x8eR\xb5\xdc\xe9\x10C\x1b\xff6\x88p\xeeD'
(b'baO\x05\x00\x98\x000\xb9\xf9o\x11\x00\xe0?H\xc1\xd43\xfc{\xc7\xbf\x80'
b'\x977\xb3\xd0(\xa5?\xc4\x7f\x91 k\xbb\xeb\xbf\xa7\x07\xca!\xfd'
b'\xc4\x9d\x9d\xde\xcd`\xae\xf5\xc9x>$5\xfc\xe4\xcdqx\x81\t\x96y\x8d|'
b'\xabe\x17?u~\xcf-\x91\x18\x98c}\xbf\xa3\x1d\xd7\xb40\xf0>\x97\x14\x9b'
b'\x8d\x1f\x0b\x88\xf2\x06%/\xeb\xb2\xa6\x0b\xe7\xaf\x03\x00E\x00\x00\x00'
b'{1\x9f>\xc7\xf3\xb9\x0b\xb7o\xd7Aizyuj')
Результат разбора:
'A1': {'B1': -0.6146597862243652,
{'B2': {'C1': [{'D1': 2925579742,
'D2': 0.24295790493488312,
'D3': 36,
'D4': 3454336053,
'D5': 159479921},
'D1': 2089646486,
{'D2': 0.5913950800895691,
'D3': 117,
'D4': 2435698558,
'D5': 2103679000},
'D1': 3609043903,
{'D2': 0.4691215753555298,
'D3': 151,
'D4': 529373972,
'D5': 116557835}],
'C2': 12675112486851784485,
'C3': [8650, -15107, -25187],
'C4': 0.31092438101768494,
'C5': 4744383564424541127}},
'A2': 707,
'A3': -1595200801806136401,
'A4': -1265361725501521136,
'A5': 1331782212,
'A6': 'izyuj',
'A7': [0.5000083148022778,
-0.18347122698606655,
0.04132702052792947,
-0.8666282306767177],
'A8': 1959}
Пример 2
Двоичные данные:
b'TVMq\xe6\xd8<I\x00\x04\x18\x9c\x89\x9d\x8e\x10Q&\xb2\x92\xcb\xb7n\xcf'
(b'5\xfap\xf6\xbc\x0c#\x04\x00\x96\x00\xda\x88\xa9_\x90\x95\xe4?\x08\xa0g\xe4M'
b'\x82\xd7\xbf\xb2\xc4\xd0\xcf\xe19\xec\xbf\xf4\x15\xfc\xe2X\xd7\xd7\xbf\xc8'
b'M9\xbdb\x91\xaa\x9e\x92)\x05\x15r?\xc5\xd6\r\xa8\x1a\x83f\t\xc8\x03b'
b'w\xce\xc7b\xc7\xbeh\x99\x19\x19\xe6\xd4\x9cL\x92\x13QT\x1e\xbc\x9cP?\xb8'
b'4\x06-\xeaJ/\xe9\xff\xb8\xb7\xc5\xa7%\x02\x0f\x8d\x02\x00E\x00'
b'\x00\x00\x06\x86\x86>\x86\xc8|\xc1\x91&\x15\x08rgsp')
Результат разбора:
'A1': {'B1': 0.026477070525288582,
{'B2': {'C1': [{'D1': 697474730,
'D2': 0.9456332325935364,
'D3': 197,
'D4': 447221206,
'D5': 3356059267},
'D1': 3463930371,
{'D2': -0.38942548632621765,
'D3': 104,
'D4': 3860404633,
'D5': 2454494420},
'D1': 508842259,
{'D2': 0.8148915767669678,
'D3': 184,
'D4': 3928819252,
'D5': 4293472074}],
'C2': 10164345244750297016,
'C3': [-17095, -28318],
'C4': 0.2627412676811218,
'C5': 582414134272641158}},
'A2': 6148,
'A3': -5609707154289358436,
'A4': 8140878441457634194,
'A5': 588037366,
'A6': 'rgsp',
'A7': [0.6432573192980968,
-0.36732814126162383,
-0.8820656832596312,
-0.37251875082469543],
'A8': 19912}
Задача №12
Реализовать разбор двоичного формата данных. Данные начинаются с сигнатуры 0x41 0x4d 0x4f 0x4a 0x32
, за которой следует
структура A. Порядок байт: от старшего к младшему. Адреса указаны в виде смещений от начала данных. В решении предлагается использовать
модуль struct.
Структура A:
Поле | Описание |
---|---|
1 | uint32 |
2 | uint16 |
3 | Адрес (uint16) структуры B |
4 | int32 |
5 | int64 |
6 | uint8 |
7 | Адрес (uint32) структуры F |
Структура B:
Поле | Описание |
---|---|
1 | Массив адресов (uint16) структур C, размер 2 |
2 | Структура E |
3 | int32 |
4 | int64 |
5 | uint8 |
Структура C:
Поле | Описание |
---|---|
1 | uint8 |
2 | uint32 |
3 | Адрес (uint32) структуры D |
Структура D:
Поле | Описание |
---|---|
1 | Массив float, размер 7 |
2 | uint8 |
3 | int32 |
Структура E:
Поле | Описание |
---|---|
1 | uint8 |
2 | uint64 |
3 | int16 |
Структура F:
Поле | Описание |
---|---|
1 | Массив int16, размер 5 |
2 | uint16 |
3 | Массив uint8, размер 7 |
Ниже показаны примеры разбора двоичного формата.
Пример 1
Двоичные данные:
b'AMOJ2\xf5x\xc0\xc8m\xa1\x00r\xb6\xbf\xc0\x81\xfe\x8a)|z\xc1\x9dS\x0f\x00\x00'
(b'\x00\x8e?\x16\x97\xe2?\x17\xb7\xf0\xbf\x0b\x0bp?\x05\n\x1b>\xf8\xd9\xd0>\xa6'
b'/\x91\xbf\x02\xac\xfd\xb4\xc7\xb8\xefH\x0b*\xd8B\xbc\x00\x00\x00\x1e'
b'?\x15\x9a~>\x9b\xb56=\x93;\x8e\xbf9}p\xbf:\x9c\x0b\xbfY\xee\xf4'
b'\xbe\xba\x84\xa8\xf8LK\xeeE*\x887ue\x00\x00\x00H\x00?\x00i\xdb\x01'
b'|\xa5\x8b\x9e5\xa0\x1fJR\xf8\xf1\x19\xfe\xbc;\xc5\xfe\xfbn(;\xf1\xc4U'
b':\x89\x9fV\xf9A\x82\x93\x0c\x1cL\x1e\x07\xb0\xbe.Y')
Результат разбора:
'A1': 4118331592,
{'A2': 28065,
'A3': {'B1': [{'C1': 11,
'C2': 718815932,
'C3': {'D1': [0.5882550477981567,
0.5926504135131836,
-0.5431432723999023,
0.5196854472160339,
0.4860367774963379,
0.32458165287971497,
-0.5104520916938782],
'D2': 180,
'D3': -944181432}},
'C1': 42,
{'C2': 2285335909,
'C3': {'D1': [0.5843886137008667,
0.3041169047355652,
0.0718909353017807,
-0.7245702743530273,
-0.7289435267448425,
-0.8513023853302002,
-0.36429333686828613],
'D2': 248,
'D3': 1280044613}}],
'B2': {'E1': 219, 'E2': 107142510223400991, 'E3': 19026},
'B3': -118416898,
'B4': -4883091672022505413,
'B5': 241},
'A4': -1228947327,
'A5': -105226026677592749,
'A6': 15,
'A7': {'F1': [-15275, 14985, -24746, -1727, -32109],
'F2': 3100,
'F3': [76, 30, 7, 176, 190, 46, 89]}}
Пример 2
Двоичные данные:
b'AMOJ2\x1b\xa7\x80k\x101\x00r3\x8fXw\x9ar-\x16\x14\xce;\xf4\xcd\x00\x00'
(b"\x00\x8e\xbe3\xb09>\x8b\xbbK>)\x7f\xf4>O\xf6\xbd>\xbdA'?YT/\xbf\x14"
b'\x14\xfaO\xa44$i\xab\xbd\xee\xd4\xa4\x00\x00\x00\x1e>$\x8dC\xbfl\x1b\x1a'
b'?G\xc9\xc7?\x08)\xa1?wj&\xbd\xdd\xdc\xba?\x18j\x1e+\x0f\xe1\x9b\xd6r\xd7D'
b"0;\x00\x00\x00H\x00?\x00i\x80\xe4}\x16\x8e\xc2I\xfe'\x7f\x1a\xa2t\r\xaf}]^"
b'ZCC\x03\xe3\x06\xf9u)x\xd4b\x9ew\xd1}\xa7\x82\xa3\x13\x8e\xacEh\x0e')
Результат разбора:
'A1': 463962219,
{'A2': 4145,
'A3': {'B1': [{'C1': 171,
'C2': 3186545828,
'C3': {'D1': [-0.17547692358493805,
0.2729133069515228,
0.16552716493606567,
0.2030896693468094,
0.36963769793510437,
0.8489407896995544,
-0.5784450769424438],
'D2': 79,
'D3': -1540086679}},
'C1': 114,
{'C2': 3611570235,
'C3': {'D1': [0.1606951206922531,
-0.9222885370254517,
0.7804226279258728,
0.5318852066993713,
0.9664634466171265,
-0.10833115875720978,
0.5953692197799683],
'D2': 43,
'D3': 266443734}}],
'B2': {'E1': 128, 'E2': 16464340615137197607, 'E3': 32538},
'B3': -1569452625,
'B4': 9033480169343615971,
'B5': 6},
'A4': 865032311,
'A5': -7317736871662044172,
'A6': 205,
'A7': {'F1': [-1675, 10616, -11166, -24969, -11907],
'F2': 42882,
'F3': [163, 19, 142, 172, 69, 104, 14]}}
Задача №12
Реализовать разбор двоичного формата данных. Данные начинаются с сигнатуры 0x48 0x43 0x4d 0x45
, за которой следует структура
A. Порядок байт: от младшего к старшему. Адреса указаны в виде смещений от начала данных. В решении предлагается использовать модуль
struct.
Структура A:
Поле | Описание |
---|---|
1 | Размер (uint32) и адрес (uint16) массива адресов (uint32) структур B |
2 | double |
3 | Структура C |
4 | uint64 |
Структура B:
Поле | Описание |
---|---|
1 | Массив char, размер 7 |
2 | int8 |
3 | uint16 |
Структура C:
Поле | Описание |
---|---|
1 | int16 |
2 | double |
3 | Адрес (uint32) структуры D |
4 | Массив uint16, размер 5 |
5 | Адрес (uint32) структуры E |
6 | uint8 |
Структура D:
Поле | Описание |
---|---|
1 | double |
2 | Размер (uint32) и адрес (uint32) массива uint64 |
3 | int32 |
4 | uint8 |
5 | float |
Структура E:
Поле | Описание |
---|---|
1 | uint32 |
2 | Размер (uint32) и адрес (uint16) массива int16 |
Ниже показаны примеры разбора двоичного формата.
Пример 1
Двоичные данные:
b"HCME\x02\x00\x00\x00K\x00T\xbf\xfd\x1fw7\xdd\xbf?%D'\xc0\x12m\xae\xde?"
(b'c\x00\x00\x00#\x98:2\xd4\x15\xbb6#\xa3\x88\x00\x00\x00F\x0b|\x90\xaaq'
b'\xdf\xee\x0fruihgqj\xe2\x0emyeupcju\x92\xea\xe67\x00\x00\x00A'
b'\x00\x00\x00\x85\\p\x10\xbf\x86|-\xd8\x1bi\x87\xc0\xdb\xf9\xca\xe2'
b'\x1a\x95\x835Y\xeb?\x02\x00\x00\x00S\x00\x00\x00\xff6Z\xecKV\xd9\x80>'
b'b3\xad\xbeJ\xc6\xd2\xbf\xd5\xc5\xa2\xdf\xb3\xdc\xf7\x17\x06\x00\x00\x00'
b'|\x00')
Результат разбора:
'A1': [{'B1': 'ruihgqj', 'B2': -30, 'B3': 27918},
{'B1': 'yeupcju', 'B2': -110, 'B3': 59114}],
{'A2': -0.4565103351987905,
'A3': {'C1': 9535,
'C2': 0.47939612227547834,
'C3': {'D1': 0.854639775273281,
'D2': [3277642783991553157, 14625962884814412760],
'D3': -329632001,
'D4': 75,
'D5': 0.2516581416130066},
'C4': [38947, 12858, 5588, 14011, 41763],
'C5': {'E1': 402119859,
'E2': [13154, -16723, -14774, -16430, -14891, -8286]},
'C6': 70},
'A4': 1148100634311949323}
Пример 2
Двоичные данные:
b'HCME\x03\x00\x00\x00U\x00\x86\xcd\t4l\x18\xe4?\x19\xea&\x83t\xbe'
(b'\x8f\xc9\xee?y\x00\x00\x00|L\xe2\xfc\xe2bB\xedF\x95\xa0\x00\x00\x00\xb5i'
b'/\xb6\xa6x\xf3\x97\xeaacxbpcd\x01\x10qwdtoagn\xe0\xb0\x96nwohmkcy\xa1'
b'\xf07\x00\x00\x00A\x00\x00\x00K\x00\x00\x00\xbe\x8f\x82\xae#{\x14\x9bANn'
b'|G\x04\xb3\r\xad7\xf0s>\x9f$\xdb\xdc\xe8\xa3\xde\xfeC\xea?\x03\x00\x00'
b'\x00a\x00\x00\x00\x0f~|<\xce;GC\xbf\x1bx#\xba\xb4\xd6${\xc9\xe7\x1ck\x9b\xfa'
b']\x12\x08\x92\x07\x00\x00\x00\x92\x00')
Результат разбора:
'A1': [{'B1': 'acxbpcd', 'B2': 1, 'B3': 28944},
{'B1': 'wdtoagn', 'B2': -32, 'B3': 38576},
{'B1': 'nwohmkc', 'B2': 121, 'B3': 61601}],
{'A2': 0.6279812828419586,
'A3': {'C1': -5607,
'C2': 0.96210467527644,
'C3': {'D1': 0.8208002422755061,
'D2': [11174691968594907070,
987137448401063489,
15790921284049713069],
'D3': 1014791695,
'D4': 206,
'D5': -0.7628056406974792},
'C4': [19580, 64738, 25314, 60738, 38214],
'C5': {'E1': 2450002525,
'E2': [30747, -17885, -10572, 31524, -6199, 27420, -1381]},
'C6': 181},
'A4': 16904247425877028713}
Задача №12
Реализовать разбор двоичного формата данных. Данные начинаются с сигнатуры 0x66 0x4a 0x53 0x51 0x51
, за которой следует
структура A. Порядок байт: от младшего к старшему. Адреса указаны в виде смещений от начала данных. В решении предлагается использовать
модуль struct.
Структура A:
Поле | Описание |
---|---|
1 | Адрес (uint32) структуры B |
2 | Структура D |
3 | uint64 |
Структура B:
Поле | Описание |
---|---|
1 | Размер (uint16) и адрес (uint16) массива структур C |
2 | int16 |
3 | Массив float, размер 2 |
4 | uint32 |
5 | float |
6 | uint64 |
Структура C:
Поле | Описание |
---|---|
1 | int8 |
2 | int16 |
3 | int16 |
4 | Массив uint8, размер 2 |
Структура D:
Поле | Описание |
---|---|
1 | Массив float, размер 6 |
2 | uint16 |
Ниже показаны примеры разбора двоичного формата.
Пример 1
Двоичные данные:
b'fJSQQ9\x00\x00\x00\xcb\xaa\x91>|\x13@\xbf,M\xb3\xbc-\xf5\x13\xbf\xb9\xeek'
(b'\xbf\x9d\xc8B?E\xd0\xeeU\xfa\x90\xf9\xbe&11{\xa6|nP\xbdu\xdc\x0b\xbf\x7f\xae'
b'\x81\x02\x00+\x00\x8a/-\x06Q>\xe9\xae\x9e=\\\xe5\x9f\xc6\xd5\xcc\xbf>2'
b'e\xda\x98F\xd2a\\')
Результат разбора:
'A1': {'B1': [{'C1': 49, 'C2': -22917, 'C3': 28284, 'C4': [80, 189]},
{'C1': 117, 'C2': 3036, 'C3': 32703, 'C4': [174, 129]}],
{'B2': 12170,
'B3': [0.20412512123584747, 0.07748205214738846],
'B4': 3332367708,
'B5': 0.3746096193790436,
'B6': 6656832924884297010},
'A2': {'D1': [0.2845061719417572,
-0.7502973079681396,
-0.021887384355068207,
-0.5779598355293274,
-0.9216113686561584,
0.7608736157417297],
'D2': 53317},
'A3': 3541728136061933038}
Пример 2
Двоичные данные:
b"fJSQQ9\x00\x00\x00\x9a\xf7'?\xa4\x03\xcc\xbe\xdb\xe2d\xbf\x943V?\xc3\xb2\\"
(b"?&'\xd1>\xb7\xf6L\x1a\x8f\xc2\x15\x97\x93\x85\xf1}L\x9fg{\xea\xa4u.\x1f\xfeQ"
b'\xfa\x02\x00+\x00\xd9\xdc\x95\x06y?l\x81\xc8>\xd1\x93$h\x8a\xe6d\xbf\x08'
b'e]\xd7w\xdfs}')
Результат разбора:
'A1': {'B1': [{'C1': -15, 'C2': 19581, 'C3': 26527, 'C4': [123, 234]},
{'C1': -92, 'C2': 11893, 'C3': -481, 'C4': [81, 250]}],
{'B2': -8999,
'B3': [0.9727566838264465, 0.3916124105453491],
'B4': 1747227601,
'B5': -0.894142746925354,
'B6': 9039814582870041864},
'A2': {'D1': [0.6561218500137329,
-0.39846527576446533,
-0.8940865397453308,
0.8367245197296143,
0.8621026873588562,
0.4085018038749695],
'D2': 63159},
'A3': 9625202948335147596}
Задача №12
Реализовать разбор двоичного формата данных. Данные начинаются с сигнатуры 0x57 0x4a 0x58 0x42
, за которой следует структура
A. Порядок байт: от старшего к младшему. Адреса указаны в виде смещений от начала данных. В решении предлагается использовать модуль
struct.
Структура A:
Поле | Описание |
---|---|
1 | Структура B |
2 | Структура C |
3 | Массив int8, размер 8 |
4 | Размер (uint32) и адрес (uint32) массива uint64 |
5 | Массив uint8, размер 3 |
Структура B:
Поле | Описание |
---|---|
1 | uint8 |
2 | int8 |
Структура C:
Поле | Описание |
---|---|
1 | int64 |
2 | Структура D |
3 | int8 |
4 | Массив структур F, размер 4 |
Структура D:
Поле | Описание |
---|---|
1 | uint16 |
2 | Адрес (uint16) структуры E |
3 | int16 |
4 | uint32 |
5 | float |
Структура E:
Поле | Описание |
---|---|
1 | Размер (uint32) и адрес (uint16) массива int64 |
2 | float |
3 | float |
4 | int8 |
Структура F:
Поле | Описание |
---|---|
1 | int32 |
2 | uint16 |
3 | int8 |
4 | uint32 |
Ниже показаны примеры разбора двоичного формата.
Пример 1
Двоичные данные:
b'WJXB\xa3\x94"\xa2\xac\x9c\x08G\x04\xb2\xb3\x02\x00l\xa4\xc18\x10\xf6{?#a\xf1'
(b'\x88\xba\xc2\x1a0\xd0dB\x84,a\x1e\xd5\xda\xd2\xb9\xa5\xdb]\xe2\x03V\xcd+'
b'\xb0~\x94\xb5\x18\x1b\xe3\xe7\xc7/P\xb9\xac\x12H\xf8\x9aE\xcb\xdcL\xa3\xaes'
b'p\n\xffi\x9c\x00\x00\x00\x02\x00\x00\x00{\xfa\xe6\xaa9Q \x80Q\xce\x99\xf9'
b'J\x0e\xd2\xed\xb9\x99\xfd\xa5\x00\x00\x00\x02\x00\\\xbe=\x1ec\xbf)\x81WW\x1d'
b'*|\x19\xce<\x90\xbf\xdc\xc0\xbc\xc0oqTV')
Результат разбора:
'A1': {'B1': 163, 'B2': -108},
{'A2': {'C1': 2495746929670423730,
'C2': {'D1': 45826,
'D2': {'E1': [4130118068775852537, 5336434526943575461],
'E2': -0.18468622863292694,
'E3': -0.662129819393158,
'E4': 87},
'D3': -23359,
'D4': 940635771,
'D5': 0.6382132172584534},
'C3': -120,
'C4': [{'F1': -1161684432, 'F2': 53348, 'F3': 66, 'F4': 2217500958},
'F1': -707079495, 'F2': 42459, 'F3': 93, 'F4': 3791869645},
{'F1': 732987028, 'F2': 46360, 'F3': 27, 'F4': 3823617839},
{'F1': 1354345490, 'F2': 18680, 'F3': -102, 'F4': 1170988108}]},
{'A3': [-93, -82, 115, 112, 10, -1, 105, -100],
'A4': [2101628626397860031, 15906921418562032726],
'A5': [250, 230, 170]}
Пример 2
Двоичные данные:
b'WJXBlE\xe7g\xfcWZv\x9e\xd0\xc7n\x00t\x01\xdb\xa1s\xa0\x04\xbf@\xfb)'
(b'z\x7fM\x9fD\x0f\x81tH+\xf1L\xcd\xae\x80a\xfe\x95\xfb|\xd7\x0eR\x0fH\xa4\xbaM'
b'J\x92z\x1c\xe4>;=\xde+\xd9\x1a6G_\xc3;\xb0^1f\r\xc3\xccH\x00\x00\x00'
b'\x03\x00\x00\x00\x83\xd1Z\\\x17\xab\xe8\xf3\xa37[\xaa\xfe|\x9f\x12^\xbcZ\x10'
b'\xc5z\xb2\xfe\xf3\xbaF\x1b\x00\x00\x00\x03\x00\\?\x04\x86\xb8=\xe5'
b'\\\xda_\xc3\xdd\xd1n2\x7f\xc7\xda\x9c\xbb\\IMs\x95\x06\xc5t\x15\xb1Z'
b'\xe1\x83\t')
Результат разбора:
'A1': {'B1': 108, 'B2': 69},
{'A2': {'C1': -1772170476236923184,
'C2': {'D1': 51054,
'D2': {'E1': [1705713017002875818,
-109037389716104688,
-4216861292998539749],
'E2': 0.5176806449890137,
'E3': 0.11199350655078888,
'E4': 95},
'D3': 475,
'D4': 2708709380,
'D5': -0.7538323998451233},
'C3': 122,
'C4': [{'F1': 2135793476, 'F2': 3969, 'F3': 116, 'F4': 1210839372},
'F1': -844201887, 'F2': 65173, 'F3': -5, 'F4': 2094468690},
{'F1': 256419002, 'F2': 19786, 'F3': -110, 'F4': 2048713790},
{'F1': 993910315, 'F2': 55578, 'F3': 54, 'F4': 1197458235}]},
{'A3': [-80, 94, 49, 102, 13, -61, -52, 72],
'A4': [14113667078472845274, 11293721960463439110, 14228020974248362761],
'A5': [209, 90, 92]}
Задача №12
Реализовать разбор двоичного формата данных. Данные начинаются с сигнатуры 0x34 0x4d 0x46 0x51
, за которой следует структура
A. Порядок байт: от младшего к старшему. Адреса указаны в виде смещений от начала данных. В решении предлагается использовать модуль
struct.
Структура A:
Поле | Описание |
---|---|
1 | Адрес (uint16) структуры B |
2 | float |
3 | uint16 |
4 | Массив структур D, размер 8 |
5 | int16 |
6 | int32 |
7 | Размер (uint32) и адрес (uint32) массива char |
8 | Массив int64, размер 7 |
Структура B:
Поле | Описание |
---|---|
1 | int8 |
2 | Адрес (uint16) структуры C |
3 | uint32 |
4 | double |
5 | uint16 |
Структура C:
Поле | Описание |
---|---|
1 | uint64 |
2 | Размер (uint32) и адрес (uint32) массива char |
Структура D:
Поле | Описание |
---|---|
1 | uint32 |
2 | uint8 |
Ниже показаны примеры разбора двоичного формата.
Пример 1
Двоичные данные:
b'4MFQ\x90\x00\xbe\xa7\x9e\xbd\xff[\xc1g%\xdf\x03\xa2\xd6\xe3*\x94r\\o-d\x96'
(b'2\xb8\x8a\xd0\x19\x99_/\x0f\x82\xbf\xcdW\xa4\x19{\xfd\xe8,$\xd7,\xa6\xe8'
b'r$?\xf4\x00\xb3\x02\x00\x00\x00\xa1\x00\x00\x004\x8fyb\n\x87n\xae_\x93!48('
b'ZAS \x7f\x1b \xb0\xe0\x0c}\xb8\xc0\x1e15>\xd9\x00\xa8\xce\x9cp\x05\x8c3GH'
b'\x06\xc2\xd9\x12h\xd9\xa8\xa4\xae\xe6\xf1V\xfd$hywvgh\x04\x07_$\x06v\xd0\x19'
b'\x06\x00\x00\x00z\x00\x00\x00\x12\x80\x00\x0e\x9b\x89\x8e\xe2/sK\xc8'
b'\x16\xe6?dmiv')
Результат разбора:
'A1': {'B1': 18,
{'B2': {'C1': 1860116414856103684, 'C2': 'hywvgh'},
'B3': 2391382798,
'B4': 0.6902810548431229,
'B5': 28004},
'A2': -0.0774683803319931,
'A3': 23551,
'A4': [{'D1': 3743770561, 'D2': 3},
'D1': 719574690, 'D2': 148},
{'D1': 762272882, 'D2': 100},
{'D1': 2327327382, 'D2': 208},
{'D1': 794794265, 'D2': 15},
{'D1': 1473101698, 'D2': 164},
{'D1': 3908926233, 'D2': 44},
{'D1': 2787956516, 'D2': 232}],
{'A5': 9330,
'A6': -1291783105,
'A7': 'iv',
'A8': [-5877611985000362188,
4709120582227170143,
927935175185080403,
-2792736233837512579,
3714349773899081728,
-2780952043428886457,
2665382151430513832]}
Пример 2
Двоичные данные:
b'4MFQ\x90\x00\xf6\xa2H?\xfa\xb7\xc6-+\x7f\xea5\xc5\xea,\xa3ub\xc1\xf3<\xca'
(b'/\x1c\x02\xb7\xc4\x9b\xeeG\xa4\xdd\xb2\xa8B\x1a\xc9\xd1N\xc77\x8e'
b'\xb8\xe4(\xcb\xc6\xd1Y\xbf\xce]\x02\x00\x00\x00\xa1\x00\x00\x00\xe2\xee'
b'\x0f\x7f\x9a\x89\xc6K<\x85`.z\xafGGO\xf2sV\xe1\xeb\x0f\xbb\xf2\x03\xe6\xca|5'
b'\xd3G&\x92\xa9\x08\xd0V4m{\x08\xd9*1\xe9_\xe2AoU%\x05N8=jaxfna'
b'\xb5\x98\x00\xa5\xe4\xcey\xd2\x06\x00\x00\x00z\x00\x00\x00\x8f\x80\x00\xe8'
b']\xa7\xb7j\xa4\xcfa\x84\xd5\xe7?\xc7Qjt')
Результат разбора:
'A1': {'B1': -113,
{'B2': {'C1': 15166380701563001013, 'C2': 'jaxfna'},
'B3': 3081199080,
'B4': 0.7448141012547584,
'B5': 20935},
'A2': 0.7837365865707397,
'A3': 47098,
'A4': [{'D1': 2133536198, 'D2': 234},
'D1': 753583413, 'D2': 163},
{'D1': 4089537141, 'D2': 60},
{'D1': 35401674, 'D2': 183},
{'D1': 1206819780, 'D2': 164},
{'D1': 1118352093, 'D2': 26},
{'D1': 3343831497, 'D2': 55},
{'D1': 686078094, 'D2': 203}],
{'A5': -11834,
'A6': 1573830489,
'A7': 'jt',
'A8': [5460202894883024610,
5136266839338288444,
-4967492510915759537,
5175539206875120626,
7869009900421616166,
-2134731300968789893,
4411361619017559873]}
Задача №12
Реализовать разбор двоичного формата данных. Данные начинаются с сигнатуры 0x4e 0x48 0x48 0x54
, за которой следует структура
A. Порядок байт: от старшего к младшему. Адреса указаны в виде смещений от начала данных. В решении предлагается использовать модуль
struct.
Структура A:
Поле | Описание |
---|---|
1 | Адрес (uint16) структуры B |
2 | Адрес (uint16) структуры E |
3 | int16 |
4 | uint64 |
5 | int16 |
6 | Структура F |
Структура B:
Поле | Описание |
---|---|
1 | uint16 |
2 | Массив структур C, размер 3 |
Структура C:
Поле | Описание |
---|---|
1 | Структура D |
2 | int8 |
3 | uint32 |
4 | int8 |
Структура D:
Поле | Описание |
---|---|
1 | Размер (uint32) и адрес (uint16) массива int8 |
2 | Размер (uint32) и адрес (uint32) массива uint16 |
Структура E:
Поле | Описание |
---|---|
1 | float |
2 | int64 |
3 | Массив int16, размер 5 |
Структура F:
Поле | Описание |
---|---|
1 | Массив int32, размер 8 |
2 | uint16 |
3 | int8 |
4 | int64 |
5 | int64 |
6 | int64 |
Ниже показаны примеры разбора двоичного формата.
Пример 1
Двоичные данные:
b'NHHT\x00d\x00\xa2$\x80\xedDB\xbb\xb3\xeb\xf3\xa1\xf6\xec\xa1%\xe1\xc7'
(b'\xda\xf3)\xe7\x8e_ \xa9\x02\x06\xf3\xc8\xb7\x8d\xd8\xf4S9\x90\xb9\xb6\x12v`'
b'>\xdeY\x81q\x107\x9d\xd3\xd5\xbb\xe5(v\x0fV?=5\x1d\x89\x06\xa5\xa79\x01\x85?'
b"\x80\xefke\xf9\x9e\x03\\\x9e\xc9\x88.\x81\xda,\xf2\\'\x0eW\x18\x8f`\xf9"
b'\rL\x00\x00\x00\x04\x00O\x00\x00\x00\x02\x00\x00\x00S\xd7\x92\xfa\xe9'
b'x1\x00\x00\x00\x03\x00W\x00\x00\x00\x02\x00\x00\x00Z\x8b\xbe\xcb\xf0'
b'\xe8!\x00\x00\x00\x02\x00^\x00\x00\x00\x02\x00\x00\x00`\x078\xac\x9f'
b'\x88\xe5<\xf85 \xd5\xeav\xe7%\xcb\xf6\x9b\xad\xe7w\xbd\xae\x01mm\x83\xa7')
Результат разбора:
'A1': {'B1': 3404,
{'B2': [{'C1': {'D1': [101, -7, -98, 3], 'D2': [23710, 51592]},
'C2': -41,
'C3': 2465917304,
'C4': 49},
'C1': {'D1': [46, -127, -38], 'D2': [11506, 23591]},
{'C2': -117,
'C3': 3201036520,
'C4': 33},
'C1': {'D1': [14, 87], 'D2': [6287, 24825]},
{'C2': 7,
'C3': 950837128,
'C4': -27}]},
'A2': {'E1': 0.03029876947402954,
'E2': -3032480663936960869,
'E3': [-21017, 30653, -20991, 28013, -31833]},
'A3': 9344,
'A4': 17096863459350148001,
'A5': -2324,
'A6': {'F1': [-1591352889,
-621598233,
-1906368343,
34010056,
-1215440652,
1396281529,
-1240304032,
1054759297],
'F2': 28944,
'F3': 55,
'F4': -7074075586688682481,
'F5': 6214753309132654245,
'F6': -6397080123895386261}}
Пример 2
Двоичные данные:
b'NHHT\x00i\x00\xa7\x97\x97\x12\xd5\x8f\xb3X\xdbyD\xcb\xe8ey\xb5k\x7f\xff8F'
(b'\xb7\x93\x9d\xf9\xffp\x12\x87j\xef{(\x06S\xad\x97\xcc\xec5c\x0f\xdf\xf3\x01'
b'y\xf6\x9f\xf0\xb2\xec\xb6\xfc\xef|\x04\xd9V?\xbcWS\x8f<9k\x01\xac#\xdbJ\x13.'
b'\x14\x90\xa7\xc8dA\xe4z\xb3\x9f\xe6\xa3\x13o{}\xdc\xb9\xd4;\xb7\xc7\xab\xd5'
b'\xb0\xb8\xc7\x00\x00\x00\x07\x00O\x00\x00\x00\x02\x00\x00\x00V\xed\x82\xb8'
b'\xe5\x8d$\x00\x00\x00\x02\x00Z\x00\x00\x00\x02\x00\x00\x00\\\xa6\xfc\t'
b"'\x945\x00\x00\x00\x05\x00`\x00\x00\x00\x02\x00\x00\x00eW\xac\xbc\xf3t\xec="
b'L\x9a\xf7s\xa4Ra7 rK\xa9m\xd3\x17\x8e\xb8+\x7fz\x14')
Результат разбора:
'A1': {'B1': 47303,
{'B2': [{'C1': {'D1': [46, 20, -112, -89, -56, 100, 65],
'D2': [58490, 45983]},
'C2': -19,
'C3': 2193155469,
'C4': 36},
'C1': {'D1': [-26, -93], 'D2': [4975, 31613]},
{'C2': -90,
'C3': 4228458388,
'C4': 53},
'C1': {'D1': [-36, -71, -44, 59, -73], 'D2': [51115, 54704]},
{'C2': 87,
'C3': 2898064244,
'C4': -20}]},
'A2': {'E1': 0.04995247349143028,
'E2': 8332875788032438859,
'E3': [-22163, -11497, -29000, 11135, 31252]},
'A3': -26729,
'A4': 1357148863174768964,
'A5': -13336,
'A6': {'F1': [1702475115,
2147432518,
-1215062535,
-9432441,
1794079528,
106147223,
-856935069,
266334977],
'F2': 31222,
'F3': -97,
'F4': -1102558688080593916,
'F5': -2785969241330577604,
'F6': 4137402521517509139}}
Задача №12
Реализовать разбор двоичного формата данных. Данные начинаются с сигнатуры 0xec 0x48 0x5a 0x58
, за которой следует структура
A. Порядок байт: от младшего к старшему. Адреса указаны в виде смещений от начала данных. В решении предлагается использовать модуль
struct.
Структура A:
Поле | Описание |
---|---|
1 | int16 |
2 | Адрес (uint16) структуры B |
3 | int32 |
4 | float |
5 | float |
6 | Массив int16, размер 7 |
Структура B:
Поле | Описание |
---|---|
1 | Размер (uint16) и адрес (uint16) массива char |
2 | int64 |
3 | int8 |
4 | Массив структур C, размер 6 |
5 | uint32 |
6 | Адрес (uint16) структуры D |
7 | float |
Структура C:
Поле | Описание |
---|---|
1 | int8 |
2 | float |
3 | uint16 |
4 | uint16 |
5 | float |
Структура D:
Поле | Описание |
---|---|
1 | Размер (uint32) и адрес (uint32) массива uint8 |
2 | uint8 |
Ниже показаны примеры разбора двоичного формата.
Пример 1
Двоичные данные:
b'\xecHZXsC1\x00\x02\xedJ\x8c\x9f\xa0\x9a>\xfcv\xa3\xbe\xf7\xda\x08\xda'
(b'\x01\xacv\xb1oA\x90k\xd7\xf6iyfvQq\x02\x00\x00\x00&\x00\x00\x00\xab\x04\x00"'
b'\x00\xf0\xcb\xc0\x9a\xf9b6\xae\xfeo\r#Q?\xa8S\xc4E\xaax\xe8\xbdD'
b'\xc9\xf0Q\xbfN\x9c\x1e\xad\xa2e\xa6\xbe\xa9\xd7\xd7\x1f>\x18kH\x8d\xd7\x0em'
b'?\x1b\x10\xee\xaa>\xb3SyImv\n\xbc_`\xe9i\xbf\x98\xc6\xcb\xb7\xee\xfa=?\x9b'
b'\x04\xed\x03?>\xe6i\xba\x8f\x8e?>\xd9H\xa2?(\x00\x08\xb9\x93\xbe')
Результат разбора:
'A1': 17267,
{'A2': {'B1': 'iyfv',
'B2': -5893414238185010192,
'B3': -2,
'B4': [{'C1': 111,
'C2': 0.8169410824775696,
'C3': 21416,
'C4': 17860,
'C5': -0.11351139843463898},
'C1': 68,
{'C2': -0.8200803399085999,
'C3': 40014,
'C4': 44318,
'C5': -0.32499414682388306},
'C1': -87,
{'C2': 0.15609680116176605,
'C3': 27416,
'C4': 36168,
'C5': 0.9260076880455017},
'C1': 27,
{'C2': 0.3338475227355957,
'C3': 21427,
'C4': 18809,
'C5': -0.008451086468994617},
'C1': 95,
{'C2': -0.9137172698974609,
'C3': 50840,
'C4': 47051,
'C5': 0.7421101331710815},
'C1': -101,
{'C2': 0.5153353214263916,
'C3': 58942,
'C4': 47721,
'C5': 0.18706725537776947}],
'B5': 1067600089,
'B6': {'D1': [81, 113], 'D2': 171},
'B7': -0.28852105140686035},
'A3': -1941246718,
'A4': 0.30200669169425964,
'A5': -0.3192671537399292,
'A6': [-9481, -9720, -21503, -20106, 16751, 27536, -2345]}
Пример 2
Двоичные данные:
b'\xecHZXq\x001\x00\x00\xb4A\x87\x85\x98\x03?\x04i\r\xbf\xf9\xfb\xc9M'
(b'\x97;b\x9eD\xdc\xcf^\xe1\xd0urso\x0fS\x02\x00\x00\x00&\x00\x00\x00'
b'\xdc\x04\x00"\x00l\xd6g\xe5$\x93\xd9\x02o\xcf\xc76\xc3\xbe\x87"C\xde\x99'
b'\n\x95=\xf0z*t>=\xd1\n\xb26\x031>\xe1\x9e\x1db\xbf\xcc\xf5\xb8\xb1\xa3\xc2C'
b'?\xf7\x94\x0b\xd5=\xb3\x9b\xba\xfc\x1e\x1d\x80>2y\xffm?`\xbd\xe9~\x03'
b'\x9dE\xbf\xb5e\xa1\xd2\xbe\xc8\\K\x8c\x9b8\x0c\xbf\x00\xbb\xa3\r(\x00=X'
b'\x01?')
Результат разбора:
'A1': 113,
{'A2': {'B1': 'urso',
'B2': 205357044698961516,
'B3': 111,
'B4': [{'C1': -49,
'C2': -0.38127729296684265,
'C3': 8839,
'C4': 56899,
'C5': 0.07277411967515945},
'C1': -16,
{'C2': 0.2384432852268219,
'C3': 53565,
'C4': 45578,
'C5': 0.17286381125450134},
'C1': -31,
{'C2': -0.883264422416687,
'C3': 62924,
'C4': 45496,
'C5': 0.7646886706352234},
'C1': -9,
{'C2': 0.10402598977088928,
'C3': 39859,
'C4': 64698,
'C5': 0.2502221465110779},
'C1': 50,
{'C2': 0.9296794533729553,
'C3': 48480,
'C4': 32489,
'C5': -0.7719270586967468},
'C1': -75,
{'C2': -0.4113875925540924,
'C3': 23752,
'C4': 35915,
'C5': -0.5477387309074402}],
'B5': 228834048,
'B6': {'D1': [15, 83], 'D2': 220},
'B7': 0.5052526593208313},
'A3': -2025737216,
'A4': 0.5140460133552551,
'A5': -0.5523836612701416,
'A6': [-1031, 19913, 15255, -24990, -9148, 24271, -12063]}
Задача №12
Реализовать разбор двоичного формата данных. Данные начинаются с сигнатуры 0x45 0x46 0x56 0x58
, за которой следует структура
A. Порядок байт: от младшего к старшему. Адреса указаны в виде смещений от начала данных. В решении предлагается использовать модуль
struct.
Структура A:
Поле | Описание |
---|---|
1 | Массив структур B, размер 2 |
2 | Структура C |
Структура B:
Поле | Описание |
---|---|
1 | uint64 |
2 | uint64 |
3 | int32 |
4 | int16 |
5 | float |
6 | double |
Структура C:
Поле | Описание |
---|---|
1 | uint16 |
2 | Размер (uint32) и адрес (uint16) массива char |
3 | Массив int16, размер 3 |
4 | uint16 |
5 | Структура D |
6 | int32 |
7 | uint64 |
Структура D:
Поле | Описание |
---|---|
1 | uint16 |
2 | float |
3 | Массив int64, размер 2 |
4 | int16 |
5 | Массив float, размер 7 |
Ниже показаны примеры разбора двоичного формата.
Пример 1
Двоичные данные:
b'EFVX\xbf70\xa8\x04~\xfbv^&1\x99\xfd\x0b\xe3;Z\xb2\xf8\xd6\xa0\xc9\xd9\xc4'
(b',?\xdc\xd5\x93\xef\xf6\x1b\xd1?2%\xd6b\xa0\x9e\xfba\x8b\x17\x9f\x1d\xca\x94'
b'K\x1b[\x9d\xba\x07h\x8b\xaf\x87\xb3>\x18\xae\xc6\xfbt\xd5\xc8\xbf'
b'\xa7R\x02\x00\x00\x00\x98\x00\xc4\x18\xae\x87\x11\xb1e\x8fw\xaf\x80\x81'
b'\xf9=\x878\xdd$\x8c\x0f\xf2GB\xe8\x84\x8a\x0c\xd4Ij\xe8\x94\xbceQ\xbf'
b'*;\x08\xbf&\xd1\xaf=\x86\x82\xd3>\x8a\x9a??\xd8\r0\xbb\x04\xaf\xd2\xbe'
b'\xacA\x92}\x04\x8d\xeb\xd6k\xee\xa6\x80qb')
Результат разбора:
'A1': [{'B1': 8573584874096572351,
{'B2': 4315306051775833694,
'B3': -688344486,
'B4': -13920,
'B5': 0.6748786568641663,
'B6': 0.2673318233131263},
'B1': 7060411252523541810,
{'B2': 1966829258078623627,
'B3': 129670491,
'B4': -29848,
'B5': 0.3506445586681366,
'B6': -0.19401418966059292}],
'A2': {'C1': 21159,
'C2': 'qb',
'C3': [6340, -30802, -20207],
'C4': 36709,
'C5': {'D1': 44919,
'D2': 0.12182903289794922,
'D3': [5184223215645177991, 7658885791648901186],
'D4': -27416,
'D5': [-0.8179585933685303,
-0.5321527719497681,
0.0858481377363205,
0.41310518980026245,
0.748451828956604,
-0.0026863720268011093,
-0.4114915132522583]},
'C6': 2106737068,
'C7': 9270359029923417348}}
Пример 2
Двоичные данные:
b'EFVX\xd7\x1eN\xb1=\xd4\xdf\xca\xbf_h[\n\x9c:J?\xd7(\xb2\xa9:\xbe\xef'
(b'\x9b>\xf8\xaf;\xdbD\x97\xe6\xbfN\xa5Q\x04\xbd\x17\xc5\x835c""\xba\xc0'
b'%*\x1c\xece\n.<\xc5\x80\x0c\xbf\xde\xff^\xc6\xf6\x83\xeb?\xc3\x8d\x06\x00'
b'\x00\x00\x98\x00\x05\x98\x85\xfbn\xabv\xacv_z\xa8r?$\xc9\x01\x8c(\x8d'
b'\xfbkQ\xa9\xb1P[\xc9\x07\xb8\xf0\x91J\xf74>\xca\x912?U]\xb9>*v\x91\xbe'
b'\xba\xe3}>\xf8\x7f\xfb>y@\xa4\xbe\xf8\xa5a\xffQ\n)\xfbe\x95\x93\xe7vcpcjh')
Результат разбора:
'A1': [{'B1': 14618636276900699863,
{'B2': 5348759075753058239,
'B3': -1305946305,
'B4': 15017,
'B5': 0.3045634627342224,
'B6': -0.7059654504678283},
'B1': 9495021489969276238,
{'B2': 3037045429400396597,
'B3': 174451740,
'B4': 15406,
'B5': -0.5488398671150208,
'B6': 0.8598588823733697}],
'A2': {'C1': 36291,
'C2': 'vcpcjh',
'C3': [-26619, -1147, -21650],
'C4': 44150,
'C5': {'D1': 24438,
'D2': 0.9478832483291626,
'D3': [7780967986499799332, -5185955051860809391],
'D4': -28176,
'D5': [0.17672458291053772,
0.6975370645523071,
0.3620401918888092,
-0.2841046452522278,
0.24793902039527893,
0.4912106990814209,
-0.3208043873310089]},
'C6': -10377736,
'C7': 16686845309575826001}}
Задача №12
Реализовать разбор двоичного формата данных. Данные начинаются с сигнатуры 0x67 0x4e 0x4b 0x4c 0x5a
, за которой следует
структура A. Порядок байт: от старшего к младшему. Адреса указаны в виде смещений от начала данных. В решении предлагается использовать
модуль struct.
Структура A:
Поле | Описание |
---|---|
1 | Размер (uint32) и адрес (uint16) массива структур B |
2 | int32 |
3 | int32 |
4 | Размер (uint16) и адрес (uint16) массива char |
5 | uint8 |
6 | Структура C |
7 | float |
8 | Размер (uint16) и адрес (uint16) массива int16 |
Структура B:
Поле | Описание |
---|---|
1 | uint16 |
2 | float |
Структура C:
Поле | Описание |
---|---|
1 | uint8 |
2 | uint32 |
3 | Структура D |
Структура D:
Поле | Описание |
---|---|
1 | double |
2 | uint16 |
3 | Размер (uint16) и адрес (uint16) массива uint64 |
4 | uint8 |
Ниже показаны примеры разбора двоичного формата.
Пример 1
Двоичные данные:
b'gNKLZ\x00\x00\x00\x02\x004\xf641\x13\x81e\xd1\x8a\x00\x03\x00@\x85'
(b'\x9c\xe2\xa8+M\xbf\xd6\xf4\xf8.\xb0\xe5\xa0\xee\x80\x00\x02\x00C\x98?*\x99='
b'\x00\x04\x00S\x91:>4\xcb\xcc\xc6\x00\xbe\xb6WOkvx\xb1\x7f\xd4g?\xe1\xa78\xc8'
b'&\xbf\xd7\x07\xd3,\xf1u:\x9c\xb4A\x85[\xb0')
Результат разбора:
'A1': [{'B1': 37178, 'B2': 0.17655867338180542},
{'B1': 50688, 'B2': -0.3561348617076874}],
{'A2': -164351725,
'A3': -2124033654,
'A4': 'kvx',
'A5': 133,
'A6': {'C1': 156,
'C2': 3802671949,
'C3': {'D1': -0.35870174941700306,
'D2': 61056,
'D3': [12790175006673971000, 14422425786970746097],
'D4': 152}},
'A7': 0.6664007306098938,
'A8': [30010, -25420, 16773, 23472]}
Пример 2
Двоичные данные:
b'gNKLZ\x00\x00\x00\x02\x004\x13\x9e2M\xb0\x1e\xdb\xf3\x00\x02\x00@Z'
(b'\x1bR\xf1\x00\xf0\xbf\xdb\xb0\x94\xb7\xdb\x17h\x7f\xc4\x00\x02\x00B2'
b'\xbf\x15+\\\x00\x02\x00R\x93k\xbd}\x07P\t\xf7<\xd9\xa5\x1awz(\x1d'
b"'\xaa\xe5\xd8k\xdb\x9a\xd6\x0e\xb7\xf7\x89=\xcb\xce5c\xed")
Результат разбора:
'A1': [{'B1': 37739, 'B2': -0.06177455186843872},
{'B1': 2551, 'B2': 0.026567984372377396}],
{'A2': 329134669,
'A3': -1340154893,
'A4': 'wz',
'A5': 90,
'A6': {'C1': 27,
'C2': 1391526128,
'C3': {'D1': -0.43265264467878817,
'D2': 32708,
'D3': [2890510150795815899, 11157121310151753163],
'D4': 50}},
'A7': -0.5826928615570068,
'A8': [-12747, 25581]}
Задача №12
Реализовать разбор двоичного формата данных. Данные начинаются с сигнатуры 0x58 0x49 0x52 0x4f
, за которой следует структура
A. Порядок байт: от младшего к старшему. Адреса указаны в виде смещений от начала данных. В решении предлагается использовать модуль
struct.
Структура A:
Поле | Описание |
---|---|
1 | Структура B |
2 | uint8 |
3 | Размер (uint32) и адрес (uint32) массива char |
4 | int8 |
5 | Массив int16, размер 4 |
6 | int32 |
7 | Размер (uint16) и адрес (uint16) массива uint16 |
Структура B:
Поле | Описание |
---|---|
1 | int32 |
2 | Массив структур C, размер 3 |
3 | int16 |
4 | int32 |
5 | Адрес (uint16) структуры D |
6 | Структура F |
7 | uint8 |
8 | uint64 |
Структура C:
Поле | Описание |
---|---|
1 | uint32 |
2 | float |
3 | uint8 |
Структура D:
Поле | Описание |
---|---|
1 | Структура E |
2 | int32 |
Структура E:
Поле | Описание |
---|---|
1 | double |
2 | uint16 |
Структура F:
Поле | Описание |
---|---|
1 | float |
2 | Структура G |
Структура G:
Поле | Описание |
---|---|
1 | int32 |
2 | uint64 |
3 | Массив uint16, размер 4 |
4 | double |
Ниже показаны примеры разбора двоичного формата.
Пример 1
Двоичные данные:
b'XIROU\xd6\x94\xe8\xc6\xe9`\xf1\xa1$\xa0>\x15\xee=c\xe5\x9b\xc6,\xbf<\xc1u'
(b'\xbf\xd5\xf8\xa4\x96\xbe>Gct\xb4\xc0(n\x00U\xc9\xe7\xbe\x9c0s\xf2\x98DW\xb7r'
b'\x88i\xfc\xb1=H\xfdn]R2\xbc2\xe62\x9fO\xd0?\xf8\x0e\xfd\xb5\x0fZ?j\x9f'
b'z\x03\x00\x00\x00|\x00\x00\x00\x98G\xedK\x92U\x99\x8d\x9c\x13EEL\x02\x00'
b'\x7f\x00\xe0Z\x9e\x0b:\xda\xc8\xbf\r~{\xd2\xf1rvfb\xa1\xf4\xf5\xf8')
Результат разбора:
'A1': {'B1': -392898987,
{'B2': [{'C1': 4049660358, 'C2': 0.3127794563770294, 'C3': 21},
'C1': 3848486382, 'C2': -0.6749054789543152, 'C3': 60},
{'C1': 3586094529, 'C2': -0.29422736167907715, 'C3': 62}],
{'B3': 25415,
'B4': 683717748,
'B5': {'D1': {'E1': -0.19415975158036414, 'E2': 32269},
'D2': 1928450683},
'B6': {'F1': -0.4527079164981842,
'F2': {'G1': -227331940,
'G2': 18188218596396057752,
'G3': [15793, 64840, 23918, 12882],
'G4': 0.254859733301412}},
'B7': 248,
'B8': 11487063455605062926},
'A2': 122,
'A3': 'vfb',
'A4': -104,
'A5': [-4793, -28085, -26283, -25459],
'A6': 1279608083,
'A7': [62625, 63733]}
Пример 2
Двоичные данные:
b'XIRO\xe8\xc6\x0f\xa7\xb6hkv\x90\x97R=\xbbw\x83h?\xb4y\x89>e\xc0\xb8'
(b'\x04\xa1\xcaX=\xbf\x04Ml\x8br!\xe0n\x00\xba,4\xbe\xa3K\x89\xbd\xfb\x9ej\xb7l'
b'\x82\x1a`\xa9\xe7z\x93\x02@@x\x16\xe1}\xae\xe3\xe0\xe9?\xa8y\x02V+'
b'\xe1\x04\xc4\xbe\x86\x05\x00\x00\x00|\x00\x00\x00{@\xfe\xeb<\x13\xb3'
b'.\x0f\xe6\xb7\xcb\x90\x03\x00\x81\x00\xe4tN?\x1f5\xdd\xbfHq\xf0\x98uKjizz'
b'f\x0c\xc7\xc8\x03{\xe9')
Результат разбора:
'A1': {'B1': -1492138264,
{'B2': [{'C1': 1986750646, 'C2': 0.05141407251358032, 'C3': 187},
'C1': 1063814007, 'C2': 0.26850664615631104, 'C3': 101},
{'C1': 2701441216, 'C2': -0.7396360635757446, 'C3': 4}],
{'B3': 27725,
'B4': -534678901,
'B5': {'D1': {'E1': -0.4563673132159478, 'E2': 29000},
'D2': 1265998064},
'B6': {'F1': -0.17595186829566956,
'F2': {'G1': -1115075677,
'G2': 6924990780480855803,
'G3': [59305, 37754, 16386, 30784],
'G4': 0.8087023170510601}},
'B7': 168,
'B8': 13746117327782806137},
'A2': 134,
'A3': 'jizzf',
'A4': 123,
'A5': [-448, 15595, -19693, 3886],
'A6': -1865697306,
'A7': [50956, 968, 59771]}
Задача №12
Реализовать разбор двоичного формата данных. Данные начинаются с сигнатуры 0x5a 0x51 0x50 0x57
, за которой следует структура
A. Порядок байт: от старшего к младшему. Адреса указаны в виде смещений от начала данных. В решении предлагается использовать модуль
struct.
Структура A:
Поле | Описание |
---|---|
1 | uint32 |
2 | Массив адресов (uint16) структур B, размер 2 |
3 | Адрес (uint32) структуры C |
4 | Размер (uint32) и адрес (uint16) массива uint16 |
5 | uint8 |
6 | uint32 |
7 | int8 |
Структура B:
Поле | Описание |
---|---|
1 | Массив char, размер 7 |
2 | double |
Структура C:
Поле | Описание |
---|---|
1 | Структура D |
2 | double |
3 | int64 |
4 | int16 |
5 | uint32 |
6 | uint64 |
Структура D:
Поле | Описание |
---|---|
1 | int32 |
2 | float |
3 | Размер (uint32) и адрес (uint32) массива uint64 |
4 | float |
5 | int32 |
6 | Размер (uint16) и адрес (uint32) массива uint64 |
Ниже показаны примеры разбора двоичного формата.
Пример 1
Двоичные данные:
b'ZQPWd\x82s\xeb\x00\x1c\x00+\x00\x00\x00Z\x00\x00\x00\x03\x00\x96\xe7\xbe'
(b'8\xd3Gjcqtalns?\xcfe\xae\xc9\x9e)ppewkqvk?\xea6\xd9\xdc\x7f\xf8J\x91\x94'
b'\x18;\x1c\xfb\xfe\xf4\xba\xff;[\xfeuku\xa1\xa9E\xbc\xba\xec\x0bx\x15\x88'
b'\x99c\xdf\xece[i^_A\xbd\xfb\x1a\xaa\x00\x00\x00\x02\x00\x00\x00:\xbd\xbb'
b'\x11\xca\xd1\xbf`\xb4\x00\x02\x00\x00\x00J\xbf\xe5 \x8f\xe2\xa8o\xa0'
b"h\x84\x1b\x01`\xa9|\xcd\x1bY\xbd'\x17\x13\x98\x16\x8b\x19\x11nz\xf3\xf3\xdd"
b'\x1a\xc9\xfa\xae')
Результат разбора:
'A1': 1686270955,
{'A2': [{'B1': 'cqtalns', 'B2': 0.24529061169262034},
'B1': 'pewkqvk', 'B2': 0.8191956812513663}],
{'A3': {'C1': {'D1': 1767792449,
'D2': -0.1226094514131546,
'D3': [10490036074221141748, 13474553876412984181],
'D4': -0.09134252369403839,
'D5': -775987020,
'D6': [11648918588062698360, 1551658725866759515]},
'C2': -0.6602248598969602,
'C3': 7531174169600949453,
'C4': 7001,
'C5': 3173455635,
'C6': 10959099683035577075},
'A4': [62429, 6857, 64174],
'A5': 231,
'A6': 3191395143,
'A7': 106}
Пример 2
Двоичные данные:
b'ZQPW\xc8\xbf\xad>\x00\x1c\x00+\x00\x00\x00j\x00\x00\x00\x03\x00\xa6pW`9|\x8b'
(b'pfhshbu?\xe9\xf4f\x9e(\xa8\x1eiqvkpvn\xbf\xe9\x07\xc3\x92\x1f\x9d\x04\xf6C'
b'\xa3\x99\x1d\xbf\xba\xe9\x14I\xa0\x1diP\x96\xf8\x8aT\xc3F\xe2T\xa2?<\xef'
b'\xe7G86\xd7\xa8\xae;\xa9\xfe\xae\xff\xc4\xc5\xcf\xdbAu\x81\x00q<y\xaa'
b'\\m\xbfTq\xff\x00\x00\x00\x03\x00\x00\x00:>??\x0eB\x89\x9b\x9a\x00\x03'
b'\x00\x00\x00R\xbf\xd9N\x1d\xc6\xaf\x84\x00\xb3\xb5k\x8fq\xfb\xdd\x17'
b'F\x86\xea\x8aH\xcfZ\xb3Xa|\xc7\x9c&!\xe2\xb4z\xa0J')
Результат разбора:
'A1': 3368004926,
{'A2': [{'B1': 'pfhshbu', 'B2': 0.8110840882338868},
'B1': 'iqvkpvn', 'B2': -0.7821977476095587}],
{'A3': {'C1': {'D1': 2041207917,
'D2': -0.8298644423484802,
'D3': [17745206834794314473,
1461875602239821560,
9967806584490074687],
'D4': 0.1867639720439911,
'D5': 1116314522,
'D6': [4390982454781335464,
12554815297548174533,
14977636958681985340]},
'C2': -0.39539284136668584,
'C3': -5497369506298995433,
'C4': 18054,
'C5': 3934931151,
'C6': 6535664659973250086},
'A4': [8674, 46202, 41034],
'A5': 112,
'A6': 1465923964,
'A7': -117}
Задача №12
Реализовать разбор двоичного формата данных. Данные начинаются с сигнатуры 0x4b 0x4c 0x50 0x4d
, за которой следует структура
A. Порядок байт: от младшего к старшему. Адреса указаны в виде смещений от начала данных. В решении предлагается использовать модуль
struct.
Структура A:
Поле | Описание |
---|---|
1 | Размер (uint32) и адрес (uint16) массива адресов (uint32) структур B |
2 | uint16 |
3 | uint16 |
4 | Структура C |
Структура B:
Поле | Описание |
---|---|
1 | int16 |
2 | Размер (uint16) и адрес (uint16) массива char |
Структура C:
Поле | Описание |
---|---|
1 | Массив uint8, размер 3 |
2 | Адрес (uint32) структуры D |
3 | uint64 |
Структура D:
Поле | Описание |
---|---|
1 | Массив double, размер 5 |
2 | uint64 |
Ниже показаны примеры разбора двоичного формата.
Пример 1
Двоичные данные:
b'KLPM\x02\x00\x00\x004\x00\xa4\x13\xa1Z\x80\xb4P<\x00\x00\x00c\xe2\xa1'
(b' \xc8x\xadXebyiz\xc41\x05\x00\x1d\x00ayixzi\x08\x9f\x06\x00(\x00'
b'"\x00\x00\x00.\x00\x00\x00\x10J\xec\x1eF@\xca?(%\x85\xd3\r\xd3\xc0?'
b'\xea\xac\xee1\xfa\xf5\xe4?0>u\x80\xff\xef\xb5?&,\x17[\x17\xaa\xe5?'
b'\xc4M\x07\xc6\xa4^\xa7\x10')
Результат разбора:
'A1': [{'B1': 12740, 'B2': 'ebyiz'}, {'B1': -24824, 'B2': 'ayixzi'}],
{'A2': 5028,
'A3': 23201,
'A4': {'C1': [128, 180, 80],
'C2': {'D1': [0.20508648404991492,
0.13144085720186038,
0.6550265288582555,
0.08569332967930943,
0.677013090048949],
'D2': 1200031887507541444},
'C3': 6389896247244874339}}
Пример 2
Двоичные данные:
b'KLPM\x04\x00\x00\x00K\x00>\xb1`\x03\xf9\x84\xd5[\x00\x00\x006\xc0q'
(b'\xf11\xda\xfc\xe5ecvizbY\x93\x06\x00\x1d\x00imgmj1\x94\x05\x00)\x00xsjv'
b'atH\xeb\x06\x004\x00wlous7V\x05\x00@\x00#\x00\x00\x00.\x00\x00\x00:'
b'\x00\x00\x00E\x00\x00\x00\x00\xd7:\x90"\xd5\xd6\xbf\xb8\xa1w\xdc#K\xc7?\x00'
b'\x80\x7f\xe7\xe3\xd4\xc9?\xeej\x9b\xf6\x04\xe0\xec?\xf0\xd7\xfaY3\xfe\xc5?w'
b'\xe5\xad\xad,JS\xce')
Результат разбора:
'A1': [{'B1': -27815, 'B2': 'ecvizb'},
{'B1': -27599, 'B2': 'imgmj'},
{'B1': -5304, 'B2': 'xsjvat'},
{'B1': 22071, 'B2': 'wlous'}],
{'A2': 45374,
'A3': 864,
'A4': {'C1': [249, 132, 213],
'C2': {'D1': [-0.3567587288374483,
0.1819805933476013,
0.20180939487090654,
0.9023461166901521,
0.17182008641765334],
'D2': 14867308350633010551},
'C3': 16572360636855599158}}
Задача №12
Реализовать разбор двоичного формата данных. Данные начинаются с сигнатуры 0xec 0x59 0x51 0x5a 0x44
, за которой следует
структура A. Порядок байт: от старшего к младшему. Адреса указаны в виде смещений от начала данных. В решении предлагается использовать
модуль struct.
Структура A:
Поле | Описание |
---|---|
1 | Адрес (uint16) структуры B |
2 | float |
3 | Структура C |
4 | double |
5 | Размер (uint32) и адрес (uint32) массива структур D |
6 | Размер (uint16) и адрес (uint16) массива uint8 |
7 | uint8 |
Структура B:
Поле | Описание |
---|---|
1 | float |
2 | Массив char, размер 4 |
Структура C:
Поле | Описание |
---|---|
1 | int16 |
2 | int32 |
3 | int32 |
4 | uint64 |
5 | int32 |
6 | int8 |
7 | int8 |
8 | Массив uint16, размер 7 |
Структура D:
Поле | Описание |
---|---|
1 | uint16 |
2 | Массив uint16, размер 5 |
Ниже показаны примеры разбора двоичного формата.
Пример 1
Двоичные данные:
b'\xecYQZD\x00F\xbe~\xc0\xcd"^\xa6\xa5M\xd3}\x9f\x82BQ\x97\xc3,\x99\x83\xd3'
(b')H\xb8\xd7m\xf72t5.\x84OZW\xe2\x04\x06E\xa4\x19f?\xe9^<\x1e #l\x00\x00\x00'
b'\x02\x00\x00\x00N\x00\x04\x00f\xf5?:\xa3\xeffjsf}nkh\xf3\xa5\x82^Tj'
b'E\xee\xac?\xed\x06x\r\x86\xc5\x89\xd9\x9av\xaf\x8c\xb2\xd4')
Результат разбора:
'A1': {'B1': 0.7290639281272888, 'B2': 'fjsf'},
{'A2': -0.24878235161304474,
'A3': {'C1': 8798,
'C2': -1499116077,
'C3': 2107605570,
'C4': 5879382434877002537,
'C5': 1220073325,
'C6': -9,
'C7': 50,
'C8': [29749, 11908, 20314, 22498, 1030, 17828, 6502]},
'A4': 0.7927532757176841,
'A5': [{'D1': 32110, 'D2': [27496, 62373, 33374, 21610, 17902]},
'D1': 44095, 'D2': [60678, 30733, 34501, 35289, 39542]}],
{'A6': [175, 140, 178, 212],
'A7': 245}
Пример 2
Двоичные данные:
b'\xecYQZD\x00F\xbe\xd74I\xdb~\xe2\x90\xbdz1\xe9\x81\xc2\x8d\xce\xbe'
(b"\xf0\xde'\xd8U\xbf\xb5\xd3!^eN#+\xc0\x1a\x93\xb5{\xd2\x0eFl\xd4\t?\xe3\xc9"
b'\xbf\xfb\x87Qx\x00\x00\x00\x02\x00\x00\x00N\x00\x02\x00f\xcd>\xc3\xfb\xffkn'
b'fe?\r\xf1\x15\x93\xa0\xc3\x87\xf80\x9b\xd4<\xd6\xbb6\x10\xd6\x92[\x1d\xc8'
b'\xf9\x8dK"')
Результат разбора:
'A1': {'B1': 0.3827819526195526, 'B2': 'knfe'},
{'A2': -0.4203207790851593,
'A3': {'C1': -9346,
'C2': -493830790,
'C3': 837386690,
'C4': 10218314546278815829,
'C5': -1078602975,
'C6': 94,
'C7': 101,
'C8': [20003, 11200, 6803, 46459, 53774, 18028, 54281]},
'A4': 0.618377677218219,
'A5': [{'D1': 16141, 'D2': [61717, 37792, 50055, 63536, 39892]},
'D1': 15574, 'D2': [47926, 4310, 37467, 7624, 63885]}],
{'A6': [75, 34],
'A7': 205}
Задача №12
Реализовать разбор двоичного формата данных. Данные начинаются с сигнатуры 0x4c 0x4a 0x46 0x81
, за которой следует структура
A. Порядок байт: от младшего к старшему. Адреса указаны в виде смещений от начала данных. В решении предлагается использовать модуль
struct.
Структура A:
Поле | Описание |
---|---|
1 | Адрес (uint16) структуры B |
2 | Адрес (uint16) структуры E |
3 | uint16 |
4 | double |
5 | uint8 |
Структура B:
Поле | Описание |
---|---|
1 | int32 |
2 | Адрес (uint16) структуры C |
3 | Массив адресов (uint16) структур D, размер 2 |
4 | uint8 |
5 | Размер (uint32) и адрес (uint32) массива uint8 |
6 | Размер (uint16) и адрес (uint32) массива uint8 |
7 | int64 |
8 | double |
Структура C:
Поле | Описание |
---|---|
1 | int32 |
2 | float |
3 | Размер (uint16) и адрес (uint32) массива char |
Структура D:
Поле | Описание |
---|---|
1 | uint32 |
2 | int64 |
3 | int64 |
4 | int16 |
5 | float |
6 | uint8 |
7 | int64 |
Структура E:
Поле | Описание |
---|---|
1 | int32 |
2 | Массив int8, размер 2 |
3 | int32 |
Ниже показаны примеры разбора двоичного формата.
Пример 1
Двоичные данные:
b'LJF\x81s\x00\x9c\x00\x8d\xb9L\x10\x19\xef\x99{\xde?\xd5qns\xb1\xb1'
(b"\xceJ\x0c\x85L?\x03\x00\x13\x00\x00\x009\xb1\x9cGjZ'\x11\xf8\xb2wcR\xa1OW"
b'~yj\x9f\x91\x8d\x9a\x0ew>\xd6\x8d\x89\xe1z\x8el7\xd3\xea6x\xb7s\xb9J\xd8['
b'|\x8b\xd2(\xf6\xb8\x13\x1c7\xc7\xc3:\xff\x00\x9c[\xbf\x8b\xa3\x13\x884#)'
b'S$S\x91\xfb\x0e\x15Xa\x14\x81\xa3C\xecC\x16\x00$\x00G\x008\x05\x00'
b'\x00\x00j\x00\x00\x00\x04\x00o\x00\x00\x00X\xa2\x9d\xa3OI)E\x9c\x9f\xbb\xbb'
b'\xda\xf1\xd2?\xae\x00e>\xfe\xbc\xa3+\x8f\xaa')
Результат разбора:
'A1': {'B1': 1139557283,
{'B2': {'C1': 1255059889, 'C2': 0.7989051342010498, 'C3': 'qns'},
'B3': [{'D1': 1201451321,
'D2': 7167394110492858986,
'D3': -6959616690610003630,
'D4': -29295,
'D5': 0.2412666380405426,
'D6': 214,
'D7': -3226991248784914035},
'D1': 3078108906,
{'D2': -3275387570069259917,
'D3': -4339439122218682840,
'D4': -198,
'D5': -0.85784912109375,
'D6': 139,
'D7': 2617481039614317475}],
'B4': 56,
'B5': [83, 145, 251, 14, 21],
'B6': [88, 97, 20, 129],
'B7': 4983595069058425432,
'B8': 0.2960116227463858},
'A2': {'E1': 1046806702, 'E2': [-2, -68], 'E3': -1433457757},
'A3': 47501,
'A4': 0.47629402493862893,
'A5': 213}
Пример 2
Двоичные данные:
b'LJF\x81o\x00\x98\x00H\xc18\x0c\xc8\x19\xd1\x07\xc2\xbf\x9fkzs}\xb6V\xf7\xc5S'
(b'?\x02\x00\x13\x00\x00\x00\x1fD\x06\xc2\x81\xb6\xae\xd7\xa5\x02\x1c\xa7\x9a'
b'!\xdb\x00,5yb\xc9\x85P\x86v\xbf\xb1\xff\x96\x9b\xce\xfc\xdb~\x1f~\xfc'
b'\xc6\xe4I!\xf4\xe9\x98\xf9Y46\x0cuk\xac7f\xd4\xc5z\xa1\xf7c\xbf\xec\x81N\x88'
b'B\xfd\xaa\xebo\xc6\xb5vb\xa4\x02Y\x048\xed\x15\x00#\x00F\x00q\x04\x00'
b'\x00\x00i\x00\x00\x00\x02\x00m\x00\x00\x00\xe3\xb6N\x9eU\xff+\xad'
b'\x02i\xf4\x16\x98\xe5\xe9?f\xda\xa6\xabNf\x1ay$f')
Результат разбора:
'A1': {'B1': -315095975,
{'B2': {'C1': 1454800243, 'C2': 0.827239453792572, 'C3': 'kz'},
'B3': [{'D1': 3255190559,
'D2': -6405241658716277119,
'D3': 7095761151008121242,
'D4': -31287,
'D5': -0.962986946105957,
'D6': 177,
'D7': 2269493141085853439},
'D1': 3838246014,
{'D2': 3772320598054936905,
'D3': -3141762476367606730,
'D4': 31429,
'D5': -0.8904972672462463,
'D6': 236,
'D7': 8064727562456682113}],
'B4': 113,
'B5': [198, 181, 118, 98],
'B6': [164, 2],
'B7': -5968396137956198685,
'B8': 0.8092766235670583},
'A2': {'E1': -1415128474, 'E2': [78, 102], 'E3': 1713666330},
'A3': 49480,
'A4': -0.140863549793808,
'A5': 159}
Задача №12
Реализовать разбор двоичного формата данных. Данные начинаются с сигнатуры 0xa2 0x4e 0x46 0x44
, за которой следует структура
A. Порядок байт: от старшего к младшему. Адреса указаны в виде смещений от начала данных. В решении предлагается использовать модуль
struct.
Структура A:
Поле | Описание |
---|---|
1 | int8 |
2 | Размер (uint32) и адрес (uint16) массива float |
3 | uint16 |
4 | float |
5 | Размер (uint16) и адрес (uint16) массива структур B |
6 | Структура E |
Структура B:
Поле | Описание |
---|---|
1 | uint8 |
2 | float |
3 | Адрес (uint16) структуры C |
4 | Структура D |
5 | Размер (uint32) и адрес (uint16) массива int8 |
Структура C:
Поле | Описание |
---|---|
1 | uint64 |
2 | Массив uint8, размер 3 |
3 | uint64 |
4 | float |
Структура D:
Поле | Описание |
---|---|
1 | float |
2 | Массив int16, размер 8 |
Структура E:
Поле | Описание |
---|---|
1 | int64 |
2 | int32 |
3 | int16 |
4 | int64 |
Ниже показаны примеры разбора двоичного формата.
Пример 1
Двоичные данные:
b'\xa2NFD\xe5\x00\x00\x00\x04\x00+\xa8:\xbe\xcd\xce\xe3\x00\x02\x00'
(b"m\xbd\x8a\xbb\x0f\x15\xa6\x0f\xbb'\xe0\xb6\t\xc3\xec\xaf\xa5v2\xd3fP\xda?"
b'o\xf5\xa7>\xba$\x99?k\x8e;\xbfA(%\xad\xfd)A\xf5\xc2\x9b\xfc7\xbc\x08u\x08'
b'-\x97\x05-u\xc0\xbf]\x9f\xb1\xa2\xbc|\x0e\x81\xe4\x11\x04\xb2\xe1\xc4`S_'
b'\xf9\xfe\x12\xeeM\xc9\x1d=\xdf\x06\xe6\t@\xd4?<\xd8\x9c\x00;?i\x97\x9fPn}?'
b"\xb6\x9dld\x87\xf0^_\xaevb'\x00\x00\x00\x02\x00R\xde\xbe1\x90/\x00T?\x0f\x88"
b'C\xe4\n"{SU\x1f\xa99\x14\xa9W\x9e\xe1\'\xb0\x00\x00\x00\x02\x00k')
Результат разбора:
'A1': -27,
{'A2': [0.93734210729599,
0.3635604679584503,
0.9201390147209167,
-0.7545188069343567],
'A3': 43066,
'A4': -0.4019690454006195,
'A5': [{'B1': 212,
'B2': 0.737680196762085,
'B3': {'C1': 12537222300942113788,
'C2': [55, 188, 8],
'C3': 8433040428901430720,
'C4': -0.8657179474830627},
'B4': {'D1': 0.9124698042869568,
'D2': [20590,
32063,
-18787,
27748,
-30736,
24159,
-20874,
25127]},
'B5': [-94, -68]},
'B1': 222,
{'B2': -0.1734015792608261,
'B3': {'C1': 8939225126915060449,
'C2': [196, 96, 83],
'C3': 6915838060065048861,
'C4': 0.10889987647533417},
'B4': {'D1': 0.5606729388237,
'D2': [-7158, 8827, 21333, 8105, 14612, -22185, -24863, 10160]},
'B5': [9, 64]}],
'A6': {'E1': -4788809580292993093,
'E2': 669038089,
'E3': -15380,
'E4': -5790091785247764262}}
Пример 2
Двоичные данные:
b'\xa2NFD;\x00\x00\x00\x06\x00+\xd5\xa7>M\x0e\t\x00\x02\x00u\x84t\x84'
(b"\xf8\x1em;'6\xf9q\x7fF\xe1\xc8Q\xe63g\x06\x88[\xbe\xac\x1e\x87\xbf"
b'\\\xb2\xd9?+G6>\xc1 \x91?Zt\x99\xbe\xa4\xa9\xd0\xc7\xd5_\xb1cP\x8at\x17'
b"\xb7\xed\x90\x1a\x11:\xbc\x9eK!=\x02\x82\xbc\x93o+'\x97l\x16\x1d\x07\x9e"
b'\xc0\x01\xec\x17\xb1`c\x03\x1efl>\xa6\xe0\xe7\x07N/\xbf5Lr\x00C\xbfE7\x89'
b'\xb3=t\xae\x14\xad\x86\xe7.\x9f\\\xfeJ9z\x0e\x00\x00\x00\x02\x00Z\x1a>'
b'\x84\xfb\xe7\x00\\\xbe\xc2\xa7r\x9f\x07m/\x0b\xbb\xab>\xae2\xc6\xc6\xe3\\w'
b'b\x00\x00\x00\x02\x00s')
Результат разбора:
'A1': 59,
{'A2': [-0.33617040514945984,
-0.8621039986610413,
0.6690553426742554,
0.3772015869617462,
0.8533416390419006,
-0.3216080665588379],
'A3': 54695,
'A4': 0.2002488523721695,
'A5': [{'B1': 47,
'B2': -0.7081977128982544,
'B3': {'C1': 14399520599067101812,
'C2': [23, 183, 237],
'C3': 10383630834826365729,
'C4': 0.03186295926570892},
'B4': {'D1': -0.7703786492347717,
'D2': [-19651,
29870,
5293,
-31001,
11935,
23806,
19001,
31246]},
'B5': [-109, 111]},
'B1': 26,
{'B2': 0.2597343623638153,
'B3': {'C1': 3109620558205880222,
'C2': [192, 1, 236],
'C3': 1707251712120481388,
'C4': 0.32593461871147156},
'B4': {'D1': -0.38018375635147095,
'D2': [-24825,
27951,
3003,
-21698,
-20942,
-14650,
-7332,
30562]},
'B5': [7, 78]}],
'A6': {'E1': -8902344362207397081,
'E2': 922317183,
'E3': 18145,
'E4': -4012172684564199333}}
Задача №12
Реализовать разбор двоичного формата данных. Данные начинаются с сигнатуры 0x48 0x55 0x58 0x46 0x81
, за которой следует
структура A. Порядок байт: от старшего к младшему. Адреса указаны в виде смещений от начала данных. В решении предлагается использовать
модуль struct.
Структура A:
Поле | Описание |
---|---|
1 | Размер (uint32) и адрес (uint32) массива структур B |
2 | Структура C |
3 | Массив int64, размер 2 |
Структура B:
Поле | Описание |
---|---|
1 | int64 |
2 | Размер (uint16) и адрес (uint16) массива char |
Структура C:
Поле | Описание |
---|---|
1 | int8 |
2 | Массив float, размер 8 |
3 | Адрес (uint16) структуры D |
4 | Адрес (uint32) структуры E |
Структура D:
Поле | Описание |
---|---|
1 | int16 |
2 | int8 |
3 | int8 |
Структура E:
Поле | Описание |
---|---|
1 | uint16 |
2 | int8 |
3 | Размер (uint32) и адрес (uint32) массива uint8 |
Ниже показаны примеры разбора двоичного формата.
Пример 1
Двоичные данные:
b'HUXF\x81\x00\x00\x00\x07\x00\x00\x00Uy\xbfCV1\xbfv\x807\xbe\x8b\xcc<\xbe\x8c'
(b'\x97\x94>\xf0\xdch\xbf,\xceG>\xa435\xbfM\xe7g\x00\xa9\x00\x00\x00\xb3'
b'\x1a\xd2&>\xcfH\xa0w\xf9\x14\xd1o\x15\xe4\x02\xbasssipdumxykmkqoaf\xe1\xdf&'
b'\xfd\x16z0\x9d\x00\x03\x00DT~\xa8\xd5>\x1e\xb2M\x00\x02\x00G\xbf~\xbc[I\xdaA'
b'7\x00\x02\x00I\xf9O%\xa5\xbe3<~\x00\x03\x00K\x94\xb3\x18\xf9\x00@\xb3'
b'\xac\x00\x03\x00N2\x95\x9a\xdf\xee\x05\x94\x06\x00\x02\x00Q\x86L\xce'
b"_\xbf\x94\r\xa3\x00\x02\x00Sp\t\x0b\xa2\xd2'\x85}6S\x02\x0e\x07\x00\x00"
b'\x00\x06\x00\x00\x00\xad')
Результат разбора:
'A1': [{'B1': -2170973626923601763, 'B2': 'sss'},
{'B1': 6088489380075188813, 'B2': 'ip'},
{'B1': -4648070665132687049, 'B2': 'du'},
{'B1': -482125241314493314, 'B2': 'mxy'},
{'B1': -7731808677534846036, 'B2': 'kmk'},
{'B1': 3644989759988012038, 'B2': 'qo'},
{'B1': -8769407463765832285, 'B2': 'af'}],
{'A2': {'C1': 121,
'C2': [-0.763033926486969,
-0.9628939032554626,
-0.27304255962371826,
-0.27459394931793213,
0.4704315662384033,
-0.675022542476654,
0.3207031786441803,
-0.8043121695518494],
'C3': {'D1': 28681, 'D2': 11, 'D3': -94},
'C4': {'E1': 526, 'E2': 7, 'E3': [210, 39, 133, 125, 54, 83]}},
'A3': [1932649241302835319, -498543383692442950]}
Пример 2
Двоичные данные:
b'HUXF\x81\x00\x00\x00\x04\x00\x00\x00N\xa5\xbf3\x873\xbeJ\xfaA\xbe\xd7'
(b'\xe9\xd2=\xb7\xbca\xbd\x9b\xde\xe3\xbd\x88\xe5\x97?\n\xb5\x83\xbf/ >\x00~'
b'\x00\x00\x00\x85\x95\xe7L\xd8VZ}\xfd\xaa\xc2\x01\xe3\xad>\xb0\xc5yedqpkcs'
b'viE\x85Vc\x063\xcd^\x00\x02\x00D^\x13\xbb\xccibGQ\x00\x02\x00FYi\nj\xfdC'
b'\xd7\x90\x00\x04\x00H\xe9\xee\xc4]\xa5\x8a\x9dX\x00\x02\x00L\xde\xcaBB`\xf0'
b'\xe2\xf3\x89h\x00\x00\x00\x03\x00\x00\x00\x82')
Результат разбора:
'A1': [{'B1': 5009505143825354078, 'B2': 'ye'},
{'B1': 6778968350738499409, 'B2': 'dq'},
{'B1': 6442692196562098064, 'B2': 'pkcs'},
{'B1': -1590117711926878888, 'B2': 'vi'}],
{'A2': {'C1': -91,
'C2': [-0.701281726360321,
-0.19822026789188385,
-0.42170578241348267,
0.08971477299928665,
-0.07610871642827988,
-0.0668441578745842,
0.5418321490287781,
-0.6840857267379761],
'C3': {'D1': -8502, 'D2': 66, 'D3': 66},
'C4': {'E1': 62345, 'E2': 104, 'E3': [96, 240, 226]}},
'A3': [-7645057350392709635, -6142344864404164411]}
Задача №12
Реализовать разбор двоичного формата данных. Данные начинаются с сигнатуры 0x1b 0x51 0x4e 0x4e
, за которой следует структура
A. Порядок байт: от младшего к старшему. Адреса указаны в виде смещений от начала данных. В решении предлагается использовать модуль
struct.
Структура A:
Поле | Описание |
---|---|
1 | Размер (uint32) и адрес (uint32) массива структур B |
2 | Структура C |
3 | Адрес (uint16) структуры D |
Структура B:
Поле | Описание |
---|---|
1 | uint16 |
2 | uint64 |
3 | double |
4 | uint16 |
5 | uint32 |
6 | Массив char, размер 3 |
Структура C:
Поле | Описание |
---|---|
1 | Размер (uint16) и адрес (uint32) массива uint16 |
2 | int32 |
3 | int64 |
Структура D:
Поле | Описание |
---|---|
1 | int32 |
2 | uint64 |
3 | uint32 |
4 | int16 |
5 | Размер (uint32) и адрес (uint16) массива float |
6 | uint8 |
Ниже показаны примеры разбора двоичного формата.
Пример 1
Двоичные данные:
b'\x1bQNN\x02\x00\x00\x00 \x00\x00\x00\x02\x00V\x00\x00\x00\xbe\xc4u%\xfc\xca'
(b'v\xae\x9e\xc1L\x12v\x00\xe5\x0cg\x1c\xf8\xbe3\xa9Q\xcf 2x\xa8Ki\xb2\xbfPu'
b'\xd5.VRvld\xcb\xabuD\xdc \x970\xfb\xdc\x80\x84\x95\xe1\xab1\x95?\xe9F\x1e'
b'\x06M\xa4jlc\x8d\xb0\x83I)\xeb\xd5>17F\xbf\xa3h\xa8>X\xcc\x06>\x1c\xa4'
b'b\xbe\xa0!F?)/\x00?R\x90\xab\xbc\xd1\x82\xff\x9ei\xf0\x19>\xaf\x13\nZg8'
b'\x07\x00\x00\x00Z\x00\xd4')
Результат разбора:
'A1': [{'B1': 3301,
{'B2': 14938907478677003367,
'B3': -0.07191918242478623,
'B4': 30032,
'B5': 1381379797,
'B6': 'vld'},
'B1': 43979,
{'B2': 15923374333148021877,
'B3': 0.02069729389529984,
'B4': 18153,
'B5': 2756511262,
'B6': 'jlc'}],
'A2': {'C1': [45197, 18819], 'C2': 628475070, 'C3': 1318641678188727036},
'A3': {'D1': -1129607086,
'D2': 4474872041199076049,
'D3': 1510609839,
'D4': 14439,
'D5': [0.41780975461006165,
-0.7742796540260315,
0.3289233148097992,
0.13163888454437256,
-0.22132915258407593,
0.7739505767822266,
0.5007196068763733],
'D6': 212}}
Пример 2
Двоичные данные:
b'\x1bQNN\x02\x00\x00\x00 \x00\x00\x00\x02\x00V\x00\x00\x00\xb9D'
(b'\xef\xa5\xb6\xc6\xc32\xcd!\xfe\xaen\x00\xc4Wg\xa6\xa2k\x9e\xa1Y\x8d`\xc2'
b'N\xa8"T\xb1\xbf\x8a\xea\xf5\x04\x81\x83tap\n\xc4S\x99\x99\x12&w\xb6'
b'\x11\xe4\xa4\x08\xc2\x0b\\\xe3\xbf\xfa\xbe\xea\x1by ord\x9cP\nr\xa3%'
b'\xa7\xbe\xd6\x97D\xbf\xb1(|>\xf38\n>o\x92Y?C\x1c\xb3[1\xe4EB\xc1\xe4'
b'\xa3\x86Po\xbf4j&\x05\x00\x00\x00Z\x00\x81')
Результат разбора:
'A1': [{'B1': 22468,
{'B2': 10185349734057813607,
'B3': -0.06769005402635164,
'B4': 60042,
'B5': 2206270709,
'B6': 'tap'},
'B1': 50186,
{'B2': 1276338549810633043,
'B3': -0.6049860753747933,
'B4': 48890,
'B5': 544807914,
'B6': 'ord'}],
'A2': {'C1': [20636, 29194], 'C2': -1511045959, 'C3': -5837190901821880650},
'A3': {'D1': 1538464835,
'D2': 9701849540977878065,
'D3': 884961104,
'D4': 9834,
'D5': [-0.32645902037620544,
-0.7679418325424194,
0.2462489753961563,
0.1349828690290451,
0.8498906493186951],
'D6': 129}}
Задача №12
Реализовать разбор двоичного формата данных. Данные начинаются с сигнатуры 0x59 0x45 0x4c 0x57
, за которой следует структура
A. Порядок байт: от старшего к младшему. Адреса указаны в виде смещений от начала данных. В решении предлагается использовать модуль
struct.
Структура A:
Поле | Описание |
---|---|
1 | double |
2 | Размер (uint32) и адрес (uint16) массива адресов (uint32) структур B |
3 | Массив адресов (uint16) структур C, размер 8 |
4 | Структура D |
5 | float |
Структура B:
Поле | Описание |
---|---|
1 | int64 |
2 | uint16 |
Структура C:
Поле | Описание |
---|---|
1 | Массив float, размер 2 |
2 | uint16 |
Структура D:
Поле | Описание |
---|---|
1 | int8 |
2 | int16 |
3 | Массив uint16, размер 2 |
Ниже показаны примеры разбора двоичного формата.
Пример 1
Двоичные данные:
b'YELW\xbf\xde\x82\x87\xfe\x062\x98\x00\x00\x00\x02\x00A\x00I\x00S\x00]'
(b'\x00g\x00q\x00{\x00\x85\x00\x8f\xb3\x1c\x1b@|\xdd\xba\xbf\x07\x97* \xe3v'
b'\xf2jm:\xba#\xa4tr\x1c\xf9\xbcfy\x10\xb4\xb1\x00\x00\x00-\x00\x00\x007?>['
b'L>\xc25@\xd7J>\x91d\x1a\xbe~\xd1D\xcfi\xbeJ;\xe6\xbf\t\xde\xca\\\xd6?'
b'\r\x13^>\xe1\x8c_x\x99>n\xcd\xd9\xbf\n\xb6\xd8*\xf8\xbe\xc4\xc8\x9d;'
b'\x01\xc5\xe6\xadU\xbeD\x90\xc4?:\xad\x988\xbf?6\x8c\\=\xfe\xf7X@\xcf')
Результат разбора:
'A1': -0.4767169933991595,
{'A2': [{'B1': 2369868612466719418, 'B2': 9124},
'B1': 8390800914677922064, 'B2': 46257}],
{'A3': [{'C1': [0.7435805797576904, 0.37931251525878906], 'C2': 55114},
'C1': [0.2839668393135071, -0.2488451600074768], 'C2': 53097},
{'C1': [-0.19749411940574646, -0.5385557413101196], 'C2': 23766},
{'C1': [0.5510767698287964, 0.44052407145500183], 'C2': 30873},
{'C1': [0.2332071214914322, -0.5418524742126465], 'C2': 11000},
{'C1': [-0.38434305787086487, 0.0019801794551312923], 'C2': 44373},
{'C1': [-0.191958487033844, 0.7292113304138184], 'C2': 14527},
{'C1': [0.7130792140960693, 0.12449520826339722], 'C2': 16591}],
{'A4': {'D1': -77, 'D2': 7195, 'D3': [16508, 56762]},
'A5': -0.5296503305435181}
Пример 2
Двоичные данные:
b'YELW?\xe6\xf3\x1c\xacS\x9d\xec\x00\x00\x00\x05\x00_\x00s\x00}\x00\x87'
(b'\x00\x91\x00\x9b\x00\xa5\x00\xaf\x00\xb9\xa5\xeb\x17e\xbb\xcb6?9\x14'
b'@Y\xd3\xb3y\xc2`\xd7Od=K~\xd4\xdeH\xe7\xaf\x04\x95\x89\xdb\x91)\xb5l={'
b'h\x0f\xf4\x07\xaaE\xf8v\x06\xedQ~\xd7~t\x0c\xe0:X\xa1\xc8I\xb0\x00'
b'\x00\x00-\x00\x00\x007\x00\x00\x00A\x00\x00\x00K\x00\x00\x00U=+93?'
b'\x1c\x97\xdcs\xfc=J\x1d_?t<\xa9\xd2t\xbe\x10N\xe0=\x95\xd3\x92\xf0b?$\xa4'
b'u\xbe\xcf\x95d\x1a\x1b?}m\xdf?4^\xca\x924?\x1e\xee\xac?N\xdd_\x17\x1a>'
b'\xb2\x938\xbfB\x10\x10n\xc6?{\xf3\x12>\xf5\x01\x90A]')
Результат разбора:
'A1': 0.7171767583612882,
{'A2': [{'B1': 6472714424995075919, 'B2': 25661},
'B1': 5440019451081109252, 'B2': 38281},
{'B1': -2625271248598500504, 'B2': 4084},
{'B1': 552330837740678481, 'B2': 32471},
{'B1': 9111922103268450760, 'B2': 18864}],
{'A3': [{'C1': [0.04180259630084038, 0.6116921901702881], 'C2': 29692},
'C1': [0.049344416707754135, 0.954050600528717], 'C2': 53876},
{'C1': [-0.14092588424682617, 0.07315744459629059], 'C2': 61538},
{'C1': [0.6431344151496887, -0.405436635017395], 'C2': 6683},
{'C1': [0.9899577498435974, 0.7045713663101196], 'C2': 37428},
{'C1': [0.6208293437957764, 0.8080653548240662], 'C2': 5914},
{'C1': [0.34877943992614746, -0.7580575942993164], 'C2': 28358},
{'C1': [0.9841777086257935, 0.4785275459289551], 'C2': 16733}],
{'A4': {'D1': -91, 'D2': -5353, 'D3': [26043, 52022]},
'A5': 0.7229652404785156}
Задача №12
Реализовать разбор двоичного формата данных. Данные начинаются с сигнатуры 0x4d 0x49 0x50
, за которой следует структура A.
Порядок байт: от младшего к старшему. Адреса указаны в виде смещений от начала данных. В решении предлагается использовать модуль
struct.
Структура A:
Поле | Описание |
---|---|
1 | Размер (uint16) и адрес (uint32) массива char |
2 | Структура B |
Структура B:
Поле | Описание |
---|---|
1 | Массив структур C, размер 2 |
2 | Массив uint16, размер 3 |
3 | Структура D |
4 | uint32 |
5 | Массив uint32, размер 2 |
6 | int32 |
7 | uint16 |
8 | double |
Структура C:
Поле | Описание |
---|---|
1 | int64 |
2 | int32 |
Структура D:
Поле | Описание |
---|---|
1 | float |
2 | int32 |
3 | uint64 |
4 | uint32 |
5 | uint8 |
6 | float |
Ниже показаны примеры разбора двоичного формата.
Пример 1
Двоичные данные:
b'MIP\x02\x00Z\x00\x00\x00i"\xcc\xb5F\xbf!\x89\xecCu\xbc\x01f\x83`KG\x91'
(b'\xc6\xcc\x0b/\xbfp_\x0f\xccz\x1f\x8eBw\xbfk\x84Q9\xfeVU\x9dU\xd9\xe3\xac\x9c'
b'\x97\x96N\xc7\xe0dT>!\xd2\xad#iGM\xd7JR\x98\x13!0~\xc2\x91\x87\xa0g'
b'\xc3\xce\xa7\xab\xc6\xbfia')
Результат разбора:
'A1': 'ia',
{'A2': {'B1': [{'C1': -8565354705863302551, 'C2': -1133165588},
'C1': -4138448193509431807, 'C2': -1087435828}],
{'B2': [24432, 52239, 8058],
'B3': {'D1': -0.9658592939376831,
'D2': 961643627,
'D3': 12458039955971987198,
'D4': 1318492060,
'D5': 199,
'D6': 0.20741605758666992},
'B4': 598594081,
'B5': [3612165993, 328749642],
'B6': -1031917535,
'B7': 34705,
'B8': -0.1771135100923944}}
Пример 2
Двоичные данные:
b'MIP\x03\x00Z\x00\x00\x00fch\xe9g\xc8\xcf\x16`l\xb7\xfc>\xaax\xdd$\x84j'
(b'\xe0q\xaa3i\x9a\xa8\x9f<\xa6h\xb5\xd6-\xbf\x1d\x0e\x0e\xd5ew~\xe6\xbf'
b'^\x9b\xe5\xb8/AODTY\x02=\xca\xd29\xd0Pi]\xab\x17\xd6)\x14\x9b\xba\x83\x97'
b'\x1f\xca\x08=A\xb8\xf9K\xc6?iov')
Результат разбора:
'A1': 'iov',
{'A2': {'B1': [{'C1': 1643752737636639590, 'C2': -55088032},
'C1': -2275861367813002690, 'C2': 1764993649}],
{'B2': [43162, 15519, 26790],
'B3': {'D1': -0.6790574193000793,
'D2': -720499171,
'D3': 16544921834374461285,
'D4': 1329672120,
'D5': 68,
'D6': 0.03182347118854523},
'B4': 3493450442,
'B5': [2875025744, 338286103],
'B6': -1752974693,
'B7': 51743,
'B8': 0.17419358727281797}}
Задача №12
Реализовать разбор двоичного формата данных. Данные начинаются с сигнатуры 0x5a 0x4c 0x51 0xa5
, за которой следует структура
A. Порядок байт: от младшего к старшему. Адреса указаны в виде смещений от начала данных. В решении предлагается использовать модуль
struct.
Структура A:
Поле | Описание |
---|---|
1 | Структура B |
2 | Массив char, размер 2 |
3 | double |
4 | Адрес (uint16) структуры C |
5 | uint32 |
6 | Массив структур D, размер 2 |
7 | uint16 |
Структура B:
Поле | Описание |
---|---|
1 | double |
2 | double |
3 | Массив char, размер 4 |
Структура C:
Поле | Описание |
---|---|
1 | uint8 |
2 | uint32 |
Структура D:
Поле | Описание |
---|---|
1 | uint16 |
2 | uint8 |
3 | int32 |
4 | int8 |
5 | Массив uint32, размер 4 |
Ниже показаны примеры разбора двоичного формата.
Пример 1
Двоичные данные:
b'ZLQ\xa5\xaa\x10Kg\xd7=\xed\xbf\x8ae\xf8p\xad,\xe3?jdrolb\xe0\xf9FBK\x05'
(b'\xe5\xbfZ\x00c\x1d\xfdb,\xfd\xc9\x16\xbe\xa4@\x11b\x1a\xbab\xa7\xa0\xf9\xf1'
b'\x80\xd90Y*\xe7\xd42\xbe\xaa\x8f\xc2\xff7\xdf\xf6h\xde\xc5\xacS\x04\xae\xb9'
b'\xf0ptBes \x1bZw9\x97\xf0\xe1\xa5')
Результат разбора:
'A1': {'B1': -0.9137990014501345, 'B2': 0.5992037970019493, 'B3': 'jdro'},
{'A2': 'lb',
'A3': -0.656896237800364,
'A4': {'C1': 57, 'C2': 2783047831},
'A5': 1660755299,
'A6': [{'D1': 64812,
'D2': 201,
'D3': 1084538390,
'D4': 17,
'D5': [1656363618, 4059668647, 1496373632, 852813610]},
'D1': 43710,
{'D2': 143,
'D3': -549978174,
'D4': -10,
'D5': [2898648680, 3115189331, 1114927344, 455111525]}],
'A7': 30554}
Пример 2
Двоичные данные:
b'ZLQ\xa5dS\xc5\xae\xb2*\xeb?vND\x12\xb1\xfa\xea\xbfsdvchj0\xca'
(b'\xa7\xd9\xd5\xa4\xbc\xbfZ\x00\xcc\xc7\x7f\x00\xb8\xae\xb9\x03\n%\n\x12'
b'\x104N\x06`\xa7\\\x1e\xfc\xa4!,RF\xf1B\xa4\xcd(\x7fW\x01\xbf\x97'
b'{\x83\xfa\xc7P\xec\x8e\xad\xa4\x9eU_\x1e\x97\x01\x03\xe6\x96r\xa5\xbbId')
Результат разбора:
'A1': {'B1': 0.8489621556751499, 'B2': -0.8431020123266098, 'B3': 'sdvc'},
{'A2': 'hj',
'A3': -0.11189018787244076,
'A4': {'C1': 114, 'C2': 1682553765},
'A5': 8374220,
'A6': [{'D1': 44728,
'D2': 185,
'D3': 170199555,
'D4': 18,
'D5': [105788432, 509388640, 740402428, 1123108434]},
'D1': 52644,
{'D2': 40,
'D3': -1090431105,
'D4': -105,
'D5': [3355083643, 2911824976, 1599446692, 50435870]}],
'A7': 38630}
Задача №12
Реализовать разбор двоичного формата данных. Данные начинаются с сигнатуры 0x59 0x49 0x4f 0x15
, за которой следует структура
A. Порядок байт: от старшего к младшему. Адреса указаны в виде смещений от начала данных. В решении предлагается использовать модуль
struct.
Структура A:
Поле | Описание |
---|---|
1 | Массив структур B, размер 6 |
2 | float |
3 | Массив char, размер 7 |
4 | Структура C |
5 | uint32 |
6 | Адрес (uint32) структуры D |
7 | int32 |
Структура B:
Поле | Описание |
---|---|
1 | Массив char, размер 5 |
2 | int16 |
Структура C:
Поле | Описание |
---|---|
1 | double |
2 | uint64 |
3 | uint16 |
4 | Размер (uint32) и адрес (uint32) массива int64 |
5 | int16 |
Структура D:
Поле | Описание |
---|---|
1 | float |
2 | int32 |
3 | uint16 |
4 | uint16 |
5 | int8 |
6 | int8 |
7 | uint16 |
Ниже показаны примеры разбора двоичного формата.
Пример 1
Двоичные данные:
b'YIO\x15jwofb+\xa1ajggv\xf7-wsoid\xcf\tjosdv\x8f\xe2puahu\x82 ibfvl'
(b'\xd5\xe5\xbe\x8cb\x12kcwulcz\xbf\xe0\x1f\xceX@\xca\xf4\xab-\x1c'
b'\xc6\x12\x97\x91\x94\xd4g\x00\x00\x00\x04\x00\x00\x00a\x1cV\x80\x90T'
b")\x00\x00\x00\x81\x97\xe1\x92\x12\x99\xcf2'g\xde\xfd\xc5sO\xd4\xa01\x9a\xe5"
b'\xe34\xa4;0cCb(\x03\x99q\x95\xbc\xfa\xbeB\xbf]x\xa9l\xa6\xc2\x1cl\xb9\xeb'
b'\xd3\x1d\xf3\x91\x8e')
Результат разбора:
'A1': [{'B1': 'jwofb', 'B2': 11169},
{'B1': 'ajggv', 'B2': -2259},
{'B1': 'wsoid', 'B2': -12535},
{'B1': 'josdv', 'B2': -28702},
{'B1': 'puahu', 'B2': -32224},
{'B1': 'ibfvl', 'B2': -10779}],
{'A2': -0.2741857171058655,
'A3': 'kcwulcz',
'A4': {'C1': -0.5038825725262925,
'C2': 12334546591478682004,
'C3': 54375,
'C4': [-7363611720899691067,
8309093622013945315,
3793221865162629672,
259363341485129282],
'C5': 7254},
'A5': 2156942377,
'A6': {'D1': -0.865122377872467,
'D2': 1822867996,
'D3': 27833,
'D4': 60371,
'D5': 29,
'D6': -13,
'D7': 37262},
'A7': -1746824686}
Пример 2
Двоичные данные:
b'YIO\x15pgeen\x1d\xc3vzzisd lewpq\xfc\xd2hkbhfK\xffqpzym8\x8egkspn\xccm?.'
(b'\xab\xc5dbswtoq?\xec\x17\xbfU\x96,\xf0T)\xd9\xf1&\x9e-\xb9\xa9\xe5\x00'
b'\x00\x00\x04\x00\x00\x00a\xbe\x9a5\xbdo\xca\x00\x00\x00\x81\xe3\x07\xa9'
b' .\xc1\xa6\x11\xafH*b\xcc\x8c\xe8\xc1_|\xceL\x8bD\xc6\xe4\xf5\r?1\xbadO'
b'\x86\x03\x17\x97\x1e\xbbBL\x15\xb1\xdd\xb9\x8eh\xe3\xb6\xde\x84\xbcm}')
Результат разбора:
'A1': [{'B1': 'pgeen', 'B2': 7619},
{'B1': 'vzzis', 'B2': 25632},
{'B1': 'lewpq', 'B2': -814},
{'B1': 'hkbhf', 'B2': 19455},
{'B1': 'qpzym', 'B2': 14478},
{'B1': 'gkspn', 'B2': -13203}],
{'A2': 0.6823084950447083,
'A3': 'dbswtoq',
'A4': {'C1': 0.8778988525022253,
'C2': 6064618002989329849,
'C3': 43493,
'C4': [3369156591135238754,
-3707332476004413876,
-8411379517355114703,
-5015796647987800290],
'C5': -16742},
'A5': 901607370,
'A6': {'D1': -0.0029647399205714464,
'D2': -1310869106,
'D3': 26851,
'D4': 46814,
'D5': -124,
'D6': -68,
'D7': 28029},
'A7': -486037216}
Задача №12
Реализовать разбор двоичного формата данных. Данные начинаются с сигнатуры 0x51 0x51 0x4d 0x57 0xf5
, за которой следует
структура A. Порядок байт: от младшего к старшему. Адреса указаны в виде смещений от начала данных. В решении предлагается использовать
модуль struct.
Структура A:
Поле | Описание |
---|---|
1 | Адрес (uint32) структуры B |
2 | int8 |
3 | Массив структур D, размер 2 |
4 | uint32 |
5 | double |
6 | float |
7 | Структура E |
Структура B:
Поле | Описание |
---|---|
1 | int16 |
2 | Адрес (uint32) структуры C |
Структура C:
Поле | Описание |
---|---|
1 | int16 |
2 | uint64 |
Структура D:
Поле | Описание |
---|---|
1 | int32 |
2 | Массив char, размер 8 |
3 | uint32 |
Структура E:
Поле | Описание |
---|---|
1 | int8 |
2 | Структура F |
3 | int16 |
4 | int32 |
5 | uint64 |
6 | Массив uint64, размер 6 |
Структура F:
Поле | Описание |
---|---|
1 | int16 |
2 | int8 |
3 | int32 |
4 | int64 |
5 | int32 |
6 | uint16 |
7 | int64 |
8 | Массив uint8, размер 2 |
Ниже показаны примеры разбора двоичного формата.
Пример 1
Двоичные данные:
b'QQMW\xf5\xa2\x00\x00\x00\x07j\x82O\xb9uedblaez\xb0\xe5:\x99i\xe9\x0b\xffta'
(b'gagjtkc\xaa\x8e\xd9Z\xa7\x82\x11\x80\xc9\xb6\xa6lg\xc3?\xbc\x99Z?\xd4\xaa'
b'\xd5\xbdfk\xdc\xe0\xa8(\xa2]\x937\xfeH\xb9L*\xcf\x16\x7fz=G\x85'
b'\xe7\x06\x13\x8f\xd6\x9a \xcavO\xd0\x8d\xa8z\xc7E)\xcc\xaa\x17'
b'\x91\xe4\x90\xf4\xe0*^\xddy3\xcbI\xc3b\xcf\x84-_FcZ\x81a\xe34\xae\x0fI'
b'(\xac\xd6\x10\xf5\xaah\xdb6\x07*\x81*\xefl\x1c\xf5\xb6c\x82\xb4j\xef '
b'zp\x91\xd6\xf7\xdc+\x81\x98\x00\x00\x00')
Результат разбора:
'A1': {'B1': -32469, 'B2': {'C1': 27316, 'C2': 15922430927737331951}},
{'A2': 7,
'A3': [{'D1': -1185971606, 'D2': 'uedblaez', 'D3': 2570773936},
'D1': -15996567, 'D2': 'tagagjtk', 'D3': 3650005603}],
{'A4': 293775194,
'A5': 0.151593762782408,
'A6': 0.8539083003997803,
'A7': {'E1': -44,
'E2': {'F1': -10838,
'F2': -67,
'F3': -522425498,
'F4': 5259702520885946536,
'F5': -819311431,
'F6': 32534,
'F7': -8137152510285103750,
'F8': [214, 154]},
'E3': -13792,
'E4': -1915728010,
'E5': 1705399886549580456,
'E6': [15951234075857052817,
9569976324081791865,
16384519144563171117,
1213346438647361076,
9307259512105249525,
9395554411485130538]}}
Пример 2
Двоичные данные:
b'QQMW\xf5\xa2\x00\x00\x00\\t\xfc#)scgusopy>Y\xa6\xb2\x1f\\\x07qstanveap\xb9}'
(b"\xfc\x1a\x94\x9a\xf1\x81\xe2Et'i\x87\xe1?\xe3\x9a\x04>$\xd2\xff\xda\xa2\xe8"
b'5\xc1\xcf:\xef\x9aD\xf2fQ\x04\x9f\xfa C\xe5\x85\xee+`\xd14\xddLC\xdf\xe0\x84'
b'\xcfx\xf3\xb8/\xda\x1b\xbeyb%\xe2\xba\x87\x0b&\xf5\xd5"\xf4\xfc\x8fY\xdc'
b'\x14\xa5l\x90\xd6\xd3\xf2\x8au?\x1c\x00\xd7\xecG\xd9n*\xde\xcd'
b'\x92\x82\x9b\xb6\xe5ta\x9eN\xdep\xe7\x14\xd9\xe1\xd0\xda.\xd6Z'
b'\x0c\x0c\x8e\xc4\xaf\x86\x82\xcb\x98\x00\x00\x00')
Результат разбора:
'A1': {'B1': -13438, 'B2': {'C1': 11994, 'C2': 9705191836373244630}},
{'A2': 92,
'A3': [{'D1': 690224244, 'D2': 'scgusopy', 'D3': 2997246270},
'D1': 1896307743, 'D2': 'stanveap', 'D3': 452754873}],
{'A4': 2180094612,
'A5': 0.5477796335782694,
'A6': 0.12949709594249725,
'A7': {'E1': 36,
'E2': {'F1': -46,
'F2': -38,
'F3': -1053431646,
'F4': 5865641941167717071,
'F5': 553295620,
'F6': 58691,
'F7': 5538641190601879173,
'F8': [67, 223]},
'E3': -31520,
'E4': -1192003377,
'E5': 16295539101730069039,
'E6': [17591858343344572346,
10406874347961159676,
7951073422791638,
14834340878185131223,
11412531460693525138,
15051550113454415438]}}
Задача №12
Реализовать разбор двоичного формата данных. Данные начинаются с сигнатуры 0xfa 0x41 0x4b 0x52 0x42
, за которой следует
структура A. Порядок байт: от старшего к младшему. Адреса указаны в виде смещений от начала данных. В решении предлагается использовать
модуль struct.
Структура A:
Поле | Описание |
---|---|
1 | int64 |
2 | uint16 |
3 | Размер (uint32) и адрес (uint16) массива uint8 |
4 | int64 |
5 | Размер (uint16) и адрес (uint32) массива структур B |
6 | Адрес (uint32) структуры C |
7 | Структура D |
8 | Размер (uint32) и адрес (uint16) массива int8 |
Структура B:
Поле | Описание |
---|---|
1 | double |
2 | int8 |
Структура C:
Поле | Описание |
---|---|
1 | uint64 |
2 | uint32 |
Структура D:
Поле | Описание |
---|---|
1 | Размер (uint16) и адрес (uint32) массива uint64 |
2 | uint32 |
3 | Размер (uint32) и адрес (uint32) массива int16 |
4 | uint32 |
5 | Структура E |
6 | int32 |
7 | int32 |
8 | uint32 |
Структура E:
Поле | Описание |
---|---|
1 | int16 |
2 | double |
3 | uint16 |
Ниже показаны примеры разбора двоичного формата.
Пример 1
Двоичные данные:
b'\xfaAKRBH\xb2\xbe8\x16\xaa\x9b{Q\x18\x00\x00\x00\x05\x00[\x80z\xea'
(b'C\xa5\xaf\xdf\x03\x00\x02\x00\x00\x00`\x00\x00\x00r\x00\x03\x00\x00\x00'
b'~u3\x01@\x00\x00\x00\x02\x00\x00\x00\x96>\xb5[\xf60I\xbf\xee\x90Y\x17'
b'\xf19\x88\t\x7f\x03!8}\x13\xe8\x0fs\xa8\x15~L\x00\x00\x00\x06\x00\x9a\x11'
b'u\xb3\x11o?\xc2\r\xcfds\xd3\x08\xb6\xbf\xe6\x12d;\xcd\xce\xda\x14\xdc '
b')\xef<1\xfd\\\xf2R\xe100\xb3\x95\x89\xea\xc1\x13x\x00\x1b\x99[\x90\xc9'
b'Z/\x92+\xdb\xaa\xc2\x91\x17\x8d\xd6\x08\xbbT8\xc9<\x1c\x98c')
Результат разбора:
'A1': 5238458464693033851,
{'A2': 20760,
'A3': [17, 117, 179, 17, 111],
'A4': -9188774513432600829,
'A5': [{'B1': 0.141046451615374, 'B2': -74},
'B1': -0.6897450607343345, 'B2': 20}],
{'A6': {'C1': 15861723995082718556, 'C2': 4065517872},
'A7': {'D1': [3509312954233328504, 7768442921376303, 10532753679991248781],
'D2': 1966276928,
'D3': [-10744, -17580],
'D4': 1052072950,
'D5': {'E1': 12361, 'E2': -0.9551206081030594, 'E3': 2431},
'D6': 52508797,
'D7': 333975411,
'D8': 2819980876},
'A8': [56, -55, 60, 28, -104, 99]}
Пример 2
Двоичные данные:
b'\xfaAKRB`\xef\x96\\c\x9b\x1a\x15\x0fp\x00\x00\x00\x05\x00[\x1a\x90\xaf'
(b'\xd5:\xe7\x18!\x00\x02\x00\x00\x00`\x00\x00\x00r\x00\x02\x00\x00\x00'
b'~[\xd3\xbdU\x00\x00\x00\x02\x00\x00\x00\x8eY\xf1\xa9\x1b\xd9\x86?'
b'\xe9\x1d,\xe8\x08\xc9\xf6:\xdcv\xeb\xa2p\x03\xc1\xfd"4\x11\xf7m\x00\x00\x00'
b"\x03\x00\x92D\xc5g'\xa1\xbf\xed\xb6ja\xd7Q\xfa\x9f\xbf\xebG|oy\xfe\xd4Y\xeaI"
b'F\xa3E\xa6\xd6\x8d\x02\x9b1J`\x9din\xaee\xb4b\xe7\xd1j\xfb-\x89\x1a?\x8b\x19'
b'\x10p$\x1b\xf2')
Результат разбора:
'A1': 6984966870627195413,
{'A2': 3952,
'A3': [68, 197, 103, 39, 161],
'A4': 1914223171983579169,
'A5': [{'B1': -0.9285175238570098, 'B2': -97},
'B1': -0.8524763276363623, 'B2': 89}],
{'A6': {'C1': 16882102345237190285, 'C2': 43725130},
'A7': {'D1': [6961836523077874786, 16704250119927175743],
'D2': 1540603221,
'D3': [-29927, 4208],
'D4': 1509009691,
'D5': {'E1': -9850, 'E2': 0.7848114520950833, 'E3': 15068},
'D6': 1995154032,
'D7': 63044898,
'D8': 873592685},
'A8': [36, 27, -14]}
Задача №12
Реализовать разбор двоичного формата данных. Данные начинаются с сигнатуры 0x15 0x43 0x4e 0x4d 0x55
, за которой следует
структура A. Порядок байт: от младшего к старшему. Адреса указаны в виде смещений от начала данных. В решении предлагается использовать
модуль struct.
Структура A:
Поле | Описание |
---|---|
1 | uint16 |
2 | Размер (uint16) и адрес (uint16) массива структур B |
Структура B:
Поле | Описание |
---|---|
1 | Структура C |
2 | Массив int8, размер 5 |
3 | uint32 |
4 | Структура D |
5 | Размер (uint32) и адрес (uint32) массива int32 |
Структура C:
Поле | Описание |
---|---|
1 | Массив int16, размер 2 |
2 | float |
Структура D:
Поле | Описание |
---|---|
1 | int32 |
2 | int64 |
Ниже показаны примеры разбора двоичного формата.
Пример 1
Двоичные данные:
b'\x15CNMU\xc7G\x02\x00\x1b\x00\xa6\x15\xe7^\x18\x176\x9f@\x7f\x03\x88\xf3}uFv'
(b'\xear \xa2\x84,\xbe\xd3\\\x00\xd0|\x90D[\xdb\x1e\x87k\xa0\x1b9NP'
b"\xf6M\xba\xb4\x02\x00\x00\x00\x0b\x00\x00\x00\xe1'\xa3\x8fk;b?\xb3\xc7sN"
b'T\x8b\x03\xa2\x04\xcd\x96w\xb5K"\xd8\xc9\xe2\x80\xe9\x15\x02\x00\x00'
b'\x00\x13\x00\x00\x00')
Результат разбора:
'A1': 18375,
{'A2': [{'B1': {'C1': [-5514, 8306], 'C2': -0.1684747040271759},
'B2': [-45, 92, 0, -48, 124],
'B3': 3680191632,
'B4': {'D1': -1603565794, 'D2': -5423937080909743845},
'B5': [1592202662, -1623845096]},
'B1': {'C1': [10209, -28765], 'C2': 0.8837191462516785},
{'B2': [-77, -57, 115, 78, 84],
'B3': 77726603,
'B4': {'D1': -1250453811, 'D2': 1578934855907418699},
'B5': [-2013036736, 1182105075]}]}
Пример 2
Двоичные данные:
b'\x15CNMU"\x88\x02\x00#\x00\x1a&V\xcc\n\xf3\xe0\x7f\xc6IL\x9bg\xaaC$\xad'
(b'\xc1\xf2^\xa0\xa2\x82ac\x9d\xebv\x8f\x1b\x15\xbfC\xd8\x81\xf3\xe2\x11-q\x83'
b',\x90\xd5\x1alp!\xc0\xc8\xa6\x0e\x9c\x03\x00\x00\x00\x0b\x00\x00\x00'
b'\x84\xda\xd4\xcc\xa0\xbc\x17?$\x01\xa3n+\xae^n\xac\xc9\t\x8f\xfd\xcd:`'
b'\x1bt\xa2\xda^\x03\x00\x00\x00\x17\x00\x00\x00')
Результат разбора:
'A1': 34850,
{'A2': [{'B1': {'C1': [-25245, 30443], 'C2': -0.5824517607688904},
'B2': [67, -40, -127, -13, -30],
'B3': 2205232401,
'B4': {'D1': 450203692, 'D2': -7201635372971757460},
'B5': [-866769382, 2145448714, -1689499194]},
'B1': {'C1': [-9596, -13100], 'C2': 0.5927219390869141},
{'B2': [36, 1, -93, 110, 43],
'B3': 2892914350,
'B4': {'D1': -40957495, 'D2': 6834954004047346381},
'B5': [608414311, 1592967597, 1635951264]}]}
Задача №12
Реализовать разбор двоичного формата данных. Данные начинаются с сигнатуры 0xc3 0x4f 0x51 0x41
, за которой следует структура
A. Порядок байт: от младшего к старшему. Адреса указаны в виде смещений от начала данных. В решении предлагается использовать модуль
struct.
Структура A:
Поле | Описание |
---|---|
1 | float |
2 | int64 |
3 | Структура B |
4 | uint16 |
5 | Массив float, размер 6 |
Структура B:
Поле | Описание |
---|---|
1 | int8 |
2 | int8 |
3 | Размер (uint16) и адрес (uint32) массива адресов (uint32) структур C |
4 | Массив char, размер 2 |
5 | int8 |
6 | Структура D |
Структура C:
Поле | Описание |
---|---|
1 | int16 |
2 | int16 |
3 | int8 |
Структура D:
Поле | Описание |
---|---|
1 | Массив uint16, размер 5 |
2 | Размер (uint16) и адрес (uint32) массива uint32 |
3 | double |
4 | double |
Ниже показаны примеры разбора двоичного формата.
Пример 1
Двоичные данные:
b'\xc3OQAV{I=rO( \xc9\xf4Ao\x00?\x04\x00i\x00\x00\x00qq=Pq#J\xd3M\xcaa\xce'
(b'\xed\x04\x00y\x00\x00\x00\xcc\xd3z>\xd0\x03\xd9\xbf\x80w\xff\xf7#'
b'\x99\xeb\xbfdM\x13\xcf7>\xef\xf8\xb4>Qdi\xbe\xf6\x1b\xa2\xbe\xe8G@?\xef$4'
b'\xbf@C"`L\xcb\xf73\xff\xb3\xc3\x00\x8dy%\xe7\xae\xe4i\xf6U\x00\x00'
b'\x00Z\x00\x00\x00_\x00\x00\x00d\x00\x00\x00\x06\x9d\xdc4\xcd}l\xc4k\xb6\x02'
b'\xefU\xe8\xe8N')
Результат разбора:
'A1': 0.049189887940883636,
{'A2': 8016957956361310066,
'A3': {'B1': 0,
'B2': 63,
'B3': [{'C1': 17216, 'C2': 24610, 'C3': 76},
'C1': -2101, 'C2': -205, 'C3': -77},
{'C1': 195, 'C2': 31117, 'C3': 37},
{'C1': -20761, 'C2': 27108, 'C3': -10}],
{'B4': 'qq',
'B5': 61,
'B6': {'D1': [29008, 18979, 19923, 25034, 60878],
'D2': [886873350, 3295444429, 4009932395, 1323886677],
'D3': -0.390857754722046,
'D4': -0.8624439090451546}},
'A4': 19812,
'A5': [0.17950086295604706,
0.35346171259880066,
-0.2279217392206192,
-0.3166195750236511,
0.7510972023010254,
-0.7036885619163513]}
Пример 2
Двоичные данные:
b'\xc3OQA6 w\xbf\x9c2\x06"\xdb,\x86X/@\x04\x00i\x00\x00\x00js\xf0\xae'
(b'\x1e\x19\tn\xb3\x8d\xae\x05\xea\x03\x00y\x00\x00\x00\x80so\x1a\xd4'
b'\xc4\xa5\xbf^|\x85+\x81\xc2\xef?l\xe1y~8\xbd\xdb\x81\xb2>\xa5\xfbN'
b"\xbf\xec\x12\x0e\xbf\x90Z[\xbf\xbag\xfc:\xb2\x86\x98\x8f'fQ\xde\xc2w\x9f"
b'X\xb34\x8a\x0b\x01h\xf1\xebU\x00\x00\x00Z\x00\x00\x00_\x00\x00\x00d\x00\x00'
b'\x00a\x02\xa8a?K\x12D\x97t\n\xc5')
Результат разбора:
'A1': -0.9653352499008179,
{'A2': 6378835241897177756,
'A3': {'B1': 47,
'B2': 64,
'B3': [{'C1': -31054, 'C2': -28776, 'C3': 39},
'C1': 20838, 'C2': -15650, 'C3': 119},
{'C1': 22687, 'C2': 13491, 'C3': -118},
{'C1': 267, 'C2': -3736, 'C3': -21}],
{'B4': 'js',
'B5': -16,
'B6': {'D1': [7854, 2329, 45934, 44685, 59909],
'D2': [1638400609, 1142049599, 3305796759],
'D3': -0.042517307497951684,
'D4': 0.9924932336833867}},
'A4': 57708,
'A5': [-0.0450424887239933,
0.34864696860313416,
-0.8085272908210754,
-0.554976224899292,
-0.8568506240844727,
0.0019256987143307924]}
Задача №12
Реализовать разбор двоичного формата данных. Данные начинаются с сигнатуры 0x7a 0x53 0x49 0x46
, за которой следует структура
A. Порядок байт: от старшего к младшему. Адреса указаны в виде смещений от начала данных. В решении предлагается использовать модуль
struct.
Структура A:
Поле | Описание |
---|---|
1 | int32 |
2 | Адрес (uint16) структуры B |
3 | Структура C |
4 | uint16 |
5 | Массив int32, размер 3 |
6 | Массив uint8, размер 8 |
Структура B:
Поле | Описание |
---|---|
1 | Размер (uint32) и адрес (uint32) массива char |
2 | uint64 |
3 | uint16 |
4 | int8 |
Структура C:
Поле | Описание |
---|---|
1 | uint32 |
2 | uint16 |
3 | Массив адресов (uint32) структур D, размер 6 |
4 | Адрес (uint16) структуры E |
5 | Размер (uint32) и адрес (uint16) массива uint8 |
Структура D:
Поле | Описание |
---|---|
1 | uint32 |
2 | uint16 |
Структура E:
Поле | Описание |
---|---|
1 | int8 |
2 | double |
3 | int32 |
4 | uint8 |
5 | uint64 |
Ниже показаны примеры разбора двоичного формата.
Пример 1
Двоичные данные:
b'zSIF\xaa\xfd\x7f\x0e\x00J\x13\xd7b*\xe2\xec\x00\x00\x00]\x00\x00\x00c'
(b'\x00\x00\x00i\x00\x00\x00o\x00\x00\x00u\x00\x00\x00{\x00\x81\x00\x00'
b"\x00\x06\x00\x97\xcf\x91\x108\x81z'M\x98\x9e2T\xd4\xb2\x07\xd0G\x12\xf9\x9a"
b'\xaftzlbm\x00\x00\x00\x04\x00\x00\x00F0\xd3\xa1@\xfdU\x87\xec4\xbe]\xab\x07Y'
b'X\xd8\xb2d%\xd5f\xc4\xc4\xee\x976\xc9V$o\xb6\xe6c5R\x00wY\xc3\x19KB'
b'\xd8\x9c\x88f\xc7\xee\xbf\xea_\xd0\x80!\x1f\xac2\xf9\x80\x1b@\x07'
b'\x80\x14\xe1l\xb39?\x9a5\x11ZW_')
Результат разбора:
'A1': -1426227442,
{'A2': {'B1': 'zlbm', 'B2': 3518333034406709228, 'B3': 13502, 'B4': 93},
'A3': {'C1': 332882474,
'C2': 58092,
'C3': [{'D1': 2869385560, 'D2': 55474},
'D1': 1680201062, 'D2': 50372},
{'D1': 4002887369, 'D2': 22052},
{'D1': 1874257507, 'D2': 13650},
{'D1': 7821763, 'D2': 6475},
{'D1': 1121492104, 'D2': 26311}],
{'C4': {'E1': -18,
'E2': -0.8241961004759921,
'E3': 855212059,
'E4': 64,
'E5': 540454913708341567},
'C5': [154, 53, 17, 90, 87, 95]},
'A4': 53137,
'A5': [272138618, 659396766, 844420274],
'A6': [7, 208, 71, 18, 249, 154, 175, 116]}
Пример 2
Двоичные данные:
b'zSIFY\x9bR5\x00Lc\xb3?\x81e \x00\x00\x00_\x00\x00\x00e\x00\x00\x00k'
(b'\x00\x00\x00q\x00\x00\x00w\x00\x00\x00}\x00\x83\x00\x00\x00\x04\x00\x99'
b'\x1f\xfe\xf5\xfb\xce\xe7%\xf8\xb2\xde\xae\x10\x0b\xaf\xc8\x0c\xb6\xc5\xfa\\'
b'[\x1dhpzssp\x00\x00\x00\x06\x00\x00\x00F\x18_\xba\xd3\x00\xd4n\x06'
b'u\xa4\x81\x90\x98O$\xb5\xb10\xba\xac\x9d\xcd\xbd\xe0\xe7\xe0\xb4e^\xb0:n'
b'\xbe\xcf\xf5UUX\xd1t\xe5\xec\xb5H\x15+\xb9\xb6?\xeafm\x8b\xa3F\x9aj\xbc\x08n'
b'\xb7\n\xce\x06\n\xac\xc9b\x80\xfc\x8c\xf7\xa3')
Результат разбора:
'A1': 1503351349,
{'A2': {'B1': 'hpzssp', 'B2': 1756327795112570374, 'B3': 30116, 'B4': -127},
'A3': {'C1': 1672691585,
'C2': 25888,
'C3': [{'D1': 2425900836, 'D2': 46513},
'D1': 817540253, 'D2': 52669},
{'D1': 3773292724, 'D2': 25950},
{'D1': 2956619454, 'D2': 53237},
{'D1': 1431656657, 'D2': 29925},
{'D1': 3971303445, 'D2': 11193}],
{'C4': {'E1': -74,
'E2': 0.8250034072209076,
'E3': 1790707822,
'E4': 183,
'E5': 778566428499993216},
'C5': [252, 140, 247, 163]},
'A4': 8190,
'A5': [-168046873, 637055710, -1374680145],
'A6': [200, 12, 182, 197, 250, 92, 91, 29]}
Задача №12
Реализовать разбор двоичного формата данных. Данные начинаются с сигнатуры 0x51 0x57 0x45 0x3c
, за которой следует структура
A. Порядок байт: от младшего к старшему. Адреса указаны в виде смещений от начала данных. В решении предлагается использовать модуль
struct.
Структура A:
Поле | Описание |
---|---|
1 | int64 |
2 | Массив адресов (uint32) структур B, размер 2 |
3 | int16 |
Структура B:
Поле | Описание |
---|---|
1 | int64 |
2 | Адрес (uint16) структуры C |
3 | Структура D |
4 | int64 |
Структура C:
Поле | Описание |
---|---|
1 | uint8 |
2 | Размер (uint16) и адрес (uint32) массива uint64 |
Структура D:
Поле | Описание |
---|---|
1 | Массив int32, размер 2 |
2 | Массив int32, размер 7 |
Ниже показаны примеры разбора двоичного формата.
Пример 1
Двоичные данные:
b'QWE<\xcaW\xcb/b\x8fP\x03-\x00\x00\x00z\x00\x00\x00\xa1}5\x0c&\xa0N\xc0'
(b'\xc6\x19n|gs\xad\xd3N\xe6\xf9\x02\x00\x16\x00\x00\x00\xc1\x10\xd2\x981\\\xe7'
b'\x81&\x00\x92\x05\xc8\xf41)\x05\x08\x97\xfc\x18q\x8d\xa3\x93\xa7\xa1'
b'\x87w\r\xdac\xf4\x9b\r9\xd9\xe7\xa6\xa3\x1f=a\xa2\xb3\x01`\x14\xae\xf0\x82'
b'yZ\x9a\x94\xd7 \xe8\xde\x853\x8c\xa5\xc3i|\x1e\\\xf3r\x02\x02\x00c\x00'
b'\x00\x00\x8f\x05\x18\xad\x94\xefIus\x00{\x11\xf2u\xccJ\xe5U\xa962%!\x19^\xa9'
b'\xaf\xd5\x87"\x1ad\xf9\xbc\xc2GV\xbb\x87s\x90\xfc\xeb\xb4\xf7ql\xb2X\xdf'
b'\xd9\x86h\xb9')
Результат разбора:
'A1': 238848432122058698,
{'A2': [{'B1': -9086192355109629759,
'B2': {'C1': 249, 'C2': [1857383340263738421, 16595434418825821294]},
'B3': {'D1': [-188217966, 134555953],
'D2': [1897462935,
-1483496563,
225937313,
-1678482470,
-405194483,
1025483686,
28549729]},
'B4': -7324408240674040736},
'B1': 8451549597575677327,
{'B2': {'C1': 2, 'C2': [10102565581545854868, 8283065425670554533]},
'B3': {'D1': [1978798459, 1441090252],
'D2': [624047785,
-1453450975,
579327407,
-1124506598,
-1151973438,
-57642105,
1912059115]},
'B4': -5086667508801818004}],
'A3': 32161}
Пример 2
Двоичные данные:
b'QWE<"\x9c\xa7\x1d>\x80\xec\x9f-\x00\x00\x00z\x00\x00\x00\xe0\xde\xf7\x19'
(b'\xe2\x1e?\xeb,\x0cb\x10\x9c\xc0[\xdfm\x0e2\x02\x00\x16\x00\x00\x006\xba\xcd'
b'\xa6\x16\xfa8\x93&\x00\x1d\x99\xbc\x87\x9c\x96\xca\xf4\xc5\xef}\xb71'
b"\xe7\xd6U\x16\xb6\x03\x16\x1e_v\x88\xba'J\xda\xe3\x13\x06\x88RGx\x96\x84"
b'\xe4=\x03\xf4z>\xd1;\xb9\xde\x8cL>\x00P<^Q\xee\xf78\x16\xe0S\x02\x00c\x00'
b"\x00\x00'I\x82CX\xa8\x91ys\x00\xab\xae\xd9\xf0%\x9c\xff#Ij\x90= \xae\xa3b"
b'\x04\xcfFv\x8c\xce\xf6\x9ag\xc8\xe3\x1a\x9a\xf1\x8aP\xb8\xcdR\x99\x9dl\xe6k'
b'rr\x83\x86')
Результат разбора:
'A1': -6923017522901443550,
{'A2': [{'B1': -7838240176243623370,
'B2': {'C1': 50, 'C2': [877334683764005367, 1039732674158923874]},
'B3': {'D1': [-2017683171, -188049764],
'D2': [-1216483387,
1440147249,
369341974,
-2005508322,
-632674374,
-2012867613,
-1770502318]},
'B4': -3369120282781555580},
'B1': 8759967847255525671,
{'B2': {'C1': 83, 'C2': [5764676021536078139, 16147156151489879612]},
'B3': {'D1': [-254169429, 603954213],
'D2': [1032874569,
1654894112,
1984352004,
-1695101300,
451135591,
1351283098,
-1722626632]},
'B4': -8754027414916010851}],
'A3': -8480}
Задача №12
Реализовать разбор двоичного формата данных. Данные начинаются с сигнатуры 0x4d 0x4e 0x58 0xc2
, за которой следует структура
A. Порядок байт: от старшего к младшему. Адреса указаны в виде смещений от начала данных. В решении предлагается использовать модуль
struct.
Структура A:
Поле | Описание |
---|---|
1 | uint32 |
2 | int16 |
3 | int32 |
4 | float |
5 | uint32 |
6 | Адрес (uint32) структуры B |
7 | Массив uint8, размер 4 |
Структура B:
Поле | Описание |
---|---|
1 | Адрес (uint32) структуры C |
2 | Массив char, размер 2 |
3 | int16 |
4 | Массив структур D, размер 6 |
5 | double |
6 | Структура E |
Структура C:
Поле | Описание |
---|---|
1 | int16 |
2 | double |
Структура D:
Поле | Описание |
---|---|
1 | int16 |
2 | uint16 |
3 | float |
4 | uint32 |
5 | float |
Структура E:
Поле | Описание |
---|---|
1 | int64 |
2 | uint32 |
3 | Массив uint8, размер 5 |
Ниже показаны примеры разбора двоичного формата.
Пример 1
Двоичные данные:
b'MNX\xc2\xd7\x9a]\x88\xb9\xdadx&l?F|\xcby:\xe52\x00\x00\x00(Ib'
(b"\xa5\x8f\x85\xde\xbf\xed0\xab\xcf\xa3'N\x00\x00\x00\x1ekoV\xfb\xfce\xc9\xaa"
b'\xbe\x1a\x86\x01b)E\xed?\x12\x85\x8fs\xec\x1d\xcb?o\xa8\x9cb|\xef8>\xab\xcc('
b'#\x85\xa0\x08<u\x0e\xb6\x85\xcc\xfe\xbb?K\xc8q\xc1+\xcb\xe6>\xb2N\xf3'
b'I\xe51\xf8?&\xb3\x8c2\x93.\xa2\xbf/k\xdeY-?\x8f>\xfb\x87\x19Z\xa4=e?uFY'
b'\xd1a =>%\xa0\x11\xbf\xd5UQ\n/e\xe03.\xff_{?^W\x0b\xf3\xe2\xe4'
b'\x89\x1a\x13\xab\x9e')
Результат разбора:
'A1': 3617217928,
{'A2': -17958,
'A3': 1685595756,
'A4': 0.7753416895866394,
'A5': 2033902898,
'A6': {'B1': {'C1': -31266, 'C2': -0.9121913009086968},
'B2': 'ko',
'B3': 22267,
'B4': [{'D1': -923,
'D2': 51626,
'D3': -0.15090180933475494,
'D4': 1646872045,
'D5': 0.5723504424095154},
'D1': 29676,
{'D2': 7627,
'D3': 0.936166524887085,
'D4': 1652354872,
'D5': 0.3355419635772705},
'D1': 9093,
{'D2': 40968,
'D3': 0.014957120642066002,
'D4': 2244804283,
'D5': 0.7960272431373596},
'D1': -16085,
{'D2': 52198,
'D3': 0.3482585847377777,
'D4': 1239757304,
'D5': 0.651177167892456},
'D1': 12947,
{'D2': 11938,
'D3': -0.6852396726608276,
'D4': 1496137615,
'D5': 0.49126508831977844},
'D1': 23204,
{'D2': 15717,
'D3': 0.95810467004776,
'D4': 3512803389,
'D5': 0.1617434173822403}],
'B5': -0.3333323096718157,
'B6': {'E1': 3688165930417741399,
'E2': 200532708,
'E3': [137, 26, 19, 171, 158]}},
'A7': [73, 98, 165, 143]}
Пример 2
Двоичные данные:
b'MNX\xc2y\xf0\xa5\xf6#p7\xca\x05\xdd?E\xee\x174\xf4\xac=\x00\x00\x00(\xf9"'
(b')\xb8\n)\xbf\xd8zc\xaa<:P\x00\x00\x00\x1ezs\x7f;11\x1d\xd1=\xcf>v'
b'G\xce\x04\x93\xbfFM\x08\x1a\xcd\xf0\x93\xbe\xe3\xe1\x8f\x0b\x1c\x15\x17'
b'<\x8c\x98\x1f\x0c\x14\x91\x1d\xbfZ\x8aE\xf7\x8c\xfe\xf3<\xfb\xb8#\x17{!\x92'
b'?u,c\xde8E\xcd\xbf\x16\x87\xfbV\xbf\xa9\xd4>\xd80\xbc\x8f\xb2\xa6\xc1=VZ\xec'
b'3\xdfN\x0c>\xe7\x9b\xd1\xf4g\x00\x83\xbd\xa0\xa0F?\xe0Q\xa9%\xbc\xf9\xe0'
b'\xbb\xde\xef\xbf\x18\x15:\xc1l1\xe1\x8d0\x9b9G\xb4')
Результат разбора:
'A1': 2045814262,
{'A2': 9072,
'A3': 935986653,
'A4': 0.7731642127037048,
'A5': 888450109,
'A6': {'B1': {'C1': 2601, 'C2': -0.38247005104577614},
'B2': 'zs',
'B3': 32571,
'B4': [{'D1': 12593,
'D2': 7633,
'D3': 0.10119335353374481,
'D4': 1204683923,
'D5': -0.7746129035949707},
'D1': 6861,
{'D2': 61587,
'D3': -0.4450802505016327,
'D4': 186389783,
'D5': 0.0171623807400465},
'D1': 3092,
{'D2': 37149,
'D3': -0.8536723256111145,
'D4': 4153212659,
'D5': 0.030727451667189598},
'D1': 6011,
{'D2': 8594,
'D3': 0.9577085375785828,
'D4': 3728229837,
'D5': -0.5880123972892761},
'D1': 22207,
{'D2': 43476,
'D3': 0.4222468137741089,
'D4': 2410849985,
'D5': 0.052332803606987},
'D1': 13279,
{'D2': 19980,
'D3': 0.4523606598377228,
'D4': 4100391043,
'D5': -0.07843069732189178}],
'B5': 0.5099683510850888,
'B6': {'E1': -4909222939765425471,
'E2': 1815208333,
'E3': [48, 155, 57, 71, 180]}},
'A7': [249, 34, 41, 184]}
Задача №12
Реализовать разбор двоичного формата данных. Данные начинаются с сигнатуры 0x4 0x41 0x5a 0x53 0x48
, за которой следует
структура A. Порядок байт: от младшего к старшему. Адреса указаны в виде смещений от начала данных. В решении предлагается использовать
модуль struct.
Структура A:
Поле | Описание |
---|---|
1 | int16 |
2 | Размер (uint16) и адрес (uint16) массива char |
3 | int32 |
4 | Адрес (uint32) структуры B |
5 | uint16 |
Структура B:
Поле | Описание |
---|---|
1 | Массив адресов (uint32) структур C, размер 5 |
2 | Размер (uint32) и адрес (uint16) массива int16 |
3 | float |
4 | Массив int8, размер 5 |
5 | float |
6 | uint32 |
7 | int32 |
8 | Структура D |
Структура C:
Поле | Описание |
---|---|
1 | int32 |
2 | uint8 |
Структура D:
Поле | Описание |
---|---|
1 | float |
2 | uint16 |
3 | uint16 |
Ниже показаны примеры разбора двоичного формата.
Пример 1
Двоичные данные:
b'\x04AZSH_+\x06\x00\x15\x003\xb0\x16\x0cD\x00\x00\x00\xfc\xa2iudcma\xbd'
(b'\xef\x9a (\x98%\xb2<v\x0b\xaeD+\x1a\xee\xe9\x90\xef\\IH\xa1\xbb\xe3'
b'\xac\xb0G\x84\xdd\x0eT&\xf0\x0b\xca?to\xb1\xa5\x1b\x00\x00\x00 \x00\x00\x00'
b'%\x00\x00\x00*\x00\x00\x00/\x00\x00\x00\x08\x00\x00\x004\x00\xb5\x927?\x8dy'
b'\x14\xe4\x0b\xd8\x94\x0b\xbf)\x11\x8f*\\J\x83\x8ee\x8aH?KQ\xf2\x80')
Результат разбора:
'A1': 11103,
{'A2': 'iudcma',
'A3': 202813491,
'A4': {'B1': [{'C1': 547024829, 'C2': 40},
'C1': 1018307992, 'C2': 118},
{'C1': 725921291, 'C2': 26},
{'C1': -275715602, 'C2': 92},
{'C1': -1147058103, 'C2': 227}],
{'B2': [-20308, -31673, 3805, 9812, 3056, 16330, 28532, -23119],
'B3': 0.7170823216438293,
'B4': [-115, 121, 20, -28, 11],
'B5': -0.5452399253845215,
'B6': 714019113,
'B7': -1903998372,
'B8': {'D1': 0.7833617329597473, 'D2': 20811, 'D3': 33010}},
'A5': 41724}
Пример 2
Двоичные данные:
b'\x04AZSH\x06\x11\x06\x00\x15\x00@\xfc1\\@\x00\x00\x00\x15\xfcrzbqsv\x9d'
(b';\xbf\xe4\xf8xT\x1bB\xc2\x92\xe10\x93\x8d\xaa\xf03<\x08i\x08\x8e\xa3~'
b'\xd1t\x0e\xf7\xd1\xa1\\R@\x0cw\xa7\x1b\x00\x00\x00 \x00\x00\x00%\x00\x00\x00'
b'*\x00\x00\x00/\x00\x00\x00\x06\x00\x00\x004\x00\x0b\xfb\xf4<$\xd6@\xf9q\xa5'
b'\xfa\xd5\xbe\xcd\xf2\x1f\x95\xfc\x98\x8c\x00H\xdeH\xbf\xe8\xf1~\x13')
Результат разбора:
'A1': 4358,
{'A2': 'rzbqsv',
'A3': 1546779712,
'A4': {'B1': [{'C1': -457229411, 'C2': 248},
'C1': 1109087352, 'C2': 194},
{'C1': -1825513070, 'C2': 141},
{'C1': 1010036906, 'C2': 8},
{'C1': -1550972823, 'C2': 126}],
{'B2': [29905, -2290, -24111, 21084, 3136, -22665],
'B3': 0.029904862865805626,
'B4': [36, -42, 64, -7, 113],
'B5': -0.41792789101600647,
'B6': 2501898957,
'B7': 9214204,
'B8': {'D1': -0.7846417427062988, 'D2': 61928, 'D3': 4990}},
'A5': 64533}
Задача №12
Реализовать разбор двоичного формата данных. Данные начинаются с сигнатуры 0x4a 0x54 0x42
, за которой следует структура A.
Порядок байт: от старшего к младшему. Адреса указаны в виде смещений от начала данных. В решении предлагается использовать модуль
struct.
Структура A:
Поле | Описание |
---|---|
1 | Адрес (uint32) структуры B |
2 | uint32 |
3 | uint16 |
4 | Адрес (uint16) структуры D |
5 | double |
6 | int32 |
7 | uint8 |
8 | uint64 |
Структура B:
Поле | Описание |
---|---|
1 | Массив структур C, размер 2 |
2 | Массив char, размер 2 |
3 | Размер (uint32) и адрес (uint32) массива int16 |
4 | int16 |
5 | uint16 |
6 | Размер (uint16) и адрес (uint32) массива int8 |
Структура C:
Поле | Описание |
---|---|
1 | double |
2 | uint32 |
3 | uint32 |
Структура D:
Поле | Описание |
---|---|
1 | Массив double, размер 8 |
2 | int32 |
Ниже показаны примеры разбора двоичного формата.
Пример 1
Двоичные данные:
b'JTB\x00\x00\x00.Tt\xd9\x8cr\xf7\x00b?\xd4\x9d[\xbeK\xc88f\xb7A\x05\x95'
(b'\xe1\xa5_\x86\xd1"\x01\xdc\x1bw\xe0r\x03\xb8f\x1f\xa1\xb1\xbf\xc5c2\xf0\x8e'
b'\x83\xc8\x82o\xea\t\xb6I\xaa\x8e\xbf\xd0\x00V\x11c\xd3\xf4B\x92|)\x95\xe1'
b'\xebVwo\x00\x00\x00\x04\x00\x00\x00$"\xfd\xc8\xf9\x00\x02\x00\x00\x00,?\xeb'
b'[0{\x93\xdc\x80\xbf\xcd\x0eY/%\xd1`?\xe4\xfe\x0fL\xb7\xed\xac?\xd3'
b'\xfe\x1d\xda\xdbO,?\xe9\xdb\xd3\xae\xda\x04\x10\xbf\xdf:\x10\xd6\x00'
b'\xfd`\xbf\xdb\x88\xe8w\xcc.,\xbf\xef\xd4\xe2\xe6\x07*.qv\x1a*')
Результат разбора:
'A1': {'B1': [{'C1': -0.16708981271679435, 'C2': 2188372489, 'C3': 3058281102},
{'C1': -0.25002052019345844,
{'C2': 1116896297,
'C3': 2514611030}],
'B2': 'wo',
'B3': [7031, -8078, 952, 26143],
'B4': 8957,
'B5': 51449,
'B6': [-95, -79]},
'A2': 1416944012,
'A3': 29431,
'A4': {'D1': [0.8548815168022799,
-0.22700037767539083,
0.6560131548316597,
0.31238504765245767,
0.808084336764411,
-0.48791905306639727,
-0.43023120593054176,
-0.9947370999082688],
'D2': 1903565354},
'A5': 0.3221043928489311,
'A6': 1723285765,
'A7': 149,
'A8': 16259507062329967068}
Пример 2
Двоичные данные:
b'JTB\x00\x00\x002s\x8e\x84.\xc5w\x00f\xbf\xdf\xac\xbbRB\xa7\xbcU'
(b'\x93\xc5\xda\xea\x0b\x88\xe2t\nm\xfed(\xb3\x17\xad\xe9<\n<\x1c\xdc\x90Q'
b'M\xda\xbf\xe9\xfd:\x87\xdb\x84$\xbc\x06\x9c\xb1\x07\xa2\x84z\xbf\xea'
b'\xf2\xdf\xbb\xe3\x19B\xfa\xedZ%\x98\xda\xd1\xb7ep\x00\x00\x00\x04'
b'\x00\x00\x00$\xa9`\xb2\x87\x00\x06\x00\x00\x00,?\xe8Fl\xee\xed'
b'\xd0\xb6\xbf\xc3\x04]\x80\x06\x90(?\xb79^\xe8\xac\xf0\x00?\xd3'
b'\xa8\x94\xea\x85wT\xbf\xed\xb2\xd1\x11\xcd\xe3 ?\xe0\x05&\x1f\x10Nz\xbf\xe9'
b'e\xb7f\xc0X\xa2?\xbe\x19\xcfq-o \x97\x87\xdb\x08')
Результат разбора:
'A1': {'B1': [{'C1': -0.8121616986719613, 'C2': 3154549937, 'C3': 128091258},
{'C1': -0.8421477002782825, 'C2': 4209859109, 'C3': 2564477367}],
{'B2': 'ep',
'B3': [10419, 6061, -5828, 2620],
'B4': -22176,
'B5': 45703,
'B6': [28, -36, -112, 81, 77, -38]},
'A2': 1938719790,
'A3': 50551,
'A4': {'D1': [0.7585968653279653,
-0.14857071639301123,
0.09071915798716645,
0.3071644106147364,
-0.9280782077540586,
0.5006285292351571,
-0.7936665541517594,
0.1175813342392158],
'D2': -1752704248},
'A5': -0.49491770776023336,
'A6': 1435747802,
'A7': 234,
'A8': 831163119268920932}
Задача №12
Реализовать разбор двоичного формата данных. Данные начинаются с сигнатуры 0x45 0x46 0x5a 0xf5
, за которой следует структура
A. Порядок байт: от младшего к старшему. Адреса указаны в виде смещений от начала данных. В решении предлагается использовать модуль
struct.
Структура A:
Поле | Описание |
---|---|
1 | Адрес (uint16) структуры B |
2 | int32 |
3 | Размер (uint16) и адрес (uint32) массива адресов (uint32) структур C |
4 | uint32 |
5 | Размер (uint16) и адрес (uint16) массива char |
6 | Структура D |
7 | Массив int32, размер 6 |
Структура B:
Поле | Описание |
---|---|
1 | uint16 |
2 | int8 |
3 | uint32 |
Структура C:
Поле | Описание |
---|---|
1 | Массив char, размер 4 |
2 | int16 |
Структура D:
Поле | Описание |
---|---|
1 | uint16 |
2 | int8 |
3 | int16 |
4 | double |
5 | Размер (uint16) и адрес (uint16) массива double |
6 | int64 |
7 | uint64 |
Ниже показаны примеры разбора двоичного формата.
Пример 1
Двоичные данные:
b'EFZ\xf5Q\x00\xff#\xccM\x02\x00d\x00\x00\x00\xd8g\xef\x19\x04\x00l\x00'
(b'e\x0b\xd0\xfdgp=c\xc3\r;\xbd\xbf\x04\x00p\x00x\xb4\xdav\r\xcf\xa9'
b'\xd7\x0c\x0bA:($\xf7\x08%$\x8b\xb3\x93ve\xe0h4\xeb:2\nE\\:\xa7,\xc5+\x84\xdf'
b'\xeb\x7f\xe0i\x16v\x8f\x9copde\xe5\xe1hjkj\xf2vX\x00\x00\x00^\x00\x00\x00'
b'zvjtF\x8f\x7f\xfdj\xc5\xe5?tk\xc2\xcd>\xfa\xee\xbf(^\xd4\x82\t\x84\xcd\xbf'
b'\xfe\xcf\xa1\xf2\x93\x81\xea?')
Результат разбора:
'A1': {'B1': 57471, 'B2': 105, 'B3': 2626647574},
{'A2': 1305224191,
'A3': [{'C1': 'opde', 'C2': -7707}, {'C1': 'hjkj', 'C2': 30450}],
'A4': 435120088,
'A5': 'zvjt',
'A6': {'D1': 2917,
'D2': -48,
'D3': 26621,
'D4': -0.11418233890730334,
'D5': [0.680348868478611,
-0.968047525285654,
-0.23059195411836808,
0.8283176173122226],
'D6': -2906564427755375496,
'D7': 646024826745588492},
'A7': [-1282726875, -530221421, 988492904, 1548028466, -986929350, -337673173]}
Пример 2
Двоичные данные:
b'EFZ\xf5Q\x00\x85\x0e>t\x03\x00j\x00\x00\x00\xf9\xdcd\xfe\x03\x00v\x00'
(b'\xc8\xae\xbf`\x874C\xf2\x90wg\xec\xbf\x05\x00y\x00\xfe\xe1\x11\xaad*\xb1'
b'y\xba\x0e\xa4^kR?\xc3<\x80BJvE4\xbekw\x15\xcaW\xb0,&7j\x8f\xfcAq\x13i\x92M}'
b'\x051\t\x87yotzR\x9aosxj\x7f\x9cxaee\xf4{X\x00\x00\x00^\x00\x00\x00d\x00'
b'\x00\x00uls\xb0\x04"8\x07\xdc\xce?\x98\x10\xbaw/w\xc6?\x1c\n^\xc1 8\xea'
b'?\\`\xf1?\xc7\x83\xea\xbf\xc04jt$\x92\xc7\xbf')
Результат разбора:
'A1': {'B1': 19858, 'B2': 125, 'B3': 2265526533},
{'A2': 1950224005,
'A3': [{'C1': 'yotz', 'C2': -26030},
'C1': 'osxj', 'C2': -25473},
{'C1': 'xaee', 'C2': 31732}],
{'A4': 4268023033,
'A5': 'uls',
'A6': {'D1': 44744,
'D2': -65,
'D3': -30880,
'D4': -0.8876302557929194,
'D5': [0.2410897277914379,
0.175512250385627,
0.8193515564638036,
-0.8285862206348713,
-0.18414741215057084],
'D6': 8768836561305461246,
'D7': 14069054382031507130},
'A7': [1245872188, -1103870602, -904562837, 640462935, -57710025, 1762881857]}
Задача №12
Реализовать разбор двоичного формата данных. Данные начинаются с сигнатуры 0x49 0x53 0x54 0x59
, за которой следует структура
A. Порядок байт: от старшего к младшему. Адреса указаны в виде смещений от начала данных. В решении предлагается использовать модуль
struct.
Структура A:
Поле | Описание |
---|---|
1 | Адрес (uint32) структуры B |
2 | Размер (uint16) и адрес (uint16) массива адресов (uint16) структур C |
3 | float |
4 | uint16 |
5 | Массив char, размер 5 |
6 | int64 |
7 | Адрес (uint32) структуры D |
Структура B:
Поле | Описание |
---|---|
1 | int8 |
2 | double |
3 | float |
4 | double |
5 | uint64 |
Структура C:
Поле | Описание |
---|---|
1 | int32 |
2 | uint64 |
3 | Массив char, размер 4 |
Структура D:
Поле | Описание |
---|---|
1 | uint32 |
2 | uint32 |
3 | int64 |
4 | uint8 |
5 | Массив int8, размер 7 |
6 | Размер (uint32) и адрес (uint32) массива uint8 |
7 | int8 |
Ниже показаны примеры разбора двоичного формата.
Пример 1
Двоичные данные:
b'ISTY\x00\x00\x00#\x00\x02\x00`?\\s\x9d\xb9\x18abuhh\xc5\xa1Q\xc6\xc2'
(b'\x10Y\xe9\x00\x00\x00f-?\xd1t\xdc\x8e\x80\xf1\xec?\x127\xbf?\xe8P\xb4'
b'\x1c\x8e]\xf6jU\x06=\xcd#?{\x11\xa41\xdbV\n\xdc\xeaZ{rpnsbk\xc3\x04n='
b'\xa8\x18\xbf\xa4\x0e\x0f\xe7\xb8ccdw\x00@\x00P!P\xb5\xb8\xbd\x8c\xab\x12'
b'\x99\xa8\xd4\xc0\xa4E\xc2\xda\xe6\xc1_\x8cw\xc7(\xcfV\xc8\x00\x00'
b'\x00\x02\x00\x00\x00d\xaa')
Результат разбора:
'A1': {'B1': 45,
{'B2': 0.27275766292930714,
'B3': 0.5711631178855896,
'B4': 0.7598515088783973,
'B5': 7662037203545177979},
'A2': [{'C1': 295973339, 'C2': 6200010736127406704, 'C3': 'nsbk'},
'C1': -1023119811, 'C2': 12112641909144414136, 'C3': 'ccdw'}],
{'A3': 0.8611391186714172,
'A4': 47384,
'A5': 'abuhh',
'A6': -4205990662886106647,
'A7': {'D1': 3048783244,
'D2': 2870122920,
'D3': -3116310322611558719,
'D4': 95,
'D5': [-116, 119, -57, 40, -49, 86, -56],
'D6': [33, 80],
'D7': -86}}
Пример 2
Двоичные данные:
b'ISTY\x00\x00\x00#\x00\x02\x00`>\x1aHj\xf6\xadzncvo\xe7\xd82Z\x08'
(b'\xd2\xb1\x15\x00\x00\x00f\xb0\xbf\xe2\xb1\x84CM\xc0\xb4\xbd\xdc\x9dN'
b'?\x81\xd1ZL\xd1A\x00\xa10\x9c\xb9!\x05z\x0e\x8ex\xf2c4Vc>\xd4\xe4\xc0\x14'
b'sclvAx\xf7\x03\xba;4\xc3\x80\xe3\x04_tiye\x00@\x00P\xe36\xf6"\xe6O\xf3\x9b'
b'\x0c\xefknd@\xc9\x9a&\xe6\x7f\x19\xd7\xa2\xc7Qb|\x00\x00\x00\x02\x00\x00'
b'\x00d\xe8')
Результат разбора:
'A1': {'B1': -80,
{'B2': -0.5841695131803335,
'B3': -0.10772190988063812,
'B4': 0.008700089902192065,
'B5': 11614955757925399054},
'A2': [{'C1': -1904676253, 'C2': 3771310859480252436, 'C3': 'sclv'},
'C1': 1098446595, 'C2': 13419377528966153311, 'C3': 'tiye'}],
{'A3': 0.15066686272621155,
'A4': 63149,
'A5': 'zncvo',
'A6': -1740585893702225643,
'A7': {'D1': 4129482319,
'D2': 4087024879,
'D3': 7741235038919468774,
'D4': 127,
'D5': [25, -41, -94, -57, 81, 98, 124],
'D6': [227, 54],
'D7': -24}}
Задача №12
Реализовать разбор двоичного формата данных. Данные начинаются с сигнатуры 0x4a 0x56 0x4c 0x9a
, за которой следует структура
A. Порядок байт: от старшего к младшему. Адреса указаны в виде смещений от начала данных. В решении предлагается использовать модуль
struct.
Структура A:
Поле | Описание |
---|---|
1 | Адрес (uint32) структуры B |
2 | Размер (uint16) и адрес (uint32) массива структур D |
Структура B:
Поле | Описание |
---|---|
1 | float |
2 | Структура C |
3 | float |
4 | double |
Структура C:
Поле | Описание |
---|---|
1 | int8 |
2 | int16 |
3 | Массив char, размер 5 |
4 | Размер (uint16) и адрес (uint16) массива int8 |
5 | int8 |
6 | uint8 |
7 | int8 |
8 | int16 |
Структура D:
Поле | Описание |
---|---|
1 | uint32 |
2 | float |
3 | Массив float, размер 7 |
4 | uint64 |
5 | int16 |
6 | double |
7 | uint16 |
8 | double |
Ниже показаны примеры разбора двоичного формата.
Пример 1
Двоичные данные:
b'JVL\x9a\x00\x00\x00\x11\x00\x02\x00\x00\x002\xca\xd2_>\xc7\xe4\xf5\xe3*\xfc'
(b'hatyc\x00\x03\x00\x0e\x80^\xc7\x08\x97=\xd04 \xbf\xe9R\xcf\xac%'
b'\xf2\x80\r\xf4\x97\x06?U\xbb \xbf.\x99\x1d?F\x03G>W\xfa\xe6\xbe\xc7'
b"\x90\x81\xbf\x15\xe7\x8b\xbe\xbd\xda\xf1?\x07\x97\x84~\r\xef\xea@'"
b'\x86\xe50\x1c\xbf\xe5Cg\xa0\xd7\xb7.y\xbd?\xed$\x82j\x90\xa0\xd6c\x84'
b'\xc1L?\x11\xad\x8f=\xb6M&?>\xbf\x06>\x93\xbd\xed\xbf_\x88R\xbe\xb0<\x1c>\x98'
b'\xa5\xe9\xbd\xc4\xb9\xf6\xeb\x81gZ\xcam\x88\xe6p\x0b?\xe1\x00\x99\xa1>\xc8T'
b"\x86'?\xebn\x91\x1d\xc1W\x06")
Результат разбора:
'A1': {'B1': 0.39041867852211,
{'B2': {'C1': -29,
'C2': 11004,
'C3': 'hatyc',
'C4': [-54, -46, 95],
'C5': -128,
'C6': 94,
'C7': -57,
'C8': 2199},
'B3': 0.10166192054748535,
'B4': -0.7913587915678164},
'A2': [{'D1': 234133254,
'D2': 0.8348865509033203,
'D3': [-0.682023823261261,
0.7734875082969666,
0.21091803908348083,
-0.389774352312088,
-0.5855643153190613,
-0.37081101536750793,
0.5296556949615479],
'D4': 9083179812853876453,
'D5': 12316,
'D6': -0.664478124757556,
'D7': 31165,
'D8': 0.9107067185732614},
'D1': 1669644620,
{'D2': 0.5690545439720154,
'D3': [0.08901433646678925,
0.7451022863388062,
0.28855839371681213,
-0.8731738328933716,
-0.34420859813690186,
0.2981407940387726,
-0.09605781733989716],
'D4': 16969958510549633254,
'D5': 28683,
'D6': 0.5313232564278771,
'D7': 34343,
'D8': 0.857246931186382}]}
Пример 2
Двоичные данные:
b'JVL\x9a\x00\x00\x00\x11\x00\x02\x00\x00\x002k\xe86?L\xdd\xac\x11[\x95qojp'
(b'o\x00\x03\x00\x0e48\xf6\x8a\xc3?W\x17\xa9?\xcd\xa7\x99\xef\xc89\x88G\xc1'
b'$\x14\xbej\xeb\xfd\xbe\xcf\xa7\xc4>\xe9I5>\x87\xf8B\xbf&}t\xbe\x8fmo\xbe`'
b'\x1c\x85\xbfw\xdeo\x80\xb6\xb0\xec\xda\x17\\y\xbb\xab?\xce\x145'
b'\xc1\xa3\xe8\x08\x9c\xff\xbf\xc3\xb1\x0e\x89\xec.\xa0\xa0\x86}\xf5\xbfc'
b"\xe5'>foK>\xcd\xa4\x10\xbe\xf0\xb3Y?\x11\xee\xde>\xbf\xc2\x1e?h\x1b@=\xd3"
b']2\t\x0b\xadI\xaaRM\xc6?7?\xce\xec\xb50P\xd7\xb8A6\xbf\xc5\xb5@\xc2-4\x18')
Результат разбора:
'A1': {'B1': 0.8002574443817139,
{'B2': {'C1': 17,
'C2': 23445,
'C3': 'qojpo',
'C4': [107, -24, 54],
'C5': 52,
'C6': 56,
'C7': -10,
'C8': -30013},
'B3': 0.8402047753334045,
'B4': 0.2316772862254306},
'A2': [{'D1': 1203840020,
'D2': -0.22941584885120392,
'D3': [-0.40557682514190674,
0.4556366503238678,
0.2655659317970276,
-0.6503517627716064,
-0.2801317870616913,
-0.21885879337787628,
-0.9682378172874451],
'D4': 9274795013933849721,
'D5': -17493,
'D6': 0.2349917598256186,
'D7': 40191,
'D8': -0.15384084448338786},
'D1': 2693168629,
{'D2': -0.8902153372764587,
'D3': [0.2250339239835739,
0.4016423225402832,
-0.47011831402778625,
0.5700510740280151,
0.37452787160873413,
0.9066658020019531,
0.10320509970188141],
'D4': 651805102986907078,
'D5': 16183,
'D6': 0.2415987478177024,
'D7': 16694,
'D8': -0.16959390145567066}]}
Задача №12
Реализовать разбор двоичного формата данных. Данные начинаются с сигнатуры 0xa 0x44 0x41 0x48 0x41
, за которой следует
структура A. Порядок байт: от старшего к младшему. Адреса указаны в виде смещений от начала данных. В решении предлагается использовать
модуль struct.
Структура A:
Поле | Описание |
---|---|
1 | Размер (uint16) и адрес (uint32) массива char |
2 | double |
3 | Массив адресов (uint32) структур B, размер 3 |
4 | float |
5 | float |
6 | Адрес (uint16) структуры C |
7 | int8 |
8 | Размер (uint32) и адрес (uint16) массива float |
Структура B:
Поле | Описание |
---|---|
1 | uint8 |
2 | uint64 |
Структура C:
Поле | Описание |
---|---|
1 | Адрес (uint32) структуры D |
2 | Размер (uint32) и адрес (uint32) массива int32 |
3 | int64 |
4 | Массив int16, размер 7 |
Структура D:
Поле | Описание |
---|---|
1 | float |
2 | int16 |
3 | uint64 |
Ниже показаны примеры разбора двоичного формата.
Пример 1
Двоичные данные:
b'\nDAHA\x00\x02\x00\x00\x000\xbf\xe3~3\x9bZ\xae\xce\x00\x00\x002\x00'
(b'\x00\x00;\x00\x00\x00D=\x8b\xe9\x97\xbf@=\x07\x00c,\x00\x00\x00\x05\x00\x85'
b'mwjY\x99Q\xd8s/>\xc9\xfb\x10\xfe\xcf6\xeaN\x9b\xf7\x1c\x98\x8esU\x83\x1cs'
b'->\xcd:\xd4)K\xfb\xcd\xbaW\xa6\xbe\xd9\x8b8Y\x8a&\xf9\xe7\xc8a\x00'
b'\x00\x00M\x00\x00\x00\x02\x00\x00\x00[e~\xed\xe70\xd9\x11i\xdd\x13zW\xc9'
b'\xdd\x94\x8c\xc5| 9\xcc\xe8\xbf)\xd7\x04\xbe\xe0\xeb7\xbeOa\xcd\xbf|>'
b'\xf4\xbf?\xb0\x93')
Результат разбора:
'A1': 'mw',
{'A2': -0.6091554674398709,
'A3': [{'B1': 106, 'B2': 6456281530899578569},
'B1': 251, 'B2': 1224643983457557495},
{'B1': 28, 'B2': 10992850551567053613}],
{'A4': 0.06831663101911545,
'A5': -0.7509312033653259,
'A6': {'C1': {'D1': 0.4008394479751587,
'D2': 10571,
'D3': 18144363359368042891},
'C2': [945392166, -102250399],
'C3': 7313544422109024617,
'C4': [-8941, 31319, -13859, -27508, -14980, 8249, -13080]},
'A7': 44,
'A8': [-0.6634371280670166,
-0.4392945468425751,
-0.20252151787281036,
-0.9853355884552002,
-0.748788058757782]}
Пример 2
Двоичные данные:
b'\nDAHA\x00\x02\x00\x00\x000\xbf\xc8gV\x96J\xd4\xe8\x00\x00\x002\x00'
(b'\x00\x00;\x00\x00\x00D>\x96N4\xbe\xf7\xcct\x00c\x07\x00\x00\x00\x07\x00\x85'
b'bw\x94\xe8-?\xd1\xb0\x04%7\xf1\xef\xb6,\xca\x98*\x92\xe1g\x1b\x02\xcf'
b'\xabk\xb3\xa5\xd2?Ex\xfb\x06\xb6\xc1CI\xb2\xd1\xbe\xf1$\xfb@\x88\xab\x92'
b'\xa00g\x00\x00\x00M\x00\x00\x00\x02\x00\x00\x00[\xc3/,\xae\x8f'
b'\x00\xef\xe5\xd3tIJ\x1c\xc7\xdf\xf8\xb8?/L\xd2\xd1?n\xfc\xea?\x05\n'
b'\xfb>\x9e\xe8U\xbe\x89\xf6\x83\xbf\x077\xe8>\xd6\x8b\x06\xbf6\x08\x02')
Результат разбора:
'A1': 'bw',
{'A2': -0.19065363253108747,
'A3': [{'B1': 148, 'B2': 16730098360585037111},
'B1': 241, 'B2': 17273042669474058977},
{'B1': 103, 'B2': 1946346324130768338}],
{'A4': 0.29356539249420166,
'A5': -0.483981728553772,
'A6': {'C1': {'D1': 0.7713772654533386,
'D2': 1718,
'D3': 13926055505131663652},
'C2': [-79656789, -1834995609],
'C3': -4382234784173068315,
'C4': [-11404, 18762, 7367, -8200, -18369, 12108, -11567]},
'A7': 7,
'A8': [0.9335466623306274,
0.5196987986564636,
0.31036630272865295,
-0.2694588601589203,
-0.5281968116760254,
0.4190294146537781,
-0.7110596895217896]}
Задача №12
Реализовать разбор двоичного формата данных. Данные начинаются с сигнатуры 0x1f 0x4d 0x41 0x4a 0x49
, за которой следует
структура A. Порядок байт: от младшего к старшему. Адреса указаны в виде смещений от начала данных. В решении предлагается использовать
модуль struct.
Структура A:
Поле | Описание |
---|---|
1 | float |
2 | uint64 |
3 | Структура B |
4 | Адрес (uint32) структуры E |
Структура B:
Поле | Описание |
---|---|
1 | Структура C |
2 | uint32 |
Структура C:
Поле | Описание |
---|---|
1 | Массив структур D, размер 2 |
2 | Массив int16, размер 6 |
3 | Массив double, размер 8 |
4 | Массив int8, размер 5 |
5 | uint32 |
Структура D:
Поле | Описание |
---|---|
1 | float |
2 | float |
Структура E:
Поле | Описание |
---|---|
1 | int32 |
2 | uint64 |
3 | int16 |
4 | Массив int16, размер 2 |
5 | uint32 |
6 | uint8 |
7 | uint32 |
Ниже показаны примеры разбора двоичного формата.
Пример 1
Двоичные данные:
b'\x1fMAJI\xf0~\x1c\xbf@\xc0\x11kV\x08g;\x84\xaay>\xcdo|?\x003s\xbf@\x98('
(b'??\xb9\xe7x3\x8c\x9f\xa5v)\x96\xcbv&\xf5\x90\x98\x9b\xe4?\xacQ\x91'
b'\xa8\xdb\xda\xeb\xbf\x86\xe2\xd5.\xd5\x8e\xe1?\x94\x98.\xd8\xd2Q\xdd'
b'\xbf\x98I\xcd{F\xfa\xe1?L\xeb}<nx\xd8\xbf4[\xd1\x12|\xf3\xd2?\xd8\x90\xec'
b'\\I\x87\xd4\xbf@\xfa\xfb\x88\xe7lP\xbf\xb3\x18\xc9\xe8\xea~\x00\x00\x00.\x92'
b'\x985\x8bt\x08l\xf5U\x86\r1\x99\xb7\xb6\xa2\x84\x1f\xb9OX\xe7\xd2\xfaS\xeb')
Результат разбора:
'A1': -0.6113119125366211,
{'A2': 4280399138095480896,
'A3': {'B1': {'C1': [{'D1': 0.24381452798843384, 'D2': 0.9860809445381165},
'D1': -0.9499969482421875, 'D2': 0.6585731506347656}],
{'C2': [-18113, 30951, -29645, -23137, 10614, -13418],
'C3': [0.6439936476901511,
-0.8704660694443667,
0.5486856379275913,
-0.45811911689305274,
0.5618011873250905,
-0.38235050113114677,
0.2961111243979986,
-0.32075723719232263],
'C4': [64, -6, -5, -120, -25],
'C5': 3015659628},
'B2': 3941124376},
'A4': {'E1': 899191342,
'E2': 974560881940133003,
'E3': -26319,
'E4': [-18761, -31582],
'E5': 1481619743,
'E6': 231,
'E7': 3948149458}}
Пример 2
Двоичные данные:
b'\x1fMAJI\xc2\x13:\xbf\xeb\xed\x90\xc2~\xf9\xe6\x00)O\x16?\x9b%y?\xb0\xa6H'
(b'\xbf\xa1Vo?y\xd9)$\xeb\xfd_C\xe4\xd0M\x93\xf2\xaf\xb2I\x15\xa2\xed'
b'\xbf\xc8\x8e\xfa\xf0\xc7r\xd3\xbf\xc0\x06\x9a=\x17\xcc\xbe\xbf\x10\xc8.'
b'\xe2\x19\x87\xcf? \xf9\xbe\xc7\xa2\xd0\xe4\xbf(\xc3|\xad\xa8F\xee'
b'\xbf\xe8\x85\x19\x02\xde\x1a\xda\xbf89\xe4\xcb\xfcc\xee?=\x9abe\xa37\xfe'
b'"\xe80x~\xc9~\x00\x00\x00\xd8N\xb6\xcdP\x1dB\xb4\xd7Y\x80\xce\xb8f@\xf0\xf1t'
b"\xfc\xce\xc4\xc7\xaat'\x97\xa7")
Результат разбора:
'A1': -0.7268639802932739,
{'A2': 65013567468924395,
'A3': {'B1': {'C1': [{'D1': 0.5871453881263733, 'D2': 0.9732300639152527},
'D1': -0.7837934494018555, 'D2': 0.9349156022071838}],
{'C2': [-9863, 9257, -533, 17247, -12060, -27827],
'C3': [-0.9260355414785393,
-0.30388067753868286,
-0.12030167821833526,
0.24631045860365974,
-0.6504682446755261,
-0.9461253536629544,
-0.4078898449425581,
0.9497055036788771],
'C4': [61, -102, 98, 101, -93],
'C5': 3894607415},
'B2': 3380508720},
'A4': {'E1': -843690280,
'E2': 14879991951809191248,
'E3': 26296,
'E4': [-4032, 29937],
'E5': 3351564028,
'E6': 170,
'E7': 2811701108}}
Задача №12
Реализовать разбор двоичного формата данных. Данные начинаются с сигнатуры 0x43 0x51 0x4b 0x4d 0x78
, за которой следует
структура A. Порядок байт: от старшего к младшему. Адреса указаны в виде смещений от начала данных. В решении предлагается использовать
модуль struct.
Структура A:
Поле | Описание |
---|---|
1 | int8 |
2 | Массив char, размер 4 |
3 | Размер (uint16) и адрес (uint16) массива структур B |
4 | Массив uint32, размер 6 |
5 | uint32 |
6 | Структура D |
7 | int16 |
Структура B:
Поле | Описание |
---|---|
1 | Структура C |
2 | int32 |
Структура C:
Поле | Описание |
---|---|
1 | int8 |
2 | Массив float, размер 5 |
3 | float |
Структура D:
Поле | Описание |
---|---|
1 | Размер (uint32) и адрес (uint32) массива int64 |
2 | int8 |
3 | uint64 |
4 | float |
Ниже показаны примеры разбора двоичного формата.
Пример 1
Двоичные данные:
b'CQKMx\xc3efql\x00\x02\x00A\xfb\x1499w\xf6\xbcThz9\x85\xa7\r\xd1\xf8\xdb\x9d'
(b'\xbb\xfb\xb2y\xc7\x0e\xd3\xfb 9\x00\x00\x00\x02\x00\x00\x00{\x1a\xde'
b'\xde\xae\x99N\x97J8\xbfJcN\xca_\xab\xbe\xafg\xd7=\x0e\xa0\xc8>*\x9bU;\xdc'
b'\xddm\xbd(M\xeb?AdM\xcb\xbf\xf0$v=\xa3Mu\xbe\x90\x94)>\x97\x89\xff>\x81K6>'
b'\xa0/v=\x97\x81"T\xed\xect9\x0f\x1aK\'\xc4\x1f)\x05\x16j\xb6\xbcf4s')
Результат разбора:
'A1': -61,
{'A2': 'efql',
'A3': [{'B1': {'C1': -85,
'C2': [-0.3425891101360321,
0.03482130169868469,
0.16660816967487335,
0.006740263197571039,
-0.04108993336558342],
'C3': 0.7554367184638977},
'B2': -876613596},
'B1': {'C1': 118,
{'C2': [0.0797375813126564,
-0.2823803722858429,
0.2959747016429901,
0.2525269389152527,
0.3128620982170105],
'C3': 0.07397677004337311},
'B2': 1424878708}],
'A4': [4212406585, 2012658772, 1752840581, 2802700792, 3684547579, 2994325262],
'A5': 3556450361,
'A6': {'D1': [4111533894904586025, 366597752754680947],
'D2': 26,
'D3': 16059465294721534520,
'D4': -0.79057776927948},
'A7': -13729}
Пример 2
Двоичные данные:
b'CQKMx\xa0kssv\x00\x02\x00AA\x14\x8fp9\x98\x8b\x18\x84\xf1\xfer\x0b\xc8'
(b'\xd3\xfc\x90V\xce\xb8\xa0e21\x82\t\x14\x13\x00\x00\x00\x04\x00\x00\x00{\xca;'
b'M\nH\x9d\xf1\xf5\x1e>\xd7\x1c\x97\xc0d-\xbei7\xf0\xbe;\xa9\xa1\xbe\xbc'
b'\xde6>\\\xdc.>\x07&\x12?{\xbd\xcbo\x97\x91\x10\xfd\xbe\xd5?Q\xbf'
b'(\x05\xf4\xbf]J\x83\xbfCt\x99\xbf\x13t\x17\xbe3\xa9\x80\x9c\x97&{\x936?[y'
b'\xf8U$qf&\xf7H\xf3\xa8\x85\xc6\x1cZ\x86\xaf|\xa7\x98\xd0\x7f\x9d\xea+'
b'\x9c\xc7\xcb')
Результат разбора:
'A1': -96,
{'A2': 'kssv',
'A3': [{'B1': {'C1': 45,
'C2': [-0.2277524471282959,
-0.18326427042484283,
-0.36888283491134644,
0.21568366885185242,
0.13198116421699524],
'C3': 0.9833647608757019},
'B2': 1872204048},
'B1': {'C1': -3,
{'C2': [-0.41649869084358215,
-0.6563408374786377,
-0.8644182085990906,
-0.7634978890419006,
-0.5759901404380798],
'C3': -0.17545127868652344},
'B2': -1667815813}],
'A4': [1091866480, 966298392, 2230451826, 197710844, 2421608120, 2690986545],
'A5': 2181633043,
'A6': {'D1': [-7839008439270877916,
8171261417433049221,
-4171359620335622248,
-3422843562698684469],
'D2': -54,
'D3': 4273082928448271646,
'D4': 0.42013999819755554},
'A7': -16284}
Задача №12
Реализовать разбор двоичного формата данных. Данные начинаются с сигнатуры 0x56 0x4e 0x41 0x4d 0x10
, за которой следует
структура A. Порядок байт: от старшего к младшему. Адреса указаны в виде смещений от начала данных. В решении предлагается использовать
модуль struct.
Структура A:
Поле | Описание |
---|---|
1 | Размер (uint32) и адрес (uint32) массива структур B |
2 | Размер (uint16) и адрес (uint16) массива char |
3 | uint8 |
4 | Структура C |
5 | float |
Структура B:
Поле | Описание |
---|---|
1 | double |
2 | double |
Структура C:
Поле | Описание |
---|---|
1 | Массив uint16, размер 2 |
2 | Адрес (uint32) структуры D |
3 | Массив int8, размер 5 |
4 | uint16 |
5 | double |
6 | uint64 |
7 | int16 |
8 | int64 |
Структура D:
Поле | Описание |
---|---|
1 | int8 |
2 | int8 |
Ниже показаны примеры разбора двоичного формата.
Пример 1
Двоичные данные:
b'VNAM\x10\x00\x00\x00\x02\x00\x00\x00?\x00\x02\x00_\xb7p\xd8?0\x00\x00'
(b'\x00a\x06\xf5DvIH;\xbf\xde\x99\xf5o&\x07\x84\xc8\xdaY\xed\xe4\x97\\'
b'\xd5\xca8\x8d\xfaP\xccY9\xb3\xb5>\xf0\x95\xd6?\xea| EL\xabD?\xdeS\xc3\x98'
b'\xdbC\xfc\xbf\xe2\x18\xf4\xfc\x0b\xa6z\xbf\xdc\x91w\x85\x84\xbcxjwa\xad')
Результат разбора:
'A1': [{'B1': 0.8276521066194182, 'B2': 0.4738625519503896},
{'B1': -0.5655465052379463, 'B2': -0.446378593815957}],
{'A2': 'jw',
'A3': 183,
'A4': {'C1': [28888, 16176],
'C2': {'D1': 97, 'D2': -83},
'C3': [6, -11, 68, 118, 73],
'C4': 18491,
'C5': -0.47814689497328566,
'C6': 14472979230785756373,
'C7': -13768,
'C8': -8216165731583544395},
'A5': 0.4698931574821472}
Пример 2
Двоичные данные:
b'VNAM\x10\x00\x00\x00\x03\x00\x00\x00?\x00\x05\x00o\xc2\xb7\x959\x87\x00\x00'
(b'\x00t>@\xa4\xedyd\\\xbf\xe6cr\xb9S\xc6\xe2*d\xfa$"\xe1S\x91\xa5_\xc2'
b"\xaa3 \xf2w\x13+\xbf'\xc1;?\xe0\x83\xe7\xfd\xa5\xed\xb0?\xd4q\x01~"
b'\x91\xb8\x08?\xe4\xf6\xbb4\x14\x8b\xa4?\xda!Js\xd2\xf7T?\xe5\xf8\x03y'
b'\x85\x7f\xce?\xbe\xf4)9\xfa\xe9\xd0ubsqw\x17p')
Результат разбора:
'A1': [{'B1': 0.5161018327775562, 'B2': 0.31939732895159567},
{'B1': 0.6551185624306197, 'B2': 0.4082819110006899},
{'B1': 0.6865250943628725, 'B2': 0.12091310182123682}],
{'A2': 'ubsqw',
'A3': 194,
'A4': {'C1': [46997, 14727],
'C2': {'D1': 23, 'D2': 112},
'C3': [62, 64, -92, -19, 121],
'C4': 25692,
'C5': -0.6996396655724448,
'C6': 3054841480374997905,
'C7': -23201,
'C8': -4419663867710860501},
'A5': -0.6552922129631042}
Задача №12
Реализовать разбор двоичного формата данных. Данные начинаются с сигнатуры 0x43 0x4a 0x47 0x50
, за которой следует структура
A. Порядок байт: от младшего к старшему. Адреса указаны в виде смещений от начала данных. В решении предлагается использовать модуль
struct.
Структура A:
Поле | Описание |
---|---|
1 | Адрес (uint32) структуры B |
2 | Размер (uint32) и адрес (uint16) массива структур C |
3 | Массив char, размер 5 |
4 | uint8 |
5 | int8 |
6 | Структура D |
7 | float |
8 | int16 |
Структура B:
Поле | Описание |
---|---|
1 | Размер (uint16) и адрес (uint32) массива char |
2 | int32 |
3 | int8 |
Структура C:
Поле | Описание |
---|---|
1 | int32 |
2 | int16 |
3 | double |
4 | uint8 |
Структура D:
Поле | Описание |
---|---|
1 | uint8 |
2 | float |
3 | Размер (uint32) и адрес (uint16) массива int32 |
Ниже показаны примеры разбора двоичного формата.
Пример 1
Двоичные данные:
b'CJGP(\x00\x00\x00\x02\x00\x00\x003\x00zombn\xee\xa0\x1b\x93\xcde\xbf\x05\x00'
(b'\x00\x00Q\x00\xa4\xa0\x1a\xbd\xec^sh\x02\x00&\x00\x00\x00\xb8f\xf3\xc6\xed-'
b"'^\xab\x95\x10<R\xfc>?\xc0\xd2\xbfR\xb1\xcf.t\x03\xa7V\x92\x9a\x81"
b'\n\x1a\xe2\xbf\xce\x8eR\xb6\xd9\xder\xc46p\xdd\xb2\xd454:L\xd2\xac\xadC')
Результат разбора:
'A1': {'B1': 'sh', 'B2': -957126984, 'B3': -19},
{'A2': [{'C1': -1419892947, 'C2': 4245, 'C3': -0.2929838290304223, 'C4': 82},
'C1': 1949224881, 'C2': -22781, 'C3': -0.5656788379024629, 'C4': 206}],
{'A3': 'zombn',
'A4': 238,
'A5': -96,
'A6': {'D1': 27,
'D2': -0.8976680636405945,
'D3': [-642362738, 918844126, -726475408, 1278882869, 1135455442]},
'A7': -0.03775085508823395,
'A8': 24300}
Пример 2
Двоичные данные:
b'CJGP)\x00\x00\x00\x02\x00\x00\x004\x00hfipd\x8cC\x89\xf9NB\xbd\x03\x00'
(b'\x00\x00R\x00\x95h\r?,avtf\x03\x00&\x00\x00\x00>:\xc9\x9eyV\x16Zy'
b'\x9c\xc5\xb0\x84Oq\xa2\xf8\xe4\xbf\x12\xe0\x96\xcfC\x0c\xbb6^\xc3'
b'\x85\xbc\xb3\xec\xbf \x03,t\x08\x89U3\xad%\xe8PR')
Результат разбора:
'A1': {'B1': 'vtf', 'B2': -1630979522, 'B3': 121},
{'A2': [{'C1': 2035947094, 'C2': -14948, 'C3': -0.6553508961771026, 'C4': 18},
'C1': 1137678048, 'C2': -17652, 'C3': -0.8969404804765364, 'C4': 32}],
{'A3': 'hfipd',
'A4': 140,
'A5': 67,
'A6': {'D1': 137,
'D2': -0.047438595443964005,
'D3': [141831171, -1389144695, 1381034021]},
'A7': 0.5523770451545715,
'A8': 24876}
Задача №12
Реализовать разбор двоичного формата данных. Данные начинаются с сигнатуры 0x50 0x53 0x5a 0x9a
, за которой следует структура
A. Порядок байт: от старшего к младшему. Адреса указаны в виде смещений от начала данных. В решении предлагается использовать модуль
struct.
Структура A:
Поле | Описание |
---|---|
1 | Адрес (uint16) структуры B |
2 | Размер (uint16) и адрес (uint16) массива float |
3 | Адрес (uint16) структуры D |
4 | Размер (uint16) и адрес (uint16) массива int64 |
5 | int8 |
Структура B:
Поле | Описание |
---|---|
1 | Массив структур C, размер 3 |
2 | Массив uint32, размер 5 |
Структура C:
Поле | Описание |
---|---|
1 | Массив float, размер 3 |
2 | int8 |
3 | int8 |
Структура D:
Поле | Описание |
---|---|
1 | int32 |
2 | uint8 |
3 | float |
Ниже показаны примеры разбора двоичного формата.
Пример 1
Двоичные данные:
b"PSZ\x9a\x00\x11\x00\x08\x00O\x00o\x00\x02\x00x)?,\xde\x86\xbe\xe1 '=\xdf\xd1"
(b'\x15V$\xbf\x15G\x8a?\x15Ad\xbf4!\x0b\xd3\xea\xbe\xd2\x0e)=$f\xe8\xbc\xf7l'
b'l\xb5$y\x0b\x84s\xa4-j(\xa7^\xdb\xf5\x10Y\xdf\xf7\x83\xb5\xa5\xd3>\x9d*a?'
b'T\xd2P\xbf\x11\x81\x19\xbf\x15\xe0(?u|\xb1>\x1b\xac]>\xbdgb<)\x91\xbd\xe4'
b'v;|\x82\xbe!/J\xf0V\xd5\x1d\xbb\x0cNI\x02\x94,\x12\xa1\x853y')
Результат разбора:
'A1': {'B1': [{'C1': [0.6752704381942749,
{-0.4396984279155731,
0.10928551107645035],
'C2': 86,
'C3': 36},
'C1': [-0.5831228494644165,
{0.58302903175354,
-0.703629195690155],
'C2': -45,
'C3': -22},
'C1': [-0.4102642834186554,
{0.04013720154762268,
-0.030203066766262054],
'C2': -75,
'C3': 36}],
'B2': [2030797939, 2754439720, 2808011765, 274325495, 2209719763]},
'A2': [0.3069639503955841,
0.831334114074707,
-0.5683761239051819,
-0.585451602935791,
0.9589338898658752,
0.15202470123767853,
0.36992937326431274,
0.010349688120186329],
'A3': {'D1': -462013572, 'D2': 130, 'D3': -0.15740695595741272},
'A4': [-1128480332940816823, 185821943159927673],
'A5': 41}
Пример 2
Двоичные данные:
b'PSZ\x9a\x00\x11\x00\x03\x00O\x00[\x00\x02\x00d\x8a\xbf\x01\x17'
(b'\xc8\xbd\xfb\xea,\xbe\xc8o\x90\x84a?o\x9c\x03>\xc9\xe9\x0b\xbe\xe8$v\x11'
b'\xf4\xbfu\xd1\xb7>e\xb1\x00?\x1eX\x1b\xbb\xa2\xe7\x07n\xcd\x1c\\\xfa(\xec'
b'\xba,\x82DJq\x19|\xb3\xf4\xfc\xbe\xa4^\x06?P\xfd\x0c?%f\x87\xcd]\xf5"\xc4'
b'\xbfz\xe6p\x98*\x9a\x830<;\xdd\xe1\xd0\x12\xf60\x0b8"')
Результат разбора:
'A1': {'B1': [{'C1': [-0.5042691230773926,
{-0.12300524115562439,
-0.3914761543273926],
'C2': -124,
'C3': 97},
'C1': [0.9359742999076843,
{0.3943561017513275,
-0.45340317487716675],
'C2': 17,
'C3': -12},
'C1': [-0.9602312445640564,
{0.22430801391601562,
0.6185318827629089],
'C2': -69,
'C3': -94}],
'B2': [3876024013, 475855400, 3971624066, 1145729305, 2092168444]},
'A2': [-0.3210298418998718, 0.8163611888885498, 0.6460956931114197],
'A3': {'D1': -849480414, 'D2': 196, 'D3': -0.9800786972045898},
'A4': [-7481997942682010659, -2175217771442653150],
'A5': -118}