Le langage Python est un langage de programmation des plus complets 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 accessible 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. Il est sous une licence proche de la 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 (bientôt dix ans!) comme manuel de références personnel. Elle prétend maintenant faciliter la prise en main du langage Python sous GNU+Linux, pour 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 changements pour le passage à Python 3.
1. Prise en main
1.1 Installation 2. Structure
2.1 Syntaxe 3. Nombres
3.1 Types de variables numériques 4. Chaînes
4.1 Affectation |
5. Collections
5.1 Listes [ ] 6. Entrées et sorties
6.1 Saisie 7. Fonctions et modules 'utilisateurs'
7.1 Fonction anonyme lambda 8. Programmation-objet
8.1 Classe et attributs 9. Informations complémentaires
9.1 Doc sur le logiciel Python |
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)
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:
[su] apt-get install python idle-python2.6
Sous SuSE, Mandrake et Fedora, vous devriez pouvoir utiliser une ligne de commande du type:
[su] 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. Pour les versions antérieures, il faut récupérer 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 ./configure, make et [su] make install. L'application se lance avec python3.
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]
Un script est un fichier de programmation, rédigé avec un simple éditeur de texte. Supposons que le fichier script.py se 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
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, il faut préciser la version:
#! /usr/bin/python3.1
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 (clic droit sur le fichier dans KDE/konqueror). 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>.
Éditer le fichier suivant:
#! /bin/bash gnome-terminal -e "python -Q new $1"
Donner les droits d'exécution sur ce script (clic droit sur le fichier, Propriétés / Permissions)
Marquer les fichiers python:
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...
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
Pour une utilisation de la division réelle, voir ci-dessus Avec Gnome
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.
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.
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:
>>> import votrefichier
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.
>>> import votrefichier
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.
Cette section est générale pour les différents types de variables.
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 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-fr ou azerty-be...
Certains mots sont réservés à Python et ne peuvent donc pas être utilisés comme nom 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 en début de fichier.
En Python 3, print n'est plus un mot réservé, car remplacé par la fonction print().
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 range(9): ou def fonct(i=0,j,k):
Attention! Toutes les variables ne sont pas 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)
id(gj) donne l'identifiant de la variable qj. Pour une variable locale, il est possible qu'il existe plusieurs identifiants en cas de récursion.
hash(zot) donne l'identifiant de la donnée contenue dans la variable zot; cet identifiant sert à ce que deux variables identiques ne servent pas comme clé de dictionnaire, qui doivent être uniques.
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.
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é != ou encore <> (en désuétude: à éviter)
>>> a=2 >>> a!=3 True
< plus petit que
<= plus petit ou égal à
> plus grand que
>= plus grand ou égal à
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: les expressions contenant or et and renvoient le dernier nombre évalué. Quand l'interpréteur rencontre l'expression 13 or 56, il se dispense d'évaluer 56, 13 étant différent de 0 et donc déjà vrai; en rencontrant 13 and 56, l'interpréteur doit par contre évaluer le 56 puisque le premier terme vrai ne suffit pas: 3 and 5 vaut 5 car le second terme a dû être évalué, 5 and 3 vaut 3.
0, None, "", [] et {} peuvent représenter la valeur False; toute valeur différente de 0, None, ou toute collection (chaîne, liste, tuple ou dictionnaire) non vide ('0' et [0] ne sont pas vides) peut représenter la valeur True. True et False sont des valeurs booléennes qui servent à permettre ou interdire une action dans une structure conditionnelle, mais valent respectivement 1 et 0 dans les opérations arithmétiques:
>>> a=3; print 5*(a==3) 5
True peut valider une chaîne par multiplication; False l'annihiler:
>>> nb=3; print nb,"oeuf"+"s"*(nb>1), "w"*False 3 oeufs
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
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.
for var in range(10) : # range(10) génère la liste [0,1,2,3,4,5,6,7,8,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".
La succession de valeurs prises par la variable peut également provenir d'une liste ou d'un tuple:
for i in (1,"trois",5,"spam",8,16): print i
...d'une chaîne:
for i in "Cumpapade": print i
...ou d'un dictionnaire:
dic={1:"un", 2:"deux", 3:"trois"}
for i in dic.keys(): # i parcourt les clés
print i, dic[i] # dic[i] renvoie chacune des valeurs
On peut imbriquer les boucles (notez les indentations successives):
#! /usr/bin/python
# -*- coding: latin-1 -*-
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 # ce print ajoute un 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
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. 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
En Python 2.6, il ne faut plus préciser from __future__ import with_statement
Les types d'erreurs définis dans le module exceptions.py:
Et voici les avertissements:
DeprecationWarning, FutureWarning, OverflowWarning, PendingDeprecationWarning, RuntimeWarning, SyntaxWarning, UserWarning, Warning
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
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
En Python 3, les entiers sont tous illimités. Le suffixe L et la fonction long() sont abandonnés.
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
= 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 donne une réponse entière, approchée 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
En Python 3, la division / n'est plus entière: 7/4 vaudra 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: cela ne limite pas le nombre de chiffre après
la virgule (voir print):
>>> round(3.14159,2) 3.1400000000000001
En Python 3, si le nombre est un entier, le résultat de round(n) est également un entier.
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 (ou x/y pour x,y entiers et sans from __future__ import division)
divmod(x,y)[1] équivaut à 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".
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
En Python 3, bin() 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: bi=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.
En Python 3, long() est supprimé, puisque tous les entiers sont considérés comme illimités.
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 2.3 Comparaisons et booléens.
Pour les généralités sur les variables, voir la section variables et assignations.
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 chaine en plusieurs lignes""" # sans commentaire à l'intérieur!
a=intern("Camelot") 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.
del var ou del(var) supprime une variable, de quelque type que ce soit
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.
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"
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
del ch ou del ch détruit la variable chaîne
* 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'
Python3: format(n,'') retourne un chaîne formatée, valable avec les lettres d, o, x, c, e de print. Une virgule permet la séparation des milliers.
>>> format(1234.56,'010.3f') '001234.560' >>> format(123456,',d') '123,456'
Il est possible de remplir une chaîne lacunaire (sans les numéros d'ordre: dans l'ordre présenté par format).
>>> "{1} et {0}".format('Roméo','Juliette')
Juliette et Roméo
filter(fonction, chaine) renvoie une chaîne filtrée par une fonction, éventuellement créée pour l'occasion avec lambda
>>> filter(lambda x: 117>ord(x)>111, "python") 'pt'
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
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 iso-8859-1
(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; le code 173 est ­, la possibilité de césure, mais sa valeur n'est pas universellement reconnue, paraît-il.
r'chaine' permet le codage d'une chaîne littérale, où les codes \- ne sont pas évalués:
>>> r"codage\nsans saut de ligne" codage\nsans saut de ligne
Il est possible d'utiliser les caractères spéciaux dans les chaines et commentaires en utilisant une directive d'encodage (PEP-263) à mettre sur la seconde ligne:
#! /usr/bin/python # -*- coding: iso-8859-1 -*- print "Déjà où" # chaîne et commentaires écrits avec des accents
Un synomyme de iso-8859-1 est latin-1 . Pour disposer des € et œ, spécifier latin-15 ou iso-8859-15.
Notes:
Le standard qui tend à s'imposer est l'UTF-8, qui code les caractères spéciaux sur plusieurs octets: de ce fait, il est possible de coder dans un même fichier-texte tous les caractères typographiques, arabes, thaï, coréen et même chinois et japonais. Pour ce faire, les caractères "ascii" (signes usuels et lettres non accentuées, code inférieur à 128) restent les mêmes, les autres étant codés sur deux ou quatre octets supérieurs à 128.
Pour permettre les chaînes et commentaires en unicode, les scripts doivent commencer par:
#! /usr/bin/python # -*- coding: utf-8 -*-
De la même manière que ci-dessus, l'éditeur de texte utilisé et la console qui lance le script doivent être configurés dans l'encodage UTF-8.
unicode("chaine","encodage") retourne un objet Unicode selon l'interprétation d'une chaîne par un encodage:
>>> unicode("ð",'latin-1')
u'\xf0'
>>> unicode("ð",'utf-8')
u'\xf0'
>>> print unicode("ð","utf-8") # en UTF-8, "ð" code le caractère "ð"
ð
>>> print unicode("ð","iso-8859-1") # en latin-1, "ð" est lu littéralement
ð
>>> print unicode("ð","iso-8859-1") # en latin-1, "ð" est lu littéralement
ð
>>> print unicode("ð","utf-8") # "ð" ne code pas un caractère UTF-8
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
UnicodeDecodeError: 'utf8' codec can't decode byte 0xf0 in position 0: unexpected end of data
>>> print unicode("ð") # le code pour "ð" n'est pas 'ascii' (de 0 à 128)
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
UnicodeDecodeError: 'ascii' codec can't decode byte 0xf0 in position 0: ordinal not in range(128)
unichr(entier) retourne un caractère Unicode:
>>> unichr(123)
u'{'
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 (set)...) c'est-à-dire de variables composées. Même les chaînes sont considérées comme des listes simples de caractères.
Deux fonctions sont applicables sur les collections présentées dans ce chapitres:
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]
enumerate(coll) génère des paires (numéro d'ordre, caractère) à partir d'une chaîne, ou (numéro d'ordre, élément) à partir de listes, tuples, ensembles ou dictionnaires (dans ce dernier cas, ce sont les clés qui forment la seconde valeur de la paire):
>>> for i in enumerate("ab cde"): print i,
(0,"a"), (1,"b"), (2," "), (3,"c"), (4,"d"), (5,"e")
En Python 2.6, on peut ajouter un début: enumerate(coll,start=entier)
Une liste est une collection ordonnée d'objets modifiables (nombres, chaînes, listes, 4.5 tuples, 4.8 dictionnaires...). 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, voire une autre liste).
li= [2,"oh",[6,3],9,47] définit la liste li, composée de 5 valeurs: le nombre 2 est au décalage 0, la chaîne "oh" est au décalage 1, la liste [6,3] au décalage au 2, etc.
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
Une chaîne étant une liste de caractères:
>>> li= [1,"eggs"]; print li[1][3] 's'
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
reversed(liste) retourne un itérateur (objet "reverse") formé de l'inversion d'une liste:
>>> for i in reversed([12,34,56,78]): print i, 78 56 34 12
del li supprime la variable li>
type(expr) renvoie <type 'list'> si l'expression est une liste
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() donne un identifiant de la donnée contenue d'une variable. Deux variable de même valeur partagent
la même valeur "hash", ce qui permet la comparaison de clés d'un dictionnaire.
all() retourne True si aucun élément d'une liste est faux (la liste peut être vide)
any() retourne True si au moins un élément d'une liste est vrai (différent de
0, None, "", [], (), {}...)
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]
sum(lst) additionne toutes les valeurs d'une liste composée uniquement de nombres
La comparaison entre deux listes 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
max(x) renvoie le plus grand élément de la liste
min(x) renvoie le plus petit élément de la liste
max(x,y) renvoie la liste dont la première valeur est plus grande, sinon la seconde, etc.
min(x,y) renvoie la liste dont la première valeur est plus petite, sinon la seconde, etc.
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)
len(liste) renvoie le nombre d'éléments d'une liste, ou d'une sous-liste:
>>> li=[2,5,4,[1,8,7]] >>> print len(li), len(li[3]) 4 3
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.sort() trie la liste exprimée sous forme de variable
li.reverse() inverse une liste exprimée sous forme de variable
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
nv=reversed([8,1,3,5,4]) renvoie un itérateur de la liste inversée
>>> sorted(["B","a","b","A"],key=str.lower) ['a', 'A', 'B', 'b']
reverse=True ajouté à sort() et sorted() permet de renverser la liste
key=operator.itemgetter(n) permet de définir la colonne (n) sur laquelle la liste doit être triée (import operator en début de fichier).
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']
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]
Cela permet de définir des listes en compréhension:
>>> [x**2 for x in range(10)] [0, 1, 4, 9, 16, 25, 36, 49, 64, 81] >>> [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:
>>> [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]
...où chaque résultat égal à un multiple de trois est éliminé.
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 Python3, range a le comportement de xrange(), qui est abandonné.
map(fonction,variable) traite les éléments d'une chaîne ou d'une liste par la fonction indiquée
>>> map(ord,'python') # donne les codes numéraux de la chaîne [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... 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. reduce(lambda x,y: x+y,range(1,7)) est aisément remplacé par sum(range(1,7)).
En Python 3, cette fonction doit être importée du module functools; elle est y déjà disponible en Python 2.6.
Un tuple (parfois traduit par n-uple) est une collection ordonnée d'éléments (chaînes, nombres, listes, tuples...). Un tuple 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
tuple() transforme une séquence (liste, chaîne) ou rassemble les clés d'un dictionnaire en tuple
reversed(tuple) retourne un itérateur formé de l'inversion d'un tuple (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,34,56,78)): print i, 78 56 34 12
del tup[1:3] renvoie TypeError: 'tuple' object does not support item deletion
del tup ou del(tup) détruit la variable tup
type(var) renvoie <type 'tuple'> si l'expression est un tuple
len(tup) renvoie le nombre d'éléments d'un tuple. len((1,(2,3),4)) ne contient que 3 éléments
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
all() retourne True si aucun élément d'un tuple est faux (le tuple peut être vide)
any() retourne True si au moins un élément d'un tuple est "vrai" (différent de 0, None, "", [], (), {}...)
sum(tup) additionne les valeurs d'un tuple, TypeError s'il ne s'agit pas de nombres
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
zip(lst1,lst2) renvoie une liste de tuples: le premier tuple rassemble tous les premiers éléments des séquences (tuples, listes ou chaînes), le deuxième tuple tous les deuxièmes éléments, etc.:
>>> print zip("abcde",(1,2,3,4,5),['v','w','x','y','z'])
[('a','1','v'), ('b','2','w'), ('c','3','x'), ('d','4','y'), ('e','5','z')]
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'
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"
reversed({1:12,2:34,3:56,4:78}) renvoie TypeError: argument to reversed() must be a sequence
max(x) renvoie la plus grande clé du dictionnaire
min(x) renvoie la plus petite clé du dictionnaire
max(x,y) renvoie le dictionnaire dont la première valeur est plus grande, sinon la seconde, etc.
min(x,y) renvoie le dictionnaire dont la première valeur est plus petite, sinon la seconde, etc.
cmp(x,y) renvoie -1 si x<y, +1 si x>y et 0 si x==y
len(dico) renvoie le nombre de doublets clé:valeur d'un dictionnaire
sum(dico) renvoie la somme des clés d'un dictionnaire. TypeError s'il ne s'agit pas de nombres
all() retourne True si aucune valeur d'un dictionnaire n'est fausse (le dictionnaire peut être vide)
any() retourne True si au moins une valeur d'un dictionnaire est vraie (différent de 0, None, "", [], (), {}...)
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
del dico ou del(dico) détruit le dictionnaire dico
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}
vars() est un dictionnaire des {variables: valeurs}
globals() renvoie un dictionnaire des variables globales uniquement
locals() renvoie un dictionnaire des variables locales uniquement
Note: le module anydbm permet de sauvegarder sur disque des dictionnaires de chaînes, shelve permet de sauvegarder également les autres objets de Python: nombres, tuples, listes, fichiers binaires...
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')...]
Python 3 connaît une nouvelle forme de dictionnaire: OrderedDict, qui conserve la mémoire de l'ordre de ses éléments.
Python propose depuis sa version 2.3 une classe d'"ensembles", qui sont des collections non ordonnées d'objets. Les ensembles sont définis par une liste, une chaîne ou un tuple. Les doublons sont automatiquement éliminés.
>>> s=set(['Z',3,]); g=set((2,2,4)) >>> s,g set([3, 'Z']), set([2, 4])
En Python, un ensemble ne peut pas appartenir à un autre ensemble:
>>> ensemble=set([1,2]) >>> b=set(['spam',ensemble]) Traceback (most recent call last): File "<stdin>", line 1, in ? TypeError: set objects are unhashable
Une chaîne seule sera considérée comme un tuple, plusieurs chaînes dans une liste ou tuple seront considérées comme des éléments:
>>> a=set('eggs')
>>> b=set(["spam",'eggs'])
>>> a, b
(set(['s', 'e', 'g']), set(['eggs', 'spam']))
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
sum(s) additionne les nombres contenus dans un ensemble
reversed(set((12,34,56,78))) renvoie TypeError: argument to reversed() must be a sequence
all() retourne True si aucun élément d'un ensemble est faux (l'ensemble peut être vide)
any() retourne True si au moins un élément d'un ensemble est "vrai" (différent de 0, None, "", [], (), {}...)
del s ou del(s) détruit la variable
del s[0] retourne TypeError: 'set' object doesn't support item deletion
id(ens) 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(ens) donne l'identifiant de la donnée contenue dans la variable var
type(s) renvoie <type 'set'>. Attention: type(s)=="<type 'set'>" renvoie
False; il faut utiliser type(set()):
>>> s=set(["spam",3]) >>> type(s)==type(set()) True
s.add(x) ajoute l'élément x s'il ne s'y trouve pas encore
s.pop() enlève un élément au hasard, KeyError générée si l'ensemble est vide
s.discard(x) enlève l'éventuel élément x de s
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<b retourne True si a est contenu dans b, lequel comprend au moins un élément supplémentaire
a.issuperset(b) (ou a>=b) retourne True si a contient (ou est égal à) b
a>b retourne True si a contient b et comprend au moins un autre élément
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()
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.
input permet la saisie d'expression(s) (nombre, chaine, 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()). À ne pas confondre avec exec, qui peut exécuter toute une chaîne d'instruction:
>>> exec "from math import sin,pi; print sin(pi/4)" 0.707106781187
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é %():
>>> 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)
%d sortie entier de base décimale; %4d pour un minimum de 4 caractères
%i sortie entière
%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)
%c sort le caractère selon son code numérique: 65=A, 66=B, etc.
%e pour une sortie scientifique: 55 -> 5,500000e+01
%f sortie décimale (virgule flottante) 5.5 -> 5.500000
%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
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("Eggs", end=" ") remplace le saut de ligne par un caractère (ici, l'espace)
print("J'ai", 23, "ans", sep="-") permet de remplacer l'espace (séparateur par défaut) par une chaîne
En Python 2.6, on peut utiliser print() grâce à from __future__ import print_function
Pour une sortie vers un fichier, voir Éditer un fichier.
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"
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.
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 deuxième pour un appel ultérieur
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') # rw en cas d'édition du fichier
for ligne in descr:
print ligne
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.
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.
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:
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.
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-fr ou azerty-be...
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()
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.
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 chaine 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 chaine def affiche(chaine): print chaine sortir(5)
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)
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 chaine() modifiera la variable globale ch print ch
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).
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()
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é.
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().
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!)
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):
from __future__ import generators
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 variable
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é 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
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 + , * , ==...
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(1.78,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)
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.
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()
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
__lt__() pour <, __le__() pour <=, __eq__() pour ==, __ne__() pour !=, __gt__() pour >, __ge__() pour >=, __contains__() pour in.
__neg__() pour -, __pos__() pour +, __invert__() pour ~ (tilde).
__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).
__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).
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...
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.
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.
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.