lafrite/2022-2023
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Compare commits

base: lafrite:6174205816e56f108f89b00480f0b7b4ade6b270
Branches Tags
lafrite:main
..
compare: lafrite:ac4aa555b7498c5aef363bb2f50f39b9cdc21a92
Branches Tags
lafrite:main

No commits in common. "6174205816e56f108f89b00480f0b7b4ade6b270" and "ac4aa555b7498c5aef363bb2f50f39b9cdc21a92" have entirely different histories.
6174205816 ... ac4aa555b7

20 changed files with 20 additions and 924 deletions
Show Stats Expand all files Collapse all files

11
1NSI/05_Interaction_client-serveur/exercises.tex
View File

@ -105,7 +105,14 @@
\begin{exercise}[subtitle={Application web avec Bottle - requête POST}, step={2}, origin={Ma tête}, topics={ Interaction client-serveur }, tags={ HTTP, Flask }] \begin{exercise}[subtitle={Application web avec Bottle - requête POST}, step={2}, origin={Ma tête}, topics={ Interaction client-serveur }, tags={ HTTP, Flask }]
Les requêtes POST envoient des informations au serveur. Ces informations sont le plus souvent envoyé à partir d'une formulaire HTML. Les requêtes POST envoient des informations au serveur. Ces informations sont le plus souvent envoyé à partir d'une formulaire HTML.
On reprend le code de la question \ref{bottle_base} de l'exercice précédent. On reprend le code de la question \ref{bottle_base} de l'exercice précédent. Puis on ajoute à côté du script de notre application, le modèle suivant:
\begin{center}
\begin{minipage}{0.9\linewidth}
\inputminted[bgcolor=base3,linenos]{html}{./scripts/modele_base.html}
\end{minipage}
\end{center}
Ce modèle permettra d'avoir une structure HTML propre. Il n'y aura plus qu'à passer le contenu du body.
\begin{enumerate} \begin{enumerate}
\item Supprimer la route \texttt{hello} et ajouter la route suivante \item Supprimer la route \texttt{hello} et ajouter la route suivante
@ -158,7 +165,7 @@
\end{exercise} \end{exercise}
\begin{exercise}[subtitle={QCM}, step={2}, origin={Annales}, topics={ Interaction client-serveur }, tags={ HTTP, Flask }] \begin{exercise}[subtitle={QCM}, step={2}, origin={Ma tête}, topics={ Interaction client-serveur }, tags={ HTTP, Flask }]
\begin{enumerate} \begin{enumerate}
\item Parmi GET et POST, quelle méthode d'envoi de formulaire crypte les informations envoyées au serveurs? \item Parmi GET et POST, quelle méthode d'envoi de formulaire crypte les informations envoyées au serveurs?
\begin{tasks}(2) \begin{tasks}(2)

21
1NSI/05_Interaction_client-serveur/index.rst
View File

@ -2,7 +2,7 @@ Interaction client-serveur
########################### ###########################
:date: 2023-01-03 :date: 2023-01-03
:modified: 2023-01-22 :modified: 2023-01-16
:authors: Benjamin Bertrand :authors: Benjamin Bertrand
:tags: Http, Flask :tags: Http, Flask
:category: 1NSI :category: 1NSI
@ -31,14 +31,8 @@ Interaction client-serveur
Progression Progression
=========== ===========
Plan de travail Étape 1: Étude des headers
--------------------------
.. image:: ./plan_de_travail.pdf
:height: 200px
:alt: Plan de travail
Etape 1: requetes
=================
Cours: rappels de ce qui a été déjà fait sur le web: client serveur, url, positionnement du protocole HTTP dans la stack web. Introduction des concepts requêtes/reponses. Cours: rappels de ce qui a été déjà fait sur le web: client serveur, url, positionnement du protocole HTTP dans la stack web. Introduction des concepts requêtes/reponses.
@ -54,11 +48,6 @@ Bilan:
:height: 200px :height: 200px
:alt: Bilan sur les requêtes POST, les formulaires et les codes status du serveur :alt: Bilan sur les requêtes POST, les formulaires et les codes status du serveur
Etape 2: construction d'un serveur
==================================
Pour faire les exercices utilisant Bottle, il faut placer `le fichier bottle.py <https://raw.githubusercontent.com/bottlepy/bottle/master/bottle.py>`_ à côté de votre script. Étape 2: Construire un serveur web avec Flask
---------------------------------------------
Etape 3: QCM type
=================

