# Guide Complet des Modules Python Essentiels

## 1. Module `random` - Génération de nombres aléatoires

Le module `random` implémente des générateurs de nombres pseudo-aléatoires pour diverses

distributions. Il est essentiel pour les simulations, les jeux, les tests et l'échantillonnage.

### Fonctions de génération de nombres

```python
import random

# random() - Nombre flottant aléatoire entre 0.0 et 1.0 (exclu)

x = [Link]()
print(x) # Ex: 0.7234156789

# uniform(a, b) - Nombre flottant aléatoire entre a et b

prix = [Link](10.0, 50.0)
print(f"{prix:.2f}€") # Ex: 27.45€

# randint(a, b) - Entier aléatoire entre a et b (INCLUS des deux côtés)

de = [Link](1, 6) # Simule un dé

# randrange(start, stop, step) - Comme range() mais aléatoire

nombre_pair = [Link](0, 100, 2) # Nombre pair entre 0 et 98
nombre = [Link](10) # Entre 0 et 9

# getrandbits(k) - Entier avec k bits aléatoires

grand_nombre = [Link](64)
```

### Fonctions pour les séquences

```python
# choice(sequence) - Élément aléatoire d'une séquence non vide
couleurs = ['rouge', 'vert', 'bleu', 'jaune']
couleur = [Link](couleurs)

# choices(population, weights=None, k=1) - Plusieurs choix AVEC remise

# Utile pour les tirages avec probabilités
resultats = [Link](['pile', 'face'], k=10) # 10 lancers
# Avec poids (probabilités)
choix_ponderes = [Link](
 ['commun', 'rare', 'légendaire'],
weights=[70, 25, 5], # 70%, 25%, 5%
k=100
)

# sample(population, k) - k éléments uniques SANS remise

cartes = list(range(1, 53)) # 52 cartes
main = [Link](cartes, 5) # 5 cartes distinctes

# shuffle(liste) - Mélange une liste EN PLACE (modifie l'original)

jeu = ['As', 'Roi', 'Dame', 'Valet']
[Link](jeu)
print(jeu) # Ordre mélangé
```

### Distributions statistiques

```python
# gauss(mu, sigma) - Distribution gaussienne (normale)
# mu = moyenne, sigma = écart-type
taille = [Link](170, 10) # Taille humaine moyenne 170cm, écart-type 10

# normalvariate(mu, sigma) - Similaire à gauss mais thread-safe

temperature = [Link](20, 5)

# expovariate(lambd) - Distribution exponentielle

temps_attente = [Link](1/5) # Moyenne de 5 unités

# triangular(low, high, mode) - Distribution triangulaire

valeur = [Link](0, 100, 60) # Mode à 60

# betavariate(alpha, beta) - Distribution beta

probabilite = [Link](2, 5)

# gammavariate(alpha, beta) - Distribution gamma

duree = [Link](2, 3)
```

### Contrôle du générateur

```python
# seed(a=None) - Initialise le générateur pour des résultats reproductibles
[Link](42) # Même séquence à chaque exécution
print([Link]()) # Toujours 0.6394267984578837
print([Link]()) # Toujours 0.025010755222666936

[Link](42) # Réinitialise
print([Link]()) # Encore 0.6394267984578837

# getstate() et setstate() - Sauvegarder/restaurer l'état

etat = [Link]()
valeur1 = [Link]()
[Link](etat) # Retour à l'état sauvegardé
valeur2 = [Link]() # Même que valeur1
```

### Exemple pratique complet

```python
# Simulation d'un jeu de dés
def lancer_des(nombre_des=2):
return [[Link](1, 6) for _ in range(nombre_des)]

# Tirage au sort pondéré

def loterie():
participants = ['Alice', 'Bob', 'Charlie', 'Diana']
tickets = [10, 5, 3, 1] # Nombre de tickets par personne
gagnant = [Link](participants, weights=tickets, k=1)[0]
return gagnant

# Génération de données de test

def generer_ages(n=100):
return [int([Link](35, 15)) for _ in range(n)]
```

---

## 2. Module `math` - Fonctions mathématiques

