- Des ressources de codes de programmation, listes de mots, textes catégorisés et liens

Une base de textes catégorisés
+ Des listes de mots

          Mots-outils   (français, jan-02/aoû-10)
          Mots pleins   (français, jan-99)
          Mots composés   (français, jan-03/jan-05)
          Noms propres   (français, jan-99/a)
          Caractères spéciaux   (français, jan-02/mar-05)
          Abréviations   (français, jan-03/jan-05)
          Verbes auxiliaires conjugués   (français, jan-03/jan-04)
          Verbes auxiliaires et irréguliers    (corse, jun-05, 1.56)
          Olive   (corse, français, juin 2005, jun-05)
          Couleurs   (anglais, juin 2005, jun-05)
          Couleurs   (français, juin 2005, jun-05)
          Constellations (français, mars 2004, mar-04)

+ Un spicilège de codes de programmation

+ Le formatage

+ Le programme de conversion en minuscule en PHP

1. La présentation du programme
2. Le code de la conversion majuscule vers minuscule

+ Les programmes de gestion du format des caractères en PHP

            1.    Les entités HTML
            2.   Les instructions de conversion
                2.1.   De caractère vers entité
                2.2.   De caractère vers entité, apostrophes incluses
                2.3.   De entité vers caractère
                2.4.   De entité vers caractère, apostrophes incluses
                2.5.   De entité numérique vers caractère, apostrophes incluses
                2.6.   Le décodage d’une chaîne à codages imbriqués

+ Le découpage

+ Le programme du découpage lexical en Macro VBA Word

            1.   La description du programme
            2.   Le code de découpage de la ponctuation
            3.   Le code de découpage lexical

+ Le programme du découpage lexical en Python

1. La description du programme
2. Le code de découpage lexical

+ Le triage

+ Le programme des hautes fréquences en Macro VBA Excel

            1.   La présentation du code
            2.   Le code des hautes-fréquences
            3.   Des liens sur les macros

+ Le programme d’ extraction de contenu RSS/ATOM en PHP

            1.   Le format RSS et ATOM
            2.   Les possibilités d’extraction de contenu RSS
                2.1.   Le parcours mot à mot
                2.2.   Les expressions régulières
                2.3.   Le module spécifique ici simpleXML
                2.4.   Le hachage par caractères
                2.5.   La solution appropriée
            3.   La lecture du fichier distant
            4.   La restitution d’un contenu RSS

+ L’ étiquetage

+ Le programme des verbes fléchis pour le corse, en Python

            1.   La présentation du code
            2.   L’ usage de la liste
            3.   Le code de flexion verbale

+ L’utilisation et le code de la catégorisation grammaticale pour le français, en Python

            1.   Le mode d’emploi
            2.   Le déroulement de la catégorisation
            3.   L’ écriture d’une règle
                3.1.   L’ identification
                3.2.   Le contenu
                3.3.   La hiérarchie
            4.   L’ insertion d’une base lexicale
            5.   La catégorisation d’un corpus dans un fichier
            6.   Le résumé des marqueurs
            7.   La correction des règles
            8.   Des erreurs possibles
                8.1.   Des erreurs dans le programme
                8.2.   Des erreurs après la catégorisation

- Des articles d’ études sur le traitement automatique de la langue

+ Les représentations graphiques du texte

         Le balisage graphique d’un texte
           Une disposition graphique
         La lexicométrie , ou statistique lexicale
           Le volume lexical
           L’ accroissement lexical
           La distance lexicale

+ La constitution de ressources, de données, d'énoncés...

         L’ appropriation numérique d’un texte
         Les ressources lexicales   II.1.
         Des tests de catégorisation et de traduction   II.6.
         La base de données lexicale   III.2.

Les logiciels bureautiques II.2.
+ Les logiciels linguistiques II.3.

            1.   Une approche théorique des logiciels de linguistique
            A.   Une copie d’écran de fenêtres emboitées
    +  La description du logiciel Notule

              1.   L’ intérêt
              2.   L’ exploitation
              3.   Les spécifications
              4.   Le téléchargement et l’installation
              5.   Le lancement

+ Les langages de programmation II.4.

