Introducción a Python para Ciencia de Datos

Objetivo de la lección: Al finalizar la sesión, los estudiantes serán capaces de entender los
conceptos básicos de Python y cómo aplicarlos en el ámbito de la Ciencia de Datos.

Agenda de la Sesión
1. Introducción a Python

o Historia y evolución de Python.

o ¿Por qué Python en Ciencia de Datos?

o Instalación y configuración del entorno (Anaconda, Jupyter Notebook).

2. Sintaxis Básica de Python

o Variables y tipos de datos.

o Operadores aritméticos y lógicos.

o Entrada y salida de datos.

3. Estructuras de Datos en Python

o Listas.

o Tuplas.

o Diccionarios.

o Conjuntos.

4. Control de Flujo

o Condicionales (if, elif, else).

o Bucles (for, while).

5. Funciones y Módulos

o Definición y uso de funciones.

o Importación de módulos.

6. Introducción a Bibliotecas para Ciencia de Datos

o NumPy.

o Pandas.

7. Ejemplo Práctico: Análisis de Datos Simple

o Cargar un conjunto de datos con Pandas.

o Realizar operaciones básicas de análisis.

o Visualización simple de datos.

8. Preguntas y Repaso Final

1. Introducción a Python
• Historia y Evolución de Python

o Creado por Guido van Rossum en 1991.

o Lenguaje de alto nivel, interpretado y de propósito general.

o Enfoque en la legibilidad del código y la productividad del desarrollador.

• ¿Por qué Python en Ciencia de Datos?

o Gran comunidad y soporte.

o Amplia gama de bibliotecas especializadas (NumPy, Pandas, Matplotlib, etc.).

o Fácil de aprender para principiantes.

• Instalación y Configuración del Entorno

o Anaconda: Distribución que incluye Python y paquetes esenciales.

o Jupyter Notebook: Herramienta interactiva para escribir y ejecutar código.

2. Sintaxis Básica de Python

Variables y Tipos de Datos
python

# Asignación de variables

edad = 25 # Entero

precio = 19.99 # Flotante

nombre = "Ana" # Cadena de texto

es_estudiante = True # Booleano

Operadores Aritméticos y Lógicos

python

# Operadores aritméticos

suma = 5 + 3

resta = 10 - 2

multiplicacion = 4 * 7

division = 15 / 3

modulo = 10 % 3
# Operadores lógicos

resultado = (5 > 3) and (2 < 4) # True

Entrada y Salida de Datos

python

# Entrada de usuario

nombre = input("Ingrese su nombre: ")

# Salida de datos

print("Hola, " + nombre)

Estructuras de Datos en Python

• Listas

python

# Definición de una lista

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

print(frutas[0]) # Output: manzana

# Añadir elementos

[Link]("naranja")

# Eliminar elementos

[Link]("banana")

• Tuplas

python

# Definición de una tupla

dimensiones = (1920, 1080)

# Acceso a elementos

print(dimensiones[0]) # Output: 1920

• Diccionarios
python

# Definición de un diccionario

