Premiers pas python

Variables · Affichage · Demande

Affichage avec print()

print("Hello World!")

prenom = "Maya"
print("Bonjour", prenom)

Affiche un message dans le terminal. Plusieurs éléments peuvent être séparés par des virgules.

Demander à l'utilisateur

La fonction input() demande une saisie et retourne une chaîne (str). Stocker la réponse pour la réutiliser.

Conversion de types

Convertir une chaîne en entier ou flottant avec int() et float(); transformer vers chaîne avec str().

# Demande de l'âge à l'utilisateur
age = input("Quel est votre âge ? ")

# l'utilisateur remplit 19
print(age)  # '19'
type(age)   # str

# convertir en entier
age = int(age)
Niveau Intro

Exercice 1 — Mon premier message

Créer un programme qui affiche "Bienvenue en Python !" dans le terminal.
Niveau Intro

Exercice 2 — Afficher mon prénom

Créer une variable prenom avec votre prénom, puis l'afficher avec print().
Niveau Intro

Exercice 3 — Dire bonjour

Demander le prénom de l'utilisateur avec input(), puis afficher "Bonjour" suivi de son prénom.
Niveau Intro

Exercice 4 — Mon âge

Demander l'âge de l'utilisateur et afficher "Vous avez X ans" (où X est l'âge saisi).
Niveau Intro

Exercice 5 — Deux informations

Demander le prénom et la ville de l'utilisateur, puis afficher les deux informations dans une seule phrase.
Niveau Intro

Exercice 6 — Animal préféré

Demander l'animal préféré de l'utilisateur, le stocker dans une variable, puis afficher "Mon animal préféré est" suivi de l'animal.

Listes · Tuples

Structures linéaires : listes (mutables) et tuples (immuables), parcours et opérations courantes, puis exercices sous forme de fonctions.

Créer et manipuler une liste

# Création
notes = [12, 15, 9, 18]

# Accès par indice
premiere = notes[0]   # 12
derniere = notes[-1]  # 18

# Longueur
taille = len(notes)   # 4

# Parcours par valeur
for n in notes:
    print(n)

# Parcours par indice
for i in range(len(notes)):
    print(i, notes[i])

# Compréhension de liste
carres = [x*x for x in range(5)]  # [0,1,4,9,16]

Méthodes utiles sur les listes

Méthodes courantes pour ajouter, retirer, trier, copier et interroger une liste.

liste = [3, 1, 4]

# Ajouter / étendre / insérer
liste.append(2)             # [3, 1, 4, 2]
liste.extend([5, 6])        # [3, 1, 4, 2, 5, 6]
liste.insert(1, 99)         # [3, 99, 1, 4, 2, 5, 6]

# Retirer / dépiler
liste.remove(99)            # supprime la première occurrence de 99
x = liste.pop()             # retire et retourne le dernier élément
y = liste.pop(2)            # retire à l’indice 2

# Compter / trouver indice
c = liste.count(3)          # nombre d’occurrences de 3
i = liste.index(4)          # première position de 4

# Trier / inverser
liste.sort()                # tri croissant
liste.sort(reverse=True)    # tri décroissant
liste.reverse()             # inversion

# Découpage (slicing)
milieu = liste[2:5]
inverse = liste[::-1]

# Copie (pour éviter les alias)
copie1 = liste[:]           # copie par slicing
copie2 = liste.copy()       # copie

Attention : les listes sont mutables; utiliser une copie pour conserver l’original si vous devez modifier sans impacter la variable source.

Tuples

Un tuple est une séquence immuable. On peut l'indexer et le parcourir comme une liste, mais on ne peut pas modifier ses éléments.

coord = (10, 20)
x = coord[0]  # 10
y = coord[1]  # 20
# coord[0] = 99  # Erreur : tuple immuable
Listes · Tuples

Exercice 1 — Somme des éléments

Écrire une fonction somme_elements(liste) qui retourne la somme des éléments de liste.
Listes · Tuples

Exercice 2 — Compter les pairs

Écrire une fonction compter_pairs(liste) qui retourne le nombre d'éléments pairs dans liste.
Listes · Tuples

Exercice 3 — Longueurs des chaînes

Écrire une fonction longueur_chaines(liste) qui retourne une nouvelle liste contenant la longueur de chaque chaîne de liste.
Listes · Tuples

Exercice 4 — Produit des éléments

Écrire une fonction produit_elements(liste) qui retourne le produit des éléments; pour une liste vide, retourner 1.
Listes · Tuples

Exercice 5 — Occurrences

Écrire une fonction compter_occurrences(liste, valeur) qui retourne le nombre d'occurrences de valeur dans liste.
Listes · Tuples

Exercice 6 — Inverser une liste

Écrire une fonction inverser_liste(liste) qui retourne une nouvelle liste avec les éléments dans l'ordre inverse.
Listes · Tuples

Exercice 7 — Concaténation

Écrire une fonction concatener_listes(a, b) qui retourne une nouvelle liste contenant les éléments de a suivis de ceux de b.
Listes · Tuples

Exercice 8 — Premiers éléments

Écrire une fonction premiers_elements(liste, n) qui retourne les n premiers éléments de liste (ou toute la liste si n est plus grand).

Conditions

La structure if

age = 18
if age >= 18:
    print("Vous êtes majeur")

Après if, écrire la condition, terminer par : et indenter le bloc exécuté si la condition est vraie.

if–else

age = 15

if age >= 18:
    print("Vous êtes majeur")
else:
    print("Vous êtes mineur")

if–elif–else

Pour tester plusieurs conditions successives, utiliser elif.

note = 14

if note >= 16:
    print("Très bien")
elif note >= 14:
    print("Bien")
elif note >= 12:
    print("Assez bien")
elif note >= 10:
    print("Passable")
else:
    print("Insuffisant")

Opérateurs de comparaison

Pour créer des conditions, utiliser les opérateurs suivants :

opérateursignificationexemple
>supérieur3 > 1
<inférieur3 < 1
>=supérieur ou égal3 >= 1
<=inférieur ou égal3 <= 1
==égal à3 == 1
!=différent de3 != 1

Attention à ne pas confondre l'affectation = avec la comparaison ==.

Opérateurs logiques

and (et)

Les deux conditions doivent être vraies.

age = 20
permis = True

if age >= 18 and permis == True:
    print("Vous pouvez conduire")

or (ou)

Au moins une des conditions doit être vraie.

jour = "samedi"

if jour == "samedi" or jour == "dimanche":
    print("C'est le week-end !")

not (non)

Inverse la condition.

pluie = False

if not pluie:
    print("On peut sortir sans parapluie")
Conditions

Exercice 1 — Comparaison de deux nombres

Demander deux nombres à l'utilisateur et afficher lequel est le plus grand. Si les deux nombres sont égaux, afficher "Les nombres sont égaux".
Conditions

Exercice 2 — Vérification de longueur

Demander un mot à l'utilisateur. Si le mot contient plus de 5 lettres, afficher "Mot long", sinon afficher "Mot court".
Indice : len(s) renvoie la longueur de la chaîne s.
Conditions

Exercice 3 — Catégorie d'âge

Demander l'âge de l'utilisateur et afficher sa catégorie : 0–12 : Enfant ; 13–17 : Adolescent ; 18–59 : Adulte ; 60+ : Senior.
Conditions

Exercice 4 — Calculatrice de moyenne

Demander deux notes à l'utilisateur et calculer leur moyenne. Si la moyenne ≥ 10 : afficher "Vous passez en classe supérieure" ; sinon : afficher "Vous devez redoubler".
Conditions

Exercice 5 — Prix du billet de train

Demander l'âge de l'utilisateur et la distance du trajet (km). Calculer le prix avec : base = distance × 0.20€ ; enfant (< 12) : −50% ; senior (≥ 65) : −30% ; si distance > 200 : −10€ supplémentaires. Afficher le prix final.

Fonctions

Qu'est-ce qu'une fonction ?

Une fonction est un bloc de code réutilisable qui effectue une tâche spécifique. Elle organise le code et évite les répétitions.

Définir et appeler une fonction

def dire_bonjour():
    print("Bonjour !")
    print("Comment allez-vous ?")

dire_bonjour()

Paramètres

def dire_bonjour(prenom):
    print("Bonjour", prenom)

dire_bonjour("Alice")
dire_bonjour("Bob")

Plusieurs paramètres sont possibles, séparés par des virgules :

def additionner(a, b):
    resultat = a + b
    print("La somme est :", resultat)

additionner(5, 3)

Retour de valeur avec return

def additionner(a, b):
    resultat = a + b
    return resultat

somme = additionner(10, 20)
print(somme)  # 30

print affiche une valeur, return renvoie une valeur pour réutilisation.

def calculer_double(nombre):
    return nombre * 2

resultat = calculer_double(5)
print("Le double est :", resultat)
Fonctions

Exercice 1 — Ma première fonction

Créer une fonction afficher_message() qui affiche "Bienvenue dans mon programme !". Appeler cette fonction 3 fois.
Fonctions

Exercice 2 — Fonction avec paramètre

Créer une fonction saluer(nom) qui prend un nom et affiche "Bonjour" suivi du nom. Appeler avec différents noms.
Fonctions

Exercice 3 — Calcul du carré

Créer une fonction calculer_carre(nombre) qui retourne le carré. Demander un nombre, utiliser la fonction et afficher le résultat.
Fonctions

Exercice 4 — Vérification de parité

Créer une fonction est_pair(nombre) qui retourne True si le nombre est pair et False sinon. Demander un nombre et afficher s'il est pair ou impair. Rappel : pair si nombre % 2 == 0.
Fonctions

Exercice 5 — Calcul de prix TTC

Créer une fonction calculer_ttc(prix_ht, taux_tva) qui retourne le prix TTC (HT × (1 + taux/100)). Demander les valeurs et afficher le prix TTC.
Fonctions

Exercice 6 — Calculatrice complète

Créer addition, soustraction, multiplication, division puis une fonction calculatrice() qui demande deux nombres et une opération, appelle la fonction appropriée et affiche le résultat.

Boucles

Rappels sur for, while, range(), break/continue, puis exercices sous forme de fonctions.

Boucle for et range()

# Parcourir une séquence de nombres de 1 à 5
for i in range(1, 6):
    print(i)

# Parcourir une liste
animaux = ["renard", "lapin", "hibou"]
for a in animaux:
    print(a)

range(debut, fin, pas) génère une séquence. Parcourir des listes directement est fréquent.

Boucle while

# Répéter tant qu'une condition est vraie
compteur = 0
while compteur < 3:
    print("tour", compteur)
    compteur += 1

Attention aux conditions et aux mises à jour des variables pour éviter les boucles infinies.

break et continue

for i in range(1, 10):
    if i == 5:
        break      # Arrête la boucle
    if i % 2 == 0:
        continue   # Passe à l'itération suivante
    print(i)

Utiliser break pour arrêter la boucle, continue pour sauter à l'itération suivante.

Boucles

Exercice 1 — 1 à 100

Écrire une fonction liste_de_1_a_100() qui retourne la liste des nombres de 1 à 100.
Boucles

Exercice 2 — Table de multiplication

Écrire une fonction table_multiplication(n) qui retourne une liste de 10 chaînes sous la forme "i x n = produit" pour i allant de 1 à 10.
Boucles

Exercice 3 — Somme de 1 à 100

Écrire une fonction somme_1_a_100() qui retourne la somme des entiers de 1 à 100.
Boucles

Exercice 4 — Pairs 1..100

Écrire une fonction pairs_1_a_100() qui retourne la liste des nombres pairs entre 1 et 100.
Boucles

Exercice 5 — Compter les voyelles

Écrire une fonction compter_voyelles(chaine) qui retourne le nombre de voyelles dans chaine. Indice : utiliser un ensemble comme set("aeiouyAEIOUY").
Boucles

Exercice 6 — Inverser une chaîne

Écrire une fonction inverser_chaine(chaine) qui retourne chaine inversée.
Boucles

Exercice 7 — Somme des chiffres

Écrire une fonction somme_chiffres(n) qui retourne la somme des chiffres de l'entier n.
Boucles

Exercice 8 — Jusqu'au premier négatif

Écrire une fonction compter_positifs_avant_negatif(entiers) qui parcourt la liste entiers et retourne le nombre de valeurs lues avant de rencontrer le premier négatif (ou la longueur si aucun négatif).
Boucles

Exercice 9 — Multiples de 3

Écrire une fonction multiples_de_trois(start, count) qui retourne la liste obtenue en partant de start et en le multipliant par 3, count fois de suite.
Boucles

Exercice 10 — Divisions par 2

Écrire une fonction nb_divisions_par_2(n) qui retourne le nombre de fois où n est divisible par 2 (division entière) jusqu'à devenir strictement inférieur à 2.
Boucles

Exercice 11 — Diviseurs et primalité

Écrire une fonction diviseurs_propres(n) qui retourne la liste des diviseurs de n (hors 1 et n). Puis écrire est_premier(n) qui retourne True si n est premier.
Boucles

Exercice 12 — Conjecture de Syracuse

Écrire une fonction sequence_syracuse(n) qui retourne la liste des termes de la suite de Syracuse en partant de n jusqu'à 1 (si pair: n // 2, sinon: 3*n + 1).
Boucles

Exercice 13 — Occurrences d’un caractère

Écrire une fonction compter_occurrences_caractere(chaine, c) qui retourne le nombre d’occurrences de c dans chaine en parcourant la chaîne caractère par caractère.
Boucles

Exercice 14 — Supprimer un caractère

Écrire une fonction supprimer_caractere(chaine, c) qui retourne une nouvelle chaîne sans aucune occurrence de c.
Boucles

Exercice 15 — Doubler chaque caractère

Écrire une fonction doubler_caracteres(chaine) qui retourne une chaîne où chaque caractère de chaine est répété deux fois (ex: "abc" → "aabbcc").
Boucles

Exercice 16 — Alterner majuscules/minuscules

Écrire une fonction alterner_casse(chaine) qui retourne une chaîne où les caractères d’indice pair sont en majuscule et ceux d’indice impair en minuscule. Utiliser une boucle sur les indices.
Boucles

Exercice 17 — Miroir des mots

Écrire une fonction miroir_mots(phrase) qui retourne une nouvelle phrase où chaque mot est inversé caractère par caractère, en conservant les espaces (ex: "bonjour monde" → "ruojnob ednom").
Boucles

Exercice 18 — Compter lettres et chiffres

Écrire une fonction compter_lettres_chiffres(chaine) qui retourne un tuple (nb_lettres, nb_chiffres) en parcourant la chaîne et en classant chaque caractère.
Boucles

Exercice 19 — Palindrome (sans slicing)

Écrire une fonction est_palindrome(chaine) qui retourne True si chaine est un palindrome en utilisant une boucle (sans [::-1] ni reversed()).