OldGentooWiki:Python, les bases

De Gentoo-Quebec.

Python, les bases

Introduction

Ce wiki n'est pas un tutoriel sur la programmation en Python. Son but est de présenter les éléments de base du langage de script Python afin que vous en sachiez suffisamment pour l'utiliser dans différents domaines d'application. Quels sont ces domaines ?

• La programmation système
• Les interfaces graphiques (GUI)
• Les scripts pour Internet
• Composants à intégrer dans des programmes écrits en C et C++
• La programmation de bases de données
• Le prototypage
• Programmation scientifique
• Programmation d'images et de jeux

Python est somme toute facile d'apprentissage et d'emploi.

Comment exécuter Python

Voici quelques façons d'exécuter Python :

• En mode intéractif
• En mode ligne de commande
• Scripts exécutables
• IDE

Exécution intéractive

Python s'exécute en mode intéractif dans un terminal. Il suffit donc d'ouvrir un terminal et de taper la commande qui lance le shell Python.

$ python

Le shell se présente ainsi :

gfontaine@aramis1 ~ $ python
Python 2.6.2 (r262:71600, Nov 13 2009, 07:44:15) 
[GCC 4.3.4] on linux2
Type "help", "copyright", "credits" or "license" for more information.
>>>

Dans ce shell, vous entrez l'énoncé Python à exécuter et le résultat s'affiche immédiatement.

>>> print "Bonjour le monde !"
Bonjour le monde !

Pour terminer l'exécution du mode intéractif de Python, tapez exit() sur la ligne de l'invite de commande du shell.

>>> exit()
gfontaine@aramis1 ~ $

Note !
Un avantage non dédaignable du mode intéractif est la possibilité de tester l'exécution du code avant d'en faire un script.

Exécution en ligne de commande

L'exécution en ligne de commande ne diffère pas beaucoup de la technique d'exécution en mode intéractif. Le tout se réalise en lançant la commande python dans un terminal à la différence qu'on lui passe un argument. Cet argument est le nom du fichier qui contient le code à exécuter.

Utilisez votre éditeur de texte pour créer le fichier. Par exemple, saisissez ce texte dans le fichier.

print "Bonjour le monde !"

Sauvegardez le fichier en n'oubliant pas de lui attribuer l'extension py. En nous basant sur l'exemple précédent, le fichier peut fort bien se nommer bonjour.py. Ouvrez un terminal dans le dossier où vous avez enregistré le fichier et exécutez-le.

gfontaine@aramis1 ~/python $ python bonjour.py
Bonjour le monde !
gfontaine@aramis1 ~/python $

Via un script exécutable

Un script exécutable est tout bonnement un fichier contenant du code Python et qui a l'attribut d'exécution. Le fichier contient comme premier énoncé une ligne de commentaire instruisant le système d'exploitation d'en exécuter le contenu à l'aide du module python. Le module est le même que celui utilisé pour exécuter Python en ligne de commande.

Créez un fichier à l'aide de votre éditeur de texte. Saisissez ces lignes dans le fichier.

#!/usr/bin/python
print "Bonjour ! Comment allez-vous ?"

La ligne de commentaire indique au système d'exploitation où trouver le module d'exécution. Il est habituellement dans le répertoire /usr/bin. Dans l'incertitude, vous pouvez toujours interroger le système par l'intermédiaire de la commande whereis python.

Sauvegardez le fichier. Pour les besoins de ce tutoriel, le fichier a été enregistré sous le nom de demo-1. Placez-vous dans le répertoire où le fichier a été sauvegardé et rendez-le exécutable.

$ chmod +x demo-1

Une bonne habitude à prendre est de placer vos fichiers exécutables dans le répertoire /usr/local/bin. Autrement mettez votre répertoire personnel de scripts Python dans la variable $PATH. Vous devez copier, commande cp, ou déplacer, commande mv, vos fichiers de script avec les privilèges du super utilisateur (root). Si vous optez pour ajouter votre fichier personnel de scripts dans la variable $PATH, procédez selon l'exemple donné ci-après.

$ export PATH=$PATH:$HOME/python

