Задача №12
Реализовать разбор двоичного формата данных. Данные начинаются с сигнатуры 0x74 0x48 0x50 0x44 0x41
, за которой следует
структура A. Порядок байт: от младшего к старшему. Адреса указаны в виде смещений от начала данных. В решении предлагается использовать
модуль struct.
Структура A:
Поле | Описание |
---|---|
1 | Массив char, размер 3 |
2 | uint8 |
3 | Адрес (uint16) структуры B |
4 | Адрес (uint16) структуры D |
5 | Размер (uint16) и адрес (uint16) массива int8 |
Структура B:
Поле | Описание |
---|---|
1 | uint32 |
2 | int32 |
3 | float |
4 | Размер (uint16) и адрес (uint16) массива структур C |
5 | uint64 |
6 | Массив float, размер 4 |
7 | double |
Структура C:
Поле | Описание |
---|---|
1 | float |
2 | uint8 |
3 | int8 |
4 | uint32 |
Структура D:
Поле | Описание |
---|---|
1 | uint32 |
2 | uint8 |
3 | int8 |
4 | Массив int8, размер 8 |
5 | double |
Ниже показаны примеры разбора двоичного формата.
Пример 1
Двоичные данные:
b'tHPDAecx=/\x00_\x00\x04\x00u\x00q\x9f\xfe\xbeLJ\xff\xc9\x08\xa7\x95c]?)'
(b'\x85\xfe\xf2\xef\xdb\x10\te?\xf5\xd3]\xe7\x11\xf1\xfe\xea}\x88P3\x95\x14V'
b'\xd4\xc5\xbe\x03\x00\x11\x00Z\x14\x10Xw@\xff\xbd=q\xb6\xbe+\x85R\xbf\xeb'
b'\x83\xb5\xbe~\x04\x13?\x90S=z\x1c\xb4\xeb?\xb7\x82\xa5\xa4\xf2'
b'\x85\xb9\xe1\xc9\xc3\xb5q\xa5\x18\x90=b\xc0=^\xd6?\xdc\xb4\xf2\x1a')
Результат разбора:
'A1': 'ecx',
{'A2': 61,
'A3': {'B1': 2289953534,
'B2': 345322320,
'B3': -0.38638561964035034,
'B4': [{'C1': -0.49731019139289856,
'C2': 76,
'C3': 74,
'C4': 2802371071},
'C1': 0.864800751209259,
{'C2': 41,
'C3': -123,
'C4': 3689935614},
'C1': 0.8946695327758789,
{'C2': 245,
'C3': -45,
'C4': 4044482397}],
'B5': 13690732273552331866,
'B6': [-0.3563326895236969,
-0.8223444819450378,
-0.35452207922935486,
0.5742872953414917],
'B7': 0.8657362353793463},
'A4': {'D1': 2762310327,
'D2': 242,
'D3': -123,
'D4': [-71, -31, -55, -61, -75, 113, -91, 24],
'D5': 0.3495020273921563},
'A5': [-36, -76, -14, 26]}
Пример 2
Двоичные данные:
b'tHPDAiec\xf2M\x00}\x00\x03\x00\x93\x00)\xcc\x13\xbf\x87)\xa4\xb1\xab\xf1j'
(b'\xc9U\xbf\xdcD7l\xad3/%E\xbf\xcf\xdejE;a3r\xdb=\x02\xc9\xb3\xbcpu\xa2\x97\t'
b'\xbf\xf4S\x93/\x9e\xde\xd8\xa4A\xbf\x02\xf8\xa3!\x04\x04z\xac\xaa'
b'\xb8@\xb0\x1a\xcb\x8cP\x0f?\x06\x00\x11\x00\xe2\xc8w\x1a#\xef\x9f\xcba\x01-'
b"?x \x0c\xbdA\xf4n\xbf?\xd5Z\xbfH\xed\xfa\xfb\x9e\xd5\xe4\xbf'\xec\x91"
b"\x82\xad\xe3\xf4\x8d={'\xd8\xb6O\xc2\xd7\x12\x82M\xa1\xe7\xbf\x8c\xa1F")
Результат разбора:
'A1': 'iec',
{'A2': 242,
'A3': {'B1': 3098193018,
'B2': -887443392,
'B3': 0.5598227977752686,
'B4': [{'C1': -0.5773339867591858,
'C2': 135,
'C3': 41,
'C4': 4054561188},
'C1': -0.8351045846939087,
{'C2': 220,
'C3': 68,
'C4': 867003447},
'C1': -0.7700986266136169,
{'C2': 207,
'C3': -34,
'C4': 1631274346},
'C1': 0.10715141147375107,
{'C2': 2,
'C3': -55,
'C4': 1970322611},
'C1': -0.5374699831008911,
{'C2': 244,
'C3': 83,
'C4': 3734908819},
'C1': -0.7564215660095215, 'C2': 2, 'C3': -8, 'C4': 67379619}],
{'B5': 14672709045043316962,
'B6': [0.6758022904396057,
-0.034210652112960815,
-0.9334145188331604,
-0.8548163771629333],
'B7': -0.6510767861831619},
'A4': {'D1': 2190601255,
'D2': 173,
'D3': -29,
'D4': [-12, -115, 61, 123, 39, -40, -74, 79],
'D5': -0.7384402790546505},
'A5': [-116, -95, 70]}
Задача №12
Реализовать разбор двоичного формата данных. Данные начинаются с сигнатуры 0x45 0x56 0x4d 0x56 0x3e
, за которой следует
структура A. Порядок байт: от младшего к старшему. Адреса указаны в виде смещений от начала данных. В решении предлагается использовать
модуль struct.
Структура A:
Поле | Описание |
---|---|
1 | Адрес (uint32) структуры B |
2 | float |
3 | uint64 |
Структура B:
Поле | Описание |
---|---|
1 | uint32 |
2 | int16 |
3 | Массив структур C, размер 2 |
4 | uint16 |
5 | float |
6 | int64 |
7 | Адрес (uint32) структуры D |
8 | Структура E |
Структура C:
Поле | Описание |
---|---|
1 | Размер (uint16) и адрес (uint16) массива uint8 |
2 | double |
3 | uint16 |
Структура D:
Поле | Описание |
---|---|
1 | Размер (uint16) и адрес (uint16) массива uint16 |
2 | Массив uint8, размер 2 |
3 | int8 |
Структура E:
Поле | Описание |
---|---|
1 | uint32 |
2 | int8 |
3 | int64 |
4 | uint16 |
5 | uint16 |
6 | float |
7 | int8 |
Ниже показаны примеры разбора двоичного формата.
Пример 1
Двоичные данные:
b'EVMV>.\x00\x00\x00\x8bZ@\xbf\x88`7&0\x1a\xd9/~S\x0b\xe4\x87\x91\x9d\xccyzs'
(b'\xecwq\xc5=V\xc7\x07\x00\x19\x00\xf2\xa4\xa3\xbb\xea\xaf5|\xdd'
b'\x02\x00\x15\x00$\xd5\xb0\xf8Y\xe9\xee\xbf`\xb9\x02\x00\x17\x00 \xda'
b'\x9c\xcd\t\x92\xec\xbf\xa8\x99\xd0\x85\xdcM\x1b<\x95\xd6\xbe\x0b~u'
b"\x0c\xf5'\x00\x00\x00\xd5C\x08\tg\xa3\xd7\xb4\xc7\xc8\xc5\xc4f\x84"
b'>\x92\x9b\xc9\xe7[?\x93')
Результат разбора:
'A1': {'B1': 900721339,
{'B2': -8836,
'B3': [{'C1': [126, 83], 'C2': -0.9659852845422034, 'C3': 47456},
'C1': [11, 228], 'C2': -0.8928269401429283, 'C3': 39336}],
{'B4': 34256,
'B5': 0.009479012340307236,
'B6': -789126650473294187,
'B7': {'D1': [37255, 52381, 31353, 60531, 29047, 15813, 51030],
'D2': [242, 164],
'D3': -93},
'B8': {'E1': 151536597,
'E2': 103,
'E3': 7405261153438586787,
'E4': 16004,
'E5': 39826,
'E6': 0.8590055108070374,
'E7': -109}},
'A2': -0.7513815760612488,
'A3': 3447815783830741128}
Пример 2
Двоичные данные:
b"EVMV>$\x00\x00\x00^\x1d\x14=\xa8\xe8\xda\xda\xe2V'\xf8\xa6\xba\xe01\xc5!["
(b'"\x02\x00\x19\x00\xd9u\xd9Y\x9f\x92d\xbf\x02\x02\x00\x15\x00b\xe8'
b'\xed\x0e\x1dn\xe5?\x03F\x02\x00\x17\x00\\\xc9\xdaf\xf2\x9a\xde?\x1es1\xd9'
b'\xd6\x96\xee>p\x91\x89c\xaec2\xfa\x1d\x00\x00\x00\xc2VJ\xe9o\xcf\xa3\x95'
b'\x9a\x88i:\x08\x8a\x90U\xad\xc8\x97\x9e\xbe\x9d')
Результат разбора:
'A1': {'B1': 1687330649,
{'B2': 703,
'B3': [{'C1': [166, 186], 'C2': 0.6696915904606267, 'C3': 17923},
'C1': [224, 49], 'C2': 0.47820720714948606, 'C3': 29470}],
{'B4': 55601,
'B5': 0.46599453687667847,
'B6': -418162214746615440,
'B7': {'D1': [8645, 8795], 'D2': [217, 117], 'D3': -39},
'B8': {'E1': 3913963202,
'E2': 111,
'E3': 592902336382608335,
'E4': 37002,
'E5': 44373,
'E6': -0.3097517490386963,
'E7': -99}},
'A2': 0.03616081923246384,
'A3': 17881356377832220840}
Задача №12
Реализовать разбор двоичного формата данных. Данные начинаются с сигнатуры 0x50 0x47 0x57 0x44 0x6c
, за которой следует
структура A. Порядок байт: от младшего к старшему. Адреса указаны в виде смещений от начала данных. В решении предлагается использовать
модуль struct.
Структура A:
Поле | Описание |
---|---|
1 | float |
2 | uint8 |
3 | Структура B |
4 | Массив float, размер 4 |
5 | Структура G |
Структура B:
Поле | Описание |
---|---|
1 | int8 |
2 | Размер (uint16) и адрес (uint32) массива адресов (uint32) структур C |
3 | Адрес (uint16) структуры D |
Структура C:
Поле | Описание |
---|---|
1 | int32 |
2 | uint32 |
Структура D:
Поле | Описание |
---|---|
1 | Структура E |
2 | int16 |
3 | Размер (uint16) и адрес (uint16) массива uint32 |
4 | int64 |
5 | Адрес (uint16) структуры F |
Структура E:
Поле | Описание |
---|---|
1 | uint8 |
2 | int32 |
Структура F:
Поле | Описание |
---|---|
1 | uint64 |
2 | int16 |
3 | float |
4 | Массив int16, размер 5 |
5 | int32 |
6 | uint32 |
Структура G:
Поле | Описание |
---|---|
1 | uint64 |
2 | int32 |
3 | int8 |
Ниже показаны примеры разбора двоичного формата.
Пример 1
Двоичные данные:
b'PGWDl\xc3\x14\xdd\xbcy\xb7\x03\x00H\x00\x00\x00\x90\x00\x12}U>\xce'
(b'b\xca\xbe\xae\x8b\x11\xbfi&\xe0>>^>EX\x0b\xad"\xef\xe6\x86\xe8\xfe\x86f0e'
b'\xeb\xb3\xcd\x16=\x1aC\xc7\xc2C\x01\xac\x11\x9d\x96g\xdcV\x8a\xb3'
b'0\x00\x00\x008\x00\x00\x00@\x00\x00\x00\x9dX\x91z\x18\xbc\x002\xfe\xeco8'
b'\xdf\x87F%\xd4\xf6\xc1s\x0eR,:\x06:S\xa8M\xe7\xe4p\x05\x028\xe6\xc9&\x80j'
b'\r\xbfvP\xb5\xceQWB\x024f\x99\x8bO\xd9\xd6\xd0\xd3?\x0cRT\x9b\xfc\xcbS\x07'
b'\x00T\x00\xda=\x9c\xc6\x93\xfeX\xe3p\x00')
Результат разбора:
'A1': -0.026987439021468163,
{'A2': 121,
'A3': {'B1': -73,
'B2': [{'C1': 1697670790, 'C2': 382579691},
'C1': -951903683, 'C2': 2885764034},
{'C1': 1737923857, 'C2': 3012187868}],
{'B3': {'D1': {'E1': 12, 'E2': -56929198},
'D2': 21451,
'D3': [2056345757,
838908952,
946859262,
625379295,
1942091476,
975983118,
2824026630],
'D4': -2064620518503596582,
'D5': {'F1': 16589011449811363661,
'F2': 9929,
'F3': -0.5524063110351562,
'F4': [20598, -12619, 22353, 578, 26164],
'F5': -649098343,
'F6': 1070846166}}},
'A4': [0.20848491787910461,
-0.39528506994247437,
-0.5685375928878784,
0.4377930462360382],
'A5': {'G1': 2498665842007236158, 'G2': -393812241, 'G3': -2}}
Пример 2
Двоичные данные:
b'PGWDl\x82\x81\xe9>\x9f\xd0\x04\x00P\x00\x00\x00\x8c\x00f\x17\xc0>E'
(b'\xfc\x9e\xbe\xaa$\xa2\xbe\xa4U\xda>\x99\xee=\xc8\xa5.\x88g3)\x16c\x04'
b'\x01\xf5(\x1f_0t@\x10\xd4\xd1\xc4\xd9\x80\xa4\t\x1c\xfbn0o\xdd.\xed%~Y\x8f'
b'l\xfd\xc6F0\x00\x00\x008\x00\x00\x00@\x00\x00\x00H\x00\x00\x004&\xb7\xe3'
b'\xa8\xc9\x9at\xed\xa3\\\xa4W(\xdf\xfe\xa5\xf0_-\x93t\x01r\xc9=\xa8\x1b'
b"9\xab\r\xcd\x9b\x8feC\xb0p\xae\x13\xc0YF'>\x19\x94[\xbdF\xcb\x03\x00`\x00/"
b'W\x97\x89\x19H\xbe\xd1l\x00')
Результат разбора:
'A1': 0.45606619119644165,
{'A2': 159,
'A3': {'B1': -48,
'B2': [{'C1': 522777857, 'C2': 1081356383},
'C1': -992881648, 'C2': 161775833},
{'C1': 812579612, 'C2': 3979271535},
{'C1': -1889960411, 'C2': 1187446124}],
{'B3': {'D1': {'E1': 62, 'E2': -1118071783},
'D2': -13498,
'D3': [3820430900, 1956301224, 2757534701],
'D4': -3333147399687809233,
'D5': {'F1': 3269596450230577239,
'F2': 29843,
'F3': 0.09836197644472122,
'F4': [7080, -21703, -13043, -28773, 17253],
'F5': 330199216,
'F6': 658921920}}},
'A4': [0.3751785159111023,
-0.31051841378211975,
-0.3166859745979309,
0.42643463611602783],
'A5': {'G1': 7460264072303210137, 'G2': 1662396723, 'G3': 4}}
Задача №12
Реализовать разбор двоичного формата данных. Данные начинаются с сигнатуры 0x93 0x59 0x59 0x4c 0x52
, за которой следует
структура A. Порядок байт: от старшего к младшему. Адреса указаны в виде смещений от начала данных. В решении предлагается использовать
модуль struct.
Структура A:
Поле | Описание |
---|---|
1 | Адрес (uint16) структуры B |
2 | float |
3 | int32 |
4 | uint32 |
5 | Структура D |
6 | int16 |
7 | uint32 |
Структура B:
Поле | Описание |
---|---|
1 | int64 |
2 | double |
3 | Адрес (uint32) структуры C |
Структура C:
Поле | Описание |
---|---|
1 | double |
2 | float |
3 | int16 |
Структура D:
Поле | Описание |
---|---|
1 | Размер (uint32) и адрес (uint16) массива int8 |
2 | Структура E |
3 | int64 |
4 | Размер (uint16) и адрес (uint32) массива структур F |
5 | Размер (uint16) и адрес (uint32) массива uint16 |
6 | Структура G |
7 | double |
Структура E:
Поле | Описание |
---|---|
1 | uint32 |
2 | uint16 |
3 | int16 |
4 | float |
Структура F:
Поле | Описание |
---|---|
1 | Размер (uint16) и адрес (uint16) массива uint64 |
2 | uint8 |
3 | uint16 |
Структура G:
Поле | Описание |
---|---|
1 | uint32 |
2 | int16 |
3 | int16 |
4 | int32 |
Ниже показаны примеры разбора двоичного формата.
Пример 1
Двоичные данные:
b'\x93YYLR\x00a>\xd6\x0b\xeb\x82A\ngP\xaeY\xa5\x00\x00\x00\x02\x00'
(b'u\xaf\xbb\xe7\x93\x1d\xc8MZ\xbd\x8b\x97\xb3]\r\x8a\xcf\xe7QB\xcc\x00\x02\x00'
b'\x00\x00\x97\x00\x04\x00\x00\x00\xa5\x8c3\xe1\xcc\xdb-\xe7\x055\xdc\xfa'
b'\xb7?\xb0\x82L\x88\xadS\xf0\x1c8\xed\x08\xdb\x8e?\xe3_\xbb\xb7\x8fjt\xbe'
b'\xbb2\x16\xdf\x03\x8adx$,\xbc-e\xbf\xdb\xe2\xd9\xfeu\x81D\x00\x00\x00'
b'S\xbd\x0f0\x01#,\xb3\xb7\xfb~\rm\xe5\x1eH\x90F\x14g\xeb\xc5D\x0c4o\xa4\xed'
b'\xf9\x90\x91\xf0\xd8\x8a1\x00\x02\x00wi1K\x00\x02\x00\x87j@%\xf2=gni\x00\xe3'
b'\xce')
Результат разбора:
'A1': {'B1': -8474516502039745179,
{'B2': -0.4357209191275795,
'B3': {'C1': 0.6054361901436338,
'C2': -0.36561650037765503,
'C3': -8445}},
'A2': 0.41805967688560486,
'A3': -2109666713,
'A4': 1353603493,
'A5': {'D1': [-67, 15],
'D2': {'E1': 2948327315,
'E2': 7624,
'E3': 19802,
'E4': -0.06816043704748154},
'D3': 6705168045768262348,
'D4': [{'F1': [3459084663697963902, 967681413183718932],
'F2': 105,
'F3': 12619},
'F1': [7488295701486792612, 17147896012675254833],
{'F2': 106,
'F3': 16421}],
'D5': [62013, 26478, 26880, 58318],
'D6': {'G1': 2352210380, 'G2': -9427, 'G3': -6395, 'G4': 903674551},
'D7': 0.06448820435373626},
'A6': 7224,
'A7': 3976780686}
Пример 2
Двоичные данные:
b'\x93YYLR\x00a?hv\x1dg\xc1\xd3\x05\xc9\x95\x07w\x00\x00\x00\x02\x00u(\xd4\xc6'
(b'\x8aS\xbe\xb1\x98\xbe~\x82x\x06\xd5\x0b\xaa\xbc\x08\xe5\xce\x00\x02\x00'
b'\x00\x00\x97\x00\x07\x00\x00\x00\xa5\xac\x8e>\x1f\xdc\xe1\x15\x08}\x06I'
b'\xd7\xbf\xa2x\x8d\xc0\x08}@\xa7\xed\xe3&\x93\x90?\xc5\xf0\xab\x9f}\xf7\xf8>'
b'\xc7-\x12\x00If\xbdZ\x80\xfe\t\xe8N\xbf\xec\x08\xc7X\x9c\xb1\xf8\x00\x00\x00'
b'S\xe4z\x92\xab\xfe)Z:\x90\xdf\xfe\xff\x89q\x05\xaf\xb1I\x15-\x1aP~'
b'!\xee\xad\xff\xc9p\xe7\x9b5\xdcr\x00\x02\x00w\xc4\xb1\xbc\x00\x02'
b'\x00\x875\x139\xba\xe1\x07\x87\xb6\xc4:sJ\xec1\x82A3')
Результат разбора:
'A1': {'B1': 7403172872531339342,
{'B2': -0.8760716181473631,
'B3': {'C1': 0.17140717780779346, 'C2': 0.38901573419570923, 'C3': 73}},
'A2': 0.9080522656440735,
'A3': 1740755717,
'A4': 3381987191,
'A5': {'D1': [-28, 122],
'D2': {'E1': 685033098,
'E2': 21438,
'E3': -20072,
'E4': -0.2485445737838745},
'D3': 492312562193982926,
'D4': [{'F1': [10568820404115902687, 18374556123214623049],
'F2': 196,
'F3': 45500},
'F1': [1525904781764325037, 18431387090034220146],
{'F2': 53,
'F3': 4921}],
'D5': [47841, 1927, 46788, 14963, 19180, 12674, 16691],
'D6': {'G1': 2895003167, 'G2': -8991, 'G3': 5384, 'G4': 2097564119},
'D7': -0.03607600182680892},
'A6': -22547,
'A7': 3810956176}
Задача №12
Реализовать разбор двоичного формата данных. Данные начинаются с сигнатуры 0x2e 0x59 0x54 0x41
, за которой следует структура
A. Порядок байт: от старшего к младшему. Адреса указаны в виде смещений от начала данных. В решении предлагается использовать модуль
struct.
Структура A:
Поле | Описание |
---|---|
1 | Размер (uint16) и адрес (uint32) массива адресов (uint16) структур B |
2 | Структура D |
Структура B:
Поле | Описание |
---|---|
1 | Адрес (uint16) структуры C |
2 | int8 |
Структура C:
Поле | Описание |
---|---|
1 | uint32 |
2 | uint8 |
Структура D:
Поле | Описание |
---|---|
1 | uint32 |
2 | Структура E |
3 | Адрес (uint16) структуры F |
Структура E:
Поле | Описание |
---|---|
1 | Массив int32, размер 8 |
2 | Размер (uint16) и адрес (uint16) массива uint16 |
Структура F:
Поле | Описание |
---|---|
1 | uint64 |
2 | Размер (uint16) и адрес (uint16) массива int16 |
3 | Размер (uint16) и адрес (uint32) массива uint16 |
Ниже показаны примеры разбора двоичного формата.
Пример 1
Двоичные данные:
b'.YTA\x00\x05\x00\x00\x00\\~?\xad\xb9:q\xfb\x8d\x80\xd9r\xdeD\x12\x9f1:\xfc'
(b'\x08\x84L1\x91\x08\xca#\x19\xcf\xef\xccX\x10\xec\\\x1ff\x00\x05\x00f\x00~'
b"\x1d\xb6\xa8C'\x004\\\xca/\xf6SC\x00<\xf4\xa7\xf0\xe5\xe5\x8a\x00D\xb4"
b'_q\x1dR\xa0\x00L\xf3U\x16n\xb4\xe5\x00T\xc4\x009\x00A\x00I\x00Q\x00Y\xe6C'
b'\xcc\xb1T8\x19\xa5\xbd\xc24Z\x99\x9d};7!\xdb3\x16\xdc\n\xd2b\xd6'
b'\x15\xda\x9d\xc8\x12\x15\x00\x04\x00p\x00\x03\x00\x00\x00x')
Результат разбора:
'A1': [{'B1': {'C1': 498509891, 'C2': 39}, 'B2': 92},
{'B1': {'C1': 3392140883, 'C2': 67}, 'B2': -12},
{'B1': {'C1': 2817582565, 'C2': 138}, 'B2': -76},
{'B1': {'C1': 1601248594, 'C2': 160}, 'B2': -13},
{'B1': {'C1': 1427533492, 'C2': 229}, 'B2': -60}],
{'A2': {'D1': 2118102457,
'D2': {'E1': [980548493,
-2133232930,
1142071089,
989595780,
1278316808,
-903669297,
-271820784,
-329506970],
'E2': [58947, 52401, 21560, 6565, 48578]},
'D3': {'F1': 7121903889427206677,
'F2': [13402, -26211, 32059, 14113],
'F3': [56115, 5852, 2770]}}}
Пример 2
Двоичные данные:
b'.YTA\x00\x03\x00\x00\x00L%\xbcX\xfdG\x9es\xc8\xb8Uo\x81\xcd\x984\t\xfc;'
(b'g\xc2\xf9\x01HX\x87\xe5\xe1!6\xfd\xf2\xd0\x1f\x99P\x19\x00\x05\x00R\x00j'
b'G\x9e\xfb\xad\x9a\x004\xf2)\x1b:\xc1\x8b\x00<\xcb\x12!\x03\x082\x00D~'
b'\x009\x00A\x00I\x8d\x08\r\x07g7WOLz\xffD\xaf\xd3R\xcd\x83\x1d2\x84\xbe\xf3'
b'\xaf\xf0\xed\x9a\x97\x1a\rg86\x00\x04\x00\\\x00\x03\x00\x00\x00d')
Результат разбора:
'A1': [{'B1': {'C1': 1201601453, 'C2': 154}, 'B2': -14},
{'B1': {'C1': 689650369, 'C2': 139}, 'B2': -53},
{'B1': {'C1': 304153352, 'C2': 50}, 'B2': 126}],
{'A2': {'D1': 633100541,
'D2': {'E1': [1201566664,
-1202360447,
-845663223,
-63215678,
-117356456,
-2014977759,
922612432,
530141209],
'E2': [36104, 3335, 26423, 22351, 19578]},
'D3': {'F1': 17121163071552174134,
'F2': [-188, -20525, 21197, -31971],
'F3': [12932, 48883, 45040]}}}
Задача №12
Реализовать разбор двоичного формата данных. Данные начинаются с сигнатуры 0x56 0x42 0x45
, за которой следует структура A.
Порядок байт: от старшего к младшему. Адреса указаны в виде смещений от начала данных. В решении предлагается использовать модуль
struct.
Структура A:
Поле | Описание |
---|---|
1 | Размер (uint32) и адрес (uint32) массива адресов (uint32) структур B |
2 | int32 |
Структура B:
Поле | Описание |
---|---|
1 | float |
2 | int8 |
3 | int32 |
4 | Структура C |
5 | Размер (uint16) и адрес (uint16) массива int32 |
6 | Структура D |
7 | Адрес (uint16) структуры E |
8 | uint32 |
Структура C:
Поле | Описание |
---|---|
1 | Массив uint8, размер 6 |
2 | int16 |
3 | double |
Структура D:
Поле | Описание |
---|---|
1 | uint16 |
2 | Размер (uint32) и адрес (uint32) массива int8 |
3 | int8 |
4 | uint32 |
5 | float |
Структура E:
Поле | Описание |
---|---|
1 | uint8 |
2 | uint32 |
Ниже показаны примеры разбора двоичного формата.
Пример 1
Двоичные данные:
b'VBE\x00\x00\x00\x02\x00\x00\x00\x9fU\xcb\x92eg\xb6\xa5\xd2\xd8\x18\xc2\x92z'
(b'\xf4+J\xa3\xd3\xec"@\x96\xb0S\xbe\x93@[\x9e\xb1\x9a\xf3\x9biw\x8c3a\xf7(\xb2'
b'?\xe3Z\xc4\xb4\xc3v\xbc\x00\x03\x00\x0f\xb7L\x00\x00\x00\x03\x00\x00'
b'\x00\x1bP\x01\xee\xb5p\xbff\x0f\x0e\x00\x1eL-\xfb\xacD\xd0N\x8dhw\xad'
b"m\xff\xcf\xc1'\xe1\xaf_b\xbe\xe50R\xd1qx8N\xceX\xee2\x00O\xd0\xb4?\xd4"
b'%o\xb1g\xae\xcc\x00\x02\x00Y\x89\x15\x00\x00\x00\x03\x00\x00\x00a'
b'\x9f\x8d\x80fl<\xe5\xcd\n\x00d\xb2F\n\xc6\x00\x00\x00#\x00\x00\x00i')
Результат разбора:
'A1': [{'B1': -0.2876003682613373,
{'B2': -98,
'B3': -1315245157,
'B4': {'C1': [105, 119, 140, 51, 97, 247],
'C2': 10418,
'C3': 0.604830124906321},
'B5': [1740023250, -669465966, 2062822218],
'B6': {'D1': 46924,
'D2': [-93, -45, -20],
'D3': 80,
'D4': 32421232,
'D5': -0.8986672163009644},
'B7': {'E1': 34, 'E2': 1083617363},
'B8': 1278081964},
'B1': -0.4476342797279358,
{'B2': -47,
'B3': 1903704142,
'B4': {'C1': [206, 88, 238, 50, 0, 79],
'C2': -12108,
'C3': 0.3147849304648218},
'B5': [1154502285, 1752673645],
'B6': {'D1': 35093,
'D2': [-1, -49, -63],
'D3': -97,
'D4': 2374002284,
'D5': 0.028051871806383133},
'B7': {'E1': 39, 'E2': 3786366818},
'B8': 2990934726}],
'A2': 1439404645}
Пример 2
Двоичные данные:
b'VBE\x00\x00\x00\x02\x00\x00\x00\xad;\x91V\x01\x1f\x8ap\xcc\xacZ+\x93\xb7'
(b'\xad\xfbd\x87\xc17\x10\x90\x86\xf22R;\x04[u\x14\x1a\x01\xcb>\x88r\xed'
b'\x85\x810\x9aX\x03\xa4^o\x1c\xe81\x1a\xbf\xeb]R=\xb8\xe8\x8e\x00\x05\x00'
b'\x0fX\xb3\x00\x00\x00\x04\x00\x00\x00#G\xf0\x14\xa9\x15\xbe\xcakj'
b"\x00'\x1a\xf9\x9c-fH\xf8k\xf2v\xde\xff\xe3\x92\xb6\xd4\x8d\x86F*\xac=fzH?"
b"B\xbf-[B\x96n\xe7\x97\xcf\x9bT'\x95@1\xbf\xdemj\x9c,M\xb0\x00\x03\x00b"
b'8\x9a\x00\x00\x00\x04\x00\x00\x00nz\x08\xdd\xfaZ\xbeYz\x94\x00r\x08\xd1\x95'
b'\xf7\x00\x00\x00,\x00\x00\x00w')
Результат разбора:
'A1': [{'B1': 0.2665018141269684,
{'B2': -123,
'B3': -2127521192,
'B4': {'C1': [3, 164, 94, 111, 28, 232],
'C2': 12570,
'C3': -0.8551417546762126},
'B5': [529166540, -1403376749, -1213334684, -2017380592, -1870204366],
'B6': {'D1': 22707,
'D2': [82, 59, 4, 91],
'D3': 71,
'D4': 4027885845,
'D5': -0.39535075426101685},
'B7': {'E1': 117, 'E2': 337248715},
'B8': 452566061},
'B1': 0.7607296109199524,
{'B2': 91,
'B3': 1117155047,
'B4': {'C1': [151, 207, 155, 84, 39, 149],
'C2': 16433,
'C3': -0.4754282498481315},
'B5': [1716058219, -227090689, -476924204],
'B6': {'D1': 14490,
'D2': [-115, -122, 70, 42],
'D3': 122,
'D4': 148765274,
'D5': -0.21238166093826294},
'B7': {'E1': 172, 'E2': 1030126152},
'B8': 147953143}],
'A2': 999380481}
Задача №12
Реализовать разбор двоичного формата данных. Данные начинаются с сигнатуры 0x42 0x51 0x41 0x78
, за которой следует структура
A. Порядок байт: от младшего к старшему. Адреса указаны в виде смещений от начала данных. В решении предлагается использовать модуль
struct.
Структура A:
Поле | Описание |
---|---|
1 | Структура B |
2 | float |
3 | double |
4 | Массив int16, размер 4 |
5 | Адрес (uint32) структуры E |
6 | int32 |
Структура B:
Поле | Описание |
---|---|
1 | Структура C |
2 | uint32 |
3 | Массив структур D, размер 3 |
4 | double |
Структура C:
Поле | Описание |
---|---|
1 | uint64 |
2 | double |
3 | uint16 |
4 | uint8 |
5 | Массив char, размер 8 |
Структура D:
Поле | Описание |
---|---|
1 | uint64 |
2 | double |
3 | Размер (uint32) и адрес (uint32) массива uint8 |
4 | uint8 |
5 | int8 |
Структура E:
Поле | Описание |
---|---|
1 | int16 |
2 | double |
Ниже показаны примеры разбора двоичного формата.
Пример 1
Двоичные данные:
b'BQAxx\x93\x8ec\xac\xee\x187:\x88\xbe6\xa3\xcf\xe4?Z\x80\x80jopbltzwl'
(b'\xba\x07\t|\xa4a\x81a\x84\x07\xb5\x000\xb7L\xd6\xf5\x94\xbf\x04'
b'\x00\x00\x00\x95\x00\x00\x00k\xedk\x92\xd8\x9b\x06L\x1b\xe4\x86\x92\xeb'
b'D\x08\xa0\xea\xbf\x05\x00\x00\x00\x99\x00\x00\x00-\x13K\xd9:=\x01'
b"P\xea\xce\xc2\x06\xc7\x841'\xe7\xbf\x04\x00\x00\x00\x9e\x00\x00\x00\x0f"
b'\xd0\xd6|\x96\x92a:\xe0\xbfY\xb7;\xbe\x00\xa0E\x96\xcdm%\xbfE\x10`!\x842\x86'
b'\x9e\xa2\x00\x00\x00<\x1b}:4\xa6\xc6W\xbfs\xbc\xb4=\xa1b\xd8\xa2\xfbK'
b'\xa8\xd5\x14\xac\xbf\x1d\xe1?')
Результат разбора:
'A1': {'B1': {'C1': 3970185495699166072,
{'C2': 0.6503463811134289,
'C3': 32858,
'C4': 128,
'C5': 'jopbltzw'},
'B2': 151501420,
'B3': [{'D1': 13044540400019285116,
'D2': -0.020469044144007853,
'D3': [52, 166, 198, 87],
'D4': 107,
'D5': -19},
'D1': 16436814856286933611,
{'D2': -0.8320351930711503,
'D3': [191, 115, 188, 180, 61],
'D4': 45,
'D5': 19},
'D1': 14909817482615904587,
{'D2': -0.7235343545255193,
'D3': [161, 98, 216, 162],
'D4': 15,
'D5': -48}],
'B4': -0.5071266043704792},
'A2': -0.18331660330295563,
'A3': -0.0001634896717732648,
'A4': [4165, 8544, 12932, -24954],
'A5': {'E1': 19451, 'E2': 0.5348814354862741},
'A6': 981277500}
Пример 2
Двоичные данные:
b'BQAx-\xfe\x10\x13\x8f\x99\xf9\xcah?P\xe5\x93\x81\xd8?\xd8h\xc7lsyjtjghd'
(b"\xb5\x1es'\xca\x8d\x17\x8f#lCF\xcd\x8f\xb1\x1c\xe0\xe7\xbf\x02"
b'\x00\x00\x00\x95\x00\x00\x00\xf8\x8a\x1cze\x18\xffw>\\t\xb5\x98e\x164\xec'
b'\xbf\x04\x00\x00\x00\x97\x00\x00\x004{\xd7\xdf\xdb\x9e9\xc5_\xe8 $\x05\x99/'
b'U\xd6\xbf\x05\x00\x00\x00\x9b\x00\x00\x00\xd6;4\xf62m\xb3F\xe9?\xb93l'
b'?L\xf1\xcd\x03\xc8\xb4\xe0?\xf1\xbbk\x18Qp_\x8a\xa0\x00\x00\x00Lg\xe7'
b'\xaf\x9e\xc4\x16\x16\x16\xae0\xbb=\x9f\xe2\xa1\t\xd8\xcf\xe3\x08\xe5N'
b'\xec\xbf')
Результат разбора:
'A1': {'B1': {'C1': 14625890104641650221,
{'C2': 0.3829087962521869,
'C3': 26840,
'C4': 199,
'C5': 'lsyjtjgh'},
'B2': 1931392356,
'B3': [{'D1': 4858297195508386343,
'D2': -0.7461074321749173,
'D3': [158, 196],
'D4': 248,
'D5': -118},
'D1': 6646882037555100188,
{'D2': -0.8813583359057433,
'D3': [22, 22, 22, 174],
'D4': 52,
'D5': 123},
'D1': 16744318790855811031,
{'D2': -0.34894933646552495,
'D3': [48, 187, 61, 159, 226],
'D4': 214,
'D5': 59}],
'B4': 0.789880479125435},
'A2': 0.922664225101471,
'A3': 0.5220680307680055,
'A4': [-17423, 6251, 28753, -30113],
'A5': {'E1': 2465, 'E2': -0.8846306966429394},
'A6': -1343789236}
Задача №12
Реализовать разбор двоичного формата данных. Данные начинаются с сигнатуры 0x52 0x42 0x44 0x58 0xc5
, за которой следует
структура A. Порядок байт: от младшего к старшему. Адреса указаны в виде смещений от начала данных. В решении предлагается использовать
модуль struct.
Структура A:
Поле | Описание |
---|---|
1 | uint32 |
2 | Массив структур B, размер 2 |
3 | Размер (uint16) и адрес (uint32) массива char |
4 | Размер (uint16) и адрес (uint16) массива char |
5 | Размер (uint32) и адрес (uint32) массива int16 |
6 | float |
Структура B:
Поле | Описание |
---|---|
1 | int64 |
2 | int64 |
3 | uint8 |
4 | int32 |
5 | Адрес (uint16) структуры C |
6 | int8 |
7 | int64 |
Структура C:
Поле | Описание |
---|---|
1 | Структура D |
2 | uint8 |
Структура D:
Поле | Описание |
---|---|
1 | uint16 |
2 | uint16 |
Ниже показаны примеры разбора двоичного формата.
Пример 1
Двоичные данные:
b'RBDX\xc5\xe0i\xc4\xc1?\xeb\x82Q`\\\x89\xf8\xbdG\xfa\x9e\x85eNQ\x13\x1d\xf2'
(b'\x18d_\x00;r\xc8=\xab\xf3m-\xbd\xd8Rd\xa5\x05/\x15\x92`\x1cs\x7f\x8f\xcem'
b'\xe8O\xb9\xfa\xf7Gd\x00@5\x1d\xear\xf6J/\xc1\x06\x00i\x00\x00\x00\x05'
b'\x00o\x00\x05\x00\x00\x00t\x00\x00\x00\xcd\x1f\xb6>\x1a\xf1\xa5\xacY'
b'\x90J\xb9\xc0/kyzdynlsmtvZe\xa8H\x12$\xd6\x05\x99\x08')
Результат разбора:
'A1': 3250874848,
{'A2': [{'B1': -537797111739913409,
'B2': 5858731789827852221,
'B3': 19,
'B4': 1679356445,
'B5': {'C1': {'D1': 61722, 'D2': 44197}, 'C2': 89},
'B6': 59,
'B7': -4815071533271758734},
'B1': -7920372668364991784,
{'B2': -1698474368734913440,
'B3': 79,
'B4': 1207433913,
'B5': {'C1': {'D1': 19088, 'D2': 49337}, 'C2': 47},
'B6': 64,
'B7': -4526316678133703371}],
'A3': 'kyzdyn',
'A4': 'lsmtv',
'A5': [25946, 18600, 9234, 1494, 2201],
'A6': 0.3557113707065582}
Пример 2
Двоичные данные:
b'RBDX\xc5\xf2\x08\xfb\xb5;\xab\xe0\x1e\xf9O\xbe"\xad\x04\xe7\xfe\xcc\x90\x1e'
(b'EL\xd2\xc94X_\x00\xf6\xb0\xe6\t{\x04\xc6=\xcc\x15\xcc\xbfZ~\xeb0\xb8\xffNb'
b'\xb8\x8f<=\xb0\xe1O\xb8z\x84d\x00\x02\xf2\xe4\xe7\\\xf7.\x11\xf0\x03\x00i'
b'\x00\x00\x00\x05\x00l\x00\x03\x00\x00\x00q\x00\x00\x00\x08 \xa8>j'
b'\x0e\x0b\xf0{\x14Z\x08V*ruyakstx-`v\x85L\x1d')
Результат разбора:
'A1': 3053127922,
{'A2': [{'B1': 2503526374248065851,
'B2': 4980577448042628269,
'B3': 76,
'B4': 1479854546,
'B5': {'C1': {'D1': 3690, 'D2': 61451}, 'C2': 123},
'B6': -10,
'B7': -3729607193846487376},
'B1': -5174377043927774187,
{'B2': -5747370961483444481,
'B3': 225,
'B4': -2072332209,
'B5': {'C1': {'D1': 23060, 'D2': 22024}, 'C2': 42},
'B6': 2,
'B7': -1148084790052264718}],
'A3': 'ruy',
'A4': 'akstx',
'A5': [24621, -31370, 7500],
'A6': 0.3283693790435791}
Задача №12
Реализовать разбор двоичного формата данных. Данные начинаются с сигнатуры 0x54 0x59 0x4f
, за которой следует структура A.
Порядок байт: от младшего к старшему. Адреса указаны в виде смещений от начала данных. В решении предлагается использовать модуль
struct.
Структура A:
Поле | Описание |
---|---|
1 | Массив адресов (uint16) структур B, размер 8 |
2 | Адрес (uint16) структуры C |
3 | float |
4 | int64 |
Структура B:
Поле | Описание |
---|---|
1 | Размер (uint32) и адрес (uint16) массива char |
2 | uint8 |
3 | int64 |
Структура C:
Поле | Описание |
---|---|
1 | float |
2 | Адрес (uint32) структуры D |
3 | int8 |
4 | int8 |
Структура D:
Поле | Описание |
---|---|
1 | Размер (uint32) и адрес (uint16) массива int32 |
2 | Размер (uint16) и адрес (uint16) массива uint32 |
3 | uint16 |
4 | Массив uint16, размер 2 |
Ниже показаны примеры разбора двоичного формата.
Пример 1
Двоичные данные:
b'TYO$\x005\x00G\x00Y\x00j\x00|\x00\x8e\x00\xa0\x00\xe3\x00\t\xac%'
(b'\xbe,\xb6\x08\x99\xc2l\xdcUvrq\x03\x00\x00\x00!\x00\x9e\xa6\xce\x14\xc8G'
b';\xbe\x84nf\x02\x00\x00\x003\x00\xf7<(\xb9\x10:\xbay\xe4frg\x03\x00\x00\x00D'
b'\x00\x08\x9a\xa1_Tj\xd9\x8a\xbclau\x03\x00\x00\x00V\x00\x9d\xf8{\xd6\xbd'
b'\x94\xebm\xa4ez\x02\x00\x00\x00h\x00\xd0h\xf4\x8bK~\xcd\x10uzkc'
b'\x03\x00\x00\x00y\x00\xb6\xed\x85V\xc5\x93M\xd0\xdaqau\x03\x00'
b'\x00\x00\x8b\x00\x17\xcaK+\xeeG\xef\xe6\xf4xht\x03\x00\x00\x00'
b'\x9d\x00\xec\x93\xc8rO\x9a\xd6\x0b/\x9f\xa3\xc6\x07\x88\x8d\xc3.\xe4'
b'\xf6/\x86\xe3\xbe<\x91\xa6\xa4\xb7P\x0b\xd94\x9d\xc2\xfa\x0eA\x91'
b'\x18\xac\x15q\x9e\x86\x91\x06\x00\x00\x00\xaf\x00\x03\x00\xc7\x00\xb5+q'
b'\x9eOC\x84!x\xbf\xd3\x00\x00\x00\xafM')
Результат разбора:
'A1': [{'B1': 'vrq', 'B2': 158, 'B3': -8881596235642515802},
{'B1': 'nf', 'B2': 247, 'B3': -1983349402328553412},
{'B1': 'frg', 'B2': 8, 'B3': -4860833797087714918},
{'B1': 'lau', 'B2': 157, 'B3': -6598358854955271176},
{'B1': 'ez', 'B2': 208, 'B3': 8435468044381975656},
{'B1': 'zkc', 'B2': 182, 'B3': -2679556481219131923},
{'B1': 'qau', 'B2': 23, 'B3': -799688791594153014},
{'B1': 'xht', 'B2': 236, 'B3': 3390039102772660371}],
{'A2': {'C1': -0.9692614078521729,
'C2': {'D1': [130458527,
784567688,
-2043676956,
-1858289949,
1354212518,
-1657480949],
'D2': [1091500738, 363600017, 2441518705],
'D3': 11189,
'D4': [40561, 17231]},
'C3': -81,
'C4': 77},
'A3': -0.16178907454013824,
'A4': 6186939571147159084}
Пример 2
Двоичные данные:
b'TYO#\x005\x00G\x00X\x00j\x00{\x00\x8c\x00\x9e\x00\xd1\x00\x8a\xc0('
(b'?\x88\xb1\x99\x03\xed\x11\xa2\x0fkq\x02\x00\x00\x00!\x00K~FT\xde<xw\xb7yu'
b'h\x03\x00\x00\x002\x00;\x0b\xb4K?\x10\xa2SZvhz\x03\x00\x00\x00D\x00\xec\x105'
b"\xf6M\x9b\xd0\xf9\xcbca\x02\x00\x00\x00V\x00\xf1\tZ\xdd\x04'I\xf9\x98q"
b'xn\x03\x00\x00\x00g\x00>\xdc{\x1c\xf0\xdb\x94\x01\x8bal\x02\x00\x00\x00y'
b'\x00\x00\x1e\x90\x96l\x8c\xd1\x9c\\vl\x02\x00\x00\x00\x8a\x00\x8d~k\xd8C\xcd'
b'6\xf50sin\x03\x00\x00\x00\x9b\x00B\x9aU]\xb0\xa1r\xf8\xef\xfe\xe0VX\x92D\xcc'
b'\x16\x80l\xca~B\x19\x8cJ\x8b\xd7x\x86\x02\x00\x00\x00\xad\x00\x03'
b'\x00\xb5\x00\x00\xbf\xb5\x90\xb9\x8e\x85\xf0*?\xc1\x00\x00\x00/+')
Результат разбора:
'A1': [{'B1': 'kq', 'B2': 75, 'B3': -5226576639716735362},
{'B1': 'yuh', 'B2': 59, 'B3': 6508724077145601035},
{'B1': 'vhz', 'B2': 236, 'B3': -3748735849362737904},
{'B1': 'ca', 'B2': 241, 'B3': -7423822078809384439},
{'B1': 'qxn', 'B2': 62, 'B3': -8430293355113710628},
{'B1': 'al', 'B2': 0, 'B3': 6673439148903665694},
{'B1': 'vl', 'B2': 141, 'B3': 3527786138349103998},
{'B1': 'sin', 'B2': 66, 'B3': -1155047265646324326}],
{'A2': {'C1': 0.6677325367927551,
'C2': {'D1': [1482088702, 382485650],
'D2': [2127195264, 1250695490, 2256066443],
'D3': 48896,
'D4': [37045, 36537]},
'C3': 47,
'C4': 43},
'A3': 0.659187912940979,
'A4': 1126482566461370760}
Задача №12
Реализовать разбор двоичного формата данных. Данные начинаются с сигнатуры 0x53 0x53 0x4c 0x43 0x0
, за которой следует
структура A. Порядок байт: от младшего к старшему. Адреса указаны в виде смещений от начала данных. В решении предлагается использовать
модуль struct.
Структура A:
Поле | Описание |
---|---|
1 | float |
2 | Размер (uint32) и адрес (uint16) массива адресов (uint32) структур B |
3 | Массив char, размер 8 |
4 | int8 |
5 | Массив uint16, размер 3 |
6 | Размер (uint32) и адрес (uint32) массива int16 |
Структура B:
Поле | Описание |
---|---|
1 | double |
2 | Структура C |
Структура C:
Поле | Описание |
---|---|
1 | uint32 |
2 | uint8 |
3 | uint32 |
4 | Структура D |
Структура D:
Поле | Описание |
---|---|
1 | uint64 |
2 | Размер (uint32) и адрес (uint32) массива uint8 |
Ниже показаны примеры разбора двоичного формата.
Пример 1
Двоичные данные:
b'SSLC\x00\xcd\x9a\x1a\xbf\x03\x00\x00\x00\x91\x00wxhhsamrJ\xacNP\xc8'
(b'v\xcf\x03\x00\x00\x00\x9d\x00\x00\x00\xd8\x03\xd0&l\xf6\x98\x88\xd2\xbf'
b'\xbf\xef\xfe\xaa6\xc65\x9eo\xac\x9f\x10N\x8f\x97\x1b\x80\x02\x00\x00'
b'\x00&\x00\x00\x00\t\xb1\x9f\x00\x01\xfe\xd6\xbf\xb1\x8a\xbf\xa9S\x1bDRNL\x1b'
b'o\xe5;[ti\xfdU\xbe\x03\x00\x00\x00I\x00\x00\x00\xfe\xc7\x9cD\xb2\x08P'
b'c\xef\xd9\xbfG\xec\xedR/#\xe5\xb8\xf2AY"\x064\xe1\xe0\x8e\x03\x00\x00'
b'\x00m\x00\x00\x00(\x00\x00\x00L\x00\x00\x00p\x00\x00\x00\nK\x14+\xfb\x97')
Результат разбора:
'A1': -0.603924572467804,
{'A2': [{'B1': -0.28958725037283006,
'B2': {'C1': 2868834239,
'C2': 54,
'C3': 1872639430,
'C4': {'D1': 9231138502971793324, 'D2': [216, 3]}}},
'B1': -0.013034342525998444,
{'B2': {'C1': 1142641577,
'C2': 82,
'C3': 1864059982,
'C4': {'D1': 13715146869592243173, 'D2': [9, 177, 159]}}},
'B1': -0.40523608032052416,
{'B2': {'C1': 1391324231,
'C2': 47,
'C3': 4072203555,
'C4': {'D1': 10295476361726417217, 'D2': [254, 199, 156]}}}],
'A3': 'wxhhsamr',
'A4': 74,
'A5': [20140, 51280, 53110],
'A6': [19210, 11028, -26629]}
Пример 2
Двоичные данные:
b'SSLC\x000\x08=?\x02\x00\x00\x00l\x00ugszltcq\xca\x93\t\xcbo\x9c\x0e\x03\x00'
(b'\x00\x00t\x00\x00\x00\x14}`\xd7\xe67\x18\xa8\xee?\x8eYO\xa9\x7f[\xc8\x07'
b'\xdbov\xbd\x97\x95V\x07\x92\x02\x00\x00\x00&\x00\x00\x00\x8b\xcf\x18'
b'\xcd\xb2\xa7\xde\x1e\xd5?.<pi\x95\xe5\x94;.i\xa1\xaeCpO\xe7x\x02\x00\x00\x00'
b'I\x00\x00\x00(\x00\x00\x00K\x00\x00\x00\xa9mC\xbb\x05q')
Результат разбора:
'A1': 0.7384061813354492,
{'A2': [{'B1': 0.9580193607168717,
'B2': {'C1': 2840549774,
'C2': 127,
'C3': 3674720347,
'C4': {'D1': 10522474254870345327, 'D2': [20, 125]}}},
'B1': 0.3300091397934053,
{'B2': {'C1': 1768963118,
'C2': 149,
'C3': 775656677,
'C4': {'D1': 8712019347761963369, 'D2': [139, 207]}}}],
'A3': 'ugszltcq',
'A4': -54,
'A5': [2451, 28619, 3740],
'A6': [28073, -17597, 28933]}
Задача №12
Реализовать разбор двоичного формата данных. Данные начинаются с сигнатуры 0x53 0x54 0x4a 0x5a
, за которой следует структура
A. Порядок байт: от младшего к старшему. Адреса указаны в виде смещений от начала данных. В решении предлагается использовать модуль
struct.
Структура A:
Поле | Описание |
---|---|
1 | Размер (uint16) и адрес (uint32) массива адресов (uint32) структур B |
2 | Структура C |
3 | int8 |
4 | uint8 |
5 | uint32 |
Структура B:
Поле | Описание |
---|---|
1 | int8 |
2 | double |
Структура C:
Поле | Описание |
---|---|
1 | Структура D |
2 | Адрес (uint32) структуры F |
3 | int64 |
4 | float |
Структура D:
Поле | Описание |
---|---|
1 | double |
2 | double |
3 | uint16 |
4 | Адрес (uint16) структуры E |
5 | uint64 |
Структура E:
Поле | Описание |
---|---|
1 | Размер (uint16) и адрес (uint16) массива float |
2 | uint64 |
Структура F:
Поле | Описание |
---|---|
1 | Массив int8, размер 8 |
2 | uint16 |
3 | Размер (uint16) и адрес (uint16) массива int8 |
4 | int64 |
5 | int32 |
Ниже показаны примеры разбора двоичного формата.
Пример 1
Двоичные данные:
b'STJZ\x04\x00`\x00\x00\x00L_\xd3\xa6V\xfe\xd9?(k\xa1\xfd\xa5\x81\xe7?\xafr'
(b'|\x00j\xda\xb2.\x1fu\xbdW\x8a\x00\x00\x00\xde\xcfd\x95F\xfd\x82\xef$\x9c'
b"M?o\xb4\x98\xf35Rq\xb8\xbc\x14\xe2\xdb\x8b\xd7\xbf\xd2\x00\xc0'\xf7)\xad"
b'O\xbf\xcdf%\xd9oa2\xe7\xbf\xa0\xf0\x1a\xb44\xa9\x82\xb4?<\x00\x00\x00'
b'E\x00\x00\x00N\x00\x00\x00W\x00\x00\x00`\x18P?\xea\xb1\xfc>\xf6\xd3\xd3>'
b"\x03\x00p\x00G\xea&(G\xb0\xe7\xbc\xb9\x0c\xf0\x00\x90'\xec\xe8+\xc3%\xf4"
b'\x02\x00\x88\x00}{\xef\x03\xa8\xd1\x12:\x10\xaa\x11\x14')
Результат разбора:
'A1': [{'B1': 113, 'B2': -0.36791131094191654},
{'B1': -46, 'B2': -0.0009666876706528882},
{'B1': -51, 'B2': -0.724899977162903},
{'B1': -96, 'B2': 0.08011872803409026}],
{'A2': {'C1': {'D1': 0.4061485890538179,
'D2': 0.734576220867301,
'D3': 29359,
'D4': {'E1': [0.8128719329833984,
0.49354487657546997,
0.4137265086174011],
'E2': 13612042218413419079},
'D5': 6322338228685953642},
'C2': {'F1': [-16, 0, -112, 39, -20, -24, 43, -61],
'F2': 62501,
'F3': [-71, 12],
'F4': 4184637523331349373,
'F5': 336701968},
'C3': -1188108872076439586,
'C4': 0.8031637668609619},
'A3': 111,
'A4': 180,
'A5': 1379267480}
Пример 2
Двоичные данные:
b'STJZ\x02\x00N\x00\x00\x00lt\xd8\xeb\x1bq\xeb\xbf\x0c\xe3\xb1\xfeDE'
(b'\xec\xbf\xbaOf\x00?\xe2\xfe\x0f\xaf\xef\x0e\xfdt\x00\x00\x00\xb3}'
b'\x19~\xe6\x1d\x1e\xb1M\xa0\x04\xbf\x1b\x12%\xd7 jUp\xc1\xdd\xaa|.\xe6'
b'\xbf\x950\xee\xde\x87-\x1a\xb4?<\x00\x00\x00E\x00\x00\x00+\xdb=?\r\x87'
b'k\xbff*\x8d\xbe\x8f\t\x10\xbf\x04\x00V\x00\xa6\xc1\xaa\x07\x99\xd1'
b'3\xce\xab\xba\x90\x9b=\nKt\xbe\x18\xe4\xb8\x02\x00r\x00dT\xeaE\xbd\x11'
b'\xcf!q\x7f\x12F')
Результат разбора:
'A1': [{'B1': 85, 'B2': -0.693174680445777},
{'B1': -107, 'B2': 0.07852444235953082}],
{'A2': {'C1': {'D1': -0.8575572592122973,
'D2': -0.8834557508954233,
'D3': 20410,
'D4': {'E1': [0.7416254878044128,
-0.9200294613838196,
-0.27571409940719604,
-0.5626458525657654],
'E2': 14858450050814230950},
'D5': 18234775476436394559},
'C2': {'F1': [-112, -101, 61, 10, 75, 116, -66, 24],
'F2': 47332,
'F3': [-85, -70],
'F4': 2436185428050203748,
'F5': 1175617393},
'C3': -5684072803899703885,
'C4': -0.5180709958076477},
'A3': 27,
'A4': 18,
'A5': 1780537125}
Задача №12
Реализовать разбор двоичного формата данных. Данные начинаются с сигнатуры 0x42 0x57 0x58 0x57
, за которой следует структура
A. Порядок байт: от старшего к младшему. Адреса указаны в виде смещений от начала данных. В решении предлагается использовать модуль
struct.
Структура A:
Поле | Описание |
---|---|
1 | Структура B |
2 | int32 |
3 | Структура C |
4 | Массив адресов (uint16) структур D, размер 2 |
5 | int8 |
Структура B:
Поле | Описание |
---|---|
1 | int64 |
2 | double |
3 | Размер (uint16) и адрес (uint16) массива char |
4 | int64 |
Структура C:
Поле | Описание |
---|---|
1 | uint16 |
2 | uint8 |
3 | int16 |
4 | Массив char, размер 2 |
5 | uint32 |
6 | uint8 |
7 | float |
8 | int32 |
Структура D:
Поле | Описание |
---|---|
1 | int64 |
2 | Размер (uint16) и адрес (uint16) массива uint32 |
Ниже показаны примеры разбора двоичного формата.
Пример 1
Двоичные данные:
b'BWXWwK\x80A<\x06L\xd2\xbf\xe3\xd4\xd6g\xdce\xe4\x00\x05\x00=\xca1\xc2\x91'
(b'\xd2\xe2\n@\x8e\x88\xb3\xbdM\x18\xb0\xb8\xd2bv@\xfeiH\xae?oP\xb5'
b'\x8d\xe9V\x1c\x00N\x00f\xd4gsikp\x94o\xce\xa2w*\x9d\xeb\xb0e]\xae\x14z'
b'\xc5\xf6>:\xc8\xb5\x00\x03\x00B2\xcf\x18\xf3\x95\xcf\xde\xf7\x9d9'
b'\xfd=\xd5\xd5_mK\xf4]9\x00\x03\x00Z')
Результат разбора:
'A1': {'B1': 8596105331434998994,
{'B2': -0.6197311428579124,
'B3': 'gsikp',
'B4': -3877103872625210816},
'A2': -1903643715,
'A3': {'C1': 19736,
'C2': 176,
'C3': -18222,
'C4': 'bv',
'C5': 1090414920,
'C6': 174,
'C7': 0.9348252415657043,
'C8': -1914087908},
'A4': [{'D1': 1475709489313925301, 'D2': [2490355362, 1999281643, 2959433134]},
'D1': -3038417450561151687,
{'D2': [852433139, 2513428215, 2637823293]}],
'A5': -44}
Пример 2
Двоичные данные:
b'BWXWh\xf6\x9c\x1a*%\xbe`?\xee\xbd\x8c)A\x9b\x10\x00\x03\x00=Q\x1f\xb7\xe9'
(b'\xdc\xb0y\x80R4gBs\xde\x19>\x0egx\x83=E\xe4f?C\\i\xd7\x15\x0e\xa4\x00H\x00\\'
b'\x16zoq%h\xc9q\xa6U"og\x1fJK2\xaa\xbb\x80\x00\x02\x00@ \x0c-\x91'
b'\xe3F\x17\xea<\xe2\xbd\x1fd\xf8\xa1\xd7\x00\x02\x00T')
Результат разбора:
'A1': {'B1': 7563404260405526112,
{'B2': 0.9606381231104439,
'B3': 'zoq',
'B4': 5845593056408009088},
'A2': 1379166018,
'A3': {'C1': 29662,
'C2': 25,
'C3': 15886,
'C4': 'gx',
'C5': 2201830884,
'C6': 102,
'C7': 0.7631288170814514,
'C8': -686485852},
'A4': [{'D1': 7430739597017660288, 'D2': [627624305, 2790597231]},
'D1': 4387276929547936215, 'D2': [537669009, 3813021674]}],
{'A5': 22}
Задача №12
Реализовать разбор двоичного формата данных. Данные начинаются с сигнатуры 0x47 0x51 0x43 0x56
, за которой следует структура
A. Порядок байт: от младшего к старшему. Адреса указаны в виде смещений от начала данных. В решении предлагается использовать модуль
struct.
Структура A:
Поле | Описание |
---|---|
1 | uint32 |
2 | Структура B |
3 | uint8 |
4 | Структура E |
Структура B:
Поле | Описание |
---|---|
1 | uint32 |
2 | Структура C |
3 | uint32 |
4 | int32 |
Структура C:
Поле | Описание |
---|---|
1 | uint64 |
2 | Размер (uint32) и адрес (uint32) массива структур D |
3 | uint8 |
Структура D:
Поле | Описание |
---|---|
1 | float |
2 | float |
3 | float |
4 | Размер (uint16) и адрес (uint32) массива uint32 |
5 | Размер (uint32) и адрес (uint16) массива int16 |
6 | uint8 |
7 | uint16 |
Структура E:
Поле | Описание |
---|---|
1 | Массив uint8, размер 7 |
2 | uint8 |
3 | int64 |
4 | uint8 |
5 | uint16 |
6 | int8 |
Ниже показаны примеры разбора двоичного формата.
Пример 1
Двоичные данные:
b'GQCV\xf9\xd3\xd4\x07\xdck\x95\xabh\x96\xc7y\xf9)\xe9\x88\x02\x00\x00\x00'
(b'p\x00\x00\x00hA\x96\xdet\x15~]\xe8{.\x1b@z\x99\x91\t\xb3\x13K\x9e0\xb7\x9f'
b'\xe46\xec W\xc7>h;\x91*\xc0\\si\xad\xd1\xbd*\x01x\x1en\xd8{L{:\xb1F\x94\x99'
b'|\xd6\xc8\xfc\xe9\x82>\x86\xf9{\xf6\x04l\xdf\xcf \xcd\xd1e\x93\xf9\x9cmt'
b'\xd1\xa6j`\xe5\x86V?(\xe0Y=\xe3\xa3\xe7\xbe\x03\x00:\x00\x00\x00\x04\x00'
b'\x00\x00F\x00\xefj\x9b\xbaC\x8c>\xd9<">\xb70\x02?\x07\x00N\x00\x00'
b'\x00\x03\x00\x00\x00j\x00KI\xae')
Результат разбора:
'A1': 131388409,
{'A2': {'B1': 2878696412,
'B2': {'C1': 9865462610198500968,
'C2': [{'D1': 0.8379958271980286,
'D2': 0.05319228768348694,
'D3': -0.45242223143577576,
'D4': [2436589630, 1935458346, 3184635241],
'D5': [298, 7800, -10130, 19579],
'D6': 239,
'D7': 39786},
'D1': 0.27395421266555786,
{'D2': 0.15843524038791656,
'D3': 0.5085558295249939,
'D4': [1186019963,
3598490004,
2196372680,
2079950398,
3748398326,
3519881423,
2633601893],
'D5': [29805, -22831, 24682],
'D6': 75,
'D7': 44617}],
'C3': 104},
'B3': 1960744513,
'B4': -396526059},
'A3': 123,
'A4': {'E1': [46, 27, 64, 122, 153, 145, 9],
'E2': 179,
'E3': 3955461981881649939,
'E4': 236,
'E5': 22304,
'E6': -57}}
Пример 2
Двоичные данные:
b"GQCV\x9c\x1e\xbd\x14\xc7p\xa4\xf6\xff\x19\xb2'7\xd0\xbe:\x02\x00\x00\x00"
(b'Z\x00\x00\x00 \x0c\x84\x03\xf6\xa7\x82\xa3y61\xd8\xe4C\x08M\xce\xe8\x87K'
b',\x8cF\xcc\x9a\xd1LX\xcb\xbb,\xed\xab\xc2Y6y\xe3\xe3\xff\x8e7\x11}[\xf7cX'
b'\x9e\xf5\xff\xc4\x81n=n\xeewP`\xb4\x8b\x83\xf7\xe2>:\x0e9\xbe\xcd\xe2'
b'@?\x04\x00:\x00\x00\x00\x02\x00\x00\x00J\x00\xb45\x818\xfe\x1d?\xfd\x85\xaa'
b'\xben-O?\x02\x00N\x00\x00\x00\x02\x00\x00\x00V\x00\x91\x02@')
Результат разбора:
'A1': 347938460,
{'A2': {'B1': 4137971911,
'B2': {'C1': 4233049635082607103,
'C2': [{'D1': 0.44329461455345154,
'D2': -0.180718332529068,
'D3': 0.753460705280304,
'D4': [3266047276, 3816371801, 932118499, 4149968145],
'D5': [22627, -2658],
'D6': 180,
'D7': 33077},
'D1': 0.6171603202819824,
{'D2': -0.33305349946022034,
'D3': 0.8092869520187378,
'D4': [1853998335, 2012114493],
'D5': [24656, -29772],
'D6': 145,
'D7': 16386}],
'C3': 32},
'B3': 4127425548,
'B4': 2040758951},
'A3': 54,
'A4': {'E1': [49, 216, 228, 67, 8, 77, 206],
'E2': 232,
'E3': -3343135169997681785,
'E4': 76,
'E5': 52056,
'E6': -69}}
Задача №12
Реализовать разбор двоичного формата данных. Данные начинаются с сигнатуры 0x41 0x4f 0x55 0x42 0xba
, за которой следует
структура A. Порядок байт: от старшего к младшему. Адреса указаны в виде смещений от начала данных. В решении предлагается использовать
модуль struct.
Структура A:
Поле | Описание |
---|---|
1 | uint16 |
2 | Структура B |
3 | Структура F |
4 | uint8 |
Структура B:
Поле | Описание |
---|---|
1 | uint8 |
2 | Структура C |
3 | uint16 |
4 | Адрес (uint16) структуры D |
5 | Размер (uint32) и адрес (uint16) массива uint8 |
Структура C:
Поле | Описание |
---|---|
1 | int8 |
2 | uint32 |
3 | int8 |
Структура D:
Поле | Описание |
---|---|
1 | Массив структур E, размер 2 |
2 | float |
3 | int32 |
4 | uint8 |
Структура E:
Поле | Описание |
---|---|
1 | Размер (uint32) и адрес (uint16) массива int8 |
2 | Массив uint32, размер 5 |
3 | int64 |
4 | uint16 |
5 | Размер (uint16) и адрес (uint16) массива int8 |
Структура F:
Поле | Описание |
---|---|
1 | uint8 |
2 | int32 |
3 | uint16 |
4 | uint32 |
5 | double |
Ниже показаны примеры разбора двоичного формата.
Пример 1
Двоичные данные:
b'AOUB\xbaK\xf4[.\xf0)\x97}}\x0e=\x007\x00\x00\x00\x03\x00\x90\xf5>\xe4\xb6'
(b'\x8c\x17\xbc0\x0b\x7f\xbf?\xee\xd9>\xa2b*\x10\x08\xbf\x14\x95\xec1\xd2ki'
b'\xe7\xd5\xbf\x00\x00\x00\x04\x00,?\xfb(fX\xfd70\xb7\x06B\xf4(\x1fq\xa2RW\xa9'
b'\x9b=a\x01\xb6/\xd9\xc1\xab\x03l\x00\x02\x000\x00\x00\x00\x03\x002\x11;\xbc'
b'S/\x13\xd8\xe9>Yd\xb7\xb1\xa7G\xb8\x98\x88\xe6\x98\xe6Kj\xec\xe9#&RVC\x00'
b'\x02\x005>\xde\xd0\xb8t\xea\xb6\x0f\x18\xd6\xd9\xf4')
Результат разбора:
'A1': 19444,
{'A2': {'B1': 91,
'B2': {'C1': 46, 'C2': 4029257597, 'C3': 125},
'B3': 3645,
'B4': {'D1': [{'E1': [-65, 20, -107, -20],
'E2': [1073424486,
1492989744,
3070640884,
673149346,
1381476763],
'E3': 4422818191053013419,
'E4': 876,
'E5': [49, -46]},
'E1': [107, 105, -25],
{'E2': [289127507,
789829865,
1046045879,
2980530104,
2559108760],
'E3': -1852269255976606126,
'E4': 22083,
'E5': [-43, -65]}],
'D2': 0.43518614768981934,
'D3': 1961539087,
'D4': 24},
'B5': [214, 217, 244]},
'A3': {'F1': 245,
'F2': 1055176332,
'F3': 6076,
'F4': 806059967,
'F5': 0.9640191241790621},
'A4': 8}
Пример 2
Двоичные данные:
b'AOUB\xba\xdc\xe8\x90\x17\x8f\x9d*\x0c\xa7?\xce\x006\x00\x00\x00\x02\x00\x8f'
(b'\x93x\xee\xc4 :Q\x97\xf3SM\xbfn\xb4\xec\t$\x1c\x00U\x9e\xaf\xfb\xb9'
b'\xf3\xe5\x06\x0c\x07\xa8\x00\x00\x00\x03\x00,Y\xc8\xf1kn\x17\x9c\xc8'
b'\xc3\x1bM\x1f\x11\xfa\t\xb4>Q{Np\n\x9fc=\xe57\x10DC\x00\x02\x00/\x00\x00'
b'\x00\x03\x001\xe1\xa5\x97\xa2{w\x07\xfd\xb4\x1e\xe3"|\xba\xd3~\xb3?~ '
b'\x8d\xde\r+\xfe\xea\xc2A\xa9\xf7\x00\x02\x004=\xb8\x86\xa5\x96w\xc3{K\xfc'
b'\x19')
Результат разбора:
'A1': 56552,
{'A2': {'B1': 144,
'B2': {'C1': 23, 'C2': 2409441804, 'C3': -89},
'B3': 16334,
'B4': {'D1': [{'E1': [-98, -81, -5],
'E2': [1506341227,
1847041224,
3273346335,
301599156,
1045527374],
'E3': 8073440530604046096,
'E4': 17475,
'E5': [-71, -13]},
'E1': [-27, 6, 12],
{'E2': [3785725858,
2071398397,
3021923106,
2092618622,
3007282720],
'E3': -8224121386920394175,
'E4': 43511,
'E5': [7, -88]}],
'D2': 0.09010056406259537,
'D3': -1770536069,
'D4': 75},
'B5': [252, 25]},
'A3': {'F1': 147,
'F2': 2028913696,
'F3': 14929,
'F4': 2549306189,
'F5': -0.0037483797142416897},
'A4': 85}
Задача №12
Реализовать разбор двоичного формата данных. Данные начинаются с сигнатуры 0xec 0x54 0x52 0x54 0x51
, за которой следует
структура A. Порядок байт: от старшего к младшему. Адреса указаны в виде смещений от начала данных. В решении предлагается использовать
модуль struct.
Структура A:
Поле | Описание |
---|---|
1 | Массив адресов (uint32) структур B, размер 3 |
2 | Массив char, размер 8 |
3 | Адрес (uint16) структуры C |
4 | double |
5 | Адрес (uint16) структуры D |
6 | uint32 |
Структура B:
Поле | Описание |
---|---|
1 | int32 |
2 | float |
Структура C:
Поле | Описание |
---|---|
1 | int16 |
2 | int32 |
3 | float |
4 | int64 |
Структура D:
Поле | Описание |
---|---|
1 | Массив uint32, размер 2 |
2 | Массив uint8, размер 3 |
Ниже показаны примеры разбора двоичного формата.
Пример 1
Двоичные данные:
b'\xecTRTQ\x00\x00\x00)\x00\x00\x001\x00\x00\x009zcbelzuo\x00A\xbf\xe6U\xb0_'
(b']-$\x00S~b\xbb\xea\xac\x9ad\xd0\xbfU\xb9\x9f2c\xa4\xe2?U\xc7O\x90\xaa\xa6'
b'\xec>\x8enZr\n\x92{\xb1\xbd\xbfT\xbeV\xc37h\xa7K\xdd\xe6\xea4#*\xae\xc2'
b'\xa4${\xe0\xb7\x14')
Результат разбора:
'A1': [{'B1': -1399167792, 'B2': -0.8348636031150818},
{'B1': 845391074, 'B2': 0.8350724577903748},
{'B1': -1867864340, 'B2': 0.2781856656074524}],
{'A2': 'zcbelzuo',
'A3': {'C1': 29194,
'C2': -1837387331,
'C3': -0.8310292959213257,
'C4': -4379917044852857110},
'A4': -0.69796007753158,
'A5': {'D1': [874719918, 3265537147], 'D2': [224, 183, 20]},
'A6': 2120399850}
Пример 2
Двоичные данные:
b'\xecTRTQ\x00\x00\x00)\x00\x00\x001\x00\x00\x009bdxpgwzx\x00A?\xe6\xaae\x8f'
(b'p\xa5R\x00S\xe7\xa9\xc3\xf8\xa0\xd3\xd08?\x06\x87=\xbcil\xb4?+\xe1'
b'\xe8d\xef\x01\x94?_vw\x82\xba\x862\x06\x1d\xbe-\x02\xac\xe3M\x16\xcb]'
b'\x81\r\xaf\x07\xf3\x05\x0f\xdf\x8bua\x0e\x99q')
Результат разбора:
'A1': [{'B1': -1596731336, 'B2': 0.5255010724067688},
{'B1': -1133941580, 'B2': 0.6714158058166504},
{'B1': 1693385108, 'B2': 0.8729013800621033}],
{'A2': 'bdxpgwzx',
'A3': {'C1': -32070,
'C2': -2043541987,
'C3': -0.1689555048942566,
'C4': -2067971591190278737},
'A4': 0.7083003808558408,
'A5': {'D1': [133367055, 3750458721], 'D2': [14, 153, 113]},
'A6': 3886662648}
Задача №12
Реализовать разбор двоичного формата данных. Данные начинаются с сигнатуры 0x61 0x54 0x50 0x46
, за которой следует структура
A. Порядок байт: от младшего к старшему. Адреса указаны в виде смещений от начала данных. В решении предлагается использовать модуль
struct.
Структура A:
Поле | Описание |
---|---|
1 | Структура B |
2 | uint64 |
3 | Размер (uint16) и адрес (uint16) массива структур D |
Структура B:
Поле | Описание |
---|---|
1 | Размер (uint16) и адрес (uint32) массива char |
2 | uint8 |
3 | Адрес (uint16) структуры C |
4 | double |
5 | Размер (uint16) и адрес (uint32) массива char |
6 | int16 |
7 | uint8 |
8 | int32 |
Структура C:
Поле | Описание |
---|---|
1 | int64 |
2 | float |
Структура D:
Поле | Описание |
---|---|
1 | Массив uint8, размер 3 |
2 | int64 |
Ниже показаны примеры разбора двоичного формата.
Пример 1
Двоичные данные:
b'aTPF\x04\x00.\x00\x00\x00\x0b2\x00\xc0\xd8\xa5R\xb9\xbc\xd7\xbf\x03\x00>'
(b'\x00\x00\x00\xd6tt \x80|+\xec,\x10\x10(f~T\x06\x00A\x00xwnd\xb5\x03'
b'\xc8\xee\x80\xafGq\x17T\xb3\xbddyyb7\xac\x83\r\xeb];|\xad\xcfM$\x8f\xd6'
b'\xe6h\xf8r\xe7+$\xe9\xe5lw\xf7i\xfd>\x17\xca\xe2\x8ap\xb0\x9f;[B\x93H\xee'
b'\xa9\xb3]\x13\x10w\xf9%\x8e\xe3F\x8d;\x1b\xe5\x10\xe2\xde\x13S}\x04x')
Результат разбора:
'A1': {'B1': 'xwnd',
{'B2': 11,
'B3': {'C1': 8162685817929073589, 'C2': -0.08756273239850998},
'B4': -0.3708937937839316,
'B5': 'dyy',
'B6': 29910,
'B7': 116,
'B8': 729579552},
'A2': 6088416068505709804,
'A3': [{'D1': [98, 55, 172], 'D2': -3481990342466925181},
'D1': [77, 36, 143], 'D2': 2606431290343876310},
{'D1': [233, 229, 108], 'D2': -2104844316535294089},
{'D1': [138, 112, 176], 'D2': -6201939839531926625},
{'D1': [179, 93, 19], 'D2': -8266669866329999600},
{'D1': [59, 27, 229], 'D2': 8648174980227326480}]} {
Пример 2
Двоичные данные:
b'aTPF\x04\x00.\x00\x00\x00\x9e2\x00\x80\xb7\x1f\x19\x9c[\x86\xbf\x04\x00>'
(b'\x00\x00\x00-\xb5x\x8a\xb1H\x87\xbe\xb4X\x83A\xc2\x1d\xb8\x06\x00B\x00aa'
b'qym\xae`&_\x1b\xfd\x11V\xd6F\xbdmypgh\x98.\x94g^\x82h\xfb\x81xm\xcf\x03'
b'\xb6\xba#<\xd0\x953v\xe6\x9d\xef\xcd3o\x13#\x8c\x1au\xfc\xb3o\xfe\x0b'
b'\x1b^%\x88R\x9664Y\xfc\xc0?IK\x0f\xb0\xc0\x06\xcc_\x9f"\xb7\xce\x89\x18(|')
Результат разбора:
'A1': {'B1': 'aaqy',
{'B2': 158,
'B3': {'C1': 1296222363232284269, 'C2': -0.048544250428676605},
'B4': -0.010916919247360601,
'B5': 'mypg',
'B6': -19155,
'B7': 120,
'B8': -2025279094},
'A2': 13266973663935640766,
'A3': [{'D1': [104, 152, 46], 'D2': 8683497982829422484},
'D1': [109, 207, 3], 'D2': 8517316041882450614},
{'D1': [230, 157, 239], 'D2': 8438210934109844429},
{'D1': [252, 179, 111], 'D2': -7614874325856089090},
{'D1': [54, 52, 89], 'D2': -4562129606500433668},
{'D1': [6, 204, 95], 'D2': 8946427639929184927}]} {
Задача №12
Реализовать разбор двоичного формата данных. Данные начинаются с сигнатуры 0x4f 0x48 0x55 0x53 0xd6
, за которой следует
структура A. Порядок байт: от старшего к младшему. Адреса указаны в виде смещений от начала данных. В решении предлагается использовать
модуль struct.
Структура A:
Поле | Описание |
---|---|
1 | Адрес (uint16) структуры B |
2 | Адрес (uint32) структуры E |
3 | int32 |
4 | Размер (uint16) и адрес (uint32) массива uint8 |
Структура B:
Поле | Описание |
---|---|
1 | float |
2 | Структура C |
Структура C:
Поле | Описание |
---|---|
1 | uint32 |
2 | float |
3 | uint8 |
4 | int16 |
5 | int64 |
6 | Размер (uint32) и адрес (uint16) массива структур D |
Структура D:
Поле | Описание |
---|---|
1 | int16 |
2 | int16 |
Структура E:
Поле | Описание |
---|---|
1 | uint8 |
2 | Размер (uint32) и адрес (uint16) массива char |
3 | Массив float, размер 4 |
4 | int16 |
5 | int8 |
6 | int64 |
Ниже показаны примеры разбора двоичного формата.
Пример 1
Двоичные данные:
b'OHUS\xd6\x00!\x00\x00\x00C\xec\xa6S\xb4\x00\x05\x00\x00\x00e\xa6\xa1\xae'
(b'\xdf\xfe;89\xfa~@\x9e?f\xfa\x1a<R7.\xbf\tD\x01\xf6\xc0\xe0\x82(\xe7i'
b'\xael\x95\x90\x00\x00\x00\x03\x00\x15gyjja\x84\x00\x00\x00\x05\x00>\xbf\x0f'
b'>\xdc>\xe0\xcc\xc2?-jP\xbfg\xb6]R\xed\x15\xd0\x80\xf9\xd9\xe8_\xb1'
b'c\xdc\x86\x07\xc3V')
Результат разбора:
'A1': {'B1': 0.9022537469863892,
{'B2': {'C1': 1012021038,
'C2': -0.5361939072608948,
'C3': 246,
'C4': -16160,
'C5': -9067743408626559600,
'C6': [{'D1': -22879, 'D2': -20769},
'D1': -453, 'D2': 14393},
{'D1': -1410, 'D2': 16542}]}},
{'A2': {'E1': 132,
'E2': 'gyjja',
'E3': [-0.5595529079437256,
0.4390621781349182,
0.677403450012207,
-0.9051263928413391],
'E4': 21229,
'E5': 21,
'E6': -3422461002499772061},
'A3': -324643916,
'A4': [220, 134, 7, 195, 86]}
Пример 2
Двоичные данные:
b'OHUS\xd6\x00)\x00\x00\x00Hq\xe8\x89\xf7\x00\x03\x00\x00\x00j\xac\x89?'
(b"g\xe5\xa9\x1b\x91\xd4\xd5\xb9HvB,N\xebR\xed\xc8<\xbf\x87B} \x9b'\xbc\xad\xfd"
b'{w\xfa+\xa333\xe1O\xa1\xbbT\x00\x00\x00\x05\x00\x15ujJ\x00\x00\x00'
b'\x02\x00F\xbe\xd5D\xe4>\xc4\x05\xeb\xbf-\x186\xbfVJ\x00\xd8\x13\xa9jg'
b'\xd7,\xc1\x1cv\xc3\xcd\xed\xf7')
Результат разбора:
'A1': {'B1': 0.02337992563843727,
{'B2': {'C1': 2099288871,
'C2': -0.021239032968878746,
'C3': 119,
'C4': -1493,
'C5': -6686943978918397100,
'C6': [{'D1': -21367, 'D2': 16231},
'D1': -6743, 'D2': 7057},
{'D1': -11051, 'D2': -18104},
{'D1': 30274, 'D2': 11342},
{'D1': -5294, 'D2': -4664}]}},
{'A2': {'E1': 74,
'E2': 'uj',
'E3': [-0.4165412187576294,
0.38285765051841736,
-0.6761506795883179,
-0.837066650390625],
'E4': -10221,
'E5': -87,
'E6': 7667333477839959747},
'A3': 1911065079,
'A4': [205, 237, 247]}
Задача №12
Реализовать разбор двоичного формата данных. Данные начинаются с сигнатуры 0x4c 0x4a 0x58
, за которой следует структура A.
Порядок байт: от младшего к старшему. Адреса указаны в виде смещений от начала данных. В решении предлагается использовать модуль
struct.
Структура A:
Поле | Описание |
---|---|
1 | Размер (uint32) и адрес (uint32) массива адресов (uint16) структур B |
2 | double |
3 | int64 |
4 | Структура C |
5 | Размер (uint16) и адрес (uint16) массива int8 |
Структура B:
Поле | Описание |
---|---|
1 | int64 |
2 | int32 |
Структура C:
Поле | Описание |
---|---|
1 | Размер (uint32) и адрес (uint32) массива char |
2 | Адрес (uint32) структуры D |
3 | Структура E |
Структура D:
Поле | Описание |
---|---|
1 | int16 |
2 | Массив int8, размер 7 |
3 | float |
4 | Размер (uint16) и адрес (uint16) массива float |
Структура E:
Поле | Описание |
---|---|
1 | float |
2 | float |
3 | int64 |
Ниже показаны примеры разбора двоичного формата.
Пример 1
Двоичные данные:
b'LJX\x03\x00\x00\x00_\x00\x00\x00\xd4\x0e\x99\xe7\x82\x94\xeb?i\xb3\x13\xe8I'
(b';@t\x05\x00\x00\x00e\x00\x00\x00r\x00\x00\x00\x865@?\xbe}\xb7>\t'
b'\xd6\xea\x93O\xf1\xa3\x01\x03\x00\x83\x00\xe6de"\n\xd4\xa0Z\xae\x9b-\x90\xa9'
b'f\x94\x0c\x19ly\x12\x88I\xe6E\x12\xb7\xf5k\xb2\xcf\xd5\xc2\x97\xed\xd0u;'
b'\x00G\x00S\x00snnmh \xa7\xaf\xbe\xd6X\xa9>\xf3YP$\xc7I\xdfv\x13\xa8'
b'E8\xbf\x02\x00j\x00\t\xf6\x9a')
Результат разбора:
'A1': [{'B1': 6530452599679050982, 'B2': -1876059218},
{'B1': 1331214019705726633, 'B2': 1172720008},
{'B1': -4407388295089768686, 'B2': 1976626583}],
{'A2': 0.8618788264652388,
'A3': 8376760495521379177,
'A4': {'C1': 'snnmh',
'C2': {'D1': 23027,
'D2': [80, 36, -57, 73, -33, 118, 19],
'D3': -0.7198128700256348,
'D4': [-0.34307193756103516, 0.33075588941574097]},
'C3': {'E1': 0.7508167028427124,
'E2': 0.3583812117576599,
'E3': 118203339328116233}},
'A5': [9, -10, -102]}
Пример 2
Двоичные данные:
b'LJX\x04\x00\x00\x00k\x00\x00\x00\xceJ0\xcbP\xcc\xea?/\x13\x16\xee\x0f'
(b'G\x07\xa7\x04\x00\x00\x00s\x00\x00\x00\x83\x00\x00\x00n-\xe9<\xb47\xc7>\xe0'
b'u\x91\xcc\xba\x86U\x18\x03\x00\x94\x00C/=\xd9\x05}\xbe\xec\x8d'
b'\xd9\xc0\x85\xc1\x00\xc3\xe6jq\x14\x12+\xc9\xc2\xd2g8Z9AD:\xd0Q\xd7\xac\xfeV'
b'\xde\xdb\xc7\xe0F\xa6\xcd\xf1\xb0(\x1c;\x00G\x00S\x00_\x00tlrfNi\xba\xbe\xee'
b'"o?\xb1\xaej?\x9e\xe3\x97\xb6\xaf\x0c\x06\xe0\xe8\xa2\xb8\x8a>\x03\x00w\x00'
b'Y\xd5\xf6')
Результат разбора:
'A1': [{'B1': -1387534171110559933, 'B2': -2050958963},
{'B1': 1302790896168927425, 'B2': -758986453},
{'B1': -3442363918245545881, 'B2': -22227119},
{'B1': -3628134518560661930, 'B2': 472428785}],
{'A2': 0.8374408691909936,
'A3': -6411077410794106065,
'A4': {'C1': 'tlrf',
'C2': {'D1': -7266,
'D2': [-105, -74, -81, 12, 6, -32, -24],
'D3': 0.2709398865699768,
'D4': [-0.3640846610069275,
0.9341267347335815,
0.9167280793190002]},
'C3': {'E1': 0.028464045375585556,
'E2': 0.38909685611724854,
'E3': 1753455766784800224}},
'A5': [89, -43, -10]}
Задача №12
Реализовать разбор двоичного формата данных. Данные начинаются с сигнатуры 0x4d 0x50 0x42 0x45 0x11
, за которой следует
структура A. Порядок байт: от младшего к старшему. Адреса указаны в виде смещений от начала данных. В решении предлагается использовать
модуль struct.
Структура A:
Поле | Описание |
---|---|
1 | Размер (uint16) и адрес (uint16) массива адресов (uint32) структур B |
2 | uint16 |
3 | uint16 |
4 | int8 |
5 | Структура D |
Структура B:
Поле | Описание |
---|---|
1 | Размер (uint16) и адрес (uint16) массива char |
2 | uint8 |
3 | uint16 |
4 | int8 |
5 | float |
6 | Адрес (uint16) структуры C |
7 | uint8 |
Структура C:
Поле | Описание |
---|---|
1 | int8 |
2 | Размер (uint16) и адрес (uint32) массива int8 |
3 | int64 |
4 | uint32 |
5 | uint32 |
6 | Размер (uint32) и адрес (uint32) массива int16 |
7 | int16 |
8 | int32 |
Структура D:
Поле | Описание |
---|---|
1 | uint32 |
2 | int8 |
Ниже показаны примеры разбора двоичного формата.
Пример 1
Двоичные данные:
b'MPBE\x11\x02\x00\x96\x00J\x7fLv\xfb\x0er\xdbF\xeftynhmx\xe5\xb9\x07'
(b'Np\xd9\xb2\xa0T\xea\x05\x00\x19\x00\x00\x00}\x8e\xdf!\xb2^\xe1\x973y\x1e'
b'\xc3\xb1H&\xf5\x02\x00\x00\x00\x1e\x00\x00\x00EB\x16WsY\x06\x00\x13\x00m'
b'\x08\xc4\xc0\xb2\xdf!\xbf"\x00\xe2ft\xa8N\xac\x8b\x9c\x14\xbf\xf6\x02;|\x06'
b'\x00X\x00\x00\x00\x93\x87\x94\xf5}\xbf\xa4\xa7\xa8\xa22\xf9\x04Sl'
b'\xcb\x02\x00\x00\x00^\x00\x00\x00\xb6\xdat\x1b\xa2\x88\x02\x00V\x00]'
b'p\xef\xe1\xeaS\xf3\xbdb\x00\xd9G\x00\x00\x00\x87\x00\x00\x00')
Результат разбора:
'A1': [{'B1': 'tynhmx',
{'B2': 109,
'B3': 50184,
'B4': -64,
'B5': -0.6323195695877075,
'B6': {'C1': -22,
'C2': [-27, -71, 7, 78, 112],
'C3': -7502611385057046915,
'C4': 3273554227,
'C5': 4112926897,
'C6': [-19751, 21664],
'C7': 16965,
'C8': 1500731158},
'B7': 226},
'B1': 'ft',
{'B2': 93,
'B3': 61296,
'B4': -31,
'B5': -0.11881239712238312,
'B6': {'C1': 124,
'C2': [-88, 78, -84, -117, -100, 20],
'C3': -6366753425483069549,
'C4': 4180845224,
'C5': 3412873988,
'C6': [-2369, 15106],
'C7': -9546,
'C8': -2002642060},
'B7': 217}],
'A2': 32586,
'A3': 30284,
'A4': -5,
'A5': {'D1': 1188786702, 'D2': -17}}
Пример 2
Двоичные данные:
b'MPBE\x11\x02\x00\x9f\x00\x0f\xd2O\xb7s"\xe6a\xcf)dk\xc2\xd1\x91\xd6P\xe7H'
(b'\xddr\xc9z\xff\xba\xdeyl\x03\x00\x15\x00\x00\x00\x04\xbe:3\xf2\xd0\xdcM\xc0'
b'\xda\x84\xea\xa32\xefO\x06\x00\x00\x00\x18\x00\x00\x00t\x95lc\xec'
b'j\x02\x00\x13\x00\xda0H\xf6\xe0\xbe\xfc=$\x00/fcavgw\xc6\xee\xbbh\x8c_40k^'
b'FY\x8au\x03\x00^\x00\x00\x00%\xd9\xa5\xaeJ\xf7N3\x98ih\xc8.\x99\xbb?\x05\x00'
b'\x00\x00a\x00\x00\x00\x84d\xec\xaa\x9f$\x06\x00X\x00\xe0*u\\Q\xa8Q\xbf'
b'k\x00\xd0I\x00\x00\x00\x90\x00\x00\x00')
Результат разбора:
'A1': [{'B1': 'dk',
{'B2': 218,
'B3': 18480,
'B4': -10,
'B5': 0.12341094017028809,
'B6': {'C1': 108,
'C2': [-62, -47, -111],
'C3': 5610588974456946180,
'C4': 3934575296,
'C5': 1341076131,
'C6': [20694, 18663, 29405, 31433, -17665, 31198],
'C7': -27276,
'C8': 1793876844},
'B7': 47},
'B1': 'fcavgw',
{'B2': 224,
'B3': 29994,
'B4': 92,
'B5': -0.8189745545387268,
'B6': {'C1': 117,
'C2': [-58, -18, -69],
'C3': 3697164244247501093,
'C4': 3362285976,
'C5': 1069259054,
'C6': [-29592, 13407, 27440, 18014, -30119],
'C7': 25732,
'C8': 614443756},
'B7': 208}],
'A2': 53775,
'A3': 46927,
'A4': 115,
'A5': {'D1': 3479299618, 'D2': 41}}
Задача №12
Реализовать разбор двоичного формата данных. Данные начинаются с сигнатуры 0x2a 0x41 0x47 0x55
, за которой следует структура
A. Порядок байт: от младшего к старшему. Адреса указаны в виде смещений от начала данных. В решении предлагается использовать модуль
struct.
Структура A:
Поле | Описание |
---|---|
1 | int16 |
2 | Массив структур B, размер 3 |
3 | Структура C |
4 | Адрес (uint16) структуры E |
Структура B:
Поле | Описание |
---|---|
1 | double |
2 | double |
3 | int32 |
Структура C:
Поле | Описание |
---|---|
1 | uint8 |
2 | Размер (uint16) и адрес (uint32) массива char |
3 | Адрес (uint32) структуры D |
Структура D:
Поле | Описание |
---|---|
1 | int8 |
2 | int16 |
3 | uint32 |
4 | int32 |
5 | uint64 |
6 | int64 |
Структура E:
Поле | Описание |
---|---|
1 | int8 |
2 | uint8 |
3 | uint8 |
4 | float |
5 | double |
6 | Структура F |
7 | int16 |
8 | uint16 |
Структура F:
Поле | Описание |
---|---|
1 | Размер (uint16) и адрес (uint32) массива uint8 |
2 | Массив int16, размер 8 |
3 | uint64 |
Ниже показаны примеры разбора двоичного формата.
Пример 1
Двоичные данные:
b'*AGU\xf0~\x80\x8b|\x19I\x8f\xce\xbf8\xaah\xd7\xab\xf6\xe9?>\x85\x17t\xc0o'
(b'Uo\x88\x04\xa2?\xb8\xb5*M\xb4\xc5\xca\xbf\xf4\ny\xa0\x00}\xd0\xec(\xd0'
b'\xdd?PPFjp\xab\xd5\xbf\x11\x15W\xd3\xc8\x02\x00O\x00\x00\x00Q\x00\x00'
b'\x00o\x00jl<\x81\r\x177\xcd\xdcF_]\xc4Y\x83\xfc\xbe?\x96\xce@r\xf6\x024'
b'x\xd7c\xfb\xf6\x9b0\x98Czc\xad\xbf\xbe\x94J\xae\xf27&\xe2?\x03\x00'
b'l\x00\x00\x00\xad:\xaf\xf9t<\xbc+\xac\xe3 \x1fKB\xb5\xa5\x80\x14\xf3\xc2'
b'T\xbdH6\xd7O\xef\xcc')
Результат разбора:
'A1': 32496,
{'A2': [{'B1': -0.23874772781809028,
'B2': 0.8113612372592973,
'B3': 1947698494},
'B1': 0.03519083365492248,
{'B2': -0.209158456496352,
'B3': -1602680076},
'B1': 0.4658300697937676,
{'B2': -0.3385888135756021,
'B3': -749267695}],
'A3': {'C1': 200,
'C2': 'jl',
'C3': {'D1': 60,
'D2': 3457,
'D3': 3704436503,
'D4': -1000513722,
'D5': 4669835064161108825,
'D6': -332185036226627982}},
'A4': {'E1': -104,
'E2': 67,
'E3': 122,
'E4': -0.37436971068382263,
'E5': 0.5671653499469635,
'E6': {'F1': [246, 155, 48],
'F2': [15021, -1617, 15476, 11196, -7252, 7968, 16971, -23115],
'F3': 3911584448116888704},
'E7': 20439,
'E8': 52463}}
Пример 2
Двоичные данные:
b'*AGU\xb8\x19(\xf5\x9b\x8d\x0c-\xe3\xbf \x0c3\xc0-\xce\xc4\xbf\xe6{'
(b'1\xa3\xbc\xc7Vv\x89\xcd\xd2?\xfe}\x02\x9f\x08\x9c\xe1\xbf\xb8\x13'
b'\xdaN\x10\xd3\xbc\xf7\x18\xec\xb6?\x8c\x14\x9eNd\xc5\xd1\xbf\x0e\xae'
b'}\xef\xdf\x03\x00O\x00\x00\x00R\x00\x00\x00p\x00qkdx\xd1i\x82J \xc4\xd7X\xfb'
b'(\xed\xa5\x994MY\x1e\x10\xa4}[\x83\x08\xd5\r\x169\xa1|K\xb2\x00`'
b'\xbdh\xbf\xa0\xe1\xf0\xd6\xff\xc6\xcb?\x03\x00m\x00\x00\x00\xac|\xd7\x89Q1?'
b'd\xed\xdd\x0f\x1b8\x9f,\xb7\x9eU\xc7%T\xd7ha\xa8p\x10\xe6')
Результат разбора:
'A1': 6584,
{'A2': [{'B1': -0.5992491498761057,
'B2': -0.16254207501160156,
'B3': -1557038106},
'B1': 0.2937949805883553, 'B2': -0.5502970796259772, 'B3': 1322914744},
{'B1': 0.08954006241112844,
{'B2': -0.2776728408574136,
'B3': -276976114}],
'A3': {'C1': 223,
'C2': 'qkd',
'C3': {'D1': 120,
'D2': 27089,
'D3': 3290450562,
'D4': 687560919,
'D5': 1161463942038005229,
'D6': 1589160476071919012}},
'A4': {'E1': 75,
'E2': 178,
'E3': 0,
'E4': -0.9091396331787109,
'E5': 0.21701047892726155,
'E6': {'F1': [57, 161, 124],
'F2': [31916, -30249, 12625, 25663, -8723, 6927, -24776, -18644],
'F3': 7019096775667963294},
'E7': 28840,
'E8': 58896}}
Задача №12
Реализовать разбор двоичного формата данных. Данные начинаются с сигнатуры 0x46 0x51 0x4f 0x4c 0xb9
, за которой следует
структура A. Порядок байт: от старшего к младшему. Адреса указаны в виде смещений от начала данных. В решении предлагается использовать
модуль struct.
Структура A:
Поле | Описание |
---|---|
1 | uint32 |
2 | Адрес (uint32) структуры B |
3 | Структура C |
4 | uint32 |
5 | Размер (uint16) и адрес (uint16) массива структур D |
Структура B:
Поле | Описание |
---|---|
1 | Массив char, размер 2 |
2 | double |
3 | Размер (uint16) и адрес (uint16) массива char |
4 | uint64 |
5 | int16 |
6 | uint16 |
Структура C:
Поле | Описание |
---|---|
1 | int64 |
2 | double |
Структура D:
Поле | Описание |
---|---|
1 | Размер (uint16) и адрес (uint32) массива int8 |
2 | Массив uint32, размер 4 |
Ниже показаны примеры разбора двоичного формата.
Пример 1
Двоичные данные:
b'FQOL\xb9.\xe6Q\xe6\x00\x00\x00,5\xe9\x027J\x0c\xf2\xdf\xbf\xd10"\x99\xe4\x94'
(b'\x18[L5\x0b\x00\x03\x00Occvlrrkuo\xbf\xe3\xb8O\x97u\xea\xac\x00\x07'
b'\x00%\x87\x87~E\xc4\xa2\x01`\xf1-\x98ld1\xcfd\r 8b;\x00\x02\x00\x00\x00'
b'F\xc7v\x10@\xa5\xca\xd4\xd49\x9f\xbeM\xa8\xe3\x16&\x00\x05\x00\x00\x00H\xbe'
b'\xdb\xb6\x13\\\xce\xa7\xbd\xcfE(\xb6\xfc0\xf9\xd8\x00\x02\x00\x00\x00'
b'M\xfb\x1c\x02\\\x02D\xdb\xb4C\xaf\x8f\xe8\x97c\xe3\xf2')
Результат разбора:
'A1': 786846182,
{'A2': {'B1': 'uo',
'B2': -0.6162488897528724,
'B3': 'ccvlrrk',
'B4': 9765913155093004640,
'B5': -3795,
'B6': 39020},
'A3': {'C1': 3884638590072582879, 'C2': -0.2685629370556071},
'A4': 1531720971,
'A5': [{'D1': [100, 49],
'D2': [3346403392, 2781533396, 966770253, 2833454630]},
'D1': [-49, 100, 13, 32, 56],
{'D2': [3202070035, 1557047229, 3477416118, 4231068120]},
'D1': [98, 59], 'D2': [4212916828, 38067124, 1135579112, 2539906034]}]} {
Пример 2
Двоичные данные:
b'FQOL\xb9\xc6\x82\x8ed\x00\x00\x00+\r\x1a\xb6V\xe2i(\xf6?\xa5^'
(b'\xd3\x84\xa4\xf6 S\xack"\x00\x03\x00Nfhnoyalf?\xeez.\x90Y\x9fx\x00\x06\x00'
b'%\xbdi>\x9a\tL\xd78T\x0c"\xf6\xc8\'\x87\xe6_\x97\xa2u4\x00\x02\x00\x00\x00E'
b'Xe\xc2Y\xb6\xcc\x97\xd8~\x9c\x96\x04\xe8\x148\xfb\x00\x02\x00\x00\x00G\x14V'
b'\xe4\xb6t6\xcb\x8d2{\x8f9\xc5\xdc}c\x00\x05\x00\x00\x00I\xcd}\xa7e'
b'\x95\xa6\xb4\xb20-\xbd`\xc0R+\xef')
Результат разбора:
'A1': 3330444900,
{'A2': {'B1': 'lf',
'B2': 0.9524147815072714,
'B3': 'fhnoya',
'B4': 13648508977024915256,
'B5': 21516,
'B6': 8950},
'A3': {'C1': 944267556169525494, 'C2': 0.041739091817799556},
'A4': 1403808546,
'A5': [{'D1': [-56, 39],
'D2': [1483063897, 3066861528, 2124191236, 3893639419]},
'D1': [-121, -26],
{'D2': [341238966, 1949748109, 846958393, 3319561571]},
'D1': [95, -105, -94, 117, 52],
{'D2': [3447564133, 2510730418, 808303968, 3226610671]}]}
Задача №12
Реализовать разбор двоичного формата данных. Данные начинаются с сигнатуры 0x94 0x41 0x41 0x45
, за которой следует структура
A. Порядок байт: от старшего к младшему. Адреса указаны в виде смещений от начала данных. В решении предлагается использовать модуль
struct.
Структура A:
Поле | Описание |
---|---|
1 | Структура B |
2 | Размер (uint16) и адрес (uint32) массива uint8 |
Структура B:
Поле | Описание |
---|---|
1 | int32 |
2 | uint16 |
3 | int8 |
4 | int16 |
5 | Массив адресов (uint16) структур C, размер 2 |
6 | Массив адресов (uint16) структур E, размер 2 |
7 | Размер (uint32) и адрес (uint32) массива int8 |
Структура C:
Поле | Описание |
---|---|
1 | float |
2 | double |
3 | Структура D |
4 | int8 |
Структура D:
Поле | Описание |
---|---|
1 | uint16 |
2 | int16 |
3 | uint16 |
Структура E:
Поле | Описание |
---|---|
1 | Массив int8, размер 6 |
2 | double |
3 | int16 |
4 | uint32 |
5 | int32 |
Ниже показаны примеры разбора двоичного формата.
Пример 1
Двоичные данные:
b'\x94AAE\x87\x8d\xech\xc0\x1d\xb8w\xab\x00#\x006\x00I\x00a\x00\x00\x00'
(b'\x05\x00\x00\x00y\x00\x08\x00\x00\x00~=\x98\tb?\xdc\xa9\x94N\xfb\xcb\xec&'
b'\xd5W\x995\xa7\xb6>\x9a\xb8\x87?\xe4i\x86\xa4[\x82\xd2\xff\xc0'
b'\xb8\x81\xd9\xb2\xa3\x8f\xe4\x08\xaf\xb3\xbb?\x8d\x97\xedcE\x8e\x00k'
b'\xeeM\xc3\xc6\xee\x9ds\xe9\x9b\x8a?\x1f\xf0+\xa1?\xd9i\xd7v\x82k\x8c\x81'
b'\x85m\xe82\xcf\xcfJ\xfeZe\x7f1\t\xe8kf\xe0\x1c\xf5\x12c\xbb')
Результат разбора:
'A1': {'B1': -2020742040,
{'B2': 49181,
'B3': -72,
'B4': 30635,
'B5': [{'C1': 0.07423664629459381,
'C2': 0.44785030091514844,
'C3': {'D1': 9941, 'D2': 22425, 'D3': 13735},
'C4': -74},
'C1': 0.30218908190727234,
{'C2': 0.637881585131334,
'C3': {'D1': 65472, 'D2': -18303, 'D3': 55730},
'C4': -93}],
'B6': [{'E1': [-113, -28, 8, -81, -77, -69],
'E2': 0.014449934570342826,
'E3': 27630,
'E4': 1304676078,
'E5': -1653347941},
'E1': [-118, 63, 31, -16, 43, -95],
{'E2': 0.3970850617712862,
'E3': -32379,
'E4': 1843933903,
'E5': -817168806}],
'B7': [101, 127, 49, 9, -24]},
'A2': [107, 102, 224, 28, 245, 18, 99, 187]}
Пример 2
Двоичные данные:
b'\x94AAEL\xc9XV;\xf6\xd9^\x06\x00#\x006\x00I\x00a\x00\x00\x00\x05\x00\x00\x00'
(b'y\x00\x06\x00\x00\x00~?)\x06N\xbf\xd6\x166*\xb4\xf3\x84<ns.,W\xc6\xbe\xda'
b"\x83\x97\xbf\xbb\xbc\x8dc\x8c\xe0\x80\xc6\xa9\xc9\xa3\x0f'8_=\xe3\x1fc\x17?"
b'\xca\xb6F\xa2J\x1a\x00\xa1:\x92\xf0\xe8|m\xdb\xf5(\xa3so\xb8\x12\xae\xbf'
b'\xb4bD^\xc3O\xc0S\xe6\xb5\x86\xcdT\xafx\x0f\x8e_\xfe5\xd7\x10\xf8}'
b'\xbd\xe2\x9aj')
Результат разбора:
'A1': {'B1': 1288263766,
{'B2': 15350,
'B3': -39,
'B4': 24070,
'B5': [{'C1': 0.6602524518966675,
'C2': -0.34510568781461637,
'C3': {'D1': 15470, 'D2': 29486, 'D3': 11351},
'C4': -58},
'C1': -0.4267852008342743,
{'C2': -0.1083458297770239,
'C3': {'D1': 50857, 'D2': -13917, 'D3': 3879},
'C4': 56}],
'B6': [{'E1': [95, 61, -29, 31, 99, 23],
'E2': 0.20868761944093706,
'E3': -24262,
'E4': 2465261692,
'E5': 1843131688},
'E1': [-93, 115, 111, -72, 18, -82],
{'E2': -0.07962443650768503,
'E3': 21478,
'E4': 3045510484,
'E5': -1351086194}],
'B7': [95, -2, 53, -41, 16]},
'A2': [248, 125, 189, 226, 154, 106]}
Задача №12
Реализовать разбор двоичного формата данных. Данные начинаются с сигнатуры 0x56 0x44 0x49 0x52 0x4
, за которой следует
структура A. Порядок байт: от старшего к младшему. Адреса указаны в виде смещений от начала данных. В решении предлагается использовать
модуль struct.
Структура A:
Поле | Описание |
---|---|
1 | uint8 |
2 | float |
3 | uint32 |
4 | Адрес (uint32) структуры B |
5 | uint16 |
6 | Массив int8, размер 6 |
Структура B:
Поле | Описание |
---|---|
1 | Адрес (uint32) структуры C |
2 | Размер (uint16) и адрес (uint32) массива char |
3 | Массив адресов (uint32) структур D, размер 3 |
4 | uint64 |
5 | int64 |
6 | Массив int16, размер 5 |
7 | Размер (uint32) и адрес (uint16) массива int16 |
Структура C:
Поле | Описание |
---|---|
1 | int8 |
2 | int32 |
Структура D:
Поле | Описание |
---|---|
1 | int64 |
2 | uint16 |
Ниже показаны примеры разбора двоичного формата.
Пример 1
Двоичные данные:
b'VDIR\x04N\xbfN\xc4m\x1c\xcan\x06\x00\x00\x00F0H:\xad\\?\xb4\xe7L\x10'
(b'^\xe9\x8cvcf\xd0\xcc\x83Ns\x12\x86\x9fN\xb9\x18"\xe0\xd6\x8d\x91ub\xc52k\xfd'
b'\x97\x05\xae\xd6u\xdaw\xd3\x8d,\x19\x91\x87\t\x00\x00\x00\x1a\x00\x03'
b'\x00\x00\x00\x1f\x00\x00\x00"\x00\x00\x00,\x00\x00\x006\x1f\xeep\x84'
b'\xba\xfc@8\x073\xe3\xf6\x9a\xbd\xa0\x81K|\xd1|7\xb4GW]\xa0\x00\x00'
b'\x00\x03\x00@')
Результат разбора:
'A1': 78,
{'A2': -0.8076847195625305,
'A3': 483028486,
'A4': {'B1': {'C1': 76, 'C2': 274655628},
'B2': 'vcf',
'B3': [{'D1': -3401199245610285409, 'D2': 20153},
'D1': 1739199618221176162, 'D2': 50482},
{'D1': 7781541781830006234, 'D2': 30675}],
{'B4': 2300900175007989816,
'B5': 519009030375317633,
'B6': [19324, -11908, 14260, 18263, 23968],
'B7': [-29396, 6545, -30967]},
'A5': 12360,
'A6': [58, -83, 92, 63, -76, -25]}
Пример 2
Двоичные данные:
b'VDIR\x04\xd9=f\xf4O\x19H\xd8\xa8\x00\x00\x00C\x19\xc2nRG \x8ake\x7f'
(b'\x0c\x06vxp\xb2ah#")\x1d\x8f`\x85\xf0=\r\x19\t\xb1\x8fno\x83\xfd\xf45'
b'\x02"\xb9\xfc\xae\x0c9N\xab\\-\x00\x00\x00\x1a\x00\x02\x00\x00\x00'
b'\x1f\x00\x00\x00!\x00\x00\x00+\x00\x00\x005`:\xe7l\x9a\xce\xa8\xe7x\x10b'
b'\x0c\x82o\x8e>\xee\\T\x1dR\xcb\xfa\xdc\xd0\n\x00\x00\x00\x02\x00?')
Результат разбора:
'A1': 217,
{'A2': 0.056385334581136703,
'A3': 424204456,
'A4': {'B1': {'C1': 101, 'C2': 2131494518},
'B2': 'xp',
'B3': [{'D1': -5593074762111181425, 'D2': 24709},
'D1': -1135737129839521938, 'D2': 28547},
{'D1': -147434604507562834, 'D2': 3129}],
{'B4': 6934109029930019047,
'B5': 8651522690046201406,
'B6': [-4516, 21533, 21195, -1316, -12278],
'B7': [20139, 23597]},
'A5': 6594,
'A6': [110, 82, 71, 32, -118, 107]}
Задача №12
Реализовать разбор двоичного формата данных. Данные начинаются с сигнатуры 0x5d 0x4e 0x54 0x48 0x4f
, за которой следует
структура A. Порядок байт: от младшего к старшему. Адреса указаны в виде смещений от начала данных. В решении предлагается использовать
модуль struct.
Структура A:
Поле | Описание |
---|---|
1 | Адрес (uint32) структуры B |
2 | double |
Структура B:
Поле | Описание |
---|---|
1 | Адрес (uint16) структуры C |
2 | Размер (uint32) и адрес (uint32) массива адресов (uint32) структур F |
3 | Массив uint32, размер 2 |
4 | uint8 |
5 | int32 |
Структура C:
Поле | Описание |
---|---|
1 | uint32 |
2 | double |
3 | uint8 |
4 | Структура D |
5 | uint8 |
Структура D:
Поле | Описание |
---|---|
1 | float |
2 | uint16 |
3 | int64 |
4 | Размер (uint32) и адрес (uint32) массива uint8 |
5 | Структура E |
6 | int64 |
7 | uint16 |
8 | int16 |
Структура E:
Поле | Описание |
---|---|
1 | int8 |
2 | int8 |
Структура F:
Поле | Описание |
---|---|
1 | Размер (uint32) и адрес (uint16) массива uint32 |
2 | int32 |
3 | float |
4 | uint64 |
5 | uint8 |
6 | uint8 |
7 | float |
Ниже показаны примеры разбора двоичного формата.
Пример 1
Двоичные данные:
b"]NTHO\x96\x00\x00\x00p\xc9\x93(\xe5'\xed?\x9d\xf3t\x17jpr\xe8\x17\x8cc"
(b"zF\xe8?\xdec\x18x\xbf\xc87\xcb\x8f\xecXg\xe8\xe4'\x03\x00\x00\x00\x11"
b'\x00\x00\x00\xc4\x058L\x12`\xb3z\xe91\xed\x88\xb98\xee\xdb\xe1'
b'\x07\xf0\xa2\xa1\x9fK\x02\x00\x00\x00F\x00\xc3\xa0\xd0\xbb\xe9CI>'
b"\x97\x1b(\x10\x10\xc3\x04\xech\xd1B'\xdb>R\xd6\x1ax\xf8\x91\xd6\x18\x02\x00"
b'\x00\x00j\x00c\x07\xe6\x96\xbd&.>\x10+\x10\xa7\x08 0+hz<"\xdd\xbeN\x00'
b'\x00\x00r\x00\x00\x00\x14\x00\x02\x00\x00\x00\x8e\x00\x00\x00\x1c+\xcav'
b'\xbd\xf0\xcd\xd0^p^\xbd\xc2')
Результат разбора:
'A1': {'B1': {'C1': 1919969815,
{'C2': 0.7586032814294841,
'C3': 222,
'C4': {'D1': -0.9691221117973328,
'D2': 14280,
'D3': 2874677992740392907,
'D4': [157, 243, 116],
'D5': {'E1': -60, 'E2': 5},
'D6': 3596540688261598264,
'D7': 35053,
'D8': 14521},
'C5': 238},
'B2': [{'F1': [4027048411, 1268752802],
'F2': -1143955261,
'F3': 0.19654811918735504,
'F4': 17006932566615792535,
'F5': 104,
'F6': 209,
'F7': 0.42803388833999634},
'F1': [2015024722, 416715256],
{'F2': -1763309725,
'F3': 0.1700696498155594,
'F4': 3112022564047694608,
'F5': 104,
'F6': 122,
'F7': -0.43190181255340576}],
'B3': [1992960796, 3503157437],
'B4': 94,
'B5': -1027776912},
'A2': 0.9111200134778255}
Пример 2
Двоичные данные:
b']NTHO\x96\x00\x00\x00nW\xe4F\x1d9\xe1?\xdde\xdd\xd6nI\xd0\xb8N\xb9\xd7'
(b'\x83s\xc8?\n\xc7\xbe\xbc\xbe\x18\xb1\x06L\xfb\x1a\xab\xbau;\x03'
b'\x00\x00\x00\x11\x00\x00\x00\xa4\xbf\x1dL\xc4\x06\x9b\xab\\l\xf3 \xee'
b'\x07\xd5\xa0\xf2\xb7"x\x13b\x8c\x02\x00\x00\x00F\x00,\xa6\x8d\x90'
b"\xa6\xad)\xbf\xe9\xb6\r\xfe\xdb\xc8]\xa2X\xa0\xd2\x1f4\xbf\xa2Nk'\xb2\xa8"
b'?d\x02\x00\x00\x00j\x00T:Z\rK\xe4t\xbf\x9b\xccG}7\x1e\xbf*\xe9r\x11\xaf'
b'N\xbfN\x00\x00\x00r\x00\x00\x00\x14\x00\x02\x00\x00\x00\x8e\x00\x00\x00'
b'\x95Bs\xac\x99\xd4\x1f\xae\\\x80/\x13\x80')
Результат разбора:
'A1': {'B1': {'C1': 3494473430,
{'C2': 0.1910252383555553,
'C3': 10,
'C4': {'D1': -0.36864301562309265,
'D2': 45336,
'D3': 4284535864567745542,
'D4': [221, 101, 221],
'D5': {'E1': -92, 'E2': -65},
'D6': 7808304536275405853,
'D7': 8435,
'D8': 2030},
'C5': 213},
'B2': [{'F1': [582480544, 2355237752],
'F2': -1869765076,
'F3': -0.6628059148788452,
'F4': 11699728254164121321,
'F5': 88,
'F6': 160,
'F7': -0.7036105394363403},
'F1': [661343906, 1681893554],
{'F2': 224016980,
'F3': -0.9566084742546082,
'F4': 3080213893818600603,
'F5': 233,
'F6': 114,
'F7': -0.8073588013648987}],
'B3': [2893234837, 2921321625],
'B4': 92,
'B5': -2146226304},
'A2': 0.5382219681366516}
Задача №12
Реализовать разбор двоичного формата данных. Данные начинаются с сигнатуры 0x43 0x49 0x4f 0xab
, за которой следует структура
A. Порядок байт: от младшего к старшему. Адреса указаны в виде смещений от начала данных. В решении предлагается использовать модуль
struct.
Структура A:
Поле | Описание |
---|---|
1 | int8 |
2 | uint8 |
3 | Структура B |
4 | Структура C |
5 | Размер (uint16) и адрес (uint32) массива uint32 |
6 | int32 |
7 | Структура E |
8 | float |
Структура B:
Поле | Описание |
---|---|
1 | uint16 |
2 | uint64 |
Структура C:
Поле | Описание |
---|---|
1 | uint8 |
2 | Размер (uint16) и адрес (uint16) массива char |
3 | Массив адресов (uint32) структур D, размер 4 |
4 | uint32 |
5 | int32 |
Структура D:
Поле | Описание |
---|---|
1 | uint32 |
2 | Массив uint16, размер 7 |
Структура E:
Поле | Описание |
---|---|
1 | float |
2 | int32 |
3 | float |
4 | int8 |
5 | uint16 |
6 | Массив uint8, размер 7 |
Ниже показаны примеры разбора двоичного формата.
Пример 1
Двоичные данные:
b'CIO\xabC\xdf\xcdXPj\xe1$\x10r4\xacO\x03\x00Q\x00T\x00\x00\x00f\x00\x00'
(b'\x00x\x00\x00\x00\x8a\x00\x00\x00\x12\xbew\xbd.[\x93\xc7\x02\x00\x9c'
b'\x00\x00\x00.r\xfb]\x9dx\xf7>\xc3"\xf2}\xe5\x96a\xbfS\xdc\x8d\xe8\xdf'
b'S\xb1\xd8\xe3j\xa0\xf4\x1f\xbfurf\xdfS\xdc\xfc\xa1\xd7+S\xe6\xba|\xe6'
b'\xa6\r\x7f\xd1u\x0e\xb3\xe0\xbb\x05\\\x92\xbeK\xc9r\xef\xc9\xdb\xed'
b'\x0f\xac\x94\x08\x97\xbdrn\xfe\xee\rD\xa0BpV-f\x0f\xf8\x83\xf2\xba\xfe'
b'\x91\xae6,\x81\xba\xb8\x18;\x9c\xca\x9c\xdbK^\xa6TY\x84\xc0\x92r\xf4\x1f')
Результат разбора:
'A1': 67,
{'A2': 223,
'A3': {'B1': 22733, 'B2': 12408668286976354896},
'A4': {'C1': 79,
'C2': 'urf',
'C3': [{'D1': 4242297823,
'D2': [55201, 21291, 47846, 59004, 3494, 53631, 3701]},
'D1': 96198835,
{'D2': [37468, 19390, 29385, 51695, 60891, 44047, 2196]},
'D1': 1853013399,
{'D2': [61182, 17421, 17056, 22128, 26157, 63503, 62083]},
'D1': 2928803514,
{'D2': [11318, 47745, 6328, 39995, 40138, 19419, 42590]}],
'C4': 3178741266,
'C5': -946644178},
'A5': [3229899092, 536113810],
'A6': 1576759854,
'A7': {'E1': 0.48334208130836487,
'E2': 2113020611,
'E3': -0.8812087178230286,
'E4': 83,
'E5': 36316,
'E6': [232, 223, 83, 177, 216, 227, 106]},
'A8': -0.6248264312744141}
Пример 2
Двоичные данные:
b'CIO\xab\xf9\xd8@\x1db\x19+\xf4\xd0\x84\x04\xe4\xc7\x05\x00Q\x00V\x00\x00'
(b'\x00h\x00\x00\x00z\x00\x00\x00\x8c\x00\x00\x00\xe3\xb2\xfe\xc5\xd3\x91\xb7'
b'\xd0\x02\x00\x9e\x00\x00\x00\xbc\xd4\xb6cgG\x9e\xbe(>e\xd9\xd5'
b'\x97\xea\xbe\xd2<Z\x86J\xf6\x0bxm\xcd\x12\xf3u?rabeb\xaf\xf5\x8fA\xf26'
b'\xf2\xf5%\xe52!\xce\xf9CM\x16/\xa3G\xcfP\t\xb6_\x8b\x8fW\x936\xd6Y\xa1C'
b'kc\x0f\xda\xd2\x7f\xb2G\xf6z0\xafE7\xb5\x08\xc9\xd9PRDC\x97?2\x1a\n\xcc'
b'\xa8/\x19\xcd\xe0\xb8u\xa6;\xb9\x9d\x8f\xfa\x84@\xfdq\xf2')
Результат разбора:
'A1': -7,
{'A2': 216,
'A3': {'B1': 7488, 'B2': 16430403373538941282},
'A4': {'C1': 199,
'C2': 'rabeb',
'C3': [{'D1': 1099953583,
'D2': [14066, 62962, 58661, 8498, 63950, 19779, 12054]},
'D1': 1355761571,
{'D2': [46601, 35679, 22415, 13971, 22998, 17313, 25451]},
'D1': 2144524815,
{'D2': [18354, 31478, 44848, 14149, 2229, 55753, 21072]},
'D1': 1066877764,
{'D2': [6706, 52234, 12200, 52505, 47328, 42613, 47419]}],
'C4': 3321803491,
'C5': -793275949},
'A5': [2231013277, 4067556672],
'A6': 1672926396,
'A7': {'E1': -0.3091385066509247,
'E2': -647676376,
'E3': -0.45818963646888733,
'E4': -46,
'E5': 23100,
'E6': [134, 74, 246, 11, 120, 109, 205]},
'A8': 0.9607402086257935}
Задача №12
Реализовать разбор двоичного формата данных. Данные начинаются с сигнатуры 0x54 0x59 0x4e 0xb1
, за которой следует структура
A. Порядок байт: от старшего к младшему. Адреса указаны в виде смещений от начала данных. В решении предлагается использовать модуль
struct.
Структура A:
Поле | Описание |
---|---|
1 | Массив char, размер 2 |
2 | uint16 |
3 | Адрес (uint16) структуры B |
4 | Структура D |
5 | float |
Структура B:
Поле | Описание |
---|---|
1 | int32 |
2 | Размер (uint16) и адрес (uint32) массива адресов (uint32) структур C |
3 | uint8 |
4 | Размер (uint32) и адрес (uint32) массива double |
Структура C:
Поле | Описание |
---|---|
1 | uint16 |
2 | Размер (uint32) и адрес (uint32) массива uint16 |
3 | uint32 |
4 | Массив uint32, размер 5 |
5 | float |
6 | int8 |
Структура D:
Поле | Описание |
---|---|
1 | int8 |
2 | int32 |
3 | int16 |
4 | int64 |
5 | uint64 |
6 | int32 |
Ниже показаны примеры разбора двоичного формата.
Пример 1
Двоичные данные:
b'TYN\xb1hg9Z\x00\xa9+C\xf1_8\xb5\x92\xcc\xac\xf2\xc84\x0e\xe3\xc8\xb8\xf3\xf6'
(b'\x94\'\xb4\x9b\xd5\xd7\xfbc\xfe\xbe\xfeDP`Y\x8e\xb3"\x1a(\x1dxK\xfc'
b'\x97\x00\x00\x00\x05\x00\x00\x00)|\x95\xa980KN\xfdB\x8d\xe0\x8dI\xa0n-\xbd[c'
b'\xe5\x9a\x86\xd4{\xbe\xfe\xdb\xca9\xa8\x1a\x10;V\xfc\x04\x9b\xec%'
b'\x00\x00\x00\x04\x00\x00\x00Z\xa6W\xa3:\xd7k)\xe8\x015C\x8aS\x01\x88_'
b'.}\x8c\xfe\xb7G\xc5*>\x81\xc1\xf2\x90\x00\x00\x003\x00\x00\x00b?\xeae'
b'\x87\xc81/\xe8\xbf\xc5%\xf0\x86\x83\xd5\x10\xbf\xd53w\x17\xbe\x7fD\xbeO\x1a'
b'6\x00\x02\x00\x00\x00\x89\\\x00\x00\x00\x03\x00\x00\x00\x91')
Результат разбора:
'A1': 'hg',
{'A2': 14682,
'A3': {'B1': -1102112202,
'B2': [{'C1': 64663,
'C2': [24665, 36531, 8730, 10269, 30795],
'C3': 2090182968,
'C4': [810241789,
1116594317,
1235250733,
3176883173,
2592527483],
'C5': -0.49777060747146606,
'C6': 57},
'C1': 60453,
{'C2': [43034, 4155, 22268, 1179],
'C3': 2790761274,
'C4': [3614124520, 20267914, 1392609375, 779980030, 3074934058],
'C5': 0.2534328103065491,
'C6': -112}],
'B3': 92,
'B4': [0.8248938474657708, -0.1652203232585312, -0.33126618689310683]},
'A4': {'D1': 43,
'D2': 1139892024,
'D3': -19054,
'D4': -3698314252297247800,
'D5': 13327266838501170133,
'D6': -671390722},
'A5': -0.496614933013916}
Пример 2
Двоичные данные:
b'TYN\xb1hw\xe8S\x00\xa3\xbf\xf8\xb7,\x86\x8f\xba\x07\xba\xe8\xf7\xc7\xc0@'
(b'\xeb\xb3\xaa_`A(\x87\xca\xcf\xb9g)\xbfsg\x89>\xbd\xc6\xcd8w\x00'
b'\x00\x00\x02\x00\x00\x00)b\xb0:\x06v\x99W\xd5D\rY\xcf\xe2\xc9\xb5\xdd\xb3'
b'\xae*p\r\x9c\xa8o\xbf5\x17\x9b\xbd\x91L\xf0\x88\xef\xd9\xd0\x9f\xa7\xbb$g'
b'\xfa}\xe5\xf1\x91\x95\x00\x00\x00\x08\x00\x00\x00T\xe1q\x92\x07\xfb_'
b"\xb7\x8b}(9\xa2\xc4'\x0c\x8a\x8b2\xdc\\\t\xa7{\xf6=\xe8 \x15\xca\x00"
b'\x00\x00-\x00\x00\x00d\xbf\xcb\xef\xb6m$z(?\xe4\x1a\xe5{sF\x14\xc1'
b'\x06\xb2\x8a\x00\x02\x00\x00\x00\x8bm\x00\x00\x00\x02\x00\x00\x00\x93')
Результат разбора:
'A1': 'hw',
{'A2': 59475,
'A3': {'B1': -1056525686,
'B2': [{'C1': 14455,
'C2': [16061, 50893],
'C3': 1655716358,
'C4': [1989760981,
1141725647,
3804870109,
3014535792,
228370543],
'C5': -0.7073914408683777,
'C6': -67},
'C1': 37269,
{'C2': [37196, 61576, 61401, 53407, 42939, 9319, 64125, 58865],
'C3': 3782316551,
'C4': [4217354123,
2099788194,
3290893450,
2335366236,
161971190],
'C5': 0.11334244161844254,
'C6': -54}],
'B3': 109,
'B4': [-0.21825294808600515, 0.6282832537783087]},
'A4': {'D1': -65,
'D2': -122213242,
'D3': -28742,
'D4': 557013654839509227,
'D5': 12946264945844586442,
'D6': -809933015},
'A5': -0.9507985711097717}
Задача №12
Реализовать разбор двоичного формата данных. Данные начинаются с сигнатуры 0x59 0x49 0x45 0x45
, за которой следует структура
A. Порядок байт: от младшего к старшему. Адреса указаны в виде смещений от начала данных. В решении предлагается использовать модуль
struct.
Структура A:
Поле | Описание |
---|---|
1 | Размер (uint32) и адрес (uint16) массива структур B |
2 | int16 |
3 | int16 |
4 | uint16 |
5 | int8 |
6 | Массив char, размер 7 |
7 | Адрес (uint16) структуры D |
8 | int8 |
Структура B:
Поле | Описание |
---|---|
1 | int8 |
2 | int8 |
3 | float |
4 | Массив char, размер 5 |
5 | int64 |
6 | Структура C |
7 | int16 |
Структура C:
Поле | Описание |
---|---|
1 | int64 |
2 | float |
3 | float |
4 | float |
5 | uint8 |
6 | int64 |
Структура D:
Поле | Описание |
---|---|
1 | uint16 |
2 | uint32 |
3 | Размер (uint16) и адрес (uint32) массива int8 |
4 | uint16 |
Ниже показаны примеры разбора двоичного формата.
Пример 1
Двоичные данные:
b'YIEE\x02\x00\x00\x00\x1b\x00:x\xb2\x9f\xafI\x00darnvvq\x82\x00\xb2`'
(b'\xbf\xeb\n\x1c?hxrjkG\xc0\x0e\xa8\xef\xec*Nr{\x9e\xce\x9b\xda\xf4\x9d\xfb&'
b'C\xbe\x95\xb4\x1c\xbf\x8b\x93\x0c\xbf\xfe1\xc8\x82\xb0b"\x0c(\x12'
b'X\x90\xcd\xa2\xac4\xbfpqvzo<I\xde\xd0y\xa2}\x88\xc7+-\xaf\x91\x19\x11<'
b'OP\xe3\xbem\xacj\xbe\xc3\xbe\x80\xbeM\xe1K\xfa2\xdd*,\xb2t\xab\x17'
b'\xd1\xbe\x16fK\xb1\x9dh\x03\x00\x7f\x00\x00\x00\x1dF')
Результат разбора:
'A1': [{'B1': 96,
{'B2': -65,
'B3': 0.6095415949821472,
'B4': 'hxrjk',
'B5': 5632574798041104455,
'B6': {'C1': -7064781552716186766,
'C2': -0.1905783861875534,
'C3': -0.6121304631233215,
'C4': -0.5491263270378113,
'C5': 254,
'C6': 2885719268501145649},
'B7': 22546},
'B1': -112,
{'B2': -51,
'B3': -0.7057591676712036,
'B4': 'pqvzo',
'B5': -8611548268383549124,
'B6': {'C1': 4328268830379682759,
'C2': -0.44397208094596863,
'C3': -0.22917337715625763,
'C4': -0.2514553964138031,
'C5': 77,
'C6': -5608060306451706911},
'B7': -21644}],
'A2': 30778,
'A3': -24654,
'A4': 18863,
'A5': 0,
'A6': 'darnvvq',
'A7': {'D1': 26134, 'D2': 1755165003, 'D3': [23, -47, -66], 'D4': 17949},
'A8': -78}
Пример 2
Двоичные данные:
b'YIEE\x02\x00\x00\x00\x1b\x00\x89w5\x00\xb0zqobsxwew\x84\x00\xc5\xa9'
(b'\xdfk\xb4\xd0>kngat\x1a\xd3\xf4\xe8\xd8\xaf^R\xb1\xd4\xb8\xc49\x97\x9eHT\xef'
b'$\xbf\xdc\x99P?\x99Ye\xbf\xd1\x12\xd8\xcf\x1dU\x10\xfc\x138\xd7\x8bh\xef'
b'\xd2*>pkaqg9y\x93\xb1\x151\xe9h\xf5y|&oe!\x92\xae\xe9!\xbf\xd2\xd2I?'
b'\x0f\xdbh?\xe0\xfab\x95p\x86\xa3\xcb\xdd6\xab\x0f\x05\x19H\x9b\xcc\xa1P='
b'\x14\x7f\x05\x00\x7f\x00\x00\x00\xec;')
Результат разбора:
'A1': [{'B1': -87,
{'B2': -33,
'B3': 0.4076264798641205,
'B4': 'kngat',
'B5': 5935374705077048090,
'B6': {'C1': 5232786091420472497,
'C2': -0.6442768573760986,
'C3': 0.8148477077484131,
'C4': -0.8958984017372131,
'C5': 209,
'C6': 1440043938610141202},
'B7': -10440},
'B1': -117,
{'B2': 104,
'B3': 0.16682027280330658,
'B4': 'pkaqg',
'B5': 7559627418761394489,
'B6': {'C1': -7916935141879154187,
'C2': -0.6324719190597534,
'C3': 0.7883731126785278,
'C4': 0.9095925688743591,
'C5': 224,
'C6': -2464696573245431046},
'B7': -21706}],
'A2': 30601,
'A3': 53,
'A4': 31408,
'A5': 113,
'A6': 'obsxwew',
'A7': {'D1': 41420,
'D2': 2132032848,
'D3': [15, 5, 25, 72, -101],
'D4': 15340},
'A8': -59}
Задача №12
Реализовать разбор двоичного формата данных. Данные начинаются с сигнатуры 0x58 0x41 0x47 0xc0
, за которой следует структура
A. Порядок байт: от младшего к старшему. Адреса указаны в виде смещений от начала данных. В решении предлагается использовать модуль
struct.
Структура A:
Поле | Описание |
---|---|
1 | Структура B |
2 | int8 |
3 | float |
4 | int8 |
Структура B:
Поле | Описание |
---|---|
1 | int8 |
2 | Структура C |
3 | Размер (uint16) и адрес (uint16) массива uint16 |
4 | uint64 |
5 | int32 |
Структура C:
Поле | Описание |
---|---|
1 | Размер (uint32) и адрес (uint32) массива адресов (uint16) структур D |
2 | int32 |
Структура D:
Поле | Описание |
---|---|
1 | Массив uint8, размер 8 |
2 | Массив int8, размер 7 |
Ниже показаны примеры разбора двоичного формата.
Пример 1
Двоичные данные:
b'XAG\xc0\x7f\x06\x00\x00\x00\x81\x00\x00\x00\xb2\xcc\x08Z\x03\x00\x8d'
(b'\x00\xc7u\xe5\x00\xf4\xad\xa2\x03/]:_\x84k\x15\x02\xbfb\xbc\x0eH\xc87'
b'e\xa7E\x06\x9e5Vl\x1c\x83\xf9y\xee\x89\xad\x9a=?\x93\x9e\x95&\xc8\x1c'
b'-\xd4\x0c\xd0\x04\x9c\x81q\xe4\xf3\x07u\xc3\x84\x95\x97\xd5\\\xae\x9d'
b'\xcb\x05Fd\xd6\x9b\x14\xa5\xa8HO\xa6@k\xc0\x14\xfa4)\x9cY\x11\x9fE\xf76\xba='
b"'\x07\xe2\xc0\xf5\x18\x97\xb0\xae\x86\xda\nf'\x006\x00E\x00T\x00c\x00r"
b'\x00\xc6s\xc7\xe8\x1b<')
Результат разбора:
'A1': {'B1': 127,
{'B2': {'C1': [{'D1': [188, 14, 72, 200, 55, 101, 167, 69],
'D2': [6, -98, 53, 86, 108, 28, -125]},
'D1': [249, 121, 238, 137, 173, 154, 61, 63],
{'D2': [-109, -98, -107, 38, -56, 28, 45]},
'D1': [212, 12, 208, 4, 156, 129, 113, 228],
{'D2': [-13, 7, 117, -61, -124, -107, -105]},
'D1': [213, 92, 174, 157, 203, 5, 70, 100],
{'D2': [-42, -101, 20, -91, -88, 72, 79]},
'D1': [166, 64, 107, 192, 20, 250, 52, 41],
{'D2': [-100, 89, 17, -97, 69, -9, 54]},
'D1': [186, 61, 39, 7, 226, 192, 245, 24],
{'D2': [-105, -80, -82, -122, -38, 10, 102]}],
'C2': 1510526130},
'B3': [29638, 59591, 15387],
'B4': 261962991839573447,
'B5': 1597660463},
'A2': -124,
'A3': -0.5081393122673035,
'A4': 98}
Пример 2
Двоичные данные:
b'XAG\xc05\x02\x00\x00\x00E\x00\x00\x00\xf8S\x10D\x03\x00I\x00N\x1f\xa8p\xd47;'
(b'\x18\xc7}\xef\xc0Y\\*\xe8>}\x18\xd6c2\x1d\xaa\x06U\xff\xc2\x81\x7fR'
b"5\xffW\xb9d\x9bNF\x98\xfa\xed\xd2?)\xd1\x94\xfb'\x006\x00~Nu\xa3WB")
Результат разбора:
'A1': {'B1': 53,
{'B2': {'C1': [{'D1': [24, 214, 99, 50, 29, 170, 6, 85],
'D2': [-1, -62, -127, 127, 82, 53, -1]},
'D1': [87, 185, 100, 155, 78, 70, 152, 250],
{'D2': [-19, -46, 63, 41, -47, -108, -5]}],
'C2': 1141920760},
'B3': [20094, 41845, 16983],
'B4': 1746050666098859854,
'B5': -1058046521},
'A2': 89,
'A3': 0.45344817638397217,
'A4': 125}
Задача №12
Реализовать разбор двоичного формата данных. Данные начинаются с сигнатуры 0x4f 0x51 0x54 0xf4
, за которой следует структура
A. Порядок байт: от старшего к младшему. Адреса указаны в виде смещений от начала данных. В решении предлагается использовать модуль
struct.
Структура A:
Поле | Описание |
---|---|
1 | Адрес (uint16) структуры B |
2 | Размер (uint16) и адрес (uint16) массива структур D |
3 | Адрес (uint32) структуры F |
Структура B:
Поле | Описание |
---|---|
1 | uint16 |
2 | Структура C |
3 | int16 |
Структура C:
Поле | Описание |
---|---|
1 | double |
2 | uint32 |
Структура D:
Поле | Описание |
---|---|
1 | float |
2 | uint32 |
3 | int8 |
4 | Размер (uint16) и адрес (uint32) массива char |
5 | Структура E |
6 | float |
Структура E:
Поле | Описание |
---|---|
1 | uint8 |
2 | uint8 |
3 | Массив int16, размер 6 |
Структура F:
Поле | Описание |
---|---|
1 | uint64 |
2 | Размер (uint32) и адрес (uint16) массива uint64 |
3 | Размер (uint16) и адрес (uint32) массива uint16 |
4 | int32 |
Ниже показаны примеры разбора двоичного формата.
Пример 1
Двоичные данные:
b'OQT\xf4\x00\x0e\x00\x02\x00#\x00\x00\x00\x81M\xb9\xbf\xe2\xb7g"\x83$Z'
(b'q\xff]\xcd\x01\x14rdwhm?lbKSt\x05lG\x00\x03\x00\x00\x00\x1ej41o\x97a'
b'\xca\xf3Xf\xb2Nd\xac?\x07\x862>B\xd3\xa3>\xd5\x97\xf6\xb6\x00\x02\x00'
b'\x00\x00!\x0e\xc9\x9b\x8f,S\x06\x98\x00\x0e\x9bm\x9a\x84?O\xbe'
b'\x98\xc3\xa9\xa5\xf7\xae-k\xb8\x14\xc3\xee\xbdZ4c\xc3B}\x80\xd24\xc4\xbe'
b'q\xae\xb7O0ni\xa2\xd9\x7f\xdf\x90B\x00\x00\x00\x03\x00e\x00\x02\x00\x00\x00'
b'}\xd7$\xdb\xd2')
Результат разбора:
'A1': {'B1': 19897,
{'B2': {'C1': -0.5848880456989136, 'C2': 1912561101},
'B3': 276},
'A2': [{'D1': 0.9233748316764832,
'D2': 1400112492,
'D3': 71,
'D4': 'rdw',
'D5': {'E1': 106,
'E2': 52,
'E3': [12655, -26783, -13581, 22630, -19890, 25772]},
'D6': 0.5293914079666138},
'D1': 0.19026045501232147,
{'D2': 1054185462,
'D3': -74,
'D4': 'hm',
'D5': {'E1': 14,
'E2': 201,
'E3': [-25713, 11347, 1688, 14, -25747, -25980]},
'D6': 0.8115019798278809}],
'A3': {'F1': 7956069271763652674,
'F2': [14098982591657765816, 1496301998246749123, 4791127218908872305],
'F3': [44727, 20272],
'F4': -685450286}}
Пример 2
Двоичные данные:
b'OQT\xf4\x00\x0e\x00\x02\x00#\x00\x00\x00\x87w\xa8?\xef\xc5\xbf'
(b'\xdc\x87\xa1\x90b\x9a"3\\\xd8plhop\xbfY\xa2wF\x13\xb3\xb7j\x00\x02\x00\x00'
b'\x00\x1eS\x99\x19\xb5]u7z\xeeB\xe0\xa3\xfb\xe1>\x10\x00\xd4?b\xeb\xda'
b"v\xd2!\xd7o\x00\x03\x00\x00\x00 \xb4I|\xc8\x11\x93\xa2b'\x91PT\xd4<\xbf{\x8e"
b'\x88d\xda\xcc\x0cc\x1f\xf2\xaf\x11\x94\xff\x81\x07B\xf2|\x15X\xee'
b'\xc8 \xed\x887VJ\xfa\xbbV\t0h\xb24\xa6I\xc9\xa2\xd3\xdf\xcf!\x00'
b'\x00\x00\x03\x00e\x00\x05\x00\x00\x00}\n\xd5\x1eN')
Результат разбора:
'A1': {'B1': 30632,
{'B2': {'C1': 0.9928893382284958, 'C2': 1654268467},
'B3': 23768},
'A2': [{'D1': -0.8501352667808533,
'D2': 1175696311,
'D3': 106,
'D4': 'pl',
'D5': {'E1': 83,
'E2': 153,
'E3': [6581, 23925, 14202, -4542, -8029, -1055]},
'D6': 0.1406281590461731},
'D1': 0.8864113092422485,
{'D2': 1993482711,
'D3': 111,
'D4': 'hop',
'D5': {'E1': 180,
'E2': 73,
'E3': [31944, 4499, -23966, 10129, 20564, -11204]},
'D6': -0.9826436042785645}],
'A3': {'F1': 11982329984772460321,
'F2': [7267345302290428591, 1266918324835644028, 1538241816060332087],
'F3': [22090, 64187, 22025, 12392, 45620],
'F4': 181739086}}
Задача №12
Реализовать разбор двоичного формата данных. Данные начинаются с сигнатуры 0x43 0x53 0x4d 0x49
, за которой следует структура
A. Порядок байт: от старшего к младшему. Адреса указаны в виде смещений от начала данных. В решении предлагается использовать модуль
struct.
Структура A:
Поле | Описание |
---|---|
1 | Структура B |
2 | uint8 |
3 | Адрес (uint32) структуры D |
Структура B:
Поле | Описание |
---|---|
1 | uint8 |
2 | Массив адресов (uint16) структур C, размер 5 |
3 | uint16 |
Структура C:
Поле | Описание |
---|---|
1 | uint8 |
2 | int8 |
3 | int8 |
Структура D:
Поле | Описание |
---|---|
1 | int16 |
2 | uint64 |
3 | double |
4 | Адрес (uint32) структуры E |
5 | Массив int32, размер 4 |
Структура E:
Поле | Описание |
---|---|
1 | int64 |
2 | uint32 |
3 | uint16 |
4 | int32 |
5 | Размер (uint16) и адрес (uint16) массива int8 |
6 | Размер (uint16) и адрес (uint32) массива uint64 |
Ниже показаны примеры разбора двоичного формата.
Пример 1
Двоичные данные:
b'CSMI\xc2\x00\x16\x00\x19\x00\x1c\x00\x1f\x00"T\xbdr\x00\x00\x00uy#\xf4\xdeQs'
(b'6L\x82&\x92H\xdb\xca\xff#\xc9\x1bZ\x1d*\xd2B\x9da\x9aV\x0cx\xd4!\xdd\xb3\xd1'
b"\xf6\x03\x00\xdf\xd6%#\xcc\xbc)\xc9\x17*\xd2\xd9\x1fF\xffC}U\x0f'\x9b"
b'\x17\xa9\x14\x98\xb0\x97\xe3\x0bl\x03\xe2\x91lF\x87\xb5\x90\x9f\xe1G'
b'$\x9c\x95\xb4H\x0ff\x00\x04\x00%\x00\x06\x00\x00\x00)\x1e\tg=\r5\xa4'
b'`\xd68\xbf\xe5\xcaW)\x82R\xfe\x00\x00\x00Y\xe3\x87\x1fv<\xe3\x85\xdb\xf4'
b"~'\xe3\xf6\xbab\x9f")
Результат разбора:
'A1': {'B1': 194,
{'B2': [{'C1': 121, 'C2': 35, 'C3': -12},
'C1': 222, 'C2': 81, 'C3': 115},
{'C1': 54, 'C2': 76, 'C3': -126},
{'C1': 38, 'C2': -110, 'C3': 72},
{'C1': 219, 'C2': -54, 'C3': -1}],
{'B3': 21693},
'A2': 114,
'A3': {'D1': 7689,
'D2': 7439116683528164920,
'D3': -0.6809497652744481,
'D4': {'E1': 279946021076186512,
'E2': 2682341156,
'E3': 40085,
'E4': -1270345882,
'E5': [35, -55, 27, 90],
'E6': [2101723359671851606,
898701367578972662,
216418892952882364,
3010963298567397190,
18393683107391183639,
12183530776173939564]},
'D5': [-477683850, 1021543899, -193058845, -155557217]}}
Пример 2
Двоичные данные:
b'CSMI\xe6\x00\x16\x00\x19\x00\x1c\x00\x1f\x00"^\xdc\xdc\x00\x00\x00o\x92R'
(b'"\xbe:>\xcc\xab8)\x06\x17\xa1K!\xa2n\xdc\x9f\x94\xca\n\xce\x04\xfb\n'
b"/\xfc\xb1!`'\xef\x80L\x88\x1e\xb0\xce^Z\xbf\x8e\xd7u\xfd\xb5\x9cL\x97"
b'7\xdaC\x12\xfb\xf5\xed\xe1\xa4\x92\xa0R}w\x0e\xfds)\xde\x80_\xb2-\x86'
b'\xbe\xca\xa7\x92i\x00\x06\x00%\x00\x05\x00\x00\x00+\xf9y\xbc\x9bIe\xb6\xde^'
b'5?\xd5c\xee\xa9dW\x84\x00\x00\x00S6\xc3:5\xce\x95\x83\x127\xfc{o\x82\x13\\'
b'\x89')
Результат разбора:
'A1': {'B1': 230,
{'B2': [{'C1': 146, 'C2': 82, 'C3': 34},
'C1': 190, 'C2': 58, 'C3': 62},
{'C1': 204, 'C2': -85, 'C3': 56},
{'C1': 41, 'C2': 6, 'C3': 23},
{'C1': 161, 'C2': 75, 'C3': 33}],
{'B3': 24284},
'A2': 220,
'A3': {'D1': -1671,
'D2': 13590537001729154613,
'D3': 0.33422438184913283,
'D4': {'E1': 5944037989464353246,
'E2': 2153755181,
'E3': 34494,
'E4': -894987671,
'E5': [-94, 110, -36, -97, -108, -54],
'E6': [778565261835893937,
2404966110619011102,
12740224139731588981,
18281690115148864067,
1367957313878790816]},
'D5': [918764085, -829062382, 939293551, -2112660343]}}
Задача №12
Реализовать разбор двоичного формата данных. Данные начинаются с сигнатуры 0xd2 0x46 0x53 0x48 0x4f
, за которой следует
структура A. Порядок байт: от младшего к старшему. Адреса указаны в виде смещений от начала данных. В решении предлагается использовать
модуль struct.
Структура A:
Поле | Описание |
---|---|
1 | Массив char, размер 7 |
2 | int8 |
3 | Структура B |
4 | Адрес (uint32) структуры D |
5 | uint8 |
Структура B:
Поле | Описание |
---|---|
1 | uint64 |
2 | int16 |
3 | Размер (uint16) и адрес (uint32) массива структур C |
4 | Массив int8, размер 4 |
Структура C:
Поле | Описание |
---|---|
1 | int8 |
2 | uint8 |
3 | uint16 |
Структура D:
Поле | Описание |
---|---|
1 | Массив uint16, размер 4 |
2 | int32 |
3 | Размер (uint16) и адрес (uint32) массива int16 |
Ниже показаны примеры разбора двоичного формата.
Пример 1
Двоичные данные:
b'\xd2FSHOjbnuyobht05\r\xfc\xcb~\xd7\x8dQ\x04\x00&\x00\x00\x00\xf3\x94\x1d'
(b"\x91:\x00\x00\x00\xb7'a\xca\xc4\xbaD\x17\x1e\x9e\xed\xfa=\xc61\x17g\xa3K"
b'\xc9\xd8)K\xd19{\xbf\xdeUC\xfc\xe2\xdf\x02\x006\x00\x00\x00')
Результат разбора:
'A1': 'jbnuyob',
{'A2': 104,
'A3': {'B1': 15528072848633835636,
'B2': 20877,
'B3': [{'C1': 39, 'C2': 97, 'C3': 50378},
'C1': -70, 'C2': 68, 'C3': 7703},
{'C1': -98, 'C2': 237, 'C3': 15866},
{'C1': -58, 'C2': 49, 'C3': 26391}],
{'B4': [-13, -108, 29, -111]},
'A4': {'D1': [19241, 14801, 49019, 21982],
'D2': -538772413,
'D3': [19363, -10039]},
'A5': 183}
Пример 2
Двоичные данные:
b'\xd2FSHOkfyldzq\xbe\xb5\xb4\x15\xa5\xd9\xb4\xfe\xbf\xa3\xaf\x04\x00&\x00\x00'
(b'\x00MDS\xba<\x00\x00\x00Y\x11\x03p\xe10R\x12\x92\xf8r\xf7\xe4\xf2\xdd'
b'o\xb3\x98\x99l^\xe7\x12\xa9E\x0b\xc6I\x12y\xcd>\xa8\xde\x8a\x03\x006\x00'
b'\x00\x00')
Результат разбора:
'A1': 'kfyldzq',
{'A2': -66,
'A3': {'B1': 13834693952199308469,
'B2': -20573,
'B3': [{'C1': 17, 'C2': 3, 'C3': 57712},
'C1': 48, 'C2': 82, 'C3': 37394},
{'C1': -8, 'C2': 114, 'C3': 58615},
{'C1': -14, 'C2': 221, 'C3': 45935}],
{'B4': [77, 68, 83, -70]},
'A4': {'D1': [17833, 50699, 4681, 52601],
'D2': -1965119426,
'D3': [-26216, 24172, 4839]},
'A5': 89}
Задача №12
Реализовать разбор двоичного формата данных. Данные начинаются с сигнатуры 0x58 0x4d 0x4b 0x53
, за которой следует структура
A. Порядок байт: от младшего к старшему. Адреса указаны в виде смещений от начала данных. В решении предлагается использовать модуль
struct.
Структура A:
Поле | Описание |
---|---|
1 | uint32 |
2 | Адрес (uint32) структуры B |
3 | Массив int16, размер 5 |
4 | Структура F |
5 | uint64 |
6 | double |
Структура B:
Поле | Описание |
---|---|
1 | uint16 |
2 | Размер (uint16) и адрес (uint16) массива адресов (uint32) структур C |
3 | int16 |
4 | Адрес (uint32) структуры D |
5 | int64 |
Структура C:
Поле | Описание |
---|---|
1 | uint32 |
2 | int64 |
Структура D:
Поле | Описание |
---|---|
1 | Массив uint16, размер 4 |
2 | uint16 |
3 | float |
4 | Размер (uint32) и адрес (uint32) массива int16 |
5 | Адрес (uint16) структуры E |
6 | double |
Структура E:
Поле | Описание |
---|---|
1 | int16 |
2 | int8 |
3 | uint8 |
4 | double |
Структура F:
Поле | Описание |
---|---|
1 | uint64 |
2 | float |
3 | double |
Ниже показаны примеры разбора двоичного формата.
Пример 1
Двоичные данные:
b'XMKSS\xacZr\x92\x00\x00\x00*6g\xf86/+\x92\xe90B\xe2X{\x8f\xbd\xf0\xbeNF'
(b'6?\xa05\x11\xd74\xf9\xd7?\x8au\x9b\x9b\xba^\xf2\\\xd0\x8c[\x16\xb9d\xc5?}z'
b'\xcb.\x0e\xb4\xee\xc1J\x8e\x83\xd0\x8f\xff\x94{\x96#\xf9/\x8c\xda\x03u:\x00'
b'\x00\x00F\x00\x00\x00\xb7>\x8a\xa4`\x03\xb0\x95Z\x7f\xda\xc9{e\xc36\xf2\xbe'
b'\xed\xbcf\x87\xe4\xbfL\xc6v*\xdd\xb3)p\x8c\x9e\xa8^\x97\xbe\x06\x00\x00\x00'
b'Z\x00\x00\x00f\x00\x90\xb8\xfd\xf6\x84\xe2\xba\xbfZ@\x02\x00R\x00\x85lr\x00'
b'\x00\x00\x03\xa8\x94\xcc\xb0\x89[|')
Результат разбора:
'A1': 1918544979,
{'A2': {'B1': 16474,
'B2': [{'C1': 785087101, 'C2': -3421734840139074546},
'C1': 2073362319, 'C2': 8431823223002833814}],
{'B3': 27781,
'B4': {'D1': [50764, 10870, 46045, 28713],
'D2': 40588,
'D3': -0.29564404487609863,
'D4': [16055, -23414, 864, -27216, 32602, -13862],
'D5': {'E1': 25979,
'E2': -61,
'E3': 54,
'E4': -0.6415284814847537},
'D6': -0.10501891164833155},
'B5': 8960907276023277571},
'A3': [13866, -1945, 12086, -28117, 12521],
'A4': {'F1': 13758705285564260930,
'F2': 0.7120102643966675,
'F3': 0.3745853519693245},
'A5': 6697519751420933514,
'A6': 0.16713632194214378}
Пример 2
Двоичные данные:
b'XMKS!\x98v\xa0\x9a\x00\x00\x00\x8b\x8c\x8b\xbb\xcf\xfc\xb5\x82'
(b'\x1a\x15\xe6\xd7~K.\x02\xe5\x00,\xccE>6X:\xd2\x95\xf4\xeb?\xcc9'
b"\x0b\xc7\xfa\xf8O\xfeJ,\x04}\xcdC\xe5?'~)g\x06\xc7\xb0\x89\xc93\xcb\xd5:\xdb"
b'\xe8\xaeI\x1e\xa4c+\xd1\x88\x83}\xd2\x1d\x8a\xa2\xb3ogz\x83?l:\x00'
b'\x00\x00F\x00\x00\x00R\x00\x00\x00\xb8\xd4]\x07\xc8M<\xcbn\xf4K\xaf\x95\xe9'
b'\xef?\x9b|\x9d\xc8\x1c\xe6\xf7\xb2\xd2\xc3N\xc3`?\x02\x00\x00\x00'
b'j\x00\x00\x00n\x00\xd0\nS:\xcd\x1f\xbb?.\xef\x03\x00^\x00\x04\xf9z\x00'
b'\x00\x00a\xc8\xf0\x15YR\xb7\x0f')
Результат разбора:
'A1': 2692126753,
{'A2': {'B1': 61230,
'B2': [{'C1': 1730772519, 'C2': -3041280182667131130},
'C1': 2934496058, 'C2': -8968688673622843831},
{'C1': 2317210237, 'C2': 7800097641373610914}],
{'B3': -1788,
'B4': {'D1': [31899, 51357, 58908, 45815],
'D2': 50130,
'D3': 0.87798011302948,
'D4': [-11080, 1885],
'D5': {'E1': 19912,
'E2': 60,
'E3': 203,
'E4': 0.9972637580646173},
'D6': 0.10595400499282026},
'B5': 1132464373880637537},
'A3': [-29557, -17525, -817, -32075, 5402],
'A4': {'F1': 64460167525095398,
'F2': 0.19316166639328003,
'F3': 0.8736065965665663},
'A5': 18325139164758751692,
'A6': 0.6645266954159379}
Задача №12
Реализовать разбор двоичного формата данных. Данные начинаются с сигнатуры 0x56 0x50 0x45 0x4b 0xcd
, за которой следует
структура A. Порядок байт: от старшего к младшему. Адреса указаны в виде смещений от начала данных. В решении предлагается использовать
модуль struct.
Структура A:
Поле | Описание |
---|---|
1 | Массив адресов (uint32) структур B, размер 4 |
2 | Массив char, размер 6 |
3 | uint16 |
4 | Структура C |
5 | Размер (uint32) и адрес (uint32) массива int8 |
Структура B:
Поле | Описание |
---|---|
1 | int64 |
2 | int32 |
3 | int32 |
Структура C:
Поле | Описание |
---|---|
1 | Структура D |
2 | Адрес (uint16) структуры E |
3 | int32 |
Структура D:
Поле | Описание |
---|---|
1 | float |
2 | uint32 |
Структура E:
Поле | Описание |
---|---|
1 | uint32 |
2 | uint8 |
3 | Размер (uint32) и адрес (uint32) массива int64 |
Ниже показаны примеры разбора двоичного формата.
Пример 1
Двоичные данные:
b'VPEK\xcd\x00\x00\x003\x00\x00\x00C\x00\x00\x00S\x00\x00\x00cbhkxro\x03'
(b">\xbf'\x95\\\xb8\xc1\x18\xc6\x00\x83u\tr\xe9\x00\x00\x00\x02\x00"
b'\x00\x00\x90|\xe3\x83-\xbf\xb4-v\xdc\\a\xdcq\x9d\xeb\x8c"\xfcp\xf8\x8a'
b'\xa2g\xb0\xdaz\x18W)\xed\xb1\xc9\x82~\x13\xef\xcd@n|O\xb6\xce\x1e25\xf69\xae'
b'}\xc6\xa5Nr\x03\xe7\x94\x9b#\xc1q\x02\x0e\xff!\xdf\xd4\xd4\xd2\xf2\xea4n'
b'\xa0\xe2\xeb}\x87\x1c\x1c)\xf8\x08\xd6(\x00\x00\x00\x02\x00\x00\x00sU#')
Результат разбора:
'A1': [{'B1': 8999180712929406326, 'B2': -597925412, 'B3': 1906174860},
{'B1': 2521014104200734640, 'B2': -629532585, 'B3': 703443401},
{'B1': -9043769081051713924, 'B2': 1337380382, 'B3': 842397241},
{'B1': -5873319925733260313, 'B2': -1801772095, 'B3': 1895960319}],
{'A2': 'bhkxro',
'A3': 830,
'A4': {'C1': {'D1': -0.6546227931976318, 'D2': 3099662534},
'C2': {'E1': 704121046,
'E2': 40,
'E3': [2440903533595388468, 7971620841496976412]},
'C3': 1963553513},
'A5': [85, 35]}
Пример 2
Двоичные данные:
b'VPEK\xcd\x00\x00\x003\x00\x00\x00C\x00\x00\x00S\x00\x00\x00czeelya\x0e'
(b'}>i\xbd@ja;\xd1\x00\x93\xb4y\xb1\xff\x00\x00\x00\x02\x00\x00\x00\xa0i\xb31h:'
b'\xc4.\xbdc\x97\x0e-%\xa3s\x85Y\xcf7q\xa4x[\x87\xc3\xe0<>(\xd6T_\xd1'
b'3\x8f\xfc\x88\x1dE\xe1C!\x0ewe}\xc7%\xc0\xc1\t\xf639\x06\xc5\xff\x00kg\xca'
b"\xbf\x89\xf9&\xb0\xa5\xb9\x0fG<\xe3\xe6\xa1\xf6'\n\xdb\xc7\xc1\x8b"
b'\x14\xa0\x19\xf7\xe3\x9c\x1e\xd7\xc5tR\xa1\x8e\xd7\x95I06\x7fU'
b'\x00\x00\x00\x04\x00\x00\x00s\x9dt')
Результат разбора:
'A1': [{'B1': 7616485718545936061, 'B2': 1670843949, 'B3': 631468933},
{'B1': 6471452150784875399, 'B2': -1008714690, 'B3': 685134943},
{'B1': -3372193381192219167, 'B2': 1126239863, 'B3': 1702741797},
{'B1': -4557350394896251195, 'B2': -16749721, 'B3': -893416967}],
{'A2': 'zeelya',
'A3': 3709,
'A4': {'C1': {'D1': 0.22826099395751953, 'D2': 1784757201},
'C2': {'E1': 1227896447,
'E2': 85,
'E3': [2787910383586196707,
-1827909326189377599,
-8424932969509839842,
-2898782886896412779]},
'C3': -1267092993},
'A5': [-99, 116]}
Задача №12
Реализовать разбор двоичного формата данных. Данные начинаются с сигнатуры 0x43 0x45 0x58
, за которой следует структура A.
Порядок байт: от старшего к младшему. Адреса указаны в виде смещений от начала данных. В решении предлагается использовать модуль
struct.
Структура A:
Поле | Описание |
---|---|
1 | Адрес (uint32) структуры B |
2 | float |
3 | uint8 |
4 | float |
5 | uint32 |
Структура B:
Поле | Описание |
---|---|
1 | int16 |
2 | int32 |
3 | Массив char, размер 5 |
4 | Массив структур C, размер 3 |
5 | Структура D |
6 | uint64 |
7 | Размер (uint32) и адрес (uint16) массива float |
8 | float |
Структура C:
Поле | Описание |
---|---|
1 | uint16 |
2 | int32 |
3 | int16 |
Структура D:
Поле | Описание |
---|---|
1 | uint64 |
2 | Размер (uint16) и адрес (uint16) массива int16 |
Ниже показаны примеры разбора двоичного формата.
Пример 1
Двоичные данные:
b'CEX\x00\x00\x00 >\xd9s\xed\xaa\xbeY\xd6\xbcz\x19\x0c\xf6\xa4Y^\xe5'
(b">\xf2\xcb\xf8?L\xb6e'\xd9S\xa5x^bipxd!\xb3,\x9a{\x0e]9=\xf5\xa7\xf4\x04"
b'>\xf7\xabJ\xcd$\x8d@\xfc)K\x02\xe8\xc1s=DU\xf3\x00\x02\x00\x14\x9e'
b'\x0fW\xc1\x13K\xff\xb3\x00\x00\x00\x02\x00\x18\xbe\x0f3\xe3')
Результат разбора:
'A1': {'B1': 10201,
{'B2': 1403353182,
'B3': 'bipxd',
'B4': [{'C1': 8627, 'C2': 748321550, 'C3': 23865},
'C1': 15861, 'C2': -1477180354, 'C3': -2133},
{'C1': 19149, 'C2': 613236988, 'C3': 10571}],
{'B5': {'D1': 209630083366016499, 'D2': [-23463, 24293]},
'B6': 11389418469407326131,
'B7': [0.4742124080657959, 0.7996581196784973],
'B8': -0.13984636962413788},
'A2': 0.42471256852149963,
'A3': 170,
'A4': -0.2127332091331482,
'A5': 2048462070}
Пример 2
Двоичные данные:
b'CEX\x00\x00\x00$?\x15\x0f6\xe0>\xee\xe7\xdd@\x14\xb36\xe3\xce\xb2\xb8'
(b'?_\x10\x9f?\x06\xc3\xcf?mq\x7f\xfe\xca\xc8\xa5\xc6\x01yjcrcZ.\x97\xb4X'
b'\x1c\x99\xd0\xdd4\xf0F\xe8XDV\x04\x9a\n\x9bb[\xb9p\xbb\x96u\xadq'
b'\xf3\xd6\xe1\x00\x02\x00\x14\xcd\xe2\xd0i\x88\x14\xfd\xdb\x00'
b'\x00\x00\x03\x00\x18??!E')
Результат разбора:
'A1': {'B1': -310,
{'B2': -928659967,
'B3': 'yjcrc',
'B4': [{'C1': 23086, 'C2': -1749788644, 'C3': -26160},
'C1': 56628, 'C2': -263788456, 'C3': 17494},
{'C1': 1178, 'C2': 177955419, 'C3': -18064}],
{'B5': {'D1': 13517120719400720097, 'D2': [-7218, -19784]},
'B6': 14835649274185055707,
'B7': [0.8713473677635193, 0.526425302028656, 0.927513062953949],
'B8': 0.746601402759552},
'A2': 0.5822633504867554,
'A3': 224,
'A4': 0.46661272644996643,
'A5': 1075098422}
Задача №12
Реализовать разбор двоичного формата данных. Данные начинаются с сигнатуры 0x50 0x41 0x4c 0x41
, за которой следует структура
A. Порядок байт: от старшего к младшему. Адреса указаны в виде смещений от начала данных. В решении предлагается использовать модуль
struct.
Структура A:
Поле | Описание |
---|---|
1 | double |
2 | Структура B |
3 | Размер (uint32) и адрес (uint32) массива структур C |
4 | Размер (uint16) и адрес (uint16) массива int32 |
5 | Адрес (uint16) структуры D |
6 | int16 |
Структура B:
Поле | Описание |
---|---|
1 | Размер (uint32) и адрес (uint16) массива char |
2 | uint16 |
3 | int8 |
4 | int8 |
5 | int8 |
6 | Массив char, размер 2 |
Структура C:
Поле | Описание |
---|---|
1 | uint64 |
2 | int16 |
3 | Массив int8, размер 4 |
4 | uint64 |
5 | uint16 |
6 | float |
7 | int8 |
8 | uint8 |
Структура D:
Поле | Описание |
---|---|
1 | int64 |
2 | uint64 |
3 | uint32 |
4 | int32 |
Ниже показаны примеры разбора двоичного формата.
Пример 1
Двоичные данные:
b'PALA?\xdb\xe0\xe7\xb3\x1a\x13\xb0\x00\x00\x00\x06\x00)r\x1dv\x87Wk'
(b'i\x00\x00\x00\x02\x00\x00\x00/\x00\x06\x00k\x00\x83\x11\xabrqqgqv\xbd'
b'\xe5\\\x11\xf1\x97a\x98\x05\xf9[X\x18v\x070\x08\xcf\xac\xe6}\x9e\xd7\xff?'
b'b\xa4\xf5\x8c\xf6\x05\xc1\x8dE\x194\xee\xec\xbc\x04\x8b\x95_Q%\x1cJq"'
b'V \xfb\x0f9\xbe\xe6\xd4\xe5\xa3\x86\x16\xe2\x0e\x82\xbb\xe9\xbfr\x90'
b'+\xc4A\x12\x9aO\xe0\xfc \xe0\xf2\xae\xc6\xddc\xf4\xf4Z\xdf\x9c'
b'\xd0\x93\xba\xe5\x05\xcaA:\x88\xb2r\xd2a`9\x01lL\xd1')
Результат разбора:
'A1': 0.43560211649338054,
{'A2': {'B1': 'rqqgqv',
'B2': 29213,
'B3': 118,
'B4': -121,
'B5': 87,
'B6': 'ki'},
'A3': [{'C1': 13683444274972549528,
'C2': 1529,
'C3': [91, 88, 24, 118],
'C4': 517923645199646110,
'C5': 55295,
'C6': 0.88532954454422,
'C7': -116,
'C8': 246},
'C1': 414767968609955564,
{'C2': -17404,
'C3': [-117, -107, 95, 81],
'C4': 2674094128519061755,
'C5': 3897,
'C6': -0.4508430063724518,
'C7': -93,
'C8': 134}],
'A4': [383913602, -1142309006, -1876179903, 312102880, -64954126, -1362698909],
'A5': {'D1': -795911317682613318,
'D2': 16502818791072772722,
'D3': 3529596985,
'D4': 23874769},
'A6': 4523}
Пример 2
Двоичные данные:
b'PALA\xbf\xe6\xbbj\xd5Nv\xc2\x00\x00\x00\x06\x00)\xb5"?\x84!ve\x00\x00\x00'
(b'\x02\x00\x00\x00/\x00\x07\x00k\x00\x87b\xc9lochux\x85UM\x05R&LC\xce'
b'\x83\xc6t\xa3\xad\xf8\x8ei\x02\x8fV\x9b!\x9c\xe9\xbfM\xcd\xfd@'
b'\x87\x15\x8f\x0f17mS\xcb\x1f\xf2\xd3\xdfn~f\xc7t\xdd\xa4\xb4\xa4\xb1K'
b"%\xbf\x06\xb7!JS=\t\x0ca\xb0gW\xb1KB\xe1\xe7('\xd4\xff_\xa7\x0e\x02cG\x14mb"
b'H\xe1Js&\x96\xf8fiU}G\xbb^\xd5\xabL\xe8\xa1\xbd\x1bX \xa4o\x10\xcb')
Результат разбора:
'A1': -0.7103780904905863,
{'A2': {'B1': 'lochux',
'B2': 46370,
'B3': 63,
'B4': -124,
'B5': 33,
'B6': 've'},
'A3': [{'C1': 9607670065313238083,
'C2': -12669,
'C3': [-58, 116, -93, -83],
'C4': 17910368227814710049,
'C5': 40169,
'C6': -0.8039243817329407,
'C7': 64,
'C8': 135},
'C1': 1553477100523836363,
{'C2': 8178,
'C3': [-45, -33, 110, 126],
'C4': 7406016607533966513,
'C5': 19237,
'C6': -0.5262318253517151,
'C7': 74,
'C8': 83}],
'A4': [1024003169,
-1335404623,
1262674407,
673699071,
1604783618,
1665602669,
1648943434],
'A5': {'D1': 8297485357090952573,
'D2': 5168829269132765345,
'D3': 3172685856,
'D4': -1536225077},
'A6': 25289}
Задача №12
Реализовать разбор двоичного формата данных. Данные начинаются с сигнатуры 0x5c 0x4d 0x58 0x4f 0x50
, за которой следует
структура A. Порядок байт: от старшего к младшему. Адреса указаны в виде смещений от начала данных. В решении предлагается использовать
модуль struct.
Структура A:
Поле | Описание |
---|---|
1 | Адрес (uint32) структуры B |
2 | int16 |
3 | Размер (uint16) и адрес (uint32) массива структур D |
Структура B:
Поле | Описание |
---|---|
1 | int16 |
2 | Размер (uint32) и адрес (uint32) массива char |
3 | Адрес (uint16) структуры C |
4 | int64 |
5 | uint8 |
6 | int64 |
7 | uint64 |
8 | uint32 |
Структура C:
Поле | Описание |
---|---|
1 | uint64 |
2 | uint64 |
3 | Массив float, размер 5 |
4 | int64 |
5 | int8 |
Структура D:
Поле | Описание |
---|---|
1 | Массив int16, размер 8 |
2 | uint8 |
Ниже показаны примеры разбора двоичного формата.
Пример 1
Двоичные данные:
b'\\MXOP\x00\x00\x00@B\xb6\x00\x02\x00\x00\x00iam\xdc\x82l[ZT\xd2\xdf\xfc'
(b'U\xb6\xfa{}Ua\xbd\x18\x13\x10\xbd\x8c\xd4\xe4\xbf(U\xed>\x99\xb84\xbe'
b'\x86\xd0\xef3\xffv-@<8\xb4je\xa5\x00\x00\x00\x02\x00\x00\x00\x11\x00\x13'
b',\xaf\xe5z]JO\xde\x0e"\xa8\x86\xc7#\xc3waxI\xd29\xaeq\x83\xb7\x92\x8b\xcd'
b")\xc5z:W'\x1dR\x97U\x00\xe4h\xd0\x8cZt\xa0\xbf2\xc15\xdew\xe4V\x97H"
b'\xff\x03\xb2\x81\xc2\x08\xa0')
Результат разбора:
'A1': {'B1': 26021,
{'B2': 'am',
'B3': {'C1': 15889381574929863391,
'C2': 18182640257508136289,
'C3': [-0.037127554416656494,
-0.06876543164253235,
-0.6575611233711243,
0.30023348331451416,
-0.26331278681755066],
'C4': 3746843351718836404,
'C5': 106},
'B4': 3220044572307115998,
'B5': 14,
'B6': 2497394183233566561,
'B7': 8667690103032873911,
'B8': 2458635561},
'A2': 17078,
'A3': [{'D1': [-14982, 14935, 10013, 21143, 21760, -7064, -12148, 23156],
'D2': 160},
'D1': [-16590, -16075, -8585, -7082, -26808, -253, -19839, -15864],
{'D2': 160}]}
Пример 2
Двоичные данные:
b'\\MXOP\x00\x00\x00@\xeb\xee\x00\x02\x00\x00\x00ivz\xdah}M\xc8\xa6\x00\x8f8'
(b'\x94\xbc\xd5\x92 \x0c8?Z\xb2&\xbf-\xa0\xac\xbf`0m>\x13\x9c\xe9\xbf'
b'\x1a\xcc\xac`\x13vc\xd3\x93\xf4\xbb\x82%?\x00\x00\x00\x02\x00\x00'
b'\x00\x11\x00\x13\x90\xe4F\x8d{o\xf7>\xca\xfc1Xp\xab\xb4\xf0^\x1d"\xe7'
b'\xe4\xe2{^v\x06S\x83\xb0t\xbd3b\xe3\xd8\x9f=i\xcd\xcf\xef\xa4\xc2y\xdc\xf6Hq'
b'\xcc]\xbc\xc5j\xdd\x1d\x0f\x89,\xfa\xcb\xdb\x93\xfb')
Результат разбора:
'A1': {'B1': 9535,
{'B2': 'vz',
'B3': {'C1': 15737966670878474383,
'C2': 4077091188142771256,
'C3': [0.8542808294296265,
-0.6782329082489014,
-0.8757389187812805,
0.14415325224399567,
-0.6046855449676514],
'C4': 6923007223322113211,
'C5': -126},
'B4': -8006196664082630850,
'B5': 202,
'B6': -274340861352546210,
'B7': 2099495346546368118,
'B8': 106136496},
'A2': -5138,
'A3': [{'D1': [29885, 13154, -7208, -24771, 27085, -12305, -23358, 31196],
'D2': 246},
'D1': [18545, -13219, -17211, 27357, 7439, -30420, -1333, -9325],
{'D2': 251}]}
Задача №12
Реализовать разбор двоичного формата данных. Данные начинаются с сигнатуры 0x57 0x4b 0x5a
, за которой следует структура A.
Порядок байт: от старшего к младшему. Адреса указаны в виде смещений от начала данных. В решении предлагается использовать модуль
struct.
Структура A:
Поле | Описание |
---|---|
1 | Структура B |
2 | uint16 |
3 | Размер (uint32) и адрес (uint16) массива char |
4 | double |
5 | Массив int16, размер 2 |
6 | int32 |
7 | double |
Структура B:
Поле | Описание |
---|---|
1 | uint64 |
2 | uint64 |
3 | uint32 |
4 | Структура C |
5 | int16 |
6 | Массив char, размер 3 |
Структура C:
Поле | Описание |
---|---|
1 | Размер (uint16) и адрес (uint32) массива адресов (uint32) структур D |
2 | int16 |
3 | int8 |
4 | uint8 |
5 | uint8 |
6 | uint64 |
7 | int32 |
8 | Структура E |
Структура D:
Поле | Описание |
---|---|
1 | uint64 |
2 | uint8 |
3 | uint64 |
4 | int32 |
5 | int32 |
6 | uint32 |
Структура E:
Поле | Описание |
---|---|
1 | double |
2 | int64 |
Ниже показаны примеры разбора двоичного формата.
Пример 1
Двоичные данные:
b'WKZ\x1a\xc06\x1a\xb3\xc3<9\x9e\x90\x9c\x10\xcclf\x00\xa1!\xda\x17\x00'
(b"\x02\x00\x00\x00\x9d'\xfc>\x12a\x07\x94Q\x84n\xff;v\x89v*\xfc\xbf\xcf"
b'\x9d3E\x15\xc4\x08Y\xa04\x1e\x1c\x8dt\x9c\x14\xfdethP\x00\x00\x00\x00'
b'\x03\x00\xa5\xbf\xdd \xe7\x1aFW \tI\xf7Sl\x96\x05\x07?\xe7\xc7~\xc9b\x9dT='
b'g\xa4\x8f\xad\x18\x15zO\xf4f+v\x94\x07l\x18\xc7\x18kyz\x8b\x16\xe6\x01*1\xef'
b'\x87\x9d\xe1\xdfG\x06u,S}_\xf3\x12\xce\xb6\xd0x\x07\xa4\x92\x9az\xcd\xc1'
b'n\x1b\xbfk@\x00\x00\x00c\x00\x00\x00\x80zuk')
Результат разбора:
'A1': {'B1': 1927600128827538489,
{'B2': 11425803850602014208,
'B3': 2703350295,
'B4': {'C1': [{'D1': 4424686095906116986,
'D2': 79,
'D3': 17610811181168552984,
'D4': -954700935,
'D5': 2055935718,
'D6': 19542511},
'D1': 9772215115549406508,
{'D2': 83,
'D3': 9034206639631552632,
'D4': 128225946,
'D5': 2060304750,
'D6': 465529664}],
'C2': 10236,
'C3': 62,
'C4': 18,
'C5': 97,
'C6': 546151084058426230,
'C7': -1988744452,
'C8': {'E1': -0.24698487160961258, 'E2': 6458219169581986972}},
'B5': 5373,
'B6': 'eth'},
'A2': 20480,
'A3': 'zuk',
'A4': -0.45513322416205604,
'A5': [2377, -2221],
'A6': 1821771015,
'A7': 0.743102448778624}
Пример 2
Двоичные данные:
b'WKZ\xde\xa8\x84\xddg\xde\x1b\x91\x18k)\x87\\\x7fj\x07\x85U"\x98\x00'
(b'\x02\x00\x00\x00\x9d\x9d\xc6\x80G\xfff\x85\xc6\xca\xcf6\xec\xd3\x02\xa1'
b"k\xee?\xe2\xda\xe4\x84W_N'\xdcJ\x93\xb0\x12Au\xf1\x7fdpz?\x92\x00\x00\x00"
b"\x03\x00\xa5?\xd9'\x93\x14\xdbo\x90\xae\x9e\x95}\x0c\xb1y\x99\xbf"
b'\x8b[\x1d\xa6\xc2\x04\x00\x87\xa1\x05\xa1\xe5\x14\xa6\xa7\xb5\x16-z\xfc'
b'\x05\x84\xf4e\x01\x8a\xcb\xa6\xab\xbc\xf2>1\xe4\x9f\xfc\x8e\x85\xfd\xe8'
b'\xc4M\xcbW\t\x9e\xbc\x91\xa4\xc4\x9cW\xbd\xa6\x82\xa4?\x1e\xbfp\xf0\xed\xc7T'
b'_\x00\x00\x00c\x00\x00\x00\x80szo')
Результат разбора:
'A1': {'B1': 16044219758972640145,
{'B2': 1759545740767488519,
'B3': 2236949144,
'B4': {'C1': [{'D1': 9773098859261896359,
'D2': 181,
'D3': 1598068665629340773,
'D4': 25873318,
'D5': -1413680578,
'D6': 837066748},
'D1': 10269893701455956823,
{'D2': 9,
'D3': 11438177290473461693,
'D4': -1501387713,
'D5': 515862768,
'D6': 3989263455}],
'C2': -25146,
'C3': -128,
'C4': 71,
'C5': 255,
'C6': 7387529338133343443,
'C7': 44133358,
'C8': {'E1': 0.589220293501947, 'E2': 2872252660530168181}},
'B5': -3713,
'B6': 'dpz'},
'A2': 16274,
'A3': 'szo',
'A4': 0.3930404380496322,
'A5': [-20834, -27267],
'A6': 212957593,
'A7': -0.013357383395716127}
Задача №12
Реализовать разбор двоичного формата данных. Данные начинаются с сигнатуры 0x4f 0x44 0x49
, за которой следует структура A.
Порядок байт: от старшего к младшему. Адреса указаны в виде смещений от начала данных. В решении предлагается использовать модуль
struct.
Структура A:
Поле | Описание |
---|---|
1 | int64 |
2 | Массив адресов (uint16) структур B, размер 2 |
3 | Структура D |
4 | double |
5 | uint8 |
Структура B:
Поле | Описание |
---|---|
1 | Структура C |
2 | uint32 |
Структура C:
Поле | Описание |
---|---|
1 | double |
2 | uint8 |
3 | int8 |
4 | int16 |
5 | uint8 |
6 | int64 |
Структура D:
Поле | Описание |
---|---|
1 | Адрес (uint32) структуры E |
2 | uint64 |
3 | float |
4 | int8 |
Структура E:
Поле | Описание |
---|---|
1 | int32 |
2 | Адрес (uint32) структуры F |
3 | Размер (uint32) и адрес (uint16) массива int16 |
4 | int32 |
5 | int8 |
6 | Массив float, размер 5 |
Структура F:
Поле | Описание |
---|---|
1 | Массив int8, размер 2 |
2 | int32 |
Ниже показаны примеры разбора двоичного формата.
Пример 1
Двоичные данные:
b'ODI\xd5I\xf0\x9e\xab\xcd\xdf\x80\x00)\x00B\x00\x00\x00i\x85T\x7f\x15='
(b'E_\x9e\xbe\x0c\xc8\x12\x07\xbf\xeeF7\xd0\x84c|0?\xd4\x91\xee?\xaeK4S7\xa6'
b'\x83\t\x90\x8b\x07\x87\x15\xb5\x04\xdc\xb2l\x0b\xdc?\xac\xfb\xf9\xd9]'
b'\x1a\xe0H\n\xd2Y\xf1\x1c\xeb\xb1\xda\x9bx\x0f\x8d\x92<\x8aI\xeda\xf3\xcc\x8d'
b'\xec\x02,qzD\x9dL\x8d\xc7\xae\x8f\x90\x00\x00\x00[\x00\x00\x00\x04\x00a\xf4'
b'\xbbno\xd8\xbf<\xcbc?\x1cX\x8a=O\x92\xa0\xbe\x9b\x1c ?X\t\xc2')
Результат разбора:
'A1': -3077664306053128320,
{'A2': [{'B1': {'C1': 0.3214069005854754,
'C2': 83,
'C3': 55,
'C4': -22909,
'C5': 9,
'C6': -8031317233718983460},
'B2': 2993425372},
'B1': {'C1': 0.056609924110082366,
{'C2': 72,
'C3': 10,
'C4': -11687,
'C5': 241,
'C6': 2083954805058310029},
'B2': 2453441097}],
'A3': {'D1': {'E1': -944861296,
'E2': {'F1': [-19, 97], 'F2': -204698132},
'E3': [556, 29050, 17565, 19597],
'E4': -189043089,
'E5': -40,
'E6': [-0.7374784350395203,
0.610725998878479,
0.050676941871643066,
-0.3029489517211914,
0.8438988924026489]},
'D2': 9607443634287107998,
'D3': -0.1374819576740265,
'D4': 7},
'A4': -0.9460715363121461,
'A5': 48}
Пример 2
Двоичные данные:
b'ODI%\xe7\x90\x1a\x9d/\x8df\x00)\x00B\x00\x00\x00q\xc9g\xa9DK\xe4$\xe9\xbe'
(b'\xe1\x8e\xbd\xe7?\xef\xbc\\w;\x12\x10<\xbf\xed\xb5\x95\xd4{\xa5'
b'\xea\x9c\xc0\x8e\xb0_\xf7_\x98\x17:\x05\xa3\xc9;\x00\xf7\x08\xbf\xe6'
b'h\xb7\xb3\xb2C\xda\x8a\xc9\xa0\x14\xc9q\x18\xf2\xa9)\x83\xc4+\xcfQ\xa1?]'
b'\x0bBg\r\x1aJ\x18\xdf\x0e\xb3K\xed\xba\x99\xb1,;\xc7\x17CpI\xf2\xc7'
b'\x8a\x00\x00\x00[\x00\x00\x00\x08\x00a\xc2E\xf9\xd48\xbf]7s\xbe7\x1a\xb2'
b'?\x16\xf0\xa0\xbft\xc1\x9b>5\x81L')
Результат разбора:
'A1': 2731310143004183910,
{'A2': [{'B1': {'C1': -0.9284161710795023,
'C2': 156,
'C3': -64,
'C4': -29008,
'C5': 95,
'C6': -621610998028721207},
'B2': 989918984},
'B1': {'C1': -0.7002829084104818,
{'C2': 138,
'C3': -55,
'C4': -24556,
'C5': 201,
'C6': 8149530334086808619},
'B2': 3478233407}],
'A3': {'D1': {'E1': 1240647562,
'E2': {'F1': [93, 11], 'F2': 1114049818},
'E3': [18968,
-8434,
-19637,
-4678,
-26191,
11323,
-14569,
17264],
'E4': -1035601452,
'E5': 56,
'E6': [-0.8641273379325867,
-0.17881277203559875,
0.5896091461181641,
-0.9560791850090027,
0.17725104093551636]},
'D2': 14512754435020825833,
'D3': -0.4405421316623688,
'D4': -25},
'A4': 0.9917433098531223,
'A5': 60}
Задача №12
Реализовать разбор двоичного формата данных. Данные начинаются с сигнатуры 0x42 0x4d 0x46 0xbf
, за которой следует структура
A. Порядок байт: от младшего к старшему. Адреса указаны в виде смещений от начала данных. В решении предлагается использовать модуль
struct.
Структура A:
Поле | Описание |
---|---|
1 | Массив адресов (uint32) структур B, размер 2 |
2 | Размер (uint16) и адрес (uint32) массива uint16 |
3 | Размер (uint16) и адрес (uint32) массива int64 |
4 | Структура D |
Структура B:
Поле | Описание |
---|---|
1 | Размер (uint16) и адрес (uint32) массива char |
2 | Адрес (uint32) структуры C |
3 | float |
Структура C:
Поле | Описание |
---|---|
1 | int8 |
2 | uint16 |
3 | Массив uint32, размер 2 |
4 | int64 |
5 | uint8 |
Структура D:
Поле | Описание |
---|---|
1 | int16 |
2 | uint8 |
3 | int32 |
Ниже показаны примеры разбора двоичного формата.
Пример 1
Двоичные данные:
b'BMF\xbf6\x00\x00\x00[\x00\x00\x00\x05\x00i\x00\x00\x00\x02\x00s\x00\x00\x00'
(b'\xf2 \x8e\x16l\xef\x8ektm#\xfa\xa6Y\xc7P\xac\xe7\xf6\xfaJ\xdfG\x08b^\x1d"'
b'\x89\xe0\x03\x00\x1f\x00\x00\x00"\x00\x00\x00\\\x15l>ldq\xf9(\x9e\x8e\xe5'
b'y\xc4\xa5\xf8V\xf1e\x11\x85+{Fg,\x1e\x03\x00D\x00\x00\x00G\x00\x00'
b'\x00\xca\x911?[w\x93\x1a\xe0\x193\xafu\xc7@\xb9\xe1\x16\xd8d~\x94\x8a'
b'\x17\x19k\xf3\x89\xf1\x9f')
Результат разбора:
'A1': [{'B1': 'ktm',
{'B2': {'C1': 35,
'C2': 42746,
'C3': [2890975065, 1257961191],
'C4': -8565251250096420897,
'C5': 224},
'B3': 0.23055022954940796},
'B1': 'ldq',
{'B2': {'C1': -7,
'C2': 40488,
'C3': [3296322958, 4049008805],
'C4': 3199603555095089509,
'C5': 30},
'B3': 0.6936308145523071}],
'A2': [30555, 6803, 6624, 44851, 51061],
'A3': [-7746643429771069120, -6921599473724876918],
'A4': {'D1': 8434, 'D2': 142, 'D3': -1896911850}}
Пример 2
Двоичные данные:
b'BMF\xbf5\x00\x00\x00Z\x00\x00\x00\x02\x00h\x00\x00\x00\x03\x00l\x00\x00\x00'
(b'[+Qc\xae\x9f\xe3fi\xa6;PTw\xb2\x84\x1e\xfc#s}\xb7sE\xe4)\xce\xaa'
b'\xd7\x02\x00\x1f\x00\x00\x00!\x00\x00\x00C\xf3\x8c\xbebbt\xe6|'
b'\xf4\xe4\xaf\x03DRu\xb3j(T,r~\xa7\x93QG\x03\x00C\x00\x00\x00F\x00\x00\x00'
b"\x06\x92'\xbfO9e\x85\\@l\x17\x06@\xac8r\xc3\xcf\x84'\xf0\xc4\x10ay\xb4x"
b'\x0b\x93\xc5o')
Результат разбора:
'A1': [{'B1': 'fi',
{'B2': {'C1': -90,
'C2': 20539,
'C3': [2226288468, 1931738142],
'C4': -6138923181664913539,
'C5': 215},
'B3': -0.2752934396266937},
'B1': 'bbt',
{'B2': {'C1': -26,
'C2': 62588,
'C3': [1141092324, 1790145874],
'C4': 5878226100171854888,
'C5': 71},
'B3': -0.6545718908309937}],
'A2': [14671, 34149],
'A3': [4083709357025149020, 1208354652564734834, 8054005186101016929],
'A4': {'D1': 11099, 'D2': 81, 'D3': -476074397}}
Задача №12
Реализовать разбор двоичного формата данных. Данные начинаются с сигнатуры 0x52 0x42 0x51 0x54 0xf2
, за которой следует
структура A. Порядок байт: от старшего к младшему. Адреса указаны в виде смещений от начала данных. В решении предлагается использовать
модуль struct.
Структура A:
Поле | Описание |
---|---|
1 | int32 |
2 | float |
3 | int16 |
4 | Структура B |
5 | Адрес (uint32) структуры D |
Структура B:
Поле | Описание |
---|---|
1 | uint16 |
2 | Размер (uint32) и адрес (uint32) массива char |
3 | Массив структур C, размер 2 |
Структура C:
Поле | Описание |
---|---|
1 | int16 |
2 | int64 |
3 | Размер (uint32) и адрес (uint32) массива uint16 |
4 | uint32 |
Структура D:
Поле | Описание |
---|---|
1 | Размер (uint16) и адрес (uint32) массива uint32 |
2 | float |
3 | Массив int16, размер 6 |
Ниже показаны примеры разбора двоичного формата.
Пример 1
Двоичные данные:
b'RBQT\xf2;o\xe7n\xbe7K\x18\x8a\x0f\xaeE\x00\x00\x00\x08\x00\x00\x00I^\x9d\xd3'
(b'\xb3\x8c6\xb1\xf8\xbc!\x00\x00\x00\x02\x00\x00\x00Q\x89\xa4H\x95\xc0\x91/me'
b'p\xd8?U\xf5\x00\x00\x00\x04\x00\x00\x00U\xdd\xb7P\xb1\x00\x00\x00}ykfvsep'
b'a\xe0J\x1350\xc4\x13\xf8\x0b\x19\xdc\x99\xf45;\x0fjB\x9b\xfb\xecp\xf2'
b"U|\xa6\n\xcf=,\x84\x9a\xa2?\xe4\xe7'\x19S\xd1\xa5\x1a\xbbf\x00\x08\x00"
b'\x00\x00]?~\xf9\xb4\xb8\xac{\xf3\xd7a\xd7I\xd7"\x8bX')
Результат разбора:
'A1': 997189486,
{'A2': -0.17899739742279053,
'A3': -30193,
'A4': {'B1': 44613,
'B2': 'ykfvsepa',
'B3': [{'C1': 24221,
'C2': -3192053544333558751,
'C3': [57418, 4917],
'C4': 2309245077},
'C1': -16239,
{'C2': 3417499227582846453,
'C3': [12484, 5112, 2841, 56473],
'C4': 3719778481}]},
'A5': {'D1': [4097129231,
1782750203,
3966825045,
2091256527,
1026327706,
2722096359,
655971281,
2769992550],
'D2': 0.9959976673126221,
'D3': [-18260, 31731, -10399, -10423, -10462, -29864]}}
Пример 2
Двоичные данные:
b'RBQT\xf2\xed\xf6\xcf\x04?iyX\xf4\x80\x8fW\x00\x00\x00\x06\x00\x00\x00IL\xe2l'
(b'\xc8\x88E\xa5\x14D\xa0\x00\x00\x00\x04\x00\x00\x00O\x07I\x08\xfaI'
b'\xb0\xe0\xbe\x1ar\xde\xbb$M\x00\x00\x00\x03\x00\x00\x00W\xf8\x9a\x15'
b'G\x00\x00\x00qbjvovq0\xeae:wd\x88\x0b\xabS\xab\x1dnxOU\xf5\xa0\xbf\x15\xf6'
b'Bn0\x18\x0e\xbe\xd8R"\xd6\xee\xa3\x7f\x00\x05\x00\x00\x00]\xbf\x19]\xe2#'
b'8\x10 \x9a\xe5\xbd\xd9%&\xca\xcd')
Результат разбора:
'A1': -302592252,
{'A2': 0.9120078086853027,
'A3': -2944,
'A4': {'B1': 36695,
'B2': 'bjvovq',
'B3': [{'C1': 19682,
'C2': 7838664984142038176,
'C3': [12522, 25914, 30564, 34827],
'C4': 122226938},
'C1': 18864,
{'C2': -2252333682973268915,
'C3': [43859, 43805, 28280],
'C4': 4170847559}]},
'A5': {'D1': [1331033504, 3205887554, 1848645646, 3201847842, 3605963647],
'D2': -0.5990887880325317,
'D3': [9016, 4128, -25883, -16935, 9510, -13619]}}