Sous-sections
3. 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ème commentaire
# ... et maintenant un troisième!
STRING = "# Ceci n'est pas un commentaire."
3.1 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.)
3.1.1 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 imaginaire. 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 "<stdin>", 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éé 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.'
Notez3.1 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ôte hôte auquel il faut se connecter
"""
produit l'affichage suivant:
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 + '>'
'<HelpAHelpAHelpAHelpAHelpA>'
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' # <- C'est ok
'chaine'
>>> string.strip('cha') + 'ine' # <- C'est ok
'chaine'
>>> string.strip('cha') 'ine' # <- Ca c'est faux
File "<stdin>", 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 "<stdin>", line 1, in ?
TypeError: object doesn't support item assignment
>>> mot[:-1] = 'Splat'
Traceback (innermost last):
File "<stdin>", 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ères
'He'
>>> mot[2:] # Tout sauf les deux premiers caractères
'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ère
'A'
>>> mot[-2] # L'avant dernier caractère
'p'
>>> mot[-2:] # Les deux derniers caractères
'pA'
>>> mot[:-2] # Tout sauf les deux derniers caractères
'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 "<stdin>", 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à où 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 modernes 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"äöü"
u'\344\366\374'
>>> str(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"äöü".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ère (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
1
2
3
5
8
Cet exemple introduit plusieurs fonctionnalités nouvelles.
Notes
- ...Notez3.1
- NDT : Ce paragraphe absent de l'édition originale a été
ajouté par Daniel Calvelo Aros à l'intention des utilisateurs de
Python francophones.
See About this document... for information on suggesting changes.
|