# main.py
import calculator

# Наша власна функція add — для роботи з рядками
def add(text1: str, text2: str) -> str:
    return text1 + " " + text2

# Жодного конфлікту! Два різних простори імен:
my_text = add("Привіт", "Світ")          # наша функція
calc_sum = calculator.add(2, 2)           # функція з модуля

print(my_text)    # "Привіт Світ"
print(calc_sum)   # 4

# namespace_demo.py
import math

global_var = "Я глобальна змінна"

def outer_function():
    enclosing_var = "Я охоплююча змінна"

    def inner_function():
        local_var = "Я локальна змінна"

        # Дивимося на локальний простір імен внутрішньої функції
        print("--- Local Namespace inside inner_function() ---")
        print(locals())  # Виведе тільки {'local_var': 'Я локальна змінна'}

        # Спробуємо знайти global_var та print (built-in)
        # Python пройде шлях: inner_local -> outer_enclosing -> global -> built-in

    inner_function()

outer_function()

# Глобальний простір імен модуля
print("\n--- Global Namespace of module ---")
# globals() містить імпортований 'math', 'global_var', 'outer_function' та службові атрибути
print(list(globals().keys())[:10])  # покажемо перші 10 ключів

import calculator

# Динамічно додаємо нове ім'я в простір імен модуля calculator
calculator.new_constant = 9.99

# Тепер це ім'я доступне звичайним шляхом!
print(calculator.new_constant)  # 9.99

# calculator.py
PI = 3.14159          # публічний атрибут ✅
_precision = 10       # «приватний» атрибут — для внутрішнього використання

def add(a, b):        # публічна функція ✅
    return a + b

def _validate(x):     # «приватна» функція — деталь реалізації
    return isinstance(x, (int, float))

import sys

print(f"Тип sys.path: {type(sys.path)}")  # <class 'list'>
print(f"Кількість шляхів: {len(sys.path)}")

for i, path in enumerate(sys.path):
    print(f"  [{i}] {path}")

import sys

# Додати власний шлях перед усіма іншими (найвищий пріоритет)
sys.path.insert(0, '/path/to/my/custom/libs')

# Або в кінець (найнижчий пріоритет)
sys.path.append('/path/to/fallback/libs')

# Тепер Python шукатиме модулі і там
import my_custom_module  # знайде у /path/to/my/custom/libs

# main.py — демонстрація кешування
import sys

print("=== Перший імпорт ===")
import calculator  # <— тут: файл читається, байткод виконується

print("\n=== Другий імпорт ===")
import calculator  # <— тут: Python бачить 'calculator' у sys.modules → пропускає

print("\n=== Третій імпорт ===")
import calculator  # <— те саме: кеш-хіт, нульова вартість

print(f"\n'calculator' у кеші? {'calculator' in sys.modules}")

# Отримати об'єкт модуля з кешу напряму
cached = sys.modules['calculator']
print(f"Той самий об'єкт? {calculator is cached}")   # True
print(f"Виклик через кеш: {cached.add(1, 2)}")        # 3

# sys_modules_experiment.py
import sys

print("--- Крок 1: Перший імпорт ---")
import calculator  # Виведе повідомлення про завантаження

print("\n--- Крок 2: Другий імпорт (кешований) ---")
import calculator  # Нічого не виведе, оскільки calculator вже у sys.modules

# Перевіряємо наявність у кеші
print(f"\ncalculator у sys.modules? {'calculator' in sys.modules}")

print("\n--- Крок 3: Видалення з sys.modules та повторний імпорт ---")
# Ручне видалення запису з кешу
del sys.modules['calculator']

print(f"calculator у sys.modules після видалення? {'calculator' in sys.modules}")

import calculator  # Python знову завантажує та виконує код модуля!

# state.py — модуль зі спільним станом
print("Ініціалізація state.py")
request_count = 0
active_connections = []

# module_a.py — реєструє запити
import state

def handle_request(url: str) -> None:
    state.request_count += 1
    state.active_connections.append(url)
    print(f"[A] Запит #{state.request_count} до {url}")

