المكتبات القياسية في Python

من أبرز نقاط قوة Python مكتبتها القياسية الغنية، التي توفر مجموعة من الوحدات الجاهزة للاستخدام وتغطي طيفًا واسعًا من الوظائف. تتوفر هذه الوحدات في أي تثبيت لـ Python دون الحاجة إلى تنزيلات إضافية، مما يجعل Python لغة “batteries included” (البطاريات مضمّنة).

في هذا الدرس، سنستكشف بعضًا من أكثر وحدات المكتبة القياسية في Python فائدة، وكيفية استخدامها لحل مختلف المشكلات الشائعة.

استكشاف الوحدات الأساسية

datetime - التعامل مع التواريخ والأوقات

توفر الوحدة datetime فئات للتعامل مع التواريخ والأوقات.

from datetime import datetime, timedelta, date

# Date et heure actuelles
maintenant = datetime.now()
print(f"Date et heure actuelles : {maintenant}")

# Formater une date
date_formatee = maintenant.strftime("%d/%m/%Y %H:%M:%S")
print(f"Date formatée : {date_formatee}")

# Créer une date spécifique
date_specifique = datetime(2023, 12, 31, 23, 59, 59)
print(f"Réveillon du Nouvel An : {date_specifique}")

# Calculer la différence entre deux dates
difference = date_specifique - maintenant
print(f"Jours jusqu'au Nouvel An : {difference.days}")

# Ajouter un délai à une date
dans_une_semaine = maintenant + timedelta(days=7)
print(f"Dans une semaine : {dans_une_semaine}")

random - توليد الأعداد العشوائية

تفيد الوحدة random في توليد الأعداد العشوائية وإجراء اختيارات عشوائية.

import random

# Nombre aléatoire entre 0 et 1
nombre_aleatoire = random.random()
print(f"Nombre aléatoire entre 0 et 1 : {nombre_aleatoire}")

# Nombre entier aléatoire dans une plage
entier_aleatoire = random.randint(1, 100)
print(f"Entier aléatoire entre 1 et 100 : {entier_aleatoire}")

# Choix aléatoire dans une liste
fruits = ["pomme", "banane", "orange", "fraise", "kiwi"]
fruit_aleatoire = random.choice(fruits)
print(f"Fruit aléatoire : {fruit_aleatoire}")

# Mélanger une liste
random.shuffle(fruits)
print(f"Liste mélangée : {fruits}")

# Sélectionner k éléments uniques aléatoires
selection = random.sample(range(1, 51), 6)  # 6 numéros pour un tirage de loto
print(f"Tirage du loto : {selection}")

math - الدوال الرياضية

توفر الوحدة math دوال رياضية متقدمة.

import math

# Constantes mathématiques
print(f"Pi : {math.pi}")
print(f"e : {math.e}")

# Fonctions trigonométriques (en radians)
print(f"sin(π/2) : {math.sin(math.pi/2)}")
print(f"cos(π) : {math.cos(math.pi)}")

# Logarithmes
print(f"log(10) (base e) : {math.log(10)}")
print(f"log10(100) : {math.log10(100)}")

# Racine carrée et puissance
print(f"Racine carrée de 16 : {math.sqrt(16)}")
print(f"2 puissance 10 : {math.pow(2, 10)}")

# Arrondi
print(f"Arrondi inférieur de 3.7 : {math.floor(3.7)}")
print(f"Arrondi supérieur de 3.7 : {math.ceil(3.7)}")

collections - هياكل بيانات متخصصة

توفر الوحدة collections بدائل لهياكل البيانات المدمجة.

from collections import Counter, defaultdict, namedtuple, deque

# Counter - Compter les occurrences
texte = "Mississippi"
compteur = Counter(texte)
print(f"Occurrences des lettres : {compteur}")
print(f"Lettres les plus fréquentes : {compteur.most_common(2)}")

