Калькулятор процентов

Начало работы с sum()

В настоящее время функция sum() является предпочтительным способом для суммирования элементов:

sum([1, 2, 3, 4, 5])
# 15
sum([])
# 0

Здорово, не правда ли? Код читается как обычный текст и четко передает действие, которое вы выполняете. Использование sum() значительно упрощает код. Более того, эта функция не вызывает TypeError, если вы передали пустой список.

У sum() есть два аргумента:

• iterable – обязательный аргумент, который может содержать любой итерируемый объект Python. Итерируемый объект обычно содержит числовые значения, но также может содержать списки или кортежи.
• start – необязательный аргумент, который может содержать начальное значение. В конце суммирования элементов это значение добавляется к окончательному результату. По умолчанию равен 0.

Как посчитать проценты, разделив число на 100

Так вы найдёте числовой эквивалент 1%. Дальше всё зависит от вашей цели. Чтобы посчитать проценты от суммы, умножьте их на размер 1%. Чтобы перевести число в проценты, разделите его на размер 1%.

Как посчитать проценты, разделив число на 10

Этот способ похож на предыдущий, но считать с его помощью гораздо быстрее. Но только если речь идёт о процентах, кратных пяти.

Сначала вы находите размер 10%, а потом делите или умножаете его, чтобы получить нужное количество процентов.

Как посчитать проценты, составив пропорцию

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

сумма, составляющая 100% : 100% = часть суммы : доля в процентном соотношении.

Или можно записать её так: a : b = c : d.

Обычно пропорция читается как «а относится к b так же, как с относится к d». Произведение крайних членов пропорции равно произведению её средних членов. Чтобы узнать неизвестное число из этого равенства, нужно решить простейшее уравнение.

Как посчитать проценты с помощью соотношений

В некоторых случаях можно воспользоваться простыми дробями. Например, 10% — это 1/10 числа. И чтобы узнать, сколько это будет в цифрах, достаточно разделить целое на 10.

• 20% — 1/5, то есть нужно делить число на 5;
• 25% — 1/4;
• 50% — 1/2;
• 12,5% — 1/8;
• 75% — это 3/4. Значит, придётся разделить число на 4 и умножить на 3.

Как посчитать проценты с помощью калькулятора

Если без калькулятора вам жизнь не мила, все вычисления можно делать с его помощью. А можно поступить ещё проще.

• Чтобы посчитать проценты от суммы, введите число, равное 100%, знак умножения, затем нужный процент и знак %. Для примера с кофе вычисления будут выглядеть так: 458 × 7%.
• Чтобы узнать сумму за вычетом процентов, введите число, равное 100%, минус, размер процентной доли и знак %: 458 – 7%.
• Аналогично можно складывать, как в примере с депозитом: 530 000 5%.

Как посчитать проценты с помощью онлайн-сервисов

Не все проценты можно посчитать в уме и даже на калькуляторе. Если речь идёт о доходности вклада, переплатах по ипотеке или налогах, требуются сложные формулы. Они учтены в некоторых онлайн-сервисах.

Allcalc

Каталог онлайн-калькуляторов, 60 из которых предназначены для подсчёта финансов. Можно вычислить налоги и пени, размер субсидии на ЖКУ и многое другое.

Allcalc→

Planetcalc

На сайте собраны разные калькуляторы, которые высчитывают не только проценты. Здесь есть сервисы для кредиторов, инвесторов, предпринимателей и всех тех, кто не любит считать в уме.

Planetcalc→

Альтернативы sum()

Как вы уже поняли, функция sum() полезна для работы с числовыми значениями в целом. Однако, когда дело доходит до работы с числами с плавающей запятой, Python предоставляет альтернативный инструмент. В библиотеке math вы найдете функцию под названием fsum(), которая поможет вам улучшить общую точность вычислений.

Вам может понадобиться объединить или связать несколько итерируемых объектов, чтобы работать с ними как с одним. Для этого можно использовать модуль itertools().

Также у вас может возникнуть необходимость объединить строки. Для этого нельзя использовать sum(). Самая питоническая альтернатива – применить str.join().

Вычисление эффективной процентной ставки

Для вычисления эффективной ставки по вкладам используется формула:

где:

• С — номинальная ставка (в процентных пунктах);
• П — количество периодов капитализации в год;
• Д — длительность (срок) депозита в годах.

Период капитализации — это интервал времени, в конце которого начисляются проценты. У банковского вклада без капитализации проценты начисляются один раз за год в конце срока — значит, П = 1. При ежемесячной капитализации П = 12, при ежеквартальной П = 4, а если проценты начисляются каждый день, П = 365.

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

Годовые проценты

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

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

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

Использование 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(). Поскольку это встроенная функция, вы можете использовать ее в коде напрямую, ничего не импортируя.

Использование рекурсии

