Los ope­ra­do­res Python te ayudan a trabajar con valores (operandos), a mo­di­fi­car­los o a vi­n­cu­lar­los entre sí. Los ope­ra­do­res pueden ser por ejemplo lógicos o ari­t­mé­ti­cos.

¿Qué son los ope­ra­do­res de Python y cómo funcionan?

Un operador es un carácter para una operación. Suelen uti­li­zar­se sobre todo para vincular múltiples operandos, y no­r­ma­l­me­n­te como resultado se crea un valor nuevo. Aplicar un operador a un único operando lo modifica.

Pro­ba­ble­me­n­te, el ejemplo más claro de operador Python es unir dos cifras con el operador de la suma, es decir, poniendo un más entre las cifras. Python evalúa la expresión y devuelve el valor co­rre­s­po­n­die­n­te:

1 + 1

Una ca­ra­c­te­rí­s­ti­ca de Python es que, además de símbolos, también utiliza palabras cortas como ope­ra­do­res, por ejemplo, “and”, “or”, “is”, “not” e “in”. La co­m­bi­na­ción de ope­ra­do­res y operandos da como resultado una expresión:

1 + 1 == 2

¿Qué tipos de ope­ra­do­res Python hay?

Python cuenta con distintas clases de ope­ra­do­res que funcionan con distintos tipos de operandos y devuelven re­su­l­ta­dos de un tipo de­te­r­mi­na­do. He aquí un esquema de los distintos tipos de ope­ra­do­res de Python:

Clases de ope­ra­do­res de Python Ex­pli­ca­ción Operandos Resultado Resumen de ope­ra­do­res
Ope­ra­do­res ari­t­mé­ti­cos Unen dos cifras y crean una nueva Cifras Cifra +, -, *, /, //, %, **, @
Ope­ra­do­res de co­m­pa­ra­ción Comparan dos ex­pre­sio­nes entre sí Ex­pre­sio­nes Booleano <, >, ==, !=, <=, >=
Ope­ra­do­res lógicos Vinculan ex­pre­sio­nes en contexto booleano Ex­pre­sio­nes Última expresión evaluada/booleano and, or, not
Ope­ra­do­res bit a bit Manipulan números enteros como se­cue­n­cias binarias Cifras Cifra <<, >>, &, |, ^, ~
Ope­ra­do­res de asi­g­na­ción Asignan un nombre a un valor Lvalue, Rvalue – / expresión evaluada =, :=, +=, -=, *=, etc.
Ope­ra­do­res de identidad De­te­r­mi­nan si dos nombres se refieren al mismo objeto Objetos Booleano is, is not
Ope­ra­do­res co­n­di­cio­na­les Devuelve uno de dos valores en función de una condición Expresión, condición, al­te­r­na­ti­va Expresión/al­te­r­na­ti­va ... if ... else ...
Ope­ra­do­res de conjuntos Unen dos conjuntos/enlazan conjuntos Conjuntos Conjunto/booleano &, |, ^, -, <, >, <=, >=
Ope­ra­do­res de membresía Prueban si un iterable contiene un objeto de­te­r­mi­na­do Objeto, iterable booleano in, not in
Operador de co­n­ca­te­na­ción Concatena se­cue­n­cias Strings / listas / registro String / lista / registro +
Ope­ra­do­res índex y slicing Entre uno o más elementos iterables Iterable, índex / Slice String / Lista / registro [], [::]

Además del tipo de operando y el valor que devuelve, los ope­ra­do­res se cla­si­fi­can según su “aridad”. La aridad de un operador no tiene nada que ver con su color. Este concepto indica el número de operandos que une un operador. En la mayoría de los casos, se utilizan ope­ra­do­res “binarios” que conectan dos operandos, pero también hay ope­ra­do­res “unarios” que solo tienen un operando, u ope­ra­do­res “ternarios”, que vinculan tres operandos:

Aridad del operador Cantidad de ope­ra­do­res Ejemplo
Unario Un operando not single_value
Binario Dos operandos left_operand + right_operand
Ternario Tres operandos some_value if condition else other_value

Co­n­si­de­rar la pre­ce­n­de­n­cia de los ope­ra­do­res

