1

INTRODUCCION A LA PROGRAMACION CON PYTHON

PRIMERA EDICIÓN

Se prohíbe la reproducción parcial o total del presente documento, su tratamiento

informático, la transmisión por cualquier forma o medio electrónico, mecánico, por
fotocopia, por registro u otros métodos, sin previa autorización de los titulares del
Copyright ©.

Derecho Reservados. Copyright ©.

©2024 GEOMÁTICA AMBIENTAL S.R.L.

Jr. Iquitos Nº 960
Tingo María – Huánuco – Perú.
Celular: +51-995664488
Email: [email protected]
Página: https://www.geomatica.pe/

©2024 Especialista Geomática

©2024 Nino Frank Bravo Morales
Huánuco – Perú
Celular: +51-995664488
Email: [email protected]
Facebook: https://www.facebook.com/NinoBravoMorales

2
PRÓLOGO PRIMERA EDICIÓN
INTRODUCCION A LA PROGRAMACION CON PYTHON

Es un honor compartir este pequeño manual a lo largo de todo este tiempo, fruto
de muchas jornadas laborales en diferentes instituciones públicas y privadas en los
últimos cinco años y de compartir mis conocimientos a la gran comunidad de ingeniería,
interesados en conocer y aprender un software libre tan versátil y potente, como es el
Python.
Es muy gratificante saber que son muchas las personas a las que he llegado a
enseñar de forma presencial e virtual en los temas de Geomática, que se encuentran
muy satisfechas por la enseñanza personalizada; y no es para más, mencionar que me
siento muy a gusto de lo compartido mis enseñanzas en este mundo muy competitivo.
Es así, que este texto nació bajo el nombre de: INTRODUCCION A LA
PROGRAMACION CON PYTHON, que impartí en la empresa GEOMATICA
AMBIENTAL S.R.L, que dio a disponibilidad de alcanzar a muchos estudiantes y
profesionales ligados a la ingeniería, por medio de las diferentes enseñanzas de forma
directa e indirecta.
Agradecer primeramente a Dios por darme la vida, por acompañarme siempre en
las circunstancias duras de la vida, también a mis padres BRAVO TRUJILLO
INOCENCIO Y MORALES BALTAZAR GENOVEBA, por el amor que me tienen, por
siempre aconsejarme y mostrarme las cosas duras de la vida, valorar su abnegado
sacrificio por hacer de mí una persona de bien y ser mis guías en la formación de mi
carrera profesional. A mi esposa JULY CLARIBEL CRUZ MONZON, hijos (Ghiro, Moddy,
Ariana, Lian, Ian y Kian), hermanas (Maritza y Jessica), tíos, y demás familiares por su
cariño y gratitud, pensar en ello represento estimulo indeclinable de superación.
Agradecer a todos los autores de los módulos de Python que hacen posible el
desarrollo de la programación más sencilla y generar procesos automatizados por su
tiempo y creación de los módulos de forma libre acceso en Python.
Esperando que sea de su total agrado y con ánimos de buscar siempre la mejora
continua, me despido, no sin antes, agradecer cualquier sugerencia y aporte para la
prosperidad del presente.
Atentamente:
Ing. Nino Frank Bravo Morales
Especialista Geomática

3
 Curso virtual que se realizó para aprender conjuntamente con el manual
https://www.geomatica.pe/cursos/introduccion-la-programacion-con-python

Más cursos dedicados en programación y Geomática.

https://www.geomatica.pe/

4
 ÍNDICE GENERAL
I. Introducción e Instalación Python .................................................................... 12

1.1. Antecedentes generales Python ............................................................. 12

1.2. Plataformas de Python ........................................................................... 12

1.2.1. Entornos de Desarrollo Integrado – IDE .................................... 12

1.2.2. Editores de Texto ........................................................................ 13

1.2.3. Notebooks ................................................................................... 13

1.3. Google Colab ......................................................................................... 14

1.3.1. Ventajas ....................................................................................... 14

1.3.2. Introducción: ¿qué son las CPUs, GPUs y TPUs ....................... 15

1.3.3. Primeros Pasos en Google Colab................................................ 16

1.4. Instalación y configuración Python ....................................................... 20

1.4.1. Instalación de Python en Windows ............................................. 20

1.5. Introducción de Jupyter notebook.......................................................... 25

1.5.1. Introducción al uso Jupyter Lab ................................................. 25

1.5.2. Sintaxis básica en Python ........................................................... 27

II. Variables en Python .......................................................................................... 28

2.1. La función import .................................................................................. 29

2.2. Variable número ..................................................................................... 30

2.2.1. Operaciones aritméticas .............................................................. 30

2.2.2. Operaciones Compuestas ............................................................ 31

2.2.3. Módulo Math .............................................................................. 31

2.2.3.1. Constantes .................................................................. 31

2.2.3.2. Funciones de redondeo ............................................... 31

2.2.3.3. Potencias y raíces ....................................................... 32

2.2.3.4. Logaritmos.................................................................. 32

5
 2.2.3.5. Funciones trigonométricas ......................................... 32

2.3. String ...................................................................................................... 33

2.3.1. Operaciones con string ............................................................... 33

2.3.2. Substrings ................................................................................... 34

2.3.3. Métodos de cambiar formato ...................................................... 34

2.3.4. Método de búsqueda y remplazo ................................................ 34

2.3.5. Método de modificar espacio ..................................................... 35

2.3.6. Métodos para Manipular el Contenido ....................................... 35

2.3.7. Métodos para Verificar Propiedades ........................................... 36

2.4. Boleanos................................................................................................. 36

2.3.3.1. Creación de valores booleanos ................................... 36

2.3.3.2. Operadores de comparación ....................................... 36

2.3.3.3. Operadores lógicos ..................................................... 37

2.5. Colección de datos en Python ................................................................ 37

2.6. Listas ...................................................................................................... 38

2.6.1. Tamaño de una lista .................................................................... 38

2.6.2. Acceso a los elementos de una lista............................................ 38

2.6.3. Concatenación y Repetición ....................................................... 38

2.6.4. Bucles con listas¶ ....................................................................... 39

2.6.5. Métodos de agregado .................................................................. 39

2.6.6. Métodos de eliminación ............................................................. 39

2.6.7. Métodos de orden ....................................................................... 40

2.6.8. Métodos de búsqueda ................................................................. 40

2.7. Tuplas ..................................................................................................... 40

2.7.1. Tamaño de una tupla ................................................................... 40

2.7.2. Elementos de una tupla ............................................................... 41

2.7.3. Desempaquetado de Tuplas ........................................................ 41

6
 2.7.4. Concatenación y Repetición ....................................................... 41

2.7.5. Métodos de tuplas ....................................................................... 41

2.8. Conjunto................................................................................................. 42

2.8.1. Creación de Conjuntos ............................................................... 42

2.8.2. Métodos de agregado .................................................................. 42

2.8.3. Eliminar elementos ..................................................................... 42

2.8.4. Operaciones de conjuntos ........................................................... 43

2.8.5. Verificación de subconjuntos y superconjuntos.......................... 43

2.9. Diccionario ............................................................................................. 43

2.9.1. Creación de Diccionarios............................................................ 44

2.9.2. Acceso a Elementos .................................................................... 44

2.9.3. Modificación de los valores diccionario ..................................... 44

2.9.4. Tamaño de un diccionario en clave ............................................ 45

2.9.5. Métodos Comunes de los Diccionarios ...................................... 45

2.10. Array .................................................................................................... 46

2.10.1. Módulo numpy – array ............................................................... 46

2.10.1.1. Instalación de NumPy ................................................ 46

2.10.1.2. Importación del Módulo ............................................. 47

2.10.1.3. Datos de tipo arrays .................................................... 47

2.10.1.4. Creación de Arrays ..................................................... 47

2.10.1.5. Arrays con valores iniciales ....................................... 48

2.10.1.6. Acceso y modificación de elementos ......................... 49

2.10.1.7. Características de array .............................................. 49

2.10.1.8. Funciones de Redimensionamiento ............................ 49

2.10.1.9. Operaciones matemáticas con array ........................... 50

2.10.1.10. Guardar y Cargar Arrays ........................................ 52

2.11. Dataframe ............................................................................................. 52

7
 2.11.1. Módulo pandas ........................................................................... 53

2.11.1.1. Tipos de datos de Pandas ............................................ 53

2.11.1.2. Instalación de Pandas ................................................. 53

2.11.1.3. Importación del Módulo ............................................. 54

2.11.1.4. Creación Dataframe .................................................... 54

2.11.1.5. Visualización de dataframe ........................................ 55

2.11.1.6. Selección y filtrado ..................................................... 57

2.11.1.7. Operaciones de datos .................................................. 58

2.11.1.8. Operaciones Estadísticas ............................................ 61

2.11.1.9. Agrupamiento y manipulación avanzada ................... 63

2.11.1.10. Funciones de aplicación ......................................... 66

2.11.1.11. Manejo de fechas y tiempos .................................. 69

2.11.1.12. Guardar un DataFrame .......................................... 70

III. Estructuras de control de flujo e interacción .................................................... 71

3.1. Estructuras de Control de Decisión........................................................ 71

3.1.1. Decisión if .................................................................................. 71

3.1.2. Decisión else ............................................................................... 71

3.1.3. Decisión elif ................................................................................ 71

3.2. Operadores de iteración ......................................................................... 72

3.2.1. Ciclo for ...................................................................................... 72

3.2.2. Ciclo while.................................................................................. 73

IV. Funciones en Python ........................................................................................ 74

4.1. Función sin parámetros ni retorno ......................................................... 74

4.2. Función con parámetros ......................................................................... 74

4.3. Función con valores por defecto ............................................................ 75

4.4. Función con múltiples parámetros y retorno de varios valores ............. 75

V. Visualización de datos ...................................................................................... 76

8
5.1. Matplotlib............................................................................................... 76

5.1.1. Instalación ................................................................................... 76

5.1.2. Importación ................................................................................. 76

5.1.3. Característica al utilizar matplotlib............................................. 76

5.1.3.1. Estilo de marcadores .................................................. 76

5.1.3.2. Estilo de líneas............................................................ 77

5.1.3.3. Estilo de temas............................................................ 78

5.1.4. Gráfico en matplotlib .................................................................. 79

5.1.3.4. plt.plot() lineal ............................................................ 79

5.1.3.5. plt.bar() – barra ........................................................... 80

5.1.3.6. plt.scatter() – dispersión ............................................. 81

5.1.3.7. plt.hist() – histograma................................................. 82

5.1.3.8. plt.pie() – circular ....................................................... 83

5.1.3.9. plt.boxplot() – caja y bigotes ...................................... 83

5.1.5. plt.subplots() – ajuste figura ....................................................... 85

5.2. Seaborn – visualización datos estadísticos: ........................................... 86

5.2.1. Instalación ................................................................................... 86

5.2.2. Importación ................................................................................. 87

5.2.3. Temas en seaborn........................................................................ 87

5.2.3.1. Estilo (style) ............................................................... 87

5.2.3.2. Paleta (palette) ............................................................ 87

5.2.3.3. Texto (context)............................................................ 87

5.2.3.4. Fuente (font) ............................................................... 88

5.2.3.5. Escala fuente (Font_scale).......................................... 88

5.2.3.6. Configuración adicional (rc) ...................................... 88

5.2.4. Tipos de gráficos por funciones .................................................. 89

5.2.4.1. Relacionales................................................................ 89

9
 5.2.4.2. Distribuciones ............................................................. 95

5.2.4.3. Categóricos ................................................................. 101

VI. Variables estadísticas y gráficos ....................................................................... 111

6.1. Variable cualitativa (Categórico) ........................................................... 111

6.1.1. Nominales ................................................................................... 111

6.1.2. Ordinales ..................................................................................... 112

6.2. Variable cuantitativa (Cantidad) ............................................................ 113

6.2.1. Discretas ..................................................................................... 113

6.2.2. Continuas .................................................................................... 113

6.3. Variables Mixtas (Combinación de Cualitativas y Cuantitativas) ......... 115

6.3.1. Comparaciones por Categoría (Cualitativa y Cuantitativa)........ 115

VII. Operaciones de sistema de archivo .................................................................. 119

7.1. Módulo os - Interfaces misceláneas del sistema operativo .................... 119

7.1.1. getcwd() ...................................................................................... 119

7.1.2. chdir(path) .................................................................................. 119

7.1.3. listdir(path) ................................................................................. 119

7.1.4. mkdir(path) ................................................................................. 119

7.1.5. makedirs(path) ............................................................................ 119

7.1.6. rename ........................................................................................ 120

7.1.7. remove(path) ............................................................................... 120

7.1.8. rmdir(path) .................................................................................. 120

7.1.9. removedirs(path) ......................................................................... 120

7.1.10. path.join(path1, path2, ...) ........................................................... 120

7.1.11. path.exists(path) .......................................................................... 120

7.1.12. os.path.isfile(path) y os.path.isdir(path) ..................................... 120

7.2. Módulo sutil - Operaciones de archivos de alto nivel ........................... 121

7.2.1. shutil.copy .................................................................................. 121

10
 7.2.2. shutil.move ................................................................................. 121

7.2.3. shutil.rmtree ................................................................................ 121

7.3. Módulo glob ........................................................................................... 121

7.3.1. glob.glob(pattern) ....................................................................... 121

7.3.2. Búsquedas recursivas con ** ...................................................... 122

7.3.3. Buscar archivos en una ruta específica ....................................... 122

7.3.4. Combinar glob y os .................................................................... 123

11
 I. Introducción e Instalación Python
1.1. Antecedentes generales Python
Es un lenguaje de programación de alto nivel, interpretado y de propósito general,
creado por Guido van Rossum y lanzado por primera vez en 1991. Es conocido por
su sintaxis clara y legible, lo que lo convierte en una excelente opción para
principiantes y expertos por igual.
Python es un lenguaje multipropósito que se puede utilizar para una amplia variedad
de tareas, incluyendo:
• Desarrollo web: Con frameworks como Django y Flask, Python es una opción
popular para construir aplicaciones web dinámicas y escalables.
• Análisis de datos: Bibliotecas como NumPy, Pandas y Matplotlib hacen que
Python sea una opción líder para el análisis y visualización de datos.
• Aprendizaje automático y inteligencia artificial: Con bibliotecas como
TensorFlow, PyTorch y scikit-learn, Python es ampliamente utilizado en el
campo del aprendizaje automático y la inteligencia artificial.
• Automatización de tareas: Python es ideal para escribir scripts que automatizan
tareas repetitivas y simplifican procesos.
• Desarrollo de aplicaciones de escritorio y juegos: Con bibliotecas como
Tkinter y Pygame, Python se puede utilizar para desarrollar una amplia variedad
de aplicaciones de escritorio y juegos.
•
1.2. Plataformas de Python
1.2.1. Entornos de Desarrollo Integrado – IDE
Es una aplicación de software que ayuda a los programadores a desarrollar
código de software de manera eficiente. Aumenta la productividad de los
desarrolladores al combinar capacidades como editar, crear, probar y
empaquetar software en una aplicación fácil de usar.
➢ PyCharm:
• Desarrollado por JetBrains.
• Ofrece autocompletado de código, depuración avanzada y gestión
de entornos virtuales.
• Disponible en versiones Community (gratuita) y Professional (de
pago).

12
 ➢ Visual Studio Code:
• Editor de código fuente ligero y potente.
• Soporta extensiones, incluyendo soporte para Python.
• Integración con Git, depurador y terminal incorporados.
➢ Spyder:
• IDE orientado a la ciencia de datos.
• Incluye un entorno interactivo, editor de scripts y herramientas de
depuración.
• Integración con bibliotecas como NumPy y Matplotlib.
➢ Thonny:
• IDE simple y fácil de usar, ideal para principiantes.
• Incluye un depurador visual y soporte para gestión de paquetes.

1.2.2. Editores de Texto

➢ Sublime Text:
• Editor de texto altamente personalizable y rápido.
• Soporta múltiples lenguajes y tiene muchas extensiones.
➢ Atom:
• Editor de texto desarrollado por GitHub.
• Soporta paquetes y temas personalizables, y es fácil de usar.
➢ Notepad++:
• Editor de texto ligero para Windows.
• Soporta resaltado de sintaxis para varios lenguajes y es muy rápido.

1.2.3. Notebooks
➢ Jupyter Notebook:
• Herramienta interactiva para crear y compartir documentos que
contienen código, ecuaciones y visualizaciones.
• Muy popular en la comunidad de ciencia de datos y aprendizaje
automático.
➢ Google Colab:
• Servicio basado en la nube que permite ejecutar Jupyter
Notebooks.

13
 • Ofrece acceso a GPUs gratuitas para ejecutar código que requiere
mucho procesamiento.
➢ Zeppelin:
• Notebook web para el análisis de datos que permite ejecutar código
en varios lenguajes, incluyendo Python.
• Soporta visualizaciones y colaboraciones en tiempo real.

1.3. Google Colab

Es una herramienta gratuita basada en Jupyter Notebooks, proporcionada por
Google, que permite escribir y ejecutar código Python o R en el navegador con la
ventaja de poder usar recursos computacionales de alto rendimiento como GPUs y
TPUs. Es especialmente útil para aquellos que necesitan capacidades de
procesamiento más allá de lo que sus computadoras personales pueden ofrecer.

