För program som rymms i en fil används oftast följande disposition i textfilen:

1. importer (där andra moduler importeras)
2. funktionsdefinitioner (en eller fler definitioner av den/de funktioner som används i programmet)
3. anrop till funktioner (ett eller fler anrop till de funktioner som gör att något händer)

Nedan följer ett lite mer konkret exempel:

# högst upp finns importer
import random
import med


# sedan följer definitioner av de funktioner som används i programmet
def main():
    # eventuella förberedelser följt av eventuell huvudloop
    data = load_data("datafile")
    while True:
        # sats1
        # sats2
        # ...
        process_something1(arg1, arg2)
        # ...
        process_something2(arg3)


def load_data(filename):
    # pass används för att kunna skriva icke-kompletta funktionsdefinitioner
    # utan att få syntax-fel när man kör programmet
    pass


def process_something1(arg1, arg2):
    pass


def process_something2(arg3):
    pass


# efter definitionerna av funktioner som programmet använder görs ofta ett anrop
# till programmets huvudfunktion, alternativt flera funktioner om det är flera
# funktioner som ska köras.
#
# många gånger lägger man dessa anrop innanför en vilkorssats som endast kör
# anropen när programmet körs som ett skript (återkommer till detta senare i
# kursen)
if __name__ == '__main__':
    main()

Det finns en hel del funktionalitet som hör ihop med specifika datatyper som man kan komma åt genom s.k. punktnotation. Exempel på detta är att använda .append() på en lista. Dessa kallas för metoder (man kan säga att metoder är funktioner som används på värden via punktnotation; mer om detta senare i kursen).

För strängar finns .lower() som returnerar strängen i enbart gemener (se kodskelettet). Andra metoder för strängar är:

• str.endswith()
• str.find()
• str.join()
• str.rstrip()
• str.split()
• str.startswith()
• str.strip()

Med ovanstående notation refererar str till ett strängvärde. Vad dessa gör får du söka dig fram till.

För att lösa problem på ett datalogiskt sätt delar man oftast upp ett problem i mindre delproblem. Ett exempel på en problemuppdelning som kan göras är:

1. Hitta möjliga kandidater på ordförslag
2. Välj den bästa kandidaten

Genom att dela upp ett problem i delproblem kan man underlätta felsökning av kod genom att det blir lättare att avgöra i vilken del av koden som problemet kan finnas. Man kan t.ex. dela upp sin kod så att varje delproblem löses i en separat funktion. Resultatet från funktionen som löser ett delproblem skickas vidare till nästa funktion:

def large_problem(data1, data2):
    result1 = subproblem1(data1, data2)
    result2 = subproblem2(result1)

• För att undvika att läsa in data från fil varje gång ni kör autocomplete, kan ni lägga till skicka med ett extra argument till funktionen autocomplete() som innehåller den information som behövs. Vissa ändringar jämfört med kodskeletet kan behövas.
• Inläsning av data görs då någonstans innan ni går in i loopen som frågar användaren efter ett ord och sedan kör autocomplete()-funktionen.

När man tar sig an ett programmeringsproblem som man aldrig löst tidigare är det oftast bättre att antingen dela upp problemet i delproblem, eller lösa en enklare variant av problemet först.

I Uppgift 1 struntar vi i att försöka skriva en funktion som ger det bästa förslaget, utan koncentrerar oss på att enbart producera ett förslag.

Fundera ut vad ni vill att autocomplete ska göra

Fundera först på vilken strategi ni vill implementera. Ni kan exempelvis låta er funktion returnera det första bästa ordet som börjar på rätt bokstäver, eller låta den returnera en uppsättning förslag som användaren får välja mellan.

De begränsningar ni har att jobba med är att funktionen ska returnera något som kan skrivas ut.

En körning kan exempelvis se ut så här:

Type word: bast
Autocompletion finished:  bastu
Type word: enhö
Autocompletion finished:  enhörning
Type word: fik
Autocompletion finished:  fiktiv
Type word: programmer
Autocompletion finished:  programmering

En variant med autocomplete som returnerar fler än ett ord skulle kunna se ut så här:

Type word: bast
Autocompletion finished: bastu, bastun
Type word: enhö
Autocompletion finished: enhörning
Type word: fik
Autocompletion finished: fiktiv, fiktiva
Type word: program
Autocompletion finished: programmet, programmen

Formulera en plan/ tips på kodstruktur

Försök att formulera vilka steg som behöver göras för att funktionen göra det ni vill att den ska göra. Dra nytt av att ni är två som jobbar tillsammans; ni kan skriva på var sitt förslag och sedan be den andra personen läsa det och förklara det tillbaka till dig.

Förslagsvis kan uppdelning av funktionen autocomplete se ut på följande sätt:

1. Läs in vald frekvensfil med hjälp av pythons inbyggda metod open och använd readlines för uppdelning av innehållet.
2. Undersök om det finns ord som börjar på användarens ord i frekvensdatafilerna och lägg till orden som matchar i en ny lista.
3. Returnera sedan den nya listan som förslag.

Implementera funktionen

Skriv sedan klart funktionen autocomplete() ovan så att den förutsäger slutet på ett inmatat ord enligt er valda strategi. Det är tillåtet att ändra på antalet argument som funktionen autocomplete() använder.

