1 La notion de variable en Python 2 Les principaux types de variables

Lycée Roland Garros - BCPST 1
Informatique
TP INFO no 2. Variables, fonctions, chiers Python
1 La notion de variable en Python
Le langage Python est un langage dit typé. Cela signie que TOUTES les variables qu'il
manipule sont dotées d'un type. Il s'agit d'une caractéristique qui spécie quel genre de
donnée représente cette variable.
Les opérations, les fonctions, sont souvent dénies spéciquement pour chaque type de
variable. Par exemple, on peut multiplier deux entiers, ou concaténer deux chaînes de
caractère, mais pas vice-versa : si l'on essaie de faire l'inverse on obtiendra une erreur.
Pour acher la valeur d'une variable, vous avez remarqué qu'il sut de taper son
nom dans la fenêtre principale, et de faire Entrée. Cela ne sera bientôt plus possible quand
on commencera à travailler dans l'éditeur. L'instruction print() sera alors la solution.
I a="Amstramgram"
I print(a)
I print(a**2)
I b="Pic et pic et colegram"
I print(b)
I print(a,b)
2 Les principaux types de variables
2.1 Le type int
C'est le type des nombres entiers. Les opérations sur les nombres entiers sont celles qui
sont calculées le plus rapidement par l'ordinateur.
I
I
I
I
I
I
type(2)
type(0)
type(-13)
type(24*5)
H=24*5
print(H)
2.2 Le type float
C'est le type des nombres réels (en fait des nombres décimaux, un ordinateur ne travaillant
qu'avec un nombre ni de chires après la virgule). L'ordinateur code de telles variables
en retenant
1
• 12 chires signicatifs,
• La position de la virgule : une puissance de 10
(d'où leur nom de nombres à virgule ottante). Ce type permet de travailler avec des
nombres très grands ou très petits, avec un degré de précision constant.
I
I
I
I
I
I
type(2.3)
type(2.)
M=2*3
type(M)
N=2.*3
type(N)
2.3 Le type str
C'est le type des variables qui sont des suites de symboles (lettres, chires, ponctuation
ou caractères spéciaux), c'est-à-dire des chaînes de caractères, qu'on délimite en Python
par des guillemets ou des apostrophes.
De telles variables sont très utiles pour faire acher des messages en cours de programme,
analyser un texte, coder un message secret. . .
I
I
I
I
a="c est bien !"
print(a)
b=' on programme en "Python" ' . . . . . . . . . . deux délimiteurs possibles ' ou "
print(b)
I 'coucou'+' ca va ?' . . . . . . . . le symbole + concatène les chaînes de caractère !
I print(a+b)
I 'guili'*3 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Ca chatouille ?
I message='glouglou'
I len(message) . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . len comme length =longueur
I
I
I
I
message[1]
message[0] . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . La numérotation part donc de 0 . . .
message[2:4] . . . . . . . . . . . . . . .et par ailleurs le dernier indice est toujours exclu !
message[8] . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Pourquoi une erreur ?
I A='1 \n+2 \n \n=3'
I print(A) . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . \n saute une ligne.
2
ATTENTION
la présence de guillemets change complètement le sens d'une expression. Par exemple,
tapez :
I gargamel=3
I gargamel*2
I 'gargamel'*2
Analysez la réaction de Python à ces deux instructions. Il ne faut surtout pas confondre
les deux : gargamel désigne la variable portant le nom gargamel, alors que 'gargamel'
désigne simplement la séquence de caractères g, a, r, g, a, m, e, l.
Soyez donc vigilant ! De nombreuses erreurs viennent de cette confusion. . .
2.4 Le type bool : booléens
Les variables du type bool représentent une valeur de vérité, elles ont donc pour valeur
soit True, soit False. Elles constitueront par exemple les conditions des boucles if, for
et while, d'où leur importance.
Le plus souvent les variables booléennes interviennent comme réponse à un test (c'est à
dire une question posée à Python). En clair Python renvoie True ou False selon si la
condition du test est vraie ou fausse.
I
I
I
I
I
I
1>2
1<2
1<1
1<=1
1=1 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Tiens ? qu'est-ce qui cloche ?
1==1
Comprenez bien la diérence entre = et == : rien à voir !
I
I
I
I
1!=1 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Que signie l'opération !=
'coucou'=='coucoucou'
'coucou'=='coucoucou'[0:6]
'coucou'==3.54325
I a='1'
I a==1 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Pourquoi ?
Les opérations que Python sait eectuer sur les variables booléennes correspondent aux
connecteurs logiques que nous connaissons
I (0==1) and (0==0)
I A=(0+0==3);B=(0+0==0)
I type(A)
3
I print(A and B)
I print(A or B)
I print(not(A))
2.5 Un type composite : le type list
Les variables du type list sont des séquences ordonnées de valeurs, qui peuvent éventuellement être de types diérents. Une liste s'écrit entre crochets, en séparant ses éléments
par des virgules :
I
I
I
I
L=[1,'haha',2.34,False]
print(L)
type(L)
len(L)
On peut extraire un élément d'une liste en précisant sa position. Les éléments qui constituent une liste peuvent être de n'importe quel type, et éventuellement de types diérents.
ATTTENTION comme toujours à la numérotation qui commence à 0.
I
I
I
I
I
I
I
I
I
I
I
L[0]
type(L[0])
L[1];type(L[1])
type(L[1])
L[2]
type(L[2])
L[3]
type(L[3])
L[-1]
L[-2] . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . -1,-2,-3 : à l'envers en partant du dernier
L[2:4] . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . extraction d'un morceau de liste
Il y a des outils simples pour créer des listes :
I
I
I
I
I
I
[i**2 for i in [1,3,5]]
A=list(range(5)); print(A)
B=list(range(2,7)); print(B)
C=list(range(0, 20, 3)); print(C)
[x**2-3 for x in C] . . . . . . . . . . . . . syntaxe à retenir absolument : super utile !
A+B+C . . . . . . . . . . . . . . . . . . . symbole + sur les listes = opération de concaténation
Autre outil : on peut changer la valeur d'un ou plusieurs éléments d'une liste. C'est
la réaectation :
I
I
I
I
L[2]='hoho'
print(L)
L[3]=L[3]+1;print(L)
L[0:2]=['a','b'] ;print(L)
Voici quelques opérations courantes sur les listes :
I L=[3,2,5,8,6,6,1,5,3]
I sum(L)
I del(L[3]);print(L) . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . to delete = supprimer
4
I
I
I
I
I
L.append(9);print(L) . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . to append = ajouter
L=L+[7];print(L) . . . . . . . . . . . . . . . . . . . même eet que l'instruction précédente
L.reverse();print(L) . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . to reverse = inverser
L.index(8) . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . index = position
sorted(L) . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . to sort = trier
Remarque. Les éléments d'une liste peuvent eux-mêmes être des listes :
I M=[1,3,5,['riri','fifi','loulou']]
I print(M[3])
I print(M[3][2])
2.6 Convertir une valeur
Il est possible de convertir une valeur d'un certain type vers un autre type. Pour cela, les
mots-clé int, float, bool, str, list, en plus de représenter des types, constituent des
instructions qui ont pour eet de convertir une valeur dans le type désiré. C'est possible
quand il existe une manière naturelle de faire la conversion.
Par exemple l'expression
I float(2)
crée le nombre ottant correspondant à 2, c'est à dire le nombre 2, 0.
Autres exemples :
I
I
I
I
I
I
I
I
I
I
I
I
I
I
int(2.3) . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . int calcule donc la partie entière.
str(2)
345+678
str(345)+str(678)
'24'+'57'
int('24')+int('57')
a='4.5'
2*a
2*float(a)
list('coucou')
bool(1)
bool(0)
int(False)
int(True) . . . . . . . . . . . . . . . . . . . . . . . . . . . En logique binaire, 1 = vrai et 0 = faux.
Quand il n'existe pas de conversion naturelle une erreur sera renvoyée :
I int('24a')
I int('2.3')
I float([1,4,6])
Remarque : Python peut parfois convertir une variable par nécessité. Exemples :
I True+True+False
I True*3
I False*3
5
Exercice 1
Expliquer le résultat pour chacune des commandes suivantes, certes tirées par les cheveux.
I len(str(float(7)))
I sorted(str(1==2)+str(1==1))
I len(str(len(str(len('Grandschtroumpf')))))
3 Fonctions, modules et chiers
3.1 Fichiers .py
Nous allons maintenant apprendre à travailler dans l'éditeur : nous y écrirons des scripts
et les exécuterons. Un script est un chier texte contenant des lignes de code constituant un programme, autrement dit c'est un ensemble d'instructions. Nous pourrons par
ailleurs enregistrer un script sous la forme d'un chier portant l'extension .py (comme
python). Un chier .py est aussi appelé un module.
L'exécution d'un chier .py a pour eet d'eectuer dans le shell l'exécution de chacune
des lignes d'instruction contenues dans le script, l'une après l'autre.
Cette façon de procéder possède de nombreux avantages :
• On n'est pas restreint à une seule ligne pour écrire nos instructions, par conséquent
on peut écrire facilement des séquences de plusieurs instructions.
• Notre travail n'est pas perdu quand on ferme Python : les chiers .py créés peuvent
être sauvegardés, emportés à la maison, modiés, envoyés au prof ou aux camarades. . .
• On bénécie de toutes les fonctionnalités pratiques de l'éditeur que vous découvrirez
bientôt : coloration syntaxique, indentation automatique. . .
Première expérience avec l'éditeur
Faites File → Save As puis choisissez le nom du chier et l'emplacement de
votre choix. Je suggère : monTP2.py dans un répertoire TP_python/TP2 de votre
machine. L'utilisation de l'éditeur est enfantine :
• tapez plusieurs lignes d'instruction dans l'éditeur :
a=1
b=3
c=(a+b)*(b+1)
print(c)
print('et voila')
• Faites Ctrl+E (le raccourci pour la commande Execute )
Que s'est-il passé ? Dans la fenêtre principale, on vous signale que toutes les lignes
de votre chier ont été exécutées comme si vous les aviez rentrées l'une après l'autre
dans le shell.
6
Résultat : la 4ème ligne a produit l'achage de la valeur de la variable c. La 5ème ligne
a produit l'achage du message 'et voila'. Rien de bien glorieux pour l'instant mais avec
l'éditeur les possibilités sont prodigieuses.
Prenez donc quelques minutes pour faire vos propres expériences avec l'éditeur !
3.2 Dénir des fonctions
Intérêt d'une fonction : apprendre à l'ordinateur à accomplir une tâche qu'il ne savait
pas accomplir auparavant, et qu'on pourra ensuite lui demander d'accomplir en exécutant la dite fonction. Nous avons déjà manipulé des fonctions pré-existantes, comme par
exemple cos. Voyons comment faire pour en créer des nouvelles, personnalisées.
Attention : comme vous verrez, une fonction informatique n'est pas exactement une
fonction au sens mathématique du terme. Par exemple une fonction informatique peut ne
pas avoir de variable, ou même ne pas renvoyer de valeur de sortie.
En fait une fonction, pour Python, désigne le regroupement d'un certain nombre d'instructions (de toutes sortes) que Python eectuera d'un coup le jour où la fonction sera appelée.
La syntaxe pour créer une fonction est la suivante.
def ma_fonction(arguments):
...
...
[bloc d'instructions]
...
...
Remarques importantes
• chaque ligne du bloc
d'instructions de la fonction DOIT être décalée d'un alinéa
de 4 espaces (ou une Tab) Python ne rigole pas avec ça ! C'est la n de l'alinéa
qui signale que la dénition de la fonction est terminée.
Cette règle peut paraître embêtante mais elle est en fait très commode. Grâce à
elle le code est très lisible : on repère du premier coup d'÷il où commence
et où termine la dénition d'une fonction. Vous verrez que l'éditeur Python vous
simpliera la vie en créant automatiquement ces alinéas.
• le symbole : est obligatoire à la n de ligne d'en-tête (sinon, message d'erreur
lorsqu'on fait Ctrl+E). En cas d'oubli, ça se remarquera tout de suite : l'éditeur ne
fera pas la création automatique d'alinéa en signe de protestation.
• la construction ci-dessus ne fait que déclarer votre fonction, elle ne l'exécute pas.
Il est donc normal que le shell ne retourne ni n'ache rien après que vous tapiez
Ctrl + E.
Pour exécuter la fonction il faudra en fait le faire dans le shell en tapant :
I nomdelafonction(a,b,c)
avec bien sûr autant d'arguments a,b,c... que vous en aviez déclarés en dénissant
votre fonction.
• vous pouvez nommer votre fonction comme vous voulez, mais et évitez les majuscules et les accents pour éviter toute erreur.
7
Premières expériences sur les fonctions :
(1) Un exemple de fonction sans argument
def tablede4():
n=4
print('la table de 4 commence par :')
print(n,2*n,3*n,4*n,5*n)
(2) Un exemple de fonction avec un argument
def tableden(a):
print('la table de '+str(a)+' commence par :')
print(a,2*a,3*a,4*a,5*a)
(3) Un exemple de fonction avec plusieurs arguments
def division(x,y):
print('reste de la div de'+str(x)+' par '+str(y)+' = '+str(x%y))
print('Le quotient de la division de'+str(x)+' par '+str(y)+' est : '+str(x//y))
(4) Un exemple de fonction qui en appelle une autre :
def tables():
tableden(1)
tableden(2)
tableden(3)
tableden(4)
tableden(5)
Toutes ces fonctions ne sont pas vraiment des fonctions à proprement parler mais des
procédures. En eet, même si elles ont eectué une tâche (elles ont produit un achage)
elles ne renvoient pas de valeur de sortie. En comparaison, cos est une vraie fonction car
à une valeur d'entrée x est associée une valeur de sortie cos(x).
Pour comprendre, dénissez par exemple la fonction suivante :
def cube(x):
print(x*x*x)
puis analysez ce qui se passe si on fait :
I
I
I
I
I
cube(3)
cube(3)-1
M=cube(10) . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . Bon sang mais où est le problème ?
M
type(M)
(5) Une fonction qui renvoie une valeur de sortie : l'instruction return
On reprend l'exemple précédent, à un détail près :
8
def cube_bis(x):
return(x*x*x)
dans l'éditeur, la ligne contenant return est forcément la dernière du paragraphe dénissant la fonction. Le saut à la ligne suivant se fait donc automatiquement
sans alinéa après le mot return.
Grâce à l'instruction return, la fonction cube renvoie eectivement une valeur. Cette valeur pourra ensuite être utilisée comme n'importe quelle autre variable. Testez à nouveau
Remarque.
I
I
I
I
cube_bis(3)-1
M=cube_bis(10)
M
type(M)
(6) Un exemple de fonction qui parle à l'utilisateur : l'instruction input
Une autre façon d'intégrer un paramètre dans une fonction est de dialoguer avec l'utilisateur, en utilisant l'instruction input(). C'est l'équivalent de la fonction prompt utilisée
au lycée mais la syntaxe est diérente : faites
I
I
I
I
a=input()
b=input('rentrer un nombre : ')
print(a+b)
print(int(a)+int(b))
A retenir, donc : input renvoie une chaîne de caractère, que celle-ci soit constituée de
chires ou non. Si l'on veut avoir accès au nombre lui-même il faudra commencer par une
conversion.
On peut utiliser input dans un programme :
def cube_ter():
a=input('Donnez moi un nombre je vous donnerai son cube')
a=int(a)
print(str(a)+' puissance 3 ='+str(a*a*a))
L'avantage est que l'utilisateur a juste à écrire le nom de la fonction sans se préoccuper
de ce que désignent les noms des variables utilisées. Cependant son utilisation n'est pas
justiée si vous êtes vous-même l'utilisateur.
3.3 Les commentaires dans un script
La lecture et la compréhension d'un script Python, si ce script est conséquent en taille,
est un exercice dicile. Comme tous les langages de programmation, Python permet pour
cette raison de documenter les scripts qu'on écrit.
Documenter un script, c'est faire des commentaires, à l'intérieur du script, qui ne seront
pas interprétés par Python. Ces commentaires serviront donc uniquement à fournir des
explications sur le script. Voici un exemple :
def pingouin(x):
# attention, n'oubliez pas le symbole :
9
y=2*x**2-3*x+5
return y
# L'exposant ne s'écrit pas ^ mais **
Dans cet exemple les commentaires ont peu d'intérêt mais dès qu'un script contient plus
de 10 lignes, utilise des boucles, des formules compliquées, et un grand nombre de variables, l'usage des commentaires est indispensable. Prenez l'habitude de les utiliser.
Comment insérer des commentaires ? En Python, on insère un commentaire grâce
au symbole #. Dans une ligne, tout ce qui est après un symbole # est considéré comme
commentaire. Un double # en début de ligne permet de tracer une ligne droite de séparation.
A qui s'adressent les commentaires ? A n'importe quelle personne qui lira votre
script ultérieurement :
• votre professeur à qui vous avez demandé de corriger votre script,
• un collègue avec qui vous collaborez pour écrire un script,
• au jury de l'oral de Maths-info, qui sera amené à lire votre projet info,
• plus fréquemment à vous-même : il arrive souvent de devoir reprendre un ancien
script pour le modier. Croyez-moi, sans commentaire on ne comprend plus rien à
ce qu'on avait soi-même écrit un mois auparavant !
4 Variables locales / variables globales
4.1 Dénition
Lorsqu'on dénit des variables à l'intérieur du corps d'une fonction, ces variables ne sont
accessibles qu'à la fonction elle-même. On dit que ces variables sont des variables LOCALES de la fonction. Par exemple créez la fonction suivante dans l'éditeur :
def fonctionexemple(x):
y=2*x
z=y+1
return z
Puis tapez les commandes suivantes :
I fonctionexemple(3)
I print(y)
Python vous signale qu'il ne connaît pas de variable portant le nom y. C'est normal :
à chaque fois que la fonction fonctionexemple est exécutée, elle va créer des variables x
et y durant l'exécution, mais ces variables seront automatiquement détruites à la n de
l'exécution de la fonction.
a le même rôle qu'une variable muette
Métaphore : une variable locale en informatique
P
en mathématiques. Lorsque vous calculez nk=1 k 2 , vous utilisez la variable k . Cependant,
dès que votre calcul est terminé, que vous êtes ressorti de la somme, la variable k n'a plus
d'existence.
10
A l'inverse, les variables dénies à l'extérieur d'une fonction sont des variables GLOBALES. Il faut savoir que
• le contenu d'une variable globale est visible de l'intérieur d'une fonction : on peut
faire appel à sa valeur dans une instruction faisant partie d'une déclaration de
fonction.
• une variable globale ne peut pas etre modiée à l'intérieur d'une fonction. On ne
peut pas modier sa valeur dans une instruction faisant partie d'une déclaration de
fonction.
s'il se trouve, par coïncidence, qu'une fonction utilise une variable (locale)
qui porte le même nom qu'une autre variable (globale) dénie en dehors de la fonction,
alors en réalité Python crée deux variables bien distinctes et indépendantes.
Intérêt : quand vous écrivez une fonction vous pouvez choisir librement les noms de vos
variables ! Aucun risque d'écraser d'autres variables dénies à l'extérieur de la fonction.
Cela n'arrivera pas puisque toutes les variables de votre fonction seront locales.
Remarque.
4.2 Un exemple d'illustration
• Créez la fonction suivante dans l'éditeur
def glouglou():
plic=2
print('valeur de plic : '+str(plic))
print('valeur de ploc : '+str(ploc))
• Expliquer ce qui se passe lors de l'exécution de la fonction dans la fenêtre principale :
I glouglou()
• Recommençons en créant au préalable une variable ploc. Analyser la réaction de Py-
thon pour chacune des lignes.
I ploc=3
I glouglou()
I plic
• On fait la même chose mais auparavant on crée la variable globale plic. Analyser.
I plic=500
I glouglou()
I plic
4.3 Déclarer une variable globale
Il est possible de forcer une fonction à travailler avec une variable globale, en le déclarant
explicitement par la commande :
global nomdevariable,
ce qui signie qu'on déclare à Python "dans la présente fonction, nomdevariable désignera la variable globale qui porte ce nom".
Exemple.
Créez la fonction :
11
def fonction_qui_met_a_au_carre_et_affiche_a():
global a
a=a**2
print('a vaut désormais ',a)
Et dans la fenêtre principale, faites (n'oubliez pas l'utilité de la touche ↑) :
I
I
I
I
a=2
fonction_qui_met_a_au_carre_et_affiche_a()
fonction_qui_met_a_au_carre_et_affiche_a()
fonction_qui_met_a_au_carre_et_affiche_a()
12
5 Un peu de pratique : exercices sur les fonctions
Exercice 2
Volume d'une sphère Créer une fonction volumesphere(R) qui prend en argument un nombre R et qui renvoie
le volume d'une sphère de rayon R
Exercice 3
Une fonction quelconque Créer une fonction f qui prend en argument deux réels x et y et renvoie la valeur de
f (x, y) = x2 y 2 +
Exercice 4
cos y
− bx + yc.
cos x
Création d'une liste à partir d'une chaîne de caractère Créer une fonction toto(C) qui prend en argument une chaîne de caractère C et renvoie une liste contenant
• comme premier élément le premier caractère de C,
• comme deuxième élément le dernier caractère de C,
• comme troisième élément la longueur de C,
. toto('messagesecret') renverra ['m','t',13]
Exemple
Exercice 5
Raccourcir un message Créer une fonction moitie(D) qui prend en argument une chaîne de caractère D et renvoie une chaîne contenant uniquement la première moitié des caractères de D (arrondi à
l'inférieur).
. si on exécute moitie('coucou') la fonction devra renvoyer la chaîne 'cou'
Exemple
Exercice 6
Calcul de l'équation d'une droite Créer une fonction equation_droite() qui prend en entrée les coordonnées de 2 points
A et B et ache l'équation de la droite passant par ces deux points. Les données xA , yA ,
xB et yB pourront être rentrées, au choix :
1. en tant que paramètres de la fonction equation_droite(xA,yA,xB,yB)
2. en utilisant l'instruction input().
Exemple. Pour les points A(1, 5) et B(3, 11) la fonction devra acher :
L'equation de la droite est :
y = 3.0 x + 2.0
13
Exercice 7
Simplier une fraction rationnelle
Créer une fonction qui permet d'écrire une fraction rationnelle
H+
G
.
cx + d
Exemple.
ax + b
sous la forme
cx + d
Si a = 4, b = 5, c = 2, d = 1, la fonction provoquera l'achage suivant :
(4x+5)/(2x+1)= 2+3/(2x+1)
Exercice 8
Censure
Créer une fonction censure qui prend comme argument un (gros) mot, et remplace toutes
les lettres par * sauf la première et la dernière.
Exemple.
censure('scrogneugneu') retournera 's**********u'
Exercice 9
Compter en heures, minutes, secondes Créer une fonction temps qui prend un argument S (nombre de secondes) et qui exprime S sous forme d'heures, minutes et secondes. La fonction devra acher le résultat
sous forme d'une belle phrase :
. temps(3733) devra acher
Exemple
'3733 secondes, ça fait 1 heure, 2 minutes et 13 secondes'
Les perfectionnistes pourront faire en sorte que le s du pluriel ne s'ache pas pour les
chires 1 et 0.
Exercice 10
Nombre de racines d'un polynôme Créer une fonction racines(a,b,c) qui prend en argument trois coecients a, b et c,
calcule le discriminant du polynôme P = aX 2 + bX + c, et précise le nombre de racines
réelles de P .
Exemple.
l'exécution de racines(2,1,-2) achera :
Delta=17. Le polynôme P possède 2 racines réelles.
14