FIP W03 · x * x 与 x ** 2 的区别

W3 学习记录，按原 Markdown 文件创建时间归档。

Does x * x Have an Obvious Difference from x ** 2?

Short answer

For ordinary built-in numeric values, x * x and x ** 2 normally produce the same mathematical result: the square of x. They are nevertheless different Python operations.

• x * x uses the multiplication.
• x ** 2 uses the power.
• pow(x, 2) is the functional form of x ** 2.
• pow(x, 2, mod) performs modular exponentiation without first constructing the full value of x ** 2.
• math.pow(x, 2) converts its arguments to floating point and returns a float.

The distinction is barely visible for small built-in int or float values, but it becomes important for exact large-integer arithmetic, modular arithmetic,etc..

Comparison at a glance

The chart below is generated by AI.

Expression	Operation requested	Typical protocol	Result for x = 3	Main use
x * x	multiplication	__mul__ / __rmul__	9	an explicit square
x ** 2	exponentiation	__pow__ / __rpow__	9	mathematical power syntax
pow(x, 2)	exponentiation	same semantics as two-argument **	9	dynamic or functional use
pow(x, 2, mod)	modular exponentiation	three-argument power protocol	depends on mod	cryptography and modular arithmetic
math.pow(x, 2)	floating-point exponentiation	math module / platform math library	9.0	explicitly floating-point work

1. Differrent methods are not operational equivalence

For common built-in numeric types, the equality is always true:

x = 12

x * x == x ** 2 == pow(x, 2)
# True

That does not make the expressions identical. Python allows a type to define multiplication and exponentiation independently:

class Demo:
    def __mul__(self, other):
        return "multiplication"

    def __pow__(self, exponent, modulo=None):
        return "power"


x = Demo()

print(x * x)     # multiplication
print(x ** 2)    # power
print(pow(x, 2)) # power

The two forms can therefore return different values or have different side effects. This matters for user-defined numeric classes and others types such as symbolic expressions, arrays, matrices, and tensors. Their exact behavior is defined by the relevant library.

There is also an evaluation difference when x is replaced by an expression with side effects:

_value() * _value()  # calls _value() twice
_value() ** 2        # calls _value() once

For a simple local variable named x, this issue does not arise.

2. Five different exponentiation forms in detail

x * x: regular multiplication

x * x asks Python to multiply two operands. Conceptually, dispatch begins with the multiplication methods __mul__ and, when applicable, __rmul__.

For a square, this form directly return a value. This is exactly true for an integer.

x ** 2: the power operator

x ** 2 uses Python’s power operator. For two arguments, it same to pow(x, 2). It communicates the mathematical idea of raising a value to a power and naturally generalizes when the exponent is not fixed at two.

pow(x, 2): built-in two-argument power

The built-in function pow(base, exp) is semantically equivalent to base ** exp. It is useful when a function is more convenient than operator syntax, but it is not a special “faster square” operation.

pow(x, 2, mod): modular exponentiation

The three-argument form computes:

(x ** 2) % mod

but does so more efficiently than first constructing the full power and then taking the remainder. For exponent 2, the avoided intermediate may be modest; for a large exponent it can be enormous.

pow(123456789, 2, 97)

For built-in integers, mod must be nonzero. Python also supports certain negative exponents in the three-argument form: when the base is invertible modulo mod, it computes using the modular inverse. This form is the correct default for modular powers.

math.pow(x, 2): floating-point power

math.pow(x, y) converts both arguments to float and returns a float:

import math

math.pow(3, 2)  # 9.0

Large integers may be rounded during conversion or may cause an overflow-related exception:

10**100                 # integer
math.pow(10**50, 2)     # floating-point calculation

math.pow also differs from ** for some domains: for example, a negative real base with a non-integral exponent is outside math.pow’s real-valued domain, while Python’s built-in power operation may produce a complex result.

3. CPython execution paths

This section is generated with AI.

The following describes CPython, the reference implementation, rather than a guarantee made to every Python implementation. Exact bytecode names, specialization strategies, and internal functions can change between releases.

At a high level:

x * x
  -> multiplication bytecode/operation
  -> PyNumber_Multiply
  -> the type's multiplication slot
  -> for int operands, CPython's integer multiplication implementation

x ** 2
  -> power bytecode/operation
  -> PyNumber_Power
  -> the type's power slot
  -> for int operands, CPython's integer power implementation

pow(x, 2)
  -> built-in pow call
  -> the same two-argument power semantics as x ** 2

pow(x, 2, mod)
  -> ternary power dispatch
  -> the type's power slot with a modulus
  -> for int operands, modular integer exponentiation

Objects/abstract.c contains generic numeric dispatch such as the PyNumber_* APIs. Objects/longobject.c contains the implementation of Python’s arbitrary-precision int, including integer multiplication and exponentiation. These files are implementation evidence, not part of Python’s stable language-level contract.

Modern CPython can specialize frequently executed bytecode for particular operand types. Consequently, a simplified path such as the one above is useful for understanding semantics, but it should not be mistaken for a promise that every execution takes exactly the same internal calls.

4. Algorithmic differences

For x * x, the high-level task is one multiplication. For x ** n, the task is general exponentiation. Integer exponentiation uses an exponentiation algorithm that reuses squaring and multiplication rather than naively multiplying by x exactly n - 1 times(Decrease-and-Conquer! Like we learned in W2). Its number of high-level multiplication steps grows roughly with the number of bits in a nonnegative exponent, although the cost of each big-integer multiplication also depends on operand size.

For the special exponent 2, a general power operation has work to do than the expression of a single multiplication. CPython’s arbitrary-precision integer code also contains optimized squaring behavior when multiplying an integer by itself. These facts explain why x * x is often faster than x ** 2.

