Lær deg Python_Modul_1‐4_Del10 - itnett/FTD02H-N GitHub Wiki

La oss lage et klassisk "hengemannen"-spill i Python! 🎮🎉

Hengemannen er et spill der en spiller gjetter bokstaver i et ord. Hver gang spilleren gjetter feil, blir de ett steg nærmere å "henge" en mann. Spilleren vinner hvis de gjetter alle bokstavene riktig før de går tom for forsøk.

Jeg vil først vise deg en fullstendig kode, og deretter forklare hvert steg med kommentarer og i detalj, slik at du kan lære Python på veien.

Koden for "Hengemannen"

import random

# Liste med ord som spilleren skal gjette
ord_liste = ['programmering', 'python', 'læring', 'spill', 'data']

# Velg et tilfeldig ord fra listen
ordet = random.choice(ord_liste)

# Antall feil spilleren kan gjøre før spillet er over
maks_feil = 6
antall_feil = 0

# Variabel som lagrer de riktige gjetningene
riktige_bokstaver = ['_'] * len(ordet)

# En liste for å holde oversikt over allerede gjettede bokstaver
gjettede_bokstaver = []

# Funksjon som viser spillstatusen
def vis_status():
    print("Ordet: " + ' '.join(riktige_bokstaver))
    print(f"Antall feil: {antall_feil}/{maks_feil}")
    print("Gjettede bokstaver: " + ', '.join(gjettede_bokstaver))

# Funksjon som kjører hengemannen-spillet
def hengemannen():
    global antall_feil  # Vi bruker globalt antall_feil
    while antall_feil < maks_feil and '_' in riktige_bokstaver:
        vis_status()
        # Spilleren gjetter en bokstav
        bokstav = input("Gjett en bokstav: ").lower()

        # Sjekk om bokstaven allerede er gjettet
        if bokstav in gjettede_bokstaver:
            print(f"Du har allerede gjettet {bokstav}. Prøv en annen bokstav.")
            continue

        gjettede_bokstaver.append(bokstav)

        # Sjekk om bokstaven er i ordet
        if bokstav in ordet:
            print(f"Bra gjettet! {bokstav} er i ordet.")
            # Oppdater riktige bokstaver på de riktige posisjonene
            for i, bokstav_i_ordet in enumerate(ordet):
                if bokstav_i_ordet == bokstav:
                    riktige_bokstaver[i] = bokstav
        else:
            print(f"Feil! {bokstav} er ikke i ordet.")
            antall_feil += 1

    # Sjekk om spilleren vant eller tapte
    if '_' not in riktige_bokstaver:
        print(f"Gratulerer! Du gjettet ordet '{ordet}'.")
    else:
        print(f"Beklager, du tapte. Ordet var '{ordet}'.")

# Start spillet
hengemannen()

Steg for steg forklaring av koden 🔍

1. Importere nødvendig modul

import random
  • random er en innebygd Python-modul som lar oss gjøre tilfeldige valg, som å velge et tilfeldig ord fra en liste.
  • Vi bruker random.choice() til å velge et tilfeldig ord fra ordlisten.

2. Definere variabler

ord_liste = ['programmering', 'python', 'læring', 'spill', 'data']
ordet = random.choice(ord_liste)
maks_feil = 6
antall_feil = 0
  • ord_liste: En liste med ord som spilleren kan gjette. Vi har lagt til noen ord relatert til programmering.
  • ordet: Her bruker vi random.choice() til å velge ett tilfeldig ord fra ord_liste.
  • maks_feil: Hvor mange feil spilleren kan gjøre før de taper. I dette tilfellet er det satt til 6 feil.
  • antall_feil: Vi starter med 0 feil, men denne variabelen vil øke for hver feil gjetning.

3. Forberedelse av spillmekanismen

riktige_bokstaver = ['_'] * len(ordet)
gjettede_bokstaver = []
  • riktige_bokstaver: En liste som holder styr på bokstavene spilleren har gjettet riktig. Den starter med tomme plasser ('_') som representerer ukjente bokstaver.
  • gjettede_bokstaver: En liste som holder oversikt over hvilke bokstaver spilleren allerede har gjettet, slik at de ikke gjetter samme bokstav flere ganger.

