Python с нуля
Серия «Библиотека программиста»
Руководитель дивизиона
Ю. Сергиенко
Руководитель проекта
А. Питиримов
Ведущий редактор
Н. Гринчик
Художественный редактор
В. Мостипан
Литературный редактор
К. Тульцева
Корректоры
С. Беляева, Н. Викторова
Верстка
Л. Егорова
ББК 32.973.2-018.1
УДК 004.43
Левашов Петр
Л34 Python с нуля. — СПб.: Питер, 2024. — 448 с.: ил. — (Серия «Библиотека программиста»).
ISBN 978-5-4461-2145-8
Добро пожаловать в увлекательный мир программирования на языке Python! Независимо от того, начинающий
вы или опытный программист, вы вооружитесь знаниями и навыками, необходимыми для успешного освоения
языка. Python, известный своей простотой и универсальностью, завоевал огромную популярность среди разработчиков во всем мире. Благодаря удобному синтаксису и широкой библиотечной поддержке он идеально
подходит для решения широкого спектра задач — от веб-разработки и анализа данных до программирования
графических интерфейсов. Книга представляет собой комплексное руководство по изучению языка Python с нуля.
16+ (В соответствии с Федеральным законом от 29 декабря 2010 г. № 436-ФЗ.)
ISBN 978-5-4461-2145-8
Все права защищены. Никакая часть данной книги не может быть воспроизведена в какой бы то ни было форме
без письменного разрешения владельцев авторских прав. Информация, содержащаяся в данной книге, получена
из источников, рассматриваемых издательством как надежные. Тем не менее, имея в виду возможные человеческие или технические ошибки, издательство не может гарантировать абсолютную точность и полноту приводимых сведений и не несет ответственности за возможные ошибки, связанные с использованием книги. В книге
возможны упоминания организаций, деятельность которых запрещена на территории Российской Федерации,
таких как Meta Platforms Inc., Facebook, Instagram и др. Издательство не несет ответственности за доступность
материалов, ссылки на которые вы можете найти в этой книге. На момент подготовки книги к изданию все ссылки
на интернет-ресурсы были действующими.
Изготовлено в России. Изготовитель: ООО «Прогресс книга». Место нахождения и фактический адрес:
194044, Россия, г. Санкт-Петербург, Б. Сампсониевский пр., д. 29А, пом. 52. Тел.: +78127037373.
Дата изготовления: 01.2024. Наименование: книжная продукция. Срок годности: не ограничен.
Налоговая льгота — общероссийский классификатор продукции ОК 034-2014, 58.11.12 — Книги печатные
профессиональные, технические и научные.
Импортер в Беларусь: ООО «ПИТЕР М», 220020, РБ, г. Минск, ул. Тимирязева, д. 121/3, к. 214, тел./факс: 208 80 01.
Подписано в печать 30.11.23. Формат 70×100/16. Бумага офсетная. Усл. п. л. 36,120. Тираж 1000. Заказ 0000.
КРАТКОЕ СОДЕРЖАНИЕ
Введение ............................................................................................................................... 16
Об авторе ............................................................................................................................... 18
От издательства....................................................................................................................... 20
Глава 1. Введение в программирование на Python........................................................... 21
Глава 2. Переменные, типы данных и операторы.............................................................. 29
Глава 3. Управляющие структуры: условные операторы и циклы.................................... 39
Глава 4. Функции и модули.................................................................................................. 46
Глава 5. Структуры данных: cписки, кортежи и словари.................................................. 57
Глава 6. Ввод и вывод........................................................................................................... 73
Глава 7. Объектно-ориентированное программирование................................................ 80
Глава 8. Обработка исключений........................................................................................ 105
Глава 9. Регулярные выражения....................................................................................... 117
Глава 10. Работа с библиотеками и API.............................................................................. 145
Глава 11. Отладка и тестирование...................................................................................... 169
Глава 12. Введение в Data Science на Python..................................................................... 230
Глава 13. Веб-скрапинг с помощью Python........................................................................ 340
Глава 14. Программирование графических интерфейсов с помощью Python................ 395
Заключение............................................................................................................................446
Список источников................................................................................................................ 447
ОГЛАВЛЕНИЕ
Введение.................................................................................................................. 16
Об авторе.................................................................................................................. 18
От издательства....................................................................................................... 20
Глава 1. Введение в программирование на Python................................................. 21
Что такое Python...............................................................................................................................21
История Python.................................................................................................................................22
Установка Python и среды разработки......................................................................................22
Интерпретатор Python и REPL (Read-Eval-Print Loop).....................................................23
Ваша первая программа на Python.............................................................................................24
Синтаксис и основные концепции программирования.......................................................24
Запуск программ на Python...........................................................................................................25
Основные методы отладки.............................................................................................................26
Стиль кода Python и лучшие практики.....................................................................................27
Ресурсы для изучения Python......................................................................................................27
Глава 2. Переменные, типы данных и операторы................................................... 29
Соглашения об именовании переменных.................................................................................29
Основные типы данных..................................................................................................................30
Числовые типы данных...................................................................................................................31
Строковый тип данных...................................................................................................................31
Булев тип данных..............................................................................................................................32
Приведение типов.............................................................................................................................33
Арифметические операторы..........................................................................................................34
Операторы сравнения......................................................................................................................35
Логические операторы....................................................................................................................36
Приоритет и ассоциативность операторов...............................................................................37
Задания для самопроверки............................................................................................................37
Оглавление 5
Глава 3. Управляющие структуры: условные операторы и циклы.......................... 39
Условные операторы: if, elif и else................................................................................................39
Булевы выражения и операторы сравнения............................................................................40
Циклы: for и while.............................................................................................................................41
Операторы break, continue и pass.................................................................................................42
Вложенные циклы и условия........................................................................................................44
Задания для самопроверки............................................................................................................45
Глава 4. Функции и модули..................................................................................... 46
Определение и вызов функций....................................................................................................46
Параметры и аргументы функции..............................................................................................47
Позиционные аргументы.........................................................................................................47
Параметры ключевых слов.....................................................................................................47
Параметры переменной длины..............................................................................................48
Операторы возврата и возвращаемые значения.....................................................................49
Область действия функции и локальные переменные........................................................50
Глобальные переменные и оператор global..............................................................................51
Лямбда-функции...............................................................................................................................52
Встроенные функции.......................................................................................................................53
Модули и оператор import.............................................................................................................53
Создание и использование модулей...........................................................................................54
Стандартная библиотека Python.................................................................................................55
Задания для самопроверки............................................................................................................56
Глава 5. Структуры данных: cписки, кортежи и словари....................................... 57
Списки в Python................................................................................................................................57
Кортежи в Python.............................................................................................................................58
Словари в Python..............................................................................................................................59
Списковое включение.....................................................................................................................60
Сортировка и поиск в структурах данных...............................................................................61
Продвинутые методы работы со структурами данных........................................................62
Копирование и клонирование структур данных.............................................................62
Нарезка списка и расширенные нарезки...........................................................................63
Множественные входные последовательности в списковых включениях............64
Словарные включения.............................................................................................................65
Множества и операции с ними..............................................................................................66
Стеки и очереди со списками.................................................................................................67
Продвинутые методы сортировки........................................................................................68
6 Оглавление
Бинарный поиск.........................................................................................................................69
Работа с вложенными структурами данных.....................................................................70
Задания для самопроверки............................................................................................................71
Глава 6. Ввод и вывод............................................................................................. 73
Стандартный ввод-вывод...............................................................................................................73
Чтение пользовательского ввода с помощью input()...........................................................74
Ввод и вывод файлов.......................................................................................................................74
Открытие файлов.......................................................................................................................75
Чтение и запись данных...........................................................................................................75
Закрытие файлов........................................................................................................................76
Работа с двоичными файлами......................................................................................................76
Обработка ошибок ввода-вывода при работе с файлами....................................................77
Задания для самопроверки............................................................................................................78
Глава 7. Объектно-ориентированное программирование....................................... 80
Классы и объекты..............................................................................................................................80
Определение классов.......................................................................................................................81
Атрибуты и методы класса............................................................................................................82
Атрибуты экземпляра и методы...................................................................................................83
Конструкторы и деструкторы.......................................................................................................84
Наследование.....................................................................................................................................85
Переопределение метода................................................................................................................86
Полиморфизм.....................................................................................................................................87
Абстрактные классы и интерфейсы............................................................................................88
Инкапсуляция и сокрытие данных.............................................................................................89
Абстракция данных и инкапсуляция данных.........................................................................90
Модификаторы частного доступа...............................................................................................91
Перегрузка операторов...................................................................................................................92
Класс и статические методы и переменные.............................................................................93
Обработка исключений в ООП....................................................................................................94
Сборка мусора и управление памятью......................................................................................95
Продвинутые темы в ООП............................................................................................................95
Декораторы...................................................................................................................................95
Метаклассы..................................................................................................................................96
Множественное наследование...............................................................................................97
Миксины и компоновщик.......................................................................................................97
Порядок разрешения методов (MRO)................................................................................99
Утиная типизация и EAFP................................................................................................... 100
Оглавление 7
Monkey patch и динамические классы............................................................................. 101
Фабрики классов и метапрограммирование................................................................. 102
Рефлексия и интроспекция ................................................................................................ 103
Задания для самопроверки......................................................................................................... 103
Глава 8. Обработка исключений............................................................................ 105
Синтаксис обработки исключений.......................................................................................... 106
Синтаксис блоков try-except............................................................................................... 106
Обработка исключений с помощью блоков except...................................................... 106
Обработка нескольких исключений с помощью одного блока except.................. 107
Использование блоков else и finally в конструкциях try-except............................. 108
Множественные блоки Except и цепочки исключений . ................................................. 109
Генерация исключений................................................................................................................. 110
Исключения, определяемые пользователем......................................................................... 111
Возможности блока finally.......................................................................................................... 111
Лучшие практики и советы по обработке исключений.................................................... 112
Сообщения об ошибках......................................................................................................... 112
Изящный сбой.......................................................................................................................... 113
Тестирование обработки исключений............................................................................. 114
Документирование................................................................................................................. 114
Задания для самопроверки......................................................................................................... 115
Глава 9. Регулярные выражения........................................................................... 117
Сопоставление текста с помощью регулярных выражений............................................ 118
Специальные символы и экранирование.............................................................................. 118
Классы символов и выражения в квадратных скобках.................................................... 119
Основные классы символов................................................................................................ 120
Сокращенные классы символов......................................................................................... 120
Вложенные классы символов............................................................................................. 121
Квантификаторы и альтернация............................................................................................... 121
Квантификатор *..................................................................................................................... 122
Квантификатор +.................................................................................................................... 122
Квантификатор ?..................................................................................................................... 123
Квантификатор { }................................................................................................................... 124
Альтернация и |......................................................................................................................... 124
Квантификаторы и альтернация: лучшие практики и советы................................. 125
Группировка и захват.................................................................................................................... 126
Использование круглых скобок для группировки...................................................... 126
Захват совпадений с помощью групп............................................................................... 127
8 Оглавление
Группы без захвата.................................................................................................................. 128
Именованные группы............................................................................................................ 129
Группировка и захват: лучшие практики и советы...................................................... 130
Обратные ссылки и подстановки............................................................................................. 131
Использование обратных ссылок в регулярных выражениях................................ 132
Замена совпадений с помощью регулярных выражений.......................................... 133
Обратные ссылки и подстановки: лучшие практики и советы............................... 134
Опережающие и ретроспективные проверки....................................................................... 134
Положительная опережающая проверка........................................................................ 135
Отрицательная опережающая проверка......................................................................... 136
Положительная ретроспективная проверка.................................................................. 137
Отрицательная ретроспективная проверка................................................................... 138
Лучшие практики и советы.................................................................................................. 138
Лучшие практики и советы по использованию регулярных выражений................... 139
Понимание задачи перед написанием регулярного выражения............................. 139
Простота и читабельность регулярного выражения................................................... 140
Тестирование и отладка регулярных выражений........................................................ 141
Использование встроенных функций и библиотек вместо регулярных
выражений................................................................................................................................. 141
Баланс между гибкостью и производительностью
в регулярных выражениях................................................................................................... 142
Работа с граничными случаями и специальными символами................................ 143
Задания для самопроверки......................................................................................................... 144
Глава 10. Работа с библиотеками и API................................................................. 145
Работа с библиотеками с помощью pip.................................................................................. 145
Установка библиотек с помощью pip................................................................................ 146
Управление установленными библиотеками с помощью pip.................................. 147
Обновление и удаление библиотек с помощью pip..................................................... 148
Лучшие практики использования pip.............................................................................. 148
Использование стандартных библиотек................................................................................ 149
Библиотеки и API сторонних производителей................................................................... 150
Поиск и оценка библиотек и API сторонних производителей............................... 150
Установка и импорт библиотек сторонних производителей................................... 151
Общие библиотеки и API сторонних производителей.............................................. 152
Лучшие практики использования библиотек и API сторонних
производителей........................................................................................................................ 152
Аутентификация и авторизация с помощью API............................................................... 153
API-ключи................................................................................................................................. 154
OAuth........................................................................................................................................... 154
Оглавление 9
Токены......................................................................................................................................... 155
Лучшие практики аутентификации и авторизации API........................................... 156
Запросы и ответы API.................................................................................................................. 156
HTTP-запросы......................................................................................................................... 157
Коды состояния ответа HTTP............................................................................................ 158
Парсинг ответов API.............................................................................................................. 159
Обработка ошибок в ответах API...................................................................................... 159
Лучшие практики работы с API......................................................................................... 161
Работа с данными JSON и XML............................................................................................... 161
Парсинг данных JSON........................................................................................................... 162
Создание данных в формате JSON................................................................................... 163
Парсинг данных XML............................................................................................................ 163
Создание данных XML.......................................................................................................... 164
Лучшие практики работы с данными JSON и XML................................................... 165
Обработка ошибок и отладка в библиотеках и API........................................................... 165
Работа с ошибками в библиотеках.................................................................................... 166
Библиотеки и API для отладки.......................................................................................... 166
Лучшие практики обработки ошибок и отладки......................................................... 166
Работа с библиотеками и API. Лучшие практики и советы............................................ 167
Задания для самопроверки......................................................................................................... 168
Глава 11. Отладка и тестирование........................................................................ 169
Техники и инструменты отладки.............................................................................................. 169
Стратегии отладки.................................................................................................................. 169
Оператор print и логирование............................................................................................ 170
Отладчик Python (PDB)...................................................................................................... 172
Отладка с помощью точек останова и точек наблюдения........................................ 173
Отладка проблем с памятью................................................................................................ 174
Профилирование и оптимизация производительности............................................ 175
Отладка распространенных ошибок и проблем.................................................................. 176
Ошибки синтаксиса................................................................................................................ 176
Ошибки отступов.................................................................................................................... 177
Ошибки именования.............................................................................................................. 177
Ошибки типов.......................................................................................................................... 178
Ошибки атрибутов.................................................................................................................. 179
Ошибки индекса и ключа..................................................................................................... 180
ValueError и TypeError.......................................................................................................... 181
Ошибки ImportError и ModuleNotFound....................................................................... 182
FileNotFoundError и IOError.............................................................................................. 184
Обработка исключений и возвратов................................................................................. 185
10 Оглавление
Отладка в интегрированных средах разработки (IDE).................................................... 186
Отладка в PyCharm................................................................................................................ 187
Отладка в Visual Studio Code.............................................................................................. 188
Отладка в Eclipse с помощью PyDev................................................................................ 189
Отладка в блокнотах Jupyter Notebooks......................................................................... 190
Функции и советы по отладке, специфичные для IDE............................................. 191
Введение в тестирование и разработку на основе тестирования (TDD)................... 192
Важность тестирования........................................................................................................ 192
Виды тестирования................................................................................................................. 193
Обзор разработки на основе тестирования (TDD)..................................................... 194
Юнит-тестирование в Python............................................................................................. 195
Написание тестируемого кода............................................................................................ 196
Автоматизация тестирования и непрерывная интеграция....................................... 197
Юнит-тестирование с помощью Pytest.................................................................................. 198
Установка и настройка Pytest............................................................................................. 199
Написание тестовых функций с помощью Pytest....................................................... 200
Фикстуры Pytest. Настройка и завершение.................................................................. 201
Утверждения и соответствия (matchers) в Pytest........................................................ 203
Запуск и настройка Pytest................................................................................................... 203
Параметризация тестов и тестирование на основе данных...................................... 205
Плагины и расширения Pytest........................................................................................... 206
Тестовое покрытие и качество кода......................................................................................... 207
Понятие тестового покрытия.............................................................................................. 207
Измерение тестового покрытия с помощью Coverage.py.......................................... 208
Анализ отчетов о покрытии................................................................................................. 209
Улучшение тестового покрытия......................................................................................... 210
Метрики качества кода......................................................................................................... 211
Линтинг и статический анализ........................................................................................... 212
Интеграция проверок качества кода в рабочий процесс........................................... 214
Интеграционное тестирование и непрерывная интеграция (CI)................................. 215
Написание интеграционных тестов.................................................................................. 215
Инструменты и фреймворки для интеграционного тестирования....................... 216
Непрерывная интеграция: обзор........................................................................................ 217
Настройка CI-пайплайна..................................................................................................... 219
Преимущества сочетания интеграционного тестирования и CI............................ 220
Отладка и тестирование: лучшие практики и советы....................................................... 221
Общие советы по отладке..................................................................................................... 221
Лучшие практики тестирования........................................................................................ 222
Советы по разработке на основе тестирования............................................................ 223
Оглавление 11
Код-ревью и совместная работа......................................................................................... 224
Непрерывное совершенствование отладки и тестирования.................................... 225
Баланс между покрытием тестами и сопровождаемостью....................................... 226
Чего следует избегать при отладке и тестировании.................................................... 227
Задания для самопроверки......................................................................................................... 228
Глава 12. Введение в Data Science на Python........................................................ 230
Что такое Data Science................................................................................................................. 230
Роль Python в Data Science.................................................................................................. 231
Обзор библиотек и инструментов..................................................................................... 232
Применение Data Science в реальном мире с помощью Python............................. 234
Установка библиотек Data Science в Python........................................................................ 235
NumPy: массивы и матрицы....................................................................................................... 236
Создание массивов NumPy.................................................................................................. 237
Атрибуты и свойства массива............................................................................................. 238
Индексация и нарезка массивов........................................................................................ 239
Операции с массивами и трансляция.............................................................................. 240
Матричные операции и линейная алгебра..................................................................... 242
Продвинутые возможности NumPy.................................................................................. 244
Практическое применение NumPy в Data Science...................................................... 245
Pandas: манипулирование данными и их анализ................................................................ 247
Ключевые структуры данных: Series и DataFrame...................................................... 248
Импорт и экспорт данных.................................................................................................... 249
Очистка и предварительная обработка данных........................................................... 250
Выбор и индексация данных............................................................................................... 252
Агрегирование и группировка данных............................................................................ 253
Слияние, объединение и конкатенация данных........................................................... 254
Функциональность временных рядов и дат.................................................................. 256
Визуализация с помощью Pandas...................................................................................... 257
Практическое применение Pandas в Data Science....................................................... 258
Matplotlib: визуализация данных............................................................................................. 260
Архитектура Matplotlib......................................................................................................... 260
Создание основных типов графиков................................................................................ 261
Настройка графиков.............................................................................................................. 263
Продвинутые техники построения графиков............................................................... 264
Сохранение и экспорт графиков........................................................................................ 265
Интеграция Matplotlib с Pandas......................................................................................... 266
Лучшие практики и советы по визуализации данных
с помощью Matplotlib............................................................................................................ 268
12 Оглавление
Seaborn: продвинутая визуализация данных....................................................................... 269
Seaborn и Matplotlib: ключевые различия...................................................................... 270
Типы графиков Seaborn........................................................................................................ 271
Настройка графиков Seaborn.............................................................................................. 277
Темы и стили Seaborn............................................................................................................ 278
Интеграция Seaborn с Pandas.............................................................................................. 279
Продвинутые техники Seaborn........................................................................................... 280
Лучшие практики и советы по визуализации данных с помощью Seaborn........ 282
Scikit-learn: машинное обучение............................................................................................... 283
Ключевые понятия и терминология................................................................................. 283
Предварительная обработка данных с помощью Scikit-learn.................................. 284
Алгоритмы контролируемого обучения.......................................................................... 286
Алгоритмы неконтролируемого обучения..................................................................... 288
Оценка и выбор модели........................................................................................................ 289
Настройка гиперпараметров............................................................................................... 290
Интеграция Scikit-learn с Pandas и Numpy..................................................................... 291
Лучшие практики и советы по машинному обучению
с помощью Scikit-learn.......................................................................................................... 293
TensorFlow: глубокое обучение................................................................................................. 294
Ключевые компоненты TensorFlow.................................................................................. 294
Архитектура TensorFlow....................................................................................................... 296
TensorFlow Eager Execution................................................................................................. 297
Построение нейронных сетей с помощью TensorFlow............................................... 298
Обучение и оценка моделей в TensorFlow...................................................................... 299
Расширения и библиотеки TensorFlow............................................................................ 300
Практическое применение TensorFlow в глубоком обучении................................. 302
Keras: высокоуровневое глубокое обучение......................................................................... 303
Ключевые особенности Keras............................................................................................. 304
Параметры бэкенда Keras..................................................................................................... 304
Построение нейронных сетей с помощью Keras.......................................................... 305
Обучение и оценка моделей в Keras................................................................................. 307
Сохранение и загрузка моделей в Keras.......................................................................... 309
Настройка Keras: пользовательские слои, функции потерь и метрики............... 310
Практическое применение Keras в глубоком обучении............................................ 311
Обработка естественного языка с помощью NLTK........................................................... 314
Установка и настройка NLTK............................................................................................. 315
Токенизация.............................................................................................................................. 315
Морфологическая разметка (POS).................................................................................. 316
Распознавание именованных сущностей (NER)......................................................... 318
Парсинг и чанкинг.................................................................................................................. 319
Оглавление 13
Классификация текста с помощью NLTK...................................................................... 321
Анализ тональности текста.................................................................................................. 323
Суммаризация текста............................................................................................................ 324
Практическое применение NLTK в NLP........................................................................ 326
Лучшие практики и советы по Data Science......................................................................... 327
Понимание проблемы и определение целей.................................................................. 327
Сбор и предварительная обработка данных.................................................................. 328
Конструирование и выбор признаков.............................................................................. 329
Выбор и оценка моделей....................................................................................................... 330
Интерпретируемость и объяснимость............................................................................. 331
Коммуникация и визуализация......................................................................................... 332
Масштабируемость и развертывание............................................................................... 333
Совместная работа и контроль версий............................................................................ 335
Постоянное обучение и совершенствование................................................................. 336
Этические аспекты в Data Science..................................................................................... 337
Задания для самопроверки......................................................................................................... 338
Глава 13. Веб-скрапинг с помощью Python........................................................... 340
Области применения веб-скрапинга................................................................................ 341
Правовые и этические соображения................................................................................ 342
Компоненты веб-страницы.................................................................................................. 343
Рабочий процесс веб-скрапинга......................................................................................... 344
Основы HTML................................................................................................................................ 345
Структура HTML-документа............................................................................................. 345
Теги и элементы HTML........................................................................................................ 346
Атрибуты HTML..................................................................................................................... 348
Таблицы и списки HTML..................................................................................................... 349
HTML-формы и элементы ввода....................................................................................... 351
Концепция объектной модели документа (DOM)...................................................... 352
Библиотеки и инструменты веб-скрапинга.......................................................................... 353
Requests: HTTP для людей.................................................................................................. 353
Beautiful Soup: парсинг и навигация по HTML............................................................ 354
lxml: высокопроизводительный парсер HTML и XML............................................. 356
Selenium: автоматизация браузера для веб-скрапинга............................................... 357
Scrapy: комплексная платформа для веб-скрапинга................................................... 359
Выбор правильного инструмента для веб-скрапинга................................................. 361
Извлечение данных из веб-страниц........................................................................................ 362
Определение целевых данных............................................................................................ 362
Изучение исходного кода веб-страницы......................................................................... 363
Навигация по структуре HTML........................................................................................ 364
14 Оглавление
Работа с пагинацией и бесконечной прокруткой......................................................... 365
Работа с динамическим содержимым и JavaScript...................................................... 366
Работа с формами и сессиями................................................................................................... 367
Взаимодействие с формами................................................................................................. 368
Отправка форм и работа с перенаправлениями........................................................... 368
Управление сессиями и файлами куки............................................................................ 369
Обработка аутентификации и входа в систему............................................................ 370
Советы по работе с формами и сессиями....................................................................... 372
Парсинг XML и JSON.................................................................................................................. 373
Парсинг XML в Python......................................................................................................... 373
Парсинг JSON в Python........................................................................................................ 374
Конвертация данных из XML в JSON и наоборот...................................................... 375
Работа с API и структурированными данными............................................................ 376
Продвинутые методы веб-скрапинга...................................................................................... 377
Обработка AJAX-запросов и асинхронная загрузка................................................... 377
Обход капчи и мер по борьбе с ботами............................................................................ 379
Работа с прокси-серверами и ротация IP-адресов...................................................... 380
Веб-скрапинг с использованием многопоточности и параллелизма.................... 382
Эффективное хранение и обработка полученных данных....................................... 384
Мониторинг и сопровождение веб-скраперов.............................................................. 385
Этические и правовые соображения....................................................................................... 386
Лучшие практики и советы по веб-скрапингу..................................................................... 387
Планирование проекта веб-скрапинга............................................................................. 387
Выбор правильных инструментов и библиотек........................................................... 388
Относитесь с уважением к ресурсам сайта.................................................................... 389
Обработка ошибок и механизмы повторной попытки ............................................. 389
Внедряйте надежные решения для хранения данных................................................ 390
Мониторинг и сопровождение веб-скраперов.............................................................. 391
Документация кода и процессов веб-скрапинга.......................................................... 392
Задания для самопроверки......................................................................................................... 393
Глава 14. Программирование графических интерфейсов с помощью Python...... 395
Преимущества приложений с GUI................................................................................... 395
Популярные библиотеки GUI............................................................................................ 396
Выбор правильной GUI-библиотеки .............................................................................. 397
Основные концепции программирования GUI............................................................ 398
Наборы инструментов и фреймворки GUI........................................................................... 399
Tkinter......................................................................................................................................... 399
PyQt и PySide........................................................................................................................... 400
Оглавление 15
Kivy.............................................................................................................................................. 402
wxPython.................................................................................................................................... 403
PyGTK и PyGObject.............................................................................................................. 404
PySimpleGUI............................................................................................................................. 405
Сравнение наборов инструментов и фреймворков GUI........................................... 406
Создание GUI-приложений с помощью Tkinter................................................................. 407
Установка и настройка Tkinter........................................................................................... 408
Создание базового окна Tkinter......................................................................................... 408
Виджеты Tkinter и их свойства.......................................................................................... 409
Менеджеры геометрии: Pack, Grid и Place..................................................................... 412
Обработка событий в Tkinter.............................................................................................. 414
Создание наследуемых виджетов и компонентов....................................................... 416
Создание приложения Tkinter: пошаговый пример................................................... 418
Отладка и устранение неполадок в приложениях Tkinter....................................... 420
Продвинутые техники программирования GUI................................................................. 421
Работа с несколькими окнами и диалогами................................................................... 421
Настройка стилей и тем виджетов.................................................................................... 423
Реализация функциональности перетаскивания........................................................ 425
Создание и управление таймерами................................................................................... 427
Обработка событий клавиатуры и мыши....................................................................... 429
Многопоточность и конкурентность в GUI-приложениях ..................................... 431
Интеграция веб-контента и API........................................................................................ 433
Развертывание и распространение................................................................................... 435
Лучшие практики и советы по программированию GUI................................................. 437
Проектирование удобных для пользователя интерфейсов...................................... 437
Организация и модульность кода..................................................................................... 438
Оптимизация производительности.................................................................................. 439
Обработка ошибок и обратная связь с пользователем............................................... 440
Доступность и интернационализация............................................................................. 441
Тестирование и отладка........................................................................................................ 442
Документация и руководства пользователя.................................................................. 444
Задания для самопроверки......................................................................................................... 445
Заключение............................................................................................................ 446
Список источников................................................................................................. 447
ВВЕДЕНИЕ
Добро пожаловать в «Python с нуля»! Эта книга даст вам основные знания
и инструменты, которые помогут стать опытным разработчиком на Python —
универсальном, мощном и доступном языке программирования. Вы узнаете,
почему Python стал одним из самых популярных языков программирования
в мире и что делает его отличным выбором и для начинающих, и для опытных
разработчиков.
Эта книга приглашает вас в путешествие по огромному миру Python и охватывает
все — от самых основ до более продвинутых тем, таких как наука о данных, вебскрапинг и программирование графических интерфейсов. Каждая глава снабжена
примерами, заданиями для самопроверки и лучшими практиками, чтобы вы не
только поняли материал, но и получили практический опыт его применения.
Неважно, новичок вы или опытный разработчик, желающий расширить свои
навыки, — в этой книге найдется что-то для всех.
В первых главах вы узнаете об истории Python, настройке среды разработки
и о том, как написать свою первую программу. Затем погрузитесь в основные
понятия Python: переменные, типы данных, управляющие структуры, функции и модули. Вы изучите мощные возможности встроенных структур данных
Python — списков, кортежей и словарей.
По мере приобретения навыков работы с Python вы познакомитесь с более
продвинутыми темами, включая объектно-ориентированное программирование, обработку исключений и регулярные выражения. Узнаете, как работать
с библиотеками и API, что позволит еще больше расширить функциональность Python.
Отладка и тестирование — важнейшие аспекты любого процесса разработки программного обеспечения. Вы узнаете, как использовать популярныеинструменты
и фреймворки, например Pytest, для тестирования кода на Python, а также как
обеспечить надежность и сопровождаемость кода.
В последних главах мы углубимся в специализированные темы: науку о данных, веб-скрапинг и программирование графических интерфейсов. Вы изучите
наиболее популярные библиотеки: NumPy, Pandas, Matplotlib, Scikit-learn
и Tkinter. К концу книги у вас будет прочная основа понимания Python, а также
Введение 17
уверенность в применении полученных навыков в различных сценариях реального мира.
Python стал незаменимым языком в современном постоянно развивающемся
технологическом ландшафте. Его универсальность, читабельность и обширная
экосистема сделали его популярным выбором для широкого спектра приложений — от веб-разработки и науки о данных до искусственного интеллекта
и робототехники. Эта книга — ваш ключ к раскрытию возможностей Python
и достижению новых высот в программировании. Увлекательное путешествие
по пути открытий, изучения и освоения Python начинается!
ОБ АВТОРЕ
Петр Severa Левашов, бывший хакер, ставший специа
листом по компьютерной безопасности, привносит в это
исчерпывающее руководство по программированию на
Python поистине уникальный взгляд. Имея более чем
15-летний опыт работы с Python, Петр использовал
этот язык в различных приложениях, начиная от управления серверными ботнетами для распространения
спама и заканчивая торговлей криптовалютами. Имея
две степени магистра в области компьютерной безопасности и экономики, а также богатый опыт преподавания, Петр излагает сложную информацию в увлекательной и академически
обоснованной манере.
Родился 13 августа 1980 года в Санкт-Петербурге и прошел увлекательный путь,
который привел его к тому, что он стал всемирно известным экспертом в своей
области. Под псевдонимом Peter Severa когда-то руководил тремя крупными
ботнетами для рассылки p2p-спама — Storm Worm, Waledac и Kelihos (Hlux), был
модератором нескольких хакерских и кардерских форумов, включая легендарный
carderplanet.com. В 2017 году арестован в Испании и экстрадирован в США, где
ему были предъявлены обвинения. Частично признал себя виновным в обмен
на снятие более серьезных обвинений.
Из этого опыта Петр извлек ценные жизненные уроки и теперь полностью
посвящает себя честным и законным занятиям. В частности, стал успешным
криптотрейдером с собственным алгоритмом, включающим ценовое действие
и искусственный интеллект. Более подробную информацию о его торговом
подходе ищите на сайте SeveraDAO.ai. Будучи твердым приверженцем свободы
распространения информации, Петр стремится поделиться своими обширными
знаниями с другими.
В этой книге Петр объединяет свои уникальные знания и предоставляет всеобъемлющий и увлекательный опыт обучения. Умение автора объяснять сложные
концепции простыми словами делает эту книгу бесценной для всех, кто хочет
освоить программирование на Python.
Дополнительную информацию об авторе вы найдете на сайте www.SeveraDAO.ai.
Об авторе 19
Петр также хотел бы выразить благодарность своему сыну Никите, без пытливых
вопросов которого эта книга вряд ли увидела бы свет, и своей любимой жене
Марии за ее постоянную поддержку, заботу и любовь. А также великолепному
адвокату Ольге Леонидовне Исянамановой за ее профессиональную работу. Потрясающее владение УК РФ и его правоприменительной практикой, огромный
опыт, честное и открытое общение с клиентами и адекватный подход к цено
образованию — что еще нужно от адвоката? Проблемы? Лучше звоните Ольге!
ОТ ИЗДАТЕЛЬСТВА
Ваши замечания, предложения, вопросы отправляйте по адресу comp@piter.com
(издательство «Питер», компьютерная редакция).
Мы будем рады узнать ваше мнение!
На веб-сайте издательства www.piter.com вы найдете подробную информацию
о наших книгах.
Глава 1
ВВЕДЕНИЕ В ПРОГРАММИРОВАНИЕ
НА PYTHON
Что такое Python
Python — это универсальный язык программирования высокого уровня, который легко изучать и читать и на котором просто писать. В 1991 году Гвидо ван
Россум впервые опубликовал исходный код Python, и с тех пор он стал одним
из самых популярных языков программирования в мире.
Python обладает рядом особенностей, которые делают его отличным выбором
как для начинающих, так и для опытных программистов. Одна из ключевых
особенностей Python — читаемость. Код на Python легко читается и понимается, что облегчает его изучение и сопровождение. Python также имеет простой
и интуитивно понятный синтаксис, это означает, что разработчики могут писать
код быстрее и с меньшим количеством ошибок.
Еще одна причина популярности языка — его универсальность. Python можно
использовать для широкого спектра приложений, включая веб-разработку, научные вычисления, искусственный интеллект и анализ данных. Python также
имеет большое и активное сообщество разработчиков, которые вносят свой вклад
в создание различных библиотек и инструментов с открытым исходным кодом.
Python — интерпретируемый язык, а это означает, что его интерпретатор выполняет код напрямую, без необходимости компиляции. Это делает код Python
легким для тестирования и отладки, а также позволяет разработчикам быстро
повторять код и экспериментировать с ним.
Python — отличный выбор для всех, кто хочет научиться программированию.
Его простота, читабельность и универсальность делают его отличным языком
для начинающих, а мощные возможности и активное сообщество делают его
ценным инструментом для опытных разработчиков.
22 Глава 1 Введение в программирование на Python
История Python
История языка программирования Python началась в конце 1980-х. Гвидо ван
Россум — голландский ученый-компьютерщик, который в то время работал
в научно-исследовательском институте Centrum Wiskunde & Informatica в Амстердаме, начал работу над Python в качестве хобби. Он намеревался создать
язык, который было бы легко читать и писать.
Первая версия Python, 0.9.0, была выпущена в феврале 1991 года. Это был простой язык с базовыми типами данных, управляющими структурами и функциями,
но он быстро завоевал популярность среди небольшого сообщества разработчиков, которые его использовали.
В 1994 году была выпущена версия Python 1.0, где появились новые возможности: инструменты функционального программирования и система
модулей. Эта версия Python также включала систему Python Enhancement
Proposals (PEPs), которая позволяла разработчикам предлагать и обсуждать
изменения в языке.
Python 2.0 был выпущен в 2000 году, в него были включены сборка мусора
и поддержка Unicode. За Python 2.0 последовало несколько других релизов
в серии 2.x, включая Python 2.7, который был выпущен в 2010 году и широко
используется по сей день.
В 2008 году началась разработка Python 3.0, целью которой было устранение
некоторых недостатков и несоответствий в Python 2.x. Python 3.0 был выпущен в 2008 году и внес в язык несколько серьезных изменений, включая новую
функцию print, улучшенную поддержку Unicode и упрощенный синтаксис для
определения классов.
Сегодня Python — один из самых популярных языков программирования в мире
с большим и активным сообществом разработчиков, которые вносят свой вклад
в создание различных библиотек и инструментов с открытым исходным кодом.
Установка Python и среды разработки
Для начала нужно установить Python на свой компьютер. Это бесплатный язык
с открытым исходным кодом, его можно загрузить с официального сайта Python
по адресу www.python.org.
Есть две основные версии Python: Python 2.x и Python 3.x. Хотя Python 2.x
все еще используется в некоторых старых приложениях, для новых проектов
рекомендую использовать Python 3.x, поскольку это последняя версия языка,
имеющая несколько важных улучшений по сравнению с Python 2.x.
Вы можете загрузить программу установки с официального сайта и следовать
инструкциям по установке. В процессе установки можно выбрать глобальную
Интерпретатор Python и REPL (Read-Eval-Print Loop) 23
установку Python на своем компьютере или локальную в определенном ка
талоге.
Помимо самого Python вам может понадобиться установить среду разработки,
которая поможет писать код Python и управлять им. Среда разработки — это
приложение, которое предоставляет инструменты для написания, тестирования
и отладки кода. Некоторые популярные среды разработки для Python включают
PyCharm, Visual Studio Code и Sublime Text.
При выборе среды разработки следует учитывать ее простоту использования,
поддержку библиотек и инструментов Python и совместимость с вашей операционной системой. Многие среды разработки предлагают автодополнение кода,
подсветку синтаксиса и инструменты отладки, которые помогут писать код более
эффективно и с меньшим количеством ошибок.
После установки Python и среды разработки можно приступать к написанию
кода на Python! В следующем разделе рассмотрим основы написания и выполнения программ на Python.
Интерпретатор Python и REPL (Read-Eval-Print Loop)
Одна из уникальных особенностей Python — его интерактивный режим, который
позволяет выполнять код и сразу же видеть результаты. Это возможно благодаря
интерпретатору Python, который представляет собой программу, читающую
и выполняющую код Python.
Когда вы устанавливаете Python на свой компьютер, он включает интерактивный
интерпретатор цикл чтения-вывода-печати (REPL). REPL позволяет вводить код
по одной строке за раз и сразу же видеть результаты. Чтобы запустить Python
REPL, откройте терминал или командную строку и введите python.
Запустите интерпретатор Python, введите код и нажмите Enter, чтобы посмотреть
результаты. Например, чтобы вывести на экране «Привет, мой новый друг»,
наберите такой код:
>>> print("Привет, мой новый друг!")
Привет, мой новый друг!
>>> — это подсказка, которую интерпретатор Python выводит на экран, чтобы
показать, что он готов к вводу кода. Интерпретатор оценит код и выведет результат на следующей строке.
Помимо интерактивного режима, можно записать код в файл и выполнить его
из командной строки. Для этого создайте новый текстовый файл и сохраните
его с расширением .py (например, myprogram.py). Затем запустите программу,
набрав python myprogram.py в командной строке.
24 Глава 1 Введение в программирование на Python
Интерпретатор Python и REPL — это мощные инструменты для написания
и тестирования кода Python. Используя интерактивный режим, можно быстро
экспериментировать с различными фрагментами кода и сразу же видеть результаты. В следующем разделе рассмотрим основы написания кода в файле и его
запуск из командной строки.
Ваша первая программа на Python
Теперь, когда у вас установлен Python и есть базовое понимание того, как использовать интерпретатор, напишем нашу первую программу на Python!
В Python программа — это набор операторов, которые выполняются по порядку.
Оператор — это строка кода, которая выполняет определенное действие, например выводит сообщение на экране или вычисляет значение.
Откройте текстовый редактор (например, Notepad или Sublime Text) и создайте
новый файл. Сохраните файл с расширением .py, которое указывает, что это
программа на Python. Например, program.py.
Затем введите следующий код:
print("Я готов, хозяин!")
Код говорит Python вывести на экран сообщение «Я готов, хозяин!». Функция
print — это встроенная функция в Python, позволяющая выводить текст на экран.
После того как вы ввели код, сохраните файл и выйдите из текстового редактора.
Теперь откройте окно командной строки или терминала и перейдите в каталог,
где сохранили файл. Введите python program.py и нажмите Enter.
Python выполнит код в файле и выведет на экран сообщение «Я готов, хозяин!».
Поздравляю, вы только что написали и запустили свою первую программу на
Python!
Конечно, это только начало того, что можно сделать с помощью Python. В следующем разделе рассмотрим некоторые основные концепции программирования
в Python, включая переменные, типы данных и операторы.
Синтаксис и основные концепции
программирования
Рассмотрим основные концепции программирования в Python, включая синтаксис, переменные, типы данных и операторы.
Запуск программ на Python 25
Синтаксис относится к правилам и рекомендациям по написанию кода Python.
В этом языке утверждения обычно пишутся на отдельных строках, а для обозначения блоков кода используются отступы.
Например, следующий код создает переменную и присваивает ей значение:
x = 33
Знак равенства (=) используется для присвоения значения переменной. Переменные предназначены для хранения значений, которые могут быть использованы в программе позже.
Python поддерживает несколько типов данных, включая целые числа, числа
с плавающей точкой, строки и булевы значения. Целочисленные данные — это
целые числа (например, 1, 2, 3), числа с плавающей точкой — это десятичные
числа (например, 9.99, 3.1415), а строки — это последовательности символов
(например, «робот», «хозяин»). Булевы значения — True или False.
Операторы используются для выполнения операций над переменными и значениями. Python поддерживает несколько операторов, включая арифметические
операторы (+, –, *, /), операторы сравнения (==, !=, ) и логические операторы
(and, or, not). В следующем коде для выполнения вычислений используются
арифметические операторы:
x = 30
y = 3
z = x + y
print(z) # Вывод: 33
В этом примере знак «плюс» (+) используется для сложения значений x и y,
а результат сохраняется в переменной z. Затем функция print используется
для вывода значения z на экран.
Изучив синтаксис, переменные, типы данных и операторы, вы сможете писать
простые программы на Python, выполняющие полезные задачи. В следующем
разделе рассмотрим управляющие структуры, которые позволяют управлять
работой программы на основе условий и циклов.
Запуск программ на Python
После написания программы на Python ее нужно запустить, чтобы увидеть
результаты. В этом разделе рассмотрим способы запуска программ.
Самый простой способ — использовать интерпретатор Python, о чем говорилось
в предыдущем разделе. Откройте окно командной строки или терминала, перей
дите в каталог, где сохранена программа на Python, и введите python program.py
26 Глава 1 Введение в программирование на Python
(замените program.py именем файла вашей программы). Интерпретатор Python
выполнит код, содержащийся в файле, и выведет результат.
Другой способ — использовать интегрированную среду разработки (IDE),
например PyCharm или Visual Studio Code. IDE предоставляет более совершенную среду для написания, отладки и тестирования кода. Чтобы запустить
программу в IDE, откройте файл программы и воспользуйтесь командой IDE
run или execute.
Если вы пишете программу для веб-приложения или сервера, может понадобиться запустить программу с помощью веб-сервера, например Apache или
Nginx. В этом случае для обработки запросов и ответов от веб-сервера обычно
используется веб-фреймворк, например Django или Flask.
Независимо от того, как вы решите запустить свою программу, важно тщательно
протестировать ее и убедиться, что она работает так, как ожидается. Это включает
в себя тестирование пограничных состояний, обработку ошибок и исключений,
а также проверку входных и выходных данных.
Основные методы отладки
Отладка — важная часть программирования, поскольку позволяет находить
и исправлять ошибки в коде. В этом разделе рассмотрим некоторые основные
методы отладки, которые можно использовать для выявления и устранения
проблем в программах на Python.
Первый шаг в отладке — понять суть проблемы. Часто это включает в себя
изучение выходных данных программы и поиск ошибок или неожиданного
поведения. Можно использовать ведение журналов и операторы print, чтобы
вывести информацию о состоянии программы в разных местах кода.
Следующий шаг после определения проблемы — изолировать ее причину. Для
этого часто используется процесс исключения, чтобы определить части кода,
вызывающие проблему. Можно использовать точки останова и пошаговую
отладку, чтобы построчно изучить код и увидеть, как изменяются переменные
и значения.
Помимо изучения кода, можно использовать сообщения об ошибках и трассировку стека, чтобы точно определить местоположение проблемы. Сообщения
об ошибках предоставляют информацию о типе и месте ошибки, а трассировка
стека показывает последовательность вызовов функций, которые привели
к ошибке.
После выявления причины проблемы ее нужно устранить. Для этого вносят
изменения в код и снова тестируют программу, чтобы убедиться, что проблема
решена. Можно использовать инструменты автоматизированного тестирования
Ресурсы для изучения Python 27
и код-ревью, чтобы убедиться, что изменения не приведут к появлению новых
проблем.
Стиль кода Python и лучшие практики
Стиль кода и лучшие практики важны для написания читабельного, удобного
и эффективного кода Python. В этом разделе рассмотрим ключевые принципы
стиля и лучшие практики.
Во-первых, при написании кода на Python важно придерживаться последовательного стиля. PEP 8 — официальное руководство по стилю Python — содержит
рекомендации по оформлению кода, отступам, соглашениям об именовании
и т. д. Придерживаясь единого стиля, вы можете писать простой в чтении и понимании код.
Важно писать модульный и переиспользуемый код. Это предполагает разбиение
кода на небольшие, независимые функции или модули, которые можно использовать в разных частях программы. Так вы облегчите тестирование и отладку
кода, а также снизите риск ошибок.
Используйте описательные имена переменных и комментарии для пояснения
кода. Это облегчает другим разработчикам понимание вашего кода и снижает
риск путаницы или ошибок.
Тщательно тестируйте код, чтобы убедиться, что все работает так, как ожидается.
Это включает использование инструментов автоматизированного тестирования
и написание юнит-тестов для проверки отдельных функций или модулей.
Наконец, следите за последними возможностями Python и лучшими практиками. Сообщество Python постоянно развивается, регулярно выпускаются новые
функции и инструменты. Оставаясь в курсе последних событий, вы сможете
писать более эффективный и действенный код.
Ресурсы для изучения Python
Python — популярный и широко используемый язык программирования, есть
множество ресурсов для его изучения и освоения. Рассмотрим некоторые из
лучших ресурсов для изучения Python: от онлайн-туториалов и курсов до книг
и документации.
Онлайн-туториалы и курсы — отличный способ начать изучение Python. Они
обеспечивают структурированную среду обучения и часто включают интерактивные примеры и упражнения. Популярные онлайн-ресурсы для изучения
Python — Codecademy, Coursera, Udemy и edX.
28 Глава 1 Введение в программирование на Python
Книги — это тоже отличный вариант, поскольку они дают всестороннее и глубокое представление о языке и его возможностях. Вот некоторые популярные книги
для изучения Python: Python Crash Course1 Эрика Мэтиза, Python for Everybody
Чарльза Северанса и Learning Python Марка Лутца.
Документация — еще один важный ресурс для изучения, поскольку в ней содержится подробная информация о языке и его возможностях. Официальная
документация Python доступна на сайте docs.python.org, и это всеобъемлющий
ресурс для разработчиков Python всех уровней.
Наконец, сообщество Python — это ценный ресурс для освоения языка. Есть
множество групп пользователей Python и онлайн-форумов, где разработчики
общаются друг с другом, делятся знаниями и опытом, а также получают помощь
по конкретным вопросам.
1
Мэтиз Э. Изучаем Python. Программирование игр, визуализация данных,
веб-приложения. — СПб.: Питер, 2016.
Глава 2
ПЕРЕМЕННЫЕ, ТИПЫ ДАННЫХ
И ОПЕРАТОРЫ
Переменные — важная часть программирования на Python, они позволяют
хранить значения и манипулировать ими в коде. Переменная — это, по сути,
именованный контейнер, в котором хранится значение. Оно может быть числом,
строкой или любым другим типом данных.
Чтобы создать переменную в Python, достаточно выбрать имя переменной и присвоить ей значение с помощью знака равенства (=). Например, следующий код
создает переменную с именем x и присваивает ей значение 33:
x = 33
В этом коде x — имя переменной, а 33 — значение, которое ей присваивается.
После создания переменной ее можно использовать в коде для выполнения вычислений, хранения результатов или манипулирования данными.
Имена переменных в Python должны следовать определенным правилам и соглашениям. Например, имена переменных не могут начинаться с цифры и содержать пробелы. Хорошей практикой будет использование описательных имен
переменных, которые отражают цель или смысл хранимого значения.
Переменные могут хранить различные типы данных в Python, включая числовые
типы данных, — целые числа и числа с плавающей точкой, а также строковые
типы и булевы значения. Далее рассмотрим некоторые распространенные типы
данных в Python и работу с ними.
Соглашения об именовании переменных
Имена переменных в Python должны соответствовать определенным соглашениям, чтобы код был удобочитаемым и понятным другим разработчикам.
Ниже приведены основные соглашения об именах, которым нужно следовать
при создании переменных в Python.
30 Глава 2 Переменные, типы данных и операторы
1. Используйте описательные имена: имена переменных должны отражать
цель или смысл хранимого значения. Это облегчает другим разработчикам
понимание кода.
2. Используйте строчные буквы: в Python имена переменных следует писать
строчными буквами, разделяя слова подчеркиванием. Например, my_variable_name — это правильное имя переменной в Python.
3. Избегайте использования зарезервированных слов: в Python есть набор зарезервированных слов, которые имеют особое значение в языке, например
if, else и while. Не используйте эти слова в качестве имен переменных.
4. Используйте верблюжий регистр для имен классов: если вы создаете класс,
имя должно быть написано в верблюжьем регистре, с заглавной первой
буквой в каждом слове. Например, MyClassName — это правильное имя
класса в Python.
5. Будьте последовательны: последовательность — важный момент в именовании переменных. Используйте одинаковые соглашения об именовании
во всем коде, чтобы его было легко читать и понимать.
Основные типы данных
Python поддерживает несколько основных типов данных, включая числовые,
строковые и булевы значения. Вот краткий обзор некоторых типов данных.
1. Целочисленные значения: целые числа, 1, 2, 3 и т. д. Они представлены
с помощью типа данных int.
2. Числа с плавающей точкой: десятичные числа, 9,99 или 3,1415. Они представлены с помощью типа данных float.
3. Строка: последовательность символов, например "робот" или "хозяин". Они
представлены с помощью типа данных str.
4. Булевы значения: True или False . Они представлены с помощью типа
данных bool.
5. None: специальный тип данных, который представляет отсутствие значения.
Он часто используется для представления переменных, которые еще не
инициализированы или не имеют значения.
В Python переменные могут содержать различные типы данных в зависимости
от значения, которое им присваивается. Например, следующий код создает две
переменные, x и y, и присваивает им значения 33 и 3.1415 соответственно:
x = 33
y = 3.1415
В этом коде x — целочисленная переменная, а y — переменная с плавающей
точкой.
Строковый тип данных 31
Далее рассмотрим, как работать с этими типами данных, выполнять вычисления
и манипулировать строками.
Числовые типы данных
Числовые типы данных используются для представления чисел. Python поддерживает несколько числовых типов данных, включая целые числа, числа
с плавающей точкой и комплексные числа.
Целочисленные значения — это целые числа, такие как 1, 2, 3. Они представлены
с помощью типа данных int. Над целыми числами можно выполнять арифметические операции: сложение (+), вычитание (–), умножение (*) и деление (/).
Например, следующий код выполняет несколько основных арифметических
операций над целыми числами:
x = 30
y = 3
print(x
print(x
print(x
print(x
+
—
*
/
y)
y)
y)
y)
#
#
#
#
Вывод:
Вывод:
Вывод:
Вывод:
33
27
90
10.0
Знак «плюс» (+) используется для сложения значений x и y, знак «минус» (-) —
для вычитания значения y из x, звездочка (*) — для умножения, а слеш (/) —
для деления x на y.
Числа с плавающей точкой — это десятичные числа. Они представлены с помощью типа данных float. Вы можете выполнять арифметические операции
над числами с плавающей точкой так же, как и над целыми числами. Однако
из-за того, как числа с плавающей точкой представлены в памяти, вы можете
столкнуться с ошибками округления или неточностями в вычислениях.
Комплексные числа — это числа, которые имеют как действительную, так
и мнимую часть. Они представлены с помощью типа данных complex. Вы можете
создать комплексное число, указав действительную и мнимую части с помощью
суффикса j. Например, следующий код создает комплексное число:
z = 30 + 3j
В этом коде z — комплексное число с действительной частью 30 и мнимой частью 3.
Строковый тип данных
Строка — это последовательность символов, например "робот" или "хозяин".
В Python строки представлены с помощью типа данных str. Вы можете создать
32 Глава 2 Переменные, типы данных и операторы
строку, заключив текст в одинарные или двойные кавычки. Например, следующий код создает строку:
string1 = "Привет, хозяин!"
В этом коде string1 — это строковая переменная, которая содержит значение
Привет, хозяин!.
Строки в Python рассматриваются как объекты, это означает, что над ними
можно выполнять операции и методы. Вот некоторые общие операции и методы,
которые можно использовать со строками в Python:
yy Конкатенация: можно объединить две строки или более вместе с помощью
оператора «плюс» (+). Следующий код объединяет две строки:
first_name = "Петр"
last_name = "Левашов"
full_name = first_name + " " + last_name
print(full_name) # Вывод: Петр Левашов
yy Длина: можно найти длину строки с помощью функции len(). Следующий
код определяет длину строки:
string2 = "Привет, хозяин!"
length = len(string2)
print(length) # Вывод: 14
yy Индексирование: можно получить доступ к отдельным символам в строке
с помощью индексации. Индексация в Python начинается с 0, это означает,
что первый символ в строке имеет индекс 0. Следующий код получает доступ
ко второму символу в строке:
string3 = "Привет, робот!"
второй_знак = string3[1]
print(second_char) # Вывод: e
yy Нарезка: можно извлечь подстроку из строки с помощью нарезки (слайсинга). Нарезка позволяет указать диапазон индексов для извлечения из строки.
Следующий код извлекает подстроку из строки:
string4 = "Робот готов!"
substring = string4[0:5]
print(substring) # Вывод: Робот
Булев тип данных
Булево значение — это значение, являющееся либо истинным, либо ложным. Они представлены с помощью типа данных bool . Булевы значения
часто используются в программировании для представления условий или
состояний.
Приведение типов 33
Например, можно использовать булево значение для представления того, является условие истинным или ложным. Следующий код создает булеву переменную
is_robot и присваивает ей значение True:
is_robot = True
В этом коде is_robot — булева переменная, которая имеет значение True.
В Python можно выполнять булевы операции с помощью следующих операторов:
yy Логическое И: логический оператор AND (И) возвращает значение True, если
оба операнда равны True. Например:
a = True
b = False
print(a and b) # Вывод: False
yy Логическое ИЛИ: логический оператор OR (ИЛИ) возвращает True, если
хотя бы один операнд равен True. Например:
a = True
b = False
print(a or b) # Вывод: True
Булевы значения также можно сравнивать с помощью операторов сравнения,
таких как оператор равенства (==) или неравенства (!=). Например:
x = 30
y = 3
print(x == y) # Вывод: False
print(x != y) # Вывод: True
В этом коде оператор == возвращает False, потому что x не равен y, а оператор !=
возвращает True, потому что x не равен y.
Приведение типов
Приведение, или преобразование, типов — это процесс преобразования одного
типа данных в другой. В Python преобразование типов можно выполнять с помощью встроенных функций, предназначенных для каждого типа данных.
Например, можно преобразовать строку в целое число с помощью функции int().
Следующий код преобразует строковую переменную string5 в целое число:
string5 = "33"
int5 = int(string5)
34 Глава 2 Переменные, типы данных и операторы
В этом коде string5 — это строковая переменная, которая содержит значение 33,
а int5 — целочисленная переменная, которая содержит преобразованное значение.
Аналогично можно преобразовать целое число в строку с помощью функции
str(). Следующий код преобразует целочисленную переменную int6 в строку:
int6 = 33
string6 = str(int6)
В этом коде int6 — это целочисленная переменная, которая содержит значение
33 , а string6 — строковая переменная, которая содержит преобразованное
значение.
Можно выполнять преобразование типов между числовыми типами данных,
например преобразовать целое число в число с плавающей точкой с помощью
функции float().
Важно отметить, что не все преобразования типов являются действительными
или осмысленными. Например, вы не cможете преобразовать строку, содержащую
буквы, в целое число, поскольку она не имеет числового значения.
Преобразование типов в Python поможет манипулировать типами данных и преобразовывать их по мере необходимости. При этом важно знать ограничения
и правила преобразования типов, чтобы избежать ошибок и неожиданного поведения в коде.
Арифметические операторы
Арифметические операторы используются для выполнения основных математических операций. Python поддерживает следующие арифметические операторы.
1. Сложение (+): складывает два значения вместе.
2. Вычитание (-): вычитает одно значение из другого.
3. Умножение (*): перемножает два значения вместе.
4. Деление (/): делит одно значение на другое.
5. Получение остатка от деления (%): возвращает остаток от операции деления.
6. Возведение в степень (**): возводит одно значение в степень другого значения.
Следующий код использует арифметические операторы для выполнения некоторых базовых вычислений:
x = 30
y = 3
# Сложение
result1 = x + y
print(result1) # Вывод: 33
Операторы сравнения 35
# Вычитание
result2 = x — y
print(result2) # Вывод:
# Умножение
result3 = x * y
print(result3) # Вывод:
# Деление
result4 = x / y
print(result4) # Вывод:
# Остаток от деления
result5 = x % y
print(result5) # Вывод:
# Возведение в степень
result6 = x ** y
print(result6) # Вывод:
27
90
10.0
0
27000
В этом коде переменные x и y содержат значения 30 и 3 соответственно. Арифметические операторы используются для выполнения операций сложения,
вычитания, умножения, деления, получения остатка от деления и возведения
в степень. Результаты сохраняются в разных переменных.
Операторы сравнения
Операторы сравнения используются для сравнения двух значений и возвращают
булево значение (True или False) на основе результата сравнения. Python поддерживает следующие операторы сравнения.
1. Равно (==): возвращает True, если два значения равны.
2. Не равно (!=): возвращает True, если два значения не равны.
3. Больше чем (>): возвращает True, если первое значение больше второго.
4. Меньше чем (=): возвращает True, если первое значение больше или
равно второму.
6. Меньше или равно ( y
print(result3) # Вывод: True
36 Глава 2 Переменные, типы данных и операторы
# Меньше, чем
result 4 = x < y
print(result4) # Вывод: False
# Больше или равно
result 5 = x >= y
print(result5) # Вывод: True
# Меньше или равно
result6 = x 4
б) 9 < 2
в) 11 == 11
г) 1986 != 1986
7. Используя логические операторы, определите истинность следующих выражений:
а) True and False.
б) True or False;
в) not True.
8. Что выведет этот код? Объясните приоритет оператора и ассоциативность.
result = 2 + 3 * 4 — 6 / 2 + 5 * 3 — 4 / 2 + 1
print(result)
9. Напишите код, который вычисляет и выводит площадь прямоугольника,
учитывая его ширину w = 4 и высоту h = 9. Используйте соответствующие
имена переменных и арифметические операторы.
10. Что выведет этот код? Почему?
a = 4
b = 6
c = 8
result = a < b and b < c or a > b
print(result)
Глава 3
УПРАВЛЯЮЩИЕ СТРУКТУРЫ:
УСЛОВНЫЕ ОПЕРАТОРЫ И ЦИКЛЫ
Условные операторы: if, elif и else
Условные операторы используются для управления ходом выполнения в программах. Они позволяют проверять наличие определенных условий и выполнять
определенный код на основе результата выполнения условия.
Основной условный оператор в Python — if. Он проверяет условие и выполняет
блок кода, если условие True.
Пример:
x = 33
i x > 3:
print("x больше 3")
# Вывод: x больше 3
Оператор if проверяет, больше ли x, чем 3, и если да, то выполняет оператор
print, который выводит x больше 3.
Вы также можете использовать оператор else для выполнения блока кода, если
условие в операторе if равно False.
Пример:
x = 1
if x > 3:
print("x больше 3")
else:
print("x меньше или равно 3")
# Вывод: x меньше или равно 3
В этом коде оператор if проверяет, больше ли x, чем 3, но поскольку это не так,
выполняется оператор else, который выводит x меньше или равно 3.
40 Глава 3 Управляющие структуры: условные операторы и циклы
Вы также можете использовать оператор elif для проверки дополнительных
условий. Оператор elif сокращенно называется else if и позволяет проверить
несколько условий в одном блоке кода. Пример:
x = 3
if x > 3:
print("x больше 3")
elif x < 3:
print("x меньше 3")
else:
print("x равно 3")
# Вывод: x равно 3
В этом коде оператор if проверяет, больше ли x, чем 3, но поскольку это не так,
выполняется оператор elif, который проверяет, меньше ли x, чем 3. Поскольку
он также не меньше 3, выполняется оператор else, который выводит x равно 3.
Булевы выражения и операторы сравнения
Булево выражение — это выражение, результатом которого является значение
логического типа данных: True или False. Булевы выражения обычно используются в условных операторах и циклах для управления потоком выполнения
на основе определенного условия.
Операторы сравнения используются для сравнения двух значений и возвращают
булево значение, основанное на результате сравнения. Python поддерживает
следующие операторы сравнения.
1. Равно (==): возвращает True, если два значения равны.
2. Не равно (!=): возвращает True, если два значения не равны.
3. Больше чем (>): возвращает True, если первое значение больше второго.
4. Меньше чем (=): возвращает True, если первое значение больше или
равно второму.
6. Меньше или равно ( y
print(result) # Вывод:
# Меньше, чем
result = x < y
print(result) # Вывод:
# Больше или равно
result = x >= y
print(result) # Вывод:
# Меньше или равно
result = x 20 and y < 10
print(result) # Вывод: True
# Логическое ИЛИ
result = x < 20 or y > 10
print(result) # Вывод: False
# Логическое НЕ
result = not (x > y)
print(result) # Вывод: False
В этом коде булевы выражения комбинируются с помощью булевых операторов and, or и not для создания более сложных условий.
Циклы: for и while
Циклы используются для многократного выполнения блока кода до тех пор,
пока не будет выполнено определенное условие. В Python есть два типа циклов:
циклы for и while.
42 Глава 3 Управляющие структуры: условные операторы и циклы
Цикл for используется для итерации последовательности (например, списка,
кортежа или строки) и выполнения блока кода для каждого элемента в последовательности. Пример:
colors = ["green", "yellow", "red"]
for color in colors:
print(color)
В этом коде цикл for проходит по списку colors и выполняет оператор print
для каждого элемента списка, в результате чего получается вывод:
green
yellow
red
Цикл while используется для многократного выполнения блока кода до тех пор,
пока определенное условие не будет равно True. Пример:
x = 0
while x < 3:
print(x)
x += 1
В этом коде цикл while выполняет оператор print до тех пор, пока значение x
меньше 3. Оператор x += 1 увеличивает значение x на 1 на каждой итерации, что
в конечном итоге делает условие x < 3 ложным, и цикл завершается:
0
1
2
В дополнение к циклам for и while Python также поддерживает операторы управления циклами, которые позволяют управлять потоком выполнения в циклах.
Есть три оператора управления циклами:
yy break — преждевременное завершение цикла;
yy continue — пропускает текущую итерацию цикла и переходит к следующей
итерации;
yy pass — ничего не делает и используется в качестве заполнителя.
Операторы break, continue и pass
Операторы управления циклами используются для управления потоком выполнения в циклах. В Python есть три оператора управления циклами — break,
continue и pass.
Оператор break используется для преждевременного завершения цикла. Когда
внутри цикла встречается оператор break, цикл немедленно завершается, а выполнение программы продолжается после цикла.
Операторы break, continue и pass 43
Пример:
colors = ["green", "yellow", "red"]
for color in colors:
if color == "red":
break
print(color)
В этом коде цикл for проходит по списку colors и выполняет оператор print для
каждого элемента списка. Но когда цикл встречает элемент red, выполняется
оператор break, который преждевременно завершает цикл и останавливает выполнение программы после цикла:
green
yellow
Оператор continue используется для пропуска текущей итерации цикла и перехода к следующей итерации. Когда внутри цикла встречается оператор continue,
цикл пропускает текущую итерацию и переходит к следующей. Пример:
colors = ["green", "yellow", "red"]
for color in colors:
if color == "yellow":
continue
print(color)
Цикл for проходит по списку colors и выполняет оператор print для каждого
элемента списка. Когда цикл встречает элемент yellow, выполняется оператор continue, который пропускает текущую итерацию и переходит к следующей. Вывод:
green
red
Оператор pass используется в качестве заполнителя. Когда оператор pass
встречается внутри цикла, он ничего не делает, и выполнение программы продолжается со следующей итерации. Пример:
colors = ["green", "yellow", "red"]
for color in colors:
if fruit == "yellow":
pass
else:
print(color)
В этом коде цикл for проходит по списку colors и выполняет оператор print для
каждого элемента списка. Когда цикл встречает элемент yellow, выполняется
оператор pass, который ничего не делает, и выполнение программы продолжается
со следующей итерации. Вывод:
green
red
44 Глава 3 Управляющие структуры: условные операторы и циклы
Вложенные циклы и условия
Вложенные циклы и условия используются для создания более сложных условий и итераций по многомерным структурам данных. Вложенный цикл — это
цикл внутри другого цикла, а вложенное условие — это условие внутри другого
условия.
Пример вложенного цикла:
cars = ["Mercedes", "BMW", "Audi"]
colors = ["red", "green", "blue"]
for car in cars:
for color in colors:
print(car, color)
В этом коде есть два вложенных цикла. Внешний цикл проходит по списку cars,
а внутренний — по списку colors. Оператор print выполняется для каждой
комбинации car и color:
Mercedes red
Mercedes green
Mercedes blue
BMW red
BMW green
BMW blue
Audi red
Audi green
Audi blue
Пример вложенного условия:
x = 30
y = 3
if x > 27:
if y > 1:
print("x is greater than 27 and y is greater than 1")
else:
print("x is greater than 27 but y is not greater than 1")
else:
print("x is not greater than 27")
В этом коде есть два вложенных условия. Внешнее условие проверяет, больше
ли x, чем 27, и если да, то внутреннее условие проверяет, больше ли y, чем 1. В зависимости от результата условия выполняется соответствующий оператор print.
# Вывод: x is greater than 27 and y is greater than 1
Задания для самопроверки 45
Задания для самопроверки
1. Объясните назначение каждой из этих управляющих структур: if, elif
и else. Приведите простой пример для каждой из них.
2. Напишите код, который использует условный оператор, чтобы определить,
является число x = 33 четным или нечетным. Выведите результат.
3. Что выведет этот код? Почему?
x = 55
if x > 13:
print("x больше 13")
elif x > 51:
print("x больше 51")
else:
print("x меньше или равно 51")
4. Зачем нужен цикл в программировании? Объясните разницу между циклами
for и while. Приведите простой пример для каждого из них.
5. Напишите код, который вычисляет сумму всех целых чисел от 13 до 1 с помощью цикла for.
6. Напишите код, который вычисляет факториал числа n = 6 с помощью цикла
while.
7. Объясните назначение управляющих операторов цикла break, continue
и pass. Приведите простой пример для каждого из них.
8. Что выведет этот код? Почему?
for i in range(3, 8):
if i % 2 == 0:
continue
print(i)
9. Используя вложенные циклы for, напишите код, который выводит таблицу
умножения (от 1 до 20).
10. Что выведет этот код? Почему?
x = 0
while x < 6:
y = 0
while y < 3:
print(f "x: {x}, y: {y}")
y += 1
x += 1
Глава 4
ФУНКЦИИ И МОДУЛИ
Функции — это фундаментальная концепция в программировании. Они используются для разбиения программы на более мелкие и управляемые части.
Функция — это блок многократно используемого кода, который выполняет
определенную задачу и может быть вызван из других частей программы.
Функции полезны по нескольким причинам:
yy делают код более модульным и легко читаемым;
yy уменьшают количество дублирования кода в программе;
yy помогают разбить сложные задачи на мелкие управляемые части.
Определение и вызов функций
В Python функция определяется с помощью ключевого слова def, за которым
следует имя функции, а параметры функции заключаются в круглые скобки.
Пример:
def welcome(name):
print("Hello, my dear " + name + "!")
В этом коде функция welcome принимает один параметр, name, и выводит приветствие. Чтобы вызвать эту функцию, укажите значение параметра name, как
показано ниже:
welcome("Peter")
Вывод:
Hello, my dear Peter!
Функции также могут возвращать значения с помощью ключевого слова return:
def square(a):
return a ** 2
Параметры и аргументы функции 47
В этом коде функция square принимает параметр a и возвращает квадрат этого
значения. Чтобы вызвать эту функцию и получить результат, нужно присвоить
вызов функции переменной:
res = square(5)
print(res)
Вывод:
25
Параметры и аргументы функции
В Python параметр функции — это переменная, которая определяется в заголовке функции и используется для получения входных значений при вызове
функции. Аргумент — это значение, которое передается функции при ее вызове.
Это может быть как переменная, так и литерал.
В Python есть три типа параметров функций.
Позиционные аргументы
Это наиболее распространенный тип параметров — они определяются в заголовке
функции без значения по умолчанию. Позиционные аргументы должны быть
предоставлены в том же порядке, в каком определены в заголовке функции при
вызове функции.
Пример:
def add(x, y):
return x + y
В этом коде функция add принимает два позиционных аргумента, x и y, и возвращает их сумму с помощью ключевого слова return. Чтобы вызватьэту функцию,
нужно предоставить значения для обоих аргументов в том же порядке, в каком
они определены в заголовке функции:
res = add(30, 3)
print(res)
Вывод:
33
Параметры ключевых слов
Это параметры, которые определены в заголовке функции со значением по умолчанию, они могут быть предоставлены в любом порядке при вызове функции.
48 Глава 4 Функции и модули
Если для параметра ключевого слова не указано значение, то используется
значение по умолчанию.
Пример:
def welcome(name="Robot"):
print("Hello, my dear " + name + "!")
Функция welcome принимает один параметр ключевого слова name со значением
по умолчанию Robot. Чтобы вызвать эту функцию и задать значение параметра
name, можно использовать имя параметра и оператор присваивания:
welcome(name="Peter")
Вывод:
Hello, my dear Peter!
Если вы не указали значение для параметра name, будет использовано значение
по умолчанию:
welcome ()
Вывод:
Hello, my dear Robot!
Параметры переменной длины
Это параметры, которые позволяют функции принимать произвольное количество аргументов, как позиционных, так и ключевых. В Python есть два типа
параметров переменной длины: *args и **kwargs.
*args используется для приема переменного количества позиционных аргу-
ментов. Пример:
def add(*args):
return sum(args)
В этом коде функция add принимает переменное количество позиционных аргументов, используя синтаксис *args, и возвращает их сумму, используя встроенную функцию sum. Чтобы вызвать эту функцию с несколькими аргументами,
укажите их через запятую:
res = add(1, 2, 4, 8, 16)
print(result)
Вывод:
31
Операторы возврата и возвращаемые значения 49
**kwargs используется для приема переменного числа аргументов ключевых
слов. Пример:
def welcome_person(**kwargs):
for key, value в kwargs.items():
print(key + ": " + value)
В этом коде функция welcome_person принимает переменное количество аргументов ключевых слов, используя синтаксис **kwargs, и выводит их с помощью
цикла for. Чтобы вызвать эту функцию с несколькими ключевыми аргументами, укажите их с помощью имени параметра и оператора присваивания, как
показано ниже:
print_person(name="Peter", age="42", city="New Haven")
Вывод:
name: Peter
age: 42
city: New Haven
Операторы возврата и возвращаемые значения
В Python функция может возвращать значение с помощью ключевого слова
return . Оператор return используется для выхода из функции и возврата
значения вызывающей стороне. Когда выполняется оператор return, функция
немедленно завершается, а значение, указанное в операторе return, передается
вызывающей стороне.
Функция также может возвращать несколько значений, возвращая кортеж.
Пример:
def sum_and_product(a, b):
return a + b, a * b
В этом коде функция sum_and_product принимает два параметра, a и b, и возвращает их сумму и произведение в виде кортежа. Чтобы вызвать эту функцию
и получить результаты, вы можете присвоить вызов функции нескольким переменным, как показано ниже:
sum, prod = sum_and_product(30, 3)
print(sum)
print(prod)
Вывод:
33
99
50 Глава 4 Функции и модули
Если функция не указывает возвращаемое значение с помощью ключевого слова
return, то по умолчанию она возвращает None. Пример:
def say_something():
print("Something!")
В этом коде функция say_something не имеет оператора возврата, поэтому по
умолчанию возвращает None. Вызовем эту функцию, чтобы получить результат:
say_something()
# Вывод:
Something!
Область действия функции
и локальные переменные
В Python переменные, определенные внутри функции, считаются локальными
для этой функции, и доступ к ним возможен только внутри функции. Это называется областью видимости функции — она помогает предотвратить конфликты
имен между переменными в разных частях программы.
Пример:
def add(x, y):
res = x + y
return res
В этом коде функция add определяет переменную res внутри функции, которая
доступна только внутри функции. Чтобы вызвать эту функцию и получить результат, необходимо присвоить вызов функции переменной, как показано ниже:
result = add(30, 3)
print(result)
Вывод:
33
Если вы попытаетесь получить доступ к переменной res вне функции, то получите ошибку NameError, поскольку переменная в этой области видимости не
определена:
def add(x, y):
res = x + y
return res
add(30, 3)
print(res)
# Вывод: NameError: имя 'res' не определено
Глобальные переменные и оператор global 51
По умолчанию переменные, определенные вне функции, считаются глобаль
ными переменными и к ним можно получить доступ из любого места программы.
Глобальные переменные и оператор global
Глобальные переменные полезны для хранения значений, которые используются
в разных частях программы, но они также могут привести к конфликтам имен
и сделать код трудным для чтения и отладки.
Пример:
counter = 0
def increment():
global counter
counter += 1
return counter
Здесь переменная counter определена вне функции и считается глобальной
переменной. Функция increment использует ключевое слово global, чтобы
указать, что она хочет изменить глобальную переменную counter, а не создавать
новую локальную переменную с тем же именем. Чтобы вызвать эту функцию
и получить результат, необходимо присвоить вызов функции переменной,
например, так:
result = increment()
print(result)
Вывод:
1
Если вы попытаетесь получить доступ к глобальной переменной внутри функции без использования ключевого слова global, Python предположит, что вы
пытаетесь создать новую локальную переменную с тем же именем:
counter = 0
def increment():
counter += 1
return counter
increment()
# Вывод: UnboundLocalError: local variable 'counter' referenced before assignment
Глобальные переменные и оператор global в Python помогут создавать более
гибкие и мощные программы, которые могут хранить данные и манипулировать
ими в разных частях программы. Хорошей практикой считается ограничивать
52 Глава 4 Функции и модули
использование глобальных переменных, поскольку они могут привести к конфликтам имен и сделать код сложным для чтения и отладки.
Лямбда-функции
В Python лямбда-функция — это небольшая анонимная функция, которая может
принимать любое количество аргументов, но иметь только одно выражение.
Лямбда-функции полезны для написания коротких одноразовых функций,
которые не требуют полного определения функции и могут использоваться
везде, где требуется функция.
Пример:
add = lambda x, y: x + y
В этом коде переменной add присвоена лямбда-функция, которая принимает два параметра, x и y, и возвращает их сумму с помощью оператора +.
Чтобы вызвать эту лямбда-функцию и получить результат, укажем значения
параметров:
result = add(30, 3)
print(result)
# Вывод: 33
Лямбда-функции также могут использоваться в качестве аргументов других
функций, например функции map:
numbers = [5, 4, 3, 2, 1]
squares = map(lambda x: x ** 2, numbers)
print(list(squares))
В этом коде функция map принимает лямбда-функцию, которая возводит в квадрат каждое число в списке numbers и возвращает новый список с возведенными
в квадрат значениями. Функция list используется для преобразования результата в список.
В результате будет выведено:
[25, 16, 9, 4, 1]
Лямбда-функции могут стать мощным инструментом для написания лаконичного и выразительного кода, но они также могут затруднить чтение и отладку
кода, если ими злоупотреблять или использовать не по назначению. Поэтому
важно использовать лямбда-функции разумно и осторожно.
Модули и оператор import 53
Встроенные функции
Python поставляется с рядом встроенных функций, которые можно использовать для выполнения обычных операций: манипулирование строками, работа со
списками и словарями и выполнение математических вычислений. Эти функции доступны без необходимости использования дополнительных библиотек
или модулей и могут сэкономить много времени и усилий при написании кода.
Вот некоторые из наиболее часто используемых встроенных функций в Python:
yy len() — возвращает количество элементов в списке, кортеже, строке или
словаре;
yy range() — возвращает последовательность чисел от начала до конца, с необязательным размером шага;
yy
yy
yy
yy
yy
yy
yy
yy
str() — преобразует объект в строку;
int() — преобразует строку или число с плавающей запятой в целое число;
float() — преобразует строку или целое число в число с плавающей точкой;
type() — возвращает тип объекта;
max() — возвращает наибольший элемент в списке, кортеже или строке;
min() — возвращает наименьший элемент в списке, кортеже или строке;
sum() — возвращает сумму всех элементов в списке или кортеже;
sorted() — возвращает отсортированный список элементов в списке, кортеже
или строке.
Вот пример использования функции len() для получения длины строки:
text = "Привет, робот!"
length = len(text)
print(length)
Вывод:
14
Модули и оператор import
В Python модуль — это файл, содержащий определения и инструкции. Модули
используются для группировки связанного кода и для обеспечения пространства имен, что помогает предотвратить конфликты имен между различными
частями программы. Python поставляется с рядом встроенных модулей, и вы
также можете создавать свои собственные модули.
54 Глава 4 Функции и модули
Чтобы использовать модуль, импортируйте его с помощью оператора import.
Оператор import дает команду Python загрузить модуль и сделать его содер
жимое доступным для использования в программе.
Вот пример импорта модуля math и использования функции sqrt для вычисления
квадратного корня из числа:
import math
result = math.sqrt(36)
print(result)
# Вывод: 6.0
Вы также можете импортировать определенные функции или переменные из
модуля с помощью ключевого слова from:
from math import sqrt
result = sqrt(9)
print(result)
# Вывод: 3.0
Когда вы импортируете модуль, Python выполняет код модуля и создает новое
пространство имен для его содержимого. Это означает, что любые функции,
классы или переменные, определенные в модуле, доступны в пространстве
имен модуля.
Создание и использование модулей
В Python вы можете создавать собственные модули, чтобы сгруппировать связанный код вместе и обеспечить пространство имен для кода. Модуль — это файл,
содержащий определения и операторы Python, который можно импортировать
и использовать в других программах Python.
Чтобы создать модуль, нужно определить свой код в файле с расширением .py.
Имя файла должно совпадать с именем модуля, и вы можете поместить файл
в любой каталог, входящий в путь Python. Путь Python — это список каталогов,
в которых Python ищет модули, и его можно задать с помощью переменной среды
PYTHONPATH или с помощью списка sys.path в коде.
Вот пример простого модуля под названием my_own_module.py:
def add(x, y):
return x + y
def subtract(x, y):
return x — y
Чтобы использовать этот модуль в другой программе Python, импортируйте его
с помощью оператора import:
Стандартная библиотека Python 55
import my_own_module
result = my_own_module.add(30, 3)
print(result)
# Вывод: 33
Стандартная библиотека Python
Стандартная библиотека Python — это набор модулей и пакетов. Они поставляются вместе с Python и обеспечивают широкий спектр функциональных
возможностей для решения общих задач программирования. Стандартная
библиотека включает в себя модули для работы с файлами, датами и временем,
регулярными выражениями, сетями и многое другое. Эти модули используются
без необходимости дополнительной установки.
Вот некоторые из наиболее часто используемых модулей стандартной библио
теки:
yy os — обеспечивает взаимодействие с операционной системой, например доступ к файлам и каталогам;
yy
yy
yy
yy
yy
yy
yy
datetime — предоставляет классы для работы с датами и временем;
re — обеспечивает поддержку регулярных выражений;
urllib — предоставляет функции для работы с URL и HTTP;
math — предоставляет математические функции и константы;
random — предоставляет функции для генерации случайных чисел и значений;
json — предоставляет функции для работы с данными JSON;
csv — предоставляет функции для работы с файлами CSV.
Чтобы использовать модуль из стандартной библиотеки Python, импортируйте
его с помощью оператора import.
Например, чтобы использовать модуль datetime, используйте следующий код:
import datetime
now = datetime.datetime.now()
print(now)
Это выведет текущую дату и время:
2023-03-03 17:22:33.593750
Использование стандартной библиотеки Python позволяет писать более эффективный код без дополнительных библиотек или модулей сторонних разработчиков. Стандартная библиотека — это мощный инструмент, который предоставляет
широкий спектр возможностей для решения общих задач программирования.
56 Глава 4 Функции и модули
Задания для самопроверки
1. Объясните разницу между параметрами и аргументами функции. Приведите
простой пример.
2. Напишите функцию под названием add, которая принимает два позиционных параметра, param1 и param2, и возвращает сумму двух чисел. Вызовите
функцию со значениями 18 и 39 и выведите результат.
3. Измените функцию add из второго задания так, чтобы она принимала параметры ключевых слов вместо позиционных параметров. Вызовите функцию
с ключевыми аргументами param1=13 и param2=233 и выведите результат.
4. Напишите функцию под названием greet, которая принимает ключевой
параметр name со значением по умолчанию Stranger и возвращает строку
приветствия Hi, {name}.... Вызовите функцию без указания аргументов
и выведите результат. Затем вызовите функцию с аргументом ключевого
слова name="Severa" и выведите результат.
5. Объясните разницу между локальными и глобальными переменными. Приведите простой пример.
6. Что выведет этот код? Почему?
x = 1934
def modify_x():
global x
x = 2023
print(f"Inside the function: x = {x}")
modify_x()
print(f"Outside the function: x = {x}")
7. Напишите лямбда-функцию, которая вычисляет квадрат числа x. Назначьте
лямбда-функцию переменной с именем square и вызовите ее со значением 11. Выведите результат.
8. Зачем нужна стандартная библиотека Python? Назовите три встроенные
функции и объясните их назначение.
9. Объясните назначение модулей и оператора import. Приведите простой
пример.
10. Создайте простой модуль с именем my_module1.py, содержащий функцию
say_hi(name), которая принимает один параметр name и возвращает строку
приветствия Hi, {name}.... В отдельном скрипте импортируйте функцию
say_hi из модуля my_module1 и вызовите ее со значением Peter. Выведите
результат.
Глава 5
СТРУКТУРЫ ДАННЫХ:
CПИСКИ, КОРТЕЖИ И СЛОВАРИ
Структура данных — это способ хранения и организации данных в вашей программе. Структуры данных позволяют работать с коллекциями данных (списки,
кортежи и словари) и выполнять операции над этими коллекциями, например
сортировку, фильтрацию и поиск.
Python поставляется с несколькими встроенными структурами данных, каждая
из которых имеет свои преимущества и варианты использования. Вот некоторые
из наиболее часто используемых структур данных в Python.
yy Список — упорядоченная коллекция элементов, представленная квадратными
скобками ([]).
Структуры данных — мощный инструмент, помогающий писать более эффективный код. В следующих разделах подробно рассмотрим каждую из структур
данных и ее использование в программах.
Списки в Python
В Python список — это упорядоченная коллекция элементов, которые могут быть
разных типов. Списки создаются с помощью квадратных скобок ([]) и могут
содержать любое количество элементов, разделенных запятыми.
58 Глава 5 Структуры данных: cписки, кортежи и словари
Вот пример создания списка чисел:
numbers = [5, 4, 3, 2, 1]
Списки являются изменяемыми, это означает, что вы можете изменять их после
того, как они были созданы. Можно добавлять, удалять или изменять элементы
в списке с помощью различных встроенных методов списка.
Вот пример добавления элемента в список с помощью метода append():
numbers = [5, 4, 3, 2, 1]
numbers.append(0)
Этот код добавляет число 0 в конец списка:
numbers = [5, 4, 3, 2, 1, 0]
Вы можете получить доступ к элементам списка, используя их индекс, который
начинается с 0 для первого элемента списка. Вот как получить доступ к третьему
элементу списка:
numbers = [5, 4, 3, 2, 1]
print(numbers[2])
Вывод:
3
Вы также можете использовать отрицательную индексацию для доступа к элементам с конца списка. Например, для доступа к последнему элементу списка
можно использовать –1:
numbers = [5, 4, 3, 2, 1]
print(numbers[-1])
Вывод:
1
Списки — это мощный инструмент, позволяющий выполнять сортировку,
фильтрацию и поиск. В следующих разделах подробно рассмотрим некоторые
расширенные возможности списков.
Кортежи в Python
В Python кортеж — это упорядоченная коллекция элементов, подобная списку.
Однако кортежи неизменяемы, это означает, что они не могут быть изменены
после создания. Кортежи создаются с помощью круглых скобок (()), а элементы
разделяются запятыми.
Словари в Python 59
Пример создания кортежа чисел:
numbers = (5, 4, 3, 2, 1)
К кортежам можно обращаться с помощью индексирования и нарезки, как
и к спискам. Поскольку кортежи неизменяемы, вы не можете изменить их
после создания. Это может быть полезно для хранения данных, которые не
подлежат изменению, например параметров конфигурации или постоянных
значений.
Вот как получить доступ ко второму элементу кортежа:
numbers = (5, 4, 3, 2, 1)
print(numbers[1])
Вывод:
4
Вы также можете использовать отрицательную индексацию и нарезку с кортежами, как и со списками.
Кортежи могут использоваться для возврата нескольких значений из функции
или для группировки связанных данных. Это полезный инструмент для работы
с коллекциями данных, и их можно использовать вместе со списками и другими
структурами данных для построения более сложных программ.
Словари в Python
В Python словарь — это неупорядоченная коллекция пар «ключ — значение».
Словари создаются с помощью фигурных скобок ({}) и могут содержать любое
количество элементов, разделенных запятыми. Каждый элемент словаря состоит
из ключа и значения, разделенных двоеточием (:).
Вот пример создания словаря имен студентов и соответствующих им возрастов:
ages = {"Peter": 42, "Ivan": 32, "Sergey": 22}
Вы можете получить доступ к элементам словаря, используя их ключи, как
показано ниже:
ages = {"Peter": 42, "Ivan": 32, "Sergey": 22}
print(ages["Ivan"])
Вывод:
32
60 Глава 5 Структуры данных: cписки, кортежи и словари
Вы также можете использовать метод get() для доступа к элементам словаря,
который позволяет указать значение по умолчанию, возвращаемое в случае,
если ключ не существует:
ages = {"Peter": 42, "Ivan": 32, "Sergey": 22}
print(ages.get("Anatoly", 40))
Вывод:
40
Словари являются изменяемыми, это означает, что вы можете добавлять, удалять
или изменять элементы после их создания. Вы можете добавить новый элемент
в словарь, присвоив значение новому ключу, как показано ниже:
ages = {"Peter": 42, "Ivan": 32, "Sergey": 22}
ages["Anatoly"] = 40
Этот код добавляет новый элемент в словарь:
ages = {"Peter": 42, "Ivan": 32, "Sergey": 22, "Anatoly": 40}
Использование словарей в Python позволяет хранить и получать доступ к данным с использованием парадигмы «ключ — значение», что может быть полезно
для широкого круга задач программирования.
В следующих разделах подробнее рассмотрим некоторые расширенные
возможности словарей: словарное включение (генератор словарей) и сор
тировку.
Списковое включение
Списковое включение — это лаконичный способ создания нового списка путем
преобразования или фильтрации существующего. Списки создаются с помощью
квадратных скобок ([]) и состоят из трех частей.
1. Входная последовательность.
2. Переменная, представляющая каждый элемент входной последовательности.
3. Выходное выражение, которое преобразует или фильтрует каждый элемент
входной последовательности.
Вот пример простого спискового включения, которое удваивает каждый элемент
в списке чисел:
numbers = [5, 4, 3, 2, 1]
doubles = [num * 2 for num in numbers]
Сортировка и поиск в структурах данных 61
Это создаст новый список doubles, где каждый элемент списка numbers будет
удвоенным:
[10, 8, 6, 4, 2]
Списковое включение может также включать условные операторы, которые
позволяют фильтровать входную последовательность на основе условия. Вот
пример спискового включения, который содержит только нечетные числа из
списка чисел:
numbers = [5, 4, 3, 2, 1]
odds = [num for num in numbers if num % 2 != 0]
Этот код создает новый список под названием odds, который будет включать
только нечетные числа из списка numbers:
[5, 3, 1]
Списковое включение — это мощный инструмент в Python, который позволяет
создавать новые списки в краткой и читабельной форме.
Сортировка и поиск в структурах данных
В Python можно использовать встроенные функции для сортировки и поиска
структур данных, таких как списки и словари. Сортировка и поиск часто используются при обработке данных, и Python предоставляет широкий спектр инструментов, позволяющих сделать решение этих задач простым и эффективным.
Для сортировки списка в Python используйте метод sort(). Он сортирует список
на месте, то есть изменяет исходный список, а не создает новый, отсортированный.
Вот пример сортировки списка чисел:
numbers = [1, 2, 5, 7, 2, 3, 4, 9, 6]
numbers.sort()
Этот код сортирует список чисел в порядке возрастания:
[1, 2, 2, 3, 4, 5, 6, 7, 9]
Для того чтобы отсортировать список по убыванию, можно передать аргумент
reverse=True в метод sort():
numbers = [1, 2, 5, 7, 2, 3, 4, 9, 6]
numbers.sort(reverse=True)
Этот код позволяет отсортировать список чисел в порядке убывания:
[9, 7, 6, 5, 4, 3, 2, 2, 1]
62 Глава 5 Структуры данных: cписки, кортежи и словари
Для поиска элемента в списке можно использовать ключевое слово in. Оно
возвращает True, если элемент находится в списке, и False в противном случае.
Вот пример поиска элемента в списке:
numbers = [5, 4, 3, 2, 1]
if 3 in numbers:
print("3 is in the list")
else:
print("3 is not in the list")
Вывод:
3 is in the list
Для поиска элемента в словаре можно использовать ключевое слово in с ключами словаря:
ages = {"Peter": 42, "Ivan": 32, "Sergey": 22}
if "Ivan" in ages:
print("Ivan's age is", ages["Ivan"])
else:
print("Ivan is not in the dictionary")
# Вывод: Ivan’s age is 32
Сортировка и поиск — это фундаментальные задачи в обработке данных, и Python
предоставляет широкий спектр инструментов, позволяющих сделать их простыми и эффективными.
В следующих разделах подробно рассмотрим некоторые продвинутые методы,
которые можно использовать для сортировки и поиска структур данных, например пользовательскую сортировку и поиск с помощью двоичного поиска.
Продвинутые методы работы
со структурами данных
Копирование и клонирование структур данных
В Python можно копировать и клонировать структуры данных для создания
новых независимых копий исходных данных. Копирование и клонирование полезны, когда нужно изменить структуру данных, не затрагивая исходные данные.
Чтобы создать копию списка в Python, можно использовать метод copy() .
Он создает новый список с теми же элементами, что и в исходном.
Вот пример создания копии списка:
numbers = [5, 4, 3, 2, 1]
copy = numbers.copy()
Продвинутые методы работы со структурами данных 63
Этот код создает новый список copy, содержащий те же элементы, что и список numbers:
[5, 4, 3, 2, 1]
Чтобы создать клон списка, используйте оператор нарезки (:). Он создает новый
список с теми же элементами, что и в исходном.
Пример создания клона списка:
numbers = [5, 4, 3, 2, 1]
clone = numbers[:]
Это создаст новый список clone, который содержит те же элементы, что и список numbers:
[5, 4, 3, 2, 1]
Копирование и клонирование похожи, но у них есть несколько важных различий.
При копировании создается новый объект, который является неглубокой (поверхностной) копией исходной структуры данных. Неглубокая копия означает,
что новый объект имеет свою собственную область памяти, но разделяет те же
внутренние объекты (например, вложенные списки или словари), что и исходная структура данных. Если какие-либо из внутренних объектов являются
изменяемыми (например, списки), изменения этих объектов будут отражены
как в исходной структуре данных, так и в копии.
При клонировании создается новый объект, который является глубокой копией
исходной структуры данных. Глубокая копия означает, что новый объект имеет
свою собственную область памяти и свои собственные внутренние объекты.
Изменения внутренних объектов нового объекта не повлияют на исходную
структуру данных, и наоборот.
Копирование и клонирование также применимы к другим структурам данных,
таким как словари, множества и кортежи, с использованием метода copy() или
оператора нарезки в зависимости от ситуации.
Нарезка списка и расширенные нарезки
Вы можете нарезать список, чтобы извлечь его часть. При нарезке списка создается новый список, содержащий только выбранные элементы. Нарезка, или
слайсирование, — это мощная техника, которую можно использовать для различных манипуляций со списками.
Для нарезки списка используется оператор нарезки (:) с начальным и конечным
индексами нарезки. Пример:
my_list = [5, 4, 3, 2, 1]
sliced_list = my_list[1:4]
64 Глава 5 Структуры данных: cписки, кортежи и словари
Этот код создаст новый список sliced_list, который будет содержать элементы 4, 3 и 2 из списка my_list.
Вы также можете нарезать список с отрицательными индексами. Отрицательные
индексы отсчитываются от конца списка, поэтому -1 относится к последнему
элементу списка, -2 — к предпоследнему элементу, и т. д.
Вот пример нарезки списка с отрицательными индексами:
my_list = [5, 4, 3, 2, 1]
sliced_list = my_list[-3:-1]
Это создаст новый список sliced_list, который будет содержать элементы 3
и 2 из списка my_list.
В дополнение к базовой нарезке Python также поддерживает расширенную
нарезку, которая позволяет указать значение шага для нарезки. Значение шага
определяет, сколько элементов будет включено в срез.
Вот пример расширенной нарезки:
my_list = [5, 4, 3, 2, 1]
sliced_list = my_list[1:4:2]
Этот код создаст новый список sliced_list, который будет содержать элементы 4 и 2 из списка my_list.
Расширенная нарезка также работает с отрицательными индексами:
my_list = [5, 4, 3, 2, 1]
sliced_list = my_list[-1:-4:-1]
Этот код создаст новый список sliced_list, который будет содержать элементы 1, 2 и 3 из списка my_list.
Помимо нарезки списков, в Python можно нарезать кортежи и строки, используя
тот же синтаксис оператора нарезки.
Множественные входные последовательности
в списковых включениях
Списковые включения — это мощный способ создания новых списков на основе
существующих. Они позволяют применять преобразование к каждому элементу
списка и фильтровать результаты на основе условия.
Одна из особенностей списковых включений — возможность использования
нескольких входных последовательностей, что позволяет объединять элементы
из нескольких списков в одном списке.
Продвинутые методы работы со структурами данных 65
Чтобы использовать несколько входных последовательностей в списке, можно
перечислить их друг за другом внутри квадратных скобок, разделяя запятыми.
Пример:
numbers = [1, 2, 3]
colors = ['green', 'yellow', 'red']
pairs = [(n, c) for n in numbers for c in colors]
Этот код создаст новый список pairs, содержащий все возможные пары чисел
и цветов, как показано ниже:
[(1, 'green'), (1, 'yellow'), (1, 'red'), (2, 'green'), (2, 'yellow'),
(2, 'red'), (3, 'green'), (3, 'yellow'), (3, 'red')]
В этом примере мы используем две входные последовательности (numbers
и colors) для создания нового списка пар. Список перебирает каждый элемент
чисел и каждый элемент цветов и объединяет их в кортеж.
Вы можете использовать любое количество входных последовательностей
в списковом включении, если разделяете их запятыми. Но имейте в виду, что
использование слишком большого количества входных последовательностей
может затруднить восприятие списка.
Словарные включения
Помимо спискового включения Python также поддерживает словарное включение (генератор словарей), что позволяет создавать новые словари из существующих в краткой и выразительной форме.
Синтаксис словаря похож на синтаксис списка, но вместо одного элемента используется пара «ключ — значение». Пример:
my_dict = {'x': 1, 'y': 2, 'z': 3}
new_dict = {k: v * v for k, v in my_dict.items() if v > 1}
Этот код создаст новый словарь new_dict, который будет содержать квадраты
значений из my_dict, но только для тех элементов, где значение больше 1. Полученный словарь будет выглядеть так:
{'y': 4, 'z': 9}
В этом примере мы используем словарное включение для создания нового словаря, который содержит квадраты значений в my_dict, но только для тех элементов,
где значение больше 1. Словарное включение использует метод items() для
итерации пар «ключ — значение» в my_dict и применяет преобразование v * v
к каждому значению в словаре. Полученный словарь отфильтровывает все пары
«ключ — значение», в которых значение меньше или равно 1.
66 Глава 5 Структуры данных: cписки, кортежи и словари
Словарное включение можно также использовать для создания словарей из
других типов последовательностей. Например, вы можете создать словарь из
списка кортежей следующим образом:
my_list = [('x', 1), ('y', 2), ('z', 3)]
my_dict = {k: v for k, v in my_list}
Этот код создает новый словарь my_dict, который будет содержать пары «ключ —
значение» из my_list, как показано ниже:
{'x': 1, 'y': 2, 'z': 3}
Множества и операции с ними
Множество — это неупорядоченная коллекция уникальных элементов. Множества похожи на списки и кортежи, но не допускают дублирования элементов.
Множества можно использовать для выполнения различных операций над
коллекциями данных, например для нахождения пересечения или разности
между двумя множествами.
Чтобы создать множество, используйте функцию set() или заключите последовательность элементов в фигурные скобки {}. Пример:
my_set = {3, 2, 1}
Этот код создаст новое множество под названием my_set, содержащее элементы 3, 2 и 1.
Вы можете выполнять различные операции над множествами, такие как объединение, пересечение и разность. Вот краткий обзор некоторых наиболее распространенных операций с множествами в Python.
Объединение
Возвращает множество, которое содержит все элементы из обоих множеств, без
дубликатов. Для выполнения объединения используйте оператор | или метод
union().
set1 = {3, 2, 1}
set2 = {5, 4, 3}
union_set = set1 | set2
# или
union_set = set1.union(set2)
# Результат: {1, 2, 3, 4, 5}
Пересечение
Возвращает множество, содержащее только те элементы, которые есть в обоих
множествах. Для выполнения пересечения используйте оператор & или метод
intersection().
Продвинутые методы работы со структурами данных 67
Разность
Возвращает множество, содержащее элементы, которые есть в первом множестве,
но которых нет во втором. Для выполнения разницы используйте оператор - или
метод difference().
set1 = {3, 2, 1}
set2 = {5, 4, 3}
difference_set = set1 - set2
# или
difference_set = set1.difference(set2)
# Результат: {1, 2}
Симметричная разность
Возвращает множество, содержащее элементы, которые есть в любом из множеств, но не в обоих. Для выполнения симметричной разности используйте
оператор ^ или метод symmetric_difference().
set1 = {3, 2, 1}
set2 = {5, 4, 3}
symmetric_difference_set = set1 ^ set2
# или
symmetric_difference_set = set1.symmetric_difference(set2)
# Результат: {1, 2, 4, 5}
Помимо этих операций, множества также поддерживают другие методы, например add(), remove() и discard(), которые позволяют добавлять или удалять
элементы из множества.
Стеки и очереди со списками
В Python списки можно использовать для реализации базовых структур данных,
таких как стеки и очереди. Стеки и очереди — это широко используемые структуры данных, которые хранят коллекцию элементов и позволяют добавлять или
удалять элементы в определенном порядке.
Стек — это структура данных типа «последний вошел — первый вышел» (LIFO).
Это означает, что последний элемент, добавленный в стек, удаляется первым.
Вы можете использовать список в качестве стека, применяя метод append() для
добавления элементов в конец списка и метод pop() для удаления элементов из
конца списка.
68 Глава 5 Структуры данных: cписки, кортежи и словари
В этом примере мы создаем новый список my_stack1 и добавляем элементы 3, 2
и 1 в конец списка с помощью метода append(). Затем используем метод pop()
для удаления последнего элемента из списка, которым является 1.
Очередь — это структура данных типа «первым пришел — первым ушел» (FIFO).
Это означает, что первый элемент, добавленный в очередь, первым и удаляется.
Вы можете использовать список в качестве очереди, применяя метод append()
для добавления элементов в конец списка и метод pop() с индексом 0 для удаления элементов из начала списка.
Пример:
my_queue1 = []
my_queue1.append(3)
my_queue1.append(2)
my_queue1.append(1)
my_queue1.pop(0)
# Результат: 3
В этом примере мы создаем новый список my_queue1 и добавляем элементы 3, 2
и 1 в конец списка с помощью метода append(). Затем используем метод pop()
с индексом 0, чтобы удалить первый элемент из списка, которым является 3.
Продвинутые методы сортировки
Сортировка — это фундаментальная операция в программировании, которая
используется для расположения коллекции элементов в определенном порядке.
Python предоставляет несколько встроенных функций сортировки, включая
sorted() , которые можно использовать для сортировки списков, кортежей
и других коллекций элементов в порядке возрастания или убывания.
Помимо этих встроенных функций, Python также предоставляет несколько расширенных методов сортировки, которые можно использовать для сортировки
сложных структур данных и выполнения пользовательских операций сортировки.
Один из таких приемов — параметр key в функции sorted(). Параметр key
позволяет указать функцию, которая будет использоваться для определения
порядка сортировки элементов в коллекции. Например, если у вас есть список
словарей и вы хотите отсортировать список по определенному ключу в каждом
словаре, используйте параметр key для указания функции key.
Продвинутые методы работы со структурами данных 69
В этом примере есть список словарей под названием my_list, где каждый словарь
содержит имя и возраст. Мы хотим отсортировать список по возрасту, поэтому
используем параметр key для указания лямбда-функции, которая извлекает
значение age из каждого словаря. Полученный отсортированный список отсор
тирован по возрасту в порядке возрастания.
Другой продвинутый метод сортировки в Python — метод sort(), который можно
использовать для сортировки списков по месту. Он позволяет указать пользовательскую функцию сравнения, которая будет использоваться для определения
порядка сортировки элементов в списке. Пример:
my_list = ['Peter', 'robot', 'Ivan', 'Sergey']
my_list.sort(key=lambda x: x.lower())
# Результат: ['Ivan', 'Peter', 'robot', 'Sergey']
В этом примере у нас есть список строк под названием my_list, и мы хотим отсортировать этот список без учета регистра. Используем параметр key с лямбда-функцией, которая преобразует каждую строку в нижний регистр перед их
сравнением.
Бинарный поиск
Поиск — это еще одна фундаментальная операция в программировании, которая используется для поиска определенного элемента в коллекции элементов.
Python предоставляет несколько встроенных функций поиска, включая in,
которая может быть использована для проверки наличия элемента в коллекции, и index(), которая может быть использована для нахождения индекса
элемента в списке.
Помимо этих встроенных функций, Python также предоставляет несколько расширенных методов поиска, которые можно использовать для более эффективного
поиска в больших коллекциях элементов. Один из таких методов — бинарный
поиск.
Бинарный, или двоичный, поиск — это эффективный алгоритм для поиска определенного элемента в отсортированной коллекции элементов. Алгоритм работает
путем многократного деления коллекции пополам и сравнения среднего элемента
с целевым элементом. Если средний элемент больше целевого элемента, поиск
продолжается в нижней половине коллекции. Если средний элемент меньше
целевого элемента, поиск продолжается в верхней половине коллекции. Поиск
70 Глава 5 Структуры данных: cписки, кортежи и словари
продолжается до тех пор, пока целевой элемент не будет найден или коллекция
не будет исчерпана.
Пример реализации бинарного поиска в Python:
def binary_search(arr, target):
low = 0
high = len(arr) - 1
while low self._balance:
raise ValueError("Insufficient funds")
self._balance -= amount
def get_balance(self):
return self._balance
В этом примере класс BankAccount имеет приватный атрибут _balance, который
доступен только изнутри класса. Методы deposit и withdraw могут использоваться для изменения баланса, а метод get_balance предоставляет доступ
к балансу только для чтения.
Инкапсуляция и сокрытие данных обеспечивают сохранность внутренней работы
класса и гарантируют, что она не будет случайно или злонамеренно изменена
извне класса. Они также облегчают модификацию реализации класса, не затрагивая другие части кода, в которых используется класс.
Абстракция данных и инкапсуляция данных
Абстракция данных и инкапсуляция данных — две важные концепции в ООП,
которые помогают отделить интерфейс класса от его реализации. Эти концепции
позволяют улучшить организацию кода, увеличить переиспользование кода
и улучшить сопровождение ПО.
Абстракция данных относится к процессу определения основных характеристик объекта или класса при игнорировании деталей реализации. Обычно это
достигается путем определения набора абстрактных методов или свойств, которые представляют интерфейс класса, без указания того, как эти методы будут
реализованы. Фактические детали реализации скрыты от пользователя класса,
что позволяет повысить гибкость и модульность кода.
Модификаторы частного доступа 91
Инкапсуляция данных относится к практике сокрытия внутренних данных и деталей реализации класса от внешнего мира. Обычно это достигается путем использования модификаторов доступа для ограничения доступа к определенным
свойствам или методам класса. Инкапсулируя данные, класс может сохранять
свое внутреннее состояние и целостность, обеспечивая при этом публичный
интерфейс, который можно использовать для взаимодействия с классом.
Пример того, как абстракция и инкапсуляция данных могут быть использованы
в классе:
class Shape:
def area(self):
pass
def perimeter(self):
pass
class Rectangle(Shape):
def __init__(self, width, height):
self._width = width
self._height = height
def area(self):
return self._width * self._height
def perimeter(self):
return 2 * (self._width + self._height)
В этом примере класс Shape определяет интерфейс с двумя абстрактными методами, площадь и периметр, которые представляют основные характеристики
любой двумерной фигуры. Класс Rectangle наследуется от класса Shape и предоставляет конкретную реализацию методов area и perimeter. Внутренние данные
класса Rectangle, а именно ширина и высота, инкапсулируются внутри класса
и не имеют прямого доступа извне.
Используя абстракцию данных и инкапсуляцию данных, мы можем определить
набор общих методов и свойств, которые могут быть использованы любым классом формы, что сохранит при этом гибкость в реализации конкретных классов
формы. Это поможет уменьшить дублирование кода и улучшить организацию
и сопровождаемость кодовой базы.
Модификаторы частного доступа
Атрибуты и методы, которые должны быть приватными (то есть доступными
только внутри класса), должны иметь префикс с двумя знаками подчеркивания
и суффикс с одним знаком подчеркивания (например, __private_attribute_).
Это приводит к тому, что имя атрибута или метода «смешивается» с именем
92 Глава 7 Объектно-ориентированное программирование
класса и случайным хешем, что затрудняет доступ к нему извне класса. Тем не
менее к этим атрибутам и методам все еще можно получить доступ, используя
рефлексию (reflection) или другие продвинутые техники.
Важно отметить, что эти соглашения не навязываются самим языком Python
и являются исключительно вопросом конвенции и хорошего стиля написания
кода. Разработчики должны руководствоваться здравым смыслом при выборе
соответствующего уровня доступа для атрибутов и методов класса и документировать предполагаемый уровень доступа по классу.
Перегрузка операторов
В Python под перегрузкой операторов понимается возможность переопределения
действий оператора при его применении к экземпляру класса. Например, если
вы добавите пользовательский класс для представления комплексных чисел, то
можете определить, что произойдет, когда оператор + будет использоваться для
сложения двух экземпляров вашего класса.
Для перегрузки операторов вы определяете специальный метод в классе,
окруженный двойным подчеркиванием и имеющий то же имя, что и оператор,
который вы хотите перегрузить. Например, чтобы перегрузить оператор +, вы
определяете метод __add__ в своем классе.
Пример класса, который перегружает оператор +:
class ComplexNumber:
def __init__(self, real, imaginary):
self.real = real
self.imaginary = imaginary
def __add__(self, other):
return ComplexNumber(self.real + other.real, self.imaginary +
other.imaginary)
def __str__(self):
return f"{self.real} + {self.imaginary}i"
В этом примере мы определяем класс ComplexNumber, который представляет
комплексные числа как комбинацию действительного и мнимого компонентов.
Мы перегружаем оператор +, определяя метод __add__, который принимает два
экземпляра ComplexNumber в качестве аргументов и возвращает новый экземпляр
ComplexNumber, представляющий сумму двух экземпляров.
Мы также определяем метод __str__, который преобразовывает экземпляр
класса в строку для печати или других целей. Символ "f" перед открывающей
кавычкой указывает Python рассматривать строку как f-строку, что позволяет
оценивать выражения внутри фигурных скобок и вставлять их в строку.
Класс и статические методы и переменные 93
С помощью этой реализации мы можем создавать экземпляры класса ComplexNumber и использовать оператор + для их сложения:
a = ComplexNumber(1, 3)
b = ComplexNumber(2, 4)
c = a + b
print(c) # выводит "3 + 7i"
Помимо основных арифметических операторов + , – , * и / , в Python можно
перегружать и многие другие операторы, включая операторы сравнения == и
Последние комментарии
13 минут 26 секунд назад
49 минут 29 секунд назад
50 минут 33 секунд назад
53 минут 26 секунд назад
17 часов 21 минут назад
18 часов 15 минут назад