# module_b.py — читає статистику
import state

def get_stats() -> dict:
    return {
        "total": state.request_count,
        "active": len(state.active_connections)
    }

# main.py
import module_a
import module_b

module_a.handle_request("/api/users")
module_a.handle_request("/api/products")

stats = module_b.get_stats()
print(f"Статистика: {stats}")
# {'total': 2, 'active': 2}
# module_b бачить зміни, зроблені module_a!

import importlib
import calculator

# Поточна версія
print(calculator.add(1, 2))   # 3

# ... ви зміни код calculator.py: add тепер повертає a + b + 100 ...

# Звичайний import нічого не зробить:
import calculator
print(calculator.add(1, 2))   # все одно 3!

# Примусово перезавантажити:
importlib.reload(calculator)
print(calculator.add(1, 2))   # тепер 103 ✅

# calculator.py
PI = 3.14159

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

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

def _run_tests():
    """Вбудовані smoke-тести."""
    assert add(2, 3) == 5, "add(2, 3) має дорівнювати 5"
    assert subtract(10, 3) == 7, "subtract(10, 3) має дорівнювати 7"
    print("✅ Всі smoke-тести пройдено!")

# Цей блок виконується ЛИШЕ при запуску: python calculator.py
# При import calculator — він повністю ігнорується
if __name__ == "__main__":
    print(f"Запуск calculator.py як головного скрипта.")
    print(f"Поточне __name__: {__name__}")
    _run_tests()

# data_processor.py
import sys
import json

def load_data(filepath: str) -> dict:
    """Завантажує JSON з файлу."""
    with open(filepath) as f:
        return json.load(f)

def process(data: dict) -> list:
    """Бізнес-логіка обробки даних."""
    return [item for item in data.get("items", []) if item.get("active")]

def save_results(results: list, output_path: str) -> None:
    """Зберігає результати."""
    with open(output_path, "w") as f:
        json.dump(results, f, indent=2)

def main() -> int:
    """
    Точка входу програми.
    Повертає код завершення: 0 = успіх, 1 = помилка.
    """
    if len(sys.argv) != 3:
        print(f"Використання: python {sys.argv[0]} <input.json> <output.json>")
        return 1

    input_path = sys.argv[1]
    output_path = sys.argv[2]

    try:
        data = load_data(input_path)
        results = process(data)
        save_results(results, output_path)
        print(f"✅ Оброблено {len(results)} записів → {output_path}")
        return 0
    except FileNotFoundError as e:
        print(f"❌ Файл не знайдено: {e}")
        return 1
    except json.JSONDecodeError as e:
        print(f"❌ Невалідний JSON: {e}")
        return 1


if __name__ == "__main__":
    sys.exit(main())  # sys.exit передає код завершення в оболонку

# a.py
print("Завантаження a.py...")
import b  # Python призупиняє a.py і завантажує b.py

def func_a():
    b.func_b()
    print("func_a виконана")

print("a.py завантажено.")

# b.py
print("Завантаження b.py...")
import a  # Python бачить: a вже є у sys.modules (частково!)

def func_b():
    print("func_b виконана")

print("b.py завантажено.")

# main.py
import a
a.func_a()  # AttributeError: partially initialized module 'b'...

❌ Погана архітектура:          ✅ Правильна архітектура:
  a.py ←→ b.py                   shared.py (незалежний)
                                  a.py → shared.py
                                  b.py → shared.py, a.py

# a.py
def func_a():
    import b  # ← імпорт всередині функції, відкладений до виклику
    b.func_b()
    print("func_a виконана")

❌ Хаос без пакетів:          ✅ Структура з пакетами:
myproject/                    myproject/
  main.py                       main.py
  users.py                      users/
  user_auth.py                    __init__.py
  user_profile.py                 auth.py
  products.py                     profile.py
  product_catalog.py            products/
  product_pricing.py              __init__.py
  orders.py                       catalog.py
  order_processing.py             pricing.py
  order_notifications.py        orders/
  database.py                     __init__.py
  api_client.py                   processing.py
  utils.py                        notifications.py
                                database.py
                                utils.py

