Spyder (Scientific Python Development Environment), es un Entorno de Desarrollo Integrado, IDE

(Integrated Development Environment) diseñado para su uso con Python.

Consta de:
• un Editor para escribir el código
• una Consola IPython para evaluar y visualizar resultados
• un Explorador de variables para inspeccionar las variables definidas durante la sesión
• un Explorador de proyectos para visualizar la estructura de un proyecto de programación
• otra serie de Utilidades para facilitar el desarrollo, depuración y ejecución de los programas
Creación de un proyecto
Aunque podemos empezar a editar y ejecutar programas de una forma más rápida, especialmente para
programas con relativamente pocas líneas, es bueno desde los primeros pasos acostumbrarse a tener
organizado nuestro código y todo aquello que lo rodea.
Lo primero es crear en nuestro ordenador personal, en nuestra cuenta de la EII y, tal vez, en una memoria
USB, un directorio donde almacenaremos nuestros programas.
Por ejemplo, podemos tener una carpeta Fundamentos_de_Programacion de la que cuelgan otras
carpetas como Cuadernos, Trabajos, …, Practicas.
De nuestro directorio reservado a las prácticas pueden colgar directamente los directorios donde
residirán los diferentes programas que iremos realizando durante el curso.
Por ejemplo, si en la sesión de prácticas 3 se solicita realizar un programa que resuelva un problema
planteado en el ejercicio 6, una forma cómoda de identificar y acceder a toda la información relevante de
ese programa es crear un directorio llamado P3_6 o algo similar.
La forma natural que tienen muchos IDE’s de cualquier lenguaje para trabajar con un directorio asociado
a un programa es crear un proyecto.
En Spyder, basta con clicar en Proyectos --> Nuevo proyecto:

A continuación, elegiremos la ubicación donde se creará la nueva carpeta del proyecto:

…
y elegimos la carpeta donde se ubicará nuestro proyecto.

Tened por costumbre no dejar espacios en blanco ni usar caracteres raros en los identificadores de los
directorios y archivos. Usad _ para simular los espacios en blanco. En este ejemplo, llamaremos a nuestro
proyecto P0_1.

Podemos observar cómo se abre en la interfaz de Spyder una ventana llamada Explorador de proyectos,
donde podemos ver nuestro recién creado proyecto, que tiene asociado su propio directorio.
La interfaz gráfica muestra por defecto en el editor un guion temp.py, que puede ser útil para probar de
forma rápida fragmentos de código. Sin embargo, los nombres de nuestros guiones deben ser también
autoexplicativos, que describan sucintamente lo que hace el código o que resulte fácil relacionarles con el
programa al que pertenecen.
En un curso introductorio como éste, muchos de nuestros programas van a constar de un único guion. En
estos casos es habitual llamar al guion main.py. Sin embargo, sugerimos para su fácil identificación
llamarles de forma similar al proyecto.
En el ejemplo anterior, si el proyecto de la práctica 3.6 tiene un único guion una opción sería p3_6.py. Si
el programa constase de varios guiones, el programa principal podría llamarse main_p3_6.py.
Clicando con el botón derecho sobre el icono de la carpeta del proyecto en la ventana del explorador de
proyectos se muestra un menú desplegable con diferentes opciones.

Elegiremos añadir un nuevo archivo al proyecto:

Y le damos un nombre, ¡sin olvidar la extensión .py.

Tras estas operaciones, ya visualizamos el guion en el explorador y aparece abierto en la ventana de

edición.

A partir de este momento, el directorio del proyecto se convierte en nuestro directorio de trabajo. Eso
significa que las rutas (paths) relativas a otros archivos tendrán a éste como raíz.
Terminal IPython: comandos mágicos
El terminal IPython no sólo sirve para introducir código Python sino que dispone de una serie de
utilidades específicas que se ejecutan a través de una serie de comandos mágicos. Estos comandos
mágicos no forman parte de un terminal estándar de Python. Los comandos mágicos son precedidos por
el símbolo %.
Para comprobar el contenido de nuestro directorio de trabajo ejecute el siguiente comando mágico en la
terminal IPython:
In [1]: %ls

La salida debería ser similar a la siguiente:

El volumen de la unidad C es Acer
El n£mero de serie del volumen es: 085E-3B4E

Directorio de C:\Users\migtr\Fundamentos_de_Programacion\Practicas\P0_1

27/12/2019 11:48 <DIR> .

27/12/2019 11:48 <DIR> ..
27/12/2019 11:37 <DIR> .spyproject
27/12/2019 11:38 27 p0_1.py
1 archivos 27 bytes
3 dirs 827.599.896.576 bytes libres

Podemos observar que, además de nuestro primer guion, Spyder crea dentro del directorio del proyecto
otro directorio que no debemos borrar, llamado .spyproject: contiene diferentes archivos de
configuración de los que, en principio, no tenemos que ocuparnos.
Podéis comprobar que el resultado sería el mismo si hubiésemos ejecutado la orden sin el símbolo %:
In [1]: ls

Esto es debido a que, por defecto, cada vez que se reinicia el núcleo, se activa automáticamente el también
comando mágico %automagic. Para distinguir los comandos mágicos de las funciones nativas de Python
usaremos % y sugerimos en estos pasos iniciales de aprendizaje desactivar automagic:
In [2]: automagic 0

Automagic is OFF, % prefix IS needed for line magics.

Ejecución de un programa
Copia y pega el siguiente código (no te preocupes si ahora no lo entiendes) en el editor del guion p0_1.py:
def area_triangulo(base, altura):
"""
Calcula el área de un triángulo a partir de su base y altura.

Parameters
----------
base : float
Base del triángulo.
altura : float
Altura del triángulo.
Returns
-------
_ : float
El área del triángulo dado por la fórmula ``area = (base*altura)/2``

Example
-------
>>> area_triangulo(2, 5)
5

"""
return 0.5*base*altura

print('\nIntroduzca la base y altura de un triángulo para calcular su área.')

base = float(input("Base: "))
altura = float(input("Altura: "))
area = area_triangulo(base, altura)

print("El área del triángulo de base {} y altura {} es {}.".format(base, altura, area))

Este sencillo programa calcula el área de un triángulo. Para ello, solicita al usuario los valores de la base y
altura.
Para ejecutar el programa, clica en la barra de herramientas o pulsa el atajo de teclado F5.
En la terminal debería mostrase algo similar a lo siguiente:
In [1]: runfile('C:/Users/migtr/Fundamentos_de_Programacion/Practicas/P0_1/p0_1.py', wd
ir='C:/Users/migtr/Fundamentos_de_Programacion/Practicas/P0_1')

Introduzca la base y altura de un triángulo para calcular su área.

Base:

Nos informa de las rutas absolutas del guion que se está ejecutando (runfile) y del directorio de trabajo
(wdir). Si se eligen los valores 2 y 5 para los parámetros solicitados se mostrará lo siguiente:
Base: 2

Altura: 5
El área del triángulo de base 2.0 y altura 5.0 es 5.0.

In [2]:
Ejecución desde el terminal
Aunque ahora mismo puede no ser algo interesante, desde el terminal IPython podemos ejecutar nuestro
guion sin más que invocar:

In [2]: %run p0_1.py

Lo que sí es importante tener en cuenta es que, al ejecutar nuestro programa, el núcleo asociado al
terminal IPython mantiene un estado de las variables utilizadas. Así, podemos invocar a la función
area_triangulo() desde el terminal.

In [2]: area_triangulo(3, 4)
Out[2]: 6.0

Inspeccionando el espacio de nombres

Ejecutando el comando nativo (built-in) dir() podemos ver un listado de todos los nombres o
identificadores presentes en el estado actual del núcleo. Es lo que constituye su espacio de nombres
(namespace) en un momento dado. Entre ellos, encontramos los que hemos creado en nuestro programa:
'altura',
'area',
'area_triangulo',
'base',

Los espacios de nombres son muy importantes en cualquier lenguaje. Previenen que, dentro del mismo
contexto de ejecución de un programa por parte del núcleo, se produzcan colisiones debido a la utilización
simultánea del mismo nombre por parte de diferentes componentes.
Si en algún momento queremos borrar los nombres que hemos creado durante la sesión, podemos
reiniciar el espacio de nombres:
In [6]: %reset

Once deleted, variables cannot be recovered. Proceed (y/[n])? Y

Esta operación, al igual que otras muchas, puede llevarse a cabo navegando por los menús. En este caso, se
accede rápidamente pulsando el botón del terminal.
Inspeccionando un objeto
Con el comando nativo help() podemos invocar la ayuda disponible acerca de un objeto. Por ejemplo, si
ejecutamos help(print) obtenemos la siguiente información:
In [5]: help(print)
Help on built-in function print in module builtins:

print(...)
print(value, ..., sep=' ', end='\n', file=sys.stdout, flush=False)

Prints the values to a stream, or to sys.stdout by default.

Optional keyword arguments:
file: a file-like object (stream); defaults to the current sys.stdout.
sep: string inserted between values, default a space.
end: string appended after the last value, default a newline.
flush: whether to forcibly flush the stream.

Si hacemos lo propio con nuestro objeto area_triangulo obtendremos:

In [3]: help(area_triangulo)
Traceback (most recent call last):

File "<ipython-input-15-f2bc47704f3e>", line 1, in <module>

help(area_triangulo)

NameError: name 'area_triangulo' is not defined

Esto ocurrirá si hemos reiniciado el espacio de nombres: en este caso, el núcleo ya no tiene constancia de
este identificador.
Si volvemos a ejecutar nuestro guion entonces obtenemos:
In [3]: help(area_triangulo)
Help on function area_triangulo in module __main__:

area_triangulo(base, altura)
Calcula el área de un triángulo a partir de su base y altura.

Parameters
----------
base: float
Base del triángulo.
altura: float
Altura del triángulo.

Returns
-------
float
El área del triángulo dado por la fórmula ``area = (base*altura)/2``

Example
-------
>>> area_triangulo(2, 5)
5
Esta salida tan prolija se produce gracias a que hemos documentado la función area_triangulo(). La
cadena de documentación (docstring) es la primera cadena de caracteres, posiblemente multilínea,
inmediatamente debajo de la línea def area_triangulo(base, altura):. Está cadena multilínea aparece
delimitada por triples comillas, """.
Los docstrings utilizan lenguajes de marcado ligero y están pensados para la generación de
documentación de forma automática. El lenguaje utilizado aquí se llama reStructuredText (reST), con unos
estilos añadidos Numpydoc standard habituales en el mundillo de la computación científica. Con esta
herramienta podemos visualizar con una estética atractiva la documentación asociada a una variable en la
ventana de ayuda. Para ello, basta clicar en el editor sobre la variable deseada y pulsar Ctrl + I:

Este tipo de utilidades que ofrecen los IDE’s facilitan sobremanera el trabajo. Puedes probar esta utilidad
clicando en el editor sobre las funciones nativas print(), float() o input().

Actualización de los objetos

Vamos a provocar un error deliberado en nuestra función area_triangulo() eliminando el factor 0.5 en
el editor.
return base*altura

Salvad el cambio con Ctrl+S o clicando . ¡Pero no ejecutéis el guion!

A continuación, ejecutad la función area_triangulo() desde la línea de comandos con dos argumentos
cualesquiera:
In [3]: area_triangulo(10,20)
Out[3]: 100.0

Vemos que el resultado es el correcto, a pesar del cambio realizado. La razón es que el núcleo aún tiene
en memoria la versión antigua de nuestro objeto. ¡El cambio en el editor no afecta al estado del núcleo!
Para sobrescribir (override) el objeto necesitamos bien:
1. Reejecutar el guion, pulsando F5 por ejemplo.
2. Seleccionar el código afectado por el cambio (en nuestro caso las líneas comprendidas entre def ...
y return ... y pulsar F9 o .
La posibilidad de ejecutar fragmentos del código desde el editor es una herramienta de gran ayuda cuando
trabajamos con programas complejos. De esta forma, solo tenemos que reejecutar la parte que estemos
desarrollando o depurando, reutilizando los objetos previamente generados, que permanecen en el estado
del núcleo.
No olvides volver a reescribir la función de forma correcta, salvando el cambio. Durante el curso
aprenderemos a utilizar funciones para testar nuestros objetos. Así, fallos tan groseros como el que hemos
provocado intencionadamente no pasarán desapercibidos.
Explorador de variables y herramientas de depuración
La ventana del explorador de variables permite inspeccionar los tipos y valores de los objetos e incluso
editar sus valores. Para ello, basta clicar dos veces sobre la fila de la variable.

La depuración de programas (debugging) consiste en identificar y corregir errores de programación.

Spyder tiene herramientas para establecer puntos de parada (break points), que permiten ejecutar el
programa paso a paso. En estos puntos de parada, el explorador de variables nos permite comprobar si los
valores que tienen éstas son los esperados.

Autocompletado de código
Dependiendo de la versión de Spyder se dispone de herramientas de autocompletado de código más o
menos eficientes:
• Todas las versiones: Pulsando la tecla del tabulador, Tab, cuando estamos escribiendo una variable
nos muestra una lista con todas las variables que comienzan por los caracteres que hayamos escrito.
Esta funcionalidad la tenemos tanto en el editor como en el terminal.
• A partir de la versión 4: Mediante la integración del complemento (plugin) de Kite, una herramienta
de autocompletado de código Python, en cuanto hemos escrito 3 caracteres, se despliega
automáticamente la lista. Esta funcionalidad sólo está disponible en el editor.
Si es el caso, podremos seleccionar el ítem de la lista.
Guía de estilo
Python es un lenguaje que por su diseño obliga a ciertas reglas de estilo. El sangrado obligatorio es un
claro ejemplo. Sin embargo, cada programador puede desarrollar sus propios hábitos de escritura de
código. Esto, por regla general, es un problema, ya que cuando leemos código ajeno nos cuesta más
interpretar el código al no ajustarse a lo que estamos acostumbrados a hacer con nuestros programas. Por
esta razón, muchas organizaciones imponen a sus empleados seguir unas guías de estilo más o menos
estrictas.
En esta línea, Python en su propuesta de mejora (Python Enhancement Proposal), PEP 8, documenta
una guía de estilo.
Esta guía PEP 8 será de obligado cumplimiento durante la asignatura.
Una de las ventajas de usar un IDE es la gran cantidad de utilidades con las que viene provisto. En concreto,
Spyder nos ayuda a cumplir la guía PEP 8 de forma muy sencilla.
Para ello, debe habilitarse la casilla correspondiente seleccionando en el menú:
Herramientas --> Preferencias --> Completado y análisis de código --> Estilo del código

Para ver a Spyder ejecutando dinámicamente el análisis de estilo PEP 8 sobrescribe las siguientes líneas
sobre las antiguas en el guion p0_1.py.
print('\nIntroduzca la base y altura de un triángulo para calcular su área.')
base=float(input("Base: "))
altura=float(input("Altura: "))

area=area_triangulo(base,altura)

print("El area del triángulo de base {} y altura {} es {}.".format(base,altura,area))

Este código es perfectamente válido, como podéis comprobar pulsando F5. Sin embargo, el analizador de
código nos avisa con el icono delante de una línea cuando detecta que no se cumple la guía PEP 8.

Basta situarse con el puntero del ratón sobre el icono correspondiente para que aparezca un mensaje con
la causa del incumplimiento.

¡Prueba a eliminar los avisos! Hay líneas con varios incumplimientos.

Bibliografía
Este tutorial es una adaptación al castellano del tutorial disponible en Spyder. Este tutorial fue creado por
Hans Fangohr, de la Universidad de Southampton.
El tutorial original puede verse en el siguiente enlace.
Nótese que, a la fecha de este documento, algunas de las descripciones del tutorial, incluido el del propio
Spyder, están desactualizadas.