Pythoner
7.23K subscribers
860 photos
27 videos
4 files
654 links
Полезные материалы по Python, которые будут интересны опытному и начинающему разработчику.

Сотрудничество - @flattys
Цены - @serpent_media

Канал на бирже: https://telega.in/c/pythonercode
Download Telegram
✈️ В Python FastAPI — это современный, высокопроизводительный веб-фреймворк для создания API. Он основан на стандартах OpenAPI и JSON Schema, что обеспечивает автоматическую генерацию интерактивной документации и валидацию данных. FastAPI использует асинхронный подход (ASGI), что делает его одним из самых быстрых Python фреймворков.

➡️ Применение FastAPI идеально подходит для разработки API, микросервисов, backend-систем и других веб-приложений, где требуется высокая производительность, простота разработки и надежная валидация данных. Автоматическая генерация документации существенно упрощает взаимодействие с API.

➡️ Вот пример простого приложения FastAPI:

from fastapi import FastAPI, Query, Path, HTTPException
from pydantic import BaseModel
from typing import List, Optional

app = FastAPI(title="My Awesome API", version="1.0.0", description="Example FastAPI application")


class Item(BaseModel):
name: str
description: Optional[str] = None
price: float
tax: Optional[float] = None


@app.get("/") # GET-запрос на корневой путь
async def root():
return {"message": "Hello World"}


@app.get("/items/{item_id}") # GET-запрос с параметром пути
async def read_item(item_id: int = Path(..., title="The ID of the item to get", ge=1)): # Валидация параметра пути
return {"item_id": item_id}


@app.get("/items/")
async def read_items(q: Optional[str] = Query(None, min_length=3, max_length=50)): # Валидация query-параметра
results = {"items": [{"item_id": "foo"}, {"item_id": "bar"}]}
if q:
results.update({"q": q})
return results



@app.post("/items/", response_model=Item) # POST-запрос с валидацией тела запроса
async def create_item(item: Item):
return item


@app.put("/items/{item_id}")
async def update_item(item_id: int, item: Item):
return {"item_id": item_id, **item.dict()}


@app.get("/users/{user_id}")
async def get_user(user_id: int):
# Пример обработки ошибок
if user_id == 404:
raise HTTPException(status_code=404, detail="User not found")
return {"user_id": user_id}


# Запуск приложения
uvicorn main:app --reload


⬆️ В этом примере демонстрируется создание приложения FastAPI, определение GET и POST маршрутов, использование параметров пути и запроса с валидацией, работа с Pydantic моделями для валидации тела запроса и обработка ошибок с помощью HTTPException. Для запуска приложения используйте команду uvicorn main:app --reload, где main — имя файла, а app — имя экземпляра FastAPI. После запуска перейдите по адресу /docs в браузере, чтобы увидеть автоматически сгенерированную интерактивную документацию.

🐍 Pythoner
Please open Telegram to view this post
VIEW IN TELEGRAM
8👍4🔥3
✈️ В Python модуль `difflib` — это мощный инструмент для сравнения последовательностей, таких как строки, списки и другие итерируемые объекты. Он предоставляет классы и функции для вычисления различий между последовательностями, что позволяет эффективно находить и отображать изменения, например, в текстовых файлах или других данных.

➡️ Применение difflib разнообразно: от сравнения версий файлов и поиска плагиата до создания патчей и слияния изменений в системах контроля версий. Он также может быть полезен для анализа текстовых данных, например, для выявления изменений в документах или сравнения ответов пользователей.

➡️ Вот пример использования difflib для сравнения двух строк:
import difflib

text1 = """
This is the first line.
This is the second line.
This is the third line.
"""

text2 = """
This is the first line.
This is the modified second line.
This is the fourth line.
"""

diff = difflib.ndiff(text1.splitlines(), text2.splitlines())


print("\n".join(diff))

# Вывод:
# This is the first line.
# - This is the second line.
# + This is the modified second line.
# ? +++++++++
#
# - This is the third line.
# ? ---
#
# + This is the fourth line.
# ? ++++
# ^



# Более наглядное сравнение:

diff = difflib.unified_diff(text1.splitlines(), text2.splitlines(), fromfile='file1.txt', tofile='file2.txt')
print("\n".join(diff))



# Вывод:
# --- file1.txt
# +++ file2.txt
# @@ -1,4 +1,4 @@
#
# This is the first line.
# -This is the second line.
# +This is the modified second line.
# -This is the third line.
# +This is the fourth line.



# Сравнение HTML:
from difflib import HtmlDiff

html_diff = HtmlDiff()
table = html_diff.make_table(text1.splitlines(), text2.splitlines(), fromdesc='file1.txt', todesc='file2.txt')

with open('diff.html', 'w') as f:
f.write(table) # Сохранение результата в HTML файл

⬆️ В этом примере демонстрируется использование функций ndiff и unified_diff для сравнения двух строк построчно. ndiff показывает различия с помощью специальных символов: - для удаленных строк, + для добавленных и ? для изменений внутри строки. unified_diff предоставляет более компактный вывод, похожий на формат патчей. Также показан пример использования HtmlDiff для создания HTML-таблицы с различиями, что удобно для визуального сравнения.

