Python Исследователь

Почему `range()` в Python использует полуоткрытые интервалы?

Функция range() в Python работает с полуоткрытыми интервалами. Например, range(2, 10) задаёт числа в диапазоне [2, 10), то есть [2, 3, 4, 5, 6, 7, 8, 9]. На первый взгляд это может показаться неочевидным или асимметричным, но у такого подхода есть свои преимущества.

Почему полуоткрытые интервалы?
Полуоткрытые интервалы позволяют легко "склеивать" смежные диапазоны без риска ошибок на единицу:

- Если a = 2, b = 5, и c = 10, то [a, c) можно выразить как:

  [a, c) = [a, b) + [b, c)
  

Это работает идеально, потому что конец одного интервала (`b`) автоматически становится началом следующего.

В случае закрытых интервалов, такая "склейка" требует дополнительной обработки:

[a, c] = [a, b] + [b+1, c]

Связь с индексацией с нуля
Индексация с нуля в Python также связана с этим принципом. Рассмотрим диапазон range(0, N):
- Этот диапазон включает ровно N элементов, что делает код более предсказуемым:

  for i in range(0, N):
      print(i)
  

Здесь i проходит значения от 0 до N-1, что логично и удобно.

Преимущества для работы с массивами
Полуоткрытые интервалы идеально подходят для работы с индексами массивов:

arr = [10, 20, 30, 40, 50]
print(arr[1:3])  # [20, 30]

Интервал [1:3) охватывает элементы с индексами 1 и 2, но не 3, что упрощает вычисления границ.

Исторический контекст
Этот подход имеет глубокие корни в компьютерной науке. Эдсгер Дейкстра, один из пионеров программирования, в 1982 году написал блестящую статью, в которой обосновал преимущества полуоткрытых интервалов. Это не просто удобство — это вопрос корректности и простоты работы с данными.

👉

Как использовать *args и **kwargs в python?

В видео про декораторы мы использовали *args и **kwargs для того, чтобы передать в функцию любое количество позиционных и именованных аргументов. Для того, чтобы понять как это работает, сначала познакомимся с тем, что такое распаковка.

👉

Уроки Python

Введение в искусственный интеллект. Обзор задач
Введение в OpenCV | Работа с камерой
Изучение OpenCV | Распознавание автомобильных номеров
Введение в ImageAI | Распознаем объекты на фото за 7.5 минут без OpenCV
Изучение OpenCV | ImageAI для распознавание объектов в реальном времени
Создаем навык для Яндекс.Алиса с использованием Flask
Интеграция Яндекс.Алиса и Вконтакте
Введение в распознавание контуров через OpenCV
OpenCV. Распознавание цвета. Работа с событиями мыши
Как знакомиться в тиндере с Tinder API

источник

👉

Если вы хотите игнорировать какое-то исключение, вы, вероятно, сделаете что-то вроде этого:

try:
    lst = [1, 2, 3, 4, 5]
    print(lst[10])
except IndexError:
    pass

Это будет работать (ничего не выводя), но contextlib позволяет сделать то же самое более выразительно и семантически правильно:

from contextlib import suppress
with suppress(IndexError):
    lst = [1, 2, 3, 4, 5]
    lst[10]

👉

Когда вы пишете декоратор в Python, почти всегда стоит использовать .wraps.

def atomic(func):
    .wraps(func)
    def wrapper():
        print('BEGIN')
        func()
        print('COMMIT')

    return wrapper

Он обновляет обёртку wrapper, чтобы она выглядела как оригинальная функция func. Декоратор копирует атрибуты __name__, __module__ и __doc__ из функции func в её обёртку.

Это может быть полезно при генерации документации с помощью pydoc, написании тестов с doctest, или при использовании инструментов для интроспекции. Однако стоит помнить, что в трассировке стека всё ещё будет отображаться оригинальное имя функции, поскольку оно хранится в wrapper.__code__.co_name.

👉

💡Шпаргалка: API OpenAI в Python

Небольшая шпаргалка поможет быстро начать работу с API OpenAI. В ней показано:
▪️как добавить API-ключ и посмотреть доступные модели,
▪️как генерировать текст с помощью GPT,
▪️как работать с эмбеддингами,
▪️как конвертировать речь в текст,
▪️как создавать изображения с помощью DALL-E.

👉

Как работать с объектным хранилищем на Python

Файлы в проекте можно хранить разными способами: локально на компьютере, в базе данных или S3-хранилище (объектное хранилище). Последнее — одно из самых популярных решений. Оно отличается надежностью и масштабируемостью. Использовать S3 можно не только в личных целях, но и для решения бизнес-задач. Для специалиста навык работы с объектным хранилищем востребован. Он поможет быстрее дойти до следующего уровня в карьере.

Под катом расскажем о преимуществах S3, научимся загружать и получать файлы, сверстаем небольшой сайт с его использованием!

https://habr.com/ru/companies/selectel/articles/822855/

👉

Срез списка по умолчанию в Python создаёт копию. Это может быть нежелательно, если срез слишком велик, требуется, чтобы изменения отражались в оригинале, или нужно изменять срез, влияя на исходный объект. Для обхода проблемы копирования данных можно использовать itertools.islice, который позволяет итерироваться по части списка без поддержки индексации или модификации.

Для создания изменяемого среза можно реализовать собственный класс, используя collections.abc.MutableSequence, переопределив методы __getitem__, __setitem__, __delitem__, __len__ и insert.

👉

Создание ботов на Python с использованием aiogram

