Cheat Sheet completa de Python
Esta cheat sheet de Python es tu guía de referencia rápida para dominar los conceptos fundamentales del lenguaje. Desde variables hasta manejo de archivos, aquí encontrarás todo lo esencial con ejemplos prácticos y explicaciones claras.
Variables
En Python, las variables se crean simplemente asignando un valor. No necesitas declarar el tipo explícitamente.
# 🚀 VARIABLES EN PYTHON
# 🔹 ASIGNACIÓN BÁSICA
nombre = "Juan" # String
edad = 30 # Integer
altura = 1.75 # Float
es_estudiante = True # Boolean
print(nombre) # Juan
print(edad) # 30
print(altura) # 1.75
print(es_estudiante) # True
# 🔹 ASIGNACIÓN MÚLTIPLE
x, y, z = 10, 20, 30
print(x, y, z) # 10 20 30
# Asignar el mismo valor a múltiples variables
a = b = c = 100
print(a, b, c) # 100 100 100
# 🔹 INTERCAMBIO DE VARIABLES
x = 5
y = 10
x, y = y, x # Intercambio elegante
print(x, y) # 10 5
# 🔹 CONVENCIONES DE NOMBRES
# ✅ Correcto
nombre_usuario = "Ana"
CONSTANTE = 3.14159
mi_lista = [1, 2, 3]
# ❌ Incorrecto (evitar)
# 2nombre = "error" # No puede empezar con número
# nombre-usuario = "error" # No usar guiones
# class = "error" # No usar palabras reservadas
# 🔹 VERIFICAR TIPO DE VARIABLE
numero = 42
print(type(numero)) # <class 'int'>
print(isinstance(numero, int)) # TrueTipos de datos
Python tiene varios tipos de datos integrados que se pueden clasificar en mutables e inmutables.
# 🚀 TIPOS DE DATOS EN PYTHON
# 🔹 TIPOS PRIMITIVOS (INMUTABLES)
# 📄 String (Cadenas de texto)
texto = "Hola Python"
texto_multilinea = """Esta es una
cadena de texto
que abarca múltiples líneas"""
# 🔢 Números
entero = 42 # int
decimal = 3.14159 # float
complejo = 3 + 4j # complex
# 🔘 Boolean (Booleanos)
verdadero = True
falso = False
# 🚫 NoneType (Valor nulo)
vacio = None
# 🔹 TIPOS DE COLECCIÓN
# 📋 List (Listas - mutables, ordenadas)
frutas = ["manzana", "banana", "naranja"]
numeros = [1, 2, 3, 4, 5]
mixta = [1, "texto", True, 3.14]
# 📖 Dictionary (Diccionarios - mutables, no ordenados antes Python 3.7)
persona = {
"nombre": "Ana",
"edad": 25,
"ciudad": "Madrid"
}
# 📦 Tuple (Tuplas - inmutables, ordenadas)
coordenadas = (10, 20)
colores = ("rojo", "verde", "azul")
# 🔗 Set (Conjuntos - mutables, únicos, no ordenados)
numeros_unicos = {1, 2, 3, 4, 5}
letras = {"a", "b", "c"}
# 🔹 VERIFICACIÓN DE TIPOS
print(type("Hola")) # <class 'str'>
print(type(42)) # <class 'int'>
print(type(3.14)) # <class 'float'>
print(type(True)) # <class 'bool'>
print(type(None)) # <class 'NoneType'>
print(type([1, 2, 3])) # <class 'list'>
print(type({"a": 1})) # <class 'dict'>
print(type((1, 2))) # <class 'tuple'>
print(type({1, 2})) # <class 'set'>
# 🔹 CONVERSIÓN DE TIPOS
numero_str = "42"
numero_int = int(numero_str) # "42" → 42
numero_float = float(numero_str) # "42" → 42.0
lista_str = str([1, 2, 3]) # [1, 2, 3] → "[1, 2, 3]"
lista_tupla = tuple([1, 2, 3]) # [1, 2, 3] → (1, 2, 3)
lista_set = set([1, 2, 2, 3]) # [1, 2, 2, 3] → {1, 2, 3}
# 🔹 MUTABILIDAD VS INMUTABILIDAD
# ✅ MUTABLE (se puede modificar)
lista = [1, 2, 3]
lista.append(4) # [1, 2, 3, 4]
lista[0] = 10 # [10, 2, 3, 4]
diccionario = {"a": 1}
diccionario["b"] = 2 # {"a": 1, "b": 2}
# ❌ INMUTABLE (no se puede modificar)
tupla = (1, 2, 3)
# tupla[0] = 10 # Error: no se puede modificar
cadena = "Hola"
# cadena[0] = "h" # Error: no se puede modificar
nueva_cadena = cadena.replace("H", "h") # "hola" (nueva cadena)String formatting
Python ofrece varias formas de formatear strings de manera elegante y eficiente.
# 🚀 FORMATEO DE STRINGS EN PYTHON
nombre = "Juan"
edad = 30
precio = 29.99
# 🔹 f-strings (RECOMENDADO - Python 3.6+)
# ✅ Interpolación de variables
mensaje = f"Hola, soy {nombre} y tengo {edad} años"
print(mensaje) # "Hola, soy Juan y tengo 30 años"
# ✅ Expresiones dentro de f-strings
print(f"El año que viene tendré {edad + 1} años") # "El año que viene tendré 31 años"
print(f"El precio con IVA es: {precio * 1.21:.2f}€") # "El precio con IVA es: 36.29€"
# ✅ Formateo de números
pi = 3.14159
print(f"Pi con 2 decimales: {pi:.2f}") # "Pi con 2 decimales: 3.14"
print(f"Número con ceros: {42:05d}") # "Número con ceros: 00042"
# 🔹 .format() (Método tradicional)
mensaje = "Hola, soy {} y tengo {} años".format(nombre, edad)
print(mensaje) # "Hola, soy Juan y tengo 30 años"
# Con índices
mensaje = "Hola, soy {0} y tengo {1} años. {0} es mi nombre".format(nombre, edad)
print(mensaje) # "Hola, soy Juan y tengo 30 años. Juan es mi nombre"
# Con nombres
mensaje = "Hola, soy {n} y tengo {e} años".format(n=nombre, e=edad)
print(mensaje) # "Hola, soy Juan y tengo 30 años"
# 🔹 % formatting (Estilo antiguo - evitar)
mensaje = "Hola, soy %s y tengo %d años" % (nombre, edad)
print(mensaje) # "Hola, soy Juan y tengo 30 años"
# 🔹 TEXTO MULTILÍNEA
texto_largo = f"""
Nombre: {nombre}
Edad: {edad}
Precio: {precio:.2f}€
"""
print(texto_largo)
# 🔹 FORMATEO AVANZADO
# Alineación
nombre_corto = "Ana"
print(f"|{nombre_corto:<10}|") # |Ana | (izquierda)
print(f"|{nombre_corto:>10}|") # | Ana| (derecha)
print(f"|{nombre_corto:^10}|") # | Ana | (centro)
# Fechas
from datetime import datetime
ahora = datetime.now()
print(f"Fecha: {ahora:%d/%m/%Y}") # "Fecha: 29/08/2025"
print(f"Hora: {ahora:%H:%M:%S}") # "Hora: 14:30:45"Comentarios
Los comentarios permiten documentar y explicar el código sin afectar su ejecución.
# 🚀 COMENTARIOS EN PYTHON
# Esto es un comentario de una sola línea
print("Hola Mundo") # También se puede comentar al final
# Comentario explicativo sobre la siguiente función
def calcular_area(radio):
return 3.14159 * radio ** 2
"""
Este es un comentario
de múltiples líneas usando
triple comillas dobles.
Ideal para documentación extensa.
"""
'''
También puedes usar
triple comillas simples
para comentarios multilínea.
'''
# 🔹 DOCSTRINGS (Documentación de funciones/clases)
def saludar(nombre, apellido=""):
"""
Función que genera un saludo personalizado.
Args:
nombre (str): El nombre de la persona
apellido (str, opcional): El apellido. Por defecto es ""
Returns:
str: Un saludo formateado
Example:
>>> saludar("Juan", "Pérez")
'Hola, Juan Pérez'
"""
if apellido:
return f"Hola, {nombre} {apellido}"
return f"Hola, {nombre}"
# Acceder a la documentación
print(saludar.__doc__)
# 🔹 COMENTARIOS PARA DEBUG
x = 10
y = 20
# print(f"Debug: x={x}, y={y}") # Comentado temporalmente
resultado = x + y
print(f"Resultado: {resultado}")
# 🔹 TODO y FIXME (convenciones útiles)
def procesar_datos(datos):
# TODO: Implementar validación de datos
# FIXME: Manejar el caso cuando datos está vacío
return datosOperadores
Los operadores en Python permiten realizar operaciones matemáticas, lógicas y de comparación.
# 🚀 OPERADORES EN PYTHON
# 🔹 OPERADORES ARITMÉTICOS
suma = 5 + 3 # ➕ 8
resta = 10 - 4 # ➖ 6
multiplicacion = 3 * 4 # ✖️ 12
division = 20 / 4 # ➗ 5.0 (siempre devuelve float)
division_entera = 20 // 4 # 🔢 5 (división entera)
modulo = 10 % 3 # 🔄 1 (resto)
potencia = 2 ** 3 # ⚡ 8 (2 elevado a 3)
# 🔹 OPERADORES DE ASIGNACIÓN
x = 10
x += 5 # ➕ x = x + 5 → 15
x -= 3 # ➖ x = x - 3 → 12
x *= 2 # ✖️ x = x * 2 → 24
x /= 4 # ➗ x = x / 4 → 6.0
x //= 2 # 🔢 x = x // 2 → 3.0
x %= 2 # 🔄 x = x % 2 → 1.0
x **= 3 # ⚡ x = x ** 3 → 1.0
# 🔹 OPERADORES DE COMPARACIÓN
print(5 == 5) # ✅ True (igual)
print(5 != 3) # ✅ True (diferente)
print(5 > 3) # ✅ True (mayor que)
print(3 < 5) # ✅ True (menor que)
print(5 >= 5) # ✅ True (mayor o igual)
print(3 <= 5) # ✅ True (menor o igual)
# 🔹 OPERADORES LÓGICOS
print(True and True) # ✅ True (Y lógico)
print(True and False) # ❌ False
print(True or False) # ✅ True (O lógico)
print(False or False) # ❌ False
print(not True) # ❌ False (NO lógico)
print(not False) # ✅ True
# 🔹 OPERADORES DE IDENTIDAD
a = [1, 2, 3]
b = [1, 2, 3]
c = a
print(a is c) # ✅ True (mismo objeto)
print(a is b) # ❌ False (objetos diferentes)
print(a is not b) # ✅ True
print(a == b) # ✅ True (mismo contenido)
print(a == c) # ✅ True (mismo contenido)
# 🔹 OPERADORES DE PERTENENCIA
lista = [1, 2, 3, 4, 5]
print(3 in lista) # ✅ True
print(6 in lista) # ❌ False
print(6 not in lista) # ✅ True
cadena = "Python"
print("Py" in cadena) # ✅ True
print("Java" in cadena) # ❌ False
# 🔹 OPERADORES BIT A BIT
a = 5 # 101 en binario
b = 3 # 011 en binario
print(a & b) # 1 (AND bit a bit)
print(a | b) # 7 (OR bit a bit)
print(a ^ b) # 6 (XOR bit a bit)
print(~a) # -6 (NOT bit a bit)
print(a << 1) # 10 (desplazamiento izquierda)
print(a >> 1) # 2 (desplazamiento derecha)
# 🔹 PRECEDENCIA DE OPERADORES (de mayor a menor)
resultado = 2 + 3 * 4 ** 2 # 2 + 3 * 16 = 2 + 48 = 50
print(resultado) # 50
# Usar paréntesis para claridad
resultado = (2 + 3) * 4 ** 2 # 5 * 16 = 80
print(resultado) # 80Estructuras de control
Las estructuras de control permiten dirigir el flujo de ejecución del programa.
# 🚀 ESTRUCTURAS DE CONTROL EN PYTHON
# 🔹 CONDICIONALES
# ✅ if / elif / else
edad = 20
if edad >= 18:
print("Eres mayor de edad")
elif edad >= 13:
print("Eres adolescente")
else:
print("Eres menor de edad")
# ✅ Operador ternario
mensaje = "Mayor" if edad >= 18 else "Menor"
print(mensaje) # "Mayor"
# ✅ Múltiples condiciones
nota = 85
es_estudiante = True
if nota >= 90 and es_estudiante:
print("Excelente estudiante")
elif nota >= 70 or es_estudiante:
print("Buen desempeño")
else:
print("Necesita mejorar")
# 🔹 BUCLES
# ✅ for (iteración sobre secuencias)
# Iterar sobre lista
frutas = ["manzana", "banana", "naranja"]
for fruta in frutas:
print(f"Me gusta la {fruta}")
# Iterar con índice
for i, fruta in enumerate(frutas):
print(f"{i}: {fruta}")
# Iterar sobre rango
for i in range(5): # 0, 1, 2, 3, 4
print(f"Número: {i}")
for i in range(1, 6): # 1, 2, 3, 4, 5
print(f"Número: {i}")
for i in range(0, 10, 2): # 0, 2, 4, 6, 8
print(f"Par: {i}")
# Iterar sobre diccionario
persona = {"nombre": "Ana", "edad": 25, "ciudad": "Madrid"}
# Solo claves
for clave in persona:
print(clave)
# Solo valores
for valor in persona.values():
print(valor)
# Claves y valores
for clave, valor in persona.items():
print(f"{clave}: {valor}")
# ✅ while (bucle mientras condición sea verdadera)
contador = 0
while contador < 5:
print(f"Contador: {contador}")
contador += 1
# ✅ Control de flujo: break y continue
for i in range(10):
if i == 3:
continue # Salta a la siguiente iteración
if i == 7:
break # Sale del bucle
print(i) # Imprime: 0, 1, 2, 4, 5, 6
# ✅ else en bucles (se ejecuta si el bucle termina normalmente)
for i in range(5):
print(i)
else:
print("Bucle completado sin break")
# 🔹 ANIDAMIENTO
for i in range(3):
for j in range(3):
print(f"({i}, {j})", end=" ")
print() # Nueva línea
# 🔹 PATTERN MATCHING (Python 3.10+)
def procesar_dato(dato):
match dato:
case int() if dato > 0:
return f"Número positivo: {dato}"
case int() if dato < 0:
return f"Número negativo: {dato}"
case 0:
return "Cero"
case str() if len(dato) > 0:
return f"Cadena: {dato}"
case []:
return "Lista vacía"
case [x] if isinstance(x, int):
return f"Lista con un número: {x}"
case _:
return "Tipo no reconocido"
# Ejemplos de uso
print(procesar_dato(5)) # "Número positivo: 5"
print(procesar_dato("Hola")) # "Cadena: Hola"
print(procesar_dato([42])) # "Lista con un número: 42"Funciones
Las funciones en Python permiten encapsular código reutilizable y organizar el programa de manera modular.
# 🚀 FUNCIONES EN PYTHON
# 🔹 FUNCIÓN BÁSICA
def saludar(nombre):
"""Función que saluda a una persona"""
return f"Hola, {nombre}!"
resultado = saludar("Juan")
print(resultado) # "Hola, Juan!"
# 🔹 FUNCIÓN CON MÚLTIPLES PARÁMETROS
def calcular_rectangulo(largo, ancho):
"""Calcula área y perímetro de un rectángulo"""
area = largo * ancho
perimetro = 2 * (largo + ancho)
return area, perimetro # Devuelve tupla
area, perimetro = calcular_rectangulo(5, 3)
print(f"Área: {area}, Perímetro: {perimetro}") # "Área: 15, Perímetro: 16"
# 🔹 PARÁMETROS POR DEFECTO
def saludar_persona(nombre, apellido="", formal=False):
"""Saluda con opciones de formalidad"""
if formal:
saludo = "Buenos días"
else:
saludo = "Hola"
if apellido:
return f"{saludo}, {nombre} {apellido}"
return f"{saludo}, {nombre}"
print(saludar_persona("Ana")) # "Hola, Ana"
print(saludar_persona("Ana", "García")) # "Hola, Ana García"
print(saludar_persona("Ana", formal=True)) # "Buenos días, Ana"
print(saludar_persona("Ana", "García", True)) # "Buenos días, Ana García"
# 🔹 *args Y **kwargs
def funcion_flexible(*args, **kwargs):
"""Acepta cualquier número de argumentos"""
print(f"Argumentos posicionales: {args}")
print(f"Argumentos con nombre: {kwargs}")
funcion_flexible(1, 2, 3, nombre="Juan", edad=30)
# Argumentos posicionales: (1, 2, 3)
# Argumentos con nombre: {'nombre': 'Juan', 'edad': 30}
def sumar_todos(*numeros):
"""Suma todos los números pasados como argumentos"""
return sum(numeros)
print(sumar_todos(1, 2, 3, 4, 5)) # 15
# 🔹 FUNCIONES LAMBDA (ANÓNIMAS)
# Función lambda simple
cuadrado = lambda x: x ** 2
print(cuadrado(5)) # 25
# Lambda con múltiples parámetros
sumar = lambda x, y: x + y
print(sumar(3, 4)) # 7
# Uso con funciones integradas
numeros = [1, 2, 3, 4, 5]
cuadrados = list(map(lambda x: x ** 2, numeros))
print(cuadrados) # [1, 4, 9, 16, 25]
pares = list(filter(lambda x: x % 2 == 0, numeros))
print(pares) # [2, 4]
# 🔹 FUNCIONES ANIDADAS Y CLOSURES
def crear_multiplicador(factor):
"""Crea una función que multiplica por el factor dado"""
def multiplicar(numero):
return numero * factor
return multiplicar
multiplicar_por_3 = crear_multiplicador(3)
print(multiplicar_por_3(4)) # 12
multiplicar_por_5 = crear_multiplicador(5)
print(multiplicar_por_5(4)) # 20
# 🔹 DECORADORES BÁSICOS
def mi_decorador(func):
"""Decorador que añade funcionalidad a una función"""
def wrapper(*args, **kwargs):
print(f"Ejecutando {func.__name__}")
resultado = func(*args, **kwargs)
print(f"Terminó {func.__name__}")
return resultado
return wrapper
@mi_decorador
def decir_hola(nombre):
return f"Hola, {nombre}!"
print(decir_hola("Ana"))
# Ejecutando decir_hola
# Terminó decir_hola
# Hola, Ana!
# 🔹 FUNCIONES RECURSIVAS
def factorial(n):
"""Calcula el factorial de n recursivamente"""
if n <= 1:
return 1
return n * factorial(n - 1)
print(factorial(5)) # 120
def fibonacci(n):
"""Calcula el n-ésimo número de Fibonacci"""
if n <= 1:
return n
return fibonacci(n - 1) + fibonacci(n - 2)
print([fibonacci(i) for i in range(8)]) # [0, 1, 1, 2, 3, 5, 8, 13]
# 🔹 ANOTACIONES DE TIPO (Type Hints)
def calcular_promedio(numeros: list[float]) -> float:
"""Calcula el promedio de una lista de números"""
if not numeros:
return 0.0
return sum(numeros) / len(numeros)
def saludar_con_tipo(nombre: str, edad: int) -> str:
"""Saluda a una persona con su edad"""
return f"Hola {nombre}, tienes {edad} años"
promedio = calcular_promedio([1.5, 2.5, 3.5])
print(promedio) # 2.5
# 🔹 FUNCIONES GENERADORAS
def contar_hasta(n):
"""Generador que cuenta hasta n"""
i = 1
while i <= n:
yield i
i += 1
# Usar el generador
for numero in contar_hasta(5):
print(numero) # 1, 2, 3, 4, 5
# Crear lista desde generador
numeros = list(contar_hasta(3))
print(numeros) # [1, 2, 3]Listas
Las listas son una de las estructuras de datos más versátiles en Python, mutables y ordenadas.
# 🚀 LISTAS EN PYTHON
# 🔹 CREAR LISTAS
# Lista vacía
lista_vacia = []
lista_vacia2 = list()
# Lista con elementos
frutas = ["manzana", "banana", "naranja"]
numeros = [1, 2, 3, 4, 5]
mixta = [1, "texto", True, 3.14, [1, 2]]
# Lista por comprensión
cuadrados = [x**2 for x in range(5)] # [0, 1, 4, 9, 16]
pares = [x for x in range(10) if x % 2 == 0] # [0, 2, 4, 6, 8]
# 🔹 ACCESO A ELEMENTOS
frutas = ["manzana", "banana", "naranja", "uva", "kiwi"]
# Índices positivos
print(frutas[0]) # "manzana" (primer elemento)
print(frutas[2]) # "naranja"
# Índices negativos
print(frutas[-1]) # "kiwi" (último elemento)
print(frutas[-2]) # "uva" (penúltimo)
# Slicing (rebanadas)
print(frutas[1:4]) # ["banana", "naranja", "uva"]
print(frutas[:3]) # ["manzana", "banana", "naranja"]
print(frutas[2:]) # ["naranja", "uva", "kiwi"]
print(frutas[::2]) # ["manzana", "naranja", "kiwi"] (cada 2)
print(frutas[::-1]) # ["kiwi", "uva", "naranja", "banana", "manzana"] (reversa)
# 🔹 MODIFICAR ELEMENTOS
frutas[1] = "plátano" # Cambiar un elemento
print(frutas) # ["manzana", "plátano", "naranja", "uva", "kiwi"]
frutas[1:3] = ["banana", "limón"] # Cambiar múltiples elementos
print(frutas) # ["manzana", "banana", "limón", "uva", "kiwi"]
# 🔹 MÉTODOS DE LISTA QUE MODIFICAN LA LISTA ORIGINAL
numeros = [1, 2, 3]
# ✅ append() - Añadir al final
numeros.append(4) # [1, 2, 3, 4]
# ✅ insert() - Insertar en posición específica
numeros.insert(1, 1.5) # [1, 1.5, 2, 3, 4]
# ✅ extend() - Añadir múltiples elementos
numeros.extend([5, 6]) # [1, 1.5, 2, 3, 4, 5, 6]
# ✅ remove() - Eliminar primera ocurrencia
numeros.remove(1.5) # [1, 2, 3, 4, 5, 6]
# ✅ pop() - Eliminar y devolver elemento
ultimo = numeros.pop() # 6, lista: [1, 2, 3, 4, 5]
segundo = numeros.pop(1) # 2, lista: [1, 3, 4, 5]
# ✅ clear() - Vaciar lista
# numeros.clear() # []
# ✅ reverse() - Invertir orden
numeros.reverse() # [5, 4, 3, 1]
# ✅ sort() - Ordenar
numeros.sort() # [1, 3, 4, 5]
numeros.sort(reverse=True) # [5, 4, 3, 1]
# 🔹 MÉTODOS QUE NO MODIFICAN LA LISTA
frutas = ["manzana", "banana", "naranja", "banana"]
# ✅ count() - Contar ocurrencias
print(frutas.count("banana")) # 2
# ✅ index() - Encontrar índice
print(frutas.index("naranja")) # 2
# ✅ copy() - Crear copia
frutas_copia = frutas.copy()
# 🔹 OPERACIONES CON LISTAS
lista1 = [1, 2, 3]
lista2 = [4, 5, 6]
# Concatenación
lista3 = lista1 + lista2 # [1, 2, 3, 4, 5, 6]
# Repetición
repetida = [0] * 5 # [0, 0, 0, 0, 0]
repetida2 = [1, 2] * 3 # [1, 2, 1, 2, 1, 2]
# Pertenencia
print(2 in lista1) # True
print(10 not in lista1) # True
# Longitud
print(len(lista1)) # 3
# 🔹 FUNCIONES INTEGRADAS CON LISTAS
numeros = [3, 1, 4, 1, 5, 9, 2, 6]
print(sum(numeros)) # 31 (suma)
print(max(numeros)) # 9 (máximo)
print(min(numeros)) # 1 (mínimo)
print(sorted(numeros)) # [1, 1, 2, 3, 4, 5, 6, 9] (ordenada, nueva lista)
# ✅ enumerate() - Índice y valor
for i, valor in enumerate(frutas):
print(f"{i}: {valor}")
# ✅ zip() - Combinar listas
nombres = ["Ana", "Juan", "Pedro"]
edades = [25, 30, 35]
for nombre, edad in zip(nombres, edades):
print(f"{nombre} tiene {edad} años")
# 🔹 LISTAS ANIDADAS (MATRICES)
matriz = [
[1, 2, 3],
[4, 5, 6],
[7, 8, 9]
]
print(matriz[1][2]) # 6 (fila 1, columna 2)
# Iterar sobre matriz
for fila in matriz:
for elemento in fila:
print(elemento, end=" ")
print() # Nueva línea
# 🔹 COPIA PROFUNDA VS SUPERFICIAL
import copy
lista_original = [[1, 2], [3, 4]]
# Copia superficial
copia_superficial = lista_original.copy()
copia_superficial[0][0] = 999
print(lista_original) # [[999, 2], [3, 4]] - ¡Se modificó!
# Copia profunda
lista_original = [[1, 2], [3, 4]]
copia_profunda = copy.deepcopy(lista_original)
copia_profunda[0][0] = 999
print(lista_original) # [[1, 2], [3, 4]] - No se modificóStrings
Los strings en Python son inmutables y ofrecen muchos métodos útiles para manipulación de texto.
# 🚀 STRINGS EN PYTHON
# 🔹 CREAR STRINGS
texto = "Hola Python"
texto2 = 'También con comillas simples'
texto3 = """Texto multilínea
que puede abarcar
varias líneas"""
# String con caracteres especiales
especiales = "Línea 1\nLínea 2\tTabulación\\"
# 🔹 ACCESO A CARACTERES
texto = "Python"
print(texto[0]) # "P" (primer carácter)
print(texto[-1]) # "n" (último carácter)
print(texto[2:5]) # "tho" (slicing)
print(texto[::-1]) # "nohtyP" (reverso)
# 🔹 MÉTODOS DE TRANSFORMACIÓN
cadena = " Hola Mundo Python "
# ✅ Cambio de caso
print(cadena.upper()) # " HOLA MUNDO PYTHON "
print(cadena.lower()) # " hola mundo python "
print(cadena.title()) # " Hola Mundo Python "
print(cadena.capitalize()) # " hola mundo python "
print(cadena.swapcase()) # " hOLA mUNDO pYTHON "
# ✅ Limpieza de espacios
print(cadena.strip()) # "Hola Mundo Python"
print(cadena.lstrip()) # "Hola Mundo Python "
print(cadena.rstrip()) # " Hola Mundo Python"
# ✅ Reemplazo
print(cadena.replace("Mundo", "Universo")) # " Hola Universo Python "
print(cadena.replace("o", "0", 2)) # " H0la Mund0 Python " (solo 2)
# 🔹 MÉTODOS DE DIVISIÓN Y UNIÓN
texto = "manzana,banana,naranja"
# ✅ split() - Dividir string
frutas = texto.split(",")
print(frutas) # ["manzana", "banana", "naranja"]
# ✅ join() - Unir lista en string
separado_por_espacios = " ".join(frutas)
print(separado_por_espacios) # "manzana banana naranja"
separado_por_guiones = " - ".join(frutas)
print(separado_por_guiones) # "manzana - banana - naranja"
# ✅ splitlines() - Dividir por líneas
multilinea = "Línea 1\nLínea 2\nLínea 3"
lineas = multilinea.splitlines()
print(lineas) # ["Línea 1", "Línea 2", "Línea 3"]
# 🔹 MÉTODOS DE BÚSQUEDA
texto = "Python es genial y Python es poderoso"
# ✅ find() - Encontrar posición (devuelve -1 si no encuentra)
print(texto.find("Python")) # 0 (primera ocurrencia)
print(texto.find("Python", 1)) # 18 (buscar desde posición 1)
print(texto.find("Java")) # -1 (no encontrado)
# ✅ index() - Como find() pero lanza excepción si no encuentra
print(texto.index("Python")) # 0
# print(texto.index("Java")) # ValueError
# ✅ count() - Contar ocurrencias
print(texto.count("Python")) # 2
print(texto.count("es")) # 2
# ✅ startswith() y endswith()
print(texto.startswith("Python")) # True
print(texto.endswith("poderoso")) # True
print(texto.startswith("Java")) # False
# 🔹 MÉTODOS DE VALIDACIÓN
# ✅ Validaciones de contenido
print("123".isdigit()) # True
print("abc".isalpha()) # True
print("abc123".isalnum()) # True
print(" ".isspace()) # True
print("Hola Mundo".istitle()) # True
print("HOLA".isupper()) # True
print("hola".islower()) # True
# 🔹 FORMATEO Y ALINEACIÓN
nombre = "Ana"
# ✅ Alineación
print(nombre.ljust(10, "-")) # "Ana-------"
print(nombre.rjust(10, "-")) # "-------Ana"
print(nombre.center(10, "-")) # "---Ana----"
# ✅ Rellenar con ceros
numero = "42"
print(numero.zfill(5)) # "00042"
# 🔹 CODIFICACIÓN Y DECODIFICACIÓN
texto = "Hola ñoño"
# ✅ Codificar a bytes
texto_bytes = texto.encode("utf-8")
print(texto_bytes) # b'Hola \xc3\xb1o\xc3\xb1o'
# ✅ Decodificar de bytes
texto_original = texto_bytes.decode("utf-8")
print(texto_original) # "Hola ñoño"
# 🔹 MÉTODOS AVANZADOS
# ✅ partition() - Dividir en 3 partes
email = "usuario@dominio.com"
usuario, separador, dominio = email.partition("@")
print(f"Usuario: {usuario}, Dominio: {dominio}") # Usuario: usuario, Dominio: dominio.com
# ✅ translate() - Traducción de caracteres
tabla = str.maketrans("aeiou", "12345")
texto = "Hola mundo"
print(texto.translate(tabla)) # "H4l1 m5nd4"
# 🔹 STRINGS COMO SECUENCIAS
texto = "Python"
# Longitud
print(len(texto)) # 6
# Iteración
for caracter in texto:
print(caracter, end=" ") # P y t h o n
print()
# Pertenencia
print("th" in texto) # True
print("java" in texto) # False
# 🔹 CONCATENACIÓN Y REPETICIÓN
saludo = "Hola"
nombre = "Ana"
# Concatenación
mensaje = saludo + " " + nombre # "Hola Ana"
# Repetición
linea = "-" * 20 # "--------------------"
# 🔹 ESCAPE Y RAW STRINGS
# Caracteres de escape
ruta_windows = "C:\\Users\\Usuario\\Desktop"
texto_con_comillas = "Dijo: \"Hola mundo\""
# Raw strings (sin procesar escapes)
ruta_raw = r"C:\Users\Usuario\Desktop"
regex_pattern = r"\d+\.\d+"
print(ruta_windows) # C:\Users\Usuario\Desktop
print(ruta_raw) # C:\Users\Usuario\DesktopNúmeros
Python maneja diferentes tipos de números y ofrece muchas operaciones y funciones matemáticas.
# 🚀 NÚMEROS EN PYTHON
# 🔹 TIPOS DE NÚMEROS
# Enteros (int)
entero = 42
entero_negativo = -17
entero_grande = 123456789012345678901234567890 # Sin límite de tamaño
# Decimales (float)
decimal = 3.14159
cientifico = 1.5e-4 # 0.00015
cientifico2 = 2E3 # 2000.0
# Complejos (complex)
complejo = 3 + 4j
complejo2 = complex(2, 5) # 2 + 5j
# 🔹 CONVERSIÓN ENTRE TIPOS
numero_str = "42"
numero_float_str = "3.14"
# String a número
entero_convertido = int(numero_str) # 42
float_convertido = float(numero_float_str) # 3.14
# Entre tipos numéricos
entero_a_float = float(42) # 42.0
float_a_entero = int(3.14) # 3 (trunca, no redondea)
# Base numérica
binario = int("1010", 2) # 10 (binario a decimal)
hexadecimal = int("FF", 16) # 255 (hexadecimal a decimal)
octal = int("17", 8) # 15 (octal a decimal)
# 🔹 OPERACIONES BÁSICAS
a = 10
b = 3
print(a + b) # 13 (suma)
print(a - b) # 7 (resta)
print(a * b) # 30 (multiplicación)
print(a / b) # 3.333... (división)
print(a // b) # 3 (división entera)
print(a % b) # 1 (módulo/resto)
print(a ** b) # 1000 (potencia)
# 🔹 FUNCIONES MATEMÁTICAS INTEGRADAS
import math
numero = 42.7
# ✅ Redondeo
print(round(numero)) # 43
print(round(numero, 1)) # 42.7
print(math.floor(numero)) # 42 (hacia abajo)
print(math.ceil(numero)) # 43 (hacia arriba)
print(math.trunc(numero)) # 42 (truncar decimales)
# ✅ Valor absoluto
print(abs(-42)) # 42
# ✅ Potencias y raíces
print(pow(2, 3)) # 8 (2 elevado a 3)
print(math.sqrt(16)) # 4.0 (raíz cuadrada)
print(math.pow(2, 3)) # 8.0 (potencia como float)
# ✅ Logaritmos
print(math.log(10)) # 2.302... (logaritmo natural)
print(math.log10(100)) # 2.0 (logaritmo base 10)
print(math.log(8, 2)) # 3.0 (logaritmo base 2)
# ✅ Funciones trigonométricas
print(math.sin(math.pi/2)) # 1.0
print(math.cos(math.pi)) # -1.0
print(math.tan(math.pi/4)) # 1.0
# ✅ Conversión de grados/radianes
grados = 90
radianes = math.radians(grados) # π/2
grados_back = math.degrees(radianes) # 90.0
# 🔹 CONSTANTES MATEMÁTICAS
print(math.pi) # 3.141592653589793
print(math.e) # 2.718281828459045
print(math.tau) # 6.283185307179586 (2*π)
print(math.inf) # inf (infinito)
print(math.nan) # nan (not a number)
# 🔹 FUNCIONES MIN/MAX Y SUM
numeros = [1, 5, 3, 9, 2, 7]
print(min(numeros)) # 1
print(max(numeros)) # 9
print(sum(numeros)) # 27
# Con múltiples argumentos
print(min(3, 7, 1, 9)) # 1
print(max(3, 7, 1, 9)) # 9
# 🔹 NÚMEROS ALEATORIOS
import random
# ✅ Número aleatorio entre 0 y 1
print(random.random()) # 0.123456789...
# ✅ Número entero aleatorio en rango
print(random.randint(1, 10)) # Entre 1 y 10 (inclusivo)
print(random.randrange(0, 10)) # Entre 0 y 9
# ✅ Número decimal aleatorio en rango
print(random.uniform(1.5, 10.5)) # Entre 1.5 y 10.5
# ✅ Elegir elemento aleatorio
frutas = ["manzana", "banana", "naranja"]
print(random.choice(frutas))
# ✅ Mezclar lista
numeros = [1, 2, 3, 4, 5]
random.shuffle(numeros)
print(numeros) # Lista mezclada
# 🔹 FORMATEO DE NÚMEROS
numero = 1234567.89
# ✅ Formateo con f-strings
print(f"{numero:,.2f}") # "1,234,567.89"
print(f"{numero:.2e}") # "1.23e+06" (notación científica)
print(f"{numero:.0f}") # "1234568" (sin decimales)
# ✅ Formateo con format()
print("{:,.2f}".format(numero)) # "1,234,567.89"
# ✅ Porcentajes
porcentaje = 0.847
print(f"{porcentaje:.1%}") # "84.7%"
# 🔹 SISTEMAS NUMÉRICOS
numero = 255
# ✅ Conversión a diferentes bases
print(binario := int("1010", 2)) # 10 (binario a decimal)
print(octalo := int("17", 8)) # 15 (octal a decimal)
print(hexadecimal := int("FF", 16)) # 255 (hexadecimal a decimal)
# ✅ Formateo en diferentes bases
print(f"{numero:b}") # "11111111" (binario sin prefijo)
print(f"{numero:o}") # "377" (octal sin prefijo)
print(f"{numero:x}") # "ff" (hex minúsculas)
print(f"{numero:X}") # "FF" (hex mayúsculas)
# 🔹 VALIDACIONES NUMÉRICAS
def es_numero(valor):
"""Verifica si un valor puede convertirse a número"""
try:
float(valor)
return True
except ValueError:
return False
print(es_numero("42")) # True
print(es_numero("3.14")) # True
print(es_numero("abc")) # False
# ✅ Verificar infinito y NaN
import math
print(math.isinf(float('inf'))) # True
print(math.isnan(float('nan'))) # True
print(math.isfinite(42.5)) # True
# 🔹 OPERACIONES BIT A BIT
a = 5 # 101 en binario
b = 3 # 011 en binario
print(a & b) # 1 (AND)
print(a | b) # 7 (OR)
print(a ^ b) # 6 (XOR)
print(~a) # -6 (NOT)
print(a << 1) # 10 (desplazamiento izquierda)
print(a >> 1) # 2 (desplazamiento derecha)Módulos
Los módulos en Python permiten organizar el código en archivos separados y reutilizar funcionalidad.
# 🚀 MÓDULOS EN PYTHON
# 🔹 IMPORTAR MÓDULOS INTEGRADOS
# ✅ Importar módulo completo
import math
print(math.pi) # 3.141592653589793
print(math.sqrt(16)) # 4.0
# ✅ Importar funciones específicas
from math import pi, sqrt, sin
print(pi) # 3.141592653589793
print(sqrt(25)) # 5.0
print(sin(pi/2)) # 1.0
# ✅ Importar con alias
import datetime as dt
from math import pi as PI
ahora = dt.datetime.now()
print(f"Ahora son las {ahora.hour}:{ahora.minute}")
print(f"Pi es aproximadamente {PI:.2f}")
# ✅ Importar todo (no recomendado)
# from math import *
# 🔹 CREAR MÓDULOS PROPIOS
# Archivo: mi_modulo.py
"""
def saludar(nombre):
return f"Hola, {nombre}!"
def calcular_area_circulo(radio):
PI = 3.14159
return PI * radio ** 2
CONSTANTE = "Valor constante"
class Persona:
def __init__(self, nombre):
self.nombre = nombre
def presentarse(self):
return f"Soy {self.nombre}"
"""
# Usar el módulo personalizado
# import mi_modulo
#
# print(mi_modulo.saludar("Ana"))
# print(mi_modulo.calcular_area_circulo(5))
# print(mi_modulo.CONSTANTE)
#
# persona = mi_modulo.Persona("Juan")
# print(persona.presentarse())
# 🔹 PAQUETES
# Estructura de directorios:
# mi_paquete/
# __init__.py
# modulo1.py
# modulo2.py
# subpaquete/
# __init__.py
# modulo3.py
# Importar desde paquetes
# from mi_paquete import modulo1
# from mi_paquete.subpaquete import modulo3
# import mi_paquete.modulo2 as mod2
# 🔹 MÓDULOS MÁS UTILIZADOS
# ✅ datetime - Manejo de fechas y horas
import datetime
ahora = datetime.datetime.now()
print(f"Fecha actual: {ahora.strftime('%d/%m/%Y')}")
print(f"Hora actual: {ahora.strftime('%H:%M:%S')}")
fecha_especifica = datetime.date(2025, 12, 25)
print(f"Navidad: {fecha_especifica}")
# ✅ os - Interacción con el sistema operativo
import os
print(f"Directorio actual: {os.getcwd()}")
print(f"Usuario: {os.getenv('USER', 'Desconocido')}")
print(f"Separador de ruta: {os.sep}")
# ✅ sys - Información del sistema Python
import sys
print(f"Versión de Python: {sys.version}")
print(f"Plataforma: {sys.platform}")
print(f"Argumentos de línea de comandos: {sys.argv}")
# ✅ random - Números aleatorios
import random
print(f"Número aleatorio: {random.random()}")
print(f"Entero aleatorio: {random.randint(1, 10)}")
lista = [1, 2, 3, 4, 5]
random.shuffle(lista)
print(f"Lista mezclada: {lista}")
# ✅ json - Manejo de JSON
import json
# Diccionario a JSON
persona = {"nombre": "Ana", "edad": 25, "ciudad": "Madrid"}
json_str = json.dumps(persona, indent=2)
print("JSON:")
print(json_str)
# JSON a diccionario
persona_desde_json = json.loads(json_str)
print(f"Nombre: {persona_desde_json['nombre']}")
# ✅ re - Expresiones regulares
import re
texto = "Mi teléfono es 123-456-7890"
patron = r"\d{3}-\d{3}-\d{4}"
if re.search(patron, texto):
print("Teléfono encontrado")
# Encontrar todas las coincidencias
numeros = re.findall(r"\d+", "Tengo 25 años y 3 gatos")
print(f"Números encontrados: {numeros}") # ['25', '3']
# ✅ collections - Estructuras de datos adicionales
from collections import Counter, defaultdict, namedtuple
# Counter - Contar elementos
palabras = ["python", "java", "python", "javascript", "python"]
contador = Counter(palabras)
print(contador) # Counter({'python': 3, 'java': 1, 'javascript': 1})
# defaultdict - Diccionario con valores por defecto
dd = defaultdict(list)
dd['frutas'].append('manzana')
print(dd) # defaultdict(<class 'list'>, {'frutas': ['manzana']})
# namedtuple - Tupla con nombres
Punto = namedtuple('Punto', ['x', 'y'])
p = Punto(1, 2)
print(f"Coordenadas: ({p.x}, {p.y})")
# 🔹 INFORMACIÓN SOBRE MÓDULOS
# ✅ dir() - Ver contenido de un módulo
print("Funciones en math:")
print([func for func in dir(math) if not func.startswith('_')])
# ✅ help() - Obtener ayuda
# help(math.sqrt)
# ✅ __name__ - Verificar si es módulo principal
if __name__ == "__main__":
print("Este código se ejecuta solo si el archivo se ejecuta directamente")
# 🔹 INSTALACIÓN DE PAQUETES EXTERNOS
# pip install requests
# pip install pandas
# pip install numpy
# Ejemplo con requests (si está instalado)
try:
import requests
respuesta = requests.get("https://api.github.com/user", timeout=5)
print(f"Status code: {respuesta.status_code}")
except ImportError:
print("requests no está instalado. Instalar con: pip install requests")
except Exception as e:
print(f"Error en la petición: {e}")
# 🔹 RECARGAR MÓDULOS (útil en desarrollo)
import importlib
# importlib.reload(mi_modulo) # Recargar módulo después de cambios
# 🔹 RUTAS DE MÓDULOS
print("Rutas donde Python busca módulos:")
for ruta in sys.path:
print(f" {ruta}")Diccionarios
Los diccionarios son estructuras de datos mutables que almacenan pares clave-valor.
# 🚀 DICCIONARIOS EN PYTHON
# 🔹 CREAR DICCIONARIOS
# Diccionario vacío
diccionario_vacio = {}
diccionario_vacio2 = dict()
# Diccionario con datos
persona = {
"nombre": "Ana",
"edad": 25,
"ciudad": "Madrid",
"activo": True
}
# Usando dict()
persona2 = dict(nombre="Juan", edad=30, ciudad="Barcelona")
# Desde listas de tuplas
pares = [("a", 1), ("b", 2), ("c", 3)]
diccionario_desde_tuplas = dict(pares)
# 🔹 ACCESO A ELEMENTOS
print(persona["nombre"]) # "Ana"
print(persona.get("edad")) # 25
print(persona.get("telefono")) # None (no existe)
print(persona.get("telefono", "No disponible")) # "No disponible"
# 🔹 MODIFICAR Y AÑADIR ELEMENTOS
persona["edad"] = 26 # Modificar
persona["telefono"] = "123456" # Añadir nuevo
persona.update({"email": "ana@email.com", "edad": 27}) # Múltiples cambios
print(persona)
# {'nombre': 'Ana', 'edad': 27, 'ciudad': 'Madrid', 'activo': True, 'telefono': '123456', 'email': 'ana@email.com'}
# 🔹 ELIMINAR ELEMENTOS
del persona["telefono"] # Eliminar clave específica
email = persona.pop("email") # Eliminar y obtener valor
ultimo = persona.popitem() # Eliminar último elemento (Python 3.7+)
# persona.clear() # Vaciar diccionario
# 🔹 MÉTODOS DE DICCIONARIO
persona = {"nombre": "Ana", "edad": 25, "ciudad": "Madrid"}
# ✅ keys() - Obtener todas las claves
claves = persona.keys()
print(list(claves)) # ["nombre", "edad", "ciudad"]
# ✅ values() - Obtener todos los valores
valores = persona.values()
print(list(valores)) # ["Ana", 25, "Madrid"]
# ✅ items() - Obtener pares clave-valor
items = persona.items()
print(list(items)) # [("nombre", "Ana"), ("edad", 25), ("ciudad", "Madrid")]
# ✅ copy() - Crear copia superficial
persona_copia = persona.copy()
# ✅ setdefault() - Obtener valor o establecer por defecto
telefono = persona.setdefault("telefono", "Sin teléfono")
print(telefono) # "Sin teléfono"
print(persona) # Ahora incluye "telefono": "Sin teléfono"
# 🔹 ITERACIÓN SOBRE DICCIONARIOS
# Iterar sobre claves
for clave in persona:
print(f"Clave: {clave}")
# Iterar sobre valores
for valor in persona.values():
print(f"Valor: {valor}")
# Iterar sobre claves y valores
for clave, valor in persona.items():
print(f"{clave}: {valor}")
# 🔹 COMPRENSIÓN DE DICCIONARIOS
# Crear diccionario de cuadrados
cuadrados = {x: x**2 for x in range(5)}
print(cuadrados) # {0: 0, 1: 1, 2: 4, 3: 9, 4: 16}
# Filtrar diccionario
numeros = {"a": 1, "b": 2, "c": 3, "d": 4}
pares = {k: v for k, v in numeros.items() if v % 2 == 0}
print(pares) # {"b": 2, "d": 4}
# Transformar valores
palabras = ["python", "java", "javascript"]
longitudes = {palabra: len(palabra) for palabra in palabras}
print(longitudes) # {"python": 6, "java": 4, "javascript": 10}
# 🔹 OPERACIONES CON DICCIONARIOS
# Verificar existencia de claves
print("nombre" in persona) # True
print("apellido" in persona) # False
print("edad" not in persona) # False
# Longitud del diccionario
print(len(persona)) # Número de pares clave-valor
# Fusionar diccionarios (Python 3.9+)
dict1 = {"a": 1, "b": 2}
dict2 = {"c": 3, "d": 4}
fusionado = dict1 | dict2
print(fusionado) # {"a": 1, "b": 2, "c": 3, "d": 4}
# Fusionar con update
dict1.update(dict2)
print(dict1) # {"a": 1, "b": 2, "c": 3, "d": 4}
# 🔹 DICCIONARIOS ANIDADOS
empresa = {
"nombre": "TechCorp",
"empleados": {
"desarrollo": ["Ana", "Luis", "Carmen"],
"marketing": ["Pedro", "Sofia"]
},
"ubicaciones": {
"madrid": {"direccion": "Calle Principal 123", "empleados": 50},
"barcelona": {"direccion": "Avenida Central 456", "empleados": 30}
}
}
# Acceder a datos anidados
print(empresa["empleados"]["desarrollo"][0]) # "Ana"
print(empresa["ubicaciones"]["madrid"]["empleados"]) # 50
# 🔹 MÉTODOS AVANZADOS
# fromkeys() - Crear diccionario con claves y valor por defecto
claves = ["nombre", "edad", "ciudad"]
diccionario_defecto = dict.fromkeys(claves, "Por definir")
print(diccionario_defecto) # {"nombre": "Por definir", "edad": "Por definir", "ciudad": "Por definir"}
# Ordenar diccionario por claves
persona_ordenado = dict(sorted(persona.items()))
print(persona_ordenado)
# Ordenar por valores
puntuaciones = {"Ana": 95, "Luis": 87, "Carmen": 92}
por_puntuacion = dict(sorted(puntuaciones.items(), key=lambda x: x[1], reverse=True))
print(por_puntuacion) # {"Ana": 95, "Carmen": 92, "Luis": 87}
# 🔹 DEFAULTDICT (del módulo collections)
from collections import defaultdict
# Diccionario con listas por defecto
grupos = defaultdict(list)
grupos["frutas"].append("manzana")
grupos["frutas"].append("banana")
grupos["verduras"].append("zanahoria")
print(dict(grupos)) # {"frutas": ["manzana", "banana"], "verduras": ["zanahoria"]}
# Diccionario con contadores
contador = defaultdict(int)
texto = "python"
for letra in texto:
contador[letra] += 1
print(dict(contador)) # {"p": 1, "y": 1, "t": 1, "h": 1, "o": 1, "n": 1}Conjuntos (Sets)
Los conjuntos son colecciones mutables de elementos únicos, ideales para operaciones matemáticas de conjuntos.
# 🚀 CONJUNTOS (SETS) EN PYTHON
# 🔹 CREAR CONJUNTOS
# Conjunto vacío
conjunto_vacio = set() # ¡No usar {} que crea un diccionario vacío!
# Conjunto con elementos
numeros = {1, 2, 3, 4, 5}
frutas = {"manzana", "banana", "naranja"}
# Desde lista (elimina duplicados automáticamente)
lista_con_duplicados = [1, 2, 2, 3, 3, 3, 4]
conjunto_sin_duplicados = set(lista_con_duplicados)
print(conjunto_sin_duplicados) # {1, 2, 3, 4}
# Desde string
letras = set("python")
print(letras) # {"p", "y", "t", "h", "o", "n"}
# 🔹 OPERACIONES BÁSICAS
conjunto = {1, 2, 3}
# ✅ add() - Añadir elemento
conjunto.add(4)
print(conjunto) # {1, 2, 3, 4}
# ✅ update() - Añadir múltiples elementos
conjunto.update([5, 6, 7])
conjunto.update({8, 9})
print(conjunto) # {1, 2, 3, 4, 5, 6, 7, 8, 9}
# ✅ remove() - Eliminar elemento (error si no existe)
conjunto.remove(9)
print(conjunto) # {1, 2, 3, 4, 5, 6, 7, 8}
# ✅ discard() - Eliminar elemento (sin error si no existe)
conjunto.discard(10) # No produce error
conjunto.discard(8) # Elimina el 8
print(conjunto) # {1, 2, 3, 4, 5, 6, 7}
# ✅ pop() - Eliminar y devolver elemento aleatorio
elemento = conjunto.pop()
print(f"Elemento eliminado: {elemento}")
print(conjunto)
# ✅ clear() - Vaciar conjunto
# conjunto.clear()
# 🔹 OPERACIONES DE CONJUNTO
a = {1, 2, 3}
b = {3, 4, 5}
# ✅ Unión
print(a | b) # {1, 2, 3, 4, 5}
print(a.union(b)) # {1, 2, 3, 4, 5}
# ✅ Intersección
print(a & b) # {3}
print(a.intersection(b)) # {3}
# ✅ Diferencia
print(a - b) # {1, 2}
print(a.difference(b)) # {1, 2}
# ✅ Diferencia simétrica
print(a ^ b) # {1, 2, 4, 5}
print(a.symmetric_difference(b)) # {1, 2, 4, 5}
# 🔹 CONJUNTOS ANIDADOS
conjunto_anidado = {1, 2, {3, 4, 5}, 6}
print(conjunto_anidado) # {1, 2, 6, {3, 4, 5}}
# Acceder a elementos (no se puede hacer slicing)
for elemento in conjunto_anidado:
print(elemento)
# 🔹 CONJUNTOS Y MUTABILIDAD
conjunto = {1, 2, 3}
# ✅ Mutable (se puede modificar)
conjunto.add(4) # {1, 2, 3, 4}
conjunto.remove(2) # {1, 3, 4}
# ❌ Inmutable (no se puede modificar)
# conjunto = {1, 2, 3}
# conjunto[0] = 10 # Error: no se puede modificar
# 🔹 MÉTODOS DE VERIFICACIÓN
a = {1, 2, 3}
b = {1, 2}
c = {4, 5}
# ✅ issubset() - Verificar si es subconjunto
print(b.issubset(a)) # True (b está contenido en a)
print(c.issubset(a)) # False
# ✅ issuperset() - Verificar si es superconjunto
print(a.issuperset(b)) # True (a contiene a b)
print(a.issuperset(c)) # False
# ✅ isdisjoint() - Verificar si no tienen elementos en común
print(a.isdisjoint(c)) # True (no comparten elementos)
print(a.isdisjoint(b)) # False (comparten elementos)
# 🔹 PERTENENCIA Y LONGITUD
conjunto = {1, 2, 3, 4, 5}
# Verificar pertenencia
print(3 in conjunto) # True
print(6 in conjunto) # False
print(7 not in conjunto) # True
# Longitud del conjunto
print(len(conjunto)) # 5
# 🔹 ITERACIÓN
frutas = {"manzana", "banana", "naranja"}
# Iterar sobre elementos
for fruta in frutas:
print(fruta)
# Comprensión de conjuntos
numeros = {1, 2, 3, 4, 5, 6}
pares = {x for x in numeros if x % 2 == 0}
print(pares) # {2, 4, 6}
cuadrados = {x**2 for x in range(5)}
print(cuadrados) # {0, 1, 4, 9, 16}
# 🔹 FROZEN SET (CONJUNTO INMUTABLE)
# Los frozenset son inmutables, se pueden usar como claves en diccionarios
conjunto_inmutable = frozenset([1, 2, 3, 4])
print(conjunto_inmutable) # frozenset({1, 2, 3, 4})
# No se puede modificar
# conjunto_inmutable.add(5) # Error: AttributeError
# Usar frozenset como clave en diccionario
diccionario_con_sets = {
frozenset([1, 2]): "conjunto A",
frozenset([3, 4]): "conjunto B"
}
print(diccionario_con_sets)
# 🔹 CASOS DE USO PRÁCTICOS
# Eliminar duplicados de una lista manteniendo tipo
lista_con_duplicados = [1, 2, 2, 3, 3, 3, 4, 1]
lista_sin_duplicados = list(set(lista_con_duplicados))
print(lista_sin_duplicados) # [1, 2, 3, 4] (orden puede variar)
# Operaciones entre listas usando sets
lista1 = [1, 2, 3, 4]
lista2 = [3, 4, 5, 6]
# Elementos comunes
comunes = list(set(lista1) & set(lista2))
print(comunes) # [3, 4]
# Elementos únicos de cada lista
unicos_lista1 = list(set(lista1) - set(lista2))
unicos_lista2 = list(set(lista2) - set(lista1))
print(f"Únicos de lista1: {unicos_lista1}") # [1, 2]
print(f"Únicos de lista2: {unicos_lista2}") # [5, 6]
# Todos los elementos únicos
todos_unicos = list(set(lista1) ^ set(lista2))
print(todos_unicos) # [1, 2, 5, 6]