Cours Python

Tutoriel d’introduction au langage de programmation Python


Télécharger Tutoriel d’introduction au langage de programmation Python

★★★★★★★★★★3.5 étoiles sur 5 basé sur 1 votes.
Votez ce document:

Télécharger aussi :


Support d’introduction au langage de programmation Python...

Une Introduction Informelle à Python

Dans les exemples suivants, la saisie et l’affichage seront distingués par la présence ou l’absence d’invites (‘>>> ’ et ‘... ’) : pour reproduire l’exemple, vous devez taper tout ce qui suit l’invite, quand celle-ci apparaît ; les lignes qui ne commencent pas par une invite correspondent à l’affichage effectué par l’interpréteur. Notez qu’une invite secondaire seule sur une ligne signifie que vous devez taper une ligne vide ; ceci marque la fin des commandes sur plusieurs lignes.

De nombreux exemples de ce manuel, même ceux qui sont saisis à l’invite interactive, contiennent des commentaires. Les commentaires en Python commencent par un caractère dièse, ‘#’, et continuent jusqu’à la fin de la ligne physique. Un commentaire peut se trouver au début d’une ligne derrière un espace ou du code, mais pas à l’intérieur d’une chaîne de caractères litérale. Un caractère dièse à l’intérieur d’une chaîne est juste un caractère dièse.

Quelques exemples :

# voici le premier commentaire

SPAM = 1 # et voici le deuxi`eme commentaire

# ... et maintenant un troisi`eme!

STRING = "# Ceci n’est pas un commentaire."

Utiliser Python comme Calculatrice

Essayons quelques commandes Python simples.  Lancez l’interpréteur et attendez l’apparition du prompt principal, ‘>>> ’. (Ç a ne devrait pas être très long.)

Nombres

L’interpréteur fonctionne comme une simple calculatrice : vous pouvez y taper une expression et il va en afficher la valeur. La syntaxe des expression est naturelle : les opérateurs +, -, * et / marchent exactement comme dans la plupart des langages (par exemple Pascal ou C) ; les parenthèses peuvent être utilisées pour les regrouper. Par exemple :

 >>> 2+2

4

>>> # Ceci est un commentaire

... 2+2

4

>>> 2+2 # et un commentaire sur la même ligne que le code 4

>>> (50-5*6)/4 5

>>> # La division des entiers retourne l’entier immédiatement inférieur:

... 7/3 2

>>> 7/-3

-3

Comme en C, le signe égale (‘=’) est utilisé pour affecter une valeur à une variable. La valeur d’une affectation n’est pas affichée :

>>> largeur = 20

>>> hauteur = 5*9

>>> largeur * hauteur 900

Une valeur peut être affectée à plusieurs variables simultanément :

>>> x = y = z = 0 # Mettre à zéro x, y et z

>>> x 0

>>> y 0

>>> z 0

Il y a un support complet des nombres à virgule flottante ; les opérateurs en présence de types d’opérandes mélangés convertissent les opérandes entiers en virgule flottante :

>>> 4 * 2.5 / 3.3

3.0303030303030303

>>> 7.0 / 2

3.5

>>> 1j * 1J (-1+0j)

>>> 1j * complex(0,1) (-1+0j)

>>> 3+1j*3 (3+3j)

>>> (3+1j)*3 (9+3j)

>>> (1+2j)/(1+1j) (1.5+0.5j)

Les nombres complexes sont toujours représentés comme deux nombres en virgule flottante, les parties réelle et ima- ginaire. Pour extraire ces parties d’un nombre complexe z, utilisez z.real et z.imag.

>>> a=1.5+0.5j

>>> a.real 1.5

>>> a.imag 0.5

Les fonctions de conversion en virgule flottante et en entier (float(), int() et long()) ne marchent pas pour les nombres complexes — il n’y a pas une façon correcte et unique de convertir un nombre complexe en un nombre réel. Utilisez abs(z) pour obtenir sa norme (en flottant) ou z.real pour sa partie réelle.

>>> a=1.5+0.5j

>>> float(a)

Traceback (innermost last): File "", line 1, in ?

TypeError: can’t convert complex to float; use e.g. abs(z)

>>> a.real 1.5

>>> abs(a) 1.5811388300841898

En mode interactif, la dernière expression affichée est affectée à  la variable    . Quand vous voulez utiliser Python comme calculatrice, c’est plus pratique pour continuer les calculs, par exemple :

>>> tva = 17.5 / 100

>>> prix = 3.50