Dans l'exemple, la valeur de la variable $HOME incluant le nom du répertoire où les scripts sont créés, est concaténée à la valeur courante de la variable $PATH. Il ne vous reste plus qu'à lancer le script.

gfontaine@aramis1 ~ $ demo-1
Bonjour ! Comment allez-vous ?
gfontaine@aramis1 ~ $

Environnement intégré de développement (IDE)

Il existe plusieurs outils d'environnement intégré de développement. Les présenter tous est hors du cadre de ce wiki. Geany a été retenu comme IDE de démonstration en raison de sa grande versatilité.

Le premier geste à poser est de lancer geany. Un document vide et sans titre est affiché. Vérifiez la configuration avant d'aller plus loin.

• Cliquez sur Document et cochez la case de renvoi à la ligne automatique;
• Dans Document, sélectionnez Définir le type de fichier ---> Langages de Script et cliquez sur Fichier source Python.

Pour les besoins de cette démonstration, insérez ces lignes dans le document sans titre :

#!/usr/bin/python
# coding=utf-8
 
import sys
 
print "Ceci est la démo 2. Ce script retourne le nom de la plate-forme du système :"
 
print sys.platform

Sauvegardez le script avec Fichier ---> Enregistrer sous. Nommez-le demo-2 sans l'extension py. Cliquez sur le bouton Enregistrer. L'étape suivante consiste à rendre le fichier exécutable. Cliquez sur Terminal dans le panneau inférieur de geany. Positionnez-vous dans le dossier où vous avez enregistré le script et exécutez la commande chmod.

$ chmod +x demo-2

Assurez-vous maintenant que le dossier du script est dans le chemin d'accès ($PATH) des fichiers exécutables (commandes). Vérifiez avec :

$ echo $PATH

Si le dossier des scripts n'y apparaît pas, ajoutez-le.

$ export PATH=$PATH:$HOME/pytnon

Dans l'exemple de la commande de concaténation, le dossier des scripts est dans le répertoire personnel de l'utilisateur ($HOME). Le dossier se nomme python.

Exécutez le script en appuyant sur la touche F5 ou via le menu Construire ---> Exécuter ou en tapant le nom du script à l'invite de commande dans la fenêtre du terminal ouverte dans le panneau inférieur de geany. Selon le contenu de l'exemple saisi précédemment, le résultat est le suivant.

Ceci est la démo 2. Ce script retourne le nom de la plate-forme du système :
linux2

Les objets et les opérations

Les objets de base sont :

1. Les nombres (Numbers)
2. Les chaînes (Strings)
3. Les listes (Lists)
4. Les dictionnaires (Dictionaries)
5. Les tuples (Tuples)
6. Les fichiers (Files)
7. Autres types

Il n'y a pas lieu de déclarer un type d'objet dans Python. La syntaxe utilisée détermine le type d'objet que vous créez et utilisez. Ainsi une expression entre accolades est du type Dictionaries alors que celle entre crochets est une liste. Python se souvient automatiquement du type de l'objet sans avoir à le déclarer. Par conséquent, vous ne pouvez pas exécuter une opération autre que celles prévues pour le type d'objet.

>>> # objets Numbers
...
>>> j = 1 
>>> k = 2 
>>> j + k 
3
>>> j * k
2
 
>>> # objets Strings
... 
>>> j = '1'
>>> k = '2'
>>> j + k
'12'
>>> j * k
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: can't multiply sequence by non-int of type 'str'

L'exemple de code montre dans un premier temps que les objets j et k sont utilisés en tant qu'objets numériques alors que dans un second temps ils sont définis comme des objets de type chaîne. L'usage de l'apostrophe pour délimiter la valeur de l'objet crée une chaîne. Sans les apostrophes, l'objet est un nombre puisque la valeur est numérique.

Le signe + et le signe = représentent des opérations permises. Le premier additionne ou concatène les valeurs selon le type d'objet et le second attribue une valeur à l'objet. Cependant le signe * qui correspond à une multiplication, devient une opération non permise sur des objets de type chaîne.

Information !
La durée de vie d'un type d'objet n'est pas permanent. Dès qu'une valeur est assignée à une variable, son type devient celui de la valeur. Dans l'exemple plus haut, la variable j est un entier numérique au départ et elle prend le type chaîne aussitôt qu'elle est initialisée avec une valeur incluse entre apostrophes.

