Python

Python a été conçu pour être un langage lisible. Il vise à être visuellement épuré, et utilise des mots anglais souvent à l'endroit où d'autres langages utilisent de la ponctuation, et possède aussi 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 dièse.

Les blocs sont identifiés par l'indentation, au lieu d'accolades comme en C/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. Les parenthèses sont facultatives dans les structures de contrôle :

 // Fonction factorielle en C
 int factorielle(int x) {      
     if (x == 0)                    
         return 1;                   
     else
         return x * factorielle(x-1);
 }

 # Fonction factorielle en python
 def factorielle(x):
     if x == 0:
         return 1
     else:
         return x * factorielle(x-1)

Types de base

Les types de base en Python sont assez complets et puissants, il y a entre autres :

• Les objets numériques
  • int est un entier classique.
  • long est un entier dont la mémoire de stockage est allouée dynamiquement, la taille maximale n'est par conséquent pas fixe et dépend de la capacité de la machine.
  • float est un flottant équivalent au double du C.
  • complex est une approximation d'un nombre complexe (typiquement deux floats)
• Les objets "itérables"
  • Les objets list sont des tableaux dynamiques (ils étendent automatiquement leur taille quand indispensable) et acceptent des types de données hétérogènes.
  • Les objets set sont des ensembles non ordonnés d'objets.
  • 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, qui possèdent une grande variété de méthodes de base pour remplacer des mots, éliminer les espaces blancs, séparer le texte en morceau, etc. Ce sont des objets itérables car ils peuvent être vus comme des listes d'autres str d'un seul caractère.
  • Les tuple (ou n-uplet) sont une variante non mutable des listes ; de même il existe une version immutable des dictionnaires (frozendict) et des ensembles (frozenset).

Les objets itérables sont parcourus avec une boucle for de la manière suivante :

for element in objet_iterable:
  traiter(element)

Il est envisageable de dériver les classes des types de base pour créer ses propres types. On peut aussi fabriquer ses propres types d'objets itérables sans hériter des itérables de base en implémentant le protocole d'itération du langage.

Programmation fonctionnelle

Python sert à programmer dans un style fonctionnel. Les compréhensions de listes sont disponibles. A titre d'exemple, pour construire la liste des carrés des entiers naturels plus petits que 10, on peut utiliser l'expression :

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

la liste des nombres pairs :

 l = [entier for entier in range(10) 
      if entier % 2 == 0]
 # l = [0, 2, 4, 6, 8]

Une forme limitée de fonctions lambda, ou fonctions anonymes, est disponible :

 lambda x: x+2

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 d'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, l'ensemble des fonctions sont des objets, qui peuvent par conséquent être passés en arguments d'autres fonctions, et nommés quand indispensable.

Programmation objet

La programmation objet est particulièrement bien supportée par Python : l'ensemble des 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++, 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 fréquemment une méthode). Il est envisageable 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, classe, nom, prenom):
        Personne.__init__(self, nom, prenom)
        self.classe = classe
    def presenter(self):
        return self.classe + Personne.presenter(self)
 
 e = Etudiant('Licence INFO', 'Dupontel', 'Albert')
 assert e.nom == 'Dupontel'

Méthodes spéciales et surcharge des opérateurs

Python apporte un mécanisme élégant et orienté objet pour la surcharge des opérateurs : tout objet python peut se voir doter de méthodes dites spéciales.

Ces méthodes, commençant et finissant par deux underscores, sont nommé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 : http ://docs. python. org/ref/specialnames. html.

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ée propres à l'objet et de 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)

Générateurs

Le mot-clef yield utilisé dans une fonction sert à faire de cette fonction un générateur. L'appel de cette fonction renvoie un objet de type generator, qui est parfois 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 devant yield, ainsi qu'à l'appel suivant, reprend son déroulement juste après le yield. Par exemple pour calculer la suite de Fibonacci, on peut faire :

import sys
def gen_fibonacci(max=sys.maxint):
    a=0
    b=1
    while a<max:
        yield a
        a,b = b,a+b
for n in gen_fibonacci(1000):
    print n

Réflexivité

Grâce à un usage intensif des dictionnaires (conteneur associatif implémenté avec des tables de hachage), Python permet d'explorer les divers objets du langage (introspection) et occasionnellementde les modifier (intercession).

Typage

Le typage n'est pas vérifié à la compilation. Par conséquent, 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 servant à 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 (et vaut 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.

Python propose aussi un mécanisme de typage fort grâce à l'API trait ou au design pattern decorators.

Compilation

Il est cependant envisageable d'effectuer une analyse statique des modules Python avec des outils comme Pylint ou PyChecker. Ceux-ci éliminent la majorité des fautes, comme une classe qui hérite d'une classe abstraite et qui ne surcharge 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__, etc. Selon la nature du projet, ces outils peuvent être réglés de façon fine afin d'obtenir une très grande qualité de code.

Il est aussi envisageable de générer un Bytecode Python.

Des outils comme PyInstaller^[16] ou d'autres plus spécifiques comme Freeze sous Unix 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 beaucoup sa distribution, surtout sur des machines où l'interpréteur python n'est pas installé.

Modèle objet

