\documentclass[10pt,aspectratio=169]{beamer}

% --- Thème ---
\usetheme[language=french]{Celestia}

% Avec [allowframebreaks] sur les frames de questions, Beamer ajoute
% par défaut « (1) », « (2) », « (3) »... sur chaque sous-slide. On
% supprime entièrement cette annotation : un template vide pour
% « frametitle continuation ». L'enseignant identifie visuellement la
% continuation par le contenu de la slide. (Les variantes [from second]
% et [roman] interagissent mal avec un titre contenant \textemdash{}
% sous Celestia : elles déclenchent une erreur « Missing $ inserted ».)
\setbeamertemplate{frametitle continuation}{}

\subject{Numérique et sciences informatiques}
\title{Variables et types de base}
\subtitle{QCM}
\author{Première}
\date{\today}

\begin{document}

\begin{frame}
    \titlepage
\end{frame}

% Q1 - Réponse en A
\begin{frame}[fragile]{Question 1 \textemdash{} Affectation}
    Quelle est la signification de l'instruction
\texttt{x = 5} en Python ?\medskip
    \begin{itemize}
        \item[\alert<2>{A.}] \alert<2>{Affecter la valeur 5 à la variable \texttt{x}}
        \item[B.] Tester si \texttt{x} est égal à 5
        \item[C.] Définir une fonction \texttt{x} qui renvoie 5
        \item[D.] Multiplier \texttt{x} par 5
    \end{itemize}
\end{frame}

% Q2 - Réponse en A
\begin{frame}[fragile]{Question 2 \textemdash{} Type entier}
    Quel est le type de la valeur \texttt{42} en Python ?\medskip
    \begin{itemize}
        \item[\alert<2>{A.}] \alert<2>{\texttt{int}}
        \item[B.] \texttt{str}
        \item[C.] \texttt{bool}
        \item[D.] \texttt{float}
    \end{itemize}
\end{frame}

% Q3 - Réponse en C
\begin{frame}[fragile]{Question 3 \textemdash{} Type flottant}
    Que renvoie \texttt{type(3.14)} en Python ?\medskip
    \begin{itemize}
        \item[A.] \texttt{<class 'int'>}
        \item[B.] \texttt{<class 'decimal'>}
        \item[\alert<2>{C.}] \alert<2>{\texttt{<class 'float'>}}
        \item[D.] \texttt{<class 'str'>}
    \end{itemize}
\end{frame}

% Q4 - Réponse en A
\begin{frame}[fragile]{Question 4 \textemdash{} Type chaîne}
    Quel est le type de \texttt{"hello"} en Python ?\medskip
    \begin{itemize}
        \item[\alert<2>{A.}] \alert<2>{\texttt{str}}
        \item[B.] \texttt{int}
        \item[C.] \texttt{bool}
        \item[D.] \texttt{char}
    \end{itemize}
\end{frame}

% Q5 - Réponse en A
\begin{frame}[fragile]{Question 5 \textemdash{} Type booléen}
    Quelles sont les \textbf{deux seules} valeurs du type
\texttt{bool} en Python ?\medskip
    \begin{itemize}
        \item[\alert<2>{A.}] \alert<2>{\texttt{True} et \texttt{False}}
        \item[B.] \texttt{oui} et \texttt{non}
        \item[C.] \texttt{yes} et \texttt{no}
        \item[D.] \texttt{0} et \texttt{1}
    \end{itemize}
\end{frame}

