INFO 1 Découverte de Pyzo et éléments de programmation en ...INFO 1 Découverte de Pyzo et...

INFO 1 Découverte de Pyzo et éléments de programmation en Python

Dans ce premier cours, on découvre le langage Python et on jette les bases de laprogrammation impérative.

1 Découverte de Pyzo et éléments de programmation en Python . . . . . . . . . . . . . . . . . . . . . . . . . . . 11 Le langage Python . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 22 Les environnements de développement . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 23 La notion de type en programmation . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 3

3.1 Nécessité du typage, catégories de typage . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 33.2 Entiers de Python . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 33.3 Flottants de Python . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 43.4 Booléens de Python . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 53.5 La fonction type et le transtypage sous Python . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 6

4 Les variables informatiques . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 65 Le noyau impératif d’un langage de programmation . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 8

5.1 Le test sous Python . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 85.2 La boucle sous Python . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 9

6 Corrigés des exemples . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 11

PCSI 2 \ 2019-2020 Laurent Kaczmarek

1. Le langage Python

Python a été créé en 1990 par Guido van Rossum, grandfan des Monty Python. C’est un langage orienté objet, im-pératif et interprété (le code écrit par le programmeur esttransformé « à la volée » en langage machine exécutable parl’ordinateur). Sa syntaxe, éloignée de celle des langages deplus bas niveau, permet une initiation aisée aux conceptsde base de la programmation.

Python est très largement utilisé : Youtube, Google 1, la Nasa, Industrial light & Magic, etc. Il est deplus en plus utilisé dans les cours d’informatique.

2. Les environnements de développement

Un environnement de développement est un logiciel permettant de rationaliser la création et le dé-veloppement de programmes.

Il comporte un éditeur de texte permettant d’écrire et de sauvegarder des programmes longs et mo-dulaires, des raccourcis pour les compiler ou les déboguer et un interpréteur.

Les environnements de développemnt suivants sont gratuits et compatibles avec Python : Eclipse,Idle, Spyder, pyzo. Cette liste n’est pas exhaustive. Le lycée Louis-Le-Grand a choisi d’installer l’envi-ronnement de développement pyzo dans les salles de TP.

Pyzo est composé de trois fe-nêtres (qui peuvent se fermer etêtre redimensionnées) :

. en haut, l’interpréteur Python;

. en bas à gauche, l’éditeur detexte ;

. en bas à droite, l’explorateurde fichiers.

Les programmes sont écrits dansl’interpréteur ou dans l’éditeur ;leur mode d’exécution en dépen-dera.

L’interpréteur s’utilise comme une calculatrice et, en cela, n’est adapté qu’à des vérifications, des pro-grammes ou des calculs courts qui n’ont pas besoin d’être sauvegardés. Les programmes plus longsou destinés à être sauvegardés sont écrits dans l’éditeur et exécutés dans l’interpréteur (cf. le menuExécuter dans la barre outil tout en haut de la fenêtre principale).

1. Rossum a travaillé pour Google jusqu’au milieu des années 2000.

LLG \ PCSI 2 INFO 1 \ 2


L’affichage d’un résultat est automatique pour un programme écrit dans l’interpréteur ; pour un pro-gramme écrit dans l’éditeur, il faudra utiliser l’instruction de sortie print pour obtenir l’affichagedans l’interpréteur.

3. La notion de type en programmation

La notion de type est une réponse à l’un des problèmes soulevés par le stockage des données dans lamémoire d’un ordinateur.

3.1. Nécessité du typage, catégories de typage

Dans un ordinateur, l’information est manipulée sous forme binaire quelque soit sa nature (nombreentier relatif, décimal, chaîne de caractères, etc). Par exemple, selon l’interprétation qu’on en fait,la séquence binaire 00111010 peut désigner le caractère de ponctuation « : » (selon le code ASCII,American Standard Code for Information Interchange) ou l’entier 58 écrit en base 2. Pour lever touteambiguité sur l’interprétation d’une donnée sous forme binaire, il est nécessaire de lui associer untype, ie une interprétation. Nous exposerons dans un premier temps les types primitifs de Python.

3.2. Entiers de Python

