Programmation Python pour les scientifiques - Premiers programmes -

Cours avec exercices corrigés

Jean-Philippe PREAUX

Ce cours a été préparé pour le niveau CPGE MPSI, il est enseigné au Lycée Thiers. Retrouvez les exercices corrigés accompagnant ce cours à la fin de chaque partie.

Retrouvez également la première partie du cours : Premier contact

Les commentaires et les suggestions d'amélioration sont les bienvenus, alors, après votre lecture, n'hésitez pas. Commentez

- Titre : Programmation Python pour les scientifiques - Premiers programmes -

- Auteur : Jean-Philippe PREAUX

- Parution : 30 octobre 2014

- Public visé :

- Licence : Copyright ® 2014 Jean-Philippe PREAUX. Aucune reproduction, même partielle, ne peut être faite de ce site et de l'ensemble de son contenu : textes, documents, images, etc. sans l'autorisation expresse de l'auteur. Sinon vous encourez selon la loi jusqu'à trois ans de prison et jusqu'à 300 000 € de dommages et intérêts.

Voir également :

- Programmation Python pour les scientifiques - Premier contact -

Sommaire

- I. Python en mode interactif

- II. Écrire un programme Python

- II-A. Environnement de programmation

- III. La fonction input()

- IV. La fonction raw_input()

- V. Type bool

- V-A. Conversion en booléen : bool()

- VI. Structures de contrôles

- VI-A. L'instruction while

- VI-B. Exemple : Écrire un nombre en base 16

- VI-C. Structure de test

- VI-C-1. Structure de test if [else]

- VI-C-2. Structure de test if [elif] [else]

- VII. Énoncés des exercices

- VII-A. Valeur absolue d'un nombre, sans utiliser la fonction intégrée abs()

- VII-B. Calcul de factorielle, sans utiliser le module math

- VII-C. Partie entière d'un nombre, sans utiliser le module math

- VII-D. Écriture d'un nombre en base 16

- VII-E. PGCD : algorithme d'Euclide

- VII-F. Écriture d'un menu

- VIII. Corrigés des exercices

- VIII-A. Valeur absolue d'un nombre, sans utiliser la fonction intégrée abs() : Solution

- VIII-B. Calcul de factorielle, sans utiliser le module math : Solution

- VIII-C. Partie entière d'un nombre, sans utiliser le module math : Solution

- VIII-D. Écriture d'un nombre en base 16 : Solution

- VIII-E. PGCD : algorithme d'Euclide : Solution

- VIII-F. Écriture d'un menu

- IX. Remerciements Developpez

I - Python en mode interactif

Nous avons vu comment Python peut s'utiliser en mode interactif en le lançant dans un terminal par la commande python.

JPh@ubuntu:~$ python
Python 2.7.7 |Anaconda 2.0.1 (64-bit)| (default, Jun  2 2014, 12:34:02)
[GCC 4.1.2 20080704 (Red Hat 4.1.2-54)] on linux2
Type "help", "copyright", "credits" or "license" for more information.
Anaconda is brought to you by Continuum Analytics.
Please check out: http://continuum.io/thanks and https://binstar.org
>>>

C'est pratique pour utiliser Python comme une calculatrice ou pour programmer des algorithmes simples. Mais :

- l'environnement de calcul est assez pauvre ;

- le mode interactif ne permet pas de développer des programmes complexes : à chaque utilisation, il faut réécrire le programme. La modification d'une ligne oblige à réécrire toutes les lignes qui la suivent. Pour développer un programme plus complexe, on saisit son code dans un fichier texte (avec une extension .py en principe) : plus besoin de tout retaper pour modifier une ligne, plus besoin de tout réécrire à chaque lancement.

Toutefois, il existe un environnement interactif beaucoup plus riche nommé IPython (commande ipython) :

JPh@ubuntu:~$ ipython
Python 2.7.7 |Anaconda 2.0.1 (64-bit)| (default, Jun  2 2014, 12:34:02)
Type "copyright", "credits" or "license" for more information.

IPython 2.1.0 -- An enhanced Interactive Python.
Anaconda is brought to you by Continuum Analytics.
Please check out: http://continuum.io/thanks and https://binstar.org
?         -> Introduction and overview of IPython's features.
%quickref -> Quick reference.
help      -> Python's own help system.
object?   -> Details about 'object', use 'object??' for extra details.

In [1]: a=15

In [2]: print a
15

In [3]: str = "bonjour l'univers"

La commande %whos produit l'affichage des variables :

