Expressions régulières:

import re

def ERpair(nb):
    if re.fullmatch(r'[01]*0', nb):
        return 1
    else:
        return 0

print(ERpair('0101')) 
print(ERpair('0101 0000'))  

# Exemple:
ph = "Prix: 41$, Convert: 35.67€, Promo: 12$ | 10€"

entiers = re.findall(r'(?<!\.)\b\d+\b(?!\.)', ph)
decimaux = re.findall(r'\b\d+\.\d+\b', ph)

print("Entiers :", entiers)
print("Décimaux :", decimaux)

emails = [
    "alice@gmail.com",
    "bob@ensam.ac.ma",
    "john.doe@company.org",
    "wrong.email@com",
    "no-at-symbol.com"
]

def mailVal(ch):
    pattern = r'^[\w\.-]+@[\w\.-]+\.\w{2,}$'
    return bool(re.fullmatch(pattern, ch))

for e in emails:
    print(e, "->", mailVal(e))

def validImm(h):
    pattern = r'^[1-9]\d{0,3}\s*\|\s*[A-Z]\s*\|\s*[1-9]\d?$'
    return bool(re.fullmatch(pattern, h))

print(validImm("7688 | A | 1"))
print(validImm("0042 | B | 05"))

def validHeure(h):
    import re
    pattern = r'^(?:[01]\d|2[0-3]):[0-5]\d:[0-5]\d$'
    return bool(re.fullmatch(pattern, h))

h='24:33:55'
print(validHeure(h))

def validTel(PN):
    pattern = r'^(?:\+212|0)(6|7)\d{8}$'
    return bool(re.fullmatch(pattern, PN))

print(validTel("0612345678"), validTel("+212712345678"), validTel("0512345678"))

text = "Bonjour!!! Python@@@ est*** magnifique..."
n_text = re.sub(r'[^A-Za-zÀ-ÖØ-öø-ÿ0-9\s]', '', text)
print(n_text)

logs="""[INFO] 2025-11-02 10:45:23 - User Alice connected
[ERROR] 2025-11-02 10:46:01 - Connection timeout
[WARNING] 2025-11-02 10:47:15 - Low disk space
[INFO] 2025-11-02 10:48:05 - User Bob disconnected
[INFO] 2025-11-02 25:00:00 - User Eve connected
[ERROR] 2025-02-30 12:00:00 - Invalid date
"""

with open("logs.txt", "w") as f:
    f.write(logs)

import re
fichier = "logs.txt"

timestamps = []
dates = []
heures = []
niveaux = []
utilisateurs = []

fichiers_logs = {
    "INFO": [],
    "ERROR": [],
    "WARNING": []
}

regex_timestamp = r'\d{4}-\d{2}-\d{2} \d{2}:\d{2}:\d{2}'
regex_date = r'\d{4}-\d{2}-\d{2}'
regex_heure = r'\d{2}:\d{2}:\d{2}'
regex_niveau = r'\[(INFO|ERROR|WARNING)\]'
regex_user = r'User (\w+)'

def heure_valide(h):
    motif = r'^([01][0-9]|2[0-3]):[0-5][0-9]:[0-5][0-9]$'
    return bool(re.fullmatch(motif, h))

def date_valide(d):
    motif = r'^(?:[12]\d{3})-(0[1-9]|1[0-2])-(0[1-9]|[12]\d|3[01])$'
    m = re.fullmatch(motif, d)
    if not m:
        return False
    annee, mois, jour = map(int, d.split('-'))
    if mois in [4, 6, 9, 11] and jour > 30:
        return False
    if mois == 2 and jour > 29:
        return False
    return True

with open(fichier, "r") as f:
    for ligne in f:
        ligne = ligne.strip()
        
        
        ts_match = re.search(regex_timestamp, ligne)
        if ts_match:
            ts = ts_match.group()
            date_part, heure_part = ts.split(' ')
            if date_valide(date_part) and heure_valide(heure_part):
                timestamps.append(ts)
                dates.append(date_part)
                heures.append(heure_part)
        
        n = re.search(regex_niveau, ligne)
        if n:
            niveau = n.group(1)
            niveaux.append(niveau)
            fichiers_logs[niveau].append(ligne)
            
            if niveau == "INFO":
                u = re.search(regex_user, ligne)
                if u:
                    utilisateurs.append(u.group(1))

print("Timestamps :", timestamps)
print("Dates :", dates)
print("Heures :", heures)
print("Niveaux :", niveaux)
print("Utilisateurs (INFO) :", utilisateurs)

for niveau, lignes in fichiers_logs.items():
    nom_fichier = f"{niveau}.txt"
    with open(nom_fichier, "w") as f:
        for l in lignes:
            f.write(l + "\n")

def MultTrois(nb):
    return int(int(nb, 2) % 3 == 0) 

print(MultTrois('110'), MultTrois('111'))

import numpy as np

M = np.array([[2, 1], [1, 2]])
valeurs_propres, vecteurs_propres = np.linalg.eig(M)

print("Valeurs propres :", valeurs_propres)
print("Vecteurs propres :\n", vecteurs_propres)

for i in range(len(valeurs_propres)):
    v = vecteurs_propres[:, i]
    λ = valeurs_propres[i]
    print(np.allclose(M @ v, λ * v))

class Forme:
    def surface(self):
        pass

class Rectangle(Forme):
    def __init__(self, longueur, largeur):
        self.longueur = longueur
        self.largeur = largeur
    
    def surface(self):
        return self.longueur * self.largeur

class Carre(Rectangle):
    def __init__(self, cote):
        super().__init__(cote, cote)

class Triangle(Forme):
    def __init__(self, base, hauteur):
        self.base = base
        self.hauteur = hauteur
    
    def surface(self):
        return (self.base * self.hauteur) / 2

r = Rectangle(8, 4)
c = Carre(8)
t = Triangle(7, 3)

print("Surface rectangle:", r.surface())
print("Surface carré:", c.surface())
print("Surface triangle:", t.surface())

import numpy as np

notes = np.array([
    [12, 15, 14],
    [10, 13, 11],
    [14, 16, 15],
    [9, 12, 10],
    [13, 14, 13]
])

moyenne_individuelle = notes.mean(axis=1)
for idx, moyenne in enumerate(moyenne_individuelle, start=1):
    print(f"Moyenne de l'étudiant {idx} : {moyenne:.2f}")

moy_matiere = np.mean(notes, axis=0)
for idx, moyenne in enumerate(moy_matiere, start=1):
    print(f"Moyenne de la matière {idx} : {moyenne:.2f}")

ecart_type = np.std(notes, axis=0)
print("Écart type par matière :")
for idx, ec in enumerate(ecart_type, start=1):
    print(f"Matière {idx} : {ec:.2f}")