Python utilise le type int pour les entiers relatifs. Ceux-ci sont manipulés en base 10 dans les pro-grammes, avec un signe − pour les éléments de Z \N. Le nombre de chiffres est théoriquement illi-mité 2.

Opérateurs sur les entiers

Opérateur Opération

+ Addition

- Soustraction

* Multiplication

/ Quotient usuel

a%b Reste dans la divisioneuclidienne de a par b

a//b Quotient dans la divisioneuclidienne de a par b

a**n a puissance n

Attention à ne pas confondre a//b (quotient dans divi-sion euclidienne) et a/b (quotient dansQ).

Il suffit d’écrire l’opération souhaitée dans une ligne ac-tive de l’interpéteur Python et d’appuyer sur la toucheENTRÉE pour obtenir le résultat :

>>> 45-441>>> 45+3479

>>> 45*4180>>> 45**22025

>>> 45//41>>> 45%41

2. Python manipule ce qu’on appelle des entiers longs depuis la version 3. En fait, il y a évidemment une limite, la taille de la mémoire de l’ordinateur.



�La notion d’expression entièrePlus généralement, en combinant des constantes et des opérateurs, on obtient ce qu’on appelleune expression entière. La syntaxe est celle des mathématiques (utilisation de parenthèses, on

ne divise par zéro, etc), nous ne l’expliciterons pas. Par exemple, 34, 47-65*3 et 32-3165 sont desexpressions entières. Pour obtenir la valeur de l’expression, autrement dit pour évaluer l’expression,on l’écrit directement dans l’interpréteur et on appuie sur la touche ENTRÉE.

Signalons que Python applique également des règles de précédence 3, mais il est préférable de paren-théser correctement ses calculs :

>>> 2**2+5//35