In [4]: %whos
Variable   Type    Data/Info
----------------------------
a          int     15
str        str     bonjour l'univers

help() lance l'aide interactive :

In [6]: help()

Welcome to Python 2.7!  This is the online help utility.

If this is your first time using Python, you should definitely check out
the tutorial on the Internet at http://docs.python.org/2.7/tutorial/.

Enter the name of any module, keyword, or topic to get help on writing
Python programs and using Python modules.  To quit this help utility and
return to the interpreter, just type "quit".

To get a list of available modules, keywords, or topics, type "modules",
"keywords", or "topics".  Each module also comes with a one-line summary
of what it does; to list the modules whose summaries contain a given word
such as "spam", type "modules spam".

help>

Dans l'aide interactive, keywords retourne les mots-clefs réservés (à ne pas utiliser pour la définition d'une variable, d'une fonction, d'une classe…).

help> keywords

Here is a list of the Python keywords.  Enter any keyword to get more help.

and                 elif                if                  print
as                  else                import              raise
assert              except              in                  return
break               exec                is                  try
class               finally             lambda              while
continue            for                 not                 with
def                 from                or                  yield
del                 global              pass

On obtient une description d'un mot-clef donné en le saisissant, par exemple : help> while produit ce résultat (touche q pour quitter) :

The ``while`` statement
***********************

The ``while`` statement is used for repeated execution as long as an
expression is true:

while_stmt ::= "while" expression ":" suite
["else" ":" suite]

This repeatedly tests the expression and, if it is true, executes the
first suite; if the expression is false (which may be the first time
it is tested) the suite of the ``else`` clause, if present, is
executed and the loop terminates.

A ``break`` statement executed in the first suite terminates the loop
without executing the ``else`` clause's suite.  A ``continue``
statement executed in the first suite skips the rest of the suite and
goes back to testing the expression.
(END)

Voir aussi : www.python.org/doc/

II - Écrire un programme Python

Le programme s'écrit dans un fichier texte que l'on sauvegarde avec l'extension .py. Le lancement du programme peut se faire à partir d'un terminal par la commande python nomfichier.py.

Il est préférable d'utiliser un environnement de développement qui rassemble tous les outils nécessaires au programmeur pour développer des logiciels.

II-A - Environnement de programmation

Par exemple avec la distribution Anaconda, vous disposez d'un véritable environnement de programmation Python nommé Spyder (commande spyder dans le terminal) :

IDE Spyder

La suite Anaconda rassemble tout le nécessaire pour faire ses premiers pas en Python scientifique. L'environnement Spyder offre un éditeur de texte (avec notamment la coloration syntaxique), les interpréteurs interactifs Python et IPython, des fenêtres d'exploration de vos fichiers, variables, objets, des outils de débogage, etc.

Premier programme : le résultat apparaît dans la console en bas à droite après avoir lancé l'exécution :

III - La fonction input()

La fonction input() attend la saisie par l'utilisateur d'un nombre ou d'une chaîne de caractères, et retourne la valeur saisie. Une chaîne de caractères doit être saisie entre ' ' (guillemets simples) ou " " (guillemets doubles).

>>> s=input()
'une chaîne de caractères'
>>> print "vous avez saisi", s
vous avez saisi une chaîne de caractères

En attendant d'écrire réellement votre premier programme, vous pouvez maintenant saisir vos commandes à partir de l'interpréteur Python intégré dans l'environnement Spyder.

On peut passer en argument à la fonction input() une chaîne de caractères qui sera affichée à l'écran.

>>> s = input('Saisissez une chaîne de caractères : ')
Saisissez une chaîne de caractères : 'ma chaîne'
>>> print "c'est :", s
c'est : ma chaîne
>>>

La fonction input() renvoie une valeur du même type que celle saisie.

>>> a=input(); b=input(); c=input()
-3
3.14
'bonjour'
>>> a, type(a)
(-3, <type 'int'>)
>>> b, type(b)
(3.14, <type 'float'>)
>>> c, type(c)
('bonjour', <type 'str'>)
>>>

IV - La fonction raw_input()

Comme input(), raw_input() attend la saisie par l'utilisateur d'une valeur. Elle retourne toujours une valeur de type chaîne de caractères (str). La chaîne de caractères saisie n'a plus besoin d'être entre guillemets (' ' ou " ").

>>> r=raw_input(); s=raw_input()
3.1415
une chaîne sans apostrophe
>>> type(r)
<type 'str'>
>>> type(s)
<type 'str'>
>>> print r,s
3.1415 une chaîne sans apostrophe
>>>

