❕❕❕Метапрограммирование и динамическое создание функций на лету

🐍 Привет, питонисты! Сегодня поговорим о настоящей магии в мире Python – метапрограммировании и динамическом создании функций.


Начнем с простого примера. Помните eval() и exec()? Это базовые инструменты метапрограммирования, но использовать их нужно с осторожностью – как острый нож в руках повара. Гораздо интереснее копнуть глубже!

def create_power_function(power):
    def power_func(x):
        return x ** power
    return power_func

# Создаём функции на лету
square = create_power_function(2)
cube = create_power_function(3)

Но это только верхушка айсберга! 🧊 Настоящее веселье начинается, когда мы подключаем модуль types и функцию exec с собственным словарем namespace. Это как собирать конструктор, только вместо деталей – части функции.

А вы знали, что можно создавать функции с динамическим количеством аргументов? Или генерировать методы классов на лету? Это как будто у вас есть 3D-принтер для кода! 🖨

import types

def create_dynamic_function(func_name, args, body):
    namespace = {}
    func_code = f"def {func_name}({', '.join(args)}):\n{body}"
    exec(func_code, globals(), namespace)
    return namespace[func_name]

# Магия в действии
greet = create_dynamic_function(
    "greet",
    ["name"],
    "    return f'Привет, {name}!'"
)

Но помните – с большой силой приходит большая ответственность! 🦸‍♂️ Метапрограммирование может сделать код сложным для понимания. Используйте его мудро, когда выгода очевидна:

- При создании API с повторяющимися паттернами
- Для автоматизации рутинных задач
- При разработке фреймворков и библиотек

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

Экспериментируйте, но не забывайте про читаемость кода – ваши коллеги скажут спасибо! 😉

P.S. Если вам понравилась статья, подписывайтесь на канал и делитесь своими магическими трюками в комментариях! 🎮

2️⃣ Вторая часть для игроделов!

🔫 Написали выстрелы.
Стоит ли добавлять ограничения по патронам. Свапы оружия. Обоймы?

https://youtu.be/5NSH-sNi-6Uhttps://youtu.be/5NSH-sNi-6U

__slots__: Магия оптимизации памяти в Python 🎩🎩✨✨

Привет, питонисты! Сегодня поговорим о крутой фиче Python, которая может значительно сократить потребление памяти вашими объектами. Да-да, речь о магическом атрибуте slots!

🤔 Для начала давайте разберемся, почему вообще возникла необходимость в slots. По умолчанию Python хранит атрибуты объектов в специальном словаре dict. Это удобно и гибко – можно добавлять новые атрибуты на лету. Но у такой роскоши есть цена: дополнительные накладные расходы на память.

💡 Представьте, что у вас миллион объектов класса User с парой атрибутов. Каждый такой объект тащит за собой словарь dict, а это прожорливая структура данных. И тут на сцену выходит наш герой – slots!

# Без slots
class User:
    def __init__(self, name, age):
        self.name = name
        self.age = age

# Со slots
class OptimizedUser:
    __slots__ = ['name', 'age']
    
    def __init__(self, name, age):
        self.name = name
        self.age = age

🚀 Что даёт нам slots? Вместо создания словаря Python выделяет фиксированный массив в памяти под указанные атрибуты. Это как переход от просторного лофта к компактной студии – места меньше, зато экономия налицо!

📊 Реальные цифры? Пожалуйста! На практике использование slots может сократить потребление памяти на 30-50% для простых объектов. А при работе с миллионами инстансов экономия становится более чем существенной.

🎯 Где это реально пригодится:

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

⚠️ Но есть и подводные камни:

- Нельзя добавлять новые атрибуты после определения класса
- Наследование работает не так прозрачно, как с обычными классами
- Некоторые метаклассы могут конфликтовать со slots

🔧 Пример реального применения:

class DataPoint:
    __slots__ = ['timestamp', 'value', 'sensor_id']
    
    def __init__(self, timestamp, value, sensor_id):
        self.timestamp = timestamp
        self.value = value
        self.sensor_id = sensor_id

# Представьте, что таких объектов у вас миллионы
data_points = [DataPoint(time.time(), random.random(), i) for i in range(1_000_000)]

💡 Про что стоит помнить: slots – это не волшебная таблетка. Используйте его там, где действительно важна оптимизация памяти и где вы уверены в неизменном наборе атрибутов.

🎉 Вот такая она – магия slots! Простая, но эффективная оптимизация, которая может здорово помочь в правильном контексте. Пользуйтесь с умом!

А вы уже используете slots в своих проектах? Делитесь опытом в комментариях! 👇

