items = ["BTC", "ETH", "SOL"]
for idx, symbol in enumerate(items, start=1):
    print(f"{idx}. {symbol}")

pairs = ["BTCUSDT", "ETHUSDT", "SOLUSDT"]
prices = [100000, 3000, 56] #цена выдумана любое совпадение случайно

for pair, price in zip(pairs, prices):
    print(f"{pair}: {price}$")

dates = ["2025-06-30", "2025-07-01", "2025-07-02"]
volumes = [1234, 2345, 3456]
pairs = ["BTCUSDT", "ETHUSDT", "SOLUSDT"]
prices = [100000, 3000, 56] #цена выдумана любое совпадение случайно

for i, (pair, price, vol) in enumerate(zip(pairs, prices, volumes), start=1):
    print(f"{i}) {pair} — {price}$, объём {vol}")

inputs  = [2, 4, 6]
outputs = [4, 16, 36]

for test_num, (inp, outp) in enumerate(zip(inputs, outputs), 1):
    assert my_func(inp) == outp, f"Fail on test #{test_num}"

metrics = ["CPU", "RAM", "Disk"]
values  = [75, 60, 90]
limits  = [80, 70, 85]

for i, (m, v, lim) in enumerate(zip(metrics, values, limits), 1):
    status = "OK" if v < lim else "ALERT"
    print(f"{i}) {m}: {v}% (limit {lim}%) — {status}")

| sale_id | product_id | sale_amount |
|---------|------------|-------------|
| S1      | P1         | 500         |
| S2      | P1         | 800         |
| S3      | P1         | 300         |
| S4      | P2         | 200         |
| S5      | P2         | 700         |
| S6      | P2         | 600         |

  SELECT
    product_id,
    sale_id,
    sale_amount,
    ROW_NUMBER() OVER (
      PARTITION BY product_id
      ORDER BY sale_amount DESC
    ) AS rn
  FROM Sales

SELECT
  t.product_id,
  t.sale_id,
  t.sale_amount
FROM (
  SELECT
    product_id,
    sale_id,
    sale_amount,
    ROW_NUMBER() OVER (
      PARTITION BY product_id
      ORDER BY sale_amount DESC
    ) AS rn
  FROM Sales
) AS t
WHERE t.rn <= 3;

| product_id | sale_id | sale_amount |
|------------|---------|-------------|
| P1         | S2      | 800         |
| P1         | S1      | 500         |
| P1         | S3      | 300         |
| P2         | S5      | 700         |
| P2         | S6      | 600         |
| P2         | S4      | 200         |

Добавим к нашей таблице `Sales` столбец `sale_date`:

| sale_id | product_id | sale_amount | sale_date   |
|---------|------------|-------------|-------------|
| S1      | P1         | 500         | 2024-06-01  |
| S2      | P1         | 800         | 2024-06-05  |
| S3      | P1         | 300         | 2024-07-02  |
| S4      | P2         | 200         | 2024-06-10  |
| S5      | P2         | 700         | 2024-06-15  |
| S6      | P2         | 600         | 2024-07-01  |

def greet(name: str, times: int) -> None:
    for _ in range(times):
        print(f"Привет, {name}!")

from typing import List, Dict

prices: List[float] = [123.4, 56.7, 89.0]
user_balances: Dict[str, float] = {"Alice": 1000.0, "Bob": 750.5}

from typing import Tuple, Union

def get_price(symbol: str) -> Union[float, None]:
    # вернёт цену или None, если не найдено

from typing import TypedDict

class Order(TypedDict):
    id: int
    symbol: str
    amount: float

order: Order = {"id": 1, "symbol": "BTCUSDT", "amount": 0.5}

from typing import TypeVar, Iterable, List

T = TypeVar("T")

def to_list(iterable: Iterable[T]) -> List[T]:
    return list(iterable)

