INDICE

Capítulo 1: Introducción ................................................................................................................. 2

1. Hablando con la máquina ................................................................................................ 2

2. Algo de historia ................................................................................................................... 6

3. Python................................................................................................................................... 11

Capítulo 2: Entorno de desarrollo .............................................................................................. 18

1. Thonny .................................................................................................................................. 18

2. Contexto real...................................................................................................................... 24

Capítulo 3: Tipos de datos .......................................................................................................... 30

1. Datos .................................................................................................................................... 30

2. Números ............................................................................................................................. 39

3. Cadenas de texto .............................................................................................................. 47

Capítulo 4: Control de flujo ........................................................................................................ 59

1. Condicionales..................................................................................................................... 59

2. Bucles ................................................................................................................................... 66

Capítulo 5: Estructuras de datos ................................................................................................ 74

1. Listas ..................................................................................................................................... 74

2. Tuplas.................................................................................................................................... 91

3. Diccionarios ........................................................................................................................ 95

4. Conjuntos .......................................................................................................................... 107

5. Ficheros .............................................................................................................................. 112

Capítulo 6: Modularidad ............................................................................................................. 118

1. Funciones ........................................................................................................................... 118

2. Módulos ............................................................................................................................ 128

1
Capítulo 1: Introducción
Este capítulo es una introducción a la programación para conocer, desde un enfoque
sencillo pero aclaratorio, los mecanismos que hay detrás de ello.

1. Hablando con la máquina

Foto original por Garett Mizunaka en Unsplash

Los ordenadores son dispositivos complejos, pero están diseñados para hacer una cosa
bien: ejecutar aquello que se les indica. La cuestión es cómo indicar a un ordenador lo
que queremos que ejecute. Esas indicaciones se llaman técnicamente instrucciones y
se expresan en un lenguaje. Podríamos decir que programar consiste en escribir
instrucciones para que sean ejecutadas por un ordenador. El lenguaje que utilizamos
para ello se denomina lenguaje de programación.

1.1 Código máquina

Pero aún seguimos con el problema de cómo hacer que un ordenador (o máquina)
entienda el lenguaje de programación. A priori podríamos decir que un ordenador
sólo entiende un lenguaje muy «simple» denominado código máquina. En este
lenguaje se utilizan únicamente los símbolos 0 y 1 en representación de los niveles de
tensión alto y bajo que, al fin y al cabo, son los estados que puede manejar un circuito
digital. Hablamos de sistema binario. Si tuviéramos que escribir programas de
ordenador en este formato sería una tarea ardua, pero afortunadamente se han ido

2
creando con el tiempo lenguajes de programación intermedios que, posteriormente,
son convertidos a código máquina.

Si intentamos visualizar un programa en código máquina, únicamente obtendríamos

una secuencia de ceros y unos:

00001000 00000010 01111011 10101100 10010111 11011001 01000000 01100010

00110100 00010111 01101111 10111001 01010110 00110001 00101010 00011111
10000011 11001101 11110101 01001110 01010010 10100001 01101010 00001111
11101010 00100111 11000100 01110101 11011011 00010110 10011111 01010110

1.2 Ensamblador
El primer lenguaje de programación que encontramos en esta «escalada» es
ensamblador. Veamos un ejemplo de código en ensamblador del típico programa que
se escribe por primera vez, el «Hello, World»:

Aunque resulte difícil de creer, lo «único» que hace este programa es mostrar en la
pantalla de nuestro ordenador la frase «Hello, World», pero además teniendo en
cuenta que sólo funcionará para una arquitectura x86.

1.3 C
Aunque el lenguaje ensamblador nos facilita un poco la tarea de desarrollar
programas, sigue siendo bastante complicado ya que las instrucciones son muy
específicas y no proporcionan una semántica entendible. Uno de los lenguajes que
vino a suplir – en parte – estos obstáculos, fue C. Considerado para muchas personas
como un referente en cuanto a los lenguajes de programación, permite hacer uso de
instrucciones más claras y potentes. El mismo ejemplo anterior del programa «Hello,
World» se escribiría así en lenguaje C:

3
 1.4 Python
Si seguimos «subiendo» en esta lista de lenguajes de programación, podemos llegar
hasta Python. Se dice que es un lenguaje de más alto nivel en el sentido de que sus
instrucciones son más entendibles por un humano. Veamos cómo se escribiría el
programa «Hello, World» en el lenguaje de programación Python:

¡Pues así de fácil! Hemos pasado de código máquina (ceros y unos) a código Python
en el que se puede entender perfectamente lo que estamos indicando al ordenador.
La pregunta que surge es:

¿cómo entiende una máquina lo que tiene que hacer si le pasamos un programa hecho
en Python (o cualquier otro lenguaje de alto nivel)? La respuesta es un compilador.

1.5 Compiladores
Los compiladores son programas que convierten un lenguaje «cualquiera» en código
máquina. Se pueden ver como traductores, permitiendo a la máquina interpretar lo
que queremos hacer.

4
Figura 1: Esquema de funcionamiento de un compilador. Iconos originales por Flaticon

Nota: Para ser más exactos, en Python hablamos de un intérprete en vez de un

compilador, pero a los efectos es prácticamente lo mismo. La diferencia está en que el
intérprete realiza la «compilación» (interpretación) y la «ejecución» de una vez,
mientras que el compilador genera un formato «ejecutable» (código objeto) que se
ejecuta en otra fase posterior.

5
 2. Algo de historia

Foto original por Dario Veronesi en Unsplash

La historia de la programación está relacionada directamente con la aparición de los

computadores, que ya desde el siglo XV tuvo sus inicios con la construcción de una
máquina que realizaba operaciones básicas y raíces cuadradas (Gottfried Wilheml von
Leibniz); aunque en realidad la primera gran influencia hacia la creación de los
computadores fue la máquina diferencial para el cálculo de polinomios, proyecto no
concluido de Charles Babbage (1793-1871) con el apoyo de Lady Ada Countess of
Lovelace (1815-1852), primera persona que incursionó en la programación y de quien
proviene el nombre del lenguaje de programación ADA creado por el DoD
(Departamento de defensa de Estados Unidos) en la década de 1970.1

2.1 Hitos de la computación

La siguiente tabla es un resumen de los principales hitos en la historia de la
computación:

6
Tabla 1: Hitos en la computación

Personaje Aporte Año

Gottfried Leibniz Máquinas de operaciones básicas XV
Charles Babbage Máquina diferencial para el cálculo de polinomios XVII
Matemática, informática y escritora británica. Primera
Ada Lovelace programadora de la historia por el desarrollo de XVII
algoritmos para la máquina analítica de Babbage
Creador de un sistema para automatizar la pesada
Herman Hollerit 1890
tarea del censo
Máquina de Turing - una máquina capaz de resolver
Alan Turing problemas - Aportes de Lógica Matemática - 1943
Computadora con tubos de vacío
Contribuyó al algebra binaria y a los sistemas de
George Boole 1854
circuitos de computadora (álgebra booleana)
Primera computadora digital electrónica patentada:
John Atanasoff 1942
Atanasoff Berry Computer (ABC)
En colaboración con IBM desarrolló el Mark I, una
computadora electromecánica de 16 metros de largo
Howard Aiken y más de dos de alto que podía realizar las cuatro 1944
operaciones básicas y trabajar con información
almacenada en forma de tablas
Grace Hopper Primera programadora que utilizó el Mark I 1945
Junto a John Presper Eckert desarrolló una
computadora electrónica completamente
John W. Mauchly 1946
operacional a gran escala llamada Electronic
Numerical Integrator And Computer (ENIAC)
Propuso guardar en memoria no solo la información,
John Von Neumann 1946
sino también los programas, acelerando los procesos

Luego los avances en las ciencias informáticas han sido muy acelerados, se
reemplazaron los tubos de vacío por transistores en 1958 y en el mismo año, se
sustituyeron por circuitos integrados, y en 1961 se miniaturizaron en chips de silicio. En
1971 apareció el primer microprocesador de Intel; y en 1973 el primer sistema operativo
CP/M. El primer computador personal es comercializado por IBM en el año 1980.

7
 2.2 De los computadores a la programación
De acuerdo con este breve viaje por la historia, la programación está vinculada a la
aparición de los computadores, y los lenguajes tuvieron también su evolución.
Inicialmente, como ya hemos visto, se programaba en código binario, es decir en
cadenas de 0s y 1s, que es el lenguaje que entiende directamente el computador, tarea
extremadamente difícil; luego se creó el lenguaje ensamblador, que, aunque era lo
mismo que programar en binario, al estar en letras era más fácil de recordar.
Posteriormente aparecieron lenguajes de alto nivel, que en general, utilizan palabras
en inglés, para dar las órdenes a seguir, para lo cual utilizan un proceso intermedio
entre el lenguaje máquina y el nuevo código llamado código fuente, este proceso
puede ser un compilador o un intérprete.

Figura 2: Ada Lovelace: primera programadora de la historia. Fuente: Meatze

Un compilador lee todas las instrucciones y genera un resultado; un intérprete ejecuta

y genera resultados línea a línea. En cualquier caso, han aparecido nuevos lenguajes
de programación, unos denominados estructurados y en la actualidad en cambio los
lenguajes orientados a objetos y los lenguajes orientados a eventos. 1

1
Fuente: Universidad Técnica del Norte

8
 2.3 Cronología de lenguajes de programación
Desde la década de los 1950 se han sucedido multitud de lenguajes de programación
que cada vez incorporan más funcionalidades destinadas a cubrir las necesidades del
desarrollo de aplicaciones. A continuación, se muestra una tabla con la historia de los
lenguajes de programación más destacados:

Figura 3: Cronología de los lenguajes de programación más destacados

El número actual de lenguajes de programación depende de lo que se considere un

lenguaje de programación y a quién se pregunte. Según TIOBE más de 250; según
Wikipedia más de 700, según Language List más de 2500; y para una cifra muy alta
podemos considerar a Online Historical Encyclopaedia of Programming Languages
que se acerca a los 9000.

2.4 Creadores de lenguajes de programación

El avance de la computación está íntimamente relacionado con el desarrollo de los
lenguajes de programación. Sus creadores y creadoras juegan un rol fundamental en
la historia tecnológica. Veamos algunas de estas personas: 2

2
Fuente: Wikipedia.

9
 Tabla 2: Creadores y creadoras de lenguajes de programación

Personaje Aporte
Alan Cooper Desarrollador de Visual Basic
Alan Kay Pionero en programación orientada a objetos. Creador de Smalltalk
Anders Hejlsberg Desarrollador de Turbo Pascal, Delphi y C#
Bertrand Meyer Inventor de Eiffel
Bill Joy Inventor de vi. Autor de BSD Unix. Creador de SunOS, el cual se
convirtió en Solaris
Bjarne Stroustrup Desarrollador de C++
Brian Kernighan Coautor del primer libro de programación en lenguaje C con Dennis
Ritchie y coautor de los lenguajes de programación AWK y AMPL
Dennis Ritchie Inventor de C. Sistema Operativo Unix
Edsger W. Dijkstra Desarrolló la estructura para la programación estructurada
Grace Hopper Desarrolladora de Flow-Matic, influenciando el lenguaje COBOL
Guido van Rossum Creador de Python
James Gosling Desarrollador de Oak. Precursor de Java
Joe Armstrong Creador de Erlang
John Backus Inventor de Fortran
John McCarthy Inventor de LISP
John von Neumann Creador del concepto de sistema operativo
Ken Thompson Inventor de B. Desarrollador de Go. Coautor del sistema operativo Unix
Kenneth E. Iverson Desarrollador de APL. Codesarrollador de J junto a Roger Hui
Larry Wall Creador de Perl y Perl 6
Martin Odersky Creador de Scala. Previamente contribuyó en el diseño de Java
Mitchel Resnick Creador del lenguaje visual Scratch
Nathaniel Rochester Inventor del primer lenguaje en ensamblador simbólico (IBM 701)
Niklaus Wirth Inventor de Pascal, Modula y Oberon
Robin Milner Inventor de ML. Compartió crédito en el método Hindley–Milner de
inferencia de tipo polimórfica
Seymour Papert Pionero de la inteligencia artificial. Inventor del lenguaje de
programación Logo en 1968
Stephen Wolfram Creador de Mathematica
Yukihiro Matsumoto Creador de Ruby

10
 3. Python

Foto original por Markéta Marcellová en Unsplash.

Python es un lenguaje de programación de alto nivel creado a finales de los

80/principios de los 90 por Guido van Rossum, holandés que trabajaba por aquella
época en el Centro para las Matemáticas y la Informática de los Países Bajos. Sus
instrucciones están muy cercanas al lenguaje natural en inglés y se hace hincapié en la
legibilidad del código. Toma su nombre de los Monty Python, grupo humorista de los
60 que gustaban mucho a Guido. Python fue creado como sucesor del lenguaje ABC.1

3.1 Características del lenguaje

A partir de su definición de la Wikipedia:

o Python es un lenguaje de programación interpretado cuya filosofía hace

hincapié en una sintaxis que favorezca un código legible.

o Se trata de un lenguaje de programación multiparadigma, ya que soporta

orientación a objetos, programación imperativa y, en menor medida,
programación funcional. Usa tipado dinámico y es multiplataforma.

o Añadiría, como característica destacada, que se trata de un lenguaje de

propósito general.

11
Ventajas

o Libre y gratuito (OpenSource).

o Fácil de leer, parecido a pseudocódigo.

o Aprendizaje relativamente fácil y rápido: claro, intuitivo…

o Alto nivel.

o Alta Productividad: simple y rápido.

o Tiende a producir un buen código: orden, limpieza, elegancia, flexibilidad…

o Multiplataforma. Portable.

o Multiparadigma: programación imperativa, orientada a objetos, funcional…

o Interactivo, modular, dinámico.

o Librerías extensivas («pilas incluidas»).

o Gran cantidad de librerías de terceros.

o Extensible (C++, C, ) y «embebible».

o Gran comunidad, amplio soporte.

o Interpretado.

o Fuertemente tipado, tipado dinámico.

o Hay diferentes implementaciones: CPython, Jython, IronPython, MicroPython…

Desventajas

