Trucs et astuces

Introduction

Dans les deux premières parties de cet ouvrage, vous avez découvert Python, puis vous avez appris à copier et à reproduire du code Python.

Cette troisième et dernière partie est beaucoup moins structurée que les autres. Il s’agit plus de montrer certains points et certaines possibilités du langage de manière croissante.

Au début, nous verrons quelques trucs et astuces et quelques notions déjà évoquées, mais présentées de manière plus approfondie. Vous trouverez aussi quelques exemples, dont certains sont volontairement récréatifs et didactiques, alors que d’autres ont une application bien réelle et pourraient vous rendre service.

Les deux derniers chapitres traitent d’outils et de logiciels écrits en Python.

Le chapitre Aller plus loin avec Python parle de quelques outils Python utilisables avec un peu d’investissement.

Tandis que le dernier chapitre évoque des logiciels écrits en Python, mais d’une dimension supérieure, où il est nécessaire de s’investir un peu plus pour bénéficier de leurs apports. Cependant, soyez sûr que le jeu en vaut la chandelle, et certains développeurs ont réellement apporté quelque chose, au moins pendant un temps, à l’informatique en général....

Adapter le copier/coller d’un tableur pour un wiki

Il s’agit d’un petit truc, qui peut rendre service et qui permet d’appréhender certaines choses.

Lorsque l’on souhaite copier/coller une sélection de cellules d’un tableur vers un wiki, on se retrouve avec une tabulation comme séparateur et il faut donc reformater le tableau en mode wiki, ce qui peut être fastidieux.

Mais grâce à Python, il est possible de modifier le contenu du clipboard (presse-papier).

Le clipboard, sous Linux, n’est pas quelque chose d’évident et, par exemple, pour le faire fonctionner, il a fallu installer un outil s’appelant xclip (sudo apt install xclip).

Il faut aussi installer le module clipboard avec ’pip install clipboard’.

Comment l’utilise-t-on ?

Il faut tout simplement sélectionner ses données dans la feuille de calcul et lancer un petit script.

Ensuite, il faut effectuer un copier/coller dans le wiki… c’est magique.

Copier depuis le tableur -> Lancer le script Python -> Coller dans le wiki.

Voici un exemple du résultat :

===> Sans le script python 
Colonne 1    Colonne 2 
100    200 
101    201 
 
===> Avec le script python 
^Colonne 1    ^Colonne 2    ^ 
|100    |200    | 
|101    |201    | ...

Déballage avec Python (unpacking)

Cela tient plus du sucre syntaxique que du vrai "truc et astuce", mais cela peut être très pratique.

Attention, c’est le genre de syntaxe qui ne saute pas forcément aux yeux et donc il y a un risque de perte de visibilité. Donc il faut bien commenter ce genre de syntaxe.

Dans les premiers chapitres où l’on découvre l’opérateur d’affectation ’=’, on découvre aussi la possibilité d’affecter plusieurs variables :

>>> a = b = c = 1 
>>> print(a,b,c) 
1 1 1 
 
>>> a,b,c = 1,2,3 
>>> print(a,b,c) 
1 2 3  

Mais il y a encore mieux avec l’opérateur ’*’.

Il est aussi possible d’affecter une variable et/ou une liste.

Voici quelques exemples :

>>> liste = list(range(0,9)) 
>>> liste 
[0, 1, 2, 3, 4, 5, 6, 7, 8] 
 
>>> *x, y, z = liste 
 
>>> print("x=",x," y=",y, " z=",z) 
x= [0, 1, 2, 3, 4, 5, 6]  y= 7  z= 8 
 
>>> x, *y, z = liste 
 
>>> print("x=",x," y=",y, " z=",z) 
x= 0  y= [1, 2, 3, 4, 5, 6, 7]  z= 8 
 
>>> x,y,*z = liste 
 
>>> print("x=",x," y=",y, " z=",z) ...

L’underscore et Python

L’underscore est un caractère multi-utilisation dans le langage Python.

Voici quelques trucs que l’on peut rencontrer dans du code.

>>> [ x for x in range(0,5)] 
[0, 1, 2, 3, 4] 
>>> _ 
4 
>>> _ * 2 
8 

