Как найти сумму чисел списка в python

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

Методы для нахождения суммы чисел в списке

Использование цикла 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.

При использовании описанных выше методов для нахождения суммы чисел в списке возможны следующие ошибки:

1. TypeError — возникает, если элемент списка не является числом.
2. 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

Обработка ошибок позволяет избежать прерывания работы программы при возникновении ошибок и предоставляет возможность корректно обработать их в процессе выполнения программы.

Watch Now This tutorial has a related video course created by the Real Python team. Watch it together with the written tutorial to deepen your understanding: Summing Values the Pythonic Way With sum()

Python’s built-in function sum() is an efficient and Pythonic way to sum a list of numeric values. Adding several numbers together is a common intermediate step in many computations, so sum() is a pretty handy tool for a Python programmer.

As an additional and interesting use case, you can concatenate lists and tuples using sum(), which can be convenient when you need to flatten a list of lists.

In this tutorial, you’ll learn how to:

• Sum numeric values by hand using general techniques and tools
• Use Python’s sum() to add several numeric values efficiently
• Concatenate lists and tuples with sum()
• Use sum() to approach common summation problems
• Use appropriate values for the arguments in sum()
• Decide between sum() and alternative tools to sum and concatenate objects

This knowledge will help you efficiently approach and solve summation problems in your code using either sum() or other alternative and specialized tools.

>>> numbers = [1, 2, 3, 4, 5]
>>> total = 0

>>> for number in numbers:
...     total += number
...

>>> total
15

>>> 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

>>> 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

>>> 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

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

>>> sum([])
0

>>> # Use a list
>>> sum([1, 2, 3, 4, 5])
15

>>> # Use a tuple
>>> sum((1, 2, 3, 4, 5))
15

>>> # Use a set
>>> sum({1, 2, 3, 4, 5})
15

>>> # Use a range
>>> sum(range(1, 6))
15

>>> # Use a dictionary
>>> sum({1: "one", 2: "two", 3: "three"})
6
>>> sum({1: "one", 2: "two", 3: "three"}.keys())
6

>>> sum([x ** 2 for x in range(1, 6)])
55

>>> sum(x ** 2 for x in range(1, 6))
55

>>> sum([1, 2, 3, 4, 5], 100)  # Positional argument
115

>>> sum([1, 2, 3, 4, 5], start=100)  # Keyword argument
115

>>> 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)

>>> 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)

>>> 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]

>>> cumulative_sales = 0

>>> monday = [50, 27, 42]
>>> cumulative_sales = sum(monday, start=cumulative_sales)
>>> cumulative_sales
119

>>> tuesday = [12, 32, 15]
>>> cumulative_sales = sum(tuesday, start=cumulative_sales)
>>> cumulative_sales
178

>>> wednesday = [20, 24, 42]
>>> cumulative_sales = sum(wednesday, start=cumulative_sales)
>>> cumulative_sales
264
    ...

>>> data_points = [2, 3, 4, 2, 3, 6, 4, 2]

>>> sum(data_points) / len(data_points)
3.25

>>> # Python >= 3.8

>>> def average(data_points):
...     if (num_points := len(data_points)) == 0:
...         raise ValueError("average requires at least one data point")
...     return sum(data_points) / num_points
...

>>> average([2, 3, 4, 2, 3, 6, 4, 2])
3.25

>>> average([])
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
  File "<stdin>", line 3, in average
ValueError: average requires at least one data point

>>> x_vector = (1, 2, 3)
>>> y_vector = (4, 5, 6)

>>> sum(x * y for x, y in zip(x_vector, y_vector))
32

>>> def dot_product(x_vector, y_vector):
...     if len(x_vector) != len(y_vector):
...         raise ValueError("Vectors must have equal sizes")
...     return sum(x * y for x, y in zip(x_vector, y_vector))
...

>>> dot_product((1, 2, 3), (4, 5, 6))
32

>>> dot_product((1, 2, 3, 4), (5, 6, 3))
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
  File "<stdin>", line 3, in dot_product
ValueError: Vectors must have equal sizes

>>> 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]

>>> matrix = [
...     [1, 2, 3],
...     [4, 5, 6],
...     [7, 8, 9],
... ]

>>> sum(matrix, [])
[1, 2, 3, 4, 5, 6, 7, 8, 9]

>>> 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]

>>> 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]

>>> 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

>>> from math import fsum

>>> sum([0.1, 0.2])
0.30000000000000004

>>> fsum([0.1, 0.2])
0.30000000000000004

>>> f"{0.1:.28f}"
'0.1000000000000000055511151231'

>>> f"{0.2:.28f}"
'0.2000000000000000111022302463'

>>> 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

>>> 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]

>>> 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]

>>> greeting = ["Hello,", "welcome to", "Real Python!"]

>>> " ".join(greeting)
'Hello, welcome to Real Python!'

Watch Now This tutorial has a related video course created by the Real Python team. Watch it together with the written tutorial to deepen your understanding: Summing Values the Pythonic Way With sum()

Списки 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.

Просмотры: 36 751

The list is an important container and is used almost in every code of day-day programming as well as web development, more it is used, the more is the requirement to master it and hence knowledge of its operations is necessary. Given a list of lists, the program to suppose to return the sum as the final list. Let’s see some of the methods to sum a list of list and return list.

Method # 1: Using Naive method

Initial List -  [[1, 2, 3], [4, 5, 6], [7, 8, 9]]
final list -  [12, 15, 18]

Time complexity: O(n^2), where n is the length of the outer list.
Auxiliary Space: O(n), the space required to store the result list.

Method #2: Using numpy array 

A numpy is a general-purpose array-processing package. It provides a high-performance multidimensional array object and tools for working with these arrays.

Initial List -  [[1 2 3]
                 [4 5 6]
                 [7 8 9]]
final list -  [12 15 18]

Method #3: Using zip() and list comprehension

Initial List -  [[1, 2, 3], [4, 5, 6], [7, 8, 9]]
final list -  [12, 15, 18]

Time Complexity: O(n), where n is the length of List.
Auxiliary Space: O(n), where n is the length of ‘res’ list.

Method #4: Using map() and lambda

One approach that is not present in the article is using the map function and a lambda function to sum the elements of the list of lists.

The map function applies a given function to each element of an iterable (such as a list) and returns a new iterable with the modified elements. In this case, we can use a lambda function that takes a list as an argument and returns the sum of its elements, and apply it to each sublist in the list of lists using map.

Here is an example of how you could use this approach to sum the list of lists:

The time complexity of the code provided is O(n * m), where n is the number of sublists and m is the length of each sublist. This is because the map function needs to iterate over all n sublists and m elements in each sublist. The space complexity is also O(m).

Method #5: Using itertools

Approach:

1. Import the itertools module: import itertools
2. Define the sum_lists_itertools function with lst as the parameter:
3. Use the zip_longest() function from itertools to transpose the list of lists. This function takes the asterisk * operator to unpack the sub-lists and fill any missing values with a fillvalue of 0.
4. Use a list comprehension to sum the corresponding elements of each sub-list and return the resulting list:
5. Define the input ‘lst’ with a list of lists.
6. Call the sum_lists_itertools function with ‘lst’ as an argument and assign the result to result.
7. Print the result to the console.

Time Complexity: O(N^2)
Auxiliary Space: O(N)

Method #6: Using built-in function reduce() from the functools module

('Initial List - ', '[[1, 2, 3], [4, 5, 6], [7, 8, 9]]')
('Final list - ', '[12, 15, 18]')

Time Complexity: O(N^2)
Auxiliary Space: O(N)

Last Updated :
27 Apr, 2023

Like Article

Save Article