Obtenir un certificat — 16,67 $5 $
PCEP Certified Entry-Level Python Programmer (PCEP-30-03) : préparation à l’examen
Préparez l’examen PCEP-30-03 : lire et dérouler du code Python, prévoir l’affichage, manipuler collections, fonctions, exceptions, fichiers et modules math et random.
Ce que vous allez apprendre
- Décrire l’examen PCEP-30-03 et expliquer comment le code Python est structuré, interprété et nommé (mots-clés, indentation, littéraux, variables)
- Évaluer des expressions avec opérateurs arithmétiques, de chaînes, relationnels et booléens, et utiliser print(), input() et les conversions de type
- Dérouler des blocs conditionnels et des boucles while/for, y compris range(), boucles imbriquées, break, continue et pass
- Créer, indexer, découper, copier et modifier listes, tuples et ensembles, y compris les listes imbriquées
- Manipuler dictionnaires et chaînes, avec les méthodes de chaînes et les formatages f-string, format() et %
- Définir et appeler des fonctions avec tous les types d’arguments, prévoir la portée des variables et gérer les exceptions avec try/except
- Lire, écrire et compléter des fichiers texte et CSV, et importer des modules pour utiliser les fonctions de math et random
Modules
- L’examen PCEP et les fondamentaux de Python
- Opérateurs, expressions et entrées-sorties console
- Flux de contrôle : conditions et boucles
- Listes, tuples et ensembles
- Dictionnaires, chaînes et formatage
- Fonctions, portée et exceptions
- Fichiers et import de modules
Fiche de la formation
- Niveau
- Préparation à l’examen
- Durée d’étude estimée
- environ 2 heures
- Évaluation finale
- 42 questions · Seuil de réussite 70%
- Disponible en
- English, Français, العربية
- Prix
- Gratuit. Certificat vérifiable en option : 5 $
- Dernière mise à jour
- Publié par
- AMAADOR ACADEMY
À qui s’adresse cette formation
Étudiants, personnes en reconversion, débutants en data et en informatique, et professionnels qui visent une première certification Python et veulent s’entraîner avant de réserver l’examen PCEP.
Prérequis
Aucune certification préalable. Avoir déjà écrit quelques petits programmes Python ; disposer de Python 3 sur un ordinateur aide à tester les exemples.
Contenu de la formation
1. L’examen PCEP et les fondamentaux de Python
Le PCEP (Certified Entry-Level Python Programmer) est la première certification du Python Institute, géré par OpenEDG. En novembre 2026, la page PCEP et la page du programme du Python Institute décrivent la version en vigueur PCEP-30-03 (blueprint version 1.5, révisé le 2 novembre 2026). Cette formation enseigne uniquement cette version.
| Élément | PCEP-30-03 (page officielle du programme) |
|---|---|
| Questions | 35 |
| Durée | 50 minutes |
| Seuil de réussite | 70 % |
| Types d’items | Choix unique, choix multiple, interactifs et mises en situation |
| Section | Questions | Poids |
|---|---|---|
| 1. Programmation et fondamentaux de Python | 6 | 17 % |
| 2. Flux de contrôle : conditions et boucles | 8 | 23 % |
| 3. Collections : listes, tuples, ensembles, dictionnaires, chaînes | 9 | 26 % |
| 4. Fonctions et exceptions | 7 | 20 % |
| 5. Fichiers et import de modules | 5 | 14 % |
Source : pythoninstitute.org/pcep et pythoninstitute.org/pcep-exam-syllabus, consultées le 18 novembre 2026. La page PCEP-30-02 du Python Institute (pythoninstitute.org/pcep-30-02) indique que le PCEP-30-03 est sorti le 31 octobre 2026 et que le PCEP-30-02 reste disponible jusqu’à sa date de retrait, le 30 novembre 2027. Le prix et les langues d’examen n’y figurent pas : vérifiez-les dans la boutique OpenEDG au moment de réserver.
2. Opérateurs, expressions et entrées-sorties console
La plupart des questions de la section 1 demandent d’évaluer une expression exactement. Apprenez ces résultats par cœur.
| Expression | Résultat | Pourquoi |
|---|---|---|
| 7 / 2 | 3.5 | / renvoie toujours un float |
| 6 / 2 | 3.0 | toujours un float |
| 7 // 2 | 3 | division entière (plancher) |
| -7 // 2 | -4 | arrondi vers moins l’infini |
| 7 % 3 | 1 | reste |
| -7 % 3 | 2 | le résultat prend le signe du diviseur |
| 7.0 // 2 | 3.0 | un opérande float donne un float |
| 2 ** 3 ** 2 | 512 | ** s’évalue de droite à gauche : 3 ** 2 d’abord |
| -2 ** 2 | -4 | ** est prioritaire sur le moins unaire |
| 'ab' * 3 | 'ababab' | répétition de chaîne |
| '4' + '2' | '42' | concaténation |
- ** (de droite à gauche)
- + et - unaires
- * / // % (de gauche à droite)
- + -
- comparaisons == != > >= < <=
- not, puis and, puis or
Les opérateurs d’affectation composée (+=, -=, *=, /=, //=, %=, **=) mettent à jour une variable : après x = 5 puis x //= 2, x vaut 2.
3. Flux de contrôle : conditions et boucles
Un bloc if ne s’exécute que si sa condition est vraie. elif ajoute d’autres conditions et else attrape tout le reste. Dans une chaîne if-elif-else, Python teste les conditions de haut en bas et n’exécute que la première branche vérifiée ; les autres sont ignorées.
score = 85
if score >= 50:
print('admis')
elif score >= 80:
print('mention')
else:
print('ajourné')
Ce code affiche seulement admis. La branche elif est inatteignable pour tout score de 80 ou plus, car la première condition l’a déjà capté. Il faut tester d’abord la condition la plus précise (>= 80, puis >= 50).
| Situation | Ce qui se passe |
|---|---|
| Plusieurs if indépendants | Chacun est testé ; plusieurs peuvent s’exécuter |
| Une chaîne if-elif-elif | Au plus une branche s’exécute |
| Chaîne avec else | Exactement une branche s’exécute |
| Condition égale à 0, '', [], None | Considérée comme False |
Les conditions composées combinent des tests avec and, or, not. L’ordre : not d’abord, puis and, puis or. Donc a or b and c signifie a or (b and c). Les conditions imbriquées placent un if dans un autre ; l’if intérieur n’est testé que si l’extérieur est vrai.
4. Listes, tuples et ensembles
Une liste est une collection ordonnée et modifiable : nums = [10, 20, 30, 40, 50]. Les index commencent à 0 ; les index négatifs comptent depuis la fin.
| Expression | Résultat |
|---|---|
| nums[0], nums[-1] | 10, 50 |
| nums[1:3] | [20, 30] (fin exclue) |
| nums[:2], nums[3:] | [10, 20], [40, 50] |
| nums[::2] | [10, 30, 50] |
| nums[::-1] | [50, 40, 30, 20, 10] |
| nums[2:99] | [30, 40, 50] (une tranche ne lève jamais IndexError) |
| nums[5] | IndexError |
| len(nums), 30 in nums | 5, True |
Copie : b = nums ne copie rien ; les deux noms désignent la même liste, donc b.append(60) modifie aussi nums. Une vraie copie (superficielle) s’obtient avec nums[:], list(nums) ou nums.copy().
| Opération | Effet |
|---|---|
| append(x) | ajoute x à la fin |
| insert(i, x) | insère x avant l’index i |
| index(x) | position du premier x ; ValueError s’il est absent |
| remove(x) | supprime le premier x ; ValueError s’il est absent |
| del nums[i], del nums[1:3] | supprime par position ou par tranche |
| sorted(nums) | renvoie une nouvelle liste triée ; nums ne change pas |
| nums.sort() | trie sur place et renvoie None |
À retenir : x = nums.sort() donne x égal à None. Les méthodes qui modifient la liste sur place (append, insert, remove, sort) renvoient None.
5. Dictionnaires, chaînes et formatage
Un dictionnaire associe des clés uniques à des valeurs : stock = {'stylos': 40, 'classeurs': 12}. Depuis Python 3.7, il conserve l’ordre d’insertion des clés. Les clés doivent être non modifiables (str, int, tuple) ; les valeurs peuvent être de tout type.
| Code | Résultat |
|---|---|
| stock['stylos'] | 40 |
| stock['encre'] | KeyError |
| stock.get('encre') | None, sans erreur |
| stock.get('encre', 0) | 0 (la valeur par défaut fournie) |
| stock['encre'] = 5 | ajoute une clé |
| stock['stylos'] = 35 | met à jour une clé existante |
| del stock['classeurs'] | supprime la clé ; KeyError si absente |
| stock.pop('stylos') | supprime la clé et renvoie sa valeur |
| 'stylos' in stock | teste les clés, pas les valeurs |
| {'a': 1, 'a': 2} | {'a': 2} : le dernier doublon l’emporte |
Vues : keys(), values() et items() renvoient des vues que l’on peut parcourir. items() produit des tuples (clé, valeur), que l’on peut déballer :
for nom, qte in stock.items():
print(nom, qte)
Une simple boucle for k in stock parcourt les clés. len(stock) compte les paires clé-valeur. Les valeurs peuvent être des listes ou d’autres dictionnaires : on rencontre alors des accès imbriqués comme equipe['ops']['chef'].
6. Fonctions, portée et exceptions
Une fonction se définit avec def, un nom, des paramètres entre parenthèses et deux-points. Son corps est indenté. La fonction doit être définie avant que la ligne qui l’appelle ne s’exécute ; l’appeler plus tôt lève NameError.
def aire(l, h):
return l * h
print(aire(3, 4))
Ce code affiche 12. return termine immédiatement la fonction et renvoie une valeur à l’appelant. Toute ligne placée après return dans le même bloc ne s’exécute jamais.
| Corps de la fonction | Ce que reçoit l’appelant |
|---|---|
| return l * h | le produit |
| return (sans valeur) | None |
| aucun return | None |
| return a, b | un tuple (a, b), que l’on peut déballer : x, y = f() |
| seulement print(l * h) | la valeur s’affiche, mais l’appelant reçoit None |
À faire
- Utiliser return quand l’appelant a besoin de la valeur
- Appeler une fonction avec des parenthèses : aire(3, 4)
À éviter
- Confondre print() dans une fonction et return
- Oublier les parenthèses : print(aire) affiche l’objet fonction, pas un résultat
Piège classique : def f(): print('A'), puis x = f() et print(x). L’affichage est A sur la première ligne et None sur la seconde, car f affiche puis ne renvoie rien.
7. Fichiers et import de modules
La section 5 est nouvelle dans le PCEP-30-03. Elle commence par open(nom, mode), qui renvoie un objet fichier.
| Mode | Sens | Si le fichier n’existe pas | S’il existe |
|---|---|---|---|
| 'r' (défaut) | lecture | FileNotFoundError | lit depuis le début |
| 'w' | écriture | le crée | efface son contenu d’abord |
| 'a' | ajout | le crée | ajoute à la fin |
Préférez toujours l’instruction with : le fichier est fermé automatiquement à la fin du bloc, même en cas d’exception.
with open('journal.txt', 'a') as f:
f.write('contrôle OK\n')
| Appel | Renvoie |
|---|---|
| f.read() | tout le fichier en une chaîne |
| f.readline() | la ligne suivante, avec son '\n' ; '' en fin de fichier |
| f.readlines() | une liste de toutes les lignes |
| for ligne in f: | une ligne par passage, avec son '\n' |
| f.write(texte) | le nombre de caractères écrits ; aucun saut de ligne n’est ajouté |
À faire
- Utiliser ligne.strip() pour retirer le saut de ligne final
- Écrire str(valeur) pour les nombres : f.write(5) lève TypeError
À éviter
- Ouvrir un rapport existant en 'w' quand on voulait le compléter
- Lire un fichier après la fin du bloc with qui l’a fermé (ValueError)
La leçon complète se poursuit dans la formation interactive de cette page.
Sources et références
- PCEP – Certified Entry-Level Python Programmer (certification page)
- PCEP-30-03 exam syllabus, blueprint v1.5
- The Python Tutorial (official documentation)
- Built-in Exceptions
- csv — CSV File Reading and Writing
- math and random modules (standard library)
- PEP 8 – Style Guide for Python Code
Formation d’entraînement non officielle. Elle n’est ni affiliée au Python Institute ou à OpenEDG, ni approuvée ou parrainée par eux. PCEP est une marque de son propriétaire. Vérifiez le programme d’examen en vigueur sur le site du Python Institute avant de réserver.
Toutes les formations · Ingénierie & analyse de données — Formations gratuites, certificat à 5 $ | AMAADOR ACADEMY