>>> prix * tva 0.6125

>>> prix + _ 4.1125

>>> round(_, 2)

4.11

Cette  variable doit être utilisée en  lecture seule  par l’utilisateur. Ne lui  affectez pas une valeur de façon explicite

— vous auriez alors crée´ une variable locale indépendante, avec le même nom, masquant la variable intégrée et son comportement magique.

3.1.2 Chaînes de Caractères

En plus des nombres, Python peut aussi manipuler des chaînes, qui peuvent être exprimées de différentes façons. Elles peuvent être incluses entre simples quotes (apostrophes) ou doubles quotes (guillemets) :

>>> ’spam eggs’ ’spam eggs’

>>> ’n\’est-ce pas’ "n’est-ce pas"

>>> "n’est-ce pas" "n’est-ce pas"

>>> ’"Oui," dit-il.’

’"Oui," dit-il.’

>>> "\"Oui,\" dit-il."

’"Oui," dit-il.’

>>> ’"N\’est-ce pas," repondit-elle.’ ’"N\’est-ce pas," repondit-elle.’

Notez1  que les chaînes admettent ou non les caractères accentués en mode intéractif suivant votre plate-forme. Si les commandes sont lues depuis un fichier, la situation est légèrement différente : en général vous pourrez, mais les caractères accentués risquent d’être interprétés différemment si vous transférez vos fichiers entre des plate-formes différentes. Pour ces questions de portabilité, les identificateurs en Python sont limités au code ASCII  7 bits. Vous ne pourrez pas (en mode intéractif ou pas) utiliser des lettres accentuées dans les noms de variables, fonctions, modules, classes, etc.

Les textes dans les chaînes peuvent se poursuivre sur plusieurs lignes de plusieurs façons. Les retours chariot peuvent être préfixés avec un antislash, par ex. :

salut = "Ceci est une chaîne plutot longue contenant\n\ plusieurs lignes de texte excatement comme on le ferait en C.\n\

Notez que les blancs au début de la ligne sont\ significatifs.\n"

print salut ce qui s’afficherait de la façon suivante :

Ceci est une chaîne plutot longue contenant plusieurs lignes de texte excatement comme on le ferait en C. Notez que les blancs au début de la ligne sont significatifs.

Ou bien, les chaînes peuvent être entourées par un couple de triple-quotes correspondantes : """ ou ’’’. Les fins de lignes n’ont pas besoin d’être préfixées lorsqu’on utilise les triple-quotes, mais elles seront incluses dans la chaîne.

print """

Usage: trucmuche [OPTIONS]

-h Affiche cette notice d’usage

-H hˆote hˆote auquel il faut se connecter

