✈️Сегодня мы нырнем в глубины Python и раскопаем настоящие жемчужины — нестандартные способы использования декораторов. Держитесь крепче, будет интересно!

➡️Декораторы на стероидах: когда обычных функций мало

Помните, как вы впервые узнали о декораторах? Наверняка это было что-то вроде @staticmethod или простенького таймера. Но, друзья мои, это лишь верхушка айсберга! Давайте посмотрим, как можно выжать из декораторов все соки.

➡️1. Декоратор-шпион: следим за аргументами

import functools

def spy_args(func):
    @functools.wraps(func)
    def wrapper(*args, **kwargs):
        print(f"Вызов {func.__name__} с аргументами: {args}, {kwargs}")
        return func(*args, **kwargs)
    return wrapper

@spy_args
def секретная_функция(x, y, шифр="007"):
    return x + y

результат = секретная_функция(3, 4, шифр="008")

⬆️Этот хитрый декоратор не просто логирует вызовы, он позволяет отслеживать все входящие аргументы. Представьте, как это может пригодиться при отладке сложных систем!

➡️2. Декоратор-трансформер: меняем возвращаемое значение

def to_json(func):
    import json
    @functools.wraps(func)
    def wrapper(*args, **kwargs):
        result = func(*args, **kwargs)
        return json.dumps(result)
    return wrapper

@to_json
def получить_данные():
    return {"имя": "Алиса", "возраст": 30}

json_data = получить_данные()

⬆️Этот декоратор автоматически сериализует результат в JSON. Удобно, правда? Особенно когда вы работаете с API и вам нужно гарантировать формат ответа.

➡️3. Декоратор-многостаночник: применяем несколько функций

def применить_все(*funcs):
    def декоратор(f):
        @functools.wraps(f)
        def wrapper(*args, **kwargs):
            result = f(*args, **kwargs)
            for func in funcs:
                result = func(result)
            return result
        return wrapper
    return декоратор

def удвоить(x): return x * 2
def прибавить_один(x): return x + 1

@применить_все(удвоить, прибавить_один)
def базовая_функция(x):
    return x

результат = базовая_функция(10)  # Вернёт 21

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

➡️4. Декоратор-ленивец: отложенное выполнение

class Ленивый:
    def __init__(self, function):
        self.function = function
        self.результат = None

    def __call__(self, *args, **kwargs):
        if self.результат is None:
            self.результат = self.function(*args, **kwargs)
        return self.результат

@Ленивый
def сложные_вычисления():
    print("Выполняю сложные вычисления...")
    return 42

результат = сложные_вычисления()  # Вычисления выполняются
результат = сложные_вычисления()  # Используется кэшированный результат

⬆️Этот декоратор позволяет отложить выполнение функции до момента первого вызова, а затем кэширует результат. Идеально для оптимизации производительности!

🐍Pythoner

✈️Тернарный оператор, также известный как условный оператор, является уникальным оператором, который используется для выполнения конденсированных версий простых операторов if-else. Он принимает три аргумента: условие, значение, если условие истинно, и значение, если условие ложно.

➡️Применение тернарного оператора

Тернарный оператор используется, когда мы хотим сократить код и упростить чтение. Это особенно полезно в случаях, когда нам нужно сделать простое условное присваивание. Однако из-за его сжатого формата, использование тернарного оператора в сложных условиях может затруднить понимание кода.

➡️Тернарный оператор в Python

Да, Python поддерживает тернарный оператор. В Python тернарный оператор выглядит следующим образом: x if condition else y. Здесь x присваивается, если условие истинно, иначе присваивается y.

➡️Пример использования тернарного оператора в Python:

age = 15
type = "teenager" if age < 18 else "adult"
print(type)  # Выведет: teenager

⬆️В этом примере, если переменная age меньше 18, переменной type присваивается значение "teenager", в противном случае - "adult".

🐍 Pythoner

✈️Модуль secrets предоставляет инструменты для создания безопасных случайных данных, сложнее предсказать.

➡️Функции модуля secrets:

1. secrets.choice(sequence): Выбирает случайный элемент из последовательности. Полезно для генерации случайных выборок или паролей из определенного набора символов.

2. secrets.randbelow(n): Возвращает случайное число от 0 до n-1. Используется для генерации случайных чисел в определенном диапазоне.

