Glosario
********

">>>"
   El prompt en el shell interactivo de Python por omisión.
   Frecuentemente vistos en ejemplos de código que pueden ser
   ejecutados interactivamente en el intérprete.

"..."
   El prompt en el shell interactivo de Python por omisión cuando se
   ingresa código para un bloque indentado de código, y cuando se
   encuentra entre dos delimitadores que emparejan (paréntesis,
   corchetes, llaves o comillas triples), o después de especificar un
   decorador.

2to3
   Una herramienta que intenta convertir código de Python 2.x a Python
   3.x arreglando la mayoría de las incompatibilidades que pueden ser
   detectadas analizando el código y recorriendo el árbol de análisis
   sintáctico.

   2to3 está disponible en la biblioteca estándar como "lib2to3"; un
   punto de entrada independiente es provisto como
   "Tools/scripts/2to3".  Vea 2to3 - Automated Python 2 to 3 code
   translation.

clase base abstracta
   Las clases base abstractas (ABC, por sus siglas en inglés *Abstract
   Base Class*) complementan al *duck-typing* brindando un forma de
   definir interfaces con técnicas como  "hasattr()" que serían
   confusas o sutilmente erróneas (por ejemplo con magic methods). Las
   ABC introduce subclases virtuales, las cuales son clases que no
   heredan desde una clase pero aún así son reconocidas por
   "isinstance()" y "issubclass()"; vea la documentación del módulo
   "abc". Python viene con muchas ABC incorporadas para las
   estructuras de datos( en el módulo  "collections.abc"), números (en
   el módulo "numbers" ) , flujos de datos (en el módulo "io" ) ,
   buscadores y cargadores de importaciones (en el módulo
   "importlib.abc" ) . Puede crear sus propios ABCs con el módulo
   "abc".

anotación
   Una etiqueta asociada a una variable, atributo de clase, parámetro
   de función o valor de retorno, usado por convención como un *type
   hint*.

   Las anotaciones de variables no pueden ser accedidas en tiempo de
   ejecución, pero las anotaciones de variables globales, atributos de
   clase, y funciones son almacenadas en el atributo especial
   "__annotations__" de módulos, clases y funciones, respectivamente.

   Vea *variable annotation*, *function annotation*, **PEP 484** y
   **PEP 526**, los cuales describen esta funcionalidad.

argumento
   Un valor pasado a una *function* (o *method*) cuando se llama a la
   función. Hay dos clases de argumentos:

   * *argumento nombrado*: es un argumento precedido por un
     identificador (por ejemplo, "nombre=") en una llamada a una
     función o pasado como valor en un diccionario precedido por "**".
     Por ejemplo "3" y "5" son argumentos nombrados en las llamadas a
     "complex()":

        complex(real=3, imag=5)
        complex(**{'real': 3, 'imag': 5})

   * *argumento posicional* son aquellos que no son nombrados. Los
     argumentos posicionales deben aparecer al principio de una lista
     de argumentos o ser pasados como elementos de un *iterable*
     precedido por "*". Por ejemplo, "3" y "5" son argumentos
     posicionales en las siguientes llamadas:

        complex(3, 5)
        complex(*(3, 5))

   Los argumentos son asignados a las variables locales en el cuerpo
   de la función. Vea en la sección Calls las reglas que rigen estas
   asignaciones. Sintácticamente, cualquier expresión puede ser usada
   para representar un argumento; el valor evaluado es asignado a la
   variable local.

   Vea también el *parameter* en el glosario, la pregunta frecuente la
   diferencia entre argumentos y parámetros, y **PEP 362**.

administrador asincrónico de contexto
   Un objeto que controla el entorno visible en un sentencia "async
   with" al definir los métodos "__aenter__()" "__aexit__()".
   Introducido por **PEP 492**.

generador asincrónico
   Una función que retorna un *asynchronous generator iterator*. Es
   similar a una función corrutina definida con "async def" excepto
   que contiene expresiones "yield" para producir series de variables
   usadas en un ciclo "async for".

   Usualmente se refiere a una función generadora asincrónica, pero
   puede referirse a un *iterador generador asincrónico* en ciertos
   contextos. En aquellos casos en los que el significado no está
   claro, usar los términos completos evita la ambigüedad.

   Una función generadora asincrónica puede contener expresiones
   "await" así como sentencias "async for", y "async with".

iterador generador asincrónico
   Un objeto creado por una función *asynchronous generator*.

   Este es un *asynchronous iterator* el cual cuando es llamado usa el
   método  "__anext__()" retornando un objeto aguardable el cual
   ejecutará el cuerpo de la función generadora asincrónica hasta la
   siguiente expresión "yield".

   Cada "yield" suspende temporalmente el procesamiento, recordando el
   estado local de ejecución (incluyendo a las variables locales y las
   sentencias *try* pendientes). Cuando el *iterador del generador
   asincrónico* vuelve efectivamente con otro aguardable retornado por
   el método  "__anext__()", retoma donde lo dejó. Vea **PEP 492** y
   **PEP 525**.

iterable asincrónico
   Un objeto, que puede ser usado en una sentencia "async for". Debe
   retornar un *asynchronous iterator* de su método "__aiter__()".
   Introducido por **PEP 492**.

iterador asincrónico
   Un objeto que implementa los métodos meth:*__aiter__* y
   "__anext__()". "__anext__" debe retornar un objeto *awaitable*.
   "async for" resuelve los esperables retornados por un método de
   iterador asincrónico "__anext__()" hasta que lanza una excepción
   "StopAsyncIteration". Introducido por **PEP 492**.

atributo
   Un valor asociado a un objeto que es referencias por el nombre
   usado expresiones de punto. Por ejemplo, si un objeto *o* tiene un
   atributo *a* sería referenciado como *o.a*.

aguardable
   Es un objeto que puede ser usado en una expresión "await". Puede
   ser una *coroutine* o un objeto con un método "__await__()". Vea
   también pep:*492*.

BDFL
   Benevolent Dictator For Life, a.k.a. Guido van Rossum, Python's
   creator.

