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 croisillon, "#", 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 croisillon à l’intérieur
d’une chaîne de caractères est juste un caractère croisillon. 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. Utilisation de 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". Vous
trouvez plus de détails 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

En 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. Dans ce cas, 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ée), son utilisation produit 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

Les nombres à virgule flottante sont tout à fait admis (NdT : Python
utilise le point *.* comme séparateur entre la partie entière et la
partie décimale des nombres, c’est la convention anglo-saxonne) ; les
opérateurs avec des opérandes de types différents convertissent
l’opérande de type entier en type 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 "_". Ainsi, lorsque vous utilisez Python comme calculatrice,
cela vous permet de continuer des calculs facilement, 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 nombres complexes, en utilisant le
suffixe "j" ou "J" pour indiquer la partie imaginaire (tel que
"3+5j").


3.1.2. Chaînes de caractères
----------------------------

En plus des nombres, Python sait aussi manipuler des chaînes de
caractères, qui peuvent être exprimées 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," they said.'
   '"Yes," they said.'
   >>> "\"Yes,\" they said."
   '"Yes," they said.'
   >>> '"Isn\'t," they said.'
   '"Isn\'t," they 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," they said.'
   '"Isn\'t," they said.'
   >>> print '"Isn\'t," they said.'
   "Isn't," they 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.

Si vous ne voulez pas que les caractères précédés d’un "\" soient
interprétés comme étant spéciaux, utilisez les *chaînes brutes* (*raw
strings* en anglais) 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.
Utilisez alors des triples guillemets, simples ou doubles :
"'''...'''" ou """"..."""". Les retours à la ligne sont
automatiquement inclus, mais on peut l’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'

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.'

Cela ne fonctionne cependant qu’avec les chaînes littérales, pas avec
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'

Les chaînes de caractères peuvent être indexées (i.e. on peut accéder
aux caractères par leur position), le premier caractère d’une chaîne
étant à 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, on compte alors en
partant de la droite. Par exemple :

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

Notez que, comme "-0" égale "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 valeurs par défaut des indices de tranches ont une utilité ; le
premier indice vaut zéro par défaut (i.e. lorsqu’il est omis), le
deuxième correspond par défaut à 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'

Pour mémoriser la façon dont les tranches fonctionnent, vous pouvez
imaginer 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 longueur de "word[1:3]" est 2.

Utiliser un indice trop grand produit 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 qu’elles sont *immuable*s. 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
nouvelle :

   >>> '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. 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, placée entre crochets, de valeurs
(éléments) séparés par des virgules. 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 type 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. Cela 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 *immuable*s, les listes sont
*muables*s : il est possible de modifier 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 sont 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 (i.e. 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 le début
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" est interprété
    "-(3 ** 2)" et vaut 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
    entre 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.
