Self-assessment quiz

# Pourquoi l’utilisation des fonctions est-elle si importante ? - [ ] Cela rend votre code plus rapide à exécuter > ❌ Bien que les fonctions apportent de la structure, elles ne rendent pas nécessairement le code plus rapide. La performance dépend de l’implémentation et du contexte. - [x] Cela rend votre code plus réutilisable > ✅ Les fonctions permettent de réutiliser du code dans différentes parties d’un programme ou même dans différents projets. - [x] Cela rend votre code plus facile à lire > ✅ Les fonctions découpent un code complexe en sections plus petites et gérables, améliorant ainsi la lisibilité. - [x] Cela rend votre code plus facile à tester > ✅ Tester des fonctions petites et isolées est plus simple que de tester de gros blocs de code avec de nombreuses dépendances. # Qu’est-ce qui est vrai ? - [ ] Une fonction Python retourne toujours une valeur > ❌ Une fonction ne retourne pas toujours une valeur. S’il n’y a pas d’instruction return, elle retourne `None` par défaut. - [x] Une fonction Python peut retourner plusieurs valeurs > ✅ Les fonctions Python peuvent retourner plusieurs valeurs, souvent sous forme de tuples. - [ ] Python exécute une fonction dès que le mot-clé `def` est rencontré > ❌ La fonction n’est exécutée que lorsqu’elle est appelée, pas lorsqu’elle est définie avec le mot-clé `def`. - [x] Une fonction peut être passée en argument d’une autre fonction > ✅ Python permet de passer des fonctions en argument à d’autres fonctions, ce qui facilite la programmation fonctionnelle. # Quelle(s) appel(s) est/sont correct(s) compte tenu du prototype de fonction suivant ? ```python def random_values (nb_points: int, min_v: int = 0, max_v: int = 100) -> List[int]: """ Returns a list of n random integers between minv and maxv (inclusive). In: * nb_points: The number of values to generate. * min_v: The minimum value for the random integers. * max_v: The maximum value for the random integers. Out: * A list of n random integers between min_v and max_v (inclusive). """ ``` - [ ] `l = random_values(5, 0, 100) -> a` > ❌ Cette syntaxe est invalide car `-> a` n’est pas une notation valide pour appeler une fonction en Python. - [x] `l = random_values(5, 0, 100)` > ✅ C’est un appel de fonction valide, spécifiant les trois arguments. - [x] `l = random_values(5)` > ✅ Comme `min_v` et `max_v` ont des valeurs par défaut, appeler la fonction avec seulement `nb_points` est valide. - [x] `l = random_values(5, 10)` > ✅ Cet appel remplace `min_v` par `10`, tandis que `max_v` utilise sa valeur par défaut `100`. - [x] `l = random_values(max_v=100, min_v=10, nb_points=5)` > ✅ Cet appel utilise des arguments nommés dans un ordre différent, ce qui est valide en Python. - [x] `l = random_values(nb_points=5, min_v=10, max_v=100)` > ✅ C’est un autre appel valide utilisant des arguments nommés dans l’ordre. - [ ] `l = random_values()` > ❌ L’argument `nb_points` est obligatoire, donc cet appel génèrerait une erreur. - [ ] `l = random_values('100', '0', '100')` > ❌ Les arguments doivent être des entiers, pas des chaînes de caractères. - [ ] `l = random_values[5, 0, 100]` > ❌ Cette syntaxe utilise des crochets, ce qui n’est pas correct pour appeler une fonction. # Quel est le résultat du code suivant ? ```python # Define a function def func (*args): s = "" for i in args: s += str(i) + "-" print(s) # Call it func('a', 3, 0.3) ``` 1. [x] `a-3-0.3-` > ✅ La fonction concatène les représentations en chaîne des arguments, séparées par des tirets. 1. [ ] `0.3-` > ❌ La fonction traite tous les arguments, pas seulement le dernier. 1. [ ] Une erreur est retournée à cause d’un décalage d’arguments > ❌ La fonction accepte un nombre variable d’arguments (*args), donc il n’y a pas de problème de correspondance.