1.3.1. Ventajas
• Gratuito y accesible: Puedes acceder y usar Google Colab de forma gratuita,
lo que lo hace ideal para estudiantes, investigadores y profesionales que
necesitan un entorno potente sin costo.
• Colaboración en tiempo real: Permite trabajar de manera colaborativa en
proyectos, compartiendo cuadernos con colegas y editando en tiempo real.
• Acceso a GPUs y TPUs: Proporciona acceso a GPUs y TPUs, facilitando el
desarrollo y entrenamiento de modelos de machine learning sin necesidad
de hardware costoso.
• Integración con Google Drive: Facilita la conexión con Google Drive,
permitiendo guardar y acceder a archivos directamente desde tus cuadernos.
• Versatilidad y compatibilidad: Aunque he probado otras plataformas como
Deepnote y Kaggle, la versatilidad y compatibilidad de Google Colab lo
hacen mi opción preferida para la mayoría de los proyectos.

14
1.3.2. Introducción: ¿qué son las CPUs, GPUs y TPUs
A. CPUs (Unidades Centrales de Procesamiento)
Es el componente principal de un ordenador que realiza la mayoría de
los cálculos. Es responsable de ejecutar instrucciones de programas y
gestionar tareas generales.
Características:
✓ Generalmente tiene unos pocos núcleos (de 2 a 16 en muchos
casos).
✓ Es versátil y puede manejar diversas tareas, desde procesamiento
de texto hasta juegos.
✓ Se enfoca en la latencia, realizando tareas secuenciales de manera
eficiente.
B. GPUs (Unidades de Procesamiento Gráfico)
Originalmente diseñadas para renderizar gráficos en videojuegos, las
GPUs se utilizan cada vez más para tareas de computación paralela,
como el aprendizaje automático.
Características:
✓ Tienen cientos o miles de núcleos, lo que les permite procesar
muchas operaciones simultáneamente.
✓ Son especialmente eficaces en tareas que requieren el
procesamiento de grandes volúmenes de datos en paralelo, como el
entrenamiento de modelos de redes neuronales.
C. TPUs (Unidades de Procesamiento Tensorial)
Diseñadas por Google específicamente para acelerar el aprendizaje
profundo, las TPUs son hardware especializado optimizado para
operaciones de matrices, que son fundamentales en las redes
neuronales.
Características:
✓ Están diseñadas para ser altamente eficientes en operaciones
tensoriales, lo que las hace más rápidas que las GPUs en tareas de
aprendizaje profundo.
✓ Se utilizan en entornos de nube y están integradas en plataformas
como Google Cloud para facilitar el desarrollo y entrenamiento de
modelos de IA.

15
1.3.3. Primeros Pasos en Google Colab
a) Accede a Google Colab:
✓ Ve a Google Colab.
✓ Si no has iniciado sesión, hazlo con tu cuenta de Google.

b) Crear un nuevo notebook:

Haz clic en "Nuevo cuaderno" en la esquina inferior derecha, un nuevo
cuaderno en una nueva pestaña, en Google Drivers se creará una carpeta
“Colab Notebooks”, se guardará los cuadernos.

16
 Otra opción es ir a Google Drivers, hacer click en Nuevo y elegir Más
en el panel desplegable y luego "Google Collaboratory".

c) Abrir un Notebook existente Drivers

Simplemente haga clic derecho sobre él -> Abrir con -> Google
Collaboratory. También puedes cargar documentos de Google Colab de
otras personas si compartes una unidad de Google con ellas.

d) Conexión a Google Drive

Para trabajar con archivos de tu Google Drive, primero necesitas
montarlo en Colab:

from google.colab import drive

drive.mount('/content/drive')

17
 Sigue las instrucciones para autenticar y conectar tu cuenta de Google
Drive.

e) Interfaz básica de Google Colab

En este sentido, Colab constituye una excelente opción, dado que se
ofrece como un servicio gratuito de Google; proporciona una interfaz
de Jupyter Notebook; permite compartir el trabajo simplemente
otorgando acceso al cuaderno de trabajo, como se hace habitualmente
con los archivos de Google Drive; sólo se necesita contar con un
navegador Web y conexión a Internet y, lo mejor de todo, tiene acceso
al hardware provisto por Google. Así, no se necesita contar con ningún
equipo potente, todo el procesamiento se realiza en la nube sobre
hardware externo.

Botón de
Nombre compartir
script

Recursos
disponibles
Celda de
texto
Celda de
código
Archivo de
datos

Espacio
disponible

f) Atajos más importantes en Google colab

✓ Atajos de edición y navegación
- Ctrl + M luego B (debajo) o A (arriba): Crear nueva celda de
código.
- Ctrl + M luego D (presionar dos veces): Eliminar celda.
- Shift + Enter: Ejecutar celda.
- Ctrl + Enter: Ejecutar celda y añadir nueva celda.
- Alt + Enter: Ejecutar celda y mover a la siguiente.

18
 - Ctrl + C: Copiar celda.
- Ctrl + V: Pegar celda.
- Ctrl + Z: Deshacer.
- Ctrl + Y: Rehacer.
✓ Navegación
- Mover hacia arriba/abajo entre celdas: Arriba/Abajo
- Seleccionar celda: Enter (mientras estás en la celda)
- Entrar en modo de edición de celda: Enter
- Salir del modo de edición: Esc
✓ Formato y visualización
- Insertar una celda de texto (Markdown): Ctrl + M luego M
- Convertir celda de código a texto (Markdown): Ctrl + M luego
M
- Convertir celda de texto a código: Ctrl + M luego Y
- Ejecutar todas las celdas: Ctrl + F9
- Reiniciar entorno de ejecución: Ctrl + M luego . (punto)
✓ Otros atajos útiles
- Mostrar ayuda: Ctrl + H
- Abrir la paleta de comandos: Ctrl + Shift + P
- Abrir el menú de herramientas: Ctrl + Shift + I
g) Módulos en Google colab
Consultas que módulos tiene instalado por defecto

!pip list

Instalación de un nuevo módulo

!pip install rasterio

19
 Consultar sobre un módulo ya instalado
!pip show tensorflow

Actualizar un módulo

!pip install --upgrade tensorflow

Instalar un módulo de la versión definida

!pip install tensorflow==1.2

1.4. Instalación y configuración Python

1.4.1. Instalación de Python en Windows
Paso 1. Descargar Python de la página oficial para windows versión estable
y recomendado es 3.11.9:

https://www.python.org/downloads/release/python-3119/ , esta versión se

recomienda porque es compatible con QGIS estable y ArcGIS Pro, con
muchas librerías que funcionan correctamente.

Figura 1. Página descargar Python 3.11.9

Paso 2. Ejecutar el archivo anterior y se abrirá una ventana de install python-
3.11.9-amd64.exe (64-bit), activar Add Python 3.9 to PATH y luego
configurar la instalación en Customize installation.

20
 Figura 2. Instalación Python 3.11.9
Paso 3. En la siguiente secuencia activar todas las opciones Features.

Figura 3. Activamos todas las opciones features.

Paso 4. En este paso es muy importante crear una carpeta en el disco
C:/Python311 donde se va instalar Python. Por último botón Install.

21
 Figura 4. Crear una carpeta en C y install.
Paso 5. Ahora verificamos en inicio abrimos Símbolo del sistema buscando
CMD. Escribimos python --version donde nos responderá la versión de Python.

22
Figura 5. Ventana de Simbología del sistema ponemos Python –version.
Paso 6. Ahora vamos a instalar la librería de pandas con el comando: pip
install pandas y es muy importante estar conectado a internet para que
automáticamente se descargue e instale.

Figura 6. Instalación de la librería de pandas

También se va instalar sus dependencias de la librería.

Figura 7. Visualización de la instalación de dependencia pandas.

Paso 7. Actualizar pip, si nos indica en el sistema de simbología con el
comando: python.exe -m pip install --upgrade pip.

Paso 8. Para el mejor aprendizaje en Python se va utilizar Jupyter notebook:

pip install jupyter notebook y Jupyter lab: pip install jupyterlab.

Figura 8. Instalación de Jupyter Notebook y Lab.

23
Paso 9. Luego de instalar las librerías básicas vamos a iniciar JupyterLab:
jupyter-lab.exe.

Figura 9. Ejecutar el IDE de Jupyter-lab.exe

Paso 10. Ahora ya puedes iniciar en el mundo de Python con el mejor
Notebook JupyterLab.

Figura 10. Primera visualización de Jupyter lab.

24
1.5. Introducción de Jupyter notebook
1.5.1. Introducción al uso Jupyter Lab
El Jupyter Notebook (Cuaderno Jupyter) es un Software libre, estándares
abiertos y servicios web para computación interactiva en todos los lenguajes
de programación

JupyterLab es el último entorno de desarrollo interactivo basado en la web

para cuadernos, código y datos. Su interfaz flexible permite a los usuarios
configurar y organizar flujos de trabajo en ciencia de datos, computación
científica, SIG, Teledetección, etc.
a) Iniciando con JupyterLab
Abrir en inicio CMD (Sistema de simbología) poner el código siguiente
para abrir jupyterlab que se encuentra ya instalado en Python: Jupyter-
Lab.exe, donde esta pantalla del sistema no se debe cerrar cuando se
trabaja con JupyterLab.

Figura 11. Ejecutar jupyter-lab.exe

25
 b) Creación de carpeta
Para una forma ordenada de los archivos de los scripts, documentos,
datos espaciales, es recomendable acomodar en carpetas.

Clic en crear una

nueva carpeta
Anti clic derecho y se abrirá
esta ventana y seleccionamos
New Folder.

Figura 12. Creación de carpeta: “01_Geo_Python”.

c) Creación de scripts
Dentro de la carpeta creada 01_Geo_Python crear una sub carpeta
llamada: Script, para guardar todos los scripts que se va ir creando.

Clic en Python 3
Ubicación de la
de Notebook para
carpeta script
generar el primer
script

Figura 13. Creación de nuevo script.

d) Cambiar el nombre del script
Por defecto se crea el nombre del script, es importante cambiarlo para
saber el contenido del código. Para ello se selecciona el script que se
desea cambiar y anti clic derecho seleccionar Rename.

Figura 14. Lo cambiamos con el nombre: 01_Introduccion_Python.

26
 El trabajo en Jupyter se desarrolla a través de celdas pueden estar en
distintos modos: Código o Markdown. Mientras en el modo código se
escribirán las instrucciones para que Jupyter ejecute, en el modo
Markdown se incluirán el texto, el formato, las imágenes o el video de
acompañamiento.

Figura 15. Cambio de modos para desarrollar en Python.

1.5.2. Sintaxis básica en Python
Atajos en ambos modos:
✓ Shift + Enter: ejecute la celda actual, seleccione a continuación
✓ Ctrl + Enter: ejecutar celdas seleccionadas
✓ Alt + Enter: ejecute la celda actual, inserte a continuación
✓ Ctrl + S: guardar y controlar
Mientras está en modo comando (presione Esc para activar):
✓ A: insertar celda arriba
✓ B: insertar celda debajo
✓ X: cortar celdas seleccionadas
✓ C: copiar celdas seleccionadas
✓ V: pegar celdas debajo
✓ Y: cambiar el tipo de celda a Código
✓ M: cambiar el tipo de celda a Markdown
✓ P: abrir la paleta de comandos
Mientras está en modo de edición (presione Enter para activar):
✓ Esc: activar el modo comando
✓ Tab: finalización de código o sangría
✓ Shift + Tab: mostrar información sobre herramientas

27
 II. Variables en Python
Es un nombre que se refiere a un objeto que reside en la memoria. El objeto puede
ser de alguno de los tipos vistos (número o cadena de texto), o alguno de los otros
tipos existentes en Python.

Tipo de Variable Tipo de Variable (inglés) type()

Entero Integer int
Punto flotante Floating points float
Cadena de Caracter String str
Dato lógico Booleans bool
Lista Lists List
Diccionarios Dictionaries Dict
Tuplas Tuples tuple

Restricciones sobre los nombres de las variables

▪ ¡No pueden empezar ni contener caracteres especiales!, @, #, $, %, etc.
▪ No pueden empezar por números.
▪ No pueden ser llamadas igual que las palabras claves reservadas en Python.
▪ No pueden contener espacios.
Observación Conviene que, al darle nombre a una variable, éste tenga sentido en
cuanto al dato que guarde, para que así resulte mucho más fácil la comprensión por
parte de quien lea el código.
Palabras clave en Python

Las palabras clave en Python Para obtener una lista de todas

import keyword
print(keyword.kwlist)
['False', 'None', 'True', 'and', 'as', 'assert', 'async', 'await', 'break', 'class',
'continue', 'def', 'del', 'elif', 'else', 'except', 'finally', 'for', 'from', 'global', 'if',
'import', 'in', 'is', 'lambda', 'nonlocal', 'not', 'or', 'pass', 'raise', 'return', 'try',
'while', 'with', 'yield']

28
 Comentarios #

Dado un bloque de código, a veces puede ser útil explicar qué hace o en qué
consiste, o bien hacer que una línea no se ejecute por algún motivo, pero que siga
presente en dicho código. Si queremos hacer un comentario en una línea, utilizamos
#.
Observación. Los comentarios, como ya se ha dicho, pueden ser muy útiles a la
hora de entender nuestro código. Sin embargo, no conviene abusar de estos.

2.1. La función import

Las funciones de un módulo pueden ser importadas. Es aquí donde entra en juego
la función import. Por ejemplo, vamos a importar el módulo math, que nos va
permitir trabajar con las funciones que contiene, haciendo uso de la sintaxis
math.funcion() o math.variable.
import math
math.pi

3.141592653589793

Renombrar el nombre del módulo

Usar funciones de un módulo, puede resultar tedioso tener que poner siempre el
nombre del módulo previo a la función, por ello con la función as renombramos.
import math as mt
mt.pi

3.141592653589793

Extraer las funciones del módulo

Si por el contrario no queremos cargar todo el módulo, sino que simplemente
queremos cargar una función o una variable, lo podemos hacer de la siguiente
forma:
from math import pi
pi

3.141592653589793

29
 Ingresar en ayuda en el módulo
import math
print(help(math))
Help on built-in module math:
NAME
math
DESCRIPTION
This module provides access to the mathematical functions
defined by the C standard.

2.2. Variable número

Tipos de números
int: número entero
float: número en coma flotante
Para saber el tipo de dato de un número podemos utilizar la función type()

2.2.1. Operaciones aritméticas

La lista de operaciones aritméticas básicas que se pueden realizar de forma

predeterminada en Python se encuentra en la siguiente tabla.

Operación Símbolo Ejemplo Resultado valor

Suma + 2+2 4

Resta - 4-2 2

Multiplicación * 2*3 6

División / 4/2 2

Exponente ** 2**3 8

Residuo % 7%3 1

30
 2.2.2. Operaciones Compuestas

También puedes realizar operaciones que combinan la asignación y la

operación.

Resultado (si a =
Operador Descripción Ejemplo Notas
10 y b = 3)

+= Suma y asignación a += b 13 a se incrementa en b.

-= Resta y asignación a -= b 7 a se decrementa en b.

Multiplicación y
*= a *= b 30 a se multiplica por b.
asignación

/= División y asignación a /= b 3.333... a se divide por b.

División entera y a se divide por b y se

//= a //= b 3
asignación toma la parte entera.

a se asigna el residuo de
%= Módulo y asignación a %= b 1
a / b.

Exponenciación y a se eleva a la potencia

**= a **= b 1000
asignación de b.

2.2.3. Módulo Math

Proporciona un conjunto de funciones matemáticas para realizar cálculos

complejos, como funciones trigonométricas, exponenciales, logaritmos,
redondeos y otras operaciones matemáticas avanzadas. Este módulo es
ideal cuando necesitas precisión en cálculos matemáticos, especialmente
con operaciones que implican números reales.

2.2.3.1. Constantes
math.pi: Valor de pi (π ≈ 3.14159).
math.e: Base del logaritmo natural (e ≈ 2.71828).
print(math.pi) # 3.141592653589793
print(math.e) # 2.718281828459045

2.2.3.2. Funciones de redondeo

math.ceil(x): Redondea x hacia arriba, al entero más cercano.

31
 math.floor(x): Redondea x hacia abajo, al entero más cercano.
math.trunc(x): Trunca x, eliminando la parte decimal.
print(math.ceil(3.2)) # 4
print(math.floor(3.8)) # 3
print(math.trunc(3.9)) # 3

2.2.3.3. Potencias y raíces

math.sqrt(x): Calcula la raíz cuadrada de x.

math.pow(x, y): Eleva x a la potencia y.

math.exp(x): Calcula el valor de e^x (exponencial).

print(math.sqrt(16)) # 4.0
print(math.pow(2, 3)) # 8.0
print(math.exp(1)) # 2.718281828459045

2.2.3.4. Logaritmos
math.log(x): Calcula el logaritmo natural de x (en base e).

math.log(x, base): Calcula el logaritmo de x en una base específica.

math.log10(x): Calcula el logaritmo en base 10 de x.

math.log2(x): Calcula el logaritmo en base 2 de x.

print(math.log(10)) # 2.30258 (logaritmo natural de 10)

