2. Validation de données

La validation est un processus permettant de garantir l’adéquation, la précision et la cohérence des données collectées. Elle est essentielle pour garantir la qualité des données et la fiabilité des analyses qui en découlent. La validation des données peut être effectuée à différents niveaux, notamment au niveau de l’interface utilisateur et du serveur pour les données récupérées via un formulaire web. Mais également avant insertion dans la base de données ou lors de la récupération de données depuis une source externe.

2.1. Validation côté client

La validation côté client est effectuée dans le navigateur de l’utilisateur avant que les données ne soient envoyées au serveur. Elle permet de garantir que les données saisies par l’utilisateur sont correctes et cohérentes. La validation côté client est généralement effectuée à l’aide de JavaScript et de bibliothèques de validation telles que jQuery Validation.

Voici un exemple de validation côté client à l’aide de jQuery Validation :

<form id="myForm">
    <input type="text" name="name" required>
    <input type="email" name="email" required>
    <input type="submit" value="Submit">
</form>

<script src="https://code.jquery.com/jquery-3.5.1.min.js"></script>
<script src="https://cdn.jsdelivr.net/jquery.validation/1.16.0/jquery.validate.min.js"></script>
<script>
    $(document).ready(function() {
        $("#myForm").validate();
    });
</script>

Dans cet exemple, jQuery Validation est utilisé pour valider un formulaire contenant un champ de texte et un champ d’e-mail. Le champ de texte est requis, tandis que le champ d’e-mail doit contenir une adresse e-mail valide.

2.2. Validation côté serveur

La validation côté serveur est effectuée sur le serveur avant de traiter les données. Elle permet de garantir que les données reçues du client sont correctes et cohérentes. La validation côté serveur est généralement effectuée à l’aide de frameworks de développement web tels que Django.

Voici un exemple de validation côté serveur à l’aide de Django :

from django import forms

class MyForm(forms.Form):
    name = forms.CharField(max_length=100)
    email = forms.EmailField()

Dans cet exemple, un formulaire Django est défini avec deux champs : un champ de texte pour le nom et un champ d’e-mail pour l’adresse e-mail. La validation est effectuée automatiquement par Django lors de la soumission du formulaire.

2.3. Validation back end

La validation back end est effectuée avant l’insertion des données dans la base de données. Elle permet de garantir que les données sont correctes et cohérentes avant d’être stockées. La validation back end est généralement effectuée à l’aide de bibliothèques de validation telles que Pydantic pour Python.

Voici un exemple de validation back end à l’aide de Pydantic :

from pydantic import BaseModel

class User(BaseModel):
    name: str
    email: str

user_data = {"name": "John Doe", "email": " [email protected]"}
user = User(**user_data)    # Validation is performed here

Dans cet exemple, une classe Pydantic est définie avec deux champs : un champ de texte pour le nom et un champ d’e-mail pour l’adresse e-mail. Lorsqu’une instance de la classe est créée avec des données utilisateur, la validation est effectuée automatiquement pour garantir que les données sont correctes.

Pydantic sera vu plus en détail ci dessous.

2.4. Types de validation

La validation des données regroupe diverses techniques visant à garantir que les données sont exactes, cohérentes et exploitables pour l’analyse. Voici les principaux types de validation des données :

2.4.1. Validation Syntaxique

La validation syntaxique vérifie que les données respectent une structure et un format spécifiques. Elle impose des règles de représentation des données. Par exemple :

• Vérification de format : s’assurer que les données suivent un format précis (ex. : une date au format YYYY-MM-DD, une adresse e-mail valide, etc.) ;

• Vérification de longueur : confirmer que la donnée respecte une longueur définie (ex. : un numéro de téléphone doit comporter 10 chiffres).

2.4.2. Validation Sémantique

La validation sémantique vérifie que les données ont un sens logique et respectent les règles métier. Par exemple :

• Vérification logique : la date de fin d’un projet doit être postérieure à la date de début ;

• Contrôle de domaine : l’âge d’un client doit être compris entre 0 et 120 ans.

2.4.3. Validation de Plage (Range Validation)

La validation de plage vérifie que les valeurs numériques appartiennent à une plage définie. Par exemple :

• Une température doit être comprise entre -50°C et 50°C ;

• Le prix d’un produit ne peut pas être négatif.

2.4.4. Validation de Type

La validation de type vérifie que la donnée est du type attendu (nombre, texte, booléen, etc.). Par exemple :

• Un champ prévu pour un nombre ne doit contenir que des chiffres ;

