✈️В мире разработки программного обеспечения постоянно появляются новые тренды и подходы. Одним из таких трендов, набирающих популярность в последние годы, является функциональное программирование (ФП). Давайте разберемся, почему это происходит!

➡️Что такое функциональное программирование?
Функциональное программирование - это парадигма, в которой процесс вычисления рассматривается как вычисление математических функций. Основная идея заключается в том, чтобы избегать изменяемого состояния и мутаций данных.

➡️Почему ФП становится популярнее?
💬Упрощение параллельного программирования: Отсутствие побочных эффектов делает код более предсказуемым и легким для распараллеливания.
💬Меньше багов: Неизменяемость данных и чистые функции снижают вероятность ошибок, связанных с состоянием программы.
💬Более читаемый код: ФП поощряет написание небольших, специализированных функций, что улучшает читаемость и поддерживаемость кода.
💬Легкость тестирования: Чистые функции легче тестировать, так как их поведение зависит только от входных данных.
💬Производительность: Некоторые функциональные концепции, такие как ленивые вычисления, могут повысить производительность программ.

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

🐍Pythoner

✈️Зачем вообще париться с памятью в 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)

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

🐍Pythoner

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

🔎Библиотека Gym может использоваться для:

➡️Для обучения агентов искусственного интеллекта, таких как нейронные сети и генетические алгоритмы.

➡️Для исследования искусственного интеллекта, например, для разработки новых алгоритмов обучения агентов.

➡️Для визуализации действий агентов искусственного интеллекта.

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

🐍Pythoner

💬HTTP GET
Этот метод извлекает ресурс с сервера. Он идемпотентен: несколько идентичных запросов возвращают один и тот же результат.

💬HTTP PUT
Этот метод обновляет или создает ресурс. Он также идемпотентен: несколько идентичных запросов обновят один и тот же ресурс.

💬HTTP POST
Этот метод используется для создания новых ресурсов. Он не идемпотентен: два одинаковых POST-запроса создадут дублированные ресурсы.

💬HTTP DELETE
Этот метод используется для удаления ресурса. Он идемпотентен: несколько идентичных запросов удалят один и тот же ресурс.

💬HTTP PATCH
Метод PATCH применяется для частичного изменения ресурса.

💬HTTP HEAD
Метод HEAD запрашивает ответ, идентичный GET-запросу, но без тела ответа.

💬HTTP CONNECT
Метод CONNECT устанавливает туннель к серверу, идентифицированному целевым ресурсом.

💬HTTP OPTIONS
Этот метод описывает параметры связи для целевого ресурса.

💬HTTP TRACE
Этот метод выполняет тест возврата сообщения по пути к целевому ресурсу.

👀Так же прикрепляю фото без сжатия если будет плохо видно на основном фото

🐍Pythoner

✈️Скачивание файла с помощью requests довольно прямолинейно. Вам просто нужно сделать запрос к URL-адресу файла, который вы хотите скачать, а затем записать ответ в файл. Вот пример кода, который скачивает изображение с интернета:

import requests
url = '<https://example.com/image.jpg>'
response = requests.get(url)
with open('image.jpg', 'wb') as f:
    f.write(response.content)

➡️Работа с ошибками

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

➡️Вот пример кода, который скачивает реальный pdf файл с сайта:

import requests

headers = {'referer': 'https://nottka.com/4364-yoshinao-nakada-etude-allegro.html'}
response = requests.get('https://nottka.com/index.php?do=download&id=4420', headers=headers)
with open('4420.pdf', 'wb') as file:
    file.write(response.content)

🐍Pythoner

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

➕Преимущества:
💬Простота разработки и развертывания
💬Легкость в отладке и тестировании
💬Высокая производительность из-за отсутствия сетевых задержек между компонентами

❌Недостатки:
💬Сложность масштабирования отдельных компонентов
💬Затруднительное внедрение новых технологий
💬Риск "снежного кома" при росте сложности проекта

➡️Микросервисная архитектура

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