🐍 Pythoner
Please open Telegram to view this post
VIEW IN TELEGRAM
6🔥5👍3
✈️ В Python модуль `concurrent.futures` предоставляет высокоуровневый интерфейс для асинхронного выполнения вызовов функций, используя пул потоков или процессов. Он упрощает распараллеливание задач и позволяет эффективно использовать многоядерные процессоры для ускорения выполнения программ.

➡️ Применение concurrent.futures особенно полезно при работе с I/O-bound задачами, такими как сетевые запросы, чтение/запись файлов, взаимодействие с базами данных. Он также может быть эффективен для CPU-bound задач, если они могут быть разделены на независимые подзадачи.

➡️ Вот пример использования concurrent.futures с ThreadPoolExecutor:
import concurrent.futures
import time
import requests

URLS = [
"https://www.example.com",
"https://www.google.com",
"https://www.python.org",
"https://www.wikipedia.org",
]

def load_url(url, timeout):
try:
response = requests.get(url, timeout=timeout)
return f"{url}: {len(response.content)} bytes"
except requests.exceptions.RequestException as e:
return f"{url}: Error: {e}"


start_time = time.time()

# Последовательное выполнение:
for url in URLS:
print(load_url(url, timeout=60))


end_time = time.time()
print(f"Последовательное выполнение заняло: {end_time - start_time} секунд")





start_time = time.time()

# Асинхронное выполнение с ThreadPoolExecutor:
with concurrent.futures.ThreadPoolExecutor(max_workers=4) as executor:
# map() возвращает результаты в порядке URLS
future_to_url = {executor.submit(load_url, url, 60): url for url in URLS}
for future in concurrent.futures.as_completed(future_to_url):
url = future_to_url[future]
try:
data = future.result()
except Exception as exc:
print(f"{url}: generated an exception: {exc}")
else:
print(data)

end_time = time.time()
print(f"Асинхронное выполнение заняло: {end_time - start_time} секунд")




⬆️ В этом примере демонстрируется загрузка содержимого нескольких URL-адресов сначала последовательно, а затем асинхронно с использованием ThreadPoolExecutor. Функция load_url загружает данные по указанному URL. ThreadPoolExecutor создает пул потоков, которые выполняют загрузку URL-адресов параллельно. as_completed позволяет обрабатывать результаты по мере их готовности, не дожидаясь завершения всех задач. Сравнение времени выполнения показывает преимущество асинхронного подхода, особенно при работе с сетевыми запросами.

🐍 Pythoner
Please open Telegram to view this post
VIEW IN TELEGRAM
👍85🔥2
✈️Сегодня поговорим о том, как создавать крутые CLI-приложения с помощью Click. Если вам надоело писать бесконечные if'ы для обработки аргументов командной строки, то этот пост определенно для вас!

➡️Начнем с того, почему вообще стоит использовать Click, а не встроенный argparse:
—Декораторный подход, который выглядит элегантно и интуитивно понятен
—Автоматическая генерация справки и сообщений об ошибках
—Вложенные команды из коробки
—Поддержка автодополнения в shell

➡️Давайте посмотрим на простой, но реальный пример. Представим, что мы делаем утилиту для работы с файлами:
import click

@click.group()
def cli():
"""Утилита для работы с файлами"""
pass

@cli.command()
@click.argument('path')
@click.option('--lines', '-l', is_flag=True, help='Показать количество строк')
def analyze(path, lines):
"""Анализирует файл и выводит статистику"""
try:
with open(path) as f:
content = f.readlines()
if lines:
click.echo(f'Количество строк: {len(content)}')
except FileNotFoundError:
click.secho('Файл не найден! 😱', fg='red')

if __name__ == '__main__':
cli()


Крутая штука в Click – это то, как легко добавлять новые команды. Хотите добавить подкоманду? Просто навешиваете еще один декоратор!

➡️А теперь лайфхак, который многие упускают: Click умеет создавать красивые прогресс-бары:
@cli.command()
@click.argument('path')
def process(path):
"""Обрабатывает файлы с прогресс-баром"""
files = os.listdir(path)
with click.progressbar(files, label='Обработка файлов') as bar:
for f in bar:
# что-то делаем с файлом
time.sleep(0.1)


➡️Про что еще стоит знать?

Click отлично работает с цветным выводом. Хотите привлечь внимание пользователя? Используйте click.secho():
click.secho('Внимание! 🚨', fg='yellow', bold=True)
click.secho('Ошибка! ', fg='red')
click.secho('Успех! ', fg='green')


➡️И напоследок, трюк – создание интерактивных подтверждений:
if click.confirm('Уверены, что хотите удалить все файлы? 🤔'):
click.echo('Поехали! 🚀')


📂Документация

🐍 Pythoner
Please open Telegram to view this post
VIEW IN TELEGRAM
6🔥6👍5🤔1
✈️ В Python shutil (shell utilities) — это высокоуровневая библиотека, предоставляющая функции для работы с файлами и директориями. Она расширяет возможности модуля os и упрощает выполнение распространенных операций, таких как копирование, перемещение, удаление, архивирование и работа с файловыми путями.

➡️ Применение shutil позволяет писать более чистый и понятный код при работе с файловой системой. Библиотека предоставляет удобные функции для выполнения сложных операций, например, рекурсивного копирования директорий или создания архивов различных форматов.

➡️ Вот пример использования shutil:
import shutil
import os

# Копирование файла:
shutil.copy("source_file.txt", "destination_folder/") # Копирование в директорию
shutil.copy("source_file.txt", "destination_file.txt") # Копирование с новым именем

