Funciones (2)

Argumentos y devolución de valores

Las funciones en Python admiten argumentos en su llamada y permiten devolver valores. Estas posibilidades permiten crear funciones más útiles y fácilmente reutilizables.

En este apartado se muestran estos conceptos mediante cuatro ejemplos. En ellos, no se pretende encontrar la mejor solución al problema planteado, sino simplemente introducir los conceptos de argumentos y devolución de valores.

Aunque las funciones en Python pueden acceder a cualquier variable del programa declarándolas como variables globales o no locales, se necesita saber el nombre de las variables, como muestra el ejemplo siguiente:

def escribe_media():
    media = (a + b) / 2
    print(f"La media de {a} y {b} es: {media}")
    return

a = 3
b = 5
escribe_media()
print("Programa terminado")

La media de 3 y 5 es: 4.0
Programa terminado

def escribe_media():
    media = (a + b) / 2
    print(f"La media de {a} y {b} es: {media}")
    return

a = 3
b = 5
escribe_media()
print("Programa terminado")

def escribe_media():
    media = (a + b) / 2
    print(f"La media de {a} y {b} es: {media}")
    return

a = 3
b = 5
escribe_media()
print("Programa terminado")

def escribe_media():
    media = (a + b) / 2
    print(f"La media de {a} y {b} es: {media}")
    return

a = 3
b = 5
escribe_media()
print("Programa terminado")

def escribe_media():
    media = (a + b) / 2
    print(f"La media de {a} y {b} es: {media}")
    return

a = 3
b = 5
escribe_media()
print("Programa terminado")

def escribe_media():
    media = (a + b) / 2
    print(f"La media de {a} y {b} es: {media}")
    return

a = 3
b = 5
escribe_media()
print("Programa terminado")

La media de 3 y 5 es: 4.0

def escribe_media():
    media = (a + b) / 2
    print(f"La media de {a} y {b} es: {media}")
    return

a = 3
b = 5
escribe_media()
print("Programa terminado")

La media de 3 y 5 es: 4.0

def escribe_media():
    media = (a + b) / 2
    print(f"La media de {a} y {b} es: {media}")
    return

a = 3
b = 5
escribe_media()
print("Programa terminado")

La media de 3 y 5 es: 4.0
Programa terminado

El problema de una función de este tipo es que es muy difícil de reutilizar en otros programas o incluso en el mismo programa, ya que sólo es capaz de hacer la media de las variables "a" y "b". Si en el programa no se utilizan esos nombres de variables, la función no funcionaría.

Para evitar ese problema, las funciones admiten argumentos, es decir, permiten que se les envíen valores con los que trabajar. De esa manera, las funciones se pueden reutilizar más fácilmente, como muestra el ejemplo siguiente:

def escribe_media(x, y):
    media = (x + y) / 2
    print(f"La media de {x} y {y} es: {media}")
    return

a = 3
b = 5
escribe_media(a, b)
print("Programa terminado")

La media de 3 y 5 es: 4.0
Programa terminado

def escribe_media(x, y):
    media = (x + y) / 2
    print(f"La media de {x} y {y} es: {media}")
    return

a = 3
b = 5
escribe_media(a, b)
print("Programa terminado")

def escribe_media(x, y):
    media = (x + y) / 2
    print(f"La media de {x} y {y} es: {media}")
    return

a = 3
b = 5
escribe_media(a, b)
print("Programa terminado")

def escribe_media(x, y):
    media = (x + y) / 2
    print(f"La media de {x} y {y} es: {media}")
    return

a = 3
b = 5
escribe_media(a, b)
print("Programa terminado")

def escribe_media(x, y):
    media = (x + y) / 2
    print(f"La media de {x} y {y} es: {media}")
    return

a = 3
b = 5
escribe_media(a, b)
print("Programa terminado")

def escribe_media(x, y):
    media = (x + y) / 2
    print(f"La media de {x} y {y} es: {media}")
    return

a = 3
b = 5
escribe_media(a, b)
print("Programa terminado")