🌳🌳🌳🌳🌳🌳 Работа с AST (Abstract Syntax Trees) для анализа и оптимизации кода

🌳 Привет, друзья-разработчики! Сегодня поговорим о мощном инструменте, который может превратить вас в настоящего код-волшебника – Abstract Syntax Trees (AST). Если вы когда-нибудь задумывались, как работают линтеры, компиляторы или автоматические рефакторинг-инструменты, то добро пожаловать в увлекательный мир синтаксических деревьев!

🔍 Представьте, что ваш код – это книга, а AST – её подробное содержание, где каждая глава, параграф и предложение аккуратно структурированы в древовидную форму. Каждый узел такого дерева представляет собой конструкцию вашего кода: функции, классы, операторы и даже отдельные переменные.

💡 В Python работа с AST стала намного проще благодаря встроенному модулю ast. Давайте разберем несколько практических примеров:

1️⃣ Базовый анализ кода

import ast

code = """
def calculate_sum(a, b):
    result = a + b
    print(f"Sum: {result}")
    return result
"""

# Создаем AST
tree = ast.parse(code)

# Анализируем структуру
for node in ast.walk(tree):
    if isinstance(node, ast.FunctionDef):
        print(f"Найдена функция: {node.name}")
    elif isinstance(node, ast.Name):
        print(f"Найдена переменная: {node.id}")

🔧 Этот простой пример показывает, как мы можем "гулять" по дереву AST и находить различные элементы кода. Это базовый строительный блок для создания более сложных анализаторов.

2️⃣ Трансформация кода

class DebugTransformer(ast.NodeTransformer):
    def visit_FunctionDef(self, node):
        # Добавляем отладочный print в начало каждой функции
        debug_print = ast.Expr(
            value=ast.Call(
                func=ast.Name(id='print', ctx=ast.Load()),
                args=[ast.Constant(value=f"Вызов функции {node.name}")],
                keywords=[]
            )
        )
        node.body.insert(0, debug_print)
        return node

# Применяем трансформацию
transformed = DebugTransformer().visit(tree)

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

3️⃣ Оптимизация кода

class StringOptimizer(ast.NodeTransformer):
    def visit_BinOp(self, node):
        # Оптимизация конкатенации строк
        if isinstance(node.op, ast.Add):
            if isinstance(node.left, ast.Constant) and isinstance(node.right, ast.Constant):
                if isinstance(node.left.value, str) and isinstance(node.right.value, str):
                    return ast.Constant(value=node.left.value + node.right.value)
        return node

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

🔍 Вот несколько интересных применений AST в реальных проектах:

- Статический анализ безопасности: поиск потенциальных уязвимостей в коде
- Автоматическая документация: генерация документации на основе структуры кода
- Миграция кода: автоматическое обновление устаревших конструкций
- Оптимизация производительности: автоматический поиск неэффективных паттернов

💡 Продвинутый пример: Давайте создадим анализатор сложности кода:

class ComplexityAnalyzer(ast.NodeVisitor):
    def __init__(self):
        self.complexity = 0
        
    def visit_If(self, node):
        self.complexity += 1
        self.generic_visit(node)
        
    def visit_For(self, node):
        self.complexity += 2
        self.generic_visit(node)
        
    def visit_While(self, node):
        self.complexity += 2
        self.generic_visit(node)

# Использование
analyzer = ComplexityAnalyzer()
analyzer.visit(tree)
print(f"Сложность кода: {analyzer.complexity}")

🎓 Для тех, кто хочет глубже погрузиться в тему, рекомендую изучить следующие аспекты:

- Работа с типами данных и аннотациями через AST
- Создание собственных декораторов с помощью трансформации AST
- Оптимизация циклов и условных конструкций
- Анализ потока данных в программе

💪 AST – это не просто инструмент, это суперспособность разработчика. Освоив работу с синтаксическими дерев

🎮🎮Игроделы тут есть??

👨‍💻👨‍💻Полезный видос!

https://youtu.be/_ySJcOJUwEAhttps://youtu.be/_ySJcOJUwEA

🔎🔎Тестирование параллельного и асинхронного кода: лучшие практики и примеры

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

Представьте, что ваш код – это оркестр в Мариинском театре. Каждый инструмент (поток или корутина) играет свою партию. А вы – дирижёр, который должен убедиться, что все звучит гармонично. Вот только как это сделать, когда все играют одновременно? 🎵 Давайте разберемся!

➡️ 1. Изоляция – ключ к успеху

