Utilisation avancée des groupes dans une regex Python

 Dans une regex les parenthèses servent  à capturer des caractères qui seront stockés dans l'objet Match.

Mais leurs fonctionnalités ne sont pas toujours bien connues.

Reference à un groupe : numerique ou nommée

Chaque parenthèse ouvrante provoque la création d'un groupe qui sera accessible par son numéro.

La numérotation commence à 1 , le texte capturé dans le groupe '1' pourra etre rappelé plus loin dans la

regex par '\1' .

La méthode groups() de l'objet match, retournera la liste des textes capturés. Le groupe 0 qui est un emplacement libre, contiendra tout le texte capturé.

Comme on  peut le voir ci-dessous, les groupes peuvent se voir attribuer un nom pour plus de lisibilité

Cette opération se réalise par le motif (?P=<NOM> .... ) 

La référence à une capture d'un groupe nommé se fait par le motif (?P=nom)

Ce nom se retrouvera dans les appels de méthode Match.group ou Match.span

Le site regex101 peut aider à la mise au point des regex.

La recherche en regardant en avant ou en arrière  (lookahead / lookbehind) .

C'est une jeu de motif très puissant qui permet de réaliser plusieurs contrôles ou d'enchainer plusieurs conditions sans consommer des caractères.

Exemples de recherche avant: on veut tronçonner la chaine ('123456789') par groupe de 2 en partant de la fin.

Avant de capturer un groupe, on va chercher à former des paires complète en avant du groupe à capturer.

Recherche en avant

Pour cela on utilise la séquence de groupe (?=...) ou sa forme négative  (?!...)

En ajoutant aux bons endroits le motif "(?:)" on ne capture plus les groupes inutiles

Le motif (?:...) permet d'effectuer de regroupement mais ne conserve pas la capture dans un groupe

Recherche en arrière

De manière symétrique à la recherche en avant, il est possible de faire dépendre la recherche d'un motif sur du texte situé en arrière (lookbehind).

Cette opération se réalise avec le motif (?<=...) ou par sa négation (?<!...)

L'avantage des regards avant ou arrière (look...) est qu'ils ne consomment pas de caractère. Il est donc possible de chainer les conditions

Les liens utiles:

• site regex101
• Mastering Lookahead and Lookbehind
• Le notebook utilisé pour les exemples.

Visualiser un fichier RST

Le format RST  ( reStructuredTex) est un langage de balisage simplifié destiné à documenter facilement du code. Il fait partie intégrante du langage Python (PEP 287 – reStructuredText Docstring Format).

Aussi, il est pratique d'utiliser du RST dans de la docstring d'un module ou d'une classe. Des générateurs de documentation comme SPHINX pourront s'en servir. 

Le site github en fait un usage important dans la présentation des projets en mettant en avant le fichier README.rst des projets (exemple ici avec pycobol) .

Le moyen le plus simple pour avoir une idée du rendu est d'installer l'utilitaire Python Restview:

pip install restview

Puis lancer la commande: Restview <mon_fichier.rst>

Un mini serveur web sera lancé.

Le navigateur ouvrira une page html avec votre RST mis en forme.

Les modifications dans le fichier RST seront immédiatement visibles dans le navigateur

Les balises basiques les plus usitées sont:

Le '=' sous toute un texte pour l'afficher comme un titre.

Le '-' sous toute un texte pour l'afficher comme un sous-titre

Le '*'  Pour commencer une liste

Cohabitation de Jupyter avec un projet POETRY

 Poetry est pour moi le meilleur outil pour la gestion technique d'un projet Python.

Cet article va vous expliquer comment utiliser Jupyter dans un projet POETRY.

L'objectif est d'avoir un nouveau kernel (noyau) Python basé sur votre environnement virtuel.

Cet environnement virtuel peut être créé par la commande : poetry new:

exemple : > poetry new monprojet

 Aller dans le répertoire 'monprojet'  (cd monprojet)

Puis lancer l'ajout d'un nouveau kernel Jupyter par la commande:

> poetry run ipython kernel install --user  --name kmonprojet

La commande ipython kernel install ... est lancée via l'environnement virtuel de votre projet.

La derniere option permet d'indiquer quel nom sera utilisé dans l'interface Jupyter pour identifier le kernel.

Puis toujours depuis le contexte Poetry, lancez jupyter par la commande:

> poetry run jupyter notebook

Le navigateur se lance et permet de choisir un kernel propre à votre projet:

Avant de se lancer dans cette manipulation, peut être faut il se poser la question suivante: 

Pourquoi avoir besoin d'un notebook Jupyter dans un dispositif de type poetry ?

Réponse au prochaine billet

Refactorisations assistées par des DOCTEST

 Python permet facilement de passer d'un programme structuré en fonction à un programme utilisant des classes et des objets.

C'est à mon avis une des forces de Python. Pas besoin de tout réécrire le gros du travail est conservé. 

Aussi , Python favorise la  refactorisation de son code au fur et à mesure de la progression du développement.

