Blog ENI : Toute la veille numérique !
Accès illimité 24h/24 à tous nos livres & vidéos ! 
Découvrez la Bibliothèque Numérique ENI. Cliquez ici
Accès illimité 24h/24 à tous nos livres & vidéos ! 
Découvrez la Bibliothèque Numérique ENI. Cliquez ici
  1. Livres et vidéos
  2. Vade-mecum de l'informatique contemporaine
  3. mecum de l'informatique contemporaine
Extrait - Vade-mecum de l'informatique contemporaine (TCP, SOA, Linux, Python, Docker, HDFS, RDF, Adam, OWASP, KPI, UML, Scrum…)
Extraits du livre
Vade-mecum de l'informatique contemporaine (TCP, SOA, Linux, Python, Docker, HDFS, RDF, Adam, OWASP, KPI, UML, Scrum…)
1 avis
Revenir à la page d'achat du livre

Python - "starter" TL;DR

L’esprit de ce starter Python

Pour être très à l’aise dans l’exploitation de ce starter, il vous faut être déjà relativement familiarisé avec quelques notions de programmation dans un langage quelconque. Dans le cas contraire, vous devez avoir Wikipédia à portée de clavier et aller vérifier la signification d’un terme ou d’une notion que nous n’aurions pas explicitée. Et puis vous disposez de la documentation Python ici : https://www.python.org/.

Ceci n’est pas un cours exhaustif sur Python, ni un manuel ou un cookbook de trucs et astuces en Python ! C’est au contraire un parcours linéaire à lire et à pratiquer séquentiellement qui vous familiarisera avec ce langage, tout en construisant pas à pas les références cognitives et/ou des pratiques utiles à la « mentalisation » d’un Python efficace, simple, propre, lisible, évolutif.

Dans un premier temps, nous vous conseillons de ne pas varier les sources d’information et d’utiliser ce starter le plus complètement possible. Ceci vous évitera de vous disperser et limitera le découragement qui peut advenir en feuilletant la masse d’informations sur Python.

Python est très riche et l’on peut y effectuer une opération de différentes...

Dénominations et conventions

