Pages

Topics

Tools

↑↓navigate↵openescclose
All guides

How to Use NumPy dtype and astype for Type Conversion

Learn how to use NumPy dtype and astype for array type conversion, including numeric, string, and datetime conversions, copy behavior, and common pitfalls.

~6 min readPython
#NumPy#data types#type conversion#astype
Illustration of a NumPy array being converted from one data type to another, showing the dtype label changing.

When you need to change the data type of a NumPy array, the dtype attribute and the astype() method are the core tools. astype() is the primary method for converting an array to another dtype, but its behavior has edge cases that can lead to silent data loss or unexpected copies if ignored.

Understanding dtype and Why Type Conversion Matters

Every NumPy array has a dtype attribute that describes the type of elements stored in memory. Unlike Python lists, which can hold mixed types, NumPy arrays enforce a single type for all elements. This constraint is what enables fast vectorized operations and compact memory layout.

Type conversion becomes necessary when you need to:

  • Reduce memory footprint by switching from float64 to float32.
  • Interface with libraries that require a specific dtype, such as OpenCV expecting uint8 images.
  • Perform integer-only operations after calculations that produce floats.
  • Serialize data to formats that only support certain types.

Choosing the correct dtype affects memory consumption and operation speed. For example, an array of 10 million float64 elements uses 80 MB, while the same data as float32 uses 40 MB.

The Basics of astype() and Its Return Behavior

The astype() method is called on an existing array and returns a new array with the requested dtype. The original array is not modified in place.

python
import numpy as np arr = np.array([1, 2, 3]) float_arr = arr.astype(np.float64) print(float_arr.dtype) # float64 print(arr.dtype) # int64 (unchanged)

The method accepts a dtype argument, which can be a NumPy type object, a string like 'float32', or a Python built-in type such as int or float. When you pass a Python type, NumPy maps it to its closest equivalent.

python
arr = np.array([1.5, 2.7, 3.2]) int_arr = arr.astype(int) # equivalent to np.int64 on most platforms print(int_arr) # [1 2 3]

By default, astype() returns a newly allocated array even when the requested dtype matches the original. If you pass copy=False, NumPy can return the original array without copying when the dtype already matches. For a true dtype change, a new array is unavoidable.

Converting Between Numeric Types: int, float, and Complex

Numeric conversions are the most common use of astype(). Moving from a wider type to a narrower one can lose precision or overflow, but NumPy does not raise an error by default. Instead, it follows C casting rules, which may wrap around for integers or round for floats.

python
large = np.array([300, 400], dtype=np.int64) small = large.astype(np.int8) print(small) # [44 -112] on most platforms print(small.dtype) # int8

The example shows that converting to a smaller integer type can produce unexpected values due to integer overflow. If you need to detect overflow, check the original values against the target type's limits before conversion.

For float-to-int conversions, astype() truncates toward zero, not rounds. This is a common source of bugs when users expect rounding behavior.

python
values = np.array([1.9, -2.5]) print(values.astype(int)) # [ 1 -2]

If you need rounding, use np.round() first, then convert.

python
rounded = np.round(values).astype(int) print(rounded) # [ 2 -2]

Complex to float conversion discards the imaginary part, and float to complex sets the imaginary part to zero.

python
c = np.array([1+2j, 3-1j]) print(c.astype(float)) # [1. 3.]

Handling String and Object Dtypes

Strings in NumPy are stored as fixed-width Unicode sequences, not Python str objects. astype() can convert between string lengths and between strings and numbers.

python
nums = np.array([10, 20, 30]) str_arr = nums.astype(str) print(str_arr) # ['10' '20' '30'] print(str_arr.dtype) # <U2 for this input

The string dtype length is determined by the longest converted value in the array.

Converting strings back to numbers works if the strings are parseable. If any string cannot be parsed, NumPy raises a ValueError.

python
mixed = np.array(['1', '2', 'abc']) try: mixed.astype(float) except ValueError as e: print(e) # could not convert string to float: 'abc'

Object dtype is a fallback for arrays that contain Python objects. Converting an object array to a numeric type attempts to call the appropriate conversion on each element. This is slower than native numeric conversions but allows mixed types.

python
obj_arr = np.array([1, '2', 3.5], dtype=object) print(obj_arr.astype(float)) # [1. 2. 3.5]