BIN
1NSI/05_Interaction_client-serveur/plan_de_travail.pdf
View File

Binary file not shown.

2
1NSI/05_Interaction_client-serveur/scripts/bottle_get_form.py
View File

@ -6,4 +6,4 @@ def get_formulaire():
<input type='submit' value='Bonjour bottle !'/> <input type='submit' value='Bonjour bottle !'/>
</form> </form>
""" """
return formulaire return template("modele_base.html", boby=formulaire)

4
1NSI/05_Interaction_client-serveur/scripts/bottle_post_form.py
View File

@ -1,6 +1,6 @@
@post('/bonjour') @post('/formulaire')
def bonjour() : def bonjour() :
nom = bottle.request.forms.get('nom') nom = bottle.request.forms.get('nom')
body = "<p>Bonjour mon(a) che(è)r(e) " + nom + "</p>" body = "<p>Bonjour mon(a) che(è)r(e) " + nom + "</p>"
return body return template("modele_base.py", body=body)

6
1NSI/05_Interaction_client-serveur/scripts/bottle_query.py
View File

@ -1,4 +1,4 @@
from bottle import request, get from botte import request, get
@get('/age') @get('/age')
def age_de(): def age_de():
@ -6,9 +6,9 @@ def age_de():
name = request.query.name name = request.query.name
age = request.query.age age = request.query.age
if int(age) > 1: if age > 1:
return name + " a " + age + " ans." return name + " a " + age + " ans."
elif int(age) <= 0: elif age <= 0:
return "Mouai..." return "Mouai..."
else: else:
return name + " a " + age + " an." return name + " a " + age + " an."

14
1NSI/06_Listes_et_tuples/1B.tex
View File

@ -1,14 +0,0 @@
\documentclass[a4paper,10pt]{article}
\usepackage{myXsim}
\author{Benjamin Bertrand}
\title{Listes et tuples - Cours}
\date{janvier 2023}
\pagestyle{empty}
\begin{document}
\maketitle
\end{document}

585
1NSI/06_Listes_et_tuples/Découverte des listes et des tuples.ipynb
View File