Вы также можете использовать рекурсию вместо итерации. Рекурсия – это метод функционального программирования, при котором функция вызывается в пределах ее собственного определения. Другими словами, рекурсивная функция вызывает сама себя в цикле:

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. Рекурсивный случай подразумевает, что общая сумма – это первый элемент плюс сумма остальных элементов. Поскольку рекурсивный случай использует более короткую последовательность на каждой итерации, вы ожидаете столкнуться с базовым случаем, когда числа представляют собой список нулевой длины.

Использование цикла 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() вы берете итерируемый объект в качестве аргумента и возвращаете общую сумму значений элементов списка.

Какие бывают проценты по вкладам в банке

Проценты бывают двух видов: простые и сложные.

Простые — те, что начисляются в конце срока вклада. Например, вы положили 100 000 Р на год под 5% годовых. Через год на вашем счете будет 105 000 Р.

Сложные. Несмотря на название, принцип их прост — они начисляются в течение срока вклада через равные интервалы. Например, ежемесячно или ежеквартально. Проценты начисляются на первоначальную сумму и на проценты от предыдущих периодов — вы получаете проценты на проценты. Это называется капитализацией.

В случае с ежемесячным начислением и вкладом на год вы как будто открываете вклад 12 раз подряд на 1 месяц, причем сумма вклада каждый раз увеличивается на сумму выплаченных за предыдущий месяц процентов.

Какие вклады облагаются налогом

Например, у вас два вклада по 600 000 Р со ставкой 4,8% годовых. По каждому вы получите доход в размере 28 800 Р. В сумме это будет 57 600 Р. Значит, налог вы заплатите с 57 600 − 42 500 = 15 100 Р. Величина налога составит 15 100 × 13% = 1963 Р.

В 2022 году безналоговый лимит может измениться, так как он зависит от ключевой ставки Центробанка России на 1 января.

Калькулятор — справочный портал

Ещё один сервис с калькуляторами на любой вкус.

Калькулятор — справочный портал→

Калькулятор онлайн со скобками

Калькулятор процентов

Кредитный калькулятор

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

Калькуляторы бывают двух типов. Данный калькулятор позволяет делать расчет обоих типов:

• Аннуитетный платеж — одинаковые ежемесячные платежи, включающие сумму процентов плюс сумма основного долга. Данный способ расчета ниболее популярен;
• Дифференцированный платеж — платежи, которые уменьшаются к окончанию срока. Включают в себя постоянную часть основного долга плюс проценты на оставшуюся часть кредита.

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

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

Нахождение скалярного произведения двух последовательностей

Другая проблема, которую мы можем решить с помощью sum(), – это нахождение скалярного произведения двух числовых последовательностей равной длины. Скалярное произведение – это алгебраическая сумма произведений каждой пары значений во входных последовательностях.

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

Объединение объектов с помощью 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() для создания желаемого плоского списка.

Объединение последовательностей

Несмотря на то, что функция 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() .

Объединение списков

Объединение списков – обычная задача в 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(). Как и в предыдущем случае, это решение создает только один список в процессе. Преимущество его в том, что оно хорошо читается.

Объединение строк с помощью str.join()

Как мы уже видели, функция sum() не объединяет строки. Если вам нужно это сделать, то предпочтительным и самым быстрым инструментом, доступным в Python, является str.join(). Этот метод принимает последовательность строк в качестве аргумента и возвращает новую объединенную строку:

greeting = ["Hello,", "welcome to", "Pythonist!"]
" ".join(greeting)
# 'Hello, welcome to Pythonist!'

Обратите внимание, что .join() использует строку, для которой вы вызываете метод, в качестве разделителя во время конкатенации. В этом примере вы вызываете .join() для строки, состоящей из одного символа пробела » «, поэтому исходные строки разделяются пробелами.

Понимание проблемы суммирования

Суммирование числовых значений – довольно распространенная задача в программировании. Например, предположим, что у вас есть список чисел a = [1, 2, 3, 4, 5] и вы хотите сложить элементы и получить сумму. Используя стандартную арифметику, вы сделаете что-то вроде этого:

1 2 3 4 5 = 15

Что касается математики, это выражение довольно простое.

Можно выполнить этот конкретный расчет вручную, но представьте себе другие ситуации, в которых это может быть невозможно. Если у вас очень длинный список чисел, добавление вручную будет неэффективным и, скорее всего, вы допустите ошибку. А если вы даже не знаете, сколько элементов в списке?

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

Пример

Допустим, вы кладёте на депозит 530 тысяч рублей на 12 месяцев. Процентная ставка составляет 5%, капитализации не предусмотрено. Вы хотите узнать, сколько денег заберёте через год.

В первую очередь надо вычислить 10% от суммы. Разделите её на 10, передвинув запятую влево на один знак. Вы получите 53 тысячи.

Чтобы узнать, сколько составляют 5%, разделите результат на 2. Это 26,5 тысячи.

Если бы в примере речь шла о 30%, нужно было бы умножить 53 на 3. Для расчёта 25% пришлось бы умножить 53 на 2 и прибавить 26,5.

В любом случае такими крупными числами оперировать довольно просто.

Пример 1

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

Сначала вычисляем процентную долю оставшегося шоколада.