Para utilizar los ope­ra­do­res Python hay que entender su pre­ce­de­n­cia. El concepto sigue el “orden de los ope­ra­do­res” de la ari­t­mé­ti­ca. A modo de re­co­r­da­to­rio: la expresión 3 * 8 + 2 se in­te­r­pre­ta como (3 * 8) + 2 y no como 3 * (8 + 2). Al igual que en sumas y en mu­l­ti­pli­ca­cio­nes, el resto de Python operators también se rigen por normas de pre­ce­de­n­cia. He aquí un ejemplo de una expresión con los ope­ra­do­res lógicos “and”, “or” y “not”:

if is_user and is_user_logged_in or is_admin and not login_blocked:
    ...

Si no sabes cuáles son las normas de pre­ce­n­de­n­cia de los ope­ra­do­res Python im­pli­ca­dos, no puedes decidir cómo se re­la­cio­nan los términos entre sí. Y si además hay varios ope­ra­do­res en una expresión, la cosa se complica rá­pi­da­me­n­te. En general, es mejor no confiar en que se vayan a entender las reglas im­plí­ci­tas e in­tro­du­cir pa­ré­n­te­sis ex­plí­ci­ta­me­n­te para aclarar las re­la­cio­nes entre los términos de una expresión:

if (is_user and is_user_logged_in) or (is_admin and not login_blocked):
    ...

Como co­m­pa­ra­ti­va, te mostramos los mismos términos agrupados de forma distinta con otro enunciado de ambas ex­pre­sio­nes:

if (is_user and is_user_logged_in or is_admin) and not login_blocked:
    ...

Ope­ra­do­res so­bre­ca­r­ga­dos, métodos dunder y funciones del Python Operator

Hay ope­ra­do­res Python que pueden usarse en más de una operación. Un buen ejemplo de ello es el símbolo más, que sirve de operador para sumar cifras y también para co­n­ca­te­nar se­cue­n­cias como strings o listas. Aquí sumamos dos cifras con el operador de sumas:

8 + 3 == 11

Con el mismo operador, co­n­ca­te­na­mos dos strings:

"Walter" + "White" == "WalterWhite"

También permite co­n­ca­te­nar listas:

['Jack', 'Jim'] + ['John'] == ['Jack', 'Jim', 'John']

Los distintos usos del signo más como operador reflejan un concepto común en in­fo­r­má­ti­ca. Un “operador so­bre­ca­r­ga­do” realiza di­fe­re­n­tes ope­ra­cio­nes en función del tipo de datos de los operandos.

¿Cómo funcionan los ope­ra­do­res so­bre­ca­r­ga­dos en Python? En general, un operador que incluye operandos se in­te­r­pre­ta como una llamada a la función co­rre­s­po­n­die­n­te. Más co­n­cre­ta­me­n­te, la llamada se hace al método dunder del primer operando, que recibe el otro u otros operandos como ar­gu­me­n­tos. “Dunder” viene de “double un­de­r­s­co­re”, es decir, “doble guion bajo”. El operador “más” co­rre­s­po­n­de al método dunder de esta manera __add__(). Los objetos que im­ple­me­n­ten métodos __add__(), pueden vi­n­cu­lar­se con el operador “más”. Lo que co­n­s­ti­tu­ya el vínculo dependerá del propio objeto.

Además del método dunder, el módulo operator contiene funciones que en­ca­p­su­lan las funciones de los ope­ra­do­res Python. De esta manera, el “operator.add(a, b)“ llama al método dunder a.__add__(b), que co­rre­s­po­n­de a la expresión a + b. En este artículo te iremos ex­pli­ca­n­do la función existente para cada operador. La función del operador lleva el mismo nombre que su método dunder, así que puedes uti­li­zar­los como re­fe­re­n­cia para im­ple­me­n­tar tus propias funciones de ope­ra­do­res:

Operador Función Método dunder
a + b operator.add(a, b) a.__add__(b)

Los ope­ra­do­res usan la llamada notación de infijo, que introduce los ope­ra­do­res entre los operandos. En cambio, en el estilo funcional, se utiliza la notación de prefijo. Ambas grafías son adecuadas:

Notación Uso Ejemplo
Infijo Ope­ra­do­res a + b
Prefijo Funciones + a b / add(a, b)

Veamos un ejemplo. Definimos dos cifras y las sumamos con el operador, la función y el método dunder co­rre­s­po­n­die­n­te:

import operator
a = 42
b = 69
assert a + b == operator.add(a, b) == a.__add__(b)

Con las funciones del Operator también pueden es­cri­bi­r­se ex­pre­sio­nes más complejas. He aquí una co­m­bi­na­ción de operador de suma y de igual en notación de prefijo:

import operator
assert 'Py' + 'thon' == 'Python'
assert operator.eq(operator.add('Py', 'thon'), 'Python')

Esquema de los ope­ra­do­res de Python

Ade­n­tré­mo­nos en las once clases de ope­ra­do­res Python.

Ope­ra­do­res ari­t­mé­ti­cos

Los ope­ra­do­res ari­t­mé­ti­cos de Python hacen ope­ra­cio­nes de números y obtienen como resultado otro número. A excepción del más o del menos unario, se trata de ope­ra­do­res binarios. He aquí un esquema:

Operador Si­g­ni­fi­ca­do Función Ejemplo
+ Suma / más unario add(a, b) / pos(a) 5 + 3 == 8 / +8 == 4 + 4
- Resta / menos unario sub(a, b) / neg(a) 7 - 2 == 5 / -4 == 2 - 6
* Mu­l­ti­pli­ca­ción mul(a, b) 2 * 3 == 6
/ División real truediv(a, b) 8 / 2 == 4.0, 7 / 2 == 3.5
// División de números enteros hasta el siguiente entero más pequeño floordiv(a, b) 8 // 2 == 4, 7 // 2 == 3
% Módulo: cantidad restante de la división de enteros mod(a, b) 8 % 2 == 0, 7 % 2 == 1
** Po­te­n­cia­ción pow(a, b) 2 ** 3 == 8, 10 ** -1 == 0.1
@ Mu­l­ti­pli­ca­ción de matrices matmul(a, b) –

La operación de módulos suele uti­li­zar­se para averiguar si un número es par. Si se divide un número par por dos, el resto es cero. Definimos una función con el operador de módulos:

def is_even(number):
    return number % 2 == 0
# test
assert is_even(8) and not is_even(7)

La mu­l­ti­pli­ca­ción de matrices requiere usar un paquete como NumPy.

Ope­ra­do­res de co­m­pa­ra­ción

Los ope­ra­do­res de co­m­pa­ra­ción de Python declaran el orden que hay entre dos elementos. Pro­po­r­cio­nan un resultado booleano y se utilizan es­pe­cia­l­me­n­te para los al­go­ri­t­mos de or­de­na­ción:

Operador Si­g­ni­fi­ca­do Función Ejemplo
< Menor que lt(a, b) 3 < 1, 'a' < 'z'
> Mayor que gt(a, b) 4 > 2, 'z' > 'a'
== Igual eq(a, b) 'a' == 'a'
!= Desigual ne(a, b) 1 != 2, 'Jim' != 'Jack'
<= Menor igual le(a, b) 9 <= 10, 10 <= 10
>= Mayor igual ge(a, b) 11 >= 10, 10 >= 10

Ope­ra­do­res lógicos

Los ope­ra­do­res lógicos de Python “and” y “or” conectan varios operandos siguiendo la lógica booleana. Ambos ope­ra­do­res dan como resultado el último objeto evaluado. El operador lógico de Python “not” in­te­r­pre­ta un objeto en el contexto booleano y niega su valor verdadero:

Operador Si­g­ni­fi­ca­do Función Ejemplo
and Y lógico Sin co­rre­s­po­n­de­n­cia directa True and False == False, 'name' and ... == ...
or O lógico Sin co­rre­s­po­n­de­n­cia directa False or True == True, a = '' or 'Default'; assert a == 'Default'
not Negación not_(a) not True == False

Es útil vi­sua­li­zar el efecto de las ope­ra­cio­nes lógicas en una tabla de la verdad. Este es el Y lógico:

and True False
True True False
False False False

Este es el O lógico:

or True False
True True True
False True False

Los operandos de los ope­ra­do­res booleanos de Python no se limitan a variables booleanas. De hecho, todos los objetos de Python pueden in­te­r­pre­tar­se en contexto booleano. Los si­guie­n­tes objetos se evalúan como False en contexto booleano, por lo que se describen como “falsy”:

Objeto Ex­pli­ca­ción
False, None Co­n­s­ta­n­tes falsas por de­fi­ni­ción
0, 0.0, Decimal(0), Fraction(0, 1), etc. Cifras que re­pre­se­n­tan cero
'', (), [], {}, set(), range(0), etc. Co­le­c­cio­nes o se­cue­n­cias vacías

Ope­ra­do­res bit a bit

Los ope­ra­do­res bit a bit de Python operan con números enteros in­te­r­pre­ta­dos como se­cue­n­cias de bit. A excepción del operador bit a bit not, son pri­n­ci­pa­l­me­n­te binarios:

Ope­ra­do­res Si­g­ni­fi­ca­do Función Ejemplo
<< Desplaza la secuencia de bits a la izquierda lshift(a, b) 5 << 3 == 5 * 2 ** 3
>> Desplaza la secuencia de bits a la derecha rshift(a, b) 1 >> 1 == 0, 8 >> 1 == 4
& Vincula dos se­cue­n­cias de bits con and and_(a, b) ``
| Conecta dos se­cue­n­cias de bits con or or_(a, b) ``
^ Vincula dos se­cue­n­cias de bits con xor xor(a, b) ``
~ Invierte la secuencia de bits con not invert(a) ``

Los ope­ra­do­res bit a bit son aptos para ope­ra­cio­nes ma­te­má­ti­cas op­ti­mi­za­das. Por ejemplo, el de­s­pla­za­mie­n­to a la izquierda co­rre­s­po­n­de a una mu­l­ti­pli­ca­ción con potencia de dos:

Expresión 23 = 8 22 = 4 21 = 2 20 = 1 Decimal
b = 6 0 1 1 0 6
b << 1 1 1 0 0 12
b >> 1 0 0 1 1 3

Para mostrar un ejemplo de ope­ra­cio­nes bit a bit de and, or y not, creamos una tabla con los bits in­di­vi­dua­les. Las ope­ra­cio­nes se aplican a un número con re­pre­se­n­ta­ción binaria en una máscara de bits:

Expresión 23 = 8 22 = 4 21 = 2 20 = 1 Decimal
bits = 6 0 1 1 0 6
mask = 5 0 1 0 1 5
bits & mask 0 1 0 0 4
bits | mask 0 1 1 1 7
bits ^ mask 0 0 1 1 3

El operador bit a bit not invierte una secuencia de bits. Ahí, cada 1 se convierte en 0 y viceversa. Además, el signo de la cifra también se invierte:

Expresión 23 = 8 22 = 4 21 = 2 20 = 1 Decimal
b = 6 0 1 1 0 6
~ b 1 0 0 1 -7

Ope­ra­do­res de asi­g­na­ción

Las asi­g­na­cio­nes son unas de las in­s­tru­c­cio­nes básicas presentes en la mayoría de los lenguajes de pro­gra­ma­ción. Los ope­ra­do­res de asi­g­na­ción de Python vinculan un valor a un nombre de variable. Además de la orden de asi­g­na­ción, existe un nuevo operador “morsa”, que permite asignar dentro de una expresión. También hay una serie de órdenes de asi­g­na­ción ampliadas que combinan una asi­g­na­ción con otra operación:

Operador Si­g­ni­fi­ca­do Función Ejemplo
= Orden de asi­g­na­ción Sin co­rre­s­po­n­de­n­cia directa name = 'Walther'
:= Expresión de asi­g­na­ción (operador morsa) Sin co­rre­s­po­n­de­n­cia directa [ half for x in range(10) if (half := x / 2) < 5 ]
+= Asi­g­na­ción de suma ampliada iadd(a, b) x = 1; x += 4; assert x == 5

