18fall/programming_basics/advanced-seq-types.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Более глубокое изучение типов последовательностей\n",
    "## Преоразование типов-последовательностей\n",
    "У каждого типа есть конструкторы типа: `list`, `str`, `tuple`, `range`. Их можно использовать, чтобы создавать значения соответствующих типов:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1) 123\n",
      "2) 5.6\n",
      "3) [10, 20, 30]\n"
     ]
    }
   ],
   "source": [
    "print(\"1) \" + str(123)) # создать строку из любого другого значения\n",
    "print(\"2) \" + str(5.6))\n",
    "print(\"3) \" + str([10, 20, 30])) # str создает строку"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "`str` превращает любой python объект в читаемый текст. Обычно этот текст используется для отладки. Замечание. Есть еще один метод, похожий на `str`, это `repr`, он тоже превращает любой pyhton объект в текст, но, в отличие от `str` пытается выдать максимальное количество информации о содержимом объекта."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[10, 20, 30]\n",
      "[10, 20, 30]\n",
      "range(0, 10)\n",
      "range(0, 10)\n"
     ]
    }
   ],
   "source": [
    "l = [10, 20, 30]\n",
    "print(str(l))\n",
    "print(repr(l))\n",
    "r = range(10)\n",
    "print(str(r))\n",
    "print(repr(r))\n",
    "# подождем, пока изучим более сложные типы, в которых эти методы дадут разный результат"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Метод `list` превращает любое перечисление в список:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1, 2]\n",
      "['a', 'b', 'c']\n",
      "[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]\n",
      "[10, 20, 30]\n"
     ]
    }
   ],
   "source": [
    "print(list((1, 2))) # был tuple 1, 2\n",
    "print(list(\"abc\"))\n",
    "print(list(range(10)))\n",
    "print(list([10, 20, 30])) # это можно использовать как копирование списка, см. далее"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(10, 20, 30)\n",
      "('a', 'b', 'c')\n"
     ]
    }
   ],
   "source": [
    "print(tuple([10, 20, 30])) # превратили список в tuple\n",
    "print(tuple(\"abc\")) # превратили текст в tuple"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Перебор элементов последовательности\n",
    "Оператор цикла `for` позволяет перебирать все значения последовательности. Синтаксис\n",
    "```\n",
    "for {переменная} in {последовательность}:\n",
    "    # отступ 4 пробела для тела цикла\n",
    "    # действия c переменной\n",
    "```\n",
    "Переменной последовательно присваивается каждое из значений последовательности. Для каждого значения переменной вызывается тело цикла:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "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": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "h\n",
      "e\n",
      "l\n",
      "l\n",
      "o\n"
     ]
    }
   ],
   "source": [
    "for x in \"hello\":\n",
    "    print(x) # x присваивается очередной символ строки"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "one\n",
      "two\n",
      "three\n"
     ]
    }
   ],
   "source": [
    "for t in \"one\", \"two\", \"three\": # tuple из трех элементов\n",
    "    print(t)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0\n",
      "1\n",
      "2\n",
      "3\n",
      "4\n",
      "5\n"
     ]
    }
   ],
   "source": [
    "for i in range(6): # range очень часто используется именно в циклах\n",
    "    print(i)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Изредка, при переборе списка нужно все-таки знать индексы элементов, тогда можно, например, использовать range:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Элемент с индексом 0 это 10\n",
      "Элемент с индексом 1 это 20\n",
      "Элемент с индексом 2 это 30\n",
      "Элемент с индексом 3 это 40\n"
     ]
    }
   ],
   "source": [
    "l = [10, 20, 30, 40]\n",
    "for i in range(len(l)): # от 0 до длины списка - 1\n",
    "    print(f\"Элемент с индексом {i} это {l[i]}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Но настояший \"питоновый\" способ перебора элементов перечисления с индексом такой:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Элемент с индексом 0 это 10\n",
      "Элемент с индексом 1 это 20\n",
      "Элемент с индексом 2 это 30\n",
      "Элемент с индексом 3 это 40\n"
     ]
    }
   ],
   "source": [
    "for i, x in enumerate(l):\n",
    "    print(f\"Элемент с индексом {i} это {x}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Функция `enumerate` получает перечисление и вовращает новое перечисление, которое состоит из tuple, где первый элемент - это индекс, а второй - элемент исходного перечислания:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[(0, 10), (1, 20), (2, 30)]"
      ]
     },
     "execution_count": 41,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "list(enumerate([10, 20, 30])) # демонстрируем"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "В `enumerate` можно передать дополнительный аргумент, с какого индекса начинать:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Элемент с индексом 3 это 10\n",
      "Элемент с индексом 4 это 20\n",
      "Элемент с индексом 5 это 30\n"
     ]
    }
   ],
   "source": [
    "for i, x in enumerate(l, 3):\n",
    "    print(f\"Элемент с индексом {i} это {x}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Как перебрать список с конца в начало? Даже для этого можно обойтись без индексов"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "40\n",
      "30\n",
      "20\n",
      "10\n"
     ]
    }
   ],
   "source": [
    "for x in l[::-1]:\n",
    "    print(x)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Изменяемые, неизменяемые объекты, ссылки"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[11, 20, 30]\n",
      "[10, 20, 30]\n",
      "[11, 20, 30]\n",
      "[10, 20, 30]\n",
      "[10, 20, 30]\n"
     ]
    }
   ],
   "source": [
    "list1 = [10, 20, 30]\n",
    "list2 = [10, 20, 30]\n",
    "list3 = list1\n",
    "list4 = list(list1) # \"копирование\" списка\n",
    "list5 = list1[:] # все элементы с начала до конца, т.е. мы опять \"копируем\" список\n",
    "\n",
    "list1[0] = 11  # заменим 10 на 11\n",
    "for l in list1, list2, list3, list4, list5:\n",
    "    print(l)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Оказалось, что в `list3` тоже изменилось первое значение!!\n",
    "\n",
    "![Копирование списков](copy-lists.svg)\n",
    "\n",
    "Квадратные скобки при описании списка создают новый список. Присваивание - это копирование ссылки. Т.е. `list3` это переменная, которая ссылается на тот же самый список, что и `list1`. Поэтмоу измнения в этом списке \"видны\" и через `list1`, и через `list2`.\n",
    "\n",
    "`list4` - был создан операцией `list`, она скопировала значения из `list1`. Ну а `list5` получен оператором `[:]` (slice), этот оператор создает новый список, копируя значения из указанного диапазона.\n",
    "\n",
    "Другие примеры, когда нужно быть аккуратным:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 50,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[10, 20, 30, 42]\n",
      "['abc', 'xyz', 42]\n",
      "global t\n"
     ]
    }
   ],
   "source": [
    "def f(l):\n",
    "    l.append(42)\n",
    "    l = [100, 200, 300, 400]\n",
    "    t = 'local t'\n",
    "    \n",
    "t = 'global t'\n",
    "l = [10, 20, 30]\n",
    "m = [\"abc\", \"xyz\"]\n",
    "f(l)\n",
    "print(l)\n",
    "f(m)\n",
    "print(m)\n",
    "print(t)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "![Списки как аргументы функции](list-in-functions.svg)\n",
    "\n",
    "В этом примере оказывается, что после вызова функции `f` в переданный список добавляется 42, а присваивание списка `[100, 200, 300, 400]` как будто не имеет эффекта.\n",
    "\n",
    "Чтобы разобраться, нужно понять, что в этой программе есть две совершенно разных переменных `l`. Одна переменная глобальная, она определена вне функции. А другая переменная `l` - определена внутри функции. Она определена как ее параметр. Назовем ее локальной `l`.\n",
    "\n",
    "При вызове `f(m)` локальной переменной `l` присваивается список из глобальной переменной `m`. Операция `l.append` добавляет число 42 в этот список. А он доступен и через глобальную `m`, и через локальную `l`, поэтому после завершения функции мы видим, что список изменен.\n",
    "А вот операция `l = [100, 200, 300, 400]` создает новый список, присваивает его локальной переменной `l` и это никаким образом не влияет на старый список, который, как и раньше, остается доступен через глобальную `m`.\n",
    "\n",
    "Первый вызов `f(l)` ничем не отличается от вызова `f(m)` кроме того, что фактический аргумент функции (то, с чем ее вызвали) по названию совпадает с формальным аргументом (параметром `l`)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 54,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[], [], [], []]\n",
      "[[42], [42], [42], [42]]\n"
     ]
    }
   ],
   "source": [
    "rows = [[]] * 4 # \n",
    "print(rows)\n",
    "rows[0].append(42)\n",
    "print(rows)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Мы повторили один и тот же пустой список 4 раза. Поэтому в большом списке мы 4 раза ссылаемся на один и тот же пустой список. Т.е. `l[0]`, `l[1]`, `l[2]`, `l[3]` - это один и тот же список, поэтому он и изменяется \"одновременно\".\n",
    "\n",
    "### Сравнение `is` и `==`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "True\n",
      "True\n",
      "True\n",
      "False\n"
     ]
    }
   ],
   "source": [
    "a = [10, 20, 30]\n",
    "b = a\n",
    "c = [10, 20, 30]\n",
    "\n",
    "print(a == b) # == сравнивает содержимое объектов\n",
    "print(a == c)\n",
    "print(a is b) # is проверяет на одинаковость сами обеъкты\n",
    "print(a is c) # здесь будет False, это разные объекты.\n",
    "              # хотя содержимое одинаково"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Деструктуризация при присваивании\n",
    "Смотрим на примерах"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "10 20 30\n"
     ]
    }
   ],
   "source": [
    "a = [10, 20, 30]\n",
    "[x, y, z] = a\n",
    "print(x, y, z) # переменным присвоились элементы списка!"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Это работает, только если сходятся размеры списка и того, куда присваивается:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "ename": "ValueError",
     "evalue": "too many values to unpack (expected 2)",
     "output_type": "error",
     "traceback": [
      "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[1;31mValueError\u001b[0m                                Traceback (most recent call last)",
      "\u001b[1;32m<ipython-input-9-2641b95b3bb5>\u001b[0m in \u001b[0;36m<module>\u001b[1;34m()\u001b[0m\n\u001b[1;32m----> 1\u001b[1;33m \u001b[1;33m[\u001b[0m\u001b[0mx\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0my\u001b[0m\u001b[1;33m]\u001b[0m \u001b[1;33m=\u001b[0m \u001b[0ma\u001b[0m \u001b[1;31m# ошибка здесь\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m\u001b[0;32m      2\u001b[0m \u001b[1;33m[\u001b[0m\u001b[0mx\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0my\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mz\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mt\u001b[0m\u001b[1;33m]\u001b[0m \u001b[1;33m=\u001b[0m \u001b[0ma\u001b[0m \u001b[1;31m# и здесь\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n",
      "\u001b[1;31mValueError\u001b[0m: too many values to unpack (expected 2)"
     ]
    }
   ],
   "source": [
    "[x, y] = a # ошибка здесь\n",
    "[x, y, z, t] = a # и здесь"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Чаще это используют с tuple, например, потому что при задании tuple можно не ставить скобки"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "10 20\n"
     ]
    }
   ],
   "source": [
    "x, y = 10, 20\n",
    "print(x, y)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "справа создался tuple (10, 20), и он сразу же присвоился tuple из переменных x и y.\n",
    "\n",
    "Любимый пример программистами на Python для использования этой возможнсти:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "20 10\n"
     ]
    }
   ],
   "source": [
    "x, y = y, x\n",
    "print(x, y) # Значения поменялись местами"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Давайте вспомним, как рекомендовалось делать перебор элементов списка с индексами:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "10\n",
      "20\n",
      "30\n",
      "0 10\n",
      "1 20\n",
      "2 30\n"
     ]
    }
   ],
   "source": [
    "a = [10, 20, 30]\n",
    "for x in a:\n",
    "    print(x)\n",
    "\n",
    "for ind, x in enumerate(a):\n",
    "    print(ind, x)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Идея в том, что `enumerate` это последовательность из tuple `(0, 10)` `(1, 20)` `(2, 30)`. Когда срабатывает `ind, x = (0, 10)`, `ind` становится 0, `x` становится 10."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## List comprehension (списковое включение???)\n",
    "Лист комприхеншон.\n",
    "Это удобный способ создавать списки, обрабатывать последовательности."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[11, 21, 31]\n"
     ]
    }
   ],
   "source": [
    "l = [10, 20, 30]\n",
    "l2 = [x + 1 for x in l]\n",
    "print(l2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "В общем случае вы пишете `[` *выражение c переменной* `for` *переменная* `in` *последовательность* `]`. Переменной по очереди присваиваются все элементы последовательности, для каждого элемента последовательности вычисляется выражения, значения выражений собираются в новый список."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['',\n",
       " 'x',\n",
       " 'xx',\n",
       " 'xxx',\n",
       " 'xxxx',\n",
       " 'xxxxx',\n",
       " 'xxxxxx',\n",
       " 'xxxxxxx',\n",
       " 'xxxxxxxx',\n",
       " 'xxxxxxxxx']"
      ]
     },
     "execution_count": 24,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "['x' * i for i in range(10)]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['0', '1', '2', '3', '4', '5', '6', '7', '8', '9']"
      ]
     },
     "execution_count": 25,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "[str(i) for i in range(10)] # строки с числами от 0 до 9"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['(cat)', '(dog)', '(cow)']"
      ]
     },
     "execution_count": 28,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "['(' + s + ')' for s in (\"cat\", \"dog\", \"cow\")] # перебор tuple"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Есть другие возможности, можно добавлять условия, делать двойные переборы и все это совмещать"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[1, 2, 4, 5, 7, 8]"
      ]
     },
     "execution_count": 34,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#if показывает, какие элементы должны попасть в результат\n",
    "[x for x in range(10) if x % 3 != 0]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[0, 1, 2, 3]"
      ]
     },
     "execution_count": 33,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "[x // 3 for x in range(10) if x % 3 == 0]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[(0, 0),\n",
       " (0, 1),\n",
       " (0, 2),\n",
       " (0, 3),\n",
       " (1, 0),\n",
       " (1, 1),\n",
       " (1, 2),\n",
       " (1, 3),\n",
       " (2, 0),\n",
       " (2, 1),\n",
       " (2, 2),\n",
       " (2, 3),\n",
       " (3, 0),\n",
       " (3, 1),\n",
       " (3, 2),\n",
       " (3, 3)]"
      ]
     },
     "execution_count": 36,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# присваивает значение первой пеменной, перебирает вторую\n",
    "# потом присваивает новое значение первой переменной, снова перебирает вторую\n",
    "# и т.д.\n",
    "[(i, j) for i in range(4) for j in range(4)]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[10, 20, 30, 'a', 'b', 'c', True, False]"
      ]
     },
     "execution_count": 41,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "l = [[10, 20, 30], ['a', 'b', 'c'], [True, False]]\n",
    "[x for sublist in l for x in sublist] # получился \"плоский\" список"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Вложенные переборы, if можно чередовать, очень много возможностей по обработке списков одними только list comprehension."
   ]
  }
 ],
 "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
}