o Interpretado (velocidad de ejecución, multithread vs GIL, etc.).

o Consumo de memoria.

o Errores durante la ejecución.

o Dos versiones mayores no del todo compatibles (v2 vs v3).

o Desarrollo móvil.

o Documentación a veces dispersa e incompleta.

o Varios módulos para la misma funcionalidad.

o Librerías de terceros no siempre del todo maduras.

12
 3.2 Uso de Python
Al ser un lenguaje de propósito general, podemos encontrar aplicaciones
prácticamente en todos los campos científico-tecnológicos:

o Análisis de datos.

o Aplicaciones de escritorio.

o Bases de datos relacionales / NoSQL.

o Buenas prácticas de programación / Patrones de diseño.

o Concurrencia.

o Criptomonedas / Blockchain.

o Desarrollo de aplicaciones multimedia.

o Desarrollo de juegos.

o Desarrollo en dispositivos embebidos.

o Desarrollo móvil.

o Desarrollo web.

o DevOps / Administración de sistemas / Scripts de automatización.

o Gráficos por ordenador.

o Inteligencia artificial.

o Internet de las cosas.

o Machine Learning.

o Programación de parsers / scrapers / crawlers.

o Programación de redes.

o Propósitos educativos.

o Prototipado de software.

o Seguridad.

o Test automatizados.

13
De igual modo son muchas las empresas, instituciones y organismos que utilizan
Python en su día a día para mejorar sus sistemas de información. Veamos algunas de
las más relevantes:

Figura 4: Grandes empresas y organismos que usan Python

Existen ránkings y estudios de mercado que sitúan a Python como uno de los lenguajes
más usados y la vez, más amados dentro del mundo del desarrollo de software. En el
momento de la escritura de este documento, la última actualización del Índice TIOBE
es de agosto de 2020 en la que Python ocupa el tercer lugar de los lenguajes de
programación más usados, sólo por detrás de C y Java. Igualmente en la encuesta a
desarrolladores de Stack Overflow hecha en 2020, Python ocupa el cuarto puesto de
los lenguajes de programación más usados, sólo por detrás de Javascript, HTML/CSS
y SQL.

3.3 Python2 vs Python3

En el momento de la escritura de este material, se muestra a continuación la evolución
de las versiones mayores de Python a lo largo de la historia: 3

3
Fuente: python.org

14
Tabla 3: Versiones mayores de Python

Versión Fecha de lanzamiento

1.4 Octubre 1996
1.5 Febrero 1998
1.6 Septiembre 2000
2.0 Octubre 2000
2.1 Abril 2001
2.2 Diciembre 2001
2.3 Julio 2003
2.4 Noviembre 2004
2.5 Septiembre 2006
2.6 Octubre 2008
2.7 Julio 2010
3.0 Diciembre 2008
3.1 Junio 2009
3.2 Febrero 2011
3.3 Septiembre 2012
3.4 Marzo 2014
3.5 Septiembre 2015
3.6 Diciembre 2016
3.7 Junio 2018
3.8 Octubre 2019

El cambio de Python 2 a Python 3 fue bastante «traumático» ya que se perdió la

compatibilidad en muchas de las estructuras del lenguaje. Los «core-developers» 4, con
Guido van Rossum a la cabeza, vieron la necesidad de aplicar estas modificaciones en
beneficio del rendimiento y expresividad del lenguaje de programación. Este cambio
implicaba que el código escrito en Python 2 no funcionaría (de manera inmediata) en
Python 3.

El pasado 1 de enero de 2020 finalizó oficialmente el soporte a la versión 2.7 del

lenguaje de programación Python. Es por ello que se recomienda lo siguiente:

o Si aún desarrollas aplicaciones escritas en Python 2, deberías migrar a Python3.

o Si vas a desarrollar una aplicación, deberías hacerlo directamente en Python 3.

Importante: Únete a Python 3 y aprovecha todas sus ventajas.

4
Término que se refiere a los/las desarrolladores/as principales del lenguaje de programación

15
 3.4 Zen de Python
Existen una serie de reglas «filosóficas» que indican una manera de hacer y de pensar
dentro del mundo pitónico 5 creadas por Tim Peters, llamadas el Zen de Python y que
se pueden aplicar incluso más allá de la programación:

En su traducción de la Wikipedia:

o Bello es mejor que feo.

o Explícito es mejor que implícito.

o Simple es mejor que complejo.

o Complejo es mejor que complicado.

o Plano es mejor que anidado.

o Espaciado es mejor que denso.

o La legibilidad es importante.

o Los casos especiales no son lo suficientemente especiales como para romper

las reglas.

5
Dícese de algo/alguien que sigue las convenciones de Python

16
o Sin embargo, la practicidad le gana a la pureza.

o Los errores nunca deberían pasar silenciosamente.

o A menos que se silencien explícitamente.

o Frente a la ambigüedad, evitar la tentación de adivinar.

o Debería haber una, y preferiblemente solo una, manera obvia de hacerlo.

o A pesar de que esa manera no sea obvia a menos que seas holandés.

o Ahora es mejor que nunca.

o A pesar de que nunca es muchas veces mejor que ahora mismo.

o Si la implementación es difícil de explicar, es una mala idea.

o Si la implementación es fácil de explicar, puede que sea una buena idea.

o Los espacios de nombres son una gran idea, ¡tengamos más de esos!

17
Capítulo 2: Entorno de desarrollo
Para poder utilizar Python debemos preparar nuestra máquina con las herramientas
necesarias. Este capítulo trata sobre la instalación y configuración de los elementos
adecuados para el desarrollo con el lenguaje de programación Python.

1. Thonny

Foto original de portada por freddie marriage en Unsplash

Cuando vamos a trabajar con Python debemos tener instalado, como mínimo, un
intérprete del lenguaje (para otros lenguajes sería un compilador). El intérprete nos
permitirá ejecutar nuestro código para obtener los resultados deseados. La idea del
intérprete es lanzar instrucciones «sueltas» para probar determinados aspectos.

Pero normalmente queremos ir un poco más allá y poder escribir programas algo más
largos, por lo que también necesitaremos un editor. Un editor es un programa que
nos permite crear ficheros de código (en nuestro caso con extensión *.py), que luego
son ejecutados por el intérprete.

Hay otra herramienta interesante dentro del entorno de desarrollo que sería el
depurador. Lo podemos encontrar habitualmente en la bibliografía por su nombre
inglés debugger. Es el módulo que nos permite ejecutar paso a paso nuestro código y
visualizar qué está ocurriendo en cada momento. Se suele usar normalmente para
encontrar fallos (bugs) en nuestros programas y poder solucionarlos (debug/fix).

18
Thonny es un programa muy interesante para empezar a aprender Python ya que
engloba estas tres herramientas: intérprete, editor y depurador.

1.1 Instalación
Para instalar Thonny debemos acceder a su web y descargar la aplicación para nuestro
sistema operativo. La ventaja es que está disponible tanto para Windows, Mac y Linux.
Una vez descargado el fichero lo ejecutamos y seguimos su instalación paso por paso.

Una vez terminada la instalación ya podemos lanzar la aplicación que se verá parecido
a la siguiente imagen:

Figura 5: Aspecto de Thonny al arrancarlo

Nota: Es posible que el aspecto del programa varíe ligeramente según el sistema
operativo, configuración de escritorio, versión utilizada o idioma (en mi caso está en
inglés), pero a efectos de funcionamiento no hay diferencia.

Podemos observar que la pantalla está dividida en 3 paneles:

o Panel principal que contiene el editor e incluye la etiqueta <untitled> donde

escribiremos nuestro código fuente Python.

o Panel inferior con la etiqueta Shell que contiene el intérprete de Python. En el

momento de la escritura del presente documento, Thonny incluye la versión de
Python 3.7.7.

o Panel derecho que contiene el depurador. Más concretamente se trata de la

ventana de variables donde podemos inspeccionar el valor de las mismas.

19
Versiones de Python
Existen múltiples versiones de Python. Desde el lanzamiento de la versión 1.0 en 1994
se han ido liberando versiones, cada vez, con nuevas características que aportan
riqueza al lenguaje:

Tabla 4: Versiones de Python

Python 1.0 Jan 1994

Python 1.5 Dec 1997
Python 1.6 Sep 2000
Python 2.0 Oct 2000
Python 2.1 Apr 2001
Python 2.2 Dec 2001
Python 2.3 Jul 2003
Python 2.4 Nov 2004
Python 2.5 Sep 2006
Python 2.6 Oct 2008
Python 2.7 Jul 2010
Python 3.0 Dec 2008
Python 3.1 Jun 2009
Python 3.2 Feb 2011
Python 3.3 Sep 2012
Python 3.4 Mar 2014
Python 3.5 Sep 2015
Python 3.6 Dec 2016
Python 3.7 Jun 2018
Python 3.8 Oct 2019

Nota: Para ser exactos, esta tabla (y en general todo este manual) versa sobre una
implementación concreta de Python denominada CPython, pero existen otras
implementaciones alternativas de Python. A los efectos de aprendizaje del lenguaje
podemos referirnos a Python (aunque realmente estaríamos hablando de CPython).

20
 1.2 Probando el intérprete
El intérprete de Python (por lo general) se identifica claramente porque posee un
prompt 6 con tres ángulos hacia la derecha >>>. En Thonny lo podemos encontrar en
el panel inferior, pero se debe tener en cuenta que el intérprete de Python es una
herramienta autocontenida y que la podemos ejecutar desde el símbolo del sistema o
la terminal:

Lista 1: Invocando el intérprete de Python 3.7 desde una terminal en MacOS

Para hacer una primera prueba del intérprete vamos a retomar el primer programa
que se suele hacer. Es el llamado «Hello, World». Para ello escribimos lo siguiente en
el intérprete y pulsamos la tecla ENTER:

Lo que hemos hecho es indicarle a Python que ejecute como entrada la instrucción
print ('Hello, World'). La salida es el texto Hello, World que lo vemos en la siguiente
línea (ya sin el prompt >>>).

1.3 Probando el editor

Ahora vamos a realizar la misma operación, pero en vez de ejecutar la instrucción
directamente en el intérprete, vamos a crear un fichero y guardarlo con la sentencia
que nos interesa. Para ello escribimos print('Hello, World') en el panel de edición
(superior) y luego guardamos el archivo con el nombre helloworld.py 7:

Importante: Los ficheros que contienen programas hechos en Python siempre deben
tener la extensión .py

6
Término inglés que se refiere al símbolo que precede la línea de comandos
7
La carpeta donde se guarden los archivos de código no es crítica para su ejecución, pero sí
es importante mantener un orden y una organización para tener localizados nuestros ficheros
y proyectos

21
Ahora ya podemos ejecutar nuestro fichero helloworld.py. Para ello pulsamos el botón
verde con triángulo blanco (en la barra de herramientas) o bien damos a la tecla F5.
Veremos que en el panel de Shell nos aparece la salida esperada. Lo que está pasando
«entre bambalinas» es que el intérprete de Python está recibiendo como entrada el
fichero que hemos creado; lo ejecuta y devuelve la salida para que Thonny nos lo
muestre en el panel correspondiente.

Figura 6: Guardando nuestro primer programa en Python

1.4 Probando el depurador

Nos falta por probar el depurador o «debugger». Aunque su funcionamiento va mucho
más allá, de momento nos vamos a quedar en la posibilidad de inspeccionar las
variables de nuestro programa. Desafortunadamente helloworld.py es muy simple y ni
siquiera contiene variables, pero podemos hacer una pequeña modificación al
programa para poder incorporarlas:

Aunque ya lo veremos en profundidad, lo que hemos hecho es incorporar una variable

msg en la línea 1 para luego utilizarla al mostrar por pantalla su contenido. Si ahora
volvemos a ejecutar nuestro programa veremos que en el panel de variables nos
aparece la siguiente información:

Name Value
msg 'Hello, World'

22
También existe la posibilidad, a través del depurador, de ir ejecutando nuestro
programa paso a paso. Para ello basta con pulsar en el botón que tiene un insecto.
Ahí comienza la sesión de depuración y podemos avanzar instrucción por instrucción
usando la tecla F7:

Figura 7: Depurando nuestro primer programa en Python

23
 2. Contexto real

Foto original de portada por SpaceX en Unsplash

Hemos visto que Thonny es una herramienta especialmente diseñada para el

aprendizaje de Python, integrando diferentes módulos que facilitan su gestión. Si bien
lo podemos utilizar para un desarrollo más «serio», se suele recurrir a un flujo de
trabajo algo diferente en contextos más reales.

2.1 Python
La forma más habitual de instalar Python (junto con sus librerías) es descargarlo e
instalarlo desde su página oficial:

o Versiones de Python para Windows

o Versiones de Python para Mac

o Versiones de Python para Linux

Anaconda
Otra de las alternativas para disponer de Python es nuestro sistema y que además es
muy utilizada, es Anaconda. Se trata de un conjunto de herramientas, orientadas en
principio a la ciencia de datos, pero que podemos utilizarlas para desarrollo general
en Python (junto con otras librerías adicionales). Existen versiones de pago, pero la
distribución Individual Edition es «open-source» y gratuita. Se puede descargar desde
los siguientes enlaces:

24
 o Anaconda 64-bits para Windows

o Anaconda 64-bits para Mac

o Anaconda 64-bits para Linux

2.2 Gestión de paquetes

La instalación limpia 8 de Python ya ofrece de por sí muchos paquetes y módulos que
vienen por defecto. Es lo que se llama la librería estándar. Pero una de las características
más destacables de Python es su inmenso «ecosistema» de paquetes disponibles en el
Python Package Index (PyPI).

Para gestionar los paquetes que tenemos en nuestro sistema se utiliza la herramienta
pip, una utilidad que también se incluye en la instalación de Python. Con ella podremos
instalar, desinstalar y actualizar paquetes, según nuestras necesidades. A continuación,
se muestran las instrucciones que usaríamos para cada una de estas operaciones:

Lista 2: Instalación, desinstalación y actualización del paquete pandas utilizando pip

2.3 Entornos virtuales

