Understanding Lists in Python 3

Inleiding

A list is a data structure in Python that is a mutable, or changeable, ordered sequence of elements. Each element or value that is inside of a list is called an item. Just as strings are defined as characters between quotes, lists are defined by having values between square brackets [ ].

Lists zijn geweldig om te gebruiken wanneer je met veel gerelateerde waarden wilt werken. Ze stellen je in staat om gegevens bij elkaar te houden die bij elkaar horen, je code te condenseren, en dezelfde methoden en bewerkingen uit te voeren op meerdere waarden tegelijk.

Als je nadenkt over Python-lijsten en andere gegevensstructuren die typen verzamelingen zijn, is het handig om alle verschillende verzamelingen op je computer te overwegen: je assortiment bestanden, je afspeellijsten van nummers, je bladwijzers in je browser, je e-mails, de verzameling video’s die je kunt bekijken op een streamingdienst, en meer.

Vereisten

Je moet Python 3 geïnstalleerd hebben en een programmeeromgeving op je computer of server hebben opgezet. Als je nog geen programmeeromgeving hebt opgezet, kun je verwijzen naar de installatie- en setupgidsen voor een lokale programmeeromgeving of voor een programmeeromgeving op je server die geschikt is voor je besturingssysteem (Ubuntu, CentOS, Debian, enz.).

String-lijsten

Om te beginnen, laten we een lijst maken die items van het type string bevat:

sea_creatures = ['shark', 'cuttlefish', 'squid', 'mantis shrimp', 'anemone']

Wanneer we de lijst afdrukken, reageert de uitvoer precies zoals de lijst die we hebben gemaakt:

print(sea_creatures)

Output
['shark', 'cuttlefish', 'squid', 'mantis shrimp', 'anemone']

Als een geordende reeks elementen kan elk item in een lijst individueel worden aangeroepen via indexering. Lijsten zijn een samengesteld gegevenstype bestaande uit kleinere onderdelen, en zijn zeer flexibel omdat ze waarden kunnen hebben die worden toegevoegd, verwijderd en gewijzigd. Als u veel waarden moet opslaan of over waarden moet itereren, en u die waarden gemakkelijk wilt kunnen wijzigen, wilt u waarschijnlijk met lijstgegevenstypen werken.

In deze zelfstudie zullen we enkele manieren doornemen waarop we met lijsten kunnen werken in Python.

Indexering van lijsten

Elk item in een lijst komt overeen met een indexnummer, dat een geheel getal is en begint met het indexnummer 0.

Voor de lijst zee_wezens ziet de indexindeling er als volgt uit:

Het eerste item, de string 'shark', begint op index 0, en de lijst eindigt op index 4 met het item 'anemoon'.

Omdat elk item in een Python-lijst een overeenkomstig indexnummer heeft, kunnen we lijsten op dezelfde manier benaderen en manipuleren als andere opeenvolgende gegevenstypen.

Nu kunnen we een afzonderlijk item van de lijst oproepen door te verwijzen naar zijn indexnummer:

print(sea_creatures[1])

Output
cuttlefish

De indexnummers voor deze lijst lopen van 0 tot 4, zoals weergegeven in de bovenstaande tabel. Dus om elk van de items afzonderlijk aan te roepen, zouden we naar de indexnummers verwijzen zoals dit:

sea_creatures[0] = 'shark'
sea_creatures[1] = 'cuttlefish'
sea_creatures[2] = 'squid'
sea_creatures[3] = 'mantis shrimp'
sea_creatures[4] = 'anemone'

Als we de lijst zee_dieren oproepen met een indexnummer dat groter is dan 4, zal dit buiten bereik zijn omdat het niet geldig zal zijn:

print(sea_creatures[18])

Output
IndexError: list index out of range

Naast positieve indexnummers kunnen we ook items uit de lijst benaderen met een negatief indexnummer, door terug te tellen vanaf het einde van de lijst, te beginnen bij -1. Dit is vooral handig als we een lange lijst hebben en we een item naar het einde van een lijst willen aanwijzen.

Voor dezelfde lijst zee_dieren ziet de negatieve indexverdeling er als volgt uit:

Dus, als we het item 'inktvis' willen afdrukken door zijn negatieve indexnummer te gebruiken, kunnen we dat als volgt doen:

print(sea_creatures[-3])

Output
squid

We kunnen stringitems in een lijst samenvoegen met andere strings met behulp van de +-operator:

print('Sammy is a ' + sea_creatures[0])

Output
Sammy is a shark

We konden het string-item op indexnummer 0 concateneren met de string 'Sammy is a '. We kunnen ook de +-operator gebruiken om 2 of meer lijsten samen te voegen.

Met indexnummers die overeenkomen met items binnen een lijst, kunnen we elk item van een lijst afzonderlijk benaderen en ermee werken.

Items wijzigen in lijsten

We kunnen indexering gebruiken om items binnen de lijst te veranderen, door een indexnummer gelijk te stellen aan een andere waarde. Dit geeft ons meer controle over lijsten omdat we in staat zijn om de items die ze bevatten te wijzigen en bij te werken.

Als we de stringwaarde van het item op index 1 van 'cuttlefish' naar 'octopus' willen veranderen, kunnen we dat als volgt doen:

sea_creatures[1] = 'octopus'

Nu zal wanneer we sea_creatures afdrukken, de lijst anders zijn:

print(sea_creatures)

Output
['shark', 'octopus', 'squid', 'mantis shrimp', 'anemone']

We kunnen ook de waarde van een item wijzigen door in plaats daarvan een negatief indexnummer te gebruiken:

sea_creatures[-3] = 'blobfish'
print(sea_creatures)

Output
['shark', 'octopus', 'blobfish', 'mantis shrimp', 'anemone']

Nu is 'blobfish' vervangen door 'squid' op het negatieve indexnummer van -3 (dat overeenkomt met het positieve indexnummer van 2).

Het kunnen wijzigen van items in lijsten geeft ons de mogelijkheid om lijsten op een efficiënte manier te wijzigen en bij te werken.

Snijden van lijsten

We kunnen ook enkele items uit de lijst halen. Laten we zeggen dat we alleen de middelste items van sea_creatures willen afdrukken, dat kunnen we doen door een slice te maken. Met slices kunnen we meerdere waarden oproepen door een reeks indexnummers te maken gescheiden door een dubbele punt [x:y]:

print(sea_creatures[1:4])

Output
['octopus', 'blobfish', 'mantis shrimp']

Bij het maken van een slice, zoals in [1:4], is het eerste indexnummer waar de slice begint (inclusief), en het tweede indexnummer is waar de slice eindigt (exclusief), daarom zijn in ons voorbeeld hierboven de items op positie 1, 2 en 3 de items die worden afgedrukt.

Als we een van de uiteinden van de lijst willen opnemen, kunnen we een van de getallen weglaten in de list[x:y] syntaxis. Bijvoorbeeld, als we de eerste 3 items van de lijst sea_creatures willen afdrukken – wat 'shark', 'octopus', 'blobfish' zou zijn – kunnen we dat doen door te typen:

print(sea_creatures[:3])

Output
['shark', 'octopus', 'blobfish']

Dit drukte het begin van de lijst af, precies voordat index 3 werd bereikt.

Om alle items aan het einde van een lijst op te nemen, zouden we de syntaxis omkeren:

print(sea_creatures[2:])

Output
['blobfish', 'mantis shrimp', 'anemone']

We kunnen ook negatieve indexnummers gebruiken bij het snijden van lijsten, vergelijkbaar met positieve indexnummers:

print(sea_creatures[-4:-2])
print(sea_creatures[-3:])

Output
['octopus', 'blobfish']
['blobfish', 'mantis shrimp', 'anemone']

Een laatste parameter die we kunnen gebruiken bij slicing wordt stride genoemd, wat verwijst naar hoeveel items vooruit te gaan nadat het eerste item uit de lijst is opgehaald. Tot nu toe hebben we de stride-parameter weggelaten, en Python gebruikt standaard een stride van 1, zodat elk item tussen twee indexnummers wordt opgehaald.

De syntaxis voor deze constructie is lijst[x:y:z], waarbij z verwijst naar de stride. Laten we een grotere lijst maken, deze dan slicen en de stride een waarde van 2 geven:

numbers = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12]

print(numbers[1:11:2])

Output
[1, 3, 5, 7, 9]