# Копирование директории (рекурсивно):
shutil.copytree("source_folder", "destination_folder")

# Перемещение файла или директории:
shutil.move("source_file.txt", "destination_folder/")
shutil.move("source_folder", "destination_folder")

# Удаление файла:
os.remove("file_to_delete.txt")

# Удаление директории (рекурсивно):
shutil.rmtree("directory_to_delete")


# Создание архива:

shutil.make_archive("archive_name", "zip", "folder_to_archive") # ZIP архив
shutil.make_archive("archive_name", "gztar", "folder_to_archive") # tar.gz архив
shutil.make_archive("archive_name", "bztar", "folder_to_archive") # tar.bz2 архив
shutil.make_archive("archive_name", "xztar", "folder_to_archive") # tar.xz архив



# Работа с файловыми путями (некоторые примеры):

print(shutil.which("python")) # Путь к исполняемому файлу python


# Проверка дискового пространства

total, used, free = shutil.disk_usage("/") # Получение информации о дисковом пространстве (корневой раздел)
print(f"Total: {total // (2**30)} GiB")
print(f"Used: {used // (2**30)} GiB")
print(f"Free: {free // (2**30)} GiB")

⬆️ В этом примере демонстрируются функции shutil для копирования файлов и директорий, перемещения, удаления, создания архивов различных форматов, а также примеры работы с файловыми путями и проверки дискового пространства. Обратите внимание, что операции с файлами и директориями могут привести к безвозвратной потере данных, поэтому будьте осторожны при их использовании. Перед выполнением операций на реальных данных рекомендуется протестировать код на тестовых файлах и директориях. Также показан пример использования shutil.which для определения пути к исполняемому файлу и shutil.disk_usage для получения информации о дисковом пространстве.

🐍 Pythoner
Please open Telegram to view this post
VIEW IN TELEGRAM
5👍5🔥4
✈️ В Python NumPy — это фундаментальная библиотека для научных вычислений. Она предоставляет мощный N-мерный массив (ndarray), а также широкий набор функций для работы с этими массивами. NumPy является основой для многих других библиотек, таких как SciPy, Pandas и Matplotlib.

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

➡️ Вот пример использования NumPy:

import numpy as np

# Создание массивов:
a = np.array([1, 2, 3]) # Одномерный массив
b = np.array([[1, 2, 3], [4, 5, 6]]) # Двумерный массив
c = np.zeros((2, 3)) # Массив из нулей
d = np.ones((3, 2)) # Массив из единиц
e = np.arange(10) # Массив с числами от 0 до 9
f = np.linspace(0, 1, 5) # Массив из 5 чисел, равномерно распределенных от 0 до 1
g = np.random.rand(2, 2) # Массив случайных чисел от 0 до 1

print("a:", a)
print("b:", b)
print("c:", c)
print("d:", d)
print("e:", e)
print("f:", f)
print("g:", g)



# Математические операции:
print("a + 2:", a + 2)
print("a * 3:", a * 3)
print("a.sum():", a.sum()) # Сумма элементов массива
print("b.mean():", b.mean()) # Среднее значение элементов массива

print("a.dot(a): ", a.dot(a)) # Скалярное произведение векторов



# Индексация и срезы:
print("a[0]:", a[0])
print("b[1, 2]:", b[1, 2])
print("e[1:4]:", e[1:4])



# Изменение формы массива:
print("b.reshape(3, 2):", b.reshape(3, 2))
print("a.T:", a.T) # Транспонирование массива


# Линейная алгебра:
A = np.array([[1, 2], [3, 4]])
B = np.array([[5, 6], [7, 8]])
print("A.dot(B):", A.dot(B)) # Умножение матриц
print("np.linalg.inv(A):", np.linalg.inv(A)) # Обратная матрица


⬆️ В этом примере демонстрируются различные способы создания массивов NumPy, выполнение математических операций с массивами, индексация и срезы массивов, изменение формы массивов, а также базовые операции линейной алгебры, такие как умножение матриц и вычисление обратной матрицы. NumPy предоставляет множество других функций для работы с массивами, включая функции для работы с файлами, статистические функции, функции для обработки изображений и сигналов, и многое другое.

🐍 Pythoner
Please open Telegram to view this post
VIEW IN TELEGRAM
1👍75🔥5
✈️ В Python pypy3 — это альтернативная реализация интерпретатора Python, использующая JIT-компиляцию (Just-In-Time). Это означает, что pypy3 динамически компилирует Python-код в машинный код во время выполнения, что часто приводит к значительному увеличению скорости работы программ.

➡️ Применение pypy3 особенно эффективно для CPU-bound задач, где основное время выполнения тратится на вычисления. В таких случаях pypy3 может значительно превзойти стандартный интерпретатор CPython. Однако, pypy3 не всегда является оптимальным выбором, особенно для программ, интенсивно использующих C-расширения, которые могут работать медленнее или вообще не работать с pypy3.

➡️ Вот пример, демонстрирующий разницу в производительности между CPython и pypy3:

import time

def compute_intensive_task(n):
result = 0
for i in range(n):
result += i * i
return result

start_time = time.time()
result = compute_intensive_task(10000000) # CPU-bound задача
end_time = time.time()

print(f"Результат: {result}")
print(f"Время выполнения: {end_time - start_time} секунд")


# Для запуска с pypy3: pypy3 example.py

