Как найти произведение двух чисел в питоне

Я приведу не очень практичное, но красивое решение в одну строку. Оно не использует eval, побочные эффекты при работе со списком или именованные функции.

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

def p(a):
    if a:
        return a[0] * p(a[1:])
    return 1

print(p([1, 2, 3, 4, 5]))

Нам оно не подходит, так именованная функция требует минимум две строки для определения и вызова. Лямбду можно определить и вызвать в одной строке, но есть трудность в создании рекурсивной лямбды. Синтаксис Python разрешает такой трюк:

p = (lambda a: a[0] * p(a[1:]) if a else 1); print(p([1, 2, 3, 4, 5]))

Это именно трюк с глобальной переменной и двумя операторами в одной строке. А можно обойтись без глобальной переменной вообще. На первый взгляд этого не может быть так как имя нужно чтобы сделать рекурсивный вызов. Но функцию можно передать как аргумент в саму себя:

p = lambda f, a: a[0] * f(f, a[1:]) if a else 1
print(p(p, [1, 2, 3, 4, 5]))

Кажется мы ничего не выиграли: всё равно два оператора и глобальная переменная p. Однако сделан очень важный шаг — тело лямбды не использует глобальные переменные. Глобальная переменная используется в операторе print. Избавимся от неё:

p = lambda f, a: a[0] * f(f, a[1:]) if a else 1
y = lambda f, a: f(f, a)
print(y(p, [1, 2, 3, 4, 5]))

Стало только хуже: три строки и две глобальные переменные. Зато каждая глобальная переменная задействована только один раз. Делаем подстановку:

print((lambda f, a: f(f, a))(lambda f, a: a[0] * f(f, a[1:]) if a else 1, [1, 2, 3, 4, 5]))

Читается тяжело, но задача решена в одну строку без глобальных имён и волшебных вызовов eval.

P.S. Читайте Fixed-point combinator чтобы узнать откуда пошло это решение.

P.P.S. Красивое утверждение: программу любой сложности можно записать в функциональном стиле не определив ни одной глобальной переменной, включая имена функций.

P.P.P.S. Не пытайтесь повторить это дома.

Для ввода значений с клавиатуры используем функцию input(«…») с соответствующей подсказкой

Для для нахождения остатка от деления используется оператор *

Для обработки целых значений делимого и делителя (x и y) подойдёт следующая программа:

x=int(input(«Первы­й сомножитель X=»))

y=int(input(«Второ­й сомножитель Y=»))

print(f’Произведен­ие X*Y={x*y}’)

Результат выполнения:

Первый сомножитель X=3

Второй сомножитель Y=8

Произведение X*Y=24

Если x и y могут быть десятичными числами, то код программы будет таким:

x=float(input(«Пер­вый сомножитель X=»))

y=float(input(«Вто­рой сомножитель Y=»))

print(f’Произведен­ие X*Y={x*y}’)

Пример выполнения

Первый сомножитель X=3.25

Второй сомножитель Y=8

Произведение X*Y=26.0

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

Говоря о числах, мы пройдемся по наиболее часто используемым математическим операторам, которые нужны для выполнения простых арифметических операций с числами в Python. А в разделе «Математические функции» познакомимся с функциями, которые будут очень полезны при вычислении сложных математических выражений: возведение в степень, синус/косинус, факториалы и т. д. Приступим.

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

Числа

 Python есть 6 основных «математических» операторов:

1. сложение;
2. вычитание;
3. умножение;
4. деление;
5. возведение в степень.
6. остаток от деления (mod);
7. целочисленное деление (div).

Большинство из вас должно быть знакомо со всеми вышеперечисленными операторами, кроме оператора взятия остатка от деления и целочисленного деления. Не волнуйтесь, мы поговорим об этом. Начнем с начала.

Сложение

Несложно догадаться, что делает этот оператор: он просто складывает числа. Чтобы проверить, как это работает, просто перейдите в IDLE и введите число, затем знак сложения + (плюс), а затем еще одно число, которое нужно добавить к первому числу. Нажмите Enter. Это должно выглядеть так, как показано ниже.

