Pseudocódigo - 1. Introducción

Uno de las mayores dificultades con las que se encuentran los hispanoparlantes que empiezan a programar es el idioma. Por una parte, la mayoría de lenguajes de programación se basan en el inglés, por lo que un estudiante de habla hispana tiene que aprender que "write" o "print" son las palabras equivalentes a "escribir". Además, la mayoría de lenguajes tienen órdenes que realmente son abreviaturas de una o varias palabras inglesas, de modo que el aprendiz tiene que entender o memorizar palabras como "printf" o "writeln" incluso para realizar las tareas más sencillas. Para colmo, la mayoría de entornos de programación están también en inglés (menús, mensajes de error y aviso, etc). Por eso, una herramienta habitual para ayudar a los que empiezan es el "Pseudocódigo", algo así como un falso lenguaje de programación en español, que permite asimilar con más facilidad las ideas básicas. El pseudocódigo soluciona el primer problema: no hace falta aprender otros idiomas para entender los conceptos básicos. Pero "históricamente" no solucionaba el problema del "entorno de programación": no existían entornos para programar en pseudocódigo, así que típicamente ha sido una herramienta para usar "con lapiz y papel". Algunas universidades han creado sus propios "intérpretes de pseudocódigo", para ayudar a los alumnos de primer curso a crear los programas "pensando en español", pero permitiéndoles además probar esos programas desde un entorno "casi real". En cuanto a estos "intérpretes de pseudocódigo", que permiten teclear nuestro programa y ver cual sería el resultado, hay uno que me parece especialmente bueno: PSEINT, que además realza con colores la sintaxis de nuestros programas para ayudar a detectar errores, tiene autocompletado para permitir ganar tiempo, está disponible para Windows y Linux, es gratuito (1), etc. Éste es el que usaremos en este curso introductorio. Eso sí, no existe un estándar claro en cuanto a pseudocódigo, puede que la sintaxis que empleen en tu universidad o centro de estudios sea ligeramente diferente a la que veremos aquí. Aun así, esperamos poder ayudarte a coger con facilidad las nociones básicas. (1) PSEINT realmente es "de código abierto": cualquiera puede ver cómo está creado, de forma que incluso si su autor perdiera el interés por el proyecto, otras personas podrían retomarlo, lo que le garantiza una vida mucho mayor. PSEINT se puede descargar desde http://pseint.sourceforge.net/

¿Y si me atrevo con el inglés?

PseInt, a pesar de ser una herramienta útil, es muy limitada. De hecho, en 2010 parece estar abandonado por su autor original, quien ni siquiera responde a los mensajes, por lo que es de suponer

que sea relativamente difícil incluso que otro programador tome el proyecto en su lugar para solucionar alguno de los problemas que tiene o para añadirle más posibilidades.

Si no te asusta el inglés, bien porque lo conozcas o bien porque estés dispuesto a aprender 30 palabras, estás de suerte: el pseudocódigo en inglés se parece a varios lenguajes de programación, así que podrías aprender los conceptos básicos usando "entornos reales".

Posiblemente Pascal sería el lenguaje que más se parecería al pseudocódigo, y por eso durante mucho tiempo se ha considerado un lenguaje muy adecuado para aprender. Pero como ya hay muchos cursos de Pascal, vamos a optar por otra alternativa más moderna: el lenguaje Python, bien diseñado y que está disponible para muchos sistemas operativos. Por eso, veremos también cómo dar los pasos básicos usando Python.

Para descargar Python: en muchos sistemas, como Linux, no es necesario: forma parte del sistema básico; pero si, como la mayoría, usas Windows, Python no está preinstalado en tu sistema, tendrías que descargarlo (gratuitamente, claro) desde http://www.python.org/download/

2-Toma de contacto

Vamos a empezar por lo más sencillo: escribir en pantalla.

Si queremos crear un programa que escriba algo en pantalla, usaremos la orden ESCRIBIR. A continuación de esta palabras, entre comillas, escribiremos el texto que queremos que aparezca en pantalla.

Escribir "Hola"

Crear un programa que escriba Hola en la pantalla usando PSEINT también es igual de simple. En el caso de PSEINT, cada programa debe encerrarse entre las palabras "Proceso" (para indicar dónde comienza) y "FinProceso" (para señalar dónde termina). Pero eso no añade ninguna dificultad, porque cuando entramos a PSEINT, ese esqueleto de programa ya aparece escrito:

Nuestro programa debería tener un nombre: se nos propone que se llame "sin_titulo", pero mejor podemos hacer clic en esa palabra y escribir otro título que recuerde mejor lo que va a hacer nuestro programa. De momento, bastará con "Ejemplo001", por eso de que es nuestro primer ejemplo.

Después, bajamos a la siguiente línea y comenzamos a teclear la palabra "Escribir". Veremos que PSEINT se da cuenta, y nos recuerda cómo era la orden exacta, incluso cuando apenas llevamos unas pocas letras :

Cuando terminamos la palabra "Escribir", se nos propone que escribamos una o más expresiones, separadas por comas; en nuestro caso, será la palabra "Hola", entre comillas:

Nuestro programa está completo: podemos comprobar su funcionamiento pulsando el botón que recuerda al "Play" de los equipos de música:

Y entonces aparecerá una nueva ventana que nos muestra el resultado de nuestro programa (por supuesto, se trata de la palabra Hola):

Por supuesto, no sólo podemos escribir textos prefijados. Podemos usar nuestro ordenador como calculadora, que nos muestre el resultado de una operación aritmética:

Proceso Ejemplo002 Escribir 20+30 FinProceso

Y como despedida por hoy, vamos a hacer algo un poco más complejo: vamos a sumar dos números que no estén prefijados dentro del programa, sino que deberá teclear el usuario. Para eso, usaremos la orden "Leer", que nos permite leer lo que el usuario teclee y dejarlo guardado para utilizarlo después. Debemos dar un nombre temporal a estos datos que leemos del usuario. Parece razonable que el primer número que teclee el usuario se llame algo como "primerNumero", y el segundo sea algo como "segundoNumero". El resultado que queremos obtener será la suma de ese primer número y ese segundo número, así que nuestro programa podría quedar así:

Proceso Ejemplo003 Escribir "Dime un numero" Leer primerNumero Escribir "Dime otro numero" Leer segundoNumero Escribir "Su suma es ", primerNumero + segundoNumero

FinProceso

En la próxima entrega puntualizaremos un poco más lo que hemos hecho en este último programa y veremos cómo comprobar condiciones. Eso será dentro de una semana...

¿Y en Python?

En primer lugar, veamos la instalación del entorno. Es poco más que descargarlo de Internet y hacer clic en los botones de "Siguiente", pero vamos a verlo con detalle:

Para descargar Python basta con entrar a su página oficial (python.org), dentro del apartado de Descargas (download):

Elegimos la versión que queremos descargar. En el momento de escribir este texto, las últimas son la 3.1.2 (dentro de la "gama nueva") y la 2.7 (dentro de la "serie antigua"). Existen dos versiones paralelas porque la "serie antigua" es ligeramente incompatible con la nueva. Como nosotros no tenemos que trabajar con programas antiguos con Python, no tenemos por qué escoger la versión "antigua" y podemos optar por la versión 3, la nueva.

Aun así, las capturas que incluyo a continuación corresponden a la versión 2.7, para Windows. Descargamos el "Windows Installer" (instalador de Windows), que tendrá cerca de 15 Mb de tamaño:

