python_pd/02_syntax/03_control_structures.ipynb

{
 "metadata": {
  "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.8.4-final"
  },
  "orig_nbformat": 2,
  "kernelspec": {
   "name": "python3",
   "display_name": "Python 3"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2,
 "cells": [
  {
   "source": [
    "# Управляющие конструкции\n",
    "\n",
    "## Условный оператор\n",
    "### Синтаксис\n",
    "\n",
    "Условный оператор ```if``` в самой простой форме имеет вид:\n",
    "```python\n",
    "if condition:\n",
    "    expression\n",
    "```\n",
    "\n",
    "В качестве условия (```condition```) может выступать любое выражение, результат которого представим в виде булева значения.\n",
    "\n",
    "В теле условного оператора помещаются одна или несколько инструкций (```expression```). Также в качестве ```expression``` может использоваться ключевое слово ```pass```, которое означает бездействие и нужно для отладки или предварительного описания структуры программы.\n",
    "\n",
    "Оператор ```if``` может содержать необязательные блоки ```elif``` и ```else```. Количество блоков ```elif``` может быть произвольным. Таким образом, полная форма оператора ```if``` имеет вид:\n",
    "\n",
    "```python\n",
    "if condition_1:\n",
    "    expression_1\n",
    "elif condition_2:\n",
    "    expression_1\n",
    "...\n",
    "else:\n",
    "    expression\n",
    "```\n",
    "\n",
    "Порядок проверки всех условий идет сверху вниз. Будет выполнено тело того блока, соответствующее условие ```condition``` которого будет иметь истинное значение. Остальные условия проверяться не будут. Если все условия ```condition``` возвращают значение, эквивалентное ```False```, то будет выполнен блок в теле ```else```, если он присутствует.\n",
    "\n",
    "### Примеры\n",
    "\n",
    "В качестве примера рассмотрим проверку числа на кратность различным числам. Попробуйте самостоятельно задать разные значения переменной ```a```.\n"
   ],
   "cell_type": "markdown",
   "metadata": {}
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "output_type": "stream",
     "name": "stdout",
     "text": [
      "Число кратно трем\n"
     ]
    }
   ],
   "source": [
    "# Попробуйте задать числа: 1, 2, 66, 12, 15, 25, 40,  \n",
    "a = 69\n",
    "if not a % 2:\n",
    "    print('Четное число')\n",
    "elif not a % 3:\n",
    "    print('Число кратно трем')\n",
    "elif not a % 4:  # ?\n",
    "    print('Число кратно четырем')\n",
    "elif not a % 5:\n",
    "    print('Число кратно пяти')\n",
    "else:\n",
    "    print('Кратность неизвестна')"
   ]
  },
  {
   "source": [
    "Обратите внимание, что выполнение идет сверху вниз, поэтому число 66 будет четным, ветка с условием на кратность трем выполнена не будет. Также блок с условием на кратность четырем никогда выполняться не будет, т. к. все эти числа будут четными и, соответственно, будет выполнена первая ветка.\n",
    "\n",
    "В Python любой объект можно привести к значению типа ```bool```. Это можно легко проверить воспользовавшись функцией ```bool()```. Это позволяет автоматически преобразовывать различные значения в значения типа ```bool``` непосредственно внутри конструкций ```if - elif - else``` не прибегая к использованию логических операторов. Напомню, что результат логической операции (```>```, ```<``` и др.) является булевым значением.\n",
    "\n",
    "Такое преобразование заключаются в использовании самого объекта без каких либо операторов сравнения:"
   ],
   "cell_type": "markdown",
   "metadata": {}
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "output_type": "stream",
     "name": "stdout",
     "text": [
      "Не ноль\n"
     ]
    }
   ],
   "source": [
    "a = 42\n",
    "if a:\n",
    "    print('Не ноль')"
   ]
  },
  {
   "source": [
    "Здесь происходит следующее. Интерпретатор проверяет объект на истинность с помощью функции ```bool```, т. е. код выше будет эквивалентен следующему:"
   ],
   "cell_type": "markdown",
   "metadata": {}
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "output_type": "stream",
     "name": "stdout",
     "text": [
      "Не ноль\n"
     ]
    }
   ],
   "source": [
    "a = 42\n",
    "if bool(a):\n",
    "    print('Не ноль')"
   ]
  },
  {
   "source": [
    "В таких проверках условия будут выполняться всегда, кроме случаев, когда объекты являются ложными, т. е. нулями, пустой строкой, ```False``` или ```None```. Их сфера применения - это проверка объектов на истинность или ложность. Кроме этого, такое использование допускается комбинировать с использованием логических операторов.\n",
    "\n",
    "### Реализация логических операторов через ```if - else```\n",
    "\n",
    "Условные операторы ```or``` и ```and``` можно попытаться смоделировать с помощью условного оператора ```if - elif - else```. \n"
   ],
   "cell_type": "markdown",
   "metadata": {}
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "output_type": "stream",
     "name": "stdout",
     "text": [
      "Исходное выражение: True\nЛевая часть: True\n"
     ]
    }
   ],
   "source": [
    "# Будем проверять что foo не принадлежит интервалу (43, 50)\n",
    "# Для этого воспользуемся условием (foo < 42) or (foo > 50)  \n",
    "foo = 42\n",
    "print('Исходное выражение:', foo < 43 or foo > 50)\n",
    "\n",
    "if foo < 43:  # проверяем левую часть\n",
    "    print('Левая часть:', True)\n",
    "else:\n",
    "    print('Правая часть:', foo > 50)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "output_type": "stream",
     "name": "stdout",
     "text": [
      "Исходное выражение: True\nПравая часть: True\n"
     ]
    }
   ],
   "source": [
    "# Проверим что значение переменной foo лежит внутри интервала [a, b)\n",
    "# Используем цепочку сравнения a <= foo < b, которая\n",
    "# раскрывается через and в (foo >= a) and (foo < b)\n",
    "foo = 42\n",
    "a, b = 40, 50\n",
    "print('Исходное выражение:', a <= foo < b)\n",
    "\n",
    "if not foo >= a:  # проверяем левую часть\n",
    "    print('Левая часть:', False)\n",
    "else:\n",
    "    print('Правая часть:', foo < b)"
   ]
  },
  {
   "source": [
    "## Операторы цикла\n",
    "\n",
    "### Цикл ```for```\n",
    "\n",
    "В Python нет цикла со счетчиком, его заменяет цикл ```for``` для перебора элементов последовательности. Синтаксис цикла ```for``` довольно прост:\n",
    "\n",
    "```python\n",
    "for [iterating variable] in [sequence]:\n",
    "    expression\n",
    "```\n",
    "\n",
    "Здесь ```iterating variable``` переменная, которая будет поочередно принимать все значения из ```sequence```. Тело цикла ```expression``` может содержать различные выражения, использующие значения ```iterating variable```. Тело цикла выделяется отступом, аналогично условному оператору.\n",
    "\n",
    "Оператор ```for``` используется для перебора элементов последовательности (например, строки, кортежа или списка) или другого итерируемого объекта.\n",
    "\n",
    "Тело цикла (блок ```expression```) будет выполнен один раз для каждого элемента ```sequence```.\n",
    "\n",
    "Цикл ```for``` может содержать необязательные блок ```else```, который выполняется только в случае выполнения цикла до конца, без его прерывания.\n",
    "\n",
    "```python\n",
    "for [iterating variable] in [sequence]:\n",
    "    expression\n",
    "else:\n",
    "    expression\n",
    "```\n",
    "\n",
    "Рассмотрим простой пример прямого подсчета разных символов в строке.\n"
   ],
   "cell_type": "markdown",
   "metadata": {}
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "output_type": "stream",
     "name": "stdout",
     "text": [
      "Количество пробелов в строке: 8\nКоличество запятых в строке: 2\n"
     ]
    }
   ],
   "source": [
    "s = 'The ultimate question of life, the universe, and everything'\n",
    "number_of_spaces = 0\n",
    "number_of_commas = 0\n",
    "\n",
    "for c in s:\n",
    "    if c == ' ':\n",
    "        number_of_spaces += 1\n",
    "    elif c == ',':\n",
    "        number_of_commas += 1\n",
    "\n",
    "print('Количество пробелов в строке:', number_of_spaces)\n",
    "print('Количество запятых в строке:', number_of_commas)\n"
   ]
  },
  {
   "source": [
    "### Цикл ```while```\n",
    "\n",
    "Цикл ```while``` называют циклом с предусловием, он похож на аналогичные циклы в других языках программирования. \n",
    "\n",
    "```python\n",
    "while condition:\n",
    "    expression\n",
    "else:\n",
    "    expression\n",
    "```\n",
    "\n",
    "Цикл ```while``` предназначен для повторного выполнения тела цикла (```expression```) пока истинно условие ```condition```. Выражение ```condition``` называется предусловием потому, что вначале каждой итерации цикла идет его проверка, а только потом выполнение тела цикла.\n",
    "\n",
    "Циклов с постусловием (аналогов ```do ... while ...```) в Python нет.\n",
    "\n",
    "Блок ```else``` в цикле ```while``` является необязательным.  И выполняется в том случае, если условие ```condition``` стало ложным.\n",
    "\n",
    "В качестве примера рассмотрим простую программу проверки числа на [множественное число Нивена](https://en.wikipedia.org/wiki/Harshad_number).\n"
   ],
   "cell_type": "markdown",
   "metadata": {}
  },
  {
   "cell_type": "code",
   "execution_count": 55,
   "metadata": {},
   "outputs": [
    {
     "output_type": "stream",
     "name": "stdout",
     "text": [
      "Число 6804 - множественное число Нивена\nЧисло 6804 достигло 1 за 4 шага\n"
     ]
    }
   ],
   "source": [
    "# Задайте число для проверки n и максимальное количество интераций k\n",
    "# самостоятельно проверьте числа 12, 972, 2016502858579884466176, 10080000000000 и другие\n",
    "n = 6804\n",
    "k = 15\n",
    "\n",
    "# зададим дополнительные переменные\n",
    "# i нужна для подсчета числа итераций, а n_ будет содержать остаток от деления\n",
    "i = 0\n",
    "n_ = n\n",
    "\n",
    "# цикл будет выполнятся пока не достигним 1 и \n",
    "# пока ограничение по итерациям не достигло 0\n",
    "while n_ != 1 and k > 0:\n",
    "    # считаем сумму цифр в числе и сохраняем в sum_digits\n",
    "    sum_digits = 0\n",
    "    str_n = str(n_)\n",
    "    for d in str_n:\n",
    "        sum_digits += int(d)\n",
    "    # проверяем на делимость\n",
    "    if n_ % sum_digits == 0:\n",
    "        # следующим числом будет целая часть от деления на сумму цифр\n",
    "        n_ = n_ // sum_digits\n",
    "        i += 1\n",
    "        k -= 1\n",
    "    else:\n",
    "        # если число не делиться нацело, то дальнейшая проверка \n",
    "        # не нужна, обнуляем число доступных итераций для того, \n",
    "        # чтобы условие стало ложным\n",
    "        k = 0\n",
    "\n",
    "# если не достигли 1, то это не множественное число Нивена\n",
    "if n_ != 1:\n",
    "    print('Число', n, 'не является множественным числом Нивена')\n",
    "else:\n",
    "    print('Число', n, '- множественное число Нивена')\n",
    "    print('Число', n, 'достигло 1 за', i, 'шага')\n"
   ]
  },
  {
   "source": [
    "### ```brak``` и ```continue```\n",
    "\n",
    "Эти операторы предназначены для управления выполнением цикла и могут быть использованы только в теле цикла.\n",
    "\n",
    "Оператор ```break``` завершает цикл в теле которого он находится. При этом выполнение блока ```else``` не происходит.\n",
    "\n",
    "Оператор ```continue``` переходит к следующей итерации цикла, в теле которого он находится, при этом блок кода после ```continue``` пропускается.\n",
    "\n",
    "В качестве примера приведен прямой поиск первого вхождения символа в строке."
   ],
   "cell_type": "markdown",
   "metadata": {}
  },
  {
   "cell_type": "code",
   "execution_count": 83,
   "metadata": {},
   "outputs": [
    {
     "output_type": "stream",
     "name": "stdout",
     "text": [
      "Символ найден. Индекс: 35\n"
     ]
    }
   ],
   "source": [
    "s = 'spam, spom, spam, spam… lovely spam! wonderful spam!'\n",
    "char = '!'  # символ, который нужно найти\n",
    "\n",
    "# перебираем поочередно все символы в строке\n",
    "# j это номер символа в строке, начиная с 0\n",
    "j = 0\n",
    "for c in s:\n",
    "    if c == char:\n",
    "        # если символ совпал, дальше не ищем, а сразу выходим из цикла\n",
    "        print('Символ найден. Индекс:', j)\n",
    "        break\n",
    "    j += 1\n",
    "else:\n",
    "    # если символ не встретился, break не выполнится, а ветка else выполнится\n",
    "    print('строка не найдена')\n"
   ]
  },
  {
   "source": [
    "## Примеры использования моржового оператора\n",
    "\n",
    "Использование моржового оператора в конструкциях ```if - elif - else``` может не только повысить читаемость, но и поможет избавиться от дублирования кода и несколько оптимизировать код. Ниже приведен простой пример проверки делимости числа."
   ],
   "cell_type": "markdown",
   "metadata": {}
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "output_type": "stream",
     "name": "stdout",
     "text": [
      "Остаток от деления на 3: 1\n"
     ]
    }
   ],
   "source": [
    "# первый вариант, без использования :=\n",
    "x = 196\n",
    "\n",
    "# заранее вичисляются остатки от деления для 3 и 4\n",
    "a = x % 3\n",
    "b = x % 4\n",
    "if a:\n",
    "    print('Остаток от деления на 3:', a)\n",
    "elif b:\n",
    "    print('Остаток от деления на 4:', a)\n",
    "else:\n",
    "    print('Что-то другое')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "output_type": "stream",
     "name": "stdout",
     "text": [
      "Остаток от деления на 3: 1\n"
     ]
    }
   ],
   "source": [
    "# второй вариант, без использования :=\n",
    "x = 196\n",
    "\n",
    "# заранее ничего не вычисляем\n",
    "if x % 3:\n",
    "    # если условие истинно, придется еще раз вычислить это выражение\n",
    "    print('Остаток от деления на 3:', x % 3)\n",
    "elif x % 4:  # это выражение не вычисляется, если первое будет истинным\n",
    "    # здесь опять повторение кода из условия x % 4\n",
    "    print('Остаток от деления на 4:', x % 4)\n",
    "else:\n",
    "    print('Что-то другое')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "output_type": "stream",
     "name": "stdout",
     "text": [
      "Остаток от деления на 3: 1\n"
     ]
    }
   ],
   "source": [
    "# вариант с использованием :=\n",
    "x = 196\n",
    "if a := x % 3:\n",
    "    # не нужно второй раз вычислять x % 3\n",
    "    print('Остаток от деления на 3:', a)\n",
    "elif a := x % 4:  # это выражение не будет вычислено, если первое истинно\n",
    "    # не нужно второй раз вычислять x % 4\n",
    "    print('Остаток от деления на 4:', a)\n",
    "else:\n",
    "    print('Что-то другое')"
   ]
  },
  {
   "source": [
    "## Должен существовать один и, желательно, только один очевидный способ...\n",
    "\n",
    "Применение моржового оператора в циклах еще более интересно и полезно. Один из примеров использования цикла ```while``` является зацикливание программы для запроса пользовательского ввода. Эту функциональность можно реализовать тремя разными способами, два из которых \"по старинке\", т. е. без использования моржового оператора.\n",
    "\n",
    "Здесь понадобиться функция запроса пользовательского ввода ```input```. Эта функция может принимать аргумент, который будет выведен пользователю как приглашение ко вводу. Если функция вызвана без аргументов, т. е. ```input()```, приглашение ко вводу бедет отсутствовать.\n",
    "\n",
    "Первая реализация \"классическая\"."
   ],
   "cell_type": "markdown",
   "metadata": {}
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# запрашиваем пользовательский ввод\n",
    "s = input('s =')\n",
    "\n",
    "# пока пользователь не введет слово stop цикл будет выполняться\n",
    "while s != 'stop':\n",
    "    # пользовательский ввод просто выводится на экран\n",
    "    print(s)\n",
    "    # снова просим что-то ввести\n",
    "    s = input('s =')\n",
    "else:\n",
    "    # когда цикл завершился, сообщаем о завершении\n",
    "    print('input completed')"
   ]
  },
  {
   "source": [
    "В примере выше есть один недостаток. Это дублирование кода. Строка ```s = input('s =')``` повторяется два раза. \n",
    "\n",
    "Вторая реализация основана на бесконечном цикле. В ней уже нет проблемы предыдущего блока кода, но есть другая проблема. Теперь цикл бесконечный, а это означает, что нужно обязательно использовать внутри него условный оператор, который будет завершать цикл с помощью ```break```. Это добавляет лишний уровень отступа. Здесь можно легко совершить ошибку. Если условие будет работать некорректно цикл может никогда не завершиться."
   ],
   "cell_type": "markdown",
   "metadata": {}
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# бесконечный цикл\n",
    "while True:\n",
    "    s = input('s =')\n",
    "\n",
    "    # проверка на условие выхода из цикла\n",
    "    if s == 'stop':\n",
    "        print('input completed')\n",
    "        break\n",
    "    print(s)\n"
   ]
  },
  {
   "source": [
    "Наконец, наиболее правильная реализация с помощью моржового оператора. Помимо того, что код стал короче, эта реализация исключает проблемы, описанные выше. \n",
    "\n",
    "Работа этого цикла будет происходить следующим образом:\n",
    "- в переменную ```s``` будет сохранен пользовательский ввод\n",
    "- производится проверка условия продолжения цикла: сравнение строки ```s``` со строкой ```'stop'```\n",
    "- если оно выполнено, выполняется тело цикла\n",
    "- иначе цикл завершается и выполняется ветка ```else```"
   ],
   "cell_type": "markdown",
   "metadata": {}
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "while (s := input('s =')) != 'stop':\n",
    "    print(s)\n",
    "else:\n",
    "    print('input completed')"
   ]
  },
  {
   "source": [
    "Вот еще один пример использования оператора моржа. Он взят прямиком из [PEP 572](https://www.python.org/dev/peps/pep-0572/). Здесь вычисляется нижняя граница корня $n$-й степени из числа $x$, а $a$ - это исходное предположение об этой границе."
   ],
   "cell_type": "markdown",
   "metadata": {}
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "output_type": "stream",
     "name": "stdout",
     "text": [
      "15\n8\n5\n"
     ]
    }
   ],
   "source": [
    "n = 2\n",
    "x = 30\n",
    "a = x\n",
    "while a > (d := x // a**(n-1)):\n",
    "    a = ((n-1)*a + d) // n\n",
    "    print(a)"
   ]
  },
  {
   "source": [
    "[Здесь](https://github.com/vlevieux/Walrus-Operator-Use-Cases) можно посмотреть на другие примеры использования оператора моржа. "
   ],
   "cell_type": "markdown",
   "metadata": {}
  }
 ]
}