Python reconoce ope­ra­do­res de asi­g­na­ción ampliada para las ope­ra­cio­nes ari­t­mé­ti­cas y bit a bit. Te mostramos el patrón general de la asi­g­na­ción de co­n­ca­te­na­ción ampliada. En primer lugar, un código que se añade a un string existente:

name = 'Walther'
name = name + 'White'
assert name == 'WaltherWhite'

Un ejemplo equi­va­le­n­te con el operador de co­n­ca­te­na­ción ampliado de Python “+=”. Consigue lo mismo pero el código es más corto y más in­fo­r­ma­ti­vo:

name  = 'Walther'
name += 'White'
assert name == 'WaltherWhite'

Ope­ra­do­res de identidad

El operador is de Python prueba si dos variables se refieren al mismo objeto en memoria. La identidad de los objetos contrasta con su igualdad, que se comprueba mediante el operador de co­m­pa­ra­ción de Python “==”. El is de Python co­rre­s­po­n­de en Ja­va­S­cri­pt a un operador de igualdad estricta “===”. Además, Python reconoce la prueba de identidad negada con el operador is not:

Operador Si­g­ni­fi­ca­do Función Ejemplo
is Prueba de identidad is_(a, b) a = 42; b = a; assert a is b
is not Prueba de identidad negada is_not(a, b) assert [42] is not [42]

Pongamos algunos ejemplos. Creamos en la memoria una re­fe­re­n­cia a un objeto. Luego creamos otra re­fe­re­n­cia como alias. Ambas variables señalan el mismo objeto de la memoria, por lo que el operador is devuelve “True”:

# assign value to name
a = [42]
# reference existing object
b = a
# if this holds
assert a is b
# so will this
assert a == b

Aquí creamos dos re­fe­re­n­cias a objetos in­de­pe­n­die­n­tes en la memoria. Aunque los objetos son los mismos, son distintos. En co­n­se­cue­n­cia, el operador is devuelve “Falso”:

# assign the same value to different names
a = [42]
b = [42]
# `a`, `b` are two different objects
assert a is not b
# that contain the same value
assert a == b

Operador co­n­di­cio­nal

El operador co­n­di­cio­nal de Python es otro uso de la palabra clave if else. Se suele utilizar para di­s­ti­n­guir entre dos posibles valores en las asi­g­na­cio­nes. Dado que el operador co­n­di­cio­nal combina una condición y dos ex­pre­sio­nes, también se conoce como operador ternario.

Operador Si­g­ni­fi­ca­do Función Ejemplo
... if ... else ... Expresión co­n­di­cio­nal Sin co­rre­la­ción directa name = 'Jim' if age == 42 else 'Jack'

A co­n­ti­nua­ción, exa­mi­na­mos un ejemplo de uso de la asi­g­na­ción if else en Python. Este código establece Celsius o Fah­re­nheit como unidad de medición de te­m­pe­ra­tu­ra en función del sistema de medición elegido:

if system == 'metric':
    unit = 'C'
else:
    unit = 'F'

Al aplicar el operador co­n­di­cio­nal, se si­m­pli­fi­ca el código en una única asi­g­na­ción:

unit = 'C' if system == 'metric' else 'F'

Ope­ra­do­res de conjunto en Python

Además de strings, tuples, listas y di­c­cio­na­rios, Python admite por defecto los conjuntos como tipo de datos compuesto. Los ope­ra­do­res so­bre­ca­r­ga­dos se definen para las ope­ra­cio­nes de conjunto ha­bi­tua­les:

Operador Si­g­ni­fi­ca­do Función Ejemplo
& Formar la unión de dos conjuntos and_(a, b) {'a', 'b'} & {'a', 'c'} == {'a'}
Crear la in­te­r­se­c­ción de dos conjuntos or_(a, b) {'a', 'b'} {'a', 'c'} == {'a', 'c', 'b'}
^ Crear una di­fe­re­n­cia simétrica entre dos conjuntos xor(a, b) {'a', 'b'} ^ {'a', 'c'} == {'c', 'b'}
- Formar la di­fe­re­n­cia de dos conjuntos sub(a, b) {'a', 'b'} - {'a'} == {'b'}
> Comprobar si el conjunto es un verdadero su­pe­r­co­n­ju­n­to gt(a, b) assert {'a', 'b'} > {'a'}
>= Comprobar si un conjunto es un su­pe­r­co­n­ju­n­to ge(a, b) assert {'a'} >= {'a'}
< Comprobar si un conjunto es un verdadero su­b­co­n­ju­n­to lt(a, b) assert {'a'} < {'a', 'b'}
<= Comprobar si un conjunto es un su­b­co­n­ju­n­to le(a, b) assert {'a'} <= {'a'}