>>> 2**(3+5//3)16

>>> 2**2+5//3*26

>>> 2**2+5//(3*2)4

3.3. Flottants de Python

Les nombres à virgule flottante, appelés aussi flottants, forment un sous-ensemble de l’ensemble desnombres décimaux. Ils permettent la représentation informatique des nombres réels. Nous les étu-dierons plus en détail dans le cours sur la représentation informatique des nombres. Contrairementau cas des entiers, la précision est ici limitée. Pour écrire un flottant, on utilise le symbole . au lieu dela virgule. On peut aussi utiliser la notation m e n pour m10n (m est la mantisse et n est l’exposant).

>>> 0.0004578954330.000457895433

>>> 4.57895433e-40.000457895433

Opérateurs sur les flottants

Les opérateurs +, -, /, * et ** sont valables pour les nombres flottants. Voici quelques exemples depuisun interpéteur Python :

>>> 7.6*4.735.72

>>> 4.3**5.42634.69083146

>>> 7/41.75

>>> 6.6-4.52.09999999999

>>> 6.5+9.516.0

On définit comme au paragraphe précédent la notion d’expression flottante (cf. page 4).

La précision étant limitée, les calculs sur les flottants, contrairement aux calculs sur les entiers, nesont approchés et les propriétés usuelles de + et × (commutativité et associativité par exemple) nesont plus vérifiées en général :

>>> 1-1/3-1/3-1/31.1102230246251565e-16

>>> 1-(1/3+1/3+1/3)0.0

�Choix d’un type de donnéesAvant de programmer, il faut choisir avec soin un type des données approprié aux traitements

3. C’est-à-dire de priorité. Par exemple, 3+5*4 sera compris comme 3+ (5×4) par un interpréteur Python, et non pas comme (3+5)×4 : on dit quela multiplication est prioritaire sur l’addition.



que l’on va effectuer : la précision est infinie pour les entiers ce qui n’est pas le cas pour lesflottants. Par exemple, pour faire des calculs sur des montants en euros, il sera préférable de travailleravec l’unité centime afin de ne manipuler que des entiers.

On remarque que la présence d’un flottant dans une expression numérique impliquera que la valeuraprès évaluation sera un flottant même si le nombre est, au sens mathématique, un entier relatif. C’estune des conséquences du typage dynamique de Python.

>>> 1+23456789902345678991

>>> 1.0+23456789902345678991.0

3.4. Booléens de Python

Le type bool (pour booléens) n’admet que deux constantes : False et True. Ce type correspond auxvaleurs de vérité Vrai et Faux de la logique.

Opérateurs logiques

Pour combiner des booléens booléennes, on dispose des trois opérateurs logiques, la disjonction,la conjonction et la négation : or (ou), and (et), not (non). Ils sont définis par les tables de véritésuivantes :

b1 b2 b1 or b2 b1 and b2 not(b1)True True True True FalseTrue False True False FalseFalse True True False TrueFalse False False False True

On étend naturellement la notion d’expression aux booléens (cf. page 4) au moyen de ces opérateurs.Voici une illustration dans un interpréteur Python :

>>> not(False or True)False

>>> (False or True) and (not(True))False

Construction de booléens par opérateurs de comparaison

On appelle expression de type numérique toute suite de caractères du langage définissant une constanted’un des types numériques (int et float pour Python).

Les opérateurs de comparaison permettent de construire des valeurs booléennes à partir d’autresexpressions. On peut appliquer à des couples d’expressions les opérateurs de comparaison suivants :

Opérateur Sens

== = (égalité)

!= 6=>, < >, <>=, <= Ê, É

Voici quelques exemples de comparaison obtenues depuis un interpré-teur Python :

>>> 1<2True

>>> 2>=2True

>>>15==45-3*10True

>>>15!=45-3*10False

Ces opérateurs sont paresseux. Par exemple, dans x and y, si la valeur de l’expression x après éva-luation est False, la deuxième expression y n’est pas évaluée.



3.5. La fonction type et le transtypage sous Python

La fonction type permet d’identifier le type d’une expression.

>>> type(3-4)<type ’int’>

>>> type(False)<type ’bool’>

>>> type(5.6)<type ’float’>

>>> type(3-4.0)<type ’float’>

Les fonctions int et float permettent des changements de type. On peut en particulier transformerun nombre donné par la chaîne de caractères de ses chiffres en base 10 en l’entier correspondant :

>>> float(355565)355565.0

>>> int(355565.0)355565

>>> int("355")355

4. Les variables informatiques

Une variable est un espace mémoire dans lequel il est possible de mettre une valeur, cette opérationétant appelée affectation. L’utilisateur manipule cette variable par l’intémédaire d’un nom qu’il choi-sit :

>>> x=2 >>> 2*x4

>>> id(x)148684964

Dans ce qui précède, la fonction id de Python permet d’accéder à la référence 4 148684964 qui per-met au système de trouver l’adresse-mémoire correspondant à la variable x. On retiendra la syntaxed’une affectation et les noms de variables admissibles :

Symbole d’affectation =

Noms de variableFormés de lettres sans accent, de chiffres, du caractère tiret bas _ etcommencent toujours par une lettre

On étend la notion d’expression au cas des variables (cf. page 4). Pour évaluer une expression, il suffitde l’écrire dans un interpréteur et d’appuyer sur la touche Entrée : l’ordinateur substitue les valeursstockées dans la mémoire aux noms de variable correspondants puis évalue l’expression numériqueainsi trouvée. Un petit exemple dans un interpréteur Python :

>>> x=0>>> x=17

>>> 12*x+17217

�Affection Vs. égalitéUne des erreurs les plus courantes chez le pythonneux débutant est de confondre le symboled’affectation = et le comparateur logique ==.

4. Les mécanismes d’allocation de mémoire ne sont pas un attendu du programme et varient beaucoup selon les langages. Sous Python, les variablescontiennent en fait les références, pas les valeurs. La référence d’une variable est générée lors de l’interprétation du programme et associée à l’adressede la mémoire où est effectivement stockée la valeur de la variable.



>>> x=0 >>> x0

>>> x==1False

>>> x0

Il est souvent commode, plus efficace et plus lisible de n’utiliser qu’une seule variable dans un pro-gramme. La variable prend des valeurs successives au cours de l’algorithme, seule la valeur finale étantd’intérêt. Pour mettre à jour une variable x au moyen d’une expression exp, on utilisera la syntaxe quisuit.

Code Action

x=exp l’expression exp est évaluée puis le résultat est stocké dans lavariable x

x+=expa le même effet que x=x+exp : l’expression exp est évaluée, puissa valeur est ajoutée à celle de x et finalement le résultat finalest enregistré dans x

x-=exp a le même effet que x=x-exp

Quelques exemples dans un interpréteur Python :

>>> x=3>>> y=x>>> x=1000>>> z=y**2+1

>>> x,y,z(1000,3,10)>>> x*y3000

>>> type(z)<type ’int’>>>>y==(y//x)*x+y%xTrue

>>> x=3>>> x+=2>>> x5

Moralité : les modifications de la variable x sont sans impact 5 sur la variable y.

Continuons avec les affectations multiples. Elles sont très spécifiques au langage Python et ne pour-ront pas être utilisées dans d’autres langages.

Code Action

x1,x2=exp1,exp2 les expressions exp1 et exp2 sont évaluées puis les résultatssont respectivement affectés aux variables x1 et x2

Le procédé se généralise à un nombre fini quelconque de variables. Voici quelques exemples d’affec-tations multiples dans un interpréteur Python :

>>> x=2>>> y=3

>>> x,y=2*x+3*y,4*x >>> x,y(13,8)

Exemple 1.1. On effectue les affectations suivantes les affectations x = 2 et y = 5.Calculer à la main les valeurs des expressions suivantes puis vérifier les résultats dans un interpré-teur Python :

a) x*y-2 ;

b) y**2 ;