4. Vise spillstatus

def vis_status():
    print("Ordet: " + ' '.join(riktige_bokstaver))
    print(f"Antall feil: {antall_feil}/{maks_feil}")
    print("Gjettede bokstaver: " + ', '.join(gjettede_bokstaver))
  • vis_status(): Denne funksjonen viser hvor langt spilleren har kommet. Den skriver ut:
    • Ordet med riktige bokstaver fylt inn.
    • Antall feil spilleren har gjort så langt.
    • Bokstavene spilleren allerede har gjettet.

5. Kjøre spillet

def hengemannen():
    global antall_feil  # Vi bruker globalt antall_feil
    while antall_feil < maks_feil and '_' in riktige_bokstaver:
        vis_status()
        bokstav = input("Gjett en bokstav: ").lower()
        # Sjekk om bokstaven er allerede gjettet
        if bokstav in gjettede_bokstaver:
            print(f"Du har allerede gjettet {bokstav}.")
            continue
        gjettede_bokstaver.append(bokstav)
        # Sjekk om bokstaven er i ordet
        if bokstav in ordet:
            print(f"Bra gjettet! {bokstav} er i ordet.")
            for i, bokstav_i_ordet in enumerate(ordet):
                if bokstav_i_ordet == bokstav:
                    riktige_bokstaver[i] = bokstav
        else:
            print(f"Feil! {bokstav} er ikke i ordet.")
            antall_feil += 1
  • Spillet kjører i en while-løkke, så lenge spilleren har færre enn 6 feil, og det fortsatt er ukjente bokstaver ('_').
  • Spilleren blir bedt om å gjette en bokstav ved hjelp av input().
  • Hvis bokstaven allerede er gjettet, blir spilleren bedt om å prøve igjen.
  • Hvis bokstaven er riktig, fylles den inn på riktig plass i ordet.
  • Hvis bokstaven er feil, økes antall_feil med 1.

6. Vinne eller tape spillet

if '_' not in riktige_bokstaver:
    print(f"Gratulerer! Du gjettet ordet '{ordet}'.")
else:
    print(f"Beklager, du tapte. Ordet var '{ordet}'.")
  • Når løkken er ferdig, sjekker vi om spilleren vant ved å se om det er noen '_' igjen i listen riktige_bokstaver. Hvis ikke, har spilleren vunnet. Hvis spilleren har nådd maks antall feil uten å gjette ordet, har de tapt.

Hva har du lært her?

  1. Variabler: Vi definerer variabler som holder ordet, antall feil, gjettede bokstaver og mer.
  2. Lister: Vi bruker lister for å lagre riktige bokstaver og gjettede bokstaver.
  3. Kontrollstrukturer: if-setninger for å sjekke om bokstavene er riktige eller feil.
  4. Løkker: En while-løkke for å holde spillet i gang til det er vunnet eller tapt.
  5. Funksjoner: Koden er organisert i funksjoner for å gjøre den mer lesbar og gjenbrukbar.
  6. Brukerinput: Vi bruker input() til å la spilleren gjette bokstaver.

Nå er det din tur! 🎮

  • Prøv å endre listen med ord.
  • Endre antall feil spilleren kan gjøre.
  • Utvid spillet med flere funksjoner, som å vise grafiske deler av hengemannen hver gang det gjøres en feil.

Lykke til med å lære Python! 🚀

Den koden du foreslår er allerede godt strukturert, men vi kan gjøre noen forbedringer for å gjøre den enda mer robust og brukervennlig. Her er noen forslag til forbedringer og optimaliseringer:

Forbedringer:

  1. Validering av brukerinput: Sjekker om spilleren gjetter mer enn én bokstav, eller om input ikke er en bokstav. Dette hindrer at brukeren skriver tall eller spesialtegn.
  2. Funksjon for å vise en grafisk representasjon av hengemannen: Dette gjør spillet mer visuelt, noe som kan gjøre det mer engasjerende.
  3. Tilbakemelding om antall gjenværende forsøk: Spilleren blir informert om hvor mange forsøk de har igjen etter hver feil.
  4. Bedre struktur på variabler og funksjoner: Dette vil gjøre koden lettere å vedlikeholde og utvide senere.

