Python create array from 1 to n with step

Asked 9 years, 1 month ago

Viewed 1.6m times

How do I create an ascending list between two values? For example, a list between 11 and 16:

[11, 12, 13, 14, 15, 16]

Mateen Ulhaq

22.2k16 gold badges86 silver badges127 bronze badges

asked Aug 16, 2013 at 4:43

Use range. In Python 2, it returns a list directly:

>>> range[11, 17]
[11, 12, 13, 14, 15, 16]

In Python 3, range is an iterator. To convert it to a list:

>>> list[range[11, 17]]
[11, 12, 13, 14, 15, 16]

Note: The second number in range[start, stop] is exclusive. So, stop = 16+1 = 17.

To increment by steps of 0.5, consider using numpy's arange[] and .tolist[]:

>>> import numpy as np
>>> np.arange[11, 17, 0.5].tolist[]

[11.0, 11.5, 12.0, 12.5, 13.0, 13.5,
 14.0, 14.5, 15.0, 15.5, 16.0, 16.5]

See: How do I use a decimal step value for range[]?

Mateen Ulhaq

22.2k16 gold badges86 silver badges127 bronze badges

answered Aug 16, 2013 at 4:47

JaredJared

24.6k7 gold badges52 silver badges61 bronze badges

9

You seem to be looking for range[]:

>>> x1=11
>>> x2=16
>>> range[x1, x2+1]
[11, 12, 13, 14, 15, 16]
>>> list1 = range[x1, x2+1]
>>> list1
[11, 12, 13, 14, 15, 16]

For incrementing by 0.5 instead of 1, say:

>>> list2 = [x*0.5 for x in range[2*x1, 2*x2+1]]
>>> list2
[11.0, 11.5, 12.0, 12.5, 13.0, 13.5, 14.0, 14.5, 15.0, 15.5, 16.0]

answered Aug 16, 2013 at 4:46

devnulldevnull

113k33 gold badges227 silver badges216 bronze badges

1

Try:

range[x1, x2+1]  

That is a list in Python 2.x and behaves mostly like a list in Python 3.x. If you are running Python 3 and need a list that you can modify, then use:

list[range[x1, x2+1]]

ah bon

8,3897 gold badges49 silver badges104 bronze badges

answered Aug 16, 2013 at 4:49

Mike HouskyMike Housky

3,8711 gold badge16 silver badges30 bronze badges

If you are looking for range like function which works for float type, then here is a very good article.

def frange[start, stop, step=1.0]:
    ''' "range[]" like function which accept float type''' 
    i = start
    while i < stop:
        yield i
        i += step
# Generate one element at a time.
# Preferred when you don't need all generated elements at the same time. 
# This will save memory.
for i in frange[1.0, 2.0, 0.5]:
    print i   # Use generated element.
# Generate all elements at once.
# Preferred when generated list ought to be small.
print list[frange[1.0, 10.0, 0.5]]    

Output:

1.0
1.5
[1.0, 1.5, 2.0, 2.5, 3.0, 3.5, 4.0, 4.5, 5.0, 5.5, 6.0, 6.5, 7.0, 7.5, 8.0, 8.5, 9.0, 9.5]

answered Mar 15, 2016 at 3:21

Rajesh SuranaRajesh Surana

7931 gold badge9 silver badges15 bronze badges

1

assuming you want to have a range between x to y

range[x,y+1]

>>> range[11,17]
[11, 12, 13, 14, 15, 16]
>>>

use list for 3.x support

answered Aug 16, 2013 at 4:47

v2bv2b

1,4169 silver badges14 bronze badges

Use list comprehension in python. Since you want 16 in the list too.. Use x2+1. Range function excludes the higher limit in the function.

list=[x for x in range[x1, x2+1]]

ah bon

8,3897 gold badges49 silver badges104 bronze badges

answered Aug 16, 2013 at 4:46

4

In python you can do this very eaisly

start=0
end=10
arr=list[range[start,end+1]]
output: arr=[0,1,2,3,4,5,6,7,8,9,10]

or you can create a recursive function that returns an array upto a given number:

ar=[]
def diff[start,end]:
    if start==end:
        d.append[end]
        return ar
    else:
        ar.append[end]
        return diff[start-1,end] 

