How would I create a list with values between two values I put in? For example, the following list is generated for values from 11 to 16:

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

Skip to content
# Python – Create list with numbers between 2 values?

## The Question :

*418 people think this question is useful*
*The Question Comments :*
## The Answer 1

*740 people think this answer is useful*
## The Answer 2

*26 people think this answer is useful*
## The Answer 3

*9 people think this answer is useful*
## The Answer 4

*5 people think this answer is useful*
## The Answer 5

*4 people think this answer is useful*
## The Answer 6

*4 people think this answer is useful*
## The Answer 7

*3 people think this answer is useful*
## The Answer 8

*1 people think this answer is useful*
## The Answer 9

*1 people think this answer is useful*
## The Answer 10

*1 people think this answer is useful*
## The Answer 11

*1 people think this answer is useful*
### Related Posts

#### java – Connect4 Code – One Condition Is Always True And Not Able To Get Tie

#### ss – What’s the difference between SCSS and Sass?

#### python – How do I set the figure title and axes labels font size in Matplotlib?

#### About Author

##### moting1a

2021-01-14

How would I create a list with values between two values I put in? For example, the following list is generated for values from 11 to 16:

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

Use `range`

. In Python 2.x it returns a list so all you need is:

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

In Python 3.x `range`

is a iterator. So, you need to convert it to a list:

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

**Note**: The second number is exclusive. So, here it needs to be `16+1`

= `17`

EDIT:

To respond to the question about incrementing by `0.5`

, the easiest option would probably be to use 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]

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]

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))

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]

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)]

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

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]

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.

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.

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]

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