El módulo operator en Python ofrece funciones que replican los operadores incorporados, proporcionando una forma eficiente de realizar operaciones en objetos. Estas funciones son útiles en contextos donde se requieren funciones de orden superior, como con map() o sorted().

Operaciones de comparación

Las funciones de comparación evalúan relaciones entre dos operandos y devuelven un valor booleano.

print(lt(5, 10)) # Salida: True print(le(8, 8)) # Salida: True print(gt(15, 5)) # Salida: True print(ge(7, 7)) # Salida: True print(eq(4, 9)) # Salida: False print(ne(3, 3)) # Salida: False

</div>### Operaciones lógicas y de identidad

Estas funciones realizan operaciones lógicas como AND, OR y XOR, además de verificar la identidad de objetos.

| Operación | Función | Ejemplo |
|---|---|---|
| AND lógico | `and_(a, b)` | `and_(True, False)` |
| OR lógico | `or_(a, b)` | `or_(False, True)` |
| XOR | `xor(a, b)` | `xor(1, 3)` |
| NOT | `invert(a)` | `invert(True)` |
| Identidad | `is_(a, b)` | `is_(a_list, a_list)` |
| No identidad | `is_not(a, b)` | `is_not(a_list, another_list)` |

<div class="code-example">```
from operator import and_, or_, xor, invert, is_, is_not

print(and_(True, False))   # Salida: False
print(or_(False, True))    # Salida: True
print(xor(1, 3))           # Salida: 2 (en binario: 01 XOR 11 = 10)
print(invert(True))        # Salida: -2 (porque True se convierte a 1)
val1 = [1, 2, 3]
val2 = val1
print(is_(val1, val2))     # Salida: True, misma referencia
val3 = [1, 2, 3]
print(is_not(val1, val3))  # Salida: True, objetos diferentes

Funciones que corresponden a operaciones aritméticas estándar.

print(add(4, 6)) # Salida: 10 print(sub(10, 3)) # Salida: 7 print(mul(2, 5)) # Salida: 10 print(truediv(7, 2)) # Salida: 3.5 print(pow(3, 4)) # Salida: 81 print(neg(5)) # Salida: -5 print(neg(-5)) # Salida: 5

</div>### Operaciones sobre secuencias

Funciones para manipular secuencias como listas, cadenas y tuplas.

| Operación | Función | Ejemplo |
|---|---|---|
| Concatenar | `concat(seq1, seq2)` | `concat('Hola', 'Mundo')` |
| Contener | `contains(seq, obj)` | `contains([1,2,3], 2)` |
| Asignar por índice | `setitem(obj, i, v)` | `setitem(lista, 0, 'nuevo')` |
| Eliminar por índice | `delitem(obj, i)` | `delitem(lista, 1)` |
| Obtener por índice | `getitem(obj, i)` | `getitem(lista, 0)` |
| Asignar por segmento | `setitem(seq, slice(i, j), vals)` | `setitem(cadena, slice(0,5), 'nuevo')` |
| Elimniar por segmento | `delitem(seq, slice(i, j))` | `delitem(lista, slice(1,3))` |
| Obtener por segmento | `getitem(seq, slice(i, j))` | `getitem(lista, slice(0,2))` |

<div class="code-example">```
from operator import concat, contains, setitem, delitem, getitem

# Ejemplo con cadenas
str1 = 'buenos'
str2 = ' días'
print(concat(str1, str2))  # Salida: 'buenos días'

# Ejemplo con listas
my_list = [10, 20, 30, 40]
print(contains(my_list, 20))  # Salida: True
setitem(my_list, 1, 25)       # Cambia el elemento en índice 1
print(my_list)                 # Salida: [10, 25, 30, 40]
delitem(my_list, 2)            # Elimina el elemento en índice 2
print(my_list)                 # Salida: [10, 25, 40]
print(getitem(my_list, 0))    # Salida: 10

# Operaciones con segmentos
my_list = [1, 2, 3, 4, 5]
setitem(my_list, slice(1, 4), [20, 30, 40])
print(my_list)  # Salida: [1, 20, 30, 40, 5]
delitem(my_list, slice(2, 4))
print(my_list)  # Salida: [1, 20, 5]
print(getitem(my_list, slice(0, 2)))  # Salida: [1, 20]

La clase attrgetter crea un callable que extrae atributos de un objeto. Es particularmente útil para clasificar o mapear objetos basados en sus atributos.

class Producto: def init(self, nombre, precio): self.nombre = nombre self.precio = precio

def __repr__(self):
    return f'Producto(nombre={self.nombre!r}, precio={self.precio!r})'

Crear una lista de productos

productos = [ Producto("Laptop", 1200), Producto("Teléfono", 800), Producto("Tablet", 500) ]

Ordenar productos por precio de forma descendente

sorted_productos = sorted(productos, key=attrgetter('precio'), reverse=True) print("Productos ordenados por precio:") print(sorted_productos)

Extraer el precio de cada producto usando attrgetter

getter_precio = attrgetter('precio') precios = [getter_precio(p) for p in productos] print("Precios extraídos:", precios)

</div>### Clase `itemgetter`

`itemgetter` devuelve un callable que obtiene elementos de secuencias o mapeos. Cuando se pasan múltiples argumentos, devuelve una tupla con los elementos correspondientes.

<div class="code-example">```
from operator import itemgetter

# Ejemplo con cadenas
obtener_caracter = itemgetter(2)
print(obtener_caracter('abcdefg'))  # Salida: 'c'

# Ejemplo con múltiples índices
obtener_tupla = itemgetter(0, 2, 4)
print(obtener_tupla('abcdefg'))  # Salida: ('a', 'c', 'e')

# Ejemplo con diccionarios
persona = {'nombre': 'Ana', 'edad': 30, 'ocupación': 'Ingeniera'}
obtener_nombre = itemgetter('nombre')
print(obtener_nombre(persona))  # Salida: 'Ana'

# Uso con listas de tuplas
datos = [('manzana', 5), ('banana', 3), ('cereza', 8)]
obtener_cantidad = itemgetter(1)

# Obtener una lista de cantidades
cantidades = list(map(obtener_cantidad, datos))
print("Cantidades:", cantidades)  # Salida: [5, 3, 8]

# Ordenar datos por cantidad
sorted_datos = sorted(datos, key=obtener_cantidad)
print("Datos ordenados por cantidad:", sorted_datos)  # Salida: [('banana', 3), ('manzana', 5), ('cereza', 8)]