archivo binario
   Un *file object* capaz de leer y escribir *objetos tipo binarios*.
   Ejemplos de archivos binarios son los abiertos en modo binario
   ("'rb'", "'wb'" o "'rb+'"), "sys.stdin.buffer",
   "sys.stdout.buffer", e instancias de "io.BytesIO" y de
   "gzip.GzipFile".

   Vea también *text file* para un objeto archivo capaz de leer y
   escribir objetos "str".

objetos tipo binarios
   Un objeto que soporta Buffer Protocol  y puede exportar un buffer
   C-*contiguous*. Esto incluye todas los objetos "bytes",
   "bytearray", y "array.array", así como muchos objetos comunes
   "memoryview". Los objetos tipo binarios pueden ser usados para
   varias operaciones que usan datos binarios; éstas incluyen
   compresión, salvar a archivos binarios, y enviarlos a través de un
   socket.

   Algunas operaciones necesitan que los datos binarios sean mutables.
   La documentación frecuentemente se refiere a éstos como "objetos
   tipo binario de lectura y escritura". Ejemplos de objetos de buffer
   mutables incluyen a "bytearray" y "memoryview" de la "bytearray".
   Otras operaciones que requieren datos binarios almacenados en
   objetos inmutables ("objetos tipo binario de sólo lectura");
   ejemplos de éstos incluyen "bytes" y "memoryview" del objeto
   "bytes".

bytecode
   El código fuente Python es compilado en bytecode, la representación
   interna de un programa python en el intérprete CPython. El bytecode
   también es guardado en caché en los archivos *.pyc* de tal forma
   que ejecutar el mismo archivo es más fácil la segunda vez (la
   recompilación desde el código fuente a bytecode puede ser evitada).
   Este "lenguaje intermedio" deberá corren en una *virtual machine*
   que ejecute el código de máquina correspondiente a cada bytecode.
   Note que los bytecodes no tienen como requisito trabajar en las
   diversas máquina virtuales de Python, ni de ser estable entre
   versiones Python.

   Una lista de las instrucciones en bytecode está disponible en la
   documentación de el módulo dis.

clase
   Una plantilla para crear objetos definidos por el usuario. Las
   definiciones de clase normalmente contienen definiciones de métodos
   que operan una instancia de la clase.

variable de clase
   Una variable definida en una clase y prevista para ser modificada
   sólo a nivel de clase (es decir, no en una instancia de la clase).

coerción
   The implicit conversion of an instance of one type to another
   during an operation which involves two arguments of the same type.
   For example, "int(3.15)" converts the floating point number to the
   integer "3", but in "3+4.5", each argument is of a different type
   (one int, one float), and both must be converted to the same type
   before they can be added or it will raise a "TypeError".  Without
   coercion, all arguments of even compatible types would have to be
   normalized to the same value by the programmer, e.g.,
   "float(3)+4.5" rather than just "3+4.5".

número complejo
   Una extensión del sistema familiar de número reales en el cual los
   números son expresados como la suma de una parte real y una parte
   imaginaria.  Los números imaginarios son múltiplos de la unidad
   imaginaria (la raíz cuadrada de "-1"), usualmente escrita como "i"
   en matemáticas o "j" en ingeniería.  Python tiene soporte
   incorporado para números complejos, los cuales son escritos con la
   notación mencionada al final.; la parte imaginaria es escrita con
   un sufijo "j", por ejemplo, "3+1j".  Para tener acceso a los
   equivalentes complejos del módulo "math" module, use
   :mod:>>`<<cmath.  El uso de números complejos es matemática
   bastante avanzada.  Si no le parecen necesarios, puede ignorarlos
   sin inconvenientes.

administrador de contextos
   Un objeto que controla el entorno en la sentencia "with" definiendo
   "__enter__()" y "__exit__()" methods. Vea **PEP 343**.

contiguo
   Un buffer es considerado contiguo con precisión si es *C-contíguo*
   o *Fortran contiguo*. Los buffers cero dimensionales con C y
   Fortran contiguos. En los arreglos unidimensionales, los ítems
   deben ser dispuestos en memoria uno siguiente al otro, ordenados
   por índices que comienzan en cero. En arreglos unidimensionales
   C-contíguos, el último índice varía más velozmente en el orden de
   las direcciones de memoria. Sin embargo, en arreglos Fortran
   contiguos, el primer índice vería más rápidamente.

corrutina
   Las corrutinas son una forma más generalizadas de las subrutinas. A
   las subrutinas se ingresa por un punto y se sale por otro punto.
   Las corrutinas pueden se iniciadas, finalizadas y reanudadas en
   muchos puntos diferentes. Pueden ser implementadas con la sentencia
   "async def". Vea además **PEP 492**.

función corrutina
   Un función que retorna un objeto  *coroutine* . Una función
   corrutina puede ser definida con la sentencia "async def", y puede
   contener las palabras claves "await", "async for", y "async with".
   Las mismas son introducidas en **PEP 492**.

CPython
   La implementación canónica del lenguaje de programación Python,
   como se distribuye en python.org. El término "CPython" es usado
   cuando es necesario distinguir esta implementación de otras como
   Jython o IronPython.

decorador
   Una función que retorna otra función, usualmente aplicada como una
   función de transformación empleando la sintaxis "@envoltorio".
   Ejemplos comunes de decoradores son  "classmethod()" y
   func:*staticmethod*.

   La sintaxis del decorador es meramente azúcar sintáctico, las
   definiciones de las siguientes dos funciones son semánticamente
   equivalentes:

      def f(...):
          ...
      f = staticmethod(f)

      @staticmethod
      def f(...):
          ...

   El mismo concepto existe para clases, pero son menos usadas. Vea la
   documentación de function definitions y class definitions para
   mayor detalle sobre decoradores.

descriptor
   Cualquier objeto que define los métodos  "__get__()", "__set__()",
   o "__delete__()".   Cuando un atributo de clase es un descriptor,
   su conducta enlazada especial es disparada durante la búsqueda del
   atributo. Normalmente, usando *a.b* para consultar, establecer o
   borrar un atributo busca el objeto llamado *b* en el diccionario de
   clase de *a*, pero si *b* es un descriptor, el respectivo método
   descriptor es llamado.  Entender descriptores es clave para lograr
   una comprensión profunda de Python porque son la base de muchas de
   las capacidades incluyendo funciones, métodos, propiedades, métodos
   de clase, métodos estáticos, y referencia a súper clases.

   Para más información sobre métodos descriptores, vea Implementing
   Descriptors.

diccionario
   Un arreglo asociativo, con claves arbitrarias que son asociadas a
   valores. Las claves pueden ser cualquier objeto con los métodos
   "__hash__()" y "__eq__()" . Son llamadas hash en Perl.

vista de diccionario
   Los objetos retornados por los métodos  "dict.keys()",
   "dict.values()", y "dict.items()" son llamados vistas de
   diccionarios. Proveen una vista dinámica de las entradas de un
   diccionario, lo que significa que cuando el diccionario cambia, la
   vista refleja éstos cambios. Para forzar a la vista de diccionario
   a convertirse en una lista completa, use "list(dictview)".  Vea
   Dictionary view objects.

docstring
   Una cadena de caracteres literal que aparece como la primera
   expresión en una clase, función o módulo. Aunque es ignorada cuando
   se ejecuta, es reconocida por el compilador y puesta en el atributo
   "__doc__" de la clase, función o módulo comprendida.  Como está
   disponible mediante introspección, es el lugar canónico para ubicar
   la documentación del objeto.

tipado de pato
   Un estilo de programación que no revisa el tipo del objeto para
   determinar si tiene la interfaz correcta; en vez de ello, el método
   o atributo es simplemente llamado o usado ("Si se ve como un pato y
   grazna como un pato, debe ser un pato").  Enfatizando las
   interfaces en vez de hacerlo con los tipos específicos, un código
   bien diseñado pues tener mayor flexibilidad permitiendo la
   sustitución polimórfica.  El tipado de pato *duck-typing* evita
   usar pruebas llamando a "type()" o "isinstance()".  (Nota: si
   embargo, el tipado de pato puede ser complementado con *abstract
   base classes*. En su lugar, generalmente emplea "hasattr()" tests o
   *EAFP*.

EAFP
   Del inglés "Easier to ask for forgiveness than permission", es más
   fácil pedir perdón que pedir permiso.  Este estilo de codificación
   común en Python asume la existencia de claves o atributos válidos y
   atrapa las excepciones si esta suposición resulta falsa.  Este
   estilo rápido y limpio está caracterizado por muchas sentencias
   "try" y "except".  Esta técnica contrasta con estilo *LBYL* usual
   en otros lenguajes como C.

expresión
   A piece of syntax which can be evaluated to some value.  In other
   words, an expression is an accumulation of expression elements like
   literals, names, attribute access, operators or function calls
   which all return a value.  In contrast to many other languages, not
   all language constructs are expressions.  There are also
   *statement*s which cannot be used as expressions, such as "if".
   Assignments are also statements, not expressions.

módulo de extensión
   Un módulo escrito en C o C++, usando la API para C de Python para
   interactuar con el núcleo y el código del usuario.

f-string
   Son llamadas "f-strings" las cadenas literales que usan el prefijo
   "'f'" o "'F'", que es una abreviatura para  cadenas literales
   formateadas.  Vea también **PEP 498**.

objeto archivo
   Un objeto que expone una API orientada a archivos (con métodos como
   "read()" o "write()") al objeto subyacente.  Dependiendo de la
   forma en la que fue creado, un objeto archivo, puede mediar el
   acceso a un archivo real en el disco u otro tipo de dispositivo de
   almacenamiento o de comunicación (por ejemplo, entrada/salida
   estándar, buffer de memoria, sockets, pipes, etc.).  Los objetos
   archivo son también denominados *objetos tipo archivo* o *flujos*.

   Existen tres categorías de objetos archivo: crudos *raw* *archivos
   binarios*, con buffer *archivos binarios* y *archivos de texto*.
   Sus interfaces son definidas en el módulo "io".  La forma canónica
   de crear objetos archivo es usando la función "open()".

objetos tipo archivo
   Un sinónimo de *file object*.

buscador
   Un objeto que trata de encontrar el *loader* para el módulo que
   está siendo importado.

   Desde la versión 3.3 de Python, existen dos tipos de buscadores:
   *meta buscadores de ruta* para usar con "sys.meta_path", y
   *buscadores de entradas de rutas* para usar con  "sys.path_hooks".

   Vea **PEP 302**, **PEP 420** y **PEP 451** para mayores detalles.

división entera
   Una división matemática que se redondea hacia el entero menor más
   cercano.  El operador de la división entera es "//".  Por ejemplo,
   la expresión "11 // 4" evalúa "2" a diferencia del "2.75" retornado
   por la verdadera división de números flotantes.  Note que "(-11) //
   4" es "-3" porque es "-2.75" redondeado *para abajo*. Ver **PEP
   238**.

función
   Una serie de sentencias que retornan un valor al que las llama.
   También se le puede pasar cero o más *argumentos* los cuales pueden
   ser usados en la ejecución de la misma. Vea también *parameter*,
   *method*, y la sección Function definitions.

anotación de función
   Una *annotation* del parámetro de una función o un valor de
   retorno.

   Las anotaciones de funciones son usadas frecuentemente para *type
   hint`s , por ejemplo, se espera que una función tome dos argumentos
   de clase :class:`int*  y también se espera que devuelva dos valores
   "int":

      def sum_two_numbers(a: int, b: int) -> int:
         return a + b

   La sintaxis de las anotaciones de funciones son explicadas en la
   sección Function definitions.

   Vea *variable annotation* y **PEP 484**, que describen esta
   funcionalidad.

__future__
   Un pseudo-módulo que los programadores pueden usar para habilitar
   nuevas capacidades del lenguaje que no son compatibles con el
   intérprete actual.

   Al importar el módulo "__future__" y evaluar sus variables, puede
   verse cuándo las nuevas capacidades fueron agregadas por primera
   vez al lenguaje y cuando se quedaron establecidas por defecto:

      >>> import __future__
      >>> __future__.division
      _Feature((2, 2, 0, 'alpha', 2), (3, 0, 0, 'alpha', 0), 8192)

recolección de basura
   El proceso de liberar la memoria de lo que ya no está en uso.
   Python realiza recolección de basura (*garbage collection*)
   llevando la cuenta de las referencias, y el recogedor de basura
   cíclico es capaz de detectar y romper las referencias cíclicas.  El
   recogedor de basura puede ser controlado mediante el módulo "gc" .

generador
   Una función que retorna un *generator iterator*.  Luce como una
   función normal excepto que contiene la expresión "yield" para
   producir series de valores utilizables en un bucle for o que pueden
   ser obtenidas una por una con la función "next()".

   Usualmente se refiere a una función generadora, pero puede
   referirse a un *iterador generador* en ciertos contextos.  En
   aquellos casos en los que el significado no está claro, usar los
   términos completos  evita la ambigüedad.

iterador generador
   Un objeto creado por una función *generator*.

   Cada "yield" suspende temporalmente el procesamiento, recordando el
   estado de ejecución local (incluyendo las variables locales y las
   sentencias try pendientes).  Cuando el "iterador generado" vuelve,
   retoma donde ha dejado, a diferencia de lo que ocurre con las
   funciones que comienzan nuevamente con cada invocación.

expresión generadora
   An expression that returns an iterator.  It looks like a normal
   expression followed by a "for" expression defining a loop variable,
   range, and an optional "if" expression.  The combined expression
   generates values for an enclosing function:

      >>> sum(i*i for i in range(10))         # sum of squares 0, 1, 4, ... 81
      285

función genérica
   Una función compuesta de muchas funciones que implementan la misma
   operación para diferentes tipos. Qué implementación deberá ser
   usada durante la llamada a la misma es determinado por el algoritmo
   de despacho.

   Vea también la entrada de glosario *single dispatch*, el decorador
   "functools.singledispatch()", y **PEP 443**.

GIL
   Vea *global interpreter lock*.

bloqueo global del intérprete
   Mecanismo empleado por el intérprete *CPython* para asegurar que
   sólo un hilo ejecute el  *bytecode* Python por vez. Esto simplifica
   la implementación de CPython haciendo que el modelo de objetos
   (incluyendo algunos críticos como "dict") están implícitamente a
   salvo de acceso concurrente.  Bloqueando el intérprete completo se
   simplifica hacerlo multi-hilos, a costa de mucho del paralelismo
   ofrecido por las máquinas con múltiples procesadores.

   Sin embargo, algunos módulos de extensión, tanto estándar como de
   terceros, están diseñados para liberar el GIL cuando se realizan
   tareas computacionalmente intensivas como la compresión o el
   hashing.  Además, el GIL siempre es liberado cuando se hace
   entrada/salida.

   Esfuerzos previos hechos para crear un intérprete "sin hilos" (uno
   que bloquee los datos compartidos con una granularidad mucho más
   fina) no han sido exitosos debido a que el rendimiento sufrió para
   el caso más común de un solo procesador. Se cree que superar este
   problema de rendimiento haría la implementación mucho más compleja
   y por tanto, más costosa de mantener.

hashable
   Un objeto es *hashable* si tiene un valor de hash que nunca
   cambiará durante su tiempo de vida (necesita un método "__hash__()"
   ), y puede ser comparado con otro objeto (necesita el método
   "__eq__()" ).  Los objetos hashables que se comparan iguales deben
   tener el mismo número hash.

   La hashabilidad hace a un objeto empleable como clave de un
   diccionario y miembro de un set, porque éstas estructuras de datos
   usan los valores de hash internamente.

   Todos los objetos inmutables incorporados en Python son hashables;
   los contenedores mutables (como las listas o los diccionarios) no
   lo son.  Los objetos que son instancias de clases definidas por el
   usuario son hashables por defecto.  Todos se comparan como
   desiguales (excepto consigo mismos), y su valor de hash está
   derivado de su función  "id()".

IDLE
   El entorno integrado de desarrollo de Python, o "Integrated
   Development Environment for Python".  IDLE es un editor básico y un
   entorno de intérprete que se incluye con la distribución estándar
   de Python.

inmutable
   Un objeto con un valor fijo.  Los objetos inmutables son números,
   cadenas y tuplas.  Éstos objetos no pueden ser alterados.  Un nuevo
   objeto debe ser creado si un valor diferente ha de ser guardado.
   Juegan un rol importante en lugares donde es necesario un valor de
   hash constante, por ejemplo como claves de un diccionario.

ruta de importación
   Una lista de las ubicaciones (o *entradas de ruta*) que son
   revisadas por *path based finder* al importar módulos. Durante la
   importación, ésta lista de localizaciones usualmente viene de
   "sys.path", pero para los subpaquetes también puede incluir al
   atributo "__path__" del paquete padre.

importar
   El proceso mediante el cual el código Python dentro de un módulo se
   hace alcanzable desde otro código Python en otro módulo.

importador
   Un objeto que buscan y lee un módulo; un objeto que es tanto
   *finder* como *loader*.

interactivo
   Python tiene un intérprete interactivo, lo que significa que puede
   ingresar sentencias y expresiones en el prompt del intérprete,
   ejecutarlos de inmediato y ver sus resultados.  Sólo ejecute
   "python" sin argumentos (podría seleccionarlo desde el menú
   principal de su computadora). Es una forma muy potente de probar
   nuevas ideas o inspeccionar módulos y paquetes (recuerde
   "help(x)").

interpretado
   Python es un lenguaje interpretado, a diferencia de uno compilado,
   a pesar de que la distinción puede ser difusa debido al compilador
   a bytecode.  Esto significa que los archivos fuente pueden ser
   corridos directamente, sin crear explícitamente un ejecutable que
   es corrido luego. Los lenguajes interpretados típicamente tienen
   ciclos de desarrollo y depuración más cortos que los compilados,
   sin embargo sus programas suelen correr más lentamente.  Vea
   también  *interactive*.

apagado del intérprete
   Cuando se le solicita apagarse, el intérprete Python ingresa a un
   fase especial en la cual gradualmente libera todos los recursos
   reservados, como módulos y varias estructuras internas críticas.
   También hace varias llamadas al *recolector de basura*.  Esto puede
   disparar la ejecución de código de destructores definidos por el
   usuario o "weakref callbacks". El código ejecutado durante la fase
   de apagado puede encontrar varias excepciones debido a que los
   recursos que necesita pueden no funcionar más (ejemplos comunes son
   los módulos de bibliotecas o los artefactos de advertencias
   "warnings machinery")

   La principal razón para el apagado del intérpreter es que el módulo
   "__main__" o el script que estaba corriendo termine su ejecución.

iterable
   Un objeto capaz de retornar sus miembros uno por vez. Ejemplos de
   iterables son todos los tipos de secuencias (como  "list", "str", y
   "tuple") y algunos de tipos no secuenciales, como "dict", *objeto
   archivo*, y objetos de cualquier clase que defina con los métodos
   "__iter__()" o con un método "__getitem__()" que implementen la
   semántica de *Sequence*.

   Los iterables pueden ser usados en el bucle "for" y en muchos otros
   sitios donde una secuencia es necesaria ("zip()", "map()", ...).
   Cuando un objeto iterable es pasado como argumento a la función
   incorporada "iter()", retorna un iterador para el objeto.  Este
   iterador pasa así el conjunto de valores.  Cuando se usan
   iterables, normalmente no es necesario llamar a la función "iter()"
   o tratar con los objetos iteradores usted mismo.  La sentencia
   "for" lo hace automáticamente por usted, creando un variable
   temporal sin nombre para mantener el iterador mientras dura el
   bucle.  Vea también *iterator*, *sequence*, y *generator*.

iterador
   Un objeto que representa un flujo de datos.  Llamadas repetidas al
   método  "__next__()" del iterador (o al pasar la función
   incorporada "next()") retorna ítems sucesivos del flujo.  Cuando no
   hay más datos disponibles, una excepción "StopIteration" es
   disparada.  En este momento, el objeto iterador está exhausto y
   cualquier llamada posterior al método "__next__()" sólo dispara
   otra vez "StopIteration".  Los iteradores necesitan tener un
   método:meth:*__iter__* que retorna el objeto iterador mismo así
   cada iterador es también un iterable y puede ser usado en casi
   todos los lugares donde los iterables son aceptados.  Una excepción
   importante es el código que intenta múltiples pases de iteración.
   Un objeto contenedor (como la "list") produce un nuevo iterador
   cada vez que las pasa a una función "iter()" o la usa en un blucle
   "for".  Intentar ésto con un iterador simplemente retornaría el
   mismo objeto iterador exhausto usado en previas iteraciones,
   haciéndolo aparecer como un contenedor vacío.

   Puede encontrar más información en Iterator Types.

función clave
   Una función clave o una función de colación es un invocable que
   retorna un valor usado para el ordenamiento o clasificación.  Por
   ejemplo, "locale.strxfrm()" es usada para producir claves de
   ordenamiento que se adaptan a las convenciones específicas de
   ordenamiento de un locale.

   Cierta cantidad de herramientas de Python aceptan funciones clave
   para controlar como los elementos son ordenados o agrupados.
   Incluyendo a  "min()", "max()", "sorted()", "list.sort()",
   "heapq.merge()", "heapq.nsmallest()", "heapq.nlargest()", y
   "itertools.groupby()".

   Hay varias formas de crear una función clave.  Por ejemplo, el
   método "str.lower()" puede servir como función clave para
   ordenamientos que no distingan mayúsculas de minúsculas.  Como
   alternativa, una función clave puede ser realizada con una
   expresión "lambda" como "lambda r: (r[0], r[2])".  También, el
   módulo "operator" provee tres constructores de funciones clave:
   "attrgetter()", "itemgetter()", y "methodcaller()".  Vea en Sorting
   HOW TO ejemplos de cómo crear y usar funciones clave.

argumento nombrado
   Vea *argument*.

lambda
   Una función anónima de una línea consistente en un sola
   *expression* que es evaluada cuando la función es llamada.  La
   sintaxis para crear una función lambda es "lambda [parameters]:
   expression"

LBYL
   Del inglés "Look before you leap", "mira antes de saltar".  Es un
   estilo de codificación que prueba explícitamente las condiciones
   previas antes de hacer llamadas o búsquedas.  Este estilo contrasta
   con la manera *EAFP* y está caracterizado por la presencia de
   muchas sentencias "if".

   En entornos multi-hilos, el método LBYL tiene el riesgo de
   introducir condiciones de carrera entre los hilos que están
   "mirando" y los que están "saltando".  Por ejemplo, el código, *if
   key in mapping: return mapping[key]`*  puede fallar si otro hilo
   remueve *key* de *mapping* después del test, pero antes de retornar
   el valor.  Este problema puede ser resuelto usando bloqueos o
   empleando el método EAFP.

