Как я могу перемножить все элементы в списке вместе с Python?
Смотрите документацию reduce и operator.mul для объяснения. Вам нужна строка import functools в Python 3+.
Поделиться 12 декабря 2012 в 13:03
Я бы использовал numpy.prod для выполнения задачи:
import numpy as np mylist = [1, 2, 3, 4, 5, 6] result = np.prod(np.array(mylist)) Поделиться 06 сентября 2015 в 17:54
Если вы хотите избежать импорта чего-либо и избежать более сложных областей Python, вы можете использовать простой цикл for:
nums = [1, 2, 3] product = 1 # Don't use 0 here, otherwise, you'll get zero # because anything times zero will be zero. for num in nums: product *= num Поделиться 12 декабря 2012 в 15:47
В Python 3.8 и выше, модуль стандартной библиотеки math предоставляет .prod для этой цели:
math.prod(iterable, *, start=1)
Метод возвращает произведение значения start (по умолчанию: 1) в размере числа в итерируемом объекте:
import math math.prod([1, 2, 3, 4, 5, 6]) # 720 Если итерируемый объект пустой, это приведет к появлению 1 (или значения start , если они предоставлены).
Поделиться 14 февраля 2019 в 19:32
Вот некоторые измерения производительности с моей машины. Соответствующие в случае, если это выполняется для небольших входов в длительном цикле:
import functools, operator, timeit import numpy as np def multiply_numpy(iterable): return np.prod(np.array(iterable)) def multiply_functools(iterable): return functools.reduce(operator.mul, iterable) def multiply_manual(iterable): prod = 1 for x in iterable: prod *= x return prod sizesToTest = [5, 10, 100, 1000, 10000, 100000] for size in sizesToTest: data = [1] * size timerNumpy = timeit.Timer(lambda: multiply_numpy(data)) timerFunctools = timeit.Timer(lambda: multiply_functools(data)) timerManual = timeit.Timer(lambda: multiply_manual(data)) repeats = int(5e6 / size) resultNumpy = timerNumpy.timeit(repeats) resultFunctools = timerFunctools.timeit(repeats) resultManual = timerManual.timeit(repeats) print(f'Input size: 7d> Repeats: 8d> Numpy: , Functools: , Manual: ') Результаты:
Input size: 5 Repeats: 1000000 Numpy: 4.670, Functools: 0.586, Manual: 0.459 Input size: 10 Repeats: 500000 Numpy: 2.443, Functools: 0.401, Manual: 0.321 Input size: 100 Repeats: 50000 Numpy: 0.505, Functools: 0.220, Manual: 0.197 Input size: 1000 Repeats: 5000 Numpy: 0.303, Functools: 0.207, Manual: 0.185 Input size: 10000 Repeats: 500 Numpy: 0.265, Functools: 0.194, Manual: 0.187 Input size: 100000 Repeats: 50 Numpy: 0.266, Functools: 0.198, Manual: 0.185 Вы можете видеть, что Numpy немного медленнее на небольших входах, так как он выделяет массив перед выполнением умножения. Также будьте осторожны с переполнением в Numpy.
Поделиться 28 ноября 2017 в 12:44
Numpy имеет функцию prod() , которая возвращает продукт списка, или в этом случае, так как он numpy, он является продуктом массива над заданной осью:
import numpy a = [1,2,3,4,5,6] b = numpy.prod(a) . или вы можете просто импортировать numpy.prod() :
from numpy import prod a = [1,2,3,4,5,6] b = prod(a) Поделиться 21 августа 2019 в 05:05
Мне лично нравится это для функции, которая умножает все элементы общего списка вместе:
def multiply(n): total = 1 for i in range(0, len(n)): total *= n[i] print total Она компактна, использует простые вещи (переменную и цикл for), и мне кажется интуитивной (так выглядит, как я думаю о проблеме, просто возьму одну, умножаю ее, а затем умножаю на следующую и так далее!)
Поделиться 22 июня 2015 в 23:31
Простой способ:
import numpy as np np.exp(np.log(your_array).sum()) Поделиться 13 января 2018 в 20:55
nums = str(tuple([1,2,3])) mul_nums = nums.replace(',','*') print(eval(mul_nums)) Поделиться 09 сентября 2016 в 05:26
Просто хочу добавить однострочный ответ Python 3.8:
def multiply(l): return [b := 1, [b := b * a for a in l]][-1][-1] print(multiply([2, 3, 8, 10])) - [b := 1, предназначен для определения временной переменной
- . [b := b * a для a в l] предназначен для перебора списка и умножения b на каждый элемент
- . [-1][-1] предназначен для того, чтобы окончательный список был [b, [b * l[0], b * l[1]. b * l[-1]]] . и, таким образом, элемент в конечном положении — это умножение всех элементов в списке.
Поделиться 24 июля 2022 в 11:28
Сегодня я нашел этот вопрос, но заметил, что он не имеет случая, когда в списке есть None . Таким образом, полное решение будет:
from functools import reduce a = [None, 1, 2, 3, None, 4] print(reduce(lambda x, y: (x if x else 1) * (y if y else 1), a)) В случае добавления у нас есть:
print(reduce(lambda x, y: (x if x else 0) + (y if y else 0), a)) Поделиться 07 июля 2016 в 14:58
Один из способов, который вы можете использовать, это math.prod() Например:
import math arr = [1, 2, 3, 4] print(math.prod(arr)) Другой способ — numpy.prod() Это другая библиотека для импорта
import numpy arr = [1, 2, 3, 4] print(numpy.prod(arr)) Поделиться 05 февраля 2023 в 00:04
Как насчет использования рекурсии?
def multiply(lst): if len(lst) > 1: return multiply(lst[:-1])* lst[-1] else: return lst[0] Поделиться 05 марта 2018 в 08:39
В этой ветке есть много хороших ответов. Если вы хотите перемножить список в реальном производстве, я рекомендую использовать стандартные пакеты numpy или math.
Если вы просто ищете быстрое и грязное решение и не хотите ничего импортировать, вы можете сделать это:
l = [1,2,3,4,5,6] def list_multiply(l): return eval('*'.join(map(str,l))) print(list_multiply(l)) #Output: 720 map(str,l) преобразует каждый элемент в списке в строку. join объединяет каждый элемент в одну строку, разделенную символом * . eval преобразует строку обратно в функцию, которая может оцениваться.
Предупреждение: eval считается опасным использовать, особенно если программа принимает ввод пользователя, потому что пользователь может потенциально ввести любую функцию в код и поставить под угрозу вашу систему.
Python как перемножить элементы списка
На этом шаге мы рассмотрим назначение и примеры использования этих функций .
До сих пор мы только выводили элементы последовательностей. Теперь попробуем умножить каждый элемент списка на 2:
arr = [1, 2, 3] for i in arr: i = i * 2 print(arr)
Рис.1. Текст программы и результат выполнения
Архив с файлом можно взять здесь.
Как видно из примера, список не изменился. Переменная i на каждой итерации цикла содержит лишь копию значения текущего элемента списка. Изменить таким способом элементы списка нельзя. Чтобы получить доступ к каждому элементу, можно, например, воспользоваться функцией range () для генерации индексов. Функция range() имеет следующий формат:
range([Начало>, ]Конец>[, Шаг>])
Первый параметр задает начальное значение. Если параметр < Начало >не указан, то по умолчанию используется значение 0. Во втором параметре указывается конечное значение. Следует заметить, что это значение не входит в возвращаемые значения. Если параметр < Шаг >не указан, то используется значение 1. Функция возвращает диапазон — особый объект, поддерживающий итерационный протокол. С помощью диапазона внутри цикла for можно получить значение текущего элемента. В качестве примера умножим каждый элемент списка на 2 (рисунок 2).
arr = [1, 2, 3] for i in range(len(arr)): arr[i] *= 2 print(arr)
Рис.2. Текст программы и результат выполнения
Архив с файлом можно взять здесь.
В этом примере мы получаем количество элементов списка с помощью функции len () и передаем результат в функцию range () . В итоге функция range() возвращает диапазон значений от 0 до len (arr) — 1. На каждой итерации цикла через переменную i доступен текущий элемент из диапазона индексов. Чтобы получить доступ к элементу списка, указываем индекс внутри квадратных скобок. Умножаем каждый элемент списка на 2, а затем выводим результат с помощью функции print () .
Рассмотрим несколько примеров использования функции range() . Выведем числа от 1 до 100:
for i in range(1, 101): print(i)
Можно не только увеличивать значение, но и уменьшать его. Выведем все числа от 100 до 1:
for i in range(100, 0, -1): print(i)
Можно также изменять значение не только на единицу. Выведем все четные числа от 1 до 100:
for i in range(2, 101, 2): print(i)
В Python 3 поведение функция range() возвращает диапазон. Чтобы получить список чисел, следует передать диапазон, возвращенный функцией range() , в функцию list() (рисунок 3).
>>> obj = range(len([1, 2, 3])) >>> obj range(0, 3) >>> obj[0], obj[1], obj[2] # Доступ по индексу (0, 1, 2) >>> obj[0:2] # Получение среза range(0, 2) >>> i = iter(obj) >>> next(i), next(i), next(i) # Доступ с помощью итераторов (0, 1, 2) >>> list(obj) # Преобразование диапазона в список [0, 1, 2] >>> 1 in obj, 7 in obj # Проверка вхождения значения (True, False)
Рис.3. Создание списка чисел на основе диапазона
index (< Значение >) — возвращает индекс элемента, имеющего указанное значение. Если значение не входит в диапазон, возбуждается исключение ValueError . Пример:
>>> obj = range(1, 5) >>> obj.index(1), obj.index(4) (0, 3) >>> obj.index(5) Traceback (most recent call last): File "#11>", line 1, in obj.index(5) ValueError: 5 is not in range
>>> obj = range(1, 5) >>> obj.count(1), obj.count(10) (1, 0)
Функция enumerate (< объект >[, start=0]) на каждой итерации цикла for возвращает кортеж из индекса и значения текущего элемента. С помощью необязательного параметра start можно задать начальное значение индекса. В качестве примера умножим на 2 каждый элемент списка, который содержит четное число (рисунок 4).
arr = [1, 2, 3, 4, 5, 6] for i, elem in enumerate(arr): if elem % 2 == 0: arr[i] *= 2 print(arr)
Рис.4. Пример использования функции enumerate() . Текст программы и результат выполнения
Архив с файлом можно взять здесь.
Функция enumerate() не создает список, а возвращает итератор. С помощью функции next() можно обойти всю последовательность. Когда перебор будет закончен, возбуждается исключение StopIteration :
>>> arr = [1, 2] >>> obj = enumerate(arr, start=2) >>> next(obj) (2, 1) >>> next(obj) (3, 2) >>> next(obj) Traceback (most recent call last): File "", line 1, in next(obj) StopIteration
Кстати, цикл for при работе активно использует итераторы, но делает это незаметно для нас.
На следующем шаге мы рассмотрим цикл while .
Как перемножить числа в списке?
Пользователь вводит любые числа в строку, которые добавляются в список. Сумму можно найти так: sum(spisok) . А как найти произведение? Можно, вроде, циклом через for . А если, например, нужно в одну строку, то как реализовать?
Отслеживать
2,786 2 2 золотых знака 10 10 серебряных знаков 38 38 бронзовых знаков
задан 3 дек 2020 в 9:28
833 1 1 золотой знак 10 10 серебряных знаков 31 31 бронзовый знак
10 ответов 10
Сортировка: Сброс на вариант по умолчанию
Раньше можно было использвать reduce(). Сейчас тоже можно, но эту функцию вынесли в отдельный модуль, так что строго говоря, считая импорт, получается две строчки:
import functools print (functools.reduce(lambda a, b : a * b, lst)) Отслеживать
Я бы добавил ещё и третью строчку, с импортом оператора умножения =) Upd: А, это есть ниже)
3 дек 2020 в 11:30
а почему сделали общим?
3 дек 2020 в 14:12
@Danis Я сам сделал, потому что код не мой и есть на многих страницах в интернете как иллюстрация к reduce()
3 дек 2020 в 14:33
Все ответы здесь отстали от современности. Как насчет python-3.8 и выше?
math.prod
import math math.prod([1, 2, 3, 4, 5, 6, 7, 8, 9, 10]) Это пожалуй самое простое и стандартное решение ИМХО.
Отслеживать
5,436 1 1 золотой знак 16 16 серебряных знаков 36 36 бронзовых знаков
ответ дан 21 дек 2020 в 11:51
USERNAME GOES HERE USERNAME GOES HERE
10.4k 21 21 золотой знак 25 25 серебряных знаков 53 53 бронзовых знака
from functools import reduce # Функция для свёрки последовательности from operator import mul # Функция, перемножающая 2 числа spisok = [16, 15, 9, 14, 13] # Исходный список result = reduce(mul, spisok) # /\ Список для свёртки # /\ Используем умножение # /\ Сворачиваем контейнер Отслеживать
ответ дан 3 дек 2020 в 10:16
Mikhail Murugov Mikhail Murugov
5,436 1 1 золотой знак 16 16 серебряных знаков 36 36 бронзовых знаков
Можно реализовать функцию 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 Отслеживать
ответ дан 3 дек 2020 в 9:41
19.7k 6 6 золотых знаков 22 22 серебряных знака 56 56 бронзовых знаков
тут пять строк, не считая той, где это будет вызываться. Про for автор даже в вопросе сам написал.
3 дек 2020 в 9:42
С импортом можно и так:
import numpy as np result = np.prod(np.array(mylist)) Отслеживать
ответ дан 3 дек 2020 в 9:51
Serg Bocharov Serg Bocharov
1,704 1 1 золотой знак 6 6 серебряных знаков 11 11 бронзовых знаков
Тяжеленный numpy для таких простейших задач.
3 дек 2020 в 10:17
@МихаилМуругов вопрос-то был «а можно ли сделать в одну строку?» — вот и приводим разные примеры
3 дек 2020 в 10:43
let num = Number(prompt()) let lis = [] let mult = [] while (num) < num = Number(prompt()) lis.append(num) >var m = 1 for (let n = 0; n
Отслеживать
ответ дан 3 дек 2020 в 10:56
Alexander_Sky Alexander_Sky
87 1 1 серебряный знак 8 8 бронзовых знаков
А где тут python?
3 дек 2020 в 10:58
а как это все записать в одну строчку?
3 дек 2020 в 11:01
@Эникейщик это даже не python))
3 дек 2020 в 11:01
)) правда, не обратил внимание, но это в целом не сложно должно быть переделать, если видишь на одном языке
3 дек 2020 в 11:02
@Alexander_Sky Ничего, я тут тоже поначалу путался где какой язык )) А надо на тэги смотреть
3 дек 2020 в 11:17
Я приведу не очень практичное, но красивое решение в одну строку. Оно не использует 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. Не пытайтесь повторить это дома.
Модификация списков поэлементно — Python: Списки
Как вы помните, элементы списков индексированы, то есть каждый элемент имеет порядковый номер. Первый элемент имеет индекс 0 , последний — len(list) — 1 .
Функция len возвращает длину списка, но работает она с различными типами, например — со строками и кортежами.
Элементы списка можно получать и заменять через присваивание по их индексу. Если указать отрицательный индекс, то элементы будут браться с конца.
Последний элемент списка будет иметь отрицательный индекс -1 . Увы, -0 использовать не получится. Вот пара примеров использования индексов со списком:
l = [0] * 3 l[0], l[1] = 10, 32 l[-1] = l[0] + l[1] print(l) # => [10, 32, 42] Обратите внимание, что мы создали список клонированием нулей. Так делать безопасно, потому что числа в Python — неизменяемые. Впрочем, все модификации списка сделаны через присваивание, поэтому ничего неожиданного мы бы не получили, даже если бы использовали изменяемые объекты.
pop и insert
Итак, получать и заменять элементы по одному мы умеем. Неплохо бы еще уметь удалять старые элементы и вставлять в середину списка новые. За это отвечают методы pop и insert соответственно. pop удаляет элемент по индексу.
Если не указать индекс, то удаляется последний элемент. При этом pop возвращает значение элемента, который удаляет:
l = [1, 2, 3] l.pop() # 3 print(l) # => [1, 2] l.pop(0) # 1 print(l) # => [2] А вот пример использования insert :
l = [1, 2, 3] l.insert(1, 100) print(l) # => [1, 100, 2, 3] l.insert(-1, 200) print(l) # => [1, 100, 2, 200, 3] insert всегда вставляет новый элемент перед элементом с указанным индексом относительно начала списка. При этом не важно, откуда мы индекс отсчитывали — от начала или от конца. И insert(-1, ..) вставляет элемент именно перед последним элементом.
Интересно, что l.insert(len(l), x) добавит элемент x в конец списка l , то есть сработает как l.append(x) .
Фактически здесь не будет элемента, перед которым будет вставлен новый, вот новый элемент и попадет в конец списка.
Имейте в виду эту особенность, но используйте append , хотя бы потому, что его вызов проще читается.
Ошибки индексации
Если попытаться вызвать pop() у пустого списка или указать индекс за пределами индексов существующих элементов, вы получите ошибку IndexError :
l = [] l.pop() # Traceback (most recent call last): # File "", line 1, in # IndexError: pop from empty list А вот insert более терпим к некорректным индексам и просто добавляет элементы с соответствующего края:
l = [0] l.insert(-500, 1) l.insert(1000, 2) print(l) # => [1, 0, 2] Однако полагаться на это не стоит — индексы все же лучше держать под контролем.
Сортировка и разворачивание
Списки чего-либо периодически приходится сортировать, а иногда и разворачивать. Желательно уметь это делать эффективно. Поэтому список уже имеет встроенные средства для выполнения обеих задач — методы sort и reverse . Оба метода изменяют список по месту. Посмотрим на несколько примеров:
l = [1, 3, 7, 2, 10, 8] l.sort() print(l) # => [1, 2, 3, 7, 8, 10] l.reverse() print(l) # => [10, 8, 7, 3, 2, 1] Эти методы могут работать без параметров. В случае reverse нечего и параметризовывать: разворачивание — это всегда разворачивание.
А вот сортировка может производиться по разным критериям. Если вызывать sort без параметров, то элементы сортируются в порядке возрастания. Однако методу можно передать параметр-функцию, которая будет возвращать критерий сортировки, то есть ключ.
Функция будет вызвана по одному разу для каждого элемента списка, после чего элементы будут отсортированы по возрастанию значения ключа. Давайте объявим функцию, которая будет возвращать остаток от деления аргумента на два, и используем ее в роли ключа:
def mod2(x): return x % 2 l = [1, 2, 3, 6, 5, 4] l.sort(key=mod2) print(l) # => [2, 6, 4, 1, 3, 5] Обратите внимание, что функцию в метод sort мы передали по имени параметра. Такой синтаксис мы рассмотрим позже, но поэкспериментировать с методом sort и разными функциями-ключами вы уже сможете, указывая их по аналогии.
Функция mod2 вернула для четных и нечетных чисел 0 и 1 соответственно. Поэтому в начале списка оказались сначала четные числа.
Интересно, что в пределах своей группы числа сохранили порядок: 6 шла в списке перед 4 , и это взаимное расположение сохранилось.
Умение сохранить относительный порядок элементов, которые уже отсортированы относительно друг друга — важная характеристика алгоритма сортировки. Называется она стабильностью.
Сортировка в этом случае называется стабильной — и в Python сортировка именно такая.
Функция-ключ не обязана возвращать числа — она может возвращать любые значения, которые Python умеет сравнивать. Давайте в предыдущем примере усложним функцию-ключ:
def key(x): return (x % 2, x) l = [1, 2, 3, 6, 5, 4] l.sort(key=key) print(l) # => [2, 4, 6, 1, 3, 5] Теперь числа разбиты на группы и при этом еще и отсортированы внутри групп. Когда Python сравнивает кортежи, он сравнивает сначала первые элементы, а если те равны — вторые и так далее.
Значения сравниваются, пока не найдется первое неравенство. Либо пока не кончится один из кортежей — в этом случае более короткий будет меньше. Вот несколько примеров:
print((1, 2, 3) (1, 2, 4)) # => True print((1, 1) (1, 1, 1)) # => True print((1, 2) > (1, 1, 1)) # => True print((3, 4, 5) == (3, 4, 5)) # => True Открыть доступ
Курсы программирования для новичков и опытных разработчиков. Начните обучение бесплатно
- 130 курсов, 2000+ часов теории
- 1000 практических заданий в браузере
- 360 000 студентов
Наши выпускники работают в компаниях: