• Quickstart
  • Installation
  • Premier pas
  • Chercher un élément
  • Trouver une liste d'éléments
  • Formuler un mot
  • Insérer un mot dans le dictionnaire
  • Savoir si un mot est connu
• Utilisation précommandé
  • La structure d'un word (mot)
• API Dictionary
• Configuration
  • Changer la configuration a l'exécution
• Les codes
• Utilisation avancée

Ouvrez un terminal et entrez le code ci-dessous (sur Windows un git bash est recommandé):

    cd <your_repository>
    git clone http://git.spacink.xyz/VictoriaEngin/dictionary.git

Commencez par importer la class Dictionary, celle-ci va nous permettre d'effectuer les différentes actions décrite plus bas.

    from dictionary import Dictionary
    
    # Crée une nouvelle instance for les prochaines étapes
    dictionary = Dictionary(
	    # path='dictionary'
    )

Nous allons tenter de chercher un mot dans notre dictionnaire et afficher les informations sur celui-ci.

    # Chercher un élément avec 'avoir' comme étiquette
    mot = dictionary['avoir']
    
    print(dictionary.beautify(mot))

{
   "label": "avoir",
   "type": "verbe",
   "lem": "avoir",
   "tags": "V+z1:W",
   "flexional": 
   [
      [ "infinitif" ]
   ],
   "semantic": 
   [
      "langage courant"
   ]
}

Rechercher un mot peut se faire de différentes manière. La comparaison des mots se fait par son label et si le type est renseigné, celui-ci est également prit en compte.

    # Chercher des éléments avec 'avoir' comme étiquette et de type 'verbe'
    mots = dictionary.find('avoir')
    
    print([dictionary.beautify(mot) for mot in mots])

[
  {
    "label": "avoir",
    "lem": "avoir",
    "tags": "V+z1:W",
    "flexional": [
      [
        "infinitif"
      ]
    ],
    "semantic": [
      "langage courant"
    ]
  },
  {
    "label": "avoir",
    "lem": "avoir",
    "tags": "N+z1:ms",
    "flexional": [
      [
        "masculin",
        "singulier"
      ]
    ],
    "semantic": [
      "langage courant"
    ]
  }
]

NOTE La méthode pour chercher un élément vu précédemment (__getitem__) utilise celle-ci pour vous renvoyer un résultat.

A partir de la lemmatisation d'un mot, il est possible de connaitre les différentes formes qu'un mot peut prendre, par exemple trouver le féminin pluriel d'un mot.

Ici nous allons tenter de conjuguer le verbe avoir:

    resultat = dictionary.compose(
	    'avoir',
	    type='verbe'
	    flexional=[
		    'présent de l’indicatif',
		    '1st personne',
		    'singulier'
	    ]
    )
    
    print(resultat)

[
   {
      "label":"ai",
      "lem":"avoir",
      "tags":"V+z1:P1s",
      "flexional":[
         [
            "présent de l’indicatif",
            "1st personne",
            "singulier"
         ]
      ],
      "semantic":[
         "langage courant"
      ]
   }
]

Il peut être utile parfois de savoir si un mot est connu de notre dictionnaire ou non.

L'exemple qui suit va vous aider a mieux comprendre :

    print('avoir' in dictionary)

    True

Pour clôturer cette introduction, nous allons nous intéresser a l'ajout de mots. Une opération qui vous sera très certainement utile pour étoffer vos dictionnaires ou dans d'autres cas d'utilisations.

Tentons d'insérer un mot avec quelques informations le concernant:

    mot = dictionary.insert(
	    'zinzin',
	    type='adjectif'
	    semantic=[
		    'langage courant'
	    ]
	    sens=[{
		 'definition': "Ce dit d'une personne ayant un comportement se rapportant a de la stupidité",
		 'examples': [
			 "Il est complêtement zinzin lui"
		 ],
		 'synonyms': [
			 'fou', 'folle', 'bête'
		 ]   
	    }]
    )

NOTE Qui dit ajout, dit suppression ?

En réalité, nous n'avons pas besoin de nous pré-occuper de ce facteur. Car, afin d'assurer des temps de traitement optimaux, la librairie gère la suppression de données inutilisées.

Néanmoins il reste possible de supprimer des éléments, nous verrons cela dans les utilisations avancées.

Plus bas nous verrons comment configurer notre dictionnaire selon nos préférences.

graph LR
A((Dictionary)) -- text --> B(__getitem__)
A -- label=text --> C(find)
A -- lem=text --> D(compose)
A -- label=text --> E(insert)
A -- text --> F(__contains__)
B -- word --> G[Fonctions*]
C -- word --> G
D -- word --> G
E -- word --> G
G -- word --> G
G -- word --> H(beautify)

Ci-dessus un graphe représentant l'ordre des actions possible. Néanmoins cela ne reste qu'une schématisation simplifié.

*Fonctions: Ensemble des fonctions qui compose la class Dictionary prenant un word en argument.

Liste des fonctions qui compris dans cet ensemble:

• get_infos_on
• update
• add_sens
• add_quote
• add_difficulty
• __contains__
• insert (**word)
• find (**word)

• word:
  • label
  • type
  • lem
  • tags
  • flexional
  • semantic
  • sens
    • definition
    • examples
    • synonyms
  • homonyms
  • difficulties
    • type
    • text
  • quotes
    • text
    • author
    • infos
    • infosAuthor

Pour plus d'information, veuillez consulter la documentation.

L'API Dictionary est un service en ligne externe utilisé pour récupérer des informations sur internet concernant un mot.

Celui-ci est intégré a la class Dictionary et par défaut contient un certain nombre d'informations en base de données recensées dans le tableau ci-dessous.

    from dictionary import Variables as settings
    
    # Setting max words that can be save
    settings.LOCAL_DICT_MIN_COUNT = 5000

ATTENTION ! Plus vous stockez des quantités importante en base de donnée et plus il a des chances qu'il se faille ressentir une certaine latence.

Les codes utilisés sont les mêmes que ceux utilisé par Unitex.

Pour plus d'information, veuillez consulter ce document.

Pour consulter des cas d'utilisation plus avancés, veuillez consulter ce document.