Как получить HTML-код выделенного на странице текста

Никогда не приходила в голову идея написать генератор (псевдо)случайных чисел? Например:

import random
import secrets
import string
import numpy as np
from collections import Counter
import time

class UniversalRandomGenerator:
"""
Универсальный генератор случайных чисел со всеми параметрами
"""

def __init__(self, seed=None):
"""Инициализация с возможностью задать seed для воспроизводимости"""
if seed is not None:
random.seed(seed)
np.random.seed(seed)
self.seed = seed

# ==================== 1. Базовые целые числа ====================
def generate_integers(self, min_val=0, max_val=100, count=10,
unique=False, exclude=None, weights=None):
"""
Генерация целых чисел

Параметры:
- min_val: нижняя граница (включительно)
- max_val: верхняя граница (включительно)
- count: количество чисел
- unique: уникальность (без повторений)
- exclude: список исключений
- weights: веса для каждого числа
"""
if exclude is None:
exclude = []

# Создаем пул доступных чисел
pool = list(range(min_val, max_val + 1))
pool = [x for x in pool if x not in exclude]

if unique:
if count > len(pool):
raise ValueError(f"Невозможно сгенерировать {count} уникальных чисел из {len(pool)} доступных")
return random.sample(pool, count)
else:
if weights is not None:
return random.choices(pool, weights=weights, k=count)
return random.choices(pool, k=count)

# ==================== 2. Вещественные числа ====================
def generate_floats(self, min_val=0.0, max_val=1.0, count=10,
decimals=2, distribution='uniform', **kwargs):
"""
Генерация вещественных чисел

Параметры:
- min_val: нижняя граница
- max_val: верхняя граница
- count: количество чисел
- decimals: количество знаков после запятой
- distribution: 'uniform', 'normal', 'exponential', 'beta'
- **kwargs: параметры для распределений
"""
if distribution == 'uniform':
numbers = np.random.uniform(min_val, max_val, count)
elif distribution == 'normal':
mean = kwargs.get('mean', 0)
std = kwargs.get('std', 1)
numbers = np.random.normal(mean, std, count)
elif distribution == 'exponential':
scale = kwargs.get('scale', 1.0)
numbers = np.random.exponential(scale, count)
elif distribution == 'beta':
alpha = kwargs.get('alpha', 2)
beta = kwargs.get('beta', 5)
numbers = np.random.beta(alpha, beta, count)
else:
raise ValueError(f"Неизвестное распределение: {distribution}")

# Округление до указанного количества знаков
return [round(float(x), decimals) for x in numbers]

# ==================== 3. Случайные строки ====================
def generate_strings(self, length=8, count=5,
charset=None,
require_digits=True,
require_uppercase=True,
require_lowercase=True,
require_special=False):
"""
Генерация случайных строк

Параметры:
- length: длина строки
- count: количество строк
- charset: алфавит (если None, строится автоматически)
- require_*: обязательное включение символов разных типов
"""
if charset is None:
charset = ''
if require_lowercase:
charset += string.ascii_lowercase
if require_uppercase:
charset += string.ascii_uppercase
if require_digits:
charset += string.digits
if require_special:
charset += '!@#$%^&*()_+-='

if not charset:
raise ValueError("Алфавит не может быть пустым")

strings = []
for _ in range(count):
# Гарантируем минимальные требования
result = []
if require_lowercase:
result.append(random.choice(string.ascii_lowercase))
if require_uppercase:
result.append(random.choice(string.ascii_uppercase))
if require_digits:
result.append(random.choice(string.digits))
if require_special:
result.append(random.choice('!@#$%^&*()_+-='))

# Добиваем остальные символы
remaining = length - len(result)
if remaining > 0:
result.extend(random.choices(charset, k=remaining))

# Перемешиваем
random.shuffle(result)
strings.append(''.join(result))

return strings

# ==================== 4. Криптографически безопасные ====================
def generate_secure(self, min_val=0, max_val=100, count=10):
"""Криптографически безопасные случайные числа"""
result = []
for _ in range(count):
# secrets.randbelow работает с [0, n)
result.append(secrets.randbelow(max_val - min_val + 1) + min_val)
return result