Bien entendu, vous ne pouvez pas effectuer de calcul sur les chaînes de caractères comme pour les nombres entiers ou réels.

>>> r
'3.1415'
>>> r*2
'3.14153.1415'
>>> r**2
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
TypeError: unsupported operand type(s) for ** or pow(): 'str' and 'int'
>>>

Mais on peut convertir la chaîne à l'aide des fonctions int() ou float() :

>>> r
'3.1415'
>>> r=float(r)
>>> r
3.1415
>>> print int(r), r**2
3 9.86902225
>>>

V - Type bool

Lorsque l'on saisit les conditions suivantes, les valeurs retournées peuvent prendre deux valeurs : True ou False. Elles sont de type booléen (bool).

Opérateurs de comparaison :

a < b

a a une valeur strictement inférieure à celle de b

a <= b

a a une valeur inférieure ou égale à celle de b

a == b

a et b ont même valeur

a != b

a et b ont des valeurs différentes

et pareillement a > b et a >= b.

On peut effectuer des opérations logiques sur les booléens (par ordre de priorité) : or, and, not() :

>>> a = (1<=2)
>>> print a, type(a)
True <type 'bool'>
>>> b = (a==False)
>>> print b, type(b)
False <type 'bool'>
>>>
>>> a or b
True
>>> a and b
False
>>> not(a)
False
>>> not(b)
True
>>>

>>> var = 'chaîne'
>>> var == "Chaîne"
False
>>> var != "Chaîne"
True
>>> not(var == "Chaîne")
True
>>> (1 == 1.00)
True
>>>

La fonction suivante définit le connecteur logique xor (ou exclusif) :

>>> # Connecteurs logique xor : a xor b = a and not(b) or not(a) and b
... def xor(a, b) :
...     return (a and not(b)) or (not(a) and b)
...
>>> xor(True, False), xor(False, True), xor(True, True), xor(False, False)
(True, True, False, False)

La fonction Xor définie dans un fichier .py

V-A - Conversion en booléen : bool()

La fonction de conversion bool() convertit une valeur de n'importe quel type en un booléen, selon les règles suivantes :

- Un nombre int ou float est converti à True s'il est non nul, à False sinon.

- Une chaîne de caractères str est convertie à True si elle est non vide, à False si c'est la chaîne vide : "".

>>> bool(3.14)
True
>>> bool(-7)
True
>>> bool('toto')
True
>>> bool('')
False
>>> s=""
>>> if not(s) : print "chaîne vide"
...
chaîne vide

VI - Structures de contrôles

Pour l'instant nous avons vu que Python est un langage de programmation impérative (un programme est une suite de lignes d'instruction), nous allons voir que c'est un langage de programmation structuré. Il reconnaît les structures de contrôles :

- une structure de test : if ... [elif] ... [else]

- deux structures de boucles : while et for

sans lesquelles les programmes ne s'exécuteraient que séquentiellement, ligne après ligne.

Nous allons commencer par voir la structure de boucle while puis la structure de test if [elif] [else].

Nous étudierons plus tard la deuxième structure de boucle for.

while et if nous suffisent pour programmer. Tandis que for et if ne suffisent pas. Cependant for est particulièrement pratique, surtout en Python !

VI-A - L'instruction while

L'instruction while permet de répéter une séquence d'instructions, en boucle, tant qu'une condition est vérifiée.

En général condition s'évalue en un booléen, par exemple :

True, a <= 0, (a == 0) and (b != -1)…

>>> x = 1.e10  # Notation scientifique x=1*10^10
>>> x
10000000000.0
>>> n=0
>>> while (2**n < x) :
...     n = n+1
...
>>> print n-1, 2**(n-1), '<', x, '<=', 2**n
33 8589934592 < 10000000000.0 <= 17179869184
>>>

Pour attendre la saisie d'une chaîne non vide :

>>> # Pour attendre la saisie d'une chaîne non vide
... while not(var) :
...     var = raw_input('Entrez une chaîne de caractères non vide : ')
...
Entrez une chaîne de caractères non vide :
Entrez une chaîne de caractères non vide :
Entrez une chaîne de caractères non vide : OK

Organigramme d'une boucle while :

On l'écrit en langage algorithmique :

VI-B - Exemple : Écrire un nombre en base 16

Code Python :

a = input('Saisissez un entier')
while a > 0 :
print a % 16
a = a // 16