| id | name       | boss_id | salary  |
|----|------------|---------|---------|
| 1  | Иван       | NULL    | 100000  |
| 2  | Ольга      | 1       |  80000  |
| 3  | Сергей     | 1       |  75000  |
| 4  | Марина     | 2       |  60000  |
| 5  | Дмитрий    | 2       |  62000  |
| 6  | Елена      | 3       |  55000  |
| 7  | Алексей    | 4       |  50000  |

WITH RECURSIVE OrgTree AS (
    -- 1) Начинаем с корня (босса)
    SELECT
        id,
        name,
        boss_id,
        salary,
        CAST(name AS TEXT) AS path
    FROM Employees
    WHERE boss_id IS NULL   -- топ-менеджмент
    
    UNION ALL
    
    -- 2) Рекурсивно добавляем прямых подчиненных
    SELECT
        e.id,
        e.name,
        e.boss_id,
        e.salary,
        ot.path || ' → ' || e.name
    FROM Employees e
    JOIN OrgTree ot
      ON e.boss_id = ot.id
)
SELECT
    boss.id        AS boss_id,
    boss.name      AS boss_name,
    COUNT(sub.id)  AS team_size,
    SUM(sub.salary) AS team_salary
FROM OrgTree sub
JOIN Employees boss
  ON sub.boss_id = boss.id
GROUP BY boss.id, boss.name
ORDER BY boss_id;

| boss_id | boss_name | team_size | team_salary |
|---------|-----------|-----------|-------------|
| 1       | Иван      | 6         | 447000      |

| code | name          | updated_at          |
|------|---------------|---------------------|
| USD  | Доллар США    | 2025-07-20 10:00:00 |
| EUR  | Евро          | 2025-07-20 10:00:00 |
| GBP  | Фунт стерлингов| 2025-07-20 10:00:00 |

INSERT INTO Currencies (code, name, updated_at)
VALUES
    ('USD', 'US Dollar',      NOW()),
    ('JPY', 'Japanese Yen',   NOW()),
    ('EUR', 'Euro (fixed)',   NOW())
ON CONFLICT (code) DO UPDATE
    SET name       = EXCLUDED.name,
        updated_at = EXCLUDED.updated_at;

| code | name             | updated_at          |
|------|------------------|---------------------|
| USD  | US Dollar        | 2025-07-22 11:35:00 |
| EUR  | Euro (fixed)     | 2025-07-22 11:35:00 |
| GBP  | Фунт стерлингов  | 2025-07-20 10:00:00 |
| JPY  | Japanese Yen     | 2025-07-22 11:35:00 |

MERGE INTO Currencies AS target
USING (VALUES 
        ('USD', 'US Dollar',      GETDATE()),
        ('JPY', 'Japanese Yen',   GETDATE())
      ) AS src(code, name, updated_at)
ON target.code = src.code
WHEN MATCHED THEN
    UPDATE SET 
        target.name       = src.name,
        target.updated_at = src.updated_at
WHEN NOT MATCHED THEN
    INSERT (code, name, updated_at)
    VALUES (src.code, src.name, src.updated_at);

nums = [2, 4, 6, 8]

# Есть ли хоть одно нечётное? (any)
has_odd = any(n % 2 for n in nums)      # False

# Все ли чётные? (all)
all_even = all(n % 2 == 0 for n in nums)  # True

emails = ["[email protected]", "", "[email protected]"]

# Проверить, что у всех сотрудников есть email
if all(emails):
    print("Все указали адреса")
else:
    print("Кто-то забыл email")

# Проверить, что хотя бы один email корпоративный
if any(e.endswith("@company.com") for e in emails if e):
    print("Есть корпоративный адрес")

SELECT 
    sale_date,
    amount,
    LAG(amount) OVER (ORDER BY sale_date) AS prev_amount,
    amount - LAG(amount) OVER (ORDER BY sale_date) AS diff,
    ROUND(
        100.0 * (amount - LAG(amount) OVER (ORDER BY sale_date)) 
        / NULLIF(LAG(amount) OVER (ORDER BY sale_date), 0), 
        2
    ) AS pct_change
FROM Sales;