Поток команд
============



В программах, которые мы до сих пор рассматривали, последовательность команд 
всегда выполнялась Python по порядку строго сверху вниз. А что, если нам 
необходимо изменить поток выполняющихся команд? Например, если требуется, чтобы 
программа принимала некоторое решение и выполняла различные действия в 
зависимости от ситуации; скажем, печатала "Доброе утро" или "Добрый вечер" в 
зависимости от времени суток.

Как вы уже, наверное, догадались, этого можно достичь при помощи операторов 
управления потоком. В Python есть три оператора управления потоком: ``if``, 
``for`` и ``while``.



Оператор if
-----------

Оператор ``if`` используется для проверки условий: *если*\ [1]_  условие верно\ 
[2]_, выполняется блок выражений (называемый "if-блок"), *иначе*\ [3]_  
выполняется другой блок выражений (называемый "else-блок"). Блок "else" 
является необязательным.

**Пример:** (сохраните как ``if.py``)

.. sourcecode:: python

    number = 23
    guess = int(input('Введите целое число : '))

    if guess == number:
        print('Поздравляю, вы угадали,') # Здесь начинается новый блок
        print('(хотя и не выиграли никакого приза!)') # Здесь заканчивается новый блок
    elif guess < number:
        print('Нет, загаданное число немного больше этого.') # Ещё один блок
        # Внутри блока вы можете выполнять всё, что угодно ...
    else:
        print('Нет, загаданное число немного меньше этого.')
        # чтобы попасть сюда, guess должно быть больше, чем number

    print('Завершено')
    # Это последнее выражение выполняется всегда после выполнения оператора if

**Вывод:**

::

    $ python if.py
    Введите целое число : 50
    Нет, загаданное число немного меньше этого.
    Завершено

    $ python if.py
    Введите целое число : 22
    Нет, загаданное число немного больше этого.
    Завершено

    $ python if.py
    Введите целое число : 23
    Поздравляю, вы угадали,
    (хотя и не выиграли никакого приза!)
    Завершено

**Как это работает:**

  В этой программе мы принимаем варианты от пользователя и проверяем, 
  совпадают ли они с заранее заданным числом. Мы устанавливаем переменной 
  ``number`` значение любого целого числа, какого хотим. Например, ``23``. 
  После этого мы принимаем вариант числа от пользователя при помощи функции 
  ``input()``. Функции -- это всего-навсего многократно используемые фрагменты 
  программы. Мы узнаем о них больше в :doc:`следующей главе <functions>`.

  Мы передаём встроенной функции ``input`` строку, которую она выводит на экран 
  и ожидает ввода от пользователя. Как только мы ввели что-нибудь и нажали 
  клавишу ``Enter``, функция ``input()`` возвращает строку, которую мы ввели. 
  Затем мы преобразуем полученную строку в число при помощи ``int()``, и
  сохраняем это значение в переменную ``guess``. Вообще-то, ``int`` -- это 
  класс, но на данном этапе вам достаточно знать лишь, что при помощи него 
  можно преобразовать строку в целое число (предполагая, что строка содержит 
  целое число).

  Далее мы сравниваем число, введённое пользователем, с числом, которое мы 
  выбрали заранее. Если они равны, мы печатаем сообщение об успехе. Обратите 
  внимание, что мы используем соответствующие уровни отступа, чтобы указать 
  Python, какие выражения относятся к какому блоку. Вот почему отступы так 
  важны в Python. Я надеюсь, вы придерживаетесь правила "постоянных отступов", 
  не так ли?

  Обратите внимание, что в конце оператора ``if`` стоит двоеточие -- этим мы 
  показываем, что далее следует блок выражений.

  После этого мы проверяем, верно ли, что пользовательский вариант числа меньше
  загаданного, и если это так, мы информируем пользователя о том, что ему 
  следует выбирать числа немного больше этого. Здесь мы использовали выражение 
  ``elif``, которое попросту объединяет в себе два связанных ``if else-if else``
  выражения в одно выражение ``if-elif-else``. Это облегчает чтение программы, 
  а также не требует дополнительных отступов.

  Выражения ``elif`` и ``else`` также имеют двоеточие в конце логической строки,
  за которым следуют соответствующие блоки команд (с соответствующим числом 
  отступов, конечно).

  Внутри if-блока оператора ``if`` может быть другой оператор ``if`` и 
  так далее -- это называется вложенным\ [4]_  оператором ``if``.

  Помните, что части ``elif`` и ``else`` не обязательны. Минимальная корректная 
  запись оператора ``if`` такова:

  .. sourcecode:: python

    if True:
        print('Да, это верно.')

  После того, как Python заканчивает выполнение всего оператора ``if`` вместе с 
  его частями ``elif`` и ``else``, он переходит к следующему выражению в блоке, 
  содержащем этот оператор ``if``. В нашем случае это основной блок программы 
  (в котором начинается выполнение программы), а следующее выражение -- это 
  ``print('Завершено')``. После этого Python доходит до конца программы и 
  просто выходит из неё.