lista
   Es una *sequence* Python incorporada.  A pesar de su nombre es más
   similar a un arreglo en otros lenguajes que a una lista enlazada
   porque el acceso a los elementos es O(1).

comprensión de listas
   Una forma compacta de procesar todos o parte de los elementos en
   una secuencia y retornar una lista como resultado.  "result =
   ['{:#04x}'.format(x) for x in range(256) if x % 2 == 0]" genera una
   lista de cadenas conteniendo números hexadecimales (0x..) entre 0 y
   255. La cláusula "if" es opcional.  Si es omitida, todos los
   elementos en "range(256)" son procesados.

cargador
   Un objeto que carga un módulo. Debe definir el método llamado
   "load_module()".  Un cargador es normalmente retornados por un
   *finder*. Vea **PEP 302** para detalles y "importlib.abc.Loader"
   para una *abstract base class*.

mapeado
   Un objeto contenedor que permite recupero de claves arbitrarias y
   que implementa los métodos especificados en la "Mapping" o
   "MutableMapping" abstract base classes.  Por ejemplo, "dict",
   "collections.defaultdict", "collections.OrderedDict" y
   "collections.Counter".

meta buscadores de ruta
   Un *finder* retornado por una búsqueda de "sys.meta_path".  Los
   meta buscadores de ruta están relacionados a *buscadores de
   entradas de rutas*, pero son algo diferente.

   Vea en "importlib.abc.MetaPathFinder" los métodos que los meta
   buscadores de ruta implementan.