# До рефакторингу: shop/products.py
# Після рефакторингу: shop/catalog/products.py

# Але __init__.py залишається незмінним:
from .catalog.products import list_products  # ← просто змінили шлях
# Зовнішній код 'shop.list_products()' не сломається!

# Де б не знаходився цей файл у структурі проекту:
import shop.products                        # весь модуль
from shop.products import list_products     # конкретна функція
from shop.orders.processing import create_order  # з підпакета

# Всередині shop/orders/processing.py:
from . import notifications       # . = поточний пакет (shop/orders/)
from .notifications import send   # конкретна функція з сусіднього модуля
from .. import products           # .. = батьківський пакет (shop/)
from ..customers import get_customer  # конкретна функція з батька

# shop/products.py

__all__ = ["list_products", "get_product", "calculate_price_with_vat"]
# _products_db та будь-які внутрішні допоміжні функції
# не включені в __all__ і не будуть імпортовані через 'from shop.products import *'

def list_products(active_only=True): ...
def get_product(product_id): ...
def calculate_price_with_vat(product_id, vat_rate=0.20): ...
def _validate_product(data): ...  # внутрішня, не у __all__

_products_db = [...]              # приватні дані, не у __all__

home = /usr/bin
include-system-site-packages = false
version = 3.12.2
executable = /usr/bin/python3.12
command = /usr/bin/python3 -m venv /home/user/myproject/.venv

# python -m venv <назва_директорії>
# Конвенція: називати середовище 'venv' або '.venv'

python -m venv venv        # звичайне середовище
python -m venv .venv       # приховане (починається з крапки)
python3.12 -m venv .venv   # явна версія Python

.venv/
├── bin/                    # (Linux/macOS)
│   ├── python              # символічне посилання на інтерпретатор
│   ├── python3
│   ├── pip
│   └── activate            # скрипт активації!
├── lib/
│   └── python3.12/
│       └── site-packages/  # сюди pip встановлює пакети
└── pyvenv.cfg              # конфігурація середовища

# Встановлення з PyPI
pip install requests                   # остання версія
pip install requests==2.31.0           # конкретна версія
pip install "requests>=2.28,<3.0"      # діапазон версій
pip install django djangorestframework  # кілька одразу

# Список встановлених пакетів
pip list

# Детальна інформація про пакет
pip show requests

deactivate

# Промпт повернувся до нормального вигляду:
# user@host:~/myproject$

which python  # /usr/bin/python3  ← глобальний Python

# pip freeze виводить всі встановлені пакети з точними версіями
pip freeze > requirements.txt

cat requirements.txt

# На іншій машині або у CI/CD:
python -m venv .venv
source .venv/bin/activate

pip install -r requirements.txt
# pip встановить точно ті ж версії, що зафіксовані у файлі

# macOS / Linux
curl -LsSf https://astral.sh/uv/install.sh | sh

# Windows (PowerShell)
powershell -ExecutionPolicy ByPass -c "irm https://astral.sh/uv/install.ps1 | iex"

# Також через pip (якщо вже є Python):
pip install uv

# Перевірка встановлення
uv --version  # uv 0.5.x (або новіше)

# Ініціалізація проекту — створює pyproject.toml і базову структуру
uv init my-web-api
cd my-web-api

# Або ініціалізація у поточній директорії
mkdir my-project && cd my-project
uv init

# pyproject.toml (генерується автоматично)
[project]
name = "my-web-api"
version = "0.1.0"
description = "Add your description here"
readme = "README.md"
requires-python = ">=3.12"
dependencies = []

# Додавання залежності — оновлює pyproject.toml і uv.lock автоматично
uv add fastapi
uv add "sqlalchemy>=2.0"
uv add "pydantic>=2.5,<3.0"

# Кілька залежностей одразу
uv add httpx aiohttp redis