➕Преимущества:
💬Гибкость в выборе технологий для каждого сервиса
💬Легкость масштабирования отдельных компонентов
💬Возможность независимой разработки и развертывания сервисов

❌Недостатки:
💬Сложность в управлении и оркестрации множества сервисов
💬Повышенные требования к инфраструктуре
💬Потенциальные проблемы с производительностью из-за сетевых взаимодействий

🔎Что выбрать для вашего проекта?

Выбор архитектуры зависит от нескольких факторов:

➡️Выбирайте монолитную архитектуру, если:
💬У вас небольшой проект или стартап
💬Вам нужно быстро вывести продукт на рынок
💬У вас ограниченные ресурсы для разработки и поддержки

➡️Выбирайте микросервисную архитектуру, если:
💬У вас крупный проект с множеством функций
💬Вам нужна высокая масштабируемость и гибкость
💬У вас есть ресурсы для управления сложной инфраструктурой

➡️Заключение

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

🐍Pythoner

✈️Что такое итерируемый счетчик?
Итерируемый счетчик в Python - это объект, который можно использовать в цикле for и других итерационных контекстах. Он позволяет последовательно получать значения, обычно числовые, в заданном диапазоне или по определенному правилу.

➡️Реализация итерируемого счетчика
Давайте рассмотрим пример реализации простого итерируемого счетчика:

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

    def __iter__(self):
        return self

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

В этом примере:
💬init инициализирует счетчик начальным и конечным значениями.
💬iter возвращает сам объект, делая его итератором.
💬next определяет логику получения следующего значения.

➡️Использование итерируемого счетчика
Теперь мы можем использовать наш счетчик в цикле for:

counter = IterableCounter(1, 5)
for num in counter:
    print(num)

⬆️Этот код выведет числа от 1 до 5.

➡️Преимущества итерируемого счетчика

💬Гибкость: можно легко изменить логику генерации значений.
💬Экономия памяти: значения генерируются по мере необходимости.
💬Интеграция с циклами: легко использовать в стандартных конструкциях Python.

➡️Альтернативы

В Python есть встроенные альтернативы для простых случаев:
💬range(): для последовательностей целых чисел.
💬enumerate(): для нумерации элементов итерируемого объекта.

💡Заключение

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

🐍Pythoner

✈️Тернарный оператор — это оператор, позволяющий записать условную конструкцию if-else в одну строку.

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

➡️Простой пример:

a = 3
b = 10

print('a больше b') if a > b else print('a меньше b')

result = 'Четное' if a % 2 == 0 else 'Нечетное'
print(result)

# Результат:
# a меньше b
# Нечетное 

⬆️В данном примере тернарный оператор используется:
—Для вывода одной из двух фраз в зависимости от условия a > b.
—Для присваивания переменной result одного из двух значений в зависимости от четности a.

🐍Pythoner

✈️Анализ текста с помощью spaCy

➡️Токенизация и лемматизация
SpaCy предоставляет эффективные инструменты для разбиения текста на токены и определения их базовых форм:

import spacy

nlp = spacy.load("ru_core_news_sm")
doc = nlp("Кошки любят спать на мягких подушках.")

for token in doc:
    print(f"{token.text} -> {token.lemma_}")

➡️Определение частей речи
SpaCy автоматически определяет части речи для каждого токена:

for token in doc:
    print(f"{token.text} - {token.pos_}")

➡️Распознавание именованных сущностей
Библиотека способна выделять в тексте именованные сущности, такие как имена, организации и локации:

for ent in doc.ents:
    print(f"{ent.text} - {ent.label_}")

➡️Генерация текста с использованием spaCy
Хотя spaCy в первую очередь предназначен для анализа текста, его можно использовать и для помощи в генерации:

➡️Использование зависимостей для построения предложений
SpaCy определяет синтаксические зависимости между словами, что может быть использовано для создания новых предложений:

def generate_sentence(subject, verb, object):
    doc = nlp(f"{subject} {verb} {object}")
    return " ".join([token.text for token in doc])