+ 1. Une mise en perspective des langages de programmation

              1.1.   Un essai de langages
              1.2.   La rapidité d’exécution
              1.3.   Une comparaison entre PHP et Python

+ Le langage Python II.4.2.

        1.   La présentation du langage Python
        2.   Le principe des chaînes et des listes en Python
          2.1.   Les chaînes en Python
            2.1.A.   Une chaîne avec extraction en Python
          2.2.   Les chaînes en expression : les expressions régulières
            2.2.B.   Une chaîne recherchée en Python
            2.2.C.   Une chaîne modifiée (pas à pas) en Python
            2.2.D.   Une chaîne modifiée (en une seule instruction) en Python
          2.3.   Les listes en Python
            2.3.E.   Une liste imbriquée créant une arborescence en Python
            2.3.F.   Une liste imbriquée au format Notule en Python
            2.3.G.   Le basculement d’une chaîne vers une liste en Python
            2.3.H.   Une liste avec nouvel élément en Python
            2.3.I.   Une liste parcourue en Python
        3.   Des liens pour Python
          3.1.   De la documentation pour Python
          3.2.   Des ressources pour Python
          3.3.   Du code pour Python
          3.4.   Les expressions régulières pour Python
          3.5.   Le traitement linguistique pour Python

+ Le langage PHP II.4.3.

1. La présentation du langage PHP
2. Le traitement du texte en langage PHP

+ La catégorisation du français, description et convention

+ L’ ambiguïté en théorie et en situation

           La gestion de l’ambiguïté   II.5.
           L’écriture d’un catégoriseur    III.1.
           La description catégorielle    III.3.
           Un état des ambiguïtés

+ La convention grammaticale, pour Notule 1.1 IV.

+ Le contenu des étiquettes IV.1.

                  1.   Les élements du texte
                    1.1.    mot et forme
                    1.2.    séquence et syntagme
                    1.3.    phrase et proposition
                  2.   La segmentation du texte
                    2.1.   Le découpage
                    2.2.   Le collage
                  3.   La constitution d’une étiquette
                    3.1.   Le lemme
                  4.   Le résumé de la terminologie
                  5.   La morphologie
                    5.1.   Le genre, nombre et personne
                    5.2.   L’ accord
                    5.3.   La casse
                  6.   La ponctuation
                    6.1.   Le format
                    6.2.   Les traits
                    6.3.   Les difficultés
                  7.   La forme
                    7.1.   L’ abrégé
                    7.2.   L’ inconnu
                    7.3.   Le composé
                  8.   Une bibliographie
                  9.   Des liens
                  A.   Le journal l’aurore

Le résumé des balises en usage dans Notule 1.1
+ La description des mots composés IV.2.

                  1.   Le classement
                  2.   Les critères sémantiques essentiels
                    2.1.   La distance analogique
                    2.2.   La description de la reconstruction
                    2.3.   L’ unicité du référent
                  3.   Les critères propres à la catégorisation
                    3.1.   Le changement catégoriel
                    3.2.   La finalité de la catégorisation
                    3.3.   La fréquence d’apparition
                  4.   Le critère lexical et sémantique de soutien
                    4.1.   Les opérations sur un énoncé
                      4.1.1.   Les suppressions et insertions
                      4.1.2.   La substitution
                      4.1.3.   La reprise
                    4.2.   La productivité
                    4.3.   Le contexte lexical et la complémentarité
                    4.4.   La construction syntaxique
                    4.5.   La modalisation
                    4.6.   La spécificité morphologique et lexicologique
                  5.   Un résumé de la terminologie
                  6.   Une synthèse des critères
                  7.   Les perspectives
                  8.   Une bibliographie
                  9.   Des instructions
                    9.1.   La suppression du figement
                    9.2.   La désambiguïsation de base

           Les catégories    IV.3.
               La description des adjectifs, noms et déterminants    IV.3.1. IV.3.2. IV.3.3.
               La description des adverbes et des pronoms    IV.3.4. IV.3.5.
               La description des prépositions et des conjonctions    IV.3.6. IV.3.7.
               La description des verbes conjugués et infinitifs    IV.3.8. IV.3.9.
               La description des participes passés et présents    IV.3.10. IV.3.11.
      +  La revue des mots-outils    IV.4.

            .        1.    ainsi
            .        2.    aucun
            .        3.    aussi
            .        4.    autre
            .        5.    beaucoup
            .        6.    bien
            .        7.    certain
            .        8.    chaque
            .        9.    comme
            .         10.    comment combien pourquoi
            .         11.    de
            .         12.    des
            .         13.    devant durant suivant maintenant
            .         14.    différent
            .         15.    divers
            .         16.    la le
            .         17.    maint
            .         18.    même
            .         19.    neuf
            .         20.    nul
            .         21.    où
            .         22.    pendant
            .         23.    plusieurs
            .         24.    pour
            .         25.    quand
            .         26.    quelconque
            .         27.    quelque
            .         28.    si
            .         29.    tel
            .         31.    tout
            .         31.    un
            .         32.    bibliographie

               Le récapitulatif des énoncés des mots-outils
           La description du mot subordonnant «que»    IV.5.
           Les ontologies ou listes de mots   IV.6.

