Voir la source de Python (langage)

Vous n’avez pas la permission de modifier cette page, pour la raison suivante :
Votre adresse IP fait partie d’une plage qui a été bloquée sur tous les wikis de la Fondation Wikimédia.
Le blocage a été effectué par ‪EPIC‬. Le motif invoqué est Open proxy/Webhost: See the help page if you are affected.
Début du blocage : 2 juillet 2024 à 09:48
Expiration du blocage : 2 juillet 2025 à 09:48
Votre adresse IP actuelle est 206.189.44.186. La plage bloquée est 206.189.32.0/20.
Veuillez inclure tous les détails ci-dessus dans toutes les demandes que vous effectuerez. Si vous pensez avoir été bloqué(e) par erreur, vous pouvez trouver plus d’informations et d’instructions dans la politique globale Pas de serveurs mandataires ouverts.
Sinon, pour discuter du blocage, veuillez publier une demande de révision sur Méta-Wiki. Vous pouvez également envoyer un courriel à la file des coordinateurs VRT à stewards@wikimedia.org, en incluant tous les détails ci-dessus.
Vous pouvez voir et copier le contenu de cette page.
{{Voir homonymes|Python}}

{{Sources secondaires|date=novembre 2024}}

{{Infobox Langage de programmation
 | couleur boîte            = 3B78A7
 | nom                      = {{blanc|Python}}
 | logo                     = 
 | paradigmes               = [[Programmation orientée objet|Objet]], [[Programmation impérative|impératif]] et [[Programmation fonctionnelle|fonctionnel]]
 | date de première version = {{date|20|02|1991}}, {{âge|20|02|1991}}<ref>{{Lien web|url=http://python-history.blogspot.com/2009/01/brief-timeline-of-python.html |titre=The History of Python: A Brief Timeline of Python |série=[[Blogger (service)|Blogger]] |date=20 janvier 2009 |consulté le=20 mars 2016}}.</ref>
 | auteur                   = [[Guido van Rossum]]
 | développeurs             = [[Python Software Foundation]]
 | typage                   = [[Typage fort|Fort]], [[Typage dynamique|dynamique]], [[duck typing]]
 | implémentations          = [[CPython]], [[Jython]], [[IronPython]], [[PyPy]]
 | dialectes                = 
 | influencé par            = [[ABC (langage)|ABC]], [[C (langage)|C]], [[Eiffel (langage)|Eiffel]], [[ICON]], [[Modula-3]], [[Java (langage)|Java]], [[Perl (langage)|Perl]], [[Smalltalk]], [[Tool Command Language|Tcl]]
 | a influencé              = [[Ruby]], [[Groovy (langage)|Groovy]], [[Boo (langage)|Boo]], [[Julia (langage)|Julia]], [[Mojo (langage de programmation)|Mojo]]
 | langage de programmation = [[C (langage)|C]] pour CPython, [[Java (langage)|Java]] pour Jython, [[C sharp|C#]] pour IronPython et en Python lui-même pour PyPy
 | système d'exploitation   = [[Logiciel multiplateforme|Multiplateforme]]
 | licence                  = [[Licence libre]] :<br>[[Python Software Foundation License]]
 | extension                = 
 | extensions               = .py, .pyc, .pyd, .pyo
 | site web                 = https://python.org/
}}

'''Python''' (prononcé {{MSAPI|/pi.tɔ̃/}}) est un [[langage de programmation]] [[Interprète (informatique)|interprété]], [[paradigme (programmation)|multiparadigme]] et [[Plate-forme (informatique)|multiplateformes]]. Il favorise la [[programmation impérative]] [[Programmation structurée|structurée]], [[Programmation fonctionnelle|fonctionnelle]] et [[Programmation orientée objet|orientée objet]]. Il est doté d'un [[typage dynamique]] [[typage fort|fort]], d'une gestion automatique de la [[Mémoire vive|mémoire]] par [[ramasse-miettes (informatique)|ramasse-miettes]] et d'un [[système de gestion d'exceptions]] ; il est ainsi similaire à [[Perl (langage)|Perl]], [[Ruby]], [[Scheme]], [[Smalltalk]] et [[Tool Command Language|Tcl]].

Le langage Python est placé sous une [[licence libre]] proche de la [[licence BSD]] et fonctionne sur la plupart des [[Plate-forme (informatique)|plateformes informatiques]], des [[smartphone]]s aux [[Ordinateur central|ordinateurs centraux]], de [[Microsoft Windows|Windows]] à [[Unix]] avec notamment [[Linux|GNU/Linux]] en passant par [[macOS]], ou encore [[Android]], [[iOS]], et peut aussi être traduit en [[Java (langage)|Java]] ou [[Microsoft .NET|.NET]]. Il est conçu pour optimiser la productivité des programmeurs en offrant des outils de [[Langage de programmation de haut niveau|haut niveau]] et une [[syntaxe]] simple à utiliser.

Il est également apprécié par certains [[Pédagogie|pédagogues]] qui y trouvent un [[Langage de programmation|langage]] où la syntaxe, clairement séparée des mécanismes de [[Langage de programmation de bas niveau|bas niveau]], permet une [[initiation]] aisée aux concepts de base de la programmation<ref>{{en}} [http://www.greenteapress.com/thinkpython/thinkCSpy/html/preface.html « il faut treize paragraphes pour expliquer un ''Hello, World!'' en C++, seulement deux en Python »].</ref>. Selon l'[[Index TIOBE]], notamment en raison de son efficacité pour l'[[apprentissage automatique]], sa popularité va croissante ; et en 2022 n'a toujours pas montré de signe de ralentissement<ref name=IndexTIOBE2022>{{Lien web |langue=fr-FR |titre=Python est le langage de programmation le plus utilisé et il ne montre aucun signe de ralentissement, selon l'index TIOBE de janvier 2022 |url=https://programmation.developpez.com/actu/329957/Python-est-le-langage-de-programmation-le-plus-utilise-et-il-ne-montre-aucun-signe-de-ralentissement-selon-l-index-TIOBE-de-janvier-2022/ |site=Developpez.com |consulté le=2023-09-30}}</ref>.

== Utilisation ==
Python est un [[langage de programmation]] qui peut s'utiliser dans de nombreux contextes et s'adapter à tout type d'utilisation grâce à des [[Bibliothèque logicielle|bibliothèques]] spécialisées.

Il est cependant particulièrement utilisé comme [[langage de script]] pour [[Automatisme|automatiser]] des tâches simples mais fastidieuses, comme un [[Langage de script|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 (voir la section [[#Adoption de Python|Adoption]]). 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 [[Bibliothèque logicielle|bibliothèques]] optimisées destinées au [[calcul numérique]].

C'est l'un des langages les plus utilisés dans le domaine de l'[[informatique quantique]]<ref>{{Lien web |langue=fr |titre=L'ordinateur quantique (L'informatique quantique) par Olivier Ezratty | MOOC Digital Paris |url=https://moocdigital.paris/cours/linformatique-quantique/lordinateur-quantique |site=moocdigital.paris |consulté le=2023-09-30}}</ref> et de l'[[intelligence artificielle]], ainsi que pour le traitement des [[Big data|Big Data]] et du [[Apprentissage automatique|Machine learning]]<ref>{{Lien web |langue=fr |prénom=Bastien |nom=L |titre=Pourquoi apprendre Python, le langage de programmation du futur |url=https://www.lebigdata.fr/pourquoi-apprendre-python |site=www.lebigdata.fr |consulté le=2023-09-30}}</ref>.

== Historique ==
=== Au CWI ===
[[Fichier:Guido van Rossum OSCON 2006.jpg|vignette|upright=0.7|gauche|Guido van Rossum, créateur de Python, à la [[OSCON]] 2006.]]

À la fin des [[années 1980]], le [[développeur|programmeur]] [[Guido van Rossum]] participe au développement du langage de programmation [[ABC (langage)|ABC]] au [[Centrum voor Wiskunde en Informatica]] (CWI) d'[[Amsterdam]], aux [[Pays-Bas]]. Il travaille alors dans l'équipe du [[système d'exploitation]] [[Amoeba (système d'exploitation)|Amoeba]] dont les [[Appel système|appels systèmes]] sont difficilement interfaçables avec le [[Bourne shell]] utilisé comme [[interface utilisateur]]. Il estime alors qu'un langage de script inspiré d'ABC pourrait être intéressant comme [[interpréteur de commandes]] pour Amoeba<ref name="FAQ1.2">[http://www.python.org/doc/faq/general/#why-was-python-created-in-the-first-place ''{{lang|en|FAQ Python 1.2 Why was Python created in the first place?}}''].</ref>.

En [[1989]], profitant d'une semaine de vacances durant les fêtes de [[Noël]], il utilise son [[ordinateur personnel]]<ref>[http://homepages.cwi.nl/~jack/macpython/intro.html ''{{lang|en|Introduction to MacPython}}''].</ref> pour écrire la première version du langage. Fan de la [[série télévisée]] ''[[Monty Python's Flying Circus]]'', il décide de baptiser ce projet Python<ref>{{Ouvrage|langue=en|auteur1=Mark Lutz|titre=Learning Python|sous-titre=Powerful Object-Oriented Programming|éditeur=O'Reilly Media, Inc.|année=2009|mois=octobre|jour=6|pages totales=1216|passage=17|isbn=978-1-4493-7932-2|lire en ligne=https://books.google.fr/books?id=1HxWGezDZcgC|titre chapitre=How Does Python Stack Up to Langage}}.</ref>. 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 [[Système de gestion d'exceptions|gestion des exceptions]], du [[C (langage)|langage C]] et des [[Unix|outils UNIX]]<ref>[http://www.python.org/doc/essays/foreword/ Introduction de la première édition du livre ''Programming Python'' de Mark Lutz], Guido van Rossum 1996.</ref>.

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 {{date-|février 1991}}, la première version publique, numérotée 0.9.0<ref>Selon le fichier [http://svn.python.org/projects/python/trunk/Misc/HISTORY HISTORY] mais la plus ancienne version accessible dans les archives du forum est la
[http://groups.google.com/group/alt.sources/browse_thread/thread/3b6652abb0e23b03/53ee3620bc53c281 0.9.1], également disponible en [[Tar (informatique)|tarball]] sur [https://www.python.org/download/releases/early/ python.org].</ref>, est postée sur le forum [[Usenet]] alt.sources. La dernière version sortie au CWI est Python 1.2.

=== Au CNRI ===
En [[1995]], Van Rossum continue son travail sur Python au {{Lien|langue=en|fr=Corporation for National Research Initiatives|texte=CNRI}} à [[Reston (Virginie)|Reston]], aux [[États-Unis]], où il sort plusieurs versions du logiciel.

À partir d'{{date||août|1995|en informatique}}, l'équipe Python travaille au CNRI sur ''Grail''<ref>[http://grail.sourceforge.net/info/team.html The Grail Development Team<!-- Titre généré automatiquement -->].</ref> un [[navigateur web]] utilisant [[Tk (informatique)|Tk]]. Il est l'équivalent pour Python du navigateur [[HotJava]], permettant d'exécuter des [[Applet|applets]] dans un environnement sécurisé. La première version publique, disponible en novembre, est la 0.2<ref>[http://grail.sourceforge.net/info/papers/restofus.html ''Grail -- The Browser For The Rest Of Us''].</ref>. Il entraîne le développement de [[Plugin|modules]] pour la bibliothèque standard comme ''rexec''<ref>[http://docs.python.org/lib/module-rexec.html 28.1 {{lang|en|rexec - Restricted execution framework}}<!-- Titre généré automatiquement -->].</ref>, ''htmllib''<ref>{{Lien web |titre=19.3. htmllib — A parser for HTML documents — Python 2.7.18 documentation |url=https://docs.python.org/2/library/htmllib.html |site=docs.python.org |consulté le=2020-08-14}}.</ref> ou ''urllib''<ref>http://grail.sourceforge.net/info/diagram.gif.</ref>. La version 0.6 sera la dernière de ''Grail'' ; elle est publiée en {{date-|avril 1999}}<ref>[http://grail.sourceforge.net/ Grail Home Page<!-- Titre généré automatiquement -->].</ref>.

En [[1999]], le projet ''Computer Programming for Everybody''<ref>{{Lien web |langue=en |titre=Computer Programming for Everybody |url=https://www.python.org/doc/essays/cp4e/ |site=Python.org |consulté le=2020-08-14}}.</ref> (CP4E) est lancé conjointement entre le CNRI et la [[Defense Advanced Research Projects Agency|DARPA]]. Il s'agit d'utiliser Python comme un langage d'enseignement de la [[Programmation informatique|programmation]]. Cette initiative conduira à la création de l'[[environnement de développement]] [[IDLE (Python)|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<ref>[http://www.python.org/doc/essays/cp4e Computer Programming for Everybody<!-- Titre généré automatiquement -->].</ref>. Python 1.6 est la dernière version sortie au CNRI.

=== À BeOpen ===
En [[2000]], l'équipe principale de développement de Python déménage à [[BeOpen.com]] pour former l'équipe [[PythonLabs]] de BeOpen. Python 2.0 est la seule version sortie à BeOpen.com. Après cette version, Guido Van Rossum et les autres développeurs de PythonLabs rejoignent Digital Creations (à présent connue sous le nom de [[Zope|Zope Corporation]])<ref>{{en}} [http://docs.python.org/2/license.html History of the software].</ref>.

Andrew M. Kuchling publie en {{date-|décembre 1999}}<ref>Andrew M. Kuchling, ''[https://mail.python.org/pipermail/python-list/1999-December/014104.html Python warts]'', Python Mailing List, 22 décembre 1999.</ref> un texte nommé ''Python Warts''<ref>[https://web.archive.org/web/20031002184114/www.amk.ca/python/writing/warts.html Python Warts].</ref>, 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<ref>[http://www.python.org/download/releases/2.2.3/descrintro/ Unifying types and classes in Python 2.2].</ref>.

=== La ''Python Software Foundation'' ===
Python 2.1 est une version dérivée de Python 1.6.1 et de Python 2.0. Sa licence est renommée [[Python Software Foundation License]]. Tout [[Programmation informatique|code]], documentation et spécification ajouté, depuis la sortie de Python 2.1 alpha, est détenu par la [[Python Software Foundation]] (PSF), une [[association sans but lucratif]] fondée en 2001, modelée d'après l{{'}}''[[Apache Software Foundation]]''.

Afin de réparer certains défauts du langage (par exemple l'[[programmation orientée objet|orienté objet]] avec deux types de [[Classe (informatique)|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 {{date-|décembre 2008}}. Cette version est rapidement suivie par une version 3.1 qui corrige les erreurs de jeunesse de la version 3.0.

Selon l'[[Index TIOBE]], {{Citation|Python, qui est devenu un élément incontournable de la [[science des données]], du [[DevOps]] et du [[Programmation web|développement web]], est aussi désormais le langage le plus populaire dans le classement de TIOBE. Classé troisième langage le plus populaire de l'index au début de l'année 2021, Python s'est hissé à la première place en octobre 2022}}<ref name=IndexTIOBE2022/>.

== Caractéristiques ==
=== Syntaxe ===
Python a été conçu pour être un langage lisible. Il vise à être visuellement épuré. Par exemple, il possède moins de constructions [[Syntaxe|syntaxiques]] que de nombreux langages structurés tels que [[C (langage)|C]], [[Perl (langage)|Perl]], ou [[Pascal (langage)|Pascal]]. Les commentaires sont indiqués par le caractère [[Croisillon (signe)|croisillon]] (#).

Les [[Bloc de base|blocs]] sont identifiés par l'[[Style d'indentation|indentation]], au lieu d'accolades comme en [[C (langage)|C]] ou [[C++]] ; ou de <code>begin ... end</code> comme en [[Pascal (langage)|Pascal]] ou [[Ruby]]. Une augmentation de l'[[Indentation comme syntaxe|indentation]] marque le début d'un bloc, et une réduction de l'indentation marque la fin du bloc courant. Par convention (actuellement PEP8<ref>{{Lien web |langue=en |titre=PEP 8 -- Style Guide for Python Code |url=https://www.python.org/dev/peps/pep-0008/ |site=Python.org |consulté le=2020-08-14}}.</ref>), l'indentation est habituellement de quatre espaces en Python<ref name="pep8">[https://www.python.org/dev/peps/pep-0008/ PEP 8 - Style Guide for Python Code].</ref>.

{| class="wikitable"
!width="50%"|Fonction [[factorielle]] en C
!width="50%"|Fonction [[factorielle]] en Python
|-valign="top"
|
<syntaxhighlight lang="c">
int factorielle(int n) {
    if (n < 2) {
        return 1;
    } else {
        return n * factorielle(n - 1);
    }
}
</syntaxhighlight>
|
<syntaxhighlight lang="python">
def factorielle(n):
    if n < 2:
        return 1
    else:
        return n * factorielle(n - 1)
</syntaxhighlight>
|}

Remarque : L'indentation pourrait être modifiée ou supprimée dans la version en C sans modifier son comportement. De même, la fonction Python peut être écrite avec une expression conditionnelle<ref>[https://www.python.org/dev/peps/pep-0308/ PEP 308 - Conditional Expressions].</ref>. Cependant, une indentation correcte permet de détecter plus aisément des erreurs en cas d'imbrication de plusieurs blocs et facilite donc l'élimination de ces erreurs. C'est pourquoi il est préférable d'indenter convenablement les programmes en C. La version courte s'écrirait ainsi :

{| class="wikitable"
!width="50%"|Fonction factorielle en C
!width="50%"|Fonction factorielle en Python
|-valign="top"
|
<syntaxhighlight lang="c">
int factorielle(int n) {
    return n < 2 ? 1 : n * factorielle(n - 1);
}
</syntaxhighlight>
|
<syntaxhighlight lang="python">
def factorielle(n):
    return n * factorielle(n - 1) if n > 1 else 1 
</syntaxhighlight>
|}

==== Mots-clés du langage ====
Les mots-clés réservés du langage Python sont fournis dans la liste <code>keyword.kwlist</code> du module <code>keyword</code><ref>[http://docs.python.org/fr/3/library/keyword.html La bibliothèque standard - 31.6. keyword — Tester si des chaînes sont des mot-clés Python].</ref>.

Les mots-clés de Python 2.7.5 sont les suivants : <code>and</code>, <code>as</code>, <code>assert</code>, <code>break</code>, <code>class</code>, <code>continue</code>, <code>def</code>, <code>del</code>, <code>elif</code>, <code>else</code>, <code>except</code>, <code>exec</code>, <code>finally</code>, <code>for</code>, <code>from</code>, <code>global</code>, <code>if</code>, <code>import</code>, <code>in</code>, <code>is</code>, <code>lambda</code>, <code>not</code>, <code>or</code>, <code>pass</code>, <code>print</code>, <code>raise</code>, <code>return</code>, <code>try</code>, <code>while</code>, <code>with</code>, <code>yield</code>.

À partir de Python 3.0, <code>print</code> et <code>exec</code> ne sont plus des mots-clés du langage, mais des fonctions du module <code>builtins</code><ref>[http://docs.python.org/fr/3/library/functions.html#built-in-funcs La bibliothèque standard - 2. Fonctions natives].</ref>. Sont ajoutés aux mots-clés : <code>True</code>, <code>False</code>, <code>None</code> et <code>nonlocal</code>. Les trois premiers étaient déjà présents dans les versions précédentes, mais ils ne sont plus modifiables (auparavant, l'affectation <code>True = 1</code> était possible)<ref>{{lien web|url=http://wiki.python.org/moin/Python3.0|titre=Python 3.0 - Core Language Changes|langue=en}}.</ref>. <code>nonlocal</code> a été introduit par le PEP 3104<ref>{{lien web|url=http://www.python.org/dev/peps/pep-3104/|titre=PEP 3104 - Access to Names in Outer Scopes|langue=en}}.</ref>, 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 (informatique)|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é <code>nonlocal</code>, de modifier un objet affecté à une variable d'un niveau de portée supérieur, par exemple une liste avec la méthode <code>append</code> - c'est évidemment impossible pour un [[objet immuable]].

À partir de Python 3.10, il y a 3 mots-clés contextuels (« ''{{langue|en|soft keywords}}'' » en anglais) : <code>match</code>, <code>case</code>, <code>_</code> identique à [[Switch (instruction)|l’instruction switch-case]]. <syntaxhighlight lang="python3">match valeur: 
    case condition_1:
        expression_1
    case condition_2:
        expression_2
    case _: # `case _´ est accédé si toutes les autres conditions sont fausses.
        expression_par_défault</syntaxhighlight>

==== Types de base ====
Les types de base en Python sont relativement complets et puissants. Il y a, entre autres :
* Les objets numériques
**<code>int</code> est le type des [[entier relatif|entiers relatifs]]. Avant la version 3.0, ce type était dénommé <code>long</code>, et le type <code>int</code> correspondait à un entier de 32 ou 64 bits. Néanmoins, une [[Conversion de type|conversion]] automatique en type <code>long</code> évitait tout [[Dépassement de pile|débordement]]. Maintenant, ce type correspond aux entiers relatifs avec une précision illimitée sans restriction de taille.
** <code>long</code> est le type des entiers relatifs, illimités de plus de 32 bits en Python 2, remplacé par le type <code>int</code> en Python 3 
** <code>float</code> est le type [[Virgule flottante|flottant]] équivalent au type <code>double</code> [[Types de donnée du langage C|du C]], soit tout nombre entre {{nombre|-1.7}}{{x10|308}} et {{nombre|1.7}}{{x10|308}} sur les plateformes conforme à l'[[IEEE 754]].
** <code>complex</code> est le type des approximations des [[nombre complexe|nombres complexes]] (c'est-à-dire deux <code>float</code>).
* Les objets « itérables »
** Les objets <code>tuple</code> ([[n-uplet]]) sont des listes [[Objet immuable|immuables]] d'objets hétérogènes.
** Les objets <code>list</code> sont des [[Tableau croisé dynamique|tableaux dynamiques]] (ils étendent automatiquement leur taille lorsque nécessaire) et acceptent des types de données hétérogènes.
** Les objets <code>set</code> sont des ensembles non ordonnés d'objets.
** Les objets <code>frozenset</code> forment une variante immuable des <code>set</code>.
** Les objets <code>dict</code> sont des [[Tableau associatif|tableaux associatifs]] (ou dictionnaires) permettant d'associer un objet (une clef) à un autre.
** Les objets <code>str</code> 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'[[Octet|octets]] sont des objets <code>bytes</code><ref>Les objets <code>bytes</code> ont été introduits par le [https://www.python.org/dev/peps/pep-0358/ PEP 358], voir aussi le [https://www.python.org/dev/peps/pep-3137/ PEP 3137].</ref>. Dans les versions précédentes, ces objets étaient respectivement de type <code>[[unicode]]</code> et <code>str</code>. Les objets <code>str</code> et <code>bytes</code> sont [[Objet immuable|immuables]].
** Les objets <code>bytearray</code> 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 <code>unidata_version</code> du module <code>unicodedata</code>.
** Les objets <code>file</code> correspond à un fichier obtenu grâce à la méthode <code>open()</code>
** Il existe aussi d'autres types d'objets itérables, notamment <code>range</code> obtenu via la méthode <code>range()</code>, et les types liés aux méthodes de dictionnaires <code>.keys()</code>, <code>.values()</code> et <code>.items()</code>. La plupart d'entre eux sont [[Objet immuable|immuables]].
* Les autres objets, n'étant ni numériques ni itérables
**<code>None</code> est simplement le type d'un « vide ». Il sert à dénoter qu'une variable est vide.
** <code>type</code> est le type du type des objets, obtenu grâce à la méthode <code>type()</code>.
** <code>object</code> est le type basique dont tous les autres types « héritent »
** <code>slice</code> est une partie de type ou un objet extensible
** <code>NotImplementedType</code> est, comme son nom l'indique, une absence d'implémentation du type auquel on essaie d'accéder.
** <code>bool</code> est un booléen, soit le type de <code>True</code> et <code>False</code> renvoyés par exemple lors de comparaisons hors de l'utilisation de méthodes <code>is_x()</code>.
** <code>exception</code> est le type d'un message d'erreur lancé lorsque le code lève une exception.
** <code>function</code> est le type d'une fonction, utilisé lors de l'appel des mots-clef <code>def</code> et <code>lambda</code>.
** <code>module</code> est le type d'un module, utilisé lors de l'appel des mots-clef <code>import</code> et <code>from</code>.

Les objets itérables sont parcourus à l'aide d'une boucle <code>for</code> de la manière suivante :
<syntaxhighlight lang="python">
for element in objet_iterable:
    traiter(element)
</syntaxhighlight>

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 [[Programmation fonctionnelle|fonctionnel]]. Il dispose également des [[Liste en compréhension|compréhensions de listes]], et plus généralement les compréhensions peuvent produire des générateurs, des [[Tableau associatif|dictionnaires]] ou des [[Ensemble (informatique)|ensembles]]<ref>Les compréhensions ont été introduites dans le [https://www.python.org/dev/peps/pep-0202/ PEP 202] en juillet 2000, et les compréhensions de dictionnaires et d'ensembles dans le [https://www.python.org/dev/peps/pep-0274/ PEP 274] en octobre 2001.</ref>. Par exemple, pour construire la liste des carrés des [[Entier naturel|entiers naturels]] plus petits que 10, on peut utiliser l'expression :
<syntaxhighlight lang="python">
liste = [x**2 for x in range(10)]
# liste = [0, 1, 4, 9, 16, 25, 36, 49, 64, 81]
</syntaxhighlight>

La liste des nombres '''pairs''' :
<syntaxhighlight lang="python">
liste = [entier for entier in range(10) if entier % 2 == 0]
# liste = [0, 2, 4, 6, 8]
</syntaxhighlight>

Une table de passage des lettres de l'alphabet vers leur code [[American Standard Code for Information Interchange|ASCII]] :
<syntaxhighlight lang="python">
{chr(n): n for n in range(65, 91)}
</syntaxhighlight>

L'ensemble des lettres d'un mot (produit l'ensemble <code>{'r', 'c', 'd', 'b', 'a'}</code>) :
<syntaxhighlight lang="python">
s = "abracadabra"
{c for c in s}
</syntaxhighlight>

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 <code>for</code> et <code>if</code> :

{| class="wikitable"
!width="50%"|Compréhension
!width="50%"|Code équivalent
|-valign="top"
|
<syntaxhighlight lang="Python">
[ 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 ]
</syntaxhighlight>
|
<syntaxhighlight lang="python">
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)
</syntaxhighlight>
|}

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 :
<syntaxhighlight lang="python">
lambda x: x + 2
</syntaxhighlight>
Les fonctions lambda peuvent être définies en ligne et utilisées comme arguments dans des expressions fonctionnelles : <syntaxhighlight lang="python"> filter(lambda x: x < 5, une_liste) </syntaxhighlight> retournera une liste constituée des éléments de une_liste inférieurs à 5. Le même résultat peut être obtenu avec <syntaxhighlight lang="python"> [x for x in une_liste if x < 5] </syntaxhighlight>

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 :
<syntaxhighlight lang="python">
def filtre_inferieur_a_5(une_liste):
    def mon_filtre(x): # variable locale mon_filtre
        return x < 5
    return filter(mon_filtre, une_liste)
</syntaxhighlight>

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

<syntaxhighlight lang="python">
def accum(pas):
    total = 0
    def ajoute(n):
        nonlocal total
        total += n * pas
        return total
    return ajoute
</syntaxhighlight>

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 <code>__closure__</code>.

==== Programmation objet ====
Tous les types de base, les fonctions, les [[Instance (programmation)|instances]] de classes (les objets « classiques » des langages [[C++]] et [[Java (langage)|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é <code>class</code>. Les [[Classe (informatique)|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 :

* <code>getattr(objet, "nom_attribut") </code>
* <code>setattr(objet, "nom_attribut", nouvel_attribut)</code>

Exemple de deux classes simples :
<syntaxhighlight lang="python">
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"
</syntaxhighlight>

==== Méthodes spéciales et définition des opérateurs ====
Python fournit un mécanisme élégant et [[Programmation orientée objet|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 : <code>+</code> (méthode <code>__add__</code>), <code>+=</code> (méthode <code>__iadd__</code>), <code>[]</code> (méthode <code>__getitem__</code>), <code>()</code> (méthode <code>__call__</code>), etc. Des méthodes comme <code>__repr__</code> et <code>__str__</code> 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<ref>The Python Language Reference » 3. Data model » [https://docs.python.org/3/fr/reference/datamodel.html#specialnames 3.3. Special method names].</ref>.

Par exemple on peut définir l'addition de deux vecteurs à deux dimensions avec la classe suivante :
<syntaxhighlight lang="python">
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)
</syntaxhighlight>

==== Générateurs ====
Le mot-clef <code>yield</code> 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 <code>for</code>, par exemple.

À chaque appel, le générateur effectue son traitement jusqu'à rencontrer le mot-clé <code>yield</code>, renvoie la valeur de l'expression <code>yield</code>, et à l'appel suivant, reprend son déroulement juste après le <code>yield</code>. Par exemple pour calculer la [[suite de Fibonacci]], on peut écrire :
<syntaxhighlight lang="python">
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))
</syntaxhighlight>

Le module <code>itertools</code> permet de manipuler les générateurs. Par exemple, pour extraire les 10 premiers éléments du générateur précédent :
<syntaxhighlight lang="python">
import itertools
list(itertools.islice(gen_fibonacci(), 10))
# renvoie [0, 1, 1, 2, 3, 5, 8, 13, 21, 34]
</syntaxhighlight>

Depuis Python 3.3, il est possible de produire un générateur à partir d'une fonction récursive, grâce à la syntaxe <code>yield from</code>, apparue dans le PEP 380<ref>[https://www.python.org/dev/peps/pep-0380/ PEP 380 - Syntax for Delegating to a Subgenerator].</ref> 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.

<syntaxhighlight lang="python">
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
</syntaxhighlight>

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''.<br/>Ainsi, le test <code>36 in [n * n for n in range(10)]</code> va s'effectuer sur la liste calculée en entier, alors que dans <code>36 in (n * n for n in range(10))</code>, 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 <code>n * n</code> par un appel de fonction réalisant un [[Effet de bord (informatique)|effet de bord]], par exemple un affichage à l'écran.

=== Réflexivité ===
Grâce à un usage intensif des dictionnaires ([[Conteneur (informatique)|conteneur]] associatif développé avec des [[table de hachage|tables de hachage]]), Python permet d'explorer les divers objets du langage ([[introspection (informatique)|introspection]]) et dans certains cas de les modifier ([[intercession (informatique)|intercession]]).

=== Typage ===
[[Fichier:Python 3. The standard type hierarchy.png|vignette]]
Le [[typage]] n'est pas vérifié à la compilation. Python utilise le [[duck typing]] : lors de l'exécution, si une méthode invoquée sur un objet a la même [[Signature de type|signature]] qu'une méthode déclarée sur cet objet, alors c'est cette dernière méthode qui est exécutée. De ce fait, invoquer une méthode qui n'existe pas sur un objet va é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 (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 :
<syntaxhighlight lang="python">
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 !'
</syntaxhighlight>

Python propose aussi un mécanisme de [[typage statique]] pour les attributs des classes grâce à l'API ''trait''<ref>[https://pypi.python.org/pypi/traits traits - explicitly typed attributes for Python].</ref> ou au [[patron de conception]] ''decorators''.

==== Annotations ====

Depuis la version 3.0, Python propose l'annotation des variables dans les fonctions (introduit dans la PEP 3107<ref>{{Lien web|langue=en|titre=PEP 3107 -- Function Annotations|url=https://www.python.org/dev/peps/pep-3107/|site=Python.org|consulté le=2020-03-04}}.</ref>). 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<ref>{{Lien web|langue=anglais|auteur1=Collin Winter|auteur2=Tony Lownds|titre=Fundamentals of Function Annotations|url=https://www.python.org/dev/peps/pep-3107/#fundamentals-of-function-annotations|site=www.python.org|date=6 décembre 2006|consulté le=10 mars 2020}}.</ref>.<syntaxhighlight lang="python3">
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
</syntaxhighlight>En complément, depuis la version 3.5, Python propose le module typing<ref>{{Lien web|titre=26.1. typing — Support for type hints — Python 3.6.10 documentation|url=https://docs.python.org/fr/3/library/typing.html|site=docs.python.org|consulté le=2020-03-04}}.</ref> (introduit dans la PEP 484<ref>{{Lien web|langue=en|titre=PEP 484 -- Type Hints|url=https://www.python.org/dev/peps/pep-0484/|site=Python.org|consulté le=2020-03-04}}.</ref>).<syntaxhighlight lang="python3">
from typing import List

def split_string(string: str) -> List[str]:
    return string.split(" ")
</syntaxhighlight>
==== Compilation ====
Il est possible d'effectuer une analyse statique des modules Python avec des outils comme Pylint <ref>http://www.pylint.org.</ref>, mypy <ref>http://mypy-lang.org/.</ref>, 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 <code>__init__</code>.

Il est aussi possible de générer un code intermédiaire ([[bytecode]]) Python.

Des outils comme PyInstaller<ref>{{en}} [http://www.pyinstaller.org// Site officiel de PyInstaller].</ref> ou d'autres plus spécifiques comme cx_Freeze sous [[Unix]], [[Microsoft Windows|Windows]] et [[macOS]], py2app<ref>http://svn.pythonmac.org/py2app/py2app/trunk/doc/index.html#abstract.</ref> sous [[macOS]] et [[py2exe]] sous [[Microsoft Windows|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é.

=== Modèle objet ===
En Python, ''tout est objet'', dans le sens qu'une variable peut contenir une [[référence (informatique)|référence]] vers tous les éléments manipulés par le langage : nombres, méthodes, modules{{etc.}}<ref>Dive into Python 3 - ''[http://www.diveintopython3.net/your-first-python-program.html#everythingisanobject 1.5 Everything Is An Object]''.</ref>. 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''.

==== Méthodes ====
Le modèle objet de Python est inspiré de celui de Modula-3<ref>[http://docs.python.org/tut/node11.html ''Python Tutorial''] chapitre 9.</ref>. 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<ref>[http://effbot.org/pyfaq/why-must-self-be-used-explicitly-in-method-definitions-and-calls.htm Why must 'self' be used explicitly in method definitions and calls?].</ref>.

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 <code>fromkeys()</code> de l'objet <code>dict</code>. Elles sont déclarées avec le décorateur <code>@classmethod</code>.
* les méthodes statiques, qui ne reçoivent pas de premier argument implicite. Elles sont déclarées avec le décorateur <code>@staticmethod</code>.

==== Visibilité ====
Le langage a un support très limité de l'[[encapsulation (programmation)|encapsulation]]. Il n'y a pas, comme en Java par exemple, de contrôle de l'accessibilité par des mots clefs comme <code>protected</code> ou <code>private</code>.

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é du système d'information|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''<ref>[http://www.mactech.com/articles/mactech/Vol.20/20.11/PythonForAppleScripters/index.html Python For AppleScripters<!-- Titre généré automatiquement -->].</ref> (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 <code>property()</code> 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'[[accesseur]]s 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'[[Linéarisation C3|algorithme C3]], issu du langage [[Dylan (langage)|Dylan]]<ref>{{article|auteur1=Kim Barrett|auteur2=Bob Cassels|auteur3=Paul Haahr|auteur4=David A. Moon|auteur5=Keith Playford|auteur6=P. Tucker Withington|titre=A monotonic superclass linearization for Dylan|périodique=ACM SIGPLAN Notices|volume=31|numéro=10|mois=octobre|année=1996|pages=69-82|doi=10.1145/236337.236343|url=http://citeseerx.ist.psu.edu/viewdoc/summary?doi=10.1.1.19.3910}}.</ref>, 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]]<ref>[http://www.python.org/download/releases/2.3/mro/ The Python 2.3 Method Resolution Order].</ref>.

== Bibliothèque standard ==
[[Image:Python batteries included.jpg|vignette|250px|Python est fourni « piles incluses ».]]
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 [[Multipurpose Internet Mail Extensions|MIME]] et [[Hypertext Transfer Protocol|HTTP]]). Des modules pour créer des [[interface graphique|interfaces graphiques]] et manipuler des [[Expression régulière|expressions rationnelles]] sont également fournis. Python inclut également un [[framework]] de [[test unitaire|tests unitaires]] (<code>unittest</code>, anciennement [[PyUnit]] avant version 2.1) pour créer des suites de tests exhaustives.

== Conventions de style ==
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 »<ref name="pep8"/>. Publié en 2001, il est toujours maintenu pour l'adapter aux évolutions du langage. [[Google]] propose également un guide<ref>[https://google.github.io/styleguide/pyguide.html Google Python Style Guide].</ref>.

== Interfaces graphiques ==
[[Fichier:Close button with wxpython in windows 10.png|vignette|Interface graphique en wxPython pour wxWidgets.]]
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.

Les principaux modules donnant accès aux bibliothèques d'interface graphique sont [[Tkinter]] et Pmw (Python megawidgets)<ref>[http://pmw.sourceforge.net/ Pmw - Python megawidgets].</ref> pour [[Tk (informatique)|Tk]], [[wxPython]] pour [[wxWidgets]], [[PyGTK]] pour [[GTK (boîte à outils)|GTK]], [[PyQt]] et [[PySide]] pour [[Qt]], et enfin FxPy pour le [[FOX Toolkit]]. Il existe aussi une adaptation de la bibliothèque [[Simple DirectMedia Layer|SDL]] : [[Pygame]], un [[binding]] de la [[SFML]] : PySFML, ainsi qu'une bibliothèque écrite spécialement pour Python : {{Lien|langue=en|fr=Pyglet}}.

Il est aussi possible de créer des applications [[Silverlight]] en Python sur la plateforme [[IronPython]].

== La communauté Python ==

[[Guido van Rossum]] est le principal auteur de Python, un langage de programmation largement utilisé dans divers domaines, allant du développement web à l'intelligence artificielle. Son rôle central dans l'évolution de Python lui a valu le titre humoristique de « Dictateur bienveillant à vie » (''[[Benevolent Dictator for Life]]'', BDFL). Cependant, en {{date-|juillet 2018}}, Guido van Rossum a annoncé sa retraite de ce rôle, se déclarant en « vacances permanentes » de ses responsabilités de BDFL<ref>{{Lien web |langue=en |titre=[python-committers] Transfer of power |url=https://www.mail-archive.com/python-committers@python.org/msg05628.html |site=www.mail-archive.com |consulté le=2020-10-19}}.</ref>. Par la suite, en {{date-|novembre 2019}}, il a également retiré sa candidature au conseil directeur du langage Python<ref>{{Lien web |langue=en-US |titre=Steering Council nomination: Guido van Rossum (2020 term) |url=https://discuss.python.org/t/steering-council-nomination-guido-van-rossum-2020-term/2657/11 |site=Discussions on Python.org |date=2019-11-27 |consulté le=2020-10-19}}.</ref>.

Après le retrait de van Rossum, la gouvernance de Python est passée à un modèle plus démocratique, sous la direction d'un [[Python Steering Council|Conseil directeur]] composé de cinq membres élus. Ces membres sont principalement issus de la communauté des ''core developers'', une équipe de développeurs ayant un accès en écriture au dépôt de [[CPython]], l'implémentation de référence du langage Python. Cette équipe se coordonne principalement via la liste de diffusion python-dev, où sont discutées et décidées les évolutions du langage et de sa bibliothèque standard.

Les contributions de la communauté sont encouragées, et les développeurs tiers peuvent soumettre des améliorations via la plateforme de gestion de bugs et de suivi de tâches [[Roundup (bugtracker)|Roundup]], qui a remplacé l'ancien système basé sur [[SourceForge (logiciel)|SourceForge]]. La transition vers [[GitHub]] en 2017 a également facilité la collaboration ouverte et la contribution au code source de Python.

Les utilisateurs et développeurs de bibliothèques tierces peuvent échanger via diverses autres ressources en ligne, notamment le forum Usenet anglophone comp.lang.python, ainsi que des forums, mailing lists, et réseaux sociaux plus modernes comme [[Reddit]] ou [[Discord]].

Les références aux Monty Python, une troupe comique britannique, sont un élément récurrent dans la culture Python. Les tutoriels du langage utilisent souvent les termes ''spam'' et ''eggs'' comme [[variable métasyntaxique]], en référence au célèbre sketch ''[[Spam (sketch)|Spam]]'' des [[Monty Python]], où le SPAM (un jambon en conserve) est omniprésent dans le menu. Ce sketch a d'ailleurs donné son nom au phénomène du [[Spam|courriel non sollicité]], illustrant l'humour décalé et omniprésent dans la communauté Python.

=== Adoption de Python ===
{{article détaillé|Liste de logiciels Python}}
Plusieurs entreprises ou organismes mentionnent sur leur site officiel<ref>[http://www.python.org/about/quotes/ Quotes about Python].</ref> qu'ils utilisent Python :
* [[Google]] ([[Guido van Rossum]] a travaillé au sein de cette entreprise entre 2005 et 2012<ref>[http://www.oreillynet.com/onlamp/blog/2005/12/python_creator_guido_van_rossu.html ''Python Creator Guido van Rossum now working at Google''], article sur ''ONLamp.com''</ref>) ;
* [[Industrial Light & Magic]] ;
* la [[National Aeronautics and Space Administration|NASA]] ;
* et CCP Games, les créateurs du [[jeu vidéo]] [[EVE Online]].

Python est aussi le langage de commande d'un grand nombre de logiciels libres :
* [[FreeCAD]], logiciel de [[Conception assistée par ordinateur|CAO]] 3D
* [[Blender]], logiciel de [[Modélisation tridimensionnelle|modélisation 3D]] et d'[[Montage vidéo|édition vidéo]]
* [[Inkscape]], logiciel de [[Image vectorielle|dessin vectoriel]]
* [[LibreOffice]] et [[Apache OpenOffice]], les deux branches de développement d'une [[suite bureautique]] issue de [[StarOffice]]
* {{lien|lang=en|trad=Portage (software)|fr=Portage (logiciel)|texte=Portage}}, le gestionnaire de paquets du [[système d'exploitation]] [[Gentoo]]
* [[ParaView]], logiciel de visualisation de [[Donnée numérique|données numériques]]
* [[Kodi Entertainment Center|Kodi]], un [[lecteur multimédia]]
* [[QGIS]], un logiciel de [[cartographie]]
* [[Weblate]], un outil de [[traduction]]
* [[gedit]], un éditeur de texte (les plugins sont écrits en Python)
* [[SageMath]], un logiciel de calcul formel

Et commerciaux :
* [[Wing IDE]], [[environnement de développement intégré]] spécialisé sur Python, et écrit en Python
* [[Corel Paint Shop Pro]], logiciel de traitement d'image et d'édition graphique
* [[Capella (notation musicale)|capella]], logiciel de notation musicale
* [[ArcGIS]], un logiciel de cartographie<ref>[http://resources.arcgis.com/en/communities/python/ Python for ArcGIS].</ref>

Python est utilisé comme langage de programmation dans l'enseignement secondaire et supérieur, notamment en France<ref>[http://cache.media.education.gouv.fr/file/special_3_ESR/50/5/programme-informatique_252505.pdf ''Bulletin officiel spécial {{n°|3}} du 30 mai 2013''], article sur http://www.education.gouv.fr/.</ref>. Depuis 2013, il y est enseigné à tous les étudiants de [[classes préparatoires scientifiques]] dans le cadre du tronc commun (informatique commune). Auparavant, l'enseignement d'informatique était limité à une option en MP, l'enseignement se faisant en langage [[Caml]] ou [[Pascal (langage)|Pascal]]. Cette option existe toujours, mais Pascal a été abandonné à partir de la session 2015 des concours et Caml a, lui, été enlevé au profit de [[OCaml]] dans cet enseignement. Les premières épreuves de concours portant sur le langage Python sont également celles de la session 2015<ref>[http://www.mines-ponts.fr/pages/upload/sujet/sujet.php Sujets du concours Mines-Ponts].</ref>{{,}}<ref>{{Lien web |titre=Centrale-Supélec Rapports et sujets |url=https://www.concours-centrale-supelec.fr/CentraleSupelec |site=www.concours-centrale-supelec.fr |consulté le=2023-09-18}}</ref>.

== Implémentations du langage ==
Outre la version de référence, nommée [[CPython]] (car écrite en langage [[C (langage)|C]]), il existe d'autres systèmes mettant en œuvre le langage Python<ref>{{Lien web |titre=PythonImplementations - Python Wiki |url=https://wiki.python.org/moin/PythonImplementations |site=wiki.python.org |consulté le=2023-09-18}}</ref> :
* [[Stackless Python]], une version de CPython n'utilisant pas la [[Pile d'exécution|pile d'appel]] du langage C ;
* [[Jython]], un [[interprète (informatique)|interprète]] Python pour [[machine virtuelle Java]]. Il a accès aux bibliothèques fournies avec l'[[environnement de développement]] [[Java (langage)|Java]] ;
* [[IronPython]], un interprète / compilateur (expérimental) pour plateforme [[Microsoft .NET|.Net]] / [[Mono (informatique)|Mono]] ;
* Brython<ref>{{Lien web |titre=Brython |url=https://brython.info/ |site=brython.info |consulté le=2021-03-21}}.</ref>, une implémentation de Python 3 pour les navigateurs web ;
* [[MicroPython]], variante légère pour [[microcontrôleur]]s ;
* [[PyPy]] un interprète Python écrit dans un sous-ensemble de Python compilable vers le [[C (langage)|C]] ou [[LLVM]] ;
* un [[compilateur]] (expérimental) pour [[Parrot (machine virtuelle)|Parrot]], la [[machine virtuelle]] de [[Perl (langage)|Perl]] 6 ;
* [[Shed Skin]]<ref>{{Lien web |titre=Google Code Archive - Long-term storage for Google Code Project Hosting. |url=https://code.google.com/archive/p/shedskin |site=code.google.com |consulté le=2023-09-18}}</ref>, un [[compilateur]] d'un sous-ensemble de Python produisant du code en [[C++]] ;
* {{Lien|langue=en|trad=Unladen Swallow|fr=Unladen Swallow}}<ref>{{Lien web |titre=Google Code Archive - Long-term storage for Google Code Project Hosting. |url=https://code.google.com/archive/p/unladen-swallow |site=code.google.com |consulté le=2023-09-18}}</ref>, une version de CPython optimisée et basée sur LLVM, maintenant abandonnée (la dernière version remonte à {{date-|octobre 2009}}) ;
* ''RustPython'', projet d'implémentation en [[Rust (langage)|Rust]]<ref>{{Lien web|url=https://github.com/RustPython/RustPython|titre=RustPython}}.</ref>.
* PySpark est une interface de programmation permettant d'utiliser [[Apache Spark|Spark]] à partir du langage Python pour faire des [[Calcul distribué|calculs distribués]].
Ces autres versions ne bénéficient pas forcément de la totalité de la bibliothèque de fonctions écrites en C pour la version de référence, ni des dernières évolutions du langage.

== Distributions ==

{{Section sources secondaires|date=novembre 2024}}

Différentes distributions sont disponibles, qui incluent parfois beaucoup de [[Paquet (logiciel)|paquets]] dédiés à un domaine donné<ref>[https://wiki.python.org/moin/PythonDistributions Python Distributions], dans le Python Wiki.</ref> :
* ActivePython<ref>[http://www.activestate.com/activepython ActivePython].</ref> : disponible en version gratuite (ne pouvant être « utilisée en production ») ou commerciale.
* Python(x,y)<ref>[https://python-xy.github.io Python(x,y)].</ref> : distribution Python à l'usage des scientifiques basée sur [[Qt]] et [[Eclipse (projet)|Eclipse]]. Obsolète, remplacé par WinPython
* Enthought Canopy<ref>[https://www.enthought.com/ Enthought].</ref> : distribution à usage scientifique, disponible en version gratuite (Canopy Express) ou commerciale.
* [[Anaconda (Python distribution)|Anaconda]]<ref>[http://continuum.io/ Anaconda].</ref> : distribution à usage scientifique, disponible en version gratuite ou commerciale.
* [[Intel]] Distribution for Python<ref>[https://software.intel.com/en-us/intel-distribution-for-python Intel Distribution for Python].</ref> : distribution basée sur Anaconda, intégrant notamment la bibliothèque {{Lien|langue=en|trad=Math Kernel Library|fr=Math Kernel Library|texte=MKL}} d'Intel afin d'accélérer les calculs numériques de bibliothèques telles que [[NumPy]] et [[SciPy]], intégrées à la distribution. Elle est disponible gratuitement seule, ou bien intégrée à [[Intel Parallel Studio]], qui nécessite une licence payante.
* Pyzo<ref>[http://www.pyzo.org/ Pyzo].</ref> : « ''Python to the people'' », destinée à être facile d'utilisation.
* WinPython<ref>[https://winpython.github.io WinPython].</ref>: distribution à usage scientifique avec [[Spyder (logiciel)|Spyder]], QT{{etc}}

Ce ne sont pas des ''implémentations'' différentes du langage Python : elles sont basées sur CPython, mais sont livrées avec un certain nombre de bibliothèques préinstallées.

== Historique des versions ==

{{Section sources secondaires|date=novembre 2024}}

{| class="wikitable sortable"
! Version !! Date de sortie 
!Fin de support!! class="unsortable" | Nouveautés majeures<ref>[https://docs.python.org/fr/3/whatsnew/ Nouveautés de Python] sur python.org</ref>
|-
|| 1.5(.2) || {{Date|03|janvier|1998|en informatique}}
|{{Date|13 avril 1999}}||
* Ajout du mot clé '''assert'''
* Possibilité d'importer une hiérarchie de modules (import spam.ham.eggs)
* Nouveau module [[Expression rationnelle|re]] qui remplace regex
* Les exceptions sont maintenant des classes
* Ajout de l'option -O qui supprime les assertions et informations de ligne de fichier
|-
|| 1.6 || {{Date|5|septembre|2000|en informatique}} 
|{{Date|Septembre 2000}}||
* La méthode <code>append()</code> des listes n'accepte plus qu'un seul argument
* Le résultat des fonctions <code>str()</code> et <code>repr()</code> est maintenant beaucoup plus souvent différent, exemple : <code>str(1L)=='1' et repr(1L)=='1L'</code>
* Les chaînes de caractères ont maintenant des méthodes (<code>" abc ".strip()</code>)
* Le module <code>re</code> est compatible avec l'ancien moteur, est plus rapide, et accepte les chaînes Unicode
* Ajout du module distutils
* Nouveau prototype <code>def f(*args, **kw)</code> pour les fonctions, avant il fallait utiliser <code>apply()</code>
*<code>int()</code> et <code>long()</code> acceptent maintenant une base en second argument
* L'opérateur in peut être surchagé avec une méthode <code>__contains__()</code>
|-
|| 2.0 || {{Date|16|octobre|2000|en informatique}} 
|{{Date|2001-06-22}}||
* Changement majeur : support d'Unicode
* Ajout des compréhensions de liste (''List Comprehensions'')
* Ajout des opérateurs avec assignement (<code>a+=b</code>, <code>a*=b</code>, etc.)
* Les chaînes str ont maintenant des méthodes
* Nouveau [[ramasse-miettes (informatique)|ramasse-miettes]] à cycles
* Ajout des modules <code>distutils</code>, <code>xml.dom.minidom</code> et <code>xml.sax</code>
|-
|| 2.1 || {{Date|15|avril|2001|en informatique}}
|{{Date|2002-04-09}}||
* Création du module <code>__future__</code> pour rendre les transitions plus douces
* Comparaisons riches (méthodes  <code>__lt__</code>, <code>__le__</code>...)
* Framework d'avertissement
* Ajout des modules [[Introspection (informatique)|inspect]], [[Commentaire (informatique)|pydoc]], [[Méthode agile|doctest]], [[pyunit]]
* Ajout des références faibles (''{{lang|en|weak references}}'')
* Les fonctions peuvent avoir des attributs
* ''{{lang|en|Nested Scopes}}''
* La version 2.0.1 ({{Date||juin|2001|en informatique}}) sera la première version compatible [[Licence publique générale GNU|GPL]]
|-
|| 2.2 || {{Date|21|décembre|2001|en informatique}} 
|{{Date|2003-05-30}}||
* Unification de Type et de Class : on peut maintenant hériter des types de base
* Ajout des [[itérateur (motif de conception)|itérateurs]] et [[générateur (informatique)|générateurs]]
* Nouvel opérateur a // b pour la division entière
|-
|| 2.3 || {{Date|29|06|2003|en informatique}}
|{{Date|2008-03-11}}||
* Ajout des fonctions enumerate() et sum()
* Le type [[Algèbre de Boole (logique)|bool]] est maintenant vraiment distinct d'un entier
* Beaucoup d'améliorations du support [[Unicode]]
|-
|| 2.4 || {{Date|30|novembre|2004|en informatique}} 
|{{Date|2008-12-19}}||
* Ajout des décorateurs de fonction/méthode (@decorateur)
* Conversion automatique d'un entier court en entier long si le résultat d'une opération est trop grand
* Expressions de générateur renvoyant les résultats l'un après l'autre et non pas sous forme d'une liste, exemple : <code>sum( x for x in xrange(10000) )</code>
* Ajout des fonctions <code>reversed()</code> et <code>sorted()</code>
* La fonction de tri <code>sort()</code> accepte les mots clés cmp, key et reverse
* Création du module decimal et du routeur
|-
|| 2.5 || {{Date|19|septembre|2006|en informatique}} 
|{{Date|2011-05-26}}||
* Ajout de l'instruction '''with'''
* Ajout des méthodes send(), throw() et close() aux générateurs
* Expression conditionnelle (<code>a if test else b</code>)
* Les imports de module peuvent être relatifs
* Ajout des méthodes partition() et rpartition() aux chaînes str et unicode
* Ajout des fonctions any() et all()
* Intégration des bibliothèques ctypes, ElementTree, hashlib, sqlite3 et wsgiref
|-
|| 2.6 || {{Date|1|octobre|2008|en informatique}} 
|{{Date|2010-08-24}} (mises à jour de sécurité jusqu'au {{Date|2013-10-29}})||
* Nouvelle syntaxe de formatage de chaînes de caractères 
* Classes de bases abstraites
* Décorateurs de classes
* Modules [[JSON]], multiprocessing, contextmanager et fractions
* Amélioration de la compatibilité avec Python 3
|-
|| 2.7 || {{Date|3|juillet|2010|en informatique}} 
|{{Date|2020-01-01}}||
* Syntaxe pour les ensembles littéraux : <code>{1, 2, 3}</code> au lieu de <code>set((1, 2, 3))</code>
* Compréhension de dictionnaire et d'ensemble, exemples : <code>{i: i*2 for i in range(3)}</code> (dictionnaire) et <code>{i*2 for i in range(3)}</code> (ensemble)
* Possibilité de spécifier plusieurs gestionnaires de contexte avec une seule déclaration <code>with</code>
* Réimplementation de la bibliothèque io (entrées/sorties) en C pour offrir de meilleures performances. Cette bibliothèque est notamment utile pour accéder à un fichier texte en Unicode.
* Dictionnaires ordonnés comme décrits dans la PEP 372 : <code>from collections import OrderedDict</code>
* La méthode format gère la numérotation automatique : <code>'{} {}!'.format('Hello', 'World')</code> donne 'Hello World'!
* Le formatage des nombres gère les séparateurs de milliers, exemple : <code>'{:,}'.format(10800)</code> donne '10,800'
* Amélioration de précision lors des conversions chaîne vers flottant et flottant vers chaîne. Pour un flottant, float(repr(x)) donnera toujours x.
* Nouveau module argparse pour parser la ligne de commande : version améliorée du module optparse
* Configuration basée sur des dictionnaires pour le module logging
* Objets memoryview : vue en lecture seule ou lecture-écriture d'un objet binaire (API similaire à celle du type bytes)
* Type PyCapsule pour l'API C (pour les modules d'extension)
* Les types int et long gagnent une méthode bit_length() : nombre de bits nécessaires pour représenter la valeur absolue du nombre
|-
|| 3.0 || {{Date|3|décembre|2008|en informatique}}<ref>Python 3.0 http://www.python.org/download/releases/3.0/.</ref> 
|{{Date|2009-02-13}}||
* Fusion des types 'int' et 'long'
* Les chaînes sont en Unicode par défaut, 'bytes' remplace l'ancien type 'str'
* Utilise des itérateurs plutôt que des listes là où c'est approprié (ex : <code>dict.keys()</code>)
*<code>a/b</code> est la vraie division par défaut
* exec et print deviennent des fonctions
*<code>None</code>, <code>True</code> et <code>False</code> deviennent des mots clé
* Le fichier <code>__init__.py</code> n'est plus nécessaire pour les modules Python
*<code>`x`</code> et l'opérateur <code><></code> disparaissent
* De nombreuses fonctions disparaissent : <code>apply()</code>, <code>buffer()</code>, <code>callable()</code>...
*<code>reduce()</code> disparaît au profit des boucles explicites

''Voir la [http://www.python.org/dev/peps/pep-3100/ PEP 3100] pour les détails''
|-
|| 3.1 || {{Date|27|juin|2009|en informatique}}<ref>Python 3.1 http://www.python.org/download/releases/3.1/.</ref> 
|{{Date|2011-06-12}} (mises à jour de sécurité jusqu'en {{Date|2012-06}})||
* Ajout d'un type de dictionnaire ordonné,
* Optimisations diverses apportées au type 'int',
* Nouvelles fonctionnalités du module 'unittest',
* Module d'entrées/sorties 'io' rendu plus rapide,
* Intégration de l'instruction « import » en pur Python
* Nouvelle syntaxe pour les instructions 'with' imbriquées.
|-
|| 3.2 || {{Date|20|février|2011|en informatique}}<ref>Python 3.2 http://www.python.org/download/releases/3.2/.</ref> 
|{{Date|2013-05-13}} (mises à jour de sécurité jusqu'au {{Date|2016-02-20}})||
* Ajout du module '''argparse''' pour le parsing des arguments passés à un programme
* Modification de la gestion des fichiers compilés ''.pyc''
* Ajout des certificats (protocole HTTPS)
* Amélioration du module '''pickle'''
* Réintroduction de la fonction <code>callable()</code> (retirée en 3.0)
|-
|| 3.3 || {{Date|29|septembre|2012|en informatique}}<ref name="py3">Python 3.3 http://www.python.org/download/releases/3.3.0/.</ref> 
|{{Date|2014-03-08}} (mises à jour de sécurité jusqu'au {{Date|2017-09-29}})||
* Ajout de la syntaxe {{code|yield from}} pour utiliser des sous-générateurs<ref name="py3" />
* La syntaxe u'unicode' est de nouveau acceptée<ref>{{lien web |titre=PEP 380 -- Syntax for Delegating to a Subgenerator |url=http://www.python.org/dev/peps/pep-0380/ |site=Python.org |consulté le=27-07-2020}}.</ref>
* Ajout du module faulthandler pour aider à déboguer les problèmes de bas niveau
* Support pour la compression [[LZMA]]
* Ajout d'un module pour les [[Mock (programmation orientée objet)|Mock]] dans unittest
* Incorporation des fonctionnalités du module virtualenv avec le module venv
* Refonte de la hiérarchie des erreurs système (I/O).
|-
|| 3.4 || {{Date|16|mars|2014|en informatique}}<ref name="py34">{{Lien web|titre=Python 3.4|url=https://www.python.org/download/releases/3.4.0/}}.</ref>
|{{Date|2017-08-09}} (mises à jour de sécurité jusqu'au {{Date|2019-03-18}})||
* ajout du module asyncio pour la programmation asynchrone<ref>{{Lien web|titre=Nouveautés de Python 3.4 — Python 3.4.5 documentation|url=https://docs.python.org/fr/3/whatsnew/3.4.html|site=docs.python.org|consulté le=2017-02-02}}.</ref>
|-
|| 3.5 || {{Date|13|septembre|2015|en informatique}}<ref name="py35">{{Lien web|titre=Python 3.5|url=https://www.python.org/download/releases/3.5.0/}}.</ref>
|{{Date|2017-08-08}} (mises à jour de sécurité jusqu'au {{Date|2020-09-13}})||
* nouvel opérateur pour les matrices : {{code|a @ b}}<ref>{{Lien web|titre=Nouveautés de Python 3.5 — Python 3.5.3 documentation|url=https://docs.python.org/fr/3/whatsnew/3.5.html|site=docs.python.org|consulté le=2017-02-02}}.</ref>
* ajout de la syntaxe {{code|await}} et <code>async</code> pour la programmation asynchrone
* création du module '''typing''' qui fournit une [[Interface de programmation|API]] pour le type hinting en ajoutant des outils tels que <code>Callable</code>, <code>Generic</code>, <code>TypeVar</code>, etc. ''Voir la [https://peps.python.org/pep-0484/ PEP 484] pour les détails''
|-
|3.6
|{{date|23|décembre|2016}}<ref>[https://www.python.org/downloads/release/python-360/ Python 3.6.0].</ref>
|{{Date|2018-12-24}} (mises à jour de sécurité jusqu'en {{Date|2021-12}})
|
* Possibilité d'écrire les grands nombres sous la forme : {{code|1_000_000}}<ref>[https://www.python.org/dev/peps/pep-0515/ PEP 515 - Underscores in Numeric Literals].</ref>.
* Ajout du module {{code|secrets}} pour simplifier la [[Générateur de nombres pseudo-aléatoires|génération de nombres pseudo-aléatoires]] de qualité cryptographique<ref>[https://www.python.org/dev/peps/pep-0506/ PEP 506 - Adding A Secrets Module To The Standard Library].</ref>.
* Nouveau formattage des chaines de caractères (les f-strings)<ref>[https://www.python.org/dev/peps/pep-0498/ PEP 498 - Literal String Interpolation].</ref> :<syntaxhighlight lang="python3">
>>> var = 50
>>> print(f'On affiche {var}')
On affiche 50
</syntaxhighlight>
|-
|3.7
|{{date-|31 janvier 2018}}<ref name="whatsnew 3.7">{{Lien web|titre=Nouveautés de Python 3.7 — Python 3.7.0a4 documentation|url=https://docs.python.org/3.7/whatsnew/3.7.html|site=docs.python.org|consulté le=2018-01-31}}.</ref>
|{{Date|2020-06-27}} (mises à jour de sécurité jusqu'en {{Date|2023-06}})
|
* Nouveaux modules.
* Nouveau mode de développement (X)<ref name="whatsnew 3.7" />.
* Support des variables de contexte via le nouveau module ''contextvars''<ref>https://docs.python.org/fr/3/library/contextvars.html.</ref>''.''
*''async'' et ''await'' font maintenant partie officiellement des mots-clefs réservés, même s'ils étaient déjà considérés comme tel par nombre de lexers et faisaient partie du langage depuis Python 3.5<ref>https://docs.python.org/fr/3/library/asyncio-task.html#awaitables.</ref>.
* ajout d'une nouvelle fonction intégrée : ''breakpoint()'' permettant une meilleure insertion de points d'arrêt<ref>{{lien web |titre=PEP 553 -- Built-in breakpoint() |url=https://www.python.org/dev/peps/pep-0553/ |site=Python.org |consulté le=27-07-2020}}.</ref>.
* le module ''time'' a maintenant un support pour les nanosecondes grâce à la méthode ''time.time_ns()'' ainsi que d'autres méthodes notamment de l'objet ''clock''<ref>https://docs.python.org/fr/3/library/time.html#time.time_ns.</ref>''.''
|-
|3.8
|{{date-|14 octobre 2019}}
|{{Date|2021-04}} (mises à jour de sécurité jusqu'en {{Date|2024-10}})
| {{…}}

* Dernière version supportant Windows 7.
|-
|3.9
|{{Date|2020-10-05}}
|{{Date|2022-05}} (mises à jour de sécurité jusqu'en {{Date|2025-10}})
|
* Support de l'opérateur union pour les dictionnaires<ref>{{Lien web |langue=en |auteur=Steven D'Aprano |auteur2=Brandt Bucher |titre=PEP 584 |url=https://www.python.org/dev/peps/pep-0584/ |site=python.org |date=1 mars 2019 |consulté le=16 novembre 2020}}.</ref>
* Nouvelles méthodes de suppression des préfixes et/ou suffixes pour les chaînes de caractères<ref>{{Lien web |langue=en |auteur=Dennis Sweeney |titre=PEP 616 |url=https://www.python.org/dev/peps/pep-0616/ |site=python.org |date=19 mars 2020 |consulté le=16 novembre 2020}}.</ref>
* Nouveaux modules :
** zoneinfo : support des fuseaux horaires IANA<ref>{{Lien web |langue=en |auteur=Paul Ganssle |titre=PEP 615 |url=https://www.python.org/dev/peps/pep-0615/ |site=python.org |date=22 février 2020 |consulté le=16 novembre 2020}}.</ref>
** graphlib : outils de tri dans des graphes
* Support des types standards pour l'annotation de type au lieu de ceux définit dans le module typing, exemple : list au lieu de typing.List<ref>{{Lien web |langue=en |auteur=Łukasz Langa |titre=PEP 585 |url=https://www.python.org/dev/peps/pep-0585/ |site=python.org |date=3 mars 2019 |consulté le=16 novembre 2020}}.</ref>
* Changement de cycle de publication des versions majeures de Python : une fois par an, en octobre<ref>{{Lien web |langue=en |auteur=Łukasz Langa |titre=PEP 602 |url=https://www.python.org/dev/peps/pep-0602/ |site=python.org |date=4 juin 2019 |consulté le=16 novembre 2020}}.</ref>{{,}}<ref>{{Lien web |langue=en |auteur=Łukasz Langa |titre=What's New In Python 3.9 |url=https://docs.python.org/3/whatsnew/3.9.html |site=docs.python.org |date=16 novembre 2020 |consulté le=16 novembre 2020}}.</ref>
|-
|3.10
|{{Date|2021-10-04}}
|{{Date|2023-04-03}} (mises à jour de sécurité jusqu'en {{Date|2026-10}})
|
* Écriture des unions de types sous la forme X | Y <ref>{{Lien web |langue=en |auteur=Maggie Moss, Philippe PRADOS |titre=PEP 0604 |url=https://www.python.org/dev/peps/pep-0604/ |site=python.org}}</ref>

* Spécification du paramètre des variables <ref>{{Lien web |langue=en |auteur=Mark Mendoza |titre=PEP 0612 |url=https://www.python.org/dev/peps/pep-0612/ |site=python.org}}</ref>

* Ajout de TypeAlias qui permet de définir sans ambiguïté un alias de type<ref>{{Lien web |langue=en |auteur=Shannon Zhu |titre=PEP 0613 |url=https://www.python.org/dev/peps/pep-0613/ |site=python.org}}</ref>

* Ajout du paramètre strict (par défaut à False) à la fonction zip permettant de relever une ValueError si les listes n'ont pas le même nombre d'éléments <ref>{{Lien web |langue=en |auteur=Brandt Bucher |titre=PEP 0618 |url=https://www.python.org/dev/peps/pep-0618/ |site=python.org}}</ref>

* Amélioration du débugger en spécifiant la ligne qui pose un problème <ref>{{Lien web |langue=en |auteur=Mark Shannon |titre=PEP 0626 |url=https://www.python.org/dev/peps/pep-0626/ |site=python.org}}</ref>

* Structural Pattern Matching <ref>{{Lien web |langue=en |auteur=Brandt Bucher, Guido van Rossum |titre=PEP 0634 |url=https://www.python.org/dev/peps/pep-0634/ |site=python.org}}</ref>{{,}}<ref>{{Lien web |langue=en |auteur=Tobias Kohn,Guido van Rossum |titre=PEP 0635 |url=https://www.python.org/dev/peps/pep-0635/ |site=python.org}}</ref>{{,}}<ref>{{Lien web |langue=en |auteur=Daniel F Moisset |titre=PEP 0636 |url=https://www.python.org/dev/peps/pep-0636/ |site=python.org}}</ref>

|-
|3.11
|{{Date|2022-10-24}}
|{{Date|2027-10}}
|
* [[CPython|Cpython]] est en moyenne 25% plus rapide pour exécuter un programme<ref>{{Ouvrage|titre=Faster CPython Benchmark Infrastructure|éditeur=faster-cpython|date=2023-10-02|lire en ligne=https://github.com/faster-cpython/benchmarking-public|consulté le=2023-10-07}}</ref>
* Meilleure gestion des exceptions :
** Possibilité de les regrouper dans <code>ExceptionGroup</code>, un nouveau type d'exceptions<ref>{{Lien web |titre=PEP 654 – Exception Groups and except* {{!}} peps.python.org |url=https://peps.python.org/pep-0654/ |site=peps.python.org |consulté le=2023-10-07}}</ref>
** Nouvelle syntaxe <code>except*</code> pour pouvoir gérer les exceptions présentes dans un groupe d'exceptions
** Ajout d'une méthode <code>add_note</code> à <code>BaseException</code><ref>{{Lien web |titre=PEP 678 – Enriching Exceptions with Notes {{!}} peps.python.org |url=https://peps.python.org/pep-0678/ |site=peps.python.org |consulté le=2023-10-07}}</ref>
* Ajout du module '''tomllib''' pour le parsing des fichiers [[TOML]]<ref>{{Lien web |titre=tomllib — Parse TOML files |url=https://docs.python.org/3/library/tomllib.html |site=Python documentation |consulté le=2023-10-07}}</ref>
* De nombreux ajouts concernant les annotations de type :
** <code>TypeVarTuple</code> qui permet le paramétrage d'une fonction générique avec un nombre quelconque de types<ref>{{Lien web |titre=PEP 646 – Variadic Generics {{!}} peps.python.org |url=https://peps.python.org/pep-0646/ |site=peps.python.org |consulté le=2023-10-07}}</ref>
** <code>LiteralString</code> qui permet de spécifier une {{Lien|langue=en|trad=String literal|fr=Chaîne de caractère littérale}}<ref>{{Lien web |titre=PEP 675 – Arbitrary Literal String Type {{!}} peps.python.org |url=https://peps.python.org/pep-0675/ |site=peps.python.org |consulté le=2023-10-07}}</ref>
** <code>Required</code> et <code>NotRequired</code> dans un <code>TypeDict</code> qui permettent de spécifier si un élément est optionnel ou non<ref>{{Lien web |langue=fr |titre=Les nouveautés de Python 3.11 |url=https://docs.python.org/3/whatsnew/3.11.html#pep-655-marking-individual-typeddict-items-as-required-or-not-required |site=Python documentation |consulté le=2023-10-07}}</ref>
** <code>Self</code> qui permet d'annoter de façon plus simple et concise qu'avec <code>TypeVar</code> les [[Méthode (informatique)|méthodes]] qui retournent une [[Instance (programmation)|instance]] spécifique de leur [[Classe (informatique)|classe]]
|-
|3.12
|{{Date|2023-10-02}}
|{{Date|2028-10}}
|
* Amélioration des f-strings pour le formattage des [[Chaîne de caractères|chaînes de caractères]]<ref>{{Lien web |titre=PEP 701 – Syntactic formalization of f-strings {{!}} peps.python.org |url=https://peps.python.org/pep-0701/ |site=peps.python.org |consulté le=2023-10-08}}</ref>
* Possibilité (seulement en passant par [[C (langage)|C]] mais prévu pour Python en 3.13) d'avoir un unique GIL par [[Interprète (informatique)|interprète]]<ref>{{Lien web |titre=PEP 684 – A Per-Interpreter GIL {{!}} peps.python.org |url=https://peps.python.org/pep-0684/ |site=peps.python.org |consulté le=2023-10-08}}</ref>
* Nouvelle [[Interface de programmation|API]] pour les outils tels que les [[Débogueur|debuggers]] ou les [[Profilage de code|profilers]], permettant de directement surveiller les événements dans [[CPython|Cpython]] avec un coût faible en performance<ref>{{Lien web |titre=PEP 669 – Low Impact Monitoring for CPython {{!}} peps.python.org |url=https://peps.python.org/pep-0669/ |site=peps.python.org |consulté le=2023-10-08}}</ref>
* Concernant les annotations de type :
** Nouvelle manière plus concise et compacte de définir des fonctions et classes génériques. De même pour les alias de type via la nouvelle instruction <code>type</code><ref name="What’s New In Python 3.12">{{Lien web |titre=What’s New In Python 3.12 |url=https://docs.python.org/3/whatsnew/3.12.html |site=Python documentation |consulté le=2023-10-08}}</ref>
** Ajout du [[Décorateur (patron de conception)|décorateur]] <code>override</code> dans le module '''typing'''<ref name="What’s New In Python 3.12" />
** Possibilité d'utiliser un <code>TypedDict</code> pour spécifier le typage de <code>**kwargs</code><ref>{{Lien web |titre=PEP 692 – Using TypedDict for more precise **kwargs typing {{!}} peps.python.org |url=https://peps.python.org/pep-0692/ |site=peps.python.org |consulté le=2023-10-08}}</ref>
|-
|3.13
|{{Date|2024-10-01}}
|{{Date|2029-10}}
|

|}

== Développement ==
=== Les PEP ===
Les propositions d'amélioration de Python (ou PEP : ''Python Enhancement Proposal'') sont des documents textuels qui ont pour objet d'être la voie d'amélioration de Python et de précéder toutes ses modifications<ref>[https://www.python.org/dev/peps/ Index of Python Enhancement Proposals].</ref>. Un PEP est une proposition d'orientation pour le développement ''(process PEP)'', une proposition technique ''(Standard Track PEP)'' ou une simple recommandation (''Informational PEP''). La PEP la plus connue est la PEP 8 pour son guide sur le style de code.

=== Python 3 ===
En 2009, c'est la version 3 de Python, qui remplace de plus en plus la version 2 (le projet était au départ appelé « Python 3000 » ou « Py3K »), sans compatibilité descendante avec la série des versions 2.x, dans le but d'éliminer les faiblesses du langage. La ligne de conduite du projet était de « réduire la redondance de Python par la suppression de méthodes obsolètes ». Python 3.0a1, la première version alpha, avait été publiée le {{date-|31 août 2007}}<ref name="autogenerated1">[http://python.org/download/releases/3.0/ Python 3.0a3 Release<!-- Titre généré automatiquement -->].</ref>, et il existe un PEP<ref>[http://www.python.org/peps/pep-3000.html Python 3000].</ref> qui détaille les changements prévus, ainsi qu'une page pour orienter les programmeurs dans leur choix de Python 2 ou 3<ref>[http://wiki.python.org/moin/Python2orPython3 Should I use Python 2 or Python 3 for my development activity?].</ref>.

Les calculatrices destinées aux lycéens (dont [[Casio]], [[NumWorks]], [[Texas Instruments]]…) et supportant Python<ref>Support par exemple exigé en [[France]] en 2019.</ref> fonctionnent en Python 3. Ces calculatrices peuvent échanger des programmes avec des [[ordinateurs personnels]].

==== 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 <code>print</code> nécessite l'emploi de parenthèses contrairement à Python 2.

==== Planning et compatibilité ====
Python 3.0a1, la première version alpha de Python 3.0, fut publiée le {{date-|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<ref>[http://www.python.org/dev/peps/pep-3000/ Plan de développement PEP 3000].</ref> 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<ref>Sam Ruby, [http://intertwingly.net/blog/2007/09/01/2to3 2to3], {{1er}} septembre 2007.</ref>. 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<ref>[http://www.python.org/dev/peps/pep-0361/ PEP 361].</ref>.

=== Python pour smartphones ===
Il existe des versions de Python adaptées pour [[Android]] et [[iPhone]] en version 2.5 ou 2.6. Disponible en [[Jailbreak d'iOS]] sur [[IOS (Apple)|iOS]] grâce à "setup tools", et sur Android grâce à [[SL4A]] qui donne même une possibilité de faire des petites [[interface graphique|interfaces graphiques]] grâce au module "android" et qui permet d'envoyer des [[SMS]], d'allumer la caméra<ref>http://code.google.com/p/android-scripting/.</ref>, ou encore de faire vibrer le téléphone. Les quelques lignes suivantes montrent comment faire ça :
<syntaxhighlight lang="python">
droid = android.Android() # client lié au serveur local lancé par l'application SL4A
       # pour contrôler un téléphone distant à l'adresse 192.168.0.5, avec SL4A lancé sur le port 9887
       # il suffit de faire : android.Android('192.168.0.5', 9887)

droid.vibrate(2.5) # fait vibrer le téléphone (local ou distant) pendant 2.5 secondes
</syntaxhighlight>

Un portage de Python sur les terminaux [[BlackBerry (société)|Blackberry]] est sorti en {{date||juin|2012}}, pour le système [[BlackBerry OS]] 10<ref>[http://blackberry-py.microcode.ca/ BlackBerry-Py Project].</ref>. Une version allégée est sortie en {{date-|septembre 2012}}, appelée « BlackBerry-Tart »<ref>[http://hg.microcode.ca/blackberry-py/wiki/Home blackberry-py] sur [[Bitbucket]].</ref>{{,}}<ref>[http://peterhansen.ca/blog/blackberry-tart-preview.html BlackBerry-Tart Preview].</ref>, en raison d'un jeu de mots en anglais : « ''a "tart" is lighter-weight than a "pie"'' », en référence à la traditionnelle « ''apple pie'' ». Elle est basée sur Python 3.2.2.

== Notes et références ==
{{Références}}

== Voir aussi ==
{{Autres projets
 | commons           = Category:Python (programming language)
 | commons titre     = Python
 | wiktionary        = Python
 | wikiversity       = Python
 | wikiversity titre = Python
 | wikibooks         = Catégorie:Python
 | wikibooks titre   = Python
}}
=== Bibliographie ===
*{{Ouvrage|auteur1=Doug Hellmann|titre=The Python Standard Library by Example|éditeur=[[Addison-Wesley]]|année=2017}}
*{{Ouvrage|auteur1=Mark Lutz|titre=Learning Python|éditeur=[[O'Reilly Media|O'Reilly]]|année=2013|numéro d'édition=5}}
*{{Ouvrage|auteur1=Luciano Ramalho|titre=Programmer en Python|sous-titre=Apprendre la programmation de façon claire, concise et efficace|titre original=Fluent Python: Clear, concise and effective programming|éditeur=[[O'Reilly Media|O'Reilly]]|année=2019}}

=== Liste des principaux frameworks ===
* Bibliothèques scientifiques :
** Calcul : [[NumPy]], [[SciPy]], [[Pandas]], [[International Mathematics and Statistics Library|PyIMSL Studio]], [[Sympy]], [[SageMath]]
** [[Système expert]] : [[pyCLIPS]], [[pyswip]], pyDatalog, pyKE (« Python Knowledge Engine »)
** Visualisation : [[pydot]], [[Matplotlib]], [[pyngl]], [[MayaVi]]
** [[Exploration de données]] : [[Orange (logiciel)|Orange]]
** Simulation : [[simPy]]
** Chimie : [[PyMOL]], [[MMTK]], [[Chimera (logiciel)|Chimera]], [[PyQuante]]
** Biologie : [[Biopython]]
* [[Logiciel utilitaire|Utilitaire]] : [[eGenix]], [[ctype]], Askbot
* [[Analyse syntaxique|Analyseur syntaxique]] : [[PyParsing]], [[PLY (Python Lex-Yacc)|PLY]] (« Python Lex & Yacc »), [[NLTK]] (« Natural Language Toolkit »), [[SpaCy]]
* [[Générateur de documentation]] : [[Sphinx (générateur de documentation)|Sphinx]]
* Graphisme : [[Python Imaging Library|PIL]] / « Pillow » [[Soya 3D]], [[Vpython]], [[pymedia]], [[NodeBox]], [[Mahotas]]
* Jeux : [[Pygame]], [[Panda3D]]
* [[Framework]] web : [[Django (framework)|Django]], [[Karrigell]], webware, {{Lien|langue=en|fr=Grok (framework)|texte=Grok}}, [[TurboGears]], {{Lien|langue=en|trad=Pylons project|fr=Pylons}}, [[Flask (framework)|Flask]], [[Bottle (framework)|Bottle]]
* [[Serveur HTTP|Serveur web]], [[Système de gestion de contenu|CMS]] : [[Plone]], [[Zope]], [[Google App Engine]], [[CherryPy]], MoinMoin, [[django CMS]]
* [[Système d'information géographique|Cartographie]] : TileCache, FeatureServer, Cartoweb 4, Shapely, GeoDjango, PCL
* Protocoles :
** pyTango
** [[Sérialisation]] : [[SimpleJSON]]
** [[Transmission Control Protocol|TCP]], [[User Datagram Protocol|UDP]], [[Secure Sockets Layer|SSL]]/[[Transport Layer Security|TLS]], multicast, Unix sockets, [[Hypertext Transfer Protocol|HTTP]], [[Network News Transfer Protocol|NNTP]], [[Internet Message Access Protocol|IMAP]], [[Secure Shell|SSH]], [[Internet Relay Chat|IRC]], [[File Transfer Protocol|FTP]] : [[Twisted]]
* Vecteur : [[GeoJSON]], OWSLib, Quadtree, Rtree, Shapely, WorldMill, ZCO
* [[Mapping objet-relationnel|ORM]] : SQLObject, [[SQLAlchemy]], Storm, Django ORM
* Driver [[Système de gestion de base de données|SGBD]] : [[PyGresQL]], Psycopg, [https://pypi.python.org/pypi/MySQL-python MySQL-python]
* Apprentissage : [[Keras]]

=== Articles connexes ===
* [[Zen de Python]] : principes de design et d'utilisation de Python
* [[pip (gestionnaire de paquets)|Pip]] : [[gestionnaire de paquets]] des [[Paquet (logiciel)|paquets]] Python.
* [[Cython]] : langage permettant d'écrire des modules compilables pour Python.
* [[IPython]] : terminal interactif.
* [[RUR-PLE]] : outil éducatif pour apprendre le Python de façon ludique en pilotant un robot virtuel.
* [[PyPI]] : dépôt tiers officiel.

{{Palette|Python|Langages de programmation|Langages Serveurs}}

{{Portail|informatique|logiciels libres|programmation informatique}}

[[Catégorie:Python|*]]
[[Catégorie:Langage de programmation]]
[[Catégorie:Langage impératif]]
[[Catégorie:Langage fonctionnel]]
[[Catégorie:Langage orienté objet]]
[[Catégorie:Langage de script]]
[[Catégorie:Logiciel libre sous licence PSFL]]
Modèles utilisés par cette page :
Modèle:' (voir la source) (semi-protection étendue)
Modèle:, (voir la source) (protégé)
Modèle:1er (voir la source) (protégé)
Modèle:Abréviation discrète (voir la source) (protégé)
Modèle:Article (voir la source) (protégé)
Modèle:Article détaillé (voir la source) (protégé)
Modèle:Autres projets (voir la source) (protégé)
Modèle:Autres projets/styles.css (voir la source) (semi-protection étendue)
Modèle:Blanc (voir la source) (protégé)
Modèle:Bma (voir la source) (semi-protection étendue)
Modèle:Catégorisation badges (voir la source) (protégé)
Modèle:Citation (voir la source) (protégé)
Modèle:Classes début infobox (voir la source) (protégé)
Modèle:Code (modifier)
Modèle:Contrôle date bandeau (voir la source) (semi-protection étendue)
Modèle:Date (voir la source) (protégé)
Modèle:Date- (voir la source) (protégé)
Modèle:Dièse couleur web (voir la source) (semi-protection étendue)
Modèle:En (voir la source) (protégé)
Modèle:Etc (voir la source) (semi-protection étendue)
Modèle:Etc. (voir la source) (protégé)
Modèle:Exp (voir la source) (protégé)
Modèle:First word (voir la source) (semi-protection étendue)
Modèle:Indication de langue (voir la source) (protégé)
Modèle:Infobox/Début (voir la source) (protégé)
Modèle:Infobox/Fin (voir la source) (protégé)
Modèle:Infobox/Image optionnelle (voir la source) (protégé)
Modèle:Infobox/Ligne mixte optionnelle (voir la source) (protégé)
Modèle:Infobox/Notice (voir la source) (protégé)
Modèle:Infobox/Pictogramme/informatique.css (voir la source) (semi-protection étendue)
Modèle:Infobox/Séparateur optionnel (voir la source) (semi-protection étendue)
Modèle:Infobox/Titre (voir la source) (protégé)
Modèle:Infobox Langage de programmation (modifier)
Modèle:Infodoc (voir la source) (protégé)
Modèle:Lang (voir la source) (protégé)
Modèle:Langue (voir la source) (protégé)
Modèle:Last word (voir la source) (semi-protection étendue)
Modèle:Lien (voir la source) (protégé)
Modèle:Lien vers modèle (voir la source) (protégé)
Modèle:Lien web (voir la source) (protégé)
Modèle:Liste horizontale (voir la source) (semi-protection étendue)
Modèle:Légende Wikidata (voir la source) (semi-protection étendue)
Modèle:M (voir la source) (protégé)
Modèle:MSAPI (voir la source) (semi-protégé)
Modèle:Multiparamètres-Lien (voir la source) (protégé)
Modèle:Méta bandeau (voir la source) (protégé)
Modèle:Méta bandeau d'avertissement (voir la source) (protégé)
Modèle:Méta bandeau de note (voir la source) (semi-protection étendue)
Modèle:Méta bandeau de section (voir la source) (protégé)
Modèle:Méta lien vers portail (voir la source) (protégé)
Modèle:Méta lien vers portail/Catégorisation (voir la source) (protégé)
Modèle:Méta palette de navigation (voir la source) (protégé)
Modèle:Nombre (voir la source) (protégé)
Modèle:Non vide (voir la source) (semi-protection étendue)
Modèle:Numéro (voir la source) (protégé)
Modèle:N° (voir la source) (semi-protection étendue)
Modèle:Ouvrage (voir la source) (protégé)
Modèle:Palette (voir la source) (protégé)
Modèle:Palette Langages Serveurs (modifier)
Modèle:Palette Langages de programmation (modifier)
Modèle:Palette Python (modifier)
Modèle:Portail (voir la source) (protégé)
Modèle:Portail informatique (voir la source) (semi-protection étendue)
Modèle:Portail logiciels libres (modifier)
Modèle:Portail programmation informatique (modifier)
Modèle:Références (voir la source) (protégé)
Modèle:Section sources secondaires (voir la source) (semi-protection étendue)
Modèle:Section vide ou incomplète (voir la source) (protégé)
Modèle:Sources secondaires (voir la source) (semi-protection étendue)
Modèle:Suivi des biographies (voir la source) (protégé)
Modèle:Tnavbar (voir la source) (protégé)
Modèle:Trim (voir la source) (protégé)
Modèle:Unité (voir la source) (protégé)
Modèle:Urldecode (voir la source) (semi-protection étendue)
Modèle:Voir homonymes (voir la source) (protégé)
Modèle:Wikidata (voir la source) (protégé)
Modèle:X10 (voir la source) (semi-protection étendue)
Modèle:Âge (voir la source) (protégé)
Modèle:… (voir la source) (protégé)
Module:API (voir la source) (semi-protection étendue)
Module:API/Infobulle (voir la source) (semi-protection étendue)
Module:Bandeau (voir la source) (protégé)
Module:Bandeau/Class (voir la source) (protégé)
Module:Biblio (voir la source) (protégé)
Module:Biblio/Article (voir la source) (semi-protection étendue)
Module:Biblio/Commun (voir la source) (protégé)
Module:Biblio/Lien web (voir la source) (protégé)
Module:Biblio/Ouvrage (voir la source) (semi-protection étendue)
Module:Biblio/Références (voir la source) (protégé)
Module:Catégorisation badges (voir la source) (semi-protection étendue)
Module:Correction syntaxique (voir la source) (semi-protection étendue)
Module:Date (voir la source) (protégé)
Module:Date/Data (voir la source) (semi-protection étendue)
Module:Date complexe (voir la source) (semi-protection étendue)
Module:Dictionnaire Wikidata/Codes langue (voir la source) (semi-protection étendue)
Module:Dièse couleur web (voir la source) (semi-protection étendue)
Module:Durée (voir la source) (semi-protection étendue)
Module:Fix (voir la source) (semi-protection étendue)
Module:Image (voir la source) (protégé)
Module:Image Wikidata (voir la source) (semi-protection étendue)
Module:Infobox/Titre (voir la source) (protégé)
Module:Interface Wikidata (voir la source) (semi-protection étendue)
Module:Langue (voir la source) (protégé)
Module:Langue/Data (voir la source) (semi-protection étendue)
Module:Lien interwiki (voir la source) (semi-protection étendue)
Module:Lien interwiki/data catégorisation (voir la source) (semi-protection étendue)
Module:Linguistique (voir la source) (semi-protection étendue)
Module:Multiparamètres (voir la source) (semi-protection étendue)
Module:Nombre2texte (voir la source) (protégé)
Module:Nombre2texte/Data (voir la source) (semi-protection étendue)
Module:Outils (voir la source) (protégé)
Module:Palette (voir la source) (semi-protection étendue)
Module:String (voir la source) (semi-protection étendue)
Module:Suivi des biographies (voir la source) (protégé)
Module:Suivi des biographies/données (voir la source) (semi-protection étendue)
Module:TableBuilder (voir la source) (protégé)
Module:Unité (voir la source) (protégé)
Module:Unité/Data (voir la source) (semi-protection étendue)
Module:Urldecode (voir la source) (semi-protection étendue)
Module:Weblink (voir la source) (semi-protection étendue)
Module:Wikidata (voir la source) (semi-protection étendue)
Module:Wikidata/I18n (voir la source) (semi-protection étendue)
Module:Yesno (voir la source) (protégé)
Revenir à la page Python (langage).
Ce document provient de « https://fr.wikipedia.org/wiki/Python_(langage) ».