Int too large to convert to float питон ошибка

Python float() function is used to return a floating-point number from a number or a string representation of a numeric value.

Python float() Function syntax

Syntax:  float(x)

Parameter x: x is optional & can be:

• any number or number in form of string, ex,: “10.5”
• inf or infinity, NaN (any cases)

Return: Float Value

Python float() Function example

Output:

10.0

Values that the Python float() method can return depending upon the argument passed

• If an argument is passed, then the equivalent floating-point number is returned.
• If no argument is passed then the method returns 0.0.
• If any string is passed that is not a decimal point number or does not match any cases mentioned above then an error will be raised.
• If a number is passed outside the range of Python float then OverflowError is generated.

Python float() example

Example 1: How Python float() works

Output: 

21.89
8.0
23.0
-16.54
-24.45
inf
inf
nan
nan

All lines are executed properly but the last one will return an error: 

Traceback (most recent call last):
  File "/home/21499f1e9ca207f0052f13d64cb6be31.py", line 25, in 
    print(float("Geeks"))
ValueError: could not convert string to float: 'Geeks'

Example 2: float() for infinity and Nan

Output:

inf
inf
nan
nan

Example 3: Converting an Integer to a Float in Python

Output:

90.0

Example 4: Converting a String to a Float in Python

Output:

90.0

Example 5: Python float() exception

float() will raise ValueError if passed parameter is not a numeric value.

Output:

could not convert string to float: 'geeks'

Example 6: Python float() OverflowError

float() will raise OverflowError if passed parameter is too large (ex.: 10**309)

Output:

Traceback (most recent call last):
  File "/home/1eb6a2abffa536ccb1cae660db04a162.py", line 1, in <module>
    print(float(10**309))
OverflowError: int too large to convert to float