print(math.log(100, 10)) # 2.0
print(math.log10(100)) # 2.0
print(math.log2(8)) # 3.0

2.2.3.5. Funciones trigonométricas

math.sin(x), math.cos(x), math.tan(x): Calculan seno, coseno y
tangente de un ángulo en radianes.

math.asin(x), math.acos(x), math.atan(x): Calculan el arco seno,

arco coseno y arco tangente de x, respectivamente.

math.radians(x): Convierte x de grados a radianes.

32
 math.degrees(x): Convierte x de radianes a grados.

angulo = 90
radianes = math.radians(angulo)
print(math.sin(radianes)) # 1.0
print(math.cos(radianes)) # 0.0
print(math.degrees(math.asin(1))) # 90.0

2.3. String
Al ser una secuencia ordenada de elementos, significa que podemos usar
la indexación y seccionar la cadena de carácteres. La indexación se realiza
con corchetes [ ] luego del nombre de la variable.

Importante: Python está indexado en cero (0).

String C U R S O P Y T H O N

Índice 0 1 2 3 4 5 6 7 8 9 10 11

Índice reverso -12 -11 -10 -9 -8 -7 -6 -5 -4 -3 -2 -1

2.3.1. Operaciones con string

Operación Descripción Ejemplo Resultado Notas

Unir dos o más "Hola" + "

Concatenación "Hola Mundo" Usa el operador +.
cadenas Mundo"

Repetir una cadena

Repetición un número "Hola" * 3 "HolaHolaHola" Usa el operador *.
específico de veces

Obtener la cantidad
Longitud de caracteres en una len("Hola") 4 Retorna un entero.
cadena

Acceder a un
Los índices comienzan
Indexación carácter específico "Python"[0] 'P'
en 0.
por su índice

Obtener una El rango es inicio:fin

Slicing "Python"[1:4] "yth"
subcadena (fin excluido).

33
 2.3.2. Substrings

Para acceder a un caracter de una variable string usamos la sintaxis

de [].
a = "Soy especialista en Teledeteccion con Python"
a[0] # Primer carácter S
a[2] # tercer carácter y

2.3.3. Métodos de cambiar formato

Método Descripción Ejemplo Resultado

Convierte todos los caracteres en

.upper() "hola".upper() "HOLA"
mayúsculas

Convierte todos los caracteres en

.lower() "HOLA".lower() "hola"
minúsculas

Convierte el primer carácter en

.capitalize() "python".capitalize() "Python"
mayúscula y los demás en minúsculas

Convierte el primer carácter de cada

.title() "hola mundo".title() "Hola Mundo"
palabra en mayúscula

Cambia mayúsculas a minúsculas y "Hola

.swapcase() "hOLA mUNDO"
viceversa Mundo".swapcase()

zfill(longitud) Rellenar un texto anteponiendo ceros "52653".zfill(8) "00052653"

2.3.4. Método de búsqueda y remplazo

Método Descripción Ejemplo Resultado

Devuelve el índice de la primera

.find(substring) aparición de substring, o -1 si no se "hola".find("o") 1
encuentra

Similar a find, pero lanza un error si

.index(substring) "hola".index("a") 3
substring no se encuentra

Reemplaza todas las apariciones de old "hola

.replace(old, new) mundo".replace("mundo", "hola Python"
por new "Python")

Cuenta las veces que substring aparece

.count(substring) "banana".count("a") 3
en la cadena

34
 Verifica si la cadena comienza con sub,
.startswith(sub) "python".startswith("py") True
devuelve True o False

Verifica si la cadena termina con sub,

.endswith(sub) "python".endswith("on") True
devuelve True o False

2.3.5. Método de modificar espacio

Método Descripción Ejemplo Resultado

Elimina espacios en blanco al principio y

.strip() " hola ".strip() "hola"
al final

Elimina espacios en blanco al inicio de

.lstrip() " hola ".lstrip() "hola "
la cadena

Elimina espacios en blanco al final de la

.rstrip() " hola ".rstrip() " hola"
cadena

2.3.6. Métodos para Manipular el Contenido

Método Descripción Ejemplo Resultado

Divide la cadena en una lista de

palabras o subcadenas separadas "hola ["hola",
.split()
por un delimitador (por defecto mundo".split() "mundo"]
espacio)

Divide la cadena usando el

.split(delim,
delimitador delim, y puede limitar "a,b,c".split(",", 1) ["a", "b,c"]
maxsplit)
la cantidad de divisiones

Une los elementos de una lista o

" ".join(["hola", "hola
.join(iterable) iterable en una sola cadena, con el
"mundo"]) mundo"
string como separador

Divide la cadena en tres partes: "hola

("hola", " ",
.partition(sub) antes, el sub, y después, al mundo".partition("
"mundo")
encontrar la primera coincidencia ")

Centra la cadena en un espacio de

"hola".center(10,
.center(width) longitud width, rellenando con "--hola---"
"-")
espacios o caracteres opcionales

35
 2.3.7. Métodos para Verificar Propiedades

Método Descripción Ejemplo Resultado

.isalpha() Verifica si todos los caracteres son letras "Python".isalpha() True

Verifica si todos los caracteres son

.isdigit() "12345".isdigit() True
dígitos

Verifica si todos los caracteres son

.isalnum() "Python3".isalnum() True
alfanuméricos (letras o dígitos)

Verifica si todos los caracteres son

.isspace() " ".isspace() True
espacios en blanco

Verifica si la cadena está en formato de

.istitle() "Hola Mundo".istitle() True
título

Verifica si todos los caracteres están en

.islower() "python".islower() True
minúsculas

Verifica si todos los caracteres están en

.isupper() "PYTHON".isupper() True
mayúsculas

2.4. Boleanos
El tipo booleano sólo puede tener dos valores: True (verdadero) y False
(falso).
2.3.3.1. Creación de valores booleanos
Puedes crear valores booleanos directamente:

a = True
b = False

2.3.3.2. Operadores de comparación

En Python podemos comparar datos y obtener un resultado booleano.
Operador Descripción Ejemplo Resultado

== Igual a: verifica si dos valores son iguales. 5 == 5 True

No igual a: verifica si dos valores son

!= 5 != 3 True
diferentes.
Mayor que: verifica si el operando de la
> 5>3 True
izquierda es mayor que el de la derecha.

Menor que: verifica si el operando de la

< 3<5 True
izquierda es menor que el de la derecha.

36
 Mayor o igual que: verifica si el operando de la
>= izquierda es mayor o igual que el de la 5 >= 5 True
derecha.

Menor o igual que: verifica si el operando de la

<= izquierda es menor o igual que el de la 3 <= 5 True
derecha.

2.3.3.3. Operadores lógicos

Los operadores lógicos and, or y not se usan para combinar condiciones
y realizar evaluaciones complejas. Funcionan de la siguiente manera:
Operador Descripción Ejemplo Resultado

True and True True

True and False False

Devuelve True si ambas
and
condiciones son verdaderas
False and True False

False and False False

True or True True

True or False True

Devuelve True si al menos una
or
condición es verdadera
False or True True

False or False False

not True False

Invierte el valor de la
not
condición
not False True

2.5. Colección de datos en Python

Hay varias estructuras de datos que puedes usar para coleccionar y organizar datos.
Aquí te presento las más comunes:

Elementos
Colección Tipo Mutabilidad Ordenada Uso Común
Únicos
Almacenar secuencias
Lista list Mutable Sí No
de elementos.
Almacenar datos que
Tupla tuple Inmutable Sí No
no deben cambiar.

37
 Eliminación de
duplicados y
Conjunto set Mutable No Sí
operaciones
matemáticas.
Claves Almacenar pares
Diccionario dict Mutable No
únicas clave-valor.
Procesamiento
Array numpy.array Mutable Sí No
numérico eficiente.
Análisis de datos
DataFrame pandas.DataFrame Mutable Sí No
tabulares.

2.6. Listas
Las listas son colecciones ordenadas y mutables que permiten almacenar
elementos de diferentes tipos.
2.6.1. Tamaño de una lista
Para saber la longitud o el tamaño de una lista, podemos hacer uso de
la función len()

a = [1, 2, 3, 4, 5, 6, 7, 8, 9]
len(a) # 9

2.6.2. Acceso a los elementos de una lista

Cada elemento en la lista tiene su propio índice

names = ["Maria", "Juan", "Claudia", "Jorge", "Avelina"]

print(names[0]) # Primer elemento “Maria”

print(names[3]) # Cuarto elemento “Jorge”

print(names[-1]) # Último elemento "Avelina"

print(names[2:5]) # rango de la lista ['Claudia', 'Jorge', 'Avelina']

2.6.3. Concatenación y Repetición

• Concatenación: Une dos listas usando el operador +.
• Repetición: Repite los elementos de una lista usando *.

lista1 = [1, 2, 3]
lista2 = [4, 5]
print(lista1 + lista2) # [1, 2, 3, 4, 5]
print(lista1 * 2) # [1, 2, 3, 1, 2, 3]

38
 2.6.4. Bucles con listas¶
Si quisiéramos imprimir por pantalla todos los elementos de una lista,
lo podríamos hacer mediante los índices.

names = ["Maria", "Juan", "Claudia", "Jorge", "Avelina"]

for i in range(len(names)):
print(names[i]) # Va imprimiendo la ubicación cada nombre.

for x in names:
print(x)
# Maria
# Juan
# Claudia
# Jorge
# Avelina

2.6.5. Métodos de agregado

Método Descripción Ejemplo Resultado
Añade el elemento x al final de
append(x) lista.append(4) [1, 2, 3, 4]
la lista
Extiende la lista añadiendo
extend(iterable) todos los elementos de un lista.extend([5, 6]) [1, 2, 3, 5, 6]
iterable (otra lista, tupla, etc.)
Inserta el elemento x en el
índice i, desplazando los
insert(i, x) lista.insert(1, "Python") [1, "Python", 2, 3]
demás elementos hacia la
derecha

2.6.6. Métodos de eliminación

Método Descripción Ejemplo Resultado

Elimina la primera aparición

remove(x) lista.remove(2) [1, 3, 4]
del elemento x en la lista

Elimina y devuelve el elemento lista.pop() Elimina y devuelve

pop(i)
en el índice i; si i no se el último elemento

39
 especifica, elimina el último
elemento

Elimina todos los elementos de

clear() lista.clear() []
la lista

2.6.7. Métodos de orden

Método Descripción Ejemplo Resultado

Ordena los elementos de la

lista en orden ascendente
sort() lista.sort() Lista ordenada
(puede usarse reverse=True
para orden descendente)

Invierte el orden de los Lista en orden

reverse() lista.reverse()
elementos de la lista inverso

2.6.8. Métodos de búsqueda

Método Descripción Ejemplo Resultado

Devuelve el índice de la
index(x) primera aparición del lista.index(3) Índice del primer 3
elemento x en la lista

Devuelve el número de veces

Número de veces
count(x) que el elemento x aparece en lista.count(3)
que aparece 3
la lista

2.7. Tuplas
Es una variable que permite almacenar varios datos inmutables (no pueden
ser modificados una vez creados).
2.7.1. Tamaño de una tupla
Para saber la longitud o el tamaño de una tupla, podemos hacer uso de
la función len()

a = (1, 2, 3, 4, 5, 6, 7, 8, 9)
len(a) # 9

40
 2.7.2. Elementos de una tupla
Podemos acceder a los elementos de una tupla mediante el índice que
ocupan con la sintaxis de claudator, []

Name = "Maria", "Juan", "Claudia", "Jorge", "Avelina"

Name = ("Maria", "Juan", "Claudia", "Jorge", "Avelina")
print(Name[0]) # Primer elemento “Maria”

print(Name[3]) # Cuarto elemento “Jorge”

print(Name[-1]) # Último elemento "Avelina"

print(Name[2:5]) # rango de la lista ['Claudia', 'Jorge', 'Avelina']

2.7.3. Desempaquetado de Tuplas
Las tuplas permiten asignar múltiples variables al mismo tiempo:

tupla = (1, 2, 3)
a, b, c = tupla
print(a, b, c) # 1 2 3

2.7.4. Concatenación y Repetición

• Concatenación: Une dos tuple usando el operador +.
• Repetición: Repite los elementos de una lista usando *.

tupla1 = (1, 2, 3)
tupla2 = (4, 5)
print(tupla1 + tupla2) # (1, 2, 3, 4, 5)
print(tupla1 * 2) # (1, 2, 3, 1, 2, 3)

2.7.5. Métodos de tuplas

Sus métodos son limitados en comparación con las listas, porque son
inmutables.
Método Descripción Ejemplo Resultado
Devuelve el número de veces
Número de veces
.count(x) que el elemento x aparece en tupla.count(2)
que aparece 2
la tupla.
Devuelve el índice de la
.index(x) primera aparición del tupla.index(3) Índice del primer 3
elemento x en la tupla.

41
2.8. Conjunto
Es una estructura de datos que almacena elementos únicos y sin orden
específico. Los conjuntos se utilizan principalmente cuando se necesita
trabajar con elementos únicos y realizar operaciones como unión,
intersección y diferencia.
2.8.1. Creación de Conjuntos
Para crear un conjunto, se utiliza la función set() o llaves {}. Para crear un
conjunto vacío, es necesario usar set() en lugar de {}, ya que las llaves vacías
crean un diccionario.

# Conjunto con elementos

conjunto = {1, 2, 3, 4}

# Crear un conjunto usando la función set()

conjunto = set([1, 2, 3, 4, 2]) # Los duplicados se eliminan
automáticamente
print(conjunto) # Resultado: {1, 2, 3, 4}

# Conjunto vacío
conjunto_vacio = set()

2.8.2. Métodos de agregado

Método Descripción Ejemplo Resultado
Añade el elemento x al
.add(x) conjunto. Si ya está presente, conjunto.add(5) {1, 2, 3, 4, 5}
no hace nada.
Agrega múltiples elementos
.update(iterable) conjunto.update([6, 7]) {1, 2, 3, 4, 5, 6, 7}
de un iterable al conjunto.

2.8.3. Eliminar elementos

Método Descripción Ejemplo Resultado
Elimina el elemento x del
.remove(x) conjunto. Si no está presente, conjunto.remove(3) {1, 2, 4}
lanza un error.
Elimina el elemento x del
.discard(x) conjunto si está presente. Si no conjunto.discard(6) {1, 2, 4} (sin error)
está, no hace nada.
Elimina y devuelve un
Elimina un
.pop() elemento aleatorio del conjunto.pop()
elemento aleatorio
conjunto.
Elimina todos los elementos set() (conjunto
.clear() conjunto.clear()
del conjunto, dejándolo vacío. vacío)

42
 2.8.4. Operaciones de conjuntos
Método Descripción Ejemplo Resultado
Devuelve un nuevo
conjunto con todos
.union(otro) los elementos de a.union(b) {1, 2, 3, 4}
ambos conjuntos
(unión).
Devuelve un nuevo
conjunto con solo los
.intersection(otro) elementos presentes a.intersection(b) {2, 3}
en ambos conjuntos
(intersección).
Devuelve un nuevo
conjunto con los
elementos presentes
.difference(otro) a.difference(b) {1}
en el conjunto actual,
pero no en el otro
(diferencia).
Devuelve un nuevo
conjunto con
elementos que están
.symmetric_difference(otro) a.symmetric_difference(b) {1, 4}
en uno u otro
conjunto, pero no en
ambos.

2.8.5. Verificación de subconjuntos y superconjuntos

Método Descripción Ejemplo Resultado
Devuelve True si el conjunto
.issubset(otro) es un subconjunto del otro {1, 2}.issubset(a) True o False
conjunto.
Devuelve True si el conjunto
.issuperset(otro) es un superconjunto del otro a.issuperset({1}) True o False
conjunto.
Devuelve True si el conjunto
.isdisjoint(otro) no tiene elementos en común {1, 2}.isdisjoint({3, 4}) True o False
con otro.

2.9. Diccionario
Mientras que a las listas y tuplas se accede solo y únicamente por un número
de índice, los diccionarios permiten utilizar una clave para declarar y
acceder a un valor.

Los diccionarios, al igual que las listas, son:

43
 ✓ Hetereogéneos: los elementos pueden ser de distinto tipo en un mismo
diccionario.
✓ Mutables: los elementos pueden ser modificados.
✓ Claves únicas: Las claves deben ser únicas; si se repite una clave, el
último valor asociado a la clave será el que permanezca.

2.9.1. Creación de Diccionarios

Los diccionarios se crean usando llaves {}, donde cada elemento se
representa con clave: valor, y los pares se separan por comas.

# Diccionario vacío
mi_diccionario = {}
# Diccionario con valores
mi_diccionario = {
"nombre": "Juan",
"edad": [10,15,20,21],
"ciudad": "Madrid"
}

2.9.2. Acceso a Elementos

Podemos acceder al valor de un elemento usando su clave. Si
intentamos acceder a una clave que no existe, lanzará un error, a
menos que utilicemos el método .get().

print(mi_diccionario["nombre"]) # Salida: Juan

print(mi_diccionario.get("edad")) # Salida: [10,15,20,21]
print(mi_diccionario.get("profesion", "Desconocido")) #
Salida: Desconocido (clave no existente)

2.9.3. Modificación de los valores diccionario

