Как найти дробную часть числа питон

Теги: python, int, программирование на python, функции, операции, число, целые числа, возведение в степень, вывести дробную часть, комплексные числа, вещественные числа

Представление чисел в Python 3 не отличается от обычных математических чисел. И поддерживают такие числа самые обыкновенные операции: сложение, вычитание, умножение, деление, возведение в степень, получение дробной части и т. п.

Целые числа (int)

Ниже вы можете увидеть стандартные Python-операции, в которых используется целое число (int):

Кроме того, числа int в Python 3 поддерживают длинную арифметику в отличие от некоторых других языков программирования. Однако для этого требуется больше памяти.

Битовые операции

Над числами int в Python можно выполнять и битовые операции. К примеру, a | b — это побитовое “или”. Есть и другие варианты:

Дополнительные методы и операции в Python

В эти операции входят:
• int.bit_length() — количество бит, которое необходимо, чтобы представить число в двоичном виде без учёта лидирующих нулей и знака;
• int.to_bytes(length, byteorder, *, signed=False) — метод возвращает строку байтов, которые представляют это число;
• classmethod int.from_bytes(bytes, byteorder, *, signed=False) — возвращение числа из заданной строки байтов.

Пример работы последнего метода:

>>>
>>> int.from_bytes(b'x00x10', byteorder='big')
16
>>> int.from_bytes(b'x00x10', byteorder='little')
4096
>>> int.from_bytes(b'xfcx00', byteorder='big', signed=True)
-1024
>>> int.from_bytes(b'xfcx00', byteorder='big', signed=False)
64512
>>> int.from_bytes([255, 0, 0], byteorder='big')
16711680


Операции с системами счисления
Как гласит математика и информатика, числа можно представить как в десятичной, так и в двоичной системе счисления. Допустим, число 19 в двоичной системе имеет вид 10011. Также можно переводить числа из одной системы в другую. В Python для этого есть ряд функций:

• int([object], [основание системы счисления]) — функция нужна для преобразования к целому числу. По умолчанию речь идёт о десятичной системе, однако можно задать любое основание в пределах чисел 2-36.

• bin(x) — функция для преобразования целого числа в двоичную строку;

• hex(х) — аналогично, но действительное целое число преобразуется в шестнадцатеричную строку;

• oct(х) — для преобразования чисел в восьмеричную строку.
Пример: 
>>>
>>> a = int('19') # Строка переводится в число
>>> b = int('19.5')  # Строка не является числом
Traceback (most recent call last):
  File "", line 1, in
ValueError: invalid literal for int() with base 10: '19.5'
>>> c = int(19.5)  # Отсекает дробную часть, если применена к числу с плавающей точкой
>>> print(a, c)
19 19
>>> bin(19)
'0b10011'
>>> oct(19)
'0o23'
>>> hex(19)
'0x13'
>>> 0b10011  # Вариант записи числовых констант
19
>>> int('10011', 2)
19
>>> int('0b10011', 2)
19






  


                       
  




Операции с вещественными числами (float)
Чтобы вывести дробную часть, в Python используют вещественные числа. Они поддерживают выполнение тех же операций, что и в случае с int. Но из-за особенностей их представления в компьютере, когда выводишь дробную часть, возможны неточности и даже ошибки: 
>>>
>>> 0.1 + 0.1 + 0.1 + 0.1 + 0.1 + 0.1 + 0.1 + 0.1 + 0.1 + 0.1
0.9999999999999999


Для повышения точности операций используются такие объекты, как Decimal и Fraction. 
Вспомогательные методы
К ним относят:

• float.as_integer_ratio() — это пара целых чисел int, отношение которых равно этому числу;

• float.is_integer() — функция определят, является ли данное значение целым числом;

• float.hex() — функция переводит float в 16-тиричную систему счисления, то есть в hex;

