Python a través de ejemplos: Operadores

Python tiene varios tipos de operadores que se pueden emplear en diferentes contextos. En este tutorial, aprenderás lo básico sobre cómo funcionan y cómo emplear cada tipo de operador.

Aritméticos

Los operadores aritméticos son probablemente los más conocidos y empleados. Ellos permiten realizar operaciones aritméticas básicas entre valores numéricos:

>>> # Adición
>>> 10 + 5
15

>>> # Sustracción
>>> 10 - 5
5

>>> # Multiplicación
>>> 10 * 5
50

>>> # División
>>> 10 / 3
3.3333333333333335

>>> # Módulo
>>> 10 % 3
1

>>> # Exponenciación
>>> 2**3
8

>>> # División entera
>>> 10 // 3
3
>>> -10 // 3  # No -3, porque -4 es el mayor entero <= -3.333
-4

Los operadores de adición, sustracción, multiplicación y división son casi idénticos a los que empleas en matemáticas.

El operador de módulo (%) devuelve el resto de la división entera. El operador de exponenciación o exponenciación te permite elevar números a una determinada potencia. Finalmente, el operador de división entera realiza una división que devuelve el mayor entero menor o igual al resultado de la división normal. Esto se conoce como división de piso.

Asignación

Los operadores de asignación se emplean para asignar valores u objetos a variables o nombres:

>>> # Asignación
>>> number = 5
>>> number
5

>>> # Suma aumentada
>>> number += 5  # Equivale a number = number + 5
>>> number
10

>>> # Resta aumentada
>>> number -= 5  # Equivale a number = number - 5
>>> number
5

>>> # Multiplicación aumentada
>>> number *= 3  # Equivale a number = number * 3
>>> number
15

>>> # División aumentada
>>> number /= 3  # Equivale a number = number / 3
>>> number
5.0

>>> # Módulo aumentado
>>> number %= 3  # Equivale a number = number % 3
>>> number
2.0

>>> # Potencia aumentada
>>> number **= 3  # Equivale a number = number ** 3
>>> number
8.0

>>> # División entera aumentada
>>> number //= 3  # Equivale a number = number // 3
>>> number
2.0

En la práctica, Python tiene un operador de asignación (=) y varios operadores de asignación aumentada. Los operadores de asignación aumentada son atajos que permiten actualizar el valor de una variable de forma rápida y concisa.

Concatenación

Los operadores de concatenación te permiten unir cadenas de caracteres, listas y otros tipos de datos:

>>> # Concatenación de cadenas
>>> "Hola, " + "mundo!"
'Hola, mundo!'
>>> "Python " + "es " + "genial"
'Python es genial'

>>> # Concatenación aumentada en cadenas
>>> greeting = "Hola"
>>> greeting += ", mundo!"
>>> greeting
'Hola, mundo!'
>>> message = "Python"
>>> message += " es genial"
>>> message
'Python es genial'

>>> # Concatenación de listas
>>> [1, 2, 3] + [4, 5, 6]
[1, 2, 3, 4, 5, 6]
>>> ["a", "b"] + ["c", "d"]
['a', 'b', 'c', 'd']

>>> # Concatenación aumentada en listas
>>> numbers = [1, 2, 3]
>>> numbers += [4, 5, 6]
>>> numbers
[1, 2, 3, 4, 5, 6]
>>> letters = ["a", "b"]
>>> letters += ["c", "d"]
>>> letters
['a', 'b', 'c', 'd']

Nuevamente, Python tiene un operador de concatenación (+) y varios operadores de concatenación aumentada.

Repetición

Puedes usar los operadores de repetición para repetir un valor un número determinado de veces:

>>> # Repetición de cadenas
>>> "Hola " * 3
'Hola Hola Hola '

>>> 2 * "Python! "
'Python! Python! '

>>> # Repetición de listas
>>> [1, 2, 3] * 2
[1, 2, 3, 1, 2, 3]

>>> 3 * ["a", "b"]
['a', 'b', 'a', 'b', 'a', 'b']

El operador de repetición comúnmente se emplea con cadenas de caracteres cuando queremos repetir una determinada cadena. Nota que este operador requiere de un operando entero que representa el número de repeticiones y que puede estar a la derecha o izquierda del operador.

Comparación

Cuando necesitas comparar valores u objetos, puedes utilizar los operadores de comparación:

>>> # Igual a
>>> 5 == 5
True
>>> 5 == 10
False

>>> # Mayor que
>>> 10 > 5
True
>>> 5 > 10
False