mi_diccionario["nombre"] = ["Nino","Frank","Bravo"]
mi_diccionario["edad"] [2] = 36 # Salida: [10,15,36,21]

44
 2.9.4. Tamaño de un diccionario en clave
Para saber cuántos elementos contiene un diccionario, podemos usar
la función len()del siguiente modo:

dicc = {"frutas": ["Manzana", "Pera", "Naranja"],

"precio": [2, 1.5, 1],
"color": ["roja", "verde", "naranja"]}
print(len(dicc)) # resultado 3

2.9.5. Métodos Comunes de los Diccionarios

Método Descripción Ejemplo Resultado

Devuelve el valor de una

.get(clave, clave. Si la clave no existe,
mi_diccionario.get("edad") 30
valor_def) devuelve valor_def (por
defecto, None).
Devuelve una vista de las dict_keys(['nombre',
.keys() mi_diccionario.keys()
claves del diccionario. 'edad', 'ciudad'])

Devuelve una vista de los dict_values(['Juan',

.values() mi_diccionario.values()
valores del diccionario. 30, 'Madrid'])

Devuelve una vista de pares dict_items([('nombre',

.items() mi_diccionario.items()
(clave, valor) como tuplas. 'Juan'), ...])

Actualiza el diccionario con

pares clave-valor de dic, mi_diccionario.update({"edad": {'nombre': 'Juan',
.update(dic)
sobrescribiendo valores de 31}) 'edad': 31, ...}
claves existentes.

Elimina y devuelve el valor

.pop(clave, de una clave; si no existe, 30 y elimina "edad":
mi_diccionario.pop("edad")
valor_def) devuelve valor_def o lanza 30
error si no se da.
Elimina y devuelve el
último par clave-valor
Elimina y devuelve
.popitem() insertado (útil en versiones mi_diccionario.popitem()
un (clave, valor)
donde los diccionarios son
ordenados).

Elimina todos los elementos {} (diccionario

.clear() mi_diccionario.clear()
del diccionario. vacío)

Devuelve una copia nuevo_dic = Copia del

.copy()
superficial del diccionario. mi_diccionario.copy() diccionario

45
2.10. Array
Es una estructura de datos que almacena una colección de elementos del mismo
tipo. Aunque Python no tiene un tipo de datos array incorporado en su núcleo (como
lo tienen otros lenguajes como C o Java), se pueden utilizar arrays a través de la
biblioteca estándar array o, más comúnmente, con NumPy, una biblioteca externa
que permite manejar y operar con arrays de forma mucho más eficiente.

2.10.1. Módulo numpy – array

Es uno de los módulos más populares y potentes en Python para trabajar con
array y realizar operaciones matemáticas de alto rendimiento. Es
especialmente útil en el análisis de datos y en cálculos científicos debido a
su capacidad para manejar grandes volúmenes de datos de forma eficiente.

Figura 1. Representación de ndarray (multidimensional array)

2.10.1.1. Instalación de NumPy

Si aún no tienes NumPy instalado, puedes hacerlo utilizando pip:

pip install numpy

46
 2.10.1.2. Importación del Módulo

Antes de utilizar NumPy, debes importarlo:

import numpy as np

2.10.1.3. Datos de tipo arrays

tipo de
Descripción GeoTIFF
datos
np.bool_/bool Boolean (True or False) stored as a byte
np.int_/int Default integer type, normally int64
np.int8 Integer a single byte (-128–127)
np.int16 Integer 16 bits (-32768–32767) +
np.int32 Integer 32 bits (-2147483648–2147483647) +
Integer 64 bits (-9223372036854775808–
np.int64
9223372036854775807)
np.uint8 Unsigned integer 8 bits (0–255) +
np.uint16 Unsigned integer 16 bits (0–65535) +
np.uint32 Unsigned integer 32 bits (0–4294967295) +
np.uint64 Unsigned integer 64 bits (0–18446744073709551615)
np.float_/float Default float type, normally float64
np.float16 Half-precision (16 bit) float (-65504–65504)
np.float32 Single-precision (32 bit) float (1e-38–1e38) +
np.float64 Double-precision (64 bit) float (1e-308–1e308) +

2.10.1.4. Creación de Arrays

NumPy permite crear arrays de diferentes formas. Aquí algunos

métodos comunes:

a. Array a partir de una lista

# Crear un array unidimensional

array_1d = np.array([1, 2, 3, 4, 5])
print(array_1d) # Salida: [1 2 3 4 5]

47
 b. Array multidimensional

# Crear un array bidimensional (matriz)

array_2d = np.array([[1, 2, 3], [4, 5, 6]])
print(array_2d)
# Salida:
# [[1 2 3]
# [4 5 6]]

2.10.1.5. Arrays con valores iniciales

# Crear un array de ceros

zeros_array = np.zeros((3, 4)) # 3 filas y 4 columnas
print(zeros_array)
# Salida:
# [[0. 0. 0. 0.]
# [0. 0. 0. 0.]
# [0. 0. 0. 0.]]
# Crear un array de unos
ones_array = np.ones((2, 3)) # 2 filas y 3 columnas
print(ones_array)
# Salida:
# [[1. 1. 1.]
# [1. 1. 1.]]
# Crear un array de valores espaciados
arange_array = np.arange(10) # Array de 0 a 9
print(arange_array) # Salida: [0 1 2 3 4 5 6 7 8 9]
# Crear un array con valores aleatorios
random_array = np.random.rand(2, 2) # Array de 2x2 con valores
aleatorios entre 0 y 1
print(random_array)

48
 2.10.1.6. Acceso y modificación de elementos

Puedes acceder a los elementos de un array utilizando índices.

# Acceder a un elemento
elemento = array_2d[1, 2] # Elemento en la segunda fila, tercera
columna
print(elemento) # Salida: 6

# Modificar un elemento
array_2d[0, 1] = 10
print(array_2d)
# Salida:
# [[ 1 10 3]
# [ 4 5 6]]

2.10.1.7. Características de array

array_2d = np.array([[1, 2, 3], [4, 5, 6]])

# Numero de dimensión matriz
array_2d.ndim # 2
# Determinar la fila y columna matriz
array_2d.shape # (2, 3)
# Determinar la cantidad de datos
array_2d.size # 6
# Tipo de datos numérico
array_2d.dtype # dtype('int32')

# Saber el tamaño de la matriz kb

array_2d.itemsize # 4

2.10.1.8. Funciones de Redimensionamiento

Puedes cambiar la forma de un array utilizando reshape.

# Redimensionar un array
array_reshaped = array_1d.reshape((5, 1)) # Redimensionar a 5
filas y 1 columna
print(array_reshaped)
# Salida:
# [[1]
# [2]
# [3]
# [4]
# [5]]
49
 2.10.1.9. Operaciones matemáticas con array

Operación Método / Función Descripción

Suma todos los elementos del
Suma np.sum(array)
array.
Suma por Suma de elementos a lo largo de
np.sum(array, axis=0)
columnas las columnas.
Suma de elementos a lo largo de
Suma por filas np.sum(array, axis=1)
las filas.
Calcula el promedio de todos los
Promedio np.mean(array)
elementos.
Desviación Calcula la desviación estándar de
np.std(array)
estándar todos los elementos.
Producto de todos los elementos
Producto np.prod(array)
del array.
Devuelve el valor máximo del
Máximo np.max(array)
array.
Devuelve el valor mínimo del
Mínimo np.min(array)
array.
Calcula la raíz cuadrada de cada
Raíz cuadrada np.sqrt(array)
elemento.
Calcula la función exponencial de
Exponencial np.exp(array)
cada elemento.
Calcula la suma de los elementos
Suma ignorando
np.nansum(array) del array ignorando los valores
NaN
NaN.
Calcula la media de los elementos
Media
np.nanmean(array) del array ignorando los valores
ignorando NaN
NaN.
Desviación
Calcula la desviación estándar del
estándar np.nanstd(array)
array ignorando los valores NaN.
ignorando NaN
Reemplazo de
np.nan_to_num(array, Reemplaza todos los valores NaN
NaN por un
nan=valor) por un valor específico dado.
valor especÃfico
Devuelve una máscara booleana
Verificar dónde
np.isnan(array) indicando la posición de los NaN
hay NaN
en el array.
Eliminar
Elimina todos los elementos del
elementos con array[~np.isnan(array)]
array que contienen valores NaN.
NaN
Calcula el producto de los
Producto
np.nanprod(array) elementos del array ignorando los
ignorando NaN
valores NaN.
Máximo Encuentra el valor máximo del
np.nanmax(array)
ignorando NaN array ignorando los valores NaN.
Mínimo Encuentra el valor mínimo del
np.nanmin(array)
ignorando NaN array ignorando los valores NaN.

50
Cómputo de Calcula un percentil específico
np.nanpercentile(array,
percentil del array ignorando los valores
percentil)
ignorando NaN NaN.

Aplicar una función en cada fila o columna, de una matriz numpy bidimensional

51
 2.10.1.10. Guardar y Cargar Arrays

NumPy permite guardar y cargar arrays fácilmente.

# Guardar un array en un archivo

np.save('mi_array.npy', array_1d)

# Cargar el array desde el archivo

cargado = np.load('mi_array.npy')
print(cargado) # Salida: [1 2 3 4 5]

2.11. Dataframe
Es una estructura de datos bidimensional, similar a una tabla en una base de datos
o a una hoja de cálculo en Excel, que forma parte de la biblioteca Pandas en Python.
Pandas es una biblioteca esencial para la manipulación y análisis de datos, y los
DataFrames son una de sus características más poderosas. La estructura puede
compararse con los diccionarios de Python. Efectivamente, las claves son los
nombres de las columnas y los valores son las Series.

52
2.11.1. Módulo pandas
Es una librería de Python especializada en el manejo y análisis de estructuras
de datos.
Las principales características de esta librería son:

✓ Define nuevas estructuras de datos basadas en los arrays de la librería

NumPy pero con nuevas funcionalidades.
✓ Permite leer y escribir fácilmente ficheros en formato CSV, Excel y bases
de datos SQL.
✓ Permite acceder a los datos mediante índices o nombres para filas y
columnas.
✓ Ofrece métodos para reordenar, dividir y combinar conjuntos de datos.
✓ Permite trabajar con series temporales.
✓ Realiza todas estas operaciones de manera muy eficiente.
2.11.1.1. Tipos de datos de Pandas

Pandas dispone de tres estructuras de datos diferentes:

Series: Estructura de una dimensión 1D.

DataFrame: Estructura de dos dimensiones 2D (tablas).

Panel: Estructura de tres dimensiones 3D (cubos).

2.11.1.2. Instalación de Pandas

Si aún no tienes pandas instalado, puedes hacerlo utilizando

pip:

pip install pandas

53
2.11.1.3. Importación del Módulo

Antes de utilizar Pandas, debes importarlo:

import pandas as pd

2.11.1.4. Creación Dataframe

✓ Crear Dataframe a partir diccionario

Un diccionario donde las claves serán los nombres de

las columnas y los valores serán listas, con tantos
elementos como número de filas queramos.

dic = {"x": [1, 2, 3, 4, 5], "y": [2, 4, 6, 8, 10]}

df1 = pd.DataFrame(data = dic)
print(df1)
x y
0 1 2
1 2 4
2 3 6
3 4 8
4 5 10

✓ Crear Dataframe a partir lista

Vamos a crear el mismo dataframe de 5 filas y 2

columnas, pero esta vez a partir de una lista de listas.

lista = [[1, 2], [2, 4], [3, 6], [4, 8], [5, 10]]
df2 = pd.DataFrame(data = lista,
columns = ["x", "y"])
print(df2)
x y
0 1 2
1 2 4
2 3 6
3 4 8
4 5 10

54
 ✓ Crear dataframe según formato CSV

De sus opciones, seleccionamos copiar ruta. Esa ruta

será la que pasemos por parámetro a la función
read_csv()

Datos_CSV = pd.read_csv(r"Ruta\Datos_CSV.csv", delimiter=";")

Datos_CSV.head(3)
Temperatura Pais Precipitacion Altitud
0 25 Bolivia 300 1500
1 20 Brasil 325 1800
2 30 Ecuador 400 2500

✓ Crear dataframe según formato XLS o XLSX

Para importar datos Excel hay un modulo que debe

estar instalado xlrd, se estala: !pip install xlrd

df = pd.read_excel(r"Ruta\Datos_Excel.xlsx")
df.head(3)
Temperatura Pais Precipitacion Altitud
0 25 Bolivia 300 1500
1 20 Brasil 325 1800
2 30 Ecuador 400 2500

2.11.1.5. Visualización de dataframe

head(n): muestra las primeras n filas del DataFrame.

df.head(2) # Muestra las dos primeras filas
tail(n): muestra las últimas n filas del DataFrame.
df.head(2) # Muestra las dos últimas filas
info(): muestra información sobre el DataFrame,
incluyendo el número de entradas, los tipos de datos y
los valores nulos.

55
df.info()
<class 'pandas.core.frame.DataFrame'>
RangeIndex: 8 entries, 0 to 7
Data columns (total 4 columns):
# Column Non-Null Count Dtype
--- ------ -------------- -----
0 Temperatura 8 non-null int64
1 Pais 8 non-null object
2 Precipitacion 8 non-null int64
3 Altitud 8 non-null int64
dtypes: int64(3), object(1)
memory usage: 388.0+ bytes

✓ describe(): genera estadísticas descriptivas de las

columnas numéricas.

df.describe()
Temperatura Precipitacion Altitud
count 8.000000 8.000000 8.000000
mean 24.250000 361.500000 2637.500000
std 4.949747 48.983962 738.603895
min 15.000000 300.000000 1500.000000
25% 23.000000 323.750000 2325.000000
50% 25.000000 356.000000 2600.000000
75% 26.250000 388.750000 3125.000000
max 30.000000 450.000000 3600.000000

✓ shape: muestra las dimensiones del DataFrame (filas,

columnas).

df.shape
(8, 4)

✓ columns: devuelve los nombres de las columnas.

df.columns
Index(['Temp', 'Pais', 'Prep', 'Altitud'], dtype='object')

Seleccionando las columnas se puede modificar el total,

sabiendo el número de columnas.

56
 df.columns = ["TEMP", "PAIS","PREP","ALT"]

✓ dtypes: devuelve el tipo de dato de cada columna.

df.dtypes
Temperatura int64
Pais object
Precipitacion int64
Altitud int64
dtype: object

2.11.1.6. Selección y filtrado

loc[]
Selecciona filas y columnas por etiquetas o nombres.

df.loc[0:1, ['TEMP', 'PREP']]

TEMP PREP
0 25 300
1 20 325

iloc[]
Selecciona filas y columnas por posición (índices).

df.iloc[0]
TEMP 25
PAIS Bolivia
PREP 300
ALT 1500
Name: 0, dtype: object

at[]
Accede a un único valor utilizando etiquetas.

dato = df.at[1, 'TEMP']

print(dato)
20

iat[]
Accede a un único valor utilizando índices.

57
 dato = df.iat[1, 2]
print(dato)
325

filter()
Filtra el DataFrame por nombres de columnas o
índices específicos.

dato = df.filter(items=['TEMP'], axis=1)

dato.head(3)
TEMP
0 25
1 20
2 30

2.11.1.7. Operaciones de datos

sort_values(by, ascending=True):
Ordena los datos por una o varias columnas.

dato = df.sort_values(by='TEMP', ascending=False)

dato.head(5)
TEMP PAIS PREP ALT
2 30 Ecuador 400 2500
4 30 Chile 320 2600
0 25 Bolivia 300 1500
3 25 Colombia 450 3000
7 25 Peru 385 2600

sort_index():
Ordena por el índice.

dato = df.sort_index(ascending=False)
dato.head(5)
TEMP PAIS PREP ALT
7 25 Peru 385 2600
6 24 Ecuador 360 3500
5 15 Peru 352 3600
4 30 Chile 320 2600
3 25 Colombia 450 3000

58
 dropna():
Elimina filas (por defecto) o columnas con valores
nulos (NaN).

base = pd.DataFrame({"A":[1, 5, 4, 7],

"B":[3, 4, 1, np.nan],
"C":[np.nan, 2, 2, 3]},
index=["Ene", "Feb", "Mar", "Abr"])
A B C
Ene 1 3.0 NaN
Feb 5 4.0 2.0
Mar 4 1.0 2.0
Abr 7 NaN 3.0

base.dropna()
A B C
Feb 5 4.0 2.0
Mar 4 1.0 2.0

fillna(valor):
Rellena los valores nulos con un valor específico, como
0, media, etc.

base.fillna(0)
A B C
Ene 1 3.0 0
Feb 5 4.0 2.0
Mar 4 1.0 2.0
Abr 7 0 3.0

drop(columns=['col1', 'col2']):
Elimina columnas específicas.

base.drop(columns=[“A”,“C”])
B
Ene 3.0
Feb 4.0
Mar 1.0
Abr 0

59
 drop_duplicates():
Elimina filas duplicadas.
subset: Etiqueta de columna o secuencia de etiquetas,
opcional Considere solo ciertas columnas para
identificar duplicados, por defecto utiliza todas las
columnas.
Keep: Si queremos conservar la primera o última
aparición de cada valor duplicado con el parámetro keep,
defecto es first.
'first': Elimina duplicados excepto la primera aparición.
'last': Elimina duplicados excepto la última aparición.
`False`: Elimina todos los duplicados.