Первое правило тестирования параллельного кода: изолируйте тесты! Каждый тест должен быть как отдельная комната в звукоизолированной студии. Используйте моки и стабы, чтобы симулировать внешние зависимости. Вот пример с использованием unittest.mock:

from unittest.mock import patch
import asyncio

async def fetch_data(url):
    # Реальный запрос к API
    ...

@patch('your_module.fetch_data')
async def test_process_data(mock_fetch):
    mock_fetch.return_value = {'key': 'value'}
    result = await process_data('http://api.example.com')
    assert result == 'processed value'

Видите? Мы изолировали тест от реального API. Теперь он быстрый, как Усэйн Болт, и предсказуемый, как восход солнца! 🌅

➡️ 2. Детерминизм – ваш лучший друг

Асинхронный код может быть непредсказуемым, как погода в Питере. Но ваши тесты должны быть стабильными, как гранитная набережная. Используйте семафоры, события и другие примитивы синхронизации, чтобы контролировать порядок выполнения. Вот пример с использованием asyncio.Event:

import asyncio

async def test_order_of_execution():
    event = asyncio.Event()
    results = []

    async def task1():
        await event.wait()
        results.append(1)

    async def task2():
        results.append(2)
        event.set()

    await asyncio.gather(task1(), task2())
    assert results == [2, 1]

Этот тест всегда будет проходить, даже если вы запустите его на компьютере, работающем на картофельной батарейке! 🥔⚡️

➡️ 3. Таймауты – не просто для пиццы

⏰ Установка таймаутов в тестах – это как страховка. Вы надеетесь, что она не понадобится, но лучше иметь ее под рукой. Вот как можно использовать таймауты в pytest:

import pytest
import asyncio

@pytest.mark.asyncio
async def test_long_running_task():
    with pytest.raises(asyncio.TimeoutError):
        await asyncio.wait_for(never_ending_task(), timeout=1.0)

Этот тест убедится, что ваша функция не зависнет, как старый Windows при запуске Crysis! 💻💥

➡️ 4. Асинхронные фикстуры – ваш секретный козырь

В мире async/await фикстуры тоже должны быть асинхронными. Используйте async fixtures в pytest для подготовки и очистки тестового окружения. Вот пример:

import pytest
import asyncio

@pytest.fixture
async def database():
    db = await create_database_connection()
    yield db
    await db.close()

@pytest.mark.asyncio
async def test_database_query(database):
    result = await database.fetch('SELECT * FROM users')
    assert len(result) > 0

Эта фикстура – как заботливая мама, которая готовит завтрак перед школой и убирает посуду после. Только вместо завтрака у нас база данных! 🍳🏫

➡️ 5. Параллельное выполнение тестов – двойная выгода

🏎 Запуск тестов параллельно не только ускоряет процесс, но и помогает выявить проблемы с состоянием гонки. Используйте pytest-xdist, но будьте осторожны: убедитесь, что ваши тесты действительно независимы друг от друга. Вот команда для запуска:

pytest -n auto your_test_file.py

Это как устроить гонки Формулы-1 для ваших тестов. Победит самый быстрый и надежный код! 🏁

👨‍💻👨‍💻👨‍💻👨‍💻👨‍💻👨‍💻 Автоматизация работы с файловой системой: умные скрипты для управления данными



Привет, Питонисты с большой буквы! 👋 Сегодня поговорим о том, как превратить рутину в удовольствие.💆‍♂️
Да-да, речь пойдет об автоматизации работы с файловой системой. Готовы прокачать свои скрипты? Поехали!

Знаете ли вы, что среднестатистический разработчик тратит до 30% рабочего времени на манипуляции с файлами? Шок! 😱 Но не спешите впадать в уныние – Python спешит на помощь!

🐍 Python: ваш верный помощник в джунглях файловой системы
🐍 Python: ваш верный помощник в джунглях файловой системы

Начнем с того, что Python – это не просто язык, это швейцарский нож для работы с файлами. Библиотека os? Классика жанра! Но давайте копнем глубже.

🔥 Хот-тип: Попробуйте pathlib. Это объектно-ориентированный подход к работе с путями. Вместо склеивания строк – элегантное решение:

from pathlib import Path

downloads = Path.home() / 'Downloads'
for file in downloads.glob('*.pdf'):
    print(f"Нашел PDF: {file.name}")

Красиво, правда? 😍 И это только начало!

🧙‍♂️ Магия автоматизации: от простого к сложному

Теперь давайте создадим что-то более мощное. Представьте: вы фрилансер, и у вас куча проектов. Каждый проект – отдельная папка. А что, если автоматизировать создание структуры проекта?

import os
from pathlib import Path

