Lecture 2.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Программирование на языке Python для сбора и анализа данных\n",
    "\n",
    "*Текст лекции: Щуров И.В., НИУ ВШЭ*\n",
    "\n",
    "Данный notebook является конспектом лекции по курсу «Программирование на языке Python для сбора и анализа данных» (НИУ ВШЭ, 2015-16). Он распространяется на условиях лицензии [Creative Commons Attribution-Share Alike 4.0](http://creativecommons.org/licenses/by-sa/4.0/). При использовании обязательно упоминание автора курса и аффилиации. При наличии технической возможности необходимо также указать активную гиперссылку на [страницу курса](http://math-info.hse.ru/s15/m). Фрагменты кода, включенные в этот notebook, публикуются как [общественное достояние](http://creativecommons.org/publicdomain/zero/1.0/).\n",
    "\n",
    "Другие материалы курса, включая конспекты и видеозаписи лекций, а также наборы задач, можно найти на [странице курса](http://math-info.hse.ru/s15/m)."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Лекция 2. Списки и цикл for\n",
    "### Списки и операции с ними\n",
    "До сих пор мы работали с числовыми и строковыми переменными — в каждой переменной лежало одно число или одна строка. На практике нам зачастую приходится работать с большими массивами данных. Данные бывают разные и хранятся в разных *структурах*. Мы начнём с самой просторой структуры данных — со *списков*. Список — это такая структура данных, которая содержит в себе сразу много элементов."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "numbers = [4, 8, 9, 2, 6]\n",
    "# вот эта штука в квадратных скобках — это и есть список"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[4, 8, 9, 2, 6]"
      ]
     },
     "execution_count": 2,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "numbers"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "В списках можно хранить не только числа. Например, создадим список из строк."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "strings = [\"Hello\", \"World\", \"Test\"]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "В списке могут храниться данные разных типов. Например, строки, целые числа, числа с плавающей точкой."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "mixed_list = [\"Hello\", 6, 7.8]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Можно обращаться к отдельным элементам списка и работать с ними как с обычными переменными. Чтобы выбрать элемент нужно указать его номер."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[4, 8, 9, 2, 6]\n",
      "8\n"
     ]
    }
   ],
   "source": [
    "print(numbers)\n",
    "print(numbers[1])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Внимание!** **Нумерация начинается с нуля!** Это такая старая программистская традиция, чтобы запутать непосвященных. Привыкайте. \n",
    "> На самом деле, у этого правила есть свои [рациональные обоснования](http://python-history.blogspot.ru/2013/10/why-python-uses-0-based-indexing.html)."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Если в списке есть элементы разных типов, они никак не «мешают» друг другу. Например, наличие в списке строк не превращает другие элементы этого списка в строки.\n",
    "> Это касается только обычных списков Python. Несколько позже мы будем проходить массивы `numpy` и там всё не так."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['Hello', 6, 7.8]\n",
      "11.8\n"
     ]
    }
   ],
   "source": [
    "print(mixed_list)\n",
    "print(mixed_list[2]+4)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Элементы списка можно менять так же, как значения обычных переменных."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[4, 8, 9, 2, 6]"
      ]
     },
     "execution_count": 7,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "numbers"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[4, 222, 9, 2, 6]"
      ]
     },
     "execution_count": 8,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "numbers[1]=222\n",
    "numbers"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "> Если вы когда-нибудь изучали программирование и знаете, что такое «односвязный список» и «двусвязный список» — в этом месте можете про это временно забыть. Списки Python основаны на стандартных C'шных массивах и обладают их свойствами с точки зрения производительности: в частности, обращение к элементу по его индексу имеет сложность $O(1)$, то есть не является массовой операцией.\n",
    "\n",
    "Чтобы узнать длину списка, можно использовать функцю `len`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "5"
      ]
     },
     "execution_count": 9,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "len(numbers)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Заметим, что это не индекс последнего элемента, а именно число элементов. Если вам нужно получить последний элемент, то его индексом будет `len(numbers)-1`. Но в Python можно обращаться к элементам списка, считая их «с конца», гораздо проще:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "5"
      ]
     },
     "execution_count": 10,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "numbers = [4, 8, 2, 5]\n",
    "numbers[-1]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "2"
      ]
     },
     "execution_count": 11,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "numbers[-2]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "А вот если вы попытаетесь обратиться к элементу с несуществующим индексом, то получите ошибку."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "ename": "IndexError",
     "evalue": "list assignment 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-12-0a3abd230a25>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m()\u001b[0m\n\u001b[0;32m----> 1\u001b[0;31m \u001b[0mnumbers\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;36m5\u001b[0m\u001b[0;34m]\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;36m100\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[0;31mIndexError\u001b[0m: list assignment index out of range"
     ]
    }
   ],
   "source": [
    "numbers[5] = 100"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Однако дописывать элементы в конец можно:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[7, 6, 2]\n",
      "[7, 6, 2, 777]\n"
     ]
    }
   ],
   "source": [
    "numbers = [7, 6, 2]\n",
    "print(numbers)\n",
    "numbers.append(777)\n",
    "print(numbers)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Слово `append` — это так называемый «метод» — функция, «принадлежащая» некоторому объекту (в данном случае — объекту `numbers` типа `list` (список)), и что-то делающая с этим объектом. У `numbers`, как у любого списка, есть много методов. Можно набрать `numbers.`, нажать табуляцию (после точки), и получить список доступных методов. А ещё можно набрать `help(list)` или даже `help(numbers)` (в нашем случае) и получить краткое описание этих методов. Например, так можно узнать, что помимо `append` у списков есть метод `extend`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[7, 6, 2, 777]\n",
      "[7, 6, 2, 777, 3, 7, 5]\n"
     ]
    }
   ],
   "source": [
    "print(numbers)\n",
    "numbers.extend([3, 7, 5])\n",
    "print(numbers)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Метод `extend` позволяет приписать к списку сразу несколько элементов. Он получает на вход список, который нужно приписать: обратите внимание на квадратные скобки внутри круглых при вызове этого метода — они создают новый список, который и передаётся функции `extend`.\n",
    "\n",
    "> Приписывание одного списка к другому называется *конкатенацией*. Это умное слово, которое используют программисты, чтобы произвети впечатление на непосвящённых. Вы теперь тоже так умеете.\n",
    "\n",
    "Методы `append` и `extend` меняют список, к которому они применяются. Иногда вместо этого нужно создать новый список, объединив (конкатенировав!) два других. Это тоже можно сделать."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[5, 8, 2, 1, 9, 4]\n"
     ]
    }
   ],
   "source": [
    "first_list = [5, 8, 2]\n",
    "second_list = [1, 9, 4]\n",
    "new_list = first_list + second_list\n",
    "print(new_list)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Плюсик в данном случае обозначает не поэлементное сложение (как вы могли подумать), а конкатенацию. Cписки `first_list` и `second_list` при этом не изменились"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[5, 8, 2]\n",
      "[1, 9, 4]\n"
     ]
    }
   ],
   "source": [
    "print(first_list)\n",
    "print(second_list)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "У вас могло возникнуть желание использовать сложение вместо операции `extend`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[7, 6, 2, 777, 3, 7, 5]\n",
      "[7, 6, 2, 777, 3, 7, 5, 2, 6, 9]\n"
     ]
    }
   ],
   "source": [
    "print(numbers)\n",
    "# не надо так\n",
    "numbers = numbers + [2, 6, 9]\n",
    "print(numbers)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Вообще говоря, этот код сработал, но делать так не следует: при выполнении операции конкатенации создаётся новый список, затем в него копируются все элементы из `numbers`, потом к ним приписываются элементы из второго списка, после чего старый `numbers` забывается. Если бы в `numbers` было много элементов, их копирование в новый список заняло бы много времени. Гораздо быстрее приписать элементы к уже готовому списку.\n",
    "\n",
    "> Впрочем, операция `+=` для списков, по всей видимости, является эквивалентом для `extend` (хотя мне не удалось сходу найти подтверждение в документации)."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Срезы"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Иногда нам нужен не весь список, а его кусочек. Его можно получить, указав в квадратных скобках не одно число, а два, разделённых двоеточием."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[7, 6, 2, 777, 3, 7, 5, 2, 6, 9]\n",
      "[6, 2, 777]\n"
     ]
    }
   ],
   "source": [
    "print(numbers)\n",
    "print(numbers[1:4])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Это называется *slice* (по-русски часто говорят *срез*). Обратите внимание: левый конец среза включается (элемент с индексом 1 — это шестёрка), а правый — нет. Так будет всегда. Это соглашение оказывается удобным, например, потому что позволяет посчитать число элементов в срезе — нужно из правого конца вычесть левый (в данном случае 4-1=3).\n",
    "\n",
    "Если левый элемент не указан, то он считается началом списка, а если правый — то концом."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[2, 6, 9]\n",
      "[7, 6, 2, 777, 3, 7, 5]\n"
     ]
    }
   ],
   "source": [
    "print(numbers[7:])\n",
    "print(numbers[:7])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Всегда верно следующее: список `numbers` это то же самое, что `numbers[:k]+numbers[k:]`, где `k` — любой индекс."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Срезы можно использовать для присваивания."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[8, 9]\n",
      "[5, 55, 77, 10]\n"
     ]
    }
   ],
   "source": [
    "numbers = [5, 8, 9, 10]\n",
    "print(numbers[1:3])\n",
    "numbers[1:3]= [55, 77]\n",
    "print(numbers)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Не обязательно, чтобы список, который мы присваиваем срезу, имел ту же длину, что и срез. Можно присвоить более длинный список (тогда исходный список расширится), а можно менее длинный (тогда сузится). Можно использовать срезы, чтобы вставить несколько элементов внутрь списка. (Для одного элемента это можно делать с помощью метода `insert`.)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[]\n",
      "[6, 99, 77, 55, 8, 9]\n"
     ]
    }
   ],
   "source": [
    "numbers = [6, 8, 9]\n",
    "print(numbers[1:1])\n",
    "# это пустой срез\n",
    "\n",
    "numbers[1:1] = [99, 77, 55]\n",
    "print(numbers)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "> Чтобы вставить какие-то элементы внутрь списка, необходимо освободить для него место, сдвинув все последующие элементы вперёд. Python сделает это автоматически, но время это займёт. Поэтому, по возможности, следует этого избегать, особенно если вы работаете с большими массивами данных. Если вам очень нужно записывать что-нибудь в начало и конец списка, посмотрите на двустороннюю очередь (deque) из модуля `collections`."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Можно удалять элементы списка (и вообще что угодно) или срезы с помощью команды `del`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[6, 7, 9, 12, 3]\n",
      "[9, 12, 3]\n"
     ]
    }
   ],
   "source": [
    "numbers = [6, 7, 9, 12, 8, 3]\n",
    "del(numbers[4]) # удалим 8\n",
    "print(numbers)\n",
    "del(numbers[0:2])\n",
    "print(numbers)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Присвоение и копирование списков\n",
    "Списки могут быть коварными. Пока вы не разберётесь с содержанием этого раздела, ваши программы будут вести себя непредсказуемым образом и вы потратите много времени на их отладку. Так что сейчас самое время сосредоточиться."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "first_list = [5, 8, 9, 'Hello']\n",
    "second_list = first_list"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[5, 8, 9, 'Hello']"
      ]
     },
     "execution_count": 24,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "first_list"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[5, 8, 9, 'Hello']"
      ]
     },
     "execution_count": 25,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "second_list"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Так мы создали два одинаковым списка. Изменим теперь один из них:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[777, 8, 9, 'Hello']"
      ]
     },
     "execution_count": 26,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "second_list[0] = 777\n",
    "second_list"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Что вы ожидаете увидеть в `first_list`?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[777, 8, 9, 'Hello']"
      ]
     },
     "execution_count": 27,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "first_list"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Ой!** Когда мы изменили список `second_list`, магическим образом изменился и исходный список `first_list`! Почему так произошло? Дело в том, что списки живут в своём собственном мире платоновских идеальных списков. Когда мы присваиваем список переменной, то есть пишем что-нибудь вроде \n",
    "\n",
    "    first_list = [5, 8, 9, 'Hello']\n",
    "    \n",
    "мы делаем две вещи: во-первых, создаём список (с помощью операции «квадратные скобки»), а потом говорим, что теперь переменная `first_list` будет указывать на этот список (с помощью операции «равно»). Можно сказать, что мы создали список и дали ему *имя* `first_list`. \n",
    "\n",
    "> Отныне предлагаю читать знак «=» как «наречём».\n",
    "\n",
    "После этого в `first_list` хранится не сам список, а указатель (ссылка) на него. Когда мы присваиваем значение `first_list` новой переменной `second_list`, мы не производим копирование списка, мы копируем только указатель. То есть `second_list` просто стала другим именем для того же самого списка, что и `firt_list`. Поэтому изменение элементов `second_list` приведет к изменению `first_list`, и наоборот.\n",
    "\n",
    "Чтобы разобраться в происходящем более подробно, посмотрим, что происходит с нашим кодом строчка за строчкой. Для этого я буду использовать сервис [Python Tutor](http://pythontutor.com/), с помощью которого можно визуализировать выполнение кода. (Вы можете использовать этот сайт для отладки своих программ.)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "%load_ext tutormagic\n",
    "# Это магия, позволяющая вставить визуализацию с pythontutor прямо в этот notebook. \n",
    "# Чтобы его использовать, необходимо установить пакет tutormagic\n",
    "# pip install tutormagic"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/html": [
       "\n",
       "        <iframe\n",
       "            width=\"90%\"\n",
       "            height=\"350\"\n",
       "            src=\"http://pythontutor.com/iframe-embed.html#code=first_list%20%3D%20%5B5%2C%208%2C%209%2C%20%27Hello%27%5D%0Asecond_list%20%3D%20first_list%0Asecond_list%5B0%5D%20%3D%20777&origin=opt-frontend.js&cumulative=false&heapPrimitives=false&textReferences=false&py=3&rawInputLstJSON=%5B%5D&curInstr=0&codeDivWidth=50%25&codeDivHeight=100%25\"\n",
       "            frameborder=\"0\"\n",
       "            allowfullscreen\n",
       "        ></iframe>\n",
       "        "
      ],
      "text/plain": [
       "<IPython.lib.display.IFrame at 0x10f580a20>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "%%tutor --lang python3 # магия\n",
    "first_list = [5, 8, 9, 'Hello']\n",
    "second_list = first_list\n",
    "second_list[0] = 777"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "В левой части наш код, зелёная стрелка — это команда, которая только что была выполнена, красная — это команда, которую сейчас предстоит выполнить; в правой части — мир имён (Frames) и мир платоновских идеальных объектов (Objects). Возможно, вам придётся воспользоваться горизонатльной прокруткой, чтобы увидеть платоновский мир. Нажимая на кнопку Forward, вы можете проследить, что происходит с вашим кодом."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Если мы хотим создать действительно новый список, то есть *скопировать* существующий, нужно использовать метод `copy()`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[6, 9, 2, 5]\n",
      "[100, 9, 2, 5]\n",
      "[6, 9, 2, 5]\n"
     ]
    }
   ],
   "source": [
    "first_list = [6, 9, 2, 5]\n",
    "third_list = first_list.copy()\n",
    "print(third_list)\n",
    "third_list[0] = 100\n",
    "print(third_list)\n",
    "print(first_list)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Как видите, теперь `first_list` и `third_list` ведут себя независимо. Этот код тоже можно визуализировать."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/html": [
       "\n",
       "        <iframe\n",
       "            width=\"90%\"\n",
       "            height=\"350\"\n",
       "            src=\"http://pythontutor.com/iframe-embed.html#code=first_list%20%3D%20%5B6%2C%209%2C%202%2C%205%5D%0Athird_list%20%3D%20first_list.copy%28%29%0Aprint%28third_list%29%0Athird_list%5B0%5D%20%3D%20100%0Aprint%28third_list%29%0Aprint%28first_list%29&origin=opt-frontend.js&cumulative=false&heapPrimitives=false&textReferences=false&py=3&rawInputLstJSON=%5B%5D&curInstr=0&codeDivWidth=50%25&codeDivHeight=100%25\"\n",
       "            frameborder=\"0\"\n",
       "            allowfullscreen\n",
       "        ></iframe>\n",
       "        "
      ],
      "text/plain": [
       "<IPython.lib.display.IFrame at 0x10faaf5c0>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "%%tutor --lang python3\n",
    "first_list = [6, 9, 2, 5]\n",
    "third_list = first_list.copy()\n",
    "print(third_list)\n",
    "third_list[0] = 100\n",
    "print(third_list)\n",
    "print(first_list)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Вы также можете встретиться с таким синтаксисом для копирования списков:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "first_list = [6, 9, 2, 5]\n",
    "other_list = first_list[:]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Он тоже сработает (по крайней мере, для обычных списков). Здесь `[:]` — это не смайлик, а срез, начало которого совпадает с началом исходного списка, а конец — с концом. Такой код вы часто можете встретить в программах, написанных на Python 2, потому что там не было метода `copy()`."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Цикл for"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "До конца лекции остаётся совсем мало времени, а мне надо ещё рассказать про цикл `for`. Он нужен в той ситуации, когда вам требуется перебрать все элементы списка и что-нибудь с ними сделать. Рассмотрим простой пример: выведем все элементы списка, увеличив их на 1."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "5\n",
      "10\n",
      "2\n",
      "6\n",
      "Вот и всё\n",
      "[4, 9, 1, 5]\n"
     ]
    }
   ],
   "source": [
    "numbers = [4, 9, 1, 5]\n",
    "for x in numbers:\n",
    "    y = x + 1\n",
    "    print(y)\n",
    "print(\"Вот и всё\")\n",
    "print(numbers)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Здесь требуются пояснения. В первой строчке создаётся список `numbers`. Во второй используется ключевое слово `for`, которое переводится с английского *для*. Читать эту строчку нужно так: *«**для** каждого элемента `x` **из** списка `numbers` сделать то-то и то-то»*. В конце этой строчки обязательно нужно поставить двоеточие, а в следующей строке сделать отступ. (IPython Notebook сделает его сам.)\n",
    "\n",
    "> С отступами отдельная история. Как правило, нам нужно выполнить в цикле не одну команду, а несколько. Чтобы отметить, где начинается и, самое главное, где заканчивается набор команд, относящихся к циклу (или другой управляющей конструкции), в разных языках программирования используются разные маркеры: в Pascal это ключевые слова `begin` и `end`, в C-подобных языках это фигурные скоби. Наряду с этими маркерами, во всех языках программирования есть правило хорошего тона: начал блок команд — сделай отступ. Это нужно, чтобы сразу видеть, где блок заканчивается, и какие команды к каким блокам относятся. Однако, компиляторы ориентировались при разборе программы как раз на маркеры, а не на отступы, и в результате правило про отступы можно было смело игнорировать: копилятор всё равно поймёт. Другие разработчики, правда, не поймут, но… В общем, правило про отступы нередко нарушалось, особенно начинающими программистами. Автор Python решил, что в его языке это правило будут соблюдать *все*, и поэтому просто не оставил других способов выделить блок, кроме отступов.\n",
    "\n",
    "Итак, отступами выделено *тело цикла*, в него входят в данном случае две команды. Когда Python доходит до строчки `for`, он берёт первый элемент списка (в данном случае `numbers`), присваивает его соответствующей переменной (в данном случае `x`), после чего идёт выполнять строчки из тела цикла. Когда он дойдёт до конца тела цикла, он вернётся к его началу, возьмёт следующий элемент списка (если он есть), присвоит теперь его переменной `x` и снова выполнит тело цикла. Так будет продолжаться до тех пор, пока в списке есть элементы, которые мы не обработали — когда список кончится, цикл прекратится и будут выполнены строчки, которые идут после тела цикла (без отступа).\n",
    "\n",
    "Иными словами, код выше эквивалентен вот такому коду:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "5\n",
      "10\n",
      "2\n",
      "6\n",
      "Вот и всё\n",
      "[4, 9, 1, 5]\n"
     ]
    }
   ],
   "source": [
    "numbers = [4, 9, 1, 5]\n",
    "\n",
    "# делай раз\n",
    "x = numbers[0]\n",
    "y = x + 1\n",
    "print(y)\n",
    "\n",
    "# делай два\n",
    "x = numbers[1]\n",
    "y = x + 1\n",
    "print(y)\n",
    "\n",
    "# делай три\n",
    "x = numbers[2]\n",
    "y = x + 1\n",
    "print(y)\n",
    "\n",
    "# делай четыре\n",
    "x = numbers[3]\n",
    "y = x + 1\n",
    "print(y)\n",
    "\n",
    "# закончили упражнение\n",
    "\n",
    "print(\"Вот и всё\")\n",
    "print(numbers)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Можно воспользоваться Python Tutor и визуализировать этот процесс."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/html": [
       "\n",
       "        <iframe\n",
       "            width=\"90%\"\n",
       "            height=\"350\"\n",
       "            src=\"http://pythontutor.com/iframe-embed.html#code=numbers%20%3D%20%5B4%2C%209%2C%201%2C%205%5D%0Afor%20x%20in%20numbers%3A%0A%20%20%20%20y%20%3D%20x%20%2B%201%0A%20%20%20%20print%28y%29%0Aprint%28%22%D0%92%D0%BE%D1%82%20%D0%B8%20%D0%B2%D1%81%D1%91%22%29%0Aprint%28numbers%29&origin=opt-frontend.js&cumulative=false&heapPrimitives=false&textReferences=false&py=3&rawInputLstJSON=%5B%5D&curInstr=0&codeDivWidth=50%25&codeDivHeight=100%25\"\n",
       "            frameborder=\"0\"\n",
       "            allowfullscreen\n",
       "        ></iframe>\n",
       "        "
      ],
      "text/plain": [
       "<IPython.lib.display.IFrame at 0x10f580a20>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "%%tutor --lang python3\n",
    "numbers = [4, 9, 1, 5]\n",
    "for x in numbers:\n",
    "    y = x + 1\n",
    "    print(y)\n",
    "print(\"Вот и всё\")\n",
    "print(numbers)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Иногда у нас нет никакого конкретного списка, а просто нужно выполнить некоторый код несколько раз, причём заранее неизвестно, сколько. Для решения этой задачи служит объект `range()`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Hello, i = 0\n",
      "Hello, i = 1\n",
      "Hello, i = 2\n",
      "Hello, i = 3\n",
      "Hello, i = 4\n"
     ]
    }
   ],
   "source": [
    "for i in range(5):\n",
    "    print(\"Hello, i =\", i)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "`range(n)` ведёт себя как как список, содержащий целые числа от `0` до `n-1` (опять последний элемент не включается!). В нём ровно `n` элементов. Ещё можно использовать `range` в двумя аргументами: указать начало и конец интервала: `range(3,9)`. Можно даже превратить `range` в настоящий список с помощью команды `list`:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[0, 1, 2, 3, 4]"
      ]
     },
     "execution_count": 37,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "list(range(5))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[3, 4, 5, 6, 7, 8]"
      ]
     },
     "execution_count": 38,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "list(range(3,9))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": []
  }
 ],
 "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.5.0"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 0
}