Återkoppling på studentskod för kmom06 analyzer

[AndreasArne]

Denna gången fick jag frågor kopplade till koden som studenten ville ha svar på. Ni hittar koden längre ner.

Globala filnamnet

Hur resonerar du kring det globala filnamnet?
Hade jag kunnat göra på något annat sätt för att uppnå det jag ville?
Förutom att ange filnamn i main-programmet och sedan använda som
argument i alla funktioner.
Skrev så här i redovisningen:
"Jag valde att använda en global för filnamnet och sedan open with vid
behov. Anledningen är nog att jag jobbat med klasser litegrann i c++
och jag ville på något sätt att alla funktioner i modulen skulle ha
tillgång till current_file. Det är såklart lite riskfyllt med en
global och något man helst bör undvika men i sammanhanget kändes det
som en bra lösning. Det är ju ingen annan som ska använda koden, och
det enda sättet att ändra i programmet är via change där jag har
felhantering."

Jag håller med i din analys av att använda global. Det är OK att lösa uppgiften med global. Men jag föredrar ändå att inte använda global. Jag gillar lösningen där vi skapar en variabel i main funktionen som vi skickar in till funktionerna. I set_file() kan du då returnera det nya filnamnet och tilldela det värdet till variabeln i main.

Varför föredrar jag den lösningen? Du är inne på det i din text, att det är lite riskabelt med globala värden. Det är lättare att göra fel. Men samtidigt är det skönt att slippa skicka in argumentet till varje funktion.

convert_lines_to_list()

Metoden att plocka ut data och konvertera till listor för vidare
analys i andra funktioner?
convert_lines_to_list(), convert_words_to_list(),
convert_letters_to_list()
Borde man istället analyserat materialet i samband med att filen var
öppen, eller kanske genom att analysera strängar? Valde jag rätt väg
helt enkelt?

Jag gillar din lösningen. Utförandet blir bra uppdelat och det är lätt att få tydlig kodstruktur. Du kan återanvända mycket kod, det är ett stort plus. Och du har bara filen öppen för att läsa upp innehållet. Filen är inte öppen längre än vad som behövs.

Jag gillar att du har tänkt till om när du ska ta bort ",.". Jag tänkte först att du skulle ha den koden i convert_lines_to_list() men sen såg jag att då hade du även gjort det för funktionen count_nonempty_lines() där det inte behövs. Nu sparar du lite prestanda. Dock vet jag inte om det är snabbast att köra rstrip på varje rad i loopen eller om det hade varit snabbare att köra .replace() på orginal strängen innan du gör om den till en lista. Men det är överkurs att tänka på sånt.

Smartare sätt att bli av med skiljetecken?

Smartare sätt att bli av med skiljetecken?
Jag löste uppgiften genom att ta bort skiljetecknen manuellt med
rstrip. Hur skulle jag kunna ta höjd för fler skiljetecken, även
sådana jag inte förutsett?

Jag var inne lite på det i förra stycket, men med det vi lär er i kursen har du en bra lösning och det är typ så vi vill att ni ska göra. Jag googlade lite på det och hittade en tråd där en person har gjort lite tidsmätningar. Den personen har dock testat med replace() funktionen. I en annan kommentar skrev någon att rstrip, strip och strip i grunden använder sig av samma funktion som replace så det är kanske inte så stor skillnad.

För alternativ lösning som tar höjd för fler tecken, kan man använda sig av string.punctuation. Sen kan du använda den med str.translate() och str.maketrans.

import string
s.translate(str.maketrans('', '', string.punctuation))

Det är en avancerad lösning, en simplare hade varit.

import string
for char in string.punctuation:
    s.replace(char, "")

Du skrev något om att lägga in alla värden i en dict för utskrift i all_functions()-funktionen. Hade det förenklat koden? Hur?

Nej. Det är nog en kvarleva från äldre krav när man också skulle jobba med något som heter JSON. Jag borde nog ta bort det från texten.

Har jag delat upp koden i logiska funktioner, eller skulle man kunnat göra på ett smartare sätt?

Exempelvis känns coun_words(), count_nonempty_lines() och
count_letters() väldigt små. Samtidigt ville jag ha fristående
funktioner för att få fram listan..

Jag gillar verkligen dina funktioner och uppdelningen. Vissa är kanske lite små som du säger men det är ju bara för att du har varit duktig och delat upp koden i flera funktioner. Dina små funktioner visar också upp en tydlig bild av vad som är möjligt att göra i ditt program. Det är också enklare att bygga ut ditt program med mer funktionalitet om man skulle vilja göra det.

Slutligen, hur kan jag gömma helper-funktioner för den som använder mitt lilla bibliotek?

