Mots-clés du langage

Les mots-clés réservés du langage Python sont fournis dans la liste keyword.kwlist du module keyword^[32].

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 builtins^[33]. 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)^[34]. nonlocal a été introduit par le PEP 3104^[35], 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. Toutefois, il était possible, et ça l'est toujours sans le mot-clé nonlocal, de modifier un objet affecté à une variable d'un niveau de portée supérieur, par exemple une liste avec la méthode append - c'est évidemment impossible pour un objet immuable.

Types de base

Les types de base en Python sont relativement complets et puissants. Il y a, entre autres :

• Les objets numériques
  • int est le type des entiers relatifs. Avant la version 3.0, ce type était dénommé long, et le type int correspondait à un entier de 32 ou 64 bits. Néanmoins, une conversion automatique en type long évitait tout débordement. Maintenant, ce type correspond aux entiers relatifs avec une précision illimitée sans restriction de taille.
  • long est le type des entiers relatifs, illimités de plus de 32 bits en Python 2, remplacé par le type int en Python 3
  • float est le type flottant équivalent au type double du C, soit tout nombre entre −1,7 × 10³⁰⁸ et 1,7 × 10³⁰⁸ sur les plateformes conforme à l'IEEE 754.
  • complex est le type des approximations des nombres complexes (c'est-à-dire deux float).
• Les objets « itérables »
  • Les objets tuple (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 sont des objets bytes^[36]. Dans les versions précédentes, ces objets étaient respectivement de type unicode et str. Les objets str et bytes sont immuables.
  • Les objets bytearray sont des chaînes d'octets modifiables. La version d'Unicode employée par Python peut être déterminée à l'aide de la variable unidata_version du module unicodedata.
  • Les objets file correspond à un fichier obtenu grâce à la méthode open()
  • Il existe aussi d'autres types d'objets itérables, notamment range obtenu via la méthode range(), et les types liés aux méthodes de dictionnaires .keys(), .values() et .items(). La plupart d'entre eux sont immuables.
• Les autres objets, n'étant ni numériques ni itérables
  • None est simplement le type d'un « vide ». Il sert à dénoter qu'une variable est vide.
  • type est le type du type des objets, obtenu grâce à la méthode type().
  • object est le type basique dont tous les autres types « héritent »
  • slice est une partie de type ou un objet extensible
  • NotImplementedType est, comme son nom l'indique, une absence d'implémentation du type auquel on essaie d'accéder.
  • bool est un booléen, soit le type de True et False renvoyés par exemple lors de comparaisons hors de l'utilisation de méthodes is_x().
  • exception est le type d'un message d'erreur lancé lorsque le code lève une exception.
  • function est le type d'une fonction, utilisé lors de l'appel des mots-clef def et lambda.
  • module est le type d'un module, utilisé lors de l'appel des mots-clef import et from.

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.

Programmation fonctionnelle

Python permet de programmer dans un style fonctionnel. Il dispose également des compréhensions de listes, et plus généralement les compréhensions peuvent produire des générateurs, des dictionnaires ou des ensembles^[37]. 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]

Une table de passage des lettres de l'alphabet vers leur code ASCII :

{chr(n): n for n in range(65, 91)}

L'ensemble des lettres d'un mot (produit l'ensemble {'r', 'c', 'd', 'b', 'a'}) :

s = "abracadabra"
{c for c in s}

Une compréhension peut comprendre plusieurs boucles et filtres, et il existe une correspondance avec le code réalisant le même calcul à l'aide d'instructions for et if :

[ i + j if i != j else 0
    for i in range(n)
        if i % 2 != 0
            for j in range(n)
                if j % 3 != 0 ]

a = []
for i in range(n):
    if i % 2 != 0:
        for j in range(n):
            if j % 3 != 0:
                a.append(i + j if i != j else 0)

Cependant, une différence notable dans la version sans compréhension est que les variables i et j existent, avec la valeur qu'elles avaient lors de leur dernier tour de boucle. Ce n'est pas le cas pour des constructions par compréhension.

Une forme limitée de fonction anonyme est possible :

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 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 c'est nécessaire. En effet, une fonction définie avec def peut être créée à l'intérieur d'une autre fonction et on obtient ainsi une définition de fonction dans une variable locale, par 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)

Une fonction locale peut modifier l'environnement de la fonction qui l'a créée, grâce au mot-clé nonlocal (voir Fermeture (informatique)) :

def accum(pas):
    total = 0
    def ajoute(n):
        nonlocal total
        total += n * pas
        return total
    return ajoute

On peut ainsi créer plusieurs accumulateurs, faisant chacun référence à son propre total. Il est possible d'accéder à l'environnement d'une fonction locale à l'aide de l'attribut __closure__.

Programmation objet

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-clé 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-clé 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

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__), etc. 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 la fonction print.

Les possibilités sont nombreuses et sont décrites dans la documentation du langage^[38].

Par exemple on peut définir l'addition de deux vecteurs à deux 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)

Générateurs

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 écrire :

def gen_fibonacci():
    """Générateur de la suite de Fibonacci"""
    a, b = 0, 1
    while True:
        yield a  # Renvoie 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))

Le module itertools permet de manipuler les générateurs. Par exemple, pour extraire les 10 premiers éléments du générateur précédent :

import itertools
list(itertools.islice(gen_fibonacci(), 10))
# renvoie [0, 1, 1, 2, 3, 5, 8, 13, 21, 34]

Depuis Python 3.3, il est possible de produire un générateur à partir d'une fonction récursive, grâce à la syntaxe yield from, apparue dans le PEP 380^[39] 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):
        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)
