Als beginneer wil u in een recordtempo leren programmeren. Na het leren van de Syntax wordt het dan ook tijd om de eerste (eenvoudige) apps in te oefenen en te programmeren. Daarvoor gaat u het beste opzoek naar leuke Python projects voor beginners.
In dit artikel zetten we 10 verschillende Python projects op een rijtje die voor u, als beginnende programmeur, ideaal zijn om te leren programmeren!
Wat zijn Python projects
Python projects zijn apps en scripts die u met Python kan programmeren. Door deze Python projecten te maken en in te oefenen, kunt u uw programmeervaardigheden trainen.
Uw eerste Python projects omvatten ideaal gezien de Python syntax ‘voor beginners’ en zijn minder dan 100 regels code lang. Onderstaande Python apps voldoen aan die voorwaarden en zijn dan ook perfect om mee te starten!
Python projects voor beginners
Voordat u met deze Python projects aan de slag gaat, willen we u nog een belangrijke tip meegeven:
Probeer eerst zelf de code de schrijven voordat u deze ‘oplossing’ bekijkt. Herhaal deze oefening meerdere keren tot je ze vanbuiten kent of zelf kan programmeren. Na verloop van tijd worden deze vaardigheden beter geïntegreerd en gaat u gelijkaardige uitdagingen beter kunnen programmeren.
Sla deze pagina op in uw favorieten en herhaal zo verschillende keren deze Python oefeningen. Ga niet te snel van de ene naar de andere tutorial, alvorens de oefeningen te beheersen.
Een programma kan ook op verschillende manieren gecodeerd worden. Dit is slechts een ‘voorbeeld’ van een mogelijke app voor het gegeven probleem. Eigen oplossingen, die correct werken, zijn daarom ook prima. Klaar voor de eerste uitdaging? Aan de slag dan maar!
1. Een raadspel programmeren
In deze eerste Python app moet de gebruiker een geheim woord raden. De programmeur heeft in dit voorbeeld al een geheim woord ingegeven.
De speler mag 3 keer een woord raden. Indien dit gelukt is, toont het programma dat de speler gewonnen heeft. In het andere geval stopt het programma en is de speler verloren.
Tips en gebruikte Python code:
- 5 variabelen
- while lus
- 2x ‘if else’
Code
geheim_woord = "buvesa"
gok = ""
gok_teller = 0
gok_limiet = 3
einde_van_gokken = False
while gok != geheim_woord and not einde_van_gokken:
if gok_teller < gok_limiet:
gok = input("Raad het geheim woord: ")
gok_teller += 1
else:
einde_van_gokken = True
if einde_van_gokken:
print("Game over! Je verliest het spel.")
else:
print("Proficiat! Je hebt het geheime woord geraden.")
2. Priemgetallen ontdekken
Een priemgetal is een natuurlijk getal dat enkel door 1 of zichzelf gedeeld kan worden . Deze Python app geeft weer of een ingegeven getal een priemgetal is of niet.
Extra moeilijkheid: Indien het getal geen priemgetal is, wordt de maaltafel van dat getal getoond.
Tip: Gebruik ‘if else’ in combinatie met een ‘For lus’.
Code
getal = int(input("Geef een getal: "))if getal > 1:
for i in range(2, getal):
if (getal % i) == 0:
print(getal, "is geen priemgetal")
print(i, "keer", getal // i, "is", getal)
break
else:
print(getal, "is een priemgetal")else:
print(getal, "is geen priemgetal")
3. Kortingen berekenen
Deze simpele app rekent de prijs uit na aftrek van een ingegeven korting.
Tip: Deze Python code kan geschreven worden met 3 variabelen en 2 input gegevens. Na een simpele wiskundige berekening wordt het resultaat aan de gebruiker getoond.
Code
rekening = int(input("Hoeveel bedraagt de rekening? "))
korting = int(input("Geef het kortingspercentage in: "))
prijs = rekening - (rekening /100 * korting)print("Na aftrek van de korting is de prijs €", prijs)
4. Je BMI berekenen
Je BMI geeft de verhouding tussen je gewicht en lengte aan. De gekende formule hiervoor is gewicht (in kg) / lengte * lengte (in meter).
Tip: Voor het gewicht en de lengte heeft u 2 input gegevens nodig. Vervolgens berekent Python je BMI uit en toont deze op het scherm. Let op: een ‘komma’ wordt in python als een ‘punt’ ingegeven en getoond.
Code
gewicht_kg = int(input("Geef uw gewicht in kilogram: "))
lengte_m = float(input("Geef uw lengte in meter: "))
bmi = gewicht_kg / (lengte_m * lengte_m)print("Uw BMI bedraagt: " + str(bmi) + ".")
5. De rij van Fibonacci
De rij van Fibonacci start met 0 en 1 en telt vervolgens steeds de 2 voorgaande getallen bij elkaar op.
Tip: Maak een functie voor deze getallen en roep ze nadien op via een ‘if statement’ en ‘For lus’.
Code
# fibonacci functie
def fibo(n):
if n <= 1:
return n
else:
return(fibo(n-1) + fibo(n-2))aantal = 10
# Het getal nakijken op een correcte invoer
if aantal <= 0:
print("Geef een positief integer in.")
else:
print("Fibonacci rij:")
for i in range(aantal):
print(fibo(i))
6. Een palindroom programmeren
We spreken van een palindroom wanneer een woord hetzelfde geschreven wordt als het omgekeerde woord. In dit Python project vragen we de gebruiker om een woord om te keren en te kijken of een woord een palindroom is of niet.
Tip: met het codeblokje [::-1] kan u een woord omkeren. Verder kan de gebruiker zijn/haar eigen input voor het palindroom invoeren.
Code
# Programma om een woord om te keren
omgekeerd_woord = input(“Welk woord wil je omkeren? “)
omgekeerd_woord = omgekeerd_woord[::-1]
print(omgekeerd_woord)
# Programma om te kijken of een woord een palindroom is
palindroom = input(“Van welk woord wil je nakijken of het een palindroom is? “)
# maak alle letters en tekens gelijk + klein
palindroom = palindroom.casefold()
# keer het woord om
check_palindroom = reversed(palindroom)
# kijk of het woord gelijk is aan het omgekeerde woord
if list(palindroom) == list(check_palindroom):
print(“Het woord ” + palindroom + ” is een palindroom.”)
else:
print(“Het woord ” + palindroom + ” is geen palindroom.”)
7. Boter kaas en eieren
Van deze app maken we een multiplayer spel voor 2 personen. Om de beurt mag een speler een X of O plaatsen. Heb je 3 op een rij van je eigen teken? Dan win je het spel!
Bij deze app is het van belang om de spelinstructies in zo duidelijk en logisch mogelijke codeblokken op te delen. Python lees de code van boven naar beneden. Programmeren met functies zorgt ervoor dat de code overzichtelijk blijft.
Code
# Multiplayerspel voor 2 personen: Boter-kaas-en-eieren (Tic Tac Toe)
# Spelbord maken, op basis van de posities van de numpad op het toetsenbord
theBoard = {‘7’: ‘ ‘, ‘8’: ‘ ‘, ‘9’: ‘ ‘,
‘4’: ‘ ‘, ‘5’: ‘ ‘, ‘6’: ‘ ‘,
‘1’: ‘ ‘, ‘2’: ‘ ‘, ‘3’: ‘ ‘}
board_keys = []
for key in theBoard:
board_keys.append(key)
# We moeten het spelbord na elke zet opnieuw afprinten. Daarvoor maken een functie.
def printBoard(board):
print(board[‘7’] + ‘|’ + board[‘8’] + ‘|’ + board[‘9’])
print(‘-+-+-‘)
print(board[‘4’] + ‘|’ + board[‘5’] + ‘|’ + board[‘6’])
print(‘-+-+-‘)
print(board[‘1’] + ‘|’ + board[‘2’] + ‘|’ + board[‘3’])
# Dit is de hoofdfunctie die de elementen van de gameplay bevat
def game():
turn = ‘X’
count = 0
for i in range(10):
printBoard(theBoard)
print(“Het is jouw beurt,” + turn + “. Welke plaats wil je aanduiden?”)
move = input()
if theBoard[move] == ‘ ‘:
theBoard[move] = turn
count += 1
else:
print(“Die plaats is al ingenomen.\nWelke plaats wil je aanduiden?”)
continue
# Nu bekijken we of speler X of O gewonnen heeft, voor elke zet (vanaf 5 zetten te tellen)
if count >= 5:
if theBoard[‘7’] == theBoard[‘8’] == theBoard[‘9’] != ‘ ‘: # check bovenste rij
printBoard(theBoard)
print(“\nGame Over.\n”)
print(” **** ” + turn + ” won. ****”)
break
elif theBoard[‘4’] == theBoard[‘5’] == theBoard[‘6’] != ‘ ‘: # check middelste rij
printBoard(theBoard)
print(“\nGame Over.\n”)
print(” **** ” + turn + ” won. ****”)
break
elif theBoard[‘1’] == theBoard[‘2’] == theBoard[‘3’] != ‘ ‘: # check onderste rij
printBoard(theBoard)
print(“\nGame Over.\n”)
print(” **** ” + turn + ” won. ****”)
break
elif theBoard[‘1’] == theBoard[‘4’] == theBoard[‘7’] != ‘ ‘: # check linker kolom
printBoard(theBoard)
print(“\nGame Over.\n”)
print(” **** ” + turn + ” won. ****”)
break
elif theBoard[‘2’] == theBoard[‘5’] == theBoard[‘8’] != ‘ ‘: # check middelste kolom
printBoard(theBoard)
print(“\nGame Over.\n”)
print(” **** ” + turn + ” won. ****”)
break
elif theBoard[‘3’] == theBoard[‘6’] == theBoard[‘9’] != ‘ ‘: # check rechtse kolom
printBoard(theBoard)
print(“\nGame Over.\n”)
print(” **** ” + turn + ” won. ****”)
break
elif theBoard[‘7’] == theBoard[‘5’] == theBoard[‘3’] != ‘ ‘: # check diagonaal
printBoard(theBoard)
print(“\nGame Over.\n”)
print(” **** ” + turn + ” won. ****”)
break
elif theBoard[‘1’] == theBoard[‘5’] == theBoard[‘9’] != ‘ ‘: # check diagonaal2
printBoard(theBoard)
print(“\nGame Over.\n”)
print(” **** ” + turn + ” won. ****”)
break
# Als X of O niet gewonnen is en het bord vol is, is het een gelijkspel.
if count == 9:
print(“\nGame Over.\n”)
print(“Het is gelijkspel!”)
# Nu moeten we de speler veranderen na elke beurt.
if turn == ‘X’:
turn = ‘O’
else:
turn = ‘X’
# Nu vragen we de spelers of ze opnieuw willen spelen of niet.
restart = input(“Wil je nog eens spelen?(j/n)”)
if restart == “j” or restart == “J”:
for key in board_keys:
theBoard[key] = ” “
game()
if __name__ == “__main__”:
game()
8. Galgje
Bij het populaire spel galgje is het de bedoeling dat de speler een bepaald woord raadt. Dit kan door om de beurt een letter te raden. Is de letter geraden? Dan wordt deze getoond op het scherm.
Bij een fout kan de letter niet nog eens geraden worden en na een aantal foute beurten is het game over. Ook bij dit project is het belangrijk om de code overzichtelijk te houden. Dit is wel een van de moeilijkste python projects in deze top 10. Probeer het overzicht te behouden en het nut van de verschillende functies in te zien.
Code
# Tijd voor het spel Galgje!
import random
word_list = ["buvesa", "marketing", "python", "programmeren", "youtube", "tips", "website"]def get_word(word_list):
word = random.choice(word_list)
return word.upper()def play(word):
word_completion = "_" * len(word)
guessed = False
guessed_letters = []
guessed_words = []
tries = 6
print("Laten we Galgje spelen!")
print(display_hangman(tries))
print(word_completion)
print("\n")
while not guessed and tries > 0:
guess = input("Raad een letter of woord: ").upper()
if len(guess) == 1 and guess.isalpha():
if guess in guessed_letters:
print("Je hebt dit al geprobeerd: ", guess, "!")
elif guess not in word:
print(guess, "is niet in het woord :(")
tries -= 1
guessed_letters.append(guess)
else:
print("Goed zo,", guess, "is in het woord!")
guessed_letters.append(guess)
word_as_list = list(word_completion)
indices = [i for i, letter in enumerate(word) if letter == guess]
for index in indices:
word_as_list[index] = guess
word_completion = "".join(word_as_list)
if "_" not in word_completion:
guessed = True
elif len(guess) == len(word) and guess.isalpha():
if guess in guessed_words:
print("Je hebt dit al geprobeerd: ", guess, "!")
elif guess != word:
print(guess, " is niet het woord :(")
tries -= 1
guessed_words.append(guess)
else:
guessed = True
word_completion = word
else:
print("ongeldige input")
print(display_hangman(tries))
print(word_completion)
print("\n")
if guessed:
print("Goed zo, je hebt het woord geraden!")
else:
print("Het spijt me, maar je hebt geen gokken meer. Het woord was " + word + ". Misschien heb je volgende keer meer geluk!")def display_hangman(tries):
stages = [ """
--------
| |
| O
| \\|/
| |
| / \\
-
""",
"""
--------
| |
| O
| \\|/
| |
| /
-
""",
"""
--------
| |
| O
| \\|/
| |
|
-
""",
"""
--------
| |
| O
| \\|
| |
|
-
""",
"""
--------
| |
| O
| |
| |
|
-
""",
"""
--------
| |
| O
|
|
|
-
""",
"""
--------
| |
|
|
|
|
-
"""
]
return stages[tries]def main():
word = get_word(word_list)
play(word)
while input("Opnieuw? (J/N) ").upper() == "J":
word = get_word(word_list)
play(word)if __name__ == "__main__":
main()
9. Een dobbelsteen programmeren
Deze app geeft een willekeurig cijfer neer tussen 1 en 6, zoals dat bij een dobbelsteen gegooid kan worden.
Daarvoor importeren we de ‘random functie’.
Code
import randomdef rollen(min, max):
while True:
print("De dobbelsteen is aan het rollen...")
print(f"Jouw getal is {random.randint(min, max)}")
answer = input("Wil je nog eens rollen? (j/n) ")
if answer.lower() == "n":
break
rollen(1, 6)
10. Blad steen schaar
Bij blad steen schaar kan je een van deze 3 opties kiezen en zo proberen de tegenstander te verslaan met de goede combinatie. In dit spel kan de speler 1 van deze 3 opties kiezen. De computer kiest ook uit een van deze opties. Het programma bekijkt vervolgens wie gewonnen heeft.
Tip: Ook in dit programma moet de ‘random module’ geïmporteerd worden. Koppel de variabelen blad, steen en schaar aan de nummers 1, 2, 3. Op die manier kan de computer een willekeurige ‘random’ keuze maken.
Code
# importeer de random module
import random# Print spelinstructies af
print("Blad steen schaar win je op de volgende manier: \n"
+ "Steen vs blad->Blad wint \n"
+ "Steen vs schaar->Steen wint \n"
+ "Blad vs schaar->Schaar wint \n")while True:
print("Kies uit \n 1. steen \n 2. blad \n 3. schaar \n")# neem input van de gebruiker
choice = int(input("Jouw beurt: "))# loop tot er een ongeldige waarde wordt ingegeven
while choice > 3 or choice < 1:
choice = int(input("Geef een geldige input: "))# de keuze van de gebruiker aan een variabele koppelen
if choice == 1:
choice_name = 'steen'
elif choice == 2:
choice_name = 'blad'
else:
choice_name = 'schaar'
# print user choice
print("Uw keuze is: " + choice_name)
print("\nNu is het de beurt aan de computer.......")# De computer kiest willekeurig een nummer van de random module
comp_choice = random.randint(1, 3)# loop totdat de computer keuze is gelijk aan de waarde van de keuzemogelijkheden
while comp_choice == choice:
comp_choice = random.randint(1, 3)# de keuze van de computer wordt gekoppeld aan een variabele
if comp_choice == 1:
comp_choice_name = 'steen'
elif comp_choice == 2:
comp_choice_name = 'blad'
else:
comp_choice_name = 'schaar'
print("De keuze van de computer is: " + comp_choice_name)print(choice_name + " vs " + comp_choice_name)
# voorwaarden om te winnen
if ((choice == 1 and comp_choice == 2) or
(choice == 2 and comp_choice == 1)):
print("blad wint => ", end="")
result = "blad"
elif ((choice == 1 and comp_choice == 3) or
(choice == 3 and comp_choice == 1)):
print("steen wint =>", end="")
result = "steen"
else:
print("schaar wint =>", end="")
result = "schaar"
# Print af of de gebruiker of de computer gewonnen is
if result == choice_name:
print(" ** Jij hebt gewonnen ** ")
else:
print(" ** De computer heeft gewonnen ** ")print("Wil je nog eens spelen? (J/N)")
ans = input()# als de gebruiker n of N ingeeft, stopt het programma
if ans == 'n' or ans == 'N':
break
# nadien komen we uit de while loop en willen we de gebruiker bedanken om het spel te spelen
print("\nBedankt om te spelen!")
Conclusie
Bepaalde Python projects zullen uitdagender zijn dan andere. Begin eerst met de meest eenvoudige en bouw zo je vaardigheden op totdat je de meer ‘uitdagende’ projecten zelf kan schrijven.
Er zijn nog veel verschillende apps, projects en domeinen die u met Python kan programmeren. Lees daarvoor ook ons vorig artikel: Wat kan je met Python maken en programmeren (+ voorbeelden).
Hallo Sander.
Bezig zijnde met een cursus Python (via NHA) en zoekende naar wat oefening kwam ik op jouw site terecht. Ik heb me gisteren een uurtje bezig gehouden met de oefening voor het bepalen of een getal een priemgetal is en dat ging me in ieder geval goed af.
Hoewel, achteraf controlerend, mijn aanpak in de kern dezelfde bleek als die van jou, was de insteek toch iets anders. Bij mijn module kun je een begin en een eind getal opgeven en de module bepaald vervolgens welke priemgetallen in die reeks voorkomen. Zo bezig was ik benieuwd hoe snel de module tot een resultaat kwam en je zag dat zeker bij de hogere getallen en langere reeksen dat soms toch wel even kon duren. Bij een reeks van 1000 tot 10000 duurde het om mijn systeem m.b.v. Pycharm 872 milliseconden en werden er 1061 priemgetallen getoond. Natuurlijk nog niet zo lang. Geef je als reeks echter 10000 tot 100000 in dan wordt dat echter 72 seconden met als resultaat 8363 priemgetallen. Bij dit soort berekeningen is Pycharm overigens nog heel snel. Thonny is vele malen langzamer.
Afgelopen nacht lag ik daar over te denken of dat niet sneller kan. Het heeft natuurlijk geen zin om bij het berekenen van de rest verder te gaan dan de helft van het getal. Dat scheelt al aanzienlijk. Toch had ik het gevoel dat dat nog niet de limiet was. Wat voor 2 geldt, geldt ook voor 3. Zo redenerende kwam ik tot de ingeving dat je in de for loop waar je voor elk deel getal controleert of er een rest is niet verder hoeft te gaan dan de wortel van het getal. Daar boven doe je in feite precies hetzelfde, waar alleen de a en de b verwisseld zijn (a x b = getal). Het resultaat verbaasde mij behoorlijk. Had wel zeker impact verwacht maar niet in die mate. Voor de reeks van 1000 – 10000 ging de procestijd terug naar 29 milliseconden. Dit is 30 keer sneller. Voor de reeks van 10000 tot 100000 ging de tijd terug naar 406 milliseconden, hetgeen zelfs 177 keer sneller is. Je begrijpt dat ik heel tevreden was met het resultaat. Voor de reeks 1E5 – 1E6 heb ik de eerste versie niet laten lopen. Ben bang dat dat lang gaat duren. Met de wortel aanpak had ik echter na 11 seconden 68906 priemgetallen op het scherm staan :-).
Overigens nog een leuke. Bij het controleren van het resultaat (reeks 10 -100) kreeg ik in eerste instantie een aantal waarden te veel. Ik zoeken. Na het door redeneren van die foute getallen en een klein half uur verder vond ik de fout. Had ik nu pas gelezen dat bij programmeren de twee meest voorkomende fouten ‘namen geven’, ‘cache consistentie’ en ‘off-by-on’ zijn :-). De fout was van een van die laatste categorie. In de for loop voor het bepalen van de deelbaar rest liet ik deze lopen tot int(sqrt(getal)). Dan mis je dus het wortel getal zelf. Dat moet dan ook zijn int(sqrt(getal))+1 en dat gaf het juiste resultaat.
Groeten, Harrie
Jij hebt zeker niet stilgezeten Harrie. Het is inderdaad te kunst om op efficiënte manieren programmeerproblemen aan te pakken, aangezien er veel mogelijkheden zijn.