La media de 3 y 5 es: 4.0

def escribe_media(x, y):
    media = (x + y) / 2
    print(f"La media de {x} y {y} es: {media}")
    return

a = 3
b = 5
escribe_media(a, b)
print("Programa terminado")

La media de 3 y 5 es: 4.0

def escribe_media(x, y):
    media = (x + y) / 2
    print(f"La media de {x} y {y} es: {media}")
    return

a = 3
b = 5
escribe_media(a, b)
print("Programa terminado")

La media de 3 y 5 es: 4.0
Programa terminado

Esta función puede ser utilizada con más flexibilidad que la del ejemplo anterior, puesto que el programador puede elegir a qué valores aplicar la función.

Pero esta función tiene todavía un inconveniente. Como las variables locales de una función son inaccesibles desde los niveles superiores, el programa principal no puede utilizar la variable "media" calculada por la función y tiene que ser la función la que escriba el valor. Pero eso complica la reutilización de la función, porque aunque es probable que en otro programa nos interese una función que calcule la media, es más difícil que nos interese que escriba el valor nada más calcularlo.

Para evitar ese problema, las funciones pueden devolver valores, es decir, pueden enviar valores al programa o función de nivel superior. De esa manera, las funciones se pueden reutilizar más fácilmente, como muestra el ejemplo siguiente:

def calcula_media(x, y):
    resultado = (x + y) / 2
    return resultado

a = 3
b = 5
media = calcula_media(a, b)
print(f"La media de {a} y {b} es: {media}")
print("Programa terminado")

La media de 3 y 5 es: 4.0
Programa terminado

def calcula_media(x, y):
    resultado = (x + y) / 2
    return resultado

a = 3
b = 5
media = calcula_media(a, b)
print(f"La media de {a} y {b} es: {media}")
print("Programa terminado")

def calcula_media(x, y):
    resultado = (x + y) / 2
    return resultado

a = 3
b = 5
media = calcula_media(a, b)
print(f"La media de {a} y {b} es: {media}")
print("Programa terminado")

def calcula_media(x, y):
    resultado = (x + y) / 2
    return resultado

a = 3
b = 5
media = calcula_media(a, b)
print(f"La media de {a} y {b} es: {media}")
print("Programa terminado")

def calcula_media(x, y):
    resultado = (x + y) / 2
    return resultado

a = 3
b = 5
media = calcula_media(a, b)
print(f"La media de {a} y {b} es: {media}")
print("Programa terminado")

def calcula_media(x, y):
    resultado = (x + y) / 2
    return resultado

a = 3
b = 5
media = calcula_media(a, b)
print(f"La media de {a} y {b} es: {media}")
print("Programa terminado")

def calcula_media(x, y):
    resultado = (x + y) / 2
    return resultado

a = 3
b = 5
media = calcula_media(a, b)
print(f"La media de {a} y {b} es: {media}")
print("Programa terminado")

def calcula_media(x, y):
    resultado = (x + y) / 2
    return resultado

a = 3
b = 5
media = calcula_media(a, b)
print(f"La media de {a} y {b} es: {media}")
print("Programa terminado")

La media de 3 y 5 es: 4.0

def calcula_media(x, y):
    resultado = (x + y) / 2
    return resultado

a = 3
b = 5
media = calcula_media(a, b)
print(f"La media de {a} y {b} es: {media}")
print("Programa terminado")

La media de 3 y 5 es: 4.0
Programa terminado

Esta función puede ser utilizada con más flexibilidad que la del ejemplo anterior, puesto que el programador puede elegir qué hacer con el valor calculado por la función.

Pero esta función tiene todavía un inconveniente y es que sólo calcula la media de dos valores. Sería más interesante que la función calculara la media de cualquier cantidad de valores.

Para evitar ese problema, las funciones pueden admitir una cantidad indeterminada de valores, como muestra el ejemplo siguiente:

def calcula_media(*args):
    total = 0
    for i in args:
        total += i
    resultado = total / len(args)
    return resultado

