Een lijst in omgekeerde volgorde afdrukken met bereik()?

Hoe kun je de volgende lijst maken met range()in Python?

[9, 8, 7, 6, 5, 4, 3, 2, 1, 0]

Antwoord 1, autoriteit 100%

gebruik de functie reversed():

reversed(range(10))

Het is veel zinvoller.

Bijwerken:

Als je wilt dat het een lijst is (zoals btk aangaf):

list(reversed(range(10)))

Bijwerken:

Als u alleen rangewilt gebruiken om hetzelfde resultaat te bereiken, kunt u alle parameters gebruiken. range(start, stop, step)

Als u bijvoorbeeld een lijst [5,4,3,2,1,0]wilt genereren, kunt u het volgende gebruiken:

range(5, -1, -1)

Het is misschien minder intuïtief, maar zoals de opmerkingen vermelden, is dit efficiënter en het juiste gebruik van bereik voor omgekeerde lijst.

Antwoord 2, autoriteit 49%

Gebruik de ingebouwde functie ‘bereik’. De handtekening is range(start, stop, step). Dit levert een reeks op die getallen oplevert, beginnend met starten eindigend als stopis bereikt, met uitzondering van stop.

>>> range(9,-1,-1)   
    [9, 8, 7, 6, 5, 4, 3, 2, 1, 0]
>>> range(-2, 6, 2)
    [-2, 0, 2, 4]

In Python 3 produceert dit een niet-lijst range-object, dat in feite functioneert als een alleen-lezen lijst (maar veel minder geheugen gebruikt, vooral voor grote bereiken).

Antwoord 3, autoriteit 8%

Je zou range(10)[::-1]kunnen gebruiken, wat hetzelfde is als range(9, -1, -1)en waarschijnlijk beter leesbaar is (als je bekend bent met de algemene sequence[::-1]Python-idioom).

Antwoord 4, autoriteit 5%

Voor degenen die geïnteresseerd zijn in de “efficiëntie” van de tot nu toe verzamelde opties…

Het antwoord van Jaime RGPbracht me ertoe mijn computer opnieuw op te startenna timingde ietwat “uitdagende” oplossing van Jasondie letterlijk mijn eigen suggestie volgt (via commentaar). Om de nieuwsgierigen van jullie de downtime te besparen, presenteer ik hier mijn resultaten (worst-first):

Jasons antwoord(misschien gewoon een uitstapje naar de kracht van lijstbegrip):

$ python -m timeit "[9-i for i in range(10)]"
1000000 loops, best of 3: 1.54 usec per loop

Martineau’s antwoord(leesbaar als je bekend bent met de syntaxis voor uitgebreide segmenten):

$ python -m timeit "range(10)[::-1]"
1000000 loops, best of 3: 0.743 usec per loop

Michal Srajer’s antwoord(de geaccepteerde, zeer leesbaar):

$ python -m timeit "reversed(range(10))"
1000000 loops, best of 3: 0.538 usec per loop

bene’s antwoord(het allereerste, maar erg schetsmatige op dat moment):

$ python -m timeit "range(9,-1,-1)"
1000000 loops, best of 3: 0.401 usec per loop

De laatste optie is gemakkelijk te onthouden met behulp van de range(n-1,-1,-1)notatie van Val Neekman.

Antwoord 5, autoriteit 2%

for i in range(8, 0, -1)

zal dit probleem oplossen. Het zal 8 tot 1 uitvoeren en -1 betekent een omgekeerde lijst

Antwoord 6, autoriteit 2%

Het heeft geen zin om reversete gebruiken omdat de functie rangeeen omgekeerde lijst kan retourneren.

Als je meer dan nitems hebt en de volgorde van de geretourneerde lijst wilt vervangen door range(start, stop, step), moet je derde parameter gebruiken van het bereik dat stepidentificeert en stel het in op -1, andere parameters zullen dienovereenkomstig worden aangepast:

1. Geef de parameter stopop als -1(de vorige waarde van stop - 1, stopwas gelijk aan 0).
2. Gebruik als startparameter n-1.

Dus het equivalent van range(n)in omgekeerde volgorde zou zijn:

n = 10
print range(n-1,-1,-1) 
#[9, 8, 7, 6, 5, 4, 3, 2, 1, 0]

Antwoord 7

Afgezien van de leesbaarheid, lijkt reversed(range(n))sneller te zijn dan range(n)[::-1].

$ python -m timeit "reversed(range(1000000000))"
1000000 loops, best of 3: 0.598 usec per loop
$ python -m timeit "range(1000000000)[::-1]"
1000000 loops, best of 3: 0.945 usec per loop

Als iemand zich dat afvroeg 🙂

Antwoord 8

Een veel gestelde vraag is of range(9, -1, -1)beter is dan reversed(range(10))in Python 3? Mensen die in andere talen met iterators hebben gewerkt, hebben onmiddellijk de neiging om te denken dat reversed() alle waarden in de cache moet opslaan en vervolgens in omgekeerde volgorde moet terugkeren. Het punt is dat de reversed()-operator van Python niet werkt als het object slechts een iterator is. Het object moet een van de onderstaande twee hebben om reversed() te laten werken:

1. Ondersteunt ofwel len()en integer-indexen via []
2. Of heb de methode __reversed__()geïmplementeerd.

Als u reversed() probeert te gebruiken op een object dat geen van bovenstaande heeft, krijgt u:

>>> [reversed((x for x in range(10)))]
TypeError: 'generator' object is not reversible

Kortom, Python’s reversed()is alleen bedoeld voor array-achtige objecten en zou dus dezelfde prestaties moeten hebben als voorwaartse iteratie.

Maar hoe zit het met range()? Is dat geen generator? In Python 3 is het een generator, maar verpakt in een klasse die beide bovenstaande implementeert. Dus range(100000)neemt niet veel geheugen in beslag, maar ondersteunt toch efficiënt indexeren en terugdraaien.

Dus samengevat kun je reversed(range(10))gebruiken zonder prestatieverlies.

Antwoord 9

De vereiste in deze vraag vereist een listvan gehele getallen van 10 in aflopend
volgorde. Laten we dus een lijst maken in python.

# This meets the requirement.
# But it is a bit harder to wrap one's head around this. right?
>>> range(10-1, -1, -1)
[9, 8, 7, 6, 5, 4, 3, 2, 1, 0]
# let's find something that is a bit more self-explanatory. Sounds good?
# ----------------------------------------------------
# This returns a list in ascending order.
# Opposite of what the requirement called for.
>>> range(10)
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
# This returns an iterator in descending order.
# Doesn't meet the requirement as it is not a list.
>>> reversed(range(10))
<listreverseiterator object at 0x10e14e090>
# This returns a list in descending order and meets the requirement
>>> list(reversed(range(10)))
[9, 8, 7, 6, 5, 4, 3, 2, 1, 0]

Antwoord 10

U kunt omgekeerde nummers afdrukken met range() BIF Like ,

for number in range ( 10 , 0 , -1 ) :
    print ( number ) 

Uitvoer zal zijn
[10,9,8,7,6,5,4,3,2,1]

bereik() – bereik ( begin, einde, verhogen/verlagen)
waarbij start inclusief is, einde exclusief is en ophoging elk willekeurig getal kan zijn en zich gedraagt ​​als stap

Antwoord 11

range(9,-1,-1)
[9, 8, 7, 6, 5, 4, 3, 2, 1, 0]

Antwoord 12

Gebruik zonder [::-1] of omgekeerd –

def reverse(text):
    result = []
    for index in range(len(text)-1,-1,-1):
        c = text[index]
        result.append(c)
    return ''.join(result)
print reverse("python!")

Antwoord 13

ik geloof dat dit kan helpen,

range(5)[::-1]

hieronder staat het gebruik:

for i in range(5)[::-1]:
    print i 

Antwoord 14

Ik dacht dat velen (zoals ikzelf) meer geïnteresseerd zouden kunnen zijn in een veelvoorkomend geval van het doorlopen van een bestaande lijst in omgekeerde volgordein plaats daarvan, zoals in de titel wordt vermeld, in plaats van alleen indices te genereren voor dergelijke traverse.

Hoewel alle juiste antwoorden in dit geval prima zijn, wil ik erop wijzen dat de prestatievergelijking in Wolf’s antwoordis alleen voor het genereren van indices. Dus ik heb een vergelijkbare benchmark gemaakt voor het doorlopen van een bestaande lijst in omgekeerde volgorde.

TL;DRa[::-1]is de snelste.

NB: Als je een meer gedetailleerde analyse wilt van verschillende omkeringsalternatieven en hun prestaties, bekijk dan dit geweldige antwoord.

Vereisten:

a = list(range(10))

Jasons antwoord:

%timeit [a[9-i] for i in range(10)]
1.27 µs ± 61.5 ns per loop (mean ± std. dev. of 7 runs, 1000000 loops each)

Martineau’s antwoord:

%timeit a[::-1]
135 ns ± 4.07 ns per loop (mean ± std. dev. of 7 runs, 10000000 loops each)

Het antwoord van Michal Srajer:

%timeit list(reversed(a))
374 ns ± 9.87 ns per loop (mean ± std. dev. of 7 runs, 1000000 loops each)

bene’s antwoord:

%timeit [a[i] for i in range(9, -1, -1)]
1.09 µs ± 11.1 ns per loop (mean ± std. dev. of 7 runs, 1000000 loops each)

Zoals je ziet, is het in dit geval niet nodig om expliciet indexen te genereren, dus de snelste methode is degene die minder extra acties uitvoert.

NB: ik heb getest in JupyterLab, dat een handig “magisch commando” %timeitheeft. Het gebruikt standaard timeit.timeitonder de motorkap. Getest voor Python 3.7.3

Antwoord 15

[9-i for i in range(10)]
[9, 8, 7, 6, 5, 4, 3, 2, 1, 0]

Antwoord 16

Je hoeft niet per se de bereikfunctie te gebruiken, je kunt gewoon list[::-1] doen, waardoor de lijst snel in omgekeerde volgorde wordt geretourneerd, zonder toevoegingen.

Antwoord 17

Stel dat je een lijst hebt, noem het maar
een={1,2,3,4,5}
Als u de lijst nu omgekeerd wilt afdrukken, gebruikt u gewoon de volgende code.

a.reverse
for i in a:
   print(i)

Ik weet dat je het met bereik hebt gevraagd, maar het is al beantwoord.

Antwoord 18

omdat range(n)een iterable produceert, zijn er allerlei leuke dingen die je kunt doen die het gewenste resultaat opleveren, zoals:

range(n)[::-1]

Als lussen in orde zijn, kunnen we een soort wachtrij maken:

a = []
for i in range(n):
    a.insert(0,a)
return a

of gebruik de methode reverse() erop:

reverse(range(n))

Antwoord 19

range(9,-1,-1)
    [9, 8, 7, 6, 5, 4, 3, 2, 1, 0]

Is de juiste vorm. Als u

reversed(range(10))

u krijgt geen 0-case. Stel bijvoorbeeld dat uw 10 geen magisch getal is en een variabele die u gebruikt om omgekeerd te zoeken. Als uw n-geval 0 is, wordt reversed(range(0)) niet uitgevoerd, wat verkeerd is als u toevallig een enkel object in de nul-index heeft.