Le module `math` fournit l'accès aux fonctions mathématiques définies par le standard C. Il ne fonctionne
PAS avec les nombres complexes (utiliser `cmath` pour cela).

### Constantes mathématiques

```python
import math
# Constantes importantes
print([Link]) # 3.141592653589793
print(math.e) # 2.718281828459045 (nombre d'Euler)
print([Link]) # 6.283185307179586 (2*pi)
print([Link]) # Infini positif (float('inf'))
print(-[Link]) # Infini négatif
print([Link]) # Not a Number (float('nan'))
```

### Fonctions de puissance et logarithmes

```python
# Racines et puissances
racine = [Link](25) # 5.0
racine_cubique = [Link](27, 1/3) # 3.0
puissance = [Link](2, 10) # 1024.0
carre = [Link](5, 2) # 25.0

# exp(x) - e élevé à la puissance x

exp = [Link](1) # e^1 = 2.718...
exp2 = [Link](2) # e^2 = 7.389...

# expm1(x) - exp(x) - 1 (précis pour petites valeurs)

petit = math.expm1(0.0001)

# Logarithmes
log_naturel = [Link](math.e) # 1.0 (ln)
log_base10 = math.log10(100) # 2.0
log_base2 = math.log2(1024) # 10.0
log_custom = [Link](8, 2) # 3.0 (log base 2 de 8)

# log1p(x) - log(1 + x) (précis pour petites valeurs)

petit_log = math.log1p(0.0001)
```

### Arrondis et valeurs absolues

```python
# ceil(x) - Plus petit entier >= x
haut1 = [Link](4.2) # 5
haut2 = [Link](4.8) # 5
haut3 = [Link](-4.2) # -4
# floor(x) - Plus grand entier <= x
bas1 = [Link](4.2) # 4
bas2 = [Link](4.8) # 4
bas3 = [Link](-4.2) # -5

# trunc(x) - Partie entière (vers zéro)

tronque1 = [Link](4.8) # 4
tronque2 = [Link](-4.8) # -4

# fabs(x) - Valeur absolue (retourne float)

absolu = [Link](-5.7) # 5.7

# modf(x) - Parties fractionnaire et entière

frac, entier = [Link](4.75) # (0.75, 4.0)

# remainder(x, y) - Reste de la division IEEE

reste = [Link](23, 5) # -2.0 (pas 3)

# fmod(x, y) - Modulo flottant

modulo = [Link](23, 5) # 3.0
```

### Fonctions trigonométriques (angles en RADIANS)

```python
# Conversion degrés <-> radians
angle_degres = 90
angle_radians = [Link](angle_degres) # 1.5707... (pi/2)
retour_degres = [Link](angle_radians) # 90.0

# Fonctions de base
sinus = [Link]([Link] / 2) # 1.0
cosinus = [Link](0) # 1.0
tangente = [Link]([Link] / 4) # 1.0

# Fonctions inverses
arcsinus = [Link](1) # pi/2 = 1.5707...
arccosinus = [Link](0) # pi/2 = 1.5707...
arctangente = [Link](1) # pi/4 = 0.7853...

# atan2(y, x) - Arctangente de y/x (gère les quadrants)

angle = math.atan2(1, 1) # pi/4 (45°)
angle2 = math.atan2(-1, -1) # -3*pi/4 (-135°)

# Fonctions hyperboliques
sinh = [Link](1)
cosh = [Link](1)
tanh = [Link](1)

# Fonctions hyperboliques inverses

asinh = [Link](1)
acosh = [Link](2)
atanh = [Link](0.5)
```

### Opérations spéciales

```python
# factorial(n) - Factorielle de n (n!)
fact5 = [Link](5) # 120 (5*4*3*2*1)
fact0 = [Link](0) #1

# gcd(a, b) - Plus grand commun diviseur

pgcd = [Link](48, 18) #6

# lcm(a, b, ...) - Plus petit commun multiple (Python 3.9+)

ppcm = [Link](12, 18) # 36

# comb(n, k) - Combinaisons: n! / (k! * (n-k)!)

combinaisons = [Link](5, 2) # 10 (5 choix parmi 2)

# perm(n, k) - Permutations: n! / (n-k)!

permutations = [Link](5, 2) # 20

# isqrt(n) - Racine carrée entière

racine_entiere = [Link](15) # 3 (car 3² = 9 < 15 < 16 = 4²)

# prod(iterable) - Produit de tous les éléments

produit = [Link]([2, 3, 4]) # 24

# dist(p, q) - Distance euclidienne entre deux points

point1 = [0, 0]
point2 = [3, 4]
distance = [Link](point1, point2) # 5.0
# hypot(*coordinates) - Norme euclidienne
hypotenuse = [Link](3, 4) # 5.0
norme_3d = [Link](1, 2, 2) # 3.0
```

