How to change object once in a loop

While doing the downshift as well (just for myself) I found an even better approach than in my previous answer:

deque adds rotation functionality to iterables.

from collections import deque

newlist = ['X', 'X', 'A', 'X', 'A', 'X', 'A']
print(f'Original:\n{newlist}')  # debug

a = deque(newlist)
b = deque(newlist)

a.rotate(1)
newlist = list(a)
print(f'Shift up:\n{newlist}')

b.rotate(-1)
newlist = list(b)
print(f'Shift down:\n{newlist}')

Result:

Original:
['X', 'X', 'A', 'X', 'A', 'X', 'A']
Shift up:
['A', 'X', 'X', 'A', 'X', 'A', 'X']
Shift down:
['X', 'A', 'X', 'A', 'X', 'A', 'X']

The code is self-explanatory. There is an if case to check the existence of [index+1]

list = ['X','X','A','X','X','X','X']

try:
    for el in list:
        print(list)
        if el == 'A':
            index = list.index(el)
            if list[index+1]:
                list[index+1] = el 
            list[index] = 'X'
except:
    print('Out of index!!')

Result:

C:\Desktop>python test.py
['X', 'X', 'A', 'X', 'X', 'X', 'X']
['X', 'X', 'A', 'X', 'X', 'X', 'X']
['X', 'X', 'A', 'X', 'X', 'X', 'X']
['X', 'X', 'X', 'A', 'X', 'X', 'X']
['X', 'X', 'X', 'X', 'A', 'X', 'X']
['X', 'X', 'X', 'X', 'X', 'A', 'X']
['X', 'X', 'X', 'X', 'X', 'X', 'A']
Out of index!!

just use the command break after doing the change:

newlist = ['X','X','A','X','X','X','X']

for i in range(len(newlist)):

    if newlist[i] == 'A':

        newlist[i] = 'X'

        newlist[i+1] = 'A'

        break
print " ". join(newlist)

or with continue:

newlist = ['X','X','A','X','X','X','X']
k = -1
for i in range(len(newlist)):

    if k == i:
        continue

    if newlist[i] == 'A':

        newlist[i] = 'X'

        newlist[i+1] = 'A'

        k = i+1
print " ". join(newlist)

With itertools.islice and next() you can manipulate the iterable.
Kudos to my source: How do I skip a few iterations in a for loop.

Also handled an 'A' at the very end and works with several 'A' in the list.

from itertools import islice

newlist = ['X', 'X', 'A', 'X', 'A', 'X', 'A']
print(newlist)  # debug

numbers = iter(range(len(newlist)))

for i in numbers:
    if newlist[i] == 'X':
        print(newlist[i])

    if newlist[i] == 'A':
        newlist[i] = 'X'
        print(newlist[i])
        if i < len(newlist) - 2:
            newlist[i+1] = 'A'
            print(newlist[i+1])
        next(islice(numbers, 1, 1), None)

print(newlist)  # debug

Result:

['X', 'X', 'A', 'X', 'A', 'X', 'A']
X
X
X
A
X
A
X
['X', 'X', 'X', 'A', 'X', 'A', 'X']

In mixing the state output and state change operations, you've presented only one item of the list for each row. This is akin to using a super high frame rate without vertical blank synchronisation. Every row shows only a fraction of the whole picture, in this case the moment when the A appears in every position from its origin down. You could easily visualise this by printing newlist instead of newlist[i].

The operation to move the A has several issues in itself. It's in a loop that we could assume is meant to find the A, but that's more efficiently done with the index method. More significantly, once found, you keep looping and therefore will continue moving the A until it hits the end - in this case with an IndexError, as there will be no newlist[i+1] entry to swap with. The traditional way to ensure the task is done once is to break out of a search loop. Another solution may be to never alter the list you're iterating over, but create a new generation derived from it; then you'll never read a newly modified position.

Yet another approach here works on the basis that X is the background and all As move in the same direction, including off the end of the list:

newstate = ['X']+oldstate[:-1]    # Shift to higher indices

And here is one where As move only if they can, based on a rule table:

moves = {('X', 'A', 'X'): 'X',  # Moved off to the right
         ('A', 'A', 'X'): 'X',  # Moved off to the right
         ('A', 'X', 'X'): 'A',  # Moved in from the left
         ('A', 'X', 'A'): 'A',  # Moved in from the left
        }
newstate = [moves.get((l,h,r), h) for (l,h,r) in 
            zip(['X']+oldstate, oldstate, oldstate[1:]+['A'])]

This uses an X as the left boundary and A as the right boundary to avoid As walking off the edges. It might be useful to define another cell state to represent a wall. On that note, this is an example of a cellular automaton.