+ Une réflexion sur le T.A.L., ses applications et ses fondements

+ Des préalables à un développement du T.A.L. I.

             Le contraste de technologies    I.1.
             Une proximité de disciplines    I.2.
             Un cadre culturel    I.3.
             La stratégie de programmation pour l’objet langue   I.4.

+ Les perspectives en matière d’ingénierie linguistique V.

             Les traducteurs    V.1.
             Les moteurs de recherche    V.2.
             Les agrégateurs    V.3.

- Les pages du site pour des recherches, informations, résumés...

       Une description des pages du site
      Le sommaire des pages du site
       Prendre contact avec le webmestre
       Une bibliographie sur le TAL, classée par sujet
       Les licences des ressources
       Le moteur de recherche interne
       L’ actualité de la lexicométrie et du TAL

1. II.4.2.1. présentation du langage Python

Python a été écrit en 1990 par Guido Van Rossum à l’Université d’Amsterdam. Il est revendiqué comme libre de droit. La licence Python l’expose compatible GPL et l’article wikipédia le dit proche de la BSD. Il s’inscrit ainsi dans la philosophie du logiciel libre, consistant à ouvrir le code source pour laisser toute possibilité d’adaptation, d’amélioration et dans une certaine mesure d’appropriation. Il sert à de nombreux types d'applications, comme le logiciel libre de 3D, Blender, et le site officiel met en avant son utilisation dans des réalisations par la Nasa ou Google.

Il est généralement comparé à d’autres langages comme Java ou Perl. Des sites dédiés et des articles font état du classement des langages, (most popular programming languages), et situent Python dans les dix plus utilisés. Les hébergeurs de site les plus connus le proposent aux côtés de Perl et de PHP pour l’exécution de script côté serveur (pour la version 2.x). Ce dernier n’est pas nécessairement en concurrence, notamment parce que Python est plus généraliste qu’un PHP plus spécifique à Internet. Même si Python est moins à l’aise avec Internet, avec moins de fonctions natives consacrées à cet environnement que PHP, il permet de développer un même programme pour en faire un logiciel instalable et une application en ligne. En prenant en compte quelques éléments (les versions de Python, l’entête d’identification et l’affichage HTML du programme, et les ressources de la machine sollicitée), un même code en .py s’exécute sur Linux, sur Windows, avec une interface graphique, se compile en un exécutable Windows .exe ou tourne en tâche de fond sur un serveur distant Linux.

Des documentations bien conçues et en français existent format PDF, pour l’initiation, en synthèse, et pour des approches plus approfondies. C’est cette documentation qui a servi pour la création de notre programme de catégorisation. Son installation et son lancement sont simples, et, comme les langages Basic équipant les micro-ordinateurs des années 80 ou le DOS, une saisie peut s’opérer dans une console, ce qui permet de tester des lignes de commandes sans avoir à sauvegarder et lancer un programme.