a, b, c = 3, 5, 10
media = calcula_media(a, b, c)
print(f"La media de {a}, {b} y {c} es: {media}")
print("Programa terminado")

La media de 3, 5 y 10 es: 6.0
Programa terminado

def calcula_media(*args):
    total = 0
    for i in args:
        total += i
    resultado = total / len(args)
    return resultado

a, b, c = 3, 5, 10
media = calcula_media(a, b, c)
print(f"La media de {a}, {b} y {c} es: {media}")
print("Programa terminado")

def calcula_media(*args):
    total = 0
    for i in args:
        total += i
    resultado = total / len(args)
    return resultado

a, b, c = 3, 5, 10
media = calcula_media(a, b, c)
print(f"La media de {a}, {b} y {c} es: {media}")
print("Programa terminado")

def calcula_media(*args):
    total = 0
    for i in args:
        total += i
    resultado = total / len(args)
    return resultado

a, b, c = 3, 5, 10
media = calcula_media(a, b, c)
print(f"La media de {a}, {b} y {c} es: {media}")
print("Programa terminado")

def calcula_media(*args):
    total = 0

    for i in args:
        total += i

    resultado = total / len(args)
    return resultado

a, b, c = 3, 5, 10
media = calcula_media(a, b, c)
print(f"La media de {a}, {b} y {c} es: {media}")
print("Programa terminado")

def calcula_media(*args):
    total = 0
    for i in args:
        total += i
    resultado = total / len(args)
    return resultado

a, b, c = 3, 5, 10
media = calcula_media(a, b, c)
print(f"La media de {a}, {b} y {c} es: {media}")
print("Programa terminado")

def calcula_media(*args):
    total = 0
    for i in args:
        total += i
    resultado = total / len(args)
    return resultado

a, b, c = 3, 5, 10
media = calcula_media(a, b, c)
print(f"La media de {a}, {b} y {c} es: {media}")
print("Programa terminado")

def calcula_media(*args):
    total = 0
    for i in args:
        total += i
    resultado = total / len(args)
    return resultado

a, b, c = 3, 5, 10
media = calcula_media(a, b, c)
print(f"La media de {a}, {b} y {c} es: {media}")
print("Programa terminado")

def calcula_media(*args):
    total = 0
    for i in args:
        total += i
    resultado = total / len(args)
    return resultado

a, b, c = 3, 5, 10
media = calcula_media(a, b, c)
print(f"La media de {a}, {b} y {c} es: {media}")
print("Programa terminado")

La media de 3, 5 y 10 es: 6.0

def calcula_media(*args):
    total = 0
    for i in args:
        total += i
    resultado = total / len(args)
    return resultado

a, b, c = 3, 5, 10
media = calcula_media(a, b, c)
print(f"La media de {a}, {b} y {c} es: {media}")
print("Programa terminado")

La media de 3, 5 y 10 es: 6.0
Programa terminado

Esta última función puede ser utilizada con más flexibilidad que las anteriores, puesto que el programador puede elegir de cuántos valores hacer la media y qué hacer con el valor calculado por la función.

Las funciones pueden devolver varios valores simultáneamente, como muestra el siguiente ejemplo:

def calcula_media_desviacion(*args):
    total = 0
    for i in args:
        total += i
    media = total / len(args)
    total = 0
    for i in args:
        total += (i - media) ** 2
    desviacion = (total / len(args)) ** 0.5
    return media, desviacion

a, b, c, d = 3, 5, 10, 12
media, desviacion_tipica = calcula_media_desviacion(a, b, c, d)
print(f"Datos: {a} {b} {c} {d}")
print(f"Media: {media}")
print(f"Desviación típica: {desviacion_tipica}")
print("Programa terminado")

Datos: 3 5 10 12
Media: 7.5
Desviación típica: 3.640054944640259
Programa terminado

def calcula_media_desviacion(*args):
    total = 0
    for i in args:
        total += i
    media = total / len(args)
    total = 0
    for i in args:
        total += (i - media) ** 2
    desviacion = (total / len(args)) ** 0.5
    return media, desviacion