OBS! För filläsning ska inte pythonmodulen csv användas, utan ni ska läsa in filen med hjälp av loop och metoden readlines() som gicks igenom på lektionen

Nu när ni skrivit en funktion som returnerar förslag är det dags att försöka förbättra det förslag som returneras.

I steg 2 ska ni

1. skriva en ny autocomplete-funktion som föreslår ord baserat på ordfrekvensdata (skriv inte över er funktion från Uppgift 1)
2. dokumentera era funktioner med funktionskommentarer (se nedan)

Skriv en helt ny funktion istället för att ändra på er existerande funktion. I er kod kan ni enkelt byta vilken funktion som används genom att kommentera bort den raden som använder den gamla funktionen, och sedan lägga till en rad som använder er nya funktion. Genom att behålla den gamla funktionen tar ni heller inte sönder den kod som som ni skrev till steg 1:

#suggestion = autocomplete(word)
suggestion = autocomplete_using_freq(word)

Ni får själva välja om ni använder en av de existerande .csv-filerna för att läsa in ord och deras ordfrekvenser, eller om ni använder er av ett fil-par (t.ex. alphabetical_words + alphabetical_freq) för att läsa in ordfrekvensdata.

Dokumentera även er kod med funktionskommentarer (se nedan).

Funktionskommentarer

Dokumentera i funktionskommentaren hur ni tänkt. Funktionskommentarer skriver man genom att med början på raden direkt efter funktionshuvudet lägga till en kommentar som börjar med tre citattecken och avslutas med tre citattecken. Se exempel nedan.

def get_most_frequent_word(document):
    """Returnera det mest frekventa ordet i document.

    Funktionen räknar ut ordfrekvenserna i strängen document och returnerar
    sedan det mest frekvent förekommande ordet. Ingen lexikal analys
    genomförs vilket alltså betyder förekomster av "grön" och "gröna" inte slås
    ihop till förekomst av samma ord."""

    # här följer sedan koden som tillhör till funktionen
    ...

En bra funktionskommentar börjar med en kort beskrivning av vad funktionen kommer göra och returnera. Enligt pythonstandard (PEP257), ska första raden i en funktionskommentar vara en mening i aktiv form. Behövs ytterligare förklaring lägger man till en tom rad och kan sedan skriva ett stycke med flera meningar.

I Uppgift 2 letade ni bland tillgänglig data efter ord som började på det användaren hade skrivit. I Uppgift 3 ska ni istället försöka leta bland tillgänglig data efter ord som användaren försökte skriva.

För den frivilliga uppgiften ska ni:

1. skriva ytterligare en funktion som istället för komplettera det användaren skrivit istället korrigerar det användaren skrivit
2. dokumentera era funktioner med funktionskommentarer (se nedan)

Redigeringsavstånd istället för frekvensinformation

I del 1 handlade problemet om att hitta ord som börjar på det användaren har skrivit för att kunna fylla på med återstående bokstäver.

Här i del 2 handlar problemet istället om att hitta ord som användaren försökte skriva. Det finns olika sätt att göra detta. En variant är att anta att användanden skrivit rätt antal bokstäver, men att någon eller några bokstäver är fel.

Skriv en funktion som utgår från denna premiss, dvs skriv funktionen autocorrect() som tar in minst ett argument (användarens ord) och försök returnera en rättstavad variant av ordet.

Inläst data (t.ex. alphabetical_words) ska fortfarande användas (för att hitta rätt ord).

Exempel på autocorrect-körning:

Type word: bast
Autocompletion finished: bäst
Type word: enhö
Autocompletion finished: enhörning
Type word: fik
Autocompletion finished: fiktiv, fiktiva
Type word: program
Autocompletion finished: programmet, programmen

Vad är redigeringsavstånd?

Redigeringsavståndet mellan två strängar är hur många redigerande steg (raderingar, infogningar och substitueringar av tecken) som krävs för att transformera ett ord till ett annat. Ett vanligt mått på redigeringsavstånd är Levenshtein-avståndet.

För att beräkna av Levenshtein-avståndet mellan två ord kan ni använda en färdig funktion som finns implementerad i filen /courses/729G46/kursmaterial/temauppg2/del2/med.py.

Kopiera filen från kurskatalogen till samma katalog som er autocomplete-pythonfil ligger i. Sedan lägger ni till raden

import med

högst upp i er python-kod. Nu kan ni beräkna Levenshtein-avståndet mellan två strängar i er kod genom att anropa med.minimum_edit_distance() med de två strängar ni vill räkna på som argument:

# skriv ut redigeringsavståndet mellan kisse och katt
print(med.minimum_edit_distance('kisse', 'katt'))

# ovanstående kommer skriva ut följande strängen "4", dvs att tre redigeringar
# behövs för att ändra strängen "kisse" till strängen "katt"

Fortsatt förfining

Om ni har tid och är intresserade kan ni uttöka er lösning till något av följande:

• Kombinera redigeringsavståndsdata med frekvensdata för att välja förslag.
• Hitta möjliga kandidater till rättstavning även bland ord som är längre eller kortare än det användaren skrev.
• Kombinera både autocorrect med autocomplete.

OBS! Ingen av de ovanstående förfinade varianterna krävs för att få godkänt, utan är endast exempel på möjlig fortsatt utveckling.