librairies Standard
dans cette partie, nous allons découvrir quelques librairies intéressantes de Python qui pourront vous servir au quotidien.
Le module math()
Le module Math contient un ensemble d’éléments permettant
d’exécuter les opérations mathématiques avec python. L’utilisation des
opérations mathématiques dans python débute par l’importation du module math.
Un module est un package qui contient diverses
classes et fonctions permettant de réaliser différentes taches sur python.
En python, l’importation d’un module se fait de
3 façon :
-From module import class ou fonction
-import module
-import module as mot_clé
Exemple :
Import math
Print(math.sin(90))
Print(math.acos(0.5))
Voici en
détail toutes les voici du module math :
'__doc__', '__loader__',
'__name__', '__package__', '__spec__', 'acos', 'acosh', 'asin', 'asinh',
'atan', 'atan2', 'atanh', 'ceil', 'copysign', 'cos', 'cosh', 'degrees', 'e',
'erf', 'erfc', 'exp', 'expm1', 'fabs', 'factorial', 'floor', 'fmod', 'frexp',
'fsum', 'gamma', 'gcd', 'hypot', 'inf', 'isclose', 'isfinite', 'isinf',
'isnan', 'ldexp', 'lgamma', 'log', 'log10', 'log1p', 'log2', 'modf', 'nan',
'pi', 'pow', 'radians', 'remainder', 'sin', 'sinh', 'sqrt', 'tan', 'tanh',
'tau', 'trunc'
Le module Random()
La class random permet de genérer des nombres
aléatoires compris entre 0 et 1
Import random
a=random.random()
print(a)
la class random contient elle-même aussi des
fonctions :
-randrange(A,B,C) : permet de générer des
nombres aléatoires compris entre A et B avec un intervalle de C
Cette instruction va chercher à générer un
nombre aléatoire entre 5 inclus et 10 non inclus, avec un écart de 2 entre
chaque valeur. Elle va donc chercher dans la liste des valeurs [5, 7, 9]. Si
vous ne précisez pas de troisième paramètre, il vaudra 1 par défaut.
Exemple :
from random import randrange
a=randrange(10)
print(a)
-shuffle(list_à_melanger) : permet de
mélanger une liste ou un tuple
-choice(list_à_choisir) : permet de
choisir un élément dans une liste ou un tuple
Exemple :
import random
nom=["neji","naruto","itachi","sasuke","gaara"]
a=random.choice (nom)
random.shuffle (nom)
print(a, nom)
neji ['gaara', 'naruto',
'itachi', 'sasuke', 'neji']
le module Time()
Le module Time permet
la temporisation des évènements.
Pour afficher la date l’on utilise le code
suivant :
Import time
Temps=time.strftime("%A %d %B %Y %H:%M:%S")
Ce code
affiche la date du jour ainsi que l’heure, la minute et la seconde
|
Symbole |
Signication |
|
%A |
Nom du jour de la semaine |
|
%B |
Nom du mois |
|
%d |
Jour du mois (de 01 à 31) |
|
%H |
Heure (de 00 à 23) |
|
%M |
Minute (entre 00 et 59) |
|
%S |
Seconde (de 00 à 59) |
|
%Y |
Année |
Pour mettre le code en pause, on utilise la
fonction sleep(nombre de seconde)
Import time
Temps=time.sleep(0.5) # met le programme en
pause pour 0.5 seconde
Le module
pySerial()
La bibliothèque pySerial est un module Python
qui permet de communiquer avec des périphériques série (comme les ports COM,
les adaptateurs USB vers série, etc.). Voici un aperçu des principales classes
et fonctions de pySerial :
serial.Serial :
Rôle : Cette
classe permet d’ouvrir et de configurer un port série pour la communication.
Paramètres :
port : Nom du périphérique (par exemple,
“/dev/ttyUSB0” sous GNU/Linux ou “COM3” sous Windows). baudrate : Vitesse de
transmission (par exemple, 9600, 115200, etc.).
bytesize : Nombre de bits de données (FIVEBITS,
SIXBITS, SEVENBITS, EIGHTBITS).
parity : Contrôle de parité (PARITY_NONE, PARITY_EVEN,
PARITY_ODD, etc.).
stopbits : Nombre de bits d’arrêt (STOPBITS_ONE,
STOPBITS_ONE_POINT_FIVE, STOPBITS_TWO). timeout : Temps d’attente pour la
lecture (en secondes).
xonxoff, rtscts, dsrdtr : Contrôle de flux logiciel et
matériel.
write_timeout : Temps d’attente pour l’écriture.
inter_byte_timeout : Temps d’attente entre les octets
(None pour désactiver).
exclusive : Mode d’accès exclusif (uniquement sur
POSIX).
Exemple :
import serial
ser = serial.Serial(port='/dev/ttyUSB0', baudrate=9600, timeout=1)
serial.tools.list_ports :
Rôle : Cette
fonction renvoie une liste des ports série disponibles sur le système.
Exemple :
from serial.tools import list_ports
available_ports = list(list_ports.comports())
serial.SerialException :
Rôle :
Exception levée en cas d’erreur lors de la configuration du port série.
Exemple :
try:
ser =
serial.Serial(port='/dev/ttyUSB0',
baudrate=9600)
except serial.SerialException
as e:
print(f"Erreur : {e}")
serial.Serial.read(size) :
Rôle : Lit size
octets depuis le port série.
Exemple :
data = ser.read(10) # Lit 10
octets
serial.Serial.write(data) :
Rôle : Écrit
les données spécifiées dans le port série.
Exemple :
ser.write(b"Hello,
world!") # Écrit une chaîne d'octets
serial.Serial.close() :
Rôle : Ferme le
port série.
Exemple :
ser.close()
Ces
fonctions et classes vous permettent d’établir des connexions série, de lire et
d’écrire des données.
Le module itertools()
itertools est
une bibliothèque puissante et flexible qui peut vous aider à écrire du code
plus propre et plus efficace, en particulier lorsque vous travaillez avec de
grandes collections de données ou lorsque vous avez besoin de réaliser des
opérations complexes sur des séquences. Voici des exemples d’utilisation de
certaines fonctions de la bibliothèque itertools en Python :
count() :
from itertools import count
for num in count(10):
if num > 15:
break
print(num)
cycle() :
from itertools import cycle
colors = ['red', 'green', 'blue']
color_cycle = cycle(colors)
for _ in range(6):
print(next(color_cycle))
repeat() :
from itertools import repeat
repeated_values = repeat(10, 3)
print(list(repeated_values))
accumulate() :
from itertools import accumulate
numbers = [1, 2, 3, 4, 5]
cumulative_sums = accumulate(numbers)
print(list(cumulative_sums))
chain() :
from itertools import chain letters = 'ABC'
digits = '123'
combined = chain(letters, digits)
print(list(combined))
compress() :
from itertools import compress
data = 'ABCDEF'
selector = [1, 0, 1, 0, 1, 1]
filtered_data = compress(data, selector)
print(list(filtered_data))
groupby() :
from itertools import groupby
animals = ['cat', 'dog', 'elephant', 'eagle', 'ant']
key_func = lambda x: x[0]
grouped_animals = groupby(animals, key_func)
for key, group in grouped_animals:
print(f"Animals starting with '{key}': {list(group)}")
islice() :
from itertools import islice
letters = 'ABCDEFG'
sliced_letters = islice(letters, 2, None)
print(list(sliced_letters))
starmap() :
from itertools import starmap
def power(x, y):
return x ** y
values = [(2, 5), (3, 2), (10, 3)]
results = starmap(power, values)
print(list(results))
takewhile() :
from itertools import takewhile
numbers = [1, 4, 6, 3, 8]
filtered_numbers
= takewhile(lambda x: x < 5, numbers)
print(list(filtered_numbers))
le module
argparse()
La bibliothèque argparse est un module de la
bibliothèque standard de Python qui permet de gérer les arguments passés en
ligne de commande. Elle est très utile pour créer des scripts qui sont faciles
à utiliser et qui fournissent des messages d’aide utiles. argparse rend
l’analyse des arguments de ligne de commande aussi facile que de définir les
arguments attendus et de les associer à des actions spécifiques dans le script.
Il génère également automatiquement des messages d’aide et d’usage et gère les
erreurs d’arguments.
Création d’un analyseur d’arguments
Pour utiliser argparse, vous commencez par créer un
objet ArgumentParser :
import argparse
parser = argparse.ArgumentParser(description='Description de votre programme.')
Ajout d’arguments
Ensuite, vous utilisez la méthode add_argument() pour
ajouter des arguments à votre programme :
parser.add_argument('echo', help='description
de ce que fait cet argument')
Analyse des arguments
Une fois que vous avez ajouté tous vos arguments, vous
utilisez la méthode parse_args() pour analyser les arguments de ligne de
commande :
args = parser.parse_args() print(args.echo)
Exemple complet
Voici un exemple de script qui utilise argparse pour
accepter un nombre et un mode d’opération (somme ou maximum) :
import argparse
# Création de l'analyseur
parser = argparse.ArgumentParser(description='Traite quelques entiers.')
# Ajout des arguments
parser.add_argument('integers', metavar='N', type=int, nargs='+', help='un
entier pour l\'accumulateur')
parser.add_argument('--sum', dest='accumulate', action='store_const', const=sum, default=max,
help='somme
les entiers (par défaut: trouve le max)')
# Analyse des arguments
args = parser.parse_args()
# Affichage du résultat
print(args.accumulate(args.integers))
Si vous enregistrez ce script sous le nom prog.py,
vous pouvez l’exécuter avec différents arguments pour voir comment il
fonctionne :
$ python prog.py 1 2 3 4 4
$ python prog.py 1 2 3 4 --sum 10
Arguments positionnels vs Arguments optionnels
Les arguments positionnels sont ceux qui
doivent être inclus et qui ont un ordre spécifique.
Les arguments optionnels sont précédés de -- et
peuvent être omis. Ils peuvent également inclure des actions supplémentaires
comme store_true ou store_const.
Sous-commandes
argparse permet également de définir des sous-commandes,
qui sont des commandes qui ont leurs propres arguments :
# Création de sous-analyseurs
subparsers = parser.add_subparsers(help='sub-command help')
# Création d'une sous-commande
parser_a=
subparsers.add_parser('commande_a', help='a help') parser_a.add_argument('bar', type=int, help='bar
help')
le module
sys()
La bibliothèque sys en Python fournit des
fonctions et des variables utilisées pour manipuler différentes parties de
l’environnement d’exécution Python. Voici un aperçu des principales classes et
fonctions de la bibliothèque sys :
sys.argv :
Rôle : Cette
liste contient les arguments passés en ligne de commande à un script Python.
sys.argv[0] est le nom du script (il peut s’agir d’un
chemin complet ou non).
Si le script a été exécuté avec l’option -c de la
ligne de commande, sys.argv[0] est défini sur la chaîne “-c”. Si aucun nom de
script n’a été passé à l’interpréteur Python, sys.argv[0] est une chaîne vide.
Exemple :
import sys
print(f"Nom
du script : {sys.argv[0]}")
print(f"Arguments
passés : {sys.argv[1:]}")
sys.path :
Rôle : Cette
liste contient les chemins de recherche pour les modules Python. Les modules
sont recherchés dans ces répertoires lorsqu’ils sont importés.
Exemple :
import sys
print(f"Chemins
de recherche des modules : {sys.path}")
sys.version :
Rôle : Cette
chaîne contient la version actuelle de Python.
Exemple :
import sys
print(f"Version
de Python : {sys.version}")
sys.exit(code=0) :
Rôle : Cette
fonction termine l’exécution du programme Python avec le code de sortie
spécifié (par défaut, 0).
Exemple :
import sys
print("Fin
du programme.")
sys.exit(1) # Quitte
le programme avec le code de sortie 1
sys.platform :
Rôle : Cette
chaîne contient le nom de la plate-forme sur laquelle Python est en cours
d’exécution (par exemple, “win32”, “linux”, “darwin”, etc.).
Exemple :
import sys
print(f"Plate-forme
: {sys.platform}")
La
bibliothèque sys est utile pour accéder à des informations sur
l’environnement d’exécution Python et pour contrôler le flux d’exécution.
.png)
Commentaires
Enregistrer un commentaire