Python - Créer une liste avec des nombres entre 2 valeurs?

Comment créer une liste avec des valeurs comprises entre deux valeurs que j'ai saisies? Par exemple, la liste suivante est générée pour les valeurs de 11 à 16:

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

Utilisez range. Dans Python 2.x, il retourne une liste donc tout ce dont vous avez besoin est:

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

En Python 3.x rangeest un itérateur. Donc, vous devez le convertir en liste:

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

Remarque : Le deuxième numéro est exclusif. Donc, ici, il doit être 16+1=17

ÉDITER:

Pour répondre à la question de l'incrémentation de 0.5, l'option la plus simple serait probablement d'utiliser numpy's arange() et .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]

Vous semblez chercher 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]

Pour incrémenter de 0.5au lieu de 1, dites:

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

Essayer:

range(x1,x2+1)  

Il s'agit d'une liste en Python 2.x et se comporte principalement comme une liste en Python 3.x. Si vous exécutez Python 3 et avez besoin d'une liste que vous pouvez modifier, utilisez:

list(range(x1,x2+1))

Si vous recherchez une fonction de type plage qui fonctionne pour le type flottant, voici un très bon 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))    

Production:

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]

Utilisez la compréhension de liste en python. Puisque vous voulez aussi 16 dans la liste. Utilisez x2 + 1. La fonction de plage exclut la limite supérieure de la fonction.

list = [x pour x dans la plage (x1, x2 + 1)]

en supposant que vous vouliez avoir une plage entre x à y

range(x,y+1)

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

utiliser la liste pour le support 3.x

En python, vous pouvez le faire très facilement

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

ou vous pouvez créer une fonction récursive qui renvoie un tableau jusqu'à un nombre donné:

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

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

La façon la plus élégante de le faire est d'utiliser la rangefonction, mais si vous souhaitez recréer cette logique, vous pouvez faire quelque chose comme ceci:

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

Cela produit la sortie:

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

Comme indiqué précédemment par @Jared, la meilleure façon est d'utiliser le rangeou numpy.arrangeje trouve le code intéressant à partager.

Chaque réponse ci-dessus suppose que la plage est uniquement composée de nombres positifs. Voici la solution pour retourner une liste de nombres consécutifs où les arguments peuvent être quelconques (positifs ou négatifs), avec la possibilité de définir une valeur de pas facultative (par défaut = 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

Par exemple, la commande standard list(range(1,-3))renvoie une liste vide [], tandis que cette fonction renvoie[-3,-2,-1,0,1]

Mis à jour : maintenant l'étape peut être négative. Merci @Michael pour son commentaire.