3. secrets.randbits(k): Генерирует k случайных битов. Полезно для создания случайных битовых строк или чисел.

4. secrets.token_bytes(nbytes=None): Генерирует безопасную случайную последовательность байтов длиной nbytes (по умолчанию - 32 байта).

5. secrets.token_hex(nbytes=None): Генерирует безопасную случайную строку в шестнадцатеричном формате длиной nbytes (по умолчанию - 32 байта).

6. secrets.token_urlsafe(nbytes=None): Генерирует безопасную случайную URL-совместимую строку длиной nbytes (по умолчанию - 32 байта).

7. secrets.compare_digest(a, b): Сравнивает две строки для предотвращения временных атак. Это полезно при сравнении хэшей паролей или токенов без утечки информации о длине сравниваемых строк.

🔎Почему использовать secrets?

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

🔐Используйте модуль secrets для защиты вашей информации и обеспечения безопасности ваших данных в Python.

🐍Pythoner

✈️Memray - это библиотека для профилирования памяти и она является важным инструментом оптимизации производительности Python программ.

➡️Библиотека отслеживает выделение и освобождение памяти при работе программы, поддерживает отслеживание ссылок на объект, применятся для профилирования на серверах и в виртуальных окружениях.

➡️Основные функции:
💬Отслеживание выделения памяти в реальном времени.
💬Анализ использования памяти по различным объектам и их типам.
💬Предоставление удобных отчетов и визуализаций для упрощения диагностики.

➡️Пример использования:
Memray для профилирования вашего Python-кода. Вот простой пример:

import memray

@memray.start()
def my_function():
    # Пример кода, который может выделять память
    a = [i for i in range(100000)]
    b = [j ** 2 for j in a]
    return b

my_function()

# Сохранение отчета о профилировании
memray.stop()

✅После завершения работы вашей функции Memray создаст файл отчета, который можно анализировать с использованием команд:

memray flamegraph <report_file>

⬆️Это визуализирует распределение памяти, что поможет вам лучше понять, как ваша программа использует память и где могут возникнуть проблемы.

🐍Pythoner

✈️Manim — это библиотека, которая используется для создания анимированных визуализаций и математических демонстраций. Manim позволяет легко оптимизировать визуализацию математических концепций с помощью анимаций, графиков и других визуальных элементов.

➡️Применение
С помощью Manim можно создавать как простые анимации, так и сложные сцены с множеством объектов и эффектов. Библиотека предоставляет обширные возможности по работе с графикой, анимацией и текстом.

➡️Пример:

from manim import *

class SquareNumber(Scene):
    def construct(self):
        # Создаем квадрат и текст
        square = Square(side_length=2)
        number = MathTex("0").scale(2)

        # Центрируем квадрат и текст
        square.move_to(ORIGIN)
        number.next_to(square, DOWN)

        # Добавляем квадрат и текст на экран
        self.play(Create(square), Write(number))
        self.wait(1)

        # Изменяем текст на 1
        self.play(Transform(number, MathTex("1").scale(2)))
        self.wait(1)

        # Изменяем текст на 4 и меняем размер квадрата
        self.play(Transform(number, MathTex("4").scale(2)),
                  square.animate.scale(2))
        self.wait(1)

        # Изменяем текст на 9 и меняем размер квадрата
        self.play(Transform(number, MathTex("9").scale(2)),
                  square.animate.scale(3))
        self.wait(1)

        # Завершаем сцену
        self.play(FadeOut(square), FadeOut(number))

# Для запуска сцены используйте следующую команду в терминале
# manim -pql имя_файла.py SquareNumber

⬆️Чтобы запустить данный код и увидеть анимацию, сохраните его в файл, например, square_number.py, и выполните указанную команду в терминале.

💡Заключение
Manim – мощный инструмент для создания анимационной графики, предлагающий гибкость и творческий потенциал для визуализации математических и научных концепций.

🐍Pythoner

✈️Полиморфизм - ключевой принцип объектно-ориентированного программирования (ООП), позволяющий объектам различных классов иметь одинаковый интерфейс. Термин "полиморфизм" происходит от греческого слова, означающего "множество форм". В Python полиморфизм реализуется двумя основными способами: перегрузкой методов и их переопределением.