# Quel est le principal avantage d’organiser le code en modules ? - [x] Réutilisabilité du code > ✅ Les modules permettent de réutiliser le code dans plusieurs projets, réduisant ainsi la duplication. - [ ] Augmentation de la vitesse d’exécution du programme > ❌ Les modules n’améliorent pas nécessairement la vitesse d’exécution d’un programme. - [x] Gestion et maintenance plus faciles du code > ✅ Découper le code en modules facilite sa maintenance et sa gestion. - [x] Meilleure structure et cohérence > ✅ Les modules aident à structurer le code de manière logique, améliorant la cohérence globale. - [ ] Réduction de l’utilisation mémoire > ❌ L’organisation en modules n’affecte pas directement l’utilisation mémoire. # Comment empêcher certaines parties du code d’être exécutées lors de l’import d’un fichier comme module ? - [ ] Utiliser le mot-clé `import` > ❌ Le mot-clé `import` sert à importer des modules, pas à empêcher l’exécution de code. - [ ] Utiliser une déclaration `global` pour les variables > ❌ `global` contrôle la portée des variables, pas l’exécution du code lors de l’import. - [x] Utiliser la construction `if __name__ == "__main__":` > ✅ Cette construction garantit que le code n’est exécuté que lorsque le fichier est lancé directement, pas lorsqu’il est importé. - [x] Inclure les cas de test uniquement dans le script principal > ✅ En incluant les tests dans le script principal, ils ne sont pas exécutés lors de l’import du fichier. - [ ] Utiliser une instruction `def` pour encapsuler tout le code > ❌ Encapsuler le code dans une fonction ne l’empêche pas d’être exécuté lors de l’import. # Quelle variable Python contient la liste des répertoires où Python cherche les modules ? 1. [ ] `os.path` > ❌ `os.path` gère les opérations sur les chemins de fichiers, pas les chemins de recherche des modules. 1. [x] `sys.path` > ✅ `sys.path` contient la liste des répertoires où Python recherche les modules. 1. [ ] `__file__` > ❌ `__file__` contient le chemin du script en cours d’exécution, pas la liste des chemins de recherche des modules. 1. [ ] `PYTHONPATH` > ❌ Bien que `PYTHONPATH` puisse influencer les chemins de recherche, la variable Python correcte est `sys.path`. 1. [ ] `dir()` > ❌ `dir()` sert à lister les attributs d’objets, pas à gérer les chemins de recherche des modules. # Pourquoi est-il important de diviser de gros codes en plusieurs fichiers (modules) ? - [x] Cela permet une meilleure organisation et séparation des préoccupations > ✅ Organiser le code en modules sépare les fonctionnalités, rendant la base de code plus facile à gérer. - [x] Cela améliore la maintenabilité et la réutilisabilité du code > ✅ Le code modulaire est plus facile à maintenir et à réutiliser dans différents projets. - [ ] Cela réduit la taille de chaque fonction > ❌ Diviser le code en modules n’affecte pas directement la taille des fonctions individuelles. - [x] Cela facilite le test des composants individuels > ✅ Les modules permettent des tests plus ciblés et isolés des composants individuels. - [ ] Cela élimine le besoin de l’instruction `import` > ❌ L’instruction `import` est toujours nécessaire pour utiliser les modules, même dans une base de code modulaire. # Quelles sont les bonnes pratiques pour organiser le code en bibliothèques ? - [x] Regrouper les fonctions liées dans des fichiers séparés selon les thèmes > ✅ Regrouper les fonctions liées dans des fichiers selon leur thème améliore l’organisation. - [ ] Éviter de diviser le code en plusieurs fichiers pour simplifier > ❌ Diviser le code en plusieurs fichiers améliore la maintenabilité et l’organisation. - [x] Utiliser des noms de fichiers significatifs pour éviter les conflits avec les bibliothèques standard de Python > ✅ Utiliser des noms descriptifs et uniques évite les conflits avec les noms des bibliothèques standard. - [ ] Toujours inclure tout le code dans un seul fichier principal > ❌ Inclure tout le code dans un seul fichier conduit à un code encombré et difficile à maintenir. - [x] Utiliser la documentation et les commentaires pour expliquer le but de chaque module > ✅ Une bonne documentation et des commentaires aident à expliquer le but et l’utilisation de chaque module.

