Fonction décalage

Bonjour,

Je dois rédiger une fonction qui, à partir d'une liste L = [a,b,c], renvoie L = [b,c,a].
Voici le programme que j'ai rédigé :

def decalage(L) :
    return L.append(L.pop(0))


Or, quand j'exécute ma fonction dans le Shell, elle ne renvoie rien ...
Merci de votre aide !

Configuration: Macintosh / Safari 13.0.5

9 réponses

  1. Bonsoir,
    La fonction
    append
    ne retourne rien, elle fait simplement une modification de la liste. Voilà pourquoi tu n'as rien en sortie.
    0
    1. D’accord merci beaucoup! Mais dans ce cas comment puis-je modifier mon programme pour avoir une liste en sortie ? J’ai tenté d’utiliser des deepcopy mais cela n’a pas marché..
      0
    2. Contributeur
      @Loucomment appelles-tu cette fonction? que fais-tu du résultat? montre-nous ton programme complet.
      0
    3. Contributeur
      @Louas-tu compris ce que faisait append()?
      quelle liste voudrais-tu en sortie?
      0
  2. Bonjour Lou,

    pourquoi ne pas créer une 2eme liste ?

    L2 = [L[k] for k in range(len(L)-1,-1, -1)]
    
    0
    1. D’accord j’ai compris , merci beaucoup pour l’ensemble de vos conseils !
      0
  3. Bonjour Phil_1857,

    Ce ne me semble pas une bonne idée. Vous indiquez une inversion de liste, alors que Lou souhaite faire une permutation circulaire. Son idée de départ me parait d'ailleurs pertinente.
    0
    1. Bonjour Furansujean,

      Mais oui, tu as raison, quel blaireau je fais ! J'ai lu trop vite !

      Allez hop, copie à revoir ! :-)
      0
      1. Ça arrive, même aux meilleurs ! :-)
        0
        1. On peut décomposer, alors:

          L = ['a','b','c']
          s = L.pop(0)
          L.append(s)
          


          Là, on obtient bien L = b,c,a
          0
          1. Mais à ce stade , si je convertis ce script en fonction , je vais avoir le même problème : à la sortie je ne vais rien avoir de renvoyé car la liste aura été modifiée en place ?
            En fait j’ai besoin que cette fonction me renvoie une liste (car je l’utilise ensuite dans un autre programme plus conséquent)
            0
          2. @LouBonsoir Lou,
            que veux-tu en sortie ? ta liste modifiée ? tu peux donc faire un
            return
            de cette liste après que tu l'as modifiée.
            0
          3. Contributeur
            pourquoi pas
                L2= [L[k] for k in range(len(L))]
                L2.append(L2.pop(0))
            , qui évite de modifier la liste de départ?
            0
        2. L = ['a','b','c']
          def decalage(L):
          
          	L2= [L[k] for k in range(len(L))]
          	L2.append(L2.pop(0))
          	return(L2)
          
          L2 = decalage(L)
          
          0
          1. Contributeur
            c'est souvent une source de confusion d'utiliser les mêmes noms de variable dans et hors les fonctions.
            0
        3. C'est vrai !

          import copy
          
          def decalage(liste_a_decaler):
          	''' Renvoie une liste qui est la permutation circulaire
          	de celle passée en argument '''
          
          	liste_decalee = copy.copy(liste_a_decaler)
          	liste_decalee.append(liste_decalee.pop(0))
          
          	return(liste_decalee)
          
          L = ['a','b','c']
          L2 = decalage(L)
          print(L2) #imprime ['b', 'c', 'a']
          
          0
          1. Bonsoir Lou,

            La réponse de Phil_1857 répond-elle à ta question ? Si oui, je te propose de marquer le sujet comme "Résolu".

            Remarques :
            1. Si la liste
            liste_a_decaler
            est plate (ce qui est le cas de l'exemple donné) c'est-à-dire qu'elle ne contient pas de sous-liste, alors on peut se passer du module
            copy
            importé.
            Pour une copie de liste on peut faire :
            liste_decalee = liste_a_decaler.copy()

            Il s'agit alors d'une "copie superficielle".

            2. Je sors un peu du sujet, mais à noter : si la liste contient des sous-listes, du genre
            [['a',1],['b'],'c',0.5]
            alors il faut utiliser une "copie profonde" :
            import copy
            #...
            liste_decalee = copy.deepcopy(liste_a_decaler)

            La vidéo suivante explique très bien ce point : https://www.youtube.com/watch?v=I3dbeflpI-Q
            0