# defaultdict - Dictionnaire avec valeur par défaut
dd = defaultdict(list)  # La valeur par défaut est une liste vide
dd["fruits"].append("pomme")
dd["fruits"].append("banane")
dd["legumes"].append("carotte")
print(f"defaultdict : {dict(dd)}")

# namedtuple - Tuples avec des champs nommés
Point = namedtuple('Point', ['x', 'y'])
p = Point(11, y=22)
print(f"Point : {p}, Coordonnées : x={p.x}, y={p.y}")

# deque - Double-ended queue (file double terminaison)
d = deque(["a", "b", "c"])
d.append("d")         # Ajouter à droite
d.appendleft("z")     # Ajouter à gauche
print(f"deque : {d}")

re - التعبيرات النمطية

تتيح الوحدة re العمل مع التعبيرات النمطية (Regular Expressions) للبحث في النصوص ومعالجتها.

import re

texte = "Contactez-moi à john.doe@example.com ou jane_smith@company.org"

# Rechercher une correspondance
if re.search(r"@example\.com", texte):
    print("Adresse e-mail example.com trouvée!")

# Trouver toutes les adresses e-mail
pattern = r"\b[A-Za-z0-9._%+-]+@[A-Za-z0-9.-]+\.[A-Z|a-z]{2,}\b"
emails = re.findall(pattern, texte)
print(f"Adresses e-mail trouvées : {emails}")

# Remplacer du texte
texte_anonymise = re.sub(pattern, "[EMAIL REMOVED]", texte)
print(f"Texte anonymisé : {texte_anonymise}")

# Séparation d'une chaîne
date = "2023-11-24"
annee, mois, jour = re.split(r"-", date)
print(f"Année : {annee}, Mois : {mois}, Jour : {jour}")

os - واجهة التعامل مع نظام التشغيل

توفر الوحدة os دوال للتفاعل مع نظام التشغيل.

import os

# Informations sur le système
print(f"Nom du système d'exploitation : {os.name}")
print(f"Répertoire de travail actuel : {os.getcwd()}")
print(f"Contenu du répertoire : {os.listdir('.')}")

# Variables d'environnement
print(f"Variable PATH : {os.environ.get('PATH')}")

# Manipulation de chemins (voir aussi le module os.path)
chemin = os.path.join("dossier", "sous_dossier", "fichier.txt")
print(f"Chemin joint : {chemin}")
print(f"Nom de base : {os.path.basename(chemin)}")
print(f"Répertoire : {os.path.dirname(chemin)}")

sys - الإعدادات الخاصة بالنظام

توفر الوحدة sys دوال ومتغيرات خاصة بنظام Python.

import sys

# Informations sur l'interpréteur Python
print(f"Version de Python : {sys.version}")
print(f"Plateforme : {sys.platform}")

# Arguments de ligne de commande
print(f"Arguments : {sys.argv}")

# Chemins de recherche de modules
print(f"Chemins de recherche : {sys.path}")

# Entrée/sortie standard
sys.stdout.write("Ceci est écrit sur la sortie standard\n")
sys.stderr.write("Ceci est un message d'erreur\n")

json - التعامل مع بيانات JSON

تتيح الوحدة json العمل مع البيانات بصيغة JSON.

import json

# Dictionnaire Python
donnees = {
    "nom": "Alice",
    "age": 30,
    "langages": ["Python", "JavaScript", "Go"],
    "adresse": {
        "rue": "123 Rue Principale",
        "ville": "Paris",
        "code_postal": "75001"
    }
}

# Conversion Python -> JSON (sérialisation)
json_str = json.dumps(donnees, indent=4)
print(f"JSON formaté :\n{json_str}")

# Conversion JSON -> Python (désérialisation)
obj = json.loads(json_str)
print(f"Prénom : {obj['nom']}, Âge : {obj['age']}")

# Écrire dans un fichier JSON
with open("donnees.json", "w") as f:
    json.dump(donnees, f, indent=4)

# Lire depuis un fichier JSON
with open("donnees.json", "r") as f:
    donnees_lues = json.load(f)
    print(f"Données lues du fichier : {donnees_lues['nom']}")