Создание Telegram ботов на AIOGRAM 3.4
Фильтры и работа с сообщениями на AIOGRAM 3.4
Роутеры и структура Telegram бота на AIOGRAM 3.4
Клавиатура в Телеграм Ботах - Inline Reply и Builder на AIOGRAM 3.4
CallbackQuery на AIOGRAM 3.4
FSM Context - машина состояний на AIOGRAM 3.4
Middleware на AIOGRAM 3.4
Телеграм Бот на Python с нуля! | Telegram Bot на Aiogram для начинающих
База Данных и Выгрузка на Сервер Телеграм Бота на Python - Aiogram 3
PostgreSQL + Скрытие Токена в .env - Aiogram 3
ДЕПЛОЙ БОТА НА СЕРВЕР | AIOGRAM 3
To Do БОТ на Python для ТЕЛЕГРАМ | AIOGRAM EASY BOT #1

источник

👉

Очередь с приоритетом — это структура данных, которая поддерживает две операции: добавление элемента и извлечение минимального из всех ранее добавленных элементов.

Одной из самых распространённых реализаций очереди с приоритетом является бинарная куча. Это полное бинарное дерево со следующим свойством: ключ, хранящийся в каждом узле, меньше или равен (≤) ключам в дочерних узлах. Минимум всех элементов находится в корне такого дерева.

              1

      3               7

  5       4       9       8

15 16   17 18   19

В бинарной куче сложность операций вставки и извлечения составляет O(log n).

Обычный способ хранения полного бинарного дерева в памяти — это массив, где дочерние элементы для x[i] находятся в x[2*i+1] и x[2*i+2].

[1, 3, 7, 5, 4, 9, 8, 15, 16, 17, 18, 19]

В Python нет бинарной кучи в виде класса, но предоставляется ряд функций, которые позволяют использовать список как бинарную кучу. Эти функции находятся в модуле heapq.

In [1]: from heapq import *
In [2]: heap = [3,2,1]
In [3]: heapify(heap)
In [4]: heap
Out[4]: [1, 2, 3]
In [5]: heappush(heap, 0)
In [6]: heap
Out[6]: [0, 1, 3, 2]
In [7]: heappop(heap)
Out[7]: 0
In [8]: heap
Out[8]: [1, 2, 3]

👉

Популярный способ объявить абстрактный метод в Python — использовать исключение NotImplementedError:

def human_name(self):
    raise NotImplementedError

Хотя этот способ довольно популярен и даже поддерживается IDE (PyCharm считает такой метод абстрактным), у него есть недостаток. Ошибка возникает только при вызове метода, а не при создании экземпляра класса.

Используйте abc, чтобы избежать этой проблемы:

from abc import ABCMeta, abstractmethod
class Service(metaclass=ABCMeta):
    
    def human_name(self):
        pass

👉

Python 3 позволяет сделать некоторые аргументы функции обязательными именованными аргументами, что означает, что их нужно передавать как (arg=value), а не просто (value).

Это может быть полезно, чтобы предотвратить вызовы функции вроде: grep(text, pattern, True, False, True), где True, False, True на самом деле означают: игнорировать регистр, не инвертировать совпадение, шаблон — регулярное выражение Perl. Было бы неплохо заставить использовать единственный разумный вид вызова:

grep(text, pattern,
    ignore_case=True,
    perl_regexp=True)

Чтобы достичь этого результата, следует разместить обязательные именованные аргументы после аргумента переменной длины (также известного как *args):

def grep(
    text, pattern, *args,
    ignore_case=False,
    invert_match=False,
    perl_regexp=False,
):
    pass

Если вам не нужен *args (как в примере), просто замените его на одиночную звездочку:

def grep(
    text, pattern, *,
    ignore_case=False,
    invert_match=False,
    perl_regexp=False,
):
    pass

👉

Если вы хотите перехватить как IndexError, так и KeyError, вы можете и должны использовать LookupError, их общего предка. Это оказалось полезным при доступе к сложным вложенным данным.

try:
    db_host = config['databases'][0]['hosts'][0]
except LookupError:
    db_host = 'localhost'

👉

>>> exit
Use exit() or Ctrl-D (i.e. EOF) to exit

Вы когда-нибудь задумывались, почему при попытке выйти из интерактивного Python с помощью простого exit или quit появляется это сообщение? Решение довольно неожиданное, но изящное. Это не специальный случай для интерактивной оболочки, она просто показывает представление каждого вычисленного результата, а эта строка - просто представление функции exit.

Строго говоря, вы не должны использовать exit в своих повседневных проектах, поскольку она была создана специально для интерактивной оболочки. Вместо этого используйте sys.exit().

👉

Известный синтаксис декораторов в Python () — это способ вызова функции высшего порядка. Раньше людям приходилось делать это вручную:

# prior to Python 2.4
def query():
    pass
query = atomic(query)

# now

def query():
    pass

По сути, идентификатор после @ — это то, что будет вызвано. Можно также использовать идентификатор со скобками ((skip_errors=True)), что обычно используется для параметризированных декораторов. Также работает что-то вроде .db.atomic(True). Кажется, что любой вид выражения можно использовать в качестве декоратора, но это не так. После @ должен следовать один «дот-идентификатор» (например, decorators.atomic) и, при необходимости, одна пара скобок с аргументами (как вызов функции). Так что [2] использовать нельзя. Вот строка из грамматики Python:

decorator: '@' dotted_name [ '(' [arglist] ')' ] NEWLINE

👉

Если dict запоминает порядок элементов в Python 3.6+, тогда зачем нужен collections.OrderedDict?

А вот зачем:

>>> OrderedDict(a=1, b=2) == OrderedDict(b=2, a=1)
False
>>> dict(a=1, b=2) == dict(b=2, a=1)
True

👉