Хотя это и чрезвычайно простая программа, я указал вам на целый ряд вещей, 
которые стоит взять на заметку. Всё это довольно легко (даже удивительно 
легко для тех из вас, кто пришёл из мира C/C++). Поначалу вам придётся держать 
все эти вещи в памяти, но после некоторой практики вы привыкнете, и они вам 
покажутся вполне "естественными".

.. admonition:: Замечание для программистов на C/C++

  В Python нет оператора ``switch``. Однако, при помощи конструкции 
  ``if..elif..else`` можно достичь того же самого (а в некоторых случаях можно
  даже использовать :ref:`словарь <dictionary>`, чтобы сделать это быстро).


Оператор while
--------------

Оператор ``while`` позволяет многократно выполнять блок команд до тех пор, 
пока выполняется некоторое условие. Это один из так называемых *операторов 
цикла*. Он также может иметь необязательный пункт ``else``.

**Пример:** (сохраните как ``while.py``) 

.. sourcecode:: python

    number = 23
    running = True

    while running:
        guess = int(input('Введите целое число : '))

        if guess == number:
            print('Поздравляю, вы угадали.')
            running = False # это останавливает цикл while
        elif guess < number:
            print('Нет, загаданное число немного больше этого.')
        else:
            print('Нет, загаданное число немного меньше этого.')
    else:
        print('Цикл while закончен.')
        # Здесь можете выполнить всё что вам ещё нужно

    print('Завершение.')


**Вывод:**

::

    $ python while.py
    Введите целое число : 50
    Нет, загаданное число немного меньше этого.
    Введите целое число : 22
    Нет, загаданное число немного больше этого.
    Введите целое число : 23
    Поздравляю, вы угадали.
    Цикл while закончен.
    Завершение.

**Как это работает:**

  В этой программе мы продолжаем играть в игру с угадыванием, но преимущество 
  состоит в том, что теперь пользователь может угадывать до тех пор, пока не 
  угадает правильное число, и ему не придётся запускать программу заново для 
  каждой попытки, как это происходило до сих пор. Это наглядно демонстрирует 
  применение оператора ``while``.

  Мы переместили операторы ``input`` и ``if`` внутрь цикла ``while`` и 
  установили переменную ``running`` в значение ``True`` перед запуском цикла. 
  Прежде всего проверяется, равно ли значение переменной ``running`` ``True``, 
  а затем происходит переход к соответствующему *while-блоку*. После выполнения 
  этого блока команд условие, которым в данном случае является переменная 
  ``running``, проверяется снова. Если оно истинно, while-блок запускается 
  снова, в противном случае происходит переход к дополнительному else-блоку, а 
  затем -- к следующему оператору.

Блок ``else`` выполняется тогда, когда условие цикла ``while`` становится 
ложным (``False``) -- это может случиться даже при самой первой проверке 
условия. Если у цикла ``while`` имеется дополнительный блок ``else``, он 
всегда выполняется, если только цикл не будет прерван оператором ``break``.