⬆️ В этом примере выполняется вычислительно интенсивная задача. Запустив этот код сначала с помощью стандартного интерпретатора CPython, а затем с помощью pypy3, можно заметить существенную разницу во времени выполнения. pypy3, вероятно, выполнит задачу значительно быстрее благодаря JIT-компиляции. Важно помнить, что результаты могут варьироваться в зависимости от конкретной задачи и аппаратного обеспечения. Этот пример демонстрирует преимущества pypy3 для CPU-bound задач. Для I/O-bound задач, где основное время тратится на ожидание ввода/вывода (например, сетевые запросы), разница в производительности может быть менее заметной.

🐍 Pythoner
Please open Telegram to view this post
VIEW IN TELEGRAM
👍64🔥3
✈️Сегодня поговорим о вечном противостоянии в мире тестирования. Знаете, как в споре "табы или пробелы", у нас есть другая горячая тема: unit-тесты против property-based тестирования. Давайте разберёмся без занудства, но с конкретикой!

➡️Unit-тестирование - это как стрельба по мишеням. Мы точно знаем, какой результат хотим получить, и проверяем конкретные случаи. Например:
def test_sum():
assert sum([1, 2, 3]) == 6
assert sum([-1, 1]) == 0


Плюсы unit-тестов:
—Понятны даже джуниору
—Легко дебажить
—Отлично подходят для документирования кода
—Быстро выполняются

Минусы:
—Покрывают только те кейсы, о которых мы подумали
—Часто пропускаем edge-cases
—Может быть много копипасты

➡️А вот property-based тестирование - это как игра в рулетку, только с гарантированным выигрышем! Вместо конкретных значений мы определяем свойства, которым должна соответствовать наша функция. Библиотека (например, hypothesis) сама генерирует тестовые данные:
from hypothesis import given
import hypothesis.strategies as st

@given(st.lists(st.integers()))
def test_sum_properties(numbers):
assert sum(numbers) == sum(reversed(numbers))
assert sum(numbers + [0]) == sum(numbers)


Преимущества property-testing:
—Находит неочевидные баги
—Меньше кода, больше покрытие
—Заставляет думать о свойствах функций, а не о конкретных значениях

Недостатки:
—Сложнее придумывать правильные свойства
—Медленнее выполняются
—Может быть сложно понять, почему тест упал

💡Не выбирайте что-то одно! Используйте unit-тесты для очевидных кейсов и документирования, а property-based - для поиска краевых случаев и сложной логики. Особенно это актуально для математических функций, парсеров и сериализаторов.

📍В идеальном мире ваши тесты должны быть как хороший детектив - проверять очевидное и раскрывать неожиданное. И помните: лучший тест - тот, который ловит баги до прода!

🐍 Pythoner
Please open Telegram to view this post
VIEW IN TELEGRAM
👍84🔥3
✈️ Conda — это кроссплатформенный менеджер пакетов и система управления окружением, которая упрощает установку, обновление и управление пакетами, особенно для научных вычислений и анализа данных. Conda работает с языками программирования Python, R, Ruby, Lua, Scala, Java, JavaScript, C/ C++, FORTRAN.

➡️ Применение conda помогает изолировать проекты с разными зависимостями, избегая конфликтов версий. Conda управляет не только пакетами Python, но и зависимостями на уровне операционной системы, такими как библиотеки, что особенно важно при работе с научными библиотеками. Conda также упрощает создание воспроизводимых сред для исследований и разработок.

➡️ Вот пример использования conda для создания и управления виртуальными окружениями:
# Создать новое окружение с Python 3.9
conda create -n my_env python=3.9

# Активировать окружение
conda activate my_env

# Установить пакеты в активное окружение
conda install numpy pandas scipy

# Просмотреть список установленных пакетов
conda list

# Деактивировать окружение
conda deactivate

# Удалить окружение
conda remove -n my_env --all

# Создать окружение из файла environment.yml
conda env create -f environment.yml

# Экспортировать окружение в файл environment.yml
conda env export > environment.yml

# Обновить все пакеты в активном окружении
conda update --all

# Поиск пакета
conda search numpy

⬆️ В этом примере показаны основные команды conda для создания, активации, деактивации и удаления виртуальных окружений. Также продемонстрировано, как устанавливать пакеты, просматривать список установленных пакетов, создавать окружение из файла environment.yml, экспортировать текущее окружение в файл environment.yml , обновлять все пакеты в окружении и искать нужный пакет. Использование виртуальных окружений с conda — лучшая практика для управления зависимостями проектов и предотвращения конфликтов.

🐍 Pythoner
Please open Telegram to view this post
VIEW IN TELEGRAM
1👍95🔥3
✈️ В Python pathlib — это модуль, предоставляющий объектно-ориентированный способ работы с файловыми путями и директориями. Он предлагает более удобный и читаемый интерфейс по сравнению с традиционными строковыми операциями с путями.

➡️ Применение pathlib упрощает работу с файловой системой, делая код более понятным и менее подверженным ошибкам. pathlib позволяет выполнять различные операции с файлами и директориями, такие как создание, удаление, переименование, чтение и запись, используя методы объектов Path.

➡️ Вот пример использования pathlib:

from pathlib import Path

# Создание объекта Path
file_path = Path("my_file.txt")
directory_path = Path("my_directory")

# Проверка существования файла/директории
if file_path.exists():
print(f"Файл {file_path} существует")
else:
print(f"Файл {file_path} не существует")