output: ar=[10,9,8,7,6,5,4,3,2,1,0]

answered Jun 4, 2019 at 19:01

I got here because I wanted to create a range between -10 and 10 in increments of 0.1 using list comprehension. Instead of doing an overly complicated function like most of the answers above I just did this

simple_range = [ x*0.1 for x in range[-100, 100] ]

By changing the range count to 100 I now get my range of -10 through 10 by using the standard range function. So if you need it by 0.2 then just do range[-200, 200] and so on etc

answered Aug 3, 2020 at 21:25

JoseJose

1,51117 silver badges19 bronze badges

The most elegant way to do this is by using the range function however if you want to re-create this logic you can do something like this :

def custom_range[*args]:
    s = slice[*args]
    start, stop, step = s.start, s.stop, s.step
    if 0 == step:
        raise ValueError["range[] arg 3 must not be zero"]
    i = start
    while i < stop if step > 0 else i > stop:
        yield i
        i += step

>>> [x for x in custom_range[10, 3, -1]]

This produces the output:

[10, 9, 8, 7, 6, 5, 4]

As expressed before by @Jared, the best way is to use the range or numpy.arrange however I find the code interesting to be shared.

answered Jan 11, 2018 at 11:22

MichaelMichael

2,2721 gold badge32 silver badges53 bronze badges

2

Every answer above assumes range is of positive numbers only. Here is the solution to return list of consecutive numbers where arguments can be any [positive or negative], with the possibility to set optional step value [default = 1].

def any_number_range[a,b,s=1]:
""" Generate consecutive values list between two numbers with optional step [default=1]."""
if [a == b]:
    return a
else:
    mx = max[a,b]
    mn = min[a,b]
    result = []
    # inclusive upper limit. If not needed, delete '+1' in the line below
    while[mn < mx + 1]:
        # if step is positive we go from min to max
        if s > 0:
            result.append[mn]
            mn += s
        # if step is negative we go from max to min
        if s < 0:
            result.append[mx]
            mx += s
    return result

For instance, standard command list[range[1,-3]] returns empty list [], while this function will return [-3,-2,-1,0,1]

Updated: now step may be negative. Thanks @Michael for his comment.

answered Dec 4, 2017 at 15:42

Denis RasulevDenis Rasulev

3,4164 gold badges33 silver badges41 bronze badges

5

While @Jared's answer for incrementing works for 0.5 step size, it fails for other step sizes due to rounding issues:

np.arange[11, 17, 0.1].tolist[]
# [11.0,11.1,11.2,11.299999999999999, ...   16.79999999999998, 16.899999999999977]

Instead I needed something like this myself, working not just for 0.5:

# Example 11->16 step 0.5
s = 11
e = 16
step = 0.5
my_list = [round[num, 2] for num in np.linspace[s,e,[e-s]*int[1/step]+1].tolist[]]
# [11.0, 11.5, 12.0, 12.5, 13.0, 13.5, 14.0, 14.5, 15.0, 15.5, 16.0]

# Example 0->1 step 0.1
s = 0
e = 1
step = 0.1
my_list = [round[num, 2] for num in np.linspace[s,e,[e-s]*int[1/step]+1].tolist[]]
# [0.0, 0.1, 0.2, 0.3, 0.4, 0.5, 0.6, 0.7, 0.8, 0.9, 1.0]

answered Jun 18, 2020 at 13:50

YTZYTZ

7276 silver badges22 bronze badges

@YTZ's answer worked great in my case. I had to generate a list from 0 to 10000 with a step of 0.01 and simply adding 0.01 at each iteration did not work due to rounding issues.

Therefore, I used @YTZ's advice and wrote the following function:

import numpy as np


def generate_floating_numbers_in_range[start: int, end: int, step: float]:
    """
    Generate a list of floating numbers within a specified range.

    :param start: range start
    :param end: range end
    :param step: range step
    :return:
    """
    numbers = np.linspace[start, end,[end-start]*int[1/step]+1].tolist[]
    return [round[num, 2] for num in numbers]

answered Oct 1, 2021 at 13:13

How do you create an array from 1 to N in Python?

How do you create an array from 1 to 10 in Python?

How do you create an array of numbers in Python?

How do you create a list from 1 to 100 in Python?