Les nombres (Numbers)

Toutes les opérations mathématiques, arithmétiques, géométriques, scientifiques, physiques et numériques de toutes sortes reposent sur l'utilisation d'objets numériques, Numbers. Que vous vouliez développer une application pour automatiser votre bilan financier, pour ajouter un compteur du nombre de visites sur une page Web, pour calculer la distance entre deux points ou n'importe quelle autre application ayant recours à des calculs, les objets numériques seront présents. Voyons ces objets en action.

Création des objets

>>> a = 3
>>> b = 4

Opérations de base

>>> # addition
... a + 1
4
>>> # soustraction
... b - 3
1
>>> # multiplication
... a * b
12
>>> # division
... b / 2
2
>>> # modulus
... a % 2
1
>>> # élévation à la puissance
... b ** 2
16
>>> # conversions (mélange de types)
... 2 + 4.0
6.0
>>> 2.0 **b
16.0
>>> # hiérarchie des évaluations ((...) + ...)
... b / 2 + a
5
>>> # hiérarchie des évaluations (... / (... + ...))
... print b / (2.0 + a)
0.8

Affichage des formats numériques

L'affichage des nombres diffèrent selon la technique utilisée. Sans l'instruction print, en mode echo, tous les caractères formant un nombre à point flottant sont affichés alors qu'en mode print la valeur est arrondie.

>>> b / (2.0 + a)
0.80000000000000004
>>> print b / (2.0 + a)
0.8
>>> num = 1 / 3.0
>>> num
0.33333333333333331
>>> print num
0.333333333333
>>> "%e" % num
'3.333333e-01'
>>> "%2.2f" % num
'0.33'

Les deux derniers exemples relèvent de l'emploi de la mise en forme des chaînes (string foramtting). Ce type d'affichage est vu plus en détail dans la section sur les chaînes.

Les divisions

Attention !
Ceci est valable pour les versions antérieures à Python 3.0.

Pour éviter les erreurs lors des opérations de division, veuillez importer le module division. Par exemple, sans l'import de division, l'opération suivante retournera un résultat incomplet.

>>> 5 / 2
2

Par contre en chargeant le module division avant toutes opérations de division, les résultats seront réels.

>>> from __future__ import division
>>> 5 / 2
2.5
>>> 5 // 2
2

La deuxième forme de division arrondit le résultat.

Opérations sur bits

Bien que ce type d'opération ne soit pas commun dans un environnement de langage de haut niveau, il est quand même possible d'effectuer des opérations sur une chaîne numérique binaire (base 2). Un nombre binaire se compose de 0 et de 1. Prenons par exemple la chaîne numérique 0000. Telle quelle, elle vaut 0 en décimal. En changeant 0 pour 1 à la position extrême droite, elle vaut alors 1 en décimal. En déplaçant le 1 vers la gauche (0010), elle vaut 2 en décimal. En fait le 1 a une valeur de 2 élevée à la puissance correspondant à la position du 1 dans la chaîne. La position est calculée à partir de 0. La valeur décimale de la chaîne binaire est la somme de tous les 1.

>>> x = 1
>>> # 0001
... x << 0
1
>>> # 0010
... x << 1
2
>>> # 1000
... x << 3
8
>>> # 1000 + 0010 + 0001
... (x << 3) + (x << 1) + x
11

Entiers longs

Quand une valeur numérique se termine par la lettre L (majuscule ou minuscule), Python crée un objet numérique du type entier long. Un entier long peut avoir autant de chiffres que la mémoire peut en contenir. L'entier long créé par Python a une précision illimitée. Le caractère L est toutefois optionnel. Python convertit automatiquement un entier en entier long quand la valeur numérique déborde celle d'un entier normal, c'est à dire quand la précision dépasse 32 bits.

Les entiers longs sont des outils qui peuvent s'avérer très utiles dans certaines situations particulières, par exemple si vous avez à élever à 200 la puissance de 2.

>>> 2 ** 200
1606938044258990275541962092341162602522202993782792835301376L
>>>

