Todo el código que propongo aquí debe ser verificado por el lector en uno de los tres ambientes siguientes:

(1)

ecabrera, sdqdr, septiembre 2015 1

print

Hay un lenguaje de programación, llamado Python, que aquí propongo para que estudiantes de Primaria y Secundaria lo usen para explorar la matemática elemental.

Todo el código que propongo aquí debe ser verificado por el lector en uno de los tres ambientes siguientes: IDLE Pyhthon, para pc, descargar https://www.python.org/downloads.

Qpython, para móvil, descargable desde la Play Store. Ideone.com, para usar en línea desde pc o móvil.

Un primer programa Python, # hola

print 'hola, mundo.'

explicación:

El carácter # le dice a Python que el texto que le sigue en esa línea sea ignorado, es un comentario. print es una sentencia o comando que le dice a Python que envíe un mensaje a la pantalla. 'hola, mundo' es el mensaje que sale en la pantalla en este caso.

Podemos también usar comillas dobles en el comando print, # hola

print "hola, mundo."

Sean simples o dobles, las comillas deben ser rectas: ' ', o " ". Y se puede combinar cuando queremos que el mensaje o parte de él salga entre comillas,

# hola

print "hola, 'mundo'."

Se recomienda al lector ejecutar todos estos ejemplos en cualquiera de los tres ambientes sugeridos y asegurarse de que se escribe el mensaje hola, mundo, salvo que en el último es hola, 'mundo'..

(2)

ejecutar

Como es tan importante que el lector se familiarice con la ejecución del código y los ejercicios Python que le proponemos, mostramos una forma en que pueden hacerlo usando IDLE en una PC.

Lo primero es descargar el software desde el sitio, escribiendo, por ejemplo, en Google: idle for

windows, y escogiendo la opción Download Python | Python.org. Recomendamos la versión 2.7.10 y de acuerdo a su Sistema Operativo (Windows, OS, Linux, Unix). Se descarga y se instala siguiendo las instrucciones que se dan.

Recomendamos crear una carpeta en el Escritorio, llamada, por ejemplo, python code. Usando notepad, crear un archivo de texto cuyo contenido sea,

# hola

print "hola, 'mundo'."

Grabar este archivo dentro de la carpeta python code, con el nombre hola.py, asegurando que la opción para grabar de Notepad sea All files, o *.*. Entonces, al abrir la carpeta python code el icono asociado al archivo hola.py debe verse así,

Quiere decir que el archivo de texto ha sido asociado con IDLE, y si hacemos clic derecho sobre el icono de hola.py y tomamos la opción del menú de contexto Edit with IDLE, tendremos el texto del programa y lo podemos ejecutar con la opción Run del menú principal en la parte superior,

Escogemos la opción Run Module F5 del submenú que parece al escoger Run, y vemos la ejecución de nuestro programa,

Como este programa está redactado sólo para escribir este mensaje en la consola (Shell) es todo lo que veremos que haga. A medida que avancemos, nuestros programas se harán más interesantes.

Para ejecutar nuestro programa en IDLE elegimos Run, Run module F5.Para crear nuevos programas podemos partir de uno anterior, modificarlo y grabarlo con Guardar como.. (Save as..).

(3)

variable

Pasemos ahora a manipular números, que es uno de nuestros objetivos esenciales aquí. Consideremos un programa que escriba los primeros tres números naturales: 1 2 3,

# primeros 3 naturales print '1 2 3'

Este programa es como hola.py, pero cambiando ‘hola, mundo.’ Por ‘1 2 3’, es decir, es un mensaje literal, no numérico. Para que sea numérico podemos redactar,

# primeros 3 naturales print 1, 2, 3

Ahora le estamos diciendo a Python que escriba el número 1 y se quede en la misma línea de la pantalla; que escriba un 2 y se quede ahí; y luego escriba un 3 y salte a la próxima línea en la pantalla. El resultado es idéntico al del programa anterior, pero el tratamiento de los datos es distinto. Introduzcamos una

variable para ir añadiendo generalidad al programa, # primeros 3 naturales n = 1 # natural print n n = n + 1 print n, n = n + 1 print n,

Ahora se crea la variable n y se le asigna el valor 1. Se escribe n, que Python interpreta como que

