Урок 5. Списки.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[1, 2, 3, 4, 5]"
      ]
     },
     "execution_count": 6,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "[1, 2, 3, 4, 5] #в списках могут храниться числа"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "list"
      ]
     },
     "execution_count": 7,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "type([1, 2, 3, 4, 5]) #проверяем тип данных"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "list"
      ]
     },
     "execution_count": 9,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "type(['line1', 'line2']) #в списках могут храниться строчки"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[1, 1.4, 'line', [1, 2, 3]]"
      ]
     },
     "execution_count": 10,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "[1, 1.4, 'line', [1, 2, 3]] #в списках могут храниться и сразу несколько разных типов данных"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 77,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[]"
      ]
     },
     "execution_count": 77,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "my_list = list() #так можно создать пустой список\n",
    "my_list"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 78,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[]"
      ]
     },
     "execution_count": 78,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "my_list = [] #и так тоже можно создать пустой список\n",
    "my_list"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<class 'int'> 1\n",
      "<class 'float'> 1.4\n",
      "<class 'str'> line\n",
      "<class 'list'> [1, 2, 3]\n",
      "<class 'float'> 1.4\n"
     ]
    }
   ],
   "source": [
    "my_list = [1, 1.4, 'line', [1, 2, 3], 1.4]\n",
    "#давайте с помощью цикла проверим тип каждого элемента\n",
    "for el in my_list:\n",
    "    print(type(el), el)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "4"
      ]
     },
     "execution_count": 16,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "len(my_list) #так можно проверять длину списка, то есть количество элементов в нем"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'line'"
      ]
     },
     "execution_count": 17,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "my_list[2] #по индексу можно обращаться к элементам списка"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1"
      ]
     },
     "execution_count": 20,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "my_list.index(1.4) \n",
    "#так можно узнать, какой индекс у элемента. \n",
    "#вернется только индекс самого первого такого элемента\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [],
   "source": [
    "my_list.append('one_more_line')\n",
    "#так можно добавлять элементы в конец списка"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[1, 1.4, 'line', [1, 2, 3], 1.4, 'one_more_line']"
      ]
     },
     "execution_count": 22,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "my_list"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [],
   "source": [
    "my_list.insert(1, 100)\n",
    "# так можно добавлять элемент на конкретное место в списке.\n",
    "# то есть сначала указываем место - это идекс, а потом сам элемент"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[1, 100, 1.4, 'line', [1, 2, 3], 1.4, 'one_more_line']"
      ]
     },
     "execution_count": 29,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "my_list"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {},
   "outputs": [],
   "source": [
    "my_list.remove(100)\n",
    "# так можно удалить элементы из списка\n",
    "# удалится только первый такой элемент в списке"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[1, 1.4, 'line', [1, 2, 3], 1.4, 'one_more_line']"
      ]
     },
     "execution_count": 31,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "my_list"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 81,
   "metadata": {},
   "outputs": [],
   "source": [
    "number_list = [3, 49, 1, 16]\n",
    "sorted_list = sorted(number_list) # так можно сортировать список\n",
    "# но результат сортировки нужно сохранять в какую-то переменную\n",
    "# потому что sorted() не изменяет исходный список"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 80,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[1, 3, 16, 49]"
      ]
     },
     "execution_count": 80,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "sorted_list"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 82,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[3, 49, 1, 16]"
      ]
     },
     "execution_count": 82,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "number_list"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[1, 3, 16, 49]"
      ]
     },
     "execution_count": 36,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "sorted_list"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['а', 'в', 'щ']"
      ]
     },
     "execution_count": 37,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "str_list = ['а', \"щ\", \"в\"] #сортировать можно не только числа в списках, но и строки\n",
    "sorted(str_list)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Попробуем написать небольшую программу. \n",
    "Она будет 5 раз просить пользователя ввести число и каждое из этих чисел добавлять в список. А потом распечатает нам список из этих 5 чисел. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 83,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Введите число: 2\n",
      "Введите число: 4\n",
      "Введите число: 6\n",
      "Введите число: 8\n",
      "Введите число: 10\n",
      "[2, 4, 6, 8, 10]\n"
     ]
    }
   ],
   "source": [
    "my_list = []\n",
    "\n",
    "for num in range(5):\n",
    "    x = int(input('Введите число: '))\n",
    "    my_list.append(x)\n",
    "    \n",
    "print(my_list)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Теперь программа должна просить пользователя 5 раз ввести четное число, проверять, действительно ли оно четное. Если да, то добавлять в список, если нет, то выводить пользователю на экране *введенное пользователем число* не делится на 2 без остатка."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Введите четное число: 3\n",
      "3 не делится на 2 без остатка.\n",
      "Введите четное число: 2\n",
      "Введите четное число: 4\n",
      "Введите четное число: 5\n",
      "5 не делится на 2 без остатка.\n",
      "Введите четное число: 1\n",
      "1 не делится на 2 без остатка.\n",
      "[2, 4]\n"
     ]
    }
   ],
   "source": [
    "my_list = []\n",
    "\n",
    "for num in range(5):\n",
    "    x = int(input('Введите четное число: '))\n",
    "    if x%2 == 0:   \n",
    "        my_list.append(x)\n",
    "    else:\n",
    "        print(f\"{x} не делится на 2 без остатка.\")\n",
    "print(my_list)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "У нас есть вот такой список — my_list = ['2%', \"45 %\", '6%', “11”, ‘15 %’] . Давайте очистим каждый элемент от лишнего знака %.\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 48,
   "metadata": {},
   "outputs": [],
   "source": [
    "my_list = ['2 %', \"45%\", '6%']\n",
    "clean_list = []\n",
    "for el in my_list:\n",
    "    clean_el = int(el.replace('%',''))\n",
    "    clean_list.append(clean_el)\n",
    "    "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 49,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[2, 45, 6]"
      ]
     },
     "execution_count": 49,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "clean_list"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 87,
   "metadata": {},
   "outputs": [],
   "source": [
    "#допустим у нас есть данные о количестве преступников в каких-то населенных пунктах\n",
    "crimes = [30000, 10000, 200]\n",
    "# И мы хотим узнать, в каком из этих населенных пунктах самая криминогенная обстановка. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 88,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "30000"
      ]
     },
     "execution_count": 88,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "max(crimes) \n",
    "#функция max вернет нам само большое число из списка. а функция min — самое маленькое"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Технически это будет правильный ответ. Но не все так просто. Показатели типа количества преступников, детей сирот, людей с алкогольной зависимость и так далее обязательно нужно нормировать на количество всех людей проживающих в этом населенном пункте. Иначе всегда бы оказывалось, что Москва самый опасный город в России просто потому, что в Москве живет больше всего людей. Поэтому нам пригодится еще одна строчка в таблице"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "population = [100000, 50000, 1000] #вот такой"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# поэтому будет нормировать вот по этой формуле\n",
    "количество преступлений/население * 1000"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 61,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[300.0, 200.0, 200.0]\n"
     ]
    }
   ],
   "source": [
    "norm_crimes = []\n",
    "for i in range(len(crimes)):\n",
    "    norm_crimes.append(crimes[i]/population[i]*1000)\n",
    "print(norm_crimes)    "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 89,
   "metadata": {},
   "outputs": [],
   "source": [
    "# если мы объединим все три списка в один, то по сути получим обычную таблицу.\n",
    "\n",
    "city_names = ['city1', 'city2', 'city3']\n",
    "crimes = [30000, 10000, 200]\n",
    "population = [100000, 50000, 1000]\n",
    "norm_crimes = [300.0, 200.0, 200.0]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 90,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[['city1', 'city2', 'city3'],\n",
       " [30000, 10000, 200],\n",
       " [100000, 50000, 1000],\n",
       " [300.0, 200.0, 200.0]]"
      ]
     },
     "execution_count": 90,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "[city_names, crimes, population, norm_crimes]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Можем еще добить нашу табличку, посчитав сумму всех преступников, сумму населения для всех населенных пунктов и общий нормированный показатель для всех населенных пунктов. Чтобы узнать сумму всех чисел в списке, нам не нужно ходить циклом по списку и прибавлять один элемент за другим. Можно использовать sum()."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 84,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "120600"
      ]
     },
     "execution_count": 84,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "total_crimes = sum(crimes) # sum() вернет сумму всех чисел в списке\n",
    "total_crimes"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 68,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "151000"
      ]
     },
     "execution_count": 68,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "total_population = sum(population)\n",
    "total_population"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 85,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "798.6754966887418"
      ]
     },
     "execution_count": 85,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "total_norm = total_crimes/total_population * 1000\n",
    "total_norm"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 75,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[30000, 10000, 200, 40200, 40200]"
      ]
     },
     "execution_count": 75,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "crimes.append(total_crimes)\n",
    "crimes"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 74,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[100000, 50000, 1000, 151000]"
      ]
     },
     "execution_count": 74,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "population.append(total_population)\n",
    "population"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 76,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[300.0, 200.0, 200.0, 266.2251655629139]"
      ]
     },
     "execution_count": 76,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "norm_crimes.append(total_norm)\n",
    "norm_crimes"
   ]
  },
  {
   "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.8.3"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}