Ses points faibles sont sa lenteur, qui concerne malheureusement tous les langages non compilés, c'est-à-dire à l'inverse de C++ ou Java, qui se chargent eux-même de la compilation, encore que ce dernier soit loin d'être une référence en la matière. L'on pourrait évoquer la difficulté d’installation et d’exploitation de certains modules (Gadfly pour les bases de données, PyExe pour en faire un exécutable sous Windows) à l'opposé de la facilité d'autres librairies (Re pour les expressions régulières, TKinter pour le graphisme), les quelques ratés de compatibilité d'une version à l'autre, problème récurrent de tout langage de programmation, que cependant l'accès libre permet parfois de résoudre. Question encore d'actualité, avec les ratés entre PHP version 4 et 5, ou la dernière version de Python, la 3.x. (actuellement la 3.2.) qui est remaniement des fondements du langage. Il faut espérer une transition sans trop de difficulté pour les applications déjà existantes afin d’éviter la coexistence de deux Python. Les évolutions de la version 2.x paraissent avoir cessé avec la 2.7.2. de juin 2011.

Sa syntaxe apparaît simple, ainsi à vocation pédagogique, et n’est pas sans rappeler le Basic, dont le prototype de Python, le langage ABC, se concevait d’ailleurs comme son successeur. L’écriture du code est indentée et offre donc une clarté dans la mise en page, facilitant la recherche d’informations et la compréhension du programme par un tiers. Ce qui se révèle particulièrement intéressant pour améliorer un système qui est expérimental et qui nécessite d’être constamment mis à l'épreuve. Si elle est aussi source de certaines erreurs et de peu d'amplitude, elle est à l’usage simple et pratique, et s’assortit assez bien avec l’esprit de la programmation objet, suggérant l’écriture de procédures courtes.

Python est orienté objet, c’est-à-dire facilitant la réutilisation de morceaux du programme aux fonctions similaires, évitant la réécriture permanente, une architecture trop linéaire, et donc la surcharge dans la rédaction. Elle permet d’envisager une programmation modulaire et la fabrication de logiciels importants par la taille. Les versions récentes de langages comme PHP (5) ou Perl l'ont intégrée ou développée. Si l’orientation objet est native en Python, à savoir inhérente au langage, elle n’est pas un handicap à la rédaction de programmes, contrairement par exemple à JavaScript qui implique de se familiariser assez rapidement avec le concept d'association des méthodes à leur objet. Il s'agit d'une caractéristique de ce langage : la programmation multi-paradigme, qui laisse une liberté de stratégie pour la rédaction du code.

2. II.4.2.2. le principe des chaînes et des listes

Le principe des chaînes de caractères et des listes est décrit afin d’illustrer les phases de catégorisation, comme le découpage du texte en mot. L'écriture repose entièrement sur les crochets. Cette convention est plus souple que C++ ou PHP, qui supposent de définir l'équivalent des listes : les tableaux, en array.

Les chaînes (§ 2.1.) traitent la forme de caractère en caractère, où la notion de mot est absente, puisque le texte est considéré comme un bloc de lettres. Les expressions (§ 2.2.) sont des chaînes à multiples paradigmes, permettant d'effectuer des manipulations complexes de lettres et de groupes de lettres (et donc atteindre le niveau du mot). Les listes (§ 2.3.) traitent une forme comme un bloc de caractères, forme par forme, autrement dit en mots ou en syntagmes. Les chaînes et les listes peuvent être imbriquées, pour gérer autant le détail d’une forme que la forme elle-même par rapport à d’autres. Les listes imbriquées sont aussi appelées tableau multi-dimensionnel.

Ce sont ces niveaux de manipulations qui vont permettre de matérialiser tous les morceaux d’opérations pour un traitement global du texte. L’important pour la linguistique est de retenir les concepts de métaplasme (modification de la chaîne) de niveau syntagmatique (liste) d'arborescence (liste imbriquée) et de basculement (passage de la liste à la chaîne), et retrouver ainsi les différents niveaux d’analyse du texte, du morphème (chaîne) à la phrase (liste).

2.1. II.4.2.2.1. chaînes

 
              >>> b = 'langage'

              >>> b[3][-3:]

              'age'

2.1.A. Chaîne avec extraction

L’extraction d’information nous permet par exemple de demander les trois derniers caractères de la dernière forme, un suffixe : l’instruction b[3][-3:] affiche « age ». La première information est son rang dans la liste, à partir de zéro et la seconde est son rang dans la chaîne en partant de la fin. Il s'agit d'une apocope, mais comme la suppression des graphèmes ne tient pas compte de la phonétique, la tranche peut-être arbitraire.

