4. Modelo de ejecución
**********************


4.1. Estructura de un programa
==============================

Un programa Python está construido a partir de bloques de código. Un
*block* es un trozo de texto de un programa Python que se ejecuta como
una unidad. Los siguientes son bloques: un módulo, el cuerpo de una
función y la definición de una clase. Cada comando ingresado en el
intérprete interactivo es un bloque. Un archivo de script (un archivo
provisto como entrada estándar al intérprete, o especificado como
argumento en la línea de comando al intérprete) es un bloque de
código. Un comando de script (un comando especificado en la línea de
comandos del intérprete con la opción "-c" es un bloque de código. El
argumento cadena de caracteres que se envía a las funciones
incorporadas "eval()" y "exec()" es también un bloque de código.

Un bloque de código se ejecuta en un *execution frame*. Un marco
contiene alguna información administrativa (que se usa para
depuración) y determina dónde y cómo continuará la ejecución una vez
que el bloque de código se haya completado.


4.2. Nombres y vínculos
=======================


4.2.1. Vinculación de nombres
-----------------------------

Los *Names* refieren a objetos. Los nombres se introducen por las
operaciones de vinculación de nombre (*name binding operations*).

The following constructs bind names: formal parameters to functions,
"import" statements, class and function definitions (these bind the
class or function name in the defining block), and targets that are
identifiers if occurring in an assignment, "for" loop header, or after
"as" in a "with" statement or "except" clause. The "import" statement
of the form "from ... import *" binds all names defined in the
imported module, except those beginning with an underscore.  This form
may only be used at the module level.

A target occurring in a "del" statement is also considered bound for
this purpose (though the actual semantics are to unbind the name).

Cada declaración de asignación o importación ocurre dentro de un
bloque determinado por una definición de clase o de función, o a nivel
de módulo (el bloque de código de máximo nivel).

Si un nombre está vinculado en un bloque, es una variable local en ese
bloque, salvo que sea declarado como "nonlocal" o "global". Si un
nombre está vinculado a nivel de módulo, es una variable global. (Las
variables del bloque de código del módulo son locales y globales.) Si
una variable se una en un bloque de código pero no está definida ahí,
es una *free variable*.

Cada ocurrencia de un nombre en el texto del programa se refiere al
*binding* de ese nombre, establecido por las siguientes reglas de
resolución de nombres.


4.2.2. Resolución de nombres
----------------------------

Un *scope* define la visibilidad de un nombre en un bloque. Si una
variable local se define en un bloque, su ámbito (*scope*) incluye ese
bloque. Si la definición ocurre en un bloque de función, el ámbito se
extiende a cualquier bloque contenido en el bloque en donde está la
definición, a menos que uno de los bloques contenidos introduzca un
vínculo diferente para el nombre.

When a name is used in a code block, it is resolved using the nearest
enclosing scope.  The set of all such scopes visible to a code block
is called the block's *environment*.

Cuando un nombre no se encuentra, se lanza una excepción "NameError".
Si el ámbito actual es una función, y el nombre se refiere a una
variable local que todavía no ha sido vinculada a un valor en el punto
en el que nombre es utilizado, se lanza una excepción
"UnboundLocalError". "UnboundLocalError" es una subclase de
"NameError".

Si una operación de vinculación de nombre ocurre en cualquier parte
dentro de un bloque de código, todos los usos del nombre dentro de ese
bloque son tratados como referencias al bloque actual. Esto puede
llevar a errores cuando el nombre es utilizado dentro del bloque antes
de su vinculación. Esta regla es sutil. Python carece de declaraciones
y permite que las operaciones de vinculación de nombres ocurran en
cualquier lugar dentro del bloque de código. Las variables locales de
un bloque de código pueden determinarse buscando operaciones de
vinculación de nombres en el texto completo del bloque.

Si la declaración "global" ocurre dentro de un bloque, todos los usos
del nombre especificado en la declaración se refieren a la vinculación
que ese nombre tiene en el espacio de nombres (*namespace*) de nivel
superior. Los nombres se resuelven en el espacio de nombres de nivel
superior buscando en el espacio de nombres global, es decir, el
espacio de nombres del módulo que contiene el bloque de código, y en
el espacio de nombres incorporado, el *namespace* del módulo
"builtins". La búsqueda se realiza primero en el espacio de nombres
global. Si el nombre no se encuentra ahí, se busca en el espacio de
nombres incorporado (*builtins namespace*). La declaración "global"
debe preceder a todos los usos del nombre.

The "global" statement has the same scope as a name binding operation
in the same block.  If the nearest enclosing scope for a free variable
contains a global statement, the free variable is treated as a global.

The "nonlocal" statement causes corresponding names to refer to
previously bound variables in the nearest enclosing function scope.
"SyntaxError" is raised at compile time if the given name does not
exist in any enclosing function scope.

El espacio de nombres (*namespace*) para un módulo se crea
automáticamente la primera vez que se importa el módulo. El módulo
principal de un *script* siempre se llama "__main__".

Los bloques de definición de clase y los argumentos para "exec()" y
"eval()" son especiales en el contexto de la resolución de nombres.
Una definición de clase es una declaración ejecutable que puede usar y
definir nombres. Estas referencias siguen las reglas normales para la
resolución de nombres con la excepción de que se buscan las variables
locales no vinculadas en el espacio de nombres global. El espacio de
nombres de la definición de clase se vuelve el diccionario de
atributos de la clase. El ámbito de nombres definido en un bloque de
clase está limitado a dicho bloque; no se extiende a los bloques de
código de los métodos. Esto incluye las comprensiones y las
expresiones generadoras (*generator expressions*), dado que están
implementadas usando el alcance de función. Esto implica que lo
siguiente fallará:

   class A:
       a = 42
       b = list(a + i for i in range(10))


4.2.3. Builtins and restricted execution
----------------------------------------

**CPython implementation detail:** Los usuarios no deberían tocar
"__builtins__"; es un detalle de la implementación en sentido
estricto. Los usuarios que quieran sobreescribir valores en los
espacios de nombres incorporados deberían usar "import" con el módulo
"builtins" y modificar sus atributos de un modo adecuado.

El espacio de nombres incorporado (*builtin namespace*) asociado a la
ejecución de un bloque de código es encontrado buscando el nombre
"__builtins__" en su espacio de nombres global; debería ser un
diccionario o un módulo (en este último caso, se usa el diccionario
del módulo). Por defecto, en el módulo "__main__", "__builtins__" es
el módulo "builtins". En cualquier otro módulo,  "__builtins__" es un
alias para el diccionario del propio módulo "builtins".


4.2.4. Interacción con funcionalidades dinámicas
------------------------------------------------

La resolución de variables libres sucede en tiempo de ejecución, no en
tiempo de compilación. Esto significa que el siguiente código va a
mostrar 42:

   i = 10
   def f():
       print(i)
   i = 42
   f()

The "eval()" and "exec()" functions do not have access to the full
environment for resolving names.  Names may be resolved in the local
and global namespaces of the caller.  Free variables are not resolved
in the nearest enclosing namespace, but in the global namespace.  [1]
The "exec()" and "eval()" functions have optional arguments to
override the global and local namespace.  If only one namespace is
specified, it is used for both.


4.3. Excepciones
================

Las excepciones son un medio para salir del flujo de control normal de
un bloque de código, para gestionar errores u otras condiciones
excepcionales. Una excepción es *lanzada* (*raised*) en el momento en
que se detecta el error; puede ser *gestionada* (*handled*) por el
bloque de código que la rodea o por cualquier bloque de código que
directa o indirectamente ha invocado al bloque de código en el que
ocurrió el error.

El intérprete Python lanza una excepción cuando detecta un error en
tiempo de ejecución (como una división por cero). Un programa Python
también puede lanzar una excepción explícitamente, con la declaración
"raise". Los gestores de excepciones se especifican con la declaración
"try" ... "except". La cláusula "finally" de tales declaraciones puede
utilizarse para especificar código de limpieza que no es el que
gestiona la excepción, sino que se ejecutará en cualquier caso, tanto
cuando la excepción ha ocurrido en el código que la precede, como
cuando esto no ha sucedido.

Python usa el modelo de gestión de errores de "terminación"
("*termination*"): un gestor de excepción puede descubrir qué sucedió
y continuar la ejecución en un nivel exterior, pero no puede reparar
la causa del error y reintentar la operación que ha fallado (excepto
que se reingrese al trozo de código fallido desde su inicio).

Cuando una excepción no está gestionada en absoluto, el intérprete
termina la ejecución del programa, o retorna a su bucle principal
interactivo. En cualquier caso, imprime un seguimiento de pila,
excepto cuando la excepción es "SystemExit".

Las excepciones están identificadas por instancias de clase. Se
selecciona la cláusula "except" dependiendo de la clase de la
instancia: debe referenciar a la clase de la instancia o a una clase
base de la misma. La instancia puede ser recibida por el gestor y
puede contener información adicional acerca de la condición
excepcional.

Nota:

  Los mensajes de excepción no forman parte de la API Python. Su
  contenido puede cambiar entre una versión de Python y la siguiente
  sin ningún tipo de advertencia; el código que corre bajo múltiples
  versiones del intérprete no debería basarse en estos mensajes.

Mira también la descripción de la declaración "try" en la sección La
sentencia try, y la declaración "raise" en la sección The raise
statement.

-[ Notas al pie ]-

[1] Esta limitación se da porque el código ejecutado por estas
    operaciones no está disponible en el momento en que se compila el
    módulo.