90 г : 100% = 70 г : Х, где Х — масса оставшегося шоколада.

Х = 70 × 100 / 90 = 77,7%.

Теперь составляем пропорцию, чтобы выяснить, сколько масла нам нужно:

200 г : 100% = Х : 77,7%, где Х — нужное количество масла.

Х = 77,7 × 200 / 100 = 155,4.

Следовательно, в тесто нужно положить примерно 155 г масла.

Пример 2

Вы видите, что игра в Steam стоит 1 000 рублей, хотя раньше продавалась за 1 500 рублей. Вам интересно, сколько процентов составила скидка.

Разделите 1 500 на 100. Сместив запятую на две позиции влево, вы получите 15. Это 1% от старой цены.

Теперь новую цену разделите на размер 1%. 1 000 / 15 = 66,6666%.

100% – 66,6666% = 33,3333%.Такую скидку предоставил магазин.

Примеры использования sum() в python

До сих пор мы говорили про основы работы с sum(). В этом разделе вы увидите еще несколько примеров того, когда и как использовать sum() в вашем коде. Из этих практических примеров вы узнаете, что эта встроенная функция очень удобна, когда вы выполняете вычисления, требующие на промежуточном этапе нахождения суммы ряда чисел.

Кроме того, мы разберем, как применять sum() при работе со списками и кортежами. Мы также рассмотрим особый пример, когда нужно объединить несколько списков.

Расчет простых процентов

При начислении процентов раз в год в конце срока вклада эффективная ставка равна номинальной. Если сумма вклада 100 000 Р, а процент по нему — 5% годовых, то доход будет 5% от 100 000 Р: это 5000 Р.

Расчет сложных процентов

Вот некоторые банковские опции по депозитам.

Вклады с капитализацией. Как мы уже рассмотрели, вклады с начислением процентов поэтапно внутри срока называются вкладами с капитализацией. Периодичность капитализации может быть разная, обычно — раз в месяц, но бывает ежедневная или раз в квартал.

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

Рассмотрим варианты начисления процентов — от ежедневного до одного раза в квартал. Во всех случаях будем считать, что вы открыли депозит на 100 000 Р под 4,8% годовых на 1 год.

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

Упрощенный расчет будет выглядеть так.

С каждым днем сумма, на которую начисляются проценты, будет расти. Соответственно, и процентов каждый месяц будет начисляться больше.

Через год у вас на счете будет 104 916,73 Р. Эффективная ставка составит 4,92% годовых.

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

Упрощенный расчет будет выглядеть так.

Через год у вас на счете будет 104 907,02 Р. Эффективная ставка составит 4,91%.

Ежеквартальная капитализация. Проценты начисляются раз в три месяца. Упрощенный расчет будет выглядеть так.

Через год у вас на счете будет 104 887,09 Р. Эффективная ставка составит 4,89%.

Вклады с пополнением. Если по условиям договора вклад можно пополнять — вносить дополнительные средства, — с момента внесения процент начисляется на общую сумму.

Пример: вы открыли счет на 100 000 Р под 4,8% годовых на 1 год с возможностью пополнения, а через полгода внесли еще 50 000 Р. При годовой ставке 4,8% за полгода банк начислит 2,4% от суммы депозита. Рассчитаем процентные начисления за каждые полгода отдельно.

Без учета капитализации сумма процентных начислений составит 6 000 Р. Вкладчик в этом случае получает фиксированный процент от вложенных денег, поэтому эффективная ставка здесь не меняется — 4,8% годовых.

Если вклад с капитализацией, для вычисления эффективной процентной ставки можно отдельно рассчитать периоды до и после пополнения — как будто это два разных депозита. Эффективная ставка у вкладов будет другой из-за изменения длительности.

где:

• СО — это средний остаток по счету в течение всего срока, как если бы вы клали деньги на беспроцентный депозит;
• Д — общая длительность вклада в годах.

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

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

Пример: вы открыли депозит на 100 000 Р под 4,8% годовых на 1 год с возможностью частичного снятия, а через полгода сняли 50 000 Р. При годовой ставке 4,8% за полгода банк начислит 2,4% от суммы вклада. Рассчитаем проценты за каждые полгода отдельно.

Без капитализации сумма процентов составит 3600 Р. Эффективная процентная ставка без ежемесячной капитализации — те же 4,8%.

Расчет эффективной ставки с капитализацией можно произвести аналогично вкладу с пополнением.

Расчет среднего значения выборки

Один из практических вариантов применения 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(), чтобы получить общее количество. Наконец, выполняем деление, чтобы вычислить среднее арифметическое значение выборки.

Суммирование чисел с плавающей запятой: 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().

Суммирование числовых значений

Основная цель 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() в Python. Теперь вы можете использовать её для сложения числовых значений. Эта функция обеспечивает эффективный, читаемый и питонический способ решения задач сложения в коде. Также мы поговорили про альтернативы функции sum() и в каких случаях их лучше использовать.

Успехов в написании кода!

Перевод статьи «Python’s sum(): The Pythonic Way to Sum Values».