estudiante = {

"nombre": "Carlos",

"edad": 21,

"carrera": "Analítica de Negocios"

# Acceso a valores

print(estudiante["nombre"]) # Output: Carlos

• Conjuntos

python

# Definición de un conjunto

numeros = {1, 2, 3, 4, 5}

# Operaciones de conjuntos

pares = {2, 4, 6, 8}

interseccion = [Link](pares) # Output: {2, 4}

Control de Flujo
• Condicionales

python

edad = 18

if edad >= 18:

print("Eres mayor de edad.")

else:

print("Eres menor de edad.")

• Bucles

o Bucle for
for i in range(5):

print("Iteración:", i)

o Bucle while

contador = 0

while contador < 5:

print("Contador:", contador)

contador += 1

5. Funciones y Módulos

• Definición y Uso de Funciones

python

def saludar(nombre):

return "Hola, " + nombre

mensaje = saludar("Luis")

print(mensaje) # Output: Hola, Luis

• Importación de Módulos

import math

resultado = [Link](25)

print(resultado) # Output: 5.0

Introducción a Bibliotecas para Ciencia de Datos

• NumPy

o Biblioteca para computación numérica eficiente.

o Manejo de arreglos multidimensionales.

import numpy as np

array = [Link]([1, 2, 3, 4, 5])

print(array * 2) # Output: [2 4 6 8 10]

• Pandas
 o Herramienta para manipulación y análisis de datos.

o Estructuras de datos como Series y DataFrames.

import pandas as pd

datos = {'Nombre': ['Ana', 'Juan', 'Luis'], 'Edad': [28, 34, 29]}

df = [Link](datos)

print(df)

Ejemplo Práctico: Análisis de Datos Simple

• Cargar un Conjunto de Datos con Pandas

import pandas as pd

# Cargar datos desde un archivo CSV

df = pd.read_csv('[Link]')

• Operaciones Básicas de Análisis

# Mostrar las primeras filas

print([Link]())

# Descripción estadística

print([Link]())

# Filtrar datos

mayores_30 = df[df['Edad'] > 30]

• Visualización Simple de Datos

import [Link] as plt

# Gráfico de barras

df['Edad'].plot(kind='bar')

[Link]()

Preguntas y Repaso Final

• Resolución de dudas.

• Repaso de los conceptos clave vistos durante la sesión.

• Recursos adicionales para continuar aprendiendo.

Archivo CSV
Nombre,Edad,Departamento,Salario
Ana,28,Marketing,35000

Luis,34,Ventas,42000

María,29,Recursos Humanos,38000

Juan,45,Tecnología,55000

Sofía,32,Finanzas,40000

Carlos,41,Ventas,45000

Elena,26,Marketing,32000

Miguel,38,Tecnología,48000

Laura,31,Recursos Humanos,37000

Pedro,29,Finanzas,39000

Ejemplo Práctico con el Archivo Simulado

Cargar los Datos

import pandas as pd

# Cargar datos desde '[Link]'

df = pd.read_csv('[Link]')

# Mostrar las primeras filas

print("Primeras filas del DataFrame:")

print([Link]())

Salida:

Primeras filas del DataFrame:

Nombre Edad Departamento Salario

0 Ana 28 Marketing 35000

1 Luis 34 Ventas 42000

2 María 29 Recursos Humanos 38000

3 Juan 45 Tecnología 55000

4 Sofía 32 Finanzas 40000

Descripción Estadística

# Descripción estadística de las columnas numéricas

print("\nDescripción estadística:")
print([Link]())

Salida:

Descripción estadística:

Edad Salario

count 10.00000 10.000000

mean 33.30000 41100.000000

std 6.22110 7195.634928

min 26.00000 32000.000000

25% 28.25000 37250.000000

50% 31.00000 40000.000000

75% 38.25000 44500.000000

max 45.00000 55000.000000

Filtrar Datos

# Filtrar empleados mayores de 30 años

mayores_30 = df[df['Edad'] > 30]

print("\nEmpleados mayores de 30 años:")

print(mayores_30)

Salida:

Empleados mayores de 30 años:

Nombre Edad Departamento Salario

1 Luis 34 Ventas 42000

3 Juan 45 Tecnología 55000

4 Sofía 32 Finanzas 40000

5 Carlos 41 Ventas 45000

7 Miguel 38 Tecnología 48000

8 Laura 31 Recursos Humanos 37000

Visualización Simple de Datos

import [Link] as plt

# Gráfico de barras del salario por empleado

[Link](figsize=(10,6))

[Link](df['Nombre'], df['Salario'], color='skyblue')

[Link]('Nombre')

[Link]('Salario')

[Link]('Salario por Empleado')

[Link](rotation=45)

plt.tight_layout()

[Link]()

Instrucciones:

• Asegúrate de tener instaladas las bibliotecas necesarias (pandas y matplotlib).

• Ejecuta cada bloque de código en orden para replicar el análisis.

• Observa cómo se cargan los datos, se realiza un análisis descriptivo, se filtran los datos
y se visualizan los resultados.

Explicación de los Pasos

• Cargar los Datos:

o Utilizamos pd.read_csv('[Link]') para leer el archivo CSV y cargarlo en un

DataFrame de Pandas.

o [Link]() muestra las primeras filas del DataFrame para verificar que los datos
se han cargado correctamente.

• Descripción Estadística:

o [Link]() proporciona estadísticas descriptivas de las columnas numéricas,

como la media, desviación estándar, valores mínimos y máximos, y los
cuartiles.

• Filtrar Datos:

o Aplicamos una condición df['Edad'] > 30 para filtrar empleados cuya edad es
mayor a 30 años.

o El resultado se almacena en mayores_30 y se imprime para visualizar los datos

filtrados.

• Visualización de Datos:

o Utilizamos Matplotlib para crear un gráfico de barras que muestra el salario de

cada empleado.

o Personalizamos el gráfico con etiquetas y un título, y ajustamos la rotación de

las etiquetas del eje X para mejorar la legibilidad.

Ejercicios Adicionales
Para reforzar el aprendizaje, puedes intentar realizar las siguientes tareas:
 1. Calcular el salario promedio por departamento:

# Calcular salario promedio por departamento

promedio_salario = [Link]('Departamento')['Salario'].mean()

print("\nSalario promedio por departamento:")

print(promedio_salario)

2. Encontrar el empleado con el salario más alto:

# Encontrar el salario máximo

salario_max = df['Salario'].max()

empleado_max = df[df['Salario'] == salario_max]

print("\nEmpleado con el salario más alto:")

print(empleado_max)

3. Agregar una nueva columna que indique si el empleado gana más del salario
promedio general:

# Calcular el salario promedio general

salario_promedio = df['Salario'].mean()

# Agregar columna 'Sobre_Promedio'

df['Sobre_Promedio'] = df['Salario'] > salario_promedio

print("\nDataFrame con la nueva columna 'Sobre_Promedio':")

print(df)

Nota: Recuerda que los datos proporcionados son ficticios y se utilizan únicamente con fines
educativos.
Manual Sencillo de SQL para Ciencia de Datos
Introducción a SQL
SQL (Structured Query Language) es un lenguaje de programación específico para gestionar y
manipular bases de datos relacionales. Es esencial en el campo de la Ciencia de Datos para
extraer, manipular y analizar datos almacenados en sistemas de gestión de bases de datos
(DBMS) como MySQL, PostgreSQL, SQL Server y Oracle.

Contenido
1. Conceptos Básicos de SQL

o ¿Qué es SQL?

o Sistemas de Gestión de Bases de Datos Relacionales (RDBMS).

o Estructura de una base de datos relacional.

2. Lenguaje de Definición de Datos (DDL)

o CREATE: Crear bases de datos y tablas.

o ALTER: Modificar la estructura de tablas.

o DROP: Eliminar bases de datos y tablas.

3. Lenguaje de Manipulación de Datos (DML)

o SELECT: Consultar datos.

o INSERT: Insertar datos.

o UPDATE: Actualizar datos.

o DELETE: Eliminar datos.

4. Cláusulas y Operadores Básicos

o WHERE: Filtrar registros.

o Operadores lógicos (AND, OR, NOT).

o Operadores de comparación (=, >, <, >=, <=, <>).

5. Ordenamiento y Limitación de Resultados

o ORDER BY: Ordenar resultados.

o LIMIT: Limitar el número de registros devueltos.

6. Funciones de Agregación y Agrupamiento

o Funciones (COUNT, SUM, AVG, MAX, MIN).

o GROUP BY: Agrupar registros.

o HAVING: Filtrar grupos.

7. Uniones de Tablas (JOINS)

o INNER JOIN
 o LEFT JOIN

o RIGHT JOIN

o FULL OUTER JOIN

8. Ejemplo Práctico: Análisis de Datos con SQL

o Creación de una tabla y inserción de datos.

o Consultas básicas y avanzadas.

o Interpretación de resultados.
1. Conceptos Básicos de SQL
¿Qué es SQL?

• Lenguaje estándar para interactuar con bases de datos relacionales.

• Permite crear, leer, actualizar y eliminar datos (operaciones CRUD).

Sistemas de Gestión de Bases de Datos Relacionales (RDBMS)

• Software que utiliza SQL para gestionar bases de datos.

• Ejemplos: MySQL, PostgreSQL, SQLite, Oracle, Microsoft SQL Server.

Estructura de una Base de Datos Relacional

• Base de Datos: Conjunto de tablas relacionadas.

• Tabla: Colección de registros (filas) con campos (columnas) específicos.

• Registro: Fila en una tabla que contiene datos relacionados.

• Campo: Columna en una tabla que define el tipo de datos.

2. Lenguaje de Definición de Datos (DDL)

CREATE: Crear Bases de Datos y Tablas

Crear una Base de Datos:
import sqlite3

# Conectar a la base de datos (si no existe, la crea)

conexion = [Link]('[Link]')

• Seleccionar una Base de Datos:

USE empresa;

Crear una Tabla:

CREATE TABLE empleados (

id INT AUTO_INCREMENT PRIMARY KEY,

nombre VARCHAR(50),

edad INT,

departamento VARCHAR(50),

salario DECIMAL(10,2)

);
ALTER: Modificar la Estructura de Tablas
Agregar una Nueva Columna:

ALTER TABLE empleados ADD columna_nueva VARCHAR(50);

import sqlite3

# Conectar a la base de datos

conexion = [Link]('[Link]')

# Crear un cursor
cursor = [Link]()

# Agregar una nueva columna a la tabla 'empleados'

[Link]("ALTER TABLE empleados ADD COLUMN columna_nueva VARCHAR(50);")

# Confirmar los cambios

[Link]()

# Ver la estructura de la tabla para comprobar la nueva columna

[Link]("PRAGMA table_info(empleados);")
columnas = [Link]()

print("Estructura de la tabla 'empleados':")

for columna in columnas:
print(columna)

# Cerrar la conexión
[Link]()
Modificar una Columna Existente:
import sqlite3

# Conectar a la base de datos

conexion = [Link]('[Link]')

# Crear un cursor
cursor = [Link]()

# 1. Crear una nueva tabla temporal con la estructura modificada

[Link]('''
CREATE TABLE empleados_nueva (
id INTEGER PRIMARY KEY,
nombre TEXT NOT NULL,
puesto TEXT NOT NULL,
salario REAL NOT NULL,
 edad INTEGER, -- Aquí defines la columna 'edad' como INTEGER (similar a SMALLINT en
SQLite)
columna_nueva VARCHAR(50)
);
''')

# 2. Copiar los datos de la tabla antigua a la nueva tabla

[Link]('''
INSERT INTO empleados_nueva (id, nombre, puesto, salario, edad, columna_nueva)
SELECT id, nombre, puesto, salario, CAST(edad AS INTEGER), columna_nueva FROM
empleados;
''')

# 3. Eliminar la tabla antigua

[Link]('DROP TABLE empleados;')

# 4. Renombrar la nueva tabla con el nombre original

[Link]('ALTER TABLE empleados_nueva RENAME TO empleados;')

# Confirmar los cambios

[Link]()

# Ver la estructura de la nueva tabla

[Link]("PRAGMA table_info(empleados);")
columnas = [Link]()

print("Estructura de la nueva tabla 'empleados':")

for columna in columnas:
print(columna)

# Cerrar la conexión
[Link]()
Eliminar una Columna:
import sqlite3

# Conectar a la base de datos

conexion = [Link]('[Link]')

# Crear un cursor
cursor = [Link]()

# 1. Crear una nueva tabla sin la columna que deseas eliminar

[Link]('''
CREATE TABLE empleados_nueva (
id INTEGER PRIMARY KEY,
nombre TEXT NOT NULL,
puesto TEXT NOT NULL,
salario REAL NOT NULL,
 edad INTEGER -- Sin la columna 'columna_nueva'
);
''')

# 2. Copiar los datos de la tabla antigua a la nueva tabla (sin la columna 'columna_nueva')
[Link]('''
INSERT INTO empleados_nueva (id, nombre, puesto, salario, edad)
SELECT id, nombre, puesto, salario, edad FROM empleados;
''')

# 3. Eliminar la tabla antigua

[Link]('DROP TABLE empleados;')

# 4. Renombrar la nueva tabla con el nombre original

[Link]('ALTER TABLE empleados_nueva RENAME TO empleados;')

# Confirmar los cambios

[Link]()

# Ver la estructura de la nueva tabla para asegurarse de que 'columna_nueva' ha sido

eliminada
[Link]("PRAGMA table_info(empleados);")
columnas = [Link]()

print("Estructura de la nueva tabla 'empleados' sin 'columna_nueva':")

for columna in columnas:
print(columna)

# Cerrar la conexión
[Link]()

DROP: Eliminar Bases de Datos y Tablas

Eliminar una Tabla:

DROP TABLE empleados;

import sqlite3

# Conectar a la base de datos

conexion = [Link]('[Link]')

# Crear un cursor
cursor = [Link]()

# Eliminar la tabla 'empleados'

[Link]('DROP TABLE IF EXISTS empleados;')

# Confirmar los cambios

[Link]()

# Verificar si la tabla ha sido eliminada listando las tablas restantes

[Link]("SELECT name FROM sqlite_master WHERE type='table';")
tablas = [Link]()

print("Tablas restantes en la base de datos:")

for tabla in tablas:
print(tabla[0])

# Cerrar la conexión
[Link]()
Eliminar una Base de Datos:
sql

DROP DATABASE empresa;

import sqlite3
import os

# Nombre del archivo de la base de datos

db_filename = '[Link]'

# Cerrar cualquier conexión abierta (si fuera necesario)

# Conectar para asegurarse de que el archivo existe
try:
conexion = [Link](db_filename)
[Link]()
except Exception as e:
print(f"No se pudo abrir la base de datos: {e}")

# Eliminar el archivo de la base de datos si existe

if [Link](db_filename):
[Link](db_filename)
print(f"La base de datos '{db_filename}' ha sido eliminada.")
else:
print(f"No se encontró la base de datos '{db_filename}'.")
3. Lenguaje de Manipulación de Datos (DML)
INSERT: Insertar Datos
import sqlite3

# 1. Crear una conexión a la base de datos (si no existe, la crea)

conexion = [Link]('[Link]')

# Crear un cursor
cursor = [Link]()

# 2. Crear la tabla 'empleados'

[Link]('''
CREATE TABLE IF NOT EXISTS empleados (
id INTEGER PRIMARY KEY AUTOINCREMENT,
nombre TEXT NOT NULL,
puesto TEXT NOT NULL,
salario REAL NOT NULL
);
''')

# 3. Insertar 20 registros en la tabla 'empleados'

empleados_datos = [
('Ana', 'Ingeniera', 50000),
('Luis', 'Contador', 45000),
('Carlos', 'Desarrollador', 55000),
('María', 'Administrativa', 30000),
('Pedro', 'Gerente', 60000),
('Sofía', 'Analista', 48000),
('Miguel', 'Consultor', 53000),
('Elena', 'Secretaria', 29000),
('Jorge', 'Marketing', 40000),
('Lucía', 'Recursos Humanos', 42000),
('Fernando', 'Vendedor', 35000),
('Paula', 'Recepcionista', 27000),
('Andrea', 'Diseñadora', 46000),
('Manuel', 'Contable', 43000),
('Sara', 'Project Manager', 62000),
('Ricardo', 'Técnico', 38000),
('Patricia', 'Investigadora', 51000),
('Rafael', 'Abogado', 55000),
('Marta', 'Directora', 70000),
('Iván', 'Soporte Técnico', 36000)
]

# Insertar los registros en la tabla

[Link]('''
INSERT INTO empleados (nombre, puesto, salario)
VALUES (?, ?, ?);
''', empleados_datos)

# Confirmar los cambios

[Link]()

# Mostrar todos los registros de la tabla 'empleados'

[Link]("SELECT * FROM empleados;")
empleados = [Link]()

print("Registros en la tabla 'empleados':")

for empleado in empleados:
print(empleado)

# Cerrar la conexión
[Link]()

UPDATE: Actualizar Datos

Actualizar el Salario de un Empleado:
sql

UPDATE empleados SET salario = 36000 WHERE nombre = 'Ana';

import sqlite3

# Conectar a la base de datos

conexion = [Link]('[Link]')

# Crear un cursor
cursor = [Link]()

# Ejecutar la actualización (UPDATE) del salario de Ana

[Link]("UPDATE empleados SET salario = 36000 WHERE nombre = 'Ana';")

# Confirmar los cambios

[Link]()

# Verificar que el cambio se realizó correctamente

[Link]("SELECT * FROM empleados WHERE nombre = 'Ana';")
empleado = [Link]()

print("Registro actualizado de Ana:")

print(empleado)

# Cerrar la conexión
[Link]()
DELETE: Eliminar Datos
Eliminar un Registro:
sql

DELETE FROM empleados WHERE nombre = 'Juan';

import sqlite3

# Conectar a la base de datos

conexion = [Link]('[Link]')

# Crear un cursor
cursor = [Link]()

# Ejecutar la eliminación (DELETE) del empleado cuyo nombre es 'Juan'

[Link]("DELETE FROM empleados WHERE nombre = 'Juan';")

# Confirmar los cambios

[Link]()

# Verificar si el registro fue eliminado buscando a 'Juan' en la tabla

[Link]("SELECT * FROM empleados WHERE nombre = 'Juan';")
empleado = [Link]()

if empleado is None:
print("El registro de 'Juan' ha sido eliminado o no existe.")
else:
print("Registro de Juan aún existe:", empleado)

# Cerrar la conexión
[Link]()
4. Cláusulas y Operadores Básicos
WHERE: Filtrar Registros
• Filtrar por Edad:

sql

SELECT * FROM empleados WHERE edad > 30;

import sqlite3

# Conectar a la base de datos

conexion = [Link]('[Link]')

# Crear un cursor
cursor = [Link]()

# Ejecutar la consulta (SELECT) para obtener empleados con edad > 30

[Link]("SELECT * FROM empleados WHERE edad > 30;")

# Obtener los resultados

empleados = [Link]()

# Mostrar los resultados

print("Empleados con edad mayor de 30 años:")
for empleado in empleados:
print(empleado)

# Cerrar la conexión
[Link]()
Operadores Lógicos
Uso de AND:
sql

SELECT * FROM empleados WHERE edad > 30 AND departamento = 'Ventas';

import sqlite3

# Conectar a la base de datos

conexion = [Link]('[Link]')

# Crear un cursor
cursor = [Link]()

# Ejecutar la consulta (SELECT) para obtener empleados con edad > 30 y del departamento
'Ventas'
[Link]("SELECT * FROM empleados WHERE edad > 30 AND departamento = 'Ventas';")

# Obtener los resultados

empleados = [Link]()

# Mostrar los resultados

print("Empleados con edad mayor de 30 años y del departamento 'Ventas':")
for empleado in empleados:
print(empleado)

# Cerrar la conexión
[Link]()

Uso de OR:
sql

SELECT * FROM empleados WHERE departamento = 'Marketing' OR departamento =

'Finanzas';

import sqlite3

# Conectar a la base de datos

conexion = [Link]('[Link]')

# Crear un cursor
cursor = [Link]()

# Ejecutar la consulta (SELECT) para obtener empleados de 'Marketing' o 'Finanzas'

[Link]("SELECT * FROM empleados WHERE departamento = 'Marketing' OR
departamento = 'Finanzas';")

# Obtener los resultados

empleados = [Link]()

# Mostrar los resultados

print("Empleados del departamento 'Marketing' o 'Finanzas':")
for empleado in empleados:
print(empleado)

# Cerrar la conexión
[Link]()

Uso de NOT:
sql

SELECT * FROM empleados WHERE NOT departamento = 'Tecnología';

import sqlite3

# Conectar a la base de datos

conexion = [Link]('[Link]')

# Crear un cursor
cursor = [Link]()

# Ejecutar la consulta (SELECT) para obtener empleados que no pertenecen al departamento

'Tecnología'
[Link]("SELECT * FROM empleados WHERE NOT departamento = 'Tecnología';")

# Obtener los resultados

empleados = [Link]()

# Mostrar los resultados

print("Empleados que no pertenecen al departamento 'Tecnología':")
for empleado in empleados:
print(empleado)

# Cerrar la conexión
[Link]()

Operadores de Comparación
import sqlite3

# Conectar a la base de datos

conexion = [Link]('[Link]')

# Crear un cursor
cursor = [Link]()

# 1. Seleccionar empleados con salario igual a 40000

[Link]("SELECT * FROM empleados WHERE salario = 40000;")
empleados_salario_igual = [Link]()
print("Empleados con salario igual a 40000:")
for empleado in empleados_salario_igual:
print(empleado)

# 2. Seleccionar empleados con salario diferente a 40000

[Link]("SELECT * FROM empleados WHERE salario <> 40000;")
empleados_salario_diferente = [Link]()
print("\nEmpleados con salario diferente a 40000:")
for empleado in empleados_salario_diferente:
print(empleado)

# 3. Seleccionar empleados con edad mayor o igual a 30

[Link]("SELECT * FROM empleados WHERE edad >= 30;")
empleados_edad_mayor_igual_30 = [Link]()
print("\nEmpleados con edad mayor o igual a 30:")
for empleado in empleados_edad_mayor_igual_30:
print(empleado)

# 4. Seleccionar empleados con edad menor o igual a 40

[Link]("SELECT * FROM empleados WHERE edad <= 40;")
empleados_edad_menor_igual_40 = [Link]()
print("\nEmpleados con edad menor o igual a 40:")
for empleado in empleados_edad_menor_igual_40:
print(empleado)

# Cerrar la conexión
[Link]()

5. Ordenamiento y Limitación de Resultados

ORDER BY: Ordenar Resultados
import sqlite3

# Conectar a la base de datos

conexion = [Link]('[Link]')

# Crear un cursor
cursor = [Link]()

# 1. Seleccionar todos los empleados y ordenarlos por salario en orden ascendente

[Link]("SELECT * FROM empleados ORDER BY salario;")
empleados_orden_salario_asc = [Link]()
print("Empleados ordenados por salario (ascendente):")
for empleado in empleados_orden_salario_asc:
print(empleado)

# 2. Seleccionar todos los empleados y ordenarlos por salario en orden descendente

[Link]("SELECT * FROM empleados ORDER BY salario DESC;")
empleados_orden_salario_desc = [Link]()
print("\nEmpleados ordenados por salario (descendente):")
for empleado in empleados_orden_salario_desc:
print(empleado)

# Cerrar la conexión
[Link]()
LIMIT: Limitar Número de Registros
• Obtener los 5 Empleados con Mayor Salario:

SELECT * FROM empleados ORDER BY salario DESC LIMIT 5;

import sqlite3

# Conectar a la base de datos

conexion = [Link]('[Link]')

# Crear un cursor
cursor = [Link]()

# 1. Obtener los 5 empleados con mayor salario

[Link]("SELECT * FROM empleados ORDER BY salario DESC LIMIT 5;")
empleados_top_5_salario = [Link]()

# Mostrar los resultados

print("Los 5 empleados con mayor salario:")
for empleado in empleados_top_5_salario:
print(empleado)

# Cerrar la conexión
[Link]()
6. Funciones de Agregación y Agrupamiento
Funciones de Agregación
Contar Registros:

SELECT COUNT(*) FROM empleados;

import sqlite3

# Conectar a la base de datos

conexion = [Link]('[Link]')

# Crear un cursor
cursor = [Link]()

# 1. Contar el número total de empleados

[Link]("SELECT COUNT(*) FROM empleados;")
total_empleados = [Link]()[0]

# Mostrar el resultado
print(f"El número total de empleados es: {total_empleados}")

# Cerrar la conexión
[Link]()

Salario Promedio:
SELECT AVG(salario) FROM empleados;

import sqlite3

# Conectar a la base de datos

conexion = [Link]('[Link]')

# Crear un cursor
cursor = [Link]()

# 1. Calcular el salario promedio de los empleados

[Link]("SELECT AVG(salario) FROM empleados;")
salario_promedio = [Link]()[0]

# Mostrar el resultado
print(f"El salario promedio de los empleados es: {salario_promedio:.2f}")

# Cerrar la conexión
[Link]()

Salario Máximo y Mínimo:

SELECT MAX(salario) FROM empleados;

SELECT MIN(salario) FROM empleados;

import sqlite3

# Conectar a la base de datos

conexion = [Link]('[Link]')

# Crear un cursor
cursor = [Link]()

# 1. Obtener el salario máximo de los empleados

[Link]("SELECT MAX(salario) FROM empleados;")
salario_maximo = [Link]()[0]

# 2. Obtener el salario mínimo de los empleados

[Link]("SELECT MIN(salario) FROM empleados;")
salario_minimo = [Link]()[0]

# Mostrar los resultados

print(f"El salario máximo de los empleados es: {salario_maximo:.2f}")
print(f"El salario mínimo de los empleados es: {salario_minimo:.2f}")

# Cerrar la conexión
[Link]()
GROUP BY: Agrupar Registros
Salario Promedio por Departamento:

SELECT departamento, AVG(salario) AS salario_promedio

FROM empleados

GROUP BY departamento;

import sqlite3

# Conectar a la base de datos

conexion = [Link]('[Link]')

# Crear un cursor
cursor = [Link]()

# 1. Agregar la columna 'departamento' si no existe

try:
[Link]("ALTER TABLE empleados ADD COLUMN departamento TEXT;")
print("Columna 'departamento' añadida.")
except [Link]:
print("La columna 'departamento' ya existe.")

# 2. Asignar valores a la columna 'departamento' (si no se han asignado antes)

# Esto es solo un ejemplo, puedes cambiar los valores según los datos que tengas
[Link]("UPDATE empleados SET departamento = 'Marketing' WHERE nombre IN
('Ana', 'Luis');")
[Link]("UPDATE empleados SET departamento = 'Finanzas' WHERE nombre IN
('Carlos', 'Pedro');")
[Link]("UPDATE empleados SET departamento = 'Tecnología' WHERE nombre IN
('Miguel', 'Sofía');")
[Link]()

# 3. Calcular el salario promedio por departamento

[Link]('''
SELECT departamento, AVG(salario) AS salario_promedio
FROM empleados
GROUP BY departamento;
''')

# Obtener los resultados

salarios_promedio_por_departamento = [Link]()

# Mostrar los resultados

print("Salario promedio por departamento:")
for departamento, salario_promedio in salarios_promedio_por_departamento:
print(f"Departamento: {departamento}, Salario Promedio: {salario_promedio:.2f}")

# Cerrar la conexión
[Link]()

HAVING: Filtrar Grupos

• Departamentos con Salario Promedio Mayor a 40,000:

SELECT departamento, AVG(salario) AS salario_promedio

FROM empleados

GROUP BY departamento

HAVING AVG(salario) > 40000;

import sqlite3
# Conectar a la base de datos
conexion = [Link]('[Link]')

# Crear un cursor
cursor = [Link]()

# 1. Consulta para obtener los departamentos con salario promedio mayor a 40,000
[Link]('''
SELECT departamento, AVG(salario) AS salario_promedio
FROM empleados
GROUP BY departamento
HAVING AVG(salario) > 40000;
''')

# Obtener los resultados

departamentos_filtrados = [Link]()

# Mostrar los resultados

print("Departamentos con salario promedio mayor a 40,000:")
for departamento, salario_promedio in departamentos_filtrados:
print(f"Departamento: {departamento}, Salario Promedio: {salario_promedio:.2f}")

# Cerrar la conexión
[Link]()
7. Uniones de Tablas (JOINS)

Supongamos que tenemos otra tabla llamada departamentos:

CREATE TABLE departamentos (

id INT AUTO_INCREMENT PRIMARY KEY,

nombre_departamento VARCHAR(50),

ubicacion VARCHAR(50)

);

INNER JOIN

• Unir empleados y departamentos:

SELECT [Link], departamentos.nombre_departamento, [Link]

FROM empleados

INNER JOIN departamentos

ON [Link] = departamentos.nombre_departamento;

LEFT JOIN

• Obtener Todos los Empleados y su Información de Departamento (Incluso si Falta):

SELECT [Link], departamentos.nombre_departamento, [Link]

FROM empleados

LEFT JOIN departamentos

ON [Link] = departamentos.nombre_departamento;

8. Ejemplo Práctico: Análisis de Datos con SQL

Paso 1: Creación de la Tabla y Inserción de Datos

Crear la Tabla empleados:

CREATE TABLE empleados (

id INT AUTO_INCREMENT PRIMARY KEY,

nombre VARCHAR(50),

edad INT,

departamento VARCHAR(50),

salario DECIMAL(10,2)

);

Insertar Datos en empleados:

INSERT INTO empleados (nombre, edad, departamento, salario) VALUES

('Ana', 28, 'Marketing', 35000),

('Luis', 34, 'Ventas', 42000),

('María', 29, 'Recursos Humanos', 38000),

('Juan', 45, 'Tecnología', 55000),

('Sofía', 32, 'Finanzas', 40000),

('Carlos', 41, 'Ventas', 45000),

('Elena', 26, 'Marketing', 32000),

('Miguel', 38, 'Tecnología', 48000),

('Laura', 31, 'Recursos Humanos', 37000),

('Pedro', 29, 'Finanzas', 39000);

Paso 2: Consultas Básicas

Listar Todos los Empleados:

SELECT * FROM empleados;

Empleados Mayores de 30 Años:

SELECT nombre, edad FROM empleados WHERE edad > 30;

Salario Promedio de la Empresa:

SELECT AVG(salario) AS salario_promedio FROM empleados;

Paso 3: Consultas Avanzadas

Salario Promedio por Departamento:

SELECT departamento, AVG(salario) AS salario_promedio

FROM empleados

GROUP BY departamento;

Empleados con Salario por Encima del Promedio General:

SELECT nombre, salario

FROM empleados

WHERE salario > (SELECT AVG(salario) FROM empleados);

Departamentos con Más de 2 Empleados:

SELECT departamento, COUNT(*) AS num_empleados

FROM empleados

GROUP BY departamento

HAVING COUNT(*) > 2;

Paso 4: Interpretación de Resultados

• Análisis de Salarios:

o Identificar departamentos con salarios promedio más altos.

o Evaluar si existe una correlación entre la edad y el salario.

• Recursos Humanos:

o Detectar posibles necesidades de contratación.

o Planificar aumentos salariales o promociones.

Conclusión

Este manual proporciona una introducción básica a SQL y sus principales comandos utilizados
en el análisis de datos. Con este conocimiento, puedes:

• Crear y manipular bases de datos y tablas.

• Realizar consultas simples y complejas para extraer información relevante.

• Aplicar funciones de agregación y agrupamiento para análisis estadísticos.

• Unir tablas para combinar datos de diferentes fuentes.

Recursos Adicionales

• Documentación Oficial de SQL:

o W3Schools SQL Tutorial

o Tutoriales de SQL en español

• Plataformas de Práctica Interactiva:

o SQLBolt

o HackerRank SQL Challenges

Ejercicios Propuestos

1. Crear una Nueva Tabla proyectos y Relacionarla con empleados:

o Tabla proyectos:

CREATE TABLE proyectos (

id INT AUTO_INCREMENT PRIMARY KEY,

nombre_proyecto VARCHAR(100),

id_empleado INT,

FOREIGN KEY (id_empleado) REFERENCES empleados(id)

);

o Insertar Datos en proyectos.

2. Listar los Empleados y sus Proyectos Asignados:

SELECT [Link], proyectos.nombre_proyecto

FROM empleados
INNER JOIN proyectos

ON [Link] = proyectos.id_empleado;

3. Encontrar el Departamento con el Mayor Número de Empleados:

SELECT departamento, COUNT(*) AS num_empleados

FROM empleados

GROUP BY departamento

ORDER BY num_empleados DESC

LIMIT 1;

4. Calcular el Salario Total Pagado por Departamento:

SELECT departamento, SUM(salario) AS salario_total

FROM empleados

GROUP BY departamento;

Nota Final:

La práctica constante es clave para dominar SQL. Se recomienda utilizar entornos de prueba
como bases de datos locales o servicios en la nube para experimentar con diferentes consultas
y escenarios.