Next Up Previous Hi Index

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}


Next Up Previous Hi Index