Ope­ra­do­res de membresía de Python

Los ope­ra­do­res de membresía de Python in y not in declaran si una colección contiene un objeto.

Operador Si­g­ni­fi­ca­do Función Ejemplo
in Comprueba si un iterable contiene un objeto contains(a, b) 'y' in 'Python'
not in Negación del operador in not contains(a, b) 'x' not in 'Python'

Los ope­ra­do­res de membresía funcionan con iterables y recurren a la co­m­pro­ba­ción de igualdad para de­te­r­mi­nar si el objeto meta está incluido en la colección:

'Py' in 'Python'
'Px' not in 'Python'
'Jack' in ['Jim', 'Jack']

Al aplicar el operador in, te ahorras tener que escribir el código de esta manera:

def my_in(target, collection):
    for element in collection:
        if element == target:
            return True
    return False
# test
word = 'Python'
letter = 'y'
assert (my_in(letter, word)) == (letter in word)

Operador de co­n­ca­te­na­ción

En Python, el operador de co­n­ca­te­na­ción se utiliza para co­n­ca­te­nar se­cue­n­cias del mismo tipo. El signo más se utiliza como símbolo de operador.

Operador Si­g­ni­fi­ca­do Función Ejemplo
+ Encadena dos se­cue­n­cias add(a, b) ['Jim'] + ['Jack', 'John']

Veamos un par de ejemplos. Co­n­ca­te­na­mos dos strings, dos listas y dos tuple:

assert "Walter" + "White" == 'WalterWhite'
assert ['a', 'b'] + ['c'] == ['a', 'b', 'c']
assert ('q', 'r') + ('s', 't') == ('q', 'r', 's', 't')

Python se usa como lenguaje de pro­gra­ma­ción de Internet. En este contexto, el operador de co­n­ca­te­na­ción se usa para ensamblar etiquetas HTML:

site_title = 'Welcome'
print('<h1>' + site_title + '</h1>')

Si co­m­pa­ra­mos Python con PHP, ob­se­r­va­mos que los ope­ra­do­res de co­n­ca­te­na­ción son distintos. PHP utiliza el punto “.” como símbolo. El mismo ejemplo en PHP:

$siteTitle = 'Welcome';
echo '<h1>' . $siteTitle . '</h1>';

Ope­ra­do­res índex y slicing

El operador índex de Python sirve para extraer un elemento de­te­r­mi­na­do de una colección. Con el operador de slicing, puedes extraer una su­b­se­cue­n­cia.

Operador Si­g­ni­fi­ca­do Función Ejemplo
iterable[index] Devuelve el elemento de un iterable situado bajo el índice getitem(iterable, index) 'Python'[1] == 'y'
sequence[start:stop:step] Devuelve un trozo de una secuencia getitem(iterable, slice(start, stop, step)) 'Python'[0:1] == 'Py', 'Python'[0:-1:2] == 'Pto'

Los ope­ra­do­res de índex y slicing recurren in­te­r­na­me­n­te al método dunder __getitem__(). Se activan con un índice numérico o un objeto slice:

names = ['Jim', 'Jack', 'John']
names[0] == names.__getitem__(0)
names[0:2] == names.__getitem__(slice(0, 2))

El operador slice es práctico porque permite extraer una su­b­se­cue­n­cia sin aplicar un Python for Loop ni un Python while loop. De esta manera, al programar, nos ahorramos tener que escribir el siguiente código:

word = 'Python'
start, stop, step = 0, 5, 2
index, substring = start, ''
while index in range(start, stop, step):
    substring += word[index]
    index += step
# test
assert substring == word[start:stop:step]
Ir al menú principal