if directory_path.exists():
print(f"Директория {directory_path} существует")

if directory_path.is_dir():
print(f"Это директория")

# Создание директории
directory_path.mkdir(parents=True, exist_ok=True) # parents=True создает все родительские директории при необходимости, exist_ok=True предотвращает ошибку, если директория уже существует

# Создание файла и запись в него
file_path.write_text("Hello, pathlib!")

# Чтение из файла
file_content = file_path.read_text()
print(f"Содержимое файла: {file_content}")

# Переименование файла
new_file_path = Path("my_new_file.txt")
file_path.rename(new_file_path)

# Удаление файла
new_file_path.unlink()

# Перебор файлов в директории
for file in directory_path.iterdir():
print(file)

# Получение абсолютного пути
absolute_path = directory_path.resolve()
print(f"Абсолютный путь: {absolute_path}")


# Создание вложенных директорий и файла
nested_dir = Path("my_directory/nested/deeper")
nested_dir.mkdir(parents=True, exist_ok=True)
nested_file = nested_dir / "nested_file.txt" # / используется для объединения путей
nested_file.write_text("Content in nested file")


import shutil

# Удаление директории и ее содержимого
shutil.rmtree(directory_path) # rmtree из shutil используется для удаления непустых директорий


⬆️ В этом примере демонстрируются различные операции с файлами и директориями с использованием pathlib. Создаются объекты Path, проверяется существование файлов и директорий, создаются и удаляются файлы и директории, производится чтение и запись данных, переименование файлов, перебор файлов в директории и получение абсолютного пути. Также показан пример создания вложенных директорий и файла внутри них с помощью оператора /. И наконец, показано, как удалить директорию и ее содержимое с помощью shutil.rmtree.

🐍 Pythoner
Please open Telegram to view this post
VIEW IN TELEGRAM
🔥94👍4
Forwarded from IT memer
Please open Telegram to view this post
VIEW IN TELEGRAM
👍10🤣62😁2
✈️ Асинхронное использование httpx. В Python httpx предоставляет мощный и удобный асинхронный интерфейс для работы с HTTP-запросами. Асинхронный режим позволяет эффективно обрабатывать множество запросов параллельно, не блокируя основной поток выполнения, что особенно полезно при взаимодействии с медленными или перегруженными серверами.

➡️ Применение асинхронного httpx идеально подходит для ситуаций, где требуется высокая производительность при работе с сетью, например, при веб-скрапинге, взаимодействии с API, загрузке файлов и обработке потоковых данных. Асинхронный подход позволяет максимально использовать ресурсы системы и сократить время ожидания ответов от сервера.

➡️ Вот примеры, демонстрирующие асинхронную работу с httpx:
import asyncio
import httpx

async def fetch_page(client: httpx.AsyncClient, url: str):
try:
response = await client.get(url, timeout=10.0)
response.raise_for_status()
return {"url": url, "status_code": response.status_code, "content": response.text}
except httpx.HTTPError as exc:
return {"url": url, "error": f"HTTP Error: {exc}"}
except httpx.TimeoutException:
return {"url": url, "error": "Request timed out"}
except Exception as e:
return {"url": url, "error": f"An unexpected error occurred: {e}"}


async def main():
urls = [
"https://www.example.com",
"https://www.google.com",
"https://www.python.org",
"https://this-is-an-invalid-url.com", # Пример некорректного URL
"https://jsonplaceholder.typicode.com/todos/1" # Пример API
]

async with httpx.AsyncClient(http2=True) as client: # Использование HTTP/2
tasks = [fetch_page(client, url) for url in urls]
results = await asyncio.gather(*tasks)

for result in results:
print(result)




async def make_requests_with_limits(urls, max_concurrent=5):
semaphore = asyncio.Semaphore(max_concurrent)

async def fetch_with_semaphore(url):
async with semaphore:
return await fetch_page(httpx.AsyncClient(), url)


async with httpx.AsyncClient() as client:
tasks = [fetch_with_semaphore(url) for url in urls]
results = await asyncio.gather(*tasks)

for result in results:
print(result)




if __name__ == "__main__":
asyncio.run(main())

# Пример с ограничением числа одновременных запросов
asyncio.run(make_requests_with_limits(["https://www.example.com"] * 10))

⬆️ В этом примере fetch_page теперь принимает httpx.AsyncClient в качестве аргумента, что позволяет использовать один клиент для всех запросов внутри main. Это способствует более эффективному использованию соединений. Добавлен пример с некорректным URL и API-запросом для демонстрации обработки ошибок и различных типов ответов. Также показано, как использовать HTTP/2 с помощью httpx.AsyncClient(http2=True). Дополнительно, представлен пример make_requests_with_limits с использованием asyncio.Semaphore для ограничения количества одновременных запросов, что позволяет контролировать нагрузку на сервер и предотвращать ошибки, связанные с превышением лимитов.

🐍 Pythoner
Please open Telegram to view this post
VIEW IN TELEGRAM
6👍5🔥3
✈️ В Python tqdm — это быстрая, расширяемая библиотека индикаторов выполнения. Она позволяет легко добавлять индикаторы прогресса к циклам, итерациям и другим длительным операциям, предоставляя пользователю визуальную информацию о ходе выполнения.

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

➡️ Вот пример использования tqdm:

from tqdm import tqdm
import time