>>> # Menor que
>>> 5 < 10
True
>>> 10 < 5
False

>>> # Mayor o igual que
>>> 10 >= 5
True
>>> 5 >= 5
True
>>> 5 >= 10
False

>>> # Menor o igual que
>>> 5 <= 10
True
>>> 5 <= 5
True
>>> 10 <= 5
False

>>> # Diferente de
>>> 10 != 5
True
>>> 5 != 5
False

Estos operadores son casi idénticos a los que usamos en las matemáticas. El operador de igualdad que se representa con dos símbolos de igualdad (==) para diferenciarlo del operador de asignación. El operador de desigualdad se representa como !=.

Lógicos

Los operadores lógicos o booleanos permiten crear expresiones lógicas que generalmente se utilizan en condiciones. Python tiene tres operadores booleanos: and, or, y not. Los siguientes ejemplos muestran el funcionamiento de cada operador:

>>> # Operador and (y)
>>> True and True
True
>>> True and False
False
>>> False and True
False
>>> False and False
False

>>> # Operador or (o)
>>> True or False
True
>>> False or True
True
>>> False or False
False
>>> True or True
True

>>> # Operador not (no)
>>> not True
False
>>> not False
True

Estos ejemplos expresan lo que se conoce como tabla de verdad de los operadores lógicos. Esta tabla resume los valores de verdad que retornan los operadores en función del valor de verdad de los operandos.

Los operadores lógicos en Python también funcionan con objetos distintos de True and False. Todos los objetos tienen un valor de verdad en Python. Las reglas para determinar estos valores de verdad son las siguientes:

Por defecto, un objeto se considera verdadero a menos que su clase defina un método .__bool__() que devuelva False o un método .__len__() que devuelva cero cuando se llama con el objeto. A continuación, se muestran la mayoría de los objetos incorporados considerados como falsos:

• Constantes definidas como falsas: None y False
• Cero en cualquiera de los diferentes tipos numéricos: 0, 0.0, 0j, Decimal(0), Fraction(0, 1)
• Cualquier colección o secuencia vacía: '', (), [], {}, set(), range(0) (Fuente)

Cuando empleas los operadores and y or con objetos distintos de True o False, obtienes uno de los objetos como resultado en lugar de un valor booleano.

>>> "Hola" and [1, 2, 3]
[1, 2, 3]
>>> "" and [1, 2, 3]
''

>>> "" or [1, 2, 3]
[1, 2, 3]
>>> "Hola" or [1, 2, 3]
'Hola'

El operador and retorna el operando derecho si el izquierdo es verdadero. Si el operando izquierdo es falso, entonces and lo retorna inmediatamente sin evaluar el operando derecho. Esto se denomina evaluación de cortocircuito.

En contraste, or retorna el operando derecho si el izquierdo es falso. Si el operando izquierdo es verdadero, entonces or lo retorna inmediatamente.

Pertenencia

Los operadores de pertenencia se emplean cuando necesitas determinar si un valor u objeto determinado forma parte de una serie de valores o colección. Python tiene dos operadores de pertenencia: in y not in.

El operador in devuelve True si el objeto está presente en la colección de valores, de lo contrario devuelve False:

>>> # Verificar si un elemento está en una lista
>>> fruits = ["manzana", "banana", "cereza"]
>>> "banana" in fruits
True
>>> "naranja" in fruits
False

>>> # Verificar si una subcadena está en una cadena
>>> texto = "Hola, mundo!"
>>> "Hola" in texto
True
>>> "adiós" in texto
False

>>> # Verificar si un elemento está en un conjunto
>>> numbers = {1, 2, 3, 4, 5}
>>> 3 in numbers
True
>>> 6 in numbers
False

>>> # Verificar si una clave está en un diccionario
>>> person = {"name": "Juan", "age": 30}
>>> "name" in person
True
>>> "address" in person
False

Por otro lado, el operador not in permite determinar si un valor no pertenece a una serie de valores. Este operador devuelve True cuando el valor no es parte de la colección de valores:

>>> # Verificar si un elemento NO está en una lista
>>> fruits = ["manzana", "banana", "cereza"]
>>> "naranja" not in fruits
True
>>> "banana" not in fruits
False

>>> # Verificar si una subcadena NO está en una cadena
>>> texto = "Hola, mundo!"
>>> "adiós" not in texto
True
>>> "Hola" not in texto
False

>>> # Verificar si un elemento NO está en un conjunto
>>> numbers = {1, 2, 3, 4, 5}
>>> 6 not in numbers
True
>>> 3 not in numbers
False