a, b, c, d = 3, 5, 10, 12
media, desviacion_tipica = calcula_media_desviacion(a, b, c, d)
print(f"Datos: {a} {b} {c} {d}")
print(f"Media: {media}")
print(f"Desviación típica: {desviacion_tipica}")
print("Programa terminado")

def calcula_media_desviacion(*args):
    total = 0
    for i in args:
        total += i
    media = total / len(args)
    total = 0
    for i in args:
        total += (i - media) ** 2
    desviacion = (total / len(args)) ** 0.5
    return media, desviacion

a, b, c, d = 3, 5, 10, 12
media, desviacion_tipica = calcula_media_desviacion(a, b, c, d)
print(f"Datos: {a} {b} {c} {d}")
print(f"Media: {media}")
print(f"Desviación típica: {desviacion_tipica}")
print("Programa terminado")

def calcula_media_desviacion(*args):

    total = 0
    for i in args:
        total += i
    media = total / len(args)

    total = 0
    for i in args:
        total += (i - media) ** 2
    desviacion = (total / len(args)) ** 0.5
    return media, desviacion

a, b, c, d = 3, 5, 10, 12
media, desviacion_tipica = calcula_media_desviacion(a, b, c, d)
print(f"Datos: {a} {b} {c} {d}")
print(f"Media: {media}")
print(f"Desviación típica: {desviacion_tipica}")
print("Programa terminado")

def calcula_media_desviacion(*args):
    total = 0
    for i in args:
        total += i
    media = total / len(args)

    total = 0
    for i in args:
        total += (i - media) ** 2
    desviacion = (total / len(args)) ** 0.5

    return media, desviacion

a, b, c, d = 3, 5, 10, 12
media, desviacion_tipica = calcula_media_desviacion(a, b, c, d)
print(f"Datos: {a} {b} {c} {d}")
print(f"Media: {media}")
print(f"Desviación típica: {desviacion_tipica}")
print("Programa terminado")

def calcula_media_desviacion(*args):
    total = 0
    for i in args:
        total += i
    media = total / len(args)
    total = 0
    for i in args:
        total += (i - media) ** 2
    desviacion = (total / len(args)) ** 0.5
    return media, desviacion

a, b, c, d = 3, 5, 10, 12
media, desviacion_tipica = calcula_media_desviacion(a, b, c, d)
print(f"Datos: {a} {b} {c} {d}")
print(f"Media: {media}")
print(f"Desviación típica: {desviacion_tipica}")
print("Programa terminado")

def calcula_media_desviacion(*args):
    total = 0
    for i in args:
        total += i
    media = total / len(args)
    total = 0
    for i in args:
        total += (i - media) ** 2
    desviacion = (total / len(args)) ** 0.5
    return media, desviacion

a, b, c, d = 3, 5, 10, 12
media, desviacion_tipica = calcula_media_desviacion(a, b, c, d)
print(f"Datos: {a} {b} {c} {d}")
print(f"Media: {media}")
print(f"Desviación típica: {desviacion_tipica}")
print("Programa terminado")

def calcula_media_desviacion(*args):
    total = 0
    for i in args:
        total += i
    media = total / len(args)
    total = 0
    for i in args:
        total += (i - media) ** 2
    desviacion = (total / len(args)) ** 0.5
    return media, desviacion

a, b, c, d = 3, 5, 10, 12
media, desviacion_tipica = calcula_media_desviacion(a, b, c, d)
print(f"Datos: {a} {b} {c} {d}")
print(f"Media: {media}")
print(f"Desviación típica: {desviacion_tipica}")
print("Programa terminado")

def calcula_media_desviacion(*args):
    total = 0
    for i in args:
        total += i
    media = total / len(args)
    total = 0
    for i in args:
        total += (i - media) ** 2
    desviacion = (total / len(args)) ** 0.5
    return media, desviacion

a, b, c, d = 3, 5, 10, 12
media, desviacion_tipica = calcula_media_desviacion(a, b, c, d)
print(f"Datos: {a} {b} {c} {d}")
print(f"Media: {media}")
print(f"Desviación típica: {desviacion_tipica}")
print("Programa terminado")

