-
Notifications
You must be signed in to change notification settings - Fork 0
Expand file tree
/
Copy pathcontrol_flow.html
More file actions
672 lines (658 loc) · 50.7 KB
/
control_flow.html
File metadata and controls
672 lines (658 loc) · 50.7 KB
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
450
451
452
453
454
455
456
457
458
459
460
461
462
463
464
465
466
467
468
469
470
471
472
473
474
475
476
477
478
479
480
481
482
483
484
485
486
487
488
489
490
491
492
493
494
495
496
497
498
499
500
501
502
503
504
505
506
507
508
509
510
511
512
513
514
515
516
517
518
519
520
521
522
523
524
525
526
527
528
529
530
531
532
533
534
535
536
537
538
539
540
541
542
543
544
545
546
547
548
549
550
551
552
553
554
555
556
557
558
559
560
561
562
563
564
565
566
567
568
569
570
571
572
573
574
575
576
577
578
579
580
581
582
583
584
585
586
587
588
589
590
591
592
593
594
595
596
597
598
599
600
601
602
603
604
605
606
607
608
609
610
611
612
613
614
615
616
617
618
619
620
621
622
623
624
625
626
627
628
629
630
631
632
633
634
635
636
637
638
639
640
641
642
643
644
645
646
647
648
649
650
651
652
653
654
655
656
657
658
659
660
661
662
663
664
665
666
667
668
669
670
671
672
<!DOCTYPE html>
<html lang="en">
<head>
<meta charset="UTF-8">
<title>Поток команд</title>
<link rel="shortcut icon" type="image/ico" href="python-logo.png"/>
<link rel="stylesheet" href="_static/classic.css" type="text/css"/>
<link rel="stylesheet" href="_static/pygments.css" type="text/css"/>
</head>
<body>
<style> body {background: #ccc;} </style>
<div style="float: left;position: absolute;top: 0px; width: 200px;height: 5470px; padding: 25px;background: #C8A98F;color: #8B4513;margin: 0px;">
<p><A href="Главная страница.html" style="color: #8B4513;font-size: 20px;text-decoration: none;" target="_blank">Главная
страница</A></p>
<p><A href="Книга.html" style="color: #8B4513;text-decoration: none;" target="_blank">Теория</A></p>
<p><A href="Обучающие видео.html" style="color: #8B4513;text-decoration: none;" target="_blank">Обучающие видео</A>
</p>
<p><A href="Exercieses.html" style="color: #8B4513;text-decoration: none;" target="_blank">Практика</A></p>
</div>
<div class="section" id="id1" style="margin-left: 270px; display: absolute; background: #ccc;">
<h1>Поток команд<a class="headerlink" href="#id1" title="Ссылка на этот заголовок">¶</a></h1>
<p>В программах, которые мы до сих пор рассматривали, последовательность команд
всегда выполнялась Python по порядку строго сверху вниз. А что, если нам
необходимо изменить поток выполняющихся команд? Например, если требуется, чтобы
программа принимала некоторое решение и выполняла различные действия в
зависимости от ситуации; скажем, печатала “Доброе утро” или “Добрый вечер” в
зависимости от времени суток.</p>
<p>Как вы уже, наверное, догадались, этого можно достичь при помощи операторов
управления потоком. В Python есть три оператора управления потоком: <code class="docutils literal"><span
class="pre">if</span></code>,
<code class="docutils literal"><span class="pre">for</span></code> и <code class="docutils literal"><span
class="pre">while</span></code>.</p>
<div class="section" id="if">
<h2>Оператор if<a class="headerlink" href="#if" title="Ссылка на этот заголовок">¶</a></h2>
<p>Оператор <code class="docutils literal"><span class="pre">if</span></code> используется для проверки условий:
<em>если</em><a class="footnote-reference" href="#id13" id="id2">[1]</a> условие верно<a
class="footnote-reference" href="#id14" id="id3">[2]</a>, выполняется блок выражений (называемый
“if-блок”), <em>иначе</em><a class="footnote-reference" href="#id15" id="id4">[3]</a>
выполняется другой блок выражений (называемый “else-блок”). Блок “else”
является необязательным.</p>
<p><strong>Пример:</strong> (сохраните как <code class="docutils literal"><span class="pre">if.py</span></code>)
</p>
<div class="highlight-python">
<div class="highlight"><pre><span></span><span class="n">number</span> <span class="o">=</span> <span
class="mi">23</span>
<span class="n">guess</span> <span class="o">=</span> <span class="nb">int</span><span class="p">(</span><span
class="nb">input</span><span class="p">(</span><span
class="s1">'Введите целое число : '</span><span class="p">))</span>
<span class="k">if</span> <span class="n">guess</span> <span class="o">==</span> <span class="n">number</span><span
class="p">:</span>
<span class="k">print</span><span class="p">(</span><span class="s1">'Поздравляю, вы угадали,'</span><span
class="p">)</span> <span class="c1"># Здесь начинается новый блок</span>
<span class="k">print</span><span class="p">(</span><span
class="s1">'(хотя и не выиграли никакого приза!)'</span><span class="p">)</span> <span
class="c1"># Здесь заканчивается новый блок</span>
<span class="k">elif</span> <span class="n">guess</span> <span class="o"><</span> <span class="n">number</span><span
class="p">:</span>
<span class="k">print</span><span class="p">(</span><span class="s1">'Нет, загаданное число немного больше этого.'</span><span
class="p">)</span> <span class="c1"># Ещё один блок</span>
<span class="c1"># Внутри блока вы можете выполнять всё, что угодно ...</span>
<span class="k">else</span><span class="p">:</span>
<span class="k">print</span><span class="p">(</span><span class="s1">'Нет, загаданное число немного меньше этого.'</span><span
class="p">)</span>
<span class="c1"># чтобы попасть сюда, guess должно быть больше, чем number</span>
<span class="k">print</span><span class="p">(</span><span class="s1">'Завершено'</span><span class="p">)</span>
<span class="c1"># Это последнее выражение выполняется всегда после выполнения оператора if</span>
</pre>
</div>
</div>
<p><strong>Вывод:</strong></p>
<div class="highlight-default">
<div class="highlight"><pre><span></span>$ python if.py
Введите целое число : 50
Нет, загаданное число немного меньше этого.
Завершено
$ python if.py
Введите целое число : 22
Нет, загаданное число немного больше этого.
Завершено
$ python if.py
Введите целое число : 23
Поздравляю, вы угадали,
(хотя и не выиграли никакого приза!)
Завершено
</pre>
</div>
</div>
<p><strong>Как это работает:</strong></p>
<blockquote>
<div><p>В этой программе мы принимаем варианты от пользователя и проверяем,
совпадают ли они с заранее заданным числом. Мы устанавливаем переменной
<code class="docutils literal"><span class="pre">number</span></code> значение любого целого числа,
какого хотим. Например, <code class="docutils literal"><span class="pre">23</span></code>.
После этого мы принимаем вариант числа от пользователя при помощи функции
<code class="docutils literal"><span class="pre">input()</span></code>. Функции – это
всего-навсего многократно используемые фрагменты
программы. Мы узнаем о них больше в <a class="reference internal" href="functions.html"><span
class="doc">следующей главе</span></a>.</p>
<p>Мы передаём встроенной функции <code class="docutils literal"><span class="pre">input</span></code>
строку, которую она выводит на экран
и ожидает ввода от пользователя. Как только мы ввели что-нибудь и нажали
клавишу <code class="docutils literal"><span class="pre">Enter</span></code>, функция <code
class="docutils literal"><span class="pre">input()</span></code> возвращает строку, которую
мы ввели.
Затем мы преобразуем полученную строку в число при помощи <code class="docutils literal"><span
class="pre">int()</span></code>, и
сохраняем это значение в переменную <code class="docutils literal"><span
class="pre">guess</span></code>. Вообще-то, <code class="docutils literal"><span
class="pre">int</span></code> – это
класс, но на данном этапе вам достаточно знать лишь, что при помощи него
можно преобразовать строку в целое число (предполагая, что строка содержит
целое число).</p>
<p>Далее мы сравниваем число, введённое пользователем, с числом, которое мы
выбрали заранее. Если они равны, мы печатаем сообщение об успехе. Обратите
внимание, что мы используем соответствующие уровни отступа, чтобы указать
Python, какие выражения относятся к какому блоку. Вот почему отступы так
важны в Python. Я надеюсь, вы придерживаетесь правила “постоянных отступов”,
не так ли?</p>
<p>Обратите внимание, что в конце оператора <code class="docutils literal"><span
class="pre">if</span></code> стоит двоеточие – этим мы
показываем, что далее следует блок выражений.</p>
<p>После этого мы проверяем, верно ли, что пользовательский вариант числа меньше
загаданного, и если это так, мы информируем пользователя о том, что ему
следует выбирать числа немного больше этого. Здесь мы использовали выражение
<code class="docutils literal"><span class="pre">elif</span></code>, которое попросту объединяет в
себе два связанных <code class="docutils literal"><span class="pre">if</span> <span class="pre">else-if</span>
<span class="pre">else</span></code>
выражения в одно выражение <code class="docutils literal"><span
class="pre">if-elif-else</span></code>. Это облегчает чтение программы,
а также не требует дополнительных отступов.</p>
<p>Выражения <code class="docutils literal"><span class="pre">elif</span></code> и <code
class="docutils literal"><span class="pre">else</span></code> также имеют двоеточие в конце
логической строки,
за которым следуют соответствующие блоки команд (с соответствующим числом
отступов, конечно).</p>
<p>Внутри if-блока оператора <code class="docutils literal"><span class="pre">if</span></code> может
быть другой оператор <code class="docutils literal"><span class="pre">if</span></code> и
так далее – это называется вложенным<a class="footnote-reference" href="#id16"
id="id5">[4]</a> оператором <code
class="docutils literal"><span class="pre">if</span></code>.</p>
<p>Помните, что части <code class="docutils literal"><span class="pre">elif</span></code> и <code
class="docutils literal"><span class="pre">else</span></code> не обязательны. Минимальная
корректная
запись оператора <code class="docutils literal"><span class="pre">if</span></code> такова:</p>
<div class="highlight-python">
<div class="highlight"><pre><span></span><span class="k">if</span> <span class="bp">True</span><span
class="p">:</span>
<span class="k">print</span><span class="p">(</span><span class="s1">'Да, это верно.'</span><span class="p">)</span>
</pre>
</div>
</div>
<p>После того, как Python заканчивает выполнение всего оператора <code class="docutils literal"><span
class="pre">if</span></code> вместе с
его частями <code class="docutils literal"><span class="pre">elif</span></code> и <code
class="docutils literal"><span class="pre">else</span></code>, он переходит к следующему
выражению в блоке,
содержащем этот оператор <code class="docutils literal"><span class="pre">if</span></code>. В нашем
случае это основной блок программы
(в котором начинается выполнение программы), а следующее выражение – это
<code class="docutils literal"><span class="pre">print('Завершено')</span></code>. После этого
Python доходит до конца программы и
просто выходит из неё.</p>
</div>
</blockquote>
<p>Хотя это и чрезвычайно простая программа, я указал вам на целый ряд вещей,
которые стоит взять на заметку. Всё это довольно легко (даже удивительно
легко для тех из вас, кто пришёл из мира C/C++). Поначалу вам придётся держать
все эти вещи в памяти, но после некоторой практики вы привыкнете, и они вам
покажутся вполне “естественными”.</p>
<div class="admonition-c-c admonition">
<p class="first admonition-title">Замечание для программистов на C/C++</p>
<p class="last">В Python нет оператора <code class="docutils literal"><span class="pre">switch</span></code>.
Однако, при помощи конструкции
<code class="docutils literal"><span class="pre">if..elif..else</span></code> можно достичь того же
самого (а в некоторых случаях можно
даже использовать <a class="reference internal" href="data_structures.html#dictionary"><span
class="std std-ref">словарь</span></a>, чтобы сделать это быстро).</p>
</div>
</div>
<div class="section" id="while">
<h2>Оператор while<a class="headerlink" href="#while" title="Ссылка на этот заголовок">¶</a></h2>
<p>Оператор <code class="docutils literal"><span class="pre">while</span></code> позволяет многократно выполнять
блок команд до тех пор,
пока выполняется некоторое условие. Это один из так называемых <em>операторов
цикла</em>. Он также может иметь необязательный пункт <code class="docutils literal"><span class="pre">else</span></code>.
</p>
<p><strong>Пример:</strong> (сохраните как <code class="docutils literal"><span
class="pre">while.py</span></code>)</p>
<div class="highlight-python">
<div class="highlight"><pre><span></span><span class="n">number</span> <span class="o">=</span> <span
class="mi">23</span>
<span class="n">running</span> <span class="o">=</span> <span class="bp">True</span>
<span class="k">while</span> <span class="n">running</span><span class="p">:</span>
<span class="n">guess</span> <span class="o">=</span> <span class="nb">int</span><span class="p">(</span><span
class="nb">input</span><span class="p">(</span><span
class="s1">'Введите целое число : '</span><span class="p">))</span>
<span class="k">if</span> <span class="n">guess</span> <span class="o">==</span> <span class="n">number</span><span
class="p">:</span>
<span class="k">print</span><span class="p">(</span><span
class="s1">'Поздравляю, вы угадали.'</span><span class="p">)</span>
<span class="n">running</span> <span class="o">=</span> <span class="bp">False</span> <span class="c1"># это останавливает цикл while</span>
<span class="k">elif</span> <span class="n">guess</span> <span class="o"><</span> <span
class="n">number</span><span class="p">:</span>
<span class="k">print</span><span class="p">(</span><span class="s1">'Нет, загаданное число немного больше этого.'</span><span
class="p">)</span>
<span class="k">else</span><span class="p">:</span>
<span class="k">print</span><span class="p">(</span><span class="s1">'Нет, загаданное число немного меньше этого.'</span><span
class="p">)</span>
<span class="k">else</span><span class="p">:</span>
<span class="k">print</span><span class="p">(</span><span class="s1">'Цикл while закончен.'</span><span
class="p">)</span>
<span class="c1"># Здесь можете выполнить всё что вам ещё нужно</span>
<span class="k">print</span><span class="p">(</span><span class="s1">'Завершение.'</span><span
class="p">)</span>
</pre>
</div>
</div>
<p><strong>Вывод:</strong></p>
<div class="highlight-default">
<div class="highlight"><pre><span></span>$ python while.py
Введите целое число : 50
Нет, загаданное число немного меньше этого.
Введите целое число : 22
Нет, загаданное число немного больше этого.
Введите целое число : 23
Поздравляю, вы угадали.
Цикл while закончен.
Завершение.
</pre>
</div>
</div>
<p><strong>Как это работает:</strong></p>
<blockquote>
<div><p>В этой программе мы продолжаем играть в игру с угадыванием, но преимущество
состоит в том, что теперь пользователь может угадывать до тех пор, пока не
угадает правильное число, и ему не придётся запускать программу заново для
каждой попытки, как это происходило до сих пор. Это наглядно демонстрирует
применение оператора <code class="docutils literal"><span class="pre">while</span></code>.</p>
<p>Мы переместили операторы <code class="docutils literal"><span class="pre">input</span></code> и <code
class="docutils literal"><span class="pre">if</span></code> внутрь цикла <code
class="docutils literal"><span class="pre">while</span></code> и
установили переменную <code class="docutils literal"><span class="pre">running</span></code> в
значение <code class="docutils literal"><span class="pre">True</span></code> перед запуском цикла.
Прежде всего проверяется, равно ли значение переменной <code class="docutils literal"><span
class="pre">running</span></code> <code class="docutils literal"><span
class="pre">True</span></code>,
а затем происходит переход к соответствующему <em>while-блоку</em>. После выполнения
этого блока команд условие, которым в данном случае является переменная
<code class="docutils literal"><span class="pre">running</span></code>, проверяется снова. Если оно
истинно, while-блок запускается
снова, в противном случае происходит переход к дополнительному else-блоку, а
затем – к следующему оператору.</p>
</div>
</blockquote>
<p>Блок <code class="docutils literal"><span class="pre">else</span></code> выполняется тогда, когда условие
цикла <code class="docutils literal"><span class="pre">while</span></code> становится
ложным (<code class="docutils literal"><span class="pre">False</span></code>) – это может случиться
даже при самой первой проверке
условия. Если у цикла <code class="docutils literal"><span class="pre">while</span></code> имеется
дополнительный блок <code class="docutils literal"><span class="pre">else</span></code>, он
всегда выполняется, если только цикл не будет прерван оператором <code class="docutils literal"><span
class="pre">break</span></code>.</p>
<p><code class="docutils literal"><span class="pre">True</span></code> и <code class="docutils literal"><span
class="pre">False</span></code> называются булевым типом данных, и вы можете считать их
эквивалентными значениям <code class="docutils literal"><span class="pre">1</span></code> и <code
class="docutils literal"><span class="pre">0</span></code> соответственно.</p>
<div class="admonition-c-c admonition">
<p class="first admonition-title">Примечание для программистов на C/C++</p>
<p class="last">Помните, что у цикла <code class="docutils literal"><span class="pre">while</span></code>
может быть блок <code class="docutils literal"><span class="pre">else</span></code>.</p>
</div>
</div>
<div class="section" id="for">
<h2>Цикл for<a class="headerlink" href="#for" title="Ссылка на этот заголовок">¶</a></h2>
<p>Оператор <code class="docutils literal"><span class="pre">for..in</span></code> также является оператором
цикла, который осуществляет
<em>итерацию</em> по последовательности объектов, т.е. проходит через каждый элемент
в последовательности. Мы узнаем больше о <a class="reference internal"
href="data_structures.html#dat-sequences"><span
class="std std-ref">последовательностях</span></a>
в дальнейших главах, а пока просто запомните, что последовательность – это
упорядоченный набор элементов.</p>
<p><strong>Пример:</strong> (сохраните как <code class="docutils literal"><span class="pre">for.py</span></code>)
</p>
<div class="highlight-python">
<div class="highlight"><pre><span></span><span class="k">for</span> <span class="n">i</span> <span
class="ow">in</span> <span class="nb">range</span><span class="p">(</span><span
class="mi">1</span><span class="p">,</span> <span class="mi">5</span><span class="p">):</span>
<span class="k">print</span><span class="p">(</span><span class="n">i</span><span class="p">)</span>
<span class="k">else</span><span class="p">:</span>
<span class="k">print</span><span class="p">(</span><span class="s1">'Цикл for закончен'</span><span
class="p">)</span>
</pre>
</div>
</div>
<p><strong>Вывод:</strong></p>
<div class="highlight-default">
<div class="highlight"><pre><span></span>$ python for.py
1
2
3
4
Цикл for закончен
</pre>
</div>
</div>
<p><strong>Как это работает:</strong></p>
<blockquote>
<div><p>В этой программе мы выводим на экран <em>последовательность</em> чисел. Мы
генерируем эту последовательность, используя встроенную функцию <code class="docutils literal"><span
class="pre">range</span></code><a class="footnote-reference" href="#id17" id="id6">[5]</a>.</p>
<p>Мы задаём два числа, и <code class="docutils literal"><span class="pre">range</span></code>
возвращает последовательность чисел от
первого числа до второго. Например, <code class="docutils literal"><span
class="pre">range(1,5)</span></code> даёт последовательность
<code class="docutils literal"><span class="pre">[1,</span> <span class="pre">2,</span> <span
class="pre">3,</span> <span class="pre">4]</span></code>. По умолчанию <code
class="docutils literal"><span class="pre">range</span></code> принимает значение шага,
равное 1.
Если мы зададим также и третье число <code class="docutils literal"><span
class="pre">range</span></code>, оно будет служить шагом.
Например, <code class="docutils literal"><span class="pre">range(1,5,2)</span></code> даст <code
class="docutils literal"><span class="pre">[1,3]</span></code>. Помните, интервал
простирается
только <em>до</em> второго числа, т.е. <strong>не</strong> включает его в себя.</p>
<p>Обратите внимание, что <code class="docutils literal"><span class="pre">range()</span></code>
генерирует последовательность чисел, но
только по одному числу за раз – когда оператор for запрашивает следующий
элемент. Чтобы увидеть всю последовательность чисел сразу, используйте
<code class="docutils literal"><span class="pre">list(range())</span></code>. Списки<a
class="footnote-reference" href="#id18" id="id7">[6]</a> подробно рассматриваются в главе
<a class="reference internal" href="data_structures.html#data-list"><span class="std std-ref">Структуры данных</span></a>.
</p>
<p>Затем цикл <code class="docutils literal"><span class="pre">for</span></code> осуществляет итерацию
по этому диапазону - <code class="docutils literal"><span class="pre">for</span> <span
class="pre">i</span> <span class="pre">in</span>
<span class="pre">range(1,5)</span></code> эквивалентно <code class="docutils literal"><span
class="pre">for</span> <span class="pre">i</span> <span class="pre">in</span> <span
class="pre">[1,</span> <span class="pre">2,</span> <span class="pre">3,</span> <span
class="pre">4]</span></code>, что напоминает
присваивание переменной i по одному числу (или объекту) за раз, выполняя блок
команд для каждого значения <code class="docutils literal"><span class="pre">i</span></code>. В
данном случае в блоке команд мы просто
выводим значение на экран.</p>
</div>
</blockquote>
<p>Помните, что блок <code class="docutils literal"><span class="pre">else</span></code> не обязателен. Если он
присутствует, он всегда
выполняется один раз после окончания цикла <code class="docutils literal"><span
class="pre">for</span></code>, если только не указан
оператор <a class="reference internal" href="#break-operator"><span class="std std-ref">break</span></a>.
</p>
<p>Помните также, что цикл <code class="docutils literal"><span class="pre">for..in</span></code> работает для
любой последовательности. В
нашем случае это список чисел, сгенерированный встроенной функцией <code class="docutils literal"><span
class="pre">range</span></code>,
но в общем случае можно использовать любую последовательность любых объектов!
В следующих разделах мы познакомимся с этим поближе.</p>
<div class="admonition-c-c-java-c admonition">
<p class="first admonition-title">Примечание для программистов на C/C++/Java/C#</p>
<p>Цикл <code class="docutils literal"><span class="pre">for</span></code> в Python радикально отличается от
цикла <code class="docutils literal"><span class="pre">for</span></code> в C/C++.
Программисты на C# заметят, что цикл <code class="docutils literal"><span class="pre">for</span></code>
в Python похож на цикл
<code class="docutils literal"><span class="pre">foreach</span></code> в C#. Программистам на Java это
может напомнить конструкцию
<code class="docutils literal"><span class="pre">for</span> <span class="pre">(int</span> <span
class="pre">i</span> <span class="pre">:</span> <span class="pre">IntArray)</span></code> в Java
1.5.</p>
<p class="last">Если в C/C++ записать <code class="docutils literal"><span class="pre">for</span> <span
class="pre">(int</span> <span class="pre">i</span> <span class="pre">=</span> <span
class="pre">0;</span> <span class="pre">i</span> <span class="pre"><</span> <span
class="pre">5;</span> <span class="pre">i++)</span></code>, то в Python этому
соответствовало бы выражение <code class="docutils literal"><span class="pre">for</span> <span
class="pre">i</span> <span class="pre">in</span> <span class="pre">range(0,5)</span></code>. Как
видно, в Python
цикл <code class="docutils literal"><span class="pre">for</span></code> проще, более выразителен и менее
подвержен ошибкам.</p>
</div>
</div>
<div class="section" id="break">
<span id="break-operator"></span>
<h2>Оператор break<a class="headerlink" href="#break" title="Ссылка на этот заголовок">¶</a></h2>
<p>Оператор <code class="docutils literal"><span class="pre">break</span></code> служит для
<em>прерывания</em><a class="footnote-reference" href="#id19" id="id8">[7]</a> цикла, т.е. остановки
выполнения команд даже если условие выполнения цикла ещё не приняло значения
<code class="docutils literal"><span class="pre">False</span></code> или последовательность элементов не
закончилась.</p>
<p>Важно отметить, что если циклы <code class="docutils literal"><span class="pre">for</span></code> или <code
class="docutils literal"><span class="pre">while</span></code> прервать оператором
<em>break</em>, соответствующие им блоки <code class="docutils literal"><span class="pre">else</span></code>
выполняться <strong>не</strong> будут.</p>
<p><strong>Пример:</strong> (сохраните как <code class="docutils literal"><span
class="pre">break.py</span></code>)</p>
<div class="highlight-python">
<div class="highlight"><pre><span></span><span class="k">while</span> <span class="bp">True</span><span
class="p">:</span>
<span class="n">s</span> <span class="o">=</span> <span class="nb">input</span><span class="p">(</span><span
class="s1">'Введите что-нибудь : '</span><span class="p">)</span>
<span class="k">if</span> <span class="n">s</span> <span class="o">==</span> <span class="s1">'выход'</span><span
class="p">:</span>
<span class="k">break</span>
<span class="k">print</span><span class="p">(</span><span class="s1">'Длина строки:'</span><span
class="p">,</span> <span class="nb">len</span><span class="p">(</span><span
class="n">s</span><span class="p">))</span>
<span class="k">print</span><span class="p">(</span><span class="s1">'Завершение'</span><span class="p">)</span>
</pre>
</div>
</div>
<p><strong>Вывод:</strong></p>
<div class="highlight-default">
<div class="highlight"><pre><span></span>$ python break.py
Введите что-нибудь : Программировать весело.
Длина строки: 23
Введите что-нибудь : Если работа скучна,
Длина строки: 19
Введите что-нибудь : Чтобы придать ей весёлый тон -
Длина строки: 30
Введите что-нибудь : используй Python!
Длина строки: 23
Введите что-нибудь : выход
Завершение
</pre>
</div>
</div>
<p><strong>Как это работает:</strong></p>
<blockquote>
<div><p>В этой программе мы многократно считываем пользовательский ввод и выводим на
экран длину каждой введённой строки. Для остановки программы мы вводим
специальное условие, проверяющее, совпадает ли пользовательский ввод со
строкой <code class="docutils literal"><span class="pre">'выход'</span></code>. Мы останавливаем
программу <em>прерыванием</em> цикла
оператором <code class="docutils literal"><span class="pre">break</span></code> и достигаем её конца.
</p>
<p>Длина введённой строки может быть найдена при помощи встроенной функции
<code class="docutils literal"><span class="pre">len</span></code>.</p>
<p>Помните также, что оператор <code class="docutils literal"><span class="pre">break</span></code>
может применяться и в цикле <code class="docutils literal"><span class="pre">for</span></code>.</p>
</div>
</blockquote>
<div class="section" id="python-swaroop">
<h3>Поэтический Python Swaroop’а<a class="headerlink" href="#python-swaroop"
title="Ссылка на этот заголовок">¶</a></h3>
<p>Для ввода строк здесь я использовал мини-стишок, который сам сочинил. Он
называется <em>Поэтический Python Swaroop’а</em><a class="footnote-reference" href="#id20"
id="id9">[8]</a></p>
<blockquote>
<div>
<div class="line-block">
<div class="line">Программировать весело.</div>
<div class="line">Если работа скучна,</div>
<div class="line">Чтобы придать ей весёлый тон -</div>
<div class="line-block">
<div class="line">используй Python!</div>
</div>
</div>
</div>
</blockquote>
</div>
</div>
<div class="section" id="continue">
<h2>Оператор continue<a class="headerlink" href="#continue" title="Ссылка на этот заголовок">¶</a></h2>
<p>Оператор <code class="docutils literal"><span class="pre">continue</span></code> используется для указания
Python, что необходимо
пропустить все оставшиеся команды в текущем блоке цикла и <em>продолжить</em><a class="footnote-reference"
href="#id21"
id="id10">[9]</a>
со следующей итерации цикла.</p>
<p><strong>Пример:</strong> (сохраните как <code class="docutils literal"><span
class="pre">continue.py</span></code>)</p>
<div class="highlight-python">
<div class="highlight"><pre><span></span><span class="k">while</span> <span class="bp">True</span><span
class="p">:</span>
<span class="n">s</span> <span class="o">=</span> <span class="nb">input</span><span class="p">(</span><span
class="s1">'Введите что-нибудь : '</span><span class="p">)</span>
<span class="k">if</span> <span class="n">s</span> <span class="o">==</span> <span class="s1">'выход'</span><span
class="p">:</span>
<span class="k">break</span>
<span class="k">if</span> <span class="nb">len</span><span class="p">(</span><span class="n">s</span><span
class="p">)</span> <span class="o"><</span> <span class="mi">3</span><span class="p">:</span>
<span class="k">print</span><span class="p">(</span><span class="s1">'Слишком мало'</span><span
class="p">)</span>
<span class="k">continue</span>
<span class="k">print</span><span class="p">(</span><span
class="s1">'Введённая строка достаточной длины'</span><span class="p">)</span>
<span class="c1"># Разные другие действия здесь...</span>
</pre>
</div>
</div>
<p><strong>Вывод:</strong></p>
<div class="highlight-default">
<div class="highlight"><pre><span></span>$ python continue.py
Введите что-нибудь : a
Слишком мало
Введите что-нибудь : 12
Слишком мало
Введите что-нибудь : абв
Введённая строка достаточной длины
Введите что-нибудь : выход
</pre>
</div>
</div>
<p><strong>Как это работает:</strong></p>
<blockquote>
<div><p>В этой программе мы запрашиваем ввод со стороны пользователя, но обрабатываем
введённую строку только если она имеет длину хотя бы в 3 символа. Итак, мы
используем встроенную функцию <code class="docutils literal"><span class="pre">len</span></code> для
получения длины строки, и если
длина менее 3, мы пропускаем остальные действия в блоке при помощи оператора
<code class="docutils literal"><span class="pre">continue</span></code>. В противном случае все
остальные команды в цикле выполняются,
производя любые манипуляции, которые нам нужны.</p>
<p>Заметьте, что оператор <code class="docutils literal"><span class="pre">continue</span></code> также
работает и с циклом <code class="docutils literal"><span class="pre">for</span></code>.</p>
</div>
</blockquote>
</div>
<div class="section" id="id11">
<h2>Резюме<a class="headerlink" href="#id11" title="Ссылка на этот заголовок">¶</a></h2>
<p>Мы увидели, как использовать три оператора для управления потоком команд:
<code class="docutils literal"><span class="pre">if</span></code>, <code class="docutils literal"><span
class="pre">while</span></code> и <code class="docutils literal"><span class="pre">for</span></code>,
а также связанные с ними операторы <code class="docutils literal"><span class="pre">break</span></code> и
<code class="docutils literal"><span class="pre">continue</span></code>. Это наиболее часто используемые
конструкции Python, поэтому
овладеть ими очень важно.</p>
<p>Далее мы увидим, как создавать и использовать функции.</p>
</div>
<div class="section" id="id12">
<h2>Примечания<a class="headerlink" href="#id12" title="Ссылка на этот заголовок">¶</a></h2>
<table class="docutils footnote" frame="void" id="id13" rules="none">
<colgroup>
<col class="label"/>
<col/>
</colgroup>
<tbody valign="top">
<tr>
<td class="label"><a class="fn-backref" href="#id2">[1]</a></td>
<td>if – <em>англ.</em> “если” (<em>прим.перев.</em>)</td>
</tr>
</tbody>
</table>
<table class="docutils footnote" frame="void" id="id14" rules="none">
<colgroup>
<col class="label"/>
<col/>
</colgroup>
<tbody valign="top">
<tr>
<td class="label"><a class="fn-backref" href="#id3">[2]</a></td>
<td>Соответствует булевому значению <code class="docutils literal"><span class="pre">True</span></code>
(<em>прим.перев.</em>)
</td>
</tr>
</tbody>
</table>
<table class="docutils footnote" frame="void" id="id15" rules="none">
<colgroup>
<col class="label"/>
<col/>
</colgroup>
<tbody valign="top">
<tr>
<td class="label"><a class="fn-backref" href="#id4">[3]</a></td>
<td>else – <em>англ.</em> “иначе”, “в противном случае”
(<em>прим.перев.</em>)
</td>
</tr>
</tbody>
</table>
<table class="docutils footnote" frame="void" id="id16" rules="none">
<colgroup>
<col class="label"/>
<col/>
</colgroup>
<tbody valign="top">
<tr>
<td class="label"><a class="fn-backref" href="#id5">[4]</a></td>
<td>nested – <em>англ.</em> “вложенный” (<em>прим.перев.</em>)</td>
</tr>
</tbody>
</table>
<table class="docutils footnote" frame="void" id="id17" rules="none">
<colgroup>
<col class="label"/>
<col/>
</colgroup>
<tbody valign="top">
<tr>
<td class="label"><a class="fn-backref" href="#id6">[5]</a></td>
<td>range – <em>англ.</em> “диапазон”, “интервал” (<em>прим.перев.</em>)
</td>
</tr>
</tbody>
</table>
<table class="docutils footnote" frame="void" id="id18" rules="none">
<colgroup>
<col class="label"/>
<col/>
</colgroup>
<tbody valign="top">
<tr>
<td class="label"><a class="fn-backref" href="#id7">[6]</a></td>
<td>list – <em>англ.</em> “список” (<em>прим.перев.</em>)</td>
</tr>
</tbody>
</table>
<table class="docutils footnote" frame="void" id="id19" rules="none">
<colgroup>
<col class="label"/>
<col/>
</colgroup>
<tbody valign="top">
<tr>
<td class="label"><a class="fn-backref" href="#id8">[7]</a></td>
<td>break – <em>англ.</em> “разбивать”, “разрывать” (<em>прим.перев.</em>)
</td>
</tr>
</tbody>
</table>
<table class="docutils footnote" frame="void" id="id20" rules="none">
<colgroup>
<col class="label"/>
<col/>
</colgroup>
<tbody valign="top">
<tr>
<td class="label"><a class="fn-backref" href="#id9">[8]</a></td>
<td>
<div class="first last line-block">
<div class="line"><strong>Swaroop’s Poetic Python</strong>:</div>
<div class="line">Programming is fun.</div>
<div class="line">When the work is done,</div>
<div class="line">if you wanna make your work also fun:</div>
<div class="line-block">
<div class="line">use Python!</div>
</div>
</div>
</td>
</tr>
</tbody>
</table>
<table class="docutils footnote" frame="void" id="id21" rules="none">
<colgroup>
<col class="label"/>
<col/>
</colgroup>
<tbody valign="top">
<tr>
<td class="label"><a class="fn-backref" href="#id10">[9]</a></td>
<td>continue – <em>англ.</em> “продолжать” (<em>прим.перев.</em>)</td>
</tr>
</tbody>
</table>
</div>
</div>
</body>
</html>