Питон модуль числа: Python – Метод abs() – модуль числа

модуль числа на примерах с int и float, синтаксис функции

Встроенная функция abs(x) в Python возвращает абсолютное значение аргумента x, который может быть целым или числом с плавающей точкой, или же объектом, реализующим функцию __abs__(). Для комплексных чисел функция возвращает их величину. Абсолютное значение любого числового значения -x или +x — это всегда соответствующее положительное +x.

Аргумент	x	целое число, число с плавающей точкой, комплексное число, объект, реализующий __abs__()
Возвращаемое значение	|x|	возвращает абсолютное значение входящего аргумента

Пример abs() с целым числом

Следующий код демонстрирует, как получить абсолютное значение 42 положительного числа 42.

Копировать Скопировано Use a different Browser

x = 42
abs_x = abs(x)
print(f"Абсолютное значение {x} это {abs_x}")
# Вывод: Абсолютное значение 42 это 42

Вывод: «Абсолютное значение 42 это 42».

То же самое, но уже с отрицательным -42.

Копировать Скопировано Use a different Browser

x = -42
abs_x = abs(x)
print(f"Абсолютное значение {x} это {abs_x}")
#  Вывод: Абсолютное значение -42 это 42

Пример с числом float

Вот как получить абсолютное значение 42.42 и для -42.42:

Копировать Скопировано Use a different Browser

x = 42.42
abs_x = abs(x)
print(f"Абсолютное значение {x} это {abs_x}")
#  Абсолютное значение 42.42 это 42.42
x = -42.42
abs_x = abs(x)
print(f"Абсолютное значение {x} это {abs_x}")
#  Абсолютное значение -42.42 это 42.42
 

Комплексное число

Абсолютное значение комплексного числа (3+10j).

Копировать Скопировано Use a different Browser

complex_number = (3+10j)
abs_complex_number = abs(complex_number)
print(f"Абсолютное значение {complex_number} это {abs_complex_number}")
#  Абсолютное значение (3+10j) это 10.44030650891055

abs() vs fabs()

abs(x) вычисляет абсолютное значение аргумента x. По аналогии функция fabs(x) модуля math вычисляет то же значение. Разница лишь в том, что math.fabs(x) возвращает число с плавающей точкой, а abs(x) вернет целое число, если в качестве аргумента было целое число. Fabs расшифровывается как float absolute value.

Пример c fabs():

Копировать Скопировано Use a different Browser

x = 42
print(abs(x))
# 42
import math
print(math.fabs(x))
# 42.0
 

abs() vs. np.abs()

И abs() в Python, и np.abs() в NumPy вычисляют абсолютное значение числа, но есть два отличия. np.abs(x) всегда возвращает число с плавающей точкой. Также np.abs(x) принимает массив NumPy, вычисляя значение для каждого элемента коллекции.

Пример:

Копировать Скопировано Use a different Browser

x = 42
print(abs(x))
# 42
import numpy as np
print(np.fabs(x))
# 42.0
a = np.array([-1, 2, -4])
print(np. abs(a))
# [1 2 4]

abs и np.abs абсолютно идентичны. Нет разницы какой использовать. У первой преимущество лишь в том, что ее вызов короче.

Вывод

Функция abs() — это встроенная функция, возвращающая абсолютное значение числа. Она принимает целые, с плавающей точкой и комплексные числа на вход.

Если передать в abs() целое число или число с плавающей точкой, то функция вернет не-отрицательное значение n и сохранит тип. Для целого числа — целое число. Для числа с плавающей точкой — число с плавающей точкой.

Копировать Скопировано Use a different Browser

>>> abs(20)
20
>>> abs(20.0)
20.0
>>> abs(-20.0)
20.0

Комплексные числа состоят из двух частей и могут быть записаны в форме a + bj, где a и b — это или целые числа, или числа с плавающей точкой. Абсолютное значение a + bj вычисляется математически как math.sqrt(a**2 + b**2).

Копировать Скопировано Use a different Browser

>>> abs(3 + 4j)
5.0
>>> math.sqrt(3**2 + 4**2)
5.0

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

Максим

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

Python Q https://yandex.ru/q/loves/python Online

Python QCEO [email protected]://secure.gravatar.com/avatar/b16f253879f7349f64830c64d1da4415?s=96&d=mm&r=gCEO PythonruPythonАлександрРедакторhttps://t.me/cashncarryhttps://pythonru.com/https://yandex.ru/q/profile/cashnc/[email protected] Zabrodin2018-10-26OnlinePython, Programming, HTML, CSS, JavaScript