Cuando lo recibamos, hacemos doble clic y Windows nos avisará del posible riesgo de seguridad:

Como sabemos que no es peligroso, decimos que Sí lo queremos "Ejecutar" y se nos preguntará si es sólo para nosotros o para todos los usuarios con los que compartamos nuestro ordenador:

Y luego la carpeta en la que queremos que se instale:

Se nos preguntará qué opciones queremos instalar (basta con aceptar lo que se nos propone):

Y entonces comenzará la instalación en sí:

que debería terminar sin problemas poco después:

Aparecerá un nuevo "grupo de programas" en nuestro Menú de Inicio de Windows, y en ese grupo de programas aparece IDLE, que es el editor de Python para Windows:

Y desde IDLE podemos crear y probar nuestros programas (pero no tengas prisa en entender todo lo que aparece en esta captura, lo iremos viendo poco a poco... ;-D )

Vamos a ver cómo quedarían nuestros primeros programas en Python:

Para escribir, se usa la orden "print", a la que se le indica entre paréntesis lo que queremos escribir. Si es un texto puro, deberá estar entre comillas:

print ("Hola")

(Nota: en versiones antiguas de Python no era necesario usar paréntesis en la orden "print"; en Python 3 y posteriores sí lo es)

En cuanto pulsemos "Intro", se muestra directamente el resultado de nuestra orden. Al contrario que en PseInt, no es necesario indicar el principio y el final del programa (o proceso). De igual modo, podemos hacer operaciones matemáticas. Para escribir, se puede usar la misma orden "print" (aunque en Python existen formas aún más rápidas), pero sin comillas:

print (20+30)

Y si queremos que sea el usuario el que introduzca los datos, usaremos la orden "input". De modo que el programa que pide dos datos al usuario y muestra su resultado podría ser:

print ("Dime un numero") primerNumero = input() print ("Dime otro numero") segundoNumero = input() print ("Su suma es ") print (primerNumero + segundoNumero)

Puede que en versiones "modernas" de Python, 3.x o superiores, si introducimos los números 3 y 5 se nos diga que su suma es 35. Esto se debe a que está tomando ese 3 y ese 5 como cadenas de texto, y el símbolo de suma (+) se puede utilizar también para unir (concatenar) varias cadenas en una. La forma de evitarlo es decirle que tome esos datos como números enteros antes de sumar. Para eso, usaremos la palabra "int", e indicaremos entre paréntesis lo que queremos que se trate como un número entero. Así, la versión correcta en Python 3 del programa anterior (y que también funcionará correctamente en las últimas versiones 2.x) sería:

print ("Dime un numero")

primerNumero = int( input() ) print ("Dime otro numero") segundoNumero = int( input() ) print ("Su suma es ") print (primerNumero + segundoNumero)

En programas un poco más largos, como éste, quizá no nos interese teclearlo de modo interactivo, obteniendo inmediatamente la respuesta a cada orden, sino que puede ser mejor teclear todo el programa y después ponerlo en funcionamiento. Eso también es sencillo de hacer:

Creamos una ventana nueva en el editor, entrando al menú "File" y escogiendo la opción "New window":

En esta ventana tecleamos nuestro fuente:

Para ponerlo en funcionamiento, entramos al menú "Run" y escogemos la opción "Run Module":

Si todavía no habíamos guardado en disco nuestro programa, se nos pedirá que lo hagamos:

Y entonces se pondrá en marcha el programa completo:

Como curiosidad poco importante, en Python se pueden fundir en un solo paso las acciones de avisar al usuario de lo que queremos y leer él dato que dicho usuario introduzca: la orden "input" permite indicar el texto de aviso, de modo que nuestro programa podría ser simplemente así, para Python 2.x:

primerNumero = input ( "Dime un numero " ) segundoNumero = input ( "Dime otro numero " ) print ("Su suma es ") print (primerNumero + segundoNumero)

y para Python 3

primerNumero = int (input ( "Dime un numero " )) segundoNumero = int (input ( "Dime otro numero " )) print ("Su suma es ") print ( primerNumero + segundoNumero )

De ahora en adelante usaremos esa última sintaxis (incluyendo "int") en los ejemplos, para que funcionen correctamente en cualquier versión reciente de Python.

Pseudocódigo. 3 - Más sobre variables

Nuestro último programa pedía dos números al usuario y mostraba su suma, así

Proceso Ejemplo003 Escribir "Dime un numero" Leer primerNumero Escribir "Dime otro numero" Leer segundoNumero Escribir "Su suma es ", primerNumero + segundoNumero FinProceso

Esas dos palabras, "primerNumero" y "segundoNumero" representan a números que no tienen un valor prefijado. Eso es lo que llamaremos "variables". En las variantes de pseudocódigo que emplean en muchas universidades y centros de estudio (ya habíamos avisado de que no existe ningún estándar totalmente asentado) debemos "declarar las variables" antes de usarlas: decir qué tipo de dato es el que querremos representar con ese nombre. En nuestro ejemplo anterior se trataba de dos números enteros, así que el programa sería:

Proceso Ejemplo003b Variable primerNumero: Entero Variable segundoNumero: Entero

Escribir "Dime un numero" Leer primerNumero Escribir "Dime otro numero" Leer segundoNumero Escribir "Su suma es ", primerNumero + segundoNumero FinProceso

Esto se debe a que en la mayoría de lenguajes de programación "reales" es necesario detallar qué tipo de datos querremos guardar en cada variable, para que la herramienta de programación sepa exactamente qué cantidad de memoria será necesaria para guardar ese dato.

Insisto: no es el caso de PSEINT; con esta herramienta no es necesario declarar las variables, el propio entorno presupone de qué estamos hablando.

