Алан Гибизов

Потому что 876544 / 8 = 109568. Любая математическая задача начинается с расчёта областей определения и значения.

Описание не до конца понятно, но судя по всему кто-то от имени юзера делает запросы в Поисковик, чтобы собирать статистику на какой позиции в выдаче нужный сайт. Обычно такое через API запросы собирают, но там есть ограничения по количеству запросов.

Специалист который занимается, ответами на данный вопрос называется продуктовый аналитик. Основная их работа это выдвижение гипотез в условиях недостаточности данных. Иными словами сведение к математическому виду определенного утверждения.

Все твои вопросы не являются общедоступной информацией, это знает владелец продукта, иногда он может сделать эту информацию публичной, иногда нет. Другой способ, это простое проведение опросов, и оценка интересующей статистики на основе случайных выборок.

Абсолютно неважно, что было до интересующего вас события. Важно лишь сколько каких шаров было в мешке в момент события.

Найдите 10 отличий =)







PS

Правильнее вот такую аннотацию сделать

/* @var null|\App\Models\User $user */
$user = Auth::user();

Всё-таки этот метод может и null вернуть.

Рекурсивно делай. Опиши требуемую функцию:

def filter_fields(obj: dict[str, ...], fields: list[str]) -> dict[str, ...]:
    """obj - фильтруемый словарь, fields - множество полей, которые надо оставить."""
    ...

Проблема в том, что поля могут быть вложенным. Тогда первым делом составляешь набор нужных тебе полей верхнего уровня:

top_level_fields = {}
for f in fields:
    top, _, bottom = f.partition('.')
    top_level_fields.setdefault(top, [])
    if bottom is not None:
        top_level_fields[top].append(bottom)

Для

fields=['boardId', 'name', 'Data.Matches.t.id', 'Data.Matches.m']

в top_level_fields получишь

{ 'boardId': [], 'name': [], 'Data': ['Matches.t.id', 'Matches.m']}

Дальше перебираешь поля, собираешь их значения в один мешок и смотришь, есть ли для них нижележащие поля:

output = {}
for top, bottom in top_level_fields.items():
    if bottom:
        output[top] = filter_fields(obj[top], bottom)  # что делать, если ключа top нет?
    else:
        output[top] = obj[top]

Таким образом наберёшь всё, что надо.

Почитай про импорты в питоне, какой-нибудь толковый учебник (типа Лутца).
Ты делаешь относительный импорт (import .something), но это можно использовать только в крупных модулях проекта, а не в корневых файлах. Импортируй как обычно, без точки.

try: 
    loop.create_task(exc())
except ZeroDivisionError as ex:
    print(f"Ошибка {ex} обработана")

1. Ты создаёшь задачу на базе корутины exc(). Созданная задача не выполнится немедленно, а только встанет в очередь исполнения (хотя в питоне 3.12 это поведение можно изменить, но по умолчанию это так). При этом с корутиной ассоциируется future-объект, который находится в состоянии "ожидание", так как корутина ещё не завершила работу.
2. Ты проверяешь, не возникло ли исключение в процессе создания задачи. Это может произойти, только если exc() - не корутина. В остальных случаях операция будет успешна независимо от содержания exc(), так как см. пункт 1.
3. Ты вызываешь loop.run_forever(). Рабочий цикл (loop) смотрит в очередь исполнения, и видит в нём только корутину exc(). Она получает управление.
4. Корутина exc() выбрасывает исключение, но не ловит его. Ассоциированный с корутиной future-объект переходит из состояния "ожидание" в состояние "отказ", и сохраняет информацию об исключении. exc() завершает работу.
5. Рабочий цикл проверяет, кто хранит ссылку на task - и понимает, что никто. Как следствие, даже в будущем никто не сможет узнать, что корутина выкинула исключение. Поскольку рабочий цикл - штука типовая, он понятия не имеет, что делала наша корутина и как надо реагировать на исключение в ней. А потому единственный вариант для него - написать в журнал работы о непойманном исключении и надеяться, что программист это увидит и поправит.

task = asyncio.create_task(exc())
try:
    # await asyncio.gather(task)  # <- gather() не нужно, если у тебя одна задача
    await task
except ZeroDivisionError as ex:
    print(f"Ошибка {ex} обработана")

1. Ты создаёшь задачу (успешно), а потом с помощью await-вызова просишь дождаться её завершения и получить результат.
2. Корутина main() приостанавливает своё выполнение и сохраняет свой контекст, а также встаёт в очередь, ожидая, когда сработает future-объект, связанный с task.
3. Рабочий цикл (loop) asyncio смотрит в очередь выполнения и видит, что корутина exc() готова выполняться (она не находится в await вызове, а только начала работу).
4. Корутина exc() получает управление, выполняется, и генерирует исключение, которое не поймано внутри этой корутины. Future-объект, связанный с этой корутиной, переходит из состояния "ожидание" в состояние "отказ", и сохраняет информацию об исключении. Корутина exc() завершает выполнение. При этом о её future-объекте знает корутина main(), поэтому рабочий цикл не дёргается по этому поводу - у main() будет возможность отреагировать на происходящее.
5. Рабочий цикл (loop) смотрит в очередь выполнения и видит, что там только корутина main(), причём она готова выполняться - future-объект, который она ждёт, более не находится в состоянии ожидания.
6. Корутина main() получает управление и восстанавливает свой контекст, продолжая с того места, где она остановилась. Так как future-объект находится в состоянии "отказ", оператор await читает из него информацию об исключении и перевыбрасывает это исключение внутри main().
7. Это исключение обрабатывается блоком try-except в main() как обычно.