time - الدوال المتعلقة بالوقت

توفر الوحدة time دوال للتعامل مع الوقت.

import time

# Timestamp actuel (secondes depuis l'époque Unix)
timestamp = time.time()
print(f"Timestamp actuel : {timestamp}")

# Convertir timestamp en temps local
temps_local = time.localtime(timestamp)
print(f"Année : {temps_local.tm_year}, Mois : {temps_local.tm_mon}, Jour : {temps_local.tm_mday}")

# Formater le temps
temps_formate = time.strftime("%Y-%m-%d %H:%M:%S", temps_local)
print(f"Temps formaté : {temps_formate}")

# Mesurer le temps d'exécution
debut = time.time()
# Simuler une opération longue
time.sleep(1)
fin = time.time()
print(f"Temps d'exécution : {fin - debut} secondes")

argparse - تحليل وسائط سطر الأوامر

تسهّل الوحدة argparse كتابة واجهات سطر أوامر سهلة الاستخدام.

import argparse

def main():
    # Créer un parser d'arguments
    parser = argparse.ArgumentParser(description='Un exemple de programme en ligne de commande')
    
    # Ajouter des arguments
    parser.add_argument('fichier', help='fichier à traiter')
    parser.add_argument('-v', '--verbose', action='store_true', help='activer la verbosité')
    parser.add_argument('-o', '--output', help='fichier de sortie')
    parser.add_argument('-n', '--number', type=int, default=1, help='nombre d\'itérations')
    
    # Parser les arguments
    args = parser.parse_args()
    
    # Utiliser les arguments
    print(f"Fichier à traiter : {args.fichier}")
    if args.verbose:
        print("Mode verbeux activé")
    if args.output:
        print(f"Fichier de sortie : {args.output}")
    print(f"Nombre d'itérations : {args.number}")

if __name__ == "__main__":
    main()

itertools - دوال للمكرِّرات الفعّالة

توفر الوحدة itertools دوال تنشئ مكرِّرات (iterators) لحلقات تكرار فعّالة.

import itertools

# Générer des combinaisons
nombres = [1, 2, 3]
for combo in itertools.combinations(nombres, 2):
    print(f"Combinaison : {combo}")

# Générer des permutations
for perm in itertools.permutations([1, 2, 3], 2):
    print(f"Permutation : {perm}")

# Produit cartésien
for prod in itertools.product("AB", "12"):
    print(f"Produit : {''.join(prod)}")

# Cycles infinis
cycleur = itertools.cycle(["rouge", "vert", "bleu"])
for _ in range(6):
    print(f"Couleur : {next(cycleur)}")

# Regrouper des éléments
donnees = [("A", 1), ("A", 2), ("B", 1), ("B", 2)]
for cle, groupe in itertools.groupby(donnees, lambda x: x[0]):
    print(f"Groupe {cle} : {list(groupe)}")

logging - تسجيل الأحداث

توفر الوحدة logging نظامًا مرنًا لتسجيل الأحداث (Logging).

import logging

# Configuration de base
logging.basicConfig(
    level=logging.INFO,
    format='%(asctime)s - %(name)s - %(levelname)s - %(message)s',
    filename='app.log'
)

# Différents niveaux de log
logging.debug("Ce message est au niveau DEBUG")
logging.info("Ce message est au niveau INFO")
logging.warning("Ce message est au niveau WARNING")
logging.error("Ce message est au niveau ERROR")
logging.critical("Ce message est au niveau CRITICAL")

# Utiliser un logger spécifique
logger = logging.getLogger('mon_application')
logger.info("Information de mon_application")

# Exception logging
try:
    1 / 0
except Exception as e:
    logging.exception("Une erreur s'est produite")

urllib - وحدات التعامل مع عناوين URL

تتيح الوحدة urllib العمل مع عناوين URL وإرسال طلبات HTTP.

import urllib.request
import urllib.parse
import json

