Manual Python EEST Nº 2

Introducción 3 1
1.1 Hablando con la máquina . . . . . . . . . . . . . . . . . . . . . . . . . . . . 3 1.2 Algo de historia . . . . . . .
..........................7

1.3 Python . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 13

2 Entornos de desarrollo 23 2.1 Thonny . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 24

2.2 Contexto real . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 28 2.3 VSCode . . . . . . . . . . . . . . . .

. . . . . . . . . . . . . . . . . . . . . . 37

3 Tipos de datos 47 3.1 Datos . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 48

3.2 Números . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 60 3.3 Cadenas de texto . . . . . . . . .

. . . . . . . . . . . . . . . . . . . . . . . . 75

4 Control de flujo 101 4.1 Condicionales . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 102

4.2 Bucles . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 124

5 Estructuras de datos 141 5.1 Listas . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 142

5.2 Tuplas . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 172 5.3 Diccionarios . . . . . . . . . . . . . .

. . . . . . . . . . . . . . . . . . . . . 179 5.4 Conjuntos . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 197
5.5 Ficheros . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 206

6 Modularidad 217 6.1 Funciones . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 218

6.2 Objetos y Clases . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 265 6.3 Excepciones . . . . . . . . . .
. . . . . . . . . . . . . . . . . . . . . . . . . 310

i
6.4 Módulos.......................................................................................................................... 318 7
Procesamiento de texto...................................................................................................330
7.1 re..................................................................................................................................... 330
7.2 string ............................................................................................................................... 335 8
Ciencia de datos..............................................................................................................339
8.1 jupyter............................................................................................................................. 339
8.2 numpy............................................................................................................................. 364
8.3 pandas............................................................................................................................. 407
8.4 matplotlib ....................................................................................................................... 476 9
Scraping ..........................................................................................................................519
9.1 requests.......................................................................................................................... 519
9.2 beautifulsoup.................................................................................................................. 528
9.3 selenium.......................................................................................................................... 543

ii
 Aprende Python

Curso gratuito para aprender el lenguaje de programación Python con un enfoque práctico,
incluyendo ejercicios y cobertura para distintos niveles de conocimiento.1
Este proyecto va de la mano con pycheck una herramienta que permite trabajar todos los
ejercicios propuestos con casos de prueba incluidos y verificación de los resultados.
Licencia: Creative Commons Reconocimiento 4.0 Internacional: CC BY 4.0.

Consejo: «Programming is not about typing, it’s about thinking.» – Rich Hickey 2 Core

CAPÍTULO 1

1
En la foto de portada aparecen los Monty Python. Fuente: noticiascyl

Core
1
Aprende Python
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.1 Hablando con la máquina

Aprende Python
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.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 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.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»:
SYS_SALIDA equ 1

section .data msg db "Hello, World",0x0a

len equ $ - msg ;longitud de msg

section .text global _start ;para el

linker
_start: ;marca la entrada
mov eax, 4 ;llamada al sistema (sys_write)

(continué en la próxima página) 1 Foto original por Garett Mizunaka en Unsplash.

Capítulo 1. Introducción
Aprende Python
4
(proviene de la página anterior)
mov ebx, 1 ;descripción de archivo (stdout) mov ecx,
msg ;msg a escribir mov edx, len ;longitud del
mensaje int 0x80 ;llama al sistema de interrupciones

fin: mov eax, SYS_SALIDA ;llamada al sistema (sys_exit) int 0x80

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.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:
#include <stdio.h>

int main() { printf("Hello,

World");
return 0;
}

1.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:
print(Hello, World)

¡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.

4 Capítulo 1. Introducción
Aprende Python
1.1. Hablando con la máquina
1.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.
 Figura 1: Esquema de funcionamiento de un compilador2

En el caso particular de Python el proceso de compilación genera un código intermedio

denominado bytecode. Si partimos del ejemplo anterior:
print(Hello, World)

el programa se compilaría3 al siguiente «bytecode»:

0 0 RESUME 0

1
2 PUSH_NULL
4 LOAD_NAME 0 (print)
6 LOAD_CONST 0 (Hello, World)

8 PRECALL 1

2
Iconos originales por Flaticon.
3
Véase más información sobre el intérprete de bytecode.
5
Aprende Python
RETURN_VALUE
12 CALL
1
22

A continuación estas instrucciones básicas son ejecutadas por el intérprete de «bytecode» de

Python (o máquina virtual).
Nota: Si queremos ver una diferencia entre un lenguaje compilado como C y un lenguaje
«interpretado» como Python es que, aunque ambos realizan un proceso de traducción del
código fuente, la compilación de C genera un código objeto que debe ser ejecutado en una
segunda fase explícita, mientras que la compilación de Python genera un «bytecode» que se
ejecuta (interpreta) de forma aparentemente simultánea.

1.2 Algo de historia

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)conelapoyodeLadyAdaCountessofLovelace(1815-1852),primerapersonaque 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
1
Foto original por Dario Veronesi en Unsplash.
6 Capítulo 1. Introducción
Aprende Python
1.2. Algo de historia
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:

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

Ada Lovelace Matemática, informática y escritora británica. XVII

Primera programadora de la historia por el
desarrollo de algoritmos para la máquina analítica
de Babbage

George Boole Contribuyó al algebra binaria y a los sistemas de 1854

circuitos de computadora (álgebra booleana)

Herman Hollerit Creador de un sistema para automatizar la 1890

pesada tarea del censo

Alan Turing Máquina de Turing - una máquina capaz de resolver 1936

problemas - Aportes de Lógica Matemática
- Computadora con tubos de vacío

John Atanasoff Primera computadora digital electrónica patentada: 1942

Atanasoff Berry Computer (ABC)

Howard Aiken En colaboración con IBM desarrolló el Mark I, una 1944

computadora electromecánica de 16 metros de largo
y más de dos de alto que podía realizar las cuatro
operaciones básicas y trabajar con información
almacenada en forma de tablas

Grace Hopper Primera programadora que utilizó el Mark I 1945

John W. Mauchly Junto a John Presper Eckert desarrolló una 1946

computadora electrónica completamente
operacional a gran escala llamada Electronic
Numerical Integrator And Computer (ENIAC)

John Von Neumann Propuso guardar en memoria no solo la información, 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
microprocesadordeIntel;yen1973elprimersistemaoperativoCP/M.Elprimercomputador personal
es comercializado por IBM en el año 1980.
2
Fuente: Meatze.

7
Aprende Python
 Figura 2: Ada Lovelace: primera programadora de la historia2

1.2. Algo de historia

1.2.2 De los computadores a la programación
De acuerdo a 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
8 Capítulo 1. Introducción
Aprende Python
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.
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.4

1.2.3 Cronología de lenguajes de programación

Desde la década de 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:
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.

1.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:5

Tabla 2: Creadores 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

continué en la próxima página

Tabla 2 – proviene de la página anterior
Personaje Aporte

Anders Hejlsberg Desarrollador de Turbo Pascal, Delphi y C#

4
Fuente: Universidad Técnica del Norte.
5
Fuente: Wikipedia.
9
Aprende Python
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++

Dennis Ritchie Inventor del lenguaje C y del Sistema Operativo Unix

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

Edsger W. Dijkstra Desarrolló las bases para la programación estructurada.

Algoritmo de caminos mínimos

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. Co-desarrollador de J junto a Roger Hui

Larry Wall Creador de Perl y Perl 6

