Python : les bases du langage

🎯 Objectif : À la fin de ce chapitre, tu maîtriseras les fondamentaux de Python — variables, types, opérateurs, strings et structures de données. ⏱️ Durée estimée : 45 minutes | Niveau : Débutant

Pourquoi Python en DevOps

Python est le langage dominant en DevOps. Ansible est écrit en Python. Les SDK AWS, GCP et Azure sont en Python. Terraform a des providers Python. Quand tu automatises un pipeline, parses des logs ou interagis avec une API — c’est Python qui sort.

Sa force : une syntaxe lisible, un écosystème massif et une courbe d’apprentissage douce. Pas besoin d’accolades, de points-virgules ou de types explicites. Tu écris du code qui ressemble à de l’anglais.

💡 Ce cours part de zéro. Si tu codes déjà dans un autre langage, tu iras vite. Sinon, pas de stress — Python est conçu pour être accessible.

Variables et types de données

En Python, créer une variable c’est simple : un nom, un =, une valeur. Pas besoin de déclarer un type — Python le détecte automatiquement.

# Types fondamentaux
hostname = "web-prod-01"        # str  (chaîne de caractères)
port = 8080                      # int  (entier)
cpu_usage = 72.5                 # float (nombre décimal)
is_running = True                # bool (booléen)
ip_address = None                # NoneType (absence de valeur)

# Vérifier le type
print(type(hostname))   # <class 'str'>
print(type(port))       # <class 'int'>

Conventions de nommage

Les variables Python utilisent le snake_case : server_name, max_retries, cpu_count. Pas de caractères spéciaux (sauf _), jamais de chiffre en début de nom. La casse compte : Server et server sont deux variables différentes.

Conversion de types

# String vers int/float
max_conn = int("100")       # 100
ratio = float("0.95")       # 0.95

# Int vers string (utile pour les logs)
port_str = str(8080)        # "8080"

# Vers booléen
bool(0)      # False
bool("")     # False
bool("text") # True
bool(42)     # True

🔥 En Python, 0, "", [], {}, None et False sont tous “falsy”. Tout le reste est “truthy”. Ce concept est central dans les conditions.

Opérateurs essentiels

Arithmétique et comparaison

# Arithmétique
10 + 3     # 13
10 / 3     # 3.333... (division flottante)
10 // 3    # 3        (division entière)
10 % 3     # 1        (modulo / reste)
2 ** 10    # 1024     (puissance)

# Comparaison
x, y = 10, 20
x == y     # False
x != y     # True
x < y      # True

# Logique
True and False   # False
True or False    # True
not True         # False

# Appartenance
ports = [80, 443, 8080]
80 in ports        # True
9090 not in ports  # True

💡 L’opérateur in est omniprésent en Python. Il marche sur les listes, les strings, les dicts (vérifie les clés) et les sets.

Strings : manipuler du texte

Les strings sont partout en DevOps : noms de fichiers, URLs, commandes shell, logs, configs YAML…

f-strings et formatage

server = "web-01"
env = "production"

# f-string (Python 3.6+) — la méthode recommandée
msg = f"Déploiement sur {server} en {env}"

# Expressions dans les f-strings
cpu = 85.7
print(f"CPU: {cpu:.1f}%")  # "CPU: 85.7%"
print(f"{'OK' if cpu < 90 else 'ALERTE'}")  # "OK"

Méthodes courantes

path = "/var/log/nginx/access.log"

# Découper et joindre
parts = path.split("/")       # ['', 'var', 'log', 'nginx', 'access.log']
"/".join(["usr", "local"])     # "usr/local"

# Transformer
hostname = "  Web-Server-01  "
hostname.strip()               # "Web-Server-01"
hostname.lower()               # "  web-server-01  "
hostname.replace("-", "_")     # "  Web_Server_01  "

# Vérifier
path.startswith("/var")        # True
path.endswith(".log")          # True
"nginx" in path                # True

Slicing

text = "Hello DevOps"
text[0]      # 'H'
text[-1]     # 's'
text[6:]     # 'DevOps'
text[:5]     # 'Hello'

⚠️ Les strings sont immutables en Python. hostname.lower() ne modifie pas hostname — il retourne une nouvelle string. Il faut réassigner : hostname = hostname.lower().

Listes : collections ordonnées

La liste est la structure de données la plus utilisée en Python. Elle est ordonnée, modifiable, et peut contenir n’importe quel type.

# Créer une liste
servers = ["web-01", "web-02", "db-01", "cache-01"]

# Accès et slicing
servers[0]      # "web-01"
servers[-1]     # "cache-01"
servers[1:3]    # ["web-02", "db-01"]
len(servers)    # 4

Modifier une liste

# Ajouter
servers.append("worker-01")         # à la fin
servers.insert(2, "api-01")         # à l'index 2

# Supprimer
servers.remove("cache-01")          # par valeur
last = servers.pop()                 # retire et retourne le dernier
del servers[0]                       # par index

