lafrite/2014-2015
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity

Import work from year 2014-2015

Browse Source
This commit is contained in:
Benjamin Bertrand
2017-06-16 09:48:07 +03:00
commit 7e5feb002b
1531 changed files with 418856 additions and 0 deletions
Download Patch File Download Diff File Expand all files Collapse all files

BIN
1S/Analyse/gene_suite/Conn/Conn0511.pdf Normal file
View File

Binary file not shown.

31
1S/Analyse/gene_suite/Conn/Conn0511.tex Normal file
View File

@@ -0,0 +1,31 @@
\documentclass{/media/documents/Cours/Prof/Enseignements/2014-2015/Archive/2014-2015/tools/style/classConn}
% Title Page
\title{}
\author{}
\date{}
\classe{Une classe}
\begin{document}
\sujet
\begin{Exo}
Ecrire un algorithme qui permet de calcul le n-ième terme d'une suite géométrique de raison 3 et de premier terme 2.
\end{Exo}
\sujet
\begin{Exo}
Ecrire un algorithme qui permet de calcul le n-ième terme d'une suite arithmétique de raison -3 et de premier terme 2.
\end{Exo}
\end{document}
%%% Local Variables:
%%% mode: latex
%%% TeX-master: "master"
%%% End:

BIN
1S/Analyse/gene_suite/Conn/Conn0518.pdf Normal file
View File

Binary file not shown.

70
1S/Analyse/gene_suite/Conn/Conn0518.tex Normal file
View File

@@ -0,0 +1,70 @@
\documentclass{/media/documents/Cours/Prof/Enseignements/2014-2015/Archive/2014-2015/tools/style/classConn}
\usepackage{/media/documents/Cours/Prof/Enseignements/2014-2015/Archive/2014-2015/2014_2015}
% Title Page
\title{}
\author{}
\date{18 mai 2015}
\classe{\premiereS}
\begin{document}
\sujet
\begin{Exo}
\begin{enumerate}
\item Donner la définition et la relation de récurrence d'une suite arithmétique.
\\[0.5cm]
.\dotfill
\\[0.5cm]
.\dotfill
\\[0.5cm]
\item Comment démontre-t-on qu'un suite est géométrique?
\\[0.5cm]
.\dotfill
\\[0.5cm]
.\dotfill
\\[0.5cm]
\item $(u_n)$ est croissante ssi \dotfill
\\[0.5cm]
\item Calculer $u_1$, $u_2$ et $u_3$ pour la suite suivante
\begin{eqnarray*}
u_0 = 2 & \qquad & u_{n+1} = u_n + n
\end{eqnarray*}
\end{enumerate}
\end{Exo}
\sujet
\begin{Exo}
\begin{enumerate}
\item Donner la définition et la relation de récurrence d'une suite géométrique.
\\[0.5cm]
.\dotfill
\\[0.5cm]
.\dotfill
\\[0.5cm]
\item Comment démontre-t-on qu'un suite est arithmétique?
\\[0.5cm]
.\dotfill
\\[0.5cm]
.\dotfill
\\[0.5cm]
\item $(u_n)$ est décroissante ssi \dotfill
\\[0.5cm]
\item Calculer $u_1$, $u_2$ et $u_3$ pour la suite suivante
\begin{eqnarray*}
u_0 = 3 & \qquad & u_{n+1} = u_n - n
\end{eqnarray*}
\end{enumerate}
\end{Exo}
\end{document}
%%% Local Variables:
%%% mode: latex
%%% TeX-master: "master"
%%% End:

BIN
1S/Analyse/gene_suite/Cours/gene_suites.pdf Normal file
View File

Binary file not shown.

125
1S/Analyse/gene_suite/Cours/gene_suites.tex Normal file
View File

