Partie 1:

Créez des données avec Python

Partie 2:

Gérez la logique du programme dans Python

Partie 3:

Extrayez des données du web avec les packages Python

Pourquoi écrire du code de façon structurée est si important ?

Avant de plonger dans les méthodes de programmation, voyons pourquoi il faut garder le code structuré autant que possible.

Pensez à l’endroit chez vous le moins bien rangé et moins bien organisé. Un tiroir, un placard ou même une pièce entière. C’est difficile de trouver quelque chose au milieu de tout ça, n’est-ce pas ? Si vous venez de vous en servir, ça peut encore aller, mais quand ça fait un moment, ça peut devenir compliqué.

Avec le code, c’est pareil... ou pire. Si vous n’y avez pas touché depuis plusieurs mois et que vous ne l’avez pas écrit avec rigueur, vous allez perdre du temps à vous rappeler les différentes fonctions et leur structure.

Maintenant, imaginez que vous avez hérité du tiroir/du placard/de la pièce d’une personne désorganisée et qui ne vit plus ici. C’est à ça que ça ressemble, de travailler avec le code de quelqu’un d’autre qui n’a pas été rigoureux !

Vous devez avoir une définition partagée avec d’autres développeurs sur ce que signifie « avoir un code structuré ». De cette façon, vous comprendrez mieux le code, sans avoir à connaître la personne qui l’a écrit.

D'autre part, il faut aussi prendre en compte toutes les erreurs qui peuvent faire planter le code, et savoir les prévoir pour éviter une mauvaise surprise.

Vous comprenez maintenant pourquoi vous devez coder correctement. Voyons comment faire.

Ne vous répétez pas

Le premier commandement de la programmation est le DRY : ne vous répétez pas (Don’t Repeat Yourself, en anglais). En tant que développeur, vous voulez que tout soit aussi rapide et efficace que possible, et automatiser autant que vous pouvez. Si vous vous retrouvez à copier et coller souvent des morceaux de code, c’est signe que vous pouvez isoler ce à quoi servent ces lignes de code.  

Admettons que vous vouliez calculer le taux de conversion et l’afficher dans plusieurs campagnes. Vous pouvez le copier et coller pour chaque campagne, comme dans le code ci-dessous :

taux_de_conversion1 = premiere_campagne['visiteurs'] / premiere_campagne['conversions']
taux_de_conversion2 = seconde_campagne['visiteurs'] / seconde_campagne['conversions']
taux_de_conversion3 = troisieme_campagne['visiteurs'] / troisieme_campagne['conversions']

Si vous commencez à écrire du code comme ça, la première chose à faire est de le transformer en fonction. Vous pouvez écrire une fonction appelée  calculer_taux_de_conversion , et tout faire en une fois.

def calculer_taux_de_conversion(campagne):
   taux_de_conversion = campagne['visiteurs'] / campagne['conversions']
   return taux_de_conversion
taux_de_conversion1 = calculer_taux_de_conversion(premiere_campagne)
taux_de_conversion2 = calculer_taux_de_conversion(seconde_campagne)
taux_de_conversion3 = calculer_taux_de_conversion(troisieme_campagne)

Les deux extraits de code ci-dessus font la même chose, mais il y en a un mieux structuré que l’autre, et qui suit le principe DRY !

Respectez le principe de responsabilité unique

Quand vous organisez quelque chose, il vaut mieux avoir un endroit où ranger chaque objet, car vous savez qu’il sera plus facile à retrouver. C’est pareil pour écrire des fonctions. Chaque fonction doit être responsable d’une seule et unique fonctionnalité, et rien de plus.

Mettons que vous vouliez calculer les taux de conversion pour plusieurs campagnes, et sauvegarder les données dans un fichier CSV.

Au lieu d’appeler une fonction   calculer_taux_de_conversion_sauvegarder_csv()  , nous allons séparer deux tâches en fonctions séparées :

• calculer_taux_de_conversion()

• sauvegarder_csv()

Chaque fonction doit être responsable d’une seule tâche. Dès que vous essayez d’accomplir plus d’une chose dans une seule fonction, vous risquez de ne plus comprendre ce que vous vouliez faire à l’origine.

Le fait de séparer les responsabilités vous permet de définir un nom plus descriptif pour la fonction, de débugger le code plus facilement, et de mieux comprendre le code.

Commentez votre code

Les commentaires sont un moyen très pratique de rappeler, à vous et aux autres développeurs, ce qu’un morceau de code est censé faire.

Il y a différents standards pour les commentaires. Votre code doit être suffisamment lisible pour ne pas avoir besoin de trop de commentaires pour que quelqu’un d’autre le comprenne.

Dans Python, on trouve des commentaires à ligne unique et multiple.

Les commentaires à ligne unique sont indiqués par   #  avant et après. La phrase juste en-dessous est un commentaire à ligne unique à propos d’une méthode.

#ceci est un commentaire

« Les commentaires qui contredisent le code sont pires qu’aucun commentaire. Gardez en priorité les commentaires à jour quand le code change ! »

- PEP 8 guide de style pour le code Python