Martin Odersky CreadordeScala.PreviamentecontribuyóeneldiseñodeJava

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 Capítulo 1. Introducción
Aprende Python
1.2. Algo de historia

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

1.3 Python
 1
1
Aprende Python
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.6

1.3.1 Características del lenguaje

A partir de su definición de la Wikipedia:
• Python es un lenguaje de programación interpretado y multiplataforma cuya filosofía hace
hincapié en una sintaxis que favorezca un código legible.
• 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.
• Añadiría, como característica destacada, que se trata de un lenguaje de propósito general.
Ventajas

• Libre y gratuito (OpenSource).

• Fácil de leer, parecido a pseudocódigo.
• Aprendizaje relativamente fácil y rápido: claro, intuitivo….
• Alto nivel.
• Alta Productividad: simple y rápido.
 • Tiende a producir un buen código: orden, limpieza, elegancia, flexibilidad, …
• Multiplataforma. Portable.
• Multiparadigma: programación imperativa, orientada a objetos, funcional, …
• Interactivo, modular, dinámico.
• Librerías extensivas («pilas incluídas»).
• Gran cantidad de librerías de terceros.

6
Foto original por Markéta Marcellová en Unsplash.

1.3. Python
12 Capítulo 1. Introducción
Aprende Python
• Extensible (C++, C, …) y «embebible».
• Gran comunidad, amplio soporte.
• Interpretado.
• Tipado dinámico7.
• Fuertemente tipado8.

Desventajas

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

• Consumo de memoria.
• Errores durante la ejecución.
• Dos versiones mayores no del todo compatibles (v2 vs v3).
• Desarrollo móvil.
• Documentación a veces dispersa e incompleta.
• Varios módulos para la misma funcionalidad.
• Librerías de terceros no siempre del todo maduras.
7
Tipado dinámico significa que una variable puede cambiar de tipo durante el tiempo de vida de un programa. C es
un lenguaje de tipado estático.
8
Fuertemente tipado significa que, de manera nativa, no podemos operar con dos variables de tipos distintos, a
menos que realice una conversión explícita. Javascript es un lenguaje débilmente tipado.
13
Aprende Python
1.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:
• Análisis de datos.
• Aplicaciones de escritorio.
• Bases de datos relacionales / NoSQL
• Buenas prácticas de programación / Patrones de diseño.
• Concurrencia.
• Criptomonedas / Blockchain.
• Desarrollo de aplicaciones multimedia.
• Desarrollo de juegos.
• Desarrollo en dispositivos embebidos.
• Desarrollo web.
• DevOps / Administración de sistemas / Scripts de automatización.
• Gráficos por ordenador.
• Inteligencia artificial.
 • Internet de las cosas.
• Machine Learning.
• Programación de parsers / scrapers / crawlers.
• Programación de redes.
• Propósitos educativos.
• Prototipado de software.
• Seguridad.
• Tests automatizados.
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:
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
marzo de 2023 en el que Python ocupaba el primer lugar de los lenguajes de programación más
usados, por delante de C y Java.

14 Capítulo 1. Introducción
Aprende Python

Figura 4: Grandes empresas y organismos que usan Python

 Figura 5: Índice TIOBE 2023
Igualmente en la encuesta a desarrolladores de Stack Overflow hecha en 2022, Python ocupaba
el cuarto puesto de los lenguajes de programación más populares, sólo por detrás de
Javascript, HTML/CSS y SQL:

1.3. Python 15
Aprende Python

Figura 6: Encuesta Stack Overflow 2022

1.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:9
Versión Fecha de lanzamiento
 Python 1.0 Enero 1994

Python 1.5 Diciembre 1997

Python 1.6 Septiembre 2000

Python 2.0 Octubre 2000

Python 2.1 Abril 2001

Python 2.2 Diciembre 2001

Python 2.3 Julio 2003

Python 2.4 Noviembre 2004

Python 2.5 Septiembre 2006

Python 2.6 Octubre 2008

Python 2.7 Julio 2010

Python 3.0 Diciembre 2008

Python 3.1 Junio 2009

Python 3.2 Febrero 2011

Python 3.3 Septiembre 2012

Python 3.4 Marzo 2014

Python 3.5 Septiembre 2015

continué en la próxima página

Tabla 3 – proviene de la página anterior

9
Fuente: python.org.

16 Capítulo 1. Introducción
Aprende Python
Versión Fecha de lanzamiento

Python 3.6 Diciembre 2016

Python 3.7 Junio 2018

Python 3.8 Octubre 2019

Python 3.9 Octubre 2020

Python 3.10 Octubre 2021

 Python 3.11 Octubre 2022

Python 3.12 Octubre 2023 ?

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:
• Si aún desarrollas aplicaciones escritas en Python 2, deberías migrar a Python 3. • Si
vas a desarrollar una nueva aplicación, deberías hacerlo directamente en Python 3.

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

1.3.4 CPython
Nivel avanzado
Existen múltiples implementaciones de Python según el lenguaje de programación que se ha
usado para desarrollarlo. Veamos algunas de ellas:
Implementación Lenguaje

CPython C

Jython Java

IronPython C#

Brython JavaScript

RustPython Rust

MicroPython C

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

Nota: Cuando hacemos referencia a Python hablamos (implícitamente) de CPython. Este manual
versa exclusivamente sobre CPython.

1.3. Python 17
Aprende Python
1.3.5 Zen de Python
Existen una serie de reglas «filosóficas» que indican una manera de hacer y de pensar dentro del
mundo pitónico2 creadas por Tim Peters, llamadas el Zen de Python y que se pueden aplicar
incluso más allá de la programación:
>>> import this
The Zen of Python, by Tim Peters

Beautiful is better than ugly.

Explicit is better than implicit.
Simple is better than complex.
Complex is better than complicated.
Flat is better than nested.
Sparse is better than dense.
Readability counts.
Special cases aren t special enough to break the rules.
Although practicality beats purity.
Errors should never pass silently.
Unless explicitly silenced.
In the face of ambiguity, refuse the temptation to guess.
There should be one-- and preferably only one --obvious way to do it.
Although that way may not be obvious at first unless you re Dutch.
Now is better than never.
Although never is often better than *right* now.
If the implementation is hard to explain, it s a bad idea.
If the implementation is easy to explain, it may be a good idea.
Namespaces are one honking great idea -- let s do more of those!

En su traducción de la Wikipedia:
• Bello es mejor que feo.
• Explícito es mejor que implícito.
• Simple es mejor que complejo.
• Complejo es mejor que complicado.
• Plano es mejor que anidado.
• Espaciado es mejor que denso.
2
Dícese de algo/alguien que sigue las convenciones de Python.
• La legibilidad es importante.

18 Capítulo 1. Introducción
Aprende Python
• Los casos especiales no son lo suficientemente especiales como para romper las reglas.
 • Sin embargo la practicidad le gana a la pureza.
• Los errores nunca deberían pasar silenciosamente.
• A menos que se silencien explícitamente.
• Frente a la ambigüedad, evitar la tentación de adivinar.
• Debería haber una, y preferiblemente solo una, manera obvia de hacerlo. • A
pesar de que esa manera no sea obvia a menos que seas Holandés. • Ahora es
mejor que nunca.
• A pesar de que nunca es muchas veces mejor que ahora mismo.
• Si la implementación es difícil de explicar, es una mala idea.
• Si la implementación es fácil de explicar, puede que sea una buena idea. • Los espacios
de nombres son una gran idea, ¡tengamos más de esos! Ver también:
Si quieres darle un toque a tu escritorio, puedes descargar este fondo de pantalla del Zen de
Python que queda muy chulo.