➡️Перегрузка методов
Перегрузка методов - это возможность класса иметь несколько методов с одинаковым именем, но разными параметрами. В Python прямая перегрузка методов не поддерживается, но похожего эффекта можно достичь с помощью параметров по умолчанию и аргументов переменной длины.

➡️Пример перегрузки метода

class MathOperations:
    def add(self, a, b, c=0):
        return a + b + c

math_op = MathOperations()
print(math_op.add(10, 20))       # Вывод: 30
print(math_op.add(10, 20, 30))   # Вывод: 60

⬆️В этом примере метод add() может принимать два или три аргумента, имитируя перегрузку метода.

➡️Переопределение методов
Переопределение методов - это механизм, позволяющий подклассу предоставить свою реализацию метода, уже определенного в родительском классе. Это позволяет изменять или расширять поведение унаследованных методов.

✅Пример переопределения метода

class Animal:
    def sound(self):
        return "Какой-то звук"

class Dog(Animal):
    def sound(self):
        return "Гав"

class Cat(Animal):
    def sound(self):
        return "Мяу"

dog = Dog()
cat = Cat()
print(dog.sound())  # Вывод: Гав
print(cat.sound())  # Вывод: Мяу

⬆️В этом примере классы Dog и Cat переопределяют метод sound(), унаследованный от класса Animal.

➡️Практическое применение полиморфизма
Рассмотрим пример использования полиморфизма в системе обработки платежей:

class Payment:
    def process(self, amount):
        raise NotImplementedError("Подклассы должны реализовать этот метод")

class CreditCardPayment(Payment):
    def process(self, amount):
        return f"Обработан платеж кредитной картой на сумму {amount}."

class PayPalPayment(Payment):
    def process(self, amount):
        return f"Обработан платеж через PayPal на сумму {amount}."

credit_card = CreditCardPayment()
paypal = PayPalPayment()

print(credit_card.process(100))
print(paypal.process(200))

⬆️Этот пример демонстрирует, как полиморфизм позволяет работать с разными типами платежей через единый интерфейс.

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

🐍Pythoner

✈️Жадные алгоритмы полезны для решения задач оптимизации, делая ряд локально оптимальных выборов, которые приводят к глобально оптимальному решению. На каждом шаге они выбирают наилучший доступный вариант, не принимая во внимание последствия будущих выборов. Хотя они не гарантируют абсолютно наилучшего решения, они часто предоставляют быстрые и приемлемые решения.

➡️Пример — жадный алгоритм для дробной задачи о рюкзаке на Python

def fractional_knapsack(items, capacity):
    # Sort items by their value-to-weight ratio in descending order
    items.sort(key=lambda x: x[1] / x[0], reverse=True)

    total_value = 0
    remaining_capacity = capacity

    for item in items:
        if remaining_capacity >= item[0]:
            total_value += item[1]
            remaining_capacity -= item[0]
        else:
            total_value += (remaining_capacity / item[0]) * item[1]
            break

    return total_value

# Example usage:
items = [(2, 10), (3, 5), (5, 15), (7, 7), (1, 6)]
knapsack_capacity = 10
max_value = fractional_knapsack(items, knapsack_capacity)
print(max_value)

➡️Объяснение алгоритма
В этом примере мы используем жадный алгоритм для решения задачи о дробном рюкзаке. Учитывая набор элементов с весами и значениями, цель состоит в том, чтобы выбрать элементы, чтобы максимизировать общую стоимость, не превышая при этом определенный предел веса (емкость рюкзака). Алгоритм сортирует элементы по соотношению их стоимости к весу и выбирает элементы жадно, максимизируя общую стоимость в пределах ограничения емкости.

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

🐍Pythoner

✈️Метод tell() используется для получения текущей позиции (смещения) при работе с файлами и файлоподобными объектами.

➡️Это позволяет:
—Узнать размер файла, сравнив позицию после чтения с начальной.
—Вернуться к определенной позиции с помощью seek().
—Отслеживать прогресс обработки больших файлов.
—Получить позицию в строковых буферах и потоках байтов.

➡️Вот пример, который демонстрирует использование tell():

