Python Sum of Array Program

Beginner
5 min read
Updated: Oct 2026
3 programs
Live preview
Definition

What Is the Sum of an Array?

The sum of an array (or list) is the result of adding every element once. This is the classic accumulator pattern: start at 0, then total += value for each item.

Remember
sum(arr) = arr[0] + arr[1] + ... + arr[n-1]

Example: [1, 2, 3, 4, 5]
  0 → 1 → 3 → 6 → 10 → 15

Empty array → 0
ArrayRunning totalSum
[1, 2, 3, 4, 5]1, 3, 6, 10, 1515
[10, -2, 7]10, 8, 1515
[](no steps)0
Approach

How to Find the Sum of an Array in Python

Four clear steps — one pass is enough.

  1. Set total = 0.
  2. Visit every element with a for loop.
  3. Add each value: total += value.
  4. Return total after the loop ends.
MethodIdeaTimeBest for
for loopAccumulator over each valueO(n)Interviews, clearest logic
Index looptotal += arr[i]O(n)When you need the index
Built-in sum()sum(arr)O(n)Production code

Pseudocode

Pseudocode
function SumArray(arr):
    total = 0
    for each value in arr:
        total = total + value
    return total
Reference

Cheat Sheet

Keep these facts handy while writing the program.

TopicDetail
Starttotal = 0
Steptotal += value
Empty arraySum is 0
NegativesAllowed; they reduce the total
Built-insum(arr)
Classic check[1, 2, 3, 4, 5] → 15
Try it

Live Preview

Enter integers separated by commas or spaces to see the running total and final sum.

Whole numbers only. An empty input sums to 0.

Result
Array: [1, 2, 3, 4, 5]
Running: 0 → 1 → 3 → 6 → 10 → 15
Sum = 15
Trace

Worked Walkthrough — [1, 2, 3, 4, 5]

Watch the accumulator grow after each addition.

Calculation
total = 0

+ 1  → total = 1
+ 2  → total = 3
+ 3  → total = 6
+ 4  → total = 10
+ 5  → total = 15

Sum = 15
Code

Python Programs

Start with a fixed list and a simple helper. Then read values from input, and finish by tracing a running total with negatives.

Example 1 — Sum of a Fixed Array

Use a for loop to add every element into an accumulator.

python
def sum_array(arr: list[int]) -> int:
    total = 0
    for value in arr:
        total += value
    return total


array = [1, 2, 3, 4, 5]
print(f"Sum of the array elements: {sum_array(array)}")

How It Works

  1. total starts at 0.
  2. The loop visits 1, 2, 3, 4, then 5.
  3. Each visit does total += value.
  4. The running values are 1, 3, 6, 10, then 15.
  5. Return the final total. Shortcut in real code: sum(array).

Example 2 — Sum with User Input

Read n, fill a list, then reuse the same summing helper.

python
def sum_array(arr: list[int]) -> int:
    total = 0
    for value in arr:
        total += value
    return total


n = int(input("Enter number of elements: "))
if n < 0:
    raise ValueError("n must be nonnegative.")

arr = []
for i in range(n):
    value = int(input(f"Enter element {i + 1}: "))
    arr.append(value)

print(f"Sum of the array elements: {sum_array(arr)}")

How It Works

  1. Read the length n and reject a negative size.
  2. Build a list by appending each typed value.
  3. Call sum_array — input and summing stay separate.
  4. If n is 0, the list is empty and the sum is 0.
  5. Same helper as Example 1, so testing stays easy.

Example 3 — Running Total with Negatives

Print the accumulator after each step so negatives are easy to see.

python
arr = [10, -2, 7]
total = 0

print("Running total:")
for value in arr:
    total += value
    print(f"  after {value:+d}: {total}")

print(f"Final sum: {total}")

How It Works

  1. Start at 0, then add 10 → 10.
  2. Add -2 → 8 (no special case for negatives).
  3. Add 7 → 15.
  4. {value:+d} shows a sign on each added value.
  5. Tracing the running total is a strong whiteboard habit.

Edge Cases & Pitfalls

Check these before calling the solution done.

Empty

Sum is 0

An empty list never enters the loop, so the accumulator stays at 0.

Negatives

Just add them

Do not take absolute values unless the problem asks for that.

Built-in

sum(arr)

Fine in apps; write the loop yourself in interviews.

None

Guard invalid input

In real code, check for None before looping. Interviews often assume a valid list.

Analysis

Time and Space Complexity

ProgramTimeExtra space
for loop / sum()O(n)O(1)
User-input build + sumO(n)O(n) for the list
Running-total traceO(n)O(1)

You must look at every element at least once, so O(n) is optimal for the general case.

Remember

Key Takeaways

  • Pattern: accumulator starts at 0, then adds each element once.
  • Loop: for value in arr: total += value.
  • Empty: no iterations → sum stays 0.
  • Test set: [1,2,3,4,5] → 15; [10,-2,7] → 15; [] → 0.

One line: start at zero, add every element once, return the total.

Frequently Asked Questions

Start with total = 0, then loop through the list and add each element with total += value. Built-in: sum(arr).
Zero is the additive identity. Starting there makes the final total equal the sum of all elements, including the empty-list case.
Yes. The same loop works; negatives reduce the running total.
Prefer a loop in interviews to show the accumulator. In real code, sum(arr) is fine.
O(n) time and O(1) extra space for a single pass over n elements.

Next: Sum of Digits

Add the digits of a number with n % 10.

Sum of digits tutorial →

About the author

Mari Selvan M P
Mari Selvan M P 🔗

Developer, cloud engineer, and technical writer

  • Experience 12 years building web and cloud systems
  • Focus Full Stack Development, AWS, and Developer Education

I write practical tutorials so students and working developers can learn by doing—from databases and APIs to deployment on AWS.

AWS Certified Developer – Associate (Credly)

13 people found this page helpful

Python Strong Number Program Python Sum of Digits Program