Bonjour, je voudrais déterminer si deux mots sont des anagrammes. Si oui, ma fonction va retourner True. Si non, elle retournera False. On suppose qu'il n'y a que des caractères alphabétiques. Exemple d'anagramme : "minuterie" et "mutinerie".

Mon raisonnement est le suivant: si les deux mots n'ont pas la même longueur, le problème est déjà réglé. En revanche, s'ils ont la même longueur, il faut vérifier leurs caractères. C'est là que je fais appel à vous car il me manque une connaissance technique : comment découper un mot en lettres (et si possible, sous forme de liste)? 

Par exemple, je sais que si je fais print("corbeau"[1:2]) je vais obtenir en réponse la deuxième lettre qui est un "o". Mais il existe sûrement une autre commande qui va me permettre d'avoir de suite ["c", "o", "r", "b", "e", "a", "u"]  Ensuite il ne reste plus qu'à faire "ma_liste.sort" pour ranger ces lettres dans l'ordre, et comparer les deux listes correspondant aux deux mots.

Merci pour vos suggestions.

Ton algo est une bonne idée (trier les caractères et comparer les listes), mais ta méthode pour passer d'une chaîne à une liste est bancale.

list est une classe dont le constructeur prend n'importe quel itérable. Une chaîne de caractères est un itérable.

>>> list('corbeau')
['c', 'o', 'r', 'b', 'e', 'a', 'u']

Pour info, tu as aussi la fonction builtin sorted, qui prend un itérable et retourne une liste triée de ses éléments :

>>> sorted('corbeau')
['a', 'b', 'c', 'e', 'o', 'r', 'u']

La méthode sort des listes et la fonction intégrée sorted font la même chose: trier les éléments. La GROSSE différence c'est que sort ne s'applique que pour des objets de type list, alors que sorted (comme l'a dit entwanne) s'applique sur n'importe quel itérable.

Donc si de base ton objet n'est pas une liste, c'est sorted qu'il faut utiliser. Ainsi au lieu d'effectuer 2 étapes explicitement (transformation en liste et trie), tu n'en fait plus qu'une .

PS: Néanmoins il est TRÈS intéressant de voir l'utilisation de list, qui est un exemple de conversion de type (on dit aussi caster un objet, il me semble). Bref, pour généraliser:

#J'ai un entier
ent = 3

#Je le convertis en flottant
flo = float(ent)

#Je le convertis en chaîne
chn = str(ent)


#J'ai une chaine
chn = "1234"

#Je la convertis en tuple
tup = tuple(chn)

#Je la convertis en liste
lst = list(chn)

Mais attention, pour les chaînes la réciproque n'est pas vraie:

#J'ai une liste
lst = [1, 2, 3]

#Ça va me convertir EXPLICITEMENT la liste en chaîne
chn = str(lst)
print(chn)  #Ce qu'on ne veut pas généralement

Pour ce faire, il faut utiliser la méthode join. Méthode que tu as vu dans le précédent post:

#Ma liste
lst = ["A", "B", "C", "D"]

#Conversion en chn
chn = "".join(lst)

#Autre conversion fantaisiste
autre_chn = "-!-".join(lst)

La contrainte, c'est que les éléments de la liste doivent OBLIGATOIREMENT être des chaînes de caractères 

-
Edité par Olygrim 25 février 2016 à 10:02:35

Merci Olygrim.

Voici la version définitive.

def test_for_anagrams(my_string1, my_string2):
    

    if len(my_string1)!= len(my_string2):
        return False
    if len(my_string1)== len(my_string2):
        string1=my_string1.lower()
        string2=my_string2.lower()
        if sorted(string1)==sorted(string2):
            return True
        else:
            return False

Plusieurs choses inutiles dans ton code :

• ligne 6, la condition est forcément vraie, donc pas besoin de la répéter ;
• tu peux simplifier les lignes 9 à 12 par un return sorted(string1) == sorted(string2, bien plus clair.

1. Inutile de comparer les longueurs des chaînes, étant donné les arguments attendus, des petites chaînes, le gain de temps est trop infime pour qu'il y aie un réel intérêt. Comparer uniquement les chaînes formatées (minuscule) et triées suffit amplement.
2. Comme le dit entwanne, tu peux directement retourner le résultat d'une expression logique, par exemple : return 0 < n < 10 and n != 5

En considérant cela comme acquis, tu dois pouvoir comprendre ces 2 lignes :

def is_anagram(word1, word2):
   return sorted(word1.lower()) == sorted(word2.lower())