« Programmation Python/Modules » : différence entre les versions

Contenu supprimé Contenu ajouté
JerGer (discussion | contributions)
m →‎Interaction avec l'utilisateur : la fonction input() : Suppression de "positif" (qui ne sert à rien) dans "Veuillez entrer un nombre positif quelconque"
Ligne 1 :
<noinclude>{{Programmation Modèle:Python}}</noinclude>
 
L'un des concepts les plus importants en programmation est celui de ''fonction''<ref>Sous Python, le terme de "fonction" est utilisé indifféremment pour désigner à la fois de véritables fonctions mais également des ''procédures''. Nous indiquerons plus loin la distinction entre ces deux concepts proches.</ref>. Les fonctions permettent en effet de décomposer un programme complexe en une série de sous-programmes plus simples, lesquels peuvent à leur tour être décomposés eux-mêmes en fragments plus petits, et ainsi de suite. D'autre part, les fonctions sont réutilisables : si nous disposons d'une fonction capable de calculer une racine carrée, par exemple, nous pouvons l'utiliser un peu partout dans nos programmes sans avoir à la ré-écrire à chaque fois.
== Définition ==
Un module peut être appelé depuis plusieurs programmes, il s'agit d'un fichier .py commençant par son identité (qui ne contient pas de point).
 
== Interaction avec l'utilisateur : la fonction input() ==
N'importe quel fichier .py peut donc être appelé depuis un autre comme un module<ref>{{en}} http://docs.python.org/2/tutorial/modules.html</ref>. Il peut contenir :
:du script
:des fonctions
:des classes
:...
 
La plupart des scripts élaborés nécessitent à un moment ou l'autre une intervention de l'utilisateur (entrée d'un paramètre, clic de souris sur un bouton, etc.). Dans un script simple en mode texte (comme ceux que nous avons créés jusqu'à présent), la méthode la plus simple consiste à employer la fonction intégrée <code>input()</code>. Cette fonction provoque une interruption dans le programme courant. L'utilisateur est invité à entrer des caractères au clavier et à terminer avec <Enter>. Lorsque cette touche est enfoncée, l'exécution du programme se poursuit, et la fonction fournit en retour une valeur correspondant à ce que l'utilisateur a entré. Cette valeur peut alors être assignée à une variable quelconque.
== Importations ==
Pour utiliser des fonctions de modules dans un programme, il faut au début du fichier importer ceux-ci.
 
On peut invoquer la fonction <code>input()</code> en laissant les parenthèses vides. On peut aussi y placer en argument un message explicatif destiné à l'utilisateur. Exemple :
Pour ce faire, utiliser la commande "import" :
<source lang="python">
import os
import codecs
</source>
Sur la même ligne :
<source lang="python">
import os, codecs
</source>
Ou encore en sélectionnant tous les éléments d'un fichier :
<source lang="python">
from wikipedia import *
</source>
A noter : cette dernière méthode est dangereuse, car des objets du module portant le même nom que des objets du programme peuvent s'écraser l'un l'autre.
 
<pre>
=== TypeError ===
print 'Veuillez entrer un nombre quelconque : ',
Si l'erreur suivante pose une colle lors de l'appel :
nn = input()
TypeError: 'module' object is not callable
print 'Le carré de', nn, 'vaut', nn**2
Il suffit d'appeler le module sous la forme : NomFichier.NomFonction.
</pre>
 
ou encore :
=== Import error ===
 
Si cette autre erreur arrive :
<pre>
Import error: No module named urllib3.response
prenom = input('Entrez votre prénom (entre guillemets) : ')
Il suffit de modifier le PYTHONPATH pour qu'il trouve le module mentionné, par exemple derrière une condition s'assurant que la machine qui exécute le script contient le répertoire du module :
print 'Bonjour,', prenom
<source lang=python>
</pre>
import sys, socket
 
if socket.gethostname() == "MonUbuntu":
==== Remarques importantes ====
sys.path.append(u'/usr/local/lib/python2.7/dist-packages/requests')
 