### Fonctions de test et de comparaison

```python
# isfinite(x) - Teste si x est fini (ni inf ni nan)
print([Link](100)) # True
print([Link]([Link])) # False
print([Link]([Link])) # False

# isinf(x) - Teste si x est infini

print([Link]([Link])) # True
print([Link](100)) # False

# isnan(x) - Teste si x est NaN

print([Link]([Link])) # True
print([Link](100)) # False

# isclose(a, b, rel_tol, abs_tol) - Compare deux flottants

# Utile car 0.1 + 0.2 != 0.3 en flottant
print(0.1 + 0.2 == 0.3) # False !
print([Link](0.1 + 0.2, 0.3)) # True
print([Link](100, 100.001, rel_tol=0.01)) # True (1% tolérance)

# copysign(x, y) - x avec le signe de y

positif = [Link](5, -1) # -5.0
negatif = [Link](-5, 1) # 5.0
```

### Exemples pratiques

```python
# Calcul de la distance entre deux points 2D
def distance_2d(x1, y1, x2, y2):
return [Link]((x2 - x1)**2 + (y2 - y1)**2)
# ou: return [Link](x2 - x1, y2 - y1)

# Aire d'un cercle

def aire_cercle(rayon):
return [Link] * rayon ** 2
# Conversion coordonnées polaires -> cartésiennes
def polaire_vers_cartesien(r, theta_degres):
theta_rad = [Link](theta_degres)
x = r * [Link](theta_rad)
y = r * [Link](theta_rad)
return x, y

# Formule de Stirling (approximation factorielle)

def stirling(n):
return [Link](2 * [Link] * n) * (n / math.e) ** n
```

---

## 3. Module `time` - Gestion du temps et des délais

Le module `time` fournit diverses fonctions liées au temps. Il dépend de la plateforme et gère le temps
système.

### Obtenir le temps actuel

```python
import time

# time() - Timestamp Unix (secondes depuis epoch: 1er janvier 1970)

maintenant = [Link]()
print(maintenant) # Ex: 1732204800.1234567

# Epoch: point de référence pour les timestamps

epoch = [Link](0)
print(epoch) # 1970-01-01 00:00:00 UTC

# clock_gettime(clock_id) - Temps haute précision selon différentes horloges

temps_monotone = time.clock_gettime(time.CLOCK_MONOTONIC)
temps_processus = time.clock_gettime(time.CLOCK_PROCESS_CPUTIME_ID)

# perf_counter() - Compteur haute résolution (pour mesures)

# Inclut le temps de sommeil
debut = time.perf_counter()
# ... code ...
fin = time.perf_counter()
duree = fin - debut
# process_time() - Temps CPU du processus
# N'inclut PAS le temps de sommeil
debut_cpu = time.process_time()
# ... code ...
fin_cpu = time.process_time()
temps_cpu = fin_cpu - debut_cpu

# monotonic() - Horloge monotone (ne recule jamais)

# Utile pour mesurer des durées sans être affecté par changements d'heure
depart = [Link]()
```

### Pause et attente

```python
# sleep(secondes) - Met le programme en pause
print("Début")
[Link](2.5) # Pause de 2.5 secondes
print("Fin")

# Boucle d'attente avec affichage

for i in range(5, 0, -1):
print(f"Décompte: {i}")
[Link](1)
print("Go!")
```

### Conversion et formatage de temps