``True`` и ``False`` называются булевым типом данных, и вы можете считать их 
эквивалентными значениям ``1`` и ``0`` соответственно.

.. admonition:: Примечание для программистов на C/C++

    Помните, что у цикла ``while`` может быть блок ``else``.



Цикл for
--------

Оператор ``for..in`` также является оператором цикла, который осуществляет 
*итерацию* по последовательности объектов, т.е. проходит через каждый элемент 
в последовательности. Мы узнаем больше о :ref:`последовательностях <dat-sequences>` 
в дальнейших главах, а пока просто запомните, что последовательность -- это 
упорядоченный набор элементов.

**Пример:** (сохраните как ``for.py``)

.. sourcecode:: python

    for i in range(1, 5):
        print(i)
    else:
        print('Цикл for закончен')


**Вывод:**

::

    $ python for.py
    1
    2
    3
    4
    Цикл for закончен

**Как это работает:**

  В этой программе мы выводим на экран *последовательность* чисел. Мы 
  генерируем эту последовательность, используя встроенную функцию ``range``\ 
  [5]_.

  Мы задаём два числа, и ``range`` возвращает последовательность чисел от 
  первого числа до второго. Например, ``range(1,5)`` даёт последовательность 
  ``[1, 2, 3, 4]``. По умолчанию ``range`` принимает значение шага, равное 1. 
  Если мы зададим также и третье число ``range``, оно будет служить шагом. 
  Например, ``range(1,5,2)`` даст ``[1,3]``. Помните, интервал простирается 
  только *до* второго числа, т.е. **не** включает его в себя.

  Обратите внимание, что ``range()`` генерирует последовательность чисел, но 
  только по одному числу за раз -- когда оператор for запрашивает следующий 
  элемент. Чтобы увидеть всю последовательность чисел сразу, используйте 
  ``list(range())``. Списки\ [6]_  подробно рассматриваются в главе 
  :ref:`Структуры данных <data-list>`.

  Затем цикл ``for`` осуществляет итерацию по этому диапазону - ``for i in 
  range(1,5)`` эквивалентно ``for i in [1, 2, 3, 4]``, что напоминает 
  присваивание переменной i по одному числу (или объекту) за раз, выполняя блок 
  команд для каждого значения ``i``. В данном случае в блоке команд мы просто 
  выводим значение на экран.

Помните, что блок ``else`` не обязателен. Если он присутствует, он всегда 
выполняется один раз после окончания цикла ``for``, если только не указан 
оператор :ref:`break <break-operator>`.

Помните также, что цикл ``for..in`` работает для любой последовательности. В 
нашем случае это список чисел, сгенерированный встроенной функцией ``range``, 
но в общем случае можно использовать любую последовательность любых объектов! 
В следующих разделах мы познакомимся с этим поближе.

.. admonition:: Примечание для программистов на C/C++/Java/C#

    Цикл ``for`` в Python радикально отличается от цикла ``for`` в C/C++. 
    Программисты на C# заметят, что цикл ``for`` в Python похож на цикл 
    ``foreach`` в C#. Программистам на Java это может напомнить конструкцию 
    ``for (int i : IntArray)`` в Java 1.5.

    Если в C/C++ записать ``for (int i = 0; i < 5; i++)``, то в Python этому
    соответствовало бы выражение ``for i in range(0,5)``. Как видно, в Python
    цикл ``for`` проще, более выразителен и менее подвержен ошибкам.


.. _break-operator:

Оператор break
--------------

Оператор ``break`` служит для *прерывания*\ [7]_  цикла, т.е. остановки 
выполнения команд даже если условие выполнения цикла ещё не приняло значения 
``False`` или последовательность элементов не закончилась.

Важно отметить, что если циклы ``for`` или ``while`` прервать оператором 
*break*, соответствующие им блоки ``else`` выполняться **не** будут.

**Пример:** (сохраните как ``break.py``)