# Effectuer une requête GET simple
with urllib.request.urlopen('https://httpbin.org/get') as response:
    data = json.loads(response.read().decode())
    print(f"URL : {data['url']}")

# Effectuer une requête POST
params = urllib.parse.urlencode({'name': 'John', 'age': 30}).encode()
req = urllib.request.Request('https://httpbin.org/post', data=params, method='POST')
with urllib.request.urlopen(req) as response:
    data = json.loads(response.read().decode())
    print(f"Données envoyées : {data['form']}")

# Analyser une URL
url = "https://www.example.com/path?param1=value1&param2=value2"
parsed_url = urllib.parse.urlparse(url)
print(f"Schéma : {parsed_url.scheme}, Domaine : {parsed_url.netloc}, Chemin : {parsed_url.path}")
print(f"Paramètres : {urllib.parse.parse_qs(parsed_url.query)}")

functools - الدوال عالية المستوى والعمليات على الدوال

توفر الوحدة functools أدوات للتعامل مع الدوال والكائنات القابلة للاستدعاء (callables).

import functools

# Décorateur pour mettre en cache les résultats d'une fonction
@functools.lru_cache(maxsize=None)
def fibonacci(n):
    if n < 2:
        return n
    return fibonacci(n-1) + fibonacci(n-2)

print(f"Fibonacci de 30 : {fibonacci(30)}")
print(f"Statistiques du cache : {fibonacci.cache_info()}")

# Fonction partielle (fixe certains arguments)
def multiplier(x, y):
    return x * y

doubler = functools.partial(multiplier, 2)
tripler = functools.partial(multiplier, 3)

print(f"Doubler 5 : {doubler(5)}")
print(f"Tripler 5 : {tripler(5)}")

# reduce - Appliquer une fonction cumulativement
nombres = [1, 2, 3, 4, 5]
somme = functools.reduce(lambda x, y: x + y, nombres)
print(f"Somme : {somme}")

وحدات لحالات استخدام محددة

statistics - الدوال الإحصائية

توفر الوحدة statistics دوال لحساب الإحصاءات الأساسية.

import statistics

donnees = [2, 4, 4, 4, 5, 5, 7, 9]

print(f"Moyenne : {statistics.mean(donnees)}")
print(f"Médiane : {statistics.median(donnees)}")
print(f"Mode : {statistics.mode(donnees)}")
print(f"Écart-type : {statistics.stdev(donnees)}")
print(f"Variance : {statistics.variance(donnees)}")

sqlite3 - واجهة التعامل مع SQLite

توفر الوحدة sqlite3 واجهة لاستخدام قاعدة بيانات SQLite.

import sqlite3

# Connexion à une base de données (sera créée si elle n'existe pas)
conn = sqlite3.connect('exemple.db')
cursor = conn.cursor()

# Créer une table
cursor.execute('''
CREATE TABLE IF NOT EXISTS utilisateurs (
    id INTEGER PRIMARY KEY,
    nom TEXT NOT NULL,
    email TEXT UNIQUE,
    age INTEGER
)
''')

# Insérer des données
cursor.execute("INSERT INTO utilisateurs (nom, email, age) VALUES (?, ?, ?)",
                ("Alice", "alice@example.com", 30))
cursor.execute("INSERT INTO utilisateurs (nom, email, age) VALUES (?, ?, ?)",
                ("Bob", "bob@example.com", 25))

# Valider les changements
conn.commit()

# Requête SELECT
cursor.execute("SELECT * FROM utilisateurs")
for row in cursor.fetchall():
    print(f"Utilisateur : {row}")

# Fermer la connexion
conn.close()

uuid - توليد معرّفات فريدة عالميًا

تتيح الوحدة uuid توليد معرّفات فريدة عالميًا.

import uuid

# Générer différents types d'UUID
print(f"UUID1 (basé sur l'horloge) : {uuid.uuid1()}")
print(f"UUID4 (aléatoire) : {uuid.uuid4()}")

