Quiz d'auto-évaluation
Présentation & objectifs
Les quiz suivants sont là pour vous aider à vérifier que vous avez compris les articles que vous deviez étudier. À la fin d’un quiz, des explications vous seront données sur vos réponses. Si certaines réponses sont fausses, vous aurez la possibilité de cliquer sur la question pour réessayer.
Ces quiz sont proposés pour l’auto-évaluation et ne seront ni notés ni enregistrés.
N’hésitez pas à poser vos questions sur le serveur Discord pour toute précision ou explication !
Quizzes
Qu’est-ce qu’un programme ?
# Classez dans l'ordre les différentes phases par lesquelles passe l'interpréteur Python lorsqu'il interprète votre code.
1. Détecter les erreurs lexicales comme les problèmes d'encodage
> 💬 C'est la première phase où les erreurs lexicales, telles que les problèmes d'encodage ou les jetons invalides, sont identifiées.
2. Vérifier la structure syntaxique du code pour détecter les instructions mal formées
> 💬 Après l'analyse lexicale, Python vérifie si la syntaxe du code est correcte, détectant des erreurs comme les deux-points ou parenthèses manquants.
3. Compiler le code source Python en bytecode pour accélérer son exécution
> 💬 Une fois la syntaxe correcte, Python compile le code source en bytecode, qui peut être exécuté plus efficacement.
4. Charger et exécuter le code dans la machine virtuelle Python
> 💬 Enfin, le bytecode est exécuté par la machine virtuelle Python pour faire tourner le programme.
# Comment améliorer le code suivant pour le rendre plus compréhensible et plus facile à faire évoluer ?
```python
from typing import List
l : List[int] = [5, 4, 8, 9, 0, -5, 1, 3]
i : int = 1
j : int = 0
while i < len(l) - 1:
if l[i] < l[len(l) - 1]:
l[j] += l[i]
l[i] = l[j] - l[i]
l[j] = l[j] - l[i]
j += 1
i += 1
l[j] += l[len(l) - 1]
l[len(l) - 1] = l[j] - l[len(l) - 1]
l[j] = l[j] - l[len(l) - 1]
```
- [ ] Utiliser plus de parenthèses et crochets
> ❌ Ajouter plus de parenthèses ou de crochets n'améliorera pas nécessairement la lisibilité ou la maintenabilité du code.
- [x] Ajouter des commentaires
> ✅ Ajouter des commentaires est essentiel pour clarifier le but de chaque section pour d'autres développeur(se)s ou pour une relecture ultérieure.
- [x] Utiliser des noms de variables plus explicites
> ✅ Dupliquer du code rend la maintenance plus difficile. Il vaut mieux abstraire la logique répétée dans une fonction d'aide.
- [x] Éviter d'avoir à deux endroits (dans et après la boucle) trois lignes de code identiques
> ✅ Correct ! Dupliquer du code rend la maintenance plus difficile. Il vaut mieux abstraire la logique répétée dans une fonction d'aide.
- [ ] Regrouper les instructions sur une même ligne
> ❌ Incorrect ! Regrouper les instructions sur une même ligne réduit la lisibilité. Il vaut mieux les garder séparées pour plus de clarté.
- [ ] Ajouter un point-virgule à la fin de chaque ligne
> ❌ Incorrect ! Python ne nécessite pas de point-virgule à la fin de chaque ligne, et en ajouter serait inutile et non conventionnel.
# Qu'est-ce qu'un programme ?
- [ ] Une suite d'instructions aléatoires
> ❌ Un programme doit suivre une structure logique et ne pas consister en instructions aléatoires.
- [x] Une suite d'instructions qui réalisent un algorithme
> ✅ Un programme est une suite d'instructions bien définies qui implémentent un algorithme.
- [ ] Un ensemble de spécifications matérielles
> ❌ Cela concerne le matériel, pas un programme informatique.
- [x] Une traduction d'un algorithme dans un langage particulier
> ✅ Un programme est un algorithme exprimé dans un langage de programmation.
- [ ] Un ensemble de saisies utilisateur
> ❌ Bien que les programmes puissent prendre des entrées utilisateur, cela ne définit pas un programme.
# De quoi dépend la syntaxe d'un programme ?
- [ ] Les spécifications matérielles
> ❌ Le matériel ne définit pas la syntaxe d'un langage de programmation.
- [ ] Le système d'exploitation
> ❌ La syntaxe est indépendante du système d'exploitation et est définie par le langage lui-même.
- [x] Le langage de programmation
> ✅ La syntaxe est déterminée par les règles du langage de programmation utilisé.
- [x] Les spécificités du langage utilisé
> ✅ Chaque langage a des règles de syntaxe uniques qui doivent être respectées.
- [ ] La complexité de l'algorithme
> ❌ La complexité d'un algorithme n'affecte pas la syntaxe, même si elle peut influencer la structure du code.
# Quels facteurs sont importants pour choisir un langage de programmation pour un projet ?
- [x] Adaptation au projet
> ✅ Choisir un langage adapté aux besoins du projet est essentiel.
- [x] Performance
> ✅ Selon le projet, la performance peut être un critère clé dans le choix du langage.
- [ ] Le classement du langage sur un site web spécifique
> ❌ Le classement en popularité ne reflète pas forcément la pertinence d'un langage pour un projet donné.
- [x] Disponibilité des bibliothèques
> ✅ La disponibilité de bibliothèques peut grandement améliorer la productivité et l'efficacité du code.
- [ ] Choix aléatoire
> ❌ Choisir un langage au hasard ne garantit pas qu'il réponde aux besoins du projet.
Bonnes pratiques de programmation
# Quels sont les éléments clés pour écrire un programme lisible ?
- [x] Une indentation correcte
> ✅ L'indentation est cruciale pour structurer le code de manière lisible, surtout en Python.
- [x] Des noms de variables explicites
> ✅ Des noms de variables clairs et descriptifs aident les autres à comprendre plus facilement le code.
- [ ] Utilisation excessive de variables globales
> ❌ Les variables globales doivent être utilisées avec parcimonie pour éviter la complexité et les problèmes de maintenance.
- [x] Des commentaires appropriés
> ✅ Les commentaires aident à expliquer les parties complexes du code et à clarifier les détails d'implémentation.
- [ ] Ignorer les règles de syntaxe du langage de programmation
> ❌ Les règles de syntaxe doivent toujours être respectées pour garantir le bon fonctionnement du code.
# Que faut-il éviter lors du choix des noms de variables ?
- [ ] Utiliser des noms explicites
> ❌ Des noms explicites sont essentiels pour la clarté et la maintenabilité.
- [x] Des noms comme `x1`, `x2`, `papa`, `maman`
> ✅ Évitez d'utiliser des noms non descriptifs ou ambigus qui ne reflètent pas le rôle de la variable.
- [ ] Suivre les conventions de nommage
> ❌ Il est recommandé de suivre les conventions de nommage pour la cohérence et la lisibilité.
- [ ] Utiliser le snake_case en Python
> ❌ Le snake_case est la convention recommandée pour les variables et fonctions en Python.
- [x] Des noms non descriptifs comme `a` ou `prog1`
> ✅ Évitez d'utiliser des lettres seules ou des noms vagues qui n'indiquent pas le rôle de la variable.
# Pourquoi est-il important d'éviter les valeurs codées en dur dans un programme ?
- [x] Cela rend le code plus difficile à mettre à jour
> ✅ Les valeurs codées en dur compliquent les modifications futures, car il faudrait les changer à plusieurs endroits.
- [x] Utiliser des variables ou des constantes rend le code plus flexible
> ✅ Remplacer les valeurs codées en dur par des variables ou des constantes facilite la modification et la maintenance du code.
- [ ] Cela affecte la vitesse d'exécution du programme
> ❌ Les valeurs codées en dur n'ont généralement pas d'impact direct sur la vitesse d'exécution.
- [ ] Les valeurs codées en dur augmentent la lisibilité
> ❌ Les valeurs codées en dur rendent souvent le code plus difficile à comprendre, surtout dans de grands programmes.
- [x] Les variables permettent de modifier le code plus facilement
> ✅ Les variables et constantes facilitent la mise à jour des valeurs dans tout le programme, réduisant le risque d'erreurs.
Évaluer la qualité d’un code Python
# À quoi sert le typage en Python (type hinting), notamment pour les prototypes de fonctions ?
- [x] Améliorer la lisibilité du code
> ✅ Le typage rend explicite le type de données attendu, ce qui améliore la lisibilité et réduit les erreurs.
- [ ] Optimiser les performances du programme
> ❌ Le typage n'a pas d'effet direct sur les performances.
- [x] Indiquer explicitement le type des variables
> ✅ Le typage rend explicite le type des variables et fonctions, ce qui facilite la compréhension et le débogage.
- [ ] Remplacer les annotations de type en Java
> ❌ Le typage en Python est différent du système de types statiques de Java et ne le remplace pas.
- [x] Aider les IDE à prévenir les erreurs
> ✅ Le typage aide les IDE et les analyseurs à détecter les erreurs potentielles avant l'exécution du programme.
# Lequel des langages suivants est typé dynamiquement ?
1. [x] Python
> ✅ Python est un langage typé dynamiquement, où le type des variables est déterminé à l'exécution.
1. [ ] Java
> ❌ Java est un langage typé statiquement, où le type des variables est vérifié à la compilation.
1. [ ] C++
> ❌ C++ est aussi typé statiquement.
1. [ ] C#
> ❌ C# est un langage typé statiquement.
1. [ ] Go
> ❌ Go est également typé statiquement.
Les erreurs de programmation
# Quels sont les principaux types d'erreurs de programmation ?
- [x] Erreurs de syntaxe
> ✅ Les erreurs de syntaxe surviennent lorsque le code ne respecte pas la grammaire du langage de programmation.
- [x] Erreurs d'exécution
> ✅ Les erreurs d'exécution surviennent lorsque le programme rencontre un problème lors de l'exécution, comme une division par zéro.
- [ ] Erreurs logiques
> ❌ Les erreurs logiques sont des erreurs dans l'algorithme du programme, mais ne constituent pas une catégorie formelle comme les erreurs de syntaxe ou d'exécution.
- [ ] Erreurs de compilation
> ❌ Python ne possède pas de phase de compilation séparée ; c'est un langage interprété.
- [ ] Erreurs de typage
> ❌ Les erreurs de type relèvent des erreurs d'exécution ou logiques, selon le moment où elles se produisent.
# Qu'est-ce qui provoque une erreur de syntaxe dans un programme Python ?
- [x] Une structure de code incorrecte qui viole les règles de syntaxe de Python
> ✅ Les erreurs de syntaxe surviennent lorsque la structure du code ne respecte pas les règles de syntaxe de Python.
- [x] Utiliser des noms de variables invalides
> ✅ Python impose des règles sur les noms de variables valides, et les enfreindre provoque une erreur de syntaxe.
- [x] Des symboles ou jetons mal placés dans le code
> ✅ Une utilisation incorrecte des jetons (comme des parenthèses ou virgules manquantes) peut entraîner des erreurs de syntaxe.
- [ ] Utiliser des types de données invalides lors de l'exécution
> ❌ Cela provoquerait une erreur d'exécution, pas une erreur de syntaxe.
- [ ] Accéder à une mémoire non disponible
> ❌ Cela provoquerait une erreur d'exécution, sans rapport avec la syntaxe.
# Qu'est-ce qui peut provoquer des erreurs d'exécution dans un programme Python ?
- [x] Division par zéro
> ✅ Diviser par zéro provoque une erreur d'exécution car c'est une opération invalide en Python.
- [x] Opérations non autorisées sur des variables
> ✅ Effectuer des opérations non autorisées sur des variables peut entraîner des erreurs d'exécution.
- [x] Accès à un fichier non disponible
> ✅ Tenter d'ouvrir un fichier qui n'existe pas provoquera une erreur d'exécution.
- [ ] Indentation incorrecte
> ❌ Une indentation incorrecte provoquerait une erreur de syntaxe, pas une erreur d'exécution.
- [ ] Noms de variables mal orthographiés
> ❌ Incorrect ! Cela provoquerait une NameError à l'exécution mais n'est pas catégorisé comme une erreur d'exécution.
# Pourquoi les nombres aléatoires compliquent-ils le débogage d'un programme ?
- [x] Le résultat du programme peut varier à chaque exécution
> ✅ Les nombres aléatoires entraînent des résultats différents, ce qui rend plus difficile la reproduction des erreurs.
- [ ] Les nombres aléatoires génèrent toujours des erreurs d'exécution
> ❌ Les nombres aléatoires ne provoquent pas d'erreurs en soi, mais peuvent entraîner une variabilité des résultats.
- [x] Certaines exécutions peuvent fonctionner alors que d'autres échouent de façon inattendue
> ✅ Cette incohérence explique pourquoi les nombres aléatoires compliquent le débogage.
- [ ] Les nombres aléatoires sont imprévisibles et causent de l'instabilité
> ❌ Les nombres aléatoires sont imprévisibles par nature mais ne causent pas forcément de l'instabilité.
- [x] Déboguer un programme avec des éléments aléatoires peut être incohérent
> ✅ Comme le résultat varie à chaque exécution, le débogage peut devenir incohérent et peu fiable.
# Que peut-on faire pour garantir la cohérence du débogage lorsqu'il y a des nombres aléatoires ?
- [x] Fixer une graine (seed) pour le générateur de nombres aléatoires
> ✅ Fixer une graine permet au générateur de produire la même séquence à chaque fois.
- [x] Utiliser une série déterministe de nombres initialisée avec une graine
> ✅ Cela garantit la cohérence du comportement du programme pour le débogage.
- [ ] Éviter complètement d'utiliser des nombres aléatoires
> ❌ Les nombres aléatoires sont souvent nécessaires, mais fixer une graine permet de gérer leur imprévisibilité.
- [ ] S'assurer que toutes les valeurs sont prédéfinies
> ❌ Des valeurs prédéfinies évitent l'aléatoire, mais utiliser une graine permet la reproductibilité sans perdre l'aléa.
- [x] Identifier la graine qui provoque des erreurs et déboguer en conséquence
> ✅ Connaître la graine permet de reproduire l'erreur et de la corriger efficacement.
# Lesquels des exemples suivants sont des erreurs de syntaxe ?
- [x] Oublier les deux-points dans une boucle `for`
> ✅ Oublier les deux-points est une erreur de syntaxe car cela viole les règles de Python pour les boucles.
- [x] Des symboles invalides comme `for i j in range()`
> ✅ Cette syntaxe est invalide car il manque des éléments nécessaires comme une virgule entre les variables.
- [ ] Division par zéro dans le code
> ❌ La division par zéro provoque une erreur d'exécution, pas une erreur de syntaxe.
- [ ] Accès à un fichier qui n'existe pas
> ❌ Cela provoquerait une erreur d'exécution plutôt qu'une erreur de syntaxe.
- [x] Parenthèses non appariées dans les appels de fonction
> ✅ Des parenthèses non appariées sont une erreur de syntaxe car elles empêchent l'analyse correcte de l'appel de fonction.
# Quelle est la bonne pratique à adopter avec les nombres aléatoires dans un programme ?
- [x] Fixer une graine spécifique pour garantir la reproductibilité lors du débogage
> ✅ Fixer une graine permet de répéter la génération de nombres aléatoires de façon cohérente.
- [ ] Toujours éviter d'utiliser des nombres aléatoires dans les calculs importants
> ❌ Les nombres aléatoires peuvent être essentiels dans certains calculs, mais il faut bien les gérer (ex : fixer la graine).
- [x] Utiliser une graine connue pour garantir que toutes les exécutions donnent le même résultat
> ✅ Une graine connue garantit la reproductibilité pour les tests et le débogage.
- [ ] Utiliser plusieurs générateurs de nombres aléatoires sans fixer leur graine
> ❌ Cela entraînerait un comportement non reproductible, rendant le débogage difficile.
- [x] Évaluer la performance des algorithmes aléatoires en moyennant les résultats sur plusieurs exécutions
> ✅ Les algorithmes aléatoires doivent être évalués sur plusieurs exécutions pour obtenir une performance moyenne.