def calculate_word_frequencies_in_file(textfile):
    tokenized_text = get_text_from_file(textfile)
    token_list = get_tokens_from_string(tokenized_text)
    for token in token_list:
        count(token)
    return frequencies

tokenized_text = get_text_from_file(textfile)
token_list = get_token_list(tokenized_text)
frequencies = dict()
for token in token_list:
    add_occurence(token, frequencies)
return frequencies

def calculate_word_frequencies_in_file(textfile):
    tokenized_text = get_text_from_file(textfile)
    token_list = get_token_list(tokenized_text)
    for token in token_list:
        count(token)
    return frequencies

def calculate_word_frequencies(tokenized_text):
    token_list = get_token_list(tokenized_text)
    for token in token_list:
        count(token)
    return frequencies
        
def calculate_word_frequencies_in_file(textfile):
    tokenized_text = get_text_from_file(textfile)
    return calculate_word_frequencies(tokenized_text)

def calculate_word_frequencies_in_file(textfile):
    tokenized_text = get_text_from_file(textfile)
    return calculate_word_frequencies(tokenized_text)

def get_text_from_file(filename):
    with open(filename) as f:
        return f.read()

if __name__ == "__main__":
    # test code:
    print(get_text_from_file("moby_dick_tokenized.txt")[:500])

﻿MOBY - DICK ;
or , THE WHALE .
By Herman Melville
CHAPTER 1 . Loomings .
Call me Ishmael . Some years ago - never mind how long precisely - having little or no money in my purse , and nothing particular to interest me on shore , I thought I would sail about a little and see the watery part of the world . It is a way I have of driving off the spleen and regulating the circulation . Whenever I find myself growing grim about the mouth ; whenever it is a damp , drizzly November in my soul ; wheneve

infile = open(filename)
    text = infile.read()
    infile.close()
    return text

def calculate_word_frequencies(tokenized_text):
    token_list = get_token_list(tokenized_text)
    for token in token_list:
        count(token)
    return frequencies

def get_token_list(tokenized_text):
    return tokenized_text.split()

if __name__ == "__main__":
    # test code:
    test_text = "Hej hej !\nHej då . "
    print(test_text)
    print(get_token_list(test_text))

Hej hej !
Hej då . 
['Hej', 'hej', '!', 'Hej', 'då', '.']

def get_token_list(tokenized_text):
    return tokenized_text.split()

def count(token):
    pass

def create_empty_queue():
    return ('queue', [])

def enqueue(value, queue):
    if queue[0] == 'queue':
        queue[1].append(value)
    else:
        raise TypeError("Not a queue")

def dequeue(queue):
    if queue[0] == 'queue':
        if queue[1]:
            return queue[1].pop(0)
        else:
            return None
    else:
        raise TypeError("Not a queue")

q = create_empty_queue()
print(1, q)
enqueue('a', q)
print(2, q)
enqueue('b', q)
print(3, q)
print(4, f"{dequeue(q)=}")
print(5, q)
enqueue('c', q)
print(6, q)

1 ('queue', [])
2 ('queue', ['a'])
3 ('queue', ['a', 'b'])
4 dequeue(q)='a'
5 ('queue', ['b'])
6 ('queue', ['b', 'c'])

print(7, f"{dequeue(q)=}")
print(8, f"{dequeue(q)=}")
print(9, f"{dequeue(q)=}")

7 dequeue(q)='b'
8 dequeue(q)='c'
9 dequeue(q)=None

def make_counter():
    return ('counter', dict())
    
def add_occurrence(value, counter):
    if counter[0] == 'counter':
        if value in counter[1].keys():
            counter[1][value] += 1
        else:
            counter[1][value] = 1
    else:
        raise TypeError('Not a counter')

def lookup_occurrences(value, counter):
    if counter[0] == 'counter':
        if value in counter[1].keys():
            return counter[1][value]
        else:
            return 0
    else:
        raise TypeError('Not a counter')
        
def get_all_counts(counter):
    if counter[0] == 'counter':
        return counter[1]
    else:
        raise TypeError('Not a counter')

def make_counter():
    return dict()

def add_occurrence(element, counter):
    if element in counter.keys():
        counter[element] += 1
    else:
        counter[element] = 1
        
def get_occurrences(element, counter):
    if element in counter.keys():
        return counter[element]
    else:
        return 0
    
if __name__ == "__main__":
    # test code:
    counter = make_counter()
    print(f"{get_occurrences('a', counter)=}")
    add_occurrence('a', counter)
    print(f"{get_occurrences('a', counter)=}")
    add_occurrence('a', counter)
    add_occurrence('a', counter)
    print(f"{get_occurrences('a', counter)=}")
    print(f"{get_occurrences('b', counter)=}")