metaclase
   La clase de una clase.  Las definiciones de clases crean nombres de
   clase, un diccionario de clase, y una lista de clases base.  Las
   metaclases son responsables de tomar estos tres argumentos y crear
   la clase.  La mayoría de los objetos de un lenguaje de programación
   orientado a objetos provienen de una implementación por defecto.
   Lo que hace a Python especial que es posible crear metaclases a
   medida.  La mayoría de los usuario nunca necesitarán esta
   herramienta, pero cuando la necesidad surge, las metaclases pueden
   brindar soluciones poderosas y elegantes.  Han sido usadas para
   loggear acceso de atributos, agregar seguridad a hilos, rastrear la
   creación de objetos, implementar singletons, y muchas otras tareas.

   Más información hallará en Metaclasses.

método
   Una función que es definida dentro del cuerpo de una clase.  Si es
   llamada como un atributo de una instancia de otra clase, el método
   tomará el objeto instanciado como su primer *argument* (el cual es
   usualmente denominado *self*). Vea *function* y *nested scope*.

orden de resolución de métodos
   Orden de resolución de métodos es el orden en el cual una clase
   base es buscada por un miembro durante la búsqueda. Mire en The
   Python 2.3 Method Resolution Order los detalles del algoritmo usado
   por el intérprete Python desde la versión 2.3.

