Chapter 3
Funciones
3.1 Llamadas a funciones
Ya hemos visto un ejemplo de una llamada a una funci�n:
>>> type("32")
<type 'string'>
El nombre de la funci�n es \texttt{type, y muestra
el tipo de un valor o de una variable. El valor o variable, llamado
el \textbf{argumento} de la funci�n, ha de estar encerrado entre par�ntesis.
Es habitual decir que una funci�n ``toma'' un argumento y ``devuelve''
un resultado. El resultado se llama \textbf{valor de retorno}.
\index{argumento} \index{valor de retorno}
En lugar de imprimir el valor de retorno, podemos asign�rselo a una
variable.
\begin{verbatim}
>>> nereida = type("32")
>>> print nereida
\end{verbatim} Otro ejemplo m�s: la funci�n \texttt{id} toma como
argumento un valor o una variable y devuelve un entero que
act�a como identificador �nico de ese valor.
\begin{verbatim}
>>> id(3)
134882108
>>> yanira = 3
>>> id(yanira)
134882108
\end{verbatim} Cada valor tiene un \texttt{id}, que es un valor �nico
relacionado con d�nde se almacena en la memoria del computador. El
\texttt{id} de una variable es el \texttt{id} del valor al que hace referencia.
\section{Conversi�n de tipos}
\index{conversi�n de tipos} \index{tipos!conversi�n}
Python proporciona una colecci�n de funciones internas que convierten
valores de un tipo a otro. La funci�n \texttt{int} toma un valor y
lo convierte a un entero, si es posible, o da un error si no es posible.
\begin{verbatim}
>>> int("32")
32
>>> int("Hola")
ValueError: invalid literal for int(): Hola
\end{verbatim} \texttt{int} tambi�n convierte valores de coma flotante
a enteros, pero recuerde que siempre redondea hacia abajo:
\begin{verbatim}
>>> int(3.99999)
3
\end{verbatim} La funci�n \texttt{float} que convierte
enteros y cadenas en n�meros en coma flotante:
\begin{verbatim}
>>> float(32)
32.0
>>> float("3.14159")
3.14159
\end{verbatim} Finalmente, est� la funci�n \texttt{str}, que convierte
a tipo \texttt{string}:
\begin{verbatim}
>>> str(32)
'32'
>>> str(3.14149)
'3.14149'
\end{verbatim} Pudiera parecer extra�o que Python distinga entre el
valor entero \texttt{1} y el valor de coma flotante \texttt{1.0}.
Tal vez representen el mismo n�mero, pero pertenecen a tipos distintos.
El motivo es que se representan de forma distinta dentro del computador.
\section{Coerci�n de tipos}
\index{coerci�n de tipos} \index{tipos!coerci�n}
\index{divisi�n de enteros}
\index{enteros!divisi�n}
Ahora que ya sabemos convertir entre tipos, tenemos otra forma de enfrentarnos
a la divisi�n de enteros. Volviendo al ejemplo del cap�tulo anterior, suponga
que queremos calcular qu� fracci�n de una hora hab�a transcurrido. La expresi�n
m�s obvia, \texttt{minuto / 60}, realiza una divisi�n de enteros, por lo que el
resultado es siempre 0, incluso 59 minutos despu�s de la hora.
Una alternativa es convetir \texttt{minuto} a tipo float (coma flotante)
y luego efectuar una divisi�n de coma flotante:
\begin{verbatim}
>>> minuto = 59
>>> float(minuto) / 60.0
0.983333333333
\end{verbatim} O bien podemos sacar provecho de las reglas de la
conversi�n autom�tica de tipos, llamada \textbf{coerci�n}
de tipos. Para los operadores matem�ticos, si uno de los
operandos matem�ticos es tipo \texttt{float}, el otro se convierte
autom�ticamente en \texttt{float}.
\index{coercion}
\begin{verbatim}
>>> minuto = 59
>>> minuto / 60.0
0.983333333333
\end{verbatim} Al usar un denomidador que es \texttt{float}, obligamos
a Python a hacer divisi�n de coma flotante.
\section{Funciones matem�ticas}
\index{funciones matem�ticas} \index{matem�ticas!funciones}
Es posible que ya haya visto usted en matem�ticas funciones como \texttt{sin}
(seno) y \texttt{log}, y que haya aprendido a evaluar expresiones
como \texttt{sin(pi/2)} y \texttt{log(1/x)}. Primero eval�a la expresi�n
entre par�ntesis, (el argumento). Por ejemplo, \texttt{pi/2} es aproximadamente
1.571, y \texttt{1/x} es 0.1 (si \texttt{x} es igual a \texttt{10.0}).
Luego eval�a la funci�n en s� misma, bien mir�ndola en una tabla,
bien llevando a cabo diversos c�lculos. El \texttt{sin} (seno) de
1.571 es 1, y el \texttt{log} de 0.1 es -1 (suponiendo que \texttt{log}
indique el logaritmo de base 10).
Este proceso puede aplicarse repetidamente para evaluar expresiones
m�s complicadas como \texttt{log(1/sin(pi/2))}. Primero evaluamos
el argumento de la funci�n m�s interna, luego se eval�a la funci�n,
y as� sucesivamente.
Python dispone de un m�dulo matem�tico que proporciona la mayor�a
de las funciones matem�ticas habituales. Un \textbf{m�dulo}
es un archivo que contiene una colecci�n de funciones agrupadas juntas.
\index{m�dulo}
Antes de poder usar las funciones de un m�dulo, tenemos que importarlo:
\begin{verbatim}
>>>import math
\end{verbatim} Para llamar a una de las funciones, tenemos que especificar
el nombre del m�dulo y el nombre de la funci�n, separados por un punto. A
esto se le llama notaci�n de punto:
\begin{verbatim}
decibelio = math.log10 (17.0)
angulo = 1.5
altura = math.sin(angulo)
\end{verbatim} La primera sentencia da a \texttt{decibelio} el valor
del logaritmo de 17, en base \texttt{10}. Hay tambi�n una funci�n
llamada \texttt{log} que toma logaritmos en base \texttt{e}.
La tercera sentencia halla el seno del valor de la variable \texttt{angulo}.
\texttt{sin} y las otras funciones trigonom�tricas (\texttt{cos},
\texttt{tan}, etc.) toman sus argumentos en \emph{radianes}. Para
convertir de grados a radianes, puede dividir por 360 y multiplicar
por \texttt{2{*}pi}. Por ejemplo, para hallar el seno de 45 grados,
calcule primero el �ngulo en radianes y luego halle el seno:
\begin{verbatim}
grados = 45
angulo = grados * 2 * math.pi / 360.0
math.sin(angulo)
\end{verbatim} La constante \texttt{pi} tambi�n es parte del m�dulo
\texttt{math}. Si se sabe la geometr�a, puede verificar el resultado
compar�ndolo con el de la ra�z cuadrada de 2, dividida entre 2.
\begin{verbatim}
>>> math.sqrt(2) / 2.0
0.707106781187
\end{verbatim}
\section{Composici�n}
\index{composici�n} \index{funciones!composici�n}
Igual que con las funciones matem�ticas, las funciones de Python se
pueden componer; eso quiere decir que se usa una expresi�n como parte
de otra. Por ejemplo, puede usar cualquier expresi�n como argumento
de una funci�n:
\begin{verbatim}
x = math.cos(angulo + pi/2)
\end{verbatim} Esta sentencia toma el valor de \texttt{pi}, lo divide
entre dos y le a�ade el resultado al valor de \texttt{angulo}. La
suma se pasa luego como argumento a la funci�n \texttt{cos}.
Tambi�n puede tomar el resultado de una funci�n y pas�rselo como argumento
a otra:
\begin{verbatim}
x = math.exp(math.log(10.0))
\end{verbatim} Esta sentencia encuentra el logaritmo en base \texttt{e}
de 10 y luego eleva \texttt{e} a ese exponente. El resultado queda
asignado a \texttt{x}.
\section{A�adir funciones nuevas}
Hasta ahora s�lo hemos usado las funciones que vienen incluidas con
Python, pero tambi�n es posible a�adir nuevas funciones. La creaci�n
de nuevas funciones para resolver sus problemas partigulares es una
de las cosas m�s �tiles de los lenguajes de programaci�n de prop�sito
general.
En contextos de programaci�n, \textbf{funci�n} es una secuencia de
instrucciones con nombre, que lleva a cabo la operaci�n deseada. Esta
operaci�n se especifica en una \textbf{definici�n de funci�n}. Las
funciones que hemos usado hsta ahora las han definido por nosotros,
y esas definiciones est�n ocultas. Eso es bueno, ya que nos permite
usar funciones sin preocuparnos sobre los detalles de sus definiciones.
\index{funci�n} \index{definici�n de funci�n} \index{funci�n!definici�n}
La sintaxis de la definici�n de una funci�n es:
\begin{verbatim}
def NOMBRE( LISTA DE PARAMETROS ):
SENTENCIAS
\end{verbatim} Puede inventarse el nombre que desee para su funci�n,
con la excepci�n de que no puede usar las palabras reservadas de Python.
La lista de par�metros especifica qu� informaci�n, en caso de haberla,
ha de proporcionar para usar la funci�n nueva.
Puede haber cualquier n�mero de sentencias dentro de la funci�n, pero
tienen que estar indentadas desde el margen izquierdo. En los ejemplos
de este libro se usar� una indentaci�n de dos espacios.
El primer par de funciones que escribiremos no tienen par�metros,
de manera que su sintaxis es:
\begin{verbatim}
def nueva_linea():
print
\end{verbatim} Esta funci�n se llama \texttt{nueva\_linea}. Los par�ntesis
vac�os indican que no tiene par�metros. Contiene una �nica sentencia,
que muestra como salida un car�cter de nueva l�nea (es lo que sucede
cuando utiliza una orden \texttt{print} sin argumentos).
Llamamos entonces a la funci�n nueva usando la misma sintaxis que
usamos para las funciones internas:
\begin{verbatim}
print "Primera linea."
nueva_linea()
print "Segunda linea."
\end{verbatim} The output of this program is
\begin{verbatim}
Primera linea.
Segunda linea.
\end{verbatim} Observe el espacio a�adido que hay entre las dos l�neas.
Si quisi�ramos m�s espacios, entre las l�neas, �qu� har�amos? Podemos
llamar varias veces a la misma funci�n:
\begin{verbatim}
print "Primera linea."
nueva_linea()
nueva_linea()
nueva_linea()
print "Segunda linea."
\end{verbatim} O bien podemos escribir una nueva funci�n que llamaremos
\texttt{tresLineas}, y que imprima tres nuevas l�neas:
\begin{verbatim}
def tresLineas():
nueva_linea()
nueva_linea()
nueva_linea()
print "Primera Linea."
tresLineas()
print "Segunda Linea."
\end{verbatim} Esta funci�n contiene tres sentencias, las cuales est�n
todas indentadas con dos espacios. Puesto que la siguiente sentencia
no est� indentada, Python sabe que no es parte de la funci�n.
Observe los siguientes puntos con respecto a este programa:
\begin{enumerate}
\item Se puede llamar al mismo procedimiento repetidamente. De hecho es
bastante �til hacerlo, adem�s de habitual.
\item Se puede llamar a una funci�n desde dentro de otra funci�n: en este
caso \texttt{tresLineas} llama a \texttt{nueva\_linea}.
\end{enumerate}
Hasta ahora puede no haber quedar claro por qu� vale la pena crear
todas estas funciones nuevas. En realidad hay much�simas razones,
pero este ejemplo demuestra dos:
\begin{itemize}
\item Crear una nueva funci�n le da la oportunidad de dar un nombre a un
grupo de sentencias. Las funciones simplifican su programa al ocultar
c�lculos complejos detr�s de �rdenes sencillas, y usar palabras de su propia
lengua en vez de c�digo arcano.
\item Crear una nueva funci�n hace que el programa sea m�s peque�o, al eliminar
c�digo repetitivo. Por ejemplo, una manera de imprimir nueve l�neas
consecutivas es llamar a \texttt{tresLineas} tres veces.
\end{itemize}
\begin{quote}
\emph{Como actividad, escriba una funci�n llamada} \texttt{\emph{nueveLineas}}
\emph{que use} \texttt{\emph{tresLineas}} \emph{para imprimir nueve
l�neas en blanco. �C�mo imprimir�a 27 l�neas nuevas?}
\end{quote}
\section{Las definiciones y el uso}
Juntando los fragmentos de c�digo de la secci�n anterior, el programa
completo queda de la siguiente manera:
\begin{verbatim}
def nueva_linea():
print
def tresLineas():
nueva_linea()
nueva_linea()
nueva_linea()
print "Primera Linea."
tresLineas()
print "Segunda Linea."
\end{verbatim}
El presente programa contiene dos definiciones de funciones:
\texttt{nueva\_linea} y \texttt{tresLineas}. Las definiciones de funciones
se ejecutan como el resto de sentencias, pero el efecto es crear una
nueva funci�n. Las sentencias del interior de la funci�n no se ejecutan
hasta que se llama a la funci�n, y la definici�n de la funci�n no
genera salida.
Como era de esperar, tiene que crear una funci�n antes de poder ejecutarla.
En otras palabras, la definici�n de la funci�n tiene que ejecutarse
antes de la primera vez que se la invoque.
\begin{quote}
\emph{Como actividad, pruebe a ejecutar este programa moviendo las
tres �ltimas sentencias al principio del programa. Registre qu� mensaje
de error obtiene usted.}
\emph{Como segunda actividad, pruebe a tomar la versi�n del programa que funcionaba
y a mover la definci�n de} \texttt{\emph{nueva\_linea}} \emph{m�s
abajo que la definici�n de} \texttt{\emph{tresLineas}}\emph{. �Qu�
ocurre cuando ejecuta el programa?}
\end{quote}
\section{Flujo de ejecuci�n}
\index{flujo de ejecuci�n}
Para asegurarse de que una funci�n se define antes de su primer uso,
tiene que conocer el orden en el que se ejecutan las sentencias; a
esto se le llama \textbf{flujo de ejecuci�n}.
La ejecuci�n comienza siempre por la primera sentencia del programa.
Las sentencias se ejecutan a raz�n de una cada vez, en orden, hasta
que se alcanza una llamada a una funci�n.
Las definiciones de funciones no alteran el flujo de ejecuci�n del
programa, pero recuerde que las sentencias que hay dentro de la funci�n
no se ejecutan hasta que se hace la llamada a la funci�n. Aunque no
es habitual, puede definir una funci�n dentro de otra. En este caso,
la definici�n de funci�n interior no se ejecuta hasta que no se llama
a la funci�n exterior.
Las llamadas a funciones son como un desv�o en el flujo de ejecuci�n.
En lugar de ir a la siguiente sentencia, el flujo salta hasta la primera
l�nea de la funci�n a la que se llama, ejecuta todas las sentencias
que encuentre all�, y vuelve a retomar la ejecuci�n en el punto donde
lo dej�.
Esto suena bastante sencillo... hasta que se acuerda de que una funci�n
puede llamar a otra. Mientras estamos en medio de una funci�n, podr�amos
vernos obligados a abandonarla e ir a ejecutar sentencias en otra
funci�n m�s. Pero mientras estamos en esta nueva funci�n, �podr�amos
salirnos y ejecutar otra funci�n m�s!
Afortunadamente, a Python se le da bien tomar nota de d�nde est�,
de manera que cada vez que se completa una funci�n, el programa retoma
el punto en donde lo dej� en la funci�n que hizo la llamada. Cuando
llega al final del programa, termina.
�Cu�l es la moraleja de toda esta historia? Cuando est� leyendo un
programa, no lo lea desde la parte superior a la inferior. En lugar
de eso, siga el flujo de ejecuci�n.
\section{Par�metros y argumentos}
\label{parameters} \index{par'ametros} \index{funciones!par'ametros}
\index{argumentos} \index{funciones!argumentos}
Algunas de las funciones internas que hemos usado precisan de argumentos,
los valores que controlan c�mo la funci�n lleva a cabo su tarea. Por
ejemplo, si desea encontrar el seno de un n�mero, tiene que indicar
de qu� n�mero se trata. As� pues, \texttt{sin} toma como argumento
un valor num�rico.
Algunas funciones toman m�s de un argumento, como \texttt{pow}, que
toma dos argumentos: la base y el exponente. Dentro de la funci�n,
los valores que se le han pasado se asignan a variables llamadas \textbf{par�metros}.
He aqu� un ejemplo de una funci�n definida por el usuario, que toma
un par�metro:
\begin{verbatim}
def imprimeDoble(paso):
print paso, paso
\end{verbatim} Esta funci�n toma un �nico argumento y se lo asigna
a un par�metro llamado \texttt{paso}. El valor del par�metro (en este
punto todav�a no tenemos ni idea de cu�l ser�) se imprime dos veces,
seguido por un car�cter de nueva l�nea. El nombre \texttt{paso} se
eligi� para sugerir que el nombre que le d� a un par�metro depende de
usted, pero en general es mejor que elija un nombre m�s ilustrativo
que \texttt{paso}.
La funci�n \texttt{imprimeDoble} sirve con cualquier tipo (de dato)
que se pueda imprimir:
\begin{verbatim}
>>> imprimeDoble('Jam�n')
Jam�n Jam�n
>>> imprimeDoble(5)
5 5
>>> imprimeDoble(3.14159)
3.14159 3.14159
\end{verbatim} En la primera llamada a la funci�n, el argumento es
una cadena; en la segunda es un entero, y en la tercera es un n�mero
de coma flotante.
Las mismas reglas de composici�n que se aplican a las funciones internas
se aplican tambi�n a las funciones definidas por el usuario, as� que
puede usar cualquier tipo de expresi�n como argumento de \texttt{imprimeDoble}.
\begin{verbatim}
>>> imprimeDoble('Jam�n'*4)
Jam�nJam�nJam�nJam�n Jam�nJam�nJam�nJam�n
>>> imprimeDoble(math.cos(math.pi))
-1.0 -1.0
\end{verbatim}
Como de costumbre, se eval�a la expresi�n antes de
ejecutar la funci�n, de modo que \texttt{imprimeDoble} devuelve
\texttt{Jam�nJam�nJam�nJam�n Jam�nJam�nJam�nJam�n}
en lugar de \texttt{'Jam�n'*4' Jam�n'*4}.
Asimismo podemos usar una variable como argumento:
\begin{verbatim}
>>> latoya = 'Dafne, es mitad laurel mitad ninfa'
>>> imprimeDoble(latoya)
Dafne, es mitad laurel mitad ninfa. Dafne, es mitad laurel mitad ninfa.
\end{verbatim}
Observe un aspecto realmente importante en este caso:
el nombre de la variable que pasamos como argumento (\texttt{latoya})
no tiene nada que ver con el nombre del par�metro (\texttt{paso}).
No importa c�mo se llamaba el valor en su lugar original (el lugar
desde donde se invoc�); aqu� en \texttt{imprimeDoble} llamamos a todo
el mundo \texttt{paso}.
\section{Las variables y los par�metros son locales}
\index{variables locales} \index{locales!variables}
Cuando crea una variable dentro de una funci�n, s�lo existe dentro
de dicha funci�n, y no puede usarla fuera de ella. Por ejemplo, la
funci�n
\begin{verbatim}
>>> def catDoble(parte1, parte2):
... cat = parte1 + parte2
... imprimeDoble(cat)
...
>>>
\end{verbatim} toma dos argumentos, los concatena y luego imprime el
resultado dos veces. Podemos llamar a la funci�n con dos cadenas:
\begin{verbatim}
>>> cantus1 = "Die Jesu domine, "
>>> cantus2 = "Dona eis requiem."
>>> catDoble(cantus1, cantus2)
Die Jesu domine, Dona eis requiem. Die Jesu domine, Dona eis requiem.
\end{verbatim} Cuando \texttt{catDoble} termina, la variable \texttt{cat}
se destruye. Si trat�semos de imprimirla, obtendr�amos un error:
\begin{verbatim}
>>> print cat
NameError: cat
\end{verbatim} Los par�metros tambi�n son locales. Por ejemplo, una vez fuera de
la funci�n \texttt{imprimeDoble}, no existe nada llamado \texttt{paso}.
Si trata de usarla, Python se quejar�.
\section{Diagramas de pila}
\label{stackdiagram}
\index{diagramas de pila}
Para mantener el rastro de qu� variables pueden usarse y d�nde, a
veces es �til dibujar un \textbf{diagrama de pila}. Como los diagramas
de estado, los diagramas de pila muestran el valor de cada variable,
pero tambi�n muestran la funci�n a la que cada variable pertenece.
Cada funci�n se representa por una caja con el nombre de la funci�n
junto a �l. Los par�metros y variables que pertenecen a una funci�n
van dentro. Por ejemplo, el diagrama de stack para el programa anterior
tiene este aspecto:
\vspace{0.1in} \centerline{\includegraphics{../illustrations/stack.eps} } \vspace{0.1in}
El orden de la pila muestra el flujo de ejecuci�n. \texttt{imprimeDoble}
fue llamado por \texttt{catDoble} y a \texttt{catDoble} lo invoc�
\texttt{\_\_main\_\_}, que es un nombre especial de la funci�n
m�s alta. Cuando crea una variable fuera de cualquier funci�n, pertenece
a \texttt{\_\_main\_\_}.
En cada caso, el par�metro se refiere al mismo valor que el argumento
correspondiente. As� que \texttt{parte1} en \texttt{catDoble} tiene
el mismo valor que \texttt{cantus1} en \texttt{\_\_main\_\_}.
Si sucede un error durante la llamada a una funci�n, Python imprime el
nombre de la funci�n y el nombre de la funci�n que la llam�,
y el nombre de la funci�n que llam� a {\em �sa}, y as� hasta
{\tt \_\_main\_\_}.
Por ejemplo, si intentamos acceder a {\tt cat} desde {\tt
imprimeDoble}, provocaremos un {\tt NameError}:
\beforeverb
\begin{verbatim}
Traceback (innermost last):
File "test.py", line 13, in __main__
catDoble(cantus1, cantus2)
File "test.py", line 5, in catDoble
imprimeDoble(cat)
File "test.py", line 9, in imprimeDoble
print cat
NameError: cat
\end{verbatim}
\afterverb
%
Esta lista de funciones de llama {\bf traceback} (traza inversa). Le dice
a usted en qu� archivo de programa sucedi� el error, y en qu� l�nea, y qu�
funciones se ejecutaban en ese momento. Tambi�n muestra la l�nea de c�digo
que caus� el error.
\index{traceback}
F�jese en la similaridad entre la traza inversa y el
diagrama de pila. No es una coincidencia.
\section{Funciones con resultado}
Seguramente ha notado ya que algunas de las funciones que estamos
usando, igual que las funciones matem�ticas, devuelven un resultado.
Otras funciones, como \texttt{nueva\_linea}, llevan a cabo una acci�n
pero no devuelven un valor. Ello suscita varias preguntas:
\begin{enumerate}
\item �Qu� sucede si llama usted a uana funci�n y no hace nada con el resultado
(es decir, no lo asigna a una variable ni lo usa como parte de una
expresi�n m�s amplia)?
\item �Qu� sucede si usa una funci�n sin resultado como parte de una expresi�n,
por ejemplo \texttt{nueva\_linea() + 7}?
\item �Se pueden escribir funciones que devuelvan resultados, o debemos limitarnos
a funcinoes simples como \texttt{nueva\_linea} e \texttt{imprimeDoble}?
\end{enumerate}
La respuesta a la tercera pregunta es {}``s�, puede escribir funciones
que devuelvan valores'', y lo haremos en el cap�tulo 5.
\begin{quote}
\emph{Como actividad final, consteste a las otras dos preguntas intentando
hacerlas en la pr�ctica. Cada vez que tenga una duda sobre lo que
es legal o ilegal en Python, perguntar al int�rprete ser� una buena
manera de averiguarlo.}
\end{quote}
\section{Glosario}
\begin{description}
\item [llamada~a~funci�n:] Una sentencia que ejecuta una funci�n. Est�
compuesta por el nombre de la funci�n m�s una lista de argumentos
encerrados entre par�ntesis.
\item [argumento:] Valor que se le pasa a una funci�n cuando se la llama.
El valor se asigna al par�metro correspondiente de la funci�n.
\item [valor~de~retorno:] Es el resultado de una funci�n. Si se usa una
llamada a funci�n a modo de expresi�n, el valor de retorno es el valor de
la expresi�n.
\item [conversi�n de tipo:] Una sentencia expl�cita que toma un valor de
un tipo y calcula el valor correspondiente de otro tipo.
\item [coerci�n:] Conversi�n tipos que ocurre autom�ticamente de acuerdo
con las reglas de coerci�n de Python.
\item [m�dulo:] Fichero que contiene una colecci�n de funciones y clases
relacionadas.
\item [notaci�n de punto:] La sintaxis para llamar a una funci�n de otro
m�dulo, especificando el nombre del m�dulo, seguido por un punto y el nombre
de la funci�n.
\item [funci�n:] Secuencia de sentencias etiquetadas que llevan a cabo determinada
operaci�n de utilidad. Las funciones pueden tomar par�metros o no,
y pueden producir un resultado o no.
\item [definici�n~de~funci�n:] Sentencia que crea una nueva funci�n, especificando
su nombre, par�metros y las sentencias que ejecuta.
\item [flujo~de~ejecuci�n:] Orden en el que se ejecutan las sentencias
durante la ejecuci�n de un programa.
\item [par�metro:]Nombre que se usa dentro de una funci�n para referirse
a el valor que se le pasa como argumento.
\item [variable~local:]variable definida dentro de una funci�n. Las variables
locales s�lo pueden usarse dentro de su funci�n.
\item [diagrama~de~pila:]Representaci�n gr�fica de una pila de funciones,
sus variables y los valores a los que se refieren.
\item [traza inversa:] (traceback en ingl�s) Una lista de las funciones en curso de
ejecuci�n, presentadas cuando sucede un error en tiempo de ejecuci�n.
\index{llamada a funci�n} \index{valor de retorno} \index{argumento}
\index{coerci�n} \index{conversi�n de tipo} \index{m�dulo} \index{funci�n}
\index {notaci�n de punto} \index{definici�n de funci�n}
\index{flujo de ejecuci�n} \index{par�metro} \index{variable local}
\index{diagrama de pila} \index {traza inversa} \end{description}
%\end{document}
" + str + "Close window
