Chapter 6
Iteración
6.1 Asignación múltiple
Es posible que haya descubierto que es posible hacer más de una asignación
a una misma variable. El efecto de la nueva asignación
es redirigir la variable de manera que deje de remitir al valor antiguo
y empieze a remitir al valor nuevo.
bruno = 5
print bruno,
bruno = 7
print bruno
La salida del programa es \texttt{5 7, ya que la primera
vez que imprimimos \texttt{bruno} su valor es 5, y la segunda vez
su valor es 7. La coma al final de la primera sentencia \texttt{print}
impide que se imprima una nueva línea en ese punto, por eso ambos valores
aparecen en la misma línea.
He aquí el aspecto de una asignación múltiple en un diagrama de estado:
\vspace{0.1in} \centerline{\includegraphics{../illustrations/assign2.eps} } \vspace{0.1in}
Cuando hay asignaciones múltiples a una variable, es especialmente
importante distinguir entre una sentencia de asignación y una sentencia
de igualdad. Puesto que Python usa el símbolo \texttt{=} para la asignación,
es tentador interpretar una sentencia como \texttt{a = b} como sentencia
de igualdad. Pero no lo es.
Para empezar, la igualdad es commutativa, y la asignación no lo es.
Por ejemplo en matemáticas si \( a = 7 \) entonces \( 7 = a \). Pero
en Python la sentencia \texttt{a = 7} es legal, y \texttt{7 = a} no
lo es.
Y lo que es más, en matemáticas, una sentencia de igualdad es verdadera
todo el tiempo. Si \( a = b \) ahora, entonces \( a \) siempre será
igual a \( b \). En Python, una sentencia de asignación puede hacer
que dos variables sean iguales, pero no tienen por qué quedarse así.
\begin{verbatim}
a = 5
b = a # a y b son ahora iguales
a = 3 # a y b ya no son iguales
\end{verbatim} La tercera línea cambia el valor de \texttt{a} pero
no cambia el valor de \texttt{b}, y por lo tanto ya dejan de ser iguales.
En algunos lenguajes de programación, se usa para la asignación un
símbolo distinto, como \texttt{<-} o como \texttt{:=}, para evitar
la confusión.
Aunque la asignación múltiple es útil a menudo, debe usarla con cuidado.
Si los valores de las variables van cambiando constantemente en distintas
partes del programa, podría suceder que el código sea difícil de leer
y mantener.
\section{La sentencia \texttt{while}}
\index{sentencia!while} \index{while!sentencia} \index{bucle!while}
\index{iteración}
Una de las tareas para las que los computadores se usan con frecuencia
es la automatización de tareas repetitivas. Repetir tareas similares
o idénticas es algo que los computadores hacen bien y las personas
no hacen tan bien.
Hemos visto dos programas, \texttt{nLineas} y \texttt{cuenta\_atras}, que usan
la recursividad para llevar a cabo la repetición, que también se llama
\textbf{iteración}. Por ser la iteración tan habitual, Python proporciona
como lenguaje varias características que la hacen más fácil. La primera
característica que vamos a considerar es la sentencia \texttt{while}.
Éste es el aspecto de \texttt{cuenta\_atras} con una sentencia \texttt{while}:
\begin{verbatim}
def cuenta_atras(n):
while n > 0:
print n
n = n-1
print "Despegando!"
\end{verbatim} Como eliminamos la llamada recursiva, esta función no es
recursiva.
Casi podría leer una sentencia \texttt{while} como si fuera inglés
(castellano ``mientras''). Quiere decir que ``Mientras
\texttt{n} sea mayor que cero, continúa mostrando el valor de \texttt{n}
y después restándole 1 al valor de \texttt{n}. Cuando llegues a cero,
muestra la palabra ``Despegando!''.
Más formalmente, el flujo de ejecución de una sentencia \texttt{while}
es el siguiente:
\begin{enumerate}
\item Evaluar la condición, devolviendo \texttt{0} o \texttt{1}.
\item Si la condición es falsa (0), salir de la sentencia \texttt{while}
y continuar la ejecución en la siguiente sentencia.
\item Si la condición es verdadera (1), ejecutar cada una de las sentencias
en el cuerpo del bucle \texttt{while}, y luego volver al paso 1.
\end{enumerate}
El cuerpo está formado por todas las sentencias bajo el encabezado que
tienen el mismo sangrado.
Este tipo de flujo de llama \textbf{bucle} porque el tercer paso vuelve
de nuevo arriba. Nótese que si la condición es falsa la primera vez
que se atraviesa el bucle, las sentencias del interior del bucle no
se ejecutan nunca.
\index{bucle} \index{bucle!cuerpo} \index{cuerpo!bucle} \index{bucle!infinito}
\index{infinito!bucle} \index{condici'on}
El cuerpo del bucle debe cambiar el valor de una o más variables de
manera que, llegado el momento, la condición sea falsa y el bucle
termine. En caso contrario, el bucle se repetirá para siempre, que
es lo que se llama \textbf{bucle infinito}. Una infinita fuente
de diversión para los científicos informáticos es la observación de que
las instrucciones del champú ``lavar, aclarar, repetir'', son un bucle
infinito.
En el caso de \texttt{cuenta\_atras}, podemos probar que el bucle
terminará porque sabemos que el valor de \texttt{n} es finito, y podemos
ver que el valor de \texttt{n} disminuye cada vez que se atraviesa
el bucle (cada iteración), de manera que ea la larga tenemos que llegar
a cero. En otros casos no es tan fácil decirlo:
\begin{verbatim}
def secuencia(n):
while n != 1:
print n,
if n%2 == 0: # n es par
n = n/2
else: # n es impar
n = n*3+1
\end{verbatim} La condición de este bucle es \texttt{n != 1}, de manera
que el bucle continuará hasta que \texttt{n} sea \texttt{1}, que hará
que la condición sea falsa.
En cada iteración, el programa muestra como salida el valor de \texttt{n}
y luego comprueba si es par o impar. Si es par, el valor de \texttt{n}
se divide entre dos. Si es impar, el valor se sustituye por \texttt{3n+1}.
Por ejemplo, si el valor de comienzo (el argumento pasado a la secuencia)
es 3, la secuencia resultante es 3, 10, 5, 16, 8, 4, 2, 1.
Puesto que \texttt{n} a veces aumenta y a veces disminuye, no hay
una prueba obvia de que \texttt{n} alcance alguna vez el valor 1,
o de que el programa vaya a terminar. Para algunos valores particulares
de \texttt{n}, podemos probar la terminación. Por ejemplo, si el valor
de inicio es una potencia de dos, entonces el valor de \texttt{n}
será par cada vez que se pasa a través del bucle, hasta que lleguemos
a 1. El ejemplo anterior acaba con dicha secuencia, empezando por
16.
Dejando aparte valores particulares, la pregunta interesante es
si podemos probar que este programa terminará para \emph{todos} los
valores de \texttt{n}. Hasta la fecha, nadie ha sido capaz de probarlo
o negarlo.
\begin{quote}
\emph{Como actividad, reescriba la función} \texttt{\emph{nLines}}
\emph{de la sección~\ref{recursion} utilizando iteración en lugar
de recursividad.}
\end{quote}
\section{Tablas}
\index{tablas}
\index{logaritmo}
Una de las cosas para las que resultan buenos los bucles es para generar
datos tabulares. Antes de que los computadores estuvieran
disponibles de forma masiva, la gente tenía que calcular a mano logaritmos,
senos, cosenos y otras funciones matemáticas. Para facilitarlo, los libros
de matemáticas contenína largas tablas donde aparecían los valores de estas
funciones. Confeccionar estas tablas era una tarea lenta y pesada, y el
resultado estaba lleno de erratas.
Cuando los computadores aparecieron en escena, una de las primeras
reacciones fue ``¡Qué bueno! Podemos usar los computadores para generar
las tablas, así no habrá errores''. Resultó cierto (casi), pero no se vio
más allá. Poco después los computadores y las calculadoras científicas se
hicieron tan ubicuas que las tablas resultaron obsoletas.
Bueno, casi. Resulta que para ciertas operaciones, los computadores
usan tablas para obtener un valor aproximado, y luego ejecutan cálculos
para mejorar la aproximación. En algunos casos, ha habido errores
en las tablas subyacentes; el más famoso estaba en la tabla que el
Pentium de Intel usaba para llevar a cabo la división de coma flotante.
\index{Intel}
\index{Pentium}
Aunque una tabla logarítmica ya no es tan útil como lo fuera antaño,
todavía constituye un buen ejemplo de iteración. El siguiente programa
muestra una secuencia de valores en la columna izquierda y sus logaritmos
en la columna derecha:
\begin{verbatim}
x = 1.0
while x < 10.0:
print x, '\t', math.log(x)
x = x + 1.0
\end{verbatim} El \texttt{\( \backslash \)t}
representa un carácter de \textbf{tabulación}.
Tal como se van mostrando en la pantalla caracteres y cadenas, un señalador
invisible llamado {\bf cursor} lleva la cuenta de dónde irá el próximo
carácter. Tras una sentencia {\tt print}, el cursor va normalmente al
principio de la línea siguiente.
El carácter de tabulación hace que el cursor se desplace a la derecha
hasta que alcance uno de los marcadores de tabulación. Los tabuladores
son útiles para alinear columnas de texto, como
en la salida del programa anterior:
\begin{verbatim}
1.0 0.0
2.0 0.69314718056
3.0 1.09861228867
4.0 1.38629436112
5.0 1.60943791243
6.0 1.79175946923
7.0 1.94591014906
8.0 2.07944154168
9.0 2.19722457734
\end{verbatim} Si estos valores le parecen raros, recuerde que la función
\texttt{log} usa como base \texttt{e}. Debido a que las potencias
de dos son muy importantes en las ciencias de la computación, generalmente
querremos hallar los logaritmos en relación con la base dos. Para
llevarlo a cabo, podemos usar la siguiente fórmula:
\begin{equation}
\log _{2}x=\frac{log_{e}x}{log_{e}2}
\end{equation}
Cambiar la sentencia de salida a:
\begin{verbatim}
print x, '\t', math.log(x)/math.log(2.0)
\end{verbatim} devuelve
\begin{verbatim}
1.0 0.0
2.0 1.0
3.0 1.58496250072
4.0 2.0
5.0 2.32192809489
6.0 2.58496250072
7.0 2.80735492206
8.0 3.0
9.0 3.16992500144
\end{verbatim} Podemos ver que 1, 2, 4 y 8 son potencias de dos, porque
sus logaritomos de base 2 son números enteros. Si quisiéramos encontrar
los logaritmos de otras potencias de dos, podríamos modificar el programa
de la siguiente manera:
\begin{verbatim}
x = 1.0
while x < 100.0:
print x, '\t', math.log(x)/math.log(2.0)
x = x * 2.0
\end{verbatim} Ahora, en lugar de añadir algo a \texttt{x} cada vez
que atravesamos el bucle, que devuelve una secuencia aritmética, multiplicamos
\texttt{x} por algo, devolviendo una secuencia geométrica. El resultado es:
\index{secuencia aritmética}
\index{secuencia geométrica}
\begin{verbatim}
1.0 0.0
2.0 1.0
4.0 2.0
8.0 3.0
16.0 4.0
32.0 5.0
64.0 6.0
\end{verbatim} Debido a que usamos caracteres de tabulación entre
las columnas, la posición de la segunda columna no depende del número
de dígitos de la primera columna.
Las tablas logarítimicas quizás ya no sean útiles, pero conocer las
potencias de dos no ha dejado de serlo para los científicos informáticos.
\begin{quote}
\emph{Como actividad, modifique el programa para que muestre las potencias
de dos hasta 65536 (es decir, \( 2^{16} \)). Imprímala y memorícela.}
\end{quote}
\index{secuencia de escape}
El carácter de barra invertida en \verb+'\t'+ indica el principio de una
{\bf secuencia de escape}. Las secuencias de escape se usan para representar
caracteres invisibles como tabulaciones y retornos de carro. La secuencia \verb+\n+
representa un retorno de carro.
Una sentencia de escape puede aparecer en cualquier lugar de una cadena; en el
ejemplo, la secuencia de escape del tabulador es la única de la cadena.
¿Cómo cree que puede representar una barra invertida en una cadena?
\begin{quote}
{\em Como ejercicio, escriba un única cadena que
\beforeverb
\begin{verbatim}
presente
esta
salida.
\end{verbatim}
\afterverb
}
\end{quote}
\section{Tablas de dos dimensiones}
\index{tablas!dos dimensiones}
Una tabla de dos dimensiones es una tabla en la que Usted elige una
fila y una columna y lee el valor de la intersección. Un buen ejemplo
es una tabla de multiplicar. Supongamos que desea imprimir una tabla
de multiplicar para los valores del 1 al 6.
Una buena manera de comenzar es escribir un bucle sencillo que imprima
los múltiplos de 2, todos en una línea.
\begin{verbatim}
i = 1
while i <= 6:
print 2*i, '\t',
i = i + 1
print
\end{verbatim} La primera línea inicializa una variable lllamada \texttt{i},
que actuará como contador, o \textbf{variable de bucle}. Conforme se ejecuta
el bucle, el valor de \texttt{i} se incrementa de 1 a 6. Cuando \texttt{i}
vale 7, el bucle termina. Cada vez que se atraviesa el bucle, imprimimos el
valor \texttt{2{*}i} seguido por tres espacios.
De nuevo, la coma de la sentencia \texttt{print} suprime el salto de línea.
Después de completar el bucle, la segunda sentencia \texttt{print} crea una
línea nueva.
La salida de este programa es:
\begin{verbatim}
2 4 6 8 10 12
\end{verbatim} Hasta ahora, bien. El siguiente paso es \textbf{encapsular}
y \textbf{generalizar}.
\section{Encapsulado y generalización}
\label{encapsulation} \index{encapsulado} \index{generalizaci'on}
\index{desarrollo de progamas!encapsulado} \index{desarrollo de programas!generalizaci'on}
Por ``encapsulado'' generalmente se entiende tomar una pieza de código
y envolverla en una función, permitiéndole obtener las ventajas de
todo aquello para lo que valen las funciones. Hemos visto dos ejemplos
de encapsulado, cuando escribimos \texttt{imprimeParidad} en la
Sección~\ref{alternative execution} y \texttt{esDivisible} en la
Sección~\ref{boolean}.
Por ``generalización'' entendemos tomar algo específico, como imprimir
los múltiplos de 2, y hacerlo más general, como imprimir los múltiplos
de cualquier entero.
He aquí una función que encapsula el bucle de la sección anterior
y la generaliza para imprimir múltiplos de \texttt{n}.
\begin{verbatim}
def imprimeMultiplos(n):
i = 1
while i <= 6:
print n*i, '\t',
i = i + 1
print
\end{verbatim} Para encapsular, todo lo que hubimos de hacer fue añadir
la primera línea, que declara el nombre de la función y la lista de
parámetros. Para generalizar, todo lo que tuvimos que hacer fue sustituir
el valor 2 por el parámetro \texttt{n}.
Si llamamos a esta función con el argumento 2, obtenemos la misma
salida que antes. Con el argumento 3, la salida es:
\begin{verbatim}
3 6 9 12 15 18
\end{verbatim} y con argumento 4, la salida es
\begin{verbatim}
4 8 12 16 20 24
\end{verbatim} A estas alturas es probable que haya adivinado cómo
vamos a imprimir una tabla de multiplicación: llamaremos a
\texttt{imprimeMultiplos} repetidamente con diferentes argumentos.
De hecho, podemos a usar otro bucle:
\begin{verbatim}
i = 1
while i <= 6:
imprimeMultiplos(i)
i = i + 1
\end{verbatim} Observe hasta qué punto este bucle es similar
al que hay en el interior de \texttt{imprimeMultiplos}. Todo lo que
hicimos fue sustituir la sentencia \texttt{print} por una llamada
a una función.
La salida de este programa es una tabla de multiplicación:
\begin{verbatim}
1 2 3 4 5 6
2 4 6 8 10 12
3 6 9 12 15 18
4 8 12 16 20 24
5 10 15 20 25 30
6 12 18 24 30 36
\end{verbatim}
\section{Más encapsulación}
Para dar más ejemplos de encapsulación, tomaremos el código del final
de la Sección~\ref{encapsulation} y lo envolveremos en una función:
\begin{verbatim}
def imprimeTablaMult():
i = 1
while i <= 6:
imprimeMultiplos(i)
i = i + 1
\end{verbatim} El proceso que mostramos aquí es un \textbf{plan de
desarrollo} habitual. Se desarrolla gradualmente el código añadiendo
líneas fuera de cualquier función o en el intérprete. Cuando conseguimos
que funcionen, se extraen y se envuelven en una función.
Este plan de desarrollo es especialmente si, al comenzar a escribir,
no sabe cómo dividir el programa en funciones. Este enfoque
le permite diseñarlo sobre la marcha.
\section{Variables locales}
\index{variables!locales} \index{local!variable}
Quizá se esté preguntando cómo podemos usar la misma variable tanto
en \texttt{imprimeMultiplos} como en \texttt{imprimeTablaMult}. ¿No habrá
problemas cuando una de las funciones cambie los valores de la variable?
La respuesta es no, ya que la variable \texttt{i} en \texttt{imprimeMultiplos}
y la variable \texttt{i} in \texttt{imprimeTablaMult} \emph{no} son la
misma variable.
Las variables creadas dentro de una función son locales.
No puede acceder a una variable local fuera de su función ``huésped''.
Eso significa que es posible tener múltiples variables con el mismo nombre,
siempre que no estén en la misma función.
El diagrama de pila de esta función muestra claramente que las dos
variables llamadas \texttt{i} no son la misma variable. Pueden referirse
a diferentes valores, y cambiar uno no afecta al otro.
\vspace{0.1in} \centerline{\includegraphics{../illustrations/stack4.eps} } \vspace{0.1in}
El valor de \texttt{i} en \texttt{imprimeTablaMult} va desde 1 hasta
6. En el diagrama, resulta ser 3. El próximo recorrido del
bucle será 4. En cada recorrido del bucle, \texttt{imprimeTablaMult}
llama a \texttt{imprimeMultiplos} con el valor actual de \texttt{i} como
argumento. Ese valor se asigna al parámetro \texttt{n}.
Dentro de \texttt{imprimeMultiplos}, el valor de \texttt{i} va desde 1 hasta
6. En el diagrama, resulta ser 2. Los cambios en esta variable no tienen ningún
efecto sobre el valor de \texttt{i} en \texttt{imprimeTablaMult}.
Es habitual y perfectamente legal tener diferentes variables locales con
el mismo nombre. En especial, los nombres \texttt{i},
\texttt{j} y \texttt{k} se suelen usar como variables de bucle. Si evita usarlas
en una función porque las utilizó en algún otro lugar, probablemente consiga que
el programa sea más difícil de leer.
\section{Más generalización}
Como otro ejemplo de generalización, imagine que desea un programa
que imprima una tabla de multiplicación de cualquier tamaño, y no
sólo la tabla de 6x6. Podría añadir un parámetro a \texttt{imprimeTablaMult}:
\begin{verbatim}
def imprimeTablaMult(mayor):
i = 1
while i <= mayor:
imprimeMultiplos(i)
i = i + 1
\end{verbatim} Hemos sustituido el valor 6 con el parámetro \texttt{mayor}.
Si ahora se llama a \texttt{imprimeTablaMult} con el argumento 7, obtenemos:
\begin{verbatim}
1 2 3 4 5 6
2 4 6 8 10 12
3 6 9 12 15 18
4 8 12 16 20 24
5 10 15 20 25 30
6 12 18 24 30 36
7 14 21 28 35 42
\end{verbatim} lo que es correcto, excepto por el hecho de que seguramente
queremos que la tabla esté cuadrada, con el mismo número de filas que de columnas.
Para hacerlo, añadimos otro parámetro a \texttt{imprimeMultiplos},
a fin de especificar cuántas columnas tendría que tener la tabla.
Sólo para fastidiar, llamaremos también a este parámetro \texttt{mayor},
para demostrar que diferentes funciones pueden tener parámetros con
el mismo nombre (al igual que las variables locales). Aquí tenemos el
programa completo:
\begin{verbatim}
def imprimeMultiplos(n, mayor):
int i = 1
while i <= mayor:
print n*i, '\t',
i = i + 1
print
def imprimeTablaMult(mayor):
int i = 1
while i <= mayor:
imprimeMultiplos(i, mayor)
i = i + 1
\end{verbatim} Nótese que al añadir un nuevo parámetro, tuvimos que
cambiar la primera línea de la función (el encabezado de la función),
y tuvimos también que cambiar el lugar donde se llama a la función
en \texttt{imprimeTablaMult}.
Según lo esperado, este programa genera
una tabla cuadrada de 7x7:
\begin{verbatim}
1 2 3 4 5 6 7
2 4 6 8 10 12 14
3 6 9 12 15 18 21
4 8 12 16 20 24 28
5 10 15 20 25 30 35
6 12 18 24 30 36 42
7 14 21 28 35 42 49
\end{verbatim} Cuando generaliza correctamente una función, a menudo se encuentra
con que el programa resultante tiene capacidades que Usted no pensaba.
Por ejemplo, quizá observe que la tabla de multiplicación es simétrica,
porque \( ab=ba \), de manera que todas las entradas de la tabla
aparecen dos veces. Puede ahorrar tinta imprimiendo sólo la mitad
de la tabla. Para hacerlo, sólo tiene que cambiar una línea de \texttt{imprimeTablaMult}.
Cambie
\begin{verbatim}
imprimeMultiplos(i, mayor)
\end{verbatim} por
\begin{verbatim}
imprimeMultiplos(i, i)
\end{verbatim} y obtendrá
\begin{verbatim}
1
2 4
3 6 9
4 8 12 16
5 10 15 20 25
6 12 18 24 30 36
7 14 21 28 35 42 49
\end{verbatim}
\begin{quote}
\emph{Como actividad, siga o trace la ejecución de esta nueva versión
de} \texttt{\emph{imprimeTablaMult}} \emph{para hacerse una idea de
cómo funciona.}
\end{quote}
\section{Funciones}
\index{funci'on}
Hasta el momento hemos mencionado en alguna ocasión ``todas las cosas
para las que sirven las funciones''. Puede que ya se esté preguntando
qué cosas son exactamente. He aquí algunas de las razones por las
que las funciones son útiles:
\begin{itemize}
\item Al dar un nombre a una secuencia de sentencias, hace que su programa
sea más fácil de leer y depurar.
\item Dividir un programa largo en funciones le permite separar partes del
programa, depurarlas aisladamente, y luego recomponerlas en un todo.
\item Las funciones facilitan tanto la recursividad como la iteración.
\item Las funciones bien diseñadas son generalmente útiles para más de
un programa. Una vez escritas y depuradas, puden reutilizarse.
\end{itemize}
\section{Glosario}
\begin{description}
\item [asignación~múltiple:]Hacer más de una asignación a la misma variable
durante la ejecución de un programa.
\item [iteración:]La ejecución repetida de un conjunto de sentencias por medio
de una llamada recursiva a una función o un bucle.
\item [bucle:]Sentencia o grupo de sentencias que se ejecutan repetidamente
hasta que se cumple una condición de terminación.
\item [bucle~infinito:]Bucle cuya condición de terminación nunca se cumple.
\item [cuerpo:]Las sentencias que hay dentro de un bucle.
\item [variable~de~bucle:]Variable que se usa para determinar la condición
de terminación de un bucle.
\item [tabulador:]Carácter especial que hace que el cursor se mueva hasta
la siguiente marca de tabulación en la línea actual.
\item [nueva línea:]Un carácter especial que hace que le cursor se mueva al
inicio de la siguiente línea.
\item [cursor:] Un marcador invisible que sigue el rastro de dónde se
imprimirá el siguiente carácter.
\item [secuencia~de~escape:]Carácter de escape (\( \backslash \)) seguido
por uno o más caracteres imprimibles, que se usan para designar un
carácter no imprimible.
\item [encapsular:]Dividir un programa largo y complejo en componentes (como
las funciones) y aislar los componentes unos de otros (por ejemplo
usando variables locales).
\item [generalizar:]Sustituir algo innecesariamente específico (como es un
valor constante) con algo convenientemente general (como es una variable
o parámetro). La generalización hace el código más versátil, más apto
para reutilizarse y algunas veces incluso más fácil de escribir.
\item [plan~de~desarrollo:]Proceso para desarrollar un programa. En este
capítulo, hemos mostrado un estilo de desarrollo basado en desarrollar
código para hacer cosas simples y específicas, y luego encapsularlas
y generalizarlas.
\index{asignación múltiple} \index{múltiple!asignación} \index{iteración}
\index{bucle!cuerpo} \index{bucle} \index{bucle!infinito} \index{escape!secuencia de}
\index{secuencia de escape} \index{tabulador} \index{cursor} \index{nueva línea}
\index{variable de bucle}
\index{bucle!variable de} \index{encapsular} \index{generalizar}
\index{plan de desarrollo} \index{programa!desarrollo de} \index{desarrollo de programas}
\end{description}
%\end{document}
