Problem:

In the following expression $$ 1 - 2 + 3 cdots + 99 - 100 $$ print result every 10th (10, 20, 30, ...) calculation.

My code:

result  = 0

operand = 1

counter = 0

for i in range(1, 101):

    result = result + (i * operand)

    counter = counter + 1

    operand = operand *  -1 #Convert between positive and negative number

    if counter >= 10:

        counter = 0

        print(result)

My problem:

I think this code has not good readability. For example, I used $ * -1 $ for changing positive and negative number. But it requires math skill(multiplying a negative number) to understand code.

And I don't sure variable name 'counter' and 'operand' is appropriate for this context.

Is there any suggestion?

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)

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

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

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)