Sintaxis y semántica de Python

La sintaxis del lenguaje de programación Python es el conjunto de reglas que define cómo se escribirá e interpretará un programa Python (tanto por el sistema de ejecución como por programadores). Python comparte muchas similitudes con Perl , C y Java . Sin embargo, existen diferencias importantes entre estos lenguajes. Admite múltiples paradigmas de programación , incluyendo la programación estructurada, la programación orientada a objetos y la programación funcional , y cuenta con un sistema de tipos dinámico y gestión automática de memoria .

La sintaxis de Python es simple y consistente, y se rige por el principio de que "debe haber una —y preferiblemente solo una— manera obvia de hacerlo". El lenguaje incorpora tipos de datos y estructuras integrados , mecanismos de control de flujo , funciones de primera clase y módulos para una mejor reutilización y organización del código . Python también utiliza palabras clave en inglés donde otros lenguajes usan signos de puntuación, lo que contribuye a su diseño visual claro y ordenado.

El lenguaje ofrece un manejo de errores robusto mediante excepciones e incluye un depurador en la biblioteca estándar para una resolución de problemas eficiente. La sintaxis de Python, diseñada para ser legible y fácil de usar, la convierte en una opción popular tanto para principiantes como para profesionales.

Python fue diseñado para ser un lenguaje altamente legible . ^{[ 1 ]} Tiene una disposición visual relativamente despejada y usa palabras clave en inglés con frecuencia donde otros lenguajes usan signos de puntuación . Python busca ser simple y consistente en el diseño de su sintaxis, encapsulado en el mantra "Debe haber una —y preferiblemente solo una— manera obvia de hacerlo" , del Zen de Python . ^{[ 2 ]}

Este mantra se opone deliberadamente al mantra de Perl y Ruby : " hay más de una manera de hacerlo ".

Python 3 tiene 35 palabras clave o palabras reservadas ; no se pueden usar como identificadores . ^{[ 3 ] [ 4 ]}

Además, Python 3 también tiene 4 palabras clave suaves , incluyendo typeuna añadida en Python 3.12. A diferencia de las palabras clave duras regulares , las palabras clave suaves son palabras reservadas solo en contextos limitados donde interpretarlas como palabras clave tendría sentido sintáctico. Estas palabras pueden usarse como identificadores en otros lugares; en otras palabras, `match` y ` case` son nombres válidos para funciones y variables. ^{[ 6 ] [ 7 ]}

• _^{[ nota 4 ]}
• case^{[ nota 4 ]}
• match^{[ nota 4 ]}
• type

Las anotaciones de funciones (sugerencias de tipo) se definen en PEP 3107. ^{[ 8 ]} Permiten adjuntar datos a los argumentos y al valor de retorno de una función. El lenguaje no define el acto de usar anotaciones, sino que se deja a los frameworks de terceros. Por ejemplo, se podría escribir una biblioteca para manejar el tipado estático: ^{[ 8 ]}

def haul ( item : Haulable , * vargs : PackAnimal ) -> Distance : # implementación aquí

Si bien las anotaciones son opcionales en Python, el resto de este artículo las utilizará para brindar mayor claridad.

En Python, el código se organiza en archivos llamados módulos , y los espacios de nombres se definen en cada módulo. Dado que los módulos pueden estar contenidos en paquetes jerárquicos, los espacios de nombres también son jerárquicos. ^{[ 9 ] [ 10 ]} En general, cuando se importa un módulo, los nombres definidos en él se definen a través del espacio de nombres de ese módulo, y se accede a ellos desde los módulos que lo llaman utilizando el nombre completo.

# Supongamos que ModuleA define dos funciones: func1() y func2() y una clase: Class1 import ModuleAModuleA.func1 ( ) ModuleA.func2 ( ) a : ModuleA.Class1 = Modulea.Class1 ( )​​​​​

La from ... import ...instrucción se puede utilizar para insertar los nombres relevantes directamente en el espacio de nombres del módulo que realiza la llamada, y se puede acceder a esos nombres desde el módulo que realiza la llamada sin el nombre calificado:

