Operadores Lógicos

Operadores Lógicos en Python

Los operadores lógicos en Python son herramientas fundamentales que nos permiten combinar y manipular expresiones booleanas (verdadero o falso). Estos operadores son esenciales para crear condiciones complejas que controlan el flujo de nuestros programas.

Los Tres Operadores Lógicos Principales

Python proporciona tres operadores lógicos básicos:

1. and (Y lógico)

El operador and devuelve True si ambas expresiones que conecta son verdaderas. De lo contrario, devuelve False.

# Operador and
x = 5
y = 10

# Ambas condiciones son verdaderas
print(x > 0 and y < 20)  # Resultado: True

# Una condición es falsa
print(x > 10 and y < 20)  # Resultado: False

# Ambas condiciones son falsas
print(x > 10 and y > 20)  # Resultado: False

2. or (O lógico)

El operador or devuelve True si al menos una de las expresiones que conecta es verdadera. Solo devuelve False si ambas expresiones son falsas.

# Operador or
x = 5
y = 10

# Ambas condiciones son verdaderas
print(x > 0 or y < 20)  # Resultado: True

# Una condición es verdadera
print(x > 10 or y < 20)  # Resultado: True

# Ambas condiciones son falsas
print(x > 10 or y > 20)  # Resultado: False

3. not (Negación lógica)

El operador not invierte el valor de verdad de una expresión. Si la expresión es verdadera, not la convierte en falsa, y viceversa.

# Operador not
x = 5

# Negación de una expresión verdadera
print(not x > 0)  # Resultado: False

# Negación de una expresión falsa
print(not x > 10)  # Resultado: True

# Doble negación
print(not not x > 0)  # Resultado: True

Tabla de Verdad

Para entender mejor cómo funcionan los operadores lógicos, es útil revisar sus tablas de verdad:

Tabla de verdad para and

Tabla de verdad para or

Tabla de verdad para not

Evaluación de Cortocircuito

Python utiliza evaluación de cortocircuito para los operadores and y or, lo que significa que no evalúa la segunda expresión si el resultado ya puede determinarse con la primera:

Cortocircuito con and

Si la primera expresión es False, Python no evalúa la segunda expresión porque el resultado será False independientemente:

# La segunda expresión no se evalúa
x = 5
print(x > 10 and print("Esta línea no se ejecuta"))  # Resultado: False

Cortocircuito con or

Si la primera expresión es True, Python no evalúa la segunda expresión porque el resultado será True independientemente:

# La segunda expresión no se evalúa
x = 5
print(x > 0 or print("Esta línea no se ejecuta"))  # Resultado: True

Precedencia de Operadores

Los operadores lógicos tienen un orden de precedencia específico:

1. not (mayor precedencia)
2. and
3. or (menor precedencia)

# Ejemplo de precedencia
print(True or False and False)  # Resultado: True (equivale a True or (False and False))
print(not True or False)        # Resultado: False (equivale a (not True) or False)

# Uso de paréntesis para cambiar la precedencia
print(True or (False and False))  # Resultado: True
print((not True) or False)        # Resultado: False
print(not (True or False))        # Resultado: False

Valores Truthy y Falsy

En Python, cualquier valor puede ser interpretado como booleano en un contexto condicional. Esto se conoce como "truthiness" (veracidad) de un valor.

Valores considerados False (Falsy)

Los siguientes valores se evalúan como False en un contexto booleano:

• False
• None
• Cero de cualquier tipo numérico: 0, 0.0, 0j
• Colecciones vacías: "", (), [], {}
• Objetos que implementan __bool__() que devuelve False o __len__() que devuelve 0

# Ejemplos de valores falsy
print(bool(False))  # False
print(bool(None))   # False
print(bool(0))      # False
print(bool(""))     # False
print(bool([]))     # False
print(bool({}))     # False

Valores considerados True (Truthy)

Cualquier valor que no sea falsy se considera truthy, incluyendo:

• True
• Números distintos de cero
• Cadenas no vacías
• Colecciones no vacías

# Ejemplos de valores truthy
print(bool(True))    # True
print(bool(1))       # True
print(bool(-1))      # True
print(bool("Hola"))  # True
print(bool([0]))     # True (lista no vacía)
print(bool({"a": 1}))  # True (diccionario no vacío)

Uso de Operadores Lógicos con Valores No Booleanos

Los operadores lógicos en Python no siempre devuelven valores booleanos. En realidad, devuelven uno de los operandos:

Comportamiento de and

El operador and devuelve el primer operando si es falsy, de lo contrario, devuelve el segundo operando:

# Ejemplos de and con valores no booleanos
print(0 and 42)        # Resultado: 0 (primer operando es falsy)
print(42 and 0)        # Resultado: 0 (segundo operando)
print("Hola" and "Mundo")  # Resultado: "Mundo" (segundo operando)
print("" and "Mundo")      # Resultado: "" (primer operando es falsy)

Comportamiento de or

El operador or devuelve el primer operando si es truthy, de lo contrario, devuelve el segundo operando:

# Ejemplos de or con valores no booleanos
print(0 or 42)        # Resultado: 42 (segundo operando)
print(42 or 0)        # Resultado: 42 (primer operando es truthy)
print("Hola" or "Mundo")  # Resultado: "Hola" (primer operando es truthy)
print("" or "Mundo")      # Resultado: "Mundo" (segundo operando)

Patrones Comunes con Operadores Lógicos

Asignación con valor predeterminado

# Asignar un valor predeterminado si la variable es None o está vacía
nombre = input("Ingresa tu nombre: ") or "Usuario"
print(f"Hola, {nombre}!")

Verificación de múltiples condiciones

# Verificar si un número está dentro de un rango
edad = 25
es_adulto_joven = 18 <= edad <= 35
print(es_adulto_joven)  # Resultado: True

# Verificar múltiples condiciones con and
es_valido = edad >= 18 and edad <= 65 and edad != 30
print(es_valido)  # Resultado: True

# Verificar si al menos una condición es verdadera con or
es_especial = edad < 18 or edad > 65 or edad == 25
print(es_especial)  # Resultado: True

Guardas de seguridad

# Evitar errores al acceder a atributos o índices
def obtener_apellido(usuario):
    # Devuelve el apellido solo si usuario existe y tiene el atributo apellido
    return usuario and usuario.apellido

# Versión segura de acceso a diccionario
def obtener_valor(diccionario, clave, predeterminado=None):
    return diccionario and diccionario.get(clave, predeterminado)

Combinación con Operadores de Comparación

Los operadores lógicos se combinan frecuentemente con operadores de comparación para crear condiciones complejas:

# Verificar múltiples condiciones
edad = 25
ingresos = 30000

# Elegibilidad para un préstamo
es_elegible = (edad >= 18 and edad <= 65) and ingresos >= 25000
print(es_elegible)  # Resultado: True

# Condiciones excluyentes
es_estudiante = True
tiene_descuento = edad < 18 or edad > 65 or es_estudiante
print(tiene_descuento)  # Resultado: True

# Negación de condiciones complejas
no_cumple_requisitos = not ((edad >= 18) and (ingresos >= 25000))
print(no_cumple_requisitos)  # Resultado: False

Ejemplos Prácticos

Sistema de autenticación básico

def verificar_acceso(usuario, contraseña, es_admin=False):
    # Verificar credenciales básicas
    credenciales_validas = usuario == "admin" and contraseña == "12345"
    
    # Verificar permisos adicionales si es necesario
    if es_admin:
        return credenciales_validas and usuario == "admin"
    else:
        return credenciales_validas or (usuario == "invitado" and contraseña == "guest")