La fonction mathématique des entiers longs consomme des ressources additionnelles car Python doit effectuer du travail supplémentaire pour en supporter l'étendue de la précision. Vous pourriez observer un ralentissement dans l'éxécution du programme.

Nombres complexes

Les nombres complexes se distinguent des autres types d'objets Python. Ils sont représentés par deux entités : des nombres en virgule flottante. Une de ces entités forme la partie du nombre réel alors que l'autre est la partie imaginaire.

La partie imaginaire du nombre est préfixée du caractère J (majuscule ou minuscule). Vous pouvez également écrire des nombres complexes ayant un nombre réel non zéro. Vous ajoutez les deux parties avec l'opérateur +.

>>> 1j * 1J
(-1+0j)
>>> 2 + 1j * 3
(2+3j)
>>> (2 + 1j) * 3
(6+3j)

Les nombres complexes permettent d'en extraire leurs parties en tant qu'attributs. Ils supportent les expressions mathématiques usuelles et il peuvent être traités par les outils du module cmath. Les nombres complexes jouent un rôle prépondérant dans les programmes orientés ingénierie.

Notations hexadécimale et octale

La sous-section sur les opérations sur bits montre comment exploiter des chaînes numériques à base binaire. Il est également possible de travailler avec des nombres à bases hexadécimal et octale. Une base hexadécimale comprend les valeurs entre 0 et F. Les valeurs entre 0 et 7 composent une base octale.

>>> # chaine octale
... 01, 010, 0100
(1, 8, 64)
>>> # chaîne hexadécimale
... 0x0, 0x10, 0xFF
(0, 16, 255)

On notera qu'une valeur hexadécimale est spécifiée en préfixant la chaîne avec 0x et qu'une valeur octale est préfixé par un 0. On peut réaliser une conversion en octal ou hexadécimal à partir d'une valeur décimale. Les fonctions oct et hex sont prévues à cet effet.

>>> # conversion de décimal en octal
... oct(64)
'0100'
>>> # conversion de décimal en hexadécimal
... hex(64)
'0x40'

La fonction eval vous permet de traiter une chaîne comme s'il s'agissait de code Python. Cela assume que vous faites confiance au contenu de la chaîne. En effet, il est possible de soumettre à Python une chaîne qui supprime des fichiers.

>>> eval('100'), eval('0100'), eval('0x40')
(100, 64, 64)

La fonction int convertit une chaîne de chiffres en un entier. Un paramètre optionnel permet d'en préciser la base, soit 8 pour octale et 16 pour hexadécimal.

>>> int ('0100'), int('0100', 8), int('0100', 16)
(100, 64, 256)

Vous remarquerez que int utilisée sans préciser la base convertit la chaîne en entier décimal. Finalement, vous pouvez convertir des entiers numériques en chaînes octale et hexadécimale grâce à une conversion exprimée via une chaîne.

>>> "%o %x" % (64, 64)
'100 40'
>>>

Attention !

Souvenez-vous toujours qu'un entier numérique décimal ne doit jamais commencer par 0. Dès que Python détecte un zéro en début de chaîne, il assume par défaut qu'il s'agit d'une valeur octale.

L'exception à cette règle est la fonction int qui réalise une conversion selon la base spécifiée (par défaut base décimale).

Outils numériques intégrés

Python offre plusieurs outils pour manipuler les objets numériques. Les uns se présentent comme des fonctions et d'autres sont des modules. Les fonctions sont intégrées au langage, par exemple int. Les modules sont vus comme des entités externes. Ils doivent être importés. Citons par exemple le module math.

Pour obtenir la liste des modules :

>>> help()
 
Welcome to Python 2.6!  This is the online help utility.
 
If this is your first time using Python, you should definitely check out
the tutorial on the Internet at http://docs.python.org/tutorial/.
 
Enter the name of any module, keyword, or topic to get help on writing
Python programs and using Python modules.  To quit this help utility and
return to the interpreter, just type "quit".
 
To get a list of available modules, keywords, or topics, type "modules",
"keywords", or "topics".  Each module also comes with a one-line summary
of what it does; to list the modules whose summaries contain a given word
such as "spam", type "modules spam".
 