df_sin = base.drop_duplicates(subset=['C'], keep='last')

A B C
Ene 1 3.0 0
Mar 4 1.0 2.0
Abr 7 0 3.0

replace():
reemplaza valores específicos en el DataFrame.

df_sin['B'] = df_sin['B'].replace({3.0: 10})

A B C
Ene 1 10 0
Mar 4 1.0 2.0
Abr 7 0 3.0
rename(columns={'old_name': 'new_name'}):
renombra columnas.

df_sin['B'] = df_sin.rename({“B”:“N”})
A N C
Ene 1 10 0
Mar 4 1.0 2.0
Abr 7 0 3.0

60
2.11.1.8. Operaciones Estadísticas

mean(), sum(), min(), max()

Calcula estadísticas como media, suma, valor mínimo y máximo
para cada columna o fila.
TEMP PAIS PREP ALT
0 25 Bolivia 300 1500
1 20 Brasil 325 1800
2 30 Ecuador 400 2500
3 25 Colombia 450 3000
4 30 Chile 320 2600
5 15 Peru 352 3600
6 24 Ecuador 360 3500
7 25 Peru 385 2600

df["TEMP"].mean() # 24.25
df["TEMP"].sum() # 194
df["TEMP"].min() # 15
df["TEMP"].max() # 30

value_counts()

Cuenta la frecuencia de cada valor en una columna

específica.

df.value_counts("PAIS")
PAIS
Ecuador 2
Peru 2
Bolivia 1
Brasil 1
Chile 1
Colombia 1
Name: count, dtype: int64

61
 count()

Cuenta el número de valores, sin los valores nulos NaN.

base.count()
A 4
B 3
C 3
dtype: int64

corr()
Calcula la correlación entre columnas numéricas.

df[["TEMP","ALT","PREP"]].corr()
TEMP ALT PREP
TEMP 1.000000 -0.280369 0.155550
ALT -0.280369 1.000000 0.464151
PREP 0.155550 0.464151 1.000000

std(), var()
Calcula la desviación estándar y la varianza,
respectivamente.

df[["TEMP","ALT","PREP"]].std()
TEMP 4.949747
ALT 738.603895
PREP 48.983962
dtype: float64

df[["TEMP","ALT","PREP"]].var()
TEMP 24.500000
ALT 545535.714286
PREP 2399.428571
dtype: float64

62
2.11.1.9. Agrupamiento y manipulación avanzada

groupby('columna')
agrupa el DataFrame por una o varias columnas.

# Agrupamiento de PAIS y el promedio de TEMP.

dato = df.groupby('PAIS')['TEMP'].mean()
PAIS
Bolivia 25.0
Brasil 20.0
Chile 30.0
Colombia 25.0
Ecuador 27.0
Peru 20.0
Name: TEMP, dtype: float64

pivot_table()
Crea una tabla pivote o tabla dinámica.
aggfunc puede tomar varias funciones de agregación
como sum, mean, count, min, max, entre otras.

# Crea tabla dinámica

tabla_pivot = df.pivot_table(values='TEMP', index='PAIS',
columns='ALT', aggfunc='sum')
ALT 1500 1800 2500 2600 3000 3500 3600
PAIS
Bolivia 25.0 NaN NaN NaN NaN NaN NaN
Brasil NaN 20.0 NaN NaN NaN NaN NaN
Chile NaN NaN NaN 30.0 NaN NaN NaN
Colombia NaN NaN NaN NaN 25.0 NaN NaN
Ecuador NaN NaN 30.0 NaN NaN 24.0 NaN
Peru NaN NaN NaN 25.0 NaN NaN 15.0Name: TEMP,
dtype: float64
Donde values son los valores de los datos que va sumar
según el index que sería la fila (PAIS) y columna (ALT).

# Definición de la función personalizada

rango(series):
return series.max() - series.min()

63
# Crea tabla dinámica con función personalizada
tabla_pivot = df.pivot_table(values='TEMP', index='PAIS',
columns='ALT', aggfunc=rango)

melt()
Convierte un DataFrame ancho en uno largo.

# Crear un DataFrame de ejemplo

data = {
'Producto': ['A', 'B', 'C'],
'Q1': [150, 200, 300],
'Q2': [200, 240, 320],
'Q3': [250, 300, 400],
'Q4': [300, 350, 450]
}
df = pd.DataFrame(data)
Producto Q1 Q2 Q3 Q4
0 A 150 200 250 300
1 B 200 240 300 350
2 C 300 320 400 450

# Usar melt para transformar el DataFrame

df_melted = pd.melt(df, id_vars=['Producto'], var_name='Muestra',
value_name='Medida')
Producto Muestra Medida
0 A Q1 150
1 B Q1 200
2 C Q1 300
3 A Q2 200
4 B Q2 240
5 C Q2 320
6 A Q3 250
7 B Q3 300
8 C Q3 400
9 A Q4 300
10 B Q4 350
11 C Q4 450

64
 merge()

Se utiliza para combinar dos DataFrames basándose en

una o más claves comunes. Es similar a las uniones en
SQL.

# DataFrame de productos
productos = pd.DataFrame({'ProductoID': [1, 2, 3],
'Nombre': ['P-A', 'P-B', 'P-C']})
ProductoID Nombre
0 1 P-A
1 2 P-B
2 3 P-C

# DataFrame de ventas
ventas = pd.DataFrame({
'VentaID': [101, 102, 103, 104],
'ProductoID': [1, 2, 2, 3],
'Cantidad': [5, 10, 15, 20]
})
VentaID ProductoID Cantidad
0 101 1 5
1 102 2 10
2 103 2 15
3 104 3 20

# Usar merge para combinar los DataFrames

resultado = pd.merge(ventas, productos, on='ProductoID')
VentaID ProductoID Cantidad Nombre
0 101 1 5 P-A
1 102 2 10 P-B
2 103 2 15 P-B
3 104 3 20 P-C

65
 concat():

concatena DataFrames por filas o columnas.

# Crear dos DataFrames de ejemplo

df1 = pd.DataFrame({
'A': [1, 2, 3],
'B': ['a', 'b', 'c']})
df2 = pd.DataFrame({
'A': [4, 5, 6],
'B': ['d', 'e', 'f']})
# Concatenar los DataFrames verticalmente
result = pd.concat([df1, df2], ignore_index=True)
print(result)
A B
0 1 a
1 2 b
2 3 c
3 4 d
4 5 e
5 6 f

2.11.1.10.Funciones de aplicación

apply(funcion)
Aplica una función a lo largo de un eje (columnas o
filas).

# Crear un DataFrame de ejemplo

data = {'Nombre': ['Ana', 'Luis', 'Pedro'],
'Edad': [23, 30, 25],
'Salario': [3000, 4000, 3500]}
df = pd.DataFrame(data)
# Definir una función que calcule el salario anual
def calcular_salario_anual(salario):
return salario * 12
# Usar apply para calcular el salario anual
df['Salario Anual'] = df['Salario'].apply(calcular_salario_anual)
print(df)
Nombre Edad Salario Salario Anual
0 Ana 23 3000 36000
1 Luis 30 4000 48000
2 Pedro 25 3500 42000

66
 applymap(funcion)
aplica una función a cada elemento del DataFrame.

# Crear un DataFrame de ejemplo

data = {'A': [1, 2, 3],
'B': [4, 5, 6],
'C': [7, 8, 9]}
df = pd.DataFrame(data)
# Definir una función que eleva al cuadrado
def elevar_al_cuadrado(x):
return x ** 2
# Usar applymap para aplicar la función a cada elemento del
DataFrame
df_cuadrado = df.applymap(elevar_al_cuadrado)
print(df_cuadrado)
A B C
0 1 16 49
1 4 25 64
2 9 36 81

map()
Aplica una función a cada elemento de una serie.

# Crear un DataFrame de ejemplo

data = { 'Nombre': ['Alice', 'Bob', 'Charlie'],
'Edad': [25, 30, 35]}
df = pd.DataFrame(data)
print(df)
Nombre Edad
0 Alice 25
1 Bob 30
2 Charlie 35

# Función para clasificar la edad

def clasificar_edad(edad):
if edad < 30:
return 'Joven'
elif edad < 40:
return 'Adulto'
else:
return 'Mayor'

67
# Aplicar map() a la columna 'Edad'
df['Clasificación'] = df['Edad'].map(clasificar_edad)
print(df)
Nombre Edad Clasificación
0 Alice 25 Joven
1 Bob 30 Adulto
2 Charlie 35 Adulto

agg(funcion)
Aplica una o varias funciones de agregación.

# Crear un DataFrame
data = { 'Grupo': ['A', 'A', 'B', 'B', 'C', 'C'],
'Valor': [10, 20, 30, 40, 50, 60],
'Cantidad': [1, 2, 1, 2, 1, 2]}
df = pd.DataFrame(data)
print(df)
Grupo Valor Cantidad
0 A 10 1
1 A 20 2
2 B 30 1
3 B 40 2
4 C 50 1
5 C 60 2

# Agrupar por 'Grupo' y aplicar múltiples funciones de agregación

resultado = df.groupby('Grupo').agg({
'Valor': ['sum', 'mean'], # Sumar y calcular la media
'Cantidad': ['sum', 'count'] # Sumar y contar
})
print(resultado)
Valor Cantidad
sum mean sum count
Grupo
A 30 15.0 3 2
B 70 35.0 3 2
C 110 55.0 3 2

68
2.11.1.11.Manejo de fechas y tiempos

to_datetime()
convierte una columna en formato de fecha.

# Crear un DataFrame
data = {'Fecha': ['2024-01-01', '2024-02-15', '2024-03-10', '2024-04-22'],
'Valor': [100, 200, 300, 400]}
df = pd.DataFrame(data)
print(df)
Fecha Valor
0 2024-01-01 100
1 2024-02-15 200
2 2024-03-10 300
3 2024-04-22 400

# Convertir la columna 'Fecha' a tipo datetime

df['Fecha'] = pd.to_datetime(df['Fecha'])
print(df)
Fecha Valor
0 2024-01-01 100
1 2024-02-15 200
2 2024-03-10 300
3 2024-04-22 400

dt()
Permite acceder a atributos de fechas, como año, mes,
día, hora, etc.

# Extraer el año y el mes

df['Año'] = df['Fecha'].dt.year
df['Mes'] = df['Fecha'].dt.month
df['Dia'] = df['Fecha'].dt.day
df['Nom_Mes'] = df['Fecha'].dt.month_name()
df['Fecha_format'] = df['Fecha'].dt.strftime('%d-%m-%Y')
print(df)
Fecha Valor Año Mes Dia Nom_Mes Fecha_format
0 2024-01-01 100 2024 1 1 January 01-01-2024
1 2024-02-15 200 2024 2 15 February 15-02-2024
2 2024-03-10 300 2024 3 10 March 10-03-2024
3 2024-04-22 400 2024 4 22 April 22-04-2024

69
2.11.1.12.Guardar un DataFrame

Guardar en formato CSV

df.to_csv('datos.csv', index=False) # index=False para no guardar el índice

Guardar en formato XSL

Puedes guardar un DataFrame en un archivo de Excel

usando to_excel(). Necesitarás tener openpyxl o
xlsxwriter instalado.

df.to_excel('datos.xlsx', index=False) # index=False para no guardar el índice

70
 III. Estructuras de control de flujo e interacción
3.1. Estructuras de Control de Decisión
Las estructuras de control de decisión (if, elif, else) permiten tomar decisiones en el
flujo de ejecución del programa.

3.1.1. Decisión if

Cuando queremos comprobar si se cumple alguna condición, utilizamos

el operador de decisión if. La sintaxis que debemos seguir es la siguiente:

Temp = 21
if (Temp >= 16 and Temp <= 31):
print("Es una temperatura adecuado")

3.1.2. Decisión else

Ahora, nos podríamos preguntar qué le podríamos decir al usuario en el

caso en que no satisfaga la condición. Ahí es donde entra en juego el
operador de decisión else. Esta vez, la sintaxis a seguir es la siguiente:

Temp = 14
if (Temp >= 16 and Temp <= 30):
print("Es una temperatura adecuado")
else:
print("No es una temperatura adecuada")

3.1.3. Decisión elif

Ahora, en vez de comprobar si se cumple o no una condición, nos

podríamos preguntar cómo haríamos para comprobar más de una
condición. podríamos hacerlo utilizando el operador de decisión elif.

71
 Temp = 26

if Temp >= 40:

print("Temperatura alta mayor a 40", ",porque el valor es:", Temp)

elif Temp >= 30:

print("Temperatura alta mayor a 30", ",porque el valor es:", Temp)

elif Temp >= 20:

print("Temperatura alta mayor a 20", ",porque el valor es:", Temp)

elif Temp >=10:

print("Temperatura alta mayor a 10", ",porque el valor es:", Temp)

else:

print("Temperatura menor a 10", ",porque el valor es:", Temp)

3.2. Operadores de iteración

Ejecutar repetidamente un bloque de código hasta que se cumpla una
condición específica o se recorran todos los elementos de una colección.

3.2.1. Ciclo for

Se utiliza para iterar sobre una secuencia (como una lista, una cadena o
un rango) y ejecutar un bloque de código por cada elemento en esa
secuencia. Este tipo de iteración se denomina iteración definida, ya que
el número de iteraciones está determinado por la longitud de la secuencia.

72
 frutas = ["manzana", "banana", "cereza"]

for fruta in frutas:

print(fruta)

Usando range() en for

La función range() se utiliza para generar una secuencia de números y
es útil para realizar un número específico de iteraciones:

for i in range(5):

print(i) # Imprime los números del 0 al 4

3.2.2. Ciclo while

Ejecuta un bloque de código mientras una condición sea verdadera. Es

conocido como iteración indefinida, ya que el número de iteraciones no
está predefinido, sino que depende de cuándo se cumpla o deje de
cumplirse la condición.

contador = 0

while contador < 5:

print(contador)

contador += 1

73
 IV. Funciones en Python

Es la forma de agrupar expresiones y sentencias (algoritmos) que realicen determinadas

acciones, pero que éstas, solo se ejecuten cuando son llamadas. Es decir, que al colocar
un algoritmo dentro de una función, al correr el archivo, el algoritmo no será ejecutado si
no se ha hecho una referencia a la función que lo contiene.

def nombre_funcion(parametros):
# Código de la función
return resultado # Opcional

Características:
def: Es la palabra clave para definir una función.
nombre_funcion: El nombre que le das a la función.
parametros: Los valores de entrada que la función recibe (opcional).
return: Palabra clave para devolver un valor (opcional).

4.1. Función sin parámetros ni retorno

Esta función simplemente imprime un mensaje.

def saludar():
print("¡Hola! Bienvenido a Python.")
saludar()

4.2. Función con parámetros

Esta función recibe dos números y los suma.

def sumar(a, b):

resultado = a + b
return resultado
suma = sumar(3, 5)
# Salida: La suma es: 8

74
4.3. Función con valores por defecto
Puedes dar valores predeterminados a los parámetros para que, si no
se pasa un valor, use el predeterminado.

def saludar(nombre="invitado"):
print("Hola", nombre)
saludar() # Salida: Hola, invitado!
saludar("Juan") # Salida: Hola, Juan!

4.4. Función con múltiples parámetros y retorno de varios valores

Esta función calcula el área y el perímetro de un rectángulo y retorna
ambos valores.

def calcular_rectangulo(largo, ancho):

area = largo * ancho
perimetro = 2 * (largo + ancho)
return area, perimetro

a, p = calcular_rectangulo(5, 3)
print("Área:", a) # Salida: Área: 15
print("Perímetro:", p) # Salida: Perímetro: 16

75
 V. Visualización de datos
5.1. Matplotlib
Creada en 2003 por John Hunter, nace como una alternativa a MATLAB. Se ha
convertido en una de las librerías de visualización más antiguas, pero sobre todo,
es sin duda la más popular.

5.1.1. Instalación
Para empezar a usar Matplotlib, primero necesitas instalarla. Puedes hacerlo
utilizando pip:

pip install matplotlib

5.1.2. Importación
Una vez que hayas instalado Matplotlib, puedes importarla en tu script de
Python. Es común importar el módulo pyplot, que proporciona una interfaz
similar a MATLAB para la creación de gráficos:

import matplotlib.pyplot as plt

5.1.3. Característica al utilizar matplotlib

5.1.3.1. Estilo de marcadores
Los tipos de marcadores disponibles en matplotlib
Cuadro 1. Tipos de marcadores en matplotlib.
Marcado Simbología Descripción

"." Punto

"," Pixel

"o" Círculo

"v" Triángulo hacia abajo

"^" Triángulo hacia arriba

"<" Triángulo hacia la izquierda

">" Triángulo hacia la derecha

76
 "1" Triángulo inferior

"2" Triángulo superior

"3" Triángulo izquierdo

"4" Triángulo derecho

"8" Octagonal

"s" Cuadrado

"p" Pentágono

"P" Cruz rellenado

"*" Estrella

"h" Hexágono 1

"H" Hexágono 2

"+" Signo más

"x" Letra 'x'

"X" Letra 'X' relleno

"D" Diamante

"d" Diamante pequeño

"|" Linea vertical

"_" Línea horizontal