En ce qui concerne la dénomination des objets/variables/fonctions que vous allez créer, ou la présentation du code, nous n’avons pas respecté les « bonnes pratiques » de la profession, en espérant faciliter la lisibilité pour un programmeur débutant. Nous avons utilisé un « franglais » peu académique que nous ne vous conseillons pas d’utiliser dans votre pratique professionnelle. De toute façon, vous devrez vous conformer aux usages de nommage de votre entité, souvent conformes à la PEP8_style_guide (https://peps.python.org/pep-0008/) que nous vous engageons à lire attentivement après avoir assimilé ce starter Python. À terme, nous vous suggérons d’utiliser des outils comme flake8 et pylint pour vous aider à identifier certaines bizarreries de votre code (https://flake8.pycqa.org/en/latest/ et https://docs.pylint.org/).

Pourtant, dans la mesure où cela ne nous semblait pas affecter la simplicité de notre propos, nous avons tâché de nous conformer à quelques règles simples (dont le sens vous apparaîtra peut-être plus loin dans la lecture de ce document) :

  • Les variables ou objets peu significatifs fonctionnellement comme les indices d’une boucle, les paramètres de fonctions techniques...

Zen de Python

Voici une transcription personnelle et très amendée de certains conseils du Zen de Python, de Tim Peters. Ces conseils n’ont rien d’anecdotique, ils reflètent la façon dont vous devez aborder la programmation (Python et autres). Leur sens se précisera au fur et à mesure de votre pratique, relisez-les souvent :

  • Le beau est mieux que le laid.

  • L’explicite est mieux que l’implicite.

  • Le simple est mieux que le complexe.

  • Le complexe est mieux que le compliqué.

  • Un style de programmation très linéaire est mieux qu’un style imbriqué.

    Traduction technique : évitez les boucles inutiles et les cascades de "if then else" inutiles. Utilisez les techniques de programmation fonctionnelles : fonctions simples, générateurs/itérateurs ou map, fonction lambda. Utilisez des objets et des méthodes compactes en évitant les classes et les fonctions trop verbeuses.

  • Un langage clair est préférable à un langage dense.

  • La lisibilité importe beaucoup (traduction technique : belles indentations de 2 ou 4 caractères, lignes de moins de 80 caractères, choix du nom des objets, commentaires concis et utiles, doc_string à jour, etc.).

  • Les cas particuliers ne sont pas assez particuliers pour enfreindre les règles, bien que l’aspect pratique doive supplanter la pureté.

  • Les erreurs lors de l’exécution du code ne doivent jamais se passer en silence (if imprévu : log et stop), sauf si elles sont explicitement...

Contexte de travail

Python est disponible en versions 2.x (typiquement 2.7) et 3.x (> 3.11 actuellement). Les versions 2.x de Python restent utilisées dans des contextes où la migration n’a pas été effectuée pour diverses raisons économiques ou pratiques, mais aujourd’hui il est d’usage de développer dans une version supérieure ou égale à 3.8. Afin de ne pas créer de frustrations, c’est ce niveau de version que nous avons utilisé dans nos exemples.

Notez que vous pouvez disposer de plusieurs versions sur une même machine, ceci au travers de différents mécanismes, dont les environnements Python (venv) ou conda. Dans ce cas, il vous faudra invoquer le bon environnement avant de commencer à coder.

Dans ce starter, on suppose que Python est installé et que vous disposez d’un contexte Python supérieur ou égal à 3.5, dans lequel vous avez l’autorisation d’installer de nouveaux paquets (librairies, packages), typiquement au travers de l’instruction suivante en ligne de commande : pip install un_nouveau_paquet.

Pour tester Python en ligne sans installation sur votre machine, vous pouvez utiliser :

Pour commencer

Ici, nous allons aborder les éléments les plus centraux, parfois frustes, permettant de transcrire un algorithme simple en Python par l’usage d’un Python on ne peut plus économe.

1. Python, comme une calculette

Vous pouvez utiliser Python comme une calculette triviale (* représente la multiplication, ** la puissance).

a = 1 
b = 3 
c = 2*a + b**2 
print(c)  
--|  11 

Pour intégrer dans votre code les objets qui ne sont pas présents par défaut, il vous faut les importer.

# numpy est un package comportant de nombreuses fonctions de calcul 
import numpy as np # une des syntaxes d'importation 

Pour avoir une idée du nombre de fonctions disponibles dans numpy, taper ceci :

dir(np) 

La liste étant très longue, nous ne l’avons pas mise dans ce document.

Votre calculette possède maintenant de nombreuses nouvelles fonctions, ici, la valeur absolue, qui n’a qu’un seul paramètre (l’argument) et l’arrondi qui possède deux arguments (le réel à arrondir et le nombre de chiffres après la virgule). 

print(np.abs(-10.45))       # fonction valeur absolue  
 
--|  10.45 

print(np.round(11.78945,2)) # arrondi à deux  
 
--|  11.79 

2. Faire des choix

Pour affecter une valeur en fonction d’une condition unique, la syntaxe la plus efficace est la suivante : resultat = (expression_if_true if condition else expression_if_false).

Par exemple, pour dire que si x est strictement négatif alors on veut obtenir 0 et sinon on veut obtenir 10, on écrit :

x  = -50 
y  = (0 if x < 0 else 10) 
print(x,y) 
--|  -50 0 

x  = 100 
y  = (0 if x < 0 else 10) 
print(x,y) 
--|  100 10 

Avec cette syntaxe, les parenthèses ne sont pas obligatoires, mais améliorent la lisibilité.

Quand vous voulez effectuer une opération en fonction d’une liste de conditions, il faut enchaîner des if, elif et else en fonction du nombre de conditions que vous voulez tester.

Ici, on a trois conditions explicites et une quatrième pour rassembler tous les autres cas de figure. Essayez de faire fonctionner ce code avec diverses valeurs pour...

Manipulations de données courantes

1. Utiliser la fonction print et découvrir les strings

Les chaînes de caractère peuvent être créées avec de simples quotes : ’blabla’, ou avec des doubles quotes : "blabla".

On peut les utiliser dans la fonction print. Si le message comporte lui-même une quote ou double quote, il faut la faire précéder du caractère \ (c’est ce que l’on nomme un caractère d’échappement).

Les chaînes de caractères sont immuables et leur type est nommé string.

print("Une chaîne de caractères avec une \" et une \'. ") 
--|  Une chaîne de caractères avec une " et une '. 

Pour créer des chaînes comportant plusieurs lignes, il faut les encadrer avec trois quotes, simples ou doubles.

print( 
  ''' 
  Ceci est un texte  
  avec plusieurs lignes 
  ''' 
) 
--| 
--|    Ceci est un texte  
--|    avec plusieurs lignes 
--| 

On peut également procéder comme dans d’autres langages pour générer des sauts de ligne, en utilisant la séquence d’échappement \n.

print("une première ligne\navec une deuxième ligne et un saut final\n") 
--|  une première ligne 
--|  avec une deuxième ligne et un saut final 

Les chaînes de caractères sont des objets qui peuvent être manipulés au travers de différentes méthodes, à savoir des fonctions propres à une classe d’objets. L’une d’elles est la méthode format qui recherche les séquences comme {0} dans une chaîne et les remplace par une autre chaîne de caractère en utilisant le numéro d’ordre entre accolades. Pour invoquer une méthode sur un objet on utilise le point « . ».

print( 
  "insertion_1 : {0}, insertion_2 : {1}, bis première : {0}" 
  .format("une chaîne",666) 
  ) 
 
--|  insertion_1 : une chaîne, insertion_2 :...

Les dictionnaires Python

1. Introduction aux dictionnaires

Cette structure est très appréciée par les développeurs Python, trop peut-être. Avant de l’utiliser, vérifiez toujours si une liste, un tableau/tenseur Numpy (ou Tensorflow ou Pytorch) ou un dataframe Pandas ne serait pas plus simple, plus puissant ou plus adapté (un dataframe est une structure tabulaire, comme un fichier csv ou une table relationnelle, mais où chaque colonne peut servir de clé d’accès sans générer de problème spécifique de performance).

Globalement, un dictionnaire est une liste de couples clé-valeur, et on peut imaginer les clés comme des index. Contrairement aux listes, aux tableaux et au t-uplets, l’ordre de rangement de ces informations dans le dictionnaire ne doit pas vous importer puisque l’on accède à chaque valeur au travers de sa clé.

Les dictionnaires sont là pour vous simplifier la vie ! Quand vous devez faire appel à des techniques compliquées ou difficilement lisibles pour utiliser vos dictionnaires, c’est sans doute que cet outil n’est pas le plus judicieux. Vous pouvez toujours transcrire vos données dans une autre structure plus adaptée pour gagner en fiabilité.

Les listes et le subsetting se caractérisent syntaxiquement par l’usage des crochets [], les dictionnaires se caractérisent par l’usage des accolades {}.

La création d’un petit dictionnaire est très aisée. En termes de clé (key en anglais), vous trouverez le plus souvent des chaînes de caractère ou des entiers. En termes de valeur, c’est comme pour les listes, vous pouvez stocker tous les types d’objet.

Voici un exemple de dictionnaire et d’usage de la méthode get avec le traitement du cas où la clé n’existe pas. Remarquez que, dans toute requête, il faut toujours traiter le cas où elle est infructueuse, même si vous imaginez ce cas fonctionnellement impossible !

sigles = { 
  "CCNE"  : "Comité consultatif national d'éthique", 
  "ADEME" : "Agence de l'environnement et de la maîtrise de l'énergie", 
  "YAML"  :...

Zoom sur les générateurs

Pour créer son propre itérateur, il est commode d’utiliser un générateur (d’itérateurs). C’est une fonction spécifique qui, au lieu de renvoyer une valeur via un return, renvoie la prochaine valeur à utiliser lors du parcours d’une structure itérable. L’instruction permettant de spécifier cette valeur est yield, elle fonctionne comme return.

Mettez le générateur suivant dans votre boîte à outils. À titre d’exercice, tentez de le modifier et analysez les conséquences de vos modifications.

def gen_i(start,end):  
  ''' gen_i génère un intérateur d'incrément de start à end inclus ''' 
  for i in range(start - 1,end): 
      i = i + 1  
      yield i 

Nous allons l’utiliser dans une boucle for, ce qui est très souvent le destin d’un itérateur !

for j in gen_i(-2,3) : print(j) # une boucle sur j variant de -2 à 3 
--|  -2 
--|  -1 
--|  0 
--|  1 
--|  2 
--|  3 

On constate que l’usage d’un tel générateur s’avère agréable et efficace.

def gen_i_pair(start...

Créer ses propres objets

1. Création de classes et d’objets

Pour créer un objet (une instance de classe), il vous faut une classe afin de pouvoir déclarer que cet objet hérite de cette classe. Ici nous créons une classe citoyen et via l’instruction individu = Citoyen( ). Nous implémentons la définition : « cet individu is_a citoyen ».

La classe est décrite au travers de ses méthodes. La première méthode à construire est le constructeur de la classe, en Python init. C’est cette méthode qui est invoquée lorsque l’on crée une instance de la classe.

Le premier paramètre de votre classe se nomme self et permet de préfixer les variables internes de la future instance en faisant référence à l’objet lui-même.

Le premier travail du constructeur, c’est de renseigner les variables internes self.xxx = yyy. Dans les cas simples comme ici, on se contente d’affecter aux variables internes les valeurs entrées dans les paramètres du constructeur, comme ceci : self.nom = nom. Si nécessaire, on peut effectuer des initialisations beaucoup plus riches et procéder à diverses vérifications de cohérence.

Après avoir exprimé le constructeur, on ajoute toutes les méthodes qui définissent le comportement de la classe.

class Citoyen :  
  '''Classe décrivant les attributs minimum d'un Français identifié''' 
 
  def __init__(self, nom, prenom, num_ss) : 
      self.nom    = nom 
      self.prenom = prenom 
      self.num_ss = num_ss  
 
  def genre(self) : # dans le num_ss le genre est 
                    # à la première position 
      ''' renvoie le genre de naissance d'un citoyen '''  
      return "féminin" if self.num_ss[0] == "2" else "masculin" ...