🐍

PYTHON
Guide Complet avec Exemples de Code
De la syntaxe de base aux applications avancées

Mai 2026 • CyberGuard AI Project

Python — Guide Complet | CyberGuard AI Project | 2026

1. Introduction à Python
Python est un langage de programmation interprété, à typage dynamique, créé par Guido van
Rossum en 1991. Il est aujourd'hui le langage le plus populaire au monde grâce à sa syntaxe
lisible, sa polyvalence et son écosystème exceptionnel.

1.1 Pourquoi Python ?

• Syntaxe claire et lisible — le code ressemble à du pseudo-code
• Multiparadigme — orienté objet, fonctionnel, procédural
• Écosystème immense — 400 000+ packages sur PyPI
• Communauté massive — ressources et support illimités
• Idéal pour l'IA, la cybersécurité, le web, l'automatisation

1.2 Votre premier programme Python

# Mon premier programme Python
print("Bonjour, CyberGuard AI !")

# Variables et types de base

nom = 'Python'
version = 3.12
actif = True

print(f"Langage : {nom}, Version : {version}, Actif : {actif}")

# Résultat : Langage : Python, Version : 3.12, Actif : True

Python — Guide Complet | CyberGuard AI Project | 2026

2. Types de Données
Python possède des types de données natifs puissants. Comprendre ces types est fondamental
pour écrire du code efficace.

Type Exemple Description

int 42, -10, 1_000_000 Entiers (taille illimitée)

float 3.14, -0.5, 1e10 Nombres décimaux (64-bit)
str "hello", 'world' Chaînes de caractères (immutables)
bool True, False Booléens (sous-classe de int)
list [1, 'a', True] Liste ordonnée et modifiable
tuple (1, 2, 3) Séquence ordonnée immuable
dict {"clé": valeur} Paires clé-valeur (hashmap)
set {1, 2, 3} Ensemble sans doublons

2.1 Exemples de manipulation

# Listes — collection ordonnée et modifiable
menaces = ['virus', 'ransomware', 'phishing', 'ddos']
[Link]('spyware') # Ajouter
[Link]('ddos') # Supprimer
print(menaces[0]) # 'virus' (index 0)
print(menaces[-1]) # 'spyware' (dernier)
print(menaces[1:3]) # ['ransomware', 'phishing']

# Dictionnaires — paires clé-valeur

alerte = {
'type': 'malware',
'niveau': 'critique',
'ip_source': '[Link]',
'port': 4444
}
print(alerte['type']) # 'malware'
alerte['traite'] = False # Ajouter une clé

# Sets — valeurs uniques

ips_suspectes = {'[Link]', '[Link]', '[Link]'}
print(ips_suspectes) # {'[Link]', '[Link]'}

Python — Guide Complet | CyberGuard AI Project | 2026

3. Structures de Contrôle
Les structures de contrôle permettent de diriger le flux d'exécution du programme selon des
conditions ou de répéter des blocs de code.

3.1 Conditions (if / elif / else)

niveau_menace = 85 # Score de 0 à 100

if niveau_menace >= 90:

print("🔴 CRITIQUE — Bloquer immédiatement")
elif niveau_menace >= 70:
print("🟠 ÉLEVÉ — Alerte prioritaire")
elif niveau_menace >= 40:
print("🟡 MODÉRÉ — Surveillance renforcée")
else:
print("🟢 FAIBLE — Journalisation simple")

# Résultat : 🟠 ÉLEVÉ — Alerte prioritaire

# Condition ternaire (one-liner)

statut = "bloqué" if niveau_menace > 80 else "autorisé"

3.2 Boucles (for / while)

# Boucle for — itérer sur une liste
fichiers_suspects = ['[Link]', '[Link]', '[Link]']

for fichier in fichiers_suspects:

print(f'Analyse de : {fichier}')

# Boucle for avec range

for i in range(1, 6):
print(f'Scan port {i000 + i}...')

# Boucle while — conditions dynamiques

tentatives = 0
max_tentatives = 3

while tentatives < max_tentatives:

code = input('Entrez le code : ')
if code == '1234':
print('Accès autorisé')

Python — Guide Complet | CyberGuard AI Project | 2026

 break
tentatives += 1
print(f'Échec ({tentatives}/{max_tentatives})')
else:
print('Compte bloqué')

Python — Guide Complet | CyberGuard AI Project | 2026

4. Fonctions
Les fonctions permettent de structurer et réutiliser le code. Python offre une grande flexibilité dans
la définition des paramètres.

