Lijsten en tuples in Python

Een lijst bewaart waarden in een gekozen volgorde. Schrijf de elementen tussen vierkante haakjes, met komma’s ertussen. Elk element heeft een positie, dus ook herhaalde waarden nemen afzonderlijke plaatsen in.

Maak een lijst en bepaal de lengte

scores = [88, 92, 75]
print(scores)
print(len(scores))

Uitvoer:

[88, 92, 75]
3

len() telt elementen, niet de grootste waarde of de laatste positie. Lijsten kunnen verschillende typen bevatten, zoals in [3, "three", 3.0, True], al maakt het bij elkaar houden van verwante gegevens de verwerking meestal eenvoudiger. Zowel [] als list() maakt een lege lijst. De lengte daarvan is 0 en de lijst kan groeien terwijl het programma waarden verzamelt.

list() kan ook de elementen van een itereerbaar object verzamelen: een object dat een for-lus kan doorlopen. list(range(4)) geeft [0, 1, 2, 3]. list("cat") geeft ['c', 'a', 't']: de string levert telkens één teken. Het resultaat is een nieuwe lijst.

Tel posities vanaf nul

Een index duidt één positie aan. Python begint bij 0, dus de drie scores hebben indices 0, 1 en 2.

Negatieve indices tellen terug vanaf het einde. Bij een lijst met lengte n lopen de geldige indices van -n tot en met n - 1. Het laatste element is scores[len(scores) - 1], of eenvoudiger scores[-1]. -0 is nog steeds 0; het betekent niet de laatste positie.

Herken een ongeldige index

scores[3] veroorzaakt IndexError omdat er geen vierde element bestaat. scores[len(scores)] maakt dezelfde fout: het aantal is één groter dan de laatste niet-negatieve index. Een lege lijst heeft geen geldige elementindex, ook -1 niet.

Een lijstindex moet een geheel getal zijn, geen zwevendekommagetal. scores[1.0] veroorzaakt TypeError, ook al heeft 1,0 een gehele waarde. / levert een zwevendekommagetal op, dus scores[len(scores) / 2] gaat ook mis. Bij deze lijst met drie elementen levert len(scores) // 2 het gehele getal 1 op en is scores[1] gelijk aan 92.

Controleer of een waarde voorkomt

Een lidmaatschapscontrole toetst waarden, geen posities:

colors = ["red", "green"]
print("green" in colors)
print("Green" in colors)
print("blue" not in colors)

Uitvoer:

True
False
True

in en not in geven booleaanse waarden terug en werken ook op lege lijsten. Stringvergelijkingen zijn hoofdlettergevoelig, dus "Green" en "green" komen niet overeen. Een lidmaatschapscontrole is nuttig vóór een bewerking waarvoor een waarde aanwezig moet zijn, zoals het verwijderen ervan of het zoeken naar de positie.

Een uitsnede selecteert een reeks elementen en geeft een nieuwe sequentie terug. Bij een lijst is het resultaat een andere lijst, ook als die maar één of geen elementen bevat.

Neem de startwaarde mee en laat de eindgrens weg

letters = ["a", "b", "c", "d", "e", "f"]
print(letters[1:4])

Uitvoer:

['b', 'c', 'd']

De geselecteerde posities zijn 1, 2 en 3. Positie 4 is de exclusieve eindgrens, dus 'e' blijft buiten de uitsnede. Bij een stapgrootte van 1 en grenzen waarvoor 0 <= start <= stop <= len(letters) geldt, is het aantal geselecteerde elementen stop - start. Hier is dat 3. letters[4:2] geeft [] omdat een voorwaartse uitsnede een eerdere eindgrens niet kan bereiken.

Laat een grens weg

Negatieve grenzen tellen vanaf het einde, net als negatieve indices. letters[:n] en letters[n:] verdelen de lijst bij één grens. Als je die twee uitsneden samenvoegt, bouw je de inhoud weer op in de oorspronkelijke volgorde.

Bepaal de stapgrootte

De volledige vorm is values[start:stop:step]. Een stapgrootte van 2 selecteert een positie, slaat er één over en selecteert de volgende. letters[::2] geeft ['a', 'c', 'e'], terwijl letters[1::2] de lijst ['b', 'd', 'f'] geeft.

Een negatieve stapgrootte gaat achteruit. letters[::-1] begint bij het laatste element en levert ['f', 'e', 'd', 'c', 'b', 'a'] op. Voor een achterwaartse uitsnede met grenzen doorloopt letters[4:1:-1] de indices 4, 3 en 2 en geeft ['e', 'd', 'c']; de eindgrens blijft uitgesloten. Een stapgrootte van 0 veroorzaakt ValueError, omdat die niet naar een andere positie kan gaan.

Maak onderscheid tussen een grens en een positie

Uitsnedegrenzen mogen voorbij beide uiteinden liggen. Python brengt ze terug tot de uiteinden: letters[4:100] is ['e', 'f'] en letters[10:] is []. Deze uitsneden veroorzaken geen IndexError. Het afzonderlijke element letters[10] uitlezen doet dat wel.

letters[2] is de string 'c'. letters[2:3] is de lijst ['c']. De dubbele punt verandert het soort resultaat, wat van belang is als latere code een string of een lijst verwacht.

Werk met het resultaat

Na first_three = letters[:3] wijzigt de toekenning first_three[0] = "z" alleen die nieuwe buitenste lijst; letters[0] blijft 'a'. Een volledige uitsnede is een ondiepe kopie, dus geneste wijzigbare elementen kunnen nog steeds worden gedeeld.

Voor strings en tuples gelden dezelfde regels voor grenzen en stapgrootte. Het resultaat behoudt het oorspronkelijke sequentietype: "python"[1:4] geeft 'yth' en (10, 20, 30)[1:] geeft (20, 30).

Lijsten ondersteunen operatoren om sequenties op te bouwen en functies om kengetallen van hun waarden te berekenen. Ga na of een bewerking een nieuwe lijst maakt, een getal oplevert of tekst teruggeeft: die resultaten dienen verschillende doelen.