Documentez votre code

Les docstrings sont des chaînes de documentation qui sont utilisées pour documenter les fonctions, les modules, les classes et les méthodes dans le code. Elles sont généralement placées directement après la déclaration de la fonction, de la classe, du module ou de la méthode, entre des guillemets triples.

L'une des principales utilisations des docstrings est de fournir une description claire et concise de ce que fait une fonction, de ses paramètres et de sa valeur de retour. Cela aide les autres développeurs à comprendre rapidement comment utiliser la fonction sans avoir à examiner le code lui-même.

Voici un exemple de docstring pour une fonction de calcul de la somme de deux nombres :

def somme(a, b):
    """
    Cette fonction calcule la somme de deux nombres et retourne le résultat.

    Parameters:
    a (int): le premier nombre
    b (int): le deuxième nombre

    Returns:
    int: la somme de a et b
    """
    return a + b

Lorsque vous appelez cette fonction dans l'interpréteur Python, vous pouvez utiliser la fonction  help()  pour afficher la docstring, voici le résultat :

>>> help(somme)
somme(a, b)
   Cette fonction calcule la somme de deux nombres et retourne le résultat.
   Parameters:
   a (int): le premier nombre
   b (int): le deuxième nombre
   Returns:
   int: la somme de a et b

Gérez les erreurs et les exceptions

Lorsqu'un programme rencontre une erreur, cela peut le faire planter complètement, ce qui n'est pas souhaitable. Pour éviter cela, il est possible d'utiliser les exceptions pour gérer les erreurs. Les exceptions sont des erreurs qui peuvent être détectées et gérées par le programme. Si une exception est levée, le programme peut afficher un message d'erreur, puis continuer à s'exécuter normalement.

Par exemple, si on demande à l'utilisateur de saisir un nombre, mais qu'il saisit un texte au lieu d'un nombre, cela peut causer une erreur. Pour éviter cela, on peut utiliser un bloc  try/except  pour gérer l'erreur, et afficher un message d'erreur personnalisé à l'utilisateur.

while True:
    try:
        x = int(input("Entrez un nombre entier : "))
        break
    except ValueError:
        print("Oops ! Ce n'est pas un nombre entier. Essayez encore...")

Dans ce code, le bloc  try  contient le code qui peut causer une erreur, c'est-à-dire la conversion de la saisie utilisateur en un entier. Si une erreur se produit, le bloc  except  est exécuté et affiche un message d'erreur personnalisé. Le programme revient ensuite au début de la boucle  while  et demande à l'utilisateur de saisir un nouveau nombre.

Respectez les standards du code

En général, vous lisez du code bien plus souvent que vous n’en écrivez. C’est pour ça que c’est important d’avoir des lignes directrices pour améliorer sa lisibilité et le rendre aussi cohérent que possible.

Le guide de style officiel pour le code Python est un document appelé PEP 8 (ressource en anglais). Il contient des règles et des bonnes pratiques qui aident à standardiser l’écriture en Python par les développeurs.

Globalement, les philosophies derrière l’écriture correcte en Python sont répertoriées dans un document appelé PEP 20 (ressource en anglais) : 

Explicite vaut mieux qu’implicite.

La simplicité est meilleure que la complexité.

(...)

LA LISIBILITÉ COMPTE AUSSI.

Il est vital de connaître ces préceptes du « Zen de Python », comme on les appelle. Je vous recommande aussi de consulter le PEP quand vous avez des questions qui surviennent dans vos projets de programmation en Python.

En résumé

• Écrire du code standard et structuré vous aide, vous et d’autres développeurs, à avoir une compréhension cohérente et partagée de ce que le code est censé faire.

• DRY : ne vous répétez pas dans le code ! Copier-coller est interdit !

• Responsabilité unique : chaque fonction a un but unique pour une meilleure lisibilité.

• ​​Les docstrings servent à documenter le code en fournissant des informations sur les fonctions, les classes et les modules.

Le try/except est une structure de contrôle qui permet de gérer les erreurs et les exceptions.

Résumé de la partie 2

Félicitations ! Vous avez atteint la fin de la partie 2 de ce cours, et vous pouvez désormais programmer la logique de votre code Python. Vous avez déjà fait beaucoup !

• Vous avez utilisé les boucles et les conditions pour contrôler le déroulement de votre logique.

• Vous avez écrit des fonctions pour séparer du code pour des besoins spécifiques. 

• Vous avez appris l’importance d’un code bien structuré et sans bug.

Une fois que vous aurez terminé le quiz, vous recevrez le certificat du cours. Félicitations ! 

Aperçu Partie 3

Vous avez les bases, mais vous n’avez pas fini de progresser ! Un défi supplémentaire vous attend dans la partie finale du cours, conçu pour vous donner une opportunité d’appliquer et d’étendre vos nouvelles compétences.

Vous avez fait un long chemin. Rappelez-vous les astuces du chapitre d’orientation : on apprend en faisant et on apprend en se dépassant. Maintenant, il est temps de vraiment exhiber vos talents de codage avec Python, et de passer au niveau supérieur. ????