# Supongamos que ModuleA define dos funciones: func1() y func2() y una clase: Class1 from ModuleA import func1func1 () func2 () # esto fallará como nombre indefinido, al igual que el nombre completo ModuleA.func2() a : Class1 = Class1 () # esto fallará como nombre indefinido, al igual que el nombre completo ModuleA.Class1()

Dado que esto importa nombres directamente (sin ninguna condición), puede sobrescribir los nombres existentes sin advertencias.

Una forma especial de la instrucción es from ... import *que importa todos los nombres definidos en el paquete nombrado directamente en el espacio de nombres del módulo que realiza la llamada. El uso de esta forma de importación, aunque está soportada por el lenguaje, generalmente se desaconseja ya que contamina el espacio de nombres del módulo que realiza la llamada y hará que los nombres ya definidos se sobrescriban en caso de conflictos de nombres. ^{[ 11 ]} Sin embargo, esta página presentará el código como si from typing import *se incluyera la línea " ", para hacer referencia a los tipos de colección.

Aquí se muestran las diferentes declaraciones de importación:

# importa el módulo de análisis de argumentos import argparse # importa la clase Pattern del módulo de expresiones regulares from re import Pattern # importa todos los símbolos dentro del módulo typing from typing import *

El uso from importde sentencias en Python puede simplificar los espacios de nombres extensos, como los espacios de nombres anidados.

from selenium.webdriver import Firefox from selenium.webdriver.common.action_chains import ActionChains from selenium.webdriver.common.by import By from selenium.webdriver.common.keys import Keys from selenium.webdriver.remote.webelement import WebElementif __name__ == " __main__ " : driver : Firefox = Firefox ( ) element : WebElement = driver.find_element ( By.ID , " myInputField " ) element.send_keys ( f " Hola Mundo { Keys.ENTER } " ) action : ActionChains = ActionChains ( driver ) action.key_down ( Keys.CONTROL ) .send_keys ( " a " ) . key_up ( Keys.CONTROL ) .perform ( )​​​​​​

Python también admite import x as ycomo una forma de proporcionar un alias o nombre alternativo para que lo utilice el módulo que realiza la llamada:

import numpy as np from numpy.typing import NDArray , float32a : NDArray [ float32 ] = np . organizar ( 1000 )

Cuando se importa un módulo, el intérprete de Python primero verifica si existe en la sys.modulescaché y lo reutiliza si se importó previamente; de ​​lo contrario, lo carga. Al cargarlo, lo busca en sys.pathy lo compila a bytecode o interpreta su contenido. Se ejecuta todo el código en el ámbito global del módulo. Sin embargo, esto se puede mitigar utilizando una función main explícita, que se comporta de manera similar a un punto de entrada en la mayoría de los lenguajes compilados, utilizando el patrón de punto de entrada que se describe a continuación.

importar sysdef main ( argv : list [ str ]) -> int : argc : int = len ( argv ) # obtener la longitud de argv n : int = int ( argv [ 1 ]) print ( n + 1 ) return 0if __name__ == "__main__" : sys . exit ( main ( sys . argv ))

Python utiliza espacios en blanco para delimitar los bloques de control de flujo (siguiendo la regla de fuera de línea ). Python toma prestada esta característica de su predecesor ABC : en lugar de signos de puntuación o palabras clave, utiliza la indentación para indicar la secuencia de un bloque .

En los lenguajes denominados de formato libre —que utilizan la estructura de bloques derivada de ALGOL— los bloques de código se delimitan con llaves ( ) o palabras clave. En la mayoría de las convenciones de codificación para estos lenguajes, los programadores suelen indentar el código dentro de un bloque para diferenciarlo visualmente del código circundante.{ }

Una función recursiva llamada , a la que se le pasa un único parámetro , , y si el parámetro es 0 llamará a una función diferente llamada y de lo contrario llamará , pasando , y también se llamará a sí misma recursivamente, pasando como parámetro, podría implementarse de esta manera en Python:fooxbarbazxx-1