# À quoi sert `pip` en Python ? - [x] Installer des packages et modules externes > ✅ `pip` est l’installateur standard de packages Python, utilisé pour installer des packages externes. - [ ] Exécuter des scripts Python > ❌ `pip` ne sert pas à exécuter des scripts Python, mais à gérer les packages. - [x] Gérer les dépendances des packages Python > ✅ `pip` gère l’installation des dépendances des packages Python. - [ ] Compiler des programmes Python > ❌ `pip` ne compile pas les programmes Python ; il installe des packages. - [x] Installer des bibliothèques depuis le Python Package Index (PyPI) > ✅ `pip` installe des bibliothèques depuis PyPI, le dépôt officiel des packages Python. # Qu’est-ce qu’un package Python ? - [x] Une collection de modules > ✅ Un package Python est une collection de modules organisés ensemble. - [ ] Un script Python unique > ❌ Un script Python unique n’est pas un package, c’est simplement un module. - [x] Un répertoire contenant plusieurs modules liés > ✅ Un package est un répertoire contenant plusieurs modules liés, souvent avec un fichier `__init__.py`. - [ ] Un fichier téléchargé depuis le web > ❌ Bien que les packages puissent être téléchargés depuis le web, cela ne définit pas un package Python. - [x] Un package qui permet d’utiliser des noms de modules en notation pointée > ✅ Les packages Python supportent les noms de modules en notation pointée, aidant à organiser les modules dans des espaces de noms. # Que fait la commande `pip3 install numpy` ? - [x] Installe le package NumPy pour Python 3 > ✅ Cette commande installe NumPy pour Python 3. - [ ] Met à jour une version existante de NumPy > ❌ La commande `install` installe un package, mais ne le met pas nécessairement à jour. - [ ] Installe NumPy uniquement pour Python 2 > ❌ `pip3` est destiné à Python 3, pas à Python 2. - [x] Récupère le package depuis PyPI et l’installe > ✅ `pip` récupère le package NumPy depuis PyPI et l’installe. - [ ] Désinstalle NumPy de votre système > ❌ La commande sert à installer, pas à désinstaller. # Quelle commande utiliseriez-vous pour mettre à jour un package déjà installé ? - [ ] `pip install --version latest` > ❌ Il n’existe pas d’option `--version latest` pour mettre à jour un package. - [ ] `pip upgrade ` > ❌ `pip upgrade` n’est pas une commande valide pour mettre à jour des packages. - [x] `pip install --upgrade ` > ✅ Cette commande met à jour un package déjà installé. - [x] `pip3 install --upgrade ` > ✅ C’est la syntaxe correcte pour mettre à jour un package en Python 3. - [ ] `pip update ` > ❌ `pip update` n’est pas une commande valide pour mettre à jour des packages. # Pourquoi `pip` peut-il échouer à installer un package même si la commande est correcte ? - [x] Le package est installé pour la mauvaise version de Python > ✅ Si `pip` est associé à une autre version de Python, l’installation peut échouer. - [x] Le package n’existe pas dans le dépôt PyPI > ✅ Si le package n’est pas listé sur PyPI, `pip` ne pourra pas le trouver. - [ ] Le système a trop de modules installés > ❌ Le nombre de modules installés n’affecte pas la capacité à installer un nouveau package. - [x] L’exécutable Python utilisé est différent de celui associé à pip > ✅ Si `pip` est lié à un exécutable Python différent, l’installation peut échouer pour la version cible. - [ ] Python n’est pas installé sur le système > ❌ Si Python n’était pas installé, `pip` ne serait pas disponible.