Функция abs() в Python, абсолютное значение числа.

Функция abs() в Python, абсолютное значение числа.

Сообщить об ошибке.

Синтаксис:

abs(x)

Параметры:

• x — число, может быть целым числом, числом с плавающей запятой или комплексным числом.

Возвращаемое значение:

• абсолютное значение числа x, переданного в качестве аргумента.

Описание:

Функция abs() используется для возврата абсолютного значения числа.

abs() принимает только один аргумент, число, абсолютное значение которого должно быть возвращено. Аргумент может быть целым числом, числом с плавающей запятой или комплексным числом.

• Если аргумент представляет собой целое число или число с плавающей запятой, abs() возвращает абсолютное значение в виде целого числа или числа с плавающей запятой.
• В случае комплексного числа abs() возвращает только часть величины, которая также может быть числом с плавающей запятой.

Примеры получения абсолютного значение числа.

# Число с плавающей точкой (запятой)
>>> f = -54.26
>>> print('=>', abs(f)) 
# => 54.26
# Целое число
>>> i = -94
>>> print('=>', abs(i)) 
# => 94
 
# Комплексное число
>>> c = (3 - 4j) 
>>> print('=>', abs(c))
# => 5.0

• ОБЗОРНАЯ СТРАНИЦА РАЗДЕЛА
• Функция abs(), абсолютное значение числа.
• Функция all(), все элементы True.
• Функция any(), хотя бы один элемент True.
• Функция ascii(), преобразует строку в ASCII.
• Функция bin(), число в двоичную строку.
• Класс bool(), логическое значение объекта.
• Функция breakpoint(), отладчик кода.
• Класс bytearray(), преобразует в массив байтов.
• Класс bytes(), преобразует в строку байтов.
• Функция callable(), проверяет можно ли вызвать объект.
• Функция chr(), число в символ Юникода.
• Класс classmethod, делает функцию методом класса.
• Функция compile() компилирует блок кода Python.
• Класс complex(), преобразует в комплексное число.
• Функция delattr(), удаляет атрибут объекта.
• Класс dict() создает словарь.
• Функция dir(), все атрибуты объекта.
• Функция divmod(), делит числа с остатком.
• Функция enumerate(), счетчик элементов последовательности.
• Функция eval(), выполняет строку-выражение с кодом.
• Функция exec(), выполняет блок кода.
• Функция filter(), фильтрует список по условию.
• Класс float(), преобразует в вещественное число.
• Функция format(), форматирует значение переменной.
• Класс frozenset(), преобразует в неизменяемое множество.
• Функция getattr(), значение атрибута по имени.
• Функция globals(), переменные глобальной области.
• Функция hasattr(), наличие атрибута объекта.
• Функция hash(), хэш-значение объекта.
• Функция help(), справка по любому объекту.
• Функция hex(), число в шестнадцатеричную строку.
• Функция id(), идентификатор объекта.
• Функция input(), ввод данных с клавиатуры.
• Класс int(), преобразует в тип int.
• Функция isinstance(), принадлежность экземпляра к классу.
• Функция issubclass(), проверяет наследование класса.
• Функция iter(), создает итератор.
• Функция len(), количество элементов объекта.
• Класс list(), преобразовывает в список.
• Функция locals(), переменные локальной области.
• Функция map(), обработка последовательности без цикла.
• Функция max(), максимальное значение элемента.
• Класс memoryview(), ссылка на буфер обмена.
• Функция min(), минимальное значение элемента.
• Функция next(), следующий элемент итератора.
• Класс object(), возвращает безликий объект.
• Функция oct(), число в восьмеричную строку.
• Функция open(), открывает файл на чтение/запись.
• Функция ord(), число символа Unicode.
• Функция pow(), возводит число в степень.
• Функция print(), печатает объект.
• Класс property(), метод класса как свойство.
• Класс range(), генерирует арифметические последовательности.
• Функция repr(), описание объекта.
• Функция reversed(), разворачивает последовательность.
• Функция round(), округляет число.
• Класс set(), создает или преобразовывает в множество.
• Функция setattr(), создает атрибут объекта.
• Класс slice(), шаблон среза.
• Функция sorted(), выполняет сортировку.
• Декоратор staticmethod(), метод класса в статический метод.
• Класс str(), преобразует объект в строку.
• Функция sum(), сумма последовательности.
• Функция super(), доступ к унаследованным методам.
• Класс tuple(), создает или преобразует в кортеж.
• Класс type(), возвращает тип объекта.
• Функция vars(), словарь переменных объекта.
• Функция zip(), объединить элементы в список кортежей.
• Функция __import__(), находит и импортирует модуль.
• Функция aiter(), создает асинхронный итератор.
• Функция anext(), следующий элемент асинхронного итератора.

