Как найти модуль от числа в питоне

{“id”:13943,”url”:”/distributions/13943/click?bit=1&hash=fa1a68c0b374f03ef7c98a801a20c4fde732f5ad4316b0bd53bd0cea0bb7d159″,”title”:”u041au0430u043a u043fu0440u043eu0434u0432u0438u0433u0430u0442u044c u0431u0440u0435u043du0434u044b u0438 u0442u043eu0432u0430u0440u044b u0432 u044du043fu043eu0445u0443 u043cu0430u0440u043au0435u0442u043fu043bu0435u0439u0441u043eu0432″,”buttonText”:””,”imageUuid”:””,”isPaidAndBannersEnabled”:false}

Вступление

Всем начинающим кодерам привет!

Модуль числа… Это, казалось бы, простая вещь… да, так оно и есть. Тем не менее – всегда интересно поэкспериментировать и по-новому взглянуть на простое.

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

1 способ

Для начала самое очевидное. Проверяем отрицательное число (назовем его x) или положительное, т.е. <0 или нет. В случае отрицательного значения x, его нужно умножить на -1. Можно так:

def abs1(x):
if x < 0:
return x*(-1)
return x

А можно заменить умножение унарным минусом:

def abs1(x):
if x < 0:
return -x
return x

2 способ

Самое короткое решение в нашей статье – найти максимум между x и -x. Таким образом результат всегда будет положительным:

def abs2(x):
return max(-x, x)

3 способ

Здесь мы проверяем строку на наличие в ней минуса. Изначально я хотел использовать метод isdigit(), но потом я понял, что метод не считает точку частью числа, поэтому для float в строке метод возвращает False. Поэтому:

​def abs3(x):
if ‘-‘ in str(x):
return -x
return x

4 способ

Этот способ использует условную инструкцию из предыдущей функции, но использует срез, чтобы избавиться от минуса. 3 строка выглядит не очень, приходится дважды менять тип данных результата. По-моему – это ухудшенная версия 3 способа:

def abs4(x):
if ‘-‘ in str(x):
return float(str(x)[1::])
return x

5 способ

Тут мы будем использовать факт того, что операция квадратного корня в Python всегда возвращает положительный результат. Эту операцию не обязательно брать из библиотеки Math, можно просто возвести число в с степень 0.5. Итак:

def abs5(x):
return (x*x)**0.5

6 способ

Здесь мы используем операции со строками, как в 4 способе. Отличие в том, что мы не проверяем строку на наличие минуса. Мы убираем уго, есть он в строке или нет. Метод replace() позволяет убрать все повторения одного символа, что для нас избыточно, но с нулем повторений он тоже работает:

def abs6(x):
return float(str(x).replace(‘-‘, ”))

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

Статистика быстродействия

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

Я измерил время работы данного куска кода, где i – одна из 6 функций.

for j in range(100000):
a = (i(1), i(-1), i(1.0), i(-1.0))

И вот что получилось:

Что у нас по итогу? Худший результат показал 4 способ, неудивительно.Самый очевидный способ – первый, на 2 месте. С большим отрывом лидирует 5 вариант, 100000 повторений за 0.79 сек! Математика быстрее логического оператора if и операций со строками.

Заключение

Я надеюсь, что вам была интересна данная статья, и вы разобрались в теме. Если хотите меня дополнить – пишите в комментариях. Удачи в мире IT!

  • Модуль числа

  • Вычисление

  • abs

  • fabs

  • Свое решение

  • Модуль комплексного числа

Очень часто возникает необходимость вычисления модуля числа в Python. Рассмотрим, что такое модуль числа, какие есть способы его вычисления. Так же отдельно коснемся комплексных чисел.

Модуль числа

Часто в программировании требуется вычислить абсолютное значение числа. Иначе говоря, отбросить знак.

При вычислении модуля возможны 3 ситуации:

  • Когда число больше 0. Если взять его по модулю — не изменится.
  • Модуль нуля так же равен нулю.
  • У отрицательного числа отбрасываем знак. То есть умножаем его на -1.

