You really should be using enumerate for stuff like this, as you can loop through the index and the value at the same time (which will save you the hassle of using two for-loops).

for i, j in enumerate(list):
    print i, j

Your inner loop is overriding the variable index that you defined in the first loop.

You can use itertools.accumulate on reversed list to get the sums and then switch to the sum in positions of where 0s exist in the original -

from itertools import accumulate

acc = list(accumulate(reversed(v)))  #list of cumsums
sums = [j if i==0 else i for i,j in zip(reversed(v), acc)]  #switch to cumsum where 0 exists in list
out = list(reversed(sums))  #reverse it back
print(out)

[36, 5, 5, 26, 6, 6, 14, 7, 7]

You should use i = 0 in situations where iterating starting at zero would be natural, as previously stated this could include array indexing or similar. Personally I would say I use this style at least 90% of the time, as when modelling problems in the computer we mold them to use built in data structures, which usually start at 0. Our minds become use to working in this style.

Starting at i = 1 is more natural for modeling many problems while designing algorithms. For example, if you are given a problem such as person 1 is x years old, person 2 is y years old, and so on, indexing using the given numbers may make it easier to give an answer if asked something such as who is the youngest person in the list. Experience and experimentation will teach you if this is worthwhile, in my experience, this can be helpful in things such as programming competitions (like the ICPC), where algorithms must be developed quickly with not much time for debugging, and the algorithms can be very complex, so the clarity is important.

In other words it may be beneficial to waste this first index if it adds clarity, however experienced programmers quickly learn to understand both styles.

However, if you start at zero, remember to be aware that the arrays still start at zero, and you will need an n + 1 size array to represent n elements if you use indexing starting at 1.

Also be aware of your conditional in the for loop.

for (int i = 0; i < 10; i++) - Will loop 10 times

for (int i = 1; i <= 10; i++) - Will loop 10 times

It is basic, but a common source of errors that may be hard to track down, especially for beginning programmers.

You shouldn't be adding kertoma in the loop, you should be adding the iteration variable from the range.

You need to use a different variable for the iteration than the variable you're adding to.

You don't have to write int(0), just 0. And tulos is an integer, so you don't have to write int(tulos).

The limit of the range should be kertomas, not kertomas+1, because range() doesn't include the end.

kertoma = int(input("Kuinka monta kierrosta?:"))

tulos = 0

for i in range(1, kertoma):
    tulos = tulos + i
    
print("Kertymäksi saatiin:", tulos)

range(1, n+1) is not considered duplication, but I can see that this might become a hassle if you were going to change 1 to another number.

This removes the duplication using a generator:

for _ in (number+1 for number in range(5)):
    print(_)

Remind them that there is a reason the range function works this way. One helpful property of it is that the number of times the loop will run is equal to the second argument of range minus the first argument.

I think people get really hung up on this, but the fact is for loops in Python are very different than from C. In C, for loops are basically a wrapper around a while loop.

These two examples should help show the difference between how loops work in C versus python.

Copy# for(int x=1; x <= 10; x++)
x = 1
while x <= 10:
    print(x)
    x += 1


i = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]  # range(1, 11)
for x in i:
    print(i)

But honestly, the real problem here is that all loops and arrays are easier to understand and work with if they start at zero, not one. Please consider adjusting your examples to start at zero.

This way, if you want to loop 10 times, you use the number 10.

Copy   # for(int x=0; x < 10; x++)
x = 0
while x < 10:
    print(x)
    x += 1


i = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]  # range(10)
for x in i:
    print(i)

First thing is to remember that python uses zero indexing.

You can iterate throught the list except using the range function to get the indexes of the items you want or slices to get the elements.

What I think is becoming confusing here is that in your example, the values and the indexes are the same so to clarify I'll use this list as example:

I = ['a', 'b', 'c', 'd', 'e']
nI = len(I) # 5

The range function will allow you to iterate through the indexes:

for i in range(1, nI):
    print(i)
# Prints:
# 1
# 2
# 3
# 4

If you want to access the values using the range function you should do it like this:

for index in range(1, nI):
    i = I[index]
    print(i)
# Prints:
# b
# c
# d
# e

You can also use array slicing to do that and you don't even need nI. Array slicing returns a new array with your slice.
The slice is done with the_list_reference[start:end:steps] where all three parameters are optional and:
start is the index of the first to be included in the slice
end is the index of the first element to be excluded from the slice
steps is how many steps for each next index starting from (as expected) the start (if steps is 2 and start with 1 it gets every odd index).
Example:

for i in I[1:]:
    print(i)
# Prints:
# b
# c
# d
# e