дробей — Рациональные числа — Документация Python 3.11.3

Исходный код: Lib/fractions.py

---

Модуль дробей обеспечивает поддержку арифметики рациональных чисел.

Экземпляр Fraction может быть создан из пары целых чисел, из другое рациональное число или из строки.

класс дроби. Дробь ( числитель=0 , знаменатель=1 )

класс фракций. Фракция ( other_fraction )

класс дроби. Фракция ( с плавающей запятой )

класс дроби. Дробь ( десятичная )

класс дроби. Фракция ( строка )

Первая версия требует, чтобы числитель и знаменатель были экземплярами из чисел. Rational и возвращает новый экземпляр Fraction со значением числитель/знаменатель . Если знаменатель равен 0 , то вызывает ZeroDivisionError . Вторая версия требует, чтобы other_fraction является экземпляром numbers.Rational и возвращает Дробный экземпляр с тем же значением. Следующие две версии принимают либо с плавающей запятой , либо decimal.Decimal экземпляр, и вернуть Дробный экземпляр с точно таким же значением. Отметим, что из-за обычные проблемы с двоичными числами с плавающей запятой (см. Арифметика с плавающей запятой: проблемы и ограничения), аргумент до

Fraction(1.1) не совсем равно 11/10, поэтому Fraction(1.1) возвращает , а не Fraction(11, 10) , как можно было бы ожидать. (Но см. документацию для метода limit_denominator() ниже.) Последняя версия конструктора ожидает строку или экземпляр Unicode. Обычная форма для этого экземпляра:

 [знак] числитель ['/' знаменатель]
 

, где необязательный знак может быть либо «+», либо «-» и числитель и знаменатель (если есть) представляют собой строки десятичные цифры (символы подчеркивания могут использоваться для разделения цифр, как в случае с целочисленные литералы в коде). Кроме того, любая строка, представляющая конечный значение и принимается конструктором float также принимается конструктором Fraction . В любой форме входная строка также может иметь начальные и/или конечные пробелы. Вот несколько примеров:

 >>> из импорта дробей Фракция
>>> Дробь(16, -10)
Дробь (-8, 5)
>>> Дробь(123)
Дробь(123, 1)
>>> Дробь()
Фракция (0, 1)
>>> Дробь('3/7')
Фракция (3, 7)
>>> Дробь('-3/7')
Дробь (-3, 7)
>>> Дробь('1.414213\t\n')
Дробь(1414213, 1000000)
>>> Дробь('-.125')
Дробь (-1, 8)
>>> Дробь('7e-6')
Дробь(7, 1000000)
>>> Дробь (2,25)
Фракция(9, 4)
>>> Дробь(1.1)
Дробь(2476979795053773, 2251799813685248)
>>> из десятичного импорта Decimal
>>> Дробь (десятичная ('1.1'))
Дробь(11, 10)
 

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

Изменено в версии 3.2: конструктор Fraction теперь принимает float и десятичных. Десятичных экземпляров.

Изменено в версии 3.9: Функция math.gcd() теперь используется для нормализации числителя . и знаменатель . math.gcd() всегда возвращает тип int . Раньше тип НОД зависел от числителя и знаменателя .

Изменено в версии 3.11: теперь разрешены символы подчеркивания при создании Фракция экземпляр из строки в соответствии с правилами PEP 515 .

Изменено в версии 3.11: Дробь реализует __int__ теперь для удовлетворения typing.SupportsInt проверяет экземпляр.

числитель

Числитель младшей дроби.

знаменатель

Знаменатель младшей дроби.

as_integer_ratio()

Возвращает кортеж из двух целых чисел, отношение которых равно к дроби и с положительным знаменателем.

Новое в версии 3.8.

classmethod from_float ( flt )

Альтернативный конструктор, который принимает только экземпляры число с плавающей запятой или . Интеграл . Остерегайтесь этого Fraction.from_float(0.3) не совпадает со значением Fraction(3, 10) .

Примечание

Начиная с Python 3.2, вы также можете создать Экземпляр дроби непосредственно из числа с плавающей запятой .

classmethod from_decimal( dec )

Альтернативный конструктор, который принимает только экземпляры Десятичное число . Десятичное число или . Целое число .

Note