@ -1,585 +0,0 @@
{
"cells": [
{
"cell_type": "markdown",
"id": "ed3c16da",
"metadata": {},
"source": [
"# Découverte des listes et des tuples\n",
"\n",
"## Mise en situation\n",
"\n",
"On souhaite écrire un programme qui fait une moyenne de notes.\n",
"\n",
"1. Écrire une fonction `moyenne3` qui prend en argument 3 notes et qui renvoie la moyenne de ces trois notes"
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "352fd339",
"metadata": {},
"outputs": [],
"source": [
"# tests\n",
"assert moyenne3(1, 2, 3) == 2\n",
"assert moyenne3(10, 0, 5) == 5"
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "ddd2db52",
"metadata": {},
"outputs": [],
"source": [
"# fonction"
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "3e58998e",
"metadata": {},
"outputs": [],
"source": []
},
{
"cell_type": "markdown",
"id": "97396105",
"metadata": {},
"source": [
"2. Écrire une fonction `moyenne_question` qui prend en argument un nombre de notes puis renvoie la moyenne des notes entrée par l'utilisateur (avec input)."
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "4dd1cb77",
"metadata": {},
"outputs": [],
"source": [
"# pas de tests à cause de l'utilisation du input"
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "572a9917",
"metadata": {},
"outputs": [],
"source": [
"# fonction"
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "af965cbe",
"metadata": {},
"outputs": [],
"source": []
},
{
"cell_type": "markdown",
"id": "91486d89",
"metadata": {},
"source": [
"3. On voudrait maintenant écrire une fonction qui prend en argument plusieurs notes (qu'on ne connait pas à l'avance) et qui renvoie la moyenne de ces notes. Quels sont les obstacles qui empêchent de réaliser une telle fonction?"
]
},
{
"cell_type": "raw",
"id": "ac18a2ae",
"metadata": {},
"source": []
},
{
"cell_type": "markdown",
"id": "28501a12",
"metadata": {},
"source": [
"## Les listes\n",
"\n",
"Les `list` sont un autre type de variable (au même titre que les `int`, `float`...). Ils ont la particularité de stocker un nombre arbitraire de variables. En voici des exemples"
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "0c8dd096",
"metadata": {},
"outputs": [],
"source": [
"liste1 = [1, 2, 3, 4, 5]\n",
"liste2 = [\"a\", \"c\" \"uio\", \"éé\"]\n",
"liste3 = [-1, 2.2, \"uio\", 10, 100, \"1000\"] "
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "28c340b2",
"metadata": {},
"outputs": [],
"source": [
"print(liste1)\n",
"print(liste2)\n",
"print(liste3)"
]
},
{
"cell_type": "markdown",
"id": "9dd742c8",
"metadata": {},
"source": [
"### Accéder à un élément de liste\n",
"\n",
"Pour accéder à un élément particulier d'une liste, on utilise les crochets`[]`.\n",
"\n",
"1. Deviner ce qui va être afficher par les commandes ci-dessous avant de l'exécuter."
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "87fc0d29",
"metadata": {},
"outputs": [],
"source": [
"print(liste1[3])\n",
"print(liste2[2])\n",
"print(liste3[0])\n",
"print(liste1[-1])"
]
},
{
"cell_type": "markdown",
"id": "61cb8afe",
"metadata": {},
"source": [
"2. Écrire les commandes pour accéder au nombre 2 de la liste1, \"éé\" de la liste2 et \"uio\" de la liste3"
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "f11b02a8",
"metadata": {},
"outputs": [],
"source": []
},
{
"cell_type": "markdown",
"id": "cadb6818",
"metadata": {},
"source": [
"3. Que se passe-t-il quand on essayer d'accéder à une valeur qui n'existe pas?"
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "37903285",
"metadata": {},
"outputs": [],
"source": []
},
{
"cell_type": "raw",
"id": "9a0e4586",
"metadata": {},
"source": []
},
{
"cell_type": "markdown",
"id": "da97681e",
"metadata": {},
"source": [
"4. On peut aussi modifier un élément d'une liste"
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "f594935a",
"metadata": {},
"outputs": [],
"source": [
"liste1[1] = \"azert\"\n",
"print(list1)"
]
},
{
"cell_type": "markdown",
"id": "bd595043",
"metadata": {},
"source": [
"5. Construire une liste avec les nombres pairs inférieur à 10. Puis modifier la pour que les multiples de 4 soient remplacés par \"a\"."
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "4677cbb0",
"metadata": {},
"outputs": [],
"source": []
},
{
"cell_type": "markdown",
"id": "f08d4c53",
"metadata": {},
"source": [
"### Ajouter/supprimer des éléments\n",
"\n",
"Pour ajouter des éléments, on utilise la méthode `.append(...)`."
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "ff4e90a0",
"metadata": {},
"outputs": [],
"source": [
"liste3 = [-1, 2.2, \"uio\", 10, 100, \"1000\"]\n",
"print(liste3)\n",
"liste3.append(\"nsi\")\n",
"print(liste3)\n",
"liste3.append(\"azert\")\n",
"print(liste3)"
]
},
{
"cell_type": "markdown",
"id": "8a0f012c",
"metadata": {},
"source": [
"1. Écrire une fonction `table` qui prend en argument un nombre `a` et une longueure `n` et qui renvoie les multiples de a de 0 à a*n."
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "59a55bc2",
"metadata": {},
"outputs": [],
"source": [
"# Testes\n",
"assert table(2, 10) == [0, 2, 4, 6, 8, 10, 12, 14, 16, 18, 20]\n",
"assert table(3, 5) == [0, 3, 6, 9, 12, 15]"
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "69fb46d6",
"metadata": {},
"outputs": [],
"source": [
"# Fonction"
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "04e04b5d",
"metadata": {},
"outputs": [],
"source": []
},
{
"cell_type": "markdown",
"id": "36258d27",
"metadata": {},
"source": [
"Pour enlever un élément, on utilise la méthode `.remove(...)`."
]
},
{
"cell_type": "code",
"execution_count": 4,
"id": "549a996d",
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"[-1, 2.2, 'uio', 10, 100, 10]\n",
"[-1, 2.2, 10, 100, 10]\n",
"[-1, 2.2, 100, 10]\n"
]
}
],
"source": [
"liste3 = [-1, 2.2, \"uio\", 10, 100, 10]\n",
"print(liste3)\n",
"liste3.remove(\"uio\")\n",
"print(liste3)\n",
"liste3.remove(10)\n",
"print(liste3)"
]
},
{
"cell_type": "markdown",
"id": "0bc67d3c",
"metadata": {},
"source": [
"### Longueur d'une liste\n",
"\n",
"Pour mesurer la longueur d'une liste, on utilise la fonction `len(...)`."
]
},
{
"cell_type": "code",
"execution_count": 5,
"id": "9c809de2",
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"5\n",
"3\n",
"6\n"
]
}
],
"source": [
"liste1 = [1, 2, 3, 4, 5]\n",
"print(len(liste1))\n",
"liste2 = [\"a\", \"c\" \"uio\", \"éé\"]\n",
"print(len(liste2))\n",
"liste3 = [-1, 2.2, \"uio\", 10, 100, \"1000\"] \n",
"print(len(liste3))"
]
},
{
"cell_type": "markdown",
"id": "88060355",
"metadata": {},
"source": [
"1. Écrire une fonction `somme` qui prend en argument une liste de nombres et qui renvoie la somme des nombres"
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "19510eb8",
"metadata": {},
"outputs": [],
"source": [
"# Tests\n",
"assert somme([1, 2, 3]) == 6\n",
"assert somme([1]) == 1\n",
"assert somme([1, 5, 10, 0, 4]) == 20\n",
"assert somme([1.2, 1, 1.5]) == 3.7"
]
},
{
"cell_type": "code",
"execution_count": 6,
"id": "38c79fed",
"metadata": {},
"outputs": [],
"source": [
"# Fonction"
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "f4cd9cbf",
"metadata": {},
"outputs": [],
"source": []
},
{
"cell_type": "markdown",
"id": "3e7e0a3a",
"metadata": {},
"source": [
"2. Écrire une fonction `moyenne` qui prend en argument une liste de nombres et qui renvoie la moyenne de ces nombres"
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "e83df22f",
"metadata": {},
"outputs": [],
"source": [
"# Tests\n",
"assert moyenne([1, 2, 3]) == 2\n",
"assert moyenne([1]) = 1"
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "750b4e2f",
"metadata": {},
"outputs": [],
"source": [
"# Fonctions"
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "35efeef8",
"metadata": {},
"outputs": [],
"source": []
},
{
"cell_type": "markdown",
"id": "9bff74a3",
"metadata": {},
"source": [
"### Boucle for sur une liste\n",
"\n",
"Il est possible de faire une boucle `for` sur les éléments d'une liste.\n",
"\n",
"Par exemple, la fonction `moyenne` précédement rédigée peut être réécrite de la manière suivante"
]
},
{
"cell_type": "code",
"execution_count": 5,
"id": "c93f43d4",
"metadata": {},
"outputs": [],
"source": [
"def moyenne(notes:list)->float:\n",
" \"\"\"Calculer la moyenne des notes de la liste\"\"\"\n",
" total = 0\n",
" for note in notes:\n",
" total = total + note\n",
" return total / len(notes)"
]
},
{
"cell_type": "markdown",
"id": "53c180b6",
"metadata": {},
"source": [
"1. Ecrire une fonction `somme` qui prend en argument une liste de nombres et qui renvoie la somme de ces nombres."
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "f956b1ec",
"metadata": {},
"outputs": [],
"source": []
},
{
"cell_type": "markdown",
"id": "4ec924e6",
"metadata": {},
"source": [
"2. Ecrire une fonction `multiplie` qui prend en argument un nombre et une liste de nombres et qui renvoie la liste des nombres multipliées par l'autre nombre."
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "c90251a7",
"metadata": {},
"outputs": [],
"source": [
"#tests\n",
"assert multiplie(2, [1, 2, 3]) == [2, 4, 6]\n",
"assert multiplie(0, [1, 3, 6]) == [0, 0, 0]\n",
"assert multiplie(-1, [1, 10, 100, -1]) == [-1, -10, -100, 1]"
]
},
{
"cell_type": "code",
"execution_count": 8,
"id": "81f3ebdf",
"metadata": {},
"outputs": [],
"source": [
"#Fonction"
]
},
{
"cell_type": "markdown",
"id": "bd7c1976",
"metadata": {},
"source": [
"3. Ecrire une fonction `filtre_impaire` qui prendre en argument une liste de nombres et qui renvoie une liste contenant uniquement les nombres impaires."
]
},
{
"cell_type": "code",
"execution_count": 6,
"id": "b484693e",
"metadata": {},
"outputs": [
{
"ename": "NameError",
"evalue": "name 'filtre_impaire' is not defined",
"output_type": "error",
"traceback": [
"\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
"\u001b[0;31mNameError\u001b[0m Traceback (most recent call last)",
"Input \u001b[0;32mIn [6]\u001b[0m, in \u001b[0;36m<module>\u001b[0;34m\u001b[0m\n\u001b[1;32m 1\u001b[0m \u001b[38;5;66;03m#tests\u001b[39;00m\n\u001b[0;32m----> 2\u001b[0m \u001b[38;5;28;01massert\u001b[39;00m \u001b[43mfiltre_impaire\u001b[49m([\u001b[38;5;241m1\u001b[39m, \u001b[38;5;241m2\u001b[39m, \u001b[38;5;241m3\u001b[39m, \u001b[38;5;241m4\u001b[39m, \u001b[38;5;241m5\u001b[39m]) \u001b[38;5;241m==\u001b[39m [\u001b[38;5;241m1\u001b[39m, \u001b[38;5;241m3\u001b[39m, \u001b[38;5;241m5\u001b[39m]\n\u001b[1;32m 3\u001b[0m \u001b[38;5;28;01massert\u001b[39;00m filtre_impaire([\u001b[38;5;241m2\u001b[39m, \u001b[38;5;241m4\u001b[39m]) \u001b[38;5;241m==\u001b[39m []\n\u001b[1;32m 4\u001b[0m \u001b[38;5;28;01massert\u001b[39;00m filtre_impaire([]) \u001b[38;5;241m==\u001b[39m []\n",
"\u001b[0;31mNameError\u001b[0m: name 'filtre_impaire' is not defined"
]
}
],
"source": [
"#tests\n",
"assert filtre_impaire([1, 2, 3, 4, 5]) == [1, 3, 5]\n",
"assert filtre_impaire([2, 4]) == []\n",
"assert filtre_impaire([]) == []"
]
},
{
"cell_type": "code",
"execution_count": 7,
"id": "c43261b1",
"metadata": {},
"outputs": [],
"source": [
"# Fonctions"
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "fc069c83",
"metadata": {},
"outputs": [],
"source": []
}
],
"metadata": {
"kernelspec": {
"display_name": "Python 3 (ipykernel)",
"language": "python",
"name": "python3"
},
"language_info": {
"codemirror_mode": {
"name": "ipython",
"version": 3
},
"file_extension": ".py",
"mimetype": "text/x-python",
"name": "python",
"nbconvert_exporter": "python",
"pygments_lexer": "ipython3",
"version": "3.10.9"
}
},
"nbformat": 4,
"nbformat_minor": 5
}

174
1NSI/06_Listes_et_tuples/exercises.tex
View File

@ -1,174 +0,0 @@
\begin{exercise}[subtitle={QCM}, step={2}, origin={Annales}, topics={Tuples et listes}, tags={tuple, liste}]
\begin{enumerate}
\item Quel est le type de l'expression \texttt{f(4)} si la fonction \texttt{f} est définie par
\begin{center}
\begin{minipage}{0.9\linewidth}
\inputminted[bgcolor=base3]{python}{./scripts/QCM_f.py}
\end{minipage}
\end{center}
\begin{tasks}(4)
\task un entier
\task un flottant
\task une liste
\task un tuple
\end{tasks}
\item On dispose d'une liste définie par \mintinline{python}{L = [15, 17, 12, 23]}.
Quelle est la valeur de L après l'instruction \mintinline{python}{L[2] = 25}
\begin{tasks}(2)
\task \mintinline{python}{[15, 25, 12, 23]}
\task \mintinline{python}{[15, 17, 25, 12, 23]}
\task \mintinline{python}{[15, 25, 25, 23]}
\task \mintinline{python}{[15, 17, 12, 25, 23]}
\end{tasks}
\item Après l'affectation suivante :
\mintinline{python}{alphabet = [ 'A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I', 'J', 'K', 'L', 'M',] }
quelle est l'expression qui permet d'accéder à la lettre E?
\begin{tasks}(2)
\task \mintinline{python}{alphabet.E}
\task \mintinline{python}{alphabet['E']}
\task \mintinline{python}{alphabet[4]}
\task \mintinline{python}{alphabet[5]}
\end{tasks}
\item On considère le script suivant:
\begin{center}
\begin{minipage}{0.9\linewidth}
\inputminted[bgcolor=base3]{python}{./scripts/QCM_t.py}
\end{minipage}
\end{center}
Quelle est la valeur de t à la fin de son exécution?
\begin{tasks}(4)
\task \mintinline{python}{[2, 13, 9, 2]}
\task \mintinline{python}{[2, 8, 14, 2]}
\task \mintinline{python}{[2, 13, 14, 2]}
\task \mintinline{python}{[2, 13, 9, 2]}
\end{tasks}
\item On considère la fonction suivante:
\begin{center}
\begin{minipage}{0.9\linewidth}
\inputminted[bgcolor=base3]{python}{./scripts/QCM_somme.py}
\end{minipage}
\end{center}
Par quelle instruction faut-il remplacer les points de suspension pour que l'appel
\mintinline{python}{somme([10, 11, 12, 13, 14])} renvoie 60?
\begin{tasks}(2)
\task \mintinline{python}{s = tab[i]}
\task \mintinline{python}{s = s + tab[i]}
\task \mintinline{python}{tab[i] = tab[i] + s}
\task \mintinline{python}{s = s + i}
\end{tasks}
\item On exécute le script suivant:
\begin{center}
\begin{minipage}{0.9\linewidth}
\inputminted[bgcolor=base3]{python}{./scripts/QCM_double.py}
\end{minipage}
\end{center}
Quelle est la valeur de m à la fin de son exécution?
\begin{tasks}(1)
\task \mintinline{python}{[ [0, 0, 0, 0, 0], [0, 1, 2, 3, 4], [0, 2, 4, 6, 8] ] }
\task \mintinline{python}{[ [0, 0, 0], [0, 1, 2], [0, 2, 4], [0, 3, 6], [0, 4, 8] ] }
\task \mintinline{python}{[ [1, 1, 1], [2, 4, 6], [3, 6, 9], [4, 8, 12], [5, 10, 15] ] }
\task \mintinline{python}{[ [1, 1, 1, 1, 1], [2, 4, 6, 8, 10], [3, 6, 9, 12, 15], [4, 8, 12, 16, 20], [5, 10, 15, 20, 25] ]}
\end{tasks}
\item L est une liste d'entiers. On définit la fonction suivante
\begin{center}
\begin{minipage}{0.9\linewidth}
\inputminted[bgcolor=base3]{python}{./scripts/QCM_filtre.py}
\end{minipage}
\end{center}
Que calcule cette fonction?
\begin{tasks}(1)
\task le maximum de la liste L passée en argument
\task le minimum de la liste L passée en argument
\task le premier terme de la liste L passée en argument
\task le dernier terme de la liste L passée en argument
\end{tasks}
\item Quelle est la valeur de la variable r à la fin de l'exécution du script suivant?
\begin{center}
\begin{minipage}{0.9\linewidth}
\inputminted[bgcolor=base3]{python}{./scripts/QCM_tuple.py}
\end{minipage}
\end{center}
\begin{tasks}(4)
\task -9
\task 2
\task 3
\task 6
\end{tasks}
\item On définit : \mintinline{python}{[10,9,8,7,6,5,4,3,2,1]}
Quelle est la valeur de \mintinline{python}{L[L[3]]}
\begin{tasks}(4)
\task 3
\task 4
\task 7
\task 8
\end{tasks}
\item On considère la liste de listes suivantes
\begin{center}
\begin{minipage}{0.9\linewidth}
\inputminted[bgcolor=base3]{python}{./scripts/QCM_tictactoe.py}
\end{minipage}
\end{center}
Quelle instruction permet d'obtenir une diagonale de "X"?
\begin{tasks}(2)
\task \mintinline{python}{tictactoe[3] = "X"}
\task \mintinline{python}{tictactoe[4] = "X"}
\task \mintinline{python}{tictactoe[1][1] = "X"}
\task \mintinline{python}{tictactoe[2][2] = "X"}
\end{tasks}
\item On définit ainsi une liste M
\begin{center}
\mintinline{python}{M = [['A','B','C','D'], ['E','F','G','H'], ['I','J','K','L']] }
\end{center}
Quelle expression vaut la chaîne de caractères 'H'?
\begin{tasks}(4)
\task \mintinline{python}{M[1][3]}
\task \mintinline{python}{M[3][1]}
\task \mintinline{python}{M(7)}
\task \mintinline{python}{M(8)}
\end{tasks}
\end{enumerate}
\end{exercise}

28
1NSI/06_Listes_et_tuples/index.rst
View File

@ -1,28 +0,0 @@
Listes et tuples
################
:date: 2023-01-22
:modified: 2023-01-22
:authors: Benjamin Bertrand
:tags: Listes, Python
:category: 1NSI
:summary: Découverte et manipulation de listes et de tuples
Éléments du programme
=====================
Contenus
--------
Capacités attendues
-------------------
Commentaires
------------
Progression
===========
Étape 1:
--------

BIN
1NSI/06_Listes_et_tuples/plan_de_travail.pdf
View File

Binary file not shown.

45
1NSI/06_Listes_et_tuples/plan_de_travail.tex
View File

@ -1,45 +0,0 @@
\documentclass[a4paper,12pt]{article}
\usepackage{myXsim}
\usepackage{minted}
\author{Benjamin Bertrand}
\title{Listes et tuples - Plan de travail}
\tribe{1NSI}
\date{janvier 2023}
\pagestyle{empty}
\DeclareExerciseCollection{banque}
\xsimsetup{
}
\begin{document}
\maketitle
% Résumé
\bigskip
Savoir-faire de la séquence
\begin{itemize}
\item
\end{itemize}
\bigskip
Ordre des étapes à respecter
\section{}
\listsectionexercises
\pagebreak
\input{exercises.tex}
\printcollection{banque}
\end{document}

6
1NSI/06_Listes_et_tuples/scripts/QCM_double.py
View File

@ -1,6 +0,0 @@
m = []
for i in range(5):
n = []
for j in range(3):
n.append(i*j)
m.append(n)

2
1NSI/06_Listes_et_tuples/scripts/QCM_f.py
View File

@ -1,2 +0,0 @@
def f(x):
return (x, x**2)

6
1NSI/06_Listes_et_tuples/scripts/QCM_filtre.py
View File

@ -1,6 +0,0 @@
def f(L):
m = L[0]
for x in L:
if x > m:
m = x
return m

5
1NSI/06_Listes_et_tuples/scripts/QCM_somme.py
View File

@ -1,5 +0,0 @@
def somme(tab):
s = 0
for i in range(len(tab)):
......
return s

2
1NSI/06_Listes_et_tuples/scripts/QCM_t.py
View File

@ -1,2 +0,0 @@
t = [2, 8, 9, 2]
t[2] = t[2] + 5

3
1NSI/06_Listes_et_tuples/scripts/QCM_tictactoe.py
View File

@ -1,3 +0,0 @@
tictactoe = [['X', 'o', 'o'],
['o', 'o', 'o'],
['o', 'o', 'X']]

2
1NSI/06_Listes_et_tuples/scripts/QCM_tuple.py
View File

@ -1,2 +0,0 @@
t = (10,6,1,12,15)
r = t[3] - t[1]

28
1NSI/06_Listes_et_tuples/solutions.tex
View File

@ -1,28 +0,0 @@
\documentclass[a4paper,10pt]{article}
\usepackage{myXsim}
\usetikzlibrary{shapes.geometric}
\author{Benjamin Bertrand}
\title{Listes et tuples - Solutions}
\tribe{1NSI}
\date{janvier 2023}
\DeclareExerciseCollection{banque}
\xsimsetup{
exercise/print=false,
solution/print=true,
}
\pagestyle{empty}
\begin{document}
\maketitle
\input{exercises.tex}
%\printcollection{banque}
%\printsolutions{exercises}
\end{document}