Her er en forbedret versjon av koden med de ovennevnte forbedringene:

Forbedret Hengemannen-kode

import random

# Liste med ord som spilleren skal gjette
ord_liste = ['programmering', 'python', 'læring', 'spill', 'data']

# Velg et tilfeldig ord fra listen
ordet = random.choice(ord_liste)

# Antall feil spilleren kan gjøre før spillet er over
maks_feil = 6
antall_feil = 0

# Variabel som lagrer de riktige gjetningene
riktige_bokstaver = ['_'] * len(ordet)

# En liste for å holde oversikt over allerede gjettede bokstaver
gjettede_bokstaver = []

# Funksjon som viser den grafiske hengemannen
def vis_hengemannen(antall_feil):
    stadier = [
        '''
           +---+
           |   |
               |
               |
               |
               |
        =========''', 
        '''
           +---+
           |   |
           O   |
               |
               |
               |
        =========''', 
        '''
           +---+
           |   |
           O   |
           |   |
               |
               |
        =========''', 
        '''
           +---+
           |   |
           O   |
          /|   |
               |
               |
        =========''', 
        '''
           +---+
           |   |
           O   |
          /|\\  |
               |
               |
        =========''', 
        '''
           +---+
           |   |
           O   |
          /|\\  |
          /    |
               |
        =========''', 
        '''
           +---+
           |   |
           O   |
          /|\\  |
          / \\  |
               |
        ========='''
    ]
    print(stadier[antall_feil])

# Funksjon som viser spillstatusen
def vis_status():
    print("Ordet: " + ' '.join(riktige_bokstaver))
    print(f"Antall feil: {antall_feil}/{maks_feil}")
    print("Gjettede bokstaver: " + ', '.join(gjettede_bokstaver))

# Funksjon som kjører hengemannen-spillet
def hengemannen():
    global antall_feil  # Vi bruker globalt antall_feil
    while antall_feil < maks_feil and '_' in riktige_bokstaver:
        vis_hengemannen(antall_feil)
        vis_status()
        # Spilleren gjetter en bokstav
        bokstav = input("Gjett en bokstav: ").lower()

        # Sjekk om input er gyldig
        if len(bokstav) != 1 or not bokstav.isalpha():
            print("Ugyldig input. Vennligst gjett en enkelt bokstav.")
            continue

        # Sjekk om bokstaven allerede er gjettet
        if bokstav in gjettede_bokstaver:
            print(f"Du har allerede gjettet {bokstav}. Prøv en annen bokstav.")
            continue

        gjettede_bokstaver.append(bokstav)

        # Sjekk om bokstaven er i ordet
        if bokstav in ordet:
            print(f"Bra gjettet! {bokstav} er i ordet.")
            # Oppdater riktige bokstaver på de riktige posisjonene
            for i, bokstav_i_ordet in enumerate(ordet):
                if bokstav_i_ordet == bokstav:
                    riktige_bokstaver[i] = bokstav
        else:
            print(f"Feil! {bokstav} er ikke i ordet.")
            antall_feil += 1
            print(f"Du har {maks_feil - antall_feil} forsøk igjen.")

    # Sjekk om spilleren vant eller tapte
    if '_' not in riktige_bokstaver:
        print(f"Gratulerer! Du gjettet ordet '{ordet}'.")
    else:
        vis_hengemannen(antall_feil)
        print(f"Beklager, du tapte. Ordet var '{ordet}'.")

# Start spillet
hengemannen()

Forklaringer til forbedringene

1. Validering av brukerinput:

  • I hengemannen()-funksjonen har vi lagt til sjekk for om spilleren har gjettet mer enn én bokstav, eller om de har skrevet noe annet enn en bokstav. Dette gjør spillet mer brukervennlig og robust.
if len(bokstav) != 1 or not bokstav.isalpha():
    print("Ugyldig input. Vennligst gjett en enkelt bokstav.")
    continue

2. Grafisk representasjon av hengemannen:

  • Funksjonen vis_hengemannen() er lagt til for å vise en enkel grafisk fremstilling av hengemannen etter hvert som spilleren gjør feil. Dette gir en mer visuell følelse av fremdriften i spillet.
