c
a
d
r
a
t






  Entrée  
   Ressources   
    Code  
     Découpage  
 
+  Des ressources en corpus, isotopies et programmes
+  Des articles d’ études sur le traitement automatique de la langue
+  Les pages du site pour des recherches, informations, résumés...


 
     le programme du découpage lexical en Python   
La segmentation détaillée des mots d’un texte selon des critères linguistiques, en Python

 

 1.  description 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. 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. Les mots composés à blanc, du type « pomme de terre », sont une problématique à part et plus complexe.

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. L'actuelle version est compatible pour Python version 2 et 3.

Les caractères accentués peuvent générer un code d'erreur. 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. Le problème se pose aussi pour les entités HTML selon la version la langage. La version 2.2a ne lit pas le caractère . Le bug est corrigé pour les versions ultérieures. Le nettoyage du corpus de départ doit donc comporter des remplacements, pour par exemple (en html : …) par ... .

 2.  code de découpage lexical

          
    # !/usr/bin/python
    # -*- coding:cp1252 -*-
    # Découpage lexical avancé pour le français - 14.11.2004, version 1.1 du 12.07.2015, par Vincent Comiti, http://cadrat.saynete.net - Python 2 et 3.
   
    import sys # Module des informations systèmes, pour compatibilité entre Python 2 et 3
    import string # Module des chaînes de caractères
    import re # Module des expressions régulières
   
    # Compatibilité Python 2 et 3
def SysVersionPython():
    return (sys.version_info[0])
   
    # Transforme minuscule en majuscule - Compatibilité Python 2 et 3
def ChaineMajusculeSys(chaine):
    compatibillite = SysVersionPython()
    if (compatibillite==2): return string.upper(chaine)
    if (compatibillite==3): return chaine.upper()
   
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.
   
    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=ChaineMajusculeSys(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=ChaineMajusculeSys(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 celle-ci : <->
   
    # Liste des formes susceptibles d'être découpées
    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"]
   
   
    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 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 si une phrase commence sans majuscule (pour le point)
    mod=re.compile("([A-Z]|[À-Ý])\.\.\. ([a-z]|[à-ý]|[!-@])")# [A-Z]|[À-Ý] signifie tous les caractères entre A et Z, c'est à dire l'alphabet majuscule et | les mêmes avec les diacritiques
    corp=mod.sub("\\1### \\2",corp)
   
    # Abréviations 18... (pour une date intentionnellement floue)
    # Une majuscule plus 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.
   
    # 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, et les problèmes générés par le décollage.
    mot_fus=["aujourd' hui","aujourd'hui","pin' s","pin's","presqu' île","presqu'î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)
   
    # Rétablissement des points de suspension par le point.
    corp=corp.replace("#",".")
   
    return corp # Renvoie la valeur corp (le corpus textuel) modifiée
   
   corpus="""Aujourd'hui M. Jean s'est exclamé, en allumant sa T.S.F. : "Bonjour, Monde !".""" # Triple guillemets pour inclure les guillemets et les apostrophes.
   corp=Format(corpus) # Lance la procédure principale
   
   texte_sorti = "Content-type: text/html\n\n"
   texte_sorti +=corp
   
   print (texte_sorti)
          



     Le langage Python    II.3.2.  
     Liens sur le langage Python    II.3.2.3.  

       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 / 12.07.2015
      http://cadrat.saynete.net2003 - 2018