Привет, питонисты! Сегодня мы погрузимся в мир профилирования и оптимизации памяти в 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 - сборище Питонистов 👩‍💻

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

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

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

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

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


Библиотека functools в Python - это настоящая сокровищница для разработчиков, стремящихся оптимизировать свой код и расширить функциональные возможности языка. Хотя многие знакомы с такими популярными инструментами, как @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 позволяет создавать функции, которые ведут себя по-разному в зависимости от типа переданного аргумента. Это элегантная альтернатива множественным условным операторам.

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 значительно упрощает реализацию классов, поддерживающих операции упорядочивания. Достаточно определить методы 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 помогает сохранить метаданные оригинальной функции при создании декораторов. Это особенно важно при использовании инструментов документации и отладки.

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__)   # Выведет: Приветствует пользователя по имени

❗️ Создание динамических классов и функций с помощью 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): динамическое создание классов на основе структуры базы данных.

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

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

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

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

👋👋Использование и настройка 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 в своих проектах? Поделитесь своими секретами в комментариях!

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



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

Знаете ли вы, что среднестатистический разработчик тратит до 30% рабочего времени на манипуляции с файлами? Шок! 😱 Но не спешите впадать в уныние – 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()

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

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

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

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

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

➡️ 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 для ваших тестов. Победит самый быстрый и надежный код! 🏁

🌳🌳🌳 Работа с 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 – это не просто инструмент, это суперспособность разработчика. Освоив работу с синтаксическими дерев

__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 в своих проектах? Делитесь опытом в комментариях! 👇

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

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

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

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

🐍 Привет, питонисты! Сегодня поговорим о настоящей магии в мире 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. Если вам понравилась статья, подписывайтесь на канал и делитесь своими магическими трюками в комментариях! 🎮

❓ Как использовать pathlib для работы с путями вместо os.path


Привет, питонисты! Сегодня поговорим о том, как сделать работу с путями в Python более элегантной и современной. Если вы всё ещё используете os.path, то пора двигаться вперёд!

Модуль pathlib появился в Python 3.4 и полностью изменил правила игры. Это как пересесть с древнего велосипеда на Tesla – всё те же базовые принципы, но насколько же удобнее! 🚗

💡 Почему стоит перейти на pathlib?

- Объектно-ориентированный подход вместо строковых операций
- Кроссплатформенность из коробки
- Цепочки методов, которые читаются как поэзия
- Меньше кода, больше смысла

🎯 Давайте посмотрим на практические примеры:

# Старый подход с os.path
import os.path
file_path = os.path.join('data', 'users', 'config.json')
parent_dir = os.path.dirname(file_path)
file_name = os.path.basename(file_path)

# Новый подход с pathlib
from pathlib import Path
file_path = Path('data') / 'users' / 'config.json'
parent_dir = file_path.parent
file_name = file_path.name

🔥 Крутые фишки pathlib, о которых вы могли не знать:

➡️Проверка существования файла:

path = Path('config.json')
if path.exists():
    print('Файл существует!')

➡️ Создание директорий одной командой:

Path('nested/directories/structure').mkdir(parents=True, exist_ok=True)

➡️ Поиск файлов по маске (glob):

# Найти все .py файлы в текущей директории
python_files = list(Path('.').glob('*.py'))

➡️ Работа с суффиксами и расширениями:

path = Path('document.pdf')
print(path.suffix)  # .pdf
print(path.stem)    # document

🎨 А теперь самое вкусное – цепочки методов:

config_path = (Path.home() / 'projects' / 'app' / 'config.json')
if config_path.exists():
    data = json.loads(config_path.read_text())

⚡️ Pro-tip: pathlib отлично работает с контекстными менеджерами:

with Path('log.txt').open('w') as f:
    f.write('Logging started')

🤔 Когда стоит использовать os.path? Практически никогда! Разве что при работе с легаси-кодом или если вам нужны какие-то очень специфические операции с путями.

🎉 В заключение: pathlib – это не просто альтернатива os.path, это следующий эволюционный шаг в работе с файловой системой в Python. Он делает код чище, понятнее и приятнее в поддержке. Если вы ещё не перешли на pathlib, самое время начать!

P.S. Не забудьте поставить лайк и поделиться постом с коллегами, которые всё ещё живут в мире os.path 😉😉😉😉

❗️ В рамках тестирования нового оборудования в Грузии — 200 бесплатных серверов по тарифу NAT Cloud-F уже доступны для заказа!

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

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

➡️Для заказа перейдите по ссылке:
https://htk.ge/index.php?rp=/store/nat-cloud
и выберите тариф Cloud-F.

Разбор 👨‍💻

🔍 Что возвращает метод строки find()?

Самый быстрый способ это узнать — заглянуть в документацию Python. Согласно официальной документации, если подстрока не найдена, метод `find()` возвращает -1.

Теперь интересный момент: что произойдет, если преобразовать `-1` в логическое значение? Давайте проверим:

print(bool(-1))  # Результат: True

Как видите, -1 в Python считается истинным значением (True) при приведении к типу bool.