* La fonction <code>input()</code> renvoie une valeur dont le type correspond à ce que l'utilisateur a entré. Dans notre exemple, la variable <tt>nn</tt> contiendra donc un entier, une chaîne de caractères, un réel, etc. suivant ce que l'utilisateur aura décidé. Si l'utilisateur souhaite entrer une chaîne de caractères, il doit l'entrer comme telle, ''c'est-à-dire incluse entre des apostrophes ou des guillemets''. Nous verrons plus loin qu'un bon script doit toujours vérifier si le type ainsi entré correspond bien à ce que l'on attend pour la suite du programme.
 
* Pour cette raison, il sera souvent préférable d'utiliser dans vos scripts la fonction similaire <code>raw_input()</code>, laquelle renvoie toujours une ''chaîne de caractères''. Vous pouvez ensuite convertir cette chaîne en nombre à l'aide de int() ou de float(). Exemple :
 
* remarque : dans les versions plus récentes du langage (à partir de python 3.1), la fonction raw_input() n'existe plus, et la fonction input() la remplace et renvoi systématiquement une chaine de caractère.
 
<pre>
>>> a = raw_input('Entrez une donnée : ')
Entrez une donnée : 52.37
>>> type(a)
<type 'str'>
>>> b = float(a) # conversion en valeur numérique
>>> type(b)
<type 'float'>
</pre>
 
== Importer un module de fonctions ==
 
Vous avez déjà rencontré des fonctions ''intégrées'' au langage lui-même, comme la fonction <code>len()</code>, par exemple, qui permet de connaître la longueur d'une chaîne de caractères. Il va de soi cependant qu'il n'est pas possible d'intégrer toutes les fonctions imaginables dans le corps standard de Python, car il en existe virtuellement une infinité : vous apprendrez d'ailleurs très bientôt comment en créer vous-même de nouvelles. Les fonctions intégrées au langage sont relativement peu nombreuses : ce sont seulement celles qui sont susceptibles d'être utilisées très fréquemment. Les autres sont regroupées dans des fichiers séparés que l'on appelle des ''modules''.
 
Les modules sont donc des fichiers qui regroupent des ensembles de fonctions. Vous verrez plus loin comme il est commode de découper un programme important en plusieurs fichiers de taille modeste pour en faciliter la maintenance. Une application Python typique sera alors constituée d'un programme principal accompagné de un ou plusieurs modules contenant chacun les définitions d'un certain nombre de fonctions accessoires.
Il existe un grand nombre de modules pré-programmés qui sont fournis d'office avec Python. Vous pouvez en trouver d'autres chez divers fournisseurs. Souvent on essaie de regrouper dans un même module des ensembles de fonctions apparentées que l'on appelle des ''bibliothèques''.
 
Le module ''math'', par exemple, contient les définitions de nombreuses fonctions mathématiques telles que ''sinus'', ''cosinus'', ''tangente'', ''racine carrée'', etc. Pour pouvoir utiliser ces fonctions, il vous suffit d'incorporer la ligne suivante au début de votre script :
 
<pre>
from math import *
</pre>
 
Cette ligne indique à Python qu'il lui faut inclure dans le programme courant ''toutes'' les fonctions (c'est là la signification du symbole *) du module ''math'', lequel contient une bibliothèque de fonctions mathématiques pré-programmées.
 
Dans le corps du script lui-même, vous écrirez par exemple :
 
<code>racine = sqrt(nombre)</code> pour assigner à la variable racine la racine carrée de nombre,
<code>sinusx = sin(angle)</code> pour assigner à la variable sinusx le sinus de angle (en radians !), etc.
 
Exemple :
 
<pre>
# Démo : utilisation des fonctions du module <math>
 
from math import *
 
nombre = 121
angle = pi/6 # soit 30° (la bibliothèque math inclut aussi la définition de pi)
print 'racine carrée de', nombre, '=', sqrt(nombre)
print 'sinus de', angle, 'radians', '=', sin(angle)
</pre>
 