# Залежності лише для розробки (не потрапляють у production)
uv add --dev pytest pytest-asyncio ruff mypy
uv add --dev black isort

# Видалення залежності
uv remove redis

# Синхронізація середовища з lockfile (аналог pip install -r requirements.txt)
uv sync

# Синхронізація без dev-залежностей (для production)
uv sync --no-dev

[project]
name = "my-web-api"
version = "0.1.0"
requires-python = ">=3.12"
dependencies = [
    "fastapi>=0.115.6",
    "uvicorn>=0.32.1",
]

[dependency-groups]
dev = [
    "pytest>=8.3.4",
    "ruff>=0.8.4",
    "mypy>=1.13.0",
]

# Запуск скрипта
uv run python main.py

# Запуск застосунку
uv run uvicorn main:app --reload

# Запуск тестів
uv run pytest

# Запуск лінтера
uv run ruff check .

# uv run також може виконувати скрипти без встановлення:
# навіть якщо pytest не у залежностях — uv встановить тимчасово
uv run --with pytest pytest tests/

# Встановлення конкретної версії Python
uv python install 3.12
uv python install 3.11 3.13  # кілька версій одразу

# Перегляд доступних та встановлених версій
uv python list

# Прив'язка версії Python до проекту
uv python pin 3.12  # записує у .python-version

# Використання конкретної версії при ініціалізації проекту
uv init --python 3.11 legacy-service

# Запуск без встановлення (uvx = uv tool run)
uvx ruff check .          # запускає ruff для перевірки поточної директорії
uvx black myfile.py        # форматує файл
uvx httpie GET httpbin.org/get  # HTTP-клієнт для тестування API

# Встановлення інструментів глобально (available everywhere)
uv tool install ruff
uv tool install black
uv tool list               # список встановлених інструментів

# uv як прямий замінник pip (набагато швидший)
uv pip install requests
uv pip install -r requirements.txt
uv pip freeze > requirements.txt

# Створення venv через uv
uv venv .venv
source .venv/bin/activate

# Компіляція requirements (аналог pip-tools)
uv pip compile requirements.in -o requirements.txt

# Рекомендований спосіб (isolated installer)
curl -sSL https://install.python-poetry.org | python3 -

# macOS через Homebrew
brew install poetry

# Перевірка встановлення
poetry --version  # Poetry (version 1.8.x)

# Важливе налаштування: зберігати venv всередині проекту
# (замість ~/.cache/pypoetry/virtualenvs/)
poetry config virtualenvs.in-project true

# Новий проект з повною структурою
poetry new my-service

# Або ініціалізація інтерактивно у поточній папці
mkdir existing-project && cd existing-project
poetry init

[tool.poetry]
name = "my-service"
version = "0.1.0"
description = "Production-ready REST API"
authors = ["Developer <dev@example.com>"]
readme = "README.md"
packages = [{include = "my_service"}]

[tool.poetry.dependencies]
python = "^3.12"           # версія Python — обов'язкова
fastapi = ">=0.115.0"      # прямі залежності проекту
sqlalchemy = "^2.0"
pydantic = "^2.5"
uvicorn = {extras = ["standard"], version = "^0.32"}

[tool.poetry.group.dev.dependencies]  # група dev — не у production
pytest = "^8.0"
pytest-asyncio = "^0.24"
ruff = "^0.8"
mypy = "^1.13"
black = "^24.0"

[tool.poetry.group.test.dependencies]  # окрема група для тестів
httpx = "^0.28"            # HTTP-клієнт для тестування FastAPI
factory-boy = "^3.3"

[build-system]
requires = ["poetry-core"]
build-backend = "poetry.core.masonry.api"

# Встановлення залежностей з pyproject.toml (також синхронізує lock)
poetry install

# Встановлення без dev-залежностей (для production)
poetry install --without dev

# Додавання нової залежності (оновлює pyproject.toml і lock автоматично)
poetry add fastapi
poetry add "sqlalchemy>=2.0,<3.0"
poetry add uvicorn[standard]          # з extras

