3. Introduction informelle à Python

Dans les exemples qui suivent, les entrées et sorties se distinguent par la présence ou l’absence d’invite (>>> et ) : pour reproduire les exemples, vous devez taper tout ce qui est après l’invite, au moment où celle-ci apparaît ; les lignes qui n’affichent pas d’invite sont les sorties de l’interpréteur. Notez qu’une invite secondaire affichée seule sur une ligne dans un exemple indique que vous devez entrer une ligne vide ; ceci est utilisé pour terminer une commande multi-lignes.

Beaucoup d’exemples de ce manuel, même ceux saisis à l’invite de l’interpréteur, incluent des commentaires. Les commentaires en Python commencent avec un caractère dièse, #, et s’étendent jusqu’à la fin de la ligne. Un commentaire peut apparaître au début d’une ligne ou à la suite d’un espace ou de code, mais pas à l’intérieur d’une chaîne de caractères littérale. Un caractère dièse à l’intérieur d’une chaîne de caractères est juste un caractère dièse. Comme les commentaires ne servent qu’à expliquer le code et ne sont pas interprétés par Python, ils peuvent être ignorés lorsque vous tapez les exemples.

Quelques exemples :

# this is the first comment
spam = 1  # and this is the second comment
          # ... and now a third!
text = "# This is not a comment because it's inside quotes."

3.1. Utiliser Python comme une calculatrice

Essayons quelques commandes Python simples. Démarrez l’interpréteur et attendez l’invite primaire, >>>. Ça ne devrait pas être long.

3.1.1. Les nombres

L’interpréteur agit comme une simple calculatrice : vous pouvez lui entrer une expression et il vous affiche la valeur. La syntaxe des expressions est simple : les opérateurs +, -, * et / fonctionnent comme dans la plupart des langages (par exemple, Pascal ou C) ; les parenthèses peuvent être utilisées pour faire des regroupements. Par exemple :

>>> 2 + 2
4
>>> 50 - 5*6
20
>>> (50 - 5.0*6) / 4
5.0
>>> 8 / 5.0
1.6

Les nombre entiers (comme 2, 4, 20) sont de type int, alors que les décimaux (comme 5.0, 1.6) sont de type float. Plus de détails sont données sur les types numériques plus loin dans ce tutoriel.

Le type donné en résultat d’une division (/) dépend de ses opérandes. Si les deux opérandes sont de type int, c’est une division entière qui est effectuée, et un int et donné. Si l’une des opérandes est un float, une division classique est effectuée et un float est renvoyé. L’opérateur // permet quand à lui d’effectuer des division entières peu importe ses opérandes. Le reste de la division est calculé grâce à l’opérateur %

>>> 17 / 3  # int / int -> int
5
>>> 17 / 3.0  # int / float -> float
5.666666666666667
>>> 17 // 3.0  # explicit floor division discards the fractional part
5.0
>>> 17 % 3  # the % operator returns the remainder of the division
2
>>> 5 * 3 + 2  # result * divisor + remainder
17

Avec Python il est possible de calculer des puissances avec l’opérateur ** [1]

>>> 5 ** 2  # 5 squared
25
>>> 2 ** 7  # 2 to the power of 7
128

Le signe égal (=) est utilisé pour affecter une valeur à une variable. Après cela, aucun résultat n’est affiché avant l’invite suivante :

>>> width = 20
>>> height = 5 * 9
>>> width * height
900

Si une variable n’est pas « définie » (si aucune valeur ne lui a été affecté), l’utiliser engendrera une erreur :

>>> n  # try to access an undefined variable
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
NameError: name 'n' is not defined

Il y a un support complet des nombres à virgule flottante ; les opérateurs avec des types d’opérandes mélangés convertissent l’opérande entier en virgule flottante :

>>> 3 * 3.75 / 1.5
7.5
>>> 7.0 / 2
3.5