Cuando trabajamos en distintos proyectos, no todos ellos requieren los mismos
paquetes ni siquiera la misma versión de Python. La gestión de estas situaciones no es
sencilla si únicamente instalamos paquetes y manejamos configuraciones a nivel global
(a nivel de máquina). Es por ello que surge el concepto de entornos virtuales. Como
su propio nombre indica se trata de crear distintos entornos en función de las
necesidades de cada proyecto, y esto nos permite establecer qué versión de Python
usaremos y qué paquetes instalaremos.

El paquete de Python que nos proporciona la funcionalidad de crear y gestionar

entornos virtuales se denomina virtualenv. Su instalación es sencilla a través del gestor
de paquetes pip:

8
También llamada «vanilla installation» ya que es la que viene por defecto y no se hace ninguna
personalización

25
Si bien con virtualenv tenemos las funcionalidades necesarias para trabajar con
entornos virtuales, destacaría una herramienta llamada virtualenvwrapper que funciona
por encima de virtualenv y que facilita las operaciones sobre entornos virtuales. Su
instalación es equivalente a cualquier otro paquete Python:

Veamos a continuación algunos de los comandos que nos ofrece:

26
 o $ mkvirtualenv env1: crea un entorno virtual llamado env1

o $ pip install requests: instala el paquete requests dentro del entorno virtual env1

o $ workon env1: activa el entorno virtual env1

o $ lssitepackages: lista los paquetes instalados en el entorno virtual activo

2.4 Editores
Existen multitud de editores en el mercado que nos pueden servir perfectamente para
escribir código Python. Algunos de ellos incorporan funcionalidades extra y otros
simplemente nos permiten editar ficheros. Cabe destacar aquí el concepto de Entorno
de Desarrollo Integrado, más conocido por sus siglas en inglés IDE 9. Se trata de una
aplicación informática que proporciona servicios integrales para el desarrollo de
software.

Podríamos decir que Thonny es un IDE de aprendizaje, pero existen muchos otros.
Veamos un listado de editores de código que se suelen utilizar para desarrollo en
Python:

Editores generales o IDEs con soporte para Python

o Eclipse + PyDev

o Sublime Text

o Atom

o GNU Emacs

o Vi-Vim

o Visual Studio (+ Python Tools)

o Visual Studio Code (+ Python Tools)

9
Integrated Development Environment.

27
Editores o IDEs específicos para Python

o PyCharm

o Spyder

o Thonny

Cada editor tiene sus características (ventajas e inconvenientes). La preferencia por

alguno de ellos puede estar en base a la experiencia y a las necesidades que surjan. La
parte buena es que hay diversidad de opciones para elegir.

2.5 Jupyter Notebook

Jupyter Notebook es una aplicación «open-source» que permite crear y compartir
documentos que contienen código, ecuaciones, visualizaciones y texto narrativo.
Podemos utilizarlo para propósito general, aunque suele estar más enfocado a ciencia
de datos: limpieza y transformación de datos, simulación numérica, modelado
estadístico, visualización de datos o «machine-learning» 10.

Podemos verlo como un intérprete de Python (contiene un «kernel» 11 que permite

ejecutar código) con la capacidad de incluir documentación en formato Markdown, lo
que potencia sus funcionalidades y lo hace adecuado para preparar cualquier tipo de
material vinculado con lenguajes de programación.

Nota: Aunque su uso está más extendido en el mundo Python, existen muchos otros
«kernels» sobre los que trabajar en Jupyter Notebook.

2.6 WSL
Si estamos trabajando en un sistema Windows 10 es posible que nos encontremos más
cómodos usando una terminal tipo «Linux», entre otras cosas para poder usar con
facilidad las herramientas vistas en esta sección para preparar y gestionar el entorno
de desarrollo Python. Durante mucho tiempo esto fue difícil de conseguir hasta que
Microsoft sacó WSL.

10
Término inglés utilizado para hacer referencia a algoritmos de aprendizaje automático.
11
Proceso específico para un lenguaje de programación que ejecuta instrucciones y actúa como
interfaz de entrada/salida.

28
WSL 12 nos proporciona una consola con entorno Linux que podemos utilizar en
nuestro Windows 10 sin necesidad de instalar una máquina virtual o crear una partición
aparte para Linux nativo. Es importante también saber que existen dos versiones de
WSL hoy en día: WSL y WSL2. La segunda es bastante reciente (publicada a mediados
de 2019), tiene mejor rendimiento y se adhiere más al comportamiento de un Linux
nativo.

Para la instalación de WSL hay que seguir los siguientes pasos:

1. Lanzamos Powershell con permisos de administrador.

2. Activamos la característica de WSL:

3. Descargamos la imagen de Ubuntu 18.04 que usaremos:

4. Finalmente, la instalamos:

En este punto, WSL debería estar instalado correctamente, y debería también aparecer
en el menú Inicio.

12
Windows Subsystem for Linux

29
Capítulo 3: Tipos de datos
Igual que en el mundo real cada objeto pertenece a una categoría, en programación
manejamos objetos que tienen asociado un tipo determinado. En este capítulo se
verán los tipos de datos básicos con los que podemos trabajar en Python.

1. Datos

Foto original de portada por Alexander Sinn en Unsplash

Los programas están formados por código y datos. Pero a nivel interno de la memoria
del ordenador no son más que una secuencia de bits. La interpretación de estos bits
depende del lenguaje de programación, que almacena en la memoria no sólo el puro
dato sino distintos metadatos.1

Cada «trozo» de memoria contiene realmente un objeto, de ahí que se diga que en
Python todo son objetos. Y cada objeto tiene, al menos, los siguientes campos:

o Un tipo del dato almacenado.

o Un identificador único para distinguirlo de otros objetos.

o Un valor consistente con su tipo.

o Un número de referencias que rastrea las veces que se usa un objeto.

30
 1.1 Tipos de datos
A continuación, se muestran los distintos tipos de datos que podemos encontrar en
Python, sin incluir aquellos que proveen paquetes externos:

Figura 8: Esquema (metadatos) de un objeto en Python

Tabla 5: Tipos de datos en Python

Nombre Tipo Ejemplos

Booleano bool True, False
Entero int 21, 34500, 34_500
Flotante float 3.14, 1.5e3
Complejo complex 2j, 3 + 5j
Cadena str 'tfn', '''tenerife - islas canarias'''
Tupla tuple (1, 3, 5)
Lista list ['Chrome', 'Firefox']
Conjunto set set([2, 4, 6])
Diccionario dict {'Chrome': 'v79' , 'Firefox': 'v71'}

31
 1.2 Variables
Las variables son un concepto clave en los lenguajes de programación y permiten
definir nombres

para los valores que tenemos en memoria y que vamos a usar en nuestro programa.

Reglas para nombrar variables

En Python existen una serie de reglas para los nombres de variables:

o Sólo pueden contener los siguientes caracteres 13:

• Letras minúsculas (de la A a la z).

• Letras mayúsculas (de la A a la Z).

• Dígitos (del 0 al 9).

• Guiones bajos (_).

o Son «case-sensitive» 14. Por ejemplo, thing, Thing y THING son nombres
diferentes. Deben empezar con una letra o un guion bajo, nunca con un dígito.

o No pueden ser una palabra reservada del lenguaje («keywords»).

Podemos obtener un listado de las palabras reservadas del lenguaje de la siguiente

forma:

13
Para ser exactos, sí se pueden utilizar otros caracteres, e incluso emojis en los nombres de
variables, aunque no suele ser una práctica extendida, ya que podría dificultar la legibilidad.
14
Sensible a cambios en mayúsculas y minúsculas.

32
Nota: Por lo general se prefiere dar nombres en inglés a las variables que utilicemos,
ya que así hacemos nuestro código más «internacional» y con la posibilidad de que
otras personas puedan leerlo, entenderlo y – llegado el caso – modificarlo. Es sólo una
recomendación, nada impide que se haga en castellano.

Ejemplos de nombres de variables

Veamos a continuación una tabla con nombres de variables:

Tabla 6: Ejemplos de nombres de variables

Válido Inválido Razón

a 3 Empieza por un dígito
a3 3a Empieza por un dígito
a_b_c 95 another-name Contiene un caracter no permitido
_abc with Es una palabra reservada del lenguaje
_3a 3_a Empieza por un dígito

Convenciones para nombres

Mientras se sigan las reglas que hemos visto para nombrar variables no hay problema
en la forma en la que se escriban, pero sí existe una convención para la nomenclatura
de las variables. Se utiliza el llamado snake_case en el que utilizamos caracteres en
minúsculas (incluyendo dígitos si procede) junto con guiones bajos – cuando sean
necesarios para su legibilidad –. 15 Por ejemplo, para nombrar una variable que
almacene el número de canciones en nuestro ordenador, podríamos usar num_songs.

Esta convención, y muchas otras, están definidas en un documento denominado PEP

8. Se trata de una guía de estilo para escribir código en Python. Los PEPs 16 son las
propuestas que se hacen para la mejora del lenguaje.

Constantes
Un caso especial y que vale la pena destacar son las constantes. Podríamos decir que
es un tipo de variable pero que su valor no cambia a lo largo de nuestro programa.
Por ejemplo, la velocidad de la luz. Sabemos que su valor es constante de 300.000
km/s. En el caso de las constantes utilizamos mayúsculas (incluyendo guiones bajos si

15
Más información sobre convenciones de nombres en PEP 8.
16
Del término inglés «Python Enhancement Proposals».

33
es necesario) para nombrarlas. Para la velocidad de la luz nuestra constante se podría
llamar: LIGHT_SPEED.

Elegir buenos nombres

Se suele decir que una persona programadora (con cierta experiencia), a lo que dedica
más tiempo, es a buscar un buen nombre para sus variables. Quizás pueda resultar
algo excesivo, pero da una idea de lo importante que es esta tarea. Es fundamental
que los nombres de variables sean autoexplicativos, pero siempre llegando a un
compromiso entre ser concisos y claros.

Supongamos que queremos buscar un nombre de variable para almacenar el número

de elementos que se deben manejar en un pedido:

1. n

2. num_elements

3. number_of_elements

4. number_of_elements_to_be_handled

No existe una regla mágica que nos diga cuál es el nombre perfecto, pero podemos
aplicar el sentido común y, a través de la experiencia, ir detectando aquellos nombres
que sean más adecuados. En el ejemplo anterior, quizás podríamos descartar de
principio la opción 1 y la 4 (por ser demasiado cortas o largas); nos quedaríamos con
las otras dos. Si nos fijamos bien, casi no hay mucha información adicional de la opción
3 con respecto a la 2. Así que podríamos concluir que la opción 2 es válida para
nuestras necesidades. En cualquier caso, esto dependerá siempre del contexto del
problema que estemos tratando.

34
 1.3 Asignación
En Python se usa el símbolo = para asignar un valor a una variable:

Figura 9: Asignación de valor a nombre de variable

Nota: Hay que diferenciar la asignación en Python con la igualación en matemáticas.

El símbolo = lo hemos aprendido desde siempre como una equivalencia entre dos
expresiones algebraicas, sin embargo, en Python nos indica una sentencia de
asignación, del valor (en la derecha) al nombre (en la izquierda).

Algunos ejemplos de asignaciones a variables:

Algunos ejemplos de asignaciones a constantes:

Python nos ofrece la posibilidad de hacer una asignación múltiple de la siguiente

manera:

En este caso las tres variables utilizadas en el «lado izquierdo» tomarán el valor 3.

Recordemos que los nombres de variables deben seguir unas reglas establecidas, de
lo contrario obtendremos un error sintáctico del intérprete de Python:

35
Asignando una variable a otra variable
Las asignaciones que hemos hecho hasta ahora han sido de un valor literal a una
variable. Pero nada impide que podamos hacer asignaciones de una variable a otra
variable:

Eso sí, la variable que utilicemos como valor de asignación debe existir previamente,
ya que, si no es así, obtendremos un error informando de que no está definida:

De hecho, en el lado derecho de la asignación pueden aparecer expresiones más

complejas que se verán en su momento.

36
Conocer el valor de una variable
Hemos visto previamente cómo asignar un valor a una variable, pero aún no sabemos
cómo «comprobar» el valor que tiene dicha variable. Para ello podemos utilizar dos
estrategias:

1. Si estamos en una «shell» de Python, basta con que usemos el nombre de

la variable:

2. Si estamos escribiendo un programa desde el editor, podemos hacer uso

de print:

Nota: print sirve también cuando estamos en una sesión interactiva de Python («shell»)

Conocer el tipo de una variable

Para poder descubrir el tipo de un literal o una variable, Python nos ofrece la función
type(). Veamos algunos ejemplos de su uso:

37
Ejercicio
1. Asigna un valor entero 2001 a la variable space_odyssey y muestra su valor.

2. Descubre el tipo del literal 'Good night & Good luck'.

3. Identifica el tipo del literal True.

4. Asigna la expresión 5 + 2.0 a la variable result y muestra su tipo.

Ampliar conocimientos
o Basic Data Types in Python

o Variables in Python

o Immutability in Python

38
 2. Números

Foto original de portada por Brett Jordan en Unsplash.

En esta sección veremos los tipos de datos numéricos que ofrece Python centrándonos
en booleanos, enteros y flotantes.

2.1 Booleanos
George Boole es considerado como uno de los fundadores del campo de las ciencias
de la computación y fue el creador del Álgebra de Boole que da lugar, entre otras
estructuras algebraicas, a la Lógica binaria. En esta lógica las variables sólo pueden
tomar dos valores discretos: verdadero o falso.

El tipo de datos bool proviene de lo explicado anteriormente y admite dos posibles

valores:

o True que se corresponde con verdadero (y también con 1 en su representación

numérica).

o False que se corresponde con falso (y también con 0 en su representación

numérica).

Veamos un ejemplo de su uso:

39
La primera variable is_opened está representando el hecho de que algo esté abierto,
y al tomar el valor True podemos concluir que sí. La segunda variable has_sugar nos
indica si una bebida tiene azúcar; dado que toma el valor False inferimos que no lleva
azúcar.

Advertencia: Tal y como se explicó en este apartado, los nombres de variables son
«case- sensitive». De igual modo el tipo booleano toma valores True y False con la
primera letra en mayúsculas. De no ser así obtendríamos un error sintáctico.