В Python 3 методы keys, values и items для словарей возвращают объекты-представления (view objects). В Python 2 они возвращали списки. Основное различие в том, что представления не хранят все элементы в памяти, а предоставляют их по мере запроса. Это работает отлично, пока вы просто итерируете ключи (что обычно и делается), но теперь вы не можете получить доступ к элементам по индексу.

TypeError: 'dict_keys' object does not support indexing

Можно утверждать, что индексация ключей не особо нужна, так как их порядок случайный, но это не совсем так. Во-первых, d.keys()[0] может быть удобным способом получить любой ключ (используйте next(iter(d.keys())) в Python 3). Во-вторых, начиная с Python 3.6, словари в CPython упорядочены по порядку добавления, и с версии Python 3.7 это стало стандартной особенностью языка.

👉

Блок else для выражений for и try используется довольно редко. Однако, комбинируя их вместе, можно написать код, который выполняет итерацию по коллекции до первого успешного результата без использования дополнительных флагов.

import logging
from typing import List, Optional

logging.basicConfig(level=logging.DEBUG)

def first_int(iterable: List[str]) -> Optional[int]:
    for x in iterable:
        try:
            result = int(x)
        except ValueError:
            logging.debug('Bad int: %s', x)
        else:
            break
    else:
        result = None
        logging.error('No int found')

    return result

print(first_int(('a', 'b', '42', 'c')))

Вывод:

DEBUG:root:Bad int: a
DEBUG:root:Bad int: b
42

👉

UV

Чрезвычайно быстрый менеджер пакетов и проектов на языке Python, написанный на Rust.

Создатели позиционируют его как замену pip, pip-tools и virtualenv. Это, кстати, те же разработчики, которые сделали линтер Ruff.

https://astral.sh/blog/uv

https://github.com/astral-sh/uv

👉

Scrapy - это лицензированный BSD быстрый высокоуровневый фреймворк для веб-скраппинга, используемый для просмотра веб-сайтов и извлечения структурированных данных с их страниц. Его можно использовать для самых разных целей, от добычи данных до мониторинга и автоматизированного тестирования.

https://pypi.org/project/Scrapy/

👉

Совет по Python💡

Вы можете использовать any(), чтобы проверить, является ли любой элемент в iterable истинным.

Пример 👆

👉

Django REST Framework и Vue против Django и HTMX

Статья сравнивает два подхода к созданию веб-приложений с Django: использование Django REST Framework (DRF) и Vue.js для полного разделения фронтенда и бэкенда, а также использование Django с HTMX для более интегрированного подхода с серверным рендерингом. В статье обсуждаются плюсы и минусы каждого из этих решений, включая вопросы сложности, производительности и удобства для разработчика.

https://testdriven.io/blog/drf-vue-vs-django-htmx/

👉

Создаем чат-бота на Python: Полное руководство

В статье автор рассказывает, как создать чат-бота на Python с использованием библиотек NLTK и TensorFlow. Она охватывает подготовку среды разработки, обработку текста, обучение модели и интеграцию её в бота. Даны примеры кода для выполнения каждой задачи, включая обработку текста, построение модели и реализацию логики ответов. В статье также приведены полезные ресурсы для дальнейшего изучения NLP и машинного обучения.

https://habr.com/ru/articles/792148/

👉

Зачем нужен pdb?

pdb (Python Debugger) — это встроенный отладчик Python, который помогает разработчикам находить и исправлять ошибки в коде. С помощью pdb можно управлять выполнением программы шаг за шагом, просматривать и изменять значения переменных, устанавливать точки останова и диагностировать причину ошибок. Вот основные функции и задачи pdb:

Основные возможности pdb:
1. Точки останова (breakpoints): Можно установить точку в коде, где выполнение программы остановится, чтобы проверить текущее состояние переменных и выполнения.

   import pdb; pdb.set_trace()  # Остановка программы в этом месте
   

2. Шаговое выполнение кода:
- n (next) — Выполняет следующую строку кода.
- s (step) — Переходит внутрь функции, если строка кода — это вызов функции.
- c (continue) — Продолжает выполнение до следующей точки останова.

3. Просмотр значений переменных:
- Можно вводить имя переменной, чтобы узнать ее текущее значение на любой остановке программы.
- Можно выполнять Python-команды прямо в отладчике для анализа данных.

4. Отслеживание стека вызовов:
- Команды where или w показывают текущий стек вызовов, что помогает понять, в какой части программы находится ошибка.

5. Динамическое изменение кода:
- Во время отладки можно изменять значения переменных, что помогает тестировать различные сценарии и предположения прямо во время выполнения программы.

Пример использования pdb:

import pdb

def divide(a, b):
    pdb.set_trace()  # Остановка для проверки переменных
    return a / b

result = divide(10, 0)
print(result)

Этот пример вызовет ошибку деления на ноль, и отладчик pdb остановится перед ошибкой, что позволит просмотреть значения a и b.

Когда использовать pdb
- Для диагностики сложных ошибок, которые трудно отследить с помощью обычных print() или logging.
- При разработке и тестировании сложных функций или алгоритмов.
- В ситуациях, когда необходимо детально понять, почему код работает не так, как ожидалось.

pdb — мощный инструмент, который помогает программистам эффективно находить ошибки и улучшать качество кода.

👉

Python 3.13, что не попало в заголовки

Python 3.13 — отличный релиз, полный различных фич и улучшений, но уже есть тонна статей, которые подробно разбирают release notes. Если вам нужна хорошая выжимка — у RealPython есть хорошая статья, но я не вижу смысла проходиться по ним еще раз в этой статье.

Так что мы не будем говорить про новый REPL, no‑GIL сборку, экспериментальный JIT‑компилятор, устаревшие штуки, новые плюшки системы типов или улучшенные сообщения об ошибках (как всегда, мое любимое).

