PytStart | Программирование на Python

🔥 Понимай asyncio как мидл — без магии и мифов Многие пишут async/await, не понимая, что происходит. В итоге код медленный, дебаг невозможен, а блокировки всё равно есть. Вот как работает asyncio — без магии: 📌 1. Event Loop — это «планировщик», который гоняет корутины. Он сам не создаёт потоки. Он ждёт, когда одна задача «освободит» CPU, и сразу берётся за другую.

    
        import asyncio

async def main():
    print("Start")
    await asyncio.sleep(1)
    print("End")

asyncio.run(main()){}
    

Здесь await asyncio.sleep(1) — не блокирует поток. Это *yield*, который говорит: "я пока жду, можешь заняться чем-то ещё". 📌 2. Ты не должен использовать time.sleep() в async-коде. Это блокирует весь event loop. Заменяй на await asyncio.sleep(). 📌 3. Любая синхронная тяжёлая операция — угроза. Например, чтение файла или SQL-запрос через обычный драйвер. ✔️ Как решить: 👍 Используй aiofiles для файлов. 👍 Используй async-драйверы (asyncpg, aiomysql, httpx и т.д.) 👍 Если нет async-аналога — выноси в ThreadPoolExecutor.

    
        from concurrent.futures import ThreadPoolExecutor
import asyncio

def blocking():
    ...

async def main():
    loop = asyncio.get_running_loop()
    await loop.run_in_executor(None, blocking){}
    

📌 4. Не забывай про семафоры, если запускаешь 1000 задач одновременно. async не значит всё сразу.

    
        sem = asyncio.Semaphore(100)

async def safe_task():
    async with sem:
        await do_something(){}
    

🧠 asyncio — это не про параллельность. Это про эффективное переключение задач, которые ждут чего-то: ответа сервера, данных, паузы. 🗣 Применяется в: Web-серверах (FastAPI, aiohttp), парсинге, бэкенде с I/O, высоконагруженных API.

👩‍💻 Библиотеки для ленивых: когда хочется больше делать с меньшими усилиями Каждый программист знает: кодить можно быстрее, если использовать проверенные решения. В Python куча библиотек, которые делают работу за тебя — не нужно изобретать велосипед. 1. `pathlib` — путь к лёгкости работы с путями Ты всё ещё юзаешь os.path? Пора остановиться. pathlib — это объектно-ориентированная альтернатива, которая позволяет работать с путями проще и чище. Пример:

    
        from pathlib import Path

p = Path("/home/user/docs")
print(p / "file.txt")  # /home/user/docs/file.txt{}
    

👉 Это значительно читаемее и проще, чем старые подходы с os.path. 2. `requests` — HTTP без головной боли HTTP-запросы — одна из самых часто используемых операций, но с ними можно запутаться. requests делает этот процесс понятным и удобным. Пример:

    
        import requests

response = requests.get('https://api.example.com/data')
print(response.json()){}
    

👉 Всё! Нет лишнего кода, никаких ненужных сложностей. 3. `pydantic` — валидация данных с минимальными усилиями Если тебе нужно проверять данные, а писать вручную кучу кода — не хочется, используй pydantic. Эта библиотека позволяет быстро проверять и валидировать данные, обрабатывая JSON, параметры и модели. Пример:

    
        from pydantic import BaseModel

class User(BaseModel):
    name: str
    age: int

user = User(name="Alice", age=30)
print(user){}
    

👉 Валидация без лишних усилий и работы с типами. Всё автоматически. 4. `attrs` — создание классов без ненужного кода Если ты создаёшь классы, но не хочешь писать лишние методы вроде __init__, __repr__, __eq__, то тебе в помощь attrs. Эта библиотека позволяет легко создавать классы с автоматическим заполнением всех необходимых методов. Пример:

    
        import attr

@attr.s
class Point:
    x = attr.ib()
    y = attr.ib()

p = Point(3, 4)
print(p)  # Point(x=3, y=4){}
    

👉 Быстро, удобно, без лишних усилий. 5. `click` — консольные приложения без мук Создание CLI-интерфейсов может быть утомительным, но с click это делается быстро и без боли. Ты можешь создавать простые и мощные консольные команды с минимальными усилиями. Пример:

    
        import click

