Compare commits
No commits in common. "8d66eb7689f0094dcc62d849ad838db1b162d333" and "38323d3c56d0377f1420b8af901bd5e7b492e9f7" have entirely different histories.
8d66eb7689
...
38323d3c56
3
.gitignore
vendored
3
.gitignore
vendored
@ -1,6 +1,3 @@
|
||||
## Do not save pdf by default
|
||||
*.pdf
|
||||
|
||||
## Core latex/pdflatex auxiliary files:
|
||||
*.aux
|
||||
*.lof
|
||||
|
||||
Binary file not shown.
@ -1,86 +0,0 @@
|
||||
\documentclass[11pt,a4paper]{../../template/template_cours}
|
||||
\usepackage{listings}
|
||||
|
||||
\title{Rédiger un mail ou un courrier papier}
|
||||
\author{Adrian Amaglio}
|
||||
\def\thesequence{}
|
||||
|
||||
\begin{document}
|
||||
\maketitle
|
||||
|
||||
Ce cours résume des codes et les outils pour préparer, structurer, rédiger et mettre en page des mails ou courriers.
|
||||
|
||||
\begin{tabular}{l|l|l}
|
||||
& Mail & Lettre\\
|
||||
Registre & Soutenu \\
|
||||
Fluide & 30 mots par phrase max & 20 mots par phrase max \\
|
||||
Rédaction & Phrases entrièrement rédigées (aucune abbréviation) \\
|
||||
|
||||
\end{tabular}
|
||||
|
||||
|
||||
%
|
||||
\section{Les formules de politesse}
|
||||
Les formules de politesse encadrent tout courrier.
|
||||
|
||||
\subsection{Formule d’appel}
|
||||
|
||||
La formule d’appel par défaut, quand on ne peut identifier le destinataire, est « Madame, Monsieur, ».
|
||||
|
||||
Trois conventions méritent d’être connues :
|
||||
\begin{itemize}
|
||||
\item à moins de vouloir faire preuve d’un respect particulier, on ne met pas de nom propre après « Monsieur » ou « Madame » ;
|
||||
\item pour exprimer le fait qu’on apprécie son destinataire, on peut écrire « Cher Monsieur » ou « Chère Madame » ;
|
||||
\item bien que la formule d’appel finisse par une virgule, le premier paragraphe commence par une majuscule.
|
||||
\end{itemize}
|
||||
|
||||
\subsection{Formule de congé}
|
||||
|
||||
\begin{tabular}{|c|c|c|}
|
||||
Situation & Dans un e-mail & Dans une lettre \\
|
||||
\hline
|
||||
on écrit à un(e) supérieur(e)
|
||||
&
|
||||
Respectueusement
|
||||
&
|
||||
Veuillez agréer/ Je vous prie d’agréer, \textbf{(reprise de la formule d’appel)}, mes salutations respectueuses
|
||||
\\
|
||||
On écrit à un(e) collègue, un(e) inconnu(e)…
|
||||
&
|
||||
Du plus au moins formel : « Respectueusement » ; « Cordialement » ; « Bien cordialement » ; « Amicalement »
|
||||
&
|
||||
Veuillez agréer/ Je vous prie d’agréer, (reprise de la formule d’appel), mes salutations distinguées/mes cordiales salutations.
|
||||
\\
|
||||
On écrit à un(e) ami(e), un(e) membre de la famille, des personnes que l’on connaît…
|
||||
&
|
||||
« bonne journée », « bon travail », « bon week-end », « à bientôt », « bonne lecture »…
|
||||
\\
|
||||
\end{tabular}
|
||||
|
||||
%
|
||||
\section{Un vocabulaire précis}
|
||||
On évite les mots vagues et passe-partout, afin de gagner en précision.
|
||||
a- Quelques noms communs « bateaux » (suggestion de synonymes à choisir selon le contexte)
|
||||
Problème : question, besoin, sujet, oubli, panne, point de désaccord, risque, dysfonctionnement
|
||||
Chose : activité, dossier, affaire, appareil, article, élément, objet, outils, question, travail
|
||||
Projet : direction, entreprise, idée, initiative, motif, plan
|
||||
Document : catalogue, tableau, contrat, fiche, formulaire, mode d’emploi, rapport, texte
|
||||
b- Quelques adjectifs « bateaux » (suggestion de synonymes à choisir selon le contexte)
|
||||
Important : considérable, décisif, central, crucial, indispensable, majeur, nécessaire, obligatoire, primordial,
|
||||
sérieux
|
||||
Correct : adapté, juste, régulier, décent, exact, conforme, fidèle, adéquat, approprié
|
||||
Difficile : ambigu, compliqué, complexe, confus, subtil, pénible, fatigant, gênant
|
||||
Simple/facile : élémentaire, fondamental, sommaire, concis, laconique, superficiel, abordable, accessible
|
||||
|
||||
\section{sources}
|
||||
Inspiré d’un document de Guillaume DE SAUZA à l’IUT de Valence, selon les documents suivants :
|
||||
\begin{itemize}
|
||||
\item AZOULAY-BISMUTH (Sylvie), Être un pro de l’e-mail : 7 étapes pour rédiger des e-mails efficaces, Paris, Eyrolles, 2014.
|
||||
\item CHAUCHEYRAS (Florence) et GABORIAUX (Chloé), L’Orthographe après le bac, Paris, Ellipses, 2012.
|
||||
\item HENNEBERT (Jérôme), dir., Communication DUT, Paris, Nathan, 2010.
|
||||
\item NISHIMATA (Aline), Savoir rédiger vos e-mails professionnels, Gualino, Issy-les-Moulineaux, 2019 (6e éd.).
|
||||
\item NISHIMATA (Aline), 100 e-mails professionnels pour bien communiquer, Gualino, Issy-les-Moulineaux, 2019.
|
||||
\item OULLION (Jean-Michel), L’Orthographe sans se fouler, Paris, Marabout, 2010.
|
||||
\item VERVIER (Anne), Courrier clair : outils et mode d’emploi pour vos lettres et e-mails, Edi.pro, Liège, 2017.
|
||||
\end{itemize}
|
||||
\end{document}
|
||||
Binary file not shown.
Binary file not shown.
Binary file not shown.
@ -23,7 +23,7 @@ Durée : 1h
|
||||
\end{exercice}
|
||||
|
||||
\begin{exercice}
|
||||
Créez un fichier texte dont vous choisirez le nom. Attention à bien garder une extention md ou txt sans quoi le type de fichier ne sera pas reconnu~!\\
|
||||
Créez un fichier texte dont vous choisirez le nom.\\
|
||||
\fbox{\includegraphics[width=\textwidth]{nouveau_document_texte.png}}
|
||||
\end{exercice}
|
||||
|
||||
@ -50,17 +50,7 @@ Durée : 1h
|
||||
\section{Partage avec une autre instance}
|
||||
\begin{exercice}
|
||||
Choisissez un binôme dans le groupe qui est sur une autre instance Nextcloud.
|
||||
Partagez lui votre dossier en lecture seule à l’aide de son identifiant nextcloud.\\
|
||||
Pour ce faire, vous devrez partager le dossier comme à l’exercice précédent, en utilisant un identifiant composé du nom d’utilisateur et de l’adresse du service. Par exemple : seconde3@educloud.jean-cloud.net
|
||||
Partagez lui votre dossier en lecture seule à l’aide de son identifiant nextcloud.
|
||||
\end{exercice}
|
||||
|
||||
% ---
|
||||
%\section{Partager une photo}
|
||||
%\begin{exercice}
|
||||
% Téléchargez une photo sur le web et enregistrez la sur votre ordinateur. Envoyez la ensuite dans votre dossier nextcloud.
|
||||
%\end{exercice}
|
||||
%
|
||||
%\begin{exercice}
|
||||
% Partagez cette photo avec un ou une autre élève (demandez-lui son compte). Quels permissions donnez-vous à ce partage ? Vérifiez qu’il ou elle a bien accès à votre photo.
|
||||
%\end{exercice}
|
||||
\end{document}
|
||||
|
||||
@ -1,5 +0,0 @@
|
||||
# Comment faire un QCM pronote juste.
|
||||
|
||||
## S’il est à faire à la maison
|
||||
- Le compter comme un bonus (s’il contient une erreur, rien n’est modifiable).
|
||||
- Laisser tout le trimestre pour y répondre : Les élèves raccrochent parfois à des moments aléatoires, on leur laisse leur rythme.
|
||||
Binary file not shown.
@ -41,15 +41,15 @@ Parmi ces registres, nous allons utiliser les trois suivants :
|
||||
\begin{description}
|
||||
\item[RI] le registre d'instruction ; il contient l'instruction en cours ;
|
||||
\item[CO] le compteur ordinal ; il contient l'adresse de la prochaine instruction à exécuter ;
|
||||
\item[ACC] l'accumulateur ; registre de l'UAL chargé de stocker une des opérandes avant l'exécution puis le résultat de l'opération.
|
||||
\item[AC] l'accumulateur ; registre de l'UAL chargé de stocker une des opérandes avant l'exécution puis le résultat de l'opération.
|
||||
\end{description}
|
||||
|
||||
% ---
|
||||
\section{Les instructions}
|
||||
Un processeur est capable d’exécuter des instructions.
|
||||
\begin{definition}
|
||||
Le \textbf{langage machine} est un ensemble d’instructions binaire que le processeur peut suivre.\\
|
||||
Un \textbf{langage assembleur} est la version lisible (par les humain·e·s) de ce langage binaire.
|
||||
Le \textbf{langage machine} est une succession de bits qui est interprétable par le processeur d'un ordinateur.\\
|
||||
Un \textbf{langage assembleur} est le langage machine machine ou des combinaisons de bits sont représentées par des "symboles" qu'un être humain peut mémoriser.
|
||||
\end{definition}
|
||||
Un langage assembleur est souvent spécifique un type de processeur.
|
||||
|
||||
@ -57,17 +57,16 @@ Un langage assembleur est souvent spécifique un type de processeur.
|
||||
\begin{tabular}{l|l|l}
|
||||
Instruction machine & Instruction Assembleur & Effet \\
|
||||
\hline
|
||||
0000 aaaa & LD A & Lit le contenu de la cellule A (ACC ← A) \\
|
||||
0001 aaaa & STO A & Enregistre dans la cellule A (A ← ACC) \\
|
||||
0010 aaaa & ADD N & Ajoute le contenu de la cellule A (ACC ← ACC + N) \\
|
||||
0011 aaaa & SUB N & Soustrait le contenu de la cellule A (ACC ← ACC - N) \\
|
||||
0100 aaaa & JMP A & Saute à l'adresse A (CO ← A) \\
|
||||
0101 aaaa & JMPZ A & Saute à l'adresse A (CO ← A) si ACC = 0\\
|
||||
0110 aaaa & JMPP A & Saute à l'adresse A (CO ← A) si ACC > 0 \\
|
||||
0111 aaaa & JMPN A & Saute à l'adresse A (CO ← A) si ACC < 0 \\
|
||||
0000 xxxx & LD X & Lit le contenu de la cellule X (ACC ← \#X) \\
|
||||
0001 xxxx & STO X & Enregistre dans la cellule X (\#X ← ACC) \\
|
||||
0010 xxxx & ADD X & Ajoute le contenu de la cellule X (ACC ← ACC + \#X) \\
|
||||
0011 xxxx & SUB X & Soustrait le contenu de la cellule X (ACC ← ACC - \#X) \\
|
||||
0100 aaaa & JMP ADR & Saute à l'adresse ADR (CO ← A) \\
|
||||
0101 aaaa & JMPZ ADR & Saute à l'adresse ADR si nul \\
|
||||
0110 aaaa & JMPP ADR & Saute à l'adresse ADR si positif \\
|
||||
0111 aaaa & JMPN ADR & Saute à l'adresse ADR si négatif \\
|
||||
\end{tabular}
|
||||
\caption{Un exemple de langage machine, dont une opération est numérotée sur 4 bits et un paramètre sur 4 bits également.\\
|
||||
\#A signifie, la valeur de la case d’adresse A.}
|
||||
\caption{Un exemple de langage machine, dont une opération est numérotée sur 4 bits et un paramètre sur 4 bits également.}
|
||||
\end{figure}
|
||||
|
||||
Voici un exemple d’état de la mémoire et des registres.
|
||||
@ -85,14 +84,14 @@ Que va faire le processeur ainsi démarré ?
|
||||
10 & STO 2 \\
|
||||
11 & END \\
|
||||
\end{tabular}\hspace{5em}
|
||||
\begin{tabular}{l|l|l|l}
|
||||
Étape & RI & CO & Acc\\
|
||||
\begin{tabular}{l|l|l|l|l|l}
|
||||
Étape & RI & CO & Acc & RAM1 & RAM2 \\
|
||||
\hline
|
||||
Initiale & & 8 & \\
|
||||
1 & & & \\
|
||||
2 & & & \\
|
||||
3 & & & \\
|
||||
4 & & & \\
|
||||
Initiale & Ø & 8 & Ø & 25 & 14 \\
|
||||
1 & & & & & \\
|
||||
2 & & & & & \\
|
||||
3 & & & & & \\
|
||||
4 & & & & & \\
|
||||
\end{tabular}
|
||||
\end{figure}
|
||||
|
||||
@ -113,14 +112,14 @@ Complétez le tableau de droite pour simuler les actions du processeur et essaye
|
||||
10 & STO 2 \\
|
||||
11 & END \\
|
||||
\end{tabular}\hspace{5em}
|
||||
\begin{tabular}{l|l|l|l}
|
||||
Étape & RI & CO & Acc \\
|
||||
\begin{tabular}{l|l|l|l|l|l}
|
||||
Étape & RI & CO & Acc & RAM1 & RAM2 \\
|
||||
\hline
|
||||
Initiale & & 8 & \\
|
||||
1 & & & \\
|
||||
2 & & & \\
|
||||
3 & & & \\
|
||||
4 & & & \\
|
||||
Initiale & & 8 & & & \\
|
||||
1 & & & & & \\
|
||||
2 & & & & & \\
|
||||
3 & & & & & \\
|
||||
4 & & & & & \\
|
||||
\end{tabular}
|
||||
\end{figure}
|
||||
|
||||
@ -140,24 +139,21 @@ Complétez le tableau de droite pour simuler les actions du processeur et essaye
|
||||
10 & JMP 8 \\
|
||||
11 & END \\
|
||||
\end{tabular}\hspace{5em}
|
||||
\begin{tabular}{l|l|l|l}
|
||||
Étape & RI & CO & Acc \\
|
||||
\begin{tabular}{l|l|l|l|l|l}
|
||||
Étape & RI & CO & Acc & RAM1 & RAM2 \\
|
||||
\hline
|
||||
Initiale & & 8 & \\
|
||||
1 & & & \\
|
||||
2 & & & \\
|
||||
3 & & & \\
|
||||
4 & & & \\
|
||||
5 & & & \\
|
||||
6 & & & \\
|
||||
7 & & & \\
|
||||
8 & & & \\
|
||||
Initiale & & 8 & & & \\
|
||||
1 & & & & & \\
|
||||
2 & & & & & \\
|
||||
3 & & & & & \\
|
||||
4 & & & & & \\
|
||||
5 & & & & & \\
|
||||
6 & & & & & \\
|
||||
7 & & & & & \\
|
||||
8 & & & & & \\
|
||||
\end{tabular}
|
||||
\end{figure}
|
||||
|
||||
\subsection{Exercice}
|
||||
\textbf{Bonus.}
|
||||
Écrire un programme en langage assembleur qui récupère la valeur en RAM à l’adresse 0, à ajoute 1 et stock le résultat à l’adresse 0.
|
||||
|
||||
\subsection{Exercice}
|
||||
\textbf{Bonus.} Voici un exemple d’état de la mémoire et des registres.
|
||||
@ -178,18 +174,18 @@ Complétez le tableau de droite pour simuler les actions du processeur et essaye
|
||||
13 & STO 0 \\
|
||||
14 & END \\
|
||||
\end{tabular}\hspace{5em}
|
||||
\begin{tabular}{l|l|l|l}
|
||||
Étape & RI & CO & Acc \\
|
||||
\begin{tabular}{l|l|l|l|l|l}
|
||||
Étape & RI & CO & Acc & RAM1 & RAM2 \\
|
||||
\hline
|
||||
Initiale & & 8 & \\
|
||||
1 & & & \\
|
||||
2 & & & \\
|
||||
3 & & & \\
|
||||
4 & & & \\
|
||||
5 & & & \\
|
||||
6 & & & \\
|
||||
7 & & & \\
|
||||
8 & & & \\
|
||||
Initiale & & 8 & & & \\
|
||||
1 & & & & & \\
|
||||
2 & & & & & \\
|
||||
3 & & & & & \\
|
||||
4 & & & & & \\
|
||||
5 & & & & & \\
|
||||
6 & & & & & \\
|
||||
7 & & & & & \\
|
||||
8 & & & & & \\
|
||||
\end{tabular}
|
||||
\end{figure}
|
||||
|
||||
|
||||
@ -1,30 +0,0 @@
|
||||
<!DOCTYPE html>
|
||||
<html>
|
||||
<head>
|
||||
<meta charset="utf8" />
|
||||
<title>Le titre de la fenêtre</title>
|
||||
|
||||
<!-- La ligne suivante demande au navigateur de télécharger une feuille de style au format CSS nommée mon_style.css -->
|
||||
<link rel="stylesheet" type="text/css" href="mon_style.css" />
|
||||
</head>
|
||||
<body>
|
||||
<!-- Écrivez le contenu de votre page au format HTML ici -->
|
||||
<h1>Vivre les camemberts normands</h1>
|
||||
<p id="paragraphe" >Merci d’avoir lu cette magnifique page web…</p>
|
||||
<button onclick="this.innerText = Date()">Quelle heure est il ?</button>
|
||||
|
||||
<!-- Voici comment faire un lien : -->
|
||||
<a href="https://google.fr">Ceci est un lien vers la recherche de Google</a>
|
||||
|
||||
<!-- Voici comment ajouter une image : -->
|
||||
<!-- width est la largeur, height est la hauteur -->
|
||||
<!-- Mettre que height ou que width permet de garder les proportions de l'image -->
|
||||
<img width="200px" height="100px" src="https://lechariotafromages.fr/665-large_default/camembert-de-normandie.jpg" />
|
||||
|
||||
<!-- Mettez bien votre nom ici -->
|
||||
<footer>Page créée par Jaune Attend pour le cours de SNT au lycée Buissonnier</footer>
|
||||
|
||||
<!-- La ligne suivante exécute le javascript du fichier script.js -->
|
||||
<script src="script.js"></script>
|
||||
</body>
|
||||
</html>
|
||||
@ -1,3 +0,0 @@
|
||||
document.getElementById('paragraphe').innerText="lol"
|
||||
document.getElementById('paragraphe').style="color:red;"
|
||||
|
||||
@ -1,186 +0,0 @@
|
||||
----------------------- Recherche d'un élément dans un tableau -----------------------
|
||||
|
||||
Données :
|
||||
L un tableau de nombre
|
||||
N le nombre d'éléments dans le tableau
|
||||
E l'élément que l'on cherche
|
||||
|
||||
Résultat :
|
||||
Vrai : si l'élément est dans le tableau
|
||||
Faux : S'il n'y est pas
|
||||
|
||||
Algorithme :
|
||||
pour compteur allant de 0 à N-1 faire
|
||||
si L[compteur] <- E alors
|
||||
on renvoie Vrai et on termine le programme
|
||||
finsi
|
||||
finpour
|
||||
on renvoie Faux
|
||||
|
||||
|
||||
----------------------- Calcul de la moyenne des nombre d'un tableau -----------------------
|
||||
|
||||
Données :
|
||||
L un tableau de nombre
|
||||
N le nombre d'éléments dans le tableau
|
||||
|
||||
Résultat :
|
||||
la moyenne des éléments de L
|
||||
|
||||
Algorithme :
|
||||
M <- 0
|
||||
compteur <- 0
|
||||
pour compteur allant de 0 à N-1 faire
|
||||
M <- M+L[compteur]
|
||||
finpour
|
||||
M <- M/N
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
----------------------- Calcul de la somme des nombres d'un tableau -----------------------
|
||||
|
||||
Données :
|
||||
L un tableau de nombre
|
||||
N le nombre d'éléments dans le tableau
|
||||
|
||||
Résultat :
|
||||
la somme des éléments de L
|
||||
|
||||
Algorithme :
|
||||
<- 0
|
||||
compteur <- 0
|
||||
pour compteur allant de 0 à N-1 faire
|
||||
m <- M+L[compteur]
|
||||
finpour
|
||||
|
||||
|
||||
|
||||
----------------------- Recherche du minimum d'un tableau -----------------------
|
||||
|
||||
Données :
|
||||
L un tableau de nombre
|
||||
N le nombre d'éléments dans le tableau
|
||||
|
||||
Résultat :
|
||||
le minimum des éléments de L
|
||||
|
||||
Algorithme :
|
||||
<- L[0]
|
||||
compteur <- 0
|
||||
pour compteur allant de 0 à N-1 faire
|
||||
si M > L[compteur] alors
|
||||
M <- L[compteur]
|
||||
finsi
|
||||
finpour
|
||||
|
||||
|
||||
----------------------- Tri par sélection -----------------------
|
||||
Données :
|
||||
T : Un tableau d’éléments indexés de 0 à N-1
|
||||
|
||||
Résultat :
|
||||
T : Le tableau sera trié
|
||||
|
||||
Algorithme :
|
||||
N <- longeur(T)
|
||||
pour i allant de 0 à N-2 faire
|
||||
Imin <- i
|
||||
pour j allant de i+1 à N-1 faire
|
||||
si T[j] < T[Imin] alors
|
||||
Imin <- j
|
||||
finsi
|
||||
finpour
|
||||
échanger T[i] et T[Imin]
|
||||
finpour
|
||||
|
||||
|
||||
----------------------- Tri par insertion -----------------------
|
||||
Données :
|
||||
T : Un tableau d’éléments indexés de 0 à N-1
|
||||
|
||||
Résultat :
|
||||
T : Le tableau sera trié
|
||||
|
||||
Algorithme :
|
||||
N <- longeur(T)
|
||||
pour i allant de 1 à N-1 faire
|
||||
j <- i
|
||||
tant que j>0 et T[j] > T[j-1] faire
|
||||
échanger T[j] et T[j-1]
|
||||
j <- j-1
|
||||
fintantque
|
||||
finpour
|
||||
|
||||
|
||||
|
||||
----------------------- Recherche dichotomique -----------------------
|
||||
|
||||
Données :
|
||||
L : un tableau trié par ordre croissant et non vide, indexé de 0 à N-1
|
||||
El : l'élément que l'on cherche
|
||||
|
||||
Résultat :
|
||||
Trouvé : Si l'élément est dans le tableau
|
||||
Pas trouvé : Sinon
|
||||
|
||||
Algorithme :
|
||||
Bmin <- 0
|
||||
Bmax <- longueur(L)-1
|
||||
tant que Bmin <= Bmax faire
|
||||
med <- (Bmin+Bmax) // 2
|
||||
si L[med] > El alors
|
||||
Bmax <- med-1
|
||||
sinon si L[med] < El alors
|
||||
Bmin <- med+1
|
||||
sinon faire
|
||||
renvoyer 'Trouvé'
|
||||
finsi
|
||||
fintantque
|
||||
renvoyer 'Pas trouvé'
|
||||
|
||||
|
||||
----------------------- Rendu de monaie -----------------------
|
||||
|
||||
Données :
|
||||
P le tableau de pièces que l'on peut rendre
|
||||
arendre le montant à rendre
|
||||
|
||||
Algorithme :
|
||||
pour compteur allant de 0 à longueur(L):
|
||||
tant que P[compteur] <= arendre faire
|
||||
rendre P[compteur]
|
||||
arendre <- arendre - P[compteur]
|
||||
fintantque
|
||||
finpour
|
||||
|
||||
----------------------- K plus proches voisins -----------------------
|
||||
Notes :
|
||||
- Seul le principe est à connaitre, pas le calcul spécifique de la distance.
|
||||
|
||||
Données :
|
||||
T un tableau (0,N-1) contenant les données d’entrainement
|
||||
Chaque élément du tableau est un tuple contenant la position sur le
|
||||
graphique et la classe : (X, Y, nom)
|
||||
E un élément dont on connait la position et dont on veut estimer la classe
|
||||
C’est également un tuple mais sans classe : (X, Y)
|
||||
k le nombre de voisins dont on va regarder la classe
|
||||
|
||||
Algorithme :
|
||||
# Ce tableau contiendra des tuples (distance, classe)
|
||||
distances <- tableau vide de taille N
|
||||
pour i allant de 0 à N-1 faire
|
||||
distances[i] <- ( racine( (E[0]-T[i][0])^2 + (E[1]-T[i][1])^2) , T[i][2])
|
||||
finpour
|
||||
|
||||
distances_triées <- distances trié par distance croissante
|
||||
|
||||
voisins <- []
|
||||
pour i allant de 0 à k-1 faire
|
||||
voisins <- voisins suivi de distances_triées[i][1]
|
||||
finpour
|
||||
|
||||
Compter le nombre d’occurence de chaque classe dans le tableau voisins
|
||||
classe <- la classe avec le plus d’occurences
|
||||
renvoyer classe
|
||||
@ -1,43 +0,0 @@
|
||||
\documentclass[11pt,a4paper]{../../template/template_cours}
|
||||
\usepackage{enumitem} % pour reprendre des énums en cours
|
||||
|
||||
\title{Contrôle}
|
||||
\author{Adrian Amaglio}
|
||||
\def\thesequence{Les algorithmes}
|
||||
\def\thelevel{NSI première}
|
||||
|
||||
\begin{document}
|
||||
\maketitle
|
||||
Tout moyen de communication, appareil électronique ou document est interdit. Toute triche engendrera des points en moins sur la note finale.\\
|
||||
|
||||
\subsection*{Moyenne d’un tableau}
|
||||
\terseQ{Écrivez un algorithme permettant de calculer la moyenne des éléments d’un tableau.}\\
|
||||
\terseQ{Quelle est sa complexité dans le meilleur cas, le pire cas et en moyenne ?}
|
||||
|
||||
\subsection*{Tri par sélection}
|
||||
\terseQ{Expliquez le principe du tri par sélection.}\\
|
||||
\terseQ{Écrivez un algorithme de tri par sélection.}\\
|
||||
\terseQ{Quelle est sa complexité dans le meilleur cas, le pire cas et en moyenne ?}\\
|
||||
\terseQ{Montrez la correction de cet algorithme de tri.}
|
||||
Vous utiliserez comme invariant le fait que la partie gauche du tableau est toujours triée.
|
||||
Si votre boucle principale va de i à N (la taille du tableau), l’invariante sera la proposition suivante :\\
|
||||
Le tableau est trié entre les indices 0 et i.
|
||||
|
||||
\subsection*{Recherche dichotomique}
|
||||
\terseQ{Expliquez le principe de la recherche dichotomique.}\\
|
||||
\terseQ{Écrivez l’algorithme de recherche dichotomique.}\\
|
||||
\terseQ{Montrer la terminaison de cet algorithme.}
|
||||
Vous pourrez utiliser le variant suivant : borne\_max - borne\_min décroit strictement à chaque tour de boucle.
|
||||
|
||||
\subsection*{K plus proches voisins}
|
||||
\terseQ{Expliquez le principe de l’algorithme des K plus proches voisins.}\\
|
||||
\terseQ{Écrivez l’algorithme des K plus proches voisins.}
|
||||
Vous pouvez rester vague dans les instructions comme vu en cours.\\
|
||||
\terseQ{Quelle est sa complexité dans le meilleur, le pire cas et en moyenne ?}
|
||||
|
||||
\subsection*{Rendu de monnaie}
|
||||
\terseQ{Expliquez le principe de l’algorithme du rendu de monnaie.}\\
|
||||
\terseQ{Écrivez cet algorithme.}\\
|
||||
\terseQ{\textit{Bonus} Lorsqu’on l’implémente ne python quel problème rencontre-t-on si l’on souhaite rendre 2,85 € ?}
|
||||
|
||||
\end{document}
|
||||
@ -1,11 +0,0 @@
|
||||
Barème de notation :
|
||||
- Votre programme devra être découpé en plusieurs fonctions, chaque fonction doit avoir un rôle donné. /3
|
||||
- Chaque fonction devra avoir sa « docstring » qui précisera le rôle et le type de chaque paramètre. /3
|
||||
- Quand c’est pertinent, les fonctions devront fixer des préconditions sur les paramètres à l’aide de l’instruction « assert » /2
|
||||
- Quand c’est pertinent, les fonctions devront fixer des postconditions sur leur résultat à l’aide de l’instruction « assert » /2
|
||||
- Chaque fonction devra être testée individuellement (ce que l’on appelle des tests unitaires) à l’aide de l’instruction « assert ». /3
|
||||
- Votre programme devra avoir une interface graphique (avec tkinter par exemple) /3
|
||||
- votre programme a au moins un bouton qui provoque un changement lorsqu’il est cliqué /2
|
||||
- votre programme a au moins un texte qui change après une action d’un·e utilisateur·ice /2
|
||||
- Bonus : Votre programme peut aussi être lancé avec une interface texte (pas de fenêtre, juste des print et des input) /2
|
||||
- Bonus : Votre programme fonctionne bien /2
|
||||
@ -1,57 +0,0 @@
|
||||
from tkinter import *
|
||||
|
||||
###############################################################################
|
||||
# Fonction de navigation entre les fenêtres
|
||||
###############################################################################
|
||||
|
||||
def afficher_fenetre1():
|
||||
racine.withdraw() # cacher la fenetre racine
|
||||
fenetre1.deiconify() # afficher la fenetre1
|
||||
|
||||
def afficher_racine():
|
||||
fenetre1.withdraw() # cacher la fenetre racine
|
||||
racine.deiconify() # afficher la fenetre1
|
||||
|
||||
|
||||
###############################################################################
|
||||
# Définitions de la fenêtre racine
|
||||
###############################################################################
|
||||
|
||||
# La fenêtre racine. Il ne peut y en avoir qu’une.
|
||||
racine = Tk()
|
||||
|
||||
# On met un label sur la racine pour identifier la fenêtre.
|
||||
label1 = Label(racine, text="""Ceci est la fenêtre racine, l’application se termine lorsqu’on la ferme.""")
|
||||
label1.pack()
|
||||
|
||||
# On a un bouton qui ouvre une nouvelle fenetre
|
||||
button1 = Button(racine, text="afficher", command=afficher_fenetre1)
|
||||
button1.pack()
|
||||
|
||||
###############################################################################
|
||||
# Définitions de la fenêtre 1
|
||||
###############################################################################
|
||||
|
||||
# On peut créer autant de fenêtres toplevel que l’on veut
|
||||
fenetre1 = Toplevel(racine)
|
||||
label2 = Label(fenetre1, text="""Ceci est une fenêtre en plus, la fermer n’affectera pas les autres.""")
|
||||
label2.pack()
|
||||
|
||||
# Un bouton pour quiter le programme. Il appelle la fonction racine.quit()
|
||||
bouton_quiter = Button(fenetre1, text="quiter", command=racine.quit)
|
||||
bouton_quiter.pack()
|
||||
|
||||
# Un bouton qui revient à la fenetre racine
|
||||
bouton_racine = Button(fenetre1, text="Retour", command=afficher_racine)
|
||||
bouton_racine.pack()
|
||||
|
||||
# On cache la fenetre1
|
||||
fenetre1.withdraw()
|
||||
|
||||
|
||||
###############################################################################
|
||||
# Démarrage du programme
|
||||
###############################################################################
|
||||
|
||||
racine.mainloop()
|
||||
|
||||
@ -1,44 +0,0 @@
|
||||
from tkinter import *
|
||||
###############################################################################
|
||||
# Fonctions de la fenêtre 1
|
||||
###############################################################################
|
||||
def start_game():
|
||||
print('lol')
|
||||
fen1.quit()
|
||||
fen2.mainloop()
|
||||
|
||||
###############################################################################
|
||||
# Définition de la fenêtre 1
|
||||
###############################################################################
|
||||
fen1=Tk()
|
||||
fen1.title("Accueil")
|
||||
|
||||
t1=Label(fen1,text="")
|
||||
t1.grid(row=0,column=0)
|
||||
|
||||
j1=Entry(fen1,bg="grey",bd=4)
|
||||
j1.grid(row=2,column=0)
|
||||
|
||||
b1=Button(fen1,text="entrer", command=start_game)
|
||||
b1.grid(row=2,column=1)
|
||||
|
||||
|
||||
|
||||
###############################################################################
|
||||
# Définition de la fenêtre 1
|
||||
###############################################################################
|
||||
|
||||
fen2=Tk()
|
||||
fen2.title("Page de jeu")
|
||||
|
||||
b1=Button(fen2,text="PIERRE")
|
||||
b1.grid(row=2,column=1)
|
||||
|
||||
b2=Button(fen2,text="FEUILLE")
|
||||
b2.grid(row=2,column=2)
|
||||
|
||||
b3=Button(fen2,text="CISEAUX", command=fen2.quit)
|
||||
b3.grid(row=2,column=3)
|
||||
|
||||
if __name__ == '__main__':
|
||||
fen1.mainloop()
|
||||
@ -1,13 +0,0 @@
|
||||
def pair(n):
|
||||
if n % 2 == 0:
|
||||
return True
|
||||
else:
|
||||
return False
|
||||
|
||||
def tests():
|
||||
assert pair(0) == True
|
||||
assert pair(-1) == False
|
||||
assert pair(2) == True
|
||||
print('Tous les tests ont été fait')
|
||||
|
||||
tests()
|
||||
@ -1,122 +0,0 @@
|
||||
\documentclass[11pt,a4paper]{../../template/template_cours}
|
||||
|
||||
\usepackage{minted}
|
||||
|
||||
\title{TP noté sur Python}
|
||||
\author{Adrian Amaglio}
|
||||
\def\thelevel{NSI}
|
||||
\def\thesequence{Programmation}
|
||||
|
||||
\begin{document}
|
||||
Durée : 1h
|
||||
|
||||
% ---
|
||||
\section{Dessiner des pyramides}
|
||||
L’objectif de cette partie est de concevoir un programme python capable d’afficher des pyramides de texte. Voici par exemple une pyramide d’étoiles de 4 étages :
|
||||
\begin{verbatim}
|
||||
*
|
||||
* *
|
||||
* * *
|
||||
* * * *
|
||||
\end{verbatim}
|
||||
Nous allons pour cela créer une fonction affichant une ligne de longueur donnée et d’un symbole donné puis une fonction, utilisant la précédente, capable d’afficher une pyramide de hauteur donnée.
|
||||
Cette partie sera à faire dans un fichier nommé \textit{pyramide.py}.
|
||||
|
||||
\begin{exercice}
|
||||
Créer une fonction appelée \textit{ligne}, prenant en paramètre un symbole (type texte ou \textit{str} en python) et une taille de ligne.\\
|
||||
Cette fonction affichera le symbole autant de fois que demandé dans le paramètre taille.\\
|
||||
\textit{Aide :} Pour afficher du texte sans retour à la ligne on ajoute un paramètre \textit{end} à print :\\
|
||||
\begin{minted}{python}
|
||||
print('Bonsoir !', end='')
|
||||
\end{minted}
|
||||
Tester la fonction ligne avec plusieurs valeurs pour vérifier son bon fonctionnement. Voici des exemples de test :
|
||||
\begin{minted}{python}
|
||||
ligne('*', 10)
|
||||
ligne('.', 1)
|
||||
ligne('o', 5)
|
||||
\end{minted}
|
||||
\end{exercice}
|
||||
|
||||
\begin{exercice}
|
||||
Créer une fonction \textit{pyramide}, qui prend en paramètre une hauteur et un symbole et qui dessine la pyramide correspondante en utilisant la fonction \textit{ligne}.
|
||||
\end{exercice}
|
||||
|
||||
\begin{exercice}
|
||||
Dessinez trois pyramides avec des symboles et des hauteurs différentes.
|
||||
\end{exercice}
|
||||
|
||||
|
||||
% ---
|
||||
\section{Jeu de morpion}
|
||||
L’objectif de cette partie est de concevoir un jeu de morpion (ou tic-tac-toe).
|
||||
Cette partie sera à faire dans un fichier nommé \textit{morpion.py}.\\
|
||||
Le plateau de jeu sera représenté par une liste contenant trois liste (une pour chaque ligne du plateau).
|
||||
Chaque ligne sera représentée par une liste de trois textes (str) qui peuvent avoir trois valeurs distinctes :
|
||||
\begin{description}
|
||||
\item[' '] Si la case est vide
|
||||
\item['x'] Si la case contient une croix
|
||||
\item['o'] Si la case contient un rond
|
||||
\end{description}
|
||||
|
||||
|
||||
\begin{exercice}
|
||||
En haut de votre fichier \textit{morpion.py}, collez la ligne de python suivante :
|
||||
\begin{minted}{python}
|
||||
plateau = [ [' ', ' ', ' '], [' ', ' ', ' '], [' ', ' ', ' '] ]
|
||||
\end{minted}
|
||||
Vérifiez que votre fichier s’exécute bien et n’affiche rien.
|
||||
\end{exercice}
|
||||
|
||||
\begin{exercice}
|
||||
Créer une fonction nommée \textit{afficher} qui affiche en texte le plateau de jeu. Elle prendra le plateau de jeu en paramètre.\\
|
||||
\end{exercice}
|
||||
|
||||
\begin{exercice}
|
||||
Créer une fonction nommée \textit{jouer} qui prend quatre paramètres :
|
||||
\begin{itemize}
|
||||
\item Le plateau de jeu
|
||||
\item Le symbole à jouer (x ou o)
|
||||
\item La ligne où on souhaite jouer
|
||||
\item La colonne où on souhaite jouer
|
||||
\end{itemize}
|
||||
Cette fonction modifiera le plateau pour mettre le symbole à l’emplacement voulu.
|
||||
Aucune vérification n’est faite à cette étape du programme, les coups de triche sont possibles.
|
||||
\end{exercice}
|
||||
|
||||
\begin{exercice}
|
||||
Testez vos deux fonctions précédentes en les appelant avec des valeurs choisies.
|
||||
Voici un exemple de test à modifier et enrichir :
|
||||
\begin{minted}{python}
|
||||
afficher(plateau)
|
||||
jouer(plateau, 'x', 0, 0)
|
||||
afficher(plateau)
|
||||
\end{minted}
|
||||
\end{exercice}
|
||||
|
||||
\begin{exercice}
|
||||
Modifier la fonction \textit{jouer} pour qu’elle vérifie de le coup demandé est valide.
|
||||
La fonction doit maintenant retourner True si le coup a été joué et False si il est invalide.\\
|
||||
Tester à nouveau la fonction.
|
||||
\end{exercice}
|
||||
|
||||
\begin{exercice}
|
||||
Créer une fonction \textit{partie} qui prend le plateau en paramètre et qui déroule une partie. Voici le principe de base.
|
||||
\begin{itemize}
|
||||
\item Demander au premier joueur où il souhaite jouer
|
||||
\item Appeler la fonction jouer avec les paramètres correspondants
|
||||
\item Demander au second joueur où il souhaite jouer
|
||||
\item Appeler la fonction jouer avec les paramètres correspondants
|
||||
\end{itemize}
|
||||
Vérifiez que votre fonction :
|
||||
\begin{itemize}
|
||||
\item Gère correctement les cas où le coup est invalide
|
||||
\item Utilise bien le symbole 'x' pour un joueur et 'o' pour l’autre
|
||||
\end{itemize}
|
||||
|
||||
\end{exercice}
|
||||
|
||||
\begin{exercice}
|
||||
Créer une fonction \textit{victoire} qui prend le plateau en paramètre et retourne le symbole 'x' si trois x sont alignés, 'o' si trois o sont alignés ou ' ' si aucun joueur n’a gagné.
|
||||
Utilisez cette fonction dans votre fonction \textit{partie}
|
||||
\end{exercice}
|
||||
\end{document}
|
||||
@ -1,33 +0,0 @@
|
||||
# Exercice 1
|
||||
# Modifiez la boucle présente à la fin du fichier pour qu’elle remplisse le dictionnaire frequences.
|
||||
# Pour ce faire, il faut ajouter 1 à la valeur corresponant à une lettre dès qu’on la rencontre lors du parcours du texte
|
||||
# Certaines valeurs vont poser problème à notre dictionnaire, tester bien que seules les lettres sont utilisées comme clé.
|
||||
|
||||
# Exercice 2
|
||||
# Affichez les valeurs des lettres eiatsr divisées par le nombre total de lettres dans le texte. Vous obtenez un ratio qui sera grand pour les lettres très utilisées.
|
||||
# Comparez ce ratio avec celui que l’on attribue souvent au français (recherez le sur internet).
|
||||
|
||||
|
||||
|
||||
# Texte issu de wikipédia
|
||||
# https://fr.wikipedia.org/wiki/Journée_du_souvenir_trans
|
||||
texte = """
|
||||
la journée du souvenir trans, déclinaison française du transgender day of remembrance (tdor), a lieu le 20 novembre dans le monde entier, pour commémorer les personnes trans assassinées pour motif transphobe, c’est-à-dire la haine des personnes trans, et pour attirer l'attention sur les violences subies par les communautés trans4.
|
||||
la journée du souvenir trans a plusieurs objectifs :
|
||||
commémorer toutes les personnes ayant été victimes de crimes haineux et de préjugés,
|
||||
sensibiliser sur les crimes haineux envers la communauté trans,
|
||||
rendre hommage aux personnes décédées et à leurs proches.
|
||||
si cette journée marque la solidarité de la communauté lgbt à l’égard des victimes et témoigne de son indignation, elle veut aussi rappeler que la transphobie n’est pas reconnue comme discrimination ou circonstance aggravante pour les crimes par l’état.
|
||||
il en résulte qu’aucune statistique officielle n’est disponible. en 2011, 221 cas de personnes trans assassinées furent comptabilisés par les associations trans.
|
||||
ce nombre ne représente pas la réalité puisque le comptage est effectué localement par un nombre réduit d’organisations et dans peu de pays. de plus, la plupart des crimes restent ignorés puisque le caractère transphobe n’est pas retenu par les autorités.
|
||||
"""
|
||||
|
||||
# Ce dictionnaire contiendra en clé les lettres de l’alphabet, en valeur le nombre de fois qu’elles sont apparues dans le texte.
|
||||
frequences = {'a':0, 'b':0, 'c':0, 'd':0, 'e':0, 'f':0, 'g':0, 'h':0, 'i':0, 'j':0, 'k':0, 'l':0, 'm':0, 'n':0, 'o':0, 'p':0, 'q':0, 'r':0, 's':0, 't':0, 'u':0, 'v':0, 'w':0, 'x':0, 'y':0, 'z':0}
|
||||
|
||||
# Cette boucle permet de parcourir le texte, lettre par lettre. À chaque tour de boucle la variable lettre contiendra toutes les lettres du texte, une à une, dans l’ordre.
|
||||
for lettre in texte:
|
||||
# On affiche le texte lettre par lettre.
|
||||
print(lettre, end='')
|
||||
|
||||
print(frequences)
|
||||
@ -1,16 +0,0 @@
|
||||
# Voici un dictionnaire dont la clé est un nom, la valeur une liste de notes
|
||||
notes = {'John' : [10, 8, 14], 'Amaglio': [2, 8, 0.5], 'Aya': [18, 20, 25]}
|
||||
|
||||
# Exercice 1
|
||||
# Affichez le nom et les notes de chaque personne répertoriée dans le dictionnaire notes.
|
||||
|
||||
# Exercice 2
|
||||
# Pour chaque personne, calculez sa moyenne. Vous la stockerez dans un nouveau dictionnaire que vous appellerez moyenne.
|
||||
# Affichez ensuite les noms et moyennes de chaque personne.
|
||||
|
||||
# Exercice 3
|
||||
# Créez un dictionnaire nommé classes dans lequel les clés seront des noms de classe (par exemple seconde18) et les valeurs seront les noms des personnes de cette classe.
|
||||
# Vous pourrez attribuer les personnes du dictionnaire à des classes, il faut au moins une classe qui ait plusieurs personnes.
|
||||
|
||||
# Exercice 4
|
||||
# Créez un dictionnaire nommé moyennes dans lequel les clés seront les noms de classe et les valeurs seront les moyennes de cette classe
|
||||
BIN
projets/projet_biere/circuit.png
Normal file
BIN
projets/projet_biere/circuit.png
Normal file
Binary file not shown.
|
After Width: | Height: | Size: 46 KiB |
92
projets/projet_biere/main.py
Normal file
92
projets/projet_biere/main.py
Normal file
@ -0,0 +1,92 @@
|
||||
import time
|
||||
|
||||
# --------------------------------------------------------------------------------
|
||||
# Gestion des pages web
|
||||
# --------------------------------------------------------------------------------
|
||||
|
||||
import bottle, threading
|
||||
|
||||
def nouvelle_temp_cible (temperature):
|
||||
""" Cette fonction sauvegarde la température cible """
|
||||
with open('cible.txt', 'w', coding="utf8") as f:
|
||||
f.write(température)
|
||||
|
||||
def temp_format_html ():
|
||||
""" Cette fonction retourne un texte HTML contenant les mesures de températures"""
|
||||
return 'Non implémenté'
|
||||
|
||||
|
||||
@bottle.get('/')
|
||||
def get_temp():
|
||||
return temp_format_html()
|
||||
|
||||
threading.Thread(target=bottle.run, kwargs=dict(host='', port=8080)).start()
|
||||
|
||||
# --------------------------------------------------------------------------------
|
||||
# Gestion du capteur de température
|
||||
# --------------------------------------------------------------------------------
|
||||
|
||||
import os
|
||||
import glob
|
||||
|
||||
# On trouve où sont les valeurs du capteurs
|
||||
dossier_base = '/sys/bus/w1/devices/'
|
||||
dossier_capteur = glob.glob(dossier_base + '28*')[0]
|
||||
fichier_capteur = dossier_capteur + '/w1_slave'
|
||||
fichier_actionneur = 'TODO'
|
||||
|
||||
def lecture_temp_brute():
|
||||
""" Cette fonction retourne la valeur du capteur sans traitement """
|
||||
with open(fichier_capteur, 'r') as f:
|
||||
lines = f.readlines()
|
||||
return lines
|
||||
|
||||
def lecture_temp():
|
||||
""" Cette fonction calcule la température à partir des mesures brutes """
|
||||
lines = lecture_temp_brute()
|
||||
while lines[0].strip()[-3:] != 'YES':
|
||||
time.sleep(0.2)
|
||||
lines = lecture_temp_brute()
|
||||
equals_pos = lines[1].find('t=')
|
||||
if equals_pos != -1:
|
||||
temp_string = lines[1][equals_pos+2:]
|
||||
temp_c = float(temp_string) / 1000.0
|
||||
return temp_c
|
||||
|
||||
# --------------------------------------------------------------------------------
|
||||
# Gestion du capteur de température
|
||||
# --------------------------------------------------------------------------------
|
||||
|
||||
def chauffage_on ():
|
||||
""" Cette fonction allume le chauffage de la cuve """
|
||||
with open(fichier_actionneur, 'w') as f:
|
||||
f.write('1')
|
||||
|
||||
def chauffage_off ():
|
||||
""" Cette fonction éteint le chauffage de la cuve """
|
||||
with open(fichier_actionneur, 'w') as f:
|
||||
f.write('0')
|
||||
|
||||
# --------------------------------------------------------------------------------
|
||||
# Fonctions d’aide
|
||||
# --------------------------------------------------------------------------------
|
||||
|
||||
def ajout_ligne_fichier(nom_fichier, ligne):
|
||||
""" Cette fonction ajoute le texte dans la variable ligne à la fin du fichier « nom_fichier » """
|
||||
with open(nom_fichier, 'a', encoding="utf8") as f:
|
||||
f.write(ligne)
|
||||
|
||||
def temp_cible():
|
||||
""" Cette fonction retourne la température cible qui doit être maintenue pendant la fermentation """
|
||||
with open("cible.txt", 'r', coding="utf8") as f:
|
||||
return f.read().strip()
|
||||
|
||||
# --------------------------------------------------------------------------------
|
||||
# Programme principal
|
||||
# --------------------------------------------------------------------------------
|
||||
|
||||
while True:
|
||||
print(lecture_temp())
|
||||
time.sleep(1)
|
||||
|
||||
|
||||
BIN
projets/projet_biere/sujet.pdf
Normal file
BIN
projets/projet_biere/sujet.pdf
Normal file
Binary file not shown.
77
projets/projet_biere/sujet.tex
Normal file
77
projets/projet_biere/sujet.tex
Normal file
@ -0,0 +1,77 @@
|
||||
\documentclass[11pt,a4paper]{../../template/template_cours}
|
||||
\usepackage{listings}
|
||||
|
||||
\usepackage{minted}
|
||||
|
||||
\title{Projet pluridisciplinaire — Le brassage de la bière}
|
||||
\author{Adrian Amaglio}
|
||||
\def\thesequence{Données structurées, web}
|
||||
|
||||
\begin{document}
|
||||
Ceci est une trame à suivre, les détails techniques ne sont pas réglés.
|
||||
Durée : 3h
|
||||
|
||||
%
|
||||
% https://pimylifeup.com/raspberry-pi-temperature-sensor/
|
||||
\section{Microcontrolleur programmable}
|
||||
Nous travaillerons sur un raspberry pi pour récupérer les valeurs des capteurs.
|
||||
|
||||
\subsection{Mesure de la température}
|
||||
% En vrai on peut aussi mesurer la pression et le pH
|
||||
Durée : 1h
|
||||
\begin{exercice}
|
||||
Connectez le capteur de température et la résistance au raspberry pi comme sur le shéma suivant :
|
||||
\includegraphics[width=\textwidth]{circuit.png}
|
||||
\end{exercice}
|
||||
|
||||
\begin{exercice}
|
||||
Récupérez le fichier python à cette adresse : \url{https://git.jean-cloud.net/adrian/cours-snt/raw/branch/master/projets/projet_biere/main.py}
|
||||
\\
|
||||
et exécutez-le sur votre raspberry pi.
|
||||
Vérifiez qu’il affiche bien la valeur de la température chaque seconde
|
||||
\end{exercice}
|
||||
|
||||
\begin{exercice}
|
||||
Modifiez le programme principal pour qu’il écrive dans un fichier CSV, la date, l’heure actuelle et la température mesurée.
|
||||
Votre fichier CSV devra ressembler à cela :
|
||||
\begin{verbatim}
|
||||
date;heure;temperature
|
||||
11/02/2021;15:14:10;22
|
||||
11/02/2021;15:15:10;21
|
||||
11/02/2021;15:16:10;21
|
||||
11/02/2021;15:17:10;20
|
||||
11/02/2021;15:18:10;20
|
||||
\end{verbatim}
|
||||
|
||||
Vous pourrez vous aider de la fonction « ajout\_ligne\_fichier » disponible dans le fichier python que vous avez téléchargé.
|
||||
\end{exercice}
|
||||
|
||||
|
||||
\subsection{Régulation du chauffage}
|
||||
Durée 1h
|
||||
|
||||
\begin{exercice}
|
||||
Le chauffage de la cuve de fermentation n’est pas réglable, le chauffage est donc mis à fond pour faire monter la température, puis eteint lorqu’elle est acceptable.
|
||||
\\
|
||||
La fonction « temp\_cible » retourne la valeur de la température idéale pour la fermentation.
|
||||
\\
|
||||
Dans votre programme principal, activez le chauffage si nécessaire (en fonction de la température relevée) pour que la température soit optimale dans la cuve.
|
||||
\\
|
||||
Vous vous aidere des fonctions « chauffage\_on » et « chauffage\_off » fournies.
|
||||
\end{exercice}
|
||||
|
||||
\subsection{Affichage des mesures sur une page web}
|
||||
Durée 1h
|
||||
\begin{exercice}
|
||||
Exécutez votre programme python puis rendez-vous à l’adresse \url{http://localhost:8080}. Vous devriez voir le message « Non implémenté ».
|
||||
\\
|
||||
Pour que cette page web affiche la liste des températures mesurées, modifiez la fonction « temp\_format\_html » pour qu’elle génère un code HTML qui met en forme les mesures dans un tableau.
|
||||
\end{exercice}
|
||||
|
||||
\begin{exercice}
|
||||
Bonus : Ajoutez une page « /reglage » qui affiche un formulaire pour que l’utilisateur puisse renseigner une température à maintenir.
|
||||
\\
|
||||
Faites en sorte que lorsque l’utilisateur valide le formulaire, la valeur qu’il a entré soit passée à la fonction « nouvelle\_temp\_cible ».
|
||||
\end{exercice}
|
||||
|
||||
\end{document}
|
||||
Binary file not shown.
@ -37,7 +37,7 @@ left(45)
|
||||
|
||||
\section{Triangles, carrés et plus si affinités}
|
||||
|
||||
Voici un programme Python qui trace deux traits de 50 pixels
|
||||
Voici un programme Python qui trace deux traits de 100 pixels
|
||||
\begin{example}
|
||||
\begin{minted}{python}
|
||||
forward(50)
|
||||
@ -52,11 +52,11 @@ forward(50)
|
||||
\end{exercice}
|
||||
|
||||
\begin{exercice}
|
||||
Complétez ce programme pour qu’il dessine un triangle.
|
||||
Complétez ce programme pour qu’il affiche un triangle.
|
||||
\end{exercice}
|
||||
|
||||
\begin{exercice}
|
||||
Modifiez maintenant ce programme Python pour qu’il dessine un carré (polygone régulier à 4 côtés).
|
||||
Modifiez ce programme Python pour qu’il dessine un carré (polygone régulier à 4 côtés).
|
||||
\end{exercice}
|
||||
|
||||
\begin{exercice}
|
||||
@ -67,7 +67,7 @@ forward(50)
|
||||
%
|
||||
\section{Répétons des instructions}
|
||||
\begin{example}
|
||||
Vous aurez remarqué que pour tracer des polygones, on répète les instructions forward et left.
|
||||
Vous aurez remarqué que pour tracer des polygones, on copie colle les instructions forward et left.
|
||||
Pour éviter cette pratique inefficace, nous allons utiliser une boucle pour répéter des instructions.
|
||||
Par exemple, le programme suivant trace un triangle en répétant trois fois les instructions forward et left.
|
||||
\begin{minted}{python}
|
||||
@ -109,7 +109,7 @@ for compteur in range(nb_cotes):
|
||||
|
||||
|
||||
\section{Écrire un sous-programme}
|
||||
Pour tracer plusieurs polygone, il nous faudrait répéter notre programme.
|
||||
Pour tracer plusieurs polygone, il nous faudrait copier-coller notre programme.
|
||||
Le résultat serait difficile à lire et donc à comprendre…
|
||||
Nous allons créer une fonction (c’est un sous-programme) capable de tracer n’importe quel polygone.
|
||||
Nous pourrons alors exécuter ce sous-programme dès que besoin.
|
||||
@ -141,12 +141,11 @@ end_fill()
|
||||
Écrivez un programme qui trace un damier de 6 cases par 6 cases.
|
||||
Les couleurs des cases doivent alterner blanc et noir.
|
||||
\\\textbf{Faites vérifier le programme par le professeur}
|
||||
\\Étapes conseillées :
|
||||
\\Indices :
|
||||
\begin{itemize}
|
||||
\item Écrivez une fonction carreB() traçant un carré et carreN() traçant un carré noir. Vous pourrez ainsi construire le damier à l’aide de ces deux fonctions.
|
||||
\item Écrivez une fonction ligneB() qui trace une ligne de damier (c’est à dire 3 carrés noirs alternés avec 3 carrés blancs) qui commence par un carré blanc.
|
||||
\item Écrivez une fonction ligneN() qui trace une ligne de damier qui commence par un carré noir.
|
||||
\item Essayez ensuite d’exécuter plusieurs fois les fonctions ligneB() et ligneN() pour tracer le damier.
|
||||
\item Écrivez une fonction carre() traçant un carré et carreN() traçant un carré noir. Vous pourrez ainsi construire le damier à l’aide de ces deux fonctions.
|
||||
\item Écrivez une fonction ligne() qui trace une ligne de damier.
|
||||
\item Essayez ensuite d’exécuter la fonction ligne() pour tracer le damier.
|
||||
\end{itemize}
|
||||
\end{exercice}
|
||||
|
||||
|
||||
Binary file not shown.
Binary file not shown.
Binary file not shown.
|
Before Width: | Height: | Size: 233 KiB |
Binary file not shown.
Binary file not shown.
Binary file not shown.
Binary file not shown.
Binary file not shown.
Binary file not shown.
Binary file not shown.
Binary file not shown.
Binary file not shown.
Binary file not shown.
Binary file not shown.
Binary file not shown.
Binary file not shown.
Binary file not shown.
Binary file not shown.
Binary file not shown.
7
urls.md
7
urls.md
@ -5,10 +5,3 @@ https://gitlab.com/eskool/profs-info
|
||||
https://groupes.renater.fr/sympa/arc/numerique-sciences-informatiques
|
||||
https://groupes.renater.fr/sympa/arc/sciences-numeriques-technologie
|
||||
https://nsi.xyz/category/projets/
|
||||
|
||||
commandes ssh
|
||||
https://overthewire.org/wargames/bandit/bandit33.html
|
||||
|
||||
python web
|
||||
http://modpython.org/live/current/doc-html/tutorial.html#a-quick-start-with-the-publisher-handler
|
||||
|
||||
|
||||
331
web/controle/test/simple.tex
Normal file
331
web/controle/test/simple.tex
Normal file
@ -0,0 +1,331 @@
|
||||
\documentclass[a4paper]{article}
|
||||
|
||||
\usepackage[utf8x]{inputenc}
|
||||
\usepackage[T1]{fontenc}
|
||||
\usepackage{listings}
|
||||
|
||||
|
||||
\usepackage[francais,bloc,completemulti]{automultiplechoice}
|
||||
\begin{document}
|
||||
|
||||
\setdefaultgroupmode{withoutreplacement}
|
||||
|
||||
\element{navmdr}{
|
||||
\begin{questionmult}{navigateur}
|
||||
À quoi sert un navigateur ?
|
||||
\begin{reponses}
|
||||
\bonne{À télécharger des documents sur le web}
|
||||
\bonne{À afficher des pages web}
|
||||
\mauvaise{À trouver des sites web selon des mots clés}
|
||||
\mauvaise{À remplacer parfois le moteur de recherche}
|
||||
\end{reponses}
|
||||
\end{questionmult}
|
||||
}
|
||||
|
||||
\element{navmdr}{
|
||||
\begin{question}{mdr}
|
||||
À quoi sert un moteur de recherche ?
|
||||
\begin{reponses}
|
||||
\mauvaise{À télécharger des documents sur le web}
|
||||
\mauvaise{À afficher des pages web}
|
||||
\bonne{À trouver des sites web selon des mots clés}
|
||||
\mauvaise{À remplacer parfois le navigateur}
|
||||
\end{reponses}
|
||||
\end{question}
|
||||
}
|
||||
|
||||
\element{urls}{
|
||||
\begin{question}{protocole}
|
||||
On considère l’URL suivante : \textit{https://www.ecosia.org/search?q=framasoft}\\
|
||||
Le morceau d’URL \textit{https://} est appellé :
|
||||
\begin{reponses}
|
||||
\bonne{Le protocole}
|
||||
\mauvaise{Le nom ou l’adresse du serveur}
|
||||
\mauvaise{Le chemin}
|
||||
\mauvaise{Les paramètres}
|
||||
\mauvaise{L’URL}
|
||||
\mauvaise{La recherche}
|
||||
\end{reponses}
|
||||
\end{question}
|
||||
}
|
||||
|
||||
\element{urls}{
|
||||
\begin{question}{adresse}
|
||||
On considère l’URL suivante : \textit{https://framasoft.org/fr/}\\
|
||||
Le morceau d’URL \textit{framasoft.org} est appellé :
|
||||
\begin{reponses}
|
||||
\mauvaise{Le protocole}
|
||||
\bonne{Le nom ou l’adresse du serveur}
|
||||
\mauvaise{Le chemin}
|
||||
\mauvaise{Les paramètres}
|
||||
\mauvaise{L’URL}
|
||||
\mauvaise{La recherche}
|
||||
\end{reponses}
|
||||
\end{question}
|
||||
}
|
||||
|
||||
\element{urls}{
|
||||
\begin{question}{url}
|
||||
On considère l’URL suivante : \textit{https://framasoft.org/fr/}\\
|
||||
Le morceau d’URL \textit{/fr/} est appellé :
|
||||
\begin{reponses}
|
||||
\mauvaise{Le protocole}
|
||||
\mauvaise{Le nom ou l’adresse du serveur}
|
||||
\bonne{Le chemin}
|
||||
\mauvaise{Les paramètres}
|
||||
\mauvaise{L’URL}
|
||||
\mauvaise{La recherche}
|
||||
\end{reponses}
|
||||
\end{question}
|
||||
}
|
||||
|
||||
\element{urls}{
|
||||
\begin{question}{param}
|
||||
On considère l’URL suivante : \textit{https://www.mon-ent-occitanie.fr/sg.do?PROC=CHARTE\_UTILISATION}\\
|
||||
Le morceau d’URL \textit{?PROC=CHARTE\_UTILISATION} est appellé :
|
||||
\begin{reponses}
|
||||
\mauvaise{Le protocole}
|
||||
\mauvaise{Le nom ou l’adresse du serveur}
|
||||
\mauvaise{Le chemin}
|
||||
\bonne{Les paramètres}
|
||||
\mauvaise{L’URL}
|
||||
\mauvaise{La recherche}
|
||||
\end{reponses}
|
||||
\end{question}
|
||||
}
|
||||
|
||||
\element{urls}{
|
||||
\begin{question}{secure}
|
||||
On considère l’URL suivante : \textit{http://julesguesde.fr}\\
|
||||
Cette URL est-elle sécurisée et pourquoi ?
|
||||
\begin{reponses}
|
||||
\bonne{Non car elle commence par http}
|
||||
\mauvaise{Oui car elle commence par http}
|
||||
\mauvaise{Oui car c’est le site du lycée}
|
||||
\mauvaise{Non car c’est le site du lycée}
|
||||
\end{reponses}
|
||||
\end{question}
|
||||
}
|
||||
|
||||
\element{cookies}{
|
||||
\begin{question}{cookie}
|
||||
Concrètement, qu’est-ce qu’un cookie ?
|
||||
\begin{reponses}
|
||||
\bonne{Un petit texte}
|
||||
\mauvaise{Un logiciel espion}
|
||||
\mauvaise{Un petit biscuit numérique}
|
||||
\end{reponses}
|
||||
\end{question}
|
||||
|
||||
}
|
||||
|
||||
\element{cookies}{
|
||||
\begin{question}{cookiestore}
|
||||
Où sont stockés les cookies ?
|
||||
\begin{reponses}
|
||||
\bonne{Dans le navigateur}
|
||||
\mauvaise{Dans le serveur}
|
||||
\mauvaise{Sur le réseau}
|
||||
\mauvaise{Dans la page web}
|
||||
\end{reponses}
|
||||
\end{question}
|
||||
|
||||
}
|
||||
|
||||
\element{cookies}{
|
||||
\begin{question}{cookieask}
|
||||
Qui demande à stocker des cookies ?
|
||||
\begin{reponses}
|
||||
\bonne{Le serveur}
|
||||
\mauvaise{Le navigateur}
|
||||
\mauvaise{Le réseau}
|
||||
\mauvaise{La page web}
|
||||
\end{reponses}
|
||||
\end{question}
|
||||
|
||||
}
|
||||
|
||||
\element{cookies}{
|
||||
\begin{question}{cookieresend}
|
||||
Quand est-ce que le cookie est envoyé au serveur ?
|
||||
\begin{reponses}
|
||||
\bonne{À chaque requête}
|
||||
\mauvaise{À la première connexion}
|
||||
\mauvaise{Quand on se reconnecte au réseau}
|
||||
\mauvaise{Quand il a besoin de réconfort}
|
||||
\end{reponses}
|
||||
\end{question}
|
||||
|
||||
}
|
||||
|
||||
\element{cookies}{
|
||||
\begin{questionmult}{cookiegoal}
|
||||
À quoi sert un cookie ?
|
||||
\begin{reponses}
|
||||
\bonne{À identifier une personne sur le web}
|
||||
\bonne{À enregistrer une préférence}
|
||||
\mauvaise{À voler des identifiants}
|
||||
\mauvaise{À décider si la publicité sera affichée}
|
||||
\end{reponses}
|
||||
\end{questionmult}
|
||||
|
||||
}
|
||||
|
||||
\element{cookies}{
|
||||
\begin{questionmult}{cookiereset}
|
||||
Comment faire pour être considéré comme une nouvelle personne par les serveurs web ?
|
||||
\begin{reponses}
|
||||
\bonne{Passer en navigation privée}
|
||||
\bonne{Supprimer les cookies}
|
||||
\mauvaise{Utiliser un VPN}
|
||||
\mauvaise{Changer de connexion à internet}
|
||||
\mauvaise{Mettre une veste à capuche et taper très vite au clavier}
|
||||
\end{reponses}
|
||||
\end{questionmult}
|
||||
|
||||
}
|
||||
|
||||
|
||||
\element{html}{
|
||||
\begin{questionmult}{titre}
|
||||
Quel·s sera ou seront le·s titre·s affiché·s en haut de la page web ?
|
||||
\begin{reponses}
|
||||
\bonne{Voici un exemple de site web}
|
||||
\mauvaise{Il est possible d'ecrire du texte sur un site web !}
|
||||
\mauvaise{Un bel exemple}
|
||||
\mauvaise{h1}
|
||||
\mauvaise{title}
|
||||
\end{reponses}
|
||||
\end{questionmult}
|
||||
|
||||
}
|
||||
|
||||
\element{html}{
|
||||
\begin{question}{paragraphe}
|
||||
Quelle sera le texte de la page ?
|
||||
\begin{reponses}
|
||||
\bonne{Il est possible d'ecrire du texte sur un site web !}
|
||||
\mauvaise{<p>Il est possible d'ecrire du texte sur un site web !</p>}
|
||||
\mauvaise{p}
|
||||
\mauvaise{Un bel exemple}
|
||||
\end{reponses}
|
||||
\end{question}
|
||||
}
|
||||
|
||||
\element{html}{
|
||||
\begin{question}{couleurtext}
|
||||
Quelle sera la couleur du texte dans le paragraphe ? Vous pourrez vous aider de l’annexe 1.
|
||||
\begin{reponses}
|
||||
\bonne{Verte}
|
||||
\mauvaise{Noire}
|
||||
\mauvaise{Rouge}
|
||||
\mauvaise{Autre}
|
||||
\end{reponses}
|
||||
\end{question}
|
||||
}
|
||||
\element{html}{
|
||||
\begin{question}{couleurtitre}
|
||||
Quelle sera la couleur du texte dans le titre ? Vous pourrez vous aider de l’annexe 1.
|
||||
\begin{reponses}
|
||||
\mauvaise{Verte}
|
||||
\bonne{Noire}
|
||||
\mauvaise{Rouge}
|
||||
\mauvaise{Autre}
|
||||
\end{reponses}
|
||||
\end{question}
|
||||
}
|
||||
\element{html}{
|
||||
\begin{question}{souligne}
|
||||
Quel texte sera souligné ? Vous pourrez vous aider de l’annexe 1.
|
||||
\begin{reponses}
|
||||
\mauvaise{Le paragraphe}
|
||||
\bonne{Le titre}
|
||||
\mauvaise{Aucun}
|
||||
\end{reponses}
|
||||
\end{question}
|
||||
}
|
||||
|
||||
|
||||
\exemplaire{25}{
|
||||
|
||||
%%% debut de l'en-tête des copies :
|
||||
|
||||
\noindent{\bf QCM \hfill SNT : Le web}
|
||||
|
||||
\vspace*{.5cm}
|
||||
\begin{minipage}{.4\linewidth}
|
||||
\centering\large\bf
|
||||
Contrôle de SNT sur le web
|
||||
\end{minipage}
|
||||
\champnom{\fbox{
|
||||
\begin{minipage}{.5\linewidth}
|
||||
Nom et prénom :
|
||||
|
||||
\vspace*{.5cm}\dotfill
|
||||
\vspace*{1mm}
|
||||
\end{minipage}
|
||||
}}
|
||||
|
||||
\begin{center}\em
|
||||
LISEZ CE TEXTE ATTENTIVEMENT PLUSIEURS FOIS.
|
||||
|
||||
Pour cocher une case il faut la noircir complètement.
|
||||
Pour anuler, il faut effacer au blanc.
|
||||
|
||||
Durée : 30 minutes.
|
||||
|
||||
Aucun document n'est autorisé.
|
||||
Il est interdit d’utiliser des outils de calcul autre que votre cerveau.
|
||||
Il est interdit d’utiliser tout moyen de communication (téléphone, papiers, pots de yaourt…)
|
||||
|
||||
Les questions faisant apparaître le symbole \multiSymbole{} peuvent
|
||||
présenter zéro, une ou plusieurs bonnes réponses. Les autres ont
|
||||
une unique bonne réponse.
|
||||
|
||||
Les mauvaises réponses ne rapportent pas de points négatifs.
|
||||
|
||||
\end{center}
|
||||
\vspace{1ex}
|
||||
|
||||
%%% fin de l'en-tête
|
||||
\subsection*{Définitions}
|
||||
\insertgroup{navmdr}
|
||||
|
||||
\subsection*{Cookies}
|
||||
\insertgroup{cookies}
|
||||
|
||||
\subsection*{Les URLs}
|
||||
\insertgroup{urls}
|
||||
|
||||
\newpage
|
||||
\subsection*{HTML et CSS}
|
||||
On considère les fichiers html et css suivants :\\
|
||||
\begin{samepage}
|
||||
\rule{\linewidth}{1px}
|
||||
\lstinputlisting[language=HTML]{index.html}
|
||||
\rule{\linewidth}{1px}
|
||||
\end{samepage}
|
||||
\begin{samepage}
|
||||
\lstinputlisting[language=HTML]{style.css}
|
||||
\rule{\linewidth}{1px}
|
||||
\end{samepage}
|
||||
|
||||
\insertgroup{html}
|
||||
|
||||
\subsection*{Annexe 1 : Quelques règles CSS}
|
||||
\begin{description}
|
||||
\item[font-size: 10px;] Spécifie que le texte fera 10 pixels de haut.
|
||||
\item[color: red;] colorie le texte en rouge.
|
||||
\item[color: green;] colorie le texte en vert.
|
||||
\item[border: 1px solid black;] Spécifie un cadre de 1px de couleure noire.
|
||||
\item[background-color: blue;] Colorie le fond du bloc en bleu.
|
||||
\item[text-decoration: underline;] souligne le texte.
|
||||
\item[letter-spacing: 3px;] Fixe l’espace entre les lettres à 3 pixels.
|
||||
\end{description}
|
||||
Le texte est affiché en noir quand aucune règle CSS ne précise de couleur.
|
||||
|
||||
|
||||
|
||||
}
|
||||
|
||||
\end{document}
|
||||
Loading…
Reference in New Issue
Block a user