Por otra parte, no siempre querremos que el valor de una variable lo introduzca el usuario. Habrá veces que seamos nosotros mismos los que demos el valor inicial a una variable desde nuestro programa, bien para usarlo en una serie de cálculos posteriores, o bien por legibilidad (es más fácil entender algo como "longitudCircunferencia = 2 * pi * radio" que algo como "longitudCircunferencia = 6.28 * radio".

La forma de dar un valor a una variable es con la secuencia de símbolos "<-":

radio <- 3 longitudCircunferencia <- 2 * pi * radio

(esos símbolos representan una flecha, para indicar que el valor 3 se va a guardar en el espacio de memoria reservado para la variable llamada "radio").

¿Y qué ocurre si usamos una variable sin haberle dado valor? Esto pasa a veces por despiste, si tecleamos mal el nombre de una variable, como en este fragmento de programa:

primerNumero <- 2 Escribir primerNmero

Si lees ese fragmento con cuidado, verás que el nombre de la variable que aparece en la segunda línea es incorrecto, falta la letra "u". ¿Qué sucede en ese caso? En algunos lenguajes (pocos, afortunadamente) se da por sentado que es una variable nueva, y se le da el valor 0; en el caso de PseInt, igual que en la mayoría de lenguajes actuales, obtendremos un mensaje de error que nos dirá que estamos usando una variable que no tenía valor.

En la próxima entrega veremos cómo comprobar condiciones...

¿Y en Python?

Se aplican las mismas ideas: se puede usar variables, y no hace falta "declararlas". Su valor lo puede introducir el usuario, si lo indicamos con la orden "input" (que vimos en el tema anterior) o lo podemos fijar desde programa usando el símbolo "=" (en vez de la flecha "<-"), así:

radio = 3

longitudCircunferencia = 2 * pi * radio

Al igual que en PseInt, si intentamos usar una variable que no tiene valor (porque no se lo hemos dado nosotros ni lo ha introducido el usuario), obtendremos un mensaje de error.

4 - Comprobando condiciones (1)

En casi cualquier secuencia de instrucciones para un ordenador, será vital poder comprobar si se cumple alguna condición. Una primera forma básica de comprobar condiciones es con la orden "SI". Su uso básico sería

Si condicion Entonces pasos_a_dar_si_es_verdadero Si No pasos_a_dar_si_es_falso FinSi

El bloque "Si No" es opcional: podemos optar por no indicar lo que queremos que se haga cuando no se cumpla la condición.

Para ayudarnos a planificar el comportamiento de una secuencia de instrucciones, se suele usar como ayuda los llamados "diagramas de flujo". En estos diagramas, una condición se representa como un rombo, del que salen dos flechas: una para la secuencia de acciones a realizar si se cumple la condición y otra para cuando no se cumple:

Así, si en PSeInt hacemos clic en el icono de la parte derecha que representa la condición SI, aparece un esqueleto de programa casi completo, para que hagamos los cambios que nos interesen:

Sólo tenemos que escribir la condición que realmente nos interesa, y la serie de pasos a dar si se cumple y si no se cumple, de modo que nuestro programa podría quedar así:

Proceso Ejemplo004 Escribir "Dime un numero" Leer primerNumero Escribir "Dime otro numero" Leer segundoNumero Si primerNumero > segundoNumero Entonces Escribir "El primero es mayor" Sino Escribir "El segundo es mayor" FinSi FinProceso

Su resultado sería éste:

En ese ejemplo hemos comparado si un valor es mayor que el otro (>). Los operadores de comparación que tenemos disponibles son:

Operador relacional Significado Ejemplo

> Mayor que 3>2

< Menor que 'ABC'<'abc'

= Igual que 4=3

<= Menor o igual que 'a'<='b'

>= Mayor o igual que 4>=5

También podemos comprobar varias condiciones a la vez, para hacer construcciones como: "si a es mayor que b y b es mayor que c", o como "si a es igual a 1 o b es igual a 1". Los operadores lógicos que de los que disponemos son:

Operador lógico Significado Ejemplo

& ó Y Conjunción (y). (7>4) & (2=1) //falso

| ó O Disyunción (o). (1=1 | 2=1) //verdadero

~ ó NO Negación (no). ~(2<5) //falso

¿Y en Python?

La orden "si" se traduce como "if", y la orden "si no" se traduce como "else". Ambas deben terminar con el símbolo de "dos puntos" (:). Las órdenes a realizar si se cumple la condición, o bien en caso de que no se cumpla, se DEBEN escribir un poco más a la derecha que la orden que las precede (pero no es para que sea más legible, como hicimos con PseInt, sino por requisito del lenguaje):

primerNumero = int(input( "Dime un numero " )) segundoNumero = int(input( "Dime otro numero " )) if primerNumero > segundoNumero: print( "El primero es mayor" ) else:

print )"El segundo es mayor" )

Los operadores que podemos usar para comparar no son exactamente los mismos que en PseInt:

Operador relacional Significado Ejemplo

> Mayor que 3 > 2

< Menor que 2 < 3

= Igual que 3 == 3

= Distinto de 4 != 3

<= Menor o igual que 7 <= 6

>= Mayor o igual que 4 >= 5

Y las condiciones se pueden enlazar usando "y" (que se escribirá en inglés, "and"), "o" (que será "or") o "no" ("not").

Ejercicio propuesto: un programa que pida al usuario 3 números y diga cual es el mayor de los tres.

En la próxima entrega veremos más formas de comprobar condiciones...

5 - Comprobando condiciones (2)

Es frecuente tener que comprobar más de una condición a la vez, o bien varias condiciones consecutivas. En concreto, un caso espercialmente habitual es el de que una variable pueda tomar distintos. Por ejemplo, ciertas notas numéricas tienen "nombres" en español: un 5 es un aprobado, un 9 y un 10 son sobresaliente, etc. Si queremos hacer un programa que convierta de la nota numérica a su equivalente escrito, podríamos emplear varias órdenes IF, una tras la otra. Pero en muchos lenguajes de

programación (y por tanto, también en muchas variantes de pseudocódigo) existe una alternativa más compacta y más legible: la orden "SEGUN". Esta órden permite hacer unas cosas u otras según el valor que tome una variable. Su uso sería así:

Segun variable Hacer valor1: pasos_a_dar_si_es_el_valor1 valor2: pasos_a_dar_si_es_el_valor2 valor3: pasos_a_dar_si_es_el_valor3 De Otro Modo: pasos_a_dar_si_es_otro_valor FinSegun

El bloque "De Otro Modo" es opcional: si detallamos todos los valores posibles, no sería necesario utilizarlo.

El número de valores que podemos probar es indefinido: no tiene por qué ser 3, sino que pueden ser menos casos o muchos más.

Según la variante de pseudocódigo (o el lenguaje de programación) que empleemos, puede haber restricciones en el tipo de datos que es aceptable. Por ejemplo, en el caso de PseInt, la variable tiene que tener un valor numérico, no puede ser un texto.

Al igual que ocurría con la orden SI, existe un símbolo que podemos usar en los diagramas de flujo para ayudarmos a planificar nuestro programa (aunqe este símbolo está menos extendido que el de SI):

Así, si en PseInt hacemos clic en el icono de la parte derecha que representa la condición SI, aparece un esqueleto de programa casi completo, para que hagamos los cambios que nos interesen:

Sólo tenemos que escribir la condición que realmente nos interesa, y la serie de pasos a dar si se cumple y si no se cumple, de modo que nuestro programa podría quedar así:

Proceso EjemploCasos Escribir "Introduzca la nota";

Leer nota; Segun nota Hacer 10: Escribir "Ha obtenido un sobresaliente alto"; 9: Escribir "Ha obtenido un sobresaliente bajo"; 8: Escribir "Ha obtenido un notable alto"; 7: Escribir "Ha obtenido un notable bajo"; 6: Escribir "Ha obtenido un aprobado alto"; 5: Escribir "Ha obtenido un aprobado"; De Otro Modo: Escribir "Ha suspendido"; FinSegun FinProceso

Su resultado sería éste:

Pero no siempre habrá que comprobar condiciones una única vez. Es muy frecuente que haya que hacerlo de forma repetitiva. Por ejemplo, "pedir una contraseña al usuario hasta que sea la correcta", o aún más cercano al mundo real, "pedir una contraseña al usuario hasta que sea la correcta o agote sus intentos". De eso hablaremos en la próxima entrega.

¿Y en Python?

La orden "según" se suele traducir como la palabra inglesa "case" o como "switch", según el lenguaje de programación que se utilice. Pero siendo estrictos, no es una orden necesaria: se podría imitar usando varias órdenes "si".

Esa es la aproximación que usa Python: no existe orden "según", pero se puede imitar con varias ordenes "if...else" encadenadas. Eso tiene un problema: en Python, cada nuevo bloque "if" debería aparecer tabulado un poco más a la derecha que el anterior, por lo que nuestro programa acabaría pareciendo "una escalera", y resultando difícil de leer. Por eso, tenemos una orden "elif", como abreviatura de "else if", que no es necesario tabular.

Así, nuestro programa capaz de convertir de nota numérica a texto en Python quedaría de la siguiente forma:

nota = int(input("Introduzca la nota "))