@@ -0,0 +1,125 @@
\documentclass[a4paper,10pt, table]{/media/documents/Cours/Prof/Enseignements/2014-2015/Archive/2014-2015/tools/style/classCours}
\usepackage{/media/documents/Cours/Prof/Enseignements/2014-2015/Archive/2014-2015/2014_2015}
% Title Page
\titre{Généralités sur les suites}
% \seconde \premiereS \PSTMG \TSTMG
\classe{\premiereS}
\date{Mai 2015}
\begin{document}
\maketitle
\section{Généralité sur les suites}
\begin{Def}
Une suite numérique est un liste infinie de nombres réels, numérotés généralement avec des entiers naturelles (0, 1, 2, 3 ...) consécutifs.
\end{Def}
\begin{Ex}
\begin{itemize}
\item On note $u_n$ la taille d'une personne à son n-ième anniversaire.
\begin{align*}
u_0 = 50cm &\mbox{ taille à la naissance}\\
u_1 = 85cm &\mbox{ taille pour son premier anniversaire} \\
u_{17} = 180cm &\mbox{ taille pour son 17-ième anniversaire}
\end{align*}
\item On connait les suites arithmétiques: pour passer d'une terme au suivant, on ajoute toujours la même quantité.
\item On connait les suites géométrique : pour passer d'une terme au suivant, on multiplie toujours par la même quantité.
\end{itemize}
\end{Ex}
\paragraph{Deux façons de générer "classique" une suite}
\begin{itemize}
\item \textbf{Explicitement}: quand pour calculer la valeur de $u_n$ on n'a besoin que de la valeur de $n$
\begin{Ex}
Soit $u_n = -n^2 + 3^n - 5$ pour calculer les termes $u_1$ et $u_{10}$ il suffit de remplacer $n$ par sa valeur.
\begin{align*}
u_1 &= -1^2 + 3^1 - 5 = -3 \\
u_{10} &= -10^2 + 3^{10} - 5 = 58944
\end{align*}
\end{Ex}
\item \textbf{Par récurence}: pour calculer un terme, il faut connaître les termes précédents.
\begin{Ex}
\begin{itemize}
\item Soit $u_{n+1} = 2^{u_{n}}$ avec $u_0 = 1$ on calcule les premiers termes de la suite
\begin{align*}
u_1 &= 2^{u_0} = 2^1 = 2 \\
u_2 &= 2^{u_1} = 2^2 = 4 \\
u_3 &= 2^{u_2} = 2^4 = 16
\end{align*}
\item Soit $u_{n+1} = u_n + n^2$ avec $u_0 = 2$ on calcule les premiers termes de la suite
\begin{align*}
u_1 &= u_0 + 0^2 = 2 \\
u_1 &= u_1 + 1^2 = 2 + 1^2 = 3 \\
u_2 &= u_2 + 2^2 = 3 + 4 = 7
\end{align*}
\item (Suite de Fibonacci) Soit $u_{n+2} = u_{n+1} + u_n$ avec $u_0 = 1$ et $u_1 = 1$ on calcule les premiers termes de la suite
\begin{align*}
u_2 &= u_1 + u_0 = 1 + 1 = 2 \\
u_3 &= u_2 + u_1 = 2 + 1 = 3 \\
u_4 &= u_3 + u_2 = 3 + 2 = 5
\end{align*}
\end{itemize}
\end{Ex}
\end{itemize}
\paragraph{Reconnaître une suite arithmétique ou géométrique}
\begin{itemize}
\item Pour démontrer qu'une suite est arithmétique, on calcule l'écart entre deux termes consécutifs: $u_{n+1} - u_n$. Si cet écart ne dépend pas de $n$ alors la suite est arithmétique.
\item Pour démontrer qu'une suite est géométrique, on calcule quotient de deux termes consécutifs: $\frac{u_{n+1}}{u_n}$. Si ce quotient ne dépend pas de $n$ alors la suite est géométrique.
\end{itemize}
\section{Variation d'une suite}
\begin{Def}
Soit $(u_n)$ une suite numérique.
\begin{itemize}
\item $(u_n)$ est \textbf{croissante} ssi pour tout $n\in \N \qquad u_{n+1} \geq u_n$
\item $(u_n)$ est \textbf{décroissante} ssi pour tout $n\in \N \qquad u_{n+1} \leq u_n$
\item $(u_n)$ est \textbf{constante} ssi pour tout $n\in \N \qquad u_{n+1} = u_n$
\end{itemize}
\end{Def}
\paragraph{Méthodes}
\begin{itemize}
\item Si la suite est définie explicitement c'est à dire $u_n = f(n)$ alors $(u_n)$ a les mêmes variations que $f(x)$ pour $x\in\R^+$
\begin{Ex}
Soit $u_n = n^2 + 1$. Cette suite est de la forme $u_n = f(n)$ avec $f(x) = x^2 + 1$. On va donc étudier les variations de $f$
\begin{align*}
f'(x) = 2x \hspace{2cm} f'(x) > 0 \equiv 2x > 0 \equiv x > 0
\end{align*}
Donc $f'(x)$ est positif quand $x$ est positif. On en déduit que la fonction $f$ est croissante sur $\R^+$ et donc que la suite $(u_n)$ est croissante.
\end{Ex}
\item Si l'expression de $u_n$ contient essentiellement des additions ou des soustractions. Alors on étudie le signe de $u_{n+1} - u_n$.
\begin{Ex}
Soit $u_{n+1} = u_n^2 + u_n + 10$.
\begin{align*}
&u_{n+1} - u_n = u_n^2 + u_n + 10 - u_n = u_n^2 + 10 > 0 \\
\mbox{Donc } & u_{n+1} - u_n > 0 \equiv u_{n+1} > u_n
\end{align*}
La suite $(u_n)$ est donc strictement croissante.
\end{Ex}
\item Si l'expression de $u_n$ contient essentiellement des multiplication ou des divisions et que $u_n$ n'est \textbf{jamais nulle}. Alors on compare $\frac{u_{n+1}}{u_n}$ et 1.
\begin{Ex}
Soit $u_n = 5^n \times n$, donc $u_{n+1} = 5^{n+1} \times (n+1)$
\begin{align*}
\frac{u_{n+1}}{u_n} = \frac{5^{n+1} \times (n+1)}{5^n \times n} = 5 \times \frac{n+1}{n} > 5 > 1
\end{align*}
Donc $\frac{u_{n+1}}{u_n} > 1$ donc $u_{n+1} > u_n$ donc la suite est croissante.
\end{Ex}
\end{itemize}
\end{document}
%%% Local Variables:
%%% mode: latex
%%% TeX-master: "master"
%%% End:

30
1S/Analyse/gene_suite/Cours/index.rst Normal file
View File

@@ -0,0 +1,30 @@
Notes sur le cours Généralité sur les Suites
############################################
:date: 2015-07-01
:modified: 2015-07-01
:tags: Cours,Analyse
:category: 1S
:authors: Benjamin Bertrand
:summary: Pas de résumé, note créée automatiquement parce que je ne l'avais pas bien fait...
`Lien vers gene_suites.tex <gene_suites.tex>`_
`Lien vers gene_suites.pdf <gene_suites.pdf>`_
Ce chapitre vient après avoir déjà manipulé les suites arithmétiques et géométriques. C'est le moment de voir qu'il y a d'autres types de suites et qu'il faut trouver des méthodes pour trouver la nature d'une suite.
Différentes façons de définir des suites:
- Par récurrence
- Explicitement
Reconnaître les deux types de suites à partir d'un calcul
Déterminer le sens de variations d'une suite
Notion de limite d'une suite.

BIN
1S/Analyse/gene_suite/Exo/Exo_suites.pdf Normal file
View File

Binary file not shown.

136
1S/Analyse/gene_suite/Exo/Exo_suites.tex Normal file
View File

@@ -0,0 +1,136 @@
\documentclass[a4paper,12pt,landscape, twocolumn]{/media/documents/Cours/Prof/Enseignements/2014-2015/Archive/2014-2015/tools/style/classExo}
\usepackage{/media/documents/Cours/Prof/Enseignements/2014-2015/Archive/2014-2015/2014_2015}
\geometry{left=5mm,right=5mm, bottom= 10mm, top=10mm}
% Title Page
\titre{Généralités sur les suites - Exercices}
% \seconde \premiereS \PSTMG \TSTMG
\classe{\premiereS}
\date{Mai 2015}
\begin{document}
\begin{questions}
\question On concidères les suites $u$ et $v$ définies sur $\N$ par:
\begin{eqnarray*}
u_n = 2n^2 - 1 & \mbox{ et } &
\left\{
\begin{array}{ccc}
v_0 &=& 0 \\ v_{n+1} &=& 2v_{n}^2 - 1
\end{array}
\right.
\end{eqnarray*}
\begin{parts}
\part Calculer les 3 premiers termes de ces suites.
\part Calculer le sixième terme de ces suites.
\end{parts}
\question Pour chacune des suites données, calculer les termes $u_0$, $u_1$, $u_2$ et $u_{100}$quand c'est possible
\begin{multicols}{2}
\begin{parts}
\part $u_n = n - \sqrt{n^2 - 9}$
\part $u_n = (-1)^n + 1$
\part $u_n = n^n$
\part $u_n = 1 - \left( \frac{-1}{2} \right)^n$
\end{parts}
\end{multicols}
\question Les suites suivantes,$u$, sont définit par $u_0 = 2$ et par une relation de récurrence. Pour chacune des suites suivantes, calculer $u_1$, $u_2$ et $u_3$.
\begin{multicols}{2}
\begin{parts}
\part $u_{n+1} = 3u_n - 2$
\part $u_{n+1} = 1 - u_n^2$
\part $u_{n+1} = \frac{3 + u_n}{1 -u_n}$
\part $u_{n+1} = \frac{1}{u_n} + 1$
\end{parts}
\end{multicols}
\question
La suite $(u_n)$ est définie par $u_0 = A$ et l'algorithme suivant permettant d'afficher les termes de $u_1$ à $u_N$
\begin{verbatim}
Saisir A
Saisir N
Pour I variant de 1 à N
A prend la valeur 2*A - 1
Fin Pour
Afficher A
\end{verbatim}
\pagebreak
\begin{parts}
\part Déterminer $u_1$, $u_2$, $u_3$ et $u_4$ quand $u_0 = 3$.
\part Exprimer $u_{n+1}$ en fonction de $u_n$
\end{parts}
\question
Pour chacune des suites de l'exercice 3, écrire un algorithme qui calcule le n-ième terme de la suite.
\question
Reconnaitre les suites arithmétiques parmi celles proposées
\begin{multicols}{2}
\begin{parts}
\part $\left\{
\begin{array}{ccc}
u_0 &=& 3 \\ u_{n+1} &=& u_n + n^2
\end{array}
\right.$
\part $v_n = 2n^2 - n + 1$
\part $w_n = \frac{n+1}{3}$
\part $\left\{
\begin{array}{ccc}
z_0 &=& -1 \\ z_{n+1} &=& z_{n} - 5
\end{array}
\right.$
\end{parts}
\end{multicols}
\question
Reconnaitre les suites géométrique parmi celles proposées
\begin{multicols}{2}
\begin{parts}
\part $\left\{
\begin{array}{ccc}
u_0 &=& 3 \\ u_{n+1} &=& \frac{u_n}{5}
\end{array}
\right.$
\part $v_n = 3\times 7^n$
\part $w_n = \frac{5^n}{3^{n+1}}$
\part $\left\{
\begin{array}{ccc}
z_0 &=& -1 \\ z_{n+1} &=& 4^{z_{n+1}}
\end{array}
\right.$
\end{parts}
\end{multicols}
\question
Déterminer le sens de variation des suites suivantes en calculant $u_{n+1} - u_n$
\begin{multicols}{2}
\begin{parts}
\part $v_n = 2n^2 - n + 1$
\part $\left\{
\begin{array}{ccc}
u_0 &=& 1 \\ u_{n+1} &=& u_n + 2n + 3
\end{array}
\right.$
\part $w_n = \frac{1}{(4n - 1)}$
\part $\left\{
\begin{array}{ccc}
z_0 &=& -1 \\ z_{n+1} &=& -z_n^2 + z_n - 1
\end{array}
\right.$
\end{parts}
\end{multicols}
\end{questions}
\end{document}
%%% Local Variables:
%%% mode: latex
%%% TeX-master: "master"
%%% End:

15
1S/Analyse/gene_suite/Exo/index.rst Normal file
View File

@@ -0,0 +1,15 @@
Notes sur Exo sur les généralités sur les suites pour les 1S
############################################################
:date: 2015-07-01
:modified: 2015-07-01
:tags: Exo,Analyse
:category: 1S
:authors: Benjamin Bertrand
:summary: Pas de résumé, note créée automatiquement parce que je ne l'avais pas bien fait...
`Lien vers Exo_suites.pdf <Exo_suites.pdf>`_
`Lien vers Exo_suites.tex <Exo_suites.tex>`_

845
1S/Analyse/gene_suite/Programmation/Decouverte de Python.html Normal file
View File

File diff suppressed because one or more lines are too long

537
1S/Analyse/gene_suite/Programmation/Decouverte de Python.ipynb Normal file
View File

@@ -0,0 +1,537 @@
{
"cells": [
{
"cell_type": "markdown",
"metadata": {},
"source": [
"# Découverte de Python\n",
"\n",
"Dans ce cours autour de la programmation Python et de l'algorithmie, nous verons beaucoup de petits morceaux de programmes. \n",
"\n",
"Il est vivement recommander de ne pas faire **que** les questions poser mais aussi d'**expérimenter** par soi même."
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"## Base de Python et Spyder\n",
"\n",
"Dans les encadrés, on peut lancer des commandes Python et écrire des petits programmes.\n",
"\n",
"La touche **F5** ou l'icône en triangle vert permet d'executer tout le programme écrit dans la partie de droite."
]
},
{
"cell_type": "code",
"execution_count": 1,
"metadata": {
"collapsed": false
},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"Boujour\n"
]
}
],
"source": [
"print('Boujour')"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"* Modifier la commande précédente pour qu'elle n'affiche plus bonjour mais votre nom puis executer cette commande."
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Il est possible d'afficher plusieurs messages:"
]
},
{
"cell_type": "code",
"execution_count": 2,
"metadata": {
"collapsed": false
},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"bonjour\n",
"monde\n"
]
}
],
"source": [
"print(\"bonjour\")\n",
"print('monde')"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"* Modifier le programme précédent pour qu'il affiche:\n",
"\n",
" Bonjour\n",
" \n",
" tous\n",
" \n",
" le \n",
" \n",
" monde"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Les commandes commençant par un dièze, ne seront pas executées. On appelle cela des commentaires. Nous les utiliserons pour expliquer ce que l'on fait."
]
},
{
"cell_type": "code",
"execution_count": 7,
"metadata": {
"collapsed": false
},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"bonjour\n"
]
}
],
"source": [
"# la commande suivante affiche Bonjour\n",
"print('bonjour')\n",
"# Quand on veut afficher quelque chose, on utilisera la commande print()"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"## Les variables\n",
"\n",
"Les variables sont des *enveloppes* où l'on stockera des nombres, des mots, des phrases ou des choses plus compliqués."
]
},
{
"cell_type": "code",
"execution_count": 4,
"metadata": {
"collapsed": true
},
"outputs": [],
"source": [
"un_nombre = 10"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Ainsi dans *l'enveloppe* appelée **un_nombre** on y met le nombre 10.\n",
"\n",
"C'est ce que l'on appelle **assigner** une **valeur** à une variable ou **stocker** une valeur dans une variable."
]
},
{
"cell_type": "code",
"execution_count": 5,
"metadata": {
"collapsed": false
},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"10\n"
]
}
],
"source": [
"un_nombre = 10\n",
"print(un_nombre)"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"* Modifier le programme précédent pour stocker 2 dans **un_nombre** puis l'arrficher."
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Pour stocker des mots ou des phrases, il faut les mettre entre guillemets"
]
},
{
"cell_type": "code",
"execution_count": 6,
"metadata": {
"collapsed": true
},
"outputs": [],
"source": [
"un_mot = \"Coucou\"\n",
"une_phrase = \"ceci est une phrase\""
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"* Modifier le programme précédent pour changer le contenu des variables puis ajouter deux lignes pour afficher ce que contiennent ces variables (avec la commande **print**)."
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"## Opérations\n",
"\n",
"Un ordinateur ne sais **que** calculer. On peut donc lui faire faire toutes les opérations classiques "
]
},
{
"cell_type": "code",
"execution_count": 13,
"metadata": {
"collapsed": false
},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"5\n",
"21\n"
]
}
],
"source": [
"print(2 + 3)\n",
"print(4*5 + 1)"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Ces simples calculs ne sont pas très interessants. La programmation devient réellement efficace quand on travail non plus avec des nombres que l'on définit par avance mais avec des nombres stockés dans des variables."
]
},
{
"cell_type": "code",
"execution_count": 17,
"metadata": {
"collapsed": false
},
"outputs": [],
"source": [
"# On définit 3 variables\n",
"a = 2\n",
"b = 10\n",
"c = 100"
]
},
{
"cell_type": "code",
"execution_count": 18,
"metadata": {
"collapsed": false
},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"20\n",
"120\n",
"50.666666666666664\n"
]
}
],
"source": [
"# On peut afficher des calculs avec elles\n",
"print(a * b)\n",
"print(a * b + c)\n",
"print(a / 3 + c * 0.5)\n"
]
},
{
"cell_type": "code",
"execution_count": 20,
"metadata": {
"collapsed": false
},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"13\n",
"3\n",
"4\n"
]
}
],
"source": [
"# On peut aussi stocker le résultat d'un calcul dans une variables\n",
"d = a + b\n",
"print(d)\n",
"print(a)\n",
"a = a + 1 \n",
"print(a)"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"* Modifier les valeurs initiales de *a*, *b* et *c* puis executer les 3 blocks.\n",
"* Écrire un programme avec une variable **age** qui affiche\n",
"\n",
" Bonjour, j'ai **age** ans."
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"## Exercice avec les suites\n",
"\n",
"Nous allons commencer à voir comment utiliser un programme pour calculer les permiers termes d'une suite.\n",
"\n",
"Soit $u_n$ la suite définie par\n",
"$$u_0 = 100$$\n",
"et \n",
"$$ u_{n+1} = 0.4u_n + 10$$\n",
"On veut calculer $u_3$"
]
},
{
"cell_type": "code",
"execution_count": 22,
"metadata": {
"collapsed": false
},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"22.0\n"
]
}
],
"source": [
"# Premiere valeur de la suite (initialisation): u0\n",
"u = 100\n",
"# On lui applique la relation de récurrence pour avoir la deuxième valeur u1\n",
"u = 0.4*u+10\n",
"# On recommence jusqu'à atteindre u3\n",
"u = 0.4*u+10\n",
"u = 0.4*u+10\n",
"# On affiche la valeur obtenue\n",
"print(u)"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"* Modifier le programme précédent pour calculer $u_5$\n",
"\n",
"* Rreprendre le programme précédent pour calculer $v_5$ pour la suite $v_n$ définie par\n",
"$$v_0 = 10$$\n",
"et \n",
"$$ u_{n+1} = 5u_n -3$$"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"## Boucles\n",
"\n",
"Le problème c'est que si l'on veut calculer $u_{100}$, il faudra recopier un grand nombre de fois la formule de récurence ce qui n'est pas très astucieux...\n",
"\n",
"Pour éviter d'avoir à recopier plusieurs fois la même chose. Quand il a des répétitions à faire, nous utilisons des **boucles**.\n",
"\n",
"Pour faire des boucles on utilise l'instruction *for*"
]
},
{
"cell_type": "code",
"execution_count": 7,
"metadata": {
"collapsed": false
},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"bonjour\n",
"bonjour\n",
"bonjour\n",
"bonjour\n",
"bonjour\n",
"bonjour\n",
"bonjour\n",
"bonjour\n",
"bonjour\n",
"bonjour\n"
]
}
],
"source": [
"for i in range(10):\n",
" print(\"bonjour\")"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"La fonction **range** va enumérer les nombres de 0 jusqu'à la valeur entre parenthèses.\n",
"\n",
"* Transformer le programme pour qu'il repète 20 fois le mot bonjour\n",
"* Remplacer \"bonjour\" par i pour voir les valeurs prises par i\n",
"\n",
"On remarquera qu'à la fin de la ligne **for**, il y a deux points puis que ce qui doit être répété est indenté (avec la touche **tab**).\n",
"\n",
"Dans l'exemple suivant nous allons faire plusieurs choses dans la boucle."
]
},
{
"cell_type": "code",
"execution_count": 8,
"metadata": {
"collapsed": false
},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"0\n",
"bonjour\n",
"1\n",
"bonjour\n",
"2\n",
"bonjour\n",
"3\n",
"bonjour\n",
"4\n",
"bonjour\n",
"5\n",
"bonjour\n",
"6\n",
"bonjour\n",
"7\n",
"bonjour\n",
"8\n",
"bonjour\n",
"9\n",
"bonjour\n",
"fin de la boucle\n",
"12\n"
]
}
],
"source": [
"un_mot = \"bonjour\"\n",
"un_nombre = 2\n",
"for i in range(10):\n",
" print(i)\n",
" print(un_mot)\n",
" un_nombre = un_nombre + 1\n",
"print(\"fin de la boucle\")\n",
"print(un_nombre)"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"* Recopier le programme précédent puis l'adapter pour calculer $u_{100}$"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"* Écrire un programme qui calcule le n-ième terme de la suite $(w_n)$ définie par\n",
"$$w_0 = 3$$\n",
"et\n",
"$$w_{n+1} = -2w_n + 2$$"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"* Écrire un programme qui calcule le n-ième terme de la suite $(t_n)$ définie par\n",
"$$t_0 = 1$$\n",
"et\n",
"$$ t_{n+1} = t_n^{n} + 1$$"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"* Écrire un programme qui calcule la somme des n premiers termes de la suite $(w_n)$"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {
"collapsed": true
},
"outputs": [],
"source": []
}
],
"metadata": {
"kernelspec": {
"display_name": "Python 3",
"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.4.3"
}
},
"nbformat": 4,
"nbformat_minor": 0
}