5.1.3.2. Estilo de líneas

Cuadro 2. Estilo de tipo de línea en matplotlib
Símbolo Código Descripción
- '-' Línea sólida
-- '--' Línea discontinua
-. '-.' Línea con guiones y puntos
: ':' Línea punteada

77
5.1.3.3. Estilo de temas
Matplotlib tiene una lista de estilos de presentaciones de gráficos ya
diseñados.

print(list(plt.style.available))
['Solarize_Light2', '_classic_test_patch', '_mpl-gallery', '_mpl-
gallery-nogrid', 'bmh', 'classic', 'dark_background', 'fast',
'fivethirtyeight', 'ggplot', 'grayscale', 'seaborn-v0_8', 'seaborn-v0_8-
bright', 'seaborn-v0_8-colorblind', 'seaborn-v0_8-dark', 'seaborn-
v0_8-dark-palette', 'seaborn-v0_8-darkgrid', 'seaborn-v0_8-deep',
'seaborn-v0_8-muted', 'seaborn-v0_8-notebook', 'seaborn-v0_8-
paper', 'seaborn-v0_8-pastel', 'seaborn-v0_8-poster', 'seaborn-v0_8-
talk', 'seaborn-v0_8-ticks', 'seaborn-v0_8-white', 'seaborn-v0_8-
whitegrid', 'tableau-colorblind10']

# Aplicar un estilo
plt.style.use('seaborn-v0_8-ticks')

78
5.1.4. Gráfico en matplotlib
5.1.3.4. plt.plot() lineal
Muestra la relación entre dos variables, típicamente con una variable
independiente en el eje X y una dependiente en el eje Y, método
lineal.

# Crear un DataFrame
datos = {'Tiempo': ['10:00', '11:00', '12:00', '13:00', '14:00'],
'Temperatura': [19, 22, 27, 29, 26]}
df = pd.DataFrame(datos)
x = df['Tiempo']
y = df['Temperatura']
# Grafico tipo lineal
plt.plot(x, y, # lista X y Y
label='Temperatura', # Etiqueta leyenda
marker='o', # tipo marcador
markersize=6, # tamaño marcador
markerfacecolor='red', # color marcador
color='blue', # Color linea
linewidth=1, # ancho linea
linestyle='--') # Tipo de linea
plt.xlabel("Hora del día", # Etiqueta x
fontsize=12, # Tamaño de fuente 12
fontname='Comic Sans MS')
plt.ylim(16, 32) # Rango de limite Y
plt.xlim(-0.5, 4.5) # Rango de limite X
plt.ylabel("Temperatura (°C)", # Etiqueta y
fontsize=12, # Tamaño de fuente 12
fontname='Comic Sans MS')
plt.title("Temperatura a lo largo del día", fontsize=16, color='red',
fontname='Comic Sans MS',# tipo letra
fontweight="bold") # Negrita
plt.grid(True, # Activa la cuadrícula
axis='y', # Mostrar linea y
color='gray', # color linea
linestyle='-.', # tipo linea
linewidth=0.5, # ancho linea
alpha=0.5) # transparencia
plt.legend(prop={'family': 'Comic Sans MS', 'size': 10}) # activar leyenda
# Añadir etiquetas en cada punto
for i in range(len(x)):
plt.text(x[i], y[i]+0.3, # Ubicacion etiqueta
y[i], fontsize=11, ha='center', # 'left','right' y 'center'
va='bottom') # 'bottom','top','center' y 'baseline'
plt.tight_layout() # Ajustar el diseño
plt.savefig("grafico_plot.jpg", dpi=300)
plt.show() # Mostrar grafico

79
5.1.3.5. plt.bar() – barra
Muestra categorías en el eje X y su frecuencia o valor en el eje Y.
Ideal para comparar diferentes categorías. Y barh es en horizontal.

categorias = ['A', 'B', 'C']

valores = [10, 15, 7]
plt.bar(categorias, valores, width=0.5, color=['lightgreen', 'lightblue',
'lightpink'],
edgecolor='black', linewidth=1.2,alpha=0.7)
# Añadir etiquetas encima de cada barra
for i, valor in enumerate(valores):
plt.text(i, valor + 0.5, str(valor), ha='center', va='bottom')
plt.ylim(0, 20)
plt.xlim(-0.5, 2.5)
plt.title('Comparación de categorías', fontsize=16,# Tamaño de fuente 16
color='red', # color
fontname='Comic Sans MS',# tipo letra
fontweight="bold")
plt.xlabel('Categorías',fontsize=12, # Tamaño de fuente 12
fontname='Comic Sans MS')
plt.ylabel('Valores',fontsize=12, # Tamaño de fuente 12
fontname='Comic Sans MS')
plt.grid(True, # Activa la cuadrícula
axis='y', # Mostrar linea y
color='gray', # color linea
linestyle='-.', # tipo linea
linewidth=0.7, # ancho linea
alpha=0.5) # transparencia
plt.tight_layout() # Ajustar el diseño
plt.savefig("grafico_barra.jpg", dpi=300)
plt.show()

80
5.1.3.6. plt.scatter() – dispersión
Útil para identificar correlaciones y patrones.

x = [1, 2, 3, 4, 5]
y = [7, 5, 2, 4, 3]
plt.figure(figsize=(8, 6))
plt.scatter(x, y, edgecolor='black',color="red", marker='s') # tipo marcador
plt.title('Relación entre Variable X e Y', fontsize=14, fontweight='bold')
plt.xlabel('Variable X', fontsize=12)
plt.ylabel('Variable Y', fontsize=12)
plt.grid(True, which='both', linestyle='--', linewidth=0.5, alpha=0.7)
for i in range(len(x)):
plt.text(x[i], y[i]+0.15,
f'({x[i]}, {y[i]})', # forma etiqueta
fontsize=10, ha='center', # 'left','right' y 'center'
va='bottom') # 'bottom','top','center' y 'baseline'
plt.tight_layout() # Ajustar el diseño
plt.savefig("grafico_dispersion.jpg", dpi=300)
plt.show()

81
5.1.3.7. plt.hist() – histograma
Visualización de la distribución de un conjunto de datos
cuantitativos, Muestra cómo los datos se agrupan en intervalos
(bins).
bins: Controla la cantidad de barras en el histograma.
import numpy as np
datos = [1, 2, 2, 2, 3, 3, 3, 3, 3, 3, 4, 5]
mean = np.mean(datos)

frecuencia, bin_edges, patches = plt.hist(datos, bins=4, color='red',

alpha=0.7, edgecolor='black', linewidth=1.2)
plt.ylim(0, 7)
plt.xlim(0.5, 5.5)
plt.xlabel('Valores', fontsize=12,fontname='Comic Sans MS')
plt.ylabel('Frecuencia', fontsize=12,fontname='Comic Sans MS')
plt.axvline(mean, color='red', linestyle='--', linewidth=1.5, label='Media: '+
str(round(mean,2)))
plt.legend(prop={'family': 'Comic Sans MS', 'size': 10})
plt.title('Histograma de Frecuencia', fontsize=14, fontweight='bold')
plt.grid(True, which='both', linestyle='--', linewidth=0.5, alpha=0.7)
# Añadir etiquetas de frecuencia en cada barra
for i in range(len(patches)):
# Posición de la etiqueta
bin_center = (bin_edges[i] + bin_edges[i + 1]) / 2
plt.text(bin_center, frecuencia[i] + 0.2, # ubicacion etiqueta
str(int(frecuencia[i])), ha='center', fontsize=10)
plt.tight_layout() # Ajustar el diseño
plt.savefig("grafico_histograma.jpg", dpi=300)
plt.show()

82
5.1.3.8. plt.pie() – circular
Representación de datos cualitativos para mostrar la proporción de
cada categoría. Visualiza la contribución de cada categoría al total.

etiquetas = ['A', 'B', 'C']

valores = [23, 36, 70]
colors = ['lightblue', 'lightgreen', 'lightcoral']
plt.pie(valores,
labels=etiquetas, colors=colors,
autopct='%1.2f%%', # muestra valores en % y decimales
wedgeprops={'edgecolor': 'black'} # borde
)
plt.title('Distribución de Categorías', fontsize=16, fontweight='bold')
plt.tight_layout()
plt.savefig("grafico_circulo.jpg", dpi=300)
plt.show()

5.1.3.9. plt.boxplot() – caja y bigotes

Representación de datos cuantitativos, útil para mostrar la
distribución, la mediana y los valores atípicos. Indica el rango
intercuartílico y posibles outliers o valores atípicos.

83
data = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10,10,20,21,22]
mean_d = np.mean(data)
box = plt.boxplot(data,
patch_artist=True,
widths=0.5,
boxprops=dict(facecolor='lightblue', color='blue'),
capprops=dict(color='magenta'),
medianprops=dict(color='red')) # mediana
plt.title('Boxplot', fontsize=16, fontweight='bold',fontname='Comic Sans
MS')
plt.xlabel('Grupos', fontsize=14)
plt.ylabel('Valores', fontsize=14)
plt.ylim(0, 23)
# Añadir líneas de referencia opcionales para resaltar rangos
plt.axhline(y=np.mean(data), color='green', linestyle='--',
linewidth=1, label='Media: '+ str(round(mean_d,2)))
plt.legend(prop={'family': 'Comic Sans MS', 'size': 10})
plt.grid(axis='y', linestyle='--', linewidth=0.5, alpha=0.7)
plt.tight_layout()
plt.savefig("grafico_boxplot.jpg", dpi=300)
plt.show()

84
5.1.5. plt.subplots() – ajuste figura
Un subplot es una parcela dentro de una figura de Matplotlib en la que se
puede dibujar un gráfico independiente. Al combinar varios subplots, se
puede crear una cuadrícula de gráficos, cada uno con su propio eje, título y
contenido.

# Generar datos
x = ['A', 'B', 'C', 'D']
y = [10, 15, 7, 20]
data = np.random.randn(1000)
# Crear la figura y subplots 2x2
fig, axes = plt.subplots(2, 2, figsize=(14, 10))
fig.suptitle('Diferentes Tipos de Gráficos',
fontsize=16,fontweight='bold',fontname='Comi
c Sans MS')
# Gráfico de barras
axes[0, 0].bar(x, y, color='skyblue')
axes[0, 0].set_title('Gráfico de Barras',fontname='Comic Sans MS')
axes[0, 0].set_xlabel('Categorías')
axes[0, 0].set_ylabel('Valores')
axes[0, 0].set_ylim(0,23)
axes[0, 0].set_xlim(-0.5,3.5)
axes[0, 0].grid(axis='y', linestyle='--', linewidth=0.5)
# Histograma
axes[0, 1].hist(data, bins=20, color='lightgreen', edgecolor='black')
axes[0, 1].set_title('Histograma',fontname='Comic Sans MS')
axes[0, 1].set_xlabel('Valores')
axes[0, 1].set_ylabel('Frecuencia')
# Boxplot
axes[1, 0].boxplot(data, patch_artist=True,
boxprops=dict(facecolor='lightyellow'))
axes[1, 0].set_title('Boxplot',fontname='Comic Sans MS')
axes[1, 0].set_xlabel('Conjunto de Datos')
axes[1, 0].set_ylabel('Valores')
# Gráfico de pastel
sizes = [60, 20, 35, 45]
labels = ['A', 'B', 'C', 'D']
axes[1, 1].pie(sizes, labels=labels, autopct='%1.1f%%', startangle=140,
colors=['lightcoral', 'lightblue', 'lightgreen',
'lightgray'])
axes[1, 1].set_title('Gráfico de Pastel',fontname='Comic Sans MS')
plt.tight_layout(rect=[0, 0, 1, 0.96])
plt.savefig("grafico_subplots.jpg", dpi=300)
plt.show()

85
5.2. Seaborn – visualización datos estadísticos:
En 2012 nace de la mano de Michael Waskom, Seaborn se centra en crear
visualizaciones estadísticas avanzadas, con un mayor nivel de elaboración,
incluyendo diagramas de violín, de caja y bigotes o mapas de calor.
Seaborn es una librería de visualización de datos para Python desarrollada sobre
matplotlib. Ofrece una interfaz de alto nivel para la creación de atractivas gráficas.
Además, está íntimamente integrada con las estructuras de datos de pandas, lo que
permite utilizar el nombre de los DataFrames y campos directamente como
argumentos de las funciones de visualización.

5.2.1. Instalación
Para empezar a usar Seaborn, primero necesitas instalarla. Puedes hacerlo
utilizando pip:

pip install seaborn

86
5.2.2. Importación
Una vez que hayas instalado seaborn, puedes importarla en tu script de
Python.

import seaborn as sns

5.2.3. Temas en seaborn

5.2.3.1. Estilo (style)
• darkgrid: El estilo predeterminado de seaborn, que tiene un
fondo gris con una cuadrícula visible.
• whitegrid: Similar a darkgrid, pero con un fondo blanco, lo
cual es ideal para gráficos donde la cuadrícula es importante.
• dark: Un fondo gris oscuro sin cuadrícula, útil para gráficos
que necesitan un enfoque visual más limpio.
• white: Un fondo completamente blanco sin cuadrícula, que
ofrece un diseño simple y limpio.
• ticks: Un estilo que enfatiza las marcas de los ejes (ticks) y es
similar a white, pero con marcas visibles en los ejes.

sns.set_theme(style="darkgrid")

5.2.3.2. Paleta (palette)

Establece la paleta de colores utilizada para diferenciar los datos.
Puedes especificar:
• Paletas predefinidas como "deep", "muted", "bright", "pastel",
"dark", "colorblind".
• Paletas de matplotlib como "viridis", "plasma".
• Listas personalizadas de colores en forma de códigos
hexadecimales o nombres de colores.

sns.set_theme(palette="pastel")

5.2.3.3. Texto (context)

Controla el tamaño de los elementos de los gráficos (por ejemplo,
etiquetas y títulos). Las opciones disponibles son:

87
 • "paper": Tamaño más pequeño, ideal para gráficos en documentos
impresos.
• "notebook": Tamaño moderado, adecuado para mostrar en
pantallas de computadoras.
• "talk": Tamaño más grande, útil para presentaciones.
• "poster": Tamaño muy grande, ideal para gráficos en pósters y
presentaciones de gran formato.

sns.set_theme(context="talk")

5.2.3.4. Fuente (font)

Permite establecer la fuente de los textos en los gráficos. Puedes
usar nombres de fuentes soportadas por tu sistema, como "Arial",
"Verdana", "Comic Sans MS", etc.

sns.set_theme(font="Comic Sans MS")

5.2.3.5. Escala fuente (Font_scale)

Ajusta la escala de la fuente globalmente. Esto es útil para hacer
que los textos sean más grandes o más pequeños sin cambiar el
contexto.

sns.set_theme(font_scale=1.5)

5.2.3.6. Configuración adicional (rc)

Permite establecer configuraciones adicionales específicas
utilizando un diccionario de parámetros de matplotlib. Esto es útil
para personalizar detalles como el grosor de las líneas, la opacidad,
etc.

sns.set_theme(rc={"axes.linewidth": 1.2, "grid.alpha": 0.5})

Ahora vamos a definir todas las configuraciones de estilo en una

sola línea.

88
 # Configurar el tema de seaborn para un artículo científico
sns.set_theme(style="whitegrid",
palette="muted",
context="paper",
font="Comic Sans MS",
font_scale=1.2,
rc={"axes.titlesize": 16, "axes.labelsize": 14,
"legend.title_fontsize": 12, "legend.fontsize": 10})

5.2.4. Tipos de gráficos por funciones

5.2.4.1. Relacionales
El vínculo estadístico entre los puntos de datos se visualiza mediante
gráficos relacionales. Dado que la visualización ayuda a los seres
humanos a detectar tendencias y patrones en los datos, es
fundamental. El análisis estadístico es el proceso de determinar
cómo se relacionan entre sí las variables de un conjunto de datos y
sus relaciones.

89
 a. Relplot
Es una herramienta versátil para crear gráficos relacionales, lo que
significa que se usa para visualizar la relación entre múltiples
variables en un conjunto de datos. Esta función permite crear
gráficos de dispersión (scatter plots) y gráficos de líneas (line plots),
y es particularmente útil para explorar cómo una variable de
respuesta se relaciona con una o más variables explicativas.

# Crear un gráfico de dispersión scatter

rela = sns.relplot(x='Longitud_pico_mm', # variable x
y='Masa_g', # variable y
data=pinguinos, # dato
kind='scatter', # Determina el tipo de gráfico: "scatter" (por defecto) o "line".
hue='Especie', # Colorea los puntos continuo o categoria
style='Sexo', # formas o tipos Puntos
#s = 50, # size Tamaño del punto
#col="Isla", # col crea subgrupos visualizacion categorico
#row="Sexo" # fila crea subgrupos visualizacion categorico
)
# Cambiar titulos y ejes
for ax in rela.axes.flat:
ax.set_xlabel('Longitud del pico (mm)', fontname='Comic Sans MS', fontsize=10)
ax.set_ylabel('Masa corporal (g)', fontname='Comic Sans MS', fontsize=10)
ax.set_title("Análisis de los Pinguinos", fontweight='bold',
fontname='Comic Sans MS', fontsize=13,color = "blue")

# Personalizar la fuente de la leyenda

plt.setp(rela._legend.get_texts(), fontname='Comic Sans MS')
plt.savefig("grafico_dispersion_scatter.jpg", dpi=300, bbox_inches='tight')
plt.show()

90
# Crear un gráfico de líneas
rela = sns.relplot(x='Especie',
y='Masa_g',
data=pinguinos,
kind='line', # tipo de gráfico línea
hue='Sexo', # Colorea los línea continuo o categoría
style='Sexo', # formas o tipos Línea
errorbar=("ci", 95), # Intervalo de confianza
markers=True, # Añade marcador línea
)
# Cambiar titulos y ejes
for ax in rela.axes.flat:
ax.set_xlabel('Especies', fontname='Comic Sans MS', fontsize=10)
ax.set_ylabel('Masa corporal (g)', fontname='Comic Sans MS', fontsize=10)
ax.set_title("Análisis de los Pinguinos", fontweight='bold',
fontname='Comic Sans MS', fontsize=13,color = "blue")
# Personalizar la fuente de la leyenda
plt.setp(rela._legend.get_texts(), fontname='Comic Sans MS')
plt.savefig("grafico_dispersion_linea.jpg", dpi=300, bbox_inches='tight')
plt.show()

Línea de tendencia Barra de error

es el promedio o Intervalo de
media confianza al 95%

91
 b. Scatterplot
Esta función permite crear gráficos de dispersión

# Crear un gráfico de dispersión scatter, no se realiza col y row

rela = sns.scatterplot(x='Longitud_pico_mm', # variable x
y='Masa_g', # variable y
data=pinguinos, # dato
hue='Especie', # Colorea los puntos continuo o categoria
style='Sexo', # formas o tipos Puntos
legend = "auto", # auto, brief, full, o False
#s = 50, # size Tamaño del punto
)
# Personalizar las etiquetas de los ejes y el título utilizando Seaborn
rela.set_xlabel('Longitud del pico (mm)', fontsize=11, fontname='Comic Sans
MS')
rela.set_ylabel('Masa corporal (g)', fontsize=11, fontname='Comic Sans MS')
rela.set_title('Relación entre Longitud del Pico y Masa Corporal', fontsize=13,
fontweight='bold', fontname='Comic Sans MS')
# Personalizar la leyenda
for text in rela.legend_.get_texts():
text.set_fontsize(9)
text.set_fontname('Comic Sans MS')

# Cambiar el tamaño y tipo de fuente de los números en los ejes x e y

plt.xticks(fontsize=10, fontname='Comic Sans MS') # Personalizar los números
del eje x
plt.yticks(fontsize=10, fontname='Comic Sans MS') # Personalizar los números
del eje y
plt.grid(True, # Activa la cuadrícula
axis='y', # Mostrar linea y
color='gray', # color linea
linestyle='-.', # tipo linea
linewidth=0.5, # ancho linea
alpha=0.5)
plt.savefig("grafico_dispersion_linea2.jpg", dpi=300, bbox_inches='tight')
plt.show()

92
 c. Lineplot
Permite generar grafico de líneas.

# Crear un gráfico de líneas

rela = sns.lineplot(x='Especie',
y='Masa_g',
data=pinguinos,
hue='Sexo', # Colorea los puntos continuo o categoria
style='Sexo', # formas o tipos Puntos
errorbar=("ci", 95), # Intervalo de confianza
markers=True, # Añade marcador linea
)
# Personalizar las etiquetas de los ejes y el título utilizando Seaborn
rela.set_xlabel('Especie', fontsize=11, fontname='Comic Sans MS')
rela.set_ylabel('Masa corporal (g)', fontsize=11, fontname='Comic Sans MS')
rela.set_title('Relación entre Especie y Masa Corporal', fontsize=13,
fontweight='bold', fontname='Comic Sans MS')
# Personalizar la leyenda
for text in rela.legend_.get_texts():
text.set_fontsize(9)
text.set_fontname('Comic Sans MS')

# Cambiar el tamaño y tipo de fuente de los números en los ejes x e y

plt.xticks(fontsize=10, fontname='Comic Sans MS') # Personalizar los números
del eje x
plt.yticks(fontsize=10, fontname='Comic Sans MS') # Personalizar los números
del eje y
plt.grid(True, # Activa la cuadrícula
axis='y', # Mostrar linea y
color='gray', # color linea
linestyle='-.', # tipo linea
linewidth=0.5, # ancho linea
alpha=0.5)
d. Combinación de gráfico dpi=300, bbox_inches='tight')
plt.savefig("grafico_dispersion_linea2.jpg",
plt.show()

93
fig, axes = plt.subplots(1,2, figsize=(15,5))
fig.suptitle('Diferentes Tipos de Gráficos', fontsize=16,fontweight='bold',fontname='Comic Sans
MS')
# Crear un gráfico de dispersión scatterplot
sns.scatterplot(x='Longitud_pico_mm', # variable x
y='Masa_g', # variable y
data=pinguinos, # dato
hue='Especie', # Colorea los puntos continuo o categoria
style='Sexo', # formas o tipos Puntos
legend = "auto", # auto, brief, full, o False
#s = 50, # size Tamaño del punto
ax=axes[0]
)
# Personalizar las etiquetas de los ejes y el título utilizando Seaborn
axes[0].set_xlabel('Longitud del pico (mm)', fontsize=11, fontname='Comic Sans MS')
axes[0].set_ylabel('Masa corporal (g)', fontsize=11, fontname='Comic Sans MS')
axes[0].set_title('Relación entre Longitud del Pico y Masa Corporal', fontsize=13,
fontweight='bold', fontname='Comic Sans MS')
# Personalizar la leyenda
for text in axes[0].legend_.get_texts():
text.set_fontsize(9)
text.set_fontname('Comic Sans MS')

axes[0].grid(True, # Activa la cuadrícula

axis='y', # Mostrar linea y
color='gray', # color linea
linestyle='-.', # tipo linea
linewidth=0.5, # ancho linea
alpha=0.5)
# Crear un gráfico de líneas
sns.lineplot(x='Especie',
y='Masa_g',
data=pinguinos,
hue='Sexo', # Colorea los puntos continuo o categoria
style='Sexo', # formas o tipos Puntos
errorbar=("ci", 95), # Intervalo de confianza
markers=True, # Añade marcador linea
ax=axes[1]
)
# Personalizar las etiquetas de los ejes y el título utilizando Seaborn
axes[1].set_xlabel('Especie', fontsize=11, fontname='Comic Sans MS')
axes[1].set_ylabel('Masa corporal (g)', fontsize=11, fontname='Comic Sans MS')
axes[1].set_title('Relación entre Especie y Masa Corporal', fontsize=13, fontweight='bold',
fontname='Comic Sans MS')
# Personalizar la leyenda
for text in axes[1].legend_.get_texts():
text.set_fontsize(9)
text.set_fontname('Comic Sans MS')
axes[1].grid(True, # Activa la cuadrícula
axis='y', # Mostrar linea y
color='gray', # color linea
linestyle='-.', # tipo linea
linewidth=0.5, # ancho linea
alpha=0.5)
plt.savefig("grafico_relacion_seaborn.jpg", dpi=300, bbox_inches='tight')
plt.show()

94
5.2.4.2. Distribuciones
Es una función muy versátil que combina la funcionalidad de varios
gráficos de distribución, como histogramas, gráficos de densidad y
gráficos de rug. Es útil para visualizar la distribución de una variable
numérica de manera sencilla y eficaz. Esta función es parte del módulo
seaborn y proporciona una manera moderna y flexible de crear gráficos
de distribución
a) Histplot
- Multiple:
Layer: Superpone los histogramas, es decir, los coloca uno
sobre otro con transparencia para comparar las distribuciones.
Stack: Apila los histogramas, mostrándolos uno encima del otro
para que la altura total refleje la suma de los conteos de ambas
distribuciones.
Dodge: Coloca los histogramas uno al lado del otro en cada bin
para facilitar la comparación directa.
Fill: Muestra los histogramas de forma normalizada para que la
altura de cada bin sume a 1, facilitando la comparación de
proporciones.

95
sns.displot(data=consumos, x='Total', # si cambias en vez x a y se mostrará horizontal
kde=True, # añade una línea de estimación de densidad de kernel (KDE)
hue= "Genero", #Permite agregar una variable categórica colore
kind='hist', # hist (defecto),kde y ecdf
bins=10, # Número de intervalos en el histograma
#col="Fumador", #Permite crear múltiples gráficos
#fill=True, # Relleno
#cumulative= True, # Acumulativo
multiple="stack", # Ajusta cómo se superponen. layer, "fill", dodge, stack
ec="green", # Color borde black
#color="blue",
#palette=["red","blue"], # Asigna el color para hue ["red","blue"], Spectral
stat="count", # density probability count
)
plt.ylabel('Recuento')
plt.savefig("Grafico_histplot.jpg", dpi=300, bbox_inches='tight')
plt.show()

línea de estimación de
densidad de kernel (KDE)

Bins: 10

Nota: La línea KDE es una curva suave que representa la densidad

de probabilidad en un rango de valores de datos. Cuanto más alta es
la curva en un punto, más concentrados están los datos en esa región.

96
b) kdeplot
Se utiliza para trazar gráficos de estimación de densidad de kernel
(KDE). Esta función es especialmente útil para representar de
manera visual la densidad de una distribución de datos de forma
suave y continua. A diferencia de los histogramas, que agrupan los
datos en intervalos discretos, kdeplot proporciona una
representación más precisa y continua de cómo se distribuyen los
datos.
Univariado: La curva KDE muestra qué tan probable es encontrar
valores de datos en diferentes partes del rango. La altura de la curva
en un punto específico refleja la densidad de los datos en esa región.
Bivariado: Los contornos y áreas sombreadas indican las regiones
donde los datos se concentran más. Las zonas más oscuras
representan áreas de mayor densidad de puntos.

# Gráfico KDE univariado

sns.kdeplot(data=consumos, x='Total',
fill=True,
color='blue',
cmap='Blues'
)
plt.title('Distribución de Total factura con KDE')
plt.xlabel('Total factura')
plt.ylabel('Densidad')
plt.savefig("Grafico_kde_univariado.jpg", dpi=300, bbox_inches='tight')
plt.show()

97
 # Gráfico KDE binaria
sns.kdeplot(data=consumos, x='Total',
y='Propina',
fill=True, # relleno sino contorno
cmap='Blues' # color densidad raster
)
plt.title('Distribución Binaria de Total factura y Propina')
plt.xlabel('Total Factura')
plt.ylabel('Propina')
plt.savefig("Grafico_kde_binaria.jpg", dpi=300, bbox_inches='tight')
plt.show()

c) Ecdfplot
Es una función que representa la proporción de puntos de datos que
son menores o iguales a un valor dado en un conjunto de datos. Es
particularmente útil para:
• Mostrar la distribución de los datos de forma acumulada.
• Identificar la mediana y percentiles.
• Comparar distribuciones de diferentes grupos.
- Stat controla cómo se representan los valores en el eje y:
proportion: Úsalo cuando quieras una representación general de
la distribución en términos de fracción del total. Es útil para
entender qué parte del total está contenida en un intervalo
específico.

98
percent: Úsalo cuando quieras mostrar los resultados en un
formato más intuitivo para la audiencia, ya que los porcentajes
son fáciles de interpretar.
count: Es ideal cuando necesitas conocer el número absoluto de
observaciones acumuladas a lo largo del rango de valores.

# Gráfico ECDF univariado

sns.ecdfplot(data=consumos, x='Total')
plt.title('ECDF de Total factura')
plt.xlabel('Total factura')
plt.ylabel('Proporción Acumulada')
plt.savefig("Grafico_ecdfplot_acumulada.jpg", dpi=300,
bbox_inches='tight')
plt.show()

# Gráfico ECDF con comparación por grupo día

sns.ecdfplot(data=consumos, x='Total',
hue='Genero',
stat='proportion', # proportion(defecto),percent y count
linestyle='--', # estilo linea
palette='Set2', # color
alpha=0.8, # transparencia
)
plt.ylim(0,1.1)
plt.title('ECDF de Total factura por Genero')
plt.xlabel('Total Factura')
plt.ylabel('Proporción Acumulada')
plt.show()

99
d) Rugplot
Se representa como pequeñas marcas (o "alfombras") en la base de
un gráfico, donde cada marca indica la posición de un punto de datos.
Esto es útil para observar cómo se distribuyen los datos de forma
discreta y puede complementar otros gráficos, como histogramas,
KDEs y ECDFs, proporcionando un contexto adicional.
# Gráfico KDE con Rugplot
plt.figure(figsize=(8, 6))
sns.kdeplot(data=consumos, x='Total', fill=True, color='lightblue')
sns.rugplot(data=consumos, x='Total', height=0.1, color='blue') # Rugplot
# Personalización del gráfico
plt.title('Distribución de Total factura con Rugplot y KDE')
plt.xlabel('Total factura')
plt.ylabel('Densidad')
plt.savefig("Grafico_ecdfplot_factura_genero.jpg", dpi=300,
bbox_inches='tight')
plt.show()