2.2 Enteros
Los números enteros no tienen decimales, pero sí pueden contener signo y estar
expresados en alguna base distinta de la usual (base 10).

Literales enteros
Veamos algunos ejemplos de números enteros:

40
Dos detalles a tener en cuenta:

o No podemos comenzar un número entero por 0.

o Python permite dividir los números enteros con guiones bajos _ para clarificar
su lectura/escritura. A efectos prácticos es como si esos guiones bajos no
existieran.

Operaciones con enteros

A continuación, se muestra una tabla con las distintas operaciones sobre enteros que
podemos realizar en Python:

Tabla 7: Operaciones con enteros en Python

Operador Descripción Ejemplo Resultado

+ Suma 5+8 13
- Resta 90 - 10 80
* Multiplicación 4*7 28
/ División flotante 7/2 3.5
// División entera 7 // 2 3
% Módulo 7%3 1
** Exponenciación 3 ** 4 81

Veamos algunas pruebas de estos operadores:

41
Es de buen estilo de programación dejar un espacio entre cada operador. Además,
hay que tener en cuenta que podemos obtener errores dependiendo de la operación
(más bien de los operandos) que estemos utilizando, como es el caso de la división
por cero.

Asignación aumentada
Python nos ofrece la posibilidad de escribir una asignación aumentada mezclando la
asignación y un operador.

Figura 10: Asignación aumentada en Python

Supongamos que disponemos de 100 vehículos en stock y que durante el pasado mes
se han vendido 20 de ellos. Veamos cómo sería el código con asignación tradicional
vs. asignación aumentada:

Lista 1: Asignación tradicional

Lista 2: Asignación aumentada

42
Estas dos formas son equivalentes a nivel de resultados y funcionalidad, pero
obviamente tienen diferencias de escritura y legibilidad. De este mismo modo,
podemos aplicar un formato compacto al resto de operaciones:

Módulo
La operación módulo (también llamado resto), cuyo símbolo en Python es %, se define
como el resto de dividir dos números. Veamos un ejemplo para entender bien su
funcionamiento:

Figura 11: Operador «módulo» en Python

43
Exponenciación
Para elevar un número a otro en Python utilizamos el operador de exponenciación **:

Se debe tener en cuenta que también podemos elevar un número entero a un número
decimal. En este caso es como si estuviéramos haciendo una raíz 17. Por ejemplo:
1
42 = 40,5 = √4 = 2

Hecho en Python:

2.3 Flotantes
Los números en punto flotante 18 tienen parte decimal. Veamos algunos ejemplos de
flotantes en Python.

Lista 3: Distintas formas de escribir el flotante 5.0

2.4 Conversión de tipos

El hecho de que existan distintos tipos de datos en Python (y en el resto de lenguajes
de programación) es una ventaja a la hora de representar la información del mundo

17
No siempre es una raíz cuadrada porque se invierten numerador y denominador
18
Punto o coma flotante es una notación científica usada por computadores

4
real de la mejor manera posible. Pero también se hace necesario buscar mecanismos
para convertir unos tipos de datos en otros.

Conversión implícita
Cuando mezclamos enteros, booleanos y flotantes, Python realiza automáticamente
una conversión implícita (o promoción) de los valores al tipo de «mayor rango».
Veamos algunos ejemplos de esto:

Podemos resumir la conversión implícita en la siguiente tabla:

Tipo 1 Tipo 2 Resultado

bool int int
bool float float
int float float

Conversión explícita
Aunque más adelante veremos el concepto de función, desde ahora podemos decir
que existen una serie de funciones para realizar conversiones explícitas de un tipo a
otro:

bool() Convierte el tipo a booleano.

int() Convierte el tipo a entero.

float() Convierte el tipo a flotante.

Veamos algunos ejemplos de estas funciones:

45
Para poder comprobar el tipo que tiene una variable podemos hacer uso de la función
type():

Ejercicio
Existe una aproximación al seno de un ángulo � expresado en grados:

���(�) ≈ 4�(180 − �)
40500 − �(180 − �)

Calcule dicha aproximación utilizando operaciones en Python. Descomponga la

expresión en subcálculos almacenados en variables. Tenga en cuenta aquellas
expresiones comunes para no repetir cálculos y seguir el principio DRY.

¿Qué tal funciona la aproximación? Compare sus resultados con estos:

o ���(90) = 1,0

o ���(45) = 0,7071067811865475

o ���(50) = 0,766044443118978

Ampliar conocimientos
o The Python Square Root Function

o How to Round Numbers in Python

o Operators and Expressions in Python

46
 3. Cadenas de texto

Foto original de portada por Roman Kraft en Unsplash

Los «strings» o cadenas de texto son el primer ejemplo de secuencia en Python. En

concreto se trata de una secuencia de caracteres. Un carácter es la mínima unidad en
un sistema de escritura e incluye letras, dígitos, símbolos, signos de puntuación e
incluso espacios en blanco o directivas.

3.1 Creando «strings»

Para escribir una cadena de texto en Python basta con rodear los caracteres con
comillas simples:

Para incluir comillas dobles dentro de la cadena de texto no hay mayor inconveniente:

Puede surgir la duda de cómo incluimos comillas simples dentro de la propia cadena
de texto. Veamos soluciones para ello:

47
En la primera opción estamos escapando las comillas simples para que no sean
tratadas como caracteres especiales. En la segunda opción estamos creando el «string»
con comillas dobles (por fuera) para poder incluir directamente las comillas simples
(por dentro). Python también nos ofrece esta posibilidad.

Comillas triples
Hay una forma alternativa de crear cadenas de texto utilizando comillas triples. Su uso
está pensado principalmente para cadenas multilínea:

Importante: Los tres puntos ... que aparecen a la izquierda de las líneas no están
incluidos en la cadena de texto. Es el símbolo que ofrece el intérprete de Python
cuando saltamos de línea.

Cadena vacía
La cadena vacía es aquella que no tiene caracteres, pero es perfectamente válida.
Aunque a priori no lo pueda parecer, es un recurso importante en cualquier código.
Su representación en Python es la siguiente:

3.2 Conversión
Podemos crear «strings» a partir de otros tipos de datos usando la función str():

48
También podemos convertir «strings» a otros tipos de datos:

>>> int('7')
7
>>> float('3.77')
3.77
>>> bool('1')
True
>>> bool('')
False

3.3 Secuencias de escape

Python permite escapar el significado de algunos caracteres para conseguir otros
resultados. Si escribimos una barra invertida \ antes del caracter en cuestión, le
otorgamos un significado especial.

Quizás la secuencia de escape más conocida es \n que representa un salto de línea,

pero existen muchas otras:

Nota: Es cuando utilizamos la función print() que vemos el resultado de utilizar los
caracteres escapados.

49
 3.4 Más sobre print()
Hemos estado utilizando la función print() de forma sencilla, pero admite algunos
parámetros interesantes:

Línea 4: Podemos imprimir todas las variables que queramos separándolas por comas.

Línea 7: El separador por defecto entre las variables es un espacio, podemos cambiar
el caracter que se utiliza como separador entre cadenas.

Línea 10: El carácter de final de texto es un salto de línea, podemos cambiar el caracter
que se utiliza como final de texto.

3.5 Leer datos desde teclado

Los programas se hacen para tener interacción con el usuario. Una de las formas de
interacción es solicitar la entrada de datos por teclado. Como muchos otros lenguajes
de programación, Python también nos ofrece la posibilidad de leer la información
introducida por teclado. Para ello se utiliza la función input():

Nota: La función input() siempre nos devuelve un objeto de tipo cadena de texto o str.
Tenerlo muy en cuenta a la hora de trabajar con números, ya que debemos realizar
una conversión explícita.

50
 3.6 Operaciones con «strings»
Combinar cadenas
Podemos combinar dos o más cadenas de texto utilizando el operador +:

Repetir cadenas
Podemos repetir dos o más cadenas de texto utilizando el operador *:

Obtener un caracter
Los «strings» están indexados y cada caracter tiene su posición propia. Para obtener
un único caracter dentro de una cadena de texto es necesario especificar su índice
dentro de corchetes [...].

Figura 12: Indexado de una cadena de texto

Veamos algunos ejemplos de acceso a caracteres:

51
Nota: Nótese que existen tanto índices positivos como índices negativos para acceder
a cada caracter de la cadena de texto. A priori puede parecer redundante, pero es muy
útil para determinados casos.

En caso de que intentemos acceder a un índice que no existe, obtendremos un error

por fuera de rango:

Advertencia: Téngase en cuenta que el indexado de una cadena de texto siempre

empieza en 0 y termina en una unidad menos de la longitud de la cadena.

Las cadenas de texto son tipos de datos inmutables. Es por ello que no podemos
modificar un caracter directamente:

Truco: Existen formas de modificar una cadena de texto que veremos más adelante,
aunque realmente no estemos transformando el original, sino que se crea un nuevo
objeto con las modificaciones.

Trocear una cadena

Es posible extraer «trozos» («rebanadas») de una cadena de texto 19. Tenemos varias
aproximaciones a ello:

19
El término usado en inglés es slice.

52
[:] Extrae la secuencia entera desde el comienzo hasta el final. Es una especia de copia
de toda la cadena de texto.

[start:] Extrae desde start hasta el final de la cadena.

[:end] Extrae desde el comienzo de la cadena hasta end menos 1.

[start:end] Extrae desde start hasta end menos 1.

[start:end:step] Extrae desde start hasta end menos 1 haciendo saltos de tamaño step.

Veamos la aplicación de cada uno de estos accesos a través de un ejemplo:

Importante: El troceado siempre llega a una unidad menos del índice final que
hayamos especificado. Sin embargo, el comienzo sí coincide con el que hemos puesto.

Longitud de una cadena

Para obtener la longitud de una cadena podemos hacer uso de len() que es una de las
funciones «built-in» 20 que ofrece Python:

20
Término inglés para referirse a algo que ya está incorporado por defecto con el lenguaje de
programación.

53
Dividir una cadena
A contrario que len() algunas funciones son específicas de «strings». Para usar una
función de cadena es necesario escribir el nombre del «string», un punto y el nombre
de la función, pasando cualquier argumento necesario:

Nota: Si no se especifica un separador, split() usa por defecto cualquier secuencia de

espacios en blanco, tabuladores y saltos de línea.

Aunque aún no lo hemos visto, lo que devuelve split() es una lista (otro tipo de datos
en Python) donde cada elemento es una parte de la cadena de texto original.

Limpiar cadenas
Cuando leemos datos del usuario o de cualquier fuente externa de información, es
bastante probable que se incluyan en esas cadenas de texto, caracteres de relleno 21 al
comienzo y al final. Python nos ofrece la posibilidad de eliminar estos caracteres u
otros que no nos interesen.

La función strip() se utiliza para eliminar caracteres del principio y final del «string».
También existen variantes de esta función para aplicarla únicamente al comienzo o al
final de la cadena de texto:

Supongamos que debemos procesar un fichero con números de serie de un

determinado artículo. Cada línea contiene el valor que nos interesa, pero se han
«colado» ciertos caracteres de relleno que debemos limpiar:

Nota: Si no se especifican los caracteres a eliminar, strip() usa por defecto cualquier
combinación de espacios en blanco, saltos de línea \n y tabuladores \t.

21
Se suele utilizar el término inglés «padding» para referirse a estos caracteres.

54
A continuación, vamos a hacer «limpieza» por la izquierda (comienzo) y por la derecha
(final) utilizando la función lstrip() y rstrip() respectivamente:

Como habíamos comentado, también existe la posibilidad de especificar los caracteres

que queremos borrar:

Importante: La función strip() no modifica la cadena que estamos usando (algo obvio
porque los «strings» son inmutables) sino que devuelve una nueva cadena de texto
con las modificaciones pertinentes.

Realizar búsquedas
Veamos aquellas funciones que proporciona Python para la búsqueda en cadenas de
texto. Vamos a partir de una variable que contiene un trozo de la canción Mediterráneo
de Joan Manuel Serrat:

Comprobar si una cadena de texto empieza o termina por alguna subcadena:

Encontrar la primera ocurrencia de alguna subcadena:

55
Tanto find() como index() devuelven el índice de la primera ocurrencia de la subcadena
que estemos buscando, pero se diferencian en su comportamiento cuando la
subcadena buscada no existe:

Contabilizar el número de veces que aparece una subcadena:

Reemplazar elementos
Podemos usar la función replace() indicando la subcadena a reemplazar, la subcadena
de reemplazo y cuántas instancias se deben reemplazar. Si no se especifica este último
argumento, la sustitución se hará en todas las instancias encontradas:

Mayúsculas y minúsculas
Python nos permite realizar variaciones en los caracteres de una cadena de texto para
pasarlos a mayúsculas y/o minúsculas. Veamos las distintas opciones disponibles:

56
 3.7 «f-strings»
Los f-strings aparecieron en Python 3.6 y se suelen usar en código de nueva creación.
Es la forma más potente – y en muchas ocasiones más eficiente – de formar cadenas
de texto incluyendo valores de otras variables.

La interpolación en cadenas de texto es un concepto que existe en la gran mayoría de

lenguajes de programación y hace referencia al hecho de sustituir los nombres de
variables por sus valores a la hora de construir un «string».

Para indicar en Python que una cadena es un «f-string» basta con precederla con una
f e incluir las variables o expresiones a interpolar entre llaves {...}.

Supongamos que disponemos de los datos de una persona y queremos formar una
frase de bienvenida con ellos:

Advertencia: Si olvidamos poner la f delante del «string» no conseguiremos sustitución

de variables.

57
Los «f-strings» proporcionan una gran variedad de opciones de formateado: ancho
del texto, número de decimales, tamaño de la cifra, alineación, etc. Muchas de estas
facilidades se pueden consultar en el artículo Best of Python3.6 f-strings 22

Ejercicio
Obtenga el número de palabras que contiene la siguiente cadena de texto:

Ampliar conocimientos
o A Guide to the Newer Python String Format Techniques

o Strings and Character Data in Python

o How to Convert a Python String to int

o Your Guide to the Python print<> Function

o Basic Input, Output, and String Formatting in Python

o Unicode & Character Encodings in Python: A Painless Guide

o Python String Formatting Tips & Best Practices

