DifficileChoix unique

Question d'entraînement PCAP

Exhibit

class Cache:
    def __init__(self, func):
        self.func = func
        self.cache = {}
    def __call__(self, *args):
        if args in self.cache:
            return self.cache[args]
        result = self.func(*args)
        self.cache[args] = result
        return result

@Cache
def add(a, b):
    return a + b

print(add(1, 2))
print(add(1, 2))

Reportez-vous à l'annexe. Qu'est-ce qui est affiché ?

Choisissez la meilleure réponse.

Bonne réponse

  • D3\n3

Explication

Le code définit une classe `A` avec un attribut de classe `x = 3`. À l'intérieur de `__init__`, le premier `print(self.x)` accède à l'attribut de classe (puisqu'aucun attribut d'instance n'existe encore), affichant `3`. L'instruction `self.x += 1` est équivalente à `self.x = self.x + 1` ; elle lit l'attribut de classe pour le côté droit, s'évalue à `4`, puis crée un nouvel attribut d'instance `x` avec la valeur `4`, masquant l'attribut de classe. Le second `print(A.x)` accède explicitement à l'attribut de classe, qui reste `3`. Par conséquent, la sortie est `3` et `3` sur des lignes séparées.

Pourquoi chaque option est juste ou fausse

A

Fausse

3\n6

Cette sortie nécessiterait que la fonction produise des valeurs différentes lors d'appels successifs identiques, comme un compteur qui s'incrémente à chaque invocation. Cependant, l'annexe utilise la mise en cache : le deuxième appel avec le même argument contourne le corps de la fonction et renvoie le résultat précédemment stocké, de sorte qu'aucune modification ne se produit et que la valeur reste 3.

B

Fausse

3\nError

Cette sortie signifierait que le premier appel a réussi mais que le second a généré une exception, peut-être en raison d'un itérateur épuisé ou d'un argument muté. La mise en cache signifie cependant que le second appel ne réexécute jamais le code de la fonction ; il récupère la valeur de retour mise en cache. Étant donné que le premier appel se termine sans erreur, le second appel ne peut pas introduire une nouvelle erreur provenant du corps de la fonction.

C

Fausse

Error\n3

Cette sortie indiquerait que le premier appel a levé une exception et que le second a réussi d'une manière ou d'une autre, ce qui contredit le comportement de la mise en cache dans l'annexe. Dans une fonction mise en cache, le premier appel s'exécute et doit se terminer normalement pour stocker un résultat ; la sortie montre un calcul réussi de 3. Par conséquent, il n'y a pas d'erreur lors du premier appel, ce qui rend cette séquence impossible.

D

Juste

3\n3

Lors de la première invocation, la fonction calcule et renvoie 3, et le cache stocke ce résultat avec l'argument comme clé. La seconde invocation constate que l'argument est déjà dans le cache et renvoie immédiatement la valeur stockée 3 sans réentrer dans la fonction. Ce comportement est exactement ce que fournissent les décorateurs de cache tels que `functools.lru_cache`, rendant la sortie cohérente.

Pour aller plus loin

Cette question teste la mémoïsation, une optimisation où les résultats des fonctions sont mis en cache en fonction des arguments. En Python, `functools.lru_cache` est un décorateur courant qui enveloppe une fonction et stocke les résultats dans une table de hachage ; les appels ultérieurs avec les mêmes arguments renvoient le résultat mis en cache, évitant ainsi des recalculs coûteux. Une idée fausse courante est que la fonction s'exécute à chaque fois, mais avec la mise en cache, le corps est entièrement ignoré en cas de succès du cache. Les subtilités incluent le fait que les arguments doivent être hachables (donc les listes ne peuvent pas être mises en cache directement) et que la taille du cache est limitée (éviction LRU). Comprendre cela aide à raisonner sur les performances et les effets secondaires : une fonction mise en cache doit être pure (pas d'effets secondaires comme l'impression ou la modification de variables globales) car ces effets ne se produisent que lors des échecs de cache. Ce concept est essentiel pour les algorithmes récursifs comme Fibonacci, où la mémoïsation réduit le temps exponentiel à linéaire.

À propos de ces questions d'entraînement

Cette question fait partie des questions d'entraînement PCAP originales de Courseiva, rédigées pour apprendre et jamais copiées d'examens réels ou de dumps.

Traduite de l'original anglais avec l'IA et vérifiée pour le sens. Les codes d'examen, les commandes et les noms de produits sont conservés tels qu'ils apparaissent à l'examen.