def vis_hengemannen(antall_feil):
    stadier = [ ... ]  # Liste med ulike stadier av hengemannen
    print(stadier[antall_feil])

3. Tilbakemelding om antall gjenværende forsøk:

  • Spilleren får beskjed om hvor mange forsøk de har igjen hver gang de gjør en feil.
print(f"Du har {maks_feil - antall_feil} forsøk igjen.")

4. Brukervennlig output:

  • For å gjøre det enklere å følge med på fremdriften i spillet, er det lagt inn funksjoner for å vise ordet, feil, og bokstavene som er gjettet.
  • Spillet gir beskjed når det er vunnet eller tapt.

Hva du har lært:

  • Hvordan bruke funksjoner for å organisere koden bedre.
  • Bruke lister og løkker for å holde styr på bokstaver og gjettede verdier.
  • Hvordan Python kan håndtere brukerinput og validere den.
  • Hvordan visualisere fremdriften av spillet med en grafisk representasjon av hengemannen.

Med disse forbedringene blir hengemannen både mer visuelt og mer brukervennlig! Prøv koden, lek deg med endringer, og se hvordan ulike forbedringer gjør spillet mer spennende. 🚀

Denne koden er et flott utgangspunkt for å lære Python og samtidig ha det gøy med et klassisk spill som hengemannen. La oss se nærmere på hvordan dette fungerer og forklare hvert trinn nøye.

Forklaring av koden:

  1. Imports:

    • import random: Importerer random-modulen for å kunne velge et tilfeldig ord fra en liste. Dette gjør spillet mer dynamisk, ettersom spilleren møter et nytt ord hver gang spillet startes.

  2. Funksjonen vis_hengemannen(antall_feil):

    • Denne funksjonen har ansvar for å vise den grafiske representasjonen av hengemannen etter hvert som spilleren gjør feil. Det er en liste (stadier) som inneholder ulike stadier av hengemannen, fra første feil (kun galgen) til siste feil (hele kroppen hengt).

    • Avhengig av hvor mange feil spilleren har gjort (antall_feil), skriver funksjonen ut det tilsvarende stadiet fra listen. Dette gir en visuell tilbakemelding på hvor mange feil spilleren har gjort.

  3. Funksjonen vis_status:

    • Denne funksjonen viser gjeldende status for spillet, inkludert:
      • Ordet som spilleren prøver å gjette, med riktig gjettede bokstaver på plass, mens de uoppdagede bokstavene vises som understrek (_).
      • Hvor mange feil spilleren har gjort og hvor mange forsøk de har igjen.
      • Bokstaver som allerede er gjettet, slik at spilleren ikke gjentar de samme bokstavene.

  4. Funksjonen hengemannen():

    • Dette er hovedfunksjonen som styrer spillet.

    • Variabler:

      • ord_liste: En liste over mulige ord som kan bli valgt i spillet.
      • ordet: Det tilfeldige ordet som velges ved hjelp av random.choice().
      • maks_feil: Maksimalt antall feil spilleren kan gjøre før de taper (her satt til 6).
      • antall_feil: Teller hvor mange feil spilleren har gjort (startet på 0).
      • riktige_bokstaver: En liste som holder oversikt over bokstavene i ordet som er korrekt gjettet (starter som en liste med understreker).
      • gjettede_bokstaver: En liste som holder oversikt over alle bokstaver som spilleren har gjettet, uansett om de var riktige eller ikke.

    • Hovedløkken:

      • Så lenge spilleren ikke har gjort for mange feil (antall_feil < maks_feil), og det fortsatt er bokstaver som ikke er gjettet ('_' in riktige_bokstaver), kjører spillet.
      • Gjette en bokstav: Spilleren blir bedt om å gjette en bokstav. Inndata sjekkes for å være gyldig (én enkelt bokstav), og det sjekkes om bokstaven allerede er gjettet.
      • Oppdaterer status: Hvis bokstaven er i ordet, oppdateres listen riktige_bokstaver med riktig gjettet bokstav på riktig plass. Hvis ikke, øker antall feil og spilleren får en melding om hvor mange forsøk de har igjen.

    • Vinner eller taper: Etter at spilleren har gjettet, sjekkes det om alle bokstavene i ordet er gjettet. Hvis ja, vinner spilleren. Hvis spilleren når maks antall feil, taper de, og det riktige ordet blir avslørt.

  5. Start av spillet:

    • Etter definisjonen av funksjonene, blir hengemannen() kalt for å starte spillet.