L'exécution de ce script provoque l'affichage suivant :
 
<pre>
racine carrée de 121 = 11.0
sinus de 0.523598775598 radians = 0.5
</pre>
 
Ce court exemple illustre déjà fort bien quelques caractéristiques importantes des fonctions :
* une fonction apparaît sous la forme d'un nom quelconque associé à des parenthèses. Exemple : <code>sqrt()</code>
* dans les parenthèses, on ''transmet'' à la fonction un ou plusieurs ''arguments''. Exemple : <code>sqrt(121)</code>
* la fonction fournit une ''valeur de retour'' (on dira aussi qu'elle « renvoie » une valeur). Exemple : <code>11.0</code>
 
Nous allons développer tout ceci dans les pages suivantes. Veuillez noter au passage que les fonctions mathématiques utilisées ici ne représentent qu'un tout premier exemple. Un simple coup d'œil dans la documentation des bibliothèques Python vous permettra de constater que de très nombreuses fonctions sont d'ores et déjà disponibles pour réaliser une multitude de tâches, y compris des algorithmes mathématiques très complexes (Python est couramment utilisé dans les universités pour la résolution de problèmes scientifiques de haut niveau). Il est donc hors de question de fournir ici une liste détaillée. Une telle liste est aisément accessible dans le système d'aide de Python :
 
:''Documentation HTML ® Python documentation ® Modules index ® math''
 
Au chapitre suivant, nous apprendrons comment créer nous-mêmes de nouvelles fonctions.
 
{{exercices}}
:''(Note : Dans tous ces exercices, utilisez la fonction <code>raw_input()</code> pour l'entrée des données)''
<ol>
<li>Écrivez un programme qui convertisse en mètres par seconde et en km/h une vitesse fournie par l'utilisateur en miles/heure. (Rappel : 1 mile = 1609 mètres)</li>
<li>Écrivez un programme qui calcule le périmètre et l'aire d'un triangle quelconque dont l'utilisateur fournit les 3 côtés.
(Rappel : l'aire d'un triangle quelconque se calcule à l'aide de la formule :<br />
<math>S = \sqrt{d \times (d-a) \times (d-b) \times (d-c)}</math>
dans laquelle d désigne la longueur du demi-périmètre, et a, b, c celles des trois côtés).</li>
<li>Écrivez un programme qui calcule la période d'un pendule simple de longueur donnée.
La formule qui permet de calculer la période d'un pendule simple est <math>T = 2\pi \sqrt{\frac{l}{g}}</math>,
l représentant la longueur du pendule et g la valeur de l'accélération de la pesanteur au lieu d'expérience.</li>
<li>Écrivez un programme qui permette d'encoder des valeurs dans une liste. Ce programme devrait fonctionner en boucle, l'utilisateur étant invité à entrer sans cesse de nouvelles valeurs, jusqu'à ce qu'il décide de terminer en frappant <enter> en guise d'entrée. Le programme se terminerait alors par l'affichage de la liste. Exemple de fonctionnement :
<pre>
Veuillez entrer une valeur : 25
Veuillez entrer une valeur : 18
Veuillez entrer une valeur : 6284
Veuillez entrer une valeur :
[25, 18, 6284]
</pre></li>
</ol>
{{solution}}
<ol>
<li>
<pre>
# Conversion de miles/heure en km/h et m/s
 
print "Veuillez entrer le nombre de miles parcourus en une heure : ",
ch = raw_input() # en général préférable à input()
mph = float(ch) # conversion de la chaîne entrée en nombre réel
mps = mph * 1609 / 3600 # conversion en mètres par seconde
kmph = mph * 1.609 # conversion en km/h
# affichage :
print mph, "miles/heure =", kmph, "km/h, ou encore", mps, "m/s"
</pre>
</li>
<li>
<pre>
# Périmètre et Aire d'un triangle quelconque
 
from math import sqrt
 
print "Veuillez entrer le côté a : "
a = float(raw_input())
print "Veuillez entrer le côté b : "
b = float(raw_input())
print "Veuillez entrer le côté c : "
c = float(raw_input())
d = (a + b + c)/2 # demi-périmètre
s = sqrt(d*(d-a)*(d-b)*(d-c)) # aire (suivant formule)
 
print "Longueur des côtés =", a, b, c
print "Périmètre =", d*2, "Aire =", s
</pre>
</li>
<li>Réfléchissez !</li>
<li>
<pre>
# Entrée d'éléments dans une liste
 
tt = [] # Liste à compléter (vide au départ)
ch = "start" # valeur quelconque (mais non nulle)
while ch != "":
print "Veuillez entrer une valeur : "
ch = raw_input()
if ch != "":
tt.append(float(ch)) # variante : tt.append(ch)
 
# affichage de la liste :
print tt
</pre>
</li>
</ol>
</ol>
{{fin}}
 
== Un peu de détente avec le module turtle ==
 
Comme nous venons de le voir, l'une des grandes qualités de Python est qu'il est extrêmement facile de lui ajouter de nombreuses fonctionnalités par importation de divers ''modules''.
 
Pour illustrer cela, et nous amuser un peu avec d'autres objets que des nombres, nous allons explorer un module Python qui permet de réaliser des « graphiques tortue », c'est-à-dire des dessins géométriques correspondant à la piste laissée derrière elle par une petite « tortue » virtuelle, dont nous contrôlons les déplacements sur l'écran de l'ordinateur à l'aide d'instructions simples.
 
Activer cette tortue est un vrai jeu d'enfant. Plutôt que de vous donner de longues explications, nous vous invitons à essayer tout de suite :
 
<pre>
>>> from turtle import *
>>> forward(120)
>>> left(90)
>>> color('red')
>>> forward(80)
</pre>
 
L'exercice est évidemment plus riche si l'on utilise des boucles :
 
<pre>
>>> reset()
>>> a = 0
>>> while a <12:
a = a +1
forward(150)
left(150)
</pre>
 
[[Image:Apprendre à programmer avec Python 8.png|center]]
 
Attention cependant : avant de lancer un tel script, assurez-vous toujours qu'il ne comporte pas de boucle sans fin (voir {{todo}}), car si c'est le cas vous risquez de ne plus pouvoir reprendre le contrôle des opérations (en particulier sous ''Windows'').
 
Amusez-vous à écrire des scripts qui réalisent des dessins suivant un modèle imposé à l'avance. Les principales fonctions mises à votre disposition dans le module ''turtle'' sont les suivantes :
 
{| style="width:100%"
|-
|<code>reset()</code> || On efface tout et on recommence
|-
|<code>goto(x, y)</code> || Aller à l'endroit de coordonnées x, y
|-
|<code>forward(distance)</code> || Avancer d'une distance donnée
|-
|<code>backward(distance)</code> || Reculer
|-
|<code>up()</code> || Relever le crayon (pour pouvoir avancer sans dessiner)
|-
|<code>down()</code> || Abaisser le crayon(pour recommencer à dessiner)
|-
|<code>color(couleur)</code> || <couleur> peut être une chaîne prédéfinie ('red', 'blue', 'green', etc.)
|-
|<code>left(angle)</code> || Tourner à gauche d'un angle donné (exprimé en degrés)
|-
|<code>right(angle)</code> || Tourner à droite
|-
|<code>width(épaisseur)</code> || Choisir l'épaisseur du tracé
|-
|<code>fill(1)</code> || Remplir un contour fermé à l'aide de la couleur sélectionnée
|-
|<code>write(texte)</code> || <texte> doit être une chaîne de caractères délimitée avec des " ou des '
|}
 
== Véracité/fausseté d'une expression ==
 
Lorsqu'un programme contient des instructions telles que <tt>while</tt> ou <tt>if</tt>, l'ordinateur qui exécute ce programme doit évaluer la véracité d'une condition, c'est-à-dire déterminer si une expression est vraie ou fausse. Par exemple, une boucle initiée par <code>while c<20</code>: s'exécutera aussi longtemps que la condition <code>c<20</code> restera vraie.
 
Mais comment un ordinateur peut-il déterminer si quelque chose est vrai ou faux ?
 
En fait - et vous le savez déjà - un ordinateur ne manipule strictement que des nombres. Tout ce qu'un ordinateur doit traiter doit d'abord toujours être converti en valeur numérique. Cela s'applique aussi à la notion de vrai/faux. En Python, tout comme en C, en Basic et en de nombreux autres langages de programmation, on considère que toute valeur numérique autre que zéro est « vraie ». Seule la valeur zéro est « fausse ». Exemple :
 
<pre>
a = input('Entrez une valeur quelconque')
if a:
print "vrai"
else:
print "faux"
</pre>
 
Le petit script ci-dessus n'affiche « faux » que si vous entrez la valeur 0. Pour toute autre valeur numérique, vous obtiendrez « vrai ».
 
Si vous entrez une chaîne de caractères ou une liste, vous obtiendrez encore « vrai ». Seules les chaînes ou les listes ''vides'' seront considérées comme « fausses ».
 
Tout ce qui précède signifie donc qu'une expression à évaluer, telle par exemple la condition a > 5 , est d'abord convertie par l'ordinateur en une valeur numérique. (Généralement 1 si l'expression est vraie, et zéro si l'expression est fausse). Exemple :
 
<pre>
a = input('entrez une valeur numérique : ')
b = (a < 5)
print 'la valeur de b est', b, ':'
if b:
print "la condition b est vraie"
else:
print "la condition b est fausse"
</pre>
 
Le script ci-dessus vous renvoie une valeur <code>b = 1</code> (condition vraie) si vous avez entré un nombre plus petit que 5.
 
Ces explications ne sont qu'une première information à propos d'un système de représentation des opérations logiques que l'on appelle ''algèbre de Boole''. Vous apprendrez plus loin que l'on peut appliquer aux nombres binaires des opérateurs tels que and, or, not, etc. qui permettent d'effectuer à l'aide de ces nombres des traitements logiques complexes.
 
== Révision ==
Dans ce qui suit, nous n'allons pas apprendre de nouveaux concepts mais simplement utiliser tout ce que nous connaissons déjà pour réaliser de vrais petits programmes.
 
=== Contrôle du flux - Utilisation d'une liste simple ===
 
Commençons par un petit retour sur les branchements conditionnels (il s'agit peut-être là du groupe d'instructions le plus important dans n'importe quel langage !) :
 
<pre>
# Utilisation d'une liste et de branchements conditionnels
 
print ("Ce script recherche le plus grand de trois nombres")
print ('Veuillez entrer trois nombres séparés par des virgules : ')
# Note : la fonction list() convertit en liste la séquence de données qu'on
# lui fournit en argument. L'instruction ci-dessous convertira donc les
# données fournies par l'utilisateur en une liste nn :
nn = list(input())
max, index = nn[0], 'premier'
if nn[1] > max: # ne pas omettre le double point !
max = nn[1]
index = 'second'
if nn[2] > max:
max = nn[2]
index = 'troisième'
print ("Le plus grand de ces nombres est", max)
print ("Ce nombre est le", index, "de votre liste.")
</pre>
 
{{remarque|Dans cet exercice, vous retrouvez à nouveau le concept de « bloc d'instructions », déjà abondamment commenté aux chapitres 3 et 4, et que vous devez absolument assimiler. Pour rappel, les blocs d'instructions sont délimités par l'indentation. Après la première instruction if, par exemple, il y a deux lignes indentées définissant un bloc d'instructions. Ces instructions ne seront exécutées que si la condition nn[1] > max est vraie.<br />
La ligne suivante, par contre (celle qui contient la deuxième instruction if) n'est pas indentée. Cette ligne se situe donc au même niveau que celles qui définissent le corps principal du programme. L'instruction contenue dans cette ligne est donc toujours exécutée, alors que les deux suivantes (qui constituent encore un autre bloc) ne sont exécutées que si la condition nn[2] > max est vraie.<br />
En suivant la même logique, on voit que les instructions des deux dernières lignes font partie du bloc principal et sont donc toujours exécutées.
}}
 
=== Boucle while - Instructions imbriquées ===
 
Continuons dans cette voie en imbriquant d'autres structures :
 
<pre>
# Instructions composées <while> - <if> - <elif> - <else> # 1
 
print 'Choisissez un nombre de 1 à 3 (ou zéro pour terminer) ', # 3
a = input() # 4
while a != 0: # l'opérateur != signifie "différent de" # 5
if a == 1: # 6
print "Vous avez choisi un :" # 7
print "le premier, l'unique, l'unité ..." # 8
elif a == 2: # 9
print "Vous préférez le deux :" # 10
print "la paire, le couple, le duo ..." # 11
elif a == 3: # 12
print "Vous optez pour le plus grand des trois :" # 13
print "le trio, la trinité, le triplet ..." # 14
else : # 15
print "Un nombre entre UN et TROIS, s.v.p." # 16
print 'Choisissez un nombre de 1 à 3 (ou zéro pour terminer) ', # 17
a = input() # 18
print "Vous avez entré zéro :" # 19
print "L'exercice est donc terminé." # 20
</pre>
 
Nous retrouvons ici une boucle <tt>while</tt>, associée à un groupe d'instructions <tt>if</tt>, <tt>elif</tt> et <tt>else</tt>. Notez bien cette fois encore comment la structure logique du programme est créée à l'aide des indentations (... et n'oubliez pas le caractère « : » à la fin de chaque ligne d'en-tête !)
 
L'instruction <tt>while</tt> est utilisée ici pour relancer le questionnement après chaque réponse de l'utilisateur (du moins jusqu'à ce que celui-ci décide de « quitter » en entrant une valeur nulle : rappelons à ce sujet que l'opérateur de comparaison != signifie « est différent de »). Dans le corps de la boucle, nous trouvons le groupe d'instructions <tt>if</tt>, <tt>elif</tt> et <tt>else</tt> (de la ligne 6 à la ligne 16), qui aiguille le flux du programme vers les différentes réponses, ensuite une instruction <tt>print</tt> et une instruction <tt>input()</tt> (lignes 17 & 18) qui seront exécutées dans tous les cas de figure : notez bien leur niveau d'indentation, qui est le même que celui du bloc <tt>if</tt>, <tt>elif</tt> et <tt>else</tt>, Après ces instructions, le programme boucle et l'exécution reprend à l'instruction <tt>while</tt> (ligne 5). Les deux dernières instructions print (lignes 19 & 20) ne sont exécutées qu'à la sortie de la boucle.
 
 
{{Exercices}}
<ol>
<li>Que fait le programme ci-dessous, dans les quatre cas où l'on aurait défini au préalable que la variable a vaut 1, 2, 3 ou 15 ?
<pre>
if a !=2:
print 'perdu'
elif a ==3:
print 'un instant, s.v.p.'
else :
print 'gagné'
</pre></li>
<li>Que font ces programmes ?
 
<pre>
a = 5
b = 2
if (a==5) & (b<2):
print '"&" signifie "et"; on peut aussi utiliser le mot "and"'
</pre>
 
<pre>
a, b = 2, 4
if (a==4) or (b!=4):
print 'gagné'
elif (a==4) or (b==4):
print 'presque gagné'
</pre>
 
<pre>
a = 1
if not a:
print 'gagné'
elif a:
print 'perdu'
</pre></li>
 
<li>Reprendre le programme c) avec a = 0 au lieu de a = 1. Que se passe-t-il ? Conclure !</li>
<li>Écrire un programme qui, étant données deux bornes entières a et b, additionne les nombres multiples de 3 et de 5 compris entre ces bornes.<br />
Prendre par exemple a = 0, b = 32 ® le résultat devrait être alors 0 + 15 + 30 = 45.<br />
Modifier légèrement ce programme pour qu'il additionne les nombres multiples de 3 ou de 5 compris entre les bornes a et b. Avec les bornes 0 et 32, le résultat devrait donc être : 0 + 3 + 5 + 6 + 9 + 10 + 12 + 15 + 18 + 20 + 21 + 24 + 25 + 27 + 30 = 225.</li>
<li>Déterminer si une année (dont le millésime est introduit par l'utilisateur) est bissextile ou non. (Une année A est bissextile si A est divisible par 4. Elle ne l'est cependant pas si A est un multiple de 100, à moins que A ne soit multiple de 400).</li>
<li>Demander à l'utilisateur son nom et son sexe (M ou F). En fonction de ces données, afficher « Cher Monsieur » ou « Chère Mademoiselle » suivi du nom de l'élève.</li>
<li>Demander à l'utilisateur d'entrer trois longueurs a, b, c. A l'aide de ces trois longueurs, déterminer s'il est possible de construire un triangle. Déterminer ensuite si ce triangle est rectangle, isocèle, équilatéral ou quelconque. Attention : un triangle rectangle peut être isocèle.</li>
<li>Demander à l'utilisateur qu'il entre un nombre. Afficher ensuite : soit la racine carrée de ce nombre, soit un message indiquant que la racine carrée de ce nombre ne peut être calculée.</li>
<li>Convertir une note scolaire N quelconque, entrée par l'utilisateur sous forme de points (par exemple 27 sur 85), en une note standardisée suivant le code suivant :
 
{| style="width:100%"
|-
|Note || Appréciation
|-
|N >= 80 % || A
|-
|80 % > N >= 60 % || B
|-
|60 % > N >= 50 % || C
|-
|50 % > N >= 40 % || D
|-
|N < 40 % || E
|}</li>
 
<li>Soit la liste suivante :<br />
<code>['Jean-Michel', 'Marc', 'Vanessa', 'Anne', 'Maximilien', 'Alexandre-Benoît', 'Louise']</code><br />
Ecrivez un script qui affiche chacun de ces noms avec le nombre de caractères correspondant.</li>
<li>Écrire une boucle de programme qui demande à l'utilisateur d'entrer des notes d'élèves. La boucle se terminera seulement si l'utilisateur entre une valeur négative. Avec les notes ainsi entrées, construire progressivement une liste. Après chaque entrée d'une nouvelle note (et donc à chaque itération de la boucle), afficher le nombre de notes entrées, la note la plus élevée, la note la plus basse, la moyenne de toutes les notes.</li>
<li>Ecrivez un script qui affiche la valeur de la force de gravitation s'exerçant entre deux masses de 10000 kg , pour des distances qui augmentent suivant une progression géométrique de raison 2, à partir de 5 cm (0,05 mètre).
La force de gravitation est régie par la formule <math>F = 6,67 \times10^{-11} \times \frac{m \times m'}{d^2}</math><br />
Exemple d'affichage :
<pre>
d = .05 m : la force vaut 2.668 N
d = .1 m : la force vaut 0.667 N
d = .2 m : la force vaut 0.167 N
d = .4 m : la force vaut 0.0417 N
etc.
</pre></li>
</ol>
{{solution}}
<ol>
<li>Réfléchissez !</li>
<li>Réfléchissez !</li>
<li>Réfléchissez !</li>
<li>
<pre>
# Traitement de nombres entiers compris entre deux limites
 
print "Veuillez entrer la limite inférieure :",
a = input()
print "Veuillez entrer la limite supérieure :",
b = input()
s = 0 # somme recherchée (nulle au départ)
# Parcours de la série des nombres compris entre a et b :
n = a # nombre en cours de traitement
while n <= b:
if n % 3 ==0 and n % 5 ==0: # variante : 'or' au lieu de 'and'
s = s + n
n = n + 1
 
print "La somme recherchée vaut", s
</pre>
</li>
<li>
<pre>
# Années bissextiles
 
print "Veuillez entrer l'année à tester :",
a = input()
 
if a % 4 != 0:
# a n'est pas divisible par 4 -> année non bissextile
bs = 0
else:
if a % 400 ==0:
# a divisible par 400 -> année bissextile
bs = 1
elif a % 100 ==0:
# a divisible par 100 -> année non bissextile
bs = 0
else:
# autres cas ou a est divisible par 4 -> année bissextile
bs = 1
if bs ==1:
ch = "est"
else:
ch = "n'est pas"
print "L'année", a, ch, "bissextile."
 
Variante (proposée par Alex Misbah) :
a=input('entrée une année:')
 
if (a%4==0) and ((a%100!=0) or (a%400==0)):
print a,"est une année bissextile"
else:
print a,"n'est pas une année bissextile"
 
Variante (de Mik)
a=input('année:')
if (a%4==0 and a%100!=0)or(a%400==0):
print "bi6"
else:
print "nbi6"
</pre>
</li>
<li>Réfléchissez !</li>
<li>
<pre>
from sys import exit # module contenant des fonctions système
 
print """
Veuillez entrer les longueurs des 3 côtés
(en séparant ces valeurs à l'aide de virgules) :"""
a, b, c = input()
# Il n'est possible de construire un triangle que si chaque côté
# a une longueur inférieure à la somme des deux autres :
if a < (b+c) and b < (a+c) and c < (a+b) :
print "Ces trois longueurs déterminent bien un triangle."
else:
print "Il est impossible de construire un tel triangle !"
exit() # ainsi l'on n'ira pas plus loin.
 
f = 0
if a == b and b == c :
print "Ce triangle est équilatéral."
f = 1
elif a == b or b == c or c == a :
print "Ce triangle est isocèle."
f = 1
if a*a + b*b == c*c or b*b + c*c == a*a or c*c + a*a == b*b :
print "Ce triangle est rectangle."
f = 1
if f == 0 :
print "Ce triangle est quelconque."
 
Variante (de Mik)
a,b= input('a:'),input('b:')
if b>a:
print '"c":](',b-a,');(',a+b,')['
else:
print '"c":](',a-b,');(',a+b,')['
c=input('c:')
if a < (b+c) and b < (a+c) and c < (a+b) :
print 'bien un triangle'
else:
print 'impossible constrution triangle'
exit()
if a>b and a>c:
max=a
x=c*c+b*b
elif b>a and b>c:
max=b
x=c*c+a*a
elif c>b and c>a:
max=c
x=a*a+b*b
if a==b and b==c :
print "triangle équilatéral."
elif a==b or b==c or c==a :
print "triangle isocèle."
elif x==max**2 :
print "triangle rectangle."
else:
print "triangle quelconque."
import requests
</sourcepre>
</li>
<li>Réfléchissez !</li>
<li>Réfléchissez !</li>
<li>Réfléchissez !</li>
<li>
<pre>
# Notes de travaux scolaires
 
notes = [] # liste à construire
La page suivante traite du module ''re''.
n = 2 # valeur positive quelconque pour initier la boucle
while n >= 0 :
print "Entrez la note suivante, s.v.p. : ",
n = float(raw_input()) # conversion de l'entrée en un nombre réel
if n < 0 :
print "OK. Terminé."
else:
notes.append(n) # ajout d'une note à la liste
# Calculs divers sur les notes déjà entrées :
# valeurs minimale et maximale + total de toutes les notes.
min = 500 # valeur supérieure à toute note
max, tot, i = 0, 0, 0
nn = len(notes) # nombre de notes déjà entrées
while i < nn:
if notes[i] > max:
max = notes[i]
if notes[i] < min:
min = notes[i]
tot = tot + notes[i]
moy = tot/nn
i = i + 1
print nn, "notes entrées. Max =", max, "Min =", min, "Moy =", moy
</pre>
</li>
<li>Réfléchissez !</li>
</ol>
{{fin}}
 
==Références Notes ==
{{références}}
<references/>
 
[[Catégorie:Apprendre à programmer avec Python (livre)|Fonctions prédéfinies]]
----
{{lienDePage|Programmation Python|Fonction|Regex}}