4.1 Fonctions de base

def analyser_fichier(chemin, niveau_sensibilite=50):
"""
Analyse un fichier pour détecter des menaces.
Retourne un score de dangerosité entre 0 et 100.
"""
# Simulation d'analyse
score = len(chemin) * 2 # Simplification pour l'exemple
if score > niveau_sensibilite:
return score, 'SUSPECT'
return score, 'SAIN'

# Appels de la fonction
score, statut = analyser_fichier('[Link]')
print(f'Score: {score}, Statut: {statut}')

score, statut = analyser_fichier('[Link]', niveau_sensibilite=30)

print(f'Score: {score}, Statut: {statut}')

4.2 Fonctions avancées

# *args — nombre variable d'arguments
def scanner_ports(*ports):
ouverts = []
for port in ports:
if port in [80, 443, 22, 21]: # Simulation
[Link](port)
return ouverts

print(scanner_ports(80, 443, 8080, 9999)) # [80, 443]

# **kwargs — arguments nommés variables

def creer_alerte(**infos):
alerte = {clé: valeur for clé, valeur in [Link]()}
return alerte

a = creer_alerte(type='ddos', ip='[Link]', gravite='haute')

Python — Guide Complet | CyberGuard AI Project | 2026

print(a)

# Lambda — fonction anonyme

trier_par_gravite = lambda alertes: sorted(alertes, key=lambda x: x['score'],
reverse=True)

Python — Guide Complet | CyberGuard AI Project | 2026

5. Programmation Orientée Objet (POO)
La POO permet de modéliser le monde réel en regroupant données et comportements dans des
objets. C'est le paradigme central pour construire CyberGuard AI.

5.1 Classes et Objets

class Menace:
"""Représente une menace cybersécurité détectée."""

# Attribut de classe (partagé par toutes les instances)

base_de_donnees = []

def __init__(self, type_menace, ip_source, score):

self.type_menace = type_menace
self.ip_source = ip_source
[Link] = score
[Link] = False
Menace.base_de_donnees.append(self)

def evaluer(self):
if [Link] >= 80:
return 'CRITIQUE'
elif [Link] >= 50:
return 'MODÉRÉE'
return 'FAIBLE'

def traiter(self):
[Link] = True
print(f'Menace {self.type_menace} traitée ✓')

def __str__(self):
return f'[{[Link]()}] {self.type_menace} depuis {self.ip_source}'

# Utilisation
m1 = Menace('ransomware', '[Link]', 95)
m2 = Menace('phishing', '[Link]', 45)

print(m1) # [CRITIQUE] ransomware depuis [Link]

print([Link]()) # FAIBLE
[Link]() # Menace ransomware traitée ✓
print(f'Total menaces: {len(Menace.base_de_donnees)}')

Python — Guide Complet | CyberGuard AI Project | 2026

5.2 Héritage
class MenaceIA(Menace):
"""Menace générée par une IA adverse — hérite de Menace."""

def __init__(self, ip_source, score, modele_ia):

super().__init__('IA_ADVERSE', ip_source, score)
self.modele_ia = modele_ia
self.auto_adaptative = True

def contrer(self):
print(f'Contre-mesure IA activée contre {self.modele_ia}')
[Link] = max(0, [Link] - 30) # Réduction du score

def __str__(self):
return f'[IA] {self.modele_ia} @ {self.ip_source} — Score: {[Link]}'

ia_adverse = MenaceIA('[Link]', 99, 'GhostBot-v3')

print(ia_adverse) # [IA] GhostBot-v3 @ [Link] — Score: 99
ia_adverse.contrer() # Contre-mesure IA activée contre GhostBot-v3
print(ia_adverse.score) # 69

Python — Guide Complet | CyberGuard AI Project | 2026

6. Gestion des Erreurs
La gestion des exceptions est cruciale en cybersécurité — une erreur non gérée peut provoquer
une interruption de service ou exposer des informations sensibles.

6.1 Try / Except / Finally

import json

def charger_config_securite(chemin_fichier):
try:
with open(chemin_fichier, 'r') as f:
config = [Link](f)
print('Configuration chargée avec succès')
return config

except FileNotFoundError:
print(f'ERREUR : Fichier {chemin_fichier} introuvable')
return {}

except [Link] as e:
print(f'ERREUR : JSON invalide — {e}')
return {}

except PermissionError:
print('ERREUR : Accès refusé (droits insuffisants)')
return {}

