Задача №12
Реализовать разбор двоичного формата данных. Данные начинаются с сигнатуры 0x43 0x50 0x56 0x53 0xae
, за которой следует
структура A. Порядок байт: от старшего к младшему. Адреса указаны в виде смещений от начала данных. В решении предлагается использовать
модуль struct.
Структура A:
Поле | Описание |
---|---|
1 | uint64 |
2 | uint8 |
3 | Структура B |
4 | Массив адресов (uint32) структур C, размер 3 |
5 | Структура D |
Структура B:
Поле | Описание |
---|---|
1 | uint16 |
2 | Размер (uint32) и адрес (uint16) массива char |
3 | double |
4 | Размер (uint16) и адрес (uint32) массива float |
Структура C:
Поле | Описание |
---|---|
1 | int8 |
2 | float |
3 | Массив uint8, размер 4 |
4 | uint64 |
Структура D:
Поле | Описание |
---|---|
1 | Размер (uint16) и адрес (uint32) массива uint32 |
2 | int16 |
3 | float |
Ниже показаны примеры разбора двоичного формата.
Пример 1
Двоичные данные:
b'CPVS\xaeP\xc4\xd1\x8b\x85\xc6,r\x8b\xe7\xd7\x00\x00\x00\x06\x00<\xbf\xe0'
(b'\x1c\x16n\xdc\xd3\\\x00\x02\x00\x00\x00B\x00\x00\x00J\x00\x00\x00['
b'\x00\x00\x00l\x00\x02\x00\x00\x00}Y\xe5?\x0f>Wdfqjfv\xbf\x04\x7f?>\xa4'
b'\x9a\x07\xad\xbf\x16\xaa\x02\xb5N\t\x82,\xec\xb7\xbe5\xc9\t\x94\xa2\xbfL0E'
b'\x80\x9f\xbfg\x9b\x9e#\xe6W\xbb\x99%s>\xadC\xffR\x9d\xbc\x15\x9c\x7f\x06'
b'\xe4\xfe\xc9`\x01\x93\x87\x00\xe7y\xb4\xf9,')
Результат разбора:
'A1': 5820007015644540018,
{'A2': 139,
'A3': {'B1': 59351,
'B2': 'dfqjfv',
'B3': -0.5034286656651648,
'B4': [-0.5175666213035583, 0.3214876353740692]},
'A4': [{'C1': -83,
'C2': -0.5885316133499146,
'C3': [181, 78, 9, 130],
'C4': 3237164259746580884},
'C1': -94,
{'C2': -0.7976115345954895,
'C3': [128, 159, 191, 103],
'C4': 11213439594420476197},
'C1': 115,
{'C2': 0.3384093940258026,
'C3': [82, 157, 188, 21],
'C4': 11276739572555931649}],
'A5': {'D1': [2475098343, 2041903404], 'D2': 23013, 'D3': 0.5595449805259705}}
Пример 2
Двоичные данные:
b'CPVS\xaem\x8d\x83r\xf8z\x9e0\xae\xe9\xce\x00\x00\x00\x07\x00<\xbf\xe1'
(b'\xef#\xd8\xbf:x\x00\x02\x00\x00\x00C\x00\x00\x00K\x00\x00\x00\\\x00\x00\x00m'
b'\x00\x03\x00\x00\x00~\xc2\x80\xbe&2\x85ivgcply>\xe2\xe2\xe9\xbf'
b'\n\xa6\x82\x8b\xbc\xd3\r\xdaNm\x8b@\x03\xbd\x11am1\xe9\x9a\x14\xbfF\x0c'
b'\xd2\xd6\x9a\x9d\xda\x9c:7@\x12\x0e\xa1\xd2\x9f\xbfYh\xd2?\xb5^\xfd^`'
b'\xa4?W\xde\x97\xd6d\xbcw\xcb\x14\xd7z*f\x9d\x01\xa0')
Результат разбора:
'A1': 7894110251668643376,
{'A2': 174,
'A3': {'B1': 59854,
'B2': 'ivgcply',
'B3': -0.560441897710759,
'B4': [0.44313743710517883, -0.5416032075881958]},
'A4': [{'C1': -117,
'C2': -0.025763440877199173,
'C3': [78, 109, 139, 64],
'C4': 269390662853585306},
'C1': 20,
{'C2': -0.7736331224441528,
'C3': [214, 154, 157, 218],
'C4': 11257370966886359506},
'C1': -97,
{'C2': -0.8492556810379028,
'C3': [63, 181, 94, 253],
'C4': 6800616029293549526}],
'A5': {'D1': [1690073035, 349665834, 1721565600],
'D2': -15744,
'D3': -0.16230209171772003}}
Задача №12
Реализовать разбор двоичного формата данных. Данные начинаются с сигнатуры 0x1a 0x4b 0x46 0x42 0x52
, за которой следует
структура A. Порядок байт: от старшего к младшему. Адреса указаны в виде смещений от начала данных. В решении предлагается использовать
модуль struct.
Структура A:
Поле | Описание |
---|---|
1 | uint8 |
2 | Структура B |
3 | uint16 |
4 | Массив адресов (uint16) структур D, размер 3 |
5 | int8 |
6 | float |
Структура B:
Поле | Описание |
---|---|
1 | int64 |
2 | int16 |
3 | Массив char, размер 2 |
4 | Массив char, размер 8 |
5 | Адрес (uint32) структуры C |
Структура C:
Поле | Описание |
---|---|
1 | int32 |
2 | int32 |
3 | int32 |
4 | uint32 |
5 | int64 |
6 | int64 |
Структура D:
Поле | Описание |
---|---|
1 | double |
2 | Размер (uint16) и адрес (uint16) массива uint16 |
Ниже показаны примеры разбора двоичного формата.
Пример 1
Двоичные данные:
b'\x1aKFBRi\x08\x9c\xec\xb9;\xe5U \xb0\xc8vgprqotiqh\x00\x00\x00+\xc0r'
(b'\x00S\x00c\x00s\x93?\x1c\xec\xa8Nv^\x11\xa1\xb6o\xa0\x9f\xc1Mo\xdc'
b'\xf8\x19\x94zE\xb2\xe9\xf0\xc9\x8d\xb54\xce#\x14\xe7\xd0h\x17\x97&a\x82\x80'
b'm\xcf|\xbf\xe0r\x12\xaf(\xdf\xcc\x00\x04\x00K\x9d\xffa\xba\xbf'
b'\xcc\x80\xa5\xfdr5`\x00\x02\x00_l\xd9hq\xbf\xb4mK\x81\xc33\x00\x00\x02\x00o')
Результат разбора:
'A1': 105,
{'A2': {'B1': 620631128988276000,
'B2': -20280,
'B3': 'vg',
'B4': 'prqotiqh',
'B5': {'C1': 1316380177,
'C2': -1581879392,
'C3': -1614721681,
'C4': 3707246996,
'C5': 8810644963857108405,
'C6': 3805017307870160919}},
'A3': 49266,
'A4': [{'D1': -0.5139249249541478, 'D2': [38694, 24962, 32877, 53116]},
'D1': -0.2226760375528256, 'D2': [40447, 25018]},
{'D1': -0.07979270856885634, 'D2': [27865, 26737]}],
{'A5': -109,
'A6': 0.6129860877990723}
Пример 2
Двоичные данные:
b'\x1aKFBR \x1d\xc4=u\x8c\x15\xcc\xb0\x83\x14tepkvaajev\x00\x00\x00+\xb0\xc1'
(b'\x00U\x00g\x00{\x90\xbe\xda\x85`H\xbdQ\x19\xf2\xa0\x85A9` +\x10\xb8\x9b\xd7|'
b'\x9a\xb4\xd27K\xe6\x9b\x91\xb4\xe2\x10v\x07\xcf\xbb\x0c\x07\xe5\xbcJ'
b'm\xd5\xfc\x83\xe1\xbf\xeb\t;\x07\xb4A\xd2\x00\x05\x00Kx\xcd\rA2\xa7\xbf'
b'\xcf\xc4 \xe9G\xde \x00\x03\x00a\xe5\x10\x8e\xe5\x04e\xb7~\xbf\xa5b\xbe\x02'
b'\x19y\x80\x00\x04\x00s')
Результат разбора:
'A1': 32,
{'A2': {'B1': 2144906897605905584,
'B2': -31980,
'B3': 'te',
'B4': 'pkvaajev',
'B5': {'C1': 1220366617,
'C2': -224361151,
'C3': 962601003,
'C4': 280533975,
'C5': 8978687622080358043,
'C6': -7947478882074505285}},
'A3': 45249,
'A4': [{'D1': -0.8448767805548931, 'D2': [3079, 58812, 19053, 54780, 33761]},
'D1': -0.2481728686395721, 'D2': [30925, 3393, 12967]},
{'D1': -0.04176896834973132, 'D2': [58640, 36581, 1125, 46974]}],
{'A5': -112,
'A6': -0.42679882049560547}
Задача №12
Реализовать разбор двоичного формата данных. Данные начинаются с сигнатуры 0x4b 0x41 0x4e
, за которой следует структура A.
Порядок байт: от старшего к младшему. Адреса указаны в виде смещений от начала данных. В решении предлагается использовать модуль
struct.
Структура A:
Поле | Описание |
---|---|
1 | Размер (uint32) и адрес (uint32) массива структур B |
2 | uint8 |
3 | float |
4 | uint8 |
5 | Адрес (uint16) структуры D |
6 | Размер (uint16) и адрес (uint32) массива int32 |
7 | int32 |
8 | Размер (uint16) и адрес (uint16) массива double |
Структура B:
Поле | Описание |
---|---|
1 | uint8 |
2 | Адрес (uint16) структуры C |
Структура C:
Поле | Описание |
---|---|
1 | int8 |
2 | int64 |
Структура D:
Поле | Описание |
---|---|
1 | Массив int8, размер 6 |
2 | uint8 |
3 | uint16 |
4 | Структура E |
5 | uint16 |
6 | int8 |
7 | uint16 |
8 | Размер (uint32) и адрес (uint32) массива int16 |
Структура E:
Поле | Описание |
---|---|
1 | uint64 |
2 | uint64 |
3 | int16 |
Ниже показаны примеры разбора двоичного формата.
Пример 1
Двоичные данные:
b'KAN\x00\x00\x00\x03\x00\x00\x00<f?\x1e\xb0F\x19\x00K\x00\x04\x00\x00\x00'
(b's\x08\x0e\x9a\x05\x00\x02\x00\x83\x01\n\xcfI\x80\xa3T\x92\xd0g\x0b$.6\x17'
b'\xa4\x8925j\x94(Z\xf2\x9d=v\xe9\x00!\xd7\x00*\xc7\x003 \xea\x9b\x0c/$\xb5'
b'\x94\x95\x0b\xf6\xbc\x04\xa26\x18\x1aeH\x9e\xe1\xd0`\x8e\xf2.ps\xd0\n7'
b'\xa0\xcae\xab\x83\xfa>\x00\x00\x00\x03\x00\x00\x00Er\x87\xffg\xae'
b'\x8fn\x03\x18z\x10>9\x9f\x8c\x8a?\xe6\xd6\xe3\xad\xef\xf6x?\xe0rZ\xe7'
b'\xe7\x8cp')
Результат разбора:
'A1': [{'B1': 233, 'B2': {'C1': 1, 'C2': 778922077403255504}},
{'B1': 215, 'B2': {'C1': 103, 'C2': 802817443438561586}},
{'B1': 199, 'B2': {'C1': 53, 'C2': 7679807635656097142}}],
{'A2': 102,
'A3': 0.6198772192001343,
'A4': 25,
'A5': {'D1': [-75, -108, -107, 11, -10, -68],
'D2': 4,
'D3': 41526,
'D4': {'E1': 1736811968882397280,
'E2': 10300346358263974455,
'E3': -24374},
'D5': 26027,
'D6': -125,
'D7': 64062,
'D8': [8426, -25844, 12068]},
'A6': [1921515367, -1366331901, 410652734, 966757514],
'A7': 135174661,
'A8': [0.7137316128934819, 0.5139593629250054]}
Пример 2
Двоичные данные:
b'KAN\x00\x00\x00\x03\x00\x00\x00<\xc8?kViO\x00M\x00\x04\x00\x00\x00'
(b'u\x85\xd3\xd0\xaf\x00\x03\x00\x85%z2\x11\x82$2\x88p\x02Dk\x1a\x00\xb3'
b'\x8f\xa6\xde\xaftK\xd9\x07w\x04\xf7\xc1\xaa\x00!\xa7\x00*r\x003#\x00\xdd'
b'\xba\xf0\xba\xbf\xf9:\xfc\x1cw\xc61\xa7s\x12Ld\xe3\x10v\x16\x14+qL'
b'Q\xd6\x0e\x1d\xe9\x17\xa0\xd9\x7f0\xf1C\xec\x00\x00\x00\x04\x00\x00\x00'
b'E\xb5\xc4\xc7\xf9\xa1>\x15\xdd\x15>\xa4\xeb\xdd\x94\x1c%\xbf\xe3D'
b'\xd6Y\x1d\xab\x8e?\xefHa\xeb`\x0f\x0e?\xe3\xd2"X\\\xc1J')
Результат разбора:
'A1': [{'B1': 170, 'B2': {'C1': 37, 'C2': 8805119472113453168}},
{'B1': 167, 'B2': {'C1': 2, 'C2': 4930062807401998046}},
{'B1': 114, 'B2': {'C1': -81, 'C2': 8380030157737752513}}],
{'A2': 200,
'A3': 0.9192872643470764,
'A4': 79,
'A5': {'D1': [58, -4, 28, 119, -58, 49],
'D2': 167,
'D3': 29458,
'D4': {'E1': 5504774304393729067,
'E2': 8163990204317559063,
'E3': -24359},
'D5': 32560,
'D6': -15,
'D7': 17388,
'D8': [8960, -8774, -3910, -16391]},
'A6': [-1245394951, -1589766691, 356426987, -577496027],
'A7': -2049716049,
'A8': [-0.6021529903931524, 0.9775857541248756, 0.6194011426760337]}
Задача №12
Реализовать разбор двоичного формата данных. Данные начинаются с сигнатуры 0x59 0x49 0x4a 0x44
, за которой следует структура
A. Порядок байт: от старшего к младшему. Адреса указаны в виде смещений от начала данных. В решении предлагается использовать модуль
struct.
Структура A:
Поле | Описание |
---|---|
1 | Структура B |
2 | float |
3 | Адрес (uint16) структуры D |
4 | int32 |
5 | Размер (uint16) и адрес (uint16) массива uint16 |
6 | int16 |
7 | int8 |
Структура B:
Поле | Описание |
---|---|
1 | uint32 |
2 | Размер (uint32) и адрес (uint16) массива char |
3 | int8 |
4 | Массив структур C, размер 4 |
5 | uint8 |
6 | uint8 |
7 | int16 |
8 | float |
Структура C:
Поле | Описание |
---|---|
1 | uint64 |
2 | Массив int16, размер 3 |
Структура D:
Поле | Описание |
---|---|
1 | int64 |
2 | int16 |
Ниже показаны примеры разбора двоичного формата.
Пример 1
Двоичные данные:
b'YIJD\xeb>Q&\x00\x00\x00\x03\x00`M\x90\xa0\x11\t\xf9s\xce\x9d\xd6\xd8h.\xa7'
(b']\x94U\xbb\xf5$\xc9\xc1\x1aU\xdebWI\r\xa3\x9f,/\x16\xf3\rAWR\x04\x0eb\xd5$MO'
b'J\xa2\xa0\x02<\xa5\x8d\xf5I\x9d\xe90U\x969\xbe~OQ?n\xba@\x00c\x8c8h'
b'\xc5\x00\x05\x00m\xd3\xdc\xb5vrb\x95\xfe\x9a\x06\xc8\xdf\x0c\xa1F'
b'\xc5i\xea\x9d\t\x8d\x9b|\xf2\xeeE')
Результат разбора:
'A1': {'B1': 3946729766,
{'B2': 'vrb',
'B3': 77,
'B4': [{'C1': 10421348272272821917, 'C2': [-10536, 26670, -22691]},
'C1': 10688655952192323866, 'C2': [21982, 25175, 18701]},
{'C1': 11790190930239360321, 'C2': [22354, 1038, 25301]},
{'C1': 2615834140546695740, 'C2': [-23155, -2743, -25111]}],
{'B5': 48,
'B6': 85,
'B7': -27079,
'B8': -0.24834944307804108},
'A2': 0.9325294494628906,
'A3': {'D1': -7638498564043240287, 'D2': 18117},
'A4': -1942460219,
'A5': [27114, 40201, 36251, 31986, 60997],
'A6': -11300,
'A7': -75}
Пример 2
Двоичные данные:
b'YIJD\x85\t\xf9\x8d\x00\x00\x00\x02\x00`\xda\xba\x87A\xca8<\x05\x1a\xcf'
(b'\xb8\xcfm\x1d\x15\xda\xc6v\xf3\xcdJ\x9c9`\x91\x97\x85D\xfc\x12\x07x\xe9r'
b'\xd8}\xc4\xa1\xf0D\x82\x829,\xa1\n, \xe8\xf9/\xbd\xef\x1fT\x0en\xde'
b'\x1e\x9aw\xbe\xfb\xd4c\xbfl0\x95\x00b\x18\x18An\x00\x05\x00l\xcc\xed\x07'
b'nc2\xa4\xbd6=P\x0b\xaf\xd4\x10\x95\xf7\xad\x8a\x90\x1f\xdfxi"')
Результат разбора:
'A1': {'B1': 2232023437,
{'B2': 'nc',
'B3': -38,
'B4': [{'C1': 13440783949693191450, 'C2': [-12360, -12435, 7445]},
'C1': 15764418335150349369, 'C2': [24721, -26747, 17660]},
{'C1': 1299139961569181124, 'C2': [-24080, 17538, -32199]},
{'C1': 3215862793566222639, 'C2': [-16913, 8020, 3694]}],
{'B5': 222,
'B6': 30,
'B7': -25993,
'B8': -0.4918547570705414},
'A2': -0.9226163029670715,
'A3': {'D1': 3649249638731484079, 'D2': -11248},
'A4': 404242798,
'A5': [38391, 44426, 36895, 57208, 26914],
'A6': -13075,
'A7': 7}
Задача №12
Реализовать разбор двоичного формата данных. Данные начинаются с сигнатуры 0x59 0x50 0x54
, за которой следует структура A.
Порядок байт: от старшего к младшему. Адреса указаны в виде смещений от начала данных. В решении предлагается использовать модуль
struct.
Структура A:
Поле | Описание |
---|---|
1 | Размер (uint16) и адрес (uint16) массива адресов (uint32) структур B |
2 | double |
3 | Структура C |
4 | uint8 |
Структура B:
Поле | Описание |
---|---|
1 | Размер (uint32) и адрес (uint16) массива char |
2 | uint16 |
Структура C:
Поле | Описание |
---|---|
1 | int64 |
2 | int64 |
3 | Адрес (uint32) структуры D |
Структура D:
Поле | Описание |
---|---|
1 | Размер (uint16) и адрес (uint32) массива uint32 |
2 | Размер (uint16) и адрес (uint16) массива uint32 |
Ниже показаны примеры разбора двоичного формата.
Пример 1
Двоичные данные:
b'YPT\x00\x02\x00<?\xd1\xf2\xe7Khg\xd8\xd0s*C\xb2|\xcb\xba\xa5YX\xcdm'
(b'T\x18\x89\x00\x00\x00lInrx\x00\x00\x00\x03\x00$B\x04mibhn\x00\x00\x00\x05'
b"\x00/\xbe3\x00\x00\x00'\x00\x00\x004I@\xf8\x1a;D\xbc\x84\xc4\xbdqB"
b'\x14a\r\x02\x08d\x90\x80\x07\xa3DA\xc6\xf9\\d\xbc\x89\x19\x828\x16\xe7\x13'
b'YD\x975\x00\x04\x00\x00\x00D\x00\x06\x00T')
Результат разбора:
'A1': [{'B1': 'nrx', 'B2': 16900}, {'B1': 'mibhn', 'B2': 48691}],
{'A2': 0.28045065273329106,
'A3': {'C1': -3426348421253116998,
'C2': -6532092145198425975,
'C3': {'D1': [1228994586, 994360452, 3300749634, 341904642],
'D2': [140808320,
128140353,
3338230884,
3163101570,
941025043,
1497667381]}},
'A4': 73}
Пример 2
Двоичные данные:
b'YPT\x00\x04\x00Q?\xe4\xfaD\x85\xb6!\xa2\\\x8a\x08I\x15F\xfe\x96\x81'
(b'AP\x8c\x8f\x04*\x1f\x00\x00\x00u\x82mepr\x00\x00\x00\x04\x00$\x82\x19'
b'ns\x00\x00\x00\x02\x000\xdeIzzgx\x00\x00\x00\x04\x00:gzjll\x00\x00\x00'
b'\x03\x00F0\xbf\x00\x00\x00(\x00\x00\x002\x00\x00\x00>\x00\x00\x00Ihk\x12'
b'\xfd\x0bJj\xec\xfb\xf6\xd6-\xfd\xf8\x16\xc2m\xdc\x94\xa7\x00\x02\x00'
b'\x00\x00a\x00\x03\x00i')
Результат разбора:
'A1': [{'B1': 'mepr', 'B2': 33305},
{'B1': 'ns', 'B2': 56905},
{'B1': 'zzgx', 'B2': 26490},
{'B1': 'jll', 'B2': 12479}],
{'A2': 0.6555502521087428,
'A3': {'C1': 6668151308258049686,
'C2': -9132930004705596897,
'C3': {'D1': [1751847677, 189426412],
'D2': [4227257901, 4260894402, 1843172519]}},
'A4': 130}
Задача №12
Реализовать разбор двоичного формата данных. Данные начинаются с сигнатуры 0x11 0x52 0x47 0x59
, за которой следует структура
A. Порядок байт: от младшего к старшему. Адреса указаны в виде смещений от начала данных. В решении предлагается использовать модуль
struct.
Структура A:
Поле | Описание |
---|---|
1 | Размер (uint16) и адрес (uint32) массива структур B |
2 | int8 |
3 | uint32 |
4 | Адрес (uint32) структуры C |
5 | int16 |
6 | int16 |
7 | uint32 |
Структура B:
Поле | Описание |
---|---|
1 | int32 |
2 | int8 |
3 | int32 |
Структура C:
Поле | Описание |
---|---|
1 | Структура D |
2 | Размер (uint16) и адрес (uint32) массива int16 |
3 | int16 |
4 | int16 |
5 | uint16 |
6 | uint16 |
7 | Массив int32, размер 8 |
Структура D:
Поле | Описание |
---|---|
1 | Массив double, размер 3 |
2 | uint32 |
3 | uint8 |
4 | int32 |
Ниже показаны примеры разбора двоичного формата.
Пример 1
Двоичные данные:
b'\x11RGY\x04\x00\x1b\x00\x00\x001\\\xbe\x15\xeeE\x00\x00\x00\xa5\x06Vy('
(b"\x8bY\xca\x04\x10\xdd\x05'\x0f\xbc\xad\xc2*p?pW\xf4\x1c~Q\xac\xde8\xc8w>\x90"
b'7t\xc2\xec\xc0TBM=\xf7\xeb\x16\x8f\xbe\xe1\x1c>\xd0w\xba\xbf?\x9b\xe4'
b"?\xb6\xc1A\xef\xb3'\xee?\xb0\xdb\x02\xf7\x15]\xdc?\xc9Y/.\xa5):{\xcf\x03\x00"
b'?\x00\x00\x00\xae\xd4\xa4\x99\x06\x97\xb2\x02\xaf\x89\xc6U\xcc\xd4\xd9^'
b'\xcf\xa8C\x82\xd9\xca\xfc\xd1\xf3P\xecag\xae\x823\xe7\xe1jx\xd8\xa0\xe6,')
Результат разбора:
'A1': [{'B1': 98373636, 'B2': 39, 'B3': -1028801521},
{'B1': 1883205674, 'B2': 87, 'B3': 1367219444},
{'B1': -935797076, 'B2': 119, 'B3': 1949798462},
{'B1': 1421929666, 'B2': 66, 'B3': -336118451}],
{'A2': 49,
'A3': 3994402396,
'A4': {'C1': {'D1': [0.6439512963004237,
0.9423465416894519,
0.44318150636848497],
'D2': 774855113,
'D3': 165,
'D4': -814007767},
'C2': [-28906, -7746, 15900],
'C3': -11090,
'C4': -26204,
'C5': 38662,
'C6': 690,
'C7': [1439074735,
1591334092,
-2109495089,
-771962151,
1642877171,
864202343,
2020270567,
753311960]},
'A5': 1701,
'A6': 31062,
'A7': 3394865960}
Пример 2
Двоичные данные:
b'\x11RGY\x03\x00\x1b\x00\x00\x00\x0eg\xe7#\xe1:\x00\x00\x00\x9e4\xd6\x08\xd7'
(b'F e\xf8\xc7\xf3\x11\xe5\x85\xe7\xc6GAi\x05g\x85\t\xber\xd5M\x081'
b'\xfb\xcf\xc9\\_\xa2G0\xb0.\x92\x8f\xe4\xf4\xa7Z\xec\xbf\xe0\xd2[\x80*\xd1'
b'\xbb\xbf\xda\x16L b\xf4\xed\xbf\xef\xc3e[\xb3\xab\x95\xc9t\x02\x006\x00\x00'
b'\x00\xff\xee)\xbe\xe9\xa2\xeb0J\xac\x88\xfa\x19\xdc:R\x19\xa4\xbd'
b'\xc2:\x92\xe6\xdc\x97\x06(\x01\xe0U\xd0tU\xe68\x85\x81GG\xd6')
Результат разбора:
'A1': [{'B1': 301189112, 'B2': -27, 'B3': 1204217733},
{'B1': 1728407873, 'B2': -123, 'B3': -713900535},
{'B1': -80672691, 'B2': -49, 'B3': -1570808631}],
{'A2': 14,
'A3': 3777226599,
'A4': {'C1': {'D1': [-0.8860664160788352,
-0.10866037019497865,
-0.9360819464497709],
'D2': 1533395951,
'D3': 179,
'D4': 1959368107},
'C2': [12359, 11952],
'C3': -4353,
'C4': -16855,
'C5': 41705,
'C6': 12523,
'C7': [-91706294,
1379589145,
-1027759079,
-588869062,
19400343,
1959810528,
-2059868587,
-699971711]},
'A5': 13470,
'A6': 2262,
'A7': 1696614103}
Задача №12
Реализовать разбор двоичного формата данных. Данные начинаются с сигнатуры 0xca 0x43 0x49 0x41 0x53
, за которой следует
структура A. Порядок байт: от младшего к старшему. Адреса указаны в виде смещений от начала данных. В решении предлагается использовать
модуль struct.
Структура A:
Поле | Описание |
---|---|
1 | Массив char, размер 7 |
2 | uint32 |
3 | Структура B |
4 | Структура E |
5 | Структура F |
6 | uint64 |
Структура B:
Поле | Описание |
---|---|
1 | double |
2 | Адрес (uint32) структуры C |
3 | Размер (uint32) и адрес (uint32) массива структур D |
4 | double |
Структура C:
Поле | Описание |
---|---|
1 | uint64 |
2 | int8 |
3 | uint16 |
4 | int32 |
5 | uint8 |
6 | uint8 |
Структура D:
Поле | Описание |
---|---|
1 | int16 |
2 | Размер (uint16) и адрес (uint16) массива uint8 |
3 | int32 |
Структура E:
Поле | Описание |
---|---|
1 | uint32 |
2 | uint8 |
Структура F:
Поле | Описание |
---|---|
1 | Массив int8, размер 2 |
2 | uint16 |
3 | int32 |
4 | float |
Ниже показаны примеры разбора двоичного формата.
Пример 1
Двоичные данные:
b'\xcaCIASypfhwqo\xd4i\x8fi\xe8\x10y\x8dg\x01\xde\xbfE\x00\x00\x00'
(b'\x05\x00\x00\x00t\x00\x00\x00\xd0\x13\xe2*@\x98\xca?\xf0\xf1I\xd8'
b'\x86\xd9\xc0\x1a2*\x80\x0c\xe1\xc2\xa7k\xbf\xfd\x99,\xf63\xd1\x83\xaa<\xea2'
b'\xd6\xe7Wq\xe8\xb9\xb2*b-\xd0z\xe3\xcaPe\x8c\xf8\xea\xa8\x14\xbc\rf'
b'\xd4\xb5\x85~\x8b\x1cXo"ll\x99?\x8c\x10 l4[B\xb5"\x05\x00V\x00K\xd9'
b'\x07\x95A\x9b\x06\x00[\x00\xb9\xc5\xcb\x1f\xf3\xe1\x07\x00a\x00\x89\x9f'
b"T$\xd6\xfd\x06\x00h\x00\x1d\x1b\x92_b'\x06\x00n\x00R\xab\x83\xbe")
Результат разбора:
'A1': 'ypfhwqo',
{'A2': 1771006420,
'A3': {'B1': -0.46883572402681617,
'B2': {'C1': 16749265142410308156,
'C2': -71,
'C3': 10930,
'C4': 2060463458,
'C5': 227,
'C6': 202},
'B3': [{'D1': 8885, 'D2': [80, 101, 140, 248, 234], 'D3': -1794647733},
'D1': -25791,
{'D2': [168, 20, 188, 13, 102, 212],
'D3': 533448121},
'D1': -7693,
{'D2': [181, 133, 126, 139, 28, 88, 111],
'D3': 609525641},
'D1': -554,
{'D2': [34, 108, 108, 153, 63, 140],
'D3': 1603410717},
'D1': 10082,
{'D2': [16, 32, 108, 52, 91, 66],
'D3': -1098667182}],
'B4': 0.2077713212385377},
'A4': {'E1': 3628724720, 'E2': 134},
'A5': {'F1': [-39, -64],
'F2': 12826,
'F3': -519274454,
'F4': -0.9205285310745239},
'A6': 12286894229500500477}
Пример 2
Двоичные данные:
b'\xcaCIASimskmmv\xaaM\xc2\x1a`JO`\x94\xd3\xed?E\x00\x00\x00\x04\x00\x00\x00'
(b"e\x00\x00\x00 a'*\x945\xa5?g\t=\x08\x84Sm\xcdA\xde\x98--\x86\xaa\xf1"
b">\xef\x05\x9f\xcca\x8b\xd3g\xc7i'\x9d\rz\x93\xeb\xb3F\x00\xe7J\x1a\x8b"
b'\x81A\xfb\xb0\xe1\x0b\x9b !\x88\x8d<jO\xe9\xc0\xd7f\x9a\x02\x00V\x00\xd7'
b'bK\x16\xc8\xfb\x05\x00X\x00\xba\xe1emF\xf3\x02\x00]\x00\xe4\x9d\x18\x88P'
b'^\x06\x00_\x00\xdeT\xb7\xdf')
Результат разбора:
'A1': 'imskmmv',
{'A2': 448941482,
'A3': {'B1': 0.9320775872277629,
'B2': {'C1': 16975045619379300807,
'C2': -77,
'C3': 70,
'C4': -1961211161,
'C5': 129,
'C6': 65},
'B3': [{'D1': -26010, 'D2': [251, 176], 'D3': 374039255},
'D1': -1080, 'D2': [225, 11, 155, 32, 33], 'D3': 1835393466},
{'D1': -3258, 'D2': [136, 141], 'D3': -2011652636},
{'D1': 24144,
{'D2': [60, 106, 79, 233, 192, 215],
'D3': -541633314}],
'B4': 0.04142439856122082},
'A4': {'E1': 138217831, 'E2': 132},
'A5': {'F1': [83, 109],
'F2': 16845,
'F3': 757962974,
'F4': 0.47200411558151245},
'A6': 7481476658153588207}
Задача №12
Реализовать разбор двоичного формата данных. Данные начинаются с сигнатуры 0x4a 0x57 0x59 0xb8
, за которой следует структура
A. Порядок байт: от младшего к старшему. Адреса указаны в виде смещений от начала данных. В решении предлагается использовать модуль
struct.
Структура A:
Поле | Описание |
---|---|
1 | Массив char, размер 5 |
2 | Адрес (uint16) структуры B |
3 | uint8 |
4 | int32 |
5 | uint64 |
6 | float |
Структура B:
Поле | Описание |
---|---|
1 | Массив структур C, размер 2 |
2 | Массив float, размер 4 |
3 | Структура D |
Структура C:
Поле | Описание |
---|---|
1 | int32 |
2 | int16 |
3 | uint8 |
4 | uint64 |
5 | int8 |
Структура D:
Поле | Описание |
---|---|
1 | Размер (uint32) и адрес (uint32) массива int64 |
2 | uint32 |
3 | int16 |
4 | int16 |
Ниже показаны примеры разбора двоичного формата.
Пример 1
Двоичные данные:
b'JWY\xb8dxmteD\x00\x08\x9b\xa7\t\xf2\xe4\xab\x08\xb38\x80\x03hr\xc2[\xbf'
(b'\xf1#}\x1a1@\xb0W\xc0\x08\x04\x1d\xfc\xde\xc19 8\xe9d\x9e\xb0,4_\xa0 \x7f'
b"\xf1\xf6\x9f\x89\x1b?\x12\x10$!W\x8aF\xc8\x00\xc6SY\xb0\xcf\x7f\xff\x8a'"
b'\\\x05E\xce\x88\\<\xcd\xe9$\x1b\xe086]\xb0n\x0b\x7f\x86!t\x1c?\x04L\x05?'
b'#R\x07\xbf\x1c\\\x88>\x05\x00\x00\x00\x1c\x00\x00\x004\xba\xe5q'
b'\xcb\xf4\xf3\xf8')
Результат разбора:
'A1': 'dxmte',
{'A2': {'B1': [{'C1': -973027258,
'C2': 22867,
'C3': 176,
'C4': 4973482688406061007,
'C5': -50},
'C1': -851682168,
{'C2': 9449,
'C3': 27,
'C4': 9154532371317799136,
'C5': -122}],
'B2': [0.6111469864845276,
0.5206911563873291,
-0.5285970568656921,
0.26632773876190186],
'B3': {'D1': [6318620856842789873,
4161852705066977472,
3759573983291848736,
-8529827652136034209,
-8478271334729498853],
'D2': 1910880820,
'D3': -2869,
'D4': -1805}},
'A3': 8,
'A4': -234248293,
'A5': 7494975185884851172,
'A6': -0.8584357500076294}
Пример 2
Двоичные данные:
b'JWY\xb8nermz<\x00\xce}Ogn?\xf5\\\x14\x8d|\x7f!\xe1\xc1\r?\x8d\xb2C-'
(b'\xf4\x06\x91\x10e\xb1\xa6x#\xaa \x84-\x12\xfa\xb6\x8f6/}<*\x9b\xaduz\xc3)'
b'\xc0,\x1d\xc5\x1c|_L&\xe3j}\xf0^>\x11\xbb\x8a?B\xa8\x1c\x1br\xb4\x0f\xa3\xbd'
b'\xa7\x12X\x88\x0b\xc4Y?cm%?\x99\x03\xd2>\xccQ\t>\x04\x00\x00\x00'
b'\x1c\x00\x00\x00\xbf\xa5\t\xfb\x85\xd6\xb0!')
Результат разбора:
'A1': 'nermz',
{'A2': {'B1': [{'C1': -987943744,
'C2': 31772,
'C3': 95,
'C4': 4494293899617183308,
'C5': 17},
'C1': 1111460539,
{'C2': 7336,
'C3': 27,
'C4': 6346319257844823154,
'C5': -120}],
'B2': [0.8506476283073425,
0.6462003588676453,
0.41018369793891907,
0.13410109281539917],
'B3': {'D1': [1193743022031090317,
-8925947392123555483,
9020488569524458029,
3009383621856012860],
'D2': 4211713471,
'D3': -10619,
'D4': 8624}},
'A3': 206,
'A4': 1852264317,
'A5': 2413784870667744575,
'A6': 0.553739607334137}
Задача №12
Реализовать разбор двоичного формата данных. Данные начинаются с сигнатуры 0x1d 0x52 0x41 0x45
, за которой следует структура
A. Порядок байт: от младшего к старшему. Адреса указаны в виде смещений от начала данных. В решении предлагается использовать модуль
struct.
Структура A:
Поле | Описание |
---|---|
1 | Размер (uint16) и адрес (uint32) массива адресов (uint32) структур B |
2 | Адрес (uint16) структуры C |
3 | Массив uint16, размер 4 |
4 | int16 |
5 | uint8 |
Структура B:
Поле | Описание |
---|---|
1 | int32 |
2 | int64 |
3 | uint8 |
4 | uint16 |
Структура C:
Поле | Описание |
---|---|
1 | Массив char, размер 2 |
2 | Структура D |
Структура D:
Поле | Описание |
---|---|
1 | int64 |
2 | double |
3 | Размер (uint16) и адрес (uint32) массива int8 |
4 | Размер (uint32) и адрес (uint32) массива int16 |
5 | uint64 |
Ниже показаны примеры разбора двоичного формата.
Пример 1
Двоичные данные:
b'\x1dRAE\x04\x00S\x00\x00\x00p\x00A2\x02J\xcf\xb8\xc6\xaf\xf2\n{\xb9'
(b']_\x1b\xfa\xdc"\xdf\x8bo\xbbT\xa1\x1d]\x18T:Z\x80KF\xd7\x83w\xa2\xaan\x0f'
b'\xb5\xedI\xf1\xdf\x9c\x86\xa3d\xf1f\x81=\x08\xbf\xc3\xb31\x86\r\xc2L\x08\xa3'
b'\xffpFRa\x8c\xdd\x17\x00\x00\x00&\x00\x00\x005\x00\x00\x00D\x00\x00\x00J'
b'\x00\xc3\x11H>]\xb2b\x82;\x0b\xfaxj\x14\x9cT\x1a\x7f\xcc\xea\x95\xd0x'
b'\x1bD_\x1b\xca\xbf\x05\x00c\x00\x00\x00\x04\x00\x00\x00h\x00\x00\x00'
b'{\x97\xf3}\x0f\xcc\x0f\xe5')
Результат разбора:
'A1': [{'B1': 459234745, 'B2': 6105596366365580538, 'B3': 161, 'B4': 23837},
{'B1': 1513772056, 'B2': -6151222732898546816, 'B3': 110, 'B4': 46351},
{'B1': -537835027, 'B2': 4431936695270868636, 'B3': 8, 'B4': 50111},
{'B1': 226898355, 'B2': 5928550202734038210, 'B3': 97, 'B4': 56716}],
{'A2': {'C1': 'xj',
'C2': {'D1': -7644072571233330156,
'D2': -0.203960331206821,
'D3': [74, 0, -61, 17, 72],
'D4': [23870, 25266, 15234, -1525],
'D5': 16505635526245848955}},
'A3': [12865, 18946, 47311, 44998],
'A4': 2802,
'A5': 123}
Пример 2
Двоичные данные:
b"\x1dRAE\x04\x00S\x00\x00\x00l\x00p\x81\xe1\x13\xe9\xb8\xab(\xf7\x9e['Mh\x96s"
(b'\xc1wE6\xad\x02T\x1bv\xbd\x9f\t\x96\xa6\x19jP\xbb\xad\xcc\xfa;%\t'
b'x\x01\x8a\x8f\x87\xadE\xa8U#\x85\xbct=\x9e\xad\xf2\xd8a\xd1\x901#\x1e'
b'\x86\xc48\xb2o\xe5\xb0\x17\x00\x00\x00&\x00\x00\x005\x00\x00\x00D'
b'\x00\x00\x00o\xbe\xcf\x1a\xc0\x00\xb1\xad\xb8lvj\x13\x1d\x9e5\xe0'
b'\x9a^\xbc\xe1K\xa1\x010\xdb\xbf\x03\x00c\x00\x00\x00\x03\x00\x00\x00'
b"f\x00\x00\x00'\x14j^L\x05m\x9b")
Результат разбора:
'A1': [{'B1': -1771549401, 'B2': 6053591297744683379, 'B3': 27, 'B4': 48502},
{'B1': -1500116577, 'B2': 4321991838959430169, 'B3': 37, 'B4': 30729},
{'B1': -2020636159, 'B2': 8411744590828684717, 'B3': 61, 'B4': 44446},
{'B1': -782116622, 'B2': -5604513655952297584, 'B3': 111, 'B4': 45285}],
{'A2': {'C1': 'lv',
'C2': {'D1': 6817007506869261162,
'D2': -0.4248050761375699,
'D3': [111, -66, -49],
'D4': [-16358, -20224, -18259],
'D5': 11199613673899955239}},
'A3': [33136, 5089, 47337, 10411],
'A4': -24841,
'A5': 91}
Задача №12
Реализовать разбор двоичного формата данных. Данные начинаются с сигнатуры 0x4b 0x49 0x5a 0x54
, за которой следует структура
A. Порядок байт: от старшего к младшему. Адреса указаны в виде смещений от начала данных. В решении предлагается использовать модуль
struct.
Структура A:
Поле | Описание |
---|---|
1 | uint64 |
2 | Размер (uint16) и адрес (uint32) массива char |
3 | double |
4 | uint16 |
5 | Адрес (uint16) структуры B |
Структура B:
Поле | Описание |
---|---|
1 | Массив адресов (uint16) структур C, размер 3 |
2 | Размер (uint32) и адрес (uint32) массива int32 |
3 | Массив uint8, размер 2 |
4 | uint64 |
5 | int16 |
6 | int32 |
7 | Структура D |
8 | float |
Структура C:
Поле | Описание |
---|---|
1 | int8 |
2 | uint8 |
Структура D:
Поле | Описание |
---|---|
1 | uint16 |
2 | uint8 |
3 | uint16 |
4 | float |
5 | double |
Ниже показаны примеры разбора двоичного формата.
Пример 1
Двоичные данные:
b'KIZT\xf1T\r\xb7\x13D\xecq\x00\x03\x00\x00\x00\x1e?\xe4\x17\xe66\xd8+>Y\xab'
(b'\x00/lknqN\x80sj\x14Q\xe6\x05w\xb4><.\x00!\x00#\x00%\x00\x00\x00'
b"\x02\x00\x00\x00'`\xe4\x93\xcd\xda,\x96\xfb\xeb\n\xd9\x83\xb2y\xceH\x98\x1d<"
b'\xe2\xbe?u\xe8\xba\xbf\xe6\xad"\xb0\xfc9z>\x00\xcf\x93')
Результат разбора:
'A1': 17389539141137788017,
{'A2': 'lkn',
'A3': 0.6279173918895606,
'A4': 22955,
'A5': {'B1': [{'C1': 113, 'C2': 78},
'C1': -128, 'C2': 115},
{'C1': 106, 'C2': 20}],
{'B2': [1374029175, -1270989778],
'B3': [96, 228],
'B4': 10650408578847599370,
'B5': -9853,
'B6': -1300640184,
'B7': {'D1': 38941,
'D2': 60,
'D3': 58046,
'D4': 0.9605823755264282,
'D5': -0.7086347061866001},
'B8': 0.12579183280467987}}
Пример 2
Двоичные данные:
b'KIZTV\xb4\xf7\xfd\xb7\xcdC@\x00\x02\x00\x00\x00\x1e\xbf\xa36m\xa0\xb2'
(b'-\xe0k\x19\x00.imt\x8e\x0f\xa6\xf1U\x85\xd9\x069&\x9b\xc56\x00 \x00"\x00$'
b'\x00\x00\x00\x02\x00\x00\x00&\xba\xf8O\x08\xcf\xd3\x0743\x02\x9b\xae'
b'\xba\xc8\x16\x02\xa8\xf1\x83\xaa\x8a\xbe\xa47\xf9\xbf\xbft\x152C*0=\xd9\x84'
b'B')
Результат разбора:
'A1': 6247891252152189760,
{'A2': 'im',
'A3': -0.03752462946530577,
'A4': 27417,
'A5': {'B1': [{'C1': 116, 'C2': 142},
'C1': 15, 'C2': 166},
{'C1': -15, 'C2': 85}],
{'B2': [-2049374663, 647742774],
'B3': [186, 248],
'B4': 5695030234075902722,
'B5': -25682,
'B6': -1161292286,
'B7': {'D1': 43249,
'D2': 131,
'D3': 43658,
'D4': -0.3207395374774933,
'D5': -0.12286503293140849},
'B8': 0.10620929300785065}}
Задача №12
Реализовать разбор двоичного формата данных. Данные начинаются с сигнатуры 0x41 0x55 0x57 0x44
, за которой следует структура
A. Порядок байт: от младшего к старшему. Адреса указаны в виде смещений от начала данных. В решении предлагается использовать модуль
struct.
Структура A:
Поле | Описание |
---|---|
1 | Структура B |
2 | uint16 |
3 | int8 |
4 | int8 |
Структура B:
Поле | Описание |
---|---|
1 | Структура C |
2 | int8 |
Структура C:
Поле | Описание |
---|---|
1 | Массив адресов (uint32) структур D, размер 3 |
2 | Массив int8, размер 3 |
3 | int64 |
4 | Размер (uint16) и адрес (uint32) массива int32 |
5 | float |
Структура D:
Поле | Описание |
---|---|
1 | uint8 |
2 | Массив float, размер 2 |
3 | int8 |
4 | Массив int64, размер 3 |
5 | int16 |
Ниже показаны примеры разбора двоичного формата.
Пример 1
Двоичные данные:
b'AUWD*\x00\x00\x00N\x00\x00\x00r\x00\x00\x008\xf2\xd9d$|g\xe7J<\xb2\x06'
(b'\x00\x96\x00\x00\x00\x10N\x8b>\xbc\x97\x87\xef\xdc`\x85\xa8\x10?\xbc'
b'\xda\x92\xbe4\xa8\xa9G.\x11\x94\x8c\x8f\x92v\x91\xdcG\xaa\x96M\xb5\x16\\\xa1'
b'\x92=\x13Q]\xa8\x15\x91\xc5\x83\xbd\xde\xda\xf3>\xaew\xa7Q?\x85#\xef;'
b'\xb9\t\xe0\xb0\xec3Z;P\x15MN\x83\xc5\xae\x89\xc9\x06\xa5p\x1b\xa9=l\xa6L?N'
b'7\xe8j\xdb$Y\xe2?\x1a\xbcg\xb0\x94\xc1\x88\x032q\x8c\x1fG\xe4\x97\xfa'
b'\x947\rO\x0e\x8e\xed\x00a\x8aDu\xc0\x80E\x1e\xee\xb5Dn\xf2\x8c\xca\x9e'
b'\xab\xe6')
Результат разбора:
'A1': {'B1': {'C1': [{'D1': 96,
{'D2': [0.5650714039802551, -0.2868250608444214],
'D3': 52,
'D4': [-8102938828034561624,
5590843213046970002,
5842080841611351733],
'D5': -22435},
'D1': 21,
{'D2': [-0.06434167176485062, 0.47627919912338257],
'D3': -82,
'D4': [4318709622871533431,
4276787887814478265,
-8525659876820708016],
'D5': 1737},
'D1': 165,
{'D2': [0.08257186412811279, 0.7994143962860107],
'D3': 78,
'D4': [4603339783960979511,
254666223305341978,
-389591848621149902],
'D5': 14228}],
'C2': [56, -14, -39],
'C3': -5603521478621649820,
'C4': [-1911664883,
-1973354259,
-2134870716,
-1242685883,
-1930269116,
-424960310],
'C5': 0.2720799446105957},
'B2': -68},
'A2': 34711,
'A3': -17,
'A4': -36}
Пример 2
Двоичные данные:
b'AUWD*\x00\x00\x00N\x00\x00\x00r\x00\x00\x00@\xef\xc7\xd3F|\x1b\x07'
(b'w\xa7\xcc\x06\x00\x96\x00\x00\x00B\xdd\xb8>\xd59&s\xdf\xc6\x85\x16\xe2\xbd4'
b'\x17\x1f\xbfZ\xf0(\xdc4\x01\xd6\xc0#\xf0\x8dh\xae\xfai\xb36\xa2R\xe8\x85'
b'\xdaV\xaf\x1aI\x90o0K-\xbf\x15\x84T?F\x95\xeb!\xa9\xfaho\xaa\xbc\x0e\xca\x91'
b'z^Kr\xb2\xc6\xccq>:[\xca\xcb\x1f\xeal\x17\x9c\xbe\xb7)P>\xc3q\xad[-'
b'\xe4cL\xf2\xf3\x9cU\x87M\x13-\x1d$H\x8f\n\xb3*[\xc3L\xf6\x16\xa7'
b'\xbb\x1a]\xaf\xf0\x06\xe8\x0c\x95T\xc2Ef\x83]`\x81-\xec@$S')
Результат разбора:
'A1': {'B1': {'C1': [{'D1': 198,
{'D2': [-0.11039451509714127, -0.6214478015899658],
'D3': 90,
'D4': [2576294287526078704,
3941610624268144112,
1922851062459945634],
'D5': -28599},
'D1': 111,
{'D2': [-0.6769285202026367, 0.8301404118537903],
'D3': 70,
'D4': [-6165593939058234475,
8235780224102043324,
-3865431815295809870],
'D5': 8139},
'D1': 234,
{'D2': [-0.3048661947250366, 0.2032841295003891],
'D3': -61,
'D4': [-987304386636305039,
2102357824755834099,
-4369852064968259548],
'D5': -2484}],
'C2': [64, -17, -57],
'C3': -3699857696451967277,
'C4': [448505622,
116436829,
1419054312,
-2090449470,
763453533,
1394884844],
'C5': 0.36106306314468384},
'B2': -43},
'A2': 9785,
'A3': 115,
'A4': -33}
Задача №12
Реализовать разбор двоичного формата данных. Данные начинаются с сигнатуры 0x48 0x4b 0x58 0x42 0x17
, за которой следует
структура A. Порядок байт: от младшего к старшему. Адреса указаны в виде смещений от начала данных. В решении предлагается использовать
модуль struct.
Структура A:
Поле | Описание |
---|---|
1 | uint8 |
2 | uint64 |
3 | Массив структур B, размер 2 |
4 | Адрес (uint32) структуры D |
5 | float |
6 | int32 |
Структура B:
Поле | Описание |
---|---|
1 | int16 |
2 | double |
3 | float |
4 | float |
5 | Адрес (uint16) структуры C |
6 | int32 |
7 | Размер (uint32) и адрес (uint16) массива uint32 |
Структура C:
Поле | Описание |
---|---|
1 | Размер (uint16) и адрес (uint32) массива int16 |
2 | double |
Структура D:
Поле | Описание |
---|---|
1 | int16 |
2 | uint64 |
3 | int32 |
4 | float |
5 | Размер (uint32) и адрес (uint16) массива int32 |
6 | uint8 |
7 | float |
8 | uint8 |
Ниже показаны примеры разбора двоичного формата.
Пример 1
Двоичные данные:
b"HKXB\x17e'\x05wf\x15\xa2=m\xfb\x94\x10\xae\x7f \x1a\xed\xe2\xbf\xf7\xe3 >"
(b'\x92\xfdw\xbf\\\x00\x19\x1d\xfc\x04\x02\x00\x00\x00j\x00_c`\x7f'
b'\xc2\xa5\x8c\xc7\xde?+\xb0\xc8\xbe\x03\xbd\x11?x\x00k\xfd\xe6\x7f'
b'\x02\x00\x00\x00\x86\x00\x96\x00\x00\x00\x08\x99\x05=\x1eX\xa9\x05aC^v>\xa1'
b'\x03\x00V\x00\x00\x00\x08\xe5<Q~h\xcc\xbf\x10~\x8e\xf9\xd2\x0e\x9b_fY'
b'\x8a\x8b\xea\x1d\x03\x00r\x00\x00\x00\x1a\xafq\xd5\x0e3\xe0\xbf\x87\\'
b"\x97\xa3X\x9b\x81\xbe\xc5\xb9\xbe\x1d\xf0\xc5|\xc3'\x80,\x00\x95\xe6"
b'\x9e\x13\xc1\x0f1l\xfa\x84\xb8\xb8\xa8>\x02\x00\x00\x00\x8e\x00\xe4\xd4'
b'\x0c\x1d\xbe\xf6')
Результат разбора:
'A1': 101,
{'A2': 7871625936510584103,
'A3': [{'B1': -27397,
'B2': -0.5914431223622518,
'B3': 0.15711961686611176,
'B4': -0.9687129259109497,
'B5': {'C1': [17249, 30302, -24258], 'C2': -0.2219388863248144},
'B6': 83631385,
'B7': [4186865168, 1603997394]},
'B1': 25439,
{'B2': 0.480929529070627,
'B3': -0.39196905493736267,
'B4': 0.5692903399467468,
'B5': {'C1': [22886, -29814, 7658], 'C2': -0.5062326592282915},
'B6': 2145844587,
'B7': [2744605831, 3196164952]}],
'A4': {'D1': -32729,
'D2': 1135210154268360748,
'D3': -2063963087,
'D4': 0.32953429222106934,
'D5': [499038661, -1015233040],
'D6': 228,
'D7': -0.1533692479133606,
'D8': 246},
'A5': 0.032616645097732544,
'A6': 94984222}
Пример 2
Двоичные данные:
b'HKXB\x17XZW\x0b\xeaf\x98\xff\x15dj\xb0M\xcb>\xabl\xb7\xbfE\x8f\xb1>U\r??'
(b'Z\x00\x06\xe8\xd2\x98\x02\x00\x00\x00h\x00I8(Y\xc7rA\xd4\xd2?9\xfdu\xbf\xaaU'
b'\xde\xbev\x00\x1eX\xd4!\x02\x00\x00\x00\x84\x00\x94\x00\x00\x00+\x987\xbfkL'
b'c\xb30\x9d\x8b\x97\x02\x00V\x00\x00\x00\xac\xf3\xfc$-4\xd9?\xf9c8\xde'
b'\xd0\xce\x8b\xea\xdd#&\xb2\x95\x99\x03\x00p\x00\x00\x00\xa8\x0f\x17Q'
b'@\x81\xdc?\xe8\x0f<x~Zs\x14H!d\x11\xf8[&\xbf7\xc04\x8d\xe1\xd7\xe8\xc9'
b'\x01\xef\xda\xa6\x17\xc7\xbb@\xb4>\x02\x00\x00\x00\x8c\x00\xec\xf0,<?\x8f')
Результат разбора:
'A1': 88,
{'A2': 1585153161638401882,
'A3': [{'B1': 27236,
'B2': -0.09150190623340992,
'B3': 0.3467961847782135,
'B4': 0.7462971806526184,
'B5': {'C1': [-25296, -26741], 'C2': 0.3938095914089057},
'B6': -1731008506,
'B7': [3728237561, 3935030992]},
'B1': 14409,
{'B2': 0.2942050572286399,
'B3': -0.9608951210975647,
'B4': -0.43424731492996216,
'B5': {'C1': [9181, -19930, -26219], 'C2': 0.44538886946633705},
'B6': 567564318,
'B7': [2017202152, 343104126]}],
'A4': {'D1': -16329,
'D2': 17222268451932966196,
'D3': -954751270,
'D4': 0.3520563542842865,
'D5': [291774792, -1088005128],
'D6': 236,
'D7': 0.7350606918334961,
'D8': 143},
'A5': -0.7171656489372253,
'A6': -1285338005}
Задача №12
Реализовать разбор двоичного формата данных. Данные начинаются с сигнатуры 0x56 0x4a 0x58
, за которой следует структура A.
Порядок байт: от младшего к старшему. Адреса указаны в виде смещений от начала данных. В решении предлагается использовать модуль
struct.
Структура A:
Поле | Описание |
---|---|
1 | Размер (uint32) и адрес (uint32) массива адресов (uint32) структур B |
2 | double |
3 | Адрес (uint32) структуры C |
4 | Размер (uint16) и адрес (uint32) массива char |
5 | float |
6 | int32 |
7 | int64 |
8 | Адрес (uint16) структуры D |
Структура B:
Поле | Описание |
---|---|
1 | int64 |
2 | int32 |
Структура C:
Поле | Описание |
---|---|
1 | uint64 |
2 | Размер (uint32) и адрес (uint16) массива char |
3 | int16 |
4 | uint8 |
5 | double |
Структура D:
Поле | Описание |
---|---|
1 | Массив int16, размер 6 |
2 | uint8 |
3 | int16 |
4 | uint8 |
5 | uint32 |
6 | float |
7 | int8 |
Ниже показаны примеры разбора двоичного формата.
Пример 1
Двоичные данные:
b'VJX\x02\x00\x00\x00G\x00\x00\x00\xf0E\xf5{\x9dj\xbf\xbfR\x00\x00\x00\x02'
(b'\x00k\x00\x00\x00\xb2\xa4\xf6\xbe\x0f\x7f\xaa>Q& \x83\x11\xa5Ewm\x00\x11'
b'A\xf2k\xe0\x13w\xb5\x8fV!\xef3\xe9D#T\xfc\x80\x1bcl\xb2\xab/\x00\x00\x00;'
b'\x00\x00\x00fsf\xfek\\\x01B&;^\x03\x00\x00\x00O\x00\xbd\xaa\xc9\x10'
b'@\xa8[\xfc\x8b\xea?lt\xc3\xadd\xe9~P\xe8\xa9\x9bd\xfe|^\xf0\xf0U\xfe\x07\xfd'
b'G\xd4\x89g?P')
Результат разбора:
'A1': [{'B1': -5370802176011386607, 'B2': -283027825},
{'B1': 1981861274342189363, 'B2': -1414370205}],
{'A2': -0.12272056843109858,
'A3': {'C1': 6790062928123685886,
'C2': 'fsf',
'C3': -21827,
'C4': 201,
'C5': 0.8295881071262574},
'A4': 'lt',
'A5': -0.48172527551651,
'A6': 1051361039,
'A7': 8594456958539408977,
'A8': {'D1': [-21053, -5788, 20606, -22040, 25755, 31998],
'D2': 94,
'D3': -3856,
'D4': 85,
'D5': 1207764990,
'D6': 0.9044468402862549,
'D7': 80}}
Пример 2
Двоичные данные:
b"VJX\x02\x00\x00\x00G\x00\x00\x00\xb09\xfav\xed'\xc6?S\x00\x00\x00\x05"
(b'\x00l\x00\x00\x00\xe91\xd1\xbeS\xfa\xa3\x05\xb3\xf0M\xc1\xd4y\xcbIq\x00\\'
b'B\n\x08CEq\xaf\xc6}\xae\x04\xb3\x1c\x1ci\xe6 \x1b\xeaN\xb9\x0bv/'
b'\x00\x00\x00;\x00\x00\x00zbgn\xc7\x1c\xef\xd1MT\xf5\r\x04\x00\x00\x00O'
b'\x00P),8\x89\xd5Th\xc0\xc4?jxuzc\x10B+8\x81\x81\xb2\xceO\xc9\x9d\x7f\xed2u'
b'\xee\xdd7\xaf\x95f\xd8\xac>\x11')
Результат разбора:
'A1': [{'B1': -5804782290503843236, 'B2': 78544326},
{'B1': -1577631070485209933, 'B2': 1980479822}],
{'A2': 0.17309349355168768,
'A3': {'C1': 1005802784998497479,
'C2': 'zbgn',
'C3': 10576,
'C4': 44,
'C5': 0.16212181227008116},
'A4': 'jxuzc',
'A5': -0.4085839092731476,
'A6': 94632531,
'A7': 5317477739724140723,
'A8': {'D1': [16912, 14379, -32383, -12622, -14001, 32669],
'D2': 237,
'D3': 30002,
'D4': 238,
'D5': 2511288285,
'D6': 0.33758848905563354,
'D7': 17}}
Задача №12
Реализовать разбор двоичного формата данных. Данные начинаются с сигнатуры 0x42 0x51 0x4a 0x55 0xf3
, за которой следует
структура A. Порядок байт: от младшего к старшему. Адреса указаны в виде смещений от начала данных. В решении предлагается использовать
модуль struct.
Структура A:
Поле | Описание |
---|---|
1 | int16 |
2 | double |
3 | uint16 |
4 | uint16 |
5 | uint64 |
6 | Адрес (uint32) структуры B |
Структура B:
Поле | Описание |
---|---|
1 | Адрес (uint16) структуры C |
2 | float |
3 | uint16 |
4 | Размер (uint16) и адрес (uint32) массива int8 |
5 | int64 |
6 | Массив float, размер 4 |
7 | uint8 |
Структура C:
Поле | Описание |
---|---|
1 | int32 |
2 | uint16 |
3 | Размер (uint16) и адрес (uint16) массива адресов (uint16) структур D |
4 | Массив uint32, размер 2 |
Структура D:
Поле | Описание |
---|---|
1 | int16 |
2 | uint32 |
3 | Размер (uint32) и адрес (uint32) массива uint8 |
Ниже показаны примеры разбора двоичного формата.
Пример 1
Двоичные данные:
b'BQJU\xf32\x17\xd8\xdf\x1bHZ\xd4\xd5?\xa2\xc9\x9bx\xca\xff\xe3D\xbd\xf7\xdcU['
(b'\x00\x00\x00m\x13M\x11\xd6a\x06\xb7\xe7\x03\x00\x00\x00\x1f\x00\x00\x00'
b'\x9f\'\xeb?v~\x12\xfba\xa4\x92\x05\x00\x00\x000\x00\x00\x00"\x005\x00\xbb'
b'\x0c\xbd~\x92`\x02\x00C\x00-\xe2=<j\xea\xb9\xfb\xd5\\G\x00\xd0[u?\n^\x02'
b"\x00Y\x00\x00\x00\xd9\xd9O'Uq\xae\x7f\xd0`\xc3\xbe*Qg?\x9cb#?O\xd8\xbb"
b'\xbe\\')
Результат разбора:
'A1': 5938,
{'A2': 0.34108597795375095,
'A3': 51618,
'A4': 30875,
'A5': 6187092380376891338,
'A6': {'B1': {'C1': 2126318779,
'C2': 24722,
'C3': [{'D1': -10735, 'D2': 3887531617, 'D3': [109, 19, 77]},
'D1': 4734,
{'D2': 2460246523,
'D3': [159, 39, 235, 63, 118]}],
'C4': [1010688557, 4223265386]},
'B2': 0.9584321975708008,
'B3': 24074,
'B4': [-43, 92],
'B5': 9200415699310205401,
'B6': [-0.38159799575805664,
0.9035822153091431,
0.63822340965271,
-0.36688467860221863],
'B7': 92}}
Пример 2
Двоичные данные:
b'BQJU\xf3\xc8\x07pX\xbc\xba\xcf\x9b\xcc\xbf\xc9l\xf5\x1d:\xfd\xe2\xae\xd5]cT~'
(b'\x00\x00\x00s\xaf\xc9\xae*k\x93#:\x03\x00\x00\x00\x1f\x00\x00\x002\x01\xd8m'
b'\x9ei\x86n\xa6\x03\x00\x00\x000\x00\x00\x00\xe3\xfb\x9bi\x99}U'
b'\x9c\x9f\x03\x00\x00\x00A\x00\x00\x00\xe2Z\x97\x8d\xb9\xd9x\xe2\x02\x00'
b'\x00\x00R\x00\x00\x00"\x003\x00D\x00T\x00:\xd1\x01\xec\xa7\x18\x04\x00b\x00'
b'y\xa4\xe1\x85\x0c\xd9\x1c\xe27Mj\x00\xce\xf4O\xbfv\x9a\x02\x00|\x00\x00\x00'
b'/\xb7\x9c\xaa\xd1\r[p*\xa6-\xbd8F>\xbfuV\x81\xbeFO\x96=h')
Результат разбора:
'A1': 1992,
{'A2': -0.22350498788790985,
'A3': 27849,
'A4': 7669,
'A5': 6080807094223830330,
'A6': {'B1': {'C1': -335425222,
'C2': 6311,
'C3': [{'D1': 10926, 'D2': 975410027, 'D3': [115, 175, 201]},
'D1': -24979, 'D2': 2792261225, 'D3': [50, 1, 216]},
{'D1': -26263, 'D2': 2677822845, 'D3': [227, 251, 155]},
{'D1': -29289, 'D2': 3799570873, 'D3': [226, 90]}],
{'C4': [2246157433, 3793541388]},
'B2': -0.8123291730880737,
'B3': 39542,
'B4': [55, 77],
'B5': 8096079949290321711,
'B6': [-0.04239479452371597,
-0.7432589530944824,
-0.25261273980140686,
0.07339338958263397],
'B7': 104}}
Задача №12
Реализовать разбор двоичного формата данных. Данные начинаются с сигнатуры 0x48 0x4f 0x52
, за которой следует структура A.
Порядок байт: от старшего к младшему. Адреса указаны в виде смещений от начала данных. В решении предлагается использовать модуль
struct.
Структура A:
Поле | Описание |
---|---|
1 | Массив адресов (uint16) структур B, размер 2 |
2 | Массив uint8, размер 7 |
3 | uint32 |
4 | Адрес (uint16) структуры E |
5 | uint32 |
6 | int8 |
7 | int16 |
Структура B:
Поле | Описание |
---|---|
1 | uint8 |
2 | int32 |
3 | Адрес (uint16) структуры C |
4 | uint8 |
5 | uint64 |
6 | uint32 |
Структура C:
Поле | Описание |
---|---|
1 | float |
2 | uint16 |
3 | Структура D |
Структура D:
Поле | Описание |
---|---|
1 | Массив uint16, размер 4 |
2 | uint32 |
3 | Размер (uint16) и адрес (uint16) массива int32 |
4 | int16 |
5 | double |
6 | int16 |
7 | uint16 |
8 | uint16 |
Структура E:
Поле | Описание |
---|---|
1 | int16 |
2 | int32 |
Ниже показаны примеры разбора двоичного формата.
Пример 1
Двоичные данные:
b'HOR\x00I\x00\x8b\xf2\xf2\x87\x96\xce\xa3j\x15\xbe\x94\xde\x00\x9fXX\xe3T'
(b'\xd7\xa2:k\xbb\x0c\x06[z?7>\x0f\xc4\x9c\x8b\x8d.e\xcd\x02\xd3\x0f\xa2'
b'\xc3X\xf9)C\x00\x02\x00\x1bY^?\xd6P\x16\x1b)]\x10x%\x1a\xee\xce\xef9\xfd@'
b'\xf8\xe4\x00#2c\xf5\xe9!s\x8fA\x9flL\xac\xcfP6\xfcyU\xd8f\xb1\xbfYq'
b'P\x06\xf4\xb4E79\xa6v^\xb7gd\x8d\xa6\x00\x02\x00]x\x18\xbf\xe6f\xf9\xfa\xc8s'
b'L\xb6\xc1\x0fF\x87$\xdd)\xf8\xea\xb4\x00e\xe1\xe8\xb8I!\xf5H\xa0\xb3\xcb'
b'\xb4\x8b\x05\x86a*\x82\x0e1')
Результат разбора:
'A1': [{'B1': 57,
{'B2': -46073628,
'B3': {'C1': 0.14039844274520874,
'C2': 35725,
'C3': {'D1': [11877, 52482, 54031, 41667],
'D2': 1492724035,
'D3': [1807420422, 1534738231],
'D4': 22878,
'D5': 0.3486380830049294,
'D6': 30757,
'D7': 6894,
'D8': 52975}},
'B4': 50,
'B5': 7202919508930937247,
'B6': 1816964303},
'B1': 221,
{'B2': 704178868,
'B3': {'C1': -0.8493852615356445,
'C2': 1780,
'C3': {'D1': [46149, 14137, 42614, 24247],
'D2': 1734643110,
'D3': [1345780857, 1440245425],
'D4': 30744,
'D5': -0.7000703714471483,
'D6': -18751,
'D7': 3910,
'D8': 34596}},
'B4': 225,
'B5': 16769233622711967923,
'B6': 3417606917}],
'A2': [242, 242, 135, 150, 206, 163, 106],
'A3': 364811486,
'A4': {'E1': -31135, 'E2': 713166385},
'A5': 1482220372,
'A6': -41,
'A7': -24006}
Пример 2
Двоичные данные:
b'HOR\x00I\x00\x8b\x7f9\xf39\xb8y\xa8\xd1\xaa\xc3\xe1\x00\x9f\x8f.\xf5\xf8'
(b'v\xf1]j^\xd9\xf2\x14\xe64o\xbfn\xd3\x19\xa3\xad*p&\x92\xc5\xd5\x0f'
b'\xd3\x95N\x15x\x00\x02\x00\x1b\x1cj?\xdc\xae\xd2\x1d\x9f\xff,\x8fx\xff\x85]'
b'b\xc9\x0fw\xb0"\x00#\x120?\nr\xe9w5\xdeW\xb3\xef\x1e\xa2"\x1f\xfe\x19\x82Y'
b'\xd7\xbe\x83h\xb8\x93I\x11\xfcZ\xac\x85\xb5.B}\xa5Y\x1e\x00\x02\x00]Y'
b'\x02?\xbfm\xa1\xfcc\xe5P\x00\xd4\x1cR^\x9avZ\xe5l\xe8\x00e>:\x94\x04\xd9\xce'
b'\x15_\xd90`\xec\xc3\x9b\x9f\x9d\x04\t\x90')
Результат разбора:
'A1': [{'B1': 201,
{'B2': 259502114,
'B3': {'C1': -0.9329085946083069,
'C2': 41901,
'C3': {'D1': [10864, 9874, 50645, 4051],
'D2': 2504922488,
'D3': [1784601074, 350631023],
'D4': 7274,
'D5': 0.44817021267953083,
'D6': -28808,
'D7': 65413,
'D8': 23906}},
'B4': 18,
'B5': 3476508926012765662,
'B6': 1471409950},
'B1': 118,
{'B2': 1524985064,
'B3': {'C1': -0.25665831565856934,
'C2': 37705,
'C3': {'D1': [4604, 23212, 34229, 11842],
'D2': 2107988254,
'D3': [-1574821890, 427973079],
'D4': 22786,
'D5': 0.1227666131197982,
'D6': 212,
'D7': 7250,
'D8': 24218}},
'B4': 62,
'B5': 4221004084264919001,
'B6': 811658435}],
'A2': [127, 57, 243, 57, 184, 121, 168],
'A3': 3517629409,
'A4': {'E1': -25697, 'E2': -1660679792},
'A5': 2402219512,
'A6': 118,
'A7': -3747}
Задача №12
Реализовать разбор двоичного формата данных. Данные начинаются с сигнатуры 0x47 0x57 0x58 0x45 0x10
, за которой следует
структура A. Порядок байт: от младшего к старшему. Адреса указаны в виде смещений от начала данных. В решении предлагается использовать
модуль struct.
Структура A:
Поле | Описание |
---|---|
1 | Массив адресов (uint16) структур B, размер 6 |
2 | Структура C |
3 | uint16 |
4 | int32 |
5 | Структура D |
Структура B:
Поле | Описание |
---|---|
1 | int8 |
2 | double |
Структура C:
Поле | Описание |
---|---|
1 | float |
2 | uint64 |
3 | uint8 |
4 | Размер (uint16) и адрес (uint32) массива char |
5 | Массив int16, размер 2 |
6 | int32 |
7 | double |
8 | Размер (uint32) и адрес (uint16) массива uint8 |
Структура D:
Поле | Описание |
---|---|
1 | float |
2 | uint8 |
3 | Размер (uint32) и адрес (uint16) массива uint16 |
4 | int64 |
5 | int64 |
6 | int64 |
7 | uint8 |
Ниже показаны примеры разбора двоичного формата.
Пример 1
Двоичные данные:
b'GWXE\x10d\x00m\x00v\x00\x7f\x00\x88\x00\x91\x00\xebh\xaf>O\xc1\xee'
(b'\xea\\\xd9`\x05\xa3\x04\x00\x9a\x00\x00\x00&\xa4b\xfa\xea#\x1b&\x8ef\xeb\xf0'
b'\xc9?\xe7\xbf\x06\x00\x00\x00\x9e\x00\xb33>\xb1\'\x7f!\xc8">\xc3\x02\x00\x00'
b'\x00\xa4\x00\xed*G\x17c\x12YP>\xd7K\xbf\xcb\xd2b\x05|\xd7RUL\xdc{"\xc9'
b'\xbc\x1eQSx\xce\xac\xe3?i\xf8M\xdd\x13\x14\x9e\xc4?=\xda\xb2\xdd]v'
b'\xb5\xe6\xbfB\x849\xeb\xa2\xbc\xf6\xd7\xbfr\x00~\xbe\xee_\xd7\xca'
b'\xbf\xfat\xca\xe7K\xcdx\xeb?eipx\xc8\xa8~}\xe3\xd5^LLJ')
Результат разбора:
'A1': [{'B1': -68, 'B2': 0.6148445463282177},
{'B1': 105, 'B2': 0.16107417077965613},
{'B1': 61, 'B2': -0.7096511681862367},
{'B1': 66, 'B2': -0.37443462286037055},
{'B1': 114, 'B2': -0.20969771535327197},
{'B1': -6, 'B2': 0.8584963305023181}],
{'A2': {'C1': 0.3425973355770111,
'C2': 387548561055596879,
'C3': 163,
'C4': 'eipx',
'C5': [-23514, -1438],
'C6': 639312874,
'C7': -0.7265367227038995,
'C8': [200, 168, 126, 125, 227, 213]},
'A3': 13235,
'A4': 2133307710,
'A5': {'D1': 0.1589665561914444,
'D2': 195,
'D3': [19550, 19020],
'D4': 5789679012763085549,
'D5': 388104290436896574,
'D6': 2484821839832078204,
'D7': 201}}
Пример 2
Двоичные данные:
b'GWXE\x10d\x00m\x00v\x00\x7f\x00\x88\x00\x91\x00\xee\xe1\x8b>L\x13\x80bm\x04y'
(b']\xdc\x05\x00\x9a\x00\x00\x00\xb4\x0bv\x86\xacu\xbf.\xb8\x00\xf3\xa4'
b'\x8fx\xd3\xbf\x03\x00\x00\x00\x9f\x00\xf9\xf9a\xa1t1\x92\xba\xa1>'
b'\xff\x02\x00\x00\x00\xa2\x00\x8d/T\xd2\xbf\x05(\x91\x9b\xb0\x84S\x11'
b'X\xa3\xb95\xc4\x8a!\xf4\x10\xa7;\x1c}\x80\r\x17\xd3\xbf|\x85\xbf\x02\x10N'
b'.\xc4mF\xc1\xbf\xa1@\x8dym\x97\xa3\xd1\xbf\x86,h\x9d\xe9\xac\xb8\xe1\xbf'
b'\xd6\xd0\xe5\x0cr$w\xc4?\x91p(\xd3\xb7*\xd8\xe0\xbfunwpe(\x8e\xc4\xcb*\xd1$')
Результат разбора:
'A1': [{'B1': 125, 'B2': -0.010491846684891781},
{'B1': 2, 'B2': -0.13496181563515153},
{'B1': -95, 'B2': -0.2756098336305577},
{'B1': -122, 'B2': -0.5537933886328168},
{'B1': -42, 'B2': 0.15988593644014637},
{'B1': -111, 'B2': -0.5263875570610832}],
{'A2': {'C1': 0.2732080817222595,
'C2': 6735419585559794508,
'C3': 220,
'C4': 'unwpe',
'C5': [2996, -31114],
'C6': 784299436,
'C7': -0.3042334662277528,
'C8': [40, 142, 196]},
'A3': 63993,
'A4': 829727073,
'A5': {'D1': 0.3158765435218811,
'D2': 255,
'D3': [10955, 9425],
'D4': -7987127617715949683,
'D5': -5070111924050153317,
'D6': 4298423010069234741,
'D7': 28}}
Задача №12
Реализовать разбор двоичного формата данных. Данные начинаются с сигнатуры 0x46 0x4e 0x46 0x56 0x52
, за которой следует
структура A. Порядок байт: от старшего к младшему. Адреса указаны в виде смещений от начала данных. В решении предлагается использовать
модуль struct.
Структура A:
Поле | Описание |
---|---|
1 | Массив структур B, размер 4 |
2 | uint32 |
3 | Адрес (uint32) структуры C |
Структура B:
Поле | Описание |
---|---|
1 | uint32 |
2 | uint8 |
3 | int32 |
Структура C:
Поле | Описание |
---|---|
1 | uint8 |
2 | Размер (uint16) и адрес (uint16) массива char |
3 | Адрес (uint16) структуры D |
4 | int16 |
5 | uint16 |
Структура D:
Поле | Описание |
---|---|
1 | int64 |
2 | Размер (uint16) и адрес (uint16) массива double |
3 | int64 |
4 | int32 |
5 | Массив int16, размер 4 |
Ниже показаны примеры разбора двоичного формата.
Пример 1
Двоичные данные:
b'FNFVRF|\x18\xbb\xde\x83\xa60\x88z\xc9\x7f\xe5\xd6\xc6)1>k\x1b\xf8K\x1b'
(b'\x0f\xfc\xe8\x92\x88-\xc5G\x9bL\x0c\x96\xc8\xd8\x96\xe7J\x00\x00\x00kgr?'
b'\xe9\xeb\xd3\x0f\xa7\x1cr?\xe3A\x9d\x1fK\xd4\xae\xbf\xe5J\x97\xf6}\x88j\xde'
b'\xe4\xa9M\x12\x01]\xa2\x00\x03\x003\xda\xc5gy\xc8\xfe\x91\xdce\x99\x07^o'
b'\xc7\xbe\rD4\x03j\xd8\x00\x02\x001\x00K\xeeB\xb5R')
Результат разбора:
'A1': [{'B1': 1182537915, 'B2': 222, 'B3': -2086260600},
{'B1': 2060025829, 'B2': 214, 'B3': -970378946},
{'B1': 1796995147, 'B2': 27, 'B3': 268232850},
{'B1': 2284700999, 'B2': 155, 'B3': 1275893448}],
{'A2': 3633768266,
'A3': {'C1': 216,
'C2': 'gr',
'C3': {'D1': -2385595754119864926,
'D2': [0.8100371652334515,
0.6017594920400791,
-0.6653556646599672],
'D3': -2682624230268431908,
'D4': 1704527710,
'D5': [28615, -16883, 17460, 874]},
'C4': -4542,
'C5': 46418}}
Пример 2
Двоичные данные:
b'FNFVR\xcc\xc4\xd0v\x89\xa3\x80\xa4o\x97\x8f\nc:\xdc\xc6U\x15\xf8\x0f\xb3z-'
(b'\x9eO\xa8\x87\xbc\x9f+w\x9c?$\xc5\x03Yu\x1c\x8c\x00\x00\x00lppf?\xdc\xfal'
b'\x9f\x05\xe7\x9c\xbf\xcd\xfd\xad\x1b\x017h\xbf\xdb\r\x8aj\xa7\xee\x88'
b'\xf7\xbc\xb9\x86\xe9\x08\xeey\x00\x03\x0040\x04L\xc2:H\x19\xb3ald\x88'
b'\xf8\x98\x80\x1f\xaf=\xde\xcc%\x00\x03\x001\x00L\xa5\xb5I&')
Результат разбора:
'A1': [{'B1': 3435450486, 'B2': 137, 'B3': -1551850385},
{'B1': 2542733923, 'B2': 58, 'B3': -590981867},
{'B1': 4161778554, 'B2': 45, 'B3': -1638946681},
{'B1': 3164547959, 'B2': 156, 'B3': 1059374339}],
{'A2': 1500847244,
'A3': {'C1': 37,
'C2': 'ppf',
'C3': {'D1': -595397061633315207,
'D2': [0.4527846863708136,
-0.23430408304778472,
-0.4227014581262911],
'D3': 3459974810812553651,
'D4': 1634493576,
'D5': [-1896, -32737, -20675, -8500]},
'C4': -23115,
'C5': 18726}}
Задача №12
Реализовать разбор двоичного формата данных. Данные начинаются с сигнатуры 0x32 0x58 0x55 0x43 0x45
, за которой следует
структура A. Порядок байт: от младшего к старшему. Адреса указаны в виде смещений от начала данных. В решении предлагается использовать
модуль struct.
Структура A:
Поле | Описание |
---|---|
1 | Размер (uint16) и адрес (uint32) массива структур B |
2 | Размер (uint32) и адрес (uint16) массива char |
3 | int32 |
4 | double |
5 | int32 |
6 | uint16 |
7 | Массив int8, размер 7 |
Структура B:
Поле | Описание |
---|---|
1 | uint16 |
2 | float |
3 | int32 |
4 | Структура C |
Структура C:
Поле | Описание |
---|---|
1 | Массив uint32, размер 2 |
2 | uint8 |
3 | Структура D |
4 | float |
5 | int8 |
Структура D:
Поле | Описание |
---|---|
1 | uint64 |
2 | uint8 |
3 | uint8 |
Ниже показаны примеры разбора двоичного формата.
Пример 1
Двоичные данные:
b'2XUCE\x02\x00*\x00\x00\x00\x06\x00\x00\x00n\x00<\xf1O\x8a\xe0Lp'
(b'\x07\xe4\xaa\xa3?\xfd3\xaf:\xa3\xe9<)\x926\xffqk\x07X\x1c\x10\n\xbf'
b'\n\xe35\xca\xc6\xf0J\xe7\x1dL\x02\x1f \xeb\xa4}\xe9\\\xfb\x12\xe2\xa8!\xfd'
b'JL\xbf\xd8.7\xa41\x96=\x1e+\xdc\xffFd\xb11\xf5\x11\xa3g\x9d\x1fc\xc7W\xd1'
b'\xe3\xce\n\xc5`\x98\xed*\xbf\x0bzpisar')
Результат разбора:
'A1': [{'B1': 22535,
{'B2': -0.5393083095550537,
'B3': -902438134,
'B4': {'C1': [3880448198, 520244253],
'C2': 32,
'C3': {'D1': 16290359178625393899, 'D2': 168, 'D3': 33},
'C4': -0.7980192303657532,
'C5': -40}},
'B1': 14126,
{'B2': 0.07333686947822571,
'B3': -2348258,
'B4': {'C1': [833709126, 1738740213],
'C2': 157,
'C3': {'D1': 778810273842029343, 'D2': 197, 'D3': 96},
'C4': -0.6676878929138184,
'C5': 11}}],
'A2': 'zpisar',
'A3': -1974472388,
'A4': 0.03841316786579241,
'A5': 984560637,
'A6': 59811,
'A7': [60, 41, -110, 54, -1, 113, 107]}
Пример 2
Двоичные данные:
b'2XUCE\x02\x00*\x00\x00\x00\x03\x00\x00\x00n\x00e\x0c6\xc1H\xfb\xad'
(b'\xdb\x92Y\xda?\xe2\x14\xa3\xeb\xa6\x9f\xb7o/([\x9d!\xe21P\xadp?ss_C'
b'\xb0\xbc\xa6AblG\xc0j\x9a\x19,!\xc1\xb8G\x82\x87\xb5\xfc\xea\xa3\xbe\xae'
b'\xd7:\xb9\xf9q\xbf\x90yl\xfe\xd0E\x87\xaf\x9d\x1e\x81o1:\x01c\x08\xb3'
b';&\x8e\xda(\x1c\xebA?\x8fewb')
Результат разбора:
'A1': [{'B1': 12770,
{'B2': 0.9401445388793945,
'B3': 1130328947,
'B4': {'C1': [1101446320, 3225906274],
'C2': 106,
'C3': {'D1': 9387675087901825434, 'D2': 135, 'D3': 181},
'C4': -0.3201521635055542,
'C5': -82}},
'B1': 15063,
{'B2': -0.945216715335846,
'B3': -26445424,
'B4': {'C1': [2944878032, 1870732957],
'C2': 49,
'C3': {'D1': 10242940042626662714, 'D2': 218, 'D3': 40},
'C4': 0.7574937343597412,
'C5': -113}}],
'A2': 'ewb',
'A3': -1053422491,
'A4': 0.4117171426113839,
'A5': -341633822,
'A6': 40870,
'A7': [-73, 111, 47, 40, 91, -99, 33]}
Задача №12
Реализовать разбор двоичного формата данных. Данные начинаются с сигнатуры 0xe2 0x51 0x45 0x54
, за которой следует структура
A. Порядок байт: от старшего к младшему. Адреса указаны в виде смещений от начала данных. В решении предлагается использовать модуль
struct.
Структура A:
Поле | Описание |
---|---|
1 | int64 |
2 | int32 |
3 | uint32 |
4 | Адрес (uint16) структуры B |
5 | double |
6 | double |
7 | Размер (uint16) и адрес (uint32) массива char |
8 | Размер (uint16) и адрес (uint32) массива int16 |
Структура B:
Поле | Описание |
---|---|
1 | float |
2 | double |
3 | Адрес (uint32) структуры C |
Структура C:
Поле | Описание |
---|---|
1 | Массив адресов (uint16) структур D, размер 3 |
2 | int16 |
3 | Размер (uint16) и адрес (uint16) массива uint32 |
4 | int32 |
5 | int64 |
6 | float |
7 | double |
Структура D:
Поле | Описание |
---|---|
1 | double |
2 | int8 |
Ниже показаны примеры разбора двоичного формата.
Пример 1
Двоичные данные:
b'\xe2QETI\xeb)\x10\xd1o{\x1ecq\xfbE\x83Z\xa6\x8e\x00}\xbf\xeb`N\\\xb3Yj?\xe8'
(b'D\xc5\xbaU#J\x00\x05\x00\x00\x00\x8d\x00\x02\x00\x00\x00\x92?\xe5C\x9f\x8eD'
b'\xb0\x98g\xbf\xcc\x14\x00L\x19\xb8\x18\xd6?\xe1<&\x90\xc2\x84\xbe-L\xe7\xcf'
b'\x8b\xf9\xa7\xe3-W\x81\xf4\xd6\x002\x00;\x00D\x83\xfd\x00\x03\x00'
b'M\xb0\x11\xdc\xee\xbev\xb9m3\xcc\xdam\xbfatG?\xdcZ\xa9\xdayg\x88\xbeTF'
b'p\xbf\xeb=\xe1\xc4\xfaV\x18\x00\x00\x00Ycdvrv\xe5\xb2\xbaX')
Результат разбора:
'A1': 5326396136505703198,
{'A2': 1668414277,
'A3': 2203756174,
'A4': {'B1': -0.20729994773864746,
'B2': -0.8513039443229813,
'B3': {'C1': [{'D1': 0.6645047930410497, 'D2': 103},
'D1': -0.21936038699954064, 'D2': -42},
{'D1': 0.5385926081982217, 'D2': 45}],
{'C2': -31747,
'C3': [1290260363, 4188529453, 1468134614],
'C4': -1341006610,
'C5': -4722383280579749267,
'C6': -0.880680501461029,
'C7': 0.44303366027235613}},
'A5': -0.8555061159666313,
'A6': 0.7583950652416231,
'A7': 'cdvrv',
'A8': [-6734, -17832]}
Пример 2
Двоичные данные:
b'\xe2QETyst\x96\xd2\n\xa9\x8d\xa9\xe1s\xba\x1c\x9eF\x90\x00\x81\xbf\xe2'
(b'jTj\xc0\xb6\x9a?\xdd\xb11\x1f)El\x00\x02\x00\x00\x00\x91\x00\x02\x00\x00'
b'\x00\x93?\xb9\xdd\xc0sp\xf3@\x03?\xe2\x1b\x84\r\x19\xd2\x86{\xbf\xc3\xff\xf5'
b'\x85\x1a\xef\xb0\x91\xc0f~\xbb\xdd-\xf2\xe0.\xcf\x8e\xf6[\x1c\x93%\x002\x00'
b';\x00Dy\xd9\x00\x04\x00M:\xaam\x18I\x84\xeb\x1f\xfc\xed|u\xbe-\xc9F?\xc4$'
b'\xfd\xa2\xbc\xfc\x18\xbd\xe5\xc7\xab\xbf\xec\x90]H}\xc8\x8c\x00\x00\x00]qz"'
b'\x8b\xc1\xc2')
Результат разбора:
'A1': 8751466692028836237,
{'A2': -1444842566,
'A3': 480134800,
'A4': {'B1': -0.11219724267721176,
'B2': -0.8926226058813582,
'B3': {'C1': [{'D1': 0.101039913352861, 'D2': 3},
'D1': 0.5658588653446521, 'D2': 123},
{'D1': -0.15624875067976296, 'D2': -111}],
{'C2': 31193,
'C3': [3227942587, 3710776032, 785354486, 1528599333],
'C4': 984247576,
'C5': 5297617584314481781,
'C6': -0.1697131097316742,
'C7': 0.15737886854364613}},
'A5': -0.5754797062888486,
'A6': 0.46393993418776946,
'A7': 'qz',
'A8': [8843, -15934]}
Задача №12
Реализовать разбор двоичного формата данных. Данные начинаются с сигнатуры 0x48 0x4c 0x48 0x45 0xa3
, за которой следует
структура A. Порядок байт: от старшего к младшему. Адреса указаны в виде смещений от начала данных. В решении предлагается использовать
модуль struct.
Структура A:
Поле | Описание |
---|---|
1 | uint8 |
2 | Адрес (uint16) структуры B |
3 | float |
4 | float |
5 | int32 |
6 | uint64 |
7 | Размер (uint32) и адрес (uint16) массива структур E |
Структура B:
Поле | Описание |
---|---|
1 | uint8 |
2 | uint64 |
3 | Структура C |
4 | int8 |
5 | Размер (uint16) и адрес (uint16) массива int16 |
Структура C:
Поле | Описание |
---|---|
1 | uint16 |
2 | Адрес (uint16) структуры D |
3 | uint16 |
4 | uint32 |
5 | float |
6 | Массив char, размер 6 |
Структура D:
Поле | Описание |
---|---|
1 | uint64 |
2 | int64 |
Структура E:
Поле | Описание |
---|---|
1 | uint16 |
2 | Размер (uint32) и адрес (uint16) массива uint8 |
Ниже показаны примеры разбора двоичного формата.
Пример 1
Двоичные данные:
b'HLHE\xa3\xc2\x006>\xdf>\xb9\xbf[\x93\xc8\xf9D\xec\x96\xfc\xa3\xc3\xc3'
(b'\xe40\x9f\xae\x00\x00\x00\x05\x00d\xb7\x88\xed\xeeh\xa9\x1b"\xdfp'
b'\xdd\x14\xd4\xe07\xfc\x82\x0f\x8b\xe0`\x00\xaa\xbc*\t\xf25tzI\x00"d'
b'\xe6|\xca6\x13\xbf`\xa5\xcawckfmt6\x00\x02\x002\xed\xfd\x14\xf8.\xc0\x80\xf0'
b'Be\x94\x04\xb1\x17\x00\x00\x00\x03\x00X\xb9L\x00\x00\x00\x02\x00['
b'\x88C\x00\x00\x00\x02\x00]S]\x00\x00\x00\x03\x00_>\xfb\x00\x00\x00\x02\x00b')
Результат разбора:
'A1': 194,
{'A2': {'B1': 96,
'B2': 48057634782328180,
'B3': {'C1': 31305,
'C2': {'D1': 13225081913987373858, 'D2': -2346132324319479812},
'C3': 25830,
'C4': 2093626899,
'C5': -0.8775297403335571,
'C6': 'wckfmt'},
'B4': 54,
'B5': [-32241, -29728]},
'A3': 0.4360254108905792,
'A4': -0.8577237129211426,
'A5': -112923498,
'A6': 18204609364876107694,
'A7': [{'E1': 45335, 'E2': [237, 253, 20]},
'E1': 47436, 'E2': [248, 46]},
{'E1': 34883, 'E2': [192, 128]},
{'E1': 21341, 'E2': [240, 66, 101]},
{'E1': 16123, 'E2': [148, 4]}]} {
Пример 2
Двоичные данные:
b'HLHE\xa3{\x006>\x18\x16D?i\x0e\xfc\xd3\xb7f\x11\xae\xb7\x1f\x19n\xb7a\xa5'
(b'\x00\x00\x00\x03\x00`v\xc1\x12\xf0\xfay\xe2\xcf\xfe\x1c8{\x98\x88\xc2s)\x91'
b'k\x8e\x98\x90\x17\x14!2\x837F08\x00"\x1fR:&\x92\xcd>c\x9f\xcddsykxo\xd0'
b'\x00\x02\x002S;\x95%\xf2\xa1\x8c>\x8c\xa1\x00\x00\x00\x03\x00Xm \x00\x00'
b'\x00\x02\x00[\xf7P\x00\x00\x00\x03\x00]')
Результат разбора:
'A1': 123,
{'A2': {'B1': 152,
'B2': 10382789598739904326,
'B3': {'C1': 12344,
'C2': {'D1': 8557141593184395983, 'D2': -136171785236725133},
'C3': 8018,
'C4': 975606477,
'C5': 0.2222892791032791,
'C6': 'dsykxo'},
'B4': -48,
'B5': [10641, 27534]},
'A3': 0.14852243661880493,
'A4': 0.9103848934173584,
'A5': -742955503,
'A6': 12589565477429666213,
'A7': [{'E1': 36001, 'E2': [83, 59, 149]},
'E1': 27936, 'E2': [37, 242]},
{'E1': 63312, 'E2': [161, 140, 62]}]} {
Задача №12
Реализовать разбор двоичного формата данных. Данные начинаются с сигнатуры 0x54 0x55 0x48 0xdc
, за которой следует структура
A. Порядок байт: от младшего к старшему. Адреса указаны в виде смещений от начала данных. В решении предлагается использовать модуль
struct.
Структура A:
Поле | Описание |
---|---|
1 | uint64 |
2 | Адрес (uint32) структуры B |
3 | uint32 |
4 | Размер (uint16) и адрес (uint32) массива uint8 |
5 | uint64 |
6 | Размер (uint16) и адрес (uint16) массива int8 |
7 | Структура D |
8 | int16 |
Структура B:
Поле | Описание |
---|---|
1 | Размер (uint16) и адрес (uint32) массива адресов (uint32) структур C |
2 | uint64 |
Структура C:
Поле | Описание |
---|---|
1 | uint8 |
2 | Размер (uint32) и адрес (uint16) массива uint32 |
Структура D:
Поле | Описание |
---|---|
1 | Массив uint16, размер 7 |
2 | double |
3 | uint64 |
Ниже показаны примеры разбора двоичного формата.
Пример 1
Двоичные данные:
b'TUH\xdc\xa3\x97Q\xc42\xf7\x9e\xa2\x9a\x00\x00\x00\xf6\xc7\xbc\x99'
(b'\x07\x00\xa8\x00\x00\x00\x04\xedC\xb9\xd0\xc3\xa6\xb4\x05\x00\xaf\x00\x1b1'
b'\xd0A\xea\xa9j\xebCwhK\xbeFx\xb2e5v\xc6\xe6?\xaf\xd0b\xa1|\xcc\xb5\xc2'
b'=\xd9?\x03\x85\x17\x102\xa1\x9b\xba\x02\x00\x00\x00F\x00\xce\xd3\xbc/7*)'
b'\xfb\xc2\x02\x00\x00\x00U\x00\x1b\xfe\xd0{\x13\x0e\xf8/v\x02\x00\x00'
b'\x00d\x00\xcc\xa0\x82\xaf\xa9r^$\xa1z\x98\xf48\x07\xaek\x1b\x04\x00\x00\x00'
b's\x00N\x00\x00\x00]\x00\x00\x00l\x00\x00\x00\x83\x00\x00\x00\x04\x00'
b'\x8a\x00\x00\x00{\xaf\nk\xa0\xfb\xf4\xb4J\xce\x7fb\x85\xeeR\xb1h\x80\x8e\xd2')
Результат разбора:
'A1': 11718075077878716323,
{'A2': {'B1': [{'C1': 186, 'C2': [394593087, 2611032592]},
'C1': 194, 'C2': [800904142, 4213778999]},
{'C1': 118, 'C2': [2077294107, 804785683]},
{'C1': 27,
{'C2': [2944573644, 610169513, 4103633569, 1806567224]}],
'B2': 13039323487553630075},
'A3': 2579286006,
'A4': [74, 206, 127, 98, 133, 238, 82],
'A5': 13017307074189847812,
'A6': [-79, 104, -128, -114, -46],
'A7': {'D1': [12571, 16848, 43498, 60266, 30531, 19304, 18110],
'D2': 0.711726288119805,
'D3': 14030345049798267055},
'A8': -9923}
Пример 2
Двоичные данные:
b'TUH\xdc\x1f\x91\xe3B\x15\x87P\x94t\x00\x00\x006`\xf5=\x06\x00\x82\x00'
(b'\x00\x00@\xc3\x863\x02\xea\x1f\x81\x03\x00\x88\x00\xac\x03\xef\xbaV\x94'
b'{\xaa8\xa3\x85\xf3\x11\x10\xbc\rzV1R\xd8?\xb5\xab\xd8\xdd\xb7\xd0\xb9R'
b'\x8a\xbbC\xac~\x9b\xc8\x9f\xfb\x17\xe4\x02\x00\x00\x00F\x009\xf5{\x06g\xf6+'
b'Z\xdb\xb8\x15\xf6\x93\xa3\xa9\x1b\x9a\x04\x00\x00\x00U\x00N\x00\x00\x00'
b'e\x00\x00\x00\x02\x00l\x00\x00\x00\xb8\xa8\x19M\x87\xc7\x86\x8f2\xc5'
b'oj\xa0\x80k\x80\x0e')
Результат разбора:
'A1': 10687190441136460063,
{'A2': {'B1': [{'C1': 228, 'C2': [2608770115, 402366408]},
'C1': 154,
{'C2': [108787001, 1512830567, 4128618715, 464102291]}],
'B2': 10342172978230962360},
'A3': 1039491126,
'A4': [50, 197, 111, 106, 160, 128],
'A5': 9304412650346038080,
'A6': [107, -128, 14],
'A7': {'D1': [940, 47855, 37974, 43643, 41784, 62341, 4113],
'D2': 0.380016645860646,
'D3': 5961025069921119157},
'A8': -17526}
Задача №12
Реализовать разбор двоичного формата данных. Данные начинаются с сигнатуры 0xbf 0x4e 0x51 0x48 0x4d
, за которой следует
структура A. Порядок байт: от младшего к старшему. Адреса указаны в виде смещений от начала данных. В решении предлагается использовать
модуль struct.
Структура A:
Поле | Описание |
---|---|
1 | Массив структур B, размер 3 |
2 | int64 |
3 | Структура C |
4 | Массив адресов (uint32) структур D, размер 5 |
5 | int16 |
Структура B:
Поле | Описание |
---|---|
1 | Размер (uint32) и адрес (uint32) массива char |
2 | uint32 |
Структура C:
Поле | Описание |
---|---|
1 | int8 |
2 | uint32 |
3 | float |
4 | int8 |
Структура D:
Поле | Описание |
---|---|
1 | Массив int16, размер 6 |
2 | int32 |
Ниже показаны примеры разбора двоичного формата.
Пример 1
Двоичные данные:
b'\xbfNQHM\x04\x00\x00\x00Q\x00\x00\x001`d\xb1\x05\x00\x00\x00U\x00\x00'
(b'\x00\xe39@.\x02\x00\x00\x00Z\x00\x00\x00\xd7\x8c\xa9\xcf\xceY{h\x8d1\xeb'
b'\xbb\xc6\xbb1\xc5\xfc\xd8\xd9l?\x85\\\x00\x00\x00l\x00\x00\x00|'
b'\x00\x00\x00\x8c\x00\x00\x00\x9c\x00\x00\x00\x95\x0cdatnyumhniam\xf7z\x00'
b'\x8f\xc4\xaaEh\xb4\xde@\x9c\x04\xc1\xe8#@\\\x92h\xc3\xf3\x8ax\xc3\xceh'
b"\xc2\xa3\x8cL\x18\xb3O_i\xe2\xb0z\x82\xebSK\xa3\xc8\x1b#'\\\x1c\xaa"
b'v\x96\x86\x07\xd1\x84\x82V\xef\x17\x81k\x88v\x8e\x1e\xe7\x0b\xe9T'
b'\xc5\xe90\xf7"3\xdbX')
Результат разбора:
'A1': [{'B1': 'datn', 'B2': 2976145457},
{'B1': 'yumhn', 'B2': 775961059},
{'B1': 'ia', 'B2': 3483995351}],
{'A2': -4905772885676959282,
'A3': {'C1': -58, 'C2': 4240781755, 'C3': 0.925199031829834, 'C4': -123},
'A4': [{'D1': [-2195, 122, -15217, 17834, -19352, 16606], 'D2': -390003556},
'D1': [16419, -28068, -15512, -29965, -15496, 26830],
{'D2': 1284285378},
'D1': [-19688, 24399, -7575, 31408, -5246, 19283], 'D2': 589023395},
{'D1': [23591, -21988, -27018, 1926, -31535, 22146], 'D2': 1803622383},
{'D1': [30344, 7822, 3047, 21737, -5691, -2256], 'D2': 1490760482}],
{'A5': 3221}
Пример 2
Двоичные данные:
b'\xbfNQHM\x03\x00\x00\x00Q\x00\x00\x005\xe7\xe0d\x03\x00\x00\x00T\x00\x00'
(b'\x00o3W4\x04\x00\x00\x00W\x00\x00\x00\xa4\x0f\r\xf0 [_z\nl=0\xdc\xe8\xcc'
b'\x1bfuR!\xbf+[\x00\x00\x00k\x00\x00\x00{\x00\x00\x00\x8b\x00\x00\x00\x9b'
b'\x00\x00\x00K\xbdwsgdptapvq\xba\x1a\xea3Yj\xb9\xffns\x0e\xb1(36A\xda'
b'\xaf\xd2\x08cW@J\x0f\xdc\x04l\xa4\x04\xfb\xe4\x9d\x97)w\x84\xbdz2\xca'
b'\xff\xd9\xb2\xce\xbb)z\xba\x94~$\xcd\x7f\xeaD]\xdb\x7f_C\xc7y\xd5['
b'}\x9d\xc1\xbbKx8\xf2W\xf6b\xa81f\x9d')
Результат разбора:
'A1': [{'B1': 'wsg', 'B2': 1692460853},
{'B1': 'dpt', 'B2': 878130031},
{'B1': 'apvq', 'B2': 4027387812}],
{'A2': 3476053279658433312,
'A3': {'C1': -36, 'C2': 1713097960, 'C3': -0.6301644444465637, 'C4': 43},
'A4': [{'D1': [6842, 13290, 27225, -71, 29550, -20210], 'D2': 1094071080},
'D1': [-20518, 2258, 22371, 19008, -9201, 27652], 'D2': -453311324},
{'D1': [-26723, 30505, -17020, 12922, -54, -19751], 'D2': 2049555406},
{'D1': [-27462, 9342, 32717, 17642, -9379, 24447], 'D2': -713439421},
{'D1': [32091, -15971, 19387, 14456, 22514, 25334], 'D2': -1654247000}],
{'A5': -17077}
Задача №12
Реализовать разбор двоичного формата данных. Данные начинаются с сигнатуры 0x55 0x57 0x46 0x45
, за которой следует структура
A. Порядок байт: от младшего к старшему. Адреса указаны в виде смещений от начала данных. В решении предлагается использовать модуль
struct.
Структура A:
Поле | Описание |
---|---|
1 | int8 |
2 | double |
3 | double |
4 | int8 |
5 | Адрес (uint32) структуры B |
6 | Адрес (uint16) структуры D |
7 | int64 |
8 | int64 |
Структура B:
Поле | Описание |
---|---|
1 | int8 |
2 | Массив адресов (uint16) структур C, размер 5 |
Структура C:
Поле | Описание |
---|---|
1 | uint8 |
2 | uint16 |
3 | uint8 |
Структура D:
Поле | Описание |
---|---|
1 | double |
2 | Размер (uint16) и адрес (uint16) массива адресов (uint16) структур E |
3 | Размер (uint32) и адрес (uint32) массива float |
4 | Массив double, размер 3 |
5 | float |
Структура E:
Поле | Описание |
---|---|
1 | uint32 |
2 | float |
Ниже показаны примеры разбора двоичного формата.
Пример 1
Двоичные данные:
b'UWFE\xa2\xf4u\x0b\xe8\x85\x9d\xea?\xb0$\xa2U=\x0c\xc2?\xcb@\x00\x00\x00o\x00'
(b'\x99\xa6& \x86\xc7\x0f;V\xd1\x15\xe3\xdc\xfeK\x96\xc9\x83\xb4\x82'
b'\xee\x026\x06\x01HD`00\x83\x8b\xf7\xca\x9c\xb39,\x000\x004\x008\x00<\x00\x9d'
b'\x0e,\x1eT\xfb\x01?\xb4m\xe8\xe4\xcfo\xbf<K\x00S\x00n\xe3\xff\xbei'
b'G\x07\xbf\xa5\xa2%>\x842W?\xb0\xd3\x99\xa3)\\\xb7?\x02\x00[\x00\x04'
b'\x00\x00\x00_\x00\x00\x00\xc0RU\x7fQ\xa4\xee\xbf\x12\xed\xab\t{'
b'\xba\xe3\xbf\xd2\x91\xd4\x02V\xa4\xe7\xbfi8\x07?')
Результат разбора:
'A1': -94,
{'A2': 0.8317288906216036,
'A3': 0.14099852258030898,
'A4': -53,
'A5': {'B1': 57,
'B2': [{'C1': 201, 'C2': 46211, 'C3': 130},
'C1': 238, 'C2': 13826, 'C3': 6},
{'C1': 1, 'C2': 17480, 'C3': 96},
{'C1': 48, 'C2': 33584, 'C3': 139},
{'C1': 247, 'C2': 40138, 'C3': 179}]},
{'A6': {'D1': 0.09125004047548546,
'D2': [{'E1': 506203805, 'E2': 0.5077412128448486},
'E1': 3840437684, 'E2': 0.023368744179606438}],
{'D3': [-0.4997820258140564,
-0.5284333825111389,
0.16175325214862823,
0.8406145572662354],
'D4': [-0.9575583922365567, -0.616513747110192, -0.7388105445175432],
'D5': 0.5282045006752014},
'A7': 4255839551767357081,
'A8': -7616714120110943914}
Пример 2
Двоичные данные:
b'UWFE\xb9 \xd0E\xbf\xb9\xd3\xe5\xbf\x80\xc5Q\xdc\xde\x8d\xba?v@\x00'
(b'\x00\x00s\x00\x90EDeh\xfc\xe9\x01\x99G\x87\xdfP\xc2\xdf\x1d@\xb6\xa0\x9f'
b'\xc5,o\xefa\xc9\xe0N\xdeT\xbb\x0fE\x89j\x11U,\x000\x004\x008\x00<\x00\x8d'
b'\xffNc\x87\xb9V?\xef\xac\xb4\xce\xb3\xf2\xaf>K\x00S\x00\x8d"\x13\xbd\xf7'
b'\xa9\xf9\xbe\xdd\xe5\x1a?\xfaN\xc7\xbe%\xb5\xeb\xbej\xa2\xb5S\xcf'
b'\x16\xec?\x02\x00[\x00\x05\x00\x00\x00_\x00\x00\x00\xae\xa8\xa7\xde\x0f'
b'E\xe9?\xd4\xb7\xa2i\x13=\xdb\xbf\xc2\xe2\x9d\x0e\x1b[\xef\xbf\x19'
b'\x84\xc5\xbe')
Результат разбора:
'A1': -71,
{'A2': -0.6820954070849474,
'A3': 0.10372727278606497,
'A4': 118,
'A5': {'B1': 85,
'B2': [{'C1': 64, 'C2': 41142, 'C3': 159},
'C1': 197, 'C2': 28460, 'C3': 239},
{'C1': 97, 'C2': 57545, 'C3': 78},
{'C1': 222, 'C2': 47956, 'C3': 15},
{'C1': 69, 'C2': 27273, 'C3': 17}]},
{'A6': {'D1': 0.8777844080878598,
'D2': [{'E1': 1666121613, 'E2': 0.8387684226036072},
'E1': 3467947247, 'E2': 0.3436485230922699}],
{'D3': [-0.035921622067689896,
-0.487624853849411,
0.6050699353218079,
-0.3892744183540344,
-0.4603663980960846],
'D4': [0.7896804188469753, -0.4256027728650882, -0.9798713002665738],
'D5': -0.3857734501361847},
'A7': 137918788917282192,
'A8': 2152652799509743513}
Задача №12
Реализовать разбор двоичного формата данных. Данные начинаются с сигнатуры 0x45 0x58 0x50 0x4f 0x6a
, за которой следует
структура A. Порядок байт: от старшего к младшему. Адреса указаны в виде смещений от начала данных. В решении предлагается использовать
модуль struct.
Структура A:
Поле | Описание |
---|---|
1 | Адрес (uint32) структуры B |
2 | uint8 |
3 | Структура D |
Структура B:
Поле | Описание |
---|---|
1 | float |
2 | Массив char, размер 3 |
3 | Массив структур C, размер 2 |
4 | Размер (uint32) и адрес (uint16) массива uint16 |
5 | float |
6 | int16 |
Структура C:
Поле | Описание |
---|---|
1 | uint8 |
2 | double |
3 | uint16 |
Структура D:
Поле | Описание |
---|---|
1 | Массив int32, размер 2 |
2 | Массив uint64, размер 6 |
Ниже показаны примеры разбора двоичного формата.
Пример 1
Двоичные данные:
b'EXPOj\x00\x00\x00R)\xf6\xf6\x02\xc0*n?\x19A\x1a\x96\xf5\x11\xc3M@\xd5Fx9Fl'
(b'\xe5\x92(r\x93\x16\xc0\xc4\xa1M\x1e\x82X\xfd\x1ck\x14\xcb\xef\x98W\xa7\xb2z'
b'A\xe3\xad]:$\xdd\xf7 i\x8e#:\xc4#\x08\x817\xdfE\xb6>DHz\xcc\xbe\x16\x91\\xa'
b'y\xf2?\xd73\xb4\xbd\x10\xcb\x84m\xa8D\xbf\xce\xf9\x1a\x8f\xaf\xf0'
b'\xa8\xd7/\x00\x00\x00\x08\x00B?\x15\x0b\x8c\xf8\xe8')
Результат разбора:
'A1': {'B1': -0.14703887701034546,
{'B2': 'xay',
'B3': [{'C1': 242, 'C2': 0.3625308843940547, 'C3': 28072},
'C1': 68, 'C2': -0.24197704330425052, 'C3': 55087}],
{'B4': [36387, 15044, 8968, 33079, 57157, 46654, 17480, 31436],
'B5': 0.582207441329956,
'B6': -1816},
'A2': 41,
'A3': {'D1': [-151649600, 711868185],
'D2': [4691227941168958784,
15368102965838407058,
2914553634794807629,
2198417412236973259,
17264645549290308067,
12492204871412818025]}}
Пример 2
Двоичные данные:
b'EXPOj\x00\x00\x00L\xc7\x92\xc6\xc5\xf2\x19|\xe6Z\xa1RNn\x95{-G\xa7B'
(b'\xa4]\x809\xbcKXG\xaau\xfax\x8f+U\xb3\x8f\xbe+\x88\x0f\xdaM\xb6[\xebWI'
b'\xf1\xa5I\x1d\x03O\xe2\x836\xf6\x8fW\x1d\x00\x1c\xbf\xd3<\xf7y>\x9d\x9adplth'
b'?\xec\x90\xfa\xf0\x81\xf4\xae\x023\t\xbf\xc1C\xb7\x17\xb8z\x90i'
b'\xf0\x00\x00\x00\x05\x00B>\xcb\x88\xd0\xf84')
Результат разбора:
'A1': {'B1': 0.30781853199005127,
{'B2': 'plt',
'B3': [{'C1': 104, 'C2': 0.8926977822699393, 'C3': 563},
'C1': 9, 'C2': -0.1348790040801373, 'C3': 27120}],
{'B4': [36695, 7424, 7359, 54076, 63353],
'B5': 0.39752817153930664,
'B6': -1996},
'A2': 199,
'A3': {'D1': [-1832466958, 427615834],
'D2': [11624439825057918279,
12052376274287049803,
6361240422374215467,
6175437560991977434,
5599764253021696421,
5268370780730898166]}}
Задача №12
Реализовать разбор двоичного формата данных. Данные начинаются с сигнатуры 0x55 0x59 0x45 0x5a
, за которой следует структура
A. Порядок байт: от старшего к младшему. Адреса указаны в виде смещений от начала данных. В решении предлагается использовать модуль
struct.
Структура A:
Поле | Описание |
---|---|
1 | uint8 |
2 | uint64 |
3 | int16 |
4 | Размер (uint16) и адрес (uint16) массива char |
5 | float |
6 | Размер (uint32) и адрес (uint16) массива адресов (uint32) структур B |
7 | int32 |
Структура B:
Поле | Описание |
---|---|
1 | uint32 |
2 | double |
3 | Адрес (uint16) структуры C |
4 | int16 |
5 | int16 |
6 | int16 |
7 | Массив float, размер 2 |
8 | Адрес (uint16) структуры D |
Структура C:
Поле | Описание |
---|---|
1 | uint16 |
2 | Массив int8, размер 5 |
Структура D:
Поле | Описание |
---|---|
1 | int32 |
2 | float |
3 | float |
Ниже показаны примеры разбора двоичного формата.
Пример 1
Двоичные данные:
b'UYEZ\xc9\x86@\x98H\x1a\xecv\xbf\x92/\x00\x02\x00!\xbf\x01\xd43\x00'
(b'\x00\x00\x02\x00\x85\x07\xc6u\xecbi\xf8\x01mp\rx\x1a\x97\xb1\xf2L>D'
b'\xe0\xae\xbe\xfe\x901Z\x82\x034\xbf\xd4\x14\xe36\xb8P@\x00#\x8e@\x06\xb3'
b'm\xee=\xa9z\xbd\xbe\xe3\x91\xe8\x00*\x1e\xf21a0y}\x8b^\x18\xba>e\x03\x18?'
b'w^b}#\x89\xd8\xbf\xdcO\xaa\x99\nc\xb4\x00T&o\xfe\xfbc\xf9?3\x82Z>\xe4mm\x00'
b'[\x00\x00\x006\x00\x00\x00g')
Результат разбора:
'A1': 201,
{'A2': 9673899435048597183,
'A3': -28113,
'A4': 'bi',
'A5': -0.5071441531181335,
'A6': [{'B1': 1518469940,
'B2': -0.3137748751044036,
'B3': {'C1': 63489, 'C2': [109, 112, 13, 120, 26]},
'B4': -29120,
'B5': 1715,
'B6': 28142,
'B7': [0.08275363594293594, -0.4444725513458252],
'B8': {'D1': -1749945780,
'D2': 0.19226333498954773,
'D3': -0.497193843126297}},
'B1': 2099481048,
{'B2': -0.44236245103234784,
'B3': {'C1': 7922, 'C2': [49, 97, 48, 121, 125]},
'B4': 9839,
'B5': -261,
'B6': 25593,
'B7': [0.7012077569961548, 0.4461473524570465],
'B8': {'D1': -1956767558,
'D2': 0.22364461421966553,
'D3': 0.966283917427063}}],
'A7': 130446828}
Пример 2
Двоичные данные:
b'UYEZ\x9c\x02\x16`\xa2O^\xfe\x00\xa16\x00\x05\x00!?K?\xf0\x00\x00\x00\x02\x00'
(b'\x88\xd9j4\xf7effla\t\xd7H\xd7\xa6a\x80\xebLT\xd0\xbd}\xda\xd0\xbe\xd3\xd7'
b'1\xbf,\xd9\xcf\xbf\xe7\x18\xe9?\x9f4\xd4\x00&\x9cQ\xb7\x9bi\xe9\xbd\xb8-'
b'*?\x10\xfa\xa6\x00-v\xf1\xdb\x0f\xd8\xf3\x7f\x07\x85\x0c\x1c\xbc?\x037>\n'
b'*lw\x16\xc4\x95\xbf\xc7\xa8\xf6\xf2\xc9\xf8\xd8\x00W\x99\xcb{\xc3'
b'v\xd5\xbf\x18\x04\xc7\xbd\xb0e"\x00^\x00\x00\x009\x00\x00\x00j')
Результат разбора:
'A1': 156,
{'A2': 150413887796084224,
'A3': -24266,
'A4': 'effla',
'A5': 0.7939443588256836,
'A6': [{'B1': 3207387599,
'B2': -0.7217909090628845,
'B3': {'C1': 2519, 'C2': [72, -41, -90, 97, -128]},
'B4': -25519,
'B5': -18533,
'B6': 27113,
'B7': [-0.08992989361286163, 0.5663245916366577],
'B8': {'D1': -347319088,
'D2': -0.06197625398635864,
'D3': -0.41375115513801575}},
'B1': 1997980821,
{'B2': -0.18484389166764603,
'B3': {'C1': 30449, 'C2': [-37, 15, -40, -13, 127]},
'B4': -26165,
'B5': 31683,
'B6': 30421,
'B7': [-0.5938228964805603, -0.08613039553165436],
'B8': {'D1': 126159900,
'D2': -0.011658481322228909,
'D3': 0.13492745161056519}}],
'A7': -647351049}
Задача №12
Реализовать разбор двоичного формата данных. Данные начинаются с сигнатуры 0xf1 0x53 0x45 0x43 0x42
, за которой следует
структура A. Порядок байт: от старшего к младшему. Адреса указаны в виде смещений от начала данных. В решении предлагается использовать
модуль struct.
Структура A:
Поле | Описание |
---|---|
1 | double |
2 | int32 |
3 | double |
4 | Структура B |
5 | Адрес (uint32) структуры D |
Структура B:
Поле | Описание |
---|---|
1 | int16 |
2 | int64 |
3 | Размер (uint32) и адрес (uint32) массива структур C |
4 | Размер (uint32) и адрес (uint32) массива char |
5 | int16 |
6 | int8 |
Структура C:
Поле | Описание |
---|---|
1 | int8 |
2 | int64 |
Структура D:
Поле | Описание |
---|---|
1 | Массив int64, размер 4 |
2 | Размер (uint32) и адрес (uint32) массива uint32 |
3 | int8 |
4 | int32 |
5 | uint64 |
6 | uint64 |
Ниже показаны примеры разбора двоичного формата.
Пример 1
Двоичные данные:
b'\xf1SECB?\xed\xe8\x94\xc9P\xcf.aw\xe6\xed?\xdb\xb6A/`\xb0\xa8\xe0\xdd\xb0'
(b'\xd1$\xd3m_+:\x00\x00\x00\x03\x00\x00\x00:\x00\x00\x00\x04\x00\x00\x00Ud'
b"\x17\xe9\x00\x00\x00a\xdf\xfe\xbf~N\x82/7o\x93\xdc\xd0\x92'Y>\xcc\x06"
b'\xef\x1c\xdf\x08<\xd30o\xaaxmui\xd4\x13\xa1f\xe9@\x9ah\xc7\xe5\xdf\x1a3\x0eQ'
b"\x19\xe5\xa0\xad\xd5\xf2&\xe4Aiz\x92w\x10y6\xdd\x0e\xfe'*\x9d\xd4O"
b"\x07\x00\x00\x00\x02\x00\x00\x00Y)\xac%Vdb\xae'\xe2\xf9\x18Z\x94C\xe8"
b'\xb1\x8b\xdbf\x7f\xeb')
Результат разбора:
'A1': 0.9346412593790541,
{'A2': 1635247853,
'A3': 0.432998939769059,
'A4': {'B1': -7971,
'B2': -5705738762410054854,
'B3': [{'C1': -33, 'C2': -90214591867439249},
'C1': -109, 'C2': -2535365892510921722},
{'C1': -17, 'C2': 2080390610202685354}],
{'B4': 'xmui',
'B5': 25623,
'B6': -23},
'A5': {'D1': [-4042579786876432103,
-1900327908348074943,
7600548361216276189,
1080344024605544199],
'D2': [3558056294, 3913325160],
'D3': 41,
'D4': -1406839196,
'D5': 7110664717459806868,
'D6': 4893356209377542123}}
Пример 2
Двоичные данные:
b'\xf1SECB?\xe6eA\xdc\xf5\xf2dA$\x8d\x86\xbf\xe7\xa4\\9:\xf3ZD)t'
(b'\xd0\xb8\xa2\xf7\xc4\xd2,\x00\x00\x00\x02\x00\x00\x00:\x00\x00\x00\x04\x00'
b'\x00\x00LI#\xf0\x00\x00\x00X\x83\x9e\xb6ZDH\x1eE\x12\xcf\x92\xa4\xc1J#W\x1fA'
b'yncq\x12w\n\xbao\xd9Y\xd2\xe9 Dt\xb7w+\xdf\x97\xe5\xed\x1b\xe1\x80~\x96'
b'\xac\xd4\xde\xf6qYS\x92\xa7\xeb\xa2\xb2\x8f\xae\x08v\x00\x00\x00\x02'
b"\x00\x00\x00P\xb8\xf7\xc57\xda\xb0\x9a\xeb\xb5\x1fpR\x8c\x19`}'\x7fm!2")
Результат разбора:
'A1': 0.6998605075492148,
{'A2': 1092914566,
'A3': -0.7388135068682502,
'A4': {'B1': 17449,
'B2': 8417430713636540972,
'B3': [{'C1': -125, 'C2': -7010316520641379054},
'C1': -49, 'C2': -7879960923826872511}],
{'B4': 'yncq',
'B5': 18723,
'B6': -16},
'A5': {'D1': [-1648242195532665889,
-7501328900312498538,
-5992920054078286958,
-6346800362050156426],
'D2': [309791418, 1876515282],
'D3': -72,
'D4': -138070054,
'D5': 12725742860237820556,
'D6': 1828599057307476274}}
Задача №12
Реализовать разбор двоичного формата данных. Данные начинаются с сигнатуры 0x4f 0x49 0x4e
, за которой следует структура A.
Порядок байт: от младшего к старшему. Адреса указаны в виде смещений от начала данных. В решении предлагается использовать модуль
struct.
Структура A:
Поле | Описание |
---|---|
1 | Массив структур B, размер 3 |
2 | float |
3 | uint32 |
4 | uint16 |
5 | uint8 |
6 | int8 |
7 | Адрес (uint32) структуры C |
Структура B:
Поле | Описание |
---|---|
1 | int8 |
2 | uint16 |
Структура C:
Поле | Описание |
---|---|
1 | Структура D |
2 | uint8 |
Структура D:
Поле | Описание |
---|---|
1 | float |
2 | uint8 |
3 | Размер (uint32) и адрес (uint16) массива uint32 |
4 | Структура E |
Структура E:
Поле | Описание |
---|---|
1 | int64 |
2 | Массив int32, размер 7 |
3 | double |
4 | Массив int32, размер 6 |
Ниже показаны примеры разбора двоичного формата.
Пример 1
Двоичные данные:
b"OIN\x8b\xda\xd1\x11=\xfb'k)\x81oF?\xe7\x0f\xbf\xc7\xe6\x9c\xafV$\x00\x00\x00"
(b'\xf3E=K\x91A\xb5\xc9\xed\xef0?\x02\x02\x00\x00\x00\x1c\x00\x06\x17\xc3^\x8b'
b'\xaa<\x7fd\xa2L\xca\x9cQe\xd5H]\xb6/VA\xb8\x97H\xb4\xbcTd^\xeb\xea\x88'
b'\xc3\xe3\x07\xf0\xdf\xd8\x10\xe0\xaf\xd9?$\x8bn;\t.H&\x06\xd0V\xa3\xd9'
b'(\x9fE:\x82\xc7]{\xcb\xb25\xff')
Результат разбора:
'A1': [{'B1': -117, 'B2': 53722},
{'B1': 17, 'B2': 64317},
{'B1': 39, 'B2': 10603}],
{'A2': 0.7751389145851135,
'A3': 3351187431,
'A4': 40166,
'A5': 175,
'A6': 86,
'A7': {'C1': {'D1': 0.6911609768867493,
'D2': 2,
'D3': [1262306803, 3384099217],
'D4': {'E1': 9168390456986507014,
'E2': [-900947356,
-714780260,
800480584,
-1749532330,
1421653064,
-353673628,
132367240],
'E3': 0.4013595737956157,
'E4': [997100324,
642264585,
-1554591738,
1168058585,
1573356090,
900909947]}},
'C2': 255}}
Пример 2
Двоичные данные:
b'OIN\x83\x17!\x0e\x1f\xd9\x11\x15\x08\xb0\x92D\xbf F7_\xaf\x1cp,(\x00\x00\x00'
(b'\xabB\x1d\xe5\xc3\xfb\xed4\x86\xda3\x90\xe5\xc6\xd5>O\x03\x00\x00'
b'\x00\x1c\x00\t)\x9e\x1fWe\xf6\x19b\xa7i\x08\x88Ep\xe7\x88\xcb\x83\xb7\xfe'
b'\xec\xc8\x9b^\x93\xed\xbb\xee\xba\xb4\xa6m\xe3\x1cRp\x1ed\x95s\xc7\xb3\xbf\t'
b'c4\x8e\xd0\xee\x18\xe8\x86F\x89\xd5V\x9a8\x826\x15\xa8\xc3(\xfec\x02\r')
Результат разбора:
'A1': [{'B1': -125, 'B2': 8471},
{'B1': 14, 'B2': 55583},
{'B1': 17, 'B2': 2069}],
{'A2': -0.7678632736206055,
'A3': 1597457952,
'A4': 7343,
'A5': 112,
'A6': 44,
'A7': {'C1': {'D1': 0.4175330698490143,
'D2': 79,
'D3': [3843900075, 888011715, 2419317382],
'D4': {'E1': 1870794120086038793,
'E2': [141141858,
-412072568,
-1216099448,
-1681330946,
-1142058146,
-1498105106,
1377624941],
'E3': -0.07726213834041018,
'E4': [-1909169399,
-401019184,
-712423802,
-2110219690,
-1012394698,
40107560]}},
'C2': 13}}
Задача №12
Реализовать разбор двоичного формата данных. Данные начинаются с сигнатуры 0x41 0x4c 0x49 0x57 0x15
, за которой следует
структура A. Порядок байт: от старшего к младшему. Адреса указаны в виде смещений от начала данных. В решении предлагается использовать
модуль struct.
Структура A:
Поле | Описание |
---|---|
1 | uint8 |
2 | uint64 |
3 | uint8 |
4 | int64 |
5 | Адрес (uint32) структуры B |
6 | Массив int16, размер 4 |
7 | int16 |
8 | Адрес (uint32) структуры D |
Структура B:
Поле | Описание |
---|---|
1 | int16 |
2 | Массив структур C, размер 2 |
3 | double |
4 | uint32 |
5 | Размер (uint16) и адрес (uint16) массива char |
6 | Массив float, размер 8 |
7 | int8 |
Структура C:
Поле | Описание |
---|---|
1 | int16 |
2 | int32 |
Структура D:
Поле | Описание |
---|---|
1 | float |
2 | double |
3 | int16 |
4 | uint32 |
5 | uint8 |
6 | int16 |
Ниже показаны примеры разбора двоичного формата.
Пример 1
Двоичные данные:
b'ALIW\x15:Z\xc3\x9b\x06\xcd2\xe6\xbe\r\x06\xa5N\x0b\xf8\xf54\xa2\x00'
(b'\x00\x00+\xf5.!\xd9\xb6\x85\x19\xd7\xb2\xc3\x00\x00\x00jvx\x1c\xca\x11\x9c_'
b'\x1elJ\xd0\x8by\xa9\xdf\xd4?\xe3Zb7\xc6\x96&\xcb3BD\x00\x02\x00)>\xcee'
b'\xcf>\xe5>\x95>\xbf\xb0\xc8\xbe\xb9>\xfd?1}\xcf=\xb7\xe8N\xbd{\n'
b'\x9a?\x16\xba\x8c\n\xbe\x07\xb2\x8e\xbf\xe5C\x04\xf8\x8c}\x00\xc9\xcc'
b'\xcc?%\xab_\xe8\xc0')
Результат разбора:
'A1': 58,
{'A2': 6540241537386866366,
'A3': 13,
'A4': 478874748713252002,
'A5': {'B1': 7370,
'B2': [{'C1': 4508, 'C2': 1595829322},
'C1': -12149, 'C2': 2041176020}],
{'B3': 0.6047831620568942,
'B4': 3409134148,
'B5': 'vx',
'B6': [0.4031204879283905,
0.44774308800697327,
0.37439560890197754,
-0.3618086874485016,
0.693325936794281,
0.08979855477809906,
-0.061289407312870026,
0.5887839794158936],
'B7': 10},
'A6': [-2770, 8665, -18811, 6615],
'A7': -19773,
'A8': {'D1': -0.13251706957817078,
'D2': -0.6644310812443166,
'D3': -13876,
'D4': 3426690475,
'D5': 95,
'D6': -5952}}
Пример 2
Двоичные данные:
b'ALIW\x15\x0f\xbe"\xa82\xd0\x98e[3\xcc\xba\x8b|\x05\xff\xe9\xac\x00'
(b'\x00\x001\x82\xda\xac\x126\xe3=\x9b\xd6\xe8\x00\x00\x00pcdarxghr\xc2\x04J'
b'\x87\xde\t\xda\xda\xd7\xa3i\xe0\xb6\x89?\xe1\x91\x93\x01Ag\xbe\xa1'
b'\xa4\x8d&\x00\x08\x00)?\rG,?l\x8aK\xbe\x0fmC>\xcb\xb1\x9f>\xf7\xbc^?'
b'd\xf8\xba?\x05\x19\xfb?\x19^\x12a?L\xd3o?\xee\xce\xd0\xb7\\2T\xcco\x82\xc1'
b'I&\x9d_D')
Результат разбора:
'A1': 15,
{'A2': 13700697952615949659,
'A3': 51,
'A4': -3694487179511207508,
'A5': {'B1': -15868,
'B2': [{'C1': 19079, 'C2': -569779494},
'C1': -10333, 'C2': 1776334473}],
{'B3': 0.5490202927132868,
'B4': 2711915814,
'B5': 'cdarxghr',
'B6': [0.5518672466278076,
0.9239851832389832,
-0.1400652378797531,
0.3978395164012909,
0.48385900259017944,
0.8944202661514282,
0.5199276804924011,
0.599091649055481],
'B7': 97},
'A6': [-32038, -21486, 14051, 15771],
'A7': -10520,
'A8': {'D1': 0.8001012206077576,
'D2': 0.9627460080387871,
'D3': -13201,
'D4': 2193705254,
'D5': 157,
'D6': 24388}}
Задача №12
Реализовать разбор двоичного формата данных. Данные начинаются с сигнатуры 0x86 0x43 0x4c 0x51
, за которой следует структура
A. Порядок байт: от старшего к младшему. Адреса указаны в виде смещений от начала данных. В решении предлагается использовать модуль
struct.
Структура A:
Поле | Описание |
---|---|
1 | Размер (uint16) и адрес (uint32) массива char |
2 | Размер (uint32) и адрес (uint32) массива адресов (uint16) структур B |
3 | Адрес (uint32) структуры D |
4 | int8 |
Структура B:
Поле | Описание |
---|---|
1 | uint32 |
2 | uint8 |
3 | double |
4 | int8 |
5 | uint64 |
6 | Структура C |
7 | Массив float, размер 5 |
Структура C:
Поле | Описание |
---|---|
1 | uint64 |
2 | uint8 |
3 | Размер (uint16) и адрес (uint16) массива int8 |
Структура D:
Поле | Описание |
---|---|
1 | uint8 |
2 | float |
Ниже показаны примеры разбора двоичного формата.
Пример 1
Двоичные данные:
b'\x86CLQ\x00\x02\x00\x00\x00\x17\x00\x00\x00\x02\x00\x00\x00\x8c\x00\x00'
(b'\x00\x90bey\x99f\xed\xf9\x08A\xccz?\xe4\x03\xe36\x7f\xcf`\xc7\xa8\r'
b'\x02\xbf\t^D\x7f\xdb%X\t\xf0\xa8\x8b[<\x00\x03\x00\x19>|\x12\xf5\xbf'
b'\x08\xa5\n\xbe\xe7>\xe1?V\xca\xff\xbe\xc4\xa1\xe6\xc8\tZ\x18\xb0'
b'\x8e\xc0?\xd4\xe8\xe8\xfa\xe2\xfd\x00\xb0\x1e8_\x95~n\xc8\x18\x83'
b'\xfa@\xa2\x18\x00\xe7\x13\x17\x00\x02\x00S??\x922\xbe\x85o\xf6?\x1e\x99\xd9'
b'\xbe\x15\x01w<\xff\xe1\x1b\x00\x1c\x00U\x06\xbe\n\x8dg')
Результат разбора:
'A1': 'ey',
{'A2': [{'B1': 4178067916,
'B2': 122,
'B3': 0.6254745544851907,
'B4': -57,
'B5': 12109337992588313727,
'B6': {'C1': 15791124468160039771, 'C2': 60, 'C3': [-103, 102, -19]},
'B7': [0.24616606533527374,
-0.5337682962417603,
-0.45165160298347473,
0.8390349745750427,
-0.3840476870536804]},
'B1': 1511567502,
{'B2': 192,
'B3': 0.3267157030167738,
'B4': -80,
'B5': 2177595515509590040,
'B6': {'C1': 9509984628077815571, 'C2': 23, 'C3': [-56, 9]},
'B7': [0.7483245134353638,
-0.2606198191642761,
0.6195350289344788,
-0.1455134004354477,
0.031235268339514732]}],
'A3': {'D1': 6, 'D2': -0.1353050321340561},
'A4': 98}
Пример 2
Двоичные данные:
b'\x86CLQ\x00\x02\x00\x00\x00\x17\x00\x00\x00\x02\x00\x00\x00\x8d\x00\x00'
(b'\x00\x91\xc6zg)\xd0\xe7\xf6g\xe7s\xdf\xbf\xdc\x18B\xb5\x1a\x00\\\xad\xf6\x87'
b'\xcd\xc1\x81\xe08v\xbb\xc1\xabL\xb9F\xe6\x0b>\x00\x03\x00\x19\xbfe\xdd\xe4?'
b'\x04\xbd\xc7\xbe\xad\xdb*?=\x148\xbe\xd0*v\xb8$2\xe5\x0b\xd3p\x02?'
b'\xe3\xf1\xc9\xcd\xc3\x1a\x90D\x07\x95M\x10\xb1\xe9H\xd2c\xc3x\xd9'
b'\x95\xe26\xb5\xed\x00\x03\x00S>\xab;\xeb?\x10\xb3\xbe>\xe2\x16\xda\xbe*\xeb'
b'k?m\xa9-\x00\x1c\x00V/?]\x8a\xb6')
Результат разбора:
'A1': 'zg',
{'A2': [{'B1': 4134004595,
'B2': 223,
'B3': -0.43898074804019926,
'B4': -83,
'B5': 17764393486177548406,
'B6': {'C1': 13529283101611976203, 'C2': 62, 'C3': [41, -48, -25]},
'B7': [-0.8979170322418213,
0.5185207724571228,
-0.33956271409988403,
0.7385897636413574,
-0.40657395124435425]},
'B1': 3842757488,
{'B2': 2,
'B3': 0.6232651728431211,
'B4': 68,
'B5': 546427663895054546,
'B6': {'C1': 7188722306131310261, 'C2': 237, 'C3': [-72, 36, 50]},
'B7': [0.33444151282310486,
0.5652426481246948,
0.441580593585968,
-0.16691367328166962,
0.9283626675605774]}],
'A3': {'D1': 47, 'D2': 0.8653978109359741},
'A4': -58}
Задача №12
Реализовать разбор двоичного формата данных. Данные начинаются с сигнатуры 0x50 0x4d 0x47 0x43
, за которой следует структура
A. Порядок байт: от старшего к младшему. Адреса указаны в виде смещений от начала данных. В решении предлагается использовать модуль
struct.
Структура A:
Поле | Описание |
---|---|
1 | uint8 |
2 | Размер (uint32) и адрес (uint32) массива double |
3 | Структура B |
Структура B:
Поле | Описание |
---|---|
1 | int16 |
2 | Массив структур C, размер 5 |
3 | uint64 |
4 | Адрес (uint16) структуры D |
5 | uint64 |
Структура C:
Поле | Описание |
---|---|
1 | Размер (uint16) и адрес (uint16) массива int16 |
2 | int8 |
3 | uint16 |
4 | uint32 |
5 | uint8 |
6 | int16 |
7 | int8 |
Структура D:
Поле | Описание |
---|---|
1 | uint32 |
2 | uint64 |
3 | Массив uint16, размер 3 |
4 | uint64 |
5 | int32 |
6 | int16 |
Ниже показаны примеры разбора двоичного формата.
Пример 1
Двоичные данные:
b'PMGC&\x00\x00\x00\x02\x00\x00\x00l\xdcI\x00\x02\x00|_\x8b\x08?4\xce\x8caE'
(b'\xd4\x89\x00\x02\x00\x80\xfb\x8a\x80\x91\xd5?\x94\xd0\xaa\xb1'
b'\xe9\x00\x03\x00\x84\x03]\xe05\x87\xfbj\x94{\xdfP\x00\x03\x00\x8a'
b'\x1bv\xa0\xe5\xb1\xf7\x19\xc7b\x91\xc4\x00\x02\x00\x90^\xbf\xc5\\\xb3'
b'm\xbb\xd7\xba\xb9\xd6\xbf\x8di\x89^\xea\x98\x90\x00\x94"\x8a\xe6N\x8aF\r\xbd'
b'?\xa5\xfa\xaf\x12R: \xbf\xeb!W\xa9/\xb0\xa8\xdf\xc4\xf6\x93-\x0b\xba\xa8'
b'\x91rU\x19c-UzPcI{\xb1\xd5\x10\x91\xa1\\\xcbT\x99\xfb\xfd-\xbe\xac\x174'
b'F\x0b+b7\xc9\x9e\x021\x0cJ%\xbe\x8a\xd6\xf2\xb0ID\xc8')
Результат разбора:
'A1': 38,
{'A2': [0.04292819117209867, -0.8478201202792848],
'A3': {'B1': -9143,
'B2': [{'C1': [-8252, -2413],
'C2': 95,
'C3': 35592,
'C4': 1060425356,
'C5': 97,
'C6': 17876,
'C7': -119},
'C1': [11531, -17752],
{'C2': -5,
'C3': 35456,
'C4': 2446671764,
'C5': 208,
'C6': -21839,
'C7': -23},
'C1': [-28302, 21785, 25389],
{'C2': 3,
'C3': 24032,
'C4': 898104170,
'C5': 148,
'C6': 31711,
'C7': 80},
'C1': [21882, 20579, 18811],
{'C2': 27,
'C3': 30368,
'C4': 3853645593,
'C5': 199,
'C6': 25233,
'C7': -60},
'C1': [-20011, 4241],
{'C2': 94,
'C3': 49093,
'C4': 1555262907,
'C5': 215,
'C6': -17735,
'C7': -42}],
'B3': 13802804471684307088,
'B4': {'D1': 2707213140,
'D2': 11095740479871653684,
'D3': [17931, 11106, 14281],
'D4': 11385716736799391370,
'D5': -688738231,
'D6': 17608},
'B5': 2489054969077304765}}
Пример 2
Двоичные данные:
b'PMGC#\x00\x00\x00\x03\x00\x00\x00lf\x98\x00\x03\x00\x84\xe7\xb1\xe3\x1eM'
(b"'\xe1H\xf3\x8a\xed\x00\x03\x00\x8a\xa2\x9e{\x8b\x1bVj\x17\x0f\xd8"
b'\xc7\x00\x03\x00\x90\x1b\x11w\xb5\x07R\xe3\xfa-Q\xcf\x00\x03\x00\x96'
b'\xdd\x00n\xb8\xcc\x813\xd1CrK\x00\x03\x00\x9cZ\xa7P\x91\xbfDs\xc0\x83'
b'\xdar\xf9/|\xdd\xfdS[>\x00\xa2\xa2\xd0\xa6/\xc4\xc0\xaaM?\xca\x86\xef'
b'J\xd5\t\xd8?\xe6\xada\xc2\xebjv?\xe5\xcd=\xad\xbaobW]"\x85\x93p\x9bW'
b'\x17\x8e\xb8>\x06\xb5/\xccc\xbfot\xa2u1\x99\xf7\xaf3\x15\x8fq\xf0f\xf8G\xe5H'
b'\xcb\x80\xb0QM\xd7r\xb1\xc0\xa5\x00\xe4\xd8/\xaf\x86\xc5\x05c\xf0'
b'\x06\xc5\xa7\xb05o')
Результат разбора:
'A1': 35,
{'A2': [0.20724288133540258, 0.7086647803328805, 0.681303824723255],
'A3': {'B1': 26264,
'B2': [{'C1': [22365, 8837, -27792],
'C2': -25,
'C3': 45539,
'C4': 508372961,
'C5': 72,
'C6': -3190,
'C7': -19},
'C1': [-25769, 6030, -18370],
{'C2': -94,
'C3': 40571,
'C4': 2333824618,
'C5': 23,
'C6': 4056,
'C7': -57},
'C1': [1717, 12236, 25535],
{'C2': 27,
'C3': 4471,
'C4': 3037156067,
'C5': 250,
'C6': 11601,
'C7': -49},
'C1': [28532, -23947, 12697],
{'C2': -35,
'C3': 110,
'C4': 3100410163,
'C5': 209,
'C6': 17266,
'C7': 75},
'C1': [-2129, 13077, -28815],
{'C2': 90,
'C3': 42832,
'C4': 2445231219,
'C5': 192,
'C6': -31782,
'C7': 114}],
'B3': 17955707532229172030,
'B4': {'D1': 4033280071,
'D2': 16521678986583035351,
'D3': [29361, 49317, 228],
'D4': 15577862629463778288,
'D5': 113616816,
'D6': 13679},
'B5': 11732059753394776653}}
Задача №12
Реализовать разбор двоичного формата данных. Данные начинаются с сигнатуры 0x86 0x56 0x49 0x49 0x4f
, за которой следует
структура A. Порядок байт: от старшего к младшему. Адреса указаны в виде смещений от начала данных. В решении предлагается использовать
модуль struct.
Структура A:
Поле | Описание |
---|---|
1 | Размер (uint16) и адрес (uint32) массива адресов (uint16) структур B |
2 | uint32 |
3 | float |
4 | uint8 |
5 | uint16 |
6 | Размер (uint32) и адрес (uint32) массива char |
7 | int8 |
8 | Структура C |
Структура B:
Поле | Описание |
---|---|
1 | int64 |
2 | uint16 |
Структура C:
Поле | Описание |
---|---|
1 | Размер (uint32) и адрес (uint16) массива int64 |
2 | int16 |
3 | uint8 |
4 | int8 |
5 | Размер (uint16) и адрес (uint32) массива int8 |
6 | int16 |
7 | double |
8 | Адрес (uint16) структуры D |
Структура D:
Поле | Описание |
---|---|
1 | double |
2 | int16 |
3 | uint32 |
4 | uint64 |
Ниже показаны примеры разбора двоичного формата.
Пример 1
Двоичные данные:
b'\x86VIIO\x00\x04\x00\x00\x00c#!\x00<\xbc\x9f4\xc3\x81\xe7"\x00\x00'
(b'\x00\x02\x00\x00\x00k\x8b\x00\x00\x00\x02\x00m\xc5\x13\xb10\x00\x04\x00'
b'\x00\x00}\x85\xc7\xbf\xd5t\xd6\xf7|{d\x00\x81.\x87\\gys\xf4\xf2\x97'
b';N\xef\x0en\x0c$}\x01<\x1b\x0638|\x13o\x112\x93\x13(\xf0\x92r\xe4\x10\xc0'
b'\xa9\xb4(\x00;\x00E\x00O\x00Yll/\x91\xf8\xedB8\x82\xdb\x83\xe2HK\xcb\xb7-'
b'\xc9\x15u\xbe=\xbf\xedP:\x9e\x95x|7\xc3s\xdeI\xb6\x0f9\xcf\x13f\x93\r\x17')
Результат разбора:
'A1': [{'B1': 3352750047089652978, 'B2': 38715},
{'B1': 5687780720205135105, 'B2': 15387},
{'B1': 446762893592957234, 'B2': 37651},
{'B1': 2950018778077905065, 'B2': 46120}],
{'A2': 589365308,
'A3': -0.019434338435530663,
'A4': 129,
'A5': 59170,
'A6': 'll',
'A7': -117,
'A8': {'C1': [3427794489307595483, -8943506419626857015],
'C2': -15085,
'C3': 177,
'C4': 48,
'C5': [21, 117, -66, 61],
'C6': -31289,
'C7': -0.3352563301904665,
'C8': {'D1': -0.9160435769406514,
'D2': 14275,
'D3': 1943947702,
'D4': 1097135666473667863}}}
Пример 2
Двоичные данные:
b'\x86VIIO\x00\x03\x00\x00\x00Y\x83O\x84\xc9\xbf.\xbf\x14\xf8\xa7?\x00\x00'
(b'\x00\x03\x00\x00\x00_\xdc\x00\x00\x00\x05\x00b)7\xeb\x8c\x00\x02\x00'
b'\x00\x00\x8a,b\xbf\xee\xdaE*j(\xb8\x00\x8c\x1fk\x17\xfa\xed\x9b\xf9\x10>'
b'\x0c\xc0\x16\xeb.\x1a\x19 \xb9c\x95"\xaf\x92%\xc6\x81\xa8)\x08.\x00;\x00'
b'E\x00Orsc\xd0\x0b3Z\xf1@\xccs\xed\xa5\t\x02\x7f\x84a\xf5%\x8d\xef\xb3\\\xda'
b'?\xc1\x03P\xceU\xf7\xf9_\xbfE\xf4\x03x\x1b\x81\xa8<\xc1\x0f?\xd0\x81&'
b'\xa0\x13W\xfci\x1at\xf0\xb5\xe6\xa8:?\xa1\xffL\x08\x8b')
Результат разбора:
'A1': [{'B1': 2263929604179491088, 'B2': 15884},
{'B1': -4605234985700876103, 'B2': 25493},
{'B1': 2499377009155745833, 'B2': 2094}],
{'A2': 2203026633,
'A3': -0.682603120803833,
'A4': 248,
'A5': 42815,
'A6': 'rsc',
'A7': -36,
'A8': {'C1': [-3455611823389094797,
-1322641009229405707,
2706082504755527617,
238917648878493631,
5040657697326868540],
'C2': 10551,
'C3': 235,
'C4': -116,
'C5': [-63, 15],
'C6': 11362,
'C7': -0.9641443088924211,
'C8': {'D1': 0.25788274414423973,
'D2': 26906,
'D3': 1961932262,
'D4': 12122071312026568843}}}
Задача №12
Реализовать разбор двоичного формата данных. Данные начинаются с сигнатуры 0x50 0x44 0x47 0x5a
, за которой следует структура
A. Порядок байт: от младшего к старшему. Адреса указаны в виде смещений от начала данных. В решении предлагается использовать модуль
struct.
Структура A:
Поле | Описание |
---|---|
1 | Структура B |
2 | Структура E |
Структура B:
Поле | Описание |
---|---|
1 | int32 |
2 | Массив структур C, размер 2 |
3 | double |
4 | int32 |
5 | Структура D |
6 | uint16 |
7 | Массив int32, размер 6 |
8 | float |
Структура C:
Поле | Описание |
---|---|
1 | Массив int16, размер 7 |
2 | uint32 |
3 | uint8 |
Структура D:
Поле | Описание |
---|---|
1 | int16 |
2 | uint64 |
3 | int32 |
Структура E:
Поле | Описание |
---|---|
1 | uint32 |
2 | float |
3 | double |
4 | uint32 |
5 | Массив uint64, размер 4 |
6 | Размер (uint32) и адрес (uint16) массива int32 |
Ниже показаны примеры разбора двоичного формата.
Пример 1
Двоичные данные:
b'PDGZ_\x11\xfdZ^\xae\x05Pp\xa6C\xc0\xff\xac\x07\xa0\xe0\x90\xddH'
(b'\x0c\xef\r\x1bQ?\x1e|\x0f{W\xb79\xb78\xba2\xbe\x8c\xe5<\x95\xe4\xbd'
b'P\xc2\n\xfa\xed\xbf#\xcf\x90\xc1O\xc2\xb2%\x0b\xc3\x14R\x1fb\xfaE\xfc\xf2'
b'\x15d\x9aR\xb0\x98 o3\xc0S\xfb\xff\xc5\xa5\xb2i\xf06\xd1]\x03o\xafRU\xce\x9b'
b'6?\x1e\xa4\xdba`\tn>\x04N;-WV\xd2\xbf(\xd8\x12\xfd\xf2\xcf\xb9"\xd7s'
b'\x89\x96\x95u\xba\x1dC\xfa\xe8\xd4\x17\xe0iR\xc5M\x8c\xce\xa5\xec'
b'\x7f\x00\x16\xfce_\x02\x00\x00\x00\xa0\x00@@\x98w\xa2sy/')
Результат разбора:
'A1': {'B1': 1526534495,
{'B2': [{'C1': [-20898, 20485, -22928, -16317, -21249, -24569, -28448],
'C2': 4010559709,
'C3': 13},
'C1': [20763, 7743, 3964, 22395, 14775, 14519, 12986],
{'C2': 1021676734,
'C3': 149}],
'B3': -0.9367727084372146,
'B4': -1047474397,
'B5': {'D1': -15793, 'D2': 7070460189120079282, 'D3': -218348038},
'B6': 25621,
'B7': [-1733274982,
-1070371040,
-973079725,
-261508443,
56480054,
1431482223],
'B8': 0.7133148908615112},
'A2': {'E1': 1641784350,
'E2': 0.23245763778686523,
'E3': -0.2865198079791471,
'E4': 4245870632,
'E5': [10847328545336315890,
15341787296806106517,
14883356378439213079,
6874177577678793893],
'E6': [2006466624, 796488610]}}
Пример 2
Двоичные данные:
b'PDGZ\xd0o\xe4}\xa5I%{5q\xb5\xb5\xbc)\x89Q\xbb\x89vJC\xd1\xde\x0e'
(b'\xc6Y\xfc\x01JLg\xb9\xf8\xad+\x82^\xd2\xfb.~Q\xc0\x8d\x80\xfb\xac\x89'
b'\xa9?\x9e *\x0f\x18)0:\xaf\x15\x81\xb6&\xf3\xfa\x01\x16\xdcT\xbc\xff)'
b'A\xb4\xb7g\xa4\x0fZ\x1a;-\x04Lh\xba3bNQ\xd3\xde\xcf\x19/\x80\xb1\xbd#\xb9'
b'^\x01=\x02\xd3> 5\xd8\x0b~U\xe2?E\xed&\xa6\xa3\x17 \xd6\x89FRW|\x8e<J}F'
b'8\xcc\x19\xaa7\xf2xb\xd6\xf9\xda\xaaVlG\x0b\xcby\x02\x00\x00\x00\xa0\x00'
b'\xa8Q\x8f\x11=\xca\x01U')
Результат разбора:
'A1': {'B1': 2112122832,
{'B2': [{'C1': [18853, 31525, 28981, -19019, 10684, 20873, -30277],
'C2': 3510848118,
'C3': 222},
'C1': [-14834, -935, 18945, 26444, -1863, 11181, 24194],
{'C2': 2117008338,
'C3': 81}],
'B3': 0.04987850732893717,
'B4': 254419102,
'B5': {'D1': 10520, 'D2': 17520892065862335024, 'D3': -602537478},
'B6': 48212,
'B7': [-1270797825,
262432695,
758848090,
-1167569916,
1364091443,
433053395],
'B8': -0.08667027205228806},
'A2': {'E1': 22984995,
'E2': 0.41212645173072815,
'E3': 0.572936080106647,
'E4': 2787568965,
'E5': [6292169187206895523,
14715589286363434620,
18002684832059468313,
8776120700249746138],
'E6': [294605224, 1426180669]}}
Задача №12
Реализовать разбор двоичного формата данных. Данные начинаются с сигнатуры 0x59 0x47 0x54
, за которой следует структура A.
Порядок байт: от старшего к младшему. Адреса указаны в виде смещений от начала данных. В решении предлагается использовать модуль
struct.
Структура A:
Поле | Описание |
---|---|
1 | Структура B |
2 | int16 |
3 | uint8 |
4 | uint16 |
5 | uint16 |
6 | uint64 |
7 | int8 |
8 | float |
Структура B:
Поле | Описание |
---|---|
1 | uint64 |
2 | Структура C |
3 | Адрес (uint16) структуры D |
4 | Массив uint8, размер 3 |
5 | int32 |
6 | Адрес (uint16) структуры H |
7 | uint16 |
Структура C:
Поле | Описание |
---|---|
1 | uint16 |
2 | int64 |
Структура D:
Поле | Описание |
---|---|
1 | uint8 |
2 | uint64 |
3 | int32 |
4 | double |
5 | Размер (uint16) и адрес (uint16) массива структур E |
6 | Структура F |
7 | Структура G |
Структура E:
Поле | Описание |
---|---|
1 | float |
2 | uint32 |
Структура F:
Поле | Описание |
---|---|
1 | Массив int16, размер 2 |
2 | Массив uint8, размер 3 |
Структура G:
Поле | Описание |
---|---|
1 | Размер (uint32) и адрес (uint32) массива uint16 |
2 | double |
3 | uint8 |
4 | uint64 |
5 | uint8 |
6 | uint32 |
Структура H:
Поле | Описание |
---|---|
1 | float |
2 | int32 |
3 | uint64 |
4 | int32 |
Ниже показаны примеры разбора двоичного формата.
Пример 1
Двоичные данные:
b'YGT\xbc\xbbSd\xbe\x0cfp\xde\xdc\x04O\x98\xd0\x95\x85[\xf3\x00NM4\x80\xa7\x18'
(b"\xeb2\x00\x8c:\xf7\xd6\x00@Bss\xbe\xca\x0eZ'\xa9\xaa\xd5\xc0\xa7?Q9\xa0\xbds"
b'0\xa7\xabj\xa1\x04?,\t\x8f7\xb6\x0c\xf3M\xden\xff\x82\xe0L^;\xfc'
b'\xd4\xc4\xf0\xc6\x17=\xae\xb3\xbe$\xf9\xbf\xbfB`\xc9\x1f\x11\xa0\x00'
b'\x02\x006v{#\x87K\xbas\x00\x00\x00\x04\x00\x00\x00F?\xd6/u\xb9\x18\xf54pf'
b'\xb9\x94\xc8jH\x10\xa1\x00g \x11\xcf\xbe\x1c&!l \r\x1e\xf7\x9bJ\xfb'
b'Z\x8f!\x10\x8b\x811(')
Результат разбора:
'A1': {'B1': 13599555191925663344,
{'B2': {'C1': 57052, 'C2': 310634920941018099},
'B3': {'D1': 59,
'D2': 18218402931015105966,
'D3': -1279384327,
'D4': -0.12210659895123976,
'D5': [{'E1': -0.05937257036566734, 'E2': 2875891972},
'E1': 0.6720208525657654, 'E2': 934677747}],
{'D6': {'F1': [30331, 9095], 'F2': [75, 186, 115]},
'D7': {'G1': [19934, 28415, 33504, 19550],
'G2': 0.3466467197029772,
'G3': 112,
'G4': 7402111051057598625,
'G5': 0,
'G6': 1730154959}},
'B4': [77, 52, 128],
'B5': -1491539150,
'B6': {'H1': -0.15248920023441315,
'H2': 1814039838,
'H3': 17841936792174928144,
'H4': -1954467544},
'B7': 15095},
'A2': -10752,
'A3': 64,
'A4': 17011,
'A5': 29630,
'A6': 14559673771732161984,
'A7': -89,
'A8': 0.8172855377197266}
Пример 2
Двоичные данные:
b'YGTM\xd0\xbf\xb48\x0f\xfe\x01sH6\x85F\xbc\xc2=mA\x00J\xb9\x83\xa2\x97\x11'
(b'c]\x00\x88\xa5\x14\xeb\xa5\x00h\xfeN\x93g\xddc\xc9\x9e\x14\xf8\xfe!\xbc\xe1'
b'\xe8\xf3?2\xe25z9\xcc5\xbd\xf4L8|\x9d\xfe|\xaa\xc7\x9bQtH\xd7*-\n\xaa@\x9b!'
b'=\x19\xa0?\xd2\xffr\xa5\x00]\x18\x00\x02\x006~E\x03\x14:\xdc!\x00\x00'
b'\x00\x02\x00\x00\x00F\xbf\xd4\xaa\x90i\xcaU\xcc\xc6\x002\x85n\x9c'
b'\xe5\x11D\x93\xe9\xda\xf8*>bQ\xd7\xbd\x9ai\xbb\xddU\xf83:Zy\xd4K\x96*\x8c')
Результат разбора:
'A1': {'B1': 5607192316831858177,
{'B2': {'C1': 29512, 'C2': 3928624026477227329},
'B3': {'D1': 116,
'D2': 5248710263664427163,
'D3': 557652384,
'D4': 0.29684129823131533,
'D5': [{'E1': 0.6987641453742981, 'E2': 2050608181},
'E1': -0.11928600072860718, 'E2': 2090729084}],
{'D6': {'F1': [32325, 788], 'F2': [58, 220, 33]},
'D7': {'G1': [43719, 39761],
'G2': -0.3229104073628519,
'G3': 198,
'G4': 14220458960687428,
'G5': 147,
'G6': 3923441706}},
'B4': [185, 131, 162],
'B5': -1760468131,
'B6': {'H1': 0.2210153192281723,
'H2': -1113953861,
'H3': 15948926554308508116,
'H4': 1268132492},
'B7': 42260},
'A2': -5211,
'A3': 0,
'A4': 26878,
'A5': 20115,
'A6': 7484247873351383294,
'A7': 33,
'A8': -0.027576899155974388}
Задача №12
Реализовать разбор двоичного формата данных. Данные начинаются с сигнатуры 0x4c 0x55 0x53 0x4d
, за которой следует структура
A. Порядок байт: от младшего к старшему. Адреса указаны в виде смещений от начала данных. В решении предлагается использовать модуль
struct.
Структура A:
Поле | Описание |
---|---|
1 | uint32 |
2 | Структура B |
3 | uint32 |
4 | Размер (uint16) и адрес (uint32) массива int64 |
5 | uint8 |
Структура B:
Поле | Описание |
---|---|
1 | float |
2 | uint64 |
3 | double |
4 | Адрес (uint32) структуры C |
5 | uint16 |
6 | Массив uint8, размер 4 |
7 | int16 |
8 | int16 |
Структура C:
Поле | Описание |
---|---|
1 | uint32 |
2 | int8 |
3 | Массив адресов (uint16) структур D, размер 3 |
4 | uint16 |
5 | uint16 |
Структура D:
Поле | Описание |
---|---|
1 | uint16 |
2 | int16 |
3 | uint16 |
4 | Массив int16, размер 4 |
5 | int64 |
Ниже показаны примеры разбора двоичного формата.
Пример 1
Двоичные данные:
b'LUSM\xb1=\xbe\xd1\xb4\x01y\xbf\xe9\x7f\xb4\xf7\x05V\x03\xad\x1c=\x82\x88'
(b'\xe6\xa3\xeb\xbfw\x00\x00\x00t\x9d\x851\xa1L\xc1\xb3r\x067*xq\x02\x00'
b'\x86\x00\x00\x00d\xcd\x94K\xaaH\xd8W>\x8ag\x12\x06{\xdc\xa9.0O\r~T\xb7P'
b'D\xb4\x90\xa7\xa6\x9f\x9d\xf1o{X\xf5\xd4\x92\x99\x80\x14k\xb3\xd3'
b'\x9a\xa7w\xce\x03\xcc\xcdy\xd1\xd62j\x9e\x07\x7f\x99\x98\xaf\x05\xb5'
b'\xd4\x8fj\x92Uw\x81_5\x00K\x00a\x00\x826\xfa\xe3\r\xf9\xcaV0\xb9'
b'\xa6\xaeJ\x16D;\x13\x02`\xe3')
Результат разбора:
'A1': 3518905777,
{'A2': {'B1': -0.9726822376251221,
'B2': 12466902777122291689,
'B3': -0.8637573877512383,
'B4': {'C1': 2172081554,
'C2': 95,
'C3': [{'D1': 38093,
'D2': -21941,
'D3': 55368,
'D4': [15959, 26506, 1554, -9093],
'D5': -5236421871096811863},
'D1': 17488,
{'D2': -28492,
'D3': 42663,
'D4': [-25185, 28657, 22651, -11019],
'D5': -7290286099295856238},
'D1': 30631,
{'D2': 974,
'D3': 52684,
'D4': [-11911, 13014, -24982, 32519],
'D5': 7678589763639548057}],
'C4': 13954,
'C5': 58362},
'B5': 40308,
'B6': [133, 49, 161, 76],
'B7': -19519,
'B8': 1650},
'A3': 1903700535,
'A4': [-5861794247710410483, -2062646347713735094],
'A5': 100}
Пример 2
Двоичные данные:
b'LUSMo\xe4x\xf3\xa8,\x9e>\xc9V\x87Y\xc6[\x08y\xf0+\x86\xa8\x0c\xb5\xe9\xbf'
(b'w\x00\x00\x00\x90\x80\xd8>\xca\xba&8\x0e\xbbfL\xbe\xfd\x03\x00'
b'\x86\x00\x00\x00\xa4.\x8dF\xc6\xf8Q\xc4\xd3\xd5\x07\xe0\xa7Q\x95\xf6'
b'L:\xf4\xc2\xcb\x95\xe8"\xdf\x11(\xdc\x8eJ-\xf0I\xaa \xbbJ\n*:&\x08o\xd7'
b'\x7f\x98\x99i\xf1\x16\xb6\xa4T\x99\xa4uq\xa7\x87\xb0\x7f\x14Ok\xb7\x82{\xb3'
b'XTa\xd35\x00K\x00a\x00\xd1\x0c\xef\xd7\xd9\xeb\xad9\xf4\xe4\xbb\xc5G\x01'
b'\x84\xb2\xfe\x04\t\x8aMHUPN.\xce\xe4')
Результат разбора:
'A1': 4084786287,
{'A2': {'B1': 0.30893445014953613,
'B2': 8721321585866659529,
'B3': -0.8033507625090106,
'B4': {'C1': 1632917683,
'C2': -45,
'C3': [{'D1': 36142,
'D2': -14778,
'D3': 20984,
'D4': [-11324, 2005, -22560, -27311],
'D5': -1687218447198827274},
'D1': 57122,
{'D2': 10257,
'D3': 36572,
'D4': [11594, 18928, 8362, 19131],
'D5': 9211953643601406474},
'D1': 39320,
{'D2': -3735,
'D3': 46614,
'D4': [21668, -23399, 29045, -30809],
'D5': 8899877485153648560}],
'C4': 3281,
'C5': 55279},
'B5': 32912,
'B6': [216, 62, 202, 186],
'B7': 14374,
'B8': -17650},
'A3': 4257107046,
'A4': [-4198510490002002983, -8500257329721900729, -1959577873969493939],
'A5': 164}
Задача №12
Реализовать разбор двоичного формата данных. Данные начинаются с сигнатуры 0xd9 0x53 0x44 0x57
, за которой следует структура
A. Порядок байт: от старшего к младшему. Адреса указаны в виде смещений от начала данных. В решении предлагается использовать модуль
struct.
Структура A:
Поле | Описание |
---|---|
1 | Адрес (uint16) структуры B |
2 | uint8 |
3 | Массив адресов (uint32) структур C, размер 5 |
4 | Размер (uint16) и адрес (uint32) массива char |
5 | int16 |
6 | Массив uint16, размер 7 |
7 | double |
8 | Адрес (uint32) структуры D |
Структура B:
Поле | Описание |
---|---|
1 | double |
2 | uint16 |
3 | float |
4 | int16 |
Структура C:
Поле | Описание |
---|---|
1 | int32 |
2 | uint32 |
3 | float |
4 | Массив char, размер 4 |
Структура D:
Поле | Описание |
---|---|
1 | double |
2 | uint32 |
Ниже показаны примеры разбора двоичного формата.
Пример 1
Двоичные данные:
b'\xd9SDW\x00="\x00\x00\x00M\x00\x00\x00]\x00\x00\x00m\x00\x00\x00}\x00'
(b'\x00\x00\x8d\x00\x02\x00\x00\x00\x9dj\xdf\xb2\xf8V-}\x0f\xda\xf4\xb0'
b'\xbd@\xc2\x82\x01\xbf\xe7?[\x8b)\x07d\x00\x00\x00\x9f\xbf\xd5\x1e\x01Y\xbeL'
b'\x8c\xc9\xf0?*\n\xe8@\x0f\xf7\xd2\x8aHoC-\x07\xbe\xda\xe1\xf4xyee\xbd\\D'
b'4\xc0\x8b\xd5[?\x03\x8a\x83hvil\xac\x03\xc4\x95^\xd9;\x9c?\x02eCrkw'
b'y\xda\xd2\x97k\xc3}\xa2\x93>~FMkfhh\xcah\x9aCS\xac\x1f_?\x1b\xd4\xd5jqnafr?'
b'\xebR\xed\xf4\xb7\xe7\xb4I\xec(\xa2')
Результат разбора:
'A1': {'B1': -0.329956376686092,
{'B2': 51696,
'B3': 0.6642289161682129,
'B4': 16399},
'A2': 34,
'A3': [{'C1': -137196984,
'C2': 1866673415,
'C3': -0.42750513553619385,
'C4': 'xyee'},
'C1': -1118026700,
{'C2': 3230389595,
'C3': 0.5138322710990906,
'C4': 'hvil'},
'C1': -1409039211,
{'C2': 1591294876,
'C3': 0.5093576312065125,
'C4': 'rkwy'},
'C1': -623732885,
{'C2': 3279790739,
'C3': 0.24831505119800568,
'C4': 'kfhh'},
'C1': -899114429,
{'C2': 1403789151,
'C3': 0.6087163090705872,
'C4': 'jqna'}],
'A4': 'fr',
'A5': 27359,
'A6': [45816, 22061, 32015, 56052, 45245, 16578, 33281],
'A7': -0.7264840810750965,
'A8': {'D1': 0.8538732318549962, 'D2': 1240213666}}
Пример 2
Двоичные данные:
b'\xd9SDW\x00=6\x00\x00\x00M\x00\x00\x00]\x00\x00\x00m\x00\x00\x00}\x00'
(b'\x00\x00\x8d\x00\x03\x00\x00\x00\x9d\xbc\x86\x07G\xf4x\x1ac\xf5\xd6^'
b'\x17\xeb\x12\xce\xf1?\xdd\xc6\xc7\x03\x19G@\x00\x00\x00\xa0?\xe3\xc4'
b'\xbf\xf1N\xc7n\xf6U>\xc6\xc8\x13<\xae9\x92\x0f-\xd1\xc4\xea\xe4=h;\xa7awo'
b'n\x1d\xb6A"\xadc>$>\xb5\xc8^gipg\xbf~\x16\xf5\x85NW#\xbd\xc8\'uwfv'
b't\xc7\xe9\xb4XY\x1bX\xee?T\xe85edxw=\xbcY\x96\x17*\xe5N>P\xc9Gzppaydi'
b'\xbf\xe4\xa7\xe1\x1d\x00\x88l\x85EJ,')
Результат разбора:
'A1': {'B1': 0.6177673066178906,
{'B2': 63061,
'B3': 0.38824519515037537,
'B4': 15534},
'A2': 54,
'A3': [{'C1': 965873453,
'C2': 3519343332,
'C3': 0.05669751390814781,
'C4': 'awon'},
'C1': 498483490,
{'C2': 2908962340,
'C3': 0.35504430532455444,
'C4': 'gipg'},
'C1': -1082255627,
{'C2': 2236503843,
'C3': -0.09773150831460953,
'C4': 'wfvt'},
'C1': -940985256,
{'C2': 1494964462,
'C3': 0.8316681981086731,
'C4': 'edxw'},
'C1': 1035753878,
{'C2': 388687182,
'C3': 0.2038928121328354,
'C4': 'zppa'}],
'A4': 'ydi',
'A5': -17274,
'A6': [1863, 62584, 6755, 62934, 24087, 60178, 52977],
'A7': 0.46525740912067093,
'A8': {'D1': -0.6454930845686824, 'D2': 2235910700}}
Задача №12
Реализовать разбор двоичного формата данных. Данные начинаются с сигнатуры 0x51 0x54 0x42 0xe1
, за которой следует структура
A. Порядок байт: от старшего к младшему. Адреса указаны в виде смещений от начала данных. В решении предлагается использовать модуль
struct.
Структура A:
Поле | Описание |
---|---|
1 | Массив int64, размер 4 |
2 | double |
3 | float |
4 | int32 |
5 | Структура B |
6 | Массив структур E, размер 3 |
7 | int64 |
8 | Структура F |
Структура B:
Поле | Описание |
---|---|
1 | Адрес (uint32) структуры C |
2 | uint16 |
3 | uint8 |
4 | double |
5 | uint32 |
Структура C:
Поле | Описание |
---|---|
1 | Структура D |
2 | int64 |
3 | uint32 |
4 | Массив int8, размер 2 |
Структура D:
Поле | Описание |
---|---|
1 | uint32 |
2 | double |
3 | int32 |
4 | uint32 |
5 | int32 |
6 | uint64 |
Структура E:
Поле | Описание |
---|---|
1 | uint8 |
2 | int8 |
Структура F:
Поле | Описание |
---|---|
1 | int16 |
2 | double |
3 | double |
4 | int8 |
5 | Массив uint8, размер 6 |
Ниже показаны примеры разбора двоичного формата.
Пример 1
Двоичные данные:
b'QTB\xe1\xad\xca\xa1w\x81\xeb\xc9\xd9\xc7=UXs@GYK\x143\x115"S\xd2?M\x88q'
(b'\x8ft\xc8\x8d?\xee\xbc\x9b><!\xae?9\x1dm\xde\xbe\xb8\x17\x00\x00\x00n'
b'\xb0\x18\x1e?\xd9Y\x13\xa2\xd8\xb3h#fQ$\x87\xd3\xad]\xc9|_ho2Waz\t\x12\x8b?'
b'\xd4\x02x,C\xd7\xe0?\xd0\xeb`\x1b\xdd\xf0P\xbe\xec8Z\xb0\xc7\x19;\x8b'
b'\xb4\xf3\xbf\xee\x15R<\xe0g\xa6\xbb\x97<\x97l\x1d\xc5_\xdd\xeeM\xd8\xf8\xfb'
b'\xe1\x1a\x00y\x91\x1e\xf9\x9d6tR\xb0\xa2\xf3M\x89\xb9[]r')
Результат разбора:
'A1': [-5923744825199572519,
{-4090019048203466919,
5410005201377711058,
4561452018915657869],
'A2': 0.9605232444310354,
'A3': 0.723105251789093,
'A4': -557926377,
'A5': {'B1': {'C1': {'D1': 999011571,
'D2': -0.940102690600942,
'D3': -1147716457,
'D4': 1813890399,
'D5': -571585064,
'D6': 17941181042353869086},
'C2': -460151713690508557,
'C3': 1300871515,
'C4': [93, 114]},
'B2': 45080,
'B3': 30,
'B4': 0.39606181052186296,
'B5': 593908004},
'A6': [{'E1': 135, 'E2': -45}, {'E1': 173, 'E2': 93}, {'E1': 201, 'E2': 124}],
'A7': 6874867093186116105,
'A8': {'F1': 4747,
'F2': 0.3126507217669978,
'F3': 0.2643661758554616,
'F4': -66,
'F5': [236, 56, 90, 176, 199, 25]}}
Пример 2
Двоичные данные:
b'QTB\xe1\xf5\xea\x97ZQ\xf3\xe8;R_\xa4).U\x0e\x02\xfd\xe2\x98*R\x81\x1b\xdb'
(b'n\xd3\xe8\xfb\xe6:\x0c\xea\xbf\xe6\x85\n\xd1\x92\x90\x90>DDZX\xe2\x8c\xe2'
b'\x00\x00\x00n\x1b5\xf4\xbff\xae\x8e"3p\x00\xf3y\xed\xba&\xc1\xf6Fv\x19R\xcb5'
b'F\xa1\xdeG.\x86\xcd\xbf\xef\x96*\x03g\xc3\x9e?\xbc\x96\xb6\x06iA\x90\xab'
b'\r\xb0\xb5@o\x0fV\x987r?\xe6\xfc\xd9!\xc1\xf5\xa8\x14\xcf\xbdh\x1et'
b'\xe3]+\xace"\x97\x85\x81f\xfew?F\xde\xb9\xc2\x7f\x13\x18\xcb\xa7\x9d\x91'
b'X\x8cg\xc2')
Результат разбора:
'A1': [-726601975689123781,
{5935643330675543554,
-152392129836934181,
7985982732855020778],
'A2': -0.7037405102933167,
'A3': 0.19166699051856995,
'A4': 1491242210,
'A5': {'B1': {'C1': {'D1': 1452816242,
'D2': 0.7183652552918618,
'D3': 349158760,
'D4': 510976861,
'D5': 732718370,
'D6': 10918275150985510726},
'C2': -2397671475561051225,
'C3': 2643548300,
'C4': [103, -62]},
'B2': 6965,
'B3': 244,
'B4': -0.002768781284983035,
'B5': 4084854202},
'A6': [{'E1': 38, 'E2': -63}, {'E1': 246, 'E2': 70}, {'E1': 118, 'E2': 25}],
'A7': 5965920708862035758,
'A8': {'F1': -31027,
'F2': -0.9870805803785634,
'F3': 0.11167466789743785,
'F4': -85,
'F5': [13, 176, 181, 64, 111, 15]}}
Задача №12
Реализовать разбор двоичного формата данных. Данные начинаются с сигнатуры 0x56 0x4b 0x4d
, за которой следует структура A.
Порядок байт: от младшего к старшему. Адреса указаны в виде смещений от начала данных. В решении предлагается использовать модуль
struct.
Структура A:
Поле | Описание |
---|---|
1 | Структура B |
2 | Адрес (uint16) структуры D |
Структура B:
Поле | Описание |
---|---|
1 | int32 |
2 | Массив структур C, размер 2 |
Структура C:
Поле | Описание |
---|---|
1 | int64 |
2 | Размер (uint16) и адрес (uint32) массива uint8 |
3 | Размер (uint16) и адрес (uint16) массива int8 |
4 | Размер (uint32) и адрес (uint16) массива uint64 |
5 | uint64 |
6 | uint64 |
Структура D:
Поле | Описание |
---|---|
1 | int8 |
2 | double |
3 | int32 |
4 | int16 |
Ниже показаны примеры разбора двоичного формата.
Пример 1
Двоичные данные:
b'VKMMMz&\x98\x87\x9dZyh\x8c\xf6\x04\x00Y\x00\x00\x00\x02\x00]\x00\x04\x00\x00'
(b'\x00_\x00\x93\xf7~\xbbL\xc6WK\x80\xf9\x8a,\xb2\xec\x9a\xbe\xc8%\xf4?F'
b'\x9e\x891\x02\x00\x7f\x00\x00\x00\x02\x00\x81\x00\x04\x00\x00'
b'\x00\x83\x00\xb3`\xb4d\xf2tO\xbe\x95A\t\x8a\x03\x07CJ\xa3\x00\xb4\xcf\x87'
b'\x04\xff6\x9d\x19>\xacW\xac#O\xbd\x04\x98\x98@\x04\x85o\xfd?\x92\xc7I'
b'\xa0\x8a\xce\xe1GV\xba\xdd\xc2\x9d|\x98z\x1c1\x10x\xca1|\xa0\xf4\xd1E'
b'y\x14\xc2\x1d\xd0\x8c\xe1\xb5\xc7\xfc\xdd\xbf\xe5T3\x8ddy>?\x8a]n,@\xd9B\xce'
b'\x10#\x98?W\xabO\xf6\xaeZ')
Результат разбора:
'A1': {'B1': 645549389,
{'B2': [{'C1': -681054573219182696,
'C2': [180, 207, 135, 4],
'C3': [-1, 54],
'C4': [5702591045733063069,
8035833785597035709,
14882884157340532733,
8979547489616414689],
'C5': 5429025908683896723,
'C6': 13734550263615388032},
'C1': 3569558204225693128,
{'C2': [152, 122],
'C3': [28, 49],
'C4': [15128893503516080144,
16252593981502028101,
3698833806203865013,
7952664521241879693],
'C5': 13713307974786900147,
'C6': 5351128494028439957}]},
'A2': {'D1': 44, 'D2': 0.023571264828853744, 'D3': -162550953, 'D4': 23214}}
Пример 2
Двоичные данные:
b'VKM\x8a r\xfdpu-|\xf6q\xd1\xef\x04\x00Y\x00\x00\x00\x02\x00]\x00\x02\x00\x00'
(b'\x00_\x00\xf6\xb06X\xbfi"\xdb\x0b\tD"\xa0\xee;t\\vr\xf8\xba|\xb3\xec\x03'
b'\x00o\x00\x00\x00\x02\x00r\x00\x03\x00\x00\x00t\x00\xc2"\xfe\x12\x00'
b'\xe9\xc7\xe3=\x10\xe6%\x95\xe4y\x90\x8c\x00?\x08\xc3#]\xc2\xaa\xda\x1b\xe9Z'
b'\x17\x99\x1a\xb3\x96\xe8\xea0(\xb3\xb8\x8d\x1f\xcd\xc9\r=\xaa\xe6\xd3'
b'\xa2\xf9$\x91+\xf6\x98\x0c\x1f\x83?\xc3\x99B\xef\xefA3G\xb5F\xf8\xc9\xe4'
b'!\xc9\xb6\xef\xbfd\xf9\n+\xefL')
Результат разбора:
'A1': {'B1': -42852214,
{'B2': [{'C1': -1166025525053000336,
'C2': [63, 8, 195, 35],
'C3': [93, -62],
'C4': [1916588795648268970, 13309025514374600371],
'C5': 15790299514054029558,
'C6': 8375550303562631435},
'C1': -1390630717453339044,
{'C2': [141, 31, 205],
'C3': [-55, 13],
'C4': [10458758712396261949,
14069107930307294763,
13062465602502738585],
'C5': 16413343553502978754,
'C6': 10410603342880706621}]},
'A2': {'D1': 70, 'D2': -0.9910627042757474, 'D3': 722139492, 'D4': 19695}}
Задача №12
Реализовать разбор двоичного формата данных. Данные начинаются с сигнатуры 0xa3 0x59 0x55 0x55 0x4a
, за которой следует
структура A. Порядок байт: от младшего к старшему. Адреса указаны в виде смещений от начала данных. В решении предлагается использовать
модуль struct.
Структура A:
Поле | Описание |
---|---|
1 | Структура B |
2 | int8 |
3 | Размер (uint32) и адрес (uint16) массива int64 |
4 | double |
5 | Структура D |
6 | int16 |
7 | Массив uint16, размер 3 |
Структура B:
Поле | Описание |
---|---|
1 | Массив структур C, размер 2 |
2 | uint8 |
3 | double |
4 | double |
5 | uint16 |
Структура C:
Поле | Описание |
---|---|
1 | uint64 |
2 | double |
3 | Массив uint8, размер 4 |
4 | double |
5 | uint8 |
6 | uint32 |
7 | int32 |
Структура D:
Поле | Описание |
---|---|
1 | uint8 |
2 | Массив double, размер 3 |
3 | float |
Ниже показаны примеры разбора двоичного формата.
Пример 1
Двоичные данные:
b'\xa3YUUJ\xf20\xd6\x97\xf9\xd2P@\x82\xfb\x01\xa6\x95\x9e\xec\xbf{\xf7{\xc7h:t'
(b'\xa1^\x0c\xef\xbf\xc0\xc3[\x9b\x8f\x94\xa1\xe0\x0e\xb9B\xaf\x89\xfc#'
b'H\x02,\xb6\xb0K\x86\x94\xe8?\xfc\xd7\xfeC,\xe4\n\xc9I5\xe2\xbfS '
b'r\xcc\x7f\xecs\xe76@\x00\xd8\xe4\xdf\xe5e\xe2\xbf\n\x82\x18\xaa'
b'\xa0\x0b\xe1\xbfW\xb6\x1b\x02\x00\x00\x00\x96\x00\x08\xf7\xf2'
b'\x10\xa6\xa2\xe1\xbf^\xb0\xac\xc3:\x95\x9b\xc4?\xacF\xac\x03\x15}'
b'\xe6\xbf\xb0\xdc\xae!\r3\xdf?*L\x15\xbf\xfe%\x18\xcc\xa8\x8aW\x87\x14`'
b'\xa8\x9dX/\x94\x01D\xca\x00]\xd2\x0c\xa8\x07')
Результат разбора:
'A1': {'B1': [{'C1': 4634435986000326898,
{'C2': -0.8943584673250913,
'C3': [123, 247, 123, 199],
'C4': -0.9702599671744112,
'C5': 192,
'C6': 2409323459,
'C7': 249602452},
'C1': 164420953947718329,
{'C2': 0.7681304434133316,
'C3': [252, 215, 254, 67],
'C4': -0.5690049101459684,
'C5': 83,
'C6': 2144104992,
'C7': 921138156}],
'B2': 64,
'B3': -0.5749387143066542,
'B4': -0.5326693842108068,
'B5': 46679},
'A2': 27,
'A3': [113767948239790100, 551705051995884100],
'A4': -0.5511045771633869,
'A5': {'D1': 94,
'D2': [0.16099801415780268, -0.702768809484231, 0.48749092378006775],
'D3': -0.5831934213638306},
'A6': 9726,
'A7': [52248, 35496, 34647]}
Пример 2
Двоичные данные:
b'\xa3YUUJ\xc6\xfd\x0f\xb8\xd1\xf1\xe6\xb7`f )\x95J\xd1\xbf{\x88\xf3'
(b'\x842\x97\x1b\x08a\xbe\xe1?\x071\x89\xb4\x11\xe0\xeb%\xe7\xb4}s\xae\xcb>'
b'\x9e^ \xafv\xf3S\xe5\xcf\xbfD>\xeb\xa7\xe8lycD(\xd5?\xa2\xdd\x7f\x9cks'
b'\x06\xe6\xe3\xbcr\x07!/\xf5\x1b\xe7\xbf\xa0\xcf\x16\x98\xf1\xf0\xc9\xbf'
b'\xd2\xa8\xb8\x02\x00\x00\x00\x96\x00XI\xeak\x88.\xc5?2\xe6\x18d\x8aj\x9a'
b'\xe4\xbf\x00x3\xe8\x97\xcd\xe2?\xc4|M\xed\xc3\xbe\xd7\xbf\x90\x0e'
b'\x8d<\xa3\xa2\xe58!\xc1,yw\xd5c\x8bI\xe5\xe9\x86\xb5\xe7\x13\xc8\x87\x06'
b'\xe1\xdd')
Результат разбора:
'A1': {'B1': [{'C1': 13251544836622777798,
{'C2': -0.27017716423288185,
'C3': [123, 136, 243, 132],
'C4': 0.554489627681255,
'C5': 7,
'C6': 297044273,
'C7': -416945184},
'C1': 6817955930411597236,
{'C2': -0.24918603313323562,
'C3': [68, 62, 235, 167],
'C4': 0.3305827113560569,
'C5': 162,
'C6': 1805418461,
'C7': -471464333}],
'B2': 188,
'B3': -0.7221628113259,
'B4': -0.20266551901079044,
'B5': 43218},
'A2': -72,
'A3': [-8725190699019676297, -2458676741320480843],
'A4': 0.1654825713090513,
'A5': {'D1': 50,
'D2': [-0.6438496306371035, 0.5875968489815477, -0.3710183923157724],
'D3': 0.017218858003616333},
'A6': -23901,
'A7': [14565, 49441, 31020]}
Задача №12
Реализовать разбор двоичного формата данных. Данные начинаются с сигнатуры 0x4d 0x55 0x50 0x71
, за которой следует структура
A. Порядок байт: от старшего к младшему. Адреса указаны в виде смещений от начала данных. В решении предлагается использовать модуль
struct.
Структура A:
Поле | Описание |
---|---|
1 | int32 |
2 | int16 |
3 | int16 |
4 | Размер (uint32) и адрес (uint32) массива адресов (uint32) структур B |
5 | Массив адресов (uint16) структур C, размер 2 |
6 | Структура D |
7 | Массив float, размер 5 |
Структура B:
Поле | Описание |
---|---|
1 | float |
2 | uint8 |
3 | int16 |
Структура C:
Поле | Описание |
---|---|
1 | double |
2 | uint64 |
3 | Массив uint8, размер 5 |
Структура D:
Поле | Описание |
---|---|
1 | int32 |
2 | uint8 |
Ниже показаны примеры разбора двоичного формата.
Пример 1
Двоичные данные:
b'MUPqW\x12yFB\xca\x16\xb5\x00\x00\x00\x03\x00\x00\x00F\x00R\x00gM\xe8\x81`'
(b'\xfd\xbfo\x10\xec\xbf^\x0b\xf2?OGz=\xcc\xaa?\xbf7Z\xdf\xbe\xdc\x17'
b'\xaf\xbc\xf0H?I\xda\xc8`\xaa\x92\xbd\xc3\xc6\x8d{.\xfc\x00\x00\x001\x00\x00'
b'\x008\x00\x00\x00??\xee\xd5X\xc5\x17\x99j\x87\xeb\xbb\xb0\x08\xb2\xd7;:\xcc'
b'\x0f!\xca?\xb7\xb9|yr9`\x1a\xe0\xa7`Q\xbf]\x93:\r<\xc9\xf1')
Результат разбора:
'A1': 1460828486,
{'A2': 17098,
'A3': 5813,
'A4': [{'B1': -0.4298681914806366, 'B2': 188, 'B3': -4024},
'B1': 0.7884945869445801, 'B2': 96, 'B3': -21870},
{'B1': -0.09559354931116104, 'B2': 123, 'B3': 12028}],
{'A5': [{'C1': 0.9635433053452236,
'C2': 9794128179381851963,
'C3': [58, 204, 15, 33, 202]},
'C1': 0.09267404522890876,
{'C2': 1936731871899508115,
'C3': [58, 13, 60, 201, 241]}],
'A6': {'D1': 1307083104, 'D2': 253},
'A7': [-0.933851957321167,
-0.8673697710037231,
0.8096843957901001,
0.09993409365415573,
-0.7162303328514099]}
Пример 2
Двоичные данные:
b'MUPqJ\xcau\x95\xae:\xd8S\x00\x00\x00\x05\x00\x00\x00T\x00h\x00}'
(b'\xac\x17\xe1\x0e|>\x98\xbf\xe3\xbfk\x9d\x81?n\x12\xf1>\x8a\xc2U\xbd\xf7\xd1'
b'\xd0\xbf\x03V\xc8O\x81\xb9?j`k\x02\xf1\x9f>\x93\xb5\x06\xab\xfc\xd2\xbc\x7f'
b'\xcd\x9a\xdb?\x8a\xbf!< \xa9C\x87\x00\x00\x001\x00\x00\x008\x00\x00\x00?'
b'\x00\x00\x00F\x00\x00\x00M\xbf\xe1\xacIh\x91j\xc0V"9Z\xfc\xfd\xdb\xe8'
b'\x12\\r=\xa4?\xe4\x18\xb2\x85 \x1f\n\xb8Q=\xc3\xdc|\xa2\xc0\x85\xac[, ')
Результат разбора:
'A1': 1254782357,
{'A2': -20934,
'A3': -10157,
'A4': [{'B1': -0.5130429267883301, 'B2': 79, 'B3': -32327},
'B1': 0.915533721446991, 'B2': 2, 'B3': -3681},
{'B1': 0.2884904742240906, 'B2': 171, 'B3': -814},
{'B1': -0.015612984076142311, 'B2': 219, 'B3': 16266},
{'B1': -0.6298236846923828, 'B2': 169, 'B3': 17287}],
{'A5': [{'C1': -0.5522810976356922,
'C2': 6206586299424300008,
'C3': [18, 92, 114, 61, 164]},
'C1': 0.6280148124796778,
{'C2': 13281464687519376064,
'C3': [133, 172, 91, 44, 32]}],
'A6': {'D1': -1407721202, 'D2': 124},
'A7': [0.29833897948265076,
-0.9203720688819885,
0.9299765229225159,
0.27101388573646545,
-0.12100565433502197]}
Задача №12
Реализовать разбор двоичного формата данных. Данные начинаются с сигнатуры 0x54 0x4b 0x52 0x52 0x7c
, за которой следует
структура A. Порядок байт: от старшего к младшему. Адреса указаны в виде смещений от начала данных. В решении предлагается использовать
модуль struct.
Структура A:
Поле | Описание |
---|---|
1 | Массив структур B, размер 3 |
2 | Структура E |
Структура B:
Поле | Описание |
---|---|
1 | int16 |
2 | Массив char, размер 8 |
3 | uint16 |
4 | Адрес (uint32) структуры C |
5 | int8 |
6 | Адрес (uint32) структуры D |
7 | float |
Структура C:
Поле | Описание |
---|---|
1 | uint16 |
2 | uint16 |
3 | Массив int8, размер 7 |
4 | Размер (uint32) и адрес (uint32) массива int8 |
5 | float |
Структура D:
Поле | Описание |
---|---|
1 | uint16 |
2 | Массив int8, размер 3 |
3 | uint64 |
Структура E:
Поле | Описание |
---|---|
1 | uint16 |
2 | uint32 |
3 | uint32 |
4 | int64 |
Ниже показаны примеры разбора двоичного формата.
Пример 1
Двоичные данные:
b'TKRR|\xee\x06bfcdpcjj7\xad\x00\x00\x00d\x13\x00\x00\x00{\xbf\x02'
(b'\xb1\xec\xc9\xa9yxlihmnm\xc0r\x00\x00\x00\x8a8\x00\x00\x00\xa1\xbf|J(p'
b'\x9bfbimbthw\xf6\x1c\x00\x00\x00\xb0I\x00\x00\x00\xc7>x\xcc>\xa4\xaej\xc6'
b'\x11\x02y\x7f\xda\xa6I\xd6Y\xa2Y\xefP\xceBNr\x1d\xde\x8c>\x93\xa8W'
b'\x0f\xe8X\x00\x00\x00\x02\x00\x00\x00b<\xf8\xce7\xd3E\xa1U*\x9b\xb3u\xb8'
b'S{\xa4\x1f\x92\x9f\xd6q\xc4U\xec\x1a\x0b2W\xe5\xab\x00\x00\x00'
b'\x02\x00\x00\x00\x88\xbb#`\xa5\xf0\xe7\xdei\x87\x92\xce\x9d\xc4&\xea'
b"E\xd5\xe0\xfb\x18\x07|\xa6\x1e\x92y'\xe8\xb9\x12\x00\x00\x00\x02\x00"
b'\x00\x00\xae\xbeG\xd7\xa5\x91\xef\xcdDW\xe2o\x84\xb0\xb4.\x15\xd3')
Результат разбора:
'A1': [{'B1': -4602,
{'B2': 'bfcdpcjj',
'B3': 14253,
'B4': {'C1': 29213,
'C2': 56972,
'C3': [62, -109, -88, 87, 15, -24, 88],
'C4': [66, 78],
'C5': 0.03037176840007305},
'B5': 19,
'B6': {'D1': 54085, 'D2': [-95, 85, 42], 'D3': 11219440531245081631},
'B7': -0.5105273723602295},
'B1': -13911,
{'B2': 'yxlihmnm',
'B3': 49266,
'B4': {'C1': 54897,
'C2': 50261,
'C3': [-20, 26, 11, 50, 87, -27, -85],
'C4': [-110, -97],
'C5': -0.0024929430801421404},
'B5': 56,
'B6': {'D1': 61671,
'D2': [-34, 105, -121],
'D3': 10578566040531912149},
'B7': -0.985506534576416},
'B1': 28827,
{'B2': 'fbimbthw',
'B3': 63004,
'B4': {'C1': 6151,
'C2': 31910,
'C3': [30, -110, 121, 39, -24, -71, 18],
'C4': [-32, -5],
'C5': -0.19515855610370636},
'B5': 73,
'B6': {'D1': 37359, 'D2': [-51, 68, 87], 'D3': 16316405869458626003},
'B7': 0.24296662211418152}],
'A2': {'E1': 42158,
'E2': 1791365378,
'E3': 2038422182,
'E4': 5320538563613249742}}
Пример 2
Двоичные данные:
b'TKRR|\xe6\xf9tlrjywqz\x83\x9c\x00\x00\x00d`\x00\x00\x00{\xbe\xfeyL\xef?ohfv'
(b'lpyf0\xf5\x00\x00\x00\x8a\x82\x00\x00\x00\xa1\xbf\x1d\xd3\x96\x18\xd7yhrketb'
b'i\x9c\x8a\x00\x00\x00\xb0\xd6\x00\x00\x00\xc7\xbf0^D;\x02\x9b\xe8'
b'\x0c\xd7\x13\x8a\xed\xc9 \t\xfb\x03\xb0\'?\xe5\xcd\x8ec\x87/N\x1b",C'
b'9\xd3\x07\x00\x00\x00\x02\x00\x00\x00b>\xd1^\xc3\x12\xd6!\x1a\x95\x83lq\x87'
b'\x1d\xeb\x8f\xde\x151\xae\xe1\x92\x1e\xa7y\x01\xe2I\xf1x\x00\x00\x00'
b'\x02\x00\x00\x00\x88\xbfaG\xc21\x8a\x05\xdb8\xc1\xd3q\x98\x07\x89'
b'\xff\xac\x0c\xed\x83\xaa\xda\xf5\x05o\x9c\xc4!\x8e\xac\x00\x00\x00\x02\x00'
b'\x00\x00\xae=\xcb\x11$\xde\x1f\xd6\xc9\xad!\xe6\xa1.AV1\x02')
Результат разбора:
'A1': [{'B1': -6407,
{'B2': 'tlrjywqz',
'B3': 33692,
'B4': {'C1': 25479,
'C2': 12110,
'C3': [27, 34, 44, 67, 57, -45, 7],
'C4': [-51, -114],
'C5': 0.4089260995388031},
'B5': 96,
'B6': {'D1': 4822, 'D2': [33, 26, -107], 'D3': 9470068941589811166},
'B7': -0.4970191717147827},
'B1': -4289,
{'B2': 'ohfvlpyf',
'B3': 12533,
'B4': {'C1': 44769,
'C2': 37406,
'C3': [-89, 121, 1, -30, 73, -15, 120],
'C4': [21, 49],
'C5': -0.8800011873245239},
'B5': -126,
'B6': {'D1': 12682, 'D2': [5, -37, 56], 'D3': 13966631767181492140},
'B7': -0.6165097951889038},
'B1': 6359,
{'B2': 'yhrketbi',
'B3': 40074,
'B4': {'C1': 33706,
'C2': 56053,
'C3': [5, 111, -100, -60, 33, -114, -84],
'C4': [12, -19],
'C5': 0.0991537868976593},
'B5': -42,
'B6': {'D1': 56863, 'D2': [-42, -55, -83], 'D3': 2442817067931808002},
'B7': -0.6889383792877197}],
'A2': {'E1': 15106,
'E2': 2615676119,
'E3': 327871945,
'E4': 2308652277262925797}}