es
Feedback

¡No caigas en manos de tramposos! Telemetrio encuentra y marca estos canales 👉 Si quieres ver la etiqueta, suscríbete

Библиотека Python разработчика | Книги по питону

Библиотека Python разработчика | Книги по питону

Ir al canal en Telegram

Погружение в CPython и архитектуру. Разбираем неочевидное поведение (GIL, Memory), Best Practices (SOLID, DDD) и тонкости Django/FastAPI. Решаем задачи с подвохом и оптимизируем алгоритмы. 🐍 По всем вопросам @evgenycarter РКН clck.ru/3Ko7Hq

Mostrar más

📈 Análisis del canal de Telegram Библиотека Python разработчика | Книги по питону

El canal Библиотека Python разработчика | Книги по питону (@bookpython) en el segmento lingüístico de Ruso es un actor destacado. Actualmente la comunidad reúne a 17 904 suscriptores, ocupando la posición 7 304 en la categoría Tecnologías y Aplicaciones y el puesto 36 554 en la región Rusia.

📊 Métricas de audiencia y dinámica

Desde su creación el невідомо, el proyecto ha mostrado un crecimiento acelerado, reuniendo a 17 904 suscriptores.

Según los últimos datos del 15 noviembre, 2026, el canal mantiene una actividad estable. En los últimos 30 días la variación de miembros fue de -116, y en las últimas 24 horas de -5, conservando un alto alcance.

  • Estado de verificación: No verificado
  • Tasa de interacción (ER): El promedio de interacción de la audiencia es 5.44%. Durante las primeras 24 horas tras publicar, el contenido suele obtener 2.71% de reacciones respecto al total de suscriptores.
  • Alcance de las publicaciones: Cada publicación recibe en promedio 974 visualizaciones. En el primer día suele acumular 486 visualizaciones.
  • Reacciones e interacción: La audiencia responde de forma activa: el promedio de reacciones por publicación es 3.
  • Intereses temáticos: El contenido se centra en temas clave como numbers, yield, модуль, none, декоратор.

📝 Descripción y política de contenido

El autor describe el recurso como un espacio para expresar opiniones subjetivas:
“Погружение в CPython и архитектуру. Разбираем неочевидное поведение (GIL, Memory), Best Practices (SOLID, DDD) и тонкости Django/FastAPI. Решаем задачи с подвохом и оптимизируем алгоритмы. 🐍 По всем вопросам @evgenycarter РКН clck.ru/3Ko7Hq”

Gracias a la alta frecuencia de actualizaciones (últimos datos recibidos el 16 noviembre, 2026), el canal mantiene la vigencia y un amplio alcance. La analítica demuestra que la audiencia interactúa activamente con el contenido, lo que lo convierte en un punto de referencia dentro de la categoría Tecnologías y Aplicaciones.