def create_project_structure(name):
    base = Path(name)
    folders = ['src', 'tests', 'docs', 'resources']
    files = ['README.md', 'requirements.txt', '.gitignore']
    
    for folder in folders:
        (base / folder).mkdir(parents=True, exist_ok=True)
    
    for file in files:
        (base / file).touch()
    
    print(f"Проект {name} создан! 🎉")

create_project_structure("super_puper_project")

Бум! 💥 Одна функция, и вся структура готова. Сколько времени вы сэкономите? Правильно, тонну!

🕵️‍♂️ Детектив в мире файлов: поиск дубликатов

А теперь представьте, что вам нужно найти дубликаты файлов. Звучит как квест, не так ли? Но с Python это проще простого:

import hashlib
from collections import defaultdict

def find_duplicates(directory):
    hash_map = defaultdict(list)
    for path in Path(directory).rglob('*'):
        if path.is_file():
            file_hash = hashlib.md5(path.read_bytes()).hexdigest()
            hash_map[file_hash].append(path)
    
    return {hash: paths for hash, paths in hash_map.items() if len(paths) > 1}

dupes = find_duplicates('/path/to/directory')
for hash, files in dupes.items():
    print(f"Найдены дубликаты: {', '.join(str(f) for f in files)}")

Вуаля! 🎩 Теперь вы – настоящий детектив в мире файлов.

🚀 Автоматизация на максималках

Но почему останавливаться на достигнутом? Давайте создадим скрипт, который будет мониторить папку и автоматически сортировать файлы по типам:

import time
from watchdog.observers import Observer
from watchdog.events import FileSystemEventHandler

class Sorter(FileSystemEventHandler):
    def on_created(self, event):
        if not event.is_directory:
            file = Path(event.src_path)
            dest = file.parent / file.suffix[1:]
            dest.mkdir(exist_ok=True)
            file.rename(dest / file.name)
            print(f"Файл {file.name} перемещен в {dest}")

path = "/path/to/watch"
event_handler = Sorter()
observer = Observer()
observer.schedule(event_handler, path, recursive=False)
observer.start()

try:
    while True:
        time.sleep(1)
except KeyboardInterrupt:
    observer.stop()
observer.join()

Теперь ваши файлы будут автоматически сортироваться по папкам.

А какие ваши любимые трюки для работы с файлами? Делитесь в комментариях!

👋👋👋👋Использование и настройка asyncio для высоконагруженных приложений

🚀 Привет, Питонисты!

👀Asyncio: ваш секретный ингредиент для высоких нагрузок

Представьте, что ваше приложение – это кухня в популярном ресторане. В синхронном мире у вас один шеф-повар, готовящий блюда по очереди. С asyncio у вас целая команда виртуозов, жонглирующих сковородками и готовящих несколько блюд одновременно. Вот это производительность! 👨‍🍳👩‍🍳

⚙️ Настройка asyncio: тюнинг вашего асинхронного Ferrari

1. 🏎 Выбор правильного event loop – это как выбор двигателя для вашего болида. Для Linux-систем рекомендую uvloop – он может разогнать ваше приложение до космических скоростей:

import asyncio
import uvloop

asyncio.set_event_loop_policy(uvloop.EventLoopPolicy())

1. 🧵 Настройка пула потоков – это как добавление турбонаддува. Используйте его для тяжелых, блокирующих операций:

loop = asyncio.get_event_loop()
loop.set_default_executor(concurrent.futures.ThreadPoolExecutor(max_workers=10))

1. 🚦 Семафоры – ваши верные регулировщики трафика. Они помогут контролировать конкурентность и избежать перегрузок:

sem = asyncio.Semaphore(10)

async def controlled_task(i):
    async with sem:
        # Ваш асинхронный код здесь
        await asyncio.sleep(1)
        print(f"Задача {i} выполнена!")

💓💓 Лайфхаки для покорения высот производительности

🌪 Замените requests на aiohttp для HTTP-запросов. Это как пересесть с велосипеда на реактивный самолет – скорость поразит ваше воображение!

💾 Используйте aiomysql или asyncpg для работы с базами данных. Ваши запросы будут молниеносными, словно Усэйн Болт на стометровке!

🔬 Профилируйте код с помощью cProfile или yappi. Найдите узкие места и оптимизируйте их, как настоящий хирург производительности.

👨‍💻 Продвинутые техники: становимся асинхронными ниндзя

🥷 Используйте асинхронные контекстные менеджеры для элегантной обработки ресурсов:

class AsyncContextManager:
    async def __aenter__(self):
        print("Entering the matrix...")
        await asyncio.sleep(1)
        return self

    async def __aexit__(self, exc_type, exc, tb):
        print("Exiting the matrix...")
        await asyncio.sleep(1)

