{ "cells": [ { "cell_type": "markdown", "metadata": {}, "source": [ "# Структура программы\n", "## Условный оператор if\n", "\n", "В полной форме:\n", "\n", "```\n", "if [условие - логическое выражение, True или False]:\n", " [блок кода с отступом 4]\n", "elif [условие]:\n", " # иначе, если. Условие проверяется, если не выполнено предыдущее\n", " [блок кода с отступом 4]\n", "elif [условие]:\n", " # еще условие, проверяется, если оба предыдущих не выполнились\n", " [блок кода с отступом 4]\n", "else:\n", " # блок выполняется, если все предыдущие условия не выполнены (False)\n", " [блок кода с отступом 4]\n", "```\n", "\n", "Обязательно иметь только блок c `if`, блоков `elif` может быть сколько угодно или вообще не быть, блок `else` либо один, либо его нет.\n", "\n", "блоки if могут быть вложены, т.е. во внутренних блоках кода тоже можно проверять условия:\n", "\n", "```\n", "if x > 0:\n", " if y > 0:\n", " print(\"здесь x и y положительны\")\n", " else:\n", " print(\"здесь только x положительный\")\n", "```\n", "\n", "Второй `else` относится к `if y > 0`. Это понятно из форматирования, потому что он поставлен с отступом от `if x > 0`.\n", "\n", "## Циклы\n", "### Цикл for\n", "\n", "Одна форма:\n", "\n", "```\n", "for [переменная] in [какое-то перечисление]:\n", " [блок кода с отступом 4, можно использовать \"переменную\"]\n", "```\n", "\n", "переменной последовательно присваиваются значения из перечисления. Например, так:" ] }, { "cell_type": "code", "execution_count": 1, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "0\n", "1\n", "2\n", "3\n", "4\n", "5\n", "6\n", "7\n", "8\n", "9\n" ] } ], "source": [ "for i in range(10):\n", " print(i)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Переменной `i` последовательно присваиваются значения от 0 до 9, подробней про `range` будет дальше.\n", "\n", "Получается, что в python нет привычных циклов из Pascal или C, когда можно сказать, что переменная сначала равна 1, а потом постепенно увеличиваеся до 10:\n", "\n", "```\n", "for i := 1 to 10 do\n", "```\n", "\n", "В C и Pascal последовательное изменение значения числовой перменной встроено в язык.\n", "\n", "### Цикл while\n", "\n", "```\n", "while [условие]:\n", " [блок кода с отступом 4]\n", "```\n", "\n", "В цикле проверяется условие. Если оно верно, выполняется блок кода, иначе цикл заканчивается.\n", "После выполнения блока кода снова проверяется условие, если оно верно, выполняется блок кода, иначе цикл заканчивается.\n", "И так далее.\n", "\n", "Другими словами, пока условие верно, блок кода выполняется. Как только оно стало неверным, цикл завершается.\n", "\n", "В Python нет цикла do while, в котором условие проверяется в конце." ] }, { "cell_type": "code", "execution_count": 4, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "1\n", "2\n", "4\n", "8\n", "16\n", "32\n", "64\n" ] } ], "source": [ "x = 1\n", "while x < 100:\n", " print(x)\n", " x = x * 2" ] }, { "cell_type": "code", "execution_count": 5, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "2\n", "4\n", "8\n", "16\n", "32\n", "64\n", "128\n" ] } ], "source": [ "x = 1\n", "while x < 100:\n", " x = x * 2\n", " print(x)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Например, давайте пользователь будет вводить числа до тех пор пока не введет слово `stop`. Дальше программа должна распечатать сумму введенных чисел. Ввод данных - это функция input.\n", "\n", "Цикл `for` не подходит, потому что он делает действия для фиксированного набора элементов из перечисления. Пользуемся `while`:|" ] }, { "cell_type": "code", "execution_count": 10, "metadata": {}, "outputs": [ { "name": "stdin", "output_type": "stream", "text": [ "введите число или слово stop 10\n", "введите число или слово stop 20\n", "введите число или слово stop 30\n", "введите число или слово stop stop\n" ] }, { "name": "stdout", "output_type": "stream", "text": [ "сумма введенных чисел равна 60\n" ] } ], "source": [ "sum = 0 # сначала сумма равна 0, потом будем изменяться\n", "text = input(\"введите число или слово stop\") # возвращает строку, введенную пользователем\n", "while text != 'stop':\n", " sum = sum + int(text) # int это и имя типа, и функция превращаения в int, т.е. целое\n", " text = input(\"введите число или слово stop\")\n", " \n", "print(f\"сумма введенных чисел равна {sum}\") " ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Как сделать лучше? Часто условие нужно проверять не в начале цикла, а в середине. В данном случае в цикле надо сначла спросить пользователя число, проверить не слово ли это stop и потом уже добавить число в сумму:" ] }, { "cell_type": "code", "execution_count": 11, "metadata": {}, "outputs": [ { "name": "stdin", "output_type": "stream", "text": [ "введите число или слово stop 10\n", "введите число или слово stop 20\n", "введите число или слово stop 30\n", "введите число или слово stop stop\n" ] }, { "name": "stdout", "output_type": "stream", "text": [ "сумма введенных чисел равна 60\n" ] } ], "source": [ "sum = 0 # сначала сумма равна 0, потом будем изменяться\n", "while True: # условие, которое всегда верно. 2 == 2 эквивалентно True\n", " text = input(\"введите число или слово stop\")\n", " if text == 'stop': # проверка условия на выход в середине цикла\n", " break # break завершает цикл\n", " sum = sum + int(text) # int это и имя типа, и функция превращаения в int, т.е. целое\n", " \n", "print(f\"сумма введенных чисел равна {sum}\") " ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "# Типы последовательности\n", "Хранят последовательность значений, эти значения можно перечислять в цикле `for`. Таких типов очень много, можно создавать свои. Встроенные:\n", "\n", "1. Строки - перечисление своих символов. \"abc\", например, это перечисление символов \"a\", \"b\", \"c\". В Python нет разделения типов между строками и символами. Символы тоже строки." ] }, { "cell_type": "code", "execution_count": 12, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "h\n", "e\n", "l\n", "l\n", "o\n" ] } ], "source": [ "for c in \"hello\":\n", " print(c)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "`c` последовательно присваиваются символы слова \"hello\"." ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "2. range - диапазоны. Это специальный тип, он называется range, диапазон можно создать функцией, которая тоже называется `range`. Варианты использования:" ] }, { "cell_type": "code", "execution_count": 20, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "0\n", "10\n", "20\n", "30\n", "40\n", "50\n", "60\n", "70\n", "80\n", "90\n", "---\n", "10\n", "9\n", "8\n", "7\n", "6\n", "5\n", "4\n", "3\n", "2\n", "1\n" ] } ], "source": [ "range(10) # от 0 до 9, указанное значение не включается. Не до 10, а до 9\n", "range(2, 10) # от 2 до 9, правое значение опять не включается\n", "range(0, 100, 10) # от 0 до 100 (не включительно) с шагом 10\n", "\n", "# Пока что мы можем использовать это только в циклах\n", "\n", "for x in range(0, 100, 10):\n", " print(x)\n", " \n", "print(\"---\") \n", " \n", "for x in range(10, 0, -1): # конечное значение 0 не включается\n", " print(x)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "3. Списки (list) и кортежи (tuple, тьюплы). Это упорядоченные последовательности произвольных элементов. Например, список `[10, 20, 30]` хранит три числа 10, 20 и 30.\n", "\n", " Кортежи аналогично, только можно без скобок:\n", " ```10, 20, 30```, это тоже три числа 10, 20, 30.\n", " \n", " Различие кортежей и списков в том, что списки можно изменять, например, добавлять в них новые элементы. Про изменяемые и неизменяемые типы будем говорить отдельно в следующий раз." ] }, { "cell_type": "code", "execution_count": 25, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "[10, 20, 30]\n", "(10, 20, 30)\n" ] } ], "source": [ "a = [10, 20, 30] # список\n", "b = 10, 20, 30 # кортеж\n", "\n", "print(a)\n", "print(b) # кортеж печатается с круглыми скобочками\n", "\n", "a = [] # пустой список\n", "b = () # пустой кортеж (обычно в нем нет смысла)\n", "a = [10] # список из одного элемента\n", "b = (10,) # кортеж из одного элемента. Здесь хитрый синтаксис - скобки и запятая\n", " # потому что 10 или (10) это просто число 10, а не кортеж." ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Списки, кортежи можно перечислять:" ] }, { "cell_type": "code", "execution_count": 26, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "10\n", "20\n", "30\n" ] } ], "source": [ "for x in [10, 20, 30]:\n", " print(x)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Очень часто можно увидеть код, в котором перечисляются элементы списка по индексу, это просто калька с Pascal или С, которая не имеет смысла:" ] }, { "cell_type": "code", "execution_count": 27, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "10\n", "20\n", "30\n" ] } ], "source": [ "a = [10, 20, 30]\n", "for i in range(3): # i от 0 до 2\n", " print(a[i]) # тоже см. дальше, это получение элемента по его номеру." ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Лучше писать предыдущим способом без индекса." ] }, { "cell_type": "code", "execution_count": 28, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "10\n", "20\n", "30\n" ] } ], "source": [ "for x in 10, 20, 30: # перечисляем кортеж\n", " print(x)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "При создании кортежа довольно часто ставят вокруг круглые скобки, потому что иначе Python не поймет, что имелось в виду. Примеры будут появляться дальше сами собой.\n", "\n", "## Действия с типами-последователностями:\n", "\n", "[Таблица действий](https://docs.python.org/3/library/stdtypes.html#sequence-types-list-tuple-range)" ] }, { "cell_type": "code", "execution_count": 2, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "True\n", "True\n", "True\n", "True\n", "[20, 30, 40, 40, 50, 60]\n", "(20, 30, 40, 40, 50, 60)\n", "3\n" ] } ], "source": [ "print(10 in [10, 20, 30])\n", "print(10 in (10, 20, 30)) # нужны скобки для кортежа, иначе другой смысл\n", "print('a' in 'qwr;oiasdsdg')\n", "print('as' in 'qwr;oiasdsdg') # можно проверять подстроки\n", "\n", "print([20, 30, 40] + [40, 50, 60])\n", "print((20, 30, 40) + (40, 50, 60))\n", "\n", "print(len([10, 20, 30])) # длина 3" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "**Слайсы**\n", "Очень мощная возможность python" ] }, { "cell_type": "code", "execution_count": 42, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "40\n", "[30, 40]\n", "[30, 40, 50, 60]\n", "[10, 20, 30, 40]\n", "[10, 30, 50]\n" ] } ], "source": [ "a = [10, 20, 30, 40, 50, 60]\n", "print(a[3]) # элемент с индексом 3, начиная с 0\n", "print(a[2:4]) # от 2 до 4 индекса, не включая последний\n", "print(a[2:]) # от 2 до конца\n", "print(a[:4]) # с начала до 4-го не включительно\n", "print(a[0:6:2]) # шаг 2\n", "print(a[::2]) # от начала до конца с шагом 2" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "И еще много других комбинаций с указанием или без указания начала или конца. Можно использовать отрицательный шаг, чтобы перечислять справа налево. **И можно использовать отрицательные индексы. Отрицательный индекс означает подсчет с конца, например, -1 означает последний элемент.**\n", "\n", "Слайсы работают со всеми типами последовательностями, со строками тоже. У нас будут задачи про строки и слайсы. Поэтому экспериментируйте." ] } ], "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.7.3" } }, "nbformat": 4, "nbformat_minor": 4 }