{ "cells": [ { "cell_type": "markdown", "metadata": {}, "source": [ "# Python для сбора данных\n", "\n", "*Алла Тамбовцева, НИУ ВШЭ*\n", "\n", "*Данный ноутбук основан на [лекции](http://python.math-hse.info:8080/github/ischurov/pythonhse/blob/master/Lecture%201.ipynb) Щурова И.В., [курс](http://math-info.hse.ru/s15/m) «Программирование на языке Python для сбора и анализа данных» (НИУ ВШЭ).*" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## Python как калькулятор. Переменные." ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### Python как калькулятор" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Привычные арифметические действия (сложение, вычитание, умножение, деление) в Python выглядят так же, как и в обычных калькуляторах:" ] }, { "cell_type": "code", "execution_count": 1, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "3" ] }, "execution_count": 1, "metadata": {}, "output_type": "execute_result" } ], "source": [ "1 + 2 # сложение" ] }, { "cell_type": "code", "execution_count": 2, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "14.2" ] }, "execution_count": 2, "metadata": {}, "output_type": "execute_result" } ], "source": [ "2 * 8 - 9 / 5 # умножение и деление" ] }, { "cell_type": "code", "execution_count": 3, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "11.5" ] }, "execution_count": 3, "metadata": {}, "output_type": "execute_result" } ], "source": [ "23 / 2 # деление" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Однако с делением все не так просто: Python 3 всегда будет выдавать результат в виде числа с плавающей точкой (*float*), даже тогда, когда ожидается целочисленный ответ. Например:" ] }, { "cell_type": "code", "execution_count": 4, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "3.0" ] }, "execution_count": 4, "metadata": {}, "output_type": "execute_result" } ], "source": [ "6 / 2 # не 3" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Получился дробный результат, где дробная часть равна 0. Как быть, если нужен ответ в виде целого числа? Можно воспользоваться целочисленным делением." ] }, { "cell_type": "code", "execution_count": 5, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "3" ] }, "execution_count": 5, "metadata": {}, "output_type": "execute_result" } ], "source": [ "6 // 2 # теперь 3" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Тут важно помнить, что при использовании оператора `//` дробная часть всегда будет просто отбрасываться – никакого округления происходить не будет." ] }, { "cell_type": "code", "execution_count": 6, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "4" ] }, "execution_count": 6, "metadata": {}, "output_type": "execute_result" } ], "source": [ "9 // 2 # от 4.5 осталось 1" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "В Python 2 обычное деление (с помощью `/`) было целочисленным. Для того чтобы получить привычные результаты деления, нужно было либо импортировать обычное деление из модуля `__future__`, который позволяет использовать функционал более новых версий Python (см. [здесь](http://rextester.com/VMMS70343)), либо использовать другие хитрости, например, делить число с плавающей точкой на целое (см. [здесь](http://rextester.com/YJZV11974)).\n", "\n", "*Примечание:* для того, чтобы сравнивать исполнение одного и того же кода в Python 3 и Python 2 совсем необязательно устанавливать обе версии на компьютер. Можно воспользоваться онлайн-компиляторами (например, http://rextester.com: выбирать Python или Python 3) и запускать код прямо в браузере. Речь идет, конечно, о небольших фрагментах кода. Полноценно работать в них, не устанавливая Python, будет неудобно. Но для нескольких строк для сравнения как раз. " ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "А остаток от деления можно находить так:" ] }, { "cell_type": "code", "execution_count": 7, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "1" ] }, "execution_count": 7, "metadata": {}, "output_type": "execute_result" } ], "source": [ "9 % 2" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Что ещё можно делать с числами? Возводить в степень и извлекать из них корень. При расчетах на калькуляторе и в R для возведения числа в степень мы обычно используем символ `^`. Попробуем! " ] }, { "cell_type": "code", "execution_count": 8, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "4" ] }, "execution_count": 8, "metadata": {}, "output_type": "execute_result" } ], "source": [ "6 ^ 2 # ой" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Получилось что-то неожиданное. В Python оператор `^` используется для побитного сложения по модулю два. Для возведения числа в степень потребуется `**` (кстати, в R тоже для возведения в степень можно использовать двойную звездочку): " ] }, { "cell_type": "code", "execution_count": 9, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "36" ] }, "execution_count": 9, "metadata": {}, "output_type": "execute_result" } ], "source": [ "6 ** 2 # как нужно" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Теперь попробуем извлечь квадратный корень из числа с помощью привычного `sqrt`." ] }, { "cell_type": "code", "execution_count": 10, "metadata": {}, "outputs": [ { "ename": "NameError", "evalue": "name 'sqrt' is not defined", "output_type": "error", "traceback": [ "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", "\u001b[0;31mNameError\u001b[0m Traceback (most recent call last)", "\u001b[0;32m\u001b[0m in \u001b[0;36m\u001b[0;34m()\u001b[0m\n\u001b[0;32m----> 1\u001b[0;31m \u001b[0msqrt\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;36m9\u001b[0m\u001b[0;34m)\u001b[0m \u001b[0;31m# не получается!\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m", "\u001b[0;31mNameError\u001b[0m: name 'sqrt' is not defined" ] } ], "source": [ "sqrt(9) # не получается!" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Python пишет, что не знает, что такое `sqrt`. В каких случаях Python может такое писать? Например, если мы опечатались в названии функции (Python не понимает, что мы от него хотим) или если мы пытаемся обратиться к функции, которая не является базовой (Python не знает, откуда её брать). В нашем случае мы столкнулись со второй проблемой. Функция для вычисления квадратного корня из числа хранится в специальном модуле `math`. Этот модуль стандартный, дополнительно устанавливать его не нужно. Но для того, чтобы воспользоваться этой функцией, нужно сначала импортировать модуль, а потом вызвать из него функцию `sqrt` (для тех, кто работал в R -- процедура, аналогичная `library()`." ] }, { "cell_type": "code", "execution_count": 11, "metadata": {}, "outputs": [], "source": [ "import math # импортируем модуль math" ] }, { "cell_type": "code", "execution_count": 12, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "3.0" ] }, "execution_count": 12, "metadata": {}, "output_type": "execute_result" } ], "source": [ "math.sqrt(9) # теперь все работает" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Если из `math` нам нужна только одна функция `sqrt`, можно извлечь только её, и тогда прописывать название модуля перед функцией не понадобится: " ] }, { "cell_type": "code", "execution_count": 13, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "4.0" ] }, "execution_count": 13, "metadata": {}, "output_type": "execute_result" } ], "source": [ "from math import sqrt\n", "sqrt(16) # так тоже работает" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "В `math` есть много полезных функций для вычислений. Чтобы посмотреть, какие функции там есть, после импортирования всего модуля через `import math` можно набрать `math.` и нажать на *Tab* (табуляция, кнопка над *Caps Lock*). Помимо квадратного корня этот модуль поможет вычислить логарифм (натуральный и не только), синус, косинус и так далее." ] }, { "cell_type": "code", "execution_count": 14, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "0.6931471805599453" ] }, "execution_count": 14, "metadata": {}, "output_type": "execute_result" } ], "source": [ "math.log(2) # натуральный логарифм" ] }, { "cell_type": "code", "execution_count": 15, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "2.0" ] }, "execution_count": 15, "metadata": {}, "output_type": "execute_result" } ], "source": [ "math.log10(100) # десятичный логарифм (логарифм по основанию 10)" ] }, { "cell_type": "code", "execution_count": 16, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "0.0" ] }, "execution_count": 16, "metadata": {}, "output_type": "execute_result" } ], "source": [ "math.sin(0) # синус" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "А еще из `math` можно импортировать константы $\\pi$ и $e$:" ] }, { "cell_type": "code", "execution_count": 17, "metadata": {}, "outputs": [], "source": [ "from math import pi, exp # можно сразу несколько - перечислить через запятую" ] }, { "cell_type": "code", "execution_count": 18, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "3.141592653589793" ] }, "execution_count": 18, "metadata": {}, "output_type": "execute_result" } ], "source": [ "pi" ] }, { "cell_type": "code", "execution_count": 19, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "2.718281828459045" ] }, "execution_count": 19, "metadata": {}, "output_type": "execute_result" } ], "source": [ "exp(1)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Если мы хотим извлечь все функции из модуля/библиотеки сразу, чтобы не прописывать название, можно сделать это так:" ] }, { "cell_type": "code", "execution_count": 20, "metadata": {}, "outputs": [], "source": [ "from math import *" ] }, { "cell_type": "code", "execution_count": 21, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "4\n", "5\n", "24\n" ] } ], "source": [ "# теперь можем использовать все функции этого модуля\n", "\n", "print(floor(4.6)) # округление в меньшую сторону\n", "print(ceil(4.3)) # округление в меньшую сторону\n", "print(factorial(4)) # факториал" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "И, наконец, можно импортировать модуль/библиотеку с сокращённым названием. В случае с `math` это не очень рационально, но просто для для примера (пригодиться в дальнейшем, когда будем разбирать библиотеки `numpy`, `scipy` и `pandas`." ] }, { "cell_type": "code", "execution_count": 22, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "-0.9111302618846769" ] }, "execution_count": 22, "metadata": {}, "output_type": "execute_result" } ], "source": [ "import math as ma\n", "ma.cos(9)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "С чем ещё можно столкнуться, выполняя вычисления в Python? С такими вещами:" ] }, { "cell_type": "code", "execution_count": 23, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "4.1513310942010236e-32" ] }, "execution_count": 23, "metadata": {}, "output_type": "execute_result" } ], "source": [ "1 / 18 ** 25" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Результат выше – компьютерная форма экспоненциальной записи числа. Возможно, тот, кто считал что-то на научных или инженерных калькуляторах или в R, уже сталкивался с такой записью. Здесь `e-32` – это $10^{-32}$, а вся запись означает $4.1513310942010236 \\cdot 10^{-32}$, то есть примерно $4.15 \\cdot 10^{-32}$. Если бы число было очень большим, `e` стояло бы в положительной степени. \n", "\n", "Такая компьютерная форма записи числа отчасти помогает понять, почему дробные числа называются числами с плавающей точкой (*float*). Возьмем число попроще, например, $12.34$. Его можно записать как $12.34$, как $1.234 \\cdot 10$, как $123.4 \\cdot 10^{-1}$, $1234 \\cdot 10^{-2}$ и так далее. Точка, отделяющая дробную часть от целой, будет «плавать», однако само число при этом меняться не будет, будут меняться только множители ‒ разные степени десятки." ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "С числами с плавающей точкой связана еще одна сложность — округление. На первый взгляд, всё хорошо:" ] }, { "cell_type": "code", "execution_count": 24, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "13" ] }, "execution_count": 24, "metadata": {}, "output_type": "execute_result" } ], "source": [ "round(12.6) # округлим до целого" ] }, { "cell_type": "code", "execution_count": 25, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "12.5" ] }, "execution_count": 25, "metadata": {}, "output_type": "execute_result" } ], "source": [ "round(12.53, 1) # округлим до первого знака после запятой" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "С другой стороны, могут возникнуть странности: " ] }, { "cell_type": "code", "execution_count": 26, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "2" ] }, "execution_count": 26, "metadata": {}, "output_type": "execute_result" } ], "source": [ "round(2.50) # не 3" ] }, { "cell_type": "code", "execution_count": 27, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "3.52" ] }, "execution_count": 27, "metadata": {}, "output_type": "execute_result" } ], "source": [ "round(3.525, 2) # не 3.53" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Эти странности связаны с тем, что число, которое мы видим (например, 3.525), не совпадает с тем, которое хранится в компьютере, потому что оно при сохранении преобразовывается и превращается из точного 3.525 в такое:" ] }, { "cell_type": "code", "execution_count": 28, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "Decimal('3.524999999999999911182158029987476766109466552734375')" ] }, "execution_count": 28, "metadata": {}, "output_type": "execute_result" } ], "source": [ "from decimal import Decimal\n", "Decimal(3.525)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "И такое число будет законно округляться до 3.52 по правилам арифметического округления. Не то чтобы это очень важная информация, которую нужно всегда иметь в виду, но знать про неё полезно, чтобы не удивляться неожиданным результатам и помнить про накапливание ошибки в операциях с числами с плавающей точкой." ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### Переменные" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Переменные в программировании похожи на переменные в математике. Кроме того, их можно рассматривать как хранилища значений – «контейнеры», в которые мы что-то кладём. Python, в отличие от некоторых языков программирования (C, C++, Java), сам распознает что мы «кладём в коробку»: число, целое число, текст, список чисел... Поэтому при создании переменной нам не нужно указывать её тип." ] }, { "cell_type": "code", "execution_count": 29, "metadata": {}, "outputs": [], "source": [ "x = 2\n", "y = 3" ] }, { "cell_type": "code", "execution_count": 30, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "2\n", "3\n" ] } ], "source": [ "print(x)\n", "print(y)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Значения переменных мы можем обновлять – изменять значение и сохранять в переменную с тем же названием. " ] }, { "cell_type": "code", "execution_count": 31, "metadata": {}, "outputs": [], "source": [ "x = x + 1 # возьмем значение x, увеличим на 1 и сохраним изменения в переменной x" ] }, { "cell_type": "code", "execution_count": 32, "metadata": {}, "outputs": [], "source": [ "y = y * 2 # возьмем значение y, увеличим в 2 раза и сохраним изменения" ] }, { "cell_type": "code", "execution_count": 33, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "3 6\n" ] } ], "source": [ "print(x, y)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Рассмотрим такую задачу. Пришла весна и решили мы заняться бегом по такой схеме: каждый день мы пробегаем столько, сколько в сумме за два предыдущих дня. При этом первые два дня мы морально готовимся: топчемся на месте и символически проходим по одному метру (полшага назад и полшага вперед). Если мы будем записывать все пройденные нами расстояния в ряд, мы получим последовательность из [чисел Фибоначчи](https://ru.wikipedia.org/wiki/%D0%A7%D0%B8%D1%81%D0%BB%D0%B0_%D0%A4%D0%B8%D0%B1%D0%BE%D0%BD%D0%B0%D1%87%D1%87%D0%B8). Давайте напишем код, который будет считать, сколько метров мы будем проходить/пробегать в следующий день." ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Сначала создадим переменные, в которые сохраним данные по первым двум дням." ] }, { "cell_type": "code", "execution_count": 34, "metadata": {}, "outputs": [], "source": [ "b = 1 # день 1 - готовимся бегать, \"бежим\" 1 метр \n", "i = 1 # номер дня, когда начинаем бегать\n", "bnext = 1 # день 2 - готовимся бегать, \"бежим\" 1 метр\n", "i = i + 1 # перешли ко второму дню, увеличили i на 1" ] }, { "cell_type": "code", "execution_count": 35, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "3 2\n" ] } ], "source": [ "res = b + bnext # в следующий день пробегаем столько же, сколько за два предыдущих\n", "i = i + 1 # перешли к следующему дню, увеличили i на 1\n", "b = bnext # значение b нам уже не нужно, сдвигаемся к следующему дню - записываем bnext\n", "bnext = res # запомнили полученное значение res\n", "print(i, bnext) # выводим на экран номер дня и расстояние, которое нужно пробежать" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Теперь можно прогонять предыдущую ячейку много раз (через *Ctrl + Enter*) и получать результат по каждому дню. Например, на 20 день мы будем пробегать уже нормальное расстояние — 6765 метров, почти 7 километров. Конечно, прогонять одну и ту ячейку много раз неудобно и странно, но о том, как считать числа Фибоначчи более рационально, мы поговорим, когда будем разбирать циклы.\n", "\n", "**Важно:** если бы не разбили наш код на части (на две ячейки), ничего бы при повторном запуске ячейки не произошло — переменным `b`, `bnext` и `i` заново присваивались бы значения 1, и движения вперед бы не происходило." ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Для тех, кто любит более лаконичный код: увеличение значения переменной на 1 можно было осуществить по-другому." ] }, { "cell_type": "code", "execution_count": 36, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "2" ] }, "execution_count": 36, "metadata": {}, "output_type": "execute_result" } ], "source": [ "i = 1\n", "i += 1 # плюс и равно, не наоборот\n", "i" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Точно так же можно использовать другие операторы (сложение, умножение, деление):" ] }, { "cell_type": "code", "execution_count": 37, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "6" ] }, "execution_count": 37, "metadata": {}, "output_type": "execute_result" } ], "source": [ "j = 7\n", "j -= 1 # минус и равно\n", "j" ] }, { "cell_type": "code", "execution_count": 38, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "24" ] }, "execution_count": 38, "metadata": {}, "output_type": "execute_result" } ], "source": [ "k = 8\n", "k *= 3 # умножить и равно\n", "k" ] } ], "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.6.5" } }, "nbformat": 4, "nbformat_minor": 2 }