Lijsten in Python

In dit artikel zullen we lijsten in Python uitleggen.

Je kunt verschillende bewerkingen op lijsten leren en lijstbegrip begrijpen met behulp van codevoorbeelden.

YouTube Video

Lijsten in Python

In Python wordt de datastructuur die vaak een array wordt genoemd, meestal geïmplementeerd als een 'lijst'. Python-lijsten zijn zeer flexibel en staan de volgende bewerkingen toe:.

Een lijst maken

1# Create an empty list
2my_list = []
3print(my_list)
4
5# Create a list with elements
6my_list = [1, 2, 3, 4, 5]
7print(my_list)

• Je kunt een lijst aanmaken die leeg is of waarin beginelementen zijn opgegeven.

Toegang krijgen tot en wijzigen van lijst-elementen

1my_list = [1, 2, 3, 4, 5]
2print(my_list)  # [1, 2, 3, 4, 5]
3
4element = my_list[0]  # Get the element at index 0
5print(element)  # 1
6
7my_list[1] = 10  # Change the element at index 1 to 10
8print(my_list)  # [1, 10, 3, 4, 5]

• Lijstelementen kunnen benaderd of gewijzigd worden door hun index op te geven.

De lengte van een lijst bepalen

1my_list = [1, 2, 3, 4, 5]
2
3length = len(my_list)
4print(my_list)
5print(length)

• Met de functie len() kun je het aantal elementen ophalen.

Elementen toevoegen of invoegen in een lijst

1my_list = [1, 2, 3, 4, 5]
2
3my_list.append(6)
4print(my_list)

• Met de append() methode kun je een element aan het einde van een lijst toevoegen.

1my_list = [1, 2, 3, 4, 5]
2
3my_list.insert(2, "A")  # Insert "A" at index 2
4print(my_list)

• Met de insert() methode kun je een element op elke positie invoegen.

Elementen verwijderen uit een lijst

1my_list = [1, 2, 3, 4, 5]
2
3del my_list[2]  # Delete the element at index 2
4print(my_list)
5
6removed_element = my_list.pop(0)  # Delete and return the element at index 0
7print(removed_element)
8print(my_list)

• Met de del instructie of de pop() methode kun je een element op een bepaalde positie verwijderen. De pop() methode retourneert het verwijderde element.

1my_list = [1, 2, 3, 4, 5]
2
3my_list.remove(5)  # Remove the first occurrence of 5 from the list
4print(my_list)

• Met de remove() methode kun je de eerste voorkomens van een opgegeven waarde verwijderen.

Lijst-slicing

1my_list = [1, 2, 3, 4, 5]
2
3print(my_list[1:3])  # [2, 3]
4print(my_list[:3])   # [1, 2, 3]
5print(my_list[2:])   # [3, 4, 5]
6print(my_list[:])    # [1, 2, 3, 4, 5]

• Met de slicing-syntaxis [start:end] haal je elementen van start tot en met end - 1 op. Je kunt ook start of end weglaten.

Een lijst sorteren

1my_list = [2, 1, 5, 4, 3]
2print(my_list)  # [2, 1, 5, 4, 3]
3
4my_list.sort()  # Sort in ascending order (modifies the list)
5print(my_list)  # [1, 2, 3, 4, 5]
6
7my_list.sort(reverse=True)  # Sort in descending order
8print(my_list)  # [5, 4, 3, 2, 1]

• De sort() methode kan een lijst oplopend of aflopend sorteren.

1my_list = [3, 1, 4, 2]
2sorted_list = sorted(my_list)
3print(my_list)       # [3, 1, 4, 2]
4print(sorted_list)   # [1, 2, 3, 4]

• Met de sorted() functie kun je een nieuwe gesorteerde lijst maken zonder de originele lijst te wijzigen.

Een omgekeerde lijst maken

1my_list = [1, 2, 3, 4, 5]
2
3my_list.reverse()
4print(my_list)

• De reverse() methode kan de volgorde van elementen in een lijst omkeren.

Lijstcomprehensie

In Python kun je de krachtige list comprehension syntaxis gebruiken om lijsten beknopt te genereren. List comprehensions stellen je in staat om het proces van het genereren van nieuwe lijsten met for-loops in één regel te schrijven. Je kunt ook voorwaarden gebruiken om alleen specifieke elementen te selecteren.

 1# Generate squares of numbers from 0 to 9
 2squares = [x**2 for x in range(10)]
 3print(squares)  # [0, 1, 4, 9, 16, 25, 36, 49, 64, 81]
 4
 5# Use a condition to extract squares of even numbers only
 6even_squares = [x**2 for x in range(10) if x % 2 == 0]
 7print(even_squares)  # [0, 4, 16, 36, 64]
 8
 9# Store either the square or the original number based on a condition
10squares_or_original = [x**2 if x % 2 == 0 else x for x in range(10)]
11print(squares_or_original)
12# Output: [0, 1, 4, 3, 16, 5, 36, 7, 64, 9]

• Met list comprehensions kun je op een beknopte manier nieuwe lijsten maken met lussen en voorwaarden. Door gebruik te maken van if en if-else, kun je lijst-comprehensies maken die elementen extraheren of verschillende waarden genereren op basis van voorwaarden.

Lijsten samenvoegen

 1# Concatenate two lists using the + operator
 2a = [1, 2, 3]
 3b = [4, 5, 6]
 4combined = a + b
 5print(combined)  # [1, 2, 3, 4, 5, 6]
 6
 7# Extend an existing list with another list
 8a = [1, 2, 3]
 9b = [4, 5, 6]
10a.extend(b)
11print(a)  # [1, 2, 3, 4, 5, 6]
12
13# Concatenate multiple lists using unpacking (*)
14a = [1, 2, 3]
15b = [4, 5, 6]
16c = [7, 8, 9]
17merged = [*a, *b, *c]
18print(merged)  # [1, 2, 3, 4, 5, 6, 7, 8, 9]

• In Python kun je lijsten samenvoegen met de +-operator, de extend()-methode of unpacking-syntaxis (*). Het is gebruikelijk om + of * te gebruiken bij het maken van een nieuwe lijst, en extend() bij het bijwerken van een bestaande lijst.

Samenvatting

Lijsten zijn een fundamentele datastructuur in Python en worden in veel situaties gebruikt. Er zijn veel flexibele en nuttige mogelijkheden, en door deze goed te beheersen wordt programmeren efficiënter.

Je kunt het bovenstaande artikel volgen met Visual Studio Code op ons YouTube-kanaal. Bekijk ook het YouTube-kanaal.

YouTube Video