# Créer un UUID à partir d'un nom
namespace = uuid.NAMESPACE_DNS
nom = "example.com"
uuid5 = uuid.uuid5(namespace, nom)
print(f"UUID5 (basé sur un nom) : {uuid5}")

hashlib - دوال التجزئة التشفيرية

تنفّذ الوحدة hashlib عدة دوال تجزئة تشفيرية.

import hashlib

# Hacher une chaîne avec différents algorithmes
texte = "Bonjour, monde!"
print(f"MD5 : {hashlib.md5(texte.encode()).hexdigest()}")
print(f"SHA-1 : {hashlib.sha1(texte.encode()).hexdigest()}")
print(f"SHA-256 : {hashlib.sha256(texte.encode()).hexdigest()}")
print(f"SHA-512 : {hashlib.sha512(texte.encode()).hexdigest()}")

# Hachage incrémental
h = hashlib.sha256()
h.update(b"Partie 1 du message")
h.update(b"Partie 2 du message")
print(f"Hachage incrémental : {h.hexdigest()}")

concurrent.futures - التنفيذ المتوازي للمهام

توفر الوحدة concurrent.futures واجهات للتنفيذ غير المتزامن للمهام.

import concurrent.futures
import time

def tache_longue(n):
    """Simule une tâche qui prend du temps"""
    time.sleep(n)
    return f"Tâche {n} terminée après {n} secondes"

# Exécution en parallèle avec ThreadPoolExecutor
with concurrent.futures.ThreadPoolExecutor(max_workers=3) as executor:
    taches = [1, 2, 3, 4, 5]
    futurs = {executor.submit(tache_longue, t): t for t in taches}
    
    for futur in concurrent.futures.as_completed(futurs):
        tache = futurs[futur]
        try:
            resultat = futur.result()
            print(f"Résultat de la tâche {tache}: {resultat}")
        except Exception as e:
            print(f"Tâche {tache} a généré une exception: {e}")

shutil - عمليات عالية المستوى على الملفات

توفّر الوحدة shutil عمليات عالية المستوى على الملفات ومجموعات الملفات.

import shutil
import os

# إنشاء مجلد للاختبارات
os.makedirs("test_dossier", exist_ok=True)
with open("test_dossier/test.txt", "w") as f:
    f.write("Contenu de test")

# نسخ ملف
shutil.copy("test_dossier/test.txt", "test_dossier/test_copie.txt")

# نسخ مجلد كامل
shutil.copytree("test_dossier", "test_dossier_copie")

# نقل ملف
shutil.move("test_dossier/test_copie.txt", "test_dossier/test_deplace.txt")

# حذف مجلد ومحتوياته
shutil.rmtree("test_dossier_copie")

# أرشفة مجلد
shutil.make_archive("archive_test", "zip", "test_dossier")

الخلاصة

المكتبة القياسية في Python واسعة وتغطي عددًا كبيرًا من الوظائف. وقد اكتفى هذا الدرس بالإلمام بسطح ما هو متاح فيها. فبمجرد أن تتعوّد على هذه الوحدات، ستتمكن من حل كثير من المشكلات الشائعة دون الحاجة إلى تثبيت حزم خارجية.

إليك بعض النصائح للاستفادة القصوى من المكتبة القياسية:

1. اطّلع على الوثائق الرسمية: تحتوي وثائق Python على معلومات مفصلة عن جميع وحدات المكتبة القياسية.

2. فضّل الحلول القياسية: قبل تثبيت حزمة خارجية، تحقق مما إذا كانت المكتبة القياسية توفر حلًا جاهزًا.

3. استكشف المستجدات: مع كل إصدار جديد من Python، تُضاف وحدات أو وظائف جديدة إلى المكتبة القياسية.

في الدرس القادم والأخير من هذه السلسلة، سنطبّق عمليًا كل ما تعلمناه من خلال إنشاء مشروع Python متكامل يستخدم عددًا من المفاهيم والوحدات التي استعرضناها حتى الآن.