Начиная с Python 3. 2, вы также можете создать Экземпляр дроби непосредственно из десятичного числа . Десятичное число пример.

limit_denominator( max_denominator=1000000 )

Находит и возвращает ближайшую дробь к собственной личности , которая имеет знаменатель не больше max_denominator. Этот метод удобен для нахождения рациональные приближения к данному числу с плавающей запятой:

 >>> из импорта дробей Фракция
>>> Дробь('3.1415926535897932').limit_denominator(1000)
Дробь(355, 113)
 

или для восстановления рационального числа, представленного в виде числа с плавающей запятой:

 >>> из математического импорта pi, cos
>>> Дробь(cos(pi/3))
Дробь(4503599627370497, 99254740992)
>>> Fraction(cos(pi/3)).limit_denominator()
Фракция (1, 2)
>>> Дробь(1.1).limit_denominator()
Дробь(11, 10)
 

__этаж__()

Возвращает наибольшее значение int <= self . Этот метод может также можно получить через функцию math.floor() :

 >>> с этажа импорта математики
>>> пол(Дробь(355, 113))
3
 

__ceil__()

Возвращает наименьшее int >= self . Этот метод может также можно получить через функцию math.ceil() .

__round__()

__round__( nцифр )

Первая версия возвращает ближайший int к self , округление половины до четного. Вторая версия округляет до до ближайшее кратное Дробь(1, 10**nцифр) (логически, если ndigits отрицательное число), снова округляя половину до четного. Этот Доступ к методу также можно получить с помощью функции round() .

См. также

Числа модуля

Абстрактные базовые классы, составляющие числовую башню.

int, float, комплекс (с примерами)

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

Интервал

В Python целые числа — это нулевые, положительные или отрицательные целые числа без дробной части и имеющие неограниченную точность, например. 0, 100, -10. Ниже приведены допустимые целочисленные литералы в Python.

 #целочисленные переменные
х = 0
печать (х)
х = 100
печать (х)
х = -10
печать (х)
х = 1234567890
печать (х)
х = 5000000000000000000000000000000000000000000000000000000000
печать (х)
 

Целые числа могут быть двоичными, восьмеричными и шестнадцатеричными значениями.

 b = 0b11011000 # двоичный код
печать (б)
о = 0o12 # восьмеричное
печать (о)
h = 0x12 # шестнадцатеричный
печать (ч)
 

Все целочисленные литералы или переменные являются объектами класса int . Используйте метод type() , чтобы получить имя класса, как показано ниже.

 печать (тип (100))
х=1234567890
печать (тип (х))
у=500000000000000000000000000000000000000000000000000000000
печать (тип (у))
 

Примечание. Начальные нули в ненулевых целых числах не допускаются в Python, например. 000123 — неверный номер, а 0000 становится 0,

 x=001234567890 #syntaxError: недопустимый токен
 

Python не допускает использование запятой в качестве разделителя чисел. Вместо этого используйте подчеркивание _ в качестве разделителя.

 х = 1_234_567_890
печать (х) # вывод: 1234567890
 

Обратите внимание, что целые числа должны быть без дробной части (десятичной точки). Если он включает дробную часть, он становится числом с плавающей запятой.

 х=5
print(type(x)) #output: <класс 'int'>
х=5,0
print(type(x)) #output: 
 

Функция int() преобразует строку или число с плавающей запятой в целое число.

 х = целое ('100')
печать (х) # вывод: 100
у = интервал ('-10')
напечатать(у) #output: -10
г = интервал (5.5)
печать (z) # вывод: 5
п = целое ('100', 2)
напечатать(n) #output: 4
 

Двоичный

Число, имеющее 0b с восемью цифрами в комбинации 0 и 1, представляет двоичные числа в Python. Например, 0b11011000 — это двоичное число, эквивалентное целому числу 216.

 х = 0b11011000
печать (х)
х = 0b_1101_1000
печать (х)
печать (тип (х))
 

Восьмеричный

Число, имеющее 0o или 00 в качестве префикса, представляет восьмеричное число . Например, 0O12 эквивалентно целому числу 10.

 х = 0o12
печать (х)
печать (тип (х))
 

Шестнадцатеричный

Число с префиксом 0x или 0X представляет собой шестнадцатеричное число . Например, 0x12 эквивалентно целому числу 18.

 х = 0x12
печать (х)
печать (тип (х))
 

Поплавок

В Python числа с плавающей запятой (float) — это положительные и отрицательные действительные числа с дробной частью, обозначаемой десятичным символом . или научное обозначение E или e , например 1234,56, 3,142, -1,55, 0,23.

 f = 1,2
