2. Puesta en Marcha

Autores:José María Herrera Fernández, Luis Miguel Sánchez Brea

Como en casi todos los programas, dependiendo del sistema operativo del que disponga nuestro ordenador la instalación de software variará ligeramente y Python no es una excepción. A fin de que el sistema operativo no suponga un bache en nuestro camino hacia el aprendizaje de Python, en esta sección veremos la instalación paso a paso en los dos sistemas operativos más extendidos en la actualidad. Para otros sistemas operativos recomendamos al lector que en caso de duda acuda a la gran bibliografía existente en la red.

2.1. Windows

A la hora de instalar Python en el sistema operativo de Microsoft tenemos dos opciones según el uso que vayamos a hacer del lenguaje de programación. Por una parte, como ya hemos mencionado en la introducción, Python es un leguanje de programación de uso general por lo que, si éste es el caso, recomendamos la instalación del paquete básico e incorporar los módulos que necesitemos. En el sitio oficial de Phython en la sección de descargas podemos encontrar diferentes versiones. En la actualidad conviven las versiones 3.3.* y 2.7.* donde * es la última versión estable. Las instalaciones de este libro fueron realizadas con la versión 2.7.2 aunque no varía sustancialmente para versiones posteriores. Por otra parte, como la programación que vamos a realizar está orientada al ámbito científico-académico e ingenieril, la opción que más se ajusta a nuestros intereses es el paquete Python(x,y). Python(x,y) es un software de desarrollo gratuito que incorpora los principales módulos necesarios para cálculo numérico junto con algún otro complemento que analizaremos posteriormente. La instalación es similar a otros programas de Windows. Lo primero que debemos de hacer es descargarmos la última versión del programa desde la sección de descargas de la web oficial, http://code.google.com/p/pythonxy/wiki/Downloads?tm=2.

En la Figura 2 podemos ver que en el mismo enlace disponemos de las notas de instalación que recomendamos repasar antes de iniciar el proceso. Son unos 420 MB (ya que tiene bastantes aplicaciones). Una vez instalado observaremos como nuestros archivos con extensión .py se asocian con python por lo que si pinchamos dos veces sobre ellos se ejecutarán.

../_images/descargaPythonXy.jpg

Figura 2. Descarga de Python(x,y) desde la sección correspondiente en la web oficial. En las misma página podemos encontrar las notas de instalación que debemos de tener en cuenta.

2.2. Linux

Python viene incorporado en la mayoría de las distribuciones existentes. Si en una terminal ejecutamos el comando

python - V

comprobaremos que versión de Python tenemos instalada. En caso de no ser así podemos instalarlo ejecutando

apt-get install python

Otra opción es, por ejemplo, desde el centro de software en Ubuntu. Basta con buscar python en el lugar correspondiente y nos indicará si lo tenemos instalado y si queremos instalarlo o desistalarlo. Para instalar nuevos módulos se puede seguir el mismo procedimiento ya sea desde la terminal o desde el centro de software.

2.2.1. Trabajar con Python

A la hora de iniciarse en la programación es muy importante conocer la sintasis del lenguaje que se va a utilizar para desarrollar codigo de una manera correcta. De igual importancia es conocer las herramientas de las que disponemos para ejecutar y depurar el código desarrollado.

2.3. Consolas

Desde el mismo momento en el que Python se instala en el sistema podemos empezar a programar abriendo una consola interactiva en una terminal. La consola interactiva más sencilla se ejecuta directamente en un terminal (Linux) escribiendo

python

Inmediantamente podremos ir introduciendo lineas de comandos y ejecutar de una en una. En Windows la forma es equivalente.

Existen concolas interactivas más completas que nos van indicando ayudas inmediatas a medida que vamos escribiendo código. Se introduce la instruccion y se ejecuta de una en una. Esta forma de programación es adecuada cuando somos principiantes y estamos desarrollando programas cortos donde nos interesa ver inmediatamente si el resultado es correcto o no.

2.4. IDEs

Las consolas no es el mejor procedimiento para desarrollar programas extensos. El código escrito en la consola no es fácil de seguir y de volver a utilizar. Una programación eficaz se realiza mediante un Entorno de Desarrollo Integrado (IDE, Integrated Developed Environment). Con este acrónimo inglés se describe a toda aplicación de sofware que proporciona una facilidad comprensiva a la hora de la creación de programas informáticos sea en el lenguaje que sea. Normalmente un IDE consta de un editor de código fuente, un compliador y/o un intérprete, herramientas de creación y un depurador. También suelen tener consolas interactivas. En esta sección nos centraremos en tres IDEs en particular: IDLE, Spyder y Eclipse.

  • IDLE: es el IDE de Python basado en el entorno de ventantas thinter y desarrollado 100% también en Python. Es el más simple de los tres que veremos pero para principiantes quizás sea el más adecuado. Posee modo depuración aunque para programadores experimentados se queda bastante corto. La instalación en Windows se realiza con la instalación del propio lenguaje mientras que en el resto de SO la instalación se realiza de la forma usual. Para más información podemos consultar la documentación oficial en el siguiente enlace: http://docs.python.org/2/library/idle.html. En la Figura 3 se muestra un ejemplo de creación de un array en la consola de IDLE.
../_images/consolaIDLE.png

Figura 3. Consola de IDLE.

  • Spyder: Spyder es un IDE específico para Python orientado a científicos y desarrollo ingenieril con una interfaz muy similar a Matlab, por lo que es la opción más adecuada cuando se quiere migrar de Matlab a Python. Si hemos instalado Python(x,y), al iniciar el programa se nos abre una ventana con diversas caracterísitcas. Dentro de la pestaña “Shortcuts” nos encontramos el apartado “Spyder”. Bastará con pinchar en el símbolo del programa (Figura 4) e inmediatamente se nos abrira el programa. Como siempre, si nos encontramos en linux abrimos una terminal y ejecutamos la orden
sudo apt-get install spyder

y tras unos segundos nos aparecerá como opción en nuestro menu.

../_images/spyder0.jpg

Figura 4. Spyder en Python(X,Y). Para iniciar el programa pinchamos en el símbolo resaltado en la imagen.

Al iniciar el programa por primera vez vemos que, si hemos sido usuarios de MATLAB, efectivamente nos encontramos en un entorno familiar. En la Figura 5 vemos que en la zona izquierda de la pantalla tenemos un editor de código. En la zona central nos encontramos un navegador con nuestros programas y en la zona derecha tenemos la ayuda y la consola interactiva.

../_images/spyder.png

Figura 5. Spyder con sus diferentes secciones.

Para más información podemos consultar el manual oficial del IDE en http://packages.python.org/spyder/

  • Eclipse: Eclipse es un programa informático compuesto por un conjunto de herramientas de programación de código abierto multiplataforma para desarrollar lo que el proyecto llama “Aplicaciones de Cliente Enriquecido”, opuesto a las aplicaciones “Cliente-liviano” basadas en navegadores. Esta plataforma, típicamente ha sido usada para desarrollar IDEs, como el IDE de Java llamado Java Development Toolkit (JDT). Eclipse puede ser usado con Python mediante la instalación de Pydev. Pydev es un IDE para Eclipse muy completo y configurable con un modo de depuración extraordinariamente potente. De los tres IDEs que hemos visto, éste es el entorno más complicado por la cantidad de opciones que contiene. Sin embargo para el programador avanzado será el que más comodo le resulte a la hora de realizar sus programas.

Si nos encontramos en el sistema operativo de Microsoft, lo primero que debemos hacer es decargarnos la ultima versión del programa en el sitio oficial, http://www.eclipse.org/downloads/. En linux,

sudo apt-get install eclipse

Tanto en linux como en Windows si no los tenemos debemos instalar la ultima versión de Java Development Kit (JDK) y el Java Runtime Environment (JRE). Para configurar PyDev en Eclipse debemos de seguir los siguientes pasos:

  1. Abrimos Eclipse y nos vamos a Help -> Install New Software. En la pantalla emergente añadimos “http://pydev.org/updates” en el campo work with.
../_images/eclipse1.jpg

Figura 6. Instalacion de Pydev en Eclipse.

  1. Pulsamos en Add, esperamos a que actualize el campo de abajo para poder seleccionar PyDev, luego pulsamos en Next, y seguimos el asistente para completar la instalación.
../_images/eclipse2.jpg

Figura 7. Instalacion de Pydev en Eclipse.

  1. Reiniciamos Eclipse.
  2. Ahora deberemos especificar dónde se encuentra el interprete de python en las preferencias Eclipse, para ello nos vamos a Eclipse -> preferences -> PyDev -> Interpreter -> Python. Pulsamos en auto Config, marcamos todo (sino lo está) y aceptamos.
../_images/pydev_conf.png

Figura 8. Instalación de Pydev en Eclipse.

En este caso también tenemos a nuestra disposición un manual oficial muy completo en http://pydev.org/manual_101_root.html. Si hemos realizado todos los pasos correctamente podremos ejecutar programas realizados en python sin ningún problema. En la Figura [figEclipse] podemos ver un ejemplo de la disposición de las secciones en Eclipse. Estas seccciones son totalmente configurables por lo que dependiendo de vuestras preferencias la imagen puede o no coincidir con vuestra disposición.

../_images/pydev_final.png

Figura 9. Eclipse con Pydev configurado.

2.5. Pythonpath

Dependiendo el IDE elegido se nos habrá creado una carpeta como directorio de trabajo. Sin embargo en ocasiones puede interesarnos trabajar con archivos fuera de este directorio. Para ello debemos de añadir la nueva ruta de nuestros archivos. Esta operación se realiza en Pythonpath.

Spyder:

  • Tools –> PYTHONPATH manager.
  • Se busca el directorio donde tenemos los programas.

Eclipse:

  • Project –> Properties –>Pydev - PYTHONPATH.
  • Se busca el directorio donde tenemos los programas.
../_images/pydevpythonpath.png

Figura 10. Carga de los directorios en el Pythonpath, para eclipse.

2.6. Ayudas

Las comandos de los lenguajes de programación son prácticamente infinitos y, sólo mediante práctica, conseguiremos aprendernos algunos de ellos. Sin embargo, en la mayoría de los casos debereos acudir a la documentación oficial para resolver nuestras dudas. Normalmente cada lenguaje de programación tiene algún comando específico para acceder a la información que nos interese. Además muchos de los IDE facilitan el acceso a esta información mediante algún acceso directo o alguna ventana permanente. En general los pasos a seguir cuando no sabemos qué comando utilizar o la sintaxis de su utilización son los siguientes.

  • Google. El buscador de información en internet por excelencia. En algunas ocasiones no sabremos muy bien por donde empezar o nos sabremos el comando equivalente en otro lenguaje de programación. Si el lector ha tenido esa duda seguramente otra persona la haya tenido antes por lo que podremos encontrar la respuesta sin demasiado esfuerzo.
  • Mediante el uso de comandos especificos. Como hemos mencionado, cada lenguaje de programación tiene una serie de comandos para accecer a la información de los comandos acerca de los cuales tengamos dudas. Por ejemplo si en una consola tecleamos
import numpy as np

help(np.linspace)

obtendremos la información de linspace en la misma consola,

Help on function linspace in module numpy.core.function_base:

linspace(start, stop, num=50, endpoint=True, retstep=False)
Return evenly spaced numbers over a specified interval.

Returns `num` evenly spaced samples, calculated over the
interval [`start`, `stop` ].

The endpoint of the interval can optionally be excluded.

Parameters
----------
start : scalar
     The starting value of the sequence.
stop : scalar
     The end value of the sequence, unless `endpoint` is set to False.
     In that case, the sequence consists of all but the last of ``num + 1``
     evenly spaced samples, so that `stop` is excluded.  Note that the step
     size changes when `endpoint` is False.
num : int, optional
     Number of samples to generate. Default is 50.
endpoint : bool, optional
     If True, `stop` is the last sample. Otherwise, it is not included.
     Default is True.
retstep : bool, optional
     If True, return (`samples`, `step`), where `step` is the spacing
     between samples.

Returns
-------
 samples : ndarray
     There are `num` equally spaced samples in the closed interval
     ``[start, stop]`` or the half-open interval ``[start, stop)``
     (depending on whether `endpoint` is True or False).
 step : float (only if `retstep` is True)
     Size of spacing between samples.


 See Also
 --------
 arange : Similiar to `linspace`, but uses a step size (instead of the
          number of samples).
 logspace : Samples uniformly distributed in log space.

 Examples
 --------
 >>> np.linspace(2.0, 3.0, num=5)
     array([ 2.  ,  2.25,  2.5 ,  2.75,  3.  ])
 >>> np.linspace(2.0, 3.0, num=5, endpoint=False)
     array([ 2. ,  2.2,  2.4,  2.6,  2.8])
 >>> np.linspace(2.0, 3.0, num=5, retstep=True)
     (array([ 2.  ,  2.25,  2.5 ,  2.75,  3.  ]), 0.25)

 Graphical illustration:

 >>> import matplotlib.pyplot as plt
 >>> N = 8
 >>> y = np.zeros(N)
 >>> x1 = np.linspace(0, 10, N, endpoint=True)
 >>> x2 = np.linspace(0, 10, N, endpoint=False)
 >>> plt.plot(x1, y, 'o')
 [<matplotlib.lines.Line2D object at 0x...>]
 >>> plt.plot(x2, y + 0.5, 'o')
 [<matplotlib.lines.Line2D object at 0x...>]
 >>> plt.ylim([-0.5, 1])
 (-0.5, 1)
 >>> plt.show()
  • En el caso concreto del IDE Spyder tenemos el Object inspector. Si escribimos en la caja object la palabra que deseamos probablemente aparezca la ayuda de forma automática. Por ejemplo, si quiero ordenar una lista y no se cómo, podemos escribir “sort” y aparecerá la forma de utilización. Además tanto en spyder como en Eclipse, al escribir el comando nos aparece la ayuda de forma automática como podemos ver en la Figura 11
../_images/spyder_ayuda.png

Figura 10. Ayuda automática u Object inspector en Spyder.

2.6.1. Mi primer programa

Por tradición se suele decir que un lenguaje de programación es más o menos complicado cuanto más nos cuesta implementar el Hola Mundo, es decir, imprimir en pantalla estas dos palabras. Python teniendo en cuenta este criterio es de los lenguajes más fáciles ya que con una sola línea de código podemos obtener el resultado deseado

>>> print("Hola Mundo")
Hola Mundo

si comparamos con C++,

#include <iostream>

using namespace std;

int main() {

     cout << "Hola Mundo" << endl;

     return 0;

}

vemos que el código es notablemente más largo. Por curiosidad y a modo de avance para el tema siguiente podemos ver como se representa una gráfica simple como la del seno en Python,

#!/usr/bin/env python
# -*- coding: utf-8 -*-

# Carga de los módulos necesarios
import scipy as sp
import matplotlib.pyplot as plt

# Creamos el array x de cero a cien con cien puntos
x = sp.linspace(0, 10, 100)

# Creamos el array y conde cada punto es el seno de cada elemento de x
y = sp.sin(x)

# Creamos una figura
plt.figure()

# Representamos
plt.plot(x,y)

# Mostramos en pantalla
plt.show()

(Source code, png, hires.png, pdf)

../_images/mi_primera_grafica1.png

2.6.2. Estructura de un programa .py

En la sección anterior hemos podido comprobar lo sencillo y legible que es un programa Python. No obstante, con el fin de que el código sea lo más comprensible posible para cualquiera que se disponga a utilizarlo o modificarlo se suelen añadir por convenio una serie de apartados y líneas de códico complementarias que facilitan su comprensión. Así, como normal general todos nuestros programas de Python deben tener los siguientes apartados

2.7. Autoejecución

#!/usr/bin/env python
# -*- coding: utf-8 -*-
from __future__ import division
  • La primera línea de código sirve para decir al sistema operativo que este archivo se puede ejecutar, es decir, si se hace click sobre el archivo, se llama al programa python y se ejecuta. Es el equivalente a los archivos ejecutables .exe en Windows, aunque aquí el programa no está compilado, sino que se interpreta (esto último es más lento).
  • La segunda línea de código sirve para poder utilizar la codificacion utf-8. De esta forma podemos poner acentos, ñ, etc.
  • La tercera línea de código carga un módulo adicional que permite que la división entre números enteros pueda dar números fraccionarios. Al ser Python un lenguaje de propósito general la división entre enteros da lugar a enteros, lo cual suele ser problematico en cálculos científicos. NOTA: También se puede solucionar escribiendo, en lugar de 3/4, 3./4, pero de esta forma el riesgo de cometer errores por esta causa es menor.

2.8. Cabecera

# Nombre:       ejemplo_estructura_programa.py
# Propósito:    Ejemplo de archivo con la estructura de un programa
#
# Origen:        Propio
# Autor:         José María Herrera-Fernandez y Luis Miguel Sanchez Brea
#
# Creación:      12 de Septiembre de 2013
# Historia:
#
# Dependencias:  scipy, matplotlib
# Licencia:      GPL

Esta sección es estrictamente voluntaria, sin embargo es muy útil cuando varios usuarios programan en el mismo archivo.

  • Nombre –> El nombre del archivo que vamos a crear cuando guardemos por primera vez. En nuestro caso ejemplo_estructura_programa.py.
  • Propósito –> La finalizad que se persigue al crear el programa, * Crear gráfica del seno*, * Calcular los coeficientes de un polinomio*, etc.
  • Origen –> Si el origen del programa no es propio conviene saber su procedencia por si se debe consultar de nuevo la fuente original en un futuro.
  • Autor(es) –> Los nombres de los creadores del programa.
  • Creación –> Fecha de creación del programa.
  • Historia –> En caso de modificaciónes posteriores es en esta seción donde se indica la modificación, la fecha de la realización y el autor de la misma.
  • Dependencias –> Módulos necesarios para la ejecución del programa. Por ejemplo scipy, matplotlib..
  • Licencia –> Apartado correspondiente a los derechos de autor.

Como se observa, para incluir un comentario se utiliza el caracter #

2.9. Generación de ayudas

En el apartado de Ayudas (2.2.4) aprendimos a utilizar el comando help para obtener información sobre el uso de un determinado comando. El resultado es una información muy valiosa que nosotros debemos de añadir también a nuestras funciones, programas etc. Es lo que se denomina Docstring. Las ayudas se deben de incluir inmediatamente despúes de la cabecera en el caso de ser una descripción general e inmediantamente después de cualquier función, clase, etc. La metodología es simple, todo aquella información que creamos necesaria para el Docstring debe de ir encerrada entre seis pares de comillas dobles (tres al inicio y tres al final). Además para funciones deberemos de incluir los siguientes apartados:

  • (Entradas) –> (salidas). Se enumeran el tipo de entrados que necesita como entradas la función y el tipo de salidas que nos devolverá, int, bool, float, etc
  • Descripción. Ecplicación de la función.
  • Explicación de cada entrada.
  • Explicación de cada salida.
  • Test. Ejemplo sencillo con el resultado que pueda servir como comprobador del buen uso de la función creada.

Ejemplo de ayuda para un archivo general,

"""
Descripción: Archivo plantilla para generar programas en Python.

"""

Aunque todavía no hemos visto las funciones podemos ver un ejemplo de ayuda en una función que nos devuelve el seno del número que entremos,

def f1(x = 3.3):
	"""
	* (float) --> (float)
	* Descripción: Función que devuelve el seno de un entero dado.
	* Entradas:
	- x = entero.
	* Salidas:
	- y = seno(entero)
	* Test:
	>>> print("f1(0.7)")
	0.64421768723769102
  	"""
	y = sp.sin(x)
	return y

2.10. Carga de Módulos

En Python no es necesario declarar las variables, lo cual supone una gran simplificación respecto a programas como C. Sin embargo para llamar a funciones y clases que no están en el archivo que se está ejecutando, es necesario decirle dónde están. Se pueden declarar un módulo, o llamar a sus funciones de diversas formas. En los siguientes ejemplos cargamos algunas o todas las funciones del módulo científico scipy.

import scipy        
import scipy as sp
from scipy import *
from scipy import sin
from scipy.fftpack import fft
import matplotlib.pyplot as plt

Veamos como llamaríamos a la funcion sin dependiendo la forma en la que hayamos cargado scipy

  • import scipy –> “y = scipy.sin(x)”, Importamos scipy y llamamos a las funciones que tiene.
  • import scipy as sp –> “y = sp.sin(x)”, Renombramos scipy con un alias más corto.
  • from scipy import * –> “y = sin(x)”, importamos todas las funciones que contiene scipy
  • from scipy import sin, cos –> “y = sin(x)”, importamos únicamente sin y cos
  • from scipy.fftpack import fft –> Si los módulos son muy largos, se pueden hacer en varios archivos. Entonces las funciones o clases están anidadas.

Esto es de gran utilidad por varios motivos:

  • Permite no estar pendiente del nombre de las funciones, clases, etc. Si el nombre se repite en dos módulos, no hay problema, pues sabemos a qué módulo pertenece
  • Permite escribir código de forma modular. Para utilizar en módulo desarrollado por otro programado, por ejemplo optica.py, lo único que hay que hacer es llamarlo antes, “import optica”

2.11. Definición de funciones

Seguidamente a las declaraciones de los módulos se pueden escribir las funciones y clases que vayamos a utilizar. Esto no significa que el programa vaya a realizar ninguna acción. En el siguiente tema se verá cómo hay que desarrollar el código para crear estas funciones y clases.

Una ventaja de Python es que en un mismo programa (o módulo, según definamos) podemos escribir muchas funciones y clases a la vez, por lo que se simplifica la revisión de código y su mantenimiento. Asimismo, incluir varias funciones en un mismo archivo permite poder pasar nuestro código a otros programadores de una forma sencilla.

def f1(x = 3.3):
	"""
	* (float) --> (float)
	* Descripción: Función que devuelve el seno de un entero dado.
	* Entradas:
	- x = entero.
	* Salidas:
	- y = seno(entero)
	* Test:
	>>> print("f1(0.7)")
	0.64421768723769102
  	"""
	y = sp.sin(x)
	return y


def f2(x=3):
	"""
	* (float) --> (float)
	* Descripción: Función que devuelve el seno de un entero dado.
	* Entradas:
	- x = entero.
	* Salidas:
	- y = cos(entero)
	* Test:
	>> print("f2(0.7)")
	0.7648421872844885
  	"""
	y = sp.cos(x)
	return y	

Python no utiliza paréntesis o llaves para decir qué código pertenece a una función. Es de esencial importancia en Python seguir un sistema de indentación. Es decir, el código que está dentro de una función tiene que estár indentado dentro de la función como en el ejemplo anterior para que pertenezca a la función. Para salirnos de la función, simplemente “des-indentamos” el código.

2.12. Código ejecutable: main

A una función de Python se la puede llamar de dos formas: a través de otra función python o directamente. El comportamiento de la función puede ser distinto por lo que se debe de tener cuidado. Si, por ejemplo, tenemos el siguiente codigo al final del archivo:

if __name__ == '__main__':

	# Creamos el array x
	x = sp.linspace(0,10,100)

	# Calculamos el seno y el coseno mediante las funciones creadas.
	y1 = f1(x)
	y2 = f2(x)
	
	# Dibujamos las dos funciones en una única figura.	
	plt.figure()
	plt.plot(x,y1,'k', label='seno')
	plt.hold(True)
	plt.plot(x,y2,'r', label='coseno')
	plt.show()

Llegados a este punto podemos ver nuestra programa completo que no servirá de plantilla para el resto de programas que creemos,

#!/usr/bin/env python
# -*- coding: utf-8 -*-
from __future__ import division

#----------------------------------------------------------------------
# Nombre:       ejemplo_estructura_programa.py
# Propósito:    Ejemplo de archivo con la estructura de un programa
#
# Origen:        Propio
# Autor:         José María Herrera-Fernandez y Luis Miguel Sanchez Brea
#
# Creación:      12 de Septiembre de 2013
# Historia:
#
# Dependencias:  scipy, matplotlib
# Licencia:      GPL
#----------------------------------------------------------------------


"""
Descripción: Archivo plantilla para generar programas en Python.

"""

import scipy        
import scipy as sp
from scipy import *
from scipy import sin
from scipy.fftpack import fft
import matplotlib.pyplot as plt



def f1(x = 3.3):
	"""
	* (float) --> (float)
	* Descripción: Función que devuelve el seno de un entero dado.
	* Entradas:
	- x = entero.
	* Salidas:
	- y = seno(entero)
	* Test:
	>>> print("f1(0.7)")
	0.64421768723769102
  	"""
	y = sp.sin(x)
	return y


def f2(x=3):
	"""
	* (float) --> (float)
	* Descripción: Función que devuelve el seno de un entero dado.
	* Entradas:
	- x = entero.
	* Salidas:
	- y = cos(entero)
	* Test:
	>> print("f2(0.7)")
	0.7648421872844885
  	"""
	y = sp.cos(x)
	return y	


if __name__ == '__main__':

	# Creamos el array x
	x = sp.linspace(0,10,100)

	# Calculamos el seno y el coseno mediante las funciones creadas.
	y1 = f1(x)
	y2 = f2(x)
	
	# Dibujamos las dos funciones en una única figura.	
	plt.figure()
	plt.plot(x,y1,'k', label='seno')
	plt.hold(True)
	plt.plot(x,y2,'r', label='coseno')
	plt.show()

Ejecutando,

(Source code, png, hires.png, pdf)

../_images/ejemplo_estructura_programa.png

2.13. Sistema de verificación del código

En el apartado de generación de ayudas vimos que era conveniente añadir un apartado de verificación de la la función que llamamos Test. Sin embargo, en ocasiones las funciones son demasiado grades para añadir este apartado. En estas ocasiones la solución es simple, nos creamos otra función que invoque a la primera proporcionando datos conocidos. De esta forma continuaremos probando el buen funcionamiento de nuestra función sin el inconveniente del espacio.