def foo ( x : int ) -> None : if x == 0 : bar () else : baz ( x ) foo ( x - 1 )

y podría escribirse así en C :

void foo ( int x ) { if ( x == 0 ) { bar (); } else { baz ( x ); foo ( x - 1 ); } }

Un código con sangría incorrecta podría ser malinterpretado por un lector humano de manera diferente a como lo interpretaría un compilador o intérprete. Por ejemplo, si la llamada a la función foo(x - 1)en la última línea del ejemplo anterior tuviera una sangría errónea fuera del bloque / if:else

def foo ( x : int ) -> None : if x == 0 : bar () else : baz ( x ) foo ( x - 1 )

Esto provocaría que la última línea siempre se ejecutara, incluso cuando xes 0, lo que resultaría en una recursión infinita .

Aunque tanto los espacios como las tabulaciones se aceptan como formas de indentación y se puede usar cualquier múltiplo de espacios, se recomiendan los espacios ^{[ 15 ]} y cuatro espacios (como en los ejemplos anteriores) son, con mucho, los más utilizados. ^{[ 16 ] [ 17 ]} No se permite mezclar espacios y tabulaciones en líneas consecutivas a partir de Python 3 ^{[ 18 ]} porque puede crear errores difíciles de ver, ya que muchos editores de texto no distinguen visualmente los espacios y las tabulaciones.

Dado que Python es un lenguaje de tipado dinámico , los valores de Python, no las variables, contienen información de tipo . Todas las variables en Python contienen referencias a objetos , y estas referencias se pasan a las funciones. Algunas personas (incluido el propio creador de Python, Guido van Rossum ) han denominado a este esquema de paso de parámetros "llamada por referencia de objeto". Una referencia de objeto es un nombre, y la referencia pasada es un "alias", es decir, una copia de la referencia al mismo objeto, al igual que en C/ C++ . El valor del objeto puede modificarse en la función llamada con el "alias", por ejemplo:

my_list : lista [ str ] = [ "a" , "b" , "c" ] def my_func ( l : lista [ str ]) -> None : l . append ( "x" ) print ( l )print ( my_func ( my_list )) # imprime ['a', 'b', 'c', 'x'] print ( my_list ) # imprime ['a', 'b', 'c', 'x']

La función my_funccambia el valor de my_listcon el argumento formal l, que es un alias de my_list. Sin embargo, cualquier intento de operar (asignar una nueva referencia de objeto a) sobre el alias en sí no tendrá ningún efecto sobre el objeto original.

mi_lista : lista [ str ] = [ "a" , "b" , "c" ]def my_func ( l : list [ str ]) -> None : # l.append("x") l = l + [ "x" ] # una nueva lista creada y asignada a l significa que l ya no es un alias de my_list print ( l )print ( my_func ( my_list )) # imprime ['a', 'b', 'c', 'x'] print ( my_list ) # imprime ['a', 'b', 'c']

En Python, los nombres accesibles que no son locales ni globales declarados son todos alias.

Entre los lenguajes de tipado dinámico, Python cuenta con una comprobación de tipos moderada. La conversión implícita está definida para los tipos numéricos (así como para los booleanos ), por lo que se puede multiplicar válidamente un número complejo por un entero (por ejemplo) sin necesidad de una conversión explícita . Sin embargo, no existe una conversión implícita entre, por ejemplo, números y cadenas ; una cadena es un argumento inválido para una función matemática que espera un número.

Una de las ventajas de Python es la disponibilidad de un estilo de programación funcional , lo que hace que trabajar con listas y otras colecciones sea mucho más sencillo.

l : lista [ Cualquier ] = [ expresión_de_mapeo para elemento en lista_de_origen si expresión_de_filtro ]

potencias_de_dos : lista [ int ] = [ 2 ** n para n en rango ( 1 , 6 )]