@click.command()
@click.argument('name')
def greet(name):
    click.echo(f"Hello, {name}!")

greet(){}
    

👉 Лёгкая настройка, удобная обработка аргументов и флагов. 🗣️ Запомни: используй библиотеки, чтобы минимизировать шаблонный код, повысить читаемость и улучшить производительность разработки.

В России можно посещать IT-мероприятия хоть каждый день: как оффлайн, так и онлайн Но где их находить? Как узнавать о них раньше, чем когда все начнут выкладывать фотографии оттуда? Переходите на канал IT-Мероприятия России. В нём каждый день анонсируются мероприятия со всех городов России 📆 в канале размещаются как онлайн, так и оффлайн мероприятия; 👩‍💻 можно найти ивенты по любому стеку: программирование, frontend-backend разработка, кибербезопасность, дата-аналитика, osint, devops и другие; 🎙 разнообразные форматы мероприятий: митапы с коллегами по цеху, конференции и вебинары с известными опытными специалистами, форумы и олимпиады от важных представителей индустрии и многое другое А чтобы не искать по разным форумам и чатам новости о предстоящих ивентах: 🚀 IT-мероприятия России — подписывайся и будь в курсе всех предстоящих мероприятий!

🖥 Как сделать список уникальным (без повторяющихся элементов) Вариант со множеством. Не гарантирует порядок элементов. Порядок сохраняется только для маленьких списков.

    
        
list(set([1, 2, 2, 2, 3, 3, 1]))
>>> [1, 2, 3]{}
    

Вариант с OrderedDict. Гарантирует порядок элементов.

    
        
>>> from collections import OrderedDict
>>> list(OrderedDict.fromkeys([1, 2, 2, 2, 3, 3, 1]))
>>> [1, 2, 3]{}
    

Вариант с циклом. Медленно, но гарантирует порядок. Подходит, если элементы нельзя помещать внутрь множества (например, словари).

    
        
res = []
for x in [1, 2, 2, 2, 3, 3, 1]:
    if x not in res:
        res.append(x)
>>> [1, 2, 3]{}
    

🖥 Что такое множество? Множество – это неупорядоченная коллекция хешируемых объектов, которые не повторяются. В множествах нет понятия позиции элемента. Соответственно, они не поддерживают индексацию и срезы. Встроенные классы множеств: set (изменяемое множество), frozenset (неизменяемое множество). Множества обычно используются для проверки элемента на вхождение в множество и удаление повторений элементов и выполнения таких операций, как объединение, пересечение, разница и симметрическая разница.

🖥 Что такое диапазон? Диапазоны – неизменяемые последовательности чисел, которые задаются началом, концом и шагом. Представлены классом range (в Python 2 – xrange; range в Python 2 – это функция, которая возвращает список). Параметры конструктора должны быть целыми числами (либо экземпляры класса int, либо любой объект с методом __index__) Поддерживает все общие для последовательностей операции, кроме конкатенации и повторения, а также, в версиях Python до 3.2, срезов и отрицательных индексов.

👩‍💻 Хак: f-строки с выражениями в форматировании Да, ты можешь использовать выражения прямо внутри f-строк!

    
        value = 3.14159
print(f"Округлено: {value:.2f}")      # Округлит до 2 знаков
print(f"В квадрате: {value**2:.1f}")  # Сразу вычисляет и форматирует{}
    

🧠 А можно и условие:

    
        name = None
print(f"Привет, {name or 'гость'}!"){}
    

🗣 При генерации отчётов, логов, CLI-вывода, шаблонов — везде, где важна читаемость и компактность.

🖥 Чем список отличается от кортежа? Списки – это изменяемые последовательности, обычно используемые для хранения однотипных данных (хотя Python не запрещает хранить в них данные разных типов). Представлены классом list. Кортежи – это неизменяемые последовательности, обычно используемые, чтобы хранить разнотипные данные. Представлены классом tuple. На уровне языка отличаются тем, что в кортеж нельзя добавить или убрать элемент. На уровне интерпретатора различий нет. Обе коллекции представлены массивом указателей на структуру PyObject. Существуют специальные функции для работы со списками. Они вызываются методами списка. Ниже приведены наиболее часто используемые:

    
        