Но это все справедливо только для действительных чисел. Чему же тогда будет равен модуль комплексных?

Комплексное число состоит из действительной составляющей и мнимой. Геометрически это можно представить как 2 ортогональные оси: действительную и мнимую. Отмечаем на координатных осях требуемую точку. Модулем будет длина отрезка, проведенного из начала координат в эту точку.

Исходя из теоремы Пифагора получаем, что модуль комплексного числа это корень квадратный из суммы квадратов мнимой и действительной частей.

Вычисление

Вычислять модуль можно следующими способами:

  • Используя стандартную функцию abs.
  • С помощью функции fabs библиотеки math.
  • При помощи самостоятельно написанной функции.

Все эти функции работают как в Python 2, так и в Python 3.

abs

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

a = -10
b = abs(a)
print(b)
print(type(b))

10
<class 'int'>

fabs

Можно так же воспользоваться функцией fabs из библиотеки math. Библиотеку можно подключить с помощью from math import fabs.

from math import fabs
a = -10
b = fabs(a)
print(b)
print(type(b))

10.0
<class 'float'>

Отличие abs от fabs заключается в том, что функция abs возвращает значение того же типа, что и аргумент. Функция же fabs вначале преобразует тип аргумента к вещественному числу.

Свое решение

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

Например, можно вычислить воспользоваться тернарным оператором.

a = -10
b = a if a > 0 else -a
print(b)

10

На основе такого условия сделаем свою функцию.

def my_abs(a):
    return a if a > 0 else -a
print(my_abs(-3))

3

Модуль комплексного числа

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

Функцией fabs мы не сможем воспользоваться. Если попытаемся это сделать, то получим ошибку приведения комплексного числа к действительному (TypeError).

from math import fabs
a = -10-2j
b = fabs(a)
print(b)

Traceback (most recent call last):
  File "main.py", line 3, in <module>
    b = fabs(a)
TypeError: can't convert complex to float

А вот с помощью abs преобразование удается.

a = -10-2j
b = abs(a)
print(b)

10.19803902718557

Или же напишем свою функцию:

from math import sqrt
def my_abs_complex(c):
    return sqrt(c.real**2 + c.imag**2)
a = -10-2j
b = my_abs_complex(a)
print(b)

10.198039027185569

Результаты получились одинаковыми. Но нам все равно пришлось подключить библиотеку math для вычисления квадратного корня.

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

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

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

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

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

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

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

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

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

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).

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():

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, вычисляя значение для каждого элемента коллекции.

Пример:

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 и сохранит тип. Для целого числа — целое число. Для числа с плавающей точкой — число с плавающей точкой.

>>> 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).

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

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

Перейти к содержанию

Картинка к уроку "Вычисление модуля числа в Python"

На чтение 1 мин Просмотров 2.6к. Опубликовано

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

Вычисление модуля числа с помощью модуля Math

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

import math

И после воспользуемся командой:

math.fabs(число или переменная, модуль которого необходимо вычислить)

Рассмотрим конкретный пример вычисления модуля на языке программирования Python:

import math
print(math.fabs(-56))
>>> 56.0

Вычисление модуля числа написанием собственной функции

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

def module(a):
    if a <0:
        a = a*-1
    return a
print(module(-56))
>>> 56

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

( 1 оценка, среднее 1 из 5 )

Содержание:развернуть

  • Что такое модуль числа
  • Abs
  • Fabs
  • Основные свойства модулей

Запускаю китайскую реплику “ТАРДИС”, и вот мы в пятом классе. На доске нарисована числовая ось, а на ней выделен отрезок. Его начало в точке 4, а конец — в 8. Учительница говорит, что длину отрезка можно найти путём вычитания координаты начала отрезка из координаты его конца. Вычитаем, получаем 4, и радуемся — мы нашли длину. Ура! 🎉