```python
# gmtime(secondes) - Convertit timestamp en struct_time UTC
temps_utc = [Link]()
print(temps_utc.tm_year) # 2025
print(temps_utc.tm_mon) # 11 (novembre)
print(temps_utc.tm_mday) # 21
print(temps_utc.tm_hour) # Heure UTC
print(temps_utc.tm_min)
print(temps_utc.tm_sec)
print(temps_utc.tm_wday) # 0=lundi, 6=dimanche
print(temps_utc.tm_yday) # Jour de l'année (1-366)
print(temps_utc.tm_isdst) # Heure d'été: 0=non, 1=oui, -1=inconnu
# localtime(secondes) - Convertit timestamp en struct_time local
temps_local = [Link]()
print(temps_local.tm_zone) # Nom du fuseau horaire

# Avec timestamp spécifique

noel = [Link](1735084800)

# mktime(struct_time) - Inverse de localtime

struct = [Link]("21/11/2025 14:30", "%d/%m/%Y %H:%M")
timestamp = [Link](struct)

# strftime(format, struct_time) - Formate une date/heure

maintenant = [Link]()
# Formats courants
print([Link]("%d/%m/%Y", maintenant)) # 21/11/2025
print([Link]("%H:%M:%S", maintenant)) # 14:30:45
print([Link]("%Y-%m-%d %H:%M:%S", maintenant)) # 2025-11-21 14:30:45
print([Link]("%A %d %B %Y", maintenant)) # Thursday 21 November 2025
print([Link]("%c", maintenant)) # Format local complet
print([Link]("%x", maintenant)) # Date locale
print([Link]("%X", maintenant)) # Heure locale

# Codes de formatage principaux:

# %Y année (4 chiffres) %m mois (01-12) %d jour (01-31)
# %H heure 24h (00-23) %I heure 12h (01-12) %M minutes (00-59)
# %S secondes (00-59) %p AM/PM %A nom jour complet
# %a nom jour abrégé %B nom mois complet %b nom mois abrégé
# %w jour semaine (0-6) %j jour année %W semaine année
# %Z nom fuseau %z offset fuseau %% caractère %

# strptime(string, format) - Parse une chaîne en struct_time

date_str = "21/11/2025 14:30:45"
parsed = [Link](date_str, "%d/%m/%Y %H:%M:%S")
print(parsed.tm_year) # 2025

# asctime(struct_time) - Format lisible standard

texte = [Link](temps_local) # 'Thu Nov 21 14:30:45 2025'

# ctime(secondes) - Convertit timestamp en texte

texte2 = [Link]([Link]()) # 'Thu Nov 21 14:30:45 2025'
```

### Informations sur le fuseau horaire

```python
# timezone - Offset en secondes du fuseau local vs UTC
offset = [Link]
print(f"Offset UTC: {offset} secondes ({offset/3600} heures)")

# altzone - Offset avec heure d'été

offset_ete = [Link]

# tzname - Tuple des noms de fuseaux (standard, été)

print([Link]) # Ex: ('CET', 'CEST')

# daylight - Non-zéro si fuseau a heure d'été

if [Link]:
print("Fuseau avec heure d'été")
```

### Exemples pratiques complets

```python
# Chronomètre précis
class Chronometre:
def __init__(self):
[Link] = None
[Link] = None

def start(self):
[Link] = time.perf_counter()

def stop(self):
[Link] = time.perf_counter()

def elapsed(self):
if [Link] and [Link]:
return [Link] - [Link]
return None

# Utilisation
chrono = Chronometre()
[Link]()
[Link](2)
[Link]()
print(f"Temps écoulé: {[Link]():.4f} secondes")
# Mesurer performances de code
def mesurer_temps(fonction, *args, iterations=1000):
debut = time.perf_counter()
for _ in range(iterations):
fonction(*args)
fin = time.perf_counter()
temps_total = fin - debut
temps_moyen = temps_total / iterations
print(f"Temps total: {temps_total:.4f}s")
print(f"Temps moyen: {temps_moyen:.6f}s")

# Horodatage lisible
def timestamp_lisible():
return [Link]("%Y-%m-%d_%H-%M-%S")

# Nom de fichier avec date

nom_fichier = f"backup_{timestamp_lisible()}.txt"

# Calculer âge
def calculer_age(date_naissance): # Format: "DD/MM/YYYY"
naissance = [Link](date_naissance, "%d/%m/%Y")
maintenant = [Link]()
age = maintenant.tm_year - naissance.tm_year
if (maintenant.tm_mon, maintenant.tm_mday) < (naissance.tm_mon, naissance.tm_mday):
age -= 1
return age

# Countdown timer
def countdown(secondes):
while secondes > 0:
mins, secs = divmod(secondes, 60)
timer = f'{mins:02d}:{secs:02d}'
print(timer, end='\r')
[Link](1)
secondes -= 1
print("Terminé!")

# Mesure avec contexte

from contextlib import contextmanager

@contextmanager
def chronometre_contexte(nom="Opération"):
 debut = time.perf_counter()
yield
fin = time.perf_counter()
print(f"{nom}: {fin - debut:.4f}s")

# Utilisation
with chronometre_contexte("Traitement"):
[Link](1.5)
```