17 904
Suscriptores
-524 horas
-337 días
-11630 días
Atraer Suscriptores
nov '26
noviembre '26
+6
en 0 canales
octubre '26
+22
en 0 canales
Get PRO
septiembre '26
+36
en 0 canales
Get PRO
agosto '26
+37
en 0 canales
Get PRO
julio '26
+35
en 0 canales
Get PRO
junio '26
+23
en 0 canales
Get PRO
mayo '26
+40
en 0 canales
Get PRO
abril '26
+26
en 0 canales
Get PRO
marzo '26
+31
en 0 canales
Get PRO
febrero '26
+62
en 0 canales
Get PRO
enero '26
+69
en 0 canales
Get PRO
diciembre '25
+67
en 0 canales
Get PRO
noviembre '25
+97
en 31 canales
Get PRO
octubre '25
+64
en 1 canales
Get PRO
septiembre '25
+90
en 36 canales
Get PRO
agosto '25
+60
en 0 canales
Get PRO
julio '25
+89
en 27 canales
Get PRO
junio '25
+116
en 19 canales
Get PRO
mayo '25
+119
en 44 canales
Get PRO
abril '25
+164
en 37 canales
Get PRO
marzo '25
+147
en 38 canales
Get PRO
febrero '25
+178
en 31 canales
Get PRO
enero '25
+176
en 33 canales
Get PRO
diciembre '24
+158
en 34 canales
Get PRO
noviembre '24
+112
en 33 canales
Get PRO
octubre '24
+139
en 29 canales
Get PRO
septiembre '24
+190
en 29 canales
Get PRO
agosto '24
+68
en 17 canales
Get PRO
julio '24
+56
en 0 canales
Get PRO
junio '24
+95
en 23 canales
Get PRO
mayo '24
+223
en 18 canales
Get PRO
abril '24
+174
en 0 canales
Get PRO
marzo '24
+240
en 20 canales
Get PRO
febrero '24
+224
en 18 canales
Get PRO
enero '24
+287
en 23 canales
Get PRO
diciembre '23
+253
en 24 canales
Get PRO
noviembre '23
+282
en 16 canales
Get PRO
octubre '23
+319
en 18 canales
Get PRO
septiembre '23
+342
en 0 canales
Get PRO
agosto '23
+264
en 0 canales
Get PRO
julio '23
+292
en 0 canales
Get PRO
junio '23
+211
en 0 canales
Get PRO
mayo '23
+284
en 0 canales
Get PRO
abril '23
+240
en 0 canales
Get PRO
marzo '23
+419
en 0 canales
Get PRO
febrero '23
+147
en 0 canales
Get PRO
enero '23
+247
en 0 canales
Get PRO
diciembre '22
+191
en 0 canales
Get PRO
noviembre '22
+174
en 0 canales
Get PRO
octubre '22
+283
en 0 canales
Get PRO
septiembre '22
+268
en 0 canales
Get PRO
agosto '22
+287
en 0 canales
Get PRO
julio '22
+322
en 0 canales
Get PRO
junio '22
+233
en 0 canales
Get PRO
mayo '22
+258
en 0 canales
Get PRO
abril '22
+252
en 0 canales
Get PRO
marzo '22
+380
en 0 canales
Get PRO
febrero '22
+207
en 0 canales
Get PRO
enero '22
+315
en 0 canales
Get PRO
diciembre '21
+211
en 0 canales
Get PRO
noviembre '21
+269
en 0 canales
Get PRO
octubre '21
+326
en 0 canales
Get PRO
septiembre '21
+286
en 0 canales
Get PRO
agosto '21
+486
en 0 canales
Get PRO
julio '21
+420
en 0 canales
Get PRO
junio '21
+368
en 0 canales
Get PRO
mayo '21
+350
en 0 canales
Get PRO
abril '21
+387
en 0 canales
Get PRO
marzo '21
+568
en 0 canales
Get PRO
febrero '21
+572
en 0 canales
Get PRO
enero '21
+777
en 0 canales
Get PRO
diciembre '20
+18 545
en 0 canales
Fecha
Crecimiento de Suscriptores
Menciones
Canales
15 noviembre0
14 noviembre0
13 noviembre0
12 noviembre0
11 noviembre+2
10 noviembre0
09 noviembre0
08 noviembre0
07 noviembre0
06 noviembre0
05 noviembre+2
04 noviembre0
03 noviembre0
02 noviembre+2
01 noviembre0
Publicaciones del Canal
Хотите в разработку, но не хотите «просто курс»? Программа «Разработчик на Python» от МФТИ и Нетологии — это профессиональная
Хотите в разработку, но не хотите «просто курс»? Программа «Разработчик на Python» от МФТИ и Нетологии — это профессиональная переподготовка с двумя дипломами. Подходит и тем, кто начинает с нуля. Что внутри: — Python от основ до командного веб-проекта: бэкенд, фронтенд на React, базы данных; — ИИ: учитесь грамотно применять его в разработке и делаете своё ИИ-приложение; — технологическое предпринимательство: как устроены продукт и бизнес. Обучение онлайн, его можно совмещать с работой. На выходе — два диплома о профессиональной переподготовке: МФТИ и Нетологии. Важно: дипломы выдаются при наличии высшего или среднего профессионального образования. Старт — 23 ноября. 🎁По промокоду MFTIPY10 — скидка 10 000 ₽. Узнать подробнее и записаться

