Informatique Prise en main TP 1 Premiers pas avec un

Informatique
Prise en main
TP 1
Premiers pas avec un environnement Python
Le shell
Le shell peut être vu comme une calculatrice (assez basique initialement, seulement en mode texte).
• Le shell interprète en direct les commandes qu’on lui donne, sans attendre.
• On peut faire des calculs simples dans le shell.
• Il y a peu de commandes de base, mais il est facile de l’enrichir. Par exemple, les constantes et les fonctions usuelles
mathématiques seront ajoutées avec la bibliothèque math.
• Avec les flèches haut et bas, on peut rappeler une commande précédente et la modifier avant de l’exécuter à nouveau.
• Les commandes peuvent être sur plusieurs lignes.
▷ Exercice 1 : Vous pouvez tout de suite utiliser l’interpréteur comme une simple calculatrice de bureau. Veuillez donc
vous-même tester et commenter les commandes ci-dessous :
>>> 5+3
>>> 2 - 9
# les espaces sont optionnels
>>> 7 + 3 * 4
# la hiérarchie des opérations mathématiques
# est - elle respectée ?
>>> (7+3) *4
>>> 20 / 3
# attention : ceci fonctionnerait différemment sous Python 2
>>> 20 // 3
>>> 20.5 / 3
>>> 8 ,7 / 5
# Erreur !
>>> sin (0)
Éditeur
Les environnements de développement possèdent tous en plus du shell un éditeur. Les avantages d’utilisation de l’éditeur
sont multiples.
• On peut taper plusieurs commandes à la suite, elles ne seront exécutées que lorsqu’on lancera le script. On va donc
pouvoir écrire un algorithme complet avant de vérifier s’il marche.
• On peut enregistrer le fichier pour revenir le modifier ou l’exécuter plus tard.
• Il en beaucoup plus aisé de corriger un algorithme. Alors que dans le shell, il faudrait retaper toutes les lignes, ici, il
suffit de modifier le fichier.
• Un programme sera aussi plus lisible. En effet, on va pouvoir aérer le code et ajouter des commentaires dans le fichier
qui ne serviront pas à l’ordinateur, mais qui expliqueront au codeur qui relira le code l’utilité de chacune des parties du
programme.
Les deux éditeurs qu’on va utiliser :
• IDLE : éditeur inclus dans la distibution Python.
• IEP : éditeur associé à l’environnement de développement Pyzo bien plus performant
Les variables
En Python, les variables permettent de stocker plus ou moins provisoirement toute sorte d’objets : des valeurs, des resultats
de calculs, des fonctions. . . La syntaxe est la suivante :
nom = expression
1
année 2016/2017
Informatique
Prise en main
TP 1
• Sous Python, les noms de variables doivent en outre obéir à quelques règles simples :
→ Un nom de variable est une séquence de lettres (a-z, A-Z) et de chiffres (0-9), qui doit toujours commencer par une
lettre.
→ Seules les lettres ordinaires sont autorisées. Les lettres accentuées, les cédilles, les espaces, les caractères spéciaux
tels que $, #, etc sont interdits, à l’exception du caractère _ (souligné).
→ La casse est significative (les caractères majuscules et minuscules sont distingués).
Prenez l’habitude d’écrire l’essentiel des noms de variables en caractères minuscules (y compris la première lettre). Il
s’agit d’une simple convention, mais elle est largement respectée. N’utilisez les majuscules qu’à l’intérieur même du
nom, pour en augmenter éventuellement la lisibilité, comme dans tableDesMatieres.
En plus de ces règles, il faut encore ajouter que vous ne pouvez pas utiliser comme nom de variables les 33 « mots
réservés » ci-dessous (ils sont utilisés par le langage lui-même) :
and
as
array break
class continue def
del
elif
else
except False finally
for
from
global
if
import in
is
lambda
None nonlocal not
or
pass
raise
return
True
try
while with
yield
• L’expression : elle peut prendre beaucoup de forme différentes – un entier, un flottant, un calcul, un calcul qui utilise
d’autres variables définies auparavant, une liste, un tableau, une fonction, une chaine de caractères. . .
Exemple :
>>> n = 7
>>> msg = " Quoi de neuf ? "
>>> pi = 3.14159
# définir la variable n et lui donner la valeur 7
# affecter la valeur " Quoi de neuf ?" à msg
# assigner sa valeur à la variable pi
Les exemples ci-dessus illustrent des instructions d’affectation Python tout à fait classiques. Après qu’on les ait exécutées, il
existe dans la mémoire de l’ordinateur, à des endroits différents :
• trois noms de variables, à savoir n, msg et pi ;
• trois séquences d’octets, où sont encodées le nombre entier 7, la chaîne de caractères « Quoi de neuf ? » et le nombre
réel 3,14159.
▷ Exercice 2 : Décrivez le plus clairement et le plus complètement possible ce qui se passe à chacune des trois lignes de
l’exemple ci-dessous :
>>> largeur = 20
>>> hauteur = 5 * 9.3
>>> largeur * hauteur
930
Affectation multiple
On peut effectuer plusieurs affectations simultanées, ou multiples
>>>
>>>
6
>>>
>>>
5 5
a ,b , c = 2 ,4 ,6
c
a = b =5
a; b
et compliquer un peu
>>> a =2; b =3;
>>> a , b = b , 3* b + a
>>> b
11
Un petit raccourci
>>> a =17
>>> a +=2
>>> a
19
2
année 2016/2017
Informatique
Prise en main
TP 1
On peut donc utiliser +=, -=, *=, /= pour raccourcir certaines affectations.
Traduire un algorithme en Python
La structuration du code repose sur l’indentation, i.e. sur le décalage plus ou moins marqué du début de la ligne.
Les conditions
Les comparaisons sont possibles à l’aide des opérateurs suivants :
x
x
x
x
x
x
== y
!= y
> y
< y
>= y
<= y
#
#
#
#
#
#
x
x
x
x
x
x
est
est
est
est
est
est
egal a y
différent de y
plus grand que y
plus petit que y
plus grand que , ou égal a y
plus petit que , ou égal a y
On peut combiner différents tests avec les opérateurs and, or et not
>>> (1 <3) and (4 >2)
True
>>> (5 >8) or not (2 >4)
True
Comment traduire les briques de base d’un algorithme en Python ?
• Le branchement conditionnel avec alternative :
1
2
3
4
if condition :
bloc de commandes
else :
bloc de commandes
• Le branchement conditionnel sans alternative :
1
2
if condition :
bloc de commandes
• La boucle « pour ». Pour signifier les bornes entre lesquelles la variable de boucle va varier, on utilise la commande
range.
→ Si on écrit range(n), où n est un entier naturel, alors la variable prendra les valeurs de 0 à n − 1.
→ Si on écrit range(a,b), où a et b sont deux entiers naturels, alors la variable prendra les valeurs de a à b − 1.
1
2
for variable in range ( bornes ) :
bloc de commandes
• La boucle « tant que » :
1
2
while condition :
bloc de commandes
Quelques exemples
1
2
3
4
1
2
3
if age >= 18:
print ( ’ majeur ’)
else :
print ( ’ mineur ’)
for i in range (10) :
j = i*i
print ( j )
3
année 2016/2017
Informatique
1
2
3
4
5
Prise en main
TP 1
p = 0
while 3** p < 1000:
p += 1
print ( ’ La plus petite puissance de 3 qui dépasse 1000 vaut ’)
print (3** p )
Une petite différence de comportement entre le shell et l’éditeur
Essayer de taper le script suivant dans le shell et dans un fichier (avant de l’exécuter) :
1
2
a = 2
a
Si dans le shell, on tape juste le nom d’une variable, Python va évaluer cette variable et alors afficher le résultat. Alors que
si on utilise un script, cette évaluation aura aussi lieu, mais en arrière plan. Aucune valeur n’est affichée. Dans un programme,
on utilisera la commande print pour afficher la valeur d’une variable.
1
2
a = 2
print ( a )
Exercices
▷ Exercice 3 : Écrire un programme qui pour un réel x donné (affecté en première ligne de l’éditeur) affiche sa valeur
absolue (sans utiliser la commande abs).
▷ Exercice 4 : Écrire un programme qui affiche un compte à rebours de 50 jusqu’à 0 (on le fera d’au moins deux façons
différentes).
▷ Exercice 5 : Écrire un programme qui donne le signe d’un produit de deux nombres non nuls. Attention, on ne doit pas
calculer le produit de ces deux nombres.
▷ Exercice 6 : Écrire un programme qui résout l’équation ax + b = 0 dans R où a et b sont deux réels saisis par l’utilisateur
(on tapera le programme dans l’éditeur et on effectera les variables a et b avant d’évaluer le programme). Le tester avec (2, 3),
(2, 0), (0, 2) et (0, 0).
▷ Exercice 7 : Écrire un programme qui calcule la somme des entiers de 1 jusqu’à 500.
▷ Exercice 8 : Soit (u n )n la suite définie par u 0 = 1 et ∀n ∈ N, u n+1 = 2u n − 3. Calculer u 8 puis u 20 .
Calculer le premier terme de la suite strictement inférieur à −1000.
▷ Exercice 9 : Quelques algorithmes supplémentaires à programmer
1. reste de la division euclidienne de deux entiers naturels en utilisant que des soustractions.
2. quotient et reste de la division euclidienne (mêmes contraintes).
3. déterminer le maximum de 3 entiers a, b et c.
4. déterminer la parité d’un entier qelconque.
5. calcul des puissances entières d’un réel (puissances positives, puis quelconques).
4
année 2016/2017
Informatique
Prise en main
TP 1
Solutions
▷ Exercice 1 :
>>> 5+3
8
# pas de surprise
>>> 2 - 9
-7
>>> 7 + 3 * 4
19
# même priorité qu ’ en maths
>>> (7+3) *4
40
# idem
>>> 20 / 3
6 .6 6 6 66 6 6 6 66 66 6 67 # passage en flottant
>>> 20 // 3
6
# c ’ est la division entière
>>> 20.5 / 3
6. 833 3 33 33 33 3 3 33 3 # la virgule est un point
>>> 8 ,7 / 5
(8 , 1.4)
# on crée le couple 8 et 7/5
>>> sin (0)
Traceback ( most recent call last ) :
File " < stdin > " , line 1 , in < module >
NameError : name ’ sin ’ is not defined
▷ Exercice 2 :
• première instruction : on affecte la valeur 20 à la variable largeur
• seconde instruction : le calcul 5 ∗ 9.3 est evalué et le résultat est affecté à hauteur
• troisième instruction : le produit est effectué, le résultat est affiché mais stocké nulle part.
▷ Exercice 3 :
1
2
3
4
5
x = -2
if x >=0:
print ( x )
else :
print ( - x )
▷ Exercice 4 :
On peut le faire de plusieurs manières (il faut faire attention aux indices de début et de fin) :
• avec une boucle for de 0 à 50
1
2
for i in range (51) :
print (50 - i )
• avec une boucle while
1
2
3
4
compteur =50
while compteur >=0:
print ( compteur )
compteur = compteur -1
• avec une boucle for avec un pas négatif de −1 (attention au dernier entier)
1
2
for i in range (50 , -1 , -1) :
print ( i )
▷ Exercice 5 :
On peut le faire de différentes manières, avec plus ou moins de tests. On suppose que les deux nombres sont x et y.
5
année 2016/2017
Informatique
1
2
3
4
5
6
7
8
9
10
Prise en main
if x >0:
if y >0:
print ( " produit
else :
print ( " produit
else :
if y >0:
print ( " produit
else :
print ( " produit
TP 1
positif " )
négatif " )
négatif " )
positif " )
ou bien
1
2
3
4
if (x >0 and y >0) or (x <0 and y <0) :
print ( " produit positif " )
else :
print ( " produit négatif " )
▷ Exercice 6 :
1
2
3
4
5
6
7
if a ==0:
if b ==0:
print ( " tous les réels sont solution " )
else :
print ( " aucune solution " )
else :
print ( " une seule solution " ,-b / a )
▷ Exercice 7 :
On utilise un accumulateur auquel on ajoute les entiers les uns après les autres :
1
2
3
4
somme =0
for i in range (501) :
somme += i
print ( somme )
▷ Exercice 8 :
Il n’y a pas de type « suite ». Le principe est d’effectuer plusieurs fois le remplacement u devient 2u − 3 - il ne faut pas se
tromper sur le nombre d’itérations :
1
2
3
4
u =1
for i in range (8) : # ou 20
u =2* u -3
print ( u )
On obtient −509 puis −2097149 pour u 20 . On peut afficher tous les termes :
1
2
3
4
u =1
for i in range (21) :
print ( " rang " ,i , " : " ,u )
u =2* u -3
5
6
7
8
9
10
11
12
13
rang
rang
...
rang
rang
...
rang
rang
0
1
:
:
1
-1
8
9
:
:
-509
-1021
19
20
:
:
-1048573
-2097149
Remarque : pourquoi fait-on range(20) dans le premier cas, et range(21) lorsqu’on veut tout ?
6
année 2016/2017
Informatique
1
2
3
4
5
6
Prise en main
TP 1
u = 1
i = 0 # pour connaître l ’ indice du terme recherché
while u >= -1000:
u = 2* u -3
i += 1
print ( " rang " ,i , " : " ,u )
7
8
rang
9
:
-1021
▷ Exercice 9 :
1. On suppose que a est entier et b > 0 (on n’effectue pas les tests dans le programme). On traduit directement l’algorithme
du cours
1
2
3
4
r=a
# ce n ’ est pas du tout necessaire , mais cela permet de ne pas modifier a
while r > b :
r =r - b
print ( r )
2. On adapte le programme précédent en comptant le nombre de fois où l’on est passé dans la boucle
1
2
3
4
5
6
7
q =0
r=a
while r > b :
r =r - b
q = q +1
print (q , r )
print (a , b * q + r )
# pour controler
3. pas de difficulté : on peut utiliser le fait que max(a, b, c) = max(max(a, b), c)
1
2
3
4
5
6
7
8
if a > b :
m=a
else :
m=b
if c > m :
m=c
# pas besoin de else m = m
print ( m )
4. Tout dépend des fonctions qu’on peut utiliser. Si on ne veut pas utiliser la division euclidienne de Python, il suffit de
calculer le reste de la division par 2 et de regarder s’il est nul ou pas - on reprend le premier programme
1
2
3
4
5
6
7
r=a
while r >2:
r =r -2
if r ==1:
print ( " impair " )
else :
print ( " pair " )
On se rend compte que ce programme ne fonctionne pas avec des entiers négatifs. Puisque a et −a ont même parité,
on peut combiner deux programmes :
1
2
3
4
5
6
7
8
9
10
11
if a >=0:
r=a
else
r=-a
# r contient la valeur absolue de a et est positif
while r >2:
r =r -2
if r ==1:
print ( " impair " )
else :
print ( " pair " )
5. On se contente ici d’un algorithme naïf : on multiplie par x le nombre de fois nécessaire...
7
année 2016/2017
Informatique
1
2
3
4
5
6
7
Prise en main
TP 1
# Données :
# x : flottant
# k : entier positif
p =1
for i in range ( k ) :
p=p*x
print ( p )
On testera notamment les cas particuliers afin de voir si tout se passe bien (k = 0 et k = 1 notamment). Si on souhaite
prendre en compte les exposants négatifs, on peut le faire ainsi (si k < 0, alors x k = 1−k ).
x
1
2
3
# Données :
# x : flottant
# k : entier quelconque
4
5
6
7
8
9
10
11
12
13
14
if k >=0:
exposant = k
else :
exposant = - k
produit =1
for i in range ( exposant ) :
produit = produit * x
if k <0:
produit =1/ produit
print ( produit )
8
année 2016/2017