Voeg lijsten samen of herhaal ze

+ voegt twee lijsten samen en maakt een nieuwe lijst. [1, 2] + [3] geeft [1, 2, 3] zonder een van beide invoerlijsten te wijzigen. Beide operanden moeten lijsten zijn: [1, 2] + 3 veroorzaakt TypeError. Zet bij gebruik van + een afzonderlijke extra waarde in een lijst met één element.

* herhaalt de sequentie. [0] * 4 geeft [0, 0, 0, 0] en ["ab", "cd"] * 2 geeft ['ab', 'cd', 'ab', 'cd']. De operator herhaalt elementen, niet de tekens binnen elke string. Een herhalingsaantal van nul of minder geeft []. counts = [0] * 7 levert zeven tellers met een beginwaarde op. Als je een binnenlijst herhaalt, wordt die op meerdere posities gedeeld. Dat is van belang als je die rijen later wijzigt.

Totaal, uitersten en gemiddelde

sum() telt getallen op. De functie voegt geen strings samen; sum(["a", "b"]) veroorzaakt TypeError. min() en max() vinden het kleinste en grootste element, dus moeten de elementen onderling vergelijkbaar zijn. Lijsten met alleen strings werken: max(["pear", "apple"]) geeft 'pear' door de ordening teken voor teken. Een lege lijst heeft geen minimum of maximum en veroorzaakt bij beide aanroepen ValueError.

Het rekenkundig gemiddelde is het totaal gedeeld door het aantal elementen:

temps = [18.5, 21.0, 19.5, 23.0]
if temps:
    total = sum(temps)
    mean = total / len(temps)
    print(total, mean)

Uitvoer:

82.0 20.5

De voorwaarde werkt omdat lege lijsten als onwaar en niet-lege lijsten als waar gelden. Zonder de beschermende voorwaarde zou het berekenen van het gemiddelde van [] door nul delen en ZeroDivisionError veroorzaken. Kies wat het programma moet doen als er geen metingen zijn, bijvoorbeeld None teruggeven.

Vergelijk sequenties op volgorde

== controleert of elementen op overeenkomstige posities gelijk zijn. [1, 2, 3] == [1, 2, 3] is True; [1, 2, 3] == [3, 2, 1] is False.

Vergelijk bij < en > vanaf links en stop bij het eerste ongelijke paar. [2, 9] < [3, 0] is True omdat 2 kleiner is dan 3. De 9 en 0 bepalen niets. Als de ene lijst het begin van een andere is, komt de kortste eerst: [2] < [2, 0] is True.

Wissel tussen tekst en lijsten

colors = "red,green,blue".split(",")
print(colors)
print(", ".join(["red", "green"]))

Uitvoer:

['red', 'green', 'blue']
red, green

split() splitst een string bij de scheidingstekst. join() wordt op de scheidingstekst aangeroepen en plaatst die tussen de opgegeven strings. Elk element moet een string zijn. Om getallen samen te voegen, maak je eerst een lijst met hun str()-resultaten; als je [1, 2] rechtstreeks aan join() doorgeeft, veroorzaakt dat TypeError.

Lijsten zijn wijzigbaar: een programma kan hun inhoud na het maken veranderen. Een methode hoort bij een object en wordt met een punt aangeroepen, zoals in cart.append("eggs"). Het effect op de lijst en de retourwaarde zijn twee afzonderlijke zaken.

Voeg één of meerdere elementen toe

cart = ["milk"]
cart.append("eggs")
cart.extend(["tea", "jam"])
print(cart)

Uitvoer:

['milk', 'eggs', 'tea', 'jam']

append(x) voegt precies één element aan het einde toe. Als x een lijst is, wordt die hele lijst één genest element. Als je begint met ['milk', 'eggs'], levert cart.append(["tea", "jam"]) de lijst ['milk', 'eggs', ['tea', 'jam']] met lengte 3 op.

extend(iterable) voegt de elementen van het itereerbare object afzonderlijk toe. Uitbreiden met ["tea", "jam"] maakt de lengte van de boodschappenlijst 4. Uitbreiden met "ab" voegt 'a' en 'b' afzonderlijk toe; voeg de string met append toe om 'ab' als één element te behouden.

insert(i, x) voegt een element toe vóór de huidige positie i. Na nums = [10, 30] en nums.insert(1, 20) is de lijst [10, 20, 30]. Latere elementen schuiven naar rechts. insert(0, x) voegt aan het begin toe; een index voorbij het einde voegt aan het einde toe zonder indexfout.

Verwijder op positie of waarde

Bij nums = [10, 20, 30] bewaart last = nums.pop() de waarde 30 en blijft [10, 20] over. Daarna geeft nums.pop(0) de waarde 10 terug en blijft [20] over. Een lege lijst of ongeldige positie zorgt dat pop() IndexError veroorzaakt.

remove() gebruikt een waarde. Bij pets = ["cat", "dog", "cat"] blijft na pets.remove("cat") de lijst ['dog', 'cat'] over. Alleen de eerste overeenkomst verdwijnt. Als de waarde ontbreekt, veroorzaakt remove() ValueError. Gebruik een lidmaatschapscontrole als de waarde afwezig kan zijn. Gebruik het volgende om elke 'cat' te verwijderen:

while "cat" in pets:
    pets.remove("cat")

Bij [5, 0, 7] verwijdert remove(0) de waarde 0 en blijft [5, 7] over; pop(0) verwijdert de waarde op positie 0 en geeft [0, 7]. De betekenis van het argument bepaalt de methode.

del kan een bereik verwijderen: vanuit [5, 6, 7, 8] laat del nums[1] de lijst [5, 7, 8] over en daarna laat del nums[0:2] de lijst [8] over. clear() maakt de bestaande lijst leeg.

Houd de retourwaarde goed in de gaten

