{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Списки"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "_Список_ — это набор элементов, следующих вопределенном порядке. Вы можетесоздать список для хранения букв алфавита, цифр от 0 до 9 или имен всех членоввашей семьи. Всписок можно поместить любую информацию, причем данныевсписке даже не обязаны быть как-то связаны друг сдругом. Так как список обыч-но содержит более одного элемента, рекомендуется присваивать спискам именавомножественном числе:letters,digits,namesит.д.\n",
    "В языке Python список обозначается квадратными скобками ([]), аотдельныеэлементы списка разделяются запятыми. Простой пример списка сназваниямимоделей велосипедов:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['trek', 'cannondale', 'redline', 'specialized']\n"
     ]
    }
   ],
   "source": [
    "bicycles = ['trek', 'cannondale', 'redline', 'specialized']\n",
    "print(bicycles)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Обращение к элементам списка"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Чтобы обратиться кэлементу в списке, укажите имя списка, за которым следует индекс элемента в квадратных скобках.Например, название первого велосипеда всписке _bicycles_ выводится следующим образом:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "trek\n"
     ]
    }
   ],
   "source": [
    "bicycles = ['trek', 'cannondale', 'redline', 'specialized']\n",
    "print(bicycles[0])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Trek\n"
     ]
    }
   ],
   "source": [
    "bicycles = ['trek', 'cannondale', 'redline', 'specialized']\n",
    "print(bicycles[0].title())"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Индексы начинаются с 0, а не с 1"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Индексы начинаются с 0, а не с 1. В следующем примере выводятся названия велосипедов синдексами 1 и 3:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "cannondale\n",
      "specialized\n"
     ]
    }
   ],
   "source": [
    "bicycles = ['trek', 'cannondale', 'redline', 'specialized']\n",
    "print(bicycles[1])\n",
    "print(bicycles[3])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "В Python также существует специальный синтаксис для обращения к последнему элементу списка. Если запросить элемент синдексом –1, Python всегда возвращает последний элемент всписке:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "specialized\n"
     ]
    }
   ],
   "source": [
    "bicycles = ['trek', 'cannondale', 'redline', 'specialized']\n",
    "print(bicycles[-1])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Использование отдельных элементов из списка"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Отдельные значения из списка используются так же, как илюбые другие переменные. Например, вы можете воспользоваться конкатенацией для построения сообщения, содержащего значение из списка."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "My first bicycle was a Trek.\n"
     ]
    }
   ],
   "source": [
    "bicycles = ['trek', 'cannondale', 'redline', 'specialized']\n",
    "message = \"My first bicycle was a \" + bicycles[0].title() + \".\"\n",
    "print(message)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Изменение, добавление и удаление элементов"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Обычно вы будете создавать _динамические_ списки; это означает, что во время выполнения программы в созданном вами списке будут добавляться и удаляться элементы. Например, вы можете создать игру, в которой игрок должен стрелять по кораблям космических захватчиков. Исходный набор кораблей сохраняется в списке; каждый раз, когда вы сбиваете корабль, он удаляется из списка. Каждый раз, когда на экране появляется новый враг, он включается всписок. Длина списка кораблей будет уменьшаться и увеличиваться по ходу игры."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Изменение элементов всписке"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Синтаксис изменения элемента напоминает синтаксис обращения к элементу списка. Чтобы изменить элемент, укажите имя списка ииндекс изменяемого элемента в квадратных скобках; далее задайте новое значение, которое должно быть присвоено элементу."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['honda', 'yamaha', 'suzuki']\n",
      "['ducati', 'yamaha', 'suzuki']\n"
     ]
    }
   ],
   "source": [
    "motorcycles = ['honda', 'yamaha', 'suzuki']\n",
    "print(motorcycles)\n",
    "motorcycles[0] = 'ducati'\n",
    "print(motorcycles)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Добавление элементов всписок"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Новые элементы могут добавляться всписки по разным причинам — например, для появления на экране новых космических кораблей, включения новых данных в визуализацию или добавления новых зарегистрированных пользователей на построенный вами сайт. Python предоставляет несколько способов добавления новых данных в существующие списки."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Присоединение элементов в конец списка"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Простейший способ добавления новых элементов в список — присоединение элемента вконец списка."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['honda', 'yamaha', 'suzuki']\n",
      "['honda', 'yamaha', 'suzuki', 'ducati']\n"
     ]
    }
   ],
   "source": [
    "motorcycles = ['honda', 'yamaha', 'suzuki']\n",
    "print(motorcycles)\n",
    "motorcycles.append('ducati')\n",
    "print(motorcycles)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Метод **append()** упрощает динамическое построение списков. Например, вы можете начать с пустого списка и добавлять в него элементы серией команд **append()**."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['honda', 'yamaha', 'suzuki']\n"
     ]
    }
   ],
   "source": [
    "motorcycles = []\n",
    "motorcycles.append('honda')\n",
    "motorcycles.append('yamaha')\n",
    "motorcycles.append('suzuki')\n",
    "print(motorcycles)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Вставка элементов в список"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Метод **insert()** позволяет добавить новый элемент в произвольную позицию списка. Для этого следует указать индекс и значение нового элемента."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['ducati', 'honda', 'yamaha', 'suzuki']\n"
     ]
    }
   ],
   "source": [
    "motorcycles = ['honda', 'yamaha', 'suzuki']\n",
    "motorcycles.insert(0, 'ducati')\n",
    "print(motorcycles)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Удаление элементов из списка"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Удаление элемента с использованием команды del"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Если вам известна позиция элемента, который должен быть удален из списка, воспользуйтесь командой **del**."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['honda', 'yamaha', 'suzuki']\n",
      "['yamaha', 'suzuki']\n"
     ]
    }
   ],
   "source": [
    "motorcycles = ['honda', 'yamaha', 'suzuki']\n",
    "print(motorcycles)\n",
    "del motorcycles[0]\n",
    "print(motorcycles)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Команда del позволяет удалить элемент из любой позиции списка, если вам известен его индекс. Например, вот как из списка удаляется второй элемент'yamaha':"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['honda', 'yamaha', 'suzuki']\n",
      "['honda', 'suzuki']\n"
     ]
    }
   ],
   "source": [
    "motorcycles = ['honda', 'yamaha', 'suzuki']\n",
    "print(motorcycles)\n",
    "del motorcycles[1]\n",
    "print(motorcycles)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Удаление элемента с использованием метода pop()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Иногда значение, удаляемое из списка, должно как-то использоваться. Допустим, вы хотите получить координаты *x* и *y* только что сбитого корабля пришельцев, что-бы изобразить взрыв в этой позиции. В веб-приложении пользователь, удаленныйиз списка активных участников, может быть добавлен в список неактивных и т.д. Метод __pop()__ удаляет последний элемент из списка, но позволяет работать с ним после удаления. Удалим мотоцикл из списка:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['honda', 'yamaha', 'suzuki']\n",
      "['honda', 'yamaha']\n",
      "suzuki\n"
     ]
    }
   ],
   "source": [
    "motorcycles = ['honda', 'yamaha', 'suzuki']\n",
    "print(motorcycles)\n",
    "popped_motorcycle = motorcycles.pop()\n",
    "print(motorcycles)\n",
    "print(popped_motorcycle)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Извлечение элементов из произвольной позиции списка"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Вызов **pop()** может использоваться для удаления элемента в произвольной позиции списка; для этого следует указать индекс удаляемого элемента в круглых скобках."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The first motorcycle I owned was a Honda.\n"
     ]
    }
   ],
   "source": [
    "motorcycles = ['honda', 'yamaha', 'suzuki']\n",
    "first_owned = motorcycles.pop(0)\n",
    "print('The first motorcycle I owned was a ' + first_owned.title() +'.')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Помните, что после каждого вызова **pop()** элемент, с которым вы работаете, уже не находится в списке. \n",
    "Если вы не уверены в том, какой из двух способов выбрать — команду **del** или метод **pop()** , — то простое правило поможет вам определиться. Если вы собираетесь просто удалить элемент из списка, никак не используя его, выбирайте команду del; если же вы намерены использовать элемент после удаления из списка, выбирайте метод pop()."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Удаление элементов по значению"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Иногда позиция удаляемого элемента неизвестна. Если вы знаете только значение элемента, используйте метод **remove()**."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['honda', 'yamaha', 'suzuki', 'ducati']\n",
      "['honda', 'yamaha', 'suzuki']\n"
     ]
    }
   ],
   "source": [
    "motorcycles = ['honda', 'yamaha', 'suzuki', 'ducati']\n",
    "print(motorcycles)\n",
    "motorcycles.remove('ducati')\n",
    "print(motorcycles)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Метод *remove()* также может использоваться для работы со значением, которое удаляется из списка. Следующая программа удаляет значение 'ducati' и выводит причину удаления:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['honda', 'yamaha', 'suzuki', 'ducati']\n",
      "['honda', 'yamaha', 'suzuki']\n",
      "\n",
      "A Ducati is too expensive for me.\n"
     ]
    }
   ],
   "source": [
    "motorcycles = ['honda', 'yamaha', 'suzuki', 'ducati']\n",
    "print(motorcycles)\n",
    "too_expensive = 'ducati'\n",
    "motorcycles.remove(too_expensive)\n",
    "print(motorcycles)\n",
    "print(\"\\nA \" + too_expensive.title() + \" is too expensive for me.\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**ПРИМЕЧАНИЕ**\n",
    "Метод remove() удаляет только первое вхождение заданного значения Если существует вероятность того, что значение встречается в списке более одного раза, используйте цикл для определения того, были ли удалены все вхождения данного значения. "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Упорядочение списка"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Нередко список создается в непредсказуемом порядке, потому что порядок получения данных от пользователя не всегда находится под вашим контролем. И хотя во многих случаях такое положение дел неизбежно, часто требуется вывести информацию в определенном порядке. Водних случаях требуется сохранить исходный порядок элементов в списке, в других исходный порядок должен быть изменен. Python предоставляет в распоряжение программиста несколько разных способов упорядочения списка в зависимости от ситуации."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Постоянная сортировка списка методом sort()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Метод **sort()** позволяет относительно легко отсортировать список. Предположим, имеется список машин, и вы хотите переупорядочить эти элементы по алфавиту.\n",
    "Чтобы упростить задачу, предположим, что все значения в списке состоят из символов нижнего регистра."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['audi', 'bmw', 'subaru', 'toyota']\n"
     ]
    }
   ],
   "source": [
    "cars = ['bmw', 'audi', 'toyota', 'subaru']\n",
    "cars.sort()\n",
    "print(cars)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Список также можно отсортировать в обратном алфавитном порядке; для этого методу *sort()* следует передать аргумент reverse=True. В следующем примере список сортируется в порядке, обратном алфавитному:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['toyota', 'subaru', 'bmw', 'audi']\n"
     ]
    }
   ],
   "source": [
    "cars = ['bmw', 'audi', 'toyota', 'subaru']\n",
    "cars.sort(reverse=True)\n",
    "print(cars)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Временная сортировка списка функцией sorted()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Чтобы сохранить исходный порядок элементов списка, но временно представить их в отсортированном порядке, можно воспользоваться функцией **sorted()**. Функция sorted()позволяет представить список в определенном порядке, но не изменяет фактического порядка элементов всписке."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Here is the original list:\n",
      "['toyota', 'subaru', 'bmw', 'audi']\n",
      "\n",
      "Here is the sorted list:\n",
      "['audi', 'bmw', 'subaru', 'toyota']\n",
      "\n",
      "Here is the original list again:\n",
      "['toyota', 'subaru', 'bmw', 'audi']\n"
     ]
    }
   ],
   "source": [
    "ars = ['bmw', 'audi', 'toyota', 'subaru']\n",
    "print(\"Here is the original list:\")\n",
    "print(cars)\n",
    "print(\"\\nHere is the sorted list:\")\n",
    "print(sorted(cars))\n",
    "print(\"\\nHere is the original list again:\")\n",
    "print(cars)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Вывод списка в обратном порядке"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Чтобы переставить элементы списка в обратном порядке, используйте метод reverse(). Скажем, если список машин первоначально хранился в хронологическом порядке даты приобретения, элементы можно легко переупорядочить в обратном хронологическом порядке:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['bmw', 'audi', 'toyota', 'subaru']\n",
      "['subaru', 'toyota', 'audi', 'bmw']\n"
     ]
    }
   ],
   "source": [
    "cars = ['bmw', 'audi', 'toyota', 'subaru']\n",
    "print(cars)\n",
    "cars.reverse()\n",
    "print(cars)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Определение длины списка"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Вы можете быстро определить длину списка с помощью функции **len()**. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "4"
      ]
     },
     "execution_count": 28,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "cars = ['bmw', 'audi', 'toyota', 'subaru']\n",
    "len(cars)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Ошибки индексирования при работе со списками"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Когда программист только начинает работать со списками, он часто допускает однухарактерную ошибку. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {},
   "outputs": [
    {
     "ename": "IndexError",
     "evalue": "list index out of range",
     "output_type": "error",
     "traceback": [
      "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[1;31mIndexError\u001b[0m                                Traceback (most recent call last)",
      "\u001b[1;32m<ipython-input-30-9811709cfb18>\u001b[0m in \u001b[0;36m<module>\u001b[1;34m()\u001b[0m\n\u001b[0;32m      1\u001b[0m \u001b[0mmotorcycles\u001b[0m \u001b[1;33m=\u001b[0m \u001b[1;33m[\u001b[0m\u001b[1;34m'honda'\u001b[0m\u001b[1;33m,\u001b[0m \u001b[1;34m'yamaha'\u001b[0m\u001b[1;33m,\u001b[0m \u001b[1;34m'suzuki'\u001b[0m\u001b[1;33m]\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m----> 2\u001b[1;33m \u001b[0mprint\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mmotorcycles\u001b[0m\u001b[1;33m[\u001b[0m\u001b[1;36m3\u001b[0m\u001b[1;33m]\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[1;31mIndexError\u001b[0m: list index out of range"
     ]
    }
   ],
   "source": [
    "motorcycles = ['honda', 'yamaha', 'suzuki']\n",
    "print(motorcycles[3])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Python пытается вернуть элемент синдексом 3. Однако при поиске по списку ни один элемент motorcycles не обладает индексом 3. Из-за смещения индексовна 1 эта ошибка весьма распространена. Люди думают, что третьим элементом является элемент с индексом 3, потому что они начинают отсчет с 1. Но для Python третьим является элемент синдексом 2, потому что индексирование начинается с 0."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "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.6.5"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}