# Додавання dev-залежності
poetry add --group dev pytest
poetry add --group dev ruff black mypy

# Видалення залежності
poetry remove redis

# Оновлення всіх залежностей (в межах версійних обмежень)
poetry update

# Оновлення конкретного пакету
poetry update fastapi

# Запуск скрипта у середовищі проекту
poetry run python main.py

# Запуск застосунку
poetry run uvicorn my_service.main:app --reload

# Запуск тестів
poetry run pytest

# Запуск лінтера
poetry run ruff check .
poetry run mypy my_service/

# Або активувати середовище вручну (як у venv)
poetry shell   # відкриває нову оболонку з активованим середовищем
exit           # повернутись

# Віртуальні середовища
.venv/
venv/
env/

# Байткод та кеш
__pycache__/
*.py[cod]
*$py.class
*.pyo

# Артефакти збірки
dist/
build/
*.egg-info/
*.egg

# Тести та покриття
.pytest_cache/
.coverage
htmlcov/

# Типи та лінтери
.mypy_cache/
.ruff_cache/

# Середовище та секрети
.env
.env.local
*.env

# IDE
.idea/
.vscode/
*.swp

# Без анотацій — помилка знайдеться лише під час виконання
def get_user_age(user):
    return user["age"] + 1  # KeyError? TypeError? Дізнаємось пізно

# З анотаціями — mypy/Pyright знаходять помилки відразу
from typing import TypedDict

class User(TypedDict):
    name: str
    age: int

def get_user_age(user: User) -> int:
    return user["age"] + 1  # mypy: OK
    # return user["nme"] + 1  # mypy: ERROR — key "nme" не існує у User

# Встановлення
uv add --dev mypy
# або
pip install mypy

# Запуск для файлу
mypy main.py

# Запуск для всього проекту
mypy .

# Перевірка конкретного пакету
mypy my_package/

[tool.mypy]
python_version = "3.12"
strict = true              # найсуворіший режим — рекомендовано для нових проектів

# Що перевіряти
check_untyped_defs = true  # перевіряти навіть нетиповані функції
disallow_untyped_defs = true  # вимагати анотацій для всіх функцій
disallow_any_generics = true  # заборонити голі Generic (list замість list[str])
warn_return_any = true     # попереджати про return Any

# Що ігнорувати
ignore_missing_imports = true  # якщо бібліотека не має стабів

# Виключення конкретних модулів
[[tool.mypy.overrides]]
module = ["tests.*"]
disallow_untyped_defs = false  # у тестах дозволяємо без анотацій

from typing import Optional, Union
from collections.abc import Sequence

# TypedDict — словник зі строгою структурою
from typing import TypedDict

class Address(TypedDict):
    street: str
    city: str
    postal_code: str

class UserProfile(TypedDict, total=False):  # total=False — всі поля необов'язкові
    bio: str
    avatar_url: str

class User(TypedDict):
    id: int
    name: str
    email: str
    address: Address
    profile: UserProfile  # вкладений TypedDict

# Функція з повними анотаціями
def find_users_by_city(
    users: Sequence[User],
    city: str,
    limit: Optional[int] = None,
) -> list[User]:
    """Знаходить користувачів із зазначеного міста."""
    result = [u for u in users if u["address"]["city"] == city]
    if limit is not None:
        result = result[:limit]
    return result

# mypy перевірить:
# - що users є Sequence[User]
# - що city є str
# - що limit є Optional[int] (може бути None)
# - що функція повертає list[User]

# Встановлення через uv
uv add --dev pyright
# або глобально
uvx pyright --version

# Запуск
pyright .
pyright main.py --pythonversion 3.12

{
    "pythonVersion": "3.12",
    "venvPath": ".",
    "venv": ".venv",
    "typeCheckingMode": "strict",
    "include": ["src", "tests"],
    "exclude": ["**/__pycache__"],
    "reportMissingImports": true,
    "reportMissingTypeStubs": false,
    "reportUnknownVariableType": false
}

