SSProgramación PDF

1
Notas de
Programa ión I
2
Índi e general
1. INTRODUCCIÓN 5
2. ALGORÍTMICA 7
2.1. Con eptos bási os . . . . . . . . . . . . . . . . . . . . . . . . . . 10
2.1.1. Variables . . . . . . . . . . . . . . . . . . . . . . . . . . . 10
2.1.2. Prueba de es ritorio . . . . . . . . . . . . . . . . . . . . 16
2.1.3. Operadores . . . . . . . . . . . . . . . . . . . . . . . . . 19
2.2. Estru turas de ontrol . . . . . . . . . . . . . . . . . . . . . . . 25
2.2.1. Estru turas de ontrol ondi ionales . . . . . . . . . . . . 26
2.2.2. Estru turas de ontrol iterativas ( i los) . . . . . . . . . 36
2.3. Arreglos (ve tores) . . . . . . . . . . . . . . . . . . . . . . . . . 48
3. LENGUAJES DE PROGRAMACIÓN 51
3.1. C . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 56
3.1.1. Compila ión y eje u ión de un programa . . . . . . . . . 56
3.1.2. Generalidades . . . . . . . . . . . . . . . . . . . . . . . . 59
3.1.3. Variables . . . . . . . . . . . . . . . . . . . . . . . . . . . 62
3.1.4. Tipos de datos . . . . . . . . . . . . . . . . . . . . . . . 63
3.1.5. Entrada y salida de datos . . . . . . . . . . . . . . . . . 66
3.1.6. Operadores . . . . . . . . . . . . . . . . . . . . . . . . . 74
3.1.7. Estru tura general de un programa . . . . . . . . . . . . 77
3.1.8. Fun iones . . . . . . . . . . . . . . . . . . . . . . . . . . 78
3.1.10. Estru turas de ontrol iterativas . . . . . . . . . . . . . . 92
3.1.11. Arreglos . . . . . . . . . . . . . . . . . . . . . . . . . . . 101
3.1.12. Más a er a de fun iones . . . . . . . . . . . . . . . . . . 107
3.2. Java . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 111
3.2.1. Eje u ión de un programa . . . . . . . . . . . . . . . . . 114
3.2.2. Tipos bási os de datos . . . . . . . . . . . . . . . . . . . 121
3
4 ÍNDICE GENERAL
3.2.3. Operadores . . . . . . . . . . . . . . . . . . . . . . . . . 124

3.2.4. Orienta ión a objetos . . . . . . . . . . . . . . . . . . . . 126
3.2.5. Modi adores de lases, métodos y atributos . . . . . . . 141
3.2.6. Crea ión de ventanas . . . . . . . . . . . . . . . . . . . . 145
3.2.10. Arreglos . . . . . . . . . . . . . . . . . . . . . . . . . . . 184
3.2.11. Ex ep iones . . . . . . . . . . . . . . . . . . . . . . . . . 188
3.3. Phyton . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 193
3.3.1. Interpreta ión y eje u ión de un programa . . . . . . . . 193
3.3.2. Comentarios . . . . . . . . . . . . . . . . . . . . . . . . . 195
3.3.3. Variables . . . . . . . . . . . . . . . . . . . . . . . . . . . 195
3.3.4. Tipos de datos bási os . . . . . . . . . . . . . . . . . . . 197
3.3.5. Operadores . . . . . . . . . . . . . . . . . . . . . . . . . 202
3.3.7. Fun iones . . . . . . . . . . . . . . . . . . . . . . . . . . 210
3.3.10. Arreglos . . . . . . . . . . . . . . . . . . . . . . . . . . . 225
3.3.11. Ex ep iones . . . . . . . . . . . . . . . . . . . . . . . . . 231
Capítulo 1
INTRODUCCIÓN
En este do umento se presentan las notas de lase orrespondientes a la

Experien ia Edu ativa Programa ión I de la Li en iatura en Matemáti as de
la Universidad Vera ruzana. El material está distribuido en dos partes. La
parte de algorítmi a es la primera, y en ella se da una breve introdu ión a la
rea ión de algoritmos de una manera independiente de ualquier lenguaje de
programa ión.
En la segunda parte se presentan tres lenguajes de programa ión: C, Java y
Python, por lo que, una vez ubierta la parte I, el le tor podrá sele ionar el
lenguaje de programa ión de su ele ión.
Para ada uno de los tres lenguajes de programa ión se presenta una breve
introdu ión sobre su uso, así omo la implementa ión de algunos algoritmos
in luidos en la parte I.
Además se in luye una lista de programas que el le tor debería implementar,
a manera de prá ti a, para rearmar los ono imientos adquiridos.
5
6 CAPÍTULO 1. INTRODUCCIÓN
Capítulo 2
ALGORÍTMICA
Llamamos programa de omputadora a una se uen ia nita de instru iones

que, una vez eje utadas, realizarán una o varias tareas en una omputadora.
En términos generales, el entorno en el que un programa vive está ilustrado
en la siguiente gura:
Figura 2.1: Representa ión grá a de entorno en el que se desarrolla un programa
En su forma más general, un programa de omputadora, mientras está en

eje u ión, es ono ido omo Pro eso, y es lo que lleva a abo las opera iones
indi adas por el usuario. Salvo ex ep iones muy espe iales, omo por ejemplo,
programas que se basan úni a y ex lusivamente en la genera ión de números
pseudo-aleatorios, todos los programas re iben una entrada, que es el insumo
sobre el ual han de operar, y omo resultado de esa entrada, y el pro esamiento
que se le apli a, nos da omo resultado una salida.
En una primera instan ia, salvo que seamos los readores o analistas de
un programa dado, nosotros solemos observar a la parte entral del diagrama,
la relativa al pro esamiento, omo si fuera una aja negra, manteniendo para
nuestra mente omo un misterio la forma en que se llevan a abo las opera iones.
Suele utilizarse el término aja negra para referirse al pro eso en el sentido de
que su estru tura interna se des ono e, pero está fundamentada.
7
8 CAPÍTULO 2. ALGORÍTMICA
La rela ión entre la entrada, el pro esamiento, y la salida, nuevamente salvo

honrosas ex ep iones, suele ser unívo a, esto es, que para una misma entrada
dada por el usuario (o el ambiente), el pro esamiento dará omo resultado
exa tamente la misma salida.
Podemos denir a un algoritmo es una se uen ia nita de instru iones

ordenadas y bien denidas, que permiten realizar una a tividad o resolver un
problema. Dados un estado ini ial y los datos de entrada ne esarios, se eje utan
las instru iones una a una, desde el prin ipio y hasta el nal del mismo, hasta
que se llega a un estado nal y se obtiene un produ to o solu ión del problema.
Con lo di ho hasta ahora, pare e que los términos algoritmo y programa son
sinónimos, la realidad es que tienen una pequeña diferen ia: los algoritmos
no dependen de lenguaje de programa ión alguno, y los programas si. Más
aún, los algoritmos no ne esariamente se deben es ribir en algun lenguaje de
programa ión.
Todos utilizamos algoritmos en nuestras a tividades otidianas, por ejemplo,

al seguir los pasos de una re eta de o ina, el manual de instala ión de una
lavadora, las instru iones a seguir para ins ribirse a la universidad, el algoritmo
de la división de Eu lides, o el método de elimina ion de Gauss para resolver
sistemas de e ua iones lineales, por men ionar algunos.
Para rear un programa, empleamos los llamados lenguajes de programa ión,

que son lenguajes arti iales diseñados para expresar opera iones que pueden
ser llevadas a abo por máquinas omo las omputadoras, elulares, tabletas,
et . Los lenguajes de programa ión podemos emplearlos para rear programas
que ontrolen el omportamiento (físi o y lógi o) de una máquina, o para
expresar algoritmos on pre isión.
En el apítulo suguiente, daremos una breve introdu ión al uso de los

lenguajes de programa ión C, Java y Python, pero por el momento, úni amente
nos dedi aremos a diseñar algoritmos. Para esto existen varias herramientas,
entre las más omunes se en uentran las dos siguientes:
i) Diagrama de ujo:
Es una des rip ión grá a de un algoritmo en la que se utilizan símbolos

estándar, que representan las a iones del algoritmo, unidas mediante
e has que indi an el orden en que se eje utan las instru iones. Aunque
su ventaja prin ipal es que son de fá il le tura, generalmente, abar an
9
mu ho espa io y su onstru ión es muy laboriosa.
En un diagrama de ujo deben representarse los siguientes aspe tos:
El omienzo del programa.

Las opera iones que el programa realiza.
El orden en que se realizan.
El nal del programa.
Los siguientes son algunos de los símbolos de uso más omun utilizados
para elaborar diagramas de ujo:
Símbolo Des rip ión

Indi a el ini io algoritmo y, desde él, sólo puede
salir una línea de ontro de ujo.
Indi a el n del algoritmo. Sólo puede llegar una

línea de ontrol de ujohasta él.
Indi a una a ión a realizar. Tiene una úni a línea

de entrada y otra de salida.
Indi a una a ión de entrada (le tura de datos

desde el te lado) o salida (es ritura de un dato por
pantalla). Tiene una úni a línea de entrada y otra
de salida.
Se usan para tomar una de isión, dependiendo de

ierta ondi ión. Tiene una línea de entrada y dos
de salidas (una por la ual salir, si la ondi ión es
verdadera, y otra, si es falsa).
Se usan para one tar los símbolos anteriores y

espe i an el ujo del algoritmo.
ii ) Pseudo ódigo:
También ono ido omo español (o inglés, en su aso) estru turado, es

una des rip ión que se pare e mu ho a un lenguaje de programa ión. Las
instru iones se es riben on palabras similares al inglés o al español,
para fa ilitar la le tura y es ritura del algoritmo. Las reglas para ha er
un pseudo ódigo no están regidas por ningún estándar ampliamente
a eptado.
Una de las ventajas de utilizar pseudo ódigos, es que podemos entrarnos

sobre la lógi a del problema, olvidándonos de la sintaxis de un lenguaje
on reto, además, es fá il modi ar el algoritmo des rito y tradu irlo
dire tamente a ualquier lenguaje de programa ión.
En adelante, durante este apítulo, utilizaremos los pseudo ódigos para elaborar
nuestros algoritmos.
2.1. Con eptos bási os
2.1.1. Variables
Antes de denir lo que signi a para nosotros una variable, onsideremos
a la memoria de la omputadora omo un armario onformado por mu hos
ajones, en los que podemos alma enar datos (estos datos se alma enan en
lenguaje máquina, es de ir, se uen ias nitas de eros y unos), y supongamos
también que ada uno de estos ajones está numerado para poder referirnos
a ada uno de manera úni a. Más pre isamente este número se ono e omo
dire ión de memoria.
Denimos una variable omo una por ión de la memoria, reservada para
alma enar un dato, on la analogía presentada antes, una variable es un ajón.
Así omo la omputadora ne esita etiquetar los ajones, nosotros también
vamos a ne esitar un nombre o identi ador de variable para referirnos a
nuestras variables. Debe existir una orresponden ia unívio a entre los nombres
de variable y los números de los ajones.
Cada lenguaje de programa ión tiene sus propias reglas para dar un nombre
a una variable. Entre las reglas más generales se en uentran las siguientes:
2.1. CONCEPTOS BÁSICOS 11
Un nombre válido para una variable es una se uen ia de ara teres que
pueden ser letras, dígitos y guiones bajos.
Un nombre de variable puede ini iar on una letra, pero nun a on un

dígito.
Debe uidarse no utilizar las palabras reservadas para el lenguaje de

programa ión.
No está permitido que un espa io en blan o forme parte de un nombre

de variable.
En la mayoría de los lenguajes de programa ión al nombrar una variable

se distingue entre mayús ulas y minús ulas. Por ejemplo, las variables
Var y var no son la misma. Pas al, Delphin y Basi son ejemplos de
lenguajes en los que no se ha e esta distin ión.
En la mayoría de los lenguajes de programa ión es ne esario de larar las
variables que se van a utilizar, así omo el tipo de variable que es, por ejemplo
un número entero, un número real, texto, ve tor, una matriz, et . Por el
momento, en los pseudo ódigos no de laramos las variables ni su tipo. En la
parte orrespondiente a ada lenguaje (C, Java y Python) se tratará a detalle
este tema.
Cabe men ionar que en el momento en que reamos una nueva variable
dentro de un programa, lo úni o que se ha e es reservar un espa io de memoria
para ésta, y la mayoría de los lenguajes de programa ión no se preo upan
por la informa ión alma enada en este espa io de memoria, generalmente
manteniendo el ontenido previamente alma enado ahí, lo que es onsiderado
omo 'basura'.
Esta es la razón por la que, además de rear las variables dentro de nuestros
programas, será nuestra responsabilidad ini ializarlas antes de utilizarlas, pues
de otra forma orremos el riesgo de estar usando esos valores basura, pues no
sabemos que hay en el ajón que se orresponde on la variable que a abamos
de de larar.
Por ejemplo, si en algún programa de laramos una nueva variable x de

tipo número real, se reserva una elda o espa io de memoria, uya dire ión
des ono emos. Supongamos que, en esta o asión, se le asigna la elda uya
dire ión es el número 325712 (ver gura 2.2).
Figura 2.2: Representa ión de la rea ión de una variable.
Si no ini ializamos la variable x, y realizamos alguna(s) opera ión(es) on

ella, estaríamos utilizando el valor basura que pudiera existir en esa elda,
en este aso x tendría un valor de 683509. Si en ambio ini ializamos la nueva
variable omo 0, se destruye el valor que existía en esa elda, y se reemplaza
por el número ero. Esta nueva situa ión se representa en la gura 2.3.
Figura 2.3: Estado de la variable después de la asigna ión.

Por otra parte, las dos opera iones que son permitidas sobre las variables
son:
Consultar el valor de la variable.
Dar un valor a la variable
En lo que on ierne a la opera ión de onsulta basta on invo ar el nombre

de la variable para re uperar su valor. Para mostrar en la salida ( omunmente
en pantalla) vamos a emplear la palabra reservada:
ESCRIBE: Presenta en la pantalla de la omputadora el/los valores de

las variables, onstantes que re ibe omo parámetros o expresiones.
Por otro lado, el alma enamiento de un valor dentro de una variable puede
ha erse de entre una de las dos siguientes maneras:
Asigna ión.
Le tura.
Asigna ión
La asigna ión es un pro eso a través del úal damos un valor a una variable.
Esta es una opera ión destru tiva, ya que reemplaza ualquier valor que la
variable tuviera antes de la asigna ión. Su forma general es:
<variable>=<expresión>
y fun iona de la siguiente manera: se evalúa expresión y el resultado se guarda

en <variable>, sustituyendo ualquier valor que hubiera anteriormente en
esa posi ión de memoria. Al símbolo de igualdad = le llamaremos operador
asigna ión.
NOTA: Para realizar la de larara ión de la sintaxis o la forma general de

las instru iones vamos a utilizar una nota ión similar a la ono ida omo
Ba kus-Naur. Por ejemplo, al espe i ar la forma en que debe efe tuarse
una asigna ión, los símbolos <, > no forman parte de la instru ión, solo las
utilizamos para delimitar los omponentes de la senten ia.
Veamos un ejemplo:
variable_1=5
indi a que en la variable (espa io de memoria) uyo nombre es variable_1

se alma ena el número 5. Observe omo los símbolos <, > no forman parte de
la de lara ión he ha.
A ontinua ión, podemos sumar una unidad a variable_1 y alma enar el

resultado en el mismo espa io de memoria, es de ir, en la misma variable, esto
de la siguiente manera:
variable_1=variable_1+1
Así, después de esta asigna ión se habrá reemplazado en el espa io de memoria

variable_1 el número 5 por el número 6. Matemáti amente, la expresión anterior
no tiene sentido (ya que se estaría di iendo que 5 = 6), es por esto que el le tor
debe onven erse que el símbolo = en realidad no lo estamos onsiderando omo
la igualdad matemáti a, sino que lo estamos empleando para signi ar una
sustitu ión. Así pues, en una asigna ión una variable puede apare er en ambos
lados del operador asigna ión, pero en el lado izquierdo de = sólo debe gurar
una variable y no una expresión. Por onsiguiente, sería in orre to es ribir:
var_x+var_y=var_z
pero
var_z=var_x+var_y
es una asigna ión orre ta. Veamos otro ejemplo:
A=5
B=7
C=A+B-1
Enton es C tiene el valor 11.
Ejemplo 2.1.1. Ha er un algoritmo en el que se asignen valores arbitrarios a

dos variables y que posteriormente inter ambie los valores de esas dos variables.
Tip: Re ordar que la asigna ión es una opera ión destru tiva.
Solu ión:Un pseudo ódigo del algoritmo que resuelve el problema es:
variable_1=3
variable_2=4
variable_3=variable_1
No será di il onven erse de que al terminar el programa, los valores asignados
se habrán invertido, esto es: variable_1=4 y variable_2=3.
Le tura
Para obtener un dato propor ionado dire tamente por el usuario durante
la eje u ión del algoritmo vamos a utilizar la palabra:
LEE: Permite la le tura de uno o más valores desde el te lado de la

omputadora, asignandolos automáti amente a una(s) variable(s). Cada
vez que el ujo del programa en uentra ésta instru ión, se suspende la
eje u ión del programa hasta que el usuario da (te lea) el valor o los
valores soli itados.
Se re omienda, razones prá ti as, leer un solo valor por ada opera ión LEE.
NOTA: Las instru iones E/S (Entrada/Salida) o I/O (del inglés Input/Output)
onstituyen la forma general que se usa para llevar a abo la intera ión
hombre/máquina. La entrada estándar (stdin), omo ya se men ionó antes,
suele se onsiderada omo el te lado, mientras que la salida estándar (stdout)
se asume omo la pantalla de la omputadora. Adi ionalmente existe otro tipo
de salida en el aso del sistema operativo Unix (Linux y sus variantes), y es
la salida de errores (stderr), a donde son enviados todos los mensajes de error
generados por un programa.
Se deben utilizar tantas variables omo sea ne esario pero tan po as omo
sea posible.
Ejemplo 2.1.2. Rees ribir el algoritmo que inter ambia los valores de las
variables, pero que en vez de asigna ión se utili e LEE para darle valores a
éstas, y que, al nal, es riba en la pantalla los valores de las dos variables.
Solu ión:
ESCRIBE Introduz a un valor numéri o para var_1

LEE var_1
ESCRIBE Introduz a un valor numéri o para var_2
LEE var_2
var_3 =var_1
var_1 =var_2
var_2 =var_3
ESCRIBE var_1
ESCRIBE var_2
OBSERVACIÓN: La primera instru ión de este algoritmo da omo resultado

mostrar en la salida la se uen ia de ara teres que apare e en errada entre
omillas (las omillas no apare en en la salida). Una adena de ara teres es
una se uen ia de ara teres, en errada entre omillas. Las omillas no forman
parte de la adena, uni amente la delimitan. Por otra parte, es onveniente
presentar un mensaje en la salida antes de ada opera ión de le tura, en el
ual se indique al usuario el tipo de dato debe introdu ir, tal omo se hizo en
el ejemplo 2.1.2 antes de leer var_1 y var_2.
2.1.2. Prueba de es ritorio

Una vez que se tiene el pseudo ódigo de una algoritmo es re omendable
ha er una omproba ión a lápiz y papel para veri ar si fun iona orre tamente.
Una herramienta bastante útil para ha er esto onsiste en onstruir una tabla
en la que se muestra el estado del algoritmo ada vez que se da un paso en
su eje u ión onforme trans urre el tiempo. El estado de un programa está
denotado por los valores de todas y ada una de sus variables en un momento
dado de su eje u ión, así omo del apuntador del programa, que indi a la
siguiente instru ión a ser eje utada. Los valores obtenidos al nal de la prueba
de es ritorio denotan el resultado del programa, es de ir, el último estado del
algoritmo es el resultado del programa.
A esta té ni a para veri ar si el algoritmo es orre to le llamaremos prueba

de es ritorio.
Para ilustrar omo se ha e una prueba de es ritorio hagamos, paso a paso,

la orrespondiente al ejemplo 2.1.2, tomando A = 10 y B = 15:
Entrada var_1 var_2 var_3 Salida

Introduz a un valor para var_1

10 10

10 10

10 10
15 15

10 10
15 15
10

10 10
15 15
10
15

10 10
15 15
10
15
10

10 10
15 15
10
15
10
15

10 10
15 15
10
15
10
15
10
Observe omo en ada renglon de la tabla, en forma des endente, se representa

un estado diferente del algoritmo onforme trans urre el tiempo de eje u ión.
Por otra parte, vemos que nuestro pseudo ódigo pare e ser orre to, ya que
ini ialmente se tenía A = 10, B = 15 y en el estado nal del algoritmo
observamos que A = 15, B = 10, tal omo se quería.
2.1.3. Operadores
Un operador es un ará ter(o se uen ia de ara teres) que a túa sobre una
o más variables, realizando una opera ión espe í a. Un operador puede ser
unario, o binario, dependiendo del número(1 o 2) de variables, expresiones o
términos a los uales se apli a. A ontinua ión presentamos los operadores de
uso más fre uente.
Operadores aritméti os
Los operadores aritméti os son los operadores binarios:
Los primeros uatro orresponden a la adi ión, sustra ión, produ to y o iente
on las que todos estamos familiarizados. El operador residuo o módulo, %,
se apli a solamente a variables, onstantes o expresiones de tipo entero. Su
signi ado es simple: el resultado de la opera ión a %b es el residuo que se
obtiene de dividir a por b, por ejemplo:
27 %5 da omo resultado 2, pues 2 es el residuo de 27/5.

936 %9 da omo resultado 0, pues 0 es el residuo de 936/9.
Observe que a %b = 0 si y solamente si a es un múltiplo de b.
Es sabido de álgebra que existe una regla de pre eden ia entre los operadores
aritméti os, que nos indi a que opera iones hay que ha er primero y uales
después. Bási amente di e lo siguiente:
Primero se realizan los produ tos, o ientes y módulos, en el orden en el

que apare en en la expresión y, de izquierda a dere ha. Luego se eje utan
las adi iones y sustra iones. Para modi ar esta pre eden ia utilizamos los
paréntesis, on su signi ado usual.
OBSERVACIÓN: Los paréntesis son los uni os símbolos que utilizaremos para
agrupar opera iones, pues en la mayoría de los lenguajes de programa ión los
or hetes y llaves tienen otras fun iones.
Ejemplo 2.1.3. Ha er un algoritmo que lea desde el te lado dos números
enteros para dos in ógnitas, y que posteriormente al ule el uadrado de la
suma de ambos números y presente en la salida el resultado de esta opera ión.
Solu ión:
ESCRIBE Este programa al ula el uadrado de la suma de
dos números introdu idos por el usuario.
ESCRIBE Introduz a un primer número entero
LEE A
ESCRIBE Introduz a un segundo número entero
LEE B
C=A*A+2*A*B+B*B
ESCRIBE C
La prueba de es ritorio orrespondiente a este algoritmo es la siguiente,

suponiendo que el primer número te leado es 5, y el segundo, 3:
LEE A B C ESCRIBE
Este programa al ula el uadrado de la suma de dos
números introdu idos por el usuario
Introduz a un primer número entero
5 5
Introduz a un segundo número entero
3 3
64
64
Los siguientes pseudo ódigos orresponden a otros algoritmos(distintos) que
también resuelven el mismo problema:
Solu ión2:
LEE A
LEE B
ESCRIBE (A+B)*(A+B)
Solu ión2:
LEE A
LEE B
C=A+B
C=C*C
ESCRIBE C
En este ejemplo puede observarse omo un problema tan simple, puede tener
múltiples solu iones. Otro aspe to importante es que podemos emplear tantas
variables omo sean ne esarias, pero a la vez, on miras en minimizar el uso
de la memoria de alma enamiento, es re omendable utilizar tan po as omo
sea posible.
Operadores de asigna ión ompuestos

Un operador de asigna ión ompuesto es un operador que sirve para abreviar
la es ritura de una opera ión re urrente sobre una misma variable. Entre estos
se en uentran:
Asigna ión on suma: + =
Asigna ión on resta: − =
Asigna ión on multipli a ión: ∗ =
Asigna ión on división: / =
Asigna ión on módulo: % =
Así, en lugar de dar la instru ión
var_x = var_x + a
podemos es ribir
var_x +=a
En general, la expresión:
<variable> <operador> = <expresión>
es equivalente a :
<variable> = <variable> <operador> <expresión>
donde <operador> es ualquiera de los operadores +, −, ∗, /, %.
Otros dos operadores de asigna ión ompuestos son:
++
−−
a los que ono emos omo operadores de in remento y de remento unitarios,

respe tivamente. Ambos son operadores unarios, ++ in rementa en una unidad
el valor de la variable a la que se apli a y −− lo de rementa (también en una
unidad). Estos operadores pueden ir antes o después de la variable. El operador
puede apli arse omo prejo, es de ir, <operador> pre ede a la variable y ésta
ve afe tada por el operador antes de que el valor de di ha variable sea utilizado
en la expresión. En ontraparte, de imos que el operador se apli a omo postjo
si es la variable la que pre ede al operador, modi andose la variable después
de ser utilizada. Por ejemplo:
i=5
x=i++
al eje utarse estas dos instru iónes el estado de las variables es: x = 5, i = 6.
Por el ontrario, si:
j=5
y =++j
enton es, una vez eje utadas las senten ias se obtiene j = 6, y = 6.
Operadores rela ionales

Son operadores binarios que sirven para ha er una ompara ión entre dos
expresiones (una a la izquierda y una a la dere ha del operador) siempre y
uando el resultado de evaluarlas sea un valor del mismo tipo.
Más expli itamente:
<expresión1> <operador> <expresión2>
si <expresión1> y <expresión2> son datos del mismo tipo por ejemplo números
enteros, adenas de ara teres o valores booleanos, si es que está denida,
enton es se realiza la ompara ión.
<operador> puede ser alguno de los siguientes:
igual que: ==
menor que: <
mayor que: >
menor o igual que: <=
mayor o igual que: >=
diferente que: ! =
El resultado de apli ar un operador de rela ión es un valor booleano, que

puede ser VERDADERO(V) o FALSO(F). Si la ondi ión representada por el
operador se umple, la opera ión devuelve el valor VERDADERO y si, por el
ontrario, la ondi ión no se umple, se devuelve el valor FALSO.
Como ejemplo, supóngase a = −3, b = 2, c = 10. Enton es:
a + b == c devuelve FALSO
a ∗ b < c devuelve VERDADERO
c/b ! = a devuelve VERDADERO
a + b − c >= 0 devuelve FALSO
También podemos ha er ompara iones omo:
hola==adios
que evidentemente, al ser evaluada, devuelve el valor FALSO. Son válidas

también ompara iones omo las siguientes:
e<j
w>=p
a==a
f<=b
z<z
los valores booleanos que devuelven estas expresiones son VERDADERO para
las tres primeras y FALSO para las restantes.
Operadores lógi os
Los operadores lógi os son los operadores binarios:
Y lógi o o onjun ión: .Y.
O lógi o o disyun ión: .O.

y el operador unario:
NO lógi o o disyun ión: .NO.
y sirven para ombinar los resultados de los operadores rela ionales.
El resultado de apli ar los operadores lógi os a las expresiones p y q es

un valor booleano que esta dado por la tabla de verdad:
p q p .Y. q p .O.q .NO. p

V V V V F
V F F V F
F V F V V
F F F F V
Estos operadores pueden ombinarse entre sí, empleando parentésis para agruparlos.
Por ejemplo, onsidérese la expresión:
(x + 22 < 0 .O. x ∗ x − 2 ∗ x − 3 == 0) .Y. (x es ra ional .O. x == π ))
Para x = 3:
2.2. ESTRUCTURAS DE CONTROL 25
(x {z < 0} .O. x
| + 22 x − 3 == 0}) .Y. (x
| ∗ x − 2 ∗{z | es ra ional
{z } .O. |x ==
{z π}))
F V V F
(x + 22 < 0 .O. x ∗ x − 2 ∗ x − 3 == 0) .Y. (x es ra ional .O. x == π))

| {z } | {z }
V V
(x + 22 < 0 .O. x ∗ x − 2 ∗ x − 3 == 0) .Y. (x es ra ional .O. x == π))

| {z }
V
Otra ara terísti a de las variables booleanas es que, dado que alm enan
un valor de verdad, pueden onsiderarse omo valores booleanos, razón por la
ual en lugar de instru iones omo:
B==V .Y. x <10
podemos es ribir simplemente:
B .Y. x<10
En ésta última de lara ión se debe entender que devolverá un valor de verdad
verdadero si B==V y x<10.
Asumimos que el le tor está familiarizado ya on este tema, de no ser

así, es re omendable onsultar algún texto a er a de lógi a de proposi iones y
teoría de onjuntos.
2.2. Estru turas de ontrol

En los algoritmos que hemos presentado hasta ahora, la eje u ión de las
instru iones ha sido se uen ial, es de ir, una tras otra y eje utando ada
instru ión una sola vez. Sin embargo, mu has ve es ne esitaremos eje utar
instru iónes sele tivamente, en fun ión de la evalua ión de ierta ondi ión.
En otros asos quisieramos que bajo iertas ondi iones se eje ute una o
varias instru iónes más de una vez.
Las senten ias que nos permiten alterar el ujo de eje u ión de un algoritmo
se ono en omo estru turas de ontrol de ujo, a las que en llamaremos
simplemente estru turas de ontrol, y dan forma a la programa ión estru turada.
En este texto presentamos dos tipos de ellas: las senten ias ondi ionales o de
sele ión y las senten ias iterativas o i los.
2.2.1. Estru turas de ontrol ondi ionales

En esta subse ión estudiaremos las senten ias ondi ionales o de sele ión
que permiten alterar el ujo de eje u ión del programa eje utando algunas
instru iones y omitiendo otras. Estas de isiones se determinan a partir del
estado del algoritmo.
Senten ia SI
Esta estu tura ondi ional permite eje utar una se uen ia de instru iones,
en fun ión del valor de verdad de una ondi ión dada. La forma general de esta
senten ia es la siguiente:
SI(< ondi ión>) {

<instru iones>
}
El bloque <instru iones> onstituye el uerpo de la ondi ional, y vamos

a delimitarlo en errandolo entre llaves. En algunos lenguajes de programa ión,
si <instru iones> tiene una úni a instru ión, las llaves pueden omitirse.
El fun ionamiento de esta ondi ional se da de la siguiente manera: se

evalúa < ondi ión>. Si ésta es evaluada omo VERDADERA, se pro ede
a eje utar el uerpo de la ondi ional. Si por el ontrario, < ondi ión> es
FALSA, el algoritmo ignora el bloque <instru iones>. Una ves he ho esto, el
programa sale de la esta estru tura de ontrol y se eje utan las instru iones
que guran despúes del uerpo de la ondi ional SI.
OBSERVACIÓN: Para fa ilitar la le tura y omprensión del algoritmo, vamos

a sangrar las instru iones en las estru turas de ontrol, es de ir, el bloque de
instru iones que forman el uerpo de la senten ia, las es ribiremos dejando
una sangría. Observe omo en la forma general del ondi ional SI, el bloque
<instru iones> apare e sangrado.
Veamos un ejemplo del uso de esta estu tura de ontrol.

Ejemplo 2.2.1. Ha er un algoritmo que re iba un número. Si éste es distinto

1
de ero, que muestre en pantalla el resultado de evaluar . Si el número
x
ingresado es ero, que mande un mensaje de error. Al nal, que es riba el
mensaje Gra ias por utilizar este programa.
Solu ión:
ESCRIBE Introduz a un número distinto de ero
LEE A
SI(A!=0) {
b=1/A
ESCRIBE 1/A = b
}
SI(A==0) {
ESCRIBE El número introdu ido no es válido
}
ESCRIBE Gra ias por utilizar este programa.
Al apli ar el algoritmo, introdu iendo un valor distinto de ero, el programa

veri ará la ondi ión A!=0, que en este aso es VERDADERA. Así que se
pro ede a eje utar las dos instru iones del uerpo del ondi ional SI(A!=0).
Una vez he ho esto, habrá terminado de apli arse este ondi ional y se pro ede
on las demás instru iones del algoritmo, en este ejemplo, tenemos nuevamente
un ondi ional SI, que al ser evaluado resultará falso, pues esta ondi ión es
ex lusiva on la anterior, i.e., su ede una o la otra, pero no ambas.
Para omprender mejor el fun ionamiento de este algoritmo, mostramos

la prueba de es ritorio orrespondiente, suponiendo que el usuario introdu e el
número 9 por medio de te lado. Está representada en la tabla Caso a probar:
A=9.
El otro aso posible para este programa es que se introduz a en la entrada

el valor entero igual a ero. El algoritmo evaluara ambas ondi iones, pero
sólo será verdadera la segunda, lo ual produ e la eje u ión de la instru ión
que forma el uerpo del SI(A==0). La prueba de es ritorio orrespondiete se
presenta en la tabla Caso a probar: A=0.
Caso a probar: A=9

LEE A b CONDICIÓN ESCRIBE
Introduz a un número distinto de
ero
9 9
(9>=0)==V
1/9
1/A=1/9
(A==0)==F
Gra ias por utilizar este programa.
Caso a probar: A=0

LEE A b CONDICIÓN ESCRIBE
Introduz a un número distinto de ero
0 0
(0!=0)==F
(A==0)==V
El número introdu ido no es válido
Gra ias por utilizar este programa.
En estas dos pruebas de es ritorio, y en todas las que se in luyen más adelante,
vamos a abreviar los valores booleamos VERADERO y FALSO omo V y F
respe tivamente.
Ejer i io 2.2.1. Ha er un algoritmo que lea dos valores A, B. Posteriormente,

si A, B son distintos de ero, que asigne el o iente de A on B a la variable A
y a B asigne el produ to de A on B. Después de ésto, que imprima los valores
de A y B.
Senten ia SI-DOM
El SI-DOM es una senten ia ondi ional que, de ierto modo, puede pensarse
omo una generaliza ión o extensión del SI. Tiene la forma:
SI(< ondi ión>) {

<instru iones1>
}
DOM{
<instru iones2>
}
Se eje uta de la siguiente manera: Si la evalua ión de < ondi ión> resulta
VERADERA, se eje utan <instru iones1> y se prosigue on las senten ias
que hubiera despues de la llave que ierra el DOM (<instru iones2> no se
eje uta). Si en ambio, al evaluar < ondi ión> resulta FALSO, el algoritmo
no lleva a abo <instru iones1> y pasa a eje utar <instu iones2>.
Esta senten ia es ideal para tratar bifur a iones en las que solo pueden
su eder dos osas: se umple la ondi ión o su omplemento, aunque, omo
veremos más adelante sirve también para tratar situa iones en las que se
presentan dos o más asos ex lusivos dos a dos.
Ejemplo 2.2.2. Utilizando la senten ia SI-DOM, dar solu ión al ejemplo

2.2.1.
Solu ión:
ESCRIBE Introduz a un número distinto de ero
LEE A
SI(A!=0) {
b=1/x
ESCRIBE 1/x = b
}
DOM{
ESCRIBE El número introdu ido no es válido
}
ESCRIBE Gra ias por utilizar este programa.
En algunas o asiones, al diseñar nuestros algoritmos, será ne esario expresar

ondi iones que a su vez dependen de otras ondi iones, por lo que se requiere
ha er en adenamiento de instru iones ondi ionales, i.e, poner ondi ionales
dentro de los ondi ionales. En otras palabras, podemos anidar las estru turas
ondi ionales, omo se ilustra en el siguiente ejemplo:
Ejemplo 2.2.3. Ha er un programa que re iba dos números M, N y que