>>> # Verificar si una clave NO está en un diccionario
>>> person = {"name": "Juan", "age": 30}
>>> "address" not in person
True
>>> "name" not in person
False

Los operadores de pertenencia funcionan con diferentes colecciones de datos como listas, duplas, conjuntos y diccionarios. Sin embargo, cuando necesitas realizar pruebas de pertenencia repetidamente, la opción más eficiente es emplear conjuntos.

Identidad

En Python, cada objeto que se crea tiene una identidad única. En CPython, esta identidad es un número entero que se corresponde con la dirección de memoria donde el objeto está almacenado.

Python tiene dos operadores que permiten verificar si dos objetos tienen la misma identidad o no. Estos operadores son is e is not y se conocen como operadores de identidad.

El operador is devuelve True si dos variables hacen referencia al mismo objeto, es decir, si apuntan a la misma ubicación en memoria:

>>> a = [1, 2, 3]
>>> b = a
>>> c = [1, 2, 3]

>>> a is b  # True, b se refiere a la misma lista que a
True
>>> a is c  # False, c es una lista independiente con el mismo contenido
False

El operador is not devuelve True si dos variables no hacen referencia al mismo objeto en memoria:

>>> a is not b
False
>>> a is not c
True

Python realiza el caché de valores enteros en el rango de -5 a 256. Esto significa que cualquier número en este rango siempre apunta al mismo objeto en memoria:

>>> x = 100
>>> y = 100
>>> x is y  # True, por estar en el rango de valores en caché
True

>>> n = 400
>>> m = 400
>>> n is m  # False, por NO estar en el rango de valores en caché
False

Esta comportamiento de Python es una optimización de uso de memoria y se basa en el hecho de que posiblemente los enteros más comúnmente empleados están en ese rango de valores.

Bitwise

Los operadores de bits permiten manipular los bits de los números enteros directamente. Python cuenta con seis operadores de bit o bitwise. A continuación, algunos ejemplos que muestran cómo funcionan estos operadores:

>>> # AND bit a bit
>>> 5 & 3  # (En binario: 5 = 101 y 3 = 011, 101 & 011 = 001)
1
>>> 6 & 2  # (En binario: 6 = 110 y 2 = 010, 110 & 010 = 010)
2

>>> # OR bit a bit
>>> 5 | 3  # (En binario: 5 = 101 y 3 = 011, 101 | 011 = 111)
7
>>> 6 | 2  # (En binario: 6 = 110 y 2 = 010, 110 | 010 = 110)
6

>>> # XOR bit a bit
>>> 5 ^ 3  # (En binario: 5 = 101 y 3 = 011, 101 ^ 011 = 110)
6
>>> 6 ^ 2  # (En binario: 6 = 110 y 2 = 010, 110 ^ 010 = 100)
4

>>> # NOT bit a bit
>>> ~5  # (En binario: 5 = 0000 0101, ~5 = 1111 1010 que es -6 en complemento a dos)
-6
>>> ~1  # (En binario: 1 = 0000 0001, ~1 = 1111 1110 que es -2 en complemento a dos)
-2

>>> # Desplazamiento a la izquierda
>>> 5 << 1  # (En binario: 5 = 0000 0101, 5 << 1 = 0000 1010 que es 10)
10
>>> 3 << 2  # (En binario: 3 = 0000 0011, 3 << 2 = 0000 1100 que es 12)
12

>>> # Desplazamiento a la derecha
>>> 5 >> 1  # (En binario: 5 = 0000 0101, 5 >> 1 = 0000 0010 que es 2)
2
>>> 12 >> 2  # (En binario: 12 = 0000 1100, 12 >> 2 = 0000 0011 que es 3)
3

Los operadores a nivel de bits no son tan comunes en el desarrollo de aplicaciones de alto nivel. Sin embargo, son muy útiles en aplicaciones que requieren manipulación de datos a nivel de bits, incluidas la programación de sistemas, el procesamiento de señales, la criptografía, las redes, y los gráficos.

Conclusiones

Has aprendido sobre los distintos tipos de operadores en Python, incluyendo aritméticos, de asignación, concatenación, repetición, comparación, lógicos, pertenencia, identidad y bitwise.

El conocimiento de los operadores es esencial para cualquier desarrollador de Python, pues con ellos puedes manipular y evaluar datos, controlar el flujo de ejecución, y realizar otras tareas de programación.

Ahora puedes aplicar tus conocimientos para resolver problemas complejos, optimizar tus programas y desarrollar aplicaciones más robustas y eficientes.