"""

produit l’affichage suivant :



1 NDT : Ce paragraphe absent de l’édition originale a été ajouté par Daniel Calvelo Aros à l’intention des utilisateurs de Python francophones.

Usage: trucmuche [OPTIONS]

-h Affiche cette notice d’usage

-H hôte hôte auquel il faut se connecter

L’interpréteur affiche  le  résultat  des  opérations sur  les  chaînes  de  la  même  façon  qu’à  la  saisie  :  entre  quotes, et avec quotes et autres caractères bizarres préfixés par un antislash, pour afficher leur valeur exacte. La chaîne sera délimitée par des doubles quotes si elle contient une simple quote et aucune double quote, sinon, elle sera délimitée par des simples quotes. (L’instruction print, décrite plus loin, peut être utilisée pour écrire des chaînes sans quotes ni caractères préfixés.)

Les chaînes peuvent être concaténées (accolées) avec l’opérateur +, et répétées avec * :

>>> word = ’Help’ + ’A’

>>> word ’HelpA’

>>> ’<’ + word*5 + ’>’

’’

Deux chaînes de texte côte à côte sont automatiquement concaténées ; la première ligne ci-dessus aurait pu être écrite ‘mot = ’Help’’A’’ ; ceci fonctionne seulement avec deux chaînes de texte, pas avec des expressions quelconques de type chaîne.

>>> import string

>>> ’cha’ ’ine’ #

’chaine’  

>>> string.strip(’cha’) + ’ine’ #

’chaine’  

>>> string.strip(’cha’) ’ine’ #

File "", line 1 string.strip(’cha’) ’ine’

SyntaxError: invalid syntax

Les chaînes peuvent être décomposées (indexées) ; comme en C, le premier caractère d’une chaîne est en position (index) 0. Il n’y a pas de type caractère spécifique ; un caractère est simplement une chaîne de taille un. Comme en Icon, les sous-chaînes peuvent être spécifiées avec la notation de découpage (slice) : deux indices séparés par deux- points.

>>> mot[4] ’A’

>>> mot[0:2] ’He’

>>> mot[2:4]

’lp’

A la différence des chaînes de caractères en C, les chaînes Python ne peuvent être modifiées. Faire une affectation à l’emplacement d’un indice dans la chaîne aboutit à une erreur :

>>> mot[0] = ’x’

Traceback (innermost last): File "", line 1, in ?

TypeError: object doesn’t support item assignment

>>> mot[:-1] = ’Splat’ Traceback (innermost last):

File "", line 1, in ?

TypeError: object doesn’t support slice assignment

Cependant, il est facile et efficace de créer une nouvelle chaîne avec un contenu combiné :

>>> ’x’ + mot[1:]

’xelpA’

>>> ’Splat’ + mot[-1:] ’SplatA’

Les indices de découpage ont des valeurs par défaut utiles ; un premier index non-défini prend pour valeur par défaut zéro, un second index omis prend pour valeur par défaut la taille de la chaîne qu’on est en train de découper.

>>> mot[:2] # Les deux premiers caract`eres ’He’

>>> mot[2:] # Tout sauf les deux premiers caract`eres ’lpA’

Voici un invariant utile des opérations de découpage : s[ :i] + s[i :] égale s.

>>> mot[:2] + mot[2:] ’HelpA’

>>> mot[:3] + mot[3:] ’HelpA’

Les indices de découpage erronés sont gérés de façon élégante : un index qui est trop grand est remplacé par la taille de la chaîne, un index de fin inférieur à l’indice de début retourne une chaîne vide.

>>> mot[1:100]

’elpA’

>>> mot[10:] ’’

>>> mot[2:1] ’’

Les indices peuvent être des nombres négatifs, pour compter à partir de la droite. Par exemple :

 >>> mot[-1] # Le dernier caract`ere ’A’

>>> mot[-2] # L’avant dernier caract`ere ’p’

>>> mot[-2:] # Les deux derniers caract`eres ’pA’

>>> mot[:-2] # Tout sauf les deux derniers caract`eres ’Hel’

Mais notez que -0 est vraiment la même chose que 0, donc ça ne compte pas à partir de la droite !

>>> mot[-0] # (puisque -0 égale 0) ’H’

Les indices de découpage négatifs hors limites sont tronqués, mais n’essayez pas ceci avec des indices d’accès à des éléments uniques (sans découpage) :

>>> mot[-100:]

’HelpA’

>>> mot[-10] # erreur Traceback (innermost last):

File "", line 1

IndexError: string index out of range

La meilleure façon de se rappeler comment marchent les découpages est de penser aux indices comme pointant entre les caractères, avec le bord gauche du premier caractère numéroté 0. Alors le bord droit du dernier caractère d’une chaîne de n caractères porte l’index n, par exemple :

+---+---+---+---+---+

| H | e | l | p | A |

+---+---+---+---+---+ 0 1 2 3 4 5

-5 -4 -3 -2 -1

La première ligne de nombres donne la position des indices 0...5 dans la chaîne ; la seconde ligne donne les indice négatifs correspondants. Le découpage de i à  j consiste en tous les caractères entre les extrémités étiquetées i et j, respectivement.

Pour les indices non négatifs, la longueur d’une tranche est la différence entre ses indices, si les deux sont à l’intérieur des limites, par ex., la longueur de mot[1 :3] est 2.

La fonction intégrée len() retourne la longueur d’une chaîne :

>>> s = ’supercalifragilisticexpialidocious’

>>> len(s) 34

3.1.3 Chaînes Unicode

A partir de Python 2.0, un nouveau type de données destiné à stocker du texte est disponible pour les programmeurs : l’objet Unicode. Il peut être utilisé pour stocker et manipuler des données Unicode (voir http ://www.unicode.org) et s’intègre bien avec les objets chaînes en fournissant des conversions automatiques là ou` c’est nécessaire.

Unicode offre l’avantage de fournir un numéro pour chaque caractère de chaque écriture utilisée dans les textes mo- dernes et anciens. Auparavant, il n’y avait que 256 numéros possibles pour les caractères d’écriture et les textes étaient donc typiquement associés à une page de codes qui réalisait l’association entre le numéros et les caractères d’écriture. Ceci conduisait à  beaucoup de confusion, spécialement en ce qui concerne l’internationalisation (écrite d’habitude comme ‘i18n’ — ‘i’ + caractères 18 + ‘n’) des logiciels. Unicode résout ces problèmes en définissant une page de codes pour toutes les écritures.

Créer des chaînes Unicode en Python est exactement aussi simple que de créer des chaînes normales :

>>> u’Bonjour !’ u’Bonjour !’

Le  ‘u’  minuscule devant les  guillemets indique  qu’on souhaite  créer  une  chaîne  Unicode.  Si  vous  désirez  placer des caractères spéciaux dans la chaîne, vous pouvez le faire en utilisant l’encodage Python Echappement-Unicode. L’exemple suivant montre comment faire :

>>> u’Salut\\u0020tout le monde !’ u’Salut tout le monde !’

La séquence d’échappement

u0020 indique qu’il faut insérer le caractère Unicode dont le numéro HEX est 0x0020 (le caractère espace) à l’endroit indiqué.



Les autres caractères sont interprétés en utilisant leurs valeurs numériques respectives directement comme des numéros Unicode. Comme les 256 premiers Unicode sont les mêmes que les encodages standard Latin-1 utilisés dans la plupart des pays occidentaux, le processus de saisie de l’Unicode est grandement simplifié.

Pour les experts, il y a aussi un mode brut exactement comme pour les chaînes normales. Vous devez insérer au début de la chaîne un petit ’r’ pour que Python utilise l’encodage Echappement-Brut-Escape. Il n’appliquera la conversion uXXXX ci-dessus que s’il y a un nombre impair d’antislash avant le petit ’u’.

>>> ur’Salut\u0020tout le monde !’ u’Salut tout le monde !’

>>> ur’Salut\\u0020tout le monde !’ u’Salut\\\\u0020tout le monde !’

Le mode brut est extrèmement utile lorsqu’il s’agit de saisir de nombreux antislash, par exemple dans les expressions rationnelles.

En dehors de ces encodages standards, Python fournit tout un ensemble d’autres moyens de créer des chaînes Unicode sur la base d’un encodage connu.

La fonction unicode() intégrée fournit un accès à tous les codecs (COdeurs et DECodeurs) Unicode enregistrés. Certains des encodages les mieux connus que ces codecs peuvent convertir sont Latin-1, ASCII, UTF-8 et UTF-16. Les deux derniers sont des encodages à longueur variable qui permettent de stocker des caractères Unicode avec 8 ou 16 bits. Python utilise UTF-8 comme encodage par défaut. On s’en apperçoit lorsqu’on imprime des chaînes Unicode ou lorsqu’on les écrit dans des fichiers.

>>> u"¨a¨o¨u" u’\344\366\374’

>>> str(u"¨a¨o¨u") ’\303\244\303\266\303\274’

Si vous avez des données dans un encodage spécifique et souhaitez produire une chaîne Unicode correspondante, vous pouvez utiliser la fonction unicode() intégrée avec le nom de l’encodage comme second argument.

>>> unicode(’\303\244\303\266\303\274’,’UTF-8’) u’\344\366\374’

Pour convertir à nouveau la chaîne Unicode vers une chaîne en utilisant l’encodage original, les objets fournissent une méthode encode().

>>> u"¨a¨o¨u".encode(’UTF-8’) ’\303\244\303\266\303\274’

3.1.4 Listes

Python connaît un grand nombre de types de données composites, utilisées pour regrouper un ensemble de valeurs. La plus riche en possibilités est la liste, qui peut être écrite comme une liste de valeurs (éléments) entre crochets et séparés par des virgules. Les éléments d’une liste n’ont pas nécessairement le même type.

>>> a = [’spam’, ’eggs’, 100, 1234]

>>> a

[’spam’, ’eggs’, 100, 1234]

Comme les indices des chaînes, les indices des listes commencent à 0, et les listes peuvent être découpées, concaténées, et ainsi de suite :

>>> a[0]

’spam’

>>> a[3] 1234

>>> a[-2] 100

>>> a[1:-1]

[’eggs’, 100]

>>> a[:2] + [’bacon’, 2*2]

[’spam’, ’eggs’, ’bacon’, 4]

>>> 3*a[:3] + [’Boe!’]

[’spam’, ’eggs’, 100, ’spam’, ’eggs’, 100, ’spam’, ’eggs’, 100, ’Boe!’]

A la différence des chaînes, qui sont non-modifiables, il est possible de changer les éléments individuels d’une liste :

 >>> a

[’spam’, ’eggs’, 100, 1234]

>>> a[2] = a[2] + 23

>>> a

[’spam’, ’eggs’, 123, 1234]

L’affectation dans des tranches est aussi possible, et ceci peut même changer la taille de la liste :

>>> # Remplacer certains éléments:

... a[0:2] = [1, 12]

>>> a

[1, 12, 123, 1234]

>>> # En enlever certains:

... a[0:2] = []

>>>  a [123, 1234]

>>> # En insérer

... a[1:1] = [’bletch’, ’xyzzy’]

>>> a

[123, ’bletch’, ’xyzzy’, 1234]

>>> a[:0] = a # Ins`ere (une copie de) soi-même au début

>>> a

[123, ’bletch’, ’xyzzy’, 1234, 123, ’bletch’, ’xyzzy’, 1234]

La fonction intégrée len() s’applique aussi aux listes :

>>> len(a) 8

Il est possible d’emboîter des listes (créer des listes contenant d’autres listes), par exemple :

>>> q = [2, 3]

>>> p = [1, q, 4]

>>> len(p) 3

>>> p[1] [2, 3]

>>> p[1][0] 2

>>> p[1].append(’xtra’) # See section 5.1

>>> p

[1, [2, 3, ’xtra’], 4]

>>> q

[2, 3, ’xtra’]

Notez que dans l’exemple précédent, p[1] et q se réfèrent réellement au même objet ! Nous reviendrons plus tard sur la sémantique des objets.

 3.2 Premiers Pas Vers la Programmation

Bien sûr, nous pouvons utiliser Python pour des tâches plus compliquées que d’ajouter deux et deux. Par exemple, nous pouvons écrire une sous-séquence de la suite de Fibonacci de la façon suivante :

>>> # Suite de Fibonacci

... # La somme de deux éléments définit le suivant

... a, b = 0, 1

>>> while b < 10:

... print b

... a, b = b, a+b

... 1

Cet exemple introduit plusieurs fonctionnalités nouvelles.

– La première ligne contient une affectation multiple : les variables a et b prennent simultanément les nouvelles valeurs 0 et 1. Sur la dernière ligne l’affectation multiple est utilisée à  nouveau, montrant que les expressions en partie droite sont d’abord toutes évaluées avant qu’aucune affectation ne se fasse.

– La boucle while s’exécute tant que la condition (ici : b < 10) reste vraie. En Python, comme en C, toute valeur entière différente de zéro est vraie ; zéro est faux. La condition pourrait aussi être une chaîne ou une valeur de type  liste,  en  fait n’importe quelle séquence ;  n’importe quoi avec une longueur  différente de  zéro est  vrai, les séquences vides correspondent à faux. Le test utilisé dans l’exemple est une simple comparaison. Les opérateurs de comparaison standard sont écrits de la même façon qu’en C : <, >, ==, <=, >= et !=.

– Le corps de la boucle est indenté : l’indentation est le moyen par lequel Python regroupe les instructions. Python ne fournit pas (encore) une fonction d’édition de ligne intelligente, donc vous devez insérer une tabulation ou un espace pour chaque ligne indentée. En pratique vous préparerez les saisies plus compliquées avec un éditeur de texte ; la plupart des éditeurs de texte ont une fonction d’auto-indentation. Lorsqu’une instruction composée est entrée en mode interactif, elle doit être suivie d’une ligne vide pour indiquer qu’elle est terminée (car l’interpréteur ne peut pas deviner si vous avez tapé la dernière ligne).

– L’instruction print écrit la valeur de la ou des expressions qui lui sont données. Elle diffère de la simple écriture de l’expression (comme tout-à-l ’heure dans les exemples de la calculatrice) dans la mesure ou` elle accepte plusieurs expressions et chaînes. Les chaînes sont imprimées sans quotes, et un espace est inséré entre les éléments, ce qui vous permet de les afficher dans un format plus sympathique, comme ceci :



>>> i = 256*256

>>> print ’La valeur de i est’, i La valeur de i est 65536

Une virgule finale empêche le retour chariot après l’affichage :

>>> a, b = 0, 1

>>> while b < 1000:

... print b,

... a, b = b, a+b

...

1 1 2 3 5 8 13 21 34 55 89 144 233 377 610 987

Notez que l’interpréteur insère un retour chariot avant d’imprimer le prompt suivant si la ligne n’a pas été complétée.

 CHAPITRE QUATRE

D’Autres Outils de Contrôle d’Exécution

A part l’instruction while que l’on vient de découvrir, Python comprend les instructions de contrôle d’exécution habituelles connues dans d’autres langages, avec quelques adaptations.

4.1 Instructions if

Peut-être l’instruction la plus connue est-elle l’instruction if. Par exemple :

>>> if x < 0:

... x = 0

... print ’Négatif changé en zéro’

... elif x == 0:

... print ’Zéro’

... elif x == 1:

... print ’Un seul’

... else:

... print ’Plus’

...

Il peut y avoir aucune ou plusieurs sections elif, et la section else est optionnelle. Le mot-clé ‘elif’ est une abréviation de ‘else if’, et est utile pour éviter une indentation excessive. Une séquence if . . . elif . . . elif . . . est un substitut pour les instructions switch ou case qu’on trouve dans d’autres langages.

4.2 Instructions for

L’instruction for en Python diffère un petit peu de ce que vous avez pu utiliser en C ou en Pascal. Au lieu d’itérer toujours dans une progression arithmétique de nombres (comme en Pascal), ou de laisser l’utilisateur complètement libre  dans les  tests  et  les  pas  d’itération  (comme en  C),  l’instruction  for de Python  itère  parmi les  éléments  de n’importe quelle séquence (par ex., une liste ou une chaîne), dans l’ordre ou`  ils apparaissent dans la séquence. Par exemple (aucun jeu de mots volontaire) :

>>> # Mesurer quelques chaînes:

... a = [’chat’, ’fenêtre’, ’défenestrer’]

>>> for x in a:

... print x, len(x)

...

chat 4

fenêtre 7

défenestrer 11

Il n’est pas prudent de modifier la séquence sur laquelle on itère dans la boucle (ceci peut seulement arriver pour les types de séquences modifiables, par exemple, les listes). Si vous avez besoin de modifier la liste sur laquelle vous itérez, par exemple, pour dupliquer des éléments sélectionnés, vous devez itérer sur une copie. La notation de découpage rend ceci particulièrement pratique :

>>> for x in a[:]: # fait une copie de la liste enti`ere par découpage

... if len(x) > 8: a.insert(0, x)

...

>>> a

[’défenestrer’, ’chat’, ’fenêtre’, ’défenestrer’]

4.3 La Fonction range()

Si vous avez besoin d’itérer sur une séquence de nombres, la fonction intégrée range() vient à point. Elle génère des listes contenant des progressions arithmétiques, par ex. :

>>> range(10)

[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]

Le nombre de fin qui lui est passé  n’est jamais dans la liste générée ; range(10) génère une liste de 10 valeurs, exactement les indices des éléments d’une séquence de longueur 10. Il est possible de faire commencer l’intervalle à un autre nombre, ou de spécifier un incrément différent (même négatif) :

>>> range(5, 10)

[5, 6, 7, 8, 9]

>>> range(0, 10, 3)

[0, 3, 6, 9]

>>> range(-10, -100, -30)

[-10, -40, -70]

Pour parcourir les indices d’une séquence, combinez range() et len() comme ci-dessous :

>>> a = [’Marie’, ’avait’, ’un’, ’petit’, ’mouton’]

>>> for i in range(len(a)):

... print i, a[i]

...

0 Marie

1 avait

2 un

3 petit

4 mouton

4.4 Les Instructions break et continue, et les Clauses else dans les Boucles

L’instruction break, comme en C, sort de la plus petite boucle for ou while englobante. L’instruction continue, également empruntée au C, continue sur la prochaine itération de la boucle.

Les instructions de boucle ont une clause else ; elle est exécutée lorsque la boucle se termine par épuisement de la liste (avec for) ou quand la condition devient fausse (avec while), mais pas quand la boucle est interrompue par une instruction break. Ceci est expliqué dans la boucle suivante, qui recherche des nombres premiers :

>>> for n in range(2, 10):

... for x in range(2, n):

... if n % x == 0:

... print n, ’égale’, x, ’*’, n/x

... break

... else:

... print n, ’est un nombre premier’

...

2 est un nombre premier

3 est un nombre premier

4 égale 2 * 2

5 est un nombre premier

6 égale 2 * 3

7 est un nombre premier

8 égale 2 * 4

9 égale 3 * 3

4.5 L’Instruction pass

L’instruction pass ne fait rien. Elle peut être utilisée lorsqu’une instruction est requise syntaxiquement mais que le programme ne nécessite aucune action. Par exemple :

>>> while 1:

... pass # Attente active d’une interruption au clavier

...



237