---

## 4. Module `os` - Interface avec le système d'exploitation

Le module `os` fournit un moyen portable d'utiliser des fonctionnalités dépendantes du système
d'exploitation.

### Navigation dans le système de fichiers

```python
import os

# getcwd() - Obtenir le répertoire de travail actuel

repertoire_actuel = [Link]()
print(repertoire_actuel) # Ex: /home/user/projets

# chdir(path) - Changer de répertoire

[Link]('/home/user/documents')
print([Link]()) # /home/user/documents

# Revenir au répertoire précédent

[Link]('..') # Remonte d'un niveau

# listdir(path) - Liste le contenu d'un répertoire

contenu = [Link]('.')
print(contenu) # ['[Link]', 'dossier1', '[Link]']

# Filtrer les fichiers Python

fichiers_py = [f for f in [Link]('.') if [Link]('.py')]

# scandir(path) - Itérateur plus efficace que listdir

with [Link]('.') as entries:
for entry in entries:
 print(f"{[Link]} - Fichier: {entry.is_file()} - Dossier: {entry.is_dir()}")
if entry.is_file():
info = [Link]()
print(f" Taille: {info.st_size} octets")

# walk(top) - Parcours récursif de l'arborescence

for racine, dossiers, fichiers in [Link]('.'):
print(f"Répertoire: {racine}")
print(f" Sous-dossiers: {dossiers}")
print(f" Fichiers: {fichiers}")
# Exemple: trouver tous les .txt
for fichier in fichiers:
if [Link]('.txt'):
chemin_complet = [Link](racine, fichier)
print(f" Trouvé: {chemin_complet}")
```

### Création et suppression

```python
# mkdir(path, mode) - Créer un répertoire
[Link]('nouveau_dossier')
[Link]('dossier_perm', mode=0o755) # Avec permissions spécifiques

# makedirs(path, exist_ok) - Créer répertoires parents si nécessaire

[Link]('parent/enfant/petit_enfant', exist_ok=True)
# exist_ok=True évite l'erreur si le dossier existe déjà

# rmdir(path) - Supprimer un répertoire VIDE

[Link]('dossier_vide')

# removedirs(path) - Supprime récursivement les dossiers vides

[Link]('parent/enfant/petit_enfant')

# remove(path) / unlink(path) - Supprimer un fichier

[Link]('[Link]')
[Link]('autre_fichier.txt') # Équivalent

# Pour supprimer un dossier non vide, utiliser shutil

import shutil
[Link]('dossier_avec_contenu')
```
### Renommage et déplacement

```python
# rename(src, dst) - Renommer/déplacer
[Link]('ancien_nom.txt', 'nouveau_nom.txt')
[Link]('[Link]', 'autre_dossier/[Link]') # Déplacer

# renames(old, new) - Comme rename mais crée les répertoires nécessaires

[Link]('a/b/[Link]', 'x/y/z/[Link]')

# replace(src, dst) - Comme rename mais écrase la destination si elle existe

[Link]('[Link]', '[Link]')
```

### Module `[Link]` - Manipulation de chemins

