🖥 Забудьте про os.path

Если вы всё еще склеиваете пути к файлам через строки или os.path.join, пора переходить на pathlib. Это встроенная библиотека, которая превращает пути в удобные объекты.

➡️ Киллер-фича:
Пути можно соединять через оператор деления /! Это выглядит очень чисто и интуитивно.

📌 Пример:
Создадим путь к файлу data/report.txt в текущей директории.

from pathlib import Path

# Получаем текущую папку
current_dir = Path.cwd()

# Магия слешей! Никаких запятых и скобок
file_path = current_dir / "data" / "report.txt"

# Проверяем, существует ли файл
if file_path.exists():
    # Читаем текст сразу методом объекта
    print(file_path.read_text())
else:
    print("Файл не найден")

💡 Это работает кроссплатформенно (и на Windows, и на Linux слэши будут правильными). Код становится объектно-ориентированным и читаемым.

🖥 Проверка условий одной строкой

Как проверить, что все элементы в списке положительные? Писать цикл? Нет!

Используйте встроенные функции all() и any().

numbers = [1, 5, 10, 20]

# all вернет True, только если ВСЕ условия верны
if all(n > 0 for n in numbers):
    print("Все числа положительные!")

# any вернет True, если ХОТЯ БЫ ОДНО условие верно
if any(n > 15 for n in numbers):
    print("Есть число больше 15!")

Это читается почти как обычный английский текст. Пишите выразительно! ✍️

👩‍💻 Python + Redis Streams: real-time пайплайны, которые работают сразу

Real-time — это не обязательно Kafka, ZooKeeper и зоопарк сервисов.
Redis Streams даёт очередь, автодоставку и группировку воркеров в одном бинарнике.Python делает остальное. Ниже — рабочая схема, которая живёт в проде годами.👇

⚙️ 1. Создаём поток событий

import redis
r = redis.Redis()

r.xadd("events:log", {
    "level": "info",
    "msg": "service started"
})

➡️ Redis сам присваивает ID и держит упорядоченность.
С этого момента у тебя есть real-time поток.

🚀 2. Читаем только новые записи

events = r.xread({"events:log": "$"}, block=0)

for stream, items in events:
    for event_id, data in items:
        print(event_id, data)

➡️ $ = читать только новые сообщения.
Идеально для live-обработчиков: телеметрия, алертинг, IoT.

👥 3. Consumer group (несколько воркеров — одна очередь)

try:
    r.xgroup_create("events:log", "log_workers", "$")
except:
    pass

events = r.xreadgroup(
    "log_workers", "worker-1",
    {"events:log": ">"},
    block=5000
)

➡️ > — бери только необработанные записи для группы.
Каждое сообщение попадёт ровно одному воркеру.

📌 4. Подтверждаем обработку

for event_id, data in events[0][1]:
    handle(data)
    r.xack("events:log", "log_workers", event_id)

➡️ Без XACK Redis будет думать, что воркер завис.
ACK — обязательный шаг любого real-time пайплайна.

🧹 5. Держим только последние N событий

r.xadd("events:log",
       {"msg": "slow request"},
       maxlen=1000)

➡️ Redis сам обрежет стрим до последних 1000 записей.
Идеально для журналов и сенсорных потоков.

🔄 6. Полный рабочий пайплайн (минимальная схема)

producer.py

r.xadd("sensor:data", {
    "temp": "22.1",
    "humidity": "44"
})

worker.py

while True:
    events = r.xreadgroup(
        "sensors", "worker-3",
        {"sensor:data": ">"},
        block=3000
    )

    if not events:
        continue

    for event_id, data in events[0][1]:
        store(data)      # запись в БД
        r.xack("sensor:data", "sensors", event_id)

➡️ Получилось: «сенсор → Redis → воркеры → база».
Работает быстро, стабильно и без лишних сервисов.

🧰 7. Backpressure и контроль скорости

length = r.xlen("sensor:data")
if length > 50000:
    throttle()  # временно уменьшаем частоту отправки

➡️ XLEN помогает вовремя ловить переполнения пайплайна.

🛰 8. Репликация для отказоустойчивости

Redis Streams прекрасно работает на Redis-кластерe:

replica-of host port

➡️ При падении ноды поток не теряется — сообщения успевают попасть на реплику.

📈 9. Мониторинг live-нагрузки

redis-cli xinfo stream sensor:data
redis-cli xinfo groups sensor:data
redis-cli xinfo consumers sensor:data group

➡️ Видишь задержку, размер лагов, состояние воркеров, pending list.
Без этого real-time не существует.