def calculate_word_frequencies(tokenized_text):
    token_list = get_token_list(tokenized_text)
    frequencies = make_counter()
    for token in token_list:
        add_occurrence(token.lower(), frequencies)
    return get_counts(frequencies)

if __name__ == "__main__":
    # test code:
    test_text = "Hej hej !\nHej då . "
    print(test_text)
    print(calculate_word_frequencies(test_text))

Hej hej !
Hej då . 
{'hej': 3, '!': 1, 'då': 1, '.': 1}

def calculate_word_frequencies(tokenized_text):
    token_list = get_token_list(tokenized_text)
    frequencies = make_counter()
    for token in token_list:
        add_occurence(token.lower(), frequencies)
    return frequencies

def make_counter():
    return ('counter', dict())
    
def add_occurrence(value, counter):
    if counter[0] == 'counter':
        if value in counter[1].keys():
            counter[1][value] += 1
        else:
            counter[1][value] = 1
    else:
        raise TypeError('Not a counter')

def lookup_occurrences(value, counter):
    if counter[0] == 'counter':
        if value in counter[1].keys():
            return counter[1][value]
        else:
            return 0
    else:
        raise TypeError('Not a counter')
        
def get_all_counts(counter):
    if counter[0] == 'counter':
        return counter[1]
    else:
        raise TypeError('Not a counter')

def calculate_word_frequencies(tokenized_text):
    token_list = get_token_list(tokenized_text)
    frequencies = make_counter()
    for token in token_list:
        add_occurrence(token.lower(), frequencies)
    return frequencies

def get_token_list(tokenized_text):
    return tokenized_text.split()

def calculate_word_frequencies_in_file(textfile):
    tokenized_text = get_text_from_file(textfile)
    return calculate_word_frequencies(tokenized_text)

def get_text_from_file(textfile):
    with open(textfile) as f:
        return f.read()

if __name__ == "__main__":
    # test code:
    freq = calculate_word_frequencies_in_file("moby_dick_tokenized.txt")
    print(f"{lookup_occurrences('the', freq)=}") 
    print(f"{lookup_occurrences('whale', freq)=}") 
    print(f"{lookup_occurrences('captain', freq)=}") 
    print(f"{lookup_occurrences('queequeg', freq)=}")

lookup_occurrences('the', freq)=14175
lookup_occurrences('whale', freq)=1152
lookup_occurrences('captain', freq)=327
lookup_occurrences('queequeg', freq)=252

729G46 Informationsteknologi och programmering¶

Tema 4, Föreläsning 4¶

Johan Falkenjack, johan.falkenjack@liu.se¶

Föreläsningsöversikt (4)¶

Temaupplägg, Tema 4-6¶

Examination: resultat på delmoment¶

Alla uppgifter i Tema 4-6 görs i par¶

Övergripande läromål för Tema 4-6¶

Tema 4-6¶

Datalogiskt tänkande¶

Vad är ett program?¶

Computational Thinking¶

Sammanfattningsvis¶

Är inte det samma sak som programmering?¶

Datalogiskt tänkande är inte…¶

Ett exempelproblem¶

Första stycket från Moby Dick¶

Vad behöver vi för att kunna lösa den här uppgiften?¶

Ett utkast¶

Dekomposition¶

Dekomposition på flera nivåer¶

Hur små delar behöver man bryta ner problem i?¶

Primitiver¶

Tillbaka till vårt utkast¶

En annan uppdelning¶

Abstraktion¶

Abstraktionsnivå¶

Disclaimer¶

Abstraktioner hjälper oss att tänka¶

Dekomposition eller abstraktion?¶

Växelverkan mellan dekomposition och abstraktion¶

Vi går ner en abstraktionsnivå och implementerar get_text_from_file¶

Vi skiftar tillbaka till calculate_word_frequencies¶

Hur ska vi göra med count?¶

Repetition: Abstrakta datatyper (ADT)¶

Exempel på abstrakt datatyp¶

Implementation av kö-ADT:n¶

Implementation av kö-ADT:n¶

En abstrakt datatyp för att räkna förekomster¶

Vår räkne-ADT i calculate_word_frequencies¶

Hur kom jag på det så snabbt?¶

Mönsterigenkänning¶

Typer av beräkningsproblem, formellt sett¶

Är alla problem någon av de 5 typerna?¶

Hur drar vi nytta av mönsterigenkänning?¶

Algoritmer, generaliseringar av processer¶

Exempel på algoritmer¶

När är en lösning en algoritm?¶

Hela vår lösning¶

Vi går ner en abstraktionsnivå och implementerar `get_text_from_file`¶

Vi skiftar tillbaka till `calculate_word_frequencies`¶

Hur ska vi göra med `count`?¶

Vår räkne-ADT i `calculate_word_frequencies`¶