Onze constructie getallen[1:11:2] geeft de waarden tussen indexnummers inclusief 1 en exclusief 11 weer, vervolgens vertelt de stride-waarde van 2 het programma om alleen elk ander item af te drukken.

We kunnen de eerste twee parameters weglaten en alleen stride gebruiken als parameter met de syntaxis lijst[::z]:

print(numbers[::3])

Output
[0, 3, 6, 9, 12]

Door de lijst getallen af te drukken met de stride ingesteld op 3, wordt alleen elk derde item afgedrukt:

0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12

Het snijden van lijsten met zowel positieve als negatieve indexnummers en het aangeven van de stride geeft ons de controle om lijsten te manipuleren en de gewenste uitvoer te ontvangen.

Lijsten wijzigen met operators

Operators kunnen worden gebruikt om wijzigingen aan te brengen in lijsten. We zullen de + en * operators en hun samengestelde vormen += en *= bespreken.

De + operator kan worden gebruikt om twee of meer lijsten samen te voegen:

sea_creatures = ['shark', 'octopus', 'blobfish', 'mantis shrimp', 'anemone']
oceans = ['Pacific', 'Atlantic', 'Indian', 'Southern', 'Arctic']

print(sea_creatures + oceans)

Output
['shark', 'octopus', 'blobfish', 'mantis shrimp', 'anemone', 'Pacific', 'Atlantic', 'Indian', 'Southern', 'Arctic']

Omdat de + operator kan samenvoegen, kan deze worden gebruikt om een item (of meerdere) in lijstvorm aan het einde van een andere lijst toe te voegen. Vergeet niet om het item tussen vierkante haken te plaatsen:

sea_creatures = sea_creatures + ['yeti crab']
print (sea_creatures)

Output
['shark', 'octopus', 'blobfish', 'mantis shrimp', 'anemone', 'yeti crab']

De * operator kan worden gebruikt om lijsten te vermenigvuldigen. Misschien moet je kopieën maken van alle bestanden in een map naar een server, of een afspeellijst delen met vrienden – in deze gevallen zou je collecties van gegevens moeten vermenigvuldigen.

Laten we de lijst sea_creatures vermenigvuldigen met 2 en de lijst oceans met 3:

print(sea_creatures * 2)
print(oceans * 3)

Output
['shark', 'octopus', 'blobfish', 'mantis shrimp', 'anemone', 'yeti crab', 'shark', 'octopus', 'blobfish', 'mantis shrimp', 'anemone', 'yeti crab']
['Pacific', 'Atlantic', 'Indian', 'Southern', 'Arctic', 'Pacific', 'Atlantic', 'Indian', 'Southern', 'Arctic', 'Pacific', 'Atlantic', 'Indian', 'Southern', 'Arctic']

Door de * operator te gebruiken kunnen we onze lijsten repliceren met het aantal keren dat we specificeren.

We kunnen ook samengestelde vormen van de + en * operators gebruiken met de toekenningsoperator =. De += en *= samengestelde operators kunnen worden gebruikt om lijsten op een snelle en geautomatiseerde manier in te vullen. Je kunt deze operators gebruiken om lijsten in te vullen met placeholders die je later kunt aanpassen met door de gebruiker geleverde invoer, bijvoorbeeld.

Laten we een item in lijstvorm toevoegen aan de lijst sea_creatures. Dit item zal fungeren als een placeholder, en we willen dit placeholder-item meerdere keren toevoegen. Hiervoor zullen we de += operator gebruiken met een for-lus.

for x in range(1,4):
    sea_creatures += ['fish']
    print(sea_creatures)

Output
['shark', 'octopus', 'blobfish', 'mantis shrimp', 'anemone', 'yeti crab', 'fish']
['shark', 'octopus', 'blobfish', 'mantis shrimp', 'anemone', 'yeti crab', 'fish', 'fish']
['shark', 'octopus', 'blobfish', 'mantis shrimp', 'anemone', 'yeti crab', 'fish', 'fish', 'fish']

Voor elke iteratie van de for-lus wordt een extra lijstitem van 'vis' toegevoegd aan de oorspronkelijke lijst zee_dieren.

De *=-operator gedraagt zich op een vergelijkbare manier:

sharks = ['shark']

for x in range(1,4):
    sharks *= 2
    print(sharks)