Om vi tänker att jag har gjort ett litet bibliotek med bra att
ha-funktioner här, så vill jag inte att användaren per automatik ska
få tillgång till alla helper-funktioner. De förvirrar bara. Användaren
ska få enkel tillgång till "huvudfunktionerna", alltså de jag använder
i all_functions(). Hur kan jag gå tillväga?

Om du hade skrivit ett ordentligt bibliotek då hade du troligen också haft en fil som heter __init__.py i din mapp. Den filen körs först när man hade importerat ditt bibliotek. I den kan du importera funktionerna från din kod som du vill ska vara "publika". Du kan se ett exempel på detta i koden som används för att skriva testerna för automaträttningen. Där importerar jag funktionerna som jag sen använder i mina tester.

Det går fortfarande att komma åt de övriga funktionerna men då måste man skriva hela sökvägen till dom. T.ex. from examiner.exam_test_case import ExamTestCase istället för from examinerimport ExamTestCase.

Du kan läsa en hel del om init filen i dokumentationen.

[AndreasArne]

"""
Analyze functions
"""

from operator import itemgetter

current_file = ""

def set_file(file_name):
    """
    Set current working file
    """
    #print("Setting current file to " + current_file)
    try:
        with open(file_name):
            global current_file 
            current_file = file_name
            #print("File correctly set: " + current_file)
    except FileNotFoundError as err:
        #print("Could not open file: " + file_name + ". Qutting!")
        raise FileNotFoundError from err
        

def convert_lines_to_list():
    """
    Return lines as a list
    """
    with open(current_file) as file:
        return file.read().split("\n")

def convert_words_to_list():
    """
    Return words as a list
    """
    words = []
    for line in convert_lines_to_list():
        current_line = line.split()
        for word in current_line:
            append_word = word.rstrip()
            append_word = append_word.rstrip(".")
            append_word = append_word.rstrip(",")
            words.append(append_word.lower())
    
    return words

def convert_letters_to_list():
    """
    Return letters as a list
    """
    letters = []
    for word in convert_words_to_list():
        for letter in word:
            if letter.isalnum():
                append_letter = letter.rstrip()
                letters.append(append_letter)

    return letters

def count_nonempty_lines():
    """
    Count non empty lines in file
    """
    return len(convert_lines_to_list()) 

def count_words():
    """
    Count words in file
    """
    return len(convert_words_to_list())

def count_letters():
    """
    Count letters in file
    """
    return len(convert_letters_to_list())

def word_frequency_as_dict():
    """
    Count word frequency
    """
    frequency = {}
    words = convert_words_to_list()
    for word in words:
        if not word in frequency:
            frequency[word] = 1
        else:
            frequency[word] += 1
    
    return frequency

def frequence_in_percent_dict(frequency, total_items, display):
    """
    Return dict with frequence in percent
    """
    frequency_sorted = {}
    for key in sorted(frequency, reverse=True):
        frequency_sorted[key] = frequency[key]

    frequency_percent = {}
    counter = 0
    for key, value in sorted(frequency_sorted.items(), key=itemgetter(1), reverse=True):
        if counter == display:
            break
        frequency_percent[key] = (value, round((value * 100) / total_items, 1))
        counter += 1
    
    return frequency_percent

def letter_frequency_as_dict():
    """
    Count letter frequency
    """
    frequency = {}
    words = convert_words_to_list()

    for word in words:
        for letter in word:
            if not letter in frequency:
                frequency[letter] = 1
            else:
                frequency[letter] += 1
    
    return frequency

def print_frequency(frequency_percent):
    """
    Print frequency of letters/words
    """
    output = ""
    for key, value in frequency_percent.items():
        output += f"{key}: {value[0]} | {value[1]}%\n"
    output = output.rstrip("\n")
    return output


def letter_frequency():
    """
    Letter frequenxy as percent
    """
    total_letters = count_letters()
    frequency = letter_frequency_as_dict()
    frequency_percent = frequence_in_percent_dict(frequency, total_letters, 7)
    return print_frequency(frequency_percent)

def word_frequency():
    """
    Word frequency as percent
    """
    total_words = count_words()
    frequency = word_frequency_as_dict()
    frequency_percent = frequence_in_percent_dict(frequency, total_words, 7)
    return print_frequency(frequency_percent)

def all_functions():
    """
    Print all functions
    """
    output = ""
    output += f"{count_nonempty_lines()}\n"
    output += f"{count_words()}\n"
    output += f"{count_letters()}\n"
    output += f"{word_frequency()}\n"
    output += f"{letter_frequency()}\n"

    return output