módulo
   Un objeto que sirve como unidad de organización del código Python.
   Los módulos tienen espacios de nombres conteniendo objetos Python
   arbitrarios.  Los módulos son cargados en Python por el proceso de
   *importing*.

   Vea también *package*.

especificador de módulo
   Un espacio de nombres que contiene la información relacionada a la
   importación usada al leer un módulo.  Una instancia de
   "importlib.machinery.ModuleSpec".

MRO
   Vea *method resolution order*.

mutable
   Los objetos mutables pueden cambiar su valor pero mantener su
   "id()".  Vea también *immutable*.

tupla nombrada
   Cualquier clase similar a una tupla cuyos elementos indexables son
   también accesibles usando atributos nombrados (por ejemplo,
   "time.localtime()" retorna un objeto similar a tupla donde *year*
   es accesible tanto como "t[0]" o con un atributo nombrado
   como``t.tm_year``).

   Una tupla nombrada puede ser un tipo incorporado como
   "time.struct_time", o puede ser creada con una definición regular
   de clase.  Una tupla nombrada con todas las características puede
   también ser creada con la función factoría
   "collections.namedtuple()".  Esta última forma automáticamente
   brinda capacidades extra como una representación autodocumentada
   como "Employee(name='jones', title='programmer')".

espacio de nombres
   El lugar donde la variable es almacenada.  Los espacios de nombres
   son implementados como diccionarios.  Hay espacio de nombre local,
   global, e incorporado así como espacios de nombres anidados en
   objetos (en métodos).  Los espacios de nombres soportan modularidad
   previniendo conflictos de nombramiento.  Por ejemplo, las funciones
   "builtins.open" y "os.open()" se distinguen por su espacio de
   nombres.  Los espacios de nombres también ayuda a la legibilidad y
   mantenibilidad dejando claro qué módulo implementa una función.
   Por ejemplo, escribiendo "random.seed()" o "itertools.islice()"
   queda claro que éstas funciones están implementadas en los módulos
   "random" y "itertools", respectivamente.

paquete de espacios de nombres
   Un **PEP 420** *package* que sirve sólo para contener subpaquetes.
   Los paquetes de espacios de nombres pueden no tener representación
   física, y específicamente se diferencian de los *regular package*
   porque no tienen un archivo "__init__.py".

   Vea también *module*.

alcances anidados
   La habilidad de referirse a una variable dentro de una definición
   encerrada.  Por ejemplo, una función definida dentro de otra
   función puede referir a variables en la función externa.  Note que
   los alcances anidados por defecto sólo funcionan para referencia y
   no para asignación.  Las variables locales leen y escriben sólo en
   el alcance más interno.  De manera semejante, las variables
   globales pueden leer y escribir en el espacio de nombres global.
   Con "nonlocal" se puede escribir en alcances exteriores.

clase de nuevo estilo
   Vieja denominación usada para el estilo de clases ahora empleado en
   todos los objetos de clase.  En versiones más tempranas de Python,
   sólo las nuevas clases podían usar capacidades nuevas y versátiles
   de Python como "__slots__", descriptores, propiedades,
   "__getattribute__()", métodos de clase y métodos estáticos.

objeto
   Cualquier dato con estado (atributo o valor) y comportamiento
   definido (métodos).  También es la más básica clase base para
   cualquier *new-style class*.

paquete
   Un *module* Python que puede contener submódulos o recursivamente,
   subpaquetes.  Técnicamente, un paquete es un módulo Python con un
   atributo "__path__".

   Vea también *regular package* y *namespace package*.

parámetro
   Una entidad nombrada en una definición de una *function* (o método)
   que especifica un *argument* (o en algunos casos, varios
   argumentos) que la función puede aceptar.  Existen cinco tipos de
   argumentos:

   * *posicional o nombrado*: especifica un argumento que puede ser
     pasado tanto como *posicional* o como *nombrado*.  Este es el
     tipo por defecto de parámetro, como *foo* y *bar* en el siguiente
     ejemplo:

        def func(foo, bar=None): ...

   * *sólo posicional*: especifica un argumento que puede ser pasado
     sólo por posición.  Python no tiene una sintaxis específica para
     los parámetros que son sólo por posición.  Sin embargo, algunas
     funciones tienen parámetros sólo por posición (por ejemplo
     "abs()").

   * *sólo nombrado*: especifica un argumento que sólo puede ser
     pasado por nombre.  Los parámetros sólo por nombre pueden ser
     definidos incluyendo un parámetro posicional de una sola variable
     o un mero "*`" antes de ellos en la lista de parámetros en la
     definición de la función, como *kw_only1* y *kw_only2* en el
     ejemplo siguiente:

        def func(arg, *, kw_only1, kw_only2): ...

   * *variable posicional*: especifica una secuencia arbitraria de
     argumentos posicionales que pueden ser brindados (además de
     cualquier argumento posicional aceptado por otros parámetros).
     Este parámetro puede ser definido anteponiendo al nombre del
     parámetro "*", como a *args* en el siguiente ejemplo:

        def func(*args, **kwargs): ...

   * *variable nombrado*: especifica que arbitrariamente muchos
     argumentos nombrados pueden ser brindados (además de cualquier
     argumento nombrado ya aceptado por cualquier otro parámetro).
     Este parámetro puede ser definido anteponiendo al nombre del
     parámetro con "**", como *kwargs* en el ejemplo más arriba.

   Los parámetros puede especificar tanto argumentos opcionales como
   requeridos, así como valores por defecto para algunos argumentos
   opcionales.

   Vea también el glosario de *argument*, la pregunta respondida en la
   diferencia entre argumentos y parámetros, la clase
   "inspect.Parameter", la sección Function definitions , y **PEP
   362**.