1.3.6 Consejos para programar

Un listado de consejos muy interesantes cuando nos enfrentamos a la programación, basados en
la experiencia de @codewithvoid:
1. Escribir código es el último paso del proceso.
2. Para resolver problemas: pizarra mejor que teclado.
3. Escribir código sin planificar = estrés.
4. Pareces más inteligente siendo claro, no siendo listo.
5. La constancia a largo plazo es mejor que la intensidad a corto plazo.
6. La solución primero. La optimización después.
7. Gran parte de la programación es resolución de problemas.
8. Piensa en múltiples soluciones antes de decidirte por una.
9. Se aprende construyendo proyectos, no tomando cursos.
10. Siempre elije simplicidad. Las soluciones simples son más fáciles de escribir. 11. Los
errores son inevitables al escribir código. Sólo te informan sobre lo que no debes hacer.

1.3. Python 19
Aprende Python
12. Fallar es barato en programación. Aprende mediante la práctica.
13. Gran parte de la programación es investigación.
14. La programación en pareja te enseñará mucho más que escribir código tu solo.
15. Da un paseo cuando estés bloqueado con un error.
16. Convierte en un hábito el hecho de pedir ayuda. Pierdes cero credibilidad pidiendo ayuda.
17. El tiempo gastado en entender el problema está bien invertido.
18. Cuando estés bloqueado con un problema: sé curioso, no te frustres. 19. Piensa en
posibles escenarios y situaciones extremas antes de resolver el problema. 20. No te
estreses con la sintaxis de lenguaje de programación. Entiende conceptos. 21. Aprende
a ser un buen corrector de errores. Esto se amortiza.
22. Conoce pronto los atajos de teclado de tu editor favorito.
23. Tu código será tan claro como lo tengas en tu cabeza.
24. Gastarás el doble de tiempo en corregir errores que en escribir código.
25. Saber buscar bien en Google es una habilidad valiosa.
26. Lee código de otras personas para inspirarte.
27. Únete a comunidades de desarrollo para aprender con otros/as programadores/as.

20 Capítulo 1. Introducción

CAPÍTULO 2

Entornos 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.

2.1 Thonny

Thonny es un programa muy interesante para empezar a aprender Python, ya que engloba tres
de las herramientas fundamentales para trabajar con el lenguaje: intérprete, editor y
depurador.1

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éprete es lanzar instrucciones
«sueltas» para probar determinados aspectos.

21
Aprende Python
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).
Cuando nos encontramos con un programa que proporciona estas funciones (e incluso otras
adicionales)paraeltrabajodeprogramación,nosreferimosaélcomoun Entorno Integrado de
Desarrollo, conocido popularmente por sus siglas en inglés IDE (por Integrated Development 1
Foto original de portada por freddie marriage en Unsplash.

Environment). Thonny es un IDE gratuito, sencillo y apto para principiantes.

2.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á parecida a la
siguiente imagen:

22 Capítulo 2. Entornos de desarrollo

Aprende Python
Figura 1: 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:

• Panel principal que contiene el editor e incluye la etiqueta <untitled> donde escribiremos
nuestro código fuente Python.
• 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.
2.1. Thonny
• Panel derecho que contiene el depurador. Más concretamente se trata de la ventana de
variables donde podemos inspeccionar el valor de las mismas.

2.1.2 Probando el intérprete

El intérprete de Python (por lo general) se identifica claramente porque posee un prompt2 con
tres angulos 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
$ python3.7
Python 3.7.4 (v3.7.4:e09359112e, Jul 8 2019, 14:54:52)
[Clang 6.0 (clang-600.0.57)] on darwin Type "help", "copyright", "credits" or "license" for
more information.
>>>

Para hacer una prueba inicial 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:
>>> print(Hello, World)
Hello, World

23
Aprende Python
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
>>>).

2.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.py3:

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

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

Figura 2: Guardando nuestro primer programa en Python

Ahorayapodemos ejecutar nuestrofichero helloworld.py. Paraello pulsamos elbotó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.

24 Capítulo 2. Entornos de desarrollo

Aprende Python
2.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:
msg = Hello, World
print(msg)

Aunque ya lo veremos en profundidad, lo que hemos hecho es añadir 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

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

2.1. Thonny
sesión de depuración y podemos avanzar instrucción por instrucción usando la tecla F7:

Figura 3:
Depurando nuestro primer programa en Python

25
Aprende Python

2.2 Contexto real

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.1

2.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:
• Versiones de Python para Windows
• Versiones de Python para Mac
• Versiones de Python para Linux

Truco: Tutorial para instalar Python en Windows.

Anaconda

Otra de las alternativas para disponer de Python en nuestro sistema y que además es muy
utilizada, es Anaconda. Se trata de un conjunto de herramientas, orientadas en principio a la

26 Capítulo 2. Entornos de desarrollo

Aprende Python
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 su página web. Anaconda trae por defecto una gran cantidad de
paquetes Python en su distribución.
Ver también:
Miniconda es un instalador mínimo que trae por defecto Python y un pequeño número de
paquetes útiles.

2.2.2 Gestión de paquetes

La instalación limpia2 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,
1
Foto original de portada por SpaceX en Unsplash.
2
También llamada «vanilla installation» ya que es la que viene por defecto y no se hace ningúna
personalización.

2.2. Contexto real

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
$ pip install pandas
$ pip uninstall pandas
$ pip install pandas --upgrade

Consejo: Para el caso de Anaconda usaríamos conda install pandas (aunque ya viene
preinstalado).

2.2.3 Entornos virtuales

Nivel intermedio
27
Aprende Python
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. La manera más
sencilla de crear un entorno virtual es la siguiente:
 $ cd myproject
$ python -m venv --prompt myproject .venv
$ source .venv/bin/activate

• Línea 1: Entrar en la carpeta de nuestro proyecto.

• Línea 2: Crear una carpeta .venv con los ficheros que constituyen el entorno virtual.
• Línea 3: Activar el entorno virtual. A partir de aquí todo lo que se instale quedará dentro
del entorno virtual.

28 Capítulo 2. Entornos de desarrollo

Aprende Python
virtualenv

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:
$ pip install virtualenv
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:
$ pip install virtualenvwrapper

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

$ ~/project1 > mkvirtualenv env1
Using base prefix /Library/Frameworks/Python.framework/Versions/3.7
New python executable in /Users/sdelquin/.virtualenvs/env1/bin/python3.7
Also creating executable in /Users/sdelquin/.virtualenvs/env1/bin/python
Installing setuptools, pip, wheel... done.
virtualenvwrapper.user_scripts creating
/Users/sdelquin/.virtualenvs/env1/bin/ ,→predeactivate
virtualenvwrapper.user_scripts creating
/Users/sdelquin/.virtualenvs/env1/bin/ ,→postdeactivate virtualenvwrapper.user_scripts
creating /Users/sdelquin/.virtualenvs/env1/bin/ ,→preactivate
virtualenvwrapper.user_scripts creating /Users/sdelquin/.virtualenvs/env1/bin/
,→postactivate virtualenvwrapper.user_scripts creating

/Users/sdelquin/.virtualenvs/env1/bin/get_ ,→env_details

$ (env1) ~/project1 > pip install requests

