(site sans réclame)
Python  –  Cont@ct  –  S'abonner  –  Forum / Questions

Introduction au langage Python - www.jchr.be

Le langage Python est un langage de programmation complet grâce aux nombreuses bibliothèques spécialisées, appelées modules. Utilisé professionnellement dans la recherche biomédicale et pour la gestion de Google, il est néanmoins idéal pour un apprentissage de la programmation. Orienté objet, on peut l'utiliser comme un bon vieux BASIC, moyennant quelques restrictions par rapport à ce dernier:

Le langage Python a été créé par Guido van Rossum, qui s'en est déclaré le «bienveillant dictateur à vie». Il est distribué sous une licence de type BSD depuis la version 2.1. Cela signifie que tout le monde peut l'utiliser librement, consulter le code-source et le modifier, redistribuer la version modifiée – sans obligation d'y joindre les sources – contrairement à la licence GPL où les sources modifiées doivent être disponibles pour toute nouvelle version distribuée.

Cette page fut commencée en mai 2002 comme manuel de références personnel. Elle prétend maintenant faciliter la prise en main du langage Python en GNU+Linux, d'autres UNIX, voire d'autres systèmes. Attention: cette page est remaniée au fil des versions, mais rien ne garantit que les corrections soient complètes.

Cette page inclut la plupart des modifications apportées par Python 3.

Autres pages

Quelques modules internes: système et fichiers, mathématiques, chaînes, bases de données simples, internet.

Modules externes: numpy (tableaux - math - random) - ECMA-48 (print at en couleur)

Recettes et exemples - TKinter (interface graphique)

1. Prise en main

1.1 Installation

Sur un système Unix normalement configuré, on a l'obligation d'avoir les droits de super-utilisateur ("root") pour installer une application. Installez Python (par défaut, version 2.6 pour Debian 6.0 Squeeze - février 2011), et éventuellement son éditeur graphique idle-python. En ligne de commande, on utilise sous Debian:

suEn mode super-utilisateur apt-get install python idle-python2.6

Sous SuSE, Mandrake et Fedora, vous devriez pouvoir utiliser une ligne de commande du type:

suEn mode super-utilisateur rpm -i python-2.5-19.6.i586.rpm

Une solution est également d'utiliser l'installateur graphique de ces distributions. Pour Debian, il existe aptitude et synaptic.

Python 3 est maintenant fourni avec les dernières versions des distributions GNU/Linux, dont Debian 6.0 Squeeze. Pour les versions antérieures, il faut récupérer un fichier Python...tar.bz2 dans la version désirée, le décompresser et compiler les sources. Il faut également que les sources ou les headers de votre noyau soient installés. Dans le répertoire décompressé intervient la séquence des commandes ./configure, make et suEn mode superutilisateur make install saisies dans une console. L'application se lance avec python3.

1.2 Le mode interactif

Ayant quitté le mode super-utilisateur (exit), python saisi dans une console affiche quelque chose qui ressemble à:

Python 2.6.6 (r266:84292, Dec 27 2010, 00:02:40) 
[GCC 4.4.5] on linux2
Type "help", "copyright", "credits" or "license" for more information.
>>>

Frappez 5+3, puis [Enter] ou [Return]:

>>> 5+3
8

Sous Unix, on quitte le mode interactif avec [Ctrl]-[d]

1.3 Lancement d'un script de Python

Un script est un fichier de programmation, rédigé avec un simple éditeur de texte. Supposons que le fichier script.pyse trouve dans le répertoire /home/dudule/python/ et contienne:

# commentaire: mon premier programme Python
print 5+3

À partir du mode interactif, frappez et saisissez:

>>> execfile ("/home/dudule/python/script.py")
8

1.4 Lancement d'un script autoexécutable

Vous pouvez rendre le fichier /home/dudule/python/script.py autoexécutable, à condition de savoir où se trouve l'application python. La commande whereis python renvoie (entre autres) une chaîne ressemblant à /usr/bin/python , un script autoexécutable devra commencer (toute première ligne) par

#! /usr/bin/python

Pour python 3 installé par vous-même, il faut préciser la version. En cas d'installation de la version 3.2:

#! /usr/bin/python3.2

Modifier ensuite les propriétés du script (il doit être exécutable au moins pour le propriétaire) par la commande:

chmod o+x /home/dudule/python/script.py

ou par un gestionnaire de fichiers (le plus souvent par un clic droit sur le fichier). Il est dès lors possible de le lancer par la ligne de commande:

/home/dudule/python/script.py

ou, dans le répertoire où se trouve le fichier:

./script.py

Note: une partition n'accepte pas le lancement d'exécutables (dont les scripts) si la ligne correspondante dans /etc/fstab comprend noexec dans la colonne <options>.

1.5 Lancement par le navigateur

Avec Gnome

Éditer le fichier suivant:

#! /bin/bash
gnome-terminal -e "python -Qnew $1"
  1. gnome-terminal est l'application "console"
  2. -e permet le lancement d'une application direstement dans la console
  3. python $1 lance python avec le script (représenté par $1)
  4. -Qnew permet l'utilisation de la division réelle (et non entière) sous python 2.x (voir 3.2 Opérateurs numériques)

Donner les droits d'exécution sur ce script (clic droit sur le fichier, Propriétés / Permissions)

Marquer les fichiers python:

  1. Clic droit sur un fichier terminant par .py
  2. Clic gauche sur Propriété / Ouvrir avec
  3. Clic gauche [+ Ajouter], puis Utiliser une commande personnalisée
  4. Introduire l'adresse du script ou le déterminer avec [Parcourir]

Attention à la priorité s'il y a plusieurs application sélectionnées. La première s'appelle avec un double clic gauche; une suivante avec le bouton droit de la souris, puis Ouvrir avec...

Avec KDE

  1. Dans konqueror, cliquer avec le bouton droit sur un fichier ayant l'extension .py
  2. Sélectionner dans le menu Édition / Modifier le type du fichier
  3. Cliquer sur Ajouter et sélectionner python parmi les "applications connues". Sinon, inscrire /usr/bin/python dans le champ éditable
  4. Veiller à ce que la case Lancer dans une console soit cochée
  5. Cliquer Appliquer.

Attention à la priorité s'il y a plusieurs application sélectionnées. La première s'appelle avec un double clic gauche; une suivante avec le bouton droit de la souris, puis Ouvrir avec...

Une manière plus sophistiquée requiert de sauvegarder le script suivant, par exemple sous le nom py:

#! /bin/bash
konsole -e python $1
  1. Donnez-lui les droits d'exécution avec chmod 740 votrescript.py (ou modifiez ses propriétés avec konqueror)
  2. Sélectionnez un fichier se terminant par .py dans konqueror et choisissez Modifier le type de fichier (menu Édition)
  3. Cliquez sur le bouton Ajouter puis sur l'icone représentante un répertoire pour préciser l'endroit où vous avez sauvegardé le script py, puis Appliquer.

Pour une utilisation de la division réelle, voir ci-dessus Avec Gnome

Notes:

Il se pourrait que la console appelée lorsque vous double-cliquez sur un fichier .py se referme le script terminé. Il faudra penser à terminer ces scripts Python par raw_input() ou une de ses sophistications:

out=""
while out!="q":  # tant que le caractere n'est pas 'q'
  out=raw_input("[q] + [Enter] pour quitter! ")

C'est à éviter pour la mise au point d'un script en Python, étant donné que toute interruption de programme se traduit par la fermeture de la console, ce qui ne permet pas de lire les messages d'erreur.

1.6 Les éditeurs

idle-python2.5 est un éditeur écrit en Python qui devrait faciliter votre prise en main sous interface La première fenêtre est le mode interactif. On peut ouvrir une fenêtre de programmation, écrire et lancer un script à partir de cette fenêtre, après l'avoir sauvegardé. Pour Windows, c'est probablement une meilleure solution que blocnote qui ne proposant pas la coloration syntaxique, mais il en existe d'autres.

Sous idle, [F1] affiche une page d'aide, par exemple http://www.python.org/doc/current/.

Il existe aussi spe , Stani's python editor, qui installe 88Mo (non testé), et bien sûr vim et Emacs.

Il est également possible d'utiliser les éditeurs des systèmes graphiques, comme gedit (Gnome) et kwrite (KDE), qui disposent de la coloration syntaxique pour la plupart des langages de programmation, plus facile à paramétrer sous kwrite que sous gedit, ce dernier ne proposant que cinq modèles peu engageants mais qu'il est possible d'aménager.

1.7 La compilation

Il est possible de compiler un fichier-texte en un fichier-bytecode. Ce nouveau fichier ne sera pas directement exécutable par le système, mais sera interprété plus rapidement par l'application python, qui devra donc toujours être installée. Il conservera sa compatibilité avec les autres plateformes, mais la compatibilité entre les différentes versions n'est pas garantie. Attention: le fichier .pyc généré par la compilation ne sera pas éditable: ne vous débarrassez pas de l'original .py.

Il y a plusieurs manières de compiler un fichier .py pour créer le fichier .pyc:

Il est à noter que cette compilation n'accélère que l'interprétation du fichier, mais pas les fonctions de python utilisées. Un fichier Python constitué d'une seule fonction qui exécuterait un remplacement de caractères sur un fichier texte de 100Mo ne serait en rien accéléré par la compilation.

2. Structure

2.1 Syntaxe

Le langage Python a une syntaxe simple et lisible:

#! /usr/bin/python

def factorielle(arg):
  if arg==0:
    return 1
  return arg*factorielle(arg-1)

print factorielle(43), factorielle(7)

Plutôt que les { } utilisées en C, PHP..., on utilise des indentations pour marquer la structure. La définition de la fonction factorielle() s'arrête au moment où le script se réaligne à la colonne 0. De la même manière, la condition imbriquée dans la fonction est également la cause d'une indentation (ici limitée à return 1). Les lignes vides sont facultatives et servent à mieux structurer le script.

