python/loop.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "a0dd7b9b",
   "metadata": {},
   "source": [
    "# Циклы\n",
    "\n",
    "### Предисловие\n",
    "\n",
    "> Циклы это специальные выражения, которые позволяют выполнять часть кода несколько раз, если оно того требует. Циклы очень полезны в программировании, поскольку это позволяет не прописывать вручную одну и ту же операцию несколько раз. Допустим нам надо вывести на экран 13 чисел от 1 до 13, как бы это выглядело без циклов:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "id": "aed53f19",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1\n",
      "2\n",
      "3\n",
      "4\n",
      "5\n",
      "6\n",
      "7\n",
      "8\n",
      "9\n",
      "10\n",
      "11\n",
      "12\n",
      "13\n"
     ]
    }
   ],
   "source": [
    "print(1)\n",
    "print(2)\n",
    "print(3)\n",
    "print(4)\n",
    "print(5)\n",
    "print(6)\n",
    "print(7)\n",
    "print(8)\n",
    "print(9)\n",
    "print(10)\n",
    "print(11)\n",
    "print(12)\n",
    "print(13)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "6e14ae80",
   "metadata": {},
   "source": [
    "Согласитесь, утомительно. Давайте посмотрим далее что можно с этим сделать, применив циклы. В языке Python есть несколько видов циклических выражений."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "4f2832b4",
   "metadata": {},
   "source": [
    "## Цикл while\n",
    "\n",
    "Самый простой вид циклов, выполняет инструкцию в блоке до тех пор, пока условие не станет ложным."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "75210624",
   "metadata": {},
   "outputs": [],
   "source": [
    "# создаем переменную, равную 1\n",
    "var = 1\n",
    "# прописываем цикл с условием - выполнять до тех пор, пока переменная\n",
    "# меньше или равна 13\n",
    "while var <= 13:\n",
    "# выводим значение переменной\n",
    "    print(var)\n",
    "# увеличиваем переменную на 1\n",
    "    var += 1"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "fc57e1cb",
   "metadata": {},
   "source": [
    "Попробуйте выполнить пример выше и посмотрите что получится, можете не переписывать комментарии. Как видно из примера, у нас появляются вложенные инструкции, а значит их надо отделять пробелами.\n",
    "\n",
    "\n",
    "\n",
    "**Памятка**\n",
    "\n",
    "> Необходимо всегда помнить, что при использовании цикла `while`, нужно следить за тем, чтобы было прописано условие выхода из цикла. Если бы в примере выше мы не увеличивали переменную `var` на `1`, тогда цикл бы стал бесконечным\n",
    "\n",
    "Давайте представим цикл `while` в виде блок схемы для наглядности: \n",
    "\n",
    "\n",
    "![блок схема 1](./pics/1_loop.png)\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "В нашем случае мы реализуем цикл `while` с помощью комбинации условие + действие. Действие будет повторяться до тех пор, пока не выполнится условие. Из схемы видно, что если мы уберем блок действия `var=var+1` , то наше условие не будет выполнено никогда и цикл будет бесконечным."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "4052353a",
   "metadata": {},
   "source": [
    "## Цикл for\n",
    "\n",
    "Цикл `for` менее универсальный, но работает быстрее, чем цикл `while`. Он способен проходить по любому итерируемому объекту, будь то списки, словари, кортежи, строки и не требует ручного увеличения счетчика итераций:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "23345690",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1\n",
      "2\n",
      "3\n",
      "4\n",
      "5\n",
      "6\n",
      "7\n",
      "8\n",
      "9\n",
      "10\n",
      "11\n",
      "12\n",
      "13\n"
     ]
    }
   ],
   "source": [
    "for i in [1, 2, 3, 4, 5 ,6 ,7 ,8 ,9 , 10, 11, 12, 13]:\n",
    "    print(i)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "236c9add",
   "metadata": {},
   "source": [
    "В примере выше написана программа с использованием цикла `for`. Мы указываем, что наша вложенная инструкция `print(i)` должна выполняться для каждого элемента из массива `[1, 2, 3, 4, 5 ,6 ,7 ,8 ,9 , 10, 11, 12, 13]`. То есть данный цикл описывает конструкцию:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "f9dff9d7",
   "metadata": {},
   "outputs": [],
   "source": [
    "i =1 \n",
    "print(i)\n",
    "i =2 \n",
    "print(i)\n",
    "i =3 \n",
    "print(i)\n",
    "...\n",
    "i = 13\n",
    "print(i)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "3cddb4e5",
   "metadata": {},
   "source": [
    "В нашем примере все равно отсутствует элегантность, присущая языку Python. Давайте попробуем что-нибудь сделать с массивом из 13 чисел. Что если нам понадобится выводить 100 или 100000 чисел? Для этих целей применим функцию `range()`, которая поможет нам автоматически сгенерировать последовательность чисел."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "id": "ebc8a1cd",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "range(1, 14)\n"
     ]
    }
   ],
   "source": [
    "var = range(1, 14)\n",
    "print(var)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "e5e247f6",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1\n",
      "2\n",
      "13\n"
     ]
    }
   ],
   "source": [
    "print(var[0])\n",
    "print(var[1])\n",
    "print(var[12])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "3c6beaa5",
   "metadata": {},
   "outputs": [
    {
     "ename": "IndexError",
     "evalue": "range object index out of range",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mIndexError\u001b[0m                                Traceback (most recent call last)",
      "\u001b[0;32m<ipython-input-3-ff19f22e8e16>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m\u001b[0m\n\u001b[0;32m----> 1\u001b[0;31m \u001b[0mprint\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mvar\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;36m14\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[0;31mIndexError\u001b[0m: range object index out of range"
     ]
    }
   ],
   "source": [
    "print(var[14])"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "e3ada58d",
   "metadata": {},
   "source": [
    "Мы присвоили переменной значение выражения `range(1,14)`, после того, как мы решили вывести содержимое переменной var, обнаружилось, что в ней заложено это выражение - `range(1, 14)`. Как говорилось ранее, range это особый тип, который содержит в себе последовательность данных. Чтобы это показать, выполним команду `print(var[0])`, которая выводит содержимое переменной, стоящей в `0` ячейке памяти. Ячейки памяти берут отсчет с `0`, поэтому на `12` позиции будет храниться число `13`, как видно из примера. Тем самым мы видим, что переменная `var` содержит в себе последовательность чисел от `1` до `13`. Но как быть с `14` позицией, ведь в команде `range()` второй параметр у нас равен `14`? Особенность `range()` состоит в том, что последнее число последовательности не включается в нее, то есть мы говорим, что нам надо сформировать последовательность чисел от `1` до `14`, не включая `14`. Функция `range()` работает так, потому что чаще всего используется для работы с  индексами, отсчет которых начинается с `0`.\n",
    "\n",
    "\n",
    "Вернемся к циклу `for`. Теперь мы можем написать нашу программу максимально компактно:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "id": "38944922",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1\n",
      "2\n",
      "3\n",
      "4\n",
      "5\n",
      "6\n",
      "7\n",
      "8\n",
      "9\n",
      "10\n",
      "11\n",
      "12\n",
      "13\n"
     ]
    }
   ],
   "source": [
    "for i in range(1,14):\n",
    "    print(i)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "f51d406c",
   "metadata": {},
   "source": [
    "В принципе, цикл `for` можно также изображать на блок-схемах, как и цикл `while`. Важно помнить, что увеличение счетчика и его начальное значение заложено внутри оператора `for` и его не надо прописывать отдельно.\n",
    "\n",
    "Примечание. Если необходимо выводить элементы цикла без перехода на следующую строку, то можно использовать параметр `end=' '` для функции `print()`. Этому параметру можно ничего не передавать, можно передавать пробелы или другие знаки:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "id": "b09ffb58",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1 2 3 4 5 6 7 8 9 10 11 12 13 "
     ]
    }
   ],
   "source": [
    "for i in range(1,14):\n",
    "    print(i, end=' ')"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "52177cb7",
   "metadata": {},
   "source": [
    "### Оператор continue\n",
    "\n",
    "Оператор `continue` позволяет начать следующий проход цикла, минуя оставшиеся инструкции:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "id": "47ff54b1",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "P\n",
      "y\n",
      "t\n",
      "o\n",
      "n\n"
     ]
    }
   ],
   "source": [
    "for var in 'Python':\n",
    "    if var == 'h':\n",
    "        continue\n",
    "    print(var)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "7bd988b3",
   "metadata": {},
   "source": [
    "На примере выше мы перебираем последовательность символов и когда наша переменная хранит в себе символ `'h'`, мы используем оператор `continue`, чтобы пропустить дальнейшую инструкцию `print(var)`.\n",
    "\n",
    "\n",
    "![блок схема 2](./pics/2_loop.png)\n",
    "\n",
    "\n",
    "\n",
    "На блок-схеме выше представлена ситуация, когда используется оператор `continue`. В текстовой сноске примерно описан вариант реализации цикла `for`. Основное, на что стоит обратить внимание, это красная линия, которая переводит на блок `for` без каких-либо действий.\n",
    "\n",
    "\n",
    "\n",
    "## Оператор break\n",
    "\n",
    "\n",
    "Оператор `break` досрочно прерывает цикл. Повторите пример ниже и посмотрите, что получится."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "id": "6770c5d6",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "P\n",
      "y\n",
      "t\n"
     ]
    }
   ],
   "source": [
    "for var in 'Python':\n",
    "    if var == 'h':\n",
    "        break\n",
    "    print(var)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "dd3c414d",
   "metadata": {},
   "source": [
    "![блок схема 3](./pics/3_loop.png)\n",
    "\n",
    "\n",
    "\n",
    "В данном случае оператор break ведет нас сразу к окончанию работы цикла. При этом получается, что выход совершается экстренный, т.к. мы не переберем все элементы эталона, о чем говорит пунктирная стрелка.\n",
    "\n",
    "\n",
    "## Оператор else\n",
    "\n",
    "Оператор `else` проверяет цикл на экстренный выход `(break)`. Если экстренного выхода не было, т.е. оператор `break` не был выполнен, блок инструкций вложенный в оператор `else` - выполняется."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "id": "caf0655a",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Символа a нет в слове Python\n"
     ]
    }
   ],
   "source": [
    "for var in 'Python':\n",
    "    if var == 'a':\n",
    "        break \n",
    "else:\n",
    "    print('Символа a нет в слове Python')"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "6bacce99",
   "metadata": {},
   "source": [
    "Операторы `continue`, `break` и `else` работают с циклами `for` и `while`."
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.9.6"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}