Collecting requests
Using cached requests-2.24.0-py2.py3-none-any.whl (61 kB)
Collecting idna<3,>=2.5
Using cached idna-2.10-py2.py3-none-any.whl (58 kB)
Collecting certifi>=2017.4.17
Using cached certifi-2020.6.20-py2.py3-none-any.whl (156 kB)
Collecting urllib3!=1.25.0,!=1.25.1,<1.26,>=1.21.1
Using cached urllib3-1.25.10-py2.py3-none-any.whl (127 kB)
Collecting chardet<4,>=3.0.2
Using cached chardet-3.0.4-py2.py3-none-any.whl (133 kB)
Installing collected packages: idna, certifi, urllib3, chardet, requests
Successfully installed certifi-2020.6.20 chardet-3.0.4 idna-2.10
requests-2.24.0␣ ,→urllib3-1.25.10

(continué en la próxima página)

2.2. Contexto real 29

Aprende Python

(proviene de la página anterior)

$ (env1) ~/project1 > deactivate

 $ ~/project1 > workon env1
$ (env1) ~/project1 > lssitepackages

__pycache__ distutils-precedence.pth pkg_resources ␣ ,→urllib3-1.25.10.dist-info

_distutils_hack easy_install.py requests ␣ ,→wheel
certifi idna requests-2.24.0.dist-info ␣ ,→wheel-0.34.2.dist-info certifi-2020.6.20.dist-info
idna
2.10.dist-info setuptools
chardet pip setuptools-49.3.2.dist-info chardet-3.0.4.dist-info pip-20.2.2.dist-info $ (env1)
urllib3
~/project1 >

• $ mkvirtualenv env1: crea un entorno virtual llamado env1

• $ pip install requests: instala el paquete requests dentro del entorno virtual env1 • $
workon env1: activa el entorno virtual env1

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

pyenv permite cambiar fácilmente entre múltiples versiones de Python en un mismo sistema. Su
instalación engloba varios pasos y está bien explicada en la página del proyecto. La mayor
diferencia con respecto a virtualenv es que no instala las distintas versiones de Python a nivel
global del sistema. En vez de eso, se suele crear una carpeta .pyenv en el HOME del usuario,
donde todo está aislado sin generar intrusión en el sistema operativo.
Podemos hacer cosas como:
• Listar las versiones de Python instaladas:
$ pyenv versions
3.7.4 * 3.5.0 (set by /Users/yuu/.pyenv/version) miniconda3-3.16.0
pypy 2.6.0

• Descubrir la versión global «activa» de Python:

$ python --version
Python 3.5.0

• Cambiar la versión global «activa» de Python:

$ pyenv global 3.7.4

30 Capítulo 2. Entornos de desarrollo

Aprende Python
 $ python --version
Python 3.7.4

• Instalar una nueva versión de Python:

$ pyenv install 3.9.1 ...

• Activar una versión de Python local por carpetas:

$ cd /cool-project
$ pyenv local 3.9.1
$ python --version
Python 3.9.1

También existe un módulo denominado pyenv-virtualenv para manejar entornos virtuales

utilizando las ventajas que proporciona pyenv.

2.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 10 . 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:
– Eclipse + PyDev
– Sublime Text
– Atom
– GNU Emacs
– Vi-Vim
– Visual Studio (+ Python Tools) – Visual Studio Code (+ Python
Tools)
• Editores o IDEs específicos para Python:

10
Integrated Development Environment.

2.2. Contexto real 31

Aprende Python
– PyCharm
– Spyder
– Thonny
Cada editor tiene sus características (ventajas e inconvenientes). Supongo que la preferencia por
alguno de ellos estará en base a la experiencia y a las necesidades que surjan. La parte buena es
que hay diversidad de opciones para elegir.