• classmethod float.fromhex(s) — функцию используют для получения float из 16-тиричной строки.
Кроме стандартных выражений, в Python есть и специальные полезные модули. Например, модуль math позволяет выполнять более сложные арифметические функции:
>>>
>>> import math
>>> math.pi
3.141592653589793
>>> math.sqrt(85)
9.219544457292887


А вот модуль random запускает генератор случайных чисел, позволяя реализовать функции случайного выбора: 
>>>
>>> import random
>>> random.random()
0.75849839767373282


Комплексные числа в Python (complex)
Также в Python встроены комплексные числа:
>>>
>>> x = complex(1, 2)
>>> print(x)
(1+2j)
>>> y = complex(3, 4)
>>> print(y)
(3+4j)
>>> z = x + y
>>> print(x)
(1+2j)
>>> print(z)
(4+6j)
>>> z = x * y
>>> print(z)
(-5+10j)
>>> z = x / y
>>> print(z)
(0.44+0.08j)
>>> print(x.conjugate())  # Сопряжённое число
(1-2j)
>>> print(x.imag)  # Мнимая часть
2.0
>>> print(x.real)  # Действительная часть
1.0
>>> print(x > y)  # Числа нельзя сравнить
Traceback (most recent call last):
  File "", line 1, in
TypeError: unorderable types: complex() > complex()
>>> print(x == y)  # Однако можно проверить их на равенство
False
>>> abs(3 + 4j)  # Модуль 
5.0
>>> pow(3 + 4j, 2)  # Возведение в степень, получение значения степени
(-7+24j)


Кроме того, для работы с complex может применяться модуль cmath.



  


                       
  





На этом пока что всё. Следите за новостями и не забывайте оставлять свои комментарии!

Примеры извлечения десятичной части (или дробной части) числа в python

Возьмем для примера число “пи”:

import math
p = math.pi
print(p)
Code language: JavaScript (javascript)

Выводит:

3.141592653589793



  


                       
  



Code language: CSS (css)

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

decimal_part = p % 1
pirnt(decimal_part)

Получаем:

0.14159265358979312
Code language: CSS (css)

Примечание по скорости работы:

CPU times: user 13 µs, sys: 0 ns, total: 13 µs
Wall time: 16.9 µs
Code language: CSS (css)

Применение функции round()

Другим решением является использование функции round()

decimal_part = p - round(p)
print(decimal_part)
Code language: PHP (php)

Выведет:

0.14159265358979312
Code language: CSS (css)

Время работы:

CPU times: user 15 µs, sys: 0 ns, total: 15 µs
Wall time: 18.8 µs
Code language: CSS (css)

and want to get only the numbers after the period,

There is no such thing. Numbers don’t have digits; the string representation of the numbers has digits. And even then, floating-point numbers are not precise; you may be shown 0.3 in one context and 0.30000000000000004 in another, for the same value.

It sounds like what you are actually after is the fractional part of the numbers. There are many ways to do this, but they all boil down the same idea: it is the result when you divide (as a floating-point number) the input by 1.

For a single value, it looks like:

fractional_part = value % 1.0

or

# This built-in function performs the division and gives you
# both quotient and remainder.
integer_part, fractional_part = divmod(value, 1.0)

or

import math
fractional_part = math.fmod(value, 1.0)

or

import math
# This function is provided as a special case.
# It also gives you the integer part.
# Notice that the results are the other way around vs. divmod!
fractional_part, integer_part = math.modf(value)

To process each value in a list in the same way, use a list comprehension.

Функции относящиеся к теории чисел.

В этом разделе представлены функции относящиеся к теории чисел.

Содержание:

• Факториал числа,
• Наибольший общий делитель целых чисел,
• Функция math.frexp(),
• Функция math.ldexp(),
• Абсолютное значение числа,
• Остаток от деления,
• Получить дробную и целую часть числа,
• Получить точную сумму элементов списка,
• Получить число x со знаком числа y,
• Сравнение в пределах указанной точности,
• Наименьшее общее кратное целых чисел,
• Следующее значение float после x по направлению к y,
• Наименьший значащий бит числа float.