# Открываем файл для записи
with open('example.txt', 'w') as f:
    f.write('Hello, World!')
    # Получаем текущую позицию курсора
    position = f.tell()
    print(f'Current position after writing: {position}')  # Вывод: 13, т.к. длина строки "Hello, World!" = 13

# Открываем файл для чтения
with open('example.txt', 'r') as f:
    content = f.read(5)  # Читаем первые 5 символов
    position = f.tell()
    print(f'Content read: {content}')  # Вывод: Hello
    print(f'Current position after reading: {position}')  # Вывод: 5

⬆️В этом примере:
1. Мы открываем файл example.txt для записи и записываем в него строку "Hello, World!".
2. Используем tell(), чтобы получить позицию курсора после записи, что будет равно 13 (длина строки).
3. Затем открываем файл для чтения и читаем первые 5 символов.
4. Снова используем tell(), чтобы получить новую позицию курсора, которая будет равна 5 после чтения.

🐍Pythoner

✈️В Python си-коллбеки (C callbacks) — это механизм, позволяющий вызывать функции, написанные на языке C или C++, из Python кода. Это мощный инструмент для интеграции Python с существующими библиотеками C/C++ или для оптимизации производительности критически важных участков кода.

➡️ Применение си-коллбеков находит применение в различных областях, таких как:
* Интеграция с C/C++ библиотеками: вызов функций из библиотек, написанных на C/C++, непосредственно из Python.
* Оптимизация производительности: реализация критичных к производительности участков кода на C/C++ и вызов их из Python.
* Обработка событий: использование функций Python в качестве обработчиков событий в C/C++ приложениях.
* Расширение функциональности Python: добавление новых возможностей в Python с помощью C/C++.

➡️Вот пример использования си-коллбеков с ctypes:

import ctypes
import time

# Загрузка библиотеки C (libcallback_example.so - пример,  нужно скомпилировать код C)
lib = ctypes.CDLL("./libcallback_example.so")

# Определение типа функции обратного вызова
CMPFUNC = ctypes.CFUNCTYPE(None, ctypes.c_int)


# Функция Python, которая будет использоваться в качестве обратного вызова
def my_callback(value):
    print(f"Python callback called with value: {value}")



# Регистрация функции обратного вызова в библиотеке C
#  Предполагается, что в библиотеке C есть функция register_callback, принимающая указатель на функцию
register_callback = lib.register_callback
register_callback.argtypes = [CMPFUNC]
register_callback.restype = None
register_callback(CMPFUNC(my_callback))


# Вызов функции C, которая будет периодически вызывать функцию обратного вызова
# Предполагается, что в библиотеке C есть функция run_loop, которая запускает цикл
run_loop = lib.run_loop
run_loop.argtypes = []
run_loop.restype = None
run_loop()

➡️Пример кода на C (callback_example.c):

#include <stdio.h>
#include <unistd.h> // for sleep


typedef void (*callback_function)(int);

static callback_function registered_callback = NULL;

void register_callback(callback_function callback) {
    registered_callback = callback;
}

void run_loop() {
    int i = 0;
    while (i < 5) {
        sleep(1);
        if (registered_callback != NULL) {
            registered_callback(i);
        }
        i++;
    }
}

➡️Компиляция кода на C:
gcc -shared -o libcallback_example.so -fPIC callback_example.c

⬆️ В этом примере показано, как использовать ctypes для вызова функций из динамически подключаемой библиотеки C и передачи функции Python в качестве обратного вызова. Код на C регистрирует коллбек и периодически вызывает его. Важно правильно определить типы данных с помощью ctypes.CFUNCTYPE и argtypes/restype. Перед запуском Python кода необходимо скомпилировать код C в shared library (.so файл для Linux).

🐍 Pythoner

✈️googlesearch — это простая в использовании библиотека для Python, которая позволяет отправлять запросы в Google и получать ссылки на результаты поиска прямо из вашего кода. Она предоставляет гибкий и мощный интерфейс, который можно настроить для различных задач поиска.

➡️Основной функционал
Основной метод библиотеки — это функция search(), которая возвращает результаты поиска в виде генератора, содержащего объекты SearchResult или URL-ссылки в зависимости от параметров.

