Operadores Aritmeticos y Logicos

Los operadores son simbolos especiales que le dicen a Python que realize una operacion especifica. Son la base de cualquier programa porque te permiten realizar calculos matematicos, comparar valores, y combinar condiciones logicas. Sin operadores, tu codigo seria estatico y no podria tomar decisiones ni proces datos.

Python tiene varios tipos de operadores: aritmeticos (para calculos matematicos), de asignacion (para guardar valores), de comparacion (para comparar valores), logicos (para combinar condiciones), de identidad (para verificar si son el mismo objeto), y de pertenencia (para verificar si un elemento esta en una coleccion). En esta leccion, nos centraremos en los operadores aritmeticos y logicos.

Los operadores aritmeticos realizan operaciones matematicas basicas:

Suma (+)

a = 10 + 5 # 15
b = 3.14 + 2.86 # 6.0

Resta (-)

a = 10 - 5 # 5
b = 100 - 1 # 99

Multiplicacion (*)

a = 10 * 5 # 50
b = 3.14 * 2 # 6.28

Division (/)

a = 10 / 2 # 5.0 (siempre devuelve float)
b = 7 / 3 # 2.3333333333333335

Division entera (//)

a = 10 // 3 # 3 (solo la parte entera)
b = 7 // 2 # 3

Modulo (%)

a = 10 % 3 # 1 (resto de la division)
b = 7 % 2 # 1 (determina si es par o impar)

El operador modulo es muy util. Por ejemplo, para saber si un numero es par o impar:

numero = 7
if numero % 2 == 0:
print("Es par")
else:
print("Es impar")

Exponenciacion ()**

a = 2 ** 3 # 8 (2 al cubo)
b = 10 ** 2 # 100 (10 al cuadrado)
c = 2 ** 10 # 1024

Cuando una expresion tiene multiples operadores, Python sigue reglas de precedencia. El orden es:

1. ** (exponenciacion)
2. • / // % (multiplicacion, division, division entera, modulo)
3. • • (suma y resta)

Ejemplo:

resultado = 2 + 3 * 4 # 14, no 20

Porque la multiplicacion se hace primero

Para cambiar el orden, usa parentesis:

resultado = (2 + 3) * 4 # 20

Es una buena practica usar parentesis para hacer el codigo mas legible, incluso cuando no sean necesarios. Makes it clear what you intend.

Ademas del operador basico (=), Python tiene operadores de asignacion combinados que realizan una operacion y asignan en un solo paso:

x = 10
x += 5 # Equivalente a x = x + 5, ahora x es 15
x -= 3 # Equivalente a x = x - 3, ahora x es 12
x *= 2 # Equivalente a x = x * 2, ahora x es 24
x /= 4 # Equivalente a x = x / 4, ahora x es 6.0
x //= 2 # Equivalente a x = x // 2, ahora x es 3.0
x **= 2 # Equivalente a x = x ** 2, ahora x es 9.0
x %= 4 # Equivalente a x = x % 4, ahora x es 1.0

Estos operadores son especialmente utiles en loops cuando necesitas modificar una variable.

Los operadores de comparacion comparan dos valores y devuelven True o False:

a = 10
b = 20

print(a == b) # False (igual)
print(a != b) # True (diferente)
print(a < b) # True (menor que)
print(a > b) # False (mayor que)
print(a <= b) # True (menor o igual)
print(a >= b) # False (mayor o igual)

Puedes encadenar comparaciones (esto es una caracteristica unica de Python):

x = 5
print(1 < x < 10) # True
print(0 < x < 5) # False
print(-1 < x < 1) # False

Los operadores logicos combinan valores booleanos: and, or, y not.

and: Devuelve True solo si ambos operandos son True

print(True and True) # True
print(True and False) # False
print(False and False) # False

or: Devuelve True si al menos un operando es True

print(True or True) # True
print(True or False) # True
print(False or False) # False

not: Invierte el valor booleano

print(not True) # False
print(not False) # True

Ejemplo practico verificando rango:

edad = 25

Verificar si la edad esta entre 18 y 65

if edad >= 18 and edad <= 65:
print("Esta en edad laboral")

Las leyes de De Morgan son reglas importantes para entender como funcionan los operadores logicos:

• not (a and b) == (not a) or (not b)
• not (a or b) == (not a) and (not b)

Esto es util para simplificar condiciones:

Estas dos condiciones son equivalentes

if not (edad >= 18 and tiene_identificacion):
print("No puede entrar")

Es igual a:

if edad < 18 or not tiene_identificacion:
print("No puede entrar")

Python evalua expresiones logicas de manera eficiente usando corto circuito (short-circuit evaluation):

• Para and: Si el primer valor es False, no evalua el segundo porque ya sabe que el resultado sera False
• Para or: Si el primer valor es True, no evalua el segundo porque ya sabe que el resultado sera True

def func():
print("Se ejecuto")
return False

False and (no se ejecuta func)

resultado = False and func()

True or (no se ejecuta func)

resultado = True or func()

Esto es util para escribir condiciones seguras:

usuario = None

Si usuario existe, muestra su nombre

if usuario and usuario.nombre:
print(usuario.nombre)

Python trata cualquier valor como booleano cuando se usa en contexto logico. Valores "falsos" (falsy):

• None
• False
• 0, 0.0
• '', "", (cadenas vacias)
• [], {}, () (colecciones vacias)

Todo lo demas es "verdadero" (truthy).

nombre = ""
if nombre:
print(f"Hola, {nombre}")
else:
print("Hola, anonimo")

numeros = [1, 2, 3]
if numeros:
print(f"Tienes {len(numeros)} numeros")

Estos operadores trabajan con bits (0 y 1) de los numeros. Son menos comunes pero utiles en programacion de bajo nivel:

a = 5 # 101 en binario
b = 3 # 011 en binario

print(a & b) # 1 (001) - AND bit a bit
print(a | b) # 7 (111) - OR bit a bit
print(a ^ b) # 6 (110) - XOR bit a bit
print(~a) # -6 - NOT bit a bit
print(a << 1) # 10 - Shift a la izquierda
print(a >> 1) # 2 - Shift a la derecha

No necesitas usar estos operadores frecuentemente, pero es bueno saber que existen.

Vamos a crear una calculadora de notas que use varios operadores:

Calculadora de promedio

nota1 = float(input("Nota 1: "))
nota2 = float(input("Nota 2: "))
nota3 = float(input("Nota 3: "))

promedio = (nota1 + nota2 + nota3) / 3

print(f"Tu promedio es: {promedio:.2f}")

if promedio >= 7 and promedio <= 10:
print("Aprobado!")
elif promedio >= 5 and promedio < 7:
print("A recuperacion")
else:
print("Reprobado")

Otro ejemplo, verificar si un ano es bisiesto:

ano = int(input("Ingresa un año: "))

Un año es bisiesto si es divisible por 4

pero no por 100, a menos que sea divisible por 400

if (ano % 4 == 0 and ano % 100 != 0) or (ano % 400 == 0):
print(f"{ano} es un año bisiesto")
else:
print(f"{ano} no es un año bisiesto")

Error 1: Confundir = con ==

Incorrecto (asigna, no compara)

if x = 5:
print(x)

Correcto (compara)

if x == 5:
print(x)

Error 2: Usar = en lugar de == en comparaciones

Error 3: Olvidar precedencia de operadores

Incorrecto: esto divide primero (10/2 = 5), luego suma 5 + 5 = 10

resultado = 5 + 10 / 2 # 10.0

Correcto: suma primero (5 + 10 = 15), luego divide 15 / 2 = 7.5

resultado = (5 + 10) / 2 # 7.5

Resumen

• Operadores aritmeticos: +, -, *, /, //, %, **
• Operadores de asignacion: =, +=, -=, *=, /=, //=, %=, **=
• Operadores de comparacion: ==, !=, <, >, <=, >=
• Operadores logicos: and, or, not
• Precedencia: ** antes que * / // %, luego + -
• Corto circuito: evaluacion eficiente de expresiones logicas
• Valores truthy/falsy: cualquier valor puede evaluarse como booleano
• Operadores bit a bit: &, |, ^, ~, <<, >>

Has completado el modulo de Fundamentos de Python. Ahora tienes las bases necesarias para comenzar a escribir programas mas complejos. Continue practicando con los ejercicios y nos vemos en el siguiente modulo!