How to doing dynamic calculation in python

How to make it like that so odd indexes will be doing (-) and even indexes will do (+) The max iteration is 6. iteration 1 +10, iteration 2 -20, iteration 3 +30, iteration 4 -40, iteration 5 + 50, iteration 6 -60

AA = np.array([[9.27914]+10,
              [9.33246]-20,
              [9.26303]+30,
              [9.30597]-40,
              [9.6594 ]+50,
              [9.04283]-60,
              [8.88866]+10,
              [8.89956]-20])

expected results:

AA=np.array([
    [19.27914],
    [-10.66754],
    [39.26303],
    [-30.69403],
    [59.6594],
    [-50.95717],
    [18.88866],
    [-11.10044],
])

I try use this code but not working

max_iter = 6
iter = 0
for i in range(len(AA)):
    if i % 2 == 0:
        AA[i][0] = AA[i][0] + (iter % max_iter)
    else:
       AA[i][0] = AA[i][0] - (iter % max_iter)
    iter += 10

This is [tag:numpy], don't loop, use vectorial code.

The modulo operator (%) is quite useful to restart a sequence.

max_iter = 6

a = np.arange(len(AA))[:,None]

out = AA + (a%max_iter+1)*10 * np.where(a%2, -1, 1)

Output:

array([[ 19.27914],
       [-10.66754],
       [ 39.26303],
       [-30.69403],
       [ 59.6594 ],
       [-50.95717],
       [ 18.88866],
       [-11.10044]])

Used input:

AA = np.array([[9.27914],
               [9.33246],
               [9.26303],
               [9.30597],
               [9.6594 ],
               [9.04283],
               [8.88866],
               [8.89956]])

Intermediates:

(a%6+1)*10

array([[10],
       [20],
       [30],
       [40],
       [50],
       [60],
       [10],
       [20]])

np.where(a%2, -1, 1)

array([[ 1],
       [-1],
       [ 1],
       [-1],
       [ 1],
       [-1],
       [ 1],
       [-1]])

You were very close. Just had to make 3 small changes. I added a +1 inside the parenthesis, added *10 for each of the array operations and change iter += 10 to array += 1

max_iter = 6
iter = 0
for i in range(len(AA)):
    if i % 2 == 0:
        AA[i][0] = AA[i][0] + (iter % max_iter+1)*10
    else:
        AA[i][0] = AA[i][0] - (iter % max_iter+1)*10
    iter += 1

In fact, you can remove the if else statement and do it in a single line if you use the following:

AA[i][0] = AA[i][0] +(-1)**(i)* (iter % max_iter+1)*10

Try this:

AA = [
    9.27914,
    9.33246,
    9.26303,
    9.30597,
    9.6594,
    9.04283,
    8.88866,
    8.89956
]

BB=[]

iter = 10
for i in range(len(AA)):
    if i % 2 == 0:
        var = AA[i] + (iter)
    else:
       var = AA[i] - (iter)
    BB.append(var)
    iter += 10
    
for i in range(len(BB)):
    print(BB[i])

Note: left out max iterations... will fix asap.

The root issue you have is a muddling of the meaning of your variable iter. Sometimes you seems to want to be a multiple of 10 and sometimes a number between 1 and 6. Let's separate that out and clean up the code a bit.

Given:

import numpy
AA = numpy.array([
    [9.27914],
    [9.33246],
    [9.26303],
    [9.30597],
    [9.6594 ],
    [9.04283],
    [8.88866],
    [8.89956]
])

Then we can do:

max_iter = 6
iter = 1
for i in range(len(AA)):
    delta = 10 * (iter % max_iter)
    sign = 1 if i % 2 == 0 else -1
    AA[i][0] += sign * delta
    iter += 1

print(AA)

to get:

[
 [ 19.27914]
 [-10.66754]
 [ 39.26303]
 [-30.69403]
 [ 59.6594 ]
 [  9.04283]
 [ 18.88866]
 [-11.10044]
]

or if you like something closer to what you started with:

max_iter = 6
iter = 1
for i in range(len(AA)):
    if i % 2 == 0:
        AA[i][0] += 10 * (iter % max_iter)
    else:
        AA[i][0] -= 10 * (iter % max_iter)
    iter += 1

print(AA)

I write for you a function that works without loops and give you desired result.

AA = np.array([[9.27914],
          [9.33246],
          [9.26303],
          [9.30597],
          [9.6594 ],
          [9.04283],
          [8.88866],
          [8.89956]])

expected_output = np.array([[19.27914],
          [-10.66754],
          [39.26303],
          [-30.69403],
          [59.6594],
          [-50.95717],
          [18.88866],
          [-11.10044],
])

def test(AA, iterstep, maxiter):
    aa_shape = AA.shape
    arr1 = np.tile(np.arange(1, max_iter+1), (aa_shape[0] // maxiter) + 1)[:aa_shape[0]] 
    sign_arr = np.tile(np.array([1, -1]), (aa_shape[0] // 2) + 1)[:aa_shape[0]]
    _ = (arr1*sign_arr)*10
    _=_.reshape(AA.shape)
    return AA + _

res = test(AA, 10, 6)

# Test 
assert (np.all(np.isclose(res, expected_output)))