o Python 3’s f-Strings: An Improved String Formatting Syntax

o Splitting, Concatenating, and Joining Strings in Python

o Conditional Statements in Python

o Python String Formatting Best Practices

22
Escrito por Nirant Kasliwal en Medium

58
Capítulo 4: Control de flujo
Todo programa informático está formado por instrucciones que se ejecutan en forma
secuencial de «arriba» a «abajo», de igual manera que leeríamos un libro. Este orden
constituye el llamado flujo del programa. Es posible modificar este flujo secuencial para
que tome bifurcaciones o repita ciertas instrucciones. Las sentencias que nos permiten
hacer estas modificaciones se engloban en el control de flujo.

1. Condicionales

Foto original de portada por ali nafezarefi en Unsplash

En esta sección veremos la sentencia condicional if y las distintas variantes que puede
asumir, pero antes de eso introduciremos algunas cuestiones generales de escritura de
código.

1.1 Definición de bloques

A diferencia de otros lenguajes que utilizan llaves para definir los bloques de código,
cuando Guido Van Rossum creó el lenguaje quiso evitar estos caracteres por
considerarlos innecesarios. Es por ello que en Python los bloques de código se definen

59
a través de espacios en blanco, preferiblemente 4. 23 En términos técnicos se habla del
tamaño de indentación.

Consejo: Esto puede resultar extraño e incómodo a personas que vienen de otros
lenguajes de programación, pero desaparece rápido y se siente natural a medida que
se escribe código.

Figura 13: Python recomienda 4 espacios en blanco para indentar

1.2 Comentarios
Un comentario es un trozo de texto en tu programa que es ignorado por el intérprete
de Python. Se pueden usar para aclarar líneas de código adyacentes, para dejar notas
recordatorias o cualquier otro propósito.

Los comentarios se inician con el símbolo almohadilla # y desde ese punto hasta el
final de la línea es parte del comentario:

Lista 1: Comentario de bloque

Los comentarios también pueden aparecer en la misma línea de código, aunque la

guía de estilo de Python no aconseja usarlos en demasía:

Lista 2: Comentario en línea

23
Reglas de indentación definidas en PEP 8

60
 1.3 Ancho del código
Los programas suelen ser más legibles cuando las líneas no son excesivamente largas.
La longitud máxima de línea recomendada por la guía de estilo de Python es de 80
caracteres.

Sin embargo, esto genera una cierta polémica hoy en día, ya que los tamaños de
pantalla han aumentado y las resoluciones son mucho mayores que hace años. Así las
líneas de más de 80 caracteres se siguen visualizando correctamente. Hay personas
que son más estrictas en este límite y otras más flexibles.

En caso de que queramos romper una línea de código demasiado larga, tenemos dos
opciones:

usar la barra invertida \ o usar los paréntesis (...). Veamos un ejemplo:

1.4 La sentencia if
Las sentencia condicional en Python (al igual que en muchos otros lenguajes de
programación) es if. En su escritura debemos añadir una expresión de comparación
terminando con dos puntos al final de la línea. Veamos un ejemplo:

Nota: Nótese que en Python no es necesario incluir paréntesis ( y ) al escribir

condiciones. Hay veces que es recomendable por claridad o por establecer prioridad.

En el caso anterior se puede ver claramente que la condición se cumple y por tanto se
ejecuta la instrucción que tenemos dentro del cuerpo de la condición. Pero podría no

61
ser así. Para controlar ese caso existe la sentencia else. Veamos el mismo ejemplo
anterior pero añadiendo esta variante:

Podríamos tener incluso condiciones dentro de condiciones, lo que se viene a llamar

técnicamente condiciones anidadas 24. Veamos un ejemplo ampliando el caso anterior:

Python nos ofrece una mejora en la escritura de condiciones anidadas cuando nos
aparecen juntos un else y un if. Podemos sustituirlos por la sentencia elif:

Figura 14: Construcción de la sentencia elif

Apliquemos esta mejora al código del ejemplo anterior:

24
El anidamiento (o «nesting») hace referencia a incorporar sentencias unas dentro de otras
mediante la inclusión de diversos niveles de profundidad (indentación).

62
Ejecución paso a paso a través de Python Tutor:

https://cutt.ly/wd58B4t

1.5 Operadores de comparación

Cuando escribimos condiciones debemos incluir alguna expresión de comparación.
Para usar estas expresiones es fundamental conocer los operadores que nos ofrece
Python:

Operador Símbolo
Igualdad ==
Desigualdad !=
Menor que <
Menor o igual que <=
Mayor que >
Mayor o igual que >=
A continuación, vamos a ver una serie de ejemplos con expresiones de comparación.
Téngase en cuenta que estas expresiones habría que incluirlas dentro de la sentencia
condicional en el caso de que quisiéramos tomar una acción concreta:

63
Podemos escribir condiciones más complejas usando los operadores lógicos:

o and

o or

o not

Python ofrece la posibilidad de ver si un valor está entre dos límites de manera directa.
Así, por ejemplo, para descubrir si value está entre 5 y 10 haríamos:

Nota:

1. Una expresión de comparación siempre devuelve un valor booleano, es

decir True o False.

2. El uso de paréntesis, en función del caso, puede aclarar la expresión de

comparación.

«Booleanos» en condiciones
Cuando queremos preguntar por la veracidad de determinada variable «booleana» en
una condición, la primera aproximación que parece razonable es la siguiente:

64
Pero podemos simplificar esta condición tal que así:

Hemos visto una comparación para un valor «booleano» verdadero (True). En el caso
de que la comparación fuera para un valor falso lo haríamos así:

De hecho, si lo pensamos, estamos reproduciendo bastante bien el lenguaje natural:

o Si hace frío, coge chaqueta.

o Si no hace frío, usa camiseta.

Ejercicio
Dada una variable year con un valor entero, compruebe si dicho año es bisiesto o no.

Un año es bisiesto en el calendario Gregoriano, si es divisible entre 4 y no divisible

entre 100, o bien si es divisible entre 400. Puede hacer la comprobación en esta lista
de años bisiestos.

Ampliar conocimientos

o How to Use the Python or Operator

o Conditional Statements in Python (if/elif/else)

65
 2. Bucles

Foto original de portada por Gary Lopater en Unsplash

Cuando queremos hacer algo más de una vez, necesitamos recurrir a un bucle. En esta
sección veremos las distintas sentencias en Python que nos permiten repetir un bloque
de código.

2.1 La sentencia while

El mecanismo más sencillo en Python para repetir instrucciones es mediante la
sentencia while. El mensaje que podemos interpretar tras esta sentencia es: «Mientras
se cumpla la condición haz algo». Veamos un sencillo bucle que muestra por pantalla
los números del 1 al 5:

66
Ejecución paso a paso a través de Python Tutor:

https://cutt.ly/dfeqTCZ

La condición del bucle se comprueba en cada nueva repetición. En este caso

chequeamos que la variable count sea menor o igual que 5. Dentro del cuerpo del
bucle estamos incrementando esa variable en 1 unidad.

Romper un bucle while

Python ofrece la posibilidad de romper o finalizar un bucle antes de que cumpla la
condición de parada. Supongamos un ejemplo en el que estamos buscando el primer
número múltiplo de 3 yendo desde 20 hasta 1:

Ejecución paso a paso a través de Python Tutor:

https://cutt.ly/wfrKnHl

Como hemos visto en este ejemplo, break nos permite finalizar el bucle una vez que
hemos encontrado nuestro objetivo: el primer múltiplo de 3. Pero si no lo hubiéramos
encontrado, el bucle habría seguido decrementando la variable num hasta valer 0, y la
condición del bucle while hubiera resultado falsa.

Bucle infinito
Si no establecemos bien la condición de parada o bien el valor de alguna variable está
fuera de control, es posible que lleguemos a una situación de bucle infinito, del que
nunca podamos salir. Veamos un ejemplo de esto:

67
El problema que surge es que la variable num toma los valores 1, 3, 5, 7, 9, 11, ... por lo
que nunca se cumple la condición del bucle. Esto hace que repitamos eternamente la
instrucción de incremento.

Ejecución paso a paso a través de Python Tutor:

https://cutt.ly/AfrZroa

Una posible solución a este error es reescribir la condición de parada en el bucle:

Truco: Para abortar una situación de bucle infinito podemos pulsar en el teclado la
combinación CTRL-C. Se puede ver reflejado en el intérprete de Python por
KeyboardInterrupt.

2.2 La sentencia for

Python permite recorrer aquellos tipos de datos que sean iterables, es decir, que
admitan iterar 25 sobre ellos. Algunos ejemplos de tipos y estructuras de datos que
permiten ser iteradas (recorridas) son: cadenas de texto, listas, diccionarios, ficheros,
etc. La sentencia for nos permite realizar esta acción.

25
Realizar cierta acción varias veces. En este caso la acción es tomar cada elemento.

68
A continuación, un ejemplo en el que vamos a recorrer (iterar) una cadena de texto:

La clave aquí está en darse cuenta de que el bucle va tomando, en cada iteración, cada
uno de los elementos de la variable que especifiquemos. En este caso concreto, letter
va tomando cada una de las letras que existen en word, porque una cadena de texto
está formada por elementos que son caracteres.

Ejecución paso a paso a través de Python Tutor:

https://cutt.ly/Pft6R2e

Nota: La variable que utilizamos en el bucle for para ir tomando los valores puede
tener cualquier nombre. Al fin y al cabo, es una variable que definimos según nuestras
necesidades. Tener en cuenta que se suele usar un nombre en singular.

Romper un bucle for

Una sentencia break dentro de un for rompe el bucle, igual que veíamos para los bucles
while. Veamos un ejemplo con el código anterior. En este caso vamos a recorrer una
cadena de texto y pararemos el bucle cuando encontremos una letra t minúscula:

Ejecución paso a paso a través de Python Tutor:

https://cutt.ly/zfyqkbJ

69
Generar secuencias de números
La función range() devuelve un flujo de números en el rango especificado, sin
necesidad de crear y almacenar previamente una larga estructura de datos. Esto
permite generar rangos enormes sin consumir toda la memoria del sistema.

El uso de range() es similar a los «slices»: range(start, stop, step). Podemos omitir start
y el rango empezaría en 0. El único valor requerido es stop y el último valor generado
será justo el anterior a este. El valor por defecto de step es 1, pero se puede ir «hacia
detrás» con -1.

range() devuelve un objeto iterable, así que necesitamos obtener los valores paso a
paso con una sentencia for ... in 26. Veamos diferentes ejemplos de uso:

Rango: [0, 1, 2]

Rango: [1, 3, 5]

Rango: [2, 1, 0]

26
O convertir el objeto a una secuencia como una lista

70
Ejecución paso a paso a través de Python Tutor:

https://cutt.ly/vfywE45

Truco: Se suelen utilizar nombres de variables i, j, k para lo que se viene a denominar

contadores. Este tipo de variables toman valores numéricos enteros como en los
ejemplos anteriores. No conviene generalizar el uso de estas variables a situaciones en
las que, claramente, tenemos la posibilidad de asignar un nombre semánticamente
más significativo.

2.3 Bucles anidados

Como ya vimos en las sentencias condicionales, el anidamiento es una técnica en la
que incluimos distintos niveles de encapsulamiento de sentencias, unas dentro de
otras, con mayor nivel de profundidad. En el caso de los bucles también es posible
hacer anidamiento.

Veamos un ejemplo de 2 bucles anidados en el que generamos todas las tablas de

multiplicar:

>>> for i in range(1, 10):

... for j in range(1, 10):
... result = i * j
... print(f'{i} * {j} = {result}')
...
1 x 1 = 1
1 x 2 = 2
1 x 3 = 3
1 x 4 = 4
1 x 5 = 5
1 x 6 = 6
1 x 7 = 7
1 x 8 = 8
1 x 9 = 9
2 x 1 = 2
2 x 2 = 4
2 x 3 = 6
2 x 4 = 8
2 x 5 = 10
2 x 6 = 12
2 x 7 = 14
2 x 8 = 16
2 x 9 = 18

(continúa en la próxima página)

71
72
Lo que está ocurriendo en este código es que, para cada valor que toma la variable i,
la otra variable j toma todos sus valores. Como resultado tenemos una combinación
completa de los valores en el rango especificado.

Ejecución paso a paso a través de Python Tutor:

https://cutt.ly/vfyeWvj

Nota:

o Podemos añadir todos los niveles de anidamiento que queramos. Eso sí, hay
que tener en cuenta que cada nuevo nivel de anidamiento supone un
importante aumento de la complejidad ciclomática de nuestro código, lo que
se traduce en mayores tiempos de ejecución.

o Los bucles anidados también se pueden aplicar a la sentencia while.

Ejercicio
Imprima los 100 primeros números de la sucesión
de Fibonacci:

0, 1, 1, 2, 3, 5, 8, 13, 21, 34, 55, 89, . . .

Ampliar conocimientos
o The Python range() Function

o How to Write Pythonic Loops

o For Loops in Python (Definite Iteration)

o Python «while» Loops (Indefinite Iteration)

73
Capítulo 5: Estructuras de datos
Si bien ya hemos visto una sección sobre Tipos de datos, podríamos hablar de tipos
de datos más complejos en Python que se constituyen en estructuras de datos. Si
pensamos en estos elementos como átomos, las estructuras de datos que vamos a ver
sería moléculas. Es decir, combinamos los tipos básicos de formas más complejas. De
hecho, esta distinción se hace en el Tutorial oficial de Python. Trataremos distintas
estructuras de datos como listas, tuplas, diccionarios y conjuntos.

1. Listas

Foto original de portada por Mike Arney en Unsplash.

Las listas son adecuadas para guardar elementos en un orden concreto. A diferencia,
por ejemplo, de las cadenas de texto, las listas son mutables. Podemos modificar,
añadir o borrar elementos de una lista. Cabe destacar que un mismo valor puede
aparecer más de una vez en una lista.

1.1 Creando listas

Una lista está compuesta por cero o más elementos, separados por comas y rodeados
por corchetes. Veamos algunos ejemplos de listas:

74
Nota: Una lista puede contener tipos de datos heterogéneos, lo que la hace una
estructura de datos muy versátil.