if nota == 10: print ("Ha obtenido un sobresaliente alto") elif nota == 9: print ("Ha obtenido un sobresaliente bajo") elif nota == 8: print ("Ha obtenido un notable alto") elif nota == 7: print ("Ha obtenido un notable bajo") elif nota == 6: print ("Ha obtenido un aprobado alto") elif nota == 5: print ("Ha obtenido un aprobado")

else: print ("Ha suspendido")

6 - Condiciones repetitivas

Habitualmente, una condición se deberá comprobar más de una vez. Por ejemplo, una condición de error puede repetirse: el usuario que introduce mal una contraseña por primera vez puede equivocarse en una segunda ocasión.

Por eso, igual que cualquier lenguaje de programación tiene una orden "si", la gran mayoría de ellos tendrá una orden "mientras", que permite que un fragmento de un programa se repita mientras una cierta condición se siga cumpliendo (por ejemplo, mientras la contraseña que teclee el usuario sea incorrecta, el usuario deberá volver a introducirla).

También existe un símbolo habitual en los diagramas de flujo para representar este tipo de condiciones repetitivas, en las que si se cumple la condición, se realizan una serie de acciones y se vuelve a comprobar la condición, y así sucesivamente hasta que la condicion no se cumpla:

Y en el caso de PseInt, ese icono generaría un esqueleto de programa como éste:

Por ejemplo, un programa capaz de sumar muchos números, todos los que el usuario quisiera, y en el que hubiera que escribir "0" para indicar que queremos terminar, podría ser así:

Proceso Mientras01 Escribir "Dime un numero"; Leer x; suma <- 0; Mientras x <> 0 Hacer suma <- suma + x;

Escribir "Hasta ahora, la suma es ", suma; Escribir "Dime otro numero"; Leer x; FinMientras Escribir "Terminado"; FinProceso

Y su ejecución mostraría algo como:

Hay más formas de comprobar condiciones repetitivas. Pronto las veremos...

¿Y en Python?

Sencillo: basta con saber que "mientras" se traduce a inglés como "while", y recordar que no existirá nada equivalente al "FinMientras", sino que todo el bloque que se repita deberá estar tabulado un poco más a la derecha, así:

print ("Dime un numero") x = int( input ( ) ) suma = 0 while x != 0: suma = suma + x print ("Hasta ahora, la suma es ") print (suma) print ("Dime otro número") x = int( input ( ) ) print ("Terminado")

El resultado sería:

Dime un numero 4 Hasta ahora, la suma es 4 Dime otro numero 5 Hasta ahora, la suma es 9 Dime otro numero 7

Hasta ahora, la suma es 16 Dime otro numero 0 Terminado

Pero esto no es exactamente lo mismo que obtenemos con el programa en PseInt, porque Python avanza de línea tras cada orden "print". Si queremos que se escriban dos cosas en la misma línea, como en "Hasta ahora, la suma es 16", lo podemos hacer indicando que queremos usar un formato especial en el texto.

Para dar este formato especial haremos lo siguiente: dentro del texto indicaremos con llaves { } la posición en la que queremos que aparezca un dato adicional, y después usaremos ".format" y detallaremos entre paréntesis el dato que queremos que aparezca en esa posición. Quedaría así:

print ("Dime un numero") x = int( input ( ) ) suma = 0 while x != 0: suma = suma + x print ("Hasta ahora, la suma es {}".format(suma) ) print ("Dime otro numero") x = int( input ( ) ) print ("Terminado")

Ahora el resultado sería:

Dime un numero 4 Hasta ahora, la suma es 4 Dime otro numero 5 Hasta ahora, la suma es 9 Dime otro numero 7

Hasta ahora, la suma es 16 Dime otro numero 0 Terminado

7 - Condiciones repetitivas (2)

Es también muy frecuente que un bloque de programa que quizá se repita, deba ejecutarse al menos una vez. Por ejemplo, si queremos pedir un dato al usuario, quizá exista algún error y haya que insistir, pero al menos deberemos pedírselo una primera vez.

En estos casos, la estructura "mientras" no es la más adecuada: no podemos comprobar la condición al principio, sino después de haber pedir el valor. En estos casos (que son muy frecuentes), sería más razonable usar otra estructura de programación en la que la condición se compruebe después de dar ciertos pasos. Esa estructura es "repetir... hasta":

Su representación en un diagrama de flujo sería:

Y en el caso de PseInt, ese icono generaría un esqueleto de programa como éste:

Por ejemplo, un programa que pida al usuario una clave de acceso, y que no le permita seguir hasta que la introduzca correctamente, se podría hacer así:

Proceso Repetir01 Repetir Escribir "Dime tu clave de acceso"; Leer clave; Si clave <> 1234 Entonces Escribir "Clave incorrecta"; FinSi Hasta Que clave=1234 Escribir "Bienvenido!"; FinProceso

Cuyo resultado sería:

Queda otra forma de repetir fragmentos de programa. Pronto estaremos con ella...

¿Y en Python?

