Python3 operator Module
In Python 2.x versions, the cmp() function was used to compare the size relationships between two lists, numbers, or strings, etc.
In Python 3.X versions, the cmp() function no longer exists. If you need to implement comparison functionality, you need to import the operator module, which is suitable for any object. The methods included are:
Methods Included in the operator Module
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) is the same as a < b, operator.le(a, b) is the same as a <= b, operator.eq(a, b) is the same as a == b, operator.ne(a, b) is the same as a != b, operator.gt(a, b) is the same as a > b, and operator.ge(a, b) is the same as a >= b.
Example
# Import the operator module
import operator
# Numbers
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()
# Strings
x = "Google"
y = "tutorialpro"
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()
# Check the return type
print("type(operator.lt(x, y)): ", type(operator.lt(x, y)))
The above code outputs:
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: tutorialpro
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
Comparing two lists:
Example
# Import the operator module
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))
The above code outputs:
operator.eq(a, b): False
operator.eq(c, b): True
Operator Functions
The operator module provides a set of efficient functions corresponding to Python's built-in operators. For example, operator.add(x, y) is equivalent to the expression x + y.
The functions include types such as object comparison, logical operations, mathematical operations, and sequence operations.
Object comparison functions are applicable to all objects, with function names derived from their corresponding comparison operators.
Many function names are the same as special method names but without double underscores. For backward compatibility, many double-underscore-containing functions are also retained. For clarity, it is recommended to use functions without double underscores.
Example
# Python example
# add(), sub(), mul()
# Import operator module
import operator
# Initialize variables
a = 4
b = 3
# Use add() to add two values
print("add() result:", end="")
print(operator.add(a, b))
# Use sub() to subtract two values
print("sub() result:", end="")
print(operator.sub(a, b))
# Use mul() to multiply two values
print("mul() result:", end="")
print(operator.mul(a, b))
The output of the above code is:
add() result: 7
sub() result: 1
mul() result: 12
| Operation | Syntax | Function |
|---|---|---|
| Addition | a + b | add(a, b) |
| String Concatenation | seq1 + seq2 | concat(seq1, seq2) |
| Containment Test | obj in seq | contains(seq, obj) |
| Division | a / b | truediv(a, b) |
| Floor Division | a // b | floordiv(a, b) |
| Bitwise And | a & b | and_(a, b) |
| Bitwise Xor | a ^ b | xor(a, b) |
| Bitwise Invert | ~ a | invert(a) |
| Bitwise Or | a | b | or_(a, b) |
| Exponentiation | a ** b | pow(a, b) |
| Identity | a is b | is_(a, b) |
| Identity | a is not b | is_not(a, b) |
| Index Assignment | obj[k] = v | setitem(obj, k, v) |
| Index Deletion | del obj[k] | delitem(obj, k) |
| Index Retrieval | obj[k] | getitem(obj, k) |
| Left Shift | a << b | lshift(a, b) |
| Modulus | a % b | mod(a, b) |
| Multiplication | a * b | mul(a, b) |
| Matrix Multiplication | a @ b | matmul(a, b) |
| Negation (Arithmetic) | - a | neg(a) |
| Negation (Logical) | not a | not_(a) |
| Positive | + a | pos(a) |
| Right Shift | a >> b | rshift(a, b) |
| Slice Assignment | seq[i:j] = values | setitem(seq, slice(i, j), values) |
| Slice Deletion | del seq[i:j] | delitem(seq, slice(i, j)) |
| Slice Retrieval | seq[i:j] | getitem(seq, slice(i, j)) |
| String Formatting | s % obj | mod(s, obj) |
| Subtraction | a - b | sub(a, b) |
| Truth Test | obj | truth(obj) |
| Comparison | a < b | lt(a, b) |
| Comparison | a <= b | le(a, b) |
| Equality | a == b | eq(a, b) |
| Inequality | a != b | ne(a, b) |
| Comparison | a >= b | ge(a, b) |
| Comparison | a > b | gt(a, b) |