Вместо этого я прочитал коротенькую книжку, которую они называют ченджлогом и мы посмотрим на то, о чем многие не говорили, но заинтересовало лично меня.

https://habr.com/ru/companies/beget/articles/856288/

original https://www.bitecode.dev/p/python-313-what-didnt-make-the-headlines

👉

Декораторы Python: пошаговое руководство

Понимание декораторов является важной вехой для любого программиста Python. Эта статья представляет собой пошаговое руководство о том, как декораторы могут помочь вам стать более эффективным и продуктивным разработчиком на Python.

Декораторы в Python позволяют расширять и изменять поведение вызываемых объектов (функций, методов и классов) без постоянного изменения самого вызываемого объекта.

Любая достаточно общая функциональность, которую можно «прикрепить» к поведению существующего класса или функции, является отличным примером использования декораторов.

Сюда входит:
- журналирование,
- обеспечение контроля доступа и аутентификации,
- инструментарий и функции управления временем,
- ограничение скорости,
- кэширование и многое другое.

Rus https://habr.com/ru/companies/otus/articles/727590/

Eng https://dbader.org/blog/python-decorators

👉

Поиск самой быстрой JSON-библиотеки на Python (8 сравнений)

Большинство тестов производительности, подобных этому, включают всего четыре библиотеки JSON: обычно стандартную библиотеку JSON, orjson, ujson и rapidjson. Однако, благодаря моему максималистскому подходу, я решил пойти гораздо дальше и найти все библиотеки JSON, которые так или иначе можно использовать, и протестировать их. Таким образом я обнаружил некоторых «новых игроков», таких как cysimdjson, yapic.json и pysimdjson.

orjson: ijl/orjson
pysimdjson: TkTech/pysimdjson
yapic.json: zozzz/yapic.json
simplejson: simplejson/simplejson
ujson: ultrajson/ultrajson
python-rapidjson: python-rapidjson/python-rapidjson
cysimdjson: TeskaLabs/cysimdjson
nujson (deprecated): caiyunapp/ultrajson

https://catnotfoundnear.github.io/finding-the-fastest-python-json-library-on-all-python-versions-8-compared.html

👉

Техническое собеседование на позицию Python Junior

источник

👉

Самый быстрый способ чтения Excel в Python: чтение 500 тысяч строк менее чем за 4 секунды

У меня нет данных, чтобы подтвердить это утверждение, но я почти уверен, что Excel — самый распространённый способ хранения, обработки и, да(!), даже передачи данных. Именно поэтому нередко приходится работать с Excel в Python. Недавно мне понадобилось это сделать, и я протестировал и оценил несколько способов чтения файлов Excel в Python.

https://hakibenita.com/fast-excel-python#results-summary

👉

Типизация в Python

Динамическая типизация позволяет определять и изменять тип переменных во время выполнения программы, в отличие от статической, при которой типы данных определяются на этапе компиляции и не подлежат изменениям. Динамическая типизация позволяет уменьшить сложность кода, но при этом возрастает риск появления ошибок, связанных с неправильным типом данных.

Аннотации типов можно использовать для типизации функций Python. В функциях можно аннотировать аргументы функций, их возвращаемые значения, декораторы функции и т.д.

def find_max(numbers: List[int]) -> int:
    if not numbers:
        raise ValueError(“Список пуст”)
    max_value: int = numbers[0]
    for num in numbers:
        if num > max_value:
            max_value = num
    return max_value

https://telegra.ph/Tipizaciya-v-Python-11-01

👉

Что такое «сырые» строки (Raw Strings) в Python?

В Python "сырые" строки (или **raw strings**) — это строки, в которых символы обратного слэша \ воспринимаются буквально, а не как специальные символы (например, \n для новой строки, \t для табуляции и т. д.). Они обозначаются префиксом r перед строкой, например: r"строка".

Сырые строки удобны, когда вам нужно использовать много обратных слэшей, например, в путях к файлам или регулярных выражениях, где \ часто встречается. Сырые строки упрощают код и помогают избежать ошибок, связанных с экранированием символов.

Пример использования

# Обычная строка
print("C:\\new_folder\\file.txt")  # Выводит: C:\new_folder\file.txt

# Сырая строка
print(r"C:\new_folder\file.txt")   # Выводит: C:\new_folder\file.txt

В первом случае \\ используется для экранирования, чтобы Python не воспринял \n как символ новой строки. В случае сырой строки r"...", экранирование не нужно, так как \ воспринимается буквально.

👉

Что такое хуки? Как они используются в Python?

Хуки (hooks) в программировании — это специальные точки в коде, в которые можно «вклиниться», чтобы изменить или расширить поведение программы без модификации её исходного кода. Хуки позволяют добавлять дополнительную логику или выполнять нужные действия, когда происходят определенные события.


⚫️Как хуки используются в Python?

В Python хуки часто реализуются в библиотеках и фреймворках для того, чтобы пользователи могли добавлять свои функции, выполняющиеся при определённых событиях. Они применяются в тестировании, веб-разработке, обработке данных и многих других областях. Вот несколько примеров использования хуков в Python:

1. Тестовые фреймворки (например, pytest):
В тестовом фреймворке pytest есть хуки для настройки и завершения тестов. Вы можете создать функции, которые будут выполняться до начала тестов (`pytest_runtest_setup`) или после их завершения (`pytest_runtest_teardown`). Это удобно для создания и очистки тестовой среды.

   # Пример hook-функции в pytest
   def pytest_runtest_setup(item):
       print(f"Setting up for test: {item.name}")
   

