Почему Python "упреждающе" висит, пытаясь вычислить очень большое число?

Ответ 1

TL;DR: Python предварительно вычисляет константы в коде. Если какое-либо очень большое число вычисляется по меньшей мере с одним промежуточным шагом, процесс будет ограниченным временем процессора.

Потребовалось довольно много поиска, но я обнаружил доказательства того, что Python 3 делает прекомпрессию постоянных литералов, которые он находит в коде, прежде чем оценивать что-либо. Одна из них - это веб-страница: Оптимизатор Peephole для Python. Я привел некоторые из них ниже.

ConstantExpressionEvaluator

Этот класс предварительно вычисляет ряд константных выражений и сохраняет их в списке констант функций, включая очевидные двоичные и унарные операции и кортежи, состоящие из простых констант. Особо следует отметить тот факт, что сложные литералы не представлены компилятором как константы, а как выражения, поэтому 2 + 3j появляется как

LOAD_CONST n (2) LOAD_CONST m (3j) BINARY_ADD

Этот класс преобразует их в

LOAD_CONST q (2+3j)

что может привести к довольно большому повышению производительности для кода, который использует сложные константы.

Тот факт, что 2+3j используется в качестве примера, очень сильно предполагает, что не только небольшие константы предварительно вычисляются и кэшируются, но и любые константные литералы в коде. Я также нашел этот комментарий в другом вопросе о переполнении (Являются ли постоянные вычисления кэшированными в Python?):

Обратите внимание, что для Python 3 оптимизатор глазок прекомпретирует константу 1/3. (Конкретный CPython, конечно.) - Марк Дикинсон 7 октября в 19:40

Это подтверждается тем фактом, что замена

y = 10**(10**10)

с этим также зависает, хотя я никогда не вызываю функцию!

def f():
    y = 10**(10**10)

Хорошие новости

К счастью для меня, у меня нет таких гигантских литералов в моем коде. Любое вычисление таких констант произойдет позже, что может быть ограничено временным пределом ЦП. Я изменил

y = 10**(10**10)

x = 10
print(x)
y = 10**x
print(y)
z = 10**y
print(z)

и получил этот выход по желанию!

-1 -1
10
10000000000
ran out of time!

Мораль истории: Ограничение процесса по времени процессора или потреблению памяти (или некоторому другому методу) будет работать, если в коде, который Python пытается прекомпопутировать, нет большой константы литерала.

Ответ 2

Используйте функцию.

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

Пример:

import resource
import os
import signal

def timeRanOut(n, stack):
    raise SystemExit('ran out of time!')
signal.signal(signal.SIGXCPU, timeRanOut)

soft,hard = resource.getrlimit(resource.RLIMIT_CPU)
print(soft,hard)
resource.setrlimit(resource.RLIMIT_CPU, (10, 100))

f = lambda x=10:x**(x**x)
y = f()

Это дает ожидаемый результат:

[email protected]:~/Desktop$ time python3 hang.py
-1 -1
ran out of time!

real    0m10.027s
user    0m10.005s
sys     0m0.016s