2.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 o
«machine-learning»4.
Podemos verlo como un intérprete de Python (contiene un «kernel»5 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.
Aunque su uso está más extendido en el mundo Python, existen muchos otros «kernels» sobre
los que trabajar en Jupyter Notebook.
Ver también:
Sección sobre Jupyter.

Truco: Visual Studio Code también dispone de integración con Jupyter Notebooks.

2.2.6 repl.it
repl.it es un servicio web que ofrece un entorno de desarrollo integrado para programar en
más de 50 lenguajes (Python incluido).
Es gratuito y de uso colaborativo. Se requiere una cuenta en el sistema para utilizarlo. El hecho
de no requerir instalación ni configuración previa lo hace atractivo en determinadas
circunstancias.
En su versión gratuita ofrece:
4
Término inglés utilizado para hacer referencia a algoritmos de aprendizaje automático. 5 Proceso específico
para un lenguaje de programación que ejecuta instrucciones y actúa como interfaz de entrada/salida.

32 Capítulo 2. Entornos de desarrollo

Aprende Python
 Figura 4: repl.it

• Almacenamiento de 500MB.
• Python 3.8.2 (febrero de 2022).
• 117 paquetes preinstalados (febrero de 2022).
• Navegador (y subida) de ficheros integrado.
• Gestor de paquetes integrado.
• Integración con GitHub.
• Gestión de secretos (datos sensibles).
• Base de datos clave-valor ya integrada.
• Acceso (limitado) al sistema operativo y sistema de ficheros.

2.2.7 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 y preparar el entorno de desarrollo Python. Durante mucho
tiempo esto fue difícil de conseguir hasta que Microsoft sacó WSL.
WSL6 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 para un 6 Windows
Subsystem for Linux.

2.2. Contexto real 33

Aprende Python
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 WSL11 hay que seguir los siguientes pasos:

1. Lanzamos Powershell con permisos de administrador.

2. Activamos la característica de WSL:
$ Enable-WindowsOptionalFeature -Online -FeatureName
Microsoft-Windows- ,→Subsystem-Linux

3. Descargamos la imagen de Ubuntu 20.04 que usaremos:

$ Invoke-WebRequest -Uri https://aka.ms/wslubuntu2004 -OutFile
Ubuntu.appx - ,→UseBasicParsing

4. Finalmente, la instalamos:
$ Add-AppxPackage .\Ubuntu.appx

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

11
Tutorial de instalación de WSL.

34 Capítulo 2. Entornos de desarrollo

Aprende Python

2.3 VSCode
Visual Studio Code (VSCode) es un entorno de desarrollo integrado12 gratuito y de código abierto
que ha ganado mucha relevancia en los últimos años. Permite trabajar fácilmente con multitud
de lenguajes de programación y dispone de una gran cantidad de plugins.13

2.3.1 Atajos de teclado

Conocer los atajos de teclado de tu editor favorito es fundamental para mejorar el flujo de
trabajo y ser más productivo. Veamos los principales atajos de teclado de Visual Studio Code14.

Ajustes generales
Acción Atajo

Abrir paleta de comandos Ctrl + Shift + P

Abrir archivo Ctrl + P

Nueva ventana Ctrl + Shift + N

12
También conocido por IDE siglas en inglés de Integrated Development Environment.
13
Foto original de portada por Kelly Sikkema en Unsplash.
14
Fuente: Gastón Danielsen en Dev.To.

2.3. VSCode
35
Aprende Python
continué en la próxima página
 Tabla 1 – proviene de la página anterior
Acción Atajo

Cerrar ventana Ctrl + Shift + W

Ajustes del perfil Ctrl + ,

Usabilidad
Acción Atajo

Crear un nuevo archivo Ctrl + N

Abrir archivo Ctrl + O

Guardar archivo Ctrl + S

Cerrar Ctrl + F4

Abrir Terminal Ctrl +

Panel de problemas Ctrl + Shift + M

Edición básica
Acción Atajo

Cortar linea Ctrl + X

Copiar linea Ctrl + C

Borrar linea Ctrl + Shift + K

Insertar linea abajo Enter

Insertar linea arriba Ctrl + Shift + Enter

Buscar en archivo abierto Ctrl + F

Reemplazar Ctrl + H

Linea de comentario Ctrl + /

Bloque de comentario Shift + Alt + A

Salto de linea Alt + Z

Seleccionar lineas Alt + Click Mouse

Tabular linea Tab

Destabular linea Shift + Tab

Pantalla
Acción Atajo

Acercar Zoom Ctrl + +

Alejar Zoom Ctrl + -

Barra lateral Ctrl + B

Abrir debug Ctrl + Shift + D

Panel de salida Ctrl + Shift + U

Control de source Ctrl + Shift + G

Acceder a extensiones Ctrl + Shift + X

Abrir terminal integrado Ctrl + Shift + Ñ

Truco: En macOS sustituir Ctrl por Command.

36 Capítulo 2. Entornos de desarrollo
Aprende Python
2.3.2 Depurando código
La depuración de programas es el proceso de identificar y corregir errores de programación. Es
conocido también por el término inglés debugging, cuyo significado es eliminación de bugs
(bichos), manera en que se conoce informalmente a los errores de programación.
Existen varias herramientas de depuración (o debuggers). Algunas de ellas en modo texto
(terminal) y otras con entorno gráfico (ventanas).
• La herramienta más extendida para depurar en modo texto es el módulo pdb (The Python
Debugger). Viene incluido en la instalación base de Python y es realmente potente.
• Aunque existen varias herramientas para depurar en entorno gráfico, nos vamos a centrar
en Visual Studio Code.
Lo primero será abrir el fichero (carpeta) donde vamos a trabajar:

Punto de ruptura

A continuación pondremos un punto de ruptura (también llamado breakpoint). Esto implica que
la ejecución se pare en ese punto y viene indicado por un punto rojo . Para ponerlo nos
tenemos que acercar a la columna que hay a la izquierda del número de línea y hacer clic.
En este ejemplo ponemos un punto de ruptura en la línea 10:
 Figura 5: Apertura del fichero a depurar

2.3. VSCode 37
Aprende Python

Figura 6: Punto de ruptura

También es posible añadir puntos de ruptura condicionales pulsando con el botón derecho y
luego Add Conditional Breakpoint…:
 Figura 7: Punto de ruptura condicional

Lanzar la depuración

Ahora ya podemos lanzar la depuración pulsando la tecla F5. Nos aparecerá el siguiente mensaje
en el que dejaremos la opción por defecto Archivo de Python y pulsamos la tecla :

38 Capítulo 2. Entornos de desarrollo

Aprende Python

Figura 8: Configuración de la depuración

Ahora ya se inicia el «modo depuración» y veremos una pantalla similar a la siguiente:

 Figura 9: Interfaz en modo depuración

Zonas de la interfaz en modo depuración:

1. Código con barra en amarillo que indica la próxima línea que se va a ejecutar.
2. Visualización automática de valores de variables.
3. Visualización personalizada de valores de variables (o expresiones).
4. Salida de la terminal.

2.3. VSCode 39
Aprende Python
5. Barra de herramientas para depuración.

Controles para la depuración

Veamos con mayor detalle la barra de herramientas para depuración:

Acción Atajo Significado

Continue F5 Continuar la ejecución del programa hasta el próximo punto

de ruptura o hasta su finalización

Step over F10 Ejecutar la siguiente instrucción del programa

Step into F11 Ejecutar la siguiente instrucción del programa entrando en un

contexto inferior

Step out + F11 Ejecutar la siguiente instrucción del programa saliendo a un

contexto superior

continué en la próxima página

 Tabla 5 – proviene de la página anterior
Acción Atajo Significado

Restart + + F5 Reiniciar la depuración del programa

Stop + F5 Detener la depuración del programa

Seguimiento de variables

Como hemos indicado previamente, la zona de Variables ya nos informa automáticamente de

los valores de las variables que tengamos en el contexto actual de ejecución:
Pero también es posible añadir manualmente el seguimiento de otras variables o expresiones
personalizadas desde la zona Watch:

40 Capítulo 2. Entornos de desarrollo

Aprende Python
 Figura 10: Barra de herarmientas para depuración

Figura 11: Panel para visualizar variables

2.3. VSCode 41
Aprende Python
Figura 12: Panel para seguimiento de expresiones

42 Capítulo 2. Entornos de desarrollo

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.

3.1 Datos

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.15

15
Foto original de portada por Alexander Sinn en Unsplash.
43
Aprende Python
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:
• Un tipo del dato almacenado.
• Un identificador único para distinguirlo de otros objetos.
 • Un valor consistente con su tipo.

3.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 1: Esquema (metadatos) de un objeto en Python

44 Capítulo 3. Tipos de datos

Aprende Python
3.1. Datos
Tabla 1: 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 }

3.1.2 Variables
Las variables son fundamentales ya que permiten definir nombres para los valores que tenemos
en memoria y que vamos a usar en nuestro programa.

Figura 2: Uso de un nombre de variable

Reglas para nombrar variables

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

1. Sólo pueden contener los siguientes caracteres16:
• Letras minúsculas.
• Letras mayúsculas.
• Dígitos.
• Guiones bajos (_).
2. Deben empezar con una letra o un guión bajo, nunca con un dígito.
3. No pueden ser una palabra reservada del lenguaje («keywords»).

16
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.
45
Aprende Python
Podemos obtener un listado de las palabras reservadas del lenguaje de la siguiente forma:
 >>> help(keywords)

Here is a list of the Python keywords. Enter any keyword to get more help.

False class from or

None continue global pass
True def if raise and del import return
as elif in try
assert else is while async except lambda with
await finally nonlocal yield
break for not

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.

Importante: Los nombres de variables son «case-sensitive»3. Por ejemplo, stuff y Stuff son
nombres diferentes.

Ejemplos de nombres de variables

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

Tabla 2: 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 carácter no permitido

_abc with Es una palabra reservada del lenguaje

_3a 3_a Empieza por un dígito

3
Sensible a cambios en mayúsculas y minúsculas.
 46 Capítulo 3. Tipos de datos
Aprende Python
3.1. Datos
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 –.17 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 PEPs18 son las propuestas que se hacen
para la mejora del lenguaje.
Aunque hay múltiples herramientas disponibles para la comprobación del estilo de código,
unabastanteaccesibleeshttp://pep8online.com/yaquenonecesitainstalación,simplemente pegar
nuestro código y verificar.

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 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
17
Más información sobre convenciones de nombres en PEP 8.
18
Del término inglés «Python Enhancement Proposals».
47
Aprende Python
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 demasiado 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.
Como regla general:
• Usar nombres para variables (ejemplo article).
• Usar verbos para funciones (ejemplo get_article()).
• Usar adjetivos para booleanos (ejemplo available).

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

Figura 3: 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:

>>> total_population = 157503
>>> avg_temperature = 16.8
>>> city_name = San Cristóbal de La Laguna
 48 Capítulo 3. Tipos de datos
Aprende Python
Algunos ejemplos de asignaciones a constantes:

3.1. Datos
>>> SOUND_SPEED = 343.2
>>> WATER_DENSITY = 997
>>> EARTH_NAME = La Tierra

Python nos ofrece la posibilidad de hacer una asignación múltiple de la siguiente manera:
>>> tres = three = drei = 3

