├── README.md ├── Урок 3. Условия if, else, elif и логические операторы.ipynb ├── Урок 4. Циклы.ipynb ├── Урок 12. Рекурсия.ipynb ├── Урок 8. Функции.ipynb ├── Урок 9. Сортировка.ipynb ├── Python _ Урок 1.ipynb ├── Урок 6. Словари.ipynb ├── Урок 10. Генераторы списков.ipynb ├── Расчет расстояния между геокоординатами по прямой в Python (1).py ├── Урок 2. Строки.ipynb ├── Урок 7. Кортежи и множества.ipynb ├── Задачи для тренировок 2.ipynb ├── Урок 5. Списки.ipynb ├── Регулярные выражения. Python.ipynb └── Задачи для тренировок.ipynb /README.md: -------------------------------------------------------------------------------- 1 | Здесь будут хранится тетрадки Jupyter Notebook с уроков Мастерской «Важных историй» по программированию на Python. 2 | Видео-уроки на Youtube-канале: https://www.youtube.com/channel/UCVZy5a_8sMo4ncI6XBb5iMQ/featured 3 | Текстовые версии на сайте: https://istories.media/workshops/ 4 | -------------------------------------------------------------------------------- /Урок 3. Условия if, else, elif и логические операторы.ipynb: -------------------------------------------------------------------------------- 1 | { 2 | "cells": [ 3 | { 4 | "cell_type": "markdown", 5 | "metadata": {}, 6 | "source": [ 7 | "# Условия if, elif, else" 8 | ] 9 | }, 10 | { 11 | "cell_type": "markdown", 12 | "metadata": {}, 13 | "source": [ 14 | "Задачка по налогам\n", 15 | "\n", 16 | " ИП1: 15 %\n", 17 | " ИП2: 6 %\n", 18 | " СЗ: 6 %\n", 19 | " ФЛ: 13 %\n", 20 | "\n" 21 | ] 22 | }, 23 | { 24 | "cell_type": "code", 25 | "execution_count": 13, 26 | "metadata": {}, 27 | "outputs": [ 28 | { 29 | "name": "stdout", 30 | "output_type": "stream", 31 | "text": [ 32 | "Василий Теркин\n" 33 | ] 34 | } 35 | ], 36 | "source": [ 37 | "name = input()" 38 | ] 39 | }, 40 | { 41 | "cell_type": "code", 42 | "execution_count": 14, 43 | "metadata": {}, 44 | "outputs": [ 45 | { 46 | "data": { 47 | "text/plain": [ 48 | "'Василий Теркин'" 49 | ] 50 | }, 51 | "execution_count": 14, 52 | "metadata": {}, 53 | "output_type": "execute_result" 54 | } 55 | ], 56 | "source": [ 57 | "name" 58 | ] 59 | }, 60 | { 61 | "cell_type": "code", 62 | "execution_count": 35, 63 | "metadata": {}, 64 | "outputs": [ 65 | { 66 | "name": "stdout", 67 | "output_type": "stream", 68 | "text": [ 69 | "ФЛ\n" 70 | ] 71 | } 72 | ], 73 | "source": [ 74 | "business_type = input()" 75 | ] 76 | }, 77 | { 78 | "cell_type": "code", 79 | "execution_count": 43, 80 | "metadata": {}, 81 | "outputs": [ 82 | { 83 | "name": "stdout", 84 | "output_type": "stream", 85 | "text": [ 86 | "13000\n" 87 | ] 88 | } 89 | ], 90 | "source": [ 91 | "income =int(input())" 92 | ] 93 | }, 94 | { 95 | "cell_type": "code", 96 | "execution_count": 44, 97 | "metadata": {}, 98 | "outputs": [], 99 | "source": [ 100 | "zp_sechina = 600000000 // 12" 101 | ] 102 | }, 103 | { 104 | "cell_type": "code", 105 | "execution_count": 45, 106 | "metadata": {}, 107 | "outputs": [], 108 | "source": [ 109 | "minimum_income = 14000" 110 | ] 111 | }, 112 | { 113 | "cell_type": "code", 114 | "execution_count": 46, 115 | "metadata": {}, 116 | "outputs": [ 117 | { 118 | "name": "stdout", 119 | "output_type": "stream", 120 | "text": [ 121 | "Василий, вы заригистрированы как ФЛ ваш налог составит 1690 рублей, а чистый доход -- 11310 рублей.\n", 122 | "Василий, ваша зп меньше прожиточного минимума на 2690.0\n" 123 | ] 124 | } 125 | ], 126 | "source": [ 127 | "if business_type == 'ИП1':\n", 128 | " tax = income * 0.15\n", 129 | " net_income = income - tax \n", 130 | " print(f'{name}, ваш налог составит {int(tax)} рублей, а чистый доход -- {int(net_income)} рублей.')\n", 131 | "elif business_type == 'ИП2':\n", 132 | " tax = income * 0.06\n", 133 | " net_income = income - tax \n", 134 | " print(f'{name}, вы зарегистрированы как {business_type} ваш налог составит {int(tax)} рублей, а чистый доход -- {int(net_income)} рублей.')\n", 135 | "else:\n", 136 | " tax = income * 0.13\n", 137 | " net_income = income - tax \n", 138 | " print(f'{name.split()[0]}, вы зарегистрированы как {business_type} ваш налог составит {int(tax)} рублей, а чистый доход -- {int(net_income)} рублей.')\n", 139 | " if net_income >= zp_sechina:\n", 140 | " print(f'{name.split()[0]}, это, конечно, круто, но будьте осторожны: ваша зп {net_income} больше зп Сечина на {net_income - zp_sechina}')\n", 141 | " elif net_income <= minimum_income:\n", 142 | " print(f'{name.split()[0]}, ваша зп меньше прожиточного минимума на {minimum_income - net_income}')\n", 143 | " else:\n", 144 | " print(f'{name.split()[0]}, не парьтесь, ваша зп меньше зп Сечина на {zp_sechina - net_income}')\n", 145 | " \n", 146 | " \n", 147 | " \n", 148 | " " 149 | ] 150 | }, 151 | { 152 | "cell_type": "code", 153 | "execution_count": null, 154 | "metadata": {}, 155 | "outputs": [], 156 | "source": [] 157 | } 158 | ], 159 | "metadata": { 160 | "kernelspec": { 161 | "display_name": "Python 3", 162 | "language": "python", 163 | "name": "python3" 164 | }, 165 | "language_info": { 166 | "codemirror_mode": { 167 | "name": "ipython", 168 | "version": 3 169 | }, 170 | "file_extension": ".py", 171 | "mimetype": "text/x-python", 172 | "name": "python", 173 | "nbconvert_exporter": "python", 174 | "pygments_lexer": "ipython3", 175 | "version": "3.7.3" 176 | } 177 | }, 178 | "nbformat": 4, 179 | "nbformat_minor": 4 180 | } 181 | -------------------------------------------------------------------------------- /Урок 4. Циклы.ipynb: -------------------------------------------------------------------------------- 1 | { 2 | "cells": [ 3 | { 4 | "cell_type": "markdown", 5 | "metadata": {}, 6 | "source": [ 7 | "# Цикл while" 8 | ] 9 | }, 10 | { 11 | "cell_type": "markdown", 12 | "metadata": {}, 13 | "source": [ 14 | "Задачка найти и посчитать все гласные в строке" 15 | ] 16 | }, 17 | { 18 | "cell_type": "code", 19 | "execution_count": 8, 20 | "metadata": {}, 21 | "outputs": [], 22 | "source": [ 23 | "poem = \"\"\"Буря мглою небо кроет, Вихри снежные крутя; То, как зверь, она завоет, То заплачет, как дитя, То по кровле обветшалой Вдруг соломой зашумит, То, как путник запоздалый, К нам в окошко застучит.\"\"\"" 24 | ] 25 | }, 26 | { 27 | "cell_type": "code", 28 | "execution_count": 9, 29 | "metadata": {}, 30 | "outputs": [], 31 | "source": [ 32 | "# while условие:\n", 33 | " #тело цикла" 34 | ] 35 | }, 36 | { 37 | "cell_type": "code", 38 | "execution_count": 10, 39 | "metadata": {}, 40 | "outputs": [], 41 | "source": [ 42 | "index = 0" 43 | ] 44 | }, 45 | { 46 | "cell_type": "code", 47 | "execution_count": 11, 48 | "metadata": {}, 49 | "outputs": [], 50 | "source": [ 51 | "vowels = 'аоэеиыуёюя'" 52 | ] 53 | }, 54 | { 55 | "cell_type": "code", 56 | "execution_count": 12, 57 | "metadata": {}, 58 | "outputs": [], 59 | "source": [ 60 | "poem_vowels = ''" 61 | ] 62 | }, 63 | { 64 | "cell_type": "code", 65 | "execution_count": 13, 66 | "metadata": {}, 67 | "outputs": [], 68 | "source": [ 69 | "while index != len(poem):\n", 70 | " if poem[index] in vowels:\n", 71 | " poem_vowels += poem[index]\n", 72 | " index += 1" 73 | ] 74 | }, 75 | { 76 | "cell_type": "code", 77 | "execution_count": 14, 78 | "metadata": {}, 79 | "outputs": [ 80 | { 81 | "data": { 82 | "text/plain": [ 83 | "60" 84 | ] 85 | }, 86 | "execution_count": 14, 87 | "metadata": {}, 88 | "output_type": "execute_result" 89 | } 90 | ], 91 | "source": [ 92 | "len(poem_vowels)" 93 | ] 94 | }, 95 | { 96 | "cell_type": "markdown", 97 | "metadata": {}, 98 | "source": [ 99 | "# Цикл for" 100 | ] 101 | }, 102 | { 103 | "cell_type": "markdown", 104 | "metadata": {}, 105 | "source": [ 106 | "Задачка на сумму" 107 | ] 108 | }, 109 | { 110 | "cell_type": "code", 111 | "execution_count": 18, 112 | "metadata": {}, 113 | "outputs": [], 114 | "source": [ 115 | "male_list = [65, 60, 45, 55]\n", 116 | "female_list = [75, 34, 68, 90]" 117 | ] 118 | }, 119 | { 120 | "cell_type": "code", 121 | "execution_count": 19, 122 | "metadata": {}, 123 | "outputs": [ 124 | { 125 | "name": "stdout", 126 | "output_type": "stream", 127 | "text": [ 128 | "Возраст женщины больше возаста мужчины на 10 лет\n", 129 | "Возраст мужчины больше возаста женщины на 31 лет\n", 130 | "Возраст женщины больше возаста мужчины на 3 лет\n", 131 | "Возраст женщины больше возаста мужчины на 25 лет\n", 132 | "Возраст женщины больше возаста мужчины на 15 лет\n", 133 | "Возраст мужчины больше возаста женщины на 26 лет\n", 134 | "Возраст женщины больше возаста мужчины на 8 лет\n", 135 | "Возраст женщины больше возаста мужчины на 30 лет\n", 136 | "Возраст женщины больше возаста мужчины на 30 лет\n", 137 | "Возраст мужчины больше возаста женщины на 11 лет\n", 138 | "Возраст женщины больше возаста мужчины на 23 лет\n", 139 | "Возраст женщины больше возаста мужчины на 45 лет\n", 140 | "Возраст женщины больше возаста мужчины на 20 лет\n", 141 | "Возраст мужчины больше возаста женщины на 21 лет\n", 142 | "Возраст женщины больше возаста мужчины на 13 лет\n", 143 | "Возраст женщины больше возаста мужчины на 35 лет\n" 144 | ] 145 | } 146 | ], 147 | "source": [ 148 | "for male_age in male_list:\n", 149 | " for female_age in female_list:\n", 150 | " if male_age > female_age:\n", 151 | " print(f'Возраст мужчины больше возаста женщины на {male_age - female_age} лет')\n", 152 | " else:\n", 153 | " print(f'Возраст женщины больше возаста мужчины на {female_age - male_age} лет')\n", 154 | " " 155 | ] 156 | }, 157 | { 158 | "cell_type": "code", 159 | "execution_count": null, 160 | "metadata": {}, 161 | "outputs": [], 162 | "source": [] 163 | }, 164 | { 165 | "cell_type": "code", 166 | "execution_count": null, 167 | "metadata": {}, 168 | "outputs": [], 169 | "source": [] 170 | } 171 | ], 172 | "metadata": { 173 | "kernelspec": { 174 | "display_name": "Python 3", 175 | "language": "python", 176 | "name": "python3" 177 | }, 178 | "language_info": { 179 | "codemirror_mode": { 180 | "name": "ipython", 181 | "version": 3 182 | }, 183 | "file_extension": ".py", 184 | "mimetype": "text/x-python", 185 | "name": "python", 186 | "nbconvert_exporter": "python", 187 | "pygments_lexer": "ipython3", 188 | "version": "3.7.3" 189 | } 190 | }, 191 | "nbformat": 4, 192 | "nbformat_minor": 4 193 | } 194 | -------------------------------------------------------------------------------- /Урок 12. Рекурсия.ipynb: -------------------------------------------------------------------------------- 1 | { 2 | "cells": [ 3 | { 4 | "cell_type": "markdown", 5 | "metadata": {}, 6 | "source": [ 7 | "# Рекурсия " 8 | ] 9 | }, 10 | { 11 | "cell_type": "code", 12 | "execution_count": 148, 13 | "metadata": {}, 14 | "outputs": [], 15 | "source": [ 16 | "# Прием в программировании, когда функция вызывает саму себя" 17 | ] 18 | }, 19 | { 20 | "cell_type": "code", 21 | "execution_count": 5, 22 | "metadata": {}, 23 | "outputs": [], 24 | "source": [ 25 | "def find_even(num_list):\n", 26 | " even = [num for num in num_list if num % 2 == 0]\n", 27 | " return even\n", 28 | " " 29 | ] 30 | }, 31 | { 32 | "cell_type": "code", 33 | "execution_count": 6, 34 | "metadata": {}, 35 | "outputs": [], 36 | "source": [ 37 | "numbers = [1, 2, 3, 4, 5, 6, 7, 8, 10]" 38 | ] 39 | }, 40 | { 41 | "cell_type": "code", 42 | "execution_count": 7, 43 | "metadata": {}, 44 | "outputs": [ 45 | { 46 | "data": { 47 | "text/plain": [ 48 | "[2, 4, 6, 8, 10]" 49 | ] 50 | }, 51 | "execution_count": 7, 52 | "metadata": {}, 53 | "output_type": "execute_result" 54 | } 55 | ], 56 | "source": [ 57 | "find_even(numbers)" 58 | ] 59 | }, 60 | { 61 | "cell_type": "code", 62 | "execution_count": 20, 63 | "metadata": {}, 64 | "outputs": [], 65 | "source": [ 66 | "def recurs_find_even(num_list, result = []):\n", 67 | " if not num_list:\n", 68 | " return \n", 69 | " else:\n", 70 | " first_element = num_list[0]\n", 71 | " if first_element % 2 == 0:\n", 72 | " result.append(first_element)\n", 73 | " recurs_find_even(num_list[1:])\n", 74 | " print(result)\n", 75 | " return result" 76 | ] 77 | }, 78 | { 79 | "cell_type": "code", 80 | "execution_count": 21, 81 | "metadata": {}, 82 | "outputs": [ 83 | { 84 | "name": "stdout", 85 | "output_type": "stream", 86 | "text": [ 87 | "[2, 4, 6, 8, 10]\n", 88 | "[2, 4, 6, 8, 10]\n", 89 | "[2, 4, 6, 8, 10]\n", 90 | "[2, 4, 6, 8, 10]\n", 91 | "[2, 4, 6, 8, 10]\n", 92 | "[2, 4, 6, 8, 10]\n", 93 | "[2, 4, 6, 8, 10]\n", 94 | "[2, 4, 6, 8, 10]\n", 95 | "[2, 4, 6, 8, 10]\n" 96 | ] 97 | }, 98 | { 99 | "data": { 100 | "text/plain": [ 101 | "[2, 4, 6, 8, 10]" 102 | ] 103 | }, 104 | "execution_count": 21, 105 | "metadata": {}, 106 | "output_type": "execute_result" 107 | } 108 | ], 109 | "source": [ 110 | "recurs_find_even(numbers)" 111 | ] 112 | }, 113 | { 114 | "cell_type": "code", 115 | "execution_count": null, 116 | "metadata": {}, 117 | "outputs": [], 118 | "source": [] 119 | }, 120 | { 121 | "cell_type": "code", 122 | "execution_count": null, 123 | "metadata": {}, 124 | "outputs": [], 125 | "source": [] 126 | }, 127 | { 128 | "cell_type": "code", 129 | "execution_count": null, 130 | "metadata": {}, 131 | "outputs": [], 132 | "source": [] 133 | }, 134 | { 135 | "cell_type": "code", 136 | "execution_count": null, 137 | "metadata": {}, 138 | "outputs": [], 139 | "source": [] 140 | }, 141 | { 142 | "cell_type": "code", 143 | "execution_count": null, 144 | "metadata": {}, 145 | "outputs": [], 146 | "source": [] 147 | }, 148 | { 149 | "cell_type": "code", 150 | "execution_count": 187, 151 | "metadata": {}, 152 | "outputs": [], 153 | "source": [ 154 | "data = {\n", 155 | " 'url': 'https://clearspending.ru/contract/2772765679021000015/',\n", 156 | " 'contracts': {'number': 235678, 'date': '2020-01-31'},\n", 157 | " 'sum': {'total': 456000, 'currency': 'RUB'}\n", 158 | "}" 159 | ] 160 | }, 161 | { 162 | "cell_type": "code", 163 | "execution_count": 188, 164 | "metadata": {}, 165 | "outputs": [ 166 | { 167 | "name": "stdout", 168 | "output_type": "stream", 169 | "text": [ 170 | "2020-01-31\n" 171 | ] 172 | } 173 | ], 174 | "source": [ 175 | "date = data.get('contracts')\n", 176 | "if date is not None:\n", 177 | " print(date['date'])" 178 | ] 179 | }, 180 | { 181 | "cell_type": "code", 182 | "execution_count": 207, 183 | "metadata": {}, 184 | "outputs": [], 185 | "source": [ 186 | "def recurs_find_key(key, obj):\n", 187 | " if key in obj:\n", 188 | " return obj[key]\n", 189 | " for k, v in obj.items():\n", 190 | " if type(v) == dict:\n", 191 | " result = recurs_find_key(key, v)\n", 192 | " if result is not None:\n", 193 | " return result\n", 194 | " " 195 | ] 196 | }, 197 | { 198 | "cell_type": "code", 199 | "execution_count": 210, 200 | "metadata": {}, 201 | "outputs": [ 202 | { 203 | "data": { 204 | "text/plain": [ 205 | "'RUB'" 206 | ] 207 | }, 208 | "execution_count": 210, 209 | "metadata": {}, 210 | "output_type": "execute_result" 211 | } 212 | ], 213 | "source": [ 214 | "recurs_find_key('currency', data)" 215 | ] 216 | }, 217 | { 218 | "cell_type": "code", 219 | "execution_count": null, 220 | "metadata": {}, 221 | "outputs": [], 222 | "source": [] 223 | } 224 | ], 225 | "metadata": { 226 | "kernelspec": { 227 | "display_name": "Python 3", 228 | "language": "python", 229 | "name": "python3" 230 | }, 231 | "language_info": { 232 | "codemirror_mode": { 233 | "name": "ipython", 234 | "version": 3 235 | }, 236 | "file_extension": ".py", 237 | "mimetype": "text/x-python", 238 | "name": "python", 239 | "nbconvert_exporter": "python", 240 | "pygments_lexer": "ipython3", 241 | "version": "3.7.3" 242 | } 243 | }, 244 | "nbformat": 4, 245 | "nbformat_minor": 4 246 | } 247 | -------------------------------------------------------------------------------- /Урок 8. Функции.ipynb: -------------------------------------------------------------------------------- 1 | { 2 | "cells": [ 3 | { 4 | "cell_type": "code", 5 | "execution_count": 2, 6 | "metadata": {}, 7 | "outputs": [], 8 | "source": [ 9 | "my_list = [1, 2, 3]" 10 | ] 11 | }, 12 | { 13 | "cell_type": "code", 14 | "execution_count": 3, 15 | "metadata": {}, 16 | "outputs": [ 17 | { 18 | "data": { 19 | "text/plain": [ 20 | "6" 21 | ] 22 | }, 23 | "execution_count": 3, 24 | "metadata": {}, 25 | "output_type": "execute_result" 26 | } 27 | ], 28 | "source": [ 29 | "sum(my_list)" 30 | ] 31 | }, 32 | { 33 | "cell_type": "code", 34 | "execution_count": 5, 35 | "metadata": {}, 36 | "outputs": [ 37 | { 38 | "name": "stdout", 39 | "output_type": "stream", 40 | "text": [ 41 | "6\n" 42 | ] 43 | } 44 | ], 45 | "source": [ 46 | "summa = 0\n", 47 | "\n", 48 | "for num in my_list:\n", 49 | " summa+=num\n", 50 | " \n", 51 | "print(summa)" 52 | ] 53 | }, 54 | { 55 | "cell_type": "code", 56 | "execution_count": 10, 57 | "metadata": {}, 58 | "outputs": [], 59 | "source": [ 60 | "def our_sum(a_list):\n", 61 | " summa = 0\n", 62 | "\n", 63 | " for num in a_list:\n", 64 | " summa+=num\n", 65 | " return summa" 66 | ] 67 | }, 68 | { 69 | "cell_type": "code", 70 | "execution_count": 11, 71 | "metadata": {}, 72 | "outputs": [ 73 | { 74 | "data": { 75 | "text/plain": [ 76 | "14" 77 | ] 78 | }, 79 | "execution_count": 11, 80 | "metadata": {}, 81 | "output_type": "execute_result" 82 | } 83 | ], 84 | "source": [ 85 | "our_sum([2, 3, 4, 5])" 86 | ] 87 | }, 88 | { 89 | "cell_type": "code", 90 | "execution_count": null, 91 | "metadata": {}, 92 | "outputs": [], 93 | "source": [ 94 | "def function_name(аргумент или ничего):\n", 95 | " \n", 96 | " код функции\n", 97 | " \n", 98 | " return результат" 99 | ] 100 | }, 101 | { 102 | "cell_type": "code", 103 | "execution_count": 12, 104 | "metadata": {}, 105 | "outputs": [], 106 | "source": [ 107 | "def say_hi():\n", 108 | " print('Hi!')" 109 | ] 110 | }, 111 | { 112 | "cell_type": "code", 113 | "execution_count": 13, 114 | "metadata": {}, 115 | "outputs": [ 116 | { 117 | "name": "stdout", 118 | "output_type": "stream", 119 | "text": [ 120 | "Hi!\n" 121 | ] 122 | } 123 | ], 124 | "source": [ 125 | "say_hi()" 126 | ] 127 | }, 128 | { 129 | "cell_type": "code", 130 | "execution_count": 28, 131 | "metadata": {}, 132 | "outputs": [ 133 | { 134 | "name": "stdout", 135 | "output_type": "stream", 136 | "text": [ 137 | "Hi!\n", 138 | "None\n" 139 | ] 140 | } 141 | ], 142 | "source": [ 143 | "print(say_hi())" 144 | ] 145 | }, 146 | { 147 | "cell_type": "code", 148 | "execution_count": 18, 149 | "metadata": {}, 150 | "outputs": [], 151 | "source": [ 152 | "def get_name():\n", 153 | " name = input('Введите имя: ')\n", 154 | " return name" 155 | ] 156 | }, 157 | { 158 | "cell_type": "code", 159 | "execution_count": 19, 160 | "metadata": {}, 161 | "outputs": [ 162 | { 163 | "name": "stdout", 164 | "output_type": "stream", 165 | "text": [ 166 | "Введите имя: Алеся\n" 167 | ] 168 | }, 169 | { 170 | "data": { 171 | "text/plain": [ 172 | "'Алеся'" 173 | ] 174 | }, 175 | "execution_count": 19, 176 | "metadata": {}, 177 | "output_type": "execute_result" 178 | } 179 | ], 180 | "source": [ 181 | "get_name()" 182 | ] 183 | }, 184 | { 185 | "cell_type": "code", 186 | "execution_count": 20, 187 | "metadata": {}, 188 | "outputs": [], 189 | "source": [ 190 | "def say_hi_to(name):\n", 191 | " return f\"Привет, {name}!\"" 192 | ] 193 | }, 194 | { 195 | "cell_type": "code", 196 | "execution_count": 21, 197 | "metadata": {}, 198 | "outputs": [ 199 | { 200 | "name": "stdout", 201 | "output_type": "stream", 202 | "text": [ 203 | "Введите имя: Алеся\n" 204 | ] 205 | }, 206 | { 207 | "data": { 208 | "text/plain": [ 209 | "'Привет, Алеся!'" 210 | ] 211 | }, 212 | "execution_count": 21, 213 | "metadata": {}, 214 | "output_type": "execute_result" 215 | } 216 | ], 217 | "source": [ 218 | "say_hi_to(get_name())" 219 | ] 220 | }, 221 | { 222 | "cell_type": "code", 223 | "execution_count": 25, 224 | "metadata": {}, 225 | "outputs": [], 226 | "source": [ 227 | "def say_hi_to(name, small_talk = 'Как дела?'):\n", 228 | " return f\"Привет, {name}! {small_talk}\"" 229 | ] 230 | }, 231 | { 232 | "cell_type": "code", 233 | "execution_count": 26, 234 | "metadata": {}, 235 | "outputs": [ 236 | { 237 | "name": "stdout", 238 | "output_type": "stream", 239 | "text": [ 240 | "Введите имя: Алеся\n" 241 | ] 242 | }, 243 | { 244 | "data": { 245 | "text/plain": [ 246 | "'Привет, Алеся! Как дела?'" 247 | ] 248 | }, 249 | "execution_count": 26, 250 | "metadata": {}, 251 | "output_type": "execute_result" 252 | } 253 | ], 254 | "source": [ 255 | "say_hi_to(get_name())" 256 | ] 257 | }, 258 | { 259 | "cell_type": "code", 260 | "execution_count": 27, 261 | "metadata": {}, 262 | "outputs": [ 263 | { 264 | "name": "stdout", 265 | "output_type": "stream", 266 | "text": [ 267 | "Введите имя: Алеся\n" 268 | ] 269 | }, 270 | { 271 | "data": { 272 | "text/plain": [ 273 | "'Привет, Алеся! Че каво?'" 274 | ] 275 | }, 276 | "execution_count": 27, 277 | "metadata": {}, 278 | "output_type": "execute_result" 279 | } 280 | ], 281 | "source": [ 282 | "say_hi_to(get_name(), small_talk = 'Че каво?')" 283 | ] 284 | }, 285 | { 286 | "cell_type": "code", 287 | "execution_count": 33, 288 | "metadata": {}, 289 | "outputs": [], 290 | "source": [ 291 | "def clean_tel(tel_num):\n", 292 | " clean_tel = tel_num.replace(' ','').replace('-','').replace(')','').replace('(','')\n", 293 | " return clean_tel" 294 | ] 295 | }, 296 | { 297 | "cell_type": "code", 298 | "execution_count": 34, 299 | "metadata": {}, 300 | "outputs": [ 301 | { 302 | "data": { 303 | "text/plain": [ 304 | "'89876571211'" 305 | ] 306 | }, 307 | "execution_count": 34, 308 | "metadata": {}, 309 | "output_type": "execute_result" 310 | } 311 | ], 312 | "source": [ 313 | "clean_tel('8-(987)-657 12 11')" 314 | ] 315 | }, 316 | { 317 | "cell_type": "code", 318 | "execution_count": 35, 319 | "metadata": {}, 320 | "outputs": [], 321 | "source": [ 322 | "phone_book = {'Alice': '8-987-657 12 11', 'Bob':'89012345678', 'Jack':'8 (9 1 2) 3 4 5 6 7 8 9'}" 323 | ] 324 | }, 325 | { 326 | "cell_type": "code", 327 | "execution_count": 36, 328 | "metadata": {}, 329 | "outputs": [], 330 | "source": [ 331 | "def clean_book(book, data = []):\n", 332 | " for name, tel in book.items():\n", 333 | " data.append([name, clean_tel(tel)])\n", 334 | " return data \n", 335 | " " 336 | ] 337 | }, 338 | { 339 | "cell_type": "code", 340 | "execution_count": 37, 341 | "metadata": {}, 342 | "outputs": [ 343 | { 344 | "data": { 345 | "text/plain": [ 346 | "[['Alice', '89876571211'], ['Bob', '89012345678'], ['Jack', '89123456789']]" 347 | ] 348 | }, 349 | "execution_count": 37, 350 | "metadata": {}, 351 | "output_type": "execute_result" 352 | } 353 | ], 354 | "source": [ 355 | "clean_book(phone_book)" 356 | ] 357 | }, 358 | { 359 | "cell_type": "code", 360 | "execution_count": 38, 361 | "metadata": {}, 362 | "outputs": [], 363 | "source": [ 364 | "def sum_two(x, y):\n", 365 | " return x+y" 366 | ] 367 | }, 368 | { 369 | "cell_type": "code", 370 | "execution_count": 39, 371 | "metadata": {}, 372 | "outputs": [ 373 | { 374 | "data": { 375 | "text/plain": [ 376 | "3" 377 | ] 378 | }, 379 | "execution_count": 39, 380 | "metadata": {}, 381 | "output_type": "execute_result" 382 | } 383 | ], 384 | "source": [ 385 | "sum_two(1,2)" 386 | ] 387 | }, 388 | { 389 | "cell_type": "code", 390 | "execution_count": 40, 391 | "metadata": {}, 392 | "outputs": [], 393 | "source": [ 394 | "func = lambda x, y : x+y" 395 | ] 396 | }, 397 | { 398 | "cell_type": "code", 399 | "execution_count": 41, 400 | "metadata": {}, 401 | "outputs": [ 402 | { 403 | "data": { 404 | "text/plain": [ 405 | "3" 406 | ] 407 | }, 408 | "execution_count": 41, 409 | "metadata": {}, 410 | "output_type": "execute_result" 411 | } 412 | ], 413 | "source": [ 414 | "func(1, 2)" 415 | ] 416 | }, 417 | { 418 | "cell_type": "code", 419 | "execution_count": 42, 420 | "metadata": {}, 421 | "outputs": [ 422 | { 423 | "data": { 424 | "text/plain": [ 425 | "3" 426 | ] 427 | }, 428 | "execution_count": 42, 429 | "metadata": {}, 430 | "output_type": "execute_result" 431 | } 432 | ], 433 | "source": [ 434 | "(lambda x, y : x+y) (1,2)" 435 | ] 436 | }, 437 | { 438 | "cell_type": "code", 439 | "execution_count": 43, 440 | "metadata": {}, 441 | "outputs": [ 442 | { 443 | "data": { 444 | "text/plain": [ 445 | "'Привет, Алеся'" 446 | ] 447 | }, 448 | "execution_count": 43, 449 | "metadata": {}, 450 | "output_type": "execute_result" 451 | } 452 | ], 453 | "source": [ 454 | "say_hi = lambda name: f\"Привет, {name.title()}\"\n", 455 | "say_hi('алеся')" 456 | ] 457 | }, 458 | { 459 | "cell_type": "code", 460 | "execution_count": null, 461 | "metadata": {}, 462 | "outputs": [], 463 | "source": [] 464 | } 465 | ], 466 | "metadata": { 467 | "kernelspec": { 468 | "display_name": "Python 3", 469 | "language": "python", 470 | "name": "python3" 471 | }, 472 | "language_info": { 473 | "codemirror_mode": { 474 | "name": "ipython", 475 | "version": 3 476 | }, 477 | "file_extension": ".py", 478 | "mimetype": "text/x-python", 479 | "name": "python", 480 | "nbconvert_exporter": "python", 481 | "pygments_lexer": "ipython3", 482 | "version": "3.8.3" 483 | } 484 | }, 485 | "nbformat": 4, 486 | "nbformat_minor": 4 487 | } 488 | -------------------------------------------------------------------------------- /Урок 9. Сортировка.ipynb: -------------------------------------------------------------------------------- 1 | { 2 | "cells": [ 3 | { 4 | "cell_type": "code", 5 | "execution_count": 1, 6 | "metadata": {}, 7 | "outputs": [], 8 | "source": [ 9 | "my_list=[6,7,3,8,1]" 10 | ] 11 | }, 12 | { 13 | "cell_type": "code", 14 | "execution_count": 2, 15 | "metadata": {}, 16 | "outputs": [ 17 | { 18 | "name": "stdout", 19 | "output_type": "stream", 20 | "text": [ 21 | "[6, 7, 3, 8, 1]\n" 22 | ] 23 | } 24 | ], 25 | "source": [ 26 | "if my_list[0]>my_list[1]:\n", 27 | " my_list[0],my_list[1]=my_list[1],my_list[0]\n", 28 | "print(my_list)" 29 | ] 30 | }, 31 | { 32 | "cell_type": "code", 33 | "execution_count": 3, 34 | "metadata": {}, 35 | "outputs": [ 36 | { 37 | "name": "stdout", 38 | "output_type": "stream", 39 | "text": [ 40 | "[6, 3, 7, 8, 1]\n" 41 | ] 42 | } 43 | ], 44 | "source": [ 45 | "if my_list[1]>my_list[2]:\n", 46 | " my_list[1],my_list[2]=my_list[2],my_list[1]\n", 47 | "print(my_list)" 48 | ] 49 | }, 50 | { 51 | "cell_type": "code", 52 | "execution_count": 4, 53 | "metadata": {}, 54 | "outputs": [ 55 | { 56 | "name": "stdout", 57 | "output_type": "stream", 58 | "text": [ 59 | "сравниваем 6 c 7\n", 60 | "[6, 7, 3, 8, 1]\n", 61 | "сравниваем 7 c 3\n", 62 | "[6, 3, 7, 8, 1]\n", 63 | "сравниваем 7 c 8\n", 64 | "[6, 3, 7, 8, 1]\n", 65 | "сравниваем 8 c 1\n", 66 | "[6, 3, 7, 1, 8]\n" 67 | ] 68 | } 69 | ], 70 | "source": [ 71 | "my_list=[6,7,3,8,1]\n", 72 | "for i in range(len(my_list)-1):\n", 73 | " print (f\"сравниваем {my_list[i]} c {my_list[i+1]}\")\n", 74 | " if my_list[i]>my_list[i+1]:\n", 75 | " my_list[i],my_list[i+1]=my_list[i+1],my_list[i]\n", 76 | " print(my_list)\n", 77 | " " 78 | ] 79 | }, 80 | { 81 | "cell_type": "code", 82 | "execution_count": 8, 83 | "metadata": {}, 84 | "outputs": [ 85 | { 86 | "name": "stdout", 87 | "output_type": "stream", 88 | "text": [ 89 | "сравниваем 6 c 7\n", 90 | "сравниваем 7 c 3\n", 91 | "сравниваем 7 c 8\n", 92 | "сравниваем 8 c 1\n", 93 | "[6, 3, 7, 1, 8]\n", 94 | "сравниваем 6 c 3\n", 95 | "сравниваем 6 c 7\n", 96 | "сравниваем 7 c 1\n", 97 | "[3, 6, 1, 7, 8]\n", 98 | "сравниваем 3 c 6\n", 99 | "сравниваем 6 c 1\n", 100 | "[3, 1, 6, 7, 8]\n", 101 | "сравниваем 3 c 1\n", 102 | "[1, 3, 6, 7, 8]\n" 103 | ] 104 | } 105 | ], 106 | "source": [ 107 | "my_list=[6,7,3,8,1]\n", 108 | "for run in range (len(my_list)-1):\n", 109 | " for i in range(len(my_list)-1-run):\n", 110 | " print (f\"сравниваем {my_list[i]} c {my_list[i+1]}\")\n", 111 | " if my_list[i]>my_list[i+1]:\n", 112 | " my_list[i],my_list[i+1]=my_list[i+1],my_list[i]\n", 113 | " print(my_list)" 114 | ] 115 | }, 116 | { 117 | "cell_type": "code", 118 | "execution_count": 15, 119 | "metadata": {}, 120 | "outputs": [], 121 | "source": [ 122 | "def bubble_sort(my_list):\n", 123 | " for run in range (len(my_list)-1):\n", 124 | " for i in range(len(my_list)-1-run):\n", 125 | " #print (f\"сравниваем {my_list[i]} c {my_list[i+1]}\")\n", 126 | " if my_list[i]>my_list[i+1]:\n", 127 | " my_list[i],my_list[i+1]=my_list[i+1],my_list[i]\n", 128 | " return my_list" 129 | ] 130 | }, 131 | { 132 | "cell_type": "code", 133 | "execution_count": 16, 134 | "metadata": {}, 135 | "outputs": [ 136 | { 137 | "data": { 138 | "text/plain": [ 139 | "[0, 1, 2, 3, 6, 8, 35, 57, 76]" 140 | ] 141 | }, 142 | "execution_count": 16, 143 | "metadata": {}, 144 | "output_type": "execute_result" 145 | } 146 | ], 147 | "source": [ 148 | "my_list=[1,6,8,3,2,57,76,35,0]\n", 149 | "bubble_sort(my_list)" 150 | ] 151 | }, 152 | { 153 | "cell_type": "code", 154 | "execution_count": 18, 155 | "metadata": {}, 156 | "outputs": [ 157 | { 158 | "data": { 159 | "text/plain": [ 160 | "[0, 1, 2, 3, 6, 8, 35, 57, 76]" 161 | ] 162 | }, 163 | "execution_count": 18, 164 | "metadata": {}, 165 | "output_type": "execute_result" 166 | } 167 | ], 168 | "source": [ 169 | "my_list=[1,6,8,3,2,57,76,35,0]\n", 170 | "my_list.sort()\n", 171 | "my_list" 172 | ] 173 | }, 174 | { 175 | "cell_type": "code", 176 | "execution_count": 19, 177 | "metadata": {}, 178 | "outputs": [ 179 | { 180 | "data": { 181 | "text/plain": [ 182 | "[0, 1, 2, 3, 6, 8, 35, 57, 76]" 183 | ] 184 | }, 185 | "execution_count": 19, 186 | "metadata": {}, 187 | "output_type": "execute_result" 188 | } 189 | ], 190 | "source": [ 191 | "my_list=[1,6,8,3,2,57,76,35,0]\n", 192 | "sorted(my_list)" 193 | ] 194 | }, 195 | { 196 | "cell_type": "code", 197 | "execution_count": 20, 198 | "metadata": {}, 199 | "outputs": [ 200 | { 201 | "data": { 202 | "text/plain": [ 203 | "[1, 6, 8, 3, 2, 57, 76, 35, 0]" 204 | ] 205 | }, 206 | "execution_count": 20, 207 | "metadata": {}, 208 | "output_type": "execute_result" 209 | } 210 | ], 211 | "source": [ 212 | "my_list" 213 | ] 214 | }, 215 | { 216 | "cell_type": "code", 217 | "execution_count": 21, 218 | "metadata": {}, 219 | "outputs": [ 220 | { 221 | "data": { 222 | "text/plain": [ 223 | "[' ', 'В', 'а', 'е', 'ж', 'и', 'и', 'и', 'н', 'о', 'р', 'с', 'т', 'ы']" 224 | ] 225 | }, 226 | "execution_count": 21, 227 | "metadata": {}, 228 | "output_type": "execute_result" 229 | } 230 | ], 231 | "source": [ 232 | "string='Важные истории'\n", 233 | "sorted(string)" 234 | ] 235 | }, 236 | { 237 | "cell_type": "code", 238 | "execution_count": 22, 239 | "metadata": {}, 240 | "outputs": [ 241 | { 242 | "data": { 243 | "text/plain": [ 244 | "['income', 'name', 'wife_income']" 245 | ] 246 | }, 247 | "execution_count": 22, 248 | "metadata": {}, 249 | "output_type": "execute_result" 250 | } 251 | ], 252 | "source": [ 253 | "fsb_dict={'name':'Бортников А.В.','income':13626718.98,'wife_income':261956.95}\n", 254 | "sorted(fsb_dict)" 255 | ] 256 | }, 257 | { 258 | "cell_type": "code", 259 | "execution_count": 23, 260 | "metadata": {}, 261 | "outputs": [ 262 | { 263 | "data": { 264 | "text/plain": [ 265 | "[76, 57, 35, 8, 6, 3, 2, 1, 0]" 266 | ] 267 | }, 268 | "execution_count": 23, 269 | "metadata": {}, 270 | "output_type": "execute_result" 271 | } 272 | ], 273 | "source": [ 274 | "my_list=[1,6,8,3,2,57,76,35,0]\n", 275 | "sorted(my_list,reverse=True)" 276 | ] 277 | }, 278 | { 279 | "cell_type": "code", 280 | "execution_count": 24, 281 | "metadata": {}, 282 | "outputs": [ 283 | { 284 | "data": { 285 | "text/plain": [ 286 | "[' ', 'а', 'В', 'е', 'ж', 'и', 'и', 'и', 'н', 'о', 'р', 'с', 'т', 'ы']" 287 | ] 288 | }, 289 | "execution_count": 24, 290 | "metadata": {}, 291 | "output_type": "execute_result" 292 | } 293 | ], 294 | "source": [ 295 | "string='Важные истории'\n", 296 | "sorted(string,key=str.lower)" 297 | ] 298 | }, 299 | { 300 | "cell_type": "code", 301 | "execution_count": 25, 302 | "metadata": {}, 303 | "outputs": [], 304 | "source": [ 305 | "fsb_list=[['Бортников А.В.',13626718.98,261956.95],['Смирнов С.М.',11882496.91,593918.65],['Кулишов В.Г.',6795228.14,861350.27]]" 306 | ] 307 | }, 308 | { 309 | "cell_type": "code", 310 | "execution_count": 27, 311 | "metadata": {}, 312 | "outputs": [ 313 | { 314 | "data": { 315 | "text/plain": [ 316 | "[['Бортников А.В.', 13626718.98, 261956.95],\n", 317 | " ['Кулишов В.Г.', 6795228.14, 861350.27],\n", 318 | " ['Смирнов С.М.', 11882496.91, 593918.65]]" 319 | ] 320 | }, 321 | "execution_count": 27, 322 | "metadata": {}, 323 | "output_type": "execute_result" 324 | } 325 | ], 326 | "source": [ 327 | "sorted(fsb_list)" 328 | ] 329 | }, 330 | { 331 | "cell_type": "code", 332 | "execution_count": 28, 333 | "metadata": {}, 334 | "outputs": [], 335 | "source": [ 336 | "def fsb_income(i):\n", 337 | " return i[1]" 338 | ] 339 | }, 340 | { 341 | "cell_type": "code", 342 | "execution_count": 29, 343 | "metadata": {}, 344 | "outputs": [ 345 | { 346 | "data": { 347 | "text/plain": [ 348 | "[['Кулишов В.Г.', 6795228.14, 861350.27],\n", 349 | " ['Смирнов С.М.', 11882496.91, 593918.65],\n", 350 | " ['Бортников А.В.', 13626718.98, 261956.95]]" 351 | ] 352 | }, 353 | "execution_count": 29, 354 | "metadata": {}, 355 | "output_type": "execute_result" 356 | } 357 | ], 358 | "source": [ 359 | "sorted(fsb_list,key=fsb_income)" 360 | ] 361 | }, 362 | { 363 | "cell_type": "code", 364 | "execution_count": 30, 365 | "metadata": {}, 366 | "outputs": [], 367 | "source": [ 368 | "fsb=[{'name':'Бортников А.В.','income':13626718.98,'wife_income':261956.95},\n", 369 | " {'name':'Смирнов С.М.','income':11882496.91,'wife_income':593918.65},\n", 370 | " {'name':'Кулишов В.Г.','income':6795228.14,'wife_income':861350.27},\n", 371 | " {'name':'Купряжкин А.Н.','income':7406264.90,'wife_income':315794.75},\n", 372 | " {'name':'Сироткин И.Г.','income':5912584.62,'wife_income':393095.22}]" 373 | ] 374 | }, 375 | { 376 | "cell_type": "code", 377 | "execution_count": 31, 378 | "metadata": {}, 379 | "outputs": [], 380 | "source": [ 381 | "def fsb_wife_income(i):\n", 382 | " return i.get('wife_income')" 383 | ] 384 | }, 385 | { 386 | "cell_type": "code", 387 | "execution_count": 32, 388 | "metadata": {}, 389 | "outputs": [ 390 | { 391 | "data": { 392 | "text/plain": [ 393 | "[{'name': 'Бортников А.В.', 'income': 13626718.98, 'wife_income': 261956.95},\n", 394 | " {'name': 'Купряжкин А.Н.', 'income': 7406264.9, 'wife_income': 315794.75},\n", 395 | " {'name': 'Сироткин И.Г.', 'income': 5912584.62, 'wife_income': 393095.22},\n", 396 | " {'name': 'Смирнов С.М.', 'income': 11882496.91, 'wife_income': 593918.65},\n", 397 | " {'name': 'Кулишов В.Г.', 'income': 6795228.14, 'wife_income': 861350.27}]" 398 | ] 399 | }, 400 | "execution_count": 32, 401 | "metadata": {}, 402 | "output_type": "execute_result" 403 | } 404 | ], 405 | "source": [ 406 | "sorted(fsb,key=fsb_wife_income)" 407 | ] 408 | }, 409 | { 410 | "cell_type": "code", 411 | "execution_count": null, 412 | "metadata": {}, 413 | "outputs": [], 414 | "source": [] 415 | } 416 | ], 417 | "metadata": { 418 | "kernelspec": { 419 | "display_name": "Python 3", 420 | "language": "python", 421 | "name": "python3" 422 | }, 423 | "language_info": { 424 | "codemirror_mode": { 425 | "name": "ipython", 426 | "version": 3 427 | }, 428 | "file_extension": ".py", 429 | "mimetype": "text/x-python", 430 | "name": "python", 431 | "nbconvert_exporter": "python", 432 | "pygments_lexer": "ipython3", 433 | "version": "3.8.3" 434 | } 435 | }, 436 | "nbformat": 4, 437 | "nbformat_minor": 4 438 | } 439 | -------------------------------------------------------------------------------- /Python _ Урок 1.ipynb: -------------------------------------------------------------------------------- 1 | { 2 | "cells": [ 3 | { 4 | "cell_type": "code", 5 | "execution_count": 1, 6 | "metadata": { 7 | "collapsed": false 8 | }, 9 | "outputs": [ 10 | { 11 | "data": { 12 | "text/plain": [ 13 | "4" 14 | ] 15 | }, 16 | "execution_count": 1, 17 | "metadata": {}, 18 | "output_type": "execute_result" 19 | } 20 | ], 21 | "source": [ 22 | "2 + 2" 23 | ] 24 | }, 25 | { 26 | "cell_type": "code", 27 | "execution_count": 2, 28 | "metadata": { 29 | "collapsed": false 30 | }, 31 | "outputs": [ 32 | { 33 | "data": { 34 | "text/plain": [ 35 | "4" 36 | ] 37 | }, 38 | "execution_count": 2, 39 | "metadata": {}, 40 | "output_type": "execute_result" 41 | } 42 | ], 43 | "source": [ 44 | "2*2" 45 | ] 46 | }, 47 | { 48 | "cell_type": "code", 49 | "execution_count": 3, 50 | "metadata": { 51 | "collapsed": false 52 | }, 53 | "outputs": [ 54 | { 55 | "data": { 56 | "text/plain": [ 57 | "1.0" 58 | ] 59 | }, 60 | "execution_count": 3, 61 | "metadata": {}, 62 | "output_type": "execute_result" 63 | } 64 | ], 65 | "source": [ 66 | "2/2" 67 | ] 68 | }, 69 | { 70 | "cell_type": "code", 71 | "execution_count": 4, 72 | "metadata": { 73 | "collapsed": true 74 | }, 75 | "outputs": [], 76 | "source": [ 77 | "x = 2" 78 | ] 79 | }, 80 | { 81 | "cell_type": "markdown", 82 | "metadata": {}, 83 | "source": [ 84 | "Создание переменной x " 85 | ] 86 | }, 87 | { 88 | "cell_type": "code", 89 | "execution_count": 5, 90 | "metadata": { 91 | "collapsed": false 92 | }, 93 | "outputs": [ 94 | { 95 | "data": { 96 | "text/plain": [ 97 | "int" 98 | ] 99 | }, 100 | "execution_count": 5, 101 | "metadata": {}, 102 | "output_type": "execute_result" 103 | } 104 | ], 105 | "source": [ 106 | "type(x)" 107 | ] 108 | }, 109 | { 110 | "cell_type": "markdown", 111 | "metadata": {}, 112 | "source": [ 113 | "Функция определения типа данных type()" 114 | ] 115 | }, 116 | { 117 | "cell_type": "code", 118 | "execution_count": 6, 119 | "metadata": { 120 | "collapsed": false 121 | }, 122 | "outputs": [ 123 | { 124 | "data": { 125 | "text/plain": [ 126 | "int" 127 | ] 128 | }, 129 | "execution_count": 6, 130 | "metadata": {}, 131 | "output_type": "execute_result" 132 | } 133 | ], 134 | "source": [ 135 | "type(2)" 136 | ] 137 | }, 138 | { 139 | "cell_type": "markdown", 140 | "metadata": {}, 141 | "source": [ 142 | "Тип int — целые числа" 143 | ] 144 | }, 145 | { 146 | "cell_type": "code", 147 | "execution_count": 7, 148 | "metadata": { 149 | "collapsed": false 150 | }, 151 | "outputs": [ 152 | { 153 | "data": { 154 | "text/plain": [ 155 | "4" 156 | ] 157 | }, 158 | "execution_count": 7, 159 | "metadata": {}, 160 | "output_type": "execute_result" 161 | } 162 | ], 163 | "source": [ 164 | "x + x" 165 | ] 166 | }, 167 | { 168 | "cell_type": "code", 169 | "execution_count": 8, 170 | "metadata": { 171 | "collapsed": false 172 | }, 173 | "outputs": [ 174 | { 175 | "data": { 176 | "text/plain": [ 177 | "20" 178 | ] 179 | }, 180 | "execution_count": 8, 181 | "metadata": {}, 182 | "output_type": "execute_result" 183 | } 184 | ], 185 | "source": [ 186 | "x*10" 187 | ] 188 | }, 189 | { 190 | "cell_type": "code", 191 | "execution_count": 9, 192 | "metadata": { 193 | "collapsed": true 194 | }, 195 | "outputs": [], 196 | "source": [ 197 | "a = x*10" 198 | ] 199 | }, 200 | { 201 | "cell_type": "code", 202 | "execution_count": 10, 203 | "metadata": { 204 | "collapsed": true 205 | }, 206 | "outputs": [], 207 | "source": [ 208 | "b = a/8" 209 | ] 210 | }, 211 | { 212 | "cell_type": "code", 213 | "execution_count": 11, 214 | "metadata": { 215 | "collapsed": false 216 | }, 217 | "outputs": [ 218 | { 219 | "data": { 220 | "text/plain": [ 221 | "2.5" 222 | ] 223 | }, 224 | "execution_count": 11, 225 | "metadata": {}, 226 | "output_type": "execute_result" 227 | } 228 | ], 229 | "source": [ 230 | "b" 231 | ] 232 | }, 233 | { 234 | "cell_type": "code", 235 | "execution_count": 13, 236 | "metadata": { 237 | "collapsed": false 238 | }, 239 | "outputs": [ 240 | { 241 | "data": { 242 | "text/plain": [ 243 | "False" 244 | ] 245 | }, 246 | "execution_count": 13, 247 | "metadata": {}, 248 | "output_type": "execute_result" 249 | } 250 | ], 251 | "source": [ 252 | "b > 3" 253 | ] 254 | }, 255 | { 256 | "cell_type": "code", 257 | "execution_count": 14, 258 | "metadata": { 259 | "collapsed": false 260 | }, 261 | "outputs": [ 262 | { 263 | "data": { 264 | "text/plain": [ 265 | "True" 266 | ] 267 | }, 268 | "execution_count": 14, 269 | "metadata": {}, 270 | "output_type": "execute_result" 271 | } 272 | ], 273 | "source": [ 274 | "b < 3" 275 | ] 276 | }, 277 | { 278 | "cell_type": "code", 279 | "execution_count": 1, 280 | "metadata": { 281 | "collapsed": false 282 | }, 283 | "outputs": [ 284 | { 285 | "data": { 286 | "text/plain": [ 287 | "bool" 288 | ] 289 | }, 290 | "execution_count": 1, 291 | "metadata": {}, 292 | "output_type": "execute_result" 293 | } 294 | ], 295 | "source": [ 296 | "type(2 == 2)" 297 | ] 298 | }, 299 | { 300 | "cell_type": "markdown", 301 | "metadata": {}, 302 | "source": [ 303 | "bool — логический или булев тип" 304 | ] 305 | }, 306 | { 307 | "cell_type": "code", 308 | "execution_count": 15, 309 | "metadata": { 310 | "collapsed": false 311 | }, 312 | "outputs": [ 313 | { 314 | "data": { 315 | "text/plain": [ 316 | "False" 317 | ] 318 | }, 319 | "execution_count": 15, 320 | "metadata": {}, 321 | "output_type": "execute_result" 322 | } 323 | ], 324 | "source": [ 325 | "type(b) == int" 326 | ] 327 | }, 328 | { 329 | "cell_type": "code", 330 | "execution_count": 16, 331 | "metadata": { 332 | "collapsed": false 333 | }, 334 | "outputs": [ 335 | { 336 | "data": { 337 | "text/plain": [ 338 | "float" 339 | ] 340 | }, 341 | "execution_count": 16, 342 | "metadata": {}, 343 | "output_type": "execute_result" 344 | } 345 | ], 346 | "source": [ 347 | "type(b)" 348 | ] 349 | }, 350 | { 351 | "cell_type": "code", 352 | "execution_count": 2, 353 | "metadata": { 354 | "collapsed": false 355 | }, 356 | "outputs": [ 357 | { 358 | "data": { 359 | "text/plain": [ 360 | "float" 361 | ] 362 | }, 363 | "execution_count": 2, 364 | "metadata": {}, 365 | "output_type": "execute_result" 366 | } 367 | ], 368 | "source": [ 369 | "type(2.5)" 370 | ] 371 | }, 372 | { 373 | "cell_type": "markdown", 374 | "metadata": {}, 375 | "source": [ 376 | "Тип float — числа с плавающей точкой" 377 | ] 378 | }, 379 | { 380 | "cell_type": "code", 381 | "execution_count": 17, 382 | "metadata": { 383 | "collapsed": false 384 | }, 385 | "outputs": [ 386 | { 387 | "data": { 388 | "text/plain": [ 389 | "False" 390 | ] 391 | }, 392 | "execution_count": 17, 393 | "metadata": {}, 394 | "output_type": "execute_result" 395 | } 396 | ], 397 | "source": [ 398 | "\"2\" == 2" 399 | ] 400 | }, 401 | { 402 | "cell_type": "code", 403 | "execution_count": 18, 404 | "metadata": { 405 | "collapsed": false 406 | }, 407 | "outputs": [ 408 | { 409 | "data": { 410 | "text/plain": [ 411 | "str" 412 | ] 413 | }, 414 | "execution_count": 18, 415 | "metadata": {}, 416 | "output_type": "execute_result" 417 | } 418 | ], 419 | "source": [ 420 | "type(\"2\")" 421 | ] 422 | }, 423 | { 424 | "cell_type": "markdown", 425 | "metadata": {}, 426 | "source": [ 427 | "Тип str — строка" 428 | ] 429 | }, 430 | { 431 | "cell_type": "code", 432 | "execution_count": 19, 433 | "metadata": { 434 | "collapsed": false 435 | }, 436 | "outputs": [ 437 | { 438 | "data": { 439 | "text/plain": [ 440 | "int" 441 | ] 442 | }, 443 | "execution_count": 19, 444 | "metadata": {}, 445 | "output_type": "execute_result" 446 | } 447 | ], 448 | "source": [ 449 | "type(2)" 450 | ] 451 | }, 452 | { 453 | "cell_type": "code", 454 | "execution_count": 22, 455 | "metadata": { 456 | "collapsed": false 457 | }, 458 | "outputs": [ 459 | { 460 | "data": { 461 | "text/plain": [ 462 | "2" 463 | ] 464 | }, 465 | "execution_count": 22, 466 | "metadata": {}, 467 | "output_type": "execute_result" 468 | } 469 | ], 470 | "source": [ 471 | "int('2')" 472 | ] 473 | }, 474 | { 475 | "cell_type": "markdown", 476 | "metadata": {}, 477 | "source": [ 478 | "Превращаем строку в число с помощью функции int()" 479 | ] 480 | }, 481 | { 482 | "cell_type": "code", 483 | "execution_count": 23, 484 | "metadata": { 485 | "collapsed": false 486 | }, 487 | "outputs": [ 488 | { 489 | "data": { 490 | "text/plain": [ 491 | "'2'" 492 | ] 493 | }, 494 | "execution_count": 23, 495 | "metadata": {}, 496 | "output_type": "execute_result" 497 | } 498 | ], 499 | "source": [ 500 | "str(2)" 501 | ] 502 | }, 503 | { 504 | "cell_type": "markdown", 505 | "metadata": {}, 506 | "source": [ 507 | "Превращаем число в строку с помощью функции str()" 508 | ] 509 | }, 510 | { 511 | "cell_type": "code", 512 | "execution_count": 24, 513 | "metadata": { 514 | "collapsed": false 515 | }, 516 | "outputs": [ 517 | { 518 | "ename": "ValueError", 519 | "evalue": "invalid literal for int() with base 10: 'привет'", 520 | "output_type": "error", 521 | "traceback": [ 522 | "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", 523 | "\u001b[0;31mValueError\u001b[0m Traceback (most recent call last)", 524 | "\u001b[0;32m\u001b[0m in \u001b[0;36m\u001b[0;34m\u001b[0m\n\u001b[0;32m----> 1\u001b[0;31m \u001b[0mint\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m'привет'\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m", 525 | "\u001b[0;31mValueError\u001b[0m: invalid literal for int() with base 10: 'привет'" 526 | ] 527 | } 528 | ], 529 | "source": [ 530 | "int('привет')" 531 | ] 532 | }, 533 | { 534 | "cell_type": "code", 535 | "execution_count": null, 536 | "metadata": { 537 | "collapsed": true 538 | }, 539 | "outputs": [], 540 | "source": [] 541 | } 542 | ], 543 | "metadata": { 544 | "kernelspec": { 545 | "display_name": "Python [Root]", 546 | "language": "python", 547 | "name": "Python [Root]" 548 | }, 549 | "language_info": { 550 | "codemirror_mode": { 551 | "name": "ipython", 552 | "version": 3 553 | }, 554 | "file_extension": ".py", 555 | "mimetype": "text/x-python", 556 | "name": "python", 557 | "nbconvert_exporter": "python", 558 | "pygments_lexer": "ipython3", 559 | "version": "3.5.2" 560 | } 561 | }, 562 | "nbformat": 4, 563 | "nbformat_minor": 4 564 | } 565 | -------------------------------------------------------------------------------- /Урок 6. Словари.ipynb: -------------------------------------------------------------------------------- 1 | { 2 | "cells": [ 3 | { 4 | "cell_type": "code", 5 | "execution_count": 1, 6 | "metadata": {}, 7 | "outputs": [ 8 | { 9 | "data": { 10 | "text/plain": [ 11 | "dict" 12 | ] 13 | }, 14 | "execution_count": 1, 15 | "metadata": {}, 16 | "output_type": "execute_result" 17 | } 18 | ], 19 | "source": [ 20 | "new_dict = {} #создаем новый словарь\n", 21 | "type(new_dict)" 22 | ] 23 | }, 24 | { 25 | "cell_type": "code", 26 | "execution_count": 2, 27 | "metadata": {}, 28 | "outputs": [ 29 | { 30 | "data": { 31 | "text/plain": [ 32 | "{}" 33 | ] 34 | }, 35 | "execution_count": 2, 36 | "metadata": {}, 37 | "output_type": "execute_result" 38 | } 39 | ], 40 | "source": [ 41 | "new_dict = dict()#создаем новый словарь \n", 42 | "new_dict" 43 | ] 44 | }, 45 | { 46 | "cell_type": "code", 47 | "execution_count": 3, 48 | "metadata": {}, 49 | "outputs": [], 50 | "source": [ 51 | "income = {'Антов Павел Генрихович': 9969174545, \n", 52 | " 'Сиушов Сергей Иванович': 6788118841, \n", 53 | " 'Струков Константин Иванович': 4461793274}\n", 54 | "\n", 55 | "#имя — ключ\n", 56 | "#сумма — значение\n" 57 | ] 58 | }, 59 | { 60 | "cell_type": "code", 61 | "execution_count": 26, 62 | "metadata": {}, 63 | "outputs": [ 64 | { 65 | "data": { 66 | "text/plain": [ 67 | "9969174545" 68 | ] 69 | }, 70 | "execution_count": 26, 71 | "metadata": {}, 72 | "output_type": "execute_result" 73 | } 74 | ], 75 | "source": [ 76 | "income['Антов Павел Генрихович'] #обращаться к словарю можно только по ключу" 77 | ] 78 | }, 79 | { 80 | "cell_type": "code", 81 | "execution_count": 5, 82 | "metadata": {}, 83 | "outputs": [], 84 | "source": [ 85 | "income['Путин Владимир Владимирович'] = 9726595 \n", 86 | "#через ключ же можно и добавлять новые значение" 87 | ] 88 | }, 89 | { 90 | "cell_type": "code", 91 | "execution_count": 6, 92 | "metadata": {}, 93 | "outputs": [ 94 | { 95 | "data": { 96 | "text/plain": [ 97 | "{'Антов Павел Генрихович': 9969174545,\n", 98 | " 'Сиушов Сергей Иванович': 6788118841,\n", 99 | " 'Струков Константин Иванович': 4461793274,\n", 100 | " 'Путин Владимир Владимирович': 9726595}" 101 | ] 102 | }, 103 | "execution_count": 6, 104 | "metadata": {}, 105 | "output_type": "execute_result" 106 | } 107 | ], 108 | "source": [ 109 | "income" 110 | ] 111 | }, 112 | { 113 | "cell_type": "code", 114 | "execution_count": 7, 115 | "metadata": {}, 116 | "outputs": [ 117 | { 118 | "data": { 119 | "text/plain": [ 120 | "9726595" 121 | ] 122 | }, 123 | "execution_count": 7, 124 | "metadata": {}, 125 | "output_type": "execute_result" 126 | } 127 | ], 128 | "source": [ 129 | "income['Путин Владимир Владимирович']" 130 | ] 131 | }, 132 | { 133 | "cell_type": "code", 134 | "execution_count": 8, 135 | "metadata": {}, 136 | "outputs": [ 137 | { 138 | "ename": "KeyError", 139 | "evalue": "3", 140 | "output_type": "error", 141 | "traceback": [ 142 | "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", 143 | "\u001b[0;31mKeyError\u001b[0m Traceback (most recent call last)", 144 | "\u001b[0;32m\u001b[0m in \u001b[0;36m\u001b[0;34m\u001b[0m\n\u001b[0;32m----> 1\u001b[0;31m \u001b[0mincome\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;36m3\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m", 145 | "\u001b[0;31mKeyError\u001b[0m: 3" 146 | ] 147 | } 148 | ], 149 | "source": [ 150 | "income[3] \n", 151 | "\n", 152 | "#Нельзя посмотреть, каким по счет идет Владимир Путин, и использовать этот номер, чтобы обратиться к нему. \n", 153 | "#Подобная попытка закончится ошибкой.\n", 154 | "#Эта ошибка означает, что в словаре нет такого ключа как 3, число которое мы пытались использовать в качестве индекса элемента. \n", 155 | "#Обращаться к словарям можно только по ключу." 156 | ] 157 | }, 158 | { 159 | "cell_type": "code", 160 | "execution_count": 9, 161 | "metadata": {}, 162 | "outputs": [ 163 | { 164 | "data": { 165 | "text/plain": [ 166 | "9726595" 167 | ] 168 | }, 169 | "execution_count": 9, 170 | "metadata": {}, 171 | "output_type": "execute_result" 172 | } 173 | ], 174 | "source": [ 175 | "income.get(\"Путин Владимир Владимирович\", 'нет ключа')\n", 176 | "\n", 177 | "#для получения значений можно использовать и метод get()\n", 178 | "#В скобочках вы указываете ключ, значение которого хотите получить, а через запятую \n", 179 | "#указываете то, что хотите получить в случае, если такого ключа нет в словаре. \n", 180 | "#В примере мы получим строку «нет ключа» в ответ. \n", 181 | "#Если через запятую не указывать ничего, то по умолчанию будет возвращаться None." 182 | ] 183 | }, 184 | { 185 | "cell_type": "code", 186 | "execution_count": 11, 187 | "metadata": {}, 188 | "outputs": [ 189 | { 190 | "data": { 191 | "text/plain": [ 192 | "'нет ключа'" 193 | ] 194 | }, 195 | "execution_count": 11, 196 | "metadata": {}, 197 | "output_type": "execute_result" 198 | } 199 | ], 200 | "source": [ 201 | "income.get(3, 'нет ключа')" 202 | ] 203 | }, 204 | { 205 | "cell_type": "code", 206 | "execution_count": 12, 207 | "metadata": {}, 208 | "outputs": [ 209 | { 210 | "data": { 211 | "text/plain": [ 212 | "0" 213 | ] 214 | }, 215 | "execution_count": 12, 216 | "metadata": {}, 217 | "output_type": "execute_result" 218 | } 219 | ], 220 | "source": [ 221 | "number_dict = {1:0, 2:1, 3:2, 4:3} #В словарях ключами и значениями могут быть разные типы данных\n", 222 | "number_dict[1]" 223 | ] 224 | }, 225 | { 226 | "cell_type": "code", 227 | "execution_count": 13, 228 | "metadata": {}, 229 | "outputs": [ 230 | { 231 | "ename": "KeyError", 232 | "evalue": "'1'", 233 | "output_type": "error", 234 | "traceback": [ 235 | "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", 236 | "\u001b[0;31mKeyError\u001b[0m Traceback (most recent call last)", 237 | "\u001b[0;32m\u001b[0m in \u001b[0;36m\u001b[0;34m\u001b[0m\n\u001b[0;32m----> 1\u001b[0;31m \u001b[0mnumber_dict\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;34m'1'\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m", 238 | "\u001b[0;31mKeyError\u001b[0m: '1'" 239 | ] 240 | } 241 | ], 242 | "source": [ 243 | "number_dict['1']\n", 244 | "\n", 245 | "#Только если ваш ключ — это число, то указывать его в квадратных скобках \n", 246 | "#при обращении нужно тоже как число. \n", 247 | "#Если вы укажете его в кавычках, то это будет уже другое значение. \n", 248 | "#Вы снова получите ошибку, что такого ключа нет в словаре." 249 | ] 250 | }, 251 | { 252 | "cell_type": "code", 253 | "execution_count": 14, 254 | "metadata": {}, 255 | "outputs": [ 256 | { 257 | "data": { 258 | "text/plain": [ 259 | "{'Антов Павел Генрихович': 9969174545,\n", 260 | " 'Сиушов Сергей Иванович': 6788118841,\n", 261 | " 'Струков Константин Иванович': 4461793274,\n", 262 | " 'Путин Владимир Владимирович': [18728268, 8648353, 9726595]}" 263 | ] 264 | }, 265 | "execution_count": 14, 266 | "metadata": {}, 267 | "output_type": "execute_result" 268 | } 269 | ], 270 | "source": [ 271 | "income['Путин Владимир Владимирович'] = [18728268, 8648353, 9726595]\n", 272 | "income\n", 273 | "\n", 274 | "#Значениями в словаре так же могут быть и списки." 275 | ] 276 | }, 277 | { 278 | "cell_type": "code", 279 | "execution_count": 15, 280 | "metadata": {}, 281 | "outputs": [ 282 | { 283 | "data": { 284 | "text/plain": [ 285 | "[18728268, 8648353, 9726595]" 286 | ] 287 | }, 288 | "execution_count": 15, 289 | "metadata": {}, 290 | "output_type": "execute_result" 291 | } 292 | ], 293 | "source": [ 294 | "income.pop('Путин Владимир Владимирович')\n", 295 | "#Удалять элемент из словаря можно с помощью .pop(). \n", 296 | "#В скобках нужно указать ключ элемента. \n", 297 | "#Он удалится, и вам вернется удаленное значение. " 298 | ] 299 | }, 300 | { 301 | "cell_type": "code", 302 | "execution_count": 16, 303 | "metadata": {}, 304 | "outputs": [ 305 | { 306 | "data": { 307 | "text/plain": [ 308 | "{'Антов Павел Генрихович': 9969174545,\n", 309 | " 'Сиушов Сергей Иванович': 6788118841,\n", 310 | " 'Струков Константин Иванович': 4461793274}" 311 | ] 312 | }, 313 | "execution_count": 16, 314 | "metadata": {}, 315 | "output_type": "execute_result" 316 | } 317 | ], 318 | "source": [ 319 | "income" 320 | ] 321 | }, 322 | { 323 | "cell_type": "code", 324 | "execution_count": 19, 325 | "metadata": {}, 326 | "outputs": [ 327 | { 328 | "data": { 329 | "text/plain": [ 330 | "['Антов Павел Генрихович',\n", 331 | " 'Сиушов Сергей Иванович',\n", 332 | " 'Струков Константин Иванович']" 333 | ] 334 | }, 335 | "execution_count": 19, 336 | "metadata": {}, 337 | "output_type": "execute_result" 338 | } 339 | ], 340 | "source": [ 341 | "list(income.keys()) #мы можем получить отдельно список всех ключей" 342 | ] 343 | }, 344 | { 345 | "cell_type": "code", 346 | "execution_count": 20, 347 | "metadata": {}, 348 | "outputs": [ 349 | { 350 | "data": { 351 | "text/plain": [ 352 | "[9969174545, 6788118841, 4461793274]" 353 | ] 354 | }, 355 | "execution_count": 20, 356 | "metadata": {}, 357 | "output_type": "execute_result" 358 | } 359 | ], 360 | "source": [ 361 | "list(income.values()) #и всех значений словаря" 362 | ] 363 | }, 364 | { 365 | "cell_type": "markdown", 366 | "metadata": {}, 367 | "source": [ 368 | "Создадим новый словарь, в котором у нас будут храниться доходы за последние три года Владимира Путина и Дмитрия Медведева. И напишем небольшой код, который будет перебирать элементы этого словаря и печатать нам сообщение о том, у кого каким за последние три года был минимальный доход. И для решения этой задачки нам потребуется еще один метод словаря .items(). Он позволяет попарно перебирать и ключ, и значение." 369 | ] 370 | }, 371 | { 372 | "cell_type": "code", 373 | "execution_count": 21, 374 | "metadata": {}, 375 | "outputs": [], 376 | "source": [ 377 | "income_dict = {'Путин Владимир': [18728268, 8648353, 9726595], 'Медведев Дмитрий': [11051195, 9917511, 8565296]}\n", 378 | "\n" 379 | ] 380 | }, 381 | { 382 | "cell_type": "code", 383 | "execution_count": 22, 384 | "metadata": {}, 385 | "outputs": [ 386 | { 387 | "data": { 388 | "text/plain": [ 389 | "list" 390 | ] 391 | }, 392 | "execution_count": 22, 393 | "metadata": {}, 394 | "output_type": "execute_result" 395 | } 396 | ], 397 | "source": [ 398 | "type(income_dict['Путин Владимир'])" 399 | ] 400 | }, 401 | { 402 | "cell_type": "code", 403 | "execution_count": 25, 404 | "metadata": {}, 405 | "outputs": [ 406 | { 407 | "name": "stdout", 408 | "output_type": "stream", 409 | "text": [ 410 | "Минамальный доход у Путин Владимир за последние три года составил 8648353 рублей\n", 411 | "Минамальный доход у Медведев Дмитрий за последние три года составил 8565296 рублей\n" 412 | ] 413 | } 414 | ], 415 | "source": [ 416 | "for key, value in income_dict.items():\n", 417 | " print(f\"Минамальный доход у {key} за последние три года составил {min(value)} рублей\")" 418 | ] 419 | }, 420 | { 421 | "cell_type": "code", 422 | "execution_count": null, 423 | "metadata": {}, 424 | "outputs": [], 425 | "source": [] 426 | } 427 | ], 428 | "metadata": { 429 | "kernelspec": { 430 | "display_name": "Python 3", 431 | "language": "python", 432 | "name": "python3" 433 | }, 434 | "language_info": { 435 | "codemirror_mode": { 436 | "name": "ipython", 437 | "version": 3 438 | }, 439 | "file_extension": ".py", 440 | "mimetype": "text/x-python", 441 | "name": "python", 442 | "nbconvert_exporter": "python", 443 | "pygments_lexer": "ipython3", 444 | "version": "3.8.3" 445 | } 446 | }, 447 | "nbformat": 4, 448 | "nbformat_minor": 4 449 | } 450 | -------------------------------------------------------------------------------- /Урок 10. Генераторы списков.ipynb: -------------------------------------------------------------------------------- 1 | { 2 | "cells": [ 3 | { 4 | "cell_type": "code", 5 | "execution_count": 88, 6 | "metadata": { 7 | "collapsed": false 8 | }, 9 | "outputs": [ 10 | { 11 | "data": { 12 | "text/plain": [ 13 | "[2000,\n", 14 | " 2001,\n", 15 | " 2002,\n", 16 | " 2003,\n", 17 | " 2004,\n", 18 | " 2005,\n", 19 | " 2006,\n", 20 | " 2007,\n", 21 | " 2008,\n", 22 | " 2009,\n", 23 | " 2010,\n", 24 | " 2011,\n", 25 | " 2012,\n", 26 | " 2013,\n", 27 | " 2014,\n", 28 | " 2015,\n", 29 | " 2016,\n", 30 | " 2017,\n", 31 | " 2018,\n", 32 | " 2019]" 33 | ] 34 | }, 35 | "execution_count": 88, 36 | "metadata": {}, 37 | "output_type": "execute_result" 38 | } 39 | ], 40 | "source": [ 41 | "years = []\n", 42 | "for i in range(2000,2020):\n", 43 | " years.append(i)\n", 44 | "years" 45 | ] 46 | }, 47 | { 48 | "cell_type": "code", 49 | "execution_count": 89, 50 | "metadata": { 51 | "collapsed": false 52 | }, 53 | "outputs": [ 54 | { 55 | "data": { 56 | "text/plain": [ 57 | "[2000,\n", 58 | " 2001,\n", 59 | " 2002,\n", 60 | " 2003,\n", 61 | " 2004,\n", 62 | " 2005,\n", 63 | " 2006,\n", 64 | " 2007,\n", 65 | " 2008,\n", 66 | " 2009,\n", 67 | " 2010,\n", 68 | " 2011,\n", 69 | " 2012,\n", 70 | " 2013,\n", 71 | " 2014,\n", 72 | " 2015,\n", 73 | " 2016,\n", 74 | " 2017,\n", 75 | " 2018,\n", 76 | " 2019]" 77 | ] 78 | }, 79 | "execution_count": 89, 80 | "metadata": {}, 81 | "output_type": "execute_result" 82 | } 83 | ], 84 | "source": [ 85 | "years = [i for i in range(2000,2020)]\n", 86 | "years\n", 87 | "#тоже самое, но с помощью генератора списка" 88 | ] 89 | }, 90 | { 91 | "cell_type": "code", 92 | "execution_count": 90, 93 | "metadata": { 94 | "collapsed": false 95 | }, 96 | "outputs": [ 97 | { 98 | "data": { 99 | "text/plain": [ 100 | "[4000,\n", 101 | " 4002,\n", 102 | " 4004,\n", 103 | " 4006,\n", 104 | " 4008,\n", 105 | " 4010,\n", 106 | " 4012,\n", 107 | " 4014,\n", 108 | " 4016,\n", 109 | " 4018,\n", 110 | " 4020,\n", 111 | " 4022,\n", 112 | " 4024,\n", 113 | " 4026,\n", 114 | " 4028,\n", 115 | " 4030,\n", 116 | " 4032,\n", 117 | " 4034,\n", 118 | " 4036,\n", 119 | " 4038]" 120 | ] 121 | }, 122 | "execution_count": 90, 123 | "metadata": {}, 124 | "output_type": "execute_result" 125 | } 126 | ], 127 | "source": [ 128 | "years_future = [i*2 for i in range(2000,2020)]\n", 129 | "years_future" 130 | ] 131 | }, 132 | { 133 | "cell_type": "code", 134 | "execution_count": 91, 135 | "metadata": { 136 | "collapsed": true 137 | }, 138 | "outputs": [], 139 | "source": [ 140 | "poverty = [42.3, 40, 35.6, 29.3, 25.2, 25.4, 21.6, 18.8, 19, 18.4, 17.7, 17.9, 15.4, 15.5, 16.3, 19.6, 19.4, \n", 141 | " 18.9, 18.4, 18.1]\n", 142 | "#количество людей, живущиих за чертой бедности в России в млн человек" 143 | ] 144 | }, 145 | { 146 | "cell_type": "code", 147 | "execution_count": 92, 148 | "metadata": { 149 | "collapsed": false 150 | }, 151 | "outputs": [], 152 | "source": [ 153 | "poverty_data = {x : y for x,y in zip(years,poverty)}\n", 154 | "#генератор словаря" 155 | ] 156 | }, 157 | { 158 | "cell_type": "code", 159 | "execution_count": 93, 160 | "metadata": { 161 | "collapsed": false 162 | }, 163 | "outputs": [ 164 | { 165 | "data": { 166 | "text/plain": [ 167 | "{2000: 42.3,\n", 168 | " 2001: 40,\n", 169 | " 2002: 35.6,\n", 170 | " 2003: 29.3,\n", 171 | " 2004: 25.2,\n", 172 | " 2005: 25.4,\n", 173 | " 2006: 21.6,\n", 174 | " 2007: 18.8,\n", 175 | " 2008: 19,\n", 176 | " 2009: 18.4,\n", 177 | " 2010: 17.7,\n", 178 | " 2011: 17.9,\n", 179 | " 2012: 15.4,\n", 180 | " 2013: 15.5,\n", 181 | " 2014: 16.3,\n", 182 | " 2015: 19.6,\n", 183 | " 2016: 19.4,\n", 184 | " 2017: 18.9,\n", 185 | " 2018: 18.4,\n", 186 | " 2019: 18.1}" 187 | ] 188 | }, 189 | "execution_count": 93, 190 | "metadata": {}, 191 | "output_type": "execute_result" 192 | } 193 | ], 194 | "source": [ 195 | "poverty_data" 196 | ] 197 | }, 198 | { 199 | "cell_type": "code", 200 | "execution_count": 94, 201 | "metadata": { 202 | "collapsed": true 203 | }, 204 | "outputs": [], 205 | "source": [ 206 | "population = [146.6, 146.3, 145.2, 145, 144.3, 143.8, 143.2, 142.8, 142.8, 142.7, 142.9, 142.9, 143.0, 143.3, 143.7, \n", 207 | " 146.3, 146.5, 146.8, 146.9, 146.8]\n", 208 | "#численность населения России в млн человек" 209 | ] 210 | }, 211 | { 212 | "cell_type": "code", 213 | "execution_count": 95, 214 | "metadata": { 215 | "collapsed": false 216 | }, 217 | "outputs": [ 218 | { 219 | "data": { 220 | "text/plain": [ 221 | "[28.854024556616643,\n", 222 | " 27.341079972658918,\n", 223 | " 24.517906336088156,\n", 224 | " 20.20689655172414,\n", 225 | " 17.46361746361746,\n", 226 | " 17.663421418636993,\n", 227 | " 15.083798882681569,\n", 228 | " 13.165266106442578,\n", 229 | " 13.305322128851541,\n", 230 | " 12.894183601962158,\n", 231 | " 12.38628411476557,\n", 232 | " 12.526242127361789,\n", 233 | " 10.76923076923077,\n", 234 | " 10.816468946266573,\n", 235 | " 11.343075852470426,\n", 236 | " 13.397129186602871,\n", 237 | " 13.242320819112626,\n", 238 | " 12.874659400544958,\n", 239 | " 12.525527569775354,\n", 240 | " 12.329700272479565]" 241 | ] 242 | }, 243 | "execution_count": 95, 244 | "metadata": {}, 245 | "output_type": "execute_result" 246 | } 247 | ], 248 | "source": [ 249 | "poverty_level = [x/y*100 for x,y in zip(poverty, population)]\n", 250 | "poverty_level\n", 251 | "#процент бедных " 252 | ] 253 | }, 254 | { 255 | "cell_type": "code", 256 | "execution_count": 96, 257 | "metadata": { 258 | "collapsed": false 259 | }, 260 | "outputs": [ 261 | { 262 | "data": { 263 | "text/plain": [ 264 | "29" 265 | ] 266 | }, 267 | "execution_count": 96, 268 | "metadata": {}, 269 | "output_type": "execute_result" 270 | } 271 | ], 272 | "source": [ 273 | "round(28.854024556616643)" 274 | ] 275 | }, 276 | { 277 | "cell_type": "code", 278 | "execution_count": 97, 279 | "metadata": { 280 | "collapsed": false 281 | }, 282 | "outputs": [ 283 | { 284 | "data": { 285 | "text/plain": [ 286 | "[28.9,\n", 287 | " 27.3,\n", 288 | " 24.5,\n", 289 | " 20.2,\n", 290 | " 17.5,\n", 291 | " 17.7,\n", 292 | " 15.1,\n", 293 | " 13.2,\n", 294 | " 13.3,\n", 295 | " 12.9,\n", 296 | " 12.4,\n", 297 | " 12.5,\n", 298 | " 10.8,\n", 299 | " 10.8,\n", 300 | " 11.3,\n", 301 | " 13.4,\n", 302 | " 13.2,\n", 303 | " 12.9,\n", 304 | " 12.5,\n", 305 | " 12.3]" 306 | ] 307 | }, 308 | "execution_count": 97, 309 | "metadata": {}, 310 | "output_type": "execute_result" 311 | } 312 | ], 313 | "source": [ 314 | "poverty_level = [round(x, 1) for x in poverty_level]\n", 315 | "poverty_level" 316 | ] 317 | }, 318 | { 319 | "cell_type": "code", 320 | "execution_count": 98, 321 | "metadata": { 322 | "collapsed": false 323 | }, 324 | "outputs": [ 325 | { 326 | "data": { 327 | "text/plain": [ 328 | "[28.9,\n", 329 | " 27.3,\n", 330 | " 24.5,\n", 331 | " 20.2,\n", 332 | " 17.5,\n", 333 | " 17.7,\n", 334 | " 15.1,\n", 335 | " 13.2,\n", 336 | " 13.3,\n", 337 | " 12.9,\n", 338 | " 12.4,\n", 339 | " 12.5,\n", 340 | " 10.8,\n", 341 | " 10.8,\n", 342 | " 11.3,\n", 343 | " 13.4,\n", 344 | " 13.2,\n", 345 | " 12.9,\n", 346 | " 12.5,\n", 347 | " 12.3]" 348 | ] 349 | }, 350 | "execution_count": 98, 351 | "metadata": {}, 352 | "output_type": "execute_result" 353 | } 354 | ], 355 | "source": [ 356 | "p_level = []\n", 357 | "p_level_round = []\n", 358 | "for x, y in zip(poverty, population):\n", 359 | " p_level.append(x/y*100)\n", 360 | "for i in p_level:\n", 361 | " p_level_round.append(round(i, 1))\n", 362 | "p_level_round\n", 363 | "#тоже самое, но без генераторов списков" 364 | ] 365 | }, 366 | { 367 | "cell_type": "code", 368 | "execution_count": 99, 369 | "metadata": { 370 | "collapsed": false 371 | }, 372 | "outputs": [], 373 | "source": [ 374 | "poverty_percent = {x : y for x, y in zip(years,poverty_level)}" 375 | ] 376 | }, 377 | { 378 | "cell_type": "code", 379 | "execution_count": 100, 380 | "metadata": { 381 | "collapsed": false 382 | }, 383 | "outputs": [ 384 | { 385 | "data": { 386 | "text/plain": [ 387 | "{2000: 28.9,\n", 388 | " 2001: 27.3,\n", 389 | " 2002: 24.5,\n", 390 | " 2003: 20.2,\n", 391 | " 2004: 17.5,\n", 392 | " 2005: 17.7,\n", 393 | " 2006: 15.1,\n", 394 | " 2007: 13.2,\n", 395 | " 2008: 13.3,\n", 396 | " 2009: 12.9,\n", 397 | " 2010: 12.4,\n", 398 | " 2011: 12.5,\n", 399 | " 2012: 10.8,\n", 400 | " 2013: 10.8,\n", 401 | " 2014: 11.3,\n", 402 | " 2015: 13.4,\n", 403 | " 2016: 13.2,\n", 404 | " 2017: 12.9,\n", 405 | " 2018: 12.5,\n", 406 | " 2019: 12.3}" 407 | ] 408 | }, 409 | "execution_count": 100, 410 | "metadata": {}, 411 | "output_type": "execute_result" 412 | } 413 | ], 414 | "source": [ 415 | "poverty_percent" 416 | ] 417 | }, 418 | { 419 | "cell_type": "code", 420 | "execution_count": 101, 421 | "metadata": { 422 | "collapsed": false 423 | }, 424 | "outputs": [ 425 | { 426 | "data": { 427 | "text/plain": [ 428 | "[(2000, 28.9),\n", 429 | " (2001, 27.3),\n", 430 | " (2002, 24.5),\n", 431 | " (2003, 20.2),\n", 432 | " (2005, 17.7),\n", 433 | " (2004, 17.5),\n", 434 | " (2006, 15.1),\n", 435 | " (2015, 13.4),\n", 436 | " (2008, 13.3),\n", 437 | " (2016, 13.2),\n", 438 | " (2007, 13.2),\n", 439 | " (2017, 12.9),\n", 440 | " (2009, 12.9),\n", 441 | " (2018, 12.5),\n", 442 | " (2011, 12.5),\n", 443 | " (2010, 12.4),\n", 444 | " (2019, 12.3),\n", 445 | " (2014, 11.3),\n", 446 | " (2012, 10.8),\n", 447 | " (2013, 10.8)]" 448 | ] 449 | }, 450 | "execution_count": 101, 451 | "metadata": {}, 452 | "output_type": "execute_result" 453 | } 454 | ], 455 | "source": [ 456 | "sort_list = sorted(poverty_percent.items(), key=lambda x: x[1], reverse=True)\n", 457 | "sort_list" 458 | ] 459 | }, 460 | { 461 | "cell_type": "code", 462 | "execution_count": 102, 463 | "metadata": { 464 | "collapsed": false 465 | }, 466 | "outputs": [ 467 | { 468 | "data": { 469 | "text/plain": [ 470 | "[(2015, 13.4), (2016, 13.2), (2017, 12.9), (2018, 12.5), (2019, 12.3)]" 471 | ] 472 | }, 473 | "execution_count": 102, 474 | "metadata": {}, 475 | "output_type": "execute_result" 476 | } 477 | ], 478 | "source": [ 479 | "[x for x in sort_list if x[0] > 2014]" 480 | ] 481 | }, 482 | { 483 | "cell_type": "code", 484 | "execution_count": 103, 485 | "metadata": { 486 | "collapsed": false 487 | }, 488 | "outputs": [ 489 | { 490 | "data": { 491 | "text/plain": [ 492 | "[(2015, 13.4), (2016, 13.2)]" 493 | ] 494 | }, 495 | "execution_count": 103, 496 | "metadata": {}, 497 | "output_type": "execute_result" 498 | } 499 | ], 500 | "source": [ 501 | "[x for x in sort_list if x[0] > 2014 and x[1] > 13]" 502 | ] 503 | }, 504 | { 505 | "cell_type": "code", 506 | "execution_count": 107, 507 | "metadata": { 508 | "collapsed": false 509 | }, 510 | "outputs": [ 511 | { 512 | "data": { 513 | "text/plain": [ 514 | "13" 515 | ] 516 | }, 517 | "execution_count": 107, 518 | "metadata": {}, 519 | "output_type": "execute_result" 520 | } 521 | ], 522 | "source": [ 523 | "len([x for x in sort_list if x[1] < 13.5])" 524 | ] 525 | } 526 | ], 527 | "metadata": { 528 | "anaconda-cloud": {}, 529 | "kernelspec": { 530 | "display_name": "Python [Root]", 531 | "language": "python", 532 | "name": "Python [Root]" 533 | }, 534 | "language_info": { 535 | "codemirror_mode": { 536 | "name": "ipython", 537 | "version": 3 538 | }, 539 | "file_extension": ".py", 540 | "mimetype": "text/x-python", 541 | "name": "python", 542 | "nbconvert_exporter": "python", 543 | "pygments_lexer": "ipython3", 544 | "version": "3.5.2" 545 | } 546 | }, 547 | "nbformat": 4, 548 | "nbformat_minor": 0 549 | } 550 | -------------------------------------------------------------------------------- /Расчет расстояния между геокоординатами по прямой в Python (1).py: -------------------------------------------------------------------------------- 1 | #!/usr/bin/env python 2 | # coding: utf-8 3 | 4 | # ## Расчет расстояния между геокоординатами по прямой в Python 5 | 6 | # Считаем расстояния между объектами по их координатам. В данном примере будем считать расстояния от населенных пунктов до школ и выбирать ближайшую школу. 7 | # 8 | # Важно: расстояния считаются по прямой, без учета дорог, гор, рек и пр., поэтому дают только общее представление о дальности объектов. Чтобы точно рассчитать дистанцию и время в пути по дорогам, можно воспользоваться API матрицы расстояний Яндекс.Карт (платно, либо можно попробовать попросить бесплатно в исследовательских и научных целях по индивидуальному запросу) или OSRM — Open Sourced Routing Machine (бесплатно) 9 | 10 | # ### 1. Скачивание данных 11 | 12 | # 1. Данные по населенным пунктам скачиваем на сайте ИНИД (Инфраструктура научно-исследовательских данных) https://www.data-in.ru/data-catalog/datasets/160/ 13 | # 2. Данные по школам — парсингом сайта https://schoolotzyv.ru/schools/9-russia/ (данные доступны в формате json по ссылке https://drive.google.com/file/d/18PQTD4upgjS-zfcPgKWEj1_zWJz7RL64/view?usp=sharing) По некоторым регионам на нем есть не все школы. Можно дополнить данными с сайтов https://arhangelsk.fulledu.ru/, https://russiaedu.ru/, набора открытых данных с лицензиями Рособрнадзора (требуется парсинг xml) http://obrnadzor.gov.ru/otkrytoe-pravitelstvo/opendata/7701537808-fbdrl/ и других источников. 14 | 15 | # ### 2. Загрузка библиотек 16 | 17 | # In[2]: 18 | 19 | 20 | import pandas as pd # будем работать в pandas 21 | import numpy as np # numpy и sklearn для математических расчетов и использования формул 22 | import sklearn.neighbors 23 | import json # для работы с файлами в формате json 24 | 25 | 26 | # ### 3. Загрузка и подготовка данных 27 | 28 | # In[8]: 29 | 30 | 31 | # загружаем датасет со школами в pandas 32 | 33 | with open('/Users/me/Downloads/schoolotzyv.json', 'r') as read_file: 34 | otzyv = json.load(read_file) 35 | 36 | 37 | # In[83]: 38 | 39 | 40 | otzyv = pd.DataFrame(otzyv) 41 | otzyv 42 | 43 | 44 | # In[84]: 45 | 46 | 47 | # нам нужно узнать регионы, для этого выбираем любую ссылку, переходим по ней и смотрим, как в ссылках зашит нужный нам регион 48 | 49 | otzyv.loc[1,'url'] 50 | 51 | 52 | # In[85]: 53 | 54 | 55 | # для примера возьмем Нижегородскую область (если взять всю Россию, считаться будет долго) 56 | # она в ссылках на школы помечена как "146-nizhegorodskaya" 57 | # выбираем только те строки, которые содержат такую запись 58 | # подробнее о том как фильтровать датафреймы в pandas — в уроке https://istories.media/workshops/2021/03/05/python-biblioteka-pandas-chast-1/ 59 | 60 | 61 | schools_nn = otzyv[otzyv['url'].str.contains('146-nizhegorodskaya')] 62 | len(schools_nn) 63 | 64 | 65 | # In[65]: 66 | 67 | 68 | schools_nn 69 | 70 | 71 | # In[ ]: 72 | 73 | 74 | 75 | 76 | 77 | # In[86]: 78 | 79 | 80 | # поскольку мы выбрали только некоторые строки, индексы датафрейма сбились 81 | # чтобы они опять начинались с нуля, нужно их сбросить методом reset_index 82 | 83 | schools_nn = schools_nn.reset_index(drop = True) 84 | 85 | 86 | # In[66]: 87 | 88 | 89 | # загружаем датасет с населенными пунктами 90 | 91 | places = pd.read_csv('/Users/me/Downloads/places.csv') 92 | places 93 | 94 | 95 | # In[78]: 96 | 97 | 98 | # для примера выбираем только Нижегородскую область и только один район — например, Воскресенский 99 | # (чтобы точно всё быстро посчиталось на небольшом объеме данных) 100 | 101 | places_voskresensk = places[(places['region'] == 'Нижегородская область') & 102 | (places['municipality'] == 'Воскресенский район')] 103 | len(places_voskresensk) 104 | 105 | 106 | # In[79]: 107 | 108 | 109 | # опять обновляем индексы, чтобы шли с нуля 110 | 111 | places_voskresensk = places_voskresensk.reset_index(drop = True) 112 | 113 | 114 | # ### 4. Создание словарей 115 | 116 | # Прежде чем считать расстояния, нам понадобится создать два словаря — с населенными пунктами и со школами. Это нужно, чтобы в дальнейшем мы могли сопоставить разные датафреймы по какому-то уникальному параметру, доставать и добавлять нужные нам данные. Это нам пригодится на последних этапах. 117 | # 118 | # Для населенных пунктов таким уникальным параметром будет код ОКТМО (Общероссийского классификатора территорий муниципальных образований) 119 | # 120 | # Перед этим нам нужно убедиться, что: 121 | # 1) Во всех нужных нам столбцахуказан правильный тип данных 122 | # 123 | # 2) Удалить дубликаты в тех столбцах, которые будут уникальным ключом для словаря (для населенных пунктов это поле oktmo, для школ — url, ссылка) 124 | 125 | # In[80]: 126 | 127 | 128 | # смотрим какой тип данный в столбце 'oktmo' 129 | 130 | places_voskresensk['oktmo'].dtype 131 | 132 | 133 | # In[81]: 134 | 135 | 136 | # float, а нам нужны строки, поэтому меняем сначала на integer, а затем на str 137 | 138 | 139 | # In[17]: 140 | 141 | 142 | places_voskresensk['oktmo'] = places_voskresensk['oktmo'].astype('int').astype('str') 143 | places_voskresensk['oktmo'].dtype 144 | 145 | 146 | # In[73]: 147 | 148 | 149 | # удаляем дубликты и сбрасываем индексы 150 | 151 | places_voskresensk[places_voskresensk['oktmo'].duplicated()] 152 | 153 | 154 | # In[29]: 155 | 156 | 157 | places_voskresensk = places_voskresensk[~places_voskresensk['oktmo'].duplicated()] 158 | places_voskresensk = places_voskresensk.reset_index(drop = True) 159 | 160 | 161 | # In[30]: 162 | 163 | 164 | # собираем датафрейм с населенными пунктами в словарь 165 | 166 | 167 | places_by_oktmo = {} # пустой словарь 168 | for i in range(len(places_voskresensk)): # i это индекс, порядковый номер строки 169 | el = places_voskresensk.loc[i] # записываем в переменную el строку с индексом i 170 | places_by_oktmo[el['oktmo']] = el # создаем словарь, где ключом будет код октмо, 171 | # а значением — соответствующая ему строка датафрейма 172 | len(places_voskresensk) 173 | 174 | 175 | # In[ ]: 176 | 177 | 178 | # (чтобы посмотреть, что содержится в el, попробуйте вывести на экран в отдельной ячейке places_voskresensk.loc[1] (или другое число)) 179 | 180 | 181 | # In[72]: 182 | 183 | 184 | places_voskresensk.loc[1] 185 | 186 | 187 | # In[31]: 188 | 189 | 190 | places_by_oktmo['22622416166'] # пример того что выдает словарь по ключу - коду октмо 191 | 192 | 193 | # In[ ]: 194 | 195 | 196 | # переходим к датафрейму со школами 197 | # сначала меняем тип данных в столбцах с широтой и долгой — были строки, а нужны числа (float) 198 | 199 | 200 | # In[87]: 201 | 202 | 203 | schools_nn['geo_lat'].dtype 204 | 205 | 206 | # In[33]: 207 | 208 | 209 | schools_nn['geo_lat'] = schools_nn['geo_lat'].astype('float') 210 | schools_nn['geo_long'] = schools_nn['geo_long'].astype('float') 211 | print(schools_nn['geo_lat'].dtype) 212 | print(schools_nn['geo_long'].dtype) 213 | 214 | 215 | # In[26]: 216 | 217 | 218 | # удаляем дубликаты 219 | schools_nn[schools_nn['url'].duplicated()] 220 | 221 | 222 | # In[35]: 223 | 224 | 225 | schools_nn = schools_nn[~schools_nn['url'].duplicated()] 226 | schools_nn = schools_nn.reset_index(drop = True) 227 | 228 | 229 | # In[ ]: 230 | 231 | 232 | # собираем такой же словарь, как с населенными пунктами, только ключом будет url школы 233 | 234 | 235 | # In[36]: 236 | 237 | 238 | schools_by_url = {} 239 | for i in range(len(schools_nn)): 240 | el = schools_nn.loc[i] 241 | schools_by_url[el['url']] = el 242 | len(schools_by_url) 243 | 244 | 245 | # ### 5. Расчет матрицы расстояний 246 | 247 | # Переходим к расчету расстояний между каждым населенным пунктом и каждой школой (матрица расстояний). За основу взят туториал Dana Lindquist https://medium.com/@danalindquist/finding-the-distance-between-two-lists-of-geographic-coordinates-9ace7e43bb2f 248 | 249 | # In[37]: 250 | 251 | 252 | # переводим координаты из градусов в радианы, потому что математические формулы обычно требуют 253 | # значения в радианах, а не в градусах. 254 | # делаем это с помощью библиотеки numpy 255 | 256 | schools_nn[['lat_radians_A','long_radians_A']] = ( 257 | np.radians(schools_nn.loc[:,['geo_lat','geo_long']]) 258 | ) 259 | places_voskresensk[['lat_radians_B','long_radians_B']] = ( 260 | np.radians(places_voskresensk.loc[:,['latitude_dd','longitude_dd']]) 261 | ) 262 | 263 | 264 | # In[38]: 265 | 266 | 267 | # считаем расстояния с помощью формулы из библиотеки scikit-learn 268 | # она вычисляет гаверсинусное расстояние, то есть представляет форму Земли как идеальную сферу (а не геоид, 269 | # как на самом деле), и за счет этого обеспечивает быстрые вычисления 270 | # если требуется измерение в км, то нужно умножить на 6371, если в милях — на 3959 271 | 272 | 273 | dist = sklearn.neighbors.DistanceMetric.get_metric('haversine') 274 | dist_matrix = (dist.pairwise 275 | (schools_nn[['lat_radians_A','long_radians_A']], 276 | places_voskresensk[['lat_radians_B','long_radians_B']])*6371 277 | ) 278 | 279 | 280 | # In[40]: 281 | 282 | 283 | # создаем матрицу расстояний — таблицу, в которой индексами будут url школ, 284 | # колонками - октмо населенных пунктов, а в ячейках будет расстояние от каждого населенного пункта до каждой школы 285 | 286 | df_dist_matrix = ( 287 | pd.DataFrame(dist_matrix,index=schools_nn['url'], 288 | columns=places_voskresensk['oktmo']) 289 | ) 290 | 291 | 292 | # In[41]: 293 | 294 | 295 | df_dist_matrix 296 | 297 | 298 | # In[42]: 299 | 300 | 301 | # нам нужно расстояние от населенных пунктов до школ, а не наоборот, поэтому транспонируем таблицу — 302 | # меняем индексы и колонки местами 303 | 304 | 305 | # In[43]: 306 | 307 | 308 | 309 | 310 | df_dist_matrix = df_dist_matrix.T 311 | df_dist_matrix 312 | 313 | 314 | # ### 6. Выбор ближайшего объекта 315 | 316 | # Выбираем ближайшую школу к каждому населенному пункту. 317 | 318 | # In[44]: 319 | 320 | 321 | # дальше мы сравниваем каждое значение в строке с предыдущим, чтобы проверить, больше оно или меньше. Меньшее записываем в переменную 322 | 323 | schools_and_min_value_by_oktmo = {} # пустой словарь, где ключом будет код октмо, 324 | #значениями — минимальное расстояние 325 | 326 | columns = df_dist_matrix.columns # список с названиями колонок (url школ) 327 | for current_oktmo in df_dist_matrix.index: 328 | distances = df_dist_matrix.loc[current_oktmo] 329 | min_distance = None # нужно для начала отсчета, чтобы было с чем сравнивать первое значение в строке 330 | min_j = None 331 | for j in range(len(columns)): 332 | if min_distance is None or min_distance > distances[j]: # сравниваем каждое значение в строке с 333 | # предыдущим, чтобы проверить, больше оно или меньше. Меньшее записываем в переменную 334 | min_distance = distances[j] 335 | min_j = j 336 | schools_and_min_value_by_oktmo[current_oktmo] = (columns[min_j], min_distance) 337 | # заполняем словарь: ключ — код октмо, значение — url ближайшей школы и расстояние до нее 338 | len(schools_and_min_value_by_oktmo) 339 | 340 | 341 | # In[45]: 342 | 343 | 344 | schools_and_min_value_by_oktmo['22622440151'] # пример того, что выдает словарь по коду октмо 345 | 346 | 347 | # In[50]: 348 | 349 | 350 | # добавляем колонки с мин расстоянием и url школы в датафрейм places_voskresensk (с населенными пунктами) 351 | # создаем списки с полученными выше url и км, чтобы затем добавить их к датафрейму с населенными пунктами 352 | 353 | school_url_column = [] 354 | min_distance_column = [] 355 | for oktmo in places_voskresensk['oktmo']: 356 | (url, distns) = schools_and_min_value_by_oktmo[oktmo] 357 | school_url_column.append(url) # берем из созданного выше словаря url ближайшей школы(url) и км до нее (distns), 358 | # добавляем их в словари в том порядке, в каком соответствующие им коды октмо расположены в датафрейме places_voskresensk 359 | min_distance_column.append(distns) 360 | places_voskresensk['school_url_column'] = school_url_column # добавляем новую колонку с url ближайших школ 361 | places_voskresensk['min_distance_column'] = min_distance_column # добавляем новую колонку с км до этих школ 362 | len(places_voskresensk) 363 | 364 | 365 | # In[46]: 366 | 367 | 368 | places_voskresensk 369 | 370 | 371 | # In[52]: 372 | 373 | 374 | # из словаря со школами достаем названия школ по url и тоже добавляем их к датафрейму places_voskresensk новой колонкой 375 | 376 | 377 | school_name = [] 378 | 379 | for url in places_voskresensk['school_url_column']: 380 | school_name.append(schools_by_url[url]['text']) 381 | places_voskresensk['school_name'] = school_name 382 | 383 | 384 | # In[54]: 385 | 386 | 387 | # в конце появились 3 новые колонки — url ближайшей школы, сколько до нее км, название школы 388 | 389 | places_voskresensk 390 | 391 | 392 | # In[55]: 393 | 394 | 395 | # сохраним полученный результат в csv 396 | 397 | 398 | places_voskresensk.to_csv('voskresensk_closest_schools.csv') 399 | 400 | 401 | # ### 7. Анализ данных 402 | 403 | # In[56]: 404 | 405 | 406 | # Дальше можно анализировать данные. 407 | # Например, выбрать 15 наиболе удаленных от школ объектов методов nlarest 408 | # подробнее об nlargest и nsmallest https://istories.media/workshops/2021/03/19/python-biblioteka-pandas-chast-3/ 409 | 410 | 411 | # In[57]: 412 | 413 | 414 | places_voskresensk.nlargest(15,'min_distance_column') 415 | 416 | 417 | # In[60]: 418 | 419 | 420 | # или посчитать, сколько детей в Воскресенском районе Нижегородской обл. живут дальше 5 км от школы 421 | 422 | km5 = places_voskresensk[places_voskresensk['min_distance_column'] > 5] 423 | print(places_voskresensk['children'].sum()) # всего детей 424 | print(km5['children'].sum()) # живут дальше 5 км 425 | 426 | 427 | # In[61]: 428 | 429 | 430 | # или среднее расстояние от населенного пункта до школы 431 | 432 | places_voskresensk['min_distance_column'].mean() 433 | 434 | 435 | # Готово, спасибо, что дошли до конца! 436 | -------------------------------------------------------------------------------- /Урок 2. Строки.ipynb: -------------------------------------------------------------------------------- 1 | { 2 | "cells": [ 3 | { 4 | "cell_type": "markdown", 5 | "metadata": {}, 6 | "source": [ 7 | "# Строки" 8 | ] 9 | }, 10 | { 11 | "cell_type": "markdown", 12 | "metadata": {}, 13 | "source": [ 14 | "Как выглядят строки" 15 | ] 16 | }, 17 | { 18 | "cell_type": "code", 19 | "execution_count": 2, 20 | "metadata": {}, 21 | "outputs": [], 22 | "source": [ 23 | "a='важные истории' #строки заключены в кавычки" 24 | ] 25 | }, 26 | { 27 | "cell_type": "code", 28 | "execution_count": 3, 29 | "metadata": {}, 30 | "outputs": [], 31 | "source": [ 32 | "b='0123456789'" 33 | ] 34 | }, 35 | { 36 | "cell_type": "code", 37 | "execution_count": 4, 38 | "metadata": {}, 39 | "outputs": [ 40 | { 41 | "data": { 42 | "text/plain": [ 43 | "str" 44 | ] 45 | }, 46 | "execution_count": 4, 47 | "metadata": {}, 48 | "output_type": "execute_result" 49 | } 50 | ], 51 | "source": [ 52 | "type(a)" 53 | ] 54 | }, 55 | { 56 | "cell_type": "code", 57 | "execution_count": 5, 58 | "metadata": {}, 59 | "outputs": [ 60 | { 61 | "data": { 62 | "text/plain": [ 63 | "str" 64 | ] 65 | }, 66 | "execution_count": 5, 67 | "metadata": {}, 68 | "output_type": "execute_result" 69 | } 70 | ], 71 | "source": [ 72 | "type(b)" 73 | ] 74 | }, 75 | { 76 | "cell_type": "markdown", 77 | "metadata": {}, 78 | "source": [ 79 | "# Сложение строк" 80 | ] 81 | }, 82 | { 83 | "cell_type": "code", 84 | "execution_count": 6, 85 | "metadata": {}, 86 | "outputs": [], 87 | "source": [ 88 | "a='важные'\n", 89 | "b='истории'" 90 | ] 91 | }, 92 | { 93 | "cell_type": "code", 94 | "execution_count": 7, 95 | "metadata": {}, 96 | "outputs": [ 97 | { 98 | "data": { 99 | "text/plain": [ 100 | "'важныеистории'" 101 | ] 102 | }, 103 | "execution_count": 7, 104 | "metadata": {}, 105 | "output_type": "execute_result" 106 | } 107 | ], 108 | "source": [ 109 | "c=a+b\n", 110 | "c" 111 | ] 112 | }, 113 | { 114 | "cell_type": "code", 115 | "execution_count": 8, 116 | "metadata": {}, 117 | "outputs": [ 118 | { 119 | "data": { 120 | "text/plain": [ 121 | "'важные истории'" 122 | ] 123 | }, 124 | "execution_count": 8, 125 | "metadata": {}, 126 | "output_type": "execute_result" 127 | } 128 | ], 129 | "source": [ 130 | "a='важные '\n", 131 | "b='истории'\n", 132 | "c=a+b\n", 133 | "c" 134 | ] 135 | }, 136 | { 137 | "cell_type": "code", 138 | "execution_count": 9, 139 | "metadata": {}, 140 | "outputs": [ 141 | { 142 | "data": { 143 | "text/plain": [ 144 | "'12'" 145 | ] 146 | }, 147 | "execution_count": 9, 148 | "metadata": {}, 149 | "output_type": "execute_result" 150 | } 151 | ], 152 | "source": [ 153 | "a='1'\n", 154 | "b='2'\n", 155 | "c=a+b\n", 156 | "c" 157 | ] 158 | }, 159 | { 160 | "cell_type": "markdown", 161 | "metadata": {}, 162 | "source": [ 163 | "# Дублирование строк" 164 | ] 165 | }, 166 | { 167 | "cell_type": "code", 168 | "execution_count": 10, 169 | "metadata": {}, 170 | "outputs": [ 171 | { 172 | "data": { 173 | "text/plain": [ 174 | "'важные важные важные '" 175 | ] 176 | }, 177 | "execution_count": 10, 178 | "metadata": {}, 179 | "output_type": "execute_result" 180 | } 181 | ], 182 | "source": [ 183 | "a='важные '\n", 184 | "c=a*3\n", 185 | "c" 186 | ] 187 | }, 188 | { 189 | "cell_type": "markdown", 190 | "metadata": {}, 191 | "source": [ 192 | "# Длина строк" 193 | ] 194 | }, 195 | { 196 | "cell_type": "code", 197 | "execution_count": 11, 198 | "metadata": {}, 199 | "outputs": [ 200 | { 201 | "data": { 202 | "text/plain": [ 203 | "14" 204 | ] 205 | }, 206 | "execution_count": 11, 207 | "metadata": {}, 208 | "output_type": "execute_result" 209 | } 210 | ], 211 | "source": [ 212 | "a='важные истории' #14 символов\n", 213 | "len(a)" 214 | ] 215 | }, 216 | { 217 | "cell_type": "markdown", 218 | "metadata": {}, 219 | "source": [ 220 | "# Индексы" 221 | ] 222 | }, 223 | { 224 | "cell_type": "code", 225 | "execution_count": 12, 226 | "metadata": {}, 227 | "outputs": [ 228 | { 229 | "data": { 230 | "text/plain": [ 231 | "0" 232 | ] 233 | }, 234 | "execution_count": 12, 235 | "metadata": {}, 236 | "output_type": "execute_result" 237 | } 238 | ], 239 | "source": [ 240 | "a.index('в')" 241 | ] 242 | }, 243 | { 244 | "cell_type": "code", 245 | "execution_count": 13, 246 | "metadata": {}, 247 | "outputs": [ 248 | { 249 | "data": { 250 | "text/plain": [ 251 | "1" 252 | ] 253 | }, 254 | "execution_count": 13, 255 | "metadata": {}, 256 | "output_type": "execute_result" 257 | } 258 | ], 259 | "source": [ 260 | "a.index('а')" 261 | ] 262 | }, 263 | { 264 | "cell_type": "code", 265 | "execution_count": 14, 266 | "metadata": {}, 267 | "outputs": [ 268 | { 269 | "data": { 270 | "text/plain": [ 271 | "7" 272 | ] 273 | }, 274 | "execution_count": 14, 275 | "metadata": {}, 276 | "output_type": "execute_result" 277 | } 278 | ], 279 | "source": [ 280 | "a.index('и')" 281 | ] 282 | }, 283 | { 284 | "cell_type": "code", 285 | "execution_count": 15, 286 | "metadata": {}, 287 | "outputs": [ 288 | { 289 | "data": { 290 | "text/plain": [ 291 | "'в'" 292 | ] 293 | }, 294 | "execution_count": 15, 295 | "metadata": {}, 296 | "output_type": "execute_result" 297 | } 298 | ], 299 | "source": [ 300 | "a[0]" 301 | ] 302 | }, 303 | { 304 | "cell_type": "code", 305 | "execution_count": 16, 306 | "metadata": {}, 307 | "outputs": [ 308 | { 309 | "data": { 310 | "text/plain": [ 311 | "'а'" 312 | ] 313 | }, 314 | "execution_count": 16, 315 | "metadata": {}, 316 | "output_type": "execute_result" 317 | } 318 | ], 319 | "source": [ 320 | "a[1]" 321 | ] 322 | }, 323 | { 324 | "cell_type": "code", 325 | "execution_count": 17, 326 | "metadata": {}, 327 | "outputs": [ 328 | { 329 | "data": { 330 | "text/plain": [ 331 | "'р'" 332 | ] 333 | }, 334 | "execution_count": 17, 335 | "metadata": {}, 336 | "output_type": "execute_result" 337 | } 338 | ], 339 | "source": [ 340 | "a[-3]" 341 | ] 342 | }, 343 | { 344 | "cell_type": "markdown", 345 | "metadata": {}, 346 | "source": [ 347 | "# Извлечение среза" 348 | ] 349 | }, 350 | { 351 | "cell_type": "code", 352 | "execution_count": 18, 353 | "metadata": {}, 354 | "outputs": [], 355 | "source": [ 356 | "#a[x:y] x - индекс 1 символа, y – индекс последнего символа + 1" 357 | ] 358 | }, 359 | { 360 | "cell_type": "code", 361 | "execution_count": 19, 362 | "metadata": {}, 363 | "outputs": [ 364 | { 365 | "data": { 366 | "text/plain": [ 367 | "'важные'" 368 | ] 369 | }, 370 | "execution_count": 19, 371 | "metadata": {}, 372 | "output_type": "execute_result" 373 | } 374 | ], 375 | "source": [ 376 | "a[0:6]" 377 | ] 378 | }, 379 | { 380 | "cell_type": "code", 381 | "execution_count": 20, 382 | "metadata": {}, 383 | "outputs": [ 384 | { 385 | "data": { 386 | "text/plain": [ 387 | "5" 388 | ] 389 | }, 390 | "execution_count": 20, 391 | "metadata": {}, 392 | "output_type": "execute_result" 393 | } 394 | ], 395 | "source": [ 396 | "a.index('е')" 397 | ] 398 | }, 399 | { 400 | "cell_type": "code", 401 | "execution_count": 21, 402 | "metadata": {}, 403 | "outputs": [ 404 | { 405 | "data": { 406 | "text/plain": [ 407 | "'важные истории'" 408 | ] 409 | }, 410 | "execution_count": 21, 411 | "metadata": {}, 412 | "output_type": "execute_result" 413 | } 414 | ], 415 | "source": [ 416 | "a[:]" 417 | ] 418 | }, 419 | { 420 | "cell_type": "code", 421 | "execution_count": 22, 422 | "metadata": {}, 423 | "outputs": [ 424 | { 425 | "data": { 426 | "text/plain": [ 427 | "'истории'" 428 | ] 429 | }, 430 | "execution_count": 22, 431 | "metadata": {}, 432 | "output_type": "execute_result" 433 | } 434 | ], 435 | "source": [ 436 | "a[7:]" 437 | ] 438 | }, 439 | { 440 | "cell_type": "code", 441 | "execution_count": 23, 442 | "metadata": {}, 443 | "outputs": [ 444 | { 445 | "data": { 446 | "text/plain": [ 447 | "'важные'" 448 | ] 449 | }, 450 | "execution_count": 23, 451 | "metadata": {}, 452 | "output_type": "execute_result" 453 | } 454 | ], 455 | "source": [ 456 | "a[:6]" 457 | ] 458 | }, 459 | { 460 | "cell_type": "markdown", 461 | "metadata": {}, 462 | "source": [ 463 | "# Шаг среза" 464 | ] 465 | }, 466 | { 467 | "cell_type": "code", 468 | "execution_count": 24, 469 | "metadata": {}, 470 | "outputs": [], 471 | "source": [ 472 | "a='0123456789'" 473 | ] 474 | }, 475 | { 476 | "cell_type": "code", 477 | "execution_count": 25, 478 | "metadata": {}, 479 | "outputs": [ 480 | { 481 | "data": { 482 | "text/plain": [ 483 | "'02468'" 484 | ] 485 | }, 486 | "execution_count": 25, 487 | "metadata": {}, 488 | "output_type": "execute_result" 489 | } 490 | ], 491 | "source": [ 492 | "a[0:10:2]" 493 | ] 494 | }, 495 | { 496 | "cell_type": "markdown", 497 | "metadata": {}, 498 | "source": [ 499 | "# Замена шаблона" 500 | ] 501 | }, 502 | { 503 | "cell_type": "code", 504 | "execution_count": 26, 505 | "metadata": {}, 506 | "outputs": [], 507 | "source": [ 508 | "a='важные истории'" 509 | ] 510 | }, 511 | { 512 | "cell_type": "code", 513 | "execution_count": 27, 514 | "metadata": {}, 515 | "outputs": [ 516 | { 517 | "data": { 518 | "text/plain": [ 519 | "'грустные истории'" 520 | ] 521 | }, 522 | "execution_count": 27, 523 | "metadata": {}, 524 | "output_type": "execute_result" 525 | } 526 | ], 527 | "source": [ 528 | "b=a.replace('важные','грустные')\n", 529 | "b" 530 | ] 531 | }, 532 | { 533 | "cell_type": "markdown", 534 | "metadata": {}, 535 | "source": [ 536 | "# Изменение регистра" 537 | ] 538 | }, 539 | { 540 | "cell_type": "code", 541 | "execution_count": 28, 542 | "metadata": {}, 543 | "outputs": [ 544 | { 545 | "data": { 546 | "text/plain": [ 547 | "'ВАЖНЫЕ ИСТОРИИ'" 548 | ] 549 | }, 550 | "execution_count": 28, 551 | "metadata": {}, 552 | "output_type": "execute_result" 553 | } 554 | ], 555 | "source": [ 556 | "b=a.upper()\n", 557 | "b" 558 | ] 559 | }, 560 | { 561 | "cell_type": "code", 562 | "execution_count": 29, 563 | "metadata": {}, 564 | "outputs": [ 565 | { 566 | "data": { 567 | "text/plain": [ 568 | "'важные истории'" 569 | ] 570 | }, 571 | "execution_count": 29, 572 | "metadata": {}, 573 | "output_type": "execute_result" 574 | } 575 | ], 576 | "source": [ 577 | "c=b.lower()\n", 578 | "c" 579 | ] 580 | }, 581 | { 582 | "cell_type": "markdown", 583 | "metadata": {}, 584 | "source": [ 585 | "# Разделение строк" 586 | ] 587 | }, 588 | { 589 | "cell_type": "code", 590 | "execution_count": 30, 591 | "metadata": {}, 592 | "outputs": [ 593 | { 594 | "data": { 595 | "text/plain": [ 596 | "['важные', 'истории']" 597 | ] 598 | }, 599 | "execution_count": 30, 600 | "metadata": {}, 601 | "output_type": "execute_result" 602 | } 603 | ], 604 | "source": [ 605 | "b=a.split()\n", 606 | "b" 607 | ] 608 | }, 609 | { 610 | "cell_type": "code", 611 | "execution_count": 31, 612 | "metadata": {}, 613 | "outputs": [ 614 | { 615 | "data": { 616 | "text/plain": [ 617 | "['в.а.ж.н.ы.е']" 618 | ] 619 | }, 620 | "execution_count": 31, 621 | "metadata": {}, 622 | "output_type": "execute_result" 623 | } 624 | ], 625 | "source": [ 626 | "a='в.а.ж.н.ы.е'\n", 627 | "b=a.split()\n", 628 | "b" 629 | ] 630 | }, 631 | { 632 | "cell_type": "code", 633 | "execution_count": 32, 634 | "metadata": {}, 635 | "outputs": [ 636 | { 637 | "data": { 638 | "text/plain": [ 639 | "['в', 'а', 'ж', 'н', 'ы', 'е']" 640 | ] 641 | }, 642 | "execution_count": 32, 643 | "metadata": {}, 644 | "output_type": "execute_result" 645 | } 646 | ], 647 | "source": [ 648 | "b=a.split('.')\n", 649 | "b" 650 | ] 651 | }, 652 | { 653 | "cell_type": "code", 654 | "execution_count": 33, 655 | "metadata": {}, 656 | "outputs": [ 657 | { 658 | "data": { 659 | "text/plain": [ 660 | "list" 661 | ] 662 | }, 663 | "execution_count": 33, 664 | "metadata": {}, 665 | "output_type": "execute_result" 666 | } 667 | ], 668 | "source": [ 669 | "type(b)" 670 | ] 671 | } 672 | ], 673 | "metadata": { 674 | "kernelspec": { 675 | "display_name": "Python 3", 676 | "language": "python", 677 | "name": "python3" 678 | }, 679 | "language_info": { 680 | "codemirror_mode": { 681 | "name": "ipython", 682 | "version": 3 683 | }, 684 | "file_extension": ".py", 685 | "mimetype": "text/x-python", 686 | "name": "python", 687 | "nbconvert_exporter": "python", 688 | "pygments_lexer": "ipython3", 689 | "version": "3.8.3" 690 | } 691 | }, 692 | "nbformat": 4, 693 | "nbformat_minor": 4 694 | } 695 | -------------------------------------------------------------------------------- /Урок 7. Кортежи и множества.ipynb: -------------------------------------------------------------------------------- 1 | { 2 | "cells": [ 3 | { 4 | "cell_type": "markdown", 5 | "metadata": {}, 6 | "source": [ 7 | "## Кортежи (Tuples)" 8 | ] 9 | }, 10 | { 11 | "cell_type": "code", 12 | "execution_count": 1, 13 | "metadata": { 14 | "collapsed": false 15 | }, 16 | "outputs": [ 17 | { 18 | "name": "stdout", 19 | "output_type": "stream", 20 | "text": [ 21 | "[1, 2, 4, 5, 6, 7, 8, 9, 10]\n" 22 | ] 23 | } 24 | ], 25 | "source": [ 26 | "my_list = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]\n", 27 | "my_list.remove(3)\n", 28 | "print(my_list)" 29 | ] 30 | }, 31 | { 32 | "cell_type": "code", 33 | "execution_count": 2, 34 | "metadata": { 35 | "collapsed": false 36 | }, 37 | "outputs": [ 38 | { 39 | "ename": "AttributeError", 40 | "evalue": "'tuple' object has no attribute 'remove'", 41 | "output_type": "error", 42 | "traceback": [ 43 | "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", 44 | "\u001b[0;31mAttributeError\u001b[0m Traceback (most recent call last)", 45 | "\u001b[0;32m\u001b[0m in \u001b[0;36m\u001b[0;34m()\u001b[0m\n\u001b[1;32m 1\u001b[0m \u001b[0mmy_tuple\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;34m(\u001b[0m\u001b[0;36m1\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;36m2\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;36m3\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;36m4\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;36m5\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;36m6\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;36m7\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;36m8\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;36m9\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;36m10\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m----> 2\u001b[0;31m \u001b[0mmy_tuple\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mremove\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;36m3\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 3\u001b[0m \u001b[0mprint\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mmy_tuple\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", 46 | "\u001b[0;31mAttributeError\u001b[0m: 'tuple' object has no attribute 'remove'" 47 | ] 48 | } 49 | ], 50 | "source": [ 51 | "my_tuple = (1, 2, 3, 4, 5, 6, 7, 8, 9, 10)\n", 52 | "my_tuple.remove(3)\n", 53 | "print(my_tuple)" 54 | ] 55 | }, 56 | { 57 | "cell_type": "code", 58 | "execution_count": 3, 59 | "metadata": { 60 | "collapsed": false 61 | }, 62 | "outputs": [ 63 | { 64 | "data": { 65 | "text/plain": [ 66 | "1" 67 | ] 68 | }, 69 | "execution_count": 3, 70 | "metadata": {}, 71 | "output_type": "execute_result" 72 | } 73 | ], 74 | "source": [ 75 | "my_tuple[0]" 76 | ] 77 | }, 78 | { 79 | "cell_type": "code", 80 | "execution_count": 4, 81 | "metadata": { 82 | "collapsed": false 83 | }, 84 | "outputs": [ 85 | { 86 | "data": { 87 | "text/plain": [ 88 | "(2, 3)" 89 | ] 90 | }, 91 | "execution_count": 4, 92 | "metadata": {}, 93 | "output_type": "execute_result" 94 | } 95 | ], 96 | "source": [ 97 | "my_tuple[1:3]" 98 | ] 99 | }, 100 | { 101 | "cell_type": "code", 102 | "execution_count": 5, 103 | "metadata": { 104 | "collapsed": false 105 | }, 106 | "outputs": [ 107 | { 108 | "data": { 109 | "text/plain": [ 110 | "1" 111 | ] 112 | }, 113 | "execution_count": 5, 114 | "metadata": {}, 115 | "output_type": "execute_result" 116 | } 117 | ], 118 | "source": [ 119 | "my_tuple.count(3)" 120 | ] 121 | }, 122 | { 123 | "cell_type": "code", 124 | "execution_count": 6, 125 | "metadata": { 126 | "collapsed": false 127 | }, 128 | "outputs": [ 129 | { 130 | "ename": "NameError", 131 | "evalue": "name 'my_tuple' is not defined", 132 | "output_type": "error", 133 | "traceback": [ 134 | "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", 135 | "\u001b[0;31mNameError\u001b[0m Traceback (most recent call last)", 136 | "\u001b[0;32m\u001b[0m in \u001b[0;36m\u001b[0;34m()\u001b[0m\n\u001b[1;32m 1\u001b[0m \u001b[0;32mdel\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mmy_tuple\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m----> 2\u001b[0;31m \u001b[0mprint\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mmy_tuple\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m", 137 | "\u001b[0;31mNameError\u001b[0m: name 'my_tuple' is not defined" 138 | ] 139 | } 140 | ], 141 | "source": [ 142 | "del(my_tuple)\n", 143 | "print(my_tuple)" 144 | ] 145 | }, 146 | { 147 | "cell_type": "code", 148 | "execution_count": 7, 149 | "metadata": { 150 | "collapsed": true 151 | }, 152 | "outputs": [], 153 | "source": [ 154 | "my_tuple = ('car1', 'car2', 'car3', 'car4', 'car5', 'car6', 'car7')" 155 | ] 156 | }, 157 | { 158 | "cell_type": "code", 159 | "execution_count": 8, 160 | "metadata": { 161 | "collapsed": true 162 | }, 163 | "outputs": [], 164 | "source": [ 165 | "my_list = ('ГАЗ-21', 'Нива', 'ЗАЗ-966', 'Лада-Калина', 'Лада-Веста', 'Мерседес-Бенц', 'Aurus')" 166 | ] 167 | }, 168 | { 169 | "cell_type": "code", 170 | "execution_count": 9, 171 | "metadata": { 172 | "collapsed": true 173 | }, 174 | "outputs": [], 175 | "source": [ 176 | "car_park = dict(list(zip(my_tuple, my_list))) #создаем словарь" 177 | ] 178 | }, 179 | { 180 | "cell_type": "code", 181 | "execution_count": 10, 182 | "metadata": { 183 | "collapsed": false 184 | }, 185 | "outputs": [ 186 | { 187 | "data": { 188 | "text/plain": [ 189 | "[('car1', 'ГАЗ-21'),\n", 190 | " ('car2', 'Нива'),\n", 191 | " ('car3', 'ЗАЗ-966'),\n", 192 | " ('car4', 'Лада-Калина'),\n", 193 | " ('car5', 'Лада-Веста'),\n", 194 | " ('car6', 'Мерседес-Бенц'),\n", 195 | " ('car7', 'Aurus')]" 196 | ] 197 | }, 198 | "execution_count": 10, 199 | "metadata": {}, 200 | "output_type": "execute_result" 201 | } 202 | ], 203 | "source": [ 204 | "car_park" 205 | ] 206 | }, 207 | { 208 | "cell_type": "markdown", 209 | "metadata": {}, 210 | "source": [ 211 | "## Множества (Sets)" 212 | ] 213 | }, 214 | { 215 | "cell_type": "code", 216 | "execution_count": 14, 217 | "metadata": { 218 | "collapsed": false 219 | }, 220 | "outputs": [ 221 | { 222 | "data": { 223 | "text/plain": [ 224 | "set()" 225 | ] 226 | }, 227 | "execution_count": 14, 228 | "metadata": {}, 229 | "output_type": "execute_result" 230 | } 231 | ], 232 | "source": [ 233 | "set()" 234 | ] 235 | }, 236 | { 237 | "cell_type": "code", 238 | "execution_count": 15, 239 | "metadata": { 240 | "collapsed": false 241 | }, 242 | "outputs": [ 243 | { 244 | "data": { 245 | "text/plain": [ 246 | "set" 247 | ] 248 | }, 249 | "execution_count": 15, 250 | "metadata": {}, 251 | "output_type": "execute_result" 252 | } 253 | ], 254 | "source": [ 255 | "set = {1, 2, 3}\n", 256 | "type(my_set)" 257 | ] 258 | }, 259 | { 260 | "cell_type": "code", 261 | "execution_count": 1, 262 | "metadata": { 263 | "collapsed": false 264 | }, 265 | "outputs": [ 266 | { 267 | "name": "stdout", 268 | "output_type": "stream", 269 | "text": [ 270 | "{1, 2, 3, 4, 5, 6, 7, 8, 9, 10}\n" 271 | ] 272 | } 273 | ], 274 | "source": [ 275 | "my_list = [1 , 2, 3, 4, 5, 10, 6, 7, 8, 9, 10]\n", 276 | "unique = set(my_list) #избавляемся от дублей\n", 277 | "print(unique)" 278 | ] 279 | }, 280 | { 281 | "cell_type": "code", 282 | "execution_count": 2, 283 | "metadata": { 284 | "collapsed": false 285 | }, 286 | "outputs": [ 287 | { 288 | "name": "stdout", 289 | "output_type": "stream", 290 | "text": [ 291 | "[1, 2, 3, 4, 5, 6, 7, 8, 9, 10]\n" 292 | ] 293 | } 294 | ], 295 | "source": [ 296 | "clean_list = list(unique)\n", 297 | "print(clean_list)" 298 | ] 299 | }, 300 | { 301 | "cell_type": "code", 302 | "execution_count": 3, 303 | "metadata": { 304 | "collapsed": false 305 | }, 306 | "outputs": [ 307 | { 308 | "data": { 309 | "text/plain": [ 310 | "{1, 2, 3, 4}" 311 | ] 312 | }, 313 | "execution_count": 3, 314 | "metadata": {}, 315 | "output_type": "execute_result" 316 | } 317 | ], 318 | "source": [ 319 | "my_set = {1, 2, 3}\n", 320 | "my_set.add(4)\n", 321 | "my_set" 322 | ] 323 | }, 324 | { 325 | "cell_type": "code", 326 | "execution_count": 4, 327 | "metadata": { 328 | "collapsed": false 329 | }, 330 | "outputs": [ 331 | { 332 | "data": { 333 | "text/plain": [ 334 | "{1, 3, 4}" 335 | ] 336 | }, 337 | "execution_count": 4, 338 | "metadata": {}, 339 | "output_type": "execute_result" 340 | } 341 | ], 342 | "source": [ 343 | "my_set.remove(2)\n", 344 | "my_set" 345 | ] 346 | }, 347 | { 348 | "cell_type": "code", 349 | "execution_count": 5, 350 | "metadata": { 351 | "collapsed": false 352 | }, 353 | "outputs": [ 354 | { 355 | "data": { 356 | "text/plain": [ 357 | "False" 358 | ] 359 | }, 360 | "execution_count": 5, 361 | "metadata": {}, 362 | "output_type": "execute_result" 363 | } 364 | ], 365 | "source": [ 366 | "2 in my_set" 367 | ] 368 | }, 369 | { 370 | "cell_type": "code", 371 | "execution_count": 6, 372 | "metadata": { 373 | "collapsed": false 374 | }, 375 | "outputs": [ 376 | { 377 | "data": { 378 | "text/plain": [ 379 | "True" 380 | ] 381 | }, 382 | "execution_count": 6, 383 | "metadata": {}, 384 | "output_type": "execute_result" 385 | } 386 | ], 387 | "source": [ 388 | "3 in my_set" 389 | ] 390 | }, 391 | { 392 | "cell_type": "code", 393 | "execution_count": 7, 394 | "metadata": { 395 | "collapsed": false 396 | }, 397 | "outputs": [ 398 | { 399 | "data": { 400 | "text/plain": [ 401 | "{8, 10}" 402 | ] 403 | }, 404 | "execution_count": 7, 405 | "metadata": {}, 406 | "output_type": "execute_result" 407 | } 408 | ], 409 | "source": [ 410 | "set1 = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10}\n", 411 | "set2 = {8, 10, 12, 14, 16, 18, 20}\n", 412 | "set1.intersection(set2) #пересечение множеств" 413 | ] 414 | }, 415 | { 416 | "cell_type": "code", 417 | "execution_count": 8, 418 | "metadata": { 419 | "collapsed": false 420 | }, 421 | "outputs": [ 422 | { 423 | "data": { 424 | "text/plain": [ 425 | "{1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 12, 14, 16, 18, 20}" 426 | ] 427 | }, 428 | "execution_count": 8, 429 | "metadata": {}, 430 | "output_type": "execute_result" 431 | } 432 | ], 433 | "source": [ 434 | "set3 = set1.union(set2) #объединение множеств\n", 435 | "set3" 436 | ] 437 | }, 438 | { 439 | "cell_type": "code", 440 | "execution_count": 10, 441 | "metadata": { 442 | "collapsed": false 443 | }, 444 | "outputs": [ 445 | { 446 | "data": { 447 | "text/plain": [ 448 | "{1, 2, 3, 4, 5, 6, 7, 9}" 449 | ] 450 | }, 451 | "execution_count": 10, 452 | "metadata": {}, 453 | "output_type": "execute_result" 454 | } 455 | ], 456 | "source": [ 457 | "set1.difference(set2) #разница множеств" 458 | ] 459 | }, 460 | { 461 | "cell_type": "code", 462 | "execution_count": 11, 463 | "metadata": { 464 | "collapsed": false 465 | }, 466 | "outputs": [ 467 | { 468 | "data": { 469 | "text/plain": [ 470 | "{1, 2, 3, 4, 5, 6, 7, 9, 12, 14, 16, 18, 20}" 471 | ] 472 | }, 473 | "execution_count": 11, 474 | "metadata": {}, 475 | "output_type": "execute_result" 476 | } 477 | ], 478 | "source": [ 479 | "set1.symmetric_difference(set2) #симметричная разница множеств" 480 | ] 481 | }, 482 | { 483 | "cell_type": "code", 484 | "execution_count": 12, 485 | "metadata": { 486 | "collapsed": true 487 | }, 488 | "outputs": [], 489 | "source": [ 490 | "set4 = frozenset(set1) #неизменяемое множество" 491 | ] 492 | }, 493 | { 494 | "cell_type": "code", 495 | "execution_count": 13, 496 | "metadata": { 497 | "collapsed": false 498 | }, 499 | "outputs": [ 500 | { 501 | "ename": "AttributeError", 502 | "evalue": "'frozenset' object has no attribute 'remove'", 503 | "output_type": "error", 504 | "traceback": [ 505 | "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", 506 | "\u001b[0;31mAttributeError\u001b[0m Traceback (most recent call last)", 507 | "\u001b[0;32m\u001b[0m in \u001b[0;36m\u001b[0;34m()\u001b[0m\n\u001b[0;32m----> 1\u001b[0;31m \u001b[0mset4\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mremove\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;36m2\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m", 508 | "\u001b[0;31mAttributeError\u001b[0m: 'frozenset' object has no attribute 'remove'" 509 | ] 510 | } 511 | ], 512 | "source": [ 513 | "set4.remove(2)" 514 | ] 515 | } 516 | ], 517 | "metadata": { 518 | "kernelspec": { 519 | "display_name": "Python [Root]", 520 | "language": "python", 521 | "name": "Python [Root]" 522 | }, 523 | "language_info": { 524 | "codemirror_mode": { 525 | "name": "ipython", 526 | "version": 3 527 | }, 528 | "file_extension": ".py", 529 | "mimetype": "text/x-python", 530 | "name": "python", 531 | "nbconvert_exporter": "python", 532 | "pygments_lexer": "ipython3", 533 | "version": "3.5.2" 534 | } 535 | }, 536 | "nbformat": 4, 537 | "nbformat_minor": 0 538 | } 539 | -------------------------------------------------------------------------------- /Задачи для тренировок 2.ipynb: -------------------------------------------------------------------------------- 1 | { 2 | "cells": [ 3 | { 4 | "cell_type": "markdown", 5 | "metadata": {}, 6 | "source": [ 7 | "## Задачи для самостоятельных тренировок по курсу Мастерской «Важных историй» — «Пограммирование на языке Python для журналистов».\n", 8 | "\n", 9 | "#### Основано на задачах из курса Ильи Щурова. Cсылка на курс: https://clck.ru/S8TAk\n", 10 | "\n", 11 | "#### Смотреть уроки Мастерской здесь: https://clck.ru/S8Wwe\n" 12 | ] 13 | }, 14 | { 15 | "cell_type": "markdown", 16 | "metadata": {}, 17 | "source": [ 18 | "### Для выполнения заданий:\n", 19 | "\n", 20 | "1) Скачайте эту тетрадку на свой компьютер: для этого нажмите raw → «сохранить как» → формат файла вместо txt напишите ipynb. \n", 21 | "\n", 22 | "2) После открытия Jupyter загрузите скаченную тетрадку через Upload (в правом верхнем углу).\n", 23 | "\n", 24 | "3) Найдите ее в списке тетрадок на той же странице и откройте. \n", 25 | "\n", 26 | "4) Активируйте тесты: это первая ячейка с кодом. Тогда ваши ответы на задания будут проверяться на ошибки. \n", 27 | "\n", 28 | "5) Вставляйте решение каждой задачи в ячейку для кода строго там, где написан комментарий # YOUR CODE HERE. Отступ вашего кода должен составлять 4 пробела (кнопка tab). Ничего не меняйте вокруг!\n", 29 | "\n", 30 | "6) Запустите ячейку после того, как вставили код с решением. Введите входные данные, если это нужно. Проверьте визуально правильность вывода. \n", 31 | "\n", 32 | "7) Запустите следующую ячейку, которая начинается с test_data (в ней содержится тест). Если запуск ячейки с тестом не приводит к появлению ошибки (assertion), значит, всё в порядке, задача решена. Если приводит к появлению ошибки, значит, тест не пройден и нужно искать ошибку.\n", 33 | "\n", 34 | "*Внимание!*\n", 35 | "\n", 36 | "Если в какой-то момент забыть ввести входные данные и перейти на следующую ячейку, есть риск, что Notebook перестанет откликаться. В этом случае надо перезапустить ядро: Kernel → Restart. При этом потеряются все значения переменных, но сам код останется.\n", 37 | "\n", 38 | "В задачах вам потребуется написать код, запрашивающий данные с клавиатуры с помощью функции input(). Обратите внимание: input() всегда возвращает строку, чтобы преобразовать результат к другому типу, нужно использовать соответствующие функции\n", 39 | "\n", 40 | "### Удачи!" 41 | ] 42 | }, 43 | { 44 | "cell_type": "code", 45 | "execution_count": 8, 46 | "metadata": { 47 | "collapsed": true 48 | }, 49 | "outputs": [], 50 | "source": [ 51 | "# Фабрика тестов для проверки программ, принимающих данные через input()\n", 52 | "\n", 53 | "from collections import deque\n", 54 | "\n", 55 | "class Tester(object):\n", 56 | " def __init__(self, inp):\n", 57 | " self.outputs = []\n", 58 | " self.inputs = deque(inp)\n", 59 | " def print(self, *args, sep = \" \", end = \"\\n\"):\n", 60 | " self.outputs.append(sep.join(map(str,args)) + end)\n", 61 | " def input(self, *args):\n", 62 | " assert self.inputs, \"Вы пытаетесь считать больше элементов, чем предусмотрено условием\"\n", 63 | " return self.inputs.popleft()\n", 64 | " def __enter__(self):\n", 65 | " global print\n", 66 | " global input\n", 67 | " print = self.print\n", 68 | " input = self.input\n", 69 | " return self.outputs\n", 70 | " def __exit__(self, *args):\n", 71 | " global print\n", 72 | " global input\n", 73 | " del print\n", 74 | " del input" 75 | ] 76 | }, 77 | { 78 | "cell_type": "markdown", 79 | "metadata": {}, 80 | "source": [ 81 | "# Для решения этих задачек вам нужно посмотреть первые 5 частей курса Мастерской «Важных историй» — «Пограммирование на языке Python для журналистов». " 82 | ] 83 | }, 84 | { 85 | "cell_type": "markdown", 86 | "metadata": {}, 87 | "source": [ 88 | "### Задача 1\n", 89 | "Список `my_list` задан следующим образом:\n", 90 | "\n", 91 | " my_list = [17, 9, 123, 7, 32, 876, -5, \"Hello\", 99, 14, 13, 100, 'World']\n", 92 | " \n", 93 | "Требуется написать программу, которая запрашивает целое число `n` с клавиатуры, а в ответ печатает `n`-й элемент списка (при нумерации с единицы). **Внимание!** В Python используется нумерация с нуля.\n", 94 | "\n", 95 | "**Пример.**\n", 96 | "\n", 97 | "**Входные данные:**\n", 98 | "\n", 99 | " 1\n", 100 | "\n", 101 | "**Выходные данные:**\n", 102 | "\n", 103 | " 17\n", 104 | " \n", 105 | "**Входные данные:**\n", 106 | " \n", 107 | " 8\n", 108 | "\n", 109 | "**Выходные данные:**\n", 110 | "\n", 111 | " Hello" 112 | ] 113 | }, 114 | { 115 | "cell_type": "code", 116 | "execution_count": null, 117 | "metadata": { 118 | "collapsed": true 119 | }, 120 | "outputs": [], 121 | "source": [ 122 | "def get_item():\n", 123 | " # YOUR CODE HERE\n", 124 | "\n", 125 | "get_item()" 126 | ] 127 | }, 128 | { 129 | "cell_type": "code", 130 | "execution_count": null, 131 | "metadata": { 132 | "collapsed": true 133 | }, 134 | "outputs": [], 135 | "source": [ 136 | "test_data = [(1, 17), (2, 9), (3, 123), (4, 7), (5, 32), (6, 876), (7, -5), (8, \"Hello\"),\n", 137 | " (9, 99), (10, 14), (11, 13), (12, 100), (13, \"World\")]\n", 138 | "\n", 139 | "for inp, out in test_data:\n", 140 | " with Tester([inp]) as t:\n", 141 | " get_item()\n", 142 | " assert len(t) == 1, \"Вам нужно вывести ровно одну строку с ответом\"\n", 143 | " assert t[0].strip() == str(out), \"Неверный ответ: \" + str(inp)\n", 144 | "print(\"Ура, всё верно!\")" 145 | ] 146 | }, 147 | { 148 | "cell_type": "markdown", 149 | "metadata": {}, 150 | "source": [ 151 | "### Задача 2\n", 152 | "Напишите программу, которая запрашивает целое число `n` с клавиатуры, затем `n` целых чисел, после чего выводит произведение всех этих чисел.\n", 153 | "\n", 154 | "**Пример.**\n", 155 | "\n", 156 | "**Входные данные:**\n", 157 | "\n", 158 | " 3\n", 159 | " 9\n", 160 | " 2\n", 161 | " 5\n", 162 | "\n", 163 | "**Выходные данные:**\n", 164 | "\n", 165 | " 90" 166 | ] 167 | }, 168 | { 169 | "cell_type": "code", 170 | "execution_count": null, 171 | "metadata": { 172 | "collapsed": true 173 | }, 174 | "outputs": [], 175 | "source": [ 176 | "def prod_n():\n", 177 | " # YOUR CODE HERE\n", 178 | " \n", 179 | "prod_n()" 180 | ] 181 | }, 182 | { 183 | "cell_type": "code", 184 | "execution_count": null, 185 | "metadata": { 186 | "collapsed": true 187 | }, 188 | "outputs": [], 189 | "source": [ 190 | "test_data = [\n", 191 | " (\"3 9 2 5\", 90),\n", 192 | " (\"1 1\", 1),\n", 193 | " (\"2 0 10\", 0),\n", 194 | " (\"2 10 0\", 0),\n", 195 | " (\"10 1 2 3 4 5 6 7 8 9 10\", 3628800),\n", 196 | " (\"5 -1 -1 -1 -1 -1\", -1)\n", 197 | "]\n", 198 | "\n", 199 | "for inp, out in test_data:\n", 200 | " with Tester(inp.split()) as t:\n", 201 | " prod_n()\n", 202 | " assert len(t) == 1, \"Вам нужно вывести ровно одну строку с ответом\"\n", 203 | " assert t[0].strip() == str(out), \"Неверный ответ, были введены числа \" + inp\n", 204 | "print(\"Ура, всё верно!\")" 205 | ] 206 | }, 207 | { 208 | "cell_type": "markdown", 209 | "metadata": {}, 210 | "source": [ 211 | "### Задача 3\n", 212 | "Факториалом натурального числа $n$ называется произведение всех натуральных чисел от 1 до $n$ включительно. Факториал $n$ обозначается $n!$. Например,\n", 213 | "$$\n", 214 | "4! = 1 \\times 2 \\times 3 \\times 4 = 24.\n", 215 | "$$\n", 216 | "Написать программу, запрашивающую натуральное число $n$ с клавиатуры, вычисляющую и печатающую $n!$. Использовать какие-либо библиотечные функции нельзя (то есть запрещена конструкция `import`).\n", 217 | "\n", 218 | "**Пример.**\n", 219 | "\n", 220 | "**Входные данные:**\n", 221 | "\n", 222 | " 5\n", 223 | "\n", 224 | "**Выходные данные:**\n", 225 | "\n", 226 | " 120" 227 | ] 228 | }, 229 | { 230 | "cell_type": "code", 231 | "execution_count": null, 232 | "metadata": { 233 | "collapsed": true 234 | }, 235 | "outputs": [], 236 | "source": [ 237 | "def my_fact():\n", 238 | " # YOUR CODE HERE\n", 239 | "\n", 240 | "my_fact()" 241 | ] 242 | }, 243 | { 244 | "cell_type": "code", 245 | "execution_count": null, 246 | "metadata": { 247 | "collapsed": true 248 | }, 249 | "outputs": [], 250 | "source": [ 251 | "test_data = [\n", 252 | " (\"1\", 1),\n", 253 | " (\"2\", 2),\n", 254 | " (\"3\", 6),\n", 255 | " (\"4\", 24),\n", 256 | " (\"5\", 120),\n", 257 | " (\"10\", 3628800),\n", 258 | " (\"20\", 2432902008176640000)\n", 259 | "]\n", 260 | "\n", 261 | "for inp, out in test_data:\n", 262 | " with Tester([inp]) as t:\n", 263 | " my_fact()\n", 264 | " assert len(t) == 1, \"Вам нужно вывести ровно одну строку с ответом\"\n", 265 | " assert t[0].strip() == str(out), \"Неверный ответ, были введены числа \" + inp\n", 266 | "print(\"Ура, всё верно!\")" 267 | ] 268 | }, 269 | { 270 | "cell_type": "markdown", 271 | "metadata": {}, 272 | "source": [ 273 | "### Задача 4\n", 274 | "Напишите программу, которая запрашивает с клавиатуры целые числа и помещает их в список. Программа должна перестать запрашивать числа после того, как будет введено 10 чисел, либо после того, как пользователь введёт число 0. В последнем случае 0 не помещается в список (и служит только указанием на то, что числа больше не нужно вводить). После того, как список сформирован, необходимо вывести его на экран (просто функцией `print`, так, чтобы числа вывелись через запятую и пробел, в квадратных скобках).\n", 275 | "\n", 276 | "**Пример.**\n", 277 | "\n", 278 | "**Входные данные:**\n", 279 | "\n", 280 | " 2\n", 281 | " 3\n", 282 | " 4\n", 283 | " 5\n", 284 | " 6\n", 285 | " 7\n", 286 | " 8\n", 287 | " 9\n", 288 | " 10\n", 289 | " 110\n", 290 | " \n", 291 | "\n", 292 | "**Выходные данные:**\n", 293 | "\n", 294 | " [2, 3, 4, 5, 6, 7, 8, 9, 10, 110]\n", 295 | " \n", 296 | "**Входные данные:**\n", 297 | "\n", 298 | " 5\n", 299 | " 9\n", 300 | " -2\n", 301 | " 0\n", 302 | " \n", 303 | "\n", 304 | "**Выходные данные:**\n", 305 | "\n", 306 | " [5, 9, -2]" 307 | ] 308 | }, 309 | { 310 | "cell_type": "code", 311 | "execution_count": null, 312 | "metadata": { 313 | "collapsed": true 314 | }, 315 | "outputs": [], 316 | "source": [ 317 | "def enter_10_stop_0():\n", 318 | " # YOUR CODE HERE\n", 319 | " \n", 320 | "enter_10_stop_0()" 321 | ] 322 | }, 323 | { 324 | "cell_type": "code", 325 | "execution_count": null, 326 | "metadata": { 327 | "collapsed": true 328 | }, 329 | "outputs": [], 330 | "source": [ 331 | "test_data = [\n", 332 | " (\"1 2 3 4 5 6 7 8 9 10\", \"[1, 2, 3, 4, 5, 6, 7, 8, 9, 10]\"),\n", 333 | " (\"2 3 0\", \"[2, 3]\"),\n", 334 | " (\"1 2 3 4 5 6 7 8 9 0\", \"[1, 2, 3, 4, 5, 6, 7, 8, 9]\"),\n", 335 | " (\"2 2 2 0\", \"[2, 2, 2]\"),\n", 336 | " (\"100 999 -2 999 2 3 5 10 9 10\", \"[100, 999, -2, 999, 2, 3, 5, 10, 9, 10]\")\n", 337 | "]\n", 338 | "\n", 339 | "for inp, out in test_data:\n", 340 | " with Tester(inp.split()) as t:\n", 341 | " enter_10_stop_0()\n", 342 | " assert len(t) == 1, \"Вам нужно вывести ровно одну строку с ответом\"\n", 343 | " assert t[0].strip() == str(out), \"Неверный ответ, были введены числа \" + inp\n", 344 | "print(\"Ура, всё верно!\")" 345 | ] 346 | }, 347 | { 348 | "cell_type": "markdown", 349 | "metadata": {}, 350 | "source": [ 351 | "### Задача 5 \n", 352 | "\n", 353 | "Напишите программу, которая запрашивает с клавиатуры целые числа и помещает их в список. Программа должна перестать запрашивать числа после того, как будет введено 10 чисел, либо после того, как пользователь введёт число 0. В последнем случае 0 не помещается в список (и служит только указанием на то, что числа больше не нужно вводить). После того, как список сформирован, необходимо вывести на экран все введённые числа (в том же порядке, в котором они вводились), кроме первого и последнего.\n", 354 | "\n", 355 | "**Пример.**\n", 356 | "\n", 357 | "**Входные данные:**\n", 358 | "\n", 359 | " 2\n", 360 | " 3\n", 361 | " 4\n", 362 | " 5\n", 363 | " 6\n", 364 | " 7\n", 365 | " 8\n", 366 | " 9\n", 367 | " 10\n", 368 | " 110\n", 369 | " \n", 370 | "\n", 371 | "**Выходные данные:**\n", 372 | "\n", 373 | " 3\n", 374 | " 4\n", 375 | " 5\n", 376 | " 6\n", 377 | " 7\n", 378 | " 8\n", 379 | " 9\n", 380 | " 10\n", 381 | " \n", 382 | "**Входные данные:**\n", 383 | "\n", 384 | " 5\n", 385 | " 9\n", 386 | " 8\n", 387 | " -2\n", 388 | " 0\n", 389 | "\n", 390 | "**Входные данные:**\n", 391 | "\n", 392 | " 9\n", 393 | " 8\n" 394 | ] 395 | }, 396 | { 397 | "cell_type": "code", 398 | "execution_count": null, 399 | "metadata": { 400 | "collapsed": true 401 | }, 402 | "outputs": [], 403 | "source": [ 404 | "def skip_first_and_last():\n", 405 | " # YOUR CODE HERE\n", 406 | "\n", 407 | "skip_first_and_last()" 408 | ] 409 | }, 410 | { 411 | "cell_type": "code", 412 | "execution_count": null, 413 | "metadata": { 414 | "collapsed": true 415 | }, 416 | "outputs": [], 417 | "source": [ 418 | "test_data = [\n", 419 | " (\"1 2 3 4 5 7 6 8 9 10\", \"2 3 4 5 7 6 8 9\"),\n", 420 | " (\"2 1 3 0\", \"1\"),\n", 421 | " (\"1 2 3 4 5 6 7 8 9 0\", \"2 3 4 5 6 7 8\"),\n", 422 | " (\"2 2 2 0\", \"2\"),\n", 423 | " (\"100 999 -2 999 2 3 5 10 9 10\", \"999 -2 999 2 3 5 10 9\")\n", 424 | "]\n", 425 | "\n", 426 | "for inp, answer in test_data:\n", 427 | " ans = answer.split()\n", 428 | " with Tester(inp.split()) as t_out:\n", 429 | " skip_first_and_last()\n", 430 | " assert len(t_out) == len(ans), \"Неверное количество строк в ответе\"\n", 431 | " for t, a in zip(t_out, ans):\n", 432 | " assert t.strip() == a.strip(), \"Что-то пошло не так\"\n", 433 | "\n", 434 | "print(\"Ура, всё верно!\")" 435 | ] 436 | }, 437 | { 438 | "cell_type": "markdown", 439 | "metadata": {}, 440 | "source": [ 441 | "### Задача 6 \n", 442 | "\n", 443 | "Напишите программу, которая запрашивает целое число `n` с клавиатуры, затем `n` целых чисел, после чего выводит все введённые числа в столбик: сначала все положительные (в том порядке, в каком они вводились), потом все отрицательные (также в том порядке, в котором они вводились). Нули следует игнорировать (не выводить).\n", 444 | "\n", 445 | "**Пример.**\n", 446 | "\n", 447 | "**Входные данные:**\n", 448 | "\n", 449 | " 3\n", 450 | " 9\n", 451 | " -2\n", 452 | " 5\n", 453 | "\n", 454 | "**Выходные данные:**\n", 455 | "\n", 456 | " 9\n", 457 | " 5\n", 458 | " -2\n", 459 | " \n", 460 | "**Входные данные:**\n", 461 | "\n", 462 | " 5\n", 463 | " 1\n", 464 | " -1\n", 465 | " 0\n", 466 | " -3\n", 467 | " 1\n", 468 | "\n", 469 | "**Выходные данные:**\n", 470 | "\n", 471 | " 1\n", 472 | " 1\n", 473 | " -1\n", 474 | " -3\n" 475 | ] 476 | }, 477 | { 478 | "cell_type": "code", 479 | "execution_count": null, 480 | "metadata": { 481 | "collapsed": true 482 | }, 483 | "outputs": [], 484 | "source": [ 485 | "def positive_and_negative():\n", 486 | " # YOUR CODE HERE\n", 487 | " \n", 488 | "positive_and_negative()" 489 | ] 490 | }, 491 | { 492 | "cell_type": "code", 493 | "execution_count": null, 494 | "metadata": { 495 | "collapsed": true 496 | }, 497 | "outputs": [], 498 | "source": [ 499 | "test_data = [\n", 500 | " (\"4 4 3 2 1\", \"4 3 2 1\"),\n", 501 | " (\"4 1 2 -3 -4\", \"1 2 -3 -4\"),\n", 502 | " (\"4 2 -1 3 -2\", \"2 3 -1 -2\"),\n", 503 | " (\"1 1\", \"1\"),\n", 504 | " (\"10 100 999 -2 999 2 3 5 10 9 10\", \"100 999 999 2 3 5 10 9 10 -2\"),\n", 505 | " (\"3 -3 -1 -2\", \"-3 -1 -2\")\n", 506 | "]\n", 507 | "\n", 508 | "for inp, answer in test_data:\n", 509 | " ans = answer.split()\n", 510 | " with Tester(inp.split()) as t_out:\n", 511 | " positive_and_negative()\n", 512 | " assert len(t_out) == len(ans), \"Неверное количество строк в ответе: \" + inp\n", 513 | " for t, a in zip(t_out, ans):\n", 514 | " assert t.strip() == a.strip(), \"Что-то пошло не так: \" + inp\n", 515 | "\n", 516 | "print(\"Ура, всё верно!\")" 517 | ] 518 | } 519 | ], 520 | "metadata": { 521 | "kernelspec": { 522 | "display_name": "Python 3", 523 | "language": "python", 524 | "name": "python3" 525 | }, 526 | "language_info": { 527 | "codemirror_mode": { 528 | "name": "ipython", 529 | "version": 3 530 | }, 531 | "file_extension": ".py", 532 | "mimetype": "text/x-python", 533 | "name": "python", 534 | "nbconvert_exporter": "python", 535 | "pygments_lexer": "ipython3", 536 | "version": "3.8.3" 537 | } 538 | }, 539 | "nbformat": 4, 540 | "nbformat_minor": 1 541 | } 542 | -------------------------------------------------------------------------------- /Урок 5. Списки.ipynb: -------------------------------------------------------------------------------- 1 | { 2 | "cells": [ 3 | { 4 | "cell_type": "code", 5 | "execution_count": 6, 6 | "metadata": {}, 7 | "outputs": [ 8 | { 9 | "data": { 10 | "text/plain": [ 11 | "[1, 2, 3, 4, 5]" 12 | ] 13 | }, 14 | "execution_count": 6, 15 | "metadata": {}, 16 | "output_type": "execute_result" 17 | } 18 | ], 19 | "source": [ 20 | "[1, 2, 3, 4, 5] #в списках могут храниться числа" 21 | ] 22 | }, 23 | { 24 | "cell_type": "code", 25 | "execution_count": 7, 26 | "metadata": {}, 27 | "outputs": [ 28 | { 29 | "data": { 30 | "text/plain": [ 31 | "list" 32 | ] 33 | }, 34 | "execution_count": 7, 35 | "metadata": {}, 36 | "output_type": "execute_result" 37 | } 38 | ], 39 | "source": [ 40 | "type([1, 2, 3, 4, 5]) #проверяем тип данных" 41 | ] 42 | }, 43 | { 44 | "cell_type": "code", 45 | "execution_count": 9, 46 | "metadata": {}, 47 | "outputs": [ 48 | { 49 | "data": { 50 | "text/plain": [ 51 | "list" 52 | ] 53 | }, 54 | "execution_count": 9, 55 | "metadata": {}, 56 | "output_type": "execute_result" 57 | } 58 | ], 59 | "source": [ 60 | "type(['line1', 'line2']) #в списках могут храниться строчки" 61 | ] 62 | }, 63 | { 64 | "cell_type": "code", 65 | "execution_count": 10, 66 | "metadata": {}, 67 | "outputs": [ 68 | { 69 | "data": { 70 | "text/plain": [ 71 | "[1, 1.4, 'line', [1, 2, 3]]" 72 | ] 73 | }, 74 | "execution_count": 10, 75 | "metadata": {}, 76 | "output_type": "execute_result" 77 | } 78 | ], 79 | "source": [ 80 | "[1, 1.4, 'line', [1, 2, 3]] #в списках могут храниться и сразу несколько разных типов данных" 81 | ] 82 | }, 83 | { 84 | "cell_type": "code", 85 | "execution_count": 77, 86 | "metadata": {}, 87 | "outputs": [ 88 | { 89 | "data": { 90 | "text/plain": [ 91 | "[]" 92 | ] 93 | }, 94 | "execution_count": 77, 95 | "metadata": {}, 96 | "output_type": "execute_result" 97 | } 98 | ], 99 | "source": [ 100 | "my_list = list() #так можно создать пустой список\n", 101 | "my_list" 102 | ] 103 | }, 104 | { 105 | "cell_type": "code", 106 | "execution_count": 78, 107 | "metadata": {}, 108 | "outputs": [ 109 | { 110 | "data": { 111 | "text/plain": [ 112 | "[]" 113 | ] 114 | }, 115 | "execution_count": 78, 116 | "metadata": {}, 117 | "output_type": "execute_result" 118 | } 119 | ], 120 | "source": [ 121 | "my_list = [] #и так тоже можно создать пустой список\n", 122 | "my_list" 123 | ] 124 | }, 125 | { 126 | "cell_type": "code", 127 | "execution_count": 19, 128 | "metadata": {}, 129 | "outputs": [ 130 | { 131 | "name": "stdout", 132 | "output_type": "stream", 133 | "text": [ 134 | " 1\n", 135 | " 1.4\n", 136 | " line\n", 137 | " [1, 2, 3]\n", 138 | " 1.4\n" 139 | ] 140 | } 141 | ], 142 | "source": [ 143 | "my_list = [1, 1.4, 'line', [1, 2, 3], 1.4]\n", 144 | "#давайте с помощью цикла проверим тип каждого элемента\n", 145 | "for el in my_list:\n", 146 | " print(type(el), el)" 147 | ] 148 | }, 149 | { 150 | "cell_type": "code", 151 | "execution_count": 16, 152 | "metadata": {}, 153 | "outputs": [ 154 | { 155 | "data": { 156 | "text/plain": [ 157 | "4" 158 | ] 159 | }, 160 | "execution_count": 16, 161 | "metadata": {}, 162 | "output_type": "execute_result" 163 | } 164 | ], 165 | "source": [ 166 | "len(my_list) #так можно проверять длину списка, то есть количество элементов в нем" 167 | ] 168 | }, 169 | { 170 | "cell_type": "code", 171 | "execution_count": 17, 172 | "metadata": {}, 173 | "outputs": [ 174 | { 175 | "data": { 176 | "text/plain": [ 177 | "'line'" 178 | ] 179 | }, 180 | "execution_count": 17, 181 | "metadata": {}, 182 | "output_type": "execute_result" 183 | } 184 | ], 185 | "source": [ 186 | "my_list[2] #по индексу можно обращаться к элементам списка" 187 | ] 188 | }, 189 | { 190 | "cell_type": "code", 191 | "execution_count": 20, 192 | "metadata": {}, 193 | "outputs": [ 194 | { 195 | "data": { 196 | "text/plain": [ 197 | "1" 198 | ] 199 | }, 200 | "execution_count": 20, 201 | "metadata": {}, 202 | "output_type": "execute_result" 203 | } 204 | ], 205 | "source": [ 206 | "my_list.index(1.4) \n", 207 | "#так можно узнать, какой индекс у элемента. \n", 208 | "#вернется только индекс самого первого такого элемента\n", 209 | "\n" 210 | ] 211 | }, 212 | { 213 | "cell_type": "code", 214 | "execution_count": 21, 215 | "metadata": {}, 216 | "outputs": [], 217 | "source": [ 218 | "my_list.append('one_more_line')\n", 219 | "#так можно добавлять элементы в конец списка" 220 | ] 221 | }, 222 | { 223 | "cell_type": "code", 224 | "execution_count": 22, 225 | "metadata": {}, 226 | "outputs": [ 227 | { 228 | "data": { 229 | "text/plain": [ 230 | "[1, 1.4, 'line', [1, 2, 3], 1.4, 'one_more_line']" 231 | ] 232 | }, 233 | "execution_count": 22, 234 | "metadata": {}, 235 | "output_type": "execute_result" 236 | } 237 | ], 238 | "source": [ 239 | "my_list" 240 | ] 241 | }, 242 | { 243 | "cell_type": "code", 244 | "execution_count": 28, 245 | "metadata": {}, 246 | "outputs": [], 247 | "source": [ 248 | "my_list.insert(1, 100)\n", 249 | "# так можно добавлять элемент на конкретное место в списке.\n", 250 | "# то есть сначала указываем место - это идекс, а потом сам элемент" 251 | ] 252 | }, 253 | { 254 | "cell_type": "code", 255 | "execution_count": 29, 256 | "metadata": {}, 257 | "outputs": [ 258 | { 259 | "data": { 260 | "text/plain": [ 261 | "[1, 100, 1.4, 'line', [1, 2, 3], 1.4, 'one_more_line']" 262 | ] 263 | }, 264 | "execution_count": 29, 265 | "metadata": {}, 266 | "output_type": "execute_result" 267 | } 268 | ], 269 | "source": [ 270 | "my_list" 271 | ] 272 | }, 273 | { 274 | "cell_type": "code", 275 | "execution_count": 30, 276 | "metadata": {}, 277 | "outputs": [], 278 | "source": [ 279 | "my_list.remove(100)\n", 280 | "# так можно удалить элементы из списка\n", 281 | "# удалится только первый такой элемент в списке" 282 | ] 283 | }, 284 | { 285 | "cell_type": "code", 286 | "execution_count": 31, 287 | "metadata": {}, 288 | "outputs": [ 289 | { 290 | "data": { 291 | "text/plain": [ 292 | "[1, 1.4, 'line', [1, 2, 3], 1.4, 'one_more_line']" 293 | ] 294 | }, 295 | "execution_count": 31, 296 | "metadata": {}, 297 | "output_type": "execute_result" 298 | } 299 | ], 300 | "source": [ 301 | "my_list" 302 | ] 303 | }, 304 | { 305 | "cell_type": "code", 306 | "execution_count": 81, 307 | "metadata": {}, 308 | "outputs": [], 309 | "source": [ 310 | "number_list = [3, 49, 1, 16]\n", 311 | "sorted_list = sorted(number_list) # так можно сортировать список\n", 312 | "# но результат сортировки нужно сохранять в какую-то переменную\n", 313 | "# потому что sorted() не изменяет исходный список" 314 | ] 315 | }, 316 | { 317 | "cell_type": "code", 318 | "execution_count": 80, 319 | "metadata": {}, 320 | "outputs": [ 321 | { 322 | "data": { 323 | "text/plain": [ 324 | "[1, 3, 16, 49]" 325 | ] 326 | }, 327 | "execution_count": 80, 328 | "metadata": {}, 329 | "output_type": "execute_result" 330 | } 331 | ], 332 | "source": [ 333 | "sorted_list" 334 | ] 335 | }, 336 | { 337 | "cell_type": "code", 338 | "execution_count": 82, 339 | "metadata": {}, 340 | "outputs": [ 341 | { 342 | "data": { 343 | "text/plain": [ 344 | "[3, 49, 1, 16]" 345 | ] 346 | }, 347 | "execution_count": 82, 348 | "metadata": {}, 349 | "output_type": "execute_result" 350 | } 351 | ], 352 | "source": [ 353 | "number_list" 354 | ] 355 | }, 356 | { 357 | "cell_type": "code", 358 | "execution_count": 36, 359 | "metadata": {}, 360 | "outputs": [ 361 | { 362 | "data": { 363 | "text/plain": [ 364 | "[1, 3, 16, 49]" 365 | ] 366 | }, 367 | "execution_count": 36, 368 | "metadata": {}, 369 | "output_type": "execute_result" 370 | } 371 | ], 372 | "source": [ 373 | "sorted_list" 374 | ] 375 | }, 376 | { 377 | "cell_type": "code", 378 | "execution_count": 37, 379 | "metadata": {}, 380 | "outputs": [ 381 | { 382 | "data": { 383 | "text/plain": [ 384 | "['а', 'в', 'щ']" 385 | ] 386 | }, 387 | "execution_count": 37, 388 | "metadata": {}, 389 | "output_type": "execute_result" 390 | } 391 | ], 392 | "source": [ 393 | "str_list = ['а', \"щ\", \"в\"] #сортировать можно не только числа в списках, но и строки\n", 394 | "sorted(str_list)" 395 | ] 396 | }, 397 | { 398 | "cell_type": "markdown", 399 | "metadata": {}, 400 | "source": [ 401 | "Попробуем написать небольшую программу. \n", 402 | "Она будет 5 раз просить пользователя ввести число и каждое из этих чисел добавлять в список. А потом распечатает нам список из этих 5 чисел. " 403 | ] 404 | }, 405 | { 406 | "cell_type": "code", 407 | "execution_count": 83, 408 | "metadata": {}, 409 | "outputs": [ 410 | { 411 | "name": "stdout", 412 | "output_type": "stream", 413 | "text": [ 414 | "Введите число: 2\n", 415 | "Введите число: 4\n", 416 | "Введите число: 6\n", 417 | "Введите число: 8\n", 418 | "Введите число: 10\n", 419 | "[2, 4, 6, 8, 10]\n" 420 | ] 421 | } 422 | ], 423 | "source": [ 424 | "my_list = []\n", 425 | "\n", 426 | "for num in range(5):\n", 427 | " x = int(input('Введите число: '))\n", 428 | " my_list.append(x)\n", 429 | " \n", 430 | "print(my_list)" 431 | ] 432 | }, 433 | { 434 | "cell_type": "markdown", 435 | "metadata": {}, 436 | "source": [ 437 | "Теперь программа должна просить пользователя 5 раз ввести четное число, проверять, действительно ли оно четное. Если да, то добавлять в список, если нет, то выводить пользователю на экране *введенное пользователем число* не делится на 2 без остатка." 438 | ] 439 | }, 440 | { 441 | "cell_type": "code", 442 | "execution_count": 44, 443 | "metadata": {}, 444 | "outputs": [ 445 | { 446 | "name": "stdout", 447 | "output_type": "stream", 448 | "text": [ 449 | "Введите четное число: 3\n", 450 | "3 не делится на 2 без остатка.\n", 451 | "Введите четное число: 2\n", 452 | "Введите четное число: 4\n", 453 | "Введите четное число: 5\n", 454 | "5 не делится на 2 без остатка.\n", 455 | "Введите четное число: 1\n", 456 | "1 не делится на 2 без остатка.\n", 457 | "[2, 4]\n" 458 | ] 459 | } 460 | ], 461 | "source": [ 462 | "my_list = []\n", 463 | "\n", 464 | "for num in range(5):\n", 465 | " x = int(input('Введите четное число: '))\n", 466 | " if x%2 == 0: \n", 467 | " my_list.append(x)\n", 468 | " else:\n", 469 | " print(f\"{x} не делится на 2 без остатка.\")\n", 470 | "print(my_list)" 471 | ] 472 | }, 473 | { 474 | "cell_type": "markdown", 475 | "metadata": {}, 476 | "source": [ 477 | "У нас есть вот такой список — my_list = ['2%', \"45 %\", '6%', “11”, ‘15 %’] . Давайте очистим каждый элемент от лишнего знака %.\n", 478 | "\n" 479 | ] 480 | }, 481 | { 482 | "cell_type": "code", 483 | "execution_count": 48, 484 | "metadata": {}, 485 | "outputs": [], 486 | "source": [ 487 | "my_list = ['2 %', \"45%\", '6%']\n", 488 | "clean_list = []\n", 489 | "for el in my_list:\n", 490 | " clean_el = int(el.replace('%',''))\n", 491 | " clean_list.append(clean_el)\n", 492 | " " 493 | ] 494 | }, 495 | { 496 | "cell_type": "code", 497 | "execution_count": 49, 498 | "metadata": {}, 499 | "outputs": [ 500 | { 501 | "data": { 502 | "text/plain": [ 503 | "[2, 45, 6]" 504 | ] 505 | }, 506 | "execution_count": 49, 507 | "metadata": {}, 508 | "output_type": "execute_result" 509 | } 510 | ], 511 | "source": [ 512 | "clean_list" 513 | ] 514 | }, 515 | { 516 | "cell_type": "code", 517 | "execution_count": 87, 518 | "metadata": {}, 519 | "outputs": [], 520 | "source": [ 521 | "#допустим у нас есть данные о количестве преступников в каких-то населенных пунктах\n", 522 | "crimes = [30000, 10000, 200]\n", 523 | "# И мы хотим узнать, в каком из этих населенных пунктах самая криминогенная обстановка. " 524 | ] 525 | }, 526 | { 527 | "cell_type": "code", 528 | "execution_count": 88, 529 | "metadata": {}, 530 | "outputs": [ 531 | { 532 | "data": { 533 | "text/plain": [ 534 | "30000" 535 | ] 536 | }, 537 | "execution_count": 88, 538 | "metadata": {}, 539 | "output_type": "execute_result" 540 | } 541 | ], 542 | "source": [ 543 | "max(crimes) \n", 544 | "#функция max вернет нам само большое число из списка. а функция min — самое маленькое" 545 | ] 546 | }, 547 | { 548 | "cell_type": "markdown", 549 | "metadata": {}, 550 | "source": [ 551 | "Технически это будет правильный ответ. Но не все так просто. Показатели типа количества преступников, детей сирот, людей с алкогольной зависимость и так далее обязательно нужно нормировать на количество всех людей проживающих в этом населенном пункте. Иначе всегда бы оказывалось, что Москва самый опасный город в России просто потому, что в Москве живет больше всего людей. Поэтому нам пригодится еще одна строчка в таблице" 552 | ] 553 | }, 554 | { 555 | "cell_type": "code", 556 | "execution_count": null, 557 | "metadata": {}, 558 | "outputs": [], 559 | "source": [ 560 | "population = [100000, 50000, 1000] #вот такой" 561 | ] 562 | }, 563 | { 564 | "cell_type": "code", 565 | "execution_count": null, 566 | "metadata": {}, 567 | "outputs": [], 568 | "source": [ 569 | "# поэтому будет нормировать вот по этой формуле\n", 570 | "количество преступлений/население * 1000" 571 | ] 572 | }, 573 | { 574 | "cell_type": "code", 575 | "execution_count": 61, 576 | "metadata": {}, 577 | "outputs": [ 578 | { 579 | "name": "stdout", 580 | "output_type": "stream", 581 | "text": [ 582 | "[300.0, 200.0, 200.0]\n" 583 | ] 584 | } 585 | ], 586 | "source": [ 587 | "norm_crimes = []\n", 588 | "for i in range(len(crimes)):\n", 589 | " norm_crimes.append(crimes[i]/population[i]*1000)\n", 590 | "print(norm_crimes) " 591 | ] 592 | }, 593 | { 594 | "cell_type": "code", 595 | "execution_count": 89, 596 | "metadata": {}, 597 | "outputs": [], 598 | "source": [ 599 | "# если мы объединим все три списка в один, то по сути получим обычную таблицу.\n", 600 | "\n", 601 | "city_names = ['city1', 'city2', 'city3']\n", 602 | "crimes = [30000, 10000, 200]\n", 603 | "population = [100000, 50000, 1000]\n", 604 | "norm_crimes = [300.0, 200.0, 200.0]" 605 | ] 606 | }, 607 | { 608 | "cell_type": "code", 609 | "execution_count": 90, 610 | "metadata": {}, 611 | "outputs": [ 612 | { 613 | "data": { 614 | "text/plain": [ 615 | "[['city1', 'city2', 'city3'],\n", 616 | " [30000, 10000, 200],\n", 617 | " [100000, 50000, 1000],\n", 618 | " [300.0, 200.0, 200.0]]" 619 | ] 620 | }, 621 | "execution_count": 90, 622 | "metadata": {}, 623 | "output_type": "execute_result" 624 | } 625 | ], 626 | "source": [ 627 | "[city_names, crimes, population, norm_crimes]" 628 | ] 629 | }, 630 | { 631 | "cell_type": "markdown", 632 | "metadata": {}, 633 | "source": [ 634 | "Можем еще добить нашу табличку, посчитав сумму всех преступников, сумму населения для всех населенных пунктов и общий нормированный показатель для всех населенных пунктов. Чтобы узнать сумму всех чисел в списке, нам не нужно ходить циклом по списку и прибавлять один элемент за другим. Можно использовать sum()." 635 | ] 636 | }, 637 | { 638 | "cell_type": "code", 639 | "execution_count": 84, 640 | "metadata": {}, 641 | "outputs": [ 642 | { 643 | "data": { 644 | "text/plain": [ 645 | "120600" 646 | ] 647 | }, 648 | "execution_count": 84, 649 | "metadata": {}, 650 | "output_type": "execute_result" 651 | } 652 | ], 653 | "source": [ 654 | "total_crimes = sum(crimes) # sum() вернет сумму всех чисел в списке\n", 655 | "total_crimes" 656 | ] 657 | }, 658 | { 659 | "cell_type": "code", 660 | "execution_count": 68, 661 | "metadata": {}, 662 | "outputs": [ 663 | { 664 | "data": { 665 | "text/plain": [ 666 | "151000" 667 | ] 668 | }, 669 | "execution_count": 68, 670 | "metadata": {}, 671 | "output_type": "execute_result" 672 | } 673 | ], 674 | "source": [ 675 | "total_population = sum(population)\n", 676 | "total_population" 677 | ] 678 | }, 679 | { 680 | "cell_type": "code", 681 | "execution_count": 85, 682 | "metadata": {}, 683 | "outputs": [ 684 | { 685 | "data": { 686 | "text/plain": [ 687 | "798.6754966887418" 688 | ] 689 | }, 690 | "execution_count": 85, 691 | "metadata": {}, 692 | "output_type": "execute_result" 693 | } 694 | ], 695 | "source": [ 696 | "total_norm = total_crimes/total_population * 1000\n", 697 | "total_norm" 698 | ] 699 | }, 700 | { 701 | "cell_type": "code", 702 | "execution_count": 75, 703 | "metadata": {}, 704 | "outputs": [ 705 | { 706 | "data": { 707 | "text/plain": [ 708 | "[30000, 10000, 200, 40200, 40200]" 709 | ] 710 | }, 711 | "execution_count": 75, 712 | "metadata": {}, 713 | "output_type": "execute_result" 714 | } 715 | ], 716 | "source": [ 717 | "crimes.append(total_crimes)\n", 718 | "crimes" 719 | ] 720 | }, 721 | { 722 | "cell_type": "code", 723 | "execution_count": 74, 724 | "metadata": {}, 725 | "outputs": [ 726 | { 727 | "data": { 728 | "text/plain": [ 729 | "[100000, 50000, 1000, 151000]" 730 | ] 731 | }, 732 | "execution_count": 74, 733 | "metadata": {}, 734 | "output_type": "execute_result" 735 | } 736 | ], 737 | "source": [ 738 | "population.append(total_population)\n", 739 | "population" 740 | ] 741 | }, 742 | { 743 | "cell_type": "code", 744 | "execution_count": 76, 745 | "metadata": {}, 746 | "outputs": [ 747 | { 748 | "data": { 749 | "text/plain": [ 750 | "[300.0, 200.0, 200.0, 266.2251655629139]" 751 | ] 752 | }, 753 | "execution_count": 76, 754 | "metadata": {}, 755 | "output_type": "execute_result" 756 | } 757 | ], 758 | "source": [ 759 | "norm_crimes.append(total_norm)\n", 760 | "norm_crimes" 761 | ] 762 | }, 763 | { 764 | "cell_type": "code", 765 | "execution_count": null, 766 | "metadata": {}, 767 | "outputs": [], 768 | "source": [] 769 | } 770 | ], 771 | "metadata": { 772 | "kernelspec": { 773 | "display_name": "Python 3", 774 | "language": "python", 775 | "name": "python3" 776 | }, 777 | "language_info": { 778 | "codemirror_mode": { 779 | "name": "ipython", 780 | "version": 3 781 | }, 782 | "file_extension": ".py", 783 | "mimetype": "text/x-python", 784 | "name": "python", 785 | "nbconvert_exporter": "python", 786 | "pygments_lexer": "ipython3", 787 | "version": "3.8.3" 788 | } 789 | }, 790 | "nbformat": 4, 791 | "nbformat_minor": 4 792 | } 793 | -------------------------------------------------------------------------------- /Регулярные выражения. Python.ipynb: -------------------------------------------------------------------------------- 1 | { 2 | "cells": [ 3 | { 4 | "cell_type": "code", 5 | "execution_count": 1, 6 | "metadata": {}, 7 | "outputs": [], 8 | "source": [ 9 | "import re" 10 | ] 11 | }, 12 | { 13 | "cell_type": "code", 14 | "execution_count": 13, 15 | "metadata": {}, 16 | "outputs": [ 17 | { 18 | "data": { 19 | "text/plain": [ 20 | "'суд'" 21 | ] 22 | }, 23 | "execution_count": 13, 24 | "metadata": {}, 25 | "output_type": "execute_result" 26 | } 27 | ], 28 | "source": [ 29 | "s = 'суд приговор суд'\n", 30 | "result = re.match(r'суд', s)\n", 31 | "result.group(0)" 32 | ] 33 | }, 34 | { 35 | "cell_type": "code", 36 | "execution_count": 4, 37 | "metadata": {}, 38 | "outputs": [ 39 | { 40 | "ename": "AttributeError", 41 | "evalue": "'NoneType' object has no attribute 'group'", 42 | "output_type": "error", 43 | "traceback": [ 44 | "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", 45 | "\u001b[0;31mAttributeError\u001b[0m Traceback (most recent call last)", 46 | "\u001b[0;32m\u001b[0m in \u001b[0;36m\u001b[0;34m\u001b[0m\n\u001b[1;32m 1\u001b[0m \u001b[0ms\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;34m'суд приговор суд'\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 2\u001b[0m \u001b[0mresult\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mre\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mmatch\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34mr'приговор'\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0ms\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m----> 3\u001b[0;31m \u001b[0mresult\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mgroup\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;36m0\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m", 47 | "\u001b[0;31mAttributeError\u001b[0m: 'NoneType' object has no attribute 'group'" 48 | ] 49 | } 50 | ], 51 | "source": [ 52 | "s = 'суд приговор суд'\n", 53 | "result = re.match(r'приговор', s)\n", 54 | "result.group(0)" 55 | ] 56 | }, 57 | { 58 | "cell_type": "code", 59 | "execution_count": 5, 60 | "metadata": {}, 61 | "outputs": [ 62 | { 63 | "data": { 64 | "text/plain": [ 65 | "'приговор'" 66 | ] 67 | }, 68 | "execution_count": 5, 69 | "metadata": {}, 70 | "output_type": "execute_result" 71 | } 72 | ], 73 | "source": [ 74 | "s = 'суд приговор суд'\n", 75 | "result = re.search(r'приговор', s)\n", 76 | "result.group(0)" 77 | ] 78 | }, 79 | { 80 | "cell_type": "code", 81 | "execution_count": 7, 82 | "metadata": {}, 83 | "outputs": [ 84 | { 85 | "data": { 86 | "text/plain": [ 87 | "['суд', 'суд']" 88 | ] 89 | }, 90 | "execution_count": 7, 91 | "metadata": {}, 92 | "output_type": "execute_result" 93 | } 94 | ], 95 | "source": [ 96 | "s = 'суд приговор суд'\n", 97 | "result = re.findall(r'суд', s)\n", 98 | "result" 99 | ] 100 | }, 101 | { 102 | "cell_type": "code", 103 | "execution_count": 8, 104 | "metadata": {}, 105 | "outputs": [ 106 | { 107 | "data": { 108 | "text/plain": [ 109 | "'Судья Нагатинского районного суда вынесла оправдательный приговор'" 110 | ] 111 | }, 112 | "execution_count": 8, 113 | "metadata": {}, 114 | "output_type": "execute_result" 115 | } 116 | ], 117 | "source": [ 118 | "s = 'Судья Нагатинского районного суда вынесла обвинительный приговор'\n", 119 | "re.sub('обвинительный', 'оправдательный', s)" 120 | ] 121 | }, 122 | { 123 | "cell_type": "code", 124 | "execution_count": 18, 125 | "metadata": {}, 126 | "outputs": [ 127 | { 128 | "data": { 129 | "text/plain": [ 130 | "['Иванова А. А.']" 131 | ] 132 | }, 133 | "execution_count": 18, 134 | "metadata": {}, 135 | "output_type": "execute_result" 136 | } 137 | ], 138 | "source": [ 139 | "s = 'Судья Нагатинского районного суда Иванова А. А. вынесла обвинительный приговор'\n", 140 | "pattern = r\"[А-ЯЁа-яё]+\\s[А-ЯЁа-яё]{1}\\.\\s*[А-ЯЁа-яё]{1}\\.\"\n", 141 | "name = re.findall(pattern, s)\n", 142 | "name" 143 | ] 144 | }, 145 | { 146 | "cell_type": "code", 147 | "execution_count": 2, 148 | "metadata": {}, 149 | "outputs": [], 150 | "source": [ 151 | "file = open('/Users/alesyamarohovskaya/Desktop/приговор.txt')\n", 152 | "text = file.read()" 153 | ] 154 | }, 155 | { 156 | "cell_type": "code", 157 | "execution_count": 3, 158 | "metadata": {}, 159 | "outputs": [ 160 | { 161 | "data": { 162 | "text/plain": [ 163 | "'ПРИГОВОР\\nИМЕНЕМ РОССИЙСКОЙ ФЕДЕРАЦИИ\\n01 декабря 2016 года Москва\\nПреображенский районный суд Москвы в составе судьи Духновской З.А., при секретаре Горшковой А.А., с участием государственных обвинителей Давыдовой Д.Е., Дудукова М.Ю., Чубенко А.А., подсудимого ************а А.А., его защитников – адвокатов Попова А.В., Колокольниковой Е.В., рассмотрев в открытом судебном заседании уголовное дело по обвинению:\\n************ ****** **************, ** ** **** года рождения, уроженца г. Москвы, гражданина РФ, зарегистрированного по адресу: *****************, со средне-специальным образованием, холостого, не работающего, не судимого, в совершении преступления, предусмотренного ч. 3 ст. 30, п.«г» ч. 4 ст. 228-1 УК РФ, \\nУСТАНОВИЛ:\\n************ ****** ******** совершил покушение на незаконный сбыт наркотических средств, то есть умышленные действия, непосредственно направленные на незаконный сбыт наркотических средств, совершенные группой лиц по предварительному сговору, в крупном размере, при этом преступление не было доведено до конца по не зависящим от него обстоятельствам, а именно:\\nТак ************ А.А., с целью быстрого и незаконного материального обогащения, из корыстных побуждений, имея преступный умысел, направленный на незаконный сбыт наркотических средств группой лиц по предварительному сговору, в крупном размере, осознавая общественную опасность последствий своих действий и желая их наступления, в нарушение ст. ст. 5, 8, 14, 20 и 24 Федерального Закона РФ от 8 января 1998 года № 3-ФЗ «О наркотических средствах и психотропных веществах», в неустановленное время и месте, в период до 17 часов 59 минут 16 сентября 2015 года, вступил в предварительный преступный сговор с неустановленными соучастниками, с целью незаконного приобретения и последующего умышленного и незаконного сбыта наркотических средств, в крупном размере, распределили между собой преступные роли каждого и разработали преступный план. \\nВо исполнение своего совместного преступного плана, согласно распределению ролей, один из его неустановленных соучастников, в неустановленном время и месте, в период до 17 часов 59 минут 16 сентября 2015 года, при неустановленных обстоятельствах, в нарушение Федерального закона РФ от 8 января 1998 года № 3-ФЗ «О наркотических средствах и психотропных веществах» незаконно приобрел у неустановленного лица наркотическое средство – героин, в крупном размере, расфасованное в сто пятьдесят один сверток из полимерного материала общей массой 293,25 г., упакованные в сверток из полимерного материала с веществом, после чего, второй неустановленный соучастник ************а А.А., продолжая реализовывать совместный с последним преступный умысел, поместил указанный сверток с наркотическим средством в тайник, оборудованный возле одиннадцатого дерева от начала зеленого забора на парковке, возле ресторана «Чайхона» по адресу: г.Москва, ул.Первомайская, д. 106а, о месте нахождения которого сообщил ************у А.А. в ходе телефонного разговора первый неустановленный соучастник.\\nПродолжая реализовывать совместный с соучастниками преступный умысел, в совместных с соучастниками интересах, ************ А.А. 16 сентября 2015 года, в 17 часов 59 минут прибыл по вышеуказанному адресу, где забрал из вышеуказанного тайника сверток со ста пятьюдесятью одним свертком из полимерного материала, с находящимся внутри каждого свертка наркотическим средством - героин, общей массой 293,25 г., о чем сообщил в ходе телефонного разговора своему первому неустановленному соучастнику, после чего ************ А.А. убрал вышеуказанный сверток с наркотическим средством – героин, в левый карман джинсовых брюк одетых на нём, которое хранил при себе, и данное наркотическое средство по указанию своего первого неустановленного соучастника, с целью дальнейшего сбыта указанного наркотического средства неустановленным лицам через «закладку» должен был направиться по адресу, где совместно и согласованно, по указанию второго, неустановленного соучастника, планировал поместить наркотические средства в «закладки» в неустановленных местах, однако ************ А.А. и его неустановленные соучастники не смогли осуществить свой преступный умысел до конца, по не зависящим от них обстоятельствам, так как в 18 часов 10 минут 16 сентября 2015 года ************ А.А. был задержан сотрудниками 2 отдела Службы по ВАО ФСКН России по г.Москве в ходе проведенного оперативно – розыскного мероприятия «Наблюдение» по адресу: г.Москва, ул.Первомайская, д. 106а. \\nДалее, 16 сентября 2015 года, в период времени с 19 часов 25 минут по 20 часов 10 минут, в помещении Службы по ВАО ФСКН России по г. Москве, расположенном по адресу: г. Москва, ул. Буженинова, д. 12, в ходе проведения личного досмотра, из левого кармана джинсовых штанов, одетых на ************е А.А., был обнаружен и изъят сверток из полимерного материала, внутри которого находился 151 (сто пятьдесят один) расфасованный в полимерный материал сверток, с веществом в виде порошка и комков внутри каждого свертка, которое, согласно заключению эксперта № Э-1/2317-15 от 16 октября 2015 года является наркотическим средством – героин, и которое, согласно Постановлению Правительства Российской Федерации от 30 июня 1998 года № 681 «Об утверждении перечня наркотических средств, психотропных веществ и их прекурсоров, подлежащих контролю в Российской Федерации» (в редакции постановления Правительства Российской Федерации от 1 апреля 2016 года № 256), является наркотическим средством и входят в список наркотических средств, оборот которых в Российской Федерации запрещен, общей массой 293,25 г. из ста пятидесяти одного свертка, что согласно Постановлению Правительства РФ от 1 октября 2012 года № 1002 «Об утверждении значительного, крупного и особо крупного размеров наркотических средств и психотропных веществ, а также значительного, крупного и особо крупного размеров для растений, содержащих наркотические средства или психотропные вещества, либо их частей, содержащих наркотические средства или психотропные вещества, для целей статей 228, 228¹, 229 и 229¹ УК РФ», является крупным размером. \\nТаким образом, ************ А.А. и его неустановленные соучастники, действуя совместно и согласованно, не довели свой совместный преступный умысел, направленный на незаконный сбыт наркотических средств, в крупном размере до конца, по не зависящим от них обстоятельствам, так как ************ А.А. был задержан сотрудниками 2 отдела Службы по ВАО ФСКН России по г. Москве в ходе проведенного оперативно – розыскного мероприятия «Наблюдение» по адресу: г. Москва, ул. Первомайская, д. 106а, и вышеуказанное наркотическое средство было изъято в ходе проведения личного досмотра ************а А.А.\\nДопрошенный в судебном заседании подсудимый вину признал частично, подтвердил фактические обстоятельства, изложенные выше, показал, что приобрел и хранил для собственного употребления наркотическое средство общим весом 293,25 г., которое 16 сентября 2015 года было обнаружено и изъято при изложенных обстоятельствах, отрицал умысел на покушение на сбыт. \\nСуд, проведя судебное следствие, выслушав судебные прения и последнее слово подсудимого, считает, что в судебном заседании вина ************а А.А. в инкриминируемом преступлении доказана следующими исследованными в судебном заседании доказательствами:\\n- показаниями ************а А.А. на предварительном следствии, согласно которым извлек из закладки сверток с героином массой 293,25 г., с целью дальнейшего сбыта, которое 16 сентября 2015 года было обнаружено и изъято при изложенных обстоятельствах;\\n- показаниями свидетелей Биткова А.Ю. и Орел И.В., понятых, в основном аналогичными, согласно которым 16 сентября 2015 года у ************а А.А. при личном досмотре изъяты: из левого кармана джинс - полимерный сверток со 151 свертками из полиэтилена, с веществом, мобильные телефоны «Самсунг» и «Сони Эриксон», сим-карты, шприц, два пузырька. ************ А.А. пояснил, что в 151 свертках - наркотическое средство, героин, которое извлек из закладки с целью сбыта. Процедура досмотра снималась на видеокамеру;\\n- показаниями свидетеля Русинова А.А., согласно которым 16 сентября 2015 года, в вечернее время, он, Русинов А.А., и ************ А.А., по предложению последнего, подошли к дому 106 по ул. Первомайской г.Москвы, ресторану «Чайхана», где ************ А.А., подняв что-то около дерева, положил в левый карман джинс. Около дома 106А по ул. Первомайская г. Москвы были задержаны полицией, доставлены по адресу: г. Москва, ул. Буженинова, д.12, где проведен личный досмотр, получены срезы ногтевых пластин, смывы;\\n- показаниями свидетелей Прасолова Д.А., Кормилицына Д.А., Лукашенко А.А., полицейских, в основном аналогичными, согласно которым 16 сентября 2015 года в рамках ОРМ «Наблюдение» по адресу: г. Москва, ул. Первомайская, д. 106а задержан ************ А.А. В ходе досмотра у ************а А.А. изъяты: из левого кармана джинс полимерный сверток со 151 свертками из полиэтилена, с веществом, также изъяты мобильные телефоны «Самсунг» и «Сони Эриксон», сим-карты, шприц, два пузырька. ************ А.А. пояснил, что в 151 свертке наркотическое средство - героин, которое извлек из закладки с целью сбыта, мобильные телефоны принадлежат ему, ************у А.А., рюкзак - Русинову А.А. Лукашенко А.А. выдал Кормилицыну Д.А. видеокамеру. При осмотре обнаружен видеофайл с личным досмотром ************а А.А.;\\n- протоколом очной ставки между обвиняемым и свидетелем Русиновым А.А., в ходе проведения которой ************ А.А. дал показания аналогичные ранее данным на предварительном следствии, Русинов А.А. – аналогичные изложенным выше (л.д. 82-86);\\n- актом досмотра и изъятия, согласно которым 16 сентября 2015 года, по адресу: г. Москва, ул. Буженинова д. 12, в присутствии понятых, в ходе проведения личного досмотра из левого кармана джинс ************а А.А. изъят сверток со 151 свертками из полимерного материала, с веществом в виде порошка светлого цвета, также изъяты мобильные телефоны «SONY ERICSSON», IMEI: 3559901-570169-9 с сим-картой оператора сотовой связи «Билайн», «Samsung», IMEI: 357795/05/044571/1 с сим-картой оператора сотовой связи «Мегафон» (л.д.15-20);\\n- актом осмотра и копирования видео-материалов, согласно которого по адресу: г.Москва, ул.Буженинова, д.12 Лукашенко А.А. выдана цифровая видеокамера Panasonic HC-V11ЕЕ, камера осмотрена, обнаруженная информация перекопирована на диск DVD-R (л.д. 25);\\n- протоколами осмотра предметов, согласно которым осмотрены: конверты и полимерный пакет, поступившие с экспертизы, в ходе осмотра не вскрывались; конверты с мобильными телефонами, шприцем, два пузырька, диск формата DVD R № MFP 696SKO222264 с видеозаписью личного досмотра ************а А.А.; компакт диски «Smart Track» CD-R 52х с записями ОРМ «ПТП» (л.д.106-108,114-115,160-168);\\n- заключением химической судебной экспертизы № Э-1/2317-15, согласно которому вещества в виде порошка и комков светло-бежевого цвета из 151 упаковки, изъятые у ************а А.А., - наркотическое средство, героин, массой 293,15 г. После экспертизы - масса 290,13 г. (л.д.97-103);\\n- рапортом об обнаружении признаков преступления в действиях ************а А.А. (л.д. 3);\\n- справкой об исследовании № И-1/1657, согласно которой в пакете: 151 сверток из полимерного материала, в каждом - сверток с веществом в виде порошка и комков. На исследование отбиралась представительная проба по 0,01 г от десяти свертков. Общая масса исследованных веществ 20,05 г. Установлено, что в составе исследуемых веществ содержится героин (л.д. 51);\\n- протоколом осмотра места происшествия, согласно которого осмотрен участок местности по адресу: г. Москва, ул. Первомайская, д. 106а, возле одиннадцатого дерева от начала забора на парковке ресторана «Чайхана», ничего не изымалось (л.д. 205-206);\\n- постановлением о признании и приобщении в качестве вещественных доказательств: героина, изъятого в ходе личного досмотра ************а А.А, срезов ногтевых пластин, смывов, компакт-дисков, мобильный телефон (л.д.109-110, 117-118).\\nОценивая вышеприведенные доказательства в их совокупности и признавая их относимыми, допустимыми доказательствами по делу, существенных противоречий не содержащих, достаточными, суд приходит к выводу о доказанности вины ************а А.А. в совершении преступления, описанного в приговоре выше, в связи с этим суд квалифицирует действия ************а А.А. по ч.3 ст.30, п.«г» ч.4 ст.228-1 УК РФ, как покушение на незаконный сбыт наркотических средств, то есть умышленные действия, непосредственно направленные на незаконный сбыт наркотических средств, совершенные группой лиц по предварительному сговору, в крупном размере, при этом, преступление не было доведено до конца по не зависящим от него обстоятельствам.\\nПри этом суд не доверяет показаниям подсудимого в судебном заседании в части отрицания умысла на сбыт, считает, что показания в этой части опровергаются показаниями подсудимого на предварительном следствии, которым у суда оснований не доверять нет, так как они последовательны, непротиворечивы, и согласуются со всеми исследованными в судебном заседании доказательствами. \\nКроме того о наличии в действиях ************а А.А. умысла на сбыт наркотического средства по мнению суда свидетельствует объем изъятого наркотического средства, его расфасовка, то, что изъятие произошло в рамках ОРМ. \\nПри назначении наказания суд учитывает характер и степень общественной опасности совершенного преступления, отнесенного законодателем к категории особо тяжких, и данные о личности подсудимого, учитывая следующее.\\nПодсудимый ************ А.А. не судим, вину частично признал, страдает заболеваниями, мать пенсионерка, ветеран труда, также страдает заболеваниями, что суд признает в качестве обстоятельств, смягчающих наказание.\\nОбстоятельств, отягчающих наказание, судом не установлено.\\nС учетом конкретных обстоятельств дела, данных о личности подсудимого, суд приходит к выводу, что исправление ************а А.А. возможно только в условиях изоляции от общества и, назначая наказание в виде лишения свободы, не усматривает оснований для применения ст.ст.15 ч.6,64,73 УК РФ.\\nСуд, учитывая смягчающие обстоятельства, полагает нецелесообразным назначение дополнительного наказания в виде штрафа.\\nУчитывая, что подсудимый не работает, оснований для назначения дополнительного наказания в виде лишения права занимать определенные должности или заниматься определенной деятельностью, суд не усматривает.\\nМестом отбывания наказания суд определяет исправительную колонию строгого режима. \\nПри постановлении приговора суд считает необходимым распорядиться судьбой вещественных доказательств.\\nНа основании изложенного и руководствуясь ст.ст.296-299, 307-309 УПК РФ, суд\\nПРИГОВОРИЛ:\\n****************** признать виновным в совершении преступления, предусмотренного ч.3 ст. 30, п.«г» ч. 4 ст. 228-1 УК РФ и назначить уголовное наказание в виде лишения свободы сроком 10 (десять) лет, с отбыванием наказания в исправительной колонии строгого режима, с исчислением срока наказания с 01 декабря 2016 года.\\nЗасчитать в срок отбытия наказания срок содержания ************а Андрея Александровича под стражей с 16 сентября 2015 года до 01 декабря 2016 года.\\nМеру пресечения осужденному *************************** до вступления приговора в законную силу оставить прежней, – содержание под стражей.\\nВещественное доказательство: наркотическое средство, конверты, срезы ногтевых пластин, смывы, сим карту оператора «Мегафон», - уничтожить; компакт диск, - оставить при материалах уголовного дела; мобильный телефон «Samsung» IMEI:357795/05/044571/1, - вернуть по принадлежности ************у А.А. \\n Приговор может быть обжалован в Московский городской суд в течение 10 дней со дня его провозглашения, осужденным в тот же срок со дня получения им копии приговора. В случае подачи апелляционной жалобы осужденный имеет право принять участие в рассмотрении дела судом апелляционной инстанции.\\n\\n\\tСудья Духновская З.А. \\n'" 164 | ] 165 | }, 166 | "execution_count": 3, 167 | "metadata": {}, 168 | "output_type": "execute_result" 169 | } 170 | ], 171 | "source": [ 172 | "text" 173 | ] 174 | }, 175 | { 176 | "cell_type": "code", 177 | "execution_count": 12, 178 | "metadata": {}, 179 | "outputs": [ 180 | { 181 | "data": { 182 | "text/plain": [ 183 | "'сроком 10 (десять) лет и 6 месяцев'" 184 | ] 185 | }, 186 | "execution_count": 12, 187 | "metadata": {}, 188 | "output_type": "execute_result" 189 | } 190 | ], 191 | "source": [ 192 | "s = 'назначить уголовное наказание в виде лишения свободы сроком 10 (десять) лет и 6 месяцев'\n", 193 | "\n", 194 | "pattern = r\"сроком*\\s(.+)\\s*(лет)*((.+)*месяц\\w+)*\"\n", 195 | "result = re.search(pattern, s) \n", 196 | "result[0]" 197 | ] 198 | }, 199 | { 200 | "cell_type": "code", 201 | "execution_count": 6, 202 | "metadata": {}, 203 | "outputs": [ 204 | { 205 | "data": { 206 | "text/plain": [ 207 | "'10 (десять) лет'" 208 | ] 209 | }, 210 | "execution_count": 6, 211 | "metadata": {}, 212 | "output_type": "execute_result" 213 | } 214 | ], 215 | "source": [ 216 | "def find_prison_term(text):\n", 217 | " return re.sub('сроком', '', re.search(r\"сроком*\\s(.+)\\s*(лет)*((.+)*месяц\\w+)*\", text)[0]).strip()\n", 218 | "s = 'назначить уголовное наказание в виде лишения свободы сроком 10 (десять) лет'\n", 219 | "find_prison_term(s) " 220 | ] 221 | }, 222 | { 223 | "cell_type": "code", 224 | "execution_count": 11, 225 | "metadata": {}, 226 | "outputs": [ 227 | { 228 | "data": { 229 | "text/plain": [ 230 | "[('alesya.marohovskaya@gmail.com', 'alesya.marohovskaya', 'gmail.com')]" 231 | ] 232 | }, 233 | "execution_count": 11, 234 | "metadata": {}, 235 | "output_type": "execute_result" 236 | } 237 | ], 238 | "source": [ 239 | "text = 'вы можете написать alesya.marohovskaya@gmail.com'\n", 240 | "pattern = r\"(([a-z0-9._%-]+)@([a-z0-9._-]+\\.[a-z]{2,}))\"\n", 241 | "re.findall(pattern, text)" 242 | ] 243 | }, 244 | { 245 | "cell_type": "code", 246 | "execution_count": null, 247 | "metadata": {}, 248 | "outputs": [], 249 | "source": [] 250 | } 251 | ], 252 | "metadata": { 253 | "kernelspec": { 254 | "display_name": "Python 3", 255 | "language": "python", 256 | "name": "python3" 257 | }, 258 | "language_info": { 259 | "codemirror_mode": { 260 | "name": "ipython", 261 | "version": 3 262 | }, 263 | "file_extension": ".py", 264 | "mimetype": "text/x-python", 265 | "name": "python", 266 | "nbconvert_exporter": "python", 267 | "pygments_lexer": "ipython3", 268 | "version": "3.8.3" 269 | } 270 | }, 271 | "nbformat": 4, 272 | "nbformat_minor": 4 273 | } 274 | -------------------------------------------------------------------------------- /Задачи для тренировок.ipynb: -------------------------------------------------------------------------------- 1 | { 2 | "cells": [ 3 | { 4 | "cell_type": "markdown", 5 | "metadata": {}, 6 | "source": [ 7 | "## Задачи для самостоятельных тренировок по курсу Мастерской «Важных историй» — «Пограммирование на языке Python для журналистов».\n", 8 | "\n", 9 | "#### Основано на задачах из курса Ильи Щурова. Cсылка на курс: https://clck.ru/S8TAk\n", 10 | "\n", 11 | "#### Смотреть уроки Мастерской здесь: https://clck.ru/S8Wwe\n" 12 | ] 13 | }, 14 | { 15 | "cell_type": "markdown", 16 | "metadata": {}, 17 | "source": [ 18 | "### Для выполнения заданий:\n", 19 | "\n", 20 | "1) Скачайте эту тетрадку на свой компьютер: для этого нажмите raw → «сохранить как» → формат файла вместо txt напишите ipynb. \n", 21 | "\n", 22 | "2) После открытия Jupyter загрузите скаченную тетрадку через Upload (в правом верхнем углу).\n", 23 | "\n", 24 | "3) Найдите ее в списке тетрадок на той же странице и откройте. \n", 25 | "\n", 26 | "4) Активируйте тесты: это первая ячейка с кодом. Тогда ваши ответы на задания будут проверяться на ошибки. \n", 27 | "\n", 28 | "5) Вставляйте решение каждой задачи в ячейку для кода строго там, где написан комментарий # YOUR CODE HERE. Отступ вашего кода должен составлять 4 пробела (кнопка tab). Ничего не меняйте вокруг!\n", 29 | "\n", 30 | "6) Запустите ячейку после того, как вставили код с решением. Введите входные данные, если это нужно. Проверьте визуально правильность вывода. \n", 31 | "\n", 32 | "7) Запустите следующую ячейку, которая начинается с test_data (в ней содержится тест). Если запуск ячейки с тестом не приводит к появлению ошибки (assertion), значит, всё в порядке, задача решена. Если приводит к появлению ошибки, значит, тест не пройден и нужно искать ошибку.\n", 33 | "\n", 34 | "*Внимание!*\n", 35 | "\n", 36 | "Если в какой-то момент забыть ввести входные данные и перейти на следующую ячейку, есть риск, что Notebook перестанет откликаться. В этом случае надо перезапустить ядро: Kernel → Restart. При этом потеряются все значения переменных, но сам код останется.\n", 37 | "\n", 38 | "В задачах вам потребуется написать код, запрашивающий данные с клавиатуры с помощью функции input(). Обратите внимание: input() всегда возвращает строку, чтобы преобразовать результат к другому типу, нужно использовать соответствующие функции\n", 39 | "\n", 40 | "### Удачи!" 41 | ] 42 | }, 43 | { 44 | "cell_type": "code", 45 | "execution_count": 8, 46 | "metadata": { 47 | "collapsed": true 48 | }, 49 | "outputs": [], 50 | "source": [ 51 | "# Фабрика тестов для проверки программ, принимающих данные через input()\n", 52 | "\n", 53 | "from collections import deque\n", 54 | "\n", 55 | "class Tester(object):\n", 56 | " def __init__(self, inp):\n", 57 | " self.outputs = []\n", 58 | " self.inputs = deque(inp)\n", 59 | " def print(self, *args, sep = \" \", end = \"\\n\"):\n", 60 | " self.outputs.append(sep.join(map(str,args)) + end)\n", 61 | " def input(self, *args):\n", 62 | " assert self.inputs, \"Вы пытаетесь считать больше элементов, чем предусмотрено условием\"\n", 63 | " return self.inputs.popleft()\n", 64 | " def __enter__(self):\n", 65 | " global print\n", 66 | " global input\n", 67 | " print = self.print\n", 68 | " input = self.input\n", 69 | " return self.outputs\n", 70 | " def __exit__(self, *args):\n", 71 | " global print\n", 72 | " global input\n", 73 | " del print\n", 74 | " del input" 75 | ] 76 | }, 77 | { 78 | "cell_type": "markdown", 79 | "metadata": {}, 80 | "source": [ 81 | "### Для решения задач вам пригодятся знания из первых четырех уроков Мастерской и, возможно, умение гуглить (оно будет пригождаться в принципе всегда) \n", 82 | "\n", 83 | "*Внимание: фукнция input() объясняется в начале 3 урока*" 84 | ] 85 | }, 86 | { 87 | "cell_type": "markdown", 88 | "metadata": {}, 89 | "source": [ 90 | "### Задача 1\n", 91 | "\n", 92 | "Напишите программу, которая последовательно запрашивает три целых числа с помощью input() (после ввода каждого числа пользователь нажимает «Enter» — иными словами, каждое число вводится на отдельной строке) и выводит их сумму.\n", 93 | "\n", 94 | "**Пример**\n", 95 | "\n", 96 | "*Входные данные*\n", 97 | "\n", 98 | "1\n", 99 | "2\n", 100 | "3\n", 101 | "\n", 102 | "*Выходные данные*\n", 103 | "\n", 104 | "6\n", 105 | "\n", 106 | "*Подсказка.* Вам придётся вызвать input() три раза." 107 | ] 108 | }, 109 | { 110 | "cell_type": "code", 111 | "execution_count": null, 112 | "metadata": { 113 | "collapsed": true 114 | }, 115 | "outputs": [], 116 | "source": [ 117 | "def sum3():\n", 118 | " # YOUR CODE HERE\n", 119 | " \n", 120 | "sum3()" 121 | ] 122 | }, 123 | { 124 | "cell_type": "code", 125 | "execution_count": null, 126 | "metadata": { 127 | "collapsed": true 128 | }, 129 | "outputs": [], 130 | "source": [ 131 | "test_data = [\n", 132 | " (\"0 0 0\", 0),\n", 133 | " (\"1 2 10\", 13),\n", 134 | " (\"-1 -5 100\", 100-6),\n", 135 | " (\"0 20 300\", 320),\n", 136 | " (\"-5 180 -17\", 158)\n", 137 | "]\n", 138 | "\n", 139 | "for inp, out in test_data:\n", 140 | " with Tester(inp.split()) as t:\n", 141 | " sum3()\n", 142 | " assert len(t) == 1, \"Вам нужно вывести ровно одну строку с ответом\"\n", 143 | " assert t[0].strip() == str(out), \"Неверный ответ, были введены числа \" + inp\n", 144 | "print(\"Это было просто, да? Дальше будет интереснее!\")" 145 | ] 146 | }, 147 | { 148 | "cell_type": "markdown", 149 | "metadata": {}, 150 | "source": [ 151 | "### Задача 2\n", 152 | "Напишите программу, которая запрашивает имя пользователя, а затем приветствует его.\n", 153 | "\n", 154 | "**Входные данные**\n", 155 | "\n", 156 | "Пользователь вводит одно слово — имя.\n", 157 | "\n", 158 | "**Выходные данные**\n", 159 | "\n", 160 | "Программа должна выводить одну строчку:\n", 161 | "\n", 162 | " Hello, имя!\n", 163 | "\n", 164 | "где имя — введенное пользователем имя. Обратите внимание на пробел после запятой. Других пробелов быть не должно!\n", 165 | "\n", 166 | "**Примеры**\n", 167 | "\n", 168 | "_Входные данные_\n", 169 | "\n", 170 | " Harry\n", 171 | "\n", 172 | "_Выходные данные_\n", 173 | "\n", 174 | " Hello, Harry!\n", 175 | "\n", 176 | "_Входные данные_\n", 177 | "\n", 178 | " Hermiona\n", 179 | "\n", 180 | "_Выходные данные_\n", 181 | "\n", 182 | " Hello, Hermiona!\n", 183 | "\n", 184 | "_Подсказка._ Чтобы напечатать значение нескольких переменных, можно либо передать их через запятую функции `print()` (например, `print(a, b)`), либо преобразовать в строки и сложить с помощью оператора `+`. Избавиться от лишних пробелов в первом случае поможет параметр `sep` — посмотрите, например, что будет, если набрать `print(\"one\", \"two\", sep=\"---\")`." 185 | ] 186 | }, 187 | { 188 | "cell_type": "code", 189 | "execution_count": null, 190 | "metadata": { 191 | "collapsed": true 192 | }, 193 | "outputs": [], 194 | "source": [ 195 | "def hello_Harry():\n", 196 | " # YOUR CODE HERE\n", 197 | "\n", 198 | "hello_Harry()" 199 | ] 200 | }, 201 | { 202 | "cell_type": "code", 203 | "execution_count": null, 204 | "metadata": { 205 | "collapsed": true 206 | }, 207 | "outputs": [], 208 | "source": [ 209 | "test_data = [\n", 210 | " (\"Harry\", \"Hello, Harry!\"),\n", 211 | " (\"Hermiona\", \"Hello, Hermiona!\"),\n", 212 | " (\"Mr. Potter\", \"Hello, Mr. Potter!\"),\n", 213 | " (\"Lord Voldemort\", \"Hello, Lord Voldemort!\")\n", 214 | "]\n", 215 | "\n", 216 | "for inp, out in test_data:\n", 217 | " with Tester([inp]) as t:\n", 218 | " hello_Harry()\n", 219 | " assert len(t) == 1, \"Вам нужно вывести ровно одну строку с ответом\"\n", 220 | " assert t[0] == out+\"\\n\", \"Неверный ответ, была введена строка \" + inp\n", 221 | "print(\"Молодцом, давай следующую!\")" 222 | ] 223 | }, 224 | { 225 | "cell_type": "markdown", 226 | "metadata": {}, 227 | "source": [ 228 | "### Задача 3\n", 229 | "Напишите программу, которая считывает длины двух катетов в прямоугольном треугольнике и выводит его гипотенузу. Входные числа могут быть целыми или с плавающей точкой. После ввода каждого числа пользователь нажимает «Enter»." 230 | ] 231 | }, 232 | { 233 | "cell_type": "code", 234 | "execution_count": null, 235 | "metadata": { 236 | "collapsed": true 237 | }, 238 | "outputs": [], 239 | "source": [ 240 | "def triangle():\n", 241 | " # YOUR CODE HERE\n", 242 | " \n", 243 | "triangle()" 244 | ] 245 | }, 246 | { 247 | "cell_type": "code", 248 | "execution_count": null, 249 | "metadata": { 250 | "collapsed": true 251 | }, 252 | "outputs": [], 253 | "source": [ 254 | "test_data = [\n", 255 | " (\"3 4\", 5.),\n", 256 | " (\"5 12\", 13.),\n", 257 | " (\"65 72\", 97.),\n", 258 | " (\"0.3 0.4\", 0.5),\n", 259 | " (\"0.05 0.12\", 0.13),\n", 260 | " (\"12.54 9.153\", 15.525108985124708)\n", 261 | "]\n", 262 | "\n", 263 | "for inp, out in test_data:\n", 264 | " with Tester(inp.split()) as t:\n", 265 | " triangle()\n", 266 | " assert len(t) == 1, \"Вам нужно вывести ровно одну строку с ответом\"\n", 267 | " assert abs(float(t[0]) - out) < 1E-6,\"Неверный ответ, были введены числа \" + inp\n", 268 | "print(\"Красава!\")" 269 | ] 270 | }, 271 | { 272 | "cell_type": "markdown", 273 | "metadata": {}, 274 | "source": [ 275 | "### Задача 4\n", 276 | "Напишите программу, которая считывает целое число и выводит текст, аналогичный приведенному в примере (пробелы важны!).\n", 277 | "\n", 278 | "**Пример**\n", 279 | "\n", 280 | "_Входные данные_\n", 281 | "\n", 282 | " 179\n", 283 | "\n", 284 | "_Выходные данные_\n", 285 | "\n", 286 | " The next number for the number 179 is 180.\n", 287 | " The previous number for the number 179 is 178.\n", 288 | "\n", 289 | "_Подсказка._ См. подсказку к задаче 2." 290 | ] 291 | }, 292 | { 293 | "cell_type": "code", 294 | "execution_count": null, 295 | "metadata": { 296 | "collapsed": true 297 | }, 298 | "outputs": [], 299 | "source": [ 300 | "def prevnext():\n", 301 | " # YOUR CODE HERE\n", 302 | " \n", 303 | "prevnext()" 304 | ] 305 | }, 306 | { 307 | "cell_type": "code", 308 | "execution_count": null, 309 | "metadata": { 310 | "collapsed": true 311 | }, 312 | "outputs": [], 313 | "source": [ 314 | "test_data = [\n", 315 | " (\"1534\", [\"The next number for the number 1534 is 1535.\\n\",\n", 316 | " \"The previous number for the number 1534 is 1533.\\n\"]),\n", 317 | " (\"0\", [\"The next number for the number 0 is 1.\\n\",\n", 318 | " \"The previous number for the number 0 is -1.\\n\"]),\n", 319 | " (\"2718281828904590\", [\n", 320 | " \"The next number for the number 2718281828904590 is 2718281828904591.\\n\",\n", 321 | " \"The previous number for the number 2718281828904590 is 2718281828904589.\\n\"])\n", 322 | "]\n", 323 | "\n", 324 | "for inp, out in test_data:\n", 325 | " with Tester([inp]) as t:\n", 326 | " prevnext()\n", 327 | " assert len(t) == 2, \"Вам нужно вывести ровно две строку с ответом\"\n", 328 | " assert t == out,\"Неверный ответ, было введено число \" + inp\n", 329 | "print(\"Круто, почти половина пути пройдена!\")" 330 | ] 331 | }, 332 | { 333 | "cell_type": "markdown", 334 | "metadata": {}, 335 | "source": [ 336 | "### Задача 5 \n", 337 | "\n", 338 | "Дано целое число $n$. Выведите следующее за ним четное число. При решении этой задачи нельзя использовать условный оператор `if` и циклы.\n", 339 | "\n", 340 | "**Примеры**\n", 341 | "\n", 342 | "_Входные данные_\n", 343 | "\n", 344 | " 7\n", 345 | "\n", 346 | "_Выходные данные_\n", 347 | "\n", 348 | " 8\n", 349 | "\n", 350 | "_Входные данные_\n", 351 | "\n", 352 | " 8\n", 353 | "\n", 354 | "_Выходные данные_\n", 355 | "\n", 356 | " 10" 357 | ] 358 | }, 359 | { 360 | "cell_type": "code", 361 | "execution_count": null, 362 | "metadata": { 363 | "collapsed": true 364 | }, 365 | "outputs": [], 366 | "source": [ 367 | "def next_even():\n", 368 | " # YOUR CODE HERE\n", 369 | " \n", 370 | "next_even()" 371 | ] 372 | }, 373 | { 374 | "cell_type": "code", 375 | "execution_count": null, 376 | "metadata": { 377 | "collapsed": true 378 | }, 379 | "outputs": [], 380 | "source": [ 381 | "test_data = [\n", 382 | " (1, 2),\n", 383 | " (2, 4),\n", 384 | " (100, 102),\n", 385 | " (0, 2),\n", 386 | " (11, 12),\n", 387 | " (594843, 594844),\n", 388 | " (-1, 0),\n", 389 | " (-100, -98)\n", 390 | "]\n", 391 | "\n", 392 | "for inp, out in test_data:\n", 393 | " with Tester([str(inp)]) as t:\n", 394 | " next_even()\n", 395 | " assert len(t) == 1, \"Вам нужно вывести ровно одну строку с ответом\"\n", 396 | " assert t[0].strip() == str(out),\"Неверный ответ, было введено число \" + str(inp)\n", 397 | "print(\"Поздравляем с экватором!\")" 398 | ] 399 | }, 400 | { 401 | "cell_type": "markdown", 402 | "metadata": {}, 403 | "source": [ 404 | "### Задача 6 \n", 405 | "Электронные часы показывают время в формате h:mm:ss, то есть сначала записывается количество часов (в 24-часовом формате), потом обязательно двузначное количество минут, затем обязательно двузначное количество секунд. Количество минут и секунд при необходимости дополняются до двузначного числа нулями.\n", 406 | "\n", 407 | "С начала суток прошло n секунд. Выведите, что покажут часы.\n", 408 | "\n", 409 | "Запрещается пользоваться условным оператором, циклами и любыми библиотеками.\n", 410 | "\n", 411 | "**Входные данные**\n", 412 | "\n", 413 | "Вводится целое число $n$.\n", 414 | "\n", 415 | "**Выходные данные**\n", 416 | "\n", 417 | "Выведите ответ на задачу, соблюдая требуемый формат.\n", 418 | "\n", 419 | "**Примеры**\n", 420 | "\n", 421 | "_Входные данные_\n", 422 | "\n", 423 | " 3602\n", 424 | "\n", 425 | "_Выходные данные_\n", 426 | "\n", 427 | " 1:00:02\n", 428 | "\n", 429 | "_Входные данные_\n", 430 | "\n", 431 | " 129700\n", 432 | "\n", 433 | "_Выходные данные_\n", 434 | "\n", 435 | " 12:01:40\n", 436 | " " 437 | ] 438 | }, 439 | { 440 | "cell_type": "code", 441 | "execution_count": null, 442 | "metadata": { 443 | "collapsed": true 444 | }, 445 | "outputs": [], 446 | "source": [ 447 | "def clock():\n", 448 | " # YOUR CODE HERE\n", 449 | " \n", 450 | "clock()" 451 | ] 452 | }, 453 | { 454 | "cell_type": "code", 455 | "execution_count": null, 456 | "metadata": { 457 | "collapsed": true 458 | }, 459 | "outputs": [], 460 | "source": [ 461 | "test_data = [\n", 462 | " (3602, \"1:00:02\"),\n", 463 | " (129700, \"12:01:40\"),\n", 464 | " (12739182731927, \"13:58:47\"),\n", 465 | " (0, \"0:00:00\"),\n", 466 | " (1, \"0:00:01\"),\n", 467 | " (60, \"0:01:00\"),\n", 468 | " (3600, \"1:00:00\"),\n", 469 | " (3599, \"0:59:59\"),\n", 470 | " (43200, \"12:00:00\"),\n", 471 | " (86400, \"0:00:00\")\n", 472 | "]\n", 473 | "\n", 474 | "for inp, out in test_data:\n", 475 | " with Tester([str(inp)]) as t:\n", 476 | " clock()\n", 477 | " assert len(t) == 1, \"Вам нужно вывести ровно одну строку с ответом\"\n", 478 | " assert t[0] == out+\"\\n\", \"Неверный ответ, было введено число \" + str(inp)\n", 479 | "print(\"Отлично, осталось всего ничего!\")" 480 | ] 481 | }, 482 | { 483 | "cell_type": "markdown", 484 | "metadata": {}, 485 | "source": [ 486 | "### Задача 7 \n", 487 | "\n", 488 | "Напишите программу, которая считывает два целых числа $a$ и $b$ и выводит наибольшее значение из них. Числа — целые от 1 до 1000.\n", 489 | "\n", 490 | "При решении задачи можно пользоваться только целочисленными арифметическими операциями `+, -, *, //, %, =`. \n", 491 | "\n", 492 | "Нельзя пользоваться нелинейными конструкциями: ветвлениями, циклами, функциями вычисления модуля, извлечения квадратного корня, возведения в нецелую степень.\n", 493 | "\n", 494 | "Использование функции `max` запрещено! И `min` тоже. \n", 495 | "\n", 496 | "И вообще всё запрещено, кроме того, что разрешено." 497 | ] 498 | }, 499 | { 500 | "cell_type": "code", 501 | "execution_count": null, 502 | "metadata": { 503 | "collapsed": true 504 | }, 505 | "outputs": [], 506 | "source": [ 507 | "def int_max():\n", 508 | " # YOUR CODE HERE\n", 509 | " \n", 510 | "int_max()" 511 | ] 512 | }, 513 | { 514 | "cell_type": "code", 515 | "execution_count": null, 516 | "metadata": { 517 | "collapsed": true 518 | }, 519 | "outputs": [], 520 | "source": [ 521 | "for a in list(range(1, 100)) + [154, 982, 324]:\n", 522 | " for b in list(range(1, 100)) + [991, 124, 183]:\n", 523 | " with Tester([str(a), str(b)]) as t:\n", 524 | " int_max()\n", 525 | " assert len(t) == 1, \"Вам нужно вывести ровно одну строку с ответом\"\n", 526 | " assert int(t[0]) == max(a, b), \"Ошибка при входных данных \" + str(a) + \", \" + str(b)\n", 527 | "print(\"Ура, всё верно!\")" 528 | ] 529 | }, 530 | { 531 | "cell_type": "markdown", 532 | "metadata": {}, 533 | "source": [ 534 | "### Задача 8 \n", 535 | "Даны два целых числа A и B (при этом A≤B). Каждое число вводится с клавитуры, после ввода пользователь нажимает «Enter». Выведите все целые числа от A до B включительно в столбик.\n", 536 | "\n", 537 | "**Пример**\n", 538 | "\n", 539 | "*Входные данные*\n", 540 | "\n", 541 | " 3\n", 542 | " 6\n", 543 | "\n", 544 | "*Выходные данные*\n", 545 | "\n", 546 | " 3\n", 547 | " 4\n", 548 | " 5\n", 549 | " 6" 550 | ] 551 | }, 552 | { 553 | "cell_type": "code", 554 | "execution_count": null, 555 | "metadata": { 556 | "collapsed": true 557 | }, 558 | "outputs": [], 559 | "source": [ 560 | "def my_range():\n", 561 | " # YOUR CODE HERE\n", 562 | " \n", 563 | "my_range()" 564 | ] 565 | }, 566 | { 567 | "cell_type": "code", 568 | "execution_count": null, 569 | "metadata": { 570 | "collapsed": true 571 | }, 572 | "outputs": [], 573 | "source": [ 574 | "test_data = [\n", 575 | " [\"2 4\", \"2 3 4\"],\n", 576 | " [\"1 10\", \"1 2 3 4 5 6 7 8 9 10\"],\n", 577 | " [\"0 0\", \"0\"],\n", 578 | " [\"-5 0\", \"-5 -4 -3 -2 -1 0\"],\n", 579 | " [\"1 1\", \"1\"],\n", 580 | " [\"0 100\", '0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100']\n", 581 | "]\n", 582 | "\n", 583 | "for inp, out in test_data:\n", 584 | " with Tester(inp.split()) as t:\n", 585 | " my_range()\n", 586 | " assert len(t) == len(out.split()), 'Вы вывели неверное количество чисел для входных данных ' + inp\n", 587 | " for o, e in zip(t, out.split()):\n", 588 | " assert int(o) == int(e), \"Неверный ответ для входных данных \" + inp\n", 589 | " \n", 590 | "print(\"Ты — космос!\")" 591 | ] 592 | }, 593 | { 594 | "cell_type": "markdown", 595 | "metadata": {}, 596 | "source": [ 597 | "### Задача 9\n", 598 | "Напишите программу, которая запрашивает с клавиатуры целое число, после чего выводит одну из двух возможных строк: `even` если число чётное и `odd` если нечётное. \n", 599 | "\n", 600 | "*Подсказка:* Чтобы понять, является ли число чётным, нужно вычислить остаток от деления его на 2, это можно сделать с помощью арифметической операции `%`.\n", 601 | "\n", 602 | "**Пример.**\n", 603 | "\n", 604 | "*Входные данные*\n", 605 | "\n", 606 | " 5\n", 607 | " \n", 608 | "*Выходные данные*\n", 609 | "\n", 610 | " odd" 611 | ] 612 | }, 613 | { 614 | "cell_type": "code", 615 | "execution_count": null, 616 | "metadata": { 617 | "collapsed": true 618 | }, 619 | "outputs": [], 620 | "source": [ 621 | "def even_or_odd():\n", 622 | " # YOUR CODE HERE\n", 623 | " \n", 624 | "even_or_odd()" 625 | ] 626 | }, 627 | { 628 | "cell_type": "code", 629 | "execution_count": null, 630 | "metadata": { 631 | "collapsed": true 632 | }, 633 | "outputs": [], 634 | "source": [ 635 | "test_data = [\n", 636 | " (5, 'odd'),\n", 637 | " (100, 'even'),\n", 638 | " (0, 'even'),\n", 639 | " (-3, 'odd'),\n", 640 | " (100500, 'even'),\n", 641 | " (100501, 'odd'),\n", 642 | " (1, 'odd')\n", 643 | "]\n", 644 | "\n", 645 | "for inp, out in test_data:\n", 646 | " with Tester([str(inp)]) as t:\n", 647 | " even_or_odd()\n", 648 | " assert len(t) == 1, \"Вам нужно вывести ровно одну строку с ответом\"\n", 649 | " assert t[0].strip() == str(out), \"Неверный ответ, были введены числа \" + str(inp)\n", 650 | "print(\"Верно! Еще чуть-чуть!\")" 651 | ] 652 | }, 653 | { 654 | "cell_type": "markdown", 655 | "metadata": {}, 656 | "source": [ 657 | "### Задача 10\n", 658 | "Напишите программу, которая запрашивает с клавиатуры целое число, после чего выводит одну из трёх возможных строк: `positive` если число положительное, `negative` если отрицательное и `zero` если введен ноль. \n", 659 | "\n", 660 | "\n", 661 | "**Пример.**\n", 662 | "\n", 663 | "*Входные данные*\n", 664 | "\n", 665 | " 5\n", 666 | " \n", 667 | "*Выходные данные*\n", 668 | "\n", 669 | " positive" 670 | ] 671 | }, 672 | { 673 | "cell_type": "code", 674 | "execution_count": null, 675 | "metadata": { 676 | "collapsed": true 677 | }, 678 | "outputs": [], 679 | "source": [ 680 | "def positive_or_negative():\n", 681 | " # YOUR CODE HERE\n", 682 | " \n", 683 | "positive_or_negative()" 684 | ] 685 | }, 686 | { 687 | "cell_type": "code", 688 | "execution_count": null, 689 | "metadata": { 690 | "collapsed": true 691 | }, 692 | "outputs": [], 693 | "source": [ 694 | "test_data = [\n", 695 | " (5, 'positive'),\n", 696 | " (100, 'positive'),\n", 697 | " (0, 'zero'),\n", 698 | " (-3, 'negative'),\n", 699 | " (100500, 'positive'),\n", 700 | " (100501, 'positive'),\n", 701 | " (1, 'positive')\n", 702 | "]\n", 703 | "\n", 704 | "for inp, out in test_data:\n", 705 | " with Tester([str(inp)]) as t:\n", 706 | " positive_or_negative()\n", 707 | " assert len(t) == 1, \"Вам нужно вывести ровно одну строку с ответом\"\n", 708 | " assert t[0].strip() == str(out), \"Неверный ответ, были введены числа \" + str(inp)\n", 709 | "print(\"Мы тобой гордимся! Не бросай уроки!\")" 710 | ] 711 | } 712 | ], 713 | "metadata": { 714 | "kernelspec": { 715 | "display_name": "Python [Root]", 716 | "language": "python", 717 | "name": "Python [Root]" 718 | }, 719 | "language_info": { 720 | "codemirror_mode": { 721 | "name": "ipython", 722 | "version": 3 723 | }, 724 | "file_extension": ".py", 725 | "mimetype": "text/x-python", 726 | "name": "python", 727 | "nbconvert_exporter": "python", 728 | "pygments_lexer": "ipython3", 729 | "version": "3.5.2" 730 | } 731 | }, 732 | "nbformat": 4, 733 | "nbformat_minor": 0 734 | } 735 | --------------------------------------------------------------------------------