Python

Dernière mise à jour : 02/01/2020

Les bases

Multithreading

A ne pas confondre avec multiprocessing. Avec des threads, on lance des programmes en //, et le système d’exploitation ou le processus parent gère comme il veut. Le multiprocessing consiste à forcer l’utilisation des différents cœurs d’un processeur.

import random 
import sys from threading
import Thread
import time

class Attente(Thread):
"""Thread chargé simplement d'afficher une lettre dans la console."""
def __init__(self, tps):
Thread.__init__(self)
self.attente = tps
def run(self):
"""Code à exécuter pendant l'exécution du thread."""
time.sleep(self.attente)
sys.stdout.write("Fin thread d'attente de {}\n".format(self.attente))
sys.stdout.flush()

# Création des threads
thread_1 = Attente(4)
thread_2 = Attente(7)
thread_3 = Attente(9)

# Lancement des threads
thread_1.start()
thread_2.start()
thread_3.start()

# Attend que les threads se terminent
thread_1.join()
thread_2.join()
thread_3.join()
  • https://www.tutorialspoint.com/python3/python_multithreading.htm  

Les décorateurs

Les décorateurs font de la « métaprogrammation », à savoir qu’ils ajoutent du code autour d’une fonction. Par l’exemple :

# Exemple avec décorateur
@decorateur
def fonction(…):
    …

Son équivalent est :

# Exemple équivalent, sans décorateur
def fonction(…):
    …
fonction = decorateur(fonction)

Ça n’a l’air de rien, mais ça permet de faire plein de choses très évoluées.

Interface graphique (Qt)

Un des avantages de Python est d’être multi plate-forme (pas comme Java). Un des gros manque de Python est qu’il n’a pas d’interface graphique native, ou que ce qui est proposé en standard (Tkinter) n’est pas très développé. Certes cela permet de rester multi plate-formes, mais au prix d’un interface graphique assez peu évoluée.

Après quelques recherches, j’ai trouvé un outil lui aussi multi plate-formes permettant de réaliser de zolies interfaces graphiques avec Python : Qt.

Qt n’est pas toujours simple, ni gratuit, mais peut toutefois être utilisé avec certaines licences libres comme GPL v2 ou GPL v3, ce qui est chouette pour un développeur du dimanche comme moi.

Concepts essentiels

Tout d’abord, pour développer en Python + Qt, il faut installer la version open source de Qt, en faisant bien attention aux compatibilités de versions. Il faut également faire la liaison entre Python et Qt grâce au module PyQt ou à PySide2 (cette dernière étant maintenue par Qt).

Layout, Widget et événements

En Python 3 et Qt 5, la plupart des objets dont on a besoin seront dans PySide2.QtWidgets. Leur nom est assez explicite, genre QApplication, QMainWindow, QDialog, QGridLayout, QLabel, QLineEdit, QPushButton, QTable, QGroupBox, QDateEdit, etc.

La notion de layout est celle communément connue par les développeurs, et celles des événements également. Seule subtilité : les événements sont des signaux (SIGNAL) et les récepteurs ou gestionnaires d’événements sont de type SLOT. Chacun a son vocabulaire, mais comme les fonctions de Qt sont nommées d’après cela, autant le savoir.

Utilisation de l’outil de conception

Il s’appelle QT Designer, mais sous Windows il faut chercher… designer !

Ensuite, le fichier issu de cet outil est en XML, suffixé par .ui. Pour le convertir en Python, il faut utiliser un transformateur, variant selon le module python utilisé :

  • PyQt ==> pyuic5.exe fichier.ui -o fichier.py
  • PySide2 ==> pyside2-uic mainwindow.ui > ui_mainwindow.py

En ce qui concerne les ressources, genre icônes, la manipulation est plus complexe. D’abord il faut un fichier .qrc dans lequel on ajoute les emplacements des ressources, puis on génère avec un autre outil un fichier Python.

  • PyQt ==> pyrcc5.exe dossier/ressources.qrc -o ressources_rc.py -py3
  • PySide2 ==> pyside2-rcc ?

Compiler un script Python en .exe

Je ne sais pas si mon titre est très académique, mais l’idée est d’avoir un .exe de son zoli programme Python. J’ai trouvé plein de tutos sur le sujet et plusieurs outils.