sum(1 for a in queens(8)) # Nombre de solutions, renvoie 92

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éments un par un.
Ainsi, le test 36 in [n * n for n in range(10)] va s'effectuer sur la liste calculée en entier, alors que dans 36 in (n * n for n in range(10)), qui utilise un générateur, le calcul des carrés s'arrête dès que 36 est trouvé. On peut s'en convaincre en remplaçant n * n par un appel de fonction réalisant un effet de bord, par exemple un affichage à l'écran.

Annotations

Depuis la version 3.0, Python propose l'annotation des variables dans les fonctions (introduit dans la PEP 3107^[41]). Ce qui permet de rendre le code plus lisible sans pour autant faire office de solution de typage statique puisque rien n'oblige à suivre ces annotations^[42].

def hello(name: str) -> str:
    return "Hello {} !".format(name)
hello("Alice") # Appel suggéré par les annotations
hello(True) # Appel non conforme mais tout à fait fonctionnel

En complément, depuis la version 3.5, Python propose le module typing^[43] (introduit dans la PEP 484^[44]).

from typing import List
def split_string(string: str) -> List[str]:
    return string.split(" ")

Compilation

Il est possible d'effectuer une analyse statique des modules Python avec des outils comme Pylint ^[45], mypy ^[46], 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^[47] ou d'autres plus spécifiques comme cx_Freeze sous Unix, Windows et macOS, py2app^[48] sous macOS 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é.

Méthodes

Le modèle objet de Python est inspiré de celui de Modula-3^[50]. 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^[51].

Python reconnaît trois types de méthodes :

• les méthodes d'instance, 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 classe, 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. Elles sont déclarées avec le décorateur @classmethod.
• les méthodes statiques, qui ne reçoivent pas de premier argument implicite. Elles sont déclarées avec le décorateur @staticmethod.

Visibilité

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 here^[52] (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.

Héritage

Python supporte l'héritage multiple. Depuis la version 2.3, il utilise l'algorithme C3, issu du langage Dylan^[53], 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^[54].

Philosophie

Python 3 a été développé avec la même philosophie que dans ses versions antérieures, donc toute référence à la philosophie de Python s'appliquera aussi bien à la version 3. Cependant, le langage avait fini par accumuler nombre de méthodes redondantes. En recherchant à supprimer ce qui est redondant dans le langage et ses modules, Python 3 suit la ligne directrice de Python « Ne devrait subsister qu'une seule méthode à la fois optimale et naturelle pour chaque chose ».

Python 3 reste un langage multiparadigme. Les programmeurs auront encore le choix entre l'orientation objet, la programmation structurée, la programmation fonctionnelle et d'autres paradigmes ; Python 3 a pour but d'être utilisé de manière plus naturelle que dans les versions 2.x, bien que son print nécessite l'emploi de parenthèses contrairement à Python 2^[130].

Planning et compatibilité

Python 3.0a1, la première version alpha de Python 3.0, fut publiée le 31 août 2007. Les versions 2.x et 3.x de Python seront publiées en parallèle pendant plusieurs cycles de développement, pendant lesquels la série des 2.x subsistera principalement pour la compatibilité, en incluant quelques caractéristiques importées depuis Python 3.x. Le PEP 3000^[131] contient plus d'informations à propos du processus de publication d'une version.

Comme Perl 6, Python 3.0 rompt la compatibilité descendante (rétrocompatibilité). L'utilisation de code écrit pour les séries 2.x n'est pas garantie avec Python 3.0. Ce dernier apporte des changements fondamentaux, comme le passage complet à l'Unicode et pour cette raison une nécessaire distinction entre les chaînes de caractère et les objets « bytes ». Le typage dynamique associé à certaines méthodes sur les objets de type dictionnaire rend une transition parfaite de Python 2.x vers Python 3.0 très délicat. Un outil nommé « 2to3 » traduit le plus gros des versions 2.x vers les versions 3.x et indique les zones de code demandant des finitions par des commentaires spéciaux et des mises en garde. Dans sa préversion, 2to3 semble réussir franchement à réaliser une traduction correcte^[132]. Dans le cadre d'une migration de Python 2.x vers Python 3.x, le PEP 3000 recommande de conserver le code original comme base des modifications et de le traduire pour la plateforme 3.x en utilisant 2to3.

Python 2.6 fournit un début de compatibilité ascendante, aussi bien qu'un mode « mise en garde » qui devrait faire prendre conscience des problèmes potentiels de transition pour le passage à Python 3^[133].