Programmation Python

publicité
ISBS ECUE 122
TP1 Programmation avec Python (avec corrigé)
2016-2017
Avant de commencer...
... quelques indications sur le travail à faire durant toute l’unité :
• Lisez l’intégralité des énoncés de TP. Ne "sautez" pas directement aux exercices à faire sans prendre
connaissances des informations associées.
• Pour chaque TP, rédigez un compte-rendu. Les comptes-rendus seront exigibles immédiatement en cas de
litige après vos évaluations.
• Vous pouvez me les envoyer par mail ( [email protected] ) si vous avez des doutes ou interrogations. Il sera alors annoté (mais non noté).
• Deux jours après le TP, un corrigé sera mis en ligne. Lisez-le intégralement.
• Pour vos comptes-rendus, utilisez un traitement de texte (LibreOffice, OpenOffice) et des styles pour
distinguer le texte du compte rendu de celui des listings des programmes Python que vous y insérez (au
minimum, un style "python" avec police de caractères à largeur constante). Cherchez une police qui
distingue bien les caractères qui se ressemblent : voir la figure ci-dessous pour des exemples de polices
avec I (i majuscule), l (L minuscule), 1 (le chiffre un), O (o majuscule), 0 (le chiffre zéro).
• En cas de problème, essayez de réduire la taille de votre programme pour en faire un exemple complet
minimal (ECM), reproduisant l’erreur sans contenir une ligne de code parasite. En créant cet ECM, neuf
fois sur dix, vous trouverez l’erreur.
• Si le problème persiste, n’abandonnez pas. La communauté des utilisateurs Python est très ouverte et
donne, même aux débutants, des conseils, trucs et astuces, dans des FAQs et forums que vous pouvez
consulter sur Internet. Par exemple :
I http://python.developpez.com/
I http://programmers.stackexchange.com/questions/tagged/python
ou contactez moi par mail, en y joignant l’ECM.
• Pensez à noter et classer les problèmes rencontrés lors de l’utilisation de Python, avec vos tentatives
infructueuses de résolutions et vos solutions expliquées.
Comparaison de polices pour listings
Deux lignes de dix et treize caractères (la deuxième commence par exactement quatre
espaces).
Remarquez les bons alignements avec les deux dernières polices : la lettre l (L
minuscule) de la deuxième ligne doit se situer exactement au-dessous du chiffre 0 de
la première ligne.
if O == 0:
I=l+1
avec serif (Times New Roman)
non
if O == 0:
I=l+1
sans serif (Arial)
non
if O == 0:
I=l+1
exotique (Gothic)
non
if O == 0:
I = l + 1
monospace (Courier New)
oui
if O == 0:
I=l+1
monospace (Inconsolata)
oui
if O == 0:
I = l + 1
monospace (DejaVu Sans Mono)
oui
–1/14–
ISBS ECUE 122
1
TP1 Programmation avec Python (avec corrigé)
2016-2017
Mise en route
Au démarrage, sélectionnez le système Linux. Créez un répertoire Python dans votre espace de travail. Lancez
Python :
• sous Linux : menu Applications, puis sous-menu Programmation, puis lancement IDLE (using Python-3.4)
• sous Windows, si vous l’avez installé chez vous : menu Tous les programmes, puis sous-menu Python 3.4,
puis lancement IDLE (Python GUI)
Une fenêtre semblable à celle de la figure ci-dessous s’ouvre.
>>>
La fenêtre Python Shell permet d’entrer des calculs. Une invite (prompt en anglais) formée de trois chevrons
autorise à entrer des expressions Python. Entrez par exemple, après l’invite, la ligne suivante :
>>> (2015 * 2016) // 2 # la somme des 2015 premiers nombres
2031120
La fin de ligne à partir du # est un commentaire, ignoré par Python. L’opérateur // est celui de la division
euclidienne.
Dans la fenêtre IDLE Python Shell, les raccourcis <Alt>p et <Alt>n permettent de naviguer dans l’historique
des commandes. Un nom spécial, _ (tiret de soulignement, underscore), permet de récupérer le résultat de la
dernière commande. Si l’on est positionné sur une ligne, l’appui sur <Entr> copie/colle cette ligne en fin de ligne
courante. Évidemment, <Ctrl>C/<Ctrl>V permet de copier/coller une portion de texte ou même un résultat.
De plus, une aide très complète est fournie avec Python en passant par le menu Help/Python Docs, raccourci <F1>.
Cette aide contient en particulier The Python Tutorial qui est une lecture indispensable : I http://docs.python.
org/3.4/tutorial/
Exercice 1 — Entrée d’expressions
Entrez les commandes suivantes sous le Shell IDLE. Utilisez <Alt>p et <Alt>n pour utiliser les commandes de
l’historique :
>>> 2015 * 2016
4062240
>>> 2015 * 2016 // 2
2031120
>>> 2015 * 2016
4062240
>>> _ // 2
2031120
>>> 2015*2016 + 2015
4064255
Python Shell sous IDLE ne permet d’entrer qu’une commande à la fois : il n’est en général utilisé que pour
tester quelques lignes de programme. Quand le travail est plus long, on utilisera de préférence un éditeur de
programmes permettant d’entrer, de sauvegarder ou de recharger des enchaînements d’instructions.
–2/14–
ISBS ECUE 122
2
TP1 Programmation avec Python (avec corrigé)
2016-2017
Python, une calculatrice simple
Python permet de calculer avec trois sortes de nombres : les entiers (int) comme 1234, les décimaux (float)
comme 3.14 ou 2.0e13) et les complexes (complex) comme 2.5+3.1j
Exercice 2 — Les nombres littéraux
Solution p. 10
Écrivez en Python les nombres suivants :
1 234
−123 456 789
3, 14
6, 02 × 1023
−1, 602 176 53 × 10−19
2+3i
2−i
Essayez d’entrer les nombres de l’exercice 2. Notez les messages d’erreur, si vous laissez des espaces, ou oubliez
de préfixer j dans les complexes. Remarquez que 3,14 n’entraîne pas d’erreur, mais crée le couple (3, 14).
Dans The Python Tutorial, rendez-vous au paragraphe
• 3. An Informal Introduction to Python
◦ 3.1. Using Python as a Calculator
3.1.1. Numbers
(ou I http://docs.python.org/3.2/tutorial/introduction.html#numbers)
et consultez-le pour les exercices suivants.
Exercice 3 — Calculs et types
Solution p. 10
Quels sont les résultats (valeur et type) des expressions suivantes ?
23 + 8
3 * 17
3 * 0
23 / 8
24 / 8
23 % 8
(2+4j) / (1+3j)
2 ** 16
(1j)** 2
Note : L’appel à la
23.2 - 8.2
3 * 17.0
3.5 * 0
23 // 8
24 // 8
23.0 % 8
(2+4j) // (1+3j)
2.0 ** 16
(-1) ** 0.5
fonction type(x) retourne
le
(17+1j) - (17+1j)
(3+1j) * (3-1j)
(3+1j) * 0
23.0 // 8
24.0 // 8
24.0 % 8
(2+4j) // (1+2j)
0 ** 0
-1 ** 0.5
type de x.
Les opérateurs numériques de base sont :
+ addition
- soustraction
* multiplication
/ division
// division entière
% reste de la division entière
** élévation à la puissance
Le type du résultat est celui de l’opérande le plus compliqué, excepté pour / pour lequel le type du résultat
ne peut pas être entier (cf. exercice 3)
–3/14–
ISBS ECUE 122
TP1 Programmation avec Python (avec corrigé)
2016-2017
Exercice 4 — Quelques calculs curieux
Solution p. 11
Calculer les valeurs suivantes. Expliquez les bizarreries.
0, 3 + 0, 2 + 0, 1
0, 1 + 0, 2 + 0, 3
0, 3 × 0, 2 × 0, 1
0, 1 × 0, 2 × 0, 3
(1, 2 + 1, 3)2
1, 22 + 2 × 1, 2 × 1, 3 + 1, 32

3


1 +
1
1




−

1
1 
19 × 

1+
1+


1
1

1+
1+
2
3
3
Python, une calculatrice à mémoire de données
Lorsque les enchaînements de calcul sont trop nombreux ou trop longs, il est possible de mémoriser des
données, en utilisant des noms prermettant de s’y référer.
Il faut utiliser des noms parlants, permettant au lecteur de se passer de commentaires. Par exemple, pour
initialiser une variable à la valeur du rayon d’un cercle :
>>> rayon = 3
puis, les lignes suivantes :
>>> pi = 3.1416
>>> périmetre = 2 * pi * rayon
>>> aire = pi * rayon ** 2
>>> print("Le périmètre d'un cercle de rayon", rayon, "vaut", périmetre)
Le périmètre d'un cercle de rayon 3 vaut 18.8496
>>> print("et son aire vaut", aire)
et son aire vaut 28.2744
La lecture des instructions est beaucoup plus facile que s’il on avait utilisé des noms comme r, p, a ou pire
Comparer le code ci-dessus avec celui ci-dessous, qui pourtant affiche la même chose.
a, b, c.
>>> a = 3
>>> b = 2 * 3.1416 * a
>>> c = 3.1416 * a ** 2
>>> print("Le périmètre d'un cercle de rayon", a, "vaut", b)
Le périmètre d'un cercle de rayon 3 vaut 18.8496
>>> print("et son aire vaut", c)
et son aire vaut 28.2744
–4/14–
ISBS ECUE 122
TP1 Programmation avec Python (avec corrigé)
2016-2017
Exercice 5 — Les grains de blé sur l’échiquier
Solution p. 11
L’écrivain arabe A s a p h a d rapporte, en effet, que S e s s a, fils de Da h e r, imagina le jeu des échecs,
où le roi, quoique la pièce la plus importante, ne peut faire un pas sans le secours de ses sujets les pions, dans
le but de rappeler au monarque indien S c h e r a n les principes de justice et d’équité avec lesquels il devait
gouverner. S c h e r a n, enchanté d’une leçon donnée d’une manière si ingénieuse, promit à l’inventeur de lui
donner tout ce qu’il voudrait pour sa récompense. Celui-ci répondit : « Que Votre Majesté daigne me donner
un grain de blé pour la première case de l’échiquier, deux pour la seconde, quatre pour la troisième, et ainsi
de suite, en doublant jusqu’à la soixante-quatrième case. »
Édouard L u c a s, L’arithmétique amusante, Blanchard 1974
Écrivez la suite d’instructions permettant de calculer le nombre d’années de production qu’il faudrait pour
garnir l’échiquier (on prendra 0,035 g pour la masse d’un grain et 653 millions de tonnes pour la production
annuelle mondiale de blé en 2013).
Note : La solution :
>>> int((2 ** 64 - 1) * 0.035 / 1000000 / 653000000)
988
donne le résultat, mais n’est pas assez claire. Pour rendre ce calcul plus lisible en évitant d’utiliser une expression
ne contenant que des nombres, utilisez des variables en leur donnant des noms parlants, de manière à ce que la
suite d’instruction s’auto-commente.
Par exemple,
>>> masse_d_un_grain = 0.035
4
Écriture de programmes
La fenêtre Python Shell s’avère vite insuffisante lorsque les développements prennent de l’importance. Il est
nécessaire alors de stocker des suites d’instructions dans un fichier (script) que l’on peut sauvegarder sur disque
pour le conserver et le réutiliser en cas de besoin.
Pour pouvoir saisir un programme et le sauvegarder, on dispose de l’éditeur de texte IDLE (lui-même écrit en
Python).
Dans la fenêtre Python Shell, choissez le File/New File. La fenêtre ci-dessous apparaît.
Cette fenêtre, titrée pour l’instant Untitled, va nous permettre de saisir notre premier programme, limitée à
une seule instruction :
print("Bonjour") # print affiche le texte écrit entre double quotes
On peut sauvegarder ce programme (le classique File/Save As...), et pour exécuter ce programme, on utilise le
menu Run/Run Module (raccourci <F5>).
La fenêtre Python Shell est réinitialisée et le programme s’exécute.
Les expressions peuvent être nommées pour être réutilisées plus facilement. Par exemple, pour demander à
l’utilisateur son nom, puis lui afficher un message de bienvenue :
–5/14–
ISBS ECUE 122
TP1 Programmation avec Python (avec corrigé)
2016-2017
nom = input("Entrez votre nom : ") # input demande une saisie clavier
print("Bonjour,", nom, "! Comment allez-vous ?")
Notez que la variable nom n’est pas mise entre double quotes. Essayez de la mettre entre double quotes et notez
le résultat.
Exercice 6 — Saisie et affichage
Solution p. 12
Écrire un programme qui demande à l’utilisateur d’entrer son nom, puis d’entrer son prénom et affiche
l’initiale du prénom, suivie du nom.
Note : pour obtenir le premier caractère d’une chaîne de caractères référencée par nom, on utilise la syntaxe
nom[0].
Certaines instructions sont composées de sous-instructions.
nom = input("Entrez votre nom : ")
if nom == "xxx": # "xxx" --> le nom d'un prof que vous n'aimez pas
print("Mauvais jour,", nom, "! Je vous déteste !")
else:
print("Bonjour,", nom, "! Comment allez-vous ?")
Les sous-instructions doivent toutes être décalées du même nombre d’espaces, en général 4 espaces. Ce
décalage est appelé indentation et on parle d’indenter ou de désindenter une ligne.
5
Écriture de fonctions
Pour que des traitements puissent être réutilisés, Python permet de leur attribuer des noms. Par exemple :
Exercice 7 — Périmètre et aire du cercle
Solution p. 12
Créez un nouveau répertoire de nom cercle
Dans IDLE, ouvrez une nouvelle fenêtre (File/New File).
Saisissez les fonctions ci-dessous.
Sauvegardez dans cercle sous le nom cercle.py et exécutez le programme .
Notez les messages d’erreur pour vous y habituer et corrigez-les.
Testez les fonctions.
P ×r
Modifiez la fonction aire pour qu’elle utilise la fonction perimetre grâce à la formule A =
2
(copier/coller, modifiez les commentaires et la fonction et renommez la aire2).
• Modifiez la fonction perimetre en faisant afficher (print) plutôt que retourner (return) la valeur du
périmètre. Votre fonction aire2 fonctionne-t-elle toujours ?
• Comment faire pour utiliser le caractère π dans les commentaires ? Peut-on utiliser π comme nom de
variable ?
•
•
•
•
•
•
•
# fichier : cercle.py
# auteur : Jean-Claude GEORGES
# date : 14/05/2010
# màj : 02/11/2015
# exemple de programme définissant des fonctions
import math
# périmètre d'un cercle
def périmètre(rayon):
""" calcule et retourne le périmètre d'un cercle de rayon r
La formule utilisée est p = 2 Pi r
–6/14–
ISBS ECUE 122
TP1 Programmation avec Python (avec corrigé)
2016-2017
"""
return 2 * math.pi * rayon
# aire d'un cercle
def aire(rayon):
""" calcule et retourne l'aire d'un cercle de rayon r
2
La formule utilisee est a = Pi r
"""
return math.pi * rayon ** 2
S’il n’y a pas d’erreurs, dans la fenêtre Shell IDLE, vous pouvez maintenant utiliser vos deux fonctions
et aire :
perimetre
>>> périmètre(0.5)
3.141592653589793
>>> aire(2.0)
12.566370614359172
De plus, la première chaîne de caractères entre """triples double quotes""" est interprétée par Python
comme une docstring (chaîne de documentation), et peut être affichée de manière naturelle par la commande :
>>> help(aire)
Help on function aire in module __main__:
aire(r)
calcule et retourne l'aire d'un cercle de rayon r
2
La formule utilisee est a = Pi r
Exercice 8 — Périmètre et aire du rectangle
Solution p. 13
Sur le même modèle, créez un nouveau répertoire de nom rectangle et les fonctions de calcul du périmètre et
de l’aire du rectangle.
6
Un programme complet
Exercice 9 — Le jeu du + ou Solution p. 13
Créez un nouveau répertoire de nom plusmoins
Dans IDLE, ouvrez une nouvelle fenêtre (File/New File).
Saisissez le programme suivant.
Notez bien que les décalages (indentations) sont importants et marquent les blocs d’instructions internes.
Sauvegardez-le dans le répertoire plusmoins sous le nom devine.py et exécutez-le.
Notez les messages d’erreur pour vous y habituer et corrigez-les.
Testez le programme.
Le programme n’est pas sécurisé et si vous entrez autre chose que des nombres, il plantera. Notez le
message d’erreur à l’exécution (nous verrons plus tard comment remédier à cela).
• Vous pouvez constater que "tentative" prend un ’s’ au pluriel dans le message de félicitations. Comment
tester qu’il n’en prend pas au singulier (gain en un coup) ?
• Essayez de modifier le programme pour autoriser un nombre limité de tentatives et faire perdre le joueur
s’il dépasse ce nombre. N’oubliez pas de modifier les commentaires de début.
•
•
•
•
•
•
•
•
Note : lorsque l’on modifie un programme qui fonctionne pour l’améliorer, on ne travaille jamais sur
l’original mais sur une copie que l’on renomme (par exemple devine2.py). Tout programme qui fonctionne doit
être conservé.
–7/14–
ISBS ECUE 122
TP1 Programmation avec Python (avec corrigé)
# fichier : devine.py
# auteur : Jean-Claude GEORGES
# date : 19/05/2010
# màj : 03/11/2015
# exemple simple de programme python : le nombre à deviner
import random # pour générer des nombres pseudo-aléatoires
########## introduction ##################
print (""" Voici le classique jeu du nombre à deviner (niveau Adibou).
L'ordinateur va choisir un nombre au pseudo-hasard
et tu vas essayer de le deviner .""")
######## initialisation ##################
MINI, MAXI = 1, 999
nb_essais = 0 # nombre d'essais
trouvé = False # type booleen
nb_à_deviner = random.randrange(MINI, MAXI +1) # nombre à deviner
msg = 'Propose un nombre entre ' + str(MINI) + ' et ' + str(MAXI)+ ' : '
########## corps du programme ##################
while not trouvé: # tant qu'on n'a pas trouvé
x = int(input(msg))
if x == 284628: # cheat code DULRDU pour beta testeurs
print(nb_à_deviner)
continue
nb_essais += 1
if x < nb_à_deviner:
print ("
C'est plus ! Essaie encore !")
elif nb_à_deviner < x:
print ("
C'est moins ! Essaie encore !")
else: # x == nb_à_deviner
trouvé = True
########## fin du programme ####################
print ("\nBravo. Tu as deviné le nombre en ",
nb_essais, " tentative",
's' if nb_essais > 1 else '', sep = '', end = ' ! ')
print("\n" * 5, "Game over...")
–8/14–
2016-2017
ISBS ECUE 122
7
TP1 Programmation avec Python (avec corrigé)
2016-2017
Le Talkhys
Le Talkhys est un traité d’arithmétique pratique d’I b n A l b a n n a, mathématicien et astronome marocain
de la première moitié du x i i i e siècle. Voici quelques tableaux numériques extraits du Talkhys :
Talkhys 1
1
11
111
1111
11111
111111
1111111
Talkhys 2
×
×
×
×
×
×
×
1
11
111
1111
11111
111111
1111111
=
=
=
=
=
=
=
1
121
12321
1234321
123454321
12345654321
1234567654321
Talkhys 3
9
9
9
9
9
9
9
×
×
×
×
×
×
×
9
9
9
9
9
9
9
9
×
×
×
×
×
×
×
×
1
12
123
1234
12345
123456
1234567
12345678
+
+
+
+
+
+
+
+
2
3
4
5
6
7
8
9
=
=
=
=
=
=
=
=
11
111
1111
11111
111111
1111111
11111111
111111111
1
12
123
1234
12345
123456
1234567
12345678
+
+
+
+
+
+
+
+
1
2
3
4
5
6
7
8
=
=
=
=
=
=
=
=
9
98
987
9876
98765
987654
9876543
98765432
Talkhys 4
9
98
987
9876
98765
987654
9876543
+
+
+
+
+
+
+
7
6
5
4
3
2
1
=
=
=
=
=
=
=
88
888
8888
88888
888888
8888888
88888888
8
8
8
8
8
8
8
8
×
×
×
×
×
×
×
×
Comment écrire en Python les instructions permettant d’afficher, par exemple, le premier tableau du Talkhys
(sans mise en forme) :
Il faut tout d’abord regarder comment s’écrit une ligne du tableau :
11111 * 11111 = 123454321
En l’analysant, on constate qu’elle est formée comme suit : un nombre (111111), un texte ('*'), le même
nombre (111111), un texte ('=') et enfin le carré du nombre. (123454321)
D’où les lignes Python que l’on peut tester dans une console :
>>> a = 11111
>>> print(a, '*', a, '=', a ** 2)
11111 * 11111 = 123454321
Cette ligne va devoir être répétée, en modifiant la valeur de a. Comment la valeur de a peut-elle être déduite
de la valeur de a de la ligne précédente ? Une petite étude permet de dire que : anouveau = aancien ∗ 10 + 1
Ce qui permet d’écrire la fonction suivante :
def Talkhys1(nb_lignes):
""" affiche les n premières lignes du tableau 1 du Talkhys.
"""
a = 0
for i in range(nb_lignes): # répètera 'nblignes' fois
a = a*10 +1
print(a, "*", a, "=", a**2)
Exercice 10 — Le Talkhys
Solution p. 14
Entrez la fonction ci-dessus et testez-la.
Écrivez les fonctions permettant d’afficher les trois autres tableaux du Talkhys (sans mise en forme)
–9/14–
ISBS ECUE 122
8
TP1 Programmation avec Python (avec corrigé)
Solutions
Exercice 2 — Les nombres littéraux (p. 3)
>>> 1234
1234
>>> -123456789
-123456789
>>> 3.14
3.14
>>> 6.02e23
6.02e+23
>>> -1.60217653e-19
-1.60217653e-19
>>> 2+3j
(2+3j)
>>> 2-1j
(2-1j)
Exercice 3 — Calculs et types (p. 3)
23 + 8
23.2 - 8.2
(17+1j) - (17+1j)
3 * 17
3 * 17.0
(3+1j) * (3-1j)
3 * 0
3.5 * 0
(3 + 1j) * 0
23 / 8
23 // 8
23.0 // 8
24 / 8
24 // 8
24.0 // 8
23 % 8
23.0 % 8
24.0 % 8
(2+4j) / (1+3j)
(2+4j) // (1+3j)
(2+4j) // (1+2j)
2 ** 16
2.0 ** 16
0 ** 0
(1j) ** 2
(-1) ** 0.5
-1 ** 0.5
-->
-->
-->
-->
-->
-->
-->
-->
-->
-->
-->
-->
-->
-->
-->
-->
-->
-->
-->
-->
-->
-->
-->
-->
-->
-->
-->
31 <class 'int'>
15.0 <class 'float'>
0j <class 'complex'>
51 <class 'int'>
51.0 <class 'float'>
(10+0j) <class 'complex'>
0 <class 'int'>
0.0 <class 'float'>
0j <class 'complex'>
2.875 <class 'float'>
2 <class 'int'>
2.0 <class 'float'>
3.0 <class 'float'>
3 <class 'int'>
3.0 <class 'float'>
7 <class 'int'>
7.0 <class 'float'>
0.0 <class 'float'>
(1.4000000000000001-0.2j) <class 'complex'>
can't take floor of complex number.
can't take floor of complex number.
65536 <class 'int'>
65536.0 <class 'float'>
1 <class 'int'>
(-1+0j) <class 'complex'>
(6.123233995736766e-17+1j) <class 'complex'>
-1.0 <class 'float'>
–10/14–
2016-2017
ISBS ECUE 122
TP1 Programmation avec Python (avec corrigé)
2016-2017
Exercice 4 — Quelques calculs curieux (p. 4)
Python semble calculer de manière différente selon l’ordre des opérations :
>>> 0.3 + 0.2 + 0.1
0.6
>>> 0.1 + 0.2 + 0.3
0.6000000000000001
En effet, Python effectue les opérations de gauche à droite. Pour la première expression, il calcule déjà 0.3 + 0.2,
puis ajoute au résultat 0.1. Pour la seconde opération, il calcule 0.1 + 0.2, puis ajoute au résultat 0.3. Or ces
nombres n’ont pas une écriture finie en base 2. Les erreurs sur le dernier chiffre se compensent dans un cas, mais
pas dans l’autre.
>>> 0.3 * 0.2 * 0.1
0.006
>>> 0.1 * 0.2 * 0.3
0.006000000000000001
>>> (1.2 + 1.3)**2
6.25
>>> 1.2**2 + 2*1.2*1.3 + 1.3**2
6.250000000000001
Même punition...
>>> 19 * (
...
1
...
+ 3
...
/ (
...
1 / (1 + 1 / (1 + 1 / 2))
...
- 1 / (1 + 1 / (1 + 1 / 3))
...
)
...
)
2013.9999999999916
... ça devrait faire 2014.
Il faut toujours avoir en tête que les calculs sur les décimaux (float) risquent d’être entachés d’erreurs. Le
module fractions permet de faire des calculs exacts sur les rationnels.
>>> from fractions import *
>>> Fraction(3, 10) + Fraction(2, 10) + Fraction(1, 10)
Fraction(3, 5)
>>> Fraction(1, 10) + Fraction(2, 10) + Fraction(3, 10)
Fraction(3, 5)
Exercice 5 — Les grains de blé sur l’échiquier (p. 5)
>>>
>>>
>>>
>>>
>>>
>>>
>>>
988
#Les grains de blé sur l'échiquier
nbTotalDeGrains=2**64-1 # 2^0+2^1+2^2+...2^(n-1)=2^n-1
nbGrammesParTonne=10**6 #g/t
nbTonnesParAn=653*10**6 #t/an
masseUnGrain=0.035 #g
nbAnnees = nbTotalDeGrains * masseUnGrain / nbGrammesParTonne / nbTonnesParAn
print(int(nbAnnees)) #troncature entiere du resultat
–11/14–
ISBS ECUE 122
TP1 Programmation avec Python (avec corrigé)
2016-2017
Exercice 6 — Saisie et affichage (p. 6)
nom = input("Entrez votre nom : ") # saisie clavier
prénom = input("Entrez votre prénom : ") # notez l'accent dans l'identificateur,
# mais pas recommandé
print(prénom[0], nom)
Exercice 7 — Périmètre et aire du cercle (p. 6)
Pour écrire π dans un fichier Python, il faut aller le chercher (sur Internet, par exemple), et le copier/coller.
# fichier : cercle.py
# auteur : Jean-Claude GEORGES
# date : 14/05/2010
# màj : 03/11/2015
# exemple de programme définissant des fonctions
import math
π = math.pi
# périmètre d'un cercle
def perimetre (rayon) :
""" calcule et retourne le périmètre d'un cercle de rayon r
La formule utilisée est p = 2 π r
"""
return 2 * π * rayon
# aire d'un cercle
def aire (rayon) :
""" retourne l'aire d'un cercle de rayon r
La formule utilisee est a = π r2
"""
return π * rayon**2
# aire d'un cercle
def aire2 (rayon) :
""" retourne l'aire d'un cercle de rayon r
La formule utilisee est a = r * Périmètre / 2
"""
return rayon * perimetre(rayon) / 2
–12/14–
ISBS ECUE 122
TP1 Programmation avec Python (avec corrigé)
2016-2017
Exercice 8 — Périmètre et aire du rectangle (p. 7)
C’est très facile : attention à bien gérer les copier/coller à partir de cercle.py. On a tendance à ne pas modifier
les commentaires (trouvez l’erreur).
#
#
#
#
#
fichier : rectangle.py
auteur : Jean-Claude GEORGES
date : 21/06/2013
màj : 03/11/2015
exemple de programme définissant des fonctions : rectangle
# périmètre d'un rectangle
def périmètre (l, L):
""" calcule et retourne le périmètre d'un rectangle
de longueur L et de largeur l
La formule utilisée est p = 2 (l+L)
"""
return 2 * (l+L)
# aire d'un rectangle
def aire (l, L):
""" calcule et retourne l'aire d'un cercle
de longueur L et de largeur l
La formule utilisée est a = L x l
""" # un copier/coller mal modifié
return L*l
Exercice 9 — Le jeu du + ou - (p. 7)
Il faut ajouter une référence NB_MAX_ESSAIS et modifier le test (while not trouve) pour que le programme
s’arrête quand le nombre d’essais atteint la valeur. Il faut également penser à modifier la conclusion.
# fichier : devine2.py
# auteur : Jean-Claude GEORGES
# date : 21/06/2013
# màj : 03/11/2015
# exemple simple de programme python : le nombre à deviner
import random # pour générer des nombres pseudo-aléatoires
########## introduction ##################
print (""" Voici le classique jeu du nombre à deviner (niveau Adibou).
L'ordinateur va choisir un nombre au pseudo-hasard
et tu vas essayer de le deviner .""")
######## initialisation ##################
MINI, MAXI = 1, 999
NB_MAX_ESSAIS = 3
nb_essais = 0 # nombre d'essais
trouvé = False # type booleen
nb_à_deviner = random.randrange(MINI, MAXI +1) # nombre à deviner
msg = 'Propose un nombre entre ' + str(MINI) + ' et ' + str(MAXI)+ ' : '
–13/14–
ISBS ECUE 122
TP1 Programmation avec Python (avec corrigé)
2016-2017
########## corps du programme ##################
while not trouvé and nb_essais < NB_MAX_ESSAIS: # tant qu'on n'a pas trouvé
x = int(input(msg))
if x==284628: # cheat code DULRDU pour beta testeurs
print(nb_à_deviner)
continue
nb_essais += 1
if x < nb_à_deviner:
print ("
C'est plus ! Essaie encore !")
elif nb_à_deviner < x:
print ("
C'est moins ! Essaie encore !")
else: # x == nb_à_deviner
trouvé = True
########## fin du programme ####################
if trouvé:
print ("\nBravo. Tu as deviné le nombre en ",
nb_essais, " tentative",
's' if nb_essais > 1 else '', sep = '', end = ' ! ')
else:
print("\nPerdu. Nombre maximal d'essais atteint")
print("\n"*5,"Game over...")
Exercice 10 — Le Talkhys (p. 9)
En analysant le deuxième tableau du Talkhys, on constate que chaque ligne contient un 9, un nombre égal au
nombre de même niveau de la ligne précédente multiplié par 10 plus le numéro de ligne, et enfin le numéro de
ligne plus 1
def talkhys2(n):
a = 0 # le nb qui sera multiplié par 9
for ligne in range(1, n + 1):
a = a*10 + ligne
print(9,"*", a, "+", ligne+1, "=", 9*a+ligne+1)
>>> talkhys2(7)
9 * 1 + 2 = 11
9 * 12 + 3 = 111
9 * 123 + 4 = 1111
9 * 1234 + 5 = 11111
9 * 12345 + 6 = 111111
9 * 123456 + 7 = 1111111
9 * 1234567 + 8 = 11111111
Même raisonnement pour le 3 et le 4
def talkhys3(n):
a = 0
for ligne in range(1, n + 1):
a = a*10 + (10 - ligne)
print(9, "*", a, "+", (8 - ligne),
"=", 9*a + (8 - ligne))
def talkhys4(n):
a = 0
for ligne in range(1, n + 1) :
a = a*10 + ligne
print(8, "*", a, "+", ligne, "=", 8*a+ligne)
–14/14–
Téléchargement