Problème boucle for python

bonjour,

pouvez vous m’aider svp, quand je lance ce code, le mot appelé mot est toujours "patate" alors que je veux le changer en "..t.t.", merci d’avance :`py

mot = "patate"
for letter in mot :
    if letter != "p":
        letter = "."
    else :
        letter = "p"
print(mot)

Le problème est assez simple : quand tu boucles sur les caractères d’une chaîne, la variable de la boucle (ici letter) n’existe que dans la boucle, et est indépendante. La modifier ne va pas changer la lettre correspondante dans la chaîne.

Ainsi, ici, ce que tu fais, c’est pour chaque lettre du mot :

• crées une variable ayant la lettre pour valeur ;
• modifie cette variable dans le corps de la boucle ;
• puis, en arrivant à la fin du corps de la boucle, supprime la variable (c’est implicite, c’est Python qui fait ça tout seul car elle n’est plus utilise).

Comme la variable n’est pas liée à la x^ème lettre dans le mot, ça ne change pas ce dernier.

Pour faire ce genre de remplacements, le plus simple est de passer par une expression régulière.

Pour garder la même structure de code, il est aussi possible de :

• transformer le mot en une vraie liste ;
• itérer sur les indexes (for i in range(len(la_liste_des_lettres_du_mot))) ; et
• modifier chaque élément de la liste via son index (là, ce sera lié à la liste d’origine) (la_liste_des_lettres_du_mot[i] = blalabla).

Pour créer une liste de caractères à partir d’une chaîne de caractères, tu peux utiliser quelque chose comme ça :

>>> mot = "patate"
>>> la_liste_des_lettres_du_mot = list(iter(mot))
>>> la_liste_des_lettres_du_mot
['p', 'a', 't', 'a', 't', 'e']

iter va retourner un itérateur sur les caractères du mot, et list va mettre ces caractères dans une vraie liste, en gros.

Bonjour, merci de m’avoir répondu mais je n’ai pas le droit d’utiliser le terme "iter"

Bonjour ,

J’ai appris ça il y a pas longtemps et quand j’apprend quelque chose de nouveau j’ai tendance a tout le temps l’utilisé. En tout qu’a ça semble fonctionné

mot = "patate"
for letter in mot :
    if letter != "t":
        mot = mot.replace(letter,".")
print(mot)

Merci !

• itérer sur les indexes (for i in range(len(la_liste_des_lettres_du_mot))) ; et
• modifier chaque élément de la liste via son index (là, ce sera lié à la liste d’origine) (la_liste_des_lettres_du_mot[i] = blalabla).

Ou enumerate, qui permettra d’avoir à la fois i et letter.

iter n’est pas nécessaire dans l’histoire, list(mot) permet déjà de transformer une chaîne de caractères (qui est un itérable) en liste (dont le constructeur accepte tout itérable).

Ça fonctionne mais ce n’est pas très efficace. À chaque itération replace va opérer sur toute la chaîne (si le caractère n’est pas 't'), c’est un algo en O(n²). Aussi, ça traite plusieurs fois pour rien les lettres qui seraient en double (ou plus) dans le mot.

iter n’est pas nécessaire dans l’histoire, list(mot) permet déjà de transformer une chaîne de caractères (qui est un itérable) en liste (dont le constructeur accepte tout itérable).

Effectivement je me compliquais la vie je le savais très bien en plus, m’enfin peu importe. My bad

Salut !

Juste à titre d’info. La façon la plus cool de faire ça en Python (sans considérer que c’est un exercice où n’a pas le droit d’utiliser quoi que ce soit d’autre que ce qui est contraint par son prof, patati patata…), c’est d’utiliser str.translate():

>>> "patate".translate({ord('t'): '.'})
'pa.a.e'

J’imagine que c’est pour un pendu ? Dans ce cas il suffit de créer une table de traduction avec toutes les lettres minuscules, et en virer les lettres au fur et à mesure qu’elles ont été devinées.

>>> import string
>>> table = {ord(c): '.' for c in string.ascii_lowercase}
>>> "patate".translate(table)
'......'
>>> del table[ord("e")]  # le joueur a deviné "e"
>>> "patate".translate(table)
'.....e'
>>> del table[ord("t")]  # le joueur a deviné "t"
>>> "patate".translate(table)
'..t.te'

Note: ici je manipule directement la table de traduction sans passer par str.maketrans (qui prendrait le même dictionnaire mais avec des clés "x" au lieu de ord("x") pour créer cette variable table), du coup les indices de la table sont les ordinaux unicode des différents caractères (ord("x") retourne l’ordinal de "x"). C’est peut-être un peu "bas niveau" comme considération dans un contexte Python… mais ce serait horriblement inefficace de regénérer la table à chaque itération, et ce faisant je me sentirais sale.