Introduction

If you see AttributeError: module 'numpy' has no attribute 'MachAr', the code is usually depending on an internal NumPy implementation detail rather than a stable public API. In modern NumPy, the supported way to inspect floating-point limits is numpy.finfo, not numpy.MachAr.

What MachAr Was Meant To Represent

MachAr refers to machine arithmetic analysis: values such as epsilon, the smallest normalized number, and the largest finite value for a floating-point type. Older code, blog posts, and internal NumPy examples sometimes referenced it directly, but it was never a good dependency for application code.

What most programs actually need is one of these questions:

• What is the precision of float64?
• What is the largest or smallest representable value?
• What is the machine epsilon?

NumPy already exposes all of that through finfo.

Use numpy.finfo Instead

The direct replacement is usually straightforward. Ask finfo about a dtype, then read the attributes you need.

1import numpy as np
2
3info = np.finfo(np.float64)
4
5print("epsilon:", info.eps)
6print("max:", info.max)
7print("min:", info.min)
8print("tiny:", info.tiny)

Typical output includes the spacing between 1.0 and the next representable number, plus the numeric range for the type. That is what most code using MachAr was trying to get in the first place.

If you need to inspect several dtypes, loop over them explicitly:

1import numpy as np
2
3for dtype in (np.float32, np.float64):
4    info = np.finfo(dtype)
5    print(dtype.__name__)
6    print("  eps =", info.eps)
7    print("  max =", info.max)
8    print("  tiny =", info.tiny)

This is public, documented, and portable.

Why The Error Happens

There are three common causes.

First, the code was written against an old NumPy version or copied from an outdated answer. Internal names sometimes move or disappear, and np.MachAr is not something you should expect to exist across releases.

Second, the code confuses a private implementation symbol with a public attribute. Some internal classes may exist deeper in the package, but importing them directly couples your code to NumPy internals. That creates upgrade problems.

Third, the import may not be loading the NumPy installation you think it is loading. A local file named numpy.py or a broken environment can cause misleading errors.

Check Your Environment Before Changing Too Much

Before you assume the library is broken, confirm what Python imported:

1import numpy as np
2
3print(np.__version__)
4print(np.__file__)

If the printed path points into your project instead of the installed package, you probably have a shadowing problem. Rename the conflicting file or directory and remove stale __pycache__ entries.

You should also verify that the rest of the numeric API works:

1import numpy as np
2
3a = np.array([1.0, 2.0, 3.0], dtype=np.float64)
4print(a.mean())
5print(np.finfo(a.dtype).eps)

If this works, NumPy is fine and the issue is specifically the obsolete attribute access.

A Safe Replacement Pattern

Many old snippets effectively did this:

# obsolete idea
# np.MachAr().eps

The modern version is:

1import numpy as np
2
3eps = np.finfo(float).eps
4print(eps)

If the original code used machine limits for a specific array dtype, derive the type from the array instead of hardcoding it:

1import numpy as np
2
3values = np.array([1, 2, 3], dtype=np.float32)
4limits = np.finfo(values.dtype)
5
6print(limits.eps)
7print(limits.max)

That avoids subtle bugs where your computations run in float32 but your constants were copied from float64.

Do Not Depend On Private NumPy Internals

The bigger lesson is architectural. Libraries expose public APIs so callers can rely on them. Internal names may disappear, change module locations, or behave differently after an upgrade. When you see examples reaching into undocumented objects, treat them as debugging material, not production patterns.

For numeric metadata, prefer documented entry points such as:

• 'numpy.finfo for floating-point types'
• 'numpy.iinfo for integer types'
• 'dtype objects for type inspection'

For example, integer limits should use iinfo, not finfo:

1import numpy as np
2
3info = np.iinfo(np.int32)
4print(info.min)
5print(info.max)

Common Pitfalls

• Using finfo on an integer dtype. Use np.iinfo for integer ranges.
• Reading old answers literally. If an example depends on undocumented internals, look for a documented equivalent before adopting it.
• Ignoring import shadowing. A local numpy.py file can make ordinary import errors look like missing attributes.
• Hardcoding float64 when the data is actually float32. Query the array dtype if precision matters.

Summary

• 'np.MachAr is not a stable public NumPy API.'
• Use np.finfo(dtype) to inspect floating-point precision and limits.
• Use np.iinfo(dtype) for integer limits.
• Check np.__version__ and np.__file__ if the error seems inconsistent.
• Prefer documented APIs over internal library symbols.