2. Веб-фреймворки (например, Django):
В Django хуки используются для расширения поведения, например, перед или после сохранения объекта. Так, у моделей Django есть хуки pre_save и post_save, которые позволяют выполнять код до и после сохранения объекта в базе данных.

   from django.db.models.signals import pre_save
   from django.dispatch import receiver
   from .models import MyModel

   (pre_save, sender=MyModel)
   def my_hook(sender, instance, **kwargs):
       print("This runs before saving MyModel instance.")
   

3. Flask (перед/после обработки запроса):
Flask имеет хуки before_request и after_request, которые позволяют выполнить код до обработки HTTP-запроса или после отправки ответа.

   from flask import Flask

   app = Flask(__name__)

   .before_request
   def before_request_func():
       print("This runs before each request")

   .after_request
   def after_request_func(response):
       print("This runs after each request")
       return response
   

4. Логирование и обработка ошибок:
Встроенный модуль logging в Python поддерживает хуки для настраиваемой обработки логов, например, через методы addFilter или создание своих обработчиков (`handlers`), чтобы настроить кастомное поведение логирования.

Хуки гибкие и удобные, поскольку они позволяют разработчику интегрировать собственную логику в существующий код, не изменяя его.

👉

Сравнение производительности dict() и {} в Python

Какое-то время назад, во время разбора кода, мы обсудили выбор dict() вместо {} в новом коде на Python. Коллега утверждал, что dict() более читаем и чётче выражает предназначение кода, поэтому следует предпочесть его. Меня это не убедило, но в тот момент контраргументов не нашлось, поэтому я воздержался.

Это заставило меня задуматься: в чём разница между типом dict и литеральным выражением {}?


https://habr.com/ru/articles/788440/

original https://madebyme.today/blog/python-dict-vs-curly-brackets/

👉

Справочник по Django
Django Software Foundation (2024)

👉

HTTP-сервер Rust для приложений на Python

Особенности
Поддерживает интерфейсные приложения ASGI/3, RSGI и WSGI
Реализует протоколы HTTP/1 и HTTP/2
Поддерживает HTTPS
Поддержка Websockets

https://github.com/emmett-framework/granian

👉

Шпаргалка по Python

👉

PikaScript

Ультралегкий интерпретатор Python, работающий всего с 4 КБ оперативной памяти, с нулевыми зависимостями. Он готов к использованию из коробки, не требует конфигурации и легко расширяется с помощью языка C. Похожие проекты: MicroPython, JerryScript.

Все это позволяет вам программировать на языке Python даже для самых маломощных микроконтроллеров семейства STM32

https://github.com/pikasTech/PikaPython

👉

Аутентификация, авторизация пользователей и единый вход (SSO) с использованием Django

Меня зовут Вячеслав Разводов, и я уже более 10 лет в IT. За это время мне удалось пройти путь от разработки на Delphi, разработки веб-сайтов на PHP-фреймворках до backend-разработки на Python. Этот материал является результатом моих усилий по систематизации знаний об SSO (единой системе идентификации).

В моей карьере присутствует период работы в бюджетной организации, подчиняющейся Министерству здравоохранения, где моя задача - разрабатывать информационные системы в формате веб-приложений. Условно системы можно сгруппировать:

- регистры для специфических заболеваний;
- инструменты для сбора статистических данных от медицинских работников;
- системы для обработки отчетности.

https://habr.com/ru/articles/787040/

👉

Что такое Pickling и Unpickling?

В Python pickling и unpickling — это процессы сериализации и десериализации объектов, соответственно, с использованием модуля pickle.

- Pickling — это процесс преобразования объекта Python (например, словаря, списка, класса и т.д.) в байтовую последовательность (или поток байтов), которая может быть сохранена в файл или передана по сети. Этот процесс позволяет сохранить состояние объекта для дальнейшего использования.

- Unpickling — это обратный процесс, при котором байтовая последовательность преобразуется обратно в объект Python.

Пример использования:

1. Pickling (сериализация):

import pickle

# Создаем объект
data = {'name': 'Alice', 'age': 25, 'city': 'New York'}

# Сохраняем объект в файл
with open('data.pickle', 'wb') as f:
    pickle.dump(data, f)

2. Unpickling (десериализация):

import pickle

# Читаем объект из файла
with open('data.pickle', 'rb') as f:
    loaded_data = pickle.load(f)

print(loaded_data)

Когда это может быть полезно?
- Сохранение промежуточных данных в файл для повторного использования.
- Передача сложных объектов между разными программами или системами.
- Сохранение состояния приложения.

Однако, нужно быть осторожным с unpickling, так как загрузка непроверенных данных может привести к выполнению вредоносного кода.

👉

Модуль functools для манипуляций с функциями

Модуль functools в Python предоставляет инструменты для работы с функциями, позволяя выполнять различные манипуляции с ними. Вот некоторые из наиболее важных функций и возможностей, которые предоставляет functools:

1. `functools.partial`: Позволяет зафиксировать некоторые аргументы функции и создать новую функцию с предопределенными значениями.

   from functools import partial

   def multiply(x, y):
       return x * y

   double = partial(multiply, 2)
   print(double(5))  # Вывод: 10
   

2. `functools.reduce`: Применяет функцию к паре элементов в последовательности, сокращая ее до одного значения. Обычно используется для аккумуляции значений.

   from functools import reduce

   numbers = [1, 2, 3, 4]
   product = reduce(lambda x, y: x * y, numbers)
   print(product)  # Вывод: 24
   

3. `functools.lru_cache`: Кэширует результаты вызовов функции, чтобы ускорить повторные вызовы с теми же аргументами. Полезно для функций с дорогими вычислениями.

   from functools import lru_cache

   (maxsize=None)
   def fibonacci(n):
       if n < 2:
           return n
       return fibonacci(n - 1) + fibonacci(n - 2)

   print(fibonacci(10))  # Вывод: 55
   