Hvordan fungerer dette pedagogisk?

  • Interaktiv læring: Denne koden involverer interaktiv input fra spilleren, noe som gjør det enklere å forstå hvordan Python behandler data fra brukeren i sanntid.

  • Funksjoner og struktur: Ved å bryte opp koden i flere funksjoner lærer vi god programmeringspraksis ved å organisere koden logisk og gjenbrukbart. Funksjonene som viser spillstatus og hengemannen kan enkelt utvides eller endres uten å påvirke resten av spillet.

  • Betingelser og løkker: Spillet viser hvordan vi kan bruke betingelser (if-else) og løkker (while) til å kontrollere flyten i et program.

Mulige forbedringer og videre læring:

  • Utvidelse av ordlisten: Legg til flere ord for å gjøre spillet mer variert.
  • Håndtering av store og små bokstaver: Sørg for at spilleren kan skrive store eller små bokstaver uten å bli straffet for det.
  • Poengsystem: Legg til et poengsystem hvor spilleren får poeng basert på antall riktige gjetninger og hvor raskt de gjetter ordet.
  • Multiplayer-modus: Utvid spillet slik at to spillere kan spille mot hverandre, hvor en spiller skriver inn et ord, og den andre prøver å gjette det.

Med disse grunnleggende konseptene kan du bygge mer komplekse Python-programmer! Lykke til videre med hengemannen og Python-læringen! 👾

Her er en forklaring av den forbedrede versjonen av hengemannen-spillet:

Hovedforbedringer:

  1. Modularisering: Koden er delt inn i funksjoner som hver utfører én oppgave, noe som gjør koden mer lesbar, vedlikeholdbar og gjenbrukbar.
  2. Konstanter: Definert en konstant MAX_FEIL for å gjøre det tydelig hvor mange feil spilleren kan gjøre før de taper. Dette gjør det lettere å justere antall tillatte feil hvis nødvendig.
  3. Brukeropplevelse: Spilleren blir spurt om de vil spille igjen etter at spillet er ferdig, uten å måtte starte skriptet på nytt.
  4. Input Validering: Det er lagt til sjekk for ugyldig input, og spilleren blir bedt om å skrive en ny bokstav hvis de skriver noe annet enn én enkelt bokstav.

Forklaring av funksjoner:

1. vis_hengemannen(antall_feil):

  • Denne funksjonen viser den grafiske hengemannen basert på antall feil spilleren har gjort. Den bruker en liste med ulike stadier som representerer hengemannen, fra tom galge til full figur.

2. vis_status(riktige_bokstaver, antall_feil, gjettede_bokstaver):

  • Viser gjeldende status i spillet:
    • Ordet spilleren prøver å gjette, med riktige bokstaver på plass og ufullstendige bokstaver som understreker (_).
    • Antall feil spilleren har gjort så langt.
    • Bokstaver spilleren allerede har gjettet.

3. behandle_gjetning(ordet, riktige_bokstaver, gjettede_bokstaver):

  • Tar imot spillerens gjetning, kontrollerer om den er gyldig (én bokstav), og sjekker om spilleren allerede har gjettet bokstaven.
  • Hvis bokstaven er i ordet, oppdaterer funksjonen listen med riktige bokstaver.
  • Returnerer True hvis gjetningen var riktig, og False hvis den var feil, slik at det kan telle som en feil.

4. hengemannen():

  • Dette er hovedspillet. Velger et tilfeldig ord fra ORD_LISTE og starter spillrunden.
  • Mens spilleren fortsatt har flere forsøk igjen og ordet ikke er fullt gjettet, kjører loopen. Funksjonen bruker behandle_gjetning() for å sjekke gjetningen og oppdaterer statusen.
  • Når spillet er ferdig, sjekker den om spilleren vant eller tapte, og viser passende meldinger.