T : TypeVar = TypeVar ( "T" )def qsort ( l : lista [ T ]) -> lista [ T ]: if l == []: return [] pivot : T = l [ 0 ] return ( qsort ([ x for x in l [ 1 :] if x < pivot ]) + [ pivot ] + qsort ([ x for x in l [ 1 :] if x >= pivot ]))

f : Llamable [[ int ], int ] = lambda x : x ** 2 f ( 5 )

def derivada ( f : Llamable [[ float ], float ], dx : float ): """Devuelve una función que aproxima la derivada de f  usando un intervalo de dx, que debe ser suficientemente pequeño.  """ def función ( x : float ) -> float : return ( f ( x + dx ) - f ( x )) / dx return función

def foo ( a : int , b : int ) -> None : print ( f "a: { a } " ) print ( f "b: { b } " ) def bar ( c : int ) -> None : b = c print ( f "b*: { b } " ) bar ( a ) print ( f "b: { b } " )print ( foo ( 1 , 2 )) # imprime: # a: 1 # b: 2 # b*: 1 # b: 2

importar itertoolsdef generate_primes ( stop_at : Optional [ int ] = None ) -> Iterator [ int ]: primes : list [ int ] = [] for n in itertools . count ( start = 2 ): if stop_at is not None and n > stop_at : return # genera la excepción StopIteration composite : bool = False for p in primes : if not n % p : composite = True break elif p ** 2 > n : break if not composite : primes . append ( n ) yield n

for i in generate_primes ( 100 ): # iterar sobre los números primos entre 0 y 100 print ( i )for i in generate_primes (): # iterar sobre TODOS los números primos indefinidamente print ( i )

importar itertoolsprimes_under_million : Iterador [ int ] = ( i para i en generate_primes ( ) si i < 1000000 ) two_thousandth_prime : Iterador [ int ] = itertools.islice ( primes_under_million , 1999 , 2000 ) .next ( )​

primes_under_million : lista [ int ] = [ i para i en generate_primes ( 2000000 ) si i < 1000000 ] two_thousandth_prime : int = primes_under_million [ 1999 ]

cuadrados = dict (( n , n * n ) for n in range ( 5 )) # en Python 3.5 y posteriores el tipo de cuadrados es dict[int, int] print ( cuadrados ) # imprime {0: 0, 1: 1, 2: 4, 3: 9, 4: 16}

print ([ n * n for n in range ( 5 )]) # comprensión de lista regular # imprime [0, 1, 4, 9, 16] print ({ n * n for n in range ( 5 )}) # comprensión de conjunto # imprime {0, 1, 4, 9, 16} print ({ n : n * n for n in range ( 5 )}) # comprensión de diccionario # imprime {0: 0, 1: 1, 2: 4, 3: 9, 4: 16}

Python admite la mayoría de las técnicas de programación orientada a objetos (POO). Permite el polimorfismo , no solo dentro de una jerarquía de clases , sino también mediante el tipado dinámico (duck typing ). Cualquier objeto puede usarse para cualquier tipo, y funcionará siempre que tenga los métodos y atributos adecuados. En Python, todo es un objeto, incluyendo clases, funciones, números y módulos. Python también admite metaclases , una herramienta avanzada para mejorar la funcionalidad de las clases. Naturalmente, admite la herencia , incluyendo la herencia múltiple . Python tiene un soporte muy limitado para variables privadas mediante la modificación de nombres (name mangling) , que rara vez se usa en la práctica, ya que algunos consideran que ocultar información no es propio de Python , pues sugiere que la clase en cuestión contiene detalles internos poco estéticos o mal planificados. El lema "somos todos usuarios responsables aquí" se usa para describir esta actitud. ^{[ 32 ]}

Al igual que ocurre con los módulos, las clases en Python no establecen una barrera absoluta entre la definición y el usuario, sino que confían en la cortesía del usuario para no "interferir en la definición".