async def main():
    async with AsyncContextManager() as manager:
        print("We're in!")

🎭 Не забывайте про асинхронные генераторы – они могут творить настоящие чудеса в потоковой обработке данных:

async def async_range(start, stop):
    for i in range(start, stop):
        await asyncio.sleep(0.1)
        yield i

async def main():
    async for num in async_range(0, 10):
        print(num)

👍 Заключение: ваш путь к асинхронному совершенству

Друзья, asyncio – это не просто библиотека, это образ мышления. Освоив его, вы сможете создавать приложения, которые будут работать быстрее, эффективнее и элегантнее. Помните: в мире асинхронного программирования нет ничего невозможного! 🚀

А теперь вопрос к вам, асинхронные гуру: какие еще трюки вы используете для оптимизации asyncio в своих проектах? Поделитесь своими секретами в комментариях!

🔝🔝 Отличный хостинг, который я часто рекомендую, теперь еще и со скидкой! 🔝

Сейчас у Hostetski крутая акция — это ваш шанс воспользоваться отличным сервисом по выгодной цене! 💥

Узнайте все подробности тут 👉 Акция от Hostetski👉 Акция от Hostetski

Не упустите шанс, ведь это последние дни акции!

Кто вообще работает с логами?

Поделитесь в комментах. А кто нет, тот пусть учится.

https://youtu.be/RpQXC9aelDc

❗️ Создание динамических классов и функций с помощью type() и метаклассов


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

➡️Магия функции type()

Функция type() в Python - это не просто инструмент для определения типа объекта. Она также может быть использована для создания новых классов динамически. Вот простой пример:

MyClass = type('MyClass', (), {'x': 42, 'my_method': lambda self: print("Hello!")})

obj = MyClass()
print(obj.x)  # Выведет: 42
obj.my_method()  # Выведет: Hello!

Здесь мы создали класс MyClass с атрибутом x и методом my_method. Удивительно, правда?

➡️Шаг вперед: метаклассы

Метаклассы - это классы классов. Они позволяют нам контролировать процесс создания классов. Рассмотрим пример:

class MyMetaclass(type):
    def __new__(cls, name, bases, attrs):
        attrs['additional_method'] = lambda self: print("I'm additional!")
        return super().__new__(cls, name, bases, attrs)

class MyClass(metaclass=MyMetaclass):
    pass

obj = MyClass()
obj.additional_method()  # Выведет: I'm additional!

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

➡️Практическое применение

Динамическое создание классов и функций может быть полезно в различных сценариях:

- Фабрики классов: создание классов на основе внешних данных или конфигурации.
- Декораторы классов: модификация классов без изменения их исходного кода.
- ORM (Object-Relational Mapping): динамическое создание классов на основе структуры базы данных.

🫣🫣 Скрытые возможности библиотеки functools в Python


Библиотека functools в Python - это настоящая сокровищница для разработчиков, стремящихся оптимизировать свой код и расширить функциональные возможности языка. Хотя многие знакомы с такими популярными инструментами, как @lru_cache@lru_cache и partial, эта библиотека скрывает ряд менее известных, но не менее полезных функций.

➡️ reduce(): мощь функционального программирования


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

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

from functools import reduce

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

➡️ singledispatch: элегантное решение для перегрузки функций


@singledispatch@singledispatch позволяет создавать функции, которые ведут себя по-разному в зависимости от типа переданного аргумента. Это элегантная альтернатива множественным условным операторам.

from functools import singledispatch

@singledispatch
def process(arg):
    print(f"Обработка объекта: {arg}")

@process.register(int)
def _(arg):
    print(f"Обработка целого числа: {arg}")

@process.register(list)
def _(arg):
    print(f"Обработка списка длиной {len(arg)}")

process("строка")  # Обработка объекта: строка
process(42)        # Обработка целого числа: 42
process([1, 2, 3]) # Обработка списка длиной 3

➡️ total_ordering: автоматическое создание методов сравнения

Декоратор @total_ordering@total_ordering значительно упрощает реализацию классов, поддерживающих операции упорядочивания. Достаточно определить методы eq() и один из методов сравнения (lt, le, gt или ge), а остальные будут автоматически созданы.

from functools import total_ordering

@total_ordering
class Person:
    def __init__(self, name, age):
        self.name = name
        self.age = age

    def __eq__(self, other):
        return self.age == other.age

    def __lt__(self, other):
        return self.age < other.age

p1 = Person("Алиса", 25)
p2 = Person("Боб", 30)