# Fusionner
servers.extend(["log-01", "mon-01"])
# ou
all_servers = servers + ["extra-01"]

# Trier
servers.sort()                       # alphabétique en place
servers.sort(reverse=True)           # ordre inverse

🔥 Vérifier si une liste est vide à la manière Python : if not servers: plutôt que if len(servers) == 0:.

Dictionnaires : clé-valeur

Le dict est la structure parfaite pour les configurations, métadonnées et réponses d’API.

# Configuration d'un service
service = {
    "name": "nginx",
    "port": 443,
    "ssl": True,
    "replicas": 3,
    "labels": ["web", "frontend"]
}

# Accès
service["name"]                # "nginx"
service.get("timeout", 30)     # 30 (défaut si clé absente)

# Modifier
service["version"] = "1.25"    # ajouter
service["port"] = 8443         # modifier
del service["ssl"]             # supprimer

Parcourir un dict

for key, value in service.items():
    print(f"{key}: {value}")

# Vérifier l'existence d'une clé
if "port" in service:
    print(f"Port: {service['port']}")

💡 Depuis Python 3.7, les dicts conservent l’ordre d’insertion. Tu peux compter dessus.

Tuples et sets

Tuples : collections immutables

Un tuple ressemble à une liste mais ne peut pas être modifié. Idéal pour les données constantes.

# Coordonnées d'un datacenter (Genève)
coords = (46.2044, 6.1432)
lat, lon = coords              # unpacking

# Échange élégant de valeurs
a, b = 10, 20
a, b = b, a                    # a=20, b=10

# Retour multiple de fonction
def get_server_info():
    return "web-01", "10.0.1.10", 8080

name, ip, port = get_server_info()

Sets : collections uniques

Un set élimine automatiquement les doublons et permet des opérations ensemblistes rapides.

# Dédupliquer
ips = ["10.0.0.1", "10.0.0.2", "10.0.0.1"]
unique_ips = set(ips)          # {"10.0.0.1", "10.0.0.2"}

# Opérations ensemblistes
allowed = {80, 443, 22}
open_ports = {80, 443, 3306, 5432}

open_ports & allowed           # {80, 443}    — intersection
open_ports - allowed           # {3306, 5432} — ports non autorisés
open_ports | allowed           # tous          — union

🎯 Cas concret : comparer les ports ouverts d’un serveur avec la whitelist du firewall. Un set fait ça en une ligne.

Cas entreprise : parser un inventaire

Contexte : tu reçois un dict représentant l’inventaire de ton infrastructure et tu dois en extraire un résumé.

inventory = {
    "web": [
        {"host": "web-01", "ip": "10.0.1.10", "env": "prod"},
        {"host": "web-02", "ip": "10.0.1.11", "env": "prod"},
    ],
    "database": [
        {"host": "db-01", "ip": "10.0.2.10", "env": "prod"},
    ],
    "monitoring": [
        {"host": "mon-01", "ip": "10.0.3.10", "env": "staging"},
    ],
}

# Compter les serveurs par groupe
total = 0
for group, servers in inventory.items():
    count = len(servers)
    total += count
    print(f"{group}: {count} serveur(s)")

print(f"\nTotal: {total} serveurs")

# Extraire toutes les IPs de production
prod_ips = []
for group, servers in inventory.items():
    for srv in servers:
        if srv["env"] == "prod":
            prod_ips.append(srv["ip"])

print(f"IPs prod: {', '.join(prod_ips)}")

Les pièges classiques

⚠️ Modifier une liste pendant l’itération — for s in servers: servers.remove(s) donne des résultats imprévisibles. Crée une nouvelle liste à la place.

⚠️ Confondre = et == — x = 5 assigne, x == 5 compare. Les débutants font souvent l’erreur dans les conditions.

⚠️ Les index commencent à 0 — servers[1] retourne le deuxième élément, pas le premier.

⚠️ Mutabilité des listes et dicts — a = [1, 2]; b = a ne copie pas la liste. b pointe vers la même liste. Utilise b = a.copy() pour une vraie copie.

⚠️ Les strings sont immutables — .lower(), .strip() retournent de nouvelles strings. L’original ne change pas.

Résumé

Python repose sur quelques types fondamentaux que tu utiliseras quotidiennement :

• Variables → typage dynamique, snake_case, conversion avec int(), str(), float()
• Strings → f-strings pour le formatage, .split() / .join() pour découper/joindre
• Listes → ordonnées, modifiables, append() / pop() / sort()
• Dicts → clé-valeur, .get() avec défaut, itération avec .items()
• Tuples → immutables, unpacking, retours multiples
• Sets → unicité, opérations ensemblistes (&, -, |)

🎯 Ces structures sont les briques de base. Dans le prochain chapitre, on ajoute les conditions, les boucles et les fonctions pour écrire de vrais scripts d’automatisation.

➡️ La suite : Structures de contrôle et fonctions