diff --git a/PreStSauveur/Programmation/Fonctions.html b/PreStSauveur/Programmation/Fonctions.html new file mode 100644 index 0000000..c0f3772 --- /dev/null +++ b/PreStSauveur/Programmation/Fonctions.html @@ -0,0 +1,13416 @@ + + + + +Fonctions + + + + + + + + + + + + + + + + + + + + + + + +
+
+ +
+
+
+

Python et fonctions

Le but de ce TP est de découvrir les fonctions en programmation.

+ + +
+
+
+
+
+
+

Que fait ce programme?

    +
  • Copier puis coller le programme, l'executer. Fait-il ce que vous attendiez de lui?
    • +
  • Commenter au dessus de chaque ligne (avec #...) pour expliquer ce qu'elle fait.
    • +
+ +
+
+
+
+
+
In [ ]:
+
+
+
entree1 = 'Choux'
+entree2 = 'Salade'
+plat1 = 'Frites'
+plat2 = 'Haricots vert'
+print("==== Menu du jour ====")
+print("")
+print("Entrées -----")
+print(" * ", entree1)
+print(" * ", entree2)
+print("Plats -------")
+print(" * ", plat1)
+print(" * ", plat2)
+print("")
+print("Faites votre choix")
+
+ +
+
+
+ +
+
+
+
+
    +
  • Ajouter un choix de dessert à ce programme
    • +
+ +
+
+
+
+
+
+

Moins se répéter

Dans le programme précédent, on répète plusieurs fois comment il faut afficher un choix.

+ +
print(" * ", entree1)
+print(" * ", entree2)
+
+
+

C'est peu long à écrire mais surtout si l'on veut mettre un ~ au lieu d'une *, il faut changer chaque ligne (et donc surement en oublier!). Pour éviter d'avoir à réécrire chaque fois la même chose, on peut définir des fonctions.

+

Ici notre fonction va transformer le nom d'un plat en ligne de notre menu.

+ +
+
+
+
+
+
In [ ]:
+
+
+
def choix(plat):
+    return ' ~ '+ plat
+
+ +
+
+
+ +
+
+
+
+

On peut alors utiliser cette fonction pour présenter notre menu.

+ +
+
+
+
+
+
In [ ]:
+
+
+
entree1 = 'Choux'
+entree2 = 'Salade'
+plat1 = 'Frites'
+plat2 = 'Haricots vert'
+print("==== Menu du jour ====")
+print("")
+print("Entrées -----")
+print(choix(entree1))
+print(choix(entree2))
+print("Plats -------")
+print(" * ", plat1)
+print(" * ", plat2)
+print("")
+print("Faites votre choix")
+
+ +
+
+
+ +
+
+
+
+
    +
  • Terminer de modifier le programme pour utiliser la fonction le plus possible.
    • +
  • Modifier la présentation d'un plat en codant une fonction.
    • +
+ +
+
+
+
+
+
+

Fonctions mathématiques

On peut aussi tout à fait programmer des fonctions similaires à celles que l'on trouve en mathématiques.

+

Cette fonction affine

+$$ f:x \mapsto -x^2 + 6x+ 3$$

se codera en python

+ +
+
+
+
+
+
In [ ]:
+
+
+
def f(x):
+    return -x**2+6*x-3
+
+ +
+
+
+ +
+
+
+
+

Maintenant que la fonction est codée, on peut l'utiliser pour calculer des images.

+ +
+
+
+
+
+
In [ ]:
+
+
+
print(f(10))
+print(f(-2))
+
+ +
+
+
+ +
+
+
+
+

Pour chacune des fonctions suivantes, testées les pour savoir si elles fonctionnents. Une fois que vous ètes sûr qu'elles font bien ce que vous souhaitez, ne les effacées pas et gardez les pour la suite.

+
    +

  • Programmer la fonction $g$ définie par + $$ g:x \mapsto x(19 - 2x) $$

    +
    • +

  • Programmer la fonction $h$ qui correspond au programme de calcul suivant

    +
      +
    • Choisir un nombre
      • +
    • -> Ajouter 2
      • +
    • -> Elever au carré
      • +
    • -> Soustraire 4
      • +
    +
    • +

  • Programmer une fonction celcius2fahrenheit qui convertit des degrés celcius vers des degrés fahrenheit en utilisant la formule suivante + $$ (°F) = 1,8 * (°C) + 32 $$

    +
    • +

  • Programmer la fonction inverse fahrenheit2celcius.

    +
    • +
+

Les 2 prochaines parties peuvent être faite independament. A vous de choisir celle qui tente le plus.

+ +
+
+
+
+
+
+

Faire beaucoup de calculs

Imaginons que je souhaite chercher le maximum de la fonction $f$ programmée précédement. Il va falloir que je fasse calculer à python plusieurs images de cette fonction.

+ +
+
+
+
+
+
In [ ]:
+
+
+
print(f(0))
+print(f(5))
+print(f(20))
+
+ +
+
+
+ +
+
+
+
+

Le faire de la sorte peut prendre beaucoup de temps et n'est pas vraiment dans la logique de faire travailler l'ordinateur à notre place.

+

Pour réaliser plusieurs calculs de façon systématiques, on peut utiliser une boucle for.

+ +
+
+
+
+
+
In [ ]:
+
+
+
for x in range(10):
+    print("Quand x vaut", x, ", f(x) vaut", f(x))
+
+ +
+
+
+ +
+
+
+
+

On peut donc penser que la fonction a un maximum autour de 3.

+
    +
  • Ecrire toutes les conversions 0 à 100 degré celcius en farhenheit
    • +
  • Trouver le maximum de la fonction $g$.
    • +
+ +
+
+
+
+
+
+

Reçut/Recalé/mentions au bac

Au bac, on applique le barème suivant:

+
    +
  • Note strictement inférieure à 10: recalé
    • +
  • Note supérieure à 10: reçut
    • +
+

On peut y voir une fonction qui transforme une note en l'un des deux mots recalé ou reçut.

+
    +
  • Programmer cette fonction (aller voir du coté des if dans le mémo).
    • +
+

Parmi les reçuts, certains peuvent avoir des mentions:

+
    +
  • $10 \leq note < 12 $: pas de mentions
    • +
  • $12 \leq note < 14 $: Assez Bien
    • +
  • $14 \leq note < 16 $: Bien
    • +
  • $16 \leq note $: Très Bien
    • +
+
    +
  • Programmer cette fonction qui transforme une note en la mention.
    • +
+ +
+
+
+
+
+ + + + + + diff --git a/PreStSauveur/Programmation/Fonctions.ipynb b/PreStSauveur/Programmation/Fonctions.ipynb index 0fdb498..4b36462 100644 --- a/PreStSauveur/Programmation/Fonctions.ipynb +++ b/PreStSauveur/Programmation/Fonctions.ipynb @@ -4,7 +4,15 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "# Python et fonctions" + "# Python et fonctions\n", + "\n", + "Le but de ce TP est de découvrir les fonctions en programmation.\n", + "\n", + "* [Echauffement](#Que-fait-ce-programme?)\n", + "* [Moins se répéter](#Moins-se-répéter)\n", + "* [Fonctions mathématiques](#Fonctions-mathématiques)\n", + "* [Faire beaucoup de calculs](#Faire-beaucoup-de-calculs)\n", + "* [Reçut/Recalé/mentions au bac](#Reçut/Recalé/mentions-au-bac)" ] }, { @@ -19,26 +27,9 @@ }, { "cell_type": "code", - "execution_count": 2, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "==== Menu du jour ====\n", - "\n", - "Entrées -----\n", - " * Choux\n", - " * Salade\n", - "Plats -------\n", - " * Frites\n", - " * Haricots vert\n", - "\n", - "Faites votre choix\n" - ] - } - ], + "outputs": [], "source": [ "entree1 = 'Choux'\n", "entree2 = 'Salade'\n", @@ -74,18 +65,18 @@ " print(\" * \", entree1)\n", " print(\" * \", entree2)\n", "\n", - "C'est peu long à écrire mais surtout si l'on veut mettre un `~` au lieu d'une `*`, il faut changer chaque ligne (et donc surement en oublier!). Pour éviter d'avoir à réécrire chaque fois la même chose, on peut définir des fonctions.\n", + "C'est peu long à écrire mais surtout si l'on veut mettre un `~` au lieu d'une `*`, il faut changer chaque ligne (et donc surement en oublier!). Pour éviter d'avoir à réécrire chaque fois la même chose, on peut définir des **fonctions**.\n", "\n", - "Ici notre fonction va transformer le nom d'un plat en ligne de notre menu." + "Ici notre **fonction** va transformer le nom d'un plat en ligne de notre menu." ] }, { "cell_type": "code", - "execution_count": 7, + "execution_count": null, "metadata": {}, "outputs": [], "source": [ - "def presente(plat):\n", + "def choix(plat):\n", " return ' ~ '+ plat" ] }, @@ -98,26 +89,9 @@ }, { "cell_type": "code", - "execution_count": 8, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "==== Menu du jour ====\n", - "\n", - "Entrées -----\n", - " ~ Choux\n", - " ~ Salade\n", - "Plats -------\n", - " * Frites\n", - " * Haricots vert\n", - "\n", - "Faites votre choix\n" - ] - } - ], + "outputs": [], "source": [ "entree1 = 'Choux'\n", "entree2 = 'Salade'\n", @@ -126,8 +100,8 @@ "print(\"==== Menu du jour ====\")\n", "print(\"\")\n", "print(\"Entrées -----\")\n", - "print(presente(entree1))\n", - "print(presente(entree2))\n", + "print(choix(entree1))\n", + "print(choix(entree2))\n", "print(\"Plats -------\")\n", "print(\" * \", plat1)\n", "print(\" * \", plat2)\n", @@ -139,8 +113,23 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "* Terminer de modifier le programme pour utiliser la fonction.\n", - "* Modifier la présentation d'un plat" + "* Terminer de modifier le programme pour utiliser la fonction le plus possible.\n", + "* Modifier la présentation d'un plat en codant une fonction." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Fonctions mathématiques \n", + "\n", + "On peut aussi tout à fait programmer des fonctions similaires à celles que l'on trouve en mathématiques. \n", + "\n", + "Cette fonction affine\n", + "\n", + "$$ f:x \\mapsto -x^2 + 6x+ 3$$\n", + "\n", + "se codera en python" ] }, { @@ -148,7 +137,126 @@ "execution_count": null, "metadata": {}, "outputs": [], - "source": [] + "source": [ + "def f(x):\n", + " return -x**2+6*x-3" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Maintenant que la fonction est codée, on peut l'utiliser pour calculer des images." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "print(f(10))\n", + "print(f(-2))" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Pour chacune des fonctions suivantes, testées les pour savoir si elles fonctionnents. Une fois que vous ètes sûr qu'elles font bien ce que vous souhaitez, ne les effacées pas et gardez les pour la suite.\n", + "\n", + "* Programmer la fonction $g$ définie par \n", + " $$ g:x \\mapsto x(19 - 2x) $$\n", + " \n", + "* Programmer la fonction $h$ qui correspond au programme de calcul suivant\n", + "\n", + " * Choisir un nombre\n", + " * -> Ajouter 2\n", + " * -> Elever au carré\n", + " * -> Soustraire 4\n", + " \n", + "* Programmer une fonction `celcius2fahrenheit` qui convertit des degrés celcius vers des degrés fahrenheit en utilisant la formule suivante\n", + " $$ (°F) = 1,8 * (°C) + 32 $$\n", + "\n", + "* Programmer la fonction inverse `fahrenheit2celcius`.\n", + "\n", + "Les 2 prochaines parties peuvent être faite independament. A vous de choisir celle qui tente le plus." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Faire beaucoup de calculs\n", + "\n", + "Imaginons que je souhaite chercher le maximum de la fonction $f$ programmée précédement. Il va falloir que je fasse calculer à python plusieurs images de cette fonction.\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "print(f(0))\n", + "print(f(5))\n", + "print(f(20))" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Le faire de la sorte peut prendre beaucoup de temps et n'est pas vraiment dans la logique de faire travailler l'ordinateur à notre place.\n", + "\n", + "Pour réaliser plusieurs calculs de façon systématiques, on peut utiliser ** une boucle ** `for`." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "for x in range(10):\n", + " print(\"Quand x vaut\", x, \", f(x) vaut\", f(x))" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "On peut donc penser que la fonction a un maximum autour de 3.\n", + "\n", + "* Ecrire toutes les conversions 0 à 100 degré celcius en farhenheit\n", + "* Trouver le maximum de la fonction $g$." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Reçut/Recalé/mentions au bac\n", + "\n", + "Au bac, on applique le barème suivant:\n", + "\n", + "* Note strictement inférieure à 10: recalé\n", + "* Note supérieure à 10: reçut\n", + "\n", + "On peut y voir une fonction qui transforme une *note* en l'un des deux mots *recalé* ou *reçut*.\n", + "\n", + "* Programmer cette fonction (aller voir du coté des `if` dans le mémo).\n", + "\n", + "Parmi les reçuts, certains peuvent avoir des mentions:\n", + "\n", + "* $10 \\leq note < 12 $: pas de mentions\n", + "* $12 \\leq note < 14 $: Assez Bien\n", + "* $14 \\leq note < 16 $: Bien\n", + "* $16 \\leq note $: Très Bien\n", + "\n", + "\n", + "* Programmer cette fonction qui transforme une note en la mention." + ] } ], "metadata": { diff --git a/PreStSauveur/Programmation/Memo.html b/PreStSauveur/Programmation/Memo.html new file mode 100644 index 0000000..37703d2 --- /dev/null +++ b/PreStSauveur/Programmation/Memo.html @@ -0,0 +1,13799 @@ + + + + +Mémo + + + + + + + + + + + + + + + + + + + + + + + +
+
+ +
+
+
+

Mémo Python

Python par Repl.it

+
+

Notions de programmation

+ +
+

Ressouces Python

+ + +
+
+
+
+
+
+

Avec Repl.it

Se rendre sur le site de repl.it.

+

L'interface se sépare en 2 parties:

+

interface replit

+
    +
  • Zone Script: Éditeur de texte où l'on pourra écrire notre programme python. Pour executer son contenu, il faudra cliquer sur replit run
    • +
  • Zone Shell: Line de commande pour interagir avec python. Ici vous pouvez tester vos commandes python et presser la touche entrer pour l'executer. Par contre on ne peut pas écrire sur plusieurs lignes.
    • +
+

Il est conseillé d'utiliser en priorité la zone script car elle permet d'écrire sur plusieurs lignes et de corriger après l'execution. La zone shell servira à tester des commandes pour voir directement leurs effets.

+

Pour sauvergarder votre travail, vous cliquerez sur les 3 points à côté de Files puis sur download as zip.

+

replit save

+ +
+
+
+
+
+
+
+

input

Contrairement à ce que l'on a fait hier on ne met plus rien dans les parenthèses d'un input.

+

input() est une commande qui va demander à l'utilisateur une information

+ +
+
+
+
+
+
In [20]:
+
+
+
print("Comment t'appelles tu?")
+nom = input()
+print("Ah! Tu t'appelles", nom)
+
+ +
+
+
+ +
+
+ + +
+ +
+ + +
+
Comment t'appelles tu?
+Ivan
+Ah! Tu t'appelles Ivan
+
+
+
+ +
+
+ +
+
+
+
+

Après avoir afficher la question, l'ordinateur se met en pose et attend que l'utilisateur réponde quelque chose. Une fois que l'utilisateur a répondu (a appuyé sur entrer) la réponse est stocké, ici, dans la variable nom.

+ +
+
+
+
+
+
+

Condition if

Pour différencier plusieurs cas, on utilisera la commande if (si), elif (sinon si) et else (sinon).

+ +
+
+
+
+
+
In [21]:
+
+
+
a = 2
+b = 3
+
+if a > b: # Si
+    print("a plus grand que b")
+elif a == b: # Sinon si
+    print("a est égal à b")
+else: # Sinon
+    print("a est plus petit que b")
+
+ +
+
+
+ +
+
+ + +
+ +
+ + +
+
a est plus petit que b
+
+
+
+ +
+
+ +
+
+
+
+

Boucles for

Les boucles for permettent de répéter un certain nombre de fois la même action.

+
    +
  • Ajouter 5 fois 100 d'affilé
    • +
+ +
+
+
+
+
+
In [22]:
+
+
+
a = 2
+print("Au debut a vaut", a)
+for i in range(5):
+    a = a + 100
+    print("a vaut maintenant", a)
+print("Finalement a vaut", a)
+
+ +
+
+
+ +
+
+ + +
+ +
+ + +
+
Au debut a vaut 2
+a vaut maintenant 102
+a vaut maintenant 202
+a vaut maintenant 302
+a vaut maintenant 402
+a vaut maintenant 502
+Finalement a vaut 502
+
+
+
+ +
+
+ +
+
+
+
+
    +
  • On peut aussi parcourir les lettres d'un mot ou d'une phrase
    • +
+ +
+
+
+
+
+
In [23]:
+
+
+
phrase = "boujour toi"
+print("On enumere >>> ", phrase)
+for l in phrase:
+    print(l)
+print("Toutes les lettres ont été énumérées")
+
+ +
+
+
+ +
+
+ + +
+ +
+ + +
+
On enumere >>>  boujour toi
+b
+o
+u
+j
+o
+u
+r
+ 
+t
+o
+i
+Toutes les lettres ont été énumérées
+
+
+
+ +
+
+ +
+
+
+
+
    +
  • Ou encore tous les éléments d'une liste
    • +
+ +
+
+
+
+
+
In [24]:
+
+
+
liste = ["premier element", 2, "coucou", 1, "aie", 0]
+print("On enumère >>>", liste)
+for i in liste:
+    print(i)
+print("Tout a été énuméré")
+
+ +
+
+
+ +
+
+ + +
+ +
+ + +
+
On enumère >>> ['premier element', 2, 'coucou', 1, 'aie', 0]
+premier element
+2
+coucou
+1
+aie
+0
+Tout a été énuméré
+
+
+
+ +
+
+ +
+
+
+
+

Boucles while

En anglais, while signifie tant que. On l'utilisera quand on veut refaire quelque plusieurs fois tant que quelque chose n'est pas vrais.

+

Ajouter 3 tant que que u n'a pas dépassé 19:

+ +
+
+
+
+
+
In [25]:
+
+
+
u = 2
+while u < 19:
+    u = u + 3
+    print("u vaut ", u)
+print("u a depassé 50 et vaut", u)
+
+ +
+
+
+ +
+
+ + +
+ +
+ + +
+
u vaut  5
+u vaut  8
+u vaut  11
+u vaut  14
+u vaut  17
+u vaut  20
+u a depassé 50 et vaut 20
+
+
+
+ +
+
+ +
+
+
+
+

Poser toujours la même question quand que l'utilisateur n'a pas bien répondu:

+ +
+
+
+
+
+
In [26]:
+
+
+
aPasTrouve = True # True signifie vrai en anglais.
+while aPasTrouve:
+    print("Quelle est la couleur du cheval blanc d'Henri 4?")
+    rep = input()
+    if rep == "blanc":
+        print("Bravo!")
+        aPasTrouve = False # False signifie faux en anglais
+    else:
+        print("Non! Recommence!")
+print("Voila tu as réussi!")
+
+ +
+
+
+ +
+
+ + +
+ +
+ + +
+
Quelle est la couleur du cheval blanc d'Henri 4?
+bleu
+Non! Recommence!
+Quelle est la couleur du cheval blanc d'Henri 4?
+vert
+Non! Recommence!
+Quelle est la couleur du cheval blanc d'Henri 4?
+jaune
+Non! Recommence!
+Quelle est la couleur du cheval blanc d'Henri 4?
+blanc
+Bravo!
+Voila tu as réussi!
+
+
+
+ +
+
+ +
+
+
+
+

Fonctions

Une fonction est un morceau de programme qui évitera de coder plusieurs fois la même chose. Quand on programme on dit souvent Si c'est la 3e fois que l'on écrit ces lignes c'est qu'il faut en faire une fonction.

+

Voici différentes utilisations de fonctions.

+ +
+
+
+
+
+
+

Fonctions numériques

En math, on utilise les fonctions pour décrire les transformations (de nombres le plus souvent).

+

Par exemple: +$$ f:x \mapsto 3x + 2$$ +Cette fonction $f$ prend un nombre, le multiplie par 3 puis ajoute 2. On pourra la coder de la façon suivante:

+ +
+
+
+
+
+
In [27]:
+
+
+
def f(x):
+    return 3*x+2
+
+ +
+
+
+ +
+
+
+
+

On vient de coder cette fonction, on peut ensuite l'utiliser

+ +
+
+
+
+
+
In [28]:
+
+
+
print(f(4))
+print("L'image de 2.5 par la fonction f est ", f(2.5))
+print("f(-2) = ", f(-2))
+
+ +
+
+
+ +
+
+ + +
+ +
+ + +
+
14
+L'image de 2.5 par la fonction f est  9.5
+f(-2) =  -4
+
+
+
+ +
+
+ +
+
+
+
+

Au collège, on a vu les "programmes de calculs". Ils peuvent eux aussi être codé avec des fonctions.

+
    +
  • Choisir un nombre
    • +
  • Ajouter 5
    • +
  • Diviser par 10
    • +
+

Se code de la façon suivante:

+ +
+
+
+
+
+
In [29]:
+
+
+
def programme(nombre):
+    reponse = nombre + 5
+    reponse = reponse / 10
+    return reponse
+
+ +
+
+
+ +
+
+
+
In [30]:
+
+
+
print(programme(60))
+
+ +
+
+
+ +
+
+ + +
+ +
+ + +
+
6.5
+
+
+
+ +
+
+ +
+
+
+
+

D'autres fonctions

Les fonctions numériques sont très utilisées en math mais en programmation, on manipule beaucoup d'autres types de fonctions.

+

On pourrait vouloir transformer un texte en un titre entouré de symboles #.

+ +
+
+
+
+
+
In [31]:
+
+
+
def entoure(titre):
+    return '##### ' + titre + ' #####'
+
+ +
+
+
+ +
+
+
+
In [32]:
+
+
+
print(entoure('Mon titre'))
+print(entoure("L'histoire du petit chaperon rouge"))
+print(entoure('Fin'))
+
+ +
+
+
+ +
+
+ + +
+ +
+ + +
+
##### Mon titre #####
+##### L'histoire du petit chaperon rouge #####
+##### Fin #####
+
+
+
+ +
+
+ +
+
+
+
+

On peut même mettre un autre argument (en plus de titre) pour entourer avec autre chose que #.

+ +
+
+
+
+
+
In [33]:
+
+
+
def entoure(texte, symbole):
+    return symbole*4 + ' ' + texte + ' ' + symbole*4
+
+ +
+
+
+ +
+
+
+
In [34]:
+
+
+
print(entoure('La belle au bois dormant', '-'))
+
+ +
+
+
+ +
+
+ + +
+ +
+ + +
+
---- La belle au bois dormant ----
+
+
+
+ +
+
+ +
+
+
+
In [ ]:
+
+
+
 
+
+ +
+
+
+ +
+
+
+ + + + + + diff --git a/PreStSauveur/Programmation/Memo.ipynb b/PreStSauveur/Programmation/Memo.ipynb new file mode 100644 index 0000000..b5cba79 --- /dev/null +++ b/PreStSauveur/Programmation/Memo.ipynb @@ -0,0 +1,566 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Mémo Python\n", + "\n", + "[Python par Repl.it](#Avec-Repl.it)\n", + "\n", + "-----------\n", + "Notions de programmation\n", + "* [input](#input)\n", + "* [Les conditions if](#Condition-if)\n", + "* [Les boucles for](#Boucles-for)\n", + "* [Les boucles while](#Boucles-while)\n", + "* [Les fonctions](#Fonctions)\n", + "------------\n", + "Ressouces Python\n", + "* [site du zero](http://openclassrooms.com/courses/apprenez-a-programmer-en-python) (cours en ligne)\n", + "* [codeacademy](http://www.codecademy.com/) (cours en ligne)\n", + "* [code conbat](http://codecombat.com) (jeu en ligne qui se joue en codant)\n", + "* [checkio](http://www.checkio.org/) (jeu en ligne - anglais - avec beaucoup de langage différents)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Avec Repl.it\n", + "\n", + "Se rendre sur le site de [repl.it](https://repl.it/repls/SpiffyOpulentBackend). \n", + "\n", + "L'interface se sépare en 2 parties:\n", + "\n", + "![interface replit](./fig/replit_global.png)\n", + "\n", + "- **Zone Script**: Éditeur de texte où l'on pourra écrire notre programme python. Pour executer son contenu, il faudra cliquer sur ![replit run](./fig/replit_run.png)\n", + "- **Zone Shell**: Line de commande pour interagir avec python. Ici vous pouvez tester vos commandes python et presser la touche *entrer* pour l'executer. Par contre on ne peut pas écrire sur plusieurs lignes.\n", + "\n", + "Il est conseillé d'utiliser en priorité la **zone script** car elle permet d'écrire sur plusieurs lignes et de corriger après l'execution. La **zone shell** servira à tester des commandes pour voir directement leurs effets. \n", + "\n", + "Pour sauvergarder votre travail, vous cliquerez sur les 3 points à côté de *Files* puis sur *download as zip*.\n", + "\n", + "![replit save](./fig/replit_files.png)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "--------------------------------------\n", + "## input\n", + "\n", + "Contrairement à ce que l'on a fait hier on ne met plus rien dans les parenthèses d'un `input`.\n", + "\n", + "`input()` est une commande qui va demander à l'utilisateur une information " + ] + }, + { + "cell_type": "code", + "execution_count": 20, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Comment t'appelles tu?\n", + "Ivan\n", + "Ah! Tu t'appelles Ivan\n" + ] + } + ], + "source": [ + "print(\"Comment t'appelles tu?\")\n", + "nom = input()\n", + "print(\"Ah! Tu t'appelles\", nom)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Après avoir afficher la question, l'ordinateur se met en pose et attend que l'utilisateur réponde quelque chose. Une fois que l'utilisateur a répondu (a appuyé sur `entrer`) la réponse est stocké, ici, dans la variable `nom`." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Condition if\n", + "\n", + "Pour différencier plusieurs cas, on utilisera la commande `if` (si), `elif` (sinon si) et `else` (sinon)." + ] + }, + { + "cell_type": "code", + "execution_count": 21, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "a est plus petit que b\n" + ] + } + ], + "source": [ + "a = 2\n", + "b = 3\n", + "\n", + "if a > b: # Si\n", + " print(\"a plus grand que b\")\n", + "elif a == b: # Sinon si\n", + " print(\"a est égal à b\")\n", + "else: # Sinon\n", + " print(\"a est plus petit que b\")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Boucles for\n", + "\n", + "Les boucles **for** permettent de répéter un certain nombre de fois la même action.\n", + "\n", + "* Générer plusieurs valeurs:" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "0\n", + "1\n", + "2\n", + "3\n", + "4\n", + "5\n", + "6\n", + "7\n", + "8\n", + "9\n" + ] + } + ], + "source": [ + "for x in range(10):\n", + " print(x)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Python a créé une variable `x` puis lui a fait prendre toutes les valeurs entre 0 et 9.\n", + "\n", + "* Ajouter 5 fois 100 d'affilé" + ] + }, + { + "cell_type": "code", + "execution_count": 22, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Au debut a vaut 2\n", + "a vaut maintenant 102\n", + "a vaut maintenant 202\n", + "a vaut maintenant 302\n", + "a vaut maintenant 402\n", + "a vaut maintenant 502\n", + "Finalement a vaut 502\n" + ] + } + ], + "source": [ + "a = 2\n", + "print(\"Au debut a vaut\", a)\n", + "for i in range(5):\n", + " a = a + 100\n", + " print(\"a vaut maintenant\", a)\n", + "print(\"Finalement a vaut\", a)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "* On peut aussi parcourir les lettres d'un mot ou d'une phrase" + ] + }, + { + "cell_type": "code", + "execution_count": 23, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "On enumere >>> boujour toi\n", + "b\n", + "o\n", + "u\n", + "j\n", + "o\n", + "u\n", + "r\n", + " \n", + "t\n", + "o\n", + "i\n", + "Toutes les lettres ont été énumérées\n" + ] + } + ], + "source": [ + "phrase = \"boujour toi\"\n", + "print(\"On enumere >>> \", phrase)\n", + "for l in phrase:\n", + " print(l)\n", + "print(\"Toutes les lettres ont été énumérées\")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "* Ou encore tous les éléments d'une liste" + ] + }, + { + "cell_type": "code", + "execution_count": 24, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "On enumère >>> ['premier element', 2, 'coucou', 1, 'aie', 0]\n", + "premier element\n", + "2\n", + "coucou\n", + "1\n", + "aie\n", + "0\n", + "Tout a été énuméré\n" + ] + } + ], + "source": [ + "liste = [\"premier element\", 2, \"coucou\", 1, \"aie\", 0]\n", + "print(\"On enumère >>>\", liste)\n", + "for i in liste:\n", + " print(i)\n", + "print(\"Tout a été énuméré\")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Boucles while\n", + "\n", + "En anglais, `while` signifie **tant que**. On l'utilisera quand on veut refaire quelque plusieurs fois **tant que** quelque chose n'est pas vrais.\n", + "\n", + "Ajouter 3 **tant que** que `u` n'a pas dépassé 19: " + ] + }, + { + "cell_type": "code", + "execution_count": 25, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "u vaut 5\n", + "u vaut 8\n", + "u vaut 11\n", + "u vaut 14\n", + "u vaut 17\n", + "u vaut 20\n", + "u a depassé 50 et vaut 20\n" + ] + } + ], + "source": [ + "u = 2\n", + "while u < 19:\n", + " u = u + 3\n", + " print(\"u vaut \", u)\n", + "print(\"u a depassé 50 et vaut\", u)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Poser toujours la même question quand que l'utilisateur n'a pas bien répondu:" + ] + }, + { + "cell_type": "code", + "execution_count": 26, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Quelle est la couleur du cheval blanc d'Henri 4?\n", + "bleu\n", + "Non! Recommence!\n", + "Quelle est la couleur du cheval blanc d'Henri 4?\n", + "vert\n", + "Non! Recommence!\n", + "Quelle est la couleur du cheval blanc d'Henri 4?\n", + "jaune\n", + "Non! Recommence!\n", + "Quelle est la couleur du cheval blanc d'Henri 4?\n", + "blanc\n", + "Bravo!\n", + "Voila tu as réussi!\n" + ] + } + ], + "source": [ + "aPasTrouve = True # True signifie vrai en anglais.\n", + "while aPasTrouve:\n", + " print(\"Quelle est la couleur du cheval blanc d'Henri 4?\")\n", + " rep = input()\n", + " if rep == \"blanc\":\n", + " print(\"Bravo!\")\n", + " aPasTrouve = False # False signifie faux en anglais\n", + " else:\n", + " print(\"Non! Recommence!\")\n", + "print(\"Voila tu as réussi!\")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Fonctions\n", + "\n", + "Une fonction est un morceau de programme qui évitera de coder plusieurs fois la même chose. Quand on programme on dit souvent `Si c'est la 3e fois que l'on écrit ces lignes c'est qu'il faut en faire une fonction`.\n", + "\n", + "Voici différentes utilisations de fonctions." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Fonctions numériques\n", + "\n", + "En math, on utilise les fonctions pour décrire les transformations (de nombres le plus souvent). \n", + "\n", + "Par exemple:\n", + "$$ f:x \\mapsto 3x + 2$$\n", + "Cette fonction $f$ prend un nombre, le multiplie par 3 puis ajoute 2. On pourra la coder de la façon suivante:" + ] + }, + { + "cell_type": "code", + "execution_count": 27, + "metadata": {}, + "outputs": [], + "source": [ + "def f(x):\n", + " return 3*x+2" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "On vient de coder cette fonction, on peut ensuite l'utiliser" + ] + }, + { + "cell_type": "code", + "execution_count": 28, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "14\n", + "L'image de 2.5 par la fonction f est 9.5\n", + "f(-2) = -4\n" + ] + } + ], + "source": [ + "print(f(4))\n", + "print(\"L'image de 2.5 par la fonction f est \", f(2.5))\n", + "print(\"f(-2) = \", f(-2))" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Au collège, on a vu les \"programmes de calculs\". Ils peuvent eux aussi être codé avec des fonctions.\n", + "\n", + "- Choisir un nombre\n", + "- Ajouter 5\n", + "- Diviser par 10\n", + "\n", + "Se code de la façon suivante:" + ] + }, + { + "cell_type": "code", + "execution_count": 29, + "metadata": {}, + "outputs": [], + "source": [ + "def programme(nombre):\n", + " reponse = nombre + 5\n", + " reponse = reponse / 10\n", + " return reponse" + ] + }, + { + "cell_type": "code", + "execution_count": 30, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "6.5\n" + ] + } + ], + "source": [ + "print(programme(60))" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### D'autres fonctions\n", + "\n", + "Les fonctions numériques sont très utilisées en math mais en programmation, on manipule beaucoup d'autres types de fonctions.\n", + "\n", + "On pourrait vouloir transformer un texte en un titre entouré de symboles `#`." + ] + }, + { + "cell_type": "code", + "execution_count": 31, + "metadata": {}, + "outputs": [], + "source": [ + "def entoure(titre):\n", + " return '##### ' + titre + ' #####'" + ] + }, + { + "cell_type": "code", + "execution_count": 32, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "##### Mon titre #####\n", + "##### L'histoire du petit chaperon rouge #####\n", + "##### Fin #####\n" + ] + } + ], + "source": [ + "print(entoure('Mon titre'))\n", + "print(entoure(\"L'histoire du petit chaperon rouge\"))\n", + "print(entoure('Fin'))" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "On peut même mettre un autre argument (en plus de `titre`) pour entourer avec autre chose que `#`." + ] + }, + { + "cell_type": "code", + "execution_count": 33, + "metadata": {}, + "outputs": [], + "source": [ + "def entoure(texte, symbole):\n", + " return symbole*4 + ' ' + texte + ' ' + symbole*4" + ] + }, + { + "cell_type": "code", + "execution_count": 34, + "metadata": { + "scrolled": true + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "---- La belle au bois dormant ----\n" + ] + } + ], + "source": [ + "print(entoure('La belle au bois dormant', '-'))" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "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.7.1" + } + }, + "nbformat": 4, + "nbformat_minor": 1 +} diff --git a/PreStSauveur/Programmation/Projets Python.ipynb b/PreStSauveur/Programmation/Projets Python.ipynb index 4882ab2..2f02edb 100644 --- a/PreStSauveur/Programmation/Projets Python.ipynb +++ b/PreStSauveur/Programmation/Projets Python.ipynb @@ -1172,7 +1172,9 @@ { "cell_type": "code", "execution_count": 34, - "metadata": {}, + "metadata": { + "scrolled": true + }, "outputs": [ { "name": "stdout",