{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Введение в Python, настройка среды программирования\n",
    "Шестаков А.В. Майнор по анализу данных - 12/01/2016 \n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Этот IPython Notebook содержит вспомогательные указания для выполнения семинарских и домашних заданий. В течение курса мы будем преимущественно работать в подобных \"тетрадках\", но может быть иногда будем переключаться на другие среды\\средства.\n",
    "\n",
    "(Мы используем Python версии 2.x.x, а не 3.x.x)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Как установить IPython Notebook у себя дома?!"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Самый простой и надежный способ - воспользоваться готовым дистрибутивом [Anaconda](https://store.continuum.io/cshop/anaconda/), включающий в себе практически все необходимые модули и утилиты, которые нам понадобятся - IPython, NumPy, SciPy, Matplotlib и **Scikit-Learn**. Просто следуйте указаниям установщика для вашей ОС."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Быстрое введение в Python"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Калькулятор"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "2*7"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "6+4**2-1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "4^4\n",
    "# О боже, госпади, что это было? "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Знак \"\\#\" символизирует начало комментариев в коде - всё что идет после этого знака до конца строки игнорируется Питоном.\n",
    "\n",
    "Поехали дальше - что у нас с делением?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "16/4"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "25/7\n",
    "# Угадайте, что получится?"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Для питона, в результате целочисленного деления должно тоже получится целое число. Т.е. остаток отбрасывается.\n",
    "Как же намекнуть питону, что мы хотим получить точный ответ?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "25./7\n",
    "25/7.\n",
    "float(25)/7"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Ну окей, пока всё это можно было посчитать в столбик. \n",
    "\n",
    "Есть что посерьезнее? КАААНЕЧНО!"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "sqrt(4)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "... Но не так сразу. Питон начал ругаться. По-умолчанию, он не знает, что такое извлечение квадратного корня. Однако можно показать ему, где искать.\n",
    "\n",
    "В стандартном модуле `math` есть такая функция. Давайте импортируем её в нашу программу"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "import math\n",
    "math.sqrt(4)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "А чтобы каждый раз не писать `math`. перед вызовом конкретных фукнций можно поступить так:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "from math import sin\n",
    "sin(3.14)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Ну хорошо, что мы всё приближенно, давайте точно посчитаем, чему равено $sin(\\pi)$. В модуле math можно найти это самое $\\pi$"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "from math import pi\n",
    "sin(pi)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Возникают вопросы: \n",
    "* ЭТО ВООБЩЕ ЧИСЛО? \n",
    "* почему так получилось?"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Переменные"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "В Python не надо как-то спецально объявлять переменную. Присвоил значение и поехали!"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "x = 4\n",
    "x"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "# Инкрементация\n",
    "x = x + 2\n",
    "x+=2 # тоже самое\n",
    "x"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "# Логические операции"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "x != 7"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "x > 7"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "x < 10"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Задание\n",
    "\n",
    "*Числа Фибоначчи* или *последовательность Фибоначчи* — последовательность чисел, начинающаяся с двух единиц, и такая, что очередное число в этой последовательности равно сумме двух предыдущих. Формально можно определить её следующим образом:\n",
    "\n",
    "$a_1=1$;\n",
    "\n",
    "$a_2=1$;\n",
    "\n",
    "$a_{n+1}=a_n+a_{n-1}$ для всех $n>2$.\n",
    "\n",
    "Например, $a_3=1+1=2$, $a_4=2+1=3$.\n",
    "\n",
    "**Задача:** посчитать 15-е число Фибоначчи"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "a = 1 # первое число\n",
    "b = 1 # второе число\n",
    "i = 2 # номер того числа, которое находится в переменной b (сейчас это a_2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "c = a + b #нашли следующее число\n",
    "i = i + 1 #увеличили i на 1\n",
    "a = b\n",
    "b = c\n",
    "# или можно сделать в одну строчку\n",
    "# a,b = b,c\n",
    "\n",
    "print i, b \n",
    "# команда print выводит на экран значение переменных \n",
    "# и всякие другие штуки"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Питон выполняет команды последовательно, строчку за строчкой, поэтому порядок следоавния команд очень важен. Выполняя эту ячейку несколько раз, вы будете получать каждый раз очередное число Фибоначчи."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Типы данных\n",
    "До сих пор мы имели дело только с числами, но уже поняли, что вещественные числа отличаются от целых. Вообще в Python есть много разных типов данных, предназначенных для хранения информации разной природы. Каждый тип данных имеет название в Python, например, целые числа — это `int`, вещественные (числа с плавающей запятой или правильнее сказать плавающей точкой) — `float`.\n",
    "\n",
    "#### Строки\n",
    "Строки выглядят так:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "print 'Hello, World!'"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Вот эта штука в кавычках — это и есть строка (тип данных `str`). Строки тоже можно сохранять в переменных и делать с ними разные операции (но совсем не такие, как с числами)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "type('Blah-Blah')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "a = \"Hello\"\n",
    "b = \"World\"\n",
    "print a + b"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "# Форматирование строк\n",
    "\n",
    "x = 123\n",
    "# Хочу:\n",
    "# x is equal to 123\n",
    "print 'x is equal to %i' % x"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Здесь символ процента означает, что нужно взять переменную, которая написана справа, и подставить в строчку, написанную слева, вместо символов `%i`. Буква `i` здесь означает `integer`, то есть что ожидается целое число."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "'ABC' == 'abc'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "'ABC' < 'DEF'"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Списки\n",
    "До сих пор мы работали с числовыми переменными — в каждой переменной лежало одно число. На практике нам зачастую приходится работать с большими массивами данных. Чтобы их хранить, нужно познакомиться со *списками*. Список — это такая переменная, которая содержит в себе сразу много элементов."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "x = [2, 5, 1, 2, 3, 2, 4, 6]\n",
    "# вот эта штука в квадратных скобках — это и есть список"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Можно обращаться к отдельным элементам списка и работать с ними как с обычными переменными. Чтобы выбрать элемент, нужно указать его номер.\n",
    "\n",
    "> **Нумерация начинается с нуля!** По старой программистская традиции, чтобы запутать непосвященных."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "x[0]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "x[1] = 10\n",
    "x"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Список можно расширять!"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "x.append(2)\n",
    "x"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "type(x)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Слово `append` — это метод класса `list`. У `x`, как у любого списка, есть много методов. Можно набрать `x.`, нажать табуляцию, и получить список доступных методов. Например:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "x.count(2) # считаем количество \"2\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "x.reverse()\n",
    "# пустые скобки означают, что мы вызываем функцию, \n",
    "# но параметров ей не передаем\n",
    "x"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "# Cписок можно попробовать отсортировать\n",
    "x.sort(reverse=True)\n",
    "print x"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Слайсы\n",
    "Иногда нам нужен не весь список, а его кусочек."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "print x\n",
    "print x[2:5]\n",
    "print x[2:]\n",
    "print x[:5]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Присвоение и копирование списков\n",
    "Списки могут быть коварными."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "y = x\n",
    "y[0] = 15\n",
    "# Что же лежит в первом элементе списка x?\n",
    "# 10 ил 15?\n",
    "x"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**ШТАА?!** Когда мы изменили список `y`, то изменился и список `x`! Почему так произошло? Дело в том, что списки живут в своём собственном мире платоновских идей. \n",
    "\n",
    "Когда мы присваиваем список переменной, то есть пишем что-нибудь вроде \n",
    "    x = [1, 2, 3]\n",
    "    \n",
    "мы говорим, что теперь переменная `x` будет указывать на этот список. Можно сказать, что мы создали список и дали ему *имя* `x`. После этого в `x` хранится не сам список, а указатель (ссылка) на него. Когда мы присваиваем значение `x` новой переменной `y`, мы не производим копирование списка, мы копируем только указатель. То есть `y` просто стала другим именем для того же самого списка, что и `y`. Поэтому изменение элементов `x` приведет к изменению `y`, и наоборот.\n",
    "\n",
    "Если мы хотим создать новый список, скопировав существующий, нужно использовать вот такой синтаксис:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "y = x[:]\n",
    "y[1] = 10\n",
    "print x\n",
    "print y"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Преобразование типов"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "a = 10.8\n",
    "b = int(a)\n",
    "print b"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "a = '213'\n",
    "x = a + a\n",
    "print int(x)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Картинки\n",
    "Немного картинок, чтобы было повеселее.\n",
    "Для рисования графиков в основном используют модуль matplotlib. Однако, он далеко не единственный, и кроме того, далеко не самый \"изящный\". Посмотрите, например, [seaborn](http://stanford.edu/~mwaskom/software/seaborn/)!"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "import matplotlib.pyplot as plt\n",
    "import numpy as np\n",
    "%matplotlib inline"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "plt.plot([1,2,3,4],[4,2,3,1])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "plt.bar([1,2,3,4,6],[1,2,3,4,10])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "x = np.arange(-10, 10, 0.5)\n",
    "y = x**2\n",
    "plt.plot(x, y)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "В \"сыром\" виде выглядит не так чтобы очень. Но всегда можно заморочиться. И себе приятно, и семенаристу (который будет смотреть твои домашнки)!"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "# Особый стриль графиков\n",
    "plt.style.use('ggplot')\n",
    "\n",
    "# Это надо, чтобы писать русскими буквами\n",
    "font = {'family': 'Verdana',\n",
    "        'weight': 'normal'}\n",
    "plt.rc('font', **font)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "x = np.arange(0, 6*np.pi, 0.3)\n",
    "y = np.sin(x)\n",
    "z = np.cos(x)\n",
    "\n",
    "plt.figure(figsize=(8, 6))\n",
    "plt.plot(x, y)\n",
    "plt.plot(x, z, 'b')\n",
    "plt.xlabel('x')\n",
    "plt.title(u'Тригонометрия!')\n",
    "plt.legend(['sin', 'cos'])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Веселье закончилось. Идем дальше.\n",
    "### Условные операторы"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Часто в программе возникают \"развилки\" - когда в зависимости от выполнения какого-то условия, программа должна пойти по тому или иному пути.\n",
    "\n",
    "В Python, как и во многих языках программирования, такие развилки задаются словом `if`:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "x = 3\n",
    "if x == 2:\n",
    "    print 'Okay'\n",
    "    print 'This is good number'\n",
    "else:\n",
    "    print 'Oh, noooo!'\n",
    "    if x > 2:\n",
    "        print 'x is greater than 2'\n",
    "    else:\n",
    "        print 'x is lesser than 2'"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Можно задавать несколько условий, объединяя их логическими операторами **И**,**ИЛИ** **НЕ**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "x = 1.5\n",
    "if x > 2 and x < 3:\n",
    "    print 'Okay'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "if x < 2 or x < 3:\n",
    "    print 'Okay'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "if 1 < x < 5:\n",
    "    print 'Ok'"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Цикл `for`"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Часто нужно сделать какое-то действие со всеми элементами списка. Для этого есть цикл `for`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "x = [1, 4, 9, 1]\n",
    "i = 1234\n",
    "for i in x:\n",
    "    print i\n",
    "    print \"One more\"\n",
    "#     print i + 1\n",
    "print \"And finally\"\n",
    "print i"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### `break` и `continue`\n",
    "Говоря о циклах, нужно упомянуть два специальных способа прекратить обработку очередного элемента. Ключевое слово `continue` означает, что нужно вернуться в начало цикла и взять следующй элемент."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "for i in xrange(1, 10):\n",
    "    if i**2>10:\n",
    "        print 'Next'\n",
    "        continue\n",
    "    else:\n",
    "        print i\n",
    "    print 'Ok'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "for i in xrange(1,10):\n",
    "    if i**2>50:\n",
    "        print \"Stop\"\n",
    "        break\n",
    "    else:\n",
    "        print i\n",
    "    print \"Okay\"\n",
    "print \"Stopped\""
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Цикл `while`\n",
    "Иногда нужно выполнять какие-то команды до тех пор, пока *что-то не произойдёт*. Например, мы выводим на экран числа Фибоначчи, но только те из них, которые меньше 1000. Это делается с помощью цикла `while`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "a = 1\n",
    "b = 1\n",
    "while b < 1000:\n",
    "    c = a + b\n",
    "    a = b\n",
    "    b = c\n",
    "    print a"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Если условие не выполняется до входа в цикл, то тело цикла не выполнится ни разу. Если вы хотите цикл с постусловием (то есть условием, проверяющимся в конце), то мне придётся вас расстроить: в Python его нет. Есть только вот такая конструкция, его заменяющая."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "x=10\n",
    "while True:\n",
    "    print \"Hello\"\n",
    "    x=x+2\n",
    "    if not (x<5):\n",
    "        break"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Простые задачки"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Задача 1.** Ввести числа `a`,  `d` и `N`. Найти сумму первых `N` членов арифметической прогрессии с первым членом `a` и разностью `d`, не пользуясь «школьной» формулой.\n",
    "\n",
    "**Задача 2.** Ввести число `N` с клавиатуры. Найти сумму первых `N` членов гармонического ряда.\n",
    "\n",
    "**Задача 3.** Ввести натуральное число `N` с клавиатуры. Проверить, является ли оно простым.\n",
    "\n",
    "**Задача 4.** Вывести `N` первых простых чисел.\n",
    "\n",
    "**Задача 5.** Даны три числа: `a`, `b`, `c`. Не пользуясь функциями `min`, `max` и какими-либо библиотечными функциями, вывести на экран максимальное из них."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Продолжаем любить Питон\n",
    "#### Пользовательские функции. Примочки функциональных языков"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "func = lambda x: x**2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "# Это тоже самое, что и сверху\n",
    "def func(x):\n",
    "    return x**2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "func(4)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "l = range(10)\n",
    "l2 = map(func, l)\n",
    "l2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "reduce(lambda x, y: x+y, l)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "filter(lambda x: x>=5, l)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "string = 'lala. alala, dada'\n",
    "no_punct = filter(lambda x: x not in ['.', ','], string)\n",
    "no_punct"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Работа с файлами"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "В общем случае, работа с файлами осуществляется через команду `open`. Давайте попробуем создать файл с каким-то текстом:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "fout = open('temp.txt', 'w')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "string = 'this is very interesting text\\n'\n",
    "fout.write(string)\n",
    "fout.close()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Попробуем записать несколько строк:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "string_arr = ['Indeed, this text is very interesting,\\n', \n",
    "              'You should read it again', \n",
    "              ' and again']\n",
    "with open('temp.txt', 'w') as fout:\n",
    "    fout.writelines(string_arr)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Теперь, загрузим содержание файла:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "with open('temp.txt', 'r') as fin:\n",
    "    data = fin.readlines()\n",
    "data = map(lambda (x): x.strip(), data)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Как правило, в зависимости от области применимости модуля Python, в нем есть свои функции загрузки из различных форматов файлов в нужный тип данных. В следующий раз мы поработаем с прекрасным модулем `Pandas`, созданный для работы с таблицами всевозможных сортов. А сейчас - посмотрим что есть в `NumPy`."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Загрузите [файл 1](https://www.dropbox.com/s/x3vkibryoaorspk/tutorial_dataset.csv?dl=0) и [файл 2](https://www.dropbox.com/s/80dei36s1gqhbu9/tutorial_dataset_2.csv?dl=0) в папку с тетрадкой. С помощью функции `loadtxt` в модуле *NumPy* загрузите табличные данные одного из файлов. Присвойте y = D[:,0] а X = D[:, 1:].\n",
    "\n",
    "Оцените коэффициенты линейной регрессии $\\hat{y} = X\\hat{\\beta}$, где\n",
    "\n",
    "$$ \\hat{\\beta} = (X^T X)^{-1} X^T y $$\n",
    "Остатки модели рассчитываются как\n",
    "$$ \\text{res} = y - \\hat{y} $$\n",
    "\n",
    "Итак, еще раз:\n",
    "\n",
    "    1. Загрузите данные\n",
    "    2. Обучите модель\n",
    "    3. Постройте два графика: \n",
    "        3.1. Выберите какой-нибудь признак (кроме x0) и на одном графике изобразите зависимость y~x и линию регрессии\n",
    "        3.2. Постройте график остатки~y"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "# Write your code here\n",
    "#\n",
    "#\n",
    "#\n",
    "\n",
    "# load data\n",
    "D = np.loadtxt('tutorial_dataset.csv', \n",
    "               skiprows=1, \n",
    "               delimiter=',')"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 2",
   "language": "python",
   "name": "python2"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 2
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython2",
   "version": "2.7.11"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 0
}