├── LICENSE ├── README.md └── images ├── image_1.png ├── image_10.png ├── image_11.png ├── image_12.png ├── image_13.png ├── image_14.png ├── image_15.png ├── image_16.png ├── image_17.png ├── image_18.png ├── image_19.png ├── image_2.png ├── image_20.png ├── image_21.png ├── image_22.png ├── image_3.png ├── image_4.png ├── image_5.png ├── image_6.png ├── image_7.png ├── image_8.png └── image_9.png /LICENSE: -------------------------------------------------------------------------------- 1 | MIT License 2 | 3 | Copyright (c) 2025 FerrumVega 4 | 5 | Permission is hereby granted, free of charge, to any person obtaining a copy 6 | of this software and associated documentation files (the "Software"), to deal 7 | in the Software without restriction, including without limitation the rights 8 | to use, copy, modify, merge, publish, distribute, sublicense, and/or sell 9 | copies of the Software, and to permit persons to whom the Software is 10 | furnished to do so, subject to the following conditions: 11 | 12 | The above copyright notice and this permission notice shall be included in all 13 | copies or substantial portions of the Software. 14 | 15 | THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR 16 | IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, 17 | FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE 18 | AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER 19 | LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, 20 | OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE 21 | SOFTWARE. 22 | -------------------------------------------------------------------------------- /README.md: -------------------------------------------------------------------------------- 1 | ## Оглавление 2 | - [Ввод-вывод](#ввод-вывод) 3 | - [Базовые команды](#базовые-команды) 4 | - [sep, end](#sep-end) 5 | - [Арифметика и её приоритеты](#арифметика-и-её-приоритеты) 6 | - [Логические операторы и их приоритеты](#логические-операторы-и-их-приоритеты) 7 | - [If-elif-else](#if-elif-else) 8 | - [Операторы сравнения](#операторы-сравнения) 9 | - [or, and, not](#or-and-not) 10 | - [Типы данных](#типы-данных) 11 | - [Числовые типы данных](#числовые-типы-данных) 12 | - [Строковый тип данных](#строковый-тип-данных) 13 | - [Модуль math](#модуль-math) 14 | - [Циклы](#циклы) 15 | - [For](#for) 16 | - [Частые сценарии](#частые-сценарии) 17 | - [While](#while) 18 | - [while: break, continue, else](#while-break-continue-else) 19 | - [Вложенные циклы](#вложенные-циклы) 20 | - [Строки](#строки) 21 | - [Индексация строк](#индексация-строк) 22 | - [Вывод символов строки](#вывод-символов-строки) 23 | - [Срезы строк](#срезы-строк) 24 | - [Методы строк](#методы-строк) 25 | - [partition()](#partition) 26 | - [format()](#format) 27 | - [f-строки](#f-строки) 28 | - [Строки в памяти компьютера](#строки-в-памяти-компьютера) 29 | - [Сравнение строк](#сравнение-строк) 30 | - [Списки](#списки) 31 | - [Создание списка](#создание-списка) 32 | - [Основы (len, sum, min, max, in)](#основы-len-sum-min-max-in) 33 | - [Добавление элементов](#добавление-элементов) 34 | - [Объединение списков](#объединение-списков) 35 | - [Удаление элементов](#удаление-элементов) 36 | - [Вывод элементов списка](#вывод-элементов-списка) 37 | - [split(), join()](#split-join) 38 | - [Методы списков](#методы-списков) 39 | - [Сортировка списков](#сортировка-списков) 40 | - [Списочные выражения](#списочные-выражения) 41 | - [Нахождение чисел палиндромов](#нахождение-чисел-палиндромов) 42 | - [Методы сортировки списков](#методы-сортировки-списков) 43 | - [Тип данных bool и NoneType](#тип-данных-bool-и-nonetype) 44 | - [bool](#bool) 45 | - [NoneType](#nonetype) 46 | - [Вложенные списки](#вложенные-списки) 47 | - [Основы](#основы) 48 | - [Матрицы, ljust(), rjust()](#матрицы-ljust-rjust) 49 | - [Кортежи](#кортежи) 50 | - [Введение](#введение) 51 | - [Основы](#основы-2) 52 | - [Сравнение кортежей](#сравнение-кортежей) 53 | - [Сортировка кортежей](#сортировка-кортежей) 54 | - [Распаковка кортежей](#распаковка-кортежей) 55 | - [Множества](#множества) 56 | - [Множества в математике](#множества-в-математике) 57 | - [Пустое множество](#пустое-множество) 58 | - [Числовые множества](#числовые-множества) 59 | - [Операции над множествами](#операции-над-множествами) 60 | - [Диаграммы Эйлера-Венна при решении задач](#диаграммы-эйлера-венна-при-решении-задач) 61 | - [Введение в множества в Python](#введение-в-множества-в-python) 62 | - [Создание множества](#создание-множества) 63 | - [Вывод множества](#вывод-множества) 64 | - [set()](#set) 65 | - [Основы работы с множествами](#основы-работы-с-множествами) 66 | - [Перебор элементов множества и распаковка](#перебор-элементов-множества-и-распаковка) 67 | - [Сравнение множеств](#сравнение-множеств) 68 | - [Методы множеств](#методы-множеств) 69 | - [Генераторы множеств](#генераторы-множеств) 70 | - [frozenset](#frozenset) 71 | - [Словари](#словари) 72 | - [Введение](#введение-2) 73 | - [Создание словаря](#создание-словаря) 74 | - [Создание пустого словаря](#создание-пустого-словаря) 75 | - [Важные детали](#важные-детали) 76 | - [Основы (len, sum, min, max, in)](#основы-len-sum-min-max-in-2) 77 | - [Сравнение словарей](#сравнение-словарей) 78 | - [Перебор элементов словаря](#перебор-элементов-словаря) 79 | - [Распаковка словарей](#распаковка-словарей) 80 | - [Методы keys(), values(), items()](#методы-keys-values-items) 81 | - [Сортировка словарей](#сортировка-словарей) 82 | - [Методы словарей](#методы-словарей) 83 | - [Генераторы словарей](#генераторы-словарей) 84 | - [Вложенные словари](#вложенные-словари) 85 | - [Модули random, string, Метод Монте-Карло, Bogosort](#модули-random-string-метод-монте-карло-bogosort) 86 | - [Модуль random](#модуль-random) 87 | - [Модуль string](#модуль-string) 88 | - [Метод Монте-Карло](#метод-монте-карло) 89 | - [Bogosort](#bogosort) 90 | - [Модули decimal, fractions и complex](#модули-decimal-fractions-и-complex) 91 | - [Модуль decimal: введение](#модуль-decimal-введение) 92 | - [Создание Decimal чисел](#создание-decimal-чисел) 93 | - [Арифметические операции над Decimal числами](#арифметические-операции-над-decimal-числами) 94 | - [Математические функции Decimal чисел](#математические-функции-decimal-чисел) 95 | - [Работа с контекстом Decimal чисел](#работа-с-контекстом-decimal-чисел) 96 | - [Точность Decimal чисел](#точность-decimal-чисел) 97 | - [Округление Decimal чисел](#округление-decimal-чисел) 98 | - [Сравнение float и Decimal чисел](#сравнение-float-и-decimal-чисел) 99 | - [Важные примечания для decimal](#важные-примечания-для-decimal) 100 | - [Модуль fractions: введение](#модуль-fractions-введение) 101 | - [Тип данных Fraction](#тип-данных-fraction) 102 | - [Создание Fraction чисел](#создание-fraction-чисел) 103 | - [Основы типа данных Fraction](#основы-типа-данных-fraction) 104 | - [Сравнение Fraction чисел](#сравнение-fraction-чисел) 105 | - [Арифметические операции над Fraction числами](#арифметические-операции-над-fraction-числами) 106 | - [Математические функции](#математические-функции) 107 | - [Свойства numerator и denominator, as_integer_ratio()](#свойства-numerator-и-denominator-as_integer_ratio) 108 | - [Метод limit_denominator()](#метод-limit_denominator) 109 | - [Комплексные числа: введение](#комплексные-числа-введение) 110 | - [Комплексные числа в математике](#комплексные-числа-в-математике) 111 | - [Комплексные числа в Python](#комплексные-числа-в-python) 112 | - [Создание комплексных чисел](#создание-комплексных-чисел) 113 | - [Арифметические операции над комплексными числами](#арифметические-операции-над-комплексными-числами) 114 | - [Методы и свойства комплексных чисел](#методы-и-свойства-комплексных-чисел) 115 | - [cmath](#cmath) 116 | - [Модуль turtle](#модуль-turtle) 117 | - [Введение в turtle](#введение-в-turtle) 118 | - [Рисование отрезков прямой](#рисование-отрезков-прямой) 119 | - [Поворот черепашки](#поворот-черепашки) 120 | - [Изменение внешнего вида черепашки](#изменение-внешнего-вида-черепашки) 121 | - [Поднятие и опускание пера](#поднятие-и-опускание-пера) 122 | - [Рисование кругов и точек](#рисование-кругов-и-точек) 123 | - [Изменение размера пера](#изменение-размера-пера) 124 | - [Изменение цвета рисунка](#изменение-цвета-рисунка) 125 | - [Изменение цвета фона](#изменение-цвета-фона) 126 | - [Создание штампа](#создание-штампа) 127 | - [Возвращение экрана в исходное состояние](#возвращение-экрана-в-исходное-состояние) 128 | - [Размер окна](#размер-окна) 129 | - [Перемещение черепашки в заданную позицию](#перемещение-черепашки-в-заданную-позицию) 130 | - [Получение текущей позиции черепашки](#получение-текущей-позиции-черепашки) 131 | - [Сокрытие черепашки](#сокрытие-черепашки) 132 | - [Управление скоростью анимации черепахи](#управление-скоростью-анимации-черепахи) 133 | - [Вывод текста в графическое окно](#вывод-текста-в-графическое-окно) 134 | - [Заполнение геометрических фигур](#заполнение-геометрических-фигур) 135 | - [Создание нескольких черепашек](#создание-нескольких-черепашек) 136 | - [Отслеживание нажатия клавиш](#отслеживание-нажатия-клавиш) 137 | - [Отслеживание нажатия мыши](#отслеживание-нажатия-мыши) 138 | - [Функции](#функции) 139 | - [Функции без параметров](#функции-без-параметров) 140 | - [Функции с параметрами](#функции-с-параметрами) 141 | - [Глобальные и локальные переменные](#глобальные-и-локальные-переменные) 142 | - [Функции с возвратом значения](#функции-с-возвратом-значения) 143 | - [Позиционные и именованные аргументы](#позиционные-и-именованные-аргументы) 144 | - [Необязательные аргументы](#необязательные-аргументы) 145 | - [Изменяемые типы в качестве значений по умолчанию](#изменяемые-типы-в-качестве-значений-по-умолчанию) 146 | - [Переменное количество аргументов](#переменное-количество-аргументов) 147 | - [Передача аргументов в форме списка и кортежа](#передача-аргументов-в-форме-списка-и-кортежа) 148 | - [Получение именованных аргументов в виде словаря](#получение-именованных-аргументов-в-виде-словаря) 149 | - [Keyword-only аргументы](#keyword-only-аргументы) 150 | - [Функции как объекты](#функции-как-объекты) 151 | - [Функции в качестве аргументов других функций](#функции-в-качестве-аргументов-других-функций) 152 | - [key в min(), max(), sort(), sorted()](#key-в-min-max-sort-sorted) 153 | - [Функции в качестве возвращаемых значений других функций (вложенные функции)](#функции-в-качестве-возвращаемых-значений-других-функций-вложенные-функции) 154 | - [Функции высшего порядка](#функции-высшего-порядка) 155 | - [map()](#map) 156 | - [filter()](#filter) 157 | - [reduce()](#reduce) 158 | - [Модуль operator](#модуль-operator) 159 | - [Анонимные функции (lambda): введение](#анонимные-функции-lambda-введение) 160 | - [Анонимные функции (lambda): основы, тернарный оператор](#анонимные-функции-lambda-основы-тернарный-оператор) 161 | - [all(), any()](#all-any) 162 | - [enumerate()](#enumerate) 163 | - [zip()](#zip) 164 | - [Работа с файлами](#работа-с-файлами) 165 | - [Введение](#введение-3) 166 | - [languages.txt](#languagestxt) 167 | - [Открытие файлов](#открытие-файлов) 168 | - [Указание места расположения файла, сырые строки](#указание-места-расположения-файла-сырые-строки) 169 | - [Кодировка](#кодировка) 170 | - [Закрытие файлов](#закрытие-файлов) 171 | - [read(), readline(), readlines()](#read-readline-readlines) 172 | - [Бинарные файлы](#бинарные-файлы) 173 | - [Свойства файла](#свойства-файла) 174 | - [Позиция в файле (курсор)](#позиция-в-файле-курсор) 175 | - [seek(), tell()](#seek-tell) 176 | - [Менеджер контекста](#менеджер-контекста) 177 | - [write(), writelines(), запись в файл при помощи print()](#write-writelines-запись-в-файл-при-помощи-print) 178 | - [Интересные штуки](#интересные-штуки) 179 | - [Числовая угадайка](#числовая-угадайка) 180 | - [Магический шар 8](#магический-шар-8) 181 | - [Генератор безопасных паролей](#генератор-безопасных-паролей) 182 | - [Калькулятор систем счисления (bin(), oct(), hex())](#калькулятор-систем-счисления-bin-oct-hex) 183 | - [Угадайка слов](#угадайка-слов) 184 | 185 | 186 | Copyright (c) 2025 FerrumVega 187 | В конспекте использованы примеры и картинки из курсов https://stepik.org/course/58852 и https://stepik.org/course/68343. 188 | # Ввод-вывод 189 | ## Базовые команды 190 | Для ввода используется команда `input()` 191 | Для вывода команда `print()` 192 | 193 | ## sep, end 194 | С помощью `sep `и `end `можно установить знак между аргументами и конец строки в `print() ` 195 | Пример: 196 | ```python 197 | print("Hello", "World", sep="*", end="/") 198 | >>> Hello*World/ 199 | 200 | ``` 201 | ## Арифметика и её приоритеты 202 | ```python 203 | + # сложение 204 | - # вычитание 205 | / # деление 206 | * # умножение 207 | ** # возведение в степень 208 | % # остаток от деления 209 | // # целочисленное деление 210 | ``` 211 | Приоритеты (сверху самый высокий): 212 | ```python 213 | 1. () 214 | 2. ** 215 | 3. - (унарный минус) 216 | 4. *, /, //, % 217 | 5. +, - 218 | 219 | ``` 220 | # Логические операторы и их приоритеты 221 | ## If-elif-else 222 | ```python 223 | answer = input('Какой язык программирования мы изучаем?') 224 | 225 | if answer == 'Python': 226 | print('Верно! Мы ботаем Python =)') 227 | print('Python - отличный язык!') 228 | elif answer == "C++": 229 | print('C++ тоже уважаем :)') 230 | else: 231 | print('Не знаю такого :(') 232 | ``` 233 | ## Операторы сравнения 234 | 235 | 236 | | Выражение | Описание | 237 | |---|---| 238 | | if x > 7 | если x больше 7 | 239 | | if x < 7 | если x меньше 7 | 240 | | if x >= 7 | если x больше либо равен 7 | 241 | | if x <= 7 | если x меньше либо равен 7 | 242 | | if x == 7 | если x равен 7 | 243 | | if x != 7 | если x не равен 7 | 244 | 245 | 246 | 247 | Также можно использовать цепочки: `a == b == c` 248 | 249 | ## or, and, not 250 | ```python 251 | or # логическое сложение 252 | and # логическое умножение 253 | not # логическое отрицание 254 | ``` 255 | Приоритеты (сверху самый высокий): 256 | ```python 257 | 1. not 258 | 2. and 259 | 3. or 260 | 261 | ``` 262 | # Типы данных 263 | ## Числовые типы данных 264 | ```python 265 | int(n) # целочисленный тип данных (1) 266 | float(n) # число с плавающей точкой (0.1) 267 | max(a, b ... n) # максимальное число 268 | min(a, b ... n) # минимальное число 269 | abs(n) # абсолютная величина числа (модуль) 270 | 271 | ``` 272 | ## Строковый тип данных 273 | ```python 274 | str("string") # преобразование в строку 275 | len("string") # длина строки 276 | 277 | print("ab"+"bc") # конкатенация (сложение строк) 278 | >>> abbc 279 | 280 | print("Hi" * 4) # умножение строки 281 | >>> HiHiHiHi 282 | 283 | text = """ 284 | многострочный текст выделяется 285 | тройными кавычками 286 | """ 287 | 288 | print("ab" in "abc") 289 | >>> True 290 | print("ac" in "abc") 291 | >>> False 292 | print("AB" in "abc") 293 | >>> False # in чувствителен к регистру 294 | 295 | ``` 296 | ## Модуль math 297 | Существует 2 вида импорта модулей: 298 | ```python 299 | 1. import math 300 | 2. from math import * 301 | ``` 302 | При использовании первого нужно использовать команды так: 303 | ```python 304 | math.sqrt(25) 305 | ``` 306 | При использовании второго: 307 | ```python 308 | sqrt(25) 309 | ``` 310 | Второй метод проще, но при нём могут возникнуть конфликты из-за одинаковых команд в разных модулях 311 | Также можно импортировать всего несколько команд, а не все из модуля: 312 | ```python 313 | from math import sqrt 314 | sqrt(25) 315 | 316 | 317 | ``` 318 | Список функций модуля math 319 | 320 | 321 | | Функция | Описание | 322 | |---|---| 323 | | Округления | | 324 | | int() | Округляет число в сторону нуля | 325 | | round(x) | Округляет число x до ближайшего целого. Если дробная часть числа равна 0.50.5, то число округляется до ближайшего четного числа (банковское округление) | 326 | | round(x, n) | Округляет число x до n знаков после точки | 327 | | floor(x) | Округляет число x вниз («пол») | 328 | | ceil(x) | Округляет число x вверх («потолок») | 329 | | abs(x) | Модуль числа x (абсолютная величина) | 330 | | Корни, логарифмы, степени и факториал | | 331 | | sqrt(x) | Квадратный корень числа x | 332 | | pow(x, n) | Возведение числа x в степень n | 333 | | log(x) | Натуральный логарифм числа x. Основание натурального логарифма равно числу e | 334 | | log10(x) | Десятичный логарифм числа x. Основание десятичного логарифма равно числу 10 | 335 | | log(x, b) | Логарифм числа x по основанию b | 336 | | factorial(n) | Факториал натурального числа n | 337 | | Тригонометрия | | 338 | | degrees(x) | Преобразует угол x, заданный в радианах, в градусы | 339 | | radians(x) | Преобразует угол x, заданный в градусах, в радианы | 340 | | cos(x) | Косинус угла x, задаваемого в радианах | 341 | | sin(x) | Синус угла x, задаваемого в радианах | 342 | | tan(x) | Тангенс угла x, задаваемого в радианах | 343 | | acos(x) | Возвращает угол в радианах от 0 до π, cos которого равен x | 344 | | asin(x) | Возвращает угол в радианах от −π2−2π​ до π22π​, sin которого равен x | 345 | | atan(x) | Возвращает угол в радианах от −π2−2π​ до π22π​, tan которого равен x | 346 | | atan2(y, x) | Полярный угол (в радианах) точки с координатами (x, y) | 347 | 348 | 349 | 350 | # Циклы 351 | ## For 352 | for перебирает все значения из итератора и заполняет переменную текущим значением. 353 | С одним аргументом (от нуля до n-1): 354 | ```python 355 | for i in range(10): 356 | print(i) 357 | >>> 0 358 | >>> 1 359 | >>> 2 360 | >>> 3 361 | >>> 4 362 | >>> 5 363 | >>> 6 364 | >>> 7 365 | >>> 8 366 | >>> 9 367 | ``` 368 | С двумя аргументами (от m до n-1): 369 | ```python 370 | for i in range(1, 10): 371 | print(i) 372 | >>> 1 373 | >>> 2 374 | >>> 3 375 | >>> 4 376 | >>> 5 377 | >>> 6 378 | >>> 7 379 | >>> 8 380 | >>> 9 381 | ``` 382 | С тремя аргументами (от m до n-1 с шагом k): 383 | ```python 384 | for i in range(1, 10, 2): # третий аргумент - величина шага 385 | print(i) 386 | >>> 1 387 | >>> 3 388 | >>> 5 389 | >>> 7 390 | >>> 9 391 | 392 | ``` 393 | ## Частые сценарии 394 | - Подсчёт количества 395 | ```python 396 | counter = 0 397 | for _ in range(10): 398 | num = int(input()) 399 | if num > 10: 400 | counter = counter + 1 401 | 402 | print('Было введено', counter, 'чисел, больших 10.') 403 | 404 | ``` 405 | - Обмен значений переменных 406 | Вместо: 407 | ```python 408 | temp = x 409 | x = y 410 | y = temp 411 | ``` 412 | Можно использовать: 413 | ```python 414 | x, y = y, x 415 | 416 | ``` 417 | - Сигнальные метки 418 | ```python 419 | num = int(input()) 420 | flag = True 421 | 422 | for i in range(2, num): 423 | if num % i == 0: # если исходное число делится на какое-либо отличное от 1 и самого себя 424 | flag = False 425 | 426 | if num == 1: 427 | print('Это единица, она не простая и не составная') 428 | elif flag == True: 429 | print('Число простое') 430 | else: 431 | print('Число составное') 432 | 433 | ``` 434 | - Максимум и минимум 435 | ```python 436 | largest = 0 437 | for _ in range(10): 438 | num = int(input()) 439 | if num > largest: 440 | largest = num 441 | 442 | print('Наибольшее число равно', largest) 443 | 444 | ``` 445 | - Расширенные операторы присваивания 446 | 447 | 448 | | Оператор | Пример использования | Эквивалент | 449 | |---|---|---| 450 | | += | x += 5 | x = x + 5 | 451 | | -= | x -= 2 | x = x - 2 | 452 | | *= | x *= 10 | x = x * 10 | 453 | | /= | x /= 4 | x = x / 4 | 454 | | //= | x //= 4 | x = x // 4 | 455 | | %= | x %= 4 | x = x % 4 | 456 | 457 | 458 | 459 | ## While 460 | While выполняет команды внутри себя пока условие(-я) выполняется(-ются) 461 | - Обработка цифр числа: 462 | ```python 463 | n = int(input()) 464 | while n != 0: # пока в числе есть цифры 465 | last_digit = n % 10 # получить последнюю цифру 466 | # код обработки последней цифры 467 | n = n // 10 # удалить последнюю цифру из числа 468 | 469 | ``` 470 | - «До остановки»: 471 | ```python 472 | text = input() 473 | total = 0 474 | while text != "stop": 475 | total += int(text) 476 | text = input() 477 | print("Сумма чисел равна", total) 478 | 479 | ``` 480 | ## while: break, continue, else 481 | `break `завершает цикл 482 | Проверка числа на простоту: 483 | ```python 484 | num = int(input()) 485 | flag = True 486 | 487 | for i in range(2, num): 488 | if num % i == 0: # если исходное число делится на какое-либо отличное от 1 и самого себя 489 | flag = False 490 | break # останавливаем цикл если встретился делитель числа 491 | if flag: # эквивалентно if flag == True: 492 | print('Число простое') 493 | else: 494 | print('Число составное') 495 | 496 | ``` 497 | `continue `позволяет перейти к следующей итерации цикла `for `или `while `до завершения всех команд в теле цикла. 498 | Программа, которая выводит все числа от 1 до 100, кроме чисел 7, 17, 29 и 78: 499 | ```python 500 | for i in range(1, 101): 501 | if i == 7 or i == 17 or i == 29 or i == 78: 502 | continue # переходим на следующую итерацию 503 | print(i) 504 | 505 | ``` 506 | Python допускает необязательный блок `else `в конце циклов `while` и `for`. Это уникальная особенность Python, не встречающаяся в большинстве других языков программирования. `else `выполнится, если цикл завершился без `break`. Синтаксис такой конструкции следующий: 507 | ```python 508 | while условие: 509 | блок кода1 510 | else: 511 | блок кода2 512 | 513 | # или 514 | 515 | for i in range(10): 516 | блок кода1 517 | else: 518 | блок кода2 519 | ``` 520 | Пример: 521 | ```python 522 | n = 5 523 | while n > 0: 524 | n -= 1 525 | print(n) 526 | else: 527 | print("Цикл завершен.") 528 | 529 | ``` 530 | ## Вложенные циклы 531 | ```python 532 | for hours in range(24): 533 | for minutes in range(60): 534 | for seconds in range(60): 535 | print(hours, ':', minutes, ':', seconds) 536 | >>> 0 : 0 : 0 537 | >>> 0 : 0 : 1 538 | >>> 0 : 0 : 2 539 | ... 540 | >>> 23 : 59 : 58 541 | >>> 23 : 59 : 59 542 | ``` 543 | При помощи вложенных циклов можно решать уравнения: 544 | Уравнение 12x+13y=777. 545 | Решение: 546 | ```python 547 | for x in range(777): 548 | for y in range(777): 549 | if 12 * x + 13 * y == 777: 550 | print(x, y) 551 | 552 | ``` 553 | # Строки 554 | ## Индексация строк 555 | ![Image 1](images/image_1.png) 556 | Пример вывода символа из строки: 557 | ```python 558 | s = 'Python' 559 | print(s[1]) # выводит символ с индексом 1 (2 с начала) 560 | print(s[-3]) # выводит символ с индексом -3 (3 с конца) 561 | >>> y 562 | >>> h 563 | 564 | ``` 565 | ## Вывод символов строки 566 | Для вывода каждого символа на новой строке используют такую конструкцию: 567 | ```python 568 | s = 'abcdef' 569 | for i in range(len(s)): 570 | print(s[i]) 571 | >>> a 572 | >>> b 573 | >>> c 574 | >>> d 575 | >>> e 576 | >>> f 577 | 578 | ``` 579 | ## Срезы строк 580 | Срез выводит символы с x по y (правильнее будет сказать с x по y-1) 581 | ![Image 2](images/image_2.png) 582 | ```python 583 | s = 'abcdefghij' 584 | print(s[2:5]) 585 | >>> cde 586 | ``` 587 | Также можно опускать параметры в срезах 588 | ![Image 3](images/image_3.png) 589 | ![Image 4](images/image_4.png) 590 | ```python 591 | s = 'abcdefghij' 592 | print(s[2:]) 593 | print(s[:7]) 594 | >>> cdefghij 595 | >>> abcdefg 596 | ``` 597 | Также можно указать шаг среза, например, срез `s[1:7:2] `создаст строку bdf состоящую из каждого второго символа (индексы 1, 3, 5) 598 | ![Image 5](images/image_5.png) 599 | Можно указать отрицательный шаг среза: 600 | 601 | 602 | | s = 'abcdefghij' | s = 'abcdefghij' | s = 'abcdefghij' | 603 | |---|---|---| 604 | | Программный код | Результат | Пояснение | 605 | | s[2:5] | cde | строка состоящая из символов с индексами 2, 3, 4 | 606 | | s[:5] | abcde | первые пять символов строки | 607 | | s[5:] | fghij | строка состоящая из символов с индексами от 5 до конца | 608 | | s[-2:] | ij | последние два символа строки | 609 | | s[:] | abcdefghij | вся строка целиком | 610 | | s[1:7:2] | bdf | строка, состоящая из каждого второго символа с индексами от 1 до 6 | 611 | | s[::-1] | jihgfedcba | строка в обратном порядке, так как шаг отрицательный | 612 | 613 | 614 | ```python 615 | s = 'abcdefghij' 616 | print(s[::-1]) 617 | >>> jihgfedcba 618 | 619 | ``` 620 | Изменение символа строки по индексу 621 | Предположим, у нас есть строка `s = 'abcdefghij' `и мы хотим заменить символ с индексом 4 на 'X'. Можно попытаться написать код: 622 | ```python 623 | s[4] = 'X' 624 | ``` 625 | Однако такой код не работает. В Python строки являются неизменяемыми, то есть мы не можем менять их содержимое с помощью индексатора. 626 | Правильный код: 627 | ```python 628 | s = s[:4] + 'X' + s[5:] 629 | 630 | ``` 631 | ## Методы строк 632 | Методы к строкам применяются так: строка.метод 633 | - Конвертация регистра 634 | ```python 635 | s = 'foO BaR BAZ quX' 636 | 637 | 638 | print(s.capitalize()) # Первое слово с большой буквы, остальные - с маленькой 639 | >>> Foo bar baz qux 640 | 641 | print(s.swapcase()) # Меняет регистр всех символов на противоположный 642 | >>> FOo bAr baz QUx 643 | 644 | print(s.title()) # Каждое слово начинается с заглавной буквы 645 | >>> Foo Bar Baz Qux 646 | 647 | print(s.lower()) # Все символы приводятся к нижнему регистру 648 | >>> foo bar baz qux 649 | 650 | print(s.upper()) # Все символы приводятся к верхнему регистру 651 | >>> FOO BAR BAZ QUX 652 | 653 | ``` 654 | - Поиск и замена 655 | ```python 656 | s = 'foo bar foo baz foo qux' 657 | 658 | # Метод count(, , ) - количество вхождений подстроки 659 | print(s.count('foo')) 660 | print(s.count('foo', 0, 10)) 661 | >>> 3 662 | >>> 1 663 | 664 | # Метод startswith(, , ) - проверка начала строки 665 | print(s.startswith('foo')) 666 | print(s.startswith('bar')) 667 | >>> True 668 | >>> False 669 | 670 | # Метод endswith(, , ) - проверка конца строки 671 | print(s.endswith('qux')) 672 | print(s.endswith('bar')) 673 | >>> True 674 | >>> False 675 | 676 | # Метод find(, , ) - индекс первого вхождения (или -1) 677 | print(s.find('foo')) 678 | print(s.find('python')) 679 | >>> 0 680 | >>> -1 681 | 682 | # Метод rfind(, , ) - поиск с конца строки 683 | print(s.rfind('foo')) 684 | print(s.rfind('python')) 685 | >>> 16 686 | >>> -1 687 | 688 | # Метод index(, , ) - как find(), но вызывает ошибку при отсутствии 689 | print(s.index('foo')) 690 | # print(s.index('python')) # Вызовет ValueError 691 | >>> 0 692 | 693 | # Метод rindex(, , ) - поиск с конца с ошибкой при отсутствии 694 | print(s.rindex('foo')) 695 | # print(s.rindex('python')) # Вызовет ValueError 696 | >>> 16 697 | 698 | s = ' foo bar foo baz foo qux ' 699 | 700 | # Метод strip() - удаляет пробелы с обоих концов 701 | print(s.strip()) 702 | >>> foo bar foo baz foo qux 703 | 704 | # Метод lstrip() - удаляет пробелы только слева 705 | print(s.lstrip()) 706 | >>> foo bar foo baz foo qux______ 707 | 708 | # Метод rstrip() - удаляет пробелы только справа 709 | print(s.rstrip()) 710 | >>> ______foo bar foo baz foo qux 711 | 712 | s = '-+-+abc+-+-' 713 | 714 | # Удаление указанных символов с обоих концов 715 | print(s.strip('+-')) 716 | >>> abc 717 | 718 | # Удаление указанных символов справа 719 | print(s.rstrip('+-')) 720 | >>> -+-+abc 721 | 722 | # Удаление указанных символов слева 723 | print(s.lstrip('+-')) 724 | >>> abc+-+- 725 | 726 | s = 'foo bar foo baz foo qux' 727 | 728 | # Метод replace(, , ) - замена всех вхождений 729 | print(s.replace('foo', 'grault')) # Все вхождения 730 | >>> grault bar grault baz grault qux 731 | 732 | print(s.replace('foo', 'grault', 2)) # Только 2 первых замены 733 | >>> grault bar grault baz foo qux0 734 | 735 | ``` 736 | - Классификация символов 737 | ```python 738 | print('Python3'.isalnum()) # состоит ли строка только из букв и/или цифр 739 | >>> True 740 | 741 | print('Hello'.isalpha()) # состоит ли строка только из букв 742 | >>> True 743 | 744 | print('2023'.isdigit()) # состоит ли строка только из цифр 745 | >>> True 746 | 747 | print('python'.islower()) # все ли буквы в строке строчные 748 | >>> True 749 | 750 | print('PYTHON'.isupper()) # все ли буквы в строке заглавные 751 | >>> True 752 | 753 | print(' '.isspace()) # состоит ли строка только из пробелов 754 | >>> True 755 | 756 | ``` 757 | ## partition() 758 | Помимо метода `split() `строковый тип данных содержит метод `partition()`. Метод `partition()` принимает на вход один аргумент `sep`, разделяет строку при первом появлении `sep` и возвращает кортеж, состоящий из трех элементов: часть перед разделителем, сам разделитель и часть после разделителя. Если разделитель не найден, то кортеж содержит саму строку, за которой следуют две пустые строки. 759 | ```python 760 | s1 = 'abc-de'.partition('-') 761 | s2 = 'abc-de'.partition('.') 762 | s3 = 'abc-de-fgh'.partition('-') 763 | 764 | print(s1) 765 | print(s2) 766 | print(s3) 767 | >>> ('abc', '-', 'de') 768 | >>> ('abc-de', '', '') 769 | >>> ('abc', '-', 'de-fgh') 770 | 771 | ``` 772 | ## format() 773 | В Python можно использовать заполнители: 774 | ```python 775 | birth_year = 1992 776 | name = 'Timur' 777 | profession = 'math teacher' 778 | text = 'My name is {}, I was born in {}, I work as a {}.'.format(name, birth_year, profession) 779 | 780 | print(text) 781 | >>> My name is Timur, I was born in 1992, I work as a math teacher. 782 | 783 | ``` 784 | Также можно несколько раз использовать один и тот же аргумент: 785 | ```python 786 | name = 'Timur' 787 | city = 'Moscow' 788 | text1 = 'My name is {0}-{0}-{0}!'.format(name, city) 789 | text2 = '{1} is my city and {0} is my name!'.format(name, city) 790 | 791 | print(text1) 792 | >>> My name is Timur-Timur-Timur! 793 | 794 | print(text2) 795 | >>> Moscow is my city and Timur is my name! 796 | 797 | ``` 798 | ## f-строки 799 | Строки вида 800 | ```python 801 | name = 'Никита' 802 | print(name, "- мой друг") 803 | >>> Никита - мой друг 804 | ``` 805 | Можно изменить на: 806 | ```python 807 | name = 'Никита' 808 | print(f"{name} - мой друг") 809 | >>> Никита - мой друг 810 | ``` 811 | В f-строках переменные нужно указывать в {} скобках, а текст просто писать 812 | 813 | ## Строки в памяти компьютера 814 | Таблица ASCII: 815 | ![Image 6](images/image_6.png) 816 | Функция `ord() `позволяет определить код некоторого символа в таблице символов Unicode. 817 | ```python 818 | num1 = ord('A') 819 | num2 = ord('B') 820 | num3 = ord('a') 821 | print(num1, num2, num3) 822 | >>> 65 66 97 823 | ``` 824 | Функция `chr() `позволяет определить по коду символа сам символ. Аргументом данной функции является численный код. 825 | ```python 826 | chr1 = chr(65) 827 | chr2 = chr(75) 828 | chr3 = chr(110) 829 | print(chr1, chr2, chr3) 830 | >>> A K n 831 | 832 | ``` 833 | ## Сравнение строк 834 | Строки можно сравнивать, работает это по лексикографическому порядку (точнее, по ASCII) 835 | Строчные символы больше заглавных 836 | ```python 837 | print('d' > 'D') 838 | print('Ы' < 'ы') 839 | >>> True 840 | >>> True 841 | 842 | ``` 843 | # Списки 844 | ## Создание списка 845 | Списки могут содержать разные типы данных 846 | Список можно задать двумя способами: 847 | ```python 848 | a = [] 849 | a = list() 850 | 851 | ``` 852 | ## Основы (len, sum, min, max, in) 853 | ```python 854 | a = [1, 5, 3] 855 | 856 | print(len(a)) # длина списка (количество элементов) 857 | >>> 3 858 | 859 | print(sum(a)) # сумма элементов списка 860 | >>> 9 861 | 862 | print(min(a)) # минимум из списка 863 | >>> 1 864 | 865 | print(max(a)) # максимум из списка 866 | >>> 5 867 | 868 | print(1 in a) # есть ли элемент со значением 1 в списке a 869 | >>> True 870 | 871 | ``` 872 | В списках индексация, срезы, конкатенация и умножение аналогично строкам, только тут вместо символов строки элементы списка. 873 | 874 | Отличие списков от строк: 875 | Несмотря на всю схожесть списков и строк, есть одно очень важное отличие: строки — неизменяемые объекты, а списки – изменяемые. 876 | 877 | Список можно удобно заполнить порядковыми числами: 878 | ```python 879 | a = list(range(1, 10, 2)) 880 | print(a) 881 | >>> [1, 3, 5, 7, 9] 882 | 883 | ``` 884 | ## Добавление элементов 885 | `a.append()` - добавление элемента в конец списка 886 | ```python 887 | a = [1, 1, 2, 3, 5, 8, 13] 888 | a.append(21) # добавляем число 21 в конец списка 889 | a.append(34) # добавляем число 34 в конец списка 890 | print(a) 891 | >>> [1, 1, 2, 3, 5, 8, 13, 21, 34] 892 | 893 | ``` 894 | ## Объединение списков 895 | Чтобы объединить списки нужно использовать следующий метод: 896 | ```python 897 | a = [1, 2] 898 | b = [5, 7] 899 | a.extend(b) 900 | print(a) 901 | >>> [1, 2, 5, 7] 902 | 903 | ``` 904 | ## Удаление элементов 905 | Для удаления элементов используется инструкция `del` 906 | ```python 907 | a = [1, 2, 3, 4, 5, 6, 7, 8, 9] 908 | del a[5] # удаляем элемент, имеющий индекс 5 909 | print(a) 910 | >>> [1, 2, 3, 4, 5, 7, 8, 9] 911 | 912 | ``` 913 | ## Вывод элементов списка 914 | - Вывод через цикл 915 | ```python 916 | a = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10] 917 | for i in range(len(a)): 918 | print(a[i]) 919 | >>> 0 920 | >>> 1 921 | >>> 2 922 | >>> 3 923 | >>> 4 924 | >>> 5 925 | >>> 6 926 | >>> 7 927 | >>> 8 928 | >>> 9 929 | >>> 10 930 | 931 | ``` 932 | - Распаковка списка 933 | ```python 934 | a = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10] 935 | print(*a) 936 | >>> 0 1 2 3 4 5 6 7 8 9 10 937 | 938 | ``` 939 | - Распаковка списка и вывод каждого элемента на новой строке 940 | ```python 941 | a = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10] 942 | print(*a, sep="\n") 943 | >>> 0 944 | >>> 1 945 | >>> 2 946 | >>> 3 947 | >>> 4 948 | >>> 5 949 | >>> 6 950 | >>> 7 951 | >>> 8 952 | >>> 9 953 | >>> 10 954 | 955 | ``` 956 | ## split(), join() 957 | Метод `split()` разбивает строку на слова, используя в качестве разделителя последовательность пробельных символов, и возвращает список из этих слов. 958 | ```python 959 | s = 'Python is the most powerful language' 960 | words = s.split() 961 | print(words) 962 | >>> ['Python', 'is', 'the', 'most', 'powerful', 'language'] 963 | ``` 964 | Также можно указать аргумент, который будет разделителем: 965 | ```python 966 | ip = '192.168.1.24' 967 | numbers = ip.split('.') # указываем явно разделитель 968 | print(numbers) 969 | >>> ['192', '168', '1', '24'] 970 | 971 | ``` 972 | Метод `join()` собирает строку из элементов списка, используя в качестве разделителя строку, к которой применяется метод. 973 | ```python 974 | words = ['Python', 'is', 'the', 'most', 'powerful', 'language'] 975 | s = ' '.join(words) 976 | print(s) 977 | >>> Python is the most powerful language 978 | 979 | ``` 980 | Шпаргалки: 981 | ![Image 7](images/image_7.png) 982 | ![Image 8](images/image_8.png) 983 | ![Image 9](images/image_9.png) 984 | 985 | ## Методы списков 986 | ```python 987 | s = [1, 3, 5] 988 | s.insert(4, 2) # вставляет 2 в индекс 4 989 | print(s) 990 | >>> [1, 3, 5, 2] 991 | 992 | s = [1, 3, 5] 993 | print(s.index(3)) # выводит индекс первого вхождения 3 список s 994 | >>> 1 995 | 996 | s = [1, 3, 5] 997 | s.remove(3) # удаляет первое вхождение элемента 3 998 | print(s) 999 | >>> [1, 5] 1000 | 1001 | s = [1, 3, 5] 1002 | s.pop(2) # удаляет элемент с индексом 2 1003 | print(s) 1004 | >>> [1, 3] 1005 | 1006 | s = [1, 3, 3, 3, 3, 5] 1007 | print(s.count(3)) # выводит количество элементов со значением 3 1008 | >>> 4 1009 | 1010 | s = [1, 3, 5] 1011 | s.reverse() # переворачивает список 1012 | print(s) 1013 | >>> [5, 3, 1] 1014 | 1015 | s = [1, 3, 5] 1016 | s.clear() # очищает список 1017 | print(s) 1018 | >>> [] 1019 | 1020 | s = [1, 3, 5] 1021 | g = s.copy() # делает копия списка, при изменении оригинала копия тоже изменяется 1022 | print(g) 1023 | >>> [1, 3, 5] 1024 | 1025 | ``` 1026 | ## Сортировка списков 1027 | В Python списки имеют встроенный метод `sort()`, который сортирует элементы списка по возрастанию или убыванию. 1028 | ```python 1029 | a = [1, 7, -3, 9, 0, -67, 34, 12, 45, 1000, 6, 8, -2, 99] 1030 | a.sort() 1031 | print('Отсортированный список:', a) 1032 | >>> Отсортированный список: [-67, -3, -2, 0, 1, 6, 7, 8, 9, 12, 34, 45, 99, 1000] 1033 | ``` 1034 | Также можно сортировать по убыванию. Если требуется отсортировать список по убыванию, необходимо явно указать параметр `reverse = True.` 1035 | ```python 1036 | a = [1, 7, -3, 9, 0, -67, 34, 12, 45, 1000, 6, 8, -2, 99] 1037 | a.sort(reverse=True) # сортируем по убыванию 1038 | print('Отсортированный список:', a) 1039 | >>> Отсортированный список: [1000, 99, 45, 34, 12, 9, 8, 7, 6, 1, 0, -2, -3, -67] 1040 | ``` 1041 | Функция `sorted() `возвращает отсортированный список, не изменяя оригинальный. 1042 | ```python 1043 | a = [1, 5, 3] 1044 | print(sorted(a)) 1045 | >>> [1, 3, 5] 1046 | ``` 1047 | ## Списочные выражения 1048 | ```python 1049 | numbers = [i for i in range(10)] # числа от 0 до 9 1050 | print(numbers) 1051 | >>> [0, 1, 2, 3, 4, 5, 6, 7, 8, 9] 1052 | 1053 | numbers = [i**2 for i in range(10)] # квадраты чисел от 0 до 9 1054 | print(numbers) 1055 | >>> [0, 1, 4, 9, 16, 25, 36, 49, 64, 81] 1056 | 1057 | numbers = [int(input()) for i in range(int(input()))] # ввод n чисел с клавиатуры 1058 | print(numbers) 1059 | <<< 5 1060 | <<< 1 1061 | <<< 2 1062 | <<< 3 1063 | <<< 4 1064 | <<< 5 1065 | >>> [1, 2, 3, 4, 5] 1066 | 1067 | numbers = [i * j for i in range(1, 5) for j in range(2)] # вложенные циклы 1068 | print(numbers) 1069 | >>> [0, 1, 0, 2, 0, 3, 0, 4] 1070 | 1071 | numbers = [i for i in range(21) if i % 2 == 0] # четные числа от 0 до 20 (условие в списочном выражении) 1072 | print(numbers) 1073 | >>> [0, 2, 4, 6, 8, 10, 12, 14, 16, 18, 20] 1074 | 1075 | ``` 1076 | ## Нахождение чисел палиндромов 1077 | Во-первых, вот что такое палиндром: 1078 | Числа-палиндромы — числа, которые в определённой позиционной системе исчисления (как правило — в десятичной) читаются одинаково как справа налево, так и слева направо. 1079 | Достаточно просто доказать, что чисел-палиндромов бесконечно много. Одним из способов доказательства является замена любой выбранной цифры в их написании двумя любыми другими цифрами, в результате чего получается новое число-палиндром. 1080 | ```python 1081 | palindromes = [i for i in range(100, 1001) if i == int(str(i)[::-1])] 1082 | print(palindromes) 1083 | 1084 | ``` 1085 | ## Методы сортировки списков 1086 | - Сортировка пузырьком 1087 | Алгоритм сортировки пузырьком состоит из повторяющихся проходов по сортируемому списку. За каждый проход элементы последовательно сравниваются попарно и, если порядок в паре неверный, выполняется обмен элементов. Проходы по списку повторяются n−1 раз, где n – длина списка. При каждом проходе алгоритма по внутреннему циклу, очередной наибольший элемент списка ставится на свое место в конце списка рядом с предыдущим «наибольшим элементом». 1088 | Наибольший элемент каждый раз «всплывает» до нужной позиции, как пузырёк в воде — отсюда и название алгоритма. 1089 | 1090 | Алгоритм пузырьковой сортировки считается учебным и практически не применяется вне учебной литературы, а на практике применяются более эффективные. 1091 | 1092 | Реализация: 1093 | ```python 1094 | a = [1, 7, -3, 9, 0, -67, 34, 12, 45, 1000, 6, 8, -2, 99] 1095 | n = len(a) 1096 | 1097 | for i in range(n - 1): 1098 | for j in range(n - 1 - i): 1099 | if a[j] > a[j + 1]: # если порядок элементов пары неправильный 1100 | a[j], a[j + 1] = a[j + 1], a[j] # меняем элементы пары местами 1101 | 1102 | print('Отсортированный список:', a) 1103 | 1104 | ``` 1105 | - Сортировка выбором 1106 | Сортировка выбором улучшает пузырьковую сортировку, совершая всего один обмен за каждый проход по списку. Для этого алгоритм ищет максимальный элемент и помещает его на соответствующую позицию. Как и для пузырьковой сортировки, после первого прохода самый большой элемент находится на правильном месте. После второго прохода на своё место становится следующий максимальный элемент. Проходы по списку повторяются n−1 раз, где n – длина списка, поскольку последний из них автоматически оказывается на своем месте. 1107 | 1108 | Алгоритм сортировки выбором также считается учебным и практически не применяется вне учебной литературы. На практике используют более эффективные алгоритмы. 1109 | 1110 | Реализация: 1111 | ```python 1112 | a = [78, -32, 5, 39, 58, -5, -63, 57, 72, 9, 53, -1, 63, -97, -21, -94, -47, 57, -8, 60, -23, -72, -22, -79, 90, 96, -41, -71, -48, 84, 89, -96, 41, -16, 94, -60, -64, -39, 60, -14, -62, -19, -3, 32, 98, 14, 43, 3, -56, 71, -71, -67, 80, 27, 92, 92, -64, 0, -77, 2, -26, 41, 3, -31, 48, 39, 20, -30, 35, 32, -58, 2, 63, 64, 66, 62, 82, -62, 9, -52, 35, -61, 87, 78, 93, -42, 87, -72, -10, -36, 61, -16, 59, 59, 22, -24, -67, 76, -94, 59] 1113 | 1114 | n = len(a) 1115 | 1116 | for i in range(n): 1117 | mx = max(a[:n - i]) 1118 | mx_ind = a.index(mx) 1119 | 1120 | a[n - 1 - i], a[mx_ind] = a[mx_ind], a[n - 1 - i] 1121 | 1122 | print('Отсортированный список:', a) 1123 | 1124 | ``` 1125 | - Сортировка простыми вставками 1126 | Алгоритм сортировки простыми вставками делит список на 2 части — отсортированную и неотсортированную. Из неотсортированной части извлекается очередной элемент и вставляется на нужную позицию в отсортированной части, в результате чего отсортированная часть списка увеличивается, а неотсортированная уменьшается. Так происходит, пока не исчерпан набор входных данных и не отсортированы все элементы. 1127 | 1128 | Сортировка простыми вставками наиболее эффективна, когда список уже частично отсортирован и элементов массива немного. Если элементов в списке меньше 10, то этот алгоритм - один из самых быстрых. 1129 | 1130 | Реализация: 1131 | ```python 1132 | a = [1, 7, -3, 9, 0, -67, 34, 12, 45, 1000, 6, 8, -2, 99] 1133 | n = len(a) 1134 | 1135 | for i in range(1, n): 1136 | elem = a[i] # берем первый элемент из неотсортированной части списка 1137 | j = i 1138 | 1139 | # пока элемент слева существует и больше нашего текущего элемента 1140 | while j >= 1 and a[j - 1] > elem: 1141 | # смещаем j-1-й элемент отсортированной части вправо 1142 | a[j] = a[j - 1] 1143 | # сами идём влево, дальше ищем место для нашего текущего элемента 1144 | j -= 1 1145 | 1146 | # нашли место для нащего текущего элемента из неотсортированной части 1147 | # и вставляем его на индекс j в отсортированной части 1148 | a[j] = elem 1149 | 1150 | print('Отсортированный список:', a) 1151 | 1152 | 1153 | ``` 1154 | # Тип данных bool и NoneType 1155 | ## bool 1156 | - bool может иметь значение `True `или `False`. 1157 | - `a and b `дает `True`, если оба операнда `True`, или `False`, если хотя бы один из них `False` 1158 | - `a or b `дает `False`, если оба операнда `False`, или `True`, если хотя бы один из них `Truef` 1159 | - `not a` дает `True`, если `a` имеет значение `False`, или `False`, если `a` имеет значение `True`. 1160 | 1161 | ```python 1162 | print(True == 1) 1163 | print(False == 0) 1164 | >>> True 1165 | >>> True 1166 | 1167 | print(True == 1) 1168 | print(False == 0) 1169 | >>> True 1170 | >>> True 1171 | ``` 1172 | Для приведения других типов данных к булеву существует функция `bool()`, работающая по следующим соглашениям: 1173 | - строки: пустая строка – ложь (`False`), непустая строка – истина (`True`) 1174 | - числа: нулевое число – ложь (`False`), ненулевое число (в том числе и меньшее нуля) – истина (`True`) 1175 | - списки: пустой список – ложь (`False`), непустой – истина (`True`). 1176 | 1177 | В языке Python имеется встроенная функция `isinstance()` для проверки соответствия типа объекта какому-либо типу данных. 1178 | ```python 1179 | print(isinstance(3, int)) 1180 | print(isinstance(3.5, float)) 1181 | print(isinstance('Beegeek', str)) 1182 | print(isinstance([1, 2, 3], list)) 1183 | print(isinstance(True, bool)) 1184 | >>> True 1185 | >>> True 1186 | >>> True 1187 | >>> True 1188 | >>> True 1189 | 1190 | ``` 1191 | В языке Python имеется встроенная функция `type()`, позволяющая получить тип указанного в качестве аргумента объекта. 1192 | ```python 1193 | print(type(3)) 1194 | print(type(3.5)) 1195 | print(type('Beegeek')) 1196 | print(type([1, 2, 3])) 1197 | print(type(True)) 1198 | >>> 1199 | >>> 1200 | >>> 1201 | >>> 1202 | >>> 1203 | 1204 | ``` 1205 | ## NoneType 1206 | ```python 1207 | var = None 1208 | print(type(var)) 1209 | >>> 1210 | ``` 1211 | Сравнение `None` с любым объектом, отличным от `None`, дает значение `False`. `None` возвращается если функция ничего не вернула. 1212 | 1213 | # Вложенные списки 1214 | ## Основы 1215 | Создание вложенного списка: 1216 | ```python 1217 | my_list = [[0], [1, 2], [3, 4, 5]] 1218 | ``` 1219 | Чтобы получить число 2 мы используем такую команду: 1220 | ```python 1221 | my_list = [[0], [1, 2], [3, 4, 5]] 1222 | print(my_list[1][1]) # сначала получаем список с индексом 1 ([1, 2]), а затем первый индекс (2) 1223 | >>> 2 1224 | 1225 | ``` 1226 | Функции `min()` и `max() `могут работать и со списками. Если этим функциям передается несколько списков, то целиком возвращается один из переданных списков. При этом сравнение происходит поэлементно: сначала сравниваются первые элементы списков. Если они не равны, то функция `min()` вернет тот список, первый элемент которого меньше, `max()` – наоборот. Если первые элементы равны, то будут сравниваться вторые и т. д. 1227 | Пример: 1228 | Задача: 1229 | На вход программе подается число n. Напишите программу, которая создает и выводит построчно вложенный список, состоящий из n списков [[1], [1, 2], [1, 2, 3], ..., [1, 2, ..., n]]. 1230 | Формат входных данных 1231 | На вход программе подается натуральное число n. 1232 | Формат выходных данных 1233 | Программа должна вывести построчно указанный вложенный список. 1234 | Решение: 1235 | ```python 1236 | print(*[[i for i in range(1, j+1)] for j in range(1, int(input())+1)], sep="\n") 1237 | 1238 | ``` 1239 | ## Матрицы, ljust(), rjust() 1240 | Матрицы - прямоугольные таблицы, заполненные какими-то значениями, обычно числами. 1241 | ![Image 10](images/image_10.png) 1242 | 1243 | Перебор элементов матрицы: 1244 | ```python 1245 | rows, cols = 3, 4 # rows - количество строк, cols - количество столбцов 1246 | 1247 | matrix = [[2, 3, 1, 0], 1248 | [9, 4, 6, 8], 1249 | [4, 7, 2, 7]] 1250 | 1251 | for r in range(rows): 1252 | for c in range(cols): 1253 | print(matrix[r][c], end=' ') 1254 | print() 1255 | >>> 2 3 1 0 1256 | >>> 9 4 6 8 1257 | >>> 4 7 2 7 1258 | ``` 1259 | Строковый метод `ljust(arg) `выравнивает текст по ширине, добавляя пробелы в конец текста: 1260 | Строковый метод `rjust(arg)` выравнивает текст по ширине, добавляя пробелы в начало текста: 1261 | ```python 1262 | matrix = [[1, 2, 3], 1263 | [4, 590, 6], 1264 | [70, 8, 9]] 1265 | 1266 | for i in range(3): 1267 | for j in range(3): 1268 | print(str(matrix[i][j]).ljust(5), end="") 1269 | print() 1270 | 1271 | print() 1272 | 1273 | for i in range(3): 1274 | for j in range(3): 1275 | print(str(matrix[i][j]).rjust(5), end="") 1276 | print() 1277 | >>> 1 2 3 1278 | >>> 4 590 6 1279 | >>> 70 8 9 1280 | 1281 | >>> 1 2 3 1282 | >>> 4 590 6 1283 | >>> 70 8 9 1284 | 1285 | ``` 1286 | Таблица умножения n на m: 1287 | ```python 1288 | n, m = int(input()), int(input()) 1289 | s = [[i * j for i in range(m)] for j in range(n)] 1290 | for i in s: 1291 | print(*i) 1292 | <<< 4 1293 | <<< 6 1294 | >>> 0 0 0 0 0 0 1295 | >>> 0 1 2 3 4 5 1296 | >>> 0 2 4 6 8 10 1297 | >>> 0 3 6 9 12 15 1298 | 1299 | ``` 1300 | # Кортежи 1301 | ## Введение 1302 | Кортежи по своей природе (задумке) – неизменяемые аналоги списков. Кортеж описывается следующим образом: 1303 | ```python 1304 | list = [] # список 1305 | tuple = () # кортеж 1306 | ``` 1307 | Для создания кортежа с единственным элементом после значения элемента ставят замыкающую запятую: 1308 | ```python 1309 | my_tuple = (1,) 1310 | print(type(my_tuple)) 1311 | >>> 1312 | ``` 1313 | Если её не поставить, то будет создан не кортеж, а просто переменная со значением 1 (типа `int`) 1314 | 1315 | В чём кортеж превосходит список? 1316 | - Скорость 1317 | - Безопасность 1318 | Где встречаются кортежи? Если функция возвращает несколько значений, она возвращает кортеж. 1319 | 1320 | Важно! Тот факт, что кортеж является неизменяемым вовсе не означает, что мы не можем поменять содержимое списка в кортеже. 1321 | 1322 | ## Основы 1323 | Кортеж можно превратить в список используя функцию `list(mytuple)`. 1324 | Список можно превратить в кортеж используя функцию `tuple(mylist)`. 1325 | Кортеж можно преобразовать в строку с помощью строкового метода `join(mytuple)`. 1326 | Строку можно преобразовать в кортеж с помощью функции `tuple(mystring)`. 1327 | 1328 | Кортежи поддерживают: 1329 | - доступ к элементу по индексу (только для получения значений элементов) 1330 | - методы, в частности `index()`, `count()` 1331 | - встроенные функции, в частности `len(), sum(), min(), max()` 1332 | - срезы 1333 | - оператор принадлежности `in` 1334 | - операторы конкатенации (+) и повторения (*). 1335 | Кортежи могут иметь вложенные кортежи и вложенные списки. 1336 | 1337 | ## Сравнение кортежей 1338 | ```python 1339 | print((1, 8) == (1, 8)) 1340 | print((1, 8) != (1, 10)) 1341 | print((1, 9) < (1, 2)) 1342 | print((2, 5) < (6,)) 1343 | print(('a', 'bc') > ('a', 'de')) 1344 | 1345 | >>> True 1346 | >>> True 1347 | >>> False 1348 | >>> True 1349 | >>> False 1350 | ``` 1351 | Обратите внимание: операции == и != применимы к любым кортежам, независимо от типов элементов. А вот операции <, >, <=, >= применимы только в том случае, когда соответствующие элементы кортежей имеют один тип. 1352 | 1353 | ## Сортировка кортежей 1354 | Так как кортежи неизменяемы, то и метода `sort()` у них нет. Но кортеж можно отсортировать при помощи функции `sorted()`. Данная функция возвращает отсортированный кортеж/список, а не сортирует его «на месте». 1355 | Примеры решения задач: 1356 | Условие: Напишите программу, которая выводит список хорошистов и отличников в классе. 1357 | Формат входных данных 1358 | На вход программе подается натуральное число 1359 | n, далее следует n строк с фамилией школьника и его оценкой на каждой из них. 1360 | Формат выходных данных 1361 | Программа должна вывести сначала все введённые строки с фамилиями и оценками учеников в том же порядке. Затем следует пустая строка, а затем выводятся строки с фамилиями и оценками хорошистов и отличников (в том же порядке). 1362 | Решение: 1363 | ```python 1364 | a = [tuple(input().split()) for _ in range(int(input()))] # создаем n кортежей, которые будут иметь 2 значения - фамилия и оценка 1365 | for i in a: 1366 | print(*i) 1367 | 1368 | print() 1369 | 1370 | for name, grade in a: # перебираем каждый кортеж 1371 | if int(grade) > 3: # если оценка выше 3, выводим имя и оценку 1372 | print(name, grade) 1373 | 1374 | ``` 1375 | ## Распаковка кортежей 1376 | Кортежи можно распаковывать так: 1377 | ```python 1378 | print(*tuple) 1379 | ``` 1380 | Но мы также можем присвоить переменным значения элементов кортежа: 1381 | ```python 1382 | colors = ('red', 'green', 'blue', 'cyan') 1383 | 1384 | (a, b, c, d) = colors 1385 | 1386 | print(a) 1387 | print(b) 1388 | print(c) 1389 | print(d) 1390 | >>> red 1391 | >>> green 1392 | >>> blue 1393 | >>> cyan 1394 | ``` 1395 | При этом переменных должно быть ровно столько, сколько символов в кортеже. 1396 | Но что делать если нам нужны например только первые 2 переменные из кортежа/списка? Для этого используют такую конструкцию: 1397 | ```python 1398 | *names, surname = ('Стефани', 'Джоанн', 'Анджелина', 'Джерманотта') 1399 | 1400 | print(names) 1401 | print(surname) 1402 | >>> ['Стефани', 'Джоанн', 'Анджелина'] 1403 | >>> Джерманотта 1404 | ``` 1405 | Перед `names` мы поставили `*`, это означает что это список, который примет все значения, которые не приняли другие переменные. 1406 | Учтите, что `*tail` всегда будет списком, даже когда в него попадает лишь один элемент или даже ноль. 1407 | 1408 | # Множества 1409 | ## Множества в математике 1410 | В математике множество – совокупность объектов, понимаемых как единое целое. Обычно множества обозначают большими латинскими буквами. 1411 | Если два множества X и Y состоят из одних и тех же элементов, то они называются равными X=Y. Обратите внимание, порядок расположения элементов в записи множеств при их сравнении во внимание не принимается. 1412 | Если все элементы множества X принадлежат также и множеству Y, то говорят, что X является подмножеством Y, а записывается это так: X ⊂ Y. 1413 | Если множество X конечно, то через ∣X∣ обозначается количество элементов множества X. 1414 | Множество X, содержащее n элементов, имеет 2^n подмножеств, включая пустое. Например, X = {a, b, c} (3 элемента) имеет 8 подмножеств: ∅, {a}, {b}, {c}, {a, b}, {a, c}, {b, c}, {a, b, c}. 1415 | Важно! Множества – неупорядоченные совокупности, то есть неважно, в каком порядке указаны элементы множества. 1416 | 1417 | ## Пустое множество 1418 | Пустое множество – множество, не содержащего ни одного элемента. Оно обозначается знаком ∅. 1419 | 1420 | ## Числовые множества 1421 | - Натуральные числа: 1422 | N={1,2,3,4,5,…} 1423 | - Целые числа: 1424 | Z={0,±1,±2,±3,±4,±5,…} 1425 | - Рациональные числа. Рациональным числом в математике называется любое число, представимое в виде частного двух целых чисел с отличным от нуля знаменателем. Множество рациональных чисел обозначается буквой Q и содержит следующие числа: 1426 | Q={, m∈Z, n∈N}. 1427 | - Иррациональные числа. Не все числа в математике можно представить в виде рационального числа. Примером служат числа: 1428 | ≈1.414213562… 1429 | π≈3.1415926535… 1430 | e≈2.71828182845… 1431 | Такие числа называются иррациональными и являются бесконечными непериодическими дробями. Иными словами, в «бесконечных хвостах» иррациональных чисел нет никакой закономерности. Иррациональные числа часто обозначают буквой I. 1432 | - Вещественные числа: 1433 | Объединение рациональных и иррациональных чисел образует множество вещественных чисел. Множество вещественных чисел R определяется так: R=Q∪I. Символ ∪ – означает объединение множеств. 1434 | - Комплексные числа: 1435 | Комплексные числа — это числа вида a + bi, где a и b — действительные числа, а i — мнимая единица (i^2 = −1). 1436 | Это множество обозначают буквой C. 1437 | 1438 | ## Операции над множествами 1439 | - Объединение множеств – множество, состоящее из элементов, принадлежащих хотя бы одному из объединяемых множеств. Для объединения множеств используется символ ∪. 1440 | ![Image 11](images/image_11.png) 1441 | 1442 | - Пересечение множеств – множество, состоящее из элементов, принадлежащих одновременно каждому из пересекающихся множеств. Для пересечения множеств используется символ ∩. 1443 | ![Image 12](images/image_12.png) 1444 | 1445 | - Разность множеств – множество, в которое входят только элементы первого множества, не входящие во второе множество. Для разности множеств используется символ ∖. 1446 | ![Image 13](images/image_13.png) 1447 | 1448 | - Симметрическая разность множеств – множество, включающее все элементы исходных множеств, не принадлежащие одновременно обоим исходным множествам. Для симметрической разности множеств используется символ △. 1449 | ![Image 14](images/image_14.png) 1450 | 1451 | - Дополнение множества – множество всех элементов, в нем не содержащихся. Для операции дополнения множества используется символ ¬. 1452 | ![Image 15](images/image_15.png) 1453 | 1454 | ## Диаграммы Эйлера-Венна при решении задач 1455 | Задача. Каждый ученик онлайн-школы BEEGEEK изучает или математику или информатику, или и то и другое одновременно. Всего 75 учеников изучает математику, а 27 – информатику и только 13 – оба предмета. Сколько учеников учится в онлайн-школе BEEGEEK? 1456 | Решение. Введем обозначения: множество учеников, изучающих математику – М, информатику – И. Изображаем множества на диаграмме Эйлера-Венна в наиболее общем случае. 1457 | ![Image 16](images/image_16.png) 1458 | Рассуждаем следующим образом: оба предмета изучают 13 учеников. Значит, только математику изучают 75 − 13 = 62 ученика, только информатику изучают 27 − 13 = 14 учеников. Таким образом, всего в школе учится 62 + 13 + 14 = 89 учеников. Ответ: 89. 1459 | 1460 | ## Введение в множества в Python 1461 | Важно знать: 1462 | - все элементы множества различны (уникальны), два элемента не могут иметь одинаковое значение 1463 | - множества неупорядочены, то есть элементы не хранятся в каком-то определенном порядке 1464 | - элементы множества должны относиться к неизменяемым типам данных 1465 | - хранящиеся в множестве элементы могут иметь разные типы данных. 1466 | - Множества изменяемы 1467 | Множество не может содержать список, множество, однако может содержать кортеж. 1468 | 1469 | ## Создание множества 1470 | Чтобы создать множество, нужно перечислить его элементы через запятую в фигурных скобках: 1471 | ```python 1472 | numbers = {2, 4, 6, 8, 10} 1473 | languages = {"Python", "C#", "C++", "Java"} 1474 | favorites = {"Nikita", 144, "My friend"} 1475 | 1476 | ``` 1477 | Создать пустое множество можно с помощью встроенной функции, которая называется `set()`: 1478 | ```python 1479 | myset = set() # пустое множество 1480 | ``` 1481 | Важно! Создать пустое множество с помощью пустых фигурных скобок нельзя: 1482 | ```python 1483 | myset = {} # создается словарь 1484 | 1485 | ``` 1486 | ## Вывод множества 1487 | Вывести множество можно через `print(myset)`. 1488 | Обратите внимание: при выводе множества порядок элементов может отличаться от существовавшего при его создании, поскольку множества — неупорядоченные коллекции данных. 1489 | 1490 | ## set() 1491 | Встроенная функция `set() `помимо создания пустого множества может преобразовывать некоторые типы объектов в множества. В функцию `set() `можно передать один аргумент. Передаваемый аргумент должен быть итерируемым объектом, таким как список, кортеж или строковое значение. Отдельные элементы объекта, передаваемого в качестве аргумента, становятся элементами множества: 1492 | ```python 1493 | myset1 = set(range(10)) # множество из элементов последовательности 1494 | myset2 = set([1, 2, 3, 4, 5]) # множество из элементов списка 1495 | myset3 = set('abcd') # множество из элементов строки 1496 | myset4 = set((10, 20, 30, 40)) # множество из элементов кортежа 1497 | ``` 1498 | Пустое множество также можно создать передав функции `set() `в качестве аргумента пустой список, строку или кортеж: 1499 | ```python 1500 | emptyset1 = set([]) # пустое множество из пустого списка 1501 | emptyset2 = set('') # пустое множество из пустой строки 1502 | emptyset3 = set(()) # пустое множество из пустого кортежа 1503 | 1504 | ``` 1505 | Множества не могут содержать повторяющиеся элементы. Если в функцию `set()` передать аргумент, содержащий повторяющиеся элементы, то в множестве появится только один из этих повторяющихся элементов. 1506 | ```python 1507 | myset1 = {2, 2, 4, 6, 6} 1508 | myset2 = set([1, 2, 2, 3, 3]) 1509 | myset3 = set("aaaaabbbbccccddd") 1510 | 1511 | print(myset1) 1512 | print(myset2) 1513 | print(myset3) 1514 | >>> {2, 4, 6} 1515 | >>> {1, 2, 3} 1516 | >>> {"b", "c", "d", "a"} 1517 | 1518 | ``` 1519 | Если требуется создать множество, в котором каждый элемент — строковое значение, содержащее более одного символа, то используем код: 1520 | ```python 1521 | myset = set(['aaa', 'bbbb', 'cc']) 1522 | 1523 | print(myset) 1524 | >>> {'bbbb', 'aaa', 'cc'} 1525 | ``` 1526 | Однако вот что будет, если аргумент будет строкой: 1527 | ```python 1528 | myset = set('aaa bbbb cc') 1529 | 1530 | print(myset) 1531 | >>> {' ', 'c', 'a', 'b'} 1532 | 1533 | ``` 1534 | ## Основы работы с множествами 1535 | - Функция `len() `возвращает длину множества (количество элементов). 1536 | - Оператор `in `позволяет проверить, содержит ли множество некоторый элемент. В множествах он работает намного быстрее чем в списках. 1537 | - Встроенная функция `sum()` принимает в качестве аргумента множество чисел и вычисляет сумму его элементов. 1538 | - Встроенные функции `min() `и `max()` принимают в качестве аргумента множество и находят минимальный и максимальный элементы соответственно. 1539 | Важно! Индексация и срезы недоступны для множеств. Операция конкатенации + и умножения на число * тоже недоступны для множеств. 1540 | 1541 | ## Перебор элементов множества и распаковка 1542 | Перебор элементов множества осуществляется точно так же, как и перебор элементов списка, то есть с помощью цикла `for`. 1543 | Для вывода элементов множества каждого на отдельной строке можно использовать следующий код: 1544 | ```python 1545 | numbers = {0, 1, 1, 2, 3, 3, 3, 5, 6, 7, 7} 1546 | 1547 | for num in numbers: 1548 | print(num) 1549 | >>> 0 1550 | >>> 1 1551 | >>> 2 1552 | >>> 3 1553 | >>> 5 1554 | >>> 6 1555 | >>> 7 1556 | ``` 1557 | Но также можно распаковать таким способом: 1558 | ```python 1559 | numbers = {0, 1, 1, 2, 3, 3, 3, 5, 6, 7, 7} 1560 | 1561 | print(*numbers) 1562 | >>> 0 1 2 3 5 6 7 1563 | ``` 1564 | Помните, что множества - неупорядоченные коллекции, а значит если вам нужно вывести элементы по возрастанию, используйте функцию `sorted()`, которая вернёт отсортированный список. Метода `sort()` у множеств нет. В функции можно указать необязательный параметр `reverse`. При `reverse=True` множество будет отсортировано по убыванию. 1565 | 1566 | ## Сравнение множеств 1567 | Множества можно сравнивать между собой. Равные множества имеют одинаковую длину и содержат равные элементы. Для сравнения множеств используются операторы == и !=. Других операторов сравнения у множеств нет. 1568 | 1569 | ## Методы множеств 1570 | Основные: 1571 | - Для добавления нового элемента в множество используется метод `add()`. 1572 | ```python 1573 | numbers = {1, 1, 2, 3, 5, 8, 3} # создаем множество 1574 | numbers.add(21) # добавляем число 21 в множество 1575 | numbers.add(34) # добавляем число 34 в множество 1576 | print(numbers) 1577 | >>> {1, 2, 3, 34, 5, 8, 21} 1578 | ``` 1579 | - Метод `remove()` удаляет элемент из множества с генерацией исключения (ошибки) в случае, если такого элемента нет. 1580 | ```python 1581 | numbers = {1, 2, 3, 4, 5} 1582 | numbers.remove(3) 1583 | print(numbers) 1584 | >>> {1, 2, 4, 5} 1585 | ``` 1586 | - Метод `discard()` удаляет элемент из множества без генерации исключения (ошибки), если элемент отсутствует. 1587 | ```python 1588 | numbers = {1, 2, 3, 4, 5} 1589 | numbers.discard(3) 1590 | print(numbers) 1591 | >>> {1, 2, 4, 5} 1592 | 1593 | numbers = {1, 2, 3, 4, 5} 1594 | numbers.discard(10) 1595 | print(numbers) 1596 | >>> {1, 2, 3, 4, 5} 1597 | ``` 1598 | - Метод `pop()` удаляет и возвращает первый элемент из множества с генерацией исключения (ошибки) при попытке удаления из пустого множества. Аргументы указать нельзя. 1599 | ```python 1600 | numbers = {1, 2, 3, 4, 5} 1601 | print('до удаления:', numbers) 1602 | num = numbers.pop() # удаляет первый элемент множества, возвращая его 1603 | print('удалённый элемент:', num) 1604 | print('после удаления:', numbers) 1605 | >>> до удаления: {1, 2, 3, 4, 5} 1606 | >>> удалённый элемент: 1 1607 | >>> после удаления: {2, 3, 4, 5} 1608 | ``` 1609 | - Метод `clear()` удаляет все элементы из множества. 1610 | ```python 1611 | numbers = {1, 2, 3, 4, 5} 1612 | numbers.clear() 1613 | print(numbers) 1614 | >>> set() 1615 | 1616 | ``` 1617 | Операции над множествами: 1618 | - Объединение множеств: `union() `возвращает новое множество со всеми элементами первого и второго. 1619 | Для объединения двух множеств можно также использовать оператор |. 1620 | Для изменения текущего множества используется метод `update()`. 1621 | Первый вариант: 1622 | ```python 1623 | myset1 = {1, 2, 3, 4, 5} 1624 | myset2 = {3, 4, 6, 7, 8} 1625 | myset3 = myset1.union(myset2) 1626 | print(myset3) 1627 | >>> {1, 2, 3, 4, 5, 6, 7, 8} 1628 | ``` 1629 | Второй вариант: 1630 | ```python 1631 | myset1 = {1, 2, 3, 4, 5} 1632 | myset2 = {3, 4, 6, 7, 8} 1633 | myset3 = myset1 | myset2 1634 | print(myset3) 1635 | >>> {1, 2, 3, 4, 5, 6, 7, 8} 1636 | ``` 1637 | Использование `update()`: 1638 | ```python 1639 | myset1 = {1, 2, 3, 4, 5} 1640 | myset2 = {3, 4, 6, 7, 8} 1641 | myset1.update(myset2) # изменяем множество myset1 1642 | print(myset1) 1643 | >>> {1, 2, 3, 4, 5, 6, 7, 8} 1644 | ``` 1645 | Еще один способ: 1646 | ```python 1647 | myset1 = {1, 2, 3, 4, 5} 1648 | myset2 = {3, 4, 6, 7, 8} 1649 | myset1 |= myset2 1650 | print(myset1) 1651 | >>> {1, 2, 3, 4, 5, 6, 7, 8} 1652 | 1653 | ``` 1654 | - Пересечение множеств: `intersection() `возвращает новое множество состоящее из элементов, принадлежащих одновременно каждому из пересекающихся множеств. 1655 | Для пересечения двух множеств можно также использовать оператор &. 1656 | Для изменения текущего множества используется метод `intersection_update()`. 1657 | Первый вариант: 1658 | ```python 1659 | myset1 = {1, 2, 3, 4, 5} 1660 | myset2 = {3, 4, 6, 7, 8} 1661 | myset3 = myset1.intersection(myset2) 1662 | print(myset3) 1663 | >>> {3, 4} 1664 | ``` 1665 | Второй вариант: 1666 | ```python 1667 | myset1 = {1, 2, 3, 4, 5} 1668 | myset2 = {3, 4, 6, 7, 8} 1669 | myset3 = myset1 & myset2 1670 | print(myset3) 1671 | >>> {3, 4} 1672 | ``` 1673 | Использование `intersection_update()`: 1674 | ```python 1675 | myset1 = {1, 2, 3, 4, 5} 1676 | myset2 = {3, 4, 6, 7, 8} 1677 | myset1.intersection_update(myset2) # изменяем множество myset1 1678 | print(myset1) 1679 | >>> {3, 4} 1680 | ``` 1681 | Еще один способ: 1682 | ```python 1683 | myset1 = {1, 2, 3, 4, 5} 1684 | myset2 = {3, 4, 6, 7, 8} 1685 | myset1 &= myset2 1686 | print(myset1) 1687 | >>> {3, 4} 1688 | ``` 1689 | - Разность множеств: `difference() `возвращает новое множество, в которое входят все элементы первого множества, не входящие во второе множество. 1690 | Для разности двух множеств можно также использовать оператор -. 1691 | Для изменения текущего множества используется метод `difference_update()`. 1692 | Первый вариант: 1693 | ```python 1694 | myset1 = {1, 2, 3, 4, 5} 1695 | myset2 = {3, 4, 6, 7, 8} 1696 | myset3 = myset1.difference(myset2) 1697 | print(myset3) 1698 | >>> {1, 2, 5} 1699 | ``` 1700 | Второй вариант: 1701 | ```python 1702 | myset1 = {1, 2, 3, 4, 5} 1703 | myset2 = {3, 4, 6, 7, 8} 1704 | myset3 = myset1 - myset2 1705 | print(myset3) 1706 | >>> {1, 2, 5} 1707 | ``` 1708 | Использование `difference_update()`: 1709 | ```python 1710 | myset1 = {1, 2, 3, 4, 5} 1711 | myset2 = {3, 4, 6, 7, 8} 1712 | myset1.difference_update(myset2) # изменяем множество myset1 1713 | print(myset1) 1714 | >>> {1, 2, 5} 1715 | ``` 1716 | Еще один способ: 1717 | ```python 1718 | myset1 = {1, 2, 3, 4, 5} 1719 | myset2 = {3, 4, 6, 7, 8} 1720 | myset1 -= myset2 1721 | print(myset1) 1722 | >>> {1, 2, 5} 1723 | ``` 1724 | - Симметричная разность множеств: `symmetric_difference() `возвращает новое множество, включающее все элементы исходных множеств, не принадлежащие одновременно обоим исходным множествам. 1725 | Для симметричной разности двух множеств можно также использовать оператор ^. 1726 | Для изменения текущего множества используется метод `symmetric_difference_update()`. 1727 | Первый вариант: 1728 | ```python 1729 | myset1 = {1, 2, 3, 4, 5} 1730 | myset2 = {3, 4, 6, 7, 8} 1731 | myset3 = myset1.symmetric_difference(myset2) 1732 | print(myset3) 1733 | >>> {1, 2, 5, 6, 7, 8} 1734 | ``` 1735 | Второй вариант: 1736 | ```python 1737 | myset1 = {1, 2, 3, 4, 5} 1738 | myset2 = {3, 4, 6, 7, 8} 1739 | myset3 = myset1 ^ myset2 1740 | print(myset3) 1741 | >>> {1, 2, 5, 6, 7, 8} 1742 | ``` 1743 | Использование `symmetric_difference_update()`: 1744 | ```python 1745 | myset1 = {1, 2, 3, 4, 5} 1746 | myset2 = {3, 4, 6, 7, 8} 1747 | myset1.symmetric_difference_update(myset2) # изменяем множество myset1 1748 | print(myset1) 1749 | >>> {1, 2, 5, 6, 7, 8} 1750 | ``` 1751 | Еще один способ: 1752 | ```python 1753 | myset1 = {1, 2, 3, 4, 5} 1754 | myset2 = {3, 4, 6, 7, 8} 1755 | myset1 ^= myset2 1756 | print(myset1) 1757 | >>> {1, 2, 5, 6, 7, 8} 1758 | 1759 | ``` 1760 | Подмножества и надмножества: 1761 | Любое множество – подмножество самого себя, про такое подмножество говорят "нестрогое подмножество". 1762 | Для определения, является ли одно из множеств подмножеством другого, используется метод `issubset(). `Данный метод возвращает значение `True`, если одно множество является подмножеством другого, и `False`, если не является 1763 | ```python 1764 | set1 = {2, 3} 1765 | set2 = {1, 2, 3, 4, 5, 6} 1766 | print(set1.issubset(set2)) 1767 | >>> True 1768 | 1769 | ``` 1770 | Для определения, является ли одно из множеств подмножеством другого, также применяются операторы <= (нестрогое подмножество) и < (строгое подмножество). 1771 | ```python 1772 | set1 = {2, 3} 1773 | set2 = {1, 2, 3, 4, 5, 6} 1774 | print(set1 <= set2) 1775 | >>> True 1776 | 1777 | ``` 1778 | Для определения, является ли одно из множеств надмножеством другого, используется метод `issuperset()`. Данный метод возвращает значение `True`, если одно множество является надмножеством другого, в противном случае он возвращает `False`. 1779 | ```python 1780 | set1 = {'a', 'b', 'c', 'd', 'e'} 1781 | set2 = {'c', 'e'} 1782 | print(set1.issuperset(set2)) 1783 | >>> True 1784 | ``` 1785 | Для определения, является ли одно из множеств надмножеством другого, также применяются операторы >= (нестрогое надмножество) и > (строгое надмножество). 1786 | ```python 1787 | set1 = {'a', 'b', 'c', 'd', 'e'} 1788 | set2 = {'c', 'e'} 1789 | print(set1 >= set2) 1790 | >>> True 1791 | ``` 1792 | Для определения отсутствия общих элементов в множествах используется метод `isdisjoint()`. Данный метод возвращает значение `True`, если множества не имеют общих элементов, и `False`, когда множества имеют общие элементы. 1793 | ```python 1794 | set1 = {1, 2, 3, 4, 5} 1795 | set2 = {5, 6, 7} 1796 | set3 = {7, 8, 9} 1797 | print(set1.isdisjoint(set2)) 1798 | print(set1.isdisjoint(set3)) 1799 | print(set2.isdisjoint(set3)) 1800 | >>> False 1801 | >>> True 1802 | >>> False 1803 | 1804 | ``` 1805 | ## Генераторы множеств 1806 | Чтобы заполнить множество всеми цифрами числа, можно использовать следующий код: 1807 | ```python 1808 | digits = {int(c) for c in input()} 1809 | ``` 1810 | В генераторах можно использовать условия: 1811 | ```python 1812 | digits = {int(d) for d in 'abcd12ef78ghj90' if d.isdigit()} 1813 | ``` 1814 | Данный код добавляет в `digits` только цифры. 1815 | 1816 | ## frozenset 1817 | frozenset – замороженный вариант множеств (set) 1818 | Синтаксис замороженных множеств полностью идентичен обычным. 1819 | Такие множества можно сравнивать с обычными. 1820 | 1821 | Зачем они нужны? 1822 | - Замороженные множества являются неизменяемыми, а значит могут быть элементами других множеств. 1823 | 1824 | # Словари 1825 | ## Введение 1826 | Словарь – изменяемый тип данных в Python. Левая часть – ключ, правая – значение. 1827 | Пример словаря: 1828 | ```python 1829 | languages = {'Python': 'Гвидо ван Россум', 1830 | 'C#': 'Андерс Хейлсберг', 1831 | 'Java': 'Джеймс Гослинг', 1832 | 'C++': 'Бьёрн Страуструп'} 1833 | ``` 1834 | Код создает словарь, в котором ключом служит строка — название языка программирования, а значением — имя создателя языка. Важно! В рамках одного словаря каждый ключ уникален. 1835 | 1836 | Для извлечения элемента словаря используют ключ: 1837 | ```python 1838 | languages = {'Python': 'Гвидо ван Россум', 1839 | 'C#': 'Андерс Хейлсберг', 1840 | 'Java': 'Джеймс Гослинг', 1841 | 'C++': 'Бьёрн Страуструп'} 1842 | 1843 | print('Создателем языка C# является', languages['C#']) 1844 | >>> Создателем языка C# является Андерс Хейлсберг 1845 | ``` 1846 | В отличие от списков, номеров позиций в словарях нет. 1847 | 1848 | Для вывода всего словаря можно использовать функцию `print()`: 1849 | ```python 1850 | info = {"name": "Nikita", "status": "Creator"} 1851 | print(info) 1852 | >>> {'name': 'Nikita', 'status': 'Creator'} 1853 | ``` 1854 | Начиная с версии Python 3.6, словари являются упорядоченными, то есть сохраняют порядок следования ключей в порядке их внесения в словарь. 1855 | 1856 | ## Создание словаря 1857 | Если ключи словаря — строки без каких-либо специальных символов, то для создания словаря можно использовать функцию `dict(). `Пример: 1858 | ```python 1859 | info = dict(name='Timur', age=28, job='Teacher') 1860 | 1861 | ``` 1862 | Создание на основе списка кортежей: 1863 | ```python 1864 | info_list = [('name', 'Timur'), ('age', 28), ('job', 'Teacher')] # список кортежей 1865 | info_dict = dict(info_list) # создаем словарь на основе списка кортежей 1866 | 1867 | ``` 1868 | Создание на основе кортежа списков: 1869 | ```python 1870 | info_tuple = (['name', 'Timur'], ['age', 28], ['job', 'Teacher']) # кортеж списков 1871 | info_dict = dict(info_tuple) # создаем словарь на основе кортежа списков 1872 | 1873 | ``` 1874 | Если необходимо создать словарь, каждому ключу которого соответствует одно и то же значение, можно воспользоваться методом `fromkeys()`. 1875 | ```python 1876 | dict1 = dict.fromkeys(['name', 'age', 'job'], 'Missed information') 1877 | ``` 1878 |  Если методу `fromkeys()` не передать второй параметр, то по умолчанию присваивается значение `None`. 1879 | 1880 | Создать словарь на основании двух списков (кортежей) можно с помощью встроенной функции-упаковщика `zip().` 1881 | ```python 1882 | keys = ['name', 'age', 'job'] 1883 | values = ['Timur', 28, 'Teacher'] 1884 | info = dict(zip(keys, values)) 1885 | print(info) 1886 | >>> {'name': 'Timur', 'age': 28, 'job': 'Teacher'} 1887 | ``` 1888 | В случае несовпадения длины списков функция самостоятельно отсечет лишние элементы. 1889 | 1890 | ## Создание пустого словаря 1891 | Создать пустой словарь можно двумя способами: 1892 | - с помощью пустых фигурных скобок 1893 | - с помощью функции `dict()` 1894 | 1895 | ## Важные детали 1896 | - Ключи должны быть уникальными 1897 | - Ключи должны быть неизменяемым типом данных 1898 | - Значения могут относиться к любому типу данных, их тип данных произволен 1899 | - Обращение по индексу и срезы недоступны для словарей 1900 | - Операция конкатенации + и умножения на число * недоступны для словарей 1901 | 1902 | 1903 | ## Основы (len, sum, min, max, in) 1904 | - Длиной словаря называется количество его элементов. Для определения длины словаря используют встроенную функцию `len()`. 1905 | ```python 1906 | fruits = {'Apple': 70, 'Grape': 100, 'Banana': 80} 1907 | print(len(fruits)) 1908 | >>> 3 1909 | ``` 1910 | - Встроенная функция `sum() `принимает в качестве аргумента словарь с числовыми ключами и вычисляет сумму его ключей. 1911 | ```python 1912 | my_dict = {10: 'Россия', 20: 'США', 30: 'Франция'} 1913 | print('Сумма всех ключей словаря =', sum(my_dict)) 1914 | >>> Сумма всех ключей словаря = 60 1915 | ``` 1916 | - Встроенные функции `min() `и `max() `принимают в качестве аргумента словарь и находят минимальный и максимальный ключ соответственно, при этом ключ может принадлежать к любому типу данных, для которого возможны операции порядка <, <=, >, >= (числа, строки, и т.д.). 1917 | ```python 1918 | capitals = {'Россия': 'Москва', 'Франция': 'Париж', 'Чехия': 'Прага'} 1919 | months = {1: 'Январь', 2: 'Февраль', 3: 'Март'} 1920 | print('Минимальный ключ =', min(capitals)) 1921 | print('Максимальный ключ =', max(months)) 1922 | >>> Минимальный ключ = Россия 1923 | >>> Максимальный ключ = 3 1924 | ``` 1925 | - Оператор `in` позволяет проверить, содержит ли словарь заданный ключ. 1926 | ```python 1927 | capitals = {'Россия': 'Москва', 'Франция': 'Париж', 'Чехия': 'Прага'} 1928 | if 'Франция' in capitals: 1929 | print('Столица Франции - это', capitals['Франция']) 1930 | >>> Столица Франции - это Париж 1931 | 1932 | ``` 1933 | ## Сравнение словарей 1934 | Словари можно сравнивать между собой. Равные словари имеют одинаковое количество элементов и содержат равные элементы (ключ: значение). Для сравнения словарей используются операторы == и !=. 1935 | 1936 | ## Перебор элементов словаря 1937 | Вывод ключей словаря: 1938 | ```python 1939 | capitals = {'Россия': 'Москва', 'Франция': 'Париж', 'Чехия': 'Прага'} 1940 | for key in capitals: 1941 | print(key) 1942 | >>> Россия 1943 | >>> Франция 1944 | >>> Чехия 1945 | ``` 1946 | Вывод значений словаря: 1947 | ```python 1948 | capitals = {'Россия': 'Москва', 'Франция': 'Париж', 'Чехия': 'Прага'} 1949 | for key in capitals: 1950 | print(capitals[key]) 1951 | >>> Москва 1952 | >>> Париж 1953 | >>> Прага 1954 | 1955 | ``` 1956 | ## Распаковка словарей 1957 | При распаковке словарей возвращаются только ключи: 1958 | ```python 1959 | capitals = {'Россия': 'Москва', 'Франция': 'Париж', 'Чехия': 'Прага'} 1960 | print(*capitals, sep='\n') 1961 | >>> Россия 1962 | >>> Франция 1963 | >>> Чехия 1964 | 1965 | ``` 1966 | ## Методы keys(), values(), items() 1967 | Словарный метод `keys()` возвращает список ключей всех элементов словаря. 1968 | ```python 1969 | capitals = {'Россия': 'Москва', 'Франция': 'Париж', 'Чехия': 'Прага'} 1970 | for key in capitals.keys(): # итерируем по списку ['Россия', 'Франция', 'Чехия'] 1971 | print(key) 1972 | >>> Россия 1973 | >>> Франция 1974 | >>> Чехия 1975 | 1976 | ``` 1977 | Словарный метод `values() `возвращает список значений всех элементов словаря. 1978 | ```python 1979 | capitals = {'Россия': 'Москва', 'Франция': 'Париж', 'Чехия': 'Прага'} 1980 | for value in capitals.values(): # итерируем по списку ['Москва', 'Париж', 'Прага'] 1981 | print(value) 1982 | >>> Москва 1983 | >>> Париж 1984 | >>> Прага 1985 | 1986 | ``` 1987 | Словарный метод `items() `возвращает список всех элементов словаря, состоящий из кортежей пар (ключ, значение). 1988 | ```python 1989 | capitals = {'Россия': 'Москва', 'Франция': 'Париж', 'Чехия': 'Прага'} 1990 | for item in capitals.items(): 1991 | print(item) 1992 | >>> ('Россия', 'Москва') 1993 | >>> ('Франция', 'Париж') 1994 | >>> ('Чехия', 'Прага') 1995 | ``` 1996 | Можно писать такой код: 1997 | ```python 1998 | capitals = {'Россия': 'Москва', 'Франция': 'Париж', 'Чехия': 'Прага'} 1999 | for key, value in capitals.items(): 2000 | print(key, '-', value) 2001 | >>> Россия - Москва 2002 | >>> Франция - Париж 2003 | >>> Чехия – Прага 2004 | 2005 | ``` 2006 | ## Сортировка словарей 2007 | Сортировка по ключам выполняется с использованием функции `sorted()`. 2008 | Важно: словари не содержат метода `sort()`. 2009 | ```python 2010 | capitals = {'Россия': 'Москва', 'Англия': 'Лондон', 'Чехия': 'Прага', 'Бразилия': 'Бразилиа'} 2011 | for key in sorted(capitals): 2012 | print(key) 2013 | >>> Англия 2014 | >>> Бразилия 2015 | >>> Россия 2016 | >>> Чехия 2017 | 2018 | ``` 2019 | ## Методы словарей 2020 | - Добавление и изменение элементов в словаре 2021 | Чтобы изменить значение по определенному ключу в словаре, достаточно использовать индексацию вместе с оператором присваивания. При этом если ключ уже присутствует в словаре, его значение заменяется новым, если же ключ отсутствует – то в словарь будет добавлен новый элемент. 2022 | ```python 2023 | info = {"name": "Sam", "age": 28, "job": "Teacher"} 2024 | info["name"] = "Timur" # изменяем значение по ключу name 2025 | info["email"] = "timyr-guev@yandex.ru" # добавляем в словарь элемент с ключом email 2026 | print(info) 2027 | >>> {'name': 'Timur', 'age': 28, 'job': 'Teacher', 'email': 'timyr-guev@yandex.ru'} 2028 | ``` 2029 | - Метод `get()` 2030 | Для того чтобы избежать возникновения ошибки в случае отсутствия ключа в словаре, можно использовать метод `get(),` способный кроме ключа принимать и второй аргумент — значение, которое вернется, если заданного ключа нет. Когда второй аргумент не указан, то метод в случае отсутствия ключа возвращает `None.` 2031 | ```python 2032 | info = {"name": "Bob", "age": 25, "job": "Dev"} 2033 | item1 = info.get("salary") 2034 | item2 = info.get("salary", "Информации о зарплате нет") 2035 | print(item1) 2036 | print(item2) 2037 | >>> None 2038 | >>> Информации о зарплате нет 2039 | ``` 2040 | - Метод `update()` 2041 | Метод `update()` реализует своеобразную операцию конкатенации для словарей. Он объединяет ключи и значения одного словаря с ключами и значениями другого. При совпадении ключей в итоге сохранится значение словаря, указанного в качестве аргумента метода `update()`. 2042 | ```python 2043 | info1 = {"name": "Bob", "age": 25, "job": "Dev"} 2044 | info2 = {"age": 30, "city": "New York", "email": "bob@web.com"} 2045 | info1.update(info2) 2046 | print(info1) 2047 | >>> {'name': 'Bob', 'age': 30, 'job': 'Dev', 'city': 'New York', 'email': 'bob@web.com'} 2048 | ``` 2049 | В Python 3.9 появились операторы | и |=, которые реализуют операцию конкатенации словарей. 2050 | ```python 2051 | info1 = {"name": "Bob", "age": 25, "job": "Dev"} 2052 | info2 = {"age": 30, "city": "New York", "email": "bob@web.com"} 2053 | info1 |= info2 2054 | print(info1) 2055 | >>> {'name': 'Bob', 'age': 30, 'job': 'Dev', 'city': 'New York', 'email': 'bob@web.com'} 2056 | ``` 2057 | - Метод `setdefault()` 2058 | Метод `setdefault()` позволяет получить значение из словаря по заданному ключу, автоматически добавляя элемент словаря, если он отсутствует. 2059 | ```python 2060 | info = {"name": "Bob", "age": 25, "job": "Dev"} 2061 | print(info.setdefault("name", "Tim")) 2062 | >>> Bob 2063 | 2064 | info = {"age": 25, "job": "Dev"} 2065 | print(info.setdefault("name", "Tim")) 2066 | >>> Tim 2067 | ``` 2068 | - Оператор `del` 2069 | ```python 2070 | info = {"name": "Sam", "age": 28, "job": "Teacher", "email": "timyr-guev@yandex.ru"} 2071 | del info["email"] # удаляем элемент имеющий ключ email 2072 | del info["job"] # удаляем элемент имеющий ключ job 2073 | print(info) 2074 | >>> {'name': 'Sam', 'age': 28} 2075 | ``` 2076 | - Метод `pop()` 2077 | ```python 2078 | info = {"name": "Sam", "age": 28, "job": "Teacher", "email": "timyr-guev@yandex.ru"} 2079 | email = info.pop('email') # удаляем элемент по ключу email, возвращая его значение 2080 | job = info.pop('job') # удаляем элемент по ключу job, возвращая его значение 2081 | print(email) 2082 | print(job) 2083 | print(info) 2084 | >>> timyr-guev@yandex.ru 2085 | >>> Teacher 2086 | >>> {'name': 'Sam', 'age': 28} 2087 | ``` 2088 | Также можно указать второй аргумент, он будет возвращен, если указанного ключа в словаре нет. Это позволяет реализовать безопасное удаление элемента из словаря: 2089 | ```python 2090 | surname = info.pop('surname', None) 2091 | ``` 2092 | - Метод `popitem() `удаляет из словаря последний добавленный элемент и возвращает удаляемый элемент в виде кортежа (ключ, значение). 2093 | ```python 2094 | info = {"name": "Bob", "age": 25, "job": "Dev"} 2095 | info["surname"] = "Sinclar" 2096 | item = info.popitem() 2097 | print(item) 2098 | print(info) 2099 | >>> ('surname', 'Sinclar') 2100 | >>> {'name': 'Bob', 'age': 25, 'job': 'Dev'} 2101 | ``` 2102 | - Метод `clear()` удаляет все элементы из словаря. 2103 | - Метод `copy() `создает поверхностную копию словаря. 2104 | 2105 | ## Генераторы словарей 2106 | Генераторы словарей имеют такой же синтаксис как и в генераторах списков. 2107 | ```python 2108 | squares = {i: i**2 for i in range(6)} # квадраты чисел от 0 до 5 2109 | print(squares) 2110 | >>> {0: 0, 1: 1, 2: 4, 3: 9, 4: 16, 5: 25} 2111 | ``` 2112 | В генераторах словарей можно использовать условия: 2113 | ```python 2114 | squares = {i: i**2 for i in range(10) if i % 2 == 0} 2115 | print(squares) 2116 | >>> {0: 0, 2: 4, 4: 16, 6: 36, 8: 64} 2117 | 2118 | ``` 2119 | ## Вложенные словари 2120 | Вложенный словарь создается как обычный, только каждое значение в нем – другой словарь. 2121 | Пример: 2122 | ```python 2123 | info = {'emp1': {'name': 'Timur', 'job': 'Teacher'}, 2124 | 'emp2': {'name': 'Ruslan', 'job': 'Developer'}, 2125 | 'emp3': {'name': 'Rustam', 'job': 'Tester'}} 2126 | ``` 2127 | Или так: 2128 | ```python 2129 | info = dict(emp1 = {'name': 'Timur', 'job': 'Teacher'}, 2130 | emp2 = {'name': 'Ruslan', 'job': 'Developer'}, 2131 | emp3 = {'name': 'Rustam', 'job': 'Tester'}) 2132 | 2133 | ``` 2134 | Для обращения по индексу используют такой код: 2135 | ```python 2136 | info = {'emp1': {'name': 'Timur', 'job': 'Teacher'}, 2137 | 'emp2': {'name': 'Ruslan', 'job': 'Developer'}, 2138 | 'emp3': {'name': 'Rustam', 'job': 'Tester'}} 2139 | 2140 | print(info['emp1']['name']) 2141 | print(info['emp2']['job']) 2142 | >>> Timur 2143 | >>> Developer 2144 | 2145 | ``` 2146 | Изменение вложенных словарей: 2147 | ```python 2148 | info = {'emp1': {'name': 'Timur', 'job': 'Teacher'}, 2149 | 'emp2': {'name': 'Ruslan', 'job': 'Developer'}, 2150 | 'emp3': {'name': 'Rustam', 'job': 'Tester'}} 2151 | 2152 | info['emp1']['job'] = 'Manager' 2153 | print(info['emp1']) 2154 | >>> {'name': 'Timur', 'job': 'Manager'} 2155 | 2156 | ``` 2157 | Итерация по вложенным словарям: 2158 | ```python 2159 | info = {'emp1': {'name': 'Timur', 'job': 'Teacher'}, 2160 | 'emp2': {'name': 'Ruslan', 'job': 'Developer'}, 2161 | 'emp3': {'name': 'Rustam', 'job': 'Tester'}} 2162 | 2163 | for emp in info: 2164 | print('Employee ID:', emp) 2165 | for key in info[emp]: 2166 | print(key + ':', info[emp][key]) 2167 | print() 2168 | >>> Employee ID: emp1 2169 | >>> name: Timur 2170 | >>> job: Teacher 2171 | 2172 | >>> Employee ID: emp2 2173 | >>> name: Ruslan 2174 | >>> job: Developer 2175 | 2176 | >>> Employee ID: emp3 2177 | >>> name: Rustam 2178 | >>> job: Tester 2179 | 2180 | ``` 2181 | # Модули random, string, Метод Монте-Карло, Bogosort 2182 | ## Модуль random 2183 | ```python 2184 | import random 2185 | 2186 | num = random.randint(0, 17) # случайное целое число от 0 до 17 (включительно) 2187 | print(num) 2188 | >>> 14 2189 | 2190 | num1 = random.randrange(0, 100, 10) # возвращает случайное число от m до n с шагом k. синтаксис идентичен range() (не включительно) 2191 | num2 = random.randrange(0, 100, 10) # возвращает случайное число от m до n с шагом k. синтаксис идентичен range() (не включительно) 2192 | num3 = random.randrange(0, 100, 10) # возвращает случайное число от m до n с шагом k. синтаксис идентичен range() (не включительно) 2193 | print(num1, num2, num3) 2194 | >>> 80 30 50 2195 | 2196 | num = random.random() # случайное число с плавающей точкой от 0.0 до 1.0, аргументы не указываются (не включительно) 2197 | print(num) 2198 | >>> 0.34980886772220243 2199 | 2200 | num = random.uniform(3.6, 9.2) # случайное число с плавающей точкой от 3.6 до 9.2, аргументы обязательны (включительно) 2201 | print(num) 2202 | >>> 6.574427819432531 2203 | ``` 2204 | Методы строк и списков: 2205 | ```python 2206 | import random 2207 | 2208 | numbers = [1, 2, 3, 4, 5, 6, 7, 8] 2209 | random.shuffle(numbers) # перемешивает список 2210 | print(numbers) 2211 | >>> [3, 6, 7, 1, 5, 8, 2, 4] 2212 | 2213 | print(random.choice('Ваня, привет')) # случайный символ из строки или случайный элемент из списка 2214 | >>> я 2215 | 2216 | numbers = [12, 89, 27, 46] 2217 | print(random.sample(numbers, 3)) # выводит 3 случайных элемента из списка numbers 2218 | >>> [46, 89, 27] 2219 | 2220 | ``` 2221 | В модуле random можно задать сид (англ. seed - семя). При одинаковых сидах одинаковый код рандома выдаст одинаковых результат. По умолчанию, начальным значением генератора является системное время (текущая дата и время). Пример: 2222 | ```python 2223 | import random 2224 | random.seed(17) # явно устанавливаем начальное значение для генератора случайных чисел 2225 | for _ in range(10): 2226 | print(random.randint(1, 100)) 2227 | >>> 67 2228 | >>> 54 2229 | >>> 39 2230 | >>> 47 2231 | >>> 38 2232 | >>> 23 2233 | >>> 99 2234 | >>> 91 2235 | >>> 91 2236 | >>> 70 2237 | ``` 2238 | Попробуйте этот код, он выведет тоже самое что и в примере. 2239 | 2240 | ## Модуль string 2241 | В модуле string есть удобные константы: 2242 | ```python 2243 | import string 2244 | 2245 | print(string.ascii_letters) 2246 | print(string.ascii_uppercase) 2247 | print(string.ascii_lowercase) 2248 | print(string.digits) 2249 | print(string.hexdigits) 2250 | print(string.octdigits) 2251 | print(string.punctuation) 2252 | print(string.printable) 2253 | >>> abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ 2254 | >>> ABCDEFGHIJKLMNOPQRSTUVWXYZ 2255 | >>> abcdefghijklmnopqrstuvwxyz 2256 | >>> 0123456789 2257 | >>> 0123456789abcdefABCDEF 2258 | >>> 01234567 2259 | >>> !"#$%&'()*+,-./:;<=>?@[\]^_`{|}~ 2260 | >>> 0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ!"#$%&'()*+,-./:;<=>?@[\]^_`{|}~ \t\n\r\x0b\x0c 2261 | 2262 | ``` 2263 | ## Метод Монте-Карло 2264 | При помощи метода Монте-Карло можно вычислить примерную площадь фигуры. 2265 | Фигура: 2266 | ![Image 17](images/image_17.png) 2267 | Формула: 2268 | ​−2 ≤ x ≤ 2 2269 | −2 ≤ y ≤ 2 2270 | x^3 + y^4 + 2 ≥ 0 2271 | 3x + y^2 ≤ 2​ 2272 | 2273 | Задача вычислить примерную площадь фигуры. 2274 | Решение: 2275 | ```python 2276 | from random import uniform 2277 | 2278 | n = 10**6 # количество испытаний 2279 | k = 0 # количество попавших точек 2280 | S = 16 # площадь квадрата, в который вписана фигура 2281 | 2282 | for _ in range(n): 2283 | x = uniform(-2, 2) # рандомное число от минимальной до максимальной возможной координаты 2284 | y = uniform(-2, 2) # рандомное число от минимальной до максимальной возможной координаты 2285 | if (x**3 + y**4 + 2 >= 0) and (3*x + y**2 <= 2): # если точка внутри фигуры 2286 | k += 1 # увеличиваем количество попавших точек 2287 | 2288 | print((k/n) * S) # (точек / метр) * площадь квадрата 2289 | 2290 | ``` 2291 | ## Bogosort 2292 | Болотная сортировка (Bogosort) — неэффективный алгоритм сортировки, используемый только в образовательных целях и противопоставляемый другим, более реалистичным алгоритмам. 2293 | Принцип работы алгоритма прост, как плесень. Перетряхиваем список случайным образом до тех пор пока он внезапно не отсортируется. Процесс может счастливо завершиться сразу, а может длиться до тепловой смерти Вселенной. Это уж как повезёт. 2294 | Реализация алгоритма: 2295 | 2296 | ```python 2297 | import random 2298 | 2299 | def is_sorted(nums): # отсортирован ли список? 2300 | for i in range(len(nums) - 1): 2301 | if nums[i] > nums[i + 1]: 2302 | return False 2303 | return True 2304 | 2305 | def bogosort(nums): # реализация алгоритма болотной сортировки 2306 | while not is_sorted(nums): 2307 | random.shuffle(nums) 2308 | return nums 2309 | 2310 | numbers = list(range(10)) 2311 | random.shuffle(numbers) # перемешиваем начальный список 2312 | print(numbers) # выводим начальный список 2313 | 2314 | sorted_numbers = bogosort(numbers) 2315 | 2316 | print(sorted_numbers) 2317 | 2318 | ``` 2319 | # Модули decimal, fractions и complex 2320 | ## Модуль decimal: введение 2321 | Тип данных float не стоит использовать в случаях, когда важна точность: 2322 | ```python 2323 | num = 0.1 + 0.1 + 0.1 2324 | 2325 | if num == 0.3: 2326 | print('YES') 2327 | else: 2328 | print('NO') 2329 | print(num) 2330 | >>> NO 2331 | >>> 0.30000000000000004 2332 | ``` 2333 | Для точных расчетов рекомендуется использовать модуль decimal и тип данных Decimal. 2334 | Тип данных Decimal неизменяемый, также он в разы медленнее float. 2335 | 2336 | ## Создание Decimal чисел 2337 | Создать Decimal число можно из строки (str) или из числа с плавающей точкой (float): 2338 | ```python 2339 | from decimal import * 2340 | 2341 | d1 = Decimal(1) 2342 | d2 = Decimal(567) 2343 | d3 = Decimal(-93) 2344 | d4 = Decimal('12345') 2345 | d5 = Decimal('52.198') 2346 | 2347 | print(d1, d2, d3, d4, d5, sep='\n') 2348 | >>> 1 2349 | >>> 567 2350 | >>> -93 2351 | >>> 12345 2352 | >>> 52.198 2353 | ``` 2354 | Не стоит создавать Decimal из float, в Decimal попадает уже “неправильное” число 2355 | ```python 2356 | from decimal import * 2357 | 2358 | num = Decimal(0.1) 2359 | print(num) 2360 | >>> 0.1000000000000000055511151231257827021181583404541015625 2361 | 2362 | ``` 2363 | ## Арифметические операции над Decimal числами 2364 | Тип данных Decimal отлично интегрирован в язык Python. С Decimal числами работают все привычные операции: сложение, вычитание, умножение, деление, возведение в степень. 2365 | ```python 2366 | from decimal import * 2367 | 2368 | num1 = Decimal('5.8') 2369 | num2 = Decimal('2.5') 2370 | 2371 | print(num1 + num2) 2372 | print(num1 - num2) 2373 | print(num1 * num2) 2374 | print(num1 / num2) 2375 | print(num1 // num2) 2376 | print(num1 ** num2) 2377 | >>> 8.3 2378 | >>> 3.3 2379 | >>> 14.50 2380 | >>> 2.32 2381 | >>> 2 2382 | >>> 81.01584832611456399030280565 2383 | 2384 | ``` 2385 | Можно совершать арифметические операции над Decimal и целыми числами (миксовать Decimal и int), но не рекомендуется смешивать их с float. 2386 | 2387 | ## Математические функции Decimal чисел 2388 | Decimal числа можно передавать как аргументы функциям, ожидающим float. Они будут преобразованы во float. К примеру, модуль math, оперирующий float числами, может работать и с Decimal числами. 2389 | ```python 2390 | from decimal import * 2391 | from math import * 2392 | 2393 | num1 = Decimal('1.44') 2394 | num2 = Decimal('0.523') 2395 | 2396 | print(sqrt(num1)) 2397 | print(sin(num2)) 2398 | print(log(num1 + num2)) 2399 | >>> 1.2 2400 | >>> 0.4994813555186418 2401 | >>> 0.6744739152943241 2402 | ``` 2403 | Важно понимать, что результатом работы функции модуля math являются float числа, а не Decimal. 2404 | У модуля decimal есть встроенные математические методы, которые возвращают число с типом данных Decimal: 2405 | 2406 | 2407 | | Функция | Описание | 2408 | |---|---| 2409 | | sqrt() | вычисляет квадратный корень из Decimal числа | 2410 | | exp() | возвращает e^x для Decimal числа | 2411 | | ln() | вычисляет натуральный логарифм (по основанию e) Decimal числа | 2412 | | log10() | вычисляет десятичный логарифм (по основанию 10) Decimal числа | 2413 | 2414 | 2415 | 2416 | ```python 2417 | from decimal import * 2418 | 2419 | num = Decimal('10.0') 2420 | 2421 | print(num.sqrt()) 2422 | print(num.exp()) 2423 | print(num.ln()) 2424 | print(num.log10()) 2425 | >>> 3.162277660168379331998893544 2426 | >>> 22026.46579480671651695790065 2427 | >>> 2.302585092994045684017991455 2428 | >>> 1 2429 | 2430 | ``` 2431 | Тип данных Decimal также содержит полезный метод `as_tuple()` который возвращает кортеж из 3 элементов: 2432 | - sign – знак числа (0 для положительного числа и 1 для отрицательного числа) 2433 | - digits – цифры числа 2434 | - exponent – значение экспоненты (количество цифр после точки, умноженное на -1) 2435 | 2436 | ```python 2437 | from decimal import * 2438 | 2439 | num1 = Decimal('-1.4568769017') 2440 | num2 = Decimal('0.523') 2441 | 2442 | print(num1.as_tuple()) 2443 | print(num2.as_tuple()) 2444 | >>> DecimalTuple(sign=1, digits=(1, 4, 5, 6, 8, 7, 6, 9, 0, 1, 7), exponent=-10) 2445 | >>> DecimalTuple(sign=0, digits=(5, 2, 3), exponent=-3) 2446 | 2447 | ``` 2448 | Удобно использовать следующий код: 2449 | ```python 2450 | from decimal import * 2451 | 2452 | num = Decimal('-1.4568769017') 2453 | num_tuple = num.as_tuple() 2454 | 2455 | print(num_tuple.sign) 2456 | print(num_tuple.digits) 2457 | print(num_tuple.exponent) 2458 | >>> 1 2459 | >>> (1, 4, 5, 6, 8, 7, 6, 9, 0, 1, 7) 2460 | >>> -10 2461 | 2462 | ``` 2463 | ## Работа с контекстом Decimal чисел 2464 | Базовые параметры Decimal можно посмотреть в его контексте, выполнив функцию `getcontext():` 2465 | ```python 2466 | from decimal import * 2467 | print(getcontext()) 2468 | >>> Context(prec=28, rounding=ROUND_HALF_EVEN, Emin=-999999, Emax=999999, capitals=1, clamp=0, 2469 | flags=[], traps=[InvalidOperation, DivisionByZero, Overflow]) 2470 | ``` 2471 | Мы видим здесь, что точность 28 знаков, округление к ближайшему четному, пределы по экспоненте ± 999999, capitals – это про заглавную Е при печати, включенные ловушки – неправильная операция, деление на ноль, переполнение. 2472 | 2473 | ## Точность Decimal чисел 2474 | Контекстом в Decimal можно управлять, устанавливая свои значения. Например, чтобы управлять точностью Decimal, необходимо изменить параметр контекста prec (от англ. precision – точность). 2475 | ```python 2476 | from decimal import * 2477 | 2478 | getcontext().prec = 3 # устанавливаем точность в 3 знака 2479 | num = Decimal('3.1415') 2480 | 2481 | print(num) 2482 | print(num * 1) 2483 | print(num * 2) 2484 | print(num / 2) 2485 | >>> 3.1415 2486 | >>> 3.14 2487 | >>> 6.28 2488 | >>> 1.57 2489 | ``` 2490 | Обратите внимание на то, что точность вступает в силу только во время арифметических операций, а не при создании самих чисел. 2491 | 2492 | ## Округление Decimal чисел 2493 | Округляют числа Decimal с помощью метода `quantize()`. Этот метод в качестве первого аргумента принимает объект Decimal, указывающий на формат округления. 2494 | ```python 2495 | from decimal import * 2496 | 2497 | getcontext().prec = 4 # устанавливаем точность числа 2498 | num = Decimal('3.1415926535') 2499 | 2500 | print(num.quantize(Decimal('1.000'))) # округление до 3 цифр в дробной части 2501 | print(num.quantize(Decimal('1.00'))) # округление до 2 цифр в дробной части 2502 | print(num.quantize(Decimal('1.0'))) # округление до 1 цифр в дробной части 2503 | >>> 3.142 2504 | >>> 3.14 2505 | >>> 3.1 2506 | 2507 | ``` 2508 | Если точность округления установлена в 2, а формат округления `Decimal('1.00')`, то возникнет ошибка: 2509 | ```python 2510 | from decimal import * 2511 | 2512 | getcontext().prec = 2 # устанавливаем точность округления 2513 | num = Decimal('3.1415926535') 2514 | 2515 | print(num.quantize(Decimal('1.00'))) # округление до 2 цифр в дробной части 2516 | >>> decimal.InvalidOperation: [] 2517 | 2518 | ``` 2519 | Помимо первого параметра, метод `quantize()` принимает в качестве второго параметра стратегию округления: 2520 | - ROUND_CEILING – округление в направлении бесконечности (Infinity) 2521 | - ROUND_FLOOR – округляет в направлении минус бесконечности (- Infinity) 2522 | - ROUND_DOWN – округление в направлении нуля 2523 | - ROUND_HALF_EVEN – округление до ближайшего четного числа, число 6.5 округлится не до 7, а до 6 2524 | - ROUND_HALF_DOWN – округление до ближайшего нуля 2525 | - ROUND_UP – округление от нуля 2526 | - ROUND_05UP – округление от нуля (если последняя цифра после округления до нуля была бы 00 или 55, в противном случае – к нулю). 2527 | 2528 | ```python 2529 | from decimal import * 2530 | 2531 | num = Decimal('3.456') 2532 | 2533 | print(num.quantize(Decimal('1.00'), ROUND_CEILING)) 2534 | print(num.quantize(Decimal('1.00'), ROUND_FLOOR)) 2535 | >>> 3.46 2536 | >>> 3.45 2537 | 2538 | ``` 2539 | ## Сравнение float и Decimal чисел 2540 | 2541 | 2542 | | Характеристика / тип | float | Decimal | 2543 | |---|---|---| 2544 | | Реализация | аппаратная | программная | 2545 | | Размер | 64 бит | не ограничен | 2546 | | Основание экспоненты | 2 | 10 | 2547 | | Скорость | + | - | 2548 | | Настраиваемость | - | + | 2549 | | Для финансов и бизнеса | - | + | 2550 | | Для симуляций, визуализаций и игр | + | - | 2551 | | Для высокоточных вычислений | - | + | 2552 | 2553 | 2554 | 2555 | ## Важные примечания для decimal 2556 | - Decimal числа можно сравнивать между собой, как обычные числа, причем в отличие от float чисел допускается и точное равенство. 2557 | ```python 2558 | from decimal import * 2559 | 2560 | num = Decimal("0.1") 2561 | if num * 3 == Decimal("0.3"): 2562 | print("YES") 2563 | else: 2564 | print("NO") 2565 | >>> YES 2566 | 2567 | ``` 2568 | - Можно сортировать списки с Decimal числами и искать минимум и максимум среди них. 2569 | ```python 2570 | from decimal import * 2571 | 2572 | s = '1.34 3.45 1.00 0.03 9.25' 2573 | 2574 | numbers = [Decimal(i) for i in s.split()] 2575 | 2576 | maximum = max(numbers) 2577 | minimum = min(numbers) 2578 | 2579 | numbers.sort() 2580 | 2581 | print(maximum) 2582 | print(minimum) 2583 | print(numbers) 2584 | >>> 9.25 2585 | >>> 0.03 2586 | >>> [Decimal('0.03'), Decimal('1.00'), Decimal('1.34'), Decimal('3.45'), Decimal('9.25')] 2587 | 2588 | ``` 2589 | - Чтобы не писать каждый раз название типа, можно использовать приведенный ниже код: 2590 | ```python 2591 | from decimal import Decimal as D 2592 | 2593 | num1 = D("1.5") + D("3.2") 2594 | num2 = D("1.4") * D("2.5") 2595 | 2596 | print(num1) 2597 | print(num2) 2598 | >>> 4.7 2599 | >>> 3.50 2600 | ``` 2601 | ## Модуль fractions: введение 2602 | Рациональное число – это число, которое можно представить в виде дроби ​m/n, где m, n соответственно, числитель и знаменатель, которые имеют целочисленное значение, при этом знаменатель не равен нулю. 2603 | Например, в дроби 5/6​ числитель m=5, а знаменатель n=6. 2604 | Знаменатель дроби показывает количество равных частей, а числитель дроби показывает, сколько из них взято. 2605 | ![Image 18](images/image_18.png) 2606 | 2607 | ## Тип данных Fraction 2608 | Для работы с рациональными числами в Python используется тип данных Fraction. Тип данных Fraction как и Decimal реализован программно, поэтому он в разы медленнее встроенных числовых типов данных int и float. Тип данных Fraction неизменяемый. Операции над данными этого типа приводят к созданию новых объектов, при этом старые не меняются. 2609 | Чтобы использовать возможности типа данных Fraction, нужно предварительно подключить модуль fractions: 2610 | ```python 2611 | from fractions import Fraction 2612 | 2613 | ``` 2614 | ## Создание Fraction чисел 2615 | Создать Fraction число можно несколькими способами: 2616 | - из целых чисел, передав значения числителя и знаменателя дроби 2617 | - из строки на основании десятичного представления 2618 | - из строки на основании обыкновенной дроби 2619 | - из числа с плавающей точкой (не рекомендуется) 2620 | 2621 | ```python 2622 | from fractions import Fraction 2623 | 2624 | num1 = Fraction(7, 32) # 7 - числитель, 32 - знаменатель 2625 | num2 = Fraction('0.67') 2626 | num3 = Fraction('1/45') 2627 | 2628 | print(num1, num2, num3, sep='\n') 2629 | >>> 7/32 2630 | >>> 67/100 2631 | >>> 1/45 2632 | 2633 | ``` 2634 | Не стоит создавать Fraction из float: 2635 | ```python 2636 | from fractions import Fraction 2637 | 2638 | num = Fraction(0.34) 2639 | 2640 | print(num) # Вместо 17/50 код выведет: 2641 | >>> 6124895493223875/18014398509481984 2642 | 2643 | ``` 2644 | ## Основы типа данных Fraction 2645 | Обратите внимание на то, что при создании рационального числа Fraction, автоматически происходит сокращение числителя и знаменателя дроби: 2646 | ```python 2647 | from fractions import Fraction 2648 | 2649 | num = Fraction(4, 8) 2650 | 2651 | print(num) 2652 | >>> 1/2 2653 | 2654 | ``` 2655 | Вывод дробей, являющихся целыми числами: 2656 | ```python 2657 | from fractions import Fraction 2658 | 2659 | num = Fraction(5, 1) 2660 | 2661 | print(num) 2662 | >>> 5 2663 | 2664 | ``` 2665 | Для того чтобы каждый раз не писать название типа, можно использовать следующий код: 2666 | ```python 2667 | from fractions import Fraction as F 2668 | 2669 | num1 = F('1/5') + F('3/2') 2670 | num2 = F('1/4') * F('2/5') 2671 | 2672 | print(num1) 2673 | print(num2) 2674 | 2675 | ``` 2676 | ## Сравнение Fraction чисел 2677 | Fraction числа можно сравнивать между собой точно так же, как и любые другие числа. Доступны 6 основных операторов сравнения: 2678 | ``` 2679 | - >: больше 2680 | - <: меньше 2681 | - >=: больше либо равно 2682 | - <=: меньше либо равно 2683 | - ==: в точности равно 2684 | - !=: не равно 2685 | ``` 2686 | Обратите внимание на то, что мы можем сравнивать Fraction числа и целые числа (числа с плавающей точкой) без явного приведения типов. 2687 | 2688 | ## Арифметические операции над Fraction числами 2689 | Тип данных Fraction отлично интегрирован в язык Python. С Fraction числами работают все привычные операции: сложение, вычитание, умножение, деление, возведение в степень. 2690 | Мы также можем совершать арифметические операции над Fraction и целыми числами (миксовать Fraction и int), но не рекомендуется смешивать их с float. 2691 | Обратите внимание на то, что операция возведения в степень (**) для Fraction чисел может возвращать вещественный результат: 2692 | ```python 2693 | from fractions import Fraction 2694 | 2695 | num1 = Fraction('3/8') 2696 | num2 = Fraction('1/2') 2697 | 2698 | print(num1 ** num2) 2699 | >>> 0.6123724356957945 2700 | 2701 | ``` 2702 | ## Математические функции 2703 | Fraction числа можно передавать как аргументы функций, ожидающих float. Тогда они будут преобразованы во float. К примеру, модуль math, оперирующий float числами, может работать и с Fraction числами. 2704 | ```python 2705 | from fractions import Fraction 2706 | from math import * 2707 | 2708 | num1 = Fraction('1.44') 2709 | num2 = Fraction('0.523') 2710 | 2711 | print(sqrt(num1)) 2712 | print(sin(num2)) 2713 | print(log(num1 + num2)) 2714 | >>> 1.2 2715 | >>> 0.4994813555186418 2716 | >>> 0.6744739152943241 2717 | 2718 | ``` 2719 | ## Свойства numerator и denominator, as_integer_ratio() 2720 | ```python 2721 | from fractions import Fraction 2722 | 2723 | num = Fraction('5/16') 2724 | 2725 | print('Числитель дроби равен:', num.numerator) 2726 | print('Знаменатель дроби равен:', num.denominator) 2727 | >>> Числитель дроби равен: 5 2728 | >>> Знаменатель дроби равен: 16 2729 | 2730 | ``` 2731 | Метод `as_integer_ratio() `возвращает кортеж, состоящий из числителя и знаменателя данного Fraction числа: 2732 | ```python 2733 | from fractions import Fraction 2734 | 2735 | num = Fraction('-5/16') 2736 | 2737 | print(num.as_integer_ratio()) 2738 | >>> (-5, 16) 2739 | 2740 | ``` 2741 | ## Метод limit_denominator() 2742 | Метод `limit_denominator() `возвращает самую близкую к данному числу рациональную дробь, чей знаменатель не превосходит переданного аргумента: 2743 | ```python 2744 | from fractions import Fraction 2745 | 2746 | num = (Fraction("0.83485")) 2747 | 2748 | for d in [1, 5, 50, 90, 100, 500, 1000000]: 2749 | limited = num.limit_denominator(d) 2750 | print(limited) 2751 | >>> 1 2752 | >>> 4/5 2753 | >>> 5/6 2754 | >>> 71/85 2755 | >>> 81/97 2756 | >>> 369/442 2757 | >>> 16697/20000 2758 | 2759 | ``` 2760 | ## Комплексные числа: введение 2761 | ``` 2762 | Рассмотрим квадрат произвольного вещественного числа: 2763 | - 2*2=4 2764 | - (−2)*(−2)=4 2765 | - 0*0=0 2766 | - 0.1*0.1=0.01 2767 | Результат всегда неотрицательное число. Действительно, пусть a – произвольное вещественное число. Тогда a*a=a^2≥0. Таким образом, на множестве вещественных чисел, перемножая два одинаковых числа мы всегда получаем неотрицательное число (большее, либо равное нулю). 2768 | 2769 | Представим, что существует число i (не являющееся вещественным), такое, что i*i=i^2=−1. Будет ли такое обозначение полезным? Оказывается, да! Такие числа в математике называются мнимыми и обозначают их буквой i, от слова imaginary (мнимый, воображаемый). Итак, получаем: 2770 | i^2=-1, отсюда i = √(-1) 2771 | 2772 | Мнимая единица i обладает интересным свойством: каждый раз при умножении на i она "циклически" проходит через 4 различных значения: 2773 | 1*i=i 2774 | i*i=-1 2775 | -1*i=-1 2776 | -i*i=1 2777 | ``` 2778 | 2779 | ## Комплексные числа в математике 2780 | Комплексное число – комбинация вещественного и мнимого числа. Таким образом, число вида a+bi, где a, b – вещественные числа, называется комплексным числом. 2781 | 2782 | Модулем комплексного числа z=a+bi называется вещественное число, равное: 2783 | |z|=√(a^2+b^2) 2784 | 2785 | Число zˉ=a−bi называется сопряженным к числу z=a+bi. Произведение двух сопряженных чисел является вещественным числом. 2786 | 2787 | ## Комплексные числа в Python 2788 | Для работы с комплексными числами (тип complex) не нужно подключать какой-либо модуль в отличие от типов Decimal и Fraction. 2789 | В языке Python есть возможность работать с комплексными числами. Общая форма представления комплексного числа следующая: real + imag j, где: 2790 | - real – вещественная часть комплексного числа 2791 | - imag – мнимая часть комплексного числа, которая завершается символом j или J. 2792 | 2793 | ```python 2794 | z1 = 5 + 7j 2795 | z2 = 1j 2796 | z3 = -3 + 5J 2797 | z4 = 1.5 + 3.2j 2798 | 2799 | print(z1, z2, z3, z4, sep='\n') 2800 | print(type(z1)) 2801 | >>> (5+7j) 2802 | >>> 1j 2803 | >>> (-3+5j) 2804 | >>> (1.5+3.2j) 2805 | >>> 2806 | 2807 | ``` 2808 | ## Создание комплексных чисел 2809 | Комплексные числа можно создать с помощью литерала, как выше, а можно с помощью функции `complex()`, которая принимает два аргумента: вещественную и мнимую часть числа, либо строковое представление числа. 2810 | ```python 2811 | z1 = -3 + 2j # создание на основе литерала 2812 | z2 = complex(6, -8) # z2 = 6 - 8j 2813 | z3 = complex(0, 2.5) # z3 = 2.5j 2814 | z4 = complex(5, 0) # z4 = 5 + 0j 2815 | z5 = complex('3+4j') # создание на основе строки 2816 | 2817 | print(z1, z2, z3, z4, z5, sep='\n') 2818 | >>> (-3+2j) 2819 | >>> (6-8j) 2820 | >>> 2.5j 2821 | >>> (5+0j) 2822 | >>> (3+4j) 2823 | 2824 | ``` 2825 | ## Арифметические операции над комплексными числами 2826 | ```python 2827 | z1 = 1 + 3j 2828 | z2 = -3 + 2j 2829 | 2830 | print('z1 + z2 =', z1 + z2) 2831 | print('z1 - z2 =', z1 - z2) 2832 | print('z1 * z2 =', z1 * z2) 2833 | print('z1 / z2 =', z1 / z2) 2834 | print('z1^20 =', z1**20) 2835 | >>> z1 + z2 = (-2+5j) 2836 | >>> z1 - z2 = (4+1j) 2837 | >>> z1 * z2 = (-9-7j) 2838 | >>> z1 / z2 = (0.23076923076923078-0.8461538461538461j) 2839 | >>> z1^20 = (9884965888-1512431616j) 2840 | ``` 2841 | Мы также можем совершать арифметические операции над complex и целыми числами (миксовать complex, int, float). 2842 | 2843 | ## Методы и свойства комплексных чисел 2844 | ```python 2845 | z = 3+4j 2846 | 2847 | print('Действительная часть =', z.real) 2848 | print('Мнимая часть =', z.imag) 2849 | >>> Действительная часть = 3.0 2850 | >>> Мнимая часть = 4.0 2851 | 2852 | ``` 2853 | Для нахождения сопряженного комплексного числа можно использовать метод `conjugate()`: 2854 | ```python 2855 | z = 3+4j 2856 | print('Сопряженное число =', z.conjugate()) 2857 | >>> Сопряженное число = (3-4j) 2858 | 2859 | ``` 2860 | Для нахождения модуля комплексного числа используется встроенная функция `abs()`: 2861 | ```python 2862 | z = 3+4j 2863 | print('Модуль числа =', abs(z)) 2864 | >>> Модуль числа = 5.0 2865 | 2866 | ``` 2867 | ## cmath 2868 | Встроенный модуль math работает с вещественными числами. Для работы с комплексными числами есть модуль cmath. Модуль cmath включает дополнительные функции для использования комплексных чисел. 2869 | ```python 2870 | import cmath 2871 | 2872 | z = 2+3j 2873 | print(cmath.phase(z)) # полярный угол 2874 | print(cmath.polar(z)) # полярные координаты 2875 | >>> 0.982793723247329 2876 | >>> (3.605551275463989, 0.982793723247329) 2877 | ``` 2878 | Модуль cmath содержит следующие категории функций: 2879 | - Экспоненциальные и логарифмические функции 2880 | - Квадратные корни 2881 | - Тригонометрические функции и их обратные 2882 | - Гиперболические функции и их обратные 2883 | 2884 | # Модуль turtle 2885 | ## Введение в turtle 2886 | Подключение модуля: 2887 | ```python 2888 | import turtle 2889 | 2890 | ``` 2891 | В результате команды `turtle.showturtle()` появляется графическое окно с черепашкой. Черепашка первоначально расположена в центре графического окна, "холста". Выглядит она как стрелка с острием на месте головы. Если дать черепашке команду двигаться вперед, она переместится в направлении, указываемом стрелкой. По умолчанию на старте черепашка смотрит на восток. 2892 | 2893 | ## Рисование отрезков прямой 2894 | Для перемещения черепашки вперед на n пикселей применяется команда `turtle.forward(n)`. 2895 | Для перемещения черепашки назад на n пикселей применяется команда `turtle.backward(n)`. 2896 | 2897 | ## Поворот черепашки 2898 | Команда `turtle.right(angle) `поворачивает черепашку вправо на angle градусов. 2899 | Команда `turtle.left(angle)` поворачивает черепашку влево на angle градусов. 2900 | Команда `turtle.setheading(angle)` применяется для установки углового направления черепашки с заданным углом. В качестве аргумента нужно указать желаемый угол. 2901 | Чтобы получить текущее угловое направление черепашки используется команда `turtle.heading()`. 2902 | 2903 | ## Изменение внешнего вида черепашки 2904 | По умолчанию черепашка выглядит как стрелочка, но возможен и другой внешний вид. Для его изменения используют команду `turtle.shape(shape_name).` Команда принимает в качестве аргумента строковое название фигуры, определяющей форму черепашки. Доступные фигуры: 2905 | - square (квадрат) 2906 | - arrow (стрелка) 2907 | - circle (круг) 2908 | - turtle (черепашка) 2909 | - triangle (треугольник) 2910 | - classic (классическая стрелка) 2911 | 2912 | При необходимости можно использовать собственные рисунки для создания внешнего вида черепашки: 2913 | ```python 2914 | import turtle 2915 | 2916 | turtle.Screen().addshape('rocketship.gif') # регистрируем изображение 2917 | turtle.shape('rocketship.gif') # устанавливаем изображение 2918 | 2919 | 2920 | for _ in range(4): 2921 | turtle.forward(150) 2922 | turtle.left(90) 2923 | 2924 | ``` 2925 | ## Поднятие и опускание пера 2926 | Команда `turtle.penup() `поднимает перо, а команда `turtle.pendown()` - опускает. Когда перо поднято, черепашка перемещается не оставляя линии. Когда перо опущено, черепашка во время перемещения чертит линию. По умолчанию перо опущено. 2927 | 2928 | ## Рисование кругов и точек 2929 | Чтобы черепашка нарисовала круг, можно применить команду `turtle.circle(radius)`. Такая команда рисует круг заданного в виде аргумента в пикселях радиуса. 2930 | Команда `turtle.dot()` применяется, чтобы черепашка нарисовала точку. 2931 | ## Изменение размера пера 2932 | Для изменения ширины пера черепашки в пикселях можно применить команду `turtle.pensize(size)`. Аргумент команды – целое число, задает ширину пера. 2933 | 2934 | ## Изменение цвета рисунка 2935 | Для изменения цвета рисунка можно применить команду `turtle.pencolor(color)`. Аргумент команды – строковое представление названия цвета. 2936 | Пример: `turtle.pencolor('red')`. 2937 | Наиболее распространённые цвета: 2938 | - red (красный) 2939 | - green (зеленый) 2940 | - bluе (синий) 2941 | - yellow (желтый) 2942 | - cyan (сине-зелёный) 2943 | 2944 | Команда `turtle.pencolor(color)` позволяет работать не только с предопределенными названиями цветов, но и с цветами, заданными в формате RGB (Red Green Blue). В качестве аргумента команды `turtle.pencolor(r, g, b)` можно использовать либо кортеж из 3 чисел (r, g, b), либо просто три числа r, g, b. В Python 3 для того, чтобы использовать цвет в формате RGB, нужно предварительно установить значение colormode в 255, для этого нужно использовать команду `turtle.Screen().colormode(255).` 2945 | 2946 | ## Изменение цвета фона 2947 | Для изменения фонового цвета графического окна можно применить команду `turtle.Screen().bgcolor(color)`. В этом случае тоже можно использовать цвета с предопределенными названиями или задать цвет в RGB формате. 2948 | 2949 | Мы также можем установить фоновое изображение с помощью команды `turtle.Screen().bgpic('picture.png')`. 2950 | 2951 | ## Создание штампа 2952 | С помощью команды `turtle.stamp()` можно оставить штамп черепашки. Использование команды `turtle.stamp()` производит тот же эффект, что и команда `turtle.dot([radius])`, но оставляет отметку в форме черепашки. 2953 | 2954 | ## Возвращение экрана в исходное состояние 2955 | Команда `turtle.clear()` стирает все рисунки в графическом окне. Но не меняет положение черепашки, цвет рисунка и цвет фона графического окна. 2956 | Команда `turtle.reset()` стирает все рисунки, имеющиеся в графическом окне, задает черный цвет рисунка и возвращает черепашку в исходное положение в центре экрана. Эта команда не переустанавливает цвет фона графического окна. 2957 | Команда `turtle.clearscreen()` стирает все рисунки в графическом окне, меняет цвет рисунка на черный, а цвет фона на белый, и возвращает черепашку в исходное положение в центре графического окна. 2958 | 2959 | ## Размер окна 2960 | Для установления размера графического окна можно применить команду `turtle.Screen().setup(width, height)`. Аргументы команды – ширина и высота (в пикселях). 2961 | 2962 | ## Перемещение черепашки в заданную позицию 2963 | ![Image 19](images/image_19.png) 2964 | Для перемещения черепашки в конкретную позицию в графическом окне применяется команда `turtle.goto(x, y)`. Аргументами служат координаты целевой позиции. Если перо черепашки опущено вниз (по умолчанию оно опущено), то будет начерчена линия. 2965 | 2966 | Команды `turtle.setposition(x, y)` и `turtle.setpos(x, y)` аналогичны команде `turtle.goto(x, y)`. Все три команды перемещают черепашку в заданную позицию. 2967 | 2968 | ## Получение текущей позиции черепашки 2969 | Команда `turtle.pos()` возвращает кортеж с x и y координатами черепашки. Команда `turtle.position()` аналогична команде `turtle.pos()`. Обе эти команды возвращают кортеж с x и y координатами черепашки. 2970 | Для получения только координаты x черепашки служит команда `turtle.xcor()`, а для получения координаты y - команда `turtle.ycor()`. 2971 | 2972 | ## Сокрытие черепашки 2973 | Когда не нужно, чтобы черепашка отображалась на экране, применяется команда `turtle.hideturtle()`, которая ее прячет. Эта команда не изменяет процесс создания графического изображения, она просто скрывает значок черепашки. Когда требуется снова вывести черепашку на экран, применяется команда `turtle.showturtle()`. 2974 | 2975 | ## Управление скоростью анимации черепахи 2976 | Для изменения скорости движения черепашки можно применить команду `turtle.speed(speed)`. Аргумент команды скорость – число в диапазоне от 0 до 10. Если указать 0, то черепашка будет делать все свои перемещения мгновенно (анимация отключена). 2977 | 2978 | ## Вывод текста в графическое окно 2979 | Для вывода текста в графическое окно применяется команда `turtle.write(string)`. Аргумент этой команды — строка текста, которую требуется вывести на экран. Левый нижний угол первого символа выведенного текста будет расположен в точке с координатами черепашки. 2980 | 2981 | Аргументы команды `write(args)`: 2982 | - arg – текст, который нужно вывести 2983 | - move – указывает будет ли двигаться черепашка по мере рисования надписи (по умолчанию значение False) 2984 | - align – служит для выравнивания надписи относительно черепашки, может принимать три строковых значения right, center, left (по умолчанию значению right) 2985 | - font – кортеж из трех значений: (название шрифта, размер шрифта, тип начертания). В качестве начертания можно использовать строковые значения: normal — обычный, bold — полужирный, italic — курсив, или объединить два последних, тогда текст будет напечатан полужирным курсивом. 2986 | 2987 | Пример: 2988 | ```python 2989 | import turtle 2990 | turtle.write('Приветик)', move=True, align='left', font=('Times New Roman', 25, 'normal')) 2991 | ``` 2992 | Вывод: 2993 | ![Image 20](images/image_20.png) 2994 | 2995 | ## Заполнение геометрических фигур 2996 | Для заполнения геометрической фигуры цветом используется команда `turtle.begin_fill()`, причем она применяется до начертания фигуры, а после завершения начертания используется команда `turtle.end_fill()` и геометрическая фигура заполняется текущим цветом заливки. 2997 | 2998 | Пример: 2999 | ```python 3000 | import turtle 3001 | 3002 | turtle.hideturtle() 3003 | turtle.begin_fill() # включаем заливку 3004 | turtle.circle(80) 3005 | turtle.end_fill() # выключаем заливку 3006 | ``` 3007 | Вывод: 3008 | ![Image 21](images/image_21.png) 3009 | 3010 | Цвет заливки можно изменить при помощи команды `turtle.fillcolor(color / r, g, b)`. Аргумент команды — название цвета в виде строкового литерала, либо значения трех компонентов RGB. 3011 | 3012 | ## Создание нескольких черепашек 3013 | Можно работать сразу с несколькими черепашками. Для этого надо создать несколько переменных, содержащих экземпляры класса Turtle. 3014 | 3015 | Пример: 3016 | ```python 3017 | import turtle 3018 | from random import randrange 3019 | 3020 | def move_turtles(turtles, dist, angle): 3021 | for turtle in turtles: # все черепашки из списка делают одни и те же действия 3022 | turtle.forward(dist) 3023 | turtle.right(angle) 3024 | 3025 | 3026 | turtles = [] # список черепашек 3027 | head = 0 3028 | num_turtles = 10 # количество череашек 3029 | for i in range(num_turtles): 3030 | turt = turtle.Turtle() # создаем черепашку и устанавливаем ее свойства 3031 | turt.setheading(head) 3032 | turt.pensize(2) 3033 | turt.color(randrange(256), randrange(256), randrange(256)) 3034 | turt.speed(5) 3035 | turt.tracer(25, 0) 3036 | turtles.append(turt) # добавляем черепашку в список 3037 | head = head + 360/num_turtles 3038 | 3039 | for i in range(70): 3040 | move_turtles(turtles, 10, i) 3041 | 3042 | ``` 3043 | Вывод: 3044 | ![Image 22](images/image_22.png) 3045 | 3046 | Команда `turtle.tracer(n, delay)` включает/выключает анимацию черепашки и устанавливает задержку для обновления рисунков. Может использоваться для ускорения рисования сложной графики. 3047 | 3048 | ## Отслеживание нажатия клавиш 3049 | Черепашья графика позволяет отслеживать происходящие события, такие как нажатия клавиш клавиатуры, перемещение мышки или нажатие на мышку. Изначально программа никак не реагирует на эти события и чтобы это поведение изменить необходимо привязать функции обратного вызова к событиям. Для этого существуют специальные команды. Для отслеживания нажатия клавиш клавиатуры используется команда `turtle.Screen().onkey(fun, key)`, которая связывает функцию обратного вызова fun с событием нажатия клавиши key. 3050 | Для отслеживания событий также необходимо установить фокус на экран черепашки с помощью команды `turtle.Screen().listen()`. 3051 | Пример: 3052 | ```python 3053 | import turtle 3054 | 3055 | def move_up(): # функция обратного вызова 3056 | x, y = turtle.pos() 3057 | turtle.setposition(x, y + 5) 3058 | 3059 | def move_down(): # функция обратного вызова 3060 | x, y = turtle.pos() 3061 | turtle.setposition(x, y - 5) 3062 | 3063 | def move_left(): # функция обратного вызова 3064 | x, y = turtle.pos() 3065 | turtle.setposition(x - 5, y) 3066 | 3067 | def move_right(): # функция обратного вызова 3068 | x, y = turtle.pos() 3069 | turtle.setposition(x + 5, y) 3070 | 3071 | turtle.showturtle() # отображаем черепашку 3072 | turtle.pensize(3) # устанавливаем размер пера 3073 | turtle.shape('turtle') 3074 | turtle.Screen().listen() # устанавливаем фокус на экран черепашки 3075 | 3076 | turtle.Screen().onkey(move_up, 'Up') # регистрируем функцию на нажатие клавиши наверх 3077 | turtle.Screen().onkey(move_down, 'Down') # регистрируем функцию на нажатие клавиши вниз 3078 | turtle.Screen().onkey(move_left, 'Left') # регистрируем функцию на нажатие клавиши налево 3079 | turtle.Screen().onkey(move_right, 'Right') # регистрируем функцию на нажатие клавиши направо 3080 | 3081 | ``` 3082 | ## Отслеживание нажатия мыши 3083 | Аналогичным образом можно отслеживать нажатие на мышку. Для отслеживания нажатия мыши используется команда `turtle.Screen().onclick(fun)`, которая связывает функцию обратного вызова fun с событием нажатия левой кнопки мыши. 3084 | Пример: 3085 | ```python 3086 | import turtle 3087 | from random import randrange 3088 | 3089 | def random_color(): 3090 | return randrange(256), randrange(256), randrange(256) 3091 | 3092 | def draw_circle(x, y, r): 3093 | turtle.penup() 3094 | turtle.goto(x, y - r) 3095 | turtle.pendown() 3096 | color = random_color() 3097 | turtle.pencolor(color) 3098 | turtle.fillcolor(color) 3099 | turtle.begin_fill() 3100 | turtle.circle(r) 3101 | turtle.end_fill() 3102 | turtle.speed(0) 3103 | 3104 | def left_mouse_click(x, y): 3105 | draw_circle(x, y, 10) 3106 | 3107 | turtle.hideturtle() 3108 | 3109 | turtle.Screen().onclick(left_mouse_click) 3110 | turtle.Screen().listen() 3111 | 3112 | ``` 3113 | # Функции 3114 | ## Функции без параметров 3115 | Именование функций 3116 | Python и тут требует соблюдения тех же правил, что при именовании переменных: 3117 | - в имени функции используются только латинские буквы a-z, A-Z, цифры и символ нижнего подчеркивания (_) 3118 | - имя функции не может начинаться с цифры 3119 | - имя функции по возможности должно отражать ее назначение 3120 | - символы верхнего и нижнего регистра различаются. 3121 | Объявление функции: 3122 | ```python 3123 | def название_функции(): 3124 | блок кода 3125 | 3126 | pass # ничего не делает, используется как заглушка. 3127 | ``` 3128 | Вызов функции: 3129 | ```python 3130 | название_функции() 3131 | ``` 3132 | Объявление функции должно предшествовать ее вызову. 3133 | 3134 | ## Функции с параметрами 3135 | Объявление функции с параметрами: 3136 | ```python 3137 | def название_функции(параметры): 3138 | блок кода 3139 | ``` 3140 | При вызове функции мы обязаны использовать столько аргументов, сколько объявлено в функции. 3141 | Пример: 3142 | ```python 3143 | def draw(c): 3144 | for i in range(c): 3145 | print('*' * 10) 3146 | 3147 | draw(10) 3148 | >>> ********** 3149 | >>> ********** 3150 | >>> ********** 3151 | >>> ********** 3152 | >>> ********** 3153 | >>> ********** 3154 | >>> ********** 3155 | >>> ********** 3156 | >>> ********** 3157 | >>> ********** 3158 | 3159 | ``` 3160 | ## Глобальные и локальные переменные 3161 | Локальными называются переменные, объявленные внутри функции и доступные только ей самой. Программный код за пределами функции к ним доступа не имеет. 3162 | ```python 3163 | def print_paris(): 3164 | s = 'I love Paris' 3165 | print(s) 3166 | 3167 | def print_london(): 3168 | s = 'I love London' 3169 | print(s) 3170 | 3171 | s = 'I love Moscow' 3172 | print_paris() 3173 | print_london() 3174 | print(s) 3175 | >>> I love Paris 3176 | >>> I love London 3177 | >>> I love Moscow 3178 | 3179 | ``` 3180 | Глобальными называются переменные, объявленные в основной программе и доступные как программе, так и всем ее функциям. 3181 | Если нужно, чтобы инструкция внутри функции присваивала значение глобальной переменной, то требуется дополнительный шаг. В этом случае глобальная переменная должна быть объявлена внутри функции. Благодаря `global `можно изменять глобальную переменную в функции. 3182 | ```python 3183 | def print_texas(): 3184 | global birds 3185 | birds = 5000 3186 | print('В Техасе обитает', birds, 'птиц.') 3187 | 3188 | def print_california(): 3189 | print('В Калифорнии обитает', birds, 'птиц.') 3190 | 3191 | print_texas() 3192 | print_california() 3193 | >>> В Техасе обитает 5000 птиц. 3194 | >>> В Калифорнии обитает 5000 птиц. 3195 | ``` 3196 | В следующем коде мы работаем с глобальной переменной в функции: 3197 | ```python 3198 | x = 5 3199 | 3200 | def add(): 3201 | global x 3202 | x = 3 3203 | x = x + 5 3204 | print(x) 3205 | 3206 | add() 3207 | print(x) 3208 | ``` 3209 | Код выведет 8 8, так как мы использовали `global x`, а значит функция будет изменять глобальную переменную. 3210 | 3211 | ## Функции с возвратом значения 3212 | Некоторые команды в Python возвращают что-то, например, `len("Бургер") `вернёт 6. 3213 | Есть команды, которые ничего не возвращают, например, `del a[2] `просто удаляет элемент списка. 3214 | Для возврата значения используют `return значение `в конце тела функции. Все команды написанные после `return `в функции не будут выполнятся. 3215 | Пример: 3216 | ```python 3217 | def square(x): 3218 | return x**2 3219 | 3220 | print(square(2)) 3221 | >>> 4 3222 | ``` 3223 | Код выводит квадрат числа 2 3224 | 3225 | Также можно возвращать `True` или `False`. 3226 | Пример: 3227 | ```python 3228 | def divide(x): 3229 | if x % 2 == 0: 3230 | return True 3231 | 3232 | if divide(2): 3233 | print('Число делится на 2') 3234 | else: 3235 | print('Число не делится на 2') 3236 | 3237 | ``` 3238 | Также можно возвращать несколько значений: 3239 | ```python 3240 | def sqr(x, y): 3241 | return x**2, y**2 3242 | 3243 | print(sqr(2, 4)) 3244 | >>> (4, 16) 3245 | 3246 | ``` 3247 | ## Позиционные и именованные аргументы 3248 | Все ранее написанные нами функции имели позиционные аргументы. Такие аргументы передаются без указания имен. Они называются позиционными, потому что именно по позиции, расположению аргумента, функция понимает, какому параметру он соответствует. 3249 | ```python 3250 | def diff(x, y): 3251 | return x - y 3252 | 3253 | 3254 | res = diff(10, 3) # используем позиционные аргументы 3255 | print(res) 3256 | >>> 7 3257 | ``` 3258 | При вызове функции `diff()` первому параметру x будет соответствовать первый переданный аргумент, 10, а второму параметру y — второй аргумент, 3. 3259 | 3260 | Аргументы, передаваемые с именами, называются именованными. При вызове функции можно использовать имена параметров из ее определения. 3261 | ```python 3262 | def diff(x, y): 3263 | return x - y 3264 | 3265 | 3266 | res = diff(y=3, x=10) # используем именованные аргументы 3267 | print(res) 3268 | >>> 7 3269 | ``` 3270 | Такой код по-прежнему выведет число 7. При вызове функции `diff()` мы явно указываем, что параметру x соответствует аргумент 10, а параметру y - аргумент 3. 3271 | 3272 | Комбинировать позиционные и именованные аргументы можно, но позиционные значения должны быть указаны до любых именованных. 3273 | ```python 3274 | res = diff(10, y=3) # используем позиционный и именованный аргумент 3275 | ``` 3276 | Но: 3277 | ```python 3278 | res = diff(x=10, 3) # используем позиционный и именованный аргумент 3279 | ``` 3280 | Приводит к возникновению ошибки `SyntaxError: positional argument follows keyword argument.` 3281 | 3282 | ## Необязательные аргументы 3283 | Например, нам нужна функция которая рисует круг с радиусом radius при указании аргумента radius. Если его не указать, radius будет выставлено значение 10. Вот так это можно реализовать: 3284 | ```python 3285 | def draw_circle(radius=10): 3286 | print(f"Радиус круга: {radius}") 3287 | 3288 | 3289 | draw_circle() 3290 | draw_circle(100) 3291 | >>> Радиус круга: 10 3292 | >>> Радиус круга: 100 3293 | 3294 | ``` 3295 | ## Изменяемые типы в качестве значений по умолчанию 3296 | ```python 3297 | def append(element, seq=[]): 3298 | seq.append(element) 3299 | return seq 3300 | 3301 | 3302 | print(append(100, [])) 3303 | print(append(238, [])) 3304 | 3305 | print(append(100)) 3306 | print(append(238)) 3307 | >>> [100] 3308 | >>> [238] 3309 | >>> [100] 3310 | >>> [100, 238] 3311 | ``` 3312 | Почему `append(238)` выводит не `[238]`, а `[100, 238]`? Значение по умолчанию для параметра создается единожды при определении функции (обычно при загрузке модуля) и становится атрибутом (свойством) функции. Поэтому, если значение по умолчанию изменяемый объект, то его изменение повлияет на каждый следующий вызов функции. Вместо этого используйте такой код: 3313 | ```python 3314 | def append(element, seq=None): 3315 | if seq is None: 3316 | seq = [] 3317 | seq.append(element) 3318 | return seq 3319 | 3320 | ``` 3321 | Чтобы посмотреть значения по умолчанию, можно использовать атрибут `__defaults__`: 3322 | ```python 3323 | def append(element, seq=[]): 3324 | seq.append(element) 3325 | return seq 3326 | 3327 | print('Значение по умолчанию', append.__defaults__) 3328 | print(append(10)) 3329 | print('Значение по умолчанию', append.__defaults__) 3330 | print(append(5)) 3331 | print('Значение по умолчанию', append.__defaults__) 3332 | print(append(1)) 3333 | print('Значение по умолчанию', append.__defaults__) 3334 | >>> Значение по умолчанию ([],) 3335 | >>> [10] 3336 | >>> Значение по умолчанию ([10],) 3337 | >>> [10, 5] 3338 | >>> Значение по умолчанию ([10, 5],) 3339 | >>> [10, 5, 1] 3340 | >>> Значение по умолчанию ([10, 5, 1],) 3341 | 3342 | ``` 3343 | ## Переменное количество аргументов 3344 | Функция может принимать столько аргументов, сколько ей передали: 3345 | ```python 3346 | def my_func(*args): 3347 | print(type(args)) 3348 | print(args) 3349 | 3350 | 3351 | my_func() 3352 | my_func(1, 2, 3) 3353 | my_func('a', 'b') 3354 | >>> 3355 | >>> () 3356 | >>> 3357 | >>> (1, 2, 3) 3358 | >>> 3359 | >>> ('a', 'b') 3360 | ``` 3361 | Звездочка в определении функции означает, что переменная (параметр) args получит в виде кортежа все аргументы, переданные в функцию при ее вызове от текущей позиции и до конца. *args нужно указывать после всех аргументов: 3362 | ```python 3363 | def my_func(num, *args): 3364 | print(args) 3365 | print(num) 3366 | 3367 | 3368 | my_func(17, 'Python', 2, 'C#') 3369 | >>> ('Python', 2, 'C#') 3370 | >>> 17 3371 | ``` 3372 | Помеченный звездочкой параметр *args нормально переживает и отсутствие аргументов, в то время как позиционные параметры всегда обязательны. 3373 | 3374 | ## Передача аргументов в форме списка и кортежа 3375 | (*args): 3376 | ```python 3377 | def my_sum(*args): 3378 | return sum(args) # args - это кортеж 3379 | 3380 | 3381 | print(my_sum(*[1, 2, 3, 4, 5])) # распаковка списка 3382 | print(my_sum(*(1, 2, 3))) # распаковка кортежа 3383 | >>> 15 3384 | >>> 6 3385 | 3386 | ``` 3387 | (**kwargs): 3388 | ```python 3389 | def my_func(**kwargs): 3390 | print(type(kwargs)) 3391 | print(kwargs) 3392 | 3393 | 3394 | info = {"name": "Timur", "age": "28", "job": "teacher"} 3395 | my_func(**info) 3396 | >>> 3397 | >>> {'name': 'Timur', 'age': '28', 'job': 'teacher'} 3398 | 3399 | ``` 3400 | ## Получение именованных аргументов в виде словаря 3401 | Позиционные аргументы можно получать в виде *args, причём произвольное их количество. Такая возможность существует и для именованных аргументов. Только именованные аргументы получаются в виде словаря, что позволяет сохранить имена аргументов в ключах. 3402 | ```python 3403 | def my_func(**kwargs): 3404 | print(type(kwargs)) 3405 | print(kwargs) 3406 | 3407 | 3408 | my_func(a=1, b=2) 3409 | my_func(name="Timur", job="Teacher") 3410 | >>> 3411 | >>> {'a': 1, 'b': 2} 3412 | >>> 3413 | >>> {'name': 'Timur', 'job': 'Teacher'} 3414 | 3415 | ``` 3416 | ## Keyword-only аргументы 3417 | В Python 3 добавили возможность пометить именованные аргументы функции так, чтобы вызвать функцию можно было, только передав эти аргументы по именам. Такие аргументы называются keyword-only и их нельзя передать в функцию в виде позиционных. 3418 | ```python 3419 | def make_circle(x, y, radius, *, line_width=1, fill=True): 3420 | pass 3421 | 3422 | 3423 | make_circle(10, 20, 10, line_width=2, fill=False) 3424 | ``` 3425 | Здесь * выступает разделителем: отделяет обычные аргументы (их можно указывать по имени и позиционно) от строго именованных. 3426 | 3427 | ## Функции как объекты 3428 | Встроенные функции или методы Python: 3429 | ```python 3430 | print(type(print)) 3431 | print(type(sum)) 3432 | print(type(abs)) 3433 | >>> 3434 | >>> 3435 | >>> 3436 | 3437 | ``` 3438 | Тип обычных функций: 3439 | ```python 3440 | def hello(): 3441 | print('Hello from function') 3442 | 3443 | 3444 | print(type(hello)) 3445 | >>> 3446 | 3447 | ``` 3448 | Мы можем назначить переменной функцию: 3449 | ```python 3450 | печать = print 3451 | печать("Hello World!") 3452 | >>> Hello World! 3453 | 3454 | ``` 3455 | Выполнение функции, введённой с клавиатуры: 3456 | ```python 3457 | def start(): 3458 | # тело функции start 3459 | pass 3460 | 3461 | 3462 | def stop(): 3463 | # тело функции stop 3464 | pass 3465 | 3466 | 3467 | def pause(): 3468 | # тело функции pause 3469 | pass 3470 | 3471 | 3472 | commands = {'start': start, 'stop': stop, 'pause': pause} # словарь соответствия команда → функция 3473 | command = input() # считываем название команды 3474 | commands[command]() # вызываем нужную функцию через словарь по ключу 3475 | 3476 | ``` 3477 | ## Функции в качестве аргументов других функций 3478 | ```python 3479 | def pick(f): 3480 | f() 3481 | 3482 | 3483 | def first(): 3484 | print("Первая функция") 3485 | 3486 | 3487 | def second(): 3488 | print("Вторая функция") 3489 | 3490 | 3491 | pick(first) 3492 | >>> Первая функция 3493 | 3494 | ``` 3495 | ## key в min(), max(), sort(), sorted() 3496 | Стандартно `min(), max(), sort(), sorted()` сравнивают сами элементы, однако можно указать key - ключ, по которому будут сравниваться аргументы. Важно, значением key должна быть функция, принимающая и возвращающая один аргумент. 3497 | Пример, сравнение по квадратам элементов: 3498 | ```python 3499 | def to_two(x): 3500 | return x**2 3501 | 3502 | 3503 | list = [-10, 0, 1] 3504 | list.sort(key=to_two) 3505 | print(list) 3506 | >>> [0, 1, -10] # так как [0, 1, 100] отсортирован по возрастанию (квадраты чисел) 3507 | ``` 3508 | Можно использовать и встроенные функции: 3509 | ```python 3510 | list = [-10, 0, 1] 3511 | list.sort(key=abs) 3512 | print(list) 3513 | >>> [0, 1, -10] # так как [0, 1, 10] отсортирован по возрастанию (модули чисел) 3514 | 3515 | ``` 3516 | ## Функции в качестве возвращаемых значений других функций (вложенные функции) 3517 | Можно использовать “вложенные” функции: 3518 | ```python 3519 | def main_function(a, b, c): 3520 | def function(x): 3521 | return a * b * c * x 3522 | 3523 | return function 3524 | 3525 | 3526 | print(main_function(1, 23, 12)(1)) 3527 | >>> 276 3528 | 3529 | ``` 3530 | ## Функции высшего порядка 3531 | Функции, которые принимают или/и возвращают другие функции, называются функциями высшего порядка. 3532 | ```python 3533 | def high_order_function(func): # функция высшего порядка, так как принимает функцию 3534 | return func(3) 3535 | 3536 | 3537 | def double(x): # обычная функция = функция первого порядка 3538 | return 2*x 3539 | 3540 | 3541 | def add_one(x): # обычная функция = функция первого порядка 3542 | return x + 1 3543 | 3544 | ``` 3545 | ## map() 3546 | `map() `применяет функцию ко всем элементам последовательности: 3547 | ```python 3548 | def increase(num): 3549 | return num + 7 3550 | 3551 | 3552 | numbers = [1, 2, 3, 4, 5, 6] 3553 | new_numbers = map(increase, numbers) 3554 | 3555 | print(new_numbers) 3556 | >>> 3557 | ``` 3558 | Код выведет специальный объект, его можно итерировать, преобразовывать в список или кортеж, распаковывать при помощи *: 3559 | ```python 3560 | def increase(num): 3561 | return num + 7 3562 | 3563 | 3564 | numbers = [1, 2, 3, 4, 5, 6] 3565 | new_numbers = map(increase, numbers) 3566 | 3567 | for i in new_numbers: 3568 | print(i) 3569 | >>> 8 3570 | >>> 9 3571 | >>> 10 3572 | >>> 11 3573 | >>> 12 3574 | >>> 13 3575 | 3576 | ``` 3577 | Чтобы получить из итератора список, нужно воспользоваться функцией `list()`: 3578 | ```python 3579 | new_numbers = list(map(increase, numbers)) 3580 | 3581 | ``` 3582 | Функции `map()` можно передать несколько последовательностей. В этом случае в функцию обратного вызова func будут передаваться сразу несколько элементов, расположенных в последовательностях на одинаковых позициях: 3583 | ```python 3584 | def func(elem1, elem2, elem3): 3585 | return elem1 + elem2 + elem3 3586 | 3587 | 3588 | numbers1 = [1, 2, 3, 4, 5] 3589 | numbers2 = [10, 20, 30, 40, 50] 3590 | numbers3 = [100, 200, 300, 400, 500] 3591 | 3592 | new_numbers = list(map(func, numbers1, numbers2, numbers3)) 3593 | 3594 | print(new_numbers) 3595 | >>> [111, 222, 333, 444, 555] 3596 | 3597 | ``` 3598 | Важно! Если в последовательностях разное количество элементов, то последовательность с минимальным количеством элементов становится ограничителем: 3599 | ```python 3600 | def func(elem1, elem2, elem3): 3601 | return elem1 + elem2 + elem3 3602 | 3603 | 3604 | numbers1 = [1, 2, 3, 4] 3605 | numbers2 = [10, 20] 3606 | numbers3 = [100, 200, 300, 400, 500] 3607 | 3608 | new_numbers = list(map(func, numbers1, numbers2, numbers3)) 3609 | 3610 | print(new_numbers) 3611 | >>> [111, 222] 3612 | 3613 | ``` 3614 | ## filter() 3615 | `filter(): `в качестве параметра func указывается ссылка на функцию, которой будет передаваться текущий элемент последовательности. Внутри функции func необходимо вернуть значение `True` или `False`. Для примера, удалим все отрицательные значения из списка: 3616 | ```python 3617 | def func(elem): 3618 | return elem >= 0 3619 | 3620 | 3621 | numbers = [-1, 2, -3, 4, 0, -20, 10] 3622 | positive_numbers = list(filter(func, numbers)) 3623 | 3624 | print(positive_numbers) 3625 | >>> [2, 4, 0, 10] 3626 | ``` 3627 | Встроенной функции `filter()` можно в качестве первого параметра func передать значение `None`. В таком случае каждый элемент последовательности будет проверен на соответствие значению `True`. Если элемент в логическом контексте возвращает значение `False`, то он не будет добавлен в возвращаемый результат. 3628 | 3629 | `filter()` возвращает специальный объект, его можно итерировать, преобразовывать в список или кортеж, распаковывать при помощи *: 3630 | 3631 | Чтобы получить из итератора список, нужно воспользоваться функцией `list()`: 3632 | ```python 3633 | list(filter()) 3634 | 3635 | ``` 3636 | ## reduce() 3637 | `reduce(): `для использования функции `reduce()` необходимо подключить специальный модуль functools. 3638 | Пример: 3639 | ```python 3640 | from functools import reduce 3641 | 3642 | 3643 | def func(a, b): 3644 | return a + b 3645 | 3646 | 3647 | numbers = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10] 3648 | total = reduce(func, numbers, 0) # в качестве начального значения 0 3649 | print(total) 3650 | >>> 55 3651 | ``` 3652 | Как работает функция: складывается 0 и 1, потом 0 + 1 складывается с 2 и т.д. 3653 | 3654 | ## Модуль operator 3655 | Чтобы не писать каждый раз функции, определяющие такие стандартные математические операции как сумма или произведение, можно использовать модуль operator. Неполный список функций из модуля operator выглядит так: 3656 | 3657 | 3658 | | Операция | Синтаксис | Функция | 3659 | |---|---|---| 3660 | | Addition | a + b | add(a, b) | 3661 | | Containment Test | obj in seq | contains(seq, obj) | 3662 | | Division | a / b | truediv(a, b) | 3663 | | Division | a // b | floordiv(a, b) | 3664 | | Exponentiation | a ** b | pow(a, b) | 3665 | | Modulo | a % b | mod(a, b) | 3666 | | Multiplication | a * b | mul(a, b) | 3667 | | Negation (Arithmetic) | -a | neg(a) | 3668 | | Subtraction | a - b | sub(a, b) | 3669 | | Ordering | a < b | lt(a, b) | 3670 | | Ordering | a <= b | le(a, b) | 3671 | | Equality | a == b | eq(a, b) | 3672 | | Difference | a != b | ne(a, b) | 3673 | | Ordering | a >= b | ge(a, b) | 3674 | | Ordering | a > b | gt(a, b) | 3675 | 3676 | 3677 | 3678 | Пример кода, который выводит сумму всех чисел от 0 до 9: 3679 | ```python 3680 | from operator import * 3681 | from functools import reduce 3682 | 3683 | print(reduce(add, range(10))) 3684 | >>> 45 3685 | 3686 | ``` 3687 | ## Анонимные функции (lambda): введение 3688 | Анонимные функции - функции с телом, но без имени. 3689 | Общий формат определения анонимной функции: `lambda список_параметров: выражение. `Параметры не нужно заключать в скобки. 3690 | Лямбда всегда будет возвращать выражение, написанное после “:”. 3691 | 3692 | ## Анонимные функции (lambda): основы, тернарный оператор 3693 | Лямбды удобно использовать как ключи в `min(), max(), sort(), sorted()`: 3694 | ```python 3695 | usernames = [ 3696 | "VulUyiD", 3697 | "YZGDxyurp", 3698 | "xjPaNUIX", 3699 | "OlKBzwein", 3700 | "InuXktD", 3701 | "xgfosAWaK", 3702 | "vMPNwVc", 3703 | "NJGPkmieKZ", 3704 | "whYrmcyNJD", 3705 | "zcQvPfe", 3706 | ] 3707 | 3708 | print(list(filter(lambda user: len(user) == 10, usernames))) 3709 | >>> ['NJGPkmieKZ', 'whYrmcyNJD'] 3710 | ``` 3711 | В коде выше `lambda user: len(user) == 10` возвращает `True` если длина имени пользователя равна десяти. 3712 | 3713 | В лямбдах можно использовать условия (их вид - `значение1 if условие else значение2`): 3714 | ```python 3715 | user = "bananchik2000" 3716 | print((lambda x: "Здравствуйте!" if len(x) > 5 else "Мы вас не знаем :(")(user)) 3717 | >>> Здравствуйте 3718 | ``` 3719 | Код выведет “Здравствуйте!”, так как длина строки user больше 5. 3720 | Важно! Лямбды не поддерживают `elif`. 3721 | 3722 | Лямбды как и обычные функции могут: 3723 | - позиционные аргументы 3724 | - именованные аргументы 3725 | - переменный список позиционных аргументов (*args) 3726 | - переменный список именованных аргументов (**kwargs) 3727 | - keyword-only аргументы (*) 3728 | 3729 | ```python 3730 | a = lambda num: num + 5 3731 | print(a(1)) 3732 | print(a(num=1)) 3733 | 3734 | 3735 | b = lambda *args: f"Аргументы: {args}" 3736 | print(b("Банан", "Лисичка")) 3737 | 3738 | c = lambda **kwargs: f"Аргументы: {kwargs}" 3739 | print(c(food="Банан", i_like="Лисичка")) 3740 | 3741 | d = lambda name, *, food: f"{name} любит {food}" 3742 | print(d("Никита", food="сыр")) 3743 | >>> 6 3744 | >>> 6 3745 | >>> Аргументы: ('Банан', 'Лисичка') 3746 | >>> Аргументы: {'food': 'Банан', 'i_like': 'Лисичка'} 3747 | >>> Никита любит сыр 3748 | 3749 | ``` 3750 | ## all(), any() 3751 | Встроенная функция `all()` возвращает значение `True`, если все элементы переданной ей последовательности (итерируемого объекта) истинны (приводятся к значению `True`), или `False` в противном случае. 3752 | Встроенная функция `any()` возвращает значение `True`, если хотя бы один элемент переданной ей последовательности (итерируемого объекта) истинный (приводится к значению `True`), или `False` в противном случае. 3753 | 3754 | Сигнатура функций следующая: `all(iterable), any(iterable)`. В качестве iterable может выступать любой итерируемый объект: 3755 | - список 3756 | - кортеж 3757 | - строка 3758 | - множество 3759 | - словарь и т.д. 3760 | В Python все следующие значения приводятся к значению `False`: 3761 | - константы `None` и `False` 3762 | - нули всех числовых типов данных: `0, 0.0, 0j, Decimal(0), Fraction(0, 1)` 3763 | - пустые коллекции: `'', (), [], {}, set(), range(0)` 3764 | 3765 | При работе со словарями функции `all(), any()` проверяют на соответствие параметрам `True `ключи словаря, а не их значения. 3766 | 3767 | Обратите внимание: если переданный итерируемый объект пустой, то функция `all()` возвращает значение `True`: 3768 | ```python 3769 | print(all([])) # передаем пустой список 3770 | print(all(())) # передаем пустой кортеж 3771 | print(all('')) # передаем пустую строку 3772 | print(all([[], []])) # передаем список, содержащий пустые списки 3773 | >>> True 3774 | >>> True 3775 | >>> True 3776 | >>> False 3777 | ``` 3778 | Обратите внимание: если переданный объект пуст, то функция `any()` возвращает значение `False`: 3779 | ```python 3780 | print(any([])) # передаем пустой список 3781 | print(any(())) # передаем пустой кортеж 3782 | print(any('')) # передаем пустую строку 3783 | print(any([[], []])) # передаем список, содержащий пустые списки 3784 | >>> False 3785 | >>> False 3786 | >>> False 3787 | >>> False 3788 | 3789 | ``` 3790 | ## enumerate() 3791 | Встроенная функция `enumerate()` возвращает кортеж из индекса элемента и самого элемента переданной ей последовательности (итерируемого объекта). С помощью необязательного параметра `start` можно задать начальное значение индекса. По умолчанию значение параметра `start = 0`, то есть счет начинается с нуля. `enumerate() `возвращает не список, а специальный итерируемый объект. 3792 | ```python 3793 | colors = ['red', 'green', 'blue'] 3794 | 3795 | for pair in enumerate(colors): 3796 | print(pair) 3797 | >>> (0, 'red') 3798 | >>> (1, 'green') 3799 | >>> (2, 'blue') 3800 | ``` 3801 | С использованием `start`: 3802 | ```python 3803 | colors = ['red', 'green', 'blue'] 3804 | 3805 | for pair in enumerate(colors, 100): 3806 | print(pair) 3807 | >>> (100, 'red') 3808 | >>> (101, 'green') 3809 | >>> (102, 'blue') 3810 | 3811 | ``` 3812 | ## zip() 3813 | Встроенная функция `zip()` объединяет отдельные элементы из каждой переданной ей последовательности (итерируемого объекта) в кортежи. `zip() `возвращает не список, а специальный итерируемый объект: 3814 | ```python 3815 | numbers = [1, 2, 3] 3816 | words = ['one', 'two', 'three'] 3817 | 3818 | for pair in zip(numbers, words): 3819 | print(pair) 3820 | >>> (1, 'one') 3821 | >>> (2, 'two') 3822 | >>> (3, 'three') 3823 | 3824 | ``` 3825 | # Работа с файлами 3826 | ## Введение 3827 | Существует 2 типа файлов: текстовые и двоичные (бинарные). Текстовый файл содержит данные, которые были закодированы в виде текста при помощи такой схемы кодирования, как ASCII или Юникод. Разделение файлов на текстовые и бинарные искусственное, так как любой файл бинарен. 3828 | 3829 | Большинство языков программирования обеспечивает два способа получения доступа к данным в файле: 3830 | - последовательный, 3831 | - прямой или произвольный. 3832 | Последовательный выдает порции информации одну за другой. При работе с таким файлом не получится перескочить сразу к нужной части данных, сначала придется прочитать все предыдущие. 3833 | При работе с файлом с прямым или произвольным доступом можно перескочить непосредственно к любой порции данных, не читая предыдущие. 3834 | 3835 | Путь файла (или путь к файлу) — последовательное указание имен папок, через которые надо пройти, чтобы добраться до объекта. 3836 | Пути к файлу бывают двух типов: абсолютные и относительные. 3837 | Абсолютный путь – полный путь к файлу, показывающий точное место его расположения. Он всегда один и тот же, пока файл не перемещен. 3838 | Относительный путь – привязан к какой-либо "отправной точке" и указан по отношению к ней. 3839 | 3840 | ## languages.txt 3841 | В последующих примерах будет использоваться файл languages.txt. Он содержит: 3842 | ```python 3843 | Python 3844 | Java 3845 | Javascript 3846 | C# 3847 | C 3848 | C++ 3849 | PHP 3850 | R 3851 | Objective-C 3852 | 3853 | ``` 3854 | ## Открытие файлов 3855 | Для открытия файлов в Python существует функция `open()`. Она создает файловый объект и связывает его с файлом на диске. Общий формат применения функции `open()`: 3856 | ```python 3857 | файловая_переменная = open(имя_файла, режим_доступа) 3858 | ``` 3859 | Режимы доступа: 3860 | 3861 | 3862 | | Стр. литерал | Режим | Описание | 3863 | |---|---|---| 3864 | | 'r' | Read (чтение) | Открыть файл только для чтения. Такой файл не может быть изменен. | 3865 | | 'w' | Write (запись) | Открыть файл для записи. Если файл уже существует, стереть его содержимое.
Если файл не существует, он будет создан. | 3866 | | 'a' | Append (добавление) | Открыть файл для записи. Данные будут добавлены в конец файла. Если файл не существует, он будет создан. | 3867 | | 'r+' | Read + Write | Открыть файл для чтения и записи. В этом режиме происходит частичная перезапись содержимого файла. | 3868 | | 'x' | Create (создание) | Создать новый файл. Если файл существует, произойдет ошибка. | 3869 | 3870 | 3871 | 3872 | Пример: 3873 | ```python 3874 | student_file = open('students.txt', 'w') # открываем файл в режиме записи 3875 | student_file = open('students.txt') # открываем файл в режиме чтения (по умолчанию режиме записи 'r') 3876 | 3877 | ``` 3878 | ## Указание места расположения файла, сырые строки 3879 | Для указания абсолютного пути нужно использовать \\, вместо \: 3880 | ```python 3881 | test_file = open('C:\\Users\\temp\\test.txt', 'w') 3882 | ``` 3883 | Вместо этого можно использовать сырые строки, для этого перед строкой нужно указать префикс r: 3884 | ```python 3885 | test_file = open(r'C:\Users\temp\test.txt', 'w') 3886 | 3887 | ``` 3888 | ## Кодировка 3889 | При работе с текстом на русском языке нужно указать кодировку, для этого служит параметр `encoding`: 3890 | ```python 3891 | file = open('info.txt', 'r', encoding='utf-8') 3892 | ``` 3893 | Чтобы получить кодировку открытого файла, используют файловое свойство `encoding`: 3894 | ```python 3895 | file1 = open('students.txt', 'w') 3896 | file2 = open('customers.txt', 'w', encoding='utf-8') 3897 | 3898 | print(file1.encoding) 3899 | print(file2.encoding) 3900 | 3901 | file1.close() 3902 | file2.close() 3903 | >>> cp1252 3904 | >>> utf-8 3905 | 3906 | ``` 3907 | ## Закрытие файлов 3908 | После окончания работы с файлом его необходимо закрыть. 3909 | 3910 | Для закрытия файла используется файловый метод `close()`: 3911 | ```python 3912 | file = open('info.txt', 'r') # открываем файл с именем info.txt для чтения 3913 | 3914 | # работаем с содержимым файла info.txt 3915 | 3916 | file.close() # закрываем файл после окончания работы 3917 | 3918 | ``` 3919 | Чтобы проверить открыт файл или закрыт можно использовать файловое свойство (атрибут) `closed`: 3920 | ```python 3921 | file1 = open('students.txt', 'w') 3922 | file2 = open('customers.txt', 'w') 3923 | 3924 | file1.close() 3925 | 3926 | print(file1.closed) 3927 | print(file2.closed) 3928 | 3929 | file2.close() 3930 | >>> True 3931 | >>> False 3932 | 3933 | ``` 3934 | ## read(), readline(), readlines() 3935 | Файловый метод `read()` считывает все содержимое из файла и возвращает строку, которая может содержать символы перехода на новую строку '\n'. 3936 | Также методу `read()` можно передать целочисленный аргумент – столько символов считает метод. 3937 | ```python 3938 | file = open('languages.txt', 'r', encoding='utf-8') 3939 | print(file.read()) 3940 | file.close() 3941 | >>> Python\nJava\nJavascript\nC#\nC\nC++\nPHP\nR\nObjective-C 3942 | 3943 | ``` 3944 | Файловый метод `readline()` считывает одну строку из файла (до символа конца строки '\n'), при этом возвращается считанная строка вместе с символом '\n'. Если считать строку не удалось – достигнут конец файла и больше строк в нем нет, возвращается пустая строка. 3945 | ```python 3946 | file = open('languages.txt', 'r', encoding='utf-8') 3947 | print(file.readline()) 3948 | file.close() 3949 | >>> Python\n 3950 | ``` 3951 | Для удаления '\n' можно использовать `rstrip():` 3952 | ```python 3953 | print("Python\n".rstrip()) 3954 | >>> Python 3955 | 3956 | ``` 3957 | Файловый метод `readlines()` считывает все строки из файла и возвращает список из всех считанных строк (одна строка — один элемент списка). При этом, каждая строка в списке заканчивается символом переноса строки '\n'. 3958 | ```python 3959 | file = open('languages.txt', 'r', encoding='utf-8') 3960 | print(file.readlines()) 3961 | file.close() 3962 | >>> ['Python\n', 'Java\n', 'Javascript\n', 'C#\n', 'C\n', 'C++\n', 'PHP\n', 'R\n', 'Objective-C'] 3963 | 3964 | ``` 3965 | ## Бинарные файлы 3966 | Чтобы открыть бинарный файл нужно использовать литерал b: 3967 | ```python 3968 | file = open('file.dat', 'rb') # открываем бинарный файл в режиме чтения 3969 | file = open('file.dat', 'rt') # открываем текстовый файл в режиме чтения 3970 | file = open('file.dat', 'r') # открываем текстовый файл в режиме чтения 3971 | 3972 | ``` 3973 | ## Свойства файла 3974 | 3975 | 3976 | | Атрибут (свойство) | Описание | 3977 | |---|---| 3978 | | file.closed | возвращает истину (True), если файл закрыт, иначе возвращает ложь (False) | 3979 | | file.mode | возвращает режим доступа, с помощью которого был открыт файл | 3980 | | file.name | возвращает имя файла | 3981 | 3982 | 3983 | 3984 | ## Позиция в файле (курсор) 3985 | Вызов методов `read()`, `readlines()`, `readline()` перемещает текущую позицию туда, где завершилось чтение. Для методов `read()` и `readlines()` это конец файла, для метода `readline()` – следующая строка после прочитанной. 3986 | Для повторного чтения данных из файла, можно: 3987 | - переоткрыть файл, тогда курсор снова попадёт в начало 3988 | - переместить курсор с помощью файлового метода seek() 3989 | 3990 | ## seek(), tell() 3991 | Файловый метод `seek()` задаёт позицию курсора в байтах от начала файла. Чтобы перевести курсор в самое начало файла необходимо вызвать метод `seek()`, передав ему в качестве аргумента значение 0: 3992 | ```python 3993 | file = open('languages.txt', 'r', encoding='utf-8') 3994 | line1 = file.readline() 3995 | file.seek(0) # переводим курсор в самое начало 3996 | line2 = file.readline() 3997 | 3998 | print(line1, line2) 3999 | 4000 | file.close() 4001 | >>> Python 4002 | >>> Python 4003 | ``` 4004 | Будьте аккуратны с символами, использующими более 1 байта (кириллица в кодировке utf-8), обращение к "промежуточному" байту может вызвать ошибку. 4005 | 4006 | Метод `tell()` получает текущую позицию курсора: 4007 | ```python 4008 | file = open('languages.txt', 'r', encoding='utf-8') 4009 | print(file.tell()) 4010 | line1 = file.readline() 4011 | print(file.tell()) 4012 | 4013 | file.close() 4014 | >>> 0 4015 | >>> 8 4016 | 4017 | ``` 4018 | ## Менеджер контекста 4019 | Закрытие файлов вручную, а также отдача закрытия на откуп среде исполнения, обладают существенным недостатком: если между открытием файла и его закрытием произойдёт ошибка, в лучшем случае файл окажется открыт слишком долго, а в худшем случае часть данных не сохранится. 4020 | Менеджер контекста автоматически закрывает файл после выхода из него. Общий вид менеджера контекста: 4021 | ```python 4022 | with object as name: 4023 | # Здесь нам доступен ресурс name. 4024 | # Это тело with-блока. 4025 | # А здесь ресурс name уже освобождён, даже если в теле with-блока произошла ошибка. 4026 | ``` 4027 | Пример использования: 4028 | ```python 4029 | with open('languages.txt', 'r', encoding='utf-8') as file: 4030 | for line in file: 4031 | print(line) 4032 | # автоматическое закрытие файла 4033 | print('Файл закрыт') 4034 | 4035 | ``` 4036 | С помощью менеджера контекста можно работать с несколькими файлами: 4037 | ```python 4038 | with open('input.txt', 'r') as input_file, open('output.txt', 'w') as output_file: 4039 | # обработка файлов 4040 | 4041 | ``` 4042 | ## write(), writelines(), запись в файл при помощи print() 4043 | У нас есть файл myfile.txt, он содержит: 4044 | ```python 4045 | First line of the file. 4046 | Second line of the file. 4047 | Third line of the file. 4048 | 4049 | ``` 4050 | Чтобы использовать методы `write(), writelines()` файл должен быть открыт в режиме записи. 4051 | - При открытии файла в режиме записи (“w”): 4052 | ```python 4053 | with open('myfile.txt', 'w', encoding='utf-8') as file: 4054 | file.write('Python and beegeek forever\n') 4055 | file.write('We love stepik <3') 4056 | ``` 4057 | Файл будет содержать: 4058 | ```python 4059 | Python and beegeek forever 4060 | We love stepik <3 4061 | ``` 4062 | - При открытии файла в режиме добавления (“a”): 4063 | ```python 4064 | with open('myfile.txt', 'a', encoding='utf-8') as file: 4065 | file.write('Python and beegeek forever\n') 4066 | file.write('We love stepik <3') 4067 | ``` 4068 | Файл будет содержать: 4069 | ```python 4070 | First line of the file. 4071 | Second line of the file. 4072 | Third line of the file.Python and beegeek forever 4073 | We love stepik <3 4074 | ``` 4075 | - При открытии файла в режиме чтения + записи (частичной перезаписи) (“r+”): 4076 | ```python 4077 | with open('myfile.txt', 'r+', encoding='utf-8') as file: 4078 | file.write('Python and beegeek forever\n') 4079 | file.write('We love stepik.') 4080 | ``` 4081 | Файл будет содержать: 4082 | ```python 4083 | Python and beegeek forever 4084 | We love stepik. file. 4085 | Third line of the file. 4086 | 4087 | ``` 4088 | Метод `writelines()` записывает все элементы итерируемого объекта в файл: 4089 | ```python 4090 | philosophers = ['Джoн Локк\n', 'Дэвид Хьюм\n', 'Эдмyнд Берк\n'] 4091 | 4092 | with open('philosophers.txt', 'w', encoding='utf-8') as file: 4093 | file.writelines(philosophers) 4094 | ``` 4095 | Чтобы каждый элемент был на новой строке, нужно добавлять “\n” в конце каждого элемента. 4096 | 4097 | Для записи данных в файл можно также использовать встроенную функцию `print()`: 4098 | ```python 4099 | philosophers = ["Джoн Локк", "Дэвид Хьюм", "Эдмyнд Берк"] 4100 | 4101 | with open("philosophers.txt", "w", encoding="utf-8") as output: 4102 | for i in philosophers: 4103 | print(i, file=output) 4104 | ``` 4105 | `print()` сама добавит переходы на новые строки. 4106 | 4107 | # Интересные штуки 4108 | ## Числовая угадайка 4109 | ```python 4110 | import random 4111 | 4112 | while True: 4113 | counter = 0 4114 | to = int(input("Укажите число, до которого компьютер будет выбирать случайное: ")) 4115 | g = random.randint(1, to) 4116 | print("Добро пожаловать в числовую угадайку!") 4117 | print(f"Введите число от 1 до {to}") 4118 | 4119 | while True: 4120 | n = int(input()) 4121 | if n < g: 4122 | print("Ваше число меньше загаданного, попробуйте еще разок") 4123 | counter += 1 4124 | 4125 | elif n > g: 4126 | print("Ваше число больше загаданного, попробуйте еще разок") 4127 | counter += 1 4128 | 4129 | else: 4130 | counter += 1 4131 | print(f"Вы угадали число за {counter} попыток, поздравляем!") 4132 | break 4133 | 4134 | if ( 4135 | input( 4136 | "Спасибо, что играли в числовую угадайку. Хотите сыграть еще раз? (да/нет): " 4137 | ) 4138 | == "нет" 4139 | ): 4140 | break 4141 | 4142 | ``` 4143 | ## Магический шар 8 4144 | ```python 4145 | import random 4146 | 4147 | answers = [ 4148 | "Бесспорно", 4149 | "Мне кажется - да", 4150 | "Пока неясно, попробуй снова", 4151 | "Даже не думай", 4152 | "Предрешено", 4153 | "Вероятнее всего", 4154 | "Спроси позже", 4155 | "Мой ответ - нет", 4156 | "Никаких сомнений", 4157 | "Хорошие перспективы", 4158 | "Лучше не рассказывать", 4159 | "По моим данным - нет", 4160 | "Можешь быть уверен в этом", 4161 | "Да", 4162 | "Сконцентрируйся и спроси опять", 4163 | "Весьма сомнительно", 4164 | ] 4165 | 4166 | print("Привет Мир, я магический шар, и я знаю ответ на любой твой вопрос.") 4167 | name = input("Как тебя зовут? ") 4168 | print(f"Привет, {name}") 4169 | while True: 4170 | input("Напиши свой вопрос: ") 4171 | print(random.choice(answers)) 4172 | if input("Хочешь задать ещё один вопрос? (да/нет): ") == "нет": 4173 | break 4174 | 4175 | ``` 4176 | ## Генератор безопасных паролей 4177 | ```python 4178 | import random 4179 | 4180 | 4181 | digits = "0123456789" 4182 | lowercase_letters = "abcdefghijklmnopqrstuvwxyz" 4183 | uppercase_letters = "ABCDEFGHIJKLMNOPQRSTUVWXYZ" 4184 | punctuation = "!#$%&*+-=?@^_" 4185 | 4186 | chars = "" 4187 | 4188 | count = int(input("Введите количество паролей: ")) 4189 | lenght = int(input("Введите длину одного пароля: ")) 4190 | contain_digits = input("Включать цифры? ") 4191 | contain_upper = input("Включать прописные буквы? ") 4192 | contain_lower = input("Включать строчные буквы? ") 4193 | contain_strange = input("Включать символы !#$%&*+-=?@^_? ") 4194 | stupid = input("Исключать неоднозначные символы il1Lo0O? ") 4195 | 4196 | if contain_digits == "да": 4197 | chars += digits 4198 | if contain_upper == "да": 4199 | chars += uppercase_letters 4200 | if contain_lower == "да": 4201 | chars += lowercase_letters 4202 | if contain_strange == "да": 4203 | chars += punctuation 4204 | if stupid == "да": 4205 | chars = "".join([i for i in chars if not i in "il1Lo0O"]) 4206 | 4207 | for i in range(count): 4208 | print("".join(random.sample(chars, lenght))) 4209 | 4210 | ``` 4211 | ## Калькулятор систем счисления (bin(), oct(), hex()) 4212 | ```python 4213 | a = int(input("Введите число в десятичной системе счисления: ")) 4214 | print(f"Число в двоичной системе: {bin(a)[2:]}") 4215 | print(f"Число в восьмеричной системе: {oct(a)[2:]}") 4216 | print(f"Число в шестнадцатеричной системе: {hex(a)[2:].upper()}") 4217 | 4218 | ``` 4219 | ## Угадайка слов 4220 | ```python 4221 | import random, os 4222 | 4223 | word_list = [ 4224 | "год", 4225 | "человек", 4226 | "время", 4227 | "дело", 4228 | "жизнь", 4229 | "день", 4230 | "рука", 4231 | "раз", 4232 | "работа", 4233 | "слово", 4234 | "место", 4235 | "лицо", 4236 | "друг", 4237 | "глаз", 4238 | "вопрос", 4239 | "дом", 4240 | "сторона", 4241 | "страна", 4242 | "мир", 4243 | "случай", 4244 | "голова", 4245 | "ребенок", 4246 | "сила", 4247 | "конец", 4248 | "вид", 4249 | "система", 4250 | "часть", 4251 | "город", 4252 | "отношение", 4253 | "женщина", 4254 | "деньги", 4255 | "земля", 4256 | "машина", 4257 | "вода", 4258 | "отец", 4259 | "проблема", 4260 | "час", 4261 | "право", 4262 | "нога", 4263 | "решение", 4264 | "дверь", 4265 | "образ", 4266 | "история", 4267 | "власть", 4268 | "закон", 4269 | "война", 4270 | "бог", 4271 | "голос", 4272 | "тысяча", 4273 | "книга", 4274 | "возможность", 4275 | "результат", 4276 | "ночь", 4277 | "стол", 4278 | "имя", 4279 | "область", 4280 | "статья", 4281 | "число", 4282 | "компания", 4283 | "народ", 4284 | "жена", 4285 | "группа", 4286 | "развитие", 4287 | "процесс", 4288 | "суд", 4289 | "условие", 4290 | "средство", 4291 | "начало", 4292 | "свет", 4293 | "пора", 4294 | "путь", 4295 | "душа", 4296 | "уровень", 4297 | "форма", 4298 | "связь", 4299 | "минута", 4300 | "улица", 4301 | "вечер", 4302 | "качество", 4303 | "мысль", 4304 | "дорога", 4305 | "мать", 4306 | "действие", 4307 | "месяц", 4308 | "государство", 4309 | "язык", 4310 | "любовь", 4311 | "взгляд", 4312 | "мама", 4313 | "век", 4314 | "школа", 4315 | "цель", 4316 | "общество", 4317 | "деятельность", 4318 | "организация", 4319 | "президент", 4320 | "комната", 4321 | "порядок", 4322 | "момент", 4323 | "театр", 4324 | ] 4325 | 4326 | 4327 | def get_word(): 4328 | return random.choice(word_list).upper() 4329 | 4330 | 4331 | # функция получения текущего состояния 4332 | def display_hangman(tries): 4333 | stages = [ # финальное состояние: голова, торс, обе руки, обе ноги 4334 | """ 4335 | -------- 4336 | | | 4337 | | O 4338 | | \\|/ 4339 | | | 4340 | | / \\ 4341 | - 4342 | """, 4343 | # голова, торс, обе руки, одна нога 4344 | """ 4345 | -------- 4346 | | | 4347 | | O 4348 | | \\|/ 4349 | | | 4350 | | / 4351 | - 4352 | """, 4353 | # голова, торс, обе руки 4354 | """ 4355 | -------- 4356 | | | 4357 | | O 4358 | | \\|/ 4359 | | | 4360 | | 4361 | - 4362 | """, 4363 | # голова, торс и одна рука 4364 | """ 4365 | -------- 4366 | | | 4367 | | O 4368 | | \\| 4369 | | | 4370 | | 4371 | - 4372 | """, 4373 | # голова и торс 4374 | """ 4375 | -------- 4376 | | | 4377 | | O 4378 | | | 4379 | | | 4380 | | 4381 | - 4382 | """, 4383 | # голова 4384 | """ 4385 | -------- 4386 | | | 4387 | | O 4388 | | 4389 | | 4390 | | 4391 | - 4392 | """, 4393 | # начальное состояние 4394 | """ 4395 | -------- 4396 | | | 4397 | | 4398 | | 4399 | | 4400 | | 4401 | - 4402 | """, 4403 | ] 4404 | os.system("cls") 4405 | return stages[tries] 4406 | 4407 | 4408 | def play(word): 4409 | word_completion = "_" * len( 4410 | word 4411 | ) # строка, содержащая символы _ на каждую букву задуманного слова 4412 | guessed_letters = [] # список уже названных букв 4413 | tries = 6 4414 | 4415 | while True: 4416 | print(display_hangman(tries)) 4417 | print(word_completion) 4418 | 4419 | symbol = input("Введите букву русского алфавита: ").upper() 4420 | 4421 | if symbol in guessed_letters: 4422 | while True: 4423 | symbol = input("Вы уже открыли эту букву, введите другую: ").upper() 4424 | if symbol not in guessed_letters: 4425 | break 4426 | 4427 | if symbol not in "АБВГДЕЖЗИЙКЛМНОПРСТУФХЦЧШЩЪЫЬЭЮЯ" or len(symbol) != 1: 4428 | while True: 4429 | symbol = input("Введите букву русского алфавита: ").upper() 4430 | if symbol in "АБВГДЕЖЗИЙКЛМНОПРСТУФХЦЧШЩЪЫЬЭЮЯ" and len(symbol) == 1: 4431 | break 4432 | 4433 | word_completion_before = word_completion 4434 | 4435 | for i in range(len(word)): 4436 | if word[i] == symbol: 4437 | word_completion = ( 4438 | word_completion[:i] + symbol + word_completion[i + 1 :] 4439 | ) 4440 | guessed_letters += symbol 4441 | 4442 | if word_completion_before == word_completion: 4443 | tries -= 1 4444 | 4445 | if tries == 0: 4446 | print(display_hangman(0)) 4447 | print(f"К сожалению, вы проиграли... Слово: {word}") 4448 | input("Нажмите Enter для повторной игры") 4449 | break 4450 | 4451 | if "_" not in word_completion: 4452 | print(f"Поздравляем! Вы угадали слово {word_completion}") 4453 | input("Нажмите Enter для повторной игры") 4454 | break 4455 | 4456 | 4457 | while True: 4458 | play(get_word()) 4459 | 4460 | 4461 | ``` 4462 | -------------------------------------------------------------------------------- /images/image_1.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/FerrumVega/Python/be5ce19a474efd1f45f23de231ec14126fafb606/images/image_1.png -------------------------------------------------------------------------------- /images/image_10.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/FerrumVega/Python/be5ce19a474efd1f45f23de231ec14126fafb606/images/image_10.png -------------------------------------------------------------------------------- /images/image_11.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/FerrumVega/Python/be5ce19a474efd1f45f23de231ec14126fafb606/images/image_11.png -------------------------------------------------------------------------------- /images/image_12.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/FerrumVega/Python/be5ce19a474efd1f45f23de231ec14126fafb606/images/image_12.png -------------------------------------------------------------------------------- /images/image_13.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/FerrumVega/Python/be5ce19a474efd1f45f23de231ec14126fafb606/images/image_13.png -------------------------------------------------------------------------------- /images/image_14.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/FerrumVega/Python/be5ce19a474efd1f45f23de231ec14126fafb606/images/image_14.png -------------------------------------------------------------------------------- /images/image_15.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/FerrumVega/Python/be5ce19a474efd1f45f23de231ec14126fafb606/images/image_15.png -------------------------------------------------------------------------------- /images/image_16.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/FerrumVega/Python/be5ce19a474efd1f45f23de231ec14126fafb606/images/image_16.png -------------------------------------------------------------------------------- /images/image_17.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/FerrumVega/Python/be5ce19a474efd1f45f23de231ec14126fafb606/images/image_17.png -------------------------------------------------------------------------------- /images/image_18.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/FerrumVega/Python/be5ce19a474efd1f45f23de231ec14126fafb606/images/image_18.png -------------------------------------------------------------------------------- /images/image_19.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/FerrumVega/Python/be5ce19a474efd1f45f23de231ec14126fafb606/images/image_19.png -------------------------------------------------------------------------------- /images/image_2.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/FerrumVega/Python/be5ce19a474efd1f45f23de231ec14126fafb606/images/image_2.png -------------------------------------------------------------------------------- /images/image_20.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/FerrumVega/Python/be5ce19a474efd1f45f23de231ec14126fafb606/images/image_20.png -------------------------------------------------------------------------------- /images/image_21.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/FerrumVega/Python/be5ce19a474efd1f45f23de231ec14126fafb606/images/image_21.png -------------------------------------------------------------------------------- /images/image_22.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/FerrumVega/Python/be5ce19a474efd1f45f23de231ec14126fafb606/images/image_22.png -------------------------------------------------------------------------------- /images/image_3.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/FerrumVega/Python/be5ce19a474efd1f45f23de231ec14126fafb606/images/image_3.png -------------------------------------------------------------------------------- /images/image_4.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/FerrumVega/Python/be5ce19a474efd1f45f23de231ec14126fafb606/images/image_4.png -------------------------------------------------------------------------------- /images/image_5.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/FerrumVega/Python/be5ce19a474efd1f45f23de231ec14126fafb606/images/image_5.png -------------------------------------------------------------------------------- /images/image_6.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/FerrumVega/Python/be5ce19a474efd1f45f23de231ec14126fafb606/images/image_6.png -------------------------------------------------------------------------------- /images/image_7.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/FerrumVega/Python/be5ce19a474efd1f45f23de231ec14126fafb606/images/image_7.png -------------------------------------------------------------------------------- /images/image_8.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/FerrumVega/Python/be5ce19a474efd1f45f23de231ec14126fafb606/images/image_8.png -------------------------------------------------------------------------------- /images/image_9.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/FerrumVega/Python/be5ce19a474efd1f45f23de231ec14126fafb606/images/image_9.png --------------------------------------------------------------------------------