help> modules

BaseHTTPServer      cairo               json                random
Bastion             calendar            keyword             re
CDROM               cgi                 lcms                readline
CGIHTTPServer       cgitb               lib2to3             repoman
ConfigParser        chunk               libxml2             repr
Cookie              cmath               libxml2mod          resource
DLFCN               cmd                 libxslt             rexec
DocXMLRPCServer     code                libxsltmod          rfc822
HTMLParser          codecs              linecache           rlcompleter
IN                  codegen             linuxaudiodev       robotparser
MimeWriter          codeop              locale              roman
Queue               collections         logging             rpm
SimpleHTTPServer    colorsys            macpath             runpy
SimpleXMLRPCServer  commands            macurl2path         sched
SocketServer        compileall          magic               select
StringIO            compiler            mailbox             sets
TYPES               contextlib          mailcap             setuptools
UserDict            cookielib           markupbase          sgmllib
UserList            copy                marshal             sha
UserString          copy_reg            math                shelve
_LWPCookieJar       cracklib            md5                 shlex
_MozillaCookieJar   crypt               mhlib               shutil
__builtin__         csv                 mimetools           signal
__future__          ctypes              mimetypes           site
_abcoll             curses              mimify              smtpd
_ast                cvstree             mirage              smtplib
_bc                 datetime            mmap                sndhdr
_bisect             dbhash              modulefinder        socket
_bsddb              dbm                 multifile           spwd
_bytesio            decimal             multiprocessing     sqlite3
_codecs             difflib             mutex               sre
_codecs_cn          dircache            netrc               sre_compile
_codecs_hk          dis                 new                 sre_constants
_codecs_iso2022     dispatch_conf       nis                 sre_parse
_codecs_jp          distutils           nntplib             ssl
_codecs_kr          dl                  ntpath              stat
_codecs_tw          doctest             nturl2path          statvfs
_collections        docutils            numbers             string
_cracklib           drv_libxml2         numpy               stringold
_csv                dsextras            opcode              stringprep
_ctypes             dumbdbm             operator            strop
_ctypes_test        dummy_thread        optparse            struct
_curses             dummy_threading     os                  subprocess
_curses_panel       easy_install        os2emxpath          sunau
_elementtree        eclass_cache        ossaudiodev         sunaudio
_emerge             email               output              symbol
_fileio             emergehelp          pango               symtable
_functools          encodings           pangocairo          sys
_gamin              errno               parser              syslog
_hashlib            exceptions          pdb                 tabnanny
_heapq              fcntl               pickle              tarfile
_hotshot            filecmp             pickletools         telnetlib
_json               fileinput           pipes               tempfile
_lcms               fnmatch             pkg_resources       termios
_locale             formatter           pkgutil             test
_lsprof             fpformat            platform            textwrap
_md5                fractions           plistlib            this
_multibytecodec     ftplib              popen2              thread
_multiprocessing    functools           poplib              threading
_random             future_builtins     portage             time
_sha                gamin               portage_checksum    timeit
_sha256             gc                  portage_compat_namespace toaiff
_sha512             gdbm                portage_const       token
_socket             genericpath         portage_data        tokenize
_sqlite3            getbinpkg           portage_debug       trace
_sre                getopt              portage_dep         traceback
_ssl                getpass             portage_exception   tty
_strptime           gettext             portage_exec        types
_struct             gio                 portage_gpg         unicodedata
_symtable           glib                portage_localization unittest
_testcapi           glob                portage_locks       urllib
_threading_local    gobject             portage_mail        urllib2
_warnings           grp                 portage_manifest    urlparse
_weakref            gsf                 portage_news        user
abc                 gtk                 portage_selinux     uu
aifc                gtkunixprint        portage_update      uuid
anydbm              gzip                portage_util        vte
array               hashlib             portage_versions    warnings
ast                 heapq               posix               wave
asynchat            hmac                posixfile           weakref
asyncore            hotshot             posixpath           webbrowser
atexit              htmlentitydefs      pprint              whichdb
atk                 htmllib             profile             wsgiref
audiodev            httplib             pstats              xcbgen
audioop             idlelib             psyco               xdrlib
base64              ihooks              pty                 xml
bdb                 imageop             pwd                 xmllib
binascii            imaplib             py_compile          xmlrpclib
binhex              imgfuncs            pyclbr              xmouse
bisect              imghdr              pydoc               xpak
bsddb               imp                 pydoc_topics        xpcom
bz2                 imputil             pyexo               xxsubtype
cPickle             inspect             pyexpat             zipfile
cProfile            io                  pygtk               zipimport
cStringIO           itertools           quopri              zlib