• Une case à cocher Oui/Non doit être un booléen (true / false).

2.4.5. Validation par Code

La validation par code vérifie que les valeurs saisies correspondent à des codes prédéfinis. Par exemple :

• Un code pays doit être valide selon la norme ISO 3166 ;

• Une catégorie de produit doit appartenir à une liste prédéfinie.

2.4.6. Validation d’Unicité

La validation d’unicité empêche la duplication de valeurs pour préserver l’intégrité des identifiants uniques. Par exemple :

• Un e-mail ou un identifiant utilisateur doit être unique dans la base de données ;

• Une clé primaire dans une table ne doit pas être dupliquée.

2.4.7. Validation de Cohérence

La validation de cohérence vérifie que les données liées entre elles sont cohérentes. Par exemple :

• L’adresse de facturation et l’adresse de livraison doivent être identiques si aucune autre adresse n’est fournie ;

• Les dates de commande et d’expédition doivent être dans un ordre logique.

2.4.8. Validation de Présence (Null/Not Null Validation)

La validation de présence vérifie que les champs obligatoires sont remplis et que les valeurs facultatives sont bien gérées. Par exemple :

• Le nom, l’adresse et l’e-mail doivent être obligatoires ;

• Un champ optionnel peut être NULL sans provoquer d’erreur.

2.4.9. Validation Croisée (Cross-Validation)

La validation croisée compare les données entre plusieurs sources pour assurer leur exactitude et leur cohérence. Par exemple :

• Vérifier que les données clients dans la base de ventes correspondent aux données du CRM ;

• Comparer les prix des produits entre plusieurs fournisseurs.

2.4.10. Validation avec Expressions Régulières (Regex Validation)

La validation avec expressions régulières (regex) permet de définir des règles de validation complexes sur les chaînes de caractères. Par exemple :

• Valider une adresse e-mail avec un motif spécifique ;

• Vérifier un mot de passe pour qu’il contienne au moins 8 caractères, des lettres, des chiffres et des symboles.

Lecture

Data Validation and Data Cleaning [Sebastian Schelter, Moore-Sloan Fellow, Center for Data Science, New York University]

2.4.11. Conclusion

L’utilisation de techniques variées de validation des données est essentielle pour assurer leur intégrité et leur qualité. En combinant plusieurs de ces méthodes, on peut minimiser les erreurs.

2.5. Les expressions régulières

Les expressions régulières (regex) sont très utiles pour valider les données en fonction de leur format.

Elles permettent de définir des patterns (motifs) de caractères qui correspondent à des chaînes de texte spécifiques. Il y existe plusieurs syntaxes pour définir un pattern, la plus utilisée étant la syntaxe Perl (Practical Extraction Report Language), adoptée par Python.

Analyser attentivement la syntaxe utilisée en Python.

Tutoriels

• Regular Expressions: Regexes in Python (Part 1).

• Regular Expressions: Regexes in Python (Part 2).

Vous êtes maintenant en mesure de répondre aux questions suivantes.

1. correspond à n’importe quel caractère excepté un retour à la ligne

2. correspond à 0 ou 1 occurrence du caractère précédent

3. correspond à 0 ou plusieurs occurrences du caractère précédent

4. correspond à 1 ou plusieurs occurrences du caractère précédent

5. doit être ajouté après l’un des trois quantifiers précédents pour les rendre non-greedy

6. correspond à n’importe quel chiffre

7. correspond à n’importe quel caractère qui n’est pas un chiffre

8. correspond à n’importe quelle lettre ou chiffre

9. correspond à n’importe quel caractère qui n’est pas une lettre ou un chiffre

10. correspond à n’importe quel espace blanc

11. correspond à n’importe quel caractère qui n’est pas un espace blanc

12. signifie exactement m occurrences du motif précédent

13. signifie entre m et n occurrences du motif précédent

14. permet d’échapper le caractère spécial suivant

15. correspond au début de la chaîne

16. correspond à la fin de la chaîne

17. permet de définir un ensemble de caractères

18. permet de définir un ensemble de caractères à exclure

19. permet de définir une alternative entre deux motifs

20. permet de grouper des motifs

21. correspond à n’importe quelle lettre minuscule

22. correspond à n’importe quelle lettre majuscule

23. correspond à n’importe quel chiffre

24. correspond à n’importe quelle lettre ou chiffre

25. correspond à n’importe quelle lettre, chiffre ou souligné

La syntaxe des expressions régulières est très puissante et permet de réaliser des opérations complexes. Utiliser regex101 pour observer comment sont construites les expressions régulières permettant de valider les données suivantes :

