Écrire renverser(t) , qui renverse le tableau en place par échanges…

def renverser(t):
    """Renverse le tableau t EN PLACE, par echanges.

    Invariant : apres k echanges, les k premiers et les k derniers
                elements sont a leur place definitive.
    """
    n = len(t)
    for i in range(n // 2):
        t[i], t[n - 1 - i] = t[n - 1 - i], t[i]
    return t

L'échange se fait par affectation multiple, sans variable temporaire : c'est la méthode a, b = b, a du cours, appliquée à deux cases d'un même tableau.

Le nombre d'échanges : $\lfloor n/2\rfloor$. Chaque échange place deux éléments. Sur un tableau de longueur impaire, l'élément du milieu est déjà à sa place — il s'échangerait avec lui-même. La division entière n // 2 traite les deux parités d'un coup : $4$ éléments donnent $2$ échanges, $3$ éléments également $1$.

Si l'on écrit range(n).

def renverser_faux(t):
    n = len(t)
    for i in range(n):
        t[i], t[n - 1 - i] = t[n - 1 - i], t[i]
    return t

print(renverser_faux([1, 2, 3, 4]))      # [1, 2, 3, 4]

On retrouve le tableau de départ : la seconde moitié de la boucle refait, à l'envers, les échanges de la première. Chaque paire est échangée deux fois, ce qui la remet en place. Le symptôme est trompeur — la fonction paraît « ne rien faire » alors qu'elle travaille deux fois trop.

Vérification.

assert renverser([1, 2, 3, 4]) == [4, 3, 2, 1]
assert renverser([1, 2, 3]) == [3, 2, 1]
assert renverser([]) == [] and renverser([7]) == [7]

for _ in range(1000):
    t = [random.randint(0, 9) for _ in range(random.randint(0, 10))]
    c = list(t)
    c.reverse()
    assert renverser(list(t)) == c

Les $1000$ cas passent. Le tableau à trois éléments est le cas de test décisif : c'est lui qui vérifie que le milieu est bien laissé tranquille.