5. start_spill():

  • Denne funksjonen starter spillet og gir spilleren muligheten til å spille flere runder uten å starte skriptet på nytt. Etter hver runde spør den spilleren om de vil spille igjen.

Hvordan bruke dette skriptet:

  1. Spilleren blir bedt om å gjette en bokstav, og spillet sjekker om gjetningen er riktig.
  2. Hver feil øker antall feil og viser et nytt trinn i hengemannen-figuren.
  3. Spillet avsluttes når spilleren enten gjetter hele ordet eller gjør for mange feil (maksimalt 6 feil).
  4. Etter at spillet er ferdig, kan spilleren velge å starte en ny runde eller avslutte spillet.

Eksempel på kjøring:

Ordet: _ _ _ _ _
Antall feil: 0/6
Gjettede bokstaver: 
Gjett en bokstav: p
Bra gjettet! p er i ordet.
Ordet: p _ _ _ _
Antall feil: 0/6
Gjettede bokstaver: p
Gjett en bokstav: y
Bra gjettet! y er i ordet.
Ordet: p y _ _ _
Antall feil: 0/6
Gjettede bokstaver: p, y
...
Gratulerer! Du gjettet ordet 'python'.

Dette forbedrede skriptet gir en mer robust og morsom brukeropplevelse med mulighet for flere spillrunder, samtidig som det håndterer feilinput og gjettede bokstaver på en intuitiv måte.

Her er en forklaring av hvilke deler av Python-læringen som blir dekket av skriptet du har bedt om – hengemannen-spillet:

Introduction to Python

Dette dekker grunnleggende Python-syntaks og konsepter som er essensielle for å lage enkle programmer.

Installing Python 3 og Running Code

For å kjøre dette skriptet, må Python 3 være installert. Koden kan kjøres i en Python IDE, eller direkte i en terminal ved å lagre koden i en .py-fil og kjøre den.

Syntax

Skriptet bruker grunnleggende Python-syntaks, inkludert variabeltilordning, funksjonsdefinisjoner og kontrollflyt med if, else, og while.

Comments