c) x<=y ;

d) y<x and y**2>x**2 ;

e) x*y>1 ;

f ) x**(-2).

5. Attention, ce ne sera plus le cas pour des variables du type list. Cela vient essentiellement du fait que, en Python, l’affectation se fait par adressageet que les listes, contrairement aux entiers et aux flottants, est un type mutable.



5. Le noyau impératif d’un langage de programmation

En 2014, on recense près de 2000 langages de programmation. On peut dégager, dans la plupart deslangages, qu’ils soient impératifs ou non, un groupe de cinq constructions élémentaires qui consti-tuent ce qu’on appelle le noyau impératif du langage :

• LA DÉCLARATION et L’AFFECTATION : nous les avons déjà étudiées ci-dessus;

• LA SÉQUENCE : exécution d’une première instruction p1 puis d’une seconde p2 ;

• LE TEST : selon l’état des variables, on exécute une instruction p1 ou une autre instruction p2 ;

• LA BOUCLE : répéter une instruction p un nombre de fois dépendant de l’état des variables.

5.1. Le test sous Python

C’est l’instruction if...then qui permet de réaliser un test. En voici la syntaxe.

Soient b une expression booléenne , p1 et p2 deux instructions. Le sens de l’instructionci-contre est le suivant : si, après évaluation b vaut True, alors p1 est exécutée ; sinon,Python exécute p2.

if b:p1

else:p2

if b:p1

L’alternative else dans le programme précédent est optionnelle. Le sens de l’instru-cion ci-contre est le suivant : si, après évaluation, b vaut True, alors l’instruction p1 estexécutée ; sinon, il ne se passe rien.

�Syntaxe d’un test sous PythonOn respectera scrupuleusement cette syntaxe qui est en par-tie spatiale ; les deux points « : » marquent la fin de la condi-

tion du test et l’indentation 6de p1 est obligatoire, car elle délimitela portée de l’instruction if.

if b :p1

fin de la condition

indentation

passage à la ligne

Voici un exemple.

Le programme ci-contre affiche le plus grand des deuxnombres a et b.

if a<b:print (b)

else:print (a)

On peut généraliser cette syntaxe. On utilise alors le mot-clé elif (qui est la contraction de else if).L’instruction else permet de déterminer les autres cas.

if b1:p1

elif b2:p2

etc.elif bN:

pNelse:

p’

Dans ce cas, le déroulement de la suite d’instructions est la suivante :

. L’expression booléenne b1 est évaluée. Si elle est vraie, l’instruction p1 est exécutée.

. Si b1 est fausse et b2 est vraie, l’instruction p2 est exécutée.

. etc.