Si traducimos "repetir" como "repeat" y "hasta que" como "until", ya tenemos la construcción que se usa en algunos lenguajes de programación, como Pascal. En otros, como C y sus derivados (C++, Java, C#, PHP...) se usa "do...while" (hacer...mientras) para comprobar la comprobación al final. Nuevamente, no es el caso de Python: no tenemos ninguna construcción que nos permita comprobar la condición al final, así que deberíamos reescribir el program ligeramente, típicamente dando una primera pasada antes de la zona repetitiva, así:

print ("Dime tu clave de acceso: ") clave = int(input()) while clave != 1234: clave = int(input( "Clave incorrecta. Vuelve a introducir tu clave: " )) print ("Bienvenido!")

El resultado sería:

Dime tu clave de acceso: 23 Clave incorrecta. Vuelve a introducir tu clave: 234 Clave incorrecta. Vuelve a introducir tu clave: 1234 Bienvenido!

Si queremos intentar reescribirlo de una forma un poco más parecida al original en PseInt, podemos hacer que no se compruebe la condición al principio (o incluso nunca), sino que se interrumpa "desde dentro" con la orden "break" (romper), así:

while True:

clave = int(input("Dime tu clave de acceso: ")) if clave != 1234: print("Clave incorrecta") else: break print ("Bienvenido!")

Ahora el resultado sería:

Dime tu clave de acceso: 23 Clave incorrecta Dime tu clave de acceso: 234 Clave incorrecta Dime tu clave de acceso: 1234 Bienvenido!

8 - Repetir un cierto número de veces

En muchas ocasiones, no querremos que algo se repita mientras se cumpla una condición, sino un cierto número de veces. Por ejemplo, para escribir "Hola" 3 veces en pantalla existe una orden más cómoda que la orden "mientras" o la orden "repetir... hasta".

Es la orden "para", que hace que una variable tome una serie de valores que se van incrementando. Por ejemplo, una estructura como "para x con valores desde 2 hasta 4" haría que un bloque de programa se repitiera 3 veces. En la primera repetición, la variable "x" tendría el valor 2, en la segunda tendría el valor 3 y en la tercera tendría el valor 4. La sintaxis exacta en PseInt es: "Para variable <- valorInicial Hasta valorFinal Hacer"

Su representación en un diagrama de flujo sería:

Y en el caso de PseInt, ese icono generaría un esqueleto de programa como éste:

Por ejemplo, un programa que mostrara los números del 1 al 10, podría ser:

Proceso Para01 Para x <- 1 Hasta 10 Hacer Escribir x; FinPara FinProceso

Cuyo resultado sería:

Si no queremos avanzar de uno en uno, podemos indicar otro tamaño de "paso"::

Proceso Para02 Para x <- 10 Hasta 20 Con Paso 2 Hacer Escribir x; FinPara FinProceso

Y obtendríamos:

Hemos visto casi todas las construcciones que podremos encontrar en los lenguajes de programación convencionales (y, por tanto, al planificarlos usando pseudocódigo). En la próxima entrega veremos alguna otra posibilidad, como el manejo de matrices y las funciones matemáticas, para pasar después a algunos ejemplos completos.

¿Y en Python?

La palabra "para" se traduciría como "for", pero en vez de indicar "hasta" donde queremos llegar, le diremos qué "rango" (range) queremos recorrer. Por ejemplo, para ir del 1 al 10 usaríamos "range(1,11)", porque se comienza en el primer número que indiquemos en el rango (1), pero no se llega a alcanzar el último (11, luego se detiene en 10):

for x in range(1,11): print (x)

Mostrar los pares del 10 al 20 es casi igual de fácil: empezaremos en 10, terminaremos antes de llegar a 21, y añadimos un tercer dato que es el incremento que queremos en cada pasada (2), así

for x in range(10,21,2): print (x)

9 - Matrices.

Cuando necesitamos manejar muchos datos, generalmente hay soluciones más efectivas que tener muchas variables. Por ejemplo, si hay que guardar 100 números, suele ser más eficiente almacenar esos 100 datos "juntos", formando una "matriz", en vez de usar 100 variables distintas.

La palabra "matriz" es una traducción del inglés "array". Algunos autores lo traducen alternativamente como tabla, vector o incluso "arreglo".

Normalmente, en una matriz podremos acceder individualmente a cada uno de sus elementos usando corchetes: el primer dato sería algo como "dato[1]".

Vamos a ver un ejemplo que nos pida 6 datos y luego los muestre en orden contrario al que se han introducido:

Proceso MostrarAlReves Dimension datos[6] Para i <- 1 Hasta 6 Hacer Escribir "Dime el dato numero ", i

Leer datos[i] FinPara Escribir "Los datos al reves son: " Para i <- 6 Hasta 1 Con Paso -1 Hacer Escribir datos[i] FinPara FinProceso

Que mostraría algo como:

(Haremos ejemplos más avanzados como parte de los ejercicios)

¿Y en Python?

Para indicar que vamos a usar una matriz en Python, usaremos llaves: miMatriz = { } No es necesario indicar tamaño. Como se empieza a numerar desde 0, y no desde 1, guardaremos los datos accediendo a la posición "i-1", de este modo:

datos = { } for i in range(1,7): datos[i-1] = input( "Dime el dato numero {}: ".format(i) )

print ("Los datos al reves son: ") for i in range(6,0,-1): print ( datos[i-1] )

El resultado sería:

Dime el dato numero 1: 1

Dime el dato numero 2: 3 Dime el dato numero 3: 5 Dime el dato numero 4: 7

Dime el dato numero 5: 9 Dime el dato numero 6: 11 Los datos al reves son: 11 9 7 5

3 1

Como curiosidad, también se puede declarar el array indicando sus valores iniciales entre corchetes, así:

datos = [0,0,0,0,0,0] for i in range(1,7): datos[i-1] = input( "Dime el dato numero {}: ".format(i) ) print ("Los datos al reves son: ")

for i in range(6,0,-1): print ( datos[i-1] )

10 - Funciones matemáticas. Comentarios.

Casi cualquier lenguaje de programación tiene incorporadas ciertas funciones matemáticas, de modo que nos permita calcular raíces cuadradas, logaritmos, senos y cosenos, etc.

Lo mismo ocurre en muchas variantes de pseudocódigo. Por ejemplo, PseInt incluye las siguientes funciones matemáticas:

Función Significado

RC(X) Raíz Cuadrada de X

ABS(X) Valor Absoluto de X

LN(X) Logaritmo Natural de X

EXP(X) Función Exponencial de X

SEN(X) Seno de X

COS(X) Coseno de X

TAN(X) Tangente de X

ASEN(X) Arco seno de X

ACOS(X) Arco coseno de X

ATAN(X) Arco tangente de X

TRUNC(X) Parte entera de X

REDON(X) Entero más cercano a X

AZAR(X) Entero aleatorio entre 0 y x-1

(Si no sabes qué hace alguna de estas funciones, no te preocupes mucho, es señal de que hasta ahora no la has necesitado... ;-) Las más importantes de ellas las probaremos directamente como parte de los ejercicios)

En cuanto a los comentarios... casi cualquier lenguaje de programación permite incluir aclaraciones, que nos ayuden a explicar la lógica del programa o cualquier detalle que no sea evidente. En el caso de PseInt, cualquier línea que comience con una doble barra (//) se considerará un comentario y no se tendrá en cuenta en el momento de analizar el código:

// Ejemplo de comentario en un fuente de PseInt

¿Y en Python?

Existen básicamente las mismas funciones (y alguna más), pero con nombres en inglés, claro. Para usarlas antes hay que "importarlas" desde la librería de matemáticas, como se verá en el siguiente ejemplo. Las funciones equivalentes a las anteriores son:

Función Significado

math.sqrt(X) Raíz Cuadrada de X

math.fabs(X) Valor Absoluto de X

math.log(X) Logaritmo Natural de X

math.exp(X) Función Exponencial de X

math.sin(X) Seno de X

math.cos(X) Coseno de X

math.tan(X) Tangente de X

math.asin(X) Arco seno de X

math.acos(X) Arco coseno de X

math.atan(X) Arco tangente de X

Pero también hay otras. Por ejemplo, "math.pow(x,y)" calcula el resultado de elevar un número a otro, "math.degrees(x)" convierte de radianes a grados y "math.radians(x)" de grados a radianes.

Los números al azar no son parte de la biblioteca "math", sino de "random": random.random() devuelve un número real entre 0 y 1, mientras que random.randint(1, 10) da un número entero entre 1 y 10 (ambos incluidos).

Un ejemplo de uso de funciones matemáticas sería

from math import sqrt valor = int(input( "Dime un numero: " )) print ( "Su raiz cuadrada es {}".format( sqrt(valor) ) )

11 - Ejercicios resueltos

a) Enunciados

1.- Crear un algoritmo que escriba "Hola" cinco veces.

2.- Crear un algoritmo que pida al usuario un número y le diga si es positivo, negativo o cero.

3.- Crear un algoritmo que pida al usuario 5 datos y muestre su suma.

4.- Crear un algoritmo que calcule la raíz cuadrada del número que introduzca el usuario. Si se introduce un número negativo, debe mostrar un mensaje de error y volver a pedirlo (tantas veces como sea necesario).

5.- Crear un algoritmo que pida al usuario un número y un símbolo, y dibuje un cuadrado usando ese símbolo. El cuadrado tendrá el tamaño que ha indicado el usuario. Por ejemplo, si el usuario introduce 4 como tamaño y * como símbolo, deberá escribirse algo como:

**** **** **** ****

b) Ejemplos de soluciones con PseInt

1.- Crear un algoritmo que escriba "Hola" cinco veces.

// 1.- Crear un algoritmo que escriba "Hola" cinco veces. Proceso Resuelto01 Para x <- 1 Hasta 5 Hacer Escribir "Hola"; FinPara FinProceso

2.- Crear un algoritmo que pida al usuario un número y le diga si es positivo, negativo o cero.