deseamos que se escriba el valor guardado en n, en este caso 1. Luego a la variable n se le asigna el valor que tiene ahora, 1, sumándole 1, lo que da 2, y 2 es el nuevo valor de n, que es lo que se escribe a seguidas. Luego se repite el aumentar en 1 el valor de n, dando 3, y se escribe. Por tanto, este programa también escribe 1 2 3, como los otros, pero es más sofisticado y podemos ver que emerge un patrón, print n,

n = n + 1

Es claro que si queremos escribir los primeros 10 naturales basta que copiemos este patrón las veces necesarias. El concepto de variable, pues, es muy poderoso. Notemos el comentario # natural luego de introducir la variable n en nuestro programa.

Una variable es un lugar en la memoria de la memoria donde podemos guardar un valor y luego podemos remplazarlo por otro, como se ilustra con n = 1 y n = n + 1. La expresión n = n + 1 no es una ecuación, es una asignación.

(4)

while

En el programa anterior vimos emerger un patrón. Pues podemos explotar este patrón mediante el uso de la sentencia while, que permite indicar que una o más sentencias se ejecuten una o más veces, sujetas a una condición,

# primeros 3 naturales n = 1 # natural

while n <= 3: print n, n = n + 1

Se inicia creando la variable n y asignándole el valor 1. A seguidas, la sentencia while verifica si el valor de n es menor o igual que 3, y como esto es cierto (notemos los dos puntos, :, luego de la condición) se ejecutan las sentencias print n, y n = n + 1, que hacen que se escriba un 1 y n pase a ser 2.

A seguidas, se verifica nuevamente la condición del ciclo, n <= 3, que sigue siendo cierta ya que n es 2, y se vuelve a escribir a n, 2, y a darle a n el valor 3. Y de nuevo se verifica la condición, que sigue siendo cierta ya que n es igual a 3. Y se escribe 3 y n pasa a ser 4.

Al verificar nuevamente la condición, ahora resulta falsa porque 4 no es menor o igual que 3, y entonces se abandona el ciclo ya que se ejecuta mientras (while) la condición es cierta. Por cierto, si la condición es falsa desde el principio, el ciclo no se ejecuta ni una vez, se salta sin ejecutar.

Por tanto, este programa también escribe 1 2 3, los primeros 3 números naturales, como el anterior, pero usando una herramienta más sofisticada, la sentencia while.

Es claro que si ahora queremos escribir los primeros 10 números naturales no tenemos que copiar y pegar el patrón print n, y n = n + 1, sino que ahora basta cambiar el 3 por un 10. Esto significa que vale la pena dominar los conceptos de comentar, escribir, variable, asignar, y while (ciclo), pues esto nos permite explorar la matemática con Python con relativamente poco esfuerzo físico.

Es importante notar que al utilizar un ciclo while se debe asegurar que la condición indicada llegue a ser falsa alguna vez, porque de otra forma el programa quedaría atrapado en un ciclo sin fin, lo cual no es nada deseable.

Notemos también cómo se han combinado los conceptos explicados para lograr distintas soluciones al mismo problema, a saber, escribir los primeros tres números naturales. Así que un mismo problema admite distintas soluciones, más específicas o generales, duras o flexibles, dependiendo de los recursos de que disponga y utilice el programador. Por tanto, no hablaremos aquí de la solución, sino de una solución propuesta para un enunciado dado. Al enunciado discutido hasta aquí le propusimos cuatro soluciones, de complejidad creciente.

(5)

input()

Luego que el lector haya ejecutado nuestro último programa con valores distintos al 3, algunos incluso grandes, podría querer dejar que sea el usuario quien que elija el tope, digamos t, hasta donde desea que se escriban los números naturales,

# primeros t naturales, t > 0 n = 1 # natural t = input() # tope while n <= t: print n, n = n + 1

Este programa es una ampliación del anterior en que se crea la variable t y a la cual se asigna el valor que elija el usuario cuando se ejecute el programa. Claro, si el usuario da un valor 0 ó negativo, el ciclo no se ejecuta porque la condición del mismo es falsa.

Pero si proporciona un número entero positivo como se sugiere en el comentario de la primera línea, el ciclo se ejecutara t veces, escribiendo los primeros t números naturales. Por ejemplo, si el usuario ingresa el valor 10 cuando le piden a t, se escribe 1 2 3 4 5 6 7 8 9 10.