math.factorial(x):

Функция math.factorial() возвращает факториал указанного числа x.

>>> import math
>>> math.factorial(5)
120

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

Если x не является целым числом или если x является отрицательным, то будет вызвано исключение ValueError.

Изменено в Python 3.9. Не рекомендуется передавать числа с плавающей запятой с целыми значениями (например, 5.0).

math.gcd(*integers):

Функция math.gcd() возвращает наибольший общий делитель указанных целочисленных аргументов *integers.

>>> import math
>>> math.gcd(3886, 9048)
# 58

# проверяем
>>> 3886/58, 9048/58
# (67.0, 156.0)

• Если какой-либо из аргументов не равен нулю, то возвращаемое значение является наибольшим положительным целым числом, которое является делителем всех аргументов:
• Если все аргументы равны нулю, то возвращаемое значение равно 0.
• функция math.gcd() вызванная без аргументов возвращает 0.

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

>>> import math
>>> math.gcd(-4, -8)
# 4
>>> math.gcd(-4, -8.8)
# Traceback (most recent call last):
#   File "<stdin>", line 1, in <module>
# TypeError: 'float' object cannot be interpreted as an integer

Изменено в Python 3.9: Добавлена ​​поддержка произвольного количества аргументов. Раньше поддерживалось только два аргумента.

math.frexp(x):

Функция math.frexp() возвращает кортеж из двух чисел (m, e) таких что x == m*2**e.

>>> import math
>>> math.frexp(123)
# (0.9609375, 7)
>>> 0.9609375*2**7
# 123.0

Число m принадлежит к типу float и всегда является таким, что 0.5 <= abs(m) < 1, даже для тех случаев, когда значением x является произвольная степень двойки. Число e всегда целое число int:

>>> math.frexp(0.25)
# (0.5, -1)
>>> math.frexp(64)
# (0.5, 7)

Если x равен 0, то будет возвращено (0.0, 0).

Данная функция используется тогда, когда представление чисел типа float не должно зависеть от архитектуры машины.

math.ldexp(x, i):

Функция math.ldexp() возвращает значение равное x*2**i, т.е. является обратной к функции math.frexp().

>>> import math
>>> math.ldexp(3, 4)
# 48.0
>>> math.ldexp(0.125, 8)
# 32.0

math.fabs(x):

Функция math.fabs() возвращает абсолютное значение, модуль числа x. Результат всегда тип float.

>>> import math
>>> math.fabs(-3)
3.0

Данная функция в отличии от встроенной функции abs() не обрабатывает комплексные числа.

math.fmod(x):

Функция math.fmod() возвращает остаток от деления числа x на число y, вычисленный так, как это определено в библиотеке math языка C.

>>> import math
>>> math.fmod(2.23, 0.2)
0.02999999999999986

Данная функция направлена на то, что бы результат был максимально приближен к значению x - n*y для некоторого целого числа n, что бы этот результат имел тот же знак, что и x, что бы разность x - n*y == abs(y).

Для чисел типа float данная функция является предпочтительнее чем команда x%y, которая в свою очередь является предпочтительной для чисел типа int. Так как для некоторых случаев, например при x = -1e-100 и x = 1e100, команда x%y может вообще выдать неправильный результат.

math.modf(x):

Функция math.modf() возвращает кортеж из двух чисел (f, w) где f это дробная, а w – целая часть числа x. Результат всегда имеет тип float.

>>> import math
>>> math.modf(3)
# (0.0, 3.0)
>>> math.modf(3.14)
# (0.14000000000000012, 3.0)

math.fsum(iterable):

Функция math.fsum() возвращает точную сумму значений в итерируемой последовательности iterable. Возвращаемый результат всегда типа float.

