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,3697 gold badges48 silver badges100 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
7831 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,3697 gold badges48 silver badges100 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,49117 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,2621 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,3764 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 badges21 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