# Простой пример с range
for i in tqdm(range(100)):
time.sleep(0.02) # Имитация длительной операции


# С ручным обновлением
with tqdm(total=100) as pbar:
for i in range(10):
time.sleep(0.1)
pbar.update(10) # Обновление индикатора на 10 единиц


# С описанием
for i in tqdm(range(100), desc="Обработка данных"):
time.sleep(0.02)

# Вложенные циклы
from tqdm import trange
for i in trange(4, desc="1st loop"):
for j in trange(5, desc="2nd loop", leave=False):
for k in trange(50, desc="3rd loop", leave=False):
time.sleep(0.001)

# С pandas
import pandas as pd
df = pd.DataFrame({'a': range(10000)})

# Применение tqdm к pandas DataFrame (apply с progress_apply)
tqdm.pandas() # Необходимо для progress_apply
df['b'] = df['a'].progress_apply(lambda x: x*x) # Индикатор выполнения для apply



# Пример с файлами
import os
with open("large_file.txt", "w") as f:
for i in trange(10000, desc="Создание файла"):
f.write("This is a line of text.\n")


with open("large_file.txt", "r") as f:
for line in tqdm(f, total=os.path.getsize("large_file.txt"), unit="B", unit_scale=True, unit_divisor=1024, desc="Чтение файла"):
# Обработка каждой строки файла
pass


⬆️ В этом примере демонстрируются различные способы использования tqdm. Показаны примеры с range, ручным обновлением, описанием, вложенными циклами, интеграцией с pandas DataFrame с помощью progress_apply и обработкой файлов. Обратите внимание на использование tqdm.pandas() для работы с pandas. Пример с файлами показывает, как отображать прогресс чтения/записи с учетом размера файла.

🐍 Pythoner
Please open Telegram to view this post
VIEW IN TELEGRAM
👍83🔥2
✈️ В Python aioredis — это асинхронная библиотека для работы с базой данных Redis. Она построена на базе asyncio и предоставляет неблокирующий интерфейс для взаимодействия с Redis, что позволяет эффективно обрабатывать множество запросов одновременно.

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

➡️ Вот пример использования библиотеки aioredis в Python:

import asyncio
import aioredis

async def redis_example():
try:
# Подключение к Redis
redis = await aioredis.create_redis_pool(
'redis://localhost',
db=0,
encoding='utf-8', # Декодирование в UTF-8
minsize=5, # Минимальное количество соединений в пуле
maxsize=10 # Максимальное количество соединений в пуле
)


# Работа со строками
await redis.set('name', 'John Doe')
name = await redis.get('name')
print(f"Name: {name}") # Вывод: Name: John Doe



# Работа со списками
await redis.rpush('my_list', 'one', 'two', 'three')
list_length = await redis.llen('my_list')
list_items = await redis.lrange('my_list', 0, -1)
print(f"List length: {list_length}") # Вывод: List length: 3
print(f"List items: {list_items}") # Вывод: List items: ['one', 'two', 'three']


# Работа с хэшами
await redis.hset('user:1', 'name', 'Alice')
await redis.hset('user:1', 'age', 30)
user_data = await redis.hgetall('user:1')
print(f"User data: {user_data}") # Вывод: User data: {'name': 'Alice', 'age': '30'}


# Работа с множествами
await redis.sadd('my_set', 'apple', 'banana', 'cherry')
set_members = await redis.smembers('my_set')
print(f"Set members: {set_members}") # Вывод: Set members: {'apple', 'banana', 'cherry'}



# Использование pipeline
async with redis.pipeline(transaction=True) as pipe: # transaction=True для атомарности операций
await pipe.set('key1', 'value1')
await pipe.get('key1')
await pipe.hset('user:2', 'name', 'Bob')
results = await pipe.execute()
print(f"Pipeline results: {results}")



redis.close()
await redis.wait_closed()


except aioredis.RedisError as e:
print(f"Ошибка Redis: {e}")


if __name__ == "__main__":
asyncio.run(redis_example())


⬆️ В этом примере показано асинхронное подключение к Redis с использованием aioredis.create_redis_pool, работа с различными типами данных (строки, списки, хэши, множества), и использование pipeline для пакетной обработки команд в транзакции. encoding='utf-8' в параметрах подключения обеспечивает декодирование в UTF-8. minsize и maxsize управляют размером пула соединений. Обработка исключения aioredis.RedisError помогает выявить проблемы с Redis. Важно запускать асинхронный код внутри asyncio.run.


🐍 Pythoner
Please open Telegram to view this post
VIEW IN TELEGRAM
15👍4🔥1🥰1
✈️Sketch — это библиотека для статистического анализа и обработки данных. Она позволяет быстро проводить первичный анализ данных и строить прототипы моделей машинного обучения.

➡️Основные возможности:
— Быстрый и эффективный подсчёт статистик по данным, таких как сумма, среднее, медиана, дисперсия.
— Аппроксимация распределений и плотностей вероятности.
— Вычисление квантилей, сглаживания, гистограмм.
— Тестирование статистических гипотез, оценка p-value.
— Генерация случайных чисел из разных распределений.

➡️Sketch позволяет ускорить статистический анализ данных с помощью простого и интуитивного API и используется для:
— Первичного анализа и визуализации данных.
— Статистических тестов в научных исследованиях.
— Построения прототипов моделей машинного обучения.
— Анализа пользовательских действий и событий.
— Симуляции процессов на основе статистических моделей.