// 2.- Crear un algoritmo que pida al usuario un numero y le diga si es positivo, negativo o cero. Proceso Resuelto02

Escribir "Dime un numero"; Leer x; Si x > 0 Entonces Escribir "Es positivo"; Sino Si x < 0 Entonces Escribir "Es negativo"; Sino Escribir "Es cero"; FinSi FinSi FinProceso

3.- Crear un algoritmo que pida al usuario 5 datos y muestre su suma.

// 3.- Crear un algoritmo que pida al usuario 5 datos y muestre su suma. // Forma (a), sin usar matrices Proceso Resuelto03 suma <- 0 Para x <- 1 Hasta 5 Hacer

Escribir "Dime un dato"; Leer x; suma <- suma + x; FinPara Escribir "Su suma es ", suma; FinProceso

o de forma alternativa, usando matrices:

// 3.- Crear un algoritmo que pida al usuario 5 datos y muestre su suma. // Forma (b), usando matrices

Proceso Resuelto03 Dimension dato[5] Para x <- 1 Hasta 5 Hacer Escribir "Dime un dato"; Leer dato[x]; FinPara suma <- 0 Para x <- 1 Hasta 5 Hacer suma <- suma + dato[x]; FinPara Escribir "Su suma es ", suma; FinProceso

4.- Crear un algoritmo que calcule la raíz cuadrada del número que introduzca el usuario. Si se introduce un número negativo, debe mostrar un mensaje de error y volver a pedirlo (tantas veces como sea necesario).

// 4.- Crear un algoritmo que calcule la raíz cuadrada del número // que introduzca el usuario. Si se introduce un número negativo, // debe mostrar un mensaje de error y volver a pedirlo // (tantas veces como sea necesario). Proceso Resuelto04 Repetir Escribir "Dime un numero"; Leer x; Si x < 0 Entonces Escribir "No puede ser negativo";

FinSi Hasta Que x >= 0 Escribir "Su raiz es ", rc(x); FinProceso

5.- Crear un algoritmo que pida al usuario un número y un símbolo, y dibuje un cuadrado usando ese símbolo. El cuadrado tendrá el tamaño que ha indicado el usuario.

(No funcionará correctamente en versiones de PseInt anteriores a agosto de 2011)

// 5.- Crear un algoritmo que pida al usuario un número y un símbolo, // y dibuje un cuadrado usando ese símbolo. El cuadrado tendrá el tamaño // que ha indicado el usuario. // No funciona con versiones de PseInt de antes de Agosto de 2011, // porque las versiones previas a la 20110801 no permiten escribir // sin avanzar de linea

Proceso Resuelto05 Escribir "Dime el lado"; Leer lado; Escribir "Dime el simbolo de relleno"; Leer simbolo; Para fila<-1 Hasta lado Hacer Para columna <- 1 Hasta lado Hacer Escribir Sin Saltar simbolo ; // Escribir sin bajar de línea FinPara Escribir ""; // Avance de línea tras cada fila FinPara FinProceso

c) Ejemplos de soluciones con Python

1.- Crear un algoritmo que escriba "Hola" cinco veces.

# 1.- Crear un algoritmo que escriba "Hola" cinco veces. for x in range(1,6): print("Hola")

2.- Crear un algoritmo que pida al usuario un número y le diga si es positivo, negativo o cero.

# 2.- Crear un algoritmo que pida al usuario un numero y le diga si es positivo, negativo o cero. x = input ("Dime un numero ") if x > 0 : print ("Es positivo") elif x < 0 : print ("Es negativo") else : print ("Es cero")

3.- Crear un algoritmo que pida al usuario 5 datos y muestre su suma.

# 3.- Crear un algoritmo que pida al usuario 5 datos y muestre su suma. # Forma (a), sin usar matrices

suma = 0 for x in range(1,6): x = input ("Dime un dato ") suma = suma + x print ("Su suma es") print (suma)

o de forma alternativa, usando matrices:

# 3.- Crear un algoritmo que pida al usuario 5 datos y muestre su suma. # Forma (b), usando matrices datos = { } for i in range(1,6): datos[i-1] = input ("Dime un dato ") suma = 0 for i in range(1,6): suma = suma + datos[i-1] print ("Su suma es") print (suma)

4.- Crear un algoritmo que calcule la raíz cuadrada del número que introduzca el usuario. Si se introduce un número negativo, debe mostrar un mensaje de error y volver a pedirlo (tantas veces como sea necesario).

# 4.- Crear un algoritmo que calcule la raiz cuadrada del numero # que introduzca el usuario. Si se introduce un numero negativo, # debe mostrar un mensaje de error y volver a pedirlo # (tantas veces como sea necesario). from math import sqrt while True: x = input( "Dime un numero: " ) if x < 0: print ( "No puede ser negativo" ) else:

print ( "Su raiz es {}".format( sqrt(x) ) ) break

5.- Crear un algoritmo que pida al usuario un número y un símbolo, y dibuje un cuadrado usando ese símbolo. El cuadrado tendrá el tamaño que ha indicado el usuario.

Esta es la forma más cercana a la de PseInt, con dos "for" anidados. Como el "símbolo" es texto, no podemos usar "input" para leerlo, o Python intentaría interpretarlo como número; en su lugar, usaremos "raw_input":

# 5.- Crear un algoritmo que pida al usuario un numero y un simbolo, # y dibuje un cuadrado usando ese simbolo. El cuadrado tendra el tamanyo # que ha indicado el usuario. # Forma "general" lado = input( "Dime el lado: " ) simbolo = raw_input( "Dime el simbolo de relleno: " )

for fila in range( 1 , lado+1 ): textoFila = '' for columna in range( 1 , lado+1 ): textoFila += simbolo print( textoFila )

Y esta es una forma alternativa más compacta, usando * para repetir una cadena de texto varias veces:

# 5.- Crear un algoritmo que pida al usuario un numero y un simbolo, # y dibuje un cuadrado usando ese simbolo. El cuadrado tendra el tamanyo # que ha indicado el usuario. # Forma compacta lado = input( "Dime el lado: " ) simbolo = raw_input( "Dime el simbolo de relleno: " ) for fila in range( 1 , lado+1 ): textoFila = simbolo * lado print( textoFila )

12 - Ejercicios propuestos

1.- Crear un algoritmo que pida al usuario 10 datos y muestre su promedio.

2.- Crear un algoritmo que calcule la raíz cuadrada del número que introduzca el usuario. Si se introduce un número negativo, debe mostrar un mensaje de error y volver a pedirlo (tantas veces como sea necesario).

3.- Crear un algoritmo que pida al usuario 3 datos y diga cual es el mayor de los tres.

4.- Crear un algoritmo que pida al usuario 5 datos, luego le pida un valor con el que comparar, y finalmente diga cuales de esos 5 datos son mayores que el valor de comparación.

5.- Crear un algoritmo que resuelva una ecuación de segundo grado del tipo ax2+bx+c=0. Las soluciones son x1 = (- b + raiz (b2 - 4ac)) / (2 a) , x2 = (- b - raiz (b2 - 4ac)) / (2 a)

6.- Crear un algoritmo que genere un número al azar entre el 1 y el 1000, y dé al usuario la oportunidad de acertarlo en 10 intentos. Tras cada intento se le dirá si ha acertado (y en ese caso terminará la ejecución), si se ha quedado corto o si se ha pasado.

