Bonjour, dans le cas d'un exercice de NSI mon professeur m'a demandé de créer un argot ainsi qu'une fonction permettant de modifier les mots de la langue française vers cet argot

j'ai donc choisit un argot d'inversion des syllabes exemple :

- argot : gotar

- campagne : pagnecam

Sauf que j'ai des difficultés à créer ce programme python et dans un premier temps de trouver les syllabes et de les stocker pour ensuite faire appel a un autre programme qui les inversera

mon code :

def coupe_syllabe(mot):
    voyelle = "aeiouy"
    consone = "zrtpqsdfghjklmwxcvbn"
    precedent = mot[0]
    mot2=""
    stockage=""
    for i in range(0,len(mot)-1):
        mot2+=mot[i]
        if mot[i] and mot[i+1] in consone:
            return mot2+mot[i+1]

Je demande donc votre aide merci d'avance

Pour découper un mot en syllabes se fait suivant certaines règles.

Il faut déjà partir de celles ci, pour en faire un algorithme (qu'on pourra coder) et on doit le retrouver à la lecture du code.

Ca commence sur une feuille de papier comment découper argot en ar/got ou campagne en cam/pa/gne...

Ça n'a rien d'évident, il te faut un algorithme de syllabation. Et il faut déjà définir syllabe. Dans des cas très simples, tu peux arriver à quelque chose, sinon c'est un travail de linguiste. Il doit exister des fichiers des syllabisés du lexique français.

j'ai trouvé la règle française qui défini les syllabes, c'est quand "On sépare les syllabes entre deux consonnes sauf à la fin d'un mot. La règle s'applique aussi pour deux consommes qui sont les mêmes. On sépare les syllabes entre une voyelle et une consonne. Lorsque trois consonnes se suivent et sont différentes, on sépare après la deuxième consonne." 

le seul problème étant que dans mon programme les syllabes sont mal prises en compte et aussi que la dernière lettre n'est pas comprise dedans

Pour l'avoir déjà fait dans le passé, les règles ne sont pas si simples.
Comment sépares-tu "tendre", "alphabet", "paraphraser", ou pire "aujourd'hui" ...
Voici une liste non exhaustive des doublets et triplets à reconnaître:
bl, br, ch, cl, cr, dr, fl, fr, gn, gr, pl, pr, tr, vr,  chr phr, ...

On s'aligne sur les suites de voyelles et on recule pour reconnaître ces séquences. Attention aux débuts et fin de mot.

-
Edité par PierrotLeFou 28 novembre 2021 à 15:22:23

Je vois bien mais après je ne vois pas comment le retraduire en code :/

Commences par reconnaître les fins de séquences de voyelles. Bon exemples: beaucoup, voyage.
Le mot interactif pose problème, mais est-ce bien un mot français?
On cherche le début de la syllabe, pas la fin.

Tu seras toujours une syllabe en retard ...

-
Edité par PierrotLeFou 28 novembre 2021 à 15:32:28

word=input("Enter the word:")
voyelle="aeiouy"
syllabe=0
for w in word:
      if w in voyelle:
            syllabe+=1
print("le nombre de syllabe est :")
print(syllabe)

j'ai ce code mais le seul problème c'est les mots où 2 et+ syllabes se suivent

Là vous avez le nombre de syllabes, pas les syllabes, il faut ensuite déterminer comment découper selon des règles.

Pour le nombre de syllabes, on peut voir du côté du module NLTK et son module cmudict.

Corentin_n a écrit:

j'ai trouvé la règle française qui défini les syllabes, c'est quand "On sépare les syllabes entre deux consonnes sauf à la fin d'un mot. La règle s'applique aussi pour deux consommes qui sont les mêmes. On sépare les syllabes entre une voyelle et une consonne. Lorsque trois consonnes se suivent et sont différentes, on sépare après la deuxième consonne."

Il faut imaginer un algorithme. Pour çà on peut supposer qu'on va balayer le mot caractère par caractère et on essaie de reformuler ces règles en fonction de ce balayage.

Premier truc, une syllabe contient au moins une voyelle: il peut y avoir n'importe quoi avant qu'on rencontre la première voyelle, toutes ces lettres seront dans la première syllabe (première voyelle rencontrée incluse).

Et arrivé là, on regarde ce qui suit: si c'est une voyelle ou une ou plusieurs consonnes pour savoir comment terminer la première syllabe.

On retranche la première syllabe du mot et on recommence avec le reste (condition d'arrêt à gérer).

Pour l'instant, c'est plus une histoire "avec les mains" qu'un algorithme... mais c'est votre exercice.

Ok mais un deuxième problème apparaît :

comment stocker les syllabes séparément pour dans un second programme les inverser ?

autre problème je n'arrive pas a tester si la valeur de mot[i+1] est inexistante ou si c'est une lettre du mot avec cette boucle :

def t(mot):
    voyelle="aeiouy"
    syllabe=""
    s=''
    for i in range(0,len(mot)):
        if mot[i] in voyelle:
            if mot[i+1]!=s and mot[i+1] in voyelle:

ça met toujours out of range alors que j'ai mis "si mot[i+1]!=s" 

-
Edité par Corentin_n 28 novembre 2021 à 16:46:15

Corentin_n a écrit:

comment stocker les syllabes séparément pour dans un second programme les inverser ?

Ça ce n'est pas un problème, l'algorithme doit prendre 98% de votre temps, le reste est simple, comme celui d'inverser des syllabes.

syllabes = ["bon", "jour"]
syllabes_inverse = syllabes[::-1] # ou reversed(syllabes)

L'algorithme à mon sens est complexe, ça demande un niveau de recherches important et je supposerai qu'il faille travailler par tests unitaires.

Le fait d'avoir un message d'erreur lié aux index prouvent que l'algorithme n'est pas fiable selon la variation des longueurs de chaîne de caractères utilisées dans votre fonction.

Sauf que je n'arrive pas a séparer les différentes syllabes

le travail étant à rendre sous peu de temps c'est un peut la course ahah

-
Edité par Corentin_n 28 novembre 2021 à 17:19:01

Votre professeur ne vous a pas donné quelques règles à respecter pour créer vos syllabes ?

https://www.alloprof.qc.ca/fr/eleves/bv/francais/la-syllabe-f1595

Selon les règles ci-dessus, ça demande de connaître l'index précédent et suivant de l'index courant et une bonne poignée de tests afin de vérifier chaque règle.

Vous pouvez utiliser les exemples du lien ci-dessus afin de vérifier le bon fonctionnement de votre code.

J'ai quand même un problème principal qui est que je ne parcours pas la dernière valeur du mot avec cette boucle :

for i in range(0,len(mot)-1):

et je suis obligé de laisser le "-1" car sinon lorsque je fais mot[i+1] et que c'est sur la dernière lettre et bah ça renvoie "out of range"

Comme je l'ai dit, il faut chercher les séquences de voyelles.
+ tu gardes la position de la prwemière pour savoir où commence la séquence de consonnes qui précède.
+ tu gardes le suivant de la dernière voyelle pour savoir où commencer la recherche de la prochaine séquence
Tu sauves cette valeur
Après tu recules dans la séquence des consonnes et tu  cherches (pour      2 consonnes ou plus) si la séquence est dans la table
Tu gardes la position du début de cette séquence.
Sinon, il n'y a qu'une consonne dans la syllabe. Ne pas s'occuper des mots comme (justement) "comme". 'mm' n'est pas dans la liste.
-
La séparation ne se fera qu'à la fin.
J'imagine un tableau des "coupures" dont la première valeur est 0 et la dernière est len(mot).
On fait un append des positions de début des séquences de consonnes.
On fait du slicing pour séparer le mot en syllabes.
coupe = []
for i in range(len(coupures)-1:
         coupe.append(mot[coupures[i]:coupures[i+1]])
coupe.reverse()
coupe = ''.join(coupe)

edit:

Si le mot commence par une voyelle, la suite des consonnes commence à 0 mais la dernière consonnes est à -1 (tant que 0 < -1 ...)

-
Edité par PierrotLeFou 28 novembre 2021 à 17:54:04

C'est un des problèmes mais il y a aussi ma boucle qui ne parcours pas la dernière valeur

Quand je te dis de garder la position après la séquence de voyelles, tu n'avances que si la position est inférieure à len(mot)
Si je prend "foret" (sans accent ...)
La seconde séquence de voyelles est le 'e' et le 't' suit.
Tu ne trouveras pas de bvoyelles après le 't' mais tu dois vérifier que tu as atteint la longueur de la chaîne.
Tel que je l'ai décrit, le tableau coupures sera:
coupures = [0, 2, 5]
Le 5 est ajouté à la fin.

Pour le mot "bateau", la séquence de voyelles s'arrêtera à la fin du mot et c'est cette position que tu gardes.

Pour savoir la différence entre les deux, s'il y a au moins une voyelle, tu recherches les consonnes qui précèdent, sinon tu ne fais rien.

-
Edité par PierrotLeFou 28 novembre 2021 à 18:18:49

def t(mot):
    comptesyllabe = 0
    voyelle = "aeiouy"
    consone = "zrtpqsdfghjklmwxcvbn"
    syllabe1=""
    syllabe2=""
    syllabe3=""
    syllabe4=""
    syllabe5=""
    syllabe6=""
    for i in range(0, len(mot)-1):
        if comptesyllabe == 0:
            comptesyllabe = 1
        if comptesyllabe == 1:
            if mot[i+2] in voyelle:
                syllabe1+=mot[i]
                comptesyllabe=2
            else:
                if mot[i] in voyelle:
                    if mot[i+1] in voyelle:
                        syllabe1+=mot[i+1]
                    else:
                        syllabe1+=mot[i]
                else:
                    syllabe1+=mot[i]
        
        
        if comptesyllabe == 2:
            if mot[i+2] in voyelle:
                syllabe2+=mot[i]
                comptesyllabe=3
            else:
                if mot[i] in voyelle:
                    if mot[i+1] in voyelle:
                        syllabe2+=mot[i+1]
                    else:
                        syllabe2+=mot[i]
                else:
                    syllabe2+=mot[i]
        
        
        
        
    return syllabe1,syllabe2
                

j'ai fais cet algorithme pour séparer les syllabes en syllabe1,2,3 etc

mais au moment où la condition pour passer à la syllabe suivant (la 2) est validée ça retest la lettre qui valide la condition

mis du coup ça ne fonctionne pas car la syllabe2 est "m" alors qu'elle devrait être "pa" ou "pag"

D'abord, tu n'as absolument pas besoin de la liste des consonnes.
Que ferais-tu avec le mot "anticonstitutionnellement" ?
Si je ne me trompe pas, il y a 9 syllabes ...
Essaies avec plusieurs mots d'afficher la position du début de chaque séquence de voyelles et la position de la fin de la séquence + 1 (position d'une consonne ou fin)
Si tu sais le faire, le reste ne sera pas trop compliqué.

là est le problème

def syl(mot):
    print(mot)
    voyelles = "eiaouy"
    fin = len(mot)
    v = fin
    c = 0
    i = 0
    while i < fin:
        if mot[i] in voyelles:
            if v == fin: v=i
        elif i > v:
            c= i
            if c > v:
                print(v,c, mot[v:c])
                v = fin
        i +=1
    if i > v:
        print(v, i, mot[v:i])
mots = ["asphalte", "bateau", "beaucoup", "foret","test", "locomotive"]
for w in mots:
    syl(w)

edit:
Je fais deux print pour les séquences de voyelles. Cela suppose deux traitements des syllabes.
Il serait préférable de n'avoir qu'un seul traitement. C'est possible!
Je garde mon truc de générer une liste des points de coupure entre les syllabes. Le reste sera évident:
-
    return ''.join([mot[coupures[i]:coupures[i+1]] for i in range(len(coupures)-1)][::-1])

re-edit:
@fred1599:
> L'algorithme à mon sens est complexe, ça demande un niveau de recherches important et je supposerai qu'il faille travailler par tests unitaires.
L'algorithme est en effet plus complexe que je pensais, même si je l'avais déjà codé en C il y a assez longtemps.
@Corentin_n:
> le travail étant à rendre sous peu de temps c'est un peut la course ahah
Il aurait fallu y penser avant ...
J'ai tout de même essayeé de le coder en Python. Je pense que ma version fonctionne:
-
def inverserSyllabes(mot):
    # Il peut manquer des séquences ou d'autres seraient invalides, 'st' est douteux.
    sequences = ['bl', 'br', 'ch', 'cl', 'cr', 'dr', 'fl', 'fr', 'gl', 'gn', 'gr', 'ph', 'pl', 'pr', 'st', 'tr', 'vr', 'chl', 'chr', 'phl', 'phr']
    voyelles = "eiaouy"
    coupures = []
    fin = len(mot)
    c = 0   # Position de la première consonne d'une séquence.
    i = 0
    while i < fin:
        if mot[i] not in voyelles:
            i += 1
        else:
            v = i   # Position de la première voyelle d'une séquence.
            i += 1
            while i < fin and mot[i] in voyelles:  i += 1   # Sauter toutes les voyelles suivantes.
            # On est soit à la fin, soit sur une consonne.
            p = max(c, v-1)
            for k in range(v-2, c-1, -1):   # Pour toutes les séquences de 2 consonnes ou plus, s'il y en a.
                if mot[k:v] in sequences:
                    p = k
                    break
            coupures.append(p)
            c = i
    coupures.append(fin)
    return ''.join([mot[coupures[i]:coupures[i+1]] for i in range(len(coupures)-1)][::-1])
#
mots = ['perchlorate', 'bonjour', 'bateau', 'france', 'algebre']
for m in mots:
    print(inverserSyllabes(m))

-
Edité par PierrotLeFou 29 novembre 2021 à 2:54:48

J'étais arrivé à un résultat similaire mais avec des erreurs sur des mots "compliqués" tel que aujourd'hui ou encore vendredi

Merci beaucoup pour votre aide

Le mot "vendredi" se convertit facilement si on connait la séquence 'dr' comme dans ma liste. Je ne sais pas comment tu sépares "aujourd'hui".
Quand je l'avais fait en C, j'utilisais le code ISO latin-1 dans lequel les lettres accentuées n'occupaient qu'un octet.
Je considérais l'apostrophe comme une voyelle.
Je pouvais séparer des mots comme "l'école" en "l'é-co-le"
Avec ma liste des séquences et en ajoutant l'apostrophe aux voyelles, j'obtiendrais "au-jourd-h'ui"

Pour les mots très particuliers, on peut se créer un dictionnaire.

Par exemple, pour traiter "interactif":

dico = {'interactif': 'in-ter-ac-tif'}

-
Edité par PierrotLeFou 29 novembre 2021 à 19:13:20

L'algorithme est en effet plus complexe que je pensais, même si je l'avais déjà codé en C il y a assez longtemps.

Oui ! Et sans tests unitaires, tu risques les régressions (un mot fonctionnait, puis par le changement de ton code, ne fonctionne plus).

Tu devrais créer une fonction par règle à mon avis, ça te permettra de modifier ta fonction si la règle a des exceptions.

Je pense qu'avec les règles que je partage sur mon lien précédent -> https://www.alloprof.qc.ca/fr/eleves/bv/francais/la-syllabe-f1595

Tu devrais déjà en faire pas mal.

@fred1599:
Dans le lien on dit:
> 2. Si deux consonnes sont placées entre deux voyelles, la première appartient à la syllabe précédente, la seconde, à la syllabe suivante.
Comment sépares-tu "périphérique"?
ou "cidre", "replacer", etc.
Pour moi, c'est "pé-ri-phé-ri-que", "ci-dre", "re-pla-ce"
Mon algo résout beaucoup plus que tu ne le penses.
Comme je viens de le mentionner, on peutplacer les exceptions dans un dictionnaire.

J'avoue comme je l'ai mentionné que la séquence 'st' pose problème:

"instable" "constante" donnent-ils "in-sta-ble" et "cons-tan-te" ?

-
Edité par PierrotLeFou 29 novembre 2021 à 19:30:11

-
Edité par Anonyme 29 novembre 2021 à 20:32:37

Le code de Pierrot est pas mal du tout et relativement simple. Je le place ci-dessous, modifié pour notre problème  :

def syllabes(mot):
    # Il peut manquer des séquences ou d'autres seraient invalides, 'st' est douteux.
    sequences = [
        'bl', 'br', 'ch', 'cl', 'cr', 'dr', 'fl', 'fr', 'gl', 'gn', 'gr', 'ph',
        'pl', 'pr', 'st', 'tr', 'vr', 'chl', 'chr', 'phl', 'phr'
    ]
    voyelles = "eiaouy"
    coupures = []
    fin = len(mot)
    c = 0  # Position de la première consonne d'une séquence.
    i = 0
    while i < fin:
        if mot[i] not in voyelles:
            i += 1
        else:
            v = i  # Position de la première voyelle d'une séquence.
            i += 1
            while i < fin and mot[i] in voyelles:
                i += 1  # Sauter toutes les voyelles suivantes.
            # On est soit à la fin, soit sur une consonne.
            p = max(c, v - 1)
            for k in range(
                    v - 2, c - 1, -1
            ):  # Pour toutes les séquences de 2 consonnes ou plus, s'il y en a.
                if mot[k:v] in sequences:
                    p = k
                    break
            coupures.append(p)
            c = i
    coupures.append(fin)
    return [mot[coupures[i]:coupures[i + 1]] for i in range(len(coupures) - 1)]


mots = [
    "theatre", "beaute", "espion", "chapeau", "charite", "articulation",
    "extreme", "textuel", "fermer", "espoir", "quartier", "objet", "admis",
    "canton", "expert", "massif", "acces", "aller", "rachat", "pathos",
    "graphique", "mignon", "sable", "racler", "mufle", "bigle", "duplex",
    "sabre", "nacre", "cadre", "soufre", "maigre", "stupre", "boutre",
    "ouvrir", "compter", "obstine", "marcher", "morphine", "arbre",
    "applaudir", "technique", "camphre", "instruction", "stagnant",
    'perchlorate', 'bonjour', 'bateau', 'france', 'algebre'
]

for m in mots:
    print(m, syllabes(m))

Les meilleures règles que j'aie trouvées : Les coupures de mots à l'écrit

On peut tester en ligne : Syllaber - Découpe et compte de syllabes poétiques

-
Edité par PascalOrtiz 29 novembre 2021 à 20:51:36