🐍 Pythoner
Please open Telegram to view this post
VIEW IN TELEGRAM
5👍3🔥2
✈️ В Python Selenium — это мощная библиотека для автоматизации веб-браузеров. Она позволяет управлять браузером программно, имитируя действия пользователя, такие как клики, ввод текста и навигация.

➡️ Применение Selenium широко распространено в веб-тестировании, веб-скрапинге и автоматизации задач. Она поддерживает различные браузеры, включая Chrome, Firefox, Safari и Edge.

➡️ Вот пример использования Selenium для автоматизации открытия страницы и поиска элемента:

from selenium import webdriver
from selenium.webdriver.common.by import By
from selenium.webdriver.support.ui import WebDriverWait
from selenium.webdriver.support import expected_conditions as EC

# Инициализация драйвера Chrome (убедитесь, что ChromeDriver установлен и находится в PATH)
driver = webdriver.Chrome()

try:
# Открытие страницы
driver.get("https://www.example.com")

# Явное ожидание элемента с ID "my-element" (до 10 секунд)
element = WebDriverWait(driver, 10).until(
EC.presence_of_element_located((By.ID, "my-element"))
)

# Вывод текста элемента
print(element.text)

finally:
# Закрытие браузера
driver.quit()


⬆️ В этом примере показано, как использовать Selenium для открытия веб-страницы, ожидания загрузки определенного элемента с помощью WebDriverWait и извлечения его текста. Убедитесь, что у вас установлен ChromeDriver и он добавлен в переменную окружения PATH или указан в executable_path при инициализации драйвера. Этот пример демонстрирует базовый сценарий использования Selenium, который можно расширить для выполнения более сложных действий, таких как заполнение форм, взаимодействие с JavaScript и обработка динамически загружаемого контента.

🐍 Pythoner
Please open Telegram to view this post
VIEW IN TELEGRAM
👍86🔥4🤔1
✈️ В Python typer — это современная и удобная библиотека для создания CLI-приложений (интерфейсов командной строки). Она построена на основе популярной библиотеки click и предоставляет простой и интуитивно понятный способ определения команд, аргументов и опций.

➡️ Применение typer особенно полезно при разработке инструментов командной строки, скриптов автоматизации и других приложений, где требуется взаимодействие с пользователем через терминал. typer автоматически генерирует справку и подсказки для пользователя, поддерживает типизацию аргументов и интегрируется с FastAPI.

➡️ Вот пример использования typer:

import typer

app = typer.Typer()

@app.command()
def hello(name: str):
"""
Простое приветствие.
"""
print(f"Привет, {name}!")

@app.command()
def goodbye(name: str, formal: bool = False):
"""
Прощание. Можно сделать формальным.
"""
if formal:
print(f"До свидания, {name}!")
else:
print(f"Пока, {name}!")

if __name__ == "__main__":
app()


⬆️ В этом примере показано создание простого CLI-приложения с двумя командами: "hello" и "goodbye". Команда "hello" принимает один аргумент — имя, и выводит приветствие. Команда "goodbye" принимает имя и опциональный аргумент "formal", который определяет, будет ли прощание формальным. Запустив этот скрипт и введя python main.py --help, вы получите автоматически сгенерированную справку по использованию приложения.

🐍 Pythoner
Please open Telegram to view this post
VIEW IN TELEGRAM
👍64🔥3👻1
✈️ В Python Pygments — это мощная библиотека для подсветки синтаксиса исходного кода. Она поддерживает огромное количество языков программирования и разметки, а также различные стили оформления.

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

➡️ Вот пример использования Pygments:

from pygments import highlight
from pygments.lexers import PythonLexer
from pygments.formatters import HtmlFormatter

code = 'print("Hello, world!")'
highlighted_code = highlight(code, PythonLexer(), HtmlFormatter())
print(highlighted_code)

# <div class="highlight"><pre><span></span><span class="nb">print</span><span class="p">(</span><span class="s2">&quot;Hello, world!&quot;</span><span class="p">)</span>
# </pre></div>


⬆️ В этом примере показано, как подсветить синтаксис Python-кода с помощью Pygments и вывести результат в формате HTML. Сначала импортируются необходимые классы: highlight, PythonLexer и HtmlFormatter. Затем определяется исходный код, который нужно подсветить. Функция highlight принимает код, лексер (в данном случае PythonLexer для Python) и форматтер (в данном случае HtmlFormatter для HTML) и возвращает подсвеченный код.

🐍 Pythoner
Please open Telegram to view this post
VIEW IN TELEGRAM
🔥8👍54
✈️Сегодня поговорим о том, как превратить свой код в настоящий искусственный интеллект.

➡️Давайте сразу посмотрим на простой пример в PyTorch:
import torch
import torch.nn as nn

class SimpleNet(nn.Module):
def __init__(self):
super().__init__()
self.layer1 = nn.Linear(784, 128)
self.relu = nn.ReLU()
self.layer2 = nn.Linear(128, 10)

def forward(self, x):
x = self.layer1(x)
x = self.relu(x)
return self.layer2(x)

Создаем модель одной строчкой! 🎯
model = SimpleNet().to('cuda' if torch.cuda.is_available() else 'cpu')


➡️Круто, правда? А теперь давайте глянем, как то же самое делается в TensorFlow:
import tensorflow as tf

