{“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
Таким образом, результат всегда положительный и всегда является числом с плавающей точкой.
Перейти к содержанию
На чтение 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||