# Charge ma feuille de style pour nbviewer
from IPython.core.display import HTML
from urllib.request import urlopen
# import urllib.request, urllib.parse, urllib.error
url='https://github.com/debimax/cours-debimax/raw/master/static/custom.css'
with urlopen(url) as response:
styles = response.read().decode("utf8")
styles="<style>\n{}\n</style>".format(styles)
HTML(styles)
Ce notebook est un document interactif, il contient différentes cellules:
On navigue entre les cellules avec les touches UP: ↑ et DOWN: ↓
Les cellules identifiées par Entrée, contiennent du code python et il faut les exécuter pour voir le résultat
Il y a plusieurs méthodes pour exécuter les cellules
Tester la cellule au dessus pour vérifier que tout fonctionne. Normalement les titres seront en couleur.
Important: Quand il y aura un problème n'hésitez pas de relancer le *kernel* (noyau):
Le langage *Python* a été développé en 1989 par *Guido Von Rossum, à l'université d'Amsterdam.
Guido était un fan de la série télévisée Monthy Python Flying Circus* crée par les Monty Python d'où l'origine du nom.
La troupe était composée de six membres : Graham Chapman, John Cleese, Eric Idle, Michael Palin, Terry Jones et Terry Gilliam.
On utilisera ce notebook pour apprendre les rudiments de python et faire des tests.
Cependant pour écrire des programmes plus complets on utilisera *pyzo* qui est libre de droit. Il existe d'autres excellents éditeurs pour écrire du code python. En voici une liste:
Les variables ont un *type*. Il y en a trois à connaître:
Python utilise le symbole *=* pour affecter une valeur à une variable. par exemple:
a=2 # a prend la valeur 2, le type de la variable a est integer
print(a) # On affiche a
b=2.3 # b prend la valeur 2.3, le type de la variable b est float
print(b)
c="3" # b prend la valeur "3", le type de la variable c est string
print(c)
d='Pablo Neruda' # On peut utiliser des simples quotes ou des doubles quotes.
print(d)
2 2.3 3 Pablo Neruda
On utilise la fonction *type()* pour connaitre le type d'une variable.
print(type(a))
print(type(b))
print(type(c))
On peut calculer avec python pour le calcul
a=2
print(a)
a=a+3
print(a)
2+4
2+"3"
On ne peut pas ajouter un nombre et une chaîne de caractères.
Pour contourner ceci on change (si possible) le type des variables.
int(2.3) # le nombre flotant 2.3 est transformé en entier (integer).
2+"3" # On obtient une erreur car les types sont différents
2+int("3") # On transforme donc la chaîne "3" en un entier
2+"3.2" # On obtient une erreur car les types sont différents
2+float("3.2") # On transforme donc la chaîne "3.2" en un flotant.
a=3
print(a,type(a))
print(a,type(str(a))) #On a transformé l'entier 3 en chaîne de caractère
Ne confondez pas *a=2* avec *a==2*
a==2
a==3
Pour afficher en python on utilise la fonction *print()*
print("Bonjour")
print("Ceci est du texte")
print(3)
print(2.5)
print("Le","lycée","pablo","Neruda")
Pour afficher le contenu d'une variable dans du texte il existe plusieurs méthodes
a='cinq'
print("Le contenu de la variable a est",a,".")
b=5
print("Le contenu de la variable b est",b,".")
Cette méthode est parfois limité, il est alors préférable d'utiliser la deuxième méthode.
On met la lettre *f* devant le texte indiquer le formatage.
On utilise des accolades autour des variables. Par exemple *{a}.
Le résultat qui sera affiché est le contenu de la variable a.
Peu importe si a* est un texte, un flottant ou un entier, le résultat sera affiché.
a="5"
print(f"La valeur de la variable a est {a}.") # a est de type string
b=5
print(f"La valeur de la variable a est {b}.") # a est de type integer
a=4
b=5
print(f"Le produit de {a} par {b} est {a*b}")
a=4
b=5
print(f"{a}*{b}={a*b} et {a}/{b}={a/b}")
Il existe de nombreux opérateurs comme l'addition *+* la soustraction *-* la multiplication ******* et la division *\*
En voici d'autre que l'on utilise souvent.
7*//2 est le quotient* de la division euclidienne de 7 par 2
7//2
7*%2 est le reste* de la division euclidienne.
7%2
7**2 pour 7 à la *puissance* 2
7**2
*sqrt(2)* pour la *racine carré* de 2.
Attention il faut auparavant importer la librairie *math*
import math
math.sqrt(2)
ou alors
from math import sqrt
sqrt(2)
Attention: Le phénomène que je m'apprête à souligner est vrai pour absolument tous les langages, mais il est bien souvent oublié.
Quel est le résultat d'une opération simple telle que 0.7 + 0.1 ?
Vous pensez que le résultat est 0.8 ? Testons donc en Python :
0.7+0.1
On dirait qu'il y a un problème ... En fait cela provient de la représentation des flottants en machine :
ils sont arrondis !
En Python, la solution consistera a utiliser un module spécial, le module decimal.
from decimal import *
Decimal('0.1')+Decimal('0.7')
Si vous manipulez des flottants pour des calculs précis, méfiez vous !
Pour écrire un commentaire sans qu'il soit interprété utilise le caractère *#*.
On utlilise les commentaires pour expliquer ce que l'on fait.
print("Bonjour")
print("Ceci est du texte")
# print("Celui ci n'est pas interprété")
Vous voyez qu'après le symbol *#* la couleur n'est pas la même.
Tout ce qui suit # n'est pas interprété par *python*
*a=2* $\quad$ signifie que a prend la valeur 2.
*a==2* $\quad$ teste si le contenu de la variable a est égale à 2.
Il existe plusieurs types pour les variables en python.
*type()* permet connaître le type d'une variable.
On utilise le caractère *#* pour écrire un commentaire
Python utilise le symbole *=* pour affecter une valeur à une variable (Attention à ne pas confondre a=12 et a==12).
On utilise pour afficher du texte et des variables la fonction *print()
*.
print("Le produit de ",a," par ",b, " est ",a*b,".")
print(f"Le produit de {a} par {b} est {a*b}.")
Opération | algorithme | python |
---|---|---|
addition | 2+3 | 2+3 |
Multiplication | 3*6 | 3*6 |
Division | 7/2 | 7/2 |
Quotient de la division euclidienne | 7 div 2 ou div(7,2) | 7//2 |
Reste de la division euclidienne | 7 mod 2 ou mod(7,2) | 7%2 |
puissance | $7^2$ | 7**2 |
racine carrée | $\sqrt{2}$ ou sqrt(2) | math.sqrt(2) |
a="Hello "
b="World !"
a+b
on parle de *concaténation* des chaînes de caractères a et b.
3*a
permet de répéter plusieurs fois un même texte.
Lorsqu'on a besoin d'utiliser plusieurs fois un même bloc d'instructions, on peut l'encapsuler dans une fonction. On peut ainsi étendre le langage avec une nouvelle instruction.
Dans la définition d'une fonction, on précise son nom et en général des paramètres formels d'entrée et une valeur de retour.
En Python on définit une fonction ainsi :
def mafonction(parametre1, parametre2):
#bloc d'instructions (optionnel)
return valeur
Par exemple la fonction *carre(x)
* qui prend en paramètre un nombre $x$ et qui retourne son carré, s'écrira :
def carre(x):
return x**2
Pour utiliser cette fonction *carre(x)* on écrira:
carre(3)
Si on est dans un script il faut utiliser *print()*
print(carre(8))
a=3
print("Le carré de",a,"est",carre(a))
# ou avec la méthode format
print(f"Le carré de {a} est {carre(a)}")
Étudions le programme ci-dessous qui calcule et affiche la moyenne d'un élève sur trois notes:
prenom1="Anne"
note1=13
note2=10
note3=16
moyenneA=(note1+note2+note3)/3
print(f"La moyenne de {prenom1} est: {moyenneA}")
C'est possible pour un élève mais moi j'ai une classe de 35 élèves.
Imaginons une classe de 5 élèves:
prenom1="Anne"
note1=13
note2=10
note3=16
moyenneA=(note1+note2+note3)/3
print(f"La moyenne de {prenom1} est {moyenneA}")
prenom2="Boris"
note4=9
note5=7.5
note6=12
moyenneB=(note4+note5+note6)/3
print(f"La moyenne de {prenom2} est {moyenneB}")
prenom3="Céline"
note7=8
note8=12
note9=16
moyenneC=(note7+note8+note9)/3
print(f"La moyenne de {prenom3} est {moyenneC}")
prenom4="Denis"
note10=11
note11=14
note12=17
moyenneD=(note10+note11+note12)/3
print(f"La moyenne de {prenom4} est {moyenneD}")
Imaginez maintenant le code pour la classe avec 35 élèves!!!!
Que se passe-t-il si on veux ajouter une note supplémentaire ? On doit
Par exemple pour un élève on écrira.
prenom1="Anne"
note1=13
note2=10
note3=16
note4=14
moyenneA=(note1+note2+note3+note4)/4
print(f"La moyenne de {prenom1} est {moyenneA}")
C'est *Fastidieux !*
Quand une tâche peut être effectuée plusieurs fois dans un programme, il devient vite TRÈS INTÉRESSANT d'utiliser un morceau de programme qu'on va réutiliser: on isole alors ce morceau de code dans un *BLOC* qu'on appelle *FONCTION*
#bloc fonction qui calcule et affiche la moyenne
def calcule_moyenne(note1,note2,note3):
moyenne=(note1+note2+note3)/3
return moyenne
#appels répétés de la fonction dans le programme principal
print(calcule_moyenne(13,10,16))
print(calcule_moyenne(9,7.5,12))
print(calcule_moyenne(8,12,16))
print(calcule_moyenne(11,14,17))
On peut aussi modifier cette fonction pour calculer et retourner la moyenne avec un texte plus complet.
def affiche_moyenne(prenom,note1,note2,note3):
moyenne=(note1+note2+note3)/3
return f"La moyenne de {prenom} est {moyenne}."
print(affiche_moyenne("Anne", 13,10,16))
print(affiche_moyenne("Boris", 9,7.5,12))
print(affiche_moyenne("Céline", 8,12,16))
print(affiche_moyenne("Denis", 11,14,17))
Ce qu'on a gagné :
Comparez maintenant ce dernier programme avec le premier :
avec moins de lignes de programme, on fait plus de choses, et en plus ça reste très lisible !
c'est aussi très utile si la personne qui définit la fonction est différente de celle qui l'utilise on peut ainsi utiliser une fonction que l'on n'a pas codé sois même, simplement, on l'appelle ! Comme par exemple la fonction print()
def mafonction(parametre1, parametre2):
#bloc d'instructions (optionnel)
return valeur
print()
dans une fonction mais il est préférable d'utiliser return
(pour retourner) et d'utiliser print()
quand on appelle la fonction.Une fonction peut prendre plusieurs paramètres.
Par exemple pour calculer l'aire d'un rectangle on utilisera.
def aire_rectangle(largeur,longueur):
return largeur*longueur
print(aire_rectangle(2,4))
Exercice 1 (fonctions):
La surface *S* en mètre carrées de la peau d'un adulte est donnée approximativement par la formule $ \dfrac{\sqrt[]{L\times M}}{6}$ où *L* est la taille de l'individu en mètres et *M* sa masse en kilogramme.
Pour calculer la racine carré en python il faut importer la fonction *sqrt* du module *math*.
surface(M,L)
qui retourne la surface corporelle d'un adulte.from math import sqrt
def surface(L, M):
...
print(surface(1.8, 75))
from math import sqrt
def surface(L, M):
return sqrt(L*M)/6
print(surface(1.8, 75))
Exercice 2 (fonctions):
L'indice de masse corporelle (IMC) est une grandeur qui permet d'estimer la corpulence d'une personne.
Il se calcule en fonction de la taille en mètre et de la masse en kilogramme.
La formue est $IMC=\dfrac{masse}{taille^2}$
Écrire une fonction imc(masse,taille)
qui retourne l'indice de la masse corporelle.
def imc(masse,taille):
........
print(imc(65,1.7)) # renvoie 22.49 environ
def imc(masse, taille):
return masse/(taille**2)
print(imc(65, 1.7))
*Exercice 2 (fonctions):*
La fonction *random()* du module *random* renvoie un nombre réel aléatoire dans l'intervalle $[0,1[$.
Voici un exemple.
from random import random
def alea():
return random()
print(alea())
*2) a.* $\quad$ Écrire en Python une fonction *alea_a()
* qui retourne un nombre aléatoire dans l'intervalle $[0;2[$.
Aide: Vous devez faire une simple modification de la fonction alea()
précédente
from random import random
def alea_a():
......
for i in range(20):
print(alea_a())
from random import random
def alea_a():
return random()*2
for i in range(20):
print(alea_a())
*2) b.* $\quad$ Écrire en Python une fonction *alea_b()
* qui retourne un nombre aléatoire dans l'intervalle $[1;3[$
Aide: Vous devez faire une simple modification de la fonction alea_a()
précédente
from random import random
def alea_b():
......
for i in range(20):
print(alea_b())
from random import random
def alea_b():
return random()*2+1
for i in range(20):
print(alea_b())
*2) c.*
somme2de()
* qui retourne la somme des faces de deux dés cubiques équilibré dont les faces sont numérotées de 1 à 6.print()
le résultat des dés dans la fonctionfrom random import randint
def somme2de():
print(somme2de())
from random import randint
def somme2de():
somme=randint(1,6)+randint(1,6)
return somme
for i in range(20):
print(somme2de())
if condition:
# Traitement bloc 1
else:
# Traitement bloc 2
Pour les tests multiples, il faudra enchaîner les if en cascade grâce à l'instruction elif, contraction de else if :
if condition:
# Traitement bloc 1
elif:
# Traitement bloc 2
else:
# Traitement bloc 3
Par exemple:
a=3
if a<5:
print(a,'appartient à ]-inf;5[')
elif 5<=a<10:
print(a,'appartient à [5;10[')
else:
print(a,'appartient à [10;+inf[')
Exercice 1 (si): Tarif du bateau
Écrire une fonction *tarif(age)
* qui doit lire l'âge d'une personne et afficher soit "Tarif réduit" si cette personne a strictement moins de 18 ans, soit "Tarif plein" dans le cas contraire.
Variables: | age | age | |
---|---|---|---|
Entrée: | 16 | 18 | |
Sortie: | Tarif réduit | Tarif plein |
def tarif(age):
if ... :
...
print(tarif(16))
print(tarif(18))
def tarif(age):
if age <18 :
return "tarif réduit"
else:
return "tarif plein"
print(tarif(16))
print(tarif(18))
*Exercice 2 (si):* Bornes kilométriques
bornes(a,b)
* qui doit lire deux entiers, correspondant à deux numéros de bornes kilométriques, et afficher la distance séparant ces deux bornes.Notez que le résultat doit être un nombre positif ou nul.
Variables: | b1, b2, d | b1, b2, d | |
---|---|---|---|
Entrée: | 25; 15 | 15; 25 | |
Sortie: | 10 | 10 |
def bornes(b1,b2):
if .... :
......
print(bornes(25,15))
print(bornes(15,25))
def bornes(b1,b2):
if b1>b2 :
distance = b1-b2
else:
distance = b2-b1
return distance
print(bornes(25,15))
print(bornes(15,25))
*Exercice 3 (si):*
On veux construire un triangle.
Ce que votre fonction doit faire
Écrire une fonction *estconstructible(a,b,c)
* qui renvoie *True* si l'on peut construire un triangle de côtés $a, b, c$ et *False* si ce triangle n'est pas constructible.
Aide: rechercher sur un moteur de recherche avec les mots *inégalité triangulaire collège*.
Exemples
Variables: | a, b, c | a, b, c | |
---|---|---|---|
Entrée: | 2 , 3, 6 | 2 3 4 | |
Sortie: | False | True |
def estconstructible(a,b,c):
if (...):
...
estconstructible(3,8,4)
def estconstructible(a,b,c):
if a+b>=c and b+c>=a and a+c>=b:
return True
else:
return False
print(estconstructible(6,8,4)) # True
print(estconstructible(3,8,4)) # False
*Exercice 4 (si):*
On lance un dé (équilibré, à six faces).
Ce que votre fonction doit faire
Écrire une fonction *jeude()
* qui simulera un lancer de dé et affichera la valeur du dé et le gain correspondant.
On rappelle que la fonction *randint(a,b)* renvoie un nombre entier au hasard entre a et b.
Exemples
Variables: | de, gain | de, gain | |
---|---|---|---|
Entrée: | |||
Sortie: | dé=2 gain=3€ | dé=1 gain=-2€ |
from random import randint
def jeude():
...
for i in range(4):
print(jeude())
from random import randint
def jeude():
de=randint(1,6)
if de==2 or de==4:
gain=3
elif de==6:
gain=4
else:
gain=-2
return f"dé={de}\ngain={gain}"
for i in range(4):
print(jeude())
*Exercice 5 (si):* Un site de tirage photos affiche les tarifs suivants:
Créer une fonction tarif_photos(n)
qui retourne le prix à payer si on développe $n$ photos.
def tarif_photos(n):
return prix
print(tarif_photos(10))
print(tarif_photos(100))
print(tarif_photos(1000))
def tarif_photos(n):
if 1<=n<=19:
prix=0.16*n+3
elif 20<=n<=499:
prix=0.14*n+4
elif n>=500:
prix=0.12*n
return prix
print(tarif_photos(10))
print(tarif_photos(100))
print(tarif_photos(1000))
for e in [ 'pomme' , 'poire' , 'kiwi' ]:
print(e)
Pour créer une boucle équivalente aux boucles traditionnelles << pour i allant de m à n, faire ... >>, nous utiliserons la fonction *range().
La syntaxe générale est for i in range(m,n,p):*
i prend alors toutes les valeurs de m à n-1 par pas de p
for i in range(0,4):
print(i)
for i in range(4):
print(i)
for i in range(0,6,2):
print(i)
for i in range(4,0,-1):
print(i)
Exercice 1 (for): Les punitions
punition(nblignes)
* qui écrira autant de fois que demandé la phrase << Je dois suivre en cours >>.Variables: | nblignes | |
---|---|---|
Entrée: | 3 | |
Sortie: | Je dois suivre en cours Je dois suivre en cours Je dois suivre en cours |
def punition(nblignes):
for i in .....:
.....
punition(10)
def punition(nblignes):
for i in range(nblignes):
print("Je dois suivre en cours")
punition(10)
Exercice 2 (for):
Qu'affiche le script ci-dessous?
Réfléchissez bien avant de l'exécuter.
for i in range(1,10):
print(i)
Exercice 3 (for):
Écrire une fonction table(n)
qui affiche la table de multiplication d'un entier n pour des multiplicateurs variant de 1 à 9.
Variables: | n |
---|---|
Entrée: | 3 |
Sortie: | 1×3=3 2×3=6 3×3=9 •••••• |
def table(n):
for i in .....:
print(.....)
table(6)
def table(n):
for i in range(1,10):
print(f'{i}*{n}={i*n}')
table(6)
Exercice 4 (for):
Écrire un script pour afficher toutes les tables de mutiplication pour les entiers de 1 à 6.
Aide: On utilisera la fonction table(n)
précédente.
for i in .....:
......
for i in range(1,7):
table(i)
print()
Exercice 5 (for):
On rappelle que l'on peut plusieurs fois une chaine de caractère avec l'opérateur *****
Par exemple 'o'*11
print('o'*11)
On rappelle "abc"+"def"
permet de concaténer deux chaînes de caractères
print("abc"+"def")
Écrire un script qui affiche le motif ci-dessous :
o
oo
ooo
oooo
ooooo
oooooo
ooooooo
oooooooo
ooooooooo
oooooooooo
for i in .....:
print(.....)
for i in range(1,11):
print('o'*i)
Exercice 6 (for):
Écrire un script qui affiche le motif ci-dessous :
ooooooooo
oooooooo
ooooooo
oooooo
ooooo
oooo
ooo
oo
o
for i in range(1,11):
print("o"*(10-i))
Exercice 7 (for):
Écrire un script qui affiche le motif ci-dessous :
o
oo
ooo
oooo
ooooo
oooooo
ooooooo
oooooooo
ooooooooo
oooooooooo
for i in range(1,11):
print(" "*(10-i)+"o"*i)
Exercice 8 (for):
Un jeu à deux joueurs.
a) Écrire une fonction lance_2de()
en Python qui simule le lancer de deux dé et renvoie
from random import randint
def lance_2de():
.....
for i in range(10):
print(lance_2de())
from random import randint
def lance_2de():
de1=randint(1,6)
de2=randint(1,6)
if de1>de2:
return 1
elif de1<de2:
return 2
else:
return 0
for i in range(10):
print(lance_2de())
b) Écrire une fonction frequence(n)
en Python qui renvoie la fréquence de parties gagnées par le joueur 1 lors de $n$ parties.
def frequence(n):
somme=0
......
frequence(10)
def frequence(n):
somme=0
for i in range(n):
if lance_2de()==1:
somme=somme+1
return somme/n
frequence(10)
Observer les valeurs obtenues pour la fréquence de parties gagnées par le joueur 1 pour de grandes valeurs de $n$.
Expliquez ces valeurs.
La seconde structure de boucle est le << tant que >> : tant qu'une condition est vraie, on boucle.
Attention : dans ce type de boucle on utilise une variable de boucle dont la valeur doit changer pour pouvoir sortir de la boucle :
i=0
while i<4:
print(i)
i=i+1
i=0
while i<4:
i=i+1
print(i)
Exercice 1 (while): Le principe
Soit $f$ la fonction affine définie par $f(x)=2*x-5$
On souhaite afficher toutes les images de $f$ pour $x$ allant de -2 à 2 par pas de 0,25.
a) Que renvoie le programme suivant?
def f(x):
return 2*x-5
for i in range(-2,3,0.25):
print(i)
Regardez bien le message d'erreur qui apparaît.
Pour contourner ce problème on utilisera une boucle while
.
b) En utilisant une boucle while
faire afficher toutes les images de $f$ pour $x$ allant de -2 à 2 par pas de 0,25.
def f(x):
return 2*x-5
i=-2
while ... :
...
...
def f(x):
return 2*x-5
i=-2
while i<=2 :
print(f"f({i})={f(i)}")
i=i+0.25
Exercice 2 (while):
En utilisant une boucle *while, écrire une fonction somme(n)
* $S_n=1+2+3+...+n$
def somme(n):
print(somme(10))
def somme(n):
som=1
i=1
while i<n:
i=i+1
som=som+i
return som
print(somme(3))
Parfois il est préférable de rentrer les valeur "à la volée". On utilise pour cela la fonction *input()* Cela correspond à *saisir* en algorithmique.
a=input("Saisir un nombre a: ") # On saisit a
print(a) # On affiche a
print(type(a)) # On affiche le type de a
b=int(input("Saisir un entier b: "))
print(b)
print(type(b)
c=float(input("Saisir un réel c: "))
print(c)
print(type(c))
Exercice 3 (while): Le nombre mystère
Votre programme doit donner un nombre au hasard entre 1 et 100.
Il faudra proposer des nombres pour trouver ce nombre mystère et afficher à chaque proposition de nombre le texte *<< c'est plus >>* lorsque le nombre proposé est trop petit ou *<< c'est moins >>* lorsque le nombre proposé est trop grand.
À la fin, il faudra afficher le texte << Bravo vous avez gagné >> et le nombre d'essais qui ont été nécessaires.
Variables: | nb_coups, mystere, essai | |
---|---|---|
Entrée: | 8; 45; 43; 44 | |
Sortie: | c'est plus c'est moins c'est plus Bravo vous avez gagné en 4 essais. |
Pour donner un nombre au hasard entre 1 et 100 on utilisera:
import random
mystere=random.randint(1,100)
import random
mystere=random.randint(1,100)
import random
mystere=random.randint(1,100)
n=None # Le nombre que l'on doit saisir, Il faut créer la variable avant de tester si n!=mystere
compteur=0 # Le compteur
while n!=mystere:
n=int(input("Saisir un entier entre 1 et 99: "))
compteur=compteur+1
if n>mystere:
print("C'est moins")
elif n<mystere:
print("C'est plus")
print(f"Bravo le nombre mystère était {mystere} et vous avez gagné en {compteur} essais.")