В этой теме:
1.1. Базовые операции. Сложение(+), вычитание(-), умножение(*), возведение в степень (**), извлечение корня (**0.5). Функция pow(). Модуль числа, функция abs(). Очерёдность выполнения множественных операций.
1.2. Типы чисел: int, float, complex. Преобразование типов. Проверка типа, функция type().
1.3. Округление чисел. Функция round(). Точность округления числа.
1.4. Операция деления (/). Целочисленное деление (//). Остаток от целочисленного деления (%). Функция divmod().
1.5. Проверка на равенство (==). Значения True и False как результат сравнения. True и False как числа. Математические знаки больше (>), больше или равно (>=), не равно (!=), меньше или равно (<=), меньше (<).
1.6. Системы счисления. Функции bin(), oct(), int(), hex() для преобразования в двоичную, восьмеричную, десятичную и шестнадцатиричную системы. Преобразование в систему счисления 0 и от 2 до 36 через функцию int().
1.7. Великий random. Генерация случайного числа. Генерация числа в заданных пределах. Особенность границ включения в диапазон.
1.8. Плюшки. Бесконечность, float(‘inf’), float(‘-inf’), float(‘nan’). Перезапуск оболочки (Ctrl-F6 и Ctrl-C). Отношение двух целых чисел (дробь) как отображение вещественного числа, методы as_integer_ratio(), is_integer(), hex(), fromhex().
1.9. Возможные ошибки. Краткое описание ошибок, выдаваемых консолью.
1.10. Думай как интерпретатор.
Рассматриваются не здесь: модули math, numpy, decimal, fraction. Функции алгебры, вычисление синусов и косинусов. Нахождение минимального и максимального числа в последовательности чисел.

После открытия консоли Python, в последней строке находятся три треугольных скобки, это приглашение к вводу:

Python 3.7.1 (v3.7.1:260ec2c36a, Oct 20 2018, 14:05:16) [MSC v.1915 32 bit (Intel)] on win32
Type "help", "copyright", "credits" or "license()" for more information.
>>> 

Всегда, когда Вы видите приглашение, это означает, что консоль ожидает действий от пользователя. Если до этого выполнялись какие-то операции, то с появлением приглашения они завершили своё выполнение, если какую-то работу выполняла программа, она также завершила свою работу и передала управление консоли.

Для выполнения базовых операций с числами можно сразу приступать к вычислениям.

1.1. Базовые операции.

Операция сложения:

>>> 20+22
42
>>> 3+-5
-2
>>> 3+(-5)
-2
>> -3+(-5)
-8

Пробелы между числами и математическими знаками игнорируются, поэтому все эти записи равнозначны:

>>> 20+22
42
>>> 20 + 22
42
>>> 20    +     22
42

Что, однако, не означает, что можно дробить само число или начинать ввод с пробела:

>>> 2 0 + 2 2
SyntaxError: invalid syntax
>>>  20 + 22
SyntaxError: unexpected indent

Также нельзя ставить ноль в начале числа (за исключением записи «ноль целых»):

>>> 05 + 10
SyntaxError: invalid token
>>> 0.5 + 10
10.5
>>> 0 + 5
5

Операция вычитания:

>>> 128-5
123

>>> 128--5
133

>>> 128-(-5)
133

Операции умножения (*) и возведения в степень (**):

>>> 7*3
21

>>> 12**2
144

Извлечение корня возможно через возведение в степень 1/2:

>>> 144**0.5
12.0
>>> 144**(1/2)
12.0

Обратите внимание, что в примере выше степень 1/2 заключена в скобки, поскольку вычисление степени в нашем случае приоритетнее возведения в степень. По умолчанию (если скобок не будет), в первую очередь выполнится 144**1, а затем результат будет разделён на 2.

Для работы со степенями числа также есть встроенная функция pow(), принимающая число и его степень:

>>> pow(12, 2)
144 
>>> pow(144, 0.5)
12.0
>>> pow(10, -2)
0.01

Если передать в pow() третий аргумент, то будет вычислено возведение в степень по модулю (при этом первые два числа должны быть положительными целыми числами):

>>> pow(125, 5, 3)
2

При вводе числа с плавающей точкой, ввод «ноль целых» можно игнорировать:

>>> 16**.5
4.0
>>> .5+.5
1.0

Нахождение модуля числа производится с помощью функции abs():

>> abs(-42)
42
>>> abs(34)
34

Множественные операции по очерёдности выполнения следуют математическим правилам:

1. возведение в степень — справа налево (2**2**3 = 256)
2. извлечение корня
3. операции в скобках
4. умножение и деление
5. сложение и вычитание

>>> 3+5*(6*8)
243

>>> 2+2*2
6

>>> 3**2*2
18

1.2. Типы чисел.

В Python есть два основных типа чисел: целые, тип int (от англ. integer), и числа с плавающей точкой (вещественные), тип float. Несмотря на разные типы, математические действия между ними всё равно выполняются (в таком случае оба числа автоматически приводятся к типу float, поэтому результат получается с точкой, даже если число после выполнения операции целое):

>>> 2.0+2.0
4.0

>>> 5+2.0
7.0

Также существует такой тип как complex для работы с комплексными числами. Комплексные числа состоят из вещественной и мнимой части, обозначаемой заглавной или прописной буквой j. Над ними доступно совершение большинства базовых операций (+, -, *, /, ==). В повседневной жизни таким числам сложно найти применение, однако, знать об их существовании нужно:

>>> 3.5+2j + 2.4+3j
(5.9+5j)
>>> 3.5+2j * 2.4+3j
(3.5+7.8j)

Любое целое число можно преобразовать в вещественное, и наоборот. Необходимо помнить, что при преобразовании float в int происходит отбрасывание части после точки без всяческого округления:

>>> float(132)
132.0
>>> int(6.95)
6

Проверка типа осуществляется функцией type():

>>> type(12)
<class 'int'>
>>> type (12.5)
<class 'float'>
>>> type(1.2j+2j)
<class 'complex'>

1.3. Округление числа. Точность округления.

Округление числа можно осуществить через функцию round():

>>> round(5.5)
6
>>> round(5.49)
5

Граница округления проходит через ближайшее чётное (так называемое банковское округление):

>> round(2.65, 1)
2.6
>>> round(2.75, 1)
2.8

В функции round() вторым аргументом через запятую можно также указать, до какого знака после запятой нужно произвести округление:

>>> 12**0.5
3.4641016151377544
>>> round(12**0.5, 3)
3.464

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

>>> round(1234.5678, -2)
1200.0
>>> round(12345.5678, -2)
12300.0

Вычисления с плавающей точкой имеют ряд особенностей:

>>> 0.1+0.1+0.1+0.1+0.1+0.1+0.1+0.1+0.1+0.1
0.9999999999999999
>> 0.1+0.2+0.3-0.1
0.5000000000000001

Такое поведение связано со сложностью вычисления вещественных чисел, и это нужно иметь ввиду. Также есть ограничения на чересчур затратные для памяти вычисления:

>>> 4**1000
1148130695274254524232833201177681984022317702088695200477
6427368257662613923703138566594863165062699184459646389874
6277344711896086305533142593135616665318539129989145312280
0006887791482400448714289269900634862447816154636463883639
4731702604046635397090499655816239880894462960562331164953
6164221970332681344168908984458505602379484807914058900934
7765004290027167066258305220081322362812917612678833172065
9899539641812702177985840404215985318325154088943390209192
0554957783589672039160081957216630582755380425583726015528
3487864194320545089152757838826251754355288008228427708179
65453762184851149029376

Четыре в степени одна тысяча? Легко. А две целых пять десятых в той же степени?

>>> 2.5**1000
Traceback (most recent call last):
    ...
OverflowError: (34, 'Result too large')

Дела могут обстоять даже немного хуже:

>> 4**1000+0.1
Traceback (most recent call last):
   ...
OverflowError: int too large to convert to float

Или совсем плохо:

>>> 0.1+0.1+0.1-0.3
5.551115123125783e-17

Странная запись 5.551115123125783e-17 обозначает число, равное 5.551115123125783, помноженному на 10 в степени -17 (экспоненциальное представление числа). Немного не тот результат, что ожидается, не правда ли? Для решения такого рода задач существуют модули вроде NumPy, Decimal и Fraction, которые способны обрабатывать вещественные числа с большей точностью либо менять их представление (например, хранить их в виде дроби). Однако эта тема заслуживает отдельной статьи, пока же просто констатируем факт: с вещественными числами всё сложно. И не только в Python. Если интересно, можете погуглить стандарт IEEE 754-2008, описывающий формат представления чисел с плавающей точкой для компиляторов языков программирования, а если математика — Ваша основная сфера применения Python, то стандарт к прочтению обязателен.

В повседневных вычислениях экспоненциальная запись немного упрощает жизнь:

>>> int(10e7)
100000000 
>>> float(10e-5)
0.0001

1.4. Операция деления.

И, наконец, операция деления. Важно помнить, что результат деления — всегда число типа float, даже если деление происходит без остатка:

>>> 20/4
5.0
>>> 22/4
5.5

Также поддерживается целочисленное деление:

>>> 22//4
5

Особенность целочисленного деления на отрицательное число, которую нужно знать («строгое» вычисление, отличное от логики, заложенной в процессоры Intel):

>>> 3/2
1.5
>>> 3/-2
-1.5
>>> 3//2
1
>>> 3//-2
-2

Можно получить остаток от целочисленного деления:

>>> 22%4
2

Или оба эти числа сразу, воспользовавшись функцией divmod():

>>> divmod(22, 4)
(5, 2)

1.5. Проверка на равенство. True и False.

Проверка на равенство осуществляется при помощи двойного знака равно, в ответ консоль вернёт True (если сравниваемые объекты между собой равны) или False (если различны).

>>> 3 == 4
False
>>> 3.0 == 3
True
>> 6.8**2 == 6.8*6.8
True

Также можно применять математические знаки «больше», «больше или равно», «меньше», «меньше или равно», «не равно».

>>> 3 >= 3
True
>>> 2+2*2 != (2+2)*2
True
>> 3 < 6 < 9
True

True и False являются довольно важными словами в языке Python. Их практическое применение будет понятно немного позже, пока же стоит знать, что в математическом смысле они также являются числами, что довольно удобно при выполнении некоторых операций. True является единицей, а False — нулём. Из этого могут получаться вот такие необычные конструкции:

>>> True + True
2
>>> 9 - True
8
>>> False - True
-1
>>> 0 == False
True

1.6. Системы счисления. Преобразования из одной системы в другую.

Перевод из одной системы счисления в другую возможен через специальные инструкции. Перевод числа 125 из десятичной (т. е. обычной) системы в двоичную возможен через функцию bin():

>> bin(125)
'0b1111101'

, где 0b — указание на систему счисления и 1111101 — само число. По аналогии устроено преобразование в восьмеричную (oct) и шестнадцатиричную (hex) системы:

>>> oct(125)
'0o175'
>> hex(125)
'0x7d'

0b или 0B — bin() — двоичная система
0o или 0O — oct() — восьмеричная
0x или 0X — hex() — шестнадцатиричная

Десятичная система — int() — в специальном обозначении не нуждается и используется по умолчанию. Чаще всего преобразование чисел требуется для проведения операций над битами (от англ. bit — бит, единица информации).

Функция type(), поверяющая тип переданного ей объекта, понимает разные системы счисления и относит их к одному объемлющему целочисленному типу int.

>>> type(0b01101)
<class 'int'>

Переводы из одной системы счисления в другую:

>>> int(0b1111101)
125
>>> 0b1111101
125
>>> hex(0o175)
'0x7d'

Помимо встроенных преобразователей bin, oct и hex можно также перевести число в другую систему счисления (по основанию 0 или от 2 до 36) при помощи инструкции int(). С её помощью мы уже преобразовывали вещественные числа в натуральные, однако возможности у этой функции гораздо шире. В качестве первого аргумента нужно передать число в кавычках (двойных или одинарных), а в качестве второго — систему счисления.

>>> int('125', 7)
68
>>> int('0b1101', 2)
13

Данные, заключённые в одинарные или двойные кавычки (или в одинарные, или в двойные, какой кавычкой открывается строка, такая же должна быть и в конце), представляют ещё один тип данных в python — тип str, строка (от англ. string). Это нечисловой тип, предназначенный для хранения строк, и цифры хранятся в нём как обычные символы, что не мешает преобразовывать их в числа с помощью уже известных нам функций int() и float().

>>> int('125')
125
>>> float("125")
125.0

Всё работает по общему правилу — пробелы при преобразовании игнорируются, само число разбивать нельзя:

>>> int('   125   ')
125
>>> int('1 2 5')
Traceback (most recent call last):
    ...
ValueError: invalid literal for int() with base 10: '1 2 5'

Однако в int() нельзя передать строку с вещественным числом:

>>> int('125.5')
Traceback (most recent call last):
    ...
ValueError: invalid literal for int() with base 10: '125.5'

Один из возможных способов преобразования строки с вещественным числом в целое:

>>> int(float('125.5'))
125

Первым действием выполнится float('125.5'), результат будет равен числу 125.5, и оно уже передастся в функцию int(). Запись может быть сколько угодно более сложной:

>>> int(float(int(hex(125),16)+25)/5)
30

Кто сказал, что без бутылки не разобраться? Это ещё не самый клинический случай. Вычисления всегда начинаются внутри наиболее глубоко вложенных скобок. Алгоритм вычисления будет следующим:

>>> int(float(int(hex(125),16)+25)/5)
30
>>> hex(125)
'0x7d'
>>> int('0x7d',16)
125
>>> float(125+25)
150.0
>>> int(150.0/5)
30

1.7. Великий random

Довольно часто при написании игр и тестировании приложений используется генератор случайных чисел, также известный как random. По умолчанию модуль random не инициализируется при запуске консоли, поэтому его нужно вызвать инструкцией import:

>> import random
>>>

Если после нажатия Enter консоль вернулась к приглашению ввода (>>>), значит, модуль импортировался успешно, если произошла ошибка ModuleNotFoundError, то проверьте правильность написания введённой команды. Если ошибки не произошло, есть возможность сгенерировать случайное вещественное число в диапазоне от 0 до 1:

>>> random.random()
0.9165752832402418
>>> random.random()
0.6594673776450634

Или целое число, воспользовавшись инструкцией random.randint() и задав в скобках нижнюю и верхнюю границы предела:

>>> random.randint(1, 10)
9
>>> random.randint(1, 10)
2

Здесь стоит обратить внимание на то, что верхняя граница предела в диапазон не входит, то есть по факту будет выбрано любое число от 1 до 9. Для генерации числа от 1 до 10, необходимо будет указать границы как (1, 11).

Передавая на исполнение random.randint() мы даём указание воспользоваться функцией randint(), расположенной в модуле random. Точка в данном случае говорит о том, что мы обращаемся к конкретной функции импортированного модуля. Если вызвать функцию без указания модуля, произойдёт ошибка:

>>> randint(1, 10)
Traceback (most recent call last):
    ...
NameError: name 'randint' is not defined

Строго говоря, если Вам хочется копнуть немного глубже, randint — это метод класса Random, расположенного в модуле random. Функции в классе называются методами. Теперь живите с этим.

>>> import random
>>> type(random)
<class 'module'>
>>> type(random.randint)
<class 'method'>

1.8. Плюшки.

В процессе использования Python как продвинутого калькулятора, иногда возникает потребность произвести ещё какую-либо операцию над последним выведенным результатом. Например, мы высчитывали площадь окружности радиусом 100 миллиметров (по формуле пи-эр-квадрат):

>>> 3.1415926*100**2
31415.926

и теперь нам нужно вычислить площадь сегмента, равную 1/3 площади окружности. Конечно же, можно поступить так:

>>> 31415.926/3
10471.975333333334

но ленивые программисты знают, что обратиться к последнему выведенному в консоли результату можно и при помощи знака подчёркивания _:

>>> 3.1415926*100**2
31415.926
>>> _/3
10471.975333333334
>>> round(_)
10472

Вряд ли Вам когда-нибудь пригодится это знание, но бесконечность в python обозначается как float('inf') или float('+inf'). Любое число в сравнении с ним всегда будет меньше. Введите, к примеру, такую строку и идите пить кофе:

>>> 1000000000**1000000 > float('inf')
|

Мигающий курсор в начале следующей строки говорит нам о том, что консоль производит вычисления и ввод данных приостановлен. Спустя несколько минут (всё зависит от быстродействия Вашего компьютера), результат будет выведен на экран:

>>> 1000000000**1000000 > float('inf')
False

после чего ввод данных снова будет доступен. Всегда, когда Вы видите мерцающий курсор в самом начале строки, это означает, что консоль занята выполнением какой-то задачи. Иногда также это свидетельствует и о том, что в коде есть очень затратные по времени исполнения вычисления (как в нашем случае), либо мы создали бесконечный цикл, и тогда ждать окончания исполнения нет никакого смысла. Для перезапуска оболочки нажмите Ctrl-F6. В некоторых случаях достаточно бывает просто остановить выполнение операции, для этого используется комбинация Ctrl-C (клавиатура при этом должна находиться в английской раскладке), но в данном случае она не поможет.

>>> 1000000000000000000000**100000000000000
|
... понимаем, что вычисления будут длиться очень долго ...
... нажимаем <Ctrl-F6> ...

===================== RESTART: Shell =====================
>>> 

Похожая история с минус бесконечностью, для неё существует нотация float('-inf') (а также -float('inf')) и любое число в сравнении с ней всегда будет больше.

А теперь внимание, минутка бредовых идей. Вычтем из бесконечности минус бесконечность!

>>> float('inf') - float('-inf')
inf

Итак, inf круче. Давайте умножим:

>>> float('+inf') * float('-inf')
-inf

Давайте сложим:

>>> float('inf') + float('-inf')
nan

Про nan мы ещё ничего не знаем, но можем проверить его на тип:

>>> type(_)
<class 'float'>

Объект float('nan') говорит нам о том, что результат не является числом (‘not a number’).

>>> float('nan') == 0
False
>>> float('nan') == False
False

Добавим ещё немного треша:

>>> float('nan') == float('nan')
False

и окажется, что nan даже не равен самому себе! Более подробно про NaN и возможные причины его появления при расчётах можно почитать здесь: https://ru.wikipedia.org/wiki/NaN. А пока запомним, что NaN — особое состояние float(), не являющееся числом.

При помощи as_integer_ratio() можно вычислить отношение двух целых чисел для отображения вещественного (и только вещественного!) числа:

>>> (5.4).as_integer_ratio()
(3039929748475085, 562949953421312)
>>> 3039929748475085/562949953421312
5.4
>>> float.as_integer_ratio(5.2)
(5854679515581645, 1125899906842624)

Проверка на целость вещественного числа:

>>> (5.4).is_integer()
False
>>> float.is_integer(15.5)
False
>>> float.is_integer(15.0)
True

Функция hex() не умеет переводить вещественные числа в шестнадцатиричную систему:

>>> hex(15.5)
Traceback (most recent call last):
    ...
TypeError: 'float' object cannot be interpreted as an integer

А вот float.hex() — может:

>>> float.hex(16.5)
'0x1.0800000000000p+4'

И обратно:

>>> float.fromhex('0x1.0800000000000p+4')
16.5

1.9. Возможные ошибки.

Пресловутое деление на 0 выдаст ошибку ZeroDivisionError:

>> 7/0
Traceback (most recent call last):
    ...
ZeroDivisionError: division by zero

При выражении 144**1/2 кто-то, возможно, предполагает, что получит результат вычисления корня из числа 144, однако, в первую очередь (см. выше порядок выполнения операций) произойдёт возведение в степень (144**1), а затем — деление на 2, поэтому дробную степень числа нужно заключить в скобки, иначе результат будет неожиданным:

>>> 144**1/2
72.0
>> 144**(1/2)
12.0

При умножении числа на результат в скобках отсутствие знака умножения вызовет ошибку:

>>> 3(25-14)
Traceback (most recent call last):
    ...
TypeError: 'int' object is not callable
>> 3*(25-14)
33

Некоторые наиболее часто встречающиеся ошибки

SyntaxError: invalid syntax
Синтаксическая ошибка: неверный синтаксис
Ошибка появляется при разборе кода интерпретатором (парсинге кода), когда нет возможности однозначно истолковать введённую команду. При этом стрелка в теле ошибки (^), либо красный маркер укажет на предполагаемое место возникновения ошибки.

SyntaxError: unexpected indent
Синтаксическая ошибка: неожиданный отступ
Отступы — очень важная часть в языке Python, они являются частью кода и поэтому беспорядочно ставить пробелы В НАЧАЛЕ СТРОК нельзя.

OverflowError: (‘Result too large’)
Ошибка переполнения: результат слишком велик.
При вычислении числа выделенная под эту операцию память переполнилась.

OverflowError: int too large to convert to float
Ошибка переполнения: int слишком велик для преобразования в float.
Нет возможности преобразовать целое число в вещественное из-за ограничения памяти.

ValueError: invalid literal for int() with base 10
Ошибка значения: неверный литерал для int() по основанию 10.
Ошибка возникает, когда в int() в качестве аргумента передаётся строка, которую невозможно преобразовать в число.

TypeError: int() can’t convert non-string with explicit base
Ошибка типа: int() не может конвертировать не-строку с выбранным основанием.
Возникает, когда в качестве аргумента передаётся число, в то время как ожидается строка.

TypeError: ‘float’ object cannot be interpreted as an integer
Ошибка типа: объект float не может быть обработан как int.

ZeroDivisionError: division by zero
Ощибка деления на ноль: деление на ноль.

TypeError: ‘int’ object is not callable
Ошибка типа: объект int() не вызван.

1.10. Думай как интерпретатор.

Что консоль выведет на экран?

>>> float(2**(8-3))                                    # 1
>>> int(float('123"))                                  # 2
>>> 5/2 == 5//2 + 5%2                                  # 3
>>> 0/5 == False                                       # 4

Задача 1. Ответ: 32.0
Сначала начнёт выполняться операция возведения в степень числа 2, для этого необходимо будет вычислить результат в скобках, 8-3 = 5. Два в пятой степени это 2*2*2*2*2 = 32. Приведение к вещественному числу даст ответ 32.0.

Задача 2. Ответ: ошибка
В строке использованы разные типы кавычек. Будет вызвано исключение SyntaxError: EOL while scanning string literal.

Задача 3. Ответ: False
5/2 = 2.5, 5//2 = 2, 5%2 = 1, 2+1 = 3. 2.5 не равно 3.

Задача 4. Ответ: True
0/5 = 0. Деление на ноль выдаст ошибку, а вот сам ноль прекрасно делится. False в математическом смысле, как мы помним, равен нулю, следовательно наше утверждение сводится к тому, что 0 == 0, а это True.

Comments

>>> pub, priv = phe.generate_paillier_keypair()
>>> a = pub.encrypt(445)
>>> b = pub.encrypt(0.16413409062205825) + pub.encrypt(2 ** -965)  # Force big exponent.
>>> priv.decrypt(a + b)
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
  File "/Users/jakub/Repositories/python-paillier/phe/paillier.py", line 290, in decrypt
    return encoded.decode()
  File "/Users/jakub/Repositories/python-paillier/phe/encoding.py", line 220, in decode
    return mantissa * pow(self.BASE, self.exponent)
OverflowError: int too large to convert to float