Operadores con Python

Los operadores en Python se pueden clasificar en varios tipos: operadores aritméticos, operadores relacionales, operadores de asignación, operadores lógicos, operadores de pertenencia, operadores de identidad, operador Walrus y operadores nivel de Bit.

Recuerda que puedes conocer más sobre los tipos de datos int, float y complex en Python para realizar operaciones aritméticas.

Operadores aritméticos

Dentro del grupo de los operadores aritméticos podemos encontrar los siguientes, veamos algunos ejemplos.

  • Suma (representado por el símbolo +)

Realiza la suma de dos operandos → 20 + 34 = 54

resultado_suma = 10 + 14
print(resultado_suma)

# 24
  • Resta (representado por el símbolo -)

Realiza la resta entre dos operandos → 20 – 34 = -14

resultado_resta = 10 - 14
print(resultado_resta)

# -4
  • Producto (representado por el símbolo *)

Realiza la multiplicación de dos operandos → 20 * 34 = 680

resultado_producto = 20 * 34
print(resultado_producto)

# 680
  • División (representado por el símbolo /)

Realiza la división de dos operandos → 89 / 14 = 6.357142857142857

resultado_division = 40 / 14
print(resultado_division)

# 2.857142857142857
  • División con resultado entero (representado por el símbolo //)

Realiza la división entre dos operandos con un resultado entero → 89 // 14 = 6

resultado_division_entero = 40 // 14
print(resultado_division_entero)

# 2
  • Resto (representado por el símbolo %)

Realiza el módulo entre dos operandos, lo que viene a ser el resto en una división → 9 % 2 = 1

resultado_resto = 40 % 14
print(resultado_resto)

# 12
  • Potencia (representado por el símbolo **)

Realiza la potencia entre dos operandos → 2 ** 4 = 16

resultado_potencia = 2 ** 4
print(resultado_potencia)

# 16

Operadores relacionales

Estos operadores relacionales en Python se utilizan para comparar, y devuelven un valor booleano de esta comparación.

  • Operador mayor que >

Devuelve True si el valor de la izquierda es mayor que el de la derecha.

8 > 10
# False

9 > 3
# True
  • Operador menor que <

Devuelve True si el valor de la izquierda es menor que el de la derecha.

8 < 10
# True

9 < 3
# False
  • Operador igual a ==

Devuelve True si los dos valores son iguales.

'hola' == 'hola'
# True

'hola' == 'adios'
# False
  • Operador mayor o igual a >=

Devuelve True si el valor de la izquierda es mayor o igual que el de la derecha.

10 >= 10
# True

10 >= 12
# False
  • Operador menor o igual a <=

Devuelve True si el valor de la izquierda es menor o igual que el de la derecha.

10 <= 10
# True

10 <= 12
# True
  • Operador diferente de !=

Devuelve True si los dos valores son diferentes.

11 != 11
# False

11 != 'hola'
True

Operadores de asignación

Con los operadores de asignación en Python podemos asignar diferentes valores a nuestras variables.

En este ejemplo estamos asignando a variable el valor del string mediante el operador = (igual)

variable = 'valor'
print(variable)

# valor

Podemos realizar operaciones aritméticas y asignar el valor a nuestra variable (el orden de prioridad es el mismo que en las matemáticas, aunque se puede modificar con paréntesis).

variable = 2 + 4 * 5
print(variable)
# 22

variable = (2+4) * 5
print(variable)
# 30

Tabla de operadores de asignación compuestos

OperadorEjemploEquivalencia
+=r += 10r = r + 10
-=r -= 10r = r – 10
*=r *= 10r = r * 10
**=r ** = 10r = r ** 10
/=r /= 10r = r / 10
//=r //= 10r = r // 2
%=r %= 10r = r % 2
&=r &= 10r = r & 10
|=r |= 10r = r | 10
^=r ^= 10x = x ^10
>>=r >>= 2r = r >> 2
<<=r <<= 2r = r << 2

Operadores lógicos

Los operadores lógicos en Python se utilizan para tomar decisiones cuando existen múltiples condiciones.

  • Operador and
  • Operador or
  • Operador not

Existen unas tablas llamadas «de la verdad» que nos pueden hacer ver esto de forma más sencilla:

Tabla de la verdad para el operador and

True and TrueTrue
True and FalseFalse
False and TrueFalse
False and FalseFalse

Tabla de la verdad para el operador or

True or TrueTrue
True or FalseTrue
False or TrueTrue
False or FalseFalse

Tabla de la verdad para el operador not

TrueFalse
FalseTrue

Veamos algunos ejemplos:

True and True
# True

10 > 5 and 3 < 10
# True

10 == 5 and 3 < 10
# False

10 == 9 or 4 < 10
# True

numero = 10
otro_numero = 3
numero is not otro_numero
# True

numero = 10
otro_numero = 10
numero is not otro_numero
# False

numero = 10
otro_numero = 8
10 != 10 or numero is not otro_numero
# True

palabra = 'hola'
otra_palabra = 'hola'
palabra is not otra_palabra
# False

palabra = 'hola'
otra_palabra = 'hola'
palabra is otra_palabra
# True

De esta forma, podemos concatenar todas las condiciones que necesitamos que se cumplan. En función del resultado de las condiciones, recibiremos un valor True o False.

Operadores de pertenencia

Los operadores de pertenencia se utilizan para detectar la existencia de un valor en algunas de las secuencias de Python (una secuencia es un contenedor en el que se almacenan elementos siguiendo un orden).

  • Operador in

El operador in en Python devuelve True si el valor que le hemos indicado se encuentra en el contenedor al que hemos hecho referencia; en caso contrario, devuelve False.

  • Operador not in

El operador not in en Python devuelve True si el valor que le hemos indicado no se encuentra en el contenedor al que hemos hecho referencia; en caso contrario, devuelve False.

Secuencias en Python

Podemos considerar secuencias de Python las listas, tuplas, rangos y cadenas de texto.

Veamos algunos ejemplos:

Secuencia de cadena de caracteres

'a' in 'hola'
# True

'a' in 'Hello'
# False

'a' not in 'Hola'
False

'a' not in 'Hello'
# True

Secuencia en forma de lista

mi_lista = ['camisa', 'zapato', 'gorro']

'lápiz' in mi_lista
# False

'camisa' in mi_lista
# True

'lápiz' not in mi_lista
# True

'camisa' not in mi_lista
# False

Secuencia en forma de tupla

mi_tupla = (1, 2, 3)

1 in mi_tupla
# True

5 in mi_tupla
# False

1 not in mi_tupla
# False

5 not in mi_tupla
# True

Secuencia en forma de rango

Para el rango hay que tener en cuenta que, si no le especificamos los parámetros start y step, únicamente cuenta con stop.

un_rango = range(inicio, stop, paso)

Un rango como este del ejemplo va desde el 0 hasta el 9, lo que quiere decir que si buscamos el valor 10 nos indicará que no está en el rango.

mi_rango = range(10) # rango de 0 a 9

10 in mi_rango
# False

9 in mi_rango
# True

'hola' in mi_rango
# False

15.5 not in mi_rango
# True

5 not in mi_rango
# False

Operadores de identidad

Los operadores de identidad se utilizan para verificar si dos variables hacen referencia al mismo objeto utilizando la misma ubicación en memoria.

  • Operador is
  • Operador is not

Para ver la ubicación en memoria del valor de una variable, podemos utilizar la función id() de Python.

variable = 10
otra_variable = 10

print(id(variable))
# 4372070928

print(id(otra_variable))
# 4372070928

Podemos ver que el valor del identificador es el mismo para las dos variables, con lo cual la ubicación de memoria es la misma.

variable = 10
otra_variable = 10

variable is otra_variable
# True

variable is not otra_variable
# False

Veamos un caso que puede chocarnos un poco:

una_lista = ['a', 'b', 'c']
# valor id: 4375131264
otra_lista = ['a', 'b', 'c']
# valor id: 4375131200

una_lista == otra_lista
# True

una_lista is otra_lista
# False

Operador Walrus o de morsa

El operador Walrus u operador de morsa es un operador de asignación que cuenta con el extra de que permite asignar un valor a la variable mientras se utiliza.

  • Operador Walrus =:

Será mejor que veamos un ejemplo:

Tenemos una lista con números, la vamos a recorrer mediante un for y en la misma condición del if haremos uso del operador Walrus en Python para detectar si es par.

numeros = [10, 11, 12, 13]
for numero in numeros:
    if (resultado := numero % 2) == 0:
        print(f'{numero} es un número par')

# 10 es un número par
# 12 es un número par

Operador nivel de Bit

El operador de Python nivel de Bit es también conocido como Bit a Bit u operador Bitwise. Este operador actúa sobre los operandos o números enteros utilizando su representación binaria.

Debemos saber que la función bin() transforma un número a su representación binaria. Para realizar la representación a decimal entero, se hace con int(valor_binario).

print(bin(100))
# 0b1100100

print(int(0b1100100))
# 100

Del resultado obtenido por consola 0b1100100 tenemos que diferenciar dos partes:

  • 0b → indica que es binario.
  • 1100100 → representa el número 100 en binario.

Operadores Bit a Bit

OperadoresFunción
&and
|or
~not
^xor
>>shift desplaza a la derecha
<<shift desplaza a la izquierda

Operador and &

Ejemplo con el operador and &: comparamos todos los bits uno a uno, y, si están los dos a 1, entonces sería 1; si alguno de los dos valores está a 0, sería 0.

numero = 20
numero_bin = 0b10100

numero_dos = 22
numero_dos_bin = 0b10110

print(bin(numero_bin & numero_dos_bin))
# 0b10100
↓
# 0b10100 → numero     → 20
# 0b10110 → numero_dos → 22
---------
# 0b10100 → resultado

Operador or |

Ejemplo con el operador or |: comparamos todos los bits uno a uno, y, si está alguno de los dos a 1, entonces sería 1; y si no está ninguno, es 0.

numero = 20
numero_bin = 0b10100

numero_dos = 22
numero_dos_bin = 0b10110

print(bin(numero_bin | numero_dos_bin))
# 0b10110
↓
# 0b10100 → numero     → 20
# 0b10110 → numero_dos → 22
---------
# 0b10110 → resultado

Operador not ~

El operador not ~ invierte cada bit en el operando. El bit que tiene como valor 1 lo pone a 0, y al contrario.

numero = 20
numero_bin = 0b10100
print(bin(~numero))

# -0b10101

Operador xor ^

El operador xor ^ devuelve los bits que estén a 1 no comunes en los dos operandos.

numero = 20
numero_bin = 0b10100

numero_dos = 22
numero_dos_bin = 0b10110

print(bin(numero_bin ^ numero_dos_bin))
# 0b10
↓
# 0b10100 → numero     → 20
# 0b10110 → numero_dos → 22
---------
# 0b00010

Operador shift >>

El operador shift >> se utiliza para mover bits hacia la derecha. Hacen falta dos parámetros para indicarle primero qué vamos a desplazar y después el número de posiciones que lo desplazaremos.

numero = 20
numero_bin = 0b10100

print(bin(numero_bin >> 2))
# 0b101
↓
# 0b10100 → numero     → 20
----↓↓--- 
# 0b00101 → numero     → 5

Vamos a moverlo ahora solo un bit para verlo más claro.

numero = 20
numero_bin = 0b10100

print(bin(numero_bin >> 1))
# 0b1010
↓
# 0b10100 → numero     → 20
----↓---- 
# 0b01010 → numero     → 10

Operador shift <<

El operador shift << se utiliza para mover bits hacia la izquierda. Hacen falta dos parámetros para indicarle primero qué vamos a desplazar y después el número de posiciones que lo desplazaremos.

numero = 20
numero_bin = 0b10100

print(bin(numero_bin << 2))
# 0b1010000
↓
# 0b10100   → numero     → 20
---------↓↓ 
# 0b1010000 → numero     → 80

Dejar un comentario

Tu dirección de correo electrónico no será publicada. Los campos obligatorios están marcados con *