4. `functools.wraps`: Декоратор, который сохраняет метаданные оригинальной функции (такие как имя и документация) при создании декоратора.

   from functools import wraps

   def my_decorator(func):
       (func)
       def wrapper(*args, **kwargs):
           print("Что-то делаем перед вызовом функции")
           return func(*args, **kwargs)
       return wrapper

   
   def say_hello():
       """Выводит приветствие."""
       print("Привет!")

   print(say_hello.__name__)  # Вывод: say_hello
   print(say_hello.__doc__)   # Вывод: Выводит приветствие.
   

5. `functools.total_ordering`: Упрощает реализацию всех методов сравнения для класса, определяя только несколько из них.

   from functools import total_ordering

   
   class Point:
       def __init__(self, x, y):
           self.x = x
           self.y = y

       def __eq__(self, other):
           return (self.x, self.y) == (other.x, other.y)

       def __lt__(self, other):
           return (self.x, self.y) < (other.x, other.y)

   p1 = Point(1, 2)
   p2 = Point(3, 4)
   print(p1 < p2)  # Вывод: True
   print(p1 <= p2)  # Вывод: True
   

Эти функции и декораторы делают functools мощным инструментом для функционального программирования в Python.

👉

Параллелизм в Python с помощью FastAPI

Давайте погрузимся в эту тему с помощью нового крутого фреймворка ASGI, FastAPI. Это concurrent framework, что означает asyncio-friendly. Тианголо, автор, утверждает, что производительность находится на одном уровне с веб-серверами Go и Node.

https://horaceguy.pages.dev/posts/python-concurrency/

👉

Бесплатное IT-образование в 2024

Отобрали для вас полезные телеграм-каналы, которые помогут освоить программирование и другие IT-направления

Выбирайте нужное и подписывайтесь:

👩‍💻 Python:
📱 GitHub:
🤓 Книги айти:
⚙️ Backend:
👩‍💻 Frontend:
👩‍💻 Java:
👩‍💻 C#:
👩‍💻 С/С++:
🖥 Базы Данных & SQL:
👩‍💻 Golang:
👩‍💻 PHP:
👩‍💻 Моб. разработка:
👩‍💻 Разработка игр:
👩‍💻 DevOps:
🖥 Data Science:
🤔 Хакинг & ИБ:
🐞 Тестирование:
📱 Маркетинг:
🖥 Дизайн:

➡️ Сохраняйте себе, чтобы не потерять

Сравнение производительности dict() и {} в Python

Какое-то время назад, во время разбора кода, мы обсудили выбор dict() вместо {} в новом коде на Python. Коллега утверждал, что dict() более читаем и чётче выражает предназначение кода, поэтому следует предпочесть его. Меня это не убедило, но в тот момент контраргументов не нашлось, поэтому я воздержался.

Это заставило меня задуматься: в чём разница между типом dict и литеральным выражением {}?

Давайте изучим этот вопрос.

https://madebyme.today/blog/python-dict-vs-curly-brackets/

👉

Как правильно структурировать Python-проект

Под "структурой" мы понимаем решения, которые вы принимаете относительно того, как ваш проект наилучшим образом достигает своей цели. Нам нужно рассмотреть, как лучше всего использовать возможности Python для создания чистого и эффективного кода. На практике "структура" означает создание чистого кода, чья логика и зависимости понятны, а также то, как файлы и папки организованы в файловой системе.

Какие функции должны находиться в каких модулях? Как данные перемещаются по проекту? Какие функции и возможности можно сгруппировать и изолировать? Отвечая на такие вопросы, вы можете начать планировать, в общих чертах, каким будет ваш готовый продукт.

В этом разделе мы более подробно рассмотрим модули Python и систему импорта, так как они являются центральными элементами, обеспечивающими структуру вашего проекта. Затем мы обсудим различные подходы к созданию кода, который можно расширять и надежно тестировать.

https://docs.python-guide.org/writing/structure/

👉

Статистика на примерах с Python #1

Содержание:
1.1 Общая информация
1.2 Генеральная совокупность и выборка
1.3 Типы переменных. Количественные и номинативные переменные
1.4 Меры центральной тенденции

https://habr.com/ru/articles/786760/

👉

Функции как объекты в Python

В Python функции являются объектами первого класса, что означает, что их можно присваивать переменным, передавать как аргументы другим функциям, возвращать из других функций и хранить в структурах данных, таких как списки или словари.

Рассмотрим основные аспекты использования функций как объектов:

1. Присваивание функции переменной
Вы можете присвоить функцию переменной и вызывать её через эту переменную.

def greet(name):
    return f"Hello, {name}!"

say_hello = greet  # присваиваем функцию переменной
print(say_hello("Alice"))  # вызов через переменную

2. Передача функции в качестве аргумента
Функцию можно передать как аргумент другой функции.

def apply_function(func, value):
    return func(value)

def square(x):
    return x ** 2

result = apply_function(square, 5)
print(result)  # вывод: 25

3. Возврат функции из другой функции
Функция может возвращать другую функцию.

def make_multiplier(factor):
    def multiplier(x):
        return x * factor
    return multiplier

double = make_multiplier(2)
print(double(5))  # вывод: 10

4. Хранение функций в структурах данных
Функции можно хранить в списках, словарях и других структурах данных.

def add(x, y):
    return x + y

def subtract(x, y):
    return x - y

operations = {
    'add': add,
    'subtract': subtract
}

print(operations['add'](10, 5))  # вывод: 15
print(operations['subtract'](10, 5))  # вывод: 5

