Il est également apprécié par les pédagogues qui y trouvent un langage où la syntaxe, clairement séparée des mécanismes de
bas niveau, permet une initiation aisée aux concepts de base de la programmation
3.
Python est un
langage qui peut s'utiliser dans de nombreux contextes et s'adapter à tout type d'utilisation grâce à des bibliothèques spécialisées. Il est cependant particulièrement utilisé comme
langage de script pour automatiser des tâches simples mais fastidieuses comme un script qui récupérerait la météo sur Internet ou qui s'intégrerait dans un logiciel de
conception assistée par ordinateur afin d'automatiser certains enchaînements d'actions répétitives. On l'utilise également comme langage de développement de prototype lorsqu'on a besoin d'une application fonctionnelle avant de l'optimiser avec un langage de plus bas niveau. Il est particulièrement répandu dans le monde scientifique, et possède de nombreuses extensions destinées aux applications numériques.
En
1989, profitant d’une semaine de vacances durant les fêtes de Noël, il utilise son ordinateur personnel
5 pour écrire la première version du langage. Fan de la série télévisée des
Monty Python, il décide de baptiser ce projet Python. Il s’est principalement inspiré d’ABC, par exemple pour l’
indentation comme syntaxe ou les types de haut niveau mais aussi de
Modula-3 pour la gestion des
exceptions, du
langage C et des outils UNIX
6.
Durant l’année suivante, le langage commence à être adopté par l’équipe du projet Amoeba, Guido poursuivant son développement principalement pendant son temps libre. En février 1991, la première version publique, numérotée 0.9.0
7, est postée sur le forum
Usenetalt.sources. La dernière version sortie au CWI fut Python 1.2
À partir d'
août 1995, l'équipe Python travaille au CNRI sur
Grail8 un
navigateur web utilisant
Tk. Il est l'équivalent pour Python du navigateur
HotJava, permettant d'exécuter des applets dans un environnement sécurisé. La première version publique, disponible en novembre, est la 0.2
9. Il a entraîné le développement de modules pour la bibliothèque standard comme
rexec10,
htmllib ou
urllib11. La version 0.6 sera la dernière de
Grail; elle est publiée en avril 1999
12.
En
1999, le projet
Computer Programming for Everybody (CP4E) est lancé avec collaboration entre le CNRI et la
DARPA. Il s'agit d'utiliser Python comme langage d'enseignement de la programmation. Cette initiative conduira à la création de l'environnement de développement IDLE. Cependant, du fait du manque de financement du projet par la DARPA, et du départ de nombreux développeurs Python du CNRI (dont Guido van Rossum), le projet s’éteint en 2000
13. Python 1.6 fut la dernière version sortie au CNRI.
En
2000, l'équipe principale de développement de Python déménagea à
BeOpen.com pour former l'équipe
PythonLabs de BeOpen. Python 2.0 fut la seule version sortie à BeOpen.com. Après cette version, Guido Van Rossum et les autres développeurs de PythonLabs rejoignirent Digital Creations (à présent connue sous le nom de
Zope Corporation)
14.
Andrew M. Kuchling a publié en décembre 1999
15 un texte nommé
python warts16 qui synthétise les griefs les plus fréquents exprimés à l'encontre du langage. Ce document aura une influence certaine sur les développements futurs du langage
17.
Afin de réparer certains défauts du langage (ex: orientation objet avec deux types de classes), et pour nettoyer la bibliothèque standard de ses éléments obsolètes et redondants, Python a choisi de casser la compatibilité ascendante dans la nouvelle version majeure : Python 3.0, publié en décembre 2008. Cette version a été suivie rapidement par une version 3.1 qui corrige les erreurs de jeunesse de la version 3.0 en la rendant directement obsolète.
Python a été conçu pour être un langage lisible. Il vise à être visuellement épuré. Par exemple, il possède moins de constructions syntaxiques que de nombreux langages structurés tels que C, Perl, ou Pascal. Les commentaires sont indiqués par le caractère
croisillon (#).
Les blocs sont identifiés par l'
indentation, au lieu d'accolades comme en
C ou
C++ ; ou de
begin ... end comme en
Pascal. Une augmentation de l'indentation marque le début d'un bloc, et une réduction de l'indentation marque la fin du bloc courant.
| Fonction factorielle en C | Fonction factorielle en Python |
|---|
/* Fonction factorielle en C */
int factorielle(int x) {
if (x < 2) {
return 1;
} else {
return x * factorielle(x-1);
}
}
|
# Fonction factorielle en Python
def factorielle(x):
if x < 2:
return 1
else:
return x * factorielle(x-1)
|
NB : des accolades pourraient être retirées de la version en C mais, des erreurs pouvant être aisément commises en cas d'imbrication de plusieurs blocs, cela ne correspondrait pas aux normes de codages habituellement recommandées.
Les mots-clés sont fournis dans la liste
keyword.kwlist du module
keyword18. Les mots-clés de Python 2.7.5 sont les suivants :
and,
as,
assert,
break,
class,
continue,
def,
del,
elif,
else,
except,
exec,
finally,
for,
from,
global,
if,
import,
in,
is,
lambda,
not,
or,
pass,
print,
raise,
return,
try,
while,
with,
yield.
À partir de Python 3.0,
print et
exec ne sont plus des mots-clés du langage, mais des fonctions du module
builtins19. Sont ajoutés aux mots-clés :
True,
False,
None et
nonlocal. Les trois premiers étaient déjà présents dans les versions précédentes, mais ils ne sont plus modifiables (auparavant, l'affectation
True = 1 était possible)
20.
nonlocal a été introduit par le PEP 3104
21, et permet, dans une fonction définie à l'intérieur d'une autre fonction, de modifier une variable d'un niveau supérieur de
portée. Avant cela, seules les variables locales à la fonction, et globales (niveau module) étaient modifiables.
Les types de base en Python sont relativement complets et puissants, il y a entre autres :
- Les objets numériques
int est un entier illimité. Avant la version 3.0, ce type était dénommé long, et le type int correspondait à un entier 32 ou 64 bits. Néanmoins, une conversion automatique évitait tout débordement.float est un flottant équivalent au type double du C, soit un nombre entre-1,7×10308 et 1,7×10308 sur les plateformes en conformité avec l'IEEE 754.complex est une approximation d'un nombre complexe (typiquement deuxfloats).
- Les objets « itérables »
- Les objets
tuple (ou n-uplet) sont des listes immuables d'objets hétérogènes.
- Les objets
list sont des tableaux dynamiques (ils étendent automatiquement leur taille lorsque nécessaire) et acceptent des types de données hétérogènes.
- Les objets
set sont des ensembles non ordonnés d'objets.
- Les objets
frozenset forment une variante immuable des set.
- Les objets
dict sont des tableaux associatifs (ou dictionnaires) permettant d'associer un objet (une clef) à un autre.
- Les objets
str sont des chaînes de caractères. À partir de la version 3.0, les caractères sont en Unicode sur 16 ou 32 bits ; les chaines d'octets ASCII sont des objets bytes. Dans les versions précédentes, ces objets étaient respectivement de type unicode et str.
Les objets itérables sont parcourus à l'aide d'une boucle for de la manière suivante :
for element in objet_iterable:
traiter(element)
Pour une chaîne de caractères, l'itération procède caractère par caractère.
Il est possible de dériver les classes des types de base pour créer ses propres types. On peut également fabriquer ses propres types d'objets itérables sans hériter des itérables de base en utilisant le protocole d'itération du langage.
Python permet de programmer dans un style
fonctionnel. Les
compréhensions de listes sont disponibles. Par exemple, pour construire la liste des carrés des entiers naturels plus petits que 10, on peut utiliser l'expression :
liste = [x**2 for x in range(10)]
# liste = [0, 1, 4, 9, 16, 25, 36, 49, 64, 81]
la liste des nombres pairs :
liste = [entier for entier in range(10) if entier % 2 == 0]
# liste = [0, 2, 4, 6, 8]
Les fonctions lambda peuvent être définies en ligne et utilisées comme arguments dans des expressions fonctionnelles :
filter(lambda x: x < 5, une_liste)
retournera une liste constituée des éléments de une_liste inférieurs à 5. Le même résultat peut être obtenu avec
[x for x in une_liste if x < 5]
Les lambdas de Python n'admettent que des expressions et ne peuvent être utilisées comme fonctions anonymes généralisées ; mais en Python, toutes les fonctions sont des objets, elles peuvent donc être passées en arguments à d'autres fonctions, et appelées lorsque nécessaire. En effet, les fonctions définies avec def sont équivalentes à celles définies aveclambda, il est d'ailleurs possible de définir une fonction à l'intérieur d'une autre fonction et ainsi obtenir une définition de fonction dans une variable locale, exemple :
def filtre_inferieur_a_5(une_liste):
def mon_filtre(x): # variable locale mon_filtre
return x < 5
return filter(mon_filtre, une_liste)
La programmation objet est très bien gérée par Python : tous les types de base, les fonctions, les instances de classes (les objets « classiques » des langages C++ et Java) et les classes elles-mêmes (qui sont des instances de méta-classes) sont des objets.
Une classe se définit avec le mot class. Les classes Python supportent l'héritage multiple ; il n'y a pas de surcharge statique comme en C++, ou de restrictions sur l'héritage comme c'est le cas en java (une classe implémente plusieurs interfaces et hérite d'une seule classe) mais le mécanisme des arguments optionnels et par mot-clef est plus général et plus flexible. En Python, l'attribut d'un objet peut référencer une variable d'instance ou de classe (le plus souvent une méthode). Il est possible de lire ou de modifier un attribut dynamiquement avec les fonctions :
getattr(objet, 'nom_attribut')setattr(objet, 'nom_attribut', nouvel_attribut)
Exemple de deux classes simples :
class Personne:
def __init__(self, nom, prenom):
self.nom = nom
self.prenom = prenom
def presenter(self) :
return self.nom + " " + self.prenom
class Etudiant(Personne):
def __init__(self, niveau, nom, prenom):
Personne.__init__(self, nom, prenom)
self.niveau = niveau
def presenter(self):
return self.niveau + " " + Personne.presenter(self)
e = Etudiant("Licence INFO", "Dupontel", "Albert")
assert e.nom == "Dupontel"
Méthodes spéciales et définition des opérateurs[modifier | modifier le code]
Python fournit un mécanisme élégant et orienté objet pour définir un ensemble pré-défini d'opérateurs : tout objet Python peut se voir doté de méthodes dites spéciales.
Ces méthodes, commençant et finissant par deux tirets de soulignement (underscores), sont appelées lors de l'utilisation d'un opérateur sur l'objet : + (méthode __add__), +=(méthode __iadd__), [] (méthode __getitem__), () (méthode __call__), … Des méthodes comme __repr__ et __str__, permettent de définir la représentation d'un objet dans l'interpréteur interactif et son rendu avec le mot clé print.
Les possibilités sont nombreuses et sont décrites dans la documentation du langage
22.
Par exemple on peut définir l'addition de deux vecteurs à 2 dimensions avec la classe suivante :
class Vector2D:
def __init__(self, x, y):
# On utilise un tuple pour stocker les coordonnées
self.coords = (x, y)
def __add__(self, other):
# L'instruction a+b sera résolue comme a.__add__(b)
# On construit un objet Vector2D à partir des coordonnées propres à l'objet, et à l'autre opérande
return Vector2D(self.coords[0]+other.coords[0], self.coords[1]+other.coords[1])
def __repr__(self):
# L'affichage de l'objet dans l'interpréteur
return "Vector2D(%s, %s)" %self.coords
a = Vector2D(1, 2)
b = Vector2D(3, 4)
print(a + b) # Vector2D(4, 6)
Le mot-clef yield utilisé dans une fonction permet de faire de cette fonction un générateur. L'appel de cette fonction renvoie un objet de type generator, qui peut être utilisé dans une boucle for, par exemple.
À chaque appel, le générateur effectue son traitement jusqu'à rencontrer le mot-clé
yield, renvoie la valeur de l'expression
yield, et à l'appel suivant, reprend son déroulement juste après le
yield. Par exemple pour calculer la
suite de Fibonacci, on peut faire :
def gen_fibonacci():
"""Générateur de la suite de Fibonacci"""
a, b = 0, 1
while True:
yield a # Renvoi de la valeur de "a", résultat de l'itération en cours
a, b = b, a + b
fi = gen_fibonacci()
for i in range(20):
print(next(fi))
| L'exécution de | renverra |
|---|
def gen_nombres_pairs():
"""Générateur de nombres pairs"""
a = 0
while True:
print("Génère le nombre", a)
yield a
a += 2
pi = gen_nombres_pairs()
for i in range(4):
print(next(pi))
|
Génère le nombre 0
0
Génère le nombre 2
2
Génère le nombre 4
4
Génère le nombre 6
6
|
Depuis Python 3.3, il est possible de produire une générateur à partir d'une fonction récursive, grâce à la syntaxe
yield from, apparue dans le PEP 380
23 et qui « délègue » le calcul à un sous-générateur. L'exemple suivant calcule les permutations des dames correspondant aux solutions du
problème des huit dames étendu à un échiquier de taille n × n.
def queens(n):
a = list(range(n))
up = [True]*(2*n - 1)
down = [True]*(2*n - 1)
def sub(i):
nonlocal a, up, down
for k in range(i, n):
j = a[k]
p = i + j
q = i - j + n - 1
if up[p] and down[q]:
if i == n - 1:
yield tuple(a)
else:
up[p] = down[q] = False
a[i], a[k] = a[k], a[i]
yield from sub(i + 1)
up[p] = down[q] = True
a[i], a[k] = a[k], a[i]
yield from sub(0)
Un générateur peut sembler identique à une fonction qui retourne une liste, mais contrairement à une liste qui contient tous ses éléments un générateur calcule ses élémentsun par un.
Grâce à un usage intensif des dictionnaires (conteneur associatif développé avec des
tables de hachage), Python permet d'explorer les divers objets du langage (
introspection) et dans certains cas de les modifier (
intercession).
Le
typage n'est pas vérifié à la compilation. De ce fait, des opérations sur un objet peuvent échouer, signifiant que l'objet en question n'est pas du bon type. Malgré l'absence de typage statique, Python est fortement typé, interdisant des opérations ayant peu de sens (comme, par exemple, additionner un nombre à une chaîne de caractères) au lieu de tenter silencieusement de la convertir en une forme qui a du sens. Python propose des fonctions permettant de transformer les variables dans un autre type :
points = 3.2 # points est du type float
print("Tu as " + points + " points !") # Génère une erreur de typage
points = int(points) # points est maintenant du type int (entier), sa valeur est arrondie à l'unité inférieure (ici 3)
print("Tu as " + points + " points !") # Génère une erreur de typage
points = str(points) # points est maintenant du type str (chaîne de caractères)
print("Tu as " + points + " points !") # Plus d'erreur de typage, affiche 'Tu as 3 points !'
De même, chaque variable devra être déclarée avant d'être utilisée.
Il est possible d'effectuer une analyse statique des modules Python avec des outils comme Pylint
24 ou PyChecker. Sans nécessiter une exécution, ces outils repèrent des fautes ou des constructions déconseillées. Par exemple, une classe qui hérite d'une classe abstraite et qui ne redéfinit pas les méthodes abstraites, ou bien des variables utilisées avant d'être déclarées, ou encore des attributs d'instance déclarés en dehors de la méthode
__init__.
Il est aussi possible de générer un code intermédiaire (
bytecode) Python.
Des outils comme PyInstaller
25 ou d'autres plus spécifiques comme cx_Freeze sous
Unix,
Windows et
Mac OS X, py2app
26 sous
Mac OS X et
py2exe sous
Windows permettent de « compiler » un programme Python sous forme d'un exécutable comprenant le programme et un interpréteur Python.
Le programme ne tourne pas plus rapidement (il n'est pas compilé sous forme de code machine) mais cela simplifie largement sa distribution, notamment sur des machines où l'interpréteur Python n'est pas installé.
En Python,
tout est objet, dans le sens qu'une variable peut contenir une
référence vers tous les éléments manipulés par le langage : nombres, méthodes, modules,
etc.27. Néanmoins, avant la version 2.2, les classes et les instances de classes étaient un type d'objet particulier, ce qui signifiait qu'il était par exemple impossible de dériver sa propre sous-classe de l'objet
list.
Le modèle objet de Python est inspiré de celui de Modula-3
28. Parmi ces emprunts se trouve l'obligation de déclarer l'instance de l'objet courant, conventionnellement nommée
self, comme premier argument des méthodes, et à chaque fois que l'on souhaite accéder à une donnée de cette instance dans le corps de cette méthode. Cette pratique n'est pas naturelle pour des programmeurs venant par exemple de C++ ou Java, la profusion des
self étant souvent critiquée comme étant une pollution visuelle qui gène la lecture du code. Les promoteurs du
self explicite estiment au contraire qu'il évite le recours à des conventions de nommage pour les données membres et qu'il simplifie des tâches comme l'appel à une méthode de la superclasse ou la résolution d'homonymie entre données membres
29.
Python reconnaît trois types de méthodes :
- les méthodes d'instances, qui sont celles définies par défaut. Elles reçoivent comme premier argument une instance de la classe où elles ont été définies.
- les méthodes de classes, qui reçoivent comme premier argument la classe où elles ont été définies. Elles peuvent être appelées depuis une instance ou directement depuis la classe. Elles permettent de définir des constructeurs alternatifs comme la méthode
fromkeys() de l'objet dict.
- les méthodes statiques, qui ne reçoivent pas de premier argument implicite. Elles sont similaires aux méthodes statiques que l'on trouve en Java ou C++.
Le langage a un support très limité de l'
encapsulation. Il n'y a pas, comme en java par exemple, de contrôle de l'accessibilité par des mots clefs comme
protected ou
private.
La philosophie de Python est de différencier conceptuellement l'encapsulation du masquage d'information. Le masquage d'information vise à prévenir les utilisations frauduleuses, c'est une préoccupation de
sécurité informatique. Le module
bastion de la bibliothèque standard, qui n'est plus maintenu dans les dernières versions du langage, permettait ainsi de contrôler l'accès aux attributs d'un objet dans le cadre d'un environnement d'exécution restreint.
L'encapsulation est une problématique de développement logiciel. Le slogan des développeurs Python est
we're all consenting adults here30 (nous sommes entre adultes consentants). Ils estiment en effet qu'il suffit d'indiquer, par des conventions d'écriture, les parties publiques des interfaces et que c'est aux utilisateurs des objets de se conformer à ces conventions ou de prendre leurs responsabilités. L'usage est de préfixer par un underscore les membres privés. Le langage permet par ailleurs d'utiliser un double underscore pour éviter les collisions de noms, en préfixant automatiquement le nom de la donnée par celui de la classe où elle est définie.
L'utilisation de la fonction
property() permet de définir des propriétés qui ont pour but d'intercepter, à l'aide de méthodes, les accès à une donnée membre. Cela rend inutile la définition systématique d'
accesseurs et le masquage des données comme il est courant de le faire en C++ par exemple.
Pytho
Python possède une grande bibliothèque standard, fournissant des outils convenant à de nombreuses tâches diverses. Le nombre de modules de la bibliothèque standard peut être augmenté avec des modules spécifiques écrits en C ou en Python.
La bibliothèque standard est particulièrement bien conçue pour écrire des applications utilisant Internet, avec un grand nombre de formats et de protocoles standards gérés (tels que
MIMEet
HTTP). Des modules pour créer des
interfaces graphiques et manipuler des
expressions rationnelles sont également fournis. Python inclut également un
framework de
tests unitaires(
unittest, anciennement
PyUnit avant version 2.1) pour créer des suites de tests exhaustives.
Bien que chaque programmeur puisse adopter ses propres conventions pour l'écriture de code Python,
Guido van Rossum a mis un guide à disposition, référencé comme « PEP 8 »
33. Publié en 2001, il est toujours maintenu en 2013, pour l'adapter aux évolutions du langage.
Google propose également un guide
34.
Python possède plusieurs modules disponibles pour la création de logiciels avec une interface graphique. Le plus répandu est
Tkinter. Ce module convient à beaucoup d'applications et peut être considéré comme suffisant dans la plupart des cas. Néanmoins, d'autres modules ont été créés pour pouvoir lier Python à d'autres
bibliothèques logicielles(«
toolkit »), pour davantage de fonctionnalités, pour une meilleure intégration avec le système d'exploitation utilisé, ou simplement pour pouvoir utiliser Python avec sa bibliothèque préférée. En effet, certains programmeurs trouvent l'utilisation de Tkinter plus pénible que d'autres bibliothèques. Ces autres modules ne font pas partie de la bibliothèque standard et doivent donc être obtenus séparément.
Van Rossum est le principal auteur de Python, et son rôle de décideur central permanent de Python est reconnu avec humour par le titre de « Dictateur bienveillant à vie » (Benevolent Dictator for Life, BDFL).
Il est assisté d'une équipe de
core developers qui ont un accès en écriture au dépôt de CPython et qui se coordonnent sur la liste de diffusion python-dev. Ils travaillent principalement sur le langage et la bibliothèque de base. Ils reçoivent ponctuellement les contributions d'autres développeurs Python via la plateforme de gestion de bug
Roundup, qui a remplacé
SourceForge.
Les utilisateurs ou développeurs de bibliothèques tierces utilisent diverses autres ressources. Le principal média généraliste autour de Python est le forum Usenet anglais comp.lang.python.
Les allusions aux Monty Python sont assez fréquentes. Les didacticiels consacrés à Python utilisent souvent les mots
spam et
eggs comme
variable métasyntaxique. Il s'agit d'une référence au sketch
Spam des
Monty Python, où deux clients tentent de commander un repas à l'aide d'une carte qui contient du jambon en conserve de marque
SPAM dans pratiquement tous les plats. Ce sketch a été aussi pris pour référence pour désigner un courriel non sollicité.
