The first thing you can do to make the sign change obvious is to use operand = -operand, this way you avoid the need for the multiplication operator. Also changing the operand name to sign can help.

You also don't need counter as it will be equal to i before the test. Just change the test to use the modulo (%) operator instead of reseting counter.

And using augmented assignment for result can lead to a more readable line too:

result = 0

sign = 1

for i in range(1, 101):

    result += sign * i

    sign = -sign

    if i % 10 == 0:

        print(result)

Now, this probably need to be made more reusable, this means building a function out of this code and avoiding mixing computation and I/Os:

def alternating_sum(start=1, stop=100, step=10):

    result = 0

    sign = 1

    for i in range(start, stop+1):

        result += sign * i

        sign = -sign

        if i % step == 0:

            yield result

Usage being:

for result in alternating_sum(1, 100, 10):

    print(result)

Also, depending on the problem at hand, you can leverage the fact that every two numbers add-up to -1. So every 10 numbers add-up to -5. If you don't need much genericity, you can simplify the code down to:

def alternating_every_ten(end=100):

    reports = end // 10

    for i in range(1, reports + 1):

        print('After', 10 * i, 'sums, result is', -5 * i)

You can get rid of your counter and directly use i by using modular arithmetic. i % 10 == 0 is true whenever i is divisible by 10.

You can get rid of your operand = operand * -1 by using itertools.cycle.

from itertools import cycle



result = 0

for i, sign in zip(range(1, 101), cycle([1, -1])):

    result += sign * i

    if i  % 10 == 0:

        print(result)

The generation of result itself would be a lot more concise with a generator comprehension, but this excludes the progress prints:

result = sum(sign * i for i, sign in zip(range(1, 101), cycle([1, -1])))

instead of doing the +- by hand, you can use the fact that (-1) ** (i-1) * i for i in range(101) alternates the values

Further on, you can use itertools.accumulate and itertools.islice to take the cumulative sum and select every 10th number

numbers = (int((-1) ** (i-1) * i) for i in range(101))

cum_sum = itertools.accumulate(numbers)

numbers_10 = itertools.islice(cum_sum, 10, None, 10)



for i in numbers_10:

    print(i)

-5

-10

-15

-20

-25

-30

-35

-40

-45

-50

or alternatively, per 200_success' suggestion:

numbers = (sign * i for sign, i in zip(itertools.cycle((1, -1)), itertools.count(1)))

cum_sum = itertools.accumulate(numbers)

numbers_10 = itertools.islice(cum_sum, 9, 100, 10)

I would convert the sign flip into a generator, created via a generator comprehension, recognizing that evens should be negative:

#  Integers from 1-100, where evens are negative: 1, -2, 3, -4, 5...

sequence_gen = (i if i % 2 else -i for i in range(1,101))

Equivalent to:

def sequence_gen():

    for i in range(1, 101):

        if bool(i % 2):  # For our purposes this is i % 2 == 1:

            yield i

        else:

            yield -i

Then your code becomes:

result = 0

for index, number in enumerate(sequence_gen):

    result += number

    if index % 10 == 9:  # Note the comparison change by starting at 0

        print(result)

Note this is about half way to what Mathias proposed, and can be used in conjunction, the combination being:

def sequence_sums(start, stop, step):

    result = 0

    seq_gen = (i if i % 2 else -i for i in range(start, stop + 1))

    for index, number in enumerate(seq_gen):

        result += number

        if index % step == step - 1:

            yield result

You could even go one further step and make the sequence a parameter:

# iterates through a sequence, printing every step'th sum

def sequence_sums(sequence, step):

    result = 0

    for index, number in enumerate(sequence):

        result += number

        if index % step == step - 1:

            yield result

Called via:

sequence = (i if i % 2 else -i for i in range(1, 101))



for sum in sequence_sums(sequence, 10):

    print(sum)

The other answers are fine. Here is a mathematical analysis of the problem you're trying to solve.

If this code is, for some reason, used in a performance-critical scenario, you can calculate the sum to $m$ in $O(1)$ time.

Notice that:

$$
begin{align}
1-2+3-4+5-6dots m &= -sum_{n=1}^{m}n(-1)^n \
&= sum_{n=1}^{m}n(-1)^{n-1} \
&= frac{1}{4}-frac{1}{4}(-1)^m(2m+1) ; ^*
end{align}
$$

* There was a typo in my original comment.

Because you only want to see every 10th result, we can substitute $m=10u$ where $uinmathbb{Z}$. This is fortunate because for all integers $(-1)^{10u} equiv 1$. Therefore:

$$
begin{align}
frac{1}{4}-frac{1}{4}(-1)^{10u}(20u+1) &= frac{1}{4}-frac{1}{4}(20u+1) \
&= frac{1}{4}-frac{20u+1}{4}\
&= frac{(1-1)-20u}{4} \
&= -5u
end{align}
$$

Look familiar? It results in $-5$, $-10$, $-15$, ...

This fact is obvious from the output, but now knowing the series that produces it, we can calculate the final result for any such $m$ quickly, and every 10th value even easier.

We can avoid computing the exponent $(-1)^m$ because $(-1)^{m} = 1$ for even values of $m$ and $-1$ for odd values.

I'm not as familiar with Python, but here's an example:

def series(m):

    alt = 1 if m % 2 == 0 else -1

    return int(1/4 - 1/4 * alt * (2 * m + 1))



def series_progress(m):

    return -5 * m



m = 134



for i in range(1, m // 10):

    print(series_progress(i))



print(series(m))

This avoids the costly computation for the final result. If we just needed the result it would be $O(1)$, but because we give "progress reports" it is more like $lfloorfrac{n}{10}rfloorin O(n)$.