finally:
# Toujours exécuté, même en cas d'erreur
print('Tentative de chargement terminée')

config = charger_config_securite('[Link]')

6.2 Exceptions personnalisées

class MenaceNonAutoriseeError(Exception):
"""Levée quand une menace critique n'est pas traitée."""
pass

class ScoreInvalideError(ValueError):
pass

Python — Guide Complet | CyberGuard AI Project | 2026

def valider_score(score):
if not isinstance(score, int):
raise ScoreInvalideError(f'Score doit être un entier, reçu:
{type(score)}')
if not 0 <= score <= 100:
raise ScoreInvalideError(f'Score doit être entre 0 et 100, reçu: {score}')
return score

try:
valider_score(150)
except ScoreInvalideError as e:
print(f'Validation échouée : {e}')

Python — Guide Complet | CyberGuard AI Project | 2026

7. Modules et Bibliothèques
L'écosystème Python est l'un de ses plus grands atouts. Voici les bibliothèques essentielles pour
CyberGuard AI.

Bibliothèque Domaine Utilisation dans CyberGuard AI

os / sys Système Accès aux fichiers, processus, variables

d'environnement
socket Réseau Analyse du trafic réseau, détection d'intrusions
hashlib Cryptographie Hash MD5/SHA des fichiers pour signature de
malwares
requests HTTP Appels API VirusTotal, threat intelligence feeds
scikit-learn Machine Learning Modèles de classification de malwares
pandas Données Analyse des logs et journaux d'événements
FastAPI API Web Exposer les modèles ML via API REST
asyncio Asynchrone Surveillance simultanée de milliers d'endpoints

7.1 Exemple — Hachage de fichiers (détection malware)

import hashlib
import os

# Base de signatures de malwares connus (simplifiée)

SIGNATURES_MALWARES = {
'd41d8cd98f00b204e9800998ecf8427e': '[Link]',
'a87ff679a2f3e71d9181a67b7542122c': '[Link]',
}

def analyser_fichier_hash(chemin):
"""Calcule le MD5 et vérifie contre les signatures."""
try:
hasher = hashlib.md5()
with open(chemin, 'rb') as f:
while chunk := [Link](8192):
[Link](chunk)
hash_md5 = [Link]()

if hash_md5 in SIGNATURES_MALWARES:
return {'statut': 'MALWARE', 'nom': SIGNATURES_MALWARES[hash_md5],
'hash': hash_md5}

Python — Guide Complet | CyberGuard AI Project | 2026

 return {'statut': 'SAIN', 'hash': hash_md5}

except FileNotFoundError:
return {'statut': 'ERREUR', 'message': 'Fichier introuvable'}

# Utilisation
resultat = analyser_fichier_hash('fichier_suspect.exe')
print(resultat)

Python — Guide Complet | CyberGuard AI Project | 2026

8. Programmation Asynchrone
L'asynchronisme est indispensable pour surveiller simultanément des milliers d'endpoints sans
bloquer le programme. Python utilise asyncio pour cela.

8.1 async / await

import asyncio
import random

async def scanner_endpoint(ip, port):

"""Simule le scan d'un endpoint de façon asynchrone."""
# Simule un délai réseau variable
delai = [Link](0.1, 0.5)
await [Link](delai)

# Simulation de détection
menace_detectee = [Link]() < 0.2 # 20% de chance
statut = '🔴 MENACE' if menace_detectee else '🟢 OK'
print(f'{ip}:{port} — {statut} (réponse en {delai:.2f}s)')
return menace_detectee

async def surveiller_reseau(endpoints):

"""Lance tous les scans en parallèle."""
taches = [scanner_endpoint(ip, port) for ip, port in endpoints]
resultats = await [Link](*taches)
nb_menaces = sum(resultats)
print(f'\nBilan : {nb_menaces}/{len(endpoints)} endpoints compromis')

# Lancement
endpoints = [('10.0.0.' + str(i), 443) for i in range(1, 11)]
[Link](surveiller_reseau(endpoints))

Python — Guide Complet | CyberGuard AI Project | 2026

9. Fichiers et Traitement de Données
La lecture et l'écriture de fichiers est omniprésente : logs de sécurité, rapports d'incidents,
configurations, exports JSON/CSV.

9.1 Lecture / Écriture de fichiers

import json
from datetime import datetime

def journaliser_alerte(alerte: dict, fichier_log='[Link]'):

"""Ajoute une alerte au journal JSON."""
alerte['timestamp'] = [Link]().isoformat()

# Charger les alertes existantes

try:
with open(fichier_log, 'r') as f:
historique = [Link](f)
except (FileNotFoundError, [Link]):
historique = []

# Ajouter et sauvegarder
[Link](alerte)
with open(fichier_log, 'w') as f:
[Link](historique, f, indent=2, ensure_ascii=False)

print(f'Alerte journalisée : {alerte["type"]}')

# Utilisation
journaliser_alerte({'type': 'ransomware', 'ip': '[Link]', 'score': 98})
journaliser_alerte({'type': 'phishing', 'ip': '[Link]', 'score': 67})

9.2 Compréhensions de listes (List Comprehensions)

alertes = [
{'type': 'virus', 'score': 92, 'ip': '[Link]'},
{'type': 'phishing', 'score': 45, 'ip': '[Link]'},
{'type': 'ransomware', 'score': 98, 'ip': '[Link]'},
{'type': 'spyware', 'score': 38, 'ip': '[Link]'},
]

# Filtrer les alertes critiques (score >= 80)

critiques = [a for a in alertes if a['score'] >= 80]

Python — Guide Complet | CyberGuard AI Project | 2026

print(critiques) # virus et ransomware

# Extraire uniquement les IPs suspectes

ips = [a['ip'] for a in alertes if a['score'] >= 80]
print(ips) # ['[Link]', '[Link]']

# Dict comprehension — index par type

index = {a['type']: a['score'] for a in alertes}
print(index) # {'virus': 92, 'phishing': 45, ...}

Python — Guide Complet | CyberGuard AI Project | 2026

10. Mini-Application CyberGuard AI
Voici un exemple complet qui intègre tous les concepts vus : classes, fonctions, gestion d'erreurs,
fichiers et logique métier.

import hashlib, json, os

from datetime import datetime

class CyberGuardAI:
"""Moteur de détection simplifié CyberGuard AI."""

SIGNATURES = {
'a87ff679a2f3e71d9181a67b7542122c': '[Link]',
'e4da3b7fbbce2345d7772b0674a318d5': '[Link]',
}

def __init__(self):
[Link] = []
self.total_analyses = 0

def _calculer_hash(self, chemin):

h = hashlib.md5()
with open(chemin, 'rb') as f:
for chunk in iter(lambda: [Link](4096), b''):
[Link](chunk)
return [Link]()

def analyser(self, chemin):

self.total_analyses += 1
try:
hash_val = self._calculer_hash(chemin)
if hash_val in [Link]:
alerte = {
'fichier': chemin,
'menace': [Link][hash_val],
'hash': hash_val,
'heure': [Link]().isoformat()
}
[Link](alerte)
print(f'🔴 MENACE DÉTECTÉE : {alerte["menace"]} dans {chemin}')
return alerte
print(f'🟢 SAIN : {chemin}')
return None
except FileNotFoundError:
print(f'⚠️ Fichier introuvable : {chemin}')

Python — Guide Complet | CyberGuard AI Project | 2026

 def rapport(self):
print(f'\n=== RAPPORT CYBERGUARD AI ===')
print(f'Fichiers analysés : {self.total_analyses}')
print(f'Menaces détectées : {len([Link])}')
for a in [Link]:
print(f' • {a["menace"]} — {a["fichier"]}')

# Lancement
garde = CyberGuardAI()
[Link]('[Link]')
[Link]('[Link]')
[Link]()

Python — Guide Complet | CyberGuard AI Project | 2026

11. Prochaines Étapes
Vous avez maintenant une vue complète de Python. Voici le chemin recommandé pour progresser
vers CyberGuard AI :

Niveau Débutant (0–2 mois)

• Maîtriser les types, boucles, fonctions et classes
• Pratiquer sur [Link] ou LeetCode (niveau Easy)
• Lire : 'Automate the Boring Stuff with Python' (gratuit en ligne)

Niveau Intermédiaire (2–6 mois)

• Apprendre NumPy, Pandas, Scikit-learn
• Construire un premier modèle de classification de malwares
• Maîtriser asyncio pour la surveillance réseau

Niveau Avancé (6–12 mois)

• PyTorch pour le deep learning (détection de comportements anormaux)
• FastAPI pour exposer les modèles en production
• Intégration avec les outils de cybersécurité (YARA, Wireshark, Zeek)

🐍 Python est votre meilleur allié pour construire CyberGuard AI.

Python — Guide Complet | CyberGuard AI Project | 2026