# ==================== 5. Матрицы и массивы ====================
def generate_matrix(self, rows=3, cols=3, min_val=0, max_val=10,
distribution='uniform', **kwargs):
"""Генерация матрицы случайных чисел"""
if distribution == 'uniform':
matrix = np.random.uniform(min_val, max_val, (rows, cols))
elif distribution == 'normal':
mean = kwargs.get('mean', 0)
std = kwargs.get('std', 1)
matrix = np.random.normal(mean, std, (rows, cols))
elif distribution == 'integers':
matrix = np.random.randint(min_val, max_val + 1, (rows, cols))
else:
raise ValueError(f"Неизвестное распределение: {distribution}")

return matrix.round(2) if distribution != 'integers' else matrix

# ==================== 6. С весами и вероятностями ====================
def generate_with_weights(self, items, weights, count=10):
"""Генерация с заданными весами"""
return random.choices(items, weights=weights, k=count)

# ==================== 7. С исключениями ====================
def generate_with_exclusions(self, min_val, max_val, count, exclude):
"""Генерация чисел с исключениями"""
pool = [x for x in range(min_val, max_val + 1) if x not in exclude]
return random.choices(pool, k=count)


# ==================== ДЕМОНСТРАЦИЯ ВСЕХ ПАРАМЕТРОВ ====================

def print_section(title, data, max_items=20):
"""Красивый вывод примеров"""
print(f"\n{'='*70}")
print(f"📊 {title}")
print(f"{'='*70}")

if isinstance(data, (np.ndarray, list)):
if len(data) > max_items:
print(f"Показано {max_items} из {len(data)} элементов:")
data = data[:max_items]

# Для чисел выводим статистику
if isinstance(data, (list, np.ndarray)) and len(data) > 0:
if all(isinstance(x, (int, float)) for x in data):
print(f" Минимум: {min(data):.4f}")
print(f" Максимум: {max(data):.4f}")
print(f" Среднее: {sum(data)/len(data):.4f}")
print(f" Всего: {len(data)} элементов")

print(f" Значения: {data}")
else:
print(f" {data}")

print()

def main():
# Создаем генератор с фиксированным seed для воспроизводимости
gen = UniversalRandomGenerator(seed=42)

print("🎲 УНИВЕРСАЛЬНЫЙ ГЕНЕРАТОР СЛУЧАЙНЫХ ЧИСЕЛ")
print("="*70)

# ===== 1. Базовые целые числа =====
print_section("1. ЦЕЛЫЕ ЧИСЛА (базовые параметры)",
gen.generate_integers(min_val=1, max_val=100, count=20))

print_section("1a. ЦЕЛЫЕ ЧИСЛА (уникальные, без повторений)",
gen.generate_integers(min_val=1, max_val=50, count=20, unique=True))

print_section("1b. ЦЕЛЫЕ ЧИСЛА (с исключениями)",
gen.generate_integers(min_val=1, max_val=20, count=15,
exclude=[5, 10, 15, 18, 20]))

print_section("1c. ЦЕЛЫЕ ЧИСЛА (с весами)",
gen.generate_integers(min_val=1, max_val=5, count=20,
weights=[0.5, 0.3, 0.1, 0.05, 0.05]))

# ===== 2. Вещественные числа =====
print_section("2. ВЕЩЕСТВЕННЫЕ ЧИСЛА (равномерное распределение, 2 знака)",
gen.generate_floats(min_val=0, max_val=1, count=15, decimals=3))

print_section("2a. НОРМАЛЬНОЕ РАСПРЕДЕЛЕНИЕ (mean=0, std=2)",
gen.generate_floats(count=20, distribution='normal',
mean=0, std=2, decimals=2))

print_section("2b. ЭКСПОНЕНЦИАЛЬНОЕ РАСПРЕДЕЛЕНИЕ (scale=2)",
gen.generate_floats(count=15, distribution='exponential',
scale=2, decimals=2))

print_section("2c. БЕТА-РАСПРЕДЕЛЕНИЕ (alpha=2, beta=5)",
gen.generate_floats(count=15, distribution='beta',
alpha=2, beta=5, decimals=3))