```python
# join(*paths) - Joindre des chemins de façon portable
chemin = [Link]('dossier', 'sous_dossier', '[Link]')
# Windows: dossier\sous_dossier\[Link]
# Unix: dossier/sous_dossier/[Link]

# exists(path) - Vérifie si le chemin existe

if [Link]('[Link]'):
print("Le fichier existe")

# isfile(path) - Vérifie si c'est un fichier

if [Link]('[Link]'):
print("C'est un fichier")

# isdir(path) - Vérifie si c'est un répertoire

if [Link]('mon_dossier'):
print("C'est un dossier")

# islink(path) - Vérifie si c'est un lien symbolique

if [Link]('mon_lien'):
print("C'est un lien symbolique")

# isabs(path) - Vérifie si le chemin est absolu

print([Link]('/home/user')) # True (Unix)
print([Link]('C:\\Users')) # True (Windows)
print([Link]('dossier')) # False (relatif)
# abspath(path) - Convertit en chemin absolu
chemin_abs = [Link]('[Link]')
print(chemin_abs) # /home/user/projets/[Link]

# realpath(path) - Résout les liens symboliques

chemin_reel = [Link]('mon_lien')

# basename(path) - Nom du fichier/dossier final

nom = [Link]('/home/user/[Link]') # [Link]

# dirname(path) - Répertoire parent

parent = [Link]('/home/user/[Link]') # /home/user

# split(path) - Sépare répertoire et nom

repertoire, fichier = [Link]('/home/user/[Link]')
# repertoire: /home/user
# fichier: [Link]

# splitext(path) - Sépare nom et extension

nom, extension = [Link]('[Link]')
# nom: document
# extension: .pdf

# splitdrive(path) - Sépare lecteur et chemin (Windows)

lecteur, chemin = [Link]('C:\\Users\\[Link]')
# lecteur: C:
# chemin: \Users\[Link]

# getsize(path) - Taille du fichier en octets

taille = [Link]('[Link]')
print(f"Taille: {taille} octets")

# getmtime(path) - Date de dernière modification

timestamp = [Link]('[Link]')
date_modif = [Link](timestamp)

# getatime(path) - Date de dernier accès

timestamp_acces = [Link]('[Link]')

# getctime(path) - Date de création (Windows) ou changement métadonnées (Unix)

timestamp_creation = [Link]('[Link]')

# samefile(path1, path2) - Teste si deux chemins pointent vers le même fichier

meme = [Link]('[Link]', './[Link]')

# commonpath(paths) - Chemin commun le plus long

commun = [Link](['/home/user/[Link]', '/home/user/[Link]'])
# Retourne: /home/user

# expanduser(path) - Expand ~ et ~user

home = [Link]('~/documents') # /home/user/documents

# expandvars(path) - Expand variables d'environnement

chemin = [Link]('$HOME/documents')
```

### Variables et informations d'environnement

```python
# environ - Dictionnaire des variables d'environnement
print([Link]) # Toutes les variables

# Accéder à une variable spécifique

home = [Link]['HOME'] # Lève KeyError si n'existe pas
path = [Link]('PATH') # Retourne None si n'existe pas
user = [Link]('USER', 'inconnu') # Valeur par défaut

# getenv(key, default) - Méthode alternative

home = [Link]('HOME')
temp = [Link]('TEMP', '/tmp')

# putenv(key, value) - Modifier une variable (pour sous-processus)

[Link]('MA_VARIABLE', 'ma_valeur')

# Modifier environ directement (recommandé)

[Link]['MA_VARIABLE'] = 'ma_valeur'

# unsetenv(key) - Supprimer une variable

[Link]('MA_VARIABLE')
del [Link]['MA_VARIABLE'] # Alternative

# name - Nom du système d'exploitation

print([Link]) # 'posix' (Unix/Linux/Mac), 'nt' (Windows), 'java' (Jython)

# uname() - Informations système (Unix uniquement)

info = [Link]()
print([Link]) # Linux
print([Link]) # Nom de la machine
print([Link]) # Version du noyau
print([Link]) # Version détaillée
print([Link]) # Architecture (x86_64, arm64, etc.)

# getlogin() - Nom de l'utilisateur connecté

utilisateur = [Link]()

# getpid() - ID du processus actuel

pid = [Link]()
print(f"PID du processus: {pid}")

# getppid() - ID du processus parent

ppid = [Link]()

# cpu_count() - Nombre de CPU

nb_cpu = os.cpu_count()
print(f"Nombre de CPU: {nb_cpu}")
```