.. sourcecode:: python

    while True:
        s = input('Введите что-нибудь : ')
        if s == 'выход':
            break
        print('Длина строки:', len(s))
    print('Завершение')

**Вывод:**

::

    $ python break.py
    Введите что-нибудь : Программировать весело.
    Длина строки: 23
    Введите что-нибудь : Если работа скучна,
    Длина строки: 19
    Введите что-нибудь : Чтобы придать ей весёлый тон -
    Длина строки: 30
    Введите что-нибудь :       используй Python!
    Длина строки: 23
    Введите что-нибудь : выход
    Завершение

**Как это работает:**

  В этой программе мы многократно считываем пользовательский ввод и выводим на 
  экран длину каждой введённой строки. Для остановки программы мы вводим 
  специальное условие, проверяющее, совпадает ли пользовательский ввод со 
  строкой ``'выход'``. Мы останавливаем программу *прерыванием* цикла 
  оператором ``break`` и достигаем её конца.

  Длина введённой строки может быть найдена при помощи встроенной функции 
  ``len``.

  Помните также, что оператор ``break`` может применяться и в цикле ``for``.



Поэтический Python Swaroop'а
~~~~~~~~~~~~~~~~~~~~~~~~~~~~


Для ввода строк здесь я использовал мини-стишок, который сам сочинил. Он 
называется *Поэтический Python Swaroop'а*\ [8]_

    | Программировать весело.
    | Если работа скучна,
    | Чтобы придать ей весёлый тон -
    |       используй Python!



Оператор continue
-----------------

Оператор ``continue`` используется для указания Python, что необходимо 
пропустить все оставшиеся команды в текущем блоке цикла и *продолжить*\ [9]_
со следующей итерации цикла.

**Пример:** (сохраните как ``continue.py``)
 
.. sourcecode:: python

     while True:
         s = input('Введите что-нибудь : ')
         if s == 'выход':
             break
         if len(s) < 3:
             print('Слишком мало')
             continue
         print('Введённая строка достаточной длины')
         # Разные другие действия здесь...

**Вывод:**

::

    $ python continue.py
    Введите что-нибудь : a
    Слишком мало
    Введите что-нибудь : 12
    Слишком мало
    Введите что-нибудь : абв
    Введённая строка достаточной длины
    Введите что-нибудь : выход
 
**Как это работает:**

  В этой программе мы запрашиваем ввод со стороны пользователя, но обрабатываем 
  введённую строку только если она имеет длину хотя бы в 3 символа. Итак, мы 
  используем встроенную функцию ``len`` для получения длины строки, и если 
  длина менее 3, мы пропускаем остальные действия в блоке при помощи оператора 
  ``continue``. В противном случае все остальные команды в цикле выполняются, 
  производя любые манипуляции, которые нам нужны.

  Заметьте, что оператор ``continue`` также работает и с циклом ``for``.
 


Резюме
------

Мы увидели, как использовать три оператора для управления потоком команд: 
``if``, ``while`` и ``for``, а также связанные с ними операторы ``break`` и 
``continue``. Это наиболее часто используемые конструкции Python, поэтому 
овладеть ими очень важно.

Далее мы увидим, как создавать и использовать функции.
 


Примечания
----------

.. [1] if -- *англ.* "если" (*прим.перев.*)
.. [2] Соответствует булевому значению ``True`` (*прим.перев.*)
.. [3] else -- *англ.* "иначе", "в противном случае" (*прим.перев.*)
.. [4] nested -- *англ.* "вложенный" (*прим.перев.*)
.. [5] range -- *англ.* "диапазон", "интервал" (*прим.перев.*)
.. [6] list -- *англ.* "список" (*прим.перев.*)
.. [7] break -- *англ.* "разбивать", "разрывать" (*прим.перев.*)
.. [8] | **Swaroop's Poetic Python**:
       | Programming is fun.
       | When the work is done,
       | if you wanna make your work also fun:
       |     use Python!
.. [9] continue -- *англ.* "продолжать" (*прим.перев.*)