append, extend, insert, remove en clear geven None terug. Schrijf cart.append("tea") op een eigen regel. Als je cart = cart.append("tea") schrijft, laat je cart naar None verwijzen; een latere cart.append("jam") veroorzaakt AttributeError. Sla een resultaat van een methode alleen op als het een waarde oplevert die het programma nodig heeft, zoals last = cart.pop() doet.

Een waarde zoeken, tellen en vervangen zijn verschillende bewerkingen. Gebruik een lidmaatschapscontrole als je een ja-of-neeantwoord nodig hebt, een zoekmethode als je een positie nodig hebt en een toekenning als je de lijst wilt wijzigen.

Zoek de eerste overeenkomende positie

days = ["Mon", "Tue", "Wed", "Tue"]
print(days.index("Tue"))
print(days.index("Tue", 2))
print(days.count("Tue"))
print(days.count("Sun"))

Uitvoer:

1
3
2
0

index(x) geeft de eerste positie terug die een waarde gelijk aan x bevat. Het optionele startargument vertelt Python waar de zoekactie moet beginnen. days.index("Tue", 2) slaat de overeenkomst op positie 1 over en vindt die op positie 3. Het antwoord blijft een index in de hele lijst, geen telling vanaf het nieuwe startpunt.

index() veroorzaakt ValueError als de waarde ontbreekt. Lijsten hebben geen methode find() die -1 teruggeeft. Als een waarde mogelijk ontbreekt, controleer dan eerst of ze aanwezig is:

if "Sun" in days:
    position = days.index("Sun")
    print(position)

Deze code toont niets omdat 'Sun' ontbreekt. count(x) kan zonder die beschermende controle worden gebruikt: de methode geeft 0 terug als er geen overeenkomsten zijn. Deze bewerkingen gebruiken gelijkheid, dus [1, 2.0].count(2) is 1. Bij tekst blijven hoofdletters en kleine letters van belang: 'tue' is niet gelijk aan 'Tue'.

Vervang één bestaand element

prices = [4.5, 3.0, 7.25]
prices[1] = 3.5
print(prices)

Uitvoer:

[4.5, 3.5, 7.25]

De oude tweede waarde wordt overschreven en de lengte blijft 3. De index moet bestaan: prices[3] = 1.0 veroorzaakt IndexError. Gebruik append() om aan het einde toe te voegen.

Vervangen gebruikt een bestaande plaats. Invoegen maakt een extra plaats vóór de geselecteerde positie.

Vervang een bereik met toekenning aan een uitsnede

nums = [1, 2, 3, 4, 5]
nums[1:3] = [20, 30, 40]
print(nums)
nums[0:2] = []
print(nums)

Uitvoer:

[1, 20, 30, 40, 4, 5]
[30, 40, 4, 5]

De eerste toekenning vervangt de twee elementen op indices 1 en 2 door drie nieuwe elementen, waardoor de lijst één element groeit. Een gewone aaneengesloten uitsnede kan worden vervangen door een kortere of langere sequentie. De toekenning van [] verwijdert het geselecteerde bereik. Dit wijzigt de oorspronkelijke lijst; dat verschilt van een uitsnede uitlezen in een nieuwe variabele.

Bewerk tekst door nieuwe tekst te maken

Een string is onwijzigbaar, dus word = "cat" gevolgd door word[0] = "b" veroorzaakt TypeError. Maak een nieuwe string met word = "b" + word[1:], of maak een lijst met tekens, wijzig die en voeg de tekens samen:

letters = list("cat")
letters[0] = "b"
word = "".join(letters)
print(word)

Uitvoer:

bat

Een lus kan de waarden van een lijst, de posities of beide gebruiken. Kies de vorm die levert wat de lusinhoud nodig heeft. Controleer bij een wijziging van de lijst ook of de instructie een element wijzigt of alleen een lokale naam herbindt.

Gebruik elementen rechtstreeks

for name in ["Ana", "Ben"]:
    print("Hi", name)

Uitvoer:

Hi Ana
Hi Ben

De lus doorloopt elk element op volgorde. Bij elke doorgang verwijst name naar het huidige element. Een andere waarde aan name toekennen vervangt dat element in de lijst niet. In for r in readings: r = 0 verandert alleen de naam r.

Gebruik posities om elementen te vervangen

readings = [3, -1, 4, -5]
for i in range(len(readings)):
    if readings[i] < 0:
        readings[i] = 0
print(readings)

Uitvoer:

[3, 0, 4, 0]

range(len(readings)) levert 0, 1, 2 en 3. Bij index 1 is de voorwaarde waar, dus vervangt de elementtoekenning -1. Bij index 3 vervangt die -5. Positieve metingen behouden hun waarde. Met range(len(readings) + 1) zou ook index 4 worden bereikt, die niet bestaat.

Verkrijg een positie en een element samen

enumerate() levert paren. Pak elk paar uit in de luskop:

for i, name in enumerate(["Ana", "Ben"]):
    print(i, name)

Uitvoer:

0 Ana
1 Ben

enumerate(names, start=1) levert labels vanaf 1 voor een genummerde weergave. Die labels zijn niet langer de indices van de lijst die bij nul beginnen. Gebruik for item in reversed(names): om van het laatste naar het eerste element te gaan zonder de lijst te wijzigen. Gebruik voor achterwaartse indices range(len(names) - 1, -1, -1); een lijst met drie elementen geeft 2, 1, 0.

Koppel twee lijsten

names = ["Ana", "Ben"]
scores = [90, 85]
for name, score in zip(names, scores):
    print(name, score)

Uitvoer:

Ana 90
Ben 85

zip() koppelt elementen op overeenkomstige posities en stopt bij de kortste invoer. Als elk record meetelt, controleer dan de lengtes voordat je hierop vertrouwt; een laatste naam zonder bijbehorende score wordt anders overgeslagen.

Stuur een index met while

Een while-lus heeft een startindex, een grenscontrole en een stap nodig:

i = 0
while i < len(readings):
    print(readings[i])
    i += 1

Als je de verhoging vergeet, kan deze lus niet eindigen. Met <= bereik je len(readings) en veroorzaak je IndexError.