### Permissions et propriétés des fichiers

```python
# chmod(path, mode) - Changer les permissions
[Link]('[Link]', 0o644) # rw-r--r--
[Link]('[Link]', 0o755) # rwxr-xr-x

# Permissions en octal:
# 0o777 = rwxrwxrwx (lecture/écriture/exécution pour tous)
# 0o755 = rwxr-xr-x (propriétaire tout, autres lecture/exécution)
# 0o644 = rw-r--r-- (propriétaire lecture/écriture, autres lecture)

# stat(path) - Informations détaillées sur un fichier

import stat
infos = [Link]('[Link]')
print(f"Taille: {infos.st_size} octets")
print(f"Permissions: {oct(infos.st_mode)}")
print(f"UID propriétaire: {infos.st_uid}")
print(f"GID groupe: {infos.st_gid}")
print(f"Dernière modification: {infos.st_mtime}")
print(f"Dernier accès: {infos.st_atime}")
print(f"Création/changement: {infos.st_ctime}")
print(f"Nombre de liens: {infos.st_nlink}")

# Tester les permissions

mode = infos.st_mode
if stat.S_ISREG(mode):
print("Fichier régulier")
if stat.S_ISDIR(mode):
print("Répertoire")
if stat.S_ISLNK(mode):
print("Lien symbolique")

# access(path, mode) - Tester les permissions d'accès

peut_lire = [Link]('[Link]', os.R_OK)
peut_ecrire = [Link]('[Link]', os.W_OK)
peut_executer = [Link]('[Link]', os.X_OK)
existe = [Link]('[Link]', os.F_OK)

# chown(path, uid, gid) - Changer propriétaire (Unix)

[Link]('[Link]', 1000, 1000) # UID 1000, GID 1000
```

### Liens symboliques

```python
# symlink(src, dst) - Créer un lien symbolique
[Link]('fichier_original.txt', 'lien_vers_fichier.txt')

# readlink(path) - Lire la cible d'un lien symbolique

cible = [Link]('lien_vers_fichier.txt')
print(f"Le lien pointe vers: {cible}")

# link(src, dst) - Créer un lien dur

[Link]('[Link]', 'copie_liee.txt')
```

### Opérations sur les descripteurs de fichiers

```python
# open(path, flags, mode) - Ouvrir avec descripteur
fd = [Link]('[Link]', os.O_RDWR | os.O_CREAT)

# Flags communs:
# os.O_RDONLY - Lecture seule
# os.O_WRONLY - Écriture seule
# os.O_RDWR - Lecture et écriture
# os.O_CREAT - Créer si n'existe pas
# os.O_APPEND - Ajouter à la fin
# os.O_TRUNC - Tronquer à 0

# read(fd, n) - Lire n octets

donnees = [Link](fd, 100)

# write(fd, data) - Écrire des données

[Link](fd, b"Contenu")

# close(fd) - Fermer le descripteur

[Link](fd)

# lseek(fd, pos, how) - Déplacer le curseur

[Link](fd, 0, os.SEEK_SET) # Début du fichier
[Link](fd, 0, os.SEEK_END) # Fin du fichier
[Link](fd, 10, os.SEEK_CUR) # 10 octets en avant

# fsync(fd) - Force l'écriture sur disque

[Link](fd)
```

### Exemples pratiques complets

```python
# Lister tous les fichiers d'un type dans un répertoire et sous-répertoires
def trouver_fichiers(racine, extension):
fichiers_trouves = []
for dossier, sous_dossiers, fichiers in [Link](racine):
for fichier in fichiers:
if [Link](extension):
chemin_complet = [Link](dossier, fichier)
fichiers_trouves.append(chemin_complet)
return fichiers_trouves

# Utilisation
fichiers_py = trouver_fichiers('.', '.py')

# Calculer la taille totale d'un répertoire

def taille_dossier(chemin):
taille_totale = 0
for racine, dossiers, fichiers in [Link](chemin):
for fichier in fichiers:
chemin_fichier = [Link](racine, fichier)