print(generate_sentence("Программист", "пишет", "код"))

➡️Использование векторных представлений слов
Векторные представления слов в spaCy могут быть использованы для поиска семантически близких слов:

def find_similar_word(word, n=3):
    token = nlp(word)[0]
    similar_words = []
    for lex in nlp.vocab:
        if lex.has_vector:
            if lex.is_lower == token.is_lower and lex.is_alpha:
                similarity = token.similarity(lex)
                similar_words.append((lex.text, similarity))
    return sorted(similar_words, key=lambda x: x[1], reverse=True)[:n]

print(find_similar_word("компьютер"))

🐍Pythoner

✈️Проблема традиционного подхода
Многие статьи рекомендуют создавать полноценный React SPA и использовать Django только как REST API. Однако такой подход имеет ряд недостатков, особенно для небольших проектов:
💬Дублирование кода (маршрутизация, аутентификация, авторизация)
💬Необходимость создания отдельных страниц ошибок
💬Дублирование состояний и моделей данных

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

➡️Альтернативное решение: React как шаблонизатор

Идея заключается в том, чтобы использовать React не как полноценный фронтенд-фреймворк, а как шаблонизатор для Django. Это позволит нам сохранить преимущества обоих инструментов.

➡️Точки монтирования React
React имеет удобное свойство: он монтируется не просто в body DOM или случайное место, а именно в указанный вами элемент. Мы можем использовать это для реализации маршрутизации, используя одну точку монтирования для каждой страницы:

ReactDOM.render(
  <h1>Страница 1!</h1>,
  document.getElementById('page-1')
);

ReactDOM.render(
  <h1>Страница 2!</h1>,
  document.getElementById('page-2')
);

➡️Маршрутизация на стороне Django
На стороне Django нам нужно только отрендерить <div> с соответствующим идентификатором:

{% extends "base.html" %}
{% load static %}

{% block content %}
  <div id="{{ element_id }}"></div>
  <script src="{% static 'index.js' %}"></script>
{% endblock %}

➡️Оптимизация размера пакета
Чтобы не загружать JavaScript для неиспользуемых страниц, мы можем использовать встроенную функцию React - Code Splitting:

let Page1 = React.lazy(() => import('./page1'))
let Page2 = React.lazy(() => import('./page2'))

ReactDOM.render(
  <Suspense fallback={<></>}>
    <Page1/>
  </Suspense>,
  document.getElementById('page-1')
);

➡️Передача контекстных данных
Для передачи данных из Django в React мы можем использовать встроенный в Django тег json_script:

{% extends "base.html" %}
{% load static %}

{% block content %}
  <div id="{{ element_id }}"></div>
  {{ page_context | json_script:'page-context' }}
  <script src="{% static 'index.js' %}"></script>
{% endblock %}

➡️На стороне React мы можем получить эти данные с помощью пользовательского хука:

export let usePageContext = <T = any>() => {
  let [pageContext, setPageContext] = useState<T | undefined>(undefined)
  useEffect(() => {
    let pageContext = document.getElementById('page-context').textContent
    setPageContext(JSON.parse(pageContext))
  }, [])
  return pageContext as T
}

const TodosIndexPage = memo(() => {
  let pageContext = usePageContext<{ todos: Todo[] }>()
  let todos = pageContext?.todos
  return <>
    <h1>React todos page</h1>
    <ul>
      {todos?.map(todo => <li key={todo.id}>{todo.title}</li>)}
    </ul>
  </>
})

💡Заключение
Этот подход позволяет использовать React как шаблонизатор для Django, сохраняя при этом простоту разработки и избегая дублирования кода. Основные шаги для реализации:
💬Создание отдельных точек монтирования для React
💬Настройка разделения кода для оптимизации производительности
💬Реализация маршрутизации на стороне Django
💬Передача контекста страницы из Django в React
💬Получение и использование контекста страницы на стороне React

🐍Pythoner

✈️Сегодня мы нырнем в глубины 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