5. Анонимные функции (lambda)
Вы можете создавать функции "на лету" с помощью выражения lambda.

multiply = lambda x, y: x * y
print(multiply(3, 4))  # вывод: 12

Таким образом, функции в Python могут использоваться гибко и динамически, что позволяет писать более функциональный и модульный код.

👉

Сборник вопросов и ответов для собеседования по Python

Если вы - разработчик Python, желающий узнать больше, руководство эксперта может дополнить знания, полученные из книги.

👉

Расскажите про области видимости переменных в Python

В Python область видимости переменной определяет, где эта переменная доступна для использования. Существуют несколько уровней областей видимости, которые можно описать через аббревиатуру LEGB:

1. Local (локальная область):
- Это переменные, определённые внутри функции. Они доступны только в пределах этой функции.
- Пример:

     def my_function():
         x = 10  # локальная переменная
         print(x)
     
     my_function()  # выведет 10
     # print(x)  # ошибка, переменная x не существует за пределами функции
     

2. Enclosing (охватывающая область):
- Переменные, определённые в функциях внешнего уровня по отношению к вложенным функциям. Эти переменные доступны вложенным функциям.
- Пример:

     def outer_function():
         x = 5
         def inner_function():
             print(x)  # доступ к переменной из охватывающей области
         inner_function()
     
     outer_function()  # выведет 5
     

3. Global (глобальная область):
- Это переменные, определённые на уровне модуля, вне каких-либо функций. Они доступны во всём модуле.
- Чтобы изменить глобальную переменную внутри функции, нужно использовать ключевое слово global.
- Пример:

     x = 20  # глобальная переменная

     def my_function():
         global x
         x = 10  # изменение глобальной переменной
     
     my_function()
     print(x)  # выведет 10
     

4. Built-in (встроенная область):
- Это встроенные в Python функции и имена, такие как len(), sum(), print() и другие. Эти имена доступны в любой точке программы.
- Пример:

     print(len([1, 2, 3]))  # использует встроенную функцию len
     

Правила поиска переменной (LEGB)

Когда вы обращаетесь к переменной, Python ищет её значение в следующем порядке:
1. Local: Ищет в локальной области.
2. Enclosing: Ищет в охватывающей области, если функция вложена.
3. Global: Ищет среди глобальных переменных модуля.
4. Built-in: Ищет среди встроенных имён.

Таким образом, Python будет использовать ближайшую переменную в соответствии с этим порядком.

👉

Как разрабатывать (и как не разрабатывать) REST API

За свою карьеру я использовал сотни REST API и создал десятки. Поскольку я часто вижу одни и те же ошибки, повторяющиеся при проектировании API, я подумал, что было бы неплохо написать набор лучших практик. И посмеяться над парой широко используемых API.
Многое из этого может быть «само собой разумеющимся», но, возможно, есть несколько правил, о которых вы еще не задумывались.
Без особого порядка...

Правило №0: НЕ будьте педантичным.
Правило №1: ИСПОЛЬЗУЙТЕ существительные во множественном числе для коллекций.
Правило №2: НЕ добавляйте ненужные сегменты пути.
Правило №3: НЕ добавляйте .json или другие расширения в URL.
Правило №4: НЕ возвращайте массивы как верхнеуровневые ответы.
Правило №5: НЕ возвращайте структуры карт (map).
Правило №6: ИСПОЛЬЗУЙТЕ строки для всех идентификаторов.
Правило №7: ДОБАВЛЯЙТЕ префикс к вашим идентификаторам.
Правило №8: НЕ используйте 404 для указания «не найдено».
Правило №9: БУДЬТЕ последовательными.
Правило №10: ИСПОЛЬЗУЙТЕ структурированный формат ошибок.
Правило №11: ПРЕДОСТАВЛЯЙТЕ механизмы идемпотентности.
Правило №12: ИСПОЛЬЗУЙТЕ строки ISO8601 для отметок времени.

https://github.com/stickfigure/blog/wiki/How-to-(and-how-not-to)-design-REST-APIs

👉

Шпаргалка по Python. Часть 2


7. Работа с исключениями

#### Множественные исключения:

try:
    result = 10 / 0
except ZeroDivisionError as e:
    print(f"Error: {e}")
except Exception as e:
    print(f"Unhandled error: {e}")
finally:
    print("Cleanup")

#### Создание своих исключений:

class MyCustomError(Exception):
    pass

raise MyCustomError("This is a custom error")

8. Операции с числами и математикой

#### Округление и точные вычисления:

import decimal
from decimal import Decimal

decimal.getcontext().prec = 4
x = Decimal('1.12345')
y = Decimal('3.14159')
print(x * y)  # Результат с 4 знаками после запятой

#### Математические операции:

import math

print(math.sqrt(16))  # 4.0
print(math.factorial(5))  # 120

9. Модули и пакеты

#### Импортирование модулей:

from my_module import my_function

my_function()

#### Динамический импорт:

module_name = 'math'
module = __import__(module_name)
print(module.sqrt(16))  # 4.0

10. Тестирование

#### Unittest:

import unittest

def add(a, b):
    return a + b

class TestMath(unittest.TestCase):
    def test_add(self):
        self.assertEqual(add(2, 3), 5)

if __name__ == '__main__':
    unittest.main()

#### Pytest:

def add(a, b):
    return a + b

def test_add():
    assert add(2, 3) == 5

11. Работа с данными и библиотеками

#### NumPy для работы с массивами:

import numpy as np

a = np.array([1, 2, 3])
print(a * 2)  # Умножение каждого элемента массива на 2

#### Pandas для работы с табличными данными:

import pandas as pd

data = {'Name': ['Alice', 'Bob'], 'Age': [25, 30]}
df = pd.DataFrame(data)
print(df)