[tool.pyright]
pythonVersion = "3.12"
venvPath = "."
venv = ".venv"
typeCheckingMode = "strict"
include = ["src"]
exclude = ["**/__pycache__"]

# Додавання аналізаторів у dev-залежності
uv add --dev mypy pyright

# Запуск у CI/CD або pre-commit
uv run mypy .
uv run pyright .

# Часто використовують разом з ruff (лінтер)
uv add --dev ruff
uv run ruff check .
uv run ruff format .

[project]
name = "my-service"
version = "0.1.0"
requires-python = ">=3.12"
dependencies = ["fastapi>=0.115", "sqlalchemy>=2.0"]

[dependency-groups]
dev = ["mypy>=1.13", "pyright>=1.1", "ruff>=0.8", "pytest>=8.0"]

[tool.mypy]
python_version = "3.12"
strict = true
ignore_missing_imports = true

[tool.pyright]
pythonVersion = "3.12"
typeCheckingMode = "basic"
venvPath = "."
venv = ".venv"

[tool.ruff]
line-length = 88
target-version = "py312"

[tool.ruff.lint]
select = ["E", "F", "I", "UP"]

import math

# Ключові константи
print(f"pi: {math.pi}")      # 3.141592653589793
print(f"e: {math.e}")        # 2.718281828459045
print(f"inf: {math.inf}")    # Позитивна нескінченність
print(f"nan: {math.nan}")    # Not a Number (не число)

# Стратегії округлення
value = 5.67
print(f"Округлення вгору (ceil): {math.ceil(value)}")      # 6
print(f"Округлення вниз (floor): {math.floor(value)}")     # 5
print(f"Відкидання дробової частини (trunc): {math.trunc(value)}")  # 5

# Квадратний корінь
print(math.sqrt(25))  # 5.0 (завжди повертає float)

# Найбільший спільний дільник (НСД) та найменше спільне кратне (НСК)
print(math.gcd(48, 64))  # 16
print(math.lcm(48, 64))  # 192 (доступно в Python 3.9+)

# Логарифми
print(math.log(math.e))  # 1.0 (натуральний логарифм)
print(math.log2(1024))   # 10.0
print(math.log10(1000))  # 3.0

import random

# Дійсне число від 0.0 до 1.0
print(f"random(): {random.random()}")

# Ціле число в діапазоні [1, 10] включно
print(f"randint(1, 10): {random.randint(1, 10)}")

# Дійсне число в діапазоні [1.5, 9.5]
print(f"uniform(1.5, 9.5): {random.uniform(1.5, 9.5)}")

# Випадкове парне число від 0 до 100
print(f"randrange(0, 101, 2): {random.randrange(0, 101, 2)}")

cards = ["Туз", "Король", "Дама", "Валет", "10"]

# Вибір одного випадкового елемента
print(f"Випадкова карта: {random.choice(cards)}")

# Вибір кількох унікальних елементів (без повторень)
print(f"Роздача на двох: {random.sample(cards, 2)}")

# Перемішування списку на місці (модифікує оригінал!)
random.shuffle(cards)
print(f"Перемішана колода: {cards}")

random.seed(100)
print(random.randint(1, 100))  # Завжди виведе 19
print(random.randint(1, 100))  # Завжди виведе 59

random.seed(100)  # Скидаємо в ту саму початкову точку
print(random.randint(1, 100))  # Знову 19!

import datetime

# Поточні значення
now = datetime.datetime.now()
today = datetime.date.today()
print(f"Зараз: {now}")
print(f"Сьогодні: {today}")

# Створення конкретної дати
deadline = datetime.datetime(2026, 12, 31, 23, 59, 0)

# Розрахунок різниці (timedelta)
time_left = deadline - now
print(f"До дедлайну залишилося: {time_left.days} днів та {time_left.seconds // 3600} годин")

# Додавання інтервалу часу
future_date = today + datetime.timedelta(weeks=4)
print(f"Через 4 тижні буде: {future_date}")

from datetime import datetime
from zoneinfo import ZoneInfo