En Python no se imponen doctrinas de la programación orientada a objetos (POO), como el uso de métodos de acceso para leer miembros de datos. Así como Python ofrece construcciones de programación funcional pero no exige transparencia referencial , ofrece un sistema de objetos pero no exige un comportamiento orientado a objetos . Además, siempre es posible redefinir la clase usando propiedades (ver Propiedades ) de modo que cuando se establece o recupera una variable determinada en el código que la llama, en realidad se invoca una llamada a función, lo que spam.eggs = toastpodría invocar realmente spam.set_eggs(toast). Esto anula la ventaja práctica de las funciones de acceso y sigue siendo POO porque la propiedad eggsse convierte en una parte legítima de la interfaz del objeto: no tiene por qué reflejar un detalle de implementación.

En la versión 2.2 de Python, se introdujeron las clases de "nuevo estilo". Con estas clases, los objetos y los tipos se unificaron, permitiendo la herencia de tipos. Incluso se pueden definir tipos completamente nuevos, con un comportamiento personalizado para los operadores infijos. Esto posibilita realizar numerosas modificaciones sintácticas radicales en Python. En la versión 2.3, también se adoptó un nuevo orden de resolución de métodos para la herencia múltiple. Asimismo, es posible ejecutar código personalizado al acceder o modificar atributos, aunque los detalles de estas técnicas han evolucionado entre las distintas versiones de Python.

clase MyClass : def __init __ ( self ) - > None : self._a : int = 0@property def a ( self ) -> int : return self . _a@a . setter # hace que la propiedad sea modificable def a ( self , value : int ) -> None : self . _a = value

Python admite (y utiliza ampliamente) el manejo de excepciones como un medio para comprobar si hay errores u otros eventos "excepcionales" en un programa.

El estilo de programación en Python exige el uso de excepciones siempre que pueda surgir un error. En lugar de comprobar si se puede acceder a un archivo o recurso antes de usarlo, en Python es habitual intentar usarlo directamente y capturar la excepción si se rechaza el acceso.

Las excepciones también pueden utilizarse como un medio más general de transferencia de control no local, incluso cuando no se trata de un error. Por ejemplo, el software de listas de correo Mailman , escrito en Python, utiliza excepciones para salir de una lógica de gestión de mensajes muy compleja cuando se ha decidido rechazar un mensaje o retenerlo para su aprobación por parte de un moderador.

Las excepciones se utilizan a menudo como alternativa al ifbloque `-block`, especialmente en situaciones multihilo . Un lema comúnmente invocado es EAFP, o "Es más fácil pedir perdón que permiso" ^{[ 35 ]} , que se atribuye a Grace Hopper . ^{[ 36 ] [ 37 ]} La ​​alternativa, conocida como LBYL, o "Piensa antes de actuar", comprueba explícitamente las precondiciones. ^{[ 38 ]}

En este primer ejemplo de código, siguiendo el enfoque LBYL, se realiza una comprobación explícita del atributo antes del acceso:

if hasattr ( spam , "eggs" ): ham = spam . eggs else : handle_missing_attr ()

Esta segunda muestra sigue el paradigma EAFP:

intentar : jamón = spam.huevos excepto AttributeError : handle_missing_attr ( )​

Estos dos ejemplos de código tienen el mismo efecto, aunque habrá diferencias de rendimiento. Cuando spamtiene el atributo eggs, el ejemplo EAFP se ejecutará más rápido. Cuando spamno tiene el atributo eggs(el caso "excepcional"), el ejemplo EAFP se ejecutará más lento. El perfilador de Python se puede usar en casos específicos para determinar las características de rendimiento. Si los casos excepcionales son raros, entonces la versión EAFP tendrá un rendimiento promedio superior a la alternativa. Además, evita toda la clase de vulnerabilidades de tiempo de verificación a tiempo de uso (TOCTTOU), otras condiciones de carrera , ^{[ 37 ] [ 39 ]} y es compatible con el tipado dinámico . Una desventaja de EAFP es que solo se puede usar con sentencias; una excepción no se puede capturar en una expresión generadora, comprensión de lista o función lambda.

