Задача №12
Реализовать разбор двоичного формата данных. Данные начинаются с сигнатуры 0x4b 0x41 0x4d
, за которой следует структура A.
Порядок байт: от старшего к младшему. Адреса указаны в виде смещений от начала данных. В решении предлагается использовать модуль
struct.
Структура A:
Поле | Описание |
---|---|
1 | Массив char, размер 5 |
2 | int64 |
3 | Адрес (uint32) структуры B |
4 | Массив uint32, размер 2 |
5 | Адрес (uint32) структуры D |
Структура B:
Поле | Описание |
---|---|
1 | int16 |
2 | int32 |
3 | Массив адресов (uint16) структур C, размер 5 |
4 | int16 |
Структура C:
Поле | Описание |
---|---|
1 | int16 |
2 | int16 |
3 | int16 |
4 | uint16 |
5 | uint8 |
Структура D:
Поле | Описание |
---|---|
1 | float |
2 | uint32 |
3 | Массив uint64, размер 4 |
4 | Массив int32, размер 2 |
5 | uint8 |
6 | uint16 |
Ниже показаны примеры разбора двоичного формата.
Пример 1
Двоичные данные:
b'KAMutfax\xc1\xfa\x88s7E\xd7\x16\x00\x00\x00M\xda&\x86U\xc0\xde\x90s'
(b'\x00\x00\x00_\r\x18\x0f\xa7\x1c F\x98\r\xbf\x14tP\xc1\x1c\xd5\xfdw%n'
b'\xafZ|\x13\xcd\xfdy\xbav\xdd\xdfm{uw\xf4\xd20\x92\xcb\xb1\x12j\xdc'
b'\xe4\xb3\xc58\xf9\xfbC\x00 \x00)\x002\x00;\x00D\xed\n>\x90u^\x85'
b'\xfd6\x0f\x0bG:\x84\\?nf\xe5(\xb6\xff\xdc\xef0\xdad#K\x19l_\x81+\xde'
b"\xe1\xf0\x8a\xf1U('\x13fq:\x06\x8c\xb1\xa4\x04\xba\xc2")
Результат разбора:
'A1': 'utfax',
{'A2': -4469109651781855466,
'A3': {'B1': -19515,
'B2': 955906883,
'B3': [{'C1': 3352, 'C2': 4007, 'C3': 7200, 'C4': 18072, 'C5': 13},
'C1': -16620,
{'C2': 29776,
'C3': -16100,
'C4': 54781,
'C5': 119},
'C1': 9582, 'C2': -20646, 'C3': 31763, 'C4': 52733, 'C5': 121},
{'C1': -17802, 'C2': -8737, 'C3': 28027, 'C4': 30071, 'C5': 244},
{'C1': -11728,
{'C2': -27957,
'C3': -20206,
'C4': 27356,
'C5': 228}],
'B4': -4854},
'A4': [3659957845, 3235811443],
'A5': {'D1': 0.2821454405784607,
'D2': 2247964175,
'D3': [812682597921418854,
16512649243793502426,
7215693600542130475,
16060382225724942375],
'D4': [325480762, 109883812],
'D5': 4,
'D6': 47810}}
Пример 2
Двоичные данные:
b'KAMpbfny\xdd\xe73[z\x98\xeb\x94\x00\x00\x00Mn\x82!\xa4\x0c\xbc\x94A'
(b'\x00\x00\x00_\x00\xaf\xff\x97\x95\r7&\xb58\xc7\xe9\x83(\xa5\n\xcf\n\xfa\xc3'
b'\x9fl\xeb\x8c\xd8j\x17\xa4\xff\x12B\x84\x02X\xc6H\x8c\x0bfiF\xa7\x8f\xe9'
b',\xcd\xd2\x94\xd9\xab\xb1\x00 \x00)\x002\x00;\x00D\xb7\x12\xbf'
b'\x06\xcf\x1c\x16\xc8\x07X\xd7fL\t\xe8\xc4\xbb\x9et\x13\n\x01\\[\xda\x03\x86'
b'x=\xa6\xa7a\xbd\x08Y\xf1\x97Ac\x8d\xe4\x06\x86\xe4\x1d\x96.\x1f\x8d+\xd5'
b'\xf0\x17')
Результат разбора:
'A1': 'pbfny',
{'A2': -2456938603715433580,
'A3': {'B1': -12846,
'B2': -1797674063,
'B3': [{'C1': 175, 'C2': -105, 'C3': -27379, 'C4': 14118, 'C5': 181},
'C1': 14535, 'C2': -5757, 'C3': 10405, 'C4': 2767, 'C5': 10},
{'C1': -1341, 'C2': -24724, 'C3': -5236, 'C4': 55402, 'C5': 23},
{'C1': -23297, 'C2': 4674, 'C3': -31742, 'C4': 22726, 'C5': 72},
{'C1': -29685, 'C2': 26217, 'C3': 18087, 'C4': 36841, 'C5': 44}],
{'B4': -18670},
'A4': [1854022052, 213685313],
'A5': {'D1': -0.5265977382659912,
'D2': 382207832,
'D3': [15521176771222616990,
8364039933917911555,
9689562384269688072,
6481127645861766150],
'D4': [-2031870570, 773819691],
'D5': 213,
'D6': 61463}}
Задача №12
Реализовать разбор двоичного формата данных. Данные начинаются с сигнатуры 0x46 0x49 0x4f 0xe0
, за которой следует структура
A. Порядок байт: от младшего к старшему. Адреса указаны в виде смещений от начала данных. В решении предлагается использовать модуль
struct.
Структура A:
Поле | Описание |
---|---|
1 | Массив char, размер 7 |
2 | Адрес (uint16) структуры B |
3 | int32 |
4 | uint16 |
5 | uint8 |
6 | Адрес (uint32) структуры E |
Структура B:
Поле | Описание |
---|---|
1 | uint8 |
2 | Размер (uint32) и адрес (uint32) массива адресов (uint32) структур C |
3 | float |
4 | uint16 |
5 | uint64 |
6 | double |
7 | Адрес (uint16) структуры D |
8 | uint16 |
Структура C:
Поле | Описание |
---|---|
1 | uint64 |
2 | Массив int8, размер 7 |
Структура D:
Поле | Описание |
---|---|
1 | Массив uint32, размер 2 |
2 | Размер (uint32) и адрес (uint16) массива int64 |
3 | int16 |
Структура E:
Поле | Описание |
---|---|
1 | uint16 |
2 | int32 |
3 | int8 |
4 | uint64 |
5 | uint32 |
Ниже показаны примеры разбора двоичного формата.
Пример 1
Двоичные данные:
b'FIO\xe0isbrbypn\x00\xe7!\xcc\x8c\x82\xdd\x82\x91\x00\x00\x00\x7fg\xb1\x06'
(b'T\xa7\x11C\xbb\xb0\xbe\x03:\xb8\xcf\xb0 \x97C\x1b\x84\x92\xe1]\xb5\x81^\xd4'
b"\x83\xc3\x18\x00\x00\x00'\x00\x00\x00(-\xd6c1\x19\x7f.|N\xc5?\xb4|"
b'\xe9\x87\xed\x923\xc7\x89\xcc\x8d\xa2\xee\x98!\xea\x98\xdd\x83\x8f\x9fo'
b'\x8dC\x82\x13\x01\x86\x04\x00\x00\x00>\x00\xc1\x9c\xe7\x02\x00\x00\x006'
b'\x00\x00\x00\x7fF]?s\xdd\xdeS\xb1\xa4<\x9fb\xb7x<\x9e\x17\xb2\x1e\xe4'
b'\xbf^\x008\x91\xcc\xeb\xd3&P\xf5Ju\xfdgF\xc3\xf4\xc5\x0e\xe4F\xda\xb2')
Результат разбора:
'A1': 'isbrbyp',
{'A2': {'B1': 231,
'B2': [{'C1': 4832827854476633983,
'C2': [-69, -80, -66, 3, 58, -72, -49]},
'C1': 16254199257766502576,
{'C2': [93, -75, -127, 94, -44, -125, -61]}],
'B3': 0.8643569350242615,
'B4': 56691,
'B5': 13214299339468395486,
'B6': -0.6287470303813185,
'B7': {'D1': [1133342623, 2248217474],
'D2': [3350424347706010920,
-8653248095409844612,
-6733500975724391699,
-8105391255503922962],
'D3': -25407},
'B8': 37176},
'A3': -1932779033,
'A4': 56706,
'A5': 130,
'A6': {'E1': 60364,
'E2': -179296557,
'E3': 74,
'E4': 1064526006480010613,
'E5': 3000649444}}
Пример 2
Двоичные данные:
b'FIO\xe0dprjpbj\x81\x00\xc7\xf2\x00o\x808\xf0\xa4\x00\x00\x00\x8e\x98\xb6l'
(b'\xaa\xa9J\x9chJ\xa2RO\xb7\xe7\xaf\xd5\xea7\x1c\xba\xb0\x8c\xc9\n\x92v8'
b"Rb\xa9\xcb\x8d\xdbD\xc0mSx\x96\x05\t\xb54\xfc\x18\x00\x00\x00'\x00\x00"
b'\x006\x00\x00\x00\x01<H\x16\xb9\x13M9\x08!\xea\xc9\xb27\x86ItI\xf4sw\x07\xc6'
b'\x133\x1a\x94r\x9b\x13\x18o/xK"\xeb\xb4\x87\xf1\x04\x00\x00\x00Q\x00\x83'
b'\x99\xb0\x03\x00\x00\x00E\x00\x00\x00\xf4(\xdc\xbe\x08x(xO\xc2\xe9A>\x94'
b"\xdc(\xaeb\xfdz\xe8\xbfq\x00f=\xb4\xf5\xad\xc6Yrb|\xc95\xca'\xae&Yiif\x02")
Результат разбора:
'A1': 'dprjpbj',
{'A2': {'B1': 176,
'B2': [{'C1': 11262000367626786958,
'C2': [104, 74, -94, 82, 79, -73, -25]},
'C1': 10137807391570974127,
{'C2': [-55, 10, -110, 118, 56, 82, 98]},
'C1': 6011672479583292329,
{'C2': [120, -106, 5, 9, -75, 52, -4]}],
'B3': -0.4299999475479126,
'B4': 30728,
'B5': 10682047838412568616,
'B6': -0.7650134017324279,
'B7': {'D1': [575371311, 4052202731],
'D2': [4128978119032323073,
5297983252679237896,
1424834541737232756,
8005169896014223923],
'D3': -26237},
'B8': 15718},
'A3': 1862333127,
'A4': 14464,
'A5': 240,
'A6': {'E1': 62900,
'E2': 1918486189,
'E3': 98,
'E4': 6424013404410071420,
'E5': 40266089}}
Задача №12
Реализовать разбор двоичного формата данных. Данные начинаются с сигнатуры 0x3d 0x57 0x53 0x57
, за которой следует структура
A. Порядок байт: от младшего к старшему. Адреса указаны в виде смещений от начала данных. В решении предлагается использовать модуль
struct.
Структура A:
Поле | Описание |
---|---|
1 | Массив char, размер 8 |
2 | Структура B |
3 | Массив адресов (uint32) структур E, размер 3 |
4 | Адрес (uint32) структуры F |
5 | float |
Структура B:
Поле | Описание |
---|---|
1 | uint8 |
2 | Адрес (uint32) структуры C |
Структура C:
Поле | Описание |
---|---|
1 | uint16 |
2 | int8 |
3 | Структура D |
4 | int8 |
Структура D:
Поле | Описание |
---|---|
1 | Размер (uint32) и адрес (uint32) массива uint64 |
2 | uint16 |
Структура E:
Поле | Описание |
---|---|
1 | Размер (uint16) и адрес (uint16) массива int16 |
2 | int32 |
Структура F:
Поле | Описание |
---|---|
1 | int64 |
2 | int64 |
3 | float |
Ниже показаны примеры разбора двоичного формата.
Пример 1
Двоичные данные:
b'=WSWrbmanwwp[U\x00\x00\x00g\x00\x00\x00u\x00\x00\x00\x81\x00\x00'
(b'\x00\x89\x00\x00\x00\xbb\xba\x85\xbd\x18\n\xa6\x1c\xd2\xfa&\xfbi7\x04'
b'\x06\xfe7\xb8\xc1tm\x13\xd12\x10\xdc\x84<\xc8\xfb_G\xc2\xa9\xd1\x01\xb7t'
b'\xae\xddH\xc9\x10\xec\xe3\xe1\xc3<\xa0M\xf3Hm\xaa\x06\x00\x00\x00'
b'%\x00\x00\x00\x11\xf8gp\x07\x9bV\x02\x00c\x00K\x99\xfa\xddh/\xf3\xecS'
b'\xeb\x03\x00o\x00\x92\xdf`(\xe8\xa2\x0fe\x02\x00}\x00+\x91\n\xf1\xf9p7'
b'\xca\xd6\x87k\xa7\x00\xb9\xeb\x13p\x07\x9cx\x8fjo>')
Результат разбора:
'A1': 'rbmanwwp',
{'A2': {'B1': 91,
'B2': {'C1': 27976,
'C2': -86,
'C3': {'D1': [18097427932965636632,
13958968609197012841,
9573544718324952436,
15107820036799842364,
1209578091877545729,
17531845107268051948],
'D2': 63505},
'C4': 103}},
'A3': [{'E1': [1904, 22171], 'E2': -570779317},
'E1': [12136, -4877, -5293], 'E2': 677437330},
{'E1': [-23832, 25871], 'E2': -250965717}],
{'A4': {'F1': -6382858690282163975,
'F2': 8690829558870161664,
'F3': 0.23380492627620697},
'A5': -0.06529756635427475}
Пример 2
Двоичные данные:
b'=WSWylpdbwrd6U\x00\x00\x00g\x00\x00\x00w\x00\x00\x00\x83\x00\x00'
(b'\x00\x8b\x00\x00\x00g\xd0l?\x02\x9a+sM\xe0\xa3<:\xfe\xa9\x98\xa0(\n'
b'\xae\xb1N\x17q\xfb<<V\x92\xc1s\x9cU/\x9e\xf0Y\x99\xc0AI\xac\xden\x82\x0fS'
b'\x90\xff\x7f\xc3\xefFf\xa5\x06\x00\x00\x00%\x00\x00\x002)pE\xe4\x07\x14\x02'
b'\x00c\x00$}e\xe8\x9f\xe9\xe8\xfd\xbc\xe3\xa0\xf4\x04\x00o\x007\x01}\xbc\xdb'
b'@I\xea\x02\x00\x7f\x00)g\xd7t\xc6;J1\xe7\x84\x1a\x93\xb1\x95\xdf\xea\x9c'
b'L\xd3\x11\xd1\x0e\x12>')
Результат разбора:
'A1': 'ylpdbwrd',
{'A2': {'B1': 54,
'B2': {'C1': 26182,
'C2': -91,
'C3': {'D1': [4369582686728854018,
12540880782587723322,
6213908636496252593,
17338347660166545810,
7989012219637569881,
17276793331138105218],
'D2': 10546},
'C4': 112}},
'A3': [{'E1': [-7099, 5127], 'E2': -396002012},
'E1': [-5729, -536, -7236, -2912], 'E2': -1132658377},
{'E1': [16603, -5559], 'E2': 1960273705}],
{'A4': {'F1': -7846813272240407610,
'F2': 1284454555569853873,
'F3': 0.14263464510440826},
'A5': 0.9250549674034119}
Задача №12
Реализовать разбор двоичного формата данных. Данные начинаются с сигнатуры 0xb 0x4d 0x44 0x58
, за которой следует структура
A. Порядок байт: от старшего к младшему. Адреса указаны в виде смещений от начала данных. В решении предлагается использовать модуль
struct.
Структура A:
Поле | Описание |
---|---|
1 | Структура B |
2 | int64 |
3 | Структура C |
4 | Размер (uint32) и адрес (uint16) массива uint32 |
5 | Размер (uint32) и адрес (uint16) массива uint32 |
Структура B:
Поле | Описание |
---|---|
1 | Массив char, размер 6 |
2 | int64 |
3 | int16 |
Структура C:
Поле | Описание |
---|---|
1 | int32 |
2 | int64 |
3 | int16 |
4 | Размер (uint16) и адрес (uint32) массива структур D |
5 | int32 |
6 | float |
Структура D:
Поле | Описание |
---|---|
1 | Размер (uint32) и адрес (uint16) массива uint8 |
2 | int64 |
3 | int8 |
Ниже показаны примеры разбора двоичного формата.
Пример 1
Двоичные данные:
b'\x0bMDXzgwpnt\x9aqtu\x04&\x14\xfa\xda(*\x07J\xff\xa4\xc6\x7f_\xe6\xc5_\x03'
(b'no\x9e\xf4\xdd\tOm\x90G\x00\x03\x00\x00\x00M-$\xa0)?Jv\xf1\x00\x00\x00\x03'
b'\x00z\x00\x00\x00\x05\x00\x86x\xff\xdas\x97b\x93\xde\xf2\x00\x00\x00'
b'\x03\x00Dj^\x0f\xc8\xc8j\xe4\xf2\x0e\x00\x00\x00\x03\x00G\x88\xd6p\xb6l\x16'
b'f\x14\xe0\x00\x00\x00\x03\x00J\x10a\x07*\x83|L48/C\x02\xbbR\xbe\xa2\xee\xe40'
b'm\xed\xe97$\xc3\xf8\x1bJ\xc1Y\xc5\xe2U\x85v{^Ml\xda3')
Результат разбора:
'A1': {'B1': 'zgwpnt', 'B2': -7317939873570745094, 'B3': -9688},
{'A2': 3028471736271535967,
'A3': {'C1': -423272701,
'C2': 7957753841104539501,
'C3': -28601,
'C4': [{'D1': [120, 255, 218], 'D2': 7664580970861487346, 'D3': 14},
'D1': [115, 151, 98], 'D2': -8586551710735505900, 'D3': -32},
{'D1': [147, 222, 242], 'D2': 1180232456523762740, 'D3': 56}],
{'C5': 757375017,
'C6': 0.7908774018287659},
'A4': [792920763, 1388225262, 3828379117],
'A5': [3912705219, 4162538177, 1506140757, 2239134558, 1298979379]}
Пример 2
Двоичные данные:
b'\x0bMDXosrucc\xba\xdc\x9c\xaa\x9b\x1c<\x8f\xee\xf3A\x0fB\xd3\x83\xf5`\xe1'
(b'\xe5\x03\x8d\xf5\xbdv\xe2\xec\x0c(2\x89C}\x00\x02\x00\x00\x00N\x80\x97\x8f@'
b'>_\xb5]\x00\x00\x00\x05\x00l\x00\x00\x00\x02\x00\x80\x9ak\xa6!;~\x0bm'
b'\x9et\x00\x00\x00\x07\x00Dn\xa5(\\\xb6\xa7\xd7(\x14\x00\x00\x00\x03\x00K\x90'
b'.\xa1ku\xaf\xaey\x83W\xe6.\xdc\x8a\xf7A\xf0X\xf9\xf8\x13\xb1\xf8\x89g'
b'\x18\xe8\x0e\xfe|\xbe\x8a1S\xfe\x08\xbf')
Результат разбора:
'A1': {'B1': 'osrucc', 'B2': -4981934831217918833, 'B3': -4365},
{'A2': 4688039213335404769,
'A3': {'C1': -452751883,
'C2': -4794395249845194103,
'C3': 17277,
'C4': [{'D1': [154, 107, 166, 33, 59, 126, 11],
'D2': 7972823093995886376,
'D3': 20},
'D1': [109, 158, 116], 'D2': -8057325200411218311, 'D3': -125}],
{'C5': -2137551040,
'C6': 0.21846528351306915},
'A4': [1474703068, 2331460080, 1492776979, 2985855335, 417861374],
'A5': [2092862001, 1409157311]}
Задача №12
Реализовать разбор двоичного формата данных. Данные начинаются с сигнатуры 0x59 0x55 0x54
, за которой следует структура A.
Порядок байт: от старшего к младшему. Адреса указаны в виде смещений от начала данных. В решении предлагается использовать модуль
struct.
Структура A:
Поле | Описание |
---|---|
1 | Структура B |
2 | Размер (uint32) и адрес (uint32) массива int32 |
3 | Размер (uint16) и адрес (uint16) массива int16 |
4 | uint16 |
5 | int8 |
Структура B:
Поле | Описание |
---|---|
1 | Структура C |
2 | float |
3 | uint64 |
4 | Размер (uint16) и адрес (uint32) массива int64 |
Структура C:
Поле | Описание |
---|---|
1 | int32 |
2 | double |
3 | Размер (uint32) и адрес (uint32) массива адресов (uint32) структур D |
4 | uint16 |
5 | int8 |
Структура D:
Поле | Описание |
---|---|
1 | Массив int32, размер 5 |
2 | int16 |
3 | int16 |
4 | uint64 |
5 | int32 |
6 | uint8 |
7 | uint8 |
8 | uint8 |
Ниже показаны примеры разбора двоичного формата.
Пример 1
Двоичные данные:
b'YUTs\xbf$\x9b\xbf\xeb\x98N\xb5\xcb\xa0\xde\x00\x00\x00\x02\x00'
(b'\x00\x00\x89\x8b\xbf\xbb\xbe\xaf\xeajVY\xb9\xda\xaczA\xaf\x00\x03'
b'\x00\x00\x00\x91\x00\x00\x00\x02\x00\x00\x00\xa9\x00\x02\x00\xb1'
b'\xda\xc8\xce\x92\x97\xe44,\xd4l\x95\xa0\x99>\xf0\xd4\xc2g_x\x92t*\xaek \x17$'
b'm\xe1\xd7\x00\xcd\xebQ,\xb6\xa8\xa2ZB`#\x1bX\t\xad`;$$|`\x01\x16\xec'
b"\x951\xcb\x9f\xe5>jp<\xf5\xe6\x93\xa96W\x9dG;%\x0c'^\xd7u7\x00\x00\x00"
b';\x00\x00\x00bk\xa4\xe2\xdcm{\xe9S\x91\xbf\xcfo\xff\xc8\x9a\xf6D\xecw'
b'N\xd3\x1d\xe8 \xd8\xb7\ra)m\x85o\x9dJ\xc1\xf8')
Результат разбора:
'A1': {'B1': {'C1': 1941906587,
{'C2': -0.8623422194187034,
'C3': [{'D1': [-1835539404,
752118933,
-1600569616,
-725457057,
2022863914],
'D2': -20885,
'D3': 8215,
'D4': 2625002471374580561,
'D5': 750168226,
'D6': 90,
'D7': 66,
'D8': 96},
'D1': [588994569,
{-1386202332,
612130817,
384603441,
-878713538],
'D2': 27248,
'D3': 15605,
'D4': 16614809501163145019,
'D5': 621553502,
'D6': 215,
'D7': 117,
'D8': 55}],
'C4': 35775,
'C5': -69},
'B2': -0.3435853123664856,
'B3': 6222208709036753327,
'B4': [7756573894596356435, -7944403137718609162, 4966475669515921440]},
'A2': [-659092127, 695043439],
'A3': [-25270, -15880],
'A4': 56008,
'A5': -50}
Пример 2
Двоичные данные:
b'YUT\x03X%\xdd\xbf\xe70\xdeh\x1e7N\x00\x00\x00\x02\x00\x00\x00\x89\xe1/{>\x9f'
(b'\x80K6r\x11%\x85k_V\x00\x02\x00\x00\x00\x91\x00\x00\x00\x02\x00\x00\x00\xa1'
b'\x00\x02\x00\xa9\xfe\r3\x95)\x98pj\xc4\r\x12\xb0\xc8F\xaa\n\x14\xe7\xe9&'
b'D\xaez\x17?O!\xa0\x12\xdeY2IP?W\xb5\xbc\xaf\x05kr\x86\n\xe23G\xc9)\xf8\x18j'
b'\x0bqB\x89;%\x89\xe76O\x86\xf1\xfaE\xa2\xc6v\xebV%\xd8\x19:\x89>%\xb67'
b'\xac\x00\x00\x00;\x00\x00\x00ba\x02\x8d\x98\rL\xfc\xeb\xf4v2\xa3\xc0\xd4\x9e'
b'\xad\x9cp\x12\xa7GU>\xc5b\xa3R\xfa')
Результат разбора:
'A1': {'B1': {'C1': 56108509,
{'C2': -0.7247154267840672,
'C3': [{'D1': [-1792436112,
1791233298,
-1329051990,
169142249,
642035322],
'D2': 5951,
'D3': 20257,
'D4': 11534526070326382655,
'D5': 1471528111,
'D6': 5,
'D7': 107,
'D8': 114},
'D1': [-2046107085,
{1204365816,
409602929,
1116289829,
-1981335985],
'D2': -30991,
'D3': -1467,
'D4': 11729193032667748377,
'D5': 982072869,
'D6': 182,
'D7': 55,
'D8': 172}],
'C4': 57647,
'C5': 123},
'B2': 0.3115256726741791,
'B3': 3923217078242991958,
'B4': [6990305255830125803, -831421402307060051]},
'A2': [-1670376793, 1196768965],
'A3': [25251, 21242],
'A4': 65037,
'A5': 51}
Задача №12
Реализовать разбор двоичного формата данных. Данные начинаются с сигнатуры 0x51 0x4a 0x42 0x4d
, за которой следует структура
A. Порядок байт: от старшего к младшему. Адреса указаны в виде смещений от начала данных. В решении предлагается использовать модуль
struct.
Структура A:
Поле | Описание |
---|---|
1 | Адрес (uint32) структуры B |
2 | Размер (uint16) и адрес (uint32) массива структур D |
3 | float |
4 | double |
5 | uint8 |
6 | Размер (uint16) и адрес (uint32) массива uint32 |
7 | int64 |
8 | uint64 |
Структура B:
Поле | Описание |
---|---|
1 | Адрес (uint16) структуры C |
2 | Массив char, размер 3 |
Структура C:
Поле | Описание |
---|---|
1 | Размер (uint16) и адрес (uint16) массива char |
2 | float |
3 | int8 |
4 | uint16 |
5 | uint16 |
6 | uint16 |
Структура D:
Поле | Описание |
---|---|
1 | Размер (uint32) и адрес (uint32) массива uint16 |
2 | uint64 |
3 | uint32 |
4 | uint8 |
5 | int8 |
Ниже показаны примеры разбора двоичного формата.
Пример 1
Двоичные данные:
b'QJBM\x00\x00\x00D\x00\x03\x00\x00\x00[\xbe\xef\xabl\xbf\xe3\xc0\x8e\x0c~'
(b'\x8e *\x00\x02\x00\x00\x00\x9d\xd6(\xe7\xef\x0c\xc6\xc4\x7f\xefg\x01'
b'\xd3\x9c(\x13\x8fbifx\x00\x04\x001\xbe\x9f\xbb\x16\xd1\xa7\x9d]\xd3.\xfe'
b'\x005afo\xd82Ur\xa6d\xf4\x14\xbc\xa2\xf0_\x1ep\xc3\x18\r[\x00'
b'\x00\x00\x05\x00\x00\x00I\x03M\xd8\x84\x8c\xd7\t0wA\xb4\xee\xcb'
b'\xfe\x00\x00\x00\x02\x00\x00\x00S\xa8\xd1p\xeb\x14\xd0R\xf4*\xa0\xd8'
b'\xec9\xd7\x00\x00\x00\x02\x00\x00\x00W\xfd\xf3\x02\x0bO\x1dp>O'
b'\xda\xc1\x81\xa9~e\xa6g h\xbc\xe9E')
Результат разбора:
'A1': {'B1': {'C1': 'bifx',
{'C2': -0.3119742274284363,
'C3': -47,
'C4': 42909,
'C5': 24019,
'C6': 12030},
'B2': 'afo'},
'A2': [{'D1': [55346, 21874, 42596, 62484, 48290],
'D2': 238084419130689840,
'D3': 2000794862,
'D4': 203,
'D5': -2},
'D1': [61535, 7792],
{'D2': 12164628223473242868,
'D3': 715184364,
'D4': 57,
'D5': -41},
'D1': [49944, 3419],
{'D2': 18298971958531682366,
'D3': 1339736449,
'D4': 169,
'D5': 126}],
'A3': -0.4681047201156616,
'A4': -0.6172552341490167,
'A5': 42,
'A6': [1705404192, 1757210949],
'A7': -3014904936626994049,
'A8': 17250758906035573647}
Пример 2
Двоичные данные:
b'QJBM\x00\x00\x00B\x00\x03\x00\x00\x00a?fs\xe9?\xdb\xa3\xc9[\x1f'
(b'\xb1\xc0\xbd\x00\x03\x00\x00\x00\xa3EIW\x0ceG\xbf\xe8\xbd\x10\xf2x\x1d\xa4W'
b'<qd\x00\x02\x001?&z}\x9a\xd0\xb1\x8b\x03\x04\xb7\x003zac\xc49\xc9f\xef'
b'\x04} M\xa5\xa7\x9e\\\xbb\x1e\xaa=\xa8jZ\x19\xb7\xb2\x13\xfc\x00\x00\x00\x00'
b'\x04\x00\x00\x00G\x1e\xde\xef!\\\xca\xbe\x0fH\xc2\x9fy%=\x00\x00\x00\x05\x00'
b"\x00\x00O\xb7\x16'\xb3\xe6T\x85*x\x7f\x85\x8b\x1e\x8f\x00\x00\x00"
b'\x04\x00\x00\x00Y2%\xc5\xf2,\xd2\xac!\x0e\xad\x05>\xc3\x7f\xa1X\xa1\xa09'
b'\x1fi7\xcbh\x9a\x12')
Результат разбора:
'A1': {'B1': {'C1': 'qd',
{'C2': 0.6503065228462219,
'C3': -102,
'C4': 53425,
'C5': 35587,
'C6': 1207},
'B2': 'zac'},
'A2': [{'D1': [50233, 51558, 61188, 32032],
'D2': 2224478192537353743,
'D3': 1220714361,
'D4': 37,
'D5': 61},
'D1': [19877, 42910, 23739, 7850, 15784],
{'D2': 13192775812045374762,
'D3': 2021623179,
'D4': 30,
'D5': -113},
'D1': [27226, 6583, 45587, 64512],
{'D2': 3613511919959452705,
'D3': 246220094,
'D4': 195,
'D5': 127}],
'A3': 0.9002061486244202,
'A4': 0.431871737468807,
'A5': 189,
'A6': [2706940320, 958359863, 3412630034],
'A7': 4992617372667330536,
'A8': 13623655470503057212}
Задача №12
Реализовать разбор двоичного формата данных. Данные начинаются с сигнатуры 0x4e 0x59 0x48
, за которой следует структура A.
Порядок байт: от старшего к младшему. Адреса указаны в виде смещений от начала данных. В решении предлагается использовать модуль
struct.
Структура A:
Поле | Описание |
---|---|
1 | Структура B |
2 | int16 |
3 | Структура D |
Структура B:
Поле | Описание |
---|---|
1 | int32 |
2 | double |
3 | int32 |
4 | int32 |
5 | Массив структур C, размер 2 |
Структура C:
Поле | Описание |
---|---|
1 | Массив int8, размер 4 |
2 | double |
3 | int16 |
4 | int64 |
5 | Размер (uint16) и адрес (uint32) массива uint32 |
Структура D:
Поле | Описание |
---|---|
1 | int16 |
2 | Размер (uint32) и адрес (uint32) массива float |
3 | Размер (uint16) и адрес (uint32) массива uint16 |
Ниже показаны примеры разбора двоичного формата.
Пример 1
Двоичные данные:
b'NYH\x99\xae0\xcb?\xbb\xcd\x92Y\xd6-\xc0\xd7FN\xd6 XG\xe4\xa8\xce\xb3\x1e?'
(b'\xe6d\x85@U\xa7\x9c8\x85r\x8bk=\xc3!D\x8f\x00\x03\x00\x00\x00a\xeb`#\xcd?'
b'\xe6Z?\xa8n\xe2\x98X\xf9I\rj_\xfaJ]r\x00\x03\x00\x00\x00m\xee'
b'\x88\x99\xf2\x00\x00\x00\x04\x00\x00\x00y\x00\x05\x00\x00\x00\x89\xcf1\xd7'
b'\x99\xa8\x18Hr\x999\x0b\xf8\xf6J\r\xe7\xcb\xbe\n\x14\xa9h\xa7n?_\x16'
b'\x93\xbe\xc4\xaa\xfb\xbe\x18\xc5\xeb?_\xd1s\xcf\xc4\xe1\x9b\xf7`\x84'
b'\x87\x1c\xf6')
Результат разбора:
'A1': {'B1': -1716637493,
{'B2': 0.1086055249526714,
'B3': -683258154,
'B4': 542656484,
'B5': [{'C1': [-88, -50, -77, 30],
'C2': 0.6997705704245507,
'C3': 14469,
'C4': 8253808655097480335,
'C5': [3476150169, 2820163698, 2570652664]},
'C1': [-21, 96, 35, -51],
{'C2': 0.6985166825971474,
'C3': 22777,
'C4': 5263980499919592818,
'C5': [4132048359, 3418229268, 2842208110]}]},
'A2': -4472,
'A3': {'D1': -26126,
'D2': [0.871438205242157,
-0.3841169774532318,
-0.14919249713420868,
0.8742896914482117],
'D3': [53188, 57755, 63328, 33927, 7414]}}
Пример 2
Двоичные данные:
b'NYHo\xf1+L\xbf\xc6:\x02\x99\x12Up\xa1\xb6\xde\x1d6\xebg~N\xd3b\xac\xbf'
(b"\xe4m\x9a\xf4|'\xbc(\xb0\xcdDP+\xa4\xb0\xd7~\x00\x04\x00\x00\x00a!"
b'\x15n\xb6\xbf\xdbg\x87B\x10\x1e\xa0k\xc68\x05\rH\xb5\xbd2\xcc\x00\x05\x00'
b'\x00\x00q\x1dr\xb0\xb1\x00\x00\x00\x02\x00\x00\x00\x85\x00\x07\x00\x00\x00'
b'\x8d9\x81\x8d-Q\x9f\x11c\x93\xb4\xa8E\x8b\x0e\xe6N]\x1c\x89\xe9\xb5a\xa1'
b'\xaf\x99\xb8\xdeW\x82\n5I7\xb8\xd0U>\xf7\x80\x9d\xbd\xbb\n\x1f\x05\x00>'
b'\x9d\xd9\x08|\x87r(<\xeaZ0')
Результат разбора:
'A1': {'B1': 1878076236,
{'B2': -0.17364532922935494,
'B3': -1581851107,
'B4': 921397118,
'B5': [{'C1': [78, -45, 98, -84],
'C2': -0.6383795523736278,
'C3': 10416,
'C4': -3655708849141131394,
'C5': [964791597, 1369379171, 2478090309, 2333009486]},
'C1': [33, 21, 110, -74],
{'C2': -0.4281938691278615,
'C3': 27590,
'C4': 4036647246945399500,
'C5': [1562151401,
3043074479,
2579029591,
2181707081,
934858837]}]},
'A2': 7538,
'A3': {'D1': -20303,
'D2': [0.48340311646461487, -0.09132789820432663],
'D3': [1280, 16029, 55560, 31879, 29224, 15594, 23088]}}
Задача №12
Реализовать разбор двоичного формата данных. Данные начинаются с сигнатуры 0xe9 0x42 0x41 0x48 0x46
, за которой следует
структура A. Порядок байт: от младшего к старшему. Адреса указаны в виде смещений от начала данных. В решении предлагается использовать
модуль struct.
Структура A:
Поле | Описание |
---|---|
1 | Размер (uint16) и адрес (uint16) массива адресов (uint32) структур B |
2 | float |
3 | Массив int8, размер 5 |
4 | uint8 |
5 | uint16 |
6 | Массив uint8, размер 5 |
Структура B:
Поле | Описание |
---|---|
1 | uint8 |
2 | double |
3 | Адрес (uint32) структуры C |
4 | Структура D |
Структура C:
Поле | Описание |
---|---|
1 | int32 |
2 | uint32 |
Структура D:
Поле | Описание |
---|---|
1 | Структура E |
2 | double |
3 | int32 |
Структура E:
Поле | Описание |
---|---|
1 | int8 |
2 | int32 |
3 | int16 |
4 | uint16 |
5 | double |
6 | Размер (uint32) и адрес (uint16) массива uint8 |
7 | uint64 |
Ниже показаны примеры разбора двоичного формата.
Пример 1
Двоичные данные:
b'\xe9BAHF\x02\x00\x9e\x002]\xac>\xaas/x\xd3\x83\xf7\xde@H\x9c\x1f\xc6\xb5J'
(b'J\xe7\x9c\xa5n\x16\xf6\xa5f$\x1bAN\x98\x99\xeb\xbf\x1a\x00\x00\x00 ?6'
b'\xe7\xac\xb3\xde\xca\xb3\xc8A \x8c3\xe9\xe4?\x02\x00\x00\x00"\x00'
b'\x14"\xd3\xb3I\x9dh\xf44\xa0\xd9\xef\xa9$\xd3\xbf\x9cG-\n\xce\xa9x\x08'
b'\xad\xbf\x89\n\x0fiw\xa0\xb8\xcb\x8e\xaf\xc5\xd1?\\\x00\x00\x00:'
b'\x81\x84\x9c\xd7\xf8\xcb\x17i@W\xdc6\xe8\x92\xdf\xbf\x02\x00\x00\x00d\x00}w'
b'\xc9\xc7\xe3Rdf@ROo\xd6\xca\xe5\xbf#\x8f\x16A$\x00\x00\x00f\x00\x00\x00')
Результат разбора:
'A1': [{'B1': 102,
{'B2': -0.8624993828205771,
'B3': {'C1': -414561611, 'C2': 376350108},
'B4': {'D1': {'E1': 32,
'E2': -1394133441,
'E3': -8525,
'E4': 46026,
'E5': 0.6534669625125895,
'E6': [246, 165],
'E7': 17611499282707456532},
'D2': -0.2991127817426815,
'D3': 170739612}},
'B1': 119,
{'B2': 0.27769078202153175,
'B3': {'C1': 142125518, 'C2': 176799661},
'B4': {'D1': {'E1': 58,
'E2': -677608319,
'E3': -13320,
'E4': 26903,
'E5': -0.4933414970158658,
'E6': [15, 105],
'E7': 7378113227802638205},
'D2': -0.6810104536076054,
'D3': 1091997475}}],
'A2': 0.33664852380752563,
'A3': [-86, 115, 47, 120, -45],
'A4': 131,
'A5': 57079,
'A6': [64, 72, 156, 31, 198]}
Пример 2
Двоичные данные:
b'\xe9BAHF\x02\x00\x9e\x00T\xcd\xe1\xbe\xf9v\xef\xc8!3&V\xd8\xa4\xe3'
(b'\xf8&\x9e\x1f\xe4\x0c\xc3\xb2\xd7V"^\xda\x80\n\xfe\x19Y\x87\xe8'
b'\xbf\x1a\x00\x00\x00\xea\x7f\xa2Q\x05\x16\x17q\xc0\xbc\x97\x1e9<\xc4'
b'\xe3\xbf\x02\x00\x00\x00"\x00+q\xa1\x80\x91\xb1^A\x98a\xd9\xba\xe6c\xdd?'
b'\xe7\xd3\xff];GZ\xa89jX\xf8\xce\xfd\x14\xb4\x91!\xa82\x14\xe2?\\'
b'\x00\x00\x00\x1f\xed[\xeb\xbbW\xad\x857\xfc|\xe3,\xcc\x9f\xea\xbf'
b'\x02\x00\x00\x00d\x00\xed}\xf6\xec\x18\xb81\xc1\x9e8\xabz\xb4\x82\xe8?;\x8e'
b'*\\$\x00\x00\x00f\x00\x00\x00')
Результат разбора:
'A1': [{'B1': 218,
{'B2': -0.7665219791091005,
'B3': {'C1': 216276894, 'C2': 1456976579},
'B4': {'D1': {'E1': -22,
'E2': 89236095,
'E3': 5910,
'E4': 49265,
'E5': -0.617704497872857,
'E6': [34, 94],
'E7': 4710397498762555691},
'D2': 0.45922249075877053,
'D3': 1577047015}},
'B1': 20,
{'B2': 0.564965561276543,
'B3': {'C1': -1470478533, 'C2': 4166543929},
'B4': {'D1': {'E1': 31,
'E2': -1142203411,
'E3': -21161,
'E4': 14213,
'E5': -0.8320065380793547,
'E6': [206, 253],
'E7': 13921110340373216749},
'D2': 0.7659551998019827,
'D3': 1546292795}}],
'A2': -0.4410196542739868,
'A3': [-7, 118, -17, -56, 33],
'A4': 51,
'A5': 22054,
'A6': [216, 164, 227, 248, 38]}
Задача №12
Реализовать разбор двоичного формата данных. Данные начинаются с сигнатуры 0x5d 0x4c 0x59 0x57 0x49
, за которой следует
структура A. Порядок байт: от старшего к младшему. Адреса указаны в виде смещений от начала данных. В решении предлагается использовать
модуль struct.
Структура A:
Поле | Описание |
---|---|
1 | Размер (uint32) и адрес (uint16) массива char |
2 | uint8 |
3 | Адрес (uint32) структуры B |
4 | Массив структур E, размер 3 |
5 | uint8 |
6 | int64 |
7 | uint32 |
Структура B:
Поле | Описание |
---|---|
1 | uint16 |
2 | uint16 |
3 | Адрес (uint32) структуры C |
Структура C:
Поле | Описание |
---|---|
1 | int16 |
2 | int8 |
3 | Структура D |
Структура D:
Поле | Описание |
---|---|
1 | Массив uint32, размер 4 |
2 | uint16 |
3 | uint32 |
4 | float |
5 | uint16 |
6 | int64 |
7 | int8 |
8 | int32 |
Структура E:
Поле | Описание |
---|---|
1 | Массив uint32, размер 5 |
2 | int8 |
Ниже показаны примеры разбора двоичного формата.
Пример 1
Двоичные данные:
b']LYWI\x00\x00\x00\x02\x00\\\x83\x00\x00\x00\x8aTk)5\x00\xca\xbf\xfd'
(b'\x8f\xd4c\xba\x94d\x1a~\x1e1\xb7`\x9ei\xef\xcd\xa8D\xe6\x9bm\xf62\xf2'
b'\xd2\x82\x82\x89\x03k\x08\x9b\xe0\x1eE\xdd\x9aT\xe8\x0c\x0ccT\x9f'
b'\x0cH\x1a\xc4\xebG\xa1&\x99\xf3kD\xd3u\xab\xc0c\xa4Wa#a\x7f\xe9zj\x1f\xac'
b'\xb0p\xfa\xe7\x1f\xc83x&)\xc9|%@\xdbUw\x1d\x04W~\xdf<?(\xeeG\xda</4$'
b'\xaf\x19\xa0?\xbb\xfcv]\xd0\xf8\xdbO\x1c\xdd\x00\x00\x00^')
Результат разбора:
'A1': 'zj',
{'A2': 131,
'A3': {'B1': 56143,
'B2': 7389,
'B3': {'C1': 8108,
'C2': -80,
'C3': {'D1': [1895491359, 3358816294, 701070373, 1088116087],
'D2': 7428,
'D3': 1467932476,
'D4': 0.659885823726654,
'D5': 55868,
'D6': 3401383953039376315,
'D7': -4,
'D8': 1985859832}}},
'A4': [{'E1': [1416309045, 13287421, 2413061050, 2489588350, 506574688],
'E2': -98},
'E1': [1777323432, 1155963757, 4130534098, 2189592835, 1795726304],
{'E2': 30},
'E1': [1172150868, 3893103715, 1419709512, 449112903, 2703661555],
{'E2': 107}],
'A5': 68,
'A6': -3209470316637825183,
'A7': 593592297}
Пример 2
Двоичные данные:
b']LYWI\x00\x00\x00\x02\x00\\\xa3\x00\x00\x00\x8a\x83Q\xdb\x19U\t\x90S'
(b'5O\x8b\x9a#\x06\x95\x9es\xc2}wU\xa5x(\xbb\xd0\x8fT\x89\xb1_\x9c'
b'\x04\t\xfc\x15\x85\x98\xc0O\xa1\x08\xfal\xa8vuU\xcd=\x90\xff\x1d\xe0N\x99'
b'!\x84~\xf7\xdc\x9d\x95\xef\xd51\x1f\xaa\xb6\xc7\xbd\xbbTt\x08\xfbyh0|'
b'V\x8f\xc9\xcf\xc8?\x9d\x1a\xe6I\xbaR:\x9cI"\xdc\xdf\xf7\xee\x1f\xf7r\xbe'
b'\xffy\x01w\x11 v^C\x0f@\xe5\xad\xae\xf5\xed\x91\xf3\xab$J\x1c\x00\x00\x00^')
Результат разбора:
'A1': 'yh',
{'A2': 163,
'A3': {'B1': 43812,
'B2': 18972,
'B3': {'C1': 12412,
'C2': 86,
'C3': {'D1': [2412367816, 1067260646, 1236947514, 2622038748],
'D2': 57335,
'D3': 3995072370,
'D4': -0.49897006154060364,
'D5': 30481,
'D6': 2339160698577282477,
'D7': -82,
'D8': -168979981}}},
'A4': [{'E1': [2203179801, 1426690131, 894405530, 587634078, 1942125943],
'E2': 85},
'E1': [2776115387, 3499054217, 2975833092, 167515525, 2562740129],
{'E2': 8},
'E1': [4201425014, 1968557373, 2432638432, 1318658436, 2130173085],
{'E2': -107}],
'A5': 239,
'A6': -3084649451700634181,
'A7': 1416890619}
Задача №12
Реализовать разбор двоичного формата данных. Данные начинаются с сигнатуры 0x58 0x50 0x4b
, за которой следует структура A.
Порядок байт: от старшего к младшему. Адреса указаны в виде смещений от начала данных. В решении предлагается использовать модуль
struct.
Структура A:
Поле | Описание |
---|---|
1 | uint16 |
2 | int16 |
3 | int64 |
4 | uint64 |
5 | Структура B |
6 | Массив char, размер 2 |
7 | Адрес (uint32) структуры D |
Структура B:
Поле | Описание |
---|---|
1 | uint32 |
2 | uint8 |
3 | uint16 |
4 | Размер (uint32) и адрес (uint32) массива структур C |
5 | uint8 |
6 | double |
Структура C:
Поле | Описание |
---|---|
1 | int8 |
2 | int32 |
3 | Массив uint8, размер 7 |
4 | int16 |
5 | uint16 |
Структура D:
Поле | Описание |
---|---|
1 | uint32 |
2 | Массив uint8, размер 4 |
3 | uint64 |
4 | uint8 |
5 | Массив uint16, размер 5 |
Ниже показаны примеры разбора двоичного формата.
Пример 1
Двоичные данные:
b'XPKc!e"z><\x1bu\x9au\xda\x15\x8c\xf9\x85\r\xbd\xfek\xcf\xaf\xe7\xc2\xaa'
(b'\x10\xb1\x00\x00\x00\x03\x00\x00\x005\x1d\xbf\xed`,\xca\xeb&2wm\x00\x00\x00'
b'e@\x16\x98n\x0c\xe9D\xf1BaN\xc6\x84\\J\xc8\x07\xf9T\xd3m\x17t\\\xea+\x07'
b'\x92\x8a\xf7\xd8\xedKSc-\x01$J\xeb\x954\x92\xcb\x99\xc0\xd51\xce\x0eT'
b'\x9c8\xb5\xa9\xa5\x81\xa6d\xbb\xae\xffr\n\x02\x8e\xd9\x9dH<\xce~\x95-\x96')
Результат разбора:
'A1': 25377,
{'A2': 25890,
'A3': 8808544009818109402,
'A4': 1552890321392500331,
'A5': {'B1': 3484411842,
'B2': 170,
'B3': 4273,
'B4': [{'C1': 64,
'C2': 379088396,
'C3': [233, 68, 241, 66, 97, 78, 198],
'C4': -31652,
'C5': 19144},
'C1': 7,
{'C2': -111881363,
'C3': [23, 116, 92, 234, 43, 7, 146],
'C4': -29961,
'C5': 55533},
'C1': 75,
{'C2': 1399008513,
'C3': [36, 74, 235, 149, 52, 146, 203],
'C4': -26176,
'C5': 54577}],
'B5': 29,
'B6': -0.9179901088002167},
'A6': 'wm',
'A7': {'D1': 3457045660,
'D2': [56, 181, 169, 165],
'D3': 9342265234284311050,
'D4': 2,
'D5': [36569, 40264, 15566, 32405, 11670]}}
Пример 2
Двоичные данные:
b'XPKv\t\xe5\xa1\xf7\x12\xb18y\xb1\xe7q\xa6k\x89\x91\xc1\x9c`\xa3\xae'
(b'\xcd4\xbb\xf7a\x1a\x00\x00\x00\x05\x00\x00\x005o\xbf\xc6]\x0e\xab\x0e\xe4xq'
b'h\x00\x00\x00\x85\xdc`\\-\x94\x91\xa6\xfcZ\x86=\xfdl\xf2$\xc6\x0b\xfd\xc5'
b'\xf8\xd7u\xd3\x07k\xe4\x17\x17\x83\x04O#\xb8\x15\xc1g\xbf\xdd\xd6'
b'\x16\x1f\xc2\xf7 \x8a:\xccP\xbf\xa2\x91\xa6%>\x08\x98\xb49\x08'
b'\xa0\x83\x9e\xd3\xf0u\x83\xe4v\xa5\x98\x0eV\xc5b*p}\xe0E"\xf3\xe3?'
b'\xf8&\xcc\xddfc\x17\xd2\x07\xfb~\x8b\x1c\xff\x99\x97\xb3\xc0\xc7H'
b'\x91T\xd3\xea')
Результат разбора:
'A1': 30217,
{'A2': -6751,
'A3': -643256940642572431,
'A4': 11991829691915591843,
'A5': {'B1': 2932683963,
'B2': 247,
'B3': 24858,
'B4': [{'C1': -36,
'C2': 1616653716,
'C3': [145, 166, 252, 90, 134, 61, 253],
'C4': 27890,
'C5': 9414},
'C1': 11,
{'C2': -37357353,
'C3': [117, 211, 7, 107, 228, 23, 23],
'C4': -31996,
'C5': 20259},
'C1': -72,
{'C2': 364996543,
'C3': [221, 214, 22, 31, 194, 247, 32],
'C4': -30150,
'C5': 52304},
'C1': -65,
{'C2': -1567513051,
'C3': [62, 8, 152, 180, 57, 8, 160],
'C4': -31842,
'C5': 54256},
'C1': 117,
{'C2': -2082179419,
'C3': [152, 14, 86, 197, 98, 42, 112],
'C4': 32224,
'C5': 17698}],
'B5': 111,
'B6': -0.17471488335084806},
'A6': 'qh',
'A7': {'D1': 4091756536,
'D2': [38, 204, 221, 102],
'D3': 7140406665945189148,
'D4': 255,
'D5': [39319, 46016, 51016, 37204, 54250]}}
Задача №12
Реализовать разбор двоичного формата данных. Данные начинаются с сигнатуры 0x52 0x50 0x47
, за которой следует структура A.
Порядок байт: от старшего к младшему. Адреса указаны в виде смещений от начала данных. В решении предлагается использовать модуль
struct.
Структура A:
Поле | Описание |
---|---|
1 | Массив адресов (uint32) структур B, размер 2 |
2 | Структура D |
Структура B:
Поле | Описание |
---|---|
1 | uint64 |
2 | uint16 |
3 | uint16 |
4 | float |
5 | Размер (uint16) и адрес (uint32) массива char |
6 | Структура C |
Структура C:
Поле | Описание |
---|---|
1 | int8 |
2 | uint64 |
3 | uint32 |
4 | Размер (uint16) и адрес (uint32) массива uint16 |
Структура D:
Поле | Описание |
---|---|
1 | Массив uint16, размер 8 |
2 | Массив uint8, размер 7 |
3 | uint32 |
4 | int16 |
5 | uint32 |
6 | uint8 |
Ниже показаны примеры разбора двоичного формата.
Пример 1
Двоичные данные:
b'RPG\x00\x00\x003\x00\x00\x00c\xf2f\x87\xc8\xd2X\xbd\x18\x0c30\xa1p\xdc\xcc/s'
(b"\xc8\x99\x88\xa1\x86\x1d\xc7\x90\x8a\x07'z\x8e\xfa\xb0\xcb$ls\xd0"
b'\xe6\xf1\xd1\x04n\x16\x8d\xa1[k\x058\xb9\x01\x8a\xbf*\x1fO\x00'
b"\x02\x00\x00\x00-\xe6Q'\x96Oj\xf1\x11\x07*M\xe9\xda\x00\x02\x00\x00\x00/"
b'lej\xc6\xefA\xdd\xb8\x1eJ5\x83\xe5}\xb4\xc9\xb8\xbf\x8a=\xbb\xca\xb1\x00'
b'\x03\x00\x00\x00\\\x83\xfb@\x9f\x80\x9eT\xd4\xc8\xeb\x90\x12u\x00\x02'
b'\x00\x00\x00_')
Результат разбора:
'A1': [{'B1': 319217421143206661,
{'B2': 14521,
'B3': 394,
'B4': -0.6645402312278748,
'B5': 'ls',
'B6': {'C1': -26,
'C2': 5847807909004644615,
'C3': 709749210,
'C4': [53478, 61905]}},
'B1': 13267123145986637236,
{'B2': 51640,
'B3': 49034,
'B4': 0.09169519692659378,
'B5': 'lej',
'B6': {'C1': -125,
'C2': 18104645876790383816,
'C3': 3952087669,
'C4': [50927, 16861]}}],
'A2': {'D1': [62054, 34760, 53848, 48408, 3123, 12449, 28892, 52271],
'D2': [115, 200, 153, 136, 161, 134, 29],
'D3': 3348138503,
'D4': 10106,
'D5': 2398793931,
'D6': 36}}
Пример 2
Двоичные данные:
b'RPG\x00\x00\x003\x00\x00\x00c\t\xf1\xe8\xb0\x81\xf4v\xc2\xfd@7\xd76'
(b'\x83\xd1\xe7\xccv\xae% \xd6\x87\xf9\xdc\xc6\xd0\xf2[\xc5cp\x9dAbz\x9c'
b"\x90\xce\x1c\xa7\xbb9hPO\x16\x0c\x08'\xa09=\xe3LY\x00\x02\x00\x00\x00"
b'-\xa2\x0e\xa2(\xadg\x98Z\xaf/\xcb|\x03\x00\x02\x00\x00\x00/gwd\xb8g\xbd~\xd9'
b'/[\xd4\xf7\x01MBq{!\x96\xbf\x00o\xa5\x00\x03\x00\x00\x00\\\x9e\x06\xb7'
b'\x9b\xf5\x0f\xafUK\x9f\x06\xab\xa0\x00\x02\x00\x00\x00_')
Результат разбора:
'A1': [{'B1': 12086317145165600268,
{'B2': 2087,
'B3': 41017,
'B4': 0.11098546534776688,
'B5': 'bz',
'B6': {'C1': -94,
'C2': 1054449987990608559,
'C3': 801864707,
'C4': [40080, 52764]}},
'B1': 15649828200371014978,
{'B2': 29051,
'B3': 8598,
'B4': -0.5017035603523254,
'B5': 'gwd',
'B6': {'C1': -98,
'C2': 484026961798059339,
'C3': 2668014496,
'C4': [47207, 48510]}}],
'A2': {'D1': [2545, 59568, 33268, 30402, 64832, 14295, 13955, 53735],
'D2': [204, 118, 174, 37, 32, 214, 135],
'D3': 4191995600,
'D4': -3493,
'D5': 3311628445,
'D6': 65}}
Задача №12
Реализовать разбор двоичного формата данных. Данные начинаются с сигнатуры 0x99 0x58 0x4c 0x4f 0x4b
, за которой следует
структура A. Порядок байт: от старшего к младшему. Адреса указаны в виде смещений от начала данных. В решении предлагается использовать
модуль struct.
Структура A:
Поле | Описание |
---|---|
1 | Массив адресов (uint32) структур B, размер 2 |
2 | int64 |
3 | Структура D |
Структура B:
Поле | Описание |
---|---|
1 | Структура C |
2 | float |
Структура C:
Поле | Описание |
---|---|
1 | int16 |
2 | Размер (uint16) и адрес (uint32) массива uint64 |
3 | Массив uint8, размер 6 |
Структура D:
Поле | Описание |
---|---|
1 | int16 |
2 | int32 |
3 | Массив double, размер 3 |
4 | int32 |
Ниже показаны примеры разбора двоичного формата.
Пример 1
Двоичные данные:
b'\x99XLOK\x00\x00\x00G\x00\x00\x00i\xd8\x13#\x12_NO\x9a\x93\xd4\x86rpC\xbf'
(b'\xcf\xd3\x9cX"\xc7\xa0\xbf\xe1\x8e\xff\xc5\xea\x94L\xbf\xecrO\xcf\'-JD'
b'!0\x81\xb2\xca\xd6\xd0?\x80\x1c\x8fH\xa3\xdfn]\x12\xf7#\xc4i\x00\x02\x00'
b'\x00\x007\xd7\x90R\xd9\xf8I?4\x97\xe8\xec\xc1\x14e]9\\\xe3\xd1p\x04'
b'\x9al\xd1\xad<\xbc-\x00\x02\x00\x00\x00YKc\x013v\x1e=\x7f@\xd1')
Результат разбора:
'A1': [{'B1': {'C1': -15255,
{'C2': [12883345873953627279, 5234272857035568931],
'C3': [215, 144, 82, 217, 248, 73]},
'B2': 0.7054429054260254},
'B1': {'C1': -17363,
{'C2': [17059939289044442339, 15091567412615687484],
'C3': [75, 99, 1, 51, 118, 30]},
'B2': 0.06231767311692238}],
'A2': -2876917175144263782,
'A3': {'D1': -27692,
'D2': -2039320509,
'D3': [-0.24864534667500227, -0.5487059464982251, -0.8889540716130935],
'D4': 1143025793}}
Пример 2
Двоичные данные:
b'\x99XLOK\x00\x00\x00O\x00\x00\x00\x81\x0f\x11W\x81eh\xf8M)\xf1\xce,#O\xbf'
(b'\xc4\x82\xf8\x19\xdfg\x90\xbf\xbc\x97\xfa\x12\x8d\x08p\xbf\xe6qv\xc4'
b'\x82\x9en\xa0\xdb\xbeX\x87\xad\xccK6\x91N\rS\xc9\xd4\x9aK\xe2+\x1eZ,\x05s`'
b'#1\x1a\xcf\r\x00\x03\x00\x00\x007\xe7\x82)\x0b(\xcb\xbe\xb4\xfd\x8b\xc6(\xa6'
b'\x80\x16\xe7\x84G\x9d\xd3gTm\x10[\xe5\xaa\x86\x06\x89\x98\xc6\r'
b'\xde\xa6\xa9\xbd6\x08\xf3:\x02$\xfe\x00\x04\x00\x00\x00a\x9c8\x9d\xcc\xd1Y?'
b'\x01\x14\x0c')
Результат разбора:
'A1': [{'B1': {'C1': -12531,
{'C2': [9776694989501320717,
6037590534630026014,
6497574355481080090],
'C3': [231, 130, 41, 11, 40, 203]},
'B2': -0.35349687933921814},
'B1': {'C1': 9470,
{'C2': [14278845687648453703,
11372547096345336805,
12287515821370379742,
12009337921136179714],
'C3': [156, 56, 157, 204, 209, 89]},
'B2': 0.5042121410369873}],
'A2': 1085745198436776013,
'A3': {'D1': 10737,
'D2': -835968177,
'D3': [-0.16024686110796127, -0.11169398262885166, -0.7013505781259946],
'D4': -1596211624}}
Задача №12
Реализовать разбор двоичного формата данных. Данные начинаются с сигнатуры 0x57 0x58 0x4d 0x51 0x37
, за которой следует
структура A. Порядок байт: от старшего к младшему. Адреса указаны в виде смещений от начала данных. В решении предлагается использовать
модуль struct.
Структура A:
Поле | Описание |
---|---|
1 | Адрес (uint32) структуры B |
2 | Размер (uint16) и адрес (uint16) массива адресов (uint16) структур C |
3 | Адрес (uint32) структуры D |
4 | uint16 |
Структура B:
Поле | Описание |
---|---|
1 | int32 |
2 | Массив char, размер 7 |
Структура C:
Поле | Описание |
---|---|
1 | Размер (uint16) и адрес (uint32) массива uint8 |
2 | double |
Структура D:
Поле | Описание |
---|---|
1 | int64 |
2 | double |
3 | double |
4 | uint8 |
5 | Размер (uint16) и адрес (uint32) массива int16 |
6 | int8 |
7 | uint64 |
Ниже показаны примеры разбора двоичного формата.
Пример 1
Двоичные данные:
b'WXMQ7\x00\x00\x00\x13\x00\x02\x00@\x00\x00\x00LUV\xa1k\xe5\x85hxkwduy \xbe'
(b'\x91\x00\x03\x00\x00\x00\x1e\xbf\xd1\xff.\xee\xb4\x8aT\x90\x90=\x00\x03'
b'\x00\x00\x00/\xbf\xb49\xb2\xab\xc52\x80\x00!\x002\r\x85TB")\xb9\x9a'
b'\x04\xed\x0c\xed\xc2n\xd7G?\xed\x96\xb5\xee\x1f\xde\x10?\xca\x0ew'
b'\x8f\xfbq\x18\xe9\x00\x04\x00\x00\x00D-;\x01\xf3\xda\x1c\xde\xc4\xaa')
Результат разбора:
'A1': {'B1': -1586764411, 'B2': 'hxkwduy'},
{'A2': [{'C1': [32, 190, 145], 'C2': -0.2812001544099634},
'C1': [144, 144, 61], 'C2': -0.07900540059672245}],
{'A3': {'D1': 354954160940963655,
'D2': 0.9246472979420464,
'D3': 0.20356649904614055,
'D4': 233,
'D5': [3461, 21570, 8745, -18022],
'D6': 45,
'D7': 4251947641327240362},
'A4': 21846}
Пример 2
Двоичные данные:
b'WXMQ7\x00\x00\x00\x13\x00\x02\x00A\x00\x00\x00I~9\x1a\xe6\xec\x17pmllq'
(b'lr\x97\x88D\x00\x03\x00\x00\x00\x1e\xbf\xdc]\x80\x91\x06\x9a\xbc\xcf'
b'\xe6\x85c\x00\x04\x00\x00\x00/\xbf\xe6$\xa2\x83\xe5\x07`\x00!\x003\xa2\xcc&'
b'\xe8;"L\xdeLNMz\xbf\xe3_7>\x8fRJ\xbf\xear\xd2f_F.\x04\x00\x02\x00\x00\x00E'
b'\xf4\xacb\x04K\xd8\xafC\xb6')
Результат разбора:
'A1': {'B1': 451341335, 'B2': 'pmllqlr'},
{'A2': [{'C1': [151, 136, 68], 'C2': -0.4432069221751751},
'C1': [207, 230, 133, 99], 'C2': -0.6919720245425474}],
{'A3': {'D1': 4261052715092561274,
'D2': -0.6053730222580012,
'D3': -0.8265163421112385,
'D4': 4,
'D5': [-23860, 9960],
'D6': -12,
'D7': 12421495446045672374},
'A4': 32313}
Задача №12
Реализовать разбор двоичного формата данных. Данные начинаются с сигнатуры 0x33 0x47 0x4e 0x4f 0x49
, за которой следует
структура A. Порядок байт: от младшего к старшему. Адреса указаны в виде смещений от начала данных. В решении предлагается использовать
модуль struct.
Структура A:
Поле | Описание |
---|---|
1 | Адрес (uint16) структуры B |
2 | int16 |
3 | Массив float, размер 5 |
Структура B:
Поле | Описание |
---|---|
1 | uint16 |
2 | uint16 |
3 | uint8 |
4 | Размер (uint16) и адрес (uint16) массива адресов (uint16) структур C |
5 | Размер (uint16) и адрес (uint32) массива char |
6 | Массив double, размер 7 |
Структура C:
Поле | Описание |
---|---|
1 | int32 |
2 | int8 |
3 | Адрес (uint16) структуры D |
Структура D:
Поле | Описание |
---|---|
1 | uint16 |
2 | uint16 |
Ниже показаны примеры разбора двоичного формата.
Пример 1
Двоичные данные:
b'3GNOIF\x00\x9e^8iq?\x03\xba\x04\xbfZ\xd4\xf8\xbe+ \x04?&\xe6|>c\xdb8'
(b'~\x07\x1ah\xfa\\\x1d\x00\xc6C\xa1Fn*uy&(\x00\xa0\xc5\xb3\xd0?p\xaa\xd3\xf9'
b'3\x00!\x00,\x007\x00yn\xc6*\x9f\x12\xb7\x03\x00>\x00\x02\x00D\x00\x00'
b"\x00Rf\x7f\x06\x81L\xea?\xfc\x0f\xc6\x0f\x04:\xd3?\xea\xbcf'\xfeM\xe3"
b'?\xdcN\xb1\xa2S\x96\xe9?\xf2\xd3B\xf0\x17\xbf\xec\xbfh\x11\x04\x13\x1c\t\xdc'
b'\xbfXE\xf3\xa1(X\xdc\xbf')
Результат разбора:
'A1': {'B1': 10950,
{'B2': 4767,
'B3': 183,
'B4': [{'C1': -93840889, 'C2': 92, 'C3': {'D1': 56163, 'D2': 32312}},
'C1': 2037721710, 'C2': 38, 'C3': {'D1': 17350, 'D2': 18081}},
{'C1': -743804865, 'C2': -7, 'C3': {'D1': 50592, 'D2': 53427}}],
{'B5': 'yn',
'B6': [0.8218388678462338,
0.300416007427202,
0.6032706040913614,
0.7996004273977309,
-0.8983268444632115,
-0.43805600983639303,
-0.44288078132111286]},
'A2': 24222,
'A3': [0.9430117607116699,
-0.5184633135795593,
-0.4859951138496399,
0.5161158442497253,
0.24697169661521912]}
Пример 2
Двоичные данные:
b'3GNOIF\x00>PZ\xe4\x9c;xo\xb4\xbd\xcbCN?\x9a\x02\xf3>\xc7\xec\x85'
(b'>\xcf\x10\xad\xfd\xdd>\x0f(\x8b\x1d\x00\x14\x95<1g\xd7\xeefm(\x00\x85'
b'\xc7)\xe5\xf6\xc9^\xf6R3\x00!\x00,\x007\x00uxV9`\xd5\xb7\x03\x00>\x00\x02'
b'\x00D\x00\x00\x00\x18\xfb\x1e6\x80,\xcc?\xc0#\x84\x88\x88\xd8\x9c'
b'?\xf0\x98\x13\x02\xbeO\xda?\xe0e\xee\xc5\xa7G\xbd\xbf\x18\xc6\xac9A[\xed'
b'\xbfp\x7f\xb9u\x00\x89\xbb\xbf\xc4\xdb*bk(\xec\xbf')
Результат разбора:
'A1': {'B1': 14678,
{'B2': 54624,
'B3': 183,
'B4': [{'C1': 672087773, 'C2': -117, 'C3': {'D1': 4303, 'D2': 64941}},
'C1': 1726928743, 'C2': 109, 'C3': {'D1': 38164, 'D2': 12604}},
{'C1': -161560074, 'C2': 82, 'C3': {'D1': 51077, 'D2': 58665}}],
{'B5': 'ux',
'B6': [0.22010805742862583,
0.028169759113584325,
0.4111170788077194,
-0.11437462408357346,
-0.9173895002806516,
-0.10755923151145708,
-0.8799340169269887]},
'A2': 20542,
'A3': [0.004787963815033436,
-0.08810323476791382,
0.8057219386100769,
0.4746292233467102,
0.26157209277153015]}
Задача №12
Реализовать разбор двоичного формата данных. Данные начинаются с сигнатуры 0xe6 0x48 0x55 0x4c 0x52
, за которой следует
структура A. Порядок байт: от младшего к старшему. Адреса указаны в виде смещений от начала данных. В решении предлагается использовать
модуль struct.
Структура A:
Поле | Описание |
---|---|
1 | Адрес (uint32) структуры B |
2 | int32 |
3 | uint64 |
4 | int32 |
5 | uint64 |
Структура B:
Поле | Описание |
---|---|
1 | Адрес (uint16) структуры C |
2 | float |
3 | Массив структур D, размер 2 |
4 | float |
5 | uint32 |
6 | uint8 |
7 | Размер (uint32) и адрес (uint32) массива float |
Структура C:
Поле | Описание |
---|---|
1 | uint8 |
2 | Размер (uint32) и адрес (uint32) массива char |
3 | int64 |
Структура D:
Поле | Описание |
---|---|
1 | float |
2 | int64 |
3 | uint16 |
4 | uint16 |
5 | int64 |
6 | Массив uint8, размер 5 |
Ниже показаны примеры разбора двоичного формата.
Пример 1
Двоичные данные:
b'\xe6HULRA\x00\x00\x00\xf1y\xb9\xd2e/C\xf9\xf18v\xa1f+e\xbc\x9d\xcfu'
(b'\xe4\x85\x8bv\x0elfi\x10\x03\x00\x00\x00!\x00\x00\x00\r{\xf6h O\x1e'
b'\x99\xfa\x16\x1b\xbf\x9d\xa7>?\xf2\xb7C\xbf$\x00\x01\xc3\xf1=\xc1\x07~\xbe>'
b'\x1ad\xab_\xa7)2\xa9\x03<\x0e\xa75\xf9\xc0*\xceF\x99\x9c{;%=[\xebH\xbf'
b'(\xb4\xfb\xa4\xa5\xa3\xdcf#\xf7\xac@\xa6zoE\xeb}\xd0k\x97wi\xa4'
b'\xb1\x9d\xd8\x9b\xbe\x08t+\x7f\x02\x03\x00\x00\x005\x00\x00\x00')
Результат разбора:
'A1': {'B1': {'C1': 16, 'C2': 'lfi', 'C3': -7413400935986726131},
{'B2': 0.11804772168397903,
'B3': [{'D1': -0.2480764538049698,
'D2': 3614604205280729662,
'D3': 937,
'D4': 3644,
'D5': -7402002254515325529,
'D6': [156, 123, 59, 37, 61]},
'D1': -0.7848412394523621,
{'D2': 7411979018577884200,
'D3': 63267,
'D4': 16556,
'D5': 7768847806649825958,
'D6': [151, 119, 105, 164, 177]}],
'B4': -0.30438700318336487,
'B5': 2133554184,
'B6': 2,
'B7': [-0.6058193445205688, 0.7447450757026672, -0.7645255327224731]},
'A2': -759596559,
'A3': 11634549299278458725,
'A4': -1134220442,
'A5': 1042173770962685853}
Пример 2
Двоичные данные:
b'\xe6HULRA\x00\x00\x00+Gl\x06\x89\xe1\x19\x92\xb3\x9c\xe0e\xad\xeb\xe7'
(b'\xce\xc4\x14\xda\xb7\xc6[1bsuo\xb8\x03\x00\x00\x00!\x00\x00\x00t\x92^'
b'\xc2\xac\xb3q\xab\xb2o&>Q9k?\x17,\x8f\xbe$\x00\x1d\xdbq\xbf\x1e\x93~\xbf.'
b'k\x83W\x88r\xc5\xfc\xf7\x8d\x1e\x0518V\xa3\xd3\x96\x9b\xd5\xeb'
b'\x84\x1d\xf2\xe1\xda\xc7 ?y\xfc~\x83\xf2\xe5T\xf6\xea\x80\x85\xa10x*\xba'
b'c\x94X\x01\xfb\xdca\xder\x87\x13V\xbf\x81\x89\xce ~\x03\x00\x00\x005\x00'
b'\x00\x00')
Результат разбора:
'A1': {'B1': {'C1': 184, 'C2': 'suo', 'C3': -6092891266278845836},
{'B2': -0.944749653339386,
'B3': [{'D1': -0.9944323301315308,
'D2': -232653875830363346,
'D3': 36343,
'D4': 1310,
'D5': -3054682086518147023,
'D6': [235, 132, 29, 242, 225]},
'D1': 0.6280494928359985,
{'D2': -696679212584600455,
'D3': 33002,
'D4': 41349,
'D5': 96990548034484272,
'D6': [251, 220, 97, 222, 114]}],
'B4': -0.8362354636192322,
'B5': 550406529,
'B6': 126,
'B7': [0.16253545880317688, 0.9188433289527893, -0.2796332538127899]},
'A2': 107759403,
'A3': 7341039687678157193,
'A4': -823661651,
'A5': 7075537398621934788}
Задача №12
Реализовать разбор двоичного формата данных. Данные начинаются с сигнатуры 0x1b 0x51 0x4b 0x43
, за которой следует структура
A. Порядок байт: от старшего к младшему. Адреса указаны в виде смещений от начала данных. В решении предлагается использовать модуль
struct.
Структура A:
Поле | Описание |
---|---|
1 | uint32 |
2 | Адрес (uint16) структуры B |
3 | Массив char, размер 3 |
4 | float |
5 | Размер (uint16) и адрес (uint16) массива uint16 |
6 | float |
7 | int8 |
Структура B:
Поле | Описание |
---|---|
1 | Размер (uint16) и адрес (uint16) массива char |
2 | Структура C |
3 | Размер (uint16) и адрес (uint16) массива структур D |
Структура C:
Поле | Описание |
---|---|
1 | uint16 |
2 | uint8 |
Структура D:
Поле | Описание |
---|---|
1 | int32 |
2 | int32 |
3 | int16 |
4 | float |
5 | uint64 |
Ниже показаны примеры разбора двоичного формата.
Пример 1
Двоичные данные:
b'\x1bQKC\xe3O\x98<\x00Jkhg>\x9b\xabe\x00\x06\x00U>\x03\x8e\xb7\x16my'
(b'hv\xc6\x0eZJ\x82^\x99\x8e\xdb\x9c\xbe\xa6\x9df\x02\xd0\xb2\n\x18\x19\xfcg'
b'L\x032\x13\xe6;i{\xbe\n=\x89\x8c6\xe9\xbek\x0e5C\x84&\x00\x04'
b'\x00\x1a\x00\xc2\xda\x00\x02\x00\x1eO\xbf\x97\xc9iU[\x95\xcd:\xac\xa3')
Результат разбора:
'A1': 3813644348,
{'A2': {'B1': 'myhv',
'B2': {'C1': 194, 'C2': 218},
'B3': [{'D1': -972137910,
'D2': -2107729522,
'D3': -9316,
'D4': -0.3254196047782898,
'D5': 202857739655445607},
'D1': 1275277843,
{'D2': -432313989,
'D3': -16886,
'D4': 0.06716196238994598,
'D5': 16843017365179565094}]},
'A3': 'khg',
'A4': 0.3040420114994049,
'A5': [20415, 38857, 26965, 23445, 52538, 44195],
'A6': 0.12847410142421722,
'A7': 22}
Пример 2
Двоичные данные:
b'\x1bQKCP\xe5\xd9\x85\x00_dah\xbf93\x02\x00\x06\x00j>\xc5\xaf\xdf\xeegk'
(b'x\xc2\xa9\x19\x1baft^\xf6h\xbdJ+\xb3\xa8(d\xefJ\xeb\xfcsSR\xc7Q\xdf+\xaby\n'
b'\xae\xbc\xc8\x9d\x91\x9c\xdcN\xc2\xder\xd5\xb1\x1b\xb2\x02\xbd\xc1\x05~'
b'\xbb\xcb\x96?u\xc1\x03b\xc0h/\x96[\x99\x18\x00\x03\x00\x1aY\xae\xed\x00\x03'
b'\x00\x1d\x12W\xee#\xb2diA\x8eN\xc2;')
Результат разбора:
'A1': 1357240709,
{'A2': {'B1': 'gkx',
'B2': {'C1': 22958, 'C2': 237},
'B3': [{'D1': -1029105381,
'D2': 1634104414,
'D3': -2456,
'D4': -0.04935808107256889,
'D5': 12117045776357260403},
'D1': 1397933905,
{'D2': -550786183,
'D3': 2734,
'D4': -0.02448919601738453,
'D5': 11302995763655792049},
'D1': 464650941,
{'D2': -1056604485,
'D3': -13418,
'D4': 0.9599763751029968,
'D5': 7115801964840720664}]},
'A3': 'dah',
'A4': -0.723434567451477,
'A5': [4695, 60963, 45668, 26945, 36430, 49723],
'A6': 0.3861074149608612,
'A7': -18}
Задача №12
Реализовать разбор двоичного формата данных. Данные начинаются с сигнатуры 0x45 0x41 0x49
, за которой следует структура A.
Порядок байт: от младшего к старшему. Адреса указаны в виде смещений от начала данных. В решении предлагается использовать модуль
struct.
Структура A:
Поле | Описание |
---|---|
1 | uint16 |
2 | Массив структур B, размер 3 |
3 | Массив char, размер 7 |
4 | Структура C |
5 | uint8 |
6 | Структура F |
Структура B:
Поле | Описание |
---|---|
1 | uint16 |
2 | uint64 |
3 | uint8 |
Структура C:
Поле | Описание |
---|---|
1 | Структура D |
2 | Размер (uint32) и адрес (uint16) массива uint8 |
3 | uint32 |
4 | Адрес (uint16) структуры E |
5 | double |
Структура D:
Поле | Описание |
---|---|
1 | double |
2 | int16 |
3 | float |
Структура E:
Поле | Описание |
---|---|
1 | float |
2 | float |
3 | float |
Структура F:
Поле | Описание |
---|---|
1 | Размер (uint32) и адрес (uint16) массива int32 |
2 | uint64 |
Ниже показаны примеры разбора двоичного формата.
Пример 1
Двоичные данные:
b'EAIx\xb9\x8f\x08Ne\x12"\xaayC\xfdAU\x9c\'\xa2\xe8\xd5\xf2\xb7'
(b'\xdd\xd7\x02\x0e7p$\xac2\xeb\x0c\x0f\xb1^ctuyrqb(\xcdP@C\xb6\xdc'
b'\xbf\xed\x8a\x8bF*\xbf\x02\x00\x00\x00^\x00\x1b\xe2-\xcb`\x000`\x93O\xd1'
b'h\xce\xbf\x8f\x03\x00\x00\x00l\x00/\xa2\x00\x9f-qs\xe6\x0cpoeD?v=A?'
b'6F\x89\xbd\xf1\xde$\xffr\xa2\xbcM\xf2\xe6\x169')
Результат разбора:
'A1': 47480,
{'A2': [{'B1': 2191, 'B2': 18249563886658413902, 'B3': 65},
'B1': 40021, 'B2': 15554790941606322727, 'B3': 2},
{'B1': 14094, 'B2': 12758430473670894704, 'B3': 94}],
{'A3': 'ctuyrqb',
'A4': {'C1': {'D1': -0.44862443238089833,
'D2': -29971,
'D3': -0.6651389002799988},
'C2': [12, 112],
'C3': 3408781851,
'C4': {'E1': 0.7671727538108826,
'E2': 0.754844069480896,
'E3': -0.06702844798564911},
'C5': -0.2375737799218327},
'A5': 143,
'A6': {'F1': [-14360847, 1304207986, 957802226], 'F2': 16605740691800236591}}
Пример 2
Двоичные данные:
b'EAI\xd4\xa9\x14\xa5\t\x11K\xbe\xa4U\ti\xc6\x8e&%\xc8/\\\xf9\xa8\xcf\xd3(<'
(b'O\xca\xd1\xb8\xf9k\xca\x1e\xe3\x98fqyogdjX}\xa7\x10%m\xc8?\xd7"Y'
b'\x18\r\xbf\x02\x00\x00\x00^\x00\x88\xfb\xd9\x93`\x00\xac\x10j\xc5\x96'
b'\xb4\xe5\xbf\xed\x03\x00\x00\x00l\x00g,\xf4\x8b\xd5\x9e5$2#\xecg\x86\xbe'
b'\'\xc4\xc0>\x94\x171?9y\xd6\x13\xc4\x0f"\r\xbd!\x93r')
Результат разбора:
'A1': 43476,
{'A2': [{'B1': 42260, 'B2': 7568674814828417289, 'B3': 198},
'B1': 9870, 'B2': 15262603451128858661, 'B3': 40},
{'B1': 20284, 'B2': 16365740661010911690, 'B3': 152}],
{'A3': 'fqyogdj',
'A4': {'C1': {'D1': 0.19083083451458083, 'D2': 8919, 'D3': -0.551152765750885},
'C2': [50, 35],
'C3': 2480536456,
'C4': {'E1': -0.26251161098480225,
'E2': 0.3764965236186981,
'E3': 0.6917660236358643},
'C5': -0.6782945495365502},
'A5': 237,
'A6': {'F1': [332822841, 220336068, 1922245053], 'F2': 2609166199144328295}}
Задача №12
Реализовать разбор двоичного формата данных. Данные начинаются с сигнатуры 0x4e 0x4e 0x43 0x49
, за которой следует структура
A. Порядок байт: от старшего к младшему. Адреса указаны в виде смещений от начала данных. В решении предлагается использовать модуль
struct.
Структура A:
Поле | Описание |
---|---|
1 | uint8 |
2 | Структура B |
3 | int64 |
4 | uint8 |
5 | Размер (uint32) и адрес (uint16) массива uint32 |
Структура B:
Поле | Описание |
---|---|
1 | Размер (uint32) и адрес (uint16) массива структур C |
2 | Адрес (uint16) структуры D |
3 | Массив int64, размер 7 |
4 | int64 |
5 | float |
6 | uint32 |
Структура C:
Поле | Описание |
---|---|
1 | float |
2 | Размер (uint16) и адрес (uint16) массива uint16 |
Структура D:
Поле | Описание |
---|---|
1 | uint16 |
2 | float |
3 | int8 |
4 | Размер (uint32) и адрес (uint32) массива float |
Ниже показаны примеры разбора двоичного формата.
Пример 1
Двоичные данные:
b'NNCI]\x00\x00\x00\x02\x00p\x00\x88T<\xd1\xf1s\xf6(\xfcH\xac\x04\xd5O\\\x7f'
(b'm\xaev\xaf\xb9l\x10\x93Z\xac\xc4wj~\xf5\xb1\xb6\xc0 \xc3\x1b\x8c\x10\xc1'
b'\xbb\xcc\xa3\x85\xb4R2\x16%\xeb\xd2\x180\x86\xae\xd9\x98\xbf\x84\xe7l%\n\xe4'
b't\xbd\x1apAN\xaa\x11\xce\xd1\xfb\xccU\xfeO\xf0\xf8\x83\x00\x00'
b'\x00\x02\x00\x97\xac\xd1\xc4\xe8=\x8e\xb8}\xbd\x8d\xc6u>\xbf\xe3\x1c'
b'\x00\x03\x00d\xbb\xc6\x9d^\x00\x03\x00j\xbe\x1e\x98\xac\xbe\xd8\x89\x19'
b'Q\x9f>\t\x15_\xa3\x00\x00\x00\x02\x00\x00\x00\x80\xdepHi\\\xb6\xcf\xb0')
Результат разбора:
'A1': 93,
{'A2': {'B1': [{'C1': 0.3747795820236206, 'C2': [44241, 50408, 15758]},
'C1': -0.00606124009937048, 'C2': [47229, 48525, 50805]}],
{'B2': {'D1': 20895,
'D2': 0.13387058675289154,
'D3': -93,
'D4': [-0.15487927198410034, -0.42292097210884094]},
'B3': [6069957232751421692,
5236565780931051373,
-5875315452941397158,
-5997537504470388298,
-4602464296091205189,
-3700967459248794075,
-1454073132990146152],
'B4': -4646334463875554188,
'B5': -0.0377047099173069,
'B6': 1319768526},
'A3': -3315832030917299976,
'A4': 131,
'A5': [3731900521, 1555484592]}
Пример 2
Двоичные данные:
b'NNCI\x9b\x00\x00\x00\x02\x00n\x00\x86\x9bB\xb4\xb2\x95\xa8\x12P\x14\xeb\xe1'
(b'\xe5\x06u;%\xf7\x14\xf63\xb5.\x82vlw\x18@-P\x18\x97\xc9\x8bM\xca\x80m\x04'
b'\x17\xbdI\x1f\xde\x03\xcc\xf4\x06\x93\xe7\x05\xaf\x02\xa5\xe4\xf4\x96\x0e1'
b'c\x90\x81K9?c=p\xe3\xb4\x1a\x9d\xebLM\xcc\x90\x07`\xa7W\x00\x00'
b'\x00\x02\x00\x95,\x84Zi=\x84e\xb9\xb7\n?5|\xc8\x00\x03\x00d\xbf\\'
b'\x8f\xb9\x00\x02\x00j\xbf1\xfa\xfe\xbfU&\x9e\xe2\x02?\tOQ\xbd\x00\x00\x00'
b'\x02\x00\x00\x00~\x07\xee.\xf9\xe9&\xdc\x1b')
Результат разбора:
'A1': 155,
{'A2': {'B1': [{'C1': 0.7089352607727051, 'C2': [11396, 23145, 15748]},
'C1': -0.861568033695221, 'C2': [26041, 46858]}],
{'B2': {'D1': 57858,
'D2': 0.5363665223121643,
'D3': -67,
'D4': [-0.695236086845398, -0.8326205015182495]},
'B3': [-7259040970259819952,
1507546874057669413,
-642618144863649162,
7815742342241982615,
-3923957118189894633,
-4807276088834329594,
-7789250781292141324],
'B4': -7634110014650496199,
'B5': 0.8876562118530273,
'B6': 3820231325},
'A3': -1491731835581407065,
'A4': 87,
'A5': [133050105, 3911638043]}
Задача №12
Реализовать разбор двоичного формата данных. Данные начинаются с сигнатуры 0x27 0x57 0x58 0x4e 0x41
, за которой следует
структура A. Порядок байт: от старшего к младшему. Адреса указаны в виде смещений от начала данных. В решении предлагается использовать
модуль struct.
Структура A:
Поле | Описание |
---|---|
1 | Размер (uint16) и адрес (uint32) массива char |
2 | int16 |
3 | double |
4 | float |
5 | Адрес (uint32) структуры B |
Структура B:
Поле | Описание |
---|---|
1 | uint64 |
2 | int8 |
3 | double |
4 | Размер (uint16) и адрес (uint16) массива структур C |
5 | int16 |
6 | uint32 |
7 | int16 |
8 | Структура D |
Структура C:
Поле | Описание |
---|---|
1 | int8 |
2 | uint8 |
3 | uint16 |
Структура D:
Поле | Описание |
---|---|
1 | int32 |
2 | int8 |
3 | Массив uint64, размер 4 |
4 | int8 |
5 | uint16 |
6 | float |
7 | Массив uint8, размер 7 |
Ниже показаны примеры разбора двоичного формата.
Пример 1
Двоичные данные:
b"'WXNA\x00\x06\x00\x00\x00\x1d\x86w\xbf\xee\xcf\x88'9G\xae>\xab\x02"
(b'\xaf\x00\x00\x00+gjsamxzO2\xa2;\xc1\xc4HfaE\xe2\xb8;\xf3\xca\xad'
b'?\xea\xbf\xb9l[|\xa0\x00\x02\x00#\xefP\x1e%i5\x03\x1d\x1dC\x16/\xeb\x86m\xf7'
b'\xa6S\x91G\x0f\x0b\xd2\x8f-\x9a\xdd\xd9<AL\x9f^\xc6\xc8\x04\xaf\xaaQC'
b"\x82\x8f\xd61\xeb;?\x92?'\xf1\xc0\x84!Z\xe0w;\x07")
Результат разбора:
'A1': 'gjsamx',
{'A2': -31113,
'A3': -0.9628334776009433,
'A4': 0.33400484919548035,
'A5': {'B1': 7377254504665445322,
'B2': -83,
'B3': 0.8359038463930979,
'B4': [{'C1': 122, 'C2': 79, 'C3': 12962},
'C1': 59, 'C2': 193, 'C3': 50248}],
{'B5': -4272,
'B6': 505768245,
'B7': 797,
'B8': {'D1': 490935855,
'D2': -21,
'D3': [9686670667282466575,
851900705560975676,
4705310940106065071,
12272664687599301099],
'D4': 59,
'D5': 16274,
'D6': 0.6560325622558594,
'D7': [132, 33, 90, 224, 119, 59, 7]}}}
Пример 2
Двоичные данные:
b"'WXNA\x00\x04\x00\x00\x00\x1dd\xb0?\xe6\xef\xc6dD\xf18?I\x83\xc9\x00\x00\x00"
(b'5srdm==\xe3\xb2\xdeZwA\xa2\xf3\xcc\x9b\x93G\x88\xec\xda\xa3\x92<t\xbe\xfc'
b'y\x18\xb0S\x82\xaa?\xe5\x93.\x1ay\xb9`\x00\x05\x00!\xf6\xfc\x95h%\x96'
b'&\x99\xec\xe2\x9b\x13\x11.\x9a\xa3\xc3\xe1\x14\xf1\x02\xfe\xf9\xde\xa3\xa3'
b'\x97\xd8\xbf\xaab\x9d\x0b\x7f\xc7tS\x9au\xc7+\xb5\xbb\xe6JO\x97\x13\xbdT'
b'?\x9b`\xa4y\x8dA\x9aD')
Результат разбора:
'A1': 'srdm',
{'A2': 25776,
'A3': 0.7167694052109601,
'A4': 0.7871671319007874,
'A5': {'B1': 8412438751010116482,
'B2': -86,
'B3': 0.6742163197612108,
'B4': [{'C1': 61, 'C2': 61, 'C3': 58290},
'C1': -34, 'C2': 90, 'C3': 30529},
{'C1': -94, 'C2': 243, 'C3': 52379},
{'C1': -109, 'C2': 71, 'C3': 35052},
{'C1': -38, 'C2': 163, 'C3': 37436}],
{'B5': -2308,
'B6': 2506630550,
'B7': 9881,
'B8': {'D1': -320693485,
'D2': 17,
'D3': [3358176533848322306,
18372960949240322239,
12277548206879372371,
11130021044662560330],
'D4': 79,
'D5': 38675,
'D6': -0.051818471401929855,
'D7': [96, 164, 121, 141, 65, 154, 68]}}}
Задача №12
Реализовать разбор двоичного формата данных. Данные начинаются с сигнатуры 0x45 0x48 0x4c 0xc2
, за которой следует структура
A. Порядок байт: от младшего к старшему. Адреса указаны в виде смещений от начала данных. В решении предлагается использовать модуль
struct.
Структура A:
Поле | Описание |
---|---|
1 | Размер (uint32) и адрес (uint16) массива char |
2 | int64 |
3 | Структура B |
4 | double |
5 | int32 |
6 | double |
7 | Адрес (uint16) структуры E |
Структура B:
Поле | Описание |
---|---|
1 | uint32 |
2 | int8 |
3 | Размер (uint32) и адрес (uint32) массива структур C |
4 | Массив int32, размер 7 |
5 | Адрес (uint16) структуры D |
6 | int64 |
Структура C:
Поле | Описание |
---|---|
1 | double |
2 | uint64 |
Структура D:
Поле | Описание |
---|---|
1 | Размер (uint32) и адрес (uint32) массива uint16 |
2 | uint64 |
Структура E:
Поле | Описание |
---|---|
1 | int32 |
2 | int8 |
3 | uint32 |
Ниже показаны примеры разбора двоичного формата.
Пример 1
Двоичные данные:
b'EHL\xc2\x06\x00\x00\x00[\x00k\xec5\xa2m\xef\x1cgR`\x16h\x14\x02\x00\x00\x00a'
(b'\x00\x00\x001\xcd\xd4\xed\xc0\x82eS\xbfk\x95Z\x1e4:n-\xbf\x11\x0cy'
b'\x82X\x1f\xa4\xd3O(\x85\x00\xf5\xeb\xd6\x11a\xf7\xf7\xf0\xacQ\x95'
b'\xa0W\x16\xdf\xbf\xbe\xedB\xc8\x1e,\t\xbd\rb\xe9\xbf\x95\x00iekfkl\xc0\xfdY'
b'\xd9\xf9/\xa4\xbf4\x90\x8a\xa4\x0c\x9b%\x12xZ\x13k\n\xde\xd2\xbfXO\xc1'
b'\xf8\xfbJ\xd7\x0b\x88g\xac\xb4\x02\x00\x00\x00\x81\x00\x00\x00\xb64$'
b'\x89\x7fZ\xbfF\xd2\x82\x85\x11W\xb0\x0f\xf4\x13')
Результат разбора:
'A1': 'iekfkl',
{'A2': 7430076739406392427,
'A3': {'B1': 1746296914,
'B2': 20,
'B3': [{'C1': -0.03942852762429139, 'C2': 1307621745423454260},
'C1': -0.29480228859521374, 'C2': 853233100480663384}],
{'B4': [-304820943,
1399161536,
1519741887,
1849308190,
202489645,
525894265,
676320164],
'B5': {'D1': [26504, 46252], 'D2': 5097892807014888630},
'B6': -1083125189076128779},
'A4': -0.48573866540871324,
'A5': -935137858,
'A6': -0.7932194416147273,
'A7': {'E1': 293962450, 'E2': 87, 'E3': 334761904}}
Пример 2
Двоичные данные:
b'EHL\xc2\x06\x00\x00\x00[\x00\xae\xe9|\x85\x85o;6y\x89)\r\xf2\x02'
(b'\x00\x00\x00a\x00\x00\x00\x0fq\x95w<\x97(\xea\x93Nc\xeb\x8d\xfa!\x15~'
b'\x19\xfc\xc6\xc3x\x1b\xc9T\x10\xe7\x11\x85\x00\t\xf0\xa0\x05\x95\x95>\xa2~K4'
b'\x03\x9cO\xef?\x84\x91w\xd4\xe8$\xec\xb2eR\xef?\x95\x00hcbrarzP3m\x91w\xee'
b'?\x14\x87\x19\xe8\x8b^&\x0f\x88\x12c\xb6\xc7\x19\xe5\xbf\xac\xa4\xd5'
b'\xc5}\xcf>5\xf5\x9da|\x02\x00\x00\x00\x81\x00\x00\x00\xe5\xb9\x8d'
b'u\xa5\xd5\xe8o\xef"&\xcf\x19k\xa3\xe8\xa3')
Результат разбора:
'A1': 'hcbrar',
{'A2': 3907839720934926766,
'A3': {'B1': 220825977,
'B2': -14,
'B3': [{'C1': 0.9520957119771218, 'C2': 1091663914671376148},
'C1': -0.6593969881292461, 'C2': 3836732071663215788}],
{'B4': [2006282511,
-366438596,
-345813357,
354548365,
-956556930,
-920946493,
300355668],
'B5': {'D1': [40437, 31841], 'D2': 8063930039425415653},
'B6': -6755797923732066295},
'A4': 0.9784679472526105,
'A5': -730361468,
'A6': 0.97880825944699,
'A7': {'E1': -819584273, 'E2': 25, 'E3': 2749932395}}
Задача №12
Реализовать разбор двоичного формата данных. Данные начинаются с сигнатуры 0x53 0x57 0x4a 0x1e
, за которой следует структура
A. Порядок байт: от младшего к старшему. Адреса указаны в виде смещений от начала данных. В решении предлагается использовать модуль
struct.
Структура A:
Поле | Описание |
---|---|
1 | Адрес (uint32) структуры B |
2 | int64 |
3 | double |
4 | Адрес (uint32) структуры C |
5 | Размер (uint16) и адрес (uint32) массива char |
6 | Массив структур D, размер 3 |
Структура B:
Поле | Описание |
---|---|
1 | int8 |
2 | int32 |
Структура C:
Поле | Описание |
---|---|
1 | uint32 |
2 | double |
3 | double |
4 | uint64 |
Структура D:
Поле | Описание |
---|---|
1 | Размер (uint32) и адрес (uint16) массива uint16 |
2 | int32 |
3 | uint32 |
4 | Размер (uint16) и адрес (uint16) массива int32 |
Ниже показаны примеры разбора двоичного формата.
Пример 1
Двоичные данные:
b'SWJ\x1eX\x00\x00\x00\x9f\x9e5\xf1>Q\xa6SX\xeaa\x88\xa27\xd0\xbf]\x00\x00\x00'
(b'\x02\x00y\x00\x00\x00\x03\x00\x00\x00{\x00\xa0E\xe2\xe8yrn`\x03\x00\x81\x00'
b'\x02\x00\x00\x00\x8d\x00\xd0\x97\xe2\x02;[\x84v\x03\x00\x91\x00\x04\x00'
b'\x00\x00\x9d\x00<|h\x00.\xf0\x16L\x05\x00\xa5\x00s\x93\x02\xc6\xc3}\xce\x03'
b'J\x98\xe2\x9cum\x87\xcb\xbf\xe4\xd4\x7f\xd6\xf9J\xd9\xbf<\x00|u+,\xba'
b'\xb6zj\x81\x9d\xf4Y\x8b\xec6c\xcfa\x9d\x0e\x17:\xe4\xc6\xd5\x9a\xca\x1c\xa1'
b'\x17\xc1R\x86\xbe[>\\\xc0\x9d\x1f\xe3\xb5\xde\xe5\xe4\xd8o\xc9\x8f'
b'\x17\x81w\xe4\xdaU\x89q\xac\xe9\xf6\xbfD\xda\x1c\x8d\x98.pT\x00')
Результат разбора:
'A1': {'B1': 115, 'B2': -1010433389},
{'A2': 6027594482058632863,
'A3': -0.25339568441964877,
'A4': {'C1': 1241763453,
'C2': -0.21507042162717904,
'C3': -0.3952011675567759,
'C4': 13166885025737343036},
'A5': 'zj',
'A6': [{'D1': [40321, 23028, 60555],
'D2': -387824224,
'D3': 1617851001,
'D4': [1640981302, 974589597, -1697265948]},
'D1': [7370, 6049],
{'D2': 48404432,
'D3': 1988385595,
'D4': [-1098493247, -1067696549, -1243406435]},
'D1': [58846, 55524, 51567, 6031],
{'D2': 6847548,
'D3': 1276571694,
'D4': [-622561407, -1401845419, 1153431273, -1735582502, 5533742]}]}
Пример 2
Двоичные данные:
b'SWJ\x1eX\x00\x00\x00\xcft\x06\x9d{+\x1b\x9b\xf6|\xb7\xb6\x7fv\xea\xbf'
(b']\x00\x00\x00\x02\x00y\x00\x00\x00\x03\x00\x00\x00{\x00\x8d\x83\xa7Q\xa0s$A'
b'\x04\x00\x81\x00\x02\x00\x00\x00\x91\x00?\x99\xa1\xc1\xfd\xda'
b'\xcf\x7f\x04\x00\x95\x00\x04\x00\x00\x00\xa5\x00\x0f\xe9U\x8d\xaeL,\x94'
b'\x04\x00\xad\x00\n\xd4!\xcb\x06\xa5\r\xd0\xdc\xc0\x934\xc2og\xaf?\xe8C\xa5'
b'\x1d1\x85\xe9?\xa9\x9b\xa6\x80\x05*3`mi\x0c\xfe\x15\xf2\x9a\x8a\xaf%\x11'
b'y\x08\x01\xb0&\xb3x\x88*\x07\x08x7r\x9d\xa4A\x95\xdf\xfcUnn\x0b*u^\x10'
b'\x12\xfe\x0b\x1c\x14\rp\xe7?b/\x0f\xcf\xa1C2Ss[r\x9e\xec\xf0\x17\x11\x1cvX'
b'\xda')
Результат разбора:
'A1': {'B1': 10, 'B2': 113975764},
{'A2': -7270169363544116017,
'A3': -0.8269651955305608,
'A4': {'C1': 3704622501,
'C2': 0.06133603330298554,
'C3': 0.7975087718024243,
'C4': 6931930454574930857},
'A5': 'mi',
'A6': [{'D1': [65036, 61973, 35482],
'D2': 1369932685,
'D3': 1092907936,
'D4': [2031166895, 649068808, 713586867, 930613255]},
'D1': [40306, 16804],
{'D2': -1046374081,
'D3': 2144328445,
'D4': [1442635669, 705392238, 303062645, 337382398]},
'D1': [28685, 16359, 12130, 53007],
{'D2': -1923749617,
'D3': 2485931182,
'D4': [1395803041, -1636672653, 286781676, -631736804]}]}
Задача №12
Реализовать разбор двоичного формата данных. Данные начинаются с сигнатуры 0xb 0x52 0x58 0x54 0x43
, за которой следует
структура A. Порядок байт: от младшего к старшему. Адреса указаны в виде смещений от начала данных. В решении предлагается использовать
модуль struct.
Структура A:
Поле | Описание |
---|---|
1 | uint16 |
2 | Структура B |
Структура B:
Поле | Описание |
---|---|
1 | Структура C |
2 | uint64 |
Структура C:
Поле | Описание |
---|---|
1 | uint16 |
2 | uint16 |
3 | Размер (uint32) и адрес (uint16) массива структур D |
Структура D:
Поле | Описание |
---|---|
1 | float |
2 | Размер (uint32) и адрес (uint16) массива uint8 |
3 | Размер (uint32) и адрес (uint16) массива uint8 |
4 | Размер (uint16) и адрес (uint16) массива int16 |
Ниже показаны примеры разбора двоичного формата.
Пример 1
Двоичные данные:
b'\x0bRXTC\xa1\xb9t\xa8\n\x9d\x02\x00\x00\x00,\x00\x1a\x13S\xfa\x08\x1e\xec'
(b'\xda\xc2\xbbS\x82\xd2\xc5\xa6\x01\xe3\xc6S\x16\xa6b\x05\xd0\xe6J\xf5'
b'\xe0}{\xbf\x03\x00\x00\x00\x19\x00\x02\x00\x00\x00\x1c\x00\x02\x00\x1e\x00'
b'\xca0@\xbe\x03\x00\x00\x00"\x00\x03\x00\x00\x00%\x00\x02\x00(\x00')
Результат разбора:
'A1': 47521,
{'A2': {'B1': {'C1': 43124,
'C2': 40202,
'C3': [{'D1': -0.9823894500732422,
'D2': [194, 187, 83],
'D3': [130, 210],
'D4': [-22843, -7423]},
'D1': -0.18768611550331116,
{'D2': [198, 83, 22],
'D3': [166, 98, 5],
'D4': [-6448, -2742]}]},
'B2': 15775016618680324890}}
Пример 2
Двоичные данные:
b'\x0bRXTC\xe8\xff\xd5m0\xfc\x02\x00\x00\x000\x00\x05\x0b\x17\x9b\xcar\xdb'
(b'=\x15d\t\xf0zA\xf8\x12\x11@\xa3\xa1qK\xb1^8\xf6\x02o\xc9\x7fN\xa5W\xa6\xbe'
b'\x04\x00\x00\x00\x19\x00\x03\x00\x00\x00\x1d\x00\x02\x00 \x00\x88\xd0N\xbf'
b'\x05\x00\x00\x00$\x00\x03\x00\x00\x00)\x00\x02\x00,\x00')
Результат разбора:
'A1': 65512,
{'A2': {'B1': {'C1': 28117,
'C2': 64560,
'C3': [{'D1': -0.3248874247074127,
'D2': [21, 100, 9, 240],
'D3': [122, 65, 248],
'D4': [4370, -23744]},
'D1': -0.8078694343566895,
{'D2': [161, 113, 75, 177, 94],
'D3': [56, 246, 2],
'D4': [-13969, 20095]}]},
'B2': 4457282470724176645}}
Задача №12
Реализовать разбор двоичного формата данных. Данные начинаются с сигнатуры 0x4c 0x43 0x54 0x49
, за которой следует структура
A. Порядок байт: от младшего к старшему. Адреса указаны в виде смещений от начала данных. В решении предлагается использовать модуль
struct.
Структура A:
Поле | Описание |
---|---|
1 | Структура B |
2 | int8 |
3 | Адрес (uint32) структуры D |
4 | uint16 |
5 | Массив uint64, размер 6 |
Структура B:
Поле | Описание |
---|---|
1 | Размер (uint16) и адрес (uint32) массива char |
2 | Массив адресов (uint32) структур C, размер 5 |
Структура C:
Поле | Описание |
---|---|
1 | uint32 |
2 | Размер (uint32) и адрес (uint16) массива int8 |
Структура D:
Поле | Описание |
---|---|
1 | float |
2 | int16 |
3 | int32 |
Ниже показаны примеры разбора двоичного формата.
Пример 1
Двоичные данные:
b'LCTI\x05\x00U\x00\x00\x00^\x00\x00\x00j\x00\x00\x00v\x00\x00\x00\x84\x00'
(b'\x00\x00\x91\x00\x00\x00u\x9b\x00\x00\x00\x99f\xbe\xa7\x0f\n\xec2\xdd'
b'i\xea\x9c\x872x\xec\xb9Jz1,}9z$\xab~C\x98\x10\x95(\x83\x00F\xc81'
b'\xe9\x13\x97\x16\xfe\x11[#\xbe\xbe\x02;3myuul\x02\xb9}%\xba\x12=\x8b\x04\x00'
b'\x00\x00Z\x00r\xce\xb1&.\xa8\x02\x00\x00\x00h\x00\x92\xa4\xa6\x9a'
b'\xcfk\x02\x00\x00\x00t\x00\xbf\xf2@\xab\xb7W\xf7M\x04\x00\x00\x00'
b'\x80\x00\xfd;\x99\x10\xf7\xa9\x1b\x03\x00\x00\x00\x8e\x00\x13\x90{\xbfc'
b'^\xf4\xb1\n\xff')
Результат разбора:
'A1': {'B1': 'myuul',
{'B2': [{'C1': 2336035514, 'C2': [2, -71, 125, 37]},
'C1': 2821596849, 'C2': [114, -50]},
{'C1': 1808767654, 'C2': [-110, -92]},
{'C1': 1308055479, 'C2': [-65, -14, 64, -85]},
{'C1': 464123664, 'C2': [-3, 59, -103]}]},
{'A2': 117,
'A3': {'D1': -0.9826671481132507, 'D2': 24163, 'D3': -16076300},
'A4': 26265,
'A5': [7628309333197957054,
5384594830486117610,
12332116066979033466,
36917842642748286,
18308987446893856838,
3691547337817283345]}
Пример 2
Двоичные данные:
b'LCTI\x05\x00U\x00\x00\x00^\x00\x00\x00j\x00\x00\x00x\x00\x00\x00\x85\x00'
(b'\x00\x00\x91\x00\x00\x00\xd1\x9b\x00\x00\x00B\xd6+q>@\x12\xban'
b'\x88\x18\xe2\x8b\xf17\xae\x8fNC\xde\x06t\xec\xa9g\xe1G\x05\xfbN\xb2\xc6\xa6'
b'}(\x9e\xdc\xaa\x89\x97\xd7Uxn\x1f\xa0p\x08\xdc\xe2wiais\x82@\xb7,\xf97'
b'\xed\xf2\x04\x00\x00\x00Z\x00D\x85\xc6\xcd\xe9\xea\x02\x00\x00\x00h\x00'
b'\x9ag\xa6!r\xa1\xa7r\x04\x00\x00\x00t\x00\x16\xcc\x931\x0e\x9b'
b'\x91\x03\x00\x00\x00\x82\x00\xa5\xdb\xd9\x01d\x82\x02\x00\x00\x00\x8f\x00"'
b'p\xdb\xbe\x9d\xd9\xd9O-F')
Результат разбора:
'A1': {'B1': 'wiais',
{'B2': [{'C1': 4075632633, 'C2': [-126, 64, -73, 44]},
'C1': 3941191110, 'C2': [68, -123]},
{'C1': 1923588466, 'C2': [-102, 103, -90, 33]},
{'C1': 2442858033, 'C2': [22, -52, -109]},
{'C1': 2187592153, 'C2': [-91, -37]}]},
{'A2': -47,
'A3': {'D1': -0.4285898804664612, 'D2': -9827, 'D3': 1177374681},
'A4': 54850,
'A5': [9830999624146383147,
5660934811926913560,
16242137414158966339,
9054142570006512967,
6185579230749564456,
16346950027263831672]}
Задача №12
Реализовать разбор двоичного формата данных. Данные начинаются с сигнатуры 0x50 0x46 0x51 0x42
, за которой следует структура
A. Порядок байт: от младшего к старшему. Адреса указаны в виде смещений от начала данных. В решении предлагается использовать модуль
struct.
Структура A:
Поле | Описание |
---|---|
1 | float |
2 | Структура B |
3 | Адрес (uint32) структуры E |
4 | uint8 |
5 | Массив float, размер 3 |
6 | int64 |
Структура B:
Поле | Описание |
---|---|
1 | int32 |
2 | Адрес (uint32) структуры C |
Структура C:
Поле | Описание |
---|---|
1 | uint8 |
2 | uint16 |
3 | Массив структур D, размер 3 |
Структура D:
Поле | Описание |
---|---|
1 | int8 |
2 | uint8 |
3 | Массив uint8, размер 5 |
4 | uint8 |
5 | Массив uint16, размер 4 |
6 | uint8 |
Структура E:
Поле | Описание |
---|---|
1 | int64 |
2 | uint32 |
Ниже показаны примеры разбора двоичного формата.
Пример 1
Двоичные данные:
b'PFQBR?->\xd7\xc9S:)\x00\x00\x00_\x00\x00\x00\xec\xa4\xb8\x0c\xbf\x87\xed\xe1'
(b'\xbd\x8d="\xbf\x94\x10Y\xb3|*\x07#{\x84\xb7\x1c{\xe1\xa3\xd0\xf8\xe8\x0e'
b'\x8e\tz\x01\x85\x0e\xe6\xaex\xd5"\x90\xc85`)\xed\xf3ib\x1c\x8coU'
b'}\x1a\xf7\x8cQ\xf2\n\xacO\xac\x12\xe5W\x80\x04\xb7O\xb2\xce8\x1e\x0e\xee\xff'
b'\xfbBi\xe4+"\xc6')
Результат разбора:
'A1': 0.16918686032295227,
{'A2': {'B1': 978569687,
'B2': {'C1': 123,
'C2': 46980,
'C3': [{'D1': 28,
'D2': 123,
'D3': [225, 163, 208, 248, 232],
'D4': 14,
'D5': [2446, 378, 3717, 44774],
'D6': 120},
'D1': -43,
{'D2': 34,
'D3': [144, 200, 53, 96, 41],
'D4': 237,
'D5': [27123, 7266, 28556, 32085],
'D6': 26},
'D1': -9,
{'D2': 140,
'D3': [81, 242, 10, 172, 79],
'D4': 172,
'D5': [58642, 32855, 46852, 45647],
'D6': 206}]}},
'A3': {'E1': 7584901799074471480, 'E2': 3324128228},
'A4': 236,
'A5': [-0.5496923923492432, -0.11031632870435715, -0.6337516903877258],
'A6': 2524032831237722260}
Пример 2
Двоичные данные:
b'PFQB\x139\xc6>\x8d\x8aw\xda)\x00\x00\x00_\x00\x00\x00\x89&\xfb@'
(b'\xbe\xe7\xfc\xb1\xbe/\x9b7?2\n-\xea\xeb\x84S\xfe\xe9\xb2\n\xe8J&li\x07\re'
b'\xeb\xa1\x04\xc0vj_\xca\xe8\t\x82?W\xc4\xe6\xf5\x18\xf3)\xa4\x0b\x931j'
b'\x88-6o6\xbb2B\x0e\xc4\x18\x0f0\x9a\xdd\xd8w\xc2d\xcaps?(\xe2I\x8d\xb8'
b'\x10\xb9\xcf')
Результат разбора:
'A1': 0.3871541917324066,
{'A2': {'B1': -629699955,
'B2': {'C1': 233,
'C2': 2738,
'C3': [{'D1': -24,
'D2': 74,
'D3': [38, 108, 105, 7, 13],
'D4': 101,
'D5': [41451, 49156, 27254, 51807],
'D6': 232},
'D1': 9,
{'D2': 130,
'D3': [63, 87, 196, 230, 245],
'D4': 24,
'D5': [10739, 2980, 12691, 34922],
'D6': 45},
'D1': 54,
{'D2': 111,
'D3': [54, 187, 50, 66, 14],
'D4': 196,
'D5': [3864, 39472, 55517, 49783],
'D6': 100}]}},
'A3': {'E1': -8265826978570735414, 'E2': 3485012152},
'A4': 137,
'A5': [-0.18845805525779724, -0.34763261675834656, 0.7172116637229919],
'A6': -120606616227870158}
Задача №12
Реализовать разбор двоичного формата данных. Данные начинаются с сигнатуры 0x4b 0x53 0x4a
, за которой следует структура A.
Порядок байт: от старшего к младшему. Адреса указаны в виде смещений от начала данных. В решении предлагается использовать модуль
struct.
Структура A:
Поле | Описание |
---|---|
1 | int16 |
2 | Массив char, размер 2 |
3 | int8 |
4 | Размер (uint32) и адрес (uint32) массива адресов (uint16) структур B |
5 | uint16 |
6 | Адрес (uint16) структуры D |
7 | int32 |
Структура B:
Поле | Описание |
---|---|
1 | int16 |
2 | Структура C |
3 | Массив int64, размер 2 |
4 | uint64 |
5 | float |
6 | int8 |
7 | uint64 |
Структура C:
Поле | Описание |
---|---|
1 | int16 |
2 | int16 |
Структура D:
Поле | Описание |
---|---|
1 | Размер (uint32) и адрес (uint16) массива int8 |
2 | uint64 |
3 | double |
4 | int16 |
5 | uint64 |
6 | int8 |
Ниже показаны примеры разбора двоичного формата.
Пример 1
Двоичные данные:
b'KSJ\xc6\xabfy\x84\x00\x00\x00\x02\x00\x00\x00n|\xe5\x00t|\t\xbe)'
(b'\x15\xc4\t\x80bf\xd2\xce\x98\x11\xe0\xe5\x17\xb3\xe7\xe4\xb7\x11a\xd7FA\xc1J'
b'\xca\x8a\xc4\xd6\xa48\xbf\x15\xc2\x11\x8c\xf2\xe4\x10Q@\x85\r^\xa0'
b':\xc8\x96\x0bS\xd7\xd4\xc6\xce(0\xfc\xf9\x0fk[?\x93\x05\x15j\x1f\x9b\xe4'
b'!\x98\x95\x8a\xc0?<\xde\x8b\xde\xbe$\x9f\x85\xc4\x7f~\xc8\x00\x18\x00C\xdbM'
b'\x00\x00\x00\x02\x00r;\xc39i=\xc8\xb1\xb7\xbf\x98\xd8\x84\xf9\x16'
b'H\xc0\xaf\x91\x8f\x11r[L\x04\xa6\xa1\xac')
Результат разбора:
'A1': -14677,
{'A2': 'fy',
'A3': -124,
'A4': [{'B1': 5572,
'B2': {'C1': 2432, 'C2': 25190},
'B3': [-3256498277987313741, -1737062270974343615],
'B4': 13928167494953378872,
'B5': -0.5849924683570862,
'B6': -116,
'B7': 17502131993029447006},
'B1': -24518,
{'B2': {'C1': -14186, 'C2': 2899},
'B3': [-2894470071752524551, 1111082061684610410],
'B4': 2277664869510908608,
'B5': 0.7377707362174988,
'B6': -34,
'B7': 13701251363244048072}],
'A5': 31973,
'A6': {'D1': [-37, 77],
'D2': 4306348792867238327,
'D3': -0.02426345606142699,
'D4': -20591,
'D5': 10309146758470739617,
'D6': -84},
'A7': 2081013289}
Пример 2
Двоичные данные:
b'KSJ\x01\xf3pd\xc4\x00\x00\x00\x02\x00\x00\x00n\xe4\x15\x00t\\6\x80\xdd'
(b'\xea\xa2\xcf\x86(\xf1\xb1Mm"LE\xe3^\xb8\x9b\xb1&L[o\x8dtG\xa7v\x99\xa2'
b'\xaa\xbc\xbe2+\x83\x1d&F\x1a\x9d$\xe5\xf6Q\x901i\xd8\x1b\x8b\x17\x18\xd9'
b'\x93p\xed?\xd2U.s\x98\xd5\xfc\xa8+\x9c>\xfb\x87".\x96\x8b<\xae\x88'
b'\xdc\xd5\x13\xf0\xc9\xffQ\xf2\xcaI\x00\x18\x00C\xb2\xce\x00\x00\x00\x02'
b'\x00r\x99\x86\xd9\xeb\xd4\xa0!6?\xd8Wx\x05d\x0f\xe8p\xd4\x1d\xe7\xb8\x03'
b'\x80\x10\x10\x7f\xcb')
Результат разбора:
'A1': 499,
{'A2': 'pd',
'A3': -60,
'A4': [{'B1': -5470,
'B2': {'C1': -12410, 'C2': 10481},
'B3': [-5670756361713622178, -5144323371292725363],
'B4': 8378849759571651260,
'B5': -0.17399410903453827,
'B6': 29,
'B7': 2757921084042245713},
'B1': -28623,
{'B2': {'C1': 27096, 'C2': 7051},
'B3': [1664319289591414738, 6137970442414893099],
'B4': 11258712676285453963,
'B5': 0.021305494010448456,
'B6': -43,
'B7': 1436870379559897673}],
'A5': 58389,
'A6': {'D1': [-78, -50],
'D2': 11062769141590008118,
'D3': 0.380338673843879,
'D4': 28884,
'D5': 2154893271893020799,
'D6': -53},
'A7': 1547075805}
Задача №12
Реализовать разбор двоичного формата данных. Данные начинаются с сигнатуры 0x50 0x59 0x54 0x44
, за которой следует структура
A. Порядок байт: от младшего к старшему. Адреса указаны в виде смещений от начала данных. В решении предлагается использовать модуль
struct.
Структура A:
Поле | Описание |
---|---|
1 | uint16 |
2 | float |
3 | Структура B |
4 | Размер (uint32) и адрес (uint32) массива int8 |
5 | int32 |
Структура B:
Поле | Описание |
---|---|
1 | Структура C |
2 | uint64 |
3 | Размер (uint32) и адрес (uint32) массива uint32 |
Структура C:
Поле | Описание |
---|---|
1 | Размер (uint32) и адрес (uint16) массива структур D |
2 | Массив int8, размер 7 |
3 | uint8 |
4 | double |
5 | uint64 |
Структура D:
Поле | Описание |
---|---|
1 | uint8 |
2 | uint8 |
3 | uint32 |
4 | int8 |
5 | int8 |
6 | int16 |
7 | Массив uint8, размер 4 |
Ниже показаны примеры разбора двоичного формата.
Пример 1
Двоичные данные:
b'PYTDJ\xcaU\xe1\xa1\xbe\x03\x00\x00\x00D\x00\xc9\x06\xfd\xb1w\xa4\x84\xa5'
(b'\x98\xe9\x8cG>\x87\xd3?F\xf1\xb5\xe6\xbf\xd1;\x17\xbe\xec\xa7\x8c'
b'\xa1e\xab\xee\x02\x00\x00\x00n\x00\x00\x00\x04\x00\x00\x00v\x00\x00\x00'
b'\x8fi\xff#\xdb\xaf\xd5\xa6\xd6}(0\xa6\xbb^\xc6\xf3\xc3g\xfbG/}\xb3'
b"\xebW\xab\xf8\\\xa7\x8a_\xc9\xc14\x13\xe9\xf5\xc1\xeb\xaf\xee\xc2uq'\xe1\xbe"
b'\x03\xfdq\x81|\xd5O\xb3\x14G')
Результат разбора:
'A1': 51786,
{'A2': -0.3161722719669342,
'A3': {'B1': {'C1': [{'D1': 219,
'D2': 175,
'D3': 2111219413,
'D4': 40,
'D5': 48,
'D6': -17498,
'D7': [94, 198, 243, 195]},
'D1': 103,
{'D2': 251,
'D3': 3011325767,
'D4': -21,
'D5': 87,
'D6': -1877,
'D7': [92, 167, 138, 95]},
'D1': 201,
{'D2': 193,
'D3': 4125692724,
'D4': -63,
'D5': -21,
'D6': -4433,
'D7': [194, 117, 113, 39]}],
'C2': [-55, 6, -3, -79, 119, -92, -124],
'C3': 165,
'C4': 0.3051295946821937,
'C5': 1674162308637913414},
'B2': 17197951346568326334,
'B3': [4244881121, 3581706609]},
'A4': [79, -77, 20, 71],
'A5': 603941263}
Пример 2
Двоичные данные:
b'PYTD\xdc\xec\x85\xce`\xbe\x03\x00\x00\x00D\x00+G\x9a\xe0\xee\xa3\x93\xcc'
(b'\x00.~\xa8e\xa7\xa7?\xf0\xfb2\xcd\xba\xcf!Dy\xf6\x07\x91\xad\xd3\xde\xa8'
b'\x05\x00\x00\x00n\x00\x00\x00\x05\x00\x00\x00\x82\x00\x00\x00\x1f\x10P\x85'
b"\x19\x98\x01'\x93\x11\xb7x~a\x14\xf8yG\xbb,\xa8(\x93V``*.G\xf9<\xbb"
b'<\x86\x19\xe8\x1f\xe7A\x80\x0e\xc3\xb0g:\x90\x061}\xa8\xbeY\xb5\xbf\x1fD'
b'\xcc\x1a\x8c\xdf\xd2\xf3\xc8\xae0\xbb f\x11\x06s')
Результат разбора:
'A1': 60636,
{'A2': -0.21953780949115753,
'A3': {'B1': {'C1': [{'D1': 25,
'D2': 152,
'D3': 294856449,
'D4': -73,
'D5': 120,
'D6': 24958,
'D7': [20, 248, 121, 71]},
'D1': 187,
{'D2': 44,
'D3': 1452484776,
'D4': 96,
'D5': 96,
'D6': 11818,
'D7': [71, 249, 60, 187]},
'D1': 60,
{'D2': 134,
'D3': 3877627929,
'D4': 65,
'D5': -128,
'D6': -15602,
'D7': [176, 103, 58, 144]}],
'C2': [43, 71, -102, -32, -18, -93, -109],
'C3': 204,
'C4': 0.04619901353643385,
'C5': 4909433470024088560},
'B2': 12168395985617679993,
'B3': [2826776838, 3216333246, 449594399, 4090683276, 3140529864]},
'A4': [32, 102, 17, 6, 115],
'A5': -2058350561}
Задача №12
Реализовать разбор двоичного формата данных. Данные начинаются с сигнатуры 0x1f 0x47 0x58 0x49 0x5a
, за которой следует
структура A. Порядок байт: от старшего к младшему. Адреса указаны в виде смещений от начала данных. В решении предлагается использовать
модуль struct.
Структура A:
Поле | Описание |
---|---|
1 | uint8 |
2 | Адрес (uint16) структуры B |
3 | Массив float, размер 6 |
Структура B:
Поле | Описание |
---|---|
1 | Структура C |
2 | int16 |
Структура C:
Поле | Описание |
---|---|
1 | Массив адресов (uint16) структур D, размер 3 |
2 | uint16 |
3 | Размер (uint32) и адрес (uint32) массива uint16 |
4 | Массив float, размер 2 |
Структура D:
Поле | Описание |
---|---|
1 | uint64 |
2 | int16 |
3 | Размер (uint32) и адрес (uint16) массива uint16 |
4 | int8 |
5 | int16 |
6 | float |
7 | float |
Ниже показаны примеры разбора двоичного формата.
Пример 1
Двоичные данные:
b"\x1fGXIZ\xe7\x00\x81\xbc\xd3\xbd\x9a='v\xed?^\xf9<>\x1d$\xd9>\x00\x05/"
(b'>\xee\x92\x815}\xb0j\xd3\x05\x10D\xf2\xf0\xfa|T\xfe\x00\x00\x00\x02\x00 '
b'\xba\x12\xf1\xbfV\xf12\xbf<\x83\x0b\xce\x17\xeb(8z\xf7"< 1\x8a\xa1'
b'\xe0\x00\x00\x00\x02\x00?1\x7f\xf6\xbd\x90\x85\xef\xbe\xc8J\x94"/'
b'\xccQ\xa8\x8f\xaew\xfe\x96]`\xed\xa8\x00\x00\x00\x02\x00^\xe5\x19'
b'A\xbe\xca\x85\xb2>i\xb4 \xde=\x856\x00$\x00C\x00b\x04\xdb\x00\x00\x00'
b'\x02\x00\x00\x00}?;m\xb7=\xe2\xf6d\rR')
Результат разбора:
'A1': 231,
{'A2': {'B1': {'C1': [{'D1': 15205577605206047356,
'D2': 21758,
'D3': [13693, 45162],
'D4': -70,
'D5': 4849,
'D6': -0.8396178483963013,
'D7': -0.73637455701828},
'D1': 4069836939692355978,
{'D2': -24096,
'D3': [52759, 60200],
'D4': 49,
'D5': 32758,
'D6': -0.07056795805692673,
'D7': -0.3911939859390259},
'D1': 12146118550437125472,
{'D2': -4696,
'D3': [8751, 52305],
'D4': -27,
'D5': 6465,
'D6': -0.39555126428604126,
'D7': 0.2282261848449707}],
'C2': 1243,
'C3': [56893, 34102],
'C4': [0.7321428656578064, 0.11082151532173157]},
'B2': 3410},
'A3': [-0.025847245007753372,
0.04088490083813667,
0.870990514755249,
0.15346087515354156,
0.12501977384090424,
0.4659614861011505]}
Пример 2
Двоичные данные:
b'\x1fGXIZH\x00\x89\xbf\x10Q^\xbe\xe5\x88\xe5\xbe\xca\x0cb?\x14C\x89\xbeW\xb4_'
(b'\xbe\xe8\x9aLS4\x87\xf5Di\x16e\x9bU*_\xc3\x95\x00\x00\x00\x02\x00 GS\x18\xbd'
b'\xc0\xf1\xa6\xbf-Lr\x0e\x80Cfq\xb5Y#A\xea)\rGX\x00\x00\x00\x02\x00?\xf1'
b'@y>\xb2;\xdc\xbf6h\xc6\xa8\x97p\x90Z\xbb>m\x89\xf3\xb6\x06\xd6\x1e0_\x00\x00'
b'\x00\x03\x00^,QA?RlC>\xa6\xdf"\x8ax\x16\x96D\x05?\xe2\xbf\xad\x00$\x00'
b'C\x00d\x11\xdc\x00\x00\x00\x05\x00\x00\x00\x7f>\xe3\x82\xa4\xbf\x00\xdb'
b'y\xd7\xcf')
Результат разбора:
'A1': 72,
{'A2': {'B1': {'C1': [{'D1': 4929495892787276383,
'D2': -15467,
'D3': [21300, 34805],
'D4': 71,
'D5': 21272,
'D6': -0.0942109078168869,
'D7': -0.6769477128982544},
'D1': 8193553105035077901,
{'D2': 18264,
'D3': [3712, 17254],
'D4': -15,
'D5': 16505,
'D6': 0.34811294078826904,
'D7': -0.7125362157821655},
'D1': 4498403282636953118,
{'D2': 12383,
'D3': [43159, 28816, 23227],
'D4': 44,
'D5': 20801,
'D6': 0.82196444272995,
'D7': 0.32592111825942993}],
'C2': 4572,
'C3': [35448, 5782, 17413, 16354, 49069],
'C4': [0.4443560838699341, -0.5033488869667053]},
'B2': -10289},
'A3': [-0.5637415647506714,
-0.4483100473880768,
-0.394625723361969,
0.5791555047035217,
-0.21064899861812592,
-0.45430219173431396]}
Задача №12
Реализовать разбор двоичного формата данных. Данные начинаются с сигнатуры 0x5a 0x57 0x56 0x48
, за которой следует структура
A. Порядок байт: от младшего к старшему. Адреса указаны в виде смещений от начала данных. В решении предлагается использовать модуль
struct.
Структура A:
Поле | Описание |
---|---|
1 | int16 |
2 | Структура B |
3 | Массив адресов (uint16) структур E, размер 2 |
4 | int64 |
5 | Массив uint16, размер 6 |
6 | uint8 |
7 | float |
8 | float |
Структура B:
Поле | Описание |
---|---|
1 | Размер (uint16) и адрес (uint32) массива char |
2 | Структура C |
Структура C:
Поле | Описание |
---|---|
1 | uint32 |
2 | Адрес (uint32) структуры D |
3 | Массив int8, размер 4 |
Структура D:
Поле | Описание |
---|---|
1 | int64 |
2 | double |
3 | uint64 |
4 | int8 |
5 | int8 |
Структура E:
Поле | Описание |
---|---|
1 | uint8 |
2 | int64 |
3 | uint16 |
4 | int32 |
5 | uint64 |
6 | int8 |
Ниже показаны примеры разбора двоичного формата.
Пример 1
Двоичные данные:
b"ZWVH\x8f\x1b\x04\x009\x00\x00\x00'\xce$\x88=\x00\x00\x00\xd9\r\xe9W"
(b'W\x00o\x00\xdd\xc7\xea5?\xab\x06\xea\xa6\x95y8\xd0\x96x\xd2\x18O;Y'
b'\x96\xdb\xf6/?v\xf8\xcb>ekwu\xdf\x1bf\xb8\xb0w\xbb\xcf0:\xd0\xab\xc7\xaf\xbb'
b'\xbf\xc7\xf7\xb5\x9d\xb4vH\x94\xba\x92\xde:\\8\xc6\x86\x0c\x04\xb7S\xafE\x99'
b'B\x88\xc6/\x111\x96\xdc\xc8\xc3[G\x11\xc7\x1d\xd7\x1bC\x0b\x86Xe\xc4\xb6'
b'\r\xf1\xa7A\xb7\xab!\xf7$\xdd<')
Результат разбора:
'A1': 7055,
{'A2': {'B1': 'ekwu',
'B2': {'C1': 2284113447,
'C2': {'D1': -3478054686321927201,
'D2': -0.10815093941366949,
'D3': 10684920634048640967,
'D4': -70,
'D5': -110},
'C3': [-39, 13, -23, 87]}},
'A3': [{'E1': 222,
'E2': -5259064691871163334,
'E3': 44883,
'E4': -2008901307,
'E5': 14107768370364493766,
'E6': 91},
'E1': 71,
{'E2': -8787856461031160047,
'E3': 25944,
'E4': -250759484,
'E5': 15935133105530552743,
'E6': 60}],
'A4': -1583389930998282275,
'A5': [38310, 14457, 38608, 53880, 20248, 22843],
'A6': 150,
'A7': 0.6873604655265808,
'A8': 0.39837998151779175}
Пример 2
Двоичные данные:
b'ZWVHI\xf0\x08\x009\x00\x00\x00\\_\x1c\xa6A\x00\x00\x00!q|\xa7[\x00s\x00'
(b'\xb8\xb0\xb1u:D\xb3\x8f\xac2\x0c\x08\x8f\x05\x86t\x81\x04I`&N\xdb\xdf'
b'\xbe\xa5\xd4s\xbfuiktuzmy.>\xb5\xda\xe8\x1b\xe0\xaa\x00\xea\xaf'
b'\x90\xab\xd8\x82\xbf\xfbg\x80\xd0P\xbd\x9a\xd3\xabk>:\xae\xb0;\xf2\\\x01,'
b'\xc8\xb9C\xba\xb7\xea\xf3i\xd39]\x93\x81\x1d\x1f\xa2\xa3\x93-\xdf'
b'{\x08\x06\xb1\xb7\xc20:\xcb\x9b}\x95\xc1\xe2\x1f\xfeS\x92p')
Результат разбора:
'A1': -4023,
{'A2': {'B1': 'uiktuzmy',
'B2': {'C1': 2786877276,
'C2': {'D1': -6133872005562941906,
'D2': -0.009202328064920273,
'D3': 15247707643209345019,
'D4': -85,
'D5': 107},
'C3': [33, 113, 124, -89]}},
'A3': [{'E1': 62,
'E2': 3170917808098815546,
'E3': 47560,
'E4': -357057981,
'E5': 2126142527706982899,
'E6': 31},
'E1': 162,
{'E2': -5690851751017737309,
'E3': 49847,
'E4': -1681180112,
'E5': 10544050565506241917,
'E6': 112}],
'A4': -8092049087581278024,
'A5': [12972, 2060, 1423, 29830, 1153, 24649],
'A6': 38,
'A7': -0.43722003698349,
'A8': -0.9524634480476379}
Задача №12
Реализовать разбор двоичного формата данных. Данные начинаются с сигнатуры 0x15 0x52 0x4c 0x44
, за которой следует структура
A. Порядок байт: от старшего к младшему. Адреса указаны в виде смещений от начала данных. В решении предлагается использовать модуль
struct.
Структура A:
Поле | Описание |
---|---|
1 | Структура B |
2 | Адрес (uint32) структуры D |
3 | Размер (uint16) и адрес (uint16) массива char |
4 | Размер (uint32) и адрес (uint32) массива float |
5 | Массив int8, размер 8 |
6 | uint16 |
7 | int16 |
8 | double |
Структура B:
Поле | Описание |
---|---|
1 | uint64 |
2 | Массив адресов (uint16) структур C, размер 6 |
Структура C:
Поле | Описание |
---|---|
1 | uint32 |
2 | int64 |
3 | uint16 |
4 | int32 |
Структура D:
Поле | Описание |
---|---|
1 | float |
2 | Структура E |
3 | Массив char, размер 4 |
Структура E:
Поле | Описание |
---|---|
1 | uint32 |
2 | uint8 |
Ниже показаны примеры разбора двоичного формата.
Пример 1
Двоичные данные:
b'\x15RLD\x07\x8c_O\x86L\xb3\xef\x00<\x00N\x00`\x00r\x00\x84\x00\x96'
(b'\x00\x00\x00\xa8\x00\x02\x00\xb5\x00\x00\x00\x02\x00\x00\x00\xb7\xb0&\x8bi'
b'{v\x81\x8aa6\x18\xdf?\xc6\xbff\xa5\x03\x00\xc0\xa7\xb2\xb3\xfd\xf2\x0b\xd5*'
b'\xe0\xf9C\x13\xac\xc8\x15j\xf3O\xedJ\x90\xddfYi\x94\xd1y\x8fz\x02^.\x9e>>'
b'd\xf5\xcb\x80`6D\xafN\x85\xcbK&\xc8BM|]?\x0f~@\xf5b\xa5\x9f\xc1A8KY\xff'
b',\xe5+\x16ar\xd5\xf6\x7f\xc10\x9dJ\xbe\x11}\xace\x8c\x94g\xc2g7\xe8`\xafv'
b'\r~h\xb39\xa2\x9cL\x08\xb1\xfa\xc9\xbeF-\x92\xde\x90\xb7\xeb\xf0chodnr\xbe'
b'\x1f\x15\x1e>\xbb\x83\xb4')
Результат разбора:
'A1': {'B1': 543914450165216239,
{'B2': [{'C1': 2813506557,
'C2': -1005475711647399149,
'C3': 44232,
'C4': 359330639},
'C1': 3981086941,
{'C2': 7375041952686378874,
'C3': 606,
'C4': 782122558},
'C1': 1693830016,
{'C2': 6932804196110814027,
'C3': 9928,
'C4': 1112374365},
'C1': 1057979968,
{'C2': -764866881138902965,
'C3': 23039,
'C4': 753216278},
'C1': 1634915830,
{'C2': 9205692565443973501,
'C3': 44133,
'C4': -1936431166},
'C1': 1731717216,
{'C2': -5803436233246688862,
'C3': 40012,
'C4': 145881801}]},
'A2': {'D1': -0.19353321194648743,
'D2': {'E1': 3734026219, 'E2': 240},
'D3': 'chod'},
'A3': 'nr',
'A4': [-0.15535399317741394, 0.36623919010162354],
'A5': [-80, 38, -117, 105, 123, 118, -127, -118],
'A6': 24886,
'A7': 6367,
'A8': 0.17771609360898388}
Пример 2
Двоичные данные:
b'\x15RLD\x8e>\xfb\x8e\xc2\xf2\xf7\x1d\x00<\x00N\x00`\x00r\x00\x84\x00\x96'
(b'\x00\x00\x00\xa8\x00\x02\x00\xb5\x00\x00\x00\x02\x00\x00\x00\xb7v\xba"\x8e'
b']\xc1\xec\xe7\xfc\xff\xcfU?\xbeS^\xe7>/ \x88\x94\xcdF\x8e\x1fb\xc2'
b'\xee\xf8<\x1d\xd9\xacnujRO\xf3D&\xdcX\x06~0|\xe7\xe9\x161/\x9a\xfbt'
b'|!\xb3\x13\x1e\x10\xe7osx1$\xbb\xf5\x1e\xff\xe9\x9d\x14^&\x99h\x91'
b'\xeaN\xa5\xd93W7\x1e\x8e\x87&\x9d\x7f\xb6\x00Z\x04*\\\x9f\x89%\xed\xf5'
b'K\xeb\xb1A\x97\xcc\xfc\xa5\n+>\xef\x82\xfa[\x14\xa8X\xf6\xd1k\x0f\x00p?y<6'
b'\xc1\x97\x0c\xa0\xf5qivhuh\xbf9V\x7f\xbcoo\x15')
Результат разбора:
'A1': {'B1': 10249906392516458269,
{'B2': [{'C1': 2291453254,
'C2': -8205731406673331171,
'C3': 55724,
'C4': 1853188690},
'C1': 1341342758,
{'C2': -2569296448365729815,
'C3': 5681,
'C4': 798686068},
'C1': 2082583315,
{'C2': 2166485886629851428,
'C3': 48117,
'C4': 520087965},
'C1': 341714585,
{'C2': 7535061275078374231,
'C3': 14110,
'C4': -1903745379},
'C1': 2142634074,
{'C2': 300154165444079093,
'C3': 19435,
'C4': -1321101364},
'C1': 4238674475,
{'C2': 4534987361566894168,
'C3': 63185,
'C4': 1796145264}]},
'A2': {'D1': 0.9735749959945679,
'D2': {'E1': 3247901856, 'E2': 245},
'D3': 'qivh'},
'A3': 'uh',
'A4': [-0.7239760756492615, -0.01461388636380434],
'A5': [118, -70, 34, -114, 93, -63, -20, -25],
'A6': 64767,
'A7': -12459,
'A8': 0.11845963616923116}
Задача №12
Реализовать разбор двоичного формата данных. Данные начинаются с сигнатуры 0x59 0x48 0x43 0xe1
, за которой следует структура
A. Порядок байт: от старшего к младшему. Адреса указаны в виде смещений от начала данных. В решении предлагается использовать модуль
struct.
Структура A:
Поле | Описание |
---|---|
1 | Структура B |
2 | int8 |
Структура B:
Поле | Описание |
---|---|
1 | Массив структур C, размер 3 |
2 | int8 |
3 | int64 |
4 | Размер (uint16) и адрес (uint16) массива uint8 |
5 | Адрес (uint32) структуры E |
6 | Массив int16, размер 4 |
7 | Структура F |
Структура C:
Поле | Описание |
---|---|
1 | uint64 |
2 | Структура D |
3 | Массив uint16, размер 2 |
Структура D:
Поле | Описание |
---|---|
1 | double |
2 | int64 |
Структура E:
Поле | Описание |
---|---|
1 | uint8 |
2 | int64 |
3 | uint64 |
4 | double |
5 | double |
6 | uint32 |
Структура F:
Поле | Описание |
---|---|
1 | int32 |
2 | uint8 |
Ниже показаны примеры разбора двоичного формата.
Пример 1
Двоичные данные:
b'YHC\xe1)^\xb0\x12I;C\xd7\xbf\xdd\x15\x81\xe0\xecxL\xde\xebPy\xd2\xd7\xdf\xc9'
(b'\x95\xb2\x92\xd3\xd8\xff\x92b\x8c\x8b\x9c\xed?\xcc\x9d-\xaf\x0cZ\xd8'
b'33\xd9\xdd\x9c\x04\x07\xa4\x01\xf9\xfc\xaa\x98\xf2 \xeb\xd2\x9b\x89\xbf'
b"\xbf\xea',\x1d\xc6\xca\xe6\t\x16$\x1aSL~\xcbET^B_\x04)\xc6I\xe0bD"
b" \x00\x04\x00w\x00\x00\x00{\x8d\x1e\xc4\xd5K\x1e\xa1\xb3\x84>\xc4F9z\x91+'f-"
b'\xb2\xbfP\xa0\xaa\xce7\x9c3\xbf\xb1\x8ev\x95\xaaJ?\xect\x90M`T\xe2\xbfv\xe1>'
b'o\xdb\xfd\x00\xc2Oz\xa4')
Результат разбора:
'A1': {'B1': [{'C1': 2981013595950367703,
{'C2': {'D1': -0.45443770375448334, 'D2': -2383723093603917879},
'C3': [38322, 37587]},
'C1': 15636377383216061677,
{'C2': {'D1': 0.22354670569685342, 'D2': 3689532065575077796},
'C3': [505, 64682]},
'C1': 11020907435351837119,
{'C2': {'D1': -0.8172817784855766, 'D2': 654750491314257611},
'C3': [17748, 24130]}],
'B2': 95,
'B3': 299988870796297248,
'B4': [145, 43, 39, 102],
'B5': {'E1': 45,
'E2': -5566641963416012900,
'E3': 3728894241919052362,
'E4': 0.8892289649253622,
'E5': -0.005585903066957387,
'E6': 3259988644},
'B6': [-29410, -15147, 19230, -24141],
'B7': {'F1': -2076261306, 'F2': 57}},
'A2': 122}
Пример 2
Двоичные данные:
b'YHC\xe1\xfc\x8a\x87m\xe6\xe0w\xcd\xbf\xd0\x8a\xb8\x9c\x12\x1d\xf0^1\xce['
(b"A\xc2\xa3\x00\xd4\xff'G\x1f2\xfe\t\xe4PZL?\xeb\xd1z\xfbc\xb0\xee"
b'\xaaF\x17\xd1\x982\xbb\x13\xaa\xe3\xe0*\x04\xa0\xd2\xc6\xe2\x1c\xbc\xf8'
b'?\xe0\xd6\xd2\n?\xe7\xbc\xc1&E\x84c\xf7\xb7<\xbd\xd7dp-\xd4\xe7%\xa0aj\x1c'
b'@\x00\x04\x00w\x00\x00\x00{\x1dHazcl\xc9\x04X\x93\xf0\xfb\xc7^\x10'
b'\xd0\xb0\xce\x00\xfd\x86\x95\xb5\x07\xfe\xceC\xb2/\xa1\xba/\xd5\xe34'
b'?\xe8/\xe48{\xac\xbc?\xc2.\x80\x98\xe5Yx\xe9\xe9\xe4I')
Результат разбора:
'A1': {'B1': [{'C1': 18197506150438565837,
{'C2': {'D1': -0.2584668659332854, 'D2': 6787433004764668672},
'C3': [54527, 10055]},
'C1': 2248138482449930828,
{'C2': {'D1': 0.8693213376950817, 'D2': -6177223649922991341},
'C3': [43747, 57386]},
'C1': 333498124064308472,
{'C2': {'D1': 0.5262232017696458, 'D2': -4528855940359276740},
'C3': [48599, 25712]}],
'B2': 45,
'B3': -3105472047289328576,
'B4': [16, 208, 176, 206],
'B5': {'E1': 0,
'E2': -178290530478797245,
'E3': 12839658883695108916,
'E4': 0.7558461287675509,
'E5': 0.14204413858051246,
'E6': 3924419657},
'B6': [7496, 24954, 25452, -14076],
'B7': {'F1': 1486090491, 'F2': 199}},
'A2': 94}
Задача №12
Реализовать разбор двоичного формата данных. Данные начинаются с сигнатуры 0x48 0x4a 0x46 0x48
, за которой следует структура
A. Порядок байт: от младшего к старшему. Адреса указаны в виде смещений от начала данных. В решении предлагается использовать модуль
struct.
Структура A:
Поле | Описание |
---|---|
1 | Структура B |
2 | int64 |
3 | Размер (uint32) и адрес (uint32) массива char |
4 | int16 |
5 | Размер (uint16) и адрес (uint32) массива структур D |
6 | Размер (uint16) и адрес (uint16) массива int64 |
7 | uint64 |
Структура B:
Поле | Описание |
---|---|
1 | int64 |
2 | int8 |
3 | float |
4 | uint64 |
5 | uint64 |
6 | uint16 |
7 | Структура C |
Структура C:
Поле | Описание |
---|---|
1 | Массив char, размер 3 |
2 | float |
3 | uint8 |
4 | int32 |
5 | uint32 |
6 | uint16 |
Структура D:
Поле | Описание |
---|---|
1 | int8 |
2 | int32 |
Ниже показаны примеры разбора двоичного формата.
Пример 1
Двоичные данные:
b'HJFH\x86\xd5\xe26,a#\x1fv\x9c\x0c=\xbfN\xc0\xe5_\xe6\n\x82\x96I\xbb\x8c'
(b'\x03\x0f_\x90\rI\xabonc\x8f\xfe.\xbf\x8d\xd7\xd8\x8c\x031\xea\x15\xdbU'
b'\xdeg\x1c\xa1_\xbfJ*\n\x07\x00\x00\x00Y\x00\x00\x00\xa53\x02\x00`\x00\x00'
b'\x00\x03\x00j\x00\xd7q\n\xaaz\xe2mkwtchxzl\xdb\xcf\xd7W\xa2\xf3r\xcch"\xaeN'
b'\xb2\xe7\xc4\xb4P\x94\x04T\x8b\x93\xf8\x17\xc1\x9c_\xbfoW\x0e\x07-\xf2')
Результат разбора:
'A1': {'B1': 2243743881887929734,
{'B2': 118,
'B3': -0.738473653793335,
'B4': 10845242837229224014,
'B5': 977385637228100425,
'B6': 43849,
'B7': {'C1': 'onc',
'C2': -0.6835717558860779,
'C3': 141,
'C4': 59562199,
'C5': 3675646513,
'C6': 56917}},
'A2': 732480075204729959,
'A3': 'wtchxzl',
'A4': 13221,
'A5': [{'D1': -37, 'D2': -1571301425}, {'D1': -13, 'D2': 577293426}],
'A6': [-7759503400165552466, -7151408376892926972, -996132184401133729],
'A7': 7741092350986449367}
Пример 2
Двоичные данные:
b'HJFH\x12t\xb0&G<\xef\x95\xe3*g\xc6\xbe[\xf1\x02\xa9\x9d^\xa2\xb8\xd0\x0bC'
(b'\x00h-a6\x87\xe6zzw\x8a%\x7f?\xd4TJ@\xbc\xea\x1f \xa1U\xa1]\xaa\xda\\4p\x96'
b'\xec\x07\x00\x00\x00Y\x00\x00\x00\xf9m\x05\x00`\x00\x00\x00\x03\x00y'
b'\x00\xe3\xed\xe4\xbe\x8f\xb5\xb4\xfawkwjyhm\x07\x85L\x88\r"\x8d\xfa'
b'v\xc2o\xa8\x063\x13\x9fHG\x8a\xa9\x81\x18\xea\xd5\xd1<SY\xe0]\x10*'
b'\x81\xb7\x18Q\xf7SmN\x7fAA\xe6\x1b-\x0f1\x96')
Результат разбора:
'A1': {'B1': -7642823766334999534,
{'B2': -29,
'B3': -0.38750582933425903,
'B4': 13304300280444285275,
'B5': 3918463075493284816,
'B6': 59015,
'B7': {'C1': 'zzw',
'C2': 0.9966665506362915,
'C3': 212,
'C4': -1136637356,
'C5': 2703237098,
'C6': 41301}},
'A2': -1398807264053515683,
'A3': 'wkwjyhm',
'A4': 28153,
'A5': [{'D1': 7, 'D2': 227036293},
'D1': 34, 'D2': -1032390003},
{'D1': 111, 'D2': 322111144},
{'D1': -97, 'D2': -1450555576},
{'D1': -127, 'D2': -774510056}],
{'A6': [-9139474498413046980, 9173389698399279287, -7624296007745519295],
'A7': 18065263634277527011}
Задача №12
Реализовать разбор двоичного формата данных. Данные начинаются с сигнатуры 0x57 0x4c 0x44 0x4e
, за которой следует структура
A. Порядок байт: от младшего к старшему. Адреса указаны в виде смещений от начала данных. В решении предлагается использовать модуль
struct.
Структура A:
Поле | Описание |
---|---|
1 | float |
2 | uint8 |
3 | int8 |
4 | uint16 |
5 | Структура B |
6 | Размер (uint16) и адрес (uint16) массива char |
7 | Структура D |
8 | int32 |
Структура B:
Поле | Описание |
---|---|
1 | Массив char, размер 8 |
2 | int8 |
3 | int8 |
4 | Массив адресов (uint32) структур C, размер 2 |
5 | int8 |
Структура C:
Поле | Описание |
---|---|
1 | double |
2 | int64 |
Структура D:
Поле | Описание |
---|---|
1 | int8 |
2 | int8 |
3 | Массив float, размер 6 |
4 | int16 |
5 | double |
6 | int64 |
Ниже показаны примеры разбора двоичного формата.
Пример 1
Двоичные данные:
b"WLDN)E@\xbf\x12~'JbqrbkmazH\xc2S\x00\x00\x00c\x00\x00\x00\xfe\x02"
(b'\x00s\x00\xa4u\xde\x1eR>)a\x10?\xcb\xea\xc3>\x86\xdd\x0e?5\xd6\xb2>$\xcdq'
b'?\xb8{\x8a\x02\x94.`\x96\xec?J\xc3Pw\x06Rb~\x86zl;\xac\x8c\xa6Ei'
b"1\xe4\xbf\xe70\xc0C\x13}@\xa6\x00\x8b\x0b\x89\x9a\xd9\x9e?'\x8bf\xce\xb8S~~r"
b't')
Результат разбора:
'A1': -0.7510553002357483,
{'A2': 18,
'A3': 126,
'A4': 18983,
'A5': {'B1': 'bqrbkmaz',
'B2': 72,
'B3': -62,
'B4': [{'C1': -0.6310316429484337, 'C2': -6467031543209512729},
'C1': 0.03012696706253859, 'C2': 9114814749046377255}],
{'B5': -2},
'A6': 'rt',
'A7': {'D1': -92,
'D2': 117,
'D3': [0.20519587397575378,
0.5639825463294983,
0.3826507031917572,
0.5580676794052124,
0.34929051995277405,
0.9445364475250244],
'D4': 31672,
'D5': 0.8933564100007783,
'D6': 9106931584221627210},
'A8': 996964998}
Пример 2
Двоичные данные:
b'WLDN\x02\xa15?\x15.\x0c\xc2wqxxpgku\xc8\xc8S\x00\x00\x00c\x00'
(b'\x00\x00\x07\x04\x00s\x008\x99L\x00\x1c\xbf\x8f\xa6\xa7<[\xea\x8d>\xbfk\xde'
b'\xbe\xd3+\xf0>\x94\xaa\xc3=h\xb0\xb4rn\xce*\xad\xdc\xbfD\xeb\xfa|\xf5'
b'U\xb0\xdf``\x8e\xfe\xa4g\xd0x\xd4#\xdf\xbfbM%\x0bboC\xab\x9ei\x8b\xd0\xa7'
b'\xbd\xe7\xbfe\x9c\x98\xb9\x7f-vLznrl')
Результат разбора:
'A1': 0.709488034248352,
{'A2': 21,
'A3': 46,
'A4': 49676,
'A5': {'B1': 'wqxxpgku',
'B2': -56,
'B3': -56,
'B4': [{'C1': -0.4865618877244009, 'C2': -6105914202899788446},
'C1': -0.7419013093124709, 'C2': 5509641220732263525}],
{'B5': 7},
'A6': 'znrl',
'A7': {'D1': 56,
'D2': -103,
'D3': [-0.6093795299530029,
0.02046516351401806,
0.2771786153316498,
-0.4344157874584198,
0.46908435225486755,
0.09554019570350647],
'D4': -20376,
'D5': -0.44806928786583033,
'D6': -2328266494498378940},
'A8': -24223648}
Задача №12
Реализовать разбор двоичного формата данных. Данные начинаются с сигнатуры 0x51 0x4f 0x55 0x4e
, за которой следует структура
A. Порядок байт: от старшего к младшему. Адреса указаны в виде смещений от начала данных. В решении предлагается использовать модуль
struct.
Структура A:
Поле | Описание |
---|---|
1 | int32 |
2 | Адрес (uint32) структуры B |
Структура B:
Поле | Описание |
---|---|
1 | uint32 |
2 | uint16 |
3 | uint64 |
4 | int8 |
5 | int8 |
6 | Размер (uint32) и адрес (uint32) массива структур C |
7 | Размер (uint32) и адрес (uint32) массива int8 |
8 | float |
Структура C:
Поле | Описание |
---|---|
1 | Структура D |
2 | int8 |
3 | uint32 |
4 | double |
5 | Размер (uint32) и адрес (uint32) массива uint8 |
Структура D:
Поле | Описание |
---|---|
1 | uint64 |
2 | Массив uint16, размер 4 |
Ниже показаны примеры разбора двоичного формата.
Пример 1
Двоичные данные:
b'QOUN\x16kX!\x00\x00\x00\x89\xbcJF\x82:%E\x1c\xf3/\xe7\xf8\xc42\x8fJ'
(b'\xdc\x0f\xaa\x8f\x83\xc3L\xec\xf7\x13\x8c\xf0\x1e\xb0c?\xcfq\xfe\xc8'
b'\xbf\xc3\x08\x00\x00\x00\x04\x00\x00\x00\x0c\x8e\x11\xe6d>5W\xb7CA\xc5)\xb0'
b'}\xd3y\xa4hrQ\xf0?\xbceE\x82|i\xa0\x00\x00\x00\x04\x00\x00\x00\x10'
b'A\x1a\xb2\x97\x01\x81\x9fQ\xe3g?h\xa4%\x8a\xcf\xcfW|\x93\xaa?\xe9=\xd1\xaa7k'
b'\x18\x00\x00\x00\x02\x00\x00\x00\x14\nP\x994:z\x8e\x0b*\xdc\xb1bw\xf2\xea'
b'*\x91\xdaE;\x00\x00\x00\x03\x00\x00\x00\x16\x00\x00\x00\x04\x00\x00\x00'
b'\x85?.\x8f\x0b')
Результат разбора:
'A1': 376133665,
{'A2': {'B1': 981110283,
'B2': 10972,
'B3': 12781910577625338330,
'B4': 69,
'B5': 59,
'B6': [{'C1': {'D1': 16715325738417052687,
'D2': [43663, 33731, 19692, 63251]},
'C2': -116,
'C3': 4028543075,
'C4': 0.24566635896874112,
'C5': [188, 74, 70, 130]},
'C1': {'D1': 10237216746204649399,
{'D2': [17217, 50473, 45181, 54137]},
'C2': -92,
'C3': 1752322544,
'C4': 0.11092028079693828,
'C5': [58, 37, 69, 28]},
'C1': {'D1': 4691258323494870865,
{'D2': [58215, 16232, 42021, 35535]},
'C2': -49,
'C3': 1467782058,
'C4': 0.7887962650814613,
'C5': [243, 47]}],
'B7': [10, 80, -103, 52],
'B8': 0.68187016248703}}
Пример 2
Двоичные данные:
b'QOUNPgp\x95\x00\x00\x00\x87a\xcb2H\xcb\xa8=\xb7C\xb4\xadNV\x9b\xc1c'
(b'\x14\xd3r\x1f{\x7f\n~\t\xf3K\x0b?\xe3S\xed#\xf9\xf5\x96\x00\x00\x00\x02'
b'\x00\x00\x00\x0cs\x10z\x8a:\xa7R12\x1d\xfd\xf8\x91;\xac/\xfdn\x82*W?\xef\xa5'
b'\xb9\xf0Z\xf2\x80\x00\x00\x00\x03\x00\x00\x00\x0e\x96\x7fE\xb7m\xc5\x1b'
b'\xbe\xa6\xaf\x818Y\xc1\x98\x11\xaac\xab\xaf\xcc\xbf\xc6\xabt\xf3\xba'
b"8P\x00\x00\x00\x02\x00\x00\x00\x11\xb4m2\x00\x94\xf6F'\xd3G\xb6~\x13\xfd"
b'.\xd4\xb2\x06W\xe9\x81\x00\x00\x00\x03\x00\x00\x00\x13\x00\x00\x00\x05\x00'
b'\x00\x00\x82\xbfhM5')
Результат разбора:
'A1': 1348956309,
{'A2': {'B1': 4131792851,
'B2': 18358,
'B3': 9084883250915182167,
'B4': -23,
'B5': -127,
'B6': [{'C1': {'D1': 13205597188817066945,
'D2': [25364, 54130, 8059, 32522]},
'C2': 126,
'C3': 166939403,
'C4': 0.6039949133552678,
'C5': [97, 203]},
'C1': {'D1': 8291261648097202737,
{'D2': [12829, 65016, 37179, 44079]},
'C2': -3,
'C3': 1854024279,
'C4': 0.9889802641333318,
'C5': [50, 72, 203]},
'C1': {'D1': 10844463081854409662,
{'D2': [42671, 33080, 22977, 38929]},
'C2': -86,
'C3': 1672196044,
'C4': -0.17710744763138786,
'C5': [168, 61]}],
'B7': [-76, 109, 50, 0, -108],
'B8': -0.9074280858039856}}
Задача №12
Реализовать разбор двоичного формата данных. Данные начинаются с сигнатуры 0x59 0x4e 0x48
, за которой следует структура A.
Порядок байт: от младшего к старшему. Адреса указаны в виде смещений от начала данных. В решении предлагается использовать модуль
struct.
Структура A:
Поле | Описание |
---|---|
1 | Размер (uint32) и адрес (uint16) массива char |
2 | Адрес (uint16) структуры B |
3 | float |
4 | Массив uint16, размер 4 |
5 | int8 |
6 | uint16 |
Структура B:
Поле | Описание |
---|---|
1 | Размер (uint16) и адрес (uint32) массива структур C |
2 | double |
3 | uint8 |
4 | uint32 |
5 | uint8 |
6 | double |
7 | Адрес (uint16) структуры D |
Структура C:
Поле | Описание |
---|---|
1 | int64 |
2 | uint8 |
3 | int64 |
4 | int16 |
5 | double |
6 | int8 |
7 | int32 |
Структура D:
Поле | Описание |
---|---|
1 | uint8 |
2 | uint64 |
3 | Массив int64, размер 2 |
4 | int32 |
5 | Массив uint64, размер 3 |
6 | uint16 |
Ниже показаны примеры разбора двоичного формата.
Пример 1
Двоичные данные:
b'YNH\x02\x00\x00\x00\x1a\x00\x93\x00\xe3\xb3\x07\xbe\x1f2\xd7\xeej'
(b'\xad\xd6\xbe\xa2]\x16cw\xff\xaf\xee\xe1\x9a\x95r\xe4\xa7\r\x05\x93\x1c\xc7nN'
b'\xa6:\xf9\xfc\xed6\x0c\xc4Z\xee\xbf~|\xc8\x8b\xc1O~vI\xdf\xc8{\x8d'
b'\xd8\xe9\xae\xcb\xb2d\x06=\xf8\x8b\xc1\xccS\xe8\xae7&\xe0\xbf\xc3'
b'\xe3\xfbD\xd2\xb4\xdcW\x84\xcd\x1b\xd5\x99Sg\xa6c\xae\xf8h/\xfb\xaf\x8a<'
b'\xe4\xd8\x84\xc0\x88\\\x1f\xd96\xc8h\xf2\xcd?\xe8\x07\xde\xfa\xfe\xa0'
b')"\x04\xc6\xa9&\xc8c\xeb\x8c.\xa0\x13\x17\xa6\x02\x00\x1c\x00\x00\x00^C\x05'
b'x\xef\xb4\xe6\xbfh\x9c\x83\xd8<2\x9c\xf4\xd6\x0b\x0cN\xd5?\\\x00')
Результат разбора:
'A1': 'cw',
{'A2': {'B1': [{'C1': -1985359993268948993,
'C2': 167,
'C3': -6463106613773138675,
'C4': -1734,
'C5': -0.9485798109594152,
'C6': 126,
'C7': -1047803780},
'C1': -8251781030890537393,
{'C2': 216,
'C3': -559283749157884183,
'C4': -15989,
'C5': -0.504665223709361,
'C6': -61,
'C7': -767231005}],
'B2': -0.7095868438865229,
'B3': 104,
'B4': 1020822428,
'B5': 50,
'B6': 0.3328886142370011,
'B7': {'D1': 180,
'D2': 6024080291973584860,
'D3': [-346943228997294489, -8592722021945931089],
'D4': 920199004,
'D5': [15999011561992775880,
12233469982572347130,
1414181465773819942],
'D6': 42519}},
'A3': -0.13252215087413788,
'A4': [12831, 61143, 44394, 48854],
'A5': -94,
'A6': 5725}
Пример 2
Двоичные данные:
b'YNH\x02\x00\x00\x00\x1a\x00\x93\x00R\xdf\x16?G\x9b<s\xac\xb5\x91@\x86'
(b'\xa8\x05bd\xc5kj\x83V\x7fJ\xb2J5+\x14.\x0eu\xb65\x11\xa7\xf0\xee\xbb\xb4w'
b'\x9e\xcf\xbfE\x84\xc1p\x19\xfa\xf4W\xb3z\xc0j\xb5\xef\xaah\x13\xac\\:<'
b"\xab>\xe5x\xfc+\xa6\xa4\x10\xde?'\xb5M/\xf5si\xb7\x96\xa9\xfc\x05]"
b'\xd8n\x9a\xfa\xa0\x06.j\xd5?\xb4\xa2\xb9T\xedB\xfax \xab\xd6\xbd\xa2G\xb8oNC'
b'\xe1\xc1\xce\xbe\x8b\xbc\n0\xcb\xd72zm\xc4\x1b\x1dp\xe6B\x02\x00\x1c\x00\x00'
b'\x00\xc8\x9e\xc5\xeem\xa3\xc5\xbfwQ\x02/\xe4\xb4\xa0\xbb\xb6I\xc9'
b'\xbc\xd9\xbf\\\x00')
Результат разбора:
'A1': 'bd',
{'A2': {'B1': [{'C1': -5599523177133085755,
'C2': 74,
'C3': 3870409633534585653,
'C4': -22767,
'C5': -0.24702354741008703,
'C6': 69,
'C7': 426819972},
'C1': -5374271572085836550,
{'C2': 239,
'C3': -6107942824922879830,
'C4': -6850,
'C5': 0.46976581790654093,
'C6': 39,
'C7': -181449291}],
'B2': -0.16904997023379154,
'B3': 119,
'B4': 3828286033,
'B5': 180,
'B6': -0.4021476001607258,
'B7': {'D1': 115,
'D2': 15590624067761649513,
'D3': [-3068589590094112146, -413507267617180609],
'D4': -693428104,
'D5': [16231903723713438397,
14641214193496149697,
8078643837036802775],
'D6': 17126}},
'A3': 0.5893450975418091,
'A4': [39751, 29500, 46508, 16529],
'A5': -122,
'A6': 1448}
Задача №12
Реализовать разбор двоичного формата данных. Данные начинаются с сигнатуры 0x6a 0x41 0x42 0x4f
, за которой следует структура
A. Порядок байт: от старшего к младшему. Адреса указаны в виде смещений от начала данных. В решении предлагается использовать модуль
struct.
Структура A:
Поле | Описание |
---|---|
1 | Структура B |
2 | float |
3 | Размер (uint16) и адрес (uint16) массива char |
4 | Структура C |
5 | Адрес (uint32) структуры F |
6 | Размер (uint16) и адрес (uint32) массива uint16 |
7 | int8 |
Структура B:
Поле | Описание |
---|---|
1 | uint64 |
2 | uint16 |
3 | int8 |
4 | int8 |
5 | int16 |
6 | uint64 |
Структура C:
Поле | Описание |
---|---|
1 | Массив структур D, размер 3 |
2 | Адрес (uint16) структуры E |
Структура D:
Поле | Описание |
---|---|
1 | uint64 |
2 | int64 |
3 | double |
4 | uint8 |
5 | int8 |
6 | uint8 |
Структура E:
Поле | Описание |
---|---|
1 | uint8 |
2 | int16 |
Структура F:
Поле | Описание |
---|---|
1 | Размер (uint16) и адрес (uint32) массива uint16 |
2 | int8 |
Ниже показаны примеры разбора двоичного формата.
Пример 1
Двоичные данные:
b'jABOGu5B\xbc\xc6\xd0\xe7\xadg\xfdal\xc0M\xe1t?\x96z\xa4\xef?|=\xf1\x00\x03'
(b'\x00\x80\xf1\x18\xe6\x16\x9f}\x81\xfbT\x8a\xd6\xb9\xc9\xb9$*?\xe7F_\xfc\xb9'
b'*x\xd7\x91\xbdU\xf1\xe6\xf7_\xe0\xe0\xd1\xa4\xad`I\xb3S\xbc\xe7?\xe6\xe5'
b'`\xebY\x13\x14\xc9\x821Kx;CB\xbb\xc6\xa8R\xfa\x1a\xc2\x1e\xff\xd5\x00'
b'?\xef\xc4\xe7\x9fS\x15\xb6\xe6\xa5\xbf\x00\x83\x00\x00\x00\x8a\x00\x08\x00'
b'\x00\x00\x91\xafdrq\xdb\x91\x06{N0\x08\x00\x02\x00\x00\x00\x86q\n\x81\xd1'
b'\xbajt\x8c\x972S\xb0C\xb4\xc7\xf3D')
Результат разбора:
'A1': {'B1': 5149080309719290087,
{'B2': 44391,
'B3': -3,
'B4': 97,
'B5': 27840,
'B6': 5611894427136730351},
'A2': 0.9853201508522034,
'A3': 'drq',
'A4': {'C1': [{'D1': 17372888547421159931,
'D2': 6091917539413664810,
'D3': 0.7273406921388661,
'D4': 215,
'D5': -111,
'D6': 189},
'D1': 6192984912751026385,
{'D2': -6580497610860938009,
'D3': 0.7155003162994,
'D4': 201,
'D5': -126,
'D6': 49},
'D1': 5438161710118323880,
{'D2': 5979120876333815040,
'D3': 0.9927862273986452,
'D4': 230,
'D5': -91,
'D6': 191}],
'C2': {'E1': 219, 'E2': -28410}},
'A5': {'F1': [31566, 12296], 'F2': 113},
'A6': [2689, 53690, 27252, 35991, 12883, 45123, 46279, 62276],
'A7': -81}
Пример 2
Двоичные данные:
b'jABOJ\x98D/\xe6\xb9u\x87\x15\x85\xae8\\\x9a\xc5I1rp\xfc\x02\xcb\xbfN'
(b'\xad\xd5\x00\x03\x00\x80\xb4\xb8K5l\x9bN\xdci803\x87/\x97\xc3?\xec'
b'\x02\xddV\x93\x8c\xf4&\xb7w\xd1\x80P\xdd\x8b\x16pb\xde\xeb\x9f\x1b~\xb3\xec'
b'\xaf?\xe4\x15\xf95:_~\x83\x00\xa2\xa9\x90\xa5\xaaU\x8a\x9a\xac\x87.^v'
b'{\x0e\xa9\x87?\xd0ou\x1a\xbe\x85\xb8\x07\xf3F\x00\x83\x00\x00\x00'
b'\x8a\x00\x08\x00\x00\x00\x91>nae\x92 \xac\x82\xc1\x80g\x00\x02'
b'\x00\x00\x00\x86\xb1\xc7r\xd1\xac\xbf\x99\x04\n){6v\x08\xb1>\xa7')
Результат разбора:
'A1': {'B1': 5375121127791752583,
{'B2': 5509,
'B3': -82,
'B4': 56,
'B5': 23706,
'B6': 14215948066363278027},
'A2': -0.8073399662971497,
'A3': 'nae',
'A4': {'C1': [{'D1': 13022241015369256668,
'D2': 7581862970547738563,
'D3': 0.8753496828980176,
'D4': 38,
'D5': -73,
'D6': 119},
'D1': 15096154863397400674,
{'D2': -2383636637323891537,
'D3': 0.6276823081598051,
'D4': 131,
'D5': 0,
'D6': 162},
'D1': 12218447940054325932,
{'D2': -8705917166696879737,
'D3': 0.25680282222500805,
'D4': 7,
'D5': -13,
'D6': 70}],
'C2': {'E1': 146, 'E2': 8364}},
'A5': {'F1': [33473, 32871], 'F2': -79},
'A6': [51058, 53676, 49049, 1034, 10619, 13942, 2225, 16039],
'A7': 62}
Задача №12
Реализовать разбор двоичного формата данных. Данные начинаются с сигнатуры 0x54 0x49 0x58 0x52
, за которой следует структура
A. Порядок байт: от старшего к младшему. Адреса указаны в виде смещений от начала данных. В решении предлагается использовать модуль
struct.
Структура A:
Поле | Описание |
---|---|
1 | float |
2 | Адрес (uint16) структуры B |
3 | int64 |
4 | uint32 |
5 | Структура C |
6 | float |
7 | int8 |
8 | int16 |
Структура B:
Поле | Описание |
---|---|
1 | Массив char, размер 7 |
2 | uint32 |
3 | int16 |
Структура C:
Поле | Описание |
---|---|
1 | Размер (uint16) и адрес (uint16) массива структур D |
2 | uint8 |
3 | int8 |
4 | Массив int8, размер 5 |
5 | Структура E |
6 | uint64 |
7 | int16 |
Структура D:
Поле | Описание |
---|---|
1 | int32 |
2 | int32 |
Структура E:
Поле | Описание |
---|---|
1 | int32 |
2 | uint16 |
3 | Массив int32, размер 3 |
4 | int64 |
Ниже показаны примеры разбора двоичного формата.
Пример 1
Двоичные данные:
b'TIXR\xbfA\x05\xe7\x00L\xb3\xbd\xfalP\x97\x90\xb4!\x05\xeb\xcf\x00\x03\x00YyV'
(b'C1p\xcf\x8e\x85\x88H\xaa\x1d\n,\x82\xf3A\x18\x8f(\xa0\xa0!&\xc1_/G\xf2\xe0'
b'\xbf\xc7\xa7\xe3B\xce\xff4\xaf\n\xb9\x0bG?y\x9bv\x0eF\xbcplggrcn\x0e'
b'\xc8~K\x83\xa9pZ\x875\xb2\x92M\x0eo\x83}\xec\xc9\xf3rF\xf4\xc6\xa2p\x01D\xca'
b'7')
Результат разбора:
'A1': -0.7539963126182556,
{'A2': {'B1': 'plggrcn', 'B2': 248020555, 'B3': -31831},
'A3': -5494960627206614860,
'A4': 554036175,
'A5': {'C1': [{'D1': 1884981045, 'D2': -1299034866},
'D1': 1870888428, 'D2': -906792378},
{'D1': -188308880, 'D2': 21285431}],
{'C2': 121,
'C3': 86,
'C4': [67, 49, 112, -49, -114],
'C5': {'E1': -2054666070,
'E2': 7434,
'E3': [746779457, 412035232, -1608440127],
'E4': 6858779865986877351},
'C6': 16375878790568413881,
'C7': 2887},
'A6': 0.975028395652771,
'A7': 14,
'A8': 18108}
Пример 2
Двоичные данные:
b'TIXR\xbe\x0eg\xdb\x00L[\xae\xf0I\xf7O\xfdh\xe3He\xc9\x00\x02\x00Y\x08~'
(b'\x14\xd7\xa1\xd9_\xd6-\xa0L\xa23V\x16\x98G\x94\xb6\xa5\xbe\x7fN1\xcd\x17'
b'I\xd7\x8f\\n\x05\\\xa4\xac"\x83\x9a_\xc6\xf0\xfa\x89?\n.\xfb\xab=dzohx'
b'ibu\xcc\xa1\x00\x89\x04e\xc3\xa9\xa1\x1d\t\x9a[\xc2\xf7\x9f \xccz\x83\x9f'
b'\xe6')
Результат разбора:
'A1': -0.13906805217266083,
{'A2': {'B1': 'zohxibu', 'B2': 3433103497, 'B3': 1125},
'A3': 6606481903871589736,
'A4': 3813172681,
'A5': {'C1': [{'D1': -1012293347, 'D2': 161110978},
'D1': -140566324, 'D2': 2055446502}],
{'C2': 8,
'C3': 126,
'C4': [20, -41, -95, -39, 95],
'C5': {'E1': -701652916,
'E2': 41523,
'E3': [1444321351, -1799969346, 2135830989],
'E4': 1678109346903229788},
'C6': 11865897066840442608,
'C7': -1399},
'A6': 0.5397793650627136,
'A7': -85,
'A8': 15716}
Задача №12
Реализовать разбор двоичного формата данных. Данные начинаются с сигнатуры 0x10 0x44 0x4e 0x4d 0x46
, за которой следует
структура A. Порядок байт: от старшего к младшему. Адреса указаны в виде смещений от начала данных. В решении предлагается использовать
модуль struct.
Структура A:
Поле | Описание |
---|---|
1 | Адрес (uint16) структуры B |
2 | Структура D |
3 | Структура E |
4 | uint8 |
5 | Массив char, размер 3 |
6 | Размер (uint32) и адрес (uint16) массива uint16 |
7 | Адрес (uint32) структуры G |
Структура B:
Поле | Описание |
---|---|
1 | int32 |
2 | int64 |
3 | Массив структур C, размер 7 |
Структура C:
Поле | Описание |
---|---|
1 | float |
2 | int16 |
Структура D:
Поле | Описание |
---|---|
1 | uint32 |
2 | int8 |
3 | uint16 |
4 | double |
5 | float |
6 | uint8 |
Структура E:
Поле | Описание |
---|---|
1 | Структура F |
2 | double |
3 | int32 |
4 | uint8 |
5 | int32 |
Структура F:
Поле | Описание |
---|---|
1 | double |
2 | Массив uint8, размер 7 |
Структура G:
Поле | Описание |
---|---|
1 | uint64 |
2 | float |
3 | uint32 |
4 | uint32 |
5 | Массив int8, размер 3 |
6 | float |
Ниже показаны примеры разбора двоичного формата.
Пример 1
Двоичные данные:
b'\x10DNMF\x00IE\x05.\x0b^\xbc\x07\xbf\xe2\xc3Is\xc4\xd0\x8e?\nr\x1f\x02?'
(b'\xcd\x85\xcd\xc3\x0f\x9d\xf0\x88\x90\xb6\xdd\xa6\xb7S\xbf\xe5\x19\x11\xfe-'
b'\x94\xae!\x00\x16\x8dl\xe6\x90\xc1I\xe5qnb\x00\x00\x00\x02\x00'
b'\x7f\x00\x00\x00\x83\xb8YT\xd8\xa8-\xe6\x18\x94\xd0\xf5s=\xf2r'
b'\xdd\xe5\xd8\xbfR\xa6\xc0\xe1n\xbf\x11\x0e\xa8\xe3\xd7?\x1fL\x8fA\xc2>A\xa5'
b'\xd8D\x05\xbf1\x8c\xb5\xd7c?O\x9c\x87}\xda6\xaao\x03\xe4\x82u\x93Lb\xda\xa3?'
b'3jD\xd9\x022\n?jq\xbcF<\x1e?`\xc63')
Результат разбора:
'A1': {'B1': -1202105128,
{'B2': -6328148908135352973,
'B3': [{'C1': 0.11838314682245255, 'C2': -6696},
'C1': -0.8228569030761719, 'C2': -7826},
{'C1': -0.5666298866271973, 'C2': -7209},
{'C1': 0.6222619414329529, 'C2': 16834},
{'C1': 0.189109206199646, 'C2': 17413},
{'C1': -0.6935532689094543, 'C2': -10397},
{'C1': 0.8109821677207947, 'C2': 32218}]},
{'A2': {'D1': 1157967371,
'D2': 94,
'D3': 48135,
'D4': -0.5863387356862562,
'D5': 0.540803849697113,
'D6': 2},
'A3': {'E1': {'F1': 0.230645866627341,
'F2': [136, 144, 182, 221, 166, 183, 83]},
'E2': -0.6593103374877012,
'E3': 553653901,
'E4': 108,
'E5': -426720951},
'A4': 229,
'A5': 'qnb',
'A6': [13994, 28419],
'A7': {'G1': 16465852463122143907,
'G2': 0.7008402347564697,
'G3': 3640799754,
'G4': 1063940540,
'G5': [70, 60, 30],
'G6': 0.8780242800712585}}
Пример 2
Двоичные данные:
b'\x10DNMF\x00I\xa0\x8fb\xb8h,\x05\xbf\xef1,Z\xf5\xc7(?f\xda\xc8\x99\xbf'
(b'\xcf\x0eWr1\x82 )\xaf\xe1\x86f\xb4[?\xea\xf75\x8eF\xfcJ\xcc_\xd3Fh\x05'
b'*\x8e\xb4\x1cmei\x00\x00\x00\x03\x00\x7f\x00\x00\x00\x85\x88UG\xdbb\xdao'
b',C\x92 Q\xbfS\xc7`\xf2\x01>\xab\xcb\xa6\xb7C>\xdf\x0c\xfa\xc0\xb9\xbe'
b'\xdb\xd4\x1c\tG\xbe\xf1\xb7\x01\xf2\xbc=M\x05\xde\x8d\xd1\xbf\n9g\x808\xac'
b'n-\xd9N\xe6\xb3\xb8A\xb5u\xc94+?Z\x10\xcf\xe4\xb1c\x06\x88\xc2\xd3\x0cgxH'
b'?<>n')
Результат разбора:
'A1': {'B1': -2007676965,
{'B2': 7123127996542754897,
'B3': [{'C1': -0.8272609710693359, 'C2': -3583},
'C1': 0.3355380892753601, 'C2': -18621},
{'C1': 0.4356458783149719, 'C2': -16199},
{'C1': -0.42935264110565186, 'C2': 2375},
{'C1': -0.47209933400154114, 'C2': -3396},
{'C1': 0.05005442351102829, 'C2': -29231},
{'C1': -0.5399383902549744, 'C2': -32712}]},
{'A2': {'D1': 2693751480,
'D2': 104,
'D3': 11269,
'D4': -0.9747525955737943,
'D5': 0.9017758369445801,
'D6': 153},
'A3': {'E1': {'F1': -0.24262517047738275,
'F2': [41, 175, 225, 134, 102, 180, 91]},
'E2': 0.8426769045689835,
'E3': -866135226,
'E4': 104,
'E5': 86675124},
'A4': 28,
'A5': 'mei',
'A6': [44142, 11737, 20198],
'A7': {'G1': 12950172976124867627,
'G2': 0.8518189787864685,
'G3': 3836830470,
'G4': 2294469388,
'G5': [103, 120, 72],
'G6': 0.7353276014328003}}
Задача №12
Реализовать разбор двоичного формата данных. Данные начинаются с сигнатуры 0x4f 0x44 0x55 0x4f 0xb6
, за которой следует
структура A. Порядок байт: от старшего к младшему. Адреса указаны в виде смещений от начала данных. В решении предлагается использовать
модуль struct.
Структура A:
Поле | Описание |
---|---|
1 | Адрес (uint16) структуры B |
2 | uint32 |
3 | Размер (uint32) и адрес (uint16) массива структур D |
4 | uint64 |
5 | Массив uint8, размер 7 |
Структура B:
Поле | Описание |
---|---|
1 | uint16 |
2 | int16 |
3 | int8 |
4 | uint32 |
5 | Адрес (uint16) структуры C |
6 | uint8 |
7 | uint64 |
Структура C:
Поле | Описание |
---|---|
1 | Массив char, размер 4 |
2 | int64 |
3 | uint16 |
Структура D:
Поле | Описание |
---|---|
1 | uint16 |
2 | Структура E |
3 | int8 |
Структура E:
Поле | Описание |
---|---|
1 | Размер (uint16) и адрес (uint32) массива uint32 |
2 | uint64 |
Ниже показаны примеры разбора двоичного формата.
Пример 1
Двоичные данные:
b'ODUO\xb6\x00.\xbd\x8dx\xe1\x00\x00\x00\x03\x00ZH\x0f\x98\xe7bC1'
(b'\xb6\xc5\xbc\xe6\xcd\x11\x11\x1cyoax\x9f7\xd24\x07k\x00\x11\xdc\xfa\x075'
b'\x80\xdc?Q\xc7\x1am\x00 \xb80R\x19-/\xed\xe5\xc9!W\xd4\x1a\xba\x03'
b'\x83\xeec\xfd\x9c\x8b]\xdb\xd9\x10\x07\xfdb\xd6\x9b\x91\xffJG\x85'
b'\x00\x02\x00\x00\x00B\xe2\xa8!\xaa \xc0\xc7Glsu\x00\x02\x00\x00\x00J\x18'
b'\xaf\xc9Ax\xba\x00\xbc\xdc\xf1#\x00\x02\x00\x00\x00R\xce\xbf]\xbe'
b'\x17\x9d<\xa9D')
Результат разбора:
'A1': {'B1': 1845,
{'B2': -32548,
'B3': 63,
'B4': 1372002925,
'B5': {'C1': 'yoax', 'C2': -6973874377055338479, 'C3': 56570},
'B6': 184,
'B7': 3481873143779157449},
'A2': 3180165345,
'A3': [{'D1': 18309,
'D2': {'E1': [559404058, 3120792558], 'E2': 16332341063236765511},
'D3': 108},
'D1': 29557,
{'D2': {'E1': [1677565067, 1574689040], 'E2': 1778861660870148284},
'D3': -36},
'D1': 61731,
{'D2': {'E1': [134046422, 2610036554], 'E2': 14897729163386240169},
'D3': 68}],
'A4': 5192537014934909366,
'A5': [197, 188, 230, 205, 17, 17, 28]}
Пример 2
Двоичные данные:
b'ODUO\xb6\x00.\xb5\xf5\xc2\xb6\x00\x00\x00\x02\x00R\x17\xe0\x84'
(b'\xe6\xf8\x12\xfc\xfb\x9b\xa1\x08&\x87\xbc\xb2nzxdKO\xa2\xd1D\xf8\xfa\x9f'
b'\xcfC\\)#\xe9\x9d\xc1\xc5\xbe\x86\x00 \xde\xfc;\x0f\xcf\x19\xd0\xe8<&\xc8'
b'd\x10\xfd\x9b\xeb\xdc\xc4yW\xde|x+\xc9\x0f\xbc\x00\x02\x00\x00\x00B\x170'
b'\xc7\x00\x9e\x03\xb7\xcc\xfb/\xcd\x00\x02\x00\x00\x00JwR\x9c\xb0"9;\x97?')
Результат разбора:
'A1': {'B1': 23593,
{'B2': 9193,
'B3': -99,
'B4': 3250962054,
'B5': {'C1': 'nzxd', 'C2': 5426735095693769375, 'C3': 53059},
'B6': 222,
'B7': 18175138103349536828},
'A2': 3052782262,
'A3': [{'D1': 4028,
'D2': {'E1': [650667024, 4254854108], 'E2': 1671054267219425228},
'D3': -5},
'D1': 12237,
{'D2': {'E1': [3296286686, 2088250313], 'E2': 8598106918906051479},
'D3': 63}],
'A4': 1720521185194867963,
'A5': [155, 161, 8, 38, 135, 188, 178]}
Задача №12
Реализовать разбор двоичного формата данных. Данные начинаются с сигнатуры 0x48 0x56 0x53 0x54
, за которой следует структура
A. Порядок байт: от младшего к старшему. Адреса указаны в виде смещений от начала данных. В решении предлагается использовать модуль
struct.
Структура A:
Поле | Описание |
---|---|
1 | float |
2 | float |
3 | int32 |
4 | int64 |
5 | uint16 |
6 | Адрес (uint32) структуры B |
7 | uint8 |
8 | Адрес (uint32) структуры D |
Структура B:
Поле | Описание |
---|---|
1 | Размер (uint16) и адрес (uint16) массива структур C |
2 | float |
3 | double |
4 | int8 |
5 | uint64 |
6 | Массив char, размер 2 |
Структура C:
Поле | Описание |
---|---|
1 | int32 |
2 | uint16 |
3 | uint8 |
4 | int16 |
5 | int32 |
Структура D:
Поле | Описание |
---|---|
1 | Массив uint16, размер 4 |
2 | uint64 |
3 | int16 |
4 | uint64 |
5 | uint16 |
6 | double |
7 | uint16 |
8 | Массив uint8, размер 7 |
Ниже показаны примеры разбора двоичного формата.
Пример 1
Двоичные данные:
b'HVST\xda7G\xbf\\[\xc3>\xa2\xb6\xe7\x10\xf5%w\x95\x16_,\x0c\x94#W\x00'
(b'\x00\x00\xebr\x00\x00\x00\x92\xa2\xcbG\x0c\x1f\xdaM\xcd\xfc\xd1f8'
b'\xa4\x16\x93\x06h\xd7\x1c\x96\x1a\x18\xb2\xa2\xa9[v\xe8\xa6u\x06\x13'
b'`\xa7u\xaeT\x1f\xd0?\x9a\xee6U\x87\xd8S\xbf\xe1\xdb\x96\x04\x00#\x00\xdd'
b'7]\xbf\xd0\x08\xd4w6\xe2\xd2?\x02\xb6g,?\xf0\x0f\x03\xb9zo\x9f\x02'
b'\xd0\xa4\xf8\x7f\xfaEi88\xe5\xfb\xcf\xcc\xb5\xe5{\xf7lI\xa6t\xa1\xb1\xbc'
b'B9,\x1d=\xdb/\xec\xdb?\xb0\xb6D\xac\t\x16\xa0T\x8b')
Результат разбора:
'A1': -0.7781959772109985,
{'A2': 0.3815563917160034,
'A3': 283621026,
'A4': 877180578031937013,
'A5': 9108,
'A6': {'B1': [{'C1': 1204527762,
'C2': 7948,
'C3': 218,
'C4': -12979,
'C5': 946262524},
'C1': 110302884,
{'C2': 55144,
'C3': 28,
'C4': 6806,
'C5': -1448955368},
'C1': -1494714789,
{'C2': 1653,
'C3': 19,
'C4': -22688,
'C5': 525643381},
'C1': -291881008,
{'C2': 21814,
'C3': 135,
'C4': 21464,
'C5': -1763974721}],
'B2': -0.8641336560249329,
'B3': 0.2950569315145346,
'B4': 2,
'B5': 13331516846473242550,
'B6': 'zo'},
'A7': 235,
'A8': {'D1': [671, 42192, 32760, 17914],
'D2': 13100074096903338089,
'D3': 31717,
'D4': 13596826272386346231,
'D5': 14658,
'D6': 0.4362907067301929,
'D7': 46768,
'D8': [68, 172, 9, 22, 160, 84, 139]}}
Пример 2
Двоичные данные:
b'HVST\x08\xb4%\xbe\x91o\x7f?%\x9eyV\x19\xfd7`\x12\x80\x03\xc5\x1d\xb1J\x00'
(b'\x00\x00\xd7e\x00\x00\x00\xe8\xe2\xebC\xda\x07\x05\xc5\xacQ\x94a\xad'
b'\xdb\xb7\xbc1uW\x8a\xff\xa9\x96\x80\xe4a-\xe9\x03\xf1\x8a*\x04f$\xfex'
b'Fz\x03\x00#\x00\xe8%\x83>`\x8f\x0e%\xb4f\xa9\xbf\xc6\xba\x0e}\xb4Z\x15:\xa1g'
b've\xb4,\xd2X\\\xce\x9f\xc3\xf7\xf3\x1c\x8d\xc5n1\xdc\xb8\xc6\xe0\xa6\xfb\x00'
b'\x98\x90Y\x14K\xa8s8\xc3~8\xef?\xde\xc1e<\xa3\xa0\xc5q,')
Результат разбора:
'A1': -0.16181957721710205,
{'A2': 0.9977961182594299,
'A3': 1450810917,
'A4': -4250412806895567591,
'A5': 45341,
'A6': {'B1': [{'C1': 1139532520,
'C2': 2010,
'C3': 5,
'C4': -21307,
'C5': -1386113967},
'C1': 834451419,
{'C2': 22389,
'C3': 138,
'C4': -22017,
'C5': 1642365078},
'C1': -251401939,
{'C2': 10890,
'C3': 4,
'C4': 9318,
'C5': 2051438846}],
'B2': 0.2561485767364502,
'B3': -0.04961169197420534,
'B4': -58,
'B5': 11617621668074950330,
'B6': 'gv'},
'A7': 215,
'A8': {'D1': [46181, 53804, 23640, 40910],
'D2': 3562001565163452355,
'D3': -18212,
'D4': 6453825396011360454,
'D5': 19220,
'D6': 0.9756463826084785,
'D7': 49630,
'D8': [101, 60, 163, 160, 197, 113, 44]}}
Задача №12
Реализовать разбор двоичного формата данных. Данные начинаются с сигнатуры 0x4c 0x49 0x49
, за которой следует структура A.
Порядок байт: от младшего к старшему. Адреса указаны в виде смещений от начала данных. В решении предлагается использовать модуль
struct.
Структура A:
Поле | Описание |
---|---|
1 | int8 |
2 | uint8 |
3 | Размер (uint16) и адрес (uint16) массива char |
4 | Адрес (uint32) структуры B |
Структура B:
Поле | Описание |
---|---|
1 | int32 |
2 | Размер (uint32) и адрес (uint32) массива структур C |
3 | Адрес (uint32) структуры D |
4 | int16 |
5 | double |
6 | int16 |
7 | Размер (uint32) и адрес (uint16) массива double |
Структура C:
Поле | Описание |
---|---|
1 | Массив uint8, размер 3 |
2 | int16 |
Структура D:
Поле | Описание |
---|---|
1 | Массив double, размер 2 |
2 | uint32 |
3 | int8 |
4 | uint16 |
5 | int8 |
6 | uint8 |
7 | uint16 |
Ниже показаны примеры разбора двоичного формата.
Пример 1
Двоичные данные:
b"LII\x14b\x03\x00\r\x00\\\x00\x00\x00mrf\x159\xde\x05\xf4\x13\xa5'\x9d\x01)@"
(b'\xf1D\xbe\x98\xf2\x9e\xd4\xe5\x8c"\xc6x\x94X[\xf7Bd\xba\xc0\xbf2\x9a\xf7'
b'\xf70\xd5\xec\xbfy\x16"O}\x12\x8f\xfdE\xa2\x97\xeeL\x06\xdb\x08\x9d\xe8?'
b"\xe2\x8a?~\x7f\xf1\xec?\xec1\x8d\xcf\x02'\xd6\xbf5\xfc\xdb\x0f"
b'\x05\x00\x00\x00\x10\x00\x00\x00)\x00\x00\x00\xf8\xaa\xb8\x0c]|\xfd\x18'
b'\xc4?&\xc5\x03\x00\x00\x00D\x00')
Результат разбора:
'A1': 20,
{'A2': 98,
'A3': 'mrf',
'A4': {'B1': 266075189,
'B2': [{'C1': [21, 57, 222], 'C2': -3067},
'C1': [19, 165, 39], 'C2': 413},
{'C1': [41, 64, 241], 'C2': -16828},
{'C1': [152, 242, 158], 'C2': -6700},
{'C1': [140, 34, 198], 'C2': -27528}],
{'B3': {'D1': [-0.13068822164378946, -0.9010243266209896],
'D2': 1327634041,
'D3': 125,
'D4': 36626,
'D5': -3,
'D6': 69,
'D7': 38818},
'B4': -21768,
'B5': 0.15701263973651236,
'B6': -15066,
'B7': [0.7691692617248955, 0.9044797387872132, -0.3461310412283456]}}
Пример 2
Двоичные данные:
b'LII\x13\xfe\x04\x00\r\x00F\x00\x00\x00zpjvtm\x8eM\xdc%\xb1\x9f\xcbr\x96'
(b'\xe5\xb1\xd1\xa6\x97\xe9\xbf\x98-\x88\x86\xa5\xb5\xdd?\xea\xa3\xf0\xc5\x8a'
b'@\xd5\x04p#\x9e\x88r\\ZDb\xdc?\x98_4\x90`(\xe8?`sB^\x02\x00\x00\x00\x11\x00'
b'\x00\x00\x1b\x00\x00\x00R\x1a.F\x13\xbb\x91\x1a\xeb?\x94\x96\x02\x00'
b'\x00\x006\x00')
Результат разбора:
'A1': 19,
{'A2': 254,
'A3': 'zpjv',
'A4': {'B1': 1581413216,
'B2': [{'C1': [116, 109, 142], 'C2': -9139},
'C1': [37, 177, 159], 'C2': 29387}],
{'B3': {'D1': [-0.7997621627429676, 0.4642118276394398],
'D2': 3320882154,
'D3': -118,
'D4': 54592,
'D5': 4,
'D6': 112,
'D7': 40483},
'B4': 6738,
'B5': 0.8469933179678202,
'B6': -26988,
'B7': [0.44349774193123226, 0.7549288574691557]}}