En este caso las tres variables utilizadas en el «lado izquierdo» tomarán el valor 3.
Recordemosquelosnombresdevariablesdebenseguirunas reglas establecidas,delocontrario
obtendremos un error sintáctico del intérprete de Python:
>>> 7floor = 40 # el nombre empieza por un dígito
File "<stdin>", line 1
7floor = 40
^
SyntaxError: invalid syntax

>>> for = Bucle # el nombre usa la palabra reservada "for"

File "<stdin>", line 1 for =
Bucle
^
SyntaxError: invalid syntax

>>> screen-size = 14 # el nombre usa un carácter no válido

File "<stdin>", line 1
SyntaxError: can t assign to operator

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:
>>> people = 157503

>>> total_population = people

>>> total_population
157503

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:
>>> total_population = lot_of_people
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
NameError: name lot_of_people is not defined

49
Aprende Python
De hecho, en el lado derecho de la asignación pueden aparecer expresiones más complejas que
se verán en su momento.

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:
>>> final_stock = 38934
>>> final_stock
38934

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

final_stock = 38934 print(final_stock)

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:
>>> type(9) int

>>> type(1.2) float

>>> height = 3718 >>>

type(height) int

>>> sound_speed = 343.2 >>>

type(sound_speed) float
Ejercicio
1. Asigna un valor entero 2001 a la variable space_odyssey y muestra su valor.

50 Capítulo 3. Tipos de datos

Aprende Python
2. Descubre el tipo del literal Good night & Good luck.
3. Identifica el tipo del literal True.
4. Asigna la expresión 10 * 3.0 a la variable result y muestra su tipo.

3.1.4 Mutabilidad
Nivel avanzado
Las variables son nombres, no lugares. Detrás de esta frase se esconde la reflexión de que
cuando asignamos un valor a una variable, lo que realmente está ocurriendo es que se hace
apuntar el nombre de la variable a una zona de memoria en el que se representa el objeto (con
su valor):
>>> a = 5

Figura 4: Representación de la asignación de valor a variable

Si ahora «copiamos» el valor de a en otra variable b se podría esperar que hubiera otro espacio
en memoria para dicho valor, pero como ya hemos dicho, son referencias a memoria:
>>> b = a

3.1. Datos 51
Aprende Python

Figura 5: Representación de la asignación de una variable a otra variable

La función id() nos permite conocer la dirección de memoria19 de un objeto en Python. A través
de ella podemos comprobar que los dos objetos que hemos creado «apuntan» a la misma zona
de memoria:
>>> id(a)
4445989712

>>> id(b)
4445989712

La prueba de que la zona de memoria no la ocupa el «nombre» de la variable, es que podemos

ver cómo se asigna una dirección de memoria únicamente al «valor» literal:
>>> id(10)
4333546384

>>> id(20)
4333546704
19
Esto es un detalle de implementación de CPython.

52 Capítulo 3. Tipos de datos

Aprende Python
Cada vez que asignamos un nuevo valor a una variable, ésta apunta a una nueva zona de
memoria:
>>> a = 5 >>> id(a)
4310690224

>>> a = 7 >>> id(a)

4310690288

Cuando la zona de memoria que ocupa el objeto se puede modificar hablamos de tipos de datos
mutables. En otro caso hablamos de tipos de datos inmutables.
Por ejemplo, las listas son un tipo de dato mutable ya que podemos modificar su contenido
(aunque la asignación de un nuevo valor sigue generando un nuevo espacio de memoria).
Ejecución paso a paso a través de Python Tutor:
https://cutt.ly/lvCyXeL
Tipos de objetos en Python según su naturaleza de cambio:
Inmutable Mutable

bool list

int set

float dict

str

tuple

Importante: El hecho de que un tipo de datos sea inmutable significa que no podemos
modificarsuvalor«in-situ»,perosiemprepodremosasignarleunnuevovalor(hacerloapuntar a otra
zona de memoria).

3.1.5 Funciones «built-in»

Nivel intermedio
Hemos ido usando una serie de funciones sin ser especialmente conscientes de ello. Esto se
debe a que son funciones «built-in» o incorporadas por defecto en el propio lenguaje Python.
 Tabla 3: Funciones «built-in»
abs() delattr() hash() memoryview() set()

all() dict() help() min() setattr()

any() any() hex() next() slice()

3.1. Datos 53
Aprende Python
ascii() divmod() id() object() sorted()

bin() enumerate() input() oct() staticmethod()

bool() eval() int() open() str()

breakpoint() exec() isinstance() ord() sum()

bytearray() filter() issubclass() pow() super()

bytes() float() iter() print() tuple()

callable() format() len() property() type()

chr() frozenset() list() range() vars()

classmethod() getattr() locals() repr() zip()

compile() globals() map() reversed() __import__()

complex() hasattr() max() round()

Los detalles de estas funciones se puede consultar en la documentación oficial de Python.

3.1.6 Pidiendo ayuda

En Python podemos pedir ayuda con la función help().
Supongamos que queremos obtener información sobre id. Desde el intérprete de Python
ejecutamos lo siguiente:
>>> help(id)
Help on built-in function id in module builtins:

id(obj, /)
Return the identity of an object.

This is guaranteed to be unique among simultaneously existing objects. (CPython uses

the object s memory address.)
Existe una forma alternativa de obtener ayuda: añadiendo el signo de interrogación ? al término
de búsqueda:
>>> id?
Signature: id(obj, /) Docstring:
Return the identity of an object.

This is guaranteed to be unique among simultaneously existing objects.

(CPython uses the object s memory address.)
Type: builtin_function_or_method

AMPLIAR CONOCIMIENTOS

• Basic Data Types in Python

• Variables in Python

54 Capítulo 3. Tipos de datos

Aprende Python
• Immutability in Python

3.2 Números

En esta sección veremos los tipos de datos númericos que ofrece Python centrándonos en
booleanos, enteros y flotantes.20

3.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:

20
Foto original de portada por Brett Jordan en Unsplash.

3.1. Datos 55
Aprende
Python
• True que se corresponde con verdadero (y también con 1 en su representación numérica).
• False que se corresponde con falso (y también con 0 en su representación numérica).
Veamos un ejemplo de su uso:

>>> is_opened = True

>>> is_opened
True

>>> has_sugar = False

>>> has_sugar
False

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.
Atención: 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.

>>> is_opened = true

Traceback (most recent call last): File
"<stdin>", line 1, in <module> NameError:
name true is not defined

>>> has_sugar = false

Traceback (most recent call last): File
"<stdin>", line 1, in <module>
NameError: name false is not defined
3.2. Números
3.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:

>>> 8
8
>>> 0
0

>>> 08

56 Capítulo 3. Tipos de datos

Aprende Python
File "<stdin>", line 1
08
^
SyntaxError: invalid token
>>> 99
99
>>> +99
99
>>> -99
-99
>>> 3000000
3000000
>>> 3_000_000
3000000

Dos detalles a tener en cuenta:

• No podemos comenzar un número entero por 0.
• Python permite dividir los números enteros con guiones bajos _ para clarificar su lectura/escritura.
Aefectos 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 4: Operaciones con enteros en Python
Operador Descripción Ejemplo Resultad
o

+ Suma 3+9 12

continué en la próxima página

Tabla 4 – proviene de la página anterior
Operador Descripción Ejemplo Resultad
o

- Resta 6-2 4

* Multiplicación 5*5 25

/ División flotante 9/2 4.5

// División entera 9 // 2 4

% Módulo 9%4 1

** Exponenciación 2 ** 4 16