100
 Nota: Complemento de un KDE o histograma: Añadir un rugplot a
un kdeplot o histograma puede ayudar a mostrar los datos
subyacentes y dar más contexto sobre la distribución.

5.2.4.3. Categóricos
son herramientas útiles para explorar la relación entre variables
categóricas y numéricas. Los gráficos categóricos permiten
visualizar distribuciones y comparaciones entre diferentes categorías
de datos.
Se va dividir en 3 funciones principales: dispersión, distribución y
estimación.
Para realizar los ejemplos se va trabajar con datos de consumos
(tips).

consumos = sns.load_dataset("tips")
consumos.columns = ["Total", "Propina", "Genero", "Fumador", "Dia", "Tipo", "Comensales"]
# cambiar nombre datos
consumos["Genero"] = consumos["Genero"].cat.rename_categories({'Male': 'Masculino', 'Female': 'Femenino'})
consumos["Dia"] = consumos["Dia"].cat.rename_categories({'Sun': 'Domingo',
'Sat': 'Sábado',
'Thur': 'Jueves',
'Fri': 'Viernes'})
consumos["Tipo"] = consumos["Tipo"].cat.rename_categories({'Dinner': 'Cena', 'Lunch': 'Almuerzo'})

A. Dispersión
- Stripplot
Es un gráfico en el que los puntos se colocan a lo largo de
una línea correspondiente a una categoría en el eje x o y. Es
similar a un gráfico de violín o un boxplot, pero en lugar de
mostrar un resumen estadístico, muestra cada punto de
datos individualmente, proporcionando una visión más
detallada de la dispersión.

101
sns.catplot(x="Dia",y="Total",
data=consumos,
hue='Comensales',
kind='strip',
col="Fumador",
s=35
)
# Personalizar el gráfico
#plt.title('Distribución de Total de Facturas por Día de la Semana', fontsize=13, fontweight='bold',
fontname='Comic Sans MS')
plt.xlabel('Día', fontsize=11, fontname='Comic Sans MS')
plt.ylabel('Total de Factura ($)', fontsize=11, fontname='Comic Sans MS')
# Cambiar el tamaño y tipo de fuente de los números en los ejes x e y
plt.xticks(fontsize=10, fontname='Comic Sans MS') # Personalizar los números del eje x
plt.yticks(fontsize=10, fontname='Comic Sans MS') # Personalizar los números del eje y
plt.grid(True, # Activa la cuadrícula
axis='y', # Mostrar linea y
color='gray', # color linea
linestyle='-.', # tipo linea
linewidth=0.5, # ancho linea
alpha=0.5)
plt.savefig("grafico_stripplot.jpg", dpi=300, bbox_inches='tight')
plt.show()

- Swarmplot
Es un tipo de gráfico de visualización de datos utilizado
principalmente para mostrar la distribución de un conjunto
de datos y resaltar la densidad de puntos en una dimensión.
Es especialmente útil cuando se desea observar la
distribución de puntos de datos individuales de una
categoría en particular.

102
sns.catplot(x="Dia",y="Total",
data=consumos,
hue='Comensales',
kind='swarm',
col="Fumador",
s=35
)
# Personalizar el gráfico
#plt.title('Distribución de Total de Facturas por Día de la Semana', fontsize=13, fontweight='bold',
fontname='Comic Sans MS')
plt.xlabel('Día', fontsize=11, fontname='Comic Sans MS')
plt.ylabel('Total de Factura ($)', fontsize=11, fontname='Comic Sans MS')

# Cambiar el tamaño y tipo de fuente de los números en los ejes x e y

plt.xticks(fontsize=10, fontname='Comic Sans MS') # Personalizar los números del eje x
plt.yticks(fontsize=10, fontname='Comic Sans MS') # Personalizar los números del eje y
plt.grid(True, # Activa la cuadrícula
axis='y', # Mostrar linea y
color='gray', # color linea
linestyle='-.', # tipo linea
linewidth=0.5, # ancho linea
alpha=0.5)
plt.savefig("grafico_swarmplot.jpg", dpi=300, bbox_inches='tight')
plt.show()

B. Distribución
- Boxplot
El boxplot (diagrama de caja) es un gráfico estadístico
estándar utilizado para mostrar la distribución de los datos
a través de sus cuartiles, destacando los valores atípicos.
Este gráfico muestra:
La caja: Representa el rango intercuartílico (IQR) que
abarca entre el primer cuartil (Q1) y el tercer cuartil (Q3).