Notez la présence de __builtin__ dans la liste des modules. Les fonctions sont incluses dans ce module. Il n'est cependant pas nécessaire d'importer une fonction. Cependant si vous voulez utilisez les outils fournis avec le module math, vous devez l'importer.

 
>>> import math
>>> math.pi
3.1415926535897931
>>> math.sqrt(144)
12.0

Vous obtiendrez plus de détails sur les fonctions en consultant le manuel des librairies de Python.

Nombres décimaux

L'objet nombres décimaux permet de présenter des valeurs numériques comportant l'usage de décimales avec une plus grande précision. Il est ainsi possible de tronquer ou d'arrondir le nombre de décimales après le point.

>>> 0.1 + 0.1 + 0.1 - 0.3
5.5511151231257827e-17
>>> print 0.1 + 0.1 + 0.1 - 0.3
5.55111512313e-17
>>>

Regardons maintenant la différence lorsque la fonction Decimal est mise à profit.

>>> from decimal import Decimal
>>> Decimal('0.1') + Decimal('0.1') + Decimal('0.1') - Decimal('0.3')
Decimal('0.0')
>>>

Decimal est une sous-fonction de l'ensemble decimal. On utilise l'instruction from pour n'importer qu'un seul élément de l'ensemble. Voici maintenant comment préciser le nombre de décimales après le point.

>>> # Sans tronquer
>>> Decimal(1) / Decimal(6)
Decimal('0.1666666666666666666666666667')
>>> # Tronquage
>>> from decimal import getcontext
>>> getcontext().prec = 4
>>> Decimal(1) / Decimal(6)
Decimal('0.1667')

Sets

Les sets sont des objets qui regroupent un ensemble d'autres objets. Il est discutable de présenter l'objet set dans la section sur les objets numériques. Mais comme ils reconnaissent les opérations mathématiques, pourquoi ne pas survoler leur utilité de base.

Pour créer un set, il suffit d'appeler la fonction set pour passer une séquence de valeurs.

>>> x = set('abcde')
>>> y = set('bzyfx')
>>> x
set(['a', 'c', 'b', 'e', 'd'])

>>> # e appartient-il à x ?
... 'e' in x
True
>>> # différence... ce qui est dans x mais pas dans y
... x - y
set(['a', 'c', 'e', 'd'])
>>> # combinaison (union)
... x | y
set(['a', 'c', 'b', 'e', 'd', 'f', 'y', 'x', 'z'])
>>> # intersection
... x & y
set(['b'])

Ces opérations conviennent très bien à la manipulation de fichiers de données volumineux. Les intersections montrent les objets communs à deux sets alors que l'union combine tous les objets des deux sets. En voici un exemple plus pratique.

>>> ingenieurs = set(['Robert', 'Suzanne', 'Anne', 'Victor'])
>>> gerants = set(['Thomas', 'Suzanne'])
>>> # Qui sont ingénieurs et gérants ?
... ingenieurs & gerants
set(['Suzanne'])
>>> # Tous les gens de toutes les catégories
... ingenieurs | gerants
set(['Thomas', 'Robert', 'Suzanne', 'Anne', 'Victor'])
>>> # Ingénieurs qui ne sont pas des gérants
... ingenieurs - gerants
set(['Robert', 'Anne', 'Victor'])

Le manuel de référence des librairies fournit de plus amples détails sur les sets.

Les chaînes (Strings)

Les chaînes servent à stocker et à représenter de l'information textuelle. Une chaîne peut emmagasiner des symboles, des mots, le contenu d'un fichier chargé en mémoire, des adresses Internet et ainsi de suite.