Voorkom verschuivende elementen tijdens een for-lus

Elementen verwijderen verandert de posities van de elementen die erop volgen. Als je bij [1, 2, 2, 3] elke aangetroffen 2 verwijdert terwijl je diezelfde lijst doorloopt, blijft [1, 2, 3] over: de tweede 2 schuift naar de positie die net is bezocht. Doorloop nums[:] als verwijderingen effect moeten hebben op het origineel, of maak een nieuwe lijst met de elementen die je wilt behouden. Ook elementen toevoegen aan de lijst die wordt doorlopen kan ervoor zorgen dat de lus zich onverwacht gedraagt.

Veel lijstproblemen gebruiken enkele herbruikbare luspatronen. Bepaal welk resultaat het programma nodig heeft, stel dat resultaat vóór de lus in en werk het bij wanneer elk element langskomt.

Houd een totaal of aantal bij

sales = [120, 75, 205, 50]
total = 0
for sale in sales:
    total += sale
print(total)

Uitvoer:

450

Het lopende totaal wordt 120, 195, 400 en 450. Als je total = 0 binnen de lus instelt, wis je bij elke doorgang het eerdere werk. sum(sales) berekent dit totaal rechtstreeks.

Een teller telt 1 erbij op voor elk element dat voldoet, niet de waarde van het element:

scores = [72, 45, 60, 88, 59]
passed = 0
for score in scores:
    if score >= 60:
        passed += 1
print(passed)

De uitvoer is 3: 72, 60 en 88 voldoen. > 60 zou 2 geven omdat precies 60 wordt uitgesloten. Zorg dat de formulering van de drempelwaarde en de vergelijking met elkaar overeenkomen.

Zoek een uiterste

Initialiseer bij een niet-lege lijst een lopend maximum met een werkelijk element:

temps = [-3, -8, -1, -5]
highest = temps[0]
for temp in temps[1:]:
    if temp > highest:
        highest = temp
print(highest)

De uitvoer is -1. Beginnen bij 0 zou ten onrechte 0 behouden, omdat alle metingen lager zijn. Gebruik < om het minimum te vinden, of gebruik de ingebouwde functies min() en max(). Controleer of de lijst leeg is voordat je het eerste element benadert.

Stop bij de eerste overeenkomst

values = [4, 0, -2, 5, -7]
position = -1
for i, value in enumerate(values):
    if value < 0:
        position = i
        break
print(position)

De uitvoer is 2. -1 is een gekozen signaal voor geen overeenkomst; gebruik het niet als index tenzij de zoekactie is geslaagd, omdat het ook een geldige index voor het laatste element is. break bewaart de eerste overeenkomende positie. Zonder die instructie zouden latere overeenkomsten het resultaat overschrijven.

x in values controleert op één exacte waarde en values.index(x) vindt de eerste positie ervan. Een voorwaarde zoals “is negatief” vereist een zoekactie op basis van een voorwaarde, zoals de lus hierboven.

Filter of transformeer

Een filter behoudt geselecteerde oorspronkelijke elementen:

passing = []
for score in scores:
    if score >= 60:
        passing.append(score)
print(passing)

De uitvoer is [72, 60, 88]; scores behoudt alle vijf elementen. Een transformatie berekent één nieuw element uit elk oorspronkelijk element:

nums = []
for text in ["3", "14", "15"]:
    nums.append(int(text))
print(nums, sum(nums))

De uitvoer is [3, 14, 15] 32. De conversie vindt vóór het optellen plaats; de oorspronkelijke strings optellen gaat mis.

Geef een herbruikbaar resultaat terug

def average(values):
    if not values:
        return None
    return sum(values) / len(values)

average([18.5, 21.0, 19.5, 23.0]) geeft 20.5 terug. Bij een lege lijst geeft de functie None terug zonder door nul te delen, en ze laat de invoerlijst ongewijzigd.

Een geneste lijst is een lijst die andere lijsten bevat. Een tabel gebruikt gewoonlijk één binnenlijst per rij. Elke opzoeking selecteert één niveau, dus zijn twee indices nodig om een cel te lezen.

Selecteer de rij en daarna de cel

grid = [[1, 2, 3], [4, 5, 6]]
print(grid[1])
print(grid[1][2])
print(len(grid), len(grid[0]))

Uitvoer:

[4, 5, 6]
6
2 3

grid[1] selecteert de tweede rij; [2] selecteert daarna het derde element van die rij. len(grid) telt rijen, terwijl len(grid[0]) cellen in de eerste rij telt. Deze rechthoekige tabel heeft zes cellen. grid[2][1] gaat mis bij de eerste opzoeking omdat rij 2 niet bestaat. Als je rij- en kolomposities verwisselt, kun je de verkeerde cel selecteren of IndexError veroorzaken.

Wijzig een cel of een hele rij

grid[0][1] = 20 wijzigt de tweede cel in de eerste rij, wat [[1, 20, 3], [4, 5, 6]] geeft. grid[0] = [0, 0, 0] vervangt de hele eerste rij. Het aantal opzoekingen laat zien welk niveau wordt vervangen.

Doorloop elke waarde

grid = [[1, 2, 3], [4, 5, 6]]
total = 0
for row in grid:
    for value in row:
        total += value
print(total)

Uitvoer:

21

De binnenste lus voltooit de eerste rij voordat de buitenste lus de tweede rij levert. Ze telt 1, 2, 3 en daarna 4, 5, 6 op. Een kolomtotaal gebruikt één vaste positie uit elke rij:

column_total = 0
for row in grid:
    column_total += row[1]
print(column_total)

De uitvoer is 7, afkomstig van 2 en 5. Voor deze code moet elke rij een tweede element hebben.

Rijen hoeven niet even lang te zijn. [[1], [2, 3]] is een geldige geneste lijst. Directe geneste lussen doorlopen nog steeds elke waarde, omdat elke binnenste lus haar eigen rij volgt. Als je aanneemt dat alle rijen len(grid[0]) elementen hebben, mis je hier waarden. Om cellen in zo’n tabel te tellen, tel je len(row) voor elke rij op.

Maak onafhankelijke rijen

table = []
for r in range(3):
    table.append([0] * 4)
table[0][0] = 1
print(table)

Uitvoer:

[[1, 0, 0, 0], [0, 0, 0, 0], [0, 0, 0, 0]]

Elke doorgang maakt een nieuwe lijst met vier elementen. De verkorte vorm [[0] * 4] * 3 herhaalt een referentie naar één rij; als je de eerste cel ervan wijzigt, is dat in alle drie de rijen zichtbaar.

Sla records op

Een rij kan één record beschrijven in plaats van een rij getallen. Bij students = [["Ana", 90], ["Ben", 85]] is students[1][0] gelijk aan 'Ben' en students[1][1] aan 85. Als elk record twee elementen heeft, pakt for name, score in students: ze uit in bruikbare namen. Lijsten met tuples kunnen dezelfde soort records voorstellen.

Een tuple bewaart elementen op volgorde, net als een lijst, maar de elementen op zijn posities kunnen niet worden vervangen, toegevoegd of verwijderd. Dit heet onwijzigbaarheid. Tuples zijn geschikt voor vaste groepen zoals coördinaten, datums en records; lijsten zijn geschikt voor collecties die groeien of veranderen.

Maak en lees een tuple

point = (3, 4)
date = (2024, 7, 15)
print(date[0])
print(date[1:])
print(len(date))

Uitvoer:

2024
(7, 15)
3

Voor indexering, negatieve indices, uitsneden en lidmaatschapscontroles gelden bij tuples dezelfde regels als bij lijsten. Een uitsnede van een tuple geeft een tuple terug. Je kunt een tuple met een lus doorlopen of +, *, min, max, sum, count en index gebruiken als de elementen geschikt zijn voor de bewerking.

De komma maakt een niet-lege tuple. t = 3, 4 maakt ook zonder haakjes (3, 4). Een tuple met één element heeft een afsluitende komma nodig:

list(t) zet de elementen van een tuple om in een wijzigbare lijst.

Begrijp wat niet kan veranderen

point[0] = 5 veroorzaakt TypeError omdat een tuple geen elementtoekenning ondersteunt. Tuples hebben geen methoden append, remove of sort; point.append(5) veroorzaakt AttributeError.

Een naam kan nog wel aan een nieuwe tuple worden gebonden:

point = (3, 4)
point = (5,) + point[1:]
print(point)

De uitvoer is (5, 4). De expressie maakt een nieuwe tuple; ze wijzigt de oude niet.

Een tuple kan een wijzigbaar element bevatten

t = ([1, 2], "x")
t[0].append(3)
print(t)

Uitvoer:

([1, 2, 3], 'x')

De eerste positie bevat nog steeds dezelfde lijst. De inhoud van die lijst is veranderd. t[0] = [9] zou het object op die positie vervangen en is verboden. De onwijzigbaarheid van de buitenste tuple zet een binnenlijst niet vast.

Kies de structuur die bij de taak past

Gebruik (x, y) voor een coördinaat, (255, 128, 0) voor een RGB-kleur of ("Ana", 90) voor een record met twee velden. Elke positie heeft een bepaalde betekenis. Gebruik een lijst voor alle scores van de klas of de artikelen in een winkelwagen, die kunnen groeien en opnieuw worden geordend. Een lijst met tuples, zoals [("Ana", 90), ("Ben", 85)], combineert een wijzigbare collectie met vaste recordposities.

Een tuple met getallen of strings kan als dictionarysleutel dienen, zoals in {(0, 0): "origin"}. Sleutels moeten hashbaar zijn: ze moeten de vaste regels van Python ondersteunen voor het opzoeken via een sleutel. Een lijst is niet hashbaar en een tuple die een lijst bevat ook niet.

Vergelijk tuples

De vergelijking begint links en stopt bij het eerste ongelijke paar. (1, 2, 5) < (1, 3, 0) is True: de eerste waarden zijn gelijk en 2 is kleiner dan 3. Dezelfde regel ordent een lijst met tuplerecords als er geen sleutelfunctie is opgegeven.

Inpakken verzamelt waarden in een tuple. Uitpakken kent de elementen van een itereerbaar object op volgorde toe aan namen. Samen maken ze het mogelijk om velden van een record duidelijke namen te geven en meerdere resultaten van één functie te ontvangen.

Koppel namen aan waarden

record = "Ana", 34, "Lima"
name, age, city = record
print(name, age, city)

Uitvoer:

Ana 34 Lima

Het eerste element wordt name, het tweede age en het derde city. Uitpakken werkt ook bij lijsten en strings: first, second = [10, 20] en a, b, c = "xyz" kennen hun elementen op volgorde toe. user, domain = "ana@example.com".split("@") geeft 'ana' en 'example.com', omdat het splitsen twee delen oplevert.

Zonder naam met een sterretje moeten de aantallen precies overeenkomen. x, y = (1, 2, 3) veroorzaakt ValueError door te veel waarden; x, y, z = (1, 2) veroorzaakt ValueError door te weinig waarden. Python gooit extra elementen niet zonder melding weg.

Verwissel waarden veilig

a = 1
b = 2
a, b = b, a
print(a, b)

De uitvoer is 2 1. Python evalueert de hele rechterkant met de oude waarden voordat een van beide namen links een waarde krijgt. De poging met twee instructies, a = b gevolgd door b = a, verliest de oude waarde van a en maakt beide namen gelijk aan 2.

Verzamel de overige elementen

Een naam met een sterretje krijgt een lijst met de overgebleven waarden:

first, *rest = [5, 6, 7, 8]
print(first, rest)
*init, last = [5, 6, 7, 8]
print(init, last)

Uitvoer:

5 [6, 7, 8]
[5, 6, 7] 8

Het sterretje kan ook tussen namen zonder sterretje staan: first, *middle, last = (5, 6, 7, 8) geeft middle de lijst [6, 7]. Het verzamelde object is altijd een lijst, ook bij het uitpakken van een tuple. head, *rest = [5] laat rest achter als []. Er moeten genoeg elementen zijn voor de namen zonder sterretje en in hetzelfde uitpakpatroon is maar één naam met een sterretje toegestaan.

Pak uit tijdens een lus

for name, score in [("Ana", 90), ("Ben", 85)]:
    print(name, score)

Uitvoer:

Ana 90
Ben 85

De kop pakt elk record uit zodra het wordt geleverd. Zo werken ook for i, item in enumerate(values): en for a, b in zip(left, right):: elke iteratie levert een paar.

Geef meerdere resultaten terug

def min_max(values):
    return min(values), max(values)

low, high = min_max([7, 2, 9])
result = min_max([7, 2, 9])
print(low, high)
print(result)

Uitvoer:

2 9
(2, 9)

De functie geeft één tuple terug. De aanroepende code kan die uitpakken of het hele object bewaren. Een onderstrepingsteken geeft volgens afspraak een naam aan een waarde die de code niet nodig heeft: _, month, day = (2024, 7, 15) bewaart de maand en dag onder beschrijvende namen. _ blijft een gewone variabele en is geen speciale bewerking om iets weg te gooien.

Een variabele is een naam die naar een object verwijst. Een toekenning verandert waarnaar een naam verwijst; ze kopieert het object niet automatisch. Bij een wijzigbare lijst kunnen twee namen daardoor dezelfde wijzigingen laten zien.

Volg de referenties

a = [1, 2, 3]
b = a
b.append(4)
print(a)
print(b)

Uitvoer:

[1, 2, 3, 4]
[1, 2, 3, 4]

Er is één lijst met twee namen. b is een alias van a. De toevoeging wijzigt het gedeelde object, dus zie je het toegevoegde element als je het via een van beide namen leest. Teken bij het volgen van deze code twee pijlen, één vanaf elke naam, naar dezelfde lijst.

Maak onderscheid tussen gelijkheid en identiteit

a = [1, 2]
b = a
c = [1, 2]
print(a == b, a == c)
print(a is b, a is c)

Uitvoer:

True True
True False

== vergelijkt de inhoud; is toetst of de objecten hetzelfde object zijn. c heeft gelijke inhoud, maar is een afzonderlijke lijst. id(x) geeft het identiteitsnummer van een object, dus komt id(a) == id(b) overeen met a is b. Identiteitsnummers vertellen niet welke elementen een lijst bevat.

Gebruik == om te vragen of de inhoud overeenkomt. Gebruik is om te controleren of een object wordt gedeeld of om een speciaal object zoals None te toetsen. Een nieuwe lijstliteral maakt een afzonderlijke lijst, dus is a is [1, 2] onwaar voor een bestaande lijst a, ook als de inhoud overeenkomt.

Mutatie en herbinden hebben een verschillend bereik

Na de laatste instructie verwijst b naar een nieuwe lijst. a blijft naar het oorspronkelijke object verwijzen. Eén naam herbinden leidt niet elke naam om die ooit naar dat object verwees.

Volg += en + afzonderlijk

Bij lijsten breidt += de bestaande lijst uit:

a = [1]
b = a
a += [2]
print(a, b)

De uitvoer is [1, 2] [1, 2]. Ter vergelijking:

a = [1]
b = a
a = a + [2]
print(a, b)

De uitvoer is [1, 2] [1]. + maakt een nieuwe lijst en de toekenning laat a daarnaar verwijzen. b verwijst nog steeds naar de oorspronkelijke lijst met één element.

Zoek minder zichtbare aliassen

row = [0, 0] gevolgd door table = [row, row] slaat dezelfde rij twee keer op. table[0][0] = 5 levert [[5, 0], [5, 0]] op omdat beide posities naar dezelfde binnenlijst verwijzen.

Getallen en strings kunnen niet ter plaatse veranderen. Na x = 5, y = x, x += 1 blijft y gelijk aan 5; x is opnieuw gebonden. Ook de elementposities van een tuple blijven vast, maar een binnenlijst kan veranderen. Na t = ([1], 2), u = t en t[0].append(3) toont u de waarde ([1, 3], 2): beide namen verwijzen nog steeds naar dezelfde tuple en dezelfde wijzigbare lijst daarin.

Kopiëren maakt een nieuw object, maar de diepte van die kopie is van belang. Een nieuwe buitenste lijst kan nog steeds referenties naar de oorspronkelijke binnenlijsten bevatten.

Maak een nieuwe buitenste lijst

a = [1, 2, 3]
b = a.copy()
b.append(4)
print(a)
print(b)
print(a is b)

Uitvoer:

[1, 2, 3]
[1, 2, 3, 4]
False

a[:], list(a) en a.copy() maken allemaal een ondiepe kopie van een lijst. De buitenste container is nieuw en de referenties naar de elementen worden gekopieerd. Bij onwijzigbare getallen of strings laat het vervangen of toevoegen van een element in de ene buitenste lijst de andere ongemoeid.

Bekijk wat een ondiepe kopie deelt

a = [[1, 2], [3, 4]]
b = a.copy()
b[0].append(99)
print(a)
print(b is a, b[0] is a[0])

Uitvoer:

[[1, 2, 99], [3, 4]]
False True

De twee buitenste lijsten verschillen, maar hun eerste elementen verwijzen naar dezelfde binnenlijst. append() wijzigt dat binnenste object.

Een positie in b vervangen is iets anders. Na b[1] = [0] heeft b een andere tweede rij, terwijl a[1] gelijk blijft aan [3, 4]. De toekenning wijzigt één referentie in de buitenste lijst van b; ze wijzigt de oude tweede rij niet.

Kopieer ook geneste lijsten

import copy

a = [[1, 2], [3, 4]]
b = copy.deepcopy(a)
b[0].append(99)
print(a)
print(b)

Uitvoer:

[[1, 2], [3, 4]]
[[1, 2, 99], [3, 4]]

import copy maakt de kopieermodule beschikbaar. copy.deepcopy() kopieert de geneste lijststructuur recursief, zodat wijzigingen aan gekopieerde binnenlijsten het origineel niet bereiken. Gebruik dit wanneer wijzigingen op die binnenste niveaus onafhankelijk moeten zijn. Een ondiepe kopie volstaat als alleen de volgorde of elementreferenties van de buitenste lijst veranderen.

Voorkom herhaalde referenties bij het maken van rijen

table = [[0] * 3] * 2
table[0][0] = 7
print(table)

De uitvoer is [[7, 0, 0], [7, 0, 0]]. De vermenigvuldiging herhaalde de referentie naar één rij. Er zijn geen twee rijen gemaakt.

Maak elke rij binnen de lus:

table = []
for r in range(2):
    table.append([0] * 3)
table[0][0] = 7
print(table)

De uitvoer is [[7, 0, 0], [0, 0, 0]]. [0] * 3 zelf is veilig voor onafhankelijke tellers: gehele getallen kunnen niet worden gewijzigd en elementtoekenning vervangt slechts één positie.

Kies een kopie met een reden

Om de oorspronkelijke volgorde vóór het sorteren te behouden, is een nieuwe buitenste lijst nodig. Om oorspronkelijke geneste metingen te behouden terwijl je gekopieerde cellen wijzigt, zijn ook onafhankelijke binnenlijsten nodig. Verwerking waarbij je alleen leest, heeft geen kopie nodig en bij bewust gedeelde wijzigingen kun je aliassen gebruiken. Controleer bij het onderzoeken van een programmeerfout in een geneste structuur zowel b is a als b[0] is a[0]; als je alleen de buitenste lijsten toetst, mis je gedeelde binnenlijsten.

Een functieparameter is een andere naam voor het object dat de aanroepende code doorgeeft. Een lijstargument wordt niet automatisch gekopieerd. De functie kan dat object wijzigen, haar lokale parameter herbinden of een nieuw resultaat teruggeven; deze acties beïnvloeden de aanroepende code op verschillende manieren.

Een mutatie bereikt de aanroepende code

def add_bonus(scores):
    scores.append(5)

marks = [80]
result = add_bonus(marks)
print(marks)
print(result)

Uitvoer:

[80, 5]
None

scores en marks verwijzen aanvankelijk naar dezelfde lijst. Toevoegen via scores wijzigt die lijst. Omdat de functie geen expliciete return-instructie heeft, is haar resultaat None.

def reset(scores): scores = [] daarentegen herbindt alleen de lokale parameter. De marks van de aanroepende code verwijst nog steeds naar de oude lijst. Gebruik scores.clear() om die gedeelde lijst zelf leeg te maken.

Bewaar zo nodig een teruggegeven lijst

Twee veelgebruikte ontwerpen zijn een lijst ter plaatse wijzigen en None teruggeven, of de lijst ongemoeid laten en een nieuwe lijst teruggeven:

def drop_first(values):
    del values[0]

def tail(values):
    return values[1:]

Bij nums = [1, 2, 3] laat de aanroep drop_first(nums) de waarde van nums achter als [2, 3]. Met nums = drop_first(nums) zou nums daarentegen aan None worden gebonden. Als je opnieuw begint met [1, 2, 3], geeft shorter = tail(nums) aan shorter de lijst [2, 3], terwijl nums ongewijzigd blijft. Als je tail(nums) aanroept zonder het resultaat te bewaren, wordt de nieuwe lijst weggegooid.

Andere ontwerpen zijn ook nuttig: sum() geeft een kengetal terug en pop() wijzigt een lijst en geeft een element terug. Maak het effect en de retourwaarde duidelijk in de naam of docstring van een functie.

Maak een resultaat zonder de invoer te wijzigen

def without_negatives(values):
    kept = []
    for value in values:
        if value >= 0:
            kept.append(value)
    return kept

original = [3, -2, 0, 7]
print(without_negatives(original))
print(original)

Uitvoer:

[3, 0, 7]
[3, -2, 0, 7]

De aanroepende code kan haar buitenste lijst ook beschermen door een ondiepe kopie door te geven, zoals drop_first(original[:]). Voor een bewerking die binnenlijsten wijzigt, moet ook op die niveaus worden gekopieerd.

Voorkom een gedeelde wijzigbare standaardwaarde

def add_item(item, basket=[]):
    basket.append(item)
    return basket

De standaardlijst wordt één keer gemaakt, wanneer de def-instructie wordt uitgevoerd. add_item("a") geeft ['a'] terug en de volgende aanroep met de standaardwaarde, add_item("b"), geeft ['a', 'b'] terug. Gebruik None om een nieuwe lijst te vragen:

def add_item(item, basket=None):
    if basket is None:
        basket = []
    basket.append(item)
    return basket

Elke aanroep zonder winkelmand maakt nu een eigen lijst. Als je een bestaande winkelmand doorgeeft, zijn bewust gedeelde wijzigingen nog steeds mogelijk. Een functie kan een getal of string niet wijzigen en ook de posities van een tuple niet vervangen, maar kan wel een lijst in een tuple wijzigen, bijvoorbeeld door pair[0].append(9) aan te roepen.

Sorteren zet elementen in vergelijkingsvolgorde. Omkeren draait hun huidige volgorde om. Bepaal ook of het programma de bestaande lijst moet wijzigen of die moet behouden en een nieuwe lijst moet ontvangen.

Sorteer ter plaatse of bewaar een nieuwe lijst

nums = [3, 1, 2]
new = sorted(nums)
print(nums)
print(new)
nums.sort()
print(nums)

Uitvoer:

[3, 1, 2]
[1, 2, 3]
[1, 2, 3]

sorted() maakt een nieuwe lijst. sort() is een lijstmethode die de bestaande lijst opnieuw ordent en None teruggeeft. Door nums = nums.sort() verliest de naam zijn referentie naar de lijst en wordt hij aan None gebonden. Schrijf nums.sort() op een eigen regel of gebruik nums = sorted(nums). print(nums.sort()) toont None, ook al is de lijst opnieuw geordend.

