Discussion :

[teddyfresnes]

Bien le bonjour,

Depuis hier soir j'ai un problème sur un programme que j'essaye de faire, à l'intérieur il y a plusieurs fonctions :
- Une fonction qui répertorient les lettres d'un mot dans un dictionnaire
- Une fonction qui répertories les mots d'un texte dans un dictionnaire
- Une fonction qui utilise les 2 fonctions précédentes pour répertorier les lettres d'un texte
- La fonction trouveLangue qui détermine la langue d'un texte
- Une fonction optionnel qui demande de rentrer un texte et exécute la fonction trouveLangue
Je n'arrive pas à faire la fonction trouveLangue, voici le code entier : (j'ai marqué la fonction en question)

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
formatListe = ['a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j', 'k', 'l', 'm', 'n', 'o', 'p', 'q', 'r', 's', 't', 'u', 'v', 'w', 'x', 'y', 'z', 'à', 'â', 'á', 'å', 'ä', 'ã', 'a', 'æ', 'œ', 'ç', 'c', 'c', 'c', 'd', 'ð', 'è', 'é', 'ê', 'ë', 'e', 'e', 'g', 'g', 'h', 'î', 'ì', 'í', 'ï', 'i', 'j', 'l', 'ñ', 'n', 'n', 'ò', 'ö', 'ô', 'ó', 'õ', 'ø', 'r', 's', 's', 's', 'š', 'ß', 't', 'þ', 'ù', 'ú', 'û', 'u', 'ü', 'u', 'ý', 'z', 'z', 'ž']
pourcentagesLettres = {'Anglais': [8.167, 1.492, 2.782, 4.253, 12.702, 2.228, 2.015, 6.094, 6.966, 0.153, 0.772, 4.025, 2.406, 6.749, 7.507, 1.929, 0.095, 5.987, 6.327, 9.056, 2.758, 0.978, 2.360, 0.150, 1.974, 0.074, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
 'Français': [7.636, 0.901, 3.260, 3.669, 14.715, 1.066, 0.866, 0.737, 7.529, 0.613, 0.074, 5.456, 2.968, 7.095, 5.796, 2.521, 1.362, 6.693, 7.948, 7.244, 6.311, 1.838, 0.049, 0.427, 0.128, 0.326, 0.486, 0.051, 0, 0, 0, 0, 0, 0, 0.018, 0.085, 0, 0, 0, 0, 0, 0.271, 1.504, 0.218, 0.008, 0, 0, 0, 0, 0, 0.045, 0, 0, 0.005, 0, 0, 0, 0, 0, 0, 0, 0, 0.023, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0.058, 0, 0.060, 0, 0, 0, 0, 0, 0, 0], 
 'Allemand': [6.516, 1.886, 2.732, 5.076, 16.396, 1.656, 3.009, 4.577, 6.550, 0.268, 1.417, 3.437, 2.534, 9.776, 2.594, 0.670, 0.018, 7.003, 7.270, 6.154, 4.166, 0.846, 1.921, 0.034, 0.039, 1.134, 0, 0, 0, 0, 0.578, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0.443, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0.307, 0, 0, 0, 0, 0, 0, 0.995, 0, 0, 0, 0, 0], 
 'Espagnol': [11.525, 2.215, 4.019, 5.010, 12.181, 0.692, 1.768, 0.703, 6.247, 0.493, 0.011, 4.967, 3.157, 6.712, 8.683, 2.510, 0.877, 6.871, 7.977, 4.632, 2.927, 1.138, 0.017, 0.215, 1.008, 0.467, 0, 0, 0.502, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0.433, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0.725, 0, 0, 0, 0, 0.311, 0, 0, 0, 0, 0, 0.827, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0.168, 0, 0, 0.012, 0, 0, 0, 0, 0], 
 'Portuguais': [14.634, 1.043, 3.882, 4.992, 12.570, 1.023, 1.303, 0.781, 6.186, 0.397, 0.015, 2.779, 4.738, 4.446, 9.735, 2.523, 1.204, 6.530, 6.805, 4.336, 3.639, 1.575, 0.037, 0.253, 0.006, 0.470, 0.072, 0.562, 0.118, 0, 0, 0.733, 0, 0, 0, 0.530, 0, 0, 0, 0, 0, 0, 0.337, 0.450, 0, 0, 0, 0, 0, 0, 0, 0, 0.132, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0.635, 0.296, 0.040, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0.207, 0, 0, 0.026, 0, 0, 0, 0, 0], 
 'Espéranto': [12.117, 0.980, 0.776, 3.044, 8.995, 1.037, 1.171, 0.384, 10.012, 3.501, 4.163, 6.104, 2.994, 7.955, 8.779, 2.755, 0, 5.914, 6.092, 5.276, 3.183, 1.904, 0, 0, 0, 0.494, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0.657, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0.691, 0, 0.022, 0, 0, 0, 0, 0, 0.055, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0.385, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0.520, 0, 0, 0, 0, 0, 0], 
 'Italien': [11.745, 0.927, 4.501, 3.736, 11.792, 1.153, 1.644, 0.636, 10.143, 0.011, 0.009, 6.510, 2.512, 6.883, 9.832, 3.056, 0.505, 6.367, 4.981, 5.623, 3.011, 2.097, 0.033, 0.003, 0.020, 1.181, 0.635, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0.263, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0.030, 0.030, 0, 0, 0, 0, 0, 0, 0, 0.002, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, (0.166), 0.166, 0, 0, 0, 0, 0, 0, 0, 0], 
 'Turc': [11.920, 2.844, 0.963, 4.706, 8.912, 0.461, 1.253, 1.212, 8.600, 0.034, 4.683, 5.922, 3.752, 7.487, 2.476, 0.886, 0, 6.722, 3.014, 3.314, 3.235, 0.959, 0, 0, 3.336, 1.500, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1.156, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1.125, 0, 0, 0, 0, 0, 5.114, 0, 0, 0, 0, 0, 0, 0.777, 0, 0, 0, 0, 0, 0, 1.780, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1.854, 0, 0, 0, 0, 0], 
 'Suédois': [9.383, 1.535, 1.486, 4.702, 10.149, 2.027, 2.862, 2.090, 5.817, 0.614, 3.140, 5.275, 3.471, 8.542, 4.482, 1.839, 0.020, 8.431, 6.590, 7.691, 1.919, 2.415, 0.142, 0.159, 0.708, 0.070, 0, 0, 0, 1.338, 1.797, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1.305, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], 
 'Polonais': [8.910, 1.470, 3.960, 3.250, 7.660, 0.300, 1.420, 1.080, 8.210, 2.280, 3.510, 2.100, 2.800, 5.520, 7.750, 3.130, 0.140, 4.690, 4.320, 3.980, 2.500, 0.040, 4.650, 0.020, 3.760, 5.640, 0, 0, 0, 0, 0, 0, 0.990, 0, 0, 0, 0, 0.400, 0, 0, 0, 0, 0, 0, 0, 1.110, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1.820, 0, 0.200, 0, 0, 0, 0, 0.850, 0, 0, 0, 0, 0, 0.660, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0.060, 0.830, 0], 
 'Néerlandais': [7.486, 1.584, 1.242, 5.933, 18.91, 0.805, 3.403, 2.380, 6.499, 1.46, 2.248, 3.568, 2.213, 10.032, 6.063, 1.57, 0.009, 6.411, 3.73, 6.79, 1.99, 2.85, 1.52, 0.036, 0.035, 1.39, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], 
 'Danois': [6.025, 2.000, 0.565, 5.858, 15.453, 2.406, 4.077, 1.621, 6.000, 0.730, 3.395, 5.229, 3.237, 7.240, 4.636, 1.756, 0.007, 8.956, 5.805, 6.862, 1.979, 2.332, 0.069, 0.028, 0.698, 0.034, 0, 0, 0, 1.190, 0, 0, 0, 0.872, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0.939, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], 
 'Islandais': [10.110, 1.043, 0, 1.575, 6.418, 3.013, 4.241, 1.871, 7.578, 1.144, 3.314, 4.532, 4.041, 7.711, 2.166, 0.789, 0, 8.581, 5.630, 4.953, 4.562, 2.437, 0, 0.046, 0.900, 0, 0, 0, 1.799, 0, 0, 0, 0, 0.867, 0, 0, 0, 0, 0, 0, 4.393, 0, 0.647, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1.570, 0, 0, 0, 0, 0, 0, 0, 0, 0.777, 0, 0.994, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1.455, 0, 0.613, 0, 0, 0, 0, 0.228, 0, 0, 0], 
 'Finlandais': [12.217, 0.281, 0.281, 1.043, 7.968, 0.194, 0.392, 1.851, 10.817, 2.042, 4.973, 5.761, 3.202, 8.826, 5.614, 1.842, 0.013, 2.872, 7.862, 8.750, 5.008, 2.250, 0.094, 0.031, 1.745, 0.051, 0, 0, 0, 0.003, 3.577, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0.444, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], 
 'Tchèque': [8.421, 0.822, 0.740, 3.475, 7.562, 0.084, 0.092, 1.356, 6.073, 1.433, 2.894, 3.802, 2.446, 6.468, 6.695, 1.906, 0.001, 4.799, 5.212, 5.727, 2.160, 5.344, 0.016, 0.027, 1.043, 1.599, 0, 0, 0.867, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0.462, 0.015, 0, 0, 0.633, 0, 0, 0, 1.222, 0, 0, 0, 0, 0, 1.643, 0, 0, 0, 0, 0, 0, 0.007, 0, 0, 0, 0.024, 0, 0, 0.380, 0, 0, 0, 0.688, 0, 0.006, 0, 0, 0.045, 0, 0, 0, 0.204, 0.995, 0, 0, 0.721]}
 
def lettre_dans_mot(mot): # Trouve les lettres dans un mot
    global dictlettre
    dictlettre = {}
    for lettre in mot: # Pour chaque lettres dans le mot
        if lettre in dictlettre: # Si la lettre est déjà dans le dictio
            dictlettre[lettre] += 1 # Indenter 1 le nombre de lettre trouver
        else: # Sinon
            dictlettre[lettre] = 1 # Ajouter la lettre au dictio et mettre à 1 la valeur trouver
    return(dictlettre) # retourne le dictionnaire de lettre
 
def mot_dans_txt(txt): # Trouve les mots dans un texte
    global dictmot
    dictmot = {}
    ponctu = ["-", ",", ":", "'", "’", ".", "!", "?", "(", ")", "/", "\n", "\\"] # Liste des ponctuations a supprimer lors de la séparation des mots
    for i in ponctu: # Pour tout les éléments de la ponctuation
        txt = txt.replace(i, " ") # Supprimer cet élément
    txt = txt.lower() # Convertit les majuscules en minuscules 
    txt = txt.split() # sépare les mots entre les espaces
    for mot in txt: # pour chaque mot dans le texte
        if mot in dictmot: # Si le mot est déjà dans le dictio
            dictmot[mot] +=1 # indenter 1 le nombre de mot trouver
        else: # sinon
            dictmot[mot] = 1 # ajouter le mot au dictio et mettre à 1 la valeur trouver
    return(dictmot) # retourne le dictionnaire de mots
 
def lettre_dans_txt(txt): # repertorie l'ensemble des lettres d'un texte
    global dictlettres
    dictlettres = {}
    for mot in mot_dans_txt(txt): # pour chaque mot trouvé dans le dictionnaire
        for lettre in lettre_dans_mot(mot): # pour chaque lettre trouvé dans le dictionnaire
            if lettre in dictlettres: # Si la lettre est déjà dans le dictio
                dictlettres[lettre] += 1 # Indenter 1 le nombre de lettre trouver
            else: # Sinon
                dictlettres[lettre] = 1 # Ajouter la lettre au dictio et mettre à 1 la valeur trouver
    return(dictlettres)
 
"""THE PROBLEM IS HERE ============================================================"""
def trouveLangue(txt): # Essaye de déterminer la langue par le nombre de lettres et en fonction des accents
    resultatsPourcentage = {'Anglais': 0, 'Français': 0, 'Allemand': 0, 'Espagnol': 0, 'Portuguais': 0, 'Espéranto': 0, 'Italien': 0, 'Turc': 0, 'Suédois': 0, 'Polonais': 0, 'Néerlandais': 0, 'Danois': 0, 'Islandais': 0, 'Finlandais': 0, 'Tchèque': 0}          
 
"""============================================================"""
    print(resultatsPourcentage)
 
def startIt():
    global texte
    choice = str(input("""* Bienvenue dans le script trouveLangue, un programme qui vous permet de déterminer la langue de votre texte parmis celles ci :
        - Anglais
        - Français
        - Allemand
        - Espagnol
        - Portuguais
        - Espéranto
        - Italien
        - Turc
        - Suédois
        - Polonais
        - Néerlandais
        - Danois
        - Islandais
        - Finlandais
        - Tchèque
    Voulez entrer votre texte via Python où l'importer via un fichier texte ?
        [1] Entrée manuelle
        [2] Importer un fichier\n"""))
    if choice == '1': # Choix 1 écrire le texte dans python
        texte = str(input("Entrez votre texte :\n====================\n"))
        print(texte)
    elif choice == '2': # Choix 2 importer un fichier possédant un texte
        file = str(input("Entrez le nom du fichier texte contenant votre texte (avec l'extension) :\n=========================================================================\n"))
        with open(file, "r", encoding='utf-8') as file:
            texte = file.read()
        print(texte)
    trouveLangue(texte) # Début de la fonction trouveLangue
 
startIt()

J'ai essayé plein de trucs foireux mais rien ne fonctionne pour l'instant en voici un extrait (inutile)

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
 
    for k in pourcentagesLettres.values(): # pour chaque liste du dico de pourcentages
        for l in resultatsPourcentage.values(): # pour chaque valeur du dico final
            for i,j in lettre_dans_txt(txt).items(): # pour clé/valeur de la liste de lettre
                locationIt = formatListe.index(i) # trouver la localisation de la lettre
                print(i,j,k[locationIt])
                l = float(j * (k[locationIt]))
                print(l)
 
    for i,j in lettre_dans_txt(txt).items(): # pour clé/valeur de la liste de lettre
        locationIt = formatListe.index(i) # trouver la localisation de la lettre
        for k in pourcentagesLettres.values(): # pour chaque liste du dico de pourcentages
            for l in resultatsPourcentage.values():
                print(i,j,k[locationIt])
                l = float(1 * j) * (k[locationIt])
                print(l)       
 
 
    for k in pourcentagesLettres.values(): # Pour chaque liste dans dans le dico
        for i, j in lettre_dans_txt(txt).items(): # pour chaque clé/valeur trouvé dans le dictionnaire
            findIt = formatListe.index(i) # Trouve l'emplacement de la lettre dans le dico de liste 
            for l in resultatsPourcentage.values():
                l = 1
                print(l,j,k[findIt],k)
                l *= j * k[findIt]
                print(l)

En gros ce que je dois réussir à faire c'est utiliser les pourcentages de lettres au début du programme, et de calculer le pourcentage des lettres (pourcentage * nombre de lettres / 100) en fonction de chaque langue, et d'ainsi avec les prochaines fusionner les résultats pour en faire une moyenne pour le dictionnaire resultatsPourcentage pour chaque langue. Je ne sais pas si je m'explique bien pour tout vous dire je suis un peu fatigué
Peut-être est ce quelque chose de facile mais je suis toujours un gros débutant dans python :p Si quelqu'un a le courage de m'aider et de me donner des conseils, quelles boucles à utiliser, je le remercie d'avance.

Bonne journée !

[Sve@r]

Bonjour

Je n'arrive pas à faire la fonction trouveLangue. J'ai essayé plein de trucs foireux mais rien ne fonctionne pour l'instant. Peut-être est ce quelque chose de facile mais je suis toujours un gros débutant dans python

Alors avant de penser à Python, il faut déjà savoir si tu arrives à trouver ton résultat avec un simple papier et un crayon. Par exemple d'après ta liste, en français il y a 7,636% de "a" et 0,901% de "b" et en allemand il y a 6.516% de "a" et 1.886% de "b". Mais que se passe-t-il si tu trouves un texte avec 7,6% de "a" et 1,8% de "b" ? Ou pire 7,0% de "a" et 1,3% de "b" ???
Une fois que tu auras trouvé l'algorithme qui répond à ce genre de question, tu pourras le coder en Python et en plus ça te semblera même assez "naturel" même si tu débutes et que ton code reste encore très "académique" parce que tu n'as pas encore certains réflexes Python. Par exemple au lieu de regarder si la lettre est dans le dico si oui incrémenter la valeur sinon mettre 1 tu peux utiliser setdefaut...

Code python :

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

1
2
for lettre in mot:
        dictlettre[lettre]=dictlettre.setdefault(lettre, 0) + 1

... mais ça ce n'est pas le plus important (ça viendra tout seul).

Sinon c'est bien d'offrir l'entrée sur saisie ou sur fichier, mais ensuite il vaut mieux dédier des fonctions spécialement faites pour ce type de saisie et appeler la fonction associée au choix de l'utilisateur. Ca te permettra demain de faire évoluer facilement ton code (rajouter par exemple un texte provenant d'une bdd, ...)

[teddyfresnes]

Hey,

Je ne connaissais pas .setdefault() je viens de regarder c'est vrai que c'est beaucoup plus optimisé, je suis preneur pour ce genre de conseil, après c'est parce que je ne connaissais pas trop la syntaxe

Concernant la fonction startIt je la modifierais mais ce n'est pas urgent, je ne compte pas améliorer ce programme (c'est un exercice).

J'ai voulu écrire l'algorithme à utiliser sur papier mais comme je l'ai dit je m'avoue un peu perdue de comment procéder, après je ne comprend pas le problème que tu me dis, le nombre de lettres trouvé dans le texte ne sera pas un pourcentage, en fait imaginons que j'ai 27 "a", alors le programme calculera un ratio à partir de ceux contenu dans la variable pourcentagesLettres, ainsi pour l'anglais ce serait 27*8.167/100 = 2.20, puis le ratio de b si il y en 3 sera 3*0.901/100 = 0.02703, il faudra alors combiner a et b (et les prochaines lettres) en faisant 2.20 * 0.2703 * ratio de c * ratio de d ect ect.

Lorsque toutes les langues auront un ratio total calculé, j'aurais voulu prendre la moyenne de toutes ses valeurs et les mettre en pourcentage afin de faire un classement de probabilités des langues les plus récurrentes.

[Sve@r]

après je ne comprend pas le problème que tu me dis, le nombre de lettres trouvé dans le texte ne sera pas un pourcentage, en fait imaginons que j'ai 27 "a", alors le programme calculera un ratio à partir de ceux contenu dans la variable pourcentagesLettres, ainsi pour l'anglais ce serait 27*8.167/100 = 2.20, puis le ratio de b si il y en 3 sera 3*0.901/100 = 0.02703

Ben d'après ton premier post, ton but est de trouver la langue d'un texte. Cela signifie que tu as un texte mais tu ne connais pas sa langue. Donc tu ne peux pas appliquer le pourcentage "français" puisque tu ne sais pas encore si le texte est français.

Donc comment tu fais pour savoir si le texte est français ? Evidemment si dans ton texte tu as 7.36% de "a" et 0.901 de "b" ça va bien car ça correspond pile poil aux pourcentages de "a" et de "b" en français. Si tu as 7.34% de "a" et 0.88% de "b" ça va encore car c'est toujours super proche des pourcentages officiels. Mais si tu as 7.6% de "a" (proche de la valeur française des "a") et 1.8% de "b" (proche de la valeur allemande des "b") comment tu choisis entre français ou allemand ?

Ou alors (prenons ta façon de voir) tu as 27 "a" et 3 "b". Tu vas alors calculer selon les pourcentages français (7.636 * 27 / 100 = 2.06 "a" ; 0.901 * 3 / 100 = 0.027 "b") puis selon les pourcentages allemands (6.516 * 27 / 100 = 1.76 "a" ; 1.886 * 3 / 100 = 0.057 "b"). Et après ? Que veulent dire ces chiffres et comment vont-ils t'aider à choisir entre français ou allemand ???

Donc voici comment je procèderais

1. je commence par ranger les lettres dans l'ordre décroissant de chaque langue. Cela forme un mot de 26 lettres qui change selon la langue. En français, c'est "esantiruloc". En allemand c'est (exemple) "abehrt" et etc etc.
2. je range les lettres du texte dans l'ordre décroissant de leur fréquence. Cela forme aussi un mot de 26 lettres
3. je calcule la distance de Hamming entre le mot du texte et chaque mot de toutes les langues. La distance de Hamming entre deux mots de même longueur est le nombre d'endroits où les lettres sont différentes. La langue qui aura la distance la moins longue sera la langue probable du texte

[teddyfresnes]

Donc comment tu fais pour savoir si le texte est français ?

Je m'explique mal, comme tu peux le voir dans mon script il y a un dictionnaire

Code :

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

resultatsPourcentage = {'Anglais': 0, 'Français': 0, 'Allemand': 0, 'Espagnol': 0, 'Portuguais': 0, 'Espéranto': 0, 'Italien': 0, 'Turc': 0, 'Suédois': 0, 'Polonais': 0, 'Néerlandais': 0, 'Danois': 0, 'Islandais': 0, 'Finlandais': 0, 'Tchèque': 0}

qui répertorie le ratio de chaque langue

L'objectif serait d'utiliser la méthode que j'ai écrit en haut pour avoir un ratio pour chaque langues, pour simplifier imaginons qu'on entre ce texte dans la fonction langue :

"aaaaabaaaaaaabaaaaaaabaaaaaaa"

On aurait seulement les lettres a = 27 et b = 3 et pour simplifier aussi, faisons comme si nous avions que les pourcentages des langues anglais, français, et allemand dans le dictionnaire pourcentagesLettres, jusque là leurs ratios serait : (nombre de lettres * pourcentage de la lettre dans la langue / 100)

anglais : a = 27*8.167/100 = 2.20 b = 3*1.492/100 = 0.04476 produits des ratios des lettres = 2.20*0.04476 = 0.098472
français : a = 27*7.636/100 = 2.06172 b = 3*0.901/100 = 0.02703 produits des ratios des lettres = 2.06172*0.02703 = 0.055728
allemand : a = 27*6.516/100 = 1.75932 b = 3*1.886/100 = 0.05658 produits des ratios des lettres = 1.75932*0.05658 = 0.099542

Et après ? Que veulent dire ces chiffres et comment vont-ils t'aider à choisir entre français ou allemand ???

On a calculer pour chacun des langages le ratio d'apparition des lettres de la langue en fonction du nombre de lettres dans le texte

Si on convertit ces ratios totales en pourcentage :

0.098472 + 0.055728 + 0.099542 = 0.253742

anglais = 0.098472 / 0.254812 = 0.3880
français = 0.055728 / 0.254812 = 0.2187
allemand = 0.099542 / 0.254812 = 0.3906

Il y aurait donc 38,8% chance que le texte soit anglais, 21,87% que le texte soit français et 39.06% que le texte soit allemand !

Bien sur avec cet exemple ça ne sert à rien mais avec des vrais mots, un vrai texte le programme serait capable de déterminer la langue.

Peut-être que les opérations que j'ai fait ne sont pas exactes et ne veulent rien dire si c'est le cas je suis totalement perdu, sinon le problème reste le même je trouve ça compliqué et je n'arrive pas à créer l'algorithme qui fera le calcul avec toutes les langues et n'importe quel lettres présente dans la variable liste formatListe

J'espère que tu as compris ma méthodologie (pas forcément judicieuse)

PS : Je viens de LEGEREMENT comprendre ce que tu me m'as proposer c'est badasse comme technique, je pourrais aussi essayer

[Sve@r]

On aurait seulement les lettres a = 27 et b = 3 et pour simplifier aussi, faisons comme si nous avions que les pourcentages des langues anglais, français, et allemand dans le dictionnaire pourcentagesLettres, jusque là leurs ratios serait : (nombre de lettres * pourcentage de la lettre dans la langue / 100)

anglais : a = 27*8.167/100 = 2.20 b = 3*1.492/100 = 0.04476 produits des ratios des lettres = 2.20*0.04476 = 0.098472
français : a = 27*7.636/100 = 2.06172 b = 3*0.901/100 = 0.02703 produits des ratios des lettres = 2.06172*0.02703 = 0.055728
allemand : a = 27*6.516/100 = 1.75932 b = 3*1.886/100 = 0.05658 produits des ratios des lettres = 1.75932*0.05658 = 0.099542

On a calculer pour chacun des langages le ratio d'apparition des lettres de la langue en fonction du nombre de lettres dans le texte

Mouais. Je pige le calcul mais je suis dubitatif sur la pertinence du résulat final. Tu as juste multiplié le nb de "a" par son pourcentage dans une langue X, et multiplié ce résultat par la même chose pour "b". Bref tu ne fais que des multiplications en série quoi.

Si on convertit ces ratios totales en pourcentage :
0.098472 + 0.055728 + 0.099542 = 0.253742

Donc là tu additionnes le total français+anglais+allemand...

anglais = 0.098472 / 0.254812 = 0.3880
français = 0.055728 / 0.254812 = 0.2187
allemand = 0.099542 / 0.254812 = 0.3906
Il y aurait donc 38,8% chance que le texte soit anglais, 21,87% que le texte soit français et 39.06% que le texte soit allemand !

Il me semble que tu as allègrement multiplié des pommes et des poires pour trouver le prix au kg de la compote.

Essayons tes calculs avec un vrai (simué) texte français. Ce texte contiendra 120 "e", 110 "s" et 2 "z" (la proportion du français est "e" puis "s" et "z" vient probablement très loin derrière). D'ailleurs on va dire pour l'exemple que la proportion générale française est de 42% "e", 39% "s" et 1% "z".
Et opposons-le au serbe où les proportions seront de 12% "e", 14% "s" et 44% "z".

Français: 120 * 42/100 * 110 * 39/100 * 2 * 1 / 100 = 43,24
Serbe: 120 * 12/100 * 110 * 14 / 100 * 2 * 44 / 100 = 195.15

Déjà ça sent pas bon car le total serbe est plus élevé que le total français. Mais continuons... Donc ensuite on les additionne: 43.24+195.15 = 238.39
Puis le français: 43.24 / 238.39 = 18%
Et le serbe: 195.15 / 238.39 = 82%
Et donc un texte français a 18% de chances de d'être français face à 82% de chances d'être serbe...

Peut-être que les opérations que j'ai fait ne sont pas exactes et ne veulent rien dire

Ben à un moment donné, je pense qu'il faut faire intervenir le nombre de chaque lettre par rapport au nombre total de lettres, choses que tu n'as jamais faite. Dans mon exemple, avec 120 "e", 110 "s" et 2 "z", la proportion est de 51,72% de "e" ce qui est plus proche des 42% de "e" en français que du 12% de "e" en serbe...

Je viens de LEGEREMENT comprendre ce que tu me m'as proposer c'est badasse comme technique, je pourrais aussi essayer

En plus je pensais qu'il allait falloir se taper la recherche des lettres mais non, on peut utiliser les pourcentages pour "générer" les mots.
Exemple

Code python :

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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
pourcentagesLettres = {
	'Anglais': (8.167, 1.492, 2.782, 4.253, 12.702, 2.228, 2.015, 6.094, 6.966, 0.153, 0.772, 4.025, 2.406, 6.749, 7.507, 1.929, 0.095, 5.987, 6.327, 9.056, 2.758, 0.978, 2.360, 0.150, 1.974, 0.074, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0),
	'Français': (7.636, 0.901, 3.260, 3.669, 14.715, 1.066, 0.866, 0.737, 7.529, 0.613, 0.074, 5.456, 2.968, 7.095, 5.796, 2.521, 1.362, 6.693, 7.948, 7.244, 6.311, 1.838, 0.049, 0.427, 0.128, 0.326, 0.486, 0.051, 0, 0, 0, 0, 0, 0, 0.018, 0.085, 0, 0, 0, 0, 0, 0.271, 1.504, 0.218, 0.008, 0, 0, 0, 0, 0, 0.045, 0, 0, 0.005, 0, 0, 0, 0, 0, 0, 0, 0, 0.023, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0.058, 0, 0.060, 0, 0, 0, 0, 0, 0, 0), 
	'Allemand': (6.516, 1.886, 2.732, 5.076, 16.396, 1.656, 3.009, 4.577, 6.550, 0.268, 1.417, 3.437, 2.534, 9.776, 2.594, 0.670, 0.018, 7.003, 7.270, 6.154, 4.166, 0.846, 1.921, 0.034, 0.039, 1.134, 0, 0, 0, 0, 0.578, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0.443, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0.307, 0, 0, 0, 0, 0, 0, 0.995, 0, 0, 0, 0, 0), 
	'Espagnol': (11.525, 2.215, 4.019, 5.010, 12.181, 0.692, 1.768, 0.703, 6.247, 0.493, 0.011, 4.967, 3.157, 6.712, 8.683, 2.510, 0.877, 6.871, 7.977, 4.632, 2.927, 1.138, 0.017, 0.215, 1.008, 0.467, 0, 0, 0.502, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0.433, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0.725, 0, 0, 0, 0, 0.311, 0, 0, 0, 0, 0, 0.827, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0.168, 0, 0, 0.012, 0, 0, 0, 0, 0), 
	'Portuguais': (14.634, 1.043, 3.882, 4.992, 12.570, 1.023, 1.303, 0.781, 6.186, 0.397, 0.015, 2.779, 4.738, 4.446, 9.735, 2.523, 1.204, 6.530, 6.805, 4.336, 3.639, 1.575, 0.037, 0.253, 0.006, 0.470, 0.072, 0.562, 0.118, 0, 0, 0.733, 0, 0, 0, 0.530, 0, 0, 0, 0, 0, 0, 0.337, 0.450, 0, 0, 0, 0, 0, 0, 0, 0, 0.132, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0.635, 0.296, 0.040, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0.207, 0, 0, 0.026, 0, 0, 0, 0, 0), 
	'Espéranto': (12.117, 0.980, 0.776, 3.044, 8.995, 1.037, 1.171, 0.384, 10.012, 3.501, 4.163, 6.104, 2.994, 7.955, 8.779, 2.755, 0, 5.914, 6.092, 5.276, 3.183, 1.904, 0, 0, 0, 0.494, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0.657, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0.691, 0, 0.022, 0, 0, 0, 0, 0, 0.055, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0.385, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0.520, 0, 0, 0, 0, 0, 0), 
	'Italien': (11.745, 0.927, 4.501, 3.736, 11.792, 1.153, 1.644, 0.636, 10.143, 0.011, 0.009, 6.510, 2.512, 6.883, 9.832, 3.056, 0.505, 6.367, 4.981, 5.623, 3.011, 2.097, 0.033, 0.003, 0.020, 1.181, 0.635, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0.263, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0.030, 0.030, 0, 0, 0, 0, 0, 0, 0, 0.002, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, (0.166), 0.166, 0, 0, 0, 0, 0, 0, 0, 0), 
	'Turc': (11.920, 2.844, 0.963, 4.706, 8.912, 0.461, 1.253, 1.212, 8.600, 0.034, 4.683, 5.922, 3.752, 7.487, 2.476, 0.886, 0, 6.722, 3.014, 3.314, 3.235, 0.959, 0, 0, 3.336, 1.500, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1.156, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1.125, 0, 0, 0, 0, 0, 5.114, 0, 0, 0, 0, 0, 0, 0.777, 0, 0, 0, 0, 0, 0, 1.780, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1.854, 0, 0, 0, 0, 0), 
	'Suédois': (9.383, 1.535, 1.486, 4.702, 10.149, 2.027, 2.862, 2.090, 5.817, 0.614, 3.140, 5.275, 3.471, 8.542, 4.482, 1.839, 0.020, 8.431, 6.590, 7.691, 1.919, 2.415, 0.142, 0.159, 0.708, 0.070, 0, 0, 0, 1.338, 1.797, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1.305, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0), 
	'Polonais': (8.910, 1.470, 3.960, 3.250, 7.660, 0.300, 1.420, 1.080, 8.210, 2.280, 3.510, 2.100, 2.800, 5.520, 7.750, 3.130, 0.140, 4.690, 4.320, 3.980, 2.500, 0.040, 4.650, 0.020, 3.760, 5.640, 0, 0, 0, 0, 0, 0, 0.990, 0, 0, 0, 0, 0.400, 0, 0, 0, 0, 0, 0, 0, 1.110, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1.820, 0, 0.200, 0, 0, 0, 0, 0.850, 0, 0, 0, 0, 0, 0.660, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0.060, 0.830, 0), 
	'Néerlandais': (7.486, 1.584, 1.242, 5.933, 18.91, 0.805, 3.403, 2.380, 6.499, 1.46, 2.248, 3.568, 2.213, 10.032, 6.063, 1.57, 0.009, 6.411, 3.73, 6.79, 1.99, 2.85, 1.52, 0.036, 0.035, 1.39, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0), 
	'Danois': (6.025, 2.000, 0.565, 5.858, 15.453, 2.406, 4.077, 1.621, 6.000, 0.730, 3.395, 5.229, 3.237, 7.240, 4.636, 1.756, 0.007, 8.956, 5.805, 6.862, 1.979, 2.332, 0.069, 0.028, 0.698, 0.034, 0, 0, 0, 1.190, 0, 0, 0, 0.872, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0.939, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0), 
	'Islandais': (10.110, 1.043, 0, 1.575, 6.418, 3.013, 4.241, 1.871, 7.578, 1.144, 3.314, 4.532, 4.041, 7.711, 2.166, 0.789, 0, 8.581, 5.630, 4.953, 4.562, 2.437, 0, 0.046, 0.900, 0, 0, 0, 1.799, 0, 0, 0, 0, 0.867, 0, 0, 0, 0, 0, 0, 4.393, 0, 0.647, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1.570, 0, 0, 0, 0, 0, 0, 0, 0, 0.777, 0, 0.994, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1.455, 0, 0.613, 0, 0, 0, 0, 0.228, 0, 0, 0), 
	'Finlandais': (12.217, 0.281, 0.281, 1.043, 7.968, 0.194, 0.392, 1.851, 10.817, 2.042, 4.973, 5.761, 3.202, 8.826, 5.614, 1.842, 0.013, 2.872, 7.862, 8.750, 5.008, 2.250, 0.094, 0.031, 1.745, 0.051, 0, 0, 0, 0.003, 3.577, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0.444, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0), 
	'Tchèque': (8.421, 0.822, 0.740, 3.475, 7.562, 0.084, 0.092, 1.356, 6.073, 1.433, 2.894, 3.802, 2.446, 6.468, 6.695, 1.906, 0.001, 4.799, 5.212, 5.727, 2.160, 5.344, 0.016, 0.027, 1.043, 1.599, 0, 0, 0.867, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0.462, 0.015, 0, 0, 0.633, 0, 0, 0, 1.222, 0, 0, 0, 0, 0, 1.643, 0, 0, 0, 0, 0, 0, 0.007, 0, 0, 0, 0.024, 0, 0, 0.380, 0, 0, 0, 0.688, 0, 0.006, 0, 0, 0.045, 0, 0, 0, 0.204, 0.995, 0, 0, 0.721),
}
 
# Génération en utilisant une liste en intension (méthodologie avancée Python)
mots_langue=dict(
	(
		k,
		"".join(
			x for (x, y) in sorted(
				zip("abcdefghijklmnopqrstuvwxyz", v),
				key=lambda elem: elem[1],
				reverse=True,
			)
		),
	) for (k, v) in pourcentagesLettres.items()
)
 
# La même chose en utilisant un algo plus classique
mots_langue=dict()
for (k, v) in pourcentagesLettres.items():
	mots_langue[k]="".join(
		x for (x, y) in sorted(
			zip("abcdefghijklmnopqrstuvwxyz", v),
			key=lambda elem: elem[1],
			reverse=True,
		)
	)
# for
 
print(mots_langue)

Bon, c'est assez difficile à piger de prime abord. Pour simplifier, sur chaque langue, je génère "à la volée" une association des lettres et de leurs fréquences (zip("abc...yz", v)) et je trie cette association selon la valeur de la fréquence (l'élément[1] de l'association) puis je ne récupère du résultat que les lettres triées (le "x") que je recompose en un mot unique ("".join(...)) et je stocke ce mot dans la langue d'où la fréquence a été sortie.

Enfin on s'en fout un peu, l'important c'est que "mots_langue" contienne pour chaque langue ses lettres dans l'ordre d'apparition. Et pour calculer une distance de Hamming entre 2 mots:

Code python :

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

1
2
3
def hamming(s1, s2):
	assert len(s1) == len(s2)
	return sum(c1 != c2 for c1, c2 in zip(s1, s2))

Comme tu peux le voir, Python offre des outils bien sympa pour agréger des listes de valeurs dans un sens ou dans l'autre. Ne reste qu'à compter tes lettres, les trier et regarder pour chaque mot de "mots_langue" la langue pour laquelle la distance de Hamming est la plus faible.

[MPython Alaplancha]

Bonjour,
Pour déterminer la langue d'un texte, j'utiliserai une expression rationnelle qui chercherai la présence d' articles spécifiques à une langue...
Pour voir si un text est ecrit en Français nous pourrions utiliser comme pattern :

Code :

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

pattern = r" (le|la|les|un|une|de|des|je|tu|il|elle|nous|vous|ils|elles|est|et|ai|mon|ton|son)+ "

Nous pourions aussi regarder du coté des accentuations spécifiques à une langue...

[jurassic pork]

hello,
sinon il y a la méthode de la distance de Levenshtein
voir ici :
Determine the Language of a Document from the Letter Frequency — using Levenshtein Distance between sequences

Ami calmant, J.P

[Sve@r]

sinon il y a la méthode de la distance de Levenshtein

Oui, il semble que ce soit un équivalent amélioré d'une distance de Hamming. La distance de Hamming suppose des mots de même longueur tandis que la distance de Levenshtein accepte des mots de taille différente (exemple avec "bright" et "freight" qui donne 2).
C'est effectivement plus intéressant surtout si on prend en compte aussi les variations de chaque langue (àâéèêîïç etc...)

[teddyfresnes]

Bonsoir à tous,

Je n'ai pas trop eu le temps de répondre car j'ai été très occupé. Je vous remercie de vos réponses.

Je me souviens avoir essayé dans un code assez brut la méthode de distance de hamming malheureusement à ma grande déception les résultats était trop vagues et les langues françaises et anglaises par exemple, avait un résultat très proche, selon le texte utilisé, pour la majorité des résultats erronés.

Je ne sais plus si j'avais fait une erreur dans mon programme enfin bref c'est oublié

[Sve@r]

Je me souviens avoir essayé dans un code assez brut la méthode de distance de hamming malheureusement à ma grande déception les résultats était trop vagues et les langues françaises et anglaises par exemple, avait un résultat très proche, selon le texte utilisé, pour la majorité des résultats erronés.

Sympa d'être revenu. J'avais oublié ce post. Ca m'a donné l'idée de m'essayer aussi au truc

Code python :

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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
#!/usr/bin/env python3
# coding: utf-8
 
import string
 
# Génération de l'alphabet trié par ordre d'apparition des lettres dans le texte
def genereAlphabet(txt):
	d=dict((c, txt.lower().count(c)) for c in string.ascii_lowercase)
	return "".join(
		x[0] for x in sorted(
			((k, v) for (k, v) in d.items()),
			key=lambda x: x[1],
			reverse=True,
		)
	)
# genereAlphabet()
 
# Distance entre deux mots de même longueur (méthode de Hamming)
def distanceHamming(m1, m2):
	return sum(x != y for (x, y) in zip(m1, m2))
 
# Distance entre deux mots pouvant être de longueur inégale (méthode nommée "distance d'édition")
def distanceEdition(m1, m2):
	dist={(-1, -1) : 0}
	for i in range(len(m1)): dist[i, -1]=i
	for i in range(len(m2)): dist[-1, i]=i
 
	for (i, c) in enumerate(m1):
		for (j, d) in enumerate(m2):
			d1=dist[i-1, j] + 1 # insertion
			d2=dist[i, j-1] + 1 # suppression
			d3=dist[i-1, j-1] + (0 if c == d else 1)
			dist[i, j]=min(d1, d2, d3)
		# for
	# for
	return dist[len(m1)-1, len(m2)-1]
# distanceEdition
 
# Recherche de la langue d'un texte
def chercheLangue(txt):
	# Génération de l'alphabet du texte
	alphaTxt=genereAlphabet(txt)
 
	# Génération des alphabets dans chaque langue selon leur pourcentage d'apparition de lettres
	pourcentagesLettres={
		'Anglais' : (8.167, 1.492, 2.782, 4.253, 12.702, 2.228, 2.015, 6.094, 6.966, 0.153, 0.772, 4.025, 2.406, 6.749, 7.507, 1.929, 0.095, 5.987, 6.327, 9.056, 2.758, 0.978, 2.360, 0.150, 1.974, 0.074, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0),
		'Français' : (7.636, 0.901, 3.260, 3.669, 14.715, 1.066, 0.866, 0.737, 7.529, 0.613, 0.074, 5.456, 2.968, 7.095, 5.796, 2.521, 1.362, 6.693, 7.948, 7.244, 6.311, 1.838, 0.049, 0.427, 0.128, 0.326, 0.486, 0.051, 0, 0, 0, 0, 0, 0, 0.018, 0.085, 0, 0, 0, 0, 0, 0.271, 1.504, 0.218, 0.008, 0, 0, 0, 0, 0, 0.045, 0, 0, 0.005, 0, 0, 0, 0, 0, 0, 0, 0, 0.023, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0.058, 0, 0.060, 0, 0, 0, 0, 0, 0, 0), 
		'Allemand' : (6.516, 1.886, 2.732, 5.076, 16.396, 1.656, 3.009, 4.577, 6.550, 0.268, 1.417, 3.437, 2.534, 9.776, 2.594, 0.670, 0.018, 7.003, 7.270, 6.154, 4.166, 0.846, 1.921, 0.034, 0.039, 1.134, 0, 0, 0, 0, 0.578, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0.443, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0.307, 0, 0, 0, 0, 0, 0, 0.995, 0, 0, 0, 0, 0), 
		'Espagnol' : (11.525, 2.215, 4.019, 5.010, 12.181, 0.692, 1.768, 0.703, 6.247, 0.493, 0.011, 4.967, 3.157, 6.712, 8.683, 2.510, 0.877, 6.871, 7.977, 4.632, 2.927, 1.138, 0.017, 0.215, 1.008, 0.467, 0, 0, 0.502, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0.433, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0.725, 0, 0, 0, 0, 0.311, 0, 0, 0, 0, 0, 0.827, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0.168, 0, 0, 0.012, 0, 0, 0, 0, 0), 
		'Portuguais' : (14.634, 1.043, 3.882, 4.992, 12.570, 1.023, 1.303, 0.781, 6.186, 0.397, 0.015, 2.779, 4.738, 4.446, 9.735, 2.523, 1.204, 6.530, 6.805, 4.336, 3.639, 1.575, 0.037, 0.253, 0.006, 0.470, 0.072, 0.562, 0.118, 0, 0, 0.733, 0, 0, 0, 0.530, 0, 0, 0, 0, 0, 0, 0.337, 0.450, 0, 0, 0, 0, 0, 0, 0, 0, 0.132, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0.635, 0.296, 0.040, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0.207, 0, 0, 0.026, 0, 0, 0, 0, 0), 
		'Espéranto' : (12.117, 0.980, 0.776, 3.044, 8.995, 1.037, 1.171, 0.384, 10.012, 3.501, 4.163, 6.104, 2.994, 7.955, 8.779, 2.755, 0, 5.914, 6.092, 5.276, 3.183, 1.904, 0, 0, 0, 0.494, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0.657, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0.691, 0, 0.022, 0, 0, 0, 0, 0, 0.055, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0.385, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0.520, 0, 0, 0, 0, 0, 0), 
		'Italien' : (11.745, 0.927, 4.501, 3.736, 11.792, 1.153, 1.644, 0.636, 10.143, 0.011, 0.009, 6.510, 2.512, 6.883, 9.832, 3.056, 0.505, 6.367, 4.981, 5.623, 3.011, 2.097, 0.033, 0.003, 0.020, 1.181, 0.635, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0.263, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0.030, 0.030, 0, 0, 0, 0, 0, 0, 0, 0.002, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, (0.166), 0.166, 0, 0, 0, 0, 0, 0, 0, 0), 
		'Turc' : (11.920, 2.844, 0.963, 4.706, 8.912, 0.461, 1.253, 1.212, 8.600, 0.034, 4.683, 5.922, 3.752, 7.487, 2.476, 0.886, 0, 6.722, 3.014, 3.314, 3.235, 0.959, 0, 0, 3.336, 1.500, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1.156, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1.125, 0, 0, 0, 0, 0, 5.114, 0, 0, 0, 0, 0, 0, 0.777, 0, 0, 0, 0, 0, 0, 1.780, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1.854, 0, 0, 0, 0, 0), 
		'Suédois' : (9.383, 1.535, 1.486, 4.702, 10.149, 2.027, 2.862, 2.090, 5.817, 0.614, 3.140, 5.275, 3.471, 8.542, 4.482, 1.839, 0.020, 8.431, 6.590, 7.691, 1.919, 2.415, 0.142, 0.159, 0.708, 0.070, 0, 0, 0, 1.338, 1.797, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1.305, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0), 
		'Polonais' : (8.910, 1.470, 3.960, 3.250, 7.660, 0.300, 1.420, 1.080, 8.210, 2.280, 3.510, 2.100, 2.800, 5.520, 7.750, 3.130, 0.140, 4.690, 4.320, 3.980, 2.500, 0.040, 4.650, 0.020, 3.760, 5.640, 0, 0, 0, 0, 0, 0, 0.990, 0, 0, 0, 0, 0.400, 0, 0, 0, 0, 0, 0, 0, 1.110, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1.820, 0, 0.200, 0, 0, 0, 0, 0.850, 0, 0, 0, 0, 0, 0.660, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0.060, 0.830, 0), 
		'Néerlandais' : (7.486, 1.584, 1.242, 5.933, 18.91, 0.805, 3.403, 2.380, 6.499, 1.46, 2.248, 3.568, 2.213, 10.032, 6.063, 1.57, 0.009, 6.411, 3.73, 6.79, 1.99, 2.85, 1.52, 0.036, 0.035, 1.39, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0), 
		'Danois' : (6.025, 2.000, 0.565, 5.858, 15.453, 2.406, 4.077, 1.621, 6.000, 0.730, 3.395, 5.229, 3.237, 7.240, 4.636, 1.756, 0.007, 8.956, 5.805, 6.862, 1.979, 2.332, 0.069, 0.028, 0.698, 0.034, 0, 0, 0, 1.190, 0, 0, 0, 0.872, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0.939, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0), 
		'Islandais' : (10.110, 1.043, 0, 1.575, 6.418, 3.013, 4.241, 1.871, 7.578, 1.144, 3.314, 4.532, 4.041, 7.711, 2.166, 0.789, 0, 8.581, 5.630, 4.953, 4.562, 2.437, 0, 0.046, 0.900, 0, 0, 0, 1.799, 0, 0, 0, 0, 0.867, 0, 0, 0, 0, 0, 0, 4.393, 0, 0.647, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1.570, 0, 0, 0, 0, 0, 0, 0, 0, 0.777, 0, 0.994, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1.455, 0, 0.613, 0, 0, 0, 0, 0.228, 0, 0, 0), 
		'Finlandais' : (12.217, 0.281, 0.281, 1.043, 7.968, 0.194, 0.392, 1.851, 10.817, 2.042, 4.973, 5.761, 3.202, 8.826, 5.614, 1.842, 0.013, 2.872, 7.862, 8.750, 5.008, 2.250, 0.094, 0.031, 1.745, 0.051, 0, 0, 0, 0.003, 3.577, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0.444, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0), 
		'Tchèque' : (8.421, 0.822, 0.740, 3.475, 7.562, 0.084, 0.092, 1.356, 6.073, 1.433, 2.894, 3.802, 2.446, 6.468, 6.695, 1.906, 0.001, 4.799, 5.212, 5.727, 2.160, 5.344, 0.016, 0.027, 1.043, 1.599, 0, 0, 0.867, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0.462, 0.015, 0, 0, 0.633, 0, 0, 0, 1.222, 0, 0, 0, 0, 0, 1.643, 0, 0, 0, 0, 0, 0, 0.007, 0, 0, 0, 0.024, 0, 0, 0.380, 0, 0, 0, 0.688, 0, 0.006, 0, 0, 0.045, 0, 0, 0, 0.204, 0.995, 0, 0, 0.721),
	}
	alphaLangue=dict(
		(
			k,
			"".join(
				x for (x, y) in sorted(
					zip(string.ascii_lowercase, v),
					key=lambda elem: elem[1],
					reverse=True,
				)
			),
		) for (k, v) in pourcentagesLettres.items()
	)
 
	# Calcul des distances entre le mot du texte et chaque mot de la langue en pourcentage par rapport à 26
	l=len(string.ascii_lowercase)
	calcul={"texte": alphaTxt, "result": dict()}
	for (k, v) in alphaLangue.items():
		calcul["result"][k]={"texte" : v, "result" : dict()}
		for (methode, fct) in (
			("Hamming", distanceHamming),
			("Edition", distanceEdition),
		):
			calcul["result"][k]["result"][methode]=100 - fct(alphaTxt, v)/l * 100
	# for
	return calcul
# chercheLangue()
 
# Analyse d'un fichier
def analyse(fic):
	with open(fic, "r") as fp: r=chercheLangue(fp.read())
	print("Mot de base de %s: %s" % (fic, r["texte"]))
	for x in sorted(
		((k, v) for (k, v) in r["result"].items()),
		key=lambda x: sum(x[1]["result"].values()) / len(x[1]["result"]),
		reverse=True,
	):
		print(
			"%s (%s): %s (moyenne=%.02f%%)" % (
				x[0],
				x[1]["texte"],
				", ".join("%s: %.02f%%" % (k, v) for (k, v) in x[1]["result"].items()),
				sum(x[1]["result"].values()) / len(x[1]["result"]),
			)
		)
	# for
# analyse()
 
# Programme principal
if __name__ == "__main__":
	import sys
	for arg in sys.argv[1:]: analyse(arg)
# if

On lance le programme en lui passant un fichier contenant un texte, et il ressort pour chaque langue la probabilité en pourcentage de lui appartenir triée par probabilité totale.

L'avantage c'est qu'on peut lui rajouter facilement d'autres méthodes de calcul (j'ai trouvé l'algorithme de distance entre deux mots nommé "distance d'édition" ici => http://www.xavierdupre.fr/app/ensae_...7_edition.html). Si par dessus jurassic pork veut implémenter la distance de Levenshtein, il lui suffit de rajouter la fonction "distanceLevenshtein" et de l'inclure dans la boucle

Code :

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

1
2
3
4
5
for (methode, fct) in (
	("Hamming", distanceHamming),
	("Edition", distanceEdition),
	("Levenshtein", distanceLevenshtein),
)

et tout le reste s'y adapte.

L'inconvénient c'est que j'ai tenté d'analyser le texte de cette page, texte à priori on ne peut plus français, et que j'ai eu ce résultat

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
Mot de base de b: earnsitluocdmphfvgbqkyxjwz
Suédois (eanrtsildomkgvhfupbcyjxwzq): Hamming: 30.77%, Edition: 42.31% (moyenne=36.54%)
Espagnol (eaosrnidltcmupbgvyqhfjzxwk): Hamming: 23.08%, Edition: 30.77% (moyenne=26.92%)
Italien (eaionlrtscdpumvgzfbhqwyjkx): Hamming: 15.38%, Edition: 34.62% (moyenne=25.00%)
Islandais (arniestulgmkfvohdjbypxcqwz): Hamming: 15.38%, Edition: 34.62% (moyenne=25.00%)
Anglais (etaoinshrdlcumwfgypbvkjxqz): Hamming: 11.54%, Edition: 30.77% (moyenne=21.15%)
Français (esaitnruoldcmpvqfbghjxzykw): Hamming: 11.54%, Edition: 30.77% (moyenne=21.15%)
Portuguais (aeosridmntculpvgqbfhzjxwky): Hamming: 15.38%, Edition: 26.92% (moyenne=21.15%)
Danois (erntaidslogkmfvbuphjycwzxq): Hamming: 15.38%, Edition: 26.92% (moyenne=21.15%)
Tchèque (aeonitvsrldkmupzjhybcgfxwq): Hamming: 11.54%, Edition: 30.77% (moyenne=21.15%)
Allemand (ensriatdhulgcomwbfkzvpjyxq): Hamming: 7.69%, Edition: 26.92% (moyenne=17.31%)
Espéranto (aieonlsrtkjudmpvgfbczhqwxy): Hamming: 3.85%, Edition: 26.92% (moyenne=15.38%)
Finlandais (aintesloukmrvjhpydgbcfwzxq): Hamming: 7.69%, Edition: 23.08% (moyenne=15.38%)
Turc (aeinrldkmytusbozghcvpfjqwx): Hamming: 7.69%, Edition: 15.38% (moyenne=11.54%)
Polonais (aioeznrwstcykdpmujlbghfqvx): Hamming: 3.85%, Edition: 15.38% (moyenne=9.62%)
Néerlandais (enatirodslgvhkmubpwjzcfxyq): Hamming: 3.85%, Edition: 11.54% (moyenne=7.69%)

Il semble donc que mon texte ait le plus de probabilités d'être du suédois
Après est-ce la faute aux valeurs des pourcentages de fréquences d'apparition ou de la méthode d'analyse...

Enfin c'était sympa à programmer

[jurassic pork]

hello,

. Si par dessus jurassic pork veut implémenter la distance de Levenshtein, il lui suffit de rajouter la fonction "distanceLevenshtein" et de l'inclure dans la boucle

Code :

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

1
2
3
4
5
for (methode, fct) in (
    ("Hamming", distanceHamming),
    ("Edition", distanceEdition),
    ("Levenshtein", distanceLevenshtein),
)

et tout le reste s'y adapte.

voici un code python que j'ai trouvé sur le net pour implémenter la fonction distanceLevenshtein :

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
 
def distanceLevenshtein(str1, str2, ):
    counter = {"+": 0, "-": 0}
    distance = 0
    for edit_code, *_ in ndiff(str1, str2):
        if edit_code == " ":
            distance += max(counter.values())
            counter = {"+": 0, "-": 0}
        else: 
            counter[edit_code] += 1
    distance += max(counter.values())
    return distance

Sve@r je ne sais pas ce que tu as pris dans ta page wikipédia pour faire le test (tout le texte html ?) mais avec le contenu du fichier hitchcock.txt en pièce jointe (début de l'article Hitchcock en mode texte) voici ce que j'obtiens avec la fonction distanceLevenshtein ajoutée à ton programme :

>>> Mot de base de hitchcock.txt: esnartiulocdmphqfgvbykxjwz
Français (esaitnruoldcmpvqfbghjxzykw): Hamming: 26.92%, Edition: 38.46%, Levenshtein: 30.77% (moyenne=32.05%)
Suédois (eanrtsildomkgvhfupbcyjxwzq): Hamming: 26.92%, Edition: 38.46%, Levenshtein: 26.92% (moyenne=30.77%)
Islandais (arniestulgmkfvohdjbypxcqwz): Hamming: 19.23%, Edition: 26.92%, Levenshtein: 7.69% (moyenne=17.95%)
Espagnol (eaosrnidltcmupbgvyqhfjzxwk): Hamming: 26.92%, Edition: 30.77%, Levenshtein: -7.69% (moyenne=16.67%)
Anglais (etaoinshrdlcumwfgypbvkjxqz): Hamming: 15.38%, Edition: 26.92%, Levenshtein: 3.85% (moyenne=15.38%)
Italien (eaionlrtscdpumvgzfbhqwyjkx): Hamming: 7.69%, Edition: 23.08%, Levenshtein: 11.54% (moyenne=14.10%)
Danois (erntaidslogkmfvbuphjycwzxq): Hamming: 23.08%, Edition: 26.92%, Levenshtein: -7.69% (moyenne=14.10%)
Portuguais (aeosridmntculpvgqbfhzjxwky): Hamming: 15.38%, Edition: 23.08%, Levenshtein: -7.69% (moyenne=10.26%)
Espéranto (aieonlsrtkjudmpvgfbczhqwxy): Hamming: 0.00%, Edition: 26.92%, Levenshtein: -3.85% (moyenne=7.69%)
Allemand (ensriatdhulgcomwbfkzvpjyxq): Hamming: 3.85%, Edition: 26.92%, Levenshtein: -11.54% (moyenne=6.41%)
Tchèque (aeonitvsrldkmupzjhybcgfxwq): Hamming: 15.38%, Edition: 23.08%, Levenshtein: -23.08% (moyenne=5.13%)
Néerlandais (enatirodslgvhkmubpwjzcfxyq): Hamming: 3.85%, Edition: 15.38%, Levenshtein: -15.38% (moyenne=1.28%)
Turc (aeinrldkmytusbozghcvpfjqwx): Hamming: 7.69%, Edition: 19.23%, Levenshtein: -30.77% (moyenne=-1.28%)
Finlandais (aintesloukmrvjhpydgbcfwzxq): Hamming: 11.54%, Edition: 19.23%, Levenshtein: -38.46% (moyenne=-2.56%)
Polonais (aioeznrwstcykdpmujlbghfqvx): Hamming: 7.69%, Edition: 15.38%, Levenshtein: -46.15% (moyenne=-7.69%)

Le Français est bien en premier avec la fonction distanceLevenshtein.

Mais en ne prenant pas en compte les caractères accentués les résultats peuvent être faussés.

Ami calmant, J.P

[Sve@r]

voici un code python que j'ai trouvé sur le net pour implémenter la fonction distanceLevenshtein

Petit souci, ton code utilise une fonction "ndiff" que je ne connais/trouve pas...

Le Français est bien en premier avec la fonction distanceLevenshtein.

Oui, rajouter d'autres méthodes affine le système Faudrait maintenant tester d'autres langues pour voir si ça matche

Mais en ne prenant pas en compte les caractères accentués les résultats peuvent être faussés.

C'est parti. On modifie la fonction "genereAlphabet" pour y inclure les caractères accentués en les assimilant à leur équivalent non accentué...

Code python :

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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
# Génération de l'alphabet trié par ordre d'apparition des lettres dans le texte
def genereAlphabet(txt):
	# Suppression des accents
	for (x, y) in (
		("àâä", "a"),
		("éèêë", "e"),
		("îï", "i"),
		("ôö", "o"),
		("ûü", "u"),
		("ÿ", "y"),
	): txt=re.sub(r"[%s]" % x, r"%s" % y, txt)
 
	# Histogramme et tri
	d=dict((c, txt.lower().count(c)) for c in string.ascii_lowercase)
	return "".join(
		x[0] for x in sorted(
			((k, v) for (k, v) in d.items()),
			key=lambda x: x[1],
			reverse=True,
		)
	)
# genereAlphabet()

Avec un import re préalable.

[jurassic pork]

Petit souci, ton code utilise une fonction "ndiff" que je ne connais/trouve pas...

Code :

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

from difflib import ndiff

et pour les caractères accentués il faudrait mieux (si c'est possible) les rajouter dans la génération de l'alphabet et pas les assimiler à leurs équivalents sans accent.

[Sve@r]

Code :

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

from difflib import ndiff

Super. Je me suis amusé avec un texte turc trouvé sur le net.

Code :

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

1
2
3
4
5
6
7
Madde 26
1) Her şahsın öğrenim hakkı vardır. Öğrenim hiç olmazsa ilk ve temel safhalarında parasızdır. İlk öğretim mecburidir. Teknik ve mesleki öğretimden herkes istifade edebilmelidir. Yüksek öğretim, liyakatlerine göre herkese tam eşitlikle açık olmalıdır.
2) Öğretim insan şahsiyetinin tam gelişmesini ve insan haklarıyla ana hürriyetlerine saygının kuvvetlenmesini hedef almalıdır. Öğretim bütün milletler, ırk ve din grupları arasında anlayış, hoşgörü ve dostluğu teşvik etmeli ve Birleşmiş Milletlerin barışın idamesi yolundaki çalışmalarını geliştirmelidir.
3) Ana baba, çocuklarına verilecek eğitim türünü seçmek hakkını öncelikle haizdirler.
Madde 27
1) Herkes, topluluğun kültürel faaliyetine serbestçe katılmak, güzel sanatları tatmak, ilim sahasındaki ilerleyişe iştirak etmek ve bundan faydalanmak hakkını haizdir.
2) Herkesin yarattığı, her türlü bilim, edebiyat veya sanat eserlerinden mütevellit manevi ve maddi menfaatlerin korunmasına hakkı vardır.