(le notebook est disponible sur : https://github.com/germanlinux/notebooks

(https://github.com/germanlinux/notebooks/blob/main/init/refactorisation.ipynb)

La refactorisation en  objet et classe consiste à :

• Ajouter le paramètre 'self' dans les déclarations des fonctions 
• Préfixer les variables locales par 'self'
• Créer un cadre pour la classe
• Améliorer le nommage des méthodes

Pour sécuriser ces opérations de refactorisation, j'utilise le dispositif  du DOCTEST pour m'assurer de la non régression du programme.

Le DOCTEST permet d'inclure des tests dans la documentation des méthodes ou des fonctions.

Il utilise pour cela le motif '>>>'  pour insérer des instructions Python dans la documentation. Le resultat de ces appels est comparé avec la ligne suivante sans préfixe.

Exemple:

Ces insertions n'auront aucun impact sur le fonctionnement des méthodes ou des fonctions.

Pour activer les tests il suffit d'ajouter l'appel au module de DOCTEST.

Dans cet exemple, la fonction à tester est indiquée. Il est possible de lancer tous les test présents dans un programme en remplaçant la methode run_docstring_examples(...) par testmod(..)

Lancement des tests 

sous condition 

Ci dessous un exemple complet (projet pycobol) 

class ZoneGroupe:
    ''' Cette classe prend en charge la creation d'une zone groupe. 
    Par nature cette zone est de type ALN.
    Sa longueur est la somme des longueurs des composants qui la composent
    >>> obj = ZoneGroupe('zoneessai', 1, 0)
    >>> obj.nom
    'zoneessai'
    >>> print(obj)
    >>> objfils = ZoneGroupe('zonefils', 2)
    >>> obj.ajout_fils_groupe(objfils)
    >>> len(obj.fils)
    1
    >>> objfils.pere # doctest: +ELLIPSIS
    ZoneGroupe(nom='zoneessai'...
    >>> objfils2 = ZoneGroupe('zonefils2', 1)
    >>> obj.ajout_fils_groupe(objfils2)  # doctest: +ELLIPSIS
    Traceback (most recent call last):
    ...
    >>> objfilsimp = ZoneFilsSimple('essaifils', 5, picture = '999')
    >>> obj.ajout_fils_simple(objfilsimp)
    >>> obj.longueur_utile
    3
    '''

La directive #doctest: +ELLIPSIS  permet de signaler au module DOCTEST d'arrêter la comparaison du résultat après les trois points (...) . C'est très utile pour tester une exception: la sortie complète de l'exception (trace de la pile d'exécution) sera  ignorée. Il est aussi utilisé ici pour des contenus un peu longs comme les objets.

class ZoneGroupe(builtins.object)
 |  ZoneGroupe(nom: str, rang: int, pere: int = 0, fils: list[int] = <factory>, son_type: str = 'GRP', usage: str = 'DISPLAY', longueur_utile: int = 0, valeur_interne: str = '', valeur_externe: str = '', section: str = 'NON RENSEIGNE') -> None
 |
 |  Cette classe prend en charge la creation d'une zone groupe
 |  par nature cette zone est de type ALN.
 |  Sa longueur est la somme des longueurs des composants qui la composent
 |  >>> obj = ZoneGroupe('zoneessai', 1, 0)
 |  >>> obj.nom
 |  'zoneessai'
 |  >>> print(obj)
 |  >>> objfils = ZoneGroupe('zonefils', 2)
 |  >>> obj.ajout_fils_groupe(objfils)
 |  >>> len(obj.fils)
 |  1
 |  >>> objfils.pere # doctest: +ELLIPSIS
 |  ZoneGroupe(nom='zoneessai'...
 |  >>> objfils2 = ZoneGroupe('zonefils2', 1)
 |  >>> obj.ajout_fils_groupe(objfils2)  # doctest: +ELLIPSIS
 |  Traceback (most recent call last):
 |  ...
 |  >>> objfilsimp = ZoneFilsSimple('essaifils', 5, picture = '999')
 |  >>> obj.ajout_fils_simple(objfilsimp)
 |  >>> obj.longueur_utile
 |  3

Résultat de l'instruction help 

Ci-dessous un résultat partiel d'exécution des tests

Trying:
    objfils = ZoneGroupe('zonefils', 2)
Expecting nothing
ok
Trying:
    obj.ajout_fils_groupe(objfils)
Expecting nothing
ok
Trying:
    len(obj.fils)
Expecting:
    1
ok
Trying:
    objfils.pere # doctest: +ELLIPSIS
Expecting:
    ZoneGroupe(nom='zoneessai'...
ok
Trying:
    objfils2 = ZoneGroupe('zonefils2', 1)
Expecting nothing
ok

Résultats des tests.

En conclusion.

Python nous donne la possibilité de se tromper et d'améliorer notre ouvrage par petites touches. 

Ces tests intégrés sont à compléter par des tests unitaires avec une couverture du code mesuré avec la commande coverage.