Les bases. Proprement. Une fois pour toutes.
// 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
# 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
IndentationError ou pire, un bug silencieux.# ── 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
x = 5 puis x = "hello" est valide. Pas de int x comme en C.# ── 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
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
.format() et % sont utiles à reconnaître dans du vieux code.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 !
/ retourne toujours un float (10 / 2 = 5.0). Pour une division entière comme en C, utilise // (10 // 2 = 5).# ── 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
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
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:.# ── 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(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)).# ── 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'usage | For | While |
|---|---|---|
| Nombre d'itérations connu | ✅ Idéal | Fonctionne |
| Parcourir une séquence | ✅ Idéal | Possible |
| Condition inconnue à l'avance | Peu adapté | ✅ Idéal |
| Boucle infinie contrôlée | Non | ✅ while True |
# ── 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
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() — 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}")
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
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)
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 :
# *
# ***
# *****
# *******
# 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)