En python tout est objet, dans le sens qu'une variable peut contenir une référence vers l'ensemble des éléments manipulés par le langage : nombres, méthodes, modules, etc. ^[17] Néanmoins, avant la version 2.2, les classes et les instances de classes étaient un type d'objet spécifique, ce qui signifiait qu'il était par exemple impossible de dériver sa propre sous-classe de l'objet list.

Méthodes

Le modèle objet de python est inspiré de celui de Modula-3^[18]. Parmi ces emprunts se trouve l'obligation de déclarer l'instance de l'objet courant, conventionnellement appelée self, comme premier argument des méthodes, ainsi qu'à chaque fois qu'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 fréquemment 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^[19]. Il permet d'autre part un traitement orthogonal des méthodes et fonctions.

Python reconnaît trois types de méthodes :

• les méthodes d'instances, qui sont celles définies par défaut. Elle 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éfinie. Elles peuvent être nommé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 identiques aux méthodes statiques qu'on trouve en Java ou C++.

Visibilité

Le langage a un support particulièrement 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 librairie standard, qui n'est plus tenu 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 here^[20] (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 d'autre part 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 () sert à définir des propriétés qui ont pour but d'intercepter, avec méthodes, les accès à une donnée membre. Cela rend inutile la définition systématiques d'accesseurs et le masquage des données comme il est courant de le faire en C++ par exemple.

Héritage

Python supporte l'héritage multiple. Depuis la version 2.3, il utilise l'algorithme C3, issu du langage Dylan ^[21], pour résoudre l'ordre de résolution de méthode (MRO]). Les versions précédentes utilisaient un algorithme de parcours en profondeur qui posait des problèmes dans le cas d'un héritage en diamant ^[22].

Bibliothèque standard

Python est apporté «Piles Incluses».

Python possède une grande bibliothèque standard, fournissant des outils convenant à de nombreuses tâches diverses. Le nombre modules de la bibliothèque standard peut être augmenté avec des modules spécifiques rédigés en C ou en Python.

La bibliothèque standard est spécifiquement bien conçue pour écrire des applications utilisant Internet, avec la plupart de formats et de protocoles standards gérés (tels que MIME et HTTP). Des modules pour créer des interfaces graphiques et manipuler des expressions rationnelles sont aussi apportés. Python inclut aussi un framework de tests unitaire pour créer des suites de test exhaustives.

Interfaces graphiques

Python possède plusieurs modules disponibles pour la création de logiciels avec une interface graphique. Le plus commun est Tkinter, qui est membre de la bibliothèque standard, et qui est par conséquent installé avec Python. Ce module convient à énormément d'applications et peut être reconnu comme suffisant dans la majorité 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 dispositif d'exploitation utilisé, ou simplement pour pouvoir utiliser Python avec sa bibliothèque préférée. Aussi, il faut dire que 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 par conséquent être obtenus scindément.

Les principaux modules donnant accès aux bibliothèques d'interface graphique sont Tkinter pour Tk, wxPython pour wxWidgets, PyGTK pour GTK+, PyQt pour Qt, FxPy pour le FOX Toolkit, et Pmw pour Mega-Widgets, il existe aussi une implantation de SDL : Pygame, et un binding de la SFML : PySFML.

La communauté Python

Van Rossum est le principal auteur de Python, et son rôle de décideur central permanent de Python s'est vu consacré 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 rédigéure au dépôt de CPython et qui se coordonnent sur la liste de diffusion python-dev. Ils travaillent essentiellement 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 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 habituelles. Les didacticiels consacrés à python utilisent fréquemment les mots spam et eggs comme variable métasyntaxique. C'est une référence à l'épisode 25 de la seconde saison du Monty Python's Flying Circus, ou deux clients tentent de commander un repas avec une carte qui contient du jambon en conserve (le spam) dans quasiment l'ensemble des plats. Ce sketch a été aussi pris pour référence pour désigner un email non sollicité.

Adoption de Python

Plusieurs entreprises mentionnent sur leur site officiel^[23] qu'elles utilisent Python :

• Google (Guido van Rossum travaille depuis 2005 au sein de cette entreprise^[24])  ;
• Industrial Light & Magic ;
• la NASA ;
• et CCP Games, les créateurs du jeu vidéo EVE Online.

Implémentations

Outre l'implémentation de référence, appelée CPython (car rédigée en langage C), il existe d'autres dispositifs implémentant le langage Python :

• Stackless Python, une version de CPython n'utilisant pas la pile d'appel du langage C ;
• Jython, un interprète Python pour machine virtuelle Java. Il a accès aux bibliothèques apportées avec l'environnement de développement Java ;
• IronPython, un interprète / compilateur (expérimental) pour plateforme . Net / Mono ;
• PyPy un interprète Python rédigé dans un sous-ensemble de Python compilable vers le C ou LLVM ;
• un compilateur (expérimental) pour Parrot, la machine virtuelle de Perl 6 ;
• Movable Python (payant)  : Python sur une clef USB pour lancer des scripts sans installer Python.

Ces autres implémentations ne bénéficient pas nécessairement de la totalité de la bibliothèque de fonctions rédigées en C pour l'implémentation de référence.

Historique des versions