# Створення часу в часовому поясі Києва
kyiv_time = datetime.now(ZoneInfo("Europe/Kyiv"))
print(f"Київ: {kyiv_time}")  # Наприкінці з'явиться зміщення UTC: +03:00 (або +02:00)

# Конвертація в часовий пояс Нью-Йорка
ny_time = kyiv_time.astimezone(ZoneInfo("America/New_York"))
print(f"Нью-Йорк: {ny_time}")  # Час автоматично перераховується

import sys

# Аргументи командного рядка (наприклад: python main.py data.txt)
# sys.argv[0] — це завжди ім'я самого скрипта
print(f"Аргументи запуску: {sys.argv}")

# Платформа та версія
print(sys.platform)  # 'darwin' (macOS), 'win32' (Windows), 'linux' (Linux)
print(sys.version)   # Детальна версія інтерпретатора

# Безпечне завершення роботи скрипта з кодом виходу
# 0 = успіх, будь-яке інше число = помилка
sys.exit(0)

from collections import namedtuple

# Створюємо тип (фабрику) Geopoint з полями latitude та longitude
Geopoint = namedtuple("Geopoint", ["latitude", "longitude"])

# Створюємо екземпляр
kyiv = Geopoint(latitude=50.4501, longitude=30.5234)

# Звернення за іменами полів!
print(f"Широта: {kyiv.latitude}, Довгота: {kyiv.longitude}")

# Але це все ще кортеж (сумісність збережена)
print(f"Індекс 0: {kyiv[0]}")
lat, lon = kyiv  # Розпакування працює

from collections import defaultdict

# Словник, який за замовчуванням створює порожній список (list) для нових ключів
grouped_students = defaultdict(list)

# Нам не потрібно перевіряти, чи є ключ "Python" у словнику!
grouped_students["Python"].append("Олег")
grouped_students["Python"].append("Марія")
grouped_students["Go"].append("Іван")

print(grouped_students)
# defaultdict(<class 'list'>, {'Python': ['Олег', 'Марія'], 'Go': ['Іван']})

from collections import Counter

words = ["яблуко", "банан", "яблуко", "апельсин", "банан", "яблуко"]
counter = Counter(words)

print(counter)  # Counter({'яблуко': 3, 'банан': 2, 'апельсин': 1})
print(f"Кількість бананів: {counter['банан']}")
print(f"Кількість неіснуючих елементів: {counter['груша']}")  # Повертає 0 замість KeyError!

# Отримання топ-N найпопулярніших елементів
print(f"Найпопулярніші: {counter.most_common(2)}")  # [('яблуко', 3), ('банан', 2)]

from collections import deque

queue = deque(["Користувач 1", "Користувач 2"])

# Швидке додавання в кінець
queue.append("Користувач 3")

# Швидке додавання на початок
queue.appendleft("VIP Користувач")
print(queue)  # deque(['VIP Користувач', 'Користувач 1', ...])

# Видалення з обох кінців
first_in = queue.popleft()  # 'VIP Користувач'
last_in = queue.pop()       # 'Користувач 3'

# 1. Створити директорію проекту
mkdir my-awesome-project
cd my-awesome-project

# 2. Ініціалізувати git-репозиторій (опціонально, але рекомендується)
git init

# 3. Створити файл .gitignore — ОДРАЗУ, до будь-яких комітів
cat > .gitignore << 'EOF'
# Віртуальне середовище — ніколи не комітимо!
.venv/
venv/

# Байткод Python
__pycache__/
*.pyc
*.pyo

# Середовища та IDE
.env
.DS_Store
.idea/
.vscode/
EOF

# 4. Створити та активувати venv
python -m venv .venv
source .venv/bin/activate  # (.venv) з'явиться у промпті

# 5. Встановити залежності проекту
pip install requests django pytest

# 6. Зафіксувати залежності
pip freeze > requirements.txt

# 7. Написати код...

# 8. Перед завершенням — оновити requirements.txt
pip freeze > requirements.txt
git add requirements.txt
git commit -m "chore: update dependencies"