Перемещаемся на год вперёд, и там происходит странное: учительница выделяет мелом другой отрезок, но делает это в каком-то неправильном месте — левее точки с цифрой “0”. Теперь перед нами старая задача, но с новыми числами и даже буквами: A, B, минус 4 и минус 8. Мы начинаем искать длину отрезка AB = [-4;-8]:

Переводим непонимающий взгляд с получившейся отрицательной длины на довольную улыбающуюся учительницу, а затем на доску. Там наверху, рядом с сегодняшней датой, написана тема урока: “Модуль числа”.

Что такое модуль числа

Теперь по-взрослому.

Модуль числа называют абсолютной величиной.

Для вещественных чисел модуль определяется так:

Формула модуля числа для вещественных чисел

Т.е. в любом случае, модуль — число большее или равное 0. Поэтому отрицательная длина в примере хитрой учительницы должна была быть взята по модулю:

Тогда дети бы увидели, что геометрический смысл модуля — есть расстояние. Это справедливо и для комплексных чисел, однако формальное определение для них отличается от вещественного:

, где z — комплексное число: z = x + iy.

В Python для нахождения модуля числа применяются две функции: fabs() из подключаемой библиотеки math и встроенная функция abs().

Abs

В то время как math.fabs() может оперировать только вещественными аргументами, abs() отлично справляется и с комплексными. Для начала покажем, что abs в python работает строго в соответствии с математическим определением.

# для вещественных чисел
print(abs(-1))
print(abs(0))
print(abs(1))

> 1
> 0
> 1

Как видно, с вещественными числами всё в порядке. Перейдём к комплексным.

# для комплексных чисел
print(complex(-3, 4))
print(abs(complex(-3, 4)))

> (-3+4j)
> 5.0

Если вспомнить, что комплексное число выглядит так: z = x + iy, а его модуль вычисляется по формуле:

, то можно без труда посчитать, что sqrt(3**2 + 4**2) действительно равно 5.0.

Можно заметить, что abs() возвращает значения разных типов. Это зависит от типа аргумента:

print(type(abs(1)))
> <class 'int'>

print(type(abs(1.0)))
> <class 'float'>

print(type(abs(complex(1.0, 1.0))))
<class 'float'>

В этом кроется ещё одно отличие abs() от fabs(). Функция из модуля math всегда приводит аргумент к вещественному типу, а если это невозможно сделать — выбрасывает ошибку:

print(type(math.fabs(complex(2,3))))
> TypeError: can't convert complex to float

Fabs

Для начала работы с fabs() необходимо импортировать модуль math с помощью следующей инструкции:

import math

Мы уже выяснили, что fabs() не работает с комплексными числами, поэтому проверим работу функции на вещественных:

print(math.fabs(-10))
print(math.fabs(0))
print(math.fabs(10))

> 10.0
> 0.0
> 10.0

Функция производит вычисления в соответствие с математическим определением, однако, в отличие от abs(), всегда возвращает результат типа float:

print(type(math.fabs(10)))
> <class 'float'>

Основные свойства модулей

# Квадрат модуля = квадрату числа
print(pow(4, 2) == pow(abs(4), 2))
> True

# |x| = |-x|
print(abs(-10) == abs(10))
> True

# Модуль произведения = произведению модулей: |ab|=|a||b|
print(math.fabs(11 * 3) == math.fabs(11) * math.fabs(3))
> True

# Аналогично для деления: |a/b|=|a|/|b|
print(math.fabs(48/8) == math.fabs(48) / math.fabs(8))
> True

# |a ** b| = |a| ** b
print(abs(2 ** 10) == abs(2) ** 10)
> True

И еще несколько важных неравенств:

  • m <= |m|
  • -|m| <= m
  • |m| >= 0
  • |m + n| <= |m| + |n|
  • |m – n| <= |m| + |n|
  • |m| – |n| <= |m + n|
  • |m + n| >= ||m| – |n||
  • |m – n| >= ||m| – |n||

Добавить комментарий