Добавил:
ivanov666
Опубликованный материал нарушает ваши авторские права? Сообщите нам.
Вуз:
Предмет:
Файл:Простой Python просто с нуля
.pdf
ɥɨɝɢɱɟɫɤɨɟ ɜɵɪɚɠɟɧɢɟ, ɤɨɬɨɪɨɟ ɦɨɠɧɨ ɩɪɢɫɜɨɢɬɶ ɥɨɝɢɱɟɫɤɨɣ ɩɟɪɟɦɟɧɧɨɣ.
Ɉɛɞɭɦɚɣɬɟ. Ɍɟɩɟɪɶ ɫɥɭɱɚɣ ɩɨɡɚɤɨɜɵɪɢɫɬɟɟ. ɑɭɬɶ ɪɚɧɶɲɟ ɹ ɩɪɨɫɢɥ ɜɚɫ
ɡɚɤɨɞɢɪɨɜɚɬɶ ɭɫɥɨɜɧɵɣ ɨɩɟɪɚɬɨɪ ɞɥɹ ɩɪɨɜɟɪɤɢ ɜɢɫɨɤɨɫɧɨɝɨ ɝɨɞɚ.
Ɂɚɤɨɞɢɪɨɜɚɥɢ? ȼɪɺɬɟ, ɧɚɜɟɪɧɨɟ. ȿɫɥɢ ɬɚɤɢ ɞɚ, ɬɨ ɜɨɬ ɜɚɦ ɜɨɡɦɨɠɧɨɫɬɶ
ɩɪɨɜɟɪɢɬɶ ɩɪɚɜɢɥɶɧɨɫɬɶ ɜɚɲɟɝɨ ɪɟɡɭɥɶɬɚɬɚ:
year = int(raw_input('year = '))
leap = (year % 4 == 0) and ((year % 4 <> 0) or ((year/4) % 4 == 0))
if leap:
print 'leap year'
else:
print 'not leap'
ɗɬɨ ɤ ɜɨɩɪɨɫɭ ɨ ɩɨɥɟɡɧɨɫɬɢ ɩɪɨɦɟɠɭɬɨɱɧɵɯ ɩɟɪɟɦɟɧɧɵɯ. Ɉɱɟɧɶ ɧɟ
ɯɨɬɟɥɨɫɶ ɛɵ ɤɚɠɞɵɣ ɪɚɡ ɜɵɩɢɫɵɜɚɬɶ ɷɬɭ ɫɬɪɨɤɭ – ɜ ɫɥɭɱɚɟ, ɟɫɥɢ ɷɬɚ
ɩɪɨɜɟɪɤɚ ɩɨɧɚɞɨɛɢɬɫɹ ɜ ɩɪɨɝɪɚɦɦɟ ɛɨɥɟɟ ɨɞɧɨɝɨ ɪɚɡɚ. Ɋɚɡɭɦɟɟɬɫɹ, ɷɬɭ
ɩɪɨɛɥɟɦɭ, ɤɚɤ ɢ ɛɨɥɶɲɢɧɫɬɜɨ ɞɪɭɝɢɯ, ɦɨɠɧɨ ɪɟɲɢɬɶ ɛɨɥɟɟ ɱɟɦ ɨɞɧɢɦ
ɫɩɨɫɨɛɨɦ. Ʉ ɷɬɨɦɭ ɦɵ ɟɳɺ ɜɟɪɧɺɦɫɹ.
ɐɢɤɥɵ. Ɉɫɨɛɟɧɧɨɫɬɢ
Ɉ ɦɟɥɤɢɯ, ɧɨ ɜɚɠɧɵɯ ɜɟɳɚɯ. ɍɫɥɨɜɧɵɟ ɨɩɟɪɚɬɨɪɵ ɦɨɝɭɬ ɛɵɬɶ
ɜɥɨɠɟɧɧɵɦɢ, ɷɬɨ ɜɵ ɡɧɚɟɬɟ. Ɍɨɱɧɨ ɬɚɤ ɠɟ ɜɥɨɠɟɧɧɵɦɢ ɦɨɝɭɬ ɛɵɬɶ ɢ
ɰɢɤɥɵ. Ɋɚɡɭɦɟɟɬɫɹ, ɦɟɥɤɢɦ ɷɬɨ ɹɜɥɟɧɢɟ ɦɨɠɧɨ ɧɚɡɜɚɬɶ ɬɨɥɶɤɨ ɩɨɬɨɦɭ, ɱɬɨ
ɨɛ ɷɬɨɦ ɦɨɠɧɨ ɛɵɥɨ ɛɵ ɞɨɝɚɞɚɬɶɫɹ ɢ ɬɚɤ. ȼɥɨɠɟɧɧɵɟ ɰɢɤɥɵ – ɨɱɟɧɶ ɢ
ɨɱɟɧɶ ɜɚɠɧɚɹ ɜɟɳɶ ɜ ɥɸɛɨɣ ɩɪɨɝɪɚɦɦɟ. Ⱦɚɥɟɟ ɩɪɢɦɟɪ, ɛɟɫɩɨɥɟɡɧɵɣ
ɩɪɚɤɬɢɱɟɫɤɢ, ɧɨ ɜɩɨɥɧɟ ɫɟɛɟ ɚɤɬɭɚɥɶɧɵɣ ɦɚɬɟɦɚɬɢɱɟɫɤɢ. ȼɵɜɟɞɟɦ ɫɩɢɫɨɤ
ɩɪɨɫɬɵɯ ɱɢɫɟɥ, ɧɟ ɩɪɟɜɵɲɚɸɳɢɯ ɧɟɤɨɬɨɪɨɝɨ, ɡɚɪɚɧɟɟ ɡɚɞɚɧɧɨɝɨ ɡɧɚɱɟɧɢɹ.
ɉɪɨɫɬɨɟ ɱɢɫɥɨ, ɧɚɩɨɦɢɧɚɸ, – ɬɚɤɨɟ ɰɟɥɨɟ ɱɢɫɥɨ, ɤɨɬɨɪɨɟ ɧɟ ɞɟɥɢɬɫɹ ɛɟɡ
ɨɫɬɚɬɤɚ ɧɢ ɧɚ ɤɚɤɨɟ ɞɪɭɝɨɟ ɱɢɫɥɨ, ɤɪɨɦɟ ɟɞɢɧɢɰɵ ɢ ɫɚɦɨɝɨ ɫɟɛɹ. Ɉɝɨɜɨɪɤɭ
ɛɟɡ ɨɫɬɚɬɤɚ ɩɪɢɲɥɨɫɶ ɞɨɛɚɜɢɬɶ ɬɨɥɶɤɨ ɩɨɬɨɦɭ, ɱɬɨ ɭ ɧɚɫ ɜ
ɩɪɨɝɪɚɦɦɢɪɨɜɚɧɢɢ ɟɫɬɶ ɢ ɞɟɥɟɧɢɟ ɫ ɨɫɬɚɬɤɨɦ, ɦɚɬɟɦɚɬɢɤɚɦ ɷɬɨ ɜɨɨɛɳɟ
ɧɟɩɨɧɹɬɧɨ. Ʉɪɨɦɟ ɬɨɝɨ, ɨɩɹɬɶ ɠɟ – ɫɩɚɫɢɛɨ ɦɚɬɟɦɚɬɢɤɚɦ – ɟɞɢɧɢɰɚ ɧɟ
ɫɱɢɬɚɟɬɫɹ ɩɪɨɫɬɵɦ ɱɢɫɥɨɦ. ȿɫɥɢ ɟɞɢɧɢɰɭ ɩɪɢɡɧɚɬɶ ɡɚ ɰɟɥɨɟ ɱɢɫɥɨ,
ɪɭɲɢɬɫɹ ɜɫɹ ɬɟɨɪɢɹ ɱɢɫɟɥ. ɇɚ ɜɫɹɤɢɣ ɫɥɭɱɚɣ – ɟɫɥɢ ɱɢɫɥɨ ɧɟ ɩɪɨɫɬɨɟ, ɬɨ
ɨɧɨ
ɫɨɫɬɚɜɧɨɟ.
Ɉɛɳɚɹ ɫɬɪɭɤɬɭɪɚ ɩɪɨɝɪɚɦɦɵ ɜɢɞɢɬɫɹ ɝɞɟ-ɬɨ ɬɚɤ:
ɜɜɟɫɬɢ ɩɪɟɞɟɥ ɱɢɫɥɚ , ɞɨ ɤɨɬɨɪɨɝɨ ɢɳɟɦ
81
ɰɢɤɥ ɩɨ ɱɢɫɥɭ ɞɨ ɩɪɟɞɟɥɚ
ɰɢɤɥ ɩɨ ɞɟɥɢɬɟɥɸ ɞɨ ɩɪɟɞɟɥɚ
ɟɫɥɢ ɱɢɫɥɨ ɞɟɥɢɬɫɹ ɧɚ ɞɟɥɢɬɟɥɶ ɛɟɡ ɨɫɬɚɬɤɚ, ɡɧɚɱɢɬ ɨɧɨ ɧɟ ɩɪɨɫɬɨɟ
ɟɫɥɢ ɱɢɫɥɨ ɩɪɨɫɬɨɟ, ɬɨ ɜɵɜɟɫɬɢ
ɉɟɪɟɜɨɞɢɬɶ ɷɬɨ ɩɫɟɜɞɨɤɨɞ ɜ ɤɨɞ ɪɟɚɥɶɧɵɣ ɦɨɠɧɨ ɩɨɱɬɢ ɩɨɫɬɪɨɱɧɨ. ɉɨɱɬɢ
– ɩɨɬɨɦɭ ɱɬɨ ɩɨɬɪɟɛɭɟɬɫɹ ɢɧɢɰɢɚɥɢɡɚɰɢɹ ɥɨɝɢɱɟɫɤɨɣ ɩɟɪɟɦɟɧɧɨɣ,
ɨɬɜɟɱɚɸɳɟɣ ɡɚ ɫɚɦɨɟ ɝɥɚɜɧɨɟ – ɡɚ ɩɪɢɡɧɚɤ ɩɪɨɫɬɨɬɵ.
howMany = int(raw_input('howMany = '))
for i in xrange(2,howMany+1):
prime = True
for k in xrange(2,i):
if i % k == 0:
prime = False
if prime:
print(i)
ɉɪɨɝɪɚɦɦɚ ɪɚɛɨɬɚɟɬ, ɹ ɩɪɨɜɟɪɹɥ, ɫ ɜɨɬ ɬɚɤɢɦ ɪɟɡɭɥɶɬɚɬɨɦ:
howMany = 10
2
3
5
7
ɑɬɨ ɧɟ ɫɨɜɫɟɦ ɯɨɪɨɲɨ ɜ ɷɬɨɣ ɩɪɨɝɪɚɦɦɟ? ə ɧɢɤɨɝɞɚ ɧɟ ɛɵɥ ɫɬɨɪɨɧɧɢɤɨɦ
ɨɩɬɢɦɢɡɚɰɢɢ ɩɪɨɝɪɚɦɦɧɨɝɨ ɤɨɞɚ. ə ɜɫɟɝɞɚ ɛɵɥ ɩɪɨɬɢɜɧɢɤɨɦ ɭɥɭɱɲɟɧɢɹ ɢ
ɨɫɨɛɟɧɧɨ ɭɫɤɨɪɟɧɢɹ. ɇɨ ɨɞɧɨ ɞɟɥɨ, ɤɨɝɞɚ ɩɪɨɝɪɚɦɦɚ ɫɬɚɥɚ ɪɚɛɨɬɚɬɶ ɜ
ɞɟɫɹɬɶ ɢɥɢ ɞɚɠɟ ɜ ɫɬɨ ɪɚɡ. Ɉɧɨ ɧɟ ɫɬɨ
ғɢɬ ɭɫɢɥɢɣ, ɨɛɵɱɧɨ. Ɍɭɬ ɫɢɬɭɚɰɢɹ
ɧɟɫɤɨɥɶɤɨ ɢɧɚɹ. Ʉɨɝɞɚ ɦɵ ɢɳɟɦ ɩɪɨɫɬɵɟ ɱɢɫɥɚ ɜ ɩɪɟɞɟɥɚɯ ɩɟɪɜɨɝɨ
ɞɟɫɹɬɤɚ, ɜɨɩɪɨɫɨɜ ɧɟɬ. ɇɨ ɱɬɨ ɛɭɞɟɬ, ɤɨɝɞɚ ɜ ɩɪɟɞɟɥɚɯ ɩɟɪɜɨɝɨ ɦɢɥɥɢɨɧɚ?
Ɉɬɜɟɬ – ɜɧɭɬɪɟɧɧɢɣ ɰɢɤɥ ɜɵɩɨɥɧɢɬɫɹ ɜ ɫɪɟɞɧɟɦ 500000 ɪɚɡ. ɇɟɨɛɯɨɞɢɦɨ
ɥɢ ɷɬɨ? Ɉɬɜɟɬ – ɫɨɜɫɟɦ ɧɟɬ, ɢɦɟɟɬ ɫɦɵɫɥ ɞɥɹ ɱɢɫɥɚ N ɩɪɨɜɟɪɹɬɶ ɬɨɥɶɤɨ ɞɨ
N , ɤɫɬɚɬɢ, ɩɨɱɟɦɭ? Ɍɚɤ ɱɬɨ ɧɟ ɧɚɞɨ ɜɵɩɨɥɧɹɬɶ ɰɢɤɥ ɛɨɥɶɲɟ ɱɟɦ §707
ɪɚɡ. ɇɚɲɚ ɩɪɨɝɪɚɦɦɚ ɧɚɫɬɨɥɶɤɨ ɧɟɷɮɮɟɤɬɢɜɧɚ, ɱɬɨ ɷɬɨ, ɩɨɠɚɥɭɣ, ɫɥɢɲɤɨɦ
ɞɚɠɟ ɞɥɹ ɦɟɧɹ. ɉɨɩɪɚɜɢɦ ɜɫɟɝɨ ɨɞɧɭ ɫɬɪɨɤɭ:
for k in xrange(2,int(i**0.5)+1):
Ɉɛɪɚɬɢɬɟ ɜɧɢɦɚɧɢɟ ɧɚ +1. Ɉɛɞɭɦɚɣɬɟ, ɩɨɱɟɦɭ ɨɬɫɭɬɫɬɜɢɟ ɷɬɨɝɨ ɚɛɫɨɥɸɬɧɨ
ɛɟɡɪɚɡɥɢɱɧɨ ɜ ɢɫɯɨɞɧɨɦ ɤɨɞɟ ɢ ɠɢɡɧɟɧɧɨ ɧɟɨɛɯɨɞɢɦɨ ɜ ɭɥɭɱɲɟɧɧɨɦ.
82
# ɨɱɟɜɢɞɧɨɟ ɡɚɦɟɱɚɧɢɟ
ȼɩɪɨɱɟɦ, ɨɱɟɜɢɞɧɨɟ ɨɧɨ ɧɚ ɬɨ ɢ ɨɱɟɜɢɞɧɨɟ, ɱɬɨ ɨɱɟɜɢɞɧɨ ɧɟ ɜɫɟɝɞɚ ɢ ɧɟ ɞɥɹ
ɜɫɟɯ. ɉɟɪɟɦɟɧɧɚɹ I ɨɩɪɟɞɟɥɟɧɚ ɬɨɥɶɤɨ ɜɧɭɬɪɢ ɜɧɟɲɧɟɝɨ ɰɢɤɥɚ, ɨɛɪɚɳɚɬɶɫɹ
ɤ ɧɟɣ ɫɧɚɪɭɠɢ ɷɬɨɝɨ ɰɢɤɥɚ ɧɟɥɶɡɹ. ɉɟɪɟɦɟɧɧɚɹ K ɨɩɪɟɞɟɥɟɧɚ ɬɨɥɶɤɨ ɜɨ
ɜɧɭɬɪɟɧɧɟɦ ɰɢɤɥɟ. ɉɨɫɤɨɥɶɤɭ ɜɧɭɬɪɟɧɧɢɣ ɰɢɤɥ ɩɨ ɱɢɫɬɨɣ ɫɥɭɱɚɣɧɨɫɬɢ
ɧɚɯɨɞɢɬɫɹ ɜɧɭɬɪɢ ɜɧɟɲɧɟɝɨ, ɜ ɧɺɦ – ɜɧɭɬɪɟɧɧɟɦ ɰɢɤɥɟ, ɦɨɠɧɨ ɨɛɪɚɳɚɬɶɫɹ
ɢ ɤ I ɢ ɤ K.
# ɤɨɧɟɰ Ɉɱɟɜɢɞɧɨɝɨ ɡɚɦɟɱɚɧɢɹ
ɉɨɤɚ ɱɬɨ ɧɢ ɫ ɱɟɦ ɧɨɜɵɦ ɦɵ ɧɟ ɩɨɡɧɚɤɨɦɢɥɢɫɶ, ɬɨɥɶɤɨ ɜɥɨɠɟɧɧɵɟ ɰɢɤɥɵ,
ɧɨ ɞɨ ɬɨɝɨ, ɱɬɨ ɨɞɢɧ ɰɢɤɥ ɦɨɠɟɬ ɧɚɯɨɞɢɬɶɫɹ ɜɧɭɬɪɢ ɞɪɭɝɨɝɨ, ɞɨɝɚɞɚɬɶɫɹ
ɦɨɠɧɨ ɛɵɥɨ ɢ ɛɟɡ ɩɨɞɫɤɚɡɨɤ. Ⱥ ɬɟɩɟɪɶ ɜɵɭɱɢɦ ɧɨɜɨɟ ɫɥɨɜɨ, ɞɚɠɟ ɞɜɚ –
ɩɨɥɟɡɧɨɟ ɢ ɛɟɫɩɨɥɟɡɧɨɟ. ɇɚɱɧɺɦ ɫ ɩɨɥɟɡɧɨɝɨ, ɚ ɡɚɨɞɧɨ ɨɩɹɬɶ ɭɫɤɨɪɢɦ ɧɚɲɭ
ɩɪɨɝɪɚɦɦɭ, ɢ ɨɩɹɬɶ ɡɚɦɟɬɧɨ. ɋɤɨɥɶɤɨ ɪɚɡ ɜɵɩɨɥɧɹɟɬɫɹ ɜɧɭɬɪɟɧɧɢɣ ɰɢɤɥ?
ɉɪɚɜɢɥɶɧɨ,
N . ɇɟɨɛɯɨɞɢɦɨ ɥɢ ɷɬɨ? Ʉɨɧɟɱɧɨ ɧɟɬ, ɜɟɞɶ ɤɚɤ ɬɨɥɶɤɨ ɦɵ
ɨɛɧɚɪɭɠɢɥɢ ɞɟɥɢɦɨɫɬɶ ɧɚɰɟɥɨ, ɬɨ ɟɫɬɶ ɩɟɪɜɵɣ ɞɟɥɢɬɟɥɶ, ɬɨ ɩɪɨɜɟɪɹɬɶ
ɞɚɥɶɲɟ ɧɟ ɧɚɞɨ, ɱɢɫɥɨ ɫɨɫɬɚɜɧɨɟ. Ɇɟɧɹɟɦ ɜɧɭɬɪɟɧɧɢɣ ɰɢɤɥ ɫ ɩɨɦɨɳɶɸ
ɧɚɲɟɝɨ ɧɨɜɨɝɨ ɫɥɨɜɚ:
for k in xrange(2,int(i**0.5)+1):
if i % k == 0:
prime = False
break
ɑɬɨ ɞɟɥɚɟɬ ɨɩɟɪɚɬɨɪ
break? ɗɬɨɬ ɨɩɟɪɚɬɨɪ ɧɟɦɟɞɥɟɧɧɨ ɡɚɜɟɪɲɚɟɬ
ɜɵɩɨɥɧɟɧɢɟ ɰɢɤɥɚ. ɇɨ, ɜɚɠɧɚɹ ɞɟɬɚɥɶ, ɡɚɜɟɪɲɚɟɬ ɜɵɩɨɥɧɟɧɢɟ ɬɨɥɶɤɨ
ɧɭɬɪɟɧɧɟɝɨ ɰɢɤɥɚ. ȿɳɺ ɬɨɱɧɟɟ – ɨɧ ɡɚɜɟɪɲɚɟɬ ɜɵɩɨɥɧɟɧɢɟ ɢɦɟɧɧɨ ɬɨɝɨ
ɜ
ɰɢɤɥɚ, ɜ ɤɨɬɨɪɨɦ ɧɚɯɨɞɢɬɫɹ. ȿɫɥɢ ɛɵ ɜɧɭɬɪɢ ɜɧɟɲɧɟɝɨ ɰɢɤɥɚ ɛɵɥɨ ɛɵ
ɧɟɫɤɨɥɶɤɨ ɜɧɭɬɪɟɧɧɢɯ, ɢ ɧɟ ɜɧɭɬɪɢ ɨɞɢɧ ɞɪɭɝɨɝɨ, ɚ ɧɚ ɨɞɧɨɦ ɭɪɨɜɧɟ, ɬɨ
ɡɚɜɟɪɲɢɥɫɹ ɛɵ ɬɨɥɶɤɨ ɨɞɢɧ ɢɡ ɧɢɯ. ɋɦɨɞɟɥɢɪɭɣɬɟ ɢ ɩɪɨɜɟɪɶɬɟ. Ⱥ ɱɬɨ
ɛɭɞɟɬ, ɟɫɥɢ ɧɚɩɢɫɚɬɶ ɬɚɤ?
for i in xrange(2,howMany+1):
prime = True
for k in xrange(2,int(i**0.5)+1):
if i % k == 0:
prime = False
break
if prime:
print(i)
break
83
ɉɪɚɜɢɥɶɧɨ, ɛɭɞɟɬ ɜɵɜɟɞɟɧɨ ɩɟɪɜɨɟ ɩɪɨɫɬɨɟ ɱɢɫɥɨ ɢ ɧɚ ɷɬɨɦ ɜɫɺ
ɡɚɤɨɧɱɢɬɫɹ. ȿɫɬɶ ɥɢ ɜ ɷɬɨɦ ɫɦɵɫɥ? ɇɢɤɚɤɨɝɨ, ɦɵ ɢ ɬɚɤ ɡɧɚɟɦ, ɱɬɨ ɩɟɪɜɨɟ
ɩɪɨɫɬɨɟ ɱɢɫɥɨ – 2. Ⱥ ɜɨɬ ɟɫɥɢ ɛɵ ɦɵ ɜɜɨɞɢɥɢ ɧɟ ɞɢɚɩɚɡɨɧ, ɜ ɩɪɟɞɟɥɚɯ
ɤɨɬɨɪɨɝɨ ɢɳɟɦ ɩɪɨɫɬɵɟ ɱɢɫɥɚ, ɚ ɱɢɫɥɨ,
ɧɚɱɢɧɚɹ ɫ ɤɨɬɨɪɨɝɨ ɢɫɤɚɬɶ
ɧɚɢɦɟɧɶɲɟɟ ɩɪɨɫɬɨɟ ɱɢɫɥɨ, ɬɨ ɫɦɵɫɥ ɛɵɥ ɛɵ ɢ ɜɩɨɥɧɟ ɦɚɬɟɦɚɬɢɱɟɫɤɢ
ɤɨɪɪɟɤɬɧɵɣ. ɂɡɦɟɧɢɬɟ ɩɪɨɝɪɚɦɦɭ ɞɥɹ ɷɬɨɣ ɰɟɥɢ. Ʉɨɝɞɚ ɩɪɨɝɪɚɦɦɚ
ɡɚɪɚɛɨɬɚɟɬ, ɞɨɛɚɜɶɬɟ ɫɧɚɪɭɠɢ ɭɫɥɨɜɧɵɣ ɨɩɟɪɚɬɨɪ, ɱɬɨɛɵ ɩɪɨɝɪɚɦɦɚ ɩɨ
ɜɵɛɨɪɭ ɪɚɛɨɬɚɥɚ ɜ ɥɸɛɨɦ ɢɡ ɞɜɭɯ ɪɟɠɢɦɨɜ –
ɠɚɥɭɣɬɟɫɶ!
Ɍɹɠɟɥɚ ɢ ɧɟɤɚɡɢɫɬɚ ɠɢɡɧɶ ɩɪɨɫɬɨɝɨ ɩɪɨɝɪɚɦɦɢɫɬɚ ©
ɞɨ ɱɢɫɥɚ ɢ ɨɬ ɱɢɫɥɚ. ɇɟ
ɇɚɪɨɞɧɨɟ.
Ɍɟɩɟɪɶ ɩɪɟɞɫɬɚɜɥɹɸ ɨɛɟɳɚɧɧɨɟ ɜɬɨɪɨɟ, ɚɧɚɥɨɝɢɱɧɨ ɛɟɫɩɨɥɟɡɧɨɟ ɫɥɨɜɨ.
Ⱦɥɹ ɬɪɟɧɢɪɨɜɤɢ ɚɧɚɥɨɝɢɱɧɨ ɛɟɫɩɨɥɟɡɧɚɹ ɩɪɨɝɪɚɦɦɚ:
for i in xrange(1, 5+1):
print 'i = ', i, i**0.5
i = 1 1.0
i = 2 1.41421356237
i = 3 1.73205080757
i = 4 2.0
i = 5 2.2360679775
ɑɬɨɛɵ ɧɟ ɛɵɬɶ ɫɨɜɫɟɦ ɭɠ ɛɟɫɩɨɥɟɡɧɨɣ, ɨɧɚ ɜɵɜɨɞɢɬ ɤɜɚɞɪɚɬɧɵɟ ɤɨɪɧɢ ɢɡ
ɩɟɪɜɵɯ ɩɹɬɢ ɧɚɬɭɪɚɥɶɧɵɯ ɱɢɫɟɥ. ɏɢɬɪɚɹ ɡɚɩɢɫɶ 5+1 ɭɩɪɨɳɚɟɬ ɩɨɧɢɦɚɧɢɟ.
Ɍɟɩɟɪɶ ɞɨɛɚɜɥɹɟɦ ɜɨɥɲɟɛɧɨɟ ɫɥɨɜɨ:
for i in xrange(1, 5+1):
if i % 2 == 0:
continue
print 'i = ', i, i**0.5
i = 1 1.0
i = 3 1.73205080757
i = 5 2.2360679775
ɑɬɨ ɞɟɥɚɟɬ ɨɩɟɪɚɬɨɪ, ɢɦɟɧɢ ɤɨɬɨɪɨɝɨ ɹ ɞɚɠɟ ɧɟ ɯɨɱɭ ɜɫɩɨɦɢɧɚɬɶ? Ɉɧ
ɢɝɧɨɪɢɪɭɟɬ ɜɫɺ, ɱɬɨ ɧɚɯɨɞɢɬɫɹ ɜɧɭɬɪɢ ɰɢɤɥɚ ɩɨɫɥɟ ɧɟɝɨ, ɢ ɩɟɪɟɯɨɞɢɬ ɤ
ɜɵɩɨɥɧɟɧɢɸ ɰɢɤɥɚ ɫ ɫɚɦɨɝɨ ɧɚɱɚɥɚ, ɧɨ ɭɠɟ ɫ ɭɜɟɥɢɱɟɧɧɨɣ ɧɚ ɟɞɢɧɢɰɭ
ɩɟɪɟɦɟɧɧɨɣ ɰɢɤɥɚ. ə ɫɱɢɬɚɸ, ɱɬɨ ɷɬɨɬ ɨɩɟɪɚɬɨɪ ɛɟɫɩɨɥɟɡɧɵɣ ɢ ɞɚɠɟ
ɜɪɟɞɧɵɣ. ɇɟɦɟɞɥɟɧɧɨ ɡɚɛɭɞɶɬɟ.
84
Ⱦɨɜɨɥɶɧɨ-ɬɚɤɢ ɫɥɨɠɧɚɹ ɡɚɞɚɱɚ
ɇɚ ɜɫɹɤɢɣ ɫɥɭɱɚɣ, ɩɪɟɞɭɩɪɟɠɞɚɸ – ɷɬɨ ɧɟ ɹ ɩɪɢɞɭɦɚɥ. ɂɡɨɛɪɚɡɢɬɶ ɬɚɛɥɢɰɭ
ɭɦɧɨɠɟɧɢɹ, ɜɨɬ ɜ ɬɚɤɨɦ ɜɢɞɟ:
1 2 3 4 5 6 7 8 9
1 1 2 3 4 5 6 7 8 9
2 2 4 6 8 10 12 14 16 18
3 3 6 9 12 15 18 21 24 27
4 4 8 12 16 20 24 28 32 36
5 5 10 15 20 25 30 35 40 45
6 6 12 18 24 30 36 42 48 54
7 7 14 21 28 35 42 49 54 63
8 8 16 24 32 40 48 56 64 72
9 9 18 27 36 45 54 63 72 81
Ƚɨɜɨɪɹɬ, ɷɬɨ ɬɚɛɥɢɰɚ ɉɢɮɚɝɨɪɚ ɢ ɩɪɢɞɭɦɚɥ ɟɺ ɉɢɮɚɝɨɪ – ɩɨɱɟɦɭ, ɧɟ ɡɧɚɸ.
ȼɪɭɬ, ɨɞɧɨɡɧɚɱɧɨ. Ɋɚɡɜɢɜɚɟɬ ɛɚɡɨɜɵɟ ɧɚɜɵɤɢ ɜɵɜɨɞɚ ɬɟɤɫɬɨɜɨɣ
ɢɧɮɨɪɦɚɰɢɢ. ɇɚɱɢɧɚɟɦ ɫ ɰɟɧɬɪɚɥɶɧɨɝɨ ɛɥɨɤɚ. ɉɨɧɹɬɧɨ, ɱɬɨ ɝɞɟ-ɬɨ ɞɨɥɠɟɧ
ɛɵɬɶ ɜɥɨɠɟɧɧɵɣ ɰɢɤɥ. ɇɚɦ ɧɭɠɧɵ ɜɡɚɢɦɧɵɟ ɩɪɨɢɡɜɟɞɟɧɢɹ ɱɢɫɟɥ ɨɬ 1 ɞɨ
10. ɉɨɷɬɨɦɭ ɩɢɲɟɦ:
for i in xrange(1,11):
s = str(i).rjust(3) + ' '
for k in xrange(1,11):
s = s + str(i*k).rjust(3) + ' '
print s
Ɉɛɪɚɬɢɬɟ ɜɧɢɦɚɧɢɟ, ɦɵ ɫɧɚɱɚɥɚ ɤɥɟɢɦ ɜɫɺ, ɱɬɨ ɩɨɡɠɟ ɧɚ ɷɤɪɚɧɟ ɛɭɞɟɬ ɜ
ɨɞɧɨɣ (ɷɤɪɚɧɧɨɣ) ɫɬɪɨɤɟ, ɜ ɨɞɧɭ (ɫɢɦɜɨɥɶɧɭɸ) ɫɬɪɨɤɭ, ɚ ɡɚɬɟɦ ɷɬɭ
ɫɢɦɜɨɥɶɧɭɸ ɫɬɪɨɤɭ ɜɵɜɨɞɢɦ ɧɚ ɷɤɪɚɧ. ȼɬɨɪɨɟ – ɷɬɨ ɮɭɧɤɰɢɹ
rjust, ɤɚɤ ɜɚɦ ɛɨɥɶɲɟ ɧɪɚɜɢɬɫɹ. str(i*k) ɩɪɟɜɪɚɳɚɟɬ ɩɪɨɢɡɜɟɞɟɧɢɟ
ɦɟɬɨɞ
I*K ɜ ɫɬɪɨɤɭ, ɚ rjust(3) ɞɨɛɚɜɥɹɟɬ ɤ ɷɬɨɣ ɫɬɪɨɤɟ ɧɟɨɛɯɨɞɢɦɨɟ ɤɨɥɢɱɟɫɬɜɨ
rjust. ɂɥɢ
ɩɪɨɛɟɥɨɜ ɫɥɟɜɚ, ɱɬɨɛɵ ɨɛɳɚɹ ɞɥɢɧɚ ɫɬɪɨɤɢ ɫɨɫɬɚɜɢɥɚ ɬɪɢ ɫɢɦɜɨɥɚ. Ɍɟɩɟɪɶ
ɭ ɧɚɫ ɟɫɬɶ ɰɟɧɬɪɚɥɶɧɚɹ ɱɚɫɬɶ ɬɚɛɥɢɰɵ. Ⱦɨɛɚɜɥɹɟɦ ɫɬɪɨɤɭ ɫɜɟɪɯɭ:
s = ''
for i in xrange(1,11):
s = s + ' ' +str(i).rjust(3)
print s
85
print
print ɛɟɡ ɩɚɪɚɦɟɬɪɨɜ ɜɫɬɚɜɥɹɟɬ ɩɭɫɬɭɸ ɫɬɪɨɤɭ. Ⱦɨɛɚɜɥɹɟɦ ɫɬɪɨɤɭ ɫɥɟɜɚ.
ɉɪɟɠɞɟ ɷɬɨɝɨ ɩɪɢɞɺɬɫɹ ɫɥɟɝɤɚ ɦɨɞɢɮɢɰɢɪɨɜɚɬɶ ɨɫɧɨɜɧɨɣ ɰɢɤɥ:
for i in xrange(1,11):
s = str(i).rjust(3) + ' '
for k in xrange(1,11):
s = s + str(i*k).rjust(3) + ' '
print s
Ɍɟɩɟɪɶ ɨɫɬɚɥɨɫɶ ɬɨɥɶɤɨ ɡɚɦɟɧɢɬɶ ɫɚɦɭɸ ɩɟɪɜɭɸ ɫɬɪɨɤɭ, ɤɨɬɨɪɚɹ
s = ''.
Ⱦɨɛɚɜɶɬɟ ɧɭɠɧɨɟ ɤɨɥɢɱɟɫɬɜɨ ɩɪɨɛɟɥɨɜ, ɱɬɨɛɵ ɜɫɺ ɫɬɚɥɨ ɤɪɚɫɢɜɨ.
Ⱦɪɭɝɢɟ ɰɢɤɥɵ
ȼ ɉɢɬɨɧɟ ɟɫɬɶ ɟɳɺ ɨɞɢɧ, ɞɪɭɝɨɣ ɰɢɤɥ. ɋɧɚɱɚɥɚ ɧɚɩɢɲɟɦ ɟɝɨ ɬɚɤ, ɤɚɤ
ɧɚɩɢɫɚɬɶ ɟɝɨ ɦɨɠɧɨ, ɧɨ ɫɦɵɫɥɚ ɧɢɤɚɤɨɝɨ ɜ ɷɬɨɦ ɧɟɬ – ɡɚɬɨ ɜɫɺ ɩɨɧɹɬɧɨ.
i = 1
while i < 5:
print i
i = i + 1
1
2
3
4
ɋɨɜɟɪɲɟɧɧɨ ɨɱɟɜɢɞɧɨ, ɱɬɨ ɩɪɟɞɵɞɭɳɢɣ ɰɢɤɥ ɷɤɜɢɜɚɥɟɧɬɟɧ
ɩɨɫɥɟɞɭɸɳɟɦɭ:
for i in xrange(1,5):
print i
Ɍɪɭɞɧɨ ɧɟ ɫɨɝɥɚɫɢɬɶɫɹ, ɱɬɨ ɜɬɨɪɨɣ ɜɚɪɢɚɧɬ ɤɨɪɨɱɟ ɢ, ɝɥɚɜɧɟɟ, ɩɨɧɹɬɧɟɟ.
Ɍɨɝɞɚ ɡɚɱɟɦ ɧɚɦ ɧɭɠɟɧ ɩɟɪɜɵɣ? ȼ ɫɥɭɱɚɟ ɩɪɢɦɟɧɟɧɢɹ ɰɢɤɥɚ
ɡɧɚɟɦ, ɫɤɨɥɶɤɨ ɪɚɡ ɜɵɩɨɥɧɢɬɫɹ ɰɢɤɥ – ɟɫɥɢ ɧɟ ɢɫɩɨɥɶɡɨɜɚɬɶ
ɪɚɡɭɦɟɟɬɫɹ. ȿɫɥɢ ɧɚɦ ɩɨɬɪɟɛɨɜɚɥɫɹ ɰɢɤɥ
while – ɦɵ ɧɟ ɡɧɚɟɦ ɡɚɪɚɧɟɟ,
for ɦɵ ɜɫɟɝɞɚ
break,
ɫɤɨɥɶɤɨ ɪɚɡ ɨɧ ɛɭɞɟɬ ɜɵɩɨɥɧɹɬɶɫɹ. ȿɳɺ ɨɞɧɨ ɭɫɥɨɠɧɟɧɢɟ – ɩɟɪɟɦɟɧɧɨɣ
ɰɢɤɥɚ ɧɟɬ. ɂɥɢ ɟɺ ɧɟɬ ɜ ɹɜɧɨɦ ɜɢɞɟ ɢ ɩɟɪɟɦɟɧɧɭɸ ɷɬɭ ɩɪɢɲɥɨɫɶ ɛɵ ɜɜɨɞɢɬɶ
ɢɫɤɭɫɫɬɜɟɧɧɨ, ɤɚɤ ɜ ɩɪɢɦɟɪɟ ɜɵɲɟ.
86
ɋɚɦɚɹ ɱɚɫɬɚɹ ɫɢɬɭɚɰɢɹ ɩɪɢɦɟɧɟɧɢɹ ɰɢɤɥɚ
S
while – ɚɤɬɢɜɧɨɟ ɢ
ɧɟɩɪɟɞɫɤɚɡɭɟɦɨɟ ɭɱɚɫɬɢɟ ɩɨɥɶɡɨɜɚɬɟɥɹ ɜ ɪɚɛɨɬɟ ɩɪɨɝɪɚɦɦɵ. ɉɪɢɦɟɪ –
ɥɸɛɚɹ ɢɝɪɭɲɤɚ. Ɇɵ ɜɟɞɶ ɧɟ ɡɧɚɟɦ ɡɚɪɚɧɟɟ, ɤɨɝɞɚ ɢɝɪɨɤ ɧɚɠɦɺɬ ɧɚ ɤɥɚɜɢɲɭ
ɢɥɢ ɤɨɝɞɚ ɜɫɺ ɢɝɪɨɤɭ ɧɚɞɨɟɫɬ, ɢ ɨɧ ɡɚɯɨɱɟɬ ɜɵɣɬɢ ɢɡ ɢɝɪɵ. ɇɨ ɞɨ ɷɬɨɣ
ɤɚɬɟɝɨɪɢɢ ɡɚɞɚɱ ɧɚɦ ɟɳɺ ɞɚɥɟɤɨ, ɜɵɛɟɪɟɦ ɱɬɨ-ɧɢɛɭɞɶ ɩɨɩɪɨɳɟ.
ɑɬɨ-ɧɢɛɭɞɶ
ɩɨɩɪɨɳɟ ɛɭɞɟɬ ɢɡ ɨɛɥɚɫɬɢ ɜɵɫɲɟɣ ɦɚɬɟɦɚɬɢɤɢ, ɤɨɧɤɪɟɬɧɨ –
ɦɚɬɟɦɚɬɢɱɟɫɤɨɝɨ ɚɧɚɥɢɡɚ. Ɍɚɦ ɬɚɤɢɯ ɡɚɞɚɱ ɫɤɨɥɶɤɨ ɭɝɨɞɧɨ.
# ɤɪɚɬɤɢɣ ɤɭɪɫ Ɍɟɨɪɢɢ ɪɹɞɨɜ
ȼɫɟ ɡɧɚɸɬ ɮɨɪɦɭɥɭ ɩɪɨ ɞɥɢɧɭ ɨɤɪɭɠɧɨɫɬɢ ɢ ɩɥɨɳɚɞɶ ɤɪɭɝɚ:
;2 RSRP
2
SS
. Ʉɨɧɫɬɚɧɬɚ ʌ§3.14158… Ⱥ ɤɚɤ ɨɧɢ ɞɨɝɚɞɚɥɢɫɶ, ɱɬɨ ɨɧɚ
ɪɚɜɧɚ ɢɦɟɧɧɨ ɷɬɨɦɭ? Ⱥ ɨɧɢ ɩɨɱɬɢ ɜɵɱɢɫɥɢɥɢ ɫɭɦɦɭ ɛɟɫɤɨɧɟɱɧɨɝɨ ɪɹɞɚ.
ɉɨɱɬɢ – ɩɨɬɨɦɭ ɱɬɨ ɪɹɞ ɛɟɫɤɨɧɟɱɧɵɣ. ȼɨɬ ɩɪɢɦɟɪ ɛɟɫɤɨɧɟɱɧɨɝɨ ɪɹɞɚ:
1
1
4
2
ɋɤɥɚɞɵɜɚɬɶ ɷɬɢ ɱɢɫɥɚ ɧɟ ɧɚɞɨ, ɩɨɬɨɦɭ ɱɬɨ ɦɚɬɟɦɚɬɢɤɢ
...
8
1
1
ɞɨɤɚɡɚɥɢ, ɱɬɨ ɟɝɨ ɫɭɦɦɚ ɪɚɜɧɚ ɜ ɬɨɱɧɨɫɬɢ ɟɞɢɧɢɰɟ.
1
1
1
Ⱥ ɜɨɬ ɝɨɪɚɡɞɨ ɛɨɥɟɟ ɩɨɥɟɡɧɵɣ ɪɹɞ:
1
5
3
1
...
ȼɫɺ ɬɟ ɠɟ ɦɚɬɟɦɚɬɢɤɢ
7
ɞɨɤɚɡɚɥɢ, ɱɬɨ ɫɭɦɦɚ ɷɬɨɝɨ ɪɹɞɚ ɪɚɜɧɚ
. Ɍɟɩɟɪɶ, ɱɬɨɛɵ ɭɡɧɚɬɶ, ɱɟɦɭ ɠɟ
4
ɪɚɜɧɨ ʌ, ɨɫɬɚɥɫɹ ɫɭɳɢɣ ɩɭɫɬɹɤ – ɫɥɨɠɢɬɶ ɧɟɫɤɨɥɶɤɨ ɱɥɟɧɨɜ ɪɹɞɚ. ɇɭ ɬɚɦ,
ɞɟɫɹɬɶ, ɫɬɨ, ɬɵɫɹɱɭ. ɋɤɨɪɟɟ, ɦɢɥɥɢɨɧ, ɟɫɥɢ ɦɵ ɯɨɬɢɦ ɩɨɥɭɱɢɬɶ ɯɨɬɶ
ɧɟɦɧɨɝɨ ɬɨɱɧɵɣ ɪɟɡɭɥɶɬɚɬ. Ʉɫɬɚɬɢ, ɷɬɨ ɧɚɡɵɜɚɟɬɫɹ ɮɨɪɦɭɥɚ Ʌɟɣɛɧɢɰɚ.
Ⱦɥɹ ɧɚɲɢɯ ɰɟɥɟɣ ɦɵ ɜɨɡɶɦɺɦ ɪɹɞ, ɢɡɨɛɪɟɬɟɧɢɟ ɤɨɬɨɪɨɝɨ ɩɪɢɩɢɫɵɜɚɟɬɫɹ
ɦɧɨɝɨ ɤɨɦɭ. Ⱥ ɟɫɥɢ ɝɨɜɨɪɹɬ ɦɧɨɝɨ ɤɨɦɭ – ɡɧɚɱɢɬ, ɧɢɤɨɦɭ ɜɨɨɛɳɟ. ȼɨɬ ɨɧ:
1
1(12
S
u
1
33
35
u
1
37
u
. Ƚɨɜɨɪɹɬ, ɷɬɨɬ ɪɹɞ ɝɨɪɚɡɞɨ ɥɭɱɲɟ – ɜɨɬ
...)
32
ɢ ɩɪɨɜɟɪɢɦ.
Ɉɱɟɧɶ ɜɚɠɧɨɟ ɩɨɧɹɬɢɟ – ɮɨɪɦɭɥɚ ɨɛɳɟɝɨ ɱɥɟɧɚ ɪɹɞɚ. ɗɬɨ ɭɠɟ ɨɱɟɧɶ
1
ɛɥɢɡɤɨ ɤ ɩɪɨɝɪɚɦɦɢɪɨɜɚɧɢɸ. Ⱦɥɹ ɩɟɪɜɨɝɨ ɪɹɞɚ ɷɬɨ
ɱɥɟɧɚ ɜ ɩɨɫɥɟɞɨɜɚɬɟɥɶɧɨɫɬɢ. Ⱦɥɹ ɜɬɨɪɨɝɨ ɪɹɞɚ
a
, ɝɞɟ n – ɧɨɦɟɪ
n
n
a
n
1
n
ɬɪɟɬɶɟɝɨ?
Ⱥ ɤɭɞɚ ɜɵ ɥɟɬɢɬɟ, ɹ ɩɨɤɚ ɧɟ ɡɧɚɸ © Ȼɪɚɬ-2
# ɤɨɧɟɰ ɤɪɚɬɤɨɝɨ ɤɭɪɫɚ.
87
. Ⱥ ɞɥɹ
1
n
)1()12(
u
Ɍɟɩɟɪɶ ɧɚɞɨ ɪɟɲɢɬɶ ɞɜɟ ɨɱɟɜɢɞɧɨ ɜɵɞɟɥɹɟɦɵɟ ɩɨɞɡɚɞɚɱɢ. ɉɟɪɜɚɹ
H
ɩɨɞɡɚɞɚɱɚ – ɤɚɤ ɡɚɩɢɫɚɬɶ ɮɨɪɦɭɥɭ ɨɛɳɟɝɨ ɱɥɟɧɚ. Ɂɚɞɚɱɚ, ɩɨɜɬɨɪɸɫɶ, ɩɨ
ɮɨɪɦɟ ɦɚɬɟɦɚɬɢɱɟɫɤɚɹ, ɚ ɩɨ ɫɭɳɟɫɬɜɭ – ɱɢɫɬɨ ɩɪɨɝɪɚɦɦɢɫɬɫɤɚɹ. ȼɬɨɪɚɹ
ɩɨɞɡɚɞɚɱɚ – ɩɨ ɤɚɤɨɦɭ ɩɪɢɡɧɚɤɭ ɡɚɜɟɪɲɢɬɶ ɰɢɤɥ. ɇɟɫɦɨɬɪɹ ɧɚ ɫɥɨɜɨ ɰɢɤɥ ɜ
ɜɨɩɪɨɫɟ, ɷɬɚ ɡɚɞɚɱɚ ɦɚɬɟɦɚɬɢɱɟɫɤɚɹ ɢ ɞɨɜɨɥɶɧɨ ɫɥɨɠɧɚɹ. Ⱦɥɹ ɬɨɝɨ ɱɬɨɛɵ
ɪɟɲɢɬɶ, ɧɚ ɤɚɤɨɦ ɲɚɝɟ ɨɫɬɚɧɨɜɢɬɶɫɹ ɩɪɢ ɫɭɦɦɢɪɨɜɚɧɢɢ ɪɹɞɚ, ɦɚɬɟɦɚɬɢɤɢ
ɜɵɜɟɥɢ ɮɨɪɦɭɥɵ, ɭɡɧɚɬɶ ɡɧɚɱɟɧɢɹ ɤɨɬɨɪɵɯ ɱɚɫɬɨ ɫɥɨɠɧɟɟ, ɱɟɦ ɫɨɫɱɢɬɚɬɶ
ɫɚɦ ɪɹɞ. ɂɡ ɜɫɟɯ ɜɨɡɦɨɠɧɨɫɬɟɣ ɦɵ ɜɵɛɟɪɟɦ ɫɚɦɭɸ ɦɚɬɟɦɚɬɢɱɟɫɤɢ
ɧɟɧɚɞɺɠɧɭɸ. Ɂɚɬɨ ɨɧɚ ɥɟɝɤɨ ɩɪɨɝɪɚɦɦɢɪɭɟɬɫɹ. ɇɚɲɟ ɭɫɥɨɜɢɟ
ɡɚɩɢɫɵɜɚɟɬɫɹ ɬɚɤ:
a . Ⱦɪɭɝɢɦɢ ɫɥɨɜɚɦɢ, ɨɱɟɪɟɞɧɨɣ, ɩɨɫɥɟɞɧɢɣ ɱɥɟɧ
n
ɪɹɞɚ ɦɟɧɶɲɟ ɤɚɤɨɣ-ɬɨ ɡɚɪɚɧɟɟ ɡɚɞɚɧɧɨɣ ɜɟɥɢɱɢɧɵ. ȿɺ, ɷɬɭ ɜɟɥɢɱɢɧɭ, ɬɨɠɟ
ɩɪɢɞɺɬɫɹ ɜɜɟɫɬɢ.
n
)1(
Ɉɛɳɢɣ ɱɥɟɧ, ɦɧɟ ɤɚɠɟɬɫɹ, ɜɵɝɥɹɞɢɬ ɜɨɬ ɬɚɤ:
a
n
n
n
3)12(
u
. Ʉɚɤ ɹ ɞɨ
1
ɷɬɨɝɨ ɞɨɞɭɦɚɥɫɹ? ɇɟɬ, ɹ ɧɟ ɩɨɞɝɥɹɞɵɜɚɥ ɢ ɧɟ ɫɩɢɫɵɜɚɥ. ɇɟɬ, ɧɟ ɩɨɬɨɦɭ, ɱɬɨ
ɹ ɫɥɢɲɤɨɦ ɭɦɧɵɣ, ɷɬɨ ɩɨɬɨɦɭ, ɱɬɨ ɹ ɨɱɟɧɶ ɞɚɜɧɨ ɩɪɨɝɪɚɦɦɢɪɭɸ. Ɉɛɵɱɧɚɹ
ɪɚɛɨɬɚ ɞɥɹ ɩɪɨɝɪɚɦɦɢɫɬɚ – ɩɨɫɦɨɬɪɟɬɶ ɧɚ ɩɨɫɥɟɞɨɜɚɬɟɥɶɧɨɫɬɶ, ɜɵɹɜɢɬɶ
ɡɚɤɨɧɨɦɟɪɧɨɫɬɶ ɢ ɜɵɜɟɫɬɢ ɮɨɪɦɭɥɭ. ɉɪɢɱɺɦ ɷɬɨ ɧɟ ɬɨɥɶɤɨ ɜ
ɦɚɬɟɦɚɬɢɱɟɫɤɢɯ ɡɚɞɚɱɚɯ. Ɍɟɩɟɪɶ ɨ ɩɪɨɜɟɪɤɟ ɭɫɥɨɜɢɹ. Ɉɧɨ ɞɨɥɠɧɨ
ɜɵɝɥɹɞɟɬɶ ɝɞɟ-ɬɨ ɬɚɤ
while An < eps: ɉɟɪɟɦɟɧɧɚɹ ɧɚɡɵɜɚɟɬɫɹ eps ɩɨɬɨɦɭ,
ɱɬɨ ɬɚ ɫɦɟɲɧɚɹ ɡɚɤɨɪɸɱɤɚ ɜ ɮɨɪɦɭɥɟ ɩɨ-ɝɪɟɱɟɫɤɢ ɧɚɡɵɜɚɟɬɫɹ ɷɩɫɢɥɨɧ.
Ɇɚɥɟɧɶɤɚɹ ɩɪɨɛɥɟɦɚ.
An ɦɵ ɟɳɺ ɧɟ ɜɵɱɢɫɥɢɥɢ, ɨɧɨ ɛɭɞɟɬ ɜɵɱɢɫɥɟɧɨ
ɬɨɥɶɤɨ ɜɧɭɬɪɢ ɰɢɤɥɚ. ȼ ɧɚɲɟɦ ɫɥɭɱɚɟ ɦɵ ɫ ɩɟɪɜɨɝɨ ɜɡɝɥɹɞɚ ɡɧɚɟɦ, ɱɬɨ
ɩɟɪɜɵɣ ɱɥɟɧ ɪɹɞɚ ɪɚɜɟɧ ɟɞɢɧɢɰɟ, ɧɨ ɬɚɤ ɛɵɜɚɟɬ ɧɟ ɜɫɟɝɞɚ. ɑɚɫɬɨ
ɩɪɢɯɨɞɢɬɫɹ ɩɪɢɫɜɚɢɜɚɬɶ ɩɪɨɜɟɪɹɟɦɨɣ ɩɟɪɟɦɟɧɧɨɣ ɤɚɤɨɟ-ɬɨ ɢɫɤɭɫɫɬɜɟɧɧɨɟ
ɡɧɚɱɟɧɢɟ, ɤ ɩɪɢɦɟɪɭ, ɡɚɜɟɞɨɦɨ ɨɱɟɧɶ ɛɨɥɶɲɨɟ. ɉɪɨɞɨɥɠɚɟɦ
ɩɪɨɝɪɚɦɦɢɪɨɜɚɬɶ, ɨɞɧɚɤɨ.
Ɉɲɢɛɤɢ ɧɭɠɧɵ ɬɨɥɶɤɨ ɞɥɹ ɬɨɝɨ, ɱɬɨɛɵ ɧɚ ɧɢɯ ɭɱɢɬɶɫɹ. ə ɧɚɩɢɫɚɥ ɜɨɬ
ɬɚɤɨɣ ɬɟɤɫɬ ɢ ɩɨɥɭɱɢɥ ɛɟɫɤɨɧɟɱɧɨ ɞɥɢɧɧɵɣ ɫɩɢɫɨɤ ɱɢɫɟɥ, ɛɟɫɤɨɧɟɱɧɨ
ɞɨɥɝɨ ɛɟɝɭɳɢɣ ɩɨ ɷɤɪɚɧɭ.
eps = float(raw_input('eps = '))
An = 1
S = 0
n = 1
while (An > eps):
An = ((-1)**(n+1)) / ((2*n-1)*3**(n-1))
88
S = S + An
print S
ɑɬɨ ɞɟɥɚɬɶ ɜ ɬɚɤɨɦ ɫɥɭɱɚɟ? ɇɟɬ, ɩɨɧɹɬɧɨ, ɱɬɨ ɧɚɞɨ ɧɟɦɟɞɥɟɧɧɨ ɧɚɣɬɢ
ɨɲɢɛɤɭ. ɇɨ ɟɳɺ ɪɚɧɶɲɟ ɧɚɞɨ ɨɫɬɚɧɨɜɢɬɶ ɛɟɫɤɨɧɟɱɧɨ ɞɨɥɝɨɟ ɜɵɩɨɥɧɟɧɢɟ
ɩɪɨɝɪɚɦɦɵ. Ⱥ ɞɥɹ ɷɬɨɝɨ ɧɚɞɨ ɜ ɬɨɦ ɨɤɧɟ, ɤɨɬɨɪɨɟ Ɉɛɨɥɨɱɤɚ, ɧɟ Ɋɟɞɚɤɬɨɪ,
ɜɵɛɪɚɬɶ ɩɭɧɤɬ ɦɟɧɸ <Shell>\<Interrupt Execution Ctrl+C> – ɢ ɜɫɺ
ɧɟɦɟɞɥɟɧɧɨ ɨɫɬɚɧɨɜɢɬɫɹ. Ɇɨɠɧɨ ɩɪɨɳɟ – ɧɚɠɚɬɶ ɫɨɜɦɟɫɬɧɨ ɤɥɚɜɢɲɢ
<Ctrl> ɢ <C>. Ɍɚɤ ɜ ɱɺɦ ɠɟ ɨɲɢɛɤɚ? Ɉɲɢɛɨɤ ɦɧɨɝɨ, ɢ ɧɟ ɜɫɟ ɢɡ ɧɢɯ ɝɥɭɩɵɟ.
ɉɟɪɜɚɹ. ɇɚɲ ɪɹɞ ɡɧɚɤɨɩɟɪɟɦɟɧɧɵɣ. Ɂɜɭɱɢɬ ɤɪɚɫɢɜɨ ɢ ɡɚɝɚɞɨɱɧɨ, ɨɡɧɚɱɚɟɬ
ɜɫɟɝɨ ɥɢɲɶ, ɱɬɨ ɟɝɨ ɱɥɟɧɵ ɨɤɚɡɵɜɚɸɬɫɹ ɬɨ ɩɨɥɨɠɢɬɟɥɶɧɵɦɢ, ɬɨ
ɨɬɪɢɰɚɬɟɥɶɧɵɦɢ. ɉɪɢ ɩɟɪɜɨɦ ɠɟ ɨɬɪɢɰɚɬɟɥɶɧɨɦ ɱɥɟɧɟ ɰɢɤɥ
eps):
ɡɚɤɨɧɨɦɟɪɧɨ ɡɚɤɚɧɱɢɜɚɟɬ ɪɚɛɨɬɭ. Ɂɚɦɟɧɹɟɦ ɧɚ while (abs(An) > eps):
while (An >
ȼɬɨɪɚɹ ɨɲɢɛɤɚ ɝɨɪɚɡɞɨ ɛɨɥɟɟ ɭɦɧɚɹ ɢ ɢɧɬɟɪɟɫɧɚɹ, ɟɫɥɢ ɬɚɤ ɦɨɠɧɨ
ɝɨɜɨɪɢɬɶ ɨɛ ɨɲɢɛɤɚɯ. ɂ ɨɲɢɛɤɚ ɷɬɚ ɭɠɟ ɱɢɫɬɨ ɩɢɬɨɧɨɜɫɤɚɹ. Ɍɭɬ ɩɪɢɞɺɬɫɹ
ɧɟɦɧɨɝɨ ɩɨɞɭɦɚɬɶ. ɉɨɫɦɨɬɪɢɬɟ ɧɚ ɫɚɦɭɸ ɞɥɢɧɧɭɸ ɫɬɪɨɤɭ, ɬɭ, ɝɞɟ
ɜɵɱɢɫɥɟɧɢɹ. Ɍɚɦ ɞɟɥɢɬɫɹ ɱɬɨ-ɬɨ ɧɚ ɱɬɨ-ɬɨ. Ɍɨ, ɱɬɨ ɫɥɟɜɚ ɨɬ ɡɧɚɤɚ ɞɟɥɟɧɢɹ,
ɡɚɜɢɫɢɬ ɬɨɥɶɤɨ ɨɬ ɰɟɥɨɣ ɩɟɪɟɦɟɧɧɨɣ N ɢ ɰɟɥɵɯ ɱɢɫɟɥ. Ɍɨ, ɱɬɨ ɫɩɪɚɜɚ, –
ɬɨɱɧɨ ɬɚɤ ɠɟ. ȿɫɥɢ ɰɟɥɨɟ ɱɢɫɥɨ ɩɨɞɟɥɢɬɶ ɧɚ ɞɪɭɝɨɟ ɱɢɫɥɨ – ɩɨɥɭɱɢɦ ɨɩɹɬɶ
ɰɟɥɨɟ ɱɢɫɥɨ, ɩɨɬɨɦɭ ɱɬɨ ɞɟɥɟɧɢɟ ɛɭɞɟɬ ɧɚɰɟɥɨ ɫ ɨɫɬɚɬɤɨɦ. ɗɬɨ ɧɚɞɨ
ɡɚɩɨɦɧɢɬɶ. ɋɥɟɜɚ ɨɬ ɨɩɟɪɚɬɨɪɚ ɩɪɢɫɜɚɢɜɚɧɢɹ ɭ ɧɚɫ ɩɥɚɜɚɸɳɟɟ ɱɢɫɥɨ
ȿɫɥɢ ɟɦɭ ɩɪɢɫɜɨɢɬɶ ɰɟɥɨɟ ɱɢɫɥɨ,
An ɧɟɦɟɞɥɟɧɧɨ ɫɬɚɧɟɬ ɬɨɠɟ ɰɟɥɵɦ
An.
ɱɢɫɥɨɦ. ɗɬɨ ɧɚɞɨ ɩɨɧɹɬɶ. ɗɬɨ ɱɢɫɬɨ ɨɫɨɛɟɧɧɨɫɬɶ ɉɢɬɨɧɚ. Ʉɚɤ ɢɫɩɪɚɜɢɬɶ?
Ɇɨɠɧɨ ɜɦɟɫɬɨ ɰɟɥɵɯ ɤɨɧɫɬɚɧɬ ɧɚɩɢɫɚɬɶ ɩɥɚɜɚɸɳɢɟ, ɬɨ ɟɫɬɶ ɡɚɦɟɧɢɬɶ: 1
Î 1.0. Ⱥ ɦɨɠɧɨ ɹɜɧɨ ɭɤɚɡɚɬɶ, ɱɬɨ ɦɵ ɯɨɬɢɦ ɢɦɟɬɶ ɩɥɚɜɚɸɳɟɟ ɱɢɫɥɨ, ɜ
ɡɧɚɦɟɧɚɬɟɥɟ, ɧɚɩɪɢɦɟɪ:
An = ((-1)**(n+1)) / float(((2*n-1)*3**(n-1))).
ɋɤɨɛɨɤ ɫɬɚɧɨɜɢɬɫɹ ɜɫɺ ɛɨɥɶɲɟ ɢ ɛɨɥɶɲɟ, ɧɨ ɬɭɬ ɭɠ ɧɢɱɟɝɨ ɧɟ ɩɨɞɟɥɚɟɲɶ,
ɜɫɺ, ɤɚɤ ɜ ɚɧɟɤɞɨɬɟ – <ɨɛɢɞɧɨɟ ɫɥɨɜɨ>, ɧɟ ɠɚɥɟɣɬɟ ɡɚɜɚɪɤɭ!
Ɍɪɟɬɶɹ ɨɲɢɛɤɚ ɞɨ ɬɨɝɨ ɩɪɨɫɬɚɹ, ɱɬɨ ɩɟɪɟɫɬɚɺɬ ɛɵɬɶ ɨɲɢɛɤɨɣ ɢ
ɩɪɟɜɪɚɳɚɟɬɫɹ ɜ ɨɫɨɛɟɧɧɨɫɬɶ. ə ɡɚɛɵɥ ɭɦɧɨɠɢɬɶ ɪɟɡɭɥɶɬɚɬ ɧɚ
12 .
ɂɫɩɪɚɜɥɹɟɦ ɜɫɺ ɪɚɡɨɦ ɢ ɞɨɪɚɛɚɬɵɜɚɟɦ ɜɵɜɨɞ ɪɟɡɭɥɶɬɚɬɚ ɢ ɩɪɨɦɟɠɭɬɨɱɧɵɯ
ɩɟɪɟɦɟɧɧɵɯ – ɞɥɹ ɤɨɧɬɪɨɥɹ ɩɪɨɰɟɫɫɚ.
eps = float(raw_input('eps = '))
print
An = 1.0
S = 0.0
89
n = 1
while (abs(An) > eps):
An = ((-1)**(n+1)) / float(((2*n-1)*(3**(n-1))))
print 'An = ', An, 'eps = ', eps, 'abs(An) > eps = ', abs(An) > eps
S = S + An
n = n +1
pi = S * (12**0.5)
print 'pi = ', pi
Ⱥ ɜɨɬ ɪɟɡɭɥɶɬɚɬɵ ɫ ɬɨɱɧɨɫɬɶɸ ɞɨ ɨɞɧɨɣ ɬɵɫɹɱɧɨɣ:
eps = 0.001
An = 1.0 eps = 0.001 abs(An) > eps = True
pi = 3.46410161514
An = -0.111111111111 eps = 0.001 abs(An) > eps = True
pi = 3.07920143568
An = 0.0222222222222 eps = 0.001 abs(An) > eps = True
pi = 3.15618147157
An = -0.00529100529101 eps = 0.001 abs(An) > eps = True
pi = 3.1378528916
An = 0.00137174211248 eps = 0.001 abs(An) > eps = True
pi = 3.14260474566
An = -0.000374111485223 eps = 0.001 abs(An) > eps = False
pi = 3.14130878546
ɉɨɧɚɞɨɛɢɥɨɫɶ ɜɫɟɝɨ ɲɟɫɬɶ ɢɬɟɪɚɰɢɣ. Ⱦɥɹ ɫɪɚɜɧɟɧɢɹ, ɡɚɩɪɨɝɪɚɦɦɢɪɭɣɬɟ
ɪɹɞ Ʌɟɣɛɧɢɰɚ ɢ ɩɨɫɦɨɬɪɢɬɟ, ɧɚɫɤɨɥɶɤɨ ɩɥɨɯɨ ɨɧ ɫɯɨɞɢɬɫɹ.
ɂ ɟɳɺ, ɜɫɩɨɦɧɢɬɟ ɡɚɞɚɱɭ ɨ ɩɪɨɰɟɧɬɚɯ, ɬɭ, ɤɨɬɨɪɚɹ ɧɚ ɨɫɧɨɜɟ
ɋɚɥɬɵɤɨɜɚ-ɓɟɞɪɢɧɚ. Ɉɛɞɭɦɚɣɬɟ, ɤɚɤ ɦɨɠɧɨ ɩɪɢɦɟɧɢɬɶ ɰɢɤɥ
while ɤ
ɧɚɯɨɠɞɟɧɢɸ ɟɺ ɜɨɡɦɨɠɧɨ ɬɨɱɧɨɝɨ ɪɟɲɟɧɢɹ.
90
Соседние файлы в предмете [НЕСОРТИРОВАННОЕ]