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 начал работу
(пауза 2 секунды)
Поток 1 завершил работу
Поток 2 завершил работу
Все потоки завершены

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("Все процессы завершены")

from concurrent.futures import ThreadPoolExecutor
import time

def task(n):
    time.sleep(2)
    return f"Готово: {n}"

with ThreadPoolExecutor(max_workers=2) as executor:
    results = executor.map(task, [1, 2, 3])
    
for result in results:
    print(result)

from concurrent.futures import ProcessPoolExecutor

def square(n):
    return n * n

with ProcessPoolExecutor() as executor:
    results = executor.map(square, [1, 2, 3, 4])

print(list(results))  # [1, 4, 9, 16]

import asyncio

async def task():
    print("Начало")
    await asyncio.sleep(2)  # Не блокирует другие задачи
    print("Конец")

async def main():
    await asyncio.gather(task(), task())

asyncio.run(main())

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

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

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

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

from selenium import webdriver

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

from locust import HttpUser, task

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

filter(function, iterable)

numbers = [1, 2, 3, 4, 5, 6]

# Оставляем только чётные числа
even_numbers = filter(lambda x: x % 2 == 0, numbers)

print(list(even_numbers))  # [2, 4, 6]

words = ["apple", "kiwi", "banana", "cherry"]

# Оставляем только слова длиной больше 5 символов
long_words = filter(lambda word: len(word) > 5, words)

print(list(long_words))  # ['banana', 'cherry']

values = [None, 0, "", "hello", 42, [], {}]

# Оставляем только "истинные" значения
filtered_values = filter(None, values)

print(list(filtered_values))  # ['hello', 42]

def is_positive(n):
    return n > 0

numbers = [-5, -2, 0, 3, 7, -1]
positive_numbers = filter(is_positive, numbers)

print(list(positive_numbers))  # [3, 7]

# С `filter()`
even_numbers = list(filter(lambda x: x % 2 == 0, numbers))

# С `for` + `if`
even_numbers = [x for x in numbers if x % 2 == 0]

data = {"name": "Alice", "age": 25, "city": "New York"}

# Проверяем, есть ли ключ "age"
if "age" in data:
    print("Ключ найден!")

Ключ найден!

if data.get("age") is not None:  # ❌ Работает, но `in` быстрее

if 25 in data.values():
    print("Значение найдено!")

Значение найдено!

if ("age", 25) in data.items():
    print("Пара (ключ, значение) найдена!")

/my_project
    /math_utils  ← Это пакет
        __init__.py  ← Делаем директорию пакетом
        arithmetic.py  ← Модуль с функциями сложения/вычитания
        geometry.py  ← Модуль с функциями для работы с фигурами
    main.py  ← Основной файл программы

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

def subtract(a, b):
    return a - b

def square_area(side):
    return side * side

from .arithmetic import add, subtract
from .geometry import square_area

from math_utils import add, square_area

print(add(2, 3))  # 5
print(square_area(4))  # 16

from math_utils import add, square_area

from math_utils import arithmetic
print(arithmetic.add(3, 5))

from math_utils.arithmetic import add
print(add(3, 5))

import sys
print(sys.path)  # Пути, где Python ищет модули

import sys
sys.path.append("/path/to/my_project")

/my_project
    /math_utils
        __init__.py
        /advanced
            __init__.py
            calculus.py

from math_utils.advanced.calculus import derivative

SELECT name, 
       (SELECT name FROM departments WHERE id = employees.department_id) AS department_name
FROM employees;

SELECT name 
FROM employees 
WHERE department_id IN (SELECT id FROM departments);

SELECT id, name, email FROM users_old
UNION
SELECT id, name, email FROM users_new;

SELECT e.name, d.name AS department
FROM employees e, departments d
WHERE e.department_id = d.id;

База данных (company_db)
 ├── Схема: public (по умолчанию)
 │   ├── Таблица: employees
 │   ├── Таблица: departments
 ├── Схема: hr
 │   ├── Таблица: employees
 │   ├── Таблица: salaries
 ├── Схема: sales
 │   ├── Таблица: customers
 │   ├── Таблица: orders

CREATE SCHEMA hr;  -- Создаём схему "hr"

CREATE TABLE hr.employees (
    id SERIAL PRIMARY KEY,
    name VARCHAR(100),
    position VARCHAR(50)
);

SET search_path TO hr;

GRANT USAGE ON SCHEMA hr TO hr_manager;
GRANT SELECT ON ALL TABLES IN SCHEMA hr TO hr_manager;

def bubble_sort(arr):
    n = len(arr)
    for i in range(n):
        swapped = False  # Флаг, отслеживающий перестановки
        for j in range(n - i - 1):
            if arr[j] > arr[j + 1]:  # Если элементы в неправильном порядке, меняем местами
                arr[j], arr[j + 1] = arr[j + 1], arr[j]
                swapped = True
        if not swapped:
            break  # Если перестановок не было, завершаем сортировку

arr = [1, 2, 3, 4, 5]  # Уже отсортированный массив
bubble_sort(arr)
print(arr)  # [1, 2, 3, 4, 5]