Output
['shark', 'shark']
['shark', 'shark', 'shark', 'shark']
['shark', 'shark', 'shark', 'shark', 'shark', 'shark', 'shark', 'shark']

De operatoren + en * kunnen worden gebruikt om lijsten samen te voegen en lijsten te vermenigvuldigen. De samengestelde operatoren += en *= kunnen lijsten samenvoegen en lijsten vermenigvuldigen en de nieuwe identiteit doorgeven aan de oorspronkelijke lijst.

Een item uit een lijst verwijderen

Items kunnen uit lijsten worden verwijderd door gebruik te maken van de del-verklaring. Hiermee wordt de waarde verwijderd op de index die u opgeeft binnen een lijst.

Uit de lijst zee_dieren laten we het item 'octopus' verwijderen. Dit item bevindt zich op de indexpositie 1. Om het item te verwijderen, gebruiken we de del-verklaring en vervolgens roepen we de lijstvariabele aan en de index van dat item:

sea_creatures =['shark', 'octopus', 'blobfish', 'mantis shrimp', 'anemone', 'yeti crab']

del sea_creatures[1]
print(sea_creatures)

Output
['shark', 'blobfish', 'mantis shrimp', 'anemone', 'yeti crab']

Nu staat het item op indexpositie 1, de string 'octopus', niet langer in onze lijst zee_dieren.

We kunnen ook een bereik specificeren met de del-verklaring. Stel dat we niet alleen het item 'octopus', maar ook 'blobvis' en 'mantisgarnaal' willen verwijderen. We kunnen een bereik in zee_dieren aanroepen met de del-verklaring om dit te bereiken:

sea_creatures =['shark', 'octopus', 'blobfish', 'mantis shrimp', 'anemone', 'yeti crab']

del sea_creatures[1:4]
print(sea_creatures)

Output
['shark', 'anemone', 'yeti crab']

Door het gebruik van een bereik met de del-verklaring, konden we de items verwijderen tussen het indexnummer van 1 (inclusief) en het indexnummer van 4 (exclusief), waardoor we een lijst van 3 items overhouden na het verwijderen van 3 items.

De del-verklaring stelt ons in staat om specifieke items te verwijderen uit het lijstgegevenstype.

Het construeren van een lijst met lijstitems

Lijsten kunnen worden gedefinieerd met items die bestaan uit lijsten, waarbij elke ingekaderde lijst binnen de grotere haken van de ouderlijst is geplaatst:

sea_names = [['shark', 'octopus', 'squid', 'mantis shrimp'],['Sammy', 'Jesse', 'Drew', 'Jamie']]

Deze lijsten binnen lijsten worden genoemd geneste lijsten.

Om een item binnen deze lijst te benaderen, moeten we meerdere indices gebruiken:

print(sea_names[1][0])
print(sea_names[0][0])

Output
Sammy
shark

De eerste lijst, omdat deze gelijk is aan een item, zal het indexnummer 0 hebben, wat het eerste nummer in de constructie zal zijn, en de tweede lijst zal het indexnummer 1 hebben. Binnen elke binnenste geneste lijst zullen er aparte indexnummers zijn, die we zullen aanroepen in het tweede indexnummer:

sea_names[0][0] = 'shark'
sea_names[0][1] = 'octopus'
sea_names[0][2] = 'squid'
sea_names[0][3] = 'mantis shrimp'

sea_names[1][0] = 'Sammy'
sea_names[1][1] = 'Jesse'
sea_names[1][2] = 'Drew'
sea_names[1][3] = 'Jamie'

Bij het werken met lijsten van lijsten is het belangrijk om in gedachten te houden dat je meer dan één indexnummer moet raadplegen om specifieke items binnen de relevante geneste lijst te benaderen.

Conclusie

De lijstgegevenstype is een flexibel gegevenstype dat gedurende de loop van je programma kan worden aangepast. Deze zelfstudie behandelt de basisfuncties van lijsten, waaronder indexering, slicen, wijzigen en lijsten samenvoegen.

Vanaf hier kunt u meer te weten komen over het werken met lijsten in Python door “Hoe lijstmethode te gebruiken” te lezen, en over lijstcomprehensies om lijsten te maken op basis van bestaande lijsten. Om meer te leren over gegevenstypen in het algemeen, kunt u onze zelfstudie “Begrip van gegevenstypen” lezen.