7.- Crear un algoritmo que pida al usuario una cantidad no definida de datos y calcule su suma. Debe estar preparado para un máximo de 100 números, que pedirá de uno en uno. Cuando se introduzca un valor 0, mostrará la suma de todos los anteriores y terminará la ejecución.

8.- Crear un algoritmo que pida al usuario que introduzca una frase, y diga cuántas veces contiene la letra A (ya sea en mayúsculas o en minúsculas).

13 - Funciones de cadenas de texto

Desde octubre de 2012, PseInt incluye ciertas funciones de manejo de cadenas de texto que es habitual encontrar en casi cualquier lenguaje de programación.

Las dos más sencillas son las que permiten convertir un texto a mayúsculas y a minúsculas:

Proceso Cadenas01 Escribir "Dime tu nombre" Leer nombre Escribir "En mayúsculas quedaría:" Escribir Mayusculas(nombre)

Escribir "En minúsculas quedaría:" Escribir Minusculas(nombre) FinProceso

Para resolver problemas reales de computación, hay otras dos funciones que dan mucho más juego: una nos dicen la longitud de una cadena y otra permite extraer una subcadena, desde cierta posición inicial hasta cierta posición final:

Proceso Cadenas02 Escribir "Dime tu nombre" Leer texto Escribir "Con espacios quedaría:"

Para x <- 1 Hasta Longitud(texto) Hacer Escribir Sin Saltar Subcadena(texto, x, x) Escribir Sin Saltar " " FinPara Escribir "" FinProceso

(Si dejamos las opciones de PseInt sin modificar, las posiciones dentro de la cadena se empezarán a contar desde uno; ya sabemos, como vimos en el apartado sobre "Matrices", que en muchos otros lenguajes de programación se empieza a contar desde cero).

También tenemos la posibilidad de "concatenar" dos cadenas, para formar una nueva cadena a partir de esas dos seguidas. Así el quinto ejercicio resuelto se podría plantear también creando una Pero todavía no está tan bien como debería: siempre estamos escribiendo 20 guiones, aunque el texto sea más largo o más corto. En la mayoría de lenguajes de programación se puede indicar detalles adicionales ("parámetros") para que se puedan utilizar desde dentro de esa subrutina. Por ejemplo, en nuestro caso podríamos indicarle qué texto queremos escribir y qué longitud queremos que tenga la secuencia de guiones:

// Crear un algoritmo que pida al usuario un número y un símbolo, // y dibuje un cuadrado usando ese símbolo. El cuadrado tendrá el // tamaño que ha indicado el usuario. // Versión concatenando cadenas. // No funciona con versiones de PseInt de antes de Octubre de 2012 Proceso Resuelto05b Escribir "Dime el lado" Leer lado Escribir "Dime el simbolo de relleno" Leer simbolo filaDeSimbolos <- "" Para columna <- 1 Hasta lado Hacer filaDeSimbolos <- Concatenar( filaDeSimbolos, simbolo )

FinPara Para fila<-1 Hasta lado Hacer Escribir filaDeSimbolos FinPara FinProceso

Ejercicios propuestos en pseudocódigo

1. Crea un programa que pida su nombre al usuario y lo escriba al revés (de principio a fin) 2. Crea un programa que pida su nombre al usuario y lo escriba alternando letras mayúsculas y minúsculas

