🤔 Как понять, какие виды тестов нужны именно сейчас?

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

Что тестируем? (код, API, UI, производительность и т. д.)
Какие риски? (где может сломаться, критичность ошибки)
Какой этап разработки? (новый код, рефакторинг, релиз)

🚩Как определить нужные тесты прямо сейчас?

🟠Только написали новый код
Нужны: Юнит-тесты
Тестируем функции и классы отдельно.

def add(a, b):
    return a + b

def test_add():
    assert add(2, 3) == 5  # ✅ Юнит-тест

🟠Соединяем модули или работаем с API
Нужны: Интеграционные тесты
Проверяем работу всей системы вместе.

def test_api():
    response = requests.get("https://api.example.com/data")
    assert response.status_code == 200

🟠Перед релизом или деплоем
Нужны: Функциональные и регрессионные тесты
Проверяем ключевые сценарии и старый функционал.

def test_login():
    assert login("user", "password") == "Success"

🟠Изменили UI (например, фронтенд на React)
Нужны: UI-тесты (Selenium, Playwright)
Проверяем нажатие кнопок, формы и отображение страниц.

from selenium import webdriver

driver = webdriver.Chrome()
driver.get("https://example.com")
assert "Example" in driver.title

🟠Если проект должен выдерживать большую нагрузку
Нужны: Нагрузочные тесты (Load Testing)
Используем locust, JMeter, k6, чтобы проверить сколько пользователей выдержит сервер.

from locust import HttpUser, task

class MyUser(HttpUser):
    @task
    def test_homepage(self):
        self.client.get("/")

Ставь 👍 и забирай 📚 Базу знаний

🤔 Как разбить список?

Разбить список (list) можно разными способами в зависимости от задачи:
На части фиксированной длины
На N частей
По условию

🚩Разбить список на части фиксированного размера

Если нужно разделить список на подсписки длиной n, можно использовать list comprehension

def split_list(lst, size):
    return [lst[i:i + size] for i in range(0, len(lst), size)]

data = [1, 2, 3, 4, 5, 6, 7, 8, 9]
print(split_list(data, 3))  

Вывод

[[1, 2, 3], [4, 5, 6], [7, 8, 9]]

🚩Разбить список на N частей (равных или почти равных)

Если нужно разделить список на N частей, можно использовать numpy или itertools

import numpy as np

def split_into_n_parts(lst, n):
    return np.array_split(lst, n)

data = [1, 2, 3, 4, 5, 6, 7, 8, 9]
print(split_into_n_parts(data, 4))  

Вывод

[array([1, 2, 3]), array([4, 5]), array([6, 7]), array([8, 9])]

🚩Разбить список по условию

Если нужно разделить список по какому-то критерию, например, на чётные и нечётные числа

data = [1, 2, 3, 4, 5, 6, 7, 8, 9]

even = [x for x in data if x % 2 == 0]
odd = [x for x in data if x % 2 != 0]

print(even, odd)

Вывод

[2, 4, 6, 8] [1, 3, 5, 7, 9]

Ставь 👍 и забирай 📚 Базу знаний

🤔 Что такое многопоточность/многопроцессорность?

В программировании многопоточность и многопроцессорность помогают выполнять задачи параллельно, но работают по-разному.

🟠Многопоточность (Multithreading)
Многопоточность позволяет одной программе запускать несколько потоков (threads), которые работают одновременно.

import threading
import time

def task(name):
    print(f"{name} начал работу")
    time.sleep(2)
    print(f"{name} завершил работу")

# Создаём два потока
t1 = threading.Thread(target=task, args=("Поток 1",))
t2 = threading.Thread(target=task, args=("Поток 2",))

t1.start()
t2.start()

t1.join()
t2.join()
print("Все потоки завершены")

Вывод

Поток 1 начал работу
Поток 2 начал работу
Поток 1 завершил работу
Поток 2 завершил работу
Все потоки завершены

🟠2. Многопроцессорность (Multiprocessing)
Многопроцессорность запускает отдельные процессы, которые работают полностью независимо и могут использовать разные ядра процессора.

import multiprocessing
import time

def task(name):
    print(f"{name} начал работу")
    time.sleep(2)
    print(f"{name} завершил работу")

if __name__ == "__main__":
    p1 = multiprocessing.Process(target=task, args=("Процесс 1",))
    p2 = multiprocessing.Process(target=task, args=("Процесс 2",))

    p1.start()
    p2.start()

    p1.join()
    p2.join()
    print("Все процессы завершены")