print(p1 < p2)  # True
print(p1 <= p2) # True
print(p1 > p2)  # False
print(p1 >= p2) # False

➡️ cache: простая альтернатива lru_cache

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

from functools import cache

@cache
def fibonacci(n):
    if n < 2:
        return n
    return fibonacci(n-1) + fibonacci(n-2)

print(fibonacci(100))  # Мгновенный результат даже для больших чисел

➡️ wraps: сохранение метаданных функции

Декоратор @wraps@wraps помогает сохранить метаданные оригинальной функции при создании декораторов. Это особенно важно при использовании инструментов документации и отладки.

from functools import wraps

def my_decorator(func):
    @wraps(func)
    def wrapper(*args, **kwargs):
        """Это документация обертки"""
        print("До вызова функции")
        result = func(*args, **kwargs)
        print("После вызова функции")
        return result
    return wrapper

@my_decorator
def say_hello(name):
    """Приветствует пользователя по имени"""
    print(f"Привет, {name}!")

say_hello("Мария")
print(say_hello.__name__)  # Выведет: say_hello
print(say_hello.__doc__)   # Выведет: Приветствует пользователя по имени

🔝🔝 Отличный хостинг, который я часто рекомендую, теперь еще и со скидкой! 🔝

Сейчас у Hostetski крутая акция — это ваш шанс воспользоваться отличным сервисом по выгодной цене! 💥

Узнайте все подробности тут 👉 Акция от Hostetski👉 Акция от Hostetski

Не упустите шанс вывести свои проекты на новый уровень с топовым хостингом!

Привет, питонисты! Сегодня мы погрузимся в мир профилирования и оптимизации памяти в Python. Держите ваши кружки с кофе наготове — будет интересно!

❗️ Зачем вообще париться с памятью в Python?

Казалось бы, Python — язык высокого уровня с автоматическим управлением памятью. Зачем нам вообще беспокоиться об этом? Но, друзья мои, даже в Пайтоне память не бесконечна. Особенно когда вы работаете с большими данными или создаете высоконагруженные приложения.

❗️memory_profiler: ваш верный спутник

memory_profiler — это как швейцарский нож для анализа памяти. Вот пример его использования:

from memory_profiler import profile

@profile
def my_func():
    a = [1] * (10 ** 6)
    b = [2] * (2 * 10 ** 7)
    del b
    return a

if __name__ == '__main__':
    my_func()

Запустите скрипт с помощью python -m memory_profiler script.py, и вы увидите подробный отчет о использовании памяти. Красота, правда?

❗️line_profiler: когда нужна точность до строчки

Если memory_profiler — это швейцарский нож, то line_profiler — это микроскоп. Он покажет вам использование памяти построчно:

@profile
def my_func():
    a = [1] * (10 ** 6)
    b = [2] * (2 * 10 ** 7)
    del b
    return a

my_func()

Запустите с помощью kernprof -l -v script.py, и вы увидите, какая строчка сколько памяти съедает.

❗️objgraph: визуализируем объекты

objgraph — это как рентген для вашего кода. Он позволяет визуализировать объекты в памяти:

import objgraph

x = []
y = [x, [x], dict(x=x)]
objgraph.show_refs([y], filename='sample-graph.png')

Запустите это, и вы получите красивую картинку связей между объектами. Полезно для поиска утечек памяти!

❗️tracemalloc: встроенная мощь Python

А теперь — жемчужина в короне Python 3. tracemalloc — это встроенный модуль для отслеживания выделения памяти:

import tracemalloc

tracemalloc.start()

# ваш код здесь

snapshot = tracemalloc.take_snapshot()
top_stats = snapshot.statistics('lineno')

print("[ Топ 10 ]")
for stat in top_stats[:10]:
    print(stat)

Это как рентген, МРТ и УЗИ в одном флаконе. Вы увидите, где именно происходят утечки памяти.

Источник: Python Hub - сборище Питонистов Источник: Python Hub - сборище Питонистов 👩‍💻👩‍💻

🤨🤨🤨🤨🤨🤨
Кто дебажит принтом?? Будет полезно!

https://youtu.be/TW97b2PQy9shttps://youtu.be/TW97b2PQy9s

❗️❗️ Нестандартное использование Python decorators: примеры сложных и креативных применений

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

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

Помните, как вы впервые узнали о декораторах? Наверняка это было что-то вроде @staticmethod@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

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

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

Заключение: декораторы — ваш секретный ингредиент

Источник: Python Hub - сборище Питонистов Источник: Python Hub - сборище Питонистов 👩‍💻👩‍💻

