Aprende

Python Sergio Delgado

Quintero

02 de mayo de 2024
Core
1 Introducción 3 1.1 Hablando con la máquina . . . . . . . . . . . . . . . . . . . . . . . . . . . . 3 1.2
Algo de historia . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 8 1.3 Python . . . . . . . . . . .
. . . . . . . . . . . . . . . . . . . . . . . . . . . 14

2 Entornos de desarrollo 25 2.1 Thonny . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

. 26 2.2 Contexto real . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 30 2.3 VSCode . .
. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 39

3 Tipos de datos 49 3.1 Datos . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 50 3.2

Números . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 63 3.3 Cadenas de texto . . .
. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 78

4 Control de flujo 105 4.1 Condicionales . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

106 4.2 Bucles . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 127

5 Estructuras de datos 145 5.1 Listas . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

146 5.2 Tuplas . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 178 5.3 Diccionarios
. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 185 5.4 Conjuntos . . . . . . . . . . . . . . . . .
. . . . . . . . . . . . . . . . . . . . 203 5.5 Ficheros . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
. . . . 214

6 Modularidad 225 6.1 Funciones . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 226

6.2 Objetos y Clases . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 276 6.3 Excepciones
. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 334

i
6.4 Módulos . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 346

7 Procesamiento de texto 357 7.1 re . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

. . 358 7.2 string . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 369

8 Acceso a datos 373 8.1 sqlite . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 374

9 Ciencia de datos 395 9.1 jupyter . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 396

9.2 numpy . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 420 9.3 pandas . . . . . . . .
. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 463 9.4 matplotlib . . . . . . . . . . . . . . . . . . . . . . .
. . . . . . . . . . . . . 527

10 Scraping 569 10.1 requests . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 570

10.2 beautifulsoup . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 578 10.3 selenium . .
. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 593
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

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

Core 1
Aprende Python
 2 Core

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

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

4 Capítulo 1. Introducción
Aprende Python

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

1.1. Hablando con la máquina 5

Aprende Python
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
12 CALL 1
22 RETURN_VALUE

2
Iconos originales por Flaticon.
3
Véase más información sobre el intérprete de bytecode.

6 Capítulo 1. Introducción
 Aprende Python

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

«bytecode» de Python (o máquina virtual):

Figura 2: Modelo de ejecución de un programa Python4

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 «transparente».

4
Imagen extraída del artículo Python bytecode analysis.

1.1. Hablando con la máquina 7

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

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

continué en la próxima página

1
Foto original por Dario Veronesi en Unsplash.
 8 Capítulo 1. Introducción
Aprende Python

Tabla 1 – proviene de la página anterior

Personaje Aporte Año

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 1854

de 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 1936

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

John Atanasoff Primera computadora digital electrónica 1942

patentada: Atanasoff Berry Computer (ABC)

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

una 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 1946

información, 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.
2
Fuente: Meatze.
 1.2. Algo de historia 9
Aprende Python

Figura 3: Ada Lovelace: primera programadora de la historia2

 10 Capítulo 1. Introducción
Aprende Python

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

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

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

3
Fuente: Universidad Técnica del Norte.
4
Fuente: Wikipedia.

1.2. Algo de historia 11

Aprende Python

Tabla 2 – proviene de la página anterior

Personaje Aporte

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

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

12 Capítulo 1. Introducción
Aprende Python
 Figura 4: Cronología de los lenguajes de programación más destacados

1.2. Algo de historia 13

Aprende Python

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

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.
1
Foto original por Markéta Marcellová en Unsplash.

14 Capítulo 1. Introducción
Aprende Python

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.
• Extensible (C++, C, …) y «embebible».
• Gran comunidad, amplio soporte.
• Interpretado.
• Tipado dinámico5.
• Fuertemente tipado6.

Desventajas

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

• Consumo de memoria.
• Errores no detectables en tiempo de compilación.
• 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.
5
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.
6
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.

1.3. Python 15
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 noviembre de 2023 en el que Python ocupaba el primer puesto de los
lenguajes de programación más usados, por delante de C y C++.

16 Capítulo 1. Introducción
Aprende Python
 Figura 5: Grandes empresas y organismos que usan Python

Figura 6: Índice TIOBE Noviembre 2023

1.3. Python 17
Aprende Python

Igualmente en la encuesta a desarrolladores/as de Stack Overflow del 2023 Python

ocupaba el tercer puesto de los lenguajes de programación más populares, sólo
por detrás de HTML/CSS y JavaScript:
 Figura 7: Encuesta Stack Overflow 2023
También podemos reseñar el informe anual que realiza GitHub sobre el uso de
tecnologías en su plataforma. En la edición de 2023 del estado del opensource de
GitHub, Python ocupaba el segundo puesto de los lenguajes de programación más
usados, sólo por detrás de JavaScript:

Figura 8: Informe GitHub 2023

18 Capítulo 1. Introducción
Aprende Python

1.3.3 Versiones de Python

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

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

Python 3.13 Octubre 2024 ?

Un dato curioso, o directamente un «frikismo»: Desde Python 3.8, cada nueva versión
estable sale a la luz en el mes de Octubre. En este escenario de Python 3.version se
cumplen las siguientes igualdades:

�������������� = �������� − 2011

�������� = �������������� + 2011

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
3
Fuente: python.org.
4
Término que se refiere a los/las desarrolladores/as principales del lenguaje de programación. 1.3.

Python 19

Aprende Python

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 JavaScrip
t

RustPython Rust

MicroPython C

Nota: Cuando hacemos referencia a Python hablamos (implícitamente) de CPython.

Este manual versa exclusivamente sobre CPython.
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ónico2creadas por Tim Peters, llamadas el Zen de Python y que
se pueden aplicar incluso más allá de la programación:

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

20 Capítulo 1. Introducción
Aprende Python
>>> 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.
• La legibilidad es importante.
 • 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.

1.3. Python 21
Aprende Python

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

22 Capítulo 1. Introducción
Aprende Python

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.
1.3. Python 23

Aprende Python
24 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.

25
Aprende 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.
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) para el trabajo de programación, nos referimos a él como un 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.

26 Capítulo 2. Entornos de desarrollo

Aprende Python

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:

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 27
Aprende Python

• 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

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.

28 Capítulo 2. Entornos de desarrollo

Aprende Python
 Figura 2: Guardando nuestro primer programa en Python

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.

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)

1
2

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 29
Aprende Python

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

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

30 Capítulo 2. Entornos de desarrollo

Aprende Python
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 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 31

Aprende Python
 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
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

1
2
3

• 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.
 32 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 33

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 urllib3
$ (env1) ~/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:

34 Capítulo 2. Entornos de desarrollo

Aprende Python
$ pyenv global 3.7.4

$ 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 IDE3. 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:
3
Integrated Development Environment.

2.2. Contexto real 35

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.

36 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 37

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

7
Tutorial de instalación de WSL.

38 Capítulo 2. Entornos de desarrollo

Aprende Python
 2.3 VSCode

Visual Studio Code (VSCode) es un entorno de desarrollo integrado1 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 extensiones.2

2.3.1 Instalación

VSCode tiene disponibles paquetes autoinstalables para todos los sistemas operativos.

2.3.2 Extensiones recomendadas

Para escribir un «mejor» código Python en VSCode sería deseable tener instaladas las
siguientes extensiones:
• Python
• Ruff
• Mypy Type Checker
• isort
1
También conocido por IDE siglas en inglés de Integrated Development
Environment. 2 Foto original de portada por Kelly Sikkema en Unsplash.

2.3. VSCode 39
Aprende Python
2.3.3 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 Code3.

Ajustes generales
Acción Atajo

Abrir paleta de comandos Ctrl + Shift + P

Abrir archivo Ctrl + P

Nueva ventana Ctrl + Shift + N

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

continué en la próxima página

3
Fuente: Gastón Danielsen en Dev.To.

40 Capítulo 2. Entornos de desarrollo

Aprende Python

Tabla 3 – proviene de la página anterior

Acción Atajo

Salto de linea Alt + Z

Seleccionar lineas Alt + Click Mouse

Tabular linea Tab

Destabular linea Shift + Tab

Renombrar símbolo F2

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.

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

2.3. VSCode 41
Aprende Python

Figura 5: Apertura del fichero a depurar

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:
También es posible añadir puntos de ruptura condicionales pulsando con el botón
derecho y luego Add Conditional Breakpoint…:

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 �:
Ahora ya se inicia el «modo depuración» y veremos una pantalla similar a la
siguiente: 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.

42 Capítulo 2. Entornos de desarrollo

Aprende Python

Figura 6: Punto de ruptura

 Figura 7: Punto de ruptura condicional

2.3. VSCode 43
Aprende Python

Figura 8: Configuración de la depuración

 Figura 9: Interfaz en modo depuración

44 Capítulo 2. Entornos de desarrollo

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:

Figura
 10: Barra de herarmientas 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

Restart �+�+ Reiniciar la depuración del programa

F5

Stop � + F5 Detener la depuración del programa

2.3. VSCode 45
Aprende Python

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:

Figura 11: Panel para visualizar variables

Pero también es posible añadir manualmente el seguimiento de otras variables o
expresiones personalizadas desde la zona Watch:
 46 Capítulo 2. Entornos de desarrollo
Aprende Python

Figura 12: Panel para seguimiento de expresiones

 2.3. VSCode 47
Aprende Python
48 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.

49
Aprende 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.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:
• 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:

1
Foto original de portada por Alexander Sinn en Unsplash.