Como este texto está orientado a lectores que van comprobando los ejemplos que se van proponiendo, asumimos que el usuario que ejecuta el programa es la misma persona que ingresa el código para ejecutarlo. Si se ejecuta este programa en IDLE tendríamos algo así,

Ahora vemos que, distinto a como ocurría con los programas anteriores, ahora Python presenta un cursor sin el prompt >>>, indicando que espera a que el usuario introduzca algo. Si ingresamos 10, entonces, antes de pulsar la tecla Enter, tendremos,

Y luego de pulsar Enter,

Que son los primeros 10 naturales.

Así que mientras print muestra mensajes y resultados al usuario, input() permite aceptar valores desde el usuario para hacer que nuestro programa sea interactivo.

(6)

contador

Si observamos un poco más detenidamente nuestro último programa, # primeros t naturales, t > 0 n = 1 # natural t = input() # tope while n <= t: print n, n = n + 1

Vemos que la variable n se inicia con 1, se verifica si no ha sobrepasado el tope t y en el ciclo se

incrementa en 1 cada vez que se ejecuta éste. Y esto es justamente lo que solemos hacer los humanos al contar: Empezamos con un número natural, verificamos si sobre pasamos el tope, incrementamos y repetimos este proceso hasta que lleguemos o sobre pasemos el tope. Por eso diremos que n aquí es un contador. De hecho, podemos empezar en 2 e incrementar en 2 para obtener lo naturales pares menores que t,

# naturales pares menores o iguales a t, t > 2

p = 2 # par t = input() # tope while n < t:

print n, p = p + 2

Se escribe 2, se verifica si p es menor que t, digamos 100, y si es así, se entra en el ciclo, donde se escribe a p y se incrementa en 2 unidades cada vez, por lo que los valores de p que se escriben son 2 4 6… 96 98. El 100 no se llega a escribir (aunque p llega valer 100) porque 100 no es menor que 100 y la condición se hace falsa y se abandona el ciclo sin escribir 100. Una extensión del concepto contador es el de acumulador, que se diferencia del contador en que la cantidad que se añade no tiene que ser fija. Por ejemplo, escribir la suma de los primeros t números naturales,

# suma de los primeros t números naturales, t > 0

s = 0 # suma n = 1 # natural t = input() # tope while n <= t: s = s + n n = n + 1 print s

Ahora se crea la variable s y se le asigna el valor 0 (apara asegurar que no haya contaminación). La condición del ciclo verifica que n no sobre pase a t y cada valor de n se le suma a s, acumulando en s todos los valores de n que se obtengan, que son los primeros números naturales porque n se incrementa de 1 en 1.Notemos que sólo se escribe el valor final de s porque la sentencia print s está fuera del ciclo.

(7)

def

Como iremos abordando enunciados de cierta complejidad, empecemos bien temprano a manejar el concepto función, que es un mecanismo que nos permite ‘envolver’ un código para reutilizarlo en otro contexto. El código y las variables contenidas en una función pretenden constituir una solución general a un problema muy particular.

Por ejemplo, nuestro programa que obtiene la suma de los primeros t números naturales, admite ser convertido en la función,

def sumaNaturales(t):

s = 0 # suma n = 1 # par while n <= t: s = s + n n = n + 1 return s

La definición de la función empieza con la particular def, el nombre de la función (en este caso

sumaNaturales) y el o los parámetros que recibe (en este caso t). Notamos que el código es idéntico, salvo que ahora t no se lee, sino que se supone es recibido como parámetro y la suma no se escribe, sino que es retornada (return).

Para tener un programa que use esta función basta insertar su definicion del código del programa, y luego una sentencia que escriba el valor que retorna la función, enviando un valor apropiado para t,

def sumaNaturales(t):

s = 0 # suma n = 1 # par while n <= t: s = s + n n = n + 1 return s print sumaNaturales(10)

Este programa empieza su ejecución en la sentencia print ya que lo que le precede es la definición de la función, la cual sólo se ejecuta cuando la invocan, lo cual se ocurre mandar a escribir el valor que retorna la función cuando se le pasa el valor 10 para t. Si se ejecuta este programa escribe 55, que es la suma de los primeros 10 números naturales.

Las funciones, pues, son muy útiles para generalizar nuestro código y abordar la solución de problemas más complejos con menos sufrimiento.

(8)

if