# ce qui se trouve à droite d'un dièse est un commentaire (sauf dans une chaîne de caractères)
, sert à séparer des données qui se suivent (liste, dictionnaires, paramètres de fonctions...)
; sépare deux instructions se suivant sur la même ligne, inutile en fin de ligne
\ permet à une instruction de déborder sur la ligne suivante. Ce signe n'est pas nécessaire si '(', '[' ou '{' n'est refermé qu'à une ligne suivante.
: à la fin de la première ligne d'une condition, boucle ou fonction, annonce le bloc d'instructions alignées dans une même indentation.

A priori, les instructions se déroulent selon l'ordre dans lequel elles ont été écrites. Il peut être intéressant de ne permettre l'exécution d'une portion de code que sous condition, de la répéter dans des boucles ou d'écrire des séquences que l'on appellera à un endroit ou l'autre du programme: les fonctions, comme dans l'exemple vu plus haut.

2.2 Variables et assignations

Cette section est générale pour les différents types de variables: numériques, chaînes, tuples, listes, dictionnaires et ensembles.

Une variable contient une valeur ou plusieurs valeurs qui peu(ven)t être redéfinie(s) autant de fois que l'on veut, d'où le nom. Un ensemble de lettres minuscules ou majuscules, non accentuées (pas de é, à, ç, ø, Ã...), de chiffres et de tirets bas "_", mais ne commençant pas par un chiffre, peut représenter une variable:

var, V, Valse43bis, _36 sont des noms de variables corrects
ni et Ni sont des noms de deux variables différentes, comme var_bis et varbis
_ contient le résultat de la dernière évaluation en mode interactif

En Python 3, les noms de variable (et de fonction) peuvent contenir des lettres accentuées. Cette nouvelle utilisation n'est pas conseillée dans le cadre d'un projet international, car même si l'UTF8 permet un codage universel de ces caractères, tous les claviers n'ont pas les mêmes facilités à produire toutes les lettres accentuées. Pour vous en convaincre, tentez š, æ, å... avec un clavier azerty...

Certains mots sont réservés à python et ne peuvent donc pas être utilisés comme nom de variable ou de fonction: and - assert - break - class - continue - def - del - elif - else - except - exec - finally - for - from - global - if - import - is - lambda - not - or - pass - raise - return - try - while - yield

À partir de Python 2.6, with et as sont également réservés. Ils le sont également en Python 2.5 en cas de spécification from __future__ import with_statement en début de fichier (première ligne ne commençant pas par '#').

En Python 3, print et exec ne sont plus des mots réservés, car remplacés par les fonctions print() et exec().

del Qio ou del(Qio) supprime la variable Qio, de quelque type que ce soit.

Le première utilisation d'une variable doit être une assignation, qui peut se faire de plusieurs manières: A=13, for i in [2,3,5]: ou def fonct(i=0,j,k):

Attention! Les variables ne sont pas nécessairement disponibles dans toutes les parties d'un script: voir fonctions.

Il est possible d'effectuer une permutations des valeur de variables, qui peuvent être de types différents (numériques, chaînes, listes...):

>>> x=4; y="trois"; z=["a","b"]
>>> x, y, z = y, z, x
>>> x, y, z
('trois', ['a', 'b'], 4)

type() permet de tester le type d'une variable. Par exemple, type([]) renvoie <type 'list'>. Attention: pour tester une variable, on ne peut utiliser la chaine "<type 'list'>", mais type([]):

>>> li=["spam",3]
>>> type(li)==type([])
True
>>> type(li)=="<type 'list'>"
False

a=intern(var) inscrit la variable parmi les variables du système, ce qui la rend plus rapidement mobilisable

En Python 3, la fonction intern() est supprimée.

id(var) donne l'identifiant de la variable var. Pour une variable locale, il est possible qu'il existe plusieurs identifiants en cas de récursion.

hash(var) donne l'identifiant de la donnée contenue dans la variable var; deux variables de même valeur partagent la même valeur "hash".

Dictionnaires du système

vars() est un dictionnaire des {variables: valeurs}
globals() renvoie un dictionnaire des variables globales uniquement
locals() renvoie un dictionnaire des variables locales uniquement

2.3 Booléens et comparaison

Il existe deux valeurs booléennes (du logicien George Booles): True et False (Capitale + minuscules!). Elles résultent souvent de l'évaluation d'une relation d'égalité ou d'inégalité et sont souvent utilisées dans les structures conditionnelle (if, while, for).

>>> print 1>2, 3==3
False True

Comme les langages C et dérivés, Python fait une différence entre l'opérateur d'assignation a=2, qui attribue une valeur à une variable, et l'opérateur de comparaison a==3, qui sert à tester l'égalité:

>>> a=2    # la valeur 2 est assignée à la variable a
>>> a==3   # comparaison de la variable a (qui vaut deux) et la valeur 3
False

L'opérateur "est différent de" est noté != (l'ancien <> est tombé en désuétude: à éviter)

>>> a=2; a!=3
True

En Python3, l'opérateur de test d'inégalité <> est supprimé

< plus petit que
<= plus petit ou égal à
> plus grand que
>= plus grand ou égal à

True et False valent respectivement 1 et 0 dans les opérations arithmétiques:

>>> a=3; print(a==3)*5+True
6

De ce fait, True peut valider une chaîne par multiplication; False l'annihiler:

>>> nb=3; print nb,"oeuf"+"s"*(nb>1), " et spam"*False
3 oeufs

Dans un test de structure conditionnelle, 0, None, "", [] et {} peuvent représenter la valeur False; toute valeur différente de 0 ou None, toute collection non vide (chaîne, tuple, liste, dictionnaire ou ensemble peuvent représenter la valeur True (attention: '0' et [0] ne sont pas vides).

a is b est vrai si les valeurs ET les types sont égaux (voir variables numériques). De plus, id(a) équivaut à ce moment à id(b).

>>> a=123; b=123+0j; a==b; a is b
True
False

a is not b est vrai si les valeurs OU les types sont inégaux: int(1) is not float(1) est vrai

Les opérateurs de comparaison évaluent également les chaînes de caractères, <, <=, >, >= selon l'ordre alphabétique de leur code ASCII: ' ' < '0' < '1'... < 'A' < 'B'... < 'a' < 'b'... (voir caractères spéciaux). Les chaînes disposent en outre de

chaine1 in chaine2 est vrai si la première chaîne est contenue dans la seconde
chaine1 not in chaine2 est vrai si la première chaîne n'est pas contenue dans la seconde

Les expressions ci-dessus peuvent se composer:

expr1 or expr2 est vrai si l'une des deux est vraie (la seconde ne sera évaluée que si la première est fausse)
expr1 and expr2 est vrai si les deux sont vraies (la seconde ne sera évaluée que si la première est vraie)
not est la négation logique: not(1==2) est vrai

Attention:

2.4 Conditions: if expr: … elif expr: … else: …

Une condition permet ou non le déroulement d'une portion de code. Un exemple sera plus éloquent qu'une explication a priori (notez l'indentation des parties de code à considérer ou non selon la condition):

#! /usr/bin/python
# -*- coding: latin-1 -*-
i=4 # on peut faire varier cette valeur
if i<5:
  print i, "est plus petit que 5"
elif i==5:
  print i, "est exactement égal à 5"
else:
  print i, "dans les autres cas, si i est plus grand que 5"
print "C'est fini"  #  ceci est hors condition, puisque non indenté

if présente ce qui doit être fait si la condition qui le suit est rencontrée, elif permet de préciser une alternative soumise à condition ; else permet une alternative si aucune des conditions (if ou elif) n'a été rencontrée. elif et else ne sont pas obligatoires et l'un peut être utilisé sans l'autre.

Il est possible d'inclure une condition dans une autre:

#! /usr/bin/python
# -*- coding: latin-1 -*-
i=7
if i<0:
  if i%2==0:
    print i,"est négatif et pair"
  else:
    print i,"est négatif et impair"
else:
  if i%2==0:
    print i,"est positif et pair"
  else:
    print i,"est positif et impair"

Il est souvent possible de simplifier ces tests de parité:

if i%2: # pour un i pair, la réponse est "0", valeur réputée fausse
  print "i est impair"
else:
  print "i est pair"

Note: une condition peuvent être utilisées dans des définitions de listes en compréhension

2.5 Boucle while

La boucle teste une condition avant d'exécuter le bloc d'instruction indenté, et celui-ci sera répété tant que la condition sera vraie. Dans l'exemple suivant, la variable i sera incrémentée (augmentée) de 1 et imprimée jusqu'à ce qu'elle atteigne 10.

i=0
while i<11 :
  print i
  i=i+1

Note: while True:, while 1: ou while not(0): est toujours vrai et génère une boucle sans condition de sortie. On en sort généralement avec une condition amenant à break.

while True:
  a=input("[q] + [return] pour quitter: ")
  if a=='q': break
  print "Réessayez"

else: introduit une séquence qui sera parcourue lors de la sortie normale de la boucle
break quitte immédiatement la boucle en évitant else
continue retourne directement au début de la boucle, ce qui permet d'éviter des tests de condition inutiles

nb=9
while nb!=0:
  nb=input("0, 1, 2 ou 3? ")
  if nb==1: print "Choix un"; continue
  if nb==2: print "Choix deux"; continue
  if nb==3: print "Choix trois"

pass ne fait rien, mais est parfois nécessaire dans une syntaxe, par exemple pour forcer une indentation ou un réalignement.

2.6 Boucle for + iter()

for var in range(10) : # range(10) génére les valeurs de 0 à 9
  print var
  print var*5
  print "toujours dans la boucle puisqu'indentation"
print "Suite du programme: alignement sur 'for'"

Cette boucle se répète un nombre de fois défini pour une variable. Dans le cas présent, var prendra successivement toutes les valeurs de 0 à 9 y compris. Les instructions du bloc seront toutes activées 10 fois, et le programme continuera ensuite après le bloc défini sous la boucle for.

Il est possible de fixer un début, une fin et un pas, éventuellement négatif:

for var in range(10,4,-2):
  print var,

10 8 6

La succession de valeurs prises par la variable peut également provenir d'une chaîne:

for i in "Cumpapade":
  print i

... ou d'une collection:

for i in (1,"eggs",5,"spam",8,16):
  print i

On peut imbriquer les boucles (notez les indentations successives):

#! /usr/bin/python
for i in range (1,11):
  print "Table de multiplication par", i
  for j in range (1,11):
    print i, "x", j, "=", i*j
  print # ajoute de ligne entre chaque table
print "C'est tout"

continue retourne directement au début de la boucle, ce qui permet d'éviter des tests de condition inutiles
else: introduit une séquence qui sera parcourue lors de la sortie normale de la boucle
break quitte immédiatement la boucle en évitant else
pass ne fait rien, mais est parfois nécessaire dans une syntaxe, par exemple pour forcer une indentation ou un réalignement. La boucle suivante pourrait servir à comparer (très) grossièrement la rapidité de deux systèmes:

#! /usr/bin/python
import time
debut=time.time()
for i in range(1000):
  for j in range(1000):
    pass
print time.time()-debut

iter() permet la construction d'un objet itérable à partir d'une chaîne, liste, tuple ou dictionnaire, utilisable par la boucle for:

a=iter([1,2,3])
for i in a:
  print i

Il est possible d'utiliser iter qui appelle lui-même une fonction, à condition de donner une valeur-sentinelle qui stoppera la boucle lorsqu'une même valeur sera rencontrée. Dans le cas qui suit, la fonction hasard() retourne aléatoirement un nombre de 0 à 4; la boucle s'arrêtera au premier 3 fourni (qui ne sera pas imprimé).

#! /usr/bin/python
import random
def hasard():
  return random.randrange(5)
for i in iter(hasard,3):
  print i

2.7 Traitement des erreurs

Plutôt que de subir une erreur, il est possible de tester une expression, de voir la réaction de l'interpréteur et de faire réagir le programme de façon adéquate avec except. else, facultatif, introduit une portion de code qui ne sera parcourue que s'il n'y a pas d'erreur.

#! /usr/bin/python
# -*- coding: latin-1 -*-
try:
  1/0
except:
  print "Une erreur est apparue"
else:
  print "Tout va bien"

Il est possible de préciser une erreur particulière et de renvoyer des valeurs selon le cas:

#! /usr/bin/python
# -*- coding: latin-1 -*-
for i in range(-10,11):
  try:
    1./i
  except ZeroDivisionError:
    print "  -  "
  else:
    print "%.3f " %(1./i)

En remplacement de else, finally introduit une portion de code qui sera parcourue dans tous les cas, erreur ou pas erreur.

raise KeyboardInterrupt produit l'exception précisée, par exemple pour une mise au point

>>> raise KeyboardInterrupt, "Commmentaire facultatif"
Traceback (most recent call last):
  File "<stdin>", line 1, in ?
KeyboardInterrupt: Commmentaire facultatif

assert produit l'exception particulière AssertionError en cas de test négatif, remplaçant la séquence if test: raise This_Error. On peut lui passer une valeur:

>>> assert 2<1, "Comparison Error"
AssertionError: Comparison Error

with et as (Python 2.5 si from __future__ import with_statement) permettent une opération locale. as (facultatif) permet de récupérer la valeur produite par l'opération qui suit with. Il faut également que l'opération porte sur un objet ayant un attribut __exit__: l'intérêt est que s'il se passe une exception dans la structure with, le fichier ouvert est refermé proprement.

#! /usr/bin/python
# -*- coding: latin-1 -*-
from __future__ import with_statement

with open("essai.txt") as fd:
  print fd.read() # imprime le fichier ouvert uniquement dans la structure 'with'
print fd.read()   # déclenche ValueError: I/O operation on closed file

Notes

2.8 Liste des erreurs

Les types d'erreurs définis dans le module exceptions.py:

Et voici les avertissements:

DeprecationWarning, FutureWarning, OverflowWarning, PendingDeprecationWarning, RuntimeWarning, SyntaxWarning, UserWarning, Warning

3. Nombres

3.1 Types de variables numériques

Pour les généralités sur les variables, voir la section variables et assignations.

var=43 permet d'assigner une valeur à une variable numérique.

Depuis la version 2.4, il n'y a plus de problèmes lorsqu'un entier dépasse les limites -2 147 483 648 et +2 147 483 647. Si un résultat se situe en dehors de cet intervalle, 'L' suit le nombre: var=100000*100000 équivaut à 10000000000L

nbr=2.65 est une variable "réelle" (en informatique, "réel" signifie "non entier")
nbr=265e-2 équivaut au précédent: 265 * 10**-2 = 265/100

nbr=3+4.1j est un nombre complexe (j ou J postposé qualifie la valeur imaginaire)
nbr.real renvoie la partie "réelle" du complexe
nbr.imag renvoie la partie imaginaire du complexe
nbr.conjugate() renvoie le nombre conplexe conjugué (a-bj et a+bj sont des complexes conjugués)

Python calcule dans l'ensemble des complexes (ici, la racine complexe d'un complexe):

>>> (1+4j)**(1/(2+3j))
(1.6758516946016602-0.20706889169199882j)

int() transforme un nombre ou une chaîne conforme en entier limité, de -2 147 483 648 à +2 147 483 647. Les "réels" sont arrondis par défaut
long() transforment un nombre ou une chaîne conforme en entier illimité, avec son L final: 43L

En Python 3, les entiers sont tous illimités. Le suffixe L et la fonction long() sont abandonnés.

float() transforme un nombre ou une chaîne conforme en nombre "réel"
complex() transforme un nombre ou une chaîne conforme en nombre complexe
a,b=coerce(a,b) ajuste les variables numériques dans le type le plus englobant.
  Hiérarchie: complexe > float > long > int

print type(var) renvoie <type 'int'>, <type 'long'>, <type 'float'> ou <type 'complex'> selon la variable. Attention: les <type '*'> ne sont pas des chaînes:

>>> var=43; type(var)=="<type 'int'>"
False

Pour s'assurer qu'une expression est entière, on peut la comparer à un nombre qu'on sait être un entier:

>>> var=43; type(var)==type(0)
True

Il existe un type de nombre permettant d'autres valeurs (l'infini...), voyez le module Decimal

3.2 Opérateurs numériques

= assigne une valeur à une variable: A=5, b=A
+ additionne nombres et variables numériques
- soustrait une valeur à une autre ou à une variable
* multiplie deux nombres ou variables numériques
/ une division d'entiers (python 2.x) donne une réponse entière, arrondie par défaut:

>>> 7/4
1

Un point après un nombre force Python à considérer la réponse comme décimale:

>>> 7./4
1.75

// permet la division entière pour les "réels":

>>> 7.7//4
1.0

Il est possible d'utiliser / comme diviseur non entier en mentionnant en début de programme (future est entouré de part et d'autre de deux "soulignés"):

>>> from __future__ import division
>>> 7/4
1.75

Ce n'est pas nécessaire si on lance python 2.6 et suivants avec un paramètre:

$ python -Qnew

En Python 3, la division / n'est plus entière: 7/4 vaut 1.75 dans tous les cas. Il vaut donc mieux déjà réserver / pour la division décimale et // pour la division entière.

round(x) arrondit un "réel" (vers l'entier supérieur à partir de .5)
round(x,n) arrondit un "réel" à la décimale n (précision à la 15e décimale). n négatif permet un arrondi à la dizaine, centaine, au millier... près. Attention: jusqu'à Python 2.6, cela ne limite pas le nombre de chiffres après la virgule (voir print):

>>> round(3.14159,2)
3.1400000000000001

En Python 3, round(n) limite l'affichage du nombre à la décimale demandée.

>>> round(3.14159,2)
3.14

Pour les arrondis par défaut et par excès, voyez le module math. Par ailleurs, int() arrondit par défaut:

>>> reel=3.6; print int(reel)
3

Pour l'arrondi par excès, il est possible d'utiliser round() après avoir ajouté .5 au nombre.

>>> reel=3.3; print round(reel+.5)
4.0

Pour prendre en compte les nombres négatifs, il faut corriger le signe du .5 ajouté (cmp(a,b) renvoie -1 si a < b):

reel=-3.3; print round(reel+.5*cmp(reel,0))

En python 2., on peut utiliser int() pour supprimer .0 (inutile en Python 3). Le plus pratique est d'utiliser une fonction:

def exces(reel):
  return int(round(reel+.5*cmp(reel,0)))

print exces(3.3)

x % y ("x modulo y") renvoie le reste d'une division: 7%3 donne 1
divmod() division renvoie une paire de nombres, le résultat entier et le reste:

>>> divmod(3,.7)
(4.0, 0.20000000000000018)

divmod(x,y)[0] équivaut à x//y
divmod(x,y)[1] équivaut à x % y
Une manière simple est d'utiliser un tuple pour recevoir les réponse:

resultat,reste=divmod(x,y)

** marque l'exposant et a la priorité sur +, -, *, /
pow(x,y) renvoie x à la puissance y, équivaut à x**y
pow(x,y,z) renvoie x à la puissance y, puis le tout %z

Ces opérateurs s'organisent entre eux comme on a appris à l'école:

>>> (7-3)*(3+2)**2 donne 4 * 5**2 = 100

Dans les formes x+=y, x-=y, x/=y, x//=y, x*=y, x**=y, x%=y... le premier opérande reçoit le résultat de l'opération:

>>> x=3; x+=2; x
5

max(x,y) renvoie la plus grande des deux valeurs
min(x,y) renvoie la plus petite des deux valeurs
cmp(x,y) renvoie -1 si x<y, +1 si x>y et 0 si x==y
abs() renvoie la valeur absolue d'un nombre (sans le signe)
abs(a+bj) renvoie le module du vecteur exprimé en coordonnées cartésiennes (l'hypothénuse du triangle rectangle dont les deux autres côtés sont a et b)

Voir également le module math pour les fonctions mathématiques plus avancées sur les "réels".

3.3 Bases numériques

Même si l'on utilise généralement la base décimale (même sans le savoir), il en existe d'autres, où chaque rang vers la gauche représente une multiplication par une autre valeur que 10. Cela ne concerne qu'une manière d'encoder un même nombre.

L'octal est une base numérique où les chiffres ont des valeurs possibles de 0 à 7. Un nombre sous forme de chaîne octale commence par 0: 0253 vaut 2*8*8 + 5*8 + 3 = 171

>>> oct(43)
'053'
>>> print 053
43

Attention: oc=09 renvoie un message d'erreur parce que '9' n'est pas un chiffre de la base octale ; oc=09.5 attribue la valeur "réelle" de 9.5 en base décimale à la variable oc

En Python 3, une chaîne octale commence par 0o (zéro et la lettre 'o', minuscule ou majuscule)

L'hexadécimal est une base numérique où les chiffres ont des valeurs possibles de 0 à 15, codées avec les chiffres de 0 à 9 et les lettres de a à f (valeurs 10... 15). Les nombres sous forme de chaîne hexadécimale commence par 0x ou 0X . 0x2b vaut 2*16 + 11 = 43

hex(entier) retourne une chaîne représentant un nombre en hexadécimal
hx=0x2b

>>> hex(43)
'0x2b'
>>> print 0x2b
43

bin() (nouveauté 2.6?) permet de transformer un nombre en chaîne binaire, qui commence avec le préfixe 0b... et ne comprenant que des 0 et des 1: 43=0b101011

>>> bin(43)
'0b101011'
>>> print(0b101011)
43

int(chaine) et long(chaine) convertissent une chaîne énoncée en base 10 en un nombre
int(chaine,base) et long(chaine,base) permettent de préciser une base, entre 2 et 36

>>> int("123456")
123456
>>> int("2b",16) # le préfixe n'est pas nécessaire
43

La chaîne ne peut pas contenir de "chiffre" plus grand que ceux admis par la base. En base 36, les chiffres conventionnels et les 26 lettres de l'alphabet peuvent être utilisés, z ou Z représentant la valeur 35.

Rappel: long() est supprimé en Python 3, puisque tous les entiers sont considérés comme illimités.

3.4 Opérations sur les bits

var << n décalage des bits vers la gauche (équivaut à var*2**n)
var >> n décalage des bits vers la droite (équivaut à var//2**n)

var1 & var2 "et logique": 1 si les deux bits correspondants valent 1

...001100 (12)
...000101 (5)
---------
...000100 (4, résultat)

var1 | var2 "ou inclusif": 1 si au moins 1 des deux bits correspondants vaut 1

...001100 (12)
...000101 (5)
---------
...001101 (13, résultat)

var1 ^ var2 "ou exclusif": 1 pour les bits correspondants différents

...001100 (12)
...000101 (5)
---------
...001001 (9, résultat)

~var inversion de chaque bit d'une variable, ~nbr équivaut à -(nbr+1)

...000010 (2)
---------
...111101 (-3, résultat; ..1111 vaut -1, ..1110 vaut -2, ..1101 vaut -3)

Attention! 13|56 (=61) n'équivaut pas à 13 or 56 (=13); 13 & 56 (=8) n'équivaut pas à 13 and 56 (=56), voir Comparaisons et booléens .

4 Chaînes de caractères

Pour les généralités sur les variables, voir la section variables et assignations. Une chaîne de caractères peut également être considérée comme un tuple de caractères.

4.1 Affectation de chaînes

ch="python" la variable ch reçoit la valeur "python"

ch="C'est bien" on peut inclure une apostrophe dans une chaîne
V='Un "faux"' et on utilise les apostrophes pour inclure des guillemets doubles
V='C\'est "faux"' le caractère \ permet de "protéger" l'apostrophe dans une chaîne
V='123' la variable V reçoit une chaîne de trois chiffres

"""Trois doubles guillemets
permettent une chaîne
en plusieurs lignes"""   # sans commentaire à l'intérieur!

Le première utilisation d'une variable doit être une assignation, qui peut se faire de plusieurs manières: A="", for i in "SPAM": ou def fonct(ch1=""):

len("python") renvoie la longueur d'une chaîne
type(expr) renvoie <type 'str'> si l'expression est une chaîne. Comparer avec la chaîne "<type 'str'>" ne fonctionne pas:

>>> type("chaine")=="<type 'str'>"
False
>>> type("chaine")==type("")
True

chr(n) affiche un caractère à partir de son code numérique
ord("c") affiche le code numérique d'un caractère

Les caractères de 0 à 127 sont quasi-universels (ascii=American Standard Code for Information Interchange):

\x20   32   \x30 0 48   \x40 @ 64   \x50 P 80   \x60 ` 96    \x70 p 112
\x21 ! 33   \x31 1 49   \x41 A 65   \x51 Q 81   \x61 a 97    \x71 q 113
\x22 " 34   \x32 2 50   \x42 B 66   \x52 R 82   \x62 b 98    \x72 r 114
\x23 # 35   \x33 3 51   \x43 C 67   \x53 S 83   \x63 c 99    \x73 s 115
\x24 $ 36   \x34 4 52   \x44 D 68   \x54 T 84   \x64 d 100   \x74 t 116
\x25 % 37   \x35 5 53   \x45 E 69   \x55 U 85   \x65 e 101   \x75 u 117
\x26 & 38   \x36 6 54   \x46 F 70   \x56 V 86   \x66 f 102   \x76 v 118
\x27 ' 39   \x37 7 55   \x47 G 71   \x57 W 87   \x67 g 103   \x77 w 119
\x28 ( 40   \x38 8 56   \x48 H 72   \x58 X 88   \x68 h 104   \x78 x 120
\x29 ) 41   \x39 9 57   \x49 I 73   \x59 Y 89   \x69 i 105   \x79 y 121
\x2a * 42   \x3a : 58   \x4a J 74   \x5a Z 90   \x6a j 106   \x7a z 122
\x2b + 43   \x3b ; 59   \x4b K 75   \x5b [ 91   \x6b k 107   \x7b { 123
\x2c , 44   \x3c < 60   \x4c L 76   \x5c \ 92   \x6c l 108   \x7c | 124
\x2d - 45   \x3d = 61   \x4d M 77   \x5d ] 93   \x6d m 109   \x7d } 125
\x2e . 46   \x3e > 62   \x4e N 78   \x5e ^ 94   \x6e n 110   \x7e ~ 126
\x2f / 47   \x3f ? 63   \x4f O 79   \x5f _ 95   \x6f o 111   \x7f   127

le 127e caractère est l'effacement. Les caractères dont le code est inférieur à 32 sont des caractères de contrôle, dont certaines ont des particularités intéressantes:

chr(0) code le caractère vide
chr(7) donne un bip
chr(8) revient d'un caractère à gauche, sans effa cer le caractère présent
chr(9) saute à la tabulation suivante loin (colonnes octuples)
chr(10) en UNIX: retour chariot (première colonne, une ligne plus bas); DOS et MAC: une ligne plus bas
chr(11) une ligne plus bas, sans changer de colonne
chr(12) une ligne plus bas, sans changer de colonne
chr(13) en UNIX et DOS: retour à la colonne 0, sans changer de ligne; MAC: retour-chariot
chr(24) et chr(26) affichagent d'un caractère grisé
chr(27) introduit les codes d'échappement, voir ECMA

dont certains peuvent être codés plus simplement dans une chaîne de caractères de Python:

\0 pour un caractère vide (contrairement au langage C, il ne s'agit pas d'une fin de chaîne)
\a émet un bip (comme chr(7))
\b pour revenir en arrière d'un caractère
\t pour une tabulation
\n pour un retour-chariot (tous systèmes)
\r pour revenir en début de ligne sans passer à la ligne suivante
\v pour passer à la ligne suivante sans revenir en début de ligne
\\ permet de coder le caractère \.

repr(objet) représentation d'un objet sous la forme d'une chaîne avec les échappements pour qu'on puisse l'afficher avec print

>>> a="C'est déjà ça"
>>> a; print a;
"C'est d\xe9j\xe0 \xe7a"
C'est déjà ça
>>> repr(a); print repr(a)
'"C\'est d\\xe9j\\xe0 \\xe7a"'
"C'est d\xe9j\xe0 \xe7a"

4.2 Opérations sur les chaînes

Voir aussi le module 3.1 string

= assigne une valeur à une variable: chaine='azerty'
+ prolonge une chaîne par une autre chaîne (concaténation):

>>> ch1='ah '; ch2='bon!; ch1+ch2
ah bon!

Il est possible d'effectuer une permutations des valeur de variables, qui peuvent être de types différents (numériques, chaînes, listes...):

>>> x='un', y="deux", z="trois"
>>> x, y, z = y, z, x
>>> x, y, z

* multiplie une chaîne par un entier

>>> _q="ah"; _q*3
ahahah

chaine[3] désigne le quatrième caractère de la chaîne
chaine=chaine[debut:fin] sélectionne une sous-chaîne à partir de la position debut (la première est 0) jusqu'à la position fin non comprise (la dernière est -1, l'avant-dernière -2...)
chaine[m:n:i] renvoie une chaîne composée du caractère m, puis tous les i caractères jusqu'au caractère n-1
chaine[0:] équivaut à la chaîne elle-même
str() converti un nombre en chaine:

>>> str(0.1)
'0.1'

repr() convertit également un nombre en chaine:

>>> repr(0.1)
'0.10000000000000001'

chaine=" ".join(liste) assemble dans une chaîne les éléments d'une liste de chaînes séparés par des espaces (ou toute autre caractère défini)
li=chaine.split() découpe une chaîne (à chaque espace) et place les éléments dans une liste
li=chaine.split(lim) découpe une chaîne (à chaque limite) et place les éléments dans une liste
li=chaine.split(lim,n) découpe une chaîne un nombre limité de fois
li=chaine.rsplit(lim,n) découpe une chaîne un nombre limité de fois à droite

format(n,'') retourne un chaîne formatée, valable avec les lettres d, o, x, c, f de print.

>>> format(1234.56,'011.3f') # '011.3f' ou ' 11.3f' permettent un remplissage à gauche '0001234.560'

Python3: Une virgule permet la séparation des milliers.

>>> format(123456,',d')
'123,456'

Il est possible de prévoir des champs à remplir à travers format():

>>> "{1} et {0}".format('Romeo','Juliette')
'Juliette et Romeo'

Python 3: il est possible de remplir une chaîne lacunaire sans les numéros d'ordre:

>>> "{} et {}".format('Romeo','Juliette')
Romeo et Juliette

filter(fonction, chaine) renvoie une chaîne filtrée par une fonction, éventuellement créée pour l'occasion avec lambda

Plus de spécifications ici

>>> filter(lambda x: 117>ord(x)>111, "python")
'pt'

4.3 Comparaison de caractères et chaînes

max(chaine) renvoie le caractère dont le code numérique est le plus élevé
min(chaine) renvoie le caractère dont le code numérique est le moins élevé
max(ch1,ch2) renvoie la chaîne qui se classe alphabétiquement après l'autre
min(ch1,ch2) renvoie la chaîne qui se classe alphabétiquement avant l'autre
cmp(ch1,ch2) envoie 0 si les chaînes sont égales, -1 si la première se classe avant l'autre, 1 si la première se classe après l'autre

x in y retourne True si la chaîne x est incluse d'un seul tenant dans y

4.4 Encodage ISO-8859

Par défaut, Python n'accepte les chaînes et commentaires des scripts que s'ils sont écrits en ASCII, de chr(0) à chr(127), c'est-à-dire sans lettres accentuées. En cas d'utilisation de caractères spéciaux, il faut utiliser un encodage. Pour utiliser les caractères latins, on peut utiliser l'encodage utf-8 (ou latin-1) ci-dessous) de la manière suivante:
\x + code hexadécimal ou chr(code décimal): "ça" s'écrit "\xe7a" ou chr(231)+"a"

\xa0 160     \xb0 176 °   \xc0 192 À   \xd0 208 Ð   \xe0 224 à   \xf0 240 ð
\xa1 161 ¡   \xb1 177 ±   \xc1 193 Á   \xd1 209 Ñ   \xe1 225 á   \xf1 241 ñ
\xa2 162 ¢   \xb2 178 ²   \xc2 194 Â   \xd2 210 Ò   \xe2 226 â   \xf2 242 ò
\xa3 163 £   \xb3 179 ³   \xc3 195 Ã   \xd3 211 Ó   \xe3 227 ã   \xf3 243 ó
\xa4 164 €   \xb4 180 Ž   \xc4 196 Ä   \xd4 212 Ô   \xe4 228 ä   \xf4 244 ô
\xa5 165 ¥   \xb5 181 µ   \xc5 197 Å   \xd5 213 Õ   \xe5 229 å   \xf5 245 õ
\xa6 166 Š   \xb6 182 ¶   \xc6 198 Æ   \xd6 214 Ö   \xe6 230 æ   \xf6 246 ö
\xa7 167 §   \xb7 183 ·   \xc7 199 Ç   \xd7 215 ×   \xe7 231 ç   \xf7 247 ÷
\xa8 168 š   \xb8 184 ž   \xc8 200 È   \xd8 216 Ø   \xe8 232 è   \xf8 248 ø
\xa9 169 ©   \xb9 185 ¹   \xc9 201 É   \xd9 217 ù   \xe9 233 é   \xf9 249 ù
\xaa 170 ª   \xba 186 º   \xca 202 Ê   \xda 218 Ú   \xea 234 ê   \xfa 250 ú
\xab 171 «   \xbb 187 »   \xcb 203 Ë   \xdb 219 Û   \xeb 235 ê   \xfb 251 û
\xac 172 ¬   \xbc 188 Œ   \xcc 204 Ì   \xdc 220 Ü   \xec 236 ì   \xfc 252 ü
\xad 173 -   \xbd 189 œ   \xcd 205 Í   \xdd 221 Ý   \xed 237 í   \xfd 253 ý
\xae 174 ®   \xbe 190 Ÿ   \xce 206 Î   \xde 222 Þ   \xee 238 î   \xfe 254 þ
\xaf 175 ¯   \xbf 191 ¿   \xcf 207 Ï   \xdf 223 ß   \xef 239 ï   \xff 255 ÿ

le code 160 est l'espace insécable (&nbsp; en html); le code 173 est la possibilité de césure (&shy en html) dont la valeur n'est pas universellement reconnue, paraît-il.

r'chaine' permet le codage d'une chaîne littérale, où les codes \x ne sont pas évalués. Comparez:

>>> print "\43\n*"
#
*
>>> print r"\43\n*"
\43\n*

Pour utiliser les caractères non-ASCII (latins accentués, non latins, symboles) dans les chaînes et commentaires, il est nécessaire d'utiliser une directive d'encodage (PEP-263) à mettre (impérativement) sur la seconde ligne:

#! /usr/bin/python
# -*- coding: utf-8 -*-

print "Déjà où" # chaîne et commentaires écrits avec des accents

Un synomyme de utf-8 est latin-1 . Pour disposer des € et œ, spécifier latin-15 ou utf-85.

Notes:

4.5 Chaînes unicode

L'UTF-8 est le standard qui s'impose, car le projet a pour but de rendre possible le codage du plus grand nombre de caractères typographiques possible, dont les dizaines de milliers d'idéogrammes chinois officiels, et antiques. Les caractères "ascii" (lettres non accentuées et signes informatiques usuels, dont le code est inférieur à 128) restent les mêmes, deux ou plusieurs octets supérieurs à 127 représentant une lettre accentuée, un caractère non latin ou un signe typographique particulier (è, π, …, —).

L'universalité a un prix: en latin-1 (iso8859-1), chaque octet (de 0 à 255) vaut un caractère, ce qui n'est plus le cas en UTF-8. Mais cela ne veut pas dire qu'il n'est plus possible de remplacer un caractère simple par un autre en utilisant leur rang ASCII (0 à 127): aucun caractère inférieur à 128 n'est utilisé pour coder un caractère unicode.

De la même manière, une suite de deux (ou trois) octets codant un caractère unicode n'est jamais contenue dans une suite plus longue d'octets codant un autre caractère unicode: si un caractère est codé par la suite d'octets w-x-y-z, aucun autre n'est codé par les doublets w-x, x-y ou y-z ou les triplets w-x-y ou x-y-z. Cela permet des remplacements de caractères unicode par le groupe d'octets qui les code sans en altérer un autre, codé de façon plus longue.

Utiliser l' unicode

Pour rappel, il est possible de coder les scripts (chaînes et commentaires) en unicode en commençant un script par:

#! /usr/bin/python -Qnew
# -*- coding: utf-8 -*-

L'éditeur de texte utilisé doit alors sauvegarder le script en utf-8, et la console en permettre l'affichage.

Chaînes unicode

Pour donner un exemple plus évident qu'un idéogramme chinois, nous allons prendre le caractère "œ", qui n'existe pas dans le codage utf-8/latin-1). Dans une console python, saisissez-le ([AltGr-o] en Linux) entouré de guillemets:

>>> "œ" 
'\xc5\x93'

qui nous montre que l'œ est codé en deux octets (représentés ici en hexadécimal). La longueur de la chaîne représentant œ en utf-8 vaut donc deux octets:

>>> print len("œ") 
2

En console configurée en codage utf-8, ces deux octets ne sont pas affichables séparément, puisqu'ils ne peuvent y exister qu'en séquence d'au moins deux octets:

>>> print "\xc5","\x93" 
� �

Python dispose d'un objet unicode:

>>> u"€"
u'\u20ac'

Il s'agit vraiment d'un objet «Python»:

>>> type(u"€")
<type 'unicode'>

Python sachant qu'il ne s'agit que d'un caractère, la longueur de cette chaîne unicode vaut 1:

>>> len(u"€")
1

Transformation

unicode("chaine","encodage") retourne un objet unicode utilisant l'encodage spécifié (la longueur de la première chaîne vaut 5, celle de la seconde chaîne est de 3):

unicode("43€","latin-1")
u'43\xe2\x82\xac'
>>> unicode("43€","utf-8")
u'43\u20ac'

Cela permet de modifier le type de codage d'une chaîne.

>>> u"é" in unicode("pétunia","utf-8"):
True

unichr(entier) retourne un caractère unicode à partir d'un entier:

>>> unichr(0x20ac)
€

Le module unicodedata permet d'obtenir des indications sur les caractères unicode:

>>> import unicodedata
>>> print unicodedata.category(u"é"), "*", unicodedata.name(u"é")
Ll * LATIN SMALL LETTER E WITH ACUTE

5. Collections

Pour les généralités sur les variables, voir la section variables et assignations.

Python connaît plusieurs types de collections (listes, tuples, dictionnaires et ensembles...) c'est-à-dire de variables composées d'éléments qui peuvent être divers (nombres, chaînes ou parfois d'autres collections). Même les chaînes sont considérées comme des tuples simples de caractères.

5.1 Tuples ( , )

Pour les généralités sur les variables, voir la section variables et assignations.

Un tuple (parfois traduit en français par n-uple) est une séquence, collection ordonnée d'éléments (chaînes, nombres, listes, tuples...). Un tuple est figé, et ne peut être modifié que par ajout d'éléments ou par une rédéfinition. Pour une variable tup:

tup=(1,2,"trois",(4,5),6) définit le tuple tup (notez les parenthèses) 1 est au décalage 0, 2 est au décalage 1, "trois" au décalage au 2, le tuple (4,5) au décalage 3...
tup=(5,) la virgule permet de n'assigner qu'un élément à un tuple: tup=(5) équivaut à tup=5, variable entière
tup=1,2,3,(4,5),6 les parenthèses ne sont pas toujours nécessaires, mais bien celles du sous-tuple

tup[3][1] (notez les crochets!) renvoie 5, le second élément du sous-tuple à la position 4

Une chaîne étant un tuple de caractères:

>>> li= [1,"eggs"]; print li[1][3]
's'

tuple() transforme une liste, chaîne, ensemble ou rassemble les clés d'un dictionnaire en tuple
type(var) renvoie <type 'tuple'> si l'expression est un tuple

del tup[1:3] renvoie TypeError: 'tuple' object does not support item deletion
len(tup) renvoie le nombre d'éléments d'un tuple. len((1,(2,3),4)) ne contient que 3 éléments

tup=() permet un tuple vide, extensible par + :
+ prolonge un tuple par un autre tuple: tup=(2,3); tup+=(5,) (virgule nécessaire pour spécifier le "tuple")
* permet de multiplier un tuple par un entier

>>> tup=(0,"",None,False)
>>> tup*3
(0,'',None,False,0,'',None,False,0,'',None,False)

+= et *= assigne directement le résultat au premier terme

Les tuples ne supportent pas les assignations de valeur à ses éléments (voir erreurs):

>>> tup= 3,5,6; tup[2]=45
TypeError: object doesn't support item assignment

5.2 Listes [ , ]

Pour les généralités sur les variables, voir la section variables et assignations.

Une liste est une collection ordonnée, une séquence modifiable d'objets divers: nombres, chaînes, listes, tuples, dictionnaires, ensembles... Chaque élément est classé selon un index numérique et peut être librement redéfini (une chaîne peut être remplacée par un nombre ou une collection).

li= [2,"oh",9,47] définit la liste li, composée de 4 valeurs: le nombre 2 est au décalage 0, la chaîne "oh" est au décalage 1, 9 au décalage au 2, etc.
len([2,"oh",(6,3),9,47]) renvoie le nombre d'éléments de la liste, en l'occurrence 5 éléments, dont le tuple (6,3).

list() transforme en liste une chaîne, un tuple, un ensemble, ou rassemble les clés d'un dictionnaire

>>> list("spam")
['s', 'p', 'a', 'm']

li[0] désigne le premier élément de la liste, li[1] le deuxième...
li[-1] désigne le dernier élément de la liste, li[-2] l'avant-dernier...

li[1]= 43 assigne la valeur 43 à la deuxième place de la liste li

li= [1,9,[7,4,5]] une liste peut en contenir une autre parmi ses éléments
li[2][0] désigne le premier élément de la sous-liste à la troisième position: 7

liste=liste[debut:fin] sélectionne une plage de liste à partir de la position debut(la toute première est 0) jusqu'à la position fin non comprise (la dernière est -1, l'avant-dernière -2...)

li[3:7] à partir de la quatrième position jusqu'à la huitième position non comprise
li[3:] à partir de la quatrième jusqu'à la dernière comprise
li[0:-1] exclut le dernier élément
li[:-2] à partir de la première position jusqu'à l'avant-dernière non comprise
li[m:n:i] renvoie l'élément au décalage m, puis tous les i éléments jusqu'à n-1

li[:0]=['a','b','c'] ajoute des éléments en début de liste
li[2:2]=['a','b','c'] insère des éléments entre les positions 1 et 2
li[m:n]=['a','b','c'] supprime les positions m à n-1 et insère des éléments entre la position m et n
del li[m:n] supprime les positions de m à n-1

li=[] initialise une liste vide, peut être nécessaire lorsqu'elle doit partir de rien, voir exemple
+ prolonge une liste par une autre liste

>>> li=["Spam"]; li+[3]
["Spam", 3]
>>> li=li+3
TypeError: can only concatenate list (not "int") to list

Pour ajouter des élément à une liste, il faut les entourer de [ ]:

>>> li=[2,3,5,7]
>>> li+=[11,13]; li
[2,3,5,7,11,13]

Pour ajouter une sous-liste, il faut l'entourer [[ ]]:

>>> li=[2,3,5,7]
>>> li+=[[11,13]]; li
[2,3,5,7,[11,13]]

* permet de multiplier une liste

>>> ["Spam"]*3
['Spam','Spam','Spam']

+= et *= assigne directement le résultat au premier terme

Attention à l'assignation simple d'une liste à une autre, car cette égalité est en fait identité:

>>> liste=[1,2,3]; autre=liste
>>> autre+=[7]; print liste, autre
[1,2,3,7] [1,2,3,7]

autre n'est donc pas une autre liste comportant les mêmes éléments, c'est plutôt un alias. On utilise list() ou b=a[:] pour copier entièrement une liste dans une autre:

>>> originale=[1,2,3]; copie=list(originale)
>>> copie+=[7];
>>> print originale, copie
[1,2,3] [1,2,3,7]

range() crée une liste à partir de progressions arithmétiques finies:

>>> range(10)
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
>>> range(5,10)
[5, 6, 7, 8, 9]
>>> range(3,27,4)
[3, 7, 11, 15, 19, 23]
>>> range(10,0,-1)
[10, 9, 8, 7, 6, 5, 4, 3, 2, 1]

xrange() ne crée pas une liste mais un objet itérable capable de délivrer un seul élément à la fois, ce qui économise la mémoire.

En Python 3, range a le comportement de xrange(), qui est abandonné.

5.3 Méthodes pour les listes

li.count(x) compte le nombre d'occurrences de la valeur x dans la liste
li.index(x) retourne le décalage de la première occurrence de x dans la liste (ValueError si n'existe pas)
li.index(x,n) retourne le décalage de la nième occurrence de x dans la liste (ValueError si moins de n occurrences de x)
li.pop() renvoie le dernier élément et le supprime de la liste (IndexError si la liste est vide)
li.pop(i) retourne l'élément au décalage i, le supprime de la liste et ramène tous les élément suivants (IndexError si la liste est vide)
li.remove(x) supprime la première occurrence de la valeur x dans la liste. Provoque une erreur si la valeur x n'existe pas! Solution:

if x in li:
  li.remove(x)

li.insert(i,valeur) insère une valeur au décalage i en repoussant les éléments suivants
li.append() ajoute un élément (nombre, chaîne, liste, tuple, dictionnaire) à la fin d'une liste
li.extend(seq) étend une liste avec chaque élément d'une séquence: les caractères d'une chaîne, les élément d'une liste ou d'un tuple, ou chaque clé d'un dictionnaire. Pour li=[1,2,3,4] et ch="abc":

>>> li.append(ch)
[1, 2, 3, 4, 'abc']
>>> li.extend(ch)
[1, 2, 3, 4, 'a', 'b', 'c']

li=chaine.split() découpe une chaîne (à chaque espace) et place les éléments dans une liste
li=chaine.split(ch) découpe une chaîne (à chaque sous-chaîne) et place les éléments dans une liste
chaine=" ".join(liste) assemble dans une chaîne les éléments d'une liste de chaînes, avec l'espace (ou toute autre caractère défini) comme séparateur.

li.sort() trie la liste exprimée sous forme de variable
li.reverse() inverse une liste exprimée sous forme de variable
liste2=li[::-1] copie une liste inversée
nv=sorted([8,1,3,5,4]) renvoie une liste triée (Python 2.4)
sorted(li,key=str.lower) permet le tri d'une liste de chaînes sans la priorité des majuscules

>>> sorted(["B","a","b","A"],key=str.lower)
['a', 'A', 'B', 'b']

sort(reverse=True) et sorted(reverse=True) permettent de renverser la liste

sort(key=operator.itemgetter(n)) permet de définir la colonne (n) sur laquelle la liste doit être triée (importer préalablement le module operator).

>>> import operator
>>> li=[[1,4],[3,2]]
>>> li.sort(key=operator.itemgetter(1))
>>> li # le 2 de [3,2] passe avant le 4 de [1,4]: (1) pour les seconds éléments
[[3,2],[1,4]]
>>> li.sort(key=operator.itemgetter(O))
>>> li # le 1 de [1,4] passe avant le 3 de [3,2]: (0) pour les premiers éléments
[[1,4],[3,2]]

5.4 Dictionnaires { : , }

Pour les généralités sur les variables, voir la section variables et assignations.

Un dictionnaire est une collection non ordonnée d'objets modifiables, accessibles par des clés. La clé d'un élément peut être un nombre (même "réel" ou complexe), une chaîne ou même un tuple (mais pas une liste ni un dictionnaire):

>>> hindi={1:"ek", 2:"do", 3:"tin", 4:"char"}; hindi[1]
'ek'

La clé est une valeur, ou une variable contenant cette valeur

>>> hindi={1:"ek", 2:"do", 3:"tin", 4:"char", 5:'panch'}
>>> one=1; hindi[one]
'ek'

hindi.get(1) peut remplacer hindi[1], mais avec un avantage:
hindi.get(6,"clé inexistante") dans ce cas: la valeur sera la valeur seconde (et pas un message d'erreur)

Attention: un dictionnaire n'est pas une liste: on accède à la valeur d'un dictionnaire par sa clé, non par son décalage:

>>> hindi= {'un': 'ek', 'deux': 'do', 'trois': 'tin', 'quatre': 'char', 'cinq': 'panch'}
>>> print hindi["cinq"] # la clé est ici une chaîne
'panch'
>>> hindi[3]
KeyError: 3

Par contre, une valeur peut être une liste, à l'intérieur de laquelle un décalage peut servir:

>>> dic= {'spam': [1, 2, "eggs", 4]}
>>> dic['spam'][2] # affiche le décalage [2] de la liste dont la clé est 'spam'
"eggs"

type(dico) renvoie <type 'dict'>, mais comparer un dictionnaire avec la chaîne "<type 'dict'>" ne fonctionne pas, il faut utiliser type({}):

>>> mondico={4:"spam",3:"egg"}
>>> type(mondico)==type({})
True

del dico[1:3] retourne TypeError: unhashable type
id(var) donne l'identifiant de la variable var. Pour une variable locale, il est possible qu'il existe plusieurs identifiants en cas de récursion.
hash(var) donne l'identifiant de la donnée contenue dans la variable var. Dans l'exemple suivant,

>>> a=2;b=2+0j
>>> dic={a:123,b:456}
>>> dic
{2: 456}

5.5 Méthodes pour dictionnaires

flag=dico.has_key(clef) renvoie True si le dictionnaire dico contient la clé clef, préférable avant d'appeler une clé qui n'existerait pas
dico.get(cle) renvoie la valeur associée à la clé, None si la clé n'existe pas
dico.get(cle,exp) renvoie l'expression (nombre, chaîne...) si la valeur n'existe pas

Une autre façon de procéder:

if "trois" in hindi:
  print hindi["trois"]
else:
  print "ce dictionnaire n'a pas la valeur requise"

dic[cle]=valeur ajoute une valeur associée à une nouvelle clé à un dictionnaire ou modifie la valeur associée à cette clé
dico.pop(clé) renvoie et supprime la valeur définie par une clé (ainsi que la clé)
dico.popitem() renvoie une paire (clé-valeur) et la supprime du dictionnaire

dico.clear() supprime tous les éléments du dictionnaire dic
dico.update(dic) ajoute les occurrences du dictionnaire dic au dictionnaire dico
dico=dic.copy() copie un dictionnaire dans un autre, les modifications de l'un n'affectent pas l'autre

dico.keys() crée une liste des clés du dictionnaire dico
dico.values() crée une liste des valeurs du dictionnaire dico
dico.items() crée une liste de tuples (clé,valeur): [(1,'ek'),(2,'do'),(3,'tin')...]

En Python 3, les méthodes keys(), values() et items() renvoient des objets itérables au lieu de listes.

dico={'a':1,'b':2,'c':3}
iteration=dico.keys()
for i in iteration:
  print(i)

Python 3 connaît une nouvelle forme de dictionnaire: OrderedDict, qui conserve la mémoire de l'ordre de ses éléments.

5.6 Ensembles { , }

Pour les généralités sur les variables, voir la section variables et assignations.

Python propose depuis sa version 2.3 une classe d'«ensembles», qui sont des collections non ordonnées d'éléments uniques.

>>> {'Z',3,2,2,4}
set(['Z', 2, 3, 4])

Les doublons sont automatiquement éliminés. Les ensembles peuvent être définis à partir d'une liste, chaîne ou d'un tuple ou dictionnaire (dans ce dernier cas, seules les clés sont considérées).

>>> set("eggs"); set({"a":3,"b":6})
set(['s', 'e', 'g'])
set(['a', 'b'])

En Python, une collection ne peut pas être élément d'un ensemble:

>>> set([1,{2,3}])
TypeError: unhashable type: 'set'

Il existe une exception pour les chaînes: les caractères d'une chaîne seule seront autant d'éléments (hormis les doublons) de l'ensemble, mais plusieurs chaînes seront autant d'éléments:

>>> set("eggs"); set(['spam',"eggs"])
set(['s', 'e', 'g'])
set(['spam','eggs']))

nv=s.copy() copie un ensemble dans un autre
s.clear() vide l'ensemble
len(s) renvoie le nombre d'éléments de l'ensemble

Méthodes pour ensembles

s.add(x) ajoute l'élément x s'il ne s'y trouve pas encore
s.discard(x) enlève l'éventuel élément x de s
s.pop() enlève un élément au hasard, KeyError générée si l'ensemble est vide
s.remove(x) enlève l'élément x, KeyError générée si x n'appartient pas à s.

x in s retourne True si l'élément x appartient à s (condition permettant d'éviter KeyError)
a.issubset(b) (ou a<=b) retourne True si a est contenu dans (ou est égal à) b
a.issuperset(b) (ou a>=b) retourne True si a contient (ou est égal à) b

a.union(b) (ou a|b) retourne les éléments de a ou b
a.update(b) (ou a|=b) ajoute les éléments de b à a
a.intersection(b) (ou a&b) renvoie les éléments communs à deux ensembles
a.intersection_update(b) (ou a&=b) ne conserve à a que les éléments communs aux deux ensembles
a.difference(b) (ou a-b) renvoie les éléments de a n'appartenant pas à b
a.difference_update(b) (ou a-=b) retire à a tous les éléments communs avec b
a.symmetric_difference(b) (ou a^b) retourne les éléments non commun à a et b
a.symmetric_difference_update(b) (ou a^=b) retire à a tous les élément communs avec b

frozenset() permet la définition d'ensemble fixes, et ne permet donc pas les modifications par les méthodes clear(), add(), pop(), discard(), remove() ni update()

5.7 Génération de collections

Nous avons vu dans la boucle for et dans les listes qu'il était possible de générer une progression arithmétique finie avec range(debut,fin,progression).

Il est encore possible d'améliorer cela en définissant des collections en compréhension. Pour une liste ([]) de carrés (x**2) des valeurs (x) variant de 0 à 9 (range(10)):

>>> [x**2 for x in range(10)]
[0, 1, 4, 9, 16, 25, 36, 49, 64, 81]

Il est possible de créer un générateur:

>>> for i in (x**3 for x in range(10)): print i,
... 
0 1 8 27 64 125 216 343 512 729

Pour générer une chaîne, il suffit de joindre (join) les résultats transformés (str) en chaînes (", " sépare les chiffres):

>>> ", ".join(str(x**3) for x in range(10))
'0, 1, 8, 27, 64, 125, 216, 343, 512, 729'

Il est possible d'imbriquer des boucles:

>>> [x*y for x in range(1,3) for y in range(7)]
[0, 1, 2, 3, 4, 5, 6, 0, 2, 4, 6, 8, 10, 12]

Cette liste est composée par la multiplication de x et y, x vaut 1, puis 2, pendant que y vaut successivement les valeurs de 0 à 6. Il en possible de filtrer les résultats par une condition (les multiples de 3 sont éliminés):

>>> [x*y for x in range(5) for y in range(7) if x*y%3 != 0]
[1, 2, 4, 5, 2, 4, 8, 10, 4, 8, 16, 20]

Si l'on génère un ensemble (reconnaissable par les accolades), les doublons sont supprimés, et l'ordre n'est pas garanti:

>>> {x*y for x in range(5) for y in range(7) if x*y%3 != 0}
set([1, 2, 4, 5, 8, 10, 16, 20])

Pour obtenir un dictionnaire, la syntaxe change, pour prendre en compte les couples clé:valeur

>>> {x : chr(96+x) for x in range(1,6)}
{1: 'a', 2: 'b', 3: 'c', 4: 'd', 5: 'e'}

5.8 Méthodes pour collections

Dénombrement

len(collection) renvoie le nombre d'éléments d'une collection (le nombre de doublets clé:valeur d'un dictionnaire), ou le nombre de caractères d'une chaîne.

Sommation

sum(collection) renvoie la somme des éléments contenus dans une collection de nombres uniquement. Dans l'exemple suivant, la sous-liste [2,6] ne peut pas être ajoutée aux élément 3 et 5.

>>> sum([3,[2,6],5])
TypeError: unsupported operand type(s) for +: 'int' and 'list'

Pour les dictionnaires, la sommation porte sur les clés.

Comparaisons

La comparaison entre deux séquences se fait élément par élément, ou par longueur si tous les éléments de l'une correspond à tous les premiers de l'autre:

>>> [1,2,3] < [2,1]
True
>>> [1,2,3,4] > [1,2,3]
True

Pour les ensembles, < signifie l'inclusion stricte, > la contenance stricte:

a>b retourne True si a contient b et comprend au moins un autre élément
a<b retourne True si a est contenu dans b, lequel comprend au moins un élément supplémentaire

>>> {2,1} < {1,3,2}
True

Pour les dictionnaires, cela se passe par paire clé/valeur:

>>> {1:3,"b":3} < {"d":4,1:3}
True

max() renvoie le plus grand élément d'une collection
min() renvoie le plus petit élément d'une collection
max(x,y) renvoie la collection la plus «grande»
min(x,y) renvoie la collection la plus «petite»
cmp(x,y) renvoie -1 si x<y, +1 si x>y et 0 si x==y

x in y retourne True si x est un élément de y (contrairement aux chaînes, où x in y vérifie que x est une plage de y)

Tester

any() retourne True si au moins un élément d'une collection est vrai, c'est-à-dire différent de 0, None, False, "", [], () ou {}. La liste suivante contient la chaîne "0", qui n'est pas vide.

>>> any([0,'','0'])
True

all() retourne True si aucun des éléments n'est faux, (mais la collection peut être vide!). La liste suivante contient trois éléments non faux, à savoir 3, [3,"eggs",0] et "spam" (même si [3,"eggs",0] contient l'élément 0).

>>> any([3,[3,"eggs",0],"spam"])
True

Enumérer

enumerate(coll) génère une objet enumerate formé des paires (numéro d'ordre, élément) à partir d'une collection. Dans le cas d'un dictionnaires, ce sont les clés qui forment la seconde valeur de la paire.

>>> list(enumerate({"a":1,"b":3,"d":9}))
[(0, 'a'), (1, 'b'), (2, 'd')]

Il est possible d'énumérer un ensemble, même si ce n'est pas une séquence.

>>> list(enumerate(set("eggs")))
[(0, 's'), (1, 'e'), (2, 'g')]

À partir de Python 2.6, on peut ajouter un début:

>>> list(enumerate([4,6,7],start=1000))
[(1000, 4), (1001, 6), (1002, 7)]

Tri

sorted(coll, cmp, key, True) renvoie une liste triée des élements d'une collection (pour les dictionnaires, il s'agit des clés):

>>> sorted(["az","vD","Ez"])
['Ez', 'az', 'vD']

Pour un tri sans considération de casse (pour les chaînes et listes de chaînes), key=str.lower:

>>> sorted(["az","vD","Ez"],key=str.lower)
['az', 'Ez', 'vD']

Pour définir un mode de tri, cmp=lambda x,y:... plus une fonction renvoyant -1, 0 ou 1. La fonction lambda permet de trier une liste selon les seconds termes des paires la composant:

>>> sorted([(8,7),(5,1),(4,6)],cmp=lambda x,y: cmp(x[1],y[1]))
[(5,1), (4,6), (8,7)]

Pour une sortie inversée (sans définir cmp ni key):

>>> sorted([4,2,1,3],None,None,True)
[4, 3, 2, 1]

Enfin, en UTF-8, pour un tri «naturel» c'est-à-dire mélangeant majuscules et minuscules, lettres accentuées ou non (merci à Tyrtamos):

import locale
locale.setlocale(locale.LC_ALL,'')
votre_liste.sort(key=locale.strxfrm)

Inverser

reversed() renvoie un itérateur formé de l'inversion d'une collection (il s'agit d'un objet "reverse", qui n'est pas affichable avec print, ni découpable avec [m:n]: on ne peut que le parcourir avec in):

>>> for i in reversed((12,56,34,78)): print i,
78 34 56 12

Dictionnaires et ensembles ne peuvent être inversés, n'étant pas des séquences:

>>> reversed({"a":1,"b":2})
TypeError: argument to reversed() must be a sequence

Divers

map(fonction,variable) applique une fonction à chaque élément d'une collection, en l'occurrence, les caractères d'une chaîne:

>>> map(ord,'python')
[112, 121, 116, 104, 111, 110]

En Python 3, map() ne renvoie plus une liste, mais un itérateur.

Cette fonction peut être remplacée par une liste en compréhension:

[ord(x) for x in "python"]

filter(fonction, liste) renvoie des éléments de tuple, liste, clés de dictionnaire, filtrés par une fonction, éventuellement créée pour l'occasion avec lambda.

>>> filter(lambda x: x%2==1, range(10))
[1, 3, 5, 7, 9]

En Python 3, filter() ne renvoie plus une liste ou une chaîne, mais un itérateur.

Cette fonction peut être remplacée par une liste en compréhension:

[x for x in range(10) if x%2==1]

reduce(fct,lst) réduit une séquence: liste, tuple, clés de dictionnaire, ensemble... par une fonction à deux arguments. Dans l'exemple, la fonction lambda définit une multiplication, qui sera appliquée aux éléments de la liste [1,2,3,4,5,6], produite par range(1,7) (il s'agit donc de la factorielle de 6).

>>> reduce(lambda x,y: x*y,range(1,7))

reduce() est une fonction interne critiquée par Guido Van Rossum, mais qui ne possède pas de remplacement standard comme pour les deux précédentes.

En Python 3, la fonction reduce() doit être importée du module functools.

zip(coll_1,coll_2,...) renvoie une liste de tuples: le premier tuple rassemble tous les premiers éléments des collections (chaînes de caractères, tuples, listes, dictionnaires ou ensembles), le deuxième tuple tous les deuxièmes éléments, etc.:

>>> print zip("abcde",(1,2,3,4,5,6,7),['u','v','w','x','y','z'])
[('a', 1, 'u'), ('b', 2, 'v'), ('c', 3, 'w'), ('d', 4, 'x'), ('e', 5, 'y')]

La liste des tuples est limitée à la longueur de la plus petite collection.

6. Entrées et sorties

6.1 Saisies

raw_input permet de saisir une chaîne, qui ne sera pas évaluée

ch=raw_input("What's your quest? ") permet l'entrée d'une chaîne, suivie d'une saisie

Pour une fonction permettant la saisie des touches de fonctions et flèches, voir le module curses.

En Python 3, raw_input() est supprimé et remplacé par input(), voir ci-dessous.

Saisie d'expression évaluées

En python 2.x, input permet la saisie d'une expression (opération, chaîne de caractères, liste... fonction...), qui sera évaluée

nb=input("Saisir un nombre: ") affiche Saisir un nombre: et attend un nombre et une saisie.
n1,n2,n3=input("3 nombres: ") trois nombres seront entrés séparés par une virgule. ValueError s'il manque un nombre lors de la saisie

input() évalue une expression: NameError si une chaîne n'est pas entourée de guillemets, un calcul est effectué ou une commande peut être exécutée (il faut donc l'utiliser avec précaution):

>>> input()
open("/home/jc/site/index.htm")
<open file '/home/jc/site/index.htm', mode 'r' at 0xb7dd9b18>

eval() évalue une expression Python, sous forme de chaîne:

>>> eval("3*8")
24

Il peut s'agir d'une fonction:

>>> a="Je vous ai compris !"; eval("a.split()")
["Je","vous","ai","compris","!"]

input() équivaut en fait à eval(raw_input()).

En python3, input() n'évalue plus la chaîne et remplace donc raw_input(). Pour retrouver la saisie et l'évaluation d'une expression, utiliser eval(input()) (13, 43 et 59 doivent être saisis, séparés par une virgule).

>>> a,b,c =eval(input("a,b,c: "))
a,b,c: 13,43,59
>>> a
13
>>> b
43
>>> c
59

Ne pas confondre eval avec exec, qui peut exécuter toute une chaîne d'instruction:

>>> exec "from math import sin,pi; print sin(pi/4)"
0.707106781187

En python3, exec() et print() prennent des parenthèses:

>>> exec("from math import sin,pi; print(sin(pi/4))")
0.7071067811865475

6.2 Affichages

Pour formater une chaîne, utilisez format()
Pour une sortie vers un fichier, voir Éditer un fichier.

print "Ni!", 123 affiche la chaîne suivi du nombre
var=123; print var, var*5
var2=123; print "Le double de", var2, "est", var2*2

Chaque 'print' génère un saut de ligne après l'affichage. On peut l'éviter avec une virgule, qui génère un espace:

>>> print 'Nombre',10
Nombre 10

Pour supprimer cet espace, il faut concaténer la chaîne, transformant les nombres en chaîne si besoin est:

>>> nb=10; print 'Nombre'+str(nb)
Nombre10

On peut insérer des variables dans une chaîne, choisies dans un tuple préfixé par %: %():

>>> print "Imprimer le %s %d et %.1f, sa %s" %("nombre", 5, 2.5, 'moitie')
Imprimer le nombre 5 et 2.5, sa moitie

%s pour une sortie générale (chaîne ou nombre)
%9s prévoit 9 caractères minimum pour la chaîne (éventuels espaces à gauche)
%-9s prévoit 9 caractères minimum pour la chaîne (éventuels espaces à droite)
%r entoure une chaîne (mais pas un nombre) de guillemets simples

%d sortie entière de base décimale
%4d pour un minimum de 4 caractères
%04d remplace les éventuels vide par des 0
%i sortie entière

En Python 3.0 et 3.1, print("%,d" %(1234)) permettait d'afficher la virgule séparatrice de milliers

%o sortie octale (base 8): 55 → 67 (6*8+7)
%x sortie hexadécimale (base 16: 0...9, a, b, c, d, e, f): 55 → 37 (3*16+5)
%X sortie hexadécimale (base 16: 0...9, A, B, C, D, E, F)
%c sort le caractère selon son code numérique: 65=A, 66=B, etc.

En Python 3.0 et 3.1, %b permettait la sortie d'un entier en binaire

%e pour une sortie scientifique: 55 → 5,500000e+01
%f sortie décimale (virgule flottante) 5.5 → 5.500000 (6 chiffres après la virgule par défaut)
%9.3f sortie sur 9 caractères, dont un pour le point et 3 pour les décimales
%09.3f la partie entière nulle sera comblée de 0: 4.3 → 00004.300
%.f arrondit (par défaut ou par excès): 5.5 → 6

%% permet d'afficher le caractère %

Pour les codes de contrôle de sortie, dont les couleurs, voir le module curses et les séquences ECMA-48.

En Python 3, print est remplacé par la fonction print():
print("Eggs & spam") remplace print "Eggs & spam" (avec saut de ligne)
print(("Eggs","Spam")) affiche le tuple ('Eggs', 'Spam')
print("J'ai", 23, "ans", sep="-") permet de remplacer l'espace (séparateur par défaut) par une chaîne
print("Eggs", end=" ") remplace le saut de ligne par un caractère (ici, l'espace). Attention: une suite de print(chaine,end="") ne sera affichée qu'à partir du premier print() contenant un saut de ligne. Ne convient pas pour afficher une barre de progression horizontale.

En Python 2.6, on peut utiliser print() grâce à from __future__ import print_function (première ligne du script ne commençant pas par '#')

repr(objet) conditionne un objet pour son affichage complet, surtout intéressant avec les chaînes:

>>> a="C'est déjà ça"
>>> a; print a; print repr(a)
"C'est d\xe9j\xe0 \xe7a"
C'est déjà ça
"C'est d\xe9j\xe0 \xe7a"

6.3 Fichiers-textes

Le module 1.3 os permet également de manipuler les fichiers.

descr=file("/chemin/fichier") ouvre un fichier en lecture, descr est ici son descripteur:

>>> descr=file("votrefichier")
>>> type(descr)
<type file>
>>> print descr
<open file 'votrefichier', mode 'r' at 0x401d13a0>

C'est sur le descripteur que s'appliquent les méthodes décrites

descr.mode renvoie le mode d'ouverture du fichier, dans ce cas-ci 'rw' ('r' par défaut)
descr.closed est vrai (True) si le fichier est fermé, False sinon
descr.name renvoie le nom du fichier
fich.fileno() est un numéro d'ouverture de fichier

descr.close() referme un fichier ouvert et enregistre un fichier créé ou édité ('w')
id(descr) donne l'identifiant de la variable descr. Pour une variable locale, il est possible qu'il existe plusieurs identifiants en cas de récursion.
hash(descr) donne l'identifiant de la donnée contenue dans la variable descr.

Attention: open() peut remplacer file(), mais peut interférer avec le module 1.3 os.

Lire un fichier

fd=file("/chemin/fichier",'r') ouvre un fichier en lecture seulement
chaine=fd.read() charge entièrement le fichier dans une variable
chaine=fd.read(n) ne charge qu'un nombre limité de n octets

fd.readline() lit une ligne d'un fichier texte et se place sur la suivante pour un appel ultérieur (le plus souvent utilisé dans une boucle)
liste=fd.readlines() place toutes les lignes dans une liste, \n compris

Il existe une syntaxe très simple pour traiter une à une les lignes d'un fichier-texte:

descr=file("monFichier.txt",'r')
for ligne in descr:
  print ligne,                   # ',' pour ne pas ajouter une nouvelle ligne

ou même

for ligne in file("monFichier.txt",'r'):
  print ligne,

...ce qui semble rendre readline() inutile.

Attention! Les trois grands systèmes n'utilisent pas le même signalement de fin de ligne (en fait fin de paragraphe): octet 13 pour Mac, octet 10 pour Unix et les deux octets 13 et 10 pour le DOS et dérivés. De ce fait, rien ne dit qu'il est possible de lire un fichier d'une autre plateforme ligne par ligne. La fin de fichier DOS, contenant les deux octets, ne pose pas de problème pour Unix et Mac, mais l'intercompréhension entre ces deux dernières n'est pas garantie.

Éditer un fichier

descr=file("/chemin/fichier",'w') crée ou ouvre un fichier en écriture
descr.write(chaine) écrit une chaîne dans un fichier, sans retour-chariot, qui est à ajouter ('\n')
descr.writelines(liste) écrit toutes les chaînes de la liste
descr.close() ne pas oublier de refermer, et donc enregistrer, un fichier édité

descr=file("/chemin/fichier",'a') ouvre ou crée un fichier en ajout d'écriture (idéal pour un .log)

Attention! Les fins de lignes ne sont pas automatiquement ajoutées par write().

Les modifications s'opèrent dans une variable-tampon, pas directement sur le disque. Donc:

descr.close() enregistre et ferme un fichier édité
descr.flush() force l'enregistrement, sans refermer le fichier

descr=file(nom,'r+') permet la lecture et l'ajout à un fichier.

Il est possible de rediriger les sorties print vers un fichier-texte:

#! /usr/bin/python
# -*- coding: latin-1 -*-

descr=open("monFichier.txt",'a') # ouverture en ajout d'un fichier

print "kjsdfg" # sortie habituelle, vers la console
li=[1,[2,3],4]
print >> descr, li # sortie vers monFichier.txt

descr.close() # inscrit les donnees et ferme le fichier

En Python 3, la syntaxe est print("Eggs", file=open("fichier","w")). Le fichier de sortie par défaut, pour autant que le module sys soit chargé (import sys) est la console, sys.stdout.

6.4 Autres fichiers

Fichiers "relatifs"

Un fichier relatif ("random access") est directement accessible à n'importe quel endroit, sans considération de paragraphe, sans utiliser readlines() et writelines. On pointe un octet particulier avant de lire ou écrire n octets.

descr.seek(43,0) pointe le 44ème octet à partir du début du fichier (,0 facultatif)
descr.seek(13,1) pointe 13 octets plus loin, à partir de la position courante
descr.seek(-5,2) pointe 5 octets avant la fin du fichier ('2')
descr.tell() retourne le décalage courant
descr.write(chaine) écrit une chaîne et ajoute len(chaine) au pointeur
descr.read(n) lit et retourne une chaîne de n octets

Notes:

Fichiers "binaires"

L'ajout de 'b' (pour binaire): 'rb', 'rwb', 'wb', 'ab' permet l'ouverture de fichier en mode binaire et non plus en mode 'texte': tous les octets, de 0 à 255 peuvent y être inscrits. Les octets de fin de paragraphe (10 et/ou 13 selon les systèmes) sont considérés comme de simples données.

Voir également le module os permettant de manipuler les fichiers.

7. Fonctions 'utilisateur'

En mathématique (analyse), une fonction retourne une et une seule valeur. Pour beaucoup de langages de programmation, les "fonctions" peuvent renvoyer plusieurs valeurs, une chaîne, l'adresse d'un tableau, voire ouvrir un fichier ou imprimer un message d'erreur (cela devrait alors s'appeler une procédure).

En Python, une fonction est toute partie de code qui peut être écrit en dehors d'une structure et qu'il est possible d'appeler de n'importe quel endroit du programme. Il est même possible de les écrire dans un autre fichier, appelé module, que l'on pourra importer (voir modules utilisateurs).

Les noms de fonction suivent les mêms règles que les noms de variable.

En Python 3, les noms de fonction (et de variable) peuvent contenir des lettres accentuées. Cette nouvelle utilisation n'est pas conseillée dans le cadre d'un projet international, car même si l'UTF8 permet un codage universel de ces caractères, tous les claviers n'ont pas les mêmes facilités à produire toutes les lettres accentuées. Pour vous en convaincre, tentez š, æ, å... avec un clavier azerty...

Les fonctions servent à ne pas répéter le même code à plusieurs endroit du programme, ce qui constitue un gain de place, permet une maintenance plus simple et une lecture plus globale, le coeur du programme pouvant être une séquence très courte et assez explicite. À condition de prévoir de façon adéquate les fonctions lecture(), trouver_liens(), ajout() et suivant(), le noyau d'une application peut ressembler à ceci:

cpt=0
while True
  page=lecture("fichier"+str(cpt))
  liens=trouver_liens(page)
  sortie=ajout("fichiersortie", liens)
  cpt+=1
  suivant()

Certains mots sont réservés à python et ne peuvent donc pas être utilisés comme nom de fonction (ou de variable): and - assert - break - class - continue - def - del - elif - else - except - exec - finally - for - from - global - if - import - is - lambda - not - or - pass - raise - return - try - while - yield

À partir de Python 2.6, with et as sont également réservés. Ils le sont également en Python 2.5 en cas de spécification from __future__ import with_statement sur la première ligne ne commençant pas par '#').

En Python 3, print et exec ne sont plus des mots réservés, car remplacés par les fonctions print() et exec().

7.1 Fonction anonyme lambda

lambda x: permet une définition simple de fonction:

carre=lambda x: x**2
print carre(5)

Les fonctions anonymes permettent également de définir une fonction à l'intérieur d'une instruction de Python.

>>> filter(lambda x: 117 > ord(x) > 111, "python")
'pt'

Cette écriture peut être remplacée par une liste en compréhension:

>>> "".join([x for x in "python" if 117 > ord(x) > 111])

qui peut se traduire: joindre les lettres contenues dans la chaîne 'python' à condition que leur code ascii se situe entre 111 et 117.

La fonction lambda est conservée en Python 3, malgré le vœu de Guido Van Rossum de l'abandonner.

7.2 Fonction classique

def fonction(arg1, arg2...) permet la définition d'une fonction définie par l'utilisateur. La valeur envoyée dans la fonction peut être un nombre, une variable ou une autre fonction. La valeur est reçue dans la définition de la fonction par une autre variable (ici arg) multipliée par deux et affichée à l'écran. Exemple:

def double(arg):
  print arg*2
print double(5)

Il est possible de définir une valeur par défaut. La réponse ici sera 20 parce qu'aucune valeur n'est précisée dans l'appel):

def double(arg=10):
  print arg*2
double()

La définition de la fonction doit être placée avant l'appel. L'exemple suivant retournera une erreur, affiche() n'étant pas connu de l'interpréteur lorsque celui-ci rencontre sortir():

def sortir(nbr):
  affiche(str(nbr)*nbr) # le nombre répété nbr fois sous forme de chaîne

sortir(5)

def affiche(chaine):
  print chaine

Même si la fonction affiche() suit la fonction sortir(), elle est connue de l'interpréteur lorsque celui-ci rencontre sortir():

def sortir(nbr):
  affiche(str(nbr)*nbr) # le nombre répété nbr fois sous forme de chaîne

def affiche(chaine):
  print chaine

sortir(5)

return

return arrête une fonction (par exemple dans une condition) et retourne la valeur None
return expression arrête la fonction et retourne la valeur (ou un tuple si les valeurs sont multiples)

def double(var):
  return var*2
for i in range(1,11):
  print double(i)

Dans le cas où plusieurs variables par défaut sont définies, il est possible de préciser la variable que l'on passe:

def mult(x=1,y=10):
  return x*y
print mult(x=3)
print mult(y=4)

Variables locales et globales

Une variable initialisée à l'intérieur d'une fonction est locale: elle est séparée de celles utilisées dans le reste de l'application ou initialisées dans d'autre fonctions. Remarquez la différence entre les deux print ch:

def chaine():
  ch="eggs"
  print ch # affichera eggs

ch="spam"
chaine()
print ch # affichera spam

Si l'on veut qu'une variable initialisée dans une fonction soit utilisable par le reste de l'application (et dans d'autres fonctions), il faut indiquer juste après la ligne def l'instruction global reprennant la liste des variables globales séparées par des virgules (global var1,var2,var3 pour plusieurs variables globales).

def chaine():
  global ch
  ch="eggs"

ch="spam"
chaine() # la fonction chaîne() modifiera la variable globale ch
print ch

Passage d'arguments spéciaux

Il est possible de passer des *tuples ou des **dictionnaires en paramètres:

def egrener(*tup,**dic):
  for i in tup:
    print i
  print
  for i in dic:
    print i, dic[i]

egrener(*(1,3,5,7,9),**{'a':7,'b':8,'c':3})

Cela remplace l'appel apply(egrener,(1,2,3),{"4":56,"6":54,"7":48}) (sans astérisque). Il est possible d'envoyer une liste à la place d'un tuple, mais celle-ci sera réceptionnée comme un tuple (pas question d'en changer un élément).

Fonction locale

Il est possible de définir une fonction locale, en l'incluant dans une autre fonction:

def euler(max):
  def fact(x):
    if x==0: return 1
    return x*fact(x-1)
  somme= 0
  for k in range(max):
    somme+=1./fact(k)   # '1.' pour que le résultat ne soit pas entier (version < 3.0)
  return somme
print euler(16)

print fact(5) # déclenche une erreur: fact() n'est défini que pour la fonction euler()

Récursivité

Une fonction peut s'appeller elle-même (récursivité). Il est alors indispensable de prévoir (au moins) une sortie:

def fact(x):
  if x==0: return 1
  return x*fact(x-1) # la fonction s'appelle elle-même
print fact(10)

...la valeur étant décrémentée jusqu'à 0; à ce moment, le calcul x*(x-1)*(x-2)...*1 est effectué et retourné.

Modification de fonctions de Python

Il est possible de modifier les fonctions internes de Python en les redéfinissant: cmp(), int(), long(), float(), complex(), coerce(), oct(), hex(), len(), abs(), divmod()... mais pas les mots réservés comme while, import, for, if...

Voir la recette pour une redéfinition de la fonction cmp().

7.3 Génération avec yield

Il est possible d'utiliser une fonction pour générer une série de valeurs, stockées une à une par l'instruction yield. L'exemple suivant donne les approximations successives (16 termes demandés dans l'appel) du nombre e, par la formule Σ(1/x!), soit 1 + 1 + 1/2 + 1/6 + 1/24...

def fact(x): # ceci est une fonction 'utilisateur' classique
  if x==0: return 1
  return x*fact(x-1)

def euler(max):
  somme= 0
  for k in range(max):
    somme+=1./fact(k)   # le point décimal après le '1' pour que le résultat ne soit pas entier
    yield somme         # l'instruction yield engrange la valeur

for i in euler(16):     # les 16 approximations successives de 'e' par la formule d'Euler
  print i

print type(euler(16))   # confirmation que euler(16) est bien de type 'generator'

L'instruction yield est pleinement disponible depuis la version 2.3; elle n'est disponible avec la version 2.2 qu'à condition de préciser en début de programme (future est précédé et suivi de deux tirets bas, et doit figurer sur la première ligne ne commençant pas par '#'):

from __future__ import generators

7.4 Module 'utilisateur'

Il est possible de regrouper des fonctions qui seront utilisées par plusieurs applications dans un fichier (par exemple monmodule.py, l'extension .py est nécessaire) que l'on appelle dans une application avec import monmodule (sans .py). Sauvegardons par exemple les deux fonctions déjà vues plus tôt, dans le fichier matsup.py:

# -*- coding: utf8 -*-
# écrit en Python 2.3.5 -- www.jchr.be -- copyleft GPL 2 -- 2006.12.20
"""MATSUP: un module juste pour essayer"""

# définition d'une constante
e=2.7182818

def fact(n):
  """Renvoie la factorielle d'un nombre: 1, 1, 2, 6, 24, 120..."""
  if n==0: return 1
  else: return n*fact(n-1)

def euler(i):
  """Valeur approchée de 'e' après 'i' itérations: 1, 2, 2.5, 2.66..., 2.70833..."""
  somme= 0
  for k in range(i):
    somme+=1./fact(k)   # le point après le '1' pour que le résultat ne soit pas entier
  return somme

Dans le mode interactif, importons-le, et interrogeons-le:

>>> import matsup
>>> matsup.euler(10)
2.7182815255731922
>>> matsup.e
2.718281828
>>> import math
>>> math.e
2.7182818284590451

Vous avez la possiblité (et le devoir) de commenter votre module """dans chaque fonction""":

>>> help(matsup.fact)
fact(n)
    Renvoie la factorielle d'un nombre: 1, 1, 2, 6, 24, 120...

Essayez également help(matsup) et help(matsup.euler).

On annule un module avec

>>> del(module)

Notes

8. Programmation-objet

La programmation orientée objet (POO) vous permet de définir et utiliser vos propres variables structurées ainsi que leurs comportements. On commence par définir une classe d'objets, c'est-à-dire un objet générique et ses composants:

Les avantages sont nombreux: une fois qu'une variable est instanciée par UneVariable=VotreClasse(paramètres) il en découle toute une série d'attributs, les objets bénéficient de méthodes qui leur sont propres; il est même possible de redéfinir les opérateurs classiques comme les + , * , ==...

8.1 Classe et attributs

Le premier script ci-dessous définit une classe d'individus définis par une hauteur et un poids, et pour lesquels l'indice de masse corporelle sera automatiquement calculé.

La méthode __init__ y réceptionne les valeurs par les paramètres ht et pds. Le paramètre self représentera l'objet dans toute la définition de la classe.

Chaque argument de réception est ensuite fixé à l'objet par self. Pour nouvel objet créé dans le script par une instanciation (par exemple x=individu(178,75)), x.hauteur représentera sa taille et x.poids son poids. Un troisième attribut est aussi calculé: l'indice de masse corporelle (le poids divisé par le carré de la taille, arrondi ici à une décimale), x.IMC.

#! /usr/bin/python

class individu:
  def __init__(self, ht, pds):
    self.hauteur=float(ht)/100
    self.poids=float(pds)
    self.IMC=round(self.poids/self.hauteur/self.hauteur, 1)

toto=individu(178,75)
print toto.hauteur, toto.poids, toto.IMC

L'exécution de ce premier script de programmation-objet permet de voir que dès que l'objet toto est défini (instanciation), l'attribut IMC est automatiquement calculé et disponible.

8.2 Méthodes

Une classe ne se limite en général pas à la définition de __init__(). L'intérêt de la programmation objet est aussi de définir des méthodes spécifiques aux objets d'une classe. Dans le script qui suit, une autre façon de calculer le poids idéal est défini. On peut appeler la méthode comme s'il s'agissait de la fonction d'un module importé: individu.ideal(toto), mais il est plus pratique d'utiliser toto.ideal(), python cherchant ideal() parmi les méthodes de l'objet m préalablement défini.

#! /usr/bin/python
# -*- coding: latin-1 -*-

class individu:
  def __init__(self,sx,ht,pds):
    """sexe: M=1, F=2; hauteur: en metres; poids: en kilos"""
    self.sexe=sx
    if (1>self.sexe or self.sexe>2): raise("1 pour les hommes; 2 pour les femmes")
    self.hauteur=float(ht)
    self.poids=float(pds)
    self.IMC=round(self.poids/self.hauteur/self.hauteur,1)

  def ideal(self):
    taux=1 # calcul pour un homme
    if self.sexe==2: taux=.9 # révision à la baisse pour les femmes
    return ((self.hauteur*100-150)*3/4+50)*taux

  def diagnostic(self):
    if self.IMC<15: return "- Maigreur extrême (< 15): grand risque de maladie"
    if 15<=self.IMC<18.5: return "- Maigreur (15-18,5): risque de maladie"
    if 18.5<=self.IMC<25: return "- Poids idéal (18,5-25): peu de risque de maladie"
    if 25<=self.IMC<30: return "- Surpoids (25-30): risque accru de maladie"
    if 30<=self.IMC<35: return "- Obésité modérée (30-35): risque élevé de maladie"
    if 35<=self.IMC<40: return "- Obésité sévère (35-40): risque très élevé de maladie"
    if 40<=self.IMC: return "- Obésité morbide (> 40): risque extrême de maladie"

  def anamnese(self):
    print "Pour adultes, exceptés sportifs et femmes enceintes ou qui allaitent"
    print "Sexe:", self.sexe, "-", self.hauteur,"m,", self.poids,\
    "Kg - Poids idéal (autre formule) :", self.ideal()
    print "IMC:", self.IMC, self.diagnostic()

toto= individu(2,1.78,75)
toto.anamnese()

Notes:

import MaClasse

nana= MaClasse.individu(2, 1.78, 75)
nana.anamnese()

8.3 Surcharge des opérateurs

Certaines méthodes, représentent les opérateurs habituels '+ - % < / //...', permettent de redéfinir ces opérations pour les adapter aux objets: on n'additionne pas de la même manière des nombres, des chaînes ou des matrices... C'est ce qu'on appelle «surcharger – en fait: redéfinir – un opérateur». Pour surcharger l'addition + entre deux instances, on écrit une méthode __add__(). Écrivons une addition de vitesses qui tienne compte de la correction relativiste (seulement sensible pour les vitesses élevées):

#! /usr/bin/python

class vr:
  """Correction relativiste de l'addition de vitesses"""
  def __init__(self,c):
    self.c=float(c)
    if c>300000000:
      c=300000000

  def __add__(premier,second):
    return (premier.c + second.c)/(1+premier.c*second.c/(9e16)

a=vr(5) # en m/s!
b=vr(11000000)

print a+b

Tout le monde n'étant pas concerné par la théorie de la relativité, voici un second exemple de surcharge d'opérateur, où l'on réécrit la comparaison d'égalité, en y incluant une tolérance de 5%:

#! /usr/bin/python

class individu:
  def __init__(self,ht,pds):
    self.hauteur=float(ht)
    self.poids=float(pds)
    self.IMC=round(self.poids/self.hauteur/self.hauteur,1)

  def __eq__(premier,second):
    if abs(premier.IMC-second.IMC)/max(premier.IMC,second.IMC)<.05:
      return True
    else:
      return False

a=individu(1.81, 82)
b=individu(1.70, 67)
print a.IMC, b.IMC, a==b

Comme il s'agit d'un test, on retourne True ou False, ce qui permet d'utiliser le test dans une condition: if (a==b):

D'autre part, Python est capable, à partir d'une opération binaire, d'enchaîner deux opérations:

a=individu(1.70, 70)
b=individu(1.70, 73)
c=individu(1.70, 76)
print a.IMC, b.IMC, c.IMC, a==b==c, a==c

donne le résultat suivant (a et c sont trop différents):

24.2 25.3 26.3 True False

Méthodes de comparaison (self, other)

__lt__() pour <, __le__() pour <=, __eq__() pour ==, __ne__() pour !=, __gt__() pour >, __ge__() pour >=, __contains__() pour in.

Méthodes unaires (self)

__neg__() pour -, __pos__() pour +, __invert__() pour ~ (tilde).

Méthodes binaires classiques (self, other)

__add__() pour +, __sub__() pour -, __mul__() pour *, __div__() pour /, __floordiv__() pour //, __mod__() pour %, __pow__() pour **, __lshift__() pour <<, __rshift__() pour >>, __and__() pour &, __xor__() pour ^, __or__() pour |, __truediv__() pour / (Python 3).

Méthodes binaires abrégées (self, other)

__iadd__() pour +=, __isub__() pour -=, __imul__() pour *=, __idiv__() pour /=, __ifloordiv__() pour //=, __imod__() pour %=, __ipow__() pour **=, __ilshift__() pour <<=, __irshift__() pour >>=, __iand__() pour &=, __ixor__() pour ^=, __ior__() pour |=, __itruediv__() pour /= (Python 3).

Fonctions Python

Il est possible de surcharger (redéfinir) les fonctions de Python cmp(), int(), long(), float(), complex(), coerce(), oct(), hex(), len(), abs(), divmod()... avec une structure def cmp(x, y): , mais pas les mots réservés comme print, import, for...

8.4 Autres fonctions [en cours d'écriture]

MonObjet=object() permet de créer une classe à partir de rien.
isinstance(obj,classe) retourne True si l'objet (instance) appartient à la classe
issubclass(sub,classe) retourne True si sub dérive de classe
dir() liste de noms dans la portée locale
dir(inst) liste les noms de méthodes et d'attributs définis pour une instance
hasattr(inst,'attr') retourne True si l'attribut existe pour l'objet
getattr(inst,'attr') retourne la valeur d'un attribut pour une instance
setattr(inst,'attr',val) fixe une valeur à l'attribut d'une instance, comme obj.attr=val
delattr(inst,'attr') détruit l'attribut d'une instance (nom est une chaîne) = del obj.attr
callable(expr) retourne True si l'expression est appelable: les classes et les fonctions internes ou définies par les utilisateurs ou dans les modules (et doit alors être préfixée), mais pas les mots réservés.

9. Informations complémentaires

9.1 Documentation dans le logiciel Python

Dans le mode interactif (obtenu en saisissant python dans une console), vous en saurez plus sur la licence avec

  >>> print copyright
  >>> print license()

Si le paquet python2.6-doc a été installé (nom du paquet pour Debian, on quitte avec la touche [q]):

help rentre dans l'aide interactive
help(fonction) informe sur une fonction ou un module interne ou chargé
help("mot-clé") les guillemets sont obligatoires pour les informations sur un mot-clé (for, while...)

Voir le fichier consacré aux modules.

9.2 Documentation sur votre système GNU+Linux

Si Python est installé, saisir man python dans une console renseigne sur les différentes manières de lancer Python.

Le script /usr/bin/pydoc permet la consultation d'informations sur les fonctions, modules, mots-clés:
pydoc math présente succinctement les fonctions du module math, équivaut à help() plus haut
pydoc divmod présente succinctement la fonction divmod, équivaut à help() plus haut
pydoc keywords liste les mots-clés sur lesquels il y a une information
pydoc -g lance une interface graphique pour une navigation dans le système d'aide

/usr/share/doc/python contient quelques fichiers d'aide
/usr/share/doc/python2.6-doc/html si le paquet python2.6-doc a été installé (nom du paquet pour Debian)

Le nom des paquets et les adresses peuvent varier selon les distributions et les versions.

9.3 Documentation sur Internet

Documentation officielle (anglais)

Documentation en français