🗣 Запомни: Redis Streams — лучший способ собрать real-time пайплайн, когда Kafka — это слишком, а Python — идеальный клей между сенсорами, сервисами и обработчиками данных

👀 Числа, от которых не рябит в глазах

Сколько здесь нулей: 1000000000? Миллиард? Сто миллионов? Приходится считать пальцем по экрану.

Python позволяет использовать знак подчеркивания _ прямо внутри чисел для разделения разрядов. Интерпретатор просто игнорирует эти знаки.

➡️Пример:

# Обычная запись
salary = 5000000 

# Читаемая запись
salary = 5_000_000  # Сразу видно — 5 миллионов

# Работает и с float, и в hex
pi = 3.141_592_653
color = 0xFF_FF_FF

💡 На логику программы это никак не влияет, но читать такой код (и конфиги) в разы приятнее.

🖥 Самый простой способ слить два словаря

Раньше, чтобы объединить два словаря, мы использовали метод .update() (который меняет исходный словарь) или сложную распаковку {**dict1, **dict2}.

Начиная с Python 3.9, появился красивый оператор слияния | (pipe).

📌 Как это работает:

settings_default = {"theme": "light", "notifications": True}
user_settings = {"theme": "dark"}

# Объединяем! Значения из второго словаря перезапишут первые
config = settings_default | user_settings

print(config)
# {'theme': 'dark', 'notifications': True}

💡 Это создает новый словарь, не ломая старые. Просто, понятно и очень похоже на математическое объединение множеств.

🖥 Python-фишка: Красивые сравнения без лишних and

В большинстве языков (C++, Java, JS), чтобы проверить, находится ли число в диапазоне, нужно писать два условия. В Python всё гораздо изящнее.

❌ Как пишут обычно:

age = 25
if age > 18 and age < 60:
    print("Трудоспособный возраст")

✅ Как можно в Python:

age = 25
# Прямо как в математике!
if 18 < age < 60:
    print("Трудоспособный возраст")

Это работает с любым количеством операторов:

x = 5
y = 10
z = 15

if x < y < z:
    print("Порядок возрастания соблюден!")

💡 Код читается быстрее, а вероятность опечататься (забыть and) — меньше.

🖥 Python-фишка: Проходим по двум спискам одновременно

Допустим, у вас есть список имен и список зарплат. Вам нужно вывести их парами. Не нужно использовать индексы!

В Python есть встроенная функция zip(), которая "сшивает" списки как молнию на куртке.

📌 Пример:

names = ["Alice", "Bob", "Charlie"]
salaries = [50000, 60000, 70000]

# name берется из names, salary из salaries
for name, salary in zip(names, salaries):
    print(f"{name} зарабатывает {salary}")

💡 Бонус-трюк:
С помощью zip можно мгновенно создать словарь из двух списков:

data_dict = dict(zip(names, salaries))
# {'Alice': 50000, 'Bob': 60000, ...}

Минимум кода — максимум пользы.

🖥 Как посчитать элементы "за 1 секунду"

Вам нужно узнать, сколько раз каждый символ встречается в строке или сколько раз слово встречается в списке? Не пишите циклы и словари вручную!

В модуле collections есть идеальный инструмент — Counter.

📌 Пример:

from collections import Counter

text = "abracadabra"
stats = Counter(text)

print(stats)
# Counter({'a': 5, 'b': 2, 'r': 2, 'c': 1, 'd': 1})

Он работает как словарь, но умеет больше. Например, метод .most_common() сразу покажет топ элементов:

# Вывести 2 самых частых символа
print(stats.most_common(2)) 
# [('a', 5), ('b', 2)]

🗣️ Идеально для аналитики текстов, логов и простой статистики.

🖥 Моржовый оператор :=

Странное название, но очень полезная суть. Оператор := (он похож на глаза и клыки моржа) позволяет присвоить значение переменной прямо внутри выражения (например, внутри if или while).

Задача:
Получить данные от функции (или пользователя) и проверить, не пустые ли они.

❌ Без моржа (3 строки):

text = input("Введите слово: ")
if len(text) > 5:
    print(f"Длинное слово: {text}")

✅ С моржом (2 строки):

# Мы и присваиваем text, и сразу проверяем его длину
if len(text := input("Введите слово: ")) > 5:
    print(f"Длинное слово: {text}")

Переменная text останется доступной и внутри блока if, и после него. Это отлично экономит место и делает код компактнее.

💻 Асинхронный код без блокировок

Как запускать десятки сетевых запросов одновременно, не тормозя программу? Писать многопоточный код? ❌ Нет!

Используйте async и await с библиотекой asyncio.