50 Capítulo 3. Tipos de datos

Aprende Python
 Figura 1: Esquema (metadatos) de un objeto en Python

3.1. Datos 51
Aprende Python

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

• 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»).
2
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.
 52 Capítulo 3. Tipos de datos
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.
 3.1. Datos 53
Aprende Python

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 –.4 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 PEPs5son 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, una bastante accesible es http://pep8online.com/ ya que no necesita
instalació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
3. number_of_elements
4. number_of_elements_to_be_handled
 4
Más información sobre convenciones de nombres en PEP 8.
5
Del término inglés «Python Enhancement Proposals».

54 Capítulo 3. Tipos de datos

Aprende Python

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 = 157_503
>>> avg_temperature = 16.8
>>> city_name = San Cristóbal de La Laguna
 Algunos ejemplos de asignaciones a constantes:

3.1. Datos 55
Aprende Python
>>> 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.
Recordemos que los nombres de variables deben seguir unas reglas establecidas, de
lo contrario 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

56 Capítulo 3. Tipos de datos

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 un intérprete («shell» o consola) 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, debmos 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

3.1. Datos 57
Aprende Python
Advertencia: Aunque está permitido, NUNCA llames type a una variable porque
destruirías la función que nos permite conocer el tipo de un objeto.

Ejercicio
Utilizando la consola interactiva de Python >>>, realiza las siguientes tareas: 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 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

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
La función id() nos permite conocer la dirección de memoria6 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: 6
Esto es un detalle de implementación de CPython.

58 Capítulo 3. Tipos de datos

Aprende Python

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

 3.1. Datos 59
Aprende Python

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

>>> id(10)
4333546384

>>> id(20)
4333546704

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

60 Capítulo 3. Tipos de datos

Aprende Python

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
modificar su valor «in-situ», pero siempre podremos asignarle un nuevo valor (hacerlo
apuntar 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()

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. Datos 61

Aprende 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
• Immutability in Python

62 Capítulo 3. Tipos de datos

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

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

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

1
Foto original de portada por Brett Jordan en Unsplash.

3.2. Números 63
Aprende Python

(proviene de la página anterior)

>>> 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.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
File "<stdin>", line 1
08
^
SyntaxError: invalid token

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

64 Capítulo 3. Tipos de datos

Aprende Python
 (proviene de la página anterior)
>>> 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. 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 4: Operaciones con enteros en Python

Operador Descripción Ejemplo Resultado

+ Suma 3 + 9 12

- 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
>>> 7 / 3
2.3333333333333335
>>> 7 // 3
2

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

3.2. Números 65
Aprende Python

(proviene de la página anterior)

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

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

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

66 Capítulo 3. Tipos de datos

Aprende Python

Figura 6: Asignación aumentada en Python

(proviene de la página anterior)

>>> 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 tienen diferencias de escritura y legibilidad. De este mismo modo, podemos
aplicar un formato compacto al resto de operaciones:
>>> 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

3.2. Números 67
Aprende Python

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
 Exponenciación

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: 412 =
√
40.5 = 4 = 2

Hecho en Python:
2
No siempre es una raíz cuadrada porque se invierten numerador y denominador. 68 Capítulo 3.

Tipos de datos

Aprende 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

Límite de un entero

Nivel avanzado
¿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
10000000000000000000000000000000000000000000000000000000000000000000000000000000000000

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…

3.2. Números 69

Aprende Python
>>> 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 flotante3tienen 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
>>> 4.000_000
4.0
>>> 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.
3
Punto o coma flotante es una notación científica usada por computadores.

70 Capítulo 3. Tipos de datos

Aprende Python

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 Resultado

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

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

3.2. Números 71
Aprende Python

(proviene de la página anterior)

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:
⌊︀
������(��) = ��⌋︀

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)
bool

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

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

72 Capítulo 3. Tipos de datos

Aprende Python
>>> 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)
3
>>> round(pi, 1)
3.1
>>> round(pi, 2)
3.14
>>> round(pi, 3)
3.142
>>> round(pi, 4)
3.1416
>>> round(pi, 5)
3.14159

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

3.2. Números 73
Aprende Python
 >>> 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.4 Bases

Nivel intermedio
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

74 Capítulo 3. Tipos de datos

Aprende Python

Función: bin()
 >>> bin(9)
0b1001
>>> bin(12)
0b1100

Prudencia: Esta función devuelve una cadena de texto.

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

Prudencia: Esta función devuelve una cadena de texto.

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
>>> 0x7F2A
32554
>>> 0x48FF
18687

Función: hex()

3.2. Números 75
Aprende Python
 >>> hex(32554)
0x7f2a
>>> hex(18687)
0x48ff

Prudencia: Esta función devuelve una cadena de texto.

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
14. pycheck: ring_area

76 Capítulo 3. Tipos de datos