# ===== 3. Случайные строки =====
print_section("3. СЛУЧАЙНЫЕ СТРОКИ (длина 10, с цифрами и буквами)",
gen.generate_strings(length=10, count=8))

print_section("3a. СТРОКИ (только цифры, длина 6)",
gen.generate_strings(length=6, count=8,
require_digits=True,
require_lowercase=False,
require_uppercase=False,
require_special=False))

print_section("3b. СТРОКИ (сложные пароли, спецсимволы)",
gen.generate_strings(length=12, count=8,
require_digits=True,
require_uppercase=True,
require_lowercase=True,
require_special=True))

# ===== 4. Криптографически безопасные =====
print_section("4. КРИПТОГРАФИЧЕСКИ БЕЗОПАСНЫЕ (secrets)",
gen.generate_secure(min_val=1000, max_val=9999, count=15))

# ===== 5. Матрицы =====
print_section("5. МАТРИЦА 4x4 (целые числа от 1 до 20)",
gen.generate_matrix(rows=4, cols=4, min_val=1, max_val=20,
distribution='integers'))

print_section("5a. МАТРИЦА 3x5 (нормальное распределение)",
gen.generate_matrix(rows=3, cols=5, distribution='normal',
mean=10, std=3))

# ===== 6. С весами =====
items = ['Красный', 'Синий', 'Зеленый', 'Желтый']
weights = [0.4, 0.3, 0.2, 0.1]
print_section("6. ВЫБОРКА С ВЕСАМИ (цвета)",
gen.generate_with_weights(items, weights, count=30))

# ===== 7. С исключениями =====
print_section("7. С ИСКЛЮЧЕНИЯМИ (исключены простые числа)",
gen.generate_with_exclusions(min_val=1, max_val=30, count=15,
exclude=[2,3,5,7,11,13,17,19,23,29]))

# ===== 8. Дополнительно: смена seed =====
print_section("8. ВОСПРОИЗВОДИМОСТЬ (seed=123, одинаковый результат)",
"Запустите код дважды с seed=123 и получите одинаковые числа")

gen2 = UniversalRandomGenerator(seed=123)
print(f" Первый запуск: {gen2.generate_integers(1, 10, 5)}")
gen3 = UniversalRandomGenerator(seed=123)
print(f" Второй запуск: {gen3.generate_integers(1, 10, 5)}")
print(f" {'✅ Совпадают!' if gen2.generate_integers(1, 10, 5) == gen3.generate_integers(1, 10, 5) else '❌ Не совпадают'}")

# ===== 9. Большой массив для статистики =====
big_data = gen.generate_floats(min_val=0, max_val=100, count=1000,
decimals=2, distribution='normal',
mean=50, std=15)
print_section("9. БОЛЬШАЯ ВЫБОРКА (1000 чисел, нормальное распределение)",
big_data[:20])

# Статистика по большой выборке
print("📈 Детальная статистика по 1000 чисел:")
print(f" Среднее: {sum(big_data)/len(big_data):.4f}")
print(f" Стандартное отклонение: {np.std(big_data):.4f}")
print(f" Медиана: {np.median(big_data):.4f}")
print(f" 25-й процентиль: {np.percentile(big_data, 25):.4f}")
print(f" 75-й процентиль: {np.percentile(big_data, 75):.4f}")

# Гистограмма распределения
hist, bins = np.histogram(big_data, bins=10)
print(f"\n Распределение по диапазонам:")
for i in range(len(hist)):
print(f" {bins[i]:6.1f} - {bins[i+1]:6.1f}: {'█' * (hist[i] // 10)}{hist[i]}")

if __name__ == "__main__":
main()

Когда в Институте учился, то ли на четвёртом, то ли на пятом курсе была такая лабораторная работа. Причём делали два генератора: с равномерным распределением (правда, простейший, по формуле A_n+1 = (A_n*M) mod M, где A0 и M — взаимно простые числа) и с гауссовским (где результаты равномерного случайного распределения подставлялись в формулу для нормального). Тогда было интересно понять, как вообще эти генераторы работают! Правда, распределений по перцентилям не строили, да и код писали на Turbo Pascal ещё, 16-битный. Соответственно, числа были в диапазоне между 0 и примерно 65 тысяч (какое-то простое число чуть ниже 0xFFFF).