печать(f) #output: 1.2
print(type(f)) #output: 
f=123_42.222_013 #выход: 12342.222013
печать (е)
f=2e400
print(f) #output: inf
 

Как видите, числа с плавающей запятой можно отделить символом подчеркивания _ . Максимальный размер поплавка зависит от вашей системы. Число с плавающей запятой, превышающее его максимальный размер, обозначается как inf, Inf, INFINITY или бесконечность. Например, число с плавающей запятой 2e400 будет рассматриваться как бесконечность для большинства систем.

Научное обозначение используется в качестве краткого представления для выражения чисел с плавающей запятой, имеющих много цифр. Например: 345,56789представлен как 3.4556789e2 или 3.4556789E2

 ф = 1e3
печать (f) # вывод: 1000.0
ф = 1e5
печать (f) # вывод: 100000.0
f = 3,4556789e2
распечатать (f) # вывод:
печать (тип (f)) # output: 345.56789
 

Используйте функцию float() для преобразования строки int в float.

 f=число с плавающей запятой('5.5')
печать (f) # output: 5.5
f = с плавающей запятой ('5')
печать (f) # вывод: 5.0
f=число с плавающей запятой('-5')
печать (f) # вывод: -5.0
f = с плавающей запятой ('1e3')
печать (f) # вывод: 1000.0
f=поплавок('-Бесконечность')
print(f) #output: -inf
f = с плавающей запятой ('инф')
print(f) #output: inf
print(type(f)) #output:
 

Комплексные номера

Комплексное число — это число, состоящее из действительных и мнимых компонентов. Например, 5 + 6j — это комплексное число, где 5 — действительная часть, а 6, умноженное на j, — мнимая часть.

 а = 5+2j
печать (а)
печать (тип (а))
 

Вы должны использовать j или J в качестве мнимой составляющей. Использование другого символа вызовет синтаксическую ошибку.

 а=5+2к
а=5+j
а=5i+2j
 

Арифметические операторы

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

Оператор	Описание	Пример
+ (Дополнение)	Добавляет операнды по обе стороны от оператора.	a,b = 10, 20 print(a+b) #30
— (Вычитание)	Вычитает правый операнд из левого операнда.	a,b = 10, 20 print(a-b) #-10
* (Умножение)	Умножает значения по обе стороны от оператора.	a,b = 10, 20 print(a*b) #200
/ (Разделение)	Делит левый операнд на правый операнд.	a,b = 10, 20 print(b/a) #2.0
% (Модуль)	Возвращает остаток от деления левого операнда на правый операнд.	a,b = 10, 22 print(a+b) #2
** (Экспонента)	Вычисляет значение левого операнда, возведенного в правый операнд.	a=3 печать(a**2) #9 печать(a**3) #27
// (Этажное отделение)	Разделение операндов, результатом которого является частное, в котором удаляются цифры после запятой. Но если один из операндов отрицательный, результат округляется от нуля (в сторону отрицательной бесконечности):	a,b = 9, 2 print(a//b) #4 Попробуйте

Арифметические операции над комплексными числами

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

 а=6+4j
б=3+2j
печать("а+2=",а+2)
печать("а*2=",а*2)
печать("а/2=",а/2)
печать("а**2=",а**2)
печать("а+б=",а+б)
печать("а-б=",а-б)
 

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

Процесс умножения этих двух комплексных чисел очень похож на умножение двух двучленов. Умножьте каждый член первого числа на каждый член второго числа.

 а=6+4j
б=3+2j
с=а*б
печать (с)
с=(6+4к)*(3+2к)
печать (с)
с=(18+12j+14j+8*1)
печать (с)
 

Числовые функции

Числовой объект одного типа можно преобразовать в другой тип с помощью следующих функций:

Встроенная функция	Описание
инт	Возвращает целочисленный объект из числа с плавающей запятой или строки, содержащей цифры.
плавать	Возвращает объект числа с плавающей запятой из числа или строки, содержащей цифры с десятичной точкой или экспоненциальной записью.
сложный	Возвращает комплексное число с вещественной и мнимой частями.
шестигранник	Преобразует десятичное целое число в шестнадцатеричное число с префиксом 0x.
октябрь	Преобразует десятичное целое число в восьмеричное представление с префиксом 0o.
паф	Возвращает мощность указанных чисел. Оставить комментарий Добавить комментарий Отменить ответ Ваш адрес email не будет опубликован. Обязательные поля помечены * Комментарий * Имя * Email * Сайт