Le texte est un peu court mais le programme, avec ta fonction, a quand-même bien détecté du Turc

et pour les caractères accentués il faudrait mieux (si c'est possible) les rajouter dans la génération de l'alphabet et pas les assimiler à leurs équivalents sans accent.

Hé là je ne suis pas certain. Car l'algo est en fait basé sur les probabilités indiquées des différentes langues. Or ces probabilités ne concernent que les lettres de base. Comment alors comparer un mot statistique (l'histogramme du texte initial) qui contiendrait des accents avec les mots générés par les valeurs des tables de probabilités qui, eux, seront sans accent?
Je suis obligé de considérer un "é" (et ses soeurs) comme un "e". Et puis bon ça reste (tiens, il faudrait aussi penser au "c cédille") ludique donc je vais pas non plus me faire des noeuds au cerveau

[jurassic pork]

Hé là je ne suis pas certain. Car l'algo est en fait basé sur les probabilités indiquées des différentes langues (sais plus où je les avais trouvées, probablement sur wikipedia). Or ces probabilités ne concernent que les lettres de base.

Dans ton code dans la variable pourcentageslettres il y a plus de 26 valeurs par lettre donc je suppose qu'il y a aussi les accents
En pièce jointe la fréquence des lettres et lettres accentuées en fonction de la langue en format csv. Et pour le fichier texte en entrée il vaudrait mieux un texte en format UTF8 pour être sûr de bien repérer les accents.