BIN
1S/Analyse/gene_suite/Programmation/Decouverte de Python.pdf Normal file
View File

Binary file not shown.

534
1S/Analyse/gene_suite/Programmation/Decouverte de Python2.ipynb Normal file
View File

@@ -0,0 +1,534 @@
{
"cells": [
{
"cell_type": "markdown",
"metadata": {},
"source": [
"# Découverte de Python\n",
"\n",
"Dans ce cours autour de la programmation Python et de l'algorithmie, nous verons beaucoup de petits morceaux de programmes. \n",
"\n",
"Il est vivement recommander de ne pas faire **que** les questions poser mais aussi d'**expérimenter** par soi même."
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"## Base de Ipython\n",
"\n",
"Dans les encadrés, on peut lancer des commandes Python et écrire des petits programmes.\n",
"\n",
"La combinaison de touche **shift+entré** permet de faire executer par l'ordinateur la ou les commandes tapées."
]
},
{
"cell_type": "code",
"execution_count": 1,
"metadata": {
"collapsed": false
},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"Boujour\n"
]
}
],
"source": [
"print 'Boujour'"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"* Modifier la commande précédente pour qu'elle n'affiche plus bonjour mais votre nom puis executer cette commande."
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"La touche **entré** permet de passer à la ligne pour écrire d'autres commandes."
]
},
{
"cell_type": "code",
"execution_count": 9,
"metadata": {
"collapsed": false
},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"bonjour\n",
"monde\n"
]
}
],
"source": [
"print(\"bonjour\")\n",
"print('monde')"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"* Modifier le programme précédent pour qu'il affiche:\n",
"\n",
" Bonjour\n",
" \n",
" tous\n",
" \n",
" le \n",
" \n",
" monde"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Les commandes commençant par un dièze, ne seront pas executées. On appelle cela des commentaires. Nous les utiliserons pour expliquer ce que l'on fait."
]
},
{
"cell_type": "code",
"execution_count": 7,
"metadata": {
"collapsed": false
},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"bonjour\n"
]
}
],
"source": [
"# la commande suivante affiche Bonjour\n",
"print('bonjour')\n",
"# Quand on veut afficher quelque chose, on utilisera la commande print()"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"## Les variables\n",
"\n",
"Les variables sont des *tirroirs* où l'on stockera des nombres, des mots, des phrases ou des choses plus compliqués. C'est ce que l'on appelle **assigner** une **valeur** à une variable ou **stocker** une valeur dans une variable."
]
},
{
"cell_type": "code",
"execution_count": 12,
"metadata": {
"collapsed": false
},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"10\n"
]
}
],
"source": [
"un_nombre = 10\n",
"print(un_nombre)"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"* Modifier le programme précédent pour stocker 2 dans **un_nombre** "
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Pour stocker des mots ou des phrases, il faut les mettre entre guillemets"
]
},
{
"cell_type": "code",
"execution_count": 11,
"metadata": {
"collapsed": true
},
"outputs": [],
"source": [
"un_mot = \"Coucou\"\n",
"une_phrase = \"ceci est une phrase\""
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"* Modifier le programme précédent pour changer le contenu des variables puis ajouter deux lignes pour afficher ce que contiennent ces variables (avec la commande **print**)."
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"## Opérations\n",
"\n",
"Un ordinateur ne sais **que** calculer. On peut donc lui faire faire toutes les opérations classiques "
]
},
{
"cell_type": "code",
"execution_count": 13,
"metadata": {
"collapsed": false
},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"5\n",
"21\n"
]
}
],
"source": [
"print(2 + 3)\n",
"print(4*5 + 1)"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Ces simples calculs ne sont pas très interessants. La programmation devient réellement efficace quand on travail non plus avec des nombres que l'on définit par avance mais avec des nombres stockés dans des variables."
]
},
{
"cell_type": "code",
"execution_count": 17,
"metadata": {
"collapsed": false
},
"outputs": [],
"source": [
"# On définit 3 variables\n",
"a = 2\n",
"b = 10\n",
"c = 100"
]
},
{
"cell_type": "code",
"execution_count": 18,
"metadata": {
"collapsed": false
},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"20\n",
"120\n",
"50.666666666666664\n"
]
}
],
"source": [
"# On peut afficher des calculs avec elles\n",
"print(a * b)\n",
"print(a * b + c)\n",
"print(a / 3 + c * 0.5)\n"
]
},
{
"cell_type": "code",
"execution_count": 20,
"metadata": {
"collapsed": false
},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"13\n",
"3\n",
"4\n"
]
}
],
"source": [
"# On peut aussi stocker le résultat d'un calcul dans une variables\n",
"d = a + b\n",
"print(d)\n",
"print(a)\n",
"a = a + 1 \n",
"print(a)"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"* Modifier les valeurs initiales de *a*, *b* et *c* puis executer les 3 blocks."
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"## Exercice avec les suites\n",
"\n",
"Nous allons commencer à voir comment utiliser un programme pour calculer les permiers termes d'une suite.\n",
"\n",
"Soit $u_n$ la suite définie par\n",
"$$u_0 = 100$$\n",
"et \n",
"$$ u_{n+1} = 0.4u_n + 10$$\n",
"On veut calculer $u_3$"
]
},
{
"cell_type": "code",
"execution_count": 22,
"metadata": {
"collapsed": false
},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"22.0\n"
]
}
],
"source": [
"# Premiere valeur de la suite (initialisation): u0\n",
"u = 100\n",
"# On lui applique la relation de récurrence pour avoir la deuxième valeur u1\n",
"u = 0.4*u+10\n",
"# On recommence jusqu'à atteindre u3\n",
"u = 0.4*u+10\n",
"u = 0.4*u+10\n",
"# On affiche la valeur obtenue\n",
"print(u)"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"* Modifier le programme précédent pour calculer $u_5$\n",
"\n",
"* Dans le cadre suivant reprendre le programme précédent pour calculer $v_5$ pour la suite $v_n$ définie par\n",
"$$v_0 = 10$$\n",
"et \n",
"$$ u_{n+1} = 5u_n -3$$"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {
"collapsed": true
},
"outputs": [],
"source": []
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"## Boucles\n",
"\n",
"Le problème c'est que si l'on veut calculer $u_{100}$, il faudra recopier un grand nombre de fois la formule de récurence ce qui n'est pas très astucieux...\n",
"\n",
"Pour éviter d'avoir à recopier plusieurs fois la même chose. Quand il a des répétitions à faire, nous utilisons des **boucles**.\n",
"\n",
"Pour faire des boucles on utilise l'instruction *for*"
]
},
{
"cell_type": "code",
"execution_count": 8,
"metadata": {
"collapsed": false
},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"bonjour\n",
"bonjour\n",
"bonjour\n",
"bonjour\n",
"bonjour\n",
"bonjour\n",
"bonjour\n",
"bonjour\n",
"bonjour\n",
"bonjour\n"
]
}
],
"source": [
"for i in range(10):\n",
" print(\"bonjour\")"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"La fonction **range** va enumérer les nombres de 0 jusqu'à la valeur entre parenthèses.\n",
"\n",
"* Transformer le programme pour qu'il repète 20 fois le mot bonjour\n",
"* Remplacer \"bonjour\" par i pour voir les valeurs prises par i\n",
"\n",
"On remarquera qu'à la fin de la ligne **for**, il y a deux points puis que ce qui doit être répété est indenté (avec la touche **tab**).\n",
"\n",
"Dans l'exemple suivant nous allons faire plusieurs choses dans la boucle."
]
},
{
"cell_type": "code",
"execution_count": 24,
"metadata": {
"collapsed": false
},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"0\n",
"bonjour\n",
"1\n",
"bonjour\n",
"2\n",
"bonjour\n",
"3\n",
"bonjour\n",
"4\n",
"bonjour\n",
"5\n",
"bonjour\n",
"6\n",
"bonjour\n",
"7\n",
"bonjour\n",
"8\n",
"bonjour\n",
"9\n",
"bonjour\n",
"fin de la boucle\n",
"12\n"
]
}
],
"source": [
"un_mot = \"bonjour\"\n",
"un_nombre = 2\n",
"for i in range(10):\n",
" print(i)\n",
" print(un_mot)\n",
" un_nombre = un_nombre + 1\n",
"print(\"fin de la boucle\")\n",
"print(un_nombre)"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"* recopier le programme précédent puis l'adapter pour calculer $u_{100}$"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {
"collapsed": true
},
"outputs": [],
"source": []
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"* écrire un programme qui calcule le n-ième terme de la suite $(w_n)$ définie par\n",
"$$w_0 = 3$$\n",
"et\n",
"$$w_{n+1} = -2u_n + 2$$"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {
"collapsed": true
},
"outputs": [],
"source": []
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"* Ecrire un programme qui calcule le n-ième terme de la suite (t_n) définie par\n",
"$$w_0 = 1$$\n",
"et\n",
"$$ w_{n+1} = w_n^{n} + 1$$"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {
"collapsed": true
},
"outputs": [],
"source": []
}
],
"metadata": {
"kernelspec": {
"display_name": "Python 2",
"language": "python",
"name": "python2"
},
"language_info": {
"codemirror_mode": {
"name": "ipython",
"version": 2
},
"file_extension": ".py",
"mimetype": "text/x-python",
"name": "python",
"nbconvert_exporter": "python",
"pygments_lexer": "ipython2",
"version": "2.7.9"
}
},
"nbformat": 4,
"nbformat_minor": 0
}

19
1S/Analyse/gene_suite/Programmation/index.rst Normal file
View File

@@ -0,0 +1,19 @@
Notes sur Programmation
#######################
:date: 2015-07-01
:modified: 2015-07-01
:tags: Analyse, Suites, Programmation
:category: 1S
:authors: Benjamin Bertrand
:summary: Pas de résumé, note créée automatiquement parce que je ne l'avais pas bien fait...
`Lien vers Decouverte de Python.pdf <Decouverte de Python.pdf>`_
`Lien vers Decouverte de Python.ipynb <Decouverte de Python.ipynb>`_
`Lien vers Decouverte de Python2.ipynb <Decouverte de Python2.ipynb>`_
Scéances de découverte (un peu tardive...) de Python. J'avais du mal à leurs faire comprendre la notion d'algorithme et à leur faire comprendre qu'il n'y avait rien de compliqué. J'ai pensé qu'en passant par la programmation effective cela passerai mieux (ce qui a été le cas, même si je n'ai pas eu la possibilité de l'évaluer).