Datos: 3 5 10 12
Media: 7.5

def calcula_media_desviacion(*args):
    total = 0
    for i in args:
        total += i
    media = total / len(args)
    total = 0
    for i in args:
        total += (i - media) ** 2
    desviacion = (total / len(args)) ** 0.5
    return media, desviacion

a, b, c, d = 3, 5, 10, 12
media, desviacion_tipica = calcula_media_desviacion(a, b, c, d)
print(f"Datos: {a} {b} {c} {d}")
print(f"Media: {media}")
print(f"Desviación típica: {desviacion_tipica}")
print("Programa terminado")

Datos: 3 5 10 12
Media: 7.5
Desviación típica: 3.640054944640259

def calcula_media_desviacion(*args):
    total = 0
    for i in args:
        total += i
    media = total / len(args)
    total = 0
    for i in args:
        total += (i - media) ** 2
    desviacion = (total / len(args)) ** 0.5
    return media, desviacion

a, b, c, d = 3, 5, 10, 12
media, desviacion_tipica = calcula_media_desviacion(a, b, c, d)
print(f"Datos: {a} {b} {c} {d}")
print(f"Media: {media}")
print(f"Desviación típica: {desviacion_tipica}")
print("Programa terminado")

Datos: 3 5 10 12
Media: 7.5
Desviación típica: 3.640054944640259
Programa terminado

Conflictos entre nombres de parámetros y nombre de variables globales

En Python no se producen conflictos entre los nombres de los parámetros y los nombres de las variables globales. Es decir, el nombre de un parámetro puede coincidir o no con el de una variable global, pero Python no los confunde: en el ámbito de la función el parámetro hace siempre referencia al dato recibido y no a la variable global y los programas producen el mismo resultado.

Eso nos facilita reutilizar funciones en otros programas sin tener que preocuparnos por este detalle.

Aunque, como siempre, dependiendo de si a la función se le envía como parámetro un objeto mutable o inmutable, la función podrá modificar o no al objeto. En los dos siguientes ejemplos, el parámetro de la función ("b") se llama igual que una de las dos variables del programa principal. En los dos ejemplos se llama dos veces a la función, enviando cada vez una de las dos variables ("a" y "b").

• Ejemplo de conflicto entre nombre de parámetro y nombre de variable global. Objeto mutable

  Como en este caso las variables son listas (objetos mutables), la función modifica la lista que se envía como argumento: primero se modifica la lista "a" y a continuación la lista "b". La lista modificada no depende del nombre del parámetro en la función (que es "b"), sino de la variable enviada como argumento ("a" o "b").

  def cambia(b):
      b += [5]
      return
  
  a, b = [3], [4]
  print(f"Al principio        : a = {a} b = {b}")
  cambia(a)
  print(f"Después de cambia(a): a = {a} b = {b}")
  cambia(b)
  print(f"Después de cambia(b): a = {a} b = {b}")
  print("Programa terminado")
  

  Al principio        : a = [3] b = [4]
  Después de cambia(a): a = [3, 5] b = [4]
  Después de cambia(b): a = [3, 5] b = [4, 5]
  Programa terminado
  

• Ejemplo de conflicto entre nombre de parámetro y nombre de variable global. Objeto inmutable

  Como en este caso las variables son números enteros (objetos inmutables), la función no puede modificar los números que se envían como argumentos, ni la variable "a" ni la variable "b".

  def cambia(b):
      b += 1
      return
  
  a, b = 3, 4
  print(f"Al principio        : a = {a} b = {b}")
  cambia(a)
  print(f"Después de cambia(a): a = {a} b = {b}")
  cambia(b)
  print(f"Después de cambia(b): a = {a} b = {b}")
  print("Programa terminado")
  

  Al principio        : a = 3 b = 4
  Después de cambia(a): a = 3 b = 4
  Después de cambia(b): a = 3 b = 4
  Programa terminado
  

Paso por valor o paso por referencia