Existen dos maneras de anotar código Python. Una consiste en usar comentarios para indicar la función de alguna parte del código. Los comentarios de una sola línea comienzan con el carácter de almohadilla (# #) y continúan hasta el final de la línea. Los comentarios que abarcan más de una línea se logran insertando una cadena de varias líneas (con el carácter de coma """o '''como delimitador en cada extremo) que no se utiliza en asignaciones ni se evalúa de ninguna otra manera, sino que se ubica entre otras instrucciones.

Comentar un fragmento de código:

importar sysdef getline () -> str : return sys . stdin . readline () # Obtiene una línea y la devuelve

Cómo comentar un fragmento de código con varias líneas:

def getline () -> str : """Esta función obtiene una línea y la devuelve. A modo de ejemplo, esta es una cadena de documentación de varias líneas. Se puede acceder a esta cadena completa como getline.__doc__.  """ return sys . stdin . readline ()

Las cadenas de documentación ( docstrings ), es decir, las cadenas que se encuentran solas sin asignación como la primera línea indentada dentro de un módulo, clase, método o función, establecen automáticamente su contenido como un atributo llamado __doc__, que está destinado a almacenar una descripción legible para humanos del propósito, comportamiento y uso del objeto. La función integrada helpgenera su salida en función de __doc__los atributos. Dichas cadenas pueden estar delimitadas con "o 'para cadenas de una sola línea, o pueden abarcar varias líneas si están delimitadas con o """, '''que es la notación de Python para especificar cadenas de varias líneas. Sin embargo, la guía de estilo del lenguaje especifica que se prefieren las comillas dobles triples ( """) tanto para cadenas de documentación de una sola línea como para cadenas de varias líneas. ^{[ 40 ]}

Cadena de documentación de una sola línea:

def getline () -> str : """Obtiene una línea de stdin y la devuelve.""" return sys . stdin . readline ()

Cadena de documentación multilínea:

def getline () -> str : """Obtiene una línea  de stdin  y la devuelve.  """ return sys . stdin . readline ()

Las cadenas de documentación pueden ser tan largas como el programador desee y contener saltos de línea . A diferencia de los comentarios, las cadenas de documentación son objetos de Python y forman parte del código interpretado que ejecuta Python. Esto significa que un programa en ejecución puede recuperar sus propias cadenas de documentación y manipular esa información, pero su uso habitual es proporcionar a otros programadores información sobre cómo invocar el objeto documentado en la cadena.

Existen herramientas que permiten extraer las cadenas de documentación del código Python y generar documentación. También se puede acceder a la documentación de las cadenas de documentación desde el intérprete con la help()función, o desde la consola con el comando pydocpydoc .

El módulo estándar doctest utiliza interacciones copiadas de sesiones de shell de Python en cadenas de documentación para crear pruebas, mientras que el módulo docopt las utiliza para definir opciones de línea de comandos.

Un decorador es cualquier objeto invocable de Python que se utiliza para modificar la definición de una función, método o clase. Al decorador se le pasa el objeto original que se está definiendo y devuelve un objeto modificado, que luego se vincula al nombre en la definición. Los decoradores de Python se inspiraron en parte en las anotaciones de Java y tienen una sintaxis similar; la sintaxis del decorador es pura azúcar sintáctica , utilizando @como símbolo. Sin embargo, a diferencia de los atributos generales en la mayoría de los lenguajes de programación, que se utilizan para agregar metadatos ya sea para el compilador o para su lectura en reflexión , los decoradores de Python no se utilizan para adjuntar metadatos, sino como envoltorios ejecutables.

@viking_chorus def menu_item () -> None : print ( "spam" )

es equivalente a

def menu_item () -> None : print ( "spam" ) menu_item = viking_chorus ( menu_item )

Los decoradores son una forma de metaprogramación ; mejoran la acción de la función o método que decoran. Por ejemplo, en el siguiente ejemplo, viking_choruspodría hacer menu_itemque se ejecute 8 veces (ver boceto de Spam ) por cada vez que se llama:

R : TypeVar = TypeVar ( "R" )def viking_chorus ( myfunc : Callable [ ... , R ]) -> Callable [ ... , None ]: def inner_func ( * args : * tuple [ Any , ... ], ** kwargs : Unpact [ dict [ str , Any ]]) -> None : for i in range ( 8 ): myfunc ( * args , ** kwargs ) return inner_func

Los usos canónicos de los decoradores de funciones son para crear métodos de clase o métodos estáticos , agregar atributos de función, rastrear , establecer precondiciones y postcondiciones , y sincronización , ^{[ 41 ]} pero pueden usarse para mucho más, incluyendo la eliminación de recursión de cola , ^{[ 42 ]} memorización e incluso mejorar la escritura de otros decoradores. ^{[ 43 ]}

Los elementos decorativos se pueden encadenar colocando varios en líneas adyacentes:

@invincible @favourite_colour ( "Azul" ) def black_knight () -> None : pass

es equivalente a

def black_knight () -> None : pass black_knight = invincible ( favourite_colour ( "Blue" )( black_knight ))

o bien, utilizando variables intermedias

def black_knight () -> None : pass blue_decorator = favourite_colour ( "Azul" ) decorated_by_blue = blue_decorator ( black_knight ) black_knight = invincible ( decorated_by_blue )

En el ejemplo anterior, la fábricafavourite_colour de decoradores recibe un argumento. Las fábricas de decoradores deben devolver un decorador, que luego se llama con el objeto que se va a decorar como argumento:

def color_favorito ( color : str ) -> Callable [[ Callable [[], R ]], Callable [[], R ]]: def decorador ( func : Callable [[], R ]) -> Callable [[], R ]: def envoltorio () -> R : print ( color ) func () return envoltorio return decorador

Esto decoraría la black_knightfunción de tal manera que el color "Blue"se imprimiría antes de que black_knightse ejecutara. El cierre garantiza que el argumento del color sea accesible para la función contenedora más interna incluso cuando se devuelve y sale del ámbito, lo que permite que los decoradores funcionen.

A pesar de su nombre, los decoradores de Python no son una implementación del patrón decorador . El patrón decorador es un patrón de diseño utilizado en lenguajes de programación orientados a objetos con tipado estático para permitir la adición de funcionalidad a los objetos en tiempo de ejecución; los decoradores de Python añaden funcionalidad a funciones y métodos en el momento de su definición, por lo que constituyen una construcción de nivel superior a las clases del patrón decorador. El patrón decorador en sí es fácilmente implementable en Python, dado que el lenguaje utiliza tipado dinámico (duck type) , por lo que no suele considerarse como tal.

Los usuarios de lenguajes con llaves , como C o Java , a veces esperan o desean que Python siga una convención de delimitación de bloques. La sintaxis de bloques delimitados por llaves se ha solicitado repetidamente, pero los desarrolladores principales la han rechazado sistemáticamente. El intérprete de Python contiene un huevo de Pascua que resume la opinión de sus desarrolladores sobre este tema. El código from __future__ import bracesgenera la excepción SyntaxError: not a chance. El __future__módulo se usa normalmente para proporcionar características de futuras versiones de Python.

Otro mensaje oculto, el Zen de Python (un resumen de la filosofía de diseño de Python ), se muestra al intentar import this.

El mensaje Hello world!se imprime cuando import __hello__se utiliza la instrucción import. En Python 2.7, en lugar de Hello world!eso, imprime Hello world....

La importación del antigravitymódulo abre un navegador web en la tira cómica 353 de xkcd , que muestra un uso ficticio y humorístico de dicho módulo, con el fin de demostrar la facilidad con la que los módulos de Python permiten funcionalidades adicionales. ^{[ 44 ]} En Python 3, este módulo también contiene una implementación del algoritmo "geohash", una referencia a la tira cómica 426 de xkcd . ^{[ 45 ]}

• "La referencia del lenguaje Python" .

• Van Rossum, Guido . "El tutorial de Python" .(escrito por el autor de Python)

• Ramalho, Luciano (abril de 2022). Python fluido, segunda edición . O'Reilly Media, Inc. ISBN 9781492056355.