Veamos algunas pruebas de estos operadores:

>>> 2 + 8 + 4
14
>>> 4 ** 4
256

57
Aprende
Python
>>> 7 / 3
2.3333333333333335 >>> 7 // 3
2
>>> 6 / 0
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
ZeroDivisionError: division by zero

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.
Igualmente es importante tener en cuenta la prioridad de los distintos operadores:
Prioridad Operador
 1 (mayor) ()

2 **

3 -a+a

4 *///%

5 (menor) +-

Ejemplos de prioridad de operadores:

>>> 2 ** 2 + 4 / 2
6.0

>>> 2 ** (2 + 4) / 2
32.0

(continué en la próxima página)

3.2. Números
(proviene de la página anterior)
>>> 2 ** (2 + 4 / 2)
16.0

Asignación aumentada

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

58 Capítulo 3. Tipos de datos

Aprende Python

Figura 6: 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

>>> total_cars = 100
>>> sold_cars = 20

>>> total_cars = total_cars - sold_cars

>>> total_cars
80

Lista 2: Asignación aumentada

>>> total_cars = 100
>>> sold_cars = 20

>>> total_cars -= sold_cars

>>> total_cars
80

Estas dos formas son equivalentes a nivel de resultados y funcionalidad, pero obviamente
tienendiferenciasdeescrituraylegibilidad.Deestemismomodo,podemosaplicarunformato
compacto al resto de operaciones:

59
Aprende
Python
 >>> random_number = 15

>>> random_number += 5
>>> random_number
20

>>> random_number *= 3
>>> random_number
60

>>> random_number //= 4

>>> random_number
15

>>> random_number **= 1

>>> random_number
15

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 enteder bien su funcionamiento:

Figura 7: Operador «módulo» en Python

>>> dividendo = 17
>>> divisor = 5

>>> cociente = dividendo // divisor # división entera

>>> resto = dividendo % divisor

>>> cociente
3
>>> resto
2

3.2. Números
Exponenciación
60 Capítulo 3. Tipos de datos
Aprende Python
Para elevar un número a otro en Python utilizamos el operador de exponenciación **:

>>> 4 ** 3
64
>>> 4 * 4 * 4

64

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íz2. Por ejemplo:

Hecho en Python:

>>> 4 ** 0.5
2.0

Ejercicio pycheck:
quadratic

Valor absoluto

Python ofrece la función abs() para obtener el valor absoluto de un número:

>>> abs(-1) 1

>>> abs(1) 1

>>> abs(-3.14)
3.14

>>> abs(3.14)
3.14

2
No siempre es una raíz cuadrada porque se invierten numerador y denominador.
Límite de un entero

Nivel avanzado
 61
Aprende
Python
¿Cómo de grande puede ser un int en Python? La respuesta es de cualquier tamaño. Por poner
un ejemplo, supongamos que queremos representar un centillón. Este valor viene a ser un «1»
seguido por ¡600 ceros! ¿Será capaz Python de almacenarlo?

>>> centillion = 10 ** 600

>>> centillion
10000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000
0 0000

Nota: En muchos lenguajes tratar con enteros tan largos causaría un «integer overflow». No es el
caso de Python que puede manejar estos valores sin problema.

¿Qué pasaría si quisiéramos «romper» todas las barreras? Pongamos 10.000 dígitos…

>>> 10 ** 10_000
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
ValueError: Exceeds the limit (4300) for integer string conversion; use sys.set_int_
,→max_str_digits() to increase the limit

Obtenemos un error… pero subsanable, ya que hay forma de ampliar este límite inicial
de 4300 dígitos usando la función sys.set_int_max_str_digits()

3.2.3 Flotantes

Los números en punto flotante3 tienen parte decimal. Veamos algunos ejemplos de flotantes en Python.

Lista 3: Distintas formas de escribir el flotante 4.0

>>> 4.0
4.0 >>> 4. 4.0
>>> 04.0
4.0 >>> 04.
4.0
(continué en la próxima página) 3

Punto o coma flotante es una notación científica usada por computadores.

3.2. Números
(proviene de la página anterior)
>>> 4.000_000
4.0
62 Capítulo 3. Tipos de datos
Aprende Python
>>> 4e0 # 4.0 * (10 ** 0)
4.0

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 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:

>>> True + 25
26
>>> 7 * False
0 >>> True + False
1
>>> 21.8 + True
22.8
>>> 10 + 11.3
21.3

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

Tipo 1 Tipo 2 Resultad
o

bool int int

bool float float

int float float

Se puede ver claramente que la conversión numérica de los valores booleanos es:

• True 1

• False 0
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

63
Aprende
Python
tipo a booleano. int() Convierte el tipo a entero. float() Convierte el tipo a flotante. Veamos
algunos ejemplos de estas funciones:

>>> bool(1)
True
>>> bool(0)
False
>>> int(True)
1 >>> int(False)
0
>>> float(1)
1.0 >>> float(0)
0.0
>>> float(True)
1.0 >>> float(False)
0.0

En el caso de que usemos la función int() sobre un valor flotante nos retornará su parte baja:

⌊︀ ⌋︀
int(x) = x Por

ejemplo:

>>> int(3.1)
3
>>> int(3.5)
3
>>> int(3.9)
3

Para obtener el tipo de una variable ya hemos visto la función type():

>>> is_raining = False

>>> type(is_raining)
(continué en la próxima página)

3.2. Números
(proviene de la página anterior)
 bool

>>> sound_level = 35
>>> type(sound_level)
int

64 Capítulo 3. Tipos de datos

Aprende Python
>>> temperature = 36.6
>>> type(temperature)
float

Pero también existe la posibilidad seguimos comprobar el tipo que tiene una variable mediante la función
isinstance():

>>> isinstance(is_raining, bool)

True
>>> isinstance(sound_level, int)
True
>>> isinstance(temperature, float)
True

Ejercicio pycheck:
sin_approx

Errores de aproximación

Nivel intermedio
Supongamos el siguiente cálculo:
>>> (19 / 155) * (155 / 19)
0.9999999999999999

Debería dar 1.0, pero no es así puesto que la representación interna de los valores en coma flotante sigue
el estándar IEEE 754 y estamos trabajando con aritmética finita.
Aunque existen distintas formas de solventar esta limitación, de momento veremos una de las
más sencillas utilizando la función «built-in» round() que nos permite redondear un número
flotante a un número determinado de decimales:

>>> pi = 3.14159265359

>>> round(pi)
 (continué en la próxima página)
(proviene de la página anterior)
3 >>>
round(pi, 1)
3.1 >>>
round(pi, 2)
3.14 >>>
round(pi, 3)

65
Aprende
Python
3.142 >>>
round(pi, 4)
3.1416 >>>
round(pi, 5)
3.14159

Para el caso del error de aproximación que nos ocupa:

>>> result = (19 / 155) * (155 / 19)

>>> round(result, 1)
1.0
Prudencia: round() aproxima al valor más cercano, mientras que int() obtiene siepre el
entero «por abajo».

Límite de un flotante

A diferencia de los enteros, los números flotantes sí que tienen un límite en Python. Para descubrirlo
podemos ejecutar el siguiente código:

>>> import sys

>>> sys.float_info.min
2.2250738585072014e-308

>>> sys.float_info.max
1.7976931348623157e+308

3.2. Números
3.2.4 Bases
Nivel intermedio

66 Capítulo 3. Tipos de datos

