Ambito de las variables

Variables locales

Una variable definida dentro de una función, se considera de ámbito local, se crea cada vez que se ejecuta la función, y se destruye al finalizar esta:

def perimetro(r):
    pi = 3.14159
    p = r * pi * 2
    return p

radio = 5
print(perimetro(radio))

En este ejemplo, las variables pi y p son locales, y no serán reconocidas fuera del bloque de sentencias de la función. Por ejemplo:

def calc_perimetro(r):
    pi = 3.14159
    p = r * pi * 2
    return p

def mostrar_perimetro(rd):
    perim = calc_perimetro(rd)
    print(perim)

radio = 5
mostrar_perimetro(radio)

En este caso:

• Desde el bloque principal llamamos a la función mostrar_perimetro() y desde esta, a su vez, a la función calc_perimetro().

• Cuando llamamos a mostrar_perimetro(), se crea la variable local perim, que se destruye automáticamente al finalizar la ejecución de mostrar_perimetro(). Durante este tiempo, la variable perim existe y ocupa temporalmente un espacio en la memoria RAM, pero no es visible para la función calc_perimetro(), ya que su ámbito se limita a la función donde se define.

Parámetros

Los parámetros de una función actúan como variables locales. En el ejemplo, la variable rd es de ámbito local y accesible solo para la función mostrar_perimetro,

Variables globales

Las variables definidas fuera de toda función se consideran de ámbito global, y son accesibles desde cualquier punto del programa. Por ejemplo:

def perimetro(r):
    pi = 3.14159
    p = r * pi * 2
    return p

radio = 5
print(perimetro(radio))

La variable radio es global, y por lo tanto, no es necesario pasarla como argumento. El programa podría quedar así:

def perimetro():
    pi = 3.14159
    p = radio * pi * 2
    return p

radio = 5
print(perimetro())

Tapando variables

En los ejemplos, hemos hecho que la variable pasada a una función y el parámetro receptor tengan diferentes nombres:

def perimetro(r):
    ...

perimetro(radio)

Pero... ¿que pasa si tienen igual nombre? Cada función tiene su propio espacio de nombres, y dos variables pueden llamarse igual si pertenecen a diferentes funciones. Por otra parte, si una variable local se llama como una global, las menciones a la variable dentro de la función se referirán a la local, que "tapará" a la global:

def test1():
    print("Accediendo a x global en test1:", x)

def test2():    
    x = 1
    print("Accediendo a x local en test2:", x)

x = 0
print("Valor inicial x global:", x)
test1()
test2()
print("Valor final x global:", x)

Muestra:

Valor inicial x global: 0
Accediendo a x global en test1: 0
Accediendo a x local en test2: 1
Valor final x global: 0

En la función test2() hemos creado una variable local, asignándole el valor 1. Esta variable tapa a la global temporalmente. Al finalizar la función, el acceso a la variable global se recupera, y su valor sigue siendo el original.

Modificar variables globales

Una variable global puede ser accedida y modificada por cualquier función. Pero hay dos inconvenientes:

• En un programa complejo, con muchas funciones, es dificil controlar cual de ellas está modificando una variable global. El programa puede volverse bastante ingobernable. Conviene limitar el uso de variables globales.

• Si en una función intentamos modificar una variable global, en realidad estaremos creando una nueva variable local:

  def test():    
      x = 1
  
  x = 0
  test()
  print(x)
  

En este ejemplo, al finalizar la función test(), la variable global no ha sido modificada y el programa mostrará un valor 0. Hemos creado una variable local con valor 1, que ha existido brevemente y se ha destruido al finalizar la función.

Este problema se puede solucionar declarando, al inicio de la función, las variables que han de ser consideradas como globales:

def test():
    global x
    x = 1

x = 0
test()
print(x)

Y ahora, el programa mostrará la variable x con valor 1.