Chapter 6
\documentclass[oneside,english]{book
\usepackage[T1]{fontenc}
\usepackage[latin1]{inputenc}
\usepackage{babel}
\setcounter{secnumdepth}{3}
\setcounter{tocdepth}{3}
\usepackage{graphics}
\makeatletter
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% LyX specific LaTeX commands.
\providecommand{\LyX}{L\kern-.1667em\lower.25em\hbox{Y}\kern-.125emX\@}
\makeatother
\begin{document}
\chapter{Iteración}
\index{iteración}
\section{Asignación múltiple}
\index{asignación} \index{sentencia!asignación} \index{asignación múltiple}
No lo hemos tratado hasta el momento, pero es legal en Python hacer
más de una asignación a la 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.
\begin{verbatim}
bruce = 5
print bruce,
bruce = 7
print bruce
\end{verbatim} La salida del programa es \texttt{5 7}, ya que la primera
vez que imprimimos \texttt{bruce} 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.
He aquí el aspecto de una asignación múltiple en un diagrama de estado:
\vspace{0.1in} \centerline{\includegraphics{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{Iteración}
\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 programas que usan la recursividad para llevar a cabo
la repetición, como por ejemplo \texttt{nLineas} y \texttt{cuenta\_atras}.
Este tipo de repetición se llama \textbf{iteración}, y Python proporciona
como lenguaje varias características que hacen más fácil la escritura
de programas iterativos.
La primera característica que vamos a considerar es la sentencia \texttt{while}.
\section{La sentencia \texttt{while}}
\index{sentencia!while} \index{while!sentencia} \index{bucle!while}
Reescribamos \texttt{cuenta\_atras} usando una sentencia \texttt{while}:
\begin{verbatim}
def cuenta_atras(n):
while n > 0:
print n
n = n-1
print "Despegando!"
\end{verbatim} Podría casi 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}, (todas las sentencias con el
mismo sangrado que siguen a la línea que contiene el \texttt{while}),
y luego vuelve al paso 1.
\end{enumerate}
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}
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}. Es una infinita fuente
de diversión para los científicos informáticos 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 sequence(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, es interesante la pregunta de
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}
Una de las cosas para las que resultan buenos los bucles es para generar
datos tabulares. Por ejemplo, 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, existían
libros donde podían encontrarse los valores de determinadas 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». Ello resultó en su mayor parte cierto, 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.
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} La \textbf{secuencia de escape} \texttt{\( \backslash \)t}
representa un carácter de \textbf{tabulación}. También puede usar
la secuencia de escape \texttt{\( \backslash \)n} para representar
un carácter de nueva línea. Estas secuencias de escape pueden incluirse
en cualquier lugar dentro de una cadena, aunque en este ejemplo la
secuencia de escape de tabulación es el único elemento en la cadena.
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 hacer columnas de texto siguiendo las líneas, como
en la salida del programa:
\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 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:
\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}
\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 variable de bucle. Conforme se ejecuta
el bucle, el valor de \texttt{i} se incrementa de 1 a 6, y entonces,
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.
Al colocar una coma al final de la sentencia \texttt{print}, obtenemos
toda la salida en una única línea. Después de completar el bucle,
una sentencia \texttt{print} sin argumentos se usa para comenzar una
línea nueva.
La salida de este programa es:
\begin{verbatim}
2 4 6 8 10 12
\end{verbatim} Cuanto más lejos, mejor. El siguiente paso es \textbf{encapsular}
y \textbf{generaliz}ar.
\section{Encapsulado y generalización}
\label{encapsulation} \index{encapsulado} \index{generalización}
\index{desarrollo de progamas!encapsulado} \index{desarrollo de programas!generalización}
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{printParity} en la Sección~\ref{alternative execution}
y \texttt{isDivisible} 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 printMultiples(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{printMultiples}
repetidamente con diferentes argumentos. De hecho, vamos a usar otro
bucle para iterar a lo largo de las filas:
\begin{verbatim}
i = 1
while i <= 6:
printMultiples(i)
i = i + 1
\end{verbatim} En primer lugar, observe cuán similar es este bucle
al que hay en el interior de \texttt{printMultiples}. Todo lo que
hicimos fue sustituir la sentencia \texttt{print} por una llamada
a una función.
La salida de este programa es
\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} que es una tabla de multiplicación.
\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 printMultTable():
i = 1
while i <= 6:
printMultiples(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 en \_\_main\_\_ o en cualquier otro lugar, y luego, cuando
se consiga que funcionen, se extraen y se envuelven en una función.
Este proceso se simplifica aún más haciendo uso del intérprete. Primero
pruebe su idea con el intérprete. Esto le permitirá obtener la inmediata
prueba de las preguntas «¿qué sucede si escribo esto?». Una vez que
consiga que la función haga lo que usted quiere, utilice un editor
de texto para guardarla en un módulo.
Este plan de desarrollo es también útil por otra razón. A veces (y
más a menudo cuando está empezando a aprender), al comenzar a escribir
no sabrá exactamente 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{printMultiples} como en \texttt{printMultTable}. ¿No habrá
problemas cuando una de las funciones cambie los valores de la variable?
La respuestas es no, ya que la variable \texttt{i} en \texttt{printMultiples}
y la variable \texttt{i} in \texttt{printMultTable} \emph{no son la
misma variable}.
Recuerde que las variables creadas dentro de una función son locales.
No puede acceder a una variable local fuera de su función «huésped»,
y 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{stack4.eps} } \vspace{0.1in}
El valor de \texttt{i} en \texttt{printMultiple} va desde uno hasta
\texttt{n}. En el diagrama, resulta ser 2. El próximo recorrido del
bucle será 3.
A menudo es una buena idea usar diferentes nombres de variable en
diferentes funciones para evitar confusión, pero hay buenas razones
para reutilizar los nombres. Por ejemplo, es usual utilizar los nombres\texttt{i},
\texttt{j} y \texttt{k} como variables de bucle. Si evita usarlas
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{printMultTable}:
\begin{verbatim}
def printMultTable(high):
i = 1
while i <= high:
printMultiples(i)
i = i + 1
\end{verbatim} Hemos sustituido el valor 6 con el parámetro \texttt{high}.
Si se llama a \texttt{printMultTable} 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é cuadriculada (mismo número de filas y columnas),
lo que significa que tenemos que añadir otro parámetro a \texttt{printMultiples},
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{high},
para demostrar que diferentes funciones pueden tener parámetros con
el mismo nombre (al igual que las variables locales):
\begin{verbatim}
def printMultiples(n, high):
int i = 1
while i <= high:
print n*i, '\t',
i = i + 1
print
def printMultTable(high):
int i = 1
while i <= high:
printMultiples(i, high)
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{printMultTable}. Según lo esperado, este programa genera
una tabla cuadriculada 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 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{printMultTable}.
Cambie
\begin{verbatim}
printMultiples(i, high)
\end{verbatim} por
\begin{verbatim}
printMultiples(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{printMultTable}} \emph{para hacerse una idea de
cómo funciona.}
\end{quote}
\section{Funciones}
\index{funciones}
En alguna ocasión hasta el momento hemos mencionado «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 con buen diseño 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 repetición sucesiva (ejecución) del cuerpo de un bucle,
hasta que se encuentre una condición de salida o terminación. En su
uso singular una iteración se refiere a un recorrido a través del
cuerpo del bucle, incluida la evaluación de la condición.
\item [cuerpo:]Las sentencias que hay dentro de 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 [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. Las otras secuencias de escape son followed
by one or more printable characters, used to designate a non-printable
character. The other escape sequences are:
\begin{tabbing}
ESCAPESEQUENCEfillUPwit:\={M}EANINGfillUPwit:\kill
\textbf{Escape Sequence} \>\textbf{Meaning}\\
\(\backslash\backslash\) \>Backslash (\(\backslash\))\\
\(\backslash\)' \>Single quote (')\\
\(\backslash\)" \>Double quote (")\\
\(\backslash\)a \>ASCII Bell (BEL)\\
\(\backslash\)b \>ASCII Backspace (BS)\\
\(\backslash\)n \>ASCII Linefeed (LF)\\
\(\backslash\)t \>ASCII Horizontal Tab (TAB)\\
\(\backslash\)v \>ASCII Vertical Tab (VT)\\
\(\backslash\){\emph{ooo}} \>ASCII character with octal value {\emph{ooo}}\\
\(\backslash\)x{\emph{hh...}} \>ASCII character with hex value {\emph{hh...}}\\
\end{tabbing}
\end{description}
\begin{description}
\item [tabulador:]Carácter especial que hace que el cursos se mueva hasta
la siguiente marca de tabulación en la línea actual.
\item [variable~de~bucle:]Variable, generalmente llamada contador, que
se usa para determinar la condición de terminación de un bucle. Cuando
se usa como contador, la variable de bucle se incrementa en 1 por
cada recorrido a través del bucle hasta que se alcance el número de
iteraciones deseadas.
\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 un
valor constante) con algo aproximadamente general (como 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{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}