Аргументы функции:
💬term — строка с запросом, которую вы хотите найти в Google.
💬num_results — количество результатов, которые нужно вернуть (по умолчанию 10).
💬lang — язык результатов поиска (по умолчанию "en").
💬proxy — возможность использования прокси для запросов (по умолчанию None).
💬advanced — расширенный режим поиска, возвращает объекты с более детализированной информацией, такими как заголовок и описание страницы (по умолчанию False).
💬sleep_interval — время ожидания между запросами в секундах (по умолчанию 0).
💬timeout — максимальное время ожидания ответа от Google (по умолчанию 5 секунд).
💬safe — настройка безопасного поиска: "off" для отключения, "active" для фильтрации контента для взрослых (по умолчанию "active").
💬ssl_verify — возможность включить или отключить проверку SSL-сертификатов (по умолчанию None).
💬region — регион для таргетирования поиска (по умолчанию None).

➡️Примеры использования. Простой поиск:

from googlesearch import search

query = "Python best practices"
for result in search(query, num_results=5):
    print(result)

⬆️Этот код отправляет запрос "Python best practices" и возвращает первые пять ссылок на результаты поиска.

💬Расширенный поиск с дополнительными параметрами:

for result in search("новости технологий", num_results=3, lang='ru', safe='off', region='RU', advanced=True):
    print(result.title, result.url)

⬆️Поиск по русскоязычным ресурсам с отключенным безопасным поиском и указанием региона RU. В данном случае возвращаются не только ссылки, но и заголовки страниц.

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

🐍Pythoner

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

➡️Характеристики Legacy кода
💬Устаревшие технологии или методологии
💬Отсутствие или недостаточность документации
💬Сложность в поддержке и расширении
💬Высокая связность и низкая сплоченность

➡️Пример Legacy кода

# Legacy код на Python
def calculate_total(items):
    total = 0
    for item in items:
        total = total + item['price'] * item['quantity']
    return total

# Современный эквивалент
def calculate_total(items):
    return sum(item['price'] * item['quantity'] for item in items)

➡️Проблемы, связанные с Legacy кодом
💬Сложность внесения изменений и добавления новых функций
💬Повышенный риск появления ошибок при модификации
💬Трудности в интеграции с современными технологиями
💬Зависимость от устаревших библиотек и фреймворков

➡️Стратегии работы с Legacy кодом
💬Постепенный рефакторинг
💬Написание тестов для существующего кода
💬Документирование существующей функциональности
💬Модульная замена частей системы

🔎Заключение
Работа с Legacy кодом - это неизбежная часть жизни многих разработчиков. Хотя он может представлять сложности, правильный подход к его обработке может значительно улучшить качество и поддерживаемость программного обеспечения.

🐍Pythoner

✈️PyBrain — это библиотека машинного обучения, которая предоставляет широкий набор алгоритмов и инструментов для обучения нейросетей и других задач машинного обучения.

➡️PyBrain имеет ряд преимуществ, которые делают его привлекательным для разработчиков машинного обучения:
— Простота использования: PyBrain имеет простой и понятный синтаксис, который делает его удобным для изучения.
— Модульность: PyBrain является модульной библиотекой, что позволяет разработчикам создавать собственные алгоритмы и инструменты.
— Производительность: PyBrain написан на Python, который является высокопроизводительным языком.

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

➡️Простой пример создания и обучения нейронной сети с использованием PyBrain:

from pybrain.datasets import ClassificationDataSet
from pybrain.supervised.trainers import BackpropTrainer
from pybrain.tools.shortcuts import BuildNetwork

# Создание выборки данных
data = ClassificationDataSet(2, 1)

# Добавление данных (x1, x2, label)
data.addSample((0, 0), (0,))
data.addSample((0, 1), (1,))
data.addSample((1, 0), (1,))
data.addSample((1, 1), (0,))

# Создание нейронной сети
network = BuildNetwork(2, 3, 1)

# Обучение нейронной сети
trainer = BackpropTrainer(network, data)
for _ in range(1000):
    trainer.train()

# Проверка результатов
for sample in [(0, 0), (0, 1), (1, 0), (1, 1)]:
    output = network.activate(sample)
    print(f'Input: {sample}, Output: {output}')

⬆️В этом примере создается простая нейронная сеть для решения задачи логического И-Иксор (XOR). Данные добавляются в выборку, затем сеть обучается, и, наконец, результаты выводятся для разных входных значений.

🐍 Pythoner