. Si les bk pour k ∈ �1,N� sont fausses, l’instruction p’ est exécutée.

. À noter que dès qu’une condition est satisfaite, les instructions associées sont effec-tuées et le programme sort du test. Dans un test, on peut utiliser plusieurs instruc-tions elif. Cependant, il y a au plus une instruction else.

6. Elle s’effectue automatiquement dans l’éditeur d’un environnement de développement, par exemple pyzo.



5.2. La boucle sous Python

Il existe deux types de boucles : la boucle conditionnelle, dite boucle while, et la boucle incondition-nelle, dite boucle for.

La boucle while

Si on souhaite répéter une séquence d’instructions un nombre de fois qui n’est pas connu à l’avancecar dépendant de l’état des variables, on utilise une boucle while.

Soient b une expression boolénne et p une instruction. Voici la syntaxe d’une bouclewhile. Comme dans le cas d’un test, notez les deux points et l’indentation.

while b:p

if b:pif b:

pif b:

pif b:

petc.

Son sens est le suivant : si b 7est True, on exécute l’instruction pet on revient au début de la boucle, on évalue à nouveau b ; sinon,on sort de la boucle.

Nous avons ici un premier exemple de programme poten-tiellement infini. La boucle while peut être vue comme uneformalisation de l’instruction infinie ci-contre. Une boucle whilepeut en effet être infinie, c’est ce qui se passe lorsque l’expressionbooléenne b est toujours vraie. Il s’agit bien-sûr d’une erreur deprogrammation car, concrètement, le programme ne s’arrête pas.

Exemple 1.2. Qu’affichent les programmes suivants ?

s,k=0,0while s <24:

k=k+1s=s+k

print(k)

s,k=0,0while s <24:

s=s+kk=k+1

print (k)

s,k=0,0while k <24:

s=s+kk=k+1

print (k)

s,k=0,0while k <=24:

k=k+1s=s+k

print (s)

Exemple 1.3. Calcul de la factorielleÉcrire un programme affichant la factorielle d’un entier n non nul préalablement défini (on imposeici l’utilisation d’une boucle while). On rappelle que la factorielle de n ∈N∗ est le produit de tousles entiers naturels de 1 à n.

La boucle for

Quand une instruction est itérée un nombre de fois connu à l’avance,on utilise une boucle for. Soient n une variable ou une constante à va-leur dans N et p une instruction. L’instruction ci-contre exécute n foisl’instruction p.

for i in range(n):p

6. Expression appelée condition comme dans le cas des tests.



for i in range (4):print ("LoL")

print (i)

Explication : cette instruction crée une variable i qu’elle affecte suc-cessivement aux valeurs 0, 1, . . . , n − 1. Par exemple, le programmeci-contre affiche 4 fois LoL puis renvoie 3 : en fin de boucle, la variabled’indice existe encore et sa dernière valeur vaut 3.

L’utilisateur peut choisir n’importe quel nom valable de variable à la place de i. Comme dans le casdes tests et de la boucle while, l’indentation du bloc d’instructions est obligatoire, car elle délimite laportée de l’instruction for.

On peut généraliser cette syntaxe : on peut remplacer range(n) par range(debut,fin,pas) et dansce cas la variable i décrit dans l’ordre croissant l’ensemble des entiers de la forme deb+k*pas com-pris entre deb et fin-1 où k ∈ N. Par exemple, pour range(3,17,2), la variable d’indice prendresuccessivement les valeurs 3, 5, 7, 9, 11, 13, et 15.

�Gestion de l’indice dans une boucle forLes indices sont à valeurs dans � deb,fin�, c’est une erreur classique chez le pythonneux débu-tant. On prendra garde aux indices de début et de fin! L’argument fin est par défaut égal à 0 et

l’argument pas est par défaut égal à 1. En fin de boucle, la variable d’indice existe toujours et contientla dernière valeur générée par range.

for i in range(debut ,fin ,pas ):p

L’instruction p est executée pour chacunedes valeurs ind de la séquence générée parrange.

Exemple 1.4. Ma première boucle for en PythonIf we list all the natural numbers below 10 that are multiples of 3 or 5, we get 3, 5, 6 and 9. The sumof these multiples is 23. Find the sum of all the multiples of 3 or 5 below 1000.