model = tf.keras.Sequential([
tf.keras.layers.Dense(128, activation='relu', input_shape=(784,)),
tf.keras.layers.Dense(10)
])

# Компилируем модель
model.compile(optimizer='adam',
loss='sparse_categorical_crossentropy',
metrics=['accuracy'])


➡️Для создания своей первой модели вам понадобится всего три шага:
1. Подготовка данных (самая нудная, но важная часть)
2. Определение архитектуры (тут можно пофантазировать)
3. Обучение модели (запасайтесь терпением и мощным железом)

➡️Давайте посмотрим, как выглядит обучение на реальных данных:
# PyTorch стиль
optimizer = torch.optim.Adam(model.parameters())
criterion = nn.CrossEntropyLoss()

for epoch in range(10):
for batch_x, batch_y in dataloader:
optimizer.zero_grad()
outputs = model(batch_x)
loss = criterion(outputs, batch_y)
loss.backward()
optimizer.step()


🔎Крутая фишка: используйте GPU-ускорение! Одна строчка кода .to('cuda') в PyTorch или with tf.device('/GPU:0') в TensorFlow - и ваша модель учится в разы быстрее.

➡️Про что часто забывают новички? Про валидацию! Вот как это делается правильно:
# Разбиваем данные
from sklearn.model_selection import train_test_split

X_train, X_val, y_train, y_val = train_test_split(
X, y, test_size=0.2, random_state=42
)

# Следим за метриками
val_loss = []
for epoch in range(epochs):
model.train()
# ... обучение ...

model.eval()
with torch.no_grad():
val_predictions = model(X_val)
v_loss = criterion(val_predictions, y_val)
val_loss.append(v_loss.item())


🐍 Pythoner
Please open Telegram to view this post
VIEW IN TELEGRAM
9🔥4👍3🤣1
✈️Признайтесь, кто из вас устал от статичных matplotlib графиков? Сегодня поговорим о том, как превратить ваши данные в интерактивные произведения искусства с помощью Plotly и Bokeh!

➡️Начинаем с Plotly

Plotly - это как швейцарский нож в мире визуализации. Вот простой пример создания интерактивного графика:
import plotly.express as px
import pandas as pd

# Создаём тестовые данные
df = pd.DataFrame({
'Месяц': ['Янв', 'Фев', 'Март', 'Апр', 'Май'],
'Продажи': [100, 150, 200, 180, 250],
'Прибыль': [20, 30, 40, 35, 50]
})

# Создаём интерактивный график
fig = px.line(df, x='Месяц', y=['Продажи', 'Прибыль'],
title='Динамика продаж и прибыли',
template='plotly_dark')

# Добавляем hover-эффекты
fig.update_traces(mode='lines+markers', hovertemplate='%{y:,.0f}₽')

# Сохраняем как HTML или показываем в браузере
fig.write_html('sales_dashboard.html')


➡️Bokeh: Мощь серверного рендеринга

А теперь давайте создадим что-то более продвинутое с Bokeh:
from bokeh.plotting import figure, show
from bokeh.layouts import column
from bokeh.models import ColumnDataSource, HoverTool
import numpy as np

# Создаём интерактивный scatter plot
x = np.random.normal(0, 1, 1000)
y = np.random.normal(0, 1, 1000)

source = ColumnDataSource(data=dict(
x=x,
y=y,
size=np.random.uniform(5, 15, 1000),
color=['#%06x' % np.random.randint(0, 0xFFFFFF) for _ in range(1000)]
))

p = figure(width=800, height=600, title='Интерактивный Scatter Plot')
p.scatter('x', 'y', size='size', color='color', alpha=0.6, source=source)

# Добавляем интерактивные подсказки
hover = HoverTool(tooltips=[
('X', '@x{0.000}'),
('Y', '@y{0.000}'),
('Размер', '@size{0.00}')
])
p.add_tools(hover)

show(p)


👀Продвинутые фичи

🔎Вот несколько крутых возможностей, о которых многие не знают:

➡️Анимированные переходы в Plotly:
import plotly.graph_objects as go

fig = go.Figure(
data=[go.Scatter(x=[1, 2, 3], y=[1, 3, 2])],
layout=dict(
updatemenus=[dict(
type="buttons",
buttons=[dict(label="Play",
method="animate",
args=[None])]
)]
)
)


➡️Real-time обновления в Bokeh:
from bokeh.plotting import curdoc
from functools import partial
from tornado.ioloop import IOLoop

def update():
source.data['y'] = np.random.rand(100)

curdoc().add_periodic_callback(update, 100) # Обновление каждые 100мс


➡️Pro-tip: Для больших датасетов используйте датаклассы и оптимизируйте память:
from dataclasses import dataclass
from typing import List

@dataclass
class DataPoint:
x: float
y: float
category: str

data_points: List[DataPoint] = [] # Эффективнее, чем DataFrame для больших данных


⚡️Личный опыт: недавно делал дашборд для финтех-проекта. Начал с Matplotlib, намучался с интерактивностью, переписал на Plotly - заказчик в восторге, пользователи счастливы. Время разработки сократилось вдвое!

➡️Что выбрать?
- Plotly: если нужны красивые графики "из коробки" и важна простота использования
- Bokeh: если работаете с большими данными или нужна глубокая кастомизация

🐍 Pythoner
Please open Telegram to view this post
VIEW IN TELEGRAM
👍74🔥3