Edición de «Historia de Python»

[[Archivo:Python-logo-notext.svg|miniaturadeimagen|derecha|Logo de Python]]
{{AP|Python}}

'''Python''' es uno de los [[Tipado dinámico|lenguajes de programación dinámicos]] más populares que existen entre los que se encuentran [[Java (lenguaje de programación)|Java]], [[JavaScript]], [[Go (lenguaje de programación)|Go]] y [[C Sharp|C#]]. Aunque es considerado a menudo como un lenguaje "scripting", es realmente un lenguaje de propósito general. En la actualidad, Python es usado para todo, desde simples "scripts", hasta grandes servidores web que proveen servicio ininterrumpido 24×7. Es utilizado para la programación de interfaces gráficas y bases de datos, programación web tanto en el cliente como en el servidor ''(véase [[Django (framework)|Django]] o [[Flask]])'' y "testing" de aplicaciones. Además tiene una amplia aceptación por científicos que hacen aplicaciones para las supercomputadores más rápidas del mundo y por los niños que recién están comenzando a programar.

La '''historia del lenguaje de programación Python''' se remonta hacia finales de los 80s y principio de los 90s,<ref name="venners-interview-pt-1">{{cita web|url=http://www.artima.com/intv/pythonP.html|título=The Making of Python|fechaacceso=22 de marzo de 2007|editorial=Artima Developer}}</ref> su implementación comenzó en diciembre de 1989<ref name="timeline-of-python">{{cita web|url=http://python-history.blogspot.com/2009/01/brief-timeline-of-python.html|título=A Brief Timeline of Python|fechaacceso=5 de enero de 2015|editorial=Guido Van Rossum}}</ref> cuando en Navidad [[Guido van Rossum]] que trabajaba en el (CWI) (un centro de investigación holandés de carácter oficial que, entre otras cosas, actualmente alberga la oficina central del W3C) decidió empezar el proyecto como un pasatiempo dándole continuidad al [[lenguaje de programación ABC]] del que había formado parte del equipo de desarrollo en el CWI,<ref name = "faq-created">{{cita web|url=https://www.python.org/doc/faq/general/#why-was-python-created-in-the-first-place|título=Why was Python created in the first place?|fechaacceso=5 de enero de 2015|editorial=Python FAQ}}</ref> dicho lenguaje se enfocaba en ser fácil de usar y aprender manteniendo potencia en su desempeño pero el hardware disponible en la época de su creación hacía difícil su uso y el proyecto no trascendió como se esperaba. Van Rossum es por tanto el autor principal de Python y continúa ejerciendo un rol central decidiendo la dirección del lenguaje, en la comunidad de Python se le conoce como ''[[Benevolent Dictator for Life|Benevolente Dictador Vitalicio]]'' (en inglés: ''Benevolent Dictator for Life'', BDFL). El nombre "Python" viene dado por la afición de Van Rossum al grupo [[Monty Python]].

El lenguaje de programación Python fue originalmente desarrollado para el sistema operativo [[Amoeba_(sistema_operativo)|Amoeba]].

== Principales influencias de otros lenguajes ==
El núcleo de la sintaxis de Python y grandes aspectos de su filosofía fueron heredados directamente del [[lenguaje de programación ABC]]. Por ejemplo el siguiente código muestra una función para obtener el conjunto de todas las palabras en un documento en ABC<ref name="abc-example">{{cita web|url=http://homepages.cwi.nl/~steven/abc|título=The ABC Programming Language|fechaacceso=5 de enero de 2015}}</ref> y en Python:
{|width="100%"
!width="50%" valign="top"|Recuperar las palabras de un documento en [[lenguaje de programación ABC|ABC]]
!width="50%" valign="top"|Recuperar las palabras de un documento en Python
|-
|valign="top"|
<syntaxhighlight lang="text">
HOW TO RETURN words document:
    PUT {} IN collection
    FOR line IN document:
        FOR word IN split line:
            IF word not.in collection:
                INSERT word IN collection
    RETURN collection
</syntaxhighlight>
|valign="top"|
<syntaxhighlight lang="python">
def words(document):
    collection = set()
    for line in document:
        for word in line.split():
            if word not in collection:
                collection.add(word)
    return collection
</syntaxhighlight>
|}

En ABC no existe propiamente el [[tipo de dato]] conjunto, sino algo como multiconjuntos, es decir, si se inserta un elemento dos veces, aparecerá dos veces en esa colección, pero en Python el <code>if</code> puede ser eliminado porque la operación <code>add</code> sobre los conjuntos en Python no hace nada si el elemento ya está en el conjunto. Se puede observar perfectamente las similitudes entre ambos códigos, la sangría, el ciclo <code>for</code>, el operador <code>in</code>, pero también sus diferencias, como por ejemplo en ABC no se utilizan paréntesis y en Python sí, además las palabras claves en ABC son escritas en mayúsculas así como los nombres de los procedimientos o funciones; ABC hace distinción entre procedimiento y función, otra diferencia con Python.

Las principales ideas de ABC que influyeron o se incluyeron en Python fueron según el propio Guido:<ref>{{cita web|url=https://www.youtube.com/watch?v=ugqu10JV7dk|título=The History of Python|fechaacceso=5 de enero de 2015}}</ref>
* La sangría para agrupar el código
* El carácter ''':''' para indicar que comienza un bloque indentado (después de pruebas con usuarios)
* El diseño simple de las instrucciones: <code>if</code>, <code>while</code>, <code>for</code>,...
* Tuplas, listas, diccionarios (fuertemente modificados en Python)
* Tipos de datos inmutables
* No imponer límites, como tamaño de un array, etc.
* El "prompt" >>>

Otras ideas que influyeron en la concepción de Python fue tener un lenguaje que pudiera ser tan potente como [[C (lenguaje de programación)|C]] pero también expresivo para ejecutar "scripts" como [[Bourne shell|sh]].<ref name="98-interview">{{cita web|url=http://www.amk.ca/python/writing/gvr-interview|título=Interview with Guido Van Rossum|fechaacceso=29 2007|fecha=julio de 1998|urlarchivo=https://web.archive.org/web/20070501105422/http://www.amk.ca/python/writing/gvr-interview|fechaarchivo=1 de mayo de 2007}}</ref> De hecho la sintaxis de Python copia muchísimo de C. Por ejemplo, las palabras claves (<code>if</code>, <code>else</code>, <code>while</code>, <code>for</code>, etc.) son las mismas que en C, los identificadores tienen las mismas reglas para nombrarlos que C, y la mayoría de los operadores estándar tienen el mismo significado que en C. Una de las mayores diferencias es que Python en lugar de usar llaves para agrupar código usa sangría, la otra gran diferencia es que Python usa tipado dinámico.

Los generadores e iteradores fueron inspirados por [[Icon]], y fusionados con las ideas de la programación funcional en un modelo unificado. [[Modula-3]] fue la base del modelo de excepciones y del sistema de módulos.<ref name="venners-interview-pt-1" /><ref name = "faq-created" /> [[Perl]] contribuyó en las [[expresiones regulares]], usadas para la manipulación de "string".<ref>https://docs.python.org/library/re.html</ref> Las adiciones a biblioteca estándar de Python standard library y algunas opciones sintácticas fueron influenciadas por [[Java (lenguaje de programación)|Java]] algunos ejemplos son: el paquete de <code>logging</code>,<ref>{{cita web|url=https://www.python.org/dev/peps/pep-0282/|título=PEP 282 - A Logging System|fechaacceso=24 de noviembre de 2008|editorial=Python.org}}</ref> introducido en la versión 2.3,<ref>{{cita web|url=https://www.python.org/doc/2.3/whatsnew/node9.html|título=8 PEP 282: The logging Package|fechaacceso=24 de noviembre de 2008|editorial=Python.org|urlarchivo=https://web.archive.org/web/20081220035601/http://www.python.org/doc/2.3/whatsnew/node9.html|fechaarchivo=20 de diciembre de 2008}}</ref> el paquete <code>threading</code> para aplicaciones [[multihilos]],<ref>https://docs.python.org/library/threading.html</ref> el parser [[Simple API for XML|SAX]], introducido en la versión 2.0, y la sintaxis del [[Python sintaxis y semántica#Decoradores|decorador]] que usa <code>@</code>,<ref>{{cita web|url=https://www.python.org/dev/peps/pep-0318/|título=PEP 318 - Decorators for Functions and Methods|fechaacceso=24 de noviembre de 2008|editorial=Python.org}}</ref> incluida en la versión 2.4<ref>{{cita web|url=https://www.python.org/doc/2.4/whatsnew/node6.html|título=5 PEP 318: Decorators for Functions and Methods|fechaacceso=24 de noviembre de 2008|editorial=Python.org|urlarchivo=https://web.archive.org/web/20081210084736/http://www.python.org/doc/2.4/whatsnew/node6.html|fechaarchivo=10 de diciembre de 2008}}</ref>

== Cronología de Python ==
[[Archivo:PythonTimeline 1.png|marco|derecha|Las versiones indicadas en rojo se consideran obsoletas.]]
[[Archivo:PythonTimeline 2.png|marco|derecha|Las versiones indicadas en rojo se consideran obsoletas.]]
Fechas de publicación:<ref>{{Cita web |url=https://www.python.org/download/releases |título=Copia archivada |fechaacceso=6 de enero de 2015 |urlarchivo=https://web.archive.org/web/20151222142552/https://www.python.org/download/releases/ |fechaarchivo=22 de diciembre de 2015 }}</ref><ref>http://python-history.blogspot.com/2009/01/brief-timeline-of-python.html</ref>

* Comienzo de la implementación - December, 1989
* Publicación interna en CWI - 1990
* Python 0.9.0 - 20 de febrero de 1991	(publicado en alt.sources)<ref name="history">{{cita web|url=http://python-history.blogspot.com/2009/01/brief-timeline-of-python.html|sitioweb=The History of Python|título=A Brief Timeline of Python|nombre=Guido|apellido=van Rossum|enlaceautor=Guido van Rossum|fecha=20 de enero de 2009|fechaacceso=14 de febrero de 2021|idioma=en}}</ref>
** Python 0.9.1 - febrero de 1991
** Python 0.9.2 - otoño de 1991
** Python 0.9.4 - 24 de diciembre de 1991
** Python 0.9.5 - 2 de enero de 1992 (solo para Macintosh)
** Python 0.9.6 - 6 de abril de 1992
** Python 0.9.7 beta - 1992
** Python 0.9.8 - 9 de enero de 1993
** Python 0.9.9 - 29 de julio de 1993
* Python 1.0 - enero de 1994
** Python 1.5 - 31 de diciembre de 1997
** Python 1.6 - 5 de septiembre de 2000
* Python 2.0 - 16 de octubre de 2000
** Python 2.1 - 17 de abril de 2001
** Python 2.2 - 21 de diciembre de 2001
** Python 2.3 - 29 de julio de 2003
** Python 2.4 - 30 de noviembre de 2004
** Python 2.5 - 19 de septiembre de 2006
** Python 2.6 - 1 de octubre de 2008
** Python 2.7 - 3 de julio de 2010
* Python 3.0 - 3 de diciembre de 2008
** Python 3.1 - 27 de junio de 2009
** Python 3.2 - 20 de febrero de 2011
** Python 3.3 - 29 de septiembre de 2012
** Python 3.4 - 16 de marzo de 2014
**Python 3.5 - 8 de febrero de 2015
**Python 3.6 - 23 de diciembre de 2016
**Python 3.7 - 12 de junio de 2018
**Python 3.8 - 14 de octubre de 2019
**Python 3.9 - 5 de octubre de 2020

== Primera publicación ==

El 20 de febrero de 1991, van Rossum publicó el código por primera vez en [news:alt.sources alt.sources], con el número de versión 0.9.0.<ref name="history" /> En esta etapa del desarrollo ya estaban presentes clases con [[Herencia (informática)|herencia]], [[manejo de excepciones]], [[Subrutina|funciones]] y los tipos modulares, como: <code>str</code>, <code>list</code>, <code>dict</code>, entre otros. Además en este lanzamiento inicial aparecía un sistema de módulos adoptado de [[Modula-3]]; Van Rossum describe el módulo como “una de las mayores unidades de programación de Python”.<ref name="venners-interview-pt-1" /> El modelo de excepciones en Python es parecido al de Modula-3, con la adición de una cláusula <code>else</code>.<ref name="faq-created" /> En el año 1994 se formó [news:comp.lang.python comp.lang.python], el foro de discusión principal de Python, marcando un hito en el crecimiento del grupo de usuarios de este lenguaje.

== Versión 1.0 ==

Python llega a la versión 1.0 en enero de 1994. Las características más importantes incluidas en esta publicación fueron las herramientas de la programación funcional <code>[[Cálculo lambda|lambda]]</code>, <code>reduce</code>, <code>filter</code> y <code>map</code>. Van Rossum ha comentado que "Python adquiere lambda, reduce(), filter() y map(), cortesía de un hacker de [[Lisp]] que las extrañaba y envió parches que funcionaban".<ref name="reduce-fate">{{cita web|url=http://www.artima.com/weblogs/viewpost.jsp?thread=98196|título=The fate of reduce() in Python 3000|fechaacceso=22 de marzo de 2007|autor=Guido Van Rossum|editorial=Artima Developer}}</ref>

La última versión liberada proveniente de CWI fue Python 1.2. En 1995, van Rossum continuó su trabajo en Python en la [[Corporation for National Research Initiatives]] (CNRI) en Reston, [[Virginia]], donde lanzó varias versiones del [[software]].

Para la versión 1.4, Python adquirió varias características nuevas. Es notable entre estas los argumentos por nombre inspirados por Modula-3 (que también son similares a los de [[Common Lisp]]) y soporte "built-in" para los [[números complejos]].

Durante su estancia en CNRI, Van Rossum lanzó la iniciativa ''Computer Programming for Everybody'' (CP4E), con el fin de hacer la programación más accesible a más gente, con un nivel de 'alfabetización' básico en lenguajes de programación, similar a las habilidades básicas en inglés y matemáticas necesarias por muchos empleadores. Python tuvo un papel crucial en este proceso: debido a su orientación hacia una sintaxis limpia, ya era idóneo, y las metas de CP4E presentaban similitudes con su predecesor, ABC. El proyecto fue patrocinado por [[DARPA]].<ref>[https://web.archive.org/web/20090223101648/http://python.org/doc/essays/cp4e.html Computer Programming for Everybody]</ref> El proyecto CP4E está inactivo, y mientras tanto Python intenta ser fácil de aprender y no muy arcano en su sintaxis y semántica, pero alcanzar a los no-programadores ya no es una preocupación activa.<ref>{{cita web|url=https://www.python.org/cp4e/|título=Computer Programming for Everybody|fechaacceso=22 de marzo de 2007|editorial=Python Software Foundation|urlarchivo=https://web.archive.org/web/20070329060757/http://www.python.org/cp4e/|fechaarchivo=29 de marzo de 2007}}</ref>

=== BeOpen ===
En el año 2000, el equipo principal de desarrolladores de Python se cambió a [[BeOpen.com]] para formar el equipo BeOpen [[PythonLabs]]. CNRI pidió que la versión 1.6 fuera publicada hasta el punto de desarrollo en que el equipo abandonó CNRI. Consecuentemente su agenda de lanzamiento para la versión 1.6 y la versión 2.0 tenían una significativa cantidad de solapamiento.<ref name="newin-2.0">[https://web.archive.org/web/20070329043037/http://www.amk.ca/python/2.0/ What's New in Python 2.0]</ref> Python 2.0 fue el primer y único lanzamiento de BeOpen.com. Después que Python 2.0 fuera publicado por BeOpen.com, Guido van Rossum y los otros desarrolladores de PythonLabs se unieron a [[Zope|Digital Creations]].

La publicación de Python 1.6 incluía una nueva licencia de CNRI que era substancialmente más larga que la licencia de CWI que había sido usada en las publicaciones anteriores.
La nueva licencia incluía una cláusula estipulando que la licencia estaba gobernada por las leyes del estado de [[Virginia]].  La [[Free Software Foundation]] (FSF) argumento la cláusula era incompatible con [[GNU General Public License|GNU GPL]].  Entonces BeOpen, CNRI, y FSF acordaron cambiar Python hacia una [[licencia de software libre]] que lo haría compatible con GPL.  Python 1.6.1 es básicamente el mismo que Python 1.6, con unos arreglos de [[error de software|bugs]], y con la nueva licencia compatible con GPL.<ref name="lib-history">{{cita web|url=https://www.python.org/doc/2.5/lib/node951.html|título=History of the software|fechaacceso=22 de marzo de 2007|obra=Python Library Reference|urlarchivo=https://web.archive.org/web/20070329061639/http://www.python.org/doc/2.5/lib/node951.html|fechaarchivo=29 de marzo de 2007}}</ref>

== Versión 2.0 ==
Python 2.0 tomó una importante característica del lenguaje de [[programación funcional]] [[Haskell]]: generación de listas. La sintaxis de Python para esta construcción es muy similar a la de Haskell, salvo por la preferencia de los caracteres de puntuación en Haskell, y la preferencia de Python por palabras claves. Python 2.0 introdujo además un sistema de [[recolección de basura]] capaz de recolectar referencias cíclicas.

Python 2.1 fue un trabajo derivado de Python 1.6.1, así como también de Python 2.0. Su licencia fue renombrada a: [[Python Software Foundation License]]. Todo el código, documentación y especificaciones añadidas, desde la fecha del lanzamiento de la versión alfa de Python 2.1, pertenece a [[Python Software Foundation]] (PSF), una organización sin ánimo de lucro fundada en el año 2001, tomando como modelo la [[Apache Software Foundation]].<ref name="lib-history" /> Este lanzamiento incluyó un cambio en el lenguaje para soportar ámbitos anidados (más conocido en programación como "nested scopes") como lo soportan otros lenguajes de "[[static scoping]]" (del cual [[Scheme]] es el originador).<ref>[http://www.python.org/dev/peps/pep-0227/ PEP 227 -- Statically Nested Scopes]</ref> (Esta característica fue deshabilitada por defecto, y no requerida, hasta Python 2.2.)

Una gran innovación en Python 2.2 fue la unificación de los tipos en Python (tipos escritos en C), y clases (tipos escritos en Python) dentro de una jerarquía. Esa unificación logró un modelo orientado a objetos de Python puro y consistente.<ref>[http://docs.python.org/whatsnew/2.2.html#peps-252-and-253-type-and-class-changes PEPs 252 and 253: Type and Class Changes]</ref> También fueron agregados los [[generador (informática)|generadores]] que fueron inspirados por el lenguaje [[Icon]].<ref>[http://docs.python.org/whatsnew/2.2.html#pep-255-simple-generators PEP 255: Simple Generators]</ref>

== Versión 3.0 ==
Python 3.0 (también conocido como "Python 3000" o "Py3K") fue diseñado para rectificar ciertas fallas fundamentales en el diseño del lenguaje (los cambios requeridos no podían ser implementados mientras se mantuviera compatibilidad hacia atrás con la serie 2.x).  El principio que guía Python 3 es: "reducir la duplicación de características eliminando viejas formas de hacer las cosas (reduce feature duplication by removing old ways of doing things)".

=== Filosofía ===
Python 3.0 fue desarrollado con la misma filosofía que en las versiones anteriores. Sin embargo, como Python ha acumulado nuevas y redundantes formas de programar la misma tarea, Python 3.0 ha hecho énfasis en eliminar constructores duplicados y módulos, en consecuencia con "Debe haber un— <!-- if you intend to correct the spacings on the em dashes, leave it alone, it's a tongue in cheek in the original philosophy by Tim Peters -->y preferiblemente solo un —modo obvio de hacerlo".

A pesar de esto, Python 3.0 se mantiene como un lenguaje de programación multiparadigma. Los programadores todavía tienen opciones entre [[orientación a objetos]], [[programación estructurada]], [[programación funcional]] y otros paradigmas, pero dentro de estas amplias opciones, los detalles intentan ser más obvios en Python 3.0 que como eran en Python 2.x.

=== Cronología y compatibilidad ===
Python 3.0 fue lanzado el 3 de diciembre de 2008.<ref name="3.0-release">[https://www.python.org/download/releases/3.0/ Python 3.0 release]</ref>
Las series Python 2.x y Python 3.x estaban planeadas para coexistir por varias publicaciones lanzándolas en paralelo, con la serie 2.x existente mayormente por compatibilidad y con algunas nuevas características siendo importadas hacia atrás de la serie 3.x.
Python 2.6 fue liberado para coincidir con Python 3.0, e incluye algunas características de esa publicación, así como un modo de "alertas (warnings)" que resalta el uso de características que han sido eliminadas en Python 3.0.<ref name="pep-361">{{cita web|url=https://www.python.org/dev/peps/pep-0361/|título=PEP 361 -- Python 2.6 and 3.0 Release Schedule|fechaacceso=7 de octubre de 2012|fecha=29 de junio de 2006|author1=Neal Norwitz|author2=Barry Warsaw}}</ref>
Similarmente, Python 2.7 coincide e incluye características de Python 3.1,<ref name="whatsnew2.7">{{cita web|url=https://docs.python.org/release/2.7/whatsnew/2.7.html|título=What’s New in Python 2.7|fechaacceso=7 de octubre de 2012|autor=A.M. Kuchling|fecha=3 de julio de 2010|cita=Much as Python 2.6 incorporated features from Python 3.0, version 2.7 incorporates some of the new features in Python 3.1. The 2.x series continues to provide tools for migrating to the 3.x series.}}</ref> que fue publicado el 26 de junio de 2009.
Python 2.7 fue la última publicación en la serie 2.x;<ref name="pep-404">{{cita web|url=https://www.python.org/dev/peps/pep-0404/|título=PEP 404 -- Python 2.8 Un-release Schedule|fechaacceso=7 de octubre de 2012|autor=Barry Warsaw|fecha=9 de noviembre de 2011}}</ref> las publicaciones en paralelo terminaron con Python 3.2.

Python 3.0 rompe la [[compatibilidad hacia atrás]]. El código de Python 2.x no necesariamente debe "correr" en Python 3.0 sin modificarlo. Hay cambios básicos tales como el cambio de <code>print</code> en una función (por lo tanto cualquier uso como <code>print "Hello Python"</code> provocará un error en Python 3.x), y el cambio a [[Unicode]] para todos los textos "strings". El [[tipado dinámico]] de Python combinado con los planes para cambiar la semántica de ciertos métodos de los diccionarios, por ejemplo, hacen que convertir perfectamente de Python 2.x a Python 3.0 sea muy difícil de manera automática. Sin embargo, una herramienta llamada "2to3" puede hacer la mayoría del trabajo de "traducción", señalando áreas que son confusas para ella usando comentarios o alertas. Incluso en la etapa "alpha", 2to3 se mostraba claramente satisfactoria para ejecutar las traducciones del código.<ref>Sam Ruby, [http://intertwingly.net/blog/2007/09/01/2to3 2to3], September 1, 2007</ref> Para proyectos que requerían compatibilidad de ambas versiones 2.x y 3.x, el equipo de Python recomendó guardar el [[código fuente]] de las versiones 2.x, y generar versiones a Python 3.x usando 2to3. Se desaconsejó esta forma de conversión a Python 3.x si el código realmente necesitase ejecutarse en Python 2.x.

=== Características ===
Algunos de los mayores cambios anunciados para Python 3.0 fueron:
* Cambiar la instrucción <code>print</code> de modo que sea una función "built-in", no una instrucción. Esto ha hecho que sea más fácil cambiar un módulo para usar una función <code>print</code> diferente, así como hacer la sintaxis más regular.  En Python 2.6 y 2.7 esta característica puede ser habilitada usando <code>from __future__ import print_function</code>.<ref>[https://www.python.org/dev/peps/pep-3105/ PEP 3105]</ref>
* Moviendo <code>reduce</code> (pero no <code>map</code> o <code>filter</code>) fuera del espacio de nombres "built-in" dentro de "functools".<ref>[http://www.artima.com/weblogs/viewpost.jsp?thread=211200 Thread on Artima programmer blog]</ref>
* Adicionar soporte para anotación opcional en funciones que pueda ser usar para la declaración informal de tipos u otros propósitos.<ref>[https://www.python.org/dev/peps/pep-3107/ PEP 3197]</ref>
* Unificar los tipos <code>str</code>/<code>unicode</code>, representando texto, e introduciendo un tipo immutable <code>bytes</code>; y un más correspondiente tipo mutable <code>bytearray</code>, ambos de los cuales representan "arrays" de [[byte]]s;<ref>[https://www.python.org/dev/peps/pep-3137/ PEP 3137]: Immutable Bytes and Mutable Buffer</ref>
* Eliminar [[compatibilidad hacia atrás]], incluidas clases "old-style", excepciones "string", e implícitos "imports" relativos.

Las subsecuentes publicaciones de la serie Python 3.x han incluido sustanciales nuevas características; todas al corriente del desarrollo que el lenguaje ha tenido en la serie 3.x.

== Véase también ==
* [[Python]]
* [[Django (framework)|Django]]
* [[Flask]]

== Referencias ==
{{listaref|2}}

== Enlaces externos ==
* [http://python-history.blogspot.com/ Guido Van Rossum blog on Python's History]
*[https://www.grupocodesi.com/blog/historia-de-python.html Historia de Python Origen y evolución]

{{Control de autoridades}}
[[Categoría:Python]]
[[Categoría:Historia del software|Python]]