A menudo ocurre que no estamos interesados en todos los números naturales, sino en aquellos que cumplen con cierta propiedad en un intervalo dado. Por ejemplo, se dice que un número natural es abundante si es menor que la suma de sus factores propios. El 12 es abundante porque sus factores propios son 1 2 3 4 6, cuya suma es 16, que es mayor que 12. Consideremos una función que determine si un natural n es abundante,

def abundante(n):

# si n>0 es abundante (menor que la suma de sus factores propios)

a = 0 # abundante d = 1 # divisor s = 0 # suma while d < n: if n%d == 0: s = s + d d = d + 1 if s > n: a = 1 return a

Aquí asumimos que n no es abundante asignando a la variable a el valor 0, que en lo adelante significa falso en cualquier contexto lógico. Se inicia el divisor d en 1 y la suma en 0. El ciclo se ejecuta para todos los números naturales menores que n, y en el ciclo se verifica, con la sentencia if, si el residuo de la división que deja n al dividirlo por d es cero, porque en tal caso n es múltiplo de d, y tal valor de d se acumula en la suma s.

Luego de abandonar el ciclo se verifica, con una sentencia if (si condicional) si la suma acumulada en s es mayor que n, porque en tal caso n es abundante y ello se indica asignando a la variable a el valor 1, que significa verdadero en cualquier contexto lógico.

Para comprobar que esta función trabaja correctamente, copiamos su definición en un archivo .py y le insertamos fuera y debajo de ella la sentencia print abundante(12), obteniendo 1, que significa que 12 es verdad que es abundante. Pero si probamos con print abundante(10), nos escribe 0, que significa que es falso que 10 sea un natural abundante.

La sentencia if resulta útil cuando necesitamos ejecutar una o más sentencias verificando que una condición resulta ser verdadera, ignorando tal código cuando resulte ser falsa. El operador % lo usamos cuando

queremos obtener el residuo de una división. Por ejemplo, 12%1 es 0, porque 12 es múltiplo de 1. Lo mismo ocurre con 2, 3, 4, 6. Pero 12%5 no es cero.

Así que la sentencia if es útil para cuando queremos hacer lo mismo que con while, pero que se ejecute una sola vez el detalle. Asumimos que 1 equivale a verdadero y 0 a falso.

(9)

a[]

Obtengamos, asumiendo la disponibilidad de la función abundante(), los números abundantes menores que t>0,

def abundantes(t):

# naturales abundante menores que t > 0

n = 1 # natural while n < t:

if abundante(n): print n, n = n + 1

Esta función recorre todos los naturales de 1 a t-1, y para cada uno verifica si es abundante invocando la función abundante(), que retorna un valor verdadero, 1, cuando n es abundante, y en tal caso escribe el valor de n; pero ignorando aquellos naturales que no son abundantes.

Sin embargo, esta función está escribiendo los números abundantes que va encontrando, lo cual podría ser no deseable en ciertos contextos. Para evitar este efecto colateral, acudimos al concepto de arreglo, que es una variable que puede alojar más de una valor a la vez bajo el mismo nombre,

def abundantes(t):

# naturales abundante menores que t > 0

n = 1 # natural a = [] # abundantes while n < t: if abundante(n): a.append(n) n = n + 1 return a

Ahora a se crea como un arreglo vacío, y en el ciclo, cada vez que el valor de n corresponde a un número abundante, se añade a a. Al abandonar el ciclo en a están los abundantes hallados. Para verificarlo, se colocan las funciones abundante() y abundantes() (versión con arreglo) , en ese orden y

escribiendo debajo, por ejemplo, abundantes(40). Se obtiene: [12, 18, 20, 24, 30, 36], que son los abundantes menores que 40. Pero un arreglo no tiene que ser dinámico,como en este caso, que se inicia nulo y se le van añadiendo valores sobre la marcha, sino que puede ser de un tamaño

predeterminado, iniciando cada posición con un valor fijo deseado, como a = [0 for i in range(100)], o dando a cada posición un valor distinto, como p = [2,3,5,7,11]. La primera posición en un arreglo es siempre la 0.

Los arreglos nos permiten generalizar las variables que alojan un único valor a la vez (llamadas escalares) y evitar el efecto

colateral de que una función escriba valores no deseados, por ejemplo. Tienen otros usos bien interesantes, como veremos más