Discussion :

[As_Myers]

Bonjour ,
Je suis bloqué sur une fonction en Python je n'arrive pas à comprendre où se trouve mon erreur.
Je dois créer une fonction en python qui remplace un mot par un autre lorsqu'on le trouve dans une liste. Pour tester les fonctions j'ai décidé de remplacer le mot "chat" par le mot "chien" .

Le but de l'exercice était de reprendre une fonction que j'ai faite en LISP, de la traduire en C, puis en Python. Mais pour celle en Python je ne comprends pas pourquoi seulement la première occurrence du mot est traitée:

Voici ma fonction :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
def remplace(L, toto, tata) :
  if not L : return None
  if L[0] == toto : L[0] = tata            #si (car L) == toto je le remplace par tata
  return remplace(L[1:], toto, tata)    #je passe à la suite de la liste (cdr L)

Test de la fonction:

>L = ['chat', 'loup', 'pieuvre', 'chat', 'loutre', 'rat']

> remplace(L, "chat", "chien")
> L
['chien', 'loup', 'pieuvre', 'chat', 'loutre', 'rat']


Merci beaucoup pour votre aide.

[plxpy]

Bonjour
Ton erreur est à la ligne 4 : L[1:] est une nouvelle liste. Tu ne changeras jamais que le premier élément (s'il vaut toto) en t'y prenant de la sorte.
Là, dans tes tests, tu as déjà eu de la chance ! Essaye de changer "loup" en ce que tu veux : ta liste ne changera même pas.

[VinsS]

Salut,

En général on ne convertit pas du code entre des langages aussi différent en espérant qu'un mimétisme syntaxique suffira.

Chance si ça marche.

Dans ton cas tu peux itérer sur les termes de la liste.

Si tu dois conserver la liste:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
 
>>> def replace_(items, old, new):
...     for idx, i in enumerate(items):
...             if i == old:
...                     items[idx] = new
... 
>>> replace_(L, 'chat', 'chien')
>>> L
['chien', 'loup', 'pieuvre', 'chien', 'loutre', 'rat']

Si tu veux une autre liste:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
 
>>> def replace_(items, old, new):
...     return [i.replace(old, new) for i in items]
... 
>>> L2 = replace_(L, 'chat', 'chien')
>>> L2
['chien', 'loup', 'pieuvre', 'chien', 'loutre', 'rat']

[As_Myers]

Je viens de faire un test en accédant directement à la deuxième occurrence de 'chat' comme le ferait la fonction. Effectivement ça ne fonctionne pas du tout.
Il n'y a donc pas de solution pour que la fonction REMPLACE fonctionne correctement en utilisant L[1:] comme paramètre?

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
>>> L
['chat', 'loup', 'pigeon', 'chat', 'pierre', 'ciseaux']
 
> L[3:][0] == 'chat'       
True
 
> L[3:][0] = 'chien'      
> L
['chat', 'loup', 'pigeon', 'chat', 'pierre', 'ciseaux']

[wiztricks]

Salut,

Il n'y a donc pas de solution pour que la fonction REMPLACE fonctionne correctement en utilisant L[1:] comme paramètre?

Il n'est pas interdit de faire que replace retourne une nouvelle liste (plutôt que d'essayer de modifier la liste "in place").
Une autre solution serait d'ajouter l'indice de début à traiter comme paramètre.
Mais comme vous programmez en Python et non en Lisp, une boucle "for" serait tout aussi bien.

- W

[As_Myers]

En général on ne convertit pas du code entre des langages aussi différent en espérant qu'un mimétisme syntaxique suffira.

J'aimerai bien faire autrement mais le déplacement dans la liste doit se faire comme en LISP, je dois donc éviter les boucles. Vous pouvez voir si dessous deux fonctions que j'ai faite en suivant cette consigne.


En Lisp

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
(defun occurences (L toto) 
  (cond
  ((not L) 0)
  ((string= (car L) toto) (1+ (occurences (cdr L) toto))) 
  ((occurences (cdr L) toto)) ) )

Puis en PYTHON

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
 
def occurences(L, toto) :
  if not L : return 0
  if L[0] == toto : return 1 + occurences(L[1:], toto)
  return occurences(L[1:], toto)

[As_Myers]

Il n'est pas interdit de faire que replace retourne une nouvelle liste (plutôt que d'essayer de modifier la liste "in place").
Une autre solution serait d'ajouter l'indice de début à traiter comme paramètre.

Je pense essayer ces deux solutions, merci à tous pour votre aide, le plus important était que je comprenne mon erreur et c'est chose faite

[wiztricks]

J'aimerai bien faire autrement mais le déplacement dans la liste doit se faire comme en LISP, je dois donc éviter les boucles. Vous pouvez voir si dessous deux fonctions que j'ai faite en suivant cette consigne.

Lorsque vous écrivez:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
for x in range(len(L)):
     if L[x] == ...

vous balayez la liste du premier au dernier élément.

Pire comme L[1:] construit une nouvelle liste à chaque appel, vous ne vous déplacez plus du tout dans la liste...

- W

[VinsS]

... je dois donc éviter les boucles

Lorsque tu fais:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
def occurences(L, toto) :
  if not L : return 0
  if L[0] == toto : return 1 + occurences(L[1:], toto)
  return occurences(L[1:], toto)

Tu boucles sur la fonction elle-même.

[As_Myers]

Quand je disais devoir éviter les boucles je voulais dire éviter d'introduire des boucles de type for ou while dans la fonction, mais je dois bien boucler sur la fonction elle même.

Je n'ai pas encore réussi à ajouter l'indice du début de la liste à traiter comme paramètre de la fonction comme l'a suggéré wiztricks mais j'ai fait en sorte que la fonction remplisse une nouvelle liste.

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
L = ['loup', 'chat', 'chat', 'chat', 'chat', 'rat']
L2 = []
 
def remplace(L, old, new) :
    if not L : return None
    if L[0] == old : L2.append(new)
    else : L2.append(L[0])
     remplace(L[1:], old, new)
 
 
>remplace(L, "chat", "chien")
>L2
['loup', 'chien', 'chien', 'chien', 'chien', 'rat']

[VinsS]

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
 
L2 = []
 
def remplace(L, old, new) :
    if not L : return None
    if L[0] == old : L2.append(new)
    else : L2.append(L[0])
     remplace(L[1:], old, new)

Nous appelons cela "définitivement anti-pythonique".

[As_Myers]

Nous appelons cela "définitivement anti-pythonique".

On est d'accord, mais c'est ce que l'on me demande de faire... Ça doit vous piquer les yeux

[wiztricks]

On est d'accord, mais c'est ce que l'on me demande de faire... Ça doit vous piquer les yeux

En Lisp (et en Python), on évite les variables globales.
On écrit donc plutôt cela ainsi:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
>>> def replace(alist, old, new):
...     if alist:
...        w = alist[0] if alist[0] != old else new
...        return [ w ] + replace(alist[1:], old, new)
...     return []
 
>>> L = ['loup', 'chat', 'chat', 'chat', 'chat', 'rat']
>>> replace(L, 'chat', 'chien')
['loup', 'chien', 'chien', 'chien', 'chien', 'rat']
>>> replace(L, 'rat', 'chien')
['loup', 'chat', 'chat', 'chat', 'chat', 'chien']
>>>

Et si on est branché côté compréhension de liste:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
>>> def replace(alist, old, new):
...     return [ w.replace(old, new) for w in alist ]
...

- W