12. Полезные утилиты

- Enumerate для индексации:

  for index, value in enumerate(['a', 'b', 'c']):
      print(index, value)
  

- Zip для объединения списков:

  names = ['Alice', 'Bob']
  ages = [25, 30]
  for name, age in zip(names, ages):
      print(f"{name} is {age} years old")
  

- Comprehensions для работы со сложными структурами данных:

  matrix = [[i * j for j in range(5)] for i in range(5)]
  

👉

Шпаргалка по Python. Часть 1

1. Основы работы с коллекциями

#### Списки (List) и генераторы списков:
- Быстрая инициализация списка:

  lst = [x**2 for x in range(10) if x % 2 == 0]
  

- Использование map и filter:

  squares = list(map(lambda x: x**2, range(10)))
  evens = list(filter(lambda x: x % 2 == 0, range(10)))
  

- Развертывание списка (spreading):

  lst1 = [1, 2, 3]
  lst2 = [4, 5]
  combined = [*lst1, *lst2]
  

#### Словари (Dict):
- Генерация словаря:

  dct = {x: x**2 for x in range(5)}
  

- Объединение двух словарей:

  dct1 = {'a': 1, 'b': 2}
  dct2 = {'b': 3, 'c': 4}
  merged = {**dct1, **dct2}  # {'a': 1, 'b': 3, 'c': 4}
  

#### Множества (Set):
- Операции с множествами:

  set1 = {1, 2, 3}
  set2 = {3, 4, 5}
  union = set1 | set2  # Объединение
  intersection = set1 & set2  # Пересечение
  

2. Работа с файлами

#### Чтение и запись:

with open('file.txt', 'r') as f:
    content = f.read()

with open('file.txt', 'w') as f:
    f.write("Hello, World!")

#### Управление JSON:

import json

data = {'key': 'value'}
with open('data.json', 'w') as f:
    json.dump(data, f)

with open('data.json', 'r') as f:
    data = json.load(f)

3. Декораторы

#### Простой декоратор:

def my_decorator(func):
    def wrapper():
        print("Before function")
        func()
        print("After function")
    return wrapper


def say_hello():
    print("Hello!")

say_hello()

#### Декоратор с аргументами:

def repeat(n):
    def decorator(func):
        def wrapper(*args, **kwargs):
            for _ in range(n):
                func(*args, **kwargs)
        return wrapper
    return decorator

(3)
def say_hello():
    print("Hello!")

say_hello()

4. Итераторы и генераторы

#### Создание итератора:

class MyIterator:
    def __init__(self, start, end):
        self.current = start
        self.end = end

    def __iter__(self):
        return self

    def __next__(self):
        if self.current >= self.end:
            raise StopIteration
        self.current += 1
        return self.current - 1

for num in MyIterator(1, 5):
    print(num)

#### Генераторы:

def my_generator():
    for i in range(3):
        yield i

for value in my_generator():
    print(value)

#### Генераторы с обработкой состояния:

def countdown(n):
    while n > 0:
        yield n
        n -= 1

5. Менеджеры контекста

#### Создание собственного менеджера контекста:

class MyContextManager:
    def __enter__(self):
        print("Entering context")
        return self

    def __exit__(self, exc_type, exc_val, exc_tb):
        print("Exiting context")

with MyContextManager():
    print("Inside context")

#### Менеджеры контекста с contextlib:

from contextlib import contextmanager


def my_context():
    print("Entering")
    yield
    print("Exiting")

with my_context():
    print("Inside")

6. Асинхронное программирование

#### Асинхронные функции и await:

import asyncio

async def say_hello():
    print("Hello")
    await asyncio.sleep(1)
    print("World")

asyncio.run(say_hello())

#### Запуск нескольких задач одновременно:

async def task1():
    await asyncio.sleep(1)
    print("Task 1 done")

async def task2():
    await asyncio.sleep(2)
    print("Task 2 done")

async def main():
    await asyncio.gather(task1(), task2())

asyncio.run(main())

👉

Что делает функция seed() модуля random

Функция seed() в модуле random в Python используется для инициализации генератора случайных чисел. По умолчанию генератор случайных чисел использует текущее системное время, чтобы генерировать случайные числа, но если задать определённое значение с помощью функции seed(), последовательность случайных чисел станет предсказуемой.

Пример использования:

import random

random.seed(10)
print(random.random())  # Всегда будет генерировать одно и то же число

Основные моменты:
- Если вызвать random.seed() с одним и тем же значением несколько раз, генератор будет создавать одну и ту же последовательность случайных чисел.
- Если seed() не вызывается или вызывается без аргументов, генерация случайных чисел будет происходить на основе текущего времени или другого системного источника.

Таким образом, использование seed() полезно, когда требуется воспроизвести результаты, например, в тестах или для отладки.

👉

Ускоряем работу python с numba

Numba — это Just-In-Time компилятор, который превращает ваш код на питоне в машинный код на лету. Это не просто мелкая оптимизация, а серьёзно ускорение.

Если вы знакомы с интерпретируемыми языками, вы знаете, что они обычно медленнее компилируемых из-за необходимости анализировать и исполнять код на лету. Но что, если бы вы могли получить лучшее из обоих миров? JIT-компиляция позволяет интерпретируемому языку, каким является питон, динамически компилировать части кода в машинный код, значительно ускоряя исполнение.

Numba использует этот подход, чтобы помочь вашему коду на питоне быть быстрей. Она анализирует вашу функцию, определяет типы данных и затем компилирует её в оптимизированный машинный код. И всё это происходит во время выполнения вашего кода.

https://habr.com/ru/companies/otus/articles/784068/

👉