2.2. II.4.2.2.2. chaînes en expression

Exemple rare de compatibilité entre instructions de base d’un langage de programmation, une expression régulière est identique ou s’adapte facilement en Perl, en PHP ou en Python.

 
                  >>> import re

                    >>> if re.compile("\d\dh\d\d").search(u"il était 14h45.") is not None:print "trouvé ! "
            
            'trouvé !'

2.2.B. Chaîne recherchée

La première ligne est l'importation du module des expressions régulières. La ligne suivante demande de chercher n'importe quel décimal à deux chiffres suivi d'un « h » puis de deux autres décimaux. Si cela est le cas, il est affiche « trouvé ! ». Le u (pour unicode) après l'instruction search spécifie que la chaîne peut contenir des accents.

 
                  >>> import re

                    >>> mot_ou_expression= " (\w)\."

            >>> phrase="Python 2.6 est un langage..."

            >>> remplacement= " \\1#"

            >>> e=re.compile(mot_ou_expression)

            >>> f=e.sub(remplacement,phrase) 

            >>> print f 

            'Python 2#6 est un langage...'

2.2.C. Chaîne modifiée (pas à pas)

Pour traiter par exemple les sigles : la ligne 5 demande de repérer n’importe quel caractère précédé d'un espace suivi d’un point, puis la suivante de reprendre ce caractère et ce point pour en changer juste le point en dièse. L’intérêt est de ne pas simplement remplacer tous les points mais seulement un caractère plus un point.

 
          >>> re.sub(" (\w)\."," \\1#","Python 2.6 est un langage...") 

		    'Python 2#6 est un langage...'

2.2.D. Chaîne modifiée (en une seule instruction)

2.3. II.4.2.2.3. listes

 
          >>>  a=["Python","2.6"]

          >>> b=[a,"est","un","langage"]

          >>> b

          [['Python', '2.6'], 'est', 'un', 'langage']

          >>> b[0]

          ['Python', '2.6']

          >>> b[0][1]

          '2.6'

2.3.E. Liste imbriquée créant une arborescence

Nous entrons à la ligne 1 une variable a possédant les valeurs « python » et « 2.4 », qui correspondront respectivement aux positions 0 et 1. La ligne 2 inclut a dans b pour les valeurs « python » « 2.5 » en position 0, et « est », « un », « langage » respectivement en postion 1, 2 et 3. À la ligne 3, la demande d'affichage de b nous donne donc les valeurs avec une liste imbriquée. À la ligne 6, l'affichage de b pour la seule position zéro donne les deux valeurs. À la ligne suivante est demandée à l'intérieur de cette liste une autre position, celle à 1, et affiche donc « 2.5 » à la ligne 8.

 
              >>> etiquette=[[['ai'], ['*avoir', 'Ver:IPac+SG+P1'], ['/amb'], ['info']], [['vraiment'], ['*vraiment', 'Adv:Manr'], ['/amb'], ['info']], [['trouv\xe9'], ['*trouver', 'Vpp:PPas+Mas+SG'], ['/amb'], ['info']]]

              >>> etiquette[0][0][0]

      'ai'

      >>> etiquette[0][1][1]

      'Ver:IPac+SG+P1'

2.3.F. Liste imbriquée au format Notule

La ligne 1 contient le format d'une étiquette pour notre programme de catégorisation. En première position se trouve la forme, puis la nature, c'est-à-dire le lemme et sa classe, ensuite, en troisième, son marqueur, et enfin une éventuelle information, ici par défaut neutre. La ligne 2 appelle la position de la forme, et la 4, celle de la classe. C'est à partir de cette étiquette que vont s’appliquer les règles et que vont être éliminées les autres natures (ou choisie la bonne).

 
          >>>        import 
          string

          >>> b=["Python","est","un","langage"]

          >>> c=string.join(b)

          >>> c

          'Python est un langage'

          >>> d=string.split(c)

          >>> d

        ['Python', 'est', 'un', 'langage']

2.3.G. Basculement d’une chaîne vers une liste

