Задачи по функции sum() и решения к ним у нас в телеграм канале PythonTurbo
Давайте разберем, что такое функция sum() в Python и почему это питонический способ суммирования.
Встроенная функция sum() – это эффективный и питонический способ суммирования списка числовых значений. Сложение нескольких чисел является обычным промежуточным шагом во многих вычислениях, поэтому sum() – довольно удобный инструмент для программиста Python.
Еще с помощью sum() можно объединять списки и кортежи. Это интересный дополнительный вариант использования,
Друзья, подписывайтесь на наш телеграм канал Pythonist. Там еще больше туториалов, задач и книг по Python
полезный, когда вам нужно сгладить список списков.
Приведенная ниже информация поможет вам эффективно решать проблемы суммирования в вашем коде с помощью 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() является предпочтительным способом для суммирования элементов:
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».