# Создаем исходный список
lst = [1, 2, 3]

# append(x): добавляет элемент в конец списка
lst.append(4)
# Теперь lst = [1, 2, 3, 4]

# extend(iterable): расширяет список, добавляя элементы из итерируемого объекта
lst.extend([5, 6])
# Теперь lst = [1, 2, 3, 4, 5, 6]

# insert(i, x): вставляет элемент x на позицию i
lst.insert(0, 'start')
# Теперь lst = ['start', 1, 2, 3, 4, 5, 6]

# remove(x): удаляет первое вхождение элемента x
lst.remove(3)
# Теперь lst = ['start', 1, 2, 4, 5, 6]

# pop([i]): удаляет и возвращает элемент на позиции i (по умолчанию последний)
last = lst.pop()
# last = 6, а lst = ['start', 1, 2, 4, 5]

# sort(): сортирует список на месте
lst = [3, 1, 4, 1, 5, 9, 2]
lst.sort()
# Теперь lst = [1, 1, 2, 3, 4, 5, 9]

# reverse(): разворачивает список на месте
lst.reverse()
# Теперь lst = [9, 5, 4, 3, 2, 1, 1]{}
    

Суровый Энтерпрайз - канал действующего java-тимлида одной банковской команды. Канал показывает всю внутреннюю кухню разработки в настоящем банковском энтерпрайзе без прикрас. Также множество лайфхаков разработки, построения архитектуры и управления командой. Подписаться

🖥 Последовательности Последовательностью в Python называется итерабельный объект, который поддерживает эффективный доступ к элементам с использованием целочисленных индексов через специальный метод __getitem__() и поддерживает метод __len__(), который возвращает длину последовательности. К основным встроенным типам последовательностей относятся list, tuple, range, str и bytes. Последовательности также опционально могут реализовывать методы count(), index(), __contains__(), __reversed__() и другие. ➡️ Операции поддерживаемые большинством последовательностей:

    
        
x in s, x not in s # находится ли элемент x в последовательности s (для строк и последовательностей байтов – является ли x подстрокой s)

s + t # конкатенация последовательностей s и t

s * n, n * s # конкатенация n нерекурсивных копий последовательности s

s[i] # i-й элемент последовательности s

s[:i] # срез всех элементов последовательности s до i (не включая i)

s[i:] # срез всех элементов последовательности s от i до последнего элемента

s[-i:] # срез последних i элементов последовательности s

s[::-1] # перевернуть последовательность

s[i:j] # срез последовательности s от i до j (не включая j)

s[i:j:k] # срез последовательности s от i до j с шагом k (не включая j)

len(s) # длина последовательности s

min(s) # минимальный элемент последовательности s

max(s) # максимальный элемент последовательности s

s.index(x[, i[, j]]) # индекс первого вхождения x (опционально – начиная с позиции i и до позиции j)

s.count(x) # общее количество вхождений x в s

sum(s) # сумма элементов последовательности{}
    

Неизменяемые последовательности обычно реализуют операцию hash(s) – хеш-значение объекта. ➡️ Большинство изменяемых последовательностей поддерживают следующие операции:

    
        
s[i] = x # элемент с индексом i заменяется на x

s[i:j] = t, s[i:j:k] = t # элементы с индексами от i до j (с шагом k) заменяются содержимым итерабельного объекта t

del s[i:j], del s[i:j:k] # удаление соответствующих элементов из последовательности

s.append(x) # добавление x в конец последовательности

s.clear() # удаление всех элементов последовательности

s.copy() # нерекурсивная копия последовательности

s.extend(t) # добавление всех элементов итерабельного объекта в конец последовательности

s.insert(i, x) # вставка элемента x по индексу i

s.pop(), s.pop(i) # возврат значения по индексу i (по умолчанию – последний элемент) и удаление его из последовательности

s.remove(x) # удаление первого вхождения x

s.reverse() # разворот последовательности в обратном порядке{}