>>> premier, _ , dernier   = (1,2,3) 
>>> print(premier, dernier) 
1 3 

>>> premier,*_, dernier = list(range(0,10)) 
>>> print(premier, dernier) 
0 9 
>>> _ 
[1, 2, 3, 4, 5, 6, 7, 8] 

>>> for _ in range(5): 
...   print(_) 
... 
0 
1 
2 
3 
4 

>>> 1024*1024*1024*1024 
1099511627776 
 
>>> 1_099_511_627_776 
1099511627776 
 
>>> 1_099_511_627_776 / 1024 / 1024 / 1024 
1024.0 

Agacer les CPU et mesurer le temps de son code

Voici deux trucs en un.

Le premier est assez simple, car le but est d’agacer un ou plusieurs CPU.

C’est plutôt facile à réaliser : il suffit de faire appel au calcul flottant sur une boucle suffisamment importante pour mesurer la chose.

Voici un petit exemple :

# fichier : timing/test_cpu1.py 
 
import time 
 
debut = time.time() 
 
num_mul = 50_000_000     #environ 15s 
data = range(num_mul) 
nombre = 1 
 
for i in data: 
   nombre *= 1.0000001 
 
fin = time.time() 
 
print("Resultat = {}".format(nombre)) 
print("Temps = {}".format(fin - debut)) 

Une boucle de 50 000 000 (50 millions) dure environ 15 s sur notre machine, à adapter en fonction du besoin.

Et cela "agace" bien un processeur.

CPU 100 %

Le deuxième truc est une version améliorée de la classe étudiée avec les gestionnaires de contexte : mesurer le temps d’une fonction, mais pouvoir aussi, dans certains cas, mesurer un temps intermédiaire.

Le principe est simple : pour avoir un gestionnaire de contexte, il faut une classe qui implémente les fonctions "spéciales" __enter__() et __exit_().

Et pour récupérer l’instance de la classe dans la syntaxe :

with <classe>...

Créer un décorateur (logger interne)

Cela a été vu dans un chapitre un peu plus haut, le décorateur n’est en fait qu’une fonction qui s’exécute avant une fonction.

Partant de là, cela peut être très pratique pour déboguer certains scripts, car il suffit de générer le log chaque fois que la fonction est appelée.

Voici un exemple de script :

#fichier : logueur/logueur1.py 
 
def logueur(function): 
   def fonction_interne( *args, **kwargs): 
       print("============ LOGUEUR ============") 
       print("Fonction : {}".format(function.__name__)) 
       print("Argument transmis : ") 
       print("  args    : {} ".format(args)) 
       print("  kwargs  : {} ".format(kwargs)) 
       print("================================") 
       return( function(*args, **kwargs) ) 
   return fonction_interne 
 
 
@logueur 
def test1( a, b ,c): 
   print(a, b ,c) 
 
@logueur 
def test2(a="?", b="?" , c="?"): 
   print(a,b,c) 
 
 
 
test1(...

Bien écrire du code Python (PEP8)

Python est un langage plutôt lisible. Il y a quelques années, l’auteur a testé la lecture de code Python sur des informaticiens ne connaissant pas le langage et quasiment tous pensaient saisir le sens du script.

Mais malgré cela, Guido Van Rossum et quelques autres codeurs recommandent un style d’écriture pour ce langage.

De là est né le PEP8 : https://www.python.org/dev/peps/pep-0008/

PEP (Python Enhancement Proposals) est une proposition d’amélioration du langage. 

Le point d’entrée se nomme le PEP 0 : https://www.python.org/dev/peps/

Rien ne vous oblige à écrire du code de cette manière, il s’agit avant tout de recommandations.

Et pour savoir si votre style de codage est éloigné de la "proposition" ou "norme" stylistique, il existe un utilitaire nommé pep8 qu’il suffit de lancer sur un script.

Voici par exemple le résultat sur un script à découvrir dans le chapitre suivant :

$ pep8 --ignore=E201,E202 python_bataille.py --statistics 
 
python_bataille.py:6:80: E501 line too long (120 > 79 characters) 
python_bataille.py:8:80: E501 line too long (87 > 79 characters) 
python_bataille.py:16:45: E211 whitespace before '(' 
python_bataille.py:28:1: E265 block comment should start with '# ' ...