En langage algorithmique :

Saisir un entier a
Tant que a > 0 faire :
écrire (a modulo 16)
a = [a / 16] ' division entière

Pour comprendre son fonctionnement, modifions le code et regardons son exécution :

passage = 0
a = input('Saisissez un entier : ')
while a > 0 :
passage = passage + 1
print 'Passage', passage
print 'a modulo 16 :', a % 16
a = a // 16
print 'a devient a//16 :', a
print 'Sortie de la boucle'

Lorsque (a > 0) est évalué à False, la boucle while s'arrête.

Amélioration du code (2e ébauche) :

a = input('Saisissez un entier :')
resultat = ''
while a > 0 :
resultat = str(a % 16) + ' ' + resultat
a = a // 16
print resultat

L'exécution produit :

str() retourne la valeur de son paramètre convertie en chaîne de caractères.

Pour les chaînes de caractères, '+' est l'opération de concaténation : 'aaaa' + 'bbbb' s'évalue en la chaîne 'aaaabbbb'.

Attention, une boucle peut ne jamais se terminer, et provoquer une exécution sans fin : while True : print 'bonjour', provoque un affichage sans fin que l'on interrompt avec la combinaison CTRL+C.

VI-C - Structure de test

La condition est évaluée en booléen.

- Si elle a valeur True le premier bloc d'instruction est exécuté, le deuxième ne l'est pas, puis l'exécution du programme se poursuit.

- Si elle a valeur False le deuxième bloc d'instruction est exécuté (le premier ne l'est pas), puis l'exécution du programme se poursuit.
L'instruction else est optionnelle.

VI-C-1 - Structure de test if [else]

Code Python :

a = input('Saisissez un nombre')
if a >= 0 :
print a, 'est positif'
else :
print a, 'est negatif'

En langage algorithmique :

Saisir un nombre a
Si a >= 0 faire :
écrire a, "est positif"
Sinon faire :
écrire a, "est négatif"

VI-C-2 - Structure de test if [elif] [else]

L'écriture de tests imbriqués :

if condition1 :
# Bloc d'instructions 1
else :
if condition2 :
# Bloc d'instructions 2
else :
# Bloc d'instructions 3

s'écrit à l'aide d'une seule structure de test :

if condition1 :
# Bloc d'instructions 1
elif condition2 :
# Bloc d'instructions 2
else :
# Bloc d'instructions 3

elif et else sont optionnels. elif peut être utilisé plusieurs fois dans une structure de test : if ... elif ... elif ... else ....

VII - Énoncés des exercices

VII-A - Valeur absolue d'un nombre, sans utiliser la fonction intégrée abs()

Écrire une fonction abs2() prenant en paramètre un nombre et qui retourne sa valeur absolue, sans utiliser la fonction intégrée abs().

Solution

VII-B - Calcul de factorielle, sans utiliser le module math

Écrire une fonction fact() prenant en paramètre un nombre entier positif et qui retourne sa factorielle (sans utiliser le module math).
On rappelle que :

Solution

VII-C - Partie entière d'un nombre, sans utiliser le module math

