Ir al contenido principal

Operadores aritméticos y lógicos

Introducción

Los operadores son símbolos especiales en Python que realizan operaciones con valores y variables. En la programación, son esenciales para manipular datos, realizar cálculos y tomar decisiones lógicas. Python ofrece una amplia variedad de operadores que podemos clasificar principalmente en aritméticos y lógicos. Los primeros nos permiten realizar operaciones matemáticas, mientras que los segundos evalúan condiciones y devuelven valores de verdad. Dominando estos operadores, podremos crear programas más potentes y versátiles.

Operadores aritméticos

Los operadores aritméticos se utilizan para realizar operaciones matemáticas, desde las más básicas hasta algunas más avanzadas.

Operadores básicos

# Suma (+)
suma = 5 + 3
print(suma)  # Muestra: 8

# Resta (-)
resta = 10 - 4
print(resta)  # Muestra: 6

# Multiplicación (*)
multiplicación = 3 * 4
print(multiplicación)  # Muestra: 12

# División (/)
división = 20 / 5
print(división)  # Muestra: 4.0 (siempre devuelve un float)

Operadores avanzados

# División entera (//)
# Devuelve solo la parte entera del resultado
división_entera = 17 // 5
print(división_entera)  # Muestra: 3

# Módulo (%)
# Devuelve el resto de la división
resto = 17 % 5
print(resto)  # Muestra: 2

# Potencia (**)
# Eleva el primer número a la potencia del segundo
potencia = 2 ** 3
print(potencia)  # Muestra: 8

Ejemplos prácticos

# Calcular si un número es par o impar
número = 15
es_par = número % 2 == 0
print(f"¿El número {número} es par? {es_par}")  # Muestra: ¿El número 15 es par? False

# Convertir segundos a formato horas:minutos:segundos
total_segundos = 3725
horas = total_segundos // 3600
minutos = (total_segundos % 3600) // 60
segundos = total_segundos % 60
print(f"{horas}:{minutos}:{segundos}")  # Muestra: 1:2:5

Precedencia de operadores aritméticos

Python sigue las reglas matemáticas estándar para la precedencia de operadores:

  1. Paréntesis ()
  2. Exponenciación **
  3. Multiplicación, división, división entera y módulo *, /, //, %
  4. Suma y resta +, -
# Sin paréntesis, se evalúa según la precedencia
resultado1 = 2 + 3 * 4
print(resultado1)  # Muestra: 14 (primero 3*4=12, luego 2+12=14)

# Con paréntesis, controlamos el orden
resultado2 = (2 + 3) * 4
print(resultado2)  # Muestra: 20 (primero 2+3=5, luego 5*4=20)

Operadores de asignación

Python ofrece operadores que combinan una operación aritmética con una asignación:

# Asignación simple (=)
x = 10

# Incremento (+=)
x += 5  # Equivale a: x = x + 5
print(x)  # Muestra: 15

# Decremento (-=)
x -= 3  # Equivale a: x = x - 3
print(x)  # Muestra: 12

# Multiplicación (*=)
x *= 2  # Equivale a: x = x * 2
print(x)  # Muestra: 24

# División (/=)
x /= 4  # Equivale a: x = x / 4
print(x)  # Muestra: 6.0

# Otras opciones: //=, %=, **=

Operadores lógicos

Los operadores lógicos evalúan expresiones booleanas y devuelven un valor booleano (True o False).

Operadores básicos

# AND lógico: devuelve True si ambas condiciones son True
resultado_and = True and False
print(resultado_and)  # Muestra: False

# OR lógico: devuelve True si al menos una condición es True
resultado_or = True or False
print(resultado_or)  # Muestra: True

# NOT lógico: invierte el valor de verdad
resultado_not = not True
print(resultado_not)  # Muestra: False

Ejemplos prácticos

# Comprobar si un número está en un rango
edad = 25
en_rango = edad >= 18 and edad <= 65
print(f"¿La edad está entre 18 y 65? {en_rango}")  # Muestra: True

# Comprobar condiciones excluyentes
día = "sábado"
es_fin_de_semana = día == "sábado" or día == "domingo"
print(f"¿Es fin de semana? {es_fin_de_semana}")  # Muestra: True

# Comprobar si una condición no se cumple
es_laborable = not es_fin_de_semana
print(f"¿Es día laborable? {es_laborable}")  # Muestra: False

Evaluación en cortocircuito

Python evalúa los operadores lógicos de manera eficiente:

  • Para and: si el primer valor es False, el resultado será False sin evaluar el segundo valor.
  • Para or: si el primer valor es True, el resultado será True sin evaluar el segundo valor.
# El segundo valor no se evalúa porque el primero ya es False
resultado = False and print("Esto no se mostrará")
print(resultado)  # Muestra: False

# El segundo valor no se evalúa porque el primero ya es True
resultado = True or print("Esto no se mostrará")
print(resultado)  # Muestra: True

Valores truthy y falsy

En Python, no solo los valores booleanos pueden usarse en operaciones lógicas. Otros tipos de datos pueden evaluarse como True o False en un contexto booleano:

  • Valores considerados False (falsy): False, None, 0, 0.0, cadenas vacías "", listas vacías [], tuplas vacías (), diccionarios vacíos {}.
  • Todo lo demás se considera True (truthy).
# Ejemplos de valores "falsy"
print(bool(0))       # Muestra: False
print(bool(""))      # Muestra: False
print(bool([]))      # Muestra: False

# Ejemplos de valores "truthy"
print(bool(1))       # Muestra: True
print(bool("texto")) # Muestra: True
print(bool([1, 2]))  # Muestra: True

Operadores de identidad y pertenencia

# is: comprueba si dos variables apuntan al mismo objeto en memoria
a = [1, 2, 3]
b = a  # b apunta al mismo objeto que a
c = [1, 2, 3]  # c es una nueva lista con los mismos valores

print(a is b)  # Muestra: True
print(a is c)  # Muestra: False (objetos diferentes)
print(a == c)  # Muestra: True (valores iguales)

# in: comprueba si un valor está dentro de una secuencia
frutas = ["manzana", "pera", "plátano"]
print("manzana" in frutas)  # Muestra: True
print("naranja" in frutas)  # Muestra: False
print("na" in "banana")     # Muestra: True

Combinar operadores aritméticos y lógicos

Podemos combinar diferentes tipos de operadores en expresiones complejas:

# Calcular si un año es bisiesto
año = 2024
es_bisiesto = (año % 4 == 0 and año % 100 != 0) or (año % 400 == 0)
print(f"¿El año {año} es bisiesto? {es_bisiesto}")  # Muestra: True

# Calcular precio con descuento basado en condiciones
precio = 100
es_cliente_habitual = True
descuento_aplicable = precio > 50 and es_cliente_habitual
precio_final = precio * 0.9 if descuento_aplicable else precio
print(f"Precio final: {precio_final} euros")  # Muestra: 90.0 euros

Resumen

En este artículo hemos explorado los operadores aritméticos y lógicos de Python, fundamentales para realizar cálculos matemáticos y evaluaciones lógicas. Los operadores aritméticos nos permiten realizar operaciones matemáticas básicas y avanzadas, mientras que los operadores lógicos nos ayudan a evaluar condiciones y tomar decisiones en nuestro código. La combinación de ambos tipos de operadores permite crear expresiones complejas para resolver problemas de programación. En próximos artículos, veremos cómo aplicar estos operadores en estructuras de control para crear programas más dinámicos y funcionales.

Volver arriba