← HUB ✦ Holberton School — Python ✦

PYTHON
DÉBUTANT

Les bases. Proprement. Une fois pour toutes.

VENANT DU C — CE QUI CHANGE
⚡ LES DIFFÉRENCES CLÉS AVEC LE C
EN C
// typage explicite
int x = 5;
char *s = "hello";

// accolades
if (x > 0) {
    printf("%d\n", x);
}

// point-virgule obligatoire
int i = 0;
while (i < 5) {
    i++;
}

// compilation nécessaire
gcc fichier.c -o prog
./prog
EN PYTHON
# pas de type déclaré
x = 5
s = "hello"

# indentation = structure !
if x > 0:
    print(x)

# pas de point-virgule
i = 0
while i < 5:
    i += 1

# interprété directement
python3 fichier.py
En Python, l'indentation n'est pas optionnelle — c'est la structure du code. 4 espaces par niveau. Un mauvais indentage = IndentationError ou pire, un bug silencieux.
VARIABLES ET TYPES DE BASE
📦 DÉCLARER ET TYPER
# ── LES 4 TYPES DE BASE ───────────────────────────────────
age    = 25           # int   — nombre entier
taille = 1.80         # float — nombre décimal
nom    = "Alice"      # str   — chaîne de caractères
actif  = True         # bool  — True ou False (majuscule !)

# ── VÉRIFIER LE TYPE ─────────────────────────────────────
print(type(age))      # → <class 'int'>
print(type(nom))      # → <class 'str'>
print(type(actif))    # → <class 'bool'>

# ── CONVERTIR UN TYPE ────────────────────────────────────
x = int("42")         # str → int    : 42
y = float("3.14")    # str → float  : 3.14
z = str(100)          # int → str    : "100"
b = bool(0)           # int → bool   : False (0 = False, tout autre = True)

# ── ASSIGNATION MULTIPLE ──────────────────────────────────
a, b, c = 1, 2, 3    # a=1, b=2, c=3
x = y = z = 0        # tous valent 0

# ── SWAP SANS VARIABLE TMP (uniquement en Python !) ───────
a, b = b, a           # échange les valeurs en une ligne
Python est dynamiquement typé — une variable peut changer de type en cours de route. x = 5 puis x = "hello" est valide. Pas de int x comme en C.
PRINT ET F-STRINGS
🖨️ AFFICHER DES VALEURS
# ── PRINT BASIQUE ────────────────────────────────────────
print("Bonjour")               # → Bonjour
print(42)                      # → 42
print("age :", 25)             # → age : 25  (espace auto entre les args)
print("a", "b", "c")           # → a b c

# ── OPTIONS DE PRINT ────────────────────────────────────
print("a", "b", sep="-")       # → a-b  (séparateur personnalisé)
print("texte", end="")         # → pas de saut de ligne en fin
print("texte", end="\n\n")     # → double saut de ligne

# ── CONCATÉNATION (méthode ancienne) ────────────────────
nom = "Alice"
age = 25
print("Je m'appelle " + nom)    # ✅ mais ne marche qu'avec des str
print("Age : " + str(age))     # ⚠️ conversion obligatoire si int
✨ F-STRINGS — LA FAÇON MODERNE (Python 3.6+)
nom = "Alice"
age = 25
taille = 1.756

# ── F-STRING — préfixe f devant les guillemets ──────────
print(f"Je m'appelle {nom}")              # → Je m'appelle Alice
print(f"J'ai {age} ans")                   # → J'ai 25 ans
print(f"{nom} a {age} ans")                 # → Alice a 25 ans

# ── EXPRESSIONS DANS LES ACCOLADES ──────────────────────
print(f"Dans 10 ans : {age + 10} ans")     # → Dans 10 ans : 35 ans
print(f"Majuscules : {nom.upper()}")       # → Majuscules : ALICE

# ── FORMATAGE DES NOMBRES ───────────────────────────────
print(f"Taille : {taille:.2f} m")          # → Taille : 1.76 m  (2 décimales)
print(f"Taille : {taille:.0f} m")          # → Taille : 2 m     (0 décimale)
print(f"Score : {42:05d}")                 # → Score : 00042    (rembourrage 0)
print(f"Pi ≈ {3.14159:.3f}")              # → Pi ≈ 3.142

