Регистрация · Вход Забыли имя или пароль?

Python. К вершинам мастерства. Второе издание [2022, PDF, RUS]

Страницы: 1


0balance Стаж: 10 лет 7 месяцев Сообщений: 1	0balance · 16-Сен-22 10:19 (3 года назад, ред. 16-Сен-22 15:31) Fluent Python: Clear, Concise, and Effective Programming 2nd Edition / Python. К вершинам мастерства. Второе издание Год издания: 2022 Автор: Luciano Ramalho / Лусиану Рамальо Переводчик: А. А. Слинкина Жанр или тематика: Программирование, python Издательство: ДMK ISBN: 978-5-97060-885-2 Язык: Русский Формат: PDF Качество: Издательский макет или текст (eBook) Интерактивное оглавление: Да Количество страниц: 898 Описание: Второе издание книги позволит вам использовать возможности Python 3 в полной мере, обратив себе на пользу лучшие идеи. Автор рассказывает о базовых средствах языка, о его библиотеках и учит писать более краткий, быстрый и удобочитаемый код. Вы узнаете о том, как применять идиоматические средства Python 3, выходящие за рамки вашего предыдущего опыта. Новое издание состоит из пяти частей, которые можно рассматривать как пять отдельных книг. Структуры данных: последовательности, словари, множества, Unicode и классы данных. Функции как объекты: полноправные функции, относящиеся к ним паттерны проектирования, а также аннотации типов в объявлениях функций. Объектно-ориентированные идиомы: композиция, наследование, классы-примеси, интерфейсы, перегрузка операторов, протоколыи дополнительные статические типы. Поток управления: контекстные менеджеры, генераторы, сопрограммы, async/await, пулы процессов и потоков. Метапрограммирование: свойства, дескрипторы атрибутов, декораторы классов и новые средства метапрограммирования классов, позволяющие заменить или упростить метаклассы. Примеры страниц Оглавление Предисловие от издательства ........................................................ 19 Отзывы и пожелания ........................................................................................19 Список опечаток ...............................................................................................19 Нарушение авторских прав .............................................................................19 Об авторе ........................................................................................... 20 Колофон ............................................................................................. 20 Предисловие ...................................................................................... 21 На кого рассчитана эта книга ..........................................................................21 На кого эта книга не рассчитана .....................................................................22 Пять книг в одной .............................................................................................22 Как организована эта книга .............................................................................22 Практикум .........................................................................................................24 Поговорим: мое личное мнение......................................................................25 Сопроводительный сайт: fluentpython.com ....................................................25 Графические выделения ..................................................................................25 О примерах кода ...............................................................................................26 Как с нами связаться ........................................................................................26 Благодарности ..................................................................................................27 Благодарности к первому изданию.................................................................28 ЧАСТЬ I. СТРУКТ УРЫ ДАННЫХ ........................................31 Глава 1. Модель данных в языке Python ...................................... 32 Что нового в этой главе ....................................................................................33 Колода карт на Python ......................................................................................33 Как используются специальные методы ........................................................36 Эмуляция числовых типов ...........................................................................37 Строковое представление ............................................................................40 Булево значение пользовательского типа ..................................................41 API коллекций ...............................................................................................41 Сводка специальных методов .........................................................................43 Почему len – не метод ......................................................................................45 Резюме ...............................................................................................................45 Дополнительная литература ............................................................................46 Глава 2. Массив последовательностей........................................... 48 Что нового в этой главе.....................................................................................49 Общие сведения о встроенных последовательностях....................................49 Списковое включение и генераторные выражения........................................51 Списковое включение и удобочитаемость..................................................52 Сравнение спискового включения с map и filter.........................................53 Декартовы произведения.............................................................................54 Генераторные выражения.............................................................................55 Кортеж – не просто неизменяемый список.....................................................57 Кортежи как записи.......................................................................................57 Кортежи как неизменяемые списки............................................................58 Сравнение методов кортежа и списка.........................................................60 Распаковка последовательностей и итерируемых объектов..........................61 Распаковка с помощью * в вызовах функций и литеральных последовательностях.....................................................................................63 Распаковка вложенных объектов.................................................................63 Сопоставление с последовательностями-образцами.....................................64 Сопоставление с последовательностями-образцами в интерпретаторе..........................................................................................69 Получение среза................................................................................................72 Почему в срезы и диапазоны не включается последний элемент.............73 Объекты среза................................................................................................73 Многомерные срезы и многоточие..............................................................74 Присваивание срезу......................................................................................75 Использование + и * для последовательностей...............................................76 Построение списка списков..........................................................................76 Составное присваивание последовательностей..............................................78 Головоломка: присваивание A += ................................................................79 Метод list.sort и встроенная функция sorted...................................................81 Когда список не подходит.................................................................................83 Массивы.........................................................................................................83 Представления областей памяти..................................................................86 NumPy.............................................................................................................88 Двусторонние и другие очереди...................................................................90 Резюме................................................................................................................93 Дополнительная литература.............................................................................94 Глава 3. Словари и множества.......................................................... 99 Что нового в этой главе.....................................................................................99 Современный синтаксис словарей.................................................................100 Словарные включения................................................................................100 Распаковка отображений............................................................................101 Объединение отображений оператором \|..................................................102 Сопоставление с отображением-образцом...................................................102 Стандартный API типов отображений...........................................................105 Что значит «хешируемый»?........................................................................105 Обзор наиболее употребительных методов отображений.......................106 Вставка и обновление изменяемых значений..........................................108 Автоматическая обработка отсутствующих ключей....................................111 defaultdict: еще один подход к обработке отсутствия ключа...................111 Метод __missing__.........................................................................................112 Несогласованное использование __missing__ в стандартной библиотеке..........................................................................114 Вариации на тему dict.....................................................................................115 collections.OrderedDict.................................................................................115 collections.ChainMap....................................................................................116 collections.Counter.......................................................................................117 shelve.Shelf...................................................................................................117 Создание подкласса UserDict вместо dict..................................................118 Неизменяемые отображения..........................................................................120 Представления словаря...................................................................................121 Практические последствия внутреннего устройства класса dict.................122 Теория множеств.............................................................................................123 Литеральные множества.............................................................................125 Множественное включение........................................................................126 Практические последствия внутреннего устройства класса set..................126 Операции над множествами......................................................................127 Теоретико-множественные операции над представлениями словарей.....129 Резюме..............................................................................................................131 Дополнительная литература...........................................................................132 Глава 4. Unicode-текст и байты......................................................135 Что нового в этой главе...................................................................................136 О символах, и не только..................................................................................136 Все, что нужно знать о байтах........................................................................137 Базовые кодировщики и декодировщики.....................................................140 Проблемы кодирования и декодирования....................................................141 Обработка UnicodeEncodeError...................................................................142 Обработка UnicodeDecodeError...................................................................143 Исключение SyntaxError при загрузке модулей с неожиданной кодировкой........................................................................144 Как определить кодировку последовательности байтов..........................145 BOM: полезный крокозябр..........................................................................146 Обработка текстовых файлов.........................................................................147 Остерегайтесь кодировок по умолчанию..................................................150 Нормализация Unicode для надежного сравнения.......................................155 Сворачивание регистра...............................................................................158 Служебные функции для сравнения нормализованного текста..............158 Экстремальная «нормализация»: удаление диакритических знаков......159 Сортировка Unicode-текстов...........................................................................162 Сортировка с помощью алгоритма упорядочивания Unicode.................164 База данных Unicode........................................................................................165 Поиск символов по имени..........................................................................165 Символы, связанные с числами.................................................................167 Двухрежимный API..........................................................................................168 str и bytes в регулярных выражениях.........................................................168 str и bytes в функциях из модуля os...........................................................170 Резюме..............................................................................................................170 Дополнительная литература...........................................................................171 Глава 5. Построители классов данных..........................................176 Что нового в этой главе...................................................................................177 Обзор построителей классов данных.............................................................177 Основные возможности..............................................................................179 Классические именованные кортежи............................................................181 Типизированные именованные кортежи......................................................184 Краткое введение в аннотации типов............................................................185 Никаких последствий во время выполнения............................................185 Синтаксис аннотаций переменных...........................................................186 Семантика аннотаций переменных...........................................................186 Инспекция typing.NamedTuple...................................................................187 Инспектирование класса с декоратором dataclass....................................188 Еще о @dataclass.............................................................................................190 Опции полей................................................................................................191 Постинициализация....................................................................................194 Типизированные атрибуты класса.............................................................196 Инициализируемые переменные, не являющиеся полями.....................196 Пример использования @dataclass: запись о ресурсе из дублинского ядра....................................................................................197 Класс данных как признак кода с душком.....................................................199 Класс данных как временная конструкция...............................................201 Класс данных как промежуточное представление...................................201 Сопоставление с экземплярами классов – образцами.................................201 Простые классы-образцы............................................................................202 Именованные классы-образцы..................................................................202 Позиционные классы-образцы..................................................................204 Резюме..............................................................................................................205 Дополнительная литература...........................................................................205 Глава 6. Ссылки на объекты, изменяемость и повторное использование..........................................................209 Что нового в этой главе...................................................................................210 Переменные – не ящики.................................................................................210 Тождественность, равенство и псевдонимы..................................................212 Выбор между == и is.....................................................................................213 Относительная неизменяемость кортежей...............................................214 По умолчанию копирование поверхностное.................................................215 Глубокое и поверхностное копирование произвольных объектов..........218 Параметры функций как ссылки....................................................................219 Значения по умолчанию изменяемого типа: неудачная мысль..............220 Защитное программирование при наличии изменяемых параметров.....222 del и сборка мусора..........................................................................................224 Как Python хитрит с неизменяемыми объектами.........................................226 Резюме..............................................................................................................228 Дополнительная литература...........................................................................229 ЧАСТЬ II. ФУНКЦИИ КАК ОБЪЕКТЫ..............................233 Глава 7. Функции как полноправные объекты............................234 Что нового в этой главе...................................................................................235 Обращение с функцией как с объектом.........................................................235 Функции высшего порядка.............................................................................236 Современные альтернативы функциям map, filter и reduce.....................237 Анонимные функции......................................................................................239 Девять видов вызываемых объектов.............................................................240 Пользовательские вызываемые типы............................................................241 От позиционных к чисто именованным параметрам..................................242 Чисто позиционные параметры.................................................................244 Пакеты для функционального программирования......................................245 Модуль operator...........................................................................................245 Фиксация аргументов с помощью functools.partial..................................248 Резюме..............................................................................................................250 Дополнительная литература...........................................................................250 Глава 8. Аннотации типов в функциях..........................................254 Что нового в этой главе...................................................................................255 О постепенной типизации..............................................................................255 Постепенная типизация на практике............................................................256 Начинаем работать с Mypy..........................................................................257 А теперь построже.......................................................................................258 Значение параметра по умолчанию..........................................................258 None в качестве значения по умолчанию..................................................260 Типы определяются тем, какие операции они поддерживают....................261 Типы, пригодные для использования в аннотациях....................................266 Тип Any.........................................................................................................266 «Является подтипом» и «совместим с»......................................................267 Простые типы и классы...............................................................................269 Типы Optional и Union.................................................................................269 Обобщенные коллекции.............................................................................270 Типы кортежей............................................................................................273 Обобщенные отображения.........................................................................275 Абстрактные базовые классы.....................................................................276 Тип Iterable...................................................................................................278 Параметризованные обобщенные типы и TypeVar..................................280 Статические протоколы..............................................................................284 Тип Callable..................................................................................................288 Тип NoReturn...............................................................................................291 Аннотирование чисто позиционных и вариадических параметров...........291 Несовершенная типизация и строгое тестирование....................................292 Резюме..............................................................................................................293 Дополнительная литература...........................................................................294 Глава 9. Декораторы и замыкания................................................300 Что нового в этой главе...................................................................................301 Краткое введение в декораторы.....................................................................301 Когда Python выполняет декораторы.............................................................302 Регистрационные декораторы........................................................................304 Правила видимости переменных...................................................................304 Замыкания.......................................................................................................307 Объявление nonlocal.......................................................................................310 Логика поиска переменных........................................................................311 Реализация простого декоратора...................................................................312 Как это работает..........................................................................................313 Декораторы в стандартной библиотеке.........................................................314 Запоминание с помощью functools.cache..................................................315 Использование lru_cache.............................................................................317 Обобщенные функции с одиночной диспетчеризацией..........................318 Параметризованные декораторы...................................................................322 Параметризованный регистрационный декоратор..................................323 Параметризованный декоратор clock........................................................324 Декоратор clock на основе класса...............................................................327 Резюме..............................................................................................................328 Дополнительная литература...........................................................................328 Глава 10. Реализация паттернов проектирования с помощью полноправных функций............................................333 Что нового в этой главе...................................................................................334 Практический пример: переработка паттерна Стратегия...........................334 Классическая Стратегия..............................................................................334 Функционально-ориентированная стратегия...............................................338 Выбор наилучшей стратегии: простой подход..........................................341 Поиск стратегий в модуле...........................................................................342 Паттерн Стратегия, дополненный декоратором...........................................343 Паттерн Команда.............................................................................................345 Резюме..............................................................................................................346 Дополнительная литература...........................................................................347 ЧАСТЬ III. К ЛАССЫ И ПРОТОКОЛЫ................................351 Глава 11. Объект в духе Python.....................................................352 Что нового в этой главе...................................................................................353 Представления объекта...................................................................................353 И снова класс вектора.....................................................................................354 Альтернативный конструктор........................................................................356 Декораторы classmethod и staticmethod........................................................357 Форматирование при выводе.........................................................................358 Хешируемый класс Vector2d...........................................................................361 Поддержка позиционного сопоставления с образцом.................................363 Полный код класса Vector2d, версия 3............................................................365 Закрытые и «защищенные» атрибуты в Python............................................368 Экономия памяти с помощью атрибута класса __slots__..............................370 Простое измерение экономии, достигаемой за счет __slot__...................372 Проблемы при использовании __slots__.....................................................373 Переопределение атрибутов класса...............................................................374 Резюме..............................................................................................................376 Дополнительная литература...........................................................................377 Глава 12. Специальные методы для последовательностей.....381 Что нового в этой главе...................................................................................381 Vector: пользовательский тип последовательности......................................382 Vector, попытка No 1: совместимость с Vector2d............................................382 Протоколы и утиная типизация.....................................................................385 Vector, попытка No 2: последовательность, допускающая срез....................386 Как работает срезка.....................................................................................387 Метод __getitem__ с учетом срезов.............................................................388 Vector, попытка No 3: доступ к динамическим атрибутам...........................390 Vector, попытка No 4: хеширование и ускорение оператора ==...................393 Vector, попытка No 5: форматирование.........................................................399 Резюме..............................................................................................................406 Дополнительная литература...........................................................................407 Глава 13. Интерфейсы, протоколы и ABC.....................................411 Карта типизации..............................................................................................412 Что нового в этой главе...................................................................................413 Два вида протоколов.......................................................................................413 Программирование уток.................................................................................415 Python в поисках следов последовательностей.........................................415 Партизанское латание как средство реализации протокола во время выполнения......................................................................................417 Защитное программирование и принцип быстрого отказа....................419 Гусиная типизация..........................................................................................421 Создание подкласса ABC.................................................................................426 ABC в стандартной библиотеке......................................................................427 Определение и использование ABC...............................................................430 Синтаксические детали ABC.......................................................................435 Создание подклассов ABC...........................................................................435 Виртуальный подкласс Tombola.................................................................438 Использование функции register на практике..............................................440 ABC и структурная типизация....................................................................440 Статические протоколы..................................................................................442 Типизированная функция double...............................................................443 Статические протоколы, допускающие проверку во время выполнения......444 Ограничения протоколов, допускающих проверку во время выполнения..................................................................................447 Поддержка статического протокола..........................................................448 Проектирование статического протокола.................................................450 Рекомендации по проектированию протоколов......................................451 Расширение протокола...............................................................................452 ABC из пакета numbers и числовые протоколы........................................453 Резюме..............................................................................................................456 Дополнительная литература...........................................................................457 Глава 14. Наследование: к добру или к худу..............................462 Что нового в этой главе...................................................................................463 Функция super()...............................................................................................463 Сложности наследования встроенным типам...............................................465 Множественное наследование и порядок разрешения методов.................468 Классы-примеси..............................................................................................473 Отображения, не зависящие от регистра...................................................473 Множественное наследование в реальном мире..........................................475 ABC – тоже примеси....................................................................................475 ThreadingMixIn и ForkingMixIn...................................................................475 Множественное наследование в Tkinter....................................................480 Жизнь с множественным наследованием.....................................................482 Предпочитайте композицию наследованию класса.................................483 Разберитесь, зачем наследование используется в каждом конкретном случае.....................................................................483 Определяйте интерфейсы явно с помощью ABC......................................483 Используйте примеси для повторного использования кода...................484 Предоставляйте пользователям агрегатные классы................................484 Наследуйте только классам, предназначенным для наследования.........484 Воздерживайтесь от наследования конкретным классам........................485 Tkinter: хороший, плохой, злой..................................................................485 Резюме..............................................................................................................487 Дополнительная литература...........................................................................488 Глава 15. Еще об аннотациях типов..............................................492 Что нового в этой главе...................................................................................492 Перегруженные сигнатуры.............................................................................492 Перегрузка max............................................................................................494 Уроки перегрузки max.................................................................................498 TypedDict..........................................................................................................498 Приведение типов...........................................................................................505 Чтение аннотаций типов во время выполнения...........................................508 Проблемы с аннотациями во время выполнения.....................................508 Как решать проблему..................................................................................511 Реализация обобщенного класса....................................................................511 Основы терминологии, относящейся к обобщенным типам...................513 Вариантность...................................................................................................514 Инвариантный разливочный автомат.......................................................514 Ковариантный разливочный автомат........................................................516 Контравариантная урна..............................................................................516 Обзор вариантности....................................................................................518 Реализация обобщенного статического протокола......................................520 Резюме..............................................................................................................522 Дополнительная литература...........................................................................523 Глава 16. Перегрузка операторов.................................................528 Что нового в этой главе...................................................................................529 Основы перегрузки операторов.....................................................................529 Унарные операторы........................................................................................530 Перегрузка оператора сложения векторов +.................................................533 Перегрузка оператора умножения на скаляр ..............................................538 Использование @ как инфиксного оператора..............................................540 Арифметические операторы – итоги.............................................................541 Операторы сравнения.....................................................................................542 Операторы составного присваивания...........................................................545 Резюме..............................................................................................................549 Дополнительная литература...........................................................................550 ЧАСТЬ IV. ПОТОК УПРАВЛЕНИЯ......................................555 Глава 17. Итераторы, генераторы и классические сопрограммы........................................................556 Что нового в этой главе...................................................................................557 Последовательность слов................................................................................557 Почему последовательности итерируемы: функция iter..............................558 Использование iter в сочетании с Callable.................................................560 Итерируемые объекты и итераторы..............................................................561 Классы Sentence с методом __iter__................................................................564 Класс Sentence, попытка No 2: классический итератор............................565 Не делайте итерируемый объект итератором для самого себя................566 Класс Sentence, попытка No 3: генераторная функция.............................567 Как работает генератор...............................................................................568 Ленивые классы Sentence................................................................................570 Класс Sentence, попытка No 4: ленивый генератор...................................570 Класс Sentence, попытка No 5: генераторное выражение.........................571 Генераторные выражения: когда использовать............................................573 Генератор арифметической прогрессии........................................................575 Построение арифметической прогрессии с помощью itertools...............577 Генераторные функции в стандартной библиотеке......................................578 Функции редуцирования итерируемого объекта..........................................588 yield from и субгенераторы.............................................................................590 Изобретаем chain заново............................................................................591 Обход дерева................................................................................................592 Обобщенные итерируемые типы...................................................................596 Классические сопрограммы............................................................................597 Пример: сопрограмма для вычисления накопительного среднего........599 Возврат значения из сопрограммы............................................................601 Аннотации обобщенных типов для классических сопрограмм...............605 Резюме..............................................................................................................607 Дополнительная литература...........................................................................607 Глава 18. Блоки with, match и else................................................612 Что нового в этой главе...................................................................................613 Контекстные менеджеры и блоки with..........................................................613 Утилиты contextlib.......................................................................................617 Использование @contextmanager..............................................................618 Сопоставление с образцом в lis.py: развернутый пример............................622 Синтаксис Scheme.......................................................................................622 Предложения импорта и типы...................................................................623 Синтаксический анализатор......................................................................624 Класс Environment.......................................................................................626 Цикл REPL....................................................................................................628 Вычислитель................................................................................................629 Procedure: класс, реализующий замыкание..............................................636 Использование OR-образцов......................................................................637 Делай то, потом это: блоки else вне if............................................................638 Резюме..............................................................................................................640 Дополнительная литература...........................................................................641 Глава 19. Модели конкурентности в Python................................646 Что нового в этой главе...................................................................................647 Общая картина.................................................................................................647 Немного терминологии...................................................................................648 Процессы, потоки и знаменитая блокировка GIL в Python .....................650 Конкурентная программа Hello World...........................................................652 Анимированный индикатор с потоками...................................................652 Индикатор с процессами............................................................................655 Индикатор с сопрограммами.....................................................................656 Сравнение супервизоров............................................................................660 Истинное влияние GIL................................................................................662 Проверка знаний.........................................................................................662 Доморощенный пул процессов......................................................................665 Решение на основе процессов....................................................................666 Интерпретация времени работы................................................................667 Код проверки на простоту для многоядерной машины...........................668 Эксперименты с большим и меньшим числом процессов.......................671 Не решение на основе потоков...................................................................672 Python в многоядерном мире.........................................................................673 Системное администрирование.................................................................674 Наука о данных............................................................................................675 Веб-разработка на стороне сервера и на мобильных устройствах..........676 WSGI-серверы приложений........................................................................678 Распределенные очереди задач..................................................................680 Резюме..............................................................................................................681 Дополнительная литература...........................................................................682 Конкурентность с применением потоков и процессов............................682 GIL.................................................................................................................684 Конкурентность за пределами стандартной библиотеки.........................684 Конкурентность и масштабируемость за пределами Python...................686 Глава 20. Конкурентные исполнители..........................................691 Что нового в этой главе...................................................................................691 Конкурентная загрузка из веба......................................................................692 Скрипт последовательной загрузки...........................................................694 Загрузка с применением библиотеки concurrent.futures.........................696 Где находятся будущие объекты?...............................................................698 Запуск процессов с помощью concurrent.futures..........................................701 И снова о проверке на простоту на многоядерной машине....................701 Эксперименты с Executor.map....................................................................704 Загрузка с индикацией хода выполнения и обработкой ошибок................707 Обработка ошибок во flags2-примерах......................................................711 Использование futures.as_completed..........................................................713 Резюме..............................................................................................................716 Дополнительная литература...........................................................................716 Глава 21. Асинхронное программирование................................719 Что нового в этой главе...................................................................................720 Несколько определений..................................................................................720 Пример использования asyncio: проверка доменных имен....................721 Предложенный Гвидо способ чтения асинхронного кода........................723 Новая концепция: объекты, допускающие ожидание..................................724 Загрузка файлов с помощью asyncio и HTTPX..............................................725 Секрет платформенных сопрограмм: скромные генераторы..................727 Проблема «все или ничего»........................................................................728 Асинхронные контекстные менеджеры.........................................................729 Улучшение асинхронного загрузчика............................................................730 Использование asyncio.as_completed и потока..........................................731 Регулирование темпа запросов с помощью семафора.............................733 Отправка нескольких запросов при каждой загрузке..............................736 Делегирование задач исполнителям..............................................................739 Написание асинхронных серверов.................................................................740 Веб-служба FastAPI......................................................................................742 Асинхронный TCP-сервер...........................................................................746 Асинхронные итераторы и итерируемые объекты.......................................751 Асинхронные генераторные функции.......................................................752 Асинхронные включения и асинхронные генераторные выражения...... 758 async за пределами asyncio: Curio..............................................................760 Аннотации типов для асинхронных объектов..............................................763 Как работает и как не работает асинхронность............................................764 Круги, разбегающиеся вокруг блокирующих вызовов.............................764 Миф о системах, ограниченных вводом-выводом...................................765 Как не попасть в ловушку счетных функций.............................................765 Резюме..............................................................................................................766 Дополнительная литература...........................................................................767 ЧАСТЬ V. МЕТАПРОГРАММИРОВАНИЕ..........................771 Глава 22. Динамические атрибуты и свойства...........................772 Что нового в этой главе...................................................................................772 Применение динамических атрибутов для обработки данных...................773 Исследование JSON-подобных данных с динамическими атрибутами..... 775 Проблема недопустимого имени атрибута...............................................778 Гибкое создание объектов с помощью метода __new__.............................779 Вычисляемые свойства...................................................................................781 Шаг 1: создание управляемого данными атрибута...................................782 Шаг 2: выборка связанных записей с помощью свойств..........................784 Шаг 3: переопределение существующего атрибута свойством................787 Шаг 4: кеширование свойств на заказ........................................................788 Шаг 5: кеширование свойств с помощью functools...................................789 Использование свойств для контроля атрибутов..........................................791 LineItem, попытка No 1: класс строки заказа.............................................791 LineItem, попытка No 2: контролирующее свойство.................................792 Правильный взгляд на свойства.....................................................................794 Свойства переопределяют атрибуты экземпляра.....................................795 Документирование свойств........................................................................797 Программирование фабрики свойств............................................................798 Удаление атрибутов.........................................................................................800 Важные атрибуты и функции для работы с атрибутами..............................802 Специальные атрибуты, влияющие на обработку атрибутов..................802 Встроенные функции для работы с атрибутами.......................................803 Специальные методы для работы с атрибутами.......................................804 Резюме..............................................................................................................805 Дополнительная литература...........................................................................806 Глава 23. Дескрипторы атрибутов................................................810 Что нового в этой главе...................................................................................810 Пример дескриптора: проверка значений атрибутов..................................811 LineItem попытка No 3: простой дескриптор.............................................811 LineItem попытка No 4: автоматическое генерирование имен атрибутов хранения...........................................................................816 LineItem попытка No 5: новый тип дескриптора.......................................818 Переопределяющие и непереопределяющие дескрипторы........................820 Переопределяющие дескрипторы..............................................................822 Переопределяющий дескриптор без __get__..............................................823 Непереопределяющий дескриптор............................................................824 Перезаписывание дескриптора в классе...................................................825 Методы являются дескрипторами.................................................................826 Советы по использованию дескрипторов......................................................828 Строка документации дескриптора и перехват удаления............................829 Резюме..............................................................................................................831 Дополнительная литература...........................................................................831 Глава 24. Метапрограммирование классов.................................834 Что нового в этой главе...................................................................................835 Классы как объекты.........................................................................................835 type: встроенная фабрика классов.................................................................836 Функция-фабрика классов..............................................................................837 Введение в __init_subclass__.........................................................................840 Почему __init_subclass__ не может конфигурировать __slots__.................846 Дополнение класса с помощью декоратора класса.......................................847 Что когда происходит: этап импорта и этап выполнения............................849 Демонстрация работы интерпретатора.....................................................850 Основы метаклассов........................................................................................854 Как метакласс настраивает класс...............................................................856 Элегантный пример метакласса.................................................................857 Демонстрация работы метакласса.............................................................860 Реализация Checked с помощью метакласса.................................................864 Метаклассы на практике.................................................................................868 Современные средства позволяют упростить или заменить метаклассы...........................................................................868 Метаклассы – стабильное языковое средство...........................................869 У класса может быть только один метакласс.............................................869 Метаклассы должны быть деталью реализации.......................................870 Метаклассный трюк с __prepare__...................................................................870 Заключение......................................................................................................872 Резюме..............................................................................................................873 Дополнительная литература...........................................................................874 Послесловие.....................................................................................878 Предметный указатель...................................................................881 Код примеров книги Download Скачать раздачу по magnet-ссылке 20.4 MB Rutracker.org не распространяет и не хранит электронные версии произведений, а лишь предоставляет доступ к создаваемому пользователями каталогу ссылок на торрент-файлы, которые содержат только списки хеш-сумм Как скачивать?* (для скачивания .torrent* файлов необходима регистрация)*
[Профиль] [ЛС]
mpv777 Стаж: 17 лет 4 месяца Сообщений: 33047	mpv777 · 16-Сен-22 14:53 (спустя 4 часа) [Цитировать] 0balance Встаньте на раздачу. ⇒Как начать раздачу ⇒Обход блокировки bt*. трекеров (основные инструкции)
[Профиль] [ЛС]
Bopox_82 Стаж: 16 лет 11 месяцев Сообщений: 1	Bopox_82 · 04-Окт-22 00:11 (спустя 17 дней, ред. 04-Окт-22 00:11) [Цитировать]
[Профиль] [ЛС]
mpv777 Стаж: 17 лет 4 месяца Сообщений: 33047	mpv777 · 04-Окт-22 05:06 (спустя 4 часа) [Цитировать] Bopox_82 Другим торрент-клиентом попробуйте открыть.
[Профиль] [ЛС]
andrhor Стаж: 14 лет 8 месяцев Сообщений: 14	andrhor · 08-Окт-22 19:56 (спустя 4 дня) [Цитировать] 0balance Это для продолжающих, или начинающим тоже подойдет?
[Профиль] [ЛС]
Angraver Стаж: 14 лет 11 месяцев Сообщений: 1	Angraver · 14-Окт-22 12:08 (спустя 5 дней) [Цитировать] andrhor писал(а): 837290880balance Это для продолжающих, или начинающим тоже подойдет? Начинающим категорически не подойдет. Для начинающих очень рекомендую Бэрри П. Изучаем программирование на Python
[Профиль] [ЛС]
teb2 Стаж: 16 лет 2 месяца Сообщений: 4	teb2 · 14-Окт-22 19:37 (спустя 7 часов, ред. 14-Окт-22 19:37) [Цитировать] 0balance В клиенте transmission 3.0 (Debian) торрент не открылся, magnet-ссылка открылась. Скачивание по magnet-ссылке не начинается, хотя источников обнаружено 31. Пишет "Ошибка. Невозможно подключиться к трекеру". Хотя после открытия этой magnet-ссылки спокойно скачался оригинал этой книги на английском по ссылке: https://rutr.life/forum/viewtopic.php?t=6241982.
[Профиль] [ЛС]
Andruta27 Стаж: 10 лет 7 месяцев Сообщений: 14	Andruta27 · 19-Окт-22 13:20 (спустя 4 дня, ред. 19-Окт-22 13:20) [Цитировать] На "ннм клуб" посмотрите. Там рабочая ссылка.
[Профиль] [ЛС]
realboost Стаж: 15 лет 10 месяцев Сообщений: 24	realboost · 23-Дек-23 18:33 (спустя 1 год 2 месяца) [Цитировать] Торрент в transmission действительно не открывается. В pdf заметил проблему с оглавлением: номер части отображается не там Глава 7 должна быть внутри части II.
[Профиль] [ЛС]
realboost Стаж: 15 лет 10 месяцев Сообщений: 24	realboost · 27-Дек-23 02:21 (спустя 3 дня) [Цитировать] Вот исправленное оглавление с правильной вложенностью: скрытый текст Код: 0 1 Обложка 0 5 Оглавление 0 18 Предисловие от издательства 0 19 Об авторе 0 19 Колофон 0 20 Предисловие 1 20 На кого рассчитана эта книга 1 21 На кого эта книга не рассчитана 1 21 Пять книг в одной 2 21 Как организована эта книга 1 23 Практикум 1 24 Поговорим: мое личное мнение 1 24 Сопроводительный сайт: fluentpython.com 1 24 Графические выделения 1 25 О примерах кода 1 25 Как с нами связаться 1 26 Благодарности 2 27 Благодарности к первому изданию 0 30 Часть I. Структуры данных 1 31 Глава 1. Модель данных 2 32 Что нового в этой главе 2 32 Колода карт на Python 2 35 Как используются специальные методы 3 36 Эмуляция числовых типов 3 39 Строковое представление 3 40 Булево значение пользовательского типа 3 40 API коллекций 2 42 Сводка специальных методов 2 44 Почему len – не метод 2 44 Резюме 2 45 Дополнительная литература 1 47 Глава 2. Массив последовательностей 2 48 Что нового в этой главе 2 48 Общие сведения о встроенных последовательностях 2 50 Списковое включение и генераторные выражения 3 51 Списковое включение и удобочитаемость 3 52 Сравнение спискового включения с map и filter 3 53 Декартовы произведения 3 54 Генераторные выражения 2 56 Кортеж – не просто неизменяемый список 3 56 Кортежи как записи 3 57 Кортежи как неизменяемые списки 3 59 Сравнение методов кортежа и списка 2 60 Распаковка последовательностей и итерируемых объектов 3 61 Использование * для выборки лишних элементов 3 62 Распаковка с помощью * в вызовах функций и литеральных последовательностях 3 62 Распаковка вложенных объектов 2 63 Сопоставление с последовательностями-образцами 3 68 Сопоставление с последовательностями-образцами в интерпретаторе 2 71 Получение среза 3 72 Почему в срезы и диапазоны не включается последний элемент 3 72 Объекты среза 3 73 Многомерные срезы и многоточие 3 74 Присваивание срезу 2 75 Использование + и * для последовательностей 3 75 Построение списка списков 3 77 Составное присваивание последовательностей 3 78 Головоломка: присваивание A += 2 80 Метод list.sort и встроенная функция sorted 2 82 Когда список не подходит 3 82 Массивы 3 85 Представления областей памяти 3 87 NumPy 3 89 Двусторонние и другие очереди 2 92 Резюме 2 93 Дополнительная литература 1 98 Глава 3. Словари и множества 2 98 Что нового в этой главе 2 99 Современный синтаксис словарей 3 99 Словарные включения 3 100 Распаковка отображений 3 101 Объединение отображений оператором \| 2 101 Сопоставление с отображением-образцом 2 104 Стандартный API типов отображений 3 104 Что значит «хешируемый»? 3 105 Обзор наиболее употребительных методов отображений 3 107 Вставка и обновление изменяемых значений 2 110 Автоматическая обработка отсутствующих ключей 3 110 defaultdict: еще один подход к обработке отсутствия ключа 3 111 Метод __missing__ 3 113 Несогласованное использование __missing__ в стандартной библиотеке 2 114 Вариации на тему dict 3 114 collections.OrderedDict 3 115 collections.ChainMap 3 116 collections.Counter 3 116 shelve.Shelf 3 117 Создание подкласса UserDict вместо dict 2 119 Неизменяемые отображения 2 120 Представления словаря 2 121 Практические последствия внутреннего устройства класса dict 2 122 Теория множеств 3 124 Литеральные множества 3 125 Множественное включение 2 125 Практические последствия внутреннего устройства класса set 3 126 Операции над множествами 2 128 Теоретико-множественные операции над представлениями словарей 2 130 Резюме 2 131 Дополнительная литература 1 134 Глава 4. Unicode-текст и байты 2 135 Что нового в этой главе 2 135 О символах, и не только 2 136 Все, что нужно знать о байтах 2 139 Базовые кодировщики и декодировщики 2 140 Проблемы кодирования и декодирования 3 141 Обработка UnicodeEncodeError 3 142 Обработка UnicodeDecodeError 3 143 Исключение SyntaxError при загрузке модулей с неожиданной кодировкой 3 144 Как определить кодировку последовательности байтов 3 145 BOM: полезный крокозябр 2 146 Обработка текстовых файлов 3 149 Остерегайтесь кодировок по умолчанию 2 154 Нормализация Unicode для надежного сравнения 3 157 Сворачивание регистра 3 157 Служебные функции для сравнения нормализованного текста 3 158 Экстремальная «нормализация»: удаление диакритических знаков 2 161 Сортировка Unicode-текстов 3 163 Сортировка с помощью алгоритма упорядочивания Unicode 2 164 База данных Unicode 3 164 Поиск символов по имени 3 166 Символы, связанные с числами 2 167 Двухрежимный API 3 167 str и bytes в регулярных выражениях 3 169 str и bytes в функциях из модуля os 2 169 Резюме 2 170 Дополнительная литература 1 175 Глава 5. Построители классов данных 2 176 Что нового в этой главе 2 176 Обзор построителей классов данных 3 178 Основные возможности 2 180 Классические именованные кортежи 2 183 Типизированные именованные кортежи 2 184 Краткое введение в аннотации типов 3 184 Никаких последствий во время выполнения 3 185 Синтаксис аннотаций переменных 3 185 Семантика аннотаций переменных 4 186 Инспекция typing.NamedTuple 4 187 Инспектирование класса с декоратором dataclass 2 189 Еще о @dataclass 3 190 Опции полей 3 193 Постинициализация 3 195 Типизированные атрибуты класса 3 195 Инициализируемые переменные, не являющиеся полями 3 196 Пример использования @dataclass: запись о ресурсе из дублинского ядра 2 198 Класс данных как признак кода с душком 3 200 Класс данных как временная конструкция 3 200 Класс данных как промежуточное представление 2 200 Сопоставление с экземплярами классов – образцами 3 201 Простые классы-образцы 3 201 Именованные классы-образцы 3 203 Позиционные классы-образцы 2 204 Резюме 2 204 Дополнительная литература 1 208 Глава 6. Ссылки на объекты, изменяемость и повторное использование 2 209 Что нового в этой главе 2 209 Переменные – не ящики 2 211 Тождественность, равенство и псевдонимы 3 212 Выбор между == и is 3 213 Относительная неизменяемость кортежей 2 214 По умолчанию копирование поверхностное 3 217 Глубокое и поверхностное копирование произвольных объектов 2 218 Параметры функций как ссылки 3 219 Значения по умолчанию изменяемого типа: неудачная мысль 3 221 Защитное программирование при наличии изменяемых параметров 2 223 del и сборка мусора 2 225 Как Python хитрит с неизменяемыми объектами 2 227 Резюме 2 228 Дополнительная литература 0 232 Часть II. Функции как объекты 1 233 Глава 7. 233 Функции как полноправные объекты 2 234 Что нового в этой главе 2 234 Обращение с функцией как с объектом 2 235 Функции высшего порядка 3 236 Современные альтернативы функциям map, filter и reduce 2 238 Анонимные функции 2 239 Девять видов вызываемых объектов 2 240 Пользовательские вызываемые типы 2 241 От позиционных к чисто именованным параметрам 3 243 Чисто позиционные параметры 2 244 Пакеты для функционального программирования 3 244 Модуль operator 3 247 Фиксация аргументов с помощью functools.partial 2 249 Резюме 2 249 Дополнительная литература 1 253 Глава 8. Аннотации типов в функциях 2 254 Что нового в этой главе 2 254 О постепенной типизации 2 255 Постепенная типизация на практике 3 256 Начинаем работать с Mypy 3 257 А теперь построже 3 257 Значение параметра по умолчанию 3 259 None в качестве значения по умолчанию 2 260 Типы определяются тем, какие операции они поддерживают 2 265 Типы, пригодные для использования в аннотациях 3 265 Тип Any 4 266 «Является подтипом» и «совместим с» 3 268 Простые типы и классы 3 268 Типы Optional и Union 3 269 Обобщенные коллекции 3 272 Типы кортежей 3 274 Обобщенные отображения 3 275 Абстрактные базовые классы 3 277 Тип Iterable 3 279 Параметризованные обобщенные типы и TypeVar 3 283 Статические протоколы 3 287 Тип Callable 3 290 Тип NoReturn 2 290 Аннотирование чисто позиционных и вариадических параметров 2 291 Несовершенная типизация и строгое тестирование 2 292 Резюме 2 293 Дополнительная литература 1 299 Глава 9. Декораторы и замыкания 2 300 Что нового в этой главе 2 300 Краткое введение в декораторы 2 301 Когда Python выполняет декораторы 2 303 Регистрационные декораторы 2 303 Правила видимости переменных 2 306 Замыкания 2 309 Объявление nonlocal 3 310 Логика поиска переменных 2 311 Реализация простого декоратора 3 312 Как это работает 2 313 Декораторы в стандартной библиотеке 3 314 Запоминание с помощью functools.cache 3 316 Использование lru_cache 3 317 Обобщенные функции с одиночной диспетчеризацией 2 321 Параметризованные декораторы 3 322 Параметризованный регистрационный декоратор 3 323 Параметризованный декоратор clock 3 326 Декоратор clock на основе класса 2 327 Резюме 2 327 Дополнительная литература 1 332 Глава 10. Реализация паттернов проектирования с помощью полноправных функций 2 333 Что нового в этой главе 2 333 Практический пример: переработка паттерна Стратегия 3 333 Классическая Стратегия 3 337 Функционально-ориентированная стратегия 3 340 Выбор наилучшей стратегии: простой подход 3 341 Поиск стратегий в модуле 2 342 Паттерн Стратегия, дополненный декоратором 2 344 Паттерн Команда 2 345 Резюме 2 346 Дополнительная литература 0 350 Часть III. Классы и протоколы 1 351 Глава 11. Объект в духе Python 2 352 Что нового в этой главе 2 352 Представления объекта 2 353 И снова класс вектора 2 355 Альтернативный конструктор 2 356 Декораторы classmethod и staticmethod 2 357 Форматирование при выводе 2 360 Хешируемый класс Vector2d 2 362 Поддержка позиционного сопоставления с образцом 2 364 Полный код класса Vector2d, версия 3 2 367 Закрытые и «защищенные» атрибуты в Python 2 369 Экономия памяти с помощью атрибута класса __slots__ 3 371 Простое измерение экономии, достигаемой за счет __slot__ 3 372 Проблемы при использовании __slots__ 2 373 Переопределение атрибутов класса 2 375 Резюме 2 376 Дополнительная литература 1 380 Глава 12. Специальные методы для последовательностей 2 380 Что нового в этой главе 2 381 Vector: пользовательский тип последовательности 2 381 Vector, попытка № 1: совместимость с Vector2d 2 384 Протоколы и утиная типизация 2 385 Vector, попытка № 2: последовательность, допускающая срез 3 386 Как работает срезка 3 387 Метод __getitem__ с учетом срезов 2 389 Vector, попытка № 3: доступ к динамическим атрибутам 2 392 Vector, попытка № 4: хеширование и ускорение оператора == 2 398 Vector, попытка № 5: форматирование 2 405 Резюме 2 406 Дополнительная литература 1 410 Глава 13. Интерфейсы, протоколы и ABC 2 411 Карта типизации 2 412 Что нового в этой главе 2 412 Два вида протоколов 2 414 Программирование уток 3 414 Python в поисках следов последовательностей 3 416 Партизанское латание как средство реализации протокола во время выполнения 3 418 Защитное программирование и принцип быстрого отказа 2 420 Гусиная типизация 3 425 Создание подкласса ABC 3 426 ABC в стандартной библиотеке 3 429 Определение и использование ABC 3 434 Синтаксические детали ABC 3 434 Создание подклассов ABC 3 437 Виртуальный подкласс Tombola 3 439 Использование функции register на практике 3 439 ABC и структурная типизация 2 441 Статические протоколы 3 442 Типизированная функция double 3 443 Статические протоколы, допускающие проверку во время выполнения 3 446 Ограничения протоколов, допускающих проверку во время выполнения 3 447 Поддержка статического протокола 3 449 Проектирование статического протокола 3 450 Рекомендации по проектированию протоколов 3 451 Расширение протокола 3 452 ABC из пакета numbers и числовые протоколы 2 455 Резюме 2 456 Дополнительная литература 1 461 Глава 14. Наследование: к добру или к худу 2 462 Что нового в этой главе 2 462 Функция super() 2 464 Сложности наследования встроенным типам 2 467 Множественное наследование и порядок разрешения методов 2 472 Классы-примеси 3 472 Отображения, не зависящие от регистра 2 474 Множественное наследование в реальном мире 3 474 ABC – тоже примеси 3 474 ThreadingMixIn и ForkingMixIn 3 476 Примеси в обобщенных представлениях Django 3 479 Множественное наследование в Tkinter 2 481 Жизнь с множественным наследованием 3 482 Предпочитайте композицию наследованию класса 3 482 Разберитесь, зачем наследование используется в каждом конкретном случае 3 482 Определяйте интерфейсы явно с помощью ABC 3 483 Используйте примеси для повторного использования кода 3 483 Предоставляйте пользователям агрегатные классы 3 483 Наследуйте только классам, предназначенным для наследования 3 484 Воздерживайтесь от наследования конкретным классам 3 484 Tkinter: хороший, плохой, злой 2 486 Резюме 2 487 Дополнительная литература 1 491 Глава 15. Еще об аннотациях типов 2 491 Что нового в этой главе 2 491 Перегруженные сигнатуры 3 493 Перегрузка max 3 497 Уроки перегрузки max 2 497 TypedDict 2 504 Приведение типов 2 507 Чтение аннотаций типов во время выполнения 3 507 Проблемы с аннотациями во время выполнения 3 510 Как решать проблему 2 510 Реализация обобщенного класса 3 512 Основы терминологии, относящейся к обобщенным типам 2 513 Вариантность 3 513 Инвариантный разливочный автомат 3 515 Ковариантный разливочный автомат 3 515 Контравариантная урна 3 517 Обзор вариантности 2 519 Реализация обобщенного статического протокола 2 521 Резюме 2 522 Дополнительная литература 1 527 Глава 16. Перегрузка операторов 2 528 Что нового в этой главе 2 528 Основы перегрузки операторов 2 529 Унарные операторы 2 532 Перегрузка оператора сложения векторов + 2 537 Перегрузка оператора умножения на скаляр * 2 539 Использование @ как инфиксного оператора 2 540 Арифметические операторы – итоги 2 541 Операторы сравнения 2 544 Операторы составного присваивания 2 548 Резюме 2 549 Дополнительная литература 0 554 Часть IV. Поток управления 1 555 Глава 17. Итераторы, генераторы и классические сопрограммы 2 556 Что нового в этой главе 2 556 Последовательность слов 2 557 Почему последовательности итерируемы: функция iter 3 559 Использование iter в сочетании с Callable 2 560 Итерируемые объекты и итераторы 2 563 Классы Sentence с методом __iter__ 3 564 Класс Sentence, попытка № 2: классический итератор 3 565 Не делайте итерируемый объект итератором для самого себя 3 566 Класс Sentence, попытка № 3: генераторная функция 3 567 Как работает генератор 2 569 Ленивые классы Sentence 3 569 Класс Sentence, попытка № 4: ленивый генератор 3 570 Класс Sentence, попытка № 5: генераторное выражение 2 572 Генераторные выражения: когда использовать 2 574 Генератор арифметической прогрессии 3 576 Построение арифметической прогрессии с помощью itertools 2 577 Генераторные функции в стандартной библиотеке 2 587 Функции редуцирования итерируемого объекта 2 589 yield from и субгенераторы 3 590 Изобретаем chain заново 3 591 Обход дерева 2 595 Обобщенные итерируемые типы 2 596 Классические сопрограммы 3 598 Пример: сопрограмма для вычисления накопительного среднего 3 600 Возврат значения из сопрограммы 3 604 Аннотации обобщенных типов для классических сопрограмм 2 606 Резюме 2 606 Дополнительная литература 1 611 Глава 18. Блоки with, match и else 2 612 Что нового в этой главе 2 612 Контекстные менеджеры и блоки with 3 616 Утилиты contextlib 3 617 Использование @contextmanager 2 621 Сопоставление с образцом в lis.py: развернутый пример 3 621 Синтаксис Scheme 3 622 Предложения импорта и типы 3 623 Синтаксический анализатор 3 625 Класс Environment 3 627 Цикл REPL 3 628 Вычислитель 3 635 Procedure: класс, реализующий замыкание 3 636 Использование OR-образцов 2 637 Делай то, потом это: блоки else вне if 2 639 Резюме 2 640 Дополнительная литература 1 645 Глава 19. Модели конкурентности в Python 2 646 Что нового в этой главе 2 646 Общая картина 2 647 Немного терминологии 3 649 Процессы, потоки и знаменитая блокировка GIL в Python 2 651 Конкурентная программа Hello World 3 651 Анимированный индикатор с потоками 3 654 Индикатор с процессами 3 655 Индикатор с сопрограммами 3 659 Сравнение супервизоров 2 661 Истинное влияние GIL 3 661 Проверка знаний 2 664 Доморощенный пул процессов 3 665 Решение на основе процессов 3 666 Интерпретация времени работы 3 667 Код проверки на простоту для многоядерной машины 3 670 Эксперименты с большим и меньшим числом процессов 3 671 Не решение на основе потоков 2 672 Python в многоядерном мире 3 673 Системное администрирование 3 674 Наука о данных 3 675 Веб-разработка на стороне сервера и на мобильных устройствах 3 677 WSGI-серверы приложений 3 679 Распределенные очереди задач 2 680 Резюме 2 681 Дополнительная литература 3 681 Конкурентность с применением потоков и процессов 3 683 GIL 3 683 Конкурентность за пределами стандартной библиотеки 3 685 Конкурентность и масштабируемость за пределами Python 1 690 Глава 20. Конкурентные исполнители 2 690 Что нового в этой главе 2 691 Конкурентная загрузка из веба 3 693 Скрипт последовательной загрузки 3 695 Загрузка с применением библиотеки concurrent.futures 3 697 Где находятся будущие объекты? 2 700 Запуск процессов с помощью concurrent.futures 3 700 И снова о проверке на простоту на многоядерной машине 2 703 Эксперименты с Executor.map 2 706 Загрузка с индикацией хода выполнения и обработкой ошибок 3 710 Обработка ошибок во flags2-примерах 3 712 Использование futures.as_completed 2 715 Резюме 2 715 Дополнительная литература 1 718 Глава 21. Асинхронное программирование 2 719 Что нового в этой главе 2 719 Несколько определений 2 720 Пример использования asyncio: проверка доменных имен 3 722 Предложенный Гвидо способ чтения асинхронного кода 2 723 Новая концепция: объекты, допускающие ожидание 2 724 Загрузка файлов с помощью asyncio и HTTPX 3 726 Секрет платформенных сопрограмм: скромные генераторы 3 727 Проблема «все или ничего» 2 728 Асинхронные контекстные менеджеры 2 729 Улучшение асинхронного загрузчика 3 730 Использование asyncio.as_completed и потока 3 732 Регулирование темпа запросов с помощью семафора 3 735 Отправка нескольких запросов при каждой загрузке 2 738 Делегирование задач исполнителям 2 739 Написание асинхронных серверов 3 741 Веб-служба FastAPI 3 745 Асинхронный TCP-сервер 2 750 Асинхронные итераторы и итерируемые объекты 3 751 Асинхронные генераторные функции 3 757 Асинхронные включения и асинхронные генераторные выражения 2 759 async за пределами asyncio: Curio 2 762 Аннотации типов для асинхронных объектов 2 763 Как работает и как не работает асинхронность 3 763 Круги, разбегающиеся вокруг блокирующих вызовов 3 764 Миф о системах, ограниченных вводом-выводом 3 764 Как не попасть в ловушку счетных функций 2 765 Резюме 2 766 Дополнительная литература 0 770 Часть V. Метапрограммирование 1 771 Глава 22. Динамические атрибуты и свойства 2 771 Что нового в этой главе 2 772 Применение динамических атрибутов для обработки данных 3 774 Исследование JSON-подобных данных с динамическими атрибутами 3 777 Проблема недопустимого имени атрибута 3 778 Гибкое создание объектов с помощью метода __new__ 2 780 Вычисляемые свойства 3 781 Шаг 1: создание управляемого данными атрибута 3 783 Шаг 2: выборка связанных записей с помощью свойств 3 786 Шаг 3: переопределение существующего атрибута свойством 3 787 Шаг 4: кеширование свойств на заказ 3 788 Шаг 5: кеширование свойств с помощью functools 2 790 Использование свойств для контроля атрибутов 3 790 LineItem, попытка № 1: класс строки заказа 3 791 LineItem, попытка № 2: контролирующее свойство 2 793 Правильный взгляд на свойства 3 794 Свойства переопределяют атрибуты экземпляра 3 796 Документирование свойств 2 797 Программирование фабрики свойств 2 799 Удаление атрибутов 2 801 Важные атрибуты и функции для работы с атрибутами 3 801 Специальные атрибуты, влияющие на обработку атрибутов 3 802 Встроенные функции для работы с атрибутами 3 803 Специальные методы для работы с атрибутами 2 804 Резюме 2 805 Дополнительная литература 1 809 Глава 23. Дескрипторы атрибутов 2 809 Что нового в этой главе 2 810 Пример дескриптора: проверка значений атрибутов 3 810 LineItem попытка № 3: простой дескриптор 3 815 LineItem попытка № 4: автоматическое генерирование имен атрибутов хранения 3 817 LineItem попытка № 5: новый тип дескриптора 2 819 Переопределяющие и непереопределяющие дескрипторы 3 821 Переопределяющие дескрипторы 3 822 Переопределяющий дескриптор без __get__ 3 823 Непереопределяющий дескриптор 3 824 Перезаписывание дескриптора в классе 2 825 Методы являются дескрипторами 2 827 Советы по использованию дескрипторов 2 828 Строка документации дескриптора и перехват удаления 2 830 Резюме 2 830 Дополнительная литература 1 833 Глава 24. Метапрограммирование классов 2 834 Что нового в этой главе 2 834 Классы как объекты 2 835 type: встроенная фабрика классов 2 836 Функция-фабрика классов 2 839 Введение в __init_subclass__ 3 845 Почему __init_subclass__ не может конфигурировать __slots__ 2 846 Дополнение класса с помощью декоратора класса 2 848 Что когда происходит: этап импорта и этап выполнения 3 849 Демонстрация работы интерпретатора 2 853 Основы метаклассов 3 855 Как метакласс настраивает класс 3 856 Элегантный пример метакласса 3 859 Демонстрация работы метакласса 2 863 Реализация Checked с помощью метакласса 2 867 Метаклассы на практике 3 867 Современные средства позволяют упростить или заменить метаклассы 3 868 Метаклассы – стабильное языковое средство 3 868 У класса может быть только один метакласс 3 869 Метаклассы должны быть деталью реализации 2 869 Метаклассный трюк с __prepare__ 2 871 Заключение 2 872 Резюме 2 873 Дополнительная литература 0 877 Послесловие 1 878 Дополнительная литература 0 880 Предметный указатель Для его применения можно использовать утилиту pdfoutline из пакета fntsample (для Debian based дистрибутивов).
[Профиль] [ЛС]
alexdemidov Стаж: 1 год 4 месяца Сообщений: 2	alexdemidov · 02-Июн-24 16:12 (спустя 5 месяцев 6 дней) [Цитировать] Автор, есть возможность перезалить файл?
[Профиль] [ЛС]
Иван Крысин Стаж: 13 лет 1 месяц Сообщений: 3	Иван Крысин · 28-Ноя-24 16:59 (спустя 5 месяцев 26 дней) [Цитировать] Про это уже много раз говорили, но здесь это очень актуально поэтому повторю: читайте оригинал (тут есть), а не перевод, иногда неточный и даже отвратный. Сегодня нужно было повторить итераторы и генераторы, думал сэкономить время, открыл перевод (глава 17 "Iterators, Generators, and Classic Coroutines" / "Итераторы, генераторы и классические сопрограммы") и читаю: Эпиграф: Цитата: When I see patterns in my programs Цитата: Видя в своих программах повторяющиеся структуры Оно конечно так, но паттерн / шаблон проектирования - это термин, и потом соответственно будет разбираться паттерн Итератор и в переводе тоже потом "паттерн Итератор". Раздел "A Sequence of Words" / "Последовательность слов": Цитата: Sentence instances are iterable; we’ll see why in a moment. Цитата: Объекты Sentence являются итерируемыми, скоро мы в этом убедимся. Недаром следующий раздел называется "Почему последовательности итерируемы: функция iter", а то что Sentence итерируема мы уже видим из примера 17.2. Подпись к рис. 17.1: Цитата: Figure 17-1. The Iterable and Iterator ABCs. Methods in italic are abstract. A concrete Iterable.__iter__ should return a new Iterator instance. A concrete Iterator must implement __next__. The Iterator.__iter__ method just returns the instance itself Цитата: Рис. 17.1. Абстрактные классы Iterable и Iterator. Курсивом набраны имена абстрактных методов. Конкретный метод Iterable.iter должен возвращать новый экземпляр Iterator. Конкретный Iterator должен реализовывать метод next. Метод Iterator.iter просто возвращает ссылку на себя Опечатка, понятно что имеется ввиду __next__ и __iter__, но начинающего будет сбивать с толку. Раздел "Iterables Versus Iterators" / "Итерируемые объекты и итераторы": Цитата: Once exhausted, an iterator will always raise StopIteration, which makes it look like it’s empty. Цитата: После исчерпания итератор бесполезен. Да, но оригинал объясняет почему. И вообще это точно перевод? "Sentence Take #2: A Classic Iterator" / "Класс Sentence, попытка № 2: классический итератор" Цитата: The Sentence class in Example 17-4 is iterable because it implements the __iter__ special method, which builds and returns a SentenceIterator. That’s how an iterable and an iterator are related. Цитата: Показанная в примере 17.4 реализация класса Sentence является итерируемой, потому что реализует специальный метод __iter__, который конструирует и возвращает объект SentenceIterator. Именно так работает паттерн проектирования Итератор, описанный в книге «Паттерны проектирования». Это точно перевод? Раздел "How a Generator Works" / "Как работает генератор": Цитата: The body of a generator function often has yield inside a loop, but not necessarily; here I just repeat yield three times. Looking closely, we see gen_123 is a function object. But when invoked, gen_123() returns a generator object. Generator objects implement the Iterator interface, so they are also iterable. We assign this new generator object to g, so we can experiment with it. Because g is an iterator, calling next(g) fetches the next item produced by yield. When the generator function returns, the generator object raises StopIteration. A generator function builds a generator object that wraps the body of the function. When we invoke next() on the generator object, execution advances to the next yield in the function body, and the next() call evaluates to the value yielded when the function body is suspended. Finally, the enclosing generator object created by Python raises StopIteration when the function body returns, in accordance with the Iterator protocol. Цитата: В теле генераторной функции yield часто встречается в цикле, но это необязательно; здесь я просто трижды повторил yield. Приглядевшись, мы увидим, что gen_123 – объект-функция. Но при вызове gen_123() возвращает объект-генератор. Объекты-генераторы реализуют интерфейс Iterator, поэтому являются также итерируемыми объектами. Присваиваем новый объект-генератор переменной g, чтобы с ним можно было экспериментировать. Поскольку g – итератор, вызов next(g) возвращает следующий элемент, порожденный yield. Когда генераторная функция возвращает управление, объект-генератор возбуждает исключение StopIteration. Генераторная функция строит объект-генератор, обертывающий тело функции. При передаче объекта-генератора функции next() выполнение продолжается до следующего предложения yield в теле функции, а вызов next() возвращает значение, порожденное перед приостановкой выполнения функции. Наконец, при возврате из функции обертывающий ее объект-генератор возбуждает исключение StopIteration в полном соответствии с протоколом Iterator. Автор не просто так старательно обходит слово "return" / "возвращать". Следующий же абзац: Цитата: Я считаю, что в терминологии, касающейся получения результатов от генератора, лучше соблюдать строгость. Фраза же «генератор возвращает значения» вносит путаницу. Значения возвращают функции. Вызов генераторной функции возвращает генератор. Генератор отдает значения. Генератор не «возвращает» значение в обычном смысле слова: предложение return в теле генераторной функции приводит к тому, что объект-генератор возбуждает исключение StopIteration. Если написать return x в генераторе, то вызывающая сторона сможет получить значение x из исключения StopIteration, но обычно это делается автоматически с помощью синтаксиса yield from, как будет показано в разделе «Возврат значения из сопрограммы». При объяснении генераторов и yield использовать термин "возвращать"... правильно - ломай мозг! Раздел "How a Generator Works" / "Как работает генератор": Цитата: Надеюсь, теперь понятно, как работает метод Sentence.__iter__ в примере 14.5: __iter__ – генераторная функция, которая конструирует объект-генератор, реализующий интерфейс Iterator, поэтому класс SentenceIterator больше не нужен. , в оригинале: Цитата: Now hopefully it’s clear how Sentence.__iter__ in Example 17-5 works: __iter__ is a generator function which, when called, builds a generator object that implements the Iterator interface, so the SentenceIterator class is no longer needed. Деталь потерялась; ссылка не туда. Короче устал я уже расписывать и цитаты искать, это только 14 страниц. Мне просто страшно с такими приколами асинхронность или метаклассы разбирать. Я вспомнил что пробовал это делать где-то год назад, и перевод дико бесил. Проблема в том, что перевод-то в целом похож на правду, но нюансы крайне важны - для этого и написана эта крутейшая книга. Может в новом тираже издательство всё исправило конечно... но в этой версии так. P. S. Код примеров книги, его бы в шапку добавить.
[Профиль] [ЛС]
mpv777 Стаж: 17 лет 4 месяца Сообщений: 33047	mpv777 · 28-Ноя-24 18:27 (спустя 1 час 28 мин.) [Цитировать] Иван Крысин писал(а): 87047746P. S. Код примеров книги, его бы в шапку добавить. готово в обоих раздачах
[Профиль] [ЛС]

Главная » Книги и журналы » Компьютерная литература » Программирование (книги)

Loading...

Error