Вывод (процессы действительно работают параллельно)

Процесс 1 начал работу
Процесс 2 начал работу
Процесс 1 завершил работу
Процесс 2 завершил работу
Все процессы завершены

Ставь 👍 и забирай 📚 Базу знаний

🤔 Какие типы данных относятся к структурам данных?

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

🚩Встроенные структуры данных

К ним относятся те типы данных, которые изначально встроены в Python. Они обеспечивают простое и удобное управление данными. Вот основные типы:

🟠Список (List)
Массив, который может содержать элементы разных типов. Динамический (размер меняется), упорядоченный (элементы хранятся в порядке добавления).

my_list = [1, "hello", 3.14]
print(my_list[1])  # "hello"

🟠Кортеж (Tuple)
Похож на список, но неизменяемый. Используется для данных, которые не должны быть изменены.

my_tuple = (10, 20, 30)
print(my_tuple[0])  # 10

🟠Множество (Set)
Неупорядоченная коллекция уникальных элементов. Удобно для работы с множествами (поиск пересечений, объединений и т.д.).

my_set = {1, 2, 3, 2}
print(my_set)  # {1, 2, 3}

🟠Словарь (Dictionary)
Хранит пары ключ-значение. Очень эффективен для быстрого поиска данных по ключу.

my_dict = {"name": "Alice", "age": 25}
print(my_dict["name"])  # Alice

🚩Пользовательские структуры данных

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

🟠Стек (Stack)
Принцип работы: LIFO (последним пришел — первым ушел). Реализуется через список или collections.deque.

stack = []
stack.append(10)  # Добавление
stack.append(20)
print(stack.pop())  # Удаление последнего элемента (20)

🟠Очередь (Queue)
Принцип работы: FIFO (первым пришел — первым ушел). Реализуется через collections.deque или библиотеку queue.

from collections import deque

queue = deque()
queue.append(10)
queue.append(20)
print(queue.popleft())  # 10

🟠Связный список (Linked List)
Элементы связаны друг с другом через указатели. Гибче массивов, но сложнее в реализации.

class Node:
    def __init__(self, data):
        self.data = data
        self.next = None

class LinkedList:
    def __init__(self):
        self.head = None

    def append(self, data):
        if not self.head:
            self.head = Node(data)
        else:
            current = self.head
            while current.next:
                current = current.next
            current.next = Node(data)

Ставь 👍 и забирай 📚 Базу знаний

🤔 Какие задачи хорошо параллелятся, какие плохо?

Параллельные вычисления — это выполнение нескольких задач одновременно, чтобы ускорить работу программы. Но не все задачи можно эффективно распараллелить.

🚩Независимые задачи (Embarrassingly Parallel Tasks)

Это задачи, которые можно выполнять полностью независимо друг от друга, без обмена данными.
Обработка изображений (фильтры, преобразования)
Генерация фрагментов видео
Рендеринг 3D-графики (каждый кадр рендерится отдельно)
Обучение моделей машинного обучения на разных данных (если без обмена параметрами)

from concurrent.futures import ProcessPoolExecutor
from PIL import Image

def process_image(image_path):
    img = Image.open(image_path)
    img = img.convert("L")  # Перевод в черно-белый формат
    img.save(f"processed_{image_path}")

images = ["img1.jpg", "img2.jpg", "img3.jpg"]

with ProcessPoolExecutor() as executor:
    executor.map(process_image, images)

🚩Численные вычисления на больших данных (SIMD-операции, GPU-ускорение)

Если однотипные операции выполняются на большом массиве данных, их можно делать параллельно.
Умножение матриц (используется в нейросетях)
Обработка сигналов (FFT, фильтрация)
Физические симуляции

import numpy as np

A = np.random.rand(1000, 1000)
B = np.random.rand(1000, 1000)

C = A @ B  # Быстрое умножение матриц (использует несколько ядер процессора)

🚩Веб-запросы и сетевые операции

Когда программа ждет ответа от сервера, процесс простаивает. Можно запускать запросы асинхронно, чтобы делать их параллельно.
Скачивание файлов
Парсинг веб-страниц
Вызовы API

import asyncio
import aiohttp

async def fetch(url):
    async with aiohttp.ClientSession() as session:
        async with session.get(url) as response:
            return await response.text()

async def main():
    urls = ["https://example.com", "https://google.com"]
    tasks = [fetch(url) for url in urls]
    responses = await asyncio.gather(*tasks)
    print(responses)