[Daguhh]

Salut!

Je n'ai pas trop compris si il fallait implémenter un méthode spécifique ou non, donc je vais peut-être être hors-sujet, mais:

On peut, plutôt que de calculer la probabilité d'apparition d'une lettre,
calculer la probabilité qu'une lettre apparaisse après une autre (chaînes de markov)

C'est plutôt simple à mettre en œuvre, comme dans les exemples précédents,
on parcourt lettre par lettre un texte/mot et on compte les occurrences,
mais cette fois-ci on fait 26 dictionnaires différents selon la lettre qui précède.

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
13
tableau_occurences = {
    'a' : {           #*lettre qui précède
        'a' : 0,     # lettre qui suit
        'b' : 5,
        ...
    },
    'b' : {
        'a' : 10,
        'b' : 0,
        ...
    },
}
"""

Soit le tableau français: (ordonné : lettre précédente, abscisse : lettre suivante)

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
        a  b  c  d  e  f  g  h  i  j  k  l  m  n  o  p  q  r  s  t  u  v  w  x  y  z
------------------------------------------------------------------------------------
  |  0 12  2  4  7 19  1  1  2  5  1  0  7  6  6  2  3  6  4  4  6  0  1  0  0  0  0
a |  4  0  3  4  2  0  2  3  0 21  0  0  6  5  9  0  3  0  6 17  9  2  2  0  0  1  0
b |  0 18  0  0  0 11  0  0  0 12  1  0 12  0  0 19  0  0 17  3  1  4  0  0  0  0  0
c |  0 14  0  5  0 10  0  0 20  8  0  0  5  0  0 18  0  1  7  0  7  6  0  0  0  0  0
d | 16  8  0  0  0 38  0  0  0 17  1  0  0  1  0  7  0  0  5  0  0  4  0  0  0  0  0
e |  9  1  1  4  1  2  1  1  0  1  0  0  3  5 17  0  2  0 23 13  4  2  1  0  2  0  7
f |  1 10  0  0  0 12 21  0  0 20  0  0  9  0  0 10  0  0 10  1  0  5  0  0  0  0  0
g |  0  9  0  0  0 30  0  1  0  8  0  0  5  1  9  8  0  0 14  0  0 13  0  0  0  0  0
h |  0 31  0  0  0 30  0  0  0 14  0  0  1  0  0 12  0  0  2  0  0  4  0  0  0  5  0
i |  5  3  1  2  2 16  2  2  0  0  0  0  6  3 11  9  1  2  4 18  9  0  2  0  0  0  0
j | 44 10  0  0  0 12  0  0  0  0  0  0  0  0  0 19  0  0  0  0  0 16  0  0  0  0  0
k |  8 17  2  0  0 22  0  0  3 19  0  1  3  0  1  4  0  0  2  5  0  1  0  0  0 12  0
l | 21 16  0  1  0 19  0  0  0 15  0  0 13  0  0  7  0  0  0  1  1  3  0  0  0  1  0
m | 18 13  8  0  0 24  0  0  0  9  0  0  0  5  0  8 11  0  0  0  0  3  0  0  0  0  0
n | 11  6  0  6  4  8  2  3  0  5  1  0  0  0  6  2  0  0  1 16 28  1  1  0  0  0  0
o |  0  0  2  3  1  0  1  2  0  4  0  0  5  5 39  0  3  1  9  3  4 15  1  0  0  1  0
p |  0 18  0  0  0 16  0  0  5 11  0  0  8  0  0 14  8  0 12  1  3  3  0  0  0  0  0
q |  0  0  0  0  0  0  0  0  0  0  0  0  0  0  0  0  0  0  0  0  0100  0  0  0  0  0
r |  4 28  1  2  2 22  0  2  0 15  0  0  0  2  1 12  1  0  3  1  2  1  1  0  0  0  0
s | 40  7  0  1  0 16  0  0  0  8  0  0  0  0  0  3  1  0  0 17  4  2  0  0  0  0  0
t | 39 10  0  0  0 18  0  0  1 12  0  0  0  0  0  4  0  0  8  1  3  2  0  0  0  0  0
u | 20  6  2  3  2 11  2  1  0  8  0  0  7  3  2  0  2  0 13  7  7  0  2  0  1  0  0
v |  0 25  0  0  0 34  0  0  0 24  0  0  0  0  0 10  0  0  6  0  0  1  0  0  0  0  0
w |  3 35  0  0  0 22  0  0  2 23  0  0  6  0  2  4  0  0  1  2  0  1  0  0  0  0  0
x |  9 10  0 12  0  9  1  0  6 10  0  0  0  0  0  4 20  0  0  1 13  2  0  0  0  3  0
y |  1 20  1  4  9 14  0  3  0  2  0  0  6  4  5  4 10  0  3  9  3  0  0  0  1  0  0
z | 96  1  0  0  0  1  0  0  0  1  0  0  0  0  0  2  0  0  0  0  0  0  0  0  0  0  0

Après cet entraînement,
on a toutes les probabilité de P(lettre_1 => lettre_2) spécifiques à une langue.

On peut alors calculer "la probabilité qu'un mot existe" dans la langue, par exemple, un mot de 5 lettres:
P = P12 * P23 * P34 * P45

Il suffit de faire ce calcul de proba sur 2 langues différentes et prendre la plus grande.

Traduction python
Calcul du tableau :

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
with open(f"liste_mot_langue_xxx.txt", 'r') as f:
 
    tableau_proba = {}
 
    for word in f:
        for precedente, suivante in fenetre_glissante_taille_2(word):
            tableau_proba.setdefault(precedente, {})
            tableau_proba[precedente][suivante] = tableau_proba[precedente].setdefault(suivante, 0) + 1
 
# transformation occurences => proba
for precedente in tableau_proba.keys():
    tab = tableau_proba[precedente]
    for suivante, occurences in tab.items():
        tab[suivante] = occurences / sum(tab.values())

Probabilité d'un mot

Code :

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

1
2
3
4
5
6
Pmot = 1
 
for precedente, suivante in fenetre_glissante_taille_2(phrase):
 
    tableau_proba[precedente] = dct.setdefault(precedente, {})       
    Pmot = Pmot * tableau_proba[precedente].setdefault(suivante, 0)

Pour comparer deux langues, simplement:

Code :

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

1
2
3
4
5
 
if P_lang_1 > P_lang_2:
    print('lang_1')
else:
    print('lang_2')

Bonus : générateur pour fenere glissante (itertools)

Code :

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

1
2
3
4
5
6
7
def read_by_2(iterable, size=2):
    iterable = iter(" " + iterable + " ")
    d = deque(islice(iterable, size), size)
    yield d
    for x in iterable:
        d.append(x)
        yield d

En pratique
Je suis parvenu à des bons résultats (pas d'erreurs sur des textes en français ou en anglais), mais en regardant quel caractère suit 2 autres.
J'ai généré les tableaux à partir de liste de mots issue d'aspell (simple liste de mot pour corrections orthographiques)

Voilà, c'était surtout pour partager le principe.Mon implémentation (et mon cote) ne sont vraiment pas terrible, Néanmoins, pour les audacieux:
https://framagit.org/-/snippets/6189 (makov mémoire à un caractère, mémoire à deux caractères + les probas au fomat json)
markovchain_guess_language

[jurassic pork]

hello,
finalement, j'ai trouvé un script python qui essaie d'identifier la langue d'un texte par la fréquence de ses lettres en utilisant un algorithme personnel. C'est ici
Ce script prend bien en compte les accents pour son calcul. Il permet aussi de visualiser de façon graphique les résultats (avec pylab). A noter qu'il n'y a pas l'anglais dans les langues
J'ai dû faire quelques modifications mineures pour le faire fonctionner en python 3 :
1 - Mettre des parenthèses pour les print
2 - Pour les open de fichiers ajouter en paramètre d'appel encoding='utf-8'
3 - J'ai rajouté deux fichiers dans le répertoire snippets ( un en français (mon fichier hitchcock.txt), l'autre turc_Sve@r.txt contenant le texte turc de Sve@r. Modification pour cela faite dans le script python :

Code :

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

    for textfile in ['hitchcock.txt','turc_Sve@r.txt','nl_columbus.txt', 'it_boccaccio.txt', 'fi_kivi.txt']:

et voici les résultats pour les deux premiers fichiers :



Ami calmant, J.P