En los lenguajes en los que las variables son "cajas" en las que se guardan valores, cuando se envía una variable como argumento en una llamada a una función suelen existir dos posibilidades:

• paso por valor: se envía simplemente el valor de la variable, en cuyo caso la función no puede modificar la variable, pues la función sólo conoce su valor, pero no la variable que lo almacenaba.
• paso por referencia: se envía la dirección de memoria de la variable, en cuyo caso la función sí que puede modificar la variable.

En Python no se hace ni una cosa ni otra. En Python cuando se envía una variable como argumento en una llamada a una función lo que se envía es la referencia al objeto al que hace referencia la variable. Dependiendo de si el objeto es mutable o inmutable, la función podrá modificar o no el objeto.

• En el ejemplo siguiente, la variable enviada a la función es una variable que hace referencia a un objeto inmutable.

  Ejemplo de paso de variable (objeto inmutable)

  def aumenta(x):
      print(id(x))
      x += 1
      print(id(x))
      return x
  
  a = 3
  print(id(3), id(4))
  print(id(a))
  print(aumenta(a))
  print(a)
  print(id(a))
  

  505894336 505894352
  505894336
  505894336
  505894352
  4
  3
  505894336
  

  Puede ver la ejecución paso a paso de este programa utilizando los iconos de avance y retroceso situados abajo a la derecha.

  

  Ejemplo de paso de variable (objeto inmutable) - Paso 1

  def aumenta(x):
      print(id(x))
      x += 1
      print(id(x))
      return x
  
  print(id(3), id(4))
  a = 3
  print(id(a))
  print(aumenta(a))
  print(a)
  print(id(a))
  

  505894336 505894352

  En la primera instrucción se escriben los identificadores de los objetos inmutables número 3 y número 4.

  

  Ejemplo de paso de variables (objeto inmutable) - Paso 2

  def aumenta(x):
      print(id(x))
      x += 1
      print(id(x))
      return x
  
  print(id(3), id(4))
  a = 3
  print(id(a))
  print(aumenta(a))
  print(a)
  print(id(a))
  

  505894336 505894352

  En la segunda instrucción se crea la variable "a", que hace referencia al número 3.

  

  Ejemplo de paso de variable (objeto inmutable) - Paso 3

  def aumenta(x):
      print(id(x))
      x += 1
      print(id(x))
      return x
  
  print(id(3), id(4))
  a = 3
  print(id(a))
  print(aumenta(a))
  print(a)
  print(id(a))
  

  505894336 505894352
  505894336
  

  En la segunda instrucción se escribe el identificador de la variable "a", que coincide con el del objeto número 3.

  

  Ejemplo de paso de variable (objeto inmutable) - Paso 4

  def aumenta(x):
      print(id(x))
      x += 1
      print(id(x))
      return x
  
  print(id(3), id(4))
  a = 3
  print(id(a))
  print(aumenta(a))
  print(a)
  print(id(a))
  

  505894336 505894352
  505894336
  

  A continuación se ejecuta la llamada a la función. De acuerdo con la definición de la función, se envía el argumento, en este caso, se envía la variable "a". En Python, enviar una variable significa enviar el identificador del objeto al que hace referencia la variable.

  

  Ejemplo de paso de variable (objeto inmutable) - Paso 5

  def aumenta(x):
      print(id(x))
      x += 1
      print(id(x))
      return x
  
  print(id(3), id(4))
  a = 3
  print(id(a))
  print(aumenta(a))
  print(a)
  print(id(a))
  

  505894336 505894352
  505894336
  505894336
  

  Se ejecuta la primera instrucción de la función, que escribe el identificador de la variable local de la función "x", que es el mismo que el de la variable del programa principal "a" (que es el mismo del objeto "3").

  

  Ejemplo de paso de variable (objeto inmutable) - Paso 6

  def aumenta(x):
      print(id(x))
      x += 1
      print(id(x))
      return x
  
  print(id(3), id(4))
  a = 3
  print(id(a))
  print(aumenta(a))
  print(a)
  print(id(a))
  

  505894336 505894352
  505894336
  505894336
  

  La segunda instrucción aumenta el valor de la variable "x", de 3 a 4, por lo que la variable "x" pasa de hacer referencia al objeto número 3 a hacer referencia al objeto número 4.

  

  Ejemplo de paso de variable (objeto inmutable) - Paso 7

  def aumenta(x):
      print(id(x))
      x += 1
      print(id(x))
      return x
  
  print(id(3), id(4))
  a = 3
  print(id(a))
  print(aumenta(a))
  print(a)
  print(id(a))
  

  505894336 505894352
  505894336
  505894336
  505894352
  

  La tercera instrucción de la función vuelve a escribr el identificador de la variable local de la función "x", que es ahora el mismo que el del objeto número 4.

  

  Ejemplo de paso de variable (objeto inmutable) - Paso 8

  def aumenta(x):
      print(id(x))
      x += 1
      print(id(x))
      return x
  
  print(id(3), id(4))
  a = 3
  print(id(a))
  print(aumenta(a))
  print(a)
  print(id(a))
  

  505894336 505894352
  505894336
  505894336
  505894352
  

  La instrucción return indica el final de la función pero también el valor que devuelve la función, que en este caso es la variable "x" (realmente es el identificador de la variable "x", que es el identificador del objeto número 4). La ejecución del programa continua tras la llamada a la función.

  

  Ejemplo de paso de variable (objeto inmutable) - Paso 9

  def aumenta(x):
      print(id(x))
      x += 1
      print(id(x))
      return x
  
  print(id(3), id(4))
  a = 3
  print(id(a))
  print(aumenta(a))
  print(a)
  print(id(a))
  

  505894336 505894352
  505894336
  505894336
  505894352
  4
  

  Se imprime el valor devuelto por la función (4).

  

  Ejemplo de paso de variable (objeto inmutable) - Paso 10

  def aumenta(x):
      print(id(x))
      x += 1
      print(id(x))
      return x
  
  print(id(3), id(4))
  a = 3
  print(id(a))
  print(aumenta(a))
  print(a)
  print(id(a))
  

  505894336 505894352
  505894336
  505894336
  505894352
  4
  3
  

  Se imprime el valor de la variable "a", que sigue siendo 3, pues la función no ha modificado su valor.

  

  Ejemplo de paso de variable (objeto inmutable) - Paso 11

  def aumenta(x):
      print(id(x))
      x += 1
      print(id(x))
      return x
  
  print(id(3), id(4))
  a = 3
  print(id(a))
  print(aumenta(a))
  print(a)
  print(id(a))
  

  505894336 505894352
  505894336
  505894336
  505894352
  4
  3
  505894336
  

  Se imprime el identificador de la variable "a", que sigue siendo el del objeto número 3, y el programa termina.

  

