Списки Python – одна из наиболее часто используемых структур данных. Часто приходится выполнять различные операции со списками. В этой статье обсудим способы нахождения суммы элементов в списке в Python.
@python_job_interview – в нашем канале разобраны все возможные практические задачи Python
Находим сумму элементов в списке с помощью цикла For
Первый способ найти сумму элементов в списке – это выполнить итерацию по списку и добавить каждый элемент с помощью цикла for. Сначала рассчитаем длину списка с помощью метода len(). После этого объявим переменную sumOfElements равной 0. Затем используем функцию range(), чтобы создать последовательность чисел от 0 до (длина list-1). Используя числа в этой последовательности, мы получим доступ к элементам данного списка и добавим их в sumOfElements:
myList = [1, 2, 3, 4, 5, 6, 7, 8, 9]
print("The given list is:")
print(myList)
list_length=len(myList)
sumOfElements=0
for i in range(list_length):
sumOfElements=sumOfElements+myList[i]
print("Sum of all the elements in the list is:", sumOfElements)Вывод:
The given list is:
[1, 2, 3, 4, 5, 6, 7, 8, 9]
Sum of all the elements in the list is: 45Также можно напрямую перебирать список, используя цикл for. Так мы получим прямой доступ к каждому элементу в списке и добавим их в сумму элементов:
myList = [1, 2, 3, 4, 5, 6, 7, 8, 9]
print("The given list is:")
print(myList)
sumOfElements = 0
for element in myList:
sumOfElements = sumOfElements + element
print("Sum of all the elements in the list is:", sumOfElements)Вывод:
The given list is:
[1, 2, 3, 4, 5, 6, 7, 8, 9]
Sum of all the elements in the list is: 45Находим сумму элементов в списке с помощью цикла While
Также можно использовать цикл while, чтобы найти сумму элементов в списке. Для этого сначала рассчитаем длину списка с помощью метода len(). После этого инициализируем переменные с именами count и sumOfElements. Мы инициализируем оба элемента равными 0.
С помощью цикла while мы получим доступ к каждому элементу списка с помощью переменной count и добавим их в sumOfElements. После этого мы увеличим значение count на 1 и продолжим до тех пор, пока количество не станет равным длине списка.
Ваша программа может выглядеть так:
myList = [1, 2, 3, 4, 5, 6, 7, 8, 9]
print("The given list is:")
print(myList)
list_length = len(myList)
sumOfElements = 0
count = 0
while count < list_length:
sumOfElements = sumOfElements + myList[count]
count = count + 1
print("Sum of all the elements in the list is:", sumOfElements)Вывод:
The given list is:
[1, 2, 3, 4, 5, 6, 7, 8, 9]
Sum of all the elements in the list is: 45Сумма элементов в списке с помощью функции sum()
Также Python предоставляет нам встроенную функцию sum() для вычисления суммы элементов в любом объекте коллекции. Функция sum() принимает повторяющийся объект, такой как список, кортеж или набор, и возвращает сумму элементов в объекте.
Так можно найти сумму элементов списка с помощью функции sum():
myList = [1, 2, 3, 4, 5, 6, 7, 8, 9]
print("The given list is:")
print(myList)
sumOfElements = sum(myList)
print("Sum of all the elements in the list is:", sumOfElements)Вывод:
The given list is:
[1, 2, 3, 4, 5, 6, 7, 8, 9]
Sum of all the elements in the list is: 45Заключение
В этой статье мы обсудили различные способы, как найти суммы элементов в списке Python.
Просмотры: 37 127
На чтение 4 мин Просмотров 4.5к. Опубликовано
Python — это язык программирования, который предоставляет нам различные встроенные функции и методы для работы со списками. Одной из таких операций является нахождение суммы чисел в списке. Это может быть полезным, когда необходимо произвести анализ числовых данных, например, при подсчете среднего значения или нахождении суммы элементов, удовлетворяющих определенным условиям. В этой статье мы рассмотрим различные методы нахождения суммы чисел в списке Python.
Содержание
- Методы для нахождения суммы чисел в списке
- Использование цикла for
- Использование встроенной функции sum()
- Использование рекурсии
- Обработка исключений при нахождении суммы чисел в списке
Методы для нахождения суммы чисел в списке
Использование цикла for
Цикл for является одним из наиболее простых и часто используемых способов для нахождения суммы чисел в списке. Просто пройдитесь по каждому элементу списка и добавьте его к накопленной сумме.
Вот пример кода, который демонстрирует использование цикла for для нахождения суммы чисел в списке:
numbers = [1, 2, 3, 4, 5]
total = 0
for num in numbers:
total += num
print("Сумма чисел в списке: ", total)В этом примере мы создали список чисел от 1 до 5 и присвоили его переменной numbers. Затем мы создали переменную total и присвоили ей начальное значение 0. Затем мы проходим по каждому элементу списка numbers и добавляем его к переменной total. Наконец, мы выводим сумму чисел на экран.
Важно отметить, что мы должны инициализировать переменную total нулевым значением перед выполнением цикла, чтобы иметь место, куда добавлять числа. Если мы попытаемся добавить число к неинициализированной переменной, возникнет ошибка.
Цикл for также может использоваться для нахождения суммы чисел в многомерном списке. В этом случае нам нужно будет использовать вложенный цикл for, чтобы перебрать каждый элемент списка.
matrix = [[1, 2, 3], [4, 5, 6], [7, 8, 9]]
total = 0
for row in matrix:
for num in row:
total += num
print("Сумма чисел в многомерном списке: ", total)В этом примере мы создали многомерный список, содержащий три списка с числами. Затем мы создали переменную total и присвоили ей начальное значение 0. Затем мы используем два вложенных цикла for для перебора каждого элемента списка и добавления его к переменной total. Наконец, мы выводим сумму чисел на экран.
Использование встроенной функции sum()
Использование встроенной функции sum() для нахождения суммы чисел в списке является очень простым и эффективным способом. Функция sum() принимает один аргумент — итерируемый объект, такой как список, и возвращает сумму всех элементов в нем.
Простой пример использования функции sum() для нахождения суммы всех чисел в списке:
my_list = [1, 2, 3, 4, 5]
sum_of_list = sum(my_list)
print(sum_of_list)Важно отметить, что функция sum() может работать только с итерируемыми объектами, элементы которых могут быть сложены. Если элементы списка не могут быть сложены, будет возбуждено исключение типа TypeError.
Использование рекурсии
Использование рекурсии — это еще один способ нахождения суммы чисел в списке Python. Рекурсия — это процесс вызова функцией самой себя. Для нахождения суммы чисел в списке при помощи рекурсии, необходимо реализовать функцию, которая будет вызывать саму себя до тех пор, пока не достигнет базового случая.
Пример реализации функции для нахождения суммы чисел в списке при помощи рекурсии:
numbers = [1, 2, 3, 4, 5]
result = recursive_sum(numbers)
print(result)Здесь мы определяем функцию recursive_sum, которая принимает список чисел numbers. Если в списке остается только один элемент, то возвращаем его значение. В противном случае мы возвращаем сумму первого элемента списка и рекурсивного вызова функции для оставшейся части списка.
Хотя использование рекурсии для нахождения суммы чисел в списке может быть удобным и понятным, стоит иметь в виду, что это может привести к переполнению стека вызовов функций при больших списках. Поэтому, в большинстве случаев лучше использовать более эффективные методы, такие как использование встроенной функции sum() или цикла for.
Обработка исключений при нахождении суммы чисел в списке
При работе с данными, особенно с пользовательским вводом, всегда есть вероятность получения ошибочных данных. Для обработки ошибок при нахождении суммы чисел в списке можно использовать конструкцию try-except.
При использовании описанных выше методов для нахождения суммы чисел в списке возможны следующие ошибки:
- TypeError — возникает, если элемент списка не является числом.
- ValueError — возникает, если в списке есть пустые строки или нечисловые значения.
Для обработки этих ошибок можно использовать конструкцию try-except. Например, чтобы обработать ошибку TypeError, мы можем использовать следующий код:
numbers = [1, 2, 3, '4', 5]
total = 0
for num in numbers:
try:
total += num
except TypeError:
print(f"Элемент {num} не является числом")
print(f"Сумма чисел в списке: {total}")В результате выполнения данного кода мы получим следующий вывод:
Элемент 4 не является числом
Сумма чисел в списке: 11Обработка ошибок позволяет избежать прерывания работы программы при возникновении ошибок и предоставляет возможность корректно обработать их в процессе выполнения программы.
Задачи по функции sum() и решения к ним у нас в телеграм канале PythonTurbo
Давайте разберем, что такое функция sum() в Python и почему это питонический способ суммирования.
Встроенная функция sum() – это эффективный и питонический способ суммирования списка числовых значений. Сложение нескольких чисел является обычным промежуточным шагом во многих вычислениях, поэтому sum() – довольно удобный инструмент для программиста Python.
Еще с помощью sum() можно объединять списки и кортежи. Это интересный дополнительный вариант использования, полезный, когда вам нужно сгладить список списков.
Приведенная ниже информация поможет вам эффективно решать проблемы суммирования в вашем коде с помощью sum() или других альтернативных и специализированных инструментов.
Понимание проблемы суммирования
Суммирование числовых значений – довольно распространенная задача в программировании. Например, предположим, что у вас есть список чисел a = [1, 2, 3, 4, 5] и вы хотите сложить элементы и получить сумму. Используя стандартную арифметику, вы сделаете что-то вроде этого:
1 + 2 + 3 + 4 + 5 = 15
Что касается математики, это выражение довольно простое.
Можно выполнить этот конкретный расчет вручную, но представьте себе другие ситуации, в которых это может быть невозможно. Если у вас очень длинный список чисел, добавление вручную будет неэффективным и, скорее всего, вы допустите ошибку. А если вы даже не знаете, сколько элементов в списке? Наконец, представьте сценарий, в котором количество элементов, которые вам нужно добавить, изменяется динамически или вообще непредсказуемо.
В подобных ситуациях, независимо от того, есть ли у вас длинный или короткий список чисел, Python может быть весьма полезен для решения задач суммирования.
Использование цикла for
Если вы хотите суммировать числа, создав собственное решение с нуля, вы можете использовать цикл for:
numbers = [1, 2, 3, 4, 5]
total = 0
for number in numbers:
total += number
print(total)
# 15
Здесь вы сначала инициализируете сумму и приравниваете её к 0. Эта переменная работает как аккумулятор, в котором вы сохраняете промежуточные результаты, пока не получите окончательный. Цикл перебирает числа и обновляет общее количество.
Цикл for можно заключить в функцию. Благодаря этому вы сможете повторно использовать код для разных списков:
def sum_numbers(numbers):
total = 0
for number in numbers:
total += number
return total
sum_numbers([1, 2, 3, 4, 5])
# 15
sum_numbers([])
# 0
В sum_numbers() вы берете итерируемый объект в качестве аргумента и возвращаете общую сумму значений элементов списка.
Прямо сейчас можете попробовать решить задачку «Напишите программу на Python для суммирования всех элементов в списке»
def sum_list(items):
ваш код
print(sum_list([1, 2, -8])) #В выводе должно быть -5
Условие и решение есть в наших поста тут и тут
Использование рекурсии
Вы также можете использовать рекурсию вместо итерации. Рекурсия – это метод функционального программирования, при котором функция вызывается в пределах ее собственного определения. Другими словами, рекурсивная функция вызывает сама себя в цикле:
def sum_numbers(numbers):
if len(numbers) == 0:
return 0
return numbers[0] + sum_numbers(numbers[1:])
sum_numbers([1, 2, 3, 4, 5])
# 15
Когда вы определяете рекурсивную функцию, вы рискуете попасть в бесконечный цикл. Чтобы предотвратить это, нужно определить как базовый случай, останавливающий рекурсию, так и рекурсивный случай для вызова функции и запуска неявного цикла.
В приведенном выше примере базовый случай подразумевает, что сумма списка нулевой длины равна 0. Рекурсивный случай подразумевает, что общая сумма – это первый элемент плюс сумма остальных элементов. Поскольку рекурсивный случай использует более короткую последовательность на каждой итерации, вы ожидаете столкнуться с базовым случаем, когда числа представляют собой список нулевой длины.
[python_ad_block]
Использование reduce()
Другой вариант суммирования списка чисел в Python – использовать reduce() из functools. Чтобы получить сумму списка чисел, вы можете передать либо оператор add, либо соответствующую лямбда-функцию в качестве первого аргумента функции reduce():
from functools import reduce from operator import add reduce(add, [1, 2, 3, 4, 5]) # 15 reduce(add, []) # Traceback (most recent call last): # ... # TypeError: reduce() of empty sequence with no initial value reduce(lambda x, y: x + y, [1, 2, 3, 4, 5]) # 15
Вы можете вызвать reduce() с folding-функцией и итерируемым объектом в качестве аргументов. reduce() использует переданную функцию для обработки итерируемого объекта и вернет единственное кумулятивное значение.
В первом примере folding-функция – это add(), которая берет два числа и складывает их. Конечный результат – это сумма чисел во входном итерируемом объекте. Но если вы вызовете reduce() с пустым итерируемым объектом, получите TypeError.
Во втором примере folding-функция – это лямбда-функция, которая возвращает сложение двух чисел.
Поскольку суммирование является обычным явлением в программировании, писать новую функцию каждый раз, когда нам нужно сложить какие-нибудь числа, — бессмысленная работа. Кроме того, использование reduce() – далеко не самое удобочитаемое решение.
Python предоставляет специальную встроенную функцию для решения этой проблемы. Это функция sum(). Поскольку это встроенная функция, вы можете использовать ее в коде напрямую, ничего не импортируя.
В настоящее время функция sum() является предпочтительным способом для суммирования элементов:
sum([1, 2, 3, 4, 5]) # 15 sum([]) # 0
Здорово, не правда ли? Код читается как обычный текст и четко передает действие, которое вы выполняете. Использование sum() значительно упрощает код. Более того, эта функция не вызывает TypeError, если вы передали пустой список.
У sum() есть два аргумента:
iterable– обязательный аргумент, который может содержать любой итерируемый объект Python. Итерируемый объект обычно содержит числовые значения, но также может содержать списки или кортежи.start– необязательный аргумент, который может содержать начальное значение. В конце суммирования элементов это значение добавляется к окончательному результату. По умолчанию равен 0.
Суммирование числовых значений
Основная цель sum() – предоставить питонический способ сложения числовых значений. До этого момента вы видели, как использовать функцию для суммирования целых чисел. Кроме того, вы можете использовать sum() с любыми другими числовыми типами Python, такими как float, complex, decimal.Decimal и fractions.Fraction.
Вот несколько примеров использования sum() со значениями разных числовых типов:
from decimal import Decimal
from fractions import Fraction
# Sum floating-point numbers
sum([10.2, 12.5, 11.8])
# 34.5
sum([10.2, 12.5, 11.8, float("inf")])
# inf
sum([10.2, 12.5, 11.8, float("nan")])
# nan
# Sum complex numbers
sum([3 + 2j, 5 + 6j])
# (8+8j)
# Sum Decimal numbers
sum([Decimal("10.2"), Decimal("12.5"), Decimal("11.8")])
# Decimal('34.5')
# Sum Fraction numbers
sum([Fraction(51, 5), Fraction(25, 2), Fraction(59, 5)])
# Fraction(69, 2)
Объединение последовательностей
Несмотря на то, что функция sum() в основном предназначена для работы с числовыми значениями, вы также можете использовать ее для объединения последовательностей, таких как списки и кортежи. Для этого вам нужно указать соответствующее значение для аргумента start:
num_lists = [[1, 2, 3], [4, 5, 6]] sum(num_lists, start=[]) # [1, 2, 3, 4, 5, 6] # Equivalent concatenation [1, 2, 3] + [4, 5, 6] # [1, 2, 3, 4, 5, 6] num_tuples = ((1, 2, 3), (4, 5, 6)) sum(num_tuples, start=()) # (1, 2, 3, 4, 5, 6) # Equivalent concatenation (1, 2, 3) + (4, 5, 6) # (1, 2, 3, 4, 5, 6)
Ключевым требованием для работы этих примеров является выбор подходящего значения для start. Например, если вы хотите объединить списки, то start должен быть равен [].
num_strs = ["123", "456"] sum(num_strs, "0") # Traceback (most recent call last): # File "<stdin>", line 1, in <module> # TypeError: sum() can't sum strings [use ''.join(seq) instead]
Если же вы попытаетесь использовать sum() для объединения строк, вы получите ошибку TypeError. Она говорит нам о том, что для объединения строк в Python следует использовать str.join() .
Примеры использования sum() в Python
До сих пор мы говорили про основы работы с sum(). В этом разделе вы увидите еще несколько примеров того, когда и как использовать sum() в вашем коде. Из этих практических примеров вы узнаете, что эта встроенная функция очень удобна, когда вы выполняете вычисления, требующие на промежуточном этапе нахождения суммы ряда чисел.
Кроме того, мы разберем, как применять sum() при работе со списками и кортежами. Мы также рассмотрим особый пример, когда нужно объединить несколько списков.
Расчет среднего значения выборки
Один из практических вариантов применения sum() – использовать ее в качестве промежуточного вычисления перед дальнейшими вычислениями. Например, вам нужно вычислить среднее арифметическое для выборки числовых значений. Среднее арифметическое, также известное как среднее значение, представляет собой общую сумму значений, деленную на количество значений в выборке.
Если у вас есть выборка [2, 3, 4, 2, 3, 6, 4, 2] и вы хотите вычислить среднее арифметическое вручную, вы можете решить эту операцию так:
(2 + 3 + 4 + 2 + 3 + 6 + 4 + 2) / 8 = 3,25
Если вы хотите ускорить это с помощью Python, вы можете разбить решение на две части. Первая часть – вы складываете все числа – это задача для sum(). В следующей части, где вы делите на 8, используется количество чисел в вашей выборке. Чтобы определить свой делитель, вы можете использовать len():
data_points = [2, 3, 4, 2, 3, 6, 4, 2] sum(data_points) / len(data_points) # 3.25
Здесь sum() вычисляет общую сумму в нашей выборке. Затем мы используем len(), чтобы получить общее количество. Наконец, выполняем деление, чтобы вычислить среднее арифметическое значение выборки.
Нахождение скалярного произведения двух последовательностей
Другая проблема, которую мы можем решить с помощью sum(), – это нахождение скалярного произведения двух числовых последовательностей равной длины. Скалярное произведение – это алгебраическая сумма произведений каждой пары значений во входных последовательностях. Например, если у вас есть последовательности (1, 2, 3) и (4, 5, 6), вы можете вычислить их скалярное произведение вручную, используя сложение и умножение:
1 × 4 + 2 × 5 + 3 × 6 = 32
Чтобы извлечь последовательные пары значений, мы можем использовать zip(). Затем воспользуемся генератором для умножения каждой пары значений. Наконец, sum() поможет суммировать произведения:
x_vector = (1, 2, 3) y_vector = (4, 5, 6) sum(x * y for x, y in zip(x_vector, y_vector)) # 32
Объединение списков
Объединение списков – обычная задача в Python. Предположим, у вас есть список списков, и вам нужно объединить его в единый список, содержащий все элементы из исходных вложенных списков. Вы можете использовать любой из нескольких подходов к объединению списков в Python. Например, можно воспользоваться циклом for, как в следующем коде:
def flatten_list(a_list):
flat = []
for sublist in a_list:
flat += sublist
return flat
matrix = [
[1, 2, 3],
[4, 5, 6],
[7, 8, 9],
]
flatten_list(matrix)
# [1, 2, 3, 4, 5, 6, 7, 8, 9]
Внутри flatten_list() цикл перебирает все вложенные списки, содержащиеся в a_list. Затем он объединяет их в один. В результате вы получаете единый список со всеми элементами из исходных вложенных списков.
Но можно ли использовать функцию sum() для объединения списков, как в примере выше? Да! Вот как:
matrix = [
[1, 2, 3],
[4, 5, 6],
[7, 8, 9],
]
sum(matrix, [])
# [1, 2, 3, 4, 5, 6, 7, 8, 9]
Это было быстро! Одна строка кода — и мы получили единый список. Однако использование sum() не кажется самым быстрым решением.
Важным недостатком любого решения, предполагающего конкатенацию, является то, что за кулисами каждый промежуточный шаг создает новый список. Это может быть довольно расточительным с точки зрения использования памяти.
Список, который в итоге возвращается, является самым последним созданным списком из всех, которые создавались на каждом этапе конкатенации. Использование генератора списка вместо этого гарантирует, что вы создадите и вернете только один список:
def flatten_list(a_list):
return [item for sublist in a_list for item in sublist]
matrix = [
[1, 2, 3],
[4, 5, 6],
[7, 8, 9],
]
flatten_list(matrix)
# [1, 2, 3, 4, 5, 6, 7, 8, 9]
Эта новая версия flatten_list() более эффективна и менее расточительна с точки зрения использования памяти. Однако вложенные генераторы могут быть сложными для чтения и понимания.
Использование .append(), вероятно, является наиболее читаемым и питоничным способом объединить списки:
def flatten_list(a_list):
flat = []
for sublist in a_list:
for item in sublist:
flat.append(item)
return flat
matrix = [
[1, 2, 3],
[4, 5, 6],
[7, 8, 9],
]
flatten_list(matrix)
# [1, 2, 3, 4, 5, 6, 7, 8, 9]
В этой версии функция выполняет итерацию по каждому подсписку в a_list. Внутри внутреннего цикла for она перебирает каждый элемент подсписка, чтобы заполнить новый список с помощью .append(). Как и в предыдущем случае, это решение создает только один список в процессе. Преимущество его в том, что оно хорошо читается.
Альтернативы sum()
Как вы уже поняли, функция sum() полезна для работы с числовыми значениями в целом. Однако, когда дело доходит до работы с числами с плавающей запятой, Python предоставляет альтернативный инструмент. В библиотеке math вы найдете функцию под названием fsum(), которая поможет вам улучшить общую точность вычислений.
Вам может понадобиться объединить или связать несколько итерируемых объектов, чтобы работать с ними как с одним. Для этого можно использовать модуль itertools().
Также у вас может возникнуть необходимость объединить строки. Для этого нельзя использовать sum(). Самая питоническая альтернатива – применить str.join().
Суммирование чисел с плавающей запятой: math.fsum()
Эта функция выполняет вычисления с плавающей запятой более тщательно, чем sum(), что повышает точность.
Согласно документации, fsum() «позволяет избежать потери точности, отслеживая несколько промежуточных частичных сумм». В документации приводится следующий пример:
from math import fsum sum([.1, .1, .1, .1, .1, .1, .1, .1, .1, .1]) # 0.9999999999999999 fsum([.1, .1, .1, .1, .1, .1, .1, .1, .1, .1]) # 1.0
Используя fsum(), вы получите более точный результат. Однако следует отметить, что fsum() не устраняет ошибку представления в арифметике с плавающей запятой. Следующий пример раскрывает это ограничение:
from math import fsum sum([0.1, 0.2]) # 0.30000000000000004 fsum([0.1, 0.2]) # 0.30000000000000004
В этих примерах обе функции возвращают одинаковый результат. Это связано с невозможностью точного представления значений 0,1 и 0,2 в двоичной системе с плавающей запятой:
f"{0.1:.28f}"
# '0.1000000000000000055511151231'
f"{0.2:.28f}"
# '0.2000000000000000111022302463'
Однако, в отличие от sum(), fsum() поможет вам уменьшить неточность, когда вы складываете очень большие и очень маленькие числа вместе:
from math import fsum sum([1e-16, 1, 1e16]) # 1e+16 fsum([1e-16, 1, 1e16]) # 1.0000000000000002e+16 sum([1, 1, 1e100, -1e100] * 10_000) # 0.0 fsum([1, 1, 1e100, -1e100] * 10_000) # 20000.0
Ух ты! Второй пример довольно неожиданный и полностью дискредитирует sum(). С помощью sum() в результате вы получите 0,0. Это довольно далеко от правильного результата 20000.0, который вы получите с помощью fsum().
Объединение объектов с помощью itertools.chain()
Если вы ищете удобный инструмент для объединения или связывания итерируемых объектов, рассмотрите возможность использования chain() из itertools. Эта функция может принимать несколько объектов и строить итератор, который выдает элементы из первого, из второго и так далее, пока не исчерпает все входные итерации:
from itertools import chain numbers = chain([1, 2, 3], [4, 5, 6], [7, 8, 9]) numbers # <itertools.chain object at 0x7f0d0f160a30> next(numbers) # 1 next(numbers) # 2 list(chain([1, 2, 3], [4, 5, 6], [7, 8, 9])) # [1, 2, 3, 4, 5, 6, 7, 8, 9]
В данном примере вы получаете доступ к последовательным элементам из чисел с помощью next(). Если вместо этого вы хотите работать со списком, вы можете применить list() для использования итератора и возврата обычного списка Python.
chain() также является хорошим вариантом для объединения списков в Python:
from itertools import chain matrix = [[1, 2, 3], [4, 5, 6], [7, 8, 9]] list(chain(*matrix)) # [1, 2, 3, 4, 5, 6, 7, 8, 9]
Чтобы объединить списки с помощью chain(), вам нужно использовать итеративный оператор распаковки *. Этот оператор распаковывает все входные итерации, так что chain() может работать с ними и генерировать соответствующий итератор. Последний шаг – вызвать list() для создания желаемого плоского списка.
Объединение строк с помощью str.join()
Как мы уже видели, функция sum() не объединяет строки. Если вам нужно это сделать, то предпочтительным и самым быстрым инструментом, доступным в Python, является str.join(). Этот метод принимает последовательность строк в качестве аргумента и возвращает новую объединенную строку:
greeting = ["Hello,", "welcome to", "Pythonist!"] " ".join(greeting) # 'Hello, welcome to Pythonist!'
Обратите внимание, что .join() использует строку, для которой вы вызываете метод, в качестве разделителя во время конкатенации. В этом примере вы вызываете .join() для строки, состоящей из одного символа пробела " ", поэтому исходные строки разделяются пробелами.
Заключение
Итак, сегодня мы разобрали, что такое функция sum() в Python. Теперь вы можете использовать её для сложения числовых значений. Эта функция обеспечивает эффективный, читаемый и питонический способ решения задач сложения в коде. Также мы поговорили про альтернативы функции sum() и в каких случаях их лучше использовать.
Успехов в написании кода!
Перевод статьи «Python’s sum(): The Pythonic Way to Sum Values».
Lists are very commonly used to store sequences of values (for example, numbers) in Python. When working with lists, it can be handy to know how to quickly get the sum of values in a list. For example, you have a list of your recorded footsteps in the last seven days and you want to know the total sum. In this tutorial, we will look at how to get the sum of the elements in a list in Python with the help of some examples.
How to get the sum of a list of numbers in Python?
You can use the python built-in sum() function to get the sum of list elements. Alternatively, you can use a loop to iterate through the list items and use a variable to keep track of the sum.
Let’s look at the above-mentioned methods with the help of some examples.
Using sum() to get the total in a list
The built-in sum() function in Python is used to return the sum of an iterable. To get the sum total of a list of numbers, you can pass the list as an argument to the sum() function.
# create a list ls = [10, 15, 20, 25] # sum of list elements sum(ls)
Output:
70
We get the sum of the values in the list as a scaler value.
Note that the sum() function may result in loss of precision with extended sums of floating-point numbers. For example –
# create a list ls = [0.1, 0.1, 0.1, 0.1, 0.1, 0.1, 0.1, 0.1, 0.1] # sum of list elements sum(ls)
Output:
0.8999999999999999
As an alternative, you can use the math standard library’s fsum() function to get an accurate sum of floating-point numbers and prevent loss of precision.
import math # create a list ls = [0.1, 0.1, 0.1, 0.1, 0.1, 0.1, 0.1, 0.1, 0.1] # sum of list elements math.fsum(ls)
Output:
0.9
We get the accurate result this time. For more on the fsum() function, refer to its documentation.
Using loop to get the sum
Alternatively, you can use the straightforward method of iterating through the list elements and keeping track of the sum.
# create a list
ls = [10, 15, 20, 25]
# use a loop to get the sum
total = 0
for item in ls:
total += item
print(total)
Output:
70
We get the sum of the values in the list.
You might also be interested in –
- Python – Find Average of values in a List
- Python – Get median of a List
- Find Mode of List in Python
Subscribe to our newsletter for more informative guides and tutorials.
We do not spam and you can opt out any time.
-
Piyush is a data professional passionate about using data to understand things better and make informed decisions. He has experience working as a Data Scientist in the consulting domain and holds an engineering degree from IIT Roorkee. His hobbies include watching cricket, reading, and working on side projects.
View all posts
Одна из наиболее часто используемых операций для работы со списками — это подсчет суммы всех элементов списка. В этой статье мы рассмотрим различные способы подсчета суммы элементов списка в Python.
Использование встроенной функции sum()
Самый простой и прямой способ подсчета суммы всех элементов списка — использовать встроенную функцию sum().
list1 = [1, 2, 3, 4, 5] print(sum(list1)) #15
Использование функции sum() с аргументом start
Функция sum() также принимает второй аргумент, start, который добавляется к общей сумме.
list1 = [1, 2, 3, 4, 5] print(sum(list1, 10)) #25
Использование цикла for для подсчета суммы
Если вы не хотите или не можете использовать функцию sum(), вы можете подсчитать сумму элементов списка, используя цикл for.
list1 = [1, 2, 3, 4, 5]
total = 0
for i in list1:
total += i
print(total)
#15
Использование функции reduce()
Функция reduce() из модуля functools применяет заданную функцию к элементам списка последовательно таким образом, что результат одного вызова функции используется в следующем вызове. Это можно использовать для подсчета суммы элементов списка.
from functools import reduce import operator list1 = [1, 2, 3, 4, 5] total = reduce(operator.add, list1) print(total) #15
Использование генератора списков
Вы можете использовать генератор списков для вычисления суммы элементов списка, особенно если вы хотите применить какую-то функцию к каждому элементу перед суммированием.
list1 = [1, 2, 3, 4, 5] total = sum(i**2 for i in list1) print(total) #55
В этом примере мы вычисляем сумму квадратов всех элементов списка.
Сумма элементов во вложенных списках
Если у вас есть список списков и вы хотите подсчитать сумму всех элементов всех списков, вы можете использовать вложенный цикл for.
list1 = [[1, 2, 3], [4, 5],[6, 7, 8, 9]]
total = 0
for sublist in list1:
total += sum(sublist)
print(total)
#45
В этом примере внешний цикл for проходит через каждый подсписок, а внутренний вызов sum() суммирует элементы каждого подсписка.
Использование генераторов списков для суммирования элементов во вложенных списках
Вы также можете использовать генераторы списков для подсчета суммы элементов во вложенных списках, особенно если вы хотите применить какую-то функцию к каждому элементу перед суммированием.
list1 = [[1, 2, 3], [4, 5], [6, 7, 8, 9]] total = sum(i for sublist in list1 for i in sublist) print(total) #45
В этом примере генератор списка i for sublist in list1 for i in sublist генерирует все элементы всех подсписков, а функция sum() суммирует их.
Заключение
Существует множество способов подсчета суммы элементов списка в Python, от простого использования функции sum() до более сложных подходов, таких как использование функции reduce() или генераторов списков. В зависимости от ваших потребностей и предпочтений, вы можете выбрать тот подход, который наиболее подходит для вашей задачи.
