Hoe zou ik een lijst maken met waarden tussen twee waarden die ik invoer?
De volgende lijst wordt bijvoorbeeld gegenereerd voor waarden van 11 tot 16:
list = [11, 12, 13, 14, 15, 16]
Antwoord 1, autoriteit 100%
Gebruik range. In Python 2.x retourneert het een lijst, dus alles wat je nodig hebt is:
>>> range(11, 17)
[11, 12, 13, 14, 15, 16]
In Python 3.x rangeis een iterator. Je moet het dus naar een lijst converteren:
>>> list(range(11, 17))
[11, 12, 13, 14, 15, 16]
Opmerking: het tweede nummer is exclusief. Dus hier moet het 16+1= 17
zijn
BEWERKEN:
Om de vraag over het verhogen met 0.5te beantwoorden, is de gemakkelijkste optie waarschijnlijk het gebruik van numpy’sarange()en .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]
Antwoord 2, autoriteit 3%
Het lijkt erop dat u op zoek bent naar 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]
Voor ophogen met 0.5in plaats van 1, zeg:
>>> 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]
Antwoord 3
Probeer:
range(x1,x2+1)
Dat is een lijst in Python 2.x en gedraagt zich meestal als een lijst in Python 3.x. Als je Python 3 gebruikt en een lijst nodig hebt die je kunt wijzigen, gebruik dan:
list(range(x1,x2+1))
Antwoord 4
Als u op zoek bent naar een bereikachtige functie die werkt voor het float-type, dan is hier een zeer goede artikel.
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))
Uitvoer:
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]
Antwoord 5
Gebruik lijstbegrip in python. Omdat je er ook 16 in de lijst wilt.. Gebruik x2+1. Bereikfunctie sluit de hogere limiet in de functie uit.
list=[x voor x binnen bereik(x1,x2+1)]
Antwoord 6
ervan uitgaande dat u een bereik tussen x en y wilt hebben
range(x,y+1)
>>> range(11,17)
[11, 12, 13, 14, 15, 16]
>>>
lijst gebruiken voor 3.x-ondersteuning
Antwoord 7
In python kun je dit heel gemakkelijk doen
start=0
end=10
arr=list(range(start,end+1))
output: arr=[0,1,2,3,4,5,6,7,8,9,10]
of je kunt een recursieve functie maken die een array retourneert tot een bepaald getal:
ar=[]
def diff(start,end):
if start==end:
d.append(end)
return ar
else:
ar.append(end)
return diff(start-1,end)
uitvoer:
ar=[10,9,8,7,6,5,4,3,2,1,0]
Antwoord 8
Elk antwoord hierboven gaat ervan uit dat het bereik alleen uit positieve getallen bestaat. Hier is de oplossing om een lijst met opeenvolgende getallen te retourneren waar argumenten elk kunnen zijn (positief of negatief), met de mogelijkheid om een optionele stapwaarde in te stellen (standaard = 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
Bijvoorbeeld, het standaardcommando list(range(1,-3))retourneert een lege lijst [], terwijl deze functie [-3,-2,-1,0,1]
Bijgewerkt: stap nu kan negatief zijn. Bedankt @Michael voor zijn commentaar.
Antwoord 9
Ik kwam hier omdat ik een bereik tussen -10 en 10 wilde creëren in stappen van 0,1 met behulp van lijstbegrip. In plaats van een al te ingewikkelde functie uit te voeren, zoals de meeste van de bovenstaande antwoorden, deed ik dit gewoon
simple_range = [ x*0.1 for x in range(-100, 100) ]
Door het aantal bereik te wijzigen in 100, krijg ik nu mijn bereik van -10 tot en met 10 door de standaard bereikfunctie te gebruiken. Dus als je het met 0.2 nodig hebt, doe dan gewoon bereik (-200, 200) enzovoort enz.
Antwoord 10
De meest elegante manier om dit te doen is door de functie rangete gebruiken, maar als je deze logica opnieuw wilt creëren, kun je zoiets als dit doen:
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)]
Dit levert de uitvoer op:
[10, 9, 8, 7, 6, 5, 4]
Zoals eerder aangegeven door @Jared, is de beste manier om het rangeof numpy.arrangete gebruiken, maar ik vind de code interessant om te delen.
Antwoord 11
Hoewel @Jared’s antwoord voor ophogen werkt voor stapgrootte 0.5, mislukt het voor andere stapgroottes vanwege afrondingsproblemen:
np.arange(11, 17, 0.1).tolist()
# [11.0,11.1,11.2,11.299999999999999, ... 16.79999999999998, 16.899999999999977]
In plaats daarvan had ik zelf zoiets nodig, niet alleen voor 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]