Le traitement sur les chaînes s'effectue à l'aide d'opérations comme la concaténation, l'extraction et l'indexation. Python possède également des méthodes pour les tâches usuelles spécifiques aux chaînes et fournit des modules pour des tâches plus complexes.

Les chaînes sont plutôt faciles à utiliser. Il suffit de leur affecter une valeur en plaçant le contenu entre doubles ou simples apostrophes. La complexité, s'il en est une, réside dans la manière de les codifier. Les prochaines sections présentent brièvement les techniques de codification.

Simples et doubles apostrophes

L'usage des simples et des doubles apostrophes aboutit au même résultat.

>>> 'exemple 1', "exemple 2"
('exemple 1', 'exemple 2')

Ceci permet d'inclure dans une chaîne de caractères une simple apostrophe ou une double apostrophe sans avoir à utiliser un caractère d'échappement. Il faut évidemment insérer une simple apostrophe dans une chaîne délimitée par des doubles apostrophes et vice-versa.

>>> s1 = "Mary's hair is black."
>>> s1
"Mary's hair is black."
>>> print s1
Mary's hair is black.

Séquences d'échappement

Une séquence d'échappement s'exprime à l'aide de l'oblique inversée (backslash). L'usage de l'oblique inversée permet d'insérer dans une chaîne un caractère autrement difficile à taper au clavier. Par exemple \n a une valeur ASCII de 10 et correspond à un retour à nouvelle ligne (linefeed).

Voici quelques exemples d'utilisation des caractères de séquences d'échappement.

>>> s = 'a\nb\tc\vd'
>>> s
'a\nb\tc\x0bd'
>>> print s
a
b	c
         d
>>> # sans séquence d'échappement
>>> s = 'knight's'
  File "<stdin>", line 1
    s = 'knight's'
                ^
SyntaxError: invalid syntax
>>> # avec séquence d'échappement
>>> s = 'knight\'s'
>>> s
"knight's"
>>> print s
knight's
>>> lecteur = "C:\python\code"
>>> lecteur
'C:\\python\\code'
>>> print lecteur
C:\python\code
>>> lecteur = "C:\\python\\code"
>>> lecteur
'C:\\python\\code'
>>> print lecteur
C:\python\code

Chaînes brutes à la rescousse des séquences d'échappement

Tel que vu dans la section précédente, l'oblique inversée est de grande utilité quand il y a un besoin d'insérer un caractère spécial dans une chaîne. Hors ! Il arrive des situations où le caractère suivant l'oblique inversée ne doit pas être considéré comme un caractère spécial. Prenons cet exemple où le chemin d'accès (Windows) vers un fichier a cette valeur :

>>> mon_fichier = open('C:\nouveau\texte.txt', 'w')
>>> mon_fichier
<open file 'C:
ouveau	exte.txt', mode 'w' at 0x8ee7520>

Ceci ne fonctionne pas car Python traduit le n de nouveau comme un caractère de contrôle pour une nouvelle ligne et le t de texte pour un caractère de tabulation. Il faut donc utiliser le préfixe r (Raw Strings) pour annuler l'application du caractère de contrôle suivant une oblique inversée.

>>> mon_fichier = open(r'C:\nouveau\texte.txt', 'w')
>>> mon_fichier
<open file 'C:\nouveau\texte.txt', mode 'w' at 0x90082a0>

Une autre utilité de la chaîne brute qui soit non négligeable, devient apparente quand le module re est mis à contribution lors de recherches textuelles basées sur un gabarit (pattern) particulier.

Chaînes multilignes

Les chaînes multilignes sont délimitées par une séquence de trois apostrophes doubles ou simples. Elles se révèlent utiles lorsque l'on désire saisir du texte sur plusieurs lignes et que l'on souhaite que Python considère le tout comme une seule et même chaîne.

>>> bloc = """Il faut
... toujours regarder
... le côté positif
... des choses."""
>>> bloc
'Il faut\ntojours regarder\nle c\xc3\xb4t\xc3\xa9 positif\ndes choses.'

Notez que Python a généré un caractère de saut de ligne (\n) là où le texte change de ligne. Cette technique de chaînes multiples est également utilisée pour insérer des exemples de code dans les scripts Python et sert également à documenter le script.