103
 La línea en la caja (mediana): Muestra la mediana de los
datos.
Bigotes: Se extienden desde los cuartiles hasta el valor más
lejano que no se considera un valor atípico (normalmente,
un valor dentro de 1.5 veces el IQR).
Puntos fuera de los bigotes: Representan los valores
atípicos o outliers, que se encuentran fuera de los bigotes.

sns.catplot(x="Dia",y="Total",
data=consumos,
kind='box',
col="Fumador",
hue="Dia",
#color="red"
)
#plt.title('Distribución de Total de Facturas por Día de la Semana', fontsize=13,
fontweight='bold', fontname='Comic Sans MS')
plt.xlabel('Día', fontsize=11, fontname='Comic Sans MS')
plt.ylabel('Total de Factura ($)', fontsize=11, fontname='Comic Sans MS')

# Cambiar el tamaño y tipo de fuente de los números en los ejes x e y

plt.xticks(fontsize=10, fontname='Comic Sans MS') # Personalizar los números del
eje x
plt.yticks(fontsize=10, fontname='Comic Sans MS') # Personalizar los números del
eje y
plt.grid(True, # Activa la cuadrícula
axis='y', # Mostrar linea y
color='gray', # color linea
linestyle='-.', # tipo linea
linewidth=0.5, # ancho linea
alpha=0.5)
plt.savefig("grafico_boxplot.jpg", dpi=300, bbox_inches='tight')
plt.show()

104
 - Boxenplot
El boxenplot (diagrama de caja "mejorado" o "más
detallado") es una versión más avanzada del boxplot. Se
introdujo en Seaborn para manejar conjuntos de datos
grandes o distribuciones con muchos valores atípicos de
manera más efectiva.
El boxenplot ajusta dinámicamente el número de "cajas"
que se dibujan, dependiendo de la cantidad de datos y de la
distribución. De esta manera, es mejor para detectar la
variabilidad en las colas de la distribución, donde pueden
existir muchos valores atípicos.

sns.catplot(x="Dia",y="Total",
data=consumos,
kind='boxen',
col="Fumador",
hue="Dia",
#color="red"
)
#plt.title('Distribución de Total de Facturas por Día de la Semana', fontsize=13,
fontweight='bold', fontname='Comic Sans MS')
plt.xlabel('Día', fontsize=11, fontname='Comic Sans MS')
plt.ylabel('Total de Factura ($)', fontsize=11, fontname='Comic Sans MS')

# Cambiar el tamaño y tipo de fuente de los números en los ejes x e y

plt.xticks(fontsize=10, fontname='Comic Sans MS') # Personalizar los números del
eje x
plt.yticks(fontsize=10, fontname='Comic Sans MS') # Personalizar los números del
eje y
plt.grid(True, # Activa la cuadrícula
axis='y', # Mostrar linea y
color='gray', # color linea
linestyle='-.', # tipo linea
linewidth=0.5, # ancho linea
alpha=0.5)
plt.savefig("grafico_boxenplot.jpg", dpi=300, bbox_inches='tight')
plt.show()

105
- Violínplot
Es una herramienta visual poderosa que combina
características de un boxplot y un kernel density plot (KDE)
para representar la distribución de un conjunto de datos. Es
muy útil para observar tanto la distribución de los datos
como su densidad, lo que permite identificar patrones como
la asimetría, la multimodalidad, la presencia de valores
atípicos y otros detalles que no son fácilmente visibles en
un boxplot clásico.

sns.catplot(x="Dia",y="Total",
data=consumos,
kind='violin',
hue="Dia",
#color="red"
)
plt.savefig("grafico_violinplot1.jpg", dpi=300, bbox_inches='tight')
plt.show()

106
sns.catplot(x="Dia",y="Total",
data=consumos,
kind='violin',
hue="Fumador",
#split=True
#color="red"
)
plt.savefig("grafico_violinplot2.jpg", dpi=300, bbox_inches='tight')
plt.show()

sns.catplot(x="Dia",y="Total",
data=consumos,
kind='violin',
hue="Fumador",
split=True # Division
#color="red"
)
plt.savefig("grafico_violinplot3.jpg", dpi=300, bbox_inches='tight')
plt.show()

107
C. Estimación
- Pointplot
Es una visualización útil en Seaborn que se utiliza para
mostrar las relaciones entre variables categóricas y
numéricas. Este tipo de gráfico dibuja puntos que
representan medidas estadísticas (por ejemplo, medias,
medianas) de una variable numérica agrupada por
categorías de otra variable, y conecta estos puntos con
líneas para ayudar a visualizar las tendencias.

sns.catplot(x="Dia",y="Total",
data=consumos,
kind='violin',
hue="Fumador",
split=True # Division
#color="red"
)
plt.savefig("grafico_violinplot3.jpg", dpi=300, bbox_inches='tight')
plt.show()

- Barplot
Es una herramienta visual muy útil para representar datos
categóricos mediante barras. Muestra la relación entre una
variable categórica y una numérica, lo que permite
visualizar y comparar las medias (o los valores agregados)
de los grupos definidos por la variable categórica.

108
 sns.catplot(x="Dia",y="Total",
data=consumos,
kind='bar',
hue="Comensales",
#col="Fumador",
errorbar=("ci", 99),
palette='pastel' # 'deep', 'muted', 'bright', 'dark', 'colorblind',
'pastel'
)
plt.savefig("grafico_barplot.jpg", dpi=300, bbox_inches='tight')
plt.show()

- countplot
Es una visualización útil para contar y representar la
frecuencia de observaciones en una variable categórica. A
diferencia de un barplot, que muestra un resumen de datos
numéricos, el countplot se centra en contar cuántas veces
aparece cada categoría en el conjunto de datos.

ax=sns.catplot(x="Dia",
data=consumos,
kind='count',
hue="Comensales",
#col="Fumador",
palette='Spectral' # 'deep', 'muted', 'bright', 'dark', 'colorblind',
'pastel' viridis
)
# Mostrar el gráfico
plt.title('Distribución de visitas por día')
plt.xlabel('Día de la semana')
plt.ylabel('Recuento')
plt.savefig("grafico_count.jpg", dpi=300, bbox_inches='tight')
plt.show()

109
110
 VI. Variables estadísticas y gráficos

Es elementos de una población o muestra que queremos describir. Puede tomar una serie
de valores.
6.1. Variable cualitativa (Categórico)
6.1.1. Nominales
Son variables que representan categorías sin un orden específico, como
colores, géneros o tipos de productos.
✓ Gráfico de Barras: Para mostrar la frecuencia o el conteo de cada
categoría.

import matplotlib.pyplot as plt

labels = ['Categoría A', 'Categoría B', 'Categoría C']
values = [10, 25, 15]
plt.bar(labels, values)
plt.title("Gráfico de Barras para Variable Nominal")
plt.show()

✓ Gráfico de Sectores (Pastel): Para visualizar proporciones en categorías.

plt.pie(values, labels=labels, autopct='%1.1f%%')

plt.title("Gráfico de Pastel para Variable Nominal")
plt.savefig("grafico_3.jpg", dpi=300)
plt.show()

111
6.1.2. Ordinales
Son variables que representan categorías con un orden implícito, como
niveles de satisfacción (bajo, medio, alto) o clasificación de rango.
✓ Gráfico de Barras Ordenado: Similar al gráfico de barras, pero con un
orden lógico en las categorías.

labels = ['Bajo', 'Medio', 'Alto']

values = [20, 30, 50]
plt.bar(labels, values, color = "red",width=0.45)
plt.ylim(0, 70)
plt.title("Gráfico de Barras para Variable Ordinal")
plt.savefig("grafico_4.jpg", dpi=300)
plt.show()

112
6.2. Variable cuantitativa (Cantidad)
6.2.1. Discretas
Representan valores numéricos contables (números enteros), como el número
de hijos o la cantidad de productos vendidos.
✓ Gráfico de Barras: Útil para mostrar la frecuencia de cada valor
numérico.

especies = ['Bolaina', 'Capirona', 'Cedro', 'Tornillo']

canti_ind = [25, 40, 15, 30] # Cantidades especie
# Crear el gráfico de barras
plt.figure(figsize=(8, 6))
plt.bar(especies, canti_ind, color="#3de096",width=0.45)
plt.ylim(0, 50)
plt.title("Cantidad de Individuos por Especie Forestal")
plt.xlabel("Especies")
plt.ylabel("Cantidad de Individuos")
plt.savefig("grafico_5.jpg", dpi=300)
plt.show()

6.2.2. Continuas
Son variables que pueden tomar cualquier valor dentro de un rango, como
peso, altura o temperatura.
✓ Histograma: Ideal para mostrar la distribución de la variable continua.

113
 import numpy as np
data = np.random.normal(0, 1, 1000) # Simulación de datos
plt.hist(data, bins=50, color="red")
plt.title("Histograma para Variable Cuantitativa Continua")
plt.savefig("grafico_6.jpg", dpi=300)
plt.show()

✓ Gráfico de Líneas: Para mostrar tendencias a lo largo del tiempo o un

rango continuo.

tiempo = np.linspace(0, 24, 100) # Rango de tiempo en horas (de 0 a 24)

temp = 20 + 5 * np.sin(2 * np.pi * tiempo / 24) # Variación de temperatura
# Crear el gráfico de líneas
plt.figure(figsize=(10, 6))
plt.plot(tiempo, temp, marker='o', linestyle='-', markersize=3)
plt.title("Variación de la Temperatura a lo Largo del Día")
plt.xlabel("Tiempo (Horas)")
plt.ylabel("Temperatura (°C)")
plt.savefig("grafico_7.jpg", dpi=300)
plt.show()

114
 ✓ Gráfico de Dispersión: Si se quiere mostrar la relación entre dos
variables continuas.

x = np.random.rand(50)
y = np.random.rand(50)
plt.scatter(x, y)
plt.title("Gráfico de Dispersión para Variables Cuantitativas Continuas")
plt.savefig("grafico_8.jpg", dpi=300)
plt.show()

6.3. Variables Mixtas (Combinación de Cualitativas y Cuantitativas)

6.3.1. Comparaciones por Categoría (Cualitativa y Cuantitativa)
✓ Boxplot (Diagrama de Caja): Ideal para mostrar la distribución de una
variable cuantitativa por categorías cualitativas.

data = pd.DataFrame({"Categoría": np.random.choice(["A", "B", "C"], 100),

"Valores": np.random.normal(0, 1, 100)})
data.boxplot(by="Categoría", column="Valores")
plt.title("Diagrama de Caja por Categoría")
plt.savefig("grafico_9.jpg", dpi=300)
plt.show()

115
✓ Gráfico de Barras Apilado o Agrupado: Para mostrar los totales y
subtotales de cada categoría.

labels = ['Categoría A', 'Categoría B', 'Categoría C']

values1 = [10, 20, 15]
values2 = [5, 15, 10]
plt.bar(labels, values1, label="Grupo 1")
plt.bar(labels, values2, bottom=values1, label="Grupo 2")
plt.legend()
plt.title("Gráfico de Barras Apilado para Comparación")
plt.savefig("grafico_9.jpg", dpi=300)
plt.show()

116
✓ Series de Tiempo (Variable Temporal)
Si tu variable es temporal (como fecha u hora), puedes utilizar gráficos
de líneas o de áreas para mostrar cómo cambian las variables
cuantitativas a lo largo del tiempo.
Gráfico de Líneas para Series de Tiempo

dates = pd.date_range('2023-01-01', periods=100)

values = np.random.randn(100).cumsum()
plt.plot(dates, values)
plt.title("Gráfico de Línea para Series de Tiempo")
plt.xlabel("Fecha")
plt.ylabel("Valor")
plt.savefig("grafico_11.jpg", dpi=300)
plt.show()

117
 Gráfico de Área para Resaltar Cambios

plt.fill_between(dates, values)
plt.title("Gráfico de Área para Series de Tiempo")
plt.xlabel("Fecha")
plt.ylabel("Valor")
plt.savefig("grafico_12.jpg", dpi=300)
plt.show()

118
 VII. Operaciones de sistema de archivo

En estas operaciones está el módulo como os, shutil y glob en Python.

7.1. Módulo os - Interfaces misceláneas del sistema operativo

Permite interactuar con el sistema operativo de forma sencilla y es útil para realizar
operaciones como manejar archivos, directorios y variables de entorno.
7.1.1. getcwd()
Obtiene el directorio actual de trabajo.
import os
directorio_actual = os.getcwd()
print(directorio_actual)
'C:\\Users\\GEOMATICA\\01_Geo_Python\\Script '

7.1.2. chdir(path)
Cambia el directorio actual de trabajo al especificado en path.
import os
os.chdir("/ruta/del/nuevo/directorio")

7.1.3. listdir(path)
Lista todos los archivos y carpetas en el directorio especificado (path). Si no
especificas un path, se utiliza el directorio actual.
files = os.listdir()
print(files)

7.1.4. mkdir(path)
Crea un nuevo directorio en la ruta especificada.
import os
os.mkdir("nueva_carpeta")
7.1.5. makedirs(path)
Crea un directorio con todas las carpetas intermedias necesarias.
import os
os.makedirs("carpeta1/carpeta2")

119
7.1.6. rename
Cambiar el nombre del directorio
import os
os.rename(“Carpeta1”, "Nuevo_nombre")

7.1.7. remove(path)
Elimina un archivo en la ruta especificada.
import os
os.remove("archivo.txt")
7.1.8. rmdir(path)
import os
os.rmdir("nueva_carpeta")
7.1.9. removedirs(path)
import os
os.removedirs("carpeta1/carpeta2")
7.1.10. path.join(path1, path2, ...)
Une varios componentes de una ruta en una sola ruta.
import os
ruta_completa = os.path.join(os.getcwd(),"archivo.txt")

'C:\\Users\\GEOMATICA\\01_Geo_Python\\Script \\archivo.txt'

7.1.11. path.exists(path)
Verifica si existe el archivo o directorio especificado.
import os
existe = os.path.exists("archivo.txt")

7.1.12. os.path.isfile(path) y os.path.isdir(path)

Verifican si el path es un archivo o un directorio.
import os
es_archivo = os.path.isfile("archivo.txt") es_directorio =
os.path.isdir("nueva_carpeta")

120
7.2. Módulo sutil - Operaciones de archivos de alto nivel
Ofrece varias operaciones de alto nivel en archivos y colecciones de archivos. En
particular, provee funciones que dan soporte a la copia y remoción de archivos.
7.2.1. shutil.copy
Crear una copia de un archivo
import shutil
shutil.copy("archivo_original.txt", "copia.txt")

7.2.2. shutil.move
Mover un archivo
import shutil
shutil.move("copia.txt", "nueva_ubicacion/copia.txt")

7.2.3. shutil.rmtree
Eliminar un directorio y su contenido
import shutil
shutil.rmtree("carpeta_a_eliminar")

7.3. Módulo glob

Es muy útil cuando quieres trabajar con rutas de archivos y directorios de manera
flexible, ya que permite buscar archivos y carpetas usando patrones de búsqueda
(wildcards) en una estructura de directorios. Es particularmente útil para encontrar
archivos específicos sin tener que recorrer todo el directorio de manera manual.
7.3.1. glob.glob(pattern)
Devuelve una lista de archivos y carpetas que coinciden con un patrón de
búsqueda. El patrón puede incluir comodines como * (cualquier número de
caracteres) o ? (cualquier carácter único).

import glob
# Buscar todos los archivos .txt en el directorio actual
archivos_txt = glob.glob("*.txt")
print(archivos_txt)

121
 Uso de comodines
• *: representa cualquier número de caracteres, incluidos ninguno.
• ?: representa un único carácter.
• []: define un conjunto de caracteres.
Por ejemplo:
# Buscar archivos .txt y .md en el directorio actual
archivos_texto = glob.glob("*.{txt,md}")
print(archivos_texto)

7.3.2. Búsquedas recursivas con **

Para buscar archivos en subdirectorios, puedes usar el doble asterisco ** en
conjunto con el parámetro recursive=True.
# Buscar todos los archivos .txt en el directorio actual y subdirectorios
archivos_recursivos = glob.glob("**/*.txt", recursive=True)
print(archivos_recursivos)

7.3.3. Buscar archivos en una ruta específica

Puedes proporcionar una ruta de directorio específica en lugar de usar el
directorio actual:
# Buscar todos los archivos .jpg en el directorio 'imagenes'
imagenes_jpg = glob.glob("imagenes/*.jpg")
print(imagenes_jpg)

Selección de bandas especificas

# Buscar todos los archivos .jpg en el directorio 'imagenes'
Lista_bandas = glob.glob("*[1-5,7].tif")
Lista_bandas
['L5_B1.tif', 'L5_B2.tif', 'L5_B3.tif', 'L5_B4.tif', 'L5_B5.tif', 'L5_B7.tif']

122
7.3.4. Combinar glob y os
El módulo glob se usa comúnmente junto con os.path para gestionar rutas
de archivos:
# Obtener archivos .txt y mostrar su ruta completa
archivos_txt = glob.glob("*.txt")
rutas_completas = [os.path.abspath(archivo) for archivo in archivos_txt]
print(rutas_completas)

123