Be cautious with object arrays: they lose the performance benefits of NumPy because operations fall back to Python-level loops.

Converting to and from datetime64 and timedelta64

NumPy's datetime64 and timedelta64 dtypes store dates and time deltas as integers with a specified unit. astype() can change the unit, which is useful for aligning data with different resolutions.

python
dates = np.array(['2023-01-01', '2023-01-02'], dtype='datetime64[D]') print(dates.astype('datetime64[s]')) # convert days to seconds

Converting datetime64 to an integer yields the underlying count from the Unix epoch. The unit of the integer depends on the datetime unit.

python
print(dates.astype(np.int64)) # [19358 19359] (days since 1970-01-01)

To convert back, you must specify the unit explicitly, otherwise NumPy will assume nanoseconds.

python
ints = np.array([19358, 19359]) print(ints.astype('datetime64[D]')) # ['2023-01-01' '2023-01-02']

Timedelta64 conversions follow similar rules. Changing units can be lossy if the target unit is coarser than the source, such as converting nanoseconds to days.

Performance and Memory: When astype Copies Data

astype() creates a new array by default, which means it allocates new memory and copies the data element by element. For large arrays, this can be a significant cost. If you are converting just to read the data in a different format, consider whether you can avoid the copy.

np.asarray(existing_array, dtype=...) can avoid a copy when the input already has the requested dtype. If the dtype differs, it still performs a conversion and allocates a new array.

Another approach is using np.ndarray.view() when you only need to reinterpret the bytes without changing the underlying values. This is only safe when the new dtype has the same itemsize and the memory layout is compatible.

python
arr = np.array([1, 2, 3], dtype=np.int32) view = arr.view(np.float32) print(view) # reinterpreted bytes, not a real conversion

This is rarely what you want for type conversion because it reinterprets the raw bits rather than converting the logical values. Use it only when you understand the binary representation.

In-place conversion is not supported by astype(). If you want to reuse the same variable, assign the result back; the old array will eventually be freed if no other references exist.

python
arr = arr.astype(np.float64) # old array becomes garbage collectable

Common Pitfalls: Lossy Conversions and NaN Handling

Converting from a higher precision float to a lower one, like float64 to float32, rounds the value. This is usually acceptable but can cause problems in calculations that require high precision.

NaN and infinity are representable in floating-point conversions, but converting either one to an integer dtype is not a mathematically meaningful conversion. Recent NumPy versions generally raise a ValueError for NaN; older versions may produce arbitrary results.

python
arr = np.array([1.0, np.nan, 3.0]) try: arr.astype(int) except ValueError as e: print(e) # cannot convert float NaN to integer

If you need to handle NaN before conversion, fill or remove those values explicitly.

Another pitfall is converting between signed and unsigned integers. Negative values become large positive numbers when cast to unsigned types.

python
signed = np.array([-1, 2]) print(signed.astype(np.uint32)) # [4294967295 2]

Always check the range of your data before converting to a narrower type.

Alternatives to astype: np.array(), dtype=, and view()

When creating a new array from existing data, you can pass the dtype parameter to np.array() to convert during construction.

python
data = [1.5, 2.5, 3.5] arr = np.array(data, dtype=np.int32) print(arr) # [1 2 3]

This avoids creating an intermediate array compared with constructing the array and then calling astype(). However, it only works when you are building a new array from a Python sequence or another array.

For in-place type changes, there is no direct method. You must reassign the variable. If you have multiple references to the same array, be aware that reassigning one variable does not affect the others.

python
a = np.array([1, 2, 3]) b = a a = a.astype(np.float64) print(b.dtype) # int64 (b still points to the original array)

view() is not a general-purpose conversion tool; it reinterprets memory. It can be useful for structured dtypes or when you need byte-level reinterpretation, but it does not change the logical values.

For most use cases, astype() is the correct choice because it is explicit and well-documented. The main decision is whether you can afford the copy. If you are working with very large arrays and need to convert frequently, consider whether the conversion is necessary at all, or whether you can design your pipeline to use a consistent dtype from the start.

Try matching browser tools

All tools

Small utilities that fit Python work — they run entirely in this browser tab, so nothing you paste leaves your device.

All Python guides

More in Python

All Python guides

The guides filed next to this one in Python, in library order.