Exemple 1.5. Calcul de la factorielleÉcrire un programme affichant la factorielle d’un entier n préalablement défini (on impose ici l’uti-lisation d’une boucle for).

Exemple 1.6. Toute boucle for peut s’écrire sous la forme d’une boucle while

Exemple 1.7. Jeu de désDe combien de façons différentes peut-on obtenir la somme de 20 avec 5 dés différenciés ?

Exemple 1.8. Fibonacci’s numbersEach new term in the Fibonacci sequence is generated by adding the previous two terms. By startingwith 1 and 2, the first 10 terms will be :

1,2,3,5,8,13,21,34,55,89, ...

By considering the terms in the Fibonacci sequence whose values do not exceed four million, findthe sum of the even-valued terms.

Exemple 1.9. Le 10001-ème nombre premierUn entier naturel n Ê 2 est dit premier si ses seuls diviseurs positifs sont 1 et n. Le premier nombrepremier est 2, le deuxième est 3, le troisième est 5, etc. Écrire un programme affichant le 10001-èmenombre premier.



6. Corrigés des exemples

SOLUTION 1.1.

On trouve successivement :

a) -12 ;

b) 25 ;

c) True ;

d) False ;

e) False ;

f ) .25.

SOLUTION 1.2.

. Le premier programme affiche 7, le plus petit entier naturel n tel que 1+·· ·+n Ê 24.

. Le deuxième programme affiche 8, le plus petit entier naturel n tel que 1+·· ·+n −1 Ê 24.

. Le troisième programme affiche 24.

. Le dernier programme affiche 325, valeur de la somme 1+·· ·+25.

SOLUTION 1.3.

n,f,k=100 ,1 ,1while k<=n:

f=f*kk=k+1

print (f)

SOLUTION 1.4.

On trouve 233168 au moyen du programme suivant :

s=0for i in range (1 ,1000):

if i%3==0 or i %5==0:s=s+i

print (s)

SOLUTION 1.5.

f,n=1 ,100for i in range (2,n+1):

f=f*iprint (f)



SOLUTION 1.6.

f,n=1 ,100for i in range (2,n+1):

f=f*iprint (f)

SOLUTION 1.7.

Les boucles for et while suivantes effectuent le même traitement, elles itèrent n fois la séquence d’ins-tructions p :

for i in range(n):p

k=0while k<n:

pk=k+1

SOLUTION 1.8.

On trouve 651 au moyen du code suivant :

s=0for a in range (1 ,7):

for b in range (1 ,7):for c in range (1 ,7):

for d in range (1 ,7):for e in range (1 ,7):

if a+b+c+d+e==20:s=s+1

print (s)

SOLUTION 1.9.

On trouve 4613732 par le script suivant :

s,u0 ,u1=0,1,2while u1 <=4*10**6:

if u1 %2==0:s=s+u1

u0 ,u1=u1 ,u0+u1print (s)



On a stocké dans des variables u0 et u1 deux termes consécutifs de la suite.

SOLUTION 1.10.

On trouve 104743 au moyen du programme suivant :

N,i=1,3while N <10001:

c,j=0,2while j**2 <=i:

if i%j==0:c=c+1

j=j+1if c==0:

N=N+1i=i+1

print (i -1)

Voici un exemple de programme non trivial qu’il est indispensable d’accompagner d’un commentaire.On utilise une variable N pour compter le nombre de nombres premiers au moyen d’un boucle while.À chaque itération, on compte (cf. la variable c) le nombre de diviseur(s) j de l’entier i vérifiant 4 Éj 2 É i . Cette méthode est valable car un nombre i n’est pas premier si et seulement si il admet undiviseur j tel que 4 É j 2 É i (considérer le plus petit diviseur > 1 de i pour le sens non trivial de cetteéquivalence).


INFO 1 Découverte de Pyzo et éléments de programmation en ...INFO 1 Découverte de Pyzo et...

Documents

Transcript of INFO 1 Découverte de Pyzo et éléments de programmation en ...INFO 1 Découverte de Pyzo et...