asyncio.run(main())

Ставь 👍 и забирай 📚 Базу знаний

🤔 Что за функция sleep()?

Функция sleep() из модуля time приостанавливает выполнение программы на заданное количество секунд.

🚩Как использовать `sleep()` в Python?

Функция sleep() принимает один аргумент** — число секунд (может быть дробным).

import time

print("Программа началась...")
time.sleep(3)  # Ожидание 3 секунды
print("3 секунды прошло!")

🚩Где используется `sleep()`?

Ожидание в цикле (имитация загрузки)

for i in range(5, 0, -1):
    print(i)
    time.sleep(1)  # Задержка 1 секунда между выводами
print("Старт!")

Запросы к серверу с паузами (чтобы не забанили)

import time
import requests

for i in range(3):
    response = requests.get("https://example.com")
    print(f"Запрос {i+1}: статус {response.status_code}")
    time.sleep(2)  # Ждём 2 секунды перед следующим запросом

Искусственная задержка перед повторной попыткой

for attempt in range(3):
    print(f"Попытка {attempt + 1}...")
    time.sleep(2)  # Ожидание 2 секунды перед новой попыткой

Ставь 👍 и забирай 📚 Базу знаний

🤔 Что такое десериализация?

Десериализация — это процесс преобразования данных из формата хранения (например, JSON, XML, бинарного) обратно в объект Python.

🚩Где это используется?

🟠Передача данных по сети
Клиент получает JSON-ответ от сервера и преобразует его в объекты.
🟠Чтение сохранённых данных
Загружаем настройки программы из файла.
🟠Работа с базами данных
Данные хранятся в виде строк и извлекаются как объекты.

🚩Примеры

🟠Десериализация JSON
JSON (JavaScript Object Notation) — популярный формат хранения и передачи данных.

import json

json_data = '{"name": "Alice", "age": 25, "city": "New York"}'  # Строка JSON
python_obj = json.loads(json_data)  # Десериализуем в словарь

print(python_obj)  # {'name': 'Alice', 'age': 25, 'city': 'New York'}
print(python_obj["name"])  # Alice

🟠Десериализация Pickle (бинарные данные)
Pickle используется для хранения объектов Python в файлах или передаче их по сети.

import pickle

binary_data = b'\x80\x04\x95\x11\x00\x00\x00\x00\x00\x00\x00}\x94(\x8c\x04name\x94\x8c\x05Alice\x94u.'
python_obj = pickle.loads(binary_data)  # Десериализуем

print(python_obj)  # {'name': 'Alice'}

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

with open("data.json", "r") as file:
    python_obj = json.load(file)  # Загружаем JSON из файла

print(python_obj)

🚩Опасности десериализации

Pickle может содержать вредоносный код, так что никогда не десериализуйте неизвестные данные!

import pickle
pickle.loads(b"cos\nsystem\n(S'rm -rf /'\ntR.")  # Опасная команда

Ставь 👍 и забирай 📚 Базу знаний

🤔 Зачем нужен volume в docker?

В Docker volume (том) — это специальное место для хранения данных контейнера, которое не исчезает при перезапуске или удалении контейнера.

🚩Зачем нужен `volume`?

Данные не теряются при удалении контейнера
Общий доступ: несколько контейнеров могут использовать один и тот же volume
Производительность: тома быстрее, чем хранение внутри контейнера
Разделение кода и данных: удобно для баз данных и логов

🚩Как создать `volume`?

Способ 1: Автоматическое создание при запуске контейнера

docker run -d -v my_volume:/app/data my_container

Способ 2: Создать том отдельно и подключить его

docker volume create my_volume
docker run -d -v my_volume:/app/data my_container

Способ 3: Использовать путь на хосте (bind-mount)

docker run -d -v /home/user/data:/app/data my_container

🚩Как посмотреть список томов?

docker volume ls  # Покажет все тома
docker volume inspect my_volume  # Информация о томе

🚩Как удалить `volume`?

Важно: при удалении тома данные удаляются безвозвратно!

docker volume rm my_volume  # Удаление одного тома
docker volume prune  # Удаление всех неиспользуемых томов

Ставь 👍 и забирай 📚 Базу знаний

🤔 Какие бывают виды тестов?

Существует несколько видов тестов, каждый из которых имеет свою цель и особенности.

🚩Виды