Kommentarer (#) er brukt i hele skriptet for å forklare hva hver del av koden gjør. Dette er viktig for dokumentasjon og forståelse av koden.

Variables

Variabler som ordet, antall_feil, riktige_bokstaver og gjettede_bokstaver brukes for å lagre verdier som kan endres under programkjøringen.

Eksempel:

ordet = random.choice(ORD_LISTE)
antall_feil = 0

Types

Flere Python-datatyper blir brukt:

  • Strenger: Brukes til å representere ordet og bokstaver spilleren gjetter.
  • Lister: Brukes til å holde oversikt over riktige bokstaver og allerede gjettede bokstaver.
  • Heltall (integers): Brukes til å telle antall feil.

Eksempel:

ORD_LISTE = ['programmering', 'python', 'læring', 'spill', 'data']

Typecasting

Denne funksjonen brukes ikke eksplisitt i skriptet, men kunne ha blitt brukt til å konvertere for eksempel tall til strenger.

User Input

Brukeren gir input ved å gjette en bokstav:

bokstav = input("Gjett en bokstav: ").lower()

Operators

Operatorer som + brukes for strengsammenkobling, og += brukes for å øke antall feil:

antall_feil += 1

Conditionals (Betingelser)

if-else-setninger brukes til å sjekke om spilleren har gjettet riktig, om gjetningen allerede er gjort, og om spillet er over:

if bokstav in ordet:
    print(f"Bra gjettet! {bokstav} er i ordet.")
else:
    print(f"Feil! {bokstav} er ikke i ordet.")

Lists

Lister brukes for å holde styr på riktige bokstaver og gjettede bokstaver. For eksempel:

riktige_bokstaver = ['_'] * len(ordet)

while Loops

En while-løkke brukes for å kjøre spillet til spilleren enten vinner eller taper. Den fortsetter så lenge antall feil er mindre enn maksimum og ordet ikke er fullt gjettet:

while antall_feil < MAX_FEIL and '_' in riktige_bokstaver:

Functions

Hele spillet er bygget rundt funksjoner som:

  • vis_hengemannen()
  • vis_status()
  • hengemannen()
  • behandle_gjetning()
  • start_spill()

Dette modulariserer koden og gjør den lettere å vedlikeholde og forstå.

Scope

Variabler som antall_feil er tilgjengelige i funksjoner ved hjelp av global, slik at verdier kan endres i hele programmet:

global antall_feil

if name == 'main'

Dette brukes ikke eksplisitt i dette skriptet, men ville vært nyttig for å skille mellom når koden kjøres direkte versus når den importeres som modul.

Conclusion

Gjennom dette skriptet dekker vi mange grunnleggende aspekter ved Python-programmering, fra variabler og betingelser til løkker og funksjoner. Det er en praktisk måte å bruke Python for å bygge et lite spill, mens du lærer viktige konsepter som vil hjelpe deg videre på reisen mot å mestre programmering i Python.

Her er en utvidet versjon av hengemannen-spillet som demonstrerer bruk av flere av de grunnleggende og viktige konseptene i Python. Denne versjonen inkluderer alle funksjoner du nevnte og flere viktige konsepter, som try-except for feilhåndtering, bruk av moduler, filhåndtering for å lagre high score, og en mer avansert bruk av datatyper som dictionaries for å lagre spilleres poengsummer.

import random
import os  # For file handling

# Konstanter
MAX_FEIL = 6
ORD_LISTE = ['programmering', 'python', 'læring', 'spill', 'data']

# Funksjon for å vise hengemannen grafisk
def vis_hengemannen(antall_feil):
    stadier = [
        '''
           +---+
           |   |
               |
               |
               |
               |
        =========''',
        '''
           +---+
           |   |
           O   |
               |
               |
               |
        =========''',
        '''
           +---+
           |   |
           O   |
           |   |
               |
               |
        =========''',
        '''
           +---+
           |   |
           O   |
          /|   |
               |
               |
        =========''',
        '''
           +---+
           |   |
           O   |
          /|\\  |
               |
               |
        =========''',
        '''
           +---+
           |   |
           O   |
          /|\\  |
          /    |
               |
        =========''',
        '''
           +---+
           |   |
           O   |
          /|\\  |
          / \\  |
               |
        ========='''
    ]
    print(stadier[antall_feil])

# Funksjon for å vise status på spillet
def vis_status(riktige_bokstaver, antall_feil, gjettede_bokstaver):
    print("Ordet: " + ' '.join(riktige_bokstaver))
    print(f"Antall feil: {antall_feil}/{MAX_FEIL}")
    print("Gjettede bokstaver: " + ', '.join(gjettede_bokstaver))

# Funksjon som tar imot en gjetning fra brukeren
def behandle_gjetning(ordet, riktige_bokstaver, gjettede_bokstaver):
    while True:
        try:
            bokstav = input("Gjett en bokstav: ").lower()

            if len(bokstav) != 1 or not bokstav.isalpha():
                raise ValueError("Du må gjette én enkelt bokstav.")
            
            if bokstav in gjettede_bokstaver:
                print(f"Du har allerede gjettet {bokstav}. Prøv en annen bokstav.")
                continue
            break

        except ValueError as ve:
            print(ve)
    
    gjettede_bokstaver.append(bokstav)

    # Sjekk om bokstaven er i ordet
    if bokstav in ordet:
        print(f"Bra gjettet! {bokstav} er i ordet.")
        for i, bokstav_i_ordet in enumerate(ordet):
            if bokstav_i_ordet == bokstav:
                riktige_bokstaver[i] = bokstav
        return True
    else:
        print(f"Feil! {bokstav} er ikke i ordet.")
        return False

# Funksjon som skriver high score til en fil
def lagre_highscore(spiller, poeng):
    with open("highscore.txt", "a") as file:
        file.write(f"{spiller}: {poeng} poeng\n")

# Funksjon for å lese high score fra filen
def vis_highscore():
    if os.path.exists("highscore.txt"):
        print("\n--- High Scores ---")
        with open("highscore.txt", "r") as file:
            for line in file:
                print(line.strip())
        print("--------------------\n")
    else:
        print("\nIngen high scores lagret ennå.\n")

# Funksjon for å kjøre hengemannen-spillet
def hengemannen(spiller):
    ordet = random.choice(ORD_LISTE)
    antall_feil = 0
    riktige_bokstaver = ['_'] * len(ordet)
    gjettede_bokstaver = []

    while antall_feil < MAX_FEIL and '_' in riktige_bokstaver:
        vis_hengemannen(antall_feil)
        vis_status(riktige_bokstaver, antall_feil, gjettede_bokstaver)

        if not behandle_gjetning(ordet, riktige_bokstaver, gjettede_bokstaver):
            antall_feil += 1
            print(f"Du har {MAX_FEIL - antall_feil} forsøk igjen.")

    if '_' not in riktige_bokstaver:
        poeng = (len(ordet) - antall_feil) * 10
        print(f"Gratulerer, {spiller}! Du gjettet ordet '{ordet}' med {poeng} poeng.")
        lagre_highscore(spiller, poeng)
    else:
        vis_hengemannen(antall_feil)
        print(f"Beklager, {spiller}, du tapte. Ordet var '{ordet}'.")

# Funksjon for å starte spillet og spørre om å spille på nytt
def start_spill():
    spiller = input("Skriv inn ditt navn: ").capitalize()
    while True:
        hengemannen(spiller)
        vis_highscore()
        spill_igjen = input("Vil du spille igjen? (ja/nei): ").lower()
        if spill_igjen != 'ja':
            break

# Start spillet
start_spill()

Forklaring av hvordan skriptet dekker grunnleggende Python-konsepter:

  1. Introduction to Python / Syntax: Hele programmet er bygget rundt grunnleggende Python-syntaks, som funksjonsdefinisjoner, kontrollstrukturer og variabeltilordninger.

  2. Variables: Flere variabler blir brukt, inkludert ordet, antall_feil, riktige_bokstaver osv., for å holde styr på spilltilstanden.

  3. Types: Datatyper som lister (gjettede_bokstaver), strenger (bokstavene i ordet), heltall (antall_feil), og booleanske verdier (sannhetsverdier i if-setninger) blir brukt.

  4. Typecasting: Selve input()-funksjonen returnerer alltid en streng, men den sjekkes om den er en gyldig bokstav ved bruk av isalpha().

  5. User Input: Spilleren gjetter bokstaver gjennom input()-funksjonen:

    bokstav = input("Gjett en bokstav: ").lower()

  6. Conditionals (Betingelser): if-else-setninger brukes for å sjekke om gjettingen er riktig eller feil, og om spillet er ferdig:

    if '_' not in riktige_bokstaver:
    print("Gratulerer!")
else:
    print("Beklager, du tapte.")

  7. Loops: while-løkker brukes til å kjøre spillet inntil spilleren enten vinner eller taper:

    while antall_feil < MAX_FEIL and '_' in riktige_bokstaver:

  8. Functions: Flere funksjoner modulariserer koden, som hengemannen(), vis_hengemannen(), behandle_gjetning(), lagre_highscore() osv.

  9. Scope: Funksjonene har sine egne scopes, og variabler deklarert innenfor funksjoner er lokal for dem. Input er hentet inn som lokale variabler som bokstav.

  10. Files: Filhåndtering blir brukt til å lagre high score i en fil:

    with open("highscore.txt", "a") as file:
    file.write(f"{spiller}: {poeng} poeng\n")

  11. Exception Handling: Feilhåndtering er brukt for å sikre at brukeren gir gyldige bokstav-inndata:

    try:
    bokstav = input("Gjett en bokstav: ").lower()
    if len(bokstav) != 1 or not bokstav.isalpha():
        raise ValueError("Du må gjette én enkelt bokstav.")
except ValueError as ve:
    print(ve)

  12. Dictionaries: Selv om de ikke er brukt i dette eksempelet, kunne dictionaries blitt brukt til å spore flere spillere eller spillhistorikk.

Andre viktige forbedringer:

  • Moduler: import random og import os demonstrerer bruk av innebygde Python-moduler.
  • High Scores: Koden lagrer og leser high score, og demonstrerer filhåndtering.

Dette spillet bruker de fleste grunnleggende funksjoner og konsepter i Python og viser hvordan de kan brukes i et prosjekt som kan utvikles videre.