Fondamentaux Python

Python est un langage interprété : le code source (.py) est exécuté ligne par ligne par l'interpréteur, sans étape de compilation. Téléchargez Python 3.12 depuis python.org en cochant « Add python.exe to PATH » sous Windows, puis vérifiez dans un terminal :

python --version
python -m pip --version

La fonction print() affiche du texte à l'écran. Les chaînes de caractères se délimitent par des guillemets simples ou doubles. Le symbole # démarre un commentaire ignoré par l'interpréteur :

print("Bonjour, automatisation !")
print('Adresse IP :', '192.168.1.1')
# Ceci est un commentaire : il documente le code

Exercice 1.1

Une variable est un nom qui référence une valeur en mémoire. En Python, on ne déclare pas de type : l'affectation avec = crée la variable et l'interpréteur déduit le type. Les noms utilisent des minuscules et des underscores (snake_case) :

hostname = "SW1"
vlan_id = 10
actif = True
print(hostname, vlan_id, actif)

On peut affecter plusieurs variables en une ligne, échanger deux valeurs sans variable temporaire, et utiliser les affectations augmentées (+=, -=, *=) très pratiques pour les compteurs :

ip, masque = "10.0.0.1", "255.255.255.0"
compteur = 0
compteur += 1      # compteur vaut 1
compteur *= 10     # compteur vaut 10

Exercice 1.2

Les quatre types de base couvrent l'essentiel : int (entiers), float (décimaux), str (texte), bool (True/False). La fonction type() révèle le type d'une valeur et les fonctions int(), float(), str() convertissent d'un type à l'autre :

port = 22
bande_passante = 1.5
banniere = "Acces reserve"
print(type(port), type(bande_passante), type(banniere))
print(int("8080") + 1)      # 8081 : conversion puis calcul
print(str(404) + " introuvable")

Attention aux conversions impossibles : int("VLAN10") lève une erreur ValueError. En automatisation, les données lues sur un équipement arrivent toujours en texte : il faut les convertir avant de calculer (module 5 et chapitre des exceptions).

Exercice 1.3

Python propose les opérateurs classiques + - * /, plus la division entière //, le modulo % (reste) et la puissance **. Le modulo sert par exemple à tester la parité ou à répartir des adresses :

print(7 / 2)    # 3.5 : division reelle
print(7 // 2)   # 3 : division entiere
print(7 % 2)    # 1 : reste
print(2 ** 8)   # 256 : 2 puissance 8 (un /24 = 256 adresses)

Les f-strings (préfixe f) injectent des variables dans un texte avec des accolades. C'est la façon moderne de générer des configurations et des rapports :

hote = "R1"
vlan = 20
print(f"Switch {hote} : port en VLAN {vlan}")
print(f"Masque /26 : {2 ** (32 - 26) - 2} hotes utilisables")

Exercice 1.4

Une condition exécute un bloc seulement si un test est vrai. Les opérateurs de comparaison sont == != < > <= >= ; on les combine avec and, or et not. Le bloc est délimité par l'indentation (4 espaces) après les deux-points :

tentatives = 15
if tentatives > 10:
    print("ALERTE : inviter a verifier cette IP")
elif tentatives > 5:
    print("Surveillance renforcee")
else:
    print("Trafic normal")

En Python, les valeurs « fausses » sont : False, None, 0, "" (chaîne vide), [], {}. On peut donc tester directement if reponse: pour vérifier qu'une chaîne n'est pas vide.

Exercice 2.1

La boucle for parcourt chaque élément d'une séquence. La fonction range(n) génère les entiers de 0 à n-1, range(debut, fin) un intervalle, range(debut, fin, pas) avec un pas personnalisé :

for i in range(5):
    print(f"Tentative {i + 1}/5")

for octet in range(1, 6):
    print(f"Scan de 192.168.1.{octet}")

On peut aussi parcourir directement une liste de chaînes — idéal pour traiter une liste d'équipements ou d'adresses :

equipements = ["R1", "SW1", "SW2"]
for hote in equipements:
    print(f"Connexion a {hote}...")

Exercice 2.2

La boucle while répète un bloc tant qu'une condition est vraie. Elle sert quand on ne connaît pas à l'avance le nombre d'itérations (attente d'un état, nouvelles tentatives). Il faut toujours faire évoluer la condition, sinon la boucle est infinie :

essais = 0
while essais < 3:
    print(f"Essai {essais + 1}")
    essais += 1
print("Fin des essais")