Пример: сложим 8 и 19.

>>> 8+19
27

После нажатия клавиши Enter чуть ниже строки кода появится ответ. Вывод так и будет отображаться каждый раз — чуть ниже кода. Нажимаете Enter — получаете результат. 

Не останавливайтесь на этом примере, попробуйте использовать оператор сложения с другими числами. Например, попробуйте сложить числа с плавающей точкой: 4.5 + 5.5 и т. д.

У вычитания такой же синтаксис, как и у сложения. Просто измените оператор на знак вычитания - (минус). Так же выберите случайные числа и попробуйте вычесть одно из другого.

Пример: вычтем из 89.33 число 23.67. Ответ 65.55. 

Умножение

Опять то же самое! Просто измените оператор на * (звездочку). Вы ведь знаете, что он используется для умножения, верно? Попробуйте использовать оператор в IDLE. 

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

Деление

На этот раз нам понадобится знак / (слэш). Попробуйте использовать оператор со случайными числами. 

Если вы новичок, то можете столкнуться с некоторыми трудностями. Какими? Сейчас узнаем. Для начала возьмем целые числа (числа без десятичной дроби), например 16 и 2, и разделим одно на другое.

>>> 16/2
8

Возведение в степень

Этого математического оператора обычно в языках программирования нет. Честно говоря, языков со встроенным возведением в степень, кроме Python, и не припомнить. В других языках для возведения в степень используют другие операторы. В Python же для этого достаточно поставить между двумя числами ** (две звездочки). Правое число возведется в степень, равную левому числу. Например, чтобы найти 10 степень числа 2, нужно написать:

>>> 2**10
1024

Теперь мы знаем обо всех часто используемых математических операторах Python. Попробуйте объединить несколько операторов и использовать их в одном выражении. Например, введите ((2**5)*10)/3. Python должен вывести 106.66666666666667.

Взятие остатка от деления

Оператор взятия остатка от деления в Python обозначается % (знак процента). Если вам знакомы другие языки программирования, скорее всего, вы знаете, что такое взятие остатка от деления. В других языках этот оператор часто называют mod. Если вы с ним еще не знакомы, ничего страшного. 

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

• 12%2 = 0, так как 12 полностью делится на 2. 
• 13%2 = 1, так как остаток от деления 13 на 2 равен 1. 
• 19%5 = 4, так как, опять же, остаток от деления 19 на 5 равен 4.

В IDLE все так же:

Целочисленное деление

Этот оператор в Python обозначается знаком // (двумя слэшами), в других языках его называют div. Оператор откидывает остаток и оставляет только целую часть. Вот как это работает:

• 13//2 = 6, так как 13/2 = 6.5
• 19//5 = 3, так как 19/5 = 3.8

Попробуйте использовать целочисленное деление со случайными числами в своей IDLE.

Математические функции

Когда вы узнаете о Python побольше, возможно, вам захочется создать «научный калькулятор» в качестве проекта. Для этого кроме простых математических операций вам придется реализовать математические функций: тригонометрические, логарифмические и так далее. Но даже если мы забудем о создании продвинутого калькулятора, в жизни программиста достаточно ситуаций, когда вам могут понадобиться эти функции. 

Например, если вы создаете ПО для инженеров-строителей — им математические функции нужны для расчета различных параметров в конструкции, которую они строят. Или, например, аэрокосмическое ПО для расчетов траектории спутника и так далее. Короче говоря, сложные математические функции используются в совершенно различных реальных программах, так что знать о них нужно.  

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

Подробнее о функциях в Python мы поговорим в другой статье. Здесь мы лишь немного коснемся этого вопроса.

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

Как вы можете увидеть на рисунке выше, на вход функции подается x, а на выходе функция f выводит значение f(x). В целом, функции не обязательно принимать что-то на вход или выводить что-то. Но для математической функции важно и то, и другое. Например, чтобы вычислить sin(x) обязательно нужно значение x.

В Python есть два типа функций.

• Встроенные функции — это функции, для которых не требуется никаких сторонних файлов кода (они же модули или библиотеки). Они — часть Python и генерируются в компиляторе Python, поэтому ничего импортировать для их использования не нужно.
• Пользовательские функции требуют внешних файлов, их называют модулями. Использование этих внешних файлов в вашем коде называется импортом. Все, что вам нужно сделать, чтобы использовать функции из библиотека, это импортировать их в ваш код.

Пришло время протестировать математические функции. Начнем со степенных функций!

Возведение в степень — pow(x, y)

Я знаю, о чем вы думаете. Мы же только что возводили числа в степень, так? Так. Но тогда мы возводили число в степень при помощи оператора, а это — встроенная функция. Это альтернативный способ возведения в степень. 

Поскольку это встроенная функция, импортировать никаких библиотек не нужно. На вход функция pow(x, y) принимает два числа — основание и показатель степени.

Откройте IDLE и напишите: 

>>> pow(3, 2)

Теперь проанализируем, что мы написали и что сделает Python. Сначала мы ввели pow — это просто имя функции, которую мы пытаемся вызвать. Это укажет компилятору Python найти встроенную функцию с именем pow и определить, что она может делать. Далее в скобках мы написали два числа через запятую: 3 и 2. Первое число — 3 — основание, а второе — 2 — показатель степень. Иначе говоря, мы пытаемся возвести 3 во вторую степень. 

Как только компилятор Python убедится, что синтаксис верен, он начнет искать реализацию функции pow и выведет ответ: 9.

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

>>> имя_функции(аргумент1, необязательный_аргумент2, необязательный_аргумент3, ...)

Значения в скобках, разделенные запятыми, называются аргументами. В функции pow(x, y) в примере выше аргументами являлись 3 и 2. В функции может быть любое количество аргументов. У математических функций, как правило, есть как минимум один аргумент. Давайте рассмотрим другие встроенные математические функции. 

Модуль — abs(x)

Функция модуля возвращает неотрицательное значение аргумента. Иначе говоря, она не меняет неотрицательные значения, а отрицательные значения делает положительными. 

Пример: модуль -3 равен 3, модуль -8.74 равен 8.74 и так далее.

Синтаксис

>>> abs(-99.99)

Так как -99.99 — отрицательное число, выводом будет положительное число — 99.99.

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

Синус — sin(x)

Синус — тригонометрическая функция, она принимает только одно значение в качестве аргумента — x. Аргумент должен быть выражен в радианах, не путайте со степенью. Как мы уже сказали, эту функцию не получится использовать напрямую. Если вы попытаетесь вызвать функцию sin(x), получите сообщение об ошибке. 

Дело в том, что компилятор не знает, что ему делать, когда он встречает функцию sin(), поскольку мы ее не определили. Чтобы использовать ее, придется импортировать математический модуль Python, в котором в том числе есть уже реализованная функция sin(), которая поможет компилятору понять, что делать, когда он встречает эту функцию. 

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

>>> import math

Жмем Enter, и готово! Теперь, чтобы использовать функцию sin(), перейдите в новую строку и введите:

>>> math.sin(3.14159)

Поскольку 3.14159 это приблизительно π, ответ будет близок к нулю.

Как вы можете видеть, ответ такой — 2.653589335273e-6. Он может показаться немного пугающим, но на самом деле, это всего лишь значит следующее: 2.653589335273 × 10^-6, что равно 0.000002653589335273. Действительно близко к нулю.

В математическом модуле есть еще ряд полезных математических функций: floor(), exp(), log(), sqrt() и многие другие. Их полный список и количество аргументов, которые они принимают на вход, можно найти на официальном сайте Python в разделе Mathematical Functions. 

Given a list, print the value obtained after multiplying all numbers in a list. 

Examples: 

Input :  list1 = [1, 2, 3] 
Output : 6 
Explanation: 1*2*3=6 

Input : list1 = [3, 2, 4] 
Output : 24 

Method 1: Traversal

Initialize the value of the product to 1(not 0 as 0 multiplied with anything returns zero). Traverse till the end of the list, multiply every number with the product. The value stored in the product at the end will give you your final answer.

Below is the Python implementation of the above approach:  

Time complexity: O(n), where n is the number of elements in the list.
Auxiliary space: O(1),

Method 2: Using numpy.prod()

We can use numpy.prod() from import numpy to get the multiplication of all the numbers in the list. It returns an integer or a float value depending on the multiplication result.

Below is the Python3 implementation of the above approach:  

Output: 
 

6
24 

Time complexity: O(n), where n is the length of the input lists. 
Auxiliary space: O(1). 

Method 3 Using lambda function: Using numpy.array

Lambda’s definition does not include a “return” statement, it always contains an expression that is returned. We can also put a lambda definition anywhere a function is expected, and we don’t have to assign it to a variable at all. This is the simplicity of lambda functions. The reduce() function in Python takes in a function and a list as an argument. The function is called with a lambda function and a list and a new reduced result is returned. This performs a repetitive operation over the pairs of the list.

Below is the Python3 implementation of the above approach:  

Time complexity: O(n) – where n is the length of the longer list.
Auxiliary space: O(1) – the memory used is constant, as no extra data structures are create.

Method 4 Using prod function of math library: Using math.prod

Starting Python 3.8, a prod function has been included in the math module in the standard library, thus no need to install external libraries.

Below is the Python3 implementation of the above approach:  

Output: 
 

6
24 

Time complexity: O(n), where n is the length of the input list. 
Auxiliary space: O(1), as the program only uses a fixed amount of memory to store the input lists and the output variables.

Method 5: Using mul() function of operator module. 

First we have to import the operator module then using the mul() function of operator module multiplying the all values in the list. 

Time complexity:

The program contains a single for loop that iterates through each element in the input list. Therefore, the time complexity of the program is O(n), where n is the length of the input list.
 

Auxiliary space:

The program uses a constant amount of auxiliary space throughout its execution. Specifically, it only creates four variables: list1, m, i, and the imported mul function from the operator module. The space required to store these variables does not depend on the size of the input list, and therefore the auxiliary space complexity of the program is O(1), which is constant.
 

Method 6: Using traversal by index

Time complexity: O(n), where n is the length of the input list. 

Auxiliary space: O(1), as the program uses a single variable to store the result and does not use any additional data structure. 

Method 7: Using itertools.accumulate

Output:

6
24

The time complexity is O(n), where n is the length of the input list.

The auxiliary space is also O(n) 

Method 8: Using the recursive function 

The function product_recursive() takes a list of numbers as input and returns the product of all the numbers in the list, using a recursive approach.

The steps for this function are:

1. Check if the list is empty. If it is, return 1 (the product of an empty list is defined as 1).
2. If the list is not empty, recursively call the product_recursive() function on the rest of the list (i.e., all the elements except for the first one) and multiply the result by the first element of the list.
3. Return the product obtained from step 2.
    

The time complexity of this function is O(n), where n is the number of elements in the list. This is because the function needs to perform n recursive calls, one for each element in the list. 
The space complexity is also O(n) because the function creates n recursive calls on the call stack. This means that for large lists, the function can quickly use up a lot of memory, which can cause the program to crash or slow down significantly.

Method: Using  reduce() and the mul() function’s

One approach to solve this problem is to use the built-in reduce() function from the functools module, which can apply a function to an iterable in a cumulative way. We can use the operator.mul() function to multiply the elements together.

Here are the steps and code:

1. Import the reduce() function and mul() function from the functools and operator modules, respectively.
2. Define the input list.
3. Apply the reduce() function to the list, using mul() as the function to apply.
4. Print the result.

Time complexity: O(n)
Auxiliary space: O(1)

Last Updated :
25 Apr, 2023

Like Article

Save Article