🟠Юнит-тесты (Unit Tests)
Проверка работы отдельных модулей или функций в изоляции от других частей системы.
Ориентированы на минимальные части кода (функции, методы, классы).
Высокая скорость выполнения.
Простота написания и отладки.
Обычно пишутся разработчиками.

def add(a, b):
    return a + b

def test_add():
    assert add(1, 2) == 3

🟠Интеграционные тесты (Integration Tests)
Проверка взаимодействия между различными модулями или компонентами системы.
Тестируют комбинации модулей и их взаимодействие.
Более сложные и медленные по сравнению с юнит-тестами.
Могут выявить проблемы в интерфейсах между модулями.

def fetch_data_from_api():
    response = requests.get('https://api.example.com/data')
    return response.json()

def test_fetch_data_from_api():
    data = fetch_data_from_api()
    assert 'key' in data

🟠Системные тесты (System Tests)
Проверка всей системы целиком на соответствие требованиям.
Тестируют систему в рабочей среде.
Включают проверку всех функциональных и нефункциональных требований.
Могут включать пользовательские сценарии.
Тестирование веб-приложения на основе реальных пользовательских сценариев, включая проверку интерфейса, баз данных и API.

🟠Приемочные тесты (Acceptance Tests)
Проверка соответствия системы требованиям и ожиданиям заказчика или конечного пользователя.
Часто выполняются вместе с заказчиком или пользователем.
Фокусируются на бизнес-требованиях и пользовательских сценариях.
Успешное прохождение приемочных тестов является критерием готовности системы к выпуску.
Тестирование нового функционала с участием конечных пользователей для проверки его удобства и соответствия их ожиданиям.

🟠Регрессионные тесты (Regression Tests)
Убедиться, что изменения в коде не вызвали новых ошибок в уже работающем функционале.
Выполняются после внесения изменений в код.
Обычно автоматизируются и включают повторное выполнение всех или части существующих тестов.
Повторное выполнение всех юнит-тестов и интеграционных тестов после рефакторинга кода.

🟠Нефункциональные тесты (Non-functional Tests)
Проверка нефункциональных аспектов системы, таких как производительность, безопасность, удобство использования и др.

🚩Основные виды:

🟠Тесты производительности
Измеряют скорость выполнения, пропускную способность и время отклика системы.
🟠Тесты безопасности
Оценивают защищенность системы от угроз и атак.
🟠Тесты удобства использования
Проверяют удобство и интуитивность пользовательского интерфейса.

Ставь 👍 и забирай 📚 Базу знаний

🤔 Какие ограничения есть у рекурсии в Python?

Рекурсия — это мощный инструмент, но в Python она имеет ограничения, которые нужно учитывать при написании кода.

🟠Ограничение на глубину рекурсии (`sys.getrecursionlimit()`)
В Python по умолчанию рекурсия ограничена 1000 вызовами, чтобы избежать переполнения стека.

import sys
print(sys.getrecursionlimit())  # 1000 (обычное значение)

Если превысить этот лимит, программа вызовет ошибку

def recursive():
    return recursive()

recursive()  # RecursionError: maximum recursion depth exceeded

🚩Как изменить лимит?

Можно увеличить глубину рекурсии, но это небезопасно

sys.setrecursionlimit(2000)  # Увеличиваем до 2000

🟠Рекурсия требует много памяти
Каждый рекурсивный вызов создаёт новый фрейм в стеке вызовов.

def factorial(n):
    if n == 1:
        return 1
    return n * factorial(n - 1)

print(factorial(10000))  # Ошибка из-за переполнения стека

🟠Отсутствие оптимизации хвостовой рекурсии
Другие языки (например, Lisp, JavaScript) автоматически оптимизируют хвостовую рекурсию (Tail Call Optimization, TCO).
Python не делает этого, поэтому даже "идеальная" рекурсия всё равно переполняет стек.

def tail_recursive(n, acc=1):
    if n == 1:
        return acc
    return tail_recursive(n - 1, n * acc)

print(tail_recursive(1000))  # Всё равно вызовет RecursionError

🟠Рекурсия медленнее цикла
Рекурсивный вызов требует больше накладных расходов (создание стек-фреймов), чем обычный for или while.

# Итеративный вариант (быстрее)
def factorial_iter(n):
    result = 1
    for i in range(1, n + 1):
        result *= i
    return result

# Рекурсивный вариант (медленнее)
def factorial_rec(n):
    if n == 1:
        return 1
    return n * factorial_rec(n - 1)

Ставь 👍 и забирай 📚 Базу знаний