entrada de ruta
   Una ubicación única en el *import path* que el *path based finder*
   consulta para encontrar los módulos a importar.

buscador de entradas de ruta
   Un *finder* retornado por un invocable en "sys.path_hooks" (esto
   es, un *path entry hook*) que sabe cómo localizar módulos dada una
   *path entry*.

   Vea en "importlib.abc.PathEntryFinder" los métodos que los
   buscadores de entradas de paths implementan.

gancho a entrada de ruta
   Un invocable en la lista "sys.path_hook" que retorna un *path entry
   finder* si éste sabe cómo encontrar módulos en un *path entry*
   específico.

buscador basado en ruta
   Uno de los *meta buscadores de ruta* por defecto que busca un
   *import path* para los módulos.

objeto tipo ruta
   Un objeto que representa una ruta del sistema de archivos. Un
   objeto tipo ruta puede ser tanto una "str" como un "bytes"
   representando una ruta, o un objeto que implementa el protocolo
   "os.PathLike". Un objeto que soporta el protocolo  "os.PathLike"
   puede ser convertido a ruta del sistema de archivo de clase "str" o
   "bytes" usando la función "os.fspath()"; "os.fsdecode()"
   "os.fsencode()" pueden emplearse para garantizar que retorne
   respectivamente "str" o "bytes". Introducido por **PEP 519**.

PEP
   Propuesta de mejora de Python, del inglés "Python Enhancement
   Proposal". Un PEP es un documento de diseño que brinda información
   a la comunidad Python, o describe una nueva capacidad para Python,
   sus procesos o entorno. Los PEPs deberían dar una especificación
   técnica concisa y una fundamentación para las capacidades
   propuestas.

   Los PEPs tienen como propósito ser los mecanismos primarios para
   proponer nuevas y mayores capacidad, para recoger la opinión de la
   comunidad sobre un tema, y para documentar las decisiones de diseño
   que se han hecho en Python. El autor del PEP es el responsable de
   lograr consenso con la comunidad y documentar las opiniones
   disidentes.

   Vea **PEP 1**.

porción
   Un conjunto de archivos en un único directorio (posiblemente guardo
   en un archivo comprimido zip) que contribuye a un espacio de
   nombres de paquete, como está definido en **PEP 420**.

argumento posicional
   Vea *argument*.

API provisoria
   Una API provisoria es aquella que deliberadamente fue excluida de
   las garantías de compatibilidad hacia atrás de la biblioteca
   estándar.  Aunque no se esperan cambios fundamentales en dichas
   interfaces, como están marcadas como provisionales, los cambios
   incompatibles hacia atrás (incluso remover la misma interfaz)
   podrían ocurrir si los desarrolladores principales lo estiman.
   Estos cambios no se hacen gratuitamente -- solo ocurrirán si fallas
   fundamentales y serias son descubiertas que no fueron vistas antes
   de la inclusión de la API.

   Incluso para APIs provisorias, los cambios incompatibles hacia
   atrás son vistos como una "solución de último recurso" - se
   intentará todo para encontrar una solución compatible hacia atrás
   para los problemas identificados.

   Este proceso permite que la biblioteca estándar continúe
   evolucionando con el tiempo, sin bloquearse por errores de diseño
   problemáticos por períodos extensos de tiempo. Vea :pep`241` para
   más detalles.

paquete provisorio
   Vea *provisional API*.

Python 3000
   Apodo para la fecha de lanzamiento de Python 3.x (acuñada en un
   tiempo cuando llegar a la versión 3 era algo distante en el
   futuro.)  También se lo abrevió como "Py3k".

Pythónico
   Una idea o pieza de código que sigue ajustadamente la convenciones
   idiomáticas comunes del lenguaje Python, en vez de implementar
   código usando conceptos comunes a otros lenguajes.  Por ejemplo,
   una convención común en Python es hacer bucles sobre todos los
   elementos de un iterable con la sentencia "for".  Muchos otros
   lenguajes no tienen este tipo de construcción, así que los que no
   están familiarizados con Python podrían usar contadores numéricos:

      for i in range(len(food)):
          print(food[i])

   En contraste, un método Pythónico más limpio:

      for piece in food:
          print(piece)