# Ejemplos de uso
print(verificar_acceso("admin", "12345"))          # True
print(verificar_acceso("admin", "contraseña"))     # False
print(verificar_acceso("invitado", "guest"))       # True
print(verificar_acceso("invitado", "guest", True)) # False (no es admin)

Filtrado de datos

# Lista de productos
productos = [
    {"nombre": "Laptop", "precio": 1200, "disponible": True},
    {"nombre": "Teléfono", "precio": 800, "disponible": True},
    {"nombre": "Tablet", "precio": 500, "disponible": False},
    {"nombre": "Auriculares", "precio": 150, "disponible": True},
    {"nombre": "Monitor", "precio": 300, "disponible": False}
]

# Filtrar productos disponibles y con precio menor a 1000
productos_filtrados = [
    p for p in productos 
    if p["disponible"] and p["precio"] < 1000
]

print("Productos disponibles por menos de 1000:")
for p in productos_filtrados:
    print(f"- {p['nombre']}: ${p['precio']}")

Validación de formularios

def validar_formulario(nombre, email, edad):
    # Verificar que todos los campos requeridos estén completos
    if not (nombre and email and edad):
        return False, "Todos los campos son obligatorios"
    
    # Validar formato de email básico
    if "@" not in email or "." not in email:
        return False, "El email no tiene un formato válido"
    
    # Validar edad
    try:
        edad = int(edad)
        if not (18 <= edad <= 120):
            return False, "La edad debe estar entre 18 y 120 años"
    except ValueError:
        return False, "La edad debe ser un número"
    
    # Si pasa todas las validaciones
    return True, "Formulario válido"

# Ejemplos de uso
print(validar_formulario("Ana", "ana@ejemplo.com", 25))
print(validar_formulario("", "ana@ejemplo.com", 25))
print(validar_formulario("Ana", "anaejemplo.com", 25))
print(validar_formulario("Ana", "ana@ejemplo.com", 15))

Mejores Prácticas

1. Usa paréntesis para claridad: Aunque Python tiene reglas de precedencia claras, usar paréntesis hace que el código sea más legible.

# Menos claro
if a > b and c > d or e > f:
    # código

# Más claro
if ((a > b) and (c > d)) or (e > f):
    # código

2. Evita negaciones complejas: Múltiples negaciones hacen que el código sea difícil de entender.

# Difícil de entender
if not (not a or not b):
    # código

# Más claro
if a and b:
    # código

3. Aprovecha la evaluación de cortocircuito: Puedes usar el comportamiento de cortocircuito para escribir código más eficiente.

# Verificación segura antes de acceder a un atributo
if usuario and usuario.es_activo:
    # código

4. Usa expresiones booleanas directamente: No compares explícitamente con True o False.

# No recomendado
if es_valido == True:
    # código

# Recomendado
if es_valido:
    # código

5. Considera usar funciones para condiciones complejas: Si una condición es muy compleja, considera extraerla a una función con un nombre descriptivo.

def cumple_requisitos_prestamo(edad, ingresos, historial_crediticio):
    return (18 <= edad <= 65) and (ingresos >= 25000) and historial_crediticio >= 700

# Uso
if cumple_requisitos_prestamo(cliente.edad, cliente.ingresos, cliente.credito):
    aprobar_prestamo()

Ejercicios Prácticos

1. Escribe una función que determine si un número es divisible por 2, 3 y 5 al mismo tiempo.
2. Crea una función que verifique si una cadena es una dirección de email válida (contiene @, un dominio y al menos un punto en el dominio).
3. Implementa un sistema de filtrado que permita buscar productos por rango de precio y disponibilidad.
4. Escribe una función que determine si un año es bisiesto (divisible por 4, pero no por 100 a menos que también sea divisible por 400).
5. Crea un validador de contraseñas que verifique múltiples criterios: longitud mínima, presencia de letras mayúsculas, minúsculas, números y caracteres especiales.

En la próxima lección, aprenderemos sobre la entrada de datos en Python y cómo interactuar con el usuario a través de la consola.