❗️❗️Асинхронные генераторы в Python: мощь и практика

Привет, питонисты! Сегодня поговорим об асинхронных генераторах — фиче, которая может серьёзно прокачать ваш код. Но для начала давайте разберёмся, что это за зверь такой.

➡️ Что такое асинхронный генератор?

Представьте обычный генератор, но на стероидах. Асинхронный генератор — это функция, которая использует async def и yield для создания асинхронного итератора. Звучит сложно? На самом деле, это просто способ лениво создавать последовательность значений, не блокируя основной поток выполнения.

➡️ Зачем они нужны?

Асинхронные генераторы особенно полезны, когда вы работаете с I/O-bound задачами. Например, при обработке больших объёмов данных из сети или файловой системы. Они позволяют эффективно управлять памятью и повышают отзывчивость приложения.

➡️ Как это выглядит на практике?

async def async_range(start, stop):
    for i in range(start, stop):
        await asyncio.sleep(0.1)
        yield i

async def main():
    async for num in async_range(0, 5):
        print(num)

asyncio.run(main())

В этом примере async_range имитирует долгую операцию с помощью asyncio.sleep. В реальном коде вместо sleep могла бы быть работа с базой данных или API.

➡️ Где это реально пригодится?

1. Парсинг данных: Представьте, что вам нужно обработать гигабайты логов. Асинхронный генератор позволит читать и обрабатывать данные порциями, не загружая всё в память разом.
2. Стриминг данных: При работе с потоковым API вы можете использовать асинхронный генератор для обработки данных по мере их поступления.
3. Пагинация: Если вы работаете с API, которое возвращает данные постранично, асинхронный генератор может абстрагировать логику пагинации, предоставляя удобный интерфейс для работы с данными.

➡️ Подводные камни

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

Источник: Python Hub - сборище Питонистов Источник: Python Hub - сборище Питонистов 👩‍💻👩‍💻

🤖🤖 9 инструментов программирования ИИ с открытым исходным кодом для разработчиков ЧАСТЬ ЧАСТЬ 2️⃣2️⃣2️⃣

➡️5. Continue — ведущий помощник по написанию кода на базе ИИ

Continue похож на популярную среду IDE Cursor, но имеет открытый исходный код под лицензией Apache. Он очень настраиваемый и позволяет добавлять любую языковую модель для автодополнения или чата.

😡 Основные характеристики:

- Общение в чате для понимания и переработки кода в боковой панели
- Автозаполнение для получения встроенных предложений кода по мере ввода текста
- Редактирование кода без необходимости покидать текущий файл
- Действия по созданию ярлыков для повседневных случаев использования

➡️ 6. Qodo Merge: инструмент для автоматизированного анализа запросов на извлечение

Qodo Merge - это инструмент с открытым исходным кодом от Codium AI, который автоматизирует обзор, анализ, обратную связь и предложения для запросов на извлечение GitHub. Он совместим с другими системами контроля версий, такими как GitLab и BitBucket.

❓ Как использовать Qodo Merge:

pip install pr-agent

from pr_agent import cli
from pr_agent.config_loader import get_settings

def main():
    provider = "github"
    user_token = "..."
    openai_key = "..."
    pr_url = "..."
    command = "/review"

    get_settings().set("CONFIG.git_provider", provider)
    get_settings().set("openai.key", openai_key)
    get_settings().set("github.user_token", user_token)

    cli.run_command(pr_url, command)

if __name__ == '__main__':
    main()

➡️ 7. OpenHands: Платформа для разработчиков программного обеспечения на основе ИИ

OpenHands - одна из ведущих платформ с открытым исходным кодом для агентов ИИ. Агент OpenHands может создавать новые проекты с нуля, добавлять функции в существующие кодовые базы, отлаживать проблемы и многое другое.

❓ Как запустить OpenHands:

docker pull docker.all-hands.dev/all-hands-ai/runtime:0.12-nikolaik
docker run -it --rm --pull=always \
    -e SANDBOX_RUNTIME_CONTAINER_IMAGE=docker.all-hands.dev/all-hands-ai/runtime:0.12-nikolaik \
    -v /var/run/docker.sock:/var/run/docker.sock \
    -p 3000:3000 \
    --add-host host.docker.internal:host-gateway \
    --name openhands-app \
    docker.all-hands.dev/all-hands-ai/openhands:0.12

После запуска OpenHands будет доступен по адресу http://localhost:3000/.

➡️ 8. Cody из Sourcegraph: помощник по кодированию для IDE

