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 random


def 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).