sorted() accepteert elk itereerbaar object en geeft altijd een lijst terug. sorted((3, 1, 2)) geeft [1, 2, 3] en sorted("cab") geeft ['a', 'b', 'c']. Strings en tuples hebben geen sort()-methode die ter plaatse werkt.

Aflopende en omgekeerde volgorde

Elke rij begint met de oorspronkelijke lijst. reverse=True vraagt om aflopende vergelijkingsvolgorde en moet met de naam worden opgegeven; sorted(nums, True) veroorzaakt TypeError. Omkeren doorloopt alleen de bestaande posities achteruit en levert dus niet noodzakelijk aflopende waarden op.

Controleer de waarden die worden vergeleken

Getallen worden op getalswaarde gesorteerd, ook als gehele getallen en zwevendekommagetallen door elkaar staan: sorted([2.5, -1, 2]) geeft [-1, 2, 2.5].

Tekst wordt teken voor teken vergeleken. sorted(["10", "9", "100"]) geeft ['10', '100', '9']. Het eerste teken '1' komt vóór '9' en een string die het begin vormt van een langere string, komt vóór die langere string. Zet strings met getallen om met int() of float() als je een numerieke volgorde wilt.

De hoofdletters A–Z komen vóór de kleine letters a–z. sorted(["b", "B", "a"]) geeft ['B', 'a', 'b']. De standaardvolgorde van strings is gebaseerd op tekencodes; het is geen hoofdletterongevoelige woordenboekvolgorde.

Alle elementen die worden vergeleken, moeten onderling < ondersteunen. sorted([3, "two", 1]) veroorzaakt TypeError. Schoon de gegevens op of zet ze om voordat je sorteert.

Gebruik gesorteerde posities

Bij een oneven aantal scores is de middelste waarde na het sorteren gemakkelijk af te lezen:

scores = [72, 95, 64, 88, 79]
ordered = sorted(scores)
median = ordered[len(ordered) // 2]
print(ordered)
print(median)

De uitvoer is [64, 72, 79, 88, 95] gevolgd door 79. De oorspronkelijke lijst bewaart nog steeds de volgorde waarin de scores binnenkwamen. Deze berekening met één middelste element geldt voor niet-lege lijsten met een oneven lengte.

Een sleutelfunctie berekent de vergelijkingswaarde voor elk element. De oorspronkelijke elementen blijven intact in het gesorteerde resultaat. Zo kan een programma tekst op lengte of records op een geselecteerd veld sorteren.

Geef een functie door, geen functieaanroep

words = ["kiwi", "fig", "banana"]
print(sorted(words, key=len))

Uitvoer:

['fig', 'kiwi', 'banana']

Python roept len één keer per element aan en vergelijkt de resulterende lengtes, 4, 3 en 6. Geef key=len door, zonder haakjes. key=len() probeert len direct zonder argument aan te roepen en gaat mis.

Gebruik key=str.lower om met kleine letters te vergelijken. Bij ["banana", "apple", "Cherry"] is de standaardvolgorde ['Cherry', 'apple', 'banana']. Met key=str.lower is het resultaat ['apple', 'banana', 'Cherry']. De oorspronkelijke hoofdletter C blijft in het resultaat staan; alleen de vergelijkingssleutels bestaan uit kleine letters.

Selecteer een recordveld

results = [("Ana", 90), ("Ben", 72), ("Cy", 85)]

def by_score(record):
    return record[1]

print(sorted(results, key=by_score))

Uitvoer:

[('Ben', 72), ('Cy', 85), ('Ana', 90)]

De functie ontvangt telkens één record. record[1] selecteert de score ervan. Voeg reverse=True toe om de hoogste score eerst te zetten. results.sort(key=by_score, reverse=True) gebruikt dezelfde regel, maar wijzigt results zelf.

key=by_score(results) is anders: dit roept de functie aan op de hele lijst en geeft het resultaat door als sleutelargument. Hier is dat resultaat de tuple ('Ben', 72), die niet als functie kan worden aangeroepen, zodat het sorteren TypeError veroorzaakt.

Gebruik meerdere velden

Zonder sleutel vergelijken tuples hun eerste elementen en daarna hun tweede elementen om de volgorde bij gelijke eerste elementen te bepalen. Het sorteren van [("Ben", 72), ("Ana", 90), ("Ana", 85)] geeft [('Ana', 85), ('Ana', 90), ('Ben', 72)].

Een sleutel kan een tuple teruggeven om een andere veldvolgorde te kiezen:

def rank_key(record):
    return (-record[1], record[0])

results = [("Dee", 85), ("Ana", 90), ("Cy", 85)]
print(sorted(results, key=rank_key))

Uitvoer:

[('Ana', 90), ('Cy', 85), ('Dee', 85)]

Door het tegengestelde van de score te nemen, krijgen hogere scores kleinere sleutels. Namen bepalen daarna de oplopende volgorde bij gelijke scores. reverse=True op een positieve sleutel (score, name) zou beide velden omkeren, inclusief de namen, en zou dus niet aan deze regel met verschillende richtingen voldoen.

Behoud de volgorde bij gelijke sleutels

Python sorteert stabiel: elementen met gelijke sleutels behouden hun invoervolgorde. Als je ["bb", "a", "cc", "d"] op len sorteert, krijg je ['a', 'd', 'bb', 'cc']. Bij de twee woorden van één letter blijft 'a' eerst; bij de woorden van twee letters blijft 'bb' eerst. Stabiliteit maakt het ook mogelijk eerst op een secundair veld en daarna op het hoofdveld te sorteren.

Ook min() en max() accepteren sleutelfuncties. max(words, key=len) geeft 'banana' terug, niet de lengte ervan. Bij gelijke sleutels geven deze functies het eerste overeenkomende element terug dat ze tegenkomen.