import asyncio

async def fetch_data(n):
    print(f"Запрос {n} стартовал")
    await asyncio.sleep(1)  # имитация сетевого запроса
    print(f"Запрос {n} завершён")
    return n * 2

async def main():
    # запускаем все задачи одновременно
    results = await asyncio.gather(*(fetch_data(i) for i in range(5)))
    print("Результаты:", results)

asyncio.run(main())

✅ Что важно:

👍asyncio.gather запускает все задачи параллельно

👍Программа ждёт только по факту завершения задач

👍Код остаётся читаемым и безопасным

😀 Это читается почти как обычный английский текст. Пишите эффективный и современный Python! ✍️

📊Векторизация с NumPy: быстрый и чистый код

Как выполнять математические операции над большими массивами без циклов Python? Писать for и append? ❌ Нет!

Используйте векторизацию NumPy.

import numpy as np

# создаём массив чисел
a = np.arange(1, 6)
b = np.arange(10, 15)

# сложение массивов поэлементно
c = a + b
print("Сумма массивов:", c)

# умножение каждого элемента на 2
d = a * 2
print("Умножение на 2:", d)

✅ Что важно:

👍Все операции выполняются в памяти, быстро и эффективно

👍Не нужны циклы Python — код остаётся чистым и читаемым

👍Подходит для машинного обучения, статистики и научных вычислений

💡 Это читается почти как обычный английский текст. Пишите быстрый и современный Python с NumPy! ✍️

📈 Pandas: группировка и агрегация данных

Как быстро подсчитать суммы, средние и максимум по категориям без цикла? Писать for и if? ❌ Нет!

Используйте groupby и агрегации.

import pandas as pd

# создаём DataFrame
data = pd.DataFrame({
    "Компания": ["A", "B", "A", "B", "C"],
    "Доход": [100, 200, 150, 120, 300],
    "Расход": [50, 80, 60, 70, 150]
})

# группируем по компании и считаем суммарный доход и средний расход
summary = data.groupby("Компания").agg({
    "Доход": "sum",
    "Расход": "mean"
})

print(summary)

✅ Что важно:

👍groupby позволяет группировать данные по ключу

👍agg выполняет несколько операций сразу

👍Код остаётся коротким, читаемым и эффективным

💡 Это читается почти как обычный английский текст. Пишите чистый и быстрый Python для аналитики данных! ✍️

💻 SciPy: оптимизация и решение сложных задач

Как найти минимум функции или решить систему нелинейных уравнений, не переписывая всё вручную? Писать цикл и градиенты самому? ❌ Нет!

Используйте scipy.optimize.

from scipy.optimize import minimize, fsolve
import numpy as np

# --- Минимизация функции ---
# функция с минимумом
def func(x):
    return (x - 3)**2 + np.sin(x)*5

# ищем минимум
res = minimize(func, x0=0)  # x0 - начальное приближение
print("Минимум функции:", res.x, "Значение:", res.fun)

# --- Решение системы нелинейных уравнений ---
# система: x^2 + y^2 = 1, x - y = 0.5
def system(vars):
    x, y = vars
    return [x**2 + y**2 - 1, x - y - 0.5]

solution = fsolve(system, [0, 0])  # начальное приближение [x0, y0]
print("Решение системы:", solution)

✅ Что важно:

👍minimize ищет минимум любой функции, можно задавать ограничения и методы

👍fsolve решает системы нелинейных уравнений с произвольной сложностью

👍Все операции быстро работают, не нужно вручную считать градиенты и итерации

💡 Это читается почти как обычный английский текст. Пишите научные и инженерные вычисления на Python профессионально! ✍️

🚀 Магия NumPy: маски и broadcasting

Как выбирать, изменять и считать элементы массивов без циклов, с полной гибкостью? Писать for и if? ❌ Нет!

Используйте булевы маски и broadcasting.

import numpy as np

# создаём массив случайных чисел
data = np.random.randint(0, 100, size=(5, 5))
print("Массив:\n", data)

# выбираем все элементы >50
mask = data > 50
print("Элементы >50:\n", data[mask])

# умножаем все >50 на 2 (broadcasting)
data[mask] *= 2
print("После умножения >50 на 2:\n", data)

# fancy indexing: выбираем 1, 3 и 4 строки, 0 и 2 столбцы
subset = data[[1,3,4], :][:, [0,2]]
print("Подмассив (fancy indexing):\n", subset)

✅ Что важно:

👍Булевы маски позволяют выбирать элементы по условию

👍Broadcasting даёт возможность применять операции ко всему массиву без циклов

👍Fancy indexing создаёт новые массивы быстро и выразительно

