Добавил:
ivanov666
Опубликованный материал нарушает ваши авторские права? Сообщите нам.
Вуз:
Предмет:
Файл:Простой Python просто с нуля
.pdf
Ƚɥɚɜɚ ɞɟɫɹɬɚɹ. Ɏɚɣɥɵ ɛɢɧɚɪɧɵɟ
Ȼɢɧɚɪɧɵɟ ɮɚɣɥɵ ɧɚɫɬɨɥɶɤɨ ɜɚɠɧɵ, ɱɬɨ ɩɨɹɜɢɥɚɫɶ ɧɟɨɬɥɨɠɧɚɹ ɧɭɠɞɚ
ɜɵɞɟɥɢɬɶ ɢɯ ɜ ɨɬɞɟɥɶɧɭɸ ɝɥɚɜɭ. ȿɫɥɢ ɜɵ ɩɪɨɱɢɬɚɥɢ ɜɫɺ ɩɪɟɞɵɞɭɳɟɟ – ɜɫɺ
ɩɪɟɞɵɞɭɳɟɟ ɦɨɠɧɨ ɡɚɛɵɬɶ. ɒɭɱɭ, ɤɨɧɟɱɧɨ. Ɂɚɛɵɜɚɬɶ ɧɢɱɟɝɨ ɧɟ ɧɚɞɨ,
ɥɸɛɵɟ ɡɧɚɧɢɹ ɛɟɫɰɟɧɧɵ. Ɍɟɦ ɧɟ ɦɟɧɟɟ, ɜɫɟ ɷɬɢ ɮɚɣɥɵ – ɷɬɨ ɧɟ ɫɨɜɫɟɦ
ɧɚɫɬɨɹɳɢɟ ɮɚɣɥɵ. ɇɚɫɬɨɹɳɢɟ ɮɚɣɥɵ – ɬɟ, ɜ ɤɨɬɨɪɵɟ ɩɢɲɭɬɫɹ ɛɢɧɚɪɧɵɟ
ɞɚɧɧɵɟ, ɤɚɤ ɨɧɢ ɟɫɬɶ. ɋɤɨɪɟɟ ɜɫɟɝɨ, ɬɚɤɚɹ ɮɨɪɦɭɥɢɪɨɜɤɚ ɜɚɦ ɧɟɩɨɧɹɬɧɚ –
ɧɨ ɹ ɨɛɴɹɫɧɸ. ȿɫɥɢ ɜɵ ɩɪɨɩɭɫɬɢɥɢ, ɩɨ ɦɨɟɦɭ ɫɨɜɟɬɭ, ɩɪɟɞɵɞɭɳɢɟ ɪɚɡɞɟɥɵ
ɢ ɩɟɪɟɲɥɢ ɫɪɚɡɭ ɫɸɞɚ, ɬɨ ɜɚɦ ɛɭɞɟɬ ɞɚɠɟ ɩɪɨɳɟ.
ɉɨɜɬɨɪɸ ɟɳɺ ɪɚɡ – ɛɢɧɚɪɧɵɣ ɮɚɣɥ ɚɛɫɨɥɸɬɧɨ ɭɧɢɜɟɪɫɚɥɟɧ, ɟɝɨ ɦɨɠɧɨ
ɫɨɜɟɪɲɟɧɧɨ ɨɞɧɨɡɧɚɱɧɨ ɩɪɨɱɟɫɬɶ ɜ ɥɸɛɨɣ ɨɩɟɪɚɰɢɨɧɧɨɣ ɫɢɫɬɟɦɟ ɢ
ɩɪɢɦɟɧɹɹ ɥɸɛɨɣ ɹɡɵɤ ɩɪɨɝɪɚɦɦɢɪɨɜɚɧɢɹ.
# ɟɫɬɶ ɧɸɚɧɫɵ, ɤɨɧɟɱɧɨ
ȼ ɪɚɡɧɵɯ ɹɡɵɤɚɯ ɢ ɧɚ ɪɚɡɧɵɯ ɩɥɚɬɮɨɪɦɚɯ ɪɚɡɧɢɰɚ, ɤɨɧɟɱɧɨ, ɫɨ ɜɪɟɦɟɧɟɦ
ɜɵɥɟɡɚɟɬ. Ʉ ɩɪɢɦɟɪɭ, ɟɫɬɶ ɦɢɧɢɦɭɦ ɞɜɚ ɮɨɪɦɚɬɚ ɡɚɩɢɫɢ ɩɥɚɜɚɸɳɢɯ ɱɢɫɟɥ.
ɇɨ ɤ ɬɨɦɭ ɦɨɦɟɧɬɭ, ɤɨɝɞɚ ɩɟɪɟɞ ɜɚɦɢ ɜɨɡɧɢɤɧɭɬ ɬɚɤɢɟ ɩɪɨɛɥɟɦɵ, ɜɵ ɭɠɟ
ɛɭɞɟɬɟ ɡɧɚɬɶ, ɤɚɤ ɫ ɧɢɦɢ ɛɨɪɨɬɶɫɹ.
# ɤɨɧɟɰ ɇɸɚɧɫɨɜ
ɏɨɬɹ ɹ ɫɱɢɬɚɸ, ɱɬɨ ɛɢɧɚɪɧɵɟ ɞɚɧɧɵɟ – ɷɬɨ ɝɥɚɜɧɵɣ, ɨɫɧɨɜɧɨɣ ɢ ɛɚɡɨɜɵɣ
ɮɨɪɦɚɬ ɡɚɩɢɫɢ ɢ ɱɬɟɧɢɹ ɮɚɣɥɨɜ, ɉɢɬɨɧ ɫɱɢɬɚɟɬ ɩɨ-ɞɪɭɝɨɦɭ. ɋ ɬɨɱɤɢ
ɡɪɟɧɢɹ ɉɢɬɨɧɚ, ɷɬɨ ɮɨɪɦɚɬ ɜɫɩɨɦɨɝɚɬɟɥɶɧɵɣ ɢ ɪɟɚɥɢɡɨɜɚɧ
ɫɨɨɬɜɟɬɫɬɜɟɧɧɨ, ɬɨ ɟɫɬɶ ɧɟ ɨɱɟɧɶ. ɂ ɟɳɺ – ɟɫɥɢ ɜɵ ɛɭɞɟɬɟ ɱɢɬɚɬɶ ɤɧɢɝɢ ɩɨ
ɉɢɬɨɧɭ ɢ ɞɚɠɟ ɟɝɨ ɨɮɢɰɢɚɥɶɧɭɸ ɢ ɩɨɥɭɨɮɢɰɢɚɥɶɧɭɸ ɞɨɤɭɦɟɧɬɚɰɢɸ, ɬɨ
ɜɟɡɞɟ ɜɫɬɪɟɬɢɬɟ ɭɬɜɟɪɠɞɟɧɢɟ, ɱɬɨ ɷɬɨɬ ɦɟɬɨɞ ɡɚɩɢɫɢ ɩɪɟɞɧɚɡɧɚɱɟɧ ɞɥɹ
ɨɛɦɟɧɚ ɞɚɧɧɵɯ ɫ ɹɡɵɤɚɦɢ C ɢ C++. ɗɬɨ, ɤɨɧɟɱɧɨ, ɬɚɤ – ɧɨ ɧɟ ɬɨɥɶɤɨ. ɗɬɨ
ɞɚɺɬ ɜɨɡɦɨɠɧɨɫɬɶ ɨɛɦɟɧɢɜɚɬɶɫɹ ɞɚɧɧɵɦɢ ɫ ɤɟɦ ɭɝɨɞɧɨ ɢ ɫ ɱɟɦ ɭɝɨɞɧɨ.
Ɂɚɩɢɫɶ ɢ ɱɬɟɧɢɟ ɛɢɧɚɪɧɨɝɨ ɮɚɣɥɚ
Ɋɟɲɢɦ ɩɪɨɫɬɭɸ ɢ ɛɟɫɫɦɵɫɥɟɧɧɭɸ ɩɪɚɤɬɢɱɟɫɤɢ ɡɚɞɚɱɭ, ɩɨɞɯɨɞɹɳɭɸ ɞɥɹ
ɭɱɟɛɧɵɯ ɰɟɥɟɣ. ȿɫɬɶ ɪɚɞɢɭɫ ɤɪɭɝɚ – ɰɟɥɨɟ ɱɢɫɥɨ. ɋɱɢɬɚɟɦ ɩɥɨɳɚɞɶ ɤɪɭɝɚ –
ɱɢɫɥɨ, ɧɟɢɡɛɟɠɧɨ, ɞɪɨɛɧɨɟ. Ɂɚɩɢɫɵɜɚɟɦ ɢ ɬɨ, ɢ ɞɪɭɝɨɟ ɜ ɛɢɧɚɪɧɵɣ ɮɚɣɥ.
Ɂɚɬɟɦ ɱɢɬɚɟɦ. ɋɧɚɱɚɥɚ ɡɚɩɢɫɶ, ɩɨɞɪɨɛɧɨ ɢ ɫ ɤɨɦɦɟɧɬɚɪɢɹɦɢ:
R = 10
S = 3.1415 * R**2
191
print R, S
import struct
f = open( 'd:/square.bin', 'wb')
data = struct.pack('<i4',R)
f.write(data)
data = struct.pack('<f4',S)
f.write(data)
f.close()
ɋɧɚɱɚɥɚ ɨɛɹɡɚɬɟɥɶɧɨɟ
import struct – ɩɨɞɤɥɸɱɚɟɦ ɜɧɟɲɧɢɣ ɦɨɞɭɥɶ. ɂɦɹ
ɮɚɣɥɚ, ɪɚɡɭɦɟɟɬɫɹ, ɫɨɜɟɪɲɟɧɧɨ ɩɪɨɢɡɜɨɥɶɧɨ. Ɍɨ, ɱɬɨ ɪɚɫɲɢɪɟɧɢɟ ɢɦɟɧɢ
ɢɦɟɧɧɨ
*.bin, ɧɢɤɚɤɨɣ ɪɨɥɢ ɧɟ ɢɝɪɚɟɬ. Ⱥ ɜɨɬ ɩɚɪɚɦɟɬɪ ‘wb’ ɨɱɟɧɶ ɜɚɠɟɧ.
ɂɦɟɧɧɨ ɨɧ ɭɤɚɡɵɜɚɟɬ ɧɚ ɬɨ, ɱɬɨ ɮɚɣɥ ɩɢɲɟɬɫɹ ɧɚ ɡɚɩɢɫɶ, ɱɬɨ ɜɚɦ ɭɠɟ
ɩɨɧɹɬɧɨ, ɢ ɱɬɨ ɮɚɣɥ ɛɢɧɚɪɧɵɣ. Ɍɟɩɟɪɶ ɨ ɝɥɚɜɧɨɦ, ɩɪɨɲɭ ɦɚɤɫɢɦɚɥɶɧɨ
ɫɨɫɪɟɞɨɬɨɱɢɬɶɫɹ. ȿɫɥɢ ɜɵ ɩɨɣɦɺɬɟ ɫɥɟɞɭɸɳɢɟ ɞɜɟ ɫɬɪɨɤɢ, ɬɨ ɜɵ ɩɨɣɦɺɬɟ
ɜɫɺ ɨ ɛɢɧɚɪɧɵɯ ɮɚɣɥɚɯ, ɹ ɧɟ ɲɭɱɭ, ɷɬɨ ɫɟɪɶɺɡɧɨ.
data = struct.pack('<i4',R)
f.write(data)
ȼ ɩɟɪɜɨɣ ɫɬɪɨɤɟ ɢɦɟɟɦ ɜɵɡɨɜ ɮɭɧɤɰɢɢ ɢɡ ɦɨɞɭɥɹ
Ɏɭɧɤɰɢɹ
pack, ɱɬɨ ɨɱɟɜɢɞɧɨ ɢɡ ɟɺ ɧɚɡɜɚɧɢɹ, ɩɚɤɭɟɬ. ɍ ɧɟɺ ɞɜɚ ɩɚɪɚɦɟɬɪɚ ɢ
struct, ɷɬɨ ɩɨɧɹɬɧɨ.
ɜɨɡɜɪɚɳɚɟɦɨɟ ɡɧɚɱɟɧɢɟ. ɇɚɱɧɺɦ ɫ ɫɚɦɨɝɨ ɩɪɨɫɬɨɝɨ – ɜɬɨɪɨɣ ɩɚɪɚɦɟɬɪ ɩɨ
ɢɦɟɧɢ
ȼɨɡɜɪɚɳɚɟɦɨɟ ɡɧɚɱɟɧɢɟ
ɩɚɪɚɦɟɬɪɚ
R – ɷɬɨ ɬɨ, ɱɬɨ ɧɚɞɨ ɭɩɚɤɨɜɚɬɶ. Ɍɟɩɟɪɶ ɧɟɦɧɨɝɨ ɫɥɨɠɧɟɟ.
data – ɷɬɨ ɬɨ, ɜɨ ɱɬɨ ɦɵ ɭɩɚɤɨɜɚɥɢ ɡɧɚɱɟɧɢɟ
R. Ʉɚɤɨɣ ɬɢɩ ɭ ɩɟɪɟɦɟɧɧɨɣ data ɢ ɱɬɨ ɜ ɬɨɱɧɨɫɬɢ ɭ ɧɟɺ ɜɧɭɬɪɢ,
ɧɚɦ ɫɨɜɟɪɲɟɧɧɨ ɧɟ ɢɧɬɟɪɟɫɧɨ. Ɉɧɚ ɟɫɬɶ, ɢ ɷɬɨ ɜɫɺ. ɉɨɤɚ ɢ ɩɨɱɬɢ.
Ɍɟɩɟɪɶ ɨ ɫɚɦɨɦ ɜɚɠɧɨɦ, ɨ ɩɟɪɜɨɦ ɩɚɪɚɦɟɬɪɟ ɮɭɧɤɰɢɢ
'<i4'. ȼɵɝɥɹɞɢɬ,
ɦɹɝɤɨ ɝɨɜɨɪɹ, ɧɟɜɪɚɡɭɦɢɬɟɥɶɧɨ. ɗɬɚ ɡɚɝɨɝɭɥɢɧɚ ɧɟ ɟɞɢɧɨɟ ɰɟɥɨɟ, ɧɟ
ɤɚɤɨɣ-ɬɨ ɢɟɪɨɝɥɢɮ, ɚ ɬɪɢ ɫɨɜɟɪɲɟɧɧɨ ɨɬɞɟɥɶɧɵɯ ɧɟɡɚɜɢɫɢɦɵɯ ɫɢɦɜɨɥɚ.
ɉɟɪɜɵɣ ɫɢɦɜɨɥ, ɤɨɬɨɪɵɣ ɡɧɚɤ ɦɟɧɶɲɟ, ɩɪɨɫɬɨ ɞɨɥɠɟɧ ɬɚɦ ɛɵɬɶ.
Ɂɚɩɨɦɧɢɬɟ ɢ ɜɫɟɝɞɚ ɟɝɨ ɩɢɲɢɬɟ. Ⱦɥɹ ɥɸɛɨɡɧɚɬɟɥɶɧɵɯ ɛɭɞɟɬ ɪɚɡɴɹɫɧɟɧɢɟ
ɞɚɥɶɲɟ. ɋɢɦɜɨɥ
i ɭɤɚɡɵɜɚɟɬ, ɱɬɨ ɦɵ ɯɨɬɢɦ ɭɩɚɤɨɜɚɬɶ ɢɦɟɧɧɨ ɰɟɥɨɟ ɱɢɫɥɨ.
ɐɢɮɪɚ 4 ɨɡɧɚɱɚɟɬ, ɱɬɨ ɦɵ ɯɨɬɢɦ ɭɩɚɤɨɜɚɬɶ ɟɝɨ ɜ ɱɟɬɵɪɟ ɛɚɣɬɚ. ɉɨɱɟɦɭ
ɢɦɟɧɧɨ ɜ ɱɟɬɵɪɟ, ɚ ɱɬɨ ɷɬɨ ɡɧɚɱɢɬ ɢ ɤɚɤ ɦɨɠɧɨ ɟɳɺ, ɜɵ ɦɨɠɟɬɟ ɩɪɨɱɢɬɚɬɶ ɜ
ɩɪɢɥɨɠɟɧɢɢ. Ɍɚɦ ɠɟ ɜɫɺ ɪɚɫɫɤɚɡɚɧɨ ɢ ɨ ɛɚɣɬɚɯ, ɧɚ ɜɫɹɤɢɣ ɫɥɭɱɚɣ. Ⱥ ɬɟɩɟɪɶ
ɨ ɫɚɦɨɦ ɝɥɚɜɧɨɦ – ɜɨɬ ɷɬɨ ɫɚɦɨɟ ɱɢɫɥɨ ɱɟɬɵɪɟ ɢ ɟɫɬɶ ɫɚɦɨɟ ɝɥɚɜɧɨɟ ɜɨ ɜɫɟɣ
192
ɷɬɨɣ ɨɩɟɪɚɰɢɢ. ȿɫɥɢ ɦɵ ɩɨɡɠɟ ɡɚɯɨɬɢɦ ɭɫɩɟɲɧɨ ɩɪɨɱɢɬɚɬɶ ɧɚɲ ɮɚɣɥ, ɬɨ
ɞɨɥɠɧɵ ɫɟɣɱɚɫ ɡɚɩɨɦɧɢɬɶ ɷɬɨ ɱɢɫɥɨ ɧɚɢɡɭɫɬɶ. ɗɬɨ ɧɟ ɤɚɤɚɹ-ɬɨ ɨɫɨɛɟɧɧɨɫɬɶ
ɉɢɬɨɧɚ. ɗɬɨ ɨɛɳɢɣ ɩɪɢɧɰɢɩ ɪɚɛɨɬɵ ɫ ɛɢɧɚɪɧɵɦɢ ɮɚɣɥɚɦɢ, ɚ 99% ɮɚɣɥɨɜ
ɜ ɦɢɪɟ ɛɢɧɚɪɧɵɟ. ɏɨɬɹ, ɫɤɨɪɟɟ ɜɫɟɝɨ, ɹ ɧɟɩɪɚɜ. 99.99%.
ɋɥɟɞɭɸɳɚɹ ɫɬɪɨɤɚ ɩɪɨɝɪɚɦɦɧɨɝɨ ɤɨɞɚ ɜɵɝɥɹɞɢɬ ɫɨɜɟɪɲɟɧɧɨ ɧɟɜɢɧɧɨ.
Ɉɧɚ ɡɚɩɢɫɵɜɚɟɬ ɭɩɚɤɨɜɚɧɧɨɟ ɰɟɥɨɟ ɱɢɫɥɨ ɜ ɮɚɣɥ. ɋ ɬɨɱɤɢ ɡɪɟɧɢɹ ɉɢɬɨɧɚ,
ɬɭɬ ɞɭɦɚɬɶ ɜɨɨɛɳɟ ɧɟ ɨ ɱɟɦ. ɋ ɬɨɱɤɢ ɡɪɟɧɢɹ ɜɧɟɲɧɟɝɨ ɦɢɪɚ, ɧɚɞɨ ɩɨɞɭɦɚɬɶ
ɨ ɬɨɦ, ɱɬɨ ɮɚɣɥ, ɤɨɬɨɪɵɣ ɪɟɚɥɶɧɨ ɢ ɮɢɡɢɱɟɫɤɢ ɨɫɬɚɧɟɬɫɹ ɧɚ ɞɢɫɤɟ ɩɨɫɥɟ
ɜɵɩɨɥɧɟɧɢɹ ɧɚɲɟɣ ɩɪɨɝɪɚɦɦɵ, ɫɬɚɥ ɛɨɥɶɲɟ ɧɚ ɱɟɬɵɪɟ ɛɚɣɬɚ. ɋɥɟɞɭɸɳɢɟ
ɞɜɟ ɫɬɪɨɤɢ ɜɵɝɥɹɞɹɬ ɨɱɟɧɶ ɩɨɯɨɠɟ, ɨɬɥɢɱɢɟ ɬɨɥɶɤɨ ɜ ɨɞɧɨɣ ɛɭɤɜɟ.
data = struct.pack('<f4',S)
f.write(data)
ɗɬɨ ɩɨɧɹɬɧɨ, ɦɵ ɫɧɨɜɚ ɡɚɩɢɫɵɜɚɟɦ ɱɢɫɥɨ, ɬɨɥɶɤɨ ɧɟ ɰɟɥɨɟ, ɚ ɩɥɚɜɚɸɳɟɟ.
f – ɫɨɤɪɚɳɟɧɢɟ ɨɬ float. ɐɢɮɪɚ ɱɟɬɵɪɟ ɫɧɨɜɚ ɩɨɞɫɤɚɡɵɜɚɟɬ, ɱɬɨ ɦɵ
Ȼɭɤɜɚ
ɯɨɬɢɦ ɡɚɩɢɫɚɬɶ ɩɥɚɜɚɸɳɟɟ ɱɢɫɥɨ ɜ ɱɟɬɵɪɟɯɛɚɣɬɨɜɨɦ ɮɨɪɦɚɬɟ, ɛɵɜɚɸɬ ɢ
ɞɪɭɝɢɟ. ȼ ɪɟɡɭɥɶɬɚɬɟ ɪɚɡɦɟɪ ɧɚɲɟɝɨ ɮɚɣɥɚ ɭɜɟɥɢɱɢɥɫɹ ɧɚ ɱɟɬɵɪɟ ɛɚɣɬɚ ɢ
ɞɨɫɬɢɝ ɜɨɫɶɦɢ. ɉɪɨɜɟɪɶɬɟ, ɩɨɠɚɥɭɣɫɬɚ.
Ɍɟɩɟɪɶ ɩɪɨɱɢɬɚɟɦ ɮɚɣɥ. ɑɬɟɧɢɟ ɨɱɟɧɶ ɩɨɯɨɠɟ ɧɚ ɡɚɩɢɫɶ – ɬɨɥɶɤɨ ɜɫɺ
ɧɚɨɛɨɪɨɬ.
f = open( 'd:/square.bin', 'rb')
data = f.read(4)
R = struct.unpack('<i4',data)
print 'R = ', R
data = f.read(4)
S = struct.unpack('<f4',data)
print 'S = ', S
f.close()
ɋɧɚɱɚɥɚ ɨɱɟɧɶ ɧɨɜɵɣ ɨɩɟɪɚɬɨɪ:
data = f.read(4). Ɉɧ ɨɡɧɚɱɚɟɬ, ɱɬɨ ɦɵ
ɱɢɬɚɟɦ ɮɚɣɥ, ɧɨ ɱɢɬɚɟɦ ɢɡ ɧɟɝɨ ɧɟ ɫɬɪɨɤɭ ɢ ɧɟ ɨɛɴɟɤɬ. Ɇɵ ɱɢɬɚɟɦ ɩɪɨɫɬɨ
ɱɟɬɵɪɟ ɛɚɣɬɚ ɜ ɩɟɪɟɦɟɧɧɭɸ
data. ɑɬɨ ɭ ɷɬɨɣ ɩɟɪɟɦɟɧɧɨɣ ɜɧɭɬɪɢ, ɧɚɫ,
ɨɩɹɬɶ-ɬɚɤɢ, ɧɟ ɢɧɬɟɪɟɫɭɟɬ. ɂ ɟɳɺ ɪɚɡ ɨ ɫɚɦɨɦ ɝɥɚɜɧɨɦ – ɦɵ ɞɨɥɠɧɵ ɬɨɱɧɨ
ɡɧɚɬɶ, ɱɬɨ ɞɨɥɠɧɵ ɩɪɨɱɢɬɚɬɶ ɢɡ ɮɚɣɥɚ ɢɦɟɧɧɨ
ɱɟɬɵɪɟ ɛɚɣɬɚ. ȿɫɥɢ ɪɚɧɶɲɟ
ɦɵ ɩɚɤɨɜɚɥɢ ɰɟɥɭɸ ɩɟɪɟɦɟɧɧɭɸ, ɬɨ ɬɟɩɟɪɶ ɦɵ ɟɺ ɪɚɫɩɚɤɨɜɵɜɚɟɦ:
193
R = struct.unpack('<i4',data)
ȼɵɝɥɹɞɢɬ ɨɱɟɧɶ ɩɨɯɨɠɟ ɧɚ ɭɩɚɤɨɜɤɭ. ɂ ɟɳɺ ɪɚɡ ɨ ɝɥɚɜɧɨɦ, ɢɡɜɢɧɢɬɟ, ɟɫɥɢ
ɭɠɟ ɧɚɞɨɟɥ, ɚ ɜɵ ɜɫɺ ɞɚɜɧɨ ɭɠɟ ɩɨɧɹɥɢ – ɦɵ ɞɨɥɠɧɵ ɨɱɟɧɶ ɱɺɬɤɨ ɩɨɦɧɢɬɶ,
ɱɬɨ ɩɪɨɱɢɬɚɧɧɵɟ ɧɚɦɢ ɫɬɪɨɤɨɣ ɪɚɧɶɲɟ ɱɟɬɵɪɟ ɛɚɣɬɚ ɷɬɨ ɢɦɟɧɧɨ ɰɟɥɚɹ
ɩɟɪɟɦɟɧɧɚɹ, ɚ ɧɟ ɩɥɚɜɚɸɳɚɹ, ɤ ɩɪɢɦɟɪɭ. Ɍɟɩɟɪɶ ɢɧɬɟɪɟɫɧɚɹ ɨɫɨɛɟɧɧɨɫɬɶ
ɱɬɟɧɢɹ, ɨɫɨɛɟɧɧɨɫɬɶ ɷɬɚ, ɦɹɝɤɨ ɝɨɜɨɪɹ, ɫ ɩɟɪɜɨɝɨ ɪɚɡɚ ɧɟɦɧɨɝɨ ɩɭɝɚɟɬ.
ȼɵɜɟɞɟɦ ɬɨ, ɱɬɨ ɬɨɥɶɤɨ ɱɬɨ ɩɪɨɱɢɬɚɥɢ.
print 'R = ', R
R = (10,)
ɉɪɨɱɢɬɚɧɧɨɟ ɱɢɫɥɨ ɱɢɬɚɟɬɫɹ ɧɟ ɩɪɨɫɬɨ ɬɚɤ, ɚ ɨɛɹɡɚɬɟɥɶɧɨ ɫɬɚɧɨɜɢɬɫɹ
ɷɥɟɦɟɧɬɨɦ ɤɨɪɬɟɠɚ. Ʉɨɪɬɟɠ ɢɡ ɨɞɧɨɝɨ ɷɥɟɦɟɧɬɚ, ɩɨɷɬɨɦɭ ɜ ɯɜɨɫɬɟ ɧɟɥɟɩɚɹ
ɡɚɩɹɬɚɹ. Ɉɬɤɚɡɚɬɶɫɹ ɨɬ ɷɬɨɝɨ – ɨɬ ɤɨɪɬɟɠɚ – ɧɟɥɶɡɹ. ə ɧɟ ɡɧɚɸ, ɡɚɱɟɦ ɢ ɤɨɦɭ
ɷɬɨ ɧɭɠɧɨ. Ɋɚɡɭɦɟɟɬɫɹ, ɫɢɬɭɚɰɢɸ ɦɨɠɧɨ ɢɫɩɪɚɜɢɬɶ, ɧɨ ɬɨɥɶɤɨ ɩɨɬɨɦ:
S = struct.unpack('<f4',data)
R_ = R[0]
print 'R_ = ', R_
R_ = 10
Ɉɛ ɷɬɨɣ ɫɬɪɚɧɧɨɫɬɢ ɹ ɛɨɥɶɲɟ ɧɚɩɨɦɢɧɚɬɶ ɧɟ ɛɭɞɭ, ɚ ɜɵ ɧɟ ɡɚɛɵɜɚɣɬɟ.
Ɍɟɩɟɪɶ ɨɛɟɳɚɧɧɵɟ ɩɨɞɪɨɛɧɨɫɬɢ ɨ ɮɨɪɦɚɬɟ ɡɚɩɢɫɢ ɢ ɱɬɨ ɨɡɧɚɱɚɟɬ ɡɧɚɤ
ɦɟɧɶɲɟ ɢ ɜɨɡɦɨɠɧɵɣ ɧɚ ɟɝɨ ɦɟɫɬɟ ɡɧɚɤ ɛɨɥɶɲɟ.
# ɧɟɧɭɠɧɵɟ ɩɨɞɪɨɛɧɨɫɬɢ ɞɥɹ ɥɸɛɨɡɧɚɬɟɥɶɧɵɯ
ȼɨɨɛɳɟ ɝɨɜɨɪɹ, ɩɟɪɜɵɣ ɢ ɧɟ ɨɱɟɧɶ ɩɨɧɹɬɧɵɣ ɩɚɪɚɦɟɬɪ ɦɨɠɧɨ ɭɩɪɨɫɬɢɬɶ,
ɜɨɬ ɬɚɤɢɦ ɨɛɪɚɡɨɦ:
data = struct.pack('i',R)
R = struct.unpack('i’, data)
ɍɤɚɡɵɜɚɬɶ ɬɢɩ ɫɨɜɟɪɲɟɧɧɨ ɧɟɨɛɯɨɞɢɦɨ, ɚ ɜɨɬ ɞɥɢɧɚ ɜ ɱɟɬɵɪɟ ɛɚɣɬɚ
ɛɟɪɺɬɫɹ ɩɪɨɫɬɨ ɩɨ ɭɦɨɥɱɚɧɢɸ. ɗɬɨ ɯɨɪɨɲɚɹ, ɩɨɞɯɨɞɹɳɚɹ ɜɟɥɢɱɢɧɚ. ɋ
ɩɟɪɜɵɦ ɫɢɦɜɨɥɨɦ ɫɥɨɠɧɟɟ. ɉɨ ɭɦɨɥɱɚɧɢɸ ɧɚ ɟɝɨ ɦɟɫɬɨ ɩɨɞɫɬɚɜɥɹɟɬɫɹ
ɡɧɚɤ ɛɨɥɶɲɟ. ɑɬɨ ɷɬɨ ɨɡɧɚɱɚɟɬ? Ɉɡɧɚɱɚɟɬ ɷɬɨ, ɜ ɤɚɤɨɦ ɩɨɪɹɞɤɟ
ɡɚɩɢɫɵɜɚɸɬɫɹ ɱɟɬɵɪɟ ɛɚɣɬɚ ɫɨɫɬɚɜɥɹɸɳɢɟ ɰɟɥɨɟ ɱɢɫɥɨ.
ɑɬɨ ɨɡɧɚɱɚɸɬ ɡɧɚɤɢ ɦɟɧɶɲɟ ɢ ɛɨɥɶɲɟ? ȼɵ ɦɨɠɟɬɟ ɭɡɧɚɬɶ ɩɨɞɪɨɛɧɟɟ ɨ
ɛɚɣɬɚɯ ɢ ɨ ɜɧɭɬɪɟɧɧɟɦ ɭɫɬɪɨɣɫɬɜɟ ɩɟɪɟɦɟɧɧɵɯ ɜ ɩɪɢɥɨɠɟɧɢɹɯ, ɡɞɟɫɶ ɨ
194
ɬɨɦ, ɤɬɨ ɢɡ ɧɢɯ ɥɭɱɲɟ. ɐɟɥɨɟ ɢɥɢ ɩɥɚɜɚɸɳɟɟ ɱɢɫɥɨ ɡɚɧɢɦɚɟɬ ɜ ɧɚɲɟɦ
ɫɥɭɱɚɟ ɱɟɬɵɪɟ ɛɚɣɬɚ. ȿɫɬɶ ɦɥɚɞɲɢɣ ɛɚɣɬ. ȿɫɬɶ ɫɬɚɪɲɢɣ. Ɂɧɚɤ ɦɟɧɶɲɟ
ɭɤɚɡɵɜɚɟɬ, ɱɬɨ ɫɧɚɱɚɥɚ ɩɢɲɟɬɫɹ ɦɥɚɞɲɢɣ ɛɚɣɬ, ɡɧɚɤ ɛɨɥɶɲɟ – ɱɬɨ
ɧɚɨɛɨɪɨɬ. ȼ ɞɪɭɝɢɯ, ɬɪɚɞɢɰɢɨɧɧɵɯ ɹɡɵɤɚɯ, ɟɫɥɢ ɧɟ ɢɡɜɪɚɳɚɬɶɫɹ
ɫɩɟɰɢɚɥɶɧɨ, ɩɨɪɹɞɨɤ ɡɚɩɢɫɢ – ɨɬ ɦɥɚɞɲɟɝɨ ɤ ɫɬɚɪɲɟɦɭ.
Ɂɚɩɢɫɚɧɧɵɣ ɜ ɉɢɬɨɧɟ ɩɨ ɭɦɨɥɱɚɧɢɸ, ɬɨ ɟɫɬɶ ɫ ɫɢɦɜɨɥɨɦ ɛɨɥɶɲɟ, ɮɚɣɥ
ɨɬɥɢɱɧɨ ɩɪɨɱɢɬɚɟɬɫɹ, ɩɪɢ ɭɫɥɨɜɢɢ, ɟɫɥɢ ɱɬɟɧɢɟ ɛɭɞɟɬ ɚɛɫɨɥɸɬɧɨ
ɫɢɦɦɟɬɪɢɱɧɵɦ, ɬɨ ɟɫɬɶ ɬɨɠɟ ɫ ɩɪɨɩɭɳɟɧɧɵɦɢ ɫɢɦɜɨɥɚɦɢ ɩɨ ɭɦɨɥɱɚɧɢɸ.
ȿɫɬɶ ɬɨɥɶɤɨ ɨɞɧɚ ɦɚɥɟɧɶɤɚɹ ɩɪɨɛɥɟɦɚ – ɩɪɨɱɢɬɚɟɬɫɹ ɨɧ ɧɚɲɟɣ ɩɪɨɝɪɚɦɦɨɣ
ɧɚ ɉɢɬɨɧɟ ɢ ɤɟɦ-ɬɨ, ɜɨɡɦɨɠɧɨ, ɟɳɺ. Ȼɨɥɶɲɢɧɫɬɜɨ ɫɬɨɪɨɧɧɢɯ ɩɪɨɝɪɚɦɦ
ɧɚɲ ɮɚɣɥ ɧɟ ɩɨɣɦɭɬ.
ȼɵɜɨɞ – ɧɟ ɭɦɧɢɱɚɣɬɟ ɢ ɞɟɥɚɣɬɟ ɜ ɬɨɱɧɨɫɬɢ, ɤɚɤ ɹ ɫɤɚɡɚɥ.
# ɤɨɧɟɰ ɇɟɧɭɠɧɵɯ ɩɨɞɪɨɛɧɨɫɬɟɣ
ɉɪɨɞɨɥɠɚɟɦ ɪɚɡɝɨɜɨɪ. ɋɧɚɱɚɥɚ ɪɟɲɢɦ ɟɳɺ ɨɞɧɭ ɭɱɟɛɧɭɸ ɡɚɞɚɱɭ, ɚ ɩɨɫɥɟ
ɢɡɭɱɢɦ, ɤɚɤ ɩɢɲɭɬɫɹ ɜ ɛɢɧɚɪɧɵɣ ɮɚɣɥ ɞɚɧɧɵɟ ɞɪɭɝɢɯ ɬɢɩɨɜ. Ⱥ ɩɨɬɨɦ
ɪɟɲɢɦ ɟɳɺ ɨɞɧɭ ɭɱɟɛɧɭɸ ɡɚɞɚɱɭ, ɧɨ ɭɠɟ ɩɨɱɬɢ ɧɚɫɬɨɹɳɭɸ.
ɍɱɟɛɧɚɹ ɡɚɞɚɱɚ. Ɂɚɩɢɫɚɬɶ – ɢ ɩɪɨɱɢɬɚɬɶ – ɫɥɭɱɚɣɧɨɟ ɱɢɫɥɨ ɫɥɭɱɚɣɧɵɯ
ɰɟɥɵɯ ɱɢɫɟɥ. Ɂɚɱɟɦ? Ⱦɚ ɤɚɤɚɹ ɪɚɡɧɢɰɚ! ɇɟɫɦɨɬɪɹ ɧɚ ɧɟɫɤɨɥɶɤɨ
ɢɫɤɭɫɫɬɜɟɧɧɵɣ ɯɚɪɚɤɬɟɪ, ɡɚɞɚɱɚ ɢɦɟɟɬ ɢ ɨɱɟɧɶ ɞɚɠɟ ɨɛɵɱɧɵɟ
ɩɪɚɤɬɢɱɟɫɤɢɟ ɨɫɨɛɟɧɧɨɫɬɢ. Ɋɟɞɤɨ ɩɪɢɯɨɞɢɬɫɹ ɱɢɬɚɬɶ ɮɚɣɥ, ɡɚɪɚɧɟɟ ɡɧɚɹ,
ɱɬɨ ɜ ɧɺɦ ɫɨɞɟɪɠɢɬɫɹ ɪɨɜɧɨ ɞɜɚɞɰɚɬɶ ɬɪɢ ɰɟɥɵɯ ɱɢɫɥɚ. Ƚɨɪɚɡɞɨ ɱɚɳɟ ɦɵ
ɫɧɚɱɚɥɚ ɱɢɬɚɟɦ ɢɡ ɮɚɣɥɚ ɱɢɫɥɨ ɱɢɫɟɥ ɜ ɧɺɦ, ɜ ɮɚɣɥɟ, ɡɚɩɢɫɚɧɧɵɯ, ɚ ɩɨɬɨɦ ɜ
ɰɢɤɥɟ ɫɚɦɢ ɷɬɢ ɱɢɫɥɚ. ɉɨɧɹɬɧɨ. ɑɬɨ ɜɫɺ ɷɬɨ ɨɪɝɚɧɢɡɨɜɚɧɨ ɦɧɨɝɨ ɢ ɦɧɨɝɨ
ɫɥɨɠɧɟɟ, ɧɨ ɢɞɟɹ ɬɚ ɠɟ, ɱɬɨ ɢ ɜ ɧɚɲɟɣ ɭɱɟɛɧɨɣ ɡɚɞɚɱɟ.
ɇɨ ɦɵ ɞɨɩɨɥɧɢɬɟɥɶɧɨ ɩɪɢɛɥɢɡɢɦ ɧɚɲɭ ɭɱɟɛɧɭɸ ɡɚɞɚɱɭ ɤ ɪɟɚɥɶɧɨɣ. Ʉɚɤɚɹ
ɩɟɪɜɚɹ ɩɪɨɛɥɟɦɚ ɜɫɬɚɺɬ ɩɟɪɟɞ ɧɚɦɢ ɩɪɢ ɱɬɟɧɢɢ ɥɸɛɨɝɨ ɧɚɦɢ ɡɚɩɢɫɚɧɧɨɝɨ
ɮɚɣɥɚ, ɫɬɪɭɤɬɭɪɭ ɤɨɬɨɪɨɝɨ ɦɵ ɨɬɥɢɱɧɨ ɡɧɚɟɦ? ɉɟɪɜɚɹ ɩɪɨɛɥɟɦɚ –
ɭɛɟɞɢɬɶɫɹ, ɱɬɨ ɷɬɨ ɞɟɣɫɬɜɢɬɟɥɶɧɨ ɧɚɲ ɮɚɣɥ, ɚ ɧɟ ɩɨɞɫɭɧɭɬɚɹ ɜɪɚɝɚɦɢ
ɞɟɲɺɜɚɹ ɤɢɬɚɣɫɤɚɹ ɩɨɞɞɟɥɤɚ. ɑɬɨɛɵ ɨɬɥɢɱɢɬɶ ɧɚɲ ɮɚɣɥ ɨɬ
ɩɨɬɭɫɬɨɪɨɧɧɟɝɨ, ɢɫɩɨɥɶɡɭɟɬɫɹ
ɫɢɝɧɚɬɭɪɚ. ɗɬɨ ɧɟ ɤɚɤɨɟ-ɬɨ ɫɜɟɪɯɫɥɨɠɧɨɟ
ɩɨɧɹɬɢɟ. ɗɬɨ ɜɫɟɝɨ-ɧɚɜɫɟɝɨ ɩɨɫɥɟɞɨɜɚɬɟɥɶɧɨɫɬɶ ɫɢɦɜɨɥɨɜ, ɡɚɩɢɫɚɧɧɚɹ ɜ
ɧɚɱɚɥɟ ɮɚɣɥɚ. ȿɫɬɶ ɫɢɦɜɨɥɵ – ɡɧɚɱɢɬ ɧɚɲ ɮɚɣɥ. ɇɟɬ – ɡɧɚɱɢɬ ɧɟɬ.
# ɢɧɬɟɪɟɫɧɵɣ ɮɚɤɬ
195
ȿɫɥɢ ɜɵ ɡɚɝɥɹɧɟɬɟ ɜ ɥɸɛɨɣ ɢɫɩɨɥɧɹɟɦɵɣ ɮɚɣɥ, ɬɨɬ, ɤɨɬɨɪɵɣ ɫ
ɪɚɫɲɢɪɟɧɢɟɦ *.exe, ɬɨ ɨɛɧɚɪɭɠɢɬɟ ɜ ɧɚɱɚɥɟ ɧɟɤɢɟ ɛɭɤɜɵ MZ. ɗɬɨ
ɫɨɤɪɚɳɟɧɢɟ ɨɬ ɢɦɟɧɢ ɢ ɮɚɦɢɥɢɢ Ɇɢɲɚ ɐɭɤɟɪɦɚɧ. ȼɨɬ ɱɟɫɬɧɨɟ ɫɥɨɜɨ. ɂ
ɤɚɤ ɬɟɩɟɪɶ ɫ ɷɬɢɦ ɠɢɬɶ?
# ɤɨɧɟɰ Ɏɚɤɬɚ
Ʉɚɤ ɡɚɩɢɫɚɬɶ ɢ ɩɪɨɱɢɬɚɬɶ ɫɬɪɨɤɭ
Ɉɞɧɚɤɨ ɞɥɹ ɪɟɚɥɢɡɚɰɢɢ ɷɬɨɣ ɨɩɰɢɢ ɧɚɦ ɧɚɞɨ ɧɚɭɱɢɬɶɫɹ ɡɚɩɢɫɵɜɚɬɶ ɜ ɮɚɣɥ
ɬɪɟɬɢɣ, ɩɨɫɥɟ ɰɟɥɵɯ ɢ ɩɥɚɜɚɸɳɢɯ, ɬɢɩ ɞɚɧɧɵɯ – ɫɬɪɨɤɢ. ɋ ɝɥɭɛɨɤɢɦ
ɫɨɠɚɥɟɧɢɟɦ, ɞɨɥɠɟɧ ɡɚɦɟɬɢɬɶ, ɱɬɨ ɬɟɯɧɨɥɨɝɢɹ ɡɚɦɟɬɧɨ ɨɬɥɢɱɚɟɬɫɹ, ɢ ɧɟ ɜ
ɥɭɱɲɭɸ ɫɬɨɪɨɧɭ. ȼɨɬ ɡɚɩɢɫɶ:
name = 'circle'
data = struct.pack('6s',name)
f.write(data)
Ɇɵ ɩɪɨɫɬɨ ɪɟɲɢɥɢ ɧɚɩɨɦɧɢɬɶ ɱɢɬɚɬɟɥɸ ɮɚɣɥɚ, ɱɬɨ ɡɚɩɢɫɚɥɢ ɜ ɧɟɝɨ ɱɬɨ-ɬɨ,
ɨɬɧɨɫɹɳɟɟɫɹ ɤ ɤɪɭɝɭ. ȿɫɥɢ ɜɵ ɡɚɝɥɹɧɟɬɟ ɜ ɫɨɡɞɚɧɧɵɣ ɮɚɣɥ, ɬɨ ɭɜɢɞɢɬɟ, ɱɬɨ
ɨɧ ɭɜɟɥɢɱɢɥɫɹ ɪɨɜɧɨ ɧɚ ɲɟɫɬɶ ɛɚɣɬ – ɱɬɨ ɧɟɭɞɢɜɢɬɟɥɶɧɨ – ɢ ɱɬɨ ɜ ɷɬɢɯ
ɲɟɫɬɢ ɛɚɣɬɚɯ ɫɨɞɟɪɠɚɬɫɹ ɲɟɫɬɶ ɛɭɤɜ ɫɥɨɜɚ circle. ɗɬɨ ɦɨɠɧɨ ɭɜɢɞɟɬɶ,
ɩɨɫɦɨɬɪɟɜ ɮɚɣɥ ɱɟɦ ɭɝɨɞɧɨ ɜɪɨɞɟ Total Commander ɢɥɢ FAR. ɋɨ ɫɬɪɨɤɚɦɢ,
ɨɞɧɚɤɨ, ɟɫɬɶ ɧɟɛɨɥɶɲɚɹ ɩɪɨɛɥɟɦɚ. ȼ ɨɬɥɢɱɢɟ ɨɬ ɰɟɥɵɯ ɢ ɩɥɚɜɚɸɳɢɯ, ɢɯ
ɨɱɟɧɶ ɪɟɞɤɨ ɦɨɠɧɨ ɩɪɨɫɬɨ ɬɚɤ ɜɡɹɬɶ ɢ ɩɪɨɱɢɬɚɬɶ. Ɏɚɤɬɢɱɟɫɤɢ ɦɵ ɡɚɩɢɫɚɥɢ
ɧɟ ɫɬɪɨɤɭ, ɚ ɲɟɫɬɶ ɫɢɦɜɨɥɨɜ, ɢɡ ɤɨɬɨɪɵɯ ɨɧɚ ɫɨɫɬɨɢɬ. ɇɚɲɚ ɤɧɢɝɚ ɧɟ
ɢɧɬɟɪɟɫɭɟɬɫɹ ɞɪɭɝɢɦɢ ɹɡɵɤɚɦɢ, ɬɨɥɶɤɨ ɉɢɬɨɧ, ɩɨɷɬɨɦɭ, ɤɚɤ ɢ ɜɫɟɝɞɚ, ɜɫɺ,
ɨɬɧɨɫɹɳɟɟɫɹ ɤ ɞɪɭɝɢɦ ɹɡɵɤɚɦ ɩɪɨɝɪɚɦɦɢɪɨɜɚɧɢɹ, ɢɞɺɬ ɜ ɩɪɢɥɨɠɟɧɢɹɯ.
ɑɢɬɚɣɬɟ ɩɪɢɥɨɠɟɧɢɟ ɨ ɬɨɦ, ɤɚɤ ɱɢɬɚɸɬɫɹ ɛɢɧɚɪɧɵɟ ɮɚɣɥɵ ɜ ɞɪɭɝɢɯ
ɹɡɵɤɚɯ.
Ⱥ ɩɨɤɚ ɫɚɦɢ, ɜ ɉɢɬɨɧɟ, ɩɪɨɱɢɬɚɟɦ ɬɨ, ɱɬɨ ɡɚɩɢɫɚɥɢ:
data = f.read(6)
name = struct.unpack('<6s',data)
print 'name = ', name
name = ('circle',)
ȼɫɺ ɛɚɧɚɥɶɧɨ ɢ ɨɠɢɞɚɟɦɨ, ɝɥɚɜɧɨɟ ɩɨɦɧɢɬɶ, ɱɬɨ ɦɵ ɡɚɩɢɫɚɥɢ ɢɦɟɧɧɨ
ɲɟɫɬɶ ɛɚɣɬ. ɇɨ ɜɨɬ ɩɪɨɝɪɚɦɦɚ, ɧɚɩɢɫɚɧɧɚɹ ɧɚ ɞɪɭɝɨɦ ɹɡɵɤɟ, ɦɨɠɟɬ ɷɬɨɝɨ ɢ
ɧɟ ɩɨɧɹɬɶ. ȼɩɪɨɱɟɦ, ɨɝɨɪɱɚɬɶɫɹ ɧɟ ɧɚɞɨ, ɱɬɨ ɤɚɫɚɟɬɫɹ ɡɚɩɢɫɢ ɢ ɱɬɟɧɢɹ
ɫɬɪɨɤ, ɷɬɢ ɫɚɦɵɟ ɧɟ ɩɢɬɨɧɫɤɢɟ ɩɪɨɝɪɚɦɦɵ ɨɛɵɱɧɨ ɞɪɭɝ ɞɪɭɝɚ ɬɨɠɟ ɧɟ
ɩɨɧɢɦɚɸɬ.
196
Ɂɚɩɢɫɶ ɢ ɱɬɟɧɢɟ ɪɚɛɨɬɚɸɬ, ɧɨ ɬɟɩɟɪɶ ɧɚɦ ɩɪɢɯɨɞɢɬɫɹ ɡɚɩɨɦɢɧɚɬɶ ɧɟ ɬɨɥɶɤɨ
ɬɨ, ɱɬɨ ɦɵ ɩɢɲɟɦ ɜ ɮɚɣɥ ɫɬɪɨɤɭ, ɧɨ ɢ ɬɨ, ɱɬɨ ɟɺ ɞɥɢɧɚ ɢɦɟɧɧɨ ɲɟɫɬɶ
ɫɢɦɜɨɥɨɜ. Ɉɬ ɡɚɩɨɦɢɧɚɧɢɹ ɬɨɝɨ, ɱɬɨ ɷɬɨ ɢɦɟɧɧɨ ɫɬɪɨɤɚ, ɦɵ ɢɡɛɚɜɢɬɶɫɹ ɧɟ
ɫɦɨɠɟɦ, ɧɨ ɜɨɬ ɫ ɲɟɫɬɶɸ ɫɢɦɜɨɥɚɦɢ ɩɪɨɳɟ. ɇɚɞɨ ɜɵɩɨɥɧɢɬɶ ɧɟɛɨɥɶɲɭɸ
ɡɚɦɟɧɭ.
# ɛɵɥɨ
data = struct.pack('6s',name)
f.write(data)
# ɫɬɚɥɨ
data = struct.pack('7p',name)
f.write(data)
ɑɬɟɧɢɟ ɬɨɠɟ ɧɟɦɧɨɝɨ ɢɡɦɟɧɢɥɨɫɶ.
data = f.read(7)
name = struct.unpack('<7p',data)
# ɩɨɞɪɨɛɧɨɫɬɢ ɞɥɹ ɥɸɛɨɡɧɚɬɟɥɶɧɵɯ
Ȼɭɤɜɚ
p ɡɞɟɫɶ ɹɜɥɹɟɬɫɹ ɫɨɤɪɚɳɟɧɢɟɦ ɨɬ ɫɥɨɜɚ Pascal – ɢɦɹ ɹɡɵɤɚ
ɩɪɨɝɪɚɦɦɢɪɨɜɚɧɢɹ. ɂɦɟɧɧɨ ɬɚɦ ɢɫɩɨɥɶɡɨɜɚɥɫɹ ɬɚɤɨɣ ɮɨɪɦɚɬ ɡɚɩɢɫɢ
ɫɬɪɨɤ. ȼ ɩɪɨɲɟɞɲɟɦ ɜɪɟɦɟɧɢ – ɩɨɬɨɦɭ, ɱɬɨ ɷɬɨ ɧɟ ɬɨɬ Object Pascal,
ɤɨɬɨɪɵɣ ɜ ɫɪɟɞɟ ɩɪɨɝɪɚɦɦɢɪɨɜɚɧɢɹ Ⱦɟɥɶɮɢ, ɚ ɬɨɬ, ɤɨɬɨɪɵɣ ɟɳɺ Turbo
Pascal. Ɍɚɦ ɫɬɪɨɤɢ ɢɦɟɥɢ ɨɝɪɚɧɢɱɟɧɢɟ ɜ 255 ɫɢɦɜɨɥɨɜ. ɍɞɢɜɢɬɟɥɶɧɨ ɢɥɢ
ɧɟɭɞɢɜɢɬɟɥɶɧɨ, ɧɨ ɜ ɉɢɬɨɧɟ ɞɥɹ ɫɬɪɨɤ, ɡɚɩɢɫɚɧɧɵɯ ɜ ɷɬɨɦ ɪɟɠɢɦɟ,
ɞɟɣɫɬɜɭɟɬ ɬɨ ɠɟ ɫɚɦɨɟ ɨɝɪɚɧɢɱɟɧɢɟ.
# ɤɨɧɟɰ Ⱦɥɹ
Ɉɛɪɚɬɢɬɟ ɜɧɢɦɚɧɢɟ, ɜɦɟɫɬɨ ɲɟɫɬɺɪɤɢ ɜ ɩɪɨɝɪɚɦɦɧɨɦ ɤɨɞɟ ɹ ɧɚɩɢɫɚɥ
ɫɟɦɺɪɤɭ. ɗɬɨ ɜɨɜɫɟ ɧɟ ɨɩɟɱɚɬɤɚ, ɬɚɤ ɧɚɞɨ. ɂ, ɬɨɱɧɨ ɬɚɤ ɠɟ, ɟɫɥɢ ɞɨ ɬɨɝɨ ɭ
ɧɚɫ ɪɚɧɶɲɟ ɲɥɚ ɛɭɤɜɚ, ɨɡɧɚɱɚɸɳɚɹ ɮɨɪɦɚɬ, ɚ ɬɨɥɶɤɨ ɩɨɬɨɦ ɟɝɨ ɞɥɢɧɚ ɜ
ɛɚɣɬɚɯ, ɬɨ ɬɟɩɟɪɶ ɜɫɺ ɧɚɨɛɨɪɨɬ. Ɍɚɤ ɧɚɞɨ, ɡɚɩɨɦɧɢɬɟ.
ɑɬɨ ɛɭɞɟɬ ɫ ɧɚɲɢɦ ɧɨɜɵɦ ɮɚɣɥɨɦ ɩɨɫɥɟ ɬɚɤɨɣ ɡɚɩɢɫɢ? Ɏɚɣɥ ɭɜɟɥɢɱɢɥɫɹ
ɧɚ ɨɞɢɧ ɛɚɣɬ, ɟɝɨ ɞɥɢɧɚ ɬɟɩɟɪɶ ɪɚɜɧɚ ɫɟɦɢ ɢ ɜ ɩɟɪɜɨɦ ɛɚɣɬɟ ɡɚɩɢɫɚɧɚ ɞɥɢɧɚ
ɫɬɪɨɤɢ. ȼ ɷɬɨɣ ɞɥɢɧɟ ɫɬɪɨɤɢ ɡɚɩɢɫɚɧɨ ɨɞɧɚɤɨ ɧɟ ɫɟɦɶ, ɚ ɲɟɫɬɶ – ɩɨɬɨɦɭ ɱɬɨ
ɷɬɨ ɢ ɟɫɬɶ ɞɥɢɧɚ ɫɬɪɨɤɢ. ɗɬɨ ɧɚɞɨ ɬɜɺɪɞɨ ɭɫɜɨɢɬɶ – ɞɥɢɧɚ ɫɬɪɨɤɢ ɩɪɢ ɬɚɤɨɦ
ɫɩɨɫɨɛɟ ɨɬɥɢɱɚɟɬɫɹ ɧɚ ɟɞɢɧɢɰɭ, ɜ ɦɟɧɶɲɭɸ ɫɬɨɪɨɧɭ, ɨɬ ɟɺ ɪɚɡɦɟɪɚ ɜ ɮɚɣɥɟ.
197
ɉɪɢ ɡɚɩɢɫɢ ɜ ɮɚɣɥ ɦɵ ɭɤɚɡɵɜɚɟɦ, ɱɬɨ ɩɢɲɟɦ ɫɟɦɶ ɛɚɣɬ, ɢɥɢ ɫɟɦɶ
ɫɢɦɜɨɥɨɜ. ɤɚɤ ɜɚɦ ɷɬɨ ɛɨɥɶɲɟ ɩɨɧɪɚɜɢɬɫɹ. Ȼɚɣɬ ɫ ɞɥɢɧɨɣ ɫɬɪɨɤɢ ɬɨɠɟ
ɭɱɢɬɵɜɚɟɬɫɹ. ɑɢɬɚɟɦ ɢɡ ɮɚɣɥɚ ɨɩɹɬɶ-ɬɚɤɢ ɫɟɦɶ ɛɚɣɬ, ɩɨɬɨɦɭ ɱɬɨ ɫɟɦɶ ɢ
ɡɚɩɢɫɚɥɢ, ɷɬɨ ɩɨɧɹɬɧɨ. Ⱥ ɜɨɬ ɬɨ, ɱɬɨ ɩɪɢ ɪɚɫɩɚɤɨɜɤɟ ɦɵ ɭɤɚɡɵɜɚɟɦ ɬɨɠɟ
ɫɟɦɶ, ɦɧɟ ɤɚɠɟɬɫɹ ɧɟɫɤɨɥɶɤɨ ɧɟɥɨɝɢɱɧɵɦ, ɧɨ ɱɬɨ ɢɦɟɟɦ, ɬɨ ɢɦɟɟɦ. ɗɬɨ
ɧɚɞɨ ɩɪɨɫɬɨ ɡɚɩɨɦɧɢɬɶ.
Ʉ ɱɟɦɭ, ɨɞɧɚɤɨ, ɜɫɟ ɷɬɢ ɫɥɨɠɧɨɫɬɢ? ȼ ɱɺɦ ɧɚɝɪɚɞɚ? Ɍɟɩɟɪɶ ɧɚɦ ɧɟ ɧɚɞɨ
ɩɨɦɧɢɬɶ ɞɥɢɧɭ ɫɬɪɨɤɢ, ɧɚɦ ɧɚɞɨ ɬɨɥɶɤɨ ɩɨɦɧɢɬɶ ɱɬɨ ɷɬɨ ɢɦɟɧɧɨ ɫɬɪɨɤɚ. ȿɺ
ɞɥɢɧɚ ɯɪɚɧɢɬɫɹ ɜ ɮɚɣɥɟ. Ɍɨɱɧɨ ɬɚɤ ɠɟ ɥɸɛɚɹ ɞɪɭɝɚɹ ɩɪɨɝɪɚɦɦɚ ɧɚ ɫɨɜɫɟɦ
ɞɪɭɝɨɦ ɹɡɵɤɟ ɩɪɨɝɪɚɦɦɢɪɨɜɚɧɢɹ, ɱɢɬɚɸɳɚɹ ɧɚɲ ɮɚɣɥ, ɞɨɥɠɧɚ ɬɨɥɶɤɨ
ɡɧɚɬɶ, ɱɬɨ ɟɺ ɨɠɢɞɚɟɬ ɞɚɥɟɟ ɢɦɟɧɧɨ ɫɬɪɨɤɚ. ɂ, ɟɳɺ ɪɚɡ, ɫ ɡɚɩɢɫɶɸ ɫɬɪɨɤ ɜ
ɮɚɣɥ ɫɢɬɭɚɰɢɹ ɩɪɨɫɬɨ ɛɟɡɨɛɪɚɡɧɚɹ ɜɨ
ɜɫɟɯ ɹɡɵɤɚɯ ɩɪɨɝɪɚɦɦɢɪɨɜɚɧɢɹ.
ɇɢɱɟɝɨ ɧɟ ɩɨɞɟɥɚɬɶ.
Ɍɟɩɟɪɶ ɦɵ ɩɪɨɱɢɬɚɟɦ ɷɬɨ, ɧɨ ɩɪɟɞɩɨɥɚɝɚɹ, ɱɬɨ ɦɵ ɡɧɚɟɦ ɬɨɥɶɤɨ, ɱɬɨ ɷɬɨ
ɫɬɪɨɤ,. ɧɨ ɧɟ ɡɧɚɟɦ, ɫɤɨɥɶɤɨ ɢɦɟɧɧɨ ɜ ɷɬɨɣ ɫɬɪɨɤɟ ɫɢɦɜɨɥɨɜ. ɉɪɨɝɪɚɦɦɚ
ɛɭɞɟɬ ɤɨɪɨɬɤɨɣ, ɧɨ ɨɱɟɧɶ ɧɚɫɵɳɟɧɧɨɣ ɧɨɜɵɦɢ ɤɨɧɰɟɩɰɢɹɦɢ ɢ ɩɨɧɹɬɢɹɦɢ.
data = f.read(1)
Ls = struct.unpack('<b1', data)
form = '<' + str(Ls[0]) + 's'
data = f.read(int(Ls[0]))
name = struct.unpack( form, data)
Ʉɨɦɦɟɧɬɚɪɢɟɜ ɞɥɹ ɬɚɤɨɝɨ ɤɨɪɨɬɤɨɝɨ ɬɟɤɫɬɚ ɩɨɬɪɟɛɭɟɬɫɹ ɦɧɨɝɨ. ɉɟɪɜɚɹ
ɫɬɪɨɤɚ – ɱɢɬɚɟɦ ɨɞɢɧ ɛɚɣɬ. ȼɬɨɪɚɹ ɫɬɪɨɤɚ – ɪɚɫɩɚɤɨɜɵɜɚɟɦ ɟɺ ɜ
ɩɟɪɟɦɟɧɧɭɸ. ɉɟɪɟɦɟɧɧɚɹ, ɫɚɦɨ ɫɨɛɨɣ, ɨɮɨɪɦɥɹɟɬɫɹ ɜ ɤɨɪɬɟɠ. Ɍɪɟɬɶɹ
ɫɬɪɨɤɚ ɜɚɠɧɟɟ ɢ ɢɧɬɟɪɟɫɧɟɟ. ɋɬɪɨɤɭ ɮɨɪɦɚɬɚ ɦɵ ɧɟ ɡɚɞɚɺɦ ɞɥɹ
ɩɨɫɥɟɞɭɸɳɟɣ ɪɚɫɩɚɤɨɜɤɢ ɧɟɩɨɫɪɟɞɫɬɜɟɧɧɨ, ɚ ɮɨɪɦɢɪɭɟɦ ɟɺ, ɱɬɨ
ɧɚɡɵɜɚɟɬɫɹ, ɧɚ ɥɟɬɭ. Ⱦɥɹ ɷɬɨɝɨ ɢɡ ɤɨɪɬɟɠɚ ɦɵ ɢɡɜɥɟɤɚɟɦ ɩɟɪɜɵɣ ɷɥɟɦɟɧɬ –
ɫ ɧɭɥɟɜɵɦ ɢɧɞɟɤɫɨɦ – ɢ ɩɟɪɟɜɨɞɢɦ ɟɝɨ ɜ ɫɬɪɨɤɭ. ɑɟɬɜɺɪɬɨɣ ɫɬɪɨɤɨɣ ɦɵ
ɱɢɬɚɟɦ ɢɡ ɮɚɣɥɚ ɱɢɫɥɨ ɛɚɣɬ, ɤɨɬɨɪɨɟ, ɱɬɨ ɜɚɠɧɨ, ɡɚɪɚɧɟɟ ɧɟ ɢɡɜɟɫɬɧɨ.
ɑɢɫɥɨ ɛɚɣɬ ɦɵ ɩɪɢɧɭɞɢɬɟɥɶɧɨ ɭɫɬɚɧɚɜɥɢɜɚɟɦ ɰɟɥɵɦ ɱɢɫɥɨɦ, ɩɨɫɤɨɥɶɤɭ
ɜɫɟɦ ɢɡɜɟɫɬɧɨ, ɱɬɨ ɜ ɉɢɬɨɧɟ ɬɢɩɨɜ ɧɟɬ.
Ɉɞɧɚɤɨ ɨɩɹɬɶ-ɬɚɤɢ ɜɫɟɦ ɢɡɜɟɫɬɧɨ, ɱɬɨ ɜ ɉɢɬɨɧɟ ɩɪɟɨɛɪɚɡɨɜɚɧɢɹ ɦɟɠɞɭ
ɫɬɪɨɤɚɦɢ ɢ ɱɢɫɥɚɦɢ ɫɚɦɢ ɫɨɛɨɣ ɧɟ ɫɥɭɱɚɸɬɫɹ ɢ ɢɯ ɧɚɞɨ ɞɟɥɚɬɶ
ɧɚɫɢɥɶɫɬɜɟɧɧɨ, ɫɜɨɢɦɢ ɫɨɛɫɬɜɟɧɧɵɦɢ ɪɭɤɚɦɢ. ɉɹɬɚɹ ɫɬɪɨɤɚ, ɤ ɫɱɚɫɬɶɸ,
ɫɨɜɟɪɲɟɧɧɨ ɨɛɵɱɧɚ.
198
ɍɱɟɛɧɚɹ ɡɚɞɚɱɚ
ɇɚɩɨɦɢɧɚɸ ɫɬɪɭɤɬɭɪɭ ɧɚɲɟɝɨ ɮɚɣɥɚ:
ɋɢɝɧɚɬɭɪɚ. ɉɭɫɬɶ ɷɬɨ ɛɭɞɟɬ ɫɬɪɨɤɚ ɢɡ ɜɨɫɶɦɢ ɫɢɦɜɨɥɨɜ ‘Random ’
Ʉɨɥɢɱɟɫɬɜɨ ɫɥɭɱɚɣɧɵɯ ɱɢɫɟɥ. ɑɟɬɵɪɺɯɛɚɣɬɨɜɨɟ ɰɟɥɨɟ
ɋɚɦɢ ɫɥɭɱɚɣɧɵɟ ɱɢɫɥɚ. Ɍɨɠɟ ɱɟɬɵɪɺɯɛɚɣɬɨɜɵɟ ɰɟɥɵɟ
ɉɨɱɟɦɭ ɫɢɝɧɚɬɭɪɚ ɢɦɟɟɬ ɞɥɢɧɭ ɜɨɫɟɦɶ ɛɚɣɬ, ɟɫɥɢ ɢɡ ɧɢɯ ɡɚɧɹɬɵ ɬɨɥɶɤɨ
ɲɟɫɬɶ? ɑɬɨɛɵ ɭɞɨɛɧɟɟ ɛɵɥɨ ɫɦɨɬɪɟɬɶ ɧɚ ɮɚɣɥ ɜ ɲɟɫɬɧɚɞɰɚɬɟɪɢɱɧɨɦ ɜɢɞɟ.
Ʉɪɚɫɧɭɸ ɲɚɩɨɱɤɭ ɩɨɦɧɢɬɟ? ɉɨɱɟɦɭ ɭ ɬɟɛɹ ɬɚɤɢɟ ɛɨɥɶɲɢɟ ɝɥɚɡɚ? ɍɲɢ?
Ɂɭɛɵ?
ȼɨɬ ɢ ɜ ɩɪɨɝɪɚɦɦɢɪɨɜɚɧɢɢ ɬɨ ɠɟ ɫɚɦɨɟ. Ɇɧɨɝɨɟ ɩɪɨɝɪɚɦɦɢɪɭɟɬɫɹ
ɢɦɟɧɧɨ ɬɚɤ, ɚ ɧɟ ɩɨ-ɞɪɭɝɨɦɭ, ɬɨɥɶɤɨ ɞɥɹ ɬɨɝɨ, ɱɬɨɛɵ ɩɨɬɨɦ ɛɵɥɨ ɩɪɨɳɟ
ɬɟɫɬɢɪɨɜɚɬɶ, ɨɬɥɚɠɢɜɚɬɶ ɢ ɢɫɩɪɚɜɥɹɬɶ ɨɲɢɛɤɢ. ɗɬɨ ɩɪɢɡɧɚɤ ɯɨɪɨɲɟɝɨ
ɩɪɨɝɪɚɦɦɢɫɬɚ, ɩɥɨɯɢɟ ɩɪɨɝɪɚɦɦɢɫɬɵ ɨɛ ɷɬɨɦ ɢ ɧɟ ɞɭɦɚɸɬ. ɂ ɟɳɺ –
ɩɪɨɜɟɪɤɭ ɫɢɝɧɚɬɭɪɵ ɨɮɨɪɦɢɦ ɤɚɤ ɮɭɧɤɰɢɸ, ɜɨɡɜɪɚɳɚɸɳɭɸ ɛɭɥɟɜɫɤɨɟ
ɡɧɚɱɟɧɢɟ. ɉɪɨɫɬɨ ɱɬɨɛɵ ɧɚɩɨɦɧɢɬɶ, ɤɚɤ ɷɬɨ ɞɟɥɚɟɬɫɹ.
Ⱥ ɬɟɩɟɪɶ ɹ ɨɬɤɪɨɸ ɜɚɦ ɬɚɣɧɭ. ɇɭ ɢɥɢ ɫɚɤɪɚɥɶɧɨɟ ɡɧɚɧɢɟ, ɤɚɤ ɜɚɦ ɛɨɥɶɲɟ
ɧɪɚɜɢɬɫɹ. ə ɧɟ ɲɭɱɭ, ɦɧɨɝɢɟ ɩɪɨɝɪɚɦɦɢɫɬɵ ɞɨɯɨɞɹɬ ɞɨ ɷɬɨɝɨ ɝɨɞɚɦɢ, ɜɨ
ɜɫɟɯ ɫɦɵɫɥɚɯ
ɞɨɯɨɞɹɬ. ɉɪɨɝɪɚɦɦɚ ɞɨɥɠɧɚ ɛɵɬɶ ɦɚɤɫɢɦɚɥɶɧɨ
ɫɢɦɦɟɬɪɢɱɧɨɣ. ȿɫɥɢ ɦɵ ɡɚɞɭɦɚɥɢ ɧɚɩɢɫɚɬɶ ɮɭɧɤɰɢɸ, ɤɨɬɨɪɚɹ ɱɢɬɚɟɬ ɢ
ɩɪɨɜɟɪɹɟɬ ɫɢɝɧɚɬɭɪɭ, ɦɵ ɞɨɥɠɧɵ ɧɟɦɟɞɥɟɧɧɨ ɩɨɞɭɦɚɬɶ ɢ ɨ ɮɭɧɤɰɢɢ,
ɤɨɬɨɪɚɹ ɩɢɲɟɬ ɫɢɝɧɚɬɭɪɭ. ɂ ɦɵ ɟɺ ɧɚɩɢɲɟɦ ɬɨɠɟ. Ⱥ ɩɨɱɟɦɭ ɬɨɥɶɤɨ ɩɢɲɟɬ,
ɧɨ ɧɟ ɩɪɨɜɟɪɹɟɬ? Ⱥ ɩɨɬɨɦɭ, ɱɬɨ ɦɵ ɚɛɫɨɥɸɬɧɨ ɭɜɟɪɟɧɵ, ɱɬɨ ɧɚ ɷɬɚɩɟ
ɡɚɩɢɫɢ ɫɢɝɧɚɬɭɪɚ ɜ ɩɨɥɧɨɦ ɩɨɪɹɞɤɟ. ȼɨɬ ɷɬɢ ɞɜɟ ɮɭɧɤɰɢɢ:
goodSign = 'Random '
def writeSign(f):
data = struct.pack('<8s', goodSign)
f.write(data)
def checkSign(f):
data = f.read(8)
sign = struct.unpack( '<8s',data)
if sign[0] == goodSign:
return True
else:
return False
Ɍɟɩɟɪɶ ɟɳɺ ɨɞɧɨ ɜɚɠɧɨɟ ɡɧɚɧɢɟ. ȿɫɥɢ ɤɚɤɨɟ-ɬɨ ɡɧɚɱɟɧɢɟ, ɧɟ ɫɨɜɫɟɦ
ɬɪɢɜɢɚɥɶɧɨɟ, ɜɪɨɞɟ ɧɭɥɹ ɢɥɢ ɟɞɢɧɢɰɵ, ɢɫɩɨɥɶɡɭɟɬɫɹ ɜ ɩɪɨɝɪɚɦɦɟ ɞɜɚ ɪɚɡɚ
199
ɢɥɢ ɛɨɥɶɲɟ, ɟɝɨ ɧɟ ɪɟɤɨɦɟɧɞɭɟɬɫɹ ɩɢɫɚɬɶ ɜ ɩɪɨɝɪɚɦɦɟ ɤɚɤ ɨɧɨ ɟɫɬɶ. ȼ
ɧɚɲɟɦ ɫɥɭɱɚɟ ɷɬɢɦ ɡɧɚɱɟɧɢɟɦ ɹɜɥɹɟɬɫɹ ɫɢɝɧɚɬɭɪɚ
‘Random ’. Ɇɵ ɞɨɥɠɧɵ
ɡɚɜɟɫɬɢ ɫɩɟɰɢɚɥɶɧɭɸ ɩɟɪɟɦɟɧɧɭɸ, ɜ ɤɨɬɨɪɨɦ ɷɬɨ ɡɧɚɱɟɧɢɟ ɯɪɚɧɢɬɫɹ.
# ɪɚɫɲɢɪɟɧɢɟ ɤɪɭɝɨɡɨɪɚ
ȼ ɞɪɭɝɢɯ ɹɡɵɤɚɯ ɟɫɬɶ ɬɚɤɨɟ ɩɨɧɹɬɢɟ, ɤɚɤ
ɤɨɧɫɬɚɧɬɚ. ɗɬɨ ɜɵɝɥɹɞɢɬ ɩɨɱɬɢ
ɤɚɤ ɩɟɪɟɦɟɧɧɚɹ, ɫ ɨɞɧɢɦ ɬɨɥɶɤɨ ɨɬɥɢɱɢɟɦ. Ʉɨɧɫɬɚɧɬɭ ɧɟɥɶɡɹ ɢɡɦɟɧɢɬɶ. ȼ
ɉɢɬɨɧɟ ɤɨɧɫɬɚɧɬ, ɜ ɬɨɱɧɨɦ ɫɦɵɫɥɟ ɷɬɨɝɨ ɫɥɨɜɚ, ɧɟɬ. ȿɫɥɢ ɜɚɦ ɧɟɩɨɧɹɬɧɨ,
ɡɚɱɟɦ ɧɭɠɧɚ ɩɟɪɟɦɟɧɧɚɹ, ɤɨɬɨɪɭɸ ɢɡɦɟɧɢɬɶ ɧɟɥɶɡɹ, ɡɧɚɱɢɬ ɜɵ ɩɨɥɧɨɫɬɶɸ
ɩɪɨɧɢɤɥɢɫɶ ɞɭɯɨɦ ɉɢɬɨɧɚ.
Ʉɫɬɚɬɢ, ɜ ɧɟɤɨɬɨɪɵɯ ɨɱɟɧɶ ɬɪɚɞɢɰɢɨɧɧɵɯ ɹɡɵɤɚɯ ɩɪɨɝɪɚɦɦɢɪɨɜɚɧɢɹ ɟɫɬɶ
ɟɳɺ ɢ ɤɨɧɫɬɚɧɬɵ, ɡɧɚɱɟɧɢɹ ɤɨɬɨɪɵɯ ɦɨɠɧɨ ɢɡɦɟɧɹɬɶ.
# ɤɨɧɟɰ Ɋɚɫɲɢɪɟɧɢɹ
ɉɪɨɝɪɚɦɦɚ ɞɥɹ ɡɚɩɢɫɢ ɢ ɧɚ ɱɬɨ ɜ ɧɟɣ ɨɛɪɚɬɢɬɶ ɜɧɢɦɚɧɢɟ.
f = open( 'd:/rand.bin', 'wb')
writeSign(f)
howMany = random.randint(1,20)
print howMany
L = []
for i in xrange(0,howMany):
r = random.randint(1,100)
L.append(r)
print L
data = struct.pack( '<i4', howMany)
f.write(data)
for i in xrange(0,howMany):
data = struct.pack( '<i4', L[i])
f.write(data)
f.close()
ȼɨɡɦɨɠɧɨ, ɭ ɜɚɫ ɜɨɡɧɢɤ ɜɨɩɪɨɫ, ɩɨɱɟɦɭ ɜ ɩɪɨɝɪɚɦɦɟ ɞɜɚ ɰɢɤɥɚ – ɨɞɢɧ ɞɥɹ
ɝɟɧɟɪɚɰɢɢ ɫɥɭɱɚɣɧɵɯ ɱɢɫɟɥ, ɞɪɭɝɨɣ ɞɥɹ ɢɯ ɡɚɩɢɫɢ. ɉɨɱɟɦɭ ɧɟɥɶɡɹ ɛɵɥɨ
ɨɛɴɟɞɢɧɢɬɶ ɜɫɺ ɜ ɨɞɢɧ ɰɢɤɥ? ȼɟɞɶ ɩɪɨɝɪɚɦɦɚ ɫɬɚɥɚ ɛɵ ɤɨɪɨɱɟ? ɗɬɨ
ɯɨɪɨɲɢɣ, ɩɪɚɜɢɥɶɧɵɣ ɜɨɩɪɨɫ. ɗɬɨɝɨ ɞɟɥɚɬɶ ɧɟ ɧɚɞɨ ɩɨ ɨɱɟɧɶ ɩɪɨɫɬɨɣ
ɩɪɢɱɢɧɟ – ɩɨɬɨɦɭ ɱɬɨ ɷɬɨ ɪɚɡɧɵɟ ɡɚɞɚɱɢ ɢ ɪɚɡɧɵɟ ɩɪɨɰɟɫɫɵ. Ɇɨɠɧɨ ɞɚɠɟ
ɜɵɪɚɡɢɬɶɫɹ ɫɢɥɶɧɟɟ – ɟɫɥɢ ɱɬɨ-ɬɨ ɜ ɩɪɨɝɪɚɦɦɟ ɦɨɠɧɨ ɩɨɞɟɥɢɬɶ ɧɚ ɱɚɫɬɢ,
ɨɛɹɡɚɬɟɥɶɧɨ ɞɟɥɢɬɟ.
200
Соседние файлы в предмете [НЕСОРТИРОВАННОЕ]