Aprende Python
Los valores numéricos con los que estamos acostumbrados a trabajar están en base 10 (o
decimal). Esto indica que disponemos de 10 «símbolos» para representar las cantidades. En este
caso del 0 al 9.
Pero también es posible representar números en otras bases. Python nos ofrece una serie de
prefijos y funciones para este cometido.

Base binaria

Cuenta con 2 símbolos para representar los valores: 0 y 1.

Prefijo: 0b

>>> 0b1001
9
>>> 0b1100
12

Función: bin()

>>> bin(9)
0b1001
>>> bin(12)
0b1100

Base octal

Cuenta con 8 símbolos para representar los valores: 0, 1, 2, 3, 4, 5, 6 y 7. Prefijo: 0o

>>> 0o6243
3235
>>> 0o1257
687

Función: oct()

>>> oct(3235)
0o6243
>>> oct(687)
0o1257
Base hexadecimal

Cuenta con 16 símbolos para representar los valores: 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, A, B, C, D, E y F.

Prefijo: 0x

67
Aprende
Python
>>> 0x7F2A
32554
>>> 0x48FF
18687

Función: hex()

>>> hex(32554)
0x7f2a
>>> hex(18687)
0x48ff

Nota: Las letras para la representación hexadecimal no atienden a mayúsculas y minúsculas.

EJERCICIOS DE REPASO

1. pycheck: circle_area
2. pycheck: sphere_volume
3. pycheck: triangle_area
4. pycheck: interest_rate
5. pycheck: euclid_distance
6. pycheck: century_year
 7. pycheck: red_square
8. pycheck: igic
9. pycheck: super_fast
10. pycheck: move_twice
11. pycheck: pillars
12. pycheck: clock_time
13. pycheck: xor

3.2. Números
EJERCICIOS EXTERNOS

68 Capítulo 3. Tipos de datos

Aprende Python
8. Cat years, dog years
9. Aspect ratio cropping
10. USD => CNY
11. Third angle of a triangle
12. Keep hydrated!
13. Price of mangoes
14. Total pressure calculation
15. NBA full 48 minutes average 16.
Age range compatibility equation 17.
Formatting decimal places

AMPLIAR CONOCIMIENTOS

• The Python Square Root Function •

How to Round Numbers in Python •
Operators and Expressions in Python
 69
Aprende Python

3.3 Cadenas de texto

Las cadenas de texto son secuencias de caracteres. También se les conoce como «strings» y nos
permiten almacenar información textual de forma muy cómoda.21

Es importante destacar que Python 3 almacena los caracteres codificados en el estándar

Unicode, lo que es una gran ventaja con respecto a versiones antiguas del lenguaje. Además
permite representar una cantidad ingente de símbolos incluyendo los famosos emojis .
3.3.1 Creando «strings»
Para escribir una cadena de texto en Python basta con rodear los caracteres con comillas
simples22:
>>> Mi primera cadena en Python
Mi primera cadena en Python

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

21
Foto original de portada por Roman Kraft en Unsplash.
22
También es posible utilizar comillas dobles. Yo me he decantado por las comillas simples ya que quedan más
limpias y suele ser el formato que devuelve el propio intérprete de Python.

70 Capítulo 3. Tipos de datos

Aprende Python
>>> Los llamados "strings" son secuencias de caracteres Los
llamados "strings" son secuencias de caracteres

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

Lista 4: Comillas simples escapadas

>>> Los llamados \ strings\ son secuencias de caracteres
"Los llamados strings son secuencias de caracteres"

Lista 5: Comillas simples dentro de comillas dobles

>>> "Los llamados strings son secuencias de caracteres"
"Los llamados strings son secuencias de caracteres"

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:
>>> poem = To be, or not to be, that is the question:
... Whether tis nobler in the mind to suffer
... The slings and arrows of outrageous fortune,
... Or to take arms against a sea of troubles

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 contiene ningún carácter. Aunque a priori no lo pueda
parecer, es un recurso importante en cualquier código. Su representación en Python es la
siguiente:
>>>

3.3. Cadenas de texto 71

Aprende Python
3.3.2 Conversión
Podemos crear «strings» a partir de otros tipos de datos usando la función str():
>>> str(True)
True
>>> str(10)
10
>>> str(21.7)
21.7

Para el caso contrario de convertir un «string» a un valor numérico, tenemos a disposición las
funciones ya vistas:
>>> int(10)
10
>>> float(21.7)
21.7

Pero hay que tener en cuenta un detalle. La función int() también admite la base en la que se
encuentra el número. Eso significa que podemos pasar un número, por ejemplo, en hexadecimal
(como «string») y lo podríamos convertir a su valor entero:
>>> int(FF, 16)
255
Nota: La base por defecto que utiliza int() para convertir cadenas de texto es la base decimal.

3.3.3 Secuencias de escape

Python permite escapar el significado de algunos caracteres para conseguir otros resultados. Si
escribimos una barra invertida \ antes del carácter 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:
# Salto de línea
>>> msg = Primera línea\nSegunda línea\nTercera línea
>>> print(msg)
Primera línea

72 Capítulo 3. Tipos de datos

Aprende Python
Segunda línea

(continué en la próxima página)

 3.3. Cadenas de texto 73
Aprende Python

(proviene de la página anterior)

Tercera línea

# Tabulador
>>> msg = Valor = \t40
>>> print(msg)
Valor = 40

# Comilla simple
>>> msg = Necesitamos \ escapar\ la comilla simple
>>> print(msg)
Necesitamos escapar la comilla simple

# Barra invertida
>>> msg = Capítulo \\ Sección \\ Encabezado
>>> print(msg)
Capítulo \ Sección \ Encabezado

Nota: Al utilizar la función print() es cuando vemos realmente el resultado de utilizar los
caracteres escapados.

Expresiones literales

Nivel intermedio
Hay situaciones en las que nos interesa que los caracteres especiales pierdan ese significado y
poder usarlos de otra manera. Existe un modificar de cadena que proporciona Python para
tratar el texto en bruto. Es el llamado «raw data» y se aplica anteponiendo una r a la cadena de
texto.
Veamos algunos ejemplos:

74 Capítulo 3. Tipos de datos

Aprende Python

(proviene de la página anterior)

 >>> text = abc\ndef >>>
print(text)
abc
def

>>> text = r abc\ndef >>>

print(text) abc\ndef

>>> text = a\tb\tc

>>> print(text)
abc

(continué en la próxima página)

>>> text = r a\tb\tc
>>> print(text) a\tb\tc

Consejo: El modificador r es muy utilizado para la escritura de expresiones regulares.

3.3.4 Más sobre print()

Hemos estado utilizando la función print() de forma sencilla, pero admite algunos parámetros
interesantes:
>>> msg1 = ¿Sabes por qué estoy acá?
>>> msg2 = Porque me apasiona

>>> print(msg1, msg2)

¿Sabes por qué estoy acá? Porque me apasiona

>>> print(msg1, msg2, sep=|)

¿Sabes por qué estoy acá?|Porque me apasiona

>>> print(msg2, end=!!)

Porque me apasiona!!

3.3. Cadenas de texto 75

Aprende Python
 (proviene de la página anterior)
7

10

11

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 carácter
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 carácter que se
utiliza como final de texto.

3.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():
>>> name = input(Introduzca su nombre:
)
Introduzca su nombre: Sergio

(continué en la próxima página)

>>> name Sergio
>>> type(name) str

>>> age = input(Introduzca su edad:

Introduzca su edad: 41
)
>>> age
41
>>> type(age) str

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.

76 Capítulo 3. Tipos de datos