Cody - это проект с открытым исходным кодом от Sourcegraph, призванный ускорить ваш рабочий процесс кодирования непосредственно в вашей IDE. Он использует расширенный поиск в качестве помощника по кодированию для извлечения контекста из локальных и удаленных кодовых баз.

❓ Основные возможности:

- Общение с базой кода
- Внесение встроенных правок
- Получение предложений по коду
- Автодополнение

➡️ 9. VannaAI: Чат с базой данных SQL

VannaAI - это инструмент с открытым исходным кодом, позволяющий общаться с базами данных SQL, используя естественный язык. Он особенно полезен для тех, кто испытывает трудности с написанием SQL-запросов.

❓ Как начать работу с VannaAI:

pip install vanna

from vanna.openai.openai_chat import OpenAI_Chat
from vanna.chromadb.chromadb_vector import ChromaDB_VectorStore

class MyVanna(ChromaDB_VectorStore, OpenAI_Chat):
    def __init__(self, config=None):
        ChromaDB_VectorStore.__init__(self, config=config)
        OpenAI_Chat.__init__(self, config=config)

vn = MyVanna(config={'api_key': 'sk-...', 'model': 'gpt-4-...'})

# Обучение модели
vn.train(ddl="""
    CREATE TABLE IF NOT EXISTS my-table (
        id INT PRIMARY KEY,
        name VARCHAR(100),
        age INT
    )
""")

# Задать вопрос
sql_query = vn.ask("What are the top 10 customers by sales?")
print(sql_query)

Источник: Python Hub - сборище Питонистов Источник: Python Hub - сборище Питонистов 👩‍💻👩‍💻

🤖🤖 9 инструментов программирования ИИ с открытым исходным кодом для разработчиков


➡️1. SWE-Kit: IDE с открытым исходным кодом для кодирующих агентов

SWE-Kit представляет собой headless IDE с такими функциями, как LSP (Language Server Protocol), индексация кода и Code RAG (Retrieval-Augmented Generation). Он предлагает гибкую среду выполнения, которая может работать на любом хосте Docker или удаленном сервере, а также специализированные наборы инструментов для кодирования.

❗️ Основные возможности:

- Интеграция с платформами GitHub, Jira и Slack
- Инструменты поиска файлов и индексации кода
- Совместимость с фреймворками LLM, такими как LangChain, CrewAI, Autogen и LlamaIndex

❓ Как начать работу с SWE-Kit:

pip install compsio-core swekit
pip install crewai composio-crewai
composio add github
swekit scaffold crewai -o swe_agent
cd swe_agent/agent
python main.py

SWE-Kit позволяет создавать и развертывать собственные агенты, такие как GitHub PR Agent для автоматизации проверки Pull Request, агент SWE для автоматического написания функций, модульных тестов и документации, а также инструмент для чата с кодовой базой.

➡️ 2. Aider - AI Pair-программист

Aider - это идеальный выбор для тех, кто ищет виртуального парного программиста. Он позволяет связать программы с моделями машинного обучения (LLM) для редактирования кода в вашем локальном репозитории GitHub.

❓ Как начать работу с Aider:

pip install aider-chat
cd /to/your/git/repo
export ANTHROPIC_API_KEY=your-key-goes-here
aider
# Или для работы с GPT-4
export OPENAI_API_KEY=your-key-goes-here
aider

➡️ 3. Mentat — собственный агент кодирования GitHub

Mentat - это инструмент на основе ИИ, призванный помочь разработчикам справиться с любой задачей по написанию кода из командной строки. В отличие от других инструментов, Mentat может координировать правки в нескольких файлах и понимает контекст проекта с самого начала.

❓ Как установить и запустить Mentat:

python3 -m venv .venv
source .venv/bin/activate
git clone https://github.com/AbanteAI/mentat.git
cd mentat
pip install -e .
export OPENAI_API_KEY=
mentat 

➡️ 4. AutoCodeRover — усовершенствование автономной программы

AutoCodeRover предлагает полностью автоматизированное решение для устранения проблем GitHub, включая исправление ошибок и добавление функций. Он объединяет LLM с расширенными возможностями анализа и отладки для эффективного создания и внедрения исправлений.

❓ Как запустить AutoCodeRover:

export OPENAI_KEY=sk-YOUR-OPENAI-API-KEY-HERE
docker build -f Dockerfile -t acr .
docker run -it -e OPENAI_KEY="${OPENAI_KEY:-OPENAI_API_KEY}" -p 3000:3000 -p 5000:5000 acr

Источник: Python Hub - сборище Питонистов Источник: Python Hub - сборище Питонистов 👩‍💻👩‍💻

https://youtu.be/MjJv14WohL4