Добавил:
ivanov666
Опубликованный материал нарушает ваши авторские права? Сообщите нам.
Вуз:
Предмет:
Файл:Простой Python просто с нуля
.pdf
10
Ʉɢɥɨɛɚɣɬ ɷɬɨ 1024 ɛɚɣɬɚ, ɱɬɨ ɪɚɜɧɨ
2 . ɋ ɦɚɬɟɦɚɬɢɱɟɫɤɨɣ ɢɥɢ
ɩɪɨɝɪɚɦɦɢɫɬɫɤɨɣ ɬɨɱɤɢ ɡɪɟɧɢɹ, ɫɦɟɫɶ ɞɜɨɟɤ ɢ ɞɟɫɹɬɨɤ ɜɵɝɥɹɞɢɬ ɤɚɤ-ɬɨ
ɧɟɨɪɝɚɧɢɱɧɨ. ɋɤɨɪɟɟ ɜɫɟɝɨ, ɤɨɦɭ-ɬɨ ɯɨɬɟɥɨɫɶ ɢɦɟɬɶ ɤɚɤɨɣ-ɬɨ ɚɧɚɥɨɝ
ɜɟɫɨɜɨɝɨ ɤɢɥɨɝɪɚɦɦɚ. ȿɞɢɧɢɰɵ ɤɪɭɩɧɟɟ:
Ɇɟɝɚɛɚɣɬ =
Ƚɢɝɚɛɚɣɬ =
10
2 ɤɢɥɨɛɚɣɬ = 202 ɛɚɣɬ
10
2 ɦɟɝɚɛɚɣɬ = 202 ɤɢɥɨɛɚɣɬ = 302 ɛɚɣɬ
Ɍɟɪɚɛɚɣɬ = ɫɱɢɬɚɣɬɟ ɫɚɦɢ
Ʉɢɥɨɛɚɣɬ – ɷɬɨ ɧɟ ɬɵɫɹɱɚ ɛɚɣɬ, ɷɬɨ ɱɭɬɶ ɛɨɥɶɲɟ. ɏɨɪɨɲɨ ɷɬɨ ɢɥɢ ɩɥɨɯɨ?
ɋɟɣɱɚɫ ɜɫɟɦ ɜɫɺ ɪɚɜɧɨ, ɚ ɪɚɧɶɲɟ ɪɟɝɭɥɹɪɧɨ ɜɨɡɧɢɤɚɥɢ ɫɢɬɭɚɰɢɢ. ɉɨɤɭɩɚɟɬ
ɱɟɥɨɜɟɤ ɡɚ ɞɟɧɶɝɢ, ɤ ɩɪɢɦɟɪɭ, ɠɺɫɬɤɢɣ ɞɢɫɤ, ɤ ɩɪɢɦɟɪɭ, ɺɦɤɨɫɬɶɸ 500
ɦɟɝɚɛɚɣɬ. ɍɫɬɚɧɚɜɥɢɜɚɟɬ ɟɝɨ ɜ ɤɨɦɩɶɸɬɟɪ ɢ ɨɛɧɚɪɭɠɢɜɚɟɬ, ɱɬɨ ɦɟɝɚɛɚɣɬ
ɬɨɥɶɤɨ 476 ɫ ɱɟɦ-ɬɨ. ɍɤɪɚɥɢ! ȼ ɤɚɤɨɦ-ɬɨ ɫɦɵɫɥɟ ɞɚ, ɭɤɪɚɥɢ. ɉɪɨɞɚɜɰɵ
ɠɺɫɬɤɢɯ ɞɢɫɤɨɜ ɫɱɢɬɚɥɢ ɨɞɢɧ ɦɟɝɚɛɚɣɬ ɡɚ ɦɢɥɥɢɨɧ ɛɚɣɬ, ɚ ɤɨɦɩɶɸɬɟɪ ɧɟ
20
ɨɛɦɚɧɟɲɶ, ɨɧ ɬɪɟɛɨɜɚɥ ɢɦɟɧɧɨ
.
2
Ⱥ ɜ ɩɨɩɭɝɚɹɯ-ɬɨ ɹ ɞɥɢɧɧɟɟ ɛɭɞɭ!
© ɤɫɬɚɬɢ, ɉɢɬɨɧ, ɢɡ ɦɭɥɶɬɮɢɥɶɦɚ «38 ɩɨɩɭɝɚɟɜ»
ɂ ɞɚ, ɹ ɡɧɚɸ, ɱɬɨ ɜɫɺ ɧɟ ɬɚɤ ɩɪɨɫɬɨ – ɢ ɫ ɛɚɣɬɚɦɢ, ɢ ɫ ɬɟɪɚɛɚɣɬɚɦɢ, ɢ ɫɨ
ɫɥɨɜɚɦɢ, ɢ ɫɨ ɫɬɪɨɤɚɦɢ. Ɉɫɨɛɟɧɧɨ, ɤɨɧɟɱɧɨ, ɫɨ ɫɬɪɨɤɚɦɢ.
251
ɉɪɢɥɨɠɟɧɢɟ G. Ɉɛɦɟɧ ɞɚɧɧɵɦɢ ɫ ɞɪɭɝɢɦɢ ɩɪɨɝɪɚɦɦɚɦɢ
ɱɟɪɟɡ ɮɚɣɥɵ
Ʌɨɝɢɱɧɨ ɡɚɜɟɪɲɢɬɶ ɤɧɢɝɭ, ɨɛɫɭɞɢɜ, ɤɚɤ ɫɬɵɤɨɜɚɬɶ ɩɪɨɝɪɚɦɦɵ ɧɚ ɉɢɬɨɧɟ ɫ
ɩɪɨɝɪɚɦɦɚɦɢ ɧɚ ɞɪɭɝɢɯ ɹɡɵɤɚɯ ɢɥɢ ɤɚɤ ɧɚɩɢɫɚɬɶ ɟɞɢɧɭɸ ɩɪɨɝɪɚɦɦɭ
ɱɚɫɬɢɱɧɨ ɧɚ ɉɢɬɨɧɟ, ɚ ɱɚɫɬɢɱɧɨ ɧɚ C++ ɢɥɢ Ⱦɟɥɶɮɢ. ɇɚɩɢɫɚɬɶ ɨɞɧɭ
ɩɪɨɝɪɚɦɦɭ ɧɚ ɧɟɫɤɨɥɶɤɢɯ ɹɡɵɤɚɯ ɫɥɨɠɧɨ. Ɉɛɦɟɧɢɜɚɬɶɫɹ ɞɚɧɧɵɦɢ ɦɟɠɞɭ
ɞɜɭɦɹ ɩɪɨɝɪɚɦɦɚɦɢ, ɧɚɩɢɫɚɧɧɵɦɢ ɧɚ ɪɚɡɧɵɯ ɹɡɵɤɚɯ, ɦɧɨɝɨ ɩɪɨɳɟ. ɋɚɦɵɣ
ɩɪɨɫɬɨɣ ɫɩɨɫɨɛ – ɨɛɦɟɧɢɜɚɬɶɫɹ ɞɚɧɧɵɦɢ ɱɟɪɟɡ ɮɚɣɥɵ. ɗɬɨ ɦɟɞɥɟɧɧɨ, ɷɬɨ
ɧɟ ɨɱɟɧɶ ɧɚɞɺɠɧɨ, ɷɬɨ ɧɟɝɢɛɤɨ – ɧɨ ɷɬɨ ɨɱɟɧɶ ɩɪɨɫɬɨ ɢ ɨɱɟɧɶ ɩɨɧɹɬɧɨ.
ɗɬɢɦ ɢ ɡɚɣɦɟɦɫɹ.
ɂ ɩɨɜɬɨɪɸɫɶ – ɷɬɚ, ɩɨɫɥɟɞɧɹɹ ɜ ɤɧɢɝɟ ɡɚɞɚɱɚ, ɧɢ ɪɚɡɭ ɧɟ ɭɱɟɛɧɚɹ. ɗɬɨ
ɡɚɞɚɱɚ ɪɟɚɥɶɧɚɹ ɢ ɚɛɫɨɥɸɬɧɨ ɧɟɨɛɯɨɞɢɦɚɹ.
Ɉɩɹɬɶ-ɬɚɤɢ, ɟɫɥɢ ɜɚɫ ɢɧɬɟɪɟɫɭɟɬ ɬɨɥɶɤɨ ɢ ɢɫɤɥɸɱɢɬɟɥɶɧɨ
ɩɪɨɝɪɚɦɦɢɪɨɜɚɧɢɟ ɧɚ ɉɢɬɨɧɟ ɢ ɬɨɥɶɤɨ ɧɚ ɧɺɦ, ɷɬɨɬ ɪɚɡɞɟɥ ɦɨɠɧɨ ɫɦɟɥɨ
ɩɪɨɩɭɫɬɢɬɶ. ȿɫɥɢ ɜ ɜɚɲɢɯ ɩɥɚɧɚɯ ɭɱɚɫɬɢɟ ɜ ɛɨɥɶɲɢɯ ɩɪɨɟɤɬɚɯ, ɝɞɟ
ɡɚɞɟɣɫɬɜɨɜɚɧɵ ɪɚɡɧɵɟ ɫɪɟɞɵ ɢ ɹɡɵɤɢ ɩɪɨɝɪɚɦɦɢɪɨɜɚɧɢɹ, ɬɨ ɷɬɨɬ ɪɚɡɞɟɥ
ɥɭɱɲɟ ɩɪɨɱɢɬɚɬɶ.
ɗɬɨ ɟɞɢɧɫɬɜɟɧɧɵɣ ɪɚɡɞɟɥ ɢɡɨ ɜɫɟɣ ɤɧɢɝɢ, ɝɞɟ ɩɪɢɜɨɞɢɬɫɹ ɩɪɢɦɟɪ ɧɚ
ɞɪɭɝɨɦ ɹɡɵɤɟ. ɐɟɥɶ ɷɬɨɝɨ ɪɚɡɞɟɥɚ – ɩɪɨɞɟɦɨɧɫɬɪɢɪɨɜɚɬɶ, ɤɚɤ ɧɚɲɢ ɮɚɣɥɵ
ɢɡ ɉɢɬɨɧɚ ɛɭɞɭɬ ɱɢɬɚɬɶɫɹ ɜ ɞɪɭɝɨɦ ɹɡɵɤɟ ɢ, ɝɥɚɜɧɨɟ, ɤɚɤɢɟ ɩɪɢ ɷɬɨɦ ɦɨɝɭɬ
ɜɨɡɧɢɤɧɭɬɶ ɩɪɨɛɥɟɦɵ. ȼ ɤɚɱɟɫɬɜɟ ɞɪɭɝɨɝɨ ɹɡɵɤɚ ɛɭɞɟɬ ɢɫɩɨɥɶɡɨɜɚɧ Delphi
ɫɟɞɶɦɨɣ ɜɟɪɫɢɢ. Ɋɚɧɶɲɟ ɜ ɫɪɟɞɟ Ⱦɟɥɶɮɢ ɢɫɩɨɥɶɡɨɜɚɥɫɹ ɹɡɵɤ
ɩɪɨɝɪɚɦɦɢɪɨɜɚɧɢɹ Object Pascal, ɬɟɩɟɪɶ ɧɟɬ. ɇɟɬ, ɨɧ ɧɢɤɭɞɚ ɧɟ ɞɟɥɫɹ, ɟɝɨ
ɥɟɝɤɨ ɢ ɧɟɩɪɢɧɭɠɞɟɧɧɨ ɩɟɪɟɢɦɟɧɨɜɚɥɢ ɜ ɹɡɵɤ Delhi. ɋɥɟɞɭɸɳɢɟ, ɩɨɫɥɟ
ɫɟɞɶɦɨɣ, ɜɟɪɫɢɢ ɡɚɝɪɨɦɨɠɞɚɥɢ ɛɵ ɢɡɥɨɠɟɧɢɟ ɧɚɥɢɱɢɟɦ ɞɜɭɯɛɚɣɬɨɜɨɣ
ɤɨɞɢɪɨɜɤɢ ɫɢɦɜɨɥɨɜ.
Ɂɚɩɢɲɟɦ ɛɢɧɚɪɧɵɣ ɮɚɣɥ ɜ ɉɢɬɨɧɟ, ɷɬɨ ɦɵ ɭɦɟɟɦ, ɡɚɬɟɦ ɩɪɨɱɢɬɚɟɦ ɜ
Ⱦɟɥɶɮɢ. ɋɨɞɟɪɠɚɧɢɟ ɮɚɣɥɚ:
ɤɨɥɢɱɟɫɬɜɨ ɰɟɥɵɯ ɱɢɫɟɥ
ɫɚɦɢ ɰɟɥɵɟ ɱɢɫɥɚ ɜ ɫɨɨɬɜɟɬɫɬɜɭɸɳɟɦ ɤɨɥɢɱɟɫɬɜɟ
ɨɞɧɨ ɩɥɚɜɚɸɳɟɟ ɱɢɫɥɨ
ɞɜɟ ɫɬɪɨɤɢ
252
ɉɪɨɝɪɚɦɦɚ ɧɚ ɉɢɬɨɧɟ ɫ ɤɨɦɦɟɧɬɚɪɢɹɦɢ, ɤɨɬɨɪɵɟ ɛɭɞɭɬ ɞɥɢɧɧɵɦɢ:
x
import struct
#-----------------------------------------------def strToFile( S, F):
length = len(S)
data = struct.pack( '<i4', length)
F.write(data)
for i in xrange(0,length):
ch = S[i]
data = struct.pack( '<s1', ch)
F.write(data)
#------------------------------------------------
f = open( 'd:/py.bin', 'wb')
numOfInts = 10
data = struct.pack( '<i4', numOfInts)
f.write(data)
for i in xrange(0,numOfInts):
what = i*2 + 1
data = struct.pack( '<i4', what)
f.write(data)
x = 0.99**100
data = struct.pack( '<f4', x)
f.write(data)
stroka_1 = 'And the silken sad uncertain rustling of each purple curtain'
strToFile( stroka_1, f)
stroka_2 = 'ɗɯ ɪɚɡ, ɟɳɺ ɪɚɡ, ɟɳɺ ɦɧɨɝɨ ɦɧɨɝɨ ɪɚɡ'
strToFile( stroka_2, f)
f.close()
Ɂɚɩɢɫɶ ɫɬɪɨɤɢ ɜ ɮɚɣɥ ɨɮɨɪɦɥɟɧɚ ɜ ɜɢɞɟ ɮɭɧɤɰɢɢ – ɩɨɜɬɨɪɧɨ ɩɢɫɚɬɶ ɩɨɱɬɢ
ɨɞɢɧ ɢ ɬɨ ɠɟ ɤɨɞ ɤɚɤ ɦɢɧɢɦɭɦ ɞɜɚɠɞɵ ɨɬɤɪɨɜɟɧɧɨ ɥɟɧɶ. ɇɟɩɥɨɯɨ ɛɵ
ɨɮɨɪɦɢɬɶ ɚɧɚɥɨɝɢɱɧɵɦ ɨɛɪɚɡɨɦ ɢ ɡɚɩɢɫɶ ɜ ɮɚɣɥ ɞɥɹ ɞɪɭɝɢɯ ɬɢɩɨɜ
ɩɟɪɟɦɟɧɧɵɯ. Ɂɚɣɦɢɬɟɫɶ ɷɬɢɦ. ȼɵ ɫɨɫɱɢɬɚɥɢ ɜ ɭɦɟ, ɫɤɨɥɶɤɨ ɛɭɞɟɬ
0.99**100
, ɬɨ ɟɫɬɶ
100
99.0
? ə ɫɨɫɱɢɬɚɥ ɢ ɨɲɢɛɫɹ ɜɫɟɝɨ ɜ ɩɨɥɬɨɪɚ ɪɚɡɚ.
x =
ɉɨɩɪɨɛɭɣɬɟ ɢ ɜɵ.
Ɍɟɩɟɪɶ ɫɚɦɵɣ ɜɚɠɧɵɣ ɜɨɩɪɨɫ. ɉɨɱɟɦɭ ɫɬɪɨɤɢ ɩɢɲɭɬɫɹ ɢɦɟɧɧɨ ɬɚɤ, ɤɚɤ
ɨɧɢ ɩɢɲɭɬɫɹ ɡɞɟɫɶ? Ɉɬɜɟɬ – ɚ ɤɚɤ? ɍɧɢɜɟɪɫɚɥɶɧɨɝɨ ɫɩɨɫɨɛɚ ɧɟ
ɜɨɨɛɳɟ.
253
ɋɬɚɧɞɚɪɬɧɵɣ ɩɢɬɨɧɫɤɢɣ ɫɩɨɫɨɛ ɱɟɪɟɡ ɮɨɪɦɚɬ
s ɧɟ ɩɨɞɯɨɞɢɬ – ɱɢɬɚɸɳɚɹ
ɩɪɨɝɪɚɦɦɚ ɦɚɥɨ ɬɨɝɨ, ɱɬɨ ɧɟ ɞɨɝɚɞɚɟɬɫɹ, ɱɬɨ ɩɟɪɟɞ ɧɟɣ ɫɬɪɨɤɚ. Ⱦɚɠɟ ɟɫɥɢ
ɤɚɤɢɦ-ɬɨ ɱɭɞɨɦ ɨɧɚ ɷɬɨ ɩɨɣɦɺɬ, ɟɣ ɧɟɢɡɜɟɫɬɧɨ ɛɭɞɟɬ, ɫɤɨɥɶɤɨ ɜ ɫɬɪɨɤɟ
ɫɢɦɜɨɥɨɜ. ȼɬɨɪɨɣ ɮɨɪɦɚɬ, ɤɨɬɨɪɵɣ
p, ɤɚɠɟɬɫɹ ɛɨɥɟɟ ɩɟɪɫɩɟɤɬɢɜɧɵɦ. ȼɟɞɶ
ɨɧ ɫɩɟɰɢɚɥɶɧɨ ɞɥɹ ɫɨɜɦɟɫɬɢɦɨɫɬɢ ɫ ɉɚɫɤɚɥɟɦ, ɤɨɬɨɪɵɣ, ɤɚɤ ɜɫɟɦ ɢɡɜɟɫɬɧɨ,
ɬɨ ɠɟ Ⱦɟɥɶɮɢ, ɬɨɥɶɤɨ ɜ ɩɪɨɮɢɥɶ. ɇɨ ɟɫɬɶ ɧɸɚɧɫ. ɂɥɢ ɞɜɚ. Ɇɵ ɦɨɠɟɦ
ɡɚɩɢɫɚɬɶ – ɢ ɩɪɨɱɢɬɚɬɶ – ɬɚɤɢɦ ɫɩɨɫɨɛɨɦ ɬɨɥɶɤɨ ɤɨɪɨɬɤɢɟ ɫɬɪɨɤɢ, ɞɨ 255
ɫɢɦɜɨɥɨɜ. ɂ, ɫɚɦɨ ɫɨɛɨɣ, ɞɪɭɝɢɦ ɹɡɵɤɚɦ ɩɪɨɝɪɚɦɦɢɪɨɜɚɧɢɹ ɷɬɨɬ ɮɨɪɦɚɬ
ɫɨɜɟɪɲɟɧɧɨ ɧɟɢɡɜɟɫɬɟɧ.
ɉɨɷɬɨɦɭ ɦɵ ɛɭɞɟɦ ɩɢɫɚɬɶ ɫɬɪɨɤɢ ɜ ɮɚɣɥ ɜ ɮɨɪɦɚɬɟ, ɤɨɬɨɪɵɣ ɯɨɬɹ ɢ ɧɟ
ɭɧɢɜɟɪɫɚɥɟɧ, ɧɨ ɩɨɧɹɬɟɧ ɢ ɜɫɬɪɟɱɚɟɬɫɹ ɱɚɫɬɨ. ɋɧɚɱɚɥɚ ɞɥɢɧɚ ɫɬɪɨɤɢ ɤɚɤ
ɱɟɬɵɪɺɯɛɚɣɬɨɜɨɟ ɰɟɥɨɟ. Ɂɚɬɟɦ ɫɚɦɢ ɫɢɦɜɨɥɵ, ɩɨ ɛɚɣɬɭ ɧɚ ɫɢɦɜɨɥ. Ɍɨɱɧɨ
ɬɚɤ ɠɟ, ɤɚɤ ɢ ɜ ɉɢɬɨɧɟ, ɱɬɟɧɢɟ ɫɬɪɨɤɢ ɨɮɨɪɦɢɦ ɜ ɜɢɞɟ ɮɭɧɤɰɢɢ. ȼɨɬ
ɩɪɨɝɪɚɦɦɚ ɞɥɹ ɱɬɟɧɢɹ:
var
F : file;
numOfInts : integer;
int : integer;
fl : single;
stroka_1, stroka_2 : string;
i : integer;
{..........................................................}
function strFromFile( var F : file) : string;
var
length : integer;
ch : char;
i : integer;
begin
BlockRead( F, length, 4);
result:='';
for i:=1 to length do begin
BlockRead( F, ch, 1);
result:=result + ch;
end;
end;
{..........................................................}
begin
AssignFile( F, 'd:\py.bin');
ReSet( F, 1);
BlockRead( F, numOfInts, 4);
for i:=1 to numOfInts do begin
BlockRead( F, int, 4);
ShowMessage(IntToStr(int));
254
end;
BlockRead( F, fl, 4);
stroka_1:=strFromFile(F);
stroka_2:=strFromFile(F);
CloseFile(F);
end;
ɇɟ ɛɭɞɟɦ ɨɛɫɭɠɞɚɬɶ ɫɪɚɜɧɢɬɟɥɶɧɵɟ ɞɨɫɬɨɢɧɫɬɜɚ ɢ ɧɟɞɨɫɬɚɬɤɢ ɉɢɬɨɧɚ ɢ
ɉɚɫɤɚɥɹ ɢ ɜɨɨɛɳɟ ɤɚɤ-ɬɨ ɤɨɦɦɟɧɬɢɪɨɜɚɬɶ ɩɪɨɝɪɚɦɦɭ. ȿɞɢɧɫɬɜɟɧɧɨɟ, ɱɬɨ
ɨɬɦɟɱɭ – ɟɫɥɢ ɜ ɩɢɬɨɧɫɤɨɣ ɩɪɨɝɪɚɦɦɟ ɰɟɥɵɟ ɱɢɫɥɚ ɜɨɡɧɢɤɚɥɢ ɢɡ ɧɢɨɬɤɭɞɚ,
ɬɨ ɜ ɩɚɫɤɚɥɟɜɫɤɨɣ ɨɧɢ ɢɫɱɟɡɚɸɬ ɜ ɧɢɤɭɞɚ – ɜɵɜɨɞɹɬɫɹ ɧɚ ɷɤɪɚɧ, ɩɪɢɱɺɦ
ɤɚɠɞɨɟ – ɜ ɨɬɞɟɥɶɧɨɟ ɨɤɧɨ ɨɬɞɟɥɶɧɵɦ ɫɨɨɛɳɟɧɢɟɦ. ɗɬɨ ɹ ɤ ɬɨɦɭ, ɱɬɨ ɷɬɚ
ɱɚɫɬɶ ɨɛɟɢɯ ɩɪɨɝɪɚɦɦ ɫɨɜɟɪɲɟɧɧɨ ɭɫɥɨɜɧɚ ɢ ɜ ɪɟɚɥɶɧɨɣ ɩɪɚɤɬɢɤɟ ɞɨɥɠɧɚ
ɛɵɬɶ ɡɚɦɟɧɟɧɚ ɧɚ ɱɬɨ-ɬɨ ɨɫɦɵɫɥɟɧɧɨɟ.
Ɍɟɩɟɪɶ ɨɛɪɚɬɧɚɹ ɡɚɞɚɱɚ. Ɂɚɩɢɲɟɦ ɮɚɣɥ ɜ ɉɚɫɤɚɥɟ, ɬɨɥɶɤɨ ɩɪɨɳɟ: ɰɟɥɨɟ,
ɩɥɚɜɚɸɳɟɟ, ɫɬɪɨɤɚ. Ɂɚɩɢɫɶ ɫɬɪɨɤɢ, ɪɚɡɭɦɟɟɬɫɹ, ɨɮɨɪɦɢɦ ɤɚɤ ɩɪɨɰɟɞɭɪɭ.
var
len : integer;
ch : char;
i : integer;
begin
len:=Length(s);
BlockWrite( F, len, 4);
for i:=1 to len do begin
ch:=s[i];
BlockWrite( F, ch, 1);
end;
end;
{..........................................................}
begin
AssignFile( F, 'd:\pas.bin');
ReWrite( F, 1);
int:=12345;
BlockWrite( F, int, 4);
fl:=123.45;
BlockWrite( F, fl, 4);
stroka:='ɂ ɦɧɨɝɨ ɦɧɨɝɨ ɪɚɞɨɫɬɢ ɞɟɬɢɲɤɚɦ ɩɪɢɧɟɫɥɚ';
strToFile( F, stroka);
CloseFile(F);
255
end;
Ɉɛɪɚɬɢɬɟ ɜɧɢɦɚɧɢɟ ɧɚ ɩɟɪɟɢɦɟɧɨɜɚɧɢɟ ɩɟɪɟɦɟɧɧɨɣ ɢɡ
length ɜ len. ɉɟɪɜɨɟ
ɢɦɹ ɜ ɉɚɫɤɚɥɟ – ɢɦɹ ɜɫɬɪɨɟɧɧɨɣ ɮɭɧɤɰɢɢ, ɚ ɜɬɨɪɨɟ – ɧɟɬ. ȼ ɉɢɬɨɧɟ
ɧɚɨɛɨɪɨɬ. Ⱥ ɬɟɩɟɪɶ ɱɬɟɧɢɟ ɜ ɉɢɬɨɧɟ, ɬɨɠɟ ɫɨɜɟɪɲɟɧɧɨ ɫɢɦɦɟɬɪɢɱɧɨɟ:
# -*- coding: cp1251 -*-
import struct
def strFromFile(F):
result = ''
data = F.read(4)
length = struct.unpack('<i4',data)
for i in xrange(0,length[0]):
data = F.read(1)
ch = struct.unpack( '<s1', data)
result = result + ch[0]
return result
F = open( 'd:/pas.bin', 'rb')
data = F.read(4)
int = struct.unpack( '<i4', data)
print int
data = F.read(4)
fl = struct.unpack( '<f4', data)
print fl
stroka = strFromFile(F)
print stroka
F.close()
ɇɚɩɨɦɢɧɚɸ – ɩɪɢ ɱɬɟɧɢɢ ɢɡ ɛɢɧɚɪɧɨɝɨ ɮɚɣɥɚ ɞɚɧɧɵɟ ɱɢɬɚɸɬɫɹ ɧɟ ɩɪɨɫɬɨ
ɬɚɤ, ɚ ɜ ɤɨɪɬɟɠ. ɉɨɬɨɦ ɢɯ ɩɪɢɯɨɞɢɬɫɹ ɨɬɬɭɞɚ ɜɵɤɨɜɵɪɢɜɚɬɶ. ɗɬɨ ɨɬɧɨɫɢɬɫɹ
ɬɨɥɶɤɨ ɤ ɉɢɬɨɧɭ.
256
Соседние файлы в предмете [НЕСОРТИРОВАННОЕ]