2
В Python имя переменной может состоять из одного символа подчёркивания: _. Хотя такие имена обычно недостаточно описательны и их не стоит использовать, существует по крайней мере три случая, когда _ имеет общепринятое значение. Во-первых, в интерактивных интерпретаторах Python _ используется для хранения результата последнего выполненного выражения: >>> 2 + 2 4 >>> _ 4 Во-вторых, в документации модуля gettext рекомендуется создавать псевдоним для функции gettext() в виде _(), чтобы не загромождать код. В-третьих, _ используется, когда необходимо придумать имя для значения, которое не представляет интереса: >>> log_entry = '10:50:24 14234 GET /api/v1/test' >>> time, _, method, location = log_entry.split() 📲 Мы в MAX 👉@BookPython
64
3
Иногда возникает необходимость выполнить участок кода и проигнорировать все возможные исключения. Это оправдано в случае с плагинами, сторонними модулями и другими компонентами, устройство которых вам неизвестно или которым вы не доверяете. Правильный способ сделать это — использовать конструкцию try с except Exception, а не голый except: try: foreign() except Exception: logging.warn('fail', exc_info=True) Голый except эквивалентен except BaseException. А разница между BaseException и Exception в том, что BaseException включает исключения, которые, как правило, ловить не следует, например, KeyboardInterrupt. 📲 Мы в MAX 👉@BookPython
607
4
В Python оператор квадратных скобок [] можно переопределить, реализовав магический метод __getitem__. Это позволяет, например, создать объект, который виртуально содержит бесконечное количество повторяющихся элементов: class Cycle: def __init__(self, lst): self._lst = lst def __getitem__(self, index): return self._lst[index % len(self._lst)] print(Cycle(['a', 'b', 'c'])[100]) # 'b' Необычность оператора [] в Python в том, что он поддерживает особый синтаксис. Его можно использовать не только так: [2], но и так: [2:10], [2:10:2], [2::2] или даже [:]. Смысл такой записи — [start:stop:step], но в ваших собственных объектах вы можете использовать этот синтаксис как угодно. Что же передаётся в __getitem__ в таких случаях? Объекты slice созданы специально для этого. Пример: class Inspector: def __getitem__(self, index): print(index) Inspector()[1] # 1 Inspector()[1:2] # slice(1, 2, None) Inspector()[1:2:3] # slice(1, 2, 3) Inspector()[:] # slice(None, None, None) Inspector()[:, 0, :] # (slice(None, None, None), 0, slice(None, None, None)) Объект slice сам по себе ничего не делает — он просто хранит атрибуты start, stop и step: s = slice(1, 2, 3) print(s.start) # 1 print(s.stop) # 2 print(s.step) # 3 📲 Мы в MAX 👉@BookPython
658
5
Существует два понятия с похожими названиями, которые легко перепутать: переопределение (overriding) и перегрузка (overloading). Переопределение происходит, когда дочерний класс определяет метод, который уже был реализован в родительском классе, фактически заменяя его. В некоторых языках необходимо явно указывать, что метод переопределяется (например, в C# используется модификатор override), в других — это необязательно (в Java можно, но не обязательно использовать аннотацию @Override). В Python нет ни обязательного, ни стандартного способа обозначать такие методы (некоторые программисты применяют пользовательский декоратор @override, который ничего не делает, а служит только для читаемости кода). Перегрузка, напротив, — это наличие нескольких функций с одним и тем же именем, но разными сигнатурами. Это поддерживается в таких языках, как Java и C++, и часто используется как способ предоставления значений по умолчанию: class Foo { public static void main(String[] args) { System.out.println(Hello()); } public static String Hello() { return Hello("world"); } public static String Hello(String name) { return "Hello, " + name; } } Python не поддерживает поиск функций по сигнатурам, только по именам. Вы можете написать код, который явно анализирует типы и количество аргументов, но это обычно выглядит громоздко и не очень красиво: def quadrilateral_area(*args): if len(args) == 4: quadrilateral = Quadrilateral(*args) elif len(args) == 1: quadrilateral = args[0] else: raise TypeError() return quadrilateral.area() Если вам нужны подсказки типов для такой реализации, модуль typing предоставляет декоратор @overload, который можно использовать следующим образом: from typing import overload @overload def quadrilateral_area( q: Quadrilateral ) -> float: ... @overload def quadrilateral_area( p1: Point, p2: Point, p3: Point, p4: Point ) -> float: ... 📲 Мы в MAX 👉@BookPython
739
6
🚀 Как логировать без боли в Python Как настроить логирование в Python один раз — и больше к этому не возвращаться. Обычно начинающие разработчики либо используют print(), либо подключают logging, но каждый раз пишут кучу однотипного кода. Я так тоже делал. Но потом вывел себе простую универсальную схему, которую теперь кидаю в каждый новый проект: import logging def setup_logger(name: str) -> logging.Logger: logger = logging.getLogger(name) if not logger.hasHandlers(): logger.setLevel(logging.INFO) handler = logging.StreamHandler() formatter = logging.Formatter( '%(asctime)s - %(levelname)s - %(name)s - %(message)s' ) handler.setFormatter(formatter) logger.addHandler(handler) return logger logger = setup_logger(__name__) logger.info("Скрипт стартовал") Что мы получаем: * Удобный формат времени и уровня лога * Защиту от дублирования логов (если модуль импортируется несколько раз) * Готовность к масштабированию (можно легко добавить файл-логгер) Если вы устали от print(), просто сохраните себе этот сниппет — он сэкономит вам время и нервы. Пользуетесь ли вы встроенным logging, или предпочитаете что-то вроде loguru? 📲 Мы в MAX 👉@BookPython
802
7
💡 Как избежать повторения кода с помощью functools.partial Как упростить код и избежать дублирования с помощью functools.partial. Допустим, у нас есть функция send_email(to, subject, body, is_html=False), и мы часто вызываем её с одним и тем же параметром is_html=True. Вместо того чтобы каждый раз писать это явно, можно создать частичную функцию: from functools import partial send_html_email = partial(send_email, is_html=True) # Теперь можно вызывать проще: send_html_email("user@example.com", "Привет", "<b>Как дела?</b>") Это удобно, если вы хотите предварительно зафиксировать часть аргументов, например: * логгеры с предустановленным уровнем * коннекторы с общими параметрами * команды CLI с типовыми флагами Таким образом, вы уменьшаете дублирование и делаете код читаемее. А ещё это красивый способ внедрить DI без фреймворков — просто передайте partial. 📲 Мы в MAX 👉@BookPython
978
8
Встроенные значения float в Python используют оборудование вашего компьютера напрямую, поэтому любое значение представляется внутренне в виде двоичной дроби. Это означает, что вы обычно работаете с приближениями, а не с точными значениями: >>> format(0.1, '.17f') '0.10000000000000001' Модуль decimal позволяет использовать десятичную арифметику с произвольной точностью: >>> from decimal import Decimal >>> Decimal(1) / Decimal(3) Decimal('0.3333333333333333333333333333') Но и этого может быть недостаточно: >>> Decimal(1) / Decimal(3) * Decimal(3) == Decimal(1) False Для абсолютно точных вычислений можно использовать модуль fractions, который хранит любое число как рациональное: >>> from fractions import Fraction >>> Fraction(1) / Fraction(3) * Fraction(3) == Fraction(1) True Очевидное ограничение — всё равно приходится использовать приближения для иррациональных чисел, таких как π. 📲 Мы в MAX 👉@BookPython
1 003
9
Создание объекта в Python включает два ключевых этапа. Сначала вызывается метод __new__, который создаёт и возвращает новый объект. Затем вызывается метод __init__ для инициализации состояния этого объекта. Однако, если __new__ возвращает объект, который не является экземпляром исходного класса, метод __init__ не будет вызван. Это связано с тем, что возвращаемый объект, вероятно, уже создан другим классом, и его __init__ уже был выполнен: class Foo: def __new__(cls, x): return dict(x=x) def __init__(self, x): print(x) # Никогда не вызывается print(Foo(0)) Важно: не следует создавать экземпляры того же класса в __new__ с использованием обычного конструктора (Foo(...)). Это может привести к двойному вызову __init__ или даже к бесконечной рекурсии. Пример бесконечной рекурсии: class Foo: def __new__(cls, x): return Foo(-x) # Рекурсия Пример двойного вызова __init__: class Foo: def __new__(cls, x): if x < 0: return Foo(-x) return super().__new__(cls) def __init__(self, x): print(x) self._x = x Правильный способ: class Foo: def __new__(cls, x): if x < 0: return cls.__new__(cls, -x) return super().__new__(cls) def __init__(self, x): print(x) self._x = x 📲 Мы в MAX 👉@BookPython
1 015
10
Как упростить работу с аргументами в командной строке с помощью typer Раньше для CLI-приложений на Python я использовал argparse, потом был click, но недавно полностью перешёл на typer. Это библиотека от автора FastAPI, и она реально 🔥 Вот простой пример: import typer app = typer.Typer() @app.command() def hello(name: str, age: int = 18): print(f"Привет, {name}! Тебе {age} лет.") if __name__ == "__main__": app() Теперь можно запускать в терминале: $ python main.py hello Alice --age 30 Привет, Alice! Тебе 30 лет. Что круто: - Автоматически генерируется --help - Пишется почти как обычная функция - Есть автокомплит в оболочках (bash/zsh) - Поддержка аннотаций типов и валидации "из коробки" Если ты всё ещё страдаешь с argparse, рекомендую попробовать typer. Особенно если ты уже кайфуешь от FastAPI — синтаксис и подход очень похожи. 📲 Мы в MAX 👉@BookPython
1 042
11
Популярный способ объявить абстрактный метод в Python — это выбросить исключение NotImplementedError: def human_name(self): raise NotImplementedError Хотя этот подход довольно распространён и даже поддерживается IDE (например, PyCharm считает такие методы абстрактными), у него есть недостаток: ошибка возникает только при вызове метода, а не при создании экземпляра класса. Чтобы избежать этой проблемы, используйте модуль abc: from abc import ABCMeta, abstractmethod class Service(metaclass=ABCMeta): @abstractmethod def human_name(self): pass Также важно помнить, что NotImplemented — это не то же самое, что NotImplementedError. NotImplemented — это специальное значение (как True и False), а не исключение. Оно используется, например, в специальных методах (__eq__(), __add__() и др.), чтобы сообщить Python, что операция не реализована для данного типа, и попытаться вызвать альтернативный метод (например, если a.__add__(b) возвращает NotImplemented, Python попробует вызвать b.__radd__(a)). 📲 Мы в MAX 👉@BookPython
1 064
12
Некоторый код может выводить интересующие вас данные в stdout, вместо того чтобы предоставлять API, возвращающий строку, пригодную для использования в программе. Вместо рефакторинга такого кода можно воспользоваться менеджером контекста contextlib.redirect_stdout, который позволяет временно перенаправить stdout в любой объект, поддерживающий файловый интерфейс. В сочетании с io.StringIO это позволяет сохранить вывод в переменную. from contextlib import redirect_stdout from io import StringIO s = StringIO() with redirect_stdout(s): print(42) print(s.getvalue()) Также существует contextlib.redirect_stderr для перенаправления вывода sys.stderr. 📲 Мы в MAX 👉@BookPython
981
13
Иногда в программе нужна очередь — контейнер, куда элементы добавляются с одной стороны и извлекаются с другой. В Python для этого можно использовать list: In : lst = [1, 2, 3] In : lst.pop() Out: 3 In : lst Out: [1, 2] In : lst[:0] = [4] # push In : lst Out: [4, 1, 2] Однако list выглядит не очень удобно (взгляните на этот "push") и работает неэффективно. In : lst = [0] * 10_000_000 In : %timeit lst[:0] = [1] 9.5 ms ± 111 µs per loop (mean ± std. dev. of 7 runs, 100 loops each) In : %timeit lst.pop() 84.3 ns ± 4.01 ns per loop (mean ± std. dev. of 7 runs, 10000000 loops each) Как видно, операция pop() в 100 раз быстрее, чем вставка в начало списка. Это связано с тем, как устроен list в Python: легко добавлять и удалять элементы с конца, но удаление/добавление в начало требует создания нового списка. Для очередей лучше использовать collections.deque. Он специально для этого создан: In : from collections import deque In : d = deque([1] * 100_000_000) In : %timeit d.popleft() 65 ns ± 0.436 ns per loop (mean ± std. dev. of 7 runs, 10000000 loops each) 📲 Мы в MAX 👉@BookPython
931
14
Скрытые фичи Enum: как выжать максимум Многие используют Enum как простой список констант. Но у enum.Enum в Python есть куда больше возможностей — и они могут сделать код чище и мощнее. Вот несколько приёмов, которые мало кто использует — но зря. 1. Добавление поведения в Enum from enum import Enum class Status(Enum): DRAFT = 'draft' PUBLISHED = 'published' ARCHIVED = 'archived' def is_visible(self): return self in {Status.DRAFT, Status.PUBLISHED} Теперь Status.DRAFT.is_visible() — это просто и элегантно. 2. Enum с полями from enum import Enum class Color(Enum): RED = ('#FF0000', 'danger') GREEN = ('#00FF00', 'safe') def __init__(self, hex_code, label): self.hex_code = hex_code self.label = label Color.RED.hex_code # '#FF0000' Color.RED.label # 'danger' 3. Автоматические значения с auto() from enum import Enum, auto class Role(Enum): ADMIN = auto() USER = auto() GUEST = auto() Удобно, если не важны конкретные значения, а нужны уникальные. 4. Строгая сериализация В реальных приложениях (API, базы) лучше контролировать сериализацию enum'ов: import json class CustomEncoder(json.JSONEncoder): def default(self, obj): if isinstance(obj, Enum): return obj.value return super().default(obj) json.dumps(Status.PUBLISHED, cls=CustomEncoder) # "published" 5. Сравнение по значению Status('draft') == Status.DRAFT # True Status('draft') is Status.DRAFT # True (enum гарантирует singleton) Итого: Enum — это не просто константы. Это лёгкий способ инкапсулировать поведение и данные, улучшить читаемость и сделать код устойчивее к ошибкам. 📲 Мы в MAX 👉@BookPython
778
15
default_factory в dataclass: мощнее, чем кажется Многие используют dataclass как удобный способ задать структуру с полями. Но редко кто по-настоящему раскрывает силу default_factory. А зря — он спасает от багов и даёт гибкость. Когда нужно задать значение по умолчанию для поля в dataclass, логично тянуться к default=. Но если это изменяемый тип (например, список или словарь) — вас поджидает ловушка. from dataclasses import dataclass, field @dataclass class User: name: str tags: list[str] = [] # ⚠️ опасно! Все экземпляры User будут делить один и тот же список. То есть: a = User("Alice") b = User("Bob") a.tags.append("admin") print(b.tags) # ['admin'] 😱 Вместо этого используйте default_factory: @dataclass class User: name: str tags: list[str] = field(default_factory=list) Теперь у каждого User будет свой список: a = User("Alice") b = User("Bob") a.tags.append("admin") print(b.tags) # [] Но default_factory не только про списки. Это отличный способ задать любое значение "по умолчанию", включая кастомную логику: import uuid @dataclass class Session: id: str = field(default_factory=lambda: str(uuid.uuid4())) Или, например, значения из окружения: import os @dataclass class Config: debug: bool = field(default_factory=lambda: os.getenv("DEBUG") == "1") Кстати, это ещё и отличное место для внедрения DI: @dataclass class Service: client: "Client" = field(default_factory=create_default_client) default_factory — это маленький хак, который позволяет сделать код чище и безопаснее, особенно когда работаешь с изменяемыми структурами или сложной инициализацией. 📲 Мы в MAX 👉@BookPython
944
16
yield from — элегантная передача управления Если вы пишете генераторы, которые вызывают другие генераторы — забудьте про for x in sub(): yield x. Есть способ проще и мощнее. Оператор yield from позволяет передавать элементы из подгенератора напрямую, без лишнего кода. Но фишка не только в лаконичности — он также автоматически пробрасывает исключения и возвращаемые значения из подгенератора. Вот классика: def gen(): for x in range(3): yield x def wrapper(): for x in gen(): yield x Можно короче и лучше: def wrapper(): yield from gen() Но главное — yield from пробрасывает return-значение из подгенератора (начиная с Python 3.3): def sub(): yield 1 yield 2 return 'done' def main(): result = yield from sub() print('Sub returned:', result) for _ in main(): pass # Выведет: Sub returned: done А ещё через yield from можно проксировать значения внутрь генератора — например, в сопрограммах: def delegator(): result = yield from coroutine() print('coroutine done:', result) def coroutine(): x = yield y = yield return x + y g = delegator() next(g) # Старт next(g) # coroutine ждет x g.send(10) # x = 10 print(g.send(20)) # y = 20 → return 30 # Выведет: coroutine done: 30 Итог: если вы пишете генераторы — освоение yield from даст вам лаконичный синтаксис, проброс return-значений, исключений и взаимодействие на новом уровне. 📲 Мы в MAX 👉@BookPython
901
17
Когда вы используете модуль multiprocessing, и в одном из процессов происходит исключение, оно передаётся в основную программу с помощью механизма сериализации (pickling). Исключение сериализуется, передаётся в другой процесс и там десериализуется обратно. Однако сериализация исключений может быть непростой задачей. Исключение создаётся с любым количеством аргументов, которые сохраняются в атрибуте args. Эти же аргументы используются при десериализации для воссоздания объекта исключения. Но это может не сработать так, как вы ожидаете, особенно если используется наследование. Посмотрите на пример: import pickle class TooMuchWeightError(Exception): def __init__(self, weight): super().__init__() self._weight = weight pickled = pickle.dumps(TooMuchWeightError(42)) pickle.loads(pickled) Вызов TooMuchWeightError.__init__ приводит к вызову Exception.__init__, который устанавливает args как пустой кортеж. Этот пустой кортеж затем используется в качестве аргументов при десериализации, что, очевидно, приводит к ошибке: TypeError: __init__() missing 1 required positional argument: 'weight' Обходное решение — либо вообще не вызывать super().__init__() (что обычно считается плохой практикой при наследовании), либо передавать все аргументы явно в конструктор родительского класса: class TooMuchWeightError(Exception): def __init__(self, weight): super().__init__(weight) self._weight = weight 📲 Мы в MAX 👉@BookPython
1 000
18
Функция map вызывает другую функцию для каждого элемента итерируемого объекта. Это значит, что функция должна принимать одно значение в качестве аргумента: In : list(map(lambda x: x ** 2, [1, 2, 3])) Out: [1, 4, 9] Однако если каждый элемент итерируемого объекта — это кортеж, было бы удобно передавать каждый элемент кортежа как отдельный аргумент. В Python 2 это было возможно благодаря распаковке параметров кортежа (обратите внимание на скобки): >>> map(lambda (a, b): a + b, [(1, 2), (3, 4)]) [3, 7] В Python 3 эта возможность исчезла, но есть другое решение — itertools.starmap. Она распаковывает кортежи за вас, будто функция вызывается со звёздочкой: f(*arg) (отсюда и название функции): from itertools import starmap In [3]: list(starmap(lambda a, b: a + b, [(1, 2), (3, 4)])) Out[3]: [3, 7] 📲 Мы в MAX 👉@BookPython
1 034
19
Функция super() позволяет обращаться к родительскому (базовому) классу. Это может быть очень полезно в случаях, когда производный класс хочет добавить что-то к реализации метода, а не полностью переопределять его: class BaseTestCase(TestCase): def setUp(self): self._db = create_db() class UserTestCase(BaseTestCase): def setUp(self): super().setUp() self._user = create_user() Имя функции super не означает "отличный" или "очень хороший". В данном контексте слово super означает "выше" (как, например, в слове superintendent — заведующий). Несмотря на это, super() не всегда ссылается на базовый класс — он может вернуть и "соседний" класс. Более точным названием была бы, возможно, функция next(), так как возвращается следующий класс согласно цепочке разрешения методов (MRO — Method Resolution Order). Пример: class Top: def foo(self): return 'top' class Left(Top): def foo(self): return super().foo() class Right(Top): def foo(self): return 'right' class Bottom(Left, Right): pass # выводит 'right' print(Bottom().foo()) Обрати внимание: результат работы super() может отличаться в зависимости от MRO вызвавшего объекта. >>> Bottom().foo() 'right' >>> Left().foo() 'top' 📲 Мы в MAX 👉@BookPython
1 232
20
Стандартный механизм расширения путей в оболочке называется globbing. Шаблоны, которые вы используете для сопоставления путей
Стандартный механизм расширения путей в оболочке называется globbing. Шаблоны, которые вы используете для сопоставления путей, называются globs. $ echo /li* /lib /lib64 Python поддерживает globbing с помощью модуля glob. Однако есть важное замечание: оболочка возвращает сам шаблон, если файлы не найдены, а Python — нет: $ echo /zz** /zz** $ python -c 'from glob import glob; print(glob("/zz**"))' [] 📲 Мы в MAX 👉@BookPython
1 047