Задача №12
Реализовать разбор двоичного формата данных. Данные начинаются с сигнатуры 0xd 0x58 0x58 0x49 0x59
, за которой следует
структура A. Порядок байт: от старшего к младшему. Адреса указаны в виде смещений от начала данных. В решении предлагается использовать
модуль struct.
Структура A:
Поле | Описание |
---|---|
1 | Структура B |
2 | Размер (uint16) и адрес (uint32) массива uint16 |
3 | int32 |
4 | uint8 |
5 | float |
Структура B:
Поле | Описание |
---|---|
1 | uint16 |
2 | Размер (uint32) и адрес (uint32) массива структур C |
Структура C:
Поле | Описание |
---|---|
1 | uint32 |
2 | Структура D |
3 | Адрес (uint16) структуры E |
Структура D:
Поле | Описание |
---|---|
1 | float |
2 | double |
3 | uint64 |
4 | uint8 |
5 | int64 |
6 | double |
Структура E:
Поле | Описание |
---|---|
1 | Массив int8, размер 8 |
2 | Размер (uint16) и адрес (uint16) массива uint32 |
3 | float |
4 | float |
Ниже показаны примеры разбора двоичного формата.
Пример 1
Двоичные данные:
b"\rXXIYm \x00\x00\x00\x02\x00\x00\x00V\x00\x02\x00\x00\x00\xacR@\xd1'\xc5>\n"
(b'\xd9\xf6D\x05]\xdc\xfb\x1d+\xdc\xb5\xf7\xdah\xe7\xf9\xcd*\x00\x02'
b'\x00\x1e\xbf\x16$s>K\xc0c\xa2\x80\xe8D^\xb21\xa0I\x1c\x7f\xb1\x81\xe4'
b'\xd6\xd2\x00\x02\x00:\xbfL/\xbd\xbe\xbdE7k.\x0bN=\xcf\xd7C?\xec\x982Yr'
b'\x0b\xd2\x1e\xeb3\xe2Z\xa9\xa5\x9f\xce\xea.\xd6\xe6\x01\x12\xbc\xb5?'
b'\xed\x9c\xbc\xb9\xac\x81\xe6\x00&\xbd\x91\xb5\xe1\xbe?|$?\xe4\x14'
b'\x08\xb3\xfb\xf9@Bm~\xfc/\x02\xcd\xfdf\x9c(\xe8\x9e\xd3\x02\xa7k\xbf\xb6'
b'\xb3\x8bM7\xff@\x00B\xaa\x92\x1b~')
Результат разбора:
'A1': {'B1': 27936,
{'B2': [{'C1': 1798179662,
'C2': {'D1': 0.10148479789495468,
'D2': 0.8935786959631236,
'D3': 2227931487941535135,
'D4': 206,
'D5': -1572082936556897099,
'D6': 0.9253829599802514},
'C3': {'E1': [-75, -9, -38, 104, -25, -7, -51, 42],
'E2': [1141202396, 4212992988],
'E3': -0.5864936709403992,
'E4': 0.1989760845899582}},
'C1': 3180443105,
{'C2': {'D1': -0.18699699640274048,
'D2': 0.6274455561940968,
'D3': 4786621600550276605,
'D4': 102,
'D5': -7194244635881724053,
'D6': -0.08867712626669988},
'C3': {'E1': [73, 28, 127, -79, -127, -28, -42, -46],
'E2': [2726357060, 1588736416],
'E3': -0.7976034283638,
'E4': -0.3696686923503876}}]},
'A2': [43666, 7038],
'A3': 1379979559,
'A4': 197,
'A5': 0.1355970799922943}
Пример 2
Двоичные данные:
b'\rXXIY\x1cC\x00\x00\x00\x02\x00\x00\x00Z\x00\x02\x00\x00\x00\xb0*\xbb\x13'
(b'\x8f\x00??\xa7t\xd9\x80O\xa4q\x05\xe7"\x96\xe9r\x13\xa4\xcc\xb5!\x00\x02'
b'\x00\x1e<\x93_R\xbe\np\xd88[Z\xf2\xda\x00C\x00\xe8{\xc6\xa1\xc0\xf4'
b'\\\xa9\x8d\xcf\xa5U\x00\x03\x00:\xbeA\xdf\x84\xbe\xd7\xb32\xa2\xc4'
b'\xb1\x0c\xbd\xee@<\xbf\xed#_\xe2\xc1\xeb\xa0\x0f8!\xa3\xde\xbe\xe0D\x95\xe6'
b"\x97\xe6\x98\xf9\xc4\xbf'?\xd8\x81\xceN4\x01\x84\x00&\x97`\xe1O\xbfgm"
b'l\xbf\xef\x01\x86\xd1\x08\xe1\xac\xbc\xfb\x87u\xfbm\xe2\xf5\x08q\xd3'
b'H\xa7\x89\xdd\x137?\xe0EsJ\xf1,6\x00F\xca\x95\xf7!')
Результат разбора:
'A1': {'B1': 7235,
{'B2': [{'C1': 2730799372,
'C2': {'D1': -0.11633345484733582,
'D2': -0.9105681828362897,
'D3': 1096663496965152836,
'D4': 149,
'D5': -1830741178802979033,
'D6': 0.3829227222159022},
'C3': {'E1': [-106, -23, 114, 19, -92, -52, -75, 33],
'E2': [3649064868, 1896212258],
'E3': 0.017989788204431534,
'E4': -0.13519608974456787}},
'C1': 2539708751,
{'C2': {'D1': -0.9040133953094482,
'D2': -0.968936355849157,
'D3': 13617626839084032757,
'D4': 8,
'D5': 8201979230781510455,
'D6': 0.5084778274261967},
'C3': {'E1': [-64, -12, 92, -87, -115, -49, -91, 85],
'E2': [945511154, 3657450240, 3900425889],
'E3': -0.18932920694351196,
'E4': -0.42128902673721313}}]},
'A2': [51861, 63265],
'A3': 716903311,
'A4': 0,
'A5': 0.7486488819122314}
Задача №12
Реализовать разбор двоичного формата данных. Данные начинаются с сигнатуры 0x55 0x47 0x54 0x55 0xe0
, за которой следует
структура A. Порядок байт: от младшего к старшему. Адреса указаны в виде смещений от начала данных. В решении предлагается использовать
модуль struct.
Структура A:
Поле | Описание |
---|---|
1 | Размер (uint16) и адрес (uint32) массива char |
2 | Адрес (uint16) структуры B |
3 | Массив int32, размер 2 |
4 | uint64 |
5 | double |
6 | uint32 |
7 | Структура D |
Структура B:
Поле | Описание |
---|---|
1 | uint32 |
2 | Размер (uint32) и адрес (uint32) массива адресов (uint32) структур C |
3 | double |
4 | int8 |
5 | int16 |
Структура C:
Поле | Описание |
---|---|
1 | Размер (uint16) и адрес (uint16) массива int8 |
2 | int16 |
Структура D:
Поле | Описание |
---|---|
1 | uint32 |
2 | uint16 |
3 | uint64 |
4 | uint8 |
5 | Размер (uint16) и адрес (uint32) массива float |
Ниже показаны примеры разбора двоичного формата.
Пример 1
Двоичные данные:
b'UGTU\xe0\x03\x00>\x00\x00\x00[\x00\xe6\x02\x02\x94[\x8ej<\xf4a.\x02aq\xe8'
(b'\n@\x14\xfd\xc61M\x9f?\xf6)6)b\xfc\x1e\xcdTHy\xbc\xe9\xd4\xdb\xe5l4\xa1'
b'\x02\x00r\x00\x00\x00uvc\xd4\x8f\xc7\x03\x00A\x00\xeb\x18\x12.v\x03\x00J'
b'\x00\xefrD\x00\x00\x00M\x00\x00\x00\x81\xb8R\xbd\x02\x00\x00\x00S'
b'\x00\x00\x008\x1eL4\x0e\xc1\xd1\xbfqj\x07m |\xbf\xa63\xe5=')
Результат разбора:
'A1': 'uvc',
{'A2': {'B1': 3176315009,
'B2': [{'C1': [-44, -113, -57], 'C2': 6379},
'C1': [18, 46, 118], 'C2': 29423}],
{'B3': -0.2774081717220471,
'B4': 113,
'B5': 1898},
'A3': [-1811807514, 1013616219],
'A4': 786002796438512116,
'A5': 0.03056791092901201,
'A6': 691415542,
'A7': {'D1': 3441359970,
'D2': 18516,
'D3': 3777646919789689977,
'D4': 161,
'D5': [-0.9848697781562805, 0.11191491782665253]}}
Пример 2
Двоичные данные:
b'UGTU\xe0\x04\x00>\x00\x00\x00Z\x00bYb\xce\xb3\x1f\xd4\xc8G\x0fg\x01\xc6$}'
(b"{\x1c\xdf\xbb\xd7f\x1c\xea\xbf\xdeXW\t\xb1\xb3\x16nx\x9d'\xae\xa4\x96\x0e"
b"\xef\xebV\r\x02\x00q\x00\x00\x00rrmr\xa0S\x02\x00B\x00\xcb'\x1dO"
b"\x02\x00J\x00\x19\x1cD\x00\x00\x00L\x00\x00\x00\x87zV'\x02\x00\x00\x00R\x00"
b'\x00\x00\x88\xc5\xe8\xf41,\xcd\xbf\xbd\n\x87\xbd\xb3\n?\x17o^?')
Результат разбора:
'A1': 'rrmr',
{'A2': {'B1': 659978887,
'B2': [{'C1': [-96, 83], 'C2': 10187}, {'C1': [29, 79], 'C2': 7193}],
'B3': -0.22791122873745118,
'B4': -67,
'B5': -30966},
'A3': [-832415390, -925622349],
'A4': 8898308871599624007,
'A5': -0.815967007975789,
'A6': 156719326,
'A7': {'D1': 1846981553,
'D2': 40312,
'D3': 6263362552724762151,
'D4': 13,
'D5': [0.54180508852005, 0.8688825964927673]}}
Задача №12
Реализовать разбор двоичного формата данных. Данные начинаются с сигнатуры 0x4f 0x45 0x58
, за которой следует структура A.
Порядок байт: от старшего к младшему. Адреса указаны в виде смещений от начала данных. В решении предлагается использовать модуль
struct.
Структура A:
Поле | Описание |
---|---|
1 | Структура B |
2 | float |
3 | Адрес (uint32) структуры E |
4 | int16 |
Структура B:
Поле | Описание |
---|---|
1 | float |
2 | uint16 |
3 | uint8 |
4 | int8 |
5 | uint16 |
6 | uint64 |
7 | Размер (uint16) и адрес (uint16) массива структур C |
8 | Массив uint32, размер 7 |
Структура C:
Поле | Описание |
---|---|
1 | int8 |
2 | Адрес (uint16) структуры D |
3 | Массив uint8, размер 4 |
4 | int8 |
Структура D:
Поле | Описание |
---|---|
1 | double |
2 | float |
Структура E:
Поле | Описание |
---|---|
1 | uint16 |
2 | int64 |
3 | float |
4 | uint64 |
5 | uint32 |
6 | Размер (uint32) и адрес (uint32) массива uint32 |
7 | uint64 |
8 | Массив int8, размер 2 |
Ниже показаны примеры разбора двоичного формата.
Пример 1
Двоичные данные:
b'OEX\xbf\\V\xff\xab\xe7\x83\xf4\xccM\x94e\xd5\x0b\x90\xb6\xec5\x00\x02\x00'
(b'Wf|.\x08dL\xb0\xa6=NG^\x9a\x95XOK\x9b\xa2\xbb=\xd1\xce\x94nN\xd2'
b'\xd3>\x9a\xff\xe3\x00\x00\x00{\x1c\x82\xbf\xc1I\xf1\x11\xb2v\xe8=\x9cL\t\xbf'
b'\xef\xec\x93\xd7C\xc4\xae\xbe\x87\xd0\xb0\xd8\x00?\xc3\x836\x0e\x03\x0f'
b'\x00Ka\xcf\xdd\xed\xbc\xd0\xe2j*\xff\x9ai\xe9\xd4\xf6\xc8\xb5\xaa'
b'\xb8\x90\xa6U\x7f\x12\xc4\x99"6\xf0\x8b\x89}\xef\xc4\x17?b<I\\\xdeC'
b'\xf8\x02\x089\xcb+\xf5\xd4\xbb\x00\x00\x00\x05\x00\x00\x00g>\xa5\x95cPw\xd2'
b'.Na')
Результат разбора:
'A1': {'B1': -0.8607024550437927,
{'B2': 44007,
'B3': 131,
'B4': -12,
'B5': 52301,
'B6': 10693187135910374453,
'B7': [{'C1': -40,
'C2': {'D1': -0.13506902088277362, 'D2': 0.07631690055131912},
'C3': [195, 131, 54, 14],
'C4': 3},
'C1': 15,
{'C2': {'D1': -0.9976290897740421, 'D2': -0.26526403427124023},
'C3': [97, 207, 221, 237],
'C4': -68}],
'B8': [1719414280,
1682747558,
1028540254,
2593478735,
1268490939,
1037160084,
1850659539]},
'A2': 0.30273351073265076,
'A3': {'E1': 39202,
'E2': 3958817495098311703,
'E3': 0.8837323784828186,
'E4': 6691860828784179659,
'E5': 737531067,
'E6': [3504499242, 4288309737, 3572943029, 2864222374, 1434391236],
'E7': 4514178455293121070,
'E8': [78, 97]},
'A4': 7298}
Пример 2
Двоичные данные:
b'OEX>et\x8c\x95$\xe4\x0cf\x0eM\x90\x15\x87\xe4\x9d\xea\x94\x00\x02\x00'
(b'W\xa0\xe0\xc0\xcfLk\xd1\xe37\xf6,\x1f\\\xac\xfcK\xb4\x0c\x92\x19x\xbe\x03'
b'_\xbd}\xa2\xf2\xber[\xc2\x00\x00\x00o]X?\xddh$B\xf5r\x9c\xbb\xf0a\xb1\xbf'
b'\xe09\x14\xb0,\x9f\xae>\x87B@m\x00?6\xc7\x80#t\xf5\x00K4\xeb\x93\xc8\x04\xc3'
b'\xd5-\x1a\xba\xc3^\xc0.Z\xe0\xfdp[\xf5\xc8%\xc1\xbf`\xd5mg\x8f\x84'
b'\x14\xaf\xfc\x16\x1a\x9d\xf5\xa4\xc4\x00\x00\x00\x02\x00\x00\x00gSE`'
b'\x1eW\xbfT\xccKC')
Результат разбора:
'A1': {'B1': 0.22407740354537964,
{'B2': 38180,
'B3': 228,
'B4': 12,
'B5': 26126,
'B6': 5588990810967108244,
'B7': [{'C1': 109,
'C2': {'D1': 0.4594813016790711, 'D2': -0.007335864473134279},
'C3': [54, 199, 128, 35],
'C4': 116},
'C1': -11,
{'C2': {'D1': -0.5069678727058908, 'D2': 0.2641773223876953},
'C3': [52, 235, 147, 200],
'C4': 4}],
'B8': [2699083983,
1282134499,
938880031,
1554840651,
3020722713,
2025718623,
3179127538]},
'A2': -0.23667815327644348,
'A3': {'E1': 11866,
'E2': -2234506299838028351,
'E3': -0.878256618976593,
'E4': 7462328331962947098,
'E5': 2650121412,
'E6': [3285527834, 3133365952],
'E7': 6000307761978496204,
'E8': [75, 67]},
'A4': 23896}
Задача №12
Реализовать разбор двоичного формата данных. Данные начинаются с сигнатуры 0xeb 0x54 0x56 0x4f
, за которой следует структура
A. Порядок байт: от младшего к старшему. Адреса указаны в виде смещений от начала данных. В решении предлагается использовать модуль
struct.
Структура A:
Поле | Описание |
---|---|
1 | Структура B |
2 | float |
3 | Размер (uint32) и адрес (uint32) массива char |
4 | Размер (uint32) и адрес (uint16) массива uint8 |
5 | uint32 |
Структура B:
Поле | Описание |
---|---|
1 | float |
2 | int32 |
3 | int8 |
4 | Структура C |
Структура C:
Поле | Описание |
---|---|
1 | uint64 |
2 | Структура D |
3 | Массив адресов (uint32) структур E, размер 2 |
Структура D:
Поле | Описание |
---|---|
1 | float |
2 | uint16 |
Структура E:
Поле | Описание |
---|---|
1 | int8 |
2 | float |
3 | Массив uint8, размер 6 |
4 | float |
Ниже показаны примеры разбора двоичного формата.
Пример 1
Двоичные данные:
b'\xebTVO\x9a\x15N>\x0e\x89\xa8\x90\x93\xabMA~\x0eN[\xe2\xdfzd>\x9d$9'
(b'\x00\x00\x00H\x00\x00\x00O\xf7\xc6\xbe\x02\x00\x00\x00W\x00\x00\x00\x05'
b'\x00\x00\x00Y\x00\xe8k\xe77\xb1\x94\x88\xb9>5.\xf0\xb8\xdf\xdeg\xecI>'
b'\x85mY\r\xbe\x85|#\xf2Kp^7!?xwgc\xcf;y')
Результат разбора:
'A1': {'B1': 0.20125427842140198,
{'B2': -1868003058,
'B3': -109,
'B4': {'C1': 16310716299607100843,
'C2': {'D1': 0.22312496602535248, 'D2': 9373},
'C3': [{'E1': -79,
'E2': 0.3623701333999634,
'E3': [53, 46, 240, 184, 223, 222],
'E4': 0.19719086587429047},
'E1': -123,
{'E2': -0.13803644478321075,
'E3': [133, 124, 35, 242, 75, 112],
'E4': 0.6297510862350464}]}},
'A2': -0.3886055648326874,
'A3': 'xw',
'A4': [103, 99, 207, 59, 121],
'A5': 937913320}
Пример 2
Двоичные данные:
b'\xebTVOL\xc3\\\xbf\x16\x13\x0e\xcd\x11\xbd\x8a\x1b\x1c\xbd\xeet'
(b'\n\x9a\xfb\x81>\x1a\x0b9\x00\x00\x00H\x00\x00\x0087s\xbf\x02\x00\x00\x00W'
b'\x00\x00\x00\x07\x00\x00\x00Y\x00\xa8\xfaEP\x9d\xd2-X\xbf)\xd8\x85\xbbs\xd1'
b'\xa1|\x06>B\x1bh>?\xff\x16X\x7f\x97\x8b-\xd3\xa4=phK\x8cg\xa0\x01\x17\x8f')
Результат разбора:
'A1': {'B1': -0.8623549938201904,
{'B2': -854715626,
'B3': 17,
'B4': {'C1': 753489533665512125,
'C2': {'D1': 0.25387269258499146, 'D2': 2842},
'C3': [{'E1': -99,
'E2': -0.8444491624832153,
'E3': [41, 216, 133, 187, 115, 209],
'E4': 0.1313347965478897},
'E1': 66,
{'E2': 0.7437760233879089,
'E3': [255, 22, 88, 127, 151, 139],
'E4': 0.0804809108376503}]}},
'A2': -0.9500613212585449,
'A3': 'ph',
'A4': [75, 140, 103, 160, 1, 23, 143],
'A5': 1346763432}
Задача №12
Реализовать разбор двоичного формата данных. Данные начинаются с сигнатуры 0xc5 0x4b 0x53 0x57
, за которой следует структура
A. Порядок байт: от старшего к младшему. Адреса указаны в виде смещений от начала данных. В решении предлагается использовать модуль
struct.
Структура A:
Поле | Описание |
---|---|
1 | float |
2 | Структура B |
Структура B:
Поле | Описание |
---|---|
1 | uint64 |
2 | int8 |
3 | Размер (uint16) и адрес (uint16) массива char |
4 | double |
5 | Массив адресов (uint32) структур C, размер 5 |
6 | Структура D |
7 | uint64 |
Структура C:
Поле | Описание |
---|---|
1 | int32 |
2 | uint16 |
Структура D:
Поле | Описание |
---|---|
1 | int64 |
2 | Массив uint64, размер 5 |
3 | int8 |
4 | uint8 |
5 | int32 |
6 | Массив uint16, размер 7 |
7 | uint64 |
Ниже показаны примеры разбора двоичного формата.
Пример 1
Двоичные данные:
b'\xc5KSW>\xa4\xbf\x89\x98}%\xe7\xd5\xa30V(\x00\x03\x00\x85\xbf\xc7\xc9'
(b'\x90h\x004\x80\x00\x00\x00\x88\x00\x00\x00\x8e\x00\x00\x00\x94\x00\x00\x00'
b'\x9a\x00\x00\x00\xa0\x10a:<\x1a\x19\x81+\n0\xb8}E\xaf\x18\x8a /\xb3'
b'\x81\xbbtbcMl9\xd0\x9e\xf5b\xe2\xc0\x18\x06\x1bzt\x83\xe3\x96R\xd2'
b'\x95\x94\xf22\x8d\x19z\xc3\xd7"\xcbTM\xbc">\r\x06}\x0cw\xecxx\x0f\xf1\xcfI'
b'ZZQ\xb4\xf8\x0c\xdao\xbf\x8e\xdb\xcc\xcfhfo4\xb5[s\xf1\\\xd6\xfe'
b'\x88\x1b\x8c\xa7\xd8\xda\xc0I\x8a\x16\xfc*O\x03c@:/\xc4}\xae3')
Результат разбора:
'A1': 0.32177379727363586,
{'A2': {'B1': 10987980343505793110,
'B2': 40,
'B3': 'hfo',
'B4': -0.18583874776996723,
'B5': [{'C1': 884300659, 'C2': 61788},
'C1': -687962085, 'C2': 36007},
{'C1': -656752567, 'C2': 35350},
{'C1': -64336125, 'C2': 25408},
{'C1': 976209021, 'C2': 44595}],
{'B6': {'D1': 1180288607158108459,
'D2': [734289587440916618,
2319269702896214627,
5578897606588064482,
13841820169811559395,
10831951593670324877],
'D3': 25,
'D4': 122,
'D5': -1009311029,
'D6': [21581, 48162, 15885, 1661, 3191, 60536, 30735],
'D7': 17424226135730926840},
'B7': 926175541904264399}}
Пример 2
Двоичные данные:
b'\xc5KSW>\x9c\rr\xa9\xd8Id4\x1a*q{\x00\x02\x00\x85\xbf\xe6\xc2\x14o\xcbj'
(b'P\x00\x00\x00\x87\x00\x00\x00\x8d\x00\x00\x00\x93\x00\x00\x00'
b'\x99\x00\x00\x00\x9f\xc1\xbd\x8b\xf9<\x93`K\xe3\x1c[[=\x7f\x9e\xe3\xf8\xa9Q'
b'p\xbe\xde\x19\xaf\x81\x87s\x9e8\xb1]\xf8!\x1d\x95\r~\x1bQVyu\xbbq9\x97,'
b"\x0f4\xfc\x02p\xe0\x8d\x9c\xb2'\xf6\xba(K\x01\x93:S\xd7\x85VN\xe5tM\xe5\x9fy"
b'\x1a\xd9\x84\x1b\x82\xa76\x9a\xa0mb,\xe8\xdf!\xaa\xcc\xe0L\x02\x90!\x9f\xc0'
b'\xadK\x8e\x91.\xcb\xe8~\xc0\x80\x849@1ew\x92')
Результат разбора:
'A1': 0.30479007959365845,
{'A2': {'B1': 12238612682099010161,
'B2': 123,
'B3': 'mb',
'B4': -0.7111913856018166,
'B5': [{'C1': 753458977, 'C2': 43724},
'C1': -531889520, 'C2': 8607},
{'C1': -1062384754, 'C2': 37166},
{'C1': -873955648, 'C2': 32900},
{'C1': 960508261, 'C2': 30610}],
{'B6': {'D1': -4486275751211737013,
'D2': [16365055593389465315,
17917942137150642607,
9333555876141817336,
2386227262759063894,
8752107545836334095],
'D3': 52,
'D4': 252,
'D5': 40951949,
'D6': [40114, 10230, 47656, 19201, 37690, 21463, 34134],
'D7': 5685077982538856730},
'B7': 15673682851121240736}}
Задача №12
Реализовать разбор двоичного формата данных. Данные начинаются с сигнатуры 0x46 0x51 0x52 0x55
, за которой следует структура
A. Порядок байт: от старшего к младшему. Адреса указаны в виде смещений от начала данных. В решении предлагается использовать модуль
struct.
Структура A:
Поле | Описание |
---|---|
1 | float |
2 | Массив структур B, размер 2 |
3 | Структура C |
4 | double |
5 | Размер (uint16) и адрес (uint32) массива int32 |
Структура B:
Поле | Описание |
---|---|
1 | uint8 |
2 | uint8 |
Структура C:
Поле | Описание |
---|---|
1 | double |
2 | int16 |
3 | Адрес (uint32) структуры D |
4 | uint64 |
5 | Массив int64, размер 6 |
6 | uint32 |
Структура D:
Поле | Описание |
---|---|
1 | Массив uint16, размер 6 |
2 | int16 |
3 | Массив uint8, размер 5 |
4 | Структура E |
Структура E:
Поле | Описание |
---|---|
1 | float |
2 | float |
3 | double |
Ниже показаны примеры разбора двоичного формата.
Пример 1
Двоичные данные:
b'FQRU?\x06\nO\xaf\xdf\x08M\xbf\x9d\xf7V)>"\xc0\xb2\x0e\x00\x00\x00d\\#r\x9dUJ'
(b'\xbc\r\xd5o1\xf2\x95\x8d\xd3\xedB^?\xe4\x8c,7\xee-\xf2*\xfb\x87Q'
b'\x8d{\xdf\xab;\xd4\xba}t\xf1\xb6\x12H\x025\xd5\x83\xcf\x93e\xa4\x8d\xc4\x03'
b'\xd0\xd8k\xc6\xd9-?\xeclja\x85\xd7\xf8\x00\x02\x00\x00\x00\x87'
b'\x92\x1f\xb0\x07\xb6\xe1\x98{w\x89\xf5\x86\xa2\xbc\xedf\x05\x8eb?'
b'\x1c\xca\xd2\xbf,\xfd\xbd?\xed\xb9\x00}\xc2\xca\x18\x98\xdb&\xabC\xc2\n\xa7')
Результат разбора:
'A1': 0.5235947966575623,
{'A2': [{'B1': 175, 'B2': 223}, {'B1': 8, 'B2': 77}],
'A3': {'C1': -0.029263826625114175,
'C2': -19954,
'C3': {'D1': [37407, 45063, 46817, 39035, 30601, 62854],
'D2': -23876,
'D3': [237, 102, 5, 142, 98],
'D4': {'E1': 0.6124697923660278,
'E2': -0.675746738910675,
'E3': 0.9288332420604233}},
'C4': 6639276295740636173,
'C5': [-3067177903255071763,
4782330105150846958,
3310755935866162555,
-2329702597386210063,
-5327116234895555633,
-7825667848700440360],
'C6': 1808193837},
'A4': 0.8882343201391896,
'A5': [-1730468181, 1136790183]}
Пример 2
Двоичные данные:
b'FQRU?Z9\xc6tQ\xae\xc1\xbf\xb7\x1f\xd2wL\xba\xc0o\x03\x00\x00\x00dK\xfd'
(b'U<\x8c\xa0\xb9D$\xee\xa7\xd4\xe5\xa1\xac\xf9\x8e|]\x81\xfb6"my\xe6'
b'\xac\xdb\xa8\xb6\\\x18\xdc\x84)\xf8\xcf-l{\xb2\xca\xd8\x88Ur\xc4\xf3\xd0h'
b'\x1d\xeb\x93\r\xef\xb2\x85\x95\x92g\xbf\xea\xe2\xf9/\x8b\xf1\xc6\x00\x04'
b'\x00\x00\x00\x87\xadR\x110\x7f\x88\x91\xa3?\x19\xefSz2de\x1e\x1b\xbd?'
b'\x18{\xb1?|a\xde?\xc7b\xa6\xbbHG\xb0\xa3\x80\xd7\xb9d\xf5\x7fq\xb5'
b'\xb3\xfa\x1bX\x9d\xa2-')
Результат разбора:
'A1': 0.852444052696228,
{'A2': [{'B1': 116, 'B2': 81}, {'B1': 174, 'B2': 193}],
'A3': {'C1': -0.090329317212972,
'C2': 28419,
'C3': {'D1': [44370, 4400, 32648, 37283, 16153, 61267],
'D2': 31282,
'D3': [100, 101, 30, 27, 189],
'D4': {'E1': 0.5956373810768127,
'E2': 0.9858683347702026,
'E3': 0.18269809860845276}},
'C4': 5475626440498133316,
'C5': [2661248962650025209,
-8179560010364870035,
8783898182661069848,
-2556872539835110277,
-5563396309602089741,
-3429458218620948558],
'C6': 2241172071},
'A4': -0.8402067116399443,
'A5': [-1551837255, 1693810545, -1246496229, 1486725677]}
Задача №12
Реализовать разбор двоичного формата данных. Данные начинаются с сигнатуры 0x47 0x41 0x55
, за которой следует структура A.
Порядок байт: от младшего к старшему. Адреса указаны в виде смещений от начала данных. В решении предлагается использовать модуль
struct.
Структура A:
Поле | Описание |
---|---|
1 | double |
2 | Размер (uint16) и адрес (uint32) массива структур B |
3 | Адрес (uint32) структуры C |
4 | int8 |
5 | Массив char, размер 3 |
6 | Массив uint8, размер 3 |
7 | Структура D |
Структура B:
Поле | Описание |
---|---|
1 | float |
2 | float |
Структура C:
Поле | Описание |
---|---|
1 | float |
2 | Массив char, размер 4 |
3 | int8 |
4 | int16 |
5 | uint16 |
6 | int16 |
Структура D:
Поле | Описание |
---|---|
1 | Массив double, размер 2 |
2 | float |
3 | uint16 |
Ниже показаны примеры разбора двоичного формата.
Пример 1
Двоичные данные:
b'GAU46a\x8aB\xb8\xe7?\x03\x002\x00\x00\x00J\x00\x00\x00\xc0osbZ\x98C'
(b'\xa8\\H\xb0[\x05\xc3?(TFSsA\xeb?(\xd7o\xbejN\xa4\xf5H?\xf8\xc6\x9e\xbe\xd4q'
b'\x0c\xbf\xd8\x12\x17>:4X?-\xfb\x1c\xbf6\x1a\x0b\xbfvbkeI\xa5l\xaa\x066\x82')
Результат разбора:
'A1': 0.7412426665047804,
{'A2': [{'B1': 0.7849981784820557, 'B2': -0.31011176109313965},
'B1': -0.5486118793487549, 'B2': 0.14753282070159912},
{'B1': 0.844546914100647, 'B2': -0.6132076382637024}],
{'A3': {'C1': -0.5433686971664429,
'C2': 'vbke',
'C3': 73,
'C4': 27813,
'C5': 1706,
'C6': -32202},
'A4': -64,
'A5': 'osb',
'A6': [90, 152, 67],
'A7': {'D1': [0.1486010180239863, 0.8517395616969496],
'D2': -0.23421919345855713,
'D3': 20074}}
Пример 2
Двоичные данные:
b'GAU \xf9>L\xb8F\xe2\xbf\x02\x002\x00\x00\x00B\x00\x00\x00\xb2iyy\xc0\x8a\x1d'
(b'"\xcf\x05\xae\x07w\xe3\xbf8\x8ew(\x8c*\xc7?L\xf2\xb3\xbe-\x13\x12(>?^\xb7'
b'r\xbf\xd3\x81q\xbf\xf7!+\xbee\xdf\x82>pectt\xd5\xe1\x83\x18>;')
Результат разбора:
'A1': -0.5711328019313306,
{'A2': [{'B1': 0.742798924446106, 'B2': -0.9481104612350464},
'B1': -0.9433872103691101, 'B2': -0.1671217530965805}],
{'A3': {'C1': 0.2556106150150299,
'C2': 'pect',
'C3': 116,
'C4': -7723,
'C5': 6275,
'C6': 15166},
'A4': -78,
'A5': 'iyy',
'A6': [192, 138, 29],
'A7': {'D1': [-0.6082800291901302, 0.18098594642570887],
'D2': -0.35145795345306396,
'D3': 4909}}
Задача №12
Реализовать разбор двоичного формата данных. Данные начинаются с сигнатуры 0xba 0x4e 0x45 0x44
, за которой следует структура
A. Порядок байт: от старшего к младшему. Адреса указаны в виде смещений от начала данных. В решении предлагается использовать модуль
struct.
Структура A:
Поле | Описание |
---|---|
1 | double |
2 | int64 |
3 | Структура B |
4 | int16 |
5 | uint64 |
Структура B:
Поле | Описание |
---|---|
1 | uint32 |
2 | Адрес (uint32) структуры C |
Структура C:
Поле | Описание |
---|---|
1 | Массив адресов (uint32) структур D, размер 3 |
2 | int8 |
3 | Массив uint8, размер 2 |
4 | uint64 |
Структура D:
Поле | Описание |
---|---|
1 | int8 |
2 | int8 |
3 | Массив double, размер 2 |
4 | Массив uint16, размер 7 |
Ниже показаны примеры разбора двоичного формата.
Пример 1
Двоичные данные:
b'\xbaNED?\xe0\x96\x9d\xb4W\xb4\xf4\xbcZ\x1a\x94XC\x89\xf6\xfc8<\x96'
(b'\x00\x00\x00\x86\xea\x9c\xc0xb\x08y$\x84c\xf0\x0b\xbf\xe1\x05`\x0b4\xbe\xe8'
b'\xbf\xe2P\xcd\xb6&ft~/\xa2\x8d\xc2\xa6\x07\xf4~h\x80\xb2`\xca\xbdc?\xe6R\xf3'
b'\x9a\xe2WB\xbf\xe6)C5Q\xae\xe2\x92\xbe\x19\xd0\x18\xe8\x1e\xeey6\xa1\x9c'
b'\xc0\xd6x\x18\xbf\xd4y>6\xcf&\xbc\xbf\xe3\xfd=I\xf2\x92tU\xda\xf5\xde'
b'v`\x05\xa27\x9a\xf1\xd71/\x00\x00\x00&\x00\x00\x00F\x00\x00\x00f\xa2\x8f'
b'\xa4<\\\xf5v\x8d\xe8~4')
Результат разбора:
'A1': 0.5183857462231161,
{'A2': -4874554422236837386,
'A3': {'B1': 4231543958,
'B2': {'C1': [{'D1': -16,
'D2': 11,
'D3': [-0.5319061488025598, -0.5723637158982471],
'D4': [32303, 41613, 49830, 2036, 32360, 32946, 24778]},
'D1': -67,
{'D2': 99,
'D3': [0.6976259255486428, -0.6925369302166156],
'D4': [37566, 6608, 6376, 7918, 31030, 41372, 49366]},
'D1': 120,
{'D2': 24,
'D3': [-0.3199000869031854, -0.6246630138671905],
'D4': [21978, 62942, 30304, 1442, 14234, 61911, 12591]}],
'C2': -94,
'C3': [143, 164],
'C4': 4349621229668826676}},
'A4': -5476,
'A5': 13868942841019139171}
Пример 2
Двоичные данные:
b"\xbaNED\xbf\xea$\x02'\xc9\x88\xa6\x905*\x8dp)\x89gQ\x13<\xf1\x00\x00\x00\x86"
(b'\xcb\xf6\xd8\xd0\xd1\xbf\x87\xe0\x15\xbb0\xfa\xbf\xb1\x00\x02\x17\x8f\x1bP'
b'?\xeeI\xcdC8\xdb\x18V%\x8a\x18\x1e\x9d\x8fl\xf6H$\x96\xc5\xd8l]?\xdd\xeek'
b'\x15\x8b\xf5\xac\xbf\xd5e\xc9f.[\x90\xd5\x14\xf1\xf7F\xbd\xd1\xc7A\xd8h7'
b'\x1c\xa4\x04g?\xec\x0b\xc6/cG\x86?\xe55\xe0\x99E\xe30f\x87\xd8[\xfa\x08)%'
b'\xccC\x8f(\xd6b\x00\x00\x00&\x00\x00\x00F\x00\x00\x00fQ\xbb\xa2I\x1aN'
b'\xef\x88\x01\x0c\xbb')
Результат разбора:
'A1': -0.8168955590338285,
{'A2': -8055485571521738393,
'A3': {'B1': 1360215281,
'B2': {'C1': [{'D1': 48,
'D2': -6,
'D3': [-0.06640637469454913, 0.9465090096408373],
'D4': [22053, 35352, 7837, 36716, 63048, 9366, 50648]},
'D1': 108,
{'D2': 93,
'D3': [0.4676768980424082, -0.33433756807920023],
'D4': [54548, 61943, 18109, 53703, 16856, 26679, 7332]},
'D1': 4,
{'D2': 103,
'D3': [0.8764372754614989, 0.6628268235791435],
'D4': [26247,
55387,
64008,
10533,
52291,
36648,
54882]}],
'C2': 81,
'C3': [187, 162],
'C4': 5267609504849136827}},
'A4': -13322,
'A5': 15623217727896819131}
Задача №12
Реализовать разбор двоичного формата данных. Данные начинаются с сигнатуры 0x4c 0x4a 0x48
, за которой следует структура A.
Порядок байт: от старшего к младшему. Адреса указаны в виде смещений от начала данных. В решении предлагается использовать модуль
struct.
Структура A:
Поле | Описание |
---|---|
1 | uint32 |
2 | Размер (uint32) и адрес (uint32) массива char |
3 | Адрес (uint16) структуры B |
4 | uint16 |
5 | Массив адресов (uint16) структур E, размер 2 |
6 | Размер (uint32) и адрес (uint32) массива double |
7 | uint32 |
Структура B:
Поле | Описание |
---|---|
1 | Структура C |
2 | Структура D |
3 | int32 |
4 | int16 |
Структура C:
Поле | Описание |
---|---|
1 | int32 |
2 | uint8 |
Структура D:
Поле | Описание |
---|---|
1 | int16 |
2 | Размер (uint32) и адрес (uint32) массива uint64 |
3 | uint16 |
4 | uint64 |
Структура E:
Поле | Описание |
---|---|
1 | uint32 |
2 | uint64 |
Ниже показаны примеры разбора двоичного формата.
Пример 1
Двоичные данные:
b'LJH\xce\xe7\xba\x08\x00\x00\x00\x05\x00\x00\x00#\x008\xc4\x8f\x00W\x00c\x00'
(b'\x00\x00\x02\x00\x00\x00ox\x829\xe3ekuakf\x00\x07\xcat\xb7\xc0\xd0\xe0B|g'
b')\xe5\x02\xdaSb\x7f\x80\xfc\x8fu\x00\x00\x00\x02\x00\x00\x00(0\xb4\xf8s\xed'
b"p\x1d4s\xf2@\x18Zg\xbf\xcf\x90\xe9\x81\xe6\xed\x1dX\xad\x1d'\xdf\xb7\xb0"
b'4i\xd34\x0b\xf9\r\xf6\xd7r\r\xbf\xc1$-\xba;$\xb0\xbf\xe0\xc1\xfeGW\x8f&')
Результат разбора:
'A1': 3471292936,
{'A2': 'ekuak',
'A3': {'B1': {'C1': 1398964096, 'C2': 252},
'B2': {'D1': -28811,
'D2': [7349883157991637200, 16159615195485111002],
'D3': 12468,
'D4': 17902914009509950450},
'B3': 1075337831,
'B4': -16433},
'A4': 50319,
'A5': [{'E1': 2431222246, 'E2': 17085910061855268791},
'E1': 2956224979, 'E2': 3750364953087275533}],
{'A6': [-0.13391658395111028, -0.523680819835566],
'A7': 2021800419}
Пример 2
Двоичные данные:
b'LJH\xbf"\x12@\x00\x00\x00\x03\x00\x00\x00#\x006\xe7\xef\x00U\x00a\x00'
(b'\x00\x00\x05\x00\x00\x00m\xd6/r\x90cmv\xd6f\xfaE[f\xb3\xd1#u\xabQ\xf9\x89'
b"\xfb\xfcb\x99TkJ\x9d'\x00\x00\x00\x02\x00\x00\x00&!\xfc\xcd%\xf0\xa9\x07"
b'zG^\x07}\xd8m\xe7\xc3\xc6\xda\xee\xfd\x17<\x90\x8d[x\xc77gF&\x02\xd2\xc8w'
b'\xc7j\xa9\xe1\xca\xbf\xcb\xe3\x0e\x84\xbbc \xbf\xb5$\xaf\xdbb\\'
b"\x10\xbf\xe2\xae\x01\xda\x97~,\xbf\xdc'\x9d6\xfa\xa2\xcc\xbf\xe2\xcf"
b'1\x81\x7f{4')
Результат разбора:
'A1': 3206681152,
{'A2': 'cmv',
'A3': {'B1': {'C1': 1654215787, 'C2': 74},
'B2': {'D1': -25305,
'D2': [15449310747534210001, 2555136732169894908],
'D3': 8700,
'D4': 14782485960679114590},
'B3': 125687917,
'B4': -6205},
'A4': 59375,
'A5': [{'E1': 3336236797, 'E2': 1674372098274412343},
'E1': 1732650498, 'E2': 15188521441678713290}],
{'A6': [-0.21786672097257398,
-0.0825910482984542,
-0.5837411183710564,
-0.43991785401389616,
-0.5877921609170245],
'A7': 3593433744}
Задача №12
Реализовать разбор двоичного формата данных. Данные начинаются с сигнатуры 0x5a 0x54 0x45
, за которой следует структура A.
Порядок байт: от старшего к младшему. Адреса указаны в виде смещений от начала данных. В решении предлагается использовать модуль
struct.
Структура A:
Поле | Описание |
---|---|
1 | Размер (uint16) и адрес (uint32) массива адресов (uint32) структур B |
2 | uint8 |
3 | Адрес (uint32) структуры C |
4 | Адрес (uint32) структуры F |
5 | int64 |
6 | double |
7 | uint16 |
8 | int32 |
Структура B:
Поле | Описание |
---|---|
1 | uint8 |
2 | uint16 |
3 | uint16 |
Структура C:
Поле | Описание |
---|---|
1 | Размер (uint32) и адрес (uint16) массива char |
2 | int64 |
3 | Адрес (uint32) структуры D |
4 | Размер (uint16) и адрес (uint16) массива uint32 |
5 | int16 |
6 | Структура E |
Структура D:
Поле | Описание |
---|---|
1 | int8 |
2 | int32 |
3 | int32 |
4 | int64 |
5 | uint16 |
6 | int64 |
Структура E:
Поле | Описание |
---|---|
1 | int32 |
2 | int16 |
Структура F:
Поле | Описание |
---|---|
1 | int32 |
2 | Массив uint32, размер 2 |
3 | uint16 |
4 | double |
5 | double |
6 | uint8 |
7 | double |
8 | int8 |
Ниже показаны примеры разбора двоичного формата.
Пример 1
Двоичные данные:
b'ZTE\x00\x03\x00\x00\x007\x1f\x00\x00\x00h\x00\x00\x00\x86\x89~n\xff\xf3\xb5'
(b'\x0f\xc1\xbf\xe2VF\xfe \xcb\xb0\xea5\x01{2\xbc\xeaWK\xccf\xfb\x85\xe3'
b'\xf5\x95\xc9\xf5\x8a\x852\x00\x00\x00(\x00\x00\x00-\x00\x00\x002mr\xbb\x9c5'
b"\xd4\xae:\x0ei\xc8M'\xb0\xe7\xe7\x96 \xee0\x1a1\xfb\xd7\xa4\xe6\xdf\xd4("
b"'\xc4\xa2\xceH(qX\x00\x00\x00\x02\x00C\x83\xc6(\xb6\x19\xd1#\x7f\x00\x00"
b'\x00E\x00\x02\x00`k{tB\xe6\x9e^\xf8\x9f\xc0\xc4\xdf\x94_\x83SFP\xbf\xdd_L'
b'\xbf\xeb\x87\xb7B \x10\x8a?\xe2\xc8\x92\x02\xad(\x9c\xc8\xbf\xd7\x07'
b'\x16\xd6\xff\xe5p5')
Результат разбора:
'A1': [{'B1': 234, 'B2': 22347, 'B3': 52326},
{'B1': 251, 'B2': 34275, 'B3': 62869},
{'B1': 201, 'B2': 62858, 'B3': 34098}],
{'A2': 31,
'A3': {'C1': 'mr',
'C2': -8951422446769986689,
'C3': {'D1': -69,
'D2': -1674193746,
'D3': 974023112,
'D4': 5559606775081476334,
'D5': 12314,
'D6': 3601709430260880424},
'C4': [667198158, 1210610008],
'C5': 27515,
'C6': {'E1': 1950541470, 'E2': 24312}},
'A4': {'F1': -1614756641,
'F2': [2489287507, 1179697117],
'F3': 24396,
'F4': -0.8603168765553317,
'F5': 0.5869836857102828,
'F6': 200,
'F7': -0.3598076915364663,
'F8': 53},
'A5': -8539265797863436351,
'A6': -0.5730318988265619,
'A7': 59957,
'A8': 24851132}
Пример 2
Двоичные данные:
b"ZTE\x00\x02\x00\x00\x002%\x00\x00\x00_\x00\x00\x00}\xca'#\x08+\xe0\xdaN?\xe9"
(b'aq\xce\xd4\xd9\xc8\xe5\xc0\x14j\xe5,S1@\x1a\xd2\xfcM\x98\x1bd\x00\x00'
b'\x00(\x00\x00\x00-sdt\x05\xb0\xd1G\x1al\x98duD\xe7\xb4\x1e)-\xfbn\xc0='
b'\x0c\x0cKB\xa4\xc91`\x88d!\t\xe0=\xe8\x00\x00\x00\x02\x00:\xa0\xded'
b'\xab\x8a\xac\xbb\xa3\x00\x00\x00<\x00\x02\x00W\x85\xc7\xbd\xd4\x81\x7f\xb0'
b'\xa7f\xc9I\xbfK\xf6\xcd\xf1,h\x96\x9aVA?\xe5\x06n4\xf1\xecX\xbf'
b'\xbc\xad\xe2\xf6\xd7\xfb\xc0\x0b?~\xf4\xd4M\x90\xff\x00\x87')
Результат разбора:
'A1': [{'B1': 83, 'B2': 12608, 'B3': 6866},
{'B1': 252, 'B2': 19864, 'B3': 7012}],
{'A2': 37,
'A3': {'C1': 'sd',
'C2': -6854930894882554973,
'C3': {'D1': 116,
'D2': 95473991,
'D3': 443324516,
'D4': 8450133561640037883,
'D5': 28352,
'D6': 4398904453414308145},
'C4': [1619551265, 165690856],
'C5': -31289,
'C6': {'E1': -1110146689, 'E2': -20313}},
'A4': {'F1': 1724467647,
'F2': [1274465777, 745051802],
'F3': 22081,
'F4': 0.6570349725801732,
'F5': -0.11202829863030583,
'F6': 11,
'F7': 0.007557706173485945,
'F8': -121},
'A5': -3880094035953526194,
'A6': 0.7931450881649704,
'A7': 58816,
'A8': 342549804}
Задача №12
Реализовать разбор двоичного формата данных. Данные начинаются с сигнатуры 0x55 0x4b 0x46 0x59
, за которой следует структура
A. Порядок байт: от младшего к старшему. Адреса указаны в виде смещений от начала данных. В решении предлагается использовать модуль
struct.
Структура A:
Поле | Описание |
---|---|
1 | Массив структур B, размер 4 |
2 | Структура C |
Структура B:
Поле | Описание |
---|---|
1 | float |
2 | int32 |
3 | uint16 |
4 | float |
Структура C:
Поле | Описание |
---|---|
1 | int8 |
2 | Структура D |
3 | float |
4 | Размер (uint16) и адрес (uint32) массива int32 |
5 | double |
6 | Массив uint16, размер 2 |
Структура D:
Поле | Описание |
---|---|
1 | int16 |
2 | uint8 |
3 | int8 |
4 | uint8 |
5 | uint8 |
6 | Адрес (uint32) структуры E |
7 | int8 |
8 | Структура F |
Структура E:
Поле | Описание |
---|---|
1 | Размер (uint16) и адрес (uint16) массива uint32 |
2 | uint16 |
3 | uint16 |
4 | int8 |
5 | int32 |
Структура F:
Поле | Описание |
---|---|
1 | uint64 |
2 | float |
Ниже показаны примеры разбора двоичного формата.
Пример 1
Двоичные данные:
b'UKFY{\xbd\x7f\xbfgR\xec\x90\x1d\x01\x08\xca\x16\xbf!LQ?\xca\x96s\xbe\xaa\xe6'
(b'\xee\n\xb8\xbe<cq\xbfs\x1a\xcaA:\xb9}\xa7\xf2\xbe\x83j]?\x0f:\xeb>U\xc6'
b"\\3J\xbf\xca\xed\xe9l]C\x90z\x00\x00\x00\x18\xfc'K\xa8\x8f\xf1W8"
b'\x9a\xde+\xbe\xe2\xb7\x12\xbf\x07\x00\x87\x00\x00\x00\x90\x97\x8aR\x0c6'
b'\xc7\xbf\x9e.\x1eu\xc2\x99\xce\xe1\xb4m\x94\xaf\xcc\x0cM(K\x9b$e\x04\x00'
b'j\x00\x88\xad\x12\xcfH\xdc\x9f\x16\x1bS}\x9b\xbd\xb3\x97\x8fT\xac\x9e86p'
b'\xcd\x82\xc9B\xc0\x06o\x88\xe8x\xad]o\xef\n')
Результат разбора:
'A1': [{'B1': -0.9989849925041199,
{'B2': -1863560601,
'B3': 285,
'B4': -0.5890202522277832},
'B1': 0.8175678849220276,
{'B2': -1099721014,
'B3': 59050,
'B4': -0.35945838689804077},
'B1': -0.942920446395874,
{'B2': 1103764083,
'B3': 47418,
'B4': -0.4739340841770172},
'B1': 0.8649064898490906,
{'B2': 1055603215,
'B3': 50773,
'B4': -0.7898461818695068}],
'A2': {'C1': -54,
'C2': {'D1': -5651,
'D2': 108,
'D3': 93,
'D4': 67,
'D5': 144,
'D6': {'E1': [3788413378, 2945740212, 676138188, 1696897867],
'E2': 44424,
'E3': 53010,
'E4': 72,
'E5': 454467548},
'D7': 24,
'D8': {'F1': 4059979188403906556, 'F2': -0.1678413450717926}},
'C3': -0.5731183290481567,
'C4': [-1113883309,
1418696627,
909680300,
-914174608,
1862713410,
-1384585080,
183463773],
'C5': -0.18133691816654762,
'C6': [11934, 29982]}}
Пример 2
Двоичные данные:
b'UKFY\n\xb4\xa1\xbe=\xceW\xd6\xee\x1b{\x1cM\xbf\xe2l7\xbf\x7f\xda'
(b'\x8f\xe6\xff\xd4\xba\x0f\xd9\xbe\xea\xea=\xbfg\x0e_\xe4;_\xa6\x9d\x00>,Z'
b'\xbb>U\x8a\xa7@l\xed*\xd1\x07\xbfBP\xee\xf3\x92\x12or\x00\x00\x00\xc2'
b'\x0fb\x03\xccU \xc8\xc5\xcf|`?6\x03\x15?\x06\x00\x7f\x00\x00\x00\xa0\xb6'
b'\x15%\xb4\xd5\xe8\xbf\xd9\x1b%\n\xde\xac\xdf\xd3\x97\r\xf4O\x02\x00j\x007x'
b'\xe9\xa8\x97\x1b!\x9f\xc9\x1c\xb5Q\xc8\x1f\xa3\xf5\x08\x8f\x01\x14\xeda'
b'#\x1f{]\xe5\x7f_\x84\xc3\xc9w')
Результат разбора:
'A1': [{'B1': -0.3158267140388489,
{'B2': -698888643,
'B3': 7150,
'B4': -0.8012158274650574},
'B1': -0.7165051698684692,
{'B2': -426780033,
'B3': 54527,
'B4': -0.42394810914993286},
'B1': -0.7418657541275024,
{'B2': -463532441,
'B3': 24379,
'B4': 0.1256013810634613},
'B1': 0.36592233180999756,
{'B2': 1084721749,
'B3': 60780,
'B4': -0.5305353403091431}],
'A2': {'C1': 66,
'C2': {'D1': -4528,
'D2': 243,
'D3': -110,
'D4': 18,
'D5': 111,
'D6': {'E1': [3554651358, 1341394327],
'E2': 30775,
'E3': 43241,
'E4': -105,
'E5': -912318181},
'D7': -62,
'D8': {'F1': 14251676573681017359, 'F2': 0.8769044280052185}},
'C3': 0.5820802450180054,
'C4': [-934169316,
150315807,
-317455985,
2065638241,
1602217309,
2009711492],
'C5': -0.7760868763268327,
'C6': [7129, 2597]}}
Задача №12
Реализовать разбор двоичного формата данных. Данные начинаются с сигнатуры 0x43 0x4c 0x53
, за которой следует структура A.
Порядок байт: от старшего к младшему. Адреса указаны в виде смещений от начала данных. В решении предлагается использовать модуль
struct.
Структура A:
Поле | Описание |
---|---|
1 | Структура B |
2 | int16 |
Структура B:
Поле | Описание |
---|---|
1 | Размер (uint16) и адрес (uint32) массива адресов (uint32) структур C |
2 | uint16 |
Структура C:
Поле | Описание |
---|---|
1 | double |
2 | Адрес (uint32) структуры D |
3 | Структура E |
4 | int8 |
5 | Адрес (uint32) структуры F |
6 | Размер (uint32) и адрес (uint16) массива uint8 |
7 | uint32 |
Структура D:
Поле | Описание |
---|---|
1 | Массив int8, размер 8 |
2 | int8 |
Структура E:
Поле | Описание |
---|---|
1 | int16 |
2 | float |
3 | int64 |
Структура F:
Поле | Описание |
---|---|
1 | Размер (uint32) и адрес (uint16) массива int8 |
2 | uint64 |
3 | int64 |
4 | int8 |
Ниже показаны примеры разбора двоичного формата.
Пример 1
Двоичные данные:
b'CLS\x00\x02\x00\x00\x00\xab\xf8\xb4\x15<U\xc2D\xbc\x0cU\x8a\x13O<\xe3'
(b'>\x00\x00\x00\x03\x00\x16"\xff\x02\xd4\xafr\xd0\ti\x03\xf9\x11\x1b'
b'\x0e\xcfl\xa6\x997\xbf\xdb\x81\xe9B\x92\xbb\x14\x00\x00\x00\rb;=\x9f\x11\x9e'
b'J\n\x94?eROpw\x00\x00\x00\x19\x00\x00\x00\x02\x000\x07\x83\xb0\x19\x08'
b'\x1e=H\xc6\x93\xa3\xab\xc2\xe4F\x00\x00\x00\x02\x00d\xe7uw\r\xd9\xdac\x07'
b'\xce\xc1\xc2_xTpTAON$\xb6\xc1\xbf\xe8\xfe\xb96\xb8y\xc6\x00\x00\x00[C('
b'\xbe\x93\x10\xa29\xb4dE\xc0q\x80\x9a\xba\x00\x00\x00f\x00\x00\x00'
b'\x05\x00}\xc51\\t\x00\x00\x002\x00\x00\x00\x82')
Результат разбора:
'A1': {'B1': [{'C1': -0.42980414868627403,
{'C2': {'D1': [85, -62, 68, -68, 12, 85, -118, 19], 'D2': 79},
'C3': {'E1': 25147,
'E2': 0.07767032086849213,
'E3': 5335239708577517424},
'C4': 119,
'C5': {'F1': [60, -29, 62],
'F2': 2521737428850626569,
'F3': 7567165650776280940,
'F4': -90},
'C6': [153, 55],
'C7': 126070809},
'C1': -0.7810941761743428,
{'C2': {'D1': [8, 30, 61, 72, -58, -109, -93, -85], 'D2': -62},
'C3': {'E1': 17192,
'E2': -0.2872362732887268,
'E3': 4158058606713995418},
'C4': -70,
'C5': {'F1': [-28, 70],
'F2': 16678367696409748231,
'F3': -3548341316094758828,
'F4': 65},
'C6': [79, 78, 36, 182, 193],
'C7': 3308346484}],
'B2': 63668},
'A2': 5436}
Пример 2
Двоичные данные:
b'CLS\x00\x02\x00\x00\x00\xaeJ:Z\xc4\xf5\x83\x85\x96q\xe9\xae/\x99\xb4\xd0'
(b'\xcc\x00\x00\x00\x03\x00\x16d\x03\xee*\x9eI\xb1\xa6"\x80\xd7A\xd5'
b"\x04\x85_\x91-\x03\xf1?\xe9\xf5\xe0}\x94'B\x00\x00\x00\rf\xdc?R\x1a"
b'\xee\xbd\xe0\xa7=\xfc\xf1\x0e\xd6\xfd\x00\x00\x00\x19\x00\x00\x00\x03\x000'
b'\xd15\xc0\xedL\x1fEB{\x14\xb8%\xd6\xbaU\x11h\x00\x00\x00\x04\x00e\xee'
b'\xb34P\xd3\xa2\xf8K\x8c\xe3\xbf<\x86>\x8b%#\xe4\xc3Ura\xbf\xc6I\x1c\xab\x19H'
b'\x88\x00\x00\x00\\_\xb1\xbd\xaa\xb92\x0c\xd90\x96\x8c!X\xb5{\x00\x00\x00i'
b'\x00\x00\x00\x05\x00\x80\xcd%)*\x00\x00\x003\x00\x00\x00\x85')
Результат разбора:
'A1': {'B1': [{'C1': 0.8112642719945387,
{'C2': {'D1': [-11, -125, -123, -106, 113, -23, -82, 47],
'D2': -103},
'C3': {'E1': 26332,
'E2': 0.8207234144210815,
'E3': -4764624521079484714},
'C4': -3,
'C5': {'F1': [-76, -48, -52],
'F2': 7206865695534592422,
'F3': 2486223672055203167,
'F4': -111},
'C6': [45, 3, 241],
'C7': 3509960941},
'C1': -0.17410620073730265,
{'C2': {'D1': [76, 31, 69, 66, 123, 20, -72, 37], 'D2': -42},
'C3': {'E1': 24497,
'E2': -0.08336104452610016,
'E3': 925824621555570869},
'C4': 123,
'C5': {'F1': [-70, 85, 17, 104],
'F2': 17200148923610757195,
'F3': -8294575822015132891,
'F4': 35},
'C6': [228, 195, 85, 114, 97],
'C7': 3441764650}],
'B2': 19002},
'A2': 23236}
Задача №12
Реализовать разбор двоичного формата данных. Данные начинаются с сигнатуры 0x41 0x52 0x44 0x52 0x2b
, за которой следует
структура A. Порядок байт: от старшего к младшему. Адреса указаны в виде смещений от начала данных. В решении предлагается использовать
модуль struct.
Структура A:
Поле | Описание |
---|---|
1 | double |
2 | int8 |
3 | Адрес (uint16) структуры B |
4 | Размер (uint32) и адрес (uint16) массива char |
5 | double |
6 | int16 |
7 | uint32 |
8 | Размер (uint16) и адрес (uint16) массива структур C |
Структура B:
Поле | Описание |
---|---|
1 | int32 |
2 | uint32 |
Структура C:
Поле | Описание |
---|---|
1 | uint32 |
2 | Массив int16, размер 2 |
3 | Структура D |
4 | uint16 |
Структура D:
Поле | Описание |
---|---|
1 | uint8 |
2 | uint16 |
3 | int16 |
4 | uint32 |
5 | uint16 |
6 | Размер (uint16) и адрес (uint32) массива int8 |
Ниже показаны примеры разбора двоичного формата.
Пример 1
Двоичные данные:
b'ARDR+?\xe8\xfd\x1c\xf0\xd3\xf8\x88\xe2\x00(\x00\x00\x00\x03\x000\xbf?'
(b'{\xd6!\xa6\xd0\x00G\xbdP\xbd\x80\xc5\x00\x02\x00:M\x0b\x99\xb0\x88\x84>\x07'
b'rfe\xa5\xed=\xc4\x9d\x1e\xcf\n\x11\xbe^v\n\xb4\xc2w\xc4P\xafr\xd7\x9c\n|-'
b'\x80\x00\x04\x00\x00\x003/X\xd4\x80\xdao\xcb\xd2\xe2\xd3\xc98\x98'
b'\x03!\xd2\xda\xe1\xf6\xf1\r\x00\x03\x00\x00\x007\x17v')
Результат разбора:
'A1': 0.7808975890800562,
{'A2': -30,
'A3': {'B1': 1292605872, 'B2': 2290368007},
'A4': 'rfe',
'A5': -0.0004804036886085772,
'A6': 18365,
'A7': 1354596549,
'A8': [{'C1': 168935006,
'C2': [30218, -19262],
'C3': {'D1': 119,
'D2': 50256,
'D3': -20622,
'D4': 3617327740,
'D5': 11648,
'D6': [-91, -19, 61, -60]},
'C4': 12120},
'C1': 3565214319,
{'C2': [-13358, -7469],
'C3': {'D1': 201,
'D2': 14488,
'D3': 801,
'D4': 3537560054,
'D5': 61709,
'D6': [-99, 30, -49]},
'C4': 6006}]}
Пример 2
Двоичные данные:
b'ARDR+?\xeb\x9d\xab\xb8\x90/\xd8\xa4\x00(\x00\x00\x00\x03\x000?\xe7'
(b'>\xc4\xe8\x81UVLnO\xcbm\xef\x00\x02\x009\xc0\xc2z\xf5\xcc\x0c\x1b\x16ggx)'
b'\xad\xadnu\xdd\xd3\xdd\xda\x8c8\x03\x0f\xd8\x82:\xb3\xf4|7\r=8\xe0\xb3'
b'\x00\x02\x00\x00\x003\x81U\x96\xc1\xe1\xc2\r\x9e\x9c\x9f\xea!\xdb\x0c'
b'\xef\xa1P:\xa2\x0c\xba\x00\x04\x00\x00\x005NO')
Результат разбора:
'A1': 0.8629969219923579,
{'A2': -92,
'A3': {'B1': -1060996363, 'B2': 3423345430},
'A4': 'ggx',
'A5': 0.7264122525327064,
'A6': 19566,
'A7': 1338732015,
'A8': [{'C1': 3554531980,
'C2': [14339, 4056],
'C3': {'D1': 130,
'D2': 15027,
'D3': -2948,
'D4': 923614520,
'D5': 57523,
'D6': [41, -83]},
'C4': 33109},
'C1': 2529288642,
{'C2': [3486, -25441],
'C3': {'D1': 234,
'D2': 8667,
'D3': 3311,
'D4': 2706389666,
'D5': 3258,
'D6': [-83, 110, 117, -35]},
'C4': 20047}]}
Задача №12
Реализовать разбор двоичного формата данных. Данные начинаются с сигнатуры 0x47 0x47 0x53 0x49
, за которой следует структура
A. Порядок байт: от младшего к старшему. Адреса указаны в виде смещений от начала данных. В решении предлагается использовать модуль
struct.
Структура A:
Поле | Описание |
---|---|
1 | Адрес (uint16) структуры B |
2 | Размер (uint32) и адрес (uint32) массива структур C |
3 | uint64 |
4 | Адрес (uint16) структуры D |
5 | uint16 |
6 | int8 |
Структура B:
Поле | Описание |
---|---|
1 | uint8 |
2 | uint64 |
3 | uint32 |
4 | Массив char, размер 2 |
Структура C:
Поле | Описание |
---|---|
1 | uint16 |
2 | uint32 |
Структура D:
Поле | Описание |
---|---|
1 | uint32 |
2 | Массив int64, размер 2 |
3 | Адрес (uint32) структуры E |
4 | Размер (uint16) и адрес (uint32) массива float |
5 | int64 |
6 | int32 |
Структура E:
Поле | Описание |
---|---|
1 | uint8 |
2 | Размер (uint32) и адрес (uint16) массива uint16 |
3 | float |
4 | uint8 |
5 | double |
Ниже показаны примеры разбора двоичного формата.
Пример 1
Двоичные данные:
b'GGSI\x1b\x00\x02\x00\x00\x00*\x00\x00\x00\xbd9>[\x99\xe3J\x98^\x00P\xcc<\xe0'
(b'\n\x05\xd2\xecH\x0eo^\x96\x80\xfeSbzwW,Y(B/~\\\x9ds\xa9\xfd\x1c\xb8[\x9f\x02'
b"\x00\x00\x006\x00I>\x06?E@\tz\xfd\x17{\xac?W\xf6\x10?x##?'\x92\xa3>$e"
b'\x82>l\xc6\xdb\x97p2\x8c\xcb\x10\x05\x19Q\xb3+4\xb0\x07\xd2/l:\x00'
b"\x00\x00\x04\x00N\x00\x00\x00\xf7M\t'J\xf9Ik\x1fsY\xf7")
Результат разбора:
'A1': {'B1': 224, 'B2': 6804673268353729802, 'B3': 1409187990, 'B4': 'bz'},
{'A2': [{'C1': 22391, 'C2': 1109940524}, {'C1': 32303, 'C2': 2842926428}],
'A3': 10973833689841940925,
'A4': {'D1': 2547762796,
'D2': [5843707561182507632, 7795680410464431027],
'D3': {'E1': 159,
'E2': [7421, 23480],
'E3': 0.5243878960609436,
'E4': 69,
'E5': 0.0556266304893307},
'D4': [0.5662588477134705,
0.6372599601745605,
0.3194744288921356,
0.2546778917312622],
'D5': 7730984332235984375,
'D6': -145132769},
'A5': 52304,
'A6': 60}
Пример 2
Двоичные данные:
b'GGSI\x1b\x00\x02\x00\x00\x00*\x00\x00\x00\xc0D\t\xf8FD\xc2\x1bf\x00'
(b'\xab\x80\xcfK\xc7\xb0\xba\xbe\xa0\xc4\xb5\x8b\x0b\xc0\xa21yn]\x80$jj\xee'
b'Q\xda\x86"\xe1\xf5\x958\xb3o\x0c\x02\x00\x00\x006\x00\xbaU\x1f\xbf&\x18d'
b'\x84\xff\x13H\xcb\xbfh\xd9X?\x10"\x85<F\x92\xcc>\xe77\x13\xbf\xb8LP>\xf0^'
b'_\xbcQ\xb74A\xdfx\x07\xc9\x84\xa9T\xbdtRx\xf6XL\x8c\x02:\x00\x00\x00\x06\x00'
b"N\x00\x00\x00h\xaa\x1e\t\xa6\x02'\x16\x06\xa6[\xcd")
Результат разбора:
'A1': {'B1': 75, 'B2': 10067168736730329287, 'B3': 832749579, 'B4': 'yn'},
{'A2': [{'C1': 32861, 'C2': 3999951396}, {'C1': 55889, 'C2': 4125172358}],
'A3': 2000236256105678016,
'A4': {'D1': 1093973841,
'D2': [-4804028514723989281, 183605629791261300],
'D3': {'E1': 12,
'E2': [14485, 28595],
'E3': -0.6224018335342407,
'E4': 38,
'E5': -0.21313714958594754},
'D4': [0.8470673561096191,
0.016251593828201294,
0.39955347776412964,
-0.5750717520713806,
0.20341765880584717,
-0.013633474707603455],
'D5': 1596247505066961512,
'D6': -849631738},
'A5': 32939,
'A6': -49}
Задача №12
Реализовать разбор двоичного формата данных. Данные начинаются с сигнатуры 0x52 0x52 0x53 0x41
, за которой следует структура
A. Порядок байт: от старшего к младшему. Адреса указаны в виде смещений от начала данных. В решении предлагается использовать модуль
struct.
Структура A:
Поле | Описание |
---|---|
1 | uint32 |
2 | Структура B |
3 | uint32 |
4 | int64 |
5 | Размер (uint32) и адрес (uint16) массива char |
6 | Массив адресов (uint16) структур D, размер 4 |
7 | int32 |
8 | Размер (uint16) и адрес (uint32) массива int32 |
Структура B:
Поле | Описание |
---|---|
1 | Адрес (uint16) структуры C |
2 | double |
3 | double |
4 | float |
5 | uint64 |
Структура C:
Поле | Описание |
---|---|
1 | uint32 |
2 | uint64 |
3 | uint16 |
4 | double |
5 | Размер (uint32) и адрес (uint32) массива char |
6 | uint32 |
Структура D:
Поле | Описание |
---|---|
1 | uint16 |
2 | Размер (uint16) и адрес (uint16) массива int16 |
Ниже показаны примеры разбора двоичного формата.
Пример 1
Двоичные данные:
b"RRSA\x05\xcd \x9f\x00O?\xe4\xd1G~\x7f\x11\xac?\xe0'\xdf\x8d&\xd0\xba\xbf]"
(b'\xf1\x9a\x1d^)\xa6\xe9\xad\x96\x0ev/\xdd\xc1SQ\xe4\x92\x883]u\x00\x00'
b'\x00\x02\x00q\x00w\x00\x81\x00\x8b\x00\x95\x02\xcb8\x15\x00\x02\x00\x00'
b'\x00\x9bqpwdn\xday:/\x84\xeb}1\x10g{GGv?\xd4yoAt:\xc8\x00\x00\x00'
b'\x05\x00\x00\x00JD\xfc\xb6\x0cfv\xf2\x17*S\xbf\xe0\x00\x02\x00s\xbc5\t'
b'y\xf2\x89\x00\x02\x00}9\xe9\xdf^\x9a\x08\x00\x02\x00\x87\xcc\xf2\x8d'
b'\x18\xac\xd1\x00\x02\x00\x91m`\xe1"mK\xe3\x13')
Результат разбора:
'A1': 97329311,
{'A2': {'B1': {'C1': 3665377839,
'C2': 9577886682215578439,
'C3': 18294,
'C4': 0.3199117793273385,
'C5': 'qpwdn',
'C6': 1157412364},
'B2': 0.6505467863685701,
'B3': 0.5048673397891641,
'B4': -0.8669677972793579,
'B5': 2116174671772489230},
'A3': 1982848449,
'A4': 6003831096263007605,
'A5': 'fv',
'A6': [{'D1': 49120, 'D2': [-3561, 10835]},
'D1': 62089, 'D2': [-17355, 2425]},
{'D1': 39432, 'D2': [14825, -8354]},
{'D1': 44241, 'D2': [-13070, -29416]}],
{'A7': 46872597,
'A8': [1835065634, 1833689875]}
Пример 2
Двоичные данные:
b'RRSA\x08\xce\xe0!\x00N\xbf\xd2&_\xd0s"\xcc?\xc7\x8a\n\x1e\x96\x99\xc8\xbcj'
(b'\xe1\xb8\x81\xbb\xa5\xa6,\xfd[0\x01\xcc\x9b,ns\x83\xecQ\x94\xebK\x00\x00'
b'\x00\x02\x00p\x00v\x00\x80\x00\x8a\x00\x94\x1c,g"\x00\x02\x00\x00\x00\x9ald'
b'wo<\xa9\xcd\x03\xbc\xf2\xef\xfa*\xcb\xf5\xf9\x7f7?\xcd\xbf\xac9\x1f\xcdh'
b'\x00\x00\x00\x04\x00\x00\x00J\xf5\xb6\xa0\x93gmU\xaav1\xd1\x06\x00\x02\x00r'
b'0`\xbf\x94\x8c\x1b\x00\x02\x00|\xb2\xf1\xa0E+o\x00\x02\x00\x86sL\xe4\xb6'
b'\x1e\xe1\x00\x02\x00\x90\xcf\x99W-\xc1\xb9\xbdl')
Результат разбора:
'A1': 147775521,
{'A2': {'B1': {'C1': 1017761027,
'C2': 13615208481233303033,
'C3': 32567,
'C4': 0.23241188802021928,
'C5': 'ldwo',
'C6': 4122386579},
'B2': -0.2835921798364722,
'B3': 0.18390013211792522,
'B4': -0.01433604210615158,
'B5': 9348247584675552048},
'A3': 30186284,
'A4': 7958850017498032971,
'A5': 'gm',
'A6': [{'D1': 53510, 'D2': [21930, 30257]},
'D1': 35867, 'D2': [12384, -16492]},
{'D1': 11119, 'D2': [-19727, -24507]},
{'D1': 7905, 'D2': [29516, -6986]}],
{'A7': 472672034,
'A8': [-812034259, -1044791956]}
Задача №12
Реализовать разбор двоичного формата данных. Данные начинаются с сигнатуры 0x56 0x57 0x4b 0x4c
, за которой следует структура
A. Порядок байт: от младшего к старшему. Адреса указаны в виде смещений от начала данных. В решении предлагается использовать модуль
struct.
Структура A:
Поле | Описание |
---|---|
1 | Структура B |
2 | Массив double, размер 2 |
3 | double |
4 | int8 |
5 | uint32 |
6 | uint8 |
Структура B:
Поле | Описание |
---|---|
1 | Массив char, размер 2 |
2 | Размер (uint16) и адрес (uint32) массива структур C |
3 | uint8 |
4 | int8 |
5 | uint32 |
6 | int8 |
7 | uint8 |
8 | Структура D |
Структура C:
Поле | Описание |
---|---|
1 | uint16 |
2 | uint32 |
3 | int8 |
Структура D:
Поле | Описание |
---|---|
1 | int8 |
2 | int32 |
3 | Размер (uint32) и адрес (uint16) массива double |
Ниже показаны примеры разбора двоичного формата.
Пример 1
Двоичные данные:
b'VWKLjt\x03\x00=\x00\x00\x00\xa4Rv]\xfca\x97\xe8\nDe\xec\x03\x03\x00\x00'
(b'\x00R\x00\x00\\k\xffE\xb2m\xbf\xec\xa5\xe6\xf5mz\xe8?\x06\x8c\x82,\x86'
b's\xeb?O7\xac9\xd9\xae\xcf\x0bS\x1c\xbeil\xbf7\x95\x9c\xa1[t\xd7mO\x99\xc9'
b'J\xd4 \xbdC\xa6R!\xc7?\xfcX\x05l\x8d\xd0\xd9\xbf\xb8\x81\xef*\xbe+\xd7\xbf')
Результат разбора:
'A1': {'B1': 'jt',
{'B2': [{'C1': 3023, 'C2': 1774066771, 'C3': 108},
'C1': 14271, 'C2': 1537318037, 'C3': 116},
{'C1': 28119, 'C2': 1254725967, 'C3': -44}],
{'B3': 164,
'B4': 82,
'B5': 1643928950,
'B6': -105,
'B7': 232,
'B8': {'D1': 10,
'D2': 65824068,
'D3': [0.18070443266285796,
-0.4033540301219458,
-0.3620448512356478]}},
'A2': [-0.0036250464575959818, 0.7649450114014917],
'A3': 0.85785206502294,
'A4': 79,
'A5': 3644435511,
'A6': 174}
Пример 2
Двоичные данные:
b'VWKLtb\x02\x00=\x00\x00\x00\xd6\x18\xc1\xeaJ\xc1\xa8\x8f\xc8\x8fC\xcb'
(b'\x1a\x03\x00\x00\x00K\x00\x92\xdf\x8b\x80\xe4\xd0\xe3\xbf\xd8\xa1\x16$\xf5'
b' \xef\xbf\xd4\xc1\xb8w\x81\xe8\xea?C\xbe\xc6\r\xf5\x98\xe17_X7v\xba'
b'{\x86\xa5\xa7\t#f0__\xc5S\xa2\xe8\xbf\x82\x83\xb3\xe2\x92\x93\xe0?\x04'
b'\xe0\x02\xda\x8f\x8c\xd0\xbf')
Результат разбора:
'A1': {'B1': 'tb',
{'B2': [{'C1': 14305, 'C2': 1983338591, 'C3': -70},
'C1': 34427, 'C2': 587835301, 'C3': 102}],
{'B3': 214,
'B4': 24,
'B5': 3242912449,
'B6': -88,
'B7': 143,
'B8': {'D1': -56,
'D2': 449528719,
'D3': [-0.7698153357441466,
0.5180143764265355,
-0.2585792187705922]}},
'A2': [-0.6192495833083618, -0.9727731423236561],
'A3': 0.8408820474924661,
'A4': 67,
'A5': 4111320766,
'A6': 152}
Задача №12
Реализовать разбор двоичного формата данных. Данные начинаются с сигнатуры 0x81 0x43 0x41 0x56 0x46
, за которой следует
структура A. Порядок байт: от старшего к младшему. Адреса указаны в виде смещений от начала данных. В решении предлагается использовать
модуль struct.
Структура A:
Поле | Описание |
---|---|
1 | Структура B |
2 | uint8 |
3 | uint8 |
4 | Структура D |
Структура B:
Поле | Описание |
---|---|
1 | Массив uint8, размер 6 |
2 | Массив структур C, размер 4 |
3 | int16 |
4 | uint32 |
Структура C:
Поле | Описание |
---|---|
1 | uint8 |
2 | float |
3 | int64 |
4 | Массив int16, размер 2 |
5 | double |
Структура D:
Поле | Описание |
---|---|
1 | int16 |
2 | Размер (uint32) и адрес (uint16) массива uint16 |
3 | double |
4 | uint16 |
5 | int64 |
6 | double |
Ниже показаны примеры разбора двоичного формата.
Пример 1
Двоичные данные:
b'\x81CAVFL\xd2\xb9\xf1\x98h~?(]\xeag_\xe8\x97W6\x9c\x9eB\xb0v\x84'
(b'?\xcd\x81\xa9\xba \x97\x18\x18\xbe=*\xaf\xd7yG\xb5\xbbf\xb7\xee@\n\xbd'
b'\x1b\xbf\xe5\xda\xa6\x97e\x04\x0e`>b\x07\xb3\x13p0\xcf\xcf\xa5X>\xf7\x9a'
b'DV\xbf\xa0\xd1\xdf\x86\x9b\x00\xa0m\xbe\x88\xc5\xe5uq\x1a/.\x1e\x12\xda\x91'
b'\xea\x92\xe9\xbf\xe3\xfd\xc4\xdd\xe5\xd2\xaeQ\x9a\xc8\xff\xe8I\x11\x7f\xce'
b'\x98\x00\x00\x00\x08\x00\x99?\xe7\xae\xdb\x07\xdd\xa7zN\xd7\xc8\xde|'
b'H\xf3\n\x920?\xcbI$\xb3\xf7\x98\x18W\x01\xd7N\xc3\xe9\xdaD\x94/\x8d'
b'j%\xdf\x92\x8d')
Результат разбора:
'A1': {'B1': [76, 210, 185, 241, 152, 104],
{'B2': [{'C1': 126,
'C2': 0.6576830148696899,
'C3': 7448928045394992286,
'C4': [17072, 30340],
'C5': 0.23051950062033977},
'C1': 24,
{'C2': -0.18473313748836517,
'C3': -2920224037514332178,
'C4': [16394, -17125],
'C5': -0.6829407650876662},
'C1': 96,
{'C2': 0.22073249518871307,
'C3': 1400673153212307518,
'C4': [-2150, 17494],
'C5': -0.03285120504506378},
'C1': 109,
{'C2': -0.26713481545448303,
'C3': 8462573964745380570,
'C4': [-28182, -27927],
'C5': -0.624727662462268}],
'B3': 20890,
'B4': 3372214345},
'A2': 17,
'A3': 127,
'A4': {'D1': -12648,
'D2': [22273, 55118, 50153, 55876, 37935, 36202, 9695, 37517],
'D3': 0.7400946763639091,
'D4': 20183,
'D5': -3972601168537152976,
'D6': 0.21316965854129033}}
Пример 2
Двоичные данные:
b'\x81CAVF\x1dj\xc3\xb5\xc3\x8f\xd2?\x12\xf2\xf0\ta\xa1\x13$\xc1\xecK'
(b'U\xc4{\x02\xbf\xdcNZ\xa6\xb74\x8c\x83>\x8b``\xe3\xc7\xf2\xbb(9H\xc5\xfc\xb1i'
b'`?\xd2Z\x95\x88v\xd2\x08\xd6>\x81p\xcd_\x19\xce=\xf8-]\x1b\xba\x8b\x1b>?\xbd'
b'a\x94H\xf4\x90\x00W?B\xba\xfd\xef\xb5!7{\x07-\xff\x88&K\xb4?\xdeol\xd6'
b'\x83\xdb\xac\xc8\xb4\xa5:\xbe"\x8d;\xe9\xc6\x00\x00\x00\x08\x00\x99?'
b'\xef\r\x87>\xa5\xd2\xca\x96^\xd3\x1e\xb4\xe2|\x19\xe5\x13?\xe9\x0b'
b'\xba\xfd9\xcb<V}\x86O\xffG\xcaJA\x9c\xe6\xb6P\xc33\xb8')
Результат разбора:
'A1': {'B1': [29, 106, 195, 181, 195, 143],
{'B2': [{'C1': 210,
'C2': 0.5740194320678711,
'C3': 675998522675424331,
'C4': [21956, 31490],
'C5': -0.4422823551256634},
'C1': 131,
{'C2': 0.2722196578979492,
'C3': -2033389821086840635,
'C4': [-847, 26976],
'C5': 0.2867788155229225},
'C1': 214,
{'C2': 0.2528137266635895,
'C3': 6852735073572969755,
'C4': [-17781, 6974],
'C5': 0.1147701910127239},
'C1': 87,
{'C2': 0.7606657147407532,
'C3': -1173995605689160193,
'C4': [-30682, 19380],
'C5': 0.4755508513330209}],
'B3': -14156,
'B4': 2772090402},
'A2': 141,
'A3': 59,
'A4': {'D1': -5690,
'D2': [22141, 34383, 65351, 51786, 16796, 59062, 20675, 13240],
'D3': 0.9704014037693807,
'D4': 38494,
'D5': -3233948597567757037,
'D6': 0.7826819368186544}}
Задача №12
Реализовать разбор двоичного формата данных. Данные начинаются с сигнатуры 0x3e 0x4f 0x51 0x47 0x53
, за которой следует
структура A. Порядок байт: от младшего к старшему. Адреса указаны в виде смещений от начала данных. В решении предлагается использовать
модуль struct.
Структура A:
Поле | Описание |
---|---|
1 | float |
2 | Массив char, размер 4 |
3 | float |
4 | int32 |
5 | uint8 |
6 | uint32 |
7 | Массив адресов (uint32) структур B, размер 2 |
8 | int8 |
Структура B:
Поле | Описание |
---|---|
1 | Структура C |
2 | Массив float, размер 6 |
3 | uint64 |
4 | Структура D |
Структура C:
Поле | Описание |
---|---|
1 | uint64 |
2 | int16 |
Структура D:
Поле | Описание |
---|---|
1 | uint8 |
2 | Размер (uint16) и адрес (uint16) массива int8 |
Ниже показаны примеры разбора двоичного формата.
Пример 1
Двоичные данные:
b'>OQGS\xd8Zu?qxqh\x07\xe1l\xbf\xa1\xa96\xe6,t\xa6X\xff%\x00\x00\x00V\x00'
(b'\x00\x00\xcf\n\xa3\xe4,\xf2\xac]]\x04\x9aE\x96\xaaP\xf0\xbe%\xba\xd9\xbe\xfa'
b'\xe7n\xbe\x91\x9e \xbf\xafHS\xbf\xe1\x86e\xbe/\xe3\x9f\x8f\xd7'
b'\xea\x80\x18\xf3\x02\x00#\x00\x953\xb8\xd4}\xed\x96+D%\xabk#\xe3p?'
b'\xc3\xbc\x8d\xbe\xef\x01H?\xcf\x98L?r\x17\x01\xbf\xc0\xa4\x07?4\xedq\x90'
b'\x85=T\xc9o\x02\x00T\x00')
Результат разбора:
'A1': 0.9584174156188965,
{'A2': 'qxqh',
'A3': -0.9253086447715759,
'A4': -432625247,
'A5': 44,
'A6': 4283999860,
'A7': [{'B1': {'C1': 11098098038662638820, 'C2': -27067},
'B2': [-0.4693654179573059,
-0.42524829506874084,
-0.23330679535865784,
-0.6274195313453674,
-0.8253278136253357,
-0.22414733469486237],
'B3': 1765669265477722927,
'B4': {'D1': 243, 'D2': [10, -93]}},
'B1': {'C1': 2685319205049193656, 'C2': 27563},
{'B2': [0.9409658312797546,
-0.2768307626247406,
0.7812795042991638,
0.7992066740989685,
-0.5042639970779419,
0.5298576354980469],
'B3': 14507287943530540340,
'B4': {'D1': 111, 'D2': [-107, 51]}}],
'A8': -49}
Пример 2
Двоичные данные:
b'>OQGS\xb3\x15\xba\xbdxkpf\xbc\x80\x02?\xa0\x87G\xdf\xa64\xb20\xef%\x00'
(b"\x00\x00V\x00\x00\x00\xfeI`\xfe\xccw'/\xdc\xd6\x00\xbc\xd7\x8e\x1f\x84\xbdT"
b'\x1aU\xbf\xb78\xd0\xbe2!\xb9\xbe\xab\x93\x06\xbfleU\xbf\\\xa9Gq\x1b'
b'\x89\xe5\xbb\xf9\x02\x00#\x004\xddwYhm!/_\x94\n\x1e$\xe3z?\xf5\xadO\xbf'
b'\xcd\xd6I\xbe\xc5\xa4d?\x1e\x1eL\xbfz\x80{?[l\xb2\x9a\x95\xf8\xcc\xed'
b'm\x02\x00T\x00')
Результат разбора:
'A1': -0.09086170047521591,
{'A2': 'xkpf',
'A3': 0.5097768306732178,
'A4': -548960352,
'A5': 166,
'A6': 4012945972,
'A7': [{'B1': {'C1': 60477740099816702, 'C2': -10308},
'B2': [-0.06451331079006195,
-0.8324329853057861,
-0.40668269991874695,
-0.36158138513565063,
-0.5256907343864441,
-0.8335788249969482],
'B3': 13539378605716908380,
'B4': {'D1': 249, 'D2': [73, 96]}},
'B1': {'C1': 10691315861016828279, 'C2': 7690},
{'B2': [0.9800283908843994,
-0.8112481236457825,
-0.1971084624528885,
0.8931391835212708,
-0.7973345518112183,
0.9824291467666626],
'B3': 17135344003667094619,
'B4': {'D1': 109, 'D2': [52, -35]}}],
'A8': -2}
Задача №12
Реализовать разбор двоичного формата данных. Данные начинаются с сигнатуры 0x4a 0x52 0x4d 0xc4
, за которой следует структура
A. Порядок байт: от младшего к старшему. Адреса указаны в виде смещений от начала данных. В решении предлагается использовать модуль
struct.
Структура A:
Поле | Описание |
---|---|
1 | int16 |
2 | Размер (uint32) и адрес (uint32) массива структур B |
Структура B:
Поле | Описание |
---|---|
1 | Массив char, размер 5 |
2 | Структура C |
3 | int32 |
4 | Адрес (uint16) структуры D |
5 | int64 |
Структура C:
Поле | Описание |
---|---|
1 | int64 |
2 | int32 |
3 | double |
Структура D:
Поле | Описание |
---|---|
1 | Массив double, размер 2 |
2 | Массив int16, размер 5 |
3 | float |
4 | int16 |
5 | float |
6 | int8 |
Ниже показаны примеры разбора двоичного формата.
Пример 1
Двоичные данные:
b'JRM\xc4=\xcc\x02\x00\x00\x00X\x00\x00\x00H\xfc\xc5\xdf\xbfp\xed\xbf\xa0\xea'
(b'\xf4\xb2\x99\x10\xd7?\x1d\x7f\xe9\xc7\x19\xe7\xb9\xf4\x07\x04UZ\xa9\xbe'
b'p\xa3\xce\x10\xaa\xbd\xe2\xac\xeaCy\xfdJ\xdc? G\xa6\xd2c[\xbb?\xb6'
b'\x8e\x13\xdf\xdf\xc7#\x9b\xb4;]\xfa/\xbe\x07C\x8d\x04\xa3\xbe\nyihs'
b'h\xd6\x17m\x86\xbf\xc3\x81LeY\xffq\xb43\x94\xaf\xeb=\xe2\xbf\x19!C'
b'\xc1\x0e\x00<\xc0\x16a\xb2\x8a\x81\xb9yfdni\xd7\x92\xc4\xefu\x81\xf5\x81'
b'K\xd4\xee0\xb4H\x1c\xd9\x8cG\xd2\xbfF\xe0V\xa03\x00\xe1%\xba\x9a\x92\xd7'
b'\x1aw')
Результат разбора:
'A1': -13251,
{'A2': [{'B1': 'yihsh',
'B2': {'C1': 5512902646239664086,
'C2': 1912559973,
'C3': -0.5700586728358901},
'B3': -1052565223,
'B4': {'D1': [-0.920013367707619, 0.36038820720902187],
'D2': [32541, -14359, -6375, -2887, 1031],
'D3': -0.33076730370521545,
'D4': -23696,
'D5': -0.08303986489772797,
'D6': -30},
'B5': -5079626405959516100},
'B1': 'yfdni',
{'B2': {'C1': -9082210729988943145,
'C2': 820958283,
'C3': -0.2856170768947195},
'B3': -1604919226,
'B4': {'D1': [0.4420770344001237, 0.10686324971018424],
'D2': [-29002, -8429, -14369, -25821, 15284],
'D3': -0.17185349762439728,
'D4': 17159,
'D5': -0.31839409470558167,
'D6': 10},
'B5': 8582409064568989153}]}
Пример 2
Двоичные данные:
b'JRM\xc4\xd3S\x02\x00\x00\x00X\x00\x00\x00r-\x00\x92Mf\xef?\x00\xfe'
(b'm\xb0\n\xb8\xc1?k\xff~T\x03\xc5\xf3\xf3\x80\x81|\xf8r>\xc5\xb8\xb9\x1b'
b'\xa6\xbe\xad<\xfb\xb7\xcf\x8d:\xe9?\xde\x02\xa0\xcb D\xe9\xbf\xe2'
b'\xa2\x93\xa5\xd9\xdd\xf02y\xcbec7?\xbef1\x9eC?/vvvlq\x15&\xc3\xdep\x9e,'
b'\xcb\xf2\xa7\xe4`\xf4\x97\xa1\xf00\xe6\xe4?\xf5\x13\xa1\x1c\x0e\x00\xb3'
b'\xc7\x85\x86!\xf9\xed\xffwvadqt\xec\x0f\xba\xc0_\xd9\xb6Y\x82k\x81\xc2%\xcdS'
b'_\xa5\xe2?\xce8\xf8\xa93\x00k\x11\xe6yFo<!')
Результат разбора:
'A1': 21459,
{'A2': [{'B1': 'vvvlq',
'B2': {'C1': -3806493377424054763,
'C2': 1625597938,
'C3': 0.6530995082691775},
'B3': 480318453,
'B4': {'D1': [0.9812381602836651, 0.1384290086243567],
'D2': [-149, 21630, -15101, -3085, -32384],
'D3': 0.23727601766586304,
'D4': -18235,
'D5': -0.3244302570819855,
'D6': -83},
'B5': -5074102171351117},
'B1': 'wvadq',
{'B2': {'C1': -5271076607500489612,
'C2': -2123660711,
'C3': 0.5826870571847211},
'B3': -1443350322,
'B4': {'D1': [0.7883976990704933, -0.7895664193202625],
'D2': [-23838, -23149, -8743, 13040, -13447],
'D3': 0.7163603901863098,
'D4': 26302,
'D5': 0.764132559299469,
'D6': 47},
'B5': 2394911450337775979}]}
Задача №12
Реализовать разбор двоичного формата данных. Данные начинаются с сигнатуры 0xfd 0x56 0x4a 0x58 0x57
, за которой следует
структура A. Порядок байт: от младшего к старшему. Адреса указаны в виде смещений от начала данных. В решении предлагается использовать
модуль struct.
Структура A:
Поле | Описание |
---|---|
1 | int8 |
2 | Структура B |
3 | Структура C |
4 | uint64 |
5 | int64 |
Структура B:
Поле | Описание |
---|---|
1 | uint32 |
2 | int32 |
3 | uint16 |
4 | Размер (uint32) и адрес (uint32) массива char |
Структура C:
Поле | Описание |
---|---|
1 | Размер (uint32) и адрес (uint32) массива структур D |
2 | float |
3 | Структура E |
4 | int64 |
Структура D:
Поле | Описание |
---|---|
1 | Массив uint16, размер 4 |
2 | int8 |
Структура E:
Поле | Описание |
---|---|
1 | Массив int32, размер 7 |
2 | int8 |
3 | Размер (uint16) и адрес (uint32) массива float |
4 | int64 |
Ниже показаны примеры разбора двоичного формата.
Пример 1
Двоичные данные:
b'\xfdVJXW\xd9\xfe2\xd2q\x18\xff2\x95B\xdd\x03\x00\x00\x00g\x00\x00\x00'
(b'\x03\x00\x00\x00j\x00\x00\x00\xddzb\xbf1r(\r\xddo\xdf{\xb4\xb08\x05\xdd]\rT'
b"S@$&\x90\xbdC\xd2'\xb0e\x90\xbd\x08\x00\x85\x00\x00\x00\xea\x16\xedg~D\x93@O"
b'\xc4n\x9f0\x8a1\xab\x03\xc8@\x10i\xaf\x99\xca\xa3%\xc7\xe4\xaa\xe8\xc3\x1fv'
b'uk!\x7f\xe0$`CYw\xa6\xca\xac\x96\xce\x15\xbc\xf3y\xc9\xff\xac\x0b\xc1'
b'\xdf\x99\xcb\xa4\xf9\x99\xb9P\xbc\xe8\rw\xbf\xb6\xc6\x18\xbf\xb2\xfe\xa2'
b'\xbe\xa7+\x00?c\x05\xcd=\x0f[:\xbf\xf0\xf1\x90\xbe')
Результат разбора:
'A1': -39,
{'A2': {'B1': 1909601022, 'B2': -1791820008, 'B3': 56642, 'B4': 'vuk'},
'A3': {'C1': [{'D1': [32545, 9440, 17248, 30553], 'D2': -90},
'D1': [44234, 52886, 48149, 31219], 'D2': -55},
{'D1': [44287, 49419, 39391, 42187], 'D2': -7}],
{'C2': -0.8846872448921204,
'C3': {'E1': [220754481,
2078240733,
87601332,
1410162141,
639909971,
-767312496,
-1872383961],
'E2': -67,
'E3': [-0.012739562429487705,
-0.9650559425354004,
-0.5967820882797241,
-0.3183494210243225,
0.500666081905365,
0.10010793060064316,
-0.7279519438743591,
-0.2830958366394043],
'E4': 4653138149704013546},
'C4': -6110951277927152561},
'A4': 14598892532877281283,
'A5': 2288928856314684835}
Пример 2
Двоичные данные:
b'\xfdVJXW\x90\xd3\x82\xc1Q[\x82\x83\xa4:\xad\x03\x00\x00\x00g\x00\x00\x00'
(b'\x03\x00\x00\x00j\x00\x00\x00\xbf\xb7Y?\xd1<\x94aNqX\x1f\xbee\xf7\xa5'
b'l\xc2\xd6\xc7\x1c\xcc*{\x1dJw)\xa2\xc6\x00\xa8\x1e\x08\x00\x85'
b'\x00\x00\x00\xa2\xcfZ:pK\xfd\x9e\x18|\x15\xe5\x0bu\x92h\xed\xa5\xe0j"'
b"h'd\x06b\xee+\xdfvj\xdbter4{\xd9\x18F.]J\xa1\xc9\xf5\x9fUF\xa4\x03\x8b\xc7"
b'\x1etoe\xb0\xd0\x9b{\xbe.\xebE\xbf\xa2Ii\xbd+\x02\xd8\xbd\xf2\x03\xdc>\x022#'
b'?\xdeyR\xbf7\xcff?6mh\xbf')
Результат разбора:
'A1': -112,
{'A2': {'B1': 1371636435, 'B2': -1534885285, 'B3': 44346, 'B4': 'ter'},
'A3': {'C1': [{'D1': [31540, 6361, 11846, 19037], 'D2': -95},
'D1': [62921, 21919, 42054, 35587], 'D2': -57},
{'D1': [29726, 25967, 53424, 31643], 'D2': -66}],
{'C2': 0.8504599928855896,
'C3': {'E1': [1637104849,
525889870,
-1510513218,
-942226836,
2066402332,
695683613,
-1476344158],
'E2': 30,
'E3': [-0.7731198072433472,
-0.05695498734712601,
-0.10547288507223129,
0.4297176003456116,
0.6374818086624146,
-0.8221720457077026,
0.9015993475914001,
-0.9079164266586304],
'E4': -6990348101221691486},
'C4': 7535213820492741656},
'A4': 7216851424915793389,
'A5': -2636163930985176570}
Задача №12
Реализовать разбор двоичного формата данных. Данные начинаются с сигнатуры 0x54 0x47 0x4c
, за которой следует структура A.
Порядок байт: от старшего к младшему. Адреса указаны в виде смещений от начала данных. В решении предлагается использовать модуль
struct.
Структура A:
Поле | Описание |
---|---|
1 | double |
2 | uint16 |
3 | float |
4 | Массив адресов (uint32) структур B, размер 2 |
5 | int32 |
6 | Структура C |
7 | Структура D |
Структура B:
Поле | Описание |
---|---|
1 | Размер (uint32) и адрес (uint16) массива char |
2 | int32 |
3 | int32 |
Структура C:
Поле | Описание |
---|---|
1 | uint8 |
2 | uint16 |
3 | Массив int64, размер 4 |
Структура D:
Поле | Описание |
---|---|
1 | uint32 |
2 | int64 |
3 | float |
4 | uint64 |
5 | uint32 |
6 | uint64 |
7 | int64 |
8 | Массив int16, размер 4 |
Ниже показаны примеры разбора двоичного формата.
Пример 1
Двоичные данные:
b'TGL?\xe2\xa9\xa4-\xcfZ\x86\x9e\xc4?8\xbd\x1f\x00\x00\x00y\x00\x00\x00'
(b'\x8a\xd929X\x1a\xfa\x1bb\xe4\xe4\xaf\xe3\xb8?\xaf\xa4\x1bW\xfb&\x81\xec5'
b'1\xca\xb3\xa9\xc4\xbe\x19\xa2R\x83\xc12\xa4"\x1b\xf0\xc8\xdch\x8a\xfa(\x13r'
b'\xa4\xc5\xd1\x94\xbe\x97\x05\xf2\xc3\xfb\xb4;\x87\xd4b\xc5\x91\x11f\x94'
b'\xddh\xd9\x1e\x86\x8b\xbfc\xf4Q\xbah\xb5`l}\x9e\xaaDw\xd4\xc3\x1bRpuco'
b'l\x00\x00\x00\x05\x00tos}\x90\xa9\xef\xbf\x84xyo\x00\x00\x00\x03\x00\x87'
b'\xe5\xaaw\xc5B\xe2z\xab')
Результат разбора:
'A1': 0.5832081694341731,
{'A2': 40644,
'A3': 0.7216357588768005,
'A4': [{'B1': 'pucol', 'B2': 1869839760, 'B3': -1443905660},
'B1': 'xyo', 'B2': -441813051, 'B3': 1122138795}],
{'A5': -651019944,
'A6': {'C1': 26,
'C2': 64027,
'C3': [7126071954497879983,
-6621602090923725771,
3587877594885659042,
5945808356305411056]},
'A7': {'D1': 3369887882,
'D2': -421065182047514220,
'D3': -0.2949672341346741,
'D4': 14122079224325235397,
'D5': 2433836692,
'D6': 15954240405089533795,
'D7': -841686696459211651,
'D8': [-24918, 17527, -11069, 6994]}}
Пример 2
Двоичные данные:
b'TGL\xbf\xe1\xca\xac\xdd;\xae*\xb9\xbb\xbe$\x17\xaa\x00\x00\x00w\x00\x00\x00'
(b'\x88\x0eT\xd9\x9d\x1df\x8b>\x7fX\xc4\t\xc7\x1c\xbe\x91\xd0\xd2\x07'
b'\x0c\t\xf1\x82\xbb\x87\x0f\xe8`\xff\xc3\x15\xd4\xc1.\xd6O\x89\x0b\x81'
b'\xf2\x88\xe2\x17\xa2\xf4\x91,\xcb\x8b\xfa\xb0?z\xd0br\x0cB.\x10\xef\xc4['
b'6\x99\xb3pr\xa8\x13\xa7\xe2\xdcc\xafN~__\x18\x07\x95\x1f8N\xfbn\r\xd4&\xb0'
b'uya\x00\x00\x00\x03\x00t\xe5\x08D\x8fM\xdeC\xe8tpy\x00\x00\x00\x03'
b'\x00\x85\x03\x90Q\xd0\x9b\xf3\xcb\x14')
Результат разбора:
'A1': -0.5559906311950205,
{'A2': 47547,
'A3': -0.16024652123451233,
'A4': [{'B1': 'uya', 'B2': -452442993, 'B3': 1306412008},
'B1': 'tpy', 'B2': 59789776, 'B3': -1678521580}],
{'A5': 240441757,
'A6': {'C1': 29,
'C2': 26251,
'C3': [4503415751394663614,
-7939615215345602174,
-4933957376026885355,
-3116157969171412095]},
'A7': {'D1': 4069057047,
'D2': -6704574323668288848,
'D3': 0.979742169380188,
'D4': 8218016185664390235,
'D5': 916042608,
'D6': 8261875128197735343,
'D7': 5656063044053603615,
'D8': [14414, -1170, 3540, 9904]}}
Задача №12
Реализовать разбор двоичного формата данных. Данные начинаются с сигнатуры 0x43 0x48 0x54 0xa8
, за которой следует структура
A. Порядок байт: от старшего к младшему. Адреса указаны в виде смещений от начала данных. В решении предлагается использовать модуль
struct.
Структура A:
Поле | Описание |
---|---|
1 | Адрес (uint16) структуры B |
2 | Размер (uint32) и адрес (uint16) массива char |
3 | Структура C |
4 | int8 |
5 | Массив структур D, размер 6 |
6 | Массив int16, размер 4 |
Структура B:
Поле | Описание |
---|---|
1 | uint32 |
2 | uint32 |
Структура C:
Поле | Описание |
---|---|
1 | uint8 |
2 | uint16 |
3 | Размер (uint32) и адрес (uint16) массива char |
4 | int32 |
5 | double |
Структура D:
Поле | Описание |
---|---|
1 | float |
2 | int16 |
Ниже показаны примеры разбора двоичного формата.
Пример 1
Двоичные данные:
b'CHT\xa8\x00N\x00\x00\x00\x02\x00VP\xad\x92\x00\x00\x00\x03\x00X\xe0*\x9b'
(b'\xa4?\xeaS\xe0?\xd9X.\x98\xbf*\xc8\x1eW\xa0\xbfZ(@\xf0\x08\xbfst\r}\xd1'
b'\xbfI\x85\x18\xae\xe2?qK\x84\x8a(>\x83\xbe\x1c\xf9\xc6B\xd3\xeee\\\xf8'
b'\x7f\x97d\xc0I\x8e\xf5/\xc2\x8empbrl')
Результат разбора:
'A1': {'B1': 1690323342, 'B2': 4113547918},
{'A2': 'mp',
'A3': {'C1': 80,
'C2': 44434,
'C3': 'brl',
'C4': -534078556,
'C5': 0.8227387663889709},
'A4': -104,
'A5': [{'D1': -0.6671160459518433, 'D2': 22432},
'D1': -0.8521766662597656, 'D2': -4088},
{'D1': -0.9509895443916321, 'D2': 32209},
{'D1': -0.7871870994567871, 'D2': -20766},
{'D1': 0.9425585269927979, 'D2': -30168},
{'D1': 0.25730979442596436, 'D2': -1594}],
{'A6': [17107, -4507, 23800, 32663]}
Пример 2
Двоичные данные:
b'CHT\xa8\x00N\x00\x00\x00\x03\x00V\xd8Ir\x00\x00\x00\x04\x00Y\xd6\x1e<'
(b'\x10?\xe5Pm0)0\xa43=\x8e\x9951\xe7?x\x025\xd5z\xbf&\\\xfdZ\x13?0\x16\xf5'
b'\xe8\xfc?\x03\xd183\x08\xbfQ.\xff4\x10\x80\x1a\xcd\xbe\xc3D\x0c&\xb6\x8e'
b'm\xba\xbc"\xfbgvfhjrah')
Результат разбора:
'A1': {'B1': 3062787514, 'B2': 3156409191},
{'A2': 'vfh',
'A3': {'C1': 216,
'C2': 18802,
'C3': 'jrah',
'C4': -702661616,
'C5': 0.666067689956908},
'A4': 51,
'A5': [{'D1': 0.06962815672159195, 'D2': 12775},
'D1': 0.9687836766242981, 'D2': -10886},
{'D1': -0.6498563885688782, 'D2': 23059},
{'D1': 0.687850296497345, 'D2': -5892},
{'D1': 0.5149111747741699, 'D2': 13064},
{'D1': -0.8171233534812927, 'D2': 13328}],
{'A6': [-32742, -12866, -15548, 3110]}
Задача №12
Реализовать разбор двоичного формата данных. Данные начинаются с сигнатуры 0x51 0x51 0x4f 0x52 0x65
, за которой следует
структура A. Порядок байт: от старшего к младшему. Адреса указаны в виде смещений от начала данных. В решении предлагается использовать
модуль struct.
Структура A:
Поле | Описание |
---|---|
1 | int32 |
2 | double |
3 | Адрес (uint32) структуры B |
4 | int16 |
5 | Адрес (uint16) структуры C |
6 | uint16 |
7 | float |
Структура B:
Поле | Описание |
---|---|
1 | uint32 |
2 | Массив char, размер 4 |
3 | int16 |
Структура C:
Поле | Описание |
---|---|
1 | double |
2 | int8 |
3 | Размер (uint32) и адрес (uint32) массива адресов (uint32) структур D |
4 | uint64 |
5 | Адрес (uint32) структуры E |
Структура D:
Поле | Описание |
---|---|
1 | uint32 |
2 | Массив uint32, размер 5 |
3 | int8 |
4 | int8 |
5 | float |
6 | uint8 |
Структура E:
Поле | Описание |
---|---|
1 | uint64 |
2 | uint16 |
3 | Размер (uint32) и адрес (uint32) массива float |
4 | uint64 |
Ниже показаны примеры разбора двоичного формата.
Пример 1
Двоичные данные:
b'QQORe\x1c6\x93p\xbf\xe8\x90\xc6\xd3\xc2\xb6:\x00\x00\x00\x1f(\xf4\x00'
(b'\x91\xc0\xab\xbf5qM\xec\xd7\xa6\xbfvrbcIS\x08\xd8\x93\xea\x89m<\xea\x88l\x90'
b'}\x12\xa9\x1b\xf5\xc7G\x07\xfdEg\x9b\x847\xbc\xbe\x89\xb3\xf2\r\xd8\xf2-\xb4'
b'\xabQ6\xc3\xe4P\xfci\x8bgZ\x15\x97]\xe9\x89\x96\x8a\x89\xafo>\xbe\xb6'
b'j\xf6r\x00\x00\x00)\x00\x00\x00H>\xce\x1f\x9a?g\xff4\xb8\x14\xab\x9cl'
b'\xe8\x1fR\x9a=\x00\x00\x00\x02\x00\x00\x00o^\xe5T@|H(h?\xe0\xc7\xc13W\xab'
b'r\xb0\x00\x00\x00\x02\x00\x00\x00g\x8a\xe6\x06\xa7\xb4\xc2\x01\xa1\x00\x00'
b'\x00w')
Результат разбора:
'A1': 473338736,
{'A2': -0.7676729331921657,
'A3': {'B1': 3973555903, 'B2': 'vrbc', 'B3': 18771},
'A4': 10484,
'A5': {'C1': 0.5243841173918169,
'C2': -80,
'C3': [{'D1': 148411370,
'D2': [2305637610,
2288816253,
313072629,
3343321085,
1164417924],
'D3': 55,
'D4': -68,
'D5': -0.2689509987831116,
'D6': 13},
'D1': 3639750068,
{'D2': [2874226371,
3830512745,
2338806293,
2539514249,
2525661615],
'D3': 111,
'D4': 62,
'D5': -0.3562847971916199,
'D6': 114}],
'C4': 10008694539239424417,
'C5': {'E1': 13264415490843352914,
'E2': 39485,
'E3': [0.40258485078811646, 0.9062378406524658],
'E4': 6837964245171710056}},
'A6': 49323,
'A7': -0.7087600827217102}
Пример 2
Двоичные данные:
b'QQOReo~^x?\xdc\x7f\x120\xbb\x8eH\x00\x00\x00\x1f-\xd0\x00\x91\x18\x0c\xbe'
(b"\xe8%I\x15\x9f\x85ihemd'2\xcd\x93\xb6x\x1ce\x00~E\xf9\xe90\x9c\xb4\xe2"
b'\xd4\xe9\x08\xb0\xb0<\x9e\xfd\xdf\x83\x96>\xab\x03\x8b\xeeU\x98>\xc9'
b'\xa9>Y\xca\x8arss\x13\xcc\xc4\x98\xbbG\xdf\xeb\x90\xb8q{\xb7U\xbdK\x156V\x00'
b'\x00\x00)\x00\x00\x00H>F\x98\x9e?[\xec\xc8J\xfaF\xdf|\x1fv\xf0?'
b'\x8e\x00\x00\x00\x02\x00\x00\x00o\xbc \x82a\xe7}\xb9R\xbf\xebK3\xa5\xdf*'
b".\xca\x00\x00\x00\x02\x00\x00\x00g\xff\xa6\x93O\x88 7'\x00\x00\x00w")
Результат разбора:
'A1': 1870552696,
{'A2': 0.4452558017639814,
'A3': {'B1': 362775913, 'B2': 'hemd', 'B3': 10034},
'A4': 11728,
'A5': {'C1': -0.8529299010927553,
'C2': -54,
'C3': [{'D1': 3449009784,
'D2': [476381310,
1174006064,
2629100244,
3909660848,
1017052639],
'D3': -125,
'D4': -106,
'D5': 0.33401140570640564,
'D6': 238},
'D1': 1436040905,
{'D2': [2839435722,
2322756467,
332186776,
3142049771,
2428006779],
'D3': -73,
'D4': 85,
'D5': -0.04958077520132065,
'D6': 86}],
'C4': 18421573295601104679,
'C5': {'E1': 5402708628658419440,
'E2': 16270,
'E3': [0.19394156336784363, 0.8590817451477051],
'E4': 13555978235392407890}},
'A6': 6156,
'A7': -0.45340946316719055}
Задача №12
Реализовать разбор двоичного формата данных. Данные начинаются с сигнатуры 0x51 0x59 0x57 0x41 0x76
, за которой следует
структура A. Порядок байт: от младшего к старшему. Адреса указаны в виде смещений от начала данных. В решении предлагается использовать
модуль struct.
Структура A:
Поле | Описание |
---|---|
1 | int64 |
2 | Размер (uint16) и адрес (uint16) массива char |
3 | Массив структур B, размер 2 |
4 | float |
5 | Адрес (uint16) структуры D |
6 | Адрес (uint16) структуры E |
Структура B:
Поле | Описание |
---|---|
1 | Адрес (uint32) структуры C |
2 | Размер (uint32) и адрес (uint16) массива int32 |
Структура C:
Поле | Описание |
---|---|
1 | uint16 |
2 | uint8 |
3 | Размер (uint16) и адрес (uint32) массива int32 |
Структура D:
Поле | Описание |
---|---|
1 | float |
2 | double |
Структура E:
Поле | Описание |
---|---|
1 | int16 |
2 | float |
3 | uint16 |
4 | Размер (uint16) и адрес (uint16) массива uint8 |
Ниже показаны примеры разбора двоичного формата.
Пример 1
Двоичные данные:
b'QYWAv.\xf3\xd0\xf1UM<\xf7\x04\x00-\x00A\x00\x00\x00\x03\x00\x00\x00J\x00f'
(b'\x00\x00\x00\x03\x00\x00\x00o\x00/\xc5\xe6\xbe{\x00\x8a\x00aiynS\x9c\x19'
b'\xe2\xef\xe7\n(,(Z\xc6\x17\x17\x0f\x0e\x98\x1a\x1a\x04\x001\x00'
b'\x00\x00\xb2\xc2\x83F\\{\x14\x0e\x13,\x15\xb8\xdf\x1cl\xb2\x94\x97'
b'\xbf0\xc9\x15\xa5\x05\xc9z\xccycn~\x04\x00V\x00\x00\x00y\xa4\xf3\x8e\xe6'
b'j \xdfNxQ\xc4\xd1\xe1\x1f?^\x1e~\x96e\xc2\xe1\xbf\x87\xef\x8fp\xbbeM`?'
b'\x9d\xf1\x03\x00\x87\x00')
Результат разбора:
'A1': -631544816214150354,
{'A2': 'aiyn',
'A3': [{'B1': {'C1': 6808,
'C2': 26,
'C3': [-501638061, 671803375, -967170004, 235869975]},
'B2': [1183040178, 236223324, -1206572013]},
'B1': {'C1': 28259,
{'C2': 126,
'C3': [-1301537569, 817862548, 94705097, 2043443913]},
'B2': [-1896635271, -551523610, -1001293746]}],
'A4': -0.45072314143180847,
'A5': {'D1': 0.6245394349098206, 'D2': -0.5549800814923846},
'A6': {'E1': -17552,
'E2': 0.8761809468269348,
'E3': 61853,
'E4': [135, 239, 143]}}
Пример 2
Двоичные данные:
b'QYWAv\xce\x8cM\r\xaf\xd2\xe8\xc4\x05\x00-\x00B\x00\x00\x00\x04\x00\x00'
(b'\x00K\x00c\x00\x00\x00\x04\x00\x00\x00l\x00\x8a\xb9b?|\x00\x8e\x00fjfznc\x11'
b'\xedbn5\x9e\xf8\xf1\xec\xf9Y\xa0(\xbd~A\xe9\xb1\x04\x002\x00\x00\x00\x16'
b'\xe9\x88\xfe\xa4\xfaV\xf8\xb7\xb4\x9e\xf4\x86\x8a\xd0N\xe3\x11\xd4\xa4\xc3'
b'I6\x9f~:t\x02\x00[\x00\x00\x00K\xd4\x8c6\x05\xdb\xa3\xc6\x04v\xca$fe\x0f\x8c'
b'\x16\xbc\x96\xbe\xd8\xcf\x90\x0c\xe9\n\xca?_\xcbZ\xc1.\xeb8\xf7a\xcc\xd0>'
b'\x0e\xb5\x06\x00\x88\x00')
Результат разбора:
'A1': -4257921798394508082,
{'A2': 'fjfzn',
'A3': [{'B1': {'C1': 59713,
'C2': 177,
'C3': [1659703651, -123849362, 1509551345, 2126325920]},
'B2': [-24581866, -128517468, -190925641, 1322289798]},
'B1': {'C1': 14974, 'C2': 116, 'C3': [-1529605661, -1623832125]},
{'B2': [915199051, -962340091, 617248260, -1945148058]}],
'A4': 0.8856436014175415,
'A5': {'D1': -0.29440373182296753, 'D2': 0.20345795739706207},
'A6': {'E1': -2248,
'E2': 0.4078092873096466,
'E3': 46350,
'E4': [95, 203, 90, 193, 46, 235]}}
Задача №12
Реализовать разбор двоичного формата данных. Данные начинаются с сигнатуры 0x59 0x4b 0x4a 0x89
, за которой следует структура
A. Порядок байт: от младшего к старшему. Адреса указаны в виде смещений от начала данных. В решении предлагается использовать модуль
struct.
Структура A:
Поле | Описание |
---|---|
1 | uint64 |
2 | uint8 |
3 | Массив char, размер 5 |
4 | uint8 |
5 | int32 |
6 | Адрес (uint16) структуры B |
7 | Структура D |
8 | uint64 |
Структура B:
Поле | Описание |
---|---|
1 | uint32 |
2 | uint64 |
3 | Размер (uint32) и адрес (uint16) массива адресов (uint16) структур C |
4 | int64 |
5 | int64 |
Структура C:
Поле | Описание |
---|---|
1 | uint32 |
2 | uint16 |
3 | Массив float, размер 4 |
Структура D:
Поле | Описание |
---|---|
1 | int16 |
2 | uint16 |
3 | uint16 |
4 | int32 |
5 | uint8 |
6 | int16 |
7 | Размер (uint32) и адрес (uint16) массива float |
Ниже показаны примеры разбора двоичного формата.
Пример 1
Двоичные данные:
b'YKJ\x89\xb5H\x83aF\xcb\x1b\xc3\xf4jciej\n\xed\xd3I8|\x00L/\xe4[O\xb3\x8d'
(b'\xf8M~\x16\xef\x12\x03\x00\x00\x00\x9e\x00#\xbc0\xeeoV\xfc9\xcb\xfblH'
b'\xafx\xc5L7\xbf\x17\xa7\xbb>\xec\xde^>\xf3\x16Q?\xd6w\xdbR\x90f&B\x0b\xbd'
b'&hJ>\x1b\x1c%\xbf\xfb\xe3e\xbf\xfb\xb75\xa3\xca\x14\n]G?\x81\x1c\xc0>\xcbL'
b'\xf6>\xab\t\xb6>4\x00J\x00`\x00\xcaR^{0C\xa0\x8d;\xe8\x8d_\x03\x00\x00\x00'
b'v\x00\xed\xe5\xf8\xc2\x84\xc2n$[\\\xc13\xcf\xa0wh\x02\x05\xff\xbd\t\xb7'
b'b?D\xd3\x8a\xbe')
Результат разбора:
'A1': 14059054164911278261,
{'A2': 244,
'A3': 'jciej',
'A4': 10,
'A5': 944362477,
'A6': {'B1': 2069779146,
'B2': 6885414747796161328,
'B3': [{'C1': 1215101899,
'C2': 30895,
'C3': [-0.7160151600837708,
0.36650916934013367,
0.2176472544670105,
0.8167564272880554]},
'C1': 1390114774,
{'C2': 26256,
'C3': [-0.033998630940914154,
0.19766291975975037,
-0.6449601054191589,
-0.8980099558830261]},
'C1': 2738206715,
{'C2': 5322,
'C3': [0.7787634134292603,
0.375217467546463,
0.4810546338558197,
0.35554251074790955]}],
'B4': 2625249508266141165,
'B5': 7527662113960057947},
'A7': {'D1': 12108,
'D2': 23524,
'D3': 45903,
'D4': 2119039117,
'D5': 22,
'D6': 4847,
'D7': [-0.12452127039432526, 0.8856053948402405, -0.2711430788040161]},
'A8': 4178309593030507555}
Пример 2
Двоичные данные:
b'YKJ\x89\xd4\x0b$\x1d\x8a\xdce\xf8\xe7udatk.!\xb0\xde<d\x00\xea\xe5\x92'
(b'\x88\xa7\x07\x14\xb64l\xe3\xe4B\x02\x00\x00\x00\x86\x00\xba\x9c\xb8\xca'
b's\xbf D\xf5J\xec4\xc4\xd9;Q\x04?f\x80M>.o(\xbf\x94\x80\xd3=}\x9f\xf0z?\x98'
b'j3}?VW{?\xd0\x1e\xae\xbe\xbe\x9ce?4\x00J\x00\xadcTwX\\\xbc\x03rz\xd9p'
b'\x02\x00\x00\x00`\x00\xd4\xf4\x84\xea\x16\x1a\xb2\x0c\xf7\xea\xb6\x97P\x7f'
b'\xd7\xa3l\x89\xbc>\xc7\x85n\xbf')
Результат разбора:
'A1': 17898954779806403540,
{'A2': 231,
'A3': 'udatk',
'A4': 46,
'A5': 1021227041,
'A6': {'B1': 2002019245,
'B2': 8131665232301677656,
'B3': [{'C1': 887900917,
'C2': 55748,
'C3': [0.5168644785881042,
0.20068511366844177,
-0.6579464673995972,
0.10327258706092834]},
'C1': 2062589821,
{'C2': 38975,
'C3': [0.9890657663345337,
0.9818013906478882,
-0.34007883071899414,
0.8969229459762573]}],
'B4': 914822360035816660,
'B5': -6640699141415048457},
'A7': {'D1': -6678,
'D2': 34962,
'D3': 1959,
'D4': 1815393812,
'D5': 227,
'D6': 17124,
'D7': [0.3682359457015991, -0.9317287802696228]},
'A8': 4909134097877081274}
Задача №12
Реализовать разбор двоичного формата данных. Данные начинаются с сигнатуры 0x23 0x51 0x56 0x4f
, за которой следует структура
A. Порядок байт: от младшего к старшему. Адреса указаны в виде смещений от начала данных. В решении предлагается использовать модуль
struct.
Структура A:
Поле | Описание |
---|---|
1 | int16 |
2 | Массив адресов (uint16) структур B, размер 4 |
3 | uint64 |
4 | Адрес (uint16) структуры C |
Структура B:
Поле | Описание |
---|---|
1 | float |
2 | float |
3 | float |
4 | Массив char, размер 6 |
5 | int64 |
Структура C:
Поле | Описание |
---|---|
1 | int64 |
2 | float |
3 | Структура D |
4 | Структура E |
5 | float |
Структура D:
Поле | Описание |
---|---|
1 | uint8 |
2 | int16 |
3 | int8 |
Структура E:
Поле | Описание |
---|---|
1 | int32 |
2 | uint8 |
3 | Массив uint8, размер 4 |
4 | Размер (uint16) и адрес (uint32) массива uint8 |
Ниже показаны примеры разбора двоичного формата.
Пример 1
Двоичные данные:
b'#QVO\x86\xb0\x18\x002\x00L\x00f\x00\xef\x85f~\xf5T\xa1\x98\x82\x00'
(b'\xc0\xb9\xd7\xbe\x85\xfe\x96>\x9c\xc2\xfe\xbegykrhb\xca\xe8\xf9_\x1d\xb2'
b'n\x16b\xb9\x12\xbe\xd2\xc4\\?c\xd7k\xbfjtsgsf\xbd\xc0\x90\x91'
b'\x84\xc3\xef\xfe~a#\xbf\xc5\x92e?\x82\x83\xdc>gbeaatR\xc9\x0f?mo\x1fM\x9cp'
b'\xe0\xbe\xdf\x99\xc3\xbe\xf2\x9cF?ozvytx\x1c\x84\x19\xabOK?\xdd;\x87g\x0f'
b'\xb6\x0c\xc5W\xcffeT\x05?\xfc\xf6\xd2t\x0f!\xa2\x80\xaet;\xc2\xc9\x02'
b'\x00\x80\x00\x00\x00\xd6,\x10>')
Результат разбора:
'A1': -20346,
{'A2': [{'B1': -0.4213390350341797,
'B2': 0.29491057991981506,
'B3': -0.497578501701355,
'B4': 'gykrhb',
'B5': 1616425155506596042},
'B1': -0.14328530430793762,
{'B2': 0.8623782396316528,
'B3': -0.9212552905082703,
'B4': 'jtsgsf',
'B5': -76627694496726851},
'B1': -0.6382063627243042,
{'B2': 0.8967707753181458,
'B3': 0.43069082498550415,
'B4': 'gbeaat',
'B5': 5557282980198598994},
'B1': -0.4383591413497925,
{'B2': -0.3820333182811737,
'B3': 0.7758322954177856,
'B4': 'ozvytx',
'B5': -2504200062249630692}],
'A3': 10998165178379830767,
'A4': {'C1': 7408236415881187175,
'C2': 0.5208190083503723,
'C3': {'D1': 252, 'D2': -11530, 'D3': 116},
'C4': {'E1': -2136858353,
'E2': 174,
'E3': [116, 59, 194, 201],
'E4': [59, 135]},
'C5': 0.14079603552818298}}
Пример 2
Двоичные данные:
b'#QVO\xb2\x0f\x18\x002\x00L\x00f\x00z\xcd\x15\xe0\xb1\xd4\x977\x83\x00'
(b'\x1a\x99c\xbf\xfdip?`!\xe2>kofait\xf4\x8d:\xd0xT\xce\x01\\\x17=?W\xf2'
b'?\xbe\xac\x965\xbfhfhban;f;.\xeel\x04k\xfe\xea\xec=\xa3:6\xbd\x80Y$?ipbnisZn'
b'H\x1b\xaf\xa7\x85\xfdN\x13s?\xd3E\x82>f3\x0c\xbejcpstm\xe2\x04\xeb*'
b"\t\xef\xfey\xde\x95S\xca\xa5\x1c'X\x02\xa0\x83\x1b+\x9d>\xdf\x1cs\xd4\xcb"
b'JbU\xa1\xf6e\xe9+\x03\x00\x80\x00\x00\x00.\xd1\x88=')
Результат разбора:
'A1': 4018,
{'A2': [{'B1': -0.8890548944473267,
'B2': 0.9391172528266907,
'B3': 0.44166088104248047,
'B4': 'kofait',
'B5': 130134317106630132},
'B1': 0.7386376857757568,
{'B2': -0.18744789063930511,
'B3': -0.7093303203582764,
'B4': 'hfhban',
'B5': 7711408232198792763},
'B1': 0.11568258702754974,
{'B2': -0.04448951408267021,
'B3': 0.6419906616210938,
'B4': 'ipbnis',
'B5': -178552239692419494},
'B1': 0.94951331615448,
{'B2': 0.25443896651268005,
'B3': -0.13691481947898865,
'B4': 'jcpstm',
'B5': 8790726345327576290}],
'A3': 4005904254003170682,
'A4': {'C1': -8962160680830720566,
'C2': 0.3069694936275482,
'C3': {'D1': 223, 'D2': 29468, 'D3': -44},
'C4': {'E1': 1432505035,
'E2': 161,
'E3': [246, 101, 233, 43],
'E4': [222, 149, 83]},
'C5': 0.06680522859096527}}
Задача №12
Реализовать разбор двоичного формата данных. Данные начинаются с сигнатуры 0xd8 0x53 0x48 0x45
, за которой следует структура
A. Порядок байт: от старшего к младшему. Адреса указаны в виде смещений от начала данных. В решении предлагается использовать модуль
struct.
Структура A:
Поле | Описание |
---|---|
1 | Размер (uint16) и адрес (uint32) массива структур B |
2 | Адрес (uint32) структуры C |
3 | float |
4 | uint64 |
5 | Структура E |
6 | uint64 |
Структура B:
Поле | Описание |
---|---|
1 | int8 |
2 | int16 |
3 | Массив char, размер 4 |
Структура C:
Поле | Описание |
---|---|
1 | Адрес (uint32) структуры D |
2 | uint16 |
3 | double |
Структура D:
Поле | Описание |
---|---|
1 | Размер (uint16) и адрес (uint16) массива uint32 |
2 | int16 |
3 | uint32 |
Структура E:
Поле | Описание |
---|---|
1 | uint64 |
2 | Массив int16, размер 7 |
3 | uint32 |
Ниже показаны примеры разбора двоичного формата.
Пример 1
Двоичные данные:
b'\xd8SHE\x00\x03\x00\x00\x00<\x00\x00\x00k>\xa3\xc8B\x08\xb4]q\xa0\xa4'
(b'\xd7a\xf6#\xac\xd8\xea\xe44#m\xb7\xac\x18tY_\xe2\xe8\x842\x81\x85\xf3\xdeNNE'
b'\xe91\x86\x1f\x08\xe5x\x1e\x9dN\xe7hgtw%u\x87eqjeW\xd2\xb6itxuvL\xc9'
b'\x7f\x1d\x845Gs\xe7\x0e\xd15\x94\xe0\xcb\x00\x04\x00Q\xc0>\x11O\xe2\x1d\x00'
b'\x00\x00a\x01\xc0?\xec\x12\xa9@\x1d\xb1\xda')
Результат разбора:
'A1': [{'B1': -99, 'B2': 20199, 'B3': 'hgtw'},
{'B1': 37, 'B2': 30087, 'B3': 'eqje'},
{'B1': 87, 'B2': -11594, 'B3': 'itxu'}],
{'A2': {'C1': {'D1': [1984743807, 495203655, 1944522449, 898949323],
'D2': -16322,
'D3': 290447901},
'C2': 448,
'C3': 0.8772779705300835},
'A3': 0.3198872208595276,
'A4': 627228990719186785,
'A5': {'E1': 17736209805168882723,
'E2': [28087, -21480, 29785, 24546, -6012, 12929, -31245],
'E3': 3729673797},
'A6': 16803359152547395614}
Пример 2
Двоичные данные:
b'\xd8SHE\x00\x02\x00\x00\x00<\x00\x00\x00`?M\xaa\x8b\xea\xd0\xa4_e\x8a'
(b'\x8cw\xac\x11\xd4\xeb\xd4U+\x9f\xffw\xb6\xad\xd9\x92\xa2\xfe\xbdx\r)2\xe7'
b'F\xa4\xb9\x05\xfe\xde(\xb9\xe4\x82\xc5\xb7\x17\xccdrmoq4#\xb2vkpz\xdb\x88'
b'\xb5\x98U\x86\xb0\xd9sel\x82\x00\x03\x00Jj\xc9\xa9S\x9b\x02\x00\x00\x00V'
b'\xf0\xc7\xbf\xc7\xa2f\x9c?\x990')
Результат разбора:
'A1': [{'B1': 23, 'B2': -13212, 'B3': 'rmoq'},
{'B1': 52, 'B2': 9138, 'B3': 'vkpz'}],
{'A2': {'C1': {'D1': [3683169688, 1434890457, 1936026754],
'D2': 27337,
'D3': 2840828674},
'C2': 61639,
'C3': -0.1846435797626298},
'A3': 0.8033835291862488,
'A4': 16920204529663380599,
'A5': {'E1': 12398925358472440735,
'E2': [-137, -18771, -9838, -23810, -17032, 3369, 13031],
'E3': 1185200389},
'A6': 18365161109331297719}
Задача №12
Реализовать разбор двоичного формата данных. Данные начинаются с сигнатуры 0x44 0x55 0x43 0x16
, за которой следует структура
A. Порядок байт: от младшего к старшему. Адреса указаны в виде смещений от начала данных. В решении предлагается использовать модуль
struct.
Структура A:
Поле | Описание |
---|---|
1 | int8 |
2 | Массив структур B, размер 6 |
3 | Адрес (uint16) структуры C |
4 | int32 |
5 | uint32 |
6 | Адрес (uint16) структуры D |
Структура B:
Поле | Описание |
---|---|
1 | Массив char, размер 3 |
2 | int32 |
3 | int8 |
4 | Массив uint8, размер 5 |
Структура C:
Поле | Описание |
---|---|
1 | int64 |
2 | uint16 |
3 | int16 |
4 | uint8 |
Структура D:
Поле | Описание |
---|---|
1 | float |
2 | Массив uint8, размер 7 |
Ниже показаны примеры разбора двоичного формата.
Пример 1
Двоичные данные:
b'DUC\x16~ykc{\x119#\xed\xa4\xd7p\xd8\xcazcds\x8d;m~\xa6\x7fM\xd6\xbbu'
(b'wc\x8a\xaeP\x0f\xbf\xd4\xac (8dbz\x8e\xfc\x85G\xba2\x93\xee\xd5\xa2bsu'
b'n\xafLN\x8b\x0e\xefr\xa9\xbdbgi\x9b\x8b\xd0;\x1c(\x03\x06iT_\x00^\xd8\xbe'
b'-\xc0\xee\xed\x05l\x00U5z\x9d~KX\x1b\xfc\x043\x13\x91L\xe3\xa6\xbe8~\xe8l'
b'\xc2i\xbe')
Результат разбора:
'A1': 126,
{'A2': [{'B1': 'ykc',
'B2': 590942587,
'B3': -19,
'B4': [164, 215, 112, 216, 202]},
'B1': 'zcd',
{'B2': 1832619379,
'B3': 126,
'B4': [166, 127, 77, 214, 187]},
'B1': 'uwc', 'B2': 256945802, 'B3': -65, 'B4': [212, 172, 32, 40, 56]},
{'B1': 'dbz',
{'B2': 1199963278,
'B3': -70,
'B4': [50, 147, 238, 213, 162]},
'B1': 'bsu',
{'B2': 1313648494,
'B3': -117,
'B4': [14, 239, 114, 169, 189]},
'B1': 'bgi', 'B2': 1003522971, 'B3': 28, 'B4': [40, 3, 6, 105, 84]}],
{'A3': {'C1': 1970407844154586453, 'C2': 1276, 'C3': 4915, 'C4': 145},
'A4': 767481950,
'A5': 99479232,
'A6': {'D1': -0.3259528875350952, 'D2': [56, 126, 232, 108, 194, 105, 190]}}
Пример 2
Двоичные данные:
b'DUC\x16\xfbodt\xecOJ\xa8SA.\x8b\x9e\xe5ror\xc6$\xfbf\xb6\x9f\x02\xe2,7p'
(b'rg\xfbq\x06\xe7zA\x9dn\x9d\nogp\xcf\x19\x13\xc5\xcb\xbd\x95-\xf1_kda'
b'T\x00\xd0\xe9\x0e\xfa\xb9\xd1>NasdB\xc8r\xf5`\xd7`\x97\xb2\xaf_'
b'\x00\xc7\xc6\x05_\xe7!\x88\xd1l\x00\xb9\x14J\xb9\xe5\xfeU\xf4\t\x0eq]b'
b'\x15\x01D\xbf\xf9\x91\xb8\xa7\xb5\xfd\xa3')
Результат разбора:
'A1': -5,
{'A2': [{'B1': 'odt',
'B2': -1471524884,
'B3': 83,
'B4': [65, 46, 139, 158, 229]},
'B1': 'ror', 'B2': 1727734982, 'B3': -74, 'B4': [159, 2, 226, 44, 55]},
{'B1': 'prg',
{'B2': -419008005,
'B3': 122,
'B4': [65, 157, 110, 157, 10]},
'B1': 'ogp',
{'B2': -988603953,
'B3': -53,
'B4': [189, 149, 45, 241, 95]},
'B1': 'kda',
{'B2': -372244396,
'B3': 14,
'B4': [250, 185, 209, 62, 78]},
'B1': 'asd',
{'B2': -177027006,
'B3': 96,
'B4': [215, 96, 151, 178, 175]}],
'A3': {'C1': -840485492825123655, 'C2': 3593, 'C3': 23921, 'C4': 98},
'A4': 1594214087,
'A5': 3515359719,
'A6': {'D1': -0.7656415104866028, 'D2': [249, 145, 184, 167, 181, 253, 163]}}
Задача №12
Реализовать разбор двоичного формата данных. Данные начинаются с сигнатуры 0x56 0x55 0x45 0x4f 0x39
, за которой следует
структура A. Порядок байт: от младшего к старшему. Адреса указаны в виде смещений от начала данных. В решении предлагается использовать
модуль struct.
Структура A:
Поле | Описание |
---|---|
1 | Структура B |
2 | Структура C |
3 | Размер (uint32) и адрес (uint16) массива структур E |
4 | int8 |
Структура B:
Поле | Описание |
---|---|
1 | float |
2 | double |
3 | uint16 |
4 | uint64 |
5 | float |
Структура C:
Поле | Описание |
---|---|
1 | float |
2 | Массив char, размер 6 |
3 | Структура D |
Структура D:
Поле | Описание |
---|---|
1 | int32 |
2 | Размер (uint32) и адрес (uint32) массива int64 |
3 | uint16 |
Структура E:
Поле | Описание |
---|---|
1 | int32 |
2 | int64 |
3 | Размер (uint32) и адрес (uint16) массива int8 |
4 | int8 |
Ниже показаны примеры разбора двоичного формата.
Пример 1
Двоичные данные:
b'VUEO9\x15\x19\n\xbf\xc80c\x80\xd5\xac\xc4\xbf( \xe1\xb2\xe0L\xa8\x1f\xd4.h'
(b'\x0ci?\xd6\x06,?nprvrz@\xa8\xbf\x84\x04\x00\x00\x00>\x00\x00\x00\x19\\\x02'
b'\x00\x00\x00c\x00\xc8\xa3\xa9\x9d\x0e\x98V"eo\xad\xa7\xb7\x9fvU\xdf\xe7O'
b"\x1e'\xcf\xeeO\xe4Y[)\xdbX\xa1K\xbf\xf2\x1b\x1eU\x82\xae\xdf\xc1a\xf3"
b'\xbb8\x9c\\z\xc8:\x02\x00\x00\x00^\x00\xd9\xff\xa0Y\x80\xd0\xb4\xc0X\x03\xba'
b'\xe2k\x03\x00\x00\x00`\x00\xcf')
Результат разбора:
'A1': {'B1': -0.5394452214241028,
{'B2': -0.16152447480124565,
'B3': 8232,
'B4': 3374356828512105185,
'B5': 0.9103455543518066},
'A2': {'C1': 0.6719793081283569,
'C2': 'nprvrz',
'C3': {'D1': -2067814336,
'D2': [7287482358119115171,
-2353844801878119057,
-1995113536419901465,
-4662455586205901991],
'D3': 23577}},
'A3': [{'E1': 1640095662,
'E2': 4235769987718495219,
'E3': [-14, 27],
'E4': -39},
'E1': -2141609729,
{'E2': 7773980430331589840,
'E3': [30, 85, -126],
'E4': -49}],
'A4': -56}
Пример 2
Двоичные данные:
b'VUEO9\x01%\xc2\xbe\xb0\xd0\xcf\xdc\n\x0e\xda\xbf\xbe\x9c\xb7\x13\x96\xcel'
(b'\x9c\xd9&|\xb2\xdf\xbe\x1f\xd5\xad=hfmthz\xba\xca\xef\x0e\x02\x00\x00'
b'\x00>\x00\x00\x00\xea\x94\x02\x00\x00\x00S\x00E2\x9d&R\xa4\x19\xa8U]\x07'
b'\x05\x97\xad\xd5\xdb"\xe1c\xa2\xdc\xed6\xf3\xe1\xbd&\xbat5V\xa0lZ\x02'
b'\x00\x00\x00N\x00Bp\xd7\xd7\x14A\xac\x83\x03\xe8\xeb\x89\xf3\x03\x00'
b'\x00\x00P\x00\xd9')
Результат разбора:
'A1': {'B1': -0.37918856739997864,
{'B2': -0.40710708202028467,
'B3': 40126,
'B4': 2799440634523816887,
'B5': -0.4369086027145386},
'A2': {'C1': 0.08487915247678757,
'C2': 'hfmthz',
'C3': {'D1': 250596026,
'D2': [6172211482854858034, 2511836158728931165],
'D3': 38122}},
'A3': [{'E1': -1109265610,
'E2': 6515759053022738982,
'E3': [-31, 99],
'E4': 66},
'E1': 349689712,
{'E2': -897927268959802303,
'E3': [-94, -36, -19],
'E4': -39}],
'A4': 69}
Задача №12
Реализовать разбор двоичного формата данных. Данные начинаются с сигнатуры 0xbf 0x47 0x46 0x53
, за которой следует структура
A. Порядок байт: от старшего к младшему. Адреса указаны в виде смещений от начала данных. В решении предлагается использовать модуль
struct.
Структура A:
Поле | Описание |
---|---|
1 | uint8 |
2 | int16 |
3 | Размер (uint16) и адрес (uint16) массива char |
4 | uint8 |
5 | Адрес (uint32) структуры B |
Структура B:
Поле | Описание |
---|---|
1 | Массив адресов (uint16) структур C, размер 2 |
2 | Структура D |
3 | Структура E |
Структура C:
Поле | Описание |
---|---|
1 | int32 |
2 | float |
3 | uint16 |
4 | uint8 |
Структура D:
Поле | Описание |
---|---|
1 | uint16 |
2 | Массив int64, размер 4 |
3 | uint16 |
4 | int32 |
Структура E:
Поле | Описание |
---|---|
1 | int64 |
2 | int8 |
3 | Размер (uint32) и адрес (uint16) массива uint32 |
4 | uint32 |
5 | uint16 |
6 | uint32 |
Ниже показаны примеры разбора двоичного формата.
Пример 1
Двоичные данные:
b'\xbfGFSn\xeb\xc2\x00\x02\x00\x10\xa4\x00\x00\x008ma\x14;\x9c\xf4?)7\x99\x9b7'
(b'^P\x18\xcf\xec?_\x88\xca<\xac\x87\xb3\xa7\xffp ,b\xaf\xd3\x1a\xb2\xa2'
b"\tR\xb0,\x00\x12\x00\x1d\xe4\x8b-\x9f[K\x0c\xce\xce\x8f\x91\xd0\xe3\x92'-"
b'a7\xb6AmP\xa4%;\x93]t\x1d\xa2\xe0=\xac\xe2\x87\x1d\xa2\xaa\x16\xd8\xbaW+\xcd'
b'\xfa\xd2\xb0^h\x00\x00\x00\x04\x00(\xd9\x9f\x95\xf4\xfc\xa2COm}')
Результат разбора:
'A1': 110,
{'A2': -5182,
'A3': 'ma',
'A4': 164,
'A5': {'B1': [{'C1': 339451124,
'C2': 0.6610046029090881,
'C3': 39735,
'C4': 94},
'C1': 1343803372,
{'C2': 0.8731809854507446,
'C3': 15532,
'C4': 135}],
'B2': {'D1': 58507,
'D2': [3287446630899306127,
-7939595926192168649,
-5313845892201759853,
6734039928209779938],
'D3': 34589,
'D4': -1565911336},
'B3': {'E1': -5019495096004726690,
'E2': 104,
'E3': [3014131568, 539779759, 3541742242, 156413996],
'E4': 3651114484,
'E5': 64674,
'E6': 1129278845}}}
Пример 2
Двоичные данные:
b'\xbfGFS&\x82\xc9\x00\x03\x00\x10\xf8\x00\x00\x00Agao\xb6\x11^\x8d\xbf'
(b'\nj\xd6\x0eG_\x1f\xa92\x0f<\xa0\xbf\xab\x1c!\x96gWc\xf5\xa7\xecy\xaa\xe8m"'
b'\xd6\x1e\xe8\xc1\x89$\x1bd\x88\x08\x0b`\xd0\x00\x13\x00\x1e\xf9,5'
b'\x94\x04\xaa\xcd\xa3P\xa2\x8eB\x14\xf3+\xd1\xb4\xa6\xb8o\xec\xeed\x069O\x02'
b'u#\xa0\xb84\x1a\xd5\x16\xf5\xe2\xd3\xe4\xa3\xaf\x083$\xa6\xb3\x7f'
b'\x9c\x03\x00\x00\x00\x06\x00)\xadUNA\x1c\xf3\xe8+Y\x06')
Результат разбора:
'A1': 38,
{'A2': -32055,
'A3': 'gao',
'A4': 248,
'A5': {'B1': [{'C1': -1240375667,
'C2': -0.5406926870346069,
'C3': 3655,
'C4': 95},
'C1': 531182095,
{'C2': 0.019622644409537315,
'C3': 7201,
'C4': 150}],
'B2': {'D1': 63788,
'D2': [3860715912204341410,
-8195965337216109402,
-5156642539691427505,
177086933543164629],
'D3': 5877,
'D4': -489429853},
'B3': {'E1': -5834357084749856868,
'E2': 3,
'E3': [1733780469,
2817292714,
3899466454,
518570377,
605774984,
134963408],
'E4': 2908048961,
'E5': 7411,
'E6': 3895154950}}}
Задача №12
Реализовать разбор двоичного формата данных. Данные начинаются с сигнатуры 0x44 0x4a 0x57 0x4d
, за которой следует структура
A. Порядок байт: от старшего к младшему. Адреса указаны в виде смещений от начала данных. В решении предлагается использовать модуль
struct.
Структура A:
Поле | Описание |
---|---|
1 | Массив структур B, размер 6 |
2 | Адрес (uint32) структуры C |
Структура B:
Поле | Описание |
---|---|
1 | Размер (uint16) и адрес (uint16) массива char |
2 | int8 |
3 | int32 |
Структура C:
Поле | Описание |
---|---|
1 | Структура D |
2 | Структура E |
3 | int16 |
4 | float |
5 | int8 |
6 | uint16 |
Структура D:
Поле | Описание |
---|---|
1 | int16 |
2 | Массив uint16, размер 2 |
Структура E:
Поле | Описание |
---|---|
1 | Размер (uint32) и адрес (uint32) массива double |
2 | uint8 |
Ниже показаны примеры разбора двоичного формата.
Пример 1
Двоичные данные:
b'DJWM\x00\x04\x00>3\x9a\xec\xe7\xf4\x00\x03\x00B\x9d\xa0i}{\x00\x02'
(b'\x00E\xfe\xe4\x8f\xc3S\x00\x05\x00GZ\xabcI\xf4\x00\x02\x00L\x13pj\xa4'
b'\xf5\x00\x05\x00NQI\x06 =\x00\x00\x00cyarmpvouorqxfctfzdebc\xbf\xe0\xe8cX'
b'K\xf7\xc2\xbf\xe9\x14\xa3\xe3\x83_\x0e\x8f\xec)\xb9<\xe5\x00\x00\x00'
b'\x02\x00\x00\x00S\xf2\xd2\xe0\xbe\x9f\xff\x92,\x8bJ')
Результат разбора:
'A1': [{'B1': 'yarm', 'B2': 51, 'B3': -1695750156},
{'B1': 'pvo', 'B2': -99, 'B3': -1603699333},
{'B1': 'uo', 'B2': -2, 'B3': -460340397},
{'B1': 'rqxfc', 'B2': 90, 'B3': -1419556364},
{'B1': 'tf', 'B2': 19, 'B3': 1886037237},
{'B1': 'zdebc', 'B2': 81, 'B3': 1225138237}],
{'A2': {'C1': {'D1': -28692, 'D2': [10681, 15589]},
'C2': {'E1': [-0.5283676838441738, -0.783769554483088], 'E2': 242},
'C3': -11552,
'C4': -0.31249672174453735,
'C5': 44,
'C6': 35658}}
Пример 2
Двоичные данные:
b'DJWM\x00\x04\x00>R\x07s\xae\x8a\x00\x03\x00B~?\x1b=\x8c\x00\x03\x00E%\t'
(b'\x0b{\xb5\x00\x04\x00H\xe9\x10"\xfd\x12\x00\x03\x00L\x0b%\x7f\xce'
b'\x96\x00\x04\x00O"\xffs\x1bU\x00\x00\x00kamwmiogrnqvbqghauugcf?'
b'\xdf\xe0\x8d\xdeu\xdb\xe0\xbf\x96j%\xe5\xc4}@\xbf\xe1t\xe3\xa2\xc3+x\x94'
b"\x91\xc0\xcf\n\x96\x00\x00\x00\x03\x00\x00\x00S\xa7S\x15?\\\x1fH'5<")
Результат разбора:
'A1': [{'B1': 'amwm', 'B2': 82, 'B3': 125021834},
{'B1': 'iog', 'B2': 126, 'B3': 1058749836},
{'B1': 'rnq', 'B2': 37, 'B3': 151747509},
{'B1': 'vbqg', 'B2': -23, 'B3': 270728466},
{'B1': 'hau', 'B2': 11, 'B3': 629132950},
{'B1': 'ugcf', 'B2': 34, 'B3': -9233579}],
{'A2': {'C1': {'D1': -27503, 'D2': [49359, 2710]},
'C2': {'E1': [0.498080699202033,
-0.021889297627351256,
-0.5455187014534735],
'E2': 167},
'C3': 21269,
'C4': 0.8598523139953613,
'C5': 39,
'C6': 13628}}
Задача №12
Реализовать разбор двоичного формата данных. Данные начинаются с сигнатуры 0x4a 0x57 0x46 0x50
, за которой следует структура
A. Порядок байт: от младшего к старшему. Адреса указаны в виде смещений от начала данных. В решении предлагается использовать модуль
struct.
Структура A:
Поле | Описание |
---|---|
1 | int8 |
2 | uint64 |
3 | Адрес (uint16) структуры B |
4 | Структура C |
5 | Массив uint8, размер 7 |
6 | Структура E |
Структура B:
Поле | Описание |
---|---|
1 | float |
2 | uint8 |
3 | float |
4 | int8 |
5 | Массив char, размер 6 |
6 | int64 |
7 | uint8 |
8 | double |
Структура C:
Поле | Описание |
---|---|
1 | int64 |
2 | float |
3 | Массив адресов (uint16) структур D, размер 2 |
4 | int64 |
5 | int64 |
6 | int32 |
7 | Размер (uint32) и адрес (uint32) массива uint16 |
8 | uint16 |
Структура D:
Поле | Описание |
---|---|
1 | uint16 |
2 | Массив int16, размер 7 |
Структура E:
Поле | Описание |
---|---|
1 | int8 |
2 | double |
Ниже показаны примеры разбора двоичного формата.
Пример 1
Двоичные данные:
b"JWFP\xed\xb6\xab,J\x8a\x94\xa3\x04M\x00\x9b\x19\xe6\t'\x93H\x10\xfe"
(b'\x15\x0f?n\x00~\x00\x03\x18A\xc8%&\x9az\x07\x01\xb5R\xbe\xc1H\xc0\x89'
b'\xe0\x9a\xea\x08\x00\x00\x00\x8e\x00\x00\x00V\xd9r6\x0f\x13\xa4\x95\xc4'
b'\xc5(\x1a\x0c\x8e\xa5\x97\xed?\x04\xbe\x05\xbf6\xad%\xd7>]popjxrR\x8aE'
b'\x1f\xcb\x0frG\xdd\\hAwRT\xee?J am\xd1\xb0\xc0"\xf23U\xe6\x0cZT\xb0\xbd\xb9'
b']#x\x0b\xd0wN\r\x07\x97T\x16\xd7p\x95}\xd0\xab\x1d\x9f\xa6\xe9\xeec\x1e\tQ-'
b'ar')
Результат разбора:
'A1': -19,
{'A2': 334274119026387894,
'A3': {'B1': -0.5224306583404541,
'B2': 54,
'B3': 0.4202093183994293,
'B4': 93,
'B5': 'popjxr',
'B6': 5148194689115327058,
'B7': 221,
'B8': 0.9477932290276487},
'A4': {'C1': 1173349498809096603,
'C2': 0.5589293241500854,
'C3': [{'D1': 8266,
'D2': [28001, -20271, 8896, 13298, -6571, 23052, -20396]},
'D1': 47549,
{'D2': [9053, 2936, 30672, 3406, -26873, 5716, 28887]}],
'C4': 8834415562756003843,
'C5': -4591206796928679673,
'C6': -358948727,
'C7': [32149, 43984, 40733, 59814, 25582, 2334, 11601, 29281],
'C8': 55638},
'A5': [114, 54, 15, 19, 164, 149, 196],
'A6': {'E1': -59, 'E2': 0.9247615599022696}}
Пример 2
Двоичные данные:
b'JWFP\x87p\xb4b\xef#\x8a\x16KM\x00v\x80\xa0\x96>\x99&\x821\xeb\xd8\xben'
(b'\x00~\x00;\xb7N=!g\xe1y\xd8\xa5\x1d\xdf\x1c=x=\x06=\x84\xf3\x06'
b'\x00\x00\x00\x8e\x00\x00\x00L"]!\xca\x85C\xd0\xb5\x01 =\xbc\xf0\x8a\xe1\xcb'
b'\xbf\x98\x07(\xbf\x1c\x996\xc4>\x02jalnlzwt\xe1}\xf4\xa6IP\x9b@\xf2f:{W'
b'\xd5?\xbb\xe4\x06A\xc4\xd2\x96G,\xc3\x13,@;\xe1\xac/\x02\xda%*\xf0'
b'\xc2\xd6\xfa\x9b\xdaD\x0b\x1c\x96\xcd\xd9\x03*\xda\x15\xd9K\xe3\x1a\xa8'
b'\xff=')
Результат разбора:
'A1': -121,
{'A2': 5410663889276941424,
'A3': {'B1': -0.6563658714294434,
'B2': 28,
'B3': 0.3832290470600128,
'B4': 2,
'B5': 'jalnlz',
'B6': 5785338765348271223,
'B7': 155,
'B8': 0.33346443847020524},
'A4': {'C1': -9068392305569791882,
'C2': -0.42366936802864075,
'C3': [{'D1': 58555,
'D2': [16646, -11580, 18326, -15572, 11283, 15168, -21279]},
'D1': 559,
{'D2': [9690, -4054, -10558, -25606, 17626, 7179, -12906]}],
'C4': 8782414140809328443,
'C5': 4429357427730523608,
'C6': -209437434,
'C7': [985, 55850, 55573, 58187, 43034, 15871],
'C8': 8780},
'A5': [93, 33, 202, 133, 67, 208, 181],
'A6': {'E1': 1, 'E2': -0.2178205180611963}}
Задача №12
Реализовать разбор двоичного формата данных. Данные начинаются с сигнатуры 0x48 0x56 0x51 0x4b
, за которой следует структура
A. Порядок байт: от младшего к старшему. Адреса указаны в виде смещений от начала данных. В решении предлагается использовать модуль
struct.
Структура A:
Поле | Описание |
---|---|
1 | Размер (uint16) и адрес (uint32) массива структур B |
2 | Структура C |
3 | uint8 |
4 | Адрес (uint32) структуры E |
5 | int8 |
Структура B:
Поле | Описание |
---|---|
1 | int8 |
2 | uint16 |
3 | Размер (uint16) и адрес (uint32) массива char |
Структура C:
Поле | Описание |
---|---|
1 | uint64 |
2 | Адрес (uint32) структуры D |
3 | int16 |
4 | float |
5 | double |
Структура D:
Поле | Описание |
---|---|
1 | int64 |
2 | Размер (uint32) и адрес (uint32) массива uint16 |
3 | Массив int64, размер 3 |
Структура E:
Поле | Описание |
---|---|
1 | uint32 |
2 | uint64 |
3 | float |
4 | Размер (uint32) и адрес (uint16) массива uint64 |
5 | float |
Ниже показаны примеры разбора двоичного формата.
Пример 1
Двоичные данные:
b'HVQK\x05\x00C\x00\x00\x00\xea\xdaZ\x8c\xd8fk\xd4x\x00\x00\x00\x1a\xd1Z!\x7f?'
(b' \xca\xc2\x85\xec\xa5\xaa\xbf\xff\xb8\x00\x00\x00\x93xopbxqysezsdskcvkxyazb'
b'gpgz3\xdb\x06\x00*\x00\x00\x00\x12\x01\xf9\x04\x000\x00\x00\x00\x1f\x83\x1d'
b'\x06\x004\x00\x00\x00\x942G\x05\x00:\x00\x00\x00\x97\xc4\x04\x04\x00'
b'?\x00\x00\x00s\xd3\xf2\x84\x80\xb0\xb1?R\xe5\x1d\xab\x88\xef\x92Y'
b'\x04\x00\x00\x00p\x00\x00\x00\x02\x9a\xd9\xc1Q\xb0\x7f\xf1lP\n4W\x93\xa3j'
b'u\xa0d\x11I\x19\xf4\tm\xf7X#~\xc0\xfb\x0e\xaaG\xcaO<5\xbbY\xd6\x82\xb1\x94'
b'j\xad\xa4F\xb8\x02h\x06OsLR\xaa\x0f\x15\xeb\xc7\x0f\x8a\xbe\x03\x00\x00\x00'
b'\xa0\x00\x95\x96c\xbf')
Результат разбора:
'A1': [{'B1': 122, 'B2': 56115, 'B3': 'xopbxq'},
{'B1': 18, 'B2': 63745, 'B3': 'ysez'},
{'B1': 31, 'B2': 7555, 'B3': 'sdskcv'},
{'B1': -108, 'B2': 18226, 'B3': 'kxyaz'},
{'B1': -105, 'B2': 1220, 'B3': 'bgpg'}],
{'A2': {'C1': 15306440838802496234,
'C2': {'D1': 6454484586240795986,
'D2': [54131, 34034, 45184, 16305],
'D3': [-1044922723335562750,
7684147391968727148,
717226042273865845]},
'C3': -12006,
'C4': 0.9966026544570923,
'C5': -0.05204714901755758},
'A3': 255,
'A4': {'E1': 107479736,
'E2': 16939462797623587663,
'E3': -0.2696516215801239,
'E4': [1079668183676811117, 6465820223173445546, 5090384152108303062],
'E5': -0.8890164494514465},
'A5': -109}
Пример 2
Двоичные данные:
b'HVQK\x03\x005\x00\x00\x00H\xae\xa4O~\xc4\xb2\xabV\x00\x00\x00\x17\xe4\x01$r?'
(b'`\x99\xec)N\xda\xb2\xbf~\x96\x00\x00\x00\xe8icztwibsbpcF\xb1\xdb'
b'\x05\x00*\x00\x00\x00\xdb\xcb/\x03\x00/\x00\x00\x00\x01F\xc3\x03\x00'
b"2\x00\x00\x00\xfd*^C\xaf}j\x8c\xaao\xa6'\x92\xa4\x03\x00\x00\x00P\x00"
b"\x00\x00\xed\xd2D\xd4\xeaR~\xb3r\x8a[\x80\x13x\xa8\x07X\xdd\xab\x00\x0f'"
b'\xbc\x19\xa0\xfc4v\xb2\xcf?\x0c\xd8w\xda\xb5\xecr\xb2\xe9\xf83S\xfdMw'
b'\xcce\x15&w\x8a:\xb6\xd5\x0b*P\xa7\x10*\xe9^\xbe\x03\x00\x00\x00~\x00'
b'\xa3\xa8"\xbd')
Результат разбора:
'A1': [{'B1': 70, 'B2': 56241, 'B3': 'icztw'},
{'B1': -37, 'B2': 12235, 'B3': 'ibs'},
{'B1': 1, 'B2': 49990, 'B3': 'bpc'}],
{'A2': {'C1': 12372167173121289800,
'C2': {'D1': -6588159709098111894,
'D2': [11005, 17246, 32175],
'D3': [-5512877725317803283,
551822979506080370,
1854400091959057752]},
'C3': -7145,
'C4': 0.9458618760108948,
'C5': -0.07364357493915952},
'A3': 126,
'A4': {'E1': 2323064341,
'E2': 1200015967234930234,
'E3': -0.21768632531166077,
'E4': [882652417382218912, 16839648317680547800, 7335369069925970936],
'E5': -0.0397116057574749},
'A5': -24}
Задача №12
Реализовать разбор двоичного формата данных. Данные начинаются с сигнатуры 0x66 0x4a 0x50 0x5a 0x4c
, за которой следует
структура A. Порядок байт: от младшего к старшему. Адреса указаны в виде смещений от начала данных. В решении предлагается использовать
модуль struct.
Структура A:
Поле | Описание |
---|---|
1 | Структура B |
2 | Структура C |
Структура B:
Поле | Описание |
---|---|
1 | Размер (uint32) и адрес (uint16) массива char |
2 | int32 |
Структура C:
Поле | Описание |
---|---|
1 | uint16 |
2 | float |
3 | double |
4 | Массив структур D, размер 4 |
Структура D:
Поле | Описание |
---|---|
1 | Размер (uint16) и адрес (uint32) массива uint8 |
2 | uint16 |
3 | Массив uint32, размер 2 |
4 | int8 |
5 | uint16 |
Ниже показаны примеры разбора двоичного формата.
Пример 1
Двоичные данные:
b"fJPZL\x04\x00\x00\x00i\x00\x17a\xc8+\x8d\xd0\x81\xe1'?\xe0v\xee"
(b"\x98\x00\xd7\xbc\xbf\x02\x00m\x00\x00\x00\x8f\x9f\xca)\xab:\xc4a'"
b'\xe4\x1b-\x1b\x02\x00o\x00\x00\x00\x14\xf8\xaak\x18\x03&\x97\x1c\x07'
b'`\x01p\x02\x00q\x00\x00\x00\xcaS\xc9\xe6\x17\xd7NCU\xf7\x1b\x8dv\x03\x00'
b's\x00\x00\x00\xc2\x07\xbdM\xc0Z\xec%\xf2\xfed+qfglx\xe0\xff\xca'
b'\x8e\x18\xa2\xdc\x96\x8c')
Результат разбора:
'A1': {'B1': 'fglx', 'B2': 734552343},
{'A2': {'C1': 53389,
'C2': 0.6557846665382385,
'C3': -0.1126556752555774,
'C4': [{'D1': [224, 255],
'D2': 40847,
'D3': [984295882, 3827786180],
'D4': 27,
'D5': 6957},
'D1': [202, 142],
{'D2': 63508,
'D3': [51932074, 119314214],
'D4': 96,
'D5': 28673},
'D1': [24, 162],
{'D2': 21450,
'D3': [3608667849, 4149560142],
'D4': 27,
'D5': 30349},
'D1': [220, 150, 140],
{'D2': 1986,
'D3': [1522552253, 4277282284],
'D4': 100,
'D5': 28971}]}}
Пример 2
Двоичные данные:
b'fJPZL\x04\x00\x00\x00i\x00\xb6\xc8\xcdx\xf5\\\x05^\xc3\xbc@7\xbd'
(b'\x01?\x0c\x90?\x02\x00m\x00\x00\x00\x82y\xec\xc7\xc9\xa6bS.\xe7\x93\xc9='
b'\x04\x00o\x00\x00\x00\xfe\x8e;\xb9XW.\xd4\x90\xac\xa4\x97I\x02\x00s\x00\x00'
b'\x00\x84L\xbc&_k\xcf\x0b%+6\xacc\x03\x00u\x00\x00\x00C\xcb\xaeEY\xfd3\x95'
b'\x18E\xdf\xc1!goif\t4^\xac\x9a\x13\nC7\x96D')
Результат разбора:
'A1': {'B1': 'goif', 'B2': 2026752182},
{'A2': {'C1': 23797,
'C2': -0.02384854294359684,
'C3': 0.01567171524157307,
'C4': [{'D1': [9, 52],
'D2': 31106,
'D3': [2798241772, 3878572898],
'D4': -109,
'D5': 15817},
'D1': [94, 172, 154, 19],
{'D2': 36606,
'D3': [1465432379, 2895172654],
'D4': -92,
'D5': 18839},
'D1': [10, 67],
{'D2': 19588,
'D3': [1801397948, 723848143],
'D4': 54,
'D5': 25516},
'D1': [55, 150, 68],
{'D2': 52035,
'D3': [4250486190, 1159238963],
'D4': -33,
'D5': 8641}]}}
Задача №12
Реализовать разбор двоичного формата данных. Данные начинаются с сигнатуры 0x98 0x51 0x48 0x48
, за которой следует структура
A. Порядок байт: от младшего к старшему. Адреса указаны в виде смещений от начала данных. В решении предлагается использовать модуль
struct.
Структура A:
Поле | Описание |
---|---|
1 | Массив адресов (uint16) структур B, размер 2 |
2 | int64 |
3 | Размер (uint16) и адрес (uint32) массива char |
4 | Адрес (uint32) структуры D |
5 | double |
Структура B:
Поле | Описание |
---|---|
1 | Адрес (uint32) структуры C |
2 | uint32 |
3 | int8 |
Структура C:
Поле | Описание |
---|---|
1 | uint32 |
2 | int64 |
3 | uint32 |
Структура D:
Поле | Описание |
---|---|
1 | uint64 |
2 | Размер (uint32) и адрес (uint32) массива uint8 |
3 | int8 |
4 | Размер (uint32) и адрес (uint16) массива uint16 |
Ниже показаны примеры разбора двоичного формата.
Пример 1
Двоичные данные:
b'\x98QHH2\x00K\x00\x8ea\xcb\x96Xl\x02\x98\x02\x00T\x00\x00\x00_\x00'
(b'\x00\x00\x10\x1f\xd6\xec\xd3\xb7\xe7\xbf\xe5(\xf9<0\x93w7\xc0\xc93t R'
b'>\xe1"\x00\x00\x00\xe7\x0b\xc3l\x0e\xff2j\x80Qt\xed\xd7\x02\xbe\x8b\x1e\xc2'
b'\xe3\xdbp;\x00\x00\x00\xbe6k_.dpi\x92\xd8\x00,\xd1\x10\xe0E\xab\x0e8.7'
b'6[\x04\x03\x00\x00\x00V\x00\x00\x00\x0f\x03\x00\x00\x00Y\x00')
Результат разбора:
'A1': [{'B1': {'C1': 1022961893, 'C2': 8373257959613371184, 'C3': 3778957856},
{'B2': 1824721895,
'B3': 14},
'B1': {'C1': 2154443519, 'C2': 2201061762322494545, 'C3': 1893458882},
{'B2': 1600861886,
'B3': 46}],
'A2': -7493307702248250994,
'A3': 'dp',
'A4': {'D1': 313904209658908331,
'D2': [105, 146, 216],
'D3': 15,
'D4': [11264, 4305, 17888]},
'A5': -0.7411899209700739}
Пример 2
Двоичные данные:
b'\x98QHH2\x00K\x00\xf1C\x94\xcaF;\r\xd3\x04\x00T\x00\x00\x00`\x00'
(b'\x00\x00\xf8^T\x8b3x\xe3\xbf\x13\xde\x1d\x00F\xc3\xb5\xe5\xaf\x8a+\xfdI\xf5'
b'^+"\x00\x00\x00\x1eg\xdd{<\x9c\x04b\xbfh\x83\xf5\xd5gM\xcdtwV\xaff;'
b'\x00\x00\x00\x89\x1bgt&wjuq\x1b\x19S\x85\x9f\x82;\x83\x8d~\xcb_##\x01\n'
b'\x02\x00\x00\x00X\x00\x00\x00\x17\x03\x00\x00\x00Z\x00')
Результат разбора:
'A1': [{'B1': {'C1': 1957395, 'C2': -203916870037421242, 'C3': 727643465},
{'B2': 2078107422,
'B3': 60},
'B1': {'C1': 3210871964, 'C2': 8416468386991932264, 'C3': 1722766967},
{'B2': 1952914313,
'B3': 38}],
'A2': -3238867381777054735,
'A3': 'wjuq',
'A4': {'D1': 720896050193989261,
'D2': [27, 25],
'D3': 23,
'D4': [34131, 33439, 33595]},
'A5': -0.6084230157166237}
Задача №12
Реализовать разбор двоичного формата данных. Данные начинаются с сигнатуры 0x45 0x57 0x41
, за которой следует структура A.
Порядок байт: от младшего к старшему. Адреса указаны в виде смещений от начала данных. В решении предлагается использовать модуль
struct.
Структура A:
Поле | Описание |
---|---|
1 | uint32 |
2 | Адрес (uint16) структуры B |
Структура B:
Поле | Описание |
---|---|
1 | Структура C |
2 | Массив адресов (uint32) структур D, размер 6 |
3 | Размер (uint16) и адрес (uint32) массива uint64 |
4 | Размер (uint32) и адрес (uint32) массива float |
5 | int64 |
Структура C:
Поле | Описание |
---|---|
1 | Размер (uint32) и адрес (uint32) массива char |
2 | float |
Структура D:
Поле | Описание |
---|---|
1 | float |
2 | uint16 |
Ниже показаны примеры разбора двоичного формата.
Пример 1
Двоичные данные:
b'EWA\xa7\x17\x00\xe3e\x00vqgnuwgo!\xeaZ=\x8c\x91\x1a^\x18\xbf\xf6S\x94\x9c<'
(b'\xbf\xa1\x9e\xee\x07F?23\xd12\x90>\xf5h9\xc0%?\x9b\xbc];\x895\x8e.\xdf'
b'\xed\xa6\x0eV5\xd0\x03\xbch\x85\xd6\t\x14\xcf\xfe\xe4Yl\x13o1\x98k\xe1'
b'\xeblY-\x8a\xc0`"\x1c\x10\x80\xc3\xbc\x94\xb1v\xbf\x08\x00\x00\x00\t\x00\x00'
b'\x00o+f\xbf\x11\x00\x00\x00\x17\x00\x00\x00\x1d\x00\x00\x00#\x00\x00'
b'\x00)\x00\x00\x00/\x00\x00\x00\x05\x005\x00\x00\x00\x02\x00\x00\x00]'
b'\x00\x00\x00\x13ev:S\xea\x8c\x95')
Результат разбора:
'A1': 3808434087,
{'A2': {'B1': {'C1': 'vqgnuwgo', 'C2': -0.8991002440452576},
'B2': [{'D1': 0.05344593897461891, 'D2': 37260},
'D1': -0.5951858758926392, 'D2': 21494},
{'D1': -0.7367641925811768, 'D2': 40609},
{'D1': 0.773558497428894, 'D2': 13106},
{'D1': 0.28163769841194153, 'D2': 26869},
{'D1': 0.6474643349647522, 'D2': 48283}],
{'B3': [17140469895113816925,
7546911268349021862,
6477582329413490309,
16996984770081526636,
2027289162338359660],
'B4': [-0.023864775896072388, -0.9636471271514893],
'B5': -7670498422134774509}}
Пример 2
Двоичные данные:
b"EWA\xeb\x10\x1c\\_\x00da\xb1D\xd7\xbe\x03\x00J\xc7\xaf>'\xe71Gb>fZ\xff\x97L"
(b'?\xcb\n\xc8\x16\x0f?J\x1dGf\x13\xbf^\x99\x1aBW>\xaf\xde7\xa5\x03*xi\x9d'
b'\xcdH\x96r\xc6\xbe\xc6\x14o\x8b\xa9sJ\x8d\x17\xc1\xdb\xa3\x17\x8e|7\x04]'
b'[\xde\x11\xb8\xfb\x1b\xbf\x0f\xe4J\xbf\x02\x00\x00\x00\t\x00\x00\x00)'
b'P\x82=\x0b\x00\x00\x00\x11\x00\x00\x00\x17\x00\x00\x00\x1d\x00\x00\x00#'
b'\x00\x00\x00)\x00\x00\x00\x05\x00/\x00\x00\x00\x02\x00\x00\x00W\x00\x00'
b'\x00\x9f\xe7\xee\xbb\xe1\xcf\xc0\xc6')
Результат разбора:
'A1': 1545343211,
{'A2': {'B1': {'C1': 'da', 'C2': 0.06362945586442947},
'B2': [{'D1': -0.4204459488391876, 'D2': 3},
'D1': 0.34331732988357544, 'D2': 59175},
{'D1': 0.22097469866275787, 'D2': 23142},
{'D1': 0.7991942763328552, 'D2': 2763},
{'D1': 0.5589413642883301, 'D2': 7498},
{'D1': -0.575779378414154, 'D2': 39262}],
{'B3': [11905228984223744538,
10829131379975399939,
12216980549197022834,
1703446706446486131,
1287566998535371918],
'B4': [-0.6093096733093262, -0.7925423979759216],
'B5': -4125068690243786849}}
Задача №12
Реализовать разбор двоичного формата данных. Данные начинаются с сигнатуры 0x9f 0x43 0x42 0x41 0x46
, за которой следует
структура A. Порядок байт: от старшего к младшему. Адреса указаны в виде смещений от начала данных. В решении предлагается использовать
модуль struct.
Структура A:
Поле | Описание |
---|---|
1 | Адрес (uint32) структуры B |
2 | Структура D |
3 | Адрес (uint32) структуры E |
Структура B:
Поле | Описание |
---|---|
1 | uint64 |
2 | double |
3 | Размер (uint16) и адрес (uint32) массива char |
4 | Массив адресов (uint16) структур C, размер 2 |
5 | int8 |
6 | int64 |
Структура C:
Поле | Описание |
---|---|
1 | Размер (uint32) и адрес (uint32) массива uint8 |
2 | uint16 |
3 | int32 |
4 | float |
5 | uint16 |
6 | int16 |
7 | uint32 |
Структура D:
Поле | Описание |
---|---|
1 | Размер (uint16) и адрес (uint32) массива uint8 |
2 | uint8 |
3 | int64 |
4 | int16 |
5 | uint16 |
Структура E:
Поле | Описание |
---|---|
1 | int16 |
2 | int16 |
3 | Массив double, размер 5 |
4 | int8 |
5 | double |
Ниже показаны примеры разбора двоичного формата.
Пример 1
Двоичные данные:
b'\x9fCBAF\x00\x00\x00]\x00\x04\x00\x00\x00\x80\\\x16[k\x94m\xf28\x9d'
(b'DM\xf9\x18\x00\x00\x00\x84nnA\x9c\x8d\xa8\x00\x00\x00\x04\x00\x00\x00"\xde4'
b'[\xf55N?P*T\xa5fK!\xd8g\xc6SK\xa0s\x00\x00\x00\x03\x00\x00\x00@s\xd9,~\xe8'
b'V?%\x8f\xdf`\xf0\x7f\xdf\x87d\xfb\xb7zX\x9a$\x0f\x11\xf3\xf2\xbf\xe7\xbb'
b'\x1a\xfb\x90\xe5V\x00\x02\x00\x00\x00 \x00&\x00C\xbb\xa4U\x12\xb7'
b'\x86\x9d\x96\xdd\x0e\xc7\xe8S\xb0_\xa5\xc9\xbf\xef6\x9c\xe8n\xc1\xf4'
b'\xbf\xe7\xb2\x96u\xae\xa9\xfa\xbf\xdc\xcb\x988\x11\xff\xa0\xbf\xd0\xd8w'
b'\x8d\x12zh\xbf\xe4\x0b\x83\xa8\x81~\xa2*\xbf\xdb\xbf\xe3\xf3<\xe60')
Результат разбора:
'A1': {'B1': 8815965750240080882,
{'B2': -0.7415900147818018,
'B3': 'nn',
'B4': [{'C1': [65, 156, 141, 168],
'C2': 56884,
'C3': 1542796622,
'C4': 0.8131458759307861,
'C5': 42342,
'C6': 19233,
'C7': 3630679635},
'C1': [75, 160, 115],
{'C2': 29657,
'C3': 746514518,
'C4': 0.6467265486717224,
'C5': 24816,
'C6': 32735,
'C7': 2271542199}],
'B5': -69,
'B6': -6605352699022174499},
'A2': {'D1': [14, 199, 232, 83],
'D2': 92,
'D3': 1610999576959006877,
'D4': 17485,
'D5': 63768},
'A3': {'E1': -20385,
'E2': -23095,
'E3': [-0.9754166164112221,
-0.7405502603990606,
-0.4499264285623159,
-0.2632120969446192,
-0.6264055529718073],
'E4': 42,
'E5': -0.4335870623941416}}
Пример 2
Двоичные данные:
b'\x9fCBAF\x00\x00\x00\\\x00\x04\x00\x00\x00\x7f%>8\xeao\xe2In\x82W\xf0\xa2Z'
(b'\x00\x00\x00\x83mp\xb4\xe6Z\x8d\x00\x00\x00\x04\x00\x00\x00"\x9e.)^72'
b'>\xce^\xa3`#\xecS\xa3\xd3\xc6\x9c\x05M\x00\x00\x00\x02\x00\x00\x00@`\xcb'
b'a\xf7\xd6\x12?n\x98\xc1\xdeO\xc3\x158\xb06\xce%\x10\xb3\xf3\xc7\xfc\x7f\xc6'
b'\xbf\xc0\x17\xdb\xec\x03\xaf\xd0\x00\x02\x00\x00\x00 \x00&\x00B%p'
b'\x1d=\xb3\xbb\xa0\xfbJ\xe1\xa4AL\xda3r\xc4?\xd4\x01\x12G\xef\x94\xb4?'
b'\xef\x18\xa0\xbd;\x85B?\xe8\x01\xd5\n\xf2\xde\x0e\xbf\xebz\xdeT\x19\xd60\xbf'
b'\xd8Vb\x9c0\xeb\xd4\xc0?\xe7\xd4?)\xd7\n\xea')
Результат разбора:
'A1': {'B1': 2670832438644342726,
{'B2': -0.12572812103405662,
'B3': 'mp',
'B4': [{'C1': [180, 230, 90, 141],
'C2': 40494,
'C3': 694040370,
'C4': 0.4030657708644867,
'C5': 24611,
'C6': -5037,
'C7': 2748565148},
'C1': [5, 77],
{'C2': 24779,
'C3': 1643632146,
'C4': 0.9320183396339417,
'C5': 56911,
'C6': -15595,
'C7': 951072462}],
'B5': 37,
'B6': 8078681148728867658},
'A2': {'D1': [225, 164, 65, 76],
'D2': 37,
'D3': 4483591195306061442,
'D4': 22512,
'D5': 41562},
'A3': {'E1': -9677,
'E2': 29380,
'E3': [0.31256539368616676,
0.9717563339183146,
0.7502236570207417,
-0.8587485926243001,
-0.3802725339225479],
'E4': -64,
'E5': 0.744659024924059}}
Задача №12
Реализовать разбор двоичного формата данных. Данные начинаются с сигнатуры 0x41 0x49 0x4b
, за которой следует структура A.
Порядок байт: от старшего к младшему. Адреса указаны в виде смещений от начала данных. В решении предлагается использовать модуль
struct.
Структура A:
Поле | Описание |
---|---|
1 | double |
2 | Массив char, размер 8 |
3 | uint16 |
4 | uint16 |
5 | Размер (uint32) и адрес (uint16) массива адресов (uint32) структур B |
6 | int32 |
7 | Структура C |
8 | int16 |
Структура B:
Поле | Описание |
---|---|
1 | uint8 |
2 | int64 |
Структура C:
Поле | Описание |
---|---|
1 | Массив int8, размер 4 |
2 | Структура D |
3 | int64 |
4 | int16 |
5 | Структура E |
6 | uint8 |
7 | int16 |
Структура D:
Поле | Описание |
---|---|
1 | uint32 |
2 | uint16 |
3 | Размер (uint16) и адрес (uint16) массива float |
4 | double |
Структура E:
Поле | Описание |
---|---|
1 | uint16 |
2 | int8 |
3 | int8 |
4 | int64 |
5 | float |
6 | int64 |
7 | Размер (uint32) и адрес (uint32) массива float |
8 | uint64 |
Ниже показаны примеры разбора двоичного формата.
Пример 1
Двоичные данные:
b'AIK\xbf\xe6\x9f\xf2\xe48\xf1zptmlizun9\x96\xb3e\x00\x00\x00\x02\x00'
(b'\x80e\xc2B \xe8\x13\x16\xebaz\xa5S\xf5\x95\x00\x04\x00\x88\xbf\xe3\x15\xece'
b'O\x9d\xae\t^\x82w\xeb\xe8"\x01\x07\xb9\x88\x02\xf5:\xaf\xc59\xd0\n\xb9Y'
b'\x93>\xf4S\xa8r\x04\xa6\xb5\xb7J\xe6\xc9\x00\x00\x00\x04\x00\x00\x00'
b'\x98Q\x7f\xbf"\xf5\xcdU\x17\n-\x8d\x82fx\x16\xcex\xa8\x1d\xd8\xc0\x0fP'
b'n\xe6\x17CV,\x90\x93\x00\x00\x00n\x00\x00\x00w\xbe\x84:\xbd\xbfH\xae\x7f'
b'\xbc\xa3\x17a>9\xeb\x14?2cY?\x18|\xbc\xbe}\x9d\x82\xbe\x0f\x05\x7f')
Результат разбора:
'A1': -0.707024999377196,
{'A2': 'ptmlizun',
'A3': 14742,
'A4': 45925,
'A5': [{'B1': 120, 'B2': 1643383577487392783},
'B1': 80, 'B2': 7991100166791532691}],
{'A6': 1707229728,
'A7': {'C1': [-24, 19, 22, -21],
'C2': {'D1': 1635427667,
'D2': 62869,
'D3': [-0.2582606375217438,
-0.7839125990867615,
-0.019908608868718147,
0.18156081438064575],
'D4': -0.5964261988382782},
'C3': 675120445722731009,
'C4': 1977,
'C5': {'E1': 34818,
'E2': -11,
'E3': 58,
'E4': -5781150980964263533,
'E5': 0.4772007465362549,
'E6': 8215874919625057993,
'E7': [0.6968284249305725,
0.5956532955169678,
-0.24767115712165833,
-0.13966940343379974],
'E8': 5872622595988083991},
'C6': 10,
'C7': 11661},
'A8': -32154}
Пример 2
Двоичные данные:
b'AIK\xbf\xe8\x86\x1a\x1a\xfc\xbf\xd6knhpklqb\x8bQ\xc9l\x00\x00\x00\x02\x00'
(b'\x80C\x10\x99-\xcfQq\xcd]~5\x18\x89\x0c\x00\x05\x00\x88?\xeb\x9b~C<\xdbz.'
b'\x8c\xee\x08\xb0\x89S\xa8(O\xdc\x9cP\x84\x14\xce\x8a\xc9%\xdc\x99\x99>B\xa1'
b'#\xb0\x1a_\xe5\xe8\xce\xeb\xb8\x00\x00\x00\x06\x00\x00\x00\x9c\x07KP'
b'w\xab\xc49\xb7.J\x81\x8d\xaa\xceO/\xfe;\x8e\x15\xa6\xf0\xd5a\xdf,9-q\xa6\xd5'
b'\x00\x00\x00n\x00\x00\x00w>\xc0\xaa\xac\xbf`\x7fP\xbf\x00\xf6w?\\\x93%'
b'?\x04\xf9\x06\xbd\xd9\xd8\xea\xbe\xf2aR\xbf\x0f\xf3l<\x1a\x15\xe1'
b'\xbdF\xb1\x15\xbf\x08\x90\xe1')
Результат разбора:
'A1': -0.7663698699088808,
{'A2': 'knhpklqb',
'A3': 35665,
'A4': 51564,
'A5': [{'B1': 206, 'B2': 5706058784642017008},
'B1': 213, 'B2': 7052404165572667093}],
{'A6': 1125161261,
'A7': {'C1': [-49, 81, 113, -51],
'C2': {'D1': 1568552216,
'D2': 35084,
'D3': [0.3763021230697632,
-0.8769426345825195,
-0.5037607550621033,
0.8616202473640442,
0.5194247961044312],
'D4': 0.862731105159454},
'C3': 3354317543573115816,
'C4': 10319,
'C5': {'E1': 56476,
'E2': 80,
'E3': -124,
'E4': 1499288322489227673,
'E5': 0.1900678128004074,
'E6': -5757183732581733448,
'E7': [-0.10637076199054718,
-0.47339874505996704,
-0.5623080730438232,
0.009404630400240421,
-0.048508722335100174,
-0.5334606766700745],
'E8': 525602256431888823},
'C6': 46,
'C7': 19073},
'A8': -29270}
Задача №12
Реализовать разбор двоичного формата данных. Данные начинаются с сигнатуры 0x50 0x4c 0x4a
, за которой следует структура A.
Порядок байт: от старшего к младшему. Адреса указаны в виде смещений от начала данных. В решении предлагается использовать модуль
struct.
Структура A:
Поле | Описание |
---|---|
1 | Массив char, размер 2 |
2 | Адрес (uint16) структуры B |
3 | float |
4 | double |
5 | int16 |
6 | Структура D |
Структура B:
Поле | Описание |
---|---|
1 | Массив структур C, размер 2 |
2 | uint32 |
Структура C:
Поле | Описание |
---|---|
1 | Массив float, размер 4 |
2 | uint8 |
Структура D:
Поле | Описание |
---|---|
1 | uint32 |
2 | Размер (uint16) и адрес (uint32) массива int16 |
3 | Массив uint64, размер 6 |
4 | int16 |
5 | int64 |
6 | uint32 |
7 | float |
Ниже показаны примеры разбора двоичного формата.
Пример 1
Двоичные данные:
b'PLJuv\x00a=\xa2\nL?\xd6\xe8\x91\x90C\x8c4D\xdb\xbc\xf8\xd0\xb0\x00\x03\x00'
(b'\x00\x00\x87\xe2\x97\xc9\xdb\xb07WN\xd5\xed\xe3\x1f\xb8((w\x1a\x94y\xec\xdf'
b'\x14\xd8J\xb82c\xa5\xe9\xf80/5/]\xaa\xa9\x7f\xba\xa3\xfd\x8a\x0e\x13\x8a'
b' \xe4\xd3\x11\xe3r^\xd4\x95s_.K\x12\xcbNf\xbe\xcd\xbe\xcc>\x08\x9f'
b'\x86\xbe\x8c\xce\xef\xbe\xe4\xd8}?(\x16\xcf\xcc?:;\xdb?Jd\x96\xbe\xf1'
b'\x94\xb5?"\xf9v\xfeg\xc6\xee\xb6\xa7GLR\x98\x17')
Результат разбора:
'A1': 'uv',
{'A2': {'B1': [{'C1': [0.13342103362083435,
-0.27501627802848816,
-0.44696417450904846,
0.6565980315208435],
'C2': 204},
'C1': [0.7274758219718933,
{0.7905973196029663,
-0.4718376696109772,
0.636618971824646],
'C2': 254}],
'B2': 1741090486},
'A3': 0.07912120223045349,
'A4': 0.35794486130015746,
'A5': 17627,
'A6': {'D1': 3170422960,
'D2': [-22713, 19538, -26601],
'D3': [16327740919446460238,
15415226824932206711,
1915289799801231434,
13272780616060383279,
3832384795485125283,
18269430315466417363],
'D4': 4579,
'D5': 8241258106485419595,
'D6': 315313766,
'D7': -0.4018462896347046}}
Пример 2
Двоичные данные:
b'PLJgg\x00a\xbf*\xee\xcc?\xc3\x0f\xa1I\xb2\x16\x90\xd6\x90\xefr\\'
(b'r\x00\x02\x00\x00\x00\x87\x9a7^\x82\x0e\x00\xb6M\xc9VU\xb8\xebf\xcc\x94\xfe'
b'\xcc\x17\xaa\xc6\xaa\x1f\r\x9b\xc8\xf8?:\xf2\x1e\xf0\xb9\x15*\xa9]1C9\xf7'
b'\xfd\xb1\xe7\xe0\xb0|VAh\xa0o\xc2\x89\xdcc\x0fW\x94\xa6p\xe4=CO\x00>>\xfc'
b'[\xbe^7>\xbd\xb1z\xfd\xbe\xd9\x14\x1ej\xbeD\x87@>\x0f\xe8i?O\xe3i\xbfC'
b'\x0ce{\xb9\x1b.\xa4\xcc\xf9\x17\x1d')
Результат разбора:
'A1': 'gg',
{'A2': {'B1': [{'C1': [0.18650953471660614,
-0.2170076072216034,
-0.08666036278009415,
-0.42398160696029663],
'C2': 106},
'C1': [-0.19192218780517578,
{0.14053501188755035,
0.8120637536048889,
-0.7619078755378723],
'C2': 123}],
'B2': 3105566372},
'A3': -0.6677062511444092,
'A4': 0.14891449068470708,
'A5': -10608,
'A6': {'D1': 4017249394,
'D2': [-13063, 5917],
'D3': [11112454518233675341,
14507877502332357780,
18360075803127586573,
11225495021676535536,
13336612778428941113,
17869634505941220438],
'D4': 16744,
'D5': -6886071407862411433,
'D6': 2493935844,
'D7': 0.047682762145996094}}
Задача №12
Реализовать разбор двоичного формата данных. Данные начинаются с сигнатуры 0x55 0x43 0x4a 0x4c 0x57
, за которой следует
структура A. Порядок байт: от старшего к младшему. Адреса указаны в виде смещений от начала данных. В решении предлагается использовать
модуль struct.
Структура A:
Поле | Описание |
---|---|
1 | int32 |
2 | uint32 |
3 | uint8 |
4 | int16 |
5 | int64 |
6 | Массив структур B, размер 2 |
7 | Адрес (uint32) структуры C |
8 | Размер (uint32) и адрес (uint32) массива uint32 |
Структура B:
Поле | Описание |
---|---|
1 | Размер (uint16) и адрес (uint16) массива char |
2 | int64 |
Структура C:
Поле | Описание |
---|---|
1 | float |
2 | Адрес (uint16) структуры D |
3 | int64 |
4 | int16 |
5 | uint64 |
6 | Адрес (uint32) структуры E |
7 | uint32 |
8 | uint16 |
Структура D:
Поле | Описание |
---|---|
1 | int64 |
2 | Массив uint32, размер 4 |
Структура E:
Поле | Описание |
---|---|
1 | int64 |
2 | int8 |
Ниже показаны примеры разбора двоичного формата.
Пример 1
Двоичные данные:
b'UCJLW\xd5\x14\x9b\x08\xfaJ\xd4\xc7\x8e\xd0\xe2\xdc1^l}rr\xdc\x00\x04\x00<'
(b'\xc6\x12 \xc5\x19\x0c\xdfE\x00\x03\x00@V\x8edi\xd353\x0c\x00\x00\x00d'
b'\x00\x00\x00\x05\x00\x00\x00\x86jhbyjsd\xcf\x85h#uY\x18\x9a\xdb[4\xc7\x15'
b'\xba\x95\x1c\xf5s\xed\x80:\x91\x88\x05^R\xd4l"E>$-?$\x81\x90\x00C\t}'
b'\x87S\x9b[\xbd*K\x8e\x89\x1a@\xdf\x97\xd8\xbf\xf6\x00\x00\x00[\xc1k\xd5\xf8'
b"\x9a\xc6\xd3\xcd\xed\xc9=G6\\\xb5\xa6'\x80\x86\xe8\xd0b\xf6PY^")
Результат разбора:
'A1': -720069880,
{'A2': 4199208135,
'A3': 142,
'A4': -12062,
'A5': -2580177291452452132,
'A6': [{'B1': 'jhby', 'B2': -4174237873718108347},
'B1': 'jsd', 'B2': 6237032939632538380}],
{'A7': {'C1': 0.6426019668579102,
'C2': {'D1': -3493271434454034278,
'D2': [3680187591, 364549404, 4118015360, 982616069]},
'C3': 683851511588699434,
'C4': 19342,
'C5': 9879280061660053494,
'C6': {'E1': 6796728348552019492, 'E2': 45},
'C7': 3245069816,
'C8': 39622},
'A8': [3553488329, 1028077148, 3047565184, 2263404642, 4132460894]}
Пример 2
Двоичные данные:
b'UCJLW\x9e\x04\x03\xe4\xd6\x00\x8b\x04+\xc7\xda\xb0\xe7:x\xa6\x93\xb4\xb4'
(b'\x00\x04\x00<3\xed\xa66\tJ\xb35\x00\x06\x00@g\xbb!B]7/@\x00\x00\x00g'
b'\x00\x00\x00\x04\x00\x00\x00\x89mrivbgglvf\xa8\xb1\xf2\x19\xe6#\xb6aH\xcd'
b'.\x18\x9c#W\x95\xadM\x9d\x0b\xb5\xe6\x8f\x87\x1dN+\x0c\x91\x8e'
b'\xbe\x96\x80\xbfF\xd9\x99\x00F\x15\xee\xb1\xb4U\x9a\x94\xdds\xe3x'
b'\xe8\x88^\xd7\x9b\xfaM\x00\x00\x00^c\x99\xf0\xf4>`?\xc5\x84\xd7\x14\x820'
b'\xe0\x0e\x8c\x88\xcbhm\xc1\xc9')
Результат разбора:
'A1': -1643904028,
{'A2': 3590359812,
'A3': 43,
'A4': -14374,
'A5': -5699522513548888908,
'A6': [{'B1': 'mriv', 'B2': 3741829616429085493},
'B1': 'bgglvf', 'B2': 7474604575466925888}],
{'A7': {'C1': -0.7767577767372131,
'C2': {'D1': -6290981011410667935,
'D2': [1221406232, 2619561877, 2907544843, 3051786119]},
'C3': 1580395907342046429,
'C4': 29667,
'C5': 8712363420073851469,
'C6': {'E1': 2111672608264994454, 'E2': -128},
'C7': 1671033076,
'C8': 15968},
'A8': [1069909207, 344076512, 244091083, 1752023497]}