This should not be turned into an overly broad complexity claim. When the exponent is the fixed constant 2, both expressions perform work dominated by squaring the value; the practical difference is chiefly the operation path and constant overhead. Statements such as “x ** 2 is logarithmic while x * x is constant” are misleading here because they treat a fixed exponent as though it were growing input.

The modular form is also important:

pow(base, exponent, modulus)

It reduces intermediate results modulo modulus throughout the exponentiation. By contrast, base ** exponent % modulus may first allocate an extremely large integer. The two expressions have the same intended modular result for appropriate integers, but potentially very different time and memory requirements.

5. Performance considerations

For a simple square of built-in numbers,x * x commonly faster than x ** 2, and both commonly avoid the Python-level function-call overhead visible in pow(x, 2). math.pow(x, 2) has conversion and function-call costs and provides different floating-point semantics, so it is not a fair substitute in exact-integer benchmarks.

However, things may change in different situation:

• results depend on the Python implementation and version;
• CPython’s adaptive specialization can change hot-loop behavior;
• operand type and integer size matter;
• third-party types may implement the two operations very differently;
• constant expressions may be folded by the compiler;
• benchmark setup can cost more than the operation being measured.

Measure the real workload with timeit or a suitable benchmark framework when the difference matters. Use variables rather than constant-only expressions, test realistic value sizes, include warm-up where appropriate, and confirm that compared expressions have the same required semantics.

6. Practical recommendations

1. Use x * x for a literal square when multiplication semantics are intended and a small performance advantage matters. It is direct and often efficient.
2. Use x ** 2 when mathematical power notation is clearer, when consistency with other exponents matters, or when the object’s power semantics are specifically desired.
3. Use pow(x, 2) when a callable form is convenient. Do not expect it to be faster than the operator.
4. Use pow(x, exponent, mod) for integer modular exponentiation, especially when the exponent can be large.
5. Use math.pow only when conversion to floating point and real-valued floating-point semantics are intended. Do not use it for exact integer powers.
6. For custom or library-defined types, consult that type’s documentation and test behavior; * and ** are separate extension points.
7. Prefer clarity until profiling shows that a square operation is a meaningful bottleneck.

Conclusion

Does x * x have an obvious difference from x ** 2? At the level of elementary arithmetic on ordinary numbers, often no: both calculate a square. At the language and implementation levels, yes: they request different operations, invoke different protocols, follow different CPython paths, and can differ in behavior and speed.

The safest summary is:

Equal results for common numeric inputs do not imply interchangeable Python semantics.

Appendix: Why x ** 2 is not a Taylor expansion

For CPython’s built-in integer type, x ** 2 is an integer-power operation: it uses the integer exponentiation implementation in Objects/longobject.c. It computes a power through integer multiplication and squaring; it does not approximate the result by summing a Taylor series. The same is true of x * x, which is directly an integer multiplication.

For ordinary floating-point float operands, x ** 2 is also a power operation, not a Taylor-series evaluation performed by Python code. CPython’s floating-point implementation may delegate general floating-point powers to the platform’s C math library. That library is free to choose its own numerical techniques; Python’s language specification does not require or document Taylor expansion for this operation. For the exact exponent 2, treating the operation as an approximation to a function is neither necessary nor the intended model.

One qualification matters: Python is extensible. A custom class can define __pow__ to run arbitrary code, including a Taylor-series calculation. Therefore, the accurate absolute statement is:

CPython’s built-in numeric implementations do not use Taylor expansion to calculate x ** 2; Python cannot prevent a user-defined __pow__ method from doing so.

Functions commonly evaluated with series or polynomial approximations

Taylor series are relevant to transcendental functions, such as the exponential function:

\[ e^x = 1 + x + \frac{x^2}{2!} + \frac{x^3}{3!} + \cdots \]

The following functions have mathematical Taylor-series expansions and are commonly implemented numerically using range reduction plus polynomial, rational, table-based, or related approximations. A production implementation need not use the literal Taylor series shown in a textbook; the algorithm is selected by the underlying math library for accuracy and speed. > The chart below is generated by AI.

Function	Mathematical role	Example Taylor expansion near zero	Python documentation
math.exp(x)	computes (e^x)	(1 + x + x^2/2! + )	math.exp
math.expm1(x)	computes (e^x - 1), accurately near zero	(x + x^2/2! + x^3/3! + )	math.expm1
math.sin(x)	sine	(x - x^3/3! + x^5/5! - )	math.sin
math.cos(x)	cosine	(1 - x^2/2! + x^4/4! - )	math.cos
math.log1p(x)	computes ((1+x)), accurately near zero	(x - x^2/2 + x^3/3 - )	math.log1p

math.expm1 and math.log1p are particularly good examples of why numerical libraries provide dedicated functions: directly evaluating math.exp(x) - 1 or math.log(1 + x) can lose significant precision when x is close to zero. The Python documentation explicitly describes these accuracy-oriented purposes.

The math module documentation also notes that CPython’s math module consists mostly of thin wrappers around the platform C math library. Accordingly, use its documentation to understand Python-level behavior and edge cases, but do not infer that every platform uses the same Taylor polynomial internally.

Official Python references

• Python Language Reference: The power operator
• Python built-in functions: pow
• Python math module: math.pow
• Python Data Model: __pow__ and numeric emulation
• CPython source: Objects/abstract.c
• CPython source: Objects/longobject.c
• Python math module overview
• Python math module: math.exp
• Python math module: math.expm1
• Python math module: math.log1p

⚖️AI Collaboration Statement

This document was developed from my existing research with the assistance of artificial intelligence. AI was used to help locate and organize relevant documentation, structure comparison tables, improve clarity and English expression, and expand the discussion with related technical context. The research direction, topic selection, and final review remained under my responsibility.