(Python) Subrutinas: Procedimientos y Funciones - 1

Subrutinas

El uso de subrutinas le permite evitar la duplicación de código, si necesita escribir el mismo código en diferentes lugares del programa. 
Las bibliotecas que se importan a un programa (por ejemplo, la biblioteca de matemáticas math) consisten en subrutinas que ya han sido compiladas por alguien. Los programadores no necesitan pensar en qué algoritmos implementarán, sino simplemente aplicarlos, pensando solo en lo que están haciendo exactamente. Este es un gran ahorro de tiempo. No es necesario escribir un algoritmo que ya haya sido escrito por otra persona.

Cada subrutina solo debe hacer una tarea,  simplemente calcule algo, genere algunos datos o haga otra cosa. 

Hay dos tipos de subrutinas: procedimientos y funciones.

Los subprocedimientos realizan alguna acción, como mostrar un resultado en la pantalla de cierta forma (un ejemplo simple, la declaración print() es un subprocedimiento estándar que imprime datos en la pantalla).

Las subrutinas de función devuelven un resultado (número, cadena de caracteres, etc.) que podemos usar en el programa principal.

Tratemos de escribir un procedimiento simple:
Supongamos que necesitamos mostrar la cadena "Error" en la pantalla cada vez que puede ocurrir un error en el código por culpa del usuario, por ejemplo, cuando ingresa datos incorrectos.
Esto se puede hacer escribiendo la declaración imprimir("Error") Y ahora imagine que esa línea debe insertarse en muchos lugares del programa. Por supuesto, puedes escribirlo en todas partes. Pero esta solución tiene dos inconvenientes.
1) Esta cadena se almacenará en la memoria muchas veces.
2) Si queremos cambiar la salida en caso de error, tendremos que cambiar esta línea en todo el programa, lo cual es bastante inconveniente

Para tales casos, se necesitan procedimientos.
Un programa con un procedimiento podría verse así:
  def printError(): # descripción del procedimiento imprimir("Error") ... printError() # inicia el procedimiento para su ejecución. # Solo especifica el nombre del procedimiento que queremos ejecutar ... imprimirError()

¡Necesito recordar!

1. El procedimiento comienza con la palabra def (del inglés - define - para definir). Después del nombre del procedimiento, se escriben corchetes vacíos y dos puntos . Los parámetros se pueden especificar entre corchetes (hablaremos de esto más adelante).
2. Todas las sentencias que se ejecutan en un procedimiento están sangradas. 
3. Para ejecutar un procedimiento, en el programa principal debe llamarlo por su nombre y recuerde escribir paréntesis!
4. Puede llamar a un procedimiento en un programa tantas veces como desee.

Parámetros y Argumentos

Ahora imaginemos que necesitamos mostrar diferentes mensajes en respuesta al error de un usuario, dependiendo del tipo de error que haya cometido.
En este caso, puede escribir su propio procedimiento para cada error:   def imprimirErrorCero(): print("Error. ¡División por cero!") def imprimirEntradaError(): print("¡Error en la entrada!")
¿Qué pasa si hay muchos más errores posibles? ¡Esta solución no nos conviene!
Necesitamos aprender a controlar el procedimiento diciéndole qué mensaje de error mostrar.
Para hacer esto, necesitamos parámetros que escribiremos entre paréntesis después del nombre del procedimiento def imprimirError(s): imprimir("s")
En este procedimiento, s es un parámetro, una variable especial que le permite controlar el procedimiento.
 

El parámetro es una variable que determina cómo funciona la subrutina. Los nombres de los parámetros están separados por comas en el encabezado de la subrutina.

Ahora, al llamar al procedimiento, debe indicar entre paréntesis el valor real que se asignará al parámetro (variable s) dentro de nuestro procedimiento printError("¡Error! ¡División por cero!")
Tal valor se llama argumento.
 

El argumento es el valor del parámetro que se pasa a la subrutina cuando se llama.

Un argumento puede ser no solo un valor constante, sino también una variable o una expresión aritmética.

Variables locales y globales

Puede acceder a las variables globales desde cualquier subrutina. 

A menudo es necesario introducir variables adicionales que solo se utilizarán en la subrutina. Este tipo de variables se denominan locales (o locales). Puede trabajar con ellos solo dentro de la subrutina en la que se crean. El resto de las rutinas no "saben" nada de ellas.

Así, es posible limitar el alcance (scope) de una variable solo a la subrutina donde realmente se necesita. En programación, esta técnica se llama encapsulación  - ocultar la variable para que no se modifique desde el exterior.

Analice tres programas:

 

Descripción	Programa
1) En este programa, la variable i es local. Si no hay una variable i en el programa principal, obtendremos un mensaje de error. Y si existe tal variable (entonces es una variable global), su valor se muestra en la pantalla.	prueba de definición(): imprimir(i)
2) Aquí, incluso si hay una variable global i, se creará una nueva variable local i con un valor de 2, y aparecerá 2 en la pantalla.	prueba de definición():   yo = 2 imprimir(i)
3) En este programa existe una variable global i con un valor de 15. Su valor puede ser cambiado dentro de la subrutina, para ello es necesario declarar explícitamente que es global ( use el comando global ). El procedimiento funcionará con la variable global i y se le asignará un nuevo valor de 2. Se muestra el valor 2.	prueba de definición():   global yo yo = 2 # programa principal yo = 15 imprimir (yo)