Show Sidebar Hide Sidebar


An Arange NumPy array is an array of equally spaced values determined by a step size between values.

New to Plotly?

Plotly's Python library is free and open source! Get started by downloading the client and reading the primer.
You can set up Plotly to work in online or offline mode, or in jupyter notebooks.
We also have a quick-reference cheatsheet (new!) to help you get started!


This tutorial imports Plotly and Numpy.

In [1]:
import plotly.plotly as py
import plotly.graph_objs as go

import numpy as np

Simple Example

We can use np.arange() to create an array of values starting from the start value and incrementally going up to end value by incrementing up by the step value. step is by default set to 1. It is very similar to np.linspace as both output arrays which start and stop at given values and with a certain number of values in the array, or rather, with a step size that gets us from the start to the end.

In [2]:
np.arange(0, 10)
array([0, 1, 2, 3, 4, 5, 6, 7, 8, 9])

Making a Plot

In [3]:
import plotly.plotly as py
import plotly.graph_objs as go

x = np.arange(0, 100)
y = np.arange(0, 200, 2)

trace = go.Scatter(x=x, y=y, mode='markers')
py.iplot([trace], filename='numpy-arange')
In [4]:
Help on built-in function arange in module numpy.core.multiarray:

    arange([start,] stop[, step,], dtype=None)
    Return evenly spaced values within a given interval.
    Values are generated within the half-open interval ``[start, stop)``
    (in other words, the interval including `start` but excluding `stop`).
    For integer arguments the function is equivalent to the Python built-in
    `range <>`_ function,
    but returns an ndarray rather than a list.
    When using a non-integer step, such as 0.1, the results will often not
    be consistent.  It is better to use ``linspace`` for these cases.
    start : number, optional
        Start of interval.  The interval includes this value.  The default
        start value is 0.
    stop : number
        End of interval.  The interval does not include this value, except
        in some cases where `step` is not an integer and floating point
        round-off affects the length of `out`.
    step : number, optional
        Spacing between values.  For any output `out`, this is the distance
        between two adjacent values, ``out[i+1] - out[i]``.  The default
        step size is 1.  If `step` is specified, `start` must also be given.
    dtype : dtype
        The type of the output array.  If `dtype` is not given, infer the data
        type from the other input arguments.
    arange : ndarray
        Array of evenly spaced values.
        For floating point arguments, the length of the result is
        ``ceil((stop - start)/step)``.  Because of floating point overflow,
        this rule may result in the last element of `out` being greater
        than `stop`.
    See Also
    linspace : Evenly spaced numbers with careful handling of endpoints.
    ogrid: Arrays of evenly spaced numbers in N-dimensions.
    mgrid: Grid-shaped arrays of evenly spaced numbers in N-dimensions.
    >>> np.arange(3)
    array([0, 1, 2])
    >>> np.arange(3.0)
    array([ 0.,  1.,  2.])
    >>> np.arange(3,7)
    array([3, 4, 5, 6])
    >>> np.arange(3,7,2)
    array([3, 5])

Still need help?
Contact Us

For guaranteed 24 hour response turnarounds, upgrade to a Developer Support Plan.