nombre calificado
   Un nombre con puntos mostrando la ruta desde el alcance global del
   módulo a la clase, función o método definido en dicho módulo, como
   se define en **PEP 3155**.  Para las funciones o clases de más alto
   nivel, el nombre calificado es el igual al nombre del objeto:

      >>> class C:
      ...     class D:
      ...         def meth(self):
      ...             pass
      ...
      >>> C.__qualname__
      'C'
      >>> C.D.__qualname__
      'C.D'
      >>> C.D.meth.__qualname__
      'C.D.meth'

   Cuando es usado para referirse a los módulos, *nombre completamente
   calificado* significa la ruta con puntos completo al módulo,
   incluyendo cualquier paquete padre, por ejemplo,
   *email.mime.text`*:

      >>> import email.mime.text
      >>> email.mime.text.__name__
      'email.mime.text'

contador de referencias
   El número de referencias a un objeto. Cuando el contador de
   referencias de un objeto cae hasta cero, éste es desalojable.  En
   conteo de referencias no suele ser visible en el código de Python,
   pero es un elemento clave para la implementación de  *CPython*.  El
   módulo "sys" define la "getrefcount()" que los programadores pueden
   emplear para retornar el conteo de referencias de un objeto en
   particular.

paquete regular
   Un  *package* tradicional, como aquellos con un directorio
   conteniendo el archivo "__init__.py".

   Vea también *namespace package*.

__slots__
   Es una declaración dentro de una clase que ahorra memoria pre
   declarando espacio para las atributos de la instancia y eliminando
   diccionarios de la instancia.  Aunque es popular, esta técnica es
   algo dificultosa de lograr correctamente y es mejor reservarla para
   los casos raros en los que existen grandes cantidades de instancias
   en aplicaciones con uso crítico de memoria.

secuencia
   Un *iterable* que logra un acceso eficiente a los elementos usando
   índices enteros a través del método especial "__getitem__()" y que
   define un método "__len__()" que devuelve la longitud de la
   secuencia. Algunas de las secuencias incorporadas son "list",
   "str", "tuple", y "bytes". Observe que "dict" también soporta
   "__getitem__()" y "__len__()", pero es considerada un mapeo más que
   una secuencia porque las búsquedas son por claves arbitraria
   *immutable* y no por enteros.

   La clase base abstracta "collections.abc.Sequence" define una
   interfaz mucho más rica que va más allá de sólo "__getitem__()" y
   "__len__()", agregando "count()", "index()", "__contains__()", y
   "__reversed__()". Los tipos que implementan esta interfaz expandida
   pueden ser registrados explícitamente usando "register()".

despacho único
   Una forma de despacho de una *generic function* donde la
   implementación es elegida a partir del tipo de un sólo argumento.

rebanada
   Un objeto que contiene una porción de una *sequence*.  Una rebanada
   es creada usando la notación de suscripto, "[]" con dos puntos
   entre los números cuando se ponen varios, como en
   "nombre_variable[1:3:5]".  La notación con corchete (suscrito) usa
   internamente objetos "slice".

método especial
   Un método que es llamado implícitamente por Python cuando ejecuta
   ciertas operaciones en un tipo, como la adición.  Estos métodos
   tienen nombres que comienzan y terminan con doble barra baja.  Los
   métodos especiales están documentados en Special method names.

sentencia
   Una sentencia es parte de un conjunto (un "bloque" de código).  Una
   sentencia tanto es una *expression*  como alguna de las varias
   sintaxis usando una palabra clave, como "if", "while" o "for".

secuencias estructuradas
   Una tupla con elementos nombrados. Las secuencias estructuradas
   exponen una interfaz similar a *named tuple* ya que los elementos
   pueden ser accedidos mediante un índice o como si fueran un
   atributo.  Sin embargo, no tienen ninguno de los métodos de las
   tuplas nombradas como "_make()" o "_asdict()". Ejemplos de
   secuencias estructuradas son "sys.float_info" y el valor de retorno
   de "os.stat()".

codificación de texto
   Un códec que codifica las cadenas Unicode a bytes.

archivo de texto
   Un *file object* capaz de leer y escribir objetos "str".
   Frecuentemente, un archivo de texto también accede a un flujo de
   datos binario y maneja automáticamente el *text encoding*. Ejemplos
   de archivos de texto que son abiertos en modo texto ("'r'" o
   "'w'"), "sys.stdin", "sys.stdout", y las instancias de
   "io.StringIO".

   Vea también *binary file* por objeto de archivos capaces de leer y
   escribir *objeto tipo binario*.

cadena con triple comilla
   Una cadena que está enmarcada por tres instancias de comillas (") o
   apostrofes (').  Aunque no brindan ninguna funcionalidad que no
   está disponible usando cadenas con comillas simple, son útiles por
   varias razones.  Permiten incluir comillas simples o dobles sin
   escapar dentro de las cadenas y pueden abarcar múltiples líneas sin
   el uso de caracteres de continuación, haciéndolas particularmente
   útiles para escribir docstrings.

tipo
   El tipo de un objeto Python determina qué tipo de objeto es; cada
   objeto tiene un tipo.  El tipo de un objeto puede ser accedido por
   su atributo "__class__" o puede ser conseguido usando "type(obj)".

alias de tipos
   Un sinónimo para un tipo, creado al asignar un tipo a un
   identificador.

   Los alias de tipos son útiles para simplificar los *indicadores de
   tipo*. Por ejemplo:

      from typing import List, Tuple

      def remove_gray_shades(
              colors: List[Tuple[int, int, int]]) -> List[Tuple[int, int, int]]:
          pass

   podría ser más legible así:

      from typing import List, Tuple

      Color = Tuple[int, int, int]

      def remove_gray_shades(colors: List[Color]) -> List[Color]:
          pass

   Vea "typing" y **PEP 484**, que describen esta funcionalidad.

indicador de tipo
   Una  *annotation* que especifica el tipo esperado para una
   variable, un atributo de clase, un parámetro para una función o un
   valor de retorno.

   Los indicadores de tipo son opcionales y no son obligados por
   Python pero son útiles para las herramientas de análisis de tipos
   estático, y ayuda a las IDE en el completado del código y la
   refactorización.

   Los indicadores de tipo de las variables globales, atributos de
   clase, y funciones, no de variables locales, pueden ser accedidos
   usando "typing.get_type_hints()".

   Vea "typing" y **PEP 484**, que describen esta funcionalidad.

saltos de líneas universales
   Una manera de interpretar flujos de texto en la cual son
   reconocidos como finales de línea todas siguientes formas: la
   convención de Unix para fin de línea "'\n'", la convención de
   Windows "'\r\n'", y la vieja convención de Macintosh "'\r'".  Vea
   **PEP 278** y **PEP 3116**, además de:func:*bytes.splitlines* para
   usos adicionales.

anotación de variable
   Una *annotation* de una variable o un atributo de clase.

   Cuando se anota una variable o un atributo de clase, la asignación
   es opcional:

      class C:
          field: 'annotation'

   Las anotaciones de variables son frecuentemente usadas para *type
   hints*: por ejemplo, se espera que esta variable tenga valores de
   clase "int":

      count: int = 0

   La sintaxis de la anotación de variables está explicada en la
   sección Annotated assignment statements.

   Vea *function annotation*, **PEP 484** y **PEP 526**, los cuales
   describen esta funcionalidad.

entorno virtual
   Un entorno cooperativamente aislado de ejecución que permite a los
   usuarios de Python y a las aplicaciones instalar y actualizar
   paquetes de distribución de Python sin interferir con el
   comportamiento de otras aplicaciones de Python en el mismo sistema.

   Vea también "venv".

máquina virtual
   Una computadora definida enteramente por software.  La máquina
   virtual de Python ejecuta el *bytecode* generado por el compilador
   de bytecode.

Zen de Python
   Un listado de los principios de diseño y la filosofía de Python que
   son útiles para entender y usar el lenguaje.  El listado puede
   encontrarse ingresando  ""import this"" en la consola interactiva.