Un basculement s’effectue entre le niveau chaîne et le niveau liste pour par exemple transformer « python », « est », « un », « langage » en « python est un langage », et vice versa, disponible dans le module string. Le point de repère pour le découpage ou la soudure est par défaut l’espace, et peut être défini, par exemple le point-virgule : string.split(c,";").

 
          >>> d[1:1]=["2.6"]

          >>> d.append("...") 
          
          >>> d=' '.join(d)

          >>> d

          'Python 2.6 est un langage ...'

2.3.H. Liste avec nouvel élément

Une fois l’énoncé découpé en liste, il est possible de manipuler celle-ci, puis de revenir à une chaîne. La première instruction insère une chaîne numérique dans la liste, la deuxième ajoute les points de suspension en fin de liste, puis la troisième ligne la ramène à une chaîne. Les lignes 2 et 3 montrent aussi une syntaxe un peu différente, correspondant respectivement à d[len(d):]=["..."] et à d=string.join(d).

 
            >>> for g in b:

                   print g,

        'Python  est un langage'

2.3.I. Liste parcourue

La manipulation de listes a aussi lieu avec son parcours. C’est cette phase qui nécessite le plus de temps et qui doit retenir l’attention pour pallier la difficulté, différenciant vraisemblablement une programmation de moindre qualité qui déroule systématiquement le corpus, d’une rédaction plus fine qui se rend là où l’information est la plus pertinente, évitant ainsi que la boucle ne passe par de nombreuses phases de vides.

L’instruction va afficher chaque valeur de g, c’est-à-dire chaque forme de la variable b. La virgule accrochant simplement la forme précédente.

3. II.4.2.3. liens

3.1. II.4.2.3.1. documentation

     Installation, détaillée, (Calogero Gigante)  « Gigante »
http://www.gigante.be/index.php/site/art/3/installation_de_python_sous_vista
     Installation, synthétique, (Guillaume Duriaud)  « Développez.com »
http://guigui.developpez.com/Tutoriel/Python/PythonWindows/
     Cours débutant, (Gérard Swinnen)  « Inforef »
http://inforef.be/swi/python.htm
     Cours pédagogique, (6pri1 et prolixe)  « Site du Zéro »
http://www.siteduzero.com/tutoriel-3-223267-apprendre-python.html
     Cours synthétique, (Jérôme Tschanz)  « Ceramiko »
http://python.50webs.com/
     Cours approfondi, (Mark Pilgrim & Alexandre Drahon)  « Plongez au coeur de Python »
http://diveintopython.adrahon.org/
     Documentation officielle traduite, (Olivier Berger)  « olivierberger »
http://olivierberger.org/python/

3.2. II.4.2.3.2. ressources

     Liens, « Python-eggs »
http://www.python-eggs.org/links.html
     Tutoriels, « Développez.com »
http://python.developpez.com/
     Officiel, en anglais « Python.org »
http://www.python.org
     Association Francophone PYthon, « AFPY »
http://afpy.org/

3.3. II.4.2.3.3. code

     FAQ, « Développez.com »
http://python.developpez.com/faq/?page=sommaire/
     IAQ, Infrequently Answered Questions, en anglais « Peter Norvig »
http://www.norvig.com/python-iaq.html
     Astuces et divers codes, « Wikipython »
http://wikipython.flibuste.net/
     Initiation et réalisations en vidéo, « Pythonneries »
http://www.dailymotion.com/user/pythonneries/1

3.4. II.4.2.3.4. expressions régulières

     Description détaillée, en anglais « Regular expression operations »
http://docs.python.org/library/re.html
     Description synthétique, en anglais « Regular expressions »
http://www.regular-expressions.info/python.html
     Approfondi, (A.M. Kuchling) en anglais « Regular Expression HOWTO »
http://docs.python.org/howto/regex.html
     Exemples détaillés de « Plongez au coeur de Python »
http://diveintopython.adrahon.org/regular_expressions/index.html

3.5. II.4.2.3.5. traitement linguistique

Chiffres romains, de « Plongez au coeur de Python »
http://diveintopython.adrahon.org/unit_testing/index.html
Boîte à outils et corpus, en anglais « Natural language Toolkit »
http://www.nltk.org/

Site motte 0.5	Imprimer
Rédaction : 01.04.2004 Publication : 10.02.2006 Révision : 01.12.2011 http://cadrat.saynete.net2003 - 2012