Lcm python что такое

Функции теории чисел модуля math в Python

Функция 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 "", line 1, in # 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 

>>> 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 должно быть не меньше нуля.

math.lcm(*integers) :

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

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

math.nextafter(x, y, steps=1) :

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

Изменено в версии 3.12: добавлен аргумент steps .

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

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

math.ulp(x) :

Функция math.ulp() возвращает значение наименьшего значащего бита числа 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 означает «Единица на последнем месте».

math.sumprod(p, q) :

Функция math.sumprod() возвращает сумму произведений значений двух итераций p и q .

Вызывает ValueError , если входные данные имеют разную длину.

sum(itertools.starmap(operator.mul, zip(p, q, strict=True))) 

Для входных данных с плавающей запятой и смешанных значений типа int / float промежуточные продукты и суммы вычисляются с повышенной точностью.

• ОБЗОРНАЯ СТРАНИЦА РАЗДЕЛА
• Функции теории чисел модуля math
• Функции округления чисел модуля math
• Степенные и логарифмические функции
• Тригонометрические функции модуля math
• Функции преобразование меры углов модуля math
• Гиперболические функции модуля math
• Константы и специальные значения модуля math
• Специальные функции модуля math

Наименьшее общее кратное

где a и b — это натуральные числа, НОД — наибольший общий делитель.

Решение задачи на языке программирования Python

Из условия задачи ясно, чтобы найти НОК, надо сначала найти НОД. Последний можно вычислить, постепенно находя остаток от деления большего числа из пары на меньшее и присваивая остаток переменной, связанной с большим числом (см. алгоритм Евклида). В какой-то момент значение одной из переменных станет равным 0. Когда это произойдет, другая будет содержать НОД. Если неизвестно, какая именно переменная содержит НОД, то можно просто сложить значения обоих переменных.

В коде ниже используется функция для нахождения НОК, которая принимает два числа и возвращает найденное наименьшее общее кратное.

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

def lcm(a, b): m = a * b while a != 0 and b != 0: if a > b: a %= b else: b %= a return m // (a + b) while 1: try: x = int(input('a = ')) y = int(input('b = ')) print('НОК:', lcm(x, y)) except ValueError: break

a = 14 b = 18 НОК: 126 a = 105 b = 305 НОК: 6405 a = stop

В модуле math языка программирования Python есть функция для нахождения наибольшего общего делителя ( gcd — greatest common devisor). При ее использовании наша функция вычисления наименьшего общего кратного lcm (least common multiple) упрощается.

def lcm(a, b): import math return (a * b) // math.gcd(a, b)

X Скрыть Наверх

Решение задач на Python

Built-in module to calculate the least common multiple

However, there is a Greatest Common Divisor function in the math library. (For Python 3.4 or 2.7, it’s buried in fractions instead.) And writing an LCM on top of a GCD is pretty trivial:

def lcm(a, b): return abs(a*b) // math.gcd(a, b) 

Or, if you’re using NumPy, it’s come with an lcm function for quite some time now.

146k 84 84 gold badges 412 412 silver badges 460 460 bronze badges
answered Aug 6, 2018 at 23:39
358k 52 52 gold badges 605 605 silver badges 678 678 bronze badges
Since Py3.9 there is now math.lcm()
Jun 15, 2020 at 12:57
The subject of this meta question.
Nov 18, 2020 at 4:02

In Python 3.9+

This is available as math.lcm() . It also takes any number of arguments, allowing you to find the lowest common multiple of more than 2 integers.

>>> from math import lcm >>> lcm(2, 5, 7) 70 

answered Mar 23, 2020 at 22:26
1,220 12 12 silver badges 15 15 bronze badges

Try this instead:

def lcm(x, y): from fractions import gcd # or can import gcd from `math` in Python 3 return x * y // gcd(x, y) 

answered Aug 6, 2018 at 23:37
Tim Peters Tim Peters
68.1k 14 14 gold badges 127 127 silver badges 133 133 bronze badges
Why do you put the import in the function?
Jan 2, 2020 at 17:14

Why not? It’s better to post a self-contained solution than to assume the user is fine with littering a containing scope with names (like «gcd») that are irrelevant to solving the problem at hand. If you want to move the import to a containing scope, that’s fine.

Jan 2, 2020 at 17:26

There is one disadvantage on having imports inside functions: Any missing module will only be discovered when such function is executed. Having all imports unconditionally at the top of a module makes sure all dependencies are available by the time the module is loaded. (Sure, this is not an issue for standard lib modules.)

Jan 5, 2020 at 14:43

^^ Also, the import time might be expensive. It’s generally advisable to pay the cost at module import time rather than function call.

Oct 15, 2020 at 9:32

@TimPeters I’ve understood that the module level __all__ is intended to advertise public names, and some extra names in containing scopes doesn’t really harm anything. As for «why not», the style guide does say Imports are always put at the top of the file but I think the more important reason is for code to be up-front about their dependencies. That makes browsing a large code-base easier, and during testing it means mocking/patching a dependency from the module namespace is simpler.

Python Program to Find LCM

To understand this example, you should have the knowledge of the following Python programming topics:

• Python while Loop
• Python Functions
• Python Function Arguments
• Python User-defined Functions

The least common multiple (L.C.M.) of two numbers is the smallest positive integer that is perfectly divisible by the two given numbers.

For example, the L.C.M. of 12 and 14 is 84.

Program to Compute LCM

# Python Program to find the L.C.M. of two input number def compute_lcm(x, y): # choose the greater number if x > y: greater = x else: greater = y while(True): if((greater % x == 0) and (greater % y == 0)): lcm = greater break greater += 1 return lcm num1 = 54 num2 = 24 print("The L.C.M. is", compute_lcm(num1, num2))

Output

The L.C.M. is 216 

Note: To test this program, change the values of num1 and num2 .

This program stores two number in num1 and num2 respectively. These numbers are passed to the compute_lcm() function. The function returns the L.C.M of two numbers.

In the function, we first determine the greater of the two numbers since the L.C.M. can only be greater than or equal to the largest number. We then use an infinite while loop to go from that number and beyond.

In each iteration, we check if both the numbers perfectly divide our number. If so, we store the number as L.C.M. and break from the loop. Otherwise, the number is incremented by 1 and the loop continues.

The above program is slower to run. We can make it more efficient by using the fact that the product of two numbers is equal to the product of the least common multiple and greatest common divisor of those two numbers.

Number1 * Number2 = L.C.M. * G.C.D. 

Here is a Python program to implement this.

Program to Compute LCM Using GCD

# Python program to find the L.C.M. of two input number # This function computes GCD def compute_gcd(x, y): while(y): x, y = y, x % y return x # This function computes LCM def compute_lcm(x, y): lcm = (x*y)//compute_gcd(x,y) return lcm num1 = 54 num2 = 24 print("The L.C.M. is", compute_lcm(num1, num2)) 

The output of this program is the same as before. We have two functions compute_gcd() and compute_lcm() . We require G.C.D. of the numbers to calculate its L.C.M.

So, compute_lcm() calls the function compute_gcd() to accomplish this. G.C.D. of two numbers can be calculated efficiently using the Euclidean algorithm.

Click here to learn more about methods to calculate G.C.D in Python.