Écrire une fonction E() prenant en paramètre un nombre et qui retourne sa partie entière (sans utiliser le module math).
(La partie entière d'un réel x, notée [x], est le plus grand entier inférieur ou égal à x.)

Solution

VII-D - Écriture d'un nombre en base 16

Améliorer le programme permettant de donner l'écriture d'un nombre en base 16, pour que les chiffres soient 0-9, A, B, C, D, E, F et que l'écriture débute par le préfixe 0x.

Solution

VII-E - PGCD : algorithme d'Euclide

Écrire un programme qui calcule le PGCD de deux nombres à l'aide de l'algorithme d'Euclide, que l'on commencera par justifier :

VII-F - Écriture d'un menu

Écrire un programme qui affiche le menu suivant et effectue les actions correspondantes :

MENU :

- 1 - Calculer le PGCD de 2 entiers

- 2 - Calculer le PPCM de 2 entiers

- 3 - Déterminer si un nombre est premier

- 4 - Donner la décomposition en facteurs premiers d'un nombre

- q - Quitter

Indication : l'instruction break permet la sortie d'une boucle.

Solution

VIII - Corrigés des exercices

VIII-A - Valeur absolue d'un nombre, sans utiliser la fonction intégrée abs() : Solution

# Fonction valeur absolue
def abs2(x) :
if x>=0 :
return x # résultat retourné lorsque x est positif
else :
return -x # résultat retourné lorsque x est négatif

L'exécution donne :

>>> abs2(-1)
1
>>> abs2(3.5)
3.5
>>> abs2(0)
0

L'exécution de abs2(x) avec x de type ni int, ni float produira une erreur…

VIII-B - Calcul de factorielle, sans utiliser le module math : Solution

# Fonction factorielle
def fact(x) :
x=int(x)
result = 1
while (x>1) :
result=result*x
x=x-1
return result

L'exécution donne :

>>> fact(0)
0
>>> fact(3)
6
>>> fact(4)
24
>>> fact(5)
120

fact(x) avec x négatif ou de type non int produira un résultat absurde…

VIII-C - Partie entière d'un nombre, sans utiliser le module math : Solution

# Fonction partie entière E()
def E(x) :
if (x == int(x)) :
return x
elif (x>=0) :
return int(x)
else :
return -E(-x)-1

L'exécution donne :

>>> E(3.14)
3
>>> E(-3.14)
-4
>>> E(0)
0

Il est sans doute là aussi plus efficace d'utiliser la fonction floor() du module math.

VIII-D - Écriture d'un nombre en base 16 : Solution

a = input ('saisissez un nombre ')
resultat = ''
while a>0 :
b = a%16
if b < 10 : b = str(b)
elif b == 10 : b = 'A'
elif b == 11 : b = 'B'
elif b == 12 : b = 'C'
elif b == 13 : b = 'D'
elif b == 14 : b = 'E'
elif b == 15 : b = 'F'
resultat = b + resultat
a=a//16
resultat = '0x' + resultat
print resultat

L'exécution donne :

saisissez un nombre 15*16**2+16*13+9
0xFD9

Bien entendu, on réinvente la roue à titre d'exercice, et la fonction intégrée hex() fera le boulot de manière plus efficace.

VIII-E - PGCD : algorithme d'Euclide : Solution

Preuve : tout d'abord lorsque r = 0, a est un multiple de b et donc pgcd(a,b) = b. Lorsque r > 0. Puisque
,

tout diviseur de b et de r est aussi diviseur de a (ainsi que de b). De même r = a − qb et donc tout diviseur de a et de b est aussi diviseur de r (ainsi que de b). Ainsi a, b et b, r ont mêmes diviseurs communs ; en particulier : pgcd(a,b) = pgcd(b,r).
L'algorithme se termine : la valeur de b est un entier naturel qui diminue strictement à chaque itération de la boucle tandis que le reste r est un entier naturel strictement inférieur à b, ainsi il y aura au plus b passages dans la boucle avant que le critère d'arrêt r = 0 ne soit satisfait. D'après ce qui précède la valeur retournée est pgcd(a,b).

Solution :

# Algorithme d'Euclide pour le pgcd
def pgcd(a,b) :
while a%b != 0 :
a, b = b, a%b
return b

L'exécution donne :

>>> pgcd(120,36)
12
>>> pgcd(2,3)
1

Si au départ a < b la division euclidienne de a par b aura pour reste a (et quotient 0) et après la première itération de la boucle while les valeurs de a et b auront été échangées, il est donc inutile de traiter séparément le cas a<b.

VIII-F - Écriture d'un menu

L'écriture du menu s'obtient par :

# Corps du programme
while True :
print """MENU :
1 - Calculer le PGCD de deux nombres
2 - Calculer le PPCM de deux nombres
3 - Déterminer si un nombre est premier
4 - Donner la décomposition en facteur premier d'un nombre
q - Quitter"""
choix = raw_input("\nVotre choix :")
# Quitter
if (choix == 'q' or choix =='Q') :
break

Une chaîne de caractères placée entre trois guillemets doubles """ """ permet d'inclure les sauts de ligne et les autres guillemets.

Le choix 1 appelle la fonction pgcd() déjà écrite lors de l'exercice précédent (elle doit figurer avant le corps du programme).

# choix 1 : pgcd
elif (choix == '1') :
print "\nSaisissez 2 entiers "
entier1 = input()
entier2 = input()
print "le pgcd de", entier1, "et", entier2, "est", pgcd(entier1,entier2)

Fonction pgcd() :

# Algorithme d'Euclide pour le pgcd
def pgcd(a,b) :
while a%b != 0 :
a, b = b, a%b
return b

Le choix 2 :

# choix 2 : ppcm
elif (choix == '2') :
print "\nSaisissez 2 entiers "
entier1 = input()
entier2 = input()
print "le ppcm de", entier1, "et", entier2, "est", ppcm(entier1,entier2)

Fonction ppcm() :

def ppcm(a,b) :
return (a * b) / pgcd(a,b)

à faire figurer avant le corps du programme. Elle utilise : a.b=pgcd(a, b).ppcm(a, b).

Les deux derniers choix appellent des fonctions premier() et pdecomp(), qu'il reste à écrire :

elif (choix == '3') :
entier = input("Saisissez un entier ")
if premier(entier) :
print entier, "est premier"
else :
print entier, "n'est pas premier"

elif (choix == '4') :
entier = input("Saisissez un entier ")
print "La décomposition de", entier, "en premiers est", pdecomp(entier)

La fonction premier() prend en argument un entier et retourne un booléen selon si l'argument est un nombre premier ou pas. La fonction pdecomp() prend en argument un entier et retourne une chaîne de caractères donnant la décomposition en nombres premiers de l'argument.

La fonction premier() doit figurer avant le corps du programme :

from math import sqrt

def premier(a) :
result = True
n = 2
top = sqrt(a)
while (n <= top) :
if a % n== 0 :
return False
else :
n += 1
return True

Elle utilise la fonction sqrt() du module math qu'il s'agit d'importer auparavant.

La fonction pdecomp() doit figurer avant le corps du programme :

def pdecomp(a) :
result = ''
n = 2
anciena = a
premier = True
while (n <= a) :
if (a % n == 0) :
premier = False
if result == '' :
result = str(n)
else :
result = result + '.' + str(n)
a = a / n
else :
n = n + 1
if premier :
return str(anciena)
else :
return result

Exemple :

MENU :
1 - Calculer le PGCD de deux nombres
2 - Calculer le PPCM de deux nombres
3 - Déterminer si un nombre est premier
4 - Donner la décomposition en facteur premier d'un nombre
q - Quitter

Votre choix :4
Saisissez un entier 120
La décomposition de 120 en premiers est 2.2.2.3.5

On peut encore, pour améliorer le programme, gérer des exceptions lorsque l'utilisateur ne saisit pas un entier positif pour lui renvoyer un message d'erreur.

Le programme final (cliquez sur l'icône pour dévoiler le code) :

# -*- coding: utf-8 -*-
"""
Created on Sun Oct 19 10:02:08 2014

@author: JPh
"""
from math import sqrt

# Algorithme d'Euclide pour le pgcd
def pgcd(a,b) :
while a%b != 0 :
a, b = b, a%b
return b

def ppcm(a,b) :
return (a * b) / pgcd(a,b)

def premier(a) :
result = True
n = 2
top = sqrt(a)
while (n <= top) :
if a % n== 0 :
return False
else :
n += 1
return True

def pdecomp(a) :
result = ''
n = 2
anciena = a
premier = True
while (n <= a) :
if (a % n == 0) :
premier = False
if result == '' :
result = str(n)
else :
result = result + '.' + str(n)
a = a / n
else :
n = n + 1
if premier :
return str(anciena)
else :
return result

# Corps du programme
while True :
print """MENU :
1 - Calculer le PGCD de deux nombres
2 - Calculer le PPCM de deux nombres
3 - Déterminer si un nombre est premier
4 - Donner la décomposition en facteur premier d'un nombre
q - Quitter"""
choix = raw_input("\nVotre choix :")
# Quitter
if (choix == 'q' or choix =='Q') :
break
# choix 1 : pgcd
elif (choix == '1') :
print "\nSaisissez 2 entiers "
entier1 = input()
entier2 = input()
print "le pgcd de", entier1, "et", entier2, "est", pgcd(entier1,entier2)
# choix 2 : ppcm
elif (choix == '2') :
print "\nSaisissez 2 entiers "
entier1 = input()
entier2 = input()
print "le ppcm de", entier1, "et", entier2, "est", ppcm(entier1,entier2)
elif (choix == '3') :
entier = input("Saisissez un entier ")
if premier(entier) :
print entier, "est premier"
else :
print entier, "n'est pas premier"
elif (choix == '4') :
entier = input("Saisissez un entier ")
print "La décomposition de", entier, "en premiers est", pdecomp(entier)

MPSI1

IX - Remerciements Developpez

Nous remercions Jean-Philippe Préaux pour la publication de ces cours avec exercices sur Developpez. Merci à toute l'équipe de rédaction ayant contribué à cette publication et particulièrement à f-leb et -Nikopol-. Un grand merci également à ClaudeLELOUP pour ses corrections orthographiques.