• En el ejemplo siguiente, la variable enviada a la función es una variable que hace referencia a un objeto mutable.

  Ejemplo de paso de variable (objeto mutable)

  def aumenta(x):
      print(id(x))
      x += [1]
      print(id(x))
      return x
  
  a = [3]
  print(id(a))
  print(aumenta(a))
  print(a)
  print(id(a))
  

  45688512
  45688512
  45688512
  [3, 1]
  [3, 1]
  45688512
  

  Puede ver la ejecución paso a paso de este programa utilizando los iconos de avance y retroceso situados abajo a la derecha.

  

  Ejemplo de paso de variable (objeto mutable) - Paso 1

  def aumenta(x):
      print(id(x))
      x += [1]
      print(id(x))
      return x
  
  a = [3]
  print(id(a))
  print(aumenta(a))
  print(a)
  print(id(a))
  

  En la primera instrucción se crea la variable "a", que hace referencia a la lista [3].

  

  Ejemplo de paso de variable (objeto mutable) - Paso 2

  def aumenta(x):
      print(id(x))
      x += [1]
      print(id(x))
      return x
  
  a = [3]
  print(id(a))
  print(aumenta(a))
  print(a)
  print(id(a))
  

  45688512

  En la segunda instrucción se escribe el identificador de la variable "a".

  

  Ejemplo de paso de variable (objeto mutable) - Paso 3

  def aumenta(x):
      print(id(x))
      x += [1]
      print(id(x))
      return x
  
  a = [3]
  print(id(a))
  print(aumenta(a))
  print(a)
  print(id(a))
  

  45688512

  A continuación se ejecuta la llamada a la función. De acuerdo con la definición de la función, se envía el argumento, en este caso, se envía la variable "a". En Python, enviar una variable significa enviar el identificador del objeto al que hace referencia la variable.

  

  Ejemplo de paso de variable (objeto mutable) - Paso 4

  def aumenta(x):
      print(id(x))
      x += [1]
      print(id(x))
      return x
  
  a = [3]
  print(id(a))
  print(aumenta(a))
  print(a)
  print(id(a))
  

  45688512
  45688512
  

  Se ejecuta la primera instrucción de la función, que escribe el identificador de la variable local de la función "x", que es el mismo que el de la variable del programa principal "a".

  

  Ejemplo de paso de variable (objeto mutable) - Paso 5

  def aumenta(x):
      print(id(x))
      x += [1]
      print(id(x))
      return x
  
  a = [3]
  print(id(a))
  print(aumenta(a))
  print(a)
  print(id(a))
  

  45688512
  45688512
  

  La segunda instrucción añade el elemento [1] a la lista "x", de [3] a [3, 1]. Como las listas son objetos mutables y la asignación aumentada += modifica el objeto, no se crea un nueva lista sino que se modifica la lista a la que hace referencia la variable "x" (que es la misma a la que hace referencia la variable del programa principal "a").

  

  Ejemplo de paso de variable (objeto mutable) - Paso 6

  def aumenta(x):
      print(id(x))
      x += [1]
      print(id(x))
      return x
  
  a = [3]
  print(id(a))
  print(aumenta(a))
  print(a)
  print(id(a))
  

  45688512
  45688512
  45688512
  

  La tercera instrucción de la función vuelve a escribr el identificador de la variable local de la función "x", que sigue siendo la misma.

  

  Ejemplo de paso de variable (objeto mutable) - Paso 7

  def aumenta(x):
      print(id(x))
      x += [1]
      print(id(x))
      return x
  
  a = [3]
  print(id(a))
  print(aumenta(a))
  print(a)
  print(id(a))
  

  45688512
  45688512
  45688512
  

  La instrucción return indica el final de la función pero también el valor que devuelve la función, que en este caso es la variable "x" (realmente es el identificador de la variable "x", que es el identificador de la lista [3, 1]). La ejecución del programa continua tras la llamada a la función.

  

  Ejemplo de paso de variable (objeto mutable) - Paso 8

  def aumenta(x):
      print(id(x))
      x += [1]
      print(id(x))
      return x
  
  a = [3]
  print(id(a))
  print(aumenta(a))
  print(a)
  print(id(a))
  

  45688512
  45688512
  45688512
  [3, 1]
  

  Se imprime el valor devuelto por la función ([3, 1]).

  

  Ejemplo de paso de variable (objeto mutable) - Paso 9

  def aumenta(x):
      print(id(x))
      x += [1]
      print(id(x))
      return x
  
  a = [3]
  print(id(a))
  print(aumenta(a))
  print(a)
  print(id(a))
  

  45688512
  45688512
  45688512
  [3, 1]
  [3, 1]
  

  Se imprime el valor de la variable "a", que es ahora [3, 1], pues la función ha modificado la lista.

  

  Ejemplo de paso de variable (objeto mutable) - Paso 10

  def aumenta(x):
      print(id(x))
      x += [1]
      print(id(x))
      return x
  
  a = [3]
  print(id(a))
  print(aumenta(a))
  print(a)
  print(id(a))
  

  45688512
  45688512
  45688512
  [3, 1]
  [3, 1]
  45688512
  

  Se imprime el identificador de la variable "a", que sigue siendo el mismo, y el programa termina.