Ce fichier est un notebook Python.
Il comporte deux types de cellules :
les cellules d'édition dans lesquelles vous pouvez saisir du texte éventuellement enrichi de mises en formes ou de liens hypertextes avec la syntaxe du langage HTML simplifié qui s'appelle Markdown. Voir http://daringfireball.net/projects/markdown/ pour la syntaxe de Markdown.
les cellules de code où l'on peut saisir du code Python3 puis le faire exécuter avec la combinaison de touches CTRL + RETURN
Une cellule peut être éditée de deux façons différentes :
en mode commande lorsqu'on clique sur sa marge gauche qui est surlignée alors en bleu, on peut alors :
changer le type de la cellule en appuyant sur m pour passer en cellule Markdown ou sur y pour passer en cellule de code
insérer une cellule juste au-dessus en appuyant sur a
insérer une cellule juste en-dessous en appuyant sur b
couper la cellule en appuyant sur x etc ...
en mode édition lorsqu'on clique sur l'intérieur de la cellule.
L'aide complète sur les raccourcis claviers est accessible depuis le bouton Help dans la barre d'outils ci-dessus.
Un algorithme décrit une suite d'instructions que l’on souhaite faire exécuter par un ordinateur. Un programme informatique est la traduction d'un algorithme dans un langage de programmation. Ce langage possède une grammaire et une syntaxe à respecter avec un nombre limité de mots clefs. Le programme est souvent dénommé code source.
Nous utiliserons le langage Python dans sa version 3. Le site officiel est Python.org et la documentation de la version 3 se trouve sur https://docs.python.org/3/.
In [94]:
# ceci est un commentaire, l'interpréteur ne le lit même pas
# les commentaires sont destinés au lecteur humain du code source
code = 'sesame' #affectation de variable
rep = input('Entrez le code : ') #affectation et instruction d'entrée
if rep == code: # test et début d'un bloc d'instructions
print('Vous pouvez entrer.') # instruction si test vrai
else:
print('Code incorrect, désolé ce ne sera pas possible.') # instruction si test faux
Réponse à l'exercice 0
Saisissez votre réponse dans cette cellule
Le plus simple est d'installer l'environnement de développement (ou Integrated Development Environment) Pyzo puis la distribution Python Anaconda en suivant le guide rapide d'installation sur le site de Pyzo. Installez bien Anaconda et non pas Miniconda (sauf sur votre clef USB éventuellement) car Anaconda inclut tous les modules nécessaires et le Jupyter Notebook si pratique que vous êtes en train d'utiliser. Par la suite nous travaillerons plutôt avec l'IDE Pyzo.
On peut installer des modules supplémentaires depuis Pyzo avec l'un des outils conda ou pip, voir http://www.pyzo.org/install_packages.html#install-packages.
pygame pose problème avec conda et pip. Dans ce cas on se rend sur le site http://www.lfd.uci.edu/~gohlke/pythonlibs/ et on télécharge le paquet wheel de pygame qu'on installe avec pip install paquet.whl
En cas de problème contactez le professeur par la messagerie de l'ENT.
Ce document est disponible sur un dépôt Github https://github.com/parcicn/Introduction-python
Le cahier de textes d'ICN est disponible sur Pronote (via l'ENT) mais aussi sur cette page http://www.frederic-junier.org/ICN/Progression/ICN_2018.html
Le site de référence est http://www.france-ioi.org, si vous souhaitez progresser, il faut s'entraîner et ce site est la plateforme idéale : créez un compte puis suivez le parcours lycée pour commencer.
Pour visualiser ce que fait la machine lors de l'exécution d'un code Python, et mieux comprendre le fonctionnement du langage, un bon outil est http://pythontutor.com/
In [1]:
# L'opérateur + réalise l'addition de deux entiers
1 + 2
Out[1]:
In [60]:
# L'opérateur + réalise aussi l'addition de deux flottants
2.0 + 3.5
Out[60]:
In [61]:
# L'opérateur * réalise la multiplication de deux entiers
3 * 2
Out[61]:
In [62]:
# L'opérateur * réalise aussi la multiplication de deux flottants
2.0 * 3.14
Out[62]:
In [2]:
# L'opérateur - réalise la soustraction de deux entiers ou de deux flottants
(10 - 4, 3.14 - 0.14) #on utilise des parenthèses pour créer un couple de valeurs
Out[2]:
In [64]:
# L'opérateur ** réalise l'exponentiation d'un entier par un entier, idem pour les flottants
(2 ** 3, 2.0 ** 0.5)
Out[64]:
In [65]:
# L'opérateur // retourne le quotient de la division euclidienne de deux entiers
15 // 4
Out[65]:
In [66]:
# L'opérateur / retourne l'approximation du quotient par le flottant le plus proche
(15 / 4, 2/3)
Out[66]:
In [67]:
# L'opérateur % retourne le reste de la division euclidienne de deux entiers
15 % 4
Out[67]:
Les opérateurs arithmétiques suivent des règles de précédence (priorité de l'exponentiation sur la multiplication et de la multiplication sur l'addition). Ces priorités peuvent être changées dans un calcul à l'aide de parenthèses.
In [68]:
( 1 + 2 * 3 ** 2) / 2
Out[68]:
In [69]:
1 + 2 * 3 ** 2 / 2
Out[69]:
python dans la cellule suivante (vous pouvez insérer une cellule par calcul):5 ** 2
9 * 5
15 / 12
12 / 15
15 // 12
12 // 15
5 % 2
9 % 5
15 % 12
12 % 15
6 % 6
0 % 7
6 * 1 - 2 pour changer sa valeur de 4 à -6.
In [6]:
# Répondez à l'exercice 1 à partir de cette cellule de code
# Vous saisissez un calcul puis vous appuyez sur CTRL + Return pour obtenir le résultat
#pour insérer ensuite une nouvelle cellule de code en-dessous, appuyez sur b.
Un petit nombre d'insctructions élémentaires permettent de traduire dans un langage de programmation tout type d'algorithme exécutable par un ordinateur.
Une variable est l'association d'un espace de la mémoire de l'ordinateur, accessible par son nom, et d'une valeur que l'on y stocke. En Python on définit une variable par une instruction d'affectation, par exemple pour affecter la valeur 12 à la variable de nom a on écrit :
a = 12
Un langage de programmation fixe des contraintes pour les nomes de variables. En Python les seuls caractères autorisés sont les caractères non accentués, les chiffres (sauf en première position) et le tiret bas (mais pas le tiret haut).
1var = 13 #nom incorrect
var1 = 13 #nom correct
var-1 = 14 #nom incorrect
var_1 = 14 #nom correct
Un langage de programmation n'accepte par défaut qu'un nombre fini de types de valeurs, ainsi une variable est caractérisée par son type accessible par la fonction type et qu'on peut afficher avec la fonction print:
type(a)
In [7]:
# Cellule de code pour répondre à l'exercice 2
int pour les entiers
In [70]:
a = 12
print(type(a))
float pour les flottants (approximations de réels)
In [71]:
b = 1/3
print(type(b))
bool pour les booléens (deux valeurs logiques possibles True ou False)
In [72]:
c = (1 < 3)
In [73]:
c
Out[73]:
In [74]:
print(type(c))
In [75]:
d = ( 1 == 2)
In [76]:
d
Out[76]:
In [77]:
print(type(d))
str pour les chaînes de caractères
In [78]:
e = 'Hello World'
print(e)
In [79]:
print(type(e))
list pour les listes (conteneurs de plusieurs valeurs)
In [80]:
L = [1, 2, 4]
print(L)
In [81]:
print(type(L))
tuple pour les tuple (conteneurs de plusieurs valeurs comme les listes mais non modifiable une fois défini)
In [82]:
coord = (1, 2)
print(coord)
In [83]:
print(type(coord))
print pour un affichage sur la sortie standard qui par défaut est l'écran.
In [15]:
print(Bonjour)
Pour afficher du texte, celui-ci doit être contenu dans une chaîne de caratère délimitée par des apostrophes comme 'La mer' ou des guillemets comme "L'océan".
In [16]:
print('Bonjour')
On peut aussi afficher la valeur d'une expression obtenue par évaluation d'une combinaison de littéraux (valeurs correspondant aux types de base du langage), d'opérateurs et de variables
In [17]:
n = 2000
print(2017 - n)
On peut passer plusieurs arguments à la fonction print en les séparant par une virgule, print les affichera par concaténation en utilisant un espace vide par défaut comme séparateur.
In [18]:
print('Vous avez ', 2017 - n, ' ans')
Par défaut, print effectue un saut de ligne après chaque affichage mais on peut changer ce comportement par défaut en réglant le paramètre optionnel end=''.
In [19]:
print('Ligne 1')
print('Ligne 2')
In [20]:
print('Colonne 1', end='|')
print('Colonne 2')
On peut aussi changer le paramètre de séparation par défaut sep=''.
In [21]:
print('Colonne 1', 'Colonne 2', sep='|')
Pour afficher l'aide sur une fonction en python, on peut utiliser la documentation en ligne sur https://docs.python.org/3/ ou la documentation intégrée avec la fonction help.
In [1]:
help(print)
In [2]:
# Répondre à l'exercice 3 dans cette cellule de code
input récupère un texte un saisi par l'utilisateur après un prompt et retourne la saisie sous forme de chaîne de caractères. La fonction prend comme argument optionnel le prompt qui doit être une chaîne de caractères.
In [ ]:
date = input('Entrez votre date de naissance : ')
print('Vous avez ', 2017 - date, 'ans')
Réponse à l'exercice 4
Saisissez ici votre réponse
In [3]:
# Répondez à l'exercice 5 dans cette cellule de code
Un test est composé d’une instruction de contrôle puis d'un bloc d'instructions.
En Python, l'instruction de contrôle commence par le mot clef if suivi d’une
condition à valeur booléenne (True ou False) et se termine par le symbole :.
Le bloc d’instructions qui suit s'exécute si et seulement si la condition de l'instruction de contrôle a pour valeur True . Il correspond à un embranchement dans le flux d'instructions.
En Python, un bloc d'instructions commence à la première ligne suivant le symbole : et son imbrication dans le reste du programme est caractérisée par son niveau d'indentation. Toutes les instructions d'un même bloc doivent avoir le même niveau d'indentation. Le flux principal d'instructions est collé contre la marge puis chaque niveau d'indentation est décalé de quatre espaces ou une tabulation vers la droite.
# flux parent
if conditionA:
#bloc d'instructions exécuté si la valeur de conditionA est True
if conditionB:
#bloc d'instructions imbriqué, exécuté si conditionA est à True
# et si conditionB est à True
# retour au flux parent
Si la condition du test n'est pas vérifiée, on peut prévoir l'exécution d'un bloc d'instructions alternatif après un else :.
# flux parent
if condition:
#bloc d'instructions exécuté si la valeur de condition est True
else:
#bloc d'instructions exécuté si la valeur de condition est False
#retour au flux parent
On peut aussi tester d'autres conditions mutuellement exclusives pour modéliser un choix entre plus de deux alternatives. Chaque condition testée dans un elif condition : commande un bloc d'instructions et un bloc d'instructions par défaut peut se trouver après un else :.
# flux parent
if condition1:
#bloc d'instructions exécuté si la valeur de condition1 est à True
elif condition2:
#bloc d'instructions si condition2 est True (et condition1 est à False)
elif condition3:
#bloc d'instructions si condition3 est True (et condition1 et condition2 sont à False)
else :
#bloc d'instruction si toutes les conditions précédentes sont à False
#retour au flux parent
Une condition de test doit avoir une valeur booléenne, ce peut être le résultat :
d'une comparaison arithmétique entre deux valeurs numériques a et b :
Python est a == bPython est a != bPython est a < b ou a > b ou a <= b ou a >= bd'une opération logique entre deux valeurs booléennes x ou y :
Python est not xPython est x or yPython est x and yIl existe des règles de priorité : opérateurs arithmétiques prioritaires sur les opérateurs logiques, not prioritaire sur and qui est prioritaire sur or. Des parenthèses permettent de changer les priorités.
In [1]:
# Cellule pour exécuter le code de l'exercice 6
L'Indice de Masse Corporelle se calcule par la formule $\text{IMC}=\frac{masse}{taille^2}$ où la masse est en kilogrammes et la taille en mètres. Un IMC est considéré comme normal s'il est compris entre 18 et 25. En dessous de 18, la personne est en sous-poids et au-dessus de 25 elle est en surpoids.
In [2]:
# Répondre à la première question de l'exercice 7 dans cette cellule de code
In [6]:
# Répondre à l'exercice 8 dans cette cellule de code
Une boucle inconditionnelle permet de répéter un bloc d'instructions lorsqu'on connaît à l'avance le nombre de répétitions.
La situation la plus courante est :
Pour k allant de 1 à 10 répéter
Bloc d'instructions
FinPour
Sa traduction en Python est :
# flux parent
for k in range(1, 11):
# bloc d'instructions
# retour au flux parent
On remarque l'utilisation range(1, 11) alors qu'on attendrait range(1, 10).
En fait range(1, 11) retourne un itérateur, qui va parcourir avec un incrément de 1 tous les entiers $n$ tels que $1 \leqslant n < 11$.
Il faut bien se souvenir que la borne supérieure de range(n, m) est exclue mais il est facile de retenir que le nombre de tours de boucles est $m - n$.
Par exemple, pour calculer la somme des tous les entiers consécutifs de 100 à 200, on peut écrire :
somme = 0
for k in range(100, 201):
somme = somme + k
print("La somme est ", somme)
S'il s'agit juste de répéter n fois un bloc d'instructions on utilise le raccourci range(n) au lieu de range(0, n) ou de range(1, n + 1).
Par exemple pour dire 100 fois "Merci", on peut écrire :
for k in range(100):
print("Merci !")
print("Ouf!")
La fonction range offre un troisième paramètre optionnel qui permet de changer l'incrément par défaut qui est 1.
Par exemple, pour calculer la somme des tous les entiers pairs consécutifs entre 100 et 200, on peut écrire :
sommePair = 0
for k in range(100, 201, 2):
sommePair = sommePair + k
print("La somme est ", sommePair)
Enfin, la boucle for permet aussi de parcourir des objets itérables comme les chaînes de caractères, les listes, les fichiers etc ...
Par exemple pour afficher les caractères consécutifs de la chaîne "Bonjour" avec un caractère par ligne, on peut écrire :
chaine = "Bonjour"
for c in chaine:
print(c)
Autre exemple, pour afficher des messages d'invitation personnalisés :
for nom in ["Jean-Luc", "Emmanuel", "François", "Marine"]:
print("Salut", nom, "je t'invite à mon anniversaire samedi !")
n premiers entiers de 1 à n, la valeur entière strictement positive de n étant saisie par l'utilisateur. On notera l'utilisation de k += 1 comme raccourci pour l'incrémentation k = k + 1. Recopier et compléter ce programme pour qu'il calcule également le produit des n premiers entiers consécutifs $1 \times 2 \times 3 \times \ldots \times n$. Tester pour $n = 100$, que peut-on dire de l'ordre de grandeur du produit ? n = int(input('Entrez un entier n strictement positif : '))
somme = 0
for k in range(1, n + 1):
somme += k
print(somme)
Écrire un programme qui affiche les 10 premiers multiples de 2 sous la forme :
2 x 1 = 2
2 x 2 = 4
....
2 x 10 = 20
Modifier le programme précédent pour qu'il affiche les tables de mulplications pour les 10 premiers multiples de tous les entiers compris entre 1 et 9
In [3]:
# Répondre à l'exercice 9 dans cette cellule de code
ab = input('Entrez une chaîne de caractères : ')
ba = ''
for c in ab:
ba = .....
print('Voici la chaîne inversée : ', ba)
In [4]:
# Répondre à l'exercice 10 dans cette cellule de code
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 une fonction maximum qui prend en paramètres deux nombres x et y et qui retourne leur maximum, s'écrira :
def maximum(x, y):
if x < y:
return y
else:
return x
En fait, l'exécution d'une instruction return correspond à une sortie de la fonction, toutes les instructions suivantes ne seront pas exécutées. Ainsi la fonction précédente peut s'écrire plus simplement :
def maximum2(x, y):
if x < y:
return y
return x
Nous venons de voir la définition d'une fonction. On exécute la fonction en substituant aux paramètres formels des valeurs particulières appelées arguments. Cette instruction se nomme un appel de fonction :
note1 = int(input('Entrez une note')) #récupération d'un argument
note2 = int(input('Entrez une note')) #récupération d'un autre argument
maxi = maximum2(note1, note2) #affectation de la valeur retournée par un appel de fonction
Il existe aussi des fonctions sans paramètres d'entrée ou sans valeur de retour. Par exemple, une fonction qui affiche le nom complet d'un acronyme peut s'écrire :
def icn():
print("Informatique et Création Numérique")
Attention, return valeur retourne valeur qu'on peut capturer dans une variable alors que print(valeur) affiche valeur sur la sortie standard (l'écran par défaut) mais valeur ne peut alors être capturée dans une variable.
def f(x):
return x ** 2
binf = 0 #borne inférieure
bsup = 2 # borne supérieur
pas = 0.1 # pas
n = int( (bsup - binf)/pas) + 1 # calcul du nombre de valeurs
tabx = [0] * n #initilisation de la liste des x
taby = [0] * n #initialisation de la liste des y
x = binf
for k in range(n):
tabx[k] = x
taby[k] = f(x)
x = x + pas
Rechercher sur le web, la formule de conversion d'une température de l'échelle des degrés Celsius dans celle des degrés Fahrenheit
Écrire en Python une fonction celsius2fahrenheit(t) puis la fonction réciproque fahrenheit2celsius(t).
In [5]:
# Répondre à l'exercice 11 dans cette cellule de code.
Réponse à l'exercice 12 :
Compléter cette cellule de texte
in d'appartenance
In [13]:
chaine = 'Bonjour'
In [15]:
'b' in chaine
Out[15]:
In [16]:
'B' in chaine
Out[16]:
In [18]:
liste = [0, 7]
In [19]:
8 in liste
Out[19]:
In [20]:
0 in liste
Out[20]:
+ de concaténation
In [26]:
chaine = 'Bonjour'
liste = [0,7]
In [22]:
chaine2 = chaine + ' à tous.'
In [23]:
chaine2
Out[23]:
In [27]:
liste2 = [0] + liste
In [28]:
liste2
Out[28]:
len permet d'obtenir la longueur du conteneur avec len(conteneur).
In [39]:
len(liste2), len(chaine2)
Out[39]:
L'opérateur [] permet d'accéder à l'élément en position k dans le conteneur (chaîne ou liste) avec la syntaxe conteneur[k].
Attention les positions sont indexées de gauche à droite de 0 à len(conteneur)-1 et de droite à gauche de $-1$ à -len(conteneur).
In [30]:
chaine = 'Bonjour'
liste = [0,7]
D'abord les index positifs
In [34]:
chaine[0], chaine[1], chaine[len(chaine) - 1]
Out[34]:
Voici ce qui se produit lorsqu'on essaie d'accéder à un index hors de la plage
In [35]:
chaine[len(chaine)]
Et maintenant les index négatifs
In [37]:
chaine[-1], chaine[-2], chaine[-len(chaine)]
Out[37]:
La fonction lower permet de convertir tous les caractères en minuscules.
De même la fonction upper permet de convertir tous les caractères en majuscules
Il s'agit de méthodes internes qu'on applique avec la syntaxe chaine.lower() ou chaine.upper().
In [41]:
chaine = 'Bonjour'
In [42]:
chaine.lower()
Out[42]:
In [43]:
chaine.upper()
Out[43]:
append avec la syntaxe liste.append(element).
In [15]:
liste = [0,7]
liste.append(1)
print(liste)
pop avec la syntaxe liste.pop(k) où k est la position de l'élément à sortir, entre 0 et len(liste) - 1 qui est la valeur par défaut.
In [19]:
liste = [9,3]
a = liste.pop()
print(liste, a)
liste.append(4)
print(liste)
b = liste.pop(0)
print(b, liste)
split découpe une chaîne de caractères selon le caractère de séparation sep avec la syntaxe chaine.split(sep).
In [22]:
chaine = 'Frédéric,Junier,enseignant,mathématiques'
champs = chaine.split(',')
print(champs)
join permet de recoller les chaînes de caractères séparées dans une liste champs selon un caractère de jointure sep passé en paramètre avec la syntaxe 'sep'.join(champs).
In [23]:
chaine2 = '*'.join(champs)
print(chaine2)
En informatique la couleur associée à un pixel de l'écran est souvent représentée sous la forme d'un triplet d'entiers comme (R, G, B). La première composante R représente la quantité de Rouge, la deuxième G celle de vert et la troisième B celle de jaune. Par addition des couleurs primaires Rouge, Vert et Bleu on peut représenter n'importe quelle couleur du spectre visible. Les couleurs de pixels sont en général codées sur 3 octets ce qui donne 8 bits par composante c'est-à-dire $2^8=256$ valeurs : de 0 pour l'absence de couleur à 255 pour l'intensité maximale.
C de type liste contient une couleur, mais laquelle ?C = [255, 255, 255]
C pour qu'elle code la couleur jaune ? la couleur noire ?
On pourra s'aider de l'outil sur la page https://www.w3schools.com/colors/colors_picker.asp.
In [6]:
# Cellule de code pour répondre à l'exercice 13
Les fichiers au format postcript sont des fichier textes contenant des instructions permettant de représenter une image dans un format vectoriel à l'aide des fonctions mathématiques du langage de programmation postscript. Ces fichiers peuvent être convertis en fichiers de format binaire comme le format png à l'aide de programme comme convert de la bibliothèque ImageMagick.
En informatique, quelle est la différence entre un fichier texte et un fichier binaire ?
Quelle est la différence entre une image de format vectoriel et une image de format binaire ? Citez des formats vectoriels ou bitmap connus.
Compléter la fonction conversion_nom(source, ext) où le paramètre source est un nom de fichier de la forme nombase.extension, pour qu'elle retourne le nom associé après remplacement de l'extension source par l'extension ext passée en paramètre.
def conversion_nom(source, ext):
# à compléter
# return
In [7]:
# Cellule de code pour répondre à l'exercice 14
Dans un langage de programmation une bibliothèque est un ensemble de fonctions qui constitue une trousse à outils autour d'un même thème. Si cette bibliothèque est installée sur sa machine on peut l'importer dans un programme pour utiliser ses fonctions.
Une bibliothèque écrite en Python s'appelle un module. Il existe des milliers de modules et l'un des plus populaires dans l'informatique éducative est turtle qui implémente en Python les fonctions du légendaire langage graphique Logo
Pour importer toutes les fonctions du module turtle dans son programme on écrit :
from turtle import *
Pour utiliser la fonction penup() du module on écrira alors penup().
On peut également créer juste un point d'accès au module turtle avec :
import turtle
Pour utiliser la fonction penup() du module on écrira alors turtle.penup().
Pour découvrir quelques fonctions de turtle, lire puis exécuter le programme ci-dessous dans la cellule juste après celle-ci.
Si vous avez un message d'erreur contenant le terme Terminator, exécutez la cellule de nouveau.
Pour aller plus loin, vous pouvez consulter la documentation sur https://docs.python.org/3/library/turtle.html#module-turtle
In [27]:
from turtle import *
speed(1) #parametrage de la vitesse de 1 lent à 10 rapide, 0 étant la vitesse la plus rapide
shape("turtle") #choix de la forme de la tortue
pencolor("red") #choix de la couleur du crayon
pensize(4) #épaisseur du crayon
penup() #lever le crayon
goto(0,0) # aller à la position (0,0)
setheading(0) #orientation de la tortue vers l'Est / 90 Nord / 180 Ouest / 270 Sud
pendown() #poser le crayon
for k in range(4):
forward(100) #avancer de 100 pixels
left(90) #tourner de 90 degrés
mainloop() #gestionnaire d’evenement, indispensable pour l’affichage et l’interactivite
In [8]:
# Cellule de code pour répondre à l'exercice 16
from turtle import *
couleur = ["red", "yellow", "green", "blue", "purple", "navy"]
rayon = 400
largeur = 2 * rayon
hauteur = 2 * rayon
screensize(largeur, hauteur)
pensize(5)
penup()
goto(0, -rayon)
pendown()
for k in range(4):
#à compléter
mainloop()
circle du module turtle sur https://docs.python.org/3/library/turtle.html#turtle.circle puis compléter et reopier le programme ci-dessus pour qu'il trace une figure similaire à celle-ci :Le module random offre plusieurs fonctions permettant de générer des nombres pseudo-aléatoires.
Par exemple pour générer un nombre pris au hasard dans l'intervalle [ 0 ; 1 [ on utilise la fonction random sans argument et pour générer un nombre entier pris au hasard dans l'intervalle [1 ; 6] on utilise la fonction randint :
from random import random, randint
a = random() # nombre aléatoire dans [0 ; 1 [
b = randint(1, 6) # entier aléatoire dans [1 ; 6 ]
Rechercher sur le web la définition d'un nombre pseudo-aléatoire.
On donne ci-dessous la liste des noms des 16 couleurs définies dans la norme HTML, le langage HTML permettant d'écrire des pages Web.
couleur = ["red", "yellow", "green", "blue", "purple", "navy", "lime", "maroon", "olive",
"gray", "black", "teal","fuchsia", "white", "silver"]
couleur_alea(c) de paramètre c une liste de noms de couleurs, qui retourne le nom
d'une couleur choisie aléatoirement dans la liste.couleur_alea(c) pour compléter le programme ci-dessous afin qu'il trace une figure aléatoire comme ci-dessus, constituée d'un nombre aléatoires de cercles de rayons et de couleurs également aléatoires :from turtle import *
from random import randint
def couleur_alea(c):
# à compléter
couleur = ["red", "yellow", "green", "blue", "purple", "navy", "lime", "maroon", "olive", "gray", "black","teal","fuchsia", "white", "silver"]
rayonMax = 400
largeur = 2 * rayonMax
hauteur = 2 * rayonMax
screensize(largeur, hauteur)
speed(0)
shape("turtle")
pensize(2)
for i in range(randint(10, 50)):
delay(100) #pause de 100 millisecondes
# à compléter
delay(100)
mainloop()
In [10]:
# cellule de code pour répondre à l'exercice 18
Généralement, on souhaite répéter un bloc d'instructions tant qu'une condition est réalisée mais on ne sait pas à l'avance combien de répétitions seront nécéssaires.
La situation la plus courante est :
Tant Que Condition répéter
Bloc d'instructions
Fin Tant Que
Elle se traduit en Python par :
# flux parent
while condition:
# bloc d'instructions indenté
# retour au flux parent
Par exemple, pour demander la saisie d'un login jusqu'à une saisie correcte, on peut écrire :
login = 'moi'
saisie = input('Login ?') # initialisation de la condition d'entrée de boucle
while saisie != login: # test d'entrée de boucle
saisie = input('Login ?') # mise à jour de la condition de boucle
print('Bienvenue ', login) # sortie de boucle
Évidemment, on peut aboutir à une boucle infinie si la condition d'entrée de boucle n'est jamais vérifiée.
On peut prévoir des conditions plus complexes avec des opérateurs booleens.
Par exemple si on veut limiter à 10 demandes de login, on peut écrire :
login = 'moi'
compteur = 1
saisie = input('Login ?') # intialisation de la condition d'entrée de boucle
while compteur < 10 and saisie != login: # test d'entrée de boucle
saisie = input('Login ?') # mise à jour de la condition de boucle
compteur = compteur + 1 # mise à jour du compteur
if compteur == 10 and saisie != login:
print('10 tentatives de login échouées')
else:
print('Bienvenue ', login) # sortie de boucle
Enfin remarquons que toute boucle for peut s'écrire avec une boucle while :
somme = 0
for k in range(100, 201):
somme = somme + k
print("La somme est ", somme)
peut ainsi s'écrire :
somme = 0
k = 100
while k < 201:
somme = somme + k
k = k + 1
print("La somme est ", somme)
Dans cet exercice on n'utilisera ni la fonction int de conversion en entier, ni la fonction sqrt du module math
Écrire une fonction intSquareFloor(n) qui retourne le plus petit entier $p$ tel que $p^2 > n$.
Écrire une fonction intSquareFloor2(n) qui retourne le plus grand entier $p$ tel que $p^2 \leqslant n$.
In [11]:
# Cellule de code pour répondre à l'exercice 19
premier6() ci-dessous pour qu'elle retourne le rang du premier 6.from random import randint
def premier6():
de = randint(1, 6)
rang = 1
# while à compléter
# bloc du while
return rang
n de fois l'expérience qui consiste à lancer un dé cubique jusqu'à obtenir un premier 6, compléter le programme précédent avec une fonction rangMoyen(n) qui retourne le rang moyen du premier 6 sur cet échantillon de taille n.def rangMoyen(n):
sommeRang = 0
for k in range(n):
# à compléter
return sommeRang / n
In [12]:
# Cellule de code pour répondre à l'exercice 20
La portée d'une variable définit où (dans quelle partie du programme) et comment une variable est accessible (en lecture, en écriture ?).
En Python, les variables sont caractérisées par leur nom et leur valeur et comme dans la plupart des langages on distingue deux types d'espaces où les variables sont accessibles :
L'espace de nommage global contient toutes les variables dites globales qui ont été définies dans le programme principal.
Une variable globale est accessible en lecture dans le programme principale et dans les fonctions définies dans le programme.
L'accès en écriture est plus subtil :
si une variable du même nom est créé par une affectation à l'intérieur du bloc d'instruction d'une fonction, cette variable sera considérée comme locale et n'écrasera pas la variable globale du même nom.
Ce comportement par défaut peut être modifié en rajoutant l'instruction global suivie du nom de la variable au début du bloc.
néanmoins pour les variables globales de certains types comme list, il est possible de modifier la valeur d'un élément de la liste avec l'opérateur crochet.
# import des modules ou bibliothèques externes
from random import randint
# variables globales avec une majuscule pour les distinguer
Npommier = 10
PomMax = 200
# fonctions ne manipulant pas de variables globales
# conseillé car on peut ainsi changer les noms des variables globales ou réutiliser les fonctions
def cueille_pomme(p, k):
'''Ramasse une pomme sur le pommier
en position k dans la liste de pommiers p'''
p[k] = p[k] - 1
def recolte_pommier(p, k):
'''Cueille toutes les pommes sur le pommier
en position k dans la liste de pommiers p'''
r = 0
while p[k] > 0:
cueille_pomme(p, k)
r += 1
return r
def recolte_champ(p):
'''Cueille toutes les pommes des pommiers
contenus dans la liste p'''
panier = 0
for k in range(len(p)):
panier += recolte_pommier(p, k)
return panier
# seule la fonction d'initialisation utilise des variables globales
def initialisation_champ():
'''Retourne une liste de pommiers
p[k] contiendra le nombre de pommes sur le pommier en position k,
ce nombre est un entier aléatoire entre 0 et la varaiable globale PomMax'''
p = [0] * Npommier
for k in range(Npommier):
p[k] = randint(0, PomMax)
return p
# programme principal
pommier = initialisation_champ() # initialisation de la liste représentant tous les pommiers
print(pommier)
panier = recolte_champ(pommier) # récolte de toutes les pommes sur tous les pommiers
print(panier)
from random import randint
# variables globales
nbPommier = 10
pommier = [0] * nbPommier
pomMax = 200
panier = 0
# la plupart des fonctions manipulent des variables globales (déconseillé)
def ramasse_pomme(k):
pommier[k] = pommier[k] - 1
def recolte_pommier(k):
global panier
while pommier[k] > 0:
ramasse_pomme(k)
panier += 1
def recolte_champ():
global panier
for k in range(len(pommier)):
recolte_pommier(k)
def initialisation_champ():
for k in range(nbPommier):
pommier[k] = randint(0, pomMax)
# programme principal
initialisation_champ()
print(pommier)
recolte_champ()
print(panier)
Au début du programme on importe les modules (ou bibliothèques externes).
Ensuite on définit les variables globales, accessibles en lecture dans les flux d'exécutions secondaires déclenchées par les appels de chaque fonction du programme.
Puis, viennent les déclarations de fonctions spécifiques au programme.
Enfin, on termine par le programme principal qui définit le flux principal d'exécution.
Le premier programme de l'exercice précédent est un bon exemple de programme en Python.