Les instructions break (sortir immédiatement) et continue (sauter à l'itération suivante) contrôlent finement les deux types de boucles :

for code in [200, 301, 404, 500, 200]:
    if code == 500:
        print("Erreur serveur : arret")
        break
    if code == 301:
        continue  # on ignore les redirections
    print(f"Code traite : {code}")

Exercice 2.3

Une fonction est un bloc nommé qui effectue une tâche. On la définit avec def, on l'appelle par son nom suivi de parenthèses. Les paramètres sont les valeurs reçues entre parenthèses :

def saluer(nom):
    print(f"Bonjour {nom} !")

saluer("Alice")
saluer("Bob")

Une fonction peut avoir des paramètres avec valeurs par défaut : l'appelant peut les omettre. La docstring (chaîne sous le def) documente le rôle de la fonction :

def generer_interface(nom, vlan=10):
    """Genere une ligne de configuration de port."""
    print(f"interface {nom} : access VLAN {vlan}")

generer_interface("Fa0/1")
generer_interface("Fa0/2", 20)

Exercice 3.1

L'instruction return renvoie un résultat à l'appelant et termine la fonction. Sans return, une fonction renvoie None. Séparer le calcul (fonction qui retourne) de l'affichage (print) rend le code testable et réutilisable :

def hotes_utilisables(prefix):
    return 2 ** (32 - prefix) - 2

print(hotes_utilisables(24))  # 254
print(hotes_utilisables(26))  # 62

Une fonction peut retourner plusieurs valeurs sous forme de tuple, et retourner tôt pour les cas particuliers (garde) :

def analyser_code(code):
    if code == 200:
        return "OK", True
    if code == 404:
        return "Introuvable", False
    return "Autre", False

message, succes = analyser_code(404)
print(message, succes)

Exercice 3.2

Une variable créée dans une fonction est locale : elle n'existe pas à l'extérieur. Une variable créée au niveau du script est globale et lisible partout. On évite de modifier des globales depuis une fonction : on préfère passer des paramètres et retourner des résultats :

seuil = 10  # globale : lisible dans les fonctions

def alerter(ip, tentatives):
    message = f"{ip} suspect"  # locale : invisible dehors
    return tentatives > seuil and message or "OK"

• Un nom de fonction = un verbe d'action (extraire_ip, generer_rapport).
• Une fonction = une seule tâche, courte (moins de 20 lignes si possible).
• Nommez les paramètres explicitement à l'appel pour les fonctions à plusieurs arguments.

Exercice 3.3

Une liste stocke plusieurs valeurs entre crochets. Les éléments sont indexés à partir de 0, les index négatifs partent de la fin. Les méthodes append(), remove(), sort() et la fonction len() sont incontournables :

ports = [22, 80, 443]
ports.append(8080)
print(ports[0], ports[-1], len(ports))
for p in ports:
    print(f"Scan du port {p}")

Le slicing liste[debut:fin] extrait une sous-liste, et l'opérateur in teste la présence d'un élément :

logs = ["OK", "OK", "FAIL", "OK"]
print(logs[1:3])        # ['OK', 'FAIL']
print("FAIL" in logs)   # True

Exercice 4.1

Un tuple (parenthèses) est une liste immuable : parfait pour des valeurs fixes comme une adresse et son masque. Un set (accolades) ne contient que des valeurs uniques et supporte les opérations d'ensembles :

reseau = ("192.168.1.0", 24)   # tuple : on ne le modifiera pas
print(f"{reseau[0]}/{reseau[1]}")

vues_jour1 = {"10.0.0.5", "10.0.0.9", "10.0.0.5"}
print(vues_jour1)  # {'10.0.0.5', '10.0.0.9'} : doublon elimine

Les sets excellent pour comparer des collections : intersection (&), différence (-), union (|). En SOC, on les utilise pour croiser des IP observées avec une liste d'IOC :

observees = {"1.2.3.4", "5.6.7.8", "9.9.9.9"}
ioc = {"5.6.7.8", "9.9.9.9"}
print(observees & ioc)  # IP malveillantes detectees

Exercice 4.2

Un dictionnaire associe des clés à des valeurs entre accolades. C'est LA structure de l'automatisation : configs d'équipements, réponses d'API JSON, compteurs. On accède avec d[cle] (ou d.get(cle, defaut) sans erreur si absent) :

equipement = {"hostname": "R1", "ip": "10.0.0.1", "os": "IOS"}
print(equipement["hostname"])
equipement["vlan"] = 10
for cle, valeur in equipement.items():
    print(f"{cle} : {valeur}")

Les méthodes utiles : .keys(), .values(), .items() pour parcourir, .get() pour un accès sûr, in pour tester une clé. On peut imbriquer listes et dictionnaires pour modéliser un parc entier :

parc = [
    {"hostname": "R1", "ip": "10.0.0.1"},
    {"hostname": "SW1", "ip": "10.0.0.2"},
]
for eq in parc:
    print(f"{eq['hostname']} -> {eq['ip']}")

Exercice 4.3

Les compréhensions construisent une collection en une ligne : [expression for x in iterable if condition]. C'est l'idiome Python pour filtrer et transformer des données :

ports = [22, 80, 443, 8080, 3389]
ouverts = [p for p in ports if p < 1024]
print(ouverts)  # [22, 80, 443]

lignes = ["OK", "FAIL", "OK", "TIMEOUT"]
erreurs = [l for l in lignes if l != "OK"]
print(erreurs)

Même principe pour les dictionnaires et les sets. On combine souvent compréhension + split() pour parser du texte :

texte = "R1,SW1,SW2"
hotetes = [h.strip() for h in texte.split(",")]
compteurs = {h: 0 for h in hotetes}
print(compteurs)  # {'R1': 0, 'SW1': 0, 'SW2': 0}

Exercice 4.4