>>> import math
>>> sum([.1, .1, .1, .1, .1, .1, .1, .1, .1, .1])
# 0.9999999999999999
>>> math.fsum([.1, .1, .1, .1, .1, .1, .1, .1, .1, .1])
# 1.0

Может показаться, что эта сумма будет точной всегда, но на самом деле это не так:

>>> math.fsum([0.3, 0.3, 0.3])
0.8999999999999999

Многое зависит от сборки компилятора языка C, который используется на данной платформе. Если вам нужны точные арифметические операции с десятичными дробями, то воспользуйтесь модулем decimal.

math.copysign(x, y):

Функция math.copysign() возвращает число c абсолютным значением x, но со знаком числа y. Возвращаемый результат всегда типа float

>>> import math
>>> math.copysign(14, -12)
# -14.0
>>> math.copysign(-14, 12)
# 14.0

На платформах, которые поддерживают нули со знаком функция math.copysign(1.0, -0.0) возвращает -1.0.

math.isclose(a, b, *, rel_tol=1e-09, abs_tol=0.0):

Функция math.isclose() возвращает True если в пределах указанной точности, числа a и b близки настолько, что их можно считать равными.

>>> import math
>>> x = 7
>>> y = 7.000000000000001
>>> x==y
# False
>>> math.isclose(x, y)
# True

Считать числа близкими или нет, определяют два аргумента rel_tol и abs_tol.

Аргумент rel_tol это относительный допуск, определяемый как максимально допустимая разница между числами a и b относительно большего из них по модулю. По умолчанию rel_tol=1e-09, что гарантирует, что числа a и b будут одинаковы, в пределах 9 десятичных цифр. Чтобы числа считались равными, если они, допустим, отличаются меньше чем на 0.1%, то достаточно установить rel_tol=0.001, но в любом случае данный параметр, должен быть больше нуля:

>>> y = 7.000001
>>> math.isclose(y, 6.999, rel_tol=0.001)
# True

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

Данная функция эквивалентна команде abs(a-b) <= max(rel_tol * max(abs(a), abs(b)), abs_tol). Значения inf, -inf считаются близкими только сами к себе, а NaN не является близким ни к одному значению, включая само NaN.

math.lcm(*integers):

Функция math.lcm() возвращает наименьшее общее кратное указанных целочисленных аргументов *integers.

• Если все аргументы отличны от нуля, то возвращаемое значение является наименьшим положительным целым числом, кратным всем аргументам.
• Если какой-либо из аргументов равен нулю, то возвращается значение 0.
• Функция math.lcm(), вызванная без аргументов возвращает 1.

Новое в Python 3.9.

math.nextafter(x, y):

Функция math.nextafter() возвращает следующее значение float после x по направлению к y.

Если x равно y, то функция возвращает y.

Примеры:

• math.nextafter(x, math.inf) идет вверх: в сторону положительной бесконечности.
• math.nextafter(x, -math.inf) идет вниз: в сторону минус бесконечности.
• math.nextafter(x, 0.0) стремится к нулю.
• math.nextafter(x, math.copysign(math.inf, x)) уходит от нуля.

Новое в Python 3.9.

Смотрите также математическую функцию math.ulp().

math.ulp(x):

Функция math.isclose() возвращает значение наименьшего значащего бита числа float x.

• Если x – NaN (не число), то вернет x.
• Если x отрицательный, то вернет ulp(-x).
• Если x – положительная бесконечность, то вернет x.
• Если x равен нулю, то вернет наименьшее положительное денормализованное представимое число float (меньше минимального положительного нормализованного числа float, sys.float_info.min).
• Если x равен наибольшему положительному представимому числу float, то вернет значение младшего значащего бита x, так что первое число float меньше x будет x - ulp(x).
• В противном случае (x – положительное конечное число) вернет значение младшего значащего бита x, так что первое число float больше x равно x + ulp(x).

ULP означает “Единица на последнем месте”.

Новое в Python 3.9.

Смотрите также математическую функцию math.nextafter().