Hola de nuevo. En este video vamos a explorar
algunos conceptos básicos de programación
usando Python como nuestro lenguaje. En la
sección anterior se discutieron los algoritmos
y sus formas de representación. Python es
un lenguaje de programación, entre muchos,
que nos permite trasladar estas instrucciones
a una computadora.
En este diagrama de flujo tenemos los siguientes
pasos: obtener radio, asignar una aproximación
de Pi a una variable con nombre Pi, calcular
el perímetro del círculo y almacenar el
resultado en una variable llamada perímetro,
calcular el área del círculo y almacenar
el resultado en una variable llamada área
y desplegar o imprimir los valores de las
variables perímetro y área. Las instrucciones
de este diagrama se traducen a Python así,
y aunque a primera vista puede resultar confuso,
intentaremos asociar los pasos del diagrama
con los del código. Por el orden y el nombre
de las variables, notaremos que la solicitud
del radio se realiza con la instrucción input,
de momento vamos a ignorar los paréntesis
que están allí incluidos. El siguiente paso
es asignar la aproximación de Pi, y con este
paso ya podemos ver un patrón, la flecha
en los diagramas de flujo es lo que el signo
igual es en el código y se refiere a una
operación que llamamos asignación. La asignación
almacena un valor en una variable y, coloquialmente,
decimos que le pone valor a la variable, porque
la variable nos permite hacer referencia al
mismo más adelante.
La utilidad de la asignación se hace aparente
cuando consideramos su ausencia. Si, por ejemplo,
el número Pi no tuviera ese nombre, cada
vez que quisiéramos usarlo tendríamos que
enumerar sus dígitos hasta alguna aproximación,
esto sería engorroso y daría oportunidad
de cometer errores o imprecisiones. Usar una
variable hace nuestro código más legible
y, además, nos permite centralizar los cambios.
Si algún día la geometría fundamental cambia
por alguna razón y Pi se vuelve 4.14159 en
lugar de 3.14159, nadie tendrá problemas
leyendo libros de texto escritos antes de
este cambio, porque en todos ellos dirá Pi
en vez de 3.14159. Todo el mundo sabrá que
el significado de Pi ha cambiado y los libros
de texto que se escriban luego del cambio
se referirán a este número por el nombre
Pi, tal como los libros de antaño. Claro
que si esto sucede, muy probablemente, todos
los usos de Pi conocidos dejen de ser válidos.
Pero, al menos, la variable habrá cumplido
su propósito.
Continuando veremos que las instrucciones
para calcular el perímetro y el área son
fáciles de identificar porque son casi iguales
a las del diagrama. Finalmente, el despliegue
de los resultados, notaremos que se hace con
la instrucción print. La particularidad con
esta instrucción es la coma que separa las
variables. Si vemos los resultados de ejecutar
este código notaremos que al mostrarse los
resultados, la coma no aparece. Esto es porque,
para Python, la coma está fungiendo de forma
similar como para nosotros sirve la coordinación
y, aunque hay detalles con respecto a esto
que no trataremos en el video, la coma es
parte de la sintaxis de Python. En otras palabras,
es parte de la estructura del lenguaje que
permite dar continuidad a una idea. Python
la necesita para entender que lo que queremos
es que muestre dos valores, ya que para él,
los espacios en blanco tienen un propósito
diferente al que para nosotros tienen durante
una lectura. Para Python, los espacios en
blanco pueden establecer una jerarquía de
operación y en ocasiones pueden ser insignificantes.
Notemos que el principio y el final del diagrama
de flujo no aparecen en el código de Python,
en este ejemplo son ignorables porque se puede
interpretar que el código inicia donde esté
la primera instrucción y termina dónde ya
no hayan instrucciones. Si nos ponemos estrictos
hay que mencionar que las computadoras sí
identifican donde inicia y termina un conjunto
de instrucciones que tiene que ejecutar, pero
a un nivel más bajo y técnico y, además,
de forma automática.
Para qué sirve, entonces, detallar el inicio
y fin de un diagrama de flujo. Así como evolucionaron
los lenguajes de programación formando estructuras
complejas a partir de parámetros básicos
y luego usando estas estructuras como elementos
básicos de estructuras aún más complejas,
de la misma forma, evolucionan las soluciones
para los problemas. Esta capacidad de abstracción
es esencial para resolver problemas, correspondientemente
para desarrollar programas.
Es práctica común y casi obligatoria en
la programación moderna el modularizar, que
es una forma de decir: separar en partes semi-independientes
nuestro código. Una de las reglas esenciales
en la programación es divide and conquer,
que expresa que para resolver un problema
es necesario separar en problemas más sencillos
que luego se resuelven de forma individual
y, finalmente, se unen para formar la solución
general. Dependiendo de qué tan complejo
sea el problema, las partes que conforman
su solución pueden ser a su vez subdividas
en partes cada una. Esto es una cuestión
de criterio y conveniencia. La cuestión es
que la solución a uno de estos subproblemas
puede ser necesitada con frecuencia o para
diferentes casos del mismo problema.
El inicio y el final de un diagrama de flujo
nos permiten identificar puntos en donde un
diagrama de flujo puede conectarse con otros
para construir una solución compleja. Esa
conexión, en código, se refiere usualmente
como una llamada. Y qué es lo que se llama,
en general, podemos decir que se llama a una
rutina. Una rutina es simplemente un conjunto
de instrucciones en código. Aunque esta definición
aplica para cualquier programa, una rutina
se identifica por cumplir un propósito específico,
tal como multiplicar dos números o llenar
una base de datos. Para el diagrama de flujo
que vemos, la rutina es casi el código que
presentamos anteriormente. Lo que falta es
proveer los medios de conexión que en el
diagrama representan el inicio y el fin y
eso lo logramos, en Python, definiendo una
función. Una función puede ser llamada,
y eso significa que puedo usar sus instrucciones
en un momento específico durante la computación
o ejecución de otro programa. El nombre de
la función hace que la llamada haga referencia
a esa función es específico. Aparte, una
función puede tener valores de retorno.
