c
a
d
r
a
t






  Entrée  
  Ressources   
  Code  
  Découpage  











      Python  
     Découpage lexical avancé
 .1.  Explication du programme
 .2.  Code

 .1.   Explication du programme

Le découpage d'un texte en mot est l'une des toutes premières opérations de traitement de la langue par l'ordinateur. Les modifications concernent essentiellement la ponctuation. Les mots composés à blanc, famille des « pomme de terre », sont une problématique différente et nettement plus complexe. Parmi les difficultés saillantes se trouvent l’apostrophe pour certaines constructions nominales ; le tiret pour les inversions verbales dans les interrogatives ; et surtout le point, qui peut être final, de suspension et entrer dans la composition des sigles.

Le programme décolle la ponctuation, comme le point ou l'apostrophe, sépare les constructions Verbe + Pronom et les mots-outils reliés par un trait d'union, il prend aussi en compte les sigles, et les mots à l'apostrophe figée. L'on obtient donc un texte ou chaque forme est séparée de la précédente selon des critères linguistiques. La ligne 260 est à supprimer pour ne pas remplacer les apostrophes par des dièses.

Le code est constitué de cinq procédures. Il utilise des boucles pour les listes, et pour les chaînes de caractères des expressions régulières, faisant usage du remplacement d'une expression par une autre. Il est souhaitable d'éviter le copier/coller à partir du code ci-dessous vers l'interface python, mais plutôt de télécharger le fichier. En domaine public, il a été extrait du programme Notule.

Le passage de Python 2.1 à 2.3 ou plus peut générer un code d'erreur si l'on utilise des caractères accentués. Pour résoudre le problème, allez dans le fichier lib/site.py , qui a comme valeur par défaut encoding = "ISO-8859-1" (à la ligne 289) et le remplacer par encoding = "ASCII" (voir forum de lists.samba.org). Il existe aussi la possibilité d'entrer l'instruction # -*- coding:cp1252 -*- en début du programme. La version 2.2a ne lit pas le caractère et plante Python. Le bug est corrigé pour les versions ultérieures. Le nettoyage du corpus de départ doit donc comporté un remplacement de (en html : …) par ... .

 .2.   Code du découpage lexical

          



# -*- coding:cp1252 -*-
    # Le programme de découpage lexical pour le français est une partie du logiciel Notule, sous licence GNU GPL et peut être utilisé de façon autonome, comme les programmes du I.
    # En conséquence les parties I et II sont laissées au domaine public.
    # 14.11.2004/30.10.2007, par Vincent Comiti, http://cadrat.saynete.net , vincent@saynete.net
   
def DecoupPonc(corp,lis):
    # Découpage de forme, par Liste, Boucle et Remplacement.
    # Chaque élément d'une liste est remplacé par celui immédiatement à droite, progressant de deux en deux.
    # Le principe de la liste binome est pratique, donc réutilisable. Elle va essentiellement servir à la ponctuation.
   
    for m in range(0,len(lis),2):      # Boucle
        corp=corp.replace(lis[m],lis[m+1]) # Remplacement d'un élément du premier élément.
   
    return corp                # Renvoie la valeur corp modifiée (le corpus textuel).
   
def DecoupPonc_maj(corp,lis):
    # Découpage de la ponctuation majuscule, par Liste, Boucle et Remplacement.
    # Procédure semblable à DecoupPonc mais tenant compte d'une majusculee n début du mot.
   
    for m in range(0,len(lis),2):                     # Boucle où chaque élément d'une liste est remplacé par celui immédiatement à droite, progressant de deux en deux.
        lis_u=string.upper(lis[m][0])+lis[m][1:len(lis[m])]      # Pour la première forme, le premier caractère de la chaîne est changé en majuscule, et le reste recopié tel quel.
        lis_up=string.upper(lis[m+1][0])+lis[m+1][1:len(lis[m+1])] # Idem que le précédent, pour la seconde forme.
        corp=corp.replace(lis_u,lis_up)                # Remplacement d'un élément par un autre.
   
    return corp                               # Renvoie la valeur corp.
   
def DecoupComp(corp):
    # Découpage des verbes et pronoms, par Liste, Boucle et Remplacement.
    # La méthode consiste à remplacer chaque forme à trait d'union part des espaces, et entourer le trait d'union : <->
   
    lis_com = ["nous","vous","les","la","là","leurs","je","tu","ils","elles","ci","mêmes","eux","lui","moi","toi","en","y","t","ce","on","-","il","elle","même","le","leur"] # Tableaux des formes susceptibles d'être découpées
   
    for n in range(len(lis_com)):      # Boucle de parcours de la liste précédente,
        un="-"+lis_com[n]+"-"      # Chaîne où une forme se trouve prise entre deux traits d'union.
        deux=" <-> "+lis_com[n]+ " <-> " # Chaîne avec les blancs et le trait d'union entouré.
        corp=corp.replace(un,deux)      # Remplacement de la première chaîne par la deuxième.
        un_fin="-"+lis_com[n]+" "      # Chaîne où une forme se trouve prise entre un trait d'union et un blanc
        deux_fin=" <-> "+lis_com[n]+" "
        corp=corp.replace(un_fin,deux_fin)
   
    return corp                # Renvoie la valeur corp (pour corpus) modifiée.
   