Ejecución paso a paso a través de Python Tutor:

https://cutt.ly/Ofiiare

1.2 Conversión
Para convertir otros tipos de datos en una lista podemos usar la función list():

Si nos fijamos en lo que ha pasado, al convertir la cadena de texto Python se ha creado

una lista con 6 elementos, donde cada uno de ellos representa un caracter de la
cadena. Podemos extender este comportamiento a cualquier otro tipo de datos que
permita acceder a sus elementos.

Lista vacía
Existe una manera particular de usar list() y es no pasarle ningún argumento. En este
caso estaremos queriendo convertir el vacío en una lista, con lo que obtendremos una
lista vacía:

75
 1.3 Operaciones con listas
Obtener un elemento
Igual que en el caso de las cadenas de texto podemos extraer un elemento de una lista
especificando su índice. Veamos un ejemplo:

El índice que usemos para acceder a los elementos de una lista tiene que estar
comprendido entre los límites de la misma. Si usamos un índice antes del comienzo o
después del final obtendremos un error (excepción):

Trocear una lista

El troceado de listas funciona de manera totalmente análoga al troceado de cadenas.
Veamos algunos ejemplos:

76
Hacer notar que el uso de índices inválidos en el troceado no genera una excepción.
Python trata de ajustarse al índice válido más próximo:

Nota: Ninguna de las operaciones anteriores modifican la lista original, simplemente

devuelven una lista nueva.

Invertir una lista

Python nos ofrece, al menos, tres mecanismos para invertir los elementos de una lista:

Conservando la lista original: Mediante troceado de listas con step negativo:

Conservando la lista original: Mediante la función reversed():

77
Modificando la lista original: Utilizando la función reverse() (nótese que es sin «d» al
final):

Añadir al final de la lista

La forma tradicional de añadir elementos al final de una lista es utilizar la función
append(). Se trata de un método destructivo que modifica la lista original:

Añadir en cualquier posición de una lista

La función append() sólo permite añadir elementos al final de la lista. Cuando se quiere
insertar un elemento en otra posición de una lista debemos usar insert() especificando
el índice de colocación. También se trata de una función destructiva 27:

27
Cuando hablamos de que una función/método es «destructiva/o» significa que modifica la
lista (objeto) original, no que la destruye.

78
Nota: El índice que especificamos en la función insert() lo podemos interpretar como
la posición delante (a la izquierda) de la cual vamos a colocar el nuevo valor en la lista.

No hay que preocuparse por insertar un elemento en desplazamientos no válidos. Si

el índice supera el tamaño de la lista, el elemento se insertará al final de la lista. Si el
índice es demasiado bajo se insertará al comienzo de la lista. En ninguno de los dos
casos vamos a obtener un error debido a esta circunstancia:

Repetir elementos
Al igual que con las cadenas de texto, el operador * nos permite repetir los elementos
de una lista:

79
Combinar listas
Python nos ofrece dos aproximaciones para combinar listas:

Conservando la lista original: Mediante el operador + o +=:

Modificando la lista original: Mediante la función extend():

Hay que tener en cuenta que extend() funciona adecuadamente si pasamos una lista
como argumento. En otro caso, quizás los resultados no sean los esperados. Veamos
un ejemplo:

El motivo es que extend() «recorre» (o itera) sobre cada uno de los elementos del
objeto en cuestión. En el caso anterior, al ser una cadena de texto, está formada por
caracteres. De ahí el resultado que obtenemos.

Se podría pensar en el uso de append() para ampliar para combinar listas. La realidad
es que no funciona exactamente como esperamos; la segunda lista se añadiría como
una sublista de la principal:

80
Modificar una lista
Del mismo modo que se accede a un elemento utilizando su índice, también podemos
modificarlo:

En el caso de acceder a un índice no válido de la lista, incluso para modificar,

obtendremos un error:

Borrar elementos
Python nos ofrece, al menos, cuatro formas para borrar elementos en una lista:

Por su índice: Mediante la función del():

Por su valor: Mediante la función remove():

81
Advertencia: Si existen valores duplicados, la función remove() sólo borrará la primera
ocurrencia.

Por su índice (con extracción):: Las dos funciones anteriores del() y remove() efectiva-
mente borran el elemento indicado de la lista, pero no «devuelven» 28 nada. Sin
embargo, Python nos ofrece la función pop() que además de borrar nos «recupera» el
elemento; algo así como una extracción*. Lo podemos ver como una combinación de
acceso + borrado:

Nota: Si usamos la función sin pasarle ningún argumento, por defecto usará el índice
-1, es decir, el último elemento de la lista. Pero también podemos indicarle el índice
del elemento a extraer.

Borrado completo de la lista:

1. Utilizando la función clear():

28
Más adelante veremos el comportamiento de las funciones. Devolver o retornar un valor es
el resultado de aplicar una función

82
 2. «Reinicializando» la lista a vacío con []:

Nota: La diferencia entre ambos métodos tiene que ver con cuestiones internas de
gestión de memoria y de rendimiento.

Encontrar un elemento
Para conocer el índice que tiene un determinado elemento dentro de una lista
podemos hacer uso de la función index():

Tener en cuenta que, si el elemento que buscamos no está en la lista, obtendremos un

error:

Pertenencia de un elemento
La forma pitónica de comprobar la existencia de un elemento (valor) dentro de una
lista, es utilizar el operador in:

83
Nota: El operador in siempre devuelve un valor booleano, es decir, verdadero o falso.

Número de ocurrencias
Para contar cuántas veces aparece un determinado valor dentro de una lista podemos
usar la función count():

Convertir lista a cadena de texto

Dada una lista, podemos convertirla a una cadena de texto, uniendo todos sus
elementos mediante algún separador. Para ello hacemos uso de la función join() con
la siguiente estructura:

Figura 15: Estructura de llamada a la función join()

84
Hay que tener en cuenta que join() sólo funciona si todos sus elementos son cadenas
de texto:

Truco: Esta función join() es realmente la opuesta a la de split() para dividir una cadena.

Ordenar una lista

Python proporciona, al menos, dos formas de ordenar los elementos de una lista:

Conservando lista original: Mediante la función sorted() que devuelve una nueva lista
ordenada:

Modificando la lista original: Mediante la función sort():

Ambos métodos admiten un parámetro «booleano» reverse para indicar si queremos

que la ordenación se haga en orden inverso:

Longitud de una lista

Podemos conocer el número de elementos que tiene una lista con la función len():

85
Iterar sobre una lista
Al igual que hemos visto con las cadenas de texto, también podemos iterar sobre los
elementos de una lista a través de la sentencia for:

Nota: También es posible usar la sentencia break en este tipo de bucles para abortar
su ejecución en algún momento que nos interese.

Iterar usando enumeración

Hay veces que no sólo nos interesa «visitar» cada uno de los elementos de una lista,
sino que también queremos saber su índice dentro de la misma. Para ello Python nos
ofrece la función enumerate():

Ejecución paso a paso a través de Python Tutor:

https://cutt.ly/TfiuIZ0

Iterar sobre múltiples listas

Python ofrece la posibilidad de iterar sobre múltiples listas en paralelo utilizando la
función zip():

86
Ejecución paso a paso a través de Python Tutor:

https://cutt.ly/lfioilG

Nota: En el caso de que las listas no tengan la misma longitud, la función zip() realiza
la combinación hasta que se agota la lista más corta.

Dado que zip() produce un iterador, si queremos obtener una lista explícita con la
combinación en paralelo de las listas, debemos construir dicha lista de la siguiente
manera:

1.4 Cuidado con las copias

Las listas son estructuras de datos mutables y esta característica nos obliga a tener
cuidado cuando realizamos copias de listas, ya que la modificación de una de ellas
puede afectar a la otra.

Veamos un ejemplo sencillo:

87
Ejecución paso a paso a través de Python Tutor:

https://cutt.ly/pfi5PC5

Nota: A través de Python Tutor se puede ver claramente el motivo de por qué ocurre
esto. Dado que las variables «apuntan» a la misma zona de memoria, al modificar una
de ellas, el cambio también se ve reflejado en la otra.

Una posible solución a este problema es hacer una «copia dura». Para ello Python
proporciona la función copy():

Ejecución paso a paso a través de Python Tutor:

https://cutt.ly/Dfi6oLk

1.5 Construyendo una lista

Una forma muy habitual de trabajar con listas es empezar con una vacía e ir añadiendo
elementos poco a poco. Supongamos un ejemplo en el que queremos construir una
lista con los números pares del 1 al 20:

Ejecución paso a paso a través de Python Tutor:

https://cutt.ly/2fiS9Ax

88
 1.6 Funciones matemáticas
Python nos ofrece, entre otras 29, estas tres funciones matemáticas básicas que se
pueden aplicar sobre listas.

Suma de todos los valores: Mediante la función sum():

Mínimo de todos los valores: Mediante la función min():

Máximo de todos los valores: Mediante la función max():

1.7 Listas de listas

Como ya hemos visto en varias ocasiones, las listas son estructuras de datos que
pueden contener elementos heterogéneos. Una de la forma en las que podemos
utilizarlas es usando listas como elementos.

Por ejemplo, si pensamos en la variable shopping que hemos estado usando y que
representa la lista de la compra, la podríamos dividir en sublistas, cada una de ellas
indicando los productos que vamos a comprar en las secciones del supermercado:

Ahora podríamos juntar todo en una única lista de la compra:

29
Existen multitud de paquetes científicos en Python para trabajar con listas o vectores
numéricos. Una de las más famosas es la librería Numpy.

89
Ejecución paso a paso a través de Python Tutor:

https://cutt.ly/dfi7e41

Ejercicio
Lea desde teclado una cadena de texto con números separados por comas. Sin utilizar
las funciones matemáticas, obtenga la media de dichos valores (muestre el resultado
con 2 decimales).

Ejemplo

o Entrada: '32,56,21,99,12,17'

o Salida: 37.50

Ampliar conocimientos
o Linked Lists in Python: An Introduction

o Python Command Line Arguments

o Sorting Data With Python

o When to Use a List Comprehension in Python

o Using the Python zip() Function for Parallel Iteration

o Lists and Tuples in Python

o How to Use sorted() and sort() in Python

o Using List Comprehensions Effectively

90
 2. Tuplas

Foto original de portada por engin akyurt en Unsplash.

El concepto de tupla es muy similar al de lista. Aunque hay algunas diferencias

menores, lo fundamental es que, mientras una lista es mutable y se puede modificar,
una tupla no admite cambios y, por lo tanto, es inmutable.

2.1 Creando tuplas

Podemos pensar en crear tuplas tal y como lo hacíamos con listas, pero usando
paréntesis en lugar de corchetes:

Tuplas de un elemento
Hay que prestar especial atención cuando vamos a crear una tupla de un único
elemento. La intención primera sería hacerlo de la siguiente manera:

91
Realmente, hemos creado una variable de tipo str (cadena de texto). Para crear una
tupla de un elemento debemos añadir una coma al final:

Tuplas sin paréntesis

Según el caso, hay veces que nos podemos encontrar con tuplas que no llevan
paréntesis. Quizás no está tan extendido, pero a efectos prácticos tiene el mismo
resultado. Veamos algunos ejemplos de ello:

2.2 Modificar una tupla

Como ya hemos comentado previamente, las tuplas con estructuras de datos
inmutables. Una vez que las creamos con un valor, no podemos modificarlas. Veamos
qué ocurre si lo intentamos:

92
 2.3 Conversión
Para convertir otros tipos de datos en una tupla podemos usar la función tuple():

Esta conversión es válida para aquellos tipos de datos que sean iterables: cadenas de
caracteres, listas, diccionarios, conjuntos, etc. Un ejemplo que no funciona es intentar
convertir un número en una tupla:

El uso de la función tuple() sin argumentos equivale a crear una tupla vacía:

2.4 Operaciones con tuplas

Con las tuplas podemos realizar todas las operaciones que vimos con listas salvo las
que conlleven una modificación «in-situ» de la misma:

o reverse()

o append()

o extend()

o remove()

o clear()

o sort()

93
 2.5 Desempaquetado de tuplas
El desempaquetado es una característica de las tuplas que nos permite asignar una
tupla a variables independientes:

Figura 16: Desempaquetado de tuplas

Veamos un ejemplo con código:

Intercambio de valores
A través del desempaquetado de variables podemos llevar a cabo el intercambio de
los valores de dos variables de manera directa:

Nota: A priori puede parecer que esto es algo «natural», pero en la gran mayoría de
lenguajes de programación no es posible hacer este intercambio de forma «directa»
ya que necesitamos recurrir a una tercera variable «auxiliar» como almacén temporal
en el paso intermedio de traspaso de valores.

94
 3. Diccionarios

Foto original de portada por Aaron Burden en Unsplash

Podemos trasladar el concepto de diccionario de la vida real al de diccionario en

Python. Al fin y al cabo, un diccionario es un objeto que contiene palabras, y cada
palabra tiene asociado un significado. Haciendo el paralelismo, diríamos que en Python
un diccionario es también un objeto indexado por claves (las palabras) que tienen
asociados unos valores (los significados).

Los diccionarios en Python tienen las siguientes características:

o Mantienen el orden en el que se insertan las claves. 30

o Son mutables con lo que admiten añadir, borrar y modificar sus elementos.

o Las claves deben ser únicas. A menudo se utilizan las cadenas de texto como
claves, pero en realidad podría ser cualquier tipo de datos inmutable: enteros,
flotantes, tuplas (entre otros).

o Tienen un acceso muy rápido a sus elementos, debido a la forma en la que

están implementados internamente. 31

30
Aunque históricamente Python no establecía que las claves de los diccionarios tuvieran que
mantener su orden de inserción, a partir de Python 3.7 este comportamiento cambió y se
garantizó el orden de inserción de las claves como parte oficial de la especificación del lenguaje
31
Véase este análisis de complejidad y rendimiento de distintas estructuras de datos en
CPython.

95
 Figura 17: Analogía de un diccionario en Python

Nota: En otros lenguajes de programación, a los diccionarios se les conoce como arrays
asociativos, «hashes» o «hashmaps».

3.1 Creando diccionarios