posteriormente diga si M es mayor, menor, o igual que N.
Solu ión
ESCRIBE Introduz a un valor numéri o para la variable M
LEE M
ESCRIBE Introduz a un valor numéri o para la variable N
LEE N
SI(M>N) {
ESCRIBE M es mayor que N
}
DOM{
SI(M<N) {
ESCRIBE M es menor que N
}
DOM{
ESCRIBE M es igual a N
}
}
ESCRIBE Fin del programa
Vale la pena re al ar el he ho de que en el último DOM de este algoritmo no

se espe ifí a ondi ion alguna para ser veri ada, pues si el ujo del algoritmo
ha llegado hasta esta instan ia, es por que M no es ni mayor ni menor que
N, lo ual impli a ne esariamente que M y N son iguales, lo que denota la
ara terísti a de ex lusión mutua entre los diferentes asos.
En esen ia, existen tres posibles asos diferentes en lo que on ierne al

ujo del programa:
M>N
M<N
M==N
Las tres tablas siguientes son las pruebas de es ritorio de ada uno de estos
tres asos (para algunos valores de M y N) respe tivamente.
Con M=0 y N=-1:
Caso a probar: M>N

LEE M N CONDICIÓN ESCRIBE
Introduz a un valor numéri o para
la variable M
0 0
la variable N
-1 -1
(M>N)==V
M es mayor que N
Fin del programa
on M=10 y N=20:
Caso a probar: M<N

Introduz a un valor numéri o
para la variable M
10 10
Introduz a un valor numéri o
para la variable N
20 20
(M>N)==F
(M<N)==V
M es menor que N
Fin del programa
nalmente, on M=N=4:
Caso a probar: M==N

la variable M
4 4
la variable N
4 4
(M>N)==F
(M<N)==F
M es igual a N
Fin del programa
NOTA: En general, en el uerpo de una estru tura de ontrol (ya sea ondi ional
o de repeti ión, las uales veremos más adelante), pueden gurar nuevamente
las estru turas de ontrol.
Ejer i io 2.2.2. Ha er un algoritmo que lea un valor numéri o desde el te lado.

Si este número es negativo, que es riba el resultado de dividir uno entre ese
número. En aso ontrario, si el número es positivo que es riba su fa torial, y
si es ero que mande un mensaje de error.
Ejer i io 2.2.3. Ha er un algoritmo que lea un número desde el te lado. Si

éste es mayor que ero, que es riba la palabra positivo, si es menor que
ero, que es riba negativo, si es igual a ero, que es riba la palabra ero.
Finalmente, que es riba el mensaje adiós, ya me voy.
Ejer i io 2.2.4. Ha er un algoritmo que re iba un número entero. Si éste

está entre 0 y 10, que es riba el mensaje NIÑO; si está entre 11 y 14, que
es riba el mensaje PREADOLESCENTE; si está entre 15 y 20 que es riba
ADOLESCENTE. Si está entre 21 y 60 que es riba ADULTO y nalmente,
si el número es mayor que 60, que es riba el mensaje VIEJITO.
Senten ia SI-(DOM-SI)-DOM
La estru tura de ontrol SI-(DOM-SI)-DOM puede pensarse omo una
abrevia ión de dos o más senten ias SI-DOM anidadas. Su forma general es:
SI(< ondi ión1>) {

<instru iones1>
}
DOM-SI(< ondi ión2>) {
<instru iones2>
}
..
.
DOM-SI(< ondi iónN-1>) {
<instru ionesN-1>
}
DOM{
<instru ionesN>
}
Es equivalente a una de lara ión omo la siguiente:

SI(< ondi ión1>) {

<instru iones1>
}
DOM{
SI(< ondi ión2>) {
<instru iones2>
}
DOM{
..
.
DOM{
SI( ondi iónN-1) {
<instru ionesN-1>
}
DOM{
<instru ionesN>
}
}
..
.
}
No hay mu ho que expli ar sobre su fun ionamiento, dada esta equivalen ia

on el SI-DOM. Nos limitamos a presentar el siguiente:
Ejemplo 2.2.4. Resolver el ejemplo 2.2.3 utilizando SI-(DOM-SI)-DOM.
Solu ión:
ESCRIBE Introduz a un valor numéri o para la variable M
LEE M
ESCRIBE Introduz a un valor numéri o para la variable N
LEE N
SI(M>N) {
ESCRIBE M es mayor que N
}
DOM-SI(M<N) {
ESCRIBE M es menor que N
}
DOM{
ESCRIBE M es igual a N
}
Observe que la ventaja de SI-(DOM-SI)-DOM es que es más barato es ribirlo,

omparado on dos SI-DOM anidados.
Ejer i io 2.2.5. Dar una solu ión alternativa al ejer i io 2.2.3 utilizando la
instru ión SI-(DOM-SI)-DOM.
Senten ia SWITCH
SWITCH es una senten ia ondi ional en la que, dada una antidad nita
de op iones, y dependiendo de ual de todas ellas se umple, se eje utará
uni amente su respe tivo bloque de instru iones. Esta estru tura de ontrol
tiene la siguiente forma:
SWITCH(<variable>){
aso < 1>:{
<instru iones1>
break;
}
aso < 2>:{
<instru iones2>
break;
}
aso < 3>:{
<instru iones3>
break;
}
..
.
aso < K>:{

<instru ionesK>
break;
}
DOM{
<instru iones>
}
}
En esta estru tura de ontrol se veri a a ual de los K asos orresponde

el valor de <variable>, omenzando el análisis desde aso < 1> hasta aso
< K >. Si se tiene <variable>==< N>, on 0 ≤ N ≤ K , enton es se
eje uta el bloque <instru ionesN>. Ya no se veri ará si se umplen las
de más op iones, pues la instru ión break ha e que, una vez realizadas
<instru ionesN>, el algoritmo salga de la senten ia ondi ional SWITCH, y
ontinua el pro eso del algoritmo inmediatamente después de donde termina el
uerpo de SWITCH. Si por el ontrario, ninguna de las K op iones se satisfa e,
el algoritmo entra en el DOM y pro ede a la eje u ión de <instu iones>. Al
nalizar esto, ontinúa on lo que hubiera después de esta ondi ional.
NOTA: Es ne esario in luir la senten ia break al nal de ada uno de los

K asos, pues si la omitimos, el programa no dará por terminada la eje u ión
de la senten ia SWITCH y ontinuará veri ando si se umple alguno de los
asos siguientes, a sabiendas de que si alguno de ellos satisfa e la ondi ión se
eje utará su respe tivo bloque de instru iones. El mismo aso apli a para el
DOM, que en aso de omitir el uso de la senten ia break, ne esariamente será
eje utada su se uen ia de instru iones, dando omo resultado, probablemente,
un omportamiento no deseado del programa. Así, el programa ontinuará
hasta que en uentre la instru ión break o hasta que llegue al DOM y eje ute
sus respe tivas instru iones.
A ontinua ión se presenta un sen illo ejemplo del uso de esta senten ia.
Para una mejor omprensión de su fun ionamiento, re omendamos al le tor
realizar al menos una prueba de es ritorio para la solu ión presentada enseguida.
Ejemplo 2.2.5. Ha er un programa que pida al usuario te lear una letra

(minús ula) del abe edario y que imprima en pantalla el mensaje Es vo al o
Es onsonante, según sea el aso. Utilizar la instru ión SWITCH.
Solu ión:
ESCRIBE Te lee una letra (minús ula) del abe edario
LEE letra
SWITCH(letra){
aso a:{
ESCRIBE Es vo al
break
}
aso e:{
ESCRIBE Es vo al
break
}
aso i:{
ESCRIBE Es vo al
break
}
aso o:{
ESCRIBE Es vo al
break
}
aso u:{
ESCRIBE Es vo al
break
}
DOM:{
ESCRIBE Es onsonante
}
}
Ejer i io 2.2.6. Dar solu ión al ejer i io 2.2.4 utilizando SWITCH.
Ejer i io 2.2.7. Elaborar un algoritmo que al ule el perímetro de una de

las siguientes guras: triángulo, uadrado, re tángulo, polígono de n lados y
ír ulo, según espe íque el usuario.
2.2.2. Estru turas de ontrol iterativas ( i los)

Una senten ia iterativa o de repeti ión permite la eje u ión de una misma
instru ión durante una antidad (nita) de ve es o repetirla mientras una
ondi ión lógi a o aritméti a dada se satisfaga. También se les ono e omo
i los.
Debemos uidar que, al espe i ar la ondi ión bajo la ual se eje utará
el uerpo de un i lo se garanti e que en determinado momento la ondi ión
será falsa, pues de no ser así, podriamos estar indi ando al programa que un
fragmento del ódigo se eje ute una antidad innita de ve es, lo que se ono e
omo i lo innito.
Senten ia MIENTRAS
La sintaxis del i lo MIENTRAS es la siguiente:
MIENTRAS(< ondi ión>) {

<instru iones>
}
Su fun ionamiento se da de la siguiente manera: si la valida ión de < ondi ión>

es VERDADERA, se pro ede a eje utar ada una de las a iones indi adas en
<instru iones>. Una vez he ho esto, se vuelve a validar < ondi ión> y se
repite el pro eso hasta que < ondi ión> sea FALSA, en uyo aso la eje u ión
del uerpo del i lo es omitida, ontinuando on la siguiente instru ión después
de la espe i a ión del i lo.
A ontinua ión in luimos un ejemplo on su respe tiva prueba de es ritorio.

Ejemplo 2.2.6. Ha er un algoritmo que lea una valor entero no negativo y
que posteriormente es riba en pantalla los valores de 0 hasta di ho número en
orden de re iente.
Solu ión
ESCRIBE Este programa imprime los enteros de 0 a N en
orden des endente
ESCRIBE Introduz a un valor entero y no negativo para N
LEE N
MIENTRAS(N>=0) {
ESCRIBE N
N−−
}
Caso a probar: N=4

LEE N CONDICIÓN ESCRIBE
Este programa imprime los enteros de
0 a N en orden des endente
Introduz a un valor entero y no
negativo para N
4 4
(4>=0)==V
4
3
(3>=0)==V
3
2
(2>=0)==V
2
1
(1>=0)==V
1
0
(0>=0)==V
0
-1
(-1>=0)==F
Fin del programa
Ejer i io 2.2.8. Ha er un algoritmo que lea un número A y que mientras el

valor de A sea mayor o igual que ero haga lo siguiente: lea otros dos números
B, C e imprima B ve es el valor de C y que leea de nuevo un valor para A.
Ejer i io 2.2.9. Ha er un algoritmo que lea un número y que muestre la suma

de los primeros enteros positivos desde el 1 hasta el número re ibido, utilizando
el i lo MIENTRAS.
Ejer i io 2.2.10. Ha er un algoritmo al ule e imprima el fa torial de un

número leído desde el te lado.
Ejer i io 2.2.11. Ha er un algoritmo que muestre en la pantalla los números

de la forma nˆ2 de tal manera que nˆ2 sea menor que un número dado por el
usuario.
Senten ia HACER-MIENTRAS
Una variante de la instru ión MIENTRAS es el i lo HACER-MIENTRAS.
La diferen ia entre éstas es que en la última se garantiza que su se uen ia de
instru iones se eje utará al menos una vez. Su sintaxis es la siguiente:
HACER {
<instru iones>
} MIENTRAS(< ondi ión>)
En el siguiente ejemplo se propone la solu ión al ejemplo 2.2.6, utilizando

la senten ia HACER-MIENTRAS.
Ejemplo 2.2.7. Solu ión al ejemplo 2.2.6 on HACER-MIENTRAS.

orden des endente
LEE N
HACER {
ESCRIBE N
N−−
} MIENTRAS(N>=0)
En realidad, esta propuesta de solu ión no es equivalente a la solu ión

dada en el ejemplo 2.2.6. Esto porque, para números no negativos, el algoritmo
produ e el mismo resultado(veri ar), pero para valores negativos, se omporta
de manera diferente. Para ver esto, presentamos la prueba de es ritorio de
ambos algoritmos, para un valor negativo:
Algoritmo del ejemplo 2.2.7

Caso a probar: N=-1
negativo para N
-1 -1
-1
-2
(-2>=0)==F
Fin del programa
Algoritmo del ejemplo 2.2.6

Caso a probar: N=-1
negativo para N
-1 -1
(-1>=0)==F
Fin del programa
Si observamos on detenimiento las dos pruebas de es ritorio anteriores, nos

damos uenta de que el el algoritmo del ejer i io 2.2.6 no se a ede al uerpo
de instru iones del i lo, por lo que el valor de N no se imprime ni se modi a.
En ambio, en el algoritmo del ejemplo 2.2.7, el programa entra una primera

vez al uerpo del i lo, por lo que el valor de N se muestra en pantalla y
posteriormente es disminuido en una unidad, antes de veri ar la ondi ión.
Reiteramos el he ho de que la razón por la ual el omportamiento es diferente,
es debido a que en el aso del algoritmo 2.2.7 la ondi ión es evaluada hasta
el nal.
El siguiente programa si produ e los mismos resultados que la solu ión

del ejemplo 2.2.6:

orden des endente
LEE N
SI(N>=0) {
HACER {
ESCRIBE N
N−−
} MIENTRAS(N>=0)
}
Su prueba de es ritorio, on el mismo valor (-1) que las dos anteriores es:
Caso a probar: N=-1

negativo para N
-1 -1
(-1>=0)==F
Fin del programa
Por último, re omendamos tener uidado al implementar programas on

las senten ias MIENTRAS y HACER-MIENTRAS ya que a pesar ser muy
pare idas, las pequeñas diferen ias que presentan pueden alterar el ujo de un
programa de una manera no deseada.
Senten ia PARA
Esta es quizá la estru tura de repeti ión que se utiliza on más fre uen ia.
En su forma más simple se de lara de la siguiente manera:
PARA (<opera ión ini ial>; < ondi ión>; <opera ión de varia ión>) {
<instru iones>
}
En <opera ion ini ial> se de laran y asignan determinados valores ini iales
a iertas variables o ontadores (no ne esariamente de tipo numéri os), mientras

que en <opera ión de varia ión> se a tualizan los estados estas variables o
ontadores.
La primera a ión que se realiza en estos i los es <opera ion ini ial>,
y no se vuelve a eje utar de nuevo. Despúes de esto y antes de pro eder
a la eje u ión de <instru iones>, se evalúa < ondi ión>, si ésta resulta
VERDADERA, se pro ede a eje utar el bloque <instru iones>. Una vez
he ho esto, se eje uta una vez <opera ión de varia ión> y se regresa al paso
que onsiste en veri ar el valor de verdad de < ondi ión>. Este pro eso se
repite hasta que < ondi ión> no sea VERDADERA, momento en el ual la
eje u ión del i lo termina y el programa ontinúa su ujo en donde termina
la de lara ión del PARA.
Figura 2.4: Orden en que se realizan las a iones durante la instru ión PARA
Todas estas a iones están representadas de manera grá a en la gura 2.4

Los pasos 1 y 2 se realizan una sóla vez, y las a iones representadas on e has
en olor azul se repetirán toda vez que la ondi ión se umpla. La eje u ión
del i lo termina uando la ondi ion deja de umplirse (e ha roja).
Para aterrizar ideas, pasemos a un ejemplo:

Ejemplo 2.2.8. Ha er un algoritmo que lea un número entero no negativo y

que es riba en pantalla el fa torial de di ho número. Utilizar el i lo PARA.
Solu ión
ESCRIBE Este programa al ula el fa torial de un número
x=1
ESCRIBE Introduz a un valor entero no negativo
LEE n
SI(n>1) {
PARA(i=2;i<=n;i++) {
x=i*x
}
ESCRIBE x
}
DOM-SI(n==0 .O. n==1) {
ESCRIBE x
}
DOM {
ESCRIBE: El número introdu ido debe ser no negativo
}
NOTA: Obsérvese que la variable x se le está asignando un valor antes de

entrar a la senten ia ondi ional y al i lo, puesto que, en aso de que no
ha erlo, podriamos estar efe tuando opera iones on un valor basura, y en
onse uen ia, obteniendo resultados erróneos en nuestro programa.
Es laro que si el número que se introdu e es 0 o 1, el fa torial será igual a 1,

tal omo en la deni ión matemáti a del fa torial para ero y uno. La siguiente
es la prueba de es ritorio en la que se ilustran los pasos que se eje utan si el
número que se da al programa es distinto de ero y uno.
Caso a probar: N=4

LEE x n CONDICIÓN i ESCRIBE
Este programa al ula el
fa torial de un número
1
Introduz a un valor entero y
no negativo para N
4 4
(4>1)==V
2
(2<=4)==V
2
3
(3<=4)==V
6
4
(4<=4)==V
24
5
(5<=4)==F
24
Fin del programa
También es posible utilizar la senten ia PARA on múltiples opera iones

ini iales, múltiples opera iones de varia ión y ondi iones omplejas.
Por ejemplo, el siguiente algoritmo en el que se al ula la suma de los

primeros N números (N es introdu ido a través de te lado), se utilizan dos
opera iones ini iales y dos de varia ión.
ESCRIBE: Introduz a un número no negativo

LEE N
X=0
PARA(i=1,j=N; j>=1; j−−, i++) {
X=i+j
}
X=X/2
ESCRIBE: La suma es igual a X
NOTA: A la variable X se le está asignando un valor antes de entrar al i lo,

puesto que, en aso de que no se umpliera la ondi ión de entrada al mismo,

y no se eje utara su uerpo, la variable X tendría un valor basura.
El siguiente es otro ejemplo en el que además de opera iones ini iales y de

varia ión múltiples, se tiene una ondi ión más ompleja.
ESCRIBE: Introduz a un número no negativo

LEE N
B=V
PARA(i=0, j=0; j<500*i*i .Y. B==V; i++, j=2*j+1) {
SI(i*i+j*j>=N) {
B=F
}
ESCIBE: i
ESCRIBE: j
ESCRIBE: iˆ2+jˆ2<N
}
ESCRIBE: Fin del programa
NOTA: La ondi ión B==V también puede ser expresada omo B, puesto
que esta variable ya es booleana, y por lo tanto alma ena un valor de verdad.
Por otra parte, ha emos hin ápie en que debe tenerse uidado en que la
ondi ión deje de umplirse en algún momento, para evitar que el programa
entre en un i lo innito.
Ejer i io 2.2.12. Ha er un algoritmo que lea un número N y que imprima en
orden inverso los enteros entre 0 y N. Utilizar el i lo PARA.
Ejer i io 2.2.13. Ha er un algoritmo que lea un número N y que es riba en

ordena as endente todos los números pares entre 2 y N. Utilizar el i lo PARA.
Ejer i io 2.2.14. Ha er un algoritmo que para una fun ión dada f (x) ≥ 0
al ule una aproxima ión del área bajo la urva.
Un problema on repeti iones

Como ya men ionamos anteriormente, las senten ias HACER-MIENTRAS
y MIENTRAS son muy pare idas. La diferen ia radi a en el he ho de que
HACER-MIENTRAS se garantiza que al menos una vez el programa entra al
i lo, y en el MIENTRAS puede su eder que nun a se eje uten las instru iones
que ontiene. Por otra parte, las senten ias PARA y MIENTRAS son las dos
instru iones utilizadas más omunmente para la rea ión de i los. Aunque a
primera vista pare en ser diferentes, lo ierto es que la mayoría de los problemas
en los que hay que eje utar varias ve es un mismo onjunto de instru iones
pueden implementarse utilizando ualquiera de estas dos senten ias.
Considerémos el siguiente problema:
Ejemplo 2.2.9. Con un grupo de 10,000 ani as se forma una pirámide

de base uadrada, on una úni a ani a en su vérti e superior y un número
uadrado perfe to de ellas en ada etapa. ¾Cúantas ani as sobrarán?
A ontinua ión proponemos tres solu iones a éste problema, una on ada
una de las senten ias de ontrol de repeti ión.
Solu ión on MIENTRAS:

ESCRIBE: Con un grupo de 10,000 ani as se forma una pirámide de
base uadrada, on una úni a ani a en su vérti e superior
y un número uadrado perfe to de ellas en ada etapa.
¾Cúantas ani as sobrarán?
i=1
k=0
x=0
y=0
MIENTRAS(k<10,000) {
k=k+i*i
i++
SI(k<10,000){
y++
x=k
}
}
ESCRIBE: 1.El número de apas es: y
ESCRIBE: 2.Las ani as sobrantes son: j-x
Solu ión on HACER-MIENTRAS:

i=1
k=0
x=0
y=0
HACER{
k=k+i*i
i++
SI(k<10,000) {
y++
x=k
}
} MIENTRAS
Solu ión on PARA:

x=0
y=0
PARA(k=0, i=1; k<10,000; i++) {
k=k+(i*i)
SI(k<10,000){
y++
x=k
}
}
El le tor puede analizar las diferen ias de los tres algoritmos y veri ar
via pruebas de es ritorio que efe tivamente los tres dan solu ión al problema
planteado.
2.3. Arreglos (ve tores)

En términos de programa ión, un arreglo no es más que una se uen ia nita
de elementos de un tipo determinado. A un arreglo unidimensional se le ono e
omúnmente omo ve tor. Los arreglos nos sirven para manejar una antidad
ja de datos bajo un mismo nombre o identi ador, pero no ne esariamente se
puede onsiderar esen ialmente omo un sólo objeto.
De he ho, uando denimos en la omputadora un ve tor on n elementos,

se estarán reservando n espa ios en la memoria (estos espa ios son onse utivos
en la memoria), en los uales se alma enarán los n datos que forman el ve tor.
Podemos a eder a ada uno de los elementos del ve tor, ya sea para ini ializar
los valores del ve tor, o bien para onsulta. Para esto, los elementos del ve tor
están indexados desde 0 hasta n−1. Por ejemplo, onsidere el ve tor de números
enteros:
Figura 2.5: Arreglo unidimensional de enteros (5 elementos)
En general, un ve tor es de la forma:
[v1 , v2 , . . . , vn ]
Para referirnos a un elemento de un ve tor, empleamos la nota ión (suponiendo

que el nombre del ve tor es v):
2.3. ARREGLOS (VECTORES) 49
v[i℄
donde i puede ser ualquier número entero desde 0 hasta el tamaño del ve tor
menos uno. Como on ualquier variable, es indispensable ini ializarla antes
de emplearla en un programa (esto se detallará uando se trate este tema en
ada uno de los lenguajes de programa ión en el apítulo siguiente). Por lo
pronto, omo ejemplo, on ayuda de la senten ia PARA, podemos a eder a
ada uno de los elementos del ve tor y mostrar su valor:
PARA(i=0; i<5; i++) {

ESCRIBE v[i℄
}
lo ual produ e imprimir en la salida los 5 elementos del ve tor v. Pueden

también modi arse los valores que ontiene el ve tor. Por ejemplo, después
de efe tuar las opera iones:
v[2℄=10
v[0℄++
la nueva instan ia de éste ve tor será:
Figura 2.6: Nueva insta ia del ve tor V
Los elementos de un arreglo pueden no ser ne esariamente números enteros.

Pueden ser letras, números reales, valores de verdad o in luso ve tores. Sin
embargo, los elementos de un arreglo deben ser estri tamente del mismo tipo.
Un arreglo bidimensional o matriz de m las por n olumnas es un arreglo

de m ve tores on n elementos ada uno. De manera similar a la que nos
referimos a una entrada (posi ión) espe í a de un ve tor, para a eder a un
elemento de una matriz empleamos la nota ión mat[i℄[j℄, donde i va de 0 a
m − 1 y j de 0 a n − 1.
Por ejemplo, onsideremos la siguiente matriz:

 
−4 0 2 1 −11
 0 2 0 45 0 
mat = 
 5 1 −3 0

1 
20 1 0 1 1
Ahora, vamos a sustituir todos y ada uno de los elementos de la mat por el
número 0. Para esto ne esitamos utilizar dos senten ias iterativas PARA de
manera anidada:
PARA(i=0; i<4; i++) {

PARA(j=0; j<5; j++) {
mat[i℄[j℄=0
}
}
Si lo deseamos podemos tener a eso a un elemento espe í o, por ejemplo:
mat[3℄[2℄=1
obteniendo:  
0 0 0 0 0
0 0 0 0 0
mat = 
0

1 0 0 0
0 0 0 0 0
Análogamente, puede generalizarse el on epto de arreglo a tres dimensiones

(o in luso más). Una matriz tridimensional es un ve tor uyas entradas son
matri es bidimensionales.
En su mayoría, los lenguajes de programa ión propor ionan herramientas

para efe tuar opera iones on arreglos, pero esto se tratará más a detalle para
los tres lenguajes que forman parte del ontenido de este texto.
Capítulo 3
LENGUAJES DE
PROGRAMACIÓN
El el apítulo 2 nos hemos dedi ado al diseño de algoritmos, sin trabajar

on algún lenguaje de programa ión en espe ial. Ahora nos o uparemos de
dar una breve introdu ión a los lenguajes C, Java y Python, re al ando que
si bien estos lenguajes son los usados para efe tos didá ti os de este urso, el
estudiante puede ha er uso del lenguaje de programa ión de su ele ión.
Antes de omenzar, es ne esario men ionar una diferen ia importante en

uanto a la forma en que los programas es ritos en estos lenguajes son tradu idos
al úni o lenguaje que entiende la omputadora: el lenguaje binario. En lo
siguiente, haremos referen ia a algunos tópi os tratados en el apítulo 2 de
este texto, por lo que suponemos que el le tor ya se ha o upado del estudio de
éste.
A las se uen ias de instru iones que es ribimos en alguno de los lenguajes
de programa ión le llamamos ódigo fuente, el ual debe tradu irse al ódigo
máquina para poder ser eje utado. Esta tradu ión puede llevarse a abo de
entre una de las tres maneras siguientes:
Compila ión a ódigo máquina:

Un programa llamado ompilador se en arga de tradu ir el ar hivo fuente,
previa veri a ión de que no haya errores de sintaxis en todo el ódigo, a
su equivalente en lenguaje máquina para que pueda ser eje utado en
la omputadora. Se ha e la tradu ión en onjunto, si es que no se
violó ninguna de las reglas sintá ti as del lenguage y a ontinua ión,
el ompilador genera y alma ena en el dis o un ar hivo (en lenguaje
51
52 CAPÍTULO 3. LENGUAJES DE PROGRAMACIÓN
máquina) eje utable.
Este programa resultante de la ompila ión puede eje utarse tantas ve es

omo uno quiera sin ne esidad de volver a ompilarlo, a menos que se
reali en ambios en el ódigo fuente, lo que impli aría ne esariamente
que el programa fuente fuera nuevamente ompilado.
El ódigo eje utable es nativo para ada tipo de omputadora/sistema

operativo. Esto signi a que si ompilamos un programa en algún lenguaje
de programa ión (por ejemplo C) dentro de una omputadora on sistema
operativo Unix, el ódigo eje utable resultante no podrá ser eje utado de
manera nativa, digamos, en una omputadora on sistema Ma OS X, a
menos que ésta última uente on un software que le permita entender
ódigos eje utables de otras plataformas (por ejemplo Parallels, Wine,
VirtualBox, et .). Ver gura 3.1
Figura 3.1: Los programas eje utables son nativos para ada tipo de omputadora.
53
Compila ión a ódigo intermedio:

En este tipo de ompila ión se realiza la tradu ión del ódigo fuente
a un lenguaje intermedio, el ual es independiente de la plataforma.
Para poder eje utar el programa es ne esario un programa espe ial al
que se le ono e, omunmente, omo máquina virtual. El programa (en
ódigo intermedio) podrá eje utarse en ualquier dispositivo que tenga
instalada di ha máquina virtual, la ual es apaz de tradu ir el programa
intermedio a un lenguaje que el dispositivo pueda omprender.
Figura 3.2: Compila ión a ódigo intermedio.
Re al amos el he ho de que el programa en ódigo intermedio no puede

eje utarse dire tamente en ningún dispositivo. Es ne esaria la máquina
virtual. En la gura 3.3 se ilustra el he ho de que, una vez que el programa
está en ódigo intermedio, puede eje utarse tanto en una omputadora
on S.O. Unix o Ma OS X, siempre y uando esté instalada la máquina
virtual.
Figura 3.3: El ódigo intermedio es independiente de la plataforma.

Si la máquina virtual está disponible para instala ión en algún otro

dispositivo que no sea ne esariamente una omputadora, el programa
podrá eje utarse en tal dispositivo.
En realidad, el ódigo intermedio es una variante del ódigo máquina,

on la ara terísti a parti ular de que no está aso iado a ningún sistema
operativo/ omputadora en parti ular, sino que se iñe a las espe i a iones
dadas por la máquina virtual dentro de la que se ha de eje utar. Ésta
ara terísti a lo ha e independiente de la plataforma, y una vez generado
el ódigo intermedio para un programa dado, no será ne esario volver a
ompilar éste último ada vez que se requiera ser eje utado, a menos que
el ódigo fuente ambie de alguna manera.
Intérpreta ión:
Se realiza la tradu ión de las instru iones una a una, eje utando ada
instru ión inmediatamente después de tradu irla.
De la misma manera que uando se utiliza un ompilador, la tradu ión

se efe tuara exitosamente si es que no se han in umplido las reglas
sintá ti as del lenguaje en uestión, sin embargo, esta veri a ión no
se ha e a-priori, sino onforme el programa va siendo leído.
Al utilizar un intérprete, ada vez que queremos eje utar el programa

en la omputadora, se va a realizar la tradu ión de ada una de las
instru iones del ódigo fuente a lenguaje máquina.
Generalmente la eje u ión de los programas intérpretados es más lenta que

los programas que son ompilados aunque, por otro lado, permiten una mayor
fa ilidad que los ompiladores durante un pro eso de aprendizaje. Es por esto
que hay lenguajes de programa ión que se han diseñado para explotar esta
exibilidad, mientras que otros pierden esta exibilidad on tal de obtener
mayor velo idad de eje u ión.
Otra de las diferen ias entre las tradu iones por ompila ión (a ódigo
máquina o intermedio) e interpreta ión es que, utilizando un ompilador, los
pro esos de tradu ión y eje u ión del programa son independientes: primero se
tradu e, y posteriormente se eje uta. Por el ontrario, al utilizar un intérprete,
ambos pro esos están ligados: ada instru ión es eje utada inmediatamente
después de que se ha tradu ido.
55
El lenguaje C es ompilado a ódigo máquina, Java es ompilado a ódigo

intermedio, mientras que Python es interpretado.
Para efe to de este urso es imperativo ha er uso de alguna variante de

sistema operativo basado en GNU+Linux (Ubuntu, Fedora, Gentoo, et .), o en
su defe to Ma OS X (ex lusivamente para omputadoras Apple). Sugerimos,

en la medida de lo posible, evitar usar el pseudo-Sistema Operativo Windows
de Mi rosoft R.
3.1. C
En esta se ión nos o uparemos de algunos de los aspe tos más elementales
en lo que on ierne a la implementa ión de programas en el lenguaje C. El
objetivo es ini iar al le tor al ono imiento de este lenguaje, esperando que
sea apaz de elaborar programas omo los planteados en el apítulo 2. Para un
estudio más detallado puede onsultar [1℄.
El orígen del lenguaje de Programa ión C se remonta al del sistema operativo

Unix. Dennis Rit hie fue quien se dio a la tarea de diseñar éste lenguaje. La
primera versión estable de C surgió en el año 1978, ono ida omo K&R C
(C de Kernighan y Rit hie), des rita en la primera edi ión del libro The C
Programming Language, uyos autores som Brian W. Kernighan y Dennis M.
Rit hie. En 1983 el Ameri an National Standars Institute (ANSI) designó un
omité uyo objetivo era estandarizar la deni ión de C, independiente de la
máquina. La segunda edi ión de The C Programming Language se basó en en
estándar ANSI(puede presentar algunas diferen ias mínimas, pues esa segunda
edi ión se es ribió mientras el ANSI se en ontraba en la etapa de revisión nal,
y que esperaba su aproba ión en 1988). Fue a nales de 1990 que se publi ó
el do umento on la espe i a ión estándar de C, a tualmente ono ida omo
C90. En 1992 la ISO(International Standars O e) revisó el do umento del
ANSI y lo a eptaron omo un estándar interna ional.
En 1999 se hizo una revisión de C90, dando lugar a C99, que es la última
versión de éste estándar de la deni ión de C. En él se han agregado algunos
tipos de datos que no guraban en la versión anterior tales omo los tipos long
long int y long long double. Otro ambio importante es que en C90 existia
bool omo tipo de dato nativo en la espe i a ión del lenguaje C, pero en
C99 bool se sa ó de la espe i a ión base de C, poniendo su espe i a ión
ahora por fuera, en un ar hivo de en abezado. Además se realizaron ambios
en la lingüisti a y ara terísti as de la bibliote a, por men ionar algunos. En
el presente texto nos apegamos al estándar C99.
3.1.1. Compila ión y eje u ión de un programa

Para ha er programas en lenguaje C vamos a es ribir las instru iones del
programa en un ar hivo fuente utilizaremos un programa editor de textos, y
guardaremos el ar hivo on una extensión .
3.1. C 57
Para ompilar y eje utar un programa seguiremos los siguientes pasos:

i ) Es ribir las instru iones del programa en un editor de texto y guardarlo
on una extensión . .
ii ) Abrir una terminal de omandos o onsola.
iii ) A eder al dire torio en que hemos guardado el ódigo fuente.
iv) Es ribimos la instru ión: g -o <nombre> <nombre. >

Si hay algún error en el ódigo, el ompilador manda un mensaje de error
y no se rea el ar hivo eje utable. Si la ompila ión se realizó de manera
exitosa, no se emite mensaje alguno y se habrá reado, en el mismo
dire torio que donde esta guardado nombre. , un ar hivo eje utable.
v ) Para eje utar el programa basta es ribir en la línea de órdenes ./nombre

NOTAS:
Para el paso I) la es ritura del ódigo fuente puede realizarse en ualquier
editor de textos, preferentemente en alguno on remar ado sintá ti o,
tales omo gedit o Geany.
Otra alternativa es utilizar algún Entorno de Desarrollo Integrado (IDE),

tales omo E lipse o Netbeans que además soportan otros lenguajes
de programa ión. En el aso de utilizar algún IDE ya no es ne esario
ompilar y eje utar los programas desde la terminal, pues estos entornos
ya in luyen sus orrespondientes omandos para ha erlo.
Durante este apítulo, para efe to de la es ritura de los ódigos de los

programas haremos uso del editor gedit, instalado por omisión en el
sistema operativo Ubuntu.
En el paso IV) la op ión -o se utiliza para dar un nombre espe í o

al programa eje utable, más pre isamente, si ponemos la instru ión
g -o <nombre> <nombre. > estamos indi ando que el eje utable se
llamará <nombre> (no ne esariamente tiene que ser el mismo nombre
que nuestro ar hivo . ). En aso de omitirse esta op ión, el eje utable
generado tendrá el nombre genéri o a.out
A ontinua ión ejempli amos la manera en que se ompila y eje uta un
programa en C, para esto onsideremos el ódigo que se muestra en la gura
3.4.
Figura 3.4: Paso I
Por el momento no vamos a entrar en detalles en uanto al signi ado de las

líneas de ódigo es ritas, simplemente vamos a enfo arnos en lograr ompilar
y eje utar este programa. Se ha guardado on el nombre primero. , en una
arpeta llamada ProgramasC ubi ada en el Es ritorio. En la gura 3.5 vemos
omo se efe tuan los pasos II-IV.
Figura 3.5: Pasos II, II y IV
En este aso, no hubo ningun problema en la ompila ión y se ha reado

un ar hivo eje utable y guardado en la misma arpeta que primero. . Para
eje utarlo es ribimos en la terminal ./primero.
El resultado de éste sen illo programa se muestran en la gura 3.6

3.1. C 59
Figura 3.6: Paso V
Como puede observarse, el resultado de este sen illo programa es imprimir

en la salida el mensaje mi primer programa.
3.1.2. Generalidades
Antes de ontinuar, ha emos unas observa iones generales y onven iones
en uanto a la forma en que debemos es ribir las instru iones de los programas
en el ar hivo fuente.
A los ar hivos on extensión .h se les llama ar hivos de en abezado (o

headers) que, al igual que el mismo programa en que se in luyen, son
ar hivos fuente por medio de los uales podemos aprove har algunas
deni iones e instru iones propor ionadas por el ompilador.
Estos ar hivos de en abezados ontienen deni iones e instru iones para

realizar diversas opera iones, por ejemplo, en algunos de estos denen
opera iones de entrada y salida (i/o) omo es el aso de stdio.h; otros
brindan deni iones de opera iones y fun iones matemáti as (math.h),
algunos más propor ionan instru iones para opera iones on ar hivos
o servi ios del sistema operativo, et . La razón de existir de éstos es
mantener mínimo el nú leo del lenguaje de programa ión C, agregándole
ara terísti as en fun ión de las ne esidades espe í as del programador.
La mayoría de los programas omenzarán on una o varias líneas on la

instru ión #in lude, que indi an al ompilador que in luya dentro del
programa, en la posi ión a tual, el ontenido del ar hivo de en abezado
que se ha espe i ado entre los símbolos <, >.
En el programa primero. la instru ión #in lude<stdio.h> ha e que

se in luya en nuestro programa la deni ion de las opera iones de entrada
(s anf) y salida (printf).
Los headers que usaremos on más fre uen ia son <stdio.h> (para entrada
y salida), <math.h> (propor iona fun iones matemáti as). Para ono er
las fun iones que propor iona ada uno de estos, y otros headers puede
onsultarse el APÉNDICE B: Bibliote a Estándar de [1℄.
Tal omo en el apítulo 2, vamos a sangrar las instru iones ( uando sea
ne esario) para fa ilitar la omprensión de los programas.
En general, los programas pueden ser muy omplejos, por lo que será
ne esario dividirlos en partes más pequeñas y manejables ono idas omo
fun iones. En este ontexto, entenderemos por fun ión a una se uen ia
de instru iones que tienen una tarea espe í a dentro del programa.
Cada programa es rito en este lenguaje debe tener al menos una fun ión,
la llamada fun ión (o programa) prin ipal. Se de lara omo se muestra
enseguida:
main(){
<instru iones>
return 0;
}
Más adelante, trateremos a detalladamente la manera en que se rean

y utilizan las fun iones, entre ellas la fun ión prin ipal.
Por el momento, basta saber que todos los programas omienzan su

eje u ión justamente en donde se en uentra la instru ion main(), y
que, en un mismo programa, no puede haber dos fun iones nombradas
main. Di ho de otra manera main es una palabra reservada. Para más
detalles revisar el apartado 3.1.8.
Al nal de ada una de las instru iones (salvo algunas omo p.e. los
#in lude< - - > y las senten ias de ontrol) es ne esario poner punto
y oma (;). En aso de no ha erlo, la ompila ión será fallida. El signo
de puntua ión ; es el delimitador de senten ias o instru iones en C.
3.1. C 61
Los programas a menudo pueden ser muy extensos, por lo que se ha e

asi imposible, in luso para el mismo programador, re ordar que papel juega
dentro del programa ada variable o in luso un fragmento de ódigo. Una
manera de remediar esta situa ión onsiste en es ribir omentarios en los que
se espe iquen algunos de los detalles más relevantes del programa. Existen
dos maneras de es ribir omentarios en los programas es ritos en C, y son las
siguientes:
Se indi a el omienzo de un omentario on el símbolo //. Todo el texto

es rito a partir de estas dos diagonales y hasta el nal de la línea se
onsidera omentario y es ompletamente ignorado por el ompilador de
C al realizar la tradu ión. A este tipo de omentarios se les ono e omo
omentarios unilínea.
Utilizamos /* y */ para indi ar el ini io y el nal, respe tivamente, de

un omentario en un ódigo es rito en este lenguaje de programa ión.
Tampo o tienen inuen ia estas líneas en la estru tura del ódigo. Son
sólo notas de y para quien lee el ódigo fuente. A estos se les llama
omentarios multilínea.
Es habitualmente útil el uso de los omentarios pues, permite omprender

on mayor fa ilidad la estru tura de un programa tanto para el programador
mismo omo para ualquier otra persona que lea ese programa. A menudo
los programadores in luyen un omentario al ini io del ódigo, en el que se
espe i an algunos datos del mismo programador para poder onta tarlo en
aso de que sea ne esario entender o modi ar el programa.
//Este es un omentario de una sóla línea

//Estas líneas de texto son ompletamente
//ignoradas por el ompilador de C
/*Esta es una forma de

es ribir omentarios
en varias líneas */
Note que no hemos es rito el delimitador de senten ias en C: ;. Esto porque

los omentarios no representan senten ias en C, simplemente son anota iones
para el programador.
3.1.3. Variables
C es uno de los lenguajes en los que es ne esario de larar e ini ializar
las variables que vayamos a utilizar dentro de un programa, indi andole al
ompilador sus nombres y sus tipos. El tipo de variable es diferente, de a uerdo
on el tipo de informa ión que ne esitemos alma enar, e indi a la lase de valor
que abe en el espa io de memoria reservado para ella, así omo las opera iones
que pueden realizarse on di ha variable.
El menor espa io de memoria que podemos manejar es un byte(8 bits).

En un bit puede alma enarse uno de entre dos valores (0 y 1), on dos bits
pueden alma enarse uno de entre 22 = 4 valores (00, 01, 10, 11, en binario, 0,
1, 2 y 3 en de imal). Así pues, on un byte pueden alma enarse un número
entero entre 0 y 28 − 1. Si se agrupan varios bytes, pueden alma enarse número
más grandes, in luso números de imales u otros tipos de datos.
Como ya sabemos, las dos opera iones que permitidas sobre las variables
son: onsultar su valor o darle algún valor.
En lo que on ierne a la onsulta del valor de una variable para ha er

uso de ese valor dentro del programa basta invo ar su nombre y utilizarla
para ha er las opera iones que ne esitemos. Si en ambio lo que queremos es
imprimir o mostrar este valor por medio de la pantalla será ne esario ha er
uso de la fun ión printf(), que es el equivalente a la palabra ESCRIBE que
hemos usado en el apítulo 2, pero este tema lo trataremos en la subse ión
Entrada y salida de datos despúes de expli ar uales son los tipos de datos
permitidos en C.
A ontinua ión veremos omo de larar e ini ializar variables, lo que orresponde
a dar algún valor a una variable.
De lara ión e ini ializa ión de variables

La de lara ión de una variable se ha e de la siguiente manera:
<tipo> <nombre de variable>;
Un identi ador o nombre de variable puede estar formado por letras y

números, pero nun a espa ios en blan o. El primer ara tér debe ser una letra
y la longitud del nombre puede ser ualquiera. Se distingue entre mayúsulas y
3.1. C 63
minús ulas. Las palabras reservadas de lenguaje son:
auto double int stru t

break else long swit h
ase enum register typedef
har extern return union
onst oat short unsigned
ontinue for signed void
default goto sizeof volatile
do if stati while
Ya se argumentó en el apítulo 2 la importan ia de ini ializar los valores
de nuestras variables antes de utilizarlas en ualquier proposi ión dentro del
programa. En C, la manera de ini ializar una variable al momento de de lararla
onsiste en es ribir
<tipo> <nombre de variable>=<valor ini ial>;
también es posible de larar e ini ializar varias variables del mismo tipo en
una misma línea
<tipo> <var1>=<valor1>, <var2>=<valor2>, <var3>=<valor3>;
3.1.4. Tipos de datos

Tipos de datos enteros
Los tipos de datos enteros en C, así omo su rango y número de bytes que
o upan, se presentan en la siguiente tabla:
Tipo Rango Bytes

har -128· · · 127 1
short int -32768· · · 32767 2
int -2147483648 · · · 2147483647 4
long int -2147483648 · · · 2147483647 4
long long int -9223372036854775808· · · 9223372036854775807 8
El tipo de dato har ha e referen ia a que se trata de un ará ter, que

puede ser una letra mayús ula, minús ula, un dígito o un ará ter espe ial. Si
un ará ter genuino del onjunto de ara teres en eje u ión se alma ena omo
tipo har, el valor alma enado en esta variable orresponde al ódigo entero
para éste ará ter, y es no negativo.
NOTA: C es un lenguaje débilmente tipi ado, i.e., las variables de diferentes

tipos pueden emplearse para representar datos de otros tipos, omo es el aso
de int y har.
Los tipos short int, long int y long long int pueden abreviarse, omo
short, long y long long respe tivamente.
A pesar de que podemos alma enar números enteros muy grandes, desde
menos nueve trillones dos ientos veinti tres mil tres ientos setenta y dos billones
treinta y seis mil o hos ientos in uenta y uatro millones sete ientos setenta
y siete mil o ho ientos o ho hasta nueve trillones dos ientos veinti tres mil
tres ientos setenta y dos billones treinta y seis mil o ho ientos in uenta y
uatro millones setes ientos setenta y siete mil o ho ientos siete, es posible
alma enar números enteros aún máyores. La restri ión que se ha e es que
pueden alma enarse solo números enteros sin signo, de larados anteponiendo
al tipo de dato la palabra reservada unsigned. Los rangos de los números que
pueden alma enarse se presentan enseguida:
Tipo Rango Bytes
unsigned har 0· · · 255 1
unsigned short int 0· · · 65535 2
unsigned int 0· · · 4294967295 4
unsigned long int 0· · · 4294967295 4
unsigned long long int 0· · · 18446744073709551615 8
Utilizando este modi ador, apli ado a long long int, el máximo número
entero que puede alma enar e es dies io ho trillones uatro ientos uarenta y
seis mil sete ientos uarenta y uatro billones setenta y tres mil sete ientos
nueve millones quinientos in uenta y un mil seis ientos quin e (positivo).
De nuevo, también están permitidas las abrevia iones unsigned short,

unsigned long y unsigned long long. Todos los tipos de datos enteros
representan valores on signo a menos que se espe ique lo ontrario.
Tipos de datos otantes

La omputadora no puede alma enar números irra ionales, sin embargo
podemos alma enar números on punto de imal, de ierto tamaño, a los que
ono emos omo otantes. En C hay tres tipos diferentes de ellos:
3.1. C 65
Tipo Máximo valor absoluto Bytes

oat 3,40282347 × 1038 4
double 1,7976931348623157 × 10308 8
long double 1,189731495357231765021263853031 × 104932 12
Los rangos de los valores de los diferentes tipos de datos enteros y otantes
en C pueden variar, en fun ión al onjunto Sistema Operativo-Computadora.
En el ar hivo de en abezado <limits.h> se denen onstantes para los tamaños
máximo y mínimo de los tipos de datos enteros. Para los tipos otantes, los
rangos pueden denirse on <oat.h>.
Como es natural suponer, para operar dos tipos de datos numéri os, estos
deben ser del mismo tipo. Por ejemplo, si queremos sumar dos variables, estas
deben ser de tipo (int, short int, oat, et .). Sin embargo, si es ribimos algo
omo lo siguiente:
int x=3;
float y=2.5;
x+y;
C realizará una onversión (implí ita): la variable int es onvertida a tipo oat
para poder efe tuar la opera ión indi ada, y el resultado es de tipo otante.
A este tipo de onversión se le denomina retipi a ión ( asting). En general,
si se operan dos (o más) variables numéri as de diferente tipo, se realiza la
opera ión, pre edida por la onversión de la(s) variable(s) uyo tipo es de
menos rango, al tipo de la variable de tipo on mayor rango.
Es posible también indi ar la retipi a ión de manera expí ita, anteponiendo

a ada variable el tipo de dato al que ha de onvertirse, por ejemplo:
float z=((float)3 - 3.14)*(float)87356;
indi a que, antes de efe tuar las opera iones indi adas, se realiza la onversión
de 3 y 87356 a tipo oat.
Tipos de datos booleanos

En C también podemos utilizar variables de tipo booleano, pero para esto
es ne esario in luir en la abe era <stdbool.h>. Como es sabido, una variable
de este tipo puede tomar uno de entre dos valores: true o false. También
podemos ha er referen ia a los valores booleanos omo 0 (false) y 1 (true), es

de ir, podemos es ribir:
bool bandera=false;
o bien
bool bandera=0;
Más generalmente, podemos denotar que una variable de tipo bool asignando
ualquier número distinto de ero a di ha variable, y ero para falso. Así,
bool bandera2=true;
es equivalente a
bool bandera2=5;
o ualquier otro número entero diferente de ero en lugar de 5.
Cuando reamos una nueva variable de tipo booleano, por omisión alma ena
el valor de verdad false, a menos que la ini ialemos nosotros mismos. Sin
embargo, es ampliamente re omedable ini ializarla nosotros mismos para evitar
ambugüedades.
3.1.5. Entrada y salida de datos

Para mostrar informa ión en la salida del sistema vamos a utilizar la
fun ión printf(), que estará disponible si in luimos el ar hivo de en abezado
<stdio.h>.
En su forma más simple nos permite imprimir una adena de ará teres,
printf(Mostrando ara téres en la pantalla.);
lo ual produ e la impresión, en la onsola misma, del texto en errado entre

omillas, uya fun ión es uni amente delimitar la adena de ará teres aunque
en la salida estas no apare en.
3.1. C 67
También se pueden imprimir otros tipos de datos, tales omo números

enteros o otantes. El primer argumento de la fun ión print es una adena de
formato, que es una adena en la que se espe í a el tipo de dato que se va a
imprimir, esto en errado ente omillas. El siguiente argumento es un dato del
tipo espe í ado en la adena de formato. Por ejemplo, onsidere las siguientes
instru iones:
int x=29;
printf( %d,x);
produ e la impresión del número x. La instru ión %d se es ribe para indi ar

que el tipo de dato que se va a imprimir es de tipo entero. A este tipo de
intru iones se les ono e omo ará ter de formato para impresión o le tura de
valores. En la tabla que apare e enseguida se muestran las mar as de formato
para imprimir datos enteros.
Tipo Cará ter de formato

har(número) %hhd
short %hd
int %d
long %ld
long long %lld
unsigned har %hhu
unsigned short %hu
unsigned %u
unsigned long %lu
unsigned long long %llu
NOTA: Los valores de tipo har pueden mostrarse en pantalla usando el

ará ter % o %hhd. La primera mar a muestra el valor omo un ará ter,
mientras que la segunda muestra su valor de imal (el ódigo ASCII del ará ter).
Para dar formato a la impresion de números enteros podemos utilizar los

siguientes modi adores:
Un número positivo: Reserva tantos espa ios omo espe i a el número

positivo, para representar el número que se va a imprimir y lo alinea a
la dere ha. Por ejemplo:
printf( %8d, 123);
produ e:
_____123
Un número negativo: Reserva tantos espa ios omo indi a el valor

absoluto de número, para representar el número que se va a imprimir.
Lo alinea a la izquierda, de la siguiente manera:
printf( %-8d, 123);
produ e:
123_____
Un número que empieza por ero: Tiene la misma fun ión que si se
antepone un número positivo, on la salvedad de que los espa ios que no
o upa el número, se rellenan on eros. Por ejemplo:
printf( %08d, 123);
produ e:
00000123
Esta op ión no está disponible para números negativos, es de ir, una

expresión omo la siquiente:
printf( %-08d, 123);
genera un error.
El signo +: Muestra explí itamente el signo del entero.

printf( %+8d, 123);
resulta en:
____+123
3.1. C 69
printf( %+-8d, 123);
en:
+123____
Note omo el uso del modi ador '+' redu e la antidad de posi iones
efe tivas utilizadas para la representa ión del número.
Los ará teres de formato de salida para los tipos de datos otantes se
muestran en la tabla siguiente:
Tipo Nota ión onven ional Nota ión exponen ial
oat %f %e
double %f %e
long double %Lf %Le
Al igual que los tipos de datos enteros, los otantes soportan modi adores
omo los siguientes:
Un número on punto de imal: La parte entera de este número tiene
el mismo efe to que en un tipo entero, mientras que la parte de imal
indi a uantos de imales del otante se mostrarán. Por ejemplo:
printf( %9.3f, 43.27);
da omo resultado
___43.270
El modi ador puede ser positivo o negativo ( omo en el aso de los

tipos enteros). También, para el aso en que el modi ador sea positivo,
puede anteponerse el número ero para rellenar on eros los espa ios no
o upados por el número en la impresión en pantalla. Por último, también
puede utilizarse signo + omo modi ador, para mostrar expli itamente
el signo del número otante que se imprime.
Un punto de imal seguido de un punto: Indi a la antidad de ifras
de imales se han de mostrar del número a imprimir. Por ejemplo:
printf( %.4f, 43.27);
da omo resultado
43.2700
Los modi adores expli ados en el aso anterior, también apli an en éste.
La instru ión printf(); nun a propor iona una nueva línea de manera
automáti a. Para obtener una nueva línea es ne esario es ne esario es ribir la
se uen ia \n en el lugar en que queramos la nueva línea. Está es una de las
instru iones que se ono en omo se uen ias de es ape.
Otras de las se uen ias de es ape más omunes son las siguientes:
Se uen ia de es ape Resultado

\n nueva línea
\t tabula ión horizontal
\v tabula ión verti al
\b retro eso
\r regreso de arro
\f avan e de forma
\a señal audible
\\ diagonal inversa
\? interroga ión
\′ apóstrofo
\ omillas
\ooo número o tal
\xhh número hexade imal
También es posible imprimir, a partir de una misma instru ión, diversos

valores o tipos de datos. Se ilustra on un ejemplo:
int x=65;
printf(Imprime:\n\t Entero: %04d\n y\n\t Flotante: %.5f\n, x, 3.1416);
Observe que, por ada vez que apare e un ará ter de formato en el primer
argumento del printf(), deben existir en los siguientes argumentos de esta
fun ión, datos del tipo espe i ado por ada uno de di hos ará teres, además,
3.1. C 71
deben oin idir en antidad y tipo pues de no ser así, la ompila ión no se
realizará exitosamente. En la segunda de las dos instru iónes que a abamos de
es ribir, en el primer argumento tenemos dos ará teres de formato, el primero
de tipo int y el segundo oat, por lo que es segundo y ter er argumento deben
gurar un entero y un otante, respe tivamente. Enton es el resultado de estas
instru iones es:
Figura 3.7: Resultado de las dos últimas instru iones presentadas
Es indispensable que la orresponden ia entre los ará teres de formato de

salida y los datos espe i ados en la fun ión printf() sea una orresponden ia
uno a uno.
Por otra parte, en lo que on ierne a la le tura de datos desde el te lado, es

ne esario indi arle al programa en que lugar de la memoria de la omputadora
ha de alma enar el nuevo valor que se está re ibiendo, por lo que se ha e
ne esario introdu ir un operador del que no hemos hablado antes: el operador
dire ión (&). La fun ión de este operador es devolver la dire ión de memoria
que está reservado para alma enamiento de una variable (a la que se apli a
di ho operador). Por ejemplo, onsideremos las instru iones:
int x;
printf(La dire ión de memoria de x es: %u, (unsigned)&x);
Observe que no se ha ini ializado la variable x, pues on el simple he ho

de de lararla se ha reservado un espa io de memoria para ella, y el valor que
se imprime por pantalla on la instru ión arriba es rita es pre isamente el

número orrespondiente al espa io reservado. Por lo que el resultado de las
líneas de ódigo anteriores es:
La dire ión de memoria de x es: 3219243036
In luso, aunque se ini iali e la variable x, el resultado será el mismo pues,

omo ya se dijo, lo que se está imprimiendo no es el ontenido de di ha variable,
sino el número que identi a al espa io en que está alma enada. Así, aunque
x ambie su valor, su dire ión seguirá siendo la misma. En otra omputadora
el resultado puede ser diferente debido a que la asigna ión del espa io de
memoria para las variables no la podemos ontrolar, además que depende
de la disponibilidad de espa io en el dis o duro de la omputadora. También
a laramos que la dire ión de memoria de una variable es de tipo unsigned,
razón por la que para imprimirla debemos utilizar el ará ter de formato %u, y
en aso de ser ne esario, ha er la onversión a tipo unsigned explí itamente.
Note que para imprimir, hemos indi ado la onversión a tipo unsigned de
manera explí ita.
Volviendo al tema de la le tura de datos desde el te lado, el ar hivo de

en abezado <stdio.h> nos propor iona la fun ión s anf(), y se emplea de la
siguiente manera:
/*Primero es ne esario de larar la variable en la que

se va a alma enar el número que se va a re ibir*/
int n;
//Ahora utilizamos la fun ión para la le tura de datos
s anf( %d, &n);
Observe que el primer argumento de s anf() es un ará ter de formato, en

este aso entero, mientras que el segundo argumento es la dire ión de memoria
de una variable de tipo entero.
Los ará teres de formato para la le tura de datos enteros son los mismos
que los que se utilizan on el printf(). Para la le tura de otantes, existe
una ligera diferen ia on los ara teres de formato para salida: el tipo double
utiliza el ará ter de formato %lf para le tura de datos (re uerde que el de
impresión era %l). Los tipos oat y long double emplean los mismos ará teres
para entrada y para salida.
3.1. C 73
Es de vital importan ia que el ará ter de formato y el tipo de la variable

uya dire ión se espe i a en la fun ión de le tura sean del mismo tipo. De
otra manera, al ompilar, obtendremos un mensaje de error. Sería in orre to
es ribir algo omo lo siguiente:
int w;
s anf( %f,&w);
float v;
s anf( %d,&v);
Otro error omún, onsiste en omitir el operador &, por ejemplo:

int n;
s anf( %d,n);
lo ual produ e también un error en la ompila ión.
Estamos ahora en posibilidades de es ribir un programa ompleto en C.
Programa 3.1.1. Tradu ión al lenguaje C del pseudo ódigo del ejemplo 2.1.2
#in lude<stdio.h>
main(){
int var_1, var_2, var_3;
printf(Introduz a un valor numéri o para var_1 \n);
s anf( %d,& var_1);
printf(Introduz a un valor numéri o para var_2 \n);
s anf( %d,& var_2);
var_3=var_1;
var_1=var_2;
var_2=var_3;
printf( %d,var_1);
printf(\n %d,var_2);
printf(\n);
return 0;
}
Al eje utar este programa obtenemos algo omo lo siguiente:
Figura 3.8: Resultado de la eje u ión del programa 3.1.1
El le tor puede intentar es ribirlo en menos líneas, on las observa iones

antes he has a er a de la fun ión printf().
La subse ión 3.1.11 presentaremos otras dos fun iones para le tura de
datos (espe í amente ará teres) in luidas en el ar hivo de en abezado <stdio.h>.
3.1.6. Operadores
Los operadores aritméti os en C son los mismos que se han dado en la
subse ión 2.1.3 de este texto. El operador módulo es apli able sólo a los tipos
de datos enteros.
La pre eden ia en la eje u ión de los operadores aritméti os en C se sujeta

a lo estable ido en las reglas de la aritméti a usual. De esta forma, produ tos y
o ientes tienen mayor pre eden ia que las adi iones y sustra iones. Operadores
de igual pre eden ia son evaluados de izquierda a dere ha onforme han sido
espe i ados en la expresión orrespondiente. En resumen:
*, /, % tienen la misma pre eden ia, y mayor que la de:
+, −.
3.1. C 75

Están permitidos también en este lenguaje de programa ión los operadores:
Tienen todos la misma pre eden ia y se aso ian de izquierda a dere ha.
Otros dos operadores de asigna ión ompuestos, uyo fun ionamiento se

expli o en la subse ión 2.1.3 son los operadores de in remento y de remento
unitarios
++
−−
respe tivamente. Pueden apli arse de manera preja o postja. Ambos son
de igual pre eden ia, y a su vez, de pre eden ia mayor que la de todos los
operadores aritméti os. También ++ y −− se aso ian de dere ha a izquierda.

Son los operadores de rela ión que se han men ionado en el apítulo anterior:
igual que: ==
menor que: <
mayor que: >
diferente que: ! =
Respe to a estos operadores solo resta men ionar que los operadores == y
! = tienen la misma pre eden ia y se aso ian de izquierda a dere ha. Por otra
parte, los uatro operadores restantes son de pre eden ia igual, y mayor que la
de ==. Además, los operadores de pre eden ias iguales se aso ian de dere ha
a izquierda.
Operadores lógi os
En la se ión 2.1.3 hemos hablado ya de los operadores:

En el lenguaje C, vamos a representarlos de la siguiente manera:
Conjun ión: &&
Disyun ión: ||
Nega ión: !
El operador de nega ión tiene pre eden ia mayor que la de la onjun ión.
La pre eden ia del operador disyun ión es menor a la de la onjun ión.
Resumen de los operadores, su pre eden ia y aso atividad

Antes de ontinuar, debemos men ionar que los operadores que hasta ahora
hemos presentado son solo algunos de los operadores que pueden utilizarse en
el lenguaje C. Nos limitamos a presentar úni amente los que serán de utilidad
para los propósitos de este texto.
En la siguiente tabla se muestran los operadores aritméti os, el operador de

asigna ión, los operadores de asigna ión ompuestos, operadores rela ionales y
lógi os que a abamos de men ionar, así omo la pre eden ia y la forma en que
se aso ian en aso de ser de la misma pre eden ia. Los operadores que guran
en la misma línea tienen la misma pre eden ia.
Operadores Aso iatividad

!, ++, −− dere ha a izquierda
*, /, % izquierda a dere ha
+, − izquierda a dere ha
<, <=, >, >= izquierda a dere ha
==, != izquierda a dere ha
&& izquierda a dere ha
|| izquierda a dere ha
=, +=, −=, *=, /=, %= dere ha a izquierda
3.1. C 77
Para modi ar el orden en que se apli an los operadores según la tabla

anterior, se utilizan los paréntesis omo signos de agrupa ión.
3.1.7. Estru tura general de un programa

La forma general de un programa es rito en C es la siguiente:
//De lara ión de los ar hivos de en abezado (headers)
//De lara ión de prototipos de fun iones
//De lara ión de variables globales
//Fun ión prin ipal

int main(void) { //Revisar en 3.1.8 el apartado referente a main()
<instru iones>
return 0;
}
//Defini ión de fun iones
Ya se abordó el tema de los ar hivos de en abezado en el la subse ión

3.1.2.
En lo que on ierne a las variables, éstas se lasi an, dependiendo de

el lugar en que se de laran, en dos grupos: variables lo ales y variables
globales.
Una variable lo al es aquella que se de lara dentro de alguna fun ión o
fragmento de ódigo, y sólo puede ser utilizada dentro de esa fun ión. Si se
invo a a una variable lo al desde otra fun ión o fragmento de ódigo que no es
en donde se ha de larado, el ompilador de C dete tará un error en el programa.
Por ejemplo, si de laramos una variable dentro de la fun ion prin ipal, sólo
podrá ser utilizada dentro de ésta fun ión main, y no en las otras fun iones
del programa, si es que las hay.
Por otra parte están las variables globales, que no se de laran dentro de
ninguna fun ión, sino después de de larar los prototipos de fun iones y antes
de la fun ión prin ipal del programa. Estas variables pueden utilizarse en
ualquiera, in luso en varias, de las fun iones de laradas en todo el programa.
Ya lo hemos men ionado en el apítulo Algoritmi a, pero no está por demás

de irlo de nuevo: debemos utilizar tantas variables omo sea ne esario, pero
tan po as omo sea posible.
A ontinua ión hablaremos de las fun iones: sus prototipos y la manera

en que deben de lararse (las fun iones).
3.1.8. Fun iones

Ya hemos men ionado antes que, en términos de programa ión en C, una
fun ión es una se uen ia de instru iones que tiene una tarea espe í a dentro
de un programa, la ual es identi ada a través de un nombre. Una fun ión
puede o no re ibir parámetros. Es posible también que una fun ión devuelva
algún dato.
La forma general de denir una fun ión es la siguiente:
<tipoDeDatoRegresado> <nombreDeFun ión>(<argumentos>){

<instru iones>
}
Y el prototipo de una fun ión así de larada es una expresión redu ida de
la de lara ión de una fun ión, en la que guran el identi ador de la fun ión,
sus argumentos y el tipo de valor que devuelve, sin in luir la deni ión de la
misma. Un prototipo de fun ión se enun ia de la siguiente manera:
<tipoDeDatoRegresado> <nombreDeFun ión>(<argumentos>);
Está permitido no de larar los prototipos de las fun iones, pero en tal
aso deben de lararse las deni iones de las fun iones antes de que aparez a la
fun ión main(), pues en aso de no ha erlo así la ompila ión será fallida. Sin
embargo, re omendamos denir las fun iones despúes del main() y de larar
los prototipos en el lugar que hemos indi ado, ya que esto permite tener una
visión general de la estru tura del programa y las fun iones que lo onforman
sin ne esidad de leer todo el ódigo.
3.1. C 79
Si la fun ión regresa algún dato, debe gurar entre las instru iones del
uerpo de la fun ión la proposi ión:
return <exp>;
donde <exp> es una variable del tipo indi ado por <tipoDeDatoRegresado>, o
bien una expresión que al ser evaluada resulta ser un valor del tipo di ho antes.
Si no queremos devolver algún tipo de dato, debemos indi arlo de manera

explí ita mediante el pseudo-tipo de dato void de la siguiente manera:
void <nombreDeFun ión>(<argumentos>){

<instru iones>
}
Al indi ar que el tipo de dato retornado es del pseudo-tipo de dato void,

lo que estamos indi ando es que no devolverá valor alguno.
En <argumentos> deben espe i arse los parámetros que ha de re ibir la

fun ión, indi ando explí itamente el tipo de dato de ada uno de los parámetros.
Cabe la posibilidad de que la fun ión no re iba argumento alguno, situa ión
en la ual basta es ribir:
<tipoDeDatoRegresado> <nombreDeFun ión>(){

<instru iones>
}
O bien:
<tipoDeDatoRegresado> <nombreDeFun ión>(void){

<instru iones>
}
También existen fun iones que no re iben ni devuelven datos. Dando lugar
a deni iones de fun iones on la forma:
void <nombreDeFun ión>(){

<instru iones>
}
o in luso indi ar explí itamente que no re ibe datos, ni retorna ningún dato:
void <nombreDeFun ión>(void){

<instru iones>
}
Note que en el aso en que una fun ión no retorna dato alguno, no hemos
omitido <tipoDeDatoRegresado> (hemos empleado el pseudo-tipo de dato
void). Si se omite por ompleto <tipoDeDatoRegresado> la fun ión retornará,
por omisión, datos de tipo int.
Para llamar a eje u ión a una fun ión basta es ribir:
nombreDeFun ión(<argumentos>);
También puede llamarse a una fun ión dentro de ella misma, lo que se
ono e omo re ursividad. Este es un tema a tratar en el urso Programa ión
II
La ventaja de utilizar fun iones es que podemos utilizarlas las ve es que

sean ne esarias sin ne esidad de volver a es ribir todo el ódigo que las dene.
Basta llamar a la fun ión de la manera antes expuesta, dando los parámetros
de forma ade uada tanto en antidad omo en tipo.
Una fun ión que regresa un valor de ierto tipo de dato, puede emplearse
omo di ho tipo de dato, por ejemplo, si tenemos una fun ión:
int uadrado(int x){

return x*x;
}
una expresión omo:
int w=( uadrado(10)-16)*5;

3.1. C 81
es orre ta, pues uadrado(10) es un número entero (int).
A la espe i a ión de los parámetros en la de lara ión de una fun ión se

le llama espe i a ión de parámetros formales, mientras que en la llamada a
eje u ión se le denomina espe i a ión de parámetros reales.
La fun ión main()

Es importante re ordar que ada programa debe tener una y sólo una
fun ión main. Además, todo programa omienza su eje u ión pre isamente
donde se en uentra la fun ión main.
Y ya que retomamos el tema de la fun ión main() abe men ionar que,
dado que en los programas presentados hasta ahora no hemos espe i ado
el tipo de dato que retorna esta fun ión, por lo que devuelve por omisión
datos de tipo entero (al igual que ualquier fun ión en la que no se espe i a
<tipoDeDatoRetornado>). Es por esta razón que no hay problema en in luir,
en su de lara ión de la fun ión rin ipal, la instru ión
return 0;
Es también orre to espe i ar que el tipo del dato que devuelve es entero,
int main(){
<instru iones>
return 0;
}
También puede omitirse sin problema alguno el return 0;
Para los programas siguientes tomamos la onven ión de de larar la fun ión
main() omo sigue:
int main(void){
<instru iones>
return 0;
}
Como ejemplo, onsideremos el siguiente programa, que es la implementa ión

en C del ejemplo 2.1.3:
Programa 3.1.2.
//De lara ión de ar hivos de en abezado
#in lude<stdio.h>
//Como no se define ninguna fun ión,no se de laran los prototipos
//Tampo o se tienen variables globales
int main(void){
printf(Este programa al ula el produ to de dos binomios
onjugados\n);
int a, b, ;
printf(Introduz a un valor para la variable a\n);
s anf( %d, &a );
printf(Introduz a un valor para la variable b\n);
s anf( %d, &b );
=(a + b)*(a − b);
printf(( %d+ %d)*( %d+ %d)= %d\n, a, b, a, b, );
printf(Fin del programa\n);
return 0;
}
//No se define ninguna fun ión
Ha emos notar que las dos primeras líneas es ritas dentro del main()
representan una úni a instru ión, pues omo hemos men ionado antes, el
delimitador de instru iones es el punto y oma. Evidentemente, la segunda
línea altera el sangrado de instru iones que hemos onvenido. Una manera de
remediarlo onsiste en utilizar los printf() que sean ne esarios, por ejemplo,
en lugar de es ribir un sólo printf() podemos es ribir:
printf(Este programa al ula el produ to de dos binomios);

printf( onjugados\n);
obteniendo el mismo resltado y, a la vez, fa ilitando la le tura del programa.

El le tor puede veri ar (implementando el programa) que es lo que su ede si
3.1. C 83
simplemente sangramos la segunda línea de la fun ión prin ial en el último

programa presentado (3.1.2). En los siguientes programas vamos a utilizar esta
segunda op ión.
Ahora vamos a implementar este mismo programa empleando una fun ión.
Programa 3.1.3.
#in lude<stdio.h>

int onjugado();
//De lara ión de variables globales

int a, b;

int main(void){
printf(( %d+ %d)*( %d+ %d)= %d\n, a, b, a, b, onjugado());
return 0;
}
//De lara ión de fun iones

int onjugado(){
int ;// es una variable lo al a la fun ión onjugado()
s anf( %d, &a );
s anf( %d, &b );
=(a + b)*(a − b);
return ;
}
Observe que el resultado de las dos implementa iones presentadas es el

mismo. La ventaja del segundo, omo hemos señalado antes es que podemos
utilizar la fun ión onjugado() tantas ve es omo queramos sin ne esidad de
es ribir nuevamente el ódigo que la dene, y podemos utilizarla ya sea en la

fun ión main o en alguna otra fun ión (in luso en ella misma).
Otra ventaja que propor iona la utiliza ión de fun iones, es que es más fá il
la le tura y omprensión del programa, así omo la modi a ión del mismo.
Por otra parte, no es re omendable utilizar variables globales, de he ho,

sugerimos emplear estri tamente variables lo ales, salvo situa iones en las que
se haga imperativo el uso de variables globales. Así que proponemos otra
solu ión, equivalente a las dos anteriores, en la que se utiliza una fun ión
pero no variables globales.
Programa 3.1.4.
#in lude<stdio.h>

int onjugado(int x, int y);

int main(void){
int a, b;
s anf( %d, &a);
s anf( %d, &b);
printf(( %d + %d)*( %d - %d)= %d\n,a,b,a,b, onjugado(a, b));
printf(Fin del programa);
return 0;
}

int onjugado(int x, int y){
int ;
=(x+y)*(x-y);
return ;
}
3.1. C 85
Más adelante, después de estudiar las estru turas de ontrol, retomaremos

el tema de las fun iones, presentando unos uantos programas un po o más
elaborados.

Ahora nos o uparemos de dar la sintaxis en el lenguaje de programa ión C,
de ada una de las estru turas de ontrol espe í adas en el apartado 2.2.1, así
omo la tradu ión a este lenguaje, de ada uno de los ejemplos presentados
allí.
A laramos que en este lenguaje de programa ión, sangrar las instru iónes
no es obligatorio, pero si re omendable on objetivo de fa ilitar la le tura y
omprensión de los programas. Cabe men ionar que existen lenguajes en los
que esto si es ne esario, pues no se pueden emplear las llaves ({, }) para
delimitar los bloques de instru iones de las senten ias de ontrol.
Senten ia if
El equivalente en C a la senten ia SI, es la instru ión if, y la de lara ión
se ha e de la siguiente manera:
if(< ondi ión>) {

<instru iones>
}
Cabe men ionar que si el bloque <instru iones > onsta de una sola
instru ión, pueden omitirse las llaves. A laramos que esto está permitido
ex lusivamente en el aso en que se debe eje utar una úni a instru ión ( on
la hipótesis de que se umple la ondi ión), pues en otro aso, el programa
podría omportarse de una manera no deseada.
Pasemos dire tamente a un ejemplo:

Programa 3.1.5. Ha er un algoritmo que re iba un número. Si éste es distinto
1
x
#in lude<stdio.h>
int main(void){
int a;
float b;
printf(Introduz a un número diferente de ero\n);
s anf( %d,&a);
if(a!=0){
//Note la onversión explí ita (float)a
b=1/(float)a;//0 bien b=1.0/a
printf(1/ %d = %f\n, a, b);
}
if(a==0){
printf(El número introdu ido no es válido\n);
}
printf(Gra ias por utilizar este programa\n);
return 0;
}
Antes de ontinuar, ha emos un par de observa iones:
i ) Aunque a es de tipo int, b se de lara otante, pues el resultado de

evaluar 1/a no ne esariamente es un número entero (de he ho, es entero
úni amente si a=1).
ii ) El resultado de la opera ión 1/a es entero (por ser osiente de dos

enteros) y se redondea a ero (para todo a>1). Posteriormente al ser
asignado a b se onvierte al tipo oat por lo que se imprime: 0.000000.
En ambio, indi ando la retipi a ión de a de forma explí ita, omo
se tiene un o iente de datos de tipo int y oat respe tivamente, se
efe túa automáti amente la retipi a ión del int 1 a tipo otante, y el
resultado es ahora un número de punto otante, el ual es asignado a b.
Otra manera de solu ionar éste problema onsiste en dar la instru ión
b=1.0/a en lugar de b=1/(float)a
Senten ia if-else
La senten ia ondi ional SI-DOM posee un equivalente en C, el if-else. La
forma general de de lararla es:
3.1. C 87
if(< ondi ión>){

<instru iones1>
}
else{
<instru iones2>
}
Al igual que el uerpo del if, en el else pueden omitirse las llaves si
<instru iones2> onsta de una úni a senten ia.
Ahora daremos una solu ión alternativa a la del programa 3.1.5, empleando
la senten ia if-else.
Programa 3.1.6. Equivalente al programa 3.1.5.
#in lude<stdio.h>
int main(void){
int a;
float b;
printf(Introduz a un número diferente de ero\n);
s anf( %d,&a);
if(a!=0){
//Note la onversión explí ita (float)a
b=1/(float)a;
printf(1/ %d = %f\n, a, b);
}
else{
printf(El número introdu ido no es válido\n");
}
printf(Gra ias por utilizar este programa\n);
return 0;
}
Note que este ódigo no tiene grandes diferen ias on el programa 3.1.5.
Lo úni o que se ha modi ado es if(a!=0) por else. Sin embargo, el ujo
del programa presenta diferen ias importantes, tal omo ya se mostró en la
subse ión 2.1.1.
El siguiente ejemplo es un po o más elaborado:

Programa 3.1.7. Ha er un programa que re iba dos números m, n y que

posteriormente diga si m es mayor, menor, o igual que n.
#in lude<stdio.h>
int main(void){
int m, n;
printf(Introduz a un valor numéri o para la variable m\n);
s anf( %d,&m);
printf(Introduz a un valor numéri o para la variable n\n);
s anf( %d,&n);
if(m>n){
printf( %d es mayor que %d\n, m, n);
}
else{
if(m<n){
printf( %d es menor que %d\n, m, n);
}
else{
printf( %d es igual a %d\n, m, n);
}
}
return 0;
}
Este mismo programa pudo haberse implementado utilizando úni amente

la senten ia if y obtener los mismos resultados, pero omo ya men ionamos
en el apítulo de algorítmi a, es más e iente utilizando la senten ia else (en
aso de que sea ne esaria).
Senten ia else if
La senten ia SI-DOM puede pensarse omo un aso parti ular de otra de las
senten ias de ontrol estudiadas en el apítulo de algoritmi a: el SI-(DOM-SI).
La sintáxis para el SI-(DOM-SI)) en C es else if, y la manera de de lararse se
presenta enseguida:
3.1. C 89
if(< ondi ión1>){

<instru iones1>
}
else if(< ondi ión2>){
<instru iones2>
}
.
.
.
else if(< ondi iónN-1>){
<instru ionesN-1>
}
else{
<instru ionesN>
}
El programa 3.1.7 puede rees ribirse de la siguiente manera:
Programa 3.1.8. Equivalente al programa 3.1.7 utilizando else if
#in lude<stdio.h>
int main(void){
int m, n;
printf(Introduz a un valor numéri o para la variable m\n);
s anf( %d,&m);
printf(Introduz a un valor numéri o para la variable n\n);
s anf( %d,&n);
if(m>n){
printf( %d es mayor que %d\n, m, n);
}
else if(m<n){
printf( %d es menor que %d\n, m, n);
}
else{
printf( %d es igual a %d\n, m, n);
}
return 0;
}
Senten ia swit h
SWITCH, la última de las estru turas de ontrol ondi ionales presentadas
en el apartado 2.2.1 no existe para todos los lenguajes de programa ión.
Afortunadamente en C si existe, aunque en realidad es muy similar a else
if. La palabra reservada para esta senten ia es swit h. Se utiliza del siguiente
modo:
swit h(<variable>){
ase < 1>:{
<instru iones1>
break;
}
ase < 2>:{
<instru iones2>
break;
}
ase < 3>:{
<instru iones3>
break;
}
.
.
.
ase < K>:{

<instru ionesK>
break;
}
default{
<instru iones>
}
}
El siguiente es el algoritmo en C del ejemplo propuesto para esta senten ia

en la parte de algoritmi a.
Programa 3.1.9. Implementa ión del algoritmo del ejer i io 2.2.5

3.1. C 91
//Este programa nos di e si una letra (te leada por el usuario)

//es vo al o onsonante
#in lude<stdio.h>
int main(void){
har letra;
printf(Te lee una letra(minús ula) del abe edario\n);
s anf( % , &letra);
swit h(letra){
ase 'a':{
printf(Es vo al\n);
break;
}
ase 'e':{
printf(Es vo al\n);
break;
}
ase 'i':{
printf(Es vo al\n);
break;
}
ase 'o':{
printf(Es vo al\n);
break;
}
ase 'u':{
printf(Es vo al\n);
break;
}
default:{
printf(Es onsonante\n);
}
}
return 0;
}
NOTA: Pueden omitirse sin problema alguno los paréntesis que delimitan
las se uen ias de instru iones que ha de eje utarse en ada ase.
En el aso de programas omo este, en el que para diferentes asos se

efe tuan la mismas instru iones, puede abreviarse el ódigo del programa
expresando asos múltiples de una manera simpli ada, omo se muestra
enseguida:
Programa 3.1.10.
//Este programa nos di e si una letra (te leada por el usuario)

//es vo al o onsonante
#in lude<stdio.h>
int main(void) {
har letra;
printf(Te lee una letra (minús ula) del abe edario\n);
s anf( % , &letra);
swit h(letra) {
ase 'a':
ase 'e':
ase 'i':
ase 'o':
ase 'u':{
printf(Es vo al\n);
break;
}
default: {
printf(Es onsonante\n);
}
}
return 0;
}
3.1.10. Estru turas de ontrol iterativas

Ahora es momento de hablar brevemente de las tres estru turas de ontrol
de repeti ión: while, do-while y for, estudiadas las tres en el apítulo anterior,
3.1. C 93
razón por la que limitaremos a dar úni amente la sintaxis de ada una, así
omo uno o dos ejemplos de programas en los que se emplea ada una de ellas,
sin detenernos a expli ar omo es que fun iona ada uno de estos i los, pues
la expli a ión se ha dado en la subse ión 2.2.2.
Senten ia while
while es una de las tres senten ias de ontrol iterativas, y es el equivalente
a la senten ia MIENTRAS que se ha presentado ya en la se ión anterior. Así
pues, para utilizarla se ha e una de lara ión del siguiente tipo:
while(< ondi ión>) {

<instru iones>
}
Y ahora presentamos la tradu ión del ejemplo 2.2.6 a lenguaje C.

Programa 3.1.11. Ha er un programa que lea una valor entero no negativo
y que posteriormente es riba en pantalla los valores de 0 hasta di ho número
en orden de re iente.
#in lude<stdio.h>
int main(void){
int n;
printf(Este programa imprime los enteros de 0 a n en orden);
printf( des endente\n);
printf(Introduz a un valor entero y no negativo para n\n);
s anf( %d,&n);
while(n>=0){
printf(" %d\n,n);
n−−;
}
return 0;
}
Senten ia do-while
do-while es la variante de la senten ia while. Di ho de otra manera,
do-while es la senten ia que orresponde al HACER-MIENTRAS del que ya se
ha dado la expli a ión en el apítulo de algoritmi a. Re ordamos simplemente

que on esta instru ión se garantiza la eje u ión del uerpo del i lo al menos
una vez.
Para utilizarlo, se ha e la de lara ión de la siguiente forma:
do{
<instru iones>
} while(< ondi ión>)
Inmediatamente pasamos a la implementa ión del ejemplo presentado en

la se ión de algoritmi a, para esta senten ia:
Programa 3.1.12. Propuesta de solu ión al ejemplo 2.2.6 on do-while

#in lude<stdio.h>
int main(void){
int n;
printf(Este programa imprime los enteros de 0 a n en);
printf( orden des endente\n);
printf(Introduz a un valor entero y no negativo para n);
s anf( %d, &n);
do{
printf( %d\n, n);
n−−;
}while(n>=0);
return 0;
}
Este programa no es pre isamente equivalente al programa 3.1.11, pues

omo hemos men ionado, se eje uta el uerpo del i lo al menos una vez (antes
de veri ar la ondi ión). El siguiente programa si produ e exa tamente los
mismos resultados, para ualquier número, que el programa 3.1.11:
3.1. C 95
Programa 3.1.13. Pograma equivalente al algoritmo de 3.1.11.
#in lude<stdio.h>
int main(void){
int n;
printf(Este programa imprime los enteros de 0 a n en);
printf( orden des endente\n);
printf(Introduz a un valor entero y no negativo para n);
s anf( %d, &n);
if(n>=0){
do{
printf( %d\n, n);
n−−;
}while(n>=0);
}
return 0;
}
El le tor puede es ribir ambos ódigos y eje utarlos para ver que en efe to,
los resultados varían ligeramente.
Senten ia for
Por último, la senten ia de ontrol iterativa for orresponde a la instru ión
PARA del apítulo anterior. Debe de espe i arse así:
for(<opera ión ini ial>;< ondi ión>;<opera ión de varia ión>){

<instru iones>
}
El siguiente es un ejemplo en el que se ilustra omo se implementa dentro

de un programa:
Programa 3.1.14. Ha er un algoritmo que lea un número entero no negativo
y que es riba en pantalla el fa torial de di ho número.
#in lude<stdio.h>
int main(void){
int x=1,n;
printf(Este programa al ula el fa torial de un número\n);
printf(Introduz a un valor entero no negativo\n);
s anf( %d,&n);
if(n>1){
int i;
for(i=2;i<=n;i++){
x=i*x;
}
printf( %d, x);
}
else if(n==0 || n==1){
printf( %d, x);
}
else{
printf(El número introdu ido debe ser no negativo);
}
printf(Fin del programa);
return 0;
}
Observe que la variable i que se emplea para espe i ar los parámetros

de la senten ia for ha sido de larada antes de emplearla por primera vez.
En general, la(s) variable(s) que se utilizan en la espe i a ión del for deben
de lararse antes de utilizar ésta senten ia iterativa.
En el apartado 2.2.2 de este texto men ionamos también que es posile

de larar un i lo for espe i ando en él múltiples opera iones de ini ializa ión,
múltiples opera iones de varia ión y/o ondi iones omplejas. Los programas
siguientes son las tradu iones a C, orrespondientes a los ejemplos presentados
on la senten ia for.
3.1. C 97
Programa 3.1.15. Programa que al ula al suma de los primeros números

enteros positivos.
#in lude<stdio.h>
int main(void){
int n, x=0, i, j;
printf(Intoduz a un número no negativo\n);
s anf( %d,&n);
for(i=1,j=n;j>=1;j−−,i++){
x=x+i+j;
}
x=x/2;
printf(La suma es igual a %d \n, x);
return 0;
}
En el siguiente programa se presenta una variante de este último programa

en la que no se de lara la opera ión de ini ializa ión dentro de los argumentos
del for:
Programa 3.1.16.
#in lude<stdio.h>
int main(void){
int n, x=0, i=1, j;
printf(Intoduz a un número no negativo\n);
s anf( %d,&n);
j=n;
for( ;j>=1;j−−,i++){
x=x+i+j;
}
x=x/2;
printf(La suma es igual a %d \n, x);
return 0;
}
Note que la ini ializa ión de la variable j se realiza una vez que se ha
leido el valor de n. De no ha erlo así, por ejemplo, asignar j=n antes de leer n
de obtendrán resultados in orre tos.
Programa 3.1.17.
#in lude<stdio.h>
#in lude<stdbool.h>
int main(void){
int n,i,j;
bool B=true;
printf(Introduz a un número no negativo);
s anf( %d, &n);
for(i=1, j=1; j<500*i*i & B; i++, j=2*j+1){
if(i*i+j*j>=n){
B=0;
}
}
printf(Hola %d \n %d \n i2 +j 2 <n\n, i, j);
printf(Fin del programa");
return 0;
}
Un problema on repeti iones

En la subse ión 2.2.2 hemos presentado un problema uya solu ión impli a
la repeti ión de un fragmento de ódigo una antidad determinada de ve es.
lo men ionamos enseguida:
Ejemplo 3.1.1. Con un grupo de 10,000 ani as se forma una pirámide

de base uadrada, on una úni a ani a en su vérti e superior y un número
uadrado perfe to de ellas en ada etapa. ¾Cúantas ani as sobrarán?
A ontinua ión presentaremos la tradu ión al lenguaje C, de ada uno de

los tres programas propuestos omo solu ión a di ho problema:
3.1. C 99
Programa 3.1.18. Implementa ión de la solu ión del ejemplo 2.2.9 empleando
while(MIENTRAS)
la senten ia
#in lude<stdio.h>
int main(void){
int x=0, y=0, i=1, k=0;
printf(Con un grupo de 10,000 ani as se forma una pirámide);
printf( de base uadrada, on una úni a ani a en su vérti e);
printf( superior y un número uadrado perfe to de ani as)
printf( en ada etapa. ¾Cuántas ani as sobrarán?);
while(k<10000){
k=k+i*i;
i++;
if(k<10000){
y++;
x=k;
}
}
printf(El número de apas es: %d,y);
printf(Las ani as sobrantes son: %d, 10000-x);
return 0;
}
la senten ia do-while(HACER-MIENTRAS)
#in lude<stdio.h>
int main(void){
int x=0, y=0, i=1, k=0;
do{
k=k+i*i;
i++;
if(k<10000){
y++;
x=k;
}
}while(k<10000);
printf(El número de apas es: %d,y);
printf(Las ani as sobrantes son: %d, 10000-x);
return 0;
}
for(PARA)
la senten ia
#in lude<stdio.h>
int main(void){
int x=0, y=0, i, k;
for(k=0, i=1;k<10000;i++){
k=k+i*i;
if(k<10000){
y++;
x=k;
}
}
printf(El número de apas es %d,y);
printf(Las ani as sobrantes son %d, 10000-x);
return 0;
}
3.1. C 101
3.1.11. Arreglos
Un ve tor, omo ya sabemos, ontiene elementos de un mismo tipo (no
puede tener, por ejemplo, elementos de tipo int y oat a la vez). Los arreglos
unidimensionales se de laran en C de la siguiente manera:
<tipoDeDato> <nombreDelVe tor>[<tamaño>℄;
donde <tamaño> es un número entero positivo. En el siguiente ódigo reamos

un ve tor uyos elementos son los números de 0 a 9:
int v1[10℄={0,1,2,3,4,5,6,7,8,9};
Podemos también ha er lo anterior on ayuda del i lo for

//de laramos a la vez un ve tor(de enteros) y un número entero
int v1[10℄, i=0;
//Con el sig. i lo ini ializamos los elementos del ve tor
for( ; i<10;i++){
v1[i℄=i;
}
Es un error suponer que al rear un ve tor, éste está va ío.
Debe tenerse espe ial uidado en no salirse del rango de las entradas
del ve tor, pues el ompilador no nos muestra un error si intentamos a eder
(y por ejemplo, imprimir) un elemento que se en uentra en una posi ión
que sobrepasa los límites de la deni ión del ve tor, i.e, i>=<tamaño>. Por
ejemplo:
printf(El ve tor reado es:);

for(i=0 ; i<15; i++) {
printf( %d,, v1[i℄);
}
printf(℄\n);
Se obtiene un resultado omo el siguiente:
Figura 3.9: A ediendo a valores no válidos de int v1
Observe que los últimos 4 elementos no los hemos denido nosotros, y de

he ho, no son elementos del ve tor (v1 tiene sólo 10 elementos).
Un error muy omún onsiste pre isamente en a eder erronéamente a los

elementos de un ve tor, por ejemplo:
for(i=1, i<=10, i++) {

printf( %d,, v[i℄);
}
Lo ual no sería mar ado omo error por el ompilador, pero evidentemente
es in orre to, pues los elementos impresos no son los que forman a v1. Es
por esto que, dado que C no tiene veri a ión en términos de validar que
úni amente se usen las posi iones de laradas, el programador debe tener sumo
uidado, pues en aso de salirse de los rangos del arreglo, estaría invadiendo
espa ios de memoria ajenos, pudiendo ondu ir esto a obtener omportamientos
inesperados.
Por otra parte, es posible no utilizar todos los elementos o entradas de un

ve tor. Así, si hemos de larado un ve tor on 100 entradas podemos ini ializar
3.1. C 103
y/o utilizar sólo las que ne esitemos (por ejemplo, 50), aunque hay que tener
uidado de no utilizar los elementos del ve tor de los que des ono emos su
ontenido, para evitar omportamientos anormales en nuestros programas.
Ahora presentamos un programa en el que se rea un ve tor de un tamaño

determinado por el usuario y que además los elementos del ve tor son también
introdu idos desde el te lado:
Programa 3.1.21.
#in lude<stdio.h>
int main(void) {
int tam, i;
printf(Introduz a entero y no negativo para el tamaño);
printf( del ve tor.\n);
s anf( %d, &tam);
int v[tam℄;
for(i=0; i<tam; i++) {
printf(Introduz a un número entero para la);
printf( entrada v[ %d℄ del ve tor v\n, i);
s anf( %d, &v[i℄);
}
printf(El ve tor leído desde el te lado es: v=[);
for(i=0; i<tam; i++) {
printf( %d,, v[i℄);
}
printf(℄);
return 0;
}
En el sentido estri to, no existe e el lenguaje de programa ión C, un tipo

de dato elemental para las adenas (se uen ias) de ará teres. En su lugar,
lo que se ha e es utilizar arreglos de ará teres, es de ir, en C una adena de
ará teres es un ve tor uyos elementos son ará teres. Ahora que ya sabemos
rear ve tores en C, podemos introdu ir las fun iones gets() y get har()
uyas deni iones se en uentran en el ar hivo de en abezado <stdio.h>
gets(): Esta fun ión nos sirve para obtener una adena de ará teres
desde el te lado. Retorna adena si es realizada on éxito. Un ejemplo

de su uso:
Programa 3.1.22. Uso de la fun ión gets()
#in lude<stdio.h>
int main(void) {
har texto[20℄;
printf(Es riba una ora ion de a lo más);
printf( 20 ará teres:\n);
gets(texto);
printf(\nTexto obtenido \ %s\\n, texto);
return 0;
}
Aqí puede su eder que no se o upen todos los espa ios disponibles del
ve tor, por de ir algo, que se introduz an úni amente 10 ará teres,
lo ual no ausará oni to alguno. En ambio, si se introdu e una
adena uya lóngitud rebasa el tamaño del ve tor destinado para el
alma enamiento, se produ e un error:
Figura 3.10: Viola ión del segmento al utilizar gets()
get har(): Esta una fun ión es omo un aso parti ular de gets(), ya
que sirve para leer desde el te lado un sólo ará ter. Considéremos el
siguiente ejemplo:
Programa 3.1.23. Uso de get ahr()

3.1. C 105
#in lude<stdio.h>
int main(void){
har letra1, letra2;
printf(Presione dos letras y pulse Intro: );
letra1 = get har();
letra2 = get har();
printf(Cará teres re ibidos: );
put har(letra1);
printf( y % \n, letra2);
return 0;
}
Antes que nada, observe que se ha utilizado la fun ión put har() por
primera vez en éste texto. Ésta sirve para imprimir ará teres(sólo uno
por ada vez que se emplea di ha fun ión). En la siguiente gura se
muestra la eje u ón de éste programa:
Figura 3.11: Uso de get har()
La fun ión get har() lee ará ter a ará ter, y no se analiza lo que
hemos te leado hasta que se pulsa Intro. Si te leamos varias letras, la
primera vez que usemos get har nos dirá ual era la primera, la siguiente
vez que se utili e nos dirá ual fue la segunda letra y así su esivamente.
En el ejemplo que presentamos, si te leamos más de dos ará teres, sólo

el primero y segundo serán alma enados (porque se usa get har() dos
ve es), mientras que ualquiere otro ará ter que se te lee después será
ignorado (no se guardará), aún uando se te lee antes de pulsar Intro.
Intro uenta omo ará ter.
Ahora to a turno a hablar un po o a er a de matri es. Se denen de una

manera muy similar a omo se de laran los ve tores:
<tipoDeDato> <nombreDeMatriz>[<numFilas>℄[<numColumnas>℄;
donde <numFilas> y <numColumnas> son un números enteros positivos. En

el siguiente programa se rea una matriz de tamaño 5
Programa 3.1.24.
#in lude<stdio.h>
int main(void) {
int mat[5℄[4℄,i, j;
//Asignamos las entradas de la matriz
for(i=0 ;i<5 ; i++) {
for(j=0; j<4; j++) {
mat[i℄[j℄=0;
}
}
//Imprimimos los elementos de la matriz
printf(Los elementos de la matriz son:\n\n);
for(i=0 ;i<5 ; i++) {
for(j=0; j<4; j++) {
printf( %d\t,mat[i℄[j℄);
}
printf(\n);
}
return 0;
}
También es fá il obtener una matriz propor ionada por el usuario, on

un programa omo el siguiente:
3.1. C 107
Programa 3.1.25.
#in lude<stdio.h>
int main(void) {
int m, n, i, j;
printf(Para rear un matriz de números flotantes\n);
printf(indique en número de filas);
s anf( %d, &m);
printf(y el número de olumnas);
s anf( %d, &n);
float matriz[m℄[n℄;
//Leemos las entradas de la matriz
for(i=0 ;i<m ; i++) {
for(j=0; j<n; j++) {
printf(Introduz a el elemento de la ");
printf(posi ión M[ %d℄[ %d℄, i, j);
s anf( %f, &matriz[i℄[j℄);
}
}
//Imprimimos los elementos de la matriz
printf(Los elementos de la matriz son:\n\n);
for(i=0 ;i<m ; i++) {
for(j=0; j<n; j++){
printf( %f\t,matriz[i℄[j℄);
}
printf(\n);
}
return 0;
}
De manera análoga se puede generalizar a arreglos de tres o más dimensiones,

aunque su uso no es muy omún.
3.1.12. Más a er a de fun iones

Ahora que ya sabemos implementar las diversas estru turas de ontrol, es
momento de retomar el tema de las fun iones, así que presentamos algunos
ejemplos de programas en los que guran tanto fun iones omo estru turas de
ontrol.
Programa 3.1.26.
//Este programa nos di e si un número es par o impar

#in lude<stdio.h>
#in lude<stdbool.h>
//De lara ión de prototipos

bool par(int x);

int main(void){
int n;
printf(Introduz a un número entero no negativo);
s anf( %d, &n);
if(par(n)){
printf(Es par);
}
else{
printf(No es par);
}
return 0;
}

bool par(int x){
if(x %2==0){
return 1;
}
else{
return 0;
}
}
Basados en este programa, ha emos otro para veri ar si un número es

múltiplo de 6:
Programa 3.1.27.
3.1. C 109
//Programa para verifi ar si un número es múltiplo de seis

#in lude<stdio.h>
#in lude<stdbool.h>
//De lara ión de prototipos

bool par(int x);
bool ter era(int x)
bool sexta(int x);

int main(void){
int n;
printf(Introduz a un número entero no negativo);
s anf( %d, &n);
if(sexta(n)){
printf( %d es divisible por 6, n);
}
else{
printf( %d es no divisible por 6, n);
}
return 0;
}

//Esta fun ión nos di e si un número es par
bool par(int x){
if(x %2==0){
return 1;
}
else{
return 0;
}
}
//Esta fun ión nos di e si un número es múltiplo de tres

bool ter era(int x){
if(x %3==0){
return 1;
}
else{
return 0;
}
}
//Esta fun ión nos di e si un número es divisible por 6

bool sexta(int x){
if(par(x) & ter era(x)){
return 1;
}
else{
return 0;
}
}
Programa 3.1.28.
Programa 3.1.29.
3.2. JAVA 111
3.2. Java
JavaT M es un lenguaje de programa ión que entra en la ategoría de los
lenguajes que se ompilan a ódigo intermedio, y fue desarrollado por Sun
Mi rosystems In . R empresa que, ha e po o fue omprada por Ora le, la ual
es a tualmente la en argada de la espe i a ión de este lenguaje. Existe una
variante de Java llamada OpenJava, que no es más que Java tomado de la
última versión de Java uando era de ódigo abierto y a partir de ella la
omunidad sigue parti ipando en el desarrollo del lenguaje. En el presente
texto vamos a utilizar Java propor ionado por Ora le, y re omendamos no
utilizar OpenJava, pues si ompilamos un programa en OpenJava posiblemente
no fun ione la eje u ión del programa en una omputadora on Java de Ora le.
El JDK (Java Development Kit) es el onjunto bási o de herramientas

para desarrollar apli a iones de Java y es de dominio públi o. Puede obtenerse
desde la página web:
http://www.ora le. om/te hnetwork/java/javase/downloads/index.html
Éste onsta de un ompilador y una máquina virtual, a saber la JVM

(Java Virtual Ma hine), entre otras osas. El JDK no posee un entorno de
desarrollo integrado, pero es su iente para poder es ribir, ompilar y eje utar
un programa en Java. Puede instalarse fá ilmente desde los sistemas operativos
Unix & Ma OS X.
Por ejemplo en el S.O. Ubuntu para veri ar si ya está instalado el ompilador

de java, es ribimos en una terminal la instru ión:
java
Si ya está instalada, nos mostrará informa ión. En aso ontrario nos noti a
que no está instalado y allí mismo nos redire iona a la instala ión del mismo.
Otra alternativa es ir al entro de software de Ubuntu,...
Con la instru ión
java -version
en la terminal, obtendremos informa ión a er a de la versión de Java que

tenemos instalada. Debe tenerse uidado de utilizar la misma versi« de Java,
ya que pueden existir iertas diferen ias entre las versiones, esto es, abe la
posibilidad de que un programa es rito en una omputadora on determinada
versión de Java no pueda eje utarse en una máquina on una versión anterior
(de Java).
3.2. JAVA 113
También existe el JRE (Java Runtime Enviroment), que es sólo la máquina

virtual, sin ningún omponente de desarrollo ( ompilador). Éste es útil uando
queremos úni amente eje utar, no ompilar o re- ompilar, un programa que
ya está se en uentra en ódigo intermedio.
Para rear un programa, las instru iones pueden es ribirse en un editor de

textos simple y posteriormente ser ompilados a ódigo intermedio. Finalmente,
para eje utarse son intérpretados por la JVM. A grandes rasgos, este pro eso
se ilustra en la gura 3.12.
Figura 3.12: Pro eso de ompila ión (java ) y eje u ión (java) de un programa en Java
Re al amos que es indispensable que esté instalado el ompilador de java

(in luido en el JDK) y la JVM (disponible si se ha instalado el JDK o el JRE).
Java es un lenguaje de propósito general, no sólo sirve para programar

applets (pequeñas apli a iones eje utables en la páginas HTML, siempre y
uando el navegador soporte Java) omo se reía anteriormente, sino que
también pueden programarse apli a iones independientes omo en ualquier
otro lenguaje. En otras palabras, a través de Java es posible rear tanto applets,
a ser eje utados en el ontexto de un navegador web, omo apli a iones, que
pueden ser eje utadas en la omputadora.
3.2.1. Eje u ión de un programa

Aunque para efe tos de este urso vamos a emplear el IDE (Entorno de
Desarrollo Integrado) Netbeans R , a ontinua ión vamos a mostrar, vía un
ejemplo, la manera de ompilar y eje utar un programa de la manera tradi ional,
desde la terminal. Por el momento no vamos a expli ar el signi ado de las
líneas de ódigo es ritas en éste programa, ni la estru tura del mismo, vamos
a entrarnos úni amente en omo eje utarlo.
Primero veri amos que se en uentre instalado el JDK, de no ser así, es

indispensable instalarlo.
A ontinua ión es ribimos el ódigo fuente en algún el editor. El que se

muestra en la gura 3.13 se es ribió en gedit del S.O. Ubuntu, pero en general,
el ódigo puede es ribirse en ualquier editor de textos, y ser guardado on
extensión .java.
Figura 3.13: Código fuente en Java
En este lenguaje, el nal de ada instru ión se indi a on punto y oma.
Antes de ontinuar, llamaremos lase (se dene lo que es una lase en

el apartado 3.2.4) prin ipal a la que ontiene la de lara ión
publi stati void main(String[℄ args) {

<instru iones>
}
3.2. JAVA 115
Debe existir una y sólo una lase pri ipal, y es en la que omienza la
eje u ión del programa. Más pre isamente el programa omienza a eje utarse
en donde se en uentra el main(). Es onveniente señalar que, si bien no es
una regla sintá ti a, es una onven ión generalmente a eptada que los nombres
de las lases omien en oon letra mayús ula, mientras que los de ualquier
otro omponente ini ien on minús ula (Se detallan éstas reglas en ??). El
seguimiento de esta onven ión, onere a los programas una más fá il le tura
por parte del programador.
También es importante men ionar que el ar hivo que ontenga una lase
denido omo publi , debe imperativamente tener el mismo nombre que
di ha lase. Esta misma regla apli a para el aso de que una lase ontenga en
su interior el método main(). Los modi adores publi , private y stati
serán abordados en 3.2.5. El nombre de esta lase prin ipal debe omenzar
forzosamente on mayús ula, al igual que ualquier otra lase. Por otra parte,
los ar hivos .java deben guardarse imperativamente on el mismo nombre que
la lase uya deni ión ontienen.
En este ejemplo la lase Hola es la lase prin ipal, es por ello que el ódigo
se alma enó (en el es ritorio de la omputadora) on el nombre Hola.java.
Ahora, abrimos una terminal, a edemos a la ubi a ion de Hola.java y

es ribimos la instru ión:
java Hola.java
Como resultado de la instru ión anterior, y en aso de que la ompila ión

no produz a errores (la ausen ia de mensajes de error, impli a ne esariamente
una ompila ión exitosa), se habrá reado y alma enado un ar hivo llamado
Hola. lass, el que es eje utado por la JVM al dar la instru ión:
java Hola
El resultado de la eje u ión de este programa se muestra en la gura 3.14:

Figura 3.14: Resultado del ódigo es rito en Hola.java
Como puede observarse, el resultado de este programa es mostrar en la

onsola el mensaje
hola, mundo.
Para efe tos de éste texto vamos a utilizar el Entorno de Desarrollo Integrado
Netbeans R . Puede des argarse desde la página o ial de Netbeans de forma
gratuita. Está disponible tanto para el S.O. Unix así omo para Ma Os X.
Hemos optado programar desde este IDE on la nalidad de explotar un po o
las ventajas que tiene este lenguaje en lo que on ierne al uso de grá os,
aunque no se abordará mu ho en el tema, sino que se dará una muy breve
expli a ión sobre la rea ión de ventanas para la intera ión hombre-máquina.
Cabe men ionar que existen otros IDE que pueden emplearse, omo por ejemplo,
E lipse R aunque para efe to de las expli a iones ontenidas en estas notas, se
hará uso de Netbeans.
Ahora veremos omo obtener el resultado del programa implementado

anteriormente, pero empleando Netbeans. Asumimos que ya se uenta on
el JDK y el IDE instalados en la omputadora.
En Netbeans sele ionamos File>NewProje t lo ual abrirá una ventana.

Elegimos Java en Categories y JavaAppli ation en Proje ts. (g 3.15).
3.2. JAVA 117
Figura 3.15: File>NewProje t>Java>JavaAppli ation
Después de sele ionar Next debemos es ribir un nómbre para el proye to,
y si deseamos que se ree la lase prin ipal del programa hay que mar ar la
op ión Create Main Class.(g 3.16).
Figura 3.16: File>NewProje t>Java>JavaAppli ation
Con ésto se habrá reado y alma enado el ar hivo Hola.java en la arpeta

sl MiPrimerPrograma ubi ada en el dire torio Netbeans proje ts que se ha
reservado para este n duarante la instala ión de este IDE. Al rear una lase
en Netbeans, a su vez, este IDE reará un ar hivo .java que, por omisión,
llevará el mismo nombre que hayamos espe i ado para la lase. Además, se
reará una lase ( on el nombre espe i ado para la lase) dentro de éste
ar hivo.
Como hemos men ionado, por omisión el ódigo a eje utarse es el que
se en uentra dentro de la instru ión
publi stati void main(String[℄ args) {
así que es ribimos allí la instru ión:

3.2. JAVA 119
System.out.println(hola, mundo);
El ódigo queda omo en la g 3.17.
Figura 3.17: La lase prin ial del proye to MiPrimerPrograma
Observe que omo en el apítulo de algoritmi a, a las instru iones que

guran dentro de un bloque ( omo en las estru turas de ontrol) se les ha
dejado su respe tiva sangría.
Para ompilar y eje utar este programa de una manera sen illa, vamos
al panel izquierdo y ha emos li dere ho en nuestro proye to y sele ionamos
la op ión Set as Main Proje t. Cada vez que ne esitemos orrer el programa
( ompilarlo y eje utarlo) basta pulsar en el i óno:
que apare e en la barra de herramientas de la parte superior. El resultado

de la eje u ión de los programas se muestra en la osola propor ionada por
Netbeans en la parte inferior de la interfaz de Netbeans.
En parti ular, el programa que a abamos de rear produ e la siguiente

salida:
Figura 3.18: Resultado de la eje u ión del proye to MiPrimerPrograma
Observe que el resultado es el mismo que el del programa que hemos

ompilado y eje utado desde la terminal. Compare los dos ódigos presentados
(guras 3.13 y 3.17). úni amente dieren en que el de Netbeans tiene varias
líneas de omentarios, esto es, son enun iados que omienzan on // para
omentarios de una sóla línea:
//Este es un omentario unilínea
o bien, podemos es ribir omentarios en varias líneas ( omentarios multilínea)

delimitados por
/* aquí
va
el
omentario*/
El ompilador de Java ignora los omentarios y su utilidad es fa ilitarle al

3.2. JAVA 121
programador la le tura y omprensión del programa. Generalmente se utilzan

los omentarios para indi ar, por ejemplo, para que ha de utilizarse alguna
variable que se de lara o ual es el objetivo espe í o de un fragmento de
ódigo dentro de un programa. Así, ambos programas son, en esen ia, iguales
uyo resultado omún onsiste en imprimir el texto:
hola, mundo.
3.2.2. Tipos bási os de datos

En Java existen diversos tipos de datos que no son onsiderados objetos:
Los tipos bási os de datos que pueden manejarse en Java se presentan en la
siguiente tabla, así omo el número de bytes que o upan:
Tamaño
Des rip ión Tipo Rango
en bits
Entero de un byte byte 8 -128 a 127
Entero orto short 16 -32768 a 32767
Entero int 32 2147483648 a 2147483647
-9223372036854775808 a
Entero largo long 64
9223372036854775807
Flotante oat 32 1,7e−308 a 1,7e308
Double double 64 3,4e−308 a 3,4e308
Un ará ter har 16 ará teres UNICODE
Booleano boolean 1 true/false
Enseguida se de laran e ini ializan una varible de ada uno de los tipos
espe i ados en la tabla:
byte a=123;
short b=43;
int =3;
long d=233432;
float e=234.124165f;
double f=1623.2847134604;
har g='t';
boolean h=true;
Es responsabilidad del programador ini ializar las variables que de lara

y utiliza en los programas, para evitar posibles ambigüedades. De he ho, si
de laramos una variable, digamos de tipo int e intentamos utilizarlo sin haberlo
ini ializado, la ompila ión resultará fallida.
Para poder operar dos variables, estas deben ser del mismo tipo por lo
ual (a ve es) es ne esario efe tuar onversiones de tipo.
En Java existen dos maneras de onvertir tipos de datos bási os:
Conversión por amplia ión: Es la onversión natural que se da al asignar

un dato de algún tipo a una variable que se ha de larado de un tipo
mayor. En la tabla se muestran los posibles asos a onvertir:
byte short int long oat double

byte > SI SI SI SI SI
short > SI SI SI SI
har SI SI SI SI
int > SI SI SI
long > SI SI
oat > SI
No es ne esario indi ar explí itamente que se reali en este tpo de onversiones,

es de ir, sin problema podemos asignar a una variable de tipo entero el
valor que se en uentre alma enado en otra variable, de tipo har o byte.
Por ejemplo, es válido tener:
byte x=100;
short x1=x;
int x2=x;
long x3=x;
float x4=x;
double x5=x;
En ualquiera de los asos, no se tiene problema alguno en uanto el

espa io de memoria, ya que estas onversiones se ha en se un tipo menor
a un tipo mayor (en rangos).
Conversión por redu ión: Es la onversión en la que se pasa de un

dato de un rango mayor a otro de rango menor. Por ejemplo, onvertir
una variable de tipo oat a tipo int. Este tipo de onversión, omo es
razonable imaginarse, tiene una desventaja: puede perderse informa ión.
3.2. JAVA 123
Dado que se onvierte un tipo que a epta un rango mayor de datos,

es posible que este valor no quepa en una variable del tipo al que se
desea onvertir. Es por eso que éste tipo de onversiones deben indi arde
expí itamente, siendo responsabilidad del programador la posible pérdida
de informa ión al efe tuarse las onversiones. Las posibles onversiones
se indi an en la tabla siguiente:
oat long int short har byte

byte > SI
short SI SI
har SI SI
int SI SI SI
long SI SI SI SI
oat SI SI SI SI SI
double SI SI SI SI SI SI
La onversión se lleva a abo trasladando los primeros bits (los menos

signi ativos) al espa io de memoria reservado para la variable de destino.
La antidad de bits que se trasladan es la misma que el número de éstos
que puede alma enar la variable de destino.
Como ejemplo, onsidére:
double y=12;
float y1=(float)y;
long y2=(long)y1;
int y3=(int)y2;
short y4=(short)y3;
byte y5= (byte)y4;
Si en ambio ponemos y=1238786123.34252435, los valores alma enados

no oin idirán en todas las variables denidas. De he ho, se obtienen los
siguientes valores:
y1=1.23878618E9
y2=1238786176
y3=1238786176
y4=24704
y5=-128
3.2.3. Operadores
Operadores aritmeti os
Los operadores aritméti os que nos propor iona este lenguaje son los mismos
que se han dado en la subse ión 2.1.3 de este texto. El operador módulo es
apli able sólo a los tipos de datos enteros.
La pre eden ia en la eje u ión de estos operadores se sujeta a lo estable ido

en las reglas de la aritméti a usual. De esta forma, produ tos y o ientes
tienen mayor pre eden ia que las adi iones y sustra iones. Operadores de
igual pre eden ia son evaluados de izquierda a dere ha onforme han sido
*, /, % tienen la misma pre eden ia, y mayor que la de:
+, −.


Tienen todos la misma pre eden ia y se aso ian de izquierda a dere ha.
Otros dos operadores de asigna ión ompuestos, uyo fun ionamiento se

expli o en la subse ión 2.1.3 son los operadores de in remento y de remento
unitarios
++
−−
respe tivamente. Pueden apli arse de manera preja o postja. Ambos son
de igual pre eden ia, y a su vez, de pre eden ia mayor que la de todos los
operadores aritméti os. También ++ y −− se aso ian de dere ha a izquierda.
3.2. JAVA 125

Son los operadores de rela ión que se han men ionado en el apítulo anterior:
igual que: ==
menor que: <
mayor que: >
diferente que: ! =
Éstos a túan sobre tipos de datos enteros, otantes o ará teres. Las expresiones
a ambos lados del operador deben pertene er al mismo tipo de dato.
Respe to a estos operadores solo resta men ionar que los operadores == y
! = tienen la misma pre eden ia y se aso ian de izquierda a dere ha. Por otra
parte, los uatro operadores restantes son de pre eden ia igual, y mayor que la
de ==. Además, los operadores de pre eden ias iguales se aso ian de dere ha
a izquierda.
Operadores lógi os
En Java, vamos a representarlos de la siguiente manera:
Conjun ión: &&

Disyun ión: ||
Nega ión: !
La pre eden ia del operador disyun ión es menor a la de la onjun ión.
De uaquier manera, se re omienda, para evitar ambugüedades tanto en la

le tura omo en la interpreta ión de éste tpo de expresiones, que el programador
haga la agrupa ión explí ita de las expresiones a través del uso de paréntesis,
en fun ión de lo que quiera expresar.

hemos presentado son solo algunos de los que pueden utilizarse en este lenguaje.
Nos limitamos a presentar úni amente los que serán de utilidad para los propósitos
de este texto.
En la siguiente tabla se muestran, en resumen, los operadores aritméti os,

el operador de asigna ión, los operadores de asigna ión ompuestos, operadores
rela ionales y lógi os que a abamos de men ionar, así omo la pre eden ia on
la que se efe tuan las opera iones. Los operadores que guran en la misma
línea tienen la misma pre eden ia.
Operadores
!, ++, −−
*, /, %
+, −
<, <=, >, >=
==, !=
&&
||
=, +=, −=, *=, /=, %=
Para modi ar el orden en que se apli an los operadores según la tabla

anterior, se utilizan los paréntesis omo signos de agrupa ión.
3.2.4. Orienta ión a objetos

El lenguaje de programa ión Java tiene además la parti ularidad de ser
un lenguaje orientado a objetos. Puede pensarse un objeto en un sentido
intuitivo, es de ir, omo una persona, un animal, un libro, un auto, un número,
3.2. JAVA 127
un polinomio, una matriz de fun iones, et ., en general ualquier osa que

podamos on ebir (en nuestra mente). Evidentemene, dos objetos del mismo
tipo tienen diversas propiedades en omún y sirven para ha er (o realizan)
determinadas a iones. Asimismo, dos objetos de diferente tipo tienen ara terísti as
y apa idades que los distinguen a tal grado que se onsideran de tipos diferentes.
En términos de lenguajes de programa ión, a las ara terísti as (o variables)

de un objeto se les llama atributos, y a las a iones (pro edimientos) que
pueden realizar, o realizarse en él o on él se les ono e omo métodos, y al
tipo de objeto se le llama lase. Para jar ideas, pensemos en los objetos de tipo
Humano. Supongamos que son de nuestro interés las siguientes ará terísti as
de los elementos del tipo Humanos:
nombre
género
edad
o upa ión
na ionalidad
y que puede efe tuar las siguientes a iones:
es ribir
trabajar
asarse
aminar
levantarManoDere ha
Enton es una persona viene a ser un objeto, que pertene e a la lase

Humano. Los atributos de una persona son su nombre, género, edad, o upa ión
y na ionalidad, mientras que sus métodos son es ribir, trabajar, asarse, aminar
y levantar mano dere ha. En general, podríamos onsiderar otros atributos y
métodos de Humano, dependiendo de nuestros interéses.
Un objeto debe pensarse omo sus atributos y métodos en onjunto, es

de ir, no puede onsiderarse omo objeto ex lusivamente a sus atributos, de
manera independiente de sus métodos, aunque abe la posibilidad de que no

posea métodos. En otras palaras, los objetos son auto ontenidos.
No deben onfundirse los on eptos lase y objeto, pues aunque en primera

instan ia puede reerse que denotan lo mismo, no es así. Una lase es la
espe i a ión de las ara terísti as que deberá tener un objeto pertene iente
a la misma (el on epto), mientras que un objeto es un elemento parti ular
(una instan ia) de una lase.
Nombres de variables
El le tor ya habrá notado de que las lases las hemos es rito on mayús ula
ini ial, mientras que los atributos y métodos omienzan on minús ula. En
adelante, para Java tomamos esta onven ión. Más espe i amente, daremos
las reglas que seguiremos en el presente texto para asignar nombres:
Java ha e distin ión entre mayús ulas y minús ulas.
Los nombres de las lases omienzan on letra mayús ula.
Los nombres de atributos y métodos omienzan on letra minús ula.
Pueden gurar números en los identi adores de variable, pero no pueden

ser el omienzo de un nombre de variable.
No deben utilizarse ninguna de las palabras reservadas del lenguaje, las

uales se presentan en la siguiente tabla:
abstra t double int stri tfp

boolean else interfa e super
break extends long swit h
byte nal nantive syn hronized
ase nally new this
at h oat pa kage throw
lass goto prote ted transient
onst try if publi
ontinue implements return void
default import short volatile
do instan eof stati while
false true null
3.2. JAVA 129
El espa io en blan o no puede formar parte de un identi ador de variable

( lase, atributo o método).
Es re omendable asigar nombres rela ionados on el signi ado u objetivo

del elemento al que identi a. Por ejemplo, si reamos una matriz y
al ulamos su inversa, a ésta podríamos llamarle inversaMatriz.
Si queremos nombrar algún elemento, uyo signi ado no puede expresarse

mediante una úni a palabra, omo es el aso de inversa matriz, la primera
palabra que onstituye el nombre será es rita on minús ula ini ial (a
ex ep ión de que se trate de una lase, aso en el ual se omenzaría on
mayús ula), mientras que para las palabras subse uentes, ada una de
éstas se es ribirá on mayús ula ini ial, onriendo una mejor legibilidad
del programa. Es por esto que hemos es rito inversaMatrizen lugar de
inversamatriz
Si bien estas reglas no son de uso obligatorio, es sumamente re omendable

utilizarlas, prin ipalmente para una mejor legibilidad de los programas.
Reiteramos que es responsabildad del programador ini ializar las variables

involu radas en un programa, así sean tipos de datos bási os o instan ias de
alguna lase. Aquí abe men ionar un tipo espe ial para el que se en uentra
reservada la palabra null, que puede ser asignado a una variable pertene iente
a ualquier lase, para indi ar que el objeto aun no ha sido ini ializado. Cuando
se rea una nueva instan ia de alguna lase, su valor por omisión esnull.
Clases predenidas: API

La API(Appli ation Programming Interfa e) de Java es la Interfaz de Apli a ión
de Programa ión de Java, en la que se in luye gran variedad de paquetes
(bibliote as) que a su vez ontienen espe i a iones de lases de Java ya
ompiladas e in luidas en el JDK (y en el JRE).
Es de gran ayuda ono er las lases denidas en la API, pues podemos

auxiliarnos de ellas para evitar tener que partir desde ero para elaborar
nuestros programas, si es que existen lases predenidas que nos sean de
utilidad, ahorrando tiempo y ódigo, pues en vez de denirlas nosotros mismos
bastará importarlas desde el paquete en elque se en uetran, aunque en iertas
o asiones será mas onveniente denir nuestras propias lases para tener un
mayor ontrol sobre sus atributos y métodos. Como vermos más adelante,
también es posible extender las lases ya existentes (di ho de otra manera,

rear sub lases) en la API o readas por el mismo programador. Algunos de
los paquetes de uso más fre uente son:
java.lang: provee lases de números (por ejemplo Integer, que no es lo

mismo que el tipo de dato bási o int), Strings, objetos, seguridad, et .
Por omisión se in luye en todos los programas reados en Java.
java.util:Contiene ve tores, una adena tokenizer, un generador de

números aleatorios, y una matriz de bits, entre otras osas.
java.io: Provee lases para la entrada y salida del sistema a través de

ujos de datos, serializa ión y el sistema de ar hivos.
java.awt: ontiene lases para utilizar y pintar grá os e imágenes

java.math: Propor iona lases para realizar aritméti a de pre isión arbitraria
entero y aritméti a de pre isión arbitraria de imal.
Cabe men ionar que el paquete java.lang propor iona lases que engloban
(de ierta manera se puede de ir que ontienen) a los tipos de datos simples
de Java. Éstas son las siguientes:
i ) java.lang.Byte
ii ) java.lang.Short
iii ) java.lang.Integer
iv ) java.lang.Long
v ) java.lang.Float
vi ) java.lang.Double
vii ) java.lang.Chara ter
viii ) java.lang.Boolean
En algunos lenguajes de programa ión existen los String ( adenas de

ará teres) omo un tipo de dato bási o, no siendo así en Java. Una adena (de
ará teres) en Java es un objeto pertene iente a la lase String. Una variable
de tipo har se es ribe entre omillas simples mientras que una de tipo String
se delimita on omillas dobles. Puede onsultarse la espe i a ión de la lase
3.2. JAVA 131
String en la do umenta ión de la API de Java.
Java es un lenguaje que se en uentra en evolu ión onstante, por lo que en

determinado momento puede su eder que alguna lase, método, onstru tor,
et . predenidas en alguno de los paquetes de la API se vuelva obsoleta,
por lo que es mar ada omo Depre ated. Esta es una manera de ha erle
saber al programador que esta lase desapare erá de la API en alguna de las
versiones posteriores de Java. La mayoría de las ve es que una lase entra en
Depre ated es por que ya no es util o porque ya hay otra alternativa mejor.
Si utilizamos alguna lase en este estado dentro de nuestros programas, la
ompila ión si se realizará (si no hay errores) pero nos mandará un mensaje
advirtiendonos que estamos utilizando un elemento en Depre ated. Es sumamente
re omendable no emplear lases mar adas on este distintivo.
De lara ión de lases y métodos

En su forma más sen illa, una lase de Java se dene de la siguiente manera:
lass <NombreDeClase>{
//Cuerpo de la lase
<atributos>
< onstru tores>
<métodos>
}
En el uerpo de la lase, no es obligatorio que se de laren primero los atributos

de la misma, pero asi siempre se ha e así.
Los métodos se de laran, en su forma mas simple (sin modi adores), de

la siguiente manera:
<tipoDevuelto> <nombreDelMétodo> (<Parámetros>){

< uerpoDelMétodo>
}
<tipoDevuelto> es el tipo al que pertene e el dato que devuelve el

método. En este aso, debe gurar la instru ión:
return <exp>;
donde <exp> es del tipo indi ado en <tipoDevuelto>.
Cabe también la posibilidad de que el método no retorne valor, aso

en el ual debemos espe i arlo mediante el pseudo-tipo de dato void,
void <nombreDelMétodo> (<Parámetros>){

< uerpoDelMétodo>
}
<nombreDelMétodo> es simplemente el nombre mediante el ual identi aremos
al método. Debe omenzar on letra minús ula.
En (<Parámetros>) se espe i an ada uno de los argumentos que re ibe

el método omo parámetros, separados por omas. Debe indi arse expli itamente
ual es el tipo de ada dato, por ejemplo:
void suma (int a, int b){

< uerpoDelMétodo>
}
< uerpoDelMétodo>: Es en donde se es riben las instru iones que deberán
ser eje utadas ada vez que se eje ute di ho método.
Un onstru tor es un método espe ial pertene iente a una lase, uya
fun ión onsiste en rear una instan ia de di ha lase eje utando, al momento
de la rea ión, ierto ódigo denido por el programador. En otras palabras,
un onstru tor nos permite rear una elemento de la lase a la que pertene e
el onstru tor. Este ódigo puede verse bajo la forma de ini ializa ión de
atributos, sea on valores por omisión, sea on valores denidos al momento
de rear el objeto por parte del programador. Además nun a se espe i a
<tipoDevuelto>, ni siquiera omo el pseudo-tipo de dato void. Su forma de
de lararlo es:
publi <NombreDeClase>(<parámetros>){
<ini ializa iónDeLosAtributos>
}
3.2. JAVA 133
La palabra reservada publi es un modi ador que a túa, en general, en

los métodos (ver 3.2.5). Por el momento, basta de ir que ada onstru tor debe
de lararse omo publi y, además, deberán tener el mismo nombre que la lase
que lo ontiene En una lase, pueden existir varios onstru tores, todos ellos
on el mismo nombre que la lase, distinguiendose entre ellos en los parámetros
que re iben.
La forma general de rear una instan ia de una lase es:
<NombreClase> <nombreNuevoObjeto>=new <NombreClase>(<parámetros>);
on lo ual se rea un objeto pertene iente a la lase que se indi a, y se

ini ializan los atributos (del objeto) indi ados en la deni ión del onstru tor.
Un ejemplo ompleto
Vamos ahora a onsiderar un ejemplo más ompleto, del ual haremos la
implementa ión de un programa en este lenguaje:
Pensemos en el onjunto de los números omplejos omo pares ordenados (a, b)

donde a es la parte real y b es la parte imaginaria. Llamemos Complejo al
onjunto de números omplejos. Un número omplejo en espe í o viene a ser
un objeto que pertene e a la lase Complejo. Sus atributos podrían ser:
parteReal
parteImaginaria
norma
inversoMultipli ativo
y sus métodos:
al ulaConjugado
al ulaNorma
sumaComplejos
al ulaInversoMultipli ativo
Enseguida vamos mostrar omo denir esta lase en Java dentro del proye to
MiPrimerPrograma:
i ) Primero a edemos a File>New File.
ii ) En la ventana que se muestra sele ionamos el proye to dentro de que

deseamos rear la lase. Sele ionamos las op iones Java y Java Class:
Figura 3.19: Paso II: Creando una nueva lase

3.2. JAVA 135
iii ) Damos un nombre a la lase que estamos reando. Re ordemos que debe
omenzar on mayús ulas. Para este ejemplo, hemos dado el nombre
Complejo.
Figura 3.20: Paso III: Asignando un nombre a la nueva lase
iv) Se habrá reado la lase Complejo en el proye to MiPrimerPrograma:
publi lass Complejo(){

}
v) Enseguida, ha emos la espe i a ión de los atributos de esta lase, así
omo sus respe tivos onstru tores y los métodos que podrán efe tuar o
efe tuarse on los objetos pertene ientes a ésta lase
En el siguiente ódigo se muestra la deni ión que hemos he ho de la lase
Complejo:
Programa 3.2.1. Deni ión de la lase Complejo
publi lass Complejo {

//Definimos los atributos de la lase
private float parteReal;
private float parteImaginaria;
private float norma;
private Complejo inversoMultipli ativo;
//CONSTRUCTORES
//Creamos un onstru tor que no re ibe argumentos
publi Complejo(){
parteReal=0;
parteImaginaria=0;
}
//Constru tor que ini ializa parteReal y parteImaginaria

publi Complejo(float a, float b){
this.defineValores(a, b);
}
//GETTERS:
publi float re uperaParteReal(){
float r=this.parteReal;
return r;
}
publi float re uperaParteImaginaria(){

float i=this.parteImaginaria;
return i;
}
publi float re uperaNorma(){

float n=this.norma;
return n;
}
publi Complejo re uperaInverso(){

Complejo =this.inversoMultipli ativo;
return ;
}
3.2. JAVA 137
//SETTERS:
publi void defineValores(float re,float im){
this.parteReal=re;
this.parteImaginaria=im;
}
publi void defineNorma(float n){

this.norma=n;
}
publi void defineInversoM(Complejo z){

this.inversoMultipli ativo=z;
}
//Método que al ula el onjugado de un omplejo

Complejo al ulaConjugado(){
Complejo x=new Complejo();
x.defineValores(this.parteReal, this.parteImaginaria);
return x;
}
//un método que, a un objeto de tipo Complejo, le

//suma el Complejo espe ifi ado omo argumento
Complejo sumaComplejo(Complejo z){
Complejo nuevo=new Complejo();
nuevo.defineValores(this.parteReal+z.parteReal,
this.parteImaginaria+z.parteImaginaria);
return nuevo;
}
//Método que al ula el inverso multipli ativo

Complejo al ulaInversoMultipli ativo(){
float a=this.parteReal, b=this.parteImaginaria;
Complejo x=new Complejo();
x.defineValores(a/(a*a+b*b), b/(a*a+b*b));
return x;
}
//Un método que al ula la norma de un omplejo

float al ulaNorma(){
return (float)Math.sqrt(this.parteReal*this.parteReal+
this.parteImaginaria*this.parteImaginaria);
}
}
La primera observa ión que ha emos es que a los atributos hemos antepuesto
el modi ador private (para más detalles ver 3.2.5), lo que quiere de ir que
sólo se tiene a eso a di hos atributos desde la misma lase, por lo que no
podremos modi arlos desde otra lase.
Note además que los atributos de una lase pueden ser in luso elementos
de la misma lase. Despúes de la de lara ión de los atributos, se han denido
dos onstru tores, los uales no re iben argumentos e ini ializan los atributos
parteReal y parteImaginaria, en el primer aso, no re ibe parámetros e
ini ializa estos valores omo ero y en el segundo onstru tor se ini ializan
omo los dos valores de tipo otante re ibidos. Podrían también denirse otros
onstru tores siempre y uando re iban diferentes argumentos (ya sea en tipo
o antidad).
Volviendo al tema de los atributos, si no los de laramos omo private,

se podrá a edera a ellos o ser modi ados desde otras partes del programa,
dependiendo de los modi adores que se men ionan en 3.2.5 el a eso a ellos.
Nosotros re omendamos de larar los atributos de una lase omo private
situa ión en la ual, debido a que no tendremos a eso a ellos más que dentro
de la lase misma, se ha e ne esario rear métodos que nos permitan a eder
o modi ar tales atributos. Estos son ono idos omo:
Setters: Son métodos denidos dentro de la espe i a ión de la lase,

que modi an alguno(s) de los atributos de un objeto. Para ésto, en
la mayoría de los asos se espe i an alguno(s) parámetros en estos
métodos. El ejemplo 3.2.1 tiene 3 getters:
• deneValores()
• deneNorma()
• deneInversoM()
3.2. JAVA 139
y a túan sobre un objeto pertene iente a la lase Complejo de la siguiente

manera: primero se rea una instan ia de Complejo:
// reamos un objeto de tipo omplejo, llamado nuevo

Complejo nuevo=new Complejo();
Ahora ini ializamos los atibutos on ayuda del setter deneValores():

nuevo.defineValores(1000.0,1242.124);
Como la norma de nuevo no ha sido ini ializada, la denimos on:
nuevo.defineNorma()
y nalmente, para que nuevo esté ompletamente determinado, empleamos:
nuevo.defineInversoM()
Posteriormente pueden modi arse nuevamente los atributos a través

de los setters.
Getters: Son métodos similares a los setters, diriendo en que los getters
retornan algúno de los atributos de un objeto. El ejemplo 3.2.1 uenta
on 4 setters:
• re uperaParteReal()
• re uperaPArteImaginaria()
• re uperaNorma()
• re uperaInverso()
Los métodos restantes no son getters ni setters.
También note que al de larar los métodos obtieneNorma(Complejo z) y

sumaComplejo hay una úni a instru ión, apesar de que se tienen dos líneas
distintas. Esto no ausa oni to alguno ya que en Java, el punto y oma es el
delimitador de instru iones o senten ias.
Los métodos(instan iados) que retornan algún valor pueden ser asignados
a alguna variable pertene iente a la lase o tipo de valor que regresa. Por
ejemplo, podemos es ribir las instru iónes:
Complejo z1=new Complejo();

Complejo z2=new Complejo();
z1.defineValores(-1,2);
z2=z1. al ulaInversoMultipli ativo;
Propiedades generales de los lenguajes Orientados a Objetos

Por otra parte, para nalizar los omentarios a er a de la orienta ión a
objetos, men ionamos a ontinua ión las tres ara terísti as prin ipales que
poseen los lenguajes de programa ión que umplen on di ho paradigma. En
parti ular, Java posee tales ara terísti as.
i ) En apsulamiento: Propiedad que tiene un objeto de o ultar sus atributos

y/o métodos a otras partes del programa u objetos. En otras palabras,
podemos restringir el a eso ya sea a onsulta o modi a ión de una
lase, método o atributo on ayuda de algunos modi adores, que se
espe i an en el apartado 3.2.5.
ii ) Heren ia: Permite denir nuevas lases a partir de las que ya existen,
de tal manera que la nueva lase posea todos los métodos y atributos
que la lase original. La nueva lase puede tener además otros métodos
y atributos o in luso se pueden redenir atributos de ésta lase. Di ho
de otra manera, podemos extender una lase preexistente, agregando o
modi ando sus atributos y/o métodos. Por ejemplo, si onsideramos
la lase omplejo, podemos denir una nueva lase Real que tenga los
mismos atributos y métodos que los de Complejo, además de (quizá)
otros adi ionales. Por ejemplo, el atributo parteImaginaria sería igual
a ero para todas las instan ias de Real. También, norma oin ide on el
valor absoluto de los números reales, y omo es sabido, la suma de reales
es oin ide on la suma de omplejos, onsidérando a éstos números reales
on parte imaginaria igual a ero.
iii ) Polimorsmo: Permite que un mismo mensaje que es enviado a dos

objetos pertene ientes a lases distintas tenga efe tos diferentes en di hos
objetos. Di ho de otra manera, para dos tipos diferentes de objetos puede
su eder que ambos posean métodos on el mismo nombre, o bien, para los
objetos de una lase pueden existir métodos on el mismo nombre pero
on diferentes parámetros. Esto se puede observar en el ejemplo de la
3.2. JAVA 141
lase Complejo, en la uál existen dos métodos (de he ho, onstru tores
ambos) que tienen el mismo nombre o identi ador pero que efe tuan
diferentes a iones, pues re iben diferentes parámetros para su eje u ión.
3.2.5. Modi adores de lases, métodos y atributos

Un modi ador no es más que una palabra reservada del lenguaje Java. La
fun ión de un modi ador resulta en un efe to ya sea en la lase, atributo o
método a que se antepone. Daremos en esta subse ión una breve des rip ión
a er a de los modi adores que los que nos permiten utilizar la propiedad de
en apsulamiento en el lenguaje de programa ión Java.
Modi adores de lases

Hasta el momento hemos di ho que una lase se de lara, en su forma más
sen illa omo:
lass <NombreDeClase>{
//Cuerpo de la lase
<atributos>
< onstru tores>
<métodos>
}
Ahora que hablamos de los modi adores que nos permitirán o limitarán el
a eso al uso de una lase, la sintaxis es la siguiente:
<modifi ador> lass <NombreDeClase>{

//Cuerpo de la lase
<atributos>
< onstru tores>
<métodos>
}
donde <modi ador> es una de las tres palabras reservadas:
publi : Las lases on esta propiedad pueden ser utilizadas desde ualquier
paquete (in luso aquellos en los que no ha sido de larada). Una lase on
tal ara terísti a debe de lararse en un ar hivo que lleve el nombre de tal
lase. De aquí se dedu e que en un ar hivo .java puede existir uni amente
una lase públi a.
No se des arta la posibilidad de denir otras lases en el mismo ar hivo,

las uales, no podrán llevar el modi ador publi , y por ende, no se
podrá a eder a ellas desde otro paquete. Por ejemplo, pueden denirse
las lases Clase1 y Clase2 en el ar hivo Clase1.java:
publi lass Clase1{

.
.
.
}
Clase2{
.
.
.
}
Si también ponemos el modi ador publi a Clase2 la ompila ión

nos resultará en un error. Si se desea que sea publi a esta lase, deberá
denirse en otro ar hivo, on el nombre Clase2.java
absta t: En las lases on este modi ador no pueden de lararse objetos,

es de ir, no pueden rearse instan ias de di ha lase.
nal: Toda lase a ompañada on este modi ador no puede extenderse,

es de ir, no puede denirse sub lase alguna a partir de ella.
Una lase puede tener dos modi adores, por ejemplo
publi abstra t Clase1 {

.
.
.
}
on la ex ep ión de que no está permitido que una lase sea a la vez abstra t
y final.
3.2. JAVA 143
Si, en ambio, no se espe i a ninguno de éstos tres modi adores, por

omisión, la lase será utilizable desde ualquier lase de larada en el mismo
paquete.
Modi adores de atributos y métodos

Un atributo de una lase puede ser de uno de los tipos bási os de Java o
bien pertene er a alguna lase. Dentro de una lase se de laran en alguna de
las formas:
<tipoBási o> <nombre>;
<Clase> <nombre>;
en ualquiera de los asos están permitidos los modi adores: private, publi ,
prote ted o ninguno de ellos.
El modi ador se espe i a antes que <tipoBási o> o <Clase> según sea
el aso:
<modifi ador> <tipoBási o> <nombre>;
<modifi ador> <Clase> <nombre>;
Los efe tos de ada uno de éstos modif adores se resumen en la tabla:
Modi ador a eso desde a eso desde a eso desde a eso desde
misma lase sub lase sismo paquete todo el entorno
private si no no no
publi si si si si
prote ted si * si no
por omisión si no si no
*Se tendrá a eso desde las sub lases del mismo paquete o desde
la primera sub lase de la lase en que se de laro el atributo
Estos modi adores también apli an para los métodos, de larandose:
<modifi ador> <tipoDevuelto> <nombreDelMétodo> (<parámetros>){

< uerpoDelMétodo>
}
on los mismos efe tos que al apli arse a un atributo.

3.2. JAVA 145
3.2.6. Crea ión de ventanas

Ahora vamos a rear paso a paso unas sen illas ventanas, que nos permitirán
la intera ión entre el usuario y la omputadora de una manera más grá a.
Primero, vamos a rear un nuevo proye to (g 3.21):
File>New Proje t>Java>Java Appli ation>Next
en donde asignamos un nombre al proye to y, en este aso no vamos a requerir

que se ree automáti amente la lase prin ipal.
Figura 3.21: Creando el proye to CreandoVentana
Es onveniente que establez amos este proye to omo nuestro proye to

prin ipal. Esto sele ionando en el panel izquierdo el proye to que a abamos
de rear, damos li k dere ho y elegimos Set as Main Proje t.
Ahora, vamos a rear una nueva lase dentro de este proye to, para esto
vamos a File>New File
En la ventana que se abre, sele ionamos en Categories: la op ión Swing

GUI Forms, y en File Types: JFrameForm (g 3.22).
Figura 3.22: Creando un objeto JFrame Form
Una ves sele ionadas estas op iones, ontinuamos on Next, después de lo

ual nos apare erá otra ventana en la que debemos dar un nombre a este objeto.
Re ordemos que el nombre que asignemos debe ser el mismo nombre que
tendrá la lase que ontiene y por ende, debe omenzar on letra mayús ula.
Además, debemos er iorarnos de que se en uentre dentro del proye to en el
que deseamos que esté in luido (g 3.23).
3.2. JAVA 147
Figura 3.23: Nombrando al objeto JFrame Form
Con estos pasos habremos obtenido una lase que es una extensión de
javax.swing.JFrame. Puede onsultarse la espe i a ión de ésta lase en la
API. Aquí no vamos a dar todos los detalles. Nos limitamos a mostrar algunas
de sus ara ter'isti as y omo emplearla. Ésta onsta prin iaplmente de dos
partes:
El diseño de la ventana.
El ódigo del programa
En la parte superior del panel entral se observan los botones Design

y Sour e, on los uales podemos trabajar en el diseño de la ventana (los
botones, espa ios para re ibir datos, espa ios para mostrar datos, et .) y en la
espe i a ión del ódigo fuente del programa(las a iones que se realizarán)
Figura 3.24: Diseño de la ventana
En la gura 3.24 se muestra la interfaz que nos permite trabajar on el

diseño de la ventana. En la parte lateral dere ha de esta ventana se en uentran
dos bloques: Palette y [JFrame℄-Properties.
En Palette se en uentra un onjunto de omponentes de Java que pueden

agregarse a la ventana que hemos reado (que pertene e a la lase JFrame).
Por otra parte, en [JFrame℄-Properties se meustran las ará terísti as on las
uales ha sido reado este JFrame. Algunas de estas son modi ables. Para
más detalles, puede onsultarse en la API la espe i a ión de la lase JFrame.

En la gura 3.25 se muestra la interfaz orrespondiente al digo fuente en
el ual podremos espe i ar las instru iones del programa. Observe además
que dentro de este ódigo se en uentra ontenida la lase prin ipal main(),
razón por la ual al momento de rear el nuevo proye to CreandoVentana
no fue ne esario rear la lase prin ipal.
3.2. JAVA 149
Figura 3.25: Código fuente de la ventana reada
En la línea 25 de este ódigo se observa que di e Generated Code, que

es un fragmento de ódigo que se rea automáti amente y orresponde a
la de lara ión e ini ializa ión de los parámetros de los omponentes que se
agreguen en Design de la ventana.
La razón por la que hemos elegido trabajar desde Netbeans se ha e notoria

pre isamente aquí, pues si estuvieramos programando desde un editor de textos
simple, o in luso desde otro IDE (o al menos la mayoría de ellos), el programador
debe es ribir desde ero todo el ódigo (evidentemente para esto deberá ono er
obligatoriamente, los atributos y métodos para la lase JFrame).
Ahora vamos a volver al diseño de la ventana, y en el subpanel Palette

vamos a bus ar un elemento Panel Este lo vamos a utilizar simplemente para
delimitar el área en la que pondremos las demás omponentes. Además sirve
para evitar que( uando eje utemos el programa) al ambiar el tamaõ de la
ventana por ejemplo al maximizar se distorsione el a omodo que hayamos
he ho de los elementos en nuestro JFrame. Una vez lo alizado, lo sele ionamos
y lo arrastramos hasta que esté sobrepuesto al JFrame. Lo más probable es

que sea ne esario ajustar el tamaño del panel agrandandólo o disminuyéndolo
omo si fuera una ventana alquiera, hasta obtener algo en la gura 3.27:
Figura 3.26: Agregando el omponente Panel a la ventana
El área delimitada por olor amarillo orresponde al panel. Si sele ionamos

el panel en el diseño de nuestro JFrame, en el subpanel dere ho inferior se
mostrará la informa ión a er a de éste omponente, y podrán modi arse
las ará terísti as del panel, que pertene e a la lase JPanel. Son editables
algunas ara terísti as tales omo: tamaño, olor de ontorno, olor de fondo,
tamaños mínimo y máximo, opa idad, in luso puede ambiarse el nombre de
éste elemento, pues a n de uentas es una instan ia de la lase Jpanel, que
tiene (por omisión) el nombre jPanel1. Si reamos más paneles, sus nombres
por omisión serán jPanel2, jPanel3, et . Puede ambiarse el nombre en el
subpanel dere ho inferior, si sele ionamos la op ión Code y editamos el ampo
orrespondiente a Variable Name; demás podrán ambiarse otros aspe tos
respe to a este objeto, tales omo modi adores. En el presente texto, no nos
detendremos a señalar todas las ara terísti as de los objetos, ni las maneras
de modi arlos, pues estos temas no son el objetivo prin ipal del urso. El
le tor intresado puede onsultar algún texto a er a de diseño de apli a iones
desde Netbeans (dar referen ias bibliográ as).
El siguiente paso que vamos a dar es agregar un boton. Para esto basta
3.2. JAVA 151
arrastrar, hasta jpanel1, un omponente de tipo (Clase) Button que se en uentra

en el Palette. El nombre que muestra por omisión es jButton1.
Figura 3.27: Agregando el omponente Button a la ventana
Este nombre es editable ha iendo doble li k sobre el boton y es ribiendo el

nombre que deseemos que se muestre. Le pondermos A eptar. A laramos que
éste no es el nombre de el objeto. Simplemente es un atributo de él, es un texto
que se muestra en este objeto, por lo que no irrumpe on la onven ión que
hi imos de que ualquier omponente de Java que no sea una lase omenzará
on letra minús ula
Si lo que queremos es ambiar el nombre del boton, omo variable, podemos

ha erlo en el re uadro de Properties eligiendo Code y poniendo el nuevo nombre
en el ampo Variable Name. También se puede ha er esto dando li k dere ho
en el boton y sele ionando la a ión Change Variable Name.
A modo de ejemplo le ambiaremos el nombre (el ual debe omenzar,

según lo a ordado, on letra minús ula), pero en adelante en la mayoría de los
asos no ambiaremos los nombres de las omponentes para ahorrar tiempo
y espa io. Vamos a asignarle el nombre a eptar, y lo haremos dando li k
dere ho en el boton, y despues de elegir Change Variable Name nos apare erá
una ventanita en la que debemos editar el nombre, omo en la gura 3.28:
Figura 3.28: Editando el nombre del objeto jButton1
Al a ionar un objeto de la lase JButton durante la eje u ión el programa,

se eje utará un determinado fragmento del ódigo fuente del programa. Veremos
un ejemplo más adelante.
Figura 3.29: Se ha reado y editado (nombre de variable y texto a mostrar) un omponente

de tipo JTextField
Enseguida arrastramos un omponente de tipo Text Field desde el re uadro

Palette hasta el panel de nuestro diseño de la ventana. Por omisión muestra
el texto: jTextField, que además oin ide on el nombre de ésta variable.
3.2. JAVA 153
Editamos el texto mostrado, dejandolo ompletamente en blan o (y dándole

un tamaño que onsiderémos ade uado). También ambiamos el nombre de la
variable por re ibe (g3.29).
El objeto re ibe es una instan ia de la lase JTextField y sirve para

obtener datos de tipo String, aunque omo veremos más adelante, pueden
leerse núneros ( omo Strings) y onvertirse posteriormente a un tipo numéri o.
Ahora, vamos a agregar a nuestra ventana un objeto de la lase JTextArea

(en el re uadro Palette apare e omo Text Area), omponentes que tienen la
fun ión de ser un ampo destinado para mostrar texto, bási amente Strings, y
datos de tipo numéri o on ayuda de la on atena ión la ual se detallará en la
subse ión inmediata siguiente. Al JTextArea que hemos agregado, ambiamos
el nombre por omisión (jTextArea1) a: salida, y lo ajustamos a un tamaño
pertinente, según la antidad de informa ión que se desee mostrar allí. Despues
de ha er esto, habremos obtenido algo omo lo siguiente:
Figura 3.30: Se ha reado y editado nombre de variable de un omponente de tipo
JTextArea
Es importante men ionar que todos estos omponentes, y los demás que
se en uentran en el Palette, perene en a lases predenidas en el pa kage
jaxax.swing. Cuando arrastramos alguno de estos omponentes hasta el área
destinada a diseñar la ventana, en realidad estamos llamando al un onstru tor

respe tivo a la lase del objeto que estemos reando, pero Netbeans es quien
se en arga de generar el ódigo, ahorrandole este trabajo al programador.
Además, uando ambiamos el nombre de alguna variable (objeto), el texto
que muestra, si lo rees alamos o lo ambiamos de posi ión, et ., en realidad
estamos modi ando los atributos de di hos objeto (posiblemente ha iendo
llamadas a métodos para efe tuar estos ambios).
El ódigo orrespondiente a éstas rea iones de objetos y ambios en sus

atributos es generado automáti amente en el ódigo fuente del programa, en la
parte que di e Generated Code, más arriba de donde se en uentra la fun ion
prin ipal del programa. Re omendamos no borrar ni modi ar esto ódigo, a
menos que el programador se en uentre apa itado para ha erlo. En la imágen
3.31 se muestra un fragmento del ódigo autogenerado por las a iones que
hemos realizado hasta ahora.
Figura 3.31: Algunas de las líneas de ódigo autogeneradas, orrespondientes al diseño de
la ventana, hasta el momento
Debe notarse también que, en la parte inferior izquierda de la interfaz de

Netbeans, se en uentra un re uadro en el que se muestran los elementos que
3.2. JAVA 155
onforman la ventana sobre la ual estamos trabajando.
Figura 3.32: Panel en el que se muestran los omponentes que hemos añadido a la ventana.
Para nalizar la elabora ión de esta ventana, agregaremos otro omponente

de uso omún. Es el que pertene e a las lase JLabel y se utiliza para poner
etiquetas (texto simple) sobre la ventana.
Para este ejemplo, hemos añadido dos elementos de esta lase, uno (jLabel1)
que muestra el texto: Programa que re ibe el nombre de una persona, y
el segundo (jLabel2) en el que se en uentra el texto: Es riba aquí su nombre
quedando nuestra ventana tal omo se muestra en la gura3.33. Nota: Se ha
efe tuado un simple rea omodo de las posi iones de los omponentes de la
ventana, para darle una mejor presenta ión.
Figura 3.33: Ventana después de un rea omodo y además se agregó un omponente
JLabel.
Para los nes de los ejemplos que se in luyen en este texto, estos son todos
los omponentes que se utilizarán, por lo que no hablaremos de los demás. El
le tor interesado puede onsultar la API para ver la espe i a ión de estas
lases, o bien, onsultar algún texto espe ializado en estos temas.

Vamos a ontinuar trabajando sobre el proye to Creando Ventana, para
mostrar ahora omo leer y mostrar datos, teniendo así la intera ión hombre-máquina.
Para ha er más interesante y ompleto éste ejemplo, vamos a rear, dentro de
éste mismo proye to una nueva lase: la lase Alumno. La espe i a ión de
la lase es la siguiente:
Programa 3.2.2. Espe i a ión de la lase Alumno, dentro del proye to Creando
Ventana
/*
* To hange this template, hoose Tools | Templates
* and open the template in the editor.
*/
3.2. JAVA 157
/**
*
* author javier
*/
publi lass Alumno {

private String nombre;
private int edad;
private String es uela;
//Constru tor
publi Alumno(){
nombre=null;
edad=0;
es uela=null;
}
//Setters
publi void defineNombre(String x){
this.nombre=x;
}
publi void defineEdad(int x){

this.edad=x;
}
publi void defineEs uela(String x){

this.es uela=x;
}
//getters
publi String regresaNombre(){
return this.nombre;
}
publi int regresaEdad(){

return this.edad;
}
publi String regresaEs uela(){

return this.es uela;
}
}
Ahora, vamos a programar las instru iones que se realizarán uando se

pulse el boton A eptar, para esto, damos triple li k sobre el boton, o bien,
ha emos li k dere ho y sele ionamos:
Events>A tion>a tionPerformed
on lo ual se reará automáti amente en el ódigo fuente las siguientes líneas:
private void a eptarA tionPerformed(java.awt.event.A tionEvent evt){

// TODO add your handling ode here:
El ódigo que se es riba en el uerpo de este método sera eje utado ada
vez que se pulse el boton, durante la eje u ión del programa.
Le tura de String on getText()

Uno de los métodos de la lase JTextField es el getText(), el ual retorna
variables de tipo String. Enton es, para obtener el texto que se en uentra en
el JTextField basta es ribir la senten ia:
String x= re ibe.getText();
Este método es apli able a instan ias de la lase JTextField, tales omo el
objeto re ibe. En ésta instru ión estamos de larando una nueva variable de
lase String y además la ini ializamos omo el valor que se en uentre en el
JTextField re ibe.
Dado que este método retorna elementos de tipo String, si al momento
de orrer un programa se en uentra es rito un número (12.314 por ejemplo),
éste será alma enado omo String y no omo número.
3.2. JAVA 159
Re ordamos al le tor que seguimos trabajando sobre la ventana que hemos

reado desde la subse ión 3.2.6, más pre isamente la instru ión:
String x= re ibe.getText();
la ual es ribimos en el uerpo del método:
a eptarA tionPerformed(<argumentos>)
que orresponde al JButton que hemos nombrado a eptar. Además vamos

autilizar la lase Alumno. Es ribimos otras líneas de ódigo, quedando omo
en la gura 3.34:
Figura 3.34: Código es rito hasta ahora
Se expli a brevemente ual es el efe to de ada una de las instru iones de

éste ódigo:
Línea 114: Obtenemos ( omo String) el ontenido de re ibe.

Línea 115: Se reestable e el texto que se muestra en el JTextField
re ibe, esto on ayuda del método setText( String str), que puede
apli arse a objetos de la lase JTextField. Este método borra el texto
que ontiene el objeto y se muestra en éste la adena va ía : .
Línea 116: Con la llamada a este onstru tor, se rea un nuevo elemento
pertene iente a la lase Alumno.
Línea 117: Estable emos el texto que se obtuvo en la línea 114, omo el
atributo nombre del elemento nuevo.
Salida de String on getText()
Mostrar texto en la ventana que hemos reado, omo veremos, es muy

sen illo. El omponente salida, que es un elemento de la lase JTextAreal
Los objetos pertene ientes a esta lase tienen omo fun ión prin ipal mostrar
elementos de la lase String, aunque omo veremos más adelante, se pueden
mostrar tipos de datos numéri os muy fá ilmente.
Por el momento, para imprimir un String basta llamar a eje u ión al

método append(String str). Di ho método a túa sobre instan ias de la lase
JTextArea. Continuando on la onstru ión de éste ejemplo y en parti ular,
on la espe i a ión de las instru iones que se efe tuarán al utilizar el boton
a eptar, podemos es ribir en su respe tivo método la instru ión:
salida.append(x);
O bien, puede imprimirse el atributo del objeto nuevo que hemos reado.
Esta es la línea que in luiremos en el ódigo, y no la anterior, aunque en la
pantalla observariamos el mismo resultado, el programa estaría fun ionando
de dos maneras muy distintas.
salida.append(nuevo.regresaNombre());
Note que salida es, en efe to, un elemento de la lase JTextArea, por lo
que el ódigo fun ionará orre tamente.
Ahora pro edemos a eje utar el ódigo para ver omo es que fun iona.
En la gura 3.35 se muestra, a la izquierda, podemos observar la ventana
tal ual resulta de la eje u ión del programa, sin haberla utilizado. Por otra
parte, a la dere ha se en uentra el resultado que se obtiene después de es ribir
Fibona i en el omponente de tipo JTextField (destinado para re ibir datos
introdu idos por el usuario) y pulsar el boton A eptar. Debido a estas a iones,
y on ordando on el ódigo que es ribimos, se muestra en el omponente
destinado a mostrar texto, el nombre que hemos propor ionado al programa.
Debe quedar laro que el ódigo que hemos es rito en el uerpo del método
a eptarA tionPerformed(<argumentos>) se eje uta sólamente ada vez que
se presiona di ho boton.
3.2. JAVA 161
Figura 3.35: Eje u ión del programa. Antes (izquierda) y después (dere ha)
Durante la eje u ión de este programa, podemos ha er que se efe tue más
de una vez las a iones pogramadas para el boton A eptar. El le tor se dará
uenta al ha er esto, que el método setTetx() no propor iona por sí solo un
ambio de línea en el ampo destinado a mostrar el texto.
Para indi arle al ompilador de Java que haga un ambio de línea es

ne esario in luir el ará ter de es ape \n. Otros ará teres de es ape que
podemos utilizar se muestran en la siguiente tabla:
Cará ter de es ape Resultado

\n Cambio de línea
\t Tabulador horizontal
\r Retorno de arro
\b Ba kspa e(borrar ha ia atrás)
\' Comilla simple
\ Comilla doble
\\ Diagonal inversa
\f Form feed
Conversión de datos String a otros tipos

Con un objeto de tipo JTextField es posible obtener, omo ya hemos visto,
úni amente datos de tipo String. No pueden obtenerse dire tamente variables
numéri as. Sin embargo, una vez que se ha re ibido la informa ión que se
en uetre en di ho ampo, es posible onvertirla a otros tipos, tales omo los
tipos bási os:
byte
short
int
long
oat
double
o bien, omo elementos pertene ientes a las lases:
Byte
Short
Int
Long
Float
Double
No ha e falta más que unos ejemplos que ilustren omo se obtienen estos
tipos de datos:
String adena = re ibe.getText();
byte x1 = Byte.parseByte( adena);

short x2 = Short.parseShort( adena);
int x3 = Integer.parseInt( adena);
long x4 = Long.parseLong( adena);
float x5 =Float.parseFloat( adena);
3.2. JAVA 163
double x6 = Double.parseDouble( adena);
Byte x1 = Byte.parseByte( adena);

Short x2 = Short.parseShort( adena);
Integer x3 = Integer.parseInt( adena);
Long x4 = Long.parseLong( adena);
Float x5 =Float.parseFloat( adena);
Double x6 = Double.parseDouble( adena);
Note que para ada tipo bási o se emplea exa tamente el mismo método
(el de la lase que extiende a di ho tipo bási o), esto debido a que los tipos
bási os al no pertene er a ninguna lase, no poseen atributos ni métodos, pero
no ausa oni to asignarles el valor alma enado en un objeto de la lase que
es una extensión del tipo de dato bási o en uestión.
Es también importante men ionar que pueden presentarse di ultades al

intentar ha er este tipo de onversiones. Por ejemplo, si el argumento adena
está ompuesto por ará tres que no son números (y a lo más un punto de imal
para Float y double y las lases que los extienden), evidentemente habrá
oni tos. Por el momento suponemos (y tendremos uidado) que se mandan
argumentos válidos, en general, a los métodos. Ver subse ión 3.2.11 para el
tratado de ex ep iones
Le tura de otros tipos de datos on getText()

Ahora, resulta fá il leer datos de tipo numéri o a través del uso de un objeto
de la lase JTextField y el método getText. Primero obtenemos un String, y
posteriormente lo onvertimos (en aso de ser posible) al tipo de dato o lase
que se requiera. Para ilustrarlo, vamos a agregar un nuevo JTextField, al que
pondremos el nombre de variable re ibeEdad. Ponemos además su respe tivo
JLabel, para indi ar al usuario del programa, ual es el objetivo de di ho
ampo. Obteniendo algo omo en la gura 3.36:
Figura 3.36: Se agregaron omponentes para re ibir un número.
Proseguimos a es ribir el ódigo ne esario para poder obtener un número

entero desde este nuevo JTextField. En este ejemplo vamos a es ribir el
ódigo en el método que se eje uta al a ionar el boton A eptar, aunque
si así lo quisieramos, podríamos agregar otro boton y es ribir el ódigo de tal
manera que los pro esos de obtener un nombre y obtener una edad fueran
independientes, a tivandose éstos on diferentes botones. El ódigo que hemos
es rito se muesta en la imágen 3.37.
Figura 3.37: Se añadió ódigo para obtener un número entero. (Líneas 135-140)
No será di il para el le tor intérpretar ual es el objetivo de ada una

3.2. JAVA 165
de las líneas de ódigo que se agregaron (líneas 135-140 en ésta imágen).

Por el momento no vamos a eje utar el ódigo, pues aún no hemos visto
omo imprimir en un objeto de lase JTextArea variables numéri as. Antes,
pasemos a la siguiente subse ión.
Salida de otros tipos de datos on getText(). Con atena ión

Por el momento estamos interesados en mostrar texto y variables pertene ientes
a tipos numéri os en objetos pertene ientes a la lase JTextArea. A pesar de
que no existen métodos propiamente para ha er ésto, lo que si hay es un tru o
(método, pro edimiento) que nos permite pegar dos o más Strings, omo por
ejemplo:
String a = Pegando, b = palabras, ;

= a + b;
en la última instru ión estamos asignando a el String Pegandopalabras.

Aquí se observa que el signo de suma '+' pega, literalmente, las variables de
tipo String una tras otra. A este pro eso de pegar Strings se le ono e omo
on atena ión.
Es posible también on atenar variables de tipo String, har o Chara ter,

o in luso on valores onstantes (también de tipo String o har). Por ejemplo:
String x0 = Hola;
har x1 = 'e', x2 = 's';
Chara ter x3 = 't', x4 = 'u'
String enun iado = x0 + ' '+ esto + x1 + x2 + x3 + x4 + a + frase
Además. No se obtienen espa ios en blan o automáti amente. Éstos pueden

obtenerse omo ará teres (' '), strings ( ), o al denir un String, por
ejemplo al ha er
String w = Hola
es string está formado por las letras de Hola y un espa io en blan o..
Lo que en realidad nos interesa por el momento es poder mostrar tipos

de datos u objetos de tipos numéri os en un área de texto. Esto lo haremos a
través de la on atena ión, pues ésta también esta permitida entre los tipos de
datos di hos antes, y variables de tipo numéri o. Si on atenamos un String
on un entero, antes de on atenar se obtiene el String orrespondiente a di ho
entero.
Así pues, para imprimir el atributo edad del elemento nuevo del ejemplo
que venimos onstruyendo, es ribimos la instru ión (después de la línea 140
de la imágen 3.37):
salida.append(\n+ nuevo.regresaEdad());
Se muestra en la imagen 3.38 la eje u ión del programa on las modi a iones
he has hasta este instante:
Cabe men ionar que deben llenarse ambos ampos de texto pues, en aso
ontrario, se produ irá un error en la eje u ión del programa. Para solu ionar
o evitar este tipo de problemas se debe ha er el uso de ex ep iones. (ver
Subse ión 3.2.11)
Figura 3.38: Eje u ión del programa. Antes (izquierda) y después (dere ha) de pulsar el
boton
Por último, agregamos otro JTextField para re ibir un String, para

ini ializar el atributo es uela del elemento nuevo. Quedando el diseõ omo
en la imágen 3.39, y el ódigo fuente omo en la imágen 3.40
3.2. JAVA 167
Figura 3.39: Diseño nal de esta ventana
Figura 3.40: Código fuente nal de este programa


Note que en el digo se han he ho algunas modi a iones en los argumentos
de los métodos append() para darle presenta ión a los datos mostrados en el
ampo destinado para mostrar el texto. El resultado de una eje u ión ( on dos
a iones del boton) se ilustra en la imágen 3.41.
Figura 3.41: Eje u ión del programa nal (2 a iones de A eptar)
Entrada y salida de datos on JOptionPane

Existe otra alternativa muy sen illa de utilizar, por medio de la ual podemos
leer e imprimir datos. Existe la lase JOptionPane, in luida en el paquete
javax.swing. Para poder utilizar en este paquete la lase JOptionPane, debemos
in luir dentro de nuestro ar hivo, la instru ión:
import javax.swing.JOptionPane;
aunque también es osible importar todo el paquete, de la siguiente manera:

3.2. JAVA 169
javax.swing.*;
Para le tura vamos a utilizar el método:
JOptionPane.showInputDialog(String <textoAMostrar>);
donde <textoAMostrar> es el mensaje que se mostrará en la pantalla se usa

regularmente para indi ar al usuario que es lo que se espera que éste te lee. Esta
instru ión, durante la eje u ión de un programa tiene el efe to de mostrar una
ventana en la pantalla, en la ual podemos es ribir texto para propor ionarselo
al programa. Este método devuelve un String.
Y para mostrar texto en pantalla utilizaremos el método:
JOptionPane.showMessageDialog(null, String <textoQueSeImprime>);
El primer argumento lo dejaremos omo null (para más detalles onsultar el

uso de este método en la API). El segundo argumento, <textoQueSeImprime<,
onsiste del texto que deseemos mostrar, estando permitido utilizar la on atena ión
para poder imprimir tipos de datos numéri os. por ejemplo, podemos es ribir
en un programa (no ne esariamente dentro de un JFrame o de una lase
prin ipal) las instru iónes:
String x=JOptionPane.showInputDialog(Es riba su nombre);

JOptionPane.showMessageDialog(null, Ha es rito: +x);
Cuyos resultados al eje utarse son:
Figura 3.42: Izquierda: Resultado de la instru ión
JOptionPane.showInputDialog(Es riba su nombre);. Dere ha: Resultado de la
instru ión JOptionPane.showInputDialog(Ha es rito);


Las estru turas (o senten ias de ontrol) ondi ionales SI, SI-DOM y
SWITCH son implementables en el lenguaje de programa ión Java, pero
la senten ia SI-(DOM-SI) no posee un equivalente en este lenguaje. Las
senten ias equivalentes a SI, SI-DOM y SWITCH son if, if-else y swit h
respe tivamente.
Las de lara iones de estas enten ias son muy similares a omo se hi ieron
en el apítulo 2. Más pre isamente:
Senten ia if-else
if(< ondi ión>){
<instru iones1>
}
else{
<instru iones2>
}
Senten ia swit h
swit h(<variable>){
ase < 1>:{
<instru iones1>
break;
}
ase < 2>:{
<instru iones3>
break;
}
.
.
.
ase < K>:{
<instru ionesK>
break;
}
default{
<instru iones>
}
}
3.2. JAVA 171
Senten ia if
if(< ondi ión>) {
<instru iones>
}
Dado que ya se ha expli ado en el apítulo de algoritmi a omo es que
fun ionan estas senten ias de ontrol, nos vamos a limitar a mostrar un ejemplo,
implementado on ada una de éstas senten ias de ontrol ondi ionales. Cabe
men ionar que en este lenguaje de programa ión, si el uerpo de las senten ias
if o if-else onsta de una úni a instru ión, pueden omitirse las llaves. Del
mismo modo, para ada uno de los asos de la senten ia swit h pueden
omitirse las llaves.
Se implementará el ejemplo 2.2.5, que apare e en el apítulo de algorítmi a.

Di e lo siguiente:
Ejemplo 3.2.1. Ha er un programa que pida al usuario te lear una letra

(minús ula) del abe edario y que imprima en pantalla el mensaje Es vo al o
Es onsonante, según sea el aso. Utilizar la instru ión SWITCH ( swit h
en java).
Para este ejemplo, partimos del he ho de que hemos realizado las siguientes
a iones:
i ) Creamos un nuevo proye to, llamado Senten ias Condi ionales (sin
lase prin ipal).
ii ) Creamos dentro de éste proye to, una ventana (que es una lase que
extiende a la lase JFrameForm) omo la que se reó en la subse ión
3.2.6. Hemos nombrado a ésta Condi ionales.
iii ) se añadieron varias omponentes, quedando el diseño de esta ventana

omo en la imágen 3.43
Figura 3.43: Disenño de la ventana Condi ionales
iv ) El omponente para re ibir texto (JTextField) tiene omo nombre de

variable: entrada.
v ) El boton Senten ia if tiene omo nombre de variable: senten iaI.
vi ) El boton Senten ia if-else tiene omo nombre de variable: senten iaIE.
vii ) El boton Senten ia swit h tiene omo nombre de variable: senten iaS.
viii ) El omponente para mostrar texto (JTextArea) tiene omo nombre de

variable: salida.
Antes de programar las a iones de ada uno de los botones, vamos a

rear un método (no es del todo ne esario, ya que podemos implementar este
programa sin utilizar un método omo este) que sirve para veri ar si un
ará ter es o no vo al. Retorna true si el ara ter que se da omo argumento
es vo al, y false en aso ontrario. El ódigo orrespondiente es el siguiente:
3.2. JAVA 173
publi boolean esVo al(String ){

if( .equals(a)|| .equals(e)|| .equals(i)||
.equals(o)|| .equals(u)){
return true;
}
return false;
}
Note que aquí ya se está utilizando la senten ia if. Este método lo hemos
de larado en la parte inferior del ódigo fuente, pero dentro de la lase publi
lass Condi ionales extends javax.swing.JFrame. Además, para nes de
este ejemplo vamos a tratar a los ará teres omo variables de tipo String, ya
que esta lase es más ri a en métodos y más manejable que el tipo bási o har
y la lase Chara ter. El método equals() sirve para omparar si el String
al que se apli a, es igual al objeto que se indi a omo argumento del método.
Para más detalles onsultar la API.
Ahora si, el ódigo para el boton Senten ia if es:
private void senten iaIA tionPerformed(java.awt.event.A tionEvent

evt) {
String aux = entrada.getText();
if(esVo al(aux)){
salida.append(La letra + aux + es VOCAL\n);
}
if(!esVo al(aux)){
salida.append(La letra + aux + es CONSONANTE\n);
}
salida.append(Fin del programa\n);
}
El ódigo para el boton orrespondiente a la senten ia if-else es:

private void senten iaIEA tionPerformed(java.awt.event.A tionEvent

evt){
if(esVo al(aux)){
}
else{
}
}
Finalmente, para la senten ia swit h, nos hemos visto en la ne esidad de

denir otro método, debido a que no está permitido que <variable> sea de
tipo String. Así que el método que nemos reado nos devuelve ero si la letra
no es vo al, 1 si es la a, 2 para la e, ..., hasta 5 par la u. El ódigo de éste
método es:
3.2. JAVA 175
publi int pasaAEntero (String s){

int w=0;
if(!esVo al(s)){
return 0;
}
if (s.equals(a){
return 1;
}
else{
if(s.equals(e)){
return 2;
}
else{
if(s.equals(i)){
return 3;
}
else{
if(s.equals(o)){
return 4;
}
else{
return 5;
}
}
}
}
}
Y el ódigo a eje utar al a ionar el boton orrespondiente a a la senten ia

swit h es:
private void senten iaSA tionPerformed(java.awt.event.A tionEvent

evt){
int n= pasaAEntero(aux);
swit h (n){
ase 1:{
break;
}
ase 2:{
break;
}
ase 3:{
salida.append(La letra + aux + es VOCAL\n");
break;
}
ase 4:{
break;
}
ase 5:{
break;
}
default:{
}
}
}
El resultado de una eje u ión del programa se muestra en la imágen 3.44.

Primero se eje utó on el boton orrespondiente a la senten ia if, en segundo
lugar, on el de la senten ia if-else y, por último, on el orrespondiente a la
senten ia swit h.
3.2. JAVA 177
Figura 3.44: Eje u ión de la ventana Condi ionales. Las dos primeras líneas se obtuvieron
al pulsar el boton Senten ia if, las ter era y uarta on el boton Senten ia if-else y las
dos últimas on el boton restante.


To a turno a las senten ias de ontrol iterativas, las uales, omo se vió
en apítulos anteriores, nos permiten eje utar una antidad nita de ve es un
determinado fragmento de ódigo, sujeto a que se umplan iertas ondi iones.
En el apítulo 2 hemos presentado tres senten ias de repeti ión: MIENTRAS,

HACER-MIENTRAS y PARA, también llamadas i los. Sus equivalentes
en java son: while, do-while y for respe tivamente. Sus de lara iones en este
lenguaje de programa ión se efe túan de la siguiente manera:
while(< ondi ión>) {

<instru iones>
}
do{
<instru iones>
} while(< ondi ión>)
for(<opera ión ini ial>;< ondi ión>;<opera ión de varia ión>){

<instru iones>
}
Pasaremos dire tamente a un ejemplo, pues ya se ha expli ado en el apítulo

2 omo fun ionan ada una de estas senten ias. Enseguida onstruiremos un
ejemplo similar al presentado en la subse ión 3.2.8.
Ejemplo 3.2.2. Con un grupo de una antidad n (te leado por el usuario)
de ani as se forma una pirámide de base uadrada, on una úni a ani a
en su vérti e superior y un número uadrado perfe to de ellas en ada etapa.
¾Cúantas apas se obtendrán?, y ¾Cúantas ani as sobrarán?
Antes de ontinuar, partimos del he ho de que, para este ejemplo, hemos

realizado las siguientes a iones:
i ) Creamos un nuevo proye to, llamado Senten ias Iterativas (sin lase
prin ipal).
ii ) Creamos dentro de éste proye to, una ventana (que es una lase que
3.2. JAVA 179
extiende a la lase JFrameForm) omo la que se reó en la subse ión

3.2.6. Hemos nombrado a ésta Ci los.
iii ) Se añadieron varias omponentes, quedando el diseño de esta ventana

omo en la imágen 3.45
Figura 3.45: Disenño de la ventana Ci los
iv ) El omponente para re ibir texto (JTextField) tiene omo nombre de

variable: entrada.
v) El boton Senten ia while tiene omo nombre de variable: senten iaW.
vi) El boton Senten ia do-while tiene omo nombre de variable: senten iaDW.
vii ) El boton Senten ia for tiene omo nombre de variable: senten iaF.
viii ) El omponente para mostrar texto (JTextArea) tiene omo nombre de

variable: salida.
Una vez he ho esto, es ribimos los fragmentos de ódigo para las a iones
de ada uno de los botones. Primero, para el boton Senten ia while, el ódigo
es:
private void senten iaWA tionPerformed(java.awt.event.A tionEvent

evt){
int n, x=0,y=0,i=1, k=0;
n=Integer.parseInt(entrada.getText());
salida.append( Solu ión on while\n
+ Con un grupo de n ani as se forma una pirámide\n
+ de base uadrada, on una úni a ani a en su\n
+ vérti e superior y un número uadrado perfe to de\n
+ ani as en ada etapa.¾Cuántas ani as sobrarán?\n);
while(k<n){
k=k+i*i;
i++;
if(k<=n){
y++;
x=k;
}
}
salida.append(El número de apas es + y + \n);
salida.append(Las ani as sobrantes son + (n-x) + \n\n);
}
3.2. JAVA 181
Y para la Senten ia do-while:
private void senten iaDWA tionPerformed(java.awt.event.A tionEvent

evt) {
int n, x=0,y=0,i=1, k=0;
salida.append( Solu ión on do-while\n
+ Con un grupo de n ani as se forma una pir'amide\n
do{
k=k+i*i;
i++;
if(k<=n){
y++;
x=k;
}
}while(k<n);
}
Finalmente, el odigo orrespondiente al boton Senten ia for es:
private void senten iaFA tionPerformed(java.awt.event.A tionEvent

evt){
int n, x=0,y=0,i, k;
salida.append( Solu ión on for\n
+ Con un grupo de n ani as se forma una pirámide\n
for(k=0, i=1;k<n;i++){
k=k+i*i;
if(k<=n){
y++;
x=k;
}
}
}
En la imágen 3.46 se muestra el resultado de la eje u ión de éste programa

que hemos reado. Los resultados (para un mismo número te leado por el
usuario) son exa tamente los mismos, aunque el fun ionamiento interno del
programa es distinto, pues se emplearon diferentes senten ias de ontrol iterativas
para implementarlos.
3.2. JAVA 183
Figura 3.46: Resultado de la eje u ion del la ventana Ci los

3.2.10. Arreglos
Ve tores (arreglos de una dimensión)
En Java existen dos maneras de de larar arreglos de una sola dimensión
(ve tores):
<tipoDeDato> <nombreDelVe tor>[℄;
<tipoDeDato>[℄ <nombreDelVe tor>;
las uales son equivalentes.
El tipo de dato que se alma ena en ada una de las entradas de un ve tor
puede ser String, ualquiera de los tipos bási os de Java o bien, elementos
pertene ientes a las lases que extienden a los tipos bási os, tales omo Byte,
Short, Integer, et ., on la restri ión de que todas las entradas deben ser
del mismo tipo.
Por otra parte, para ini ializar un ve tor debemos es ribir una línea omo
la siguiente:
<nombreDelVe tor> = new <tipoDeDato>[<tamañoDelVe tor>℄;
Durante la ini ializa ión de un arreglo es obligatorio espe i ar el tamaño

del ve tor. Para referirnos a alguna de las entradas del ve tor, ya sea para
ini ializa ión, onsulta o asigna ión, basta invo arla de la siguiente manera:
<nombreDelVe tor>[i℄
donde i es un número entero entre ero y (<tamañoDelVe tor>-1).
A modo de ejemplo onsidere el siguiente ódigo, el ual es un programa

ompleto y muy sen illo:
Programa 3.2.3.
3.2. JAVA 185
import javax.swing.JOptionPane;
publi lass Ve tores {
publi stati void main(String[℄ args){

int n = Integer.parseInt(JOptionPane.showInputDialog(
Introduz a un número entero positivo));
String ve [℄, frase = ;
ve = new String[n℄;
for(int k = 0 ; k <n; k++ ){
ve [k℄ = JOptionPane.showInputDialog(
+ Te lee una palabra);
frase = frase + ve [k℄ + ;
}
JOptionPane.showMessageDialog(null, frase);
}
Observe que hemos utilizado, para la entrada y salida de datos, la lase

JOptionPane (por eso se importa parte del paquete javax.swing). Se de laró
un ve tor que alma enará en sus entradas, variables de tipo String.
El tamaño del ve tor es un número introdu ido por el usuario antes de

ini ializar el ve tor. Re uerde además que los indi es de las entradas de un
ve tor de tamaño n van desde ero hasta n − 1. Además nos hemos valido
de la on atena ión para poder imprimir (de he ho formar una frase) en un
solo JOptionPane, pues de otra manera tendríamos que mostrar ada una de
las entradas en ventanitas diferentes. Enseguida se muestra la eje u ión del
programa:
Figura 3.47: (1)Resultado de la eje u ión del programa 3.2.3


3.2. JAVA 187
También podríamos denir las entradas de un ve tor listandolas en forma de

se uen ia ( onjunto ordenado). Por ejemplo, el mismo ve tor que se introdujo
en el ejemplo anterior puede ini ializarse omo:
String ve [℄;
ve = {Esta, es, una, frase, ompleta}
Por otra parte, abe resaltar de nuevo que, en la línea:
int n = Integer.parseInt(JOptionPane.
showInputDialog(Introduz a un número));
si se te lea un ará ter, el ará ter va ío, un número no entero o entero no

positivo en vez de un número entero positivo, el programa entra en un estado de
error, debido a que <tamañoDelVe tor> debe ser un número entero positivo,
y estaríamos dando omo este parámetro un valor no válido. Así que este
programa fun iona ade uadamente si y sólo si se te lea un número entero
positivo y, en aso ontrario, se produ e un eror. En la siguiente (y última de
Java) se ión se expone el tema de las ex ep iones, las uales nos permiten
evitar problemas de este (y otros) tipo(s).
Matri es (arreglos bidimensionales)

De manera similar a los ve tores en Java hay dos maneras distintas, pero
equivalentes, para de larar matri es, es de ir, arreglos bidimensionales (ve tores
de ve tores). Estas dos maneras son:
<tipoDeDato> <nombreDeLaMatriz>[℄[℄;
<tipoDeDato>[℄[℄ <nombreDeLaMatriz>;
y se ini ializan de la siguiene manera:
<nombreDeLaMatriz> = new <tipoDeDato>[<númeroColunmas>℄[<númeroFilas>℄
Es obligatorio espe i ar <númeroColunmas> y <númeroFilas> (ambos

número entero positivos). Considerémos el siguiente ódigo, en el que se rea
una matriz de tamaño 5×4, on todas sus entradas iguales a ero (de tipo int).
publi lass Ve tores {

publi stati void main(String[℄ args){

int mat[℄[℄;
mat = new int[5℄[4℄;
for(int i = 0 ; i <5 ; i++){
for(int j = 0 ; j<4 ; j++ ){
mat[i℄[j℄=0;
}
}
//Para imprimir la matriz:
for(int i = 0 ; i <5 ; i++){
for(int j = 0 ; j<4 ; j++ ){
System.out.print(mat[i℄[j℄=0);
System.out.print(\t);
}
System.out.print(\n);
}
}
Este programa también puede implementarse en un omponente JFrameForm,

omo los que ya hemos reado en ejemplos anteriores.
3.2.11. Ex ep iones
Hemos men ionado previamente que en algunos asos, abe la posibilidad
de que un programa entre en un estado de error mientras se en uentra en
eje u ión (aunque la ompila i'on haya sido exitosa), uyas posibles ausas
son de tipo semánti o tales omo intentar dividir por ero, asignar un número
de punto otante a una variable entera, salirse del rango del tamaño de un
ve tor, et . Cuando un error de este tipo se produ e, la JVM rea un objeto
pertene iente a la lase Ex eption y se noti a esta situa ión al sistema de
eje u ión (en el aso de Netbeans en la noti a ión se realiza en la onsola de
este IDE). Una vez reada la ex ep ion, la JVM bus a algún método apaz de
tratar la ex ep ión, efe tuando la busqueda primero dentro del método desde
el que se produjo el error, y si no lo en uentra, bus a ahora dentro del método
desde el que se hizo la llamada al método en el que se produjo el error, y así
su esivamente hasta que en uentra el método que trate la ex ep ión (si es que
3.2. JAVA 189
existe) o hasta que no hay más donde bus ar. Si ningún método es apaz de
tratar la ex ep ión, la JVM manda un mensaje de error y el programa naliza.
Para tratar las ex ep iones, en Java existen los manejadores de ex ep iones:
try
at h
finally
los uales no son más que fragmentos de ódigo en los que el programador
puede espe i ar que a iones se deben realizar en aso de que se produz a
una determinada ex ep ión (prevista por el mismo programador).
Estos manejadores de ex ep iones se emplean de la siguiente manera:
try{
<Instru iones>
} at h(<tipoDeEx ep ión> <nombreDeVariable>){
<instru iones1>
}
at h(<tipoDeEx ep ión> <nombreDeVariable>){
<instru iones2>
}
.
.
.
finally{
<instru ionesn>
}
En el bloque de instru iones de try deben es ribirse las líneas (o el fragmento)

de ódigo que el programador onsidera sus eptible de produ ir una ex ep ión.
Si no se genera ex ep ión alguna, al eje utar todas las instru iones de try, el
ujo del programa pasa a eje utar el bloque de instru iones de nally. Si por
el ontrario, se produ e una ex ep ión estando en eje u ión las instru iones
de try, inmediatamente se abandona el bloque try, pasando a eje utarse las
instru iones del bloque at h que sea apaz de tratar la ex ep ión. En general
puede haber más de un bloque de at h, ada uno de los uales tratarán
diferentes tipos de ex ep iones. Una vez que se eje utaron las instru iones
del at h para la ex ep ión produ ida, el ujo del programa pasa al bloque
nally y se eje utan ada una de las instru iones de éste. Cabe la posiblidad
de que no esté presente el manejador nally.
Ahora men ionaremos algunos de los tios de ex ep iones. En Jaava los

errores se representan mediante alguna de las lases Error o Ex eption,
ambas derivadas de la lase Throwable. Se mandá un error mediante un
objeto de lase Error uando el error se produ e por errores de ompila ión,
del sistema o de la máquina virtual. El programador no puede apturarlos
y tratarlos, es de ir, son irre uperables. Por otra parte, un error de tipo
Ex eption puede lasei arse en uno de los dos tipos siguientes:
Ex ep iones implí itas: Pertene en a la lase RuntimeEx eption que
es una sub lase de Ex eption. Son ex ep iones quela mayoría de las
ve es tiene que ver on errores de programa ión, y que el programador
debería tener uidado para no aer en ellos. Ejemplos de esto son pasar
referen ia null a un método, o intentar a eder a una po isón fuera del
rango de un arreglo, por men ionar algunos. Aunque es posible omprobar
y apturar estos errores para tratarlos, no se ha e así, pues tiene un
osto: el ódigo se ha e más extenso y ompli ado, además de que se
ne esitará posiblemente mayor tiempo para eje u ión. Es por esto que el
programador no ne esita estable er los manejadores de ex ep iones para
este tipo de errores.
Algunas de éstas son NullPointerEx eption, IndexOutOfBoundsEx eption,

NegativeArraySizeEx eption, et .
Ex ep iones explí itas: Son todas las lases derivadas de Ex eption,
que no pertene en a la sub lase RuntimeEx eption. El programador
está obligado a tenerlas en uenta y tratarlas en aso de produ irse.
Ejemplos de éstas son IOEx eption y AWTEx eption, sub lases de
Throwable. A su vez, EOFEx eption, FileNotFoundEx eption,
MalformedURLEx eption son sub lases de IOEx eption.
Veamos un ejemplo: Consideremos el programa 3.2.3. En la línea:
int n = Integer.parseInt(JOptionPane.showInputDialog(
Introduz a un número entero positivo));
puede produ irse un error, si en lugar de te lear un número se te lea ualquier

ará ter no numéri o, numéri o no positivo, numéri o otante, et . Por ejemplo,
3.2. JAVA 191
al eje utar di ho programa y te lear el número -1, en la onsola se muestra el

siguiente mensaje de error:
Figura 3.54: Error produ ido al te lear un número no válido
Se observa en la gura 3.54 que la ex ep ión que se produ e es de tipo

java.lang.NegativeArraySizeEx eption. Si se te lea una letra en lugar de
un número se produ e ena ex ep ión de tipo java.lang.NumberFormatEx eption.
Para no tratar varias ex ep iones (pues son mu has a onsiderar) vamos a
utilizar la lase Ex eption. El ódigo queda ahora omo se muestra a ontinua ión:
Figura 3.55: Código equivalente al programa 3.2.3 apturando y tratando la ex ep ión
Observe que los manejadores de ex ep iones solo se en argan de veri ar

que se asigne efe tivamente un número entero a la variable n. Es por eso que
hemos veri ado después (dentro de la senten ia if), que el n sea positivo.
3.3. PHYTON 193
3.3. Phyton
Como ya se dijo antes Python es un lenguaje interpretado, una de sus
ara terísti as prin ipales es que su es ritura es muy sen illa, al grado de
que los programas es ritos en este lenguaje se asemejan on mu ho a los
pseudo ódigos.
Python viene instalado por omision en la mayoría de las distribu iones

de Linux y en las últimas de Ma OS X. Para veri ar si está instalado basta
es ribir python en una terminal de omandos. Si ya está instalado, en la onsola
se mostrará la versión de Python que está instalada y al nal apare erá el
prompt ( >>> ), el ual indi a que el intérprete de Python está listo para
que el usuario es riba ódigo a ser eje utado.
3.3.1. Interpreta ión y eje u ión de un programa

Existen dos maneras de es ribir y eje utar ódigo en este lenguaje:
Es ribir líneas de ódigo dire tamente en el intérprete y obtener una

respuesta inmediata ( al presionar enter) del intérprete. Para ha er
esto basta on es ribir python en una terminal de omandos y es ribir
las instru iones una vez que aparez a el prompt. A esta forma de trabajo
se le llama sesion intera tiva ( gura 3.56).
Figura 3.56: Sesion intera tiva de Python
Es ribir el ódigo fuente en un ar hivo de texto y después eje utarlo.
Aquí vamos a utilizar la segunda op ión, aso en el ual la eje u ión de un

programa se realiza de la siguiente manera:
i ) Es ribir el ódigo fuente en un editor de texto y guardarlo on la extensión

.py
ii ) Abrir una teminal de omandos o onsola.
iii ) A eder al dire torio en que está guardado el ar hivo del punto I).
iv ) Es ribir la instru ión python <nombre.py>
Para es ribir el ódigo fuente de los programas, puede emplearse ualquer

editor de textos omo por ejemplo gedit o Geany, de preferen ia alguno que
tenga la op ión de resaltado sintá ti o, omo los aquí men ionados. En esta
se ión vamos a utilizar gedit. Otra alternativa es utilizar algún Entorno de
Desarrollo integrado (IDE), tales omo E lipse o Netbeans que además soportan
otros lenguajes de programa ión.
Ahora vamos a mostrar omo se eje uta un programa es rito en python

vamos a es ribir el siguiente ódigo en el editor de textos (el ar hivo fue
guardado on el nombre primero.py):
Figura 3.57: Paso I
Enseguida abrimos una terminal y vamos hasta la arpeta ProgramasPython

ubi ada en el es ritorio, y efe tuamos el paso IV, omo se muestra en la gura
3.58:
3.3. PHYTON 195
Figura 3.58: Pasos II, III y IV
Como puede observarse, el resultado de este programa es es ribir en la

pantalla Mi primer programa en python.
En otros lenguajes (p.e. Java y C) se indi a el nal de una instru ión

on punto y oma. En Phyton esto no es ne esario.
Por otra parte, la instru ión print es una fun ión predenida en Python,
y se utiliza para imprimir en la pantalla el texto, o los datos que se en uentran
enseguida. Se darán más detalles en la subse ión 3.3.6. Tampo o hemos denido
lo que es una fun ión, pero por el momento basta saber que se trata simplemente
de una se uen ia de instru iones que tiene una tarea espe í a dentro de un
programa. Se abordará más sobre ellas en 3.3.7
3.3.2. Comentarios
Un programa puede, en general, ser muy extenso, por lo que es re omendable
poner omentarios para indi ar (al programador), por ejemplo, ual es el
objetivo de alguna variable o in luso de un fragmento de ódigo. Los omentarios
en éste lenguaje omienzan on #. Así, todas las líneas que omien en on este
símbolo (#) no son senten ias en Python, por lo que no tienen interpéta ión al
eje utar un programa.
3.3.3. Variables
En la mayoría de los lenguajes de programa ión, es ne esario de larar las
variables, espe i ando además el tipo al que perene en. In luso hay lenguajes
( omo Java) que exigen más aún, deben de lararse las variables espe i ando su
tipo y, además hay que ini ializarlas antes de intentar ompilar los programas,
pues de no ser así, la ompila ioón no se realiza exitosamente.
En Python no es ne esario indi ar ual es el tipo al que pertene e una

variable, es de ir, no es ne esario de larar su tipo. Sin embargo, no se puede
utilizar una variable a la que no se le haya asignado previamente algún valor.
En otras palabras, la primera opera ión que debe realizarse sobre una variable
es asignarle un valor, esto es, ini ializarla.
Para asignar un valor una variable en este lenguaje lo uni o que hay que
ha er es es ribir un nombre para ella (la variable) y asignarle un valor de
alguno de los tipos que se men ionarán más adelante. En general, esto se ha e
on senten ias omo:
<nombreDeVariable> = <expresión>
Llamamos identi ador de variable al nombre que se le da a una variable.

Los identi adores permitidos en Python deben umplir las siguientes reglas:
Pueden tener letras mayús ulas o minús ulas, números (y el guión bajo).
Ningun identi ador puede omenzar on un dígito.
Un identi ador no puede ontener espa ios en blan o.
No debe on idir on las palabras reservadas del lenguaje. Se presentan

en la siguiente tabla:
and assert break lass

ontinue def del elif
else ex ept exe nally
for from global if
import in is lambda
not or pass print
raise return try while
yield
Es de ir las palabras anteriores no podrán ser utilizadas omo nombres

de variables.
Se distingue entre mayús ulas y minús ulas. Esto es, var y Var serían
dos variables distintas.
3.3. PHYTON 197
Además, Python es un lenguaje on tipado dinámi o, es de ir, que durante

la eje u ión de un mismo programa, una variable puede alma enar valores de
diferentes tipos, por ejemplo si ha emos:
x=5
x=4.0
se tiene que la variable llamada x alma ena primero un valor entero, y despúes
de la segunda asigna ión alma ena un valor otante. Esto no se genera oni to
alguno en la interpreta ión y eje u ión de un programa. En otros lenguajes, por
ejemplo C, si asignamos un valor otante a una variable de tipo entero, habrá
problemas de ompila ión y/o eje u ión. Así pues, no se de lara el tipo de una
variable debido a que podrá ambiar durante la eje u ión de un programa. Los
tipos bási os de Python son: números, adenas y booleanos.
Debe el programador tener extremo uidado on el tipado dinámi o, ya

que podría intentar efe tuar opera iones no válidas sobre alguna variable, por
ejemplo, intentar manipular un ará ter (no número), digamos, omo si fuera
un número on punto de imal.
3.3.4. Tipos de datos bási os

En esta subse ión presentamos una des rip ión breve a er a de los tipos
de datos bási os de este lenguaje:
Números
• Enteros
• Flotantes
• Complejos
Cadenas
Booleanos
Números
En Python pueden manejarse tres tipos de variables numéri as:
Enteros: Los números enteros (positivos, negativos o ero) se representan
en Python mediante el tipo int. Pueden alma enarse números entre −231
y 231 − 1, es de ir, desde -2147483648 hasta 2147483647. En dado aso

que ne esitemos alma enar un número mayor en valor absoluto al rango
espe i ado antes, podemos emplear el tipo entero long. Con este tipo
de dato podemos alma enar números de ualquier magnitud, siendo la
memoria en el dis o duro de la omputadora la úni a limitante.
Por omisión, uando reamos una nueva variable entera, se alma ena
omo tipo de dato int. Sólo en aso de que el número no se en uentre
dentro del rango del tipo int es omo será alma enado omo tipo long.
Por otra parte, si alma enamos un número pequeño (no long) podemos
indi arle al intérprete de Python que lo alma ene omo tipo long simplemente
agregando una L (mayús ula) inmediatamente despúes del último dígito
del número. Por ejemplo:
n=1941L
Flotantes: Es un tipo de dato que puede alma enar números on punto

de imal dentro de los rangos (+/−)2,2250738585072020 × 10−308 hasta
(+/−)1,7976931348623157308. A una variable se le asigna un número
real de la manera tradi ional, por ejemplo:
r=3.1416
s=2.0
Además abe la posibilidad de que expresemos un número otante en

su nota ión ientí a. Para esto se es ribe una 'e' después del último
dígito del número, y seguida del exponente (en base 10). Por ejemplo, en
Python el equivalente al número 4,3219123 × 1012 es:
4.3219123e12
El exponente puede ser también negativo:
0.3193e-8
Complejos: Un omplejo en Python es, en esen ia, un número omplejo

en el sentido matemáti o usual. Es de ir, onsta de dos partes: parte real
y parte imaginaria. Un omplejo es de tipo omplex. La de lara ión de
3.3. PHYTON 199
un omplejo es muy simple:
omp = 3i +2j
z=22.132+0.2j
Cadenas
Una adena en Python es una se uen ia de ará teres en errados entre
omillas simples (' ') o omillas dobles ( ). Las adenas pertene en al tipo
str. En el programa uyo ódigo se muesta en la gura 3.57 apare e entre
omillas dobles el texto Mi primer programa, es de ir es una adena. También
pudo es ribirse en errada entre omillas simples:
'Mi primer programa'
Existe una ter era manera de representar adenas, siendo esta última empleada
para es ribir una adena en varias líneas. Para esto, en erramos entre omillas
(simples o dobles) triples el texto que onformará la adena. Por ejemplo:
ad= 'Esta es una

adena de texto es rita
en más de una línea'
Las adenas tiene unas porpiedades muy pe uliares, pues pueden apli arse
a ellas los operadores + y *.
El operador suma, apli ado a dos adenas, las pega (una tras otra) literalmente,
lo que se ono e omo on atena ión. Por ejemplo, si:
a='Hola' b=mundo
enton es
= a + ' ' + b
es la adena hola mundo. Por otra parte, el operador * efe túa la multipli a ión
de un número entero y una adena. El resultado onsiste en la repeti ión de la
adena, la antidad de ve es indi ada por di ho número. por ejemplo, on la
adena es rita arriba y las instru iones:
print 2*
print *2
se obtiene:
holamundoholamundo
holamundoholamundo
Por último, dentro de las omillas pueden in luir ará teres de es ape, tales
omo el ambio de línea '\'. Otros ará teres de es ape son:
Cará ter de es ape Resultado

\n Cambio de línea
\t Tabulador horizontal
\r Retorno de arro
\' Comilla simple
\ Comilla doble
\\ Diagonal inversa
\f Form feed
Booleanos
Las variables booleanas o tipo boolean pueden alma enar uno de entre los
dos valores de verdad: True o False, por ejemplo:
m=True
n=False
Se utilizan para ha er ompara ionés lógi as, utilizando los operadores lógi os
omo veremos más adelante. También, algunas senten ias omparativas (o
fun iones) regresan un valor de verdad.
Las variables y sus tipos

Si en determinado momento des ono emos ual es el tipo de dato al que
pertene e alguna variable, podemos re urrir a la fun ión predenida
type(<variable>)
3.3. PHYTON 201
la ual nos indi a el tipo de valor que se alma ena dentro de una variable.
Como ya lo men ionamos hantes, dado que no se de lara el tipo de las

variables en Python, ésta puede tomar dentro de un mismo programa valores
de diferentes tipos. Puede alma enar primero un número entero, despúes un
valor booleano o omplejo, et . Considére, a modo de ejemplo:
a=3
b=2
=a+b
=True
=2+3j
Si utilizamos la fun ión type(<variable>), de la siguiente manera:
a=3
b=2
=a+b
print type( )
=True
print type( )
=2+3j
print type( )
obtenemos el siguiente resultado en la onsola:
Figura 3.59: Uso de type()
Re uerde que la asigna ión es una opera ión destru tiva, por lo que en
las líneas de ódigo es ritas arriba, primero la variable es de tipo entero.

Al asignarle el valor de verdad True deja de ser de tipo entero, siendo ahora
de tipo booleano, y nalmente, on la última instru ión pasa a ser de tipo
omplejo.
El he ho de no tener que de larar el tipo al que pertene e una variable

tiene sus ventajas y desventajas. Re al amos que debe tenerse mu ho uidado
on las asigna iones que se efe tuen, para no tener resultados anormales o no
deseados.
3.3.5. Operadores
A ontinua ión se presentan algunos de los operadores que están disponibles
en Python. En este texto sólo hemos in luido los que nos serán de utilidad para
los objetivos del presente.
Los operadores aritméti os apli ables a los tipos de datos numéri os en
Python son los mismos que se han dado en la subse ión 2.1.3 de este texto,
más el operador operador poten ia (**) on su signi ado usual. El operador
módulo es apli able sólo a los tipos de datos enteros.
La pre eden ia en la eje u ión de los operadores aritméti os en Python

se sujeta a lo estable ido en las reglas de la aritméti a usual. De esta forma la
poten ia tiene pre eden ia sobre los demás operadores, produ tos y o ientes
tienen mayor pre eden ia que las adi iones y sustra iones. Operadores de
igual pre eden ia son evaluados de izquierda a dere ha onforme han sido
**: Mayor pre eden ia que los demás. Este opreador aso ia de dere ha a
izquierda. Es de ir, 3**4**5 representa 3( 45 ) y no (34 )5 .
*, /, %: tienen la misma pre eden ia, por lo que operadores de igual

pre eden ia son evaluados de izquierda a dere ha onforme han sido
espe i ados en la expresión orrespondiente.
+, −: Operadores de igual pre eden ia son evaluados de izquierda a

dere ha onforme han sido espe i ados en la expresión orrespondiente.
3.3. PHYTON 203
A pesar de ono er las pre eden ias, para evitar ambigüedades y dar mejor
legibilidad a los programas se re omienda ha er expí ito el orden en que deben
ha erse las opera iones, mediante el uso de paréntesis. Un pro eso urioso se
da uando dividimos dos números enteros en Python. Considere la asigna ión:
x=1/2
El resultado que esperaríamos es que x=0.5, sin embargo, si esta instru ión
apara iera en un programa en Python, el valor alma enado en la variable x
sería 0. Esto porque en este lenguaje al operar dos enteros se obtiene de nuevo
un entero. El valor devuelto de un o iente de dos números enteros es igual a
la parte entera del resultado ( omo otante) de di ho o iente. Para obtener
el resultado on de imales, es ne esario que al menos uno de los operandos sea
un número otante. Por ejemplo:
x=1.0/2
siendo ahora el resultado x=0.5.
En general, en este lenguaje de programa ión, si se efe tua alguna opera ión
aritméti a en la que los operandos son de tipos distintos, el tipo de dato del
resultado será el tipo más general de los dos operandos. Los tipos numéri os,
de más general a menos general se muestran enseguida:
Complejo
Flotante
Entero


Tienen todos la misma pre eden ia y menor que la de los operadores

aritméti os.
En Python no existen los operadores de in remento y de remento unitarios

(++ y −−), los uales se presentaron en el apítulo 2 junto on los demás
operadores de asigna ión ompuestos.
Operadores lógi os
En este lenguaje, la sintaxis para ellos es la siguiente:
Conjun ión: and

Disyun ión: or
Nega ión: not
La pre eden ia del operador disyun ión es menor a la de la onjun ión. La
aso iatividad de and y or es de izquierda a dere ha.

Son los operadores de rela ión que se han men ionado en el apítulo 2:
igual que: ==
menor que: <
mayor que: >

3.3. PHYTON 205
diferente que: ! =
Respe to a estos operadores solo resta men ionar todos tienen la misma
pre eden ia. No hay una manera de aso iarse por omisión, ya que éstos operadores
son binarios. ¾Qué signi ado tendría, en el sentido usual, 3<4<=5?. Si se
aso iara de izquierda a dere ha se ompararía primero 3<4, que resulta verdadero.
La siguiente ompara ión sería True<5 lo ual no tiene ningún signi ado.
Sin embargo, Python si permite ente tipo de ompara iones, devolviendo el
resultado de la ompara ión:
(3<4) and (4<=5)

hemos presentado son solo algunos de los operadores que pueden utilizarse en
este lenguaje pero nos hemos limitado a presentar úni amente los que serán
de utilidad para los propósitos de este texto.
En la siguiente tabla se muestran un resumen de los operadores des ritos

anteriormente, así omo las pre eden ias. Los operadores que guran en la
misma línea tienen la misma pre eden ia, mientras que los operadores que
están más arriba tienen mayor pre eden ia que los que guran en líneas más
inferiores en la tabla.
Operadores Aso iatividad

** dere ha a izquierda
*, /, % izquierda a dere ha
+, − izquierda a dere ha
<, <=, >, >=, ==, !=
not
and izquierda a dere ha
or izquierda a dere ha
=, +=, −=, *=, /=, %=
De uaquier manera, se re omienda, para evitar ambugüedades tanto en la

le tura omo en la interpreta ión de éste tpo de expresiones, que el programador
haga la agrupa ión explí ita de las expresiones a través del uso de paréntesis,
en fun ión de lo que se desee expresar.

Ahora vamos a hablar un po o sobre la entrada y salida de datos mediante
el te lado y la pantalla, respe tivamente. Para esto vamos a emplear algunas
fun iones predenidas de Python. Aunque el tema de las fun iones se tratará en
el siguiente partado (subse ión 3.3.7), no es ne esario saber gran osa a er a
de ellas, sino solamente para que sirven y que tipo de parámetros a eptan.
Salida de datos
En algunos de los programas previos hemos mostrado datos a través de la
pantalla utilizando la fun ión predenida print.
Como hemos visto, pueden imprimirse adenas, por ejemplo:
print Imprimiendo por pantalla
Durante la eje u ión de esta instru ión, se mostrará en la pantalla el

texto Imprimiendo por pantalla y las omillas no apare erán pues éstas son
simplemente los delimitadores del tipo bási o adena.
Por omisión, en la adena que queremos imprimir ontiene a entos, el

intérprete nos mostrará por pantalla un mensaje de error. Así que para poder
imprimir palabras on a entos es ne esario es ribir la senten ia:
# oding=iso-8859-1
on lo que podremos imprimir, por ejemplo:
print Te lee un número
También es posible imprimir ualquiera de los otros tipos bási os dire tamente,
es de ir, sin ne esidad de onvertirlos a tipo str. Por ejemplo:
x=12
y=0.02
w=3+2j
b=True
print x
print y
3.3. PHYTON 207
print w
print b
Obteniendo omo resultado de estas líneas:
Figura 3.60: Imprimiendo varios tipos de datos on print
Además, la fun ión print nos permite imprimir más de un dato (in luso
de diferentes tipos). Para esto solamente tenemos que separar on omas los
datos que queremos imprimir, omo en el siguiente ejemplo:
x=10
print el área de la figura es, x, unidades
de lo que se obtiene:
También ya habrá notado el le tor que ada vez que llamamos a la fun ión
print, sus argumentos se imprimen en una nueva línea. Si queremos que no se
reali e este ambio de línea, debemos terminar la instru ión print anterior
on oma. Por ejemplo:
x=10
print el area de la figura es,
print x,
print unidades
uyo resultado es elmismo que se muestra en la imágen 3.61. Este omportamiento

se debe a que ada intru ión print lo primero que imprime es el ará ter
Figura 3.61: Imprimiendo diversos tipos de datos desde un solo print
ambio de línea, por lo que el ursor de la onsola se desplaza a la línea

siguiente. La oma en el print inmediato anterior ha e que la siguiente instru ión
print no imprima el ará ter de ambio de línea.
Entrada de datos
Para obtener datos desde el te lado vamos a emplear la fun ión predenida:
raw_input(<argumento>)
Donde <argumento> es una adena. Esta fun ión realiza lo siguiente:

detiene la eje u ión del programa y muestra en la pantalla la adena que se
espe i o omo parámetro y espera a que el usuario es riba un texto, y ontinúa
on la eje u ión hasta que el usuario presiona enter. Por omisión retorna omo
adena (tipo str) el texto que haya es rito el usuario. Comúnmente en la
adena que muestra esta fun ión en la salida, se indi a al usuario el tipo de
dato que éste debe te lear.
Por ejemplo, on la instru ión:
x = raw_input(es ribe algo)
se alma enará en x el texto es rito. x será de tipo str.
Si deseamos que el valor alma enado sea de otro tipo, podemos utilizar
3.3. PHYTON 209
las siguientes fun iones para onvertir datos de un tipo a otro:
oat(<argumento>)
Si <argumento> puede ser de tipo int, simplemente onvierte este entero
a su equivalente en otante. También está permitido que el parámetro
sea de tipo str, en uyo aso la adena se onvierte al número de punto
otante que esta represente. Si la adena no representa un otante, el
intérprete nos mandará un mensaje de error a través de la onsola. Así
print float(13)
print float(12.35)+1
resulta en:
13.0
13.35
También puede onvertirse adenas que representan números otantes

expresados en nota ión ientí a:
print float(1.2e5)
da omo resultado
120000.0
Si en ambio el argumento es de tipo float, la fun ión devuelve el mismo

valor que se espe i ó omo parámetro.
int(<argumento>)
<argumento> puede ser de tipo float o str. En el primer aso, la
fun ión retorna la parte entera del argumento. En el segundo aso, se
retorna el entero que representa la adena, en aso de di ha adena
represente efe tivamente un número entero. Ejemplos:
print int(3.14)
print int(3)
Como resultado de estas dos instru iones se imprime en la pantalla

los números enteros: 3 y 3.
str(<argumento>)
Re ibe omo <argumento> un número y devuelve a este mismo pero
omo una adena. Si ha emos
x = str(2)
y = str(54.02)
se tendrá que:
x = 2
y = 54.02.
Note que x, y son adenas, no números.
Así, podemos obtener desde te lado datos de tipo str, es de ir, adenas y
posteriormente onvertirlas a enteros o otantes, en aso de que sea posible.
El siguiente programa es la implementa ión del pseudo- ódigo 2.1.2
Programa 3.3.1. Implementa ión del pseudo- ódigo 2.1.2
# oding=iso-8859-1
print Introduz a un valor numéri o para var_1

var_1=raw_input()
print Introduz a un valor numéri o para var_2 var_2=raw_input()
var_3=var_1
var_1=var_2
var_2=var_3
print var_1
print var_2
3.3.7. Fun iones

Como hemos men ionado antes, una fun ión es un fragmento de ódigo
que tiene una tarea espe í a dentro de un programa. En general, puede ser
que una fun ión ne esite re ibir parámetros o argumentos para poder eje utar
las instru iones que la onforman. También, omo veremos, podemos denir
fun iones que devuelven algún valor, o que no devuelven nada. La forma general
de denir una fun ión en este lenguaje es la siguiente:
3.3. PHYTON 211
def <nombreDeFun ión> (<parámetros>) :

<instru iones>
Re ordamos al le tor que en este lenguaje de programa ión, sangrar las

instru iónes es obligatorio debido a que en este lenguaje no se utilizan llaves
{, } para delimitar el uerpo de una fun ión o bloque de instru iones. Así
pues, el sangrado determina los uerpos (o bloques) de instru iones de las
fun iones y senten ias de ontrol. Cuando se dene una fun ión, ésta no se
eje uta. Para llamar a eje u ión una fun ión en ualquier parte del programa,
basta es ribir el identi ador(nombre) de la fun ión y espe i ar la antidad de
parámetros que se espe i aron en la deni ión de la fun ión. El ódigo es rito
en la deni ión de una fun ión no se eje utará si no se llama a eje u ión di ha
fun ión. En general, para llamar a eje u ión una fun ión debe es ribirse:
<nombreDeFun ión> (<parámetros>)
Además, toda fun ión debe estar denida antes de llamarla a eje u ión
por primera vez, pues de no ha erlo así, el intérprete de Python nos mandará
un mensaje de erros di iendonos que la fun ión a la que intentamos llamar, no
ha sido denida aún.
Si la fun ión regresa algún dato, debe gurar entre las instru iones del
uerpo de la fun ión la proposi ión:
return <exp>
Veamos un ejemplo sen illo:
def obtieneCuadrado(x):
return x**2
Esta es una fun ión uyo argumento debe ser un número (entero, otante
o omplejo). Para esta fun ión, si el argumento es entero, el valor regresado
será también entero. Si se da un argumento de tipo otante, el valor retornado
será tambien de tipo otante. Una situa ión análoga se da si el parámetro
dado a la fun ión obtieneCuadrado () es de tipo omplejo. Para veri ar
esta arma ión, eje ute el siguiente programa:
Programa 3.3.2.
def obtieneCuadrado(w):
return w**2
print type(obtieneCuadrado(2))
print type(obtieneCuadrado(2.0))
print type(obtieneCuadrado(2+0j))
Podemos también denir una fun ión similar a la del programa 3.3.2 en la
que no se re ibe argumento alguno y se obtiene un número desde el te lado
para después obtener su uadrado:
Programa 3.3.3.
# oding=iso-8859-1
def obtieneCuadrado():
w = int(raw_input(Es riba un número))
return w**2
print obtieneCuadrado()
Observe que este último programa obtiene números enteros (en aso de ser
posible), así que si queremos elevar al uadrado un número de tipo float
o omplex, sería ne esario denir otros métodos, o utilizar alguna de las
senten ias de ontrol ondi ionales que se presentarán en el apartado 3.3.8.
Módulos
Cuando los programas son muy extensos, podemos es ribir fragmentos de
ódigo en diferentes ar hivos funte de Python ( on extensión .py) a los que
se ono en omo módulos. En un programa, podemos utilizar las fun iones
denidas en otros módulos, pero para ello es ne esario indi arle al intérprete de
Python que in luya a di ho módulo. Esto se ha e muy fá il: si el módulo que
queremos importar es <nombreDelMódulo>.py, preferentemente en la parte
superior del programa al que deseamos añadirlo debemos es ribir la instru ión:
import <nombreDelMódulo>
(sin la extensión .py). Además es indispensable que el módulo que queremos

3.3. PHYTON 213
importar se en uentre en el mismo dire torio ( arpeta) que el programa en el

ual queremos utilizar las fun ionalidades del módulo que estamos importando.
En general, uando importamos un módulo a otro, podemos emplear la

fun iones que se hayan denido en el módulo importado, y además, todo el
ódigo eje utable (fuera de las deni iones de las fun iones), se eje utará
por el simple he ho de haber importado el módulo. Por ejemplo, si la fun ión
uadrado() del programa 3.3.3 se guarda en un ar hivo llamado fun ion1.py,
y en otro ar hivo fuente es ribimos el ódigo:
Programa 3.3.4.
# oding=iso-8859-1
import fun ion1
print Importando módulos

x=fun ion1.obtieneCuadrado()
print type(x)
Al eje utar el programa 3.3.4, observaremos que lo primero que se ha e

es eje utar el ódigo del módul que estamos importando (pues la primera
instru ión de este progrma en pre isamente la importa ión de di ho módulo)
en este aso se trata del módulo fun ion1. Posteriormente se eje utan las
instru iones del programa 3.3.4, en el ual omo podemos observar, se está
utilizando la fun ión obtieneCuadrado() denida en el módulo fun ion1.
Además note la forma en que ésta se ha llamado a eje u ión. En general, una
fun ión que se en uentra denida en otro módulo se llama a eje u ión de la
siguiente manera:
<nombreDelModúlo>.<nombreDeFun ion>
previa importa ión del módulo, pues si por ejemplo, se llamara a eje u ión
la fun ión antes de importar el módulo fun ión1 se noti aría un mensaje de
error, indi ando que la fun ión no ha sido denida aún.
Es posible también es ribir ódigo dentro de un módulo de tal manera que

se eje ute si y sólo si se está eje utando di ho módulo, es de ir, que podemos
espe i ar que un fragmento de ódigo no se eje ute al importar di ho módulo.
Por ejemlo, onsidére la siguiente modi a ión al programa 3.3.3:
Programa 3.3.5.
# oding=iso-8859-1
def obtieneCuadrado():
w = int(raw_input(Es riba un número))
return w**2
if __name__==__main__:
# Estas instru iones se eje utan solo si se
# está eje utando este módulo
print obtieneCuadrado()
# Este ódigo se eje uta siempre

print Este fragmento de ódigo,
print Se eje uta siempre
donde las líneas de ódigo es ritas en el uerpo de la senten ia
son las úni as que no se eje utan al importar este módulo ( ar hivo on
extensión .py en el que se guardó el programa 3.3.5). Todo el ódigo que
se en uentre fuera del bloque de instru iones de esta senten ia o fuera de las
deni iones de las fun iones (si es que las hay), será eje utado al importar
di ho módulo. Pruebe implementando el módulo 3.3.4 junto on el programa
3.3.5 y eje utando este último.
En otros lenguajes de programa ión toda la valida ión del programa va

es rita dentro de una fun ión prin ipal llamada fun ión main(). En Python
no es no es ne esario ni obligatorio, pero es una buena ostrumbre es ribir la
valida ión del programa dentro de la senten ia:
de manera que la estru tura de un programa sea la siguiente:

3.3. PHYTON 215
# Importamos los módulos (en aso de haber)
# Defini ión de fun iones
# Fun ión prin ipal
# Instru iones prin ipales del programa
<instru iones>
En adelante, tomaremos esta onven ión para es ribir nuestros programas.
Cabe men ionar que existen alguno módulos predenidos, en los uales
se denen algunas fun iones que podemos emplear al importar el módulo que
la ontenga. Algunos módulos de uso omún son:
math: posee las fun iones trigonométri as, exponen ial, logaritmo, raiz
uadrada, redondeos, et ., así omo algunos valores onstantes omo un
valor aproximado de π o e por men ionar algunos.
syst: ontiene fun iones que permiten a esar al sistema operativo, así
omo onstantes que dependen de la omputadora.

En este apartado vamos a dar la sintaxis en el lenguaje de programa ión
Python, de tres de las estru turas de ontrol espe í adas en el apartado 2.2.1,
así omo la tradu ión a este lenguaje, de algunos de los ejemplos presentados
allí. Las senten ias que si soporta Python son SI, SI-DOM y SI-(DOM-SI).
En este lenguaje no existe la senten ia SWITCH, pero esto no representa
problema alguno, ya que es asi equivalente a la senten ia SI-(DOM-SI).
Suponemos además que ada vez que se pide al usuario de la omputadora

que te lee texto, números enteros, números otantes, et ., éste propor ionará
mediante el te lado datos válidos, pues lo más probable es que si se pide que se
te lee un número entero pero el usuario te lea texto, se produ irá un estado de
error en el programa. Es posible apturar estos errores e indi arle al programa
que es lo que debe ha er en aso de que se produz a un determinado error,

utilizando las ex ep iones, pero ese tema se tratará hasta la subse ión 3.3.11.
Senten ia if
En Python el equivalente a la senten ia SI, es la instru ión if, y la de lara ión
se ha e de la siguiente manera:
if < ondi ión> :

<instru iones>
En la mayoría de los lenguajes de programa ión (por ejemplo Java y C)

se emplean las llaves para delimitar el bloque de instru iones que deben
efe tuarse en aso de que < ondi ión> se umpla, y el sangrado de instru iones
se ha e solo para darle mayor legibilidad a los programas. En este lenguaje no
es así, sino que las instru iones a eje utarse al umplirse la ondi ión, deben
es ribirse dejando su respe tiva sangría. De esta manera, en Python el sangrado
no es una op ión, es una obliga ión.
Pasemos dire tamente a un ejemplo:

Programa 3.3.6. Ha er un algoritmo que re iba un número. Si éste es distinto
1
x
# oding=iso-8859-1
a=int(raw_input(Introduz a un número diferente de ero\n))
if a!=0 :
b=1.0/a
print1/ + str(a) + = + str(b)
if a==0:
print El número introdu ido no es valido
print Gra ias por utilizar este programa
Antes de ontinuar, observe que en la uarta línea del programa hemos

es rito b=1.0/a pues de haber es rito b=1/a el resultado hubiera de esta
opera ión será ero, ya que, el o iente de dos números enteros es a su vez
3.3. PHYTON 217
un número entero, y en el aso de 1/a, se el resultado es igual a la parte entera

del resultado. Otra manera de solu ionar onsiste en transformar a al tipo
otante: b=1/float(a).
En lo referente a las sangrías de las instru iones, on el siguiente programa

vamos a mostrar que una simple sangría de más o de menos, tendrá efe to en
el ujo del programa.
Programa 3.3.7.
# oding=iso-8859-1
if a!=0 :
b=1.0/a
print1/ + str(a) + = + str(b)
if a==0:
Aunque éste es muy pare ido al programa 3.3.6 tendrá diferentes resultados.
Observe que la úni a diferen ia de estos dos programas es en la línea 7. En el
primero de estos dos programas la séptima línea no está sangrada, por lo que
ésta no forma parte del bloque de instru iones else, y se eje utará aunque
no se umpla el else. Por el ontrario, en el segundo programa, al poner
sangría a esta línea estamos indi ando al intérprete de Python que la séptina
línea forma parte de las instru iones que onforman al else y, por lo tanto,
esta instru ión sólo se eje utará si se umple el else y no en aso ontrario.
Así, esta simple sangría ha e que el ujo de los dos programas sea distinto.
Por eso, debemos tener sumo uidado al utilizar las sangrías, para es ribir
ade uadamente lo que en realidad deseemos expresear.
Senten ia if-else
La senten ia ondi ional SI-DOM tiene omo equivalente en Python a la
senten ia if-else. La forma general de de lararla es:
if < ondi ión> :

<instru iones1>
else:
<instru iones2>
Al igual que para la senten ia if, el uerpo del else debe es ribirse on
sus debido sangrado.
El siguiente programa representa una solu ión alternativa a la del programa

3.3.6, pero empleando la senten ia if-else.
Programa 3.3.8. Equivalente al programa 3.3.6.
# oding=iso-8859-1
if a!=0 :
b=1.0/a
print 1/ + str(a) + = + str(b)
else:
Note que este ódigo no tiene grandes diferen ias on el programa 3.1.5.
Lo úni o que se ha modi ado es if(a!=0) por else. Sin embargo, el ujo
del programa presenta diferen ias importantes, tal omo ya se mostró en la
subse ión 2.1.1., ya que se efe túan menos veri a iones, lo que representa
menos opera iones y menor tiempo de eje u ión (aunque en programas pequeños
no se note la diferen ia).
El siguiente ejemplo es un po o más elaborado y es la implementa ión

del ejemplo 2.2.3:
Programa 3.3.9. Ha er un programa que re iba dos números m, n y que

posteriormente diga si m es mayor, menor, o igual que n.
3.3. PHYTON 219
# oding=iso-8859-1
m=int(raw_input(Te lee un valor númeri o para la variable m\n))
n=int(raw_input(Te lee un valor númeri o para la variable n\n))
if m>n:
print m, es mayor que, n
else:
if m<n:
print m, es menor que, n
else:
print m, es igual a, n
print Fin del programa
Aquí observe que hay senten ias ondi ionales anidadas: en el bloque de
instru iones del primer if gura a su vez otra senten ia if on su respe tivo
else. Es por eso que hay en este ódigo senten ias on doble o hasta triple
sangrado, on el n de determinar uales serán las instru iones que se eje utarán
en ada senten ia ondi ional.
Senten ia elif
Como ya se men ionó antes, la senten ia SI-DOM puede pensarse omo un
aso parti ular de otra de las senten ias de ontrol estudiadas en el apítulo
de algoritmi a: el SI-(DOM-SI). La sintáxis para el SI-(DOM-SI)) en Python
es elif, y la manera de de lararse se presenta enseguida:
if < ondi ión1>:

<instru iones1>
elif < ondi ión2>:
<instru iones2>
.
.
.
elif < ondi iónN-1> :
<instru ionesN-1>
else:
<instru ionesN>
Al igual que if y if-else, los bloques de instru iones a eje utarse en ada
uno de los asos deben tener su respe tiva sangría. El programa 3.1.7 puede
rees ribirse de la siguiente manera:

Programa 3.3.10. Equivalente al programa 3.1.7 utilizando elif
# oding=iso-8859-1
m=int(raw_input(Te lee un valor númeri o para la variable m\n))
n=int(raw_input(Te lee un valor númeri o para la variable n\n))
if m>n:
print m, es mayor que, n
elif m<n:
print m, es menor que, n
else:
print m, es igual a, n
Previamente hemos he ho la observa ión de que, adiferen ia de otros lenguajes

omo C y Java, en Python no existe la senten ia swit h. Esto no representa
ningún problema ya que on la senten ia elif es tan fá il la implementa ión
omo en otros lenguajes se ha e on la senten ia swit h. El siguiente programa
es el equivalente al pseudo ódigo del ejemplo 2.2.5, pero implementado on la
senten ia elif:
Programa 3.3.11. Implementa ión del pseudo ódigo del ejemplo 2.2.5, utilizando
la senten ia elif de Python.
# oding=iso-8859-1
letra=raw_input(Te lee una letra (minús ula) del abe edario\n)
if letra==a:
print Es vo al
elif letra==e:
print Es vo al
elif letra==i:
print Es vo al
elif letra==o:
print Es vo al
elif letra==u:
print Es vo al
else:
print Es onsonante
3.3. PHYTON 221

Al igual que las senten ias de ontrol ondi ionales, ahora presentaremos
la sintaxis de dos de las senten ias de ontrol iterativas en el lenguaje del que
ahora nos estamos o upando. Éstas son: MIENTRAS y PARA, ya que en
este lenguaje no existe el HACER-MIENTRAS.
Las expli a iones serán muy breves, pues ya se expli ó en el apítulo 2

el fun ionamiento de ada una de estas senten ias. De la misma manera que
las senten ias ondi ionales, los uerpos de ada una de las senten ias que
presentaremos a ontinua ión, tienen que estar debidamente indentados.
Suponemos también que ada vez que se pide al usuario de la omputadora

que te lee algún(os) dato(s) ya sea texto, números enteros, números otantes,
et ., propor ionará a través del te lado el tipo de datos soli itados, pues lo
más probable es que si se pide que se te lee un número entero pero el usuario
te lea texto (no número), se produ irá un estado de error en el programa. Es
posible apturar estos errores e indi arle al programa que es lo que debe ha er
en aso de que se produz a un determinado error, utilizando las ex ep iones
(ver 3.3.11).
Senten ia while
while es una de las senten ias de ontrol iterativas que pueden emplearse en
Python, y es el equivalente a la senten ia MIENTRAS que se ha presentado ya
en al apítulo de algoritmi a. Así pues, para utilizarla se ha e una de lara ión
del siguiente tipo:
while < ondi ión> :

<instru iones>
En el siguiente programa presentamos la tradu ión del ejemplo 2.2.6 a

este lenguaje de programa ión:
Programa 3.3.12. Implementa ión del pseudo- ódigo del ejemplo 2.2.6.
# oding=iso-8859-1
print Este programa imprime los enteros de 0 a n en,
print orden des endente
n=int(raw_input(Te lee un valor entero no negativo para n\n))
while n>=0:
print n
n-=1 #O bien n=n-1
Senten ia for
La senten ia de ontrol iterativa for orresponde a la instru ión PARA
del apítulo anterior. Re ordemos que ésta se de lara de la siguiente manera:
PARA (<opera ión ini ial>; < ondi ión>; <opera ión de varia ión>) {
<instru iones>
}
ésta diere notablemente de la sintaxis que se emplea en Python, y que

presentamos enseguida:
for <variable> in <rango> :

<instru iones>
<variable> no ne esita haber sido ini ializada, ya que tomará los valores
espe i ados en el <rango>. <rango>, omo hemos di ho, onsiste de la
se uen ia de valores que tomará <variable> en ada itera ión del i lo. Más
pre isamente, <rango> debe ser lo que en Python se ono e omo lista, y es
equivalente a lo que se ono e omo arreglo unidimensional o ve tor en otros
lenguajes. La senten ia for fun iona de la siguiente manera: <variable> toma
ini ialmente el primer valor alma enado en la lista (equivale a la opera ión de
ini ializa ión) y eje uta el bloque <instru iones>y, una vez nalizado esto, a
<variable> se le asigna el siguiente elemento del rango de valores (en algunos
asos para listas de números es posible espe i ar el in remento o de remento
entre los valores). El pro eso ontinúa hasta que <variable> ha tomado todos
y ada uno de los valores de <rango>.
3.3. PHYTON 223
Veamos pues omo obtener listas.
Una lista es una se uen ia de elementos no ne esariamente del mismo tipo.

Una lista se de lara de la siguiente manera:
<nombre>=[<elemento0>,<elemento1>,. . . ,<elementon>℄
donde <elemento0>, <elemento1> ,. . . , <elementon> pueden ser valores de

ualquier tipo (entero, otante, omplejo, adena, booleano) o in luso listas.
Por ejemplo:
x=[Luis, Moni a, Edgar, Carlos, Andrea℄
Ahora, imprimimos estos valores on ayuda de la senten ia for:

for var in x:
print tu nombre es:, var
on lo que obtenemos en la pantalla:
tu nombre es Luis
tu nombre es Moni a
tu nombre es Edgar
tu nombre es Carlos
tu nombre es Andrea
Para este tipo de listas no es posible espe i ar dire tamente un in remento,ya

que se está iterando sobre los elementos de la lista y no sobre sus posi iones.
Alternativamente, podemos obtener el tamaño de la lista on ayuda de la
fun ión len(), e iterar sobre sus posi iones ( onsiderando que la pos isiónes
van de 0 a len()-1), en donde puede espe i arse un in remento, omo veremos
más adelante. Considére ahora la lista:
w=[0, 1, 2, 3, 4, 5, 6, 7, 8, 9℄.
Ésta puede obtenerse también de la siguiente manera:
range(10)
En general, la fun ión range() fun iona de la siguiente manera:
range(<valorIni ial>,<valorFinal+1>,<varia ión>)
donde valor ini ial será el primer elemento de la lista, y el segundo será el
primero más la <varia ión> en aso de ser ésta positiva (o menos la varia ión
en aso de ser ésta negativa), mientras que <valorFinal> es el máximo valor
posible que puede pertene er a la lista. Puede emplearse range() on dos
argumentos, en uyo aso se toman omo <valor ini ial> y <valorFinal+1> y
onsiderando que <varia ión>=1. Finalmente, uando utilizamos esta misma
fun ión on un sólo argumento, se onsidéra que éste es <valorFinal+1>, y
por omisión será <valor ini ial>=0. Es por ello que range(10) es la lista
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9℄
Por ejemplo, on el siguiente ódigo imprimimos los números pares entre 1

y 10:
for i in range(1,10,2):
print i
y on el siguiente imprimimos desde 10 a 0 en orden des endente (note que

<varia ión><0): for i in range(1,-10, -1): print i
El siguiente es un ejemplo en el que se ilustra omo se implementa la

senten ia for dentro de un programa:
Programa 3.3.13. Ha er un algoritmo que lea un número entero no negativo

y que es riba en pantalla el fa torial de di ho número.
3.3. PHYTON 225
# oding=iso-8859-1
x=1
print Este programa al ula el fa torial de un número\n
n=int(raw_input(Introduz a un valor entero no negativo\n))
if n>1:
for i in range(2,n+1):
x=i*x
print x
print El fa torial de, n, es, x
else:
if (n==0 or n==1):
print El fa torial de, n, es, x
else:
print El número introdu ido debe ser no negativo
3.3.10. Arreglos
En Python, la estru tura equivalente a los arreglos unidimensionales se les
ono e omo listas. Como y hemos di ho en la al hablar de la senten ia for.
Así pues, una lista es una se uen ia de elementos los uales pueden ser enteros,
otantes, omplejos, adenas, booleanos o in luso listas y no ne esariamente
todos del mismo tipo. Una lista se de lara de la siguiente manera:
<nombre>=[<elemento0>,<elemento1>,. . . ,<elementon>℄
donde <elemento0>, <elemento1> ,. . . , <elementon> pueden ser valores de

ualquier tipo. Las posi iones se numeran desde 0 hasta n − 1. Por ejemplo:
#Lista va ía:
a=[]
#Lista on elementos de diferentes tipos

b=[hola, 1, 1.0, 9+3j, fin, True]
#Lista on elementos de tipo numéri o
=[0, 1, 2, 3, 4, 5, 6, 7]
Podemos obtener la longitud de una lista on la fun ión len(<lista>),

por ejemplo:
print len(a)
print len(b)
print len( )
Existe otra manera de rear listas de números enteros entre un rango de

valores que podemos espe i ar, as¢omo en in remento o de remento ente los
elementos de la misma. Esto lo ha emos on la fun ión range():
range(<valorIni ial>,<valorFinal+1>,<varia ión>)
on los tres argumentos números enteros, y donde <valor ini ial> es el elememto
que o upará la posi ión 0, <valorIni ial>+<varia ión> será el elemento en la
posi ión 1, el elemento en la posi ión 2 será igual al elemento en la posi ión 1
más <varia ión> y así su esivamente, siempre y uando no se rebase al número
<valorFinal>. Evidentemente, si <varia ión> es positiva, <valorIni ial> debe
ser menor (o igual) que <valorFinal> pues, en aso ontrario se obtendrá
una lista va ía. De manera similar, si <varia ión> es negativa, para obtener
una lista no va ía debe ser <valorIni ial> mayor (o igual) que <valorFinal>.
Ejemplos:
v1=range(-10,15,2)
v2=range(-10,15,-2)
v3=range(15,-10,-2)
v3=range(15,-10,2)
on lo que se obtendrá:
[-10, -8, -6, -4, -2, 0, 2, 4, 6, 8, 10, 12, 14]

[ ]
[15, 13, 11, 9, 7, 5, 3, 1, -1, -3, -5, -7, -9]
[ ]
Puede emplearse también la fun ión range() on sólo dos argumentos,

aso en el que se onsidera por omisión que <varia ión>=1, por lo que los dos
argumentos restantes son <valorIni ial> y <valorFinal> respe tivamente. Más
aún si utilizamos range(), on un sólo argumento que será el <valorFinal>,
3.3. PHYTON 227
y se entenderá que por omisión es <valorIni ial>=0 y <varia ión>=1
Además podemos referirnos a un elemento espe í o de la lista ya sea para

modi arlo o para onsulta. :
v1[10℄=0
obteniendo en este aso:
[-10, -8, -6, -4, -2, 0, 2, 4, 6, 8, 10, 12, 14]
Además, se pueden apli ar a las listas los operadores + y *:
El operador + on atena las listas a las que se apli a, es de ir, se obtiene

una nueva lista que ontiene los elementos de las dos listas que se
están on atenando, primero los de la primera lista y enseguida los de la
segunda, por ejemplo:
print v1+v3
devuelve:
[-10, -8, -6, -4, -2, 0, 2, 4, 6, 8, 10, 12, 14, 15, 13, 11, 9,
7, 5, 3, 1, -1, -3, -5, -7, -9]
El operador * apli ado a una lista y un número entero positivo, devuelve

una lista en la que se repiten, la antidad de ve es indi ada por el número
positivo, ada uno de los elementos de la lista. Ejemplo:
print [1,2,3]*3
resulta en:
[1, 2, 3, 1, 2, 3, 1, 2, 3]
También es posible rear listas (arreglos) en los que el usuario propor ione
tanto la longitud del arreglo omo ada una de las entradas del mismo, tal
omo se obtiene on el siguiente programa:
Programa 3.3.14. Programa pare leer una lista desde el te lado.

# oding=iso-8859-1
n=int(raw_input(Espe ifique el tamaño de la lista\n))
#Ini ializamos una lista on 10 ' eros'
x=[0℄*n
#Leemos los elementos que onformarán a la lista
for i in range(n):
print obteniendo el elemento, i
x[i℄=int(raw_input(Introduz a un número\n))
for k in range(len(x)):
print x[k℄
También es posible que, dada una lista on un tamaño jo, se le agregue

otro elemento, on lo que el tamaño de la lista aumentará. Estos se ha e on
la fun ión
append(<argumento>)
la ual aumenta en una unidad el tamaño de la lista y agrega <argumento>

en la última posi ión. Veamos un ejemplo:
v=[-2, 44, 6, 8, 0]
print v
print len(v)
v.append(-1)
print v
print len(v)
uyos resultados son:[-2, 44, 6, 8, 0]

5
[-2, 44, 6, 8, 0, -1]
6
Otro programa que también fun iona para leer un arreglo desde el te lado
es el siguiente:
Programa 3.3.15. Otro programa para leer un arreglo.

3.3. PHYTON 229
# oding=iso-8859-1
#Creamos una lista va ía
x=[℄
n=int(raw_input(Espe ifique el tamaño de la lista\n))
#Leemos los elementos que onformarán a la lista
for i in range(n):
print obteniendo el elemento, i
mero\n)))
x.append(int(raw_input(Introduz a un n
#Imprimimos la lista
print x
Con ayuda de las listas podemos también trabajar on matri es, que son
listas de listas. Es de ir, una matriz es una lista uyos elementos son a su
vez listas. Pueden ini ializarse ha iendo explí itos ada uno de sus elementos,
por ejemplo:
mat=[ [1,2,3,4], [5,6,7,8], [1,0,1,0] ]

print mat
El resultado de las líneas de ódigo anteriores se muestra en la imágen

3.62
Como puede observarse, puede imprimirse toda la matriz desde una misma
instru ión, sin ne esidad de a eder a ada uno de sus elementos.
Las listas que son elementos de la matriz deben tener la misma longitud o
tamaño, pues en aso ontrario no habremos denido una matriz, sino simplemente
una lista on listas (de diferentes tamaños). La siguiente no es una matriz:
mat=[ [0,1,2,3,4], [5,6,7,8], [1,0,1,0] ]
A menudo, será ne esario a eder a los elementos de una matriz, ya sea

para onsulta o modi a ión. La manera de referirse a un elemento espe í o
de la matriz es:
<nombreDeLaMatriz> [i][j]
Figura 3.62: Matri es:listas de listas
donde i ∈{0, 1, . . . , m-1} y j ∈{0, 1,. . . , n-1}, siendo n el número de listas

( olumnas), y n el tamaño de ada una de éstas (las). Como ejemplo, modi amos
algunos de los elementos de mat:
mat [0][1]=0
mat [3][2]=1
mat [2][0]=-1
on lo que se obtiene:
[ [1,2,-1,4], [1,6,7,8], [1,0,1,1] ]
También es posible leer una matriz uyos elementos sean propor ionados
por el usuario del programa. Para esto, primero vamos a rear una matriz de
eros de manera automáti a, del tamaño deseado, y posteriormente reemplazaremos
estos eros on los datos propor ionados por el usuario. Primero veamos omo
obtener una matriz de eros ( on dimensiones dadas por el usuario):
Programa 3.3.16.
3.3. PHYTON 231
# oding=iso-8859-1
n=int(raw_input(Espe ifique el número de filas\n))
m=int(raw_input(Espe ifique el número de olumnas\n))
mat=[℄
for k in range(m):
v=[0℄*n
mat.append(v)
print mat
Y en el siguiente, obtenemos las entradas de la matriz, desde el te lado.
Programa 3.3.17. Programa para obtener una matriz on tamaño y elementos

(números) propor ionados por el usuario.
# oding=iso-8859-1
m=int(raw_input(Espe ifique el número de olumnas\n))
#Creamos una matriz de eros
mat=[℄
for k in range(m):
v=[0℄*n
mat.append(v)
#Reemplazamos los eros on los valores dados por el usuario
for i in range(m):
for j in range(n):
print obteniendo , i, ,,j
mat[i℄[j℄=int(raw_input(De un número\n))
print mat
3.3.11. Ex ep iones
Existen varias situa iones en las que un programa puede entrar en un estado
de error, por ejemplo, si en una instru ión omo:
el usuario del programa te lea algún ará ter que no representa un número
entero (o otante), se produ e un error, ya que no se puede ha er la onversión
a número entero. Otras situa iones en las que se produ en errores son intentar
dividir por ero, al ular la raiz uadrada de un número negativo, intentar
a eder a un elemento fuera del rango de un arreglo, entre otros mu hos.
Algunos de los errores pueden apturarse y tratarse, esto es, el programador
puede indi arle al programa que ha er en aso de que se produz a un error. Para
esto vamos a utilizar el manejador de ex ep iones try-ex ept. En general, se
utiliza de la siguiente manera
try:
<instru iones>
ex ept <tipoDeEx ep ión1>:
<instru iones2>
ex ept <tipoDeEx ep ión2>:
.
.
.ex ept <tipoDeEx ep iónk>:
<instru ionesk> finally:
<instru ionesF>
Fun iona de la siguiente manera: en el bloque <instru iones> de try se es ribe

el ódigo sus eptible de errores (las instru iones en las que puede produ irse
un error). Enseguida en ada uerpo de instru iones ex ept <tipoDeEx ep ióni>
se espe i an las instru iones que deben eje utarse en aso que la ex ep ión
que se produz a sea <tipoDeEx ep ióni> (i ∈ {1, . . . , k}). Por ultimo, el
uerpo de nally se eje utará ya sea que hubo exx ep iones o que no, es
de ir, son instru iones que se eje utarán siempre. Éste ultimo bloque puede
omitirse sin ningún problema.
Algunos de los tipos de ex ep iones más omunes son:
Arithmeti Error: Clase base para los errores aritméti os.
FloatingPointError: Error en una opera ión de oma otante.
OverowError: Resultado demasiado grande para poder representarse.
ZeroDivisionError: Lanzada uando el segundo argumento de una opera ión

de división o módulo era 0.
3.3. PHYTON 233
IOError: Error en una opera ión de entrada/salida.
OSError: Error en una llamada a sistema.
ImportError: No se en uentra el módulo o el elemento del módulo que

se quería importar.
IndexError: El índi e de la se uen ia está fuera del rango posible.
MemoryError: No queda memoria su iente.
NameError: No se en ontró elemento alguno on ese nombre.
UnboundLo alError: El nombre no está aso iado a ninguna variable.
NotImplementedError: Ese método o fun ión no está implementado.
IndentationError: Error en la indenta ión del ar hivo.
TabError: Error debido a la mez la de espa ios y tabuladores.
SystemError: Error interno del intérprete.
TypeError: Tipo de argumento no apropiado.
ValueError: Valor del argumento no apropiado.
Así, <tipoDeEx ep ión> puede ser ualquiera de las anteriores ex ep iones

(y otras que no hemos men ionado aquí). Igualmente, es posible no espe i ar
el tipo de ex ep ión que se produ irá.
Como ejemplo, vamos a apturar el error que se produ e en el programa

3.3.16 al te lear ará teres que no son números uando el programa está
soli itando que indiquemos la dimensión de la matriz. En la gura 3.63 observamos
que la ex ep ión que se produ e es del tipo ValueError
Figura 3.63: Error que se produ e al te lear un ará ter no numéri o
Y el siguiente es un programa en el que on ayuda del try-ex ept se manda

un mensaje de error al usuario en aso de que el (los) ará ter(es) te leados
no puedan onvertirse a entero.
Programa 3.3.18.
# oding=iso-8859-1
try:
n=int(raw_input(Espe ifique el número de filas))
m=int(raw_input(Espe ifique el número de olumnas))
mat=[℄
for k in range(m):
v=[0℄*n
mat.append(v)
print mat
ex ept:
print El ará ter te leado no representa un número entero
finally:
print Fin del Programa
3.3. PHYTON 235
También podemos ha er explí ito el tipo de ex ep ión que se produ irá,

pues lo ono emos. El programa quedaría de la siguiente manera:
# oding=iso-8859-1
try:
n=int(raw_input(Espe ifique el no mero de filas"))
m=int(raw_input(Espe ifique el no mero de olumnas"))
mat=[℄
for k in range(m):
v=[0℄*n
mat.append(v)
print mat
ex ept ValueError:
print El ará ter te leado no representa un número entero
finally:
print Fin del Programa
Espe i ar el tipo de ex ep ión que se produ e es útil uando hay diversas

posibilidades o situa iones que llevan a errores, y que deben ser tratados de
diferentes maneras. Por ejemplo, onsidére el programa siguiente:
Programa 3.3.19.
# oding=iso-8859-1
from math import sqrt
try:
a=float(raw_input(Es riba un número positivo a))
b=float(raw_input(Es riba un número positivo b))
=float(raw_input(Es riba un número positivo ))
x=(sqrt(b**b-4*a* ))/(2*a)
ex ept ValueError:
print El ará ter te leado no representa un número
ex ept ZeroDivisionError:
print a debe ser distinto de ero
En éste hemos apturado las ex ep ión que se produ e al intentar dividir

por ero: ZeroDivisionError, y la de un valor no apropiado para la fun ión

float(). Sin embargo, la opera ión:
x=(sqrt(b**b-4*a* ))/(2*a)
es sus eptible de otro error: que el argumento de la fun ión sqrt() sea negativo.
Pero resulta que éste problema también entra dentro de la ex ep ión ValueError,
así que se eje utarán las instru iones del bloque ex ept ValueError:
Veriquelo implementando y eje utando estos programas on diversos valores.

En este ejemplo, es onveniente separar las ex ep iones, para saber en donde se
esta generando un error en el programa. Por ejemplo, en el siguiente programa
si se notan las diferentes ausas del error:
Programa 3.3.20.
# oding=iso-8859-1
from math import sqrt
try:
a=float(raw_input(Es riba un número positivo a))
b=float(raw_input(Es riba un número positivo b))
=float(raw_input(Es riba un número positivo ))
if b**b-4*a* >=0:
x=(sqrt(b**b-4*a* ))/(2*a)
print x
else:
print .El dis riminante es negativo"
ex ept ValueError:
print El ará ter te leado no representa un número
ex ept ZeroDivisionError:
print a debe ser distinto de ero
Bibliografía
[1℄ Brian W. Kernighan & Dennis M. Rit hie: EL LENGUAJE DE PROGRAMACIÓN C,

Pearson Edu a ión, segunda edi ión, 1991.
237

SSProgramación PDF

Cargado por

Información del documento

Título original

Derechos de autor

Formatos disponibles

Compartir este documento

Compartir o incrustar documentos

Opciones para compartir

¿Le pareció útil este documento?

¿Este contenido es inapropiado?

Copyright:

Formatos disponibles

SSProgramación PDF

Cargado por

Copyright:

Formatos disponibles

1

3.2.3. Operadores . . . . . . . . . . . . . . . . . . . . . . . . . 124

En este do umento se presentan las notas de lase orrespondientes a la

Llamamos programa de omputadora a una se uen ia nita de instru iones

Figura 2.1: Representa ión grá a de entorno en el que se desarrolla un programa

En su forma más general, un programa de omputadora, mientras está en

La rela ión entre la entrada, el pro esamiento, y la salida, nuevamente salvo

Podemos denir a un algoritmo es una se uen ia nita de instru iones

Todos utilizamos algoritmos en nuestras a tividades otidianas, por ejemplo,

Para rear un programa, empleamos los llamados lenguajes de programa ión,

En el apítulo suguiente, daremos una breve introdu ión al uso de los

Es una des rip ión grá a de un algoritmo en la que se utilizan símbolos

mu ho espa io y su onstru ión es muy laboriosa.

En un diagrama de ujo deben representarse los siguientes aspe tos:

El omienzo del programa.

Símbolo Des rip ión

Indi a el n del algoritmo. Sólo puede llegar una

Indi a una a ión a realizar. Tiene una úni a línea

Indi a una a ión de entrada (le tura de datos

Se usan para tomar una de isión, dependiendo de

Se usan para one tar los símbolos anteriores y

También ono ido omo español (o inglés, en su aso) estru turado, es

Una de las ventajas de utilizar pseudo ódigos, es que podemos entrarnos

2.1. Con eptos bási os

Un nombre de variable puede ini iar on una letra, pero nun a on un

Debe uidarse no utilizar las palabras reservadas para el lenguaje de

No está permitido que un espa io en blan o forme parte de un nombre

En la mayoría de los lenguajes de programa ión al nombrar una variable

Por ejemplo, si en algún programa de laramos una nueva variable x de

Figura 2.2: Representa ión de la rea ión de una variable.

Si no ini ializamos la variable x, y realizamos alguna(s) opera ión(es) on

Figura 2.3: Estado de la variable después de la asigna ión.

Consultar el valor de la variable.

Dar un valor a la variable

En lo que on ierne a la opera ión de onsulta basta on invo ar el nombre

ESCRIBE: Presenta en la pantalla de la omputadora el/los valores de

y fun iona de la siguiente manera: se evalúa expresión y el resultado se guarda

NOTA: Para realizar la de larara ión de la sintaxis o la forma general de

indi a que en la variable (espa io de memoria) uyo nombre es variable_1

A ontinua ión, podemos sumar una unidad a variable_1 y alma enar el

Así, después de esta asigna ión se habrá reemplazado en el espa io de memoria

es una asigna ión orre ta. Veamos otro ejemplo:

Enton es C tiene el valor 11.

Ejemplo 2.1.1. Ha er un algoritmo en el que se asignen valores arbitrarios a

LEE: Permite la le tura de uno o más valores desde el te lado de la

ESCRIBE Introduz a un valor numéri o para var_1

OBSERVACIÓN: La primera instru ión de este algoritmo da omo resultado

2.1.2. Prueba de es ritorio

A esta té ni a para veri ar si el algoritmo es orre to le llamaremos prueba

Para ilustrar omo se ha e una prueba de es ritorio hagamos, paso a paso,

Entrada var_1 var_2 var_3 Salida

Entrada var_1 var_2 var_3 Salida

Entrada var_1 var_2 var_3 Salida

Entrada var_1 var_2 var_3 Salida

Entrada var_1 var_2 var_3 Salida

Entrada var_1 var_2 var_3 Salida

Entrada var_1 var_2 var_3 Salida

Entrada var_1 var_2 var_3 Salida

Entrada var_1 var_2 var_3 Salida

Observe omo en ada renglon de la tabla, en forma des endente, se representa

27 %5 da omo resultado 2, pues 2 es el residuo de 27/5.

Observe que a %b = 0 si y solamente si a es un múltiplo de b.

Primero se realizan los produ tos, o ientes y módulos, en el orden en el

Llamamos programa de omputadora a una se uen ia nita de instru iones

Figura 2.1: Representa ión grá a de entorno en el que se desarrolla un programa

Podemos denir a un algoritmo es una se uen ia nita de instru iones

Es una des rip ión grá a de un algoritmo en la que se utilizan símbolos

En un diagrama de ujo deben representarse los siguientes aspe tos:

Indi a el n del algoritmo. Sólo puede llegar una

ESCRIBE Introduz a un valor numéri o para var_1

A esta té ni a para veri ar si el algoritmo es orre to le llamaremos prueba

O lógi o o disyun ión: .O.

Observe que la ventaja de SI-(DOM-SI)-DOM es que es más barato es ribirlo,

En esta estru tura de ontrol se veri a a ual de los K asos orresponde

NOTA: Es ne esario in luir la senten ia break al nal de ada uno de los