Operadores en Python

Este artículo explica los operadores en Python.

YouTube Video

Operadores en Python

Python tiene varios operadores, que se pueden clasificar de la siguiente manera. Explicaremos los operadores representativos de cada categoría.

Operadores aritméticos

Los operadores aritméticos son operadores que se utilizan para realizar cálculos con números.

 1a = 10
 2b = 3
 3
 4print(f"{a} + {b} = {a + b}")     # Addition
 5print(f"{a} - {b} = {a - b}")     # Subtraction
 6print(f"{a} * {b} = {a * b}")     # Multiplication
 7print(f"{a} / {b} = {a / b}")     # Division (float)
 8print(f"6 / 3 = {6 / 3}")         # Division (float)
 9print(f"{a} // {b} = {a // b}")   # Floor Division
10print(f"{a} % {b} = {a % b}")     # Modulo (remainder)
11print(f"{a} ** {b} = {a ** b}")   # Exponentiation

• Además de las cuatro operaciones aritméticas básicas, Python proporciona operadores para división (/), división entera (//), módulo (%) y potenciación (**). La división devuelve un número de punto flotante incluso cuando se dividen enteros.

Operadores de asignación

Los operadores de asignación se utilizan para asignar valores a las variables.

 1x = 5           # x = 5
 2
 3x += 3          # x = x + 3
 4x -= 2          # x = x - 2
 5x *= 4          # x = x * 4
 6x /= 3          # x = x / 3
 7x //= 2         # x = x // 2
 8x %= 5          # x = x % 5
 9x **= 3         # x = x ** 3
10
11x = 0b1100      # x = 0b1100 (12)
12
13x &= 0b1010     # x = x & 0b1010
14x |= 0b0011     # x = x | 0b0011
15x ^= 0b0101     # x = x ^ 0b0101
16x <<= 2         # x = x << 2
17x >>= 1         # x = x >> 1
18
19print(bin(x))   # Display in binary
20print(x)        # Display in decimal
21
22# Walrus operator
23if (n := len("hello")) > 3:
24    print(f"Length is {n}")

• Los operadores de asignación permiten combinar la asignación estándar con varios operadores para asignar el resultado.
• El operador morsa (:=) es una expresión de asignación disponible en Python 3.8 y versiones posteriores.
• Mientras que la asignación estándar solo puede usarse como una declaración, el operador morsa permite la asignación dentro de una expresión.

Operadores de comparación

Los operadores de comparación comparan valores y devuelven True o False.

 1a = 10
 2b = 20
 3
 4# Equal to (==)
 5print(f"{a} == {b} -> {a == b}")      # False: a and b are not equal
 6print(f"3 == 3.0 -> {3 == 3.0}")      # True: int and float with the same value are equal
 7print(f"3 == '3' -> {3 == '3'}")      # False: different types (int vs str)
 8print(f"True == 1 -> {True == 1}")    # True: True is equivalent to 1
 9print(f"False == 0 -> {False == 0}")  # True: False is equivalent to 0
10print(f"None == 0 -> {None == 0}")    # False: None is not equal to 0
11
12# Not equal to (!=)
13print(f"{a} != {b} -> {a != b}")      # True: a and b are not equal
14
15# Greater than (>)
16print(f"{b} > {a} -> {b > a}")        # True: 20 > 10
17
18# Less than (<)
19print(f"{a} < {b} -> {a < b}")        # True: 10 < 20
20
21# Greater than or equal to (>=)
22print(f"{a} >= 10 -> {a >= 10}")      # True: a is greater than or equal to 10
23
24# Less than or equal to (<=)
25print(f"{a} <= 10 -> {a <= 10}")      # True: a is less than or equal to 10

• Los operadores de comparación comparan dos valores para su orden o igualdad y devuelven True o False como resultado.
• En Python, se debe tener cuidado al comparar diferentes tipos de datos. Algunos tipos se pueden comparar entre sí, pero los resultados pueden no ser intuitivos.

Operadores lógicos

Los operadores lógicos se utilizan para combinar expresiones lógicas.

1x = 10
2print(x > 5 and x < 20)  # True
3print(x < 5 or x > 20)   # False
4print(not x == 10)       # False

• and es un operador lógico que devuelve True solo si ambas condiciones a la izquierda y derecha son True.
• or es un operador lógico que devuelve True si cualquiera de las condiciones a la izquierda o a la derecha es True.
• not es un operador lógico que invierte el valor de verdad de una condición. Si es True, se convierte en False, y si es False, se convierte en True.

Precedencia de los operadores lógicos

Los operadores tienen precedencia. Esta es la regla que determina qué operador se evalúa primero en una expresión. Los operadores lógicos se evalúan en el orden: not, luego and y después or.

1result = True or False and False
2print(result)  # True
3
4result = (True or False) and False
5print(result)  # False

たとえば、

En el primer ejemplo, and se evalúa primero, así que False and False se convierte en False, y como resultado, True or False se convierte en True. También puedes cambiar el orden de evaluación usando paréntesis, como se muestra en el segundo ejemplo.

Operadores a nivel de bits

Los operadores a nivel de bits realizan operaciones a nivel de bit.

 1# Sample code for bitwise operators
 2
 3# Define two integers
 4a = 5  # Binary: 0101
 5b = 3  # Binary: 0011
 6
 7# Bitwise AND
 8result_and = a & b  # Binary: 0001 -> Decimal: 1
 9print(f"{a} & {b} = {result_and}")
10
11# Bitwise OR
12result_or = a | b  # Binary: 0111 -> Decimal: 7
13print(f"{a} | {b} = {result_or}")
14
15# Bitwise XOR
16result_xor = a ^ b  # Binary: 0110 -> Decimal: 6
17print(f"{a} ^ {b} = {result_xor}")
18
19# Bitwise NOT (inverting bits)
20result_not = ~a  # Binary: -(0101 + 1) -> Decimal: -6
21print(f"~{a} = {result_not}")
22
23# Left shift
24shift_left = a << 1  # Binary: 1010 -> Decimal: 10
25print(f"{a} << 1 = {shift_left}")
26
27# Right shift
28shift_right = a >> 1  # Binary: 0010 -> Decimal: 2
29print(f"{a} >> 1 = {shift_right}")

• Se pueden realizar operaciones a nivel de bits AND, OR, XOR, NOT, así como operaciones de desplazamiento de bits. También se pueden combinar con operadores de asignación como &=.

Operadores de membresía

Los operadores de pertenencia se utilizan con colecciones como listas y diccionarios.

 1x = [1, 2, 3]
 2y = 2
 3z = 4
 4
 5print("y in x : ", y in x)  # Result is True
 6print("z in x : ", z in x)  # Result is False
 7
 8print("y not in x : ", y not in x)  # Result is False
 9print("z not in x : ", z not in x)  # Result is True
10
11text = "hello world"
12print("'world' in 'hello world' : ",      "world" in text)      # True
13print("'python' not in 'hello world' : ", "python" not in text) # True

• El operador in se utiliza para determinar si un valor especificado está contenido en una secuencia como una lista o una cadena, o en una colección como un diccionario.
• El operador not in se utiliza para determinar si un valor especificado no está contenido en una secuencia o colección.

Operadores de identidad

Los operadores de identidad verifican la identidad de los objetos.

 1x = [1, 2, 3]
 2y = x
 3z = x.copy()
 4
 5print("x is y : ", x is y)  # Result is True
 6print("x is z : ", x is z)  # Result is False
 7
 8print("x is not y : ", x is not y)  # Result is False
 9print("x is not z : ", x is not z)  # Result is True
10
11print("x == y : ", x == y)  # Result is True
12print("x == z : ", x == z)  # Result is True

• El operador is comprueba si dos objetos son el mismo objeto (es decir, si hacen referencia a la misma ubicación de memoria).
• El operador is not comprueba si dos objetos son objetos diferentes.
• Por ejemplo, x is y difiere de x == y en que verifica la identidad del objeto, no la igualdad de valor.

Comprobación de tipo

En Python, usas la función isinstance() para comprobar si un valor es de un tipo específico. También puedes usar la función type() para comprobar el tipo exacto de una variable. Aunque estos no son operadores, son mecanismos básicos para la comprobación de tipos.

 1x = 10
 2print(isinstance(x, int))  # True
 3
 4y = "hello"
 5print(isinstance(y, str))  # True
 6
 7z = [1, 2, 3]
 8print(isinstance(z, list))  # True
 9
10print(type(10))        # <class 'int'>
11print(type("hello"))   # <class 'str'>
12
13print("isinstance(3, int) : ", isinstance(3, int))  # True
14print("type(3) is int : ", type(3) is int)          # True
15print("type(True) is bool : ", type(True) is bool)  # True

• isinstance() es una función que comprueba si un objeto es una instancia de una clase especificada o de su subclase.
• type() es una función que devuelve el tipo exacto (clase) de un objeto. Normalmente se utiliza cuando deseas realizar una comparación estricta de tipos.
• isinstance() considera las relaciones de herencia, mientras que type() comprueba coincidencias exactas.

Resumen

Al usar cada operador, debes elegir adecuadamente según su propósito y tipo. Dado que Python es un lenguaje de tipado dinámico, el resultado de una operación puede variar según el tipo de valores que se calculen.

Puedes seguir el artículo anterior utilizando Visual Studio Code en nuestro canal de YouTube. Por favor, también revisa nuestro canal de YouTube.

YouTube Video