# Quel est le résultat du code suivant ? ```python # Define a variable x = 30 # Define a function def my_func(): x = 20 print("D1:", x) # Call it my_func() print("D2:", x) ``` 1. [x] `D1: 20` et `D2: 30` > ✅ La variable `x` à l’intérieur de la fonction est locale à la fonction, elle n’affecte donc pas la variable globale `x`. D’où `D1: 20` et `D2: 30`. 1. [ ] `D1: 30` et `D2: 30` > ❌ La variable locale `x` dans la fonction n’affecte pas la variable globale, donc `D1` vaut `20`, pas `30`. 1. [ ] `D1: 20` et `D2: 20` > ❌ La variable locale `x` vaut `20`, mais elle ne modifie pas la variable globale `x`, qui reste `30` après l’appel. # Quelles sont les principales différences entre variables locales et globales ? - [x] Les variables locales ne sont visibles que dans la fonction où elles sont définies > ✅ Les variables locales sont limitées à la portée de la fonction où elles sont définies et ne peuvent pas être accédées en dehors. - [x] Les variables globales peuvent être accédées depuis n’importe où dans le programme > ✅ Les variables globales sont accessibles depuis n’importe quelle partie du programme, y compris à l’intérieur des fonctions (sauf si masquées par une variable locale). - [ ] Les variables locales existent pendant toute l’exécution du programme > ❌ Les variables locales existent uniquement pendant l’exécution de la fonction où elles sont définies, pas pendant toute la durée du programme. - [ ] Les variables globales sont supprimées après l’exécution de la fonction > ❌ Les variables globales persistent jusqu’à la fin du programme, contrairement aux variables locales qui sont limitées à la portée de la fonction. - [ ] Les variables locales deviennent automatiquement globales après avoir été utilisées dans une boucle > ❌ Les variables locales restent locales à leur fonction, même si elles sont utilisées dans une boucle à l’intérieur de celle-ci. # Que se passe-t-il si vous essayez d’accéder à une variable locale en dehors de sa fonction ? - [ ] Le programme affichera la valeur de la variable > ❌ Les variables locales ne peuvent pas être accédées en dehors de la fonction où elles sont définies, donc rien ne sera affiché. - [ ] La variable deviendra globale > ❌ Les variables locales ne deviennent pas automatiquement globales lorsqu’on y accède en dehors de leur portée. - [x] Une `NameError` se produira > ✅ Accéder à une variable locale en dehors de sa fonction génère une `NameError` car elle n’est pas définie dans la portée globale. - [x] L’interpréteur signalera que la variable n’est pas définie > ✅ Quand une variable locale est accédée hors de sa portée, l’interpréteur signale une erreur indiquant que la variable n’est pas définie. - [ ] La fonction sera appelée automatiquement > ❌ Les fonctions ne sont pas appelées automatiquement si vous essayez d’accéder à une variable locale hors de sa portée. # Que sera affiché si une variable locale et une variable globale ont le même nom dans une fonction ? - [x] La variable locale « masque » la variable globale > ✅ Si une variable locale porte le même nom qu’une variable globale, la variable locale masque la variable globale dans la portée de la fonction. - [ ] Les deux variables, globale et locale, seront affichées > ❌ Seule la variable locale sera affichée dans la fonction car elle masque la variable globale. - [ ] Une erreur d’exécution se produira > ❌ Aucune erreur ne se produit. La variable locale masque simplement la variable globale. - [ ] La variable globale écrasera la variable locale > ❌ La variable locale masque la variable globale dans la portée de la fonction, pas l’inverse. - [x] Seule la valeur de la variable locale sera affichée dans la fonction > ✅ La fonction affichera uniquement la valeur de la variable locale car elle prend le pas sur la variable globale dans la fonction.