💡 Это читается почти как обычный английский текст. Пишите эффективный Python для больших данных и ML! ✍️

🖥 Магия множеств (Sets)

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

Используйте множества (set). Они поддерживают математические операции "из коробки".

Пример:
Есть два списка разработчиков:

frontend = {"Anna", "Bob", "Alice"}
backend = {"Bob", "John", "Alice"}

Что можно сделать одной строкой:

1️⃣ Кто фуллстек? (пересечение &)

print(frontend & backend)
# {'Alice', 'Bob'}

2️⃣ Кто только фронтендер? (разность -)

print(frontend - backend)
# {'Anna'}

3️⃣ Кто работает только на одной стороне? (симметрическая разность ^)

print(frontend ^ backend)
# {'Anna', 'John'}

Это работает очень быстро (почти мгновенно) даже на больших объемах данных.

🖥 Python-фишка: Игнорируем ошибки элегантно

Вам наверняка приходилось писать код, где ошибку нужно просто проигнорировать.
Например, удалить файл, если он есть (а если нет — ну и ладно).

❌ Обычно это выглядит так:

import os

try:
    os.remove("temp.txt")
except FileNotFoundError:
    pass  # Выглядит не очень красиво

✅ Pythonic way:
Используйте контекстный менеджер suppress из модуля contextlib.

import os
from contextlib import suppress

with suppress(FileNotFoundError):
    os.remove("temp.txt")

Это делает намерение программиста очевидным: "Попробуй выполнить, но если вылетит эта ошибка — подави её". Код становится чище и читаемее.

#python #cleancode #refactoring #tips

🖥 Python-фишка: Переворачиваем словарь одной строкой

Допустим, у вас есть словарь, и нужно поменять местами ключи и значения (инвертировать его).

Исходные данные:

currencies = {'USD': 1, 'EUR': 0.9, 'GBP': 0.8}

Вместо того чтобы создавать пустой словарь и запускать цикл, используйте Dict Comprehension:

# {значение: ключ}
inverted = {value: key for key, value in currencies.items()}

print(inverted)
# {1: 'USD', 0.9: 'EUR', 0.8: 'GBP'}

Синтаксис {k: v for ...} работает так же мощно, как и для списков. Можно даже добавить условия:

# Оставим только валюты с курсом меньше 1
cheap = {k: v for k, v in currencies.items() if v < 1}

🖥 Ускорение кода в 100 раз одной строкой

Если у вас есть функция, которая выполняет тяжелые вычисления (или рекурсию) с одними и теми же аргументами, вы можете мгновенно её ускорить.

Импортируем декоратор `@lru_cache` из модуля functools.

Пример (классический Фибоначчи):

from functools import lru_cache

@lru_cache(maxsize=None)  # <--- Вся магия здесь
def fib(n):
    if n < 2:
        return n
    return fib(n-1) + fib(n-2)

print(fib(50))

Без кэша: Python будет считать это вечность (миллиарды вызовов).
С кэшем: Результат выведется мгновенно.

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

#python #performance #optimization #functools

🖥 Именованные кортежи

Обычные кортежи (`tuple`) экономят память, но обращаться к данным по индексу — неудобно.
point[0] — что это? Координата X? Широта? ID пользователя?

Используйте `NamedTuple` из модуля typing (или `collections`). Это как класс, только легче.

from typing import NamedTuple

class Point(NamedTuple):
    x: int
    y: int

p = Point(10, 20)

# Теперь можно обращаться по имени!
print(p.x, p.y)  # 10 20

# Но поведение кортежа сохраняется
print(p[0])      # 10

Это делает код "самодокументируемым". Идеально для возврата нескольких значений из функции.

#python #typing #structures #tips

🤯 Математика с булевыми значениями

А вы знали, что в Python True и False — это на самом деле просто замаскированные 1 и 0? Тип bool наследуется от int.

Поэтому такой код абсолютно валиден:

x = True + True + 5
print(x) 
# Вывод: 7 (1 + 1 + 5)

Или даже так (используем как индекс):

options = ["Нет", "Да"]
is_agreed = True

print(options[is_agreed]) 
# Вывод: "Да" (потому что options[1])

💡 Примечание: в продакшене лучше так не писать, но знать об этом полезно!

#python #funfacts #underTheHood

👩‍💻 Работа с внешними API на Python: библиотека requests

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

👉 Ссылка на первоисточник

🗣️Запомни: умение работать с API - это ключ к интеграции ваших программ с миром внешних данных и сервисов, от погоды до нейросетей.

🤩 Pytstart || #Видеокурс