Python's Operator Module: A Custom Implementation

The operator module in Python provides a collection of efficient functions corresponding to Python's intrinsic operators. Implementing these operators yourself can deepen your understanding of how Python handles fundamental operations and the mechanics behind them. This challenge asks you to reimplement some common operators as functions.

Problem Description

Your task is to create a Python module that mimics the functionality of some key functions within the standard operator module. You will need to define functions that perform common arithmetic, comparison, and logical operations.

Key Requirements:

1. Arithmetic Operations: Implement functions for addition (add), subtraction (sub), multiplication (mul), division (truediv), and modulo (mod).
2. Comparison Operations: Implement functions for equality (eq), inequality (ne), less than (lt), less than or equal to (le), greater than (gt), and greater than or equal to (ge).
3. Logical Operations: Implement functions for logical AND (and_), logical OR (or_), and logical NOT (not_).
4. Function Signatures: Each function should accept two arguments, a and b, unless it's a unary operation like not_.
5. Return Values: The functions should return the result of applying the corresponding operator to the input arguments.
6. Error Handling: For arithmetic operations, consider potential division by zero. For other operations, assume valid input types unless specified otherwise.

Expected Behavior:

Your functions should behave identically to their built-in Python operator counterparts when given appropriate arguments.

Edge Cases to Consider:

• Division by zero for truediv and mod.
• Type compatibility for operations (e.g., adding a string and an integer). Your functions should raise appropriate exceptions if operations are not supported for the given types.

Examples

Example 1: Arithmetic Operations

Input:
a = 10
b = 3
operation = "add" # or "sub", "mul", "truediv", "mod"

Output:
add(a, b) -> 13
sub(a, b) -> 7
mul(a, b) -> 30
truediv(a, b) -> 3.3333333333333335
mod(a, b) -> 1

Explanation: Standard arithmetic operations applied to integers. truediv performs float division.

Example 2: Comparison Operations

Input:
a = 5
b = 5
operation = "eq" # or "ne", "lt", "le", "gt", "ge"

Output:
eq(a, b) -> True
ne(a, b) -> False
lt(a, b) -> False
le(a, b) -> True
gt(a, b) -> False
ge(a, b) -> True

Explanation: Boolean results based on the comparison between a and b.

Example 3: Logical Operations

Input:
a = True
b = False
operation = "and_" # or "or_"

Input:
a = True
operation = "not_"

Output:
and_(a, b) -> False
or_(a, b) -> True
not_(a) -> False

Explanation: Standard boolean logical operations.

Example 4: Error Handling (Division by Zero)

Input:
a = 10
b = 0
operation = "truediv"

Output:
Raises ZeroDivisionError

Explanation: Attempting to divide by zero should result in a ZeroDivisionError.

Constraints

• Your implementation should cover the following operators: add, sub, mul, truediv, mod, eq, ne, lt, le, gt, ge, and_, or_, not_.
• Input arguments a and b can be of various Python built-in types (integers, floats, booleans, strings, lists, tuples). Your functions should handle these types appropriately where the operations are defined.
• Your functions should mimic the behavior of Python's standard operators. For unsupported type combinations, they should raise standard Python exceptions (e.g., TypeError).
• Your implementation should not use the built-in operator module itself.

Notes

• Consider how different Python data types behave with each operator. For instance, how does addition work with strings or lists?
• Pay close attention to the difference between integer division (//) and true division (/). This challenge specifically asks for truediv.
• The not_ operation is a unary operator, meaning it only takes one argument.
• Think about the return type of each operation. For example, comparison operations return booleans.