(por ejemplo, "Nacho" se mostraría como "NaChO" 3. Crea un programa que pida su nombre al usuario y diga cuántas vocales contiene

¿Y en Python?

Las manipulaciones básicas, como convertir a mayúsculas o minúsculas, son igual de simples como en PseInt: se añade ".upper()" o ".lower()" al texto que queremos modificar:

nombre = input( "Dime tu nombre: " ) print ( "En mayúsculas sería {}".format( nombre.upper() ) ) print ( "En minúsculas sería {}".format( nombre.lower() ) )

Extraer una letra de una cadena es como acceder a cualquier posición de una matriz o un vector: se indica la posición entre corchetes, como en "nombre[i]". Para una subcadena, basta indica la posición inicial y la final, separadas por un símbolo de dos puntos: "nombre[desde:hasta]". Hay que recordar que se empieza a contar desde cero y que se termina en la longitud ("len") menos uno:

nombre = input( "Dime tu nombre: " ) print ( "Con espacios sería" ) for i in range(0, len(nombre)): print ( nombre[i], end="" ) print ( " ", end="" )

Como se ve, en Python (versión 3 y posteriores) podemos escribir cosas en la misma línea, indicando un segundo detalle, que es que no queremos ningún símbolo al final de cada línea: end=""

Concatenar cadenas es muy fácil en Python: basta usar el símbolo de la suma (+):

nombre = "Juan" espacio = " " apellido = "Juanez" frase = nombre + espacio + apellido print ( frase )

Pero en Python se pueden hacer muchas más cosas con las cadenas de texto que con PseInt. Por ejemplo, usando la misma nomenclatura de corchetes, se pueden emplear posiciones negativas para indicar que queremos contar desde el final de la cadena, o dejar una posición en blanco para decir

"desde el principio" (si es la primera) o "hasta el final" (si es la segunda), o añadir un tercer dato para indicar de cuánto en cuánto hay que avanzar (y puede incluso ser un número negativo, para retroceder):

nombre = input( "Dime tu nombre: " ) print ( "Sus dos últimas letras son: ", end="" ) print ( nombre[-2:] ) print ( "Y a partir de la tercera: ", end="" ) print ( nombre[2:] )

print ( "Al revés sería: ", end="" ) print ( nombre[::-1] )

Ejercicios propuestos en Python

1. Crea un programa que pida su nombre al usuario y lo escriba alternando letras mayúsculas y minúsculas (por ejemplo, "Nacho" se mostraría como "NaChO"

2. Crea un programa que pida su nombre al usuario y diga cuántas vocales contiene

14 - Creación de funciones y procedimientos (subprocesos)

En muchos casos, nos encontraremos con tareas que tenemos que repetir varias veces en distintos puntos de nuestro programa. Si tecleamos varias veces el mismo fragmento de programa no sólo tardaremos más en escribir: además el programa final resultará menos legible, será más también será más fácil que cometamos algún error alguna de las veces que volvemos a teclear el fragmento repetitivo, o que decidamos hacer una modificación y olvidemos hacerla en alguno de los fragmentos. Por eso, conviene evitar que nuestro programa contenga código repetitivo. Una de las formas de evitarlo es usar "subrutinas", una posibilidad que permite casi cualquier lenguaje de programación, y que en ocasiones recibe el nombre de "procedimientos" o de "funciones" (a veces, con algún matiz que hace que esas palabras no sean realmente sinónimos).

PseInt permite definir "subrutinas" (o "funciones") dentro del pseudocódigo, desde la versión del 10 de octubre de 2012. En su caso, se llaman "subprocesos". Veamos un ejemplo de su uso:

Vamos a empezar por crear un subproceso (o "subrutina", o "procedimiento") que escriba 20 guiones, que podríamos utilizar para subrayar textos. Un programa completo que escribiera tres textos y los subrayara podría ser:

Proceso SubProcesos01 Escribir " Primer ejemplo" Para x <- 1 Hasta 20 Hacer

Escribir Sin Saltar "-" FinPara Escribir "" Escribir " Segundo ejemplo" Para x <- 1 Hasta 20 Hacer Escribir Sin Saltar "-" FinPara Escribir "" Escribir " Tercer ejemplo" Para x <- 1 Hasta 20 Hacer

Escribir Sin Saltar "-" FinPara Escribir "" FinProceso

Muy repetitivo. Sería un poco más elegante si lo reescribimos así:

Proceso SubProcesos02

Escribir " Primer ejemplo" Subrayar Escribir " Segundo ejemplo" Subrayar Escribir " Tercer ejemplo" Subrayar FinProceso Subproceso Subrayar Para x <- 1 Hasta 20 Hacer Escribir Sin Saltar "-" FinPara Escribir "" FinSubproceso

Mucho más legible. Pero todavía no está tan bien como debería: siempre estamos escribiendo 20 guiones, aunque el texto sea más largo o más corto. En la mayoría de lenguajes de programación se puede indicar detalles adicionales ("parámetros") para que se puedan utilizar desde dentro de esa subrutina. Por ejemplo, en nuestro caso podríamos indicarle qué texto queremos escribir y qué longitud queremos que tenga la secuencia de guiones:

Proceso SubProcesos03 EscribirSubrayado(" Primer ejemplo", 16) EscribirSubrayado(" Segundo ejemplo", 17) EscribirSubrayado(" Tercer ejemplo", 16) FinProceso Subproceso EscribirSubrayado(texto, cantidad) Escribir texto Para x <- 1 Hasta cantidad Hacer Escribir Sin Saltar "-" FinPara Escribir "" FinSubproceso

Aunque todavía es un poco redundante: en general, querremos escribir tantos guiones como letras tenga el texto, así que no será necesario indicar ese dato. Desde octubre de 2012, PseInt incluye ciertas funciones predefinidas para manejo de cadenas de texto; una de ellas es "Longitud", que nos indica la cantidad de letras que tiene un texto, de modo que nuestro programa se podría simplificar así:

Proceso SubProcesos04

EscribirSubrayado("Primer ejemplo") EscribirSubrayado("Segundo ejemplo") EscribirSubrayado("Tercer ejemplo") FinProceso Subproceso EscribirSubrayado(texto) Escribir texto

Para x <- 1 Hasta Longitud(texto) Hacer Escribir Sin Saltar "-" FinPara Escribir "" FinSubproceso

También podemos crear funciones que realicen ciertas operaciones aritméticas y devuelvan un resultado, como las funciones matemáticas que vimos en el tema 10. Se puede hacer con la misma palabra "subproceso" que hemos empleado hasta ahora, pero muchos lenguajes de programación distinguen entre un "procedimiento" o "subrutina", cuando se da una serie de pasos pero no se devuelve ningún valor, y una "función", cuando sí se devuelve un resultado, así que usaremos esta última nomenclatura. Se parece mucho a lo que hemos hecho hasta ahora, con la diferencia de que escogeremos un nombre para la variable que guardará el resultado, así:

Funcion resultado <- Maximo( n1, n2) Si n1 > n2 Entonces resultado <- n1 Sino resultado <- n2 FinSi FinFuncion Proceso Funciones01 Escribir "El máximo de 5 y 12 es:" Escribir Maximo(5,12); Escribir "El máximo de 25 y 12 es:" Escribir Maximo(25,12);

Finproceso

Este programa crea una función que calcula cuál es el mayor de los dos números que se le indican como parámetro, y la usa dos veces, para mostrar el máximo de dos valores prefijados.

No sólo pdemos devolver valores numéricos; también podemos devolver cadenas (como las funciones que vimos en el apartado 13) o "valores de verdad" (verdadero, falso). Por ejemplo, podemos crear una función que diga si un número es primo o no (lo vamos a hacer de la forma más simple pero también de la menos eficiente: aplicar la definición, probando a dividir entre todos los números que hay entre 1 y n; si hemos encontrado dos divisores -o menos, para el número uno-, entonces el número es primo):

SubProceso resultado <- Primo ( num ) cantidadDivisores <- 0 Para cont <- 1 Hasta num Hacer Si num % cont = 0 Entonces cantidadDivisores <- cantidadDivisores + 1 FinSi Fin Para Si cantidadDivisores <= 2 Entonces resultado <- verdadero Sino resultado <- falso

Fin Si Fin SubProceso Proceso PrimosDel1Al30 Para n <- 1 hasta 30 si Primo(n) Entonces Imprimir n

FinSi FinPara FinProceso

Hay más detalles que comentar sobre funciones, pero son un poco más avanzados, así que vamos a descansar un poco aquí de nuevos conceptos y a practicar lo que hemos visto...

Ejercicios propuestos en pseudocódigo

1. Crea un subproceso que reciba como parámetro un texto y lo escriba centrado en pantalla (suponiendo una anchura de 80 columnas)

2. Crea una función que reciba un número entero y devuelva la cantidad de divisores (por ejemplo, para el número 16, sus divisores son 1, 2, 4, 8, 16, luego la respuesta debería ser 5).

3. Crea un programa que pida dos número enteros al usuario y diga si alguno de ellos es múltiplo del otro. Crea una función EsMultiplo que te ayude a que el proceso principal sea legible.

¿Y en Python?

Los subprocesos o subrutinas se definen en Python con la palabra "def", deben tener paréntesis después del nombre (aunque estarán vacíos si no hay parámetros) y la primera línea debe terminar en "dos puntos", con todo su contenido tabulado hacia la derecha (igual que hacíamos con las condiciones y con los bucles):

def subrayar(): for i in range(0, 20): print( "-", end="" )

print() print ( " Primer ejemplo" ) subrayar() print ( " Segundo ejemplo" ) subrayar() print ( " Tercer ejemplo" ) subrayar()

Como se puede ver en este ejemplo, en Python hay que declarar las funciones antes de usarlas (en PseInt no es necesario):

Los parámetros, en caso de existir, se escribirán dentro del paréntesis, y separados por comas:

def escribirSubrayado(texto): print(texto)

for i in range(0, len(texto)): print( "-", end="" ) print() escribirSubrayado ( "Primer ejemplo" ) escribirSubrayado ( "Segundo ejemplo" ) escribirSubrayado ( "Tercer ejemplo" )

Si se trata de una función que devuelva valores, también se usará la palabra "def" para definirla, y los resultados se devolverán con la palabra "return":

def maximo(n1,n2): if n1 > n2: return n1 else: return n2 print("El máximo de 5 y 12 es:") print( maximo(5,12) ) print("El máximo de 25 y 12 es:") print( maximo(25,12) )

Y se pueden devolver valores no numéricos, como cadenas o valores de verdad (verdadero, "True" o falso, "False"), de modo que así quedaría la función que dice si un número es primo o no:

# Comprobación de si un número es primo (ineficiente), # aplicando la definición: divisible sólo entre 1 y él mismo def esPrimo(n):

cantidadDivisores = 0 for i in range(1, n+1): if n % i == 0: cantidadDivisores = cantidadDivisores + 1 if cantidadDivisores <= 2: # Si solo hay 2 divisores, es primo return True else: # Si hay más, no es primo return False # Prueba: mostrar los primos del 1 al 30 for i in range(1, 31): if esPrimo(i): print(i)

Ejercicios propuestos en Python

1. Crea una función que reciba como parámetro un texto y lo escriba centrado en pantalla (suponiendo una anchura de 80 columnas)

2. Crea una función que reciba un número entero y devuelva la cantidad de divisores (por ejemplo, para el número 16, sus divisores son 1, 2, 4, 8, 16, luego la respuesta debería ser 5).

3. Crea un programa que pida dos números enteros al usuario y diga si alguno de ellos es múltiplo del otro. Crea una función EsMultiplo que te ayude a que el cuerpo del programa sea legible.