# ── .FORMAT() — ancienne syntaxe (à connaître) ──────────
print("Je m'appelle {}".format(nom))       # → Je m'appelle Alice
print("{} a {} ans".format(nom, age))     # → Alice a 25 ans
print("{0} et {0}".format(nom))           # → Alice et Alice  (index)
print("{n} a {a} ans".format(n=nom, a=age)) # → Alice a 25 ans (nommé)

# ── % FORMATTING — très ancienne syntaxe (encore vue) ───
print("Je m'appelle %s" % nom)            # → Je m'appelle Alice
print("%s a %d ans" % (nom, age))        # → Alice a 25 ans
Utilise les f-strings par défaut — c'est la syntaxe moderne, la plus lisible et la plus rapide. .format() et % sont utiles à reconnaître dans du vieux code.
OPÉRATEURS
🔢 OPÉRATEURS ARITHMÉTIQUES
a, b = 10, 3

print(a + b)    # 13  — addition
print(a - b)    # 7   — soustraction
print(a * b)    # 30  — multiplication
print(a / b)    # 3.333... — division RÉELLE (retourne toujours un float)
print(a // b)   # 3   — division ENTIÈRE (comme en C)
print(a % b)    # 1   — modulo (reste de la division)
print(a ** b)   # 1000 — puissance (10³) ← pas d'équivalent direct en C

# ── ASSIGNATION COMPOSÉE ────────────────────────────────
x = 10
x += 5   # x = 15
x -= 3   # x = 12
x *= 2   # x = 24
x //= 4  # x = 6
x **= 2  # x = 36

# ⚠️ Il n'y a PAS de x++ ou x-- en Python !
En Python, / retourne toujours un float (10 / 2 = 5.0). Pour une division entière comme en C, utilise // (10 // 2 = 5).
⚖️ OPÉRATEURS DE COMPARAISON ET LOGIQUES
# ── COMPARAISON (retournent True ou False) ──────────────
print(5 == 5)    # True  — égal
print(5 != 3)    # True  — différent
print(5 >  3)    # True  — supérieur
print(5 <  3)    # False — inférieur
print(5 >= 5)    # True  — supérieur ou égal
print(5 <= 3)    # False — inférieur ou égal

# ── OPÉRATEURS LOGIQUES (and, or, not) ─────────────────
print(True and False)   # False — les deux doivent être vrais (comme &&)
print(True or  False)   # True  — au moins un doit être vrai (comme ||)
print(not True)          # False — inverse le booléen (comme !)

# ── CHAÎNER LES COMPARAISONS (uniquement en Python !) ──
x = 5
print(1 < x < 10)        # True  — équivaut à (1 < x and x < 10)
print(0 <= x <= 5)       # True

# ── IN / NOT IN ─────────────────────────────────────────
print("a" in "alphabet")   # True  — "a" est dans la chaîne
print(3 in [1, 2, 3])     # True  — 3 est dans la liste
print(5 not in [1, 2])   # True  — 5 n'est pas dans la liste
CONDITIONS — IF / ELIF / ELSE
🔀 STRUCTURE DES CONDITIONS
age = 17

# ── IF SIMPLE ───────────────────────────────────────────
if age >= 18:
    print("Majeur")         # ← 4 espaces d'indentation

# ── IF / ELSE ────────────────────────────────────────────
if age >= 18:
    print("Majeur")
else:
    print("Mineur")         # → Mineur

# ── IF / ELIF / ELSE ─────────────────────────────────────
note = 75

if note >= 90:
    print("A")
elif note >= 80:
    print("B")
elif note >= 70:
    print("C")               # → C
elif note >= 60:
    print("D")
else:
    print("F")

# ── CONDITIONS IMBRIQUÉES ────────────────────────────────
x = 15
if x > 0:
    if x % 2 == 0:
        print("positif et pair")
    else:
        print("positif et impair")  # → positif et impair

# ── TERNAIRE — if en une ligne ───────────────────────────
statut = "majeur" if age >= 18 else "mineur"
print(statut)               # → mineur
Valeurs considérées comme False : 0, 0.0, "" (chaîne vide), [] (liste vide), None. Tout le reste est True. Utile pour if ma_liste: au lieu de if len(ma_liste) > 0:.
BOUCLE FOR ET RANGE
🔁 FOR — PARCOURIR DES SÉQUENCES
# ── FOR + RANGE — comme le for du C ─────────────────────
for i in range(5):            # i = 0, 1, 2, 3, 4
    print(i)

for i in range(1, 6):         # i = 1, 2, 3, 4, 5  (de 1 à 5 inclus)
    print(i)

for i in range(0, 10, 2):    # i = 0, 2, 4, 6, 8  (par pas de 2)
    print(i)

for i in range(10, 0, -1):  # i = 10, 9, ..., 1  (à rebours)
    print(i)

# ── FOR SUR UNE STRING ───────────────────────────────────
for lettre in "Python":        # parcourt chaque caractère
    print(lettre)              # → P y t h o n

# ── PARCOURIR L'ALPHABET ─────────────────────────────────
import string
for lettre in string.ascii_lowercase:   # a, b, c, ..., z
    print(lettre, end=" ")

# OU avec ord/chr
for i in range(97, 123):       # 97='a', 122='z'
    print(chr(i), end=" ")      # → a b c ... z

# ── FOR SUR UNE LISTE ────────────────────────────────────
fruits = ["pomme", "banane", "cerise"]
for fruit in fruits:
    print(fruit)

# ── FOR AVEC INDEX — enumerate ───────────────────────────
for index, fruit in enumerate(fruits):
    print(f"{index} : {fruit}")  # → 0 : pomme, 1 : banane ...

# ── BREAK ET CONTINUE ────────────────────────────────────
for i in range(10):
    if i == 5:
        break              # arrêter la boucle
    if i % 2 == 0:
        continue           # passer à l'itération suivante
    print(i)               # → 1, 3
📐 RANGE — TOUT COMPRENDRE
# range(stop)           → de 0 à stop-1
# range(start, stop)    → de start à stop-1
# range(start, stop, step) → de start à stop-1 par pas de step

range(5)          # 0, 1, 2, 3, 4
range(1, 6)       # 1, 2, 3, 4, 5
range(0, 10, 2)  # 0, 2, 4, 6, 8
range(5, 0, -1) # 5, 4, 3, 2, 1

# Voir le contenu d'un range
print(list(range(5)))     # → [0, 1, 2, 3, 4]
print(list(range(1, 6)))  # → [1, 2, 3, 4, 5]

# Exemples pratiques
# Afficher les carrés de 1 à 10
for n in range(1, 11):
    print(f"{n}² = {n**2}")

# Afficher les multiples de 3 jusqu'à 30
for n in range(3, 31, 3):
    print(n, end=" ")       # → 3 6 9 12 ... 30
range ne crée pas une liste en mémoire — c'est un objet paresseux qui génère les nombres à la demande. Pour en faire une vraie liste : list(range(5)).
BOUCLE WHILE
🔄 WHILE — TANT QUE LA CONDITION EST VRAIE
# ── WHILE BASIQUE ────────────────────────────────────────
i = 0
while i < 5:
    print(i)           # → 0, 1, 2, 3, 4
    i += 1             # ⚠️ ne pas oublier d'incrémenter → boucle infinie sinon

# ── WHILE AVEC BREAK ────────────────────────────────────
compteur = 0
while True:           # boucle infinie — sortie par break
    compteur += 1
    if compteur == 5:
        break
print(compteur)        # → 5

# ── WHILE AVEC CONTINUE ──────────────────────────────────
i = 0
while i < 10:
    i += 1
    if i % 2 == 0:
        continue       # sauter les pairs
    print(i)           # → 1, 3, 5, 7, 9

# ── WHILE / ELSE ─────────────────────────────────────────
# Le else s'exécute si la boucle se termine SANS break
i = 0
while i < 3:
    print(i)
    i += 1
else:
    print("Boucle terminée normalement")   # → s'affiche
Cas d'usageForWhile
Nombre d'itérations connu✅ IdéalFonctionne
Parcourir une séquence✅ IdéalPossible
Condition inconnue à l'avancePeu adapté✅ Idéal
Boucle infinie contrôléeNon✅ while True
FONCTIONS BUILT-IN — LES INCONTOURNABLES
🛠️ FONCTIONS INTÉGRÉES À CONNAÎTRE PAR CŒUR
# ── AFFICHAGE ET ENTRÉE ──────────────────────────────────
print("texte")                  # afficher sur stdout
nom = input("Ton nom : ")      # lire depuis stdin (retourne toujours une str !)
age = int(input("Ton âge : ")) # lire ET convertir en int

# ── TYPES ET CONVERSIONS ─────────────────────────────────
type(42)                        # → <class 'int'>
int("42")                       # → 42
float("3.14")                   # → 3.14
str(100)                        # → "100"
bool(0)                         # → False
list("abc")                     # → ['a', 'b', 'c']

# ── MATHS ────────────────────────────────────────────────
abs(-5)                         # → 5    (valeur absolue)
round(3.7)                      # → 4    (arrondi)
round(3.14159, 2)               # → 3.14 (arrondi à N décimales)
min(3, 1, 4)                    # → 1
max(3, 1, 4)                    # → 4
sum([1, 2, 3, 4])               # → 10
pow(2, 10)                      # → 1024 (équivaut à 2**10)

# ── CHAÎNES DE CARACTÈRES ────────────────────────────────
len("hello")                    # → 5  (longueur)
ord("A")                        # → 65 (code ASCII du caractère)
chr(65)                         # → "A" (caractère depuis son code ASCII)
chr(ord("a") + 1)               # → "b" (lettre suivante dans l'alphabet)

# ── LISTES ───────────────────────────────────────────────
len([1, 2, 3])                  # → 3
sorted([3, 1, 2])               # → [1, 2, 3]
reversed([1, 2, 3])             # → itérateur 3, 2, 1
enumerate(["a", "b"])           # → (0, "a"), (1, "b")
range(5)                        # → 0, 1, 2, 3, 4

# ── DIVERS UTILES ────────────────────────────────────────
print(id(42))                    # adresse mémoire de l'objet
print(isinstance(42, int))      # → True (vérifier le type)
print(dir("hello"))              # liste toutes les méthodes disponibles
help(print)                      # documentation intégrée de print
MÉTHODES DES STRINGS — .METHODE()
🔤 LES MÉTHODES ESSENTIELLES DES CHAÎNES
s = "  Bonjour le Monde  "

# ── CASSE ────────────────────────────────────────────────
s.upper()            # → "  BONJOUR LE MONDE  "
s.lower()            # → "  bonjour le monde  "
s.capitalize()       # → "  bonjour le monde  " (1ère lettre en maj)
s.title()            # → "  Bonjour Le Monde  " (chaque mot en maj)
s.swapcase()         # → "  bONJOUR LE mONDE  " (inverse la casse)

# ── NETTOYAGE ────────────────────────────────────────────
s.strip()             # → "Bonjour le Monde"  (supprime espaces début/fin)
s.lstrip()            # → "Bonjour le Monde  " (gauche seulement)
s.rstrip()            # → "  Bonjour le Monde" (droite seulement)

# ── RECHERCHE ────────────────────────────────────────────
mot = "Python est super"
mot.find("est")       # → 7  (index de "est", -1 si pas trouvé)
mot.count("s")        # → 2  (nombre d'occurrences)
mot.startswith("Py") # → True
mot.endswith("er")   # → True
"est" in mot          # → True  (test d'appartenance)

# ── MODIFICATION ─────────────────────────────────────────
mot.replace("super", "génial")  # → "Python est génial"

# ── DÉCOUPAGE / JOINTURE ─────────────────────────────────
phrase = "un,deux,trois"
mots = phrase.split(",")         # → ["un", "deux", "trois"]
"-".join(mots)                   # → "un-deux-trois"
" ".join(["a", "b", "c"])      # → "a b c"

# ── VÉRIFICATIONS ────────────────────────────────────────
"123".isdigit()      # → True  (que des chiffres)
"abc".isalpha()      # → True  (que des lettres)
"abc3".isalnum()     # → True  (lettres et chiffres)
"   ".isspace()      # → True  (que des espaces)

# ── SLICING — accès à des parties ────────────────────────
s = "Python"
s[0]       # → "P"    (1er caractère)
s[-1]      # → "n"   (dernier caractère)
s[0:3]     # → "Pyt" (de 0 à 2 inclus)
s[2:]      # → "thon"(de l'index 2 à la fin)
s[:3]      # → "Pyt" (du début à l'index 2)
s[::-1]    # → "nohtyP" (chaîne inversée)
ORD() ET CHR() — TRAVAILLER AVEC L'ALPHABET
🔡 PARCOURIR L'ALPHABET ET MANIPULER LES CARACTÈRES
# ── ORD() — caractère → code ASCII ───────────────────────
print(ord("a"))   # → 97
print(ord("z"))   # → 122
print(ord("A"))   # → 65
print(ord("Z"))   # → 90

# ── CHR() — code ASCII → caractère ───────────────────────
print(chr(97))    # → "a"
print(chr(65))    # → "A"

# ── PARCOURIR TOUT L'ALPHABET ────────────────────────────
# Minuscules : a = 97, z = 122
for i in range(97, 123):
    print(chr(i), end=" ")
# → a b c d e f g h i j k l m n o p q r s t u v w x y z

# Majuscules : A = 65, Z = 90
for i in range(65, 91):
    print(chr(i), end=" ")
# → A B C D E F G H I J K L M N O P Q R S T U V W X Y Z

# ── DÉCALER UNE LETTRE ───────────────────────────────────
lettre = "c"
print(chr(ord(lettre) + 3))   # → "f"  (décalage de 3)
print(chr(ord(lettre) - 1))   # → "b"  (lettre précédente)

# ── POSITION DANS L'ALPHABET ─────────────────────────────
for lettre in "abc":
    pos = ord(lettre) - ord("a") + 1   # a=1, b=2, c=3
    print(f"{lettre} est la lettre n°{pos}")
SCRIPTS TYPES — EXEMPLES COMPLETS
🐣 EXEMPLE 1 — TABLE DE MULTIPLICATION
n = int(input("Table de quel nombre ? "))

print(f"\n── Table de {n} ──")
for i in range(1, 11):
    print(f"{n} x {i:2d} = {n * i:3d}")

# :2d = aligner sur 2 caractères  |  :3d = aligner sur 3 caractères
⚔️ EXEMPLE 2 — FizzBuzz
for i in range(1, 101):
    if i % 15 == 0:         # divisible par 3 ET 5 → tester en premier
        print("FizzBuzz")
    elif i % 3 == 0:
        print("Fizz")
    elif i % 5 == 0:
        print("Buzz")
    else:
        print(i)
💀 EXEMPLE 3 — PYRAMIDE D'ÉTOILES
hauteur = int(input("Hauteur de la pyramide : "))

for i in range(1, hauteur + 1):
    # espaces à gauche + étoiles
    espaces = " " * (hauteur - i)
    etoiles = "*" * (2 * i - 1)
    print(espaces + etoiles)

# Résultat pour hauteur=4 :
#    *
#   ***
#  *****
# *******
RÉSUMÉ — TOUT EN UN COUP D'ŒIL
🗺️ LA CARTE MENTALE PYTHON DÉBUTANT
# TYPES DE BASE
# ─────────────────────────────────────────────────────
# int   → 42          float  → 3.14
# str   → "hello"     bool   → True / False

# PRINT
# ─────────────────────────────────────────────────────
# print("texte")             → affiche avec \n
# print(f"valeur : {var}")   → f-string ← préférer
# print(a, b, sep="-")       → séparateur
# print("x", end="")         → sans saut de ligne

# OPÉRATEURS IMPORTANTS
# ─────────────────────────────────────────────────────
# /   → division réelle (float)   // → division entière
# **  → puissance                 %  → modulo
# and, or, not  (pas &&, ||, !)
# in, not in    (appartenance)
# ⚠️  Pas de ++ ni --  →  utiliser += 1

# CONDITIONS
# ─────────────────────────────────────────────────────
# if condition:          elif condition:      else:
#     code                   code                code

# BOUCLES
# ─────────────────────────────────────────────────────
# for i in range(n):     → 0 à n-1
# for i in range(a, b):  → a à b-1
# for x in sequence:     → parcourir string/liste
# while condition:        → tant que vrai
# break / continue       → même logique qu'en C

# BUILT-INS ESSENTIELS
# ─────────────────────────────────────────────────────
# print()   input()   type()   len()
# int()     float()   str()    bool()
# range()   abs()     min()    max()
# ord()     chr()     sum()    round()

# MÉTHODES STRING
# ─────────────────────────────────────────────────────
# .upper()  .lower()  .strip()   .replace()
# .split()  .join()   .find()    .startswith()
# .isdigit() .isalpha() .count()

# ORD / CHR
# ─────────────────────────────────────────────────────
# ord("a") = 97     chr(97) = "a"
# ord("A") = 65     chr(65) = "A"
# Alphabet minuscule : range(97, 123)
# Alphabet majuscule : range(65, 91)