Задача №12
Реализовать разбор двоичного формата данных. Данные начинаются с сигнатуры 0xc9 0x51 0x51 0x56
, за которой следует структура
A. Порядок байт: от младшего к старшему. Адреса указаны в виде смещений от начала данных. В решении предлагается использовать модуль
struct.
Структура A:
Поле | Описание |
---|---|
1 | Структура B |
2 | uint64 |
3 | Размер (uint32) и адрес (uint32) массива char |
4 | Массив структур C, размер 2 |
5 | int16 |
6 | double |
Структура B:
Поле | Описание |
---|---|
1 | int8 |
2 | uint16 |
Структура C:
Поле | Описание |
---|---|
1 | Массив uint64, размер 3 |
2 | Структура D |
Структура D:
Поле | Описание |
---|---|
1 | float |
2 | Массив uint16, размер 7 |
3 | uint32 |
Ниже показаны примеры разбора двоичного формата.
Пример 1
Двоичные данные:
b'\xc9QQV\x8f\x0cPl\x16\x97\xdd\xba\xea\xf7\xf4\x02\x00\x00\x00}\x00\x00\x00i'
(b'\x9b\x189\x13\xb9\x0b\xee\x95-\x9b\x1e\xb0$\xd7\x1a\xe9\xd3\x1d\xd6\x96'
b'A\xe3\xc1q*\x18>\x1c(^;\xdf\x06\xe9\xd3\x94\x8d\x85\x97\xc3\xba\xd2q5B\x94?1'
b'\x19y\x07\x97\x08jX\x84\xa7j\x17ru\x88\xc1\x83\x89\xc5L\xdc\x9d\x7fy\xfd'
b'>P\xbd\xce\xd9\xf8\x05\xf9\xc3\xa7\x8f \x8cl\xfd5\xe2\x02[\xc8\x85\xcc3>'
b't\xd8{\xd2?cq')
Результат разбора:
'A1': {'B1': -113, 'B2': 20492},
{'A2': 17651835352804431468,
'A3': 'cq',
'A4': [{'C1': [17153007097984097129,
1934054903825247637,
13971082585126589417],
'C2': {'D1': 0.14859940111637115,
'D2': [10268, 15198, 1759, 54249, 36244, 38789, 47811],
'D3': 1110798802}},
'C1': [618971690481827732, 8462852396627023978, 11375051170130411912],
{'C2': {'D1': 0.4950675666332245,
'D2': [48464, 55758, 1528, 50169, 36775, 35872, 64876],
'D3': 1526915637}}],
'A5': -31288,
'A6': 0.28880893089154536}
Пример 2
Двоичные данные:
b"\xc9QQV\xec\x80\xadg\xf5\xa2F'\x1dT\xa6\x02\x00\x00\x00}\x00\x00\x00\x08"
(b'2\x11$+u\xaa\x83R0\x14Y\xc1L\xd2\xec\xe8\x16\x80\x94\x9a\x9b\xcbax\xf9x>\xc6'
b'\x91\x18\xe6\x96\x8f*\xdd\x8fv\xaap\xb1/\x81\xf9J\x07\xe6\x15\x03'
b'A\x1d\xbf\x9e\x80\xe0zi\r\xbf\xa8\xb1\x87\xb2\xe6\xe1\x94\xe7\xaa\x15'
b"\xe7N\x9f^?\xb5\xd7\xf0\x1awKJ@\x1162Nx\x0f\xce\x8d@\xad\xdf'\x98~\xfc"
b'\xba\x90+\xda?mw')
Результат разбора:
'A1': {'B1': -20, 'B2': 44416},
{'A2': 11985236562865747303,
'A3': 'mw',
'A4': [{'C1': [9487524393158521352, 17064786331367125074, 7046897130169964264],
'C2': {'D1': 0.2431391477584839,
'D2': [37318, 58904, 36758, 56618, 30351, 28842, 12209],
'D3': 122354049}},
'C1': [9268055215540737510, 9777781804515293920, 16651403108884276914],
{'C2': {'D1': 0.86961829662323,
'D2': [55221, 6896, 19319, 16458, 13841, 20018, 3960],
'D3': 2906688974}}],
'A5': 10207,
'A6': 0.40890901813870917}
Задача №12
Реализовать разбор двоичного формата данных. Данные начинаются с сигнатуры 0x4a 0x42 0x41 0xda
, за которой следует структура
A. Порядок байт: от младшего к старшему. Адреса указаны в виде смещений от начала данных. В решении предлагается использовать модуль
struct.
Структура A:
Поле | Описание |
---|---|
1 | uint64 |
2 | int32 |
3 | Массив адресов (uint16) структур B, размер 4 |
4 | Адрес (uint32) структуры C |
5 | Адрес (uint32) структуры D |
Структура B:
Поле | Описание |
---|---|
1 | int8 |
2 | int32 |
Структура C:
Поле | Описание |
---|---|
1 | uint8 |
2 | Размер (uint16) и адрес (uint32) массива char |
3 | Размер (uint16) и адрес (uint32) массива float |
4 | double |
5 | Размер (uint16) и адрес (uint32) массива int32 |
Структура D:
Поле | Описание |
---|---|
1 | Размер (uint32) и адрес (uint16) массива int8 |
2 | int16 |
3 | uint64 |
Ниже показаны примеры разбора двоичного формата.
Пример 1
Двоичные данные:
b'JBA\xda\xaf\xda\xf9\x13\xd5\xc43J\xf3\x90\xba\xe3 \x00%\x00*\x00/\x00'
(b'V\x00\x00\x00w\x00\x00\x00\x9b\x8e4\x00I2\xd2\x86\x92E\xa9\xd2\x8d\xfd\x8f&'
b"\xa603\xc7sj[\x06s=3*l?c+\xd2>\x03\x1c\x9b>5'u?\xd9\xfbm?9}\x16WhM"
b'\x02\xb8z\x02\x004\x00\x00\x00\x06\x006\x00\x00\x00(\xca\xf75\x7f'
b'\xc0\xc7\xbf\x02\x00N\x00\x00\x00\xde\xe6\xf6\xe3\xa5E\x06\x00\x00\x00q'
b'\x00\xe2\x19\xf0\xeds\x98\x8f\xed\x01<')
Результат разбора:
'A1': 5346833602061130415,
{'A2': -474312461,
'A3': [{'B1': -101, 'B2': 1224750222},
'B1': 50, 'B2': 1167230674},
{'B1': -87, 'B2': -1879208494},
{'B1': 38, 'B2': -952946522}],
{'A4': {'C1': 122,
'C2': 'sj',
'C3': [0.0593322329223156,
0.9225189089775085,
0.41048726439476013,
0.30294808745384216,
0.9576295018196106,
0.9296241402626038],
'C4': -0.18556203971054797,
'C5': [1461091641, -1207808664]},
'A5': {'D1': [-34, -26, -10, -29, -91, 69],
'D2': 6626,
'D3': 4323998318246227440}}
Пример 2
Двоичные данные:
b'JBA\xda\x94\x05k\xba\xa9\x07\xe9\t\x0c!\xd1D \x00%\x00*\x00/\x00'
(b'T\x00\x00\x00t\x00\x00\x00_\xbf\x95\x07`\xd2\x15V\xdf\x93\xbf\x8c\xea\\Jt'
b'W\x7f\x93^bhul4\x9e\x1a\xbf\xa6Nb\xbff\x188>jr:\xbf_[D?\xe4\xebX\x1b'
b'\x1fq%\xd1\xa6\x04\x004\x00\x00\x00\x05\x008\x00\x00\x00p\xb5\xe9\x0c=5\xe5'
b'\xbf\x02\x00L\x00\x00\x00/\x03\xfa\x1dr\x05\x00\x00\x00o\x00\xc0\x88'
b'$\x8a\xdb5\xfcn\x94\x08')
Результат разбора:
'A1': 714110441473377684,
{'A2': 1154556172,
'A3': [{'B1': 95, 'B2': 1611109823},
'B1': -46, 'B2': -1814079979},
{'B1': -65, 'B2': 1247603340},
{'B1': 116, 'B2': 1586724695}],
{'A4': {'C1': 166,
'C2': 'bhul',
'C3': [-0.6039764881134033,
-0.8840125799179077,
0.17978057265281677,
-0.7283083200454712,
0.7670192122459412],
'C4': -0.6627488376813471,
'C5': [458812388, -786075361]},
'A5': {'D1': [47, 3, -6, 29, 114], 'D2': -30528, 'D3': 618241078370994724}}
Задача №12
Реализовать разбор двоичного формата данных. Данные начинаются с сигнатуры 0xdd 0x53 0x4d 0x47 0x51
, за которой следует
структура A. Порядок байт: от младшего к старшему. Адреса указаны в виде смещений от начала данных. В решении предлагается использовать
модуль struct.
Структура A:
Поле | Описание |
---|---|
1 | Размер (uint32) и адрес (uint16) массива char |
2 | uint16 |
3 | double |
4 | Адрес (uint16) структуры B |
5 | uint8 |
6 | uint64 |
7 | Адрес (uint32) структуры D |
8 | uint16 |
Структура B:
Поле | Описание |
---|---|
1 | int64 |
2 | uint16 |
3 | Массив адресов (uint32) структур C, размер 2 |
4 | int32 |
Структура C:
Поле | Описание |
---|---|
1 | int64 |
2 | Размер (uint32) и адрес (uint16) массива uint8 |
Структура D:
Поле | Описание |
---|---|
1 | int32 |
2 | Массив float, размер 4 |
3 | float |
4 | int32 |
Ниже показаны примеры разбора двоичного формата.
Пример 1
Двоичные данные:
b'\xddSMGQ\x02\x00\x00\x00&\x00\x85b\x08\x81\xc4\xed">\xc4\xbfM\x00\xef'
(b'6\x90D\xd1\\6\xc7jc\x00\x00\x00\x01zby\xf5\xc5\x80?\x0f\xbb3\x96'
b'\xb9E\xf5\xb0z\xfa\x06\x00\x00\x00(\x001\xab\xe5\xb3\xf4G%}\x15;\x9f\x03'
b'\x00\x00\x00<\x00\xe4\xa6\x93-\xfdi\x96)\xc8U.\x00\x00\x00?\x00\x00\x00u'
b'4\x03I\xe8A\x07\x8d\xbf\xfb\x07\xbf\xa7\xae%\xbf\xbe0r?Y&m\xbf&\x14z?P'
b'\xda\x0e\xe6')
Результат разбора:
'A1': 'by',
{'A2': 25221,
'A3': -0.15814625367875856,
'A4': {'B1': 2996699138173937380,
'B2': 21960,
'B3': [{'C1': -397811049585600973, 'C2': [245, 197, 128, 63, 15, 187]},
'C1': -6972955970812513101, 'C2': [49, 171, 229]}],
{'B4': 1224946805},
'A5': 239,
'A6': 7694178260661604406,
'A7': {'D1': -1928904216,
'D2': [-0.5311850905418396,
-0.6471962332725525,
0.9460562467575073,
-0.92636638879776],
'D3': 0.9768699407577515,
'D4': -435234224},
'A8': 31233}
Пример 2
Двоичные данные:
b'\xddSMGQ\x02\x00\x00\x00&\x00\xb8\xe7\x88\x03\xd3\xed\xb4b\xe9?N\x00\xcc'
(b'\xe1\xc8\x92?S\x96\xb4\x13d\x00\x00\x00\xf1Inb\x97\x0c<\x06\x04\x95T\x1e'
b'\xb2Q\xc4\xe6\xff\x05\x00\x00\x00(\x002\x9c\x97`\xd3X\xd9\xec\xe7'
b'\x1b\xe8\x82\xfa\x05\x00\x00\x00;\x00\xc5G\x01\xb2\x89\x02\xbca\xbeo'
b"-\x00\x00\x00@\x00\x00\x00\xb6R\xabM\x9f\xe6\x1e}\x95rE\xbf'9\x06\xbf"
b'\x18\x80g?\xe1v\x86\xbeK\x7f\xe7>_\x03]\x9a')
Результат разбора:
'A1': 'nb',
{'A2': 59320,
'A3': 0.7932991642957044,
'A4': {'B1': 7042506707720816581,
'B2': 28606,
'B3': [{'C1': -7102494234749803, 'C2': [151, 12, 60, 6, 4]},
'C1': -395498610702362280, 'C2': [50, 156, 151, 96, 211]}],
{'B4': 1303073462},
'A5': 204,
'A6': 1419925066821585121,
'A7': {'D1': 2099177119,
'D2': [-0.7712796330451965,
-0.5243095755577087,
0.9042983055114746,
-0.26262572407722473],
'D3': 0.4521430432796478,
'D4': -1705180321},
'A8': 18929}
Задача №12
Реализовать разбор двоичного формата данных. Данные начинаются с сигнатуры 0x54 0x41 0x56 0x4c 0x55
, за которой следует
структура A. Порядок байт: от старшего к младшему. Адреса указаны в виде смещений от начала данных. В решении предлагается использовать
модуль struct.
Структура A:
Поле | Описание |
---|---|
1 | Массив структур B, размер 2 |
2 | Адрес (uint16) структуры C |
3 | int32 |
4 | uint16 |
5 | double |
Структура B:
Поле | Описание |
---|---|
1 | uint32 |
2 | Массив char, размер 8 |
3 | uint8 |
Структура C:
Поле | Описание |
---|---|
1 | int16 |
2 | Структура D |
3 | Массив uint16, размер 2 |
4 | int16 |
Структура D:
Поле | Описание |
---|---|
1 | float |
2 | Массив uint32, размер 4 |
3 | uint8 |
4 | uint32 |
5 | uint8 |
6 | float |
7 | uint8 |
8 | int16 |
Ниже показаны примеры разбора двоичного формата.
Пример 1
Двоичные данные:
b'TAVLU\x95\xc4\xd4!inkwzgxs\xdb\x11\xdd*Yzgtflcxd\xc6\x00/\xb9Dp\xf0=\xea\xbf'
(b'\xb8g\xba\xfa\x03\xd4`\xc2f\xbf\x1b\xb0Q\x00\x14\xea7\xf9\x16\x83'
b'%\x9d\xee\x12]\x9b\xed\xb4A\xc8T\xf1H\xad}?Z\x03\x16G\x9f\xeb_\xa2'
b'\x00\xb8\x93\xbb')
Результат разбора:
'A1': [{'B1': 2512704545, 'B2': 'inkwzgxs', 'B3': 219},
{'B1': 299706969, 'B2': 'zgtflcxd', 'B3': 198}],
{'A2': {'C1': -15770,
'C2': {'D1': -0.6081591248512268,
'D2': [1370679, 4179002149, 2649625181, 2616046657],
'D3': 200,
'D4': 1425098925,
'D5': 125,
'D6': 0.8516095876693726,
'D7': 71,
'D8': -24597},
'C3': [24482, 184],
'C4': -27717},
'A3': -1186696976,
'A4': 15850,
'A5': -0.09533279994850963}
Пример 2
Двоичные данные:
b'TAVLU\xbav0\x1ctueethie\xe0\xcbRy\xe7jvftwlnt\n\x00/F\xa2\x88Z\xb2e?'
(b'\xd2\x12\xabf,A\xc0\xbc\xe1\xbe\x0e\xb2\xbaS\xb2uAf\xfc\x14\xa8|\xc4K'
b'A\x94\xf3\\\xbb\xc1\xe6cr3^>\xd4GQ@\x8ap\t0\x0e\x00\xff\x9c')
Результат разбора:
'A1': [{'B1': 3128307740, 'B2': 'tueethie', 'B3': 224},
{'B1': 3411180007, 'B2': 'jvftwlnt', 'B3': 10}],
{'A2': {'C1': -17183,
'C2': {'D1': -0.1393536627292633,
'D2': [1404204353, 1727796392, 2093239105, 2498976955],
'D3': 193,
'D4': 3865276979,
'D5': 94,
'D6': 0.41460660099983215,
'D7': 64,
'D8': -30096},
'C3': [2352, 3584],
'C4': -100},
'A3': 1185056858,
'A4': 45669,
'A5': 0.2823894975454344}
Задача №12
Реализовать разбор двоичного формата данных. Данные начинаются с сигнатуры 0x56 0x4a 0x4b 0x4f
, за которой следует структура
A. Порядок байт: от младшего к старшему. Адреса указаны в виде смещений от начала данных. В решении предлагается использовать модуль
struct.
Структура A:
Поле | Описание |
---|---|
1 | uint16 |
2 | Структура B |
3 | Адрес (uint16) структуры D |
4 | uint32 |
5 | int16 |
6 | Размер (uint16) и адрес (uint32) массива uint16 |
7 | float |
8 | double |
Структура B:
Поле | Описание |
---|---|
1 | Массив структур C, размер 3 |
2 | uint64 |
3 | Массив int8, размер 4 |
4 | uint32 |
Структура C:
Поле | Описание |
---|---|
1 | int32 |
2 | uint16 |
Структура D:
Поле | Описание |
---|---|
1 | uint16 |
2 | Размер (uint32) и адрес (uint32) массива uint16 |
3 | uint64 |
4 | int32 |
5 | Адрес (uint32) структуры E |
Структура E:
Поле | Описание |
---|---|
1 | uint64 |
2 | uint32 |
3 | int64 |
4 | int16 |
5 | Массив int8, размер 2 |
6 | float |
7 | int64 |
Ниже показаны примеры разбора двоичного формата.
Пример 1
Двоичные данные:
b'VJKO\xda\xca\no\xd8\xc8(O\x97\x08f\x0f\xf3D\x00!b\xf42\xee\xe1\xd8g\xea'
(b'\x1avj\x8aj[\x0b\xe9\x0c\xc4mYn\x00<p8\xd9\x97\xb0\x02\x00\x88\x00'
b'\x00\x00\xc3\xcd\x0b?\x14\xd7\x05Y\x85\x8e\xd1\xbf\x917\xa0\x95\x1aE'
b'E\xb7\x111\\\xf9=\xb8\xcd\xe3\xc7\xd3\xdb\xf0\x0e\xfb_\xa2li\x94\x1a\xb06'
b'\xe20\x94\x04\xcf>\xf6\xa8\x10R\n\xd3\x05\xb2Z\x0f\x04\x00\x00\x00'
b'B\x00\x00\x00\xb4\x04\xfc\xe9R\xe8\x0fU\xc1\x0b\xbe\x00J\x00\x00\x00'
b'\xc9\x81S\xf1')
Результат разбора:
'A1': 51930,
{'A2': {'B1': [{'C1': -925339894, 'C2': 20264},
'C1': 258345111, 'C2': 17651},
{'C1': -194895616, 'C2': 60978}],
{'B2': 9973914182739286241,
'B3': [106, 91, 11, -23],
'B4': 1500365836},
'A3': {'D1': 3930,
'D2': [14225, 38304, 17690, 46917],
'D3': 6129373060685104308,
'D4': 12454849,
'D5': {'E1': 16414978793151410449,
'E2': 4040938439,
'E3': 1915271656840887054,
'E4': 14000,
'E5': [-30, 48],
'E6': 0.4043318033218384,
'E7': -5618852918794868490}},
'A4': 3644354620,
'A5': -20329,
'A6': [33225, 61779],
'A7': 0.5461084246635437,
'A8': -0.274323784767476}
Пример 2
Двоичные данные:
b"VJKO\xa7\x1fx\x01\xfd\xe3\x1f\xd5Dr\x96M'Y\xc6a}z\xff_\xb7\xa4A{"
(b'\xdd\x8c[\x0b~t\x87"\xc2g\x9f\x7fp\x00\xd6\x90A\xc5!\x0b\x03\x00\x8a\x00'
b'\x00\x00\x04y"\xbf \x95\xdf\xbc\'&\xb4?\xaaw\xb6\x8f\xd0\x0b\x14f@\x9a'
b'\xbf\xd4hg\xc0\xe06H_cm\xa3\x9cX\n\x95\x81I\xc5[\x8a\xa2\xe3\x17'
b'\xb3\x90\x7f? \x99\xa4\xbf\x7fR\xc9\xc6\x9d\xc6\x05\x00\x00\x00B\x00'
b'\x00\x00\x98l\xb3\x02\xc0}\xbe\x8b\x00}\xf5,L\x00\x00\x00C{\xb5\x08:~')
Результат разбора:
'A1': 8103,
{'A2': {'B1': [{'C1': -469958280, 'C2': 54559},
'C1': 1301705284, 'C2': 22823},
{'C1': 2055037382, 'C2': 24575}],
{'B2': 818402640181437623,
'B3': [126, 116, -121, 34],
'B4': 2141153218},
'A3': {'D1': 50845,
'D2': [30634, 36790, 3024, 26132, 39488],
'D3': 10069624080479513752,
'D4': 754285824,
'D5': {'E1': 5203593536446452927,
'E2': 2741855071,
'E3': 6612772448763533468,
'E4': -23926,
'E5': [-29, 23],
'E6': 0.9983016848564148,
'E7': -4122673275251418848}},
'A4': 3309408470,
'A5': 2849,
'A6': [31555, 2229, 32314],
'A7': -0.6346590518951416,
'A8': 0.07870720254102936}
Задача №12
Реализовать разбор двоичного формата данных. Данные начинаются с сигнатуры 0x46 0x4d 0x47 0x52
, за которой следует структура
A. Порядок байт: от младшего к старшему. Адреса указаны в виде смещений от начала данных. В решении предлагается использовать модуль
struct.
Структура A:
Поле | Описание |
---|---|
1 | Размер (uint32) и адрес (uint16) массива адресов (uint32) структур B |
2 | Массив char, размер 7 |
3 | uint32 |
4 | int32 |
5 | Адрес (uint32) структуры C |
6 | Массив char, размер 7 |
7 | Структура D |
Структура B:
Поле | Описание |
---|---|
1 | uint16 |
2 | uint16 |
Структура C:
Поле | Описание |
---|---|
1 | int64 |
2 | int32 |
3 | int64 |
4 | int32 |
Структура D:
Поле | Описание |
---|---|
1 | Массив int16, размер 3 |
2 | double |
Ниже показаны примеры разбора двоичного формата.
Пример 1
Двоичные данные:
b'FMGR\x07\x00\x00\x00N\x00hdabcfl\xcdI>^\x85\x10\x9bCj\x00\x00\x00zvbqqdk'
(b'#7\x1c\x19\xb2\xc8\xacdFN\xc2\x9d\xd3\xbf\xad\x1btj\x91\x14\xc3\x9b!\t'
b'\x19\x19Z,\xb8I\xdd\xdb\xb5\x13\xb7\xd1\xd4T$\xe4h\x8a2\x00\x00\x006\x00'
b'\x00\x00:\x00\x00\x00>\x00\x00\x00B\x00\x00\x00F\x00\x00\x00J\x00'
b'\x00\x00\x01\x12\xeaTP\xaasy1\xb3?a^\x934r\xaas\x95\x9a\x88q\x8dt')
Результат разбора:
'A1': [{'B1': 7085, 'B2': 27252},
{'B1': 5265, 'B2': 39875},
{'B1': 2337, 'B2': 6425},
{'B1': 11354, 'B2': 18872},
{'B1': 56285, 'B2': 5045},
{'B1': 53687, 'B2': 21716},
{'B1': 58404, 'B2': 35432}],
{'A2': 'hdabcfl',
'A3': 1581140429,
'A4': 1134235781,
'A5': {'C1': 8751525762909737473,
'C2': 1631564593,
'C3': -7307807644441078946,
'C4': 1955426696},
'A6': 'zvbqqdk',
'A7': {'D1': [14115, 6428, -14158], 'D2': -0.3065038456348457}}
Пример 2
Двоичные данные:
b'FMGR\x03\x00\x00\x00>\x00suibfuie\x05\x84\x0f\xf5\xb4A(J\x00\x00\x00upgzwvi'
(b'\xbdv\x01\xbbZ\xa0l\x064GW\x83\xe8\xbf\x03iz\xba\x1b\x07lZ\xba\xb7_\x162\x00'
b'\x00\x006\x00\x00\x00:\x00\x00\x00\xe6\xe1\xd1\xf1$R\x7f\xdfGI\x14G\x80\xd6'
b'\x8b\xd4\x1a\xa7\xef\xbd\n\x86\x0f\x9f')
Результат разбора:
'A1': [{'B1': 26883, 'B2': 47738},
{'B1': 1819, 'B2': 23148},
{'B1': 47034, 'B2': 5727}],
{'A2': 'suibfui',
'A3': 260310373,
'A4': 675394805,
'A5': {'C1': -2342062962580004378,
'C2': 1192511815,
'C3': -4760402547430402432,
'C4': -1626372598},
'A6': 'upgzwvi',
'A7': {'D1': [30397, -17663, -24486], 'D2': -0.7660328283966016}}
Задача №12
Реализовать разбор двоичного формата данных. Данные начинаются с сигнатуры 0x58 0x4a 0x4b 0x49 0x5c
, за которой следует
структура A. Порядок байт: от младшего к старшему. Адреса указаны в виде смещений от начала данных. В решении предлагается использовать
модуль struct.
Структура A:
Поле | Описание |
---|---|
1 | Адрес (uint32) структуры B |
2 | Адрес (uint16) структуры D |
3 | Структура E |
Структура B:
Поле | Описание |
---|---|
1 | Массив char, размер 6 |
2 | Массив адресов (uint16) структур C, размер 4 |
3 | double |
4 | int8 |
5 | int32 |
Структура C:
Поле | Описание |
---|---|
1 | int8 |
2 | uint8 |
Структура D:
Поле | Описание |
---|---|
1 | Массив int16, размер 5 |
2 | float |
3 | Массив int32, размер 4 |
Структура E:
Поле | Описание |
---|---|
1 | int32 |
2 | Размер (uint16) и адрес (uint32) массива uint32 |
3 | int16 |
4 | uint32 |
5 | float |
Ниже показаны примеры разбора двоичного формата.
Пример 1
Двоичные данные:
b"XJKI\\'\x00\x00\x00B\x00\x89\xb1\xb8\x08\x07\x00`\x00\x00\x00\xa1\xb9\x94"
(b'\xd8\x80\xe8x\x86\xec=Z\xe6\x18*t\n\xff\xd2tdbpkj\x1f\x00!\x00#\x00%'
b'\x00\x8c\x03\xc5,\xd5\xe5\xee\xbfT&\xc8\xd1\xea\x90H\x85\xeb\x0e\x00'
b'\xcb\xc0\x18\xd3\xc5\x97!?\xf2\x8b\x1bs\x81dl\x91\x00\x13m\x01.\x10\xaeT'
b'4;\xd7\xf8\xb0X\x90\x0e\xbe\x0f\xeaV\xd6(\x93\x9b(e\x16\x00\x99\x0f\xbe\xed'
b'LN\xe6\xbe')
Результат разбора:
'A1': {'B1': 'tdbpkj',
{'B2': [{'C1': 90, 'C2': 230},
'C1': 24, 'C2': 42},
{'C1': 116, 'C2': 10},
{'C1': -1, 'C2': 210}],
{'B3': -0.9655557512670483,
'B4': 84,
'B5': -355350490},
'A2': {'D1': [18576, -5243, 14, -16181, -11496],
'D2': 0.6312220692634583,
'D3': [1931185138, -1855167359, 23925504, 1420693550]},
'A3': {'E1': 146321801,
'E2': [4174854964,
244340912,
1458180030,
2610112726,
1467688,
3988656025,
3202764364],
'E3': -18015,
'E4': 3900758164,
'E5': 0.1154908537864685}}
Пример 2
Двоичные данные:
b"XJKI\\'\x00\x00\x00B\x00\xbf\x00,j\x07\x00`\x00\x00\x00\x83>\x8a-SW\xa0"
(b'}\xd3\xbe \xee\xd3bp3>\x99anmudq\x1f\x00!\x00#\x00%\x00\xd0-\x12\x10SY\xb9'
b'?\xee\xa87\x7f~2\xb6*\xbaVU\xac\x1e\xe5\xf7>\xb8\xcd\xbe\xc3\xdf\x17\x11'
b'\xf8*\x91`\xbf&\xc1Bk\xe6\xc3\xf2\xe0\x8a\xb2\x0f\xc8\xa2%0\xc7\x9b\xf3\x96'
b'4C\\\xa8\xdc3\x96\xc4\x9fdDE{\x84\xe1\xb7')
Результат разбора:
'A1': {'B1': 'anmudq',
{'B2': [{'C1': 32, 'C2': 238},
'C1': -45, 'C2': 98},
{'C1': 112, 'C2': 51},
{'C1': 62, 'C2': 153}],
{'B3': 0.09901923315390282,
'B4': -18,
'B5': 2122266536},
'A2': {'D1': [-18894, -17878, 21846, 7852, -2075],
'D2': -0.40179628133773804,
'D3': [286777283, 1620126456, 1119954623, -222042517]},
'A3': {'E1': 1781268671,
'E2': [263359200,
807772872,
2532547527,
2824618804,
3298178012,
1162110111,
3085010043],
'E3': 16003,
'E4': 1465068938,
'E5': -0.4130678176879883}}
Задача №12
Реализовать разбор двоичного формата данных. Данные начинаются с сигнатуры 0x52 0x41 0x46 0x46 0xf
, за которой следует
структура A. Порядок байт: от старшего к младшему. Адреса указаны в виде смещений от начала данных. В решении предлагается использовать
модуль struct.
Структура A:
Поле | Описание |
---|---|
1 | Массив адресов (uint32) структур B, размер 7 |
2 | uint32 |
3 | Структура C |
4 | Структура D |
Структура B:
Поле | Описание |
---|---|
1 | Размер (uint16) и адрес (uint16) массива char |
2 | uint64 |
Структура C:
Поле | Описание |
---|---|
1 | uint8 |
2 | uint32 |
3 | uint64 |
4 | Размер (uint32) и адрес (uint16) массива uint8 |
5 | int32 |
6 | uint64 |
7 | int8 |
8 | Размер (uint16) и адрес (uint32) массива int8 |
Структура D:
Поле | Описание |
---|---|
1 | uint32 |
2 | uint32 |
3 | Массив uint64, размер 2 |
Ниже показаны примеры разбора двоичного формата.
Пример 1
Двоичные данные:
b'RAFF\x0f\x00\x00\x00e\x00\x00\x00t\x00\x00\x00\x82\x00\x00\x00'
(b'\x90\x00\x00\x00\xa0\x00\x00\x00\xaf\x00\x00\x00\xbe-\x88T-\xaes\x8a!TEc'
b'\xa6\xfa1WK\x91\x00\x00\x00\x03\x00\xca\xb2\x0e\xe0~\xd8M\x1b\x96\xdf\t\xb3n'
b'\xd1\x00\x02\x00\x00\x00\xcdp\xd57?i\x0f&\xc6\x8e\xea\x82\xd1\xa0'
b'P\x11\xe5\xc1\xa3\x9d @\x81\x98gyp\x00\x02\x00ct\xf8\xf7\xce\xef\xd0\xf2'
b'\xc8gpq\x00\x03\x00q]\xe0\xa4\x91{\xc6\xe5Xdb\x00\x02\x00\x80,1\xb3y\x87\xe9'
b'\x9f\x06ur\x00\x02\x00\x8e\xde\xd0\x88]6\x19\xfa\xd9tewl\x00\x04\x00\x9c'
b'\x10>C\n\x8b\xe4\xdb\xadfos\x00\x03\x00\xac\xc8\xeb\xfcI\x08d6!ksd\x00\x03'
b'\x00\xbb\xb5\xb2\xf4=\xb0\x13\xe3xY\x08\x8f\xd9\xab')
Результат разбора:
'A1': [{'B1': 'yp', 'B2': 8428759170782655176},
{'B1': 'gpq', 'B2': 6764587585064330584},
{'B1': 'db', 'B2': 3184523746080300806},
{'B1': 'ur', 'B2': 16055482605496826585},
{'B1': 'tewl', 'B2': 1170446665738673069},
{'B1': 'fos', 'B2': 14477942817716188705},
{'B1': 'ksd', 'B2': 13092795612503729016}],
{'A2': 763909165,
'A3': {'C1': 174,
'C2': 1938432340,
'C3': 5000023604811221905,
'C4': [89, 8, 143],
'C5': -1307647874,
'C6': 15586144220200153966,
'C7': -47,
'C8': [-39, -85]},
'A4': {'D1': 1893021503,
'D2': 1762600646,
'D3': [10298187334785438181, 13953168832370677863]}}
Пример 2
Двоичные данные:
b'RAFF\x0f\x00\x00\x00e\x00\x00\x00t\x00\x00\x00\x83\x00\x00\x00'
(b'\x91\x00\x00\x00\xa0\x00\x00\x00\xb0\x00\x00\x00\xbe\xeb\x01aPp\xb7R'
b"\xc0\xfcJ\x80i:\xcb\x1d\xf0~\x00\x00\x00\x04\x00\xca2\xb4%\xc5\x10\x1dN'"
b'\x87\xc1\xd8/\xff\x00\x03\x00\x00\x00\xce\x80`\xcf\x0bG\x12\x86\xaeQ'
b'd\xb0\xd4.C\x86"\xfeL\xdew7\xa1\xf3\x1dbs\x00\x02\x00c \xdb\xd5\xaf\xf2\x97#'
b'\x87xxg\x00\x03\x00q\x9b\xcf\xe6\xb8\x10\xfe\xd3zsmv\x00\x03\x00\x80jMj].'
b'\xd5\x95\x8azo\x00\x02\x00\x8f\xbe\xc4\xc8T\xab\xfa\x9a\xc6kfi'
b'\x00\x03\x00\x9d\xda\xa95\xfb\xa0\x86\xa53ffnu\x00\x04\x00\xacv\x0e\xa8w'
b'\xcc\xa4|/zh\x00\x02\x00\xbcv7\x8fO\xec\xd0%N\xe4C\xee\r\xc1p1')
Результат разбора:
'A1': [{'B1': 'bs', 'B2': 2367720980779312007},
{'B1': 'xxg', 'B2': 11227446074291442554},
{'B1': 'smv', 'B2': 7659895489677333898},
{'B1': 'zo', 'B2': 13746332228629732038},
{'B1': 'kfi', 'B2': 15756184126178633011},
{'B1': 'ffnu', 'B2': 8506921978637351983},
{'B1': 'zh', 'B2': 8518434793632834894}],
{'A2': 3942736208,
'A3': {'C1': 112,
'C2': 3075653884,
'C3': 5368406457062387838,
'C4': [228, 67, 238, 13],
'C5': 850666949,
'C6': 1161170210619775023,
'C7': -1,
'C8': [-63, 112, 49]},
'A4': {'D1': 2153828107,
'D2': 1192396462,
'D3': [5865007040098960930, 18324265587479540509]}}
Задача №12
Реализовать разбор двоичного формата данных. Данные начинаются с сигнатуры 0x43 0x41 0x4f
, за которой следует структура A.
Порядок байт: от младшего к старшему. Адреса указаны в виде смещений от начала данных. В решении предлагается использовать модуль
struct.
Структура A:
Поле | Описание |
---|---|
1 | uint64 |
2 | Структура B |
3 | uint8 |
4 | Размер (uint32) и адрес (uint32) массива адресов (uint32) структур C |
Структура B:
Поле | Описание |
---|---|
1 | Размер (uint32) и адрес (uint32) массива char |
2 | int16 |
3 | int8 |
Структура C:
Поле | Описание |
---|---|
1 | Структура D |
2 | uint64 |
3 | Размер (uint16) и адрес (uint32) массива uint32 |
4 | uint8 |
5 | int8 |
6 | uint16 |
Структура D:
Поле | Описание |
---|---|
1 | double |
2 | Размер (uint16) и адрес (uint16) массива int8 |
Ниже показаны примеры разбора двоичного формата.
Пример 1
Двоичные данные:
b'CAO\x94\x0c\xe9\x9d\xd0\xc4/\xfb\x02\x00\x00\x00\x1f\x00\x00\x00\xad'
(b'h:\xb1\x02\x00\x00\x00{\x00\x00\x00xbJ|k~\xe4\xbe\x9bfV\x8d\x7f\x1d\xfa\xe4A'
b'\xf8\x0f\xf9\xe4?\x04\x00!\x00\x942\xca:\xac\xa8\xb7\xbb\x02\x00%'
b'\x00\x00\x00\x90\xbe\xbc\x81\n\x00\xcc\xdcR\x1b<k\xa5\xf9\xd8\x98\xe3t)K\xb6'
b'\x00X\xe9V\xd7{\xb5\xce\xbf\x06\x00K\x00\x1a\x1dN\x92\xf6\xa5\xc4'
b'\x1c\x03\x00Q\x00\x00\x00\n\xedE\xbc-\x00\x00\x00]\x00\x00\x00')
Результат разбора:
'A1': 18099901827706850452,
{'A2': {'B1': 'xb', 'B2': 26797, 'B3': 58},
'A3': 177,
'A4': [{'C1': {'D1': 0.6554031227853152, 'D2': [74, 124, 107, 126]},
'C2': 13526465463504745108,
'C3': [1721482980, 494898518],
'C4': 144,
'C5': -66,
'C6': 33212},
'C1': {'D1': -0.2399134446585076, 'D2': [10, 0, -52, -36, 82, 27]},
{'C2': 2072964206932401434,
'C3': [4188367676, 1961072856, 11946793],
'C4': 10,
'C5': -19,
'C6': 48197}]}
Пример 2
Двоичные данные:
b'CAO\x1f\n\x1c\x04\xd3\x17\xccD\x04\x00\x00\x00\x1f\x00\x00\x00\xb7'
(b'\x87\xbc3\x02\x00\x00\x00\x80\x00\x00\x00jura:\x9b^M\x84Fmw\x07\x80AR~'
b'\tb\xb0G\xb2\x90\x99\xe6?\x06\x00#\x00\x17j\x8f\xaf\xc6<G>\x02\x00)'
b'\x00\x00\x00\xd2\x8f\x018u-\xc0z\xc8\x83\xf7bA$\xb4\xd3\x8b6\x16\xd6\xd2'
b'\xee\xb1T\xcc\x0f\xf8\xefA\xe3?\x03\x00O\x00\x9c\xd6\xae\x11X\xed'
b'9\xec\x04\x00R\x00\x00\x00+V@\xc11\x00\x00\x00b\x00\x00\x00')
Результат разбора:
'A1': 4957363484902558239,
{'A2': {'B1': 'jura', 'B2': -30793, 'B3': -68},
'A3': 51,
'A4': [{'C1': {'D1': 0.7062457544357239, 'D2': [58, -101, 94, 77, -124, 70]},
'C2': 4487622377744591383,
'C3': [2147972973, 159273537],
'C4': 210,
'C5': -113,
'C6': 14337},
'C1': {'D1': 0.6017989964442543, 'D2': [117, 45, -64]},
{'C2': 17021897229133076124,
'C3': [4152608890, 3022274914, 372673491, 2985218774],
'C4': 43,
'C5': 86,
'C6': 49472}]}
Задача №12
Реализовать разбор двоичного формата данных. Данные начинаются с сигнатуры 0x4b 0x4e 0x55 0x4b
, за которой следует структура
A. Порядок байт: от старшего к младшему. Адреса указаны в виде смещений от начала данных. В решении предлагается использовать модуль
struct.
Структура A:
Поле | Описание |
---|---|
1 | uint8 |
2 | int16 |
3 | Структура B |
4 | int32 |
5 | Структура C |
6 | uint16 |
Структура B:
Поле | Описание |
---|---|
1 | int64 |
2 | uint8 |
3 | int8 |
4 | double |
5 | Размер (uint16) и адрес (uint32) массива char |
6 | uint8 |
Структура C:
Поле | Описание |
---|---|
1 | uint32 |
2 | int16 |
3 | Массив структур D, размер 3 |
4 | Размер (uint32) и адрес (uint16) массива uint64 |
Структура D:
Поле | Описание |
---|---|
1 | double |
2 | float |
3 | Массив int8, размер 2 |
Ниже показаны примеры разбора двоичного формата.
Пример 1
Двоичные данные:
b"KNUK\xf5'\x84\xbf\x9b^\xb9\xf4\x07\xa9\xc4\x8c\x07\xbf\xe4\xad\xcdPNq"
(b'\x14\x00\x03\x00\x00\x00\\\x8dnf\x8d?}\xf8\xd0e\x03\xbd?\xa9S\xd9=\xf8'
b'\xc1\xe0\xbd\x80\xbb\x16\xcf\x02?\xee\xdd\xffb_k\xa2\xbfn\xb8\x8a\xf6??\xac'
b'\x8bx\x0e\xa7\x9d@<Qq\xadu{\x00\x00\x00\x06\x00_\x12$uvq\x8f\xa84\xd5H'
b't\xf6\x07\xb8PS\x9e\xcea\xe9\xc8\x1a?jE\xbb-t\xbfr\xfa$w\xe2!\xee\xd7I'
b'\xba\xcc\xac\xc9\x9b\xda\x0b\x8a=\x01\x17b\xa1\x82\x85')
Результат разбора:
'A1': 245,
{'A2': 10116,
'A3': {'B1': -4640010838319060540,
'B2': 140,
'B3': 7,
'B4': -0.6462160652622821,
'B5': 'uvq',
'B6': 141},
'A4': 1852214591,
'A5': {'C1': 2113458277,
'C2': 957,
'C3': [{'D1': 0.049467839064508246,
'D2': -0.06285683810710907,
'D3': [-49, 2]},
'D1': 0.9645993157713415,
{'D2': -0.932503342628479,
'D3': [-10, 63]},
'D1': 0.05575156382456692,
{'D2': 0.012783450074493885,
'D3': [117, 123]}],
'C4': [10351581834159388167,
13281207242648054216,
1891347216244503743,
8284974561815031511,
5312783752925796875,
9961119150764032645]},
'A6': 4644}
Пример 2
Двоичные данные:
b'KNUKg\x10\x84d\x89\xd2\x81\\UCC\x1a\xa4?\xdb\xab\x97\x02\x83\xb1'
(b'p\x00\x02\x00\x00\x00\\\xd4\xcfF+\xf9\xba\xab\xfc\xc0\xc5\xbf?\xeb\xe2\x9ea='
b'=d>\x85\xd5\x00!H?\xe9\x95\xb2O5,V\xbf\\\xae\x0f\xc2\x9c\xbf\xee'
b'\xe3(\xdc\x11\xa6\xde>\\\xb5D\xdaO\x00\x00\x00\x02\x00^<\x9cjygI}q\xa6l'
b'\xa3\x0f\xd6\x8b\x8c\xdd\r\x93\xd0\xb2')
Результат разбора:
'A1': 103,
{'A2': 4228,
'A3': {'B1': 7244552928643859267,
'B2': 26,
'B3': -92,
'B4': 0.43234801526593625,
'B5': 'jy',
'B6': 212},
'A4': -817484807,
'A5': {'C1': 3131833536,
'C2': -14913,
'C3': [{'D1': 0.8714134120181538,
'D2': 0.26139068603515625,
'D3': [33, 72]},
'D1': 0.7995235011125128,
{'D2': -0.8620309233665466,
'D3': [-62, -100]},
'D1': -0.9652294443341949,
{'D2': 0.2155352234840393,
'D3': [-38, 79]}],
'C4': [7442617786283369231, 15459605026922811570]},
'A6': 15516}
Задача №12
Реализовать разбор двоичного формата данных. Данные начинаются с сигнатуры 0x79 0x47 0x58 0x5a 0x53
, за которой следует
структура A. Порядок байт: от младшего к старшему. Адреса указаны в виде смещений от начала данных. В решении предлагается использовать
модуль struct.
Структура A:
Поле | Описание |
---|---|
1 | int8 |
2 | Адрес (uint16) структуры B |
3 | uint64 |
4 | float |
5 | Адрес (uint16) структуры E |
6 | uint8 |
7 | uint8 |
Структура B:
Поле | Описание |
---|---|
1 | Размер (uint16) и адрес (uint32) массива адресов (uint32) структур C |
2 | Размер (uint32) и адрес (uint32) массива char |
3 | int16 |
4 | int32 |
Структура C:
Поле | Описание |
---|---|
1 | int16 |
2 | uint64 |
3 | int32 |
4 | Адрес (uint16) структуры D |
5 | uint16 |
Структура D:
Поле | Описание |
---|---|
1 | uint8 |
2 | uint32 |
Структура E:
Поле | Описание |
---|---|
1 | uint32 |
2 | Адрес (uint16) структуры F |
3 | Размер (uint32) и адрес (uint32) массива int8 |
Структура F:
Поле | Описание |
---|---|
1 | double |
2 | Массив uint16, размер 7 |
3 | float |
Ниже показаны примеры разбора двоичного формата.
Пример 1
Двоичные данные:
b'yGXZSbQ\x00\xa5qIQ\xc7\xccr\xbc\xb8(\x00?\x87\x00\x165\x8blY`Q\x0f\xef\xd1'
(b'\x95\x0b\xdb\xfc\x91\xdeZ&\xed\x1c~\x18\x00[\ra`\n\x94i\x97\xd4\xcf\x15'
b'\x19c\x0b\xde`}0"\n\xe8/\x00GY\x1d\x00\x00\x004\x00\x00\x00ayc\x02\x00F'
b'\x00\x00\x00\x03\x00\x00\x00N\x00\x00\x00;L;\xc5\x8b\xe0\xc0\xed\xf3'
b'\xda?\x8b\xd6?\x17\xef\x07\xb7\x1c\xad\xc1D\xd0\x16\xa9B\xfdjN\x045\xbf\xfa'
b'\x8c\xa3\xb9\x90\x07\x12\x10\x1b\xac2se\x00\x08\x00\x00\x00\x7f\x00\x00\x00')
Результат разбора:
'A1': 98,
{'A2': {'B1': [{'C1': -4337,
'C2': 6547831423436035537,
'C3': 2115824934,
'C4': {'D1': 139, 'D2': 1365268844},
'C5': 3419},
'C1': -11113,
{'C2': 9034464992993809871,
'C3': -401989072,
'C4': {'D1': 97, 'D2': 1771309664},
'C5': 22855}],
'B2': 'ayc',
'B3': 19515,
'B4': -527710917},
'A3': 13579140982909792677,
'A4': 0.5006213188171387,
'A5': {'E1': 1932700699,
'E2': {'F1': 0.35224911100496215,
'F2': [61207, 46855, 44316, 17601, 5840, 17065, 27389],
'F3': -0.7070969343185425},
'E3': [-6, -116, -93, -71, -112, 7, 18, 16]},
'A6': 22,
'A7': 53}
Пример 2
Двоичные данные:
b'yGXZS\x7fP\x00n\xc4{\x14Y,\x96\xe1\xea=w?\x83\x00b\xef\xc8""\xbb^\xbe&\xf7'
(b'\xb8\xf8\xbb#s\x8b\xe8\x19\x03\xbdJ\x18\x00\xd7,+V}\xc9\x90\x87h\xd4\x02'
b'\\\xafCXi\xa3\x0b\x16\xd1\xfe/\x00\x9dM\x1d\x00\x00\x004\x00\x00\x00oa'
b'\x02\x00F\x00\x00\x00\x02\x00\x00\x00N\x00\x00\x00,Q\x1c[\xb2\x04'
b'\x0c<\xd5\xfd\x89\xec\xe1\xbfZ\x9bK\xc6J[\xe9s\x95\xef\xf9\x9a\xeb\\\xe31'
b'\xc1=\xca\xc5\x97!\xb9\x1b\xa3a\x8ed\x00\x05\x00\x00\x00~\x00\x00\x00')
Результат разбора:
'A1': 127,
{'A2': {'B1': [{'C1': 9918,
'C2': 16756613435876751607,
'C3': 1253901081,
'C4': {'D1': 200, 'D2': 1589322274},
'C5': 11479},
'C1': 26759,
{'C2': 11775039748464968404,
'C3': -19851765,
'C4': {'D1': 43, 'D2': 2429123926},
'C5': 19869}],
'B2': 'oa',
'B3': 20780,
'B4': 78797596},
'A3': 16255228666147751022,
'A4': 0.9657884836196899,
'A5': {'E1': 2388763419,
'E2': {'F1': -0.5601243932413822,
'F2': [39770, 50763, 23370, 29673, 61333, 39673, 23787],
'F3': 0.09433343261480331},
'E3': [-54, -59, -105, 33, -71]},
'A6': 98,
'A7': 239}
Задача №12
Реализовать разбор двоичного формата данных. Данные начинаются с сигнатуры 0x45 0x55 0x4f
, за которой следует структура A.
Порядок байт: от старшего к младшему. Адреса указаны в виде смещений от начала данных. В решении предлагается использовать модуль
struct.
Структура A:
Поле | Описание |
---|---|
1 | Структура B |
2 | uint64 |
3 | uint32 |
4 | uint8 |
5 | Структура C |
6 | Массив char, размер 7 |
7 | Размер (uint32) и адрес (uint16) массива структур D |
8 | double |
Структура B:
Поле | Описание |
---|---|
1 | int16 |
2 | double |
Структура C:
Поле | Описание |
---|---|
1 | float |
2 | int16 |
3 | Размер (uint16) и адрес (uint16) массива char |
4 | int16 |
Структура D:
Поле | Описание |
---|---|
1 | Размер (uint16) и адрес (uint16) массива uint32 |
2 | int8 |
3 | int32 |
4 | uint32 |
Ниже показаны примеры разбора двоичного формата.
Пример 1
Двоичные данные:
b'EUO \xd3?\xd6i];\x11\xc1x3Rc\xf0\xc3E\xc6\xe7\xad\xfbA\x03\xff\xbfq'
(b'\xb7\xcbl\xa1\x00\x05\x00;(\x80aezokfq\x00\x00\x00\x04\x00`?\xe8\xca\x02\xe1'
b'\xa0q|kqzdkS7\xcbK=\xdb\xe8\xa8=N\xb4\x06\x08\xcd\x02qJ\x90\x92\x82'
b'^\x9a<\xa9\x8a9\xd4\xb6/ly/\x00\x02\x00@N\xda?\xa1\xa4\xfc\xe5\xf5'
b'\x07\x00\x02\x00Hd\xee\x9c6\xaa\xd8\x80#\xcd\x00\x02\x00P\xaft\xcb\x8b\xb88'
b'\xe3\xec8\x00\x02\x00X?2\x14\xb4\xe7\xd3H\xb1i')
Результат разбора:
'A1': {'B1': 8403, 'B2': 0.35018091934673334},
{'A2': 3698128129744029415,
'A3': 2918924547,
'A4': 255,
'A5': {'C1': -0.9442107081413269, 'C2': 27809, 'C3': 'kqzdk', 'C4': 10368},
'A6': 'aezokfq',
'A7': [{'D1': [1396165451, 1037822120],
'D2': 78,
'D3': -633364060,
'D4': 4242928903},
'D1': [1028568070, 147653233],
{'D2': 100,
'D3': -291752278,
'D4': 3632276429},
'D1': [1250988674, 1587166377],
{'D2': -81,
'D3': 1959496632,
'D4': 954461240},
'D1': [2319045814, 795638063],
{'D2': 63,
'D3': 840217831,
'D4': 3544756585}],
'A8': 0.7746595770618536}
Пример 2
Двоичные данные:
b'EUO\xae\xbf?\xd5d\xc8T\xb5\x05\xbc\xa5A)\xca\xf1\xa5\xc0\xaa\xa1\x9bh\xdaT=X'
(b'\xeb\x15U\xfc\x00\x02\x00;`\xecjpvkqse\x00\x00\x00\x06\x00m\xbf\xe536\xf1'
b'\x80d\xd2gn\x93a\xd8\xe4\xc3\xd5x\xaf\xce.!\x98\t0\xcf2\xe7\x05f\xa0*3\x07'
b'\xc3V\xd7`;>\n\xd9\xea\x88?\xd7CTU\x1b\x88C\xc9t\xb3\x9f*\xaa'
b'\x86\x00\x02\x00=\x13\xf4h\xa6}\x9cneu\x00\x02\x00E!\xa9\x01\xad\x1f\xdc'
b"a\x8c\x00\x00\x02\x00M6\t\xf8C\xa5\xab\xc2\xa3\xe4\x00\x02\x00U'\x8e\xa8H"
b'\x8b*\xc7%\xb1\x00\x02\x00]D\xe7\x9a$_\xbe\xcd:\xdf\x00\x02\x00e\x1f.'
b'=\xf9\x9d\x1d\xf0\x10\xfd')
Результат разбора:
'A1': {'B1': -20801, 'B2': 0.33427627823047223},
{'A2': 11907844841358606506,
'A3': 2711316698,
'A4': 84,
'A5': {'C1': 0.052958566695451736, 'C2': 22012, 'C3': 'gn', 'C4': 24812},
'A6': 'jpvkqse',
'A7': [{'D1': [2472663268, 3285547183],
'D2': 19,
'D3': -194468227,
'D4': 2624480629},
'D1': [3459129752, 154193714],
{'D2': 33,
'D3': -1459507937,
'D4': 3697380352},
'D1': [3875890848, 707987395],
{'D2': 54,
'D3': 167265189,
'D4': 2881659876},
'D1': [1456955451, 1040898538],
{'D2': 39,
'D3': -1901574005,
'D4': 717694385},
'D1': [2285885251, 1414863752],
{'D2': 68,
'D3': -409328545,
'D4': 3201120991},
'D1': [1137276083, 2670373510],
{'D2': 31,
'D3': 775813533,
'D4': 502272253}],
'A8': -0.662501784975712}
Задача №12
Реализовать разбор двоичного формата данных. Данные начинаются с сигнатуры 0x50 0x53 0x4a
, за которой следует структура A.
Порядок байт: от младшего к старшему. Адреса указаны в виде смещений от начала данных. В решении предлагается использовать модуль
struct.
Структура A:
Поле | Описание |
---|---|
1 | Адрес (uint32) структуры B |
2 | uint16 |
Структура B:
Поле | Описание |
---|---|
1 | Адрес (uint32) структуры C |
2 | Размер (uint32) и адрес (uint32) массива uint16 |
3 | uint16 |
4 | uint8 |
5 | double |
Структура C:
Поле | Описание |
---|---|
1 | int8 |
2 | Массив адресов (uint16) структур D, размер 4 |
3 | int64 |
4 | Структура E |
Структура D:
Поле | Описание |
---|---|
1 | Массив int32, размер 2 |
2 | int32 |
3 | int32 |
4 | Массив int8, размер 7 |
Структура E:
Поле | Описание |
---|---|
1 | double |
2 | uint16 |
3 | uint16 |
4 | float |
Ниже показаны примеры разбора двоичного формата.
Пример 1
Двоичные данные:
b'PSJ\x8a\x00\x00\x00\xafg\xf2\x13k\xb3\x8a\xd0\xb3\x82"D\xe7<\xd7u\x17'
(b'\xce\xa8\x07\xc2.N\xaauk\xfb*!\n\xdb\x11\x0e\xc4l\xa7nP\xcd\x1f8'
b'\x0eG\xe3\xf7koF\x15\x9b\xd5hG\xd6\x04mr\xea\xbf\xberBlB\x19\xccvxo'
b'\xf4\x88\x0b\xd9 W\x9e\xbe\xc1Xf\x0c\x1d8\xfeI\x87\x11\xd9\xd6C\xe6\xd2u'
b'\xd4W\t\x00 \x007\x00N\x00u\xb6\xde:\xbb\xee\xb08\x08\xbd\t\x17\x0f%\xd4?f2'
b'\xe5\x9a1\xf4\x15>\xbc=:%e\x00\x00\x00\x02\x00\x00\x00\x86\x00\x00\x00\xd7{'
b'\xefBG\xa7\x1f\x02H\xe8?')
Результат разбора:
'A1': {'B1': {'C1': 87,
{'C2': [{'D1': [-1284828174, -2102144886],
'D2': 1021789218,
'D3': -837323305,
'D4': [-88, 7, -62, 46, 78, -86, 117]},
'D1': [556465003, 236051210],
{'D2': 1856466116,
'D3': 941608272,
'D4': [14, 71, -29, -9, 107, 111, 70]},
'D1': [1758829333, 1829033543],
{'D2': -1094718862,
'D3': 1114391154,
'D4': [25, -52, 118, 120, 111, -12, -120]},
'D1': [1461770507, 1489092254],
{'D2': 941427814,
'D3': 294078974,
'D4': [-39, -42, 67, -26, -46, 117, -44]}],
'C3': 4085027349939009141,
'C4': {'E1': 0.31476189851578384,
'E2': 12902,
'E3': 39653,
'E4': 0.146439328789711}},
'B2': [15804, 9530],
'B3': 31703,
'B4': 239,
'B5': 0.7587900751334262},
'A2': 26543}
Пример 2
Двоичные данные:
b'PSJ\x8c\x00\x00\x00.M\xdf{\xf0h\x06\x8e\xfe\x9cH}\xa4\xf6\x1c \xf7'
(b'{\xec\xe4\x1c\xfdy\xa1#"$\x843\xb4\xc6\xbd\'\x8e_\xa7\x0eM \xe3\x1aa(p?'
b'I\xe8\xcb\xe7\xfeS5L\xf1\xf1%L\xb5\x89n\xf5c\xe1a\xdf\tw\xd2`\xaa0\x14 '
b'\n\x88\n.\xdfi\xb1rmAo,\xe7\xb88\x1f\xc7!u\xc1s!\t\x00 \x007\x00N\x00\xec['
b'\x9e)\xdc\x96c\x92|\x82N^Wm\xe0?\x82!\x1d$\xde5\xd3\xbe1pkfR\xf0'
b'e\x00\x00\x00\x03\x00\x00\x00\x86\x00\x00\x00\rX\xca\xc0\xb7\xbb\xc5j'
b'\xbf\xb4\xbf')
Результат разбора:
'A1': {'B1': {'C1': 33,
{'C2': [{'D1': [1760590815, -1661039098],
'D2': -156992184,
'D3': 2079793180,
'D4': [-20, -28, 28, -3, 121, -95, 35]},
'D1': [864298018, 666748596],
{'D2': 245849998,
'D3': 451092557,
'D4': [97, 40, 112, 63, 73, -24, -53]},
'D1': [894697191, 636612940],
{'D2': 1854518604,
'D3': 1642161141,
'D4': [-33, 9, 119, -46, 96, -86, 48]},
'D1': [-2012602348, 1776233994],
{'D2': 1097691825,
'D3': -1192809361,
'D4': [56, 31, -57, 33, 117, -63, 115]}],
'C3': -7898303449142502420,
'C4': {'E1': 0.513347324555141,
'E2': 8578,
'E3': 9245,
'E4': -0.4125203490257263}},
'B2': [28721, 26219, 61522],
'B3': 22541,
'B4': 202,
'B5': -0.08104579284164881},
'A2': 19758}
Задача №12
Реализовать разбор двоичного формата данных. Данные начинаются с сигнатуры 0x50 0x49 0x4c 0xa6
, за которой следует структура
A. Порядок байт: от младшего к старшему. Адреса указаны в виде смещений от начала данных. В решении предлагается использовать модуль
struct.
Структура A:
Поле | Описание |
---|---|
1 | int8 |
2 | Адрес (uint32) структуры B |
3 | Размер (uint16) и адрес (uint16) массива int16 |
4 | Адрес (uint16) структуры D |
5 | uint8 |
6 | float |
7 | int32 |
Структура B:
Поле | Описание |
---|---|
1 | int16 |
2 | Массив char, размер 4 |
3 | Массив структур C, размер 2 |
4 | uint16 |
Структура C:
Поле | Описание |
---|---|
1 | Размер (uint32) и адрес (uint32) массива int64 |
2 | float |
3 | Размер (uint16) и адрес (uint16) массива int16 |
4 | uint8 |
5 | int32 |
6 | int32 |
Структура D:
Поле | Описание |
---|---|
1 | uint16 |
2 | int8 |
3 | int16 |
Ниже показаны примеры разбора двоичного формата.
Пример 1
Двоичные данные:
b'PIL\xa6\xc0J\x00\x00\x00\x03\x00\x84\x00\x8a\x00\xb0\xa4\x16 \xbf'
(b'\xe0\x8c\x17\xa4\x9b\xe1jS\x0b\xad\x0fzib\xda;\xcak\x7f\xa1\x96Ulf\x02q!l'
b'K\x0c,\x06\xe9\xc5\x15\x11\x0ew\xcc\xf7_\xc0\xd9\xe56R\xef8\n\xf9\x05\xfe'
b'\x0e3\x1c\x82fbvi\x02\x00\x00\x00\x18\x00\x00\x00\x9e\xb0\x06?\x04\x00(\x00'
b'6\xcf\xc1\xac9\xf7\xd9\xd1\x9a\x02\x00\x00\x000\x00\x00\x00\xabd\x8a'
b'\xbe\x05\x00@\x00gV\xe0HT\x0e\xf3Q\n\x98\xff\xa3\x05\xf9\xc1j9\xf8\xfe'
b'\xdd\xf4\x8e')
Результат разбора:
'A1': -64,
{'A2': {'B1': -32228,
'B2': 'fbvi',
'B3': [{'C1': [8795438861433627035, -6809605595229166999],
'C2': 0.5261324644088745,
'C3': [21910, 26220, 28930, 27681],
'C4': 54,
'C5': 967623119,
'C6': -1697523209},
'C1': [1231107677777300555, -1884263450666043634],
{'C2': -0.2702992856502533,
'C3': [21046, 14575, -1782, -507, 13070],
'C4': 103,
'C5': 1414062166,
'C6': 173142798}],
'B4': 65432},
'A3': [1443, -15879, 14698],
'A4': {'D1': 65272, 'D2': -35, 'D3': -28940},
'A5': 176,
'A6': -0.6253454685211182,
'A7': -1541960480}
Пример 2
Двоичные данные:
b'PIL\xa6]H\x00\x00\x00\x04\x00\x82\x00\x8a\x00\xdb\xcf;\x08>\xc9\xdf\xb3\xc3'
(b'\x966\xc32\x14`\x95\x15<\xf2\xc7\xf0\x84c\xccYD{\xdd\r\x9a\xaex\xef'
b' \xad\x10\xfa\xa9\xb1\xae\xad\xa6\xfc[\xee\xc2\xe2Uu\xa2\xd5\x9a\x06*R#\x8d'
b'\xe3\xb4vnfa\x02\x00\x00\x00\x18\x00\x00\x00\xfb\x89\xb4\xbe\x03\x00(\x00_|'
b'\xb7\x08x\x18\xab{\x97\x02\x00\x00\x00.\x00\x00\x00\x8b9\x0c?\x05'
b'\x00>\x00\x03l{ch\xc0d\xc8\x83\xd0\x1eKe\xe7xX\xf2Bv\x85a[Y\xc8')
Результат разбора:
'A1': 93,
{'A2': {'B1': -19229,
'B2': 'vnfa',
'B3': [{'C1': [1555254886193641110, 6470656187251028540],
'C2': -0.35261520743370056,
'C3': [31556, 3549, -20838],
'C4': 95,
'C5': 2013837180,
'C6': -1753502952},
'C1': [-5644705708401168520, -2106859596807754322],
{'C2': 0.5477530360221863,
'C3': [30037, -10846, 1690, 21034, -29405],
'C4': 3,
'C5': 1751350124,
'C6': -2084019008}],
'B4': 7888},
'A3': [25931, 30951, -3496, 30274],
'A4': {'D1': 24965, 'D2': 91, 'D3': -14247},
'A5': 219,
'A6': 0.133040651679039,
'A7': -1011621943}
Задача №12
Реализовать разбор двоичного формата данных. Данные начинаются с сигнатуры 0xb 0x57 0x43 0x56 0x4b
, за которой следует
структура A. Порядок байт: от старшего к младшему. Адреса указаны в виде смещений от начала данных. В решении предлагается использовать
модуль struct.
Структура A:
Поле | Описание |
---|---|
1 | Массив char, размер 8 |
2 | Структура B |
3 | Размер (uint32) и адрес (uint16) массива uint8 |
Структура B:
Поле | Описание |
---|---|
1 | double |
2 | uint64 |
3 | double |
4 | Массив адресов (uint16) структур C, размер 4 |
5 | Адрес (uint32) структуры D |
Структура C:
Поле | Описание |
---|---|
1 | Массив uint8, размер 8 |
2 | float |
3 | int16 |
Структура D:
Поле | Описание |
---|---|
1 | float |
2 | Массив uint32, размер 5 |
Ниже показаны примеры разбора двоичного формата.
Пример 1
Двоичные данные:
b'\x0bWCVKmwhfxhez?\xec\xebVR\x03UZ\xde\x1f+\x92\x84\x0e\xbb]?\xe6\x83'
(b'pd\x90\x97\x02\x007\x00E\x00S\x00a\x00\x00\x00o\x00\x00\x00\x02\x00\x87\r'
b'\x96\xaf\x99;\xa8\xff\xfe?~Z\xd2\xa2\xc5$\xce\x9dC\x817O\x1b\xbd\xfc\xe6'
b'\x1f6\x95\x1d<\xe2\xe4\xeeP\x90\xca\xbeY:\xfc\x11\xb1\x80\xee\x1b\xcbD%\xe6'
b'G\xbe\xd0\x03\xd5]d?\x1a\x16G#\x12\xcf\xd7KR\xf0\t\xc5q\x17\x07\xa7'
b'\x98\n@\xfb\xcf\xab#\xa6\xb7')
Результат разбора:
'A1': 'mwhfxhez',
{'A2': {'B1': 0.9037276841942614,
'B2': 16005559508978809693,
'B3': 0.7035448040157635,
'B4': [{'C1': [13, 150, 175, 153, 59, 168, 255, 254],
'C2': 0.9935733079910278,
'C3': -23867},
'C1': [36, 206, 157, 67, 129, 55, 79, 27],
{'C2': -0.12348579615354538,
'C3': 13973},
'C1': [29, 60, 226, 228, 238, 80, 144, 202],
{'C2': -0.2121390700340271,
'C3': 4529},
'C1': [128, 238, 27, 203, 68, 37, 230, 71],
{'C2': -0.40627923607826233,
'C3': 23908}],
'B5': {'D1': 0.601902425289154,
'D2': [588435415,
1263726601,
3312523015,
2811759168,
4224690979]}},
'A3': [166, 183]}
Пример 2
Двоичные данные:
b'\x0bWCVKmhhdncwm?\xe9\x9d\xc0\xc2\x16\xf7:\x86\xc6\xc4\xd2\xdfx\x8e'
(b'\xd8?\xe5\xaac\xaa\xcc.\xd0\x007\x00E\x00S\x00a\x00\x00\x00o\x00\x00\x00'
b'\x02\x00\x87\xb6v\xa2\xbb\xcd!\x17\xd3\xbf5\n\xb5\xf5\xaa\xa1\xd9\x7f'
b'\xb4\x97~\xcd\x1b>.4\xdd\x8f\xeb\xc2\xbe7\xe0\t~\xce\xfa\xbc\xcc0G\xdd'
b'\x8eF\xca2\xd1\xd7\x03\xc11\xbe\x93\x84\x8b\x8f\xcb\xbe\xd66wd\xc4+\x94\xd3'
b'\xef0\xc1(\xadd\xf1\x1f\x1c\xdf\xb7&\xe6\xcc\xa3\xcd\x1e')
Результат разбора:
'A1': 'mhhdncwm',
{'A2': {'B1': 0.8005069533171316,
'B2': 9711666056442449624,
'B3': 0.6770494781389633,
'B4': [{'C1': [182, 118, 162, 187, 205, 33, 23, 211],
'C2': -0.7071946263313293,
'C3': -2646},
'C1': [161, 217, 127, 180, 151, 126, 205, 27],
{'C2': 0.17012353241443634,
'C3': -28693},
'C1': [194, 190, 55, 224, 9, 126, 206, 250],
{'C2': -0.024925364181399345,
'C3': -8818},
'C1': [70, 202, 50, 209, 215, 3, 193, 49],
{'C2': -0.2881205976009369,
'C3': -28725}],
'B5': {'D1': -0.41838428378105164,
'D2': [1690577812,
3555668161,
682452209,
521985975,
652659875]}},
'A3': [205, 30]}
Задача №12
Реализовать разбор двоичного формата данных. Данные начинаются с сигнатуры 0x41 0x43 0x44 0x57 0x1
, за которой следует
структура A. Порядок байт: от старшего к младшему. Адреса указаны в виде смещений от начала данных. В решении предлагается использовать
модуль struct.
Структура A:
Поле | Описание |
---|---|
1 | uint32 |
2 | Массив double, размер 8 |
3 | int8 |
4 | Массив адресов (uint32) структур B, размер 3 |
5 | Адрес (uint16) структуры C |
6 | int32 |
7 | int32 |
Структура B:
Поле | Описание |
---|---|
1 | int16 |
2 | uint8 |
Структура C:
Поле | Описание |
---|---|
1 | Массив uint8, размер 6 |
2 | int32 |
3 | uint8 |
4 | Адрес (uint16) структуры D |
5 | int32 |
Структура D:
Поле | Описание |
---|---|
1 | Массив uint8, размер 8 |
2 | uint16 |
3 | int8 |
4 | uint8 |
5 | uint8 |
6 | double |
Ниже показаны примеры разбора двоичного формата.
Пример 1
Двоичные данные:
b'ACDW\x01\x9d\x10y3?\xc8\xcf\x7f\xa1\x8c\xa1\xe0?\xa5\x7f\x99\x9d\x07U'
(b'\x00\xbf\xec4F\xb3W\x92\\?\xc1R\xd3$\x940 ?\xc0\x80\xf3\x91De(?\xcfA'
b'\xf28*\xe7\x10\xbf\xb2\x8d{\x84"\xa0p\xbf\xe8\r\x80\x0c\xeb\x0f'
b'\xae\xfb\x00\x00\x00`\x00\x00\x00c\x00\x00\x00f\x00~\xc3\xf1\xebl}e$\xca'
b'.\x1fI\x1f\xcb w={\x0fd\xf1{:k\x95wL\xbe>\x13\x88\xbf\xebqe\xceKR^\xbb\xbe'
b'\xb3\xb2\xa0y0Z.\xf2\xa6\x00i\xe49]\xd0')
Результат разбора:
'A1': 2635102515,
{'A2': [0.1938323534789239,
0.041989136141333816,
-0.881381368901724,
0.13534011159970394,
0.12893528550265754,
0.24420001738126773,
-0.07247135139425764,
-0.7516479732807875],
'A3': -5,
'A4': [{'B1': 11807, 'B2': 73},
'B1': 8139, 'B2': 32},
{'B1': 30525, 'B2': 123}],
{'A5': {'C1': [187, 190, 179, 178, 160, 121],
'C2': 811216626,
'C3': 166,
'C4': {'D1': [15, 100, 241, 123, 58, 107, 149, 119],
'D2': 19646,
'D3': 62,
'D4': 19,
'D5': 136,
'D6': -0.8575924901184171},
'C5': -466002480},
'A6': -1007555732,
'A7': 2103780554}
Пример 2
Двоичные данные:
b'ACDW\x01U)\x0e\x9a?\xef\xb9?\xff \xe5\xd2?\xd0@3N{\xc3\x84?\xd50'
(b"\xe55\xef\xd2P\xbf\xd9P\x87S.\xa5|?\xefF\x0e\xc8\xf7\xe3<\xbf\xe8'v\xbb{\xa1"
b'.\xbf\xdf\x02\x11_\xe7\x1e\xb4?\xb2?\x1e@P\xe3\x10\x1b\x00\x00\x00`\x00\x00'
b'\x00c\x00\x00\x00f\x00~I\xd4\xf3;8\xeeT\xd7\xab\xe2\xe2\x9e\x13!\xaeEpW\x1aj'
b'\x8d\x88\xa1Zre\xb3\x16\xb7\x86\xbf\xd2\xf9\x95\x9d\x9f`<)\x0c\xe5\xa1\xd0r'
b'|\x947\xea\x8b\x00i\xe6\x8e\xc9\xca')
Результат разбора:
'A1': 1428754074,
{'A2': [0.9913635237673424,
0.25391848244094484,
0.33110933558717637,
-0.3955400764776511,
0.9773019719278646,
-0.7548173581863347,
-0.48450121274479874,
0.07127560682500822],
'A3': 27,
'A4': [{'B1': -21534, 'B2': 226},
'B1': -25069, 'B2': 33},
{'B1': -20923, 'B2': 112}],
{'A5': {'C1': [41, 12, 229, 161, 208, 114],
'C2': 2090088426,
'C3': 139,
'C4': {'D1': [87, 26, 106, 141, 136, 161, 90, 114],
'D2': 26035,
'D3': 22,
'D4': 183,
'D5': 134,
'D6': -0.29648342507198655},
'C5': -426849846},
'A6': 1238692667,
'A7': 955143383}
Задача №12
Реализовать разбор двоичного формата данных. Данные начинаются с сигнатуры 0x88 0x5a 0x50 0x4d 0x48
, за которой следует
структура A. Порядок байт: от старшего к младшему. Адреса указаны в виде смещений от начала данных. В решении предлагается использовать
модуль struct.
Структура A:
Поле | Описание |
---|---|
1 | int8 |
2 | double |
3 | Размер (uint16) и адрес (uint16) массива char |
4 | uint8 |
5 | Размер (uint32) и адрес (uint32) массива адресов (uint16) структур B |
6 | int32 |
7 | double |
8 | Массив uint8, размер 5 |
Структура B:
Поле | Описание |
---|---|
1 | uint8 |
2 | int16 |
3 | Адрес (uint32) структуры C |
4 | Адрес (uint32) структуры D |
Структура C:
Поле | Описание |
---|---|
1 | int8 |
2 | int16 |
3 | uint8 |
Структура D:
Поле | Описание |
---|---|
1 | float |
2 | Массив int8, размер 7 |
3 | int8 |
4 | uint32 |
5 | uint8 |
6 | uint8 |
Ниже показаны примеры разбора двоичного формата.
Пример 1
Двоичные данные:
b'\x88ZPMH\x12?\xd4{\xf5\x87\xf0\x1a\xb0\x00\x03\x00,\xe6\x00\x00\x00\x05\x00'
(b'\x00\x00\xd4Y\xbe\xd0\xfa\xbf\xd4E\x88\x07\xe6\xfdh\x88\xd0\xa5`\xe3mvw1'
b'\x05\xcd\x91\xbf\x01\xc6\x15\xbb\x0fp\x99,\x842\x08\xfc/\xc0\x8bP\xe5\x08if'
b'\x00\x00\x00/\x00\x00\x003\xb0f8\xee>\xc7\xe3\x08\x9d\xbc\xc0\t'
b'\x8c\xed\x1f\x07!\x91\xb3\xdea\xf0\xd2\x9f\xb9\x00\x00\x00P\x00\x00\x00'
b'T\x05\xdfi\x08\xbfw\xcf\xa9z\x7fr\xf5c\xb2?\x86\x81\xeb\x8c\xf2\xccj]'
b'\x16\x00\x00\x00\x00q\x00\x00\x00u\x0b\x89\x7f\xaa>\xae\xc4\x1d\xd9\x84'
b"\x0e'\xb2\xd1S\xda^\r~\xf4~\xd0ZD\xdf\x00\x00\x00\x92\x00\x00\x00\x96\xf7"
b'\xe4m\xf8\xbd\x1e\xad#\x89\x7f\xe5\x81\x9a\xd6\xda\x93z\xa1>l@'
b'\xf1\xe6\xec\xc2\x00\x00\x00\xb3\x00\x00\x00\xb7\x00E\x00f\x00\x87\x00\xa8'
b'\x00\xc9')
Результат разбора:
'A1': 18,
{'A2': 0.3200658633726716,
'A3': 'mvw',
'A4': 230,
'A5': [{'B1': 8,
'B2': 26982,
'B3': {'C1': 49, 'C2': 1485, 'C3': 145},
'B4': {'D1': -0.5069287419319153,
'D2': [-69, 15, 112, -103, 44, -124, 50],
'D3': 8,
'D4': 4230987915,
'D5': 80,
'D6': 229}},
'B1': 210,
{'B2': -24647,
'B3': {'C1': -80, 'C2': 26168, 'C3': 238},
'B4': {'D1': 0.39040398597717285,
'D2': [-99, -68, -64, 9, -116, -19, 31],
'D3': 7,
'D4': 563196894,
'D5': 97,
'D6': 240}},
'B1': 93,
{'B2': 5632,
'B3': {'C1': 5, 'C2': -8343, 'C3': 8},
'B4': {'D1': -0.9680123925209045,
'D2': [122, 127, 114, -11, 99, -78, 63],
'D3': -122,
'D4': 2179697906,
'D5': 204,
'D6': 106}},
'B1': 90,
{'B2': 17631,
'B3': {'C1': 11, 'C2': -30337, 'C3': 170},
'B4': {'D1': 0.34133997559547424,
'D2': [-39, -124, 14, 39, -78, -47, 83],
'D3': -38,
'D4': 1577942772,
'D5': 126,
'D6': 208}},
'B1': 230,
{'B2': -4926,
'B3': {'C1': -9, 'C2': -7059, 'C3': 248},
'B4': {'D1': -0.03873933479189873,
'D2': [-119, 127, -27, -127, -102, -42, -38],
'D3': -109,
'D4': 2057387628,
'D5': 64,
'D6': 241}}],
'A6': 1505677562,
'A7': -0.3167438580676021,
'A8': [136, 208, 165, 96, 227]}
Пример 2
Двоичные данные:
b'\x88ZPMH\x92?\xd2S\x06A[\x93,\x00\x02\x00,\xa1\x00\x00\x00\x03\x00'
(b'\x00\x00\x91\xe9\x8d\xdaV\xbf\xa8\x90pW"\xe5 N\xf81"\x02sr\x1a\xd5'
b'\x809\xbe\xd7\xe9\xf4v\x0b\x9c{\x85\xb6\xe8\x80\xd8\x05\x93\xd2\x9a\x0f'
b'\xab\x94\x91\x00\x00\x00.\x00\x00\x002\x0e\xba\xf8\xc6?\r\x9f5d'
b'\xec\xfa\xee\xdf\x99\x8b\xc6\x01\xa6\xa2\xf0;\xb3\\k\xf2\x00\x00\x00O'
b'\x00\x00\x00S\xf3\xb1\xd7\xeb?\x190\xac\xeb\xdb4\xe6q!CE\x84\x86\x84\x0f'
b"\xf3v1'3\x00\x00\x00p\x00\x00\x00t\x00D\x00e\x00\x86")
Результат разбора:
'A1': -110,
{'A2': 0.28631740934933947,
'A3': 'sr',
'A4': 161,
'A5': [{'B1': 171,
'B2': -27503,
'B3': {'C1': 26, 'C2': -10880, 'C3': 57},
'B4': {'D1': -0.42170679569244385,
'D2': [118, 11, -100, 123, -123, -74, -24],
'D3': -128,
'D4': 3624244178,
'D5': 154,
'D6': 15}},
'B1': 92,
{'B2': 27634,
'B3': {'C1': 14, 'C2': -17672, 'C3': 198},
'B4': {'D1': 0.5532105565071106,
'D2': [100, -20, -6, -18, -33, -103, -117],
'D3': -58,
'D4': 27697904,
'D5': 59,
'D6': 179}},
'B1': 49,
{'B2': 10035,
'B3': {'C1': -13, 'C2': -20009, 'C3': 235},
'B4': {'D1': 0.5983989238739014,
'D2': [-21, -37, 52, -26, 113, 33, 67],
'D3': 69,
'D4': 2223408143,
'D5': 243,
'D6': 118}}],
'A6': -376579498,
'A7': -0.04797698081660884,
'A8': [78, 248, 49, 34, 2]}
Задача №12
Реализовать разбор двоичного формата данных. Данные начинаются с сигнатуры 0x35 0x47 0x4d 0x54
, за которой следует структура
A. Порядок байт: от младшего к старшему. Адреса указаны в виде смещений от начала данных. В решении предлагается использовать модуль
struct.
Структура A:
Поле | Описание |
---|---|
1 | Адрес (uint16) структуры B |
2 | uint16 |
Структура B:
Поле | Описание |
---|---|
1 | double |
2 | Адрес (uint16) структуры C |
3 | Размер (uint16) и адрес (uint16) массива адресов (uint16) структур D |
4 | Адрес (uint32) структуры E |
5 | int16 |
6 | float |
7 | uint8 |
8 | Структура F |
Структура C:
Поле | Описание |
---|---|
1 | uint8 |
2 | uint16 |
3 | int32 |
4 | uint64 |
5 | Размер (uint32) и адрес (uint32) массива char |
Структура D:
Поле | Описание |
---|---|
1 | int16 |
2 | uint8 |
3 | uint64 |
4 | uint8 |
Структура E:
Поле | Описание |
---|---|
1 | double |
2 | Размер (uint32) и адрес (uint16) массива int8 |
3 | float |
4 | uint64 |
5 | float |
6 | uint16 |
7 | Массив uint16, размер 7 |
Структура F:
Поле | Описание |
---|---|
1 | int16 |
2 | Массив double, размер 4 |
3 | int64 |
Ниже показаны примеры разбора двоичного формата.
Пример 1
Двоичные данные:
b'5GMTs\x00!ggmbwkc\x01o\xe1\x015e\xe9\xae\xd8\xdeI\x1cE\xc3o\x06\x00\x00'
(b'\x00\x08\x00\x00\x00!oJ\x7f\xeb\xb3\xb9u2\x9b\xce\xbb\x8a\x8eU'
b"\xa0\x90\x98\xb7~\x016\x18\xcd%\x001\x00\xa2K\xbc'\xbc\xad?\xcc\xd9\xe6\xd7"
b'\xbf\x04\x00\x00\x00A\x00(u\x0e\xbf\x05\xb1\xcc\xa0_\x0f\x0c\xee>'
b'o\xf7\xbe\xef6\xbd\xbd\xdfI\x8b\xc9\xf7\xf8\x1f\xe3\xab\xe3\xb0\x00\xe0'
b'\xf5\xc93\x88\xf3\xaa?\x0e\x00\x02\x00=\x00E\x00\x00\x00\xcco\xc9DQ\xbfe'
b'$:\xf0\x817<\x1f\xfe\xb9\xbf\xb43a\x00N\xdd\xe3\xbf0vV\xed\xe18\xc2\xbf\xbc-'
b'\xb0\x11d\xee\xdf\xbf\x15=\xcbR\x9d\x1e\x07F')
Результат разбора:
'A1': {'B1': 0.05263925201596087,
{'B2': {'C1': 1,
'C2': 57711,
'C3': -379243263,
'C4': 8053356546469320878,
'C5': 'gmbwkc'},
'B3': [{'D1': 28449, 'D2': 74, 'D3': 14887548474411445119, 'D4': 187},
'D1': -29046, 'D2': 85, 'D3': 1744583549410381984, 'D4': 205}],
{'B4': {'E1': -0.37346501299063184,
'E2': [-94, 75, -68, 39],
'E3': -0.5564751625061035,
'E4': 17153101984141455621,
'E5': -0.4832705855369568,
'E6': 14063,
'E7': [48573, 18911, 51595, 63735, 58143, 58283, 176]},
'B5': 28620,
'B6': -0.8174558281898499,
'B7': 101,
'B8': {'F1': 14884,
'F2': [-0.1015338441861855,
-0.6207647330680772,
-0.14236091698414688,
-0.4989252255188281],
'F3': 5046035568539680021}},
'A2': 26401}
Пример 2
Двоичные данные:
b'5GMTs\x00\xd88gxomyw\x17Rs\xd7b[\xb2\x06\xf3\x95\x15\xcc\xea\xf4'
(b'\xc4\x06\x00\x00\x00\x08\x00\x00\x000\x855\xd1\t\xaf\xffA\x80\x8b~'
b'C\xab\x1a\xd8\xc6\xb2\x88\x00\xe1$\xd8\xd8\xc3%\x001\x00X\xecn\xdbPc\r'
b'y\x8f\xa1\xcc\xbf\x04\x00\x00\x00A\x00\x81\x80\xfd\xbd\x0cM\xff.\x15'
b'\xb3\xaa\x17\xc8\xf3 \xbf\xca\xd9\xe8\x13\x08\xaa\xe2Q\xd9(\x0c\x13\x94'
b'\xb1vU\xfc\xc8El\xae\x03\xec?\x0e\x00\x02\x00=\x00E\x00\x00\x00\xdb-\xab'
b'\x88(?\x93\xd6\xf8\x9a\x0e\xd0l\n,\xe7\xbf\xb4\xd9\xc3L\xb0!\xd1?<Y'
b'\x14i\xe6\xb7\xe4?\xe0?\x8dz \xfd\xd2\xbf\x0eL\xe1\x82\x8dy\x921')
Результат разбора:
'A1': {'B1': 0.8754493822764569,
{'B2': {'C1': 23,
'C2': 29522,
'C3': -1302633769,
'C4': 14192226488007652102,
'C5': 'gxomyw'},
'B3': [{'D1': -31440, 'D2': 53, 'D3': 9118522891492592081, 'D4': 67},
'D1': 6827, 'D2': 216, 'D3': 15625279455957136070, 'D4': 195}],
{'B4': {'E1': -0.22368043337589905,
'E2': [88, -20, 110, -37],
'E3': -0.123780257999897,
'E4': 1705372312477322508,
'E5': -0.6287198066711426,
'E6': 55754,
'E7': [5096, 43528, 20962, 10457, 4876, 45460, 21878]},
'B5': 11739,
'B6': 0.6583353877067566,
'B7': 147,
'B8': {'F1': -1834,
'F2': [-0.7241260648010723,
0.26768119331918716,
0.6474487354596827,
-0.2966996380609981],
'F3': 3572051103151377422}},
'A2': 14552}
Задача №12
Реализовать разбор двоичного формата данных. Данные начинаются с сигнатуры 0x27 0x5a 0x48 0x49 0x44
, за которой следует
структура A. Порядок байт: от младшего к старшему. Адреса указаны в виде смещений от начала данных. В решении предлагается использовать
модуль struct.
Структура A:
Поле | Описание |
---|---|
1 | uint8 |
2 | Структура B |
3 | Размер (uint32) и адрес (uint16) массива char |
4 | Массив структур C, размер 5 |
5 | int32 |
6 | Адрес (uint32) структуры D |
7 | Массив float, размер 7 |
Структура B:
Поле | Описание |
---|---|
1 | Массив char, размер 7 |
2 | int64 |
3 | int64 |
Структура C:
Поле | Описание |
---|---|
1 | uint16 |
2 | int64 |
Структура D:
Поле | Описание |
---|---|
1 | uint32 |
2 | float |
Ниже показаны примеры разбора двоичного формата.
Пример 1
Двоичные данные:
b"'ZHID\xb6umegtomR\xd0\xaeU!\x97\xa2\x88\xd5\xeb\x0e'R\xb1fS\x07\x00\x00"
(b'\x00y\x00\x96\x0f\xf8\x8fN\x87\xe1j\xc6\x90\xad\xa6R\xd5h\x01\xd3\xf0L^\xa6'
b'\xdb\\\x1813\xc6\xb4f}h\xa8\x04\x15\x82\xf3\xdb\x879I\xaa\xcbhyY'
b'\x93\x8b\xd4\x04\xcc\x98\xf2\x83&\x80\x00\x00\x00F\xcd\x03?u\xf0\xc6>.$('
b'?\x7fU;?t\xdc\xb8\xbeem/\xbf\x82\r\xfd\xbekemomdq+\xee\xb3\xc1\xc1T\n>')
Результат разбора:
'A1': 182,
{'A2': {'B1': 'umegtom', 'B2': -8601146168896991150, 'B3': 6009685719173229525},
'A3': 'kemomdq',
'A4': [{'C1': 3990, 'C2': -8014600969988960264},
'C1': 42669, 'C2': 6795070726847649106},
{'C1': 56230, 'C2': 9036108465720858716},
{'C1': 43112, 'C2': 5276397817194222852},
{'C1': 52138, 'C2': -3745635294127752856}],
{'A5': 646181528,
'A6': {'D1': 3249794603, 'D2': 0.1350889354944229},
'A7': [0.5148509740829468,
0.38855329155921936,
0.6568020582199097,
0.731773316860199,
-0.361056923866272,
-0.6852629780769348,
-0.49424368143081665]}
Пример 2
Двоичные данные:
b"'ZHID\xe0htoqkpi\xd2\xcdkX\x1e\xf0\xc1\x17\xea\xaepV\x00\xb2\x8a"
(b'n\x03\x00\x00\x00y\x00\xbd\xd1>\xf0Bw~,Lh1\xaf\x07P\xf9u\x84\x92\xf4p{'
b'\xfa\xee\x1dA\xad\xc6\xcfT\xde\xfa\xc8y\x8e\xb0\xcfV\x0f\xae\xff\xb1'
b"\xd5\x9c>b\x914*\x15N\xc6\xb67\x1e|\x00\x00\x00\xa4\x9b'\xbf\xc8ex"
b'\xbf\xf1\xc7y\xbf\xca\x113?\xe3\xcfv\xbf\xfcN\xc7>\xba\xb3u?act\xd2a}\xd7'
b'\x8d\x05\x12?')
Результат разбора:
'A1': 224,
{'A2': {'B1': 'htoqkpi', 'B2': 1711913346500644306, 'B3': 7965374605478113002},
'A3': 'act',
'A4': [{'C1': 53693, 'C2': 7515430799852892222},
'C1': 44849, 'C2': 8139291524177940487},
{'C1': 64123, 'C2': -2426085847028654610},
{'C1': 51450, 'C2': -23064082564215175},
{'C1': 54705, 'C2': 5626449714735103644}],
{'A5': 506967750,
'A6': {'D1': 3615318482, 'D2': 0.5703971982002258},
'A7': [-0.6547186374664307,
-0.9703030586242676,
-0.9757071137428284,
0.6994901895523071,
-0.9641095995903015,
0.3892744779586792,
0.9597736597061157]}
Задача №12
Реализовать разбор двоичного формата данных. Данные начинаются с сигнатуры 0x56 0x59 0x51
, за которой следует структура A.
Порядок байт: от младшего к старшему. Адреса указаны в виде смещений от начала данных. В решении предлагается использовать модуль
struct.
Структура A:
Поле | Описание |
---|---|
1 | Размер (uint16) и адрес (uint32) массива char |
2 | double |
3 | double |
4 | uint16 |
5 | Размер (uint16) и адрес (uint32) массива адресов (uint32) структур B |
6 | Адрес (uint16) структуры D |
7 | int16 |
Структура B:
Поле | Описание |
---|---|
1 | Структура C |
2 | float |
3 | uint16 |
Структура C:
Поле | Описание |
---|---|
1 | uint8 |
2 | uint64 |
Структура D:
Поле | Описание |
---|---|
1 | Массив int16, размер 5 |
2 | Массив uint8, размер 7 |
3 | Массив int8, размер 3 |
Ниже показаны примеры разбора двоичного формата.
Пример 1
Двоичные данные:
b'VYQ\x02\x00%\x00\x00\x00\x86=\xf7ZL\x9c\xeb\xbf`n\x8c\x0f}f\xee\xbf\x16W\x02'
(b'\x00E\x00\x00\x00M\x00\xc92cx|\xea\x8cI\xe6\xdd2|\x90\x02\xe6\xa4>'
b"\x93\xb3\x95 g\x88\x1a\xd2.\xe0\xe5\xe8\x00\xeb=\x1c\x9a'\x00\x00"
b'\x006\x00\x00\x00\xaf\xba\xff\xb1\xe9)\xf5\x89\xf4}\xd7K\xc93\xdcx\xb3-KZ')
Результат разбора:
'A1': 'cx',
{'A2': -0.862829377810997,
'A3': -0.9500108054812237,
'A4': 22294,
'A5': [{'B1': {'C1': 124, 'C2': 10411252367206485226},
'B2': 0.3220673203468323,
'B3': 45971},
'B1': {'C1': 149, 'C2': 16564290909391841056},
{'B2': 0.11474782228469849,
'B3': 39452}],
'A6': {'D1': [-17745, -19969, 10729, -30219, 32244],
'D2': [215, 75, 201, 51, 220, 120, 179],
'D3': [45, 75, 90]},
'A7': 13001}
Пример 2
Двоичные данные:
b'VYQ\x02\x00%\x00\x00\x00\x00<\xb6]1\xd6\x97?x\xa5\xdcH(\xb0\xca'
(b'\xbf\x8d\x80\x02\x00E\x00\x00\x00M\x00-!cj\xc2R\xfcp1\x10\x08\xf3C"a\xb7>'
b"cRj\xad\\r\xc0\x0f\x9c^\x02\xab\xd8_?\x92w'\x00\x00\x006\x00\x00"
b'\x00\xbb\x0fA\x08\x87\xf7+\xa6\xa3-Y\xbcSN\x8bl\xca\xb8\xa4\x98')
Результат разбора:
'A1': 'cj',
{'A2': 0.023278018326490013,
'A3': -0.2085008960505481,
'A4': 32909,
'A5': [{'B1': {'C1': 194, 'C2': 4896266085523848274},
'B2': 0.35816293954849243,
'B3': 21091},
'B1': {'C1': 106, 'C2': 170745427353820333},
{'B2': 0.8743998408317566,
'B3': 30610}],
'A6': {'D1': [4027, 2113, -2169, -22997, 11683],
'D2': [89, 188, 83, 78, 139, 108, 202],
'D3': [-72, -92, -104]},
'A7': 8493}
Задача №12
Реализовать разбор двоичного формата данных. Данные начинаются с сигнатуры 0xc9 0x52 0x4d 0x41 0x53
, за которой следует
структура A. Порядок байт: от старшего к младшему. Адреса указаны в виде смещений от начала данных. В решении предлагается использовать
модуль struct.
Структура A:
Поле | Описание |
---|---|
1 | uint16 |
2 | Адрес (uint32) структуры B |
3 | int32 |
4 | Размер (uint32) и адрес (uint16) массива char |
5 | int64 |
6 | Структура E |
Структура B:
Поле | Описание |
---|---|
1 | uint8 |
2 | Адрес (uint32) структуры C |
Структура C:
Поле | Описание |
---|---|
1 | uint32 |
2 | Массив структур D, размер 2 |
3 | float |
4 | uint8 |
Структура D:
Поле | Описание |
---|---|
1 | int8 |
2 | uint16 |
Структура E:
Поле | Описание |
---|---|
1 | int16 |
2 | uint16 |
3 | Размер (uint32) и адрес (uint16) массива uint64 |
4 | Массив int8, размер 5 |
Ниже показаны примеры разбора двоичного формата.
Пример 1
Двоичные данные:
b'\xc9RMASGq\x00\x00\x00;4\x1e.Q\x00\x00\x00\x02\x00@R\x83\xe1Z8?e'
(b'\xac\x86\xc2]k\x00\x00\x00\x05\x00Bo\xd3,a\x18\xb7\x17}C\x96\xd2\x00\xc2'
b'\xe2\xe8?$\xca;\x91\xcc\x00\x00\x00,ta\x97\xbfE\xedcp\x94\x1f*)\xbdV\x00\xdc'
b'1#\xdb~\xe2\xc6vL\x86\xf6\x02\xa1,\x90\xa0\xcd\x14\x82\x8d\xce\x16\xb1+\xa9'
b'\xbcD')
Результат разбора:
'A1': 18289,
{'A2': {'B1': 204,
'B2': {'C1': 3071769923,
'C2': [{'D1': -106, 'D2': 53760}, {'D1': -62, 'D2': 58088}],
'C3': 0.6437107920646667,
'C4': 145}},
'A3': 874393169,
'A4': 'ta',
'A5': 5945843710666171820,
'A6': {'E1': -31038,
'E2': 23915,
'E3': [10934535306156741663,
3038167600717377827,
15816328283387889398,
189481659010978946,
10218129554747800644],
'E4': [111, -45, 44, 97, 24]}}
Пример 2
Двоичные данные:
b'\xc9RMAS\xc9\x11\x00\x00\x00;\x99\r\xf5\x97\x00\x00\x00\x02\x00@\x05\x04\x94'
(b"\xfe\xd4\x05\x95.\xddN\xc5'\x00\x00\x00\x06\x00B\x05AO\xad\x00,\xfe\x9bj"
b'\xe2~8N\x02.\xbf$\x04\x9e\xe9 \x00\x00\x00,ui\xd5\xad\x0e\xb6\x85&\x10^D('
b'\xde\x97 PM\x04NQ@\x13B\x87\xd6\xb6\xf7\x93PE\x03\xa6%\x04\xa4I\xc9Ko\xc0'
b'\xec%\xba\xf5\x82O\xcc\x94h\xbe')
Результат разбора:
'A1': 51473,
{'A2': {'B1': 32,
'B2': {'C1': 754883434,
'C2': [{'D1': -30, 'D2': 32312}, {'D1': 78, 'D2': 558}],
'C3': -0.6406954526901245,
'C4': 233}},
'A3': -1727138409,
'A4': 'ui',
'A5': 361577692296221998,
'A6': {'E1': -8882,
'E2': 50471,
'E3': [15396978878130294878,
4911420134311087364,
5643362259536697014,
17839690806288852228,
11838214421354703909,
13471817139595012286],
'E4': [5, 65, 79, -83, 0]}}
Задача №12
Реализовать разбор двоичного формата данных. Данные начинаются с сигнатуры 0xa3 0x53 0x4e 0x59 0x59
, за которой следует
структура A. Порядок байт: от младшего к старшему. Адреса указаны в виде смещений от начала данных. В решении предлагается использовать
модуль struct.
Структура A:
Поле | Описание |
---|---|
1 | Адрес (uint16) структуры B |
2 | uint64 |
3 | uint16 |
Структура B:
Поле | Описание |
---|---|
1 | Адрес (uint16) структуры C |
2 | int8 |
3 | Массив int8, размер 6 |
Структура C:
Поле | Описание |
---|---|
1 | int8 |
2 | uint16 |
3 | Массив структур D, размер 4 |
4 | Массив int64, размер 4 |
5 | uint8 |
6 | Размер (uint16) и адрес (uint16) массива int8 |
7 | uint32 |
Структура D:
Поле | Описание |
---|---|
1 | int8 |
2 | uint8 |
3 | int16 |
4 | Массив uint8, размер 5 |
5 | uint16 |
6 | uint32 |
Ниже показаны примеры разбора двоичного формата.
Пример 1
Двоичные данные:
b'\xa3SNYY{\x00\xd4\xb0\x86\xf9W%\xdb\xd4\xf9r\xc1@&i\xad\xe340C\x85\x0f'
(b'\xcev\xa92\x9b\xd0@\xc6F{\x1f\x007x\xb2M\xfb-\xfb\xb8d\xcf\xd3d\xcdAt3'
b'$\x0f\x92:\xec\xd6hT\x03\xf7\xb8\xddUZ\xac8\xf8\xace\xf4\xc2.\x0f\x9d'
b'R\x0f\xd8\x1e\x19\xcb\xe5\x96>\xa2\xfd\x92\x1f\xe4\xe0{\xca:!\xcf'
b'\x9c\xa3\xeeS?\x7f8<\xb8`#\xe2\xac\x0b\xdf\x02\x00\x11\x00u@D\xd4\x13'
b'\x00B\n\xc5`\x87\x11@')
Результат разбора:
'A1': {'B1': {'C1': 38,
{'C2': 44393,
'C3': [{'D1': -29,
'D2': 52,
'D3': 17200,
'D4': [133, 15, 206, 118, 169],
'D5': 39730,
'D6': 1187397840},
'D1': 123,
{'D2': 31,
'D3': 14080,
'D4': [120, 178, 77, 251, 45],
'D5': 47355,
'D6': 1691602788},
'D1': -51,
{'D2': 65,
'D3': 13172,
'D4': [36, 15, 146, 58, 236],
'D5': 26838,
'D6': 3103195988},
'D1': -35,
{'D2': 85,
'D3': -21414,
'D4': [56, 248, 172, 101, 244],
'D5': 11970,
'D6': 257072399}],
'C4': [-6755796477310066984,
4236334605325538045,
9169139650761903905,
841295871985859640],
'C5': 223,
'C6': [-63, 64],
'C7': 3561242741},
'B2': 66,
'B3': [10, -59, 96, -121, 17, 64]},
'A2': 15337894015719092436,
'A3': 29433}
Пример 2
Двоичные данные:
b'\xa3SNYY|\x00\xf8\xdfl\x88\xcb2f\x1c6N9\x9c\xb3\xdc\xd9\xb6M\x12\x1d\xa5\x93'
(b'\xb2\xbc*\x19Lt{p]:\x1f\xe2\x16\x9e\xd4]N\n\x0c\x82\xdd\xcdy*7\xe2\xab\xc7'
b'\xa5o\x1d;\xc4\xb6\xa5\x8cmx>o\r\x86\xa3\xe2f5\xf1\xab\x01\xb2\x1eE'
b'\x07\xed\x10\x8eBTu\xb1\xebc\xe7\x00\x84\xc7\xb8a,v;CNA\x10\x92'
b'\xd5\xf6\xb3\xd2\xfa\x0e\x91g\xc0\xa8\x99\xa2\x03\x00\x11\x00\xb6\x00\xedY'
b'\x14\x00\x1aba~\xf0\xf0\xb6')
Результат разбора:
'A1': {'B1': {'C1': -36,
{'C2': 46809,
'C3': [{'D1': 77,
'D2': 18,
'D3': -23267,
'D4': [147, 178, 188, 42, 25],
'D5': 29772,
'D6': 979202171},
'D1': 31,
{'D2': 226,
'D3': -25066,
'D4': [212, 93, 78, 10, 12],
'D5': 56706,
'D6': 925530573},
'D1': -30,
{'D2': 171,
'D3': -23097,
'D4': [111, 29, 59, 196, 182],
'D5': 36005,
'D6': 1866365037},
'D1': 13,
{'D2': 134,
'D3': -7517,
'D4': [102, 53, 241, 171, 1],
'D5': 7858,
'D6': 283969349}],
'C4': [-1773314680843648370,
4284660893713138688,
-5478957073334972861,
-7374432838771344686],
'C5': 162,
'C6': [57, -100, -77],
'C7': 1508704438},
'B2': 26,
'B3': [98, 97, 126, -16, -16, -74]},
'A2': 2046378930435055608,
'A3': 20022}
Задача №12
Реализовать разбор двоичного формата данных. Данные начинаются с сигнатуры 0x59 0x52 0x50
, за которой следует структура A.
Порядок байт: от старшего к младшему. Адреса указаны в виде смещений от начала данных. В решении предлагается использовать модуль
struct.
Структура A:
Поле | Описание |
---|---|
1 | double |
2 | Структура B |
3 | int16 |
4 | int64 |
5 | uint32 |
6 | float |
7 | Размер (uint16) и адрес (uint32) массива структур D |
Структура B:
Поле | Описание |
---|---|
1 | Массив char, размер 6 |
2 | int64 |
3 | Размер (uint32) и адрес (uint32) массива int64 |
4 | float |
5 | uint64 |
6 | Адрес (uint32) структуры C |
7 | uint16 |
8 | uint8 |
Структура C:
Поле | Описание |
---|---|
1 | uint64 |
2 | double |
Структура D:
Поле | Описание |
---|---|
1 | Размер (uint32) и адрес (uint16) массива int16 |
2 | Массив uint8, размер 4 |
3 | uint8 |
4 | uint32 |
5 | uint16 |
Ниже показаны примеры разбора двоичного формата.
Пример 1
Двоичные данные:
b'YRP?\xc4\x14\xb3\x01\xc8\x92\xe0bxgzxh#t\xfd\x8ad\xaf\x99g\x00\x00\x00'
(b'\x02\x00\x00\x00L\xbf\x0c\x00\xec\xf8O\x84\xb33\xc6\x1a>\x00\x00\x00'
b'\\\xaa\x1d\xc0De6"\x00\x92\xebA\xae4T\xa44L>f\xfd\xaf\x00\x02\x00\x00\x00z'
b'Pw\xee\xea\x08}\x14\xf0\xea:f\r?H\r\xb9D\xd0\xaeF\x18M\xb0\x1b?\xdb\x0b\xe7'
b'K\xe5*\x98p\xf2\xb9\xbc\x8aK\xdaPC\xc3\xf56".\x00\x00\x00\x04\x00lt\x00`\xe0'
b'\x1f\x9e\x19y\xdc\x90\xfc\x00\x00\x00\x03\x00t\x12d\x9a.\r\xf8\x8c\xbe\xac.b')
Результат разбора:
'A1': 0.15688169085583237,
{'A2': {'B1': 'bxgzxh',
'B2': 2554945659462457703,
'B3': [5798365734194975984, -1568829313102901831],
'B4': -0.546889066696167,
'B5': 17892665749768903230,
'B6': {'C1': 4958654805813604379, 'C2': 0.422601532093418},
'B7': 43549,
'B8': 192},
'A3': 17509,
'A4': 3900680858268446260,
'A5': 1420047436,
'A6': 0.22557710111141205,
'A7': [{'D1': [28914, -17988, -30133, -9648],
'D2': [116, 0, 96, 224],
'D3': 31,
'D4': 2652469724,
'D5': 37116},
'D1': [17347, -2762, 8750],
{'D2': [18, 100, 154, 46],
'D3': 13,
'D4': 4169973420,
'D5': 11874}]}
Пример 2
Двоичные данные:
b'YRP?\xe5\xc9e\xc5\xfb\xcf.pbfesdg\xac\x00 \xaf\xf7eO\x00\x00\x00'
(b'\x02\x00\x00\x00L\xbe\x93\x12\x16\x80y\xbc\x04N\xbf\xcf^\x00\x00\x00'
b'\\\xa5\xf3o\xdd\xe3\xc7*n\xea;\xbb("ZOL\x8a\xbff\x1f\xd5\x00\x02'
b'\x00\x00\x00z7\xfd\x99\x18W\x06\x1d\xa7\xb4\xcb"\xba\xbd\x19/\x0co\xa6\\\x07'
b'\xb11@#?\xe6r\xe8\x1c\xa6\xc9\x92H\x1chX\x1c\xde\x03z\xef\x1b\xe3"IK\x00\x00'
b'\x00\x03\x00l2E\xf7\x17W\xaa\x13\xc6\x82\x7f$\x00\x00\x00\x04\x00re\xa3\x03'
b'-\x91;5\x00H\x97\x1d')
Результат разбора:
'A1': 0.6808346621387267,
{'A2': {'B1': 'pbfesd',
'B2': 7470346022291989839,
'B3': [4034549171012115879, -5419199541178454260],
'B4': -0.28724735975265503,
'B5': 9257637235723849566,
'B6': {'C1': 8045218972451291171, 'C2': 0.7015266952133052},
'B7': 42483,
'B8': 111},
'A3': -8733,
'A4': -4095338958836520926,
'A5': 1515146378,
'A6': -0.8989232182502747,
'A7': [{'D1': [18460, 26712, 7390],
'D2': [50, 69, 247, 23],
'D3': 87,
'D4': 2853422722,
'D5': 32548},
'D1': [890, -4325, -7390, 18763],
{'D2': [101, 163, 3, 45],
'D3': 145,
'D4': 993329224,
'D5': 38685}]}
Задача №12
Реализовать разбор двоичного формата данных. Данные начинаются с сигнатуры 0x14 0x41 0x42 0x53 0x49
, за которой следует
структура A. Порядок байт: от младшего к старшему. Адреса указаны в виде смещений от начала данных. В решении предлагается использовать
модуль struct.
Структура A:
Поле | Описание |
---|---|
1 | uint32 |
2 | int64 |
3 | int8 |
4 | Структура B |
5 | uint8 |
Структура B:
Поле | Описание |
---|---|
1 | Массив структур C, размер 2 |
2 | int8 |
3 | Размер (uint16) и адрес (uint16) массива int16 |
4 | Структура F |
5 | Массив int16, размер 2 |
6 | int16 |
Структура C:
Поле | Описание |
---|---|
1 | int32 |
2 | int32 |
3 | Адрес (uint16) структуры D |
4 | Структура E |
5 | int32 |
6 | int16 |
Структура D:
Поле | Описание |
---|---|
1 | uint8 |
2 | Массив float, размер 3 |
3 | int8 |
4 | double |
5 | int16 |
6 | int64 |
Структура E:
Поле | Описание |
---|---|
1 | double |
2 | int16 |
Структура F:
Поле | Описание |
---|---|
1 | float |
2 | Массив int8, размер 8 |
Ниже показаны примеры разбора двоичного формата.
Пример 1
Двоичные данные:
b'\x14ABSI\x0fy\xd1\xee\xd9oJn\x9f\x148\xcd\xda\x1c\x1b\xc0\xb0\xaa-'
(b'\xff\r^\x00\xec1\xce\xd3\xf1\x19\xde\xbf\x97\xc8\x9e,\x8c\xa1.\xa9'
b'\x1d\xda\xf3\x80\xe2\x08\x0bg~\x00~^(=7\xb7\xe0\xbfc\x04_i\x86\xdb'
b'\xf1v\xa4\x03\x00\x9e\x004\x00a?.p\xc7|=\xf3\xf3\xf5\xb1\xfb\x86z\x83'
b'p\xfc%\xc1\x932\xbf(\xead\xbf\x8f\xb8\xef\xbe\x8eHWf\x00\xf9\x04\xed?\t0^h'
b'm\x07\xba\xc8\x9c\xd8{7@\xf9>\xae\x90H?\xbc\x04??\xb7\xf0\x97dR'
b'\xf1\x8c\xd2\xbf\x06^NN\x7f\x872\x83Q\xb2Z\xe6g\xe6Y\x85')
Результат разбора:
'A1': 4006705423,
{'A2': -3659152022255800359,
'A3': -38,
'A4': {'B1': [{'C1': -1329587428,
'C2': 234827178,
'C3': {'D1': 37,
'D2': [-0.6975670456886292,
-0.894197940826416,
-0.46820494532585144],
'D3': -114,
'D4': 0.9068570144470209,
'D5': 12297,
'D6': -2838172963836172194},
'C4': {'E1': -0.4703335350430098, 'E2': -14185},
'C5': -1584649058,
'C6': -22226},
'C1': -2131502563,
{'C2': 1728776418,
'C3': {'D1': 123,
'D2': [0.4868180453777313,
0.7834576368331909,
0.7461659908294678],
'D3': -73,
'D4': -0.28985245748697164,
'D5': 24070,
'D6': -5597548608799945138},
'C4': {'E1': -0.5223652071462792, 'E2': 1123},
'C5': -611948193,
'C6': 30449}],
'B2': -92,
'B3': [-6566, -6553, -31399],
'B4': {'F1': 0.8789093494415283,
'F2': [46, 112, -57, 124, 61, -13, -13, -11]},
'B5': [-1103, 31366],
'B6': 28803},
'A5': 252}
Пример 2
Двоичные данные:
b"\x14ABSI\x19\x80'\x15\xb6\x9d_\xca\x17w\x94!\xbf\x99c;\x12}\x97\xc02^\x00"
(b'\x8cu\x1a\xee\x1e\xa8\xec\xbf\x81\x15\r\x0e\x9b\x96\x87\x9fI,\xa7\x0f'
b'^\t\xd6\xea~\x00\xa0\xebTzL\xce\xb9?\xc7\xa2\rz\x1d\x94\x14\x82k\x03'
b'\x00\x9e\x00\xd4sA\xbf:\xc5\xa1\x19H\x1c\xd2\xe5\xdbh7\xcdu\x96\x11\xab\xee'
b'\xf9\xeb\xbdqlR>\xdb\x10"?\xd7\x00\x9b\xa4\x86\xf9J\x8a\xbfq\x03\xe3\x83A$^.'
b'|\x01Y\x99\xac\x16?\x0c\xefL\xbd\xa5\x95o?\xdc\x88\xb7\x03p\xefl\xeb?'
b'\xb3H\x7f\xe0\xbb\x18\x19p\xcb#\x11\xc1\xe6"\x84\xce')
Результат разбора:
'A1': 354910233,
{'A2': 2419689843868016054,
'A3': -65,
'A4': {'B1': [{'C1': 305882009,
'C2': 851482493,
'C3': {'D1': 171,
'D2': [-0.11522279679775238,
0.2054917961359024,
0.6330696940422058],
'D3': -41,
'D4': -0.012838315412023515,
'D5': 881,
'D6': 107011473020126179},
'C4': {'E1': -0.8955225611168074, 'E2': 5505},
'C5': -1768223219,
'C6': -24697},
'C1': 262614089,
{'C2': -355071650,
'C3': {'D1': 89,
'D2': [0.5885711312294006,
-0.050032660365104675,
0.9358771443367004],
'D3': -36,
'D4': 0.8570477664741114,
'D5': 18611,
'D6': 2579278464691200127},
'C4': {'E1': 0.10080411898245112, 'E2': -23865},
'C5': -1810007539,
'C6': -32236}],
'B2': 107,
'B3': [-16111, 8934, -12668],
'B4': {'F1': -0.7556736469268799,
'F2': [58, -59, -95, 25, 72, 28, -46, -27]},
'B5': [26843, -13001],
'B6': -27019},
'A5': 17}
Задача №12
Реализовать разбор двоичного формата данных. Данные начинаются с сигнатуры 0x49 0x53 0x4a 0x56 0x70
, за которой следует
структура A. Порядок байт: от старшего к младшему. Адреса указаны в виде смещений от начала данных. В решении предлагается использовать
модуль struct.
Структура A:
Поле | Описание |
---|---|
1 | uint16 |
2 | Структура B |
Структура B:
Поле | Описание |
---|---|
1 | Массив структур C, размер 4 |
2 | Размер (uint16) и адрес (uint16) массива int8 |
3 | Структура D |
Структура C:
Поле | Описание |
---|---|
1 | int8 |
2 | Массив int8, размер 7 |
3 | float |
Структура D:
Поле | Описание |
---|---|
1 | uint64 |
2 | Массив int64, размер 4 |
3 | Размер (uint16) и адрес (uint16) массива int16 |
Ниже показаны примеры разбора двоичного формата.
Пример 1
Двоичные данные:
b'ISJVp\xba\x11\x91\xd9\xd7\xa7q\xf7z\x0c\xbf8\x92\x0f\x89\x93\xc4\xebF'
(b'&\xf8\x9d>?\x8598\xa5\xf0\x93\xd5\xb9A+?2mj\xe5\x98\x08\xa7B\x9c\xbb\x05?'
b']\x15\x16\x00\x07\x00g\xa6\x83\x7f\x18z\x9a$\x18I\xae\xbe\xd5.'
b'\xeb\xf6\xd8\xdc\xceis}\xd5\x89\x10\xf6\xe7\x07Ap\xe7\x08\xd3\x1dcS\xb1\xf8'
b'\x04\xa5\xfe\x00\x02\x00n\xdb\twT\x0c\xad\x19\xe9R\xb9:')
Результат разбора:
'A1': 47633,
{'A2': {'B1': [{'C1': -111,
'C2': [-39, -41, -89, 113, -9, 122, 12],
'C3': -0.7209786772727966},
'C1': -119,
{'C2': [-109, -60, -21, 70, 38, -8, -99],
'C3': 0.18703164160251617},
'C1': 56,
{'C2': [-91, -16, -109, -43, -71, 65, 43],
'C3': 0.6969820261001587},
'C1': -27,
{'C2': [-104, 8, -89, 66, -100, -69, 5],
'C3': 0.8636029958724976}],
'B2': [-37, 9, 119, 84, 12, -83, 25],
'B3': {'D1': 11998573575357998104,
'D2': [5309390833540921048,
-2535973595409708784,
-655547243110659885,
2117628273629636094],
'D3': [-5806, -18118]}}}
Пример 2
Двоичные данные:
b'ISJVpDr\x16\xf3\xe7\x99!\xf0)\xae\xbd\xb5\xb1\x11ln\x1b1F\x17k\xe5>'
(b"\xfc\x10\xad\xcb\x89\x00\xe5\xa4K'P\xbe\n\xb2\x04\xf9\xa9\xce\x1e{"
b'\xd4\xc0\xe1>\x801G\x00\x07\x00g\xef\xc0d\xdeI\x8c/`\x8el\x1c\xc6!'
b'\xaa>\xc5\xf3\xaf\xbf\x04\xf2p\xe7\xc3\x90\xa8\xf2\x17\x133?\xd7>\x04\xf459'
b'\x11E\x8b\x00\x03\x00n\x11\x02\x0e\xc4\xb6\x97\x08\xb64\xb5x\x06}')
Результат разбора:
'A1': 17522,
{'A2': {'B1': [{'C1': 22,
'C2': [-13, -25, -103, 33, -16, 41, -82],
'C3': -0.08871663361787796},
'C1': 108,
{'C2': [110, 27, 49, 70, 23, 107, -27],
'C3': 0.49231472611427307},
'C1': -53,
{'C2': [-119, 0, -27, -92, 75, 39, 80],
'C3': -0.13544470071792603},
'C1': -7,
{'C2': [-87, -50, 30, 123, -44, -64, -31],
'C3': 0.2503759562969208}],
'B2': [17, 2, 14, -60, -74, -105, 8],
'B3': {'D1': 17275919076472663904,
'D2': [-8184134785545126203,
-887280573600438333,
-8022896555240243241,
4468965239686251915],
'D3': [-18892, -19080, 1661]}}}
Задача №12
Реализовать разбор двоичного формата данных. Данные начинаются с сигнатуры 0xc 0x47 0x4c 0x4c
, за которой следует структура
A. Порядок байт: от младшего к старшему. Адреса указаны в виде смещений от начала данных. В решении предлагается использовать модуль
struct.
Структура A:
Поле | Описание |
---|---|
1 | double |
2 | Размер (uint32) и адрес (uint32) массива структур B |
3 | Массив int8, размер 4 |
4 | uint64 |
5 | Структура D |
Структура B:
Поле | Описание |
---|---|
1 | uint64 |
2 | int16 |
3 | int8 |
4 | uint32 |
5 | Размер (uint16) и адрес (uint32) массива char |
6 | Адрес (uint32) структуры C |
7 | int32 |
Структура C:
Поле | Описание |
---|---|
1 | float |
2 | uint8 |
3 | Размер (uint32) и адрес (uint16) массива int8 |
4 | int64 |
5 | uint8 |
Структура D:
Поле | Описание |
---|---|
1 | int16 |
2 | uint32 |
3 | double |
4 | int8 |
5 | double |
6 | int16 |
7 | double |
Ниже показаны примеры разбора двоичного формата.
Пример 1
Двоичные данные:
b'\x0cGLL\\|\x04\xd4hH\xd9?\x02\x00\x00\x00t\x00\x00\x00\xf0\xac\xe9c'
(b'N@\x08\x124\xd8\xc3g\x85 f\x84\x85!\xe0\x86\xd9/\x88s\xe1\xbf\x98T'
b'\xa0\x85\xf5\xe6\xff\xe6\xbf\xf6\x07\x8c\xf3\xca;\x13\xaa\xde\xbfxe\x93'
b's\xf9z\xd2\xd9\xbe\xcf\x03\x00\x00\x00C\x00\x8c\xe7\x8e\xc8P\x0c\xfaD\xbdrh'
b'b\x15\x9f#:\x9cG\xbf\xb8\x04\x00\x00\x00\\\x00\xd9(\xda\xbel\\\xb4Q\x04'
b'|Y\xd9\x1c\xc2\x90\xf4\x97Z\xa3H\xc1\xdb\x8f\x86\x02\x00A\x00\x00'
b'\x00F\x00\x00\x00\xf9e\xa1,\xc4b}JB@\xf1\xf4\x8f\xd5\xf6\xf8\xc1N\xa8'
b'\x02\x00Z\x00\x00\x00`\x00\x00\x00\xa6\xbdx\x13')
Результат разбора:
'A1': 0.39504452423893155,
{'A2': [{'B1': 10949535757426579836,
'B2': -23718,
'B3': 72,
'B4': 2257574849,
'B5': 'xe',
'B6': {'C1': -0.4254339337348938,
'C2': 207,
'C3': [-109, 115, -7],
'C4': 4970298679858489228,
'C5': 189},
'B7': 748774905},
'B1': 17649959068103434948,
{'B2': -10865,
'B3': -10,
'B4': 2823733752,
'B5': 'rh',
'B6': {'C1': -0.779727578163147,
'C2': 184,
'C3': [98, 21, -97, 35],
'C4': 5887432235008272601,
'C5': 4},
'B7': 326679974}],
'A3': [-16, -84, -23, 99],
'A4': 7477057524517584974,
'A5': {'D1': 8325,
'D2': 562398310,
'D3': -0.5453530249180538,
'D4': -104,
'D5': -0.7187380595542074,
'D6': 2038,
'D7': -0.47913056220186756}}
Пример 2
Двоичные данные:
b'\x0cGLL\xa0\\A \xfe\xbb\xc9\xbf\x02\x00\x00\x00v\x00\x00\x00aa\x91\xf4'
(b'\x12{\xfb\xe2R\xdcZ\xe7\xa3\xa2\xa1\xdd*\xf80\xa7\x03\x12\xaa\xd9\xc7\xbf}@'
b'\xf1\xd8\xb4\xb6\x11\xb0\xbf\xab4\xa4F\xc8\xae!G\xe7?lc s-\x16\xc2m)>\xb1'
b'\x04\x00\x00\x00C\x00\xfb\xa2\x8d\xdc\xed\nQ\x82>ks\xbfw\x06\xc4\xae\xb1\xdf'
b'C\xbe0\x05\x00\x00\x00]\x00\x84\x98\xdc-\x07\xa2\xad\xe0\xc0s\xeb<E\x9a\xd3'
b'\xdf!\xb9m\xa5\x10\xaa\xe9h\x02\x00A\x00\x00\x00G\x00\x00\x00\x88'
b'\x8c\x90\xa8!N\xc2\x13@\xc5\x9c\xaa\xaa\xe1\xe2j\xe1\xe8=\x02\x00'
b'[\x00\x00\x00b\x00\x00\x00\x8c?\x8aT')
Результат разбора:
'A1': -0.20104958128897454,
{'A2': [{'B1': 2440902182598142835,
'B2': 28089,
'B3': -91,
'B4': 1760143888,
'B5': 'lc',
'B6': {'C1': 0.16545775532722473,
'C2': 177,
'C3': [32, 115, 45, 22],
'C4': -9056445358941560069,
'C5': 62},
'B7': -1466921848},
'B1': 12293917961814691361,
{'B2': -7766,
'B3': -30,
'B4': 1038672234,
'B5': 'ks',
'B6': {'C1': -0.19128300249576569,
'C2': 48,
'C3': [-65, 119, 6, -60, -82],
'C4': -2256969686524847996,
'C5': 192},
'B7': 1418346380}],
'A3': [97, 97, -111, -12],
'A4': 16670879219218873106,
'A5': {'D1': -23901,
'D2': 4163558817,
'D3': -0.1863300884208967,
'D4': 125,
'D5': -0.06277028956623543,
'D6': 13483,
'D7': 0.7274330533711759}}
Задача №12
Реализовать разбор двоичного формата данных. Данные начинаются с сигнатуры 0x4a 0x4c 0x56
, за которой следует структура A.
Порядок байт: от младшего к старшему. Адреса указаны в виде смещений от начала данных. В решении предлагается использовать модуль
struct.
Структура A:
Поле | Описание |
---|---|
1 | uint8 |
2 | Массив char, размер 4 |
3 | Структура B |
Структура B:
Поле | Описание |
---|---|
1 | Массив структур C, размер 5 |
2 | Массив int8, размер 6 |
3 | float |
4 | Адрес (uint16) структуры D |
5 | uint32 |
Структура C:
Поле | Описание |
---|---|
1 | uint8 |
2 | int16 |
3 | uint16 |
4 | uint32 |
Структура D:
Поле | Описание |
---|---|
1 | uint64 |
2 | uint64 |
3 | uint64 |
4 | int32 |
5 | int8 |
6 | uint64 |
7 | Массив int32, размер 7 |
Ниже показаны примеры разбора двоичного формата.
Пример 1
Двоичные данные:
b'JLV\xf8efjy<\x13\xc8\t>\x94\xc6>-\x03\xf8\x11\x0e\x90K\xb5Ra\xc1\x15'
(b':f\x96\xb9u\x10\x85\x1b\xba\x12\x0b\xc1\xfb\xa1`2-"\x9d\x11\xe1\xa8\x15\x97'
b'D\xba\xac\x95\x14\xe8B#s\x13\xbfE\x00`>\x9b\x9b\xd3\x1d/\x01\xf9\xe8\xcf'
b'\x99\xd8>xG\xac\x8f\xa8^\xc9\xa5\xcac\xe3[L\x0eS8\xacW\xb3G\x8d'
b'\xc9\\\xe0\xe5H\xc0%~\xd9FX\xfb\x84\x8f\xb1:\x1b\xcc\xad\xda\xd5\xf8\x14\x97'
b'\xa3\xbc\xb0\xbb\x87\x97\xff~0a')
Результат разбора:
'A1': 248,
{'A2': 'efjy',
'A3': {'B1': [{'C1': 60, 'C2': -14317, 'C3': 15881, 'C4': 759088788},
'C1': 3, 'C2': 4600, 'C3': 36878, 'C4': 1632810315},
{'C1': 193, 'C2': 14869, 'C3': 38502, 'C4': 2232448441},
{'C1': 27, 'C2': 4794, 'C3': 49419, 'C4': 845193723},
{'C1': 45, 'C2': -25310, 'C3': 57617, 'C4': 1150752168}],
{'B2': [-70, -84, -107, 20, -24, 66],
'B3': -0.5759755969047546,
'B4': {'D1': 11083333364146445779,
'D2': 6820859605748825816,
'D3': 1030299446950929865,
'D4': 1470904403,
'D5': -77,
'D6': 13855577005397478727,
'D7': [1188658725,
-1887110312,
-870630735,
-120202579,
-1130129644,
-1752712272,
1630568191]},
'B5': 2610642528}}
Пример 2
Двоичные данные:
b'JLV\xaduzky\xc4\xfb\xa4\x1dJ\xca\r\x11\x1e\x15\xdd\x80\xf7\x93\xd2\xd1'
(b'\xed?4\x14m,V5\xa0<\xdf\x19b\x9f\xae,\xab\xfb<&\xe4\x14\x98\xcc~\n\xc2V'
b'\x00\x9d\xd0\x1dC\xa0o\xf9\x86m?E\x00\x04\x19\x10\x14\xae\xc2\xf8'
b'\x1az\xe7\xd0\xe9K\x80V)\xc1\xff\x9aw}]\x05\xe2$\xc3\x7f{\r\x00L'
b'\\\xde\x0b\xd4\x08@\x00\xfe\xc9\xc5\xae\x9b0 p\x1c\xbf)wV\xd0HVz'
b'\xe5\xf7\xac\x19\x1c\xae\x8b\n\xe7\xc8\x92}D\x9a')
Результат разбора:
'A1': 173,
{'A2': 'uzky',
'A3': {'B1': [{'C1': 196, 'C2': -23301, 'C3': 18973, 'C4': 504434122},
'C1': 21, 'C2': -32547, 'C3': 37879, 'C4': 1072550354},
{'C1': 52, 'C2': 27924, 'C3': 22060, 'C4': 3745292341},
{'C1': 25, 'C2': -24734, 'C3': 11438, 'C4': 641530795},
{'C1': 228, 'C2': -26604, 'C3': 32460, 'C4': 5685770}],
{'B2': [-99, -48, 29, 67, -96, 111],
'B3': 0.9278407692909241,
'B4': {'D1': 16848220717617562286,
'D2': 8618482042014171211,
'D3': 8899045951885630845,
'D4': 1548484621,
'D5': -34,
'D6': 14252201772818420747,
'D7': [540056494,
700390512,
1221613175,
-135955882,
-1373890132,
-924382581,
-1706787438]},
'B5': 336599300}}
Задача №12
Реализовать разбор двоичного формата данных. Данные начинаются с сигнатуры 0x3e 0x4f 0x4e 0x43
, за которой следует структура
A. Порядок байт: от старшего к младшему. Адреса указаны в виде смещений от начала данных. В решении предлагается использовать модуль
struct.
Структура A:
Поле | Описание |
---|---|
1 | float |
2 | Структура B |
Структура B:
Поле | Описание |
---|---|
1 | uint16 |
2 | Размер (uint32) и адрес (uint16) массива char |
3 | Адрес (uint16) структуры C |
4 | Массив адресов (uint16) структур D, размер 3 |
5 | int64 |
6 | int8 |
7 | Адрес (uint16) структуры E |
8 | int16 |
Структура C:
Поле | Описание |
---|---|
1 | int32 |
2 | uint8 |
Структура D:
Поле | Описание |
---|---|
1 | Размер (uint32) и адрес (uint16) массива uint16 |
2 | Массив int32, размер 4 |
Структура E:
Поле | Описание |
---|---|
1 | uint8 |
2 | uint8 |
3 | int32 |
4 | Размер (uint32) и адрес (uint16) массива int8 |
Ниже показаны примеры разбора двоичного формата.
Пример 1
Двоичные данные:
b">ONC?<\xcc\xc09'\x00\x00\x00\x02\x00%\x00'\x000\x00P\x00n\xea\xbc\x16\xe4"
(b'1\xd3+\xf9\xf6\x00\x8b\x1f\x85vz\x89J\xae\xe7\xf0\xf0x,\x11\x00\x00\x00\x02'
b"\x00,\xa0\xe8\x98\x01\xd1E_\x1f\xbc\xe0\xc1\xba \xeb\x0f7\x85Y\xc1\xa8\xa9'"
b'\x1c\xae\xac\xa3\x00\x00\x00\x05\x00F\xaa\xab\xb4\xbaT\x8d\x9b\xda\x8e\xa2'
b'\xadi\x0c\xbc\xeb\x89>\xc4\xa1gJI\xa1\xd0\x00\x00\x00\x04\x00f]\x97\xc2\x90'
b'\xec\xdc\xe2\xcc\x15i1*\xd6\x98\xd2\x0b\xfc\xb7\xbb\xea\x041\x05F'
b'\xcd\xb8\x89\xb1=\x00\x00\x00\x07\x00\x84')
Результат разбора:
'A1': 0.7374992370605469,
{'A2': {'B1': 14631,
'B2': 'vz',
'B3': {'C1': -1991594265, 'C2': 240},
'B4': [{'D1': [61560, 11281],
'D2': [-1595369471, -783982817, -1126121030, 552275767]},
'D1': [34137, 49576, 43303, 7342, 44195],
{'D2': [-1431587654, 1418566618, -1901941399, 213707657]},
'D1': [16068, 41319, 19017, 41424],
{'D2': [1570226832, -321068340, 359215402, -694627829]}],
'B5': -1532324603868533767,
'B6': -10,
'B7': {'E1': 70,
'E2': 205,
'E3': -1198935747,
'E4': [-4, -73, -69, -22, 4, 49, 5]},
'B8': 8069}}
Пример 2
Двоичные данные:
b'>ONC\xbf\x11\x1b\xad$m\x00\x00\x00\x03\x00%\x00(\x005\x00W\x00u'
(b'\xc6\x82\xbd\x96\xb4\xa6\xa1E\xe2\x00\x92\xdd\x18ggg\x0e\xcf\x83\x84'
b'\xc5X\xc5\xec\x98\x18\xc4\xda\x91\x00\x00\x00\x04\x00-\xb7\x94\x15\x92\x1c'
b'o=\x13\x8b\x9d\x85<\xdc\xefzr\x86b\x85\x81\x1b\t\xd9\x1ch\x1b\xf8\x99\x00'
b'\x00\x00\x06\x00KQ\xba:K\xae\xeeu\x0c\xad\xc1wM\xc7\xeco\xc6\x88\xa4\x05'
b'Q\xba\xa6\xfd?\x00\x00\x00\x04\x00m\xd3\x8c\xb2m\xaa\xcetz\x0b7\xb2 j'
b'\x9b\x99\xefK?\x1d\xf8$\xf1\x16\xff\x0c\xaefD\xa7\x00\x00\x00\x07\x00\x8b')
Результат разбора:
'A1': -0.5668285489082336,
{'A2': {'B1': 9325,
'B2': 'ggg',
'B3': {'C1': 248480644, 'C2': 197},
'B4': [{'D1': [22725, 60568, 6340, 55953],
'D2': [-1215031918, 477052179, -1952611012, -588285326]},
'D1': [34402, 34177, 6921, 55580, 26651, 63641],
{'D2': [1371159115, -1360104180, -1379829939, -940806202]},
'D1': [34980, 1361, 47782, 64831],
{'D2': [-745754003, -1429310342, 188199456, 1788582383]}],
'B5': -4142540252253871803,
'B6': -30,
'B7': {'E1': 255,
'E2': 12,
'E3': -1369029465,
'E4': [75, 63, 29, -8, 36, -15, 22]},
'B8': -8936}}
Задача №12
Реализовать разбор двоичного формата данных. Данные начинаются с сигнатуры 0x29 0x48 0x46 0x4d
, за которой следует структура
A. Порядок байт: от младшего к старшему. Адреса указаны в виде смещений от начала данных. В решении предлагается использовать модуль
struct.
Структура A:
Поле | Описание |
---|---|
1 | uint16 |
2 | uint16 |
3 | Адрес (uint32) структуры B |
4 | int64 |
5 | uint8 |
6 | Структура D |
Структура B:
Поле | Описание |
---|---|
1 | uint32 |
2 | Размер (uint32) и адрес (uint32) массива char |
3 | uint8 |
4 | Массив адресов (uint16) структур C, размер 3 |
5 | Размер (uint16) и адрес (uint16) массива double |
6 | int64 |
Структура C:
Поле | Описание |
---|---|
1 | int32 |
2 | uint32 |
3 | uint16 |
Структура D:
Поле | Описание |
---|---|
1 | Размер (uint32) и адрес (uint32) массива int16 |
2 | uint64 |
Ниже показаны примеры разбора двоичного формата.
Пример 1
Двоичные данные:
b')HFM\x05\x18\xb3\xfbw\x00\x00\x00\xa1\xb88\xc7\x10 Q\xb7\x13\x03\x00\x00'
(b'\x00\x96\x00\x00\x00\xd4\xd1\x0f\xc2U\x04\x9a\x95fgna\r\xf6zi\xc2\x1f\x8c'
b')\xcf"\x0e\xc3\xa6c[\xc082\xc6M\xb5`\x84\xee\xc9 \xc9\xdcN\xcb\x06R\xcd\xc3N'
b'\x89\xe7\xbfx\x15\xde\x90\xc5z\xe4\xbf\x00$\xc0\x865f\x91\xbft\xfc\xf5\xa8n'
b'n\xdd?\xd4\x15\x12\xbfo\x95\xdd\xbf\x08s\xf6\x18%\xde\xd5\xbf\x90'
b'\x0e\xb1\xb6\x04\x00\x00\x00%\x00\x00\x00a)\x003\x00=\x00\x06\x00G\x00C '
b'\x8eH&\xf5e\x9eV\xf6\x1b3/\xc6')
Результат разбора:
'A1': 6149,
{'A2': 64435,
'A3': {'B1': 3065056912,
'B2': 'fgna',
'B3': 97,
'B4': [{'C1': 1769666061, 'C2': 697049026, 'C3': 8911},
'C1': 1671873294, 'C2': 842580059, 'C3': 19910},
{'C1': -293314379, 'C2': 3704168649, 'C3': 52046}],
{'B5': [-0.7355111908205465,
-0.6399867848819403,
-0.016991459226151306,
0.4598652505882861,
-0.46224588069193584,
-0.341683649423246],
'B6': -7032945698294325181},
'A4': -5237369635221227359,
'A5': 19,
'A6': {'D1': [-2474, 13083, -14801], 'D2': 10779933424439251412}}
Пример 2
Двоичные данные:
b')HFM7\xea\x9c\xee\x88\x00\x00\x00\x92\xd1\xf5.# +o\x80\x02\x00\x00'
(b'\x00\xa7\x00\x00\x00\x05\xd6_\xb2\x06\xc5\xd2\x82njzoz\xad\xe4\xdc\x8c)\xd9'
b'\xf4\xfe\xedUb\xec\xa4Z\x92S?\x9e\x87j\xf8\x19Q\xf0\xc8\xdc3\xbf\xda\xc7'
b'\x94tT\x99\x9dE\xef\xbf,5\xc5\xa2x\x96\xd2\xbf\xd0\xc8\x96\x04\x11X\xbb\xbf'
b'\xdc\x87\xfd\xd2\x17\x13\xe3\xbf\x809~\xe5\x05\xe6\x90?\xb6\xb8\xea#'
b'\xb0\x99\xe2?\xa8\xab*VY\xab\xdd\xbfB2\x97Z\xaa\xe7\xee\xbftXs\x9e'
b'\x05\x00\x00\x00%\x00\x00\x00"*\x004\x00>\x00\x08\x00H\x00\xcb\xc3x\x06\xcc'
b'\xa8\xc4\x9c\x18{\x0e;')
Результат разбора:
'A1': 59959,
{'A2': 61084,
'A3': {'B1': 2658359412,
'B2': 'njzoz',
'B3': 34,
'B4': [{'C1': -1931680595, 'C2': 4277459241, 'C3': 21997},
'C1': 1520757858, 'C2': 2654950290, 'C3': 27271},
{'C1': -263120392, 'C2': 3207847112, 'C3': 51162}],
{'B5': [-0.9772480005955395,
-0.2904340352586867,
-0.10681253778492139,
-0.5960806961922986,
0.016502468235154222,
0.5812607480527479,
-0.46358331122126595,
-0.965779473242556],
'B6': -7150404714122132533},
'A4': 8010531697692365202,
'A5': 128,
'A6': {'D1': [31512, 15118], 'D2': 9426813602592970245}}
Задача №12
Реализовать разбор двоичного формата данных. Данные начинаются с сигнатуры 0x49 0x4d 0x55 0x59
, за которой следует структура
A. Порядок байт: от старшего к младшему. Адреса указаны в виде смещений от начала данных. В решении предлагается использовать модуль
struct.
Структура A:
Поле | Описание |
---|---|
1 | Массив структур B, размер 2 |
2 | uint16 |
3 | Массив uint16, размер 2 |
4 | Структура C |
5 | Размер (uint32) и адрес (uint32) массива float |
6 | int8 |
7 | int64 |
Структура B:
Поле | Описание |
---|---|
1 | double |
2 | int8 |
3 | uint32 |
4 | int8 |
Структура C:
Поле | Описание |
---|---|
1 | int64 |
2 | Адрес (uint32) структуры D |
3 | float |
4 | uint32 |
Структура D:
Поле | Описание |
---|---|
1 | int8 |
2 | Массив float, размер 4 |
3 | double |
4 | uint32 |
Ниже показаны примеры разбора двоичного формата.
Пример 1
Двоичные данные:
b'IMUY\xbf\xdbF@\xa8>8\xb0p\x95\xcc\xe9\xdb\xaf?\xeb\xd8\x13\x80x\xf2J\x05W'
(b'M\xfd\xbb\xb8\xe8\x92=W}\xff\xc2\xc0\xf3+\xad\xdd\xe9\x07\x00\x00\x00K\xbfd'
b'\xf5|\x15\x82\xfc\x11\x00\x00\x00\x08\x00\x00\x00hL\x97\xda@tb\xa6A\xd1\x08'
b'\xbb\xabt\xce>\x96x\xa9>\xf0\x89A?=\xff|?\xdd\xa1\xab\xa1\xf7\x05\x10'
b'\x18\xa5@;\xbc\x9d\xd5\x06\xbeF3L>\xa7a\r\xbeR\xddu>\xb1pE>\x8e\x1a\x96'
b"\xbfa\xbd@='\xfb\xbe")
Результат разбора:
'A1': [{'B1': -0.4261628764151153, 'B2': 112, 'B3': 2513234395, 'B4': -81},
{'B1': 0.8701264867045861, 'B2': 5, 'B3': 1464729019, 'B4': -72}],
{'A2': 59538,
'A3': [15703, 32255],
'A4': {'C1': -4413260265896941305,
'C2': {'D1': 8,
'D2': [-0.005232430063188076,
0.2938893139362335,
0.46979716420173645,
0.7421796321868896],
'D3': 0.4629925805748636,
'D4': 413483067},
'C3': -0.8943707942962646,
'C4': 360905745},
'A5': [-0.01926661655306816,
-0.1935550570487976,
0.3269123136997223,
-0.2059229165315628,
0.34655967354774475,
0.27754658460617065,
-0.8817939758300781,
0.041011564433574677],
'A6': 76,
'A7': -7504614960444063279}
Пример 2
Двоичные данные:
b'IMUY?\xef\xff\x83y\xd8\xed\xa4\xc0\xbe\xa5\x97\x19\xd7\xbf\xea*X\x11\x83'
(b'7\x0c+\x01\xb5\xe8\x0em\x80\xd9\x15\xa6\xc4\x90\x98\xa9\xfc\xa3\x8c!'
b'\xe7\x89\x00\x00\x00K=0\xd5?\xe6H\xc0\x13\x00\x00\x00\x06\x00\x00'
b'\x00h\xcd\xd1\xf3\x11\xb2>\xa4\xf1h\x8c\xbe\x94\xd1>\xbd\x0e{\x89\xbf_\x04d'
b'\xbfH\xd4|\xbf\xed\x04A)\xf9\x07\xb2M\x1di\x95\xbf0\xaf\x8d\xbf|\x94\xb2'
b'=\xe3k\xbe\xbe\xfd\x83G\xbeeE^>\xad\x8c\x80')
Результат разбора:
'A1': [{'B1': 0.9999406223136487, 'B2': -64, 'B3': 3198523161, 'B4': -41},
{'B1': -0.8176689474146044, 'B2': 43, 'B3': 28698638, 'B4': 109}],
{'A2': 32985,
'A3': [5542, 50320],
'A4': {'C1': -7446142729519503479,
'C2': {'D1': -116,
'D2': [-0.2906588912010193,
-0.03478578105568886,
-0.8711607456207275,
-0.7844922542572021],
'D3': -0.9067693538456665,
'D4': 1293773205},
'C3': 0.043172117322683334,
'C4': 3863527443},
'A5': [-0.6901786923408508,
-0.98664391040802,
0.11104534566402435,
-0.4951421916484833,
-0.22389742732048035,
0.3389625549316406],
'A6': -51,
'A7': -3318289043189075608}
Задача №12
Реализовать разбор двоичного формата данных. Данные начинаются с сигнатуры 0x4e 0x44 0x55
, за которой следует структура A.
Порядок байт: от старшего к младшему. Адреса указаны в виде смещений от начала данных. В решении предлагается использовать модуль
struct.
Структура A:
Поле | Описание |
---|---|
1 | int16 |
2 | Размер (uint16) и адрес (uint16) массива адресов (uint32) структур B |
3 | Структура C |
Структура B:
Поле | Описание |
---|---|
1 | Размер (uint32) и адрес (uint32) массива char |
2 | int16 |
3 | float |
Структура C:
Поле | Описание |
---|---|
1 | uint32 |
2 | Структура D |
3 | double |
4 | float |
5 | Структура E |
6 | uint16 |
Структура D:
Поле | Описание |
---|---|
1 | double |
2 | uint8 |
3 | int8 |
Структура E:
Поле | Описание |
---|---|
1 | float |
2 | int16 |
3 | uint8 |
4 | uint8 |
5 | Массив int32, размер 4 |
6 | Размер (uint16) и адрес (uint16) массива int16 |
Ниже показаны примеры разбора двоичного формата.
Пример 1
Двоичные данные:
b'NDU\x07\xe6\x00\x05\x00\x9dh\xc1\x8a ?3s\xe3p\xeb0\x00\xea\\\xbf'
(b'\xce\x9d\xf5\xb4\xd5\x90\x18\xbf\x0711>\x1bW\x9c@\xa0\x91\x1c#d\xe3s\xdc'
b'\x1eC8\x10\xdf\xfeN]\xfb.P\x00\x05\x00\xb1\xad\x7fxodgfg\x00\x00\x00\x06\x00'
b'\x00\x00AO\x06\xbf<\xd6\x81zu\x00\x00\x00\x02\x00\x00\x00U\xcc&\xbf_\xa9'
b'\xdaisu\x00\x00\x00\x03\x00\x00\x00e\xa9\x88?6\x87\xb8mksjy\x00'
b'\x00\x00\x05\x00\x00\x00v\x1e\xd4?Q/\x0ejpsqbe\x00\x00\x00\x06\x00'
b'\x00\x00\x89\x89\xcc?\x17\xfb$\x00\x00\x00G\x00\x00\x00W\x00\x00\x00'
b'h\x00\x00\x00{\x00\x00\x00\x8f\xa54\xaa:S\xb8\xa6\x94\x92\x97')
Результат разбора:
'A1': 2022,
{'A2': [{'B1': 'xodgfg', 'B2': 20230, 'B3': -0.737648069858551},
'B1': 'zu', 'B2': -13274, 'B3': -0.8736854791641235},
{'B1': 'isu', 'B2': -22136, 'B3': 0.7130084037780762},
{'B1': 'mksjy', 'B2': 7892, 'B3': 0.8171242475509644},
{'B1': 'jpsqbe', 'B2': -30260, 'B3': 0.5936758518218994}],
{'A3': {'C1': 1757514272,
'C2': {'D1': 0.0002968244815917398, 'D2': 234, 'D3': 92},
'C3': -0.23919555024906525,
'C4': -0.5280943512916565,
'C5': {'E1': 0.15170139074325562,
'E2': 16544,
'E3': 145,
'E4': 28,
'E5': [593814387, -601996488, 283115086, 1576742480],
'E6': [-23244, -21958, 21432, -22892, -28009]},
'C6': 44415}}
Пример 2
Двоичные данные:
b'NDU\nZ\x00\x03\x00xq:U\xe1?\xbfzs\x97!\x02\xd0OW?\xea\xea\xd2\xfe'
(b'\xe2\xc3 \xbf^\xe2\xf9\xbe\xec\xb5\x1bj\xe6\xb6\x15*?\xf5\xa7`\x1d\xefV\xa7'
b'I\xfc\xd4\xe4\xb26\x95\x00\x04\x00\x84M\xfeddfcm\x00\x00\x00\x05\x00\x00'
b'\x00A_v;\x93\xf9\x84fz\x00\x00\x00\x02\x00\x00\x00T\x18\x0b\xbf<\x9e[nbfh'
b'cl\x00\x00\x00\x06\x00\x00\x00d\xcd\x08>\xcd\r0\x00\x00\x00F\x00\x00\x00V'
b'\x00\x00\x00j\x1aq\xd4\x15-\xcap\xc9')
Результат разбора:
'A1': 2650,
{'A2': [{'B1': 'ddfcm', 'B2': 24438, 'B3': 0.004515828564763069},
'B1': 'fz', 'B2': 6155, 'B3': -0.7367913126945496},
{'B1': 'nbfhcl', 'B2': -13048, 'B3': 0.40049123764038086}],
{'A3': {'C1': 1899648481,
'C2': {'D1': 0.12296221198722468, 'D2': 79, 'D3': 87},
'C3': 0.8411650636900028,
'C4': -0.8706508278846741,
'C5': {'E1': -0.4623192250728607,
'E2': 27366,
'E3': 182,
'E4': 21,
'E5': [708834727, 1612574550, -1488323372, -458082667],
'E6': [6769, -11243, 11722, 28873]},
'C6': 19966}}
Задача №12
Реализовать разбор двоичного формата данных. Данные начинаются с сигнатуры 0xb2 0x49 0x47 0x53 0x53
, за которой следует
структура A. Порядок байт: от младшего к старшему. Адреса указаны в виде смещений от начала данных. В решении предлагается использовать
модуль struct.
Структура A:
Поле | Описание |
---|---|
1 | int32 |
2 | Размер (uint32) и адрес (uint32) массива структур B |
3 | Массив int8, размер 2 |
Структура B:
Поле | Описание |
---|---|
1 | Адрес (uint16) структуры C |
2 | Адрес (uint32) структуры D |
Структура C:
Поле | Описание |
---|---|
1 | int16 |
2 | int64 |
3 | float |
4 | uint32 |
Структура D:
Поле | Описание |
---|---|
1 | uint8 |
2 | Структура E |
3 | int64 |
4 | uint8 |
5 | Массив float, размер 2 |
6 | int8 |
7 | Массив int16, размер 5 |
Структура E:
Поле | Описание |
---|---|
1 | uint16 |
2 | uint16 |
Ниже показаны примеры разбора двоичного формата.
Пример 1
Двоичные данные:
b'\xb2IGSS%\xb6\x15p\x02\x00\x00\x00y\x00\x00\x007\xd6\xadT\xda\xb6\xab'
(b'\xc1I\xad\xa9\xdc]\x8c\x0f>\x82^8\xbd\x85>\x17\xd7@\xb4\x12FqK\xf1~f\x97s'
b'\xac\x12<8\x89\xbb>T\xd4\xe3\x1f\x1b.wfE\x057\x1a\x11&\xe6g\x07H:&\xa9"Cc?'
b'\xa4_*\xc0\xc5\xe1<\x8e\xcda\xe6b\x85R\x80\xfb{\x16F\x00\xad\xbe%,i>\xa5z'
b'\xbc\xe0\x83Vs6\xb2\x9e\xdd\x13\x00%\x00\x00\x00F\x00X\x00\x00\x00')
Результат разбора:
'A1': 1880471077,
{'A2': [{'B1': {'C1': 21677,
'C2': -2546313582007830822,
'C3': 0.14018388092517853,
'C4': 3174588034},
'B2': {'D1': 133,
'D2': {'E1': 5950, 'E2': 16599},
'D3': 7385605745259451060,
'D4': 151,
'D5': [0.00895224791020155, 0.36628127098083496],
'D6': 84,
'D7': [-7212, 6943, 30510, 17766, 14085]}},
'B1': {'C1': 4378,
{'C2': -6258250551148419546,
'C3': 0.8877431154251099,
'C4': 3224002468},
'B2': {'D1': 197,
'D2': {'E1': 15585, 'E2': 52622},
'D3': 8933875377733035617,
'D4': 22,
'D5': [-0.33789271116256714, 0.22770746052265167],
'D6': -91,
'D7': [-17286, -31776, 29526, -19914, -8802]}}],
'A3': [55, -42]}
Пример 2
Двоичные данные:
b'\xb2IGSS\xea\xaeZ\xf3\x02\x00\x00\x00y\x00\x00\x00Q\x12\xec\xff?M\x07'
(b'j>\xb3\xa6\xfc\x02\xdbG?se+\xfb"4SA\xfe"\xf8\x13\x811\xdf\xb2n\x1a\x8a'
b"\x95H?wxd>U\x12\x03\x18c\x05V]\xe1\x1a\x06\xc8Y'\xd59\xf5\x1a5q\x8f"
b'\xc3,-\xbfG\x06\xff\x8a\x0e\x9ew\xfb\xf1W\xa2$Ga\xa8\x08Y\xfaa\x04\x16\xbf& '
b'\xf3>\x99\xd4\xe2\xa4\xd2E\xf8\xd3|\xe2\xfc\x13\x00%\x00\x00\x00F'
b'\x00X\x00\x00\x00')
Результат разбора:
'A1': -212160790,
{'A2': [{'B1': {'C1': -20,
'C2': -241308449369535169,
'C3': 0.780685544013977,
'C4': 4213925235},
'B2': {'D1': 34,
'D2': {'E1': 21300, 'E2': 65089},
'D3': 7976683293738530850,
'D4': 26,
'D5': [0.7835317850112915, 0.22311578691005707],
'D6': 85,
'D7': [786, 25368, 22021, -7843, 1562]}},
'B1': {'C1': 22984,
{'C2': -8110643064017922777,
'C3': -0.6764642596244812,
'C4': 2331969095},
'B2': {'D1': 14,
'D2': {'E1': 30622, 'E2': 61947},
'D3': 6415562804948148823,
'D4': 250,
'D5': [-0.5860043168067932, 0.47485464811325073],
'D6': -103,
'D7': [-7468, -11612, -1979, 31955, -798]}}],
'A3': [81, 18]}
Задача №12
Реализовать разбор двоичного формата данных. Данные начинаются с сигнатуры 0x42 0x4e 0x42
, за которой следует структура A.
Порядок байт: от младшего к старшему. Адреса указаны в виде смещений от начала данных. В решении предлагается использовать модуль
struct.
Структура A:
Поле | Описание |
---|---|
1 | int16 |
2 | uint32 |
3 | uint16 |
4 | Массив адресов (uint32) структур B, размер 2 |
5 | int8 |
6 | Структура C |
Структура B:
Поле | Описание |
---|---|
1 | Размер (uint16) и адрес (uint16) массива char |
2 | uint8 |
3 | uint16 |
Структура C:
Поле | Описание |
---|---|
1 | int64 |
2 | uint32 |
3 | int16 |
4 | uint32 |
5 | Размер (uint16) и адрес (uint16) массива int32 |
6 | Структура D |
7 | int32 |
8 | int8 |
Структура D:
Поле | Описание |
---|---|
1 | float |
2 | int8 |
3 | Размер (uint16) и адрес (uint32) массива double |
Ниже показаны примеры разбора двоичного формата.
Пример 1
Двоичные данные:
b"BNB\xc6\x19<\x00\x8b\x99\x83\xd2<\x00\x00\x00E\x00\x00\x00\xa2'\xfe\x16\x07"
(b'dn"\xc0}4\xd3\xc5!\x9c>\xdfC\xb4\x03\x00L\x006)\x81\xber\x04\x00X\x00\x00'
b'\x00d9\x8a+\xfcbc\x02\x00:\x00\xd71\xd1sz\x02\x00C\x00\xfd\xf2\xcb'
b'\x08P\x91\xd0#k\xf7Gb(~ \xbc\x1c\x14q>?\xe8\xbf$\xbb2\xd14Q\xdf?'
b" \x8b\xe6\xc39!\xaa?\x88\xacY'\x86N\xcb\xbf")
Результат разбора:
'A1': 6598,
{'A2': 2576023612,
'A3': 53891,
'A4': [{'B1': 'bc', 'B2': 215, 'B3': 53553},
'B1': 'sz', 'B2': 253, 'B3': 52210}],
{'A5': -94,
'A6': {'C1': -4601994493324493273,
'C2': 3318953085,
'C3': -25567,
'C4': 3024346942,
'C5': [-795783160, 1207397155, 545138786],
'C6': {'D1': -0.2522675395011902,
'D2': 114,
'D3': [-0.7577202042165463,
0.48933144025333974,
0.05103474155773413,
-0.21333386346245597]},
'C7': 730478948,
'C8': -4}}
Пример 2
Двоичные данные:
b'BNBHi\xf1\xe5\x04\xc2\xd1\x03<\x00\x00\x00E\x00\x00\x00i\xd7\xf5)\x1f'
(b'\xfa\x1b\xba\xc5E\x0b\xa7.\xe2\xcbDl\xf5\xdd\x02\x00L\x00CG\x1f\xbf#\x02'
b'\x00T\x00\x00\x00\x87\x11O\x05\x9fiy\x02\x00:\x00\r\xe8\x7fyx\x02\x00C'
b'\x00Y\x89\xc9\t\x98\xa7\xb1.\xbb\x89\xb1\xa0,eM\x99+\xce\xbfd\xab\xb8\x90'
b'c\xa4\xe5\xbf')
Результат разбора:
'A1': 26952,
{'A2': 3255100913,
'A3': 977,
'A4': [{'B1': 'iy', 'B2': 13, 'B3': 32744},
'B1': 'yx', 'B2': 89, 'B3': 51593}],
{'A5': 105,
'A6': {'C1': -4199012941490948649,
'C2': 782699333,
'C3': -13342,
'C4': 3723848772,
'C5': [-1314416631, -1316373714],
'C6': {'D1': -0.6221811175346375,
'D2': 35,
'D3': [-0.2357055309206304, -0.676317007693211]},
'C7': 89067911,
'C8': -97}}
Задача №12
Реализовать разбор двоичного формата данных. Данные начинаются с сигнатуры 0x49 0x4f 0x59 0x42 0x26
, за которой следует
структура A. Порядок байт: от младшего к старшему. Адреса указаны в виде смещений от начала данных. В решении предлагается использовать
модуль struct.
Структура A:
Поле | Описание |
---|---|
1 | Массив адресов (uint32) структур B, размер 2 |
2 | int32 |
3 | Структура D |
4 | uint16 |
5 | float |
6 | int8 |
7 | Массив int32, размер 5 |
8 | Адрес (uint16) структуры E |
Структура B:
Поле | Описание |
---|---|
1 | Массив float, размер 5 |
2 | Структура C |
3 | int8 |
Структура C:
Поле | Описание |
---|---|
1 | int8 |
2 | Размер (uint32) и адрес (uint32) массива uint32 |
3 | uint16 |
4 | int32 |
5 | int16 |
6 | uint8 |
7 | int16 |
8 | float |
Структура D:
Поле | Описание |
---|---|
1 | uint32 |
2 | uint64 |
3 | uint32 |
4 | double |
Структура E:
Поле | Описание |
---|---|
1 | double |
2 | uint8 |
3 | int16 |
Ниже показаны примеры разбора двоичного формата.
Пример 1
Двоичные данные:
b'IOYB&N\x00\x00\x00\x83\x00\x00\x00\xa51\xe7\xb1\xd7j\x8e\xf2\xbb*]\x92#4\xe9'
(b'\xc7\xac\nu)\xc8\x84\xc2\xd2\x8d\x8a\xd6\xbfqcZV\xeb\xbe\x04\xb0%m9'
b'\xce\x0b[\xcb\x872~\xec\xc5\x9eFb\xfb\x07Y\xfc\xb0\x00AE\x0eS\x00\x8c'
b'7}\xf8\xe6U?\xfc\xf1\x86>\xf9\x18B\xbf\x1d\xe9\x0c?\x93Iy?\x86\x02'
b'\x00\x00\x00F\x00\x00\x00\xe0\x95\xb57X\x10\xa3;\xa94\x15)!\xff<NA\xe5?b<'
b'\xabA\xf4\x93\xca\x94\xbd\xe8\xc3\x18?\t\x87\xd3>H%`?(\xeb@?>'
b'\x02\x00\x00\x00{\x00\x00\x00\x057\x84aOL\x85,s\xa5\x82~e\x9e\xbe\xf8'
b'\xd0\x17\xe7\xefN\x00\xcd\xbf\xf6\x04\xdc')
Результат разбора:
'A1': [{'B1': [0.8355555534362793,
{0.26356494426727295,
-0.7581935524940491,
0.550432026386261,
0.9737789034843445],
'B2': {'C1': -122,
'C2': [1393444161, 2100792320],
'C3': 38368,
'C4': 274216885,
'C5': 15267,
'C6': 169,
'C7': 5428,
'C8': 0.03114374168217182},
'B3': 78},
'B1': [-0.07265200465917587,
{0.5967392921447754,
0.41313961148262024,
0.8755688667297363,
0.7535881996154785],
'B2': {'C1': 62,
'C2': [1648354625, 4097944380],
'C3': 14085,
'C4': 1280270724,
'C5': 11397,
'C6': 115,
'C7': -32091,
'C8': -0.3093680739402771},
'B3': -8}],
'A2': -1310248539,
'A3': {'D1': 4069419735,
'D2': 14405102210505321147,
'D3': 695536300,
'D4': -0.3522066648675488},
'A4': 25457,
'A5': -0.4596431851387024,
'A6': 4,
'A7': [963454384, -883225650, -327273849, 1648795333, -61274117],
'A8': {'E1': -0.22657191003798838, 'E2': 246, 'E3': -9212}}
Пример 2
Двоичные данные:
b'IOYB&N\x00\x00\x00\x83\x00\x00\x00\x96\x87\x92)\x0fD\xf6x2\xb1\xb9F\xb7g*'
(b'\xf0Y\xc1Lu,[\xcb\x05\xe7K\xdf\xbf\xc0\xf2\xcc>\x9d>9Dtf\n\x81s\xc4\xa0'
b'\xe9\x95\x95\x86G\x90\x93\x1f\xee\x9f\x184\xb0\x00j\x9b\x07d\x83\x05'
b'\xbdE\x01\xe0:\xbf\x16\xde\x7f?\x08`\xf6\xbeG\x12\xe9\xbeA\xb8i=\xb2\x02'
b'\x00\x00\x00F\x00\x00\x00:\x8d\xa9\xf41?\x83\x94C,\xe7\x98{\xd4\xbeT6'
b'4\xda\xf3RR\xec\x11\xd2}\xd2\xbe\xc1\x1c+?~\x9d\xe4>\x19X@>7k\x86\xbeL'
b'\x02\x00\x00\x00{\x00\x00\x00%\xe9\xf2\xcb[\xd7/:-N\xeb7WV?\xf3'
b'\xf6\xb3\xb2\xbcWk\xea?(\x92a')
Результат разбора:
'A1': [{'B1': [-0.7299805283546448,
{0.9994825124740601,
-0.4812014102935791,
-0.455217570066452,
0.05706048384308815],
'B2': {'C1': -78,
'C2': [1678220138, 1170015619],
'C3': 36154,
'C4': 1060238505,
'C5': -27517,
'C6': 67,
'C7': -6356,
'C8': -0.4150054454803467},
'B3': 84},
'B1': [-0.41111618280410767,
{0.6684074997901917,
0.4465140700340271,
0.18783606588840485,
-0.2625367343425751],
'B2': {'C1': 76,
'C2': [4091163702, 300700242],
'C3': 59685,
'C4': -681849870,
'C5': 14895,
'C6': 45,
'C7': -5298,
'C8': 0.8372682929039001},
'B3': -13}],
'A2': 697468822,
'A3': {'D1': 2029405199,
'D2': 17305758554987802930,
'D3': 1967964505,
'D4': -0.48900771680694066},
'A4': 62144,
'A5': 0.3071197271347046,
'A6': 57,
'A7': [174486596, -1597738111, -2037017111, 529764423, 874029038],
'A8': {'E1': 0.825603359747787, 'E2': 40, 'E3': 24978}}
Задача №12
Реализовать разбор двоичного формата данных. Данные начинаются с сигнатуры 0xfd 0x49 0x44 0x49 0x58
, за которой следует
структура A. Порядок байт: от старшего к младшему. Адреса указаны в виде смещений от начала данных. В решении предлагается использовать
модуль struct.
Структура A:
Поле | Описание |
---|---|
1 | Массив int64, размер 6 |
2 | Размер (uint16) и адрес (uint16) массива адресов (uint16) структур B |
3 | Размер (uint16) и адрес (uint16) массива char |
4 | Структура C |
5 | int8 |
6 | Адрес (uint16) структуры D |
7 | int16 |
Структура B:
Поле | Описание |
---|---|
1 | uint16 |
2 | int32 |
Структура C:
Поле | Описание |
---|---|
1 | float |
2 | Массив int16, размер 5 |
Структура D:
Поле | Описание |
---|---|
1 | int64 |
2 | uint16 |
3 | int32 |
4 | int8 |
Ниже показаны примеры разбора двоичного формата.
Пример 1
Двоичные данные:
b'\xfdIDIX\xe6O\x87\x81\xc51T\xde^[B\xc9\xd4\x82\x10\xac\x02\xa8|'
(b'\xe5\x94\t\x0cn\xf1flT\x07*0Q}FP\x01]\xd8\x99\xf1^HO\x02\xbf\x01x'
b'\xac\x00\x02\x00\\\x00\x04\x00`\xbf.t\x1a\x10"\x8e\x1a\xc8\x18\xa9%`\xaf\xf7'
b"\x00dM\x15$\xfa/<'\x02\xe4\xbdcY\xf3\xc8\x00P\x00Vglgn195`\x85\x080\xbc"
b'\nQ\xf6\r\xfa\xbe%')
Результат разбора:
'A1': [-1851111930397109026,
{6799101497067049132,
191540309636222062,
-1052034354791174063,
9026990469910403569,
6793766911101466796],
'A2': [{'B1': 9466, 'B2': 792471298}, {'B1': 58557, 'B2': 1666839496}],
'A3': 'glgn',
'A4': {'C1': -0.6814590692520142, 'C2': [4130, -29158, -14312, -22235, 24751]},
'A5': -9,
'A6': {'D1': 3546924870196015292, 'D2': 2641, 'D3': -166856002, 'D4': 37},
'A7': 19733}
Пример 2
Двоичные данные:
b'\xfdIDIX\xd6\xe8\x11|\x12n\x91h\x18\x89\xdd2J\xa3\\\xa6{\x14:'
(b'\x05\x99\x9f\xac\xc7\x8fi\x9f\rY4\x07I\xf9\x1e\x1b\x82Ji\x84\x90=\xe4\xdc'
b'\xeeVD\xd4\x1a\x00\x04\x00h\x00\x05\x00p?\x08\x06\xbe\xb0\xbf\xfd\xa9vM>'
b'\xea\x8f\xbe\xf7\x00ux4\xf8]\xad\x92\xf1\xd4y]D\xe2\xb2\x87\xbe\xe8\x98\xee'
b'g\xeb10\x17\x8b\x87\x9d\x00P\x00V\x00\\\x00brqaby\xe4\xf5,k\x19\x1e\xca'
b'|\x0e\xf2$`\xaedi')
Результат разбора:
'A1': [-2961097530413248152,
{1768187536789953702,
8868777361925975239,
-8112778374051264695,
-495928662556048240,
4459932447211312154],
'A2': [{'B1': 63581, 'B2': -1382878764},
'B1': 31069, 'B2': 1155707527},
{'B1': 48872, 'B2': -1729206293},
{'B1': 12592, 'B2': 395020189}],
{'A3': 'rqaby',
'A4': {'C1': 0.5313528776168823, 'C2': [-20289, -599, 30285, 16106, -28738]},
'A5': -9,
'A6': {'D1': -1948602425273300356, 'D2': 3826, 'D3': 610315876, 'D4': 105},
'A7': 30772}
Задача №12
Реализовать разбор двоичного формата данных. Данные начинаются с сигнатуры 0x4f 0x45 0x47 0x4f 0xea
, за которой следует
структура A. Порядок байт: от младшего к старшему. Адреса указаны в виде смещений от начала данных. В решении предлагается использовать
модуль struct.
Структура A:
Поле | Описание |
---|---|
1 | Структура B |
2 | int16 |
Структура B:
Поле | Описание |
---|---|
1 | uint8 |
2 | Массив адресов (uint32) структур C, размер 7 |
3 | uint32 |
4 | uint16 |
5 | Размер (uint32) и адрес (uint32) массива char |
6 | Структура D |
7 | Размер (uint32) и адрес (uint32) массива int16 |
8 | uint8 |
Структура C:
Поле | Описание |
---|---|
1 | float |
2 | int64 |
Структура D:
Поле | Описание |
---|---|
1 | int16 |
2 | uint32 |
3 | Размер (uint32) и адрес (uint32) массива double |
Ниже показаны примеры разбора двоичного формата.
Пример 1
Двоичные данные:
b'OEGO\xea\xc7I\x00\x00\x00U\x00\x00\x00a\x00\x00\x00m\x00\x00\x00y\x00'
(b'\x00\x00\x85\x00\x00\x00\x91\x00\x00\x00\xcf\xfc\x19\x83\xbfZ'
b'\x02\x00\x00\x00\x9d\x00\x00\x00\xaaP_o\r\xa6\x02\x00\x00\x00\x9f\x00'
b'\x00\x00\x02\x00\x00\x00\xaf\x00\x00\x00.w\x14\xf0\x0e \xbe\xb1\xe9\xff'
b"&4\xf1\xb8\x0f?Q]>V#'w%T}\x94h\xed*\xbcE\x81o\x9e\xab\xbc\xe2C\xfe\xde\x04"
b'?\x0eZ\x82i\xec~\xd1\xe1\xa0E8\xbe7\xdc\xea;\xb9\x9c!\x1b\x9d\x96 ?L#\\'
b'*\x1e%\xbf\xaf-\x08&>\xb0\xfa{8\x1b\xcb\xb3\xdenh\x00\x9cIk\x8aY\xb6\xbfZ'
b'\xb5_\xfeXG\xe5?,\x85\x98\xfd')
Результат разбора:
'A1': {'B1': 199,
{'B2': [{'C1': -0.15630698204040527, 'C2': 1132920512578578865},
'C1': 0.21613024175167084, 'C2': -7746943264117808298},
{'C1': -0.01043257862329483, 'C2': 4891679590561317189},
{'C1': 0.519027590751648, 'C2': -2174817591195706866},
{'C1': -0.17995309829711914, 'C2': 1955016032643636279},
{'C1': 0.6272981762886047, 'C2': -5782862585030499508},
{'C1': 0.16214056313037872, 'C2': -2399350858686137680}],
{'B3': 2199518415,
'B4': 23231,
'B5': 'nh',
'B6': {'D1': 20650,
'D2': 2785898335,
'D3': [-0.08730378264736771, 0.6649594276656601]},
'B7': [-31444, -616],
'B8': 46},
'A2': 5239}
Пример 2
Двоичные данные:
b'OEGO\xea\xc3I\x00\x00\x00U\x00\x00\x00a\x00\x00\x00m\x00\x00\x00y\x00'
(b'\x00\x00\x85\x00\x00\x00\x91\x00\x00\x00^c\xfddp\xb3\x02\x00\x00\x00'
b'\x9d\x00\x00\x00\x06\x06\x1ej\xa8j\x03\x00\x00\x00\x9f\x00\x00\x00\x03\x00'
b'\x00\x00\xb7\x00\x00\x00\xcf\xe5c\x84\xaa@?\xaf\xe2\x90\xb2\x9a\xf7\x92'
b'\tY>\x84>\x83\xa4\x01\xbb\xaa\xe3\x04\x19\x01\xca`?\t-\x15\xe2\xff\xe1\x8d'
b"!\xd5\xff\x1a>H\xd1>\xf0U\x80h\xda\xbc\xce4\xbf\x80\xe4\xaam'u\x8d"
b'\x99K\x99"?\x9b"\rq\xc0\xce\xbby\xd9%\'\xbe>\x03@\xf3\xac\x16\xf5\x17exX'
b'\xc4I1\x94\x81\xd5?\x08u\x94L\x89\xe9\xc8\xbf\xd0\xd3o0\x8c\x91\xb9?\xdd'
b'`w\xc4\x14\xd4')
Результат разбора:
'A1': {'B1': 195,
{'B2': [{'C1': 0.7526018619537354, 'C2': 689885936733971119},
'C1': 0.25828817486763, 'C2': 1802816073276433539},
{'C1': 0.8780823349952698, 'C2': 2417837064093773065},
{'C1': 0.15136654675006866, 'C2': -2708774069272129208},
{'C1': -0.7062795162200928, 'C2': -7382115401986284416},
{'C1': 0.6351515650749207, 'C2': 8771832025159901851},
{'C1': -0.1632303148508072, 'C2': 1726310964237697854}],
{'B3': 1694327646,
'B4': 45936,
'B5': 'ex',
'B6': {'D1': 1542,
'D2': 1789422110,
'D3': [0.33603386700912585,
-0.19462696303609328,
0.09987713034190837]},
'B7': [24797, -15241, -11244],
'B8': 207},
'A2': 25573}
Задача №12
Реализовать разбор двоичного формата данных. Данные начинаются с сигнатуры 0x54 0x59 0x57 0xae
, за которой следует структура
A. Порядок байт: от младшего к старшему. Адреса указаны в виде смещений от начала данных. В решении предлагается использовать модуль
struct.
Структура A:
Поле | Описание |
---|---|
1 | Адрес (uint32) структуры B |
2 | int16 |
3 | uint32 |
4 | Массив int64, размер 4 |
5 | float |
6 | int32 |
Структура B:
Поле | Описание |
---|---|
1 | float |
2 | Размер (uint32) и адрес (uint32) массива char |
3 | float |
4 | Размер (uint32) и адрес (uint16) массива структур C |
5 | Структура D |
6 | float |
Структура C:
Поле | Описание |
---|---|
1 | int32 |
2 | Размер (uint16) и адрес (uint16) массива uint8 |
3 | int16 |
4 | uint16 |
Структура D:
Поле | Описание |
---|---|
1 | int16 |
2 | Массив float, размер 8 |
Ниже показаны примеры разбора двоичного формата.
Пример 1
Двоичные данные:
b'TYW\xae[\x00\x00\x00\x03\xdbpp\x90\xf7k\xc4?\x93\xe6r\xf3t\xb9\n=(\x96\xb0'
(b"\x1e\x8d\xd4Z\x02\xa40\x98Y\xfe\xef\n\xfb\xd4E\xf2/\xa9\x7fA'\xbf\x8e\xa2"
b'\x1b\x7frbbuls\x9c\x9f\xff\x1f\xd9B\x96o\n\x85\xdb\x04\x00<\x00\x82'
b'\x93\xc9\xd8\x97A\xc9\xcd\x03\x00@\x00\x9a#\xdcV\xbd\x83-\xbf\x06'
b'\x00\x00\x006\x00\x00\x00O\xb4/=\x02\x00\x00\x00C\x00\xef\x1c\x84\xc2\x96>~'
b"\x84\x1f\xbfp'Z\xbf\xf7z\x01?y\x12\xa9\xbdP\x82\xd4=R8\xc0>\x15\xde\x7f\xbfL"
b'\xaf\x17?')
Результат разбора:
'A1': {'B1': -0.67779141664505,
{'B2': 'rbbuls',
'B3': 0.042896565049886703,
'B4': [{'C1': -612038033,
'C2': [156, 159, 255, 31],
'C3': -27774,
'C4': 55497},
'C1': -842448489,
{'C2': [217, 66, 150],
'C3': 9114,
'C4': 22236}],
'B5': {'D1': 7407,
'D2': [0.2944527864456177,
-0.6231154203414917,
-0.8521642684936523,
0.5057825446128845,
-0.08255476504564285,
0.10376417636871338,
0.3754296898841858,
-0.9994824528694153]},
'B6': 0.5925185680389404},
'A2': -9469,
'A3': 4153438320,
'A4': [8427205662378804331,
-8277984906093720903,
-118896580471137580,
-6255514975654442257],
'A5': -0.653343141078949,
'A6': 2132517518}
Пример 2
Двоичные данные:
b"TYW\xaeU\x00\x00\x00\x8b\xc4\x99%N'\xc1\xc4\xfb\x1eH){\xc9Q`\xc7.\xf3\xd5"
(b'\xd7\x1e\xd6\xaf\xfc\x9e\xf1\xbfb\xd7\xb7\xac\r\xf6=\xf0-\xc7\xc7\xf5'
b'x>\x1c\xc7\xcd\x96ip\x96\xe0\xa5\xf4\x92+7TY\x02\x008\x00\t\xc6\xf9'
b'\xcbSF\x05s\x03\x00:\x00\xdcq\xfd\x16w\xc0L?\x02\x00\x00\x006\x00\x00'
b'\x00\x18\x86\x8d\xbe\x02\x00\x00\x00=\x00\xf1:\xf9\x9d\xee\xbea6\xf4'
b'>\xfd\xcc\x03?bL\xbe=&\xa1[\xbfQ](=\xab-\xad\xbdv\xa6\xa1\xbe35z\xbf')
Результат разбора:
'A1': {'B1': 0.7998117804527283,
{'B2': 'ip',
'B3': -0.2764136791229248,
'B4': [{'C1': 1498691371, 'C2': [150, 224], 'C3': -14839, 'C4': 52217},
'C1': 1929725523,
{'C2': [165, 244, 146],
'C3': 29148,
'C4': 5885}],
'B5': {'D1': 15089,
'D2': [-0.4660489857196808,
0.4769773781299591,
0.5148466229438782,
0.09291912615299225,
-0.857927680015564,
0.04110461845993996,
-0.08455976098775864,
-0.31572312116622925]},
'B6': -0.977374255657196},
'A2': -15221,
'A3': 659432857,
'A4': [-3928500860216425279,
2222480181569216593,
-2926565763362017322,
-4094352337298150217],
'A5': 0.2431250661611557,
'A6': -1764899044}
Задача №12
Реализовать разбор двоичного формата данных. Данные начинаются с сигнатуры 0x57 0x42 0x53 0x4c
, за которой следует структура
A. Порядок байт: от старшего к младшему. Адреса указаны в виде смещений от начала данных. В решении предлагается использовать модуль
struct.
Структура A:
Поле | Описание |
---|---|
1 | float |
2 | Размер (uint16) и адрес (uint16) массива char |
3 | Структура B |
4 | int64 |
5 | int8 |
Структура B:
Поле | Описание |
---|---|
1 | uint32 |
2 | Структура C |
3 | Размер (uint32) и адрес (uint32) массива адресов (uint16) структур D |
4 | float |
5 | uint16 |
6 | int32 |
Структура C:
Поле | Описание |
---|---|
1 | uint64 |
2 | uint32 |
3 | uint32 |
4 | uint16 |
5 | uint64 |
6 | int64 |
7 | int64 |
Структура D:
Поле | Описание |
---|---|
1 | Массив float, размер 3 |
2 | Размер (uint32) и адрес (uint32) массива uint16 |
3 | Массив uint16, размер 5 |
Ниже показаны примеры разбора двоичного формата.
Пример 1
Двоичные данные:
b'WBSL\xbef\xe1\xef\x00\x07\x00U\xbd\x92P\xd8\xb3\x9c\xb4\x90\xc9O\x97)(ccL'
(b'\x93\xe5\xa3\x0e\x975-y\xd1yu\x89sF\xff\x94\xae\xe0C\xdfi\x8a\xc2\x04'
b'^J\x9d\xa8\xd0@\x00\x00\x00\x02\x00\x00\x00\xac?>E\x05\xcb^\xc1Nt\xcb'
b'B\x9e\xc3\x1f%d#\xd6\xcdpffmiyl\xe6\xd5vz\xb0\xc6\xb4*;u\xb2i\xbf\r\xd7\x85'
b'?(\xad\xaf>\xa4I"\x00\x00\x00\x06\x00\x00\x00\\\xbdw;0\xf6W\xa9\xb1'
b'\xad\xea\x85\xe1\xf7\xc0\x8a\xd2\x0c"\xbe\x11~l?G\x18\x90\xbf\x08'
b'\xb4K\x00\x00\x00\x04\x00\x00\x00\x86\x13\xa4\xa8\xc3+\x8b\xbepb:'
b'\x00h\x00\x8e')
Результат разбора:
'A1': -0.22547124326229095,
{'A2': 'pffmiyl',
'A3': {'B1': 3180482776,
'B2': {'C1': 12942417963101689641,
'C2': 677602124,
'C3': 2481300238,
'C4': 38709,
'C5': 3276880523481936710,
'C6': -30207019250128502,
'C7': -4466341255879012288},
'B3': [{'D1': [-0.5540698170661926,
0.6589002013206482,
0.32087045907974243],
'D2': [59093, 30330, 45254, 46122, 15221, 45673],
'D3': [48503, 15152, 63063, 43441, 44522]},
'D1': [-0.14208382368087769,
{0.7777185440063477,
-0.5340010523796082],
'D2': [34273, 63424, 35538, 3106],
'D3': [5028, 43203, 11147, 48752, 25146]}],
'B4': 0.7432406544685364,
'B5': 52062,
'B6': -1051822901},
'A4': 4800488791362249686,
'A5': -51}
Пример 2
Двоичные данные:
b'WBSL\xbe\xb78\x88\x00\x02\x00Ug_\xdb\x96\xbd\xac\xe9\xe7\x1e\xe1\x11Lm9K#'
(b' \x06}!\x14\x04t\xf7\xd7Z\\\xf8R\xb9\x19&\xb5\xa0\xd7\xb4\xc8\x87\xd1\xad'
b"\xfb'\xe9\x8fi\x8d\x00\x00\x00\x02\x00\x00\x00\xa5?*\x04\x99\xc3\x17"
b'\xd9e\xd8\x90\x9a1qN$P\xa2\xe2\xb8zq\xb7\xfa\x06\x04\x8d\xa5\xe6S7'
b'\x07\x1d\x9f\xbf\x1f\xca\xd7\xbe\xde\xdf\x81>\xcd\x1d"\x00\x00\x00\x06\x00'
b'\x00\x00W\xc2\x90\xd6M\\\x1a\xb2]|7\xc8\xa074\x07v>\x07\x1a1\xbfh\xa5n?'
b"gH\xe8\x00\x00\x00\x03\x00\x00\x00\x81'\x883\x9f\xf1\xd0;\xe0\xa5"
b'\xc5\x00c\x00\x87')
Результат разбора:
'A1': -0.3578531742095947,
{'A2': 'zq',
'A3': {'B1': 1734335382,
'B2': {'C1': 13667556148027396428,
'C2': 1832471331,
'C3': 537296161,
'C4': 5124,
'C5': 8428442010753979065,
'C6': 1812335602481547399,
'C7': -3337735599970883187},
'B3': [{'D1': [-0.6241888403892517,
-0.43529894948005676,
0.40061289072036743],
'D2': [47098, 1540, 36261, 58963, 14087, 7583],
'D3': [49808, 54861, 23578, 45661, 31799]},
'D1': [0.13193584978580475,
{-0.9087742567062378,
0.9034562110900879],
'D2': [51360, 14132, 1910],
'D3': [10120, 13215, 61904, 15328, 42437]}],
'B4': 0.6641326546669006,
'B5': 49943,
'B6': -647636848},
'A4': -7335957737579175198,
'A5': -72}
Задача №12
Реализовать разбор двоичного формата данных. Данные начинаются с сигнатуры 0xf8 0x55 0x42 0x4c
, за которой следует структура
A. Порядок байт: от старшего к младшему. Адреса указаны в виде смещений от начала данных. В решении предлагается использовать модуль
struct.
Структура A:
Поле | Описание |
---|---|
1 | Размер (uint32) и адрес (uint16) массива адресов (uint32) структур B |
2 | Массив char, размер 8 |
3 | float |
4 | int8 |
5 | int32 |
6 | Адрес (uint16) структуры D |
7 | int32 |
Структура B:
Поле | Описание |
---|---|
1 | uint16 |
2 | Массив адресов (uint32) структур C, размер 4 |
3 | uint16 |
4 | uint8 |
5 | int8 |
Структура C:
Поле | Описание |
---|---|
1 | uint16 |
2 | int8 |
Структура D:
Поле | Описание |
---|---|
1 | Размер (uint16) и адрес (uint16) массива double |
2 | int64 |
3 | uint8 |
4 | uint32 |
Ниже показаны примеры разбора двоичного формата.
Пример 1
Двоичные данные:
b'\xf8UBL\x00\x00\x00\x05\x00\xcbymuspmtg>\\\x93\xabS\xce\xd0:\xb1\x00'
(b'\xf7\x9d\xb0\xf8\x0f\x96B\xf8"\x0cv\xf0\x06\xa1\x05-\x15\xfb\x1b\x00'
b"\x00\x00!\x00\x00\x00$\x00\x00\x00'\x00\x00\x00*l:KZ\xaf\xf3=\xf8r"
b'\xab\x88d\x05\xd2\x94Z\xe1W\x00\x00\x00C\x00\x00\x00F\x00\x00\x00'
b'I\x00\x00\x00Lp\xc4\xf6-\x9b\xe5\x1f\xd7\xf75\xea\x94\xcc\x14\xd9@\x92V\x00'
b'\x00\x00e\x00\x00\x00h\x00\x00\x00k\x00\x00\x00n](\xe2w\x8c\xd2\xa4\x1c\x8a'
b'9;K\xa7\x82^\x14\xff{\x00\x00\x00\x87\x00\x00\x00\x8a\x00\x00\x00'
b'\x8d\x00\x00\x00\x90\xcbWQ\x1ae\xfd\x01\x15Q\xe9\xc6\x0eH\xf3\xff'
b'\x03J\x0c\x00\x00\x00\xa9\x00\x00\x00\xac\x00\x00\x00\xaf\x00\x00\x00\xb2v'
b'\xab\x9c\xcf\x00\x00\x00-\x00\x00\x00O\x00\x00\x00q\x00\x00\x00\x93\x00'
b'\x00\x00\xb5\xbf\xb6\xc4\xf4,R\xbd0?\xc4@W7>!8\xbf\xe2\xf6\x1a\x14'
b'\xdc`\xdc\x00\x03\x00\xdf8\xbf\x1c\xaeGe"\xb9\xc0\xd4\xa0\xabD')
Результат разбора:
'A1': [{'B1': 64283,
{'B2': [{'C1': 38466, 'C2': -8},
'C1': 8716, 'C2': 118},
{'C1': 61446, 'C2': -95},
{'C1': 1325, 'C2': 21}],
{'B3': 27706,
'B4': 75,
'B5': 90},
'B1': 57687,
{'B2': [{'C1': 45043, 'C2': 61},
'C1': 63602, 'C2': -85},
{'C1': 34916, 'C2': 5},
{'C1': 53908, 'C2': 90}],
{'B3': 28868,
'B4': 246,
'B5': 45},
'B1': 37462,
{'B2': [{'C1': 39909, 'C2': 31},
'C1': 55287, 'C2': 53},
{'C1': 60052, 'C2': -52},
{'C1': 5337, 'C2': 64}],
{'B3': 23848,
'B4': 226,
'B5': 119},
'B1': 65403,
{'B2': [{'C1': 36050, 'C2': -92},
'C1': 7306, 'C2': 57},
{'C1': 15179, 'C2': -89},
{'C1': 33374, 'C2': 20}],
{'B3': 52055,
'B4': 81,
'B5': 26},
'B1': 18956,
{'B2': [{'C1': 26109, 'C2': 1},
'C1': 5457, 'C2': -23},
{'C1': 50702, 'C2': 72},
{'C1': 62463, 'C2': 3}],
{'B3': 30379,
'B4': 156,
'B5': -49}],
'A2': 'ymuspmtg',
'A3': 0.21540705859661102,
'A4': 83,
'A5': -825214287,
'A6': {'D1': [-0.08894277650937421, 0.1582135219325751, -0.5925417334974799],
'D2': 4089018521523397305,
'D3': 192,
'D4': 3567299396},
'A7': -1649346545}
Пример 2
Двоичные данные:
b'\xf8UBL\x00\x00\x00\x04\x00\xa9jrfaejqi>E\xaeG1\x01\xefYP\x00\xc9%\xf2\xf8'
(b'\x1d\xc0qg\xbcgQ\x97U\xebt\xa4\xc8\xe6:\x00\x00\x00!\x00\x00\x00$\x00'
b"\x00\x00'\x00\x00\x00*\x12\xed\x83\x84{\xa3\xc2\x9fP\xca\xc7\xf4\xaa"
b'\xc3m\x9a\x07\xb0\x00\x00\x00C\x00\x00\x00F\x00\x00\x00I\x00\x00\x00'
b'L\x11\xb2]$\x8b\x03[\t\x9b1\xa9\x90\\\x01\xc4\xa0)\x15\x00\x00\x00e\x00'
b'\x00\x00h\x00\x00\x00k\x00\x00\x00n1\x91\xb4t\x84#9\xe97\xa7\xc8\xea<'
b'k\xca0\\\x9b\x00\x00\x00\x87\x00\x00\x00\x8a\x00\x00\x00\x8d\x00\x00\x00'
b'\x90\xad\xb0\xb9c\x00\x00\x00-\x00\x00\x00O\x00\x00\x00q\x00\x00\x00'
b'\x93?\xe2\xfc\xf7\x16_\xfb\xfa\xbf\xd7b\x05_F\xa5d\x00\x02\x00\xb9\rV\xcf'
b'\xc2\xa6\xa9\x94\x99\xd87dS\xd1')
Результат разбора:
'A1': [{'B1': 58938,
{'B2': [{'C1': 49265, 'C2': 103},
'C1': 48231, 'C2': 81},
{'C1': 38741, 'C2': -21},
{'C1': 29860, 'C2': -56}],
{'B3': 4845,
'B4': 131,
'B5': -124},
'B1': 1968,
{'B2': [{'C1': 31651, 'C2': -62},
'C1': 40784, 'C2': -54},
{'C1': 51188, 'C2': -86},
{'C1': 50029, 'C2': -102}],
{'B3': 4530,
'B4': 93,
'B5': 36},
'B1': 10517,
{'B2': [{'C1': 35587, 'C2': 91},
'C1': 2459, 'C2': 49},
{'C1': 43408, 'C2': 92},
{'C1': 452, 'C2': -96}],
{'B3': 12689,
'B4': 180,
'B5': 116},
'B1': 23707,
{'B2': [{'C1': 33827, 'C2': 57},
'C1': 59703, 'C2': -89},
{'C1': 51434, 'C2': 60},
{'C1': 27594, 'C2': 48}],
{'B3': 44464,
'B4': 185,
'B5': 99}],
'A2': 'jrfaejqi',
'A3': 0.1930476278066635,
'A4': 49,
'A5': 32463184,
'A6': {'D1': [0.593379539204647, -0.36535772613804895],
'D2': 961184005416916121,
'D3': 216,
'D4': 929321937},
'A7': 636680221}
Задача №12
Реализовать разбор двоичного формата данных. Данные начинаются с сигнатуры 0x48 0x46 0x44 0x9b
, за которой следует структура
A. Порядок байт: от младшего к старшему. Адреса указаны в виде смещений от начала данных. В решении предлагается использовать модуль
struct.
Структура A:
Поле | Описание |
---|---|
1 | Адрес (uint16) структуры B |
2 | Адрес (uint32) структуры D |
3 | int16 |
4 | int32 |
Структура B:
Поле | Описание |
---|---|
1 | Размер (uint32) и адрес (uint32) массива char |
2 | Размер (uint16) и адрес (uint16) массива структур C |
3 | uint64 |
Структура C:
Поле | Описание |
---|---|
1 | uint16 |
2 | uint8 |
3 | int16 |
4 | int16 |
5 | Массив uint8, размер 6 |
6 | uint8 |
7 | int16 |
8 | int64 |
Структура D:
Поле | Описание |
---|---|
1 | uint16 |
2 | float |
3 | Размер (uint32) и адрес (uint32) массива int16 |
4 | Размер (uint32) и адрес (uint32) массива uint64 |
5 | uint8 |
6 | float |
7 | uint8 |
Ниже показаны примеры разбора двоичного формата.
Пример 1
Двоичные данные:
b'HFD\x9bB\x00t\x00\x00\x00\x15{\xc8\xee\xa8\xe0um3h\x9a\xe0\x0b\xec9io\xa1'
(b'\xe9F\xa16\xe4\xe5\x1b\x9c\x1f\xc9\xad\x01\x04\xbe\xd3\xc5W\x9e\xd7\x1a'
b'\x91|\x92\x17\x1a\x8c\xbb\xf2\nN\x10\x0e=M\x1f\xdc\x93h\x02\x00'
b'\x00\x00\x10\x00\x00\x00\x02\x00\x12\x00\xd9\xd3%}$\xbf\x98I?\x8d'
b'M\xa7\xd5\xda\\\x92\x89\x87\xa7\x1f\xcd\xaf\xf9x]\x15F\xfa\x97t\xb5Y\xd62'
b'\x08\xea@\xf9\x1e\x15\x1c\xee\x1b?\x03\x00\x00\x00V\x00\x00\x00\x03\x00'
b'\x00\x00\\\x00\x00\x00\x90\xf1\x1a\xfb\xbe\\')
Результат разбора:
'A1': {'B1': 'um',
{'B2': [{'C1': 26675,
'C2': 154,
'C3': 3040,
'C4': 14828,
'C5': [105, 111, 161, 233, 70, 161],
'C6': 54,
'C7': -6684,
'C8': -4754673460681139173},
'C1': 50643,
{'C2': 87,
'C3': -10338,
'C4': -28390,
'C5': [124, 146, 23, 26, 140, 187],
'C6': 242,
'C7': 19978,
'C8': 7535608628518915600}],
'B3': 5303198724668117977},
'A2': {'D1': 5406,
'D2': 0.6091020107269287,
'D3': [-29377, -22707, -9515],
'D4': [12667816131257012828, 8401458808796051705, 17960612634887084469],
'D5': 144,
'D6': -0.49043992161750793,
'D7': 92},
'A3': 31509,
'A4': -525799736}
Пример 2
Двоичные данные:
b'HFD\x9bC\x00s\x00\x00\x00\x9c}\xbc\x18\xf3\x0eyvv\xdd\xff\x82^\xa2'
(b'\xcf\xa4\x8f\xf03\xdbg\r\xe7\xbf\x9eu\x8c\x13\xa2K\x06\xe6\xe7\xa2\x978\xeb`'
b'\xaa\x19!\xfc\xc0\xda\x06\xaeW\x8e#\xd6O]\xf2U\x11\xf8\xf2\x03'
b'\x00\x00\x00\x10\x00\x00\x00\x02\x00\x13\x00\xfc\xd6\x8c7\x9eT\xae\xfbm'
b"\xbd\x88|'C\x02HO\x99\xfd8\xde\x84\x19\x12Wg\x83\xc7\xa1\x01`\xc0\xba"
b'\xfa\xf7\x89&\xbc\xb1\xc0d\xbf\x02\x00\x00\x00W\x00\x00\x00\x03\x00\x00'
b'\x00[\x00\x00\x00z\xc7/\x9c\xbe\t')
Результат разбора:
'A1': {'B1': 'yvv',
{'B2': [{'C1': 65501,
'C2': 130,
'C3': -23970,
'C4': -23345,
'C5': [143, 240, 51, 219, 103, 13],
'C6': 231,
'C7': -24897,
'C8': -1736693684393243531},
'C1': 38818,
{'C2': 56,
'C3': 24811,
'C4': 6570,
'C5': [33, 252, 192, 218, 6, 174],
'C6': 87,
'C7': 9102,
'C8': -938981461470654506}],
'B3': 18135525787981108988},
'A2': {'D1': 48166,
'D2': -0.8935652375221252,
'D3': [-17043, 31880],
'D4': [4106607001021334311, 14376448059160233182, 9941690382442037665],
'D5': 122,
'D6': -0.3050520122051239,
'D7': 9},
'A3': 32156,
'A4': 250812604}