• un mot de passe fort

• une date au format RFC3339

• un email au format RFC2822

• une adresse IP au format RFC791

Exercice

Ecrire une expression régulière pour valider chaque type de nom de variable en Python :

• b (single lowercase letter)

• B (single uppercase letter)

• lowercase

• lower_case_with_underscores

• UPPERCASE

• UPPER_CASE_WITH_UNDERSCORES

• CapitalizedWords

• mixedCase

• Capitalized_Words_With_Underscores

• _single_leading_underscore

• single_trailing_underscore_

• __double_leading_underscore

• __double_leading_and_trailing_underscore__

Pour chaque règle vérifier avec regex101 si elle est valide ou non avec les noms de variable contenus dans la liste list_of_names.

list_of_names = [ "__privateVar", "myVariableName", "VARIABLE", "_var_", "_privateVar", "My_Variable_Name", "my_variable_name", \
                  "var_", "XY", "myVariableName", "Variable", "x", "privateVar", "__magic", "MyVariableName", "__magic__", \
                  "MY_VARIABLE_NAME", "variable", "My_Variable_Name", "my_variable_name", "MY_VARIABLE_NAME", "My_Variable_Name", \
                  "my_variable_name", "__privateVar", "Variable", "__magic", "__magic__", "MyVariableName", "privateVar", "_privateVar", \
                  "XY", "VARIABLE", "x", "var_", "_var_"]

2.6. Pydantic

Pydantic est une bibliothèque de validation de données pour Python. Elle permet de définir des modèles de données avec des types de champs et des règles de validation, puis de valider les données par rapport à ces modèles. Pydantic est utile pour garantir la qualité et la cohérence des données dans une application.

L’un des principaux attraits de Python est qu’il s’agit d’un langage à typage dynamique. Le typage dynamique signifie que les types des variables sont déterminés à l’exécution, contrairement aux langages à typage statique, où ils sont explicitement déclarés au moment de la compilation. Bien que le typage dynamique soit idéal pour un développement rapide et une utilisation simplifiée, il est souvent nécessaire d’avoir une vérification des types et une validation des données plus robustes pour les applications en conditions réelles. C’est là que la bibliothèque Pydantic de Python entre en jeu.

Pydantic a rapidement gagné en popularité et est aujourd’hui la bibliothèque de validation de données la plus utilisée en Python. Elle est largement utilisée dans les applications web, les services RESTful, les applications de traitement de données et les applications de machine learning. Pydantic est également intégré à de nombreuses autres bibliothèques Python populaires, telles que FastAPI, Tortoise-ORM et Typer.

Pydantic exploite les annotations de type pour aider à valider et sérialiser facilement les schémas de données. Cela rend le code plus robuste, lisible, concis et facile à déboguer. Pydantic s’intègre également avec mypy et VS Code, ce qui permet de détecter les erreurs de schéma avant d’exécuter le code.

Principales fonctionnalités de Pydantic :

• Personnalisation : on peut valider pratiquement n’importe quel type de données. Que ce soit des types primitifs de Python ou des structures de données profondément imbriquées, on peut valider et sérialiser presque tous les objets Python ;

• Flexibilité : on peut choisir entre une validation stricte ou souple des données ;

• Sérialisation : on peut convertir ses objets en dictionnaires et en chaînes JSON (et inversement). Cela facilite l’intégration avec des API et des outils utilisant des schémas JSON ;

• Performance : grâce à son coeur écrit en Rust, la validation est très rapide ;

• Adoption et écosystème : Pydantic est une dépendance clé dans des bibliothèques Python populaires comme FastAPI, LangChain et Polars.

Tutoriel

Le tutoriel Pydantic: Simplifying Data Validation in Python présente les principaux aspects de l’utilisation de Pydantic pour la validation des données en Python. Il couvre les sujets suivants :

• Python’s Pydantic Library

• Using Models

• Working With Validators

• Managing Settings

2.7. Application

Ecrire un validateur pour les données utilisées dans le Test technique. Utiliser ce validateur avec le fichier population-corrupted.csv dans lequel 15 erreurs ont été introduites. Quelles sont les lignes concernées ?

1. Erreur #1

2. Erreur #2

3. Erreur #3

4. Erreur #4

5. Erreur #5

6. Erreur #6

7. Erreur #7

8. Erreur #8

9. Erreur #9

10. Erreur #10

11. Erreur #11

12. Erreur #12

13. Erreur #13

14. Erreur #14

15. Erreur #15