Python - 2 değer arasında sayılar içeren bir liste oluşturulsun mu?

Girdiğim iki değer arasındaki değerleri içeren bir listeyi nasıl oluştururum? Örneğin, 11'den 16'ya kadar olan değerler için aşağıdaki liste oluşturulur:

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

Kullanın range. Python 2.x'te bir liste döndürür, böylece ihtiyacınız olan tek şey:

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

Python 3.x rangebir yineleyici olduğunu. Yani, bir listeye dönüştürmeniz gerekir:

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

Not : İkinci sayı özeldir. Yani, burada olması gerekiyor 16+1=17

DÜZENLE:

Arttırma ile ilgili soruya cevap vermek için en 0.5kolay seçenek muhtemelen numpy arange() ve .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]

Görünüşe göre 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]

0.5Bunun yerine artırmak için 1:

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

Deneyin:

range(x1,x2+1)  

Bu, Python 2.x'teki bir listedir ve çoğunlukla Python 3.x'teki bir liste gibi davranır. Python 3 çalıştırıyorsanız ve değiştirebileceğiniz bir listeye ihtiyacınız varsa, şunu kullanın:

list(range(x1,x2+1))

Şamandıra tipi için çalışan işlev gibi bir aralık arıyorsanız, işte burada çok iyi bir makale .

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

Çıktı:

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]

Python'da liste kavrayışı kullanın. Listede de 16 olmasını istediğinizden .. x2 + 1 kullanın. Aralık işlevi, işlevin üst sınırını hariç tutar.

list = [aralıktaki x için x (x1, x2 + 1)]

x ile y arasında bir aralık olmasını istediğinizi varsayarsak

range(x,y+1)

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

3.x desteği için listeyi kullan

Python'da bunu çok rahat yapabilirsiniz

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

veya belirli bir sayıya kadar bir dizi döndüren özyinelemeli bir işlev oluşturabilirsiniz:

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

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

Bunu yapmanın en zarif yolu rangeişlevi kullanmaktır, ancak bu mantığı yeniden oluşturmak istiyorsanız, böyle bir şey yapabilirsiniz:

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

Bu çıktıyı üretir:

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

@Jared tarafından daha önce ifade edildiği gibi, en iyi yolu kullanmak rangeveya numpy.arrangeancak paylaşılması ilginç kodu bulmak.

Yukarıdaki her cevabın menzilin sadece pozitif sayılar olduğu varsayılmaktadır. Burada, bağımsız değişkenlerin herhangi bir (pozitif veya negatif) olabileceği ve isteğe bağlı adım değerini (varsayılan = 1) ayarlama imkanı olan ardışık sayıların listesini döndürme çözümü.

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

Örneğin, standart komut list(range(1,-3))boş liste döndürürken [], bu işlev geri döner[-3,-2,-1,0,1]

Güncellendi : şimdi adım negatif olabilir. @Michael yorumu için teşekkürler.

@ Jared'in artış için cevabı 0.5adım boyutu için çalışırken , yuvarlama sorunları nedeniyle diğer adım boyutları için başarısız olur:

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

Bunun yerine, sadece kendim için değil, böyle bir şeye ihtiyacım vardı 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]