En mode interactif, la dernière expression affichée est affectée à la variable _. Ce qui signifie que lorsque vous utilisez Python comme calculatrice, il est parfois plus simple de continuer des calculs, par exemple :

>>> tax = 12.5 / 100
>>> price = 100.50
>>> price * tax
12.5625
>>> price + _
113.0625
>>> round(_, 2)
113.06

Cette variable doit être considérée comme une variable en lecture seule par l’utilisateur. Ne lui affectez pas de valeur explicitement — vous créeriez ainsi une variable locale indépendante avec le même nom qui masquerait la variable native et son fonctionnement magique.

En plus des int et des float, il existe les Decimal et les Fraction. Python gère aussi les nombre complexes, en utilisant le suffixe j ou J pour indiquer la partie imaginaire (tel que: 3+5j).

3.1.2. Les chaînes de caractères

Au delà des nombres, Python peut aussi manipuler des chaînes de caractères, qui peuvent être exprimés de différentes manières. Elles peuvent être écrites entre guillemets simples ('...') ou entre guillemets ("...") sans distinction [2]. \ peut être utilisé pour protéger un guillemet :

>>> 'spam eggs'  # single quotes
'spam eggs'
>>> 'doesn\'t'  # use \' to escape the single quote...
"doesn't"
>>> "doesn't"  # ...or use double quotes instead
"doesn't"
>>> '"Yes," he said.'
'"Yes," he said.'
>>> "\"Yes,\" he said."
'"Yes," he said.'
>>> '"Isn\'t," she said.'
'"Isn\'t," she said.'

Dans une session interactive, la chaîne est affichée entre guillemets simples, et les caractères spéciaux sont protégés par des backslash. Bien que cela puisse paraître différent de ce qui à été donné (les guillements peuvent changer), les deux chaînes sont équivalentes. La chaîne est entre guillemets si elles contient un apostrophe mais aucun guillemet, sinon elle est entre guillemets simples. L’instruction print donne un affichage plus lisible : sans guillemets et en affichant les caractères protégés et spéciaux :

>>> '"Isn\'t," she said.'
'"Isn\'t," she said.'
>>> print '"Isn\'t," she said.'
"Isn't," she said.
>>> s = 'First line.\nSecond line.'  # \n means newline
>>> s  # without print, \n is included in the output
'First line.\nSecond line.'
>>> print s  # with print, \n produces a new line
First line.
Second line.

Pour éviter que les caractères précédées d’un \ ne soient interprétés comme étant spéciaux, utilisez les chaînes brutes (raw strings) en préfixant la chaîne d’un r

>>> print 'C:\some\name'  # here \n means newline!
C:\some
ame
>>> print r'C:\some\name'  # note the r before the quote
C:\some\name

Les chaînes de caractères peuvent s’étendre sur plusieurs lignes. On peut utiliser les triples guillemets, simples ou doubles: '''...''' ou """...""". Les retours à la ligne sont automatiquement inclus, mais on peut l’en empêcher en ajoutant \ à la fin de la ligne. L’exemple suivant :

print """\
Usage: thingy [OPTIONS]
     -h                        Display this usage message
     -H hostname               Hostname to connect to
"""

produit l’affichage suivant (notez que le premier retour à la ligne n’est pas inclus) :

Usage: thingy [OPTIONS]
     -h                        Display this usage message
     -H hostname               Hostname to connect to

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

>>> # 3 times 'un', followed by 'ium'
>>> 3 * 'un' + 'ium'
'unununium'

Plusieurs chaînes de caractères, écrites littéralement (c’est à dire entre guillemets), côte à côte, sont automatiquement concaténées.

>>> 'Py' 'thon'
'Python'

Cela ne fonctionne cependant qu’avec les chaînes littérales, pas les variables ni les expressions :

>>> prefix = 'Py'
>>> prefix 'thon'  # can't concatenate a variable and a string literal
  ...
