Módulo operator de Python3

En la versión Python 2.x, se usacmp()la función para comparar el tamaño relativo de dos listas, números o cadenas, etc.

En la versión Python 3.X ya no existecmp()la función. Si necesitas implementar comparaciones, debes importaroperatorel módulo operator, adecuado para cualquier objeto. Los métodos incluidos son:

Métodos incluidos en el módulo operator

operator.lt(a, b)
operator.le(a, b)
operator.eq(a, b)
operator.ne(a, b)
operator.ge(a, b)
operator.gt(a, b)
operator.__lt__(a, b)
operator.__le__(a, b)
operator.__eq__(a, b)
operator.__ne__(a, b)
operator.__ge__(a, b)
operator.__gt__(a, b)

operator.lt(a, b)ya < bequivalente a,operator.le(a, b)ya <= bequivalente a,operator.eq(a, b)ya == bequivalente a,operator.ne(a, b)ya != bequivalente a,operator.gt(a, b)ya > bequivalente a,operator.ge(a, b)ya >= bequivalente.

Ejemplo

# Importar el módulo operator
import operator
 
# Números
x = 10
y = 20

print("x:",x, ", y:",y)
print("operator.lt(x,y): ", operator.lt(x,y))
print("operator.gt(y,x): ", operator.gt(y,x))
print("operator.eq(x,x): ", operator.eq(x,x))
print("operator.ne(y,y): ", operator.ne(y,y))
print("operator.le(x,y): ", operator.le(x,y))
print("operator.ge(y,x): ", operator.ge(y,x))
print()

# Cadenas
x = "Google"
y = "Ejemplo"

print("x:",x, ", y:",y)
print("operator.lt(x,y): ", operator.lt(x,y))
print("operator.gt(y,x): ", operator.gt(y,x))
print("operator.eq(x,x): ", operator.eq(x,x))
print("operator.ne(y,y): ", operator.ne(y,y))
print("operator.le(x,y): ", operator.le(x,y))
print("operator.ge(y,x): ", operator.ge(y,x))
print()

# Ver el valor de retorno
print("type((operator.lt(x,y)): ", type(operator.lt(x,y)))

El resultado de salida del código anterior es:

x: 10 , y: 20
operator.lt(x,y):  True
operator.gt(y,x):  True
operator.eq(x,x):  True
operator.ne(y,y):  False
operator.le(x,y):  True
operator.ge(y,x):  True

x: Google , y: Ejemplo
operator.lt(x,y):  True
operator.gt(y,x):  True
operator.eq(x,x):  True
operator.ne(y,y):  False
operator.le(x,y):  True
operator.ge(y,x):  True

Comparar dos listas:

Ejemplo

# Importar el módulo operator
import operator

a = [1, 2]
b = [2, 3]
c = [2, 3]
print("operator.eq(a,b): ", operator.eq(a,b))
print("operator.eq(c,b): ", operator.eq(c,b))

El resultado de salida del código anterior es:

operator.eq(a,b):  False
operator.eq(c,b):  True

Funciones de operadores

El módulo operator proporciona un conjunto de funciones de alta eficiencia que corresponden a los operadores integrados de Python. Por ejemplo,operator.add(x, y)con la expresiónx+yes equivalente.

Los tipos de funciones incluyen: operaciones de comparación de objetos, operaciones lógicas, operaciones matemáticas y operaciones de secuencia.

Las funciones de comparación de objetos se aplican a todos los objetos, y sus nombres se derivan de los operadores de comparación correspondientes.

Muchos nombres de funciones son iguales a los de los métodos especiales, solo que sin dobles guiones bajos. Por compatibilidad con versiones anteriores, también se conservan muchas funciones con dobles guiones bajos. Para mayor claridad, se recomienda usar las funciones sin dobles guiones bajos.

Ejemplo

# Ejemplo de Python
# add(), sub(), mul()
 
# Importar el módulo operator
import operator
 
# Inicializar variables
a = 4
 
b = 3
 
# Usar add() para sumar dos valores
print ("Resultado de add() :",end="");
print (operator.add(a, b))
 
# Usar sub() para restar dos valores
print ("Resultado de sub() :",end="");
print (operator.sub(a, b))
 
# Usar mul() para multiplicar dos valores
print ("Resultado de mul() :",end="");
print (operator.mul(a, b))

El resultado de salida del código anterior es:

add() 运算结果 :7
sub() 运算结果 :1
mul() 运算结果 :12

Operación

Sintaxis

Función

Suma

a + b

add(a, b)

Concatenación de cadenas

seq1 + seq2

concat(seq1, seq2)

Prueba de contención

obj in seq

contains(seq, obj)

División

a / b

truediv(a, b)

División

a // b

floordiv(a, b)

Y bit a bit

a & b

and_(a, b)

O exclusivo bit a bit

a ^ b

xor(a, b)

Complemento bit a bit

~ a

invert(a)

O bit a bit

a | b

or_(a, b)

Exponenciación

a ** b

pow(a, b)

Identidad

a is b

is_(a, b)

Identidad

a is not b

is_not(a, b)

Asignación de índice

obj[k] = v

setitem(obj, k, v)

Eliminación de índice

del obj[k]

delitem(obj, k)

Obtención de índice

obj[k]

getitem(obj, k)

Desplazamiento a la izquierda

a << b

lshift(a, b)

Módulo

a % b

mod(a, b)

Multiplicación

a * b

mul(a, b)

Multiplicación de matrices

a @ b

matmul(a, b)

Negación (aritmética)

- a

neg(a)

Negación (lógica)

not a

not_(a)

Positivo

+ a

pos(a)

Desplazamiento a la derecha

a >> b

rshift(a, b)

Asignación de rebanada

seq[i:j] = values

setitem(seq, slice(i, j), values)

Eliminación de rebanada

del seq[i:j]

delitem(seq, slice(i, j))

Obtención de rebanada

seq[i:j]

getitem(seq, slice(i, j))

Formateo de cadenas

s % obj

mod(s, obj)

Resta

a - b

sub(a, b)

Prueba de valor verdadero

obj

truth(obj)

Comparación

a < b

lt(a, b)

Comparación

a <= b

le(a, b)

Igualdad

a == b

eq(a, b)

Desigualdad

a != b

ne(a, b)

Comparación

a >= b

ge(a, b)

Comparación

a > b

gt(a, b)
Otras extensiones