def DecoupAcro(corp):
    # Découpage des acronymes et mots abrégés, par Expressions régulières.
    # La méthode consiste à répérer les combinaisons majuscule + point + majuscule.
    # Il s'agit de remplacer tout point qui n'est pas une ponctuation forte par le dièse.
   
    # En cas de cumul de ponctuation accolée, les points de suspension sont changés #. (De nombreuses combinaisons sont possibles)
    corp=corp.replace("...,","###,")
   
    # Mot abrégé, S.N.C.M.
    # \w signifie n'importe quel caractère alphanumérique, \. signifie un point
    # Les expressions entre paranthèses comme (\w) peuvent être conservées, afin d'être remplacée par elle-même. Elles deviennent \\1 dans l'instruction suivante (puis \\2 puis \\3...)
   
    # Initiale du mot abrégé. Type prénom M. Falcone, et monsieur M. Dupont
    mod=re.compile(" ([A-Z])\. ") # Toute lettre majuscule suivie d'un point, et isolée, et considérée comme abréviation
    corp=mod.sub(" \\1# ",corp) # Elle est reportée et le point changé en dièse. Ce qui pose l'ambiguïté, « multiplié par I. »
    mod=re.compile(" ([a-z])\. ([a-z])") # Exception à l'ambiguité une abréviation minuscule du type « J'ai donné à m. le paquet. »
    corp=mod.sub(" \\1# \\2",corp) # l'indice étant la minuscule, de « le »
   
    # Initiale et suite du mot abrégé, S.N
    for a in range(2):      # Répétition de l'instruction afin de compléter entièrement l'abréviation.
        mod=re.compile("(\w)\.(\w)") # La variable mod devient un (/w) suivi d'un point \. et d'un autre (\w)
        corp=mod.sub("\\1#\\2",corp) # mod est remplacé par le caractère entre paranthèse (\w) conservé, puis le second caractère le point permute avec le dièse, enfin le troisème (\w) est aussi conservé.
    # Fin du mot abrégé, M.
    mod=re.compile("#(\w)\.")
    corp=mod.sub("#\\1#",corp)
   
    # Abréviations G...
    # Une majuscule plus point de suspension suivi d'un blanc et d'une minuscule est une abréviation.
    # Ce découpage entraîne une erreur d'aiguillage si une phrase commence sans majuscule (pour le point)
    mod=re.compile("([A-Z]|[À-Ý])\.\.\. ([a-z]|[à-ý]|[!-@])")
    corp=mod.sub("\\1### \\2",corp)
   
    # Abréviations 18... (pour une date intentionnellement floue)
    # Deux chiffres plus un point de suspension suivi d'un blanc et d'une minuscule est une abréviation.
    mod=re.compile("( [0-9][0-9])\.\.\. ([a-z]|[à-ý]|[!-@])")
    corp=mod.sub("\\1### \\2",corp)
   
    # Abréviations G.
    mod=re.compile("([A-Z]|[À-Ý])\. ([a-z]|[à-ý])")
    corp=mod.sub("\\1# \\2",corp)
    return corp # Renvoie la valeur corp
   
def Format(corp):
    # Découpage du texte corp, par appel des Procédures.
    corp=corp.replace("\n"," ")
    # Procédure principale usant de la découpe des mots-composés et de la ponctuation.
    corp=DecoupAcro(corp)
   
    # La méthode utilise le principe binome, c'est à dire une ponctuation remplacée par un blanc + elle-même.
    # La progression est importante, afin d'éviter le chevauchement du point et des points de suspension (pachopacho).
    mot_ponc=['"',' " ',"...","pachopacho","."," .","pachopacho"," ...",","," ,","(","( ",")"," )","'","' "]
    corp=DecoupPonc(corp,mot_ponc)
   
    # Première série d'exception. Le principe binome est appliqué pour recoller les mots composés à apostrophe.
    mot_fus=["aujourd' hui","aujourd'hui","pin' s","pin's","présqu' île","présqu'île","m' as-tu-vu","m'as-tu-vu","prud' ","prud'","entr' ","entr'","jusqu' au-bout","jusqu'au-bout","je-m' en-","je-m'en-","-l' ","-l'","-d' ","-d'","d' abord","d'abord","quelqu' un","quelqu'un","mm .","mm.","MM .","MM.", "M .","M.","[ ...]","[...]"]
    corp=DecoupPonc(corp,mot_fus)
    corp=DecoupPonc_maj(corp,mot_fus)
   
    # Découpage des verbes et pronoms.
    corp=DecoupComp(corp)
   
    # Date essai
    mois=["janvier","février","mars","avril","mai","juin","juillet","août","septembre","octobre","novembre","décembre"]
    mois.append("en")
    for dts in range(0,10):
         for dtspre in mois:
         corp=corp.replace(dtspre+" 18"+str(dts)+" ...",dtspre+" 18"+str(dts)+"...")
         corp=corp.replace(dtspre+" 17"+str(dts)+" ...",dtspre+" 17"+str(dts)+"...")
         corp=corp.replace(dtspre+" 16"+str(dts)+" ...",dtspre+" 16"+str(dts)+"...")
   
   
    # Rétablissement des points de suspension par le point.
    corp=corp.replace("#",".")
   
    corp=DecoupPonc(corp,[" <-> le <-> ","-le-"])
    corp=corp.replace("'","#") # Remplacement des apostrophes par le dièse, à supprimer pour un usage autonome
    corp = corp.split()

import string # Module des chaînes de caractères
import re     # Module des expressions régulières
corpus=""" M. Jean s'est exclamé, en allumant sa T.S.F. : "Bonjour, Monde !". """ # Triple guillemets pour mêler les guillemets et les apostrophes.
corp=Format(corpus) # Lance la procédure principale
for mot in corp:print mot,          # Affiche le texte modifié
 
          



     Le langage Python    II.4.2.  
     Adresses pour le langage Python 

       Site       motte 0.5  
       Imprimer  
     Le code du découpage lexical avancé 
     La page d’accueil
     Le sommaire des pages
     Rédaction : 01.02.2003      Publication : 14.11.2004     Révision : 13.10.2006
      http://cadrat.saynete.net2003 - 2012