% Q6 - Réponse en B
\begin{frame}[fragile]{Question 6 \textemdash{} Conversion en entier}
    Que renvoie \texttt{int("42")} ?\medskip
    \begin{itemize}
        \item[A.] La chaîne \texttt{"42"}
        \item[\alert<2>{B.}] \alert<2>{L'entier \texttt{42}}
        \item[C.] Une erreur
        \item[D.] Le flottant \texttt{42.0}
    \end{itemize}
\end{frame}

% Q7 - Réponse en D
\begin{frame}[fragile]{Question 7 \textemdash{} Opérateur de division}
    Que renvoie \texttt{7 / 2} en Python 3 ?\medskip
    \begin{itemize}
        \item[A.] 3
        \item[B.] Une erreur
        \item[C.] 4
        \item[\alert<2>{D.}] \alert<2>{3.5}
    \end{itemize}
\end{frame}

% Q8 - Réponse en D
\begin{frame}[fragile]{Question 8 \textemdash{} Division entière}
    Que renvoie \texttt{7 // 2} ?\medskip
    \begin{itemize}
        \item[A.] 0
        \item[B.] 4
        \item[C.] 3.5
        \item[\alert<2>{D.}] \alert<2>{3}
    \end{itemize}
\end{frame}

% Q9 - Réponse en A
\begin{frame}[fragile]{Question 9 \textemdash{} Modulo}
    Que renvoie \texttt{7 \% 2} ?\medskip
    \begin{itemize}
        \item[\alert<2>{A.}] \alert<2>{1}
        \item[B.] 3.5
        \item[C.] 0
        \item[D.] 3
    \end{itemize}
\end{frame}

% Q10 - Réponse en C
\begin{frame}[fragile]{Question 10 \textemdash{} Print}
    Que fait l'instruction \texttt{print("bonjour")} ?\medskip
    \begin{itemize}
        \item[A.] Définit une variable nommée \texttt{bonjour}
        \item[B.] Ne fait rien
        \item[\alert<2>{C.}] \alert<2>{Affiche \texttt{bonjour} dans la console}
        \item[D.] Imprime sur l'imprimante de l'ordinateur
    \end{itemize}
\end{frame}

% Q11 - Réponse en D
\begin{frame}[fragile,allowframebreaks]{Question 11 \textemdash{} Typage dynamique}
    \begin{lstlisting}
x = 5
x = "hello"
\end{lstlisting}
Cette suite d'instructions est-elle valide ?\medskip
    \begin{itemize}
        \item[A.] Non, il faut redéclarer \texttt{x}
        \item[B.] Oui, mais Python affiche un avertissement
        \item[C.] Non, \texttt{x} est figé en entier
        \item[D.] Oui, parce que Python est typé dynamiquement : une variable peut changer de type au cours du programme
    \end{itemize}
\end{frame}

% Q11 - Réponse en D
\begin{frame}[fragile,allowframebreaks]{Question 11 \textemdash{} Typage dynamique}
    \begin{lstlisting}
x = 5
x = "hello"
\end{lstlisting}
Cette suite d'instructions est-elle valide ?\medskip
    \begin{itemize}
        \item[A.] Non, il faut redéclarer \texttt{x}
        \item[B.] Oui, mais Python affiche un avertissement
        \item[C.] Non, \texttt{x} est figé en entier
        \item[\alert{D.}] \alert{Oui, parce que Python est typé dynamiquement : une variable peut changer de type au cours du programme}
    \end{itemize}
\end{frame}

% Q12 - Réponse en D
\begin{frame}[fragile]{Question 12 \textemdash{} Conversion qui plante}
    Que se passe-t-il avec \texttt{int("abc")} ?\medskip
    \begin{itemize}
        \item[A.] Renvoie \texttt{0}
        \item[B.] Renvoie \texttt{None}
        \item[C.] Renvoie \texttt{"abc"}
        \item[\alert<2>{D.}] \alert<2>{Lève \texttt{ValueError}}
    \end{itemize}
\end{frame}

% Q13 - Réponse en D
\begin{frame}[fragile]{Question 13 \textemdash{} Concaténation}
    Que renvoie \texttt{"abc" + "def"} ?\medskip
    \begin{itemize}
        \item[A.] \texttt{abc def}
        \item[B.] \texttt{9} (somme alphabétique)
        \item[C.] Une erreur
        \item[\alert<2>{D.}] \alert<2>{\texttt{abcdef}}
    \end{itemize}
\end{frame}

% Q14 - Réponse en A
\begin{frame}[fragile]{Question 14 \textemdash{} Répétition de chaîne}
    Que renvoie \texttt{"ab" * 3} ?\medskip
    \begin{itemize}
        \item[\alert<2>{A.}] \alert<2>{\texttt{ababab}}
        \item[B.] Une erreur
        \item[C.] \texttt{6} (longueur)
        \item[D.] \texttt{ab3}
    \end{itemize}
\end{frame}

% Q15 - Réponse en D
\begin{frame}[fragile]{Question 15 \textemdash{} Saisie utilisateur}
    Que renvoie \texttt{input("Âge ?")} après que
l'utilisateur a tapé \texttt{17} ?\medskip
    \begin{itemize}
        \item[A.] Le flottant \texttt{17.0}
        \item[B.] Le booléen \texttt{True}
        \item[C.] L'entier \texttt{17}
        \item[\alert<2>{D.}] \alert<2>{La chaîne \texttt{"17"}}
    \end{itemize}
\end{frame}

% Q16 - Réponse en D
\begin{frame}[fragile]{Question 16 \textemdash{} Comparaison}
    Que renvoie \texttt{2 < 3 < 5} en Python ?\medskip
    \begin{itemize}
        \item[A.] \texttt{False}
        \item[B.] \texttt{5}
        \item[C.] Une erreur de syntaxe
        \item[\alert<2>{D.}] \alert<2>{\texttt{True} (équivalent à \texttt{2 < 3 and 3 < 5})}
    \end{itemize}
\end{frame}

% Q17 - Réponse en C
\begin{frame}[fragile]{Question 17 \textemdash{} Conversion en booléen}
    Que renvoie \texttt{bool(0)} ?\medskip
    \begin{itemize}
        \item[A.] \texttt{True}
        \item[B.] \texttt{0}
        \item[\alert<2>{C.}] \alert<2>{\texttt{False}}
        \item[D.] Une erreur
    \end{itemize}
\end{frame}

% Q18 - Réponse en D
\begin{frame}[fragile]{Question 18 \textemdash{} Longueur de chaîne}
    Que renvoie \texttt{len("hello")} ?\medskip
    \begin{itemize}
        \item[A.] \texttt{hello}
        \item[B.] 1
        \item[C.] 5.0
        \item[\alert<2>{D.}] \alert<2>{5}
    \end{itemize}
\end{frame}

% Q19 - Réponse en C
\begin{frame}[fragile]{Question 19 \textemdash{} Conversion float → int}
    Que renvoie \texttt{int(3.9)} ?\medskip
    \begin{itemize}
        \item[A.] 4 (arrondi)
        \item[B.] Une erreur
        \item[\alert<2>{C.}] \alert<2>{3 (troncature vers 0)}
        \item[D.] 3.9
    \end{itemize}
\end{frame}

% Q20 - Réponse en A
\begin{frame}[fragile]{Question 20 \textemdash{} Indexation de chaîne}
    Que renvoie \texttt{"hello"[0]} ?\medskip
    \begin{itemize}
        \item[\alert<2>{A.}] \alert<2>{\texttt{h}}
        \item[B.] \texttt{e}
        \item[C.] Une erreur
        \item[D.] \texttt{hello}
    \end{itemize}
\end{frame}

% Q21 - Réponse en D
\begin{frame}[fragile]{Question 21 \textemdash{} Précision flottante}
    Que renvoie \texttt{0.1 + 0.2 == 0.3} ?\medskip
    \begin{itemize}
        \item[A.] \texttt{0.3}
        \item[B.] \texttt{True}
        \item[C.] Une erreur
        \item[\alert<2>{D.}] \alert<2>{\texttt{False}}
    \end{itemize}
\end{frame}

% Q22 - Réponse en B
\begin{frame}[fragile]{Question 22 \textemdash{} Opérateur puissance}
    Que vaut \texttt{2 ** 10} ?\medskip
    \begin{itemize}
        \item[A.] 100
        \item[\alert<2>{B.}] \alert<2>{1024 (= 2¹⁰)}
        \item[C.] Une erreur
        \item[D.] 20
    \end{itemize}
\end{frame}

% Q23 - Réponse en D
\begin{frame}[fragile,allowframebreaks]{Question 23 \textemdash{} Affectation simultanée}
    \begin{lstlisting}
a, b = 1, 2
a, b = b, a
\end{lstlisting}
Que valent \texttt{a} et \texttt{b} à la fin ?\medskip
    \begin{itemize}
        \item[A.] a = 2, b = 2
        \item[B.] Une erreur
        \item[C.] a = 1, b = 2 (inchangé)
        \item[D.] a = 2, b = 1 (échangés)
    \end{itemize}
\end{frame}

% Q23 - Réponse en D
\begin{frame}[fragile,allowframebreaks]{Question 23 \textemdash{} Affectation simultanée}
    \begin{lstlisting}
a, b = 1, 2
a, b = b, a
\end{lstlisting}
Que valent \texttt{a} et \texttt{b} à la fin ?\medskip
    \begin{itemize}
        \item[A.] a = 2, b = 2
        \item[B.] Une erreur
        \item[C.] a = 1, b = 2 (inchangé)
        \item[\alert{D.}] \alert{a = 2, b = 1 (échangés)}
    \end{itemize}
\end{frame}

% Q24 - Réponse en C
\begin{frame}[fragile]{Question 24 \textemdash{} Print avec virgule}
    Que renvoie \texttt{print("a", "b", "c")} ?\medskip
    \begin{itemize}
        \item[A.] Affiche \texttt{[a, b, c]}
        \item[B.] Affiche \texttt{abc}
        \item[\alert<2>{C.}] \alert<2>{Affiche \texttt{a b c} (espaces entre les arguments)}
        \item[D.] Lève une exception
    \end{itemize}
\end{frame}

% Q25 - Réponse en B
\begin{frame}[fragile]{Question 25 \textemdash{} Synthèse}
    Parmi les affirmations suivantes, laquelle est
\textbf{fausse} ?\medskip
    \begin{itemize}
        \item[A.] Python est typé dynamiquement
        \item[\alert<2>{B.}] \alert<2>{La chaîne vide \texttt{""} est considérée comme vraie dans une condition}
        \item[C.] \texttt{/} produit toujours un flottant en Python 3
        \item[D.] Les indices Python commencent à 0
    \end{itemize}
\end{frame}

% Q26 - Réponse en D
\begin{frame}[fragile]{Question 26 \textemdash{} Échanger deux variables en Python}
    Quelle est la façon la plus idiomatique d'échanger
les valeurs de deux variables \texttt{a} et \texttt{b} en Python ?\medskip
    \begin{itemize}
        \item[A.] \texttt{swap(a, b)}
        \item[B.] \texttt{a = b = a}
        \item[C.] \texttt{a = b} puis \texttt{b = a}
        \item[\alert<2>{D.}] \alert<2>{\texttt{a, b = b, a}}
    \end{itemize}
\end{frame}

% Q27 - Réponse en A
\begin{frame}[fragile,allowframebreaks]{Question 27 \textemdash{} Affichage formaté avec une f-string}
    On exécute le code suivant :

\begin{lstlisting}
prix = 12.5
quantite = 3
print(f"Total : {prix * quantite} €")
\end{lstlisting}

Que va afficher le programme ?\medskip
    \begin{itemize}
        \item[A.] \texttt{Total : 37.5 €}
        \item[B.] \texttt{Total : 12.5 * 3 €}
        \item[C.] \texttt{Total : \{prix * quantite\} €}
        \item[D.] Le code provoque une erreur de syntaxe
    \end{itemize}
\end{frame}

% Q27 - Réponse en A
\begin{frame}[fragile,allowframebreaks]{Question 27 \textemdash{} Affichage formaté avec une f-string}
    On exécute le code suivant :

\begin{lstlisting}
prix = 12.5
quantite = 3
print(f"Total : {prix * quantite} €")
\end{lstlisting}

Que va afficher le programme ?\medskip
    \begin{itemize}
        \item[\alert{A.}] \alert{\texttt{Total : 37.5 €}}
        \item[B.] \texttt{Total : 12.5 * 3 €}
        \item[C.] \texttt{Total : \{prix * quantite\} €}
        \item[D.] Le code provoque une erreur de syntaxe
    \end{itemize}
\end{frame}

% Q28 - Réponse en C
\begin{frame}[fragile]{Question 28 \textemdash{} Méthodes de chaîne}
    Que vaut l'expression \texttt{"NSI".lower()} en Python ?\medskip
    \begin{itemize}
        \item[A.] \texttt{'Nsi'}
        \item[B.] La méthode \texttt{lower} n'existe pas
        \item[\alert<2>{C.}] \alert<2>{\texttt{'nsi'}}
        \item[D.] \texttt{'NSI'}
    \end{itemize}
\end{frame}

% Q29 - Réponse en D
\begin{frame}[fragile]{Question 29 \textemdash{} Différence entre \texttt{==} et \texttt{is}}
    En Python, quelle est la différence entre les
opérateurs \texttt{==} et \texttt{is} ?\medskip
    \begin{itemize}
        \item[A.] \texttt{==} renvoie un nombre, \texttt{is} renvoie un booléen
        \item[B.] Les deux sont strictement équivalents
        \item[C.] \texttt{==} ne fonctionne que sur les nombres ; \texttt{is} ne fonctionne que sur les chaînes
        \item[\alert<2>{D.}] \alert<2>{\texttt{==} compare les valeurs ; \texttt{is} teste si les deux références désignent le même objet en mémoire}
    \end{itemize}
\end{frame}

\begin{frame}[standout]{}
    Fin de l'évaluation
\end{frame}

\end{document}