On peut également recourir à cette technique pour isoler une partie du code qu'on en veut pas exécuter au cours des essais durant les phases de développement. Ce n'est pas ce qu'il y a de plus esthétique mais cela a un côté pratique acceptable.

Chaînes unicode

Ce type de chaîne n'est pas communément utilisé. Il sert avant tout à l'internationalisation des applications. Un programmeur y a recours quand il veut directement supporter les caractères européens de l'Est et asiatiques dans ses scripts.

Il y a plusieurs façons de codifier une chaîne unicode.

>>> # u ou U devant la chaîne
... u'test'
u'test'
>>> # combinaison de types
... 'ni' + u'spam'
u'nispam'
>>> # transformation de unicode à normal
... str(u'spam')
'spam'
>>> # transformation de normal à unicode
... unicode('spam')
u'spam'
>>> # caractères sur 1 octet
... u'ab\x20cd'
u'ab cd'
>>> # caractères sur 2 octets
... u'ab\u0020cd'
u'ab cd'
>>> # caractères sur 4 octets
>>> u'ab\U00000020cd'
u'ab cd'

Vous trouverez de plus amples informations sur les chaînes unicode dans le manuel de Python.

Les opérations sur les chaînes

En plus des opérations basiques telles la concaténation et la répétition, les chaînes peuvent être indexées, converties, changées, formatées, et analysées pour en extraire des sous-chaînes. Suivent quelques exemples d'opérations et manipulations sur des chaînes.

Opérations basiques

>>> # Longueur d'une chaîne
>>> len("Lorem")
5
>>> # Concaténation
... "Lorem" + " " + "Ipsum"
'Lorem Ipsum'
>>> # Répétition
... "-" * 20
'--------------------'
>>> # Reproduction d'une chaîne par itération (déplacement)
... texte = "Lorem Ipsum"
>>> for x in texte: print x,
... 
L o r e m   I p s u m
>>> # Recherche
... "l" in texte
False
>>> "L" in texte
True

Les opérations de concaténation et de répétition sont respectivement le fruit de l'utilisation des caractères + et * qui sont en fait des opérateurs de calcul. Python s'en accomode très bien autant sur des chaînes de caractères que sur des chaînes numériques. Python réagit positivement en fonction du contenu en autant que ce dernier soit du même type.

La boucle for assigne tour à tour à une variable chacun des éléments d'une chaîne et pour chaque occurence rencontrée, item de la chaîne, un ou plusieurs énoncés (ici print) sont exécutés.

Indexation et extraction

Les chaînes constituant un ensemble ordonné de caractères, on peut donc accéder une position précise dans une chaîne (indexing/indexation) et ainsi obtenir un nouvel objet (slicing/extraction). Voici quelques exemples pour illustrer le tout.

>>> chaîne = "Lorem Ipsum"
>>> # Indexation
... chaîne[0]
'L'
>>> chaîne[1]
'o'
>>> chaîne[-2]
'u'
>>> # Extraction
... chaîne[1:3]
'or'
>>> chaîne[1:]
'orem Ipsum'
>>> chaîne[:-1]
'Lorem Ipsu'

L'indexation retourne toujours le caractère à la position spécifiée entre crochets. La premier caractère d'une chaîne est en position 0 (zéro). L'extraction retourne une valeur comprise entre la position de départ et la position de fin -1. En d'autres mots le caractère situé à l'adresse de fin spécifiée n'est jamais retourné.

Une autre technique d'extraction se fait par itération en spécifiant un saut. Ce saut s'exprime par une troisième valeur.

>>> len(chaîne)
11
>>> chaîne[1:11:2]
'oe pu'
>>> chaîne[0:11:2]
'LrmIsm'
>>> chaîne[0:11:3]
'LeIu'
>>> chaîne[::-1]
'muspI meroL'

En spécifiant une valeur négative comme troisième valeur, on inverse la chaîne.

Les listes (Lists)

Les dictionnaires (Dictionaries)

Les tuples (Tuples)

Les fichiers (Files)

Autres types

Les énoncés et la syntaxe

Les fonctions

Les modules

Les classes

Les exceptions

Ressources additionnelles