SyntaxError: invalid syntax
>>> ('un' * 3) 'ium'
  ...
SyntaxError: invalid syntax

Pour concaténer des variables, ou des variables avec des chaînes littérales, utilisez l’opérateur +:

>>> prefix + 'thon'
'Python'

Cette fonctionnalité est surtout intéressante pour couper des chaînes trop longues :

>>> text = ('Put several strings within parentheses '
...         'to have them joined together.')
>>> text
'Put several strings within parentheses to have them joined together.'

Les chaînes de caractères peuvent être indexées (accéder aux caractères par leur position), le premiercaractère d’une chaîne est à la position 0. Il n’existe pas de type distinct pour les caractères, un caractère est simplement une chaîne de longueur 1

>>> word = 'Python'
>>> word[0]  # character in position 0
'P'
>>> word[5]  # character in position 5
'n'

Les indices peuvent également être négatifs, pour effectuer un décompte en partant de la droite. Par exemple :

>>> word[-1]  # last character
'n'
>>> word[-2]  # second-last character
'o'
>>> word[-6]
'P'

Notez que puisque -0 égal 0, les indices négatifs commencent par -1.

En plus de l’indexation, le découpage (slicing) est géré. L’indexation est utilisée pour obtenir les caractères individuellement, alors que le découpage permet d’obtenir une sous-chaîne.

>>> word[0:2]  # characters from position 0 (included) to 2 (excluded)
'Py'
>>> word[2:5]  # characters from position 2 (included) to 5 (excluded)
'tho'

Notez que le début est toujours inclus et la fin toujours exclue. Cela assure que s[:i] + s[i:] est toujours égal à s

>>> word[:2] + word[2:]
'Python'
>>> word[:4] + word[4:]
'Python'

Les indices par tranches ont des valeurs par défaut utiles ; le premier indice lorsqu’il est omis équivaut à zéro, le second à la taille de la chaîne de caractères :

>>> word[:2]   # character from the beginning to position 2 (excluded)
'Py'
>>> word[4:]   # characters from position 4 (included) to the end
'on'
>>> word[-2:]  # characters from the second-last (included) to the end
'on'

Une façon de mémoriser la façon dont les tranches fonctionnent est de penser que les indices pointent entre les caractères, le côté gauche du premier caractère ayant la position 0. Le côté droit du dernier caractère d’une chaîne de n caractères a alors pour indice n, par exemple :

 +---+---+---+---+---+---+
 | P | y | t | h | o | n |
 +---+---+---+---+---+---+
 0   1   2   3   4   5   6
-6  -5  -4  -3  -2  -1

La première ligne de nombres donne la position des indices 0…6 dans la chaîne ; la deuxième ligne donne l’indice négatif correspondant. La tranche de i à j est constituée de tous les caractères situés entre les bords libellés i et j, respectivement.

Pour des indices non négatifs, la longueur d’une tranche est la différence entre ces indices, si les deux sont entre les bornes. Par exemple, la longue de word[1:3] est 2.

Utiliser un indice trop grand générera une erreur :

>>> word[42]  # the word only has 6 characters
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
IndexError: string index out of range

Cependant, les indices hors bornes sont gérés silencieusement lorsqu’ils sont utilisés dans des tranches :

>>> word[4:42]
'on'
>>> word[42:]
''

Les chaînes de caractères, en Python ne peuvent pas être modifiées, on dit quelles sont immutable. Affecter une nouvelle valeur à un indice dans une chaîne produit une erreur :

>>> word[0] = 'J'
  ...
TypeError: 'str' object does not support item assignment
>>> word[2:] = 'py'
  ...
TypeError: 'str' object does not support item assignment

Si vous avez besoin d’une chaîne différente, vous devez en créer une autre :

>>> 'J' + word[1:]
'Jython'
>>> word[:2] + 'py'
'Pypy'

La fonction native len() renvoie la longueur d’une chaîne :

>>> s = 'supercalifragilisticexpialidocious'
>>> len(s)
34

Voir aussi

Sequence Types — str, unicode, list, tuple, bytearray, buffer, xrange
Les chaînes de caractères, et les chaînes Unicode décrites dans la prochaine section, sont des exemples de types de séquences, et supportent donc les opérations classiques prises en charge par ces types.
Méthodes de chaînes de caractères
Aussi bien les chaînes de caractères que les chaînes Unicode supportent un large éventail de méthodes de transformations basiques et de recherche.
Syntaxe de formatage de chaîne
Informations sur le formatage des chaînes avec la méthode str.format().
String Formatting Operations
Les anciennes opérations de formatage appelées lorsque les chaînes de caractères et les chaînes Unicode sont les opérandes placés à gauche de l’opérateur % sont décrites plus en détail ici.

3.1.3. Chaînes Unicode

À partir de Python 2.0, un nouveau type permettant de stocker du texte est mis à la disposition du programmeur : le type Unicode. Il peut être utilisé pour stocker et manipuler des données Unicode (voir http://www.unicode.org/) et s’intègre très bien avec les types de chaînes de caractères existant, en fournissant une conversion automatique lorsque c’est nécessaire.

Unicode a l’avantage de fournir une valeur ordinale pour chaque caractère d’un script utilisé aussi bien dans d’anciens textes que dans des textes modernes. Auparavant, il n’y avait que 256 valeurs ordinales possibles pour chaque caractère. Chaque texte était typiquement associé à une page de codes qui associait une valeur ordinale à chaque caractère. Ceci conduisait à une grande confusion, notamment pour tout ce qui touchait à l’internationalisation (souvent écrite i18n'i' + 18 caractères + 'n') des logiciels. Unicode résout ces problèmes en définissant une page de code unique pour tous les scripts.

Créer des chaînes Unicode en Python est aussi simple que de créer des chaînes de caractères normales

>>> u'Hello World !'
u'Hello World !'

Le petit 'u' qui précède l’apostrophe indique que l’on veut créer une chaîne Unicode. Si vous voulez intégrer des caractères spéciaux dans la chaîne, vous pouvez le faire en utilisant l’encodage Python d’échappement des caractères Unicode. Comme dans cet exemple

>>> u'Hello\u0020World !'
u'Hello World !'

La séquence d’échappement \u0020 indique d’insérer le caractère Unicode de valeur ordinale 0x0020 (un espace) à la position indiquée.

Les autres caractères sont interprétés en utilisant leurs valeurs ordinales respectives directement comme des ordinaux Unicode. Si vous avez des chaînes littérales dans l’encodage standard Latin-1 utilisé dans de nombreux pays occidentaux, vous trouverez pratique que les 256 premiers caractères Unicode soient les mêmes que ceux de l’encodage Latin-1.

Pour les experts, il existe également un mode « brut » identique à celui disponible pour les chaînes de caractères. Vous devez préfixer la première apostrophe avec “ur” pour que Python utilise l’encodage Unicode-Brut. Il n’appliquera la conversion \uXXXX de l’exemple ci-dessous que s’il y a un nombre impair d’antislashs devant le petit “u”

>>> ur'Hello\u0020World !'
u'Hello World !'
>>> ur'Hello\\u0020World !'
u'Hello\\\\u0020World !'

Le mode brut est le plus utile lorsque vous devez saisir de nombreux antislashs, comme il peut être nécessaire de le faire dans des expressions rationnelles.

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

La primitive unicode() donne accès à tous les codecs (COdeurs et DECodeurs) enregistrés. Certains des encodages les plus connus pris en charge par ces codecs sont Latin-1, ASCII, UTF-8 et UTF-16. Les deux derniers sont des encodages à longueur variable qui stockent chaque caractère Unicode dans un ou plusieurs octets. L’encodage par défaut est normalement défini en ASCII, qui gère les caractères de valeur ordinale 0 à 127 et rejette tous les autres caractères avec une erreur. Quand une chaîne Unicode est imprimée, écrite dans un fichier ou convertie avec la fonction str(), une conversion s’effectue en utilisant cet encodage par défaut

>>> u"abc"
u'abc'
>>> str(u"abc")
'abc'
>>> u"äöü"
u'\xe4\xf6\xfc'
>>> str(u"äöü")
Traceback (most recent call last):
  File "<stdin>", line 1, in ?
UnicodeEncodeError: 'ascii' codec can't encode characters in position 0-2: ordinal not in range(128)

Pour convertir une chaîne Unicode en une chaîne encodée sur 8 bits en utilisant un encodage spécifique, les objets Unicode fournissent une méthode encode() qui prend pour argument le nom de l’encodage. Les noms d’encodages en minuscules sont préférés

>>> u"äöü".encode('utf-8')
'\xc3\xa4\xc3\xb6\xc3\xbc'

Si vous avez une donnée dans un encodage spécifique et voulez générer la chaîne Unicode correspondante, vous pouvez utiliser la fonction unicode() en fournissant le nom de l’encodage comme second argument

>>> unicode('\xc3\xa4\xc3\xb6\xc3\xbc', 'utf-8')
u'\xe4\xf6\xfc'

3.1.4. Les listes

Python connaît différents types de données combinés, utilisés pour regrouper plusieurs valeurs. La plus souple est la liste, qui peut être écrite comme une suite de valeurs (éléments) séparés par des virgules placée entre crochets. Les éléments d’une liste ne sont pas obligatoirement tous du même type, bien qu’à l’usage ce soit souvent le cas.

>>> squares = [1, 4, 9, 16, 25]
>>> squares
[1, 4, 9, 16, 25]

Comme les chaînes de caractères (et toute autre types de sequence), les listes peuvent être indicées et découpées :

>>> squares[0]  # indexing returns the item
1
>>> squares[-1]
25
>>> squares[-3:]  # slicing returns a new list
[9, 16, 25]

Toutes les opérations par tranches renvoient une nouvelle liste contenant les éléments demandés. Ce qui signifie que l’opération suivante renvoie une copie superficielle de la liste :

>>> squares[:]
[1, 4, 9, 16, 25]

Les listes gèrent aussi les opérations comme la concaténation :

>>> squares + [36, 49, 64, 81, 100]
[1, 4, 9, 16, 25, 36, 49, 64, 81, 100]

Mais à la différence des chaînes qui sont immuables, les listes sont mutables : il est possible de changer leur contenu :

>>> cubes = [1, 8, 27, 65, 125]  # something's wrong here
>>> 4 ** 3  # the cube of 4 is 64, not 65!
64
>>> cubes[3] = 64  # replace the wrong value
>>> cubes
[1, 8, 27, 64, 125]

Il est aussi possible d’ajouter de nouveaux éléments à la fin d’une liste avec la méthode append(). (Les méthodes seront abordées plus tard)

>>> cubes.append(216)  # add the cube of 6
>>> cubes.append(7 ** 3)  # and the cube of 7
>>> cubes
[1, 8, 27, 64, 125, 216, 343]

Des affectations de tranches sont également possibles, ce qui peut même modifier la taille de la liste ou la vider complètement :

>>> letters = ['a', 'b', 'c', 'd', 'e', 'f', 'g']
>>> letters
['a', 'b', 'c', 'd', 'e', 'f', 'g']
>>> # replace some values
>>> letters[2:5] = ['C', 'D', 'E']
>>> letters
['a', 'b', 'C', 'D', 'E', 'f', 'g']
>>> # now remove them
>>> letters[2:5] = []
>>> letters
['a', 'b', 'f', 'g']
>>> # clear the list by replacing all the elements with an empty list
>>> letters[:] = []
>>> letters
[]

La primitive len() s’applique aussi aux listes :

>>> letters = ['a', 'b', 'c', 'd']
>>> len(letters)
4

Il est possible d’imbriquer des listes (de créer des listes contenant d’autres listes), par exemple :

>>> a = ['a', 'b', 'c']
>>> n = [1, 2, 3]
>>> x = [a, n]
>>> x
[['a', 'b', 'c'], [1, 2, 3]]
>>> x[0]
['a', 'b', 'c']
>>> x[0][1]
'b'

3.2. Premiers pas vers la programmation

Bien entendu, on peut utiliser Python pour des tâches plus compliquées que d’additionner deux et deux. Par exemple, on peut écrire une sous-séquence initiale de la suite de Fibonacci comme ceci :

>>> # Fibonacci series:
... # the sum of two elements defines the next
... a, b = 0, 1
>>> while b < 10:
...     print b
...     a, b = b, a+b
...
1
1
2
3
5
8

Cet exemple introduit plusieurs nouvelles fonctionnalités.

  • La première ligne contient une affectation multiple : les variables a et b se voient affecter simultanément leurs nouvelles valeurs 0 et 1. Cette méthode est encore utilisée à la dernière ligne, pour démontrer que les expressions sur la partie droite de l’affectation sont toutes évaluées avant que les affectations ne soient effectuées. Ces expressions en partie droite sont toujours évaluées de la gauche vers la droite.

  • La boucle while s’exécute tant que la condition (ici : b < 10) reste vraie. En Python, comme en C, tout entier différent de zéro est vrai et zéro est faux. La condition peut aussi être une chaîne de caractères, une liste, ou en fait toute séquence ; une séquence avec une valeur non nulle est vraie, une séquence vide est fausse. Le test utilisé dans l’exemple est une simple comparaison. Les opérateurs de comparaison standards sont écrits comme en C : < (inférieur), > (supérieur), == (égal), <= (inférieur ou égal), >= (supérieur ou égal) et != (non égal).

  • Le corps de la boucle est indenté : l’indentation est la méthode utilisée par Python pour regrouper des instructions. En mode interactif, vous devez saisir une tabulation ou des espaces pour chaque ligne indentée. En pratique, vous aurez intérêt à utiliser un éditeur de texte pour les saisies plus compliquées ; tous les éditeurs de texte dignes de ce nom disposent d’une fonction d’auto-indentation. Lorsqu’une expression composée est saisie en mode interactif, elle doit être suivie d’une ligne vide pour indiquer qu’elle est terminée (car l’analyseur ne peut pas deviner que vous venez de saisir la dernière ligne). Notez bien que toutes les lignes à l’intérieur d’un bloc doivent être indentées au même niveau.

  • L’instruction print écrit la valeur de l’expression qui lui est fournie. Ce n’est pas la même chose que d’écrire l’expression que vous voulez écrire (comme nous l’avons fait dans l’exemple de la calculatrice), et diffère dans la façon dont elle gère les expressions et chaînes de caractères multiples. Les chaînes sont imprimées sans apostrophes et un espace est inséré entre les éléments de telle sorte que vous pouvez facilement formater les choses, comme ceci :

    >>> i = 256*256
    >>> print 'The value of i is', i
    The value of i is 65536
    

    Une virgule à la fin de l’instruction supprime le saut de ligne

    >>> 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 saut de ligne avant d’afficher l’invite suivante si la dernière ligne n’était pas complète.

Notes

[1]Puisque ** est prioritaire sur -, -3 ** 2 sera interprété -(3 ** 2) et vaudra donc -9. Pour éviter cela et obtenir 9, utilisez des parenthèses : (-3) ** 2.
[2]Contrairement à d’autres langages, les caractères spéciaux comme \n ont la même signification entre guillemets (« … ») ou guillemets simples (“…”). La seule différence est que dans une chaîne entre guillemets il n’est pas nécessaire de protéger les guillemets simples et vice-versa.