Как перемножить числа в списке?

Можно реализовать функцию mul

def mul(list_):
    n = 1
    for el in list_:
        n *= el
    return n

либо так, с помощью lambda и рекурсии

mul = lambda arr:arr[0] * mul(arr[1:]) if arr else 1

Раньше можно было использвать reduce(). Сейчас тоже можно, но эту функцию вынесли в отдельный модуль, так что строго говоря, считая импорт, получается две строчки:

import functools
print (functools.reduce(lambda a, b : a * b, lst)) 

С импортом можно и так:

import numpy as np
result = np.prod(np.array(mylist))

from functools import reduce  # Функция для свёрки последовательности
from operator import mul  # Функция, перемножающая 2 числа

spisok = [16, 15, 9, 14, 13]  # Исходный список

result = reduce(mul, spisok)
#                    /\ Список для свёртки
#               /\ Используем умножение
#        /\ Сворачиваем контейнер

let num = Number(prompt())
let lis = []
let mult = []

while (num) {
   num = Number(prompt())
   lis.append(num)
}
var m = 1
for (let n = 0; n < lis.length; n++) {
  m = m*lis[n]
  mult.append(m)
}

Все ответы здесь отстали от современности. Как насчет python-3.8 и выше?

import math
math.prod([1, 2, 3, 4, 5, 6, 7, 8, 9, 10])

Это пожалуй самое простое и стандартное решение ИМХО.

d = [1, 2, 3, 4, 5]
print(eval(str(d)[1:-1].replace(',', '*')))

Если очень захотеть, то можно и в одну строчку записать, но так конечно делать не стоит , например перемножить '2 3 4 5' = 120

print(list(map(lambda s, t=[1]: [t.append(i*t[-1]) for i in map(int, s.split())][0] or t[-1], ['2 3 4 5']))[0])  # 120

Я приведу не очень практичное но красивое решение в одну строку. Оно не использует 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. Не пытайтесь повторить это дома.

Можно сделать так:

arr = [1,2,3,4,5]
output = 1
for i in arr:
    output *= i
print(output) #120