Para crear un diccionario basta con usar llaves {} rodeando pares clave: valor separados
por comas. Veamos algunos ejemplos de diccionarios:

96
En el código anterior podemos observar la creación de un diccionario vacío, otro
donde sus claves y sus valores son cadenas de texto y otro donde las claves y los
valores son valores enteros.

Ejecución paso a paso a través de Python Tutor:

https://cutt.ly/Sfav2Yw

3.2 Conversión
Para convertir otros tipos de datos en un diccionario podemos usar la función dict():

3.3 Operaciones con diccionarios

Obtener un elemento
Para obtener un elemento de un diccionario basta con escribir la clave entre corchetes.
Veamos un ejemplo:

Si intentamos acceder a una clave que no existe, obtendremos un error:

97
Usando get()
Existe una función muy útil para «superar» los posibles errores de acceso por claves
inexistentes. Se trata de get() y su comportamiento es el siguiente:

1. Si la clave que buscamos existe, nos devuelve su valor.

2. Si la clave que buscamos no existe, nos devuelve None 32 salvo que le

indiquemos otro valor por defecto, pero en ninguno de los dos casos
obtendremos un error.

Línea 6: Equivalente a rae['bifronte'].

Línea 9: La clave buscada no existe y obtenemos None. 33

Línea 11: La clave buscada no existe y nos devuelve el valor que hemos aportado por
defecto.

Añadir o modificar un elemento

Añadir un elemento a un diccionario es sencillo. Sólo es necesario hacer referencia a
la clave y asignarle un valor:

o Si la clave ya existía en el diccionario, se reemplaza el valor existente por el

nuevo.

o Si la clave es nueva, se añade al diccionario con su valor.

32
None es la palabra reservada en Python para la «nada». Más información en esta web.
33
Realmente no estamos viendo nada en la consola de Python porque la representación en
cadena de texto es vacía.

98
Al contrario que en las listas, no hay que preocuparse por las excepciones (errores) por
fuera de rango durante la asignación de elementos a un diccionario:

Vamos a añadir la palabra enjuiciar a nuestro diccionario de la Real Academia de La

Lengua:

Supongamos ahora que queremos modificar el significado de la palabra enjuiciar por

otra acepción:

Pertenencia de una clave

La forma pitónica de comprobar la existencia de una clave dentro de un diccionario,
es utilizar el operador in:

Nota: El operador in siempre devuelve un valor booleano, es decir, verdadero o falso.

Obtener todos los elementos

Python ofrece mecanismos para obtener todos los elementos de un diccionario.
Partimos del siguiente diccionario:

99
Obtener todas las claves de un diccionario: Mediante la función keys():

Obtener todos los valores de un diccionario: Mediante la función values():

Obtener todos los pares «clave-valor» de un diccionario: Mediante la función items():

Nota: Para este último caso cabe destacar que los «items» se devuelven como una lista
de tuplas, donde cada tupla tiene dos elementos: el primero representa la clave y el
segundo representa el valor.

Longitud de un diccionario
Podemos conocer el número de elementos («clave-valor») que tiene un diccionario
con la función len():

10
Iterar sobre un diccionario
En base a los elementos que podemos obtener, Python nos proporciona tres maneras
de iterar sobre un diccionario.

Iterar sobre claves:

Iterar sobre valores:

Iterar sobre «clave-valor»:

Nota: En este último caso, recuerde el uso de los «f-strings» para formatear cadenas
de texto.

Combinar diccionarios
Dados dos (o más) diccionarios, es posible «mezclarlos» para obtener una combinación
de los mismos. Esta combinación se basa en dos premisas:

1. Si la clave no existe, se añade con su valor.

2. Si la clave ya existe, se añade con el valor del «último» diccionario en la
mezcla. 34

34
En este caso «último» hace referencia al diccionario que se encuentra más a la derecha en la
expresión.

10
Python ofrece dos mecanismos para realizar esta combinación. Vamos a partir de los
siguientes diccionarios para ejemplificar su uso:

Sin modificar los diccionarios originales: Mediante el operador **:

Modificando los diccionarios originales: Mediante la función update():

Nota: Tener en cuenta que el orden en el que especificamos los diccionarios a la hora
de su combinación (mezcla) es relevante en el resultado final. En este caso el orden de
los factores sí altera el producto.

Borrar elementos
Python nos ofrece, al menos, tres formas para borrar elementos en un diccionario:

Por su clave: Mediante la sentencia del:

10
Por su clave (con extracción): Mediante la función pop() podemos extraer un elemento
del diccionario por su clave. Vendría a ser una combinación de get() + del:

Advertencia: Si la clave que pretendemos extraer con pop() no existe, obtendremos un

error.

Borrado completo del diccionario:

1. Utilizando la función clear():

10
 2. «Reinicializando» el diccionario a vacío con {}:

Nota: La diferencia entre ambos métodos tiene que ver con cuestiones internas de
gestión de memoria y de rendimiento.

3.4 Cuidado con las copias

Al igual que ocurría con las listas, si hacemos un cambio en un diccionario, se verá
reflejado en todas las variables que hagan referencia al mismo. Esto se deriva de la
propiedad de mutabilidad. Veamos un ejemplo concreto:

Una posible solución a este problema es hacer una «copia dura». Para ello Python
proporciona la función copy():

10
 3.5 Construyendo un diccionario
Una forma muy habitual de trabajar con diccionarios es empezar con uno vacío e ir
añadiendo elementos poco a poco. Supongamos un ejemplo en el que queremos
construir un diccionario donde las claves son las letras vocales y los valores son sus
posiciones:

Nota: Hemos utilizado la función enumerate() que ya vimos para las listas en el
apartado: Iterar usando enumeración.

10
Ejercicio
Usando un diccionario, cuente el número de veces que se repite cada letra en una
cadena de texto dada.

Ejemplo

Entrada: 'boom'

Salida: {'b': 1, 'o': 2, 'm': 1}

Ampliar conocimientos
o Using the Python defaultdict Type for Handling Missing Keys

o Python Dictionary Iteration: Advanced Tips & Tricks

o Python KeyError Exceptions and How to Handle Them

o Dictionaries in Python

o How to Iterate Through a Dictionary in Python

o Shallow vs Deep Copying of Python Objects

10
 4. Conjuntos

Foto original de portada por Duy Pham en Unsplash.

Un conjunto en Python se representa por una serie de valores únicos y sin orden
establecido. Lo podríamos ver como un diccionario al que le hemos quitado los valores
y nos hemos quedado sólo con las claves. Mantiene muchas similitudes con el
concepto matemático de conjunto

4.1 Creando conjuntos

Para crear un conjunto basta con separar sus valores por comas y rodearlos de llaves
{}:

La excepción la tenemos a la hora de crear un conjunto vacío, ya que, siguiendo la

lógica de apartados anteriores, deberíamos hacerlo a través de llaves:

Advertencia: Si hacemos esto, lo que obtenemos es un diccionario vacío.

10
La única opción que tenemos es utilizar la función set():

4.2 Conversión
Para convertir otros tipos de datos en un conjunto podemos usar la función set():

Importante: Como se ha visto en los ejemplos anteriores, set() se suele utilizar en

muchas ocasiones como una forma de extraer los valores únicos de otros tipos de
datos. En el caso de los diccionarios se extraen las claves, que, por definición, son
únicas.

Nota: El hecho de que en los ejemplos anteriores los elementos de los conjuntos estén
ordenados es únicamente un «detalle de implementación» en el que no se puede
confiar.

4.3 Operaciones con conjuntos

Obtener un elemento
En un conjunto no existe un orden establecido para sus elementos, por lo cual no
podemos acceder a un elemento en concreto.

10
De este hecho se deriva igualmente que no podemos modificar un elemento existente,
ya que no podemos acceder a él. Python sí nos permite añadir o borrar elementos de
un conjunto.

Añadir un elemento
Para añadir un elemento a un conjunto debemos utilizar la función add(). Como ya
hemos indicado, al no importar el orden dentro del conjunto, la inserción no establece
a priori la posición dónde se realizará.

A modo de ejemplo, vamos a partir de un conjunto que representa a los cuatro

integrantes originales de The Beatles. Luego añadiremos a un nuevo componente:

Ejecución paso a paso a través de Python Tutor:

https://tinyurl.com/9folv2v

Borrar elementos
Para borrar un elemento de un conjunto podemos utilizar la función remove().
Siguiendo con el ejemplo anterior vamos a borrar al último «beatle» añadido:

Longitud de un conjunto
Podemos conocer el número de elementos que tiene un conjunto con la función len():

10
Iterar sobre un conjunto
Tal y como hemos visto para otros tipos de datos iterables, la forma de recorrer los
elementos de un conjunto es utilizar la sentencia for:

Consejo: Como en el ejemplo anterior, es muy común utilizar una variable en singular
para recorrer un iterable (en plural). No es una regla fija ni sirve para todos los casos,
pero sí suele ser una buena práctica.

Pertenencia de elemento
Al igual que con otros tipos de datos, Python nos ofrece el operador in para determinar
si un elemento pertenece a un conjunto:

4.4 Teoría de conjuntos

Vamos a partir de dos conjuntos 𝐴𝐴 = {1, 2} y 𝐵𝐵 = {2, 3} para ejemplificar las distintas
operaciones que se pueden hacer entre ellos basadas en los Diagramas de Venn y la
Teoría de Conjuntos:

Figura 18: Diagramas de Venn

11
Intersección
𝐴𝐴 ∩ 𝐵𝐵 – Elementos que están a la vez en 𝐴𝐴 y en 𝐵𝐵:

Unión
𝐴𝐴 ∪ 𝐵𝐵 – Elementos que están tanto en 𝐴𝐴 como en 𝐵𝐵:

Diferencia
𝐴𝐴 − 𝐵𝐵 – Elementos que están en 𝐴𝐴 y no están en 𝐵𝐵:

Diferencia simétrica
𝐴𝐴 ∩ 𝐵𝐵 – Elementos que están en 𝐴𝐴 o en 𝐵𝐵 pero no en ambos conjuntos:

Ampliar conocimientos
o Sets in Python

11
 5. Ficheros

Foto original de portada por Maksym Kaharlytskyi en Unsplash

Aunque los ficheros encajarían más en un apartado de «entrada/salida» ya que

representan un medio de almacenamiento persistente, también podrían ser vistos
como estructuras de datos, puesto que nos permiten guardar la información y
asignarles un cierto formato.

Un fichero es una secuencia de bytes almacenados en algún sistema de ficheros y

accesibles por un nombre de fichero. Un directorio (o carpeta) es una colección de
ficheros, y probablemente de otros directorios. Muchos sistemas de ficheros son
jerárquicos y a menudo nos referimos a ellos como árbol de ficheros.

5.1 Lectura de un fichero

Python ofrece la función open() para «abrir» un fichero. Esta apertura se puede realizar
en 3 modos distintos:

o Lectura del contenido de un fichero existente.

o Escritura del contenido en un fichero nuevo.

o Añadido al contenido de un fichero existente.

11
Veamos un ejemplo para leer el contenido de un fichero en el que se encuentran las
temperaturas máximas y mínimas de cada día de la última semana. El fichero está en
la subcarpeta (ruta relativa) files/temps.dat y tiene el siguiente contenido:

Lo primero será abrir el fichero:

La función open() recibe como primer argumento la ruta al fichero que queremos
manejar (como un «string») y devuelve el manejador del fichero, que en este caso lo
estamos asignando a una variable llamada f, pero le podríamos haber puesto cualquier
otro nombre.

Nota: Es importante dominar los conceptos de ruta relativa y ruta absoluta para el
trabajo con ficheros. Véase este artículo de DeNovatoANovato.

Hay que tener en cuenta que la ruta al fichero que abrimos (en modo lectura) debe
existir, ya que de lo contrario obtendremos un error:

Una vez abierto el fichero ya podemos proceder a leer su contenido. Para ello Python
nos ofrece la posibilidad de leer todo el fichero de una vez o bien leerlo línea a línea.

Lectura completa de un fichero

Siguiendo con nuestro ejemplo de temperaturas, veamos cómo leer todo el contenido
del fichero de una sola vez. Para esta operación, Python nos provee, al menos, de dos
funciones:

read() Devuelve todo el contenido del fichero como una cadena de texto (str):

11
readlines() Devuelve todo el contenido del fichero como una lista (list) donde cada
elemento es una línea:

Importante: Nótese que, en ambos casos, los saltos de línea \n siguen apareciendo en
los datos leídos, por lo que habría que «limpiar» estos caracteres. Para ello es posible
utilizar las funciones ya vistas de cadenas de texto.

Lectura línea a línea

Hay situaciones en las que interesa leer el contenido del fichero línea a línea.
Imaginemos un fichero de tamaño considerable (varios GB). Si intentamos leer
completamente este fichero de una vez podríamos ocupar demasiada RAM y reducir
el rendimiento de la máquina.

Es por ello que Python nos ofrece varias aproximaciones a la lectura de ficheros línea
a línea. La más usada es iterar sobre el propio manejador del fichero:

11
Truco: Igual que pasaba anteriormente, la lectura línea por línea también incluye el
salto de línea \n lo que provoca un «doble espacio» entre cada una de las salidas.
Bastaría con aplicar line.split() para eliminarlo.

5.2 Escritura en un fichero

Para escribir texto en un fichero hay que abrir dicho fichero en modo escritura. Para
ello utilizamos un argumento adicional en la función open() que indica esta operación:

Nota: Si bien el fichero en sí mismo se crea al abrirlo en modo escritura, la ruta hasta
ese fichero no. Eso quiere decir que debemos asegurarnos de que las carpetas hasta
llegar a dicho fichero existen. En otro caso obtenemos un error de tipo
FileNotFoundError.

Ahora ya podemos hacer uso de la función write() para que enviar contenido al fichero
abierto. Supongamos que queremos volcar el contenido de una lista en dicho fichero.
En este caso partimos de los códigos IATA de aeropuertos de las Islas Canarias 35.

Nótese:

Línea 4 Escritura de cada código en el fichero. La función write() no incluye el salto de

línea por defecto, así que lo añadimos de manera explícita.

Línea 7 Cierre del fichero con la función close(). Especialmente en el caso de la escritura
de ficheros, se recomienda encarecidamente cerrar los ficheros para evitar pérdida de
datos.

35
Fuente: Smart Drone

11
Advertencia: Siempre que se abre un fichero en modo escritura utilizando el
argumento 'w', el fichero se inicializa, borrando cualquier contenido que pudiera tener.

5.3 Añadido a un fichero

La única diferencia entre añadir información a un fichero y escribir información en un
fichero es el modo de apertura del fichero. En este caso utilizamos 'a' por «append»:

En este caso el fichero more-data.txt se abrir en modo añadir con lo que las llamadas
a la función write() hará que aparezcan nuevo contenido al final del contenido ya
existente en dicho fichero.

5.4 Usando contextos

Python ofrece gestores de contexto que permiten establecer reglas de entrada y salida
al contexto definido. En el caso que nos ocupa, usaremos la sentencia with y el contexto
creado se ocupará de cerrar adecuadamente el fichero que hemos abierto, liberando
así sus recursos:

Línea 1 Apertura del fichero en modo lectura utilizando el gestor de contexto definido
por la palabra reservada with.

Línea 2 Lectura del fichero línea a línea utilizando la iteración sobre el manejador del
fichero.

Línea 3 Limpieza de saltos de línea con strip() encadenando la función split() para
separar las dos temperaturas por el caracter espacio. Ver limpiar una cadena y dividir
una cadena.

Línea 4 Imprimir por pantalla la temperatura mínima y la máxima.

11
Nota: Es una buena práctica usar with cuando se manejan ficheros. La ventaja es que
el fichero se cierra adecuadamente en cualquier circunstancia, incluso si se produce
cualquier tipo de error.

Hay que prestar atención a la hora de escribir valores numéricos en un fichero, ya que
el método write() por defecto espera ver un «string» como argumento:

Importante: Para evitar este tipo de errores, se debe convertir a str aquellos valores
que queramos usar con la función write() para escribir información en un fichero de
texto.

Ampliar conocimientos
o Reading and Writing Files in Python

o Python Context Managers and the «with» Statement

11
Capítulo 6: Modularidad
La modularidad es la característica de un sistema que permite que sea estudiado, visto
o entendido como la unión de varias partes que interactúan entre sí y que trabajan
solidariamente para alcanzar un objetivo común, realizando cada una de ellas una
tarea necesaria para la consecución de dicho objetivo.

Cada una de esas partes en que se encuentre dividido el sistema recibe el nombre de
módulo. Ideal- mente un módulo debe poder cumplir las condiciones de caja negra,
es decir, ser independiente del resto de los módulos y comunicarse con ellos (con
todos o sólo con una parte) a través de entradas y salidas bien definidas. 36

En este capítulo veremos las facilidades que nos proporciona Python para trabajar en
la línea de modularidad del código.

1. Funciones

Foto original por Nathan Dumlao en Unsplash.

Hasta ahora todo lo que hemos hecho han sido breves fragmentos de código Python.
Esto puede ser razonable para pequeñas tareas, pero nadie quiere reescribir los
fragmentos de código cada vez. Necesitamos una manera de organizar nuestro código
en piezas manejables.

36
Definición de modularidad en Wikipedia

11
El primer paso para la reutilización de código es la función. Se trata de un trozo de
código con nombre y separado del resto. Puede tomar cualquier número y tipo de
parámetros y devolver cualquier número y tipo de resultados.

Básicamente podemos hacer dos cosas con una función:

o Definirla (con cero o más parámetros).

o Invocarla (y obtener cero o más resultados).

1.1 Definir una función

Para definir una función en Python debemos usar la palabra reservada def seguida del
nombre de la función con paréntesis rodeando a los parámetros de entrada y
finalmente dos puntos :

Advertencia: Prestar especial atención a los dos puntos : porque suelen olvidarse en la
definición de la función.

Figura 19: Definición de una función en Python

Hagamos una primera función sencilla que no recibe parámetros:

o Nótese la indentación (sangrado) del cuerpo de la función.

o Los nombres de las funciones siguen las mismas reglas que las variables.

Invocar una función

Para invocar (o «llamar») a una función basta con escribir su nombre y utilizar
paréntesis. En el caso de la función sencilla (vista anteriormente) se haría así:

11
Como era de esperar, al invocar a la función obtenemos un mensaje por pantalla, fruto
de la ejecución del cuerpo de la función.

Retornar un valor
Las funciones pueden retornar (o «devolver») un valor. Veamos un ejemplo muy
sencillo:

Pero no sólo podemos invocar a la función directamente, también la podemos integrar

en otras expresiones. Por ejemplo, en condicionales:

Nota: En la sentencia return podemos incluir variables y expresiones, no únicamente

literales.

En aquellos casos en los que una función no tenga un return explícito, siempre
devolverá None.

12
 1.2 Parámetros y argumentos
Vamos a empezar a crear funciones que reciben parámetros. En este caso escribiremos
una función echo() que recibe el parámetro anything y muestra esa variable dos veces
separada por un espacio:

Nota: En este caso, 'Is anybody out there?' es un argumento de la función.

Cuando llamamos a una función con argumentos, los valores de estos argumentos se
copian en los correspondientes parámetros dentro de la función:

Figura 20: Parámetros y argumentos de una función

Truco: La sentencia pass permite «no hacer nada». Es una especie de «placeholder».

Veamos otra función con algo más de lógica de negocio: 37

37
Término para identificar el «algoritmo» o secuencia de instrucciones derivadas del
procesamiento que corresponda.

12
Argumentos posicionales
Los argumentos posicionales son aquellos argumentos que se copian en sus
correspondientes parámetros en orden. Vamos a mostrar un ejemplo definiendo una
función que construye y devuelve un diccionario a partir de los argumentos recibidos:

Una posible llamada a la función con argumentos posicionales sería la siguiente:

Lo que ha sucedido es un mapeo directo entre argumentos y parámetros en el mismo

orden que estaban definidos:

Argumento Parámetro
Flor de chasna wine
Garbanzas entree
Quesillo dessert

Nota: Una clara desventaja del uso de argumentos posicionales es que se necesita
recordar el significado de cada posición.

12
Argumentos por nombre
Para evitar la confusión que pueden producir los argumentos posicionales, es posible
especificar argumentos usando el nombre de los correspondientes parámetros, incluso
en un orden distinto a cómo están definidos en la función:

Incluso podemos mezclar argumentos posicionales y argumentos por nombre:

Nota: Si se llama a una función mezclando argumentos posicionales y por nombre, los
argumentos posicionales deben ir primero.

Parámetros por defecto

Es posible especificar valores por defecto en los parámetros de una función. El valor
por defecto se usará cuando en la llamada a la función no se haya proporcionado el
correspondiente argumento.

Supongamos que nos gusta mucho el Tiramisú. Podemos especificar en la definición

de la función que, si no se especifica el postre, éste sea siempre Tiramisú:

Llamada a la función sin especificar postre:

Llamada a la función indicando un postre concreto:

12
Importante: Los valores por defecto en los parámetros se calculan cuando se define la
función, no cuando se ejecuta.

1.3 Documentación
Ya hemos visto que en Python podemos incluir comentarios para explicar mejor
determinadas zonas de nuestro código.

Del mismo modo podemos (y en muchos casos debemos) adjuntar documentación a

la definición de una función incluyendo una cadena de texto (docstring) al comienzo
de su cuerpo:

La forma más ortodoxa de escribir un docstring es utilizando triples comillas:

Para ver el docstring de una función, basta con utilizar help:

Explicación de parámetros
Como ya se ha visto es posible documentar una función utilizando un docstring. Pero
la redacción y el formato de esta cadena de texto puede ser muy variada. Existen

12
distintas formas de documentar una función (u otros objetos) 38 pero vamos a
centrarnos en el modelo NumPy/SciPy.

Este modelo se basa en:

o Una primera línea de descripción de la función.

o A continuación, especificamos las características de los parámetros (incluyendo

sus tipos) usando el encabezado Parameters.

o Por último, si la función retorna un valor, lo indicamos con el encabezado

Returns.

Veamos un ejemplo:

38
Véase Docstring Formats

12
 1.4 Espacios de nombres
Un nombre puede hacer referencia a múltiples cosas, dependiendo de dónde lo
estemos usando. Los programas en Python tienen diferentes espacios de nombres,
secciones donde un nombre particular es único e independiente del mismo nombre
en otros espacios de nombres.

Cada función define su propio espacio de nombres. Si se define una variable x en el

programa principal y otra variable x dentro de una función, hacen referencia a cosas
diferentes. Dicho esto, también es posible (aunque desaconsejado) acceder al espacio
de nombres global dentro de las funciones.

En el siguiente ejemplo se define una variable global (primer nivel) y luego mostramos
su valor directamente y mediante una función:

Ejecución paso a paso a través de Python Tutor:

https://cutt.ly/3fMI8de

Sin embargo, si creamos una variable dentro de la función que también tenga el
nombre animal, realmente estaremos creando una nueva variable distinta de la global:

Ejecución paso a paso a través de Python Tutor:

https://cutt.ly/ifMOeYf

12
Ejercicio
Primera parte

Escriba una función factorial que reciba un único parámetro n y devuelva su factorial.

El factorial de un número n se define como:

�! = � · (� − 1) · (� − 2) · . . . · 1

Ejemplo

o Entrada: 5

o Salida: 120

Ampliar conocimientos
o Defining Your Own Python Function

o Python args and kwargs: Demystified

o Documenting Python Code: A Complete Guide

o Thinking Recursively in Python

o Writing Comments in Python

12
 2. Módulos

Foto original por Xavi Cabrera en Unsplash.

Es una certeza que, antes o después, usaremos código Python en más de un fichero.
Un módulo es simplemente un fichero con código Python. No se necesita hacer nada
especial. Cualquier código Python se puede usar como un módulo en código de
terceros.

2.1 Importar un módulo

Para hacer uso del código de otros módulos usaremos la sentencia import. Esto
permite importar el código y las variables de dicho módulo para que estén disponibles
en tu programa.

La forma más sencilla de importar un módulo es import <module> donde module es

el nombre de otro fichero Python, sin la extensión .py.

Supongamos que partimos del siguiente fichero (módulo):

arith.py

12
Desde otro fichero - en principio en la misma carpeta - podríamos hacer uso de las
funciones definidas en arith.py.

Importar módulo completo

Desde otro fichero haríamos lo siguiente para importar todo el contenido del módulo
arith.py:

Nota: Nótese que en la línea 3 debemos anteponer a la función addere() el espacio de

nombres que define el módulo arith.

Importar partes de un módulo

Es posible que no necesitemos todo aquello que está definido en arith.py.
Supongamos que sólo vamos a realizar divisiones. Para ello haremos lo siguiente:

12
Nota: Nótese que en la línea 3 ya podemos hacer uso directamente de la función
partitus() porque la hemos importado directamente. Este esquema tiene el
inconveniente de la posible colisión de nombres, en aquellos casos en los que
tuviéramos algún objeto con el mismo nombre que el objeto que estamos importando.

2.2 Paquetes
Un paquete es simplemente una carpeta que contiene ficheros .py. Además, permite
tener una jerarquía con más de un nivel de subcarpetas anidadas.

Para ejemplificar vamos a crear un paquete llamado mymath que contendrá 2

módulos:

o arith.py para operaciones aritméticas (ya visto anteriormente).

o logic.py para operaciones lógicas.

El código del módulo de operaciones lógicas es el siguiente:

logic.py

Si nuestro código principal va a estar en un fichero main.py (a primer nivel), la

estructura de ficheros nos quedaría tal que así:

13
Línea 2 Punto de entrada de nuestro programa a partir del fichero main.py

Línea 3 Carpeta que define el paquete mymath.

Línea 4 Módulo para operaciones aritméticas.

Línea 5 Módulo para operaciones lógicas.

Importar desde un paquete

Si ya estamos en el fichero main.py (o a ese nivel) podremos hacer uso de nuestro
paquete de la siguiente forma:

Línea 1 Importar los módulos arith y logic del paquete mymath

Línea 3 Uso de la función pullulate que está definida en el módulo arith

Línea 5 Uso de la función et que está definida en el módulo logic

2.3 Programa principal

Cuando decidimos hacer una pieza de software en Python, normalmente usamos
distintos ficheros para ello. Algunos de esos ficheros se convertirán en módulos, otros
se englobarán en paquetes y existirá uno en concreto que será nuestro punto de
entrada, también llamado programa principal.

Consejo: Suele ser una buena práctica llamar main.py al fichero que contiene nuestro
programa principal.

La estructura que suele tener este programa principal es la siguiente:

13
Importante: Si queremos ejecutar este fichero main.py desde línea de comandos,
tendríamos que hacer:

if name == ' main '

Esta condición permite, en el programa principal, diferenciar qué código se lanzará

cuando el fichero se ejecuta directamente o cuando el fichero se importa desde otro
lugar.

Figura 21: Comportamiento de un programa principal al importarlo o ejecutarlo

import hello El código se ejecuta siempre desde la primera instrucción a la última:

o Línea 1: se importa el módulo blabla.

o Línea 4: se define la función myfunc() y estará disponible para usarse.

13
 o Línea 9: esta condición no se cumple, ya que estamos importando y la variable
especial name no toma ese valor. Con lo cual finaliza la ejecución.

o No hay salida por pantalla.

$ python3 hello.py El código se ejecuta siempre desde la primera instrucción a la

última:

o Línea 1: se importa el módulo blabla.

o Línea 4: se define la función myfunc() y estará disponible para usarse.

o Línea 9: esta condición sí se cumple, ya que estamos ejecutando directamente

el fichero (como programa principal) y la variable especial ___name toma
el valor ____main .

o Línea 10: salida por pantalla de la cadena de texto Entry point.

o Línea 11: llamada a la función myfunc() que muestra por pantalla Inside myfunc,
además de invocar a la función hi() del módulo blabla.

Ampliar conocimientos
o Defining Main Functions in Python

o Python Modules and Packages: An Introduction

o Absolute vs Relative Imports in Python

o Running Python Scripts

o Writing Beautiful Pythonic Code With PEP 8

o Python Imports 101

13
Contenidos creados por:

Sergio Delgado Quintero

Maquetado por:

13