def calculate_word_frequencies_in_file(textfile):
    pass

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):
    pass

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):
    pass

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

Hej hej !
Hej då . 
None

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

def add_occurence(token, frequencies):
    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():
    pass

def add_occurrence(element, counter):
    pass
        
def get_occurrences(element, counter):
    pass
    
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)=}")

get_occurrences('a', counter)=0
get_occurrences('a', counter)=1
get_occurrences('a', counter)=3
get_occurrences('b', counter)=0

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)=}")

get_occurrences('a', counter)=0
get_occurrences('a', counter)=1
get_occurrences('a', counter)=3
get_occurrences('b', counter)=0

def calculate_word_frequencies(tokenized_text):
    token_list = get_token_list(tokenized_text)
    for token in token_list:
        count(token)
    return 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': 2, 'hej': 1, '!': 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 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

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

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

freq['the']=14175
freq['whale']=1152
freq['captain']=327
freq['queequeg']=252

def get_max_value(values):
    max_value = values[0]
    for value in values:
        if value > max_value:
            max_value = value
    return max_value

def get_max_value(values):
    max_value = values[0]
    for value in values:
        if value > max_value:
            max_value = value
    return max_value

def get_max_value(values):
    print(f"{len(values)=}")
    max_value = values[0]
    number_of_operations = 0
    for value in values:
        number_of_operations +=1
        if value > max_value:
            max_value = value
    print(f"{number_of_operations=}")
    return max_value

from random import sample

random_values = sample(range(1000), k=100)
print(f"{random_values=}")
print(get_max_value(random_values))

random_values=[20, 860, 427, 672, 176, 775, 130, 921, 550, 778, 27, 450, 749, 182, 386, 592, 444, 413, 973, 306, 1, 731, 241, 30, 320, 236, 942, 374, 868, 35, 70, 404, 895, 259, 468, 646, 406, 685, 919, 307, 644, 856, 810, 515, 665, 885, 652, 477, 784, 998, 74, 313, 715, 284, 598, 863, 111, 223, 95, 489, 276, 395, 667, 442, 302, 886, 767, 394, 519, 355, 104, 412, 770, 859, 39, 524, 525, 71, 326, 850, 753, 239, 605, 606, 331, 411, 21, 904, 700, 620, 167, 800, 659, 82, 426, 762, 16, 511, 334, 267]
len(values)=100
number_of_operations=100
998

def get_pairs(values):
    pairs = []
    for v1 in values:
        for v2 in values:
            pairs.append([v1, v2])
    return pairs

def get_pairs(values):
    print(f"{len(values)=}")
    pairs = []
    number_of_operations = 0
    for v1 in values:
        for v2 in values:
            number_of_operations += 1
            pairs.append([v1, v2])
    print(f"{number_of_operations=}")
    return pairs

values = range(7)
print(f"{values=}")
print(get_pairs(values))

values=range(0, 7)
len(values)=7
number_of_operations=49
[[0, 0], [0, 1], [0, 2], [0, 3], [0, 4], [0, 5], [0, 6], [1, 0], [1, 1], [1, 2], [1, 3], [1, 4], [1, 5], [1, 6], [2, 0], [2, 1], [2, 2], [2, 3], [2, 4], [2, 5], [2, 6], [3, 0], [3, 1], [3, 2], [3, 3], [3, 4], [3, 5], [3, 6], [4, 0], [4, 1], [4, 2], [4, 3], [4, 4], [4, 5], [4, 6], [5, 0], [5, 1], [5, 2], [5, 3], [5, 4], [5, 5], [5, 6], [6, 0], [6, 1], [6, 2], [6, 3], [6, 4], [6, 5], [6, 6]]

print(str)

<class 'str'>

list()

[]

my_variable = list()
print(my_variable)

[]

print(type(my_variable))

<class 'list'>

print(len(my_variable))

0

print(my_variable.append(1))

None

print(my_variable)

[1]

class Counter:
    
    def __init__(self):
        self.storage = dict()
        
    def add(self, element):
        if element in self.storage.keys():
            self.storage[element] += 1
        else:
            self.storage[element] = 1
    
    def get_occurrences(self, element):
        if element in self.storage.keys():
            return self.storage[element]
        else:
            return 0

    
if __name__ == "__main__":
    # test code:
    c = Counter()
    print(f"{c.get_occurrences('a')=}")
    c.add('a')
    print(f"{c.get_occurrences('a')=}")
    c.add('a')
    c.add('a')
    print(f"{c.get_occurrences('a')=}")
    print(f"{c.get_occurrences('b')=}")
    print(f"{c=}")

c.get_occurrences('a')=0
c.get_occurrences('a')=1
c.get_occurrences('a')=3
c.get_occurrences('b')=0
c=<__main__.Counter object at 0x7f85bd8be080>

    def __str__(self):
        return f"(Counter: {self.storage})"

class Counter:

def add(self, element):
        if element in self.storage.keys():
            self.storage[element] += 1
        else:
            self.storage[element] = 1

class Counter:
    ...
    def __init__(self):
        self.storage = dict()
    ...
c = Counter()

class Counter:
    ...
    def __str__(self):
        return f"(Counter: {self.storage})"
    ...
print(c)
str(c)

def create_person(name):
    return {'name':name, 'interest':None}

def set_interest(person, interest):
    person['interest'] = interest 

def matches(person1, person2):
    return person1['interest'] == person2['interest']

p1 = create_person('Annie')
set_interest(p1, 'rocketry')
p2 = create_person('Adele')
set_interest(p2, 'graphical user interfaces')
p3 = create_person('Margaret')
set_interest(p3, 'rocketry')

matches(1, 3)

---------------------------------------------------------------------------
TypeError                                 Traceback (most recent call last)
Cell In[57], line 1
----> 1 matches(1, 3)

Cell In[53], line 8, in matches(person1, person2)
      7 def matches(person1, person2):
----> 8     return person1['interest'] == person2['interest']

TypeError: 'int' object is not subscriptable

class Person:
    
    def __init__(self, name):
        self.name = name
        self.interest = None
        
    def set_interest(self, interest):
        self.interest = interest
        
    def matches(self, other):
        return self.interest == other.interest

p1 = Person('Annie')
p1.set_interest('rocketry')
p2 = Person('Adele')
p2.set_interest('graphical user interfaces')
p3 = Person('Margaret')
p3.set_interest('rocketry')

p3.matches(p1)

True

class Person(object):
    def __init__(self, name, pid):
        self._name = name
        self._pid = pid

class Student(Person):
    def get_email(self):
        return self._pid + "@student.liu.se"

class Teacher(Person):
    def get_email(self):
        return self._name.replace(' ', '.').lower() + "@liu.se"

dude1 = Teacher("Johan Falkenjack", "johsj47")
dude2 = Student("Johan Sjöholm", "johsj304")

dude1.get_email()

'johan.falkenjack@liu.se'

dude2.get_email()

'johsj304@student.liu.se'

# definition av klassen Dog med explicit basklass; object
class Dog(object):
    pass

# också godkänd definition av klassen Dog, ingen basklass angiven;
# basklassen object antas implicit av Python
class Dog:
    pass

# ingen explicit basklass; Python antar att object är basklass
class GameCharacter:
    pass

# explicit basklass - GameCharacter
class PlayerCharacter(GameCharacter):
    pass

# explicit basklass - GameCharacter
class EnemyCharacter(GameCharacter):
    pass

class CounterDict(dict):
        
    def add(self, element):
        if element in self.keys():
            self[element] += 1
        else:
            self[element] = 1
    
    def get_occurrences(self, element):
        if element in self.keys():
            return self[element]
        else:
            return 0

if __name__ == "__main__":
    # test code:
    cd = CounterDict()
    print(f"{cd.get_occurrences('a')=}")
    cd.add('a')
    print(f"{cd.get_occurrences('a')=}")
    cd.add('a')
    cd.add('a')
    print(f"{cd.get_occurrences('a')=}")
    print(f"{cd.get_occurrences('b')=}")
    print(f"{cd=}")

cd.get_occurrences('a')=0
cd.get_occurrences('a')=1
cd.get_occurrences('a')=3
cd.get_occurrences('b')=0
cd={'a': 3}

class Book:
    
    def __init__(self, title):
        self.title = title
        self.author = "Unknown"
        self.year = None

    def print_citation(self):
        if not self.year:
            year = "N/A"
        else:
            year = self.year
        print(f"{self.author}. ({year}). {self.title}")

729G46 Informationsteknologi och programmering¶

Tema 4, Föreläsning 4.1-4.2¶

Johan Falkenjack, johan.falkenjack@liu.se¶

Föreläsningsöversikt (4.1-4.2)¶

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 upp problem i?¶

Primitiver¶

Tillbaka till vårt utkast¶

En annan uppdelning¶

Abstraktion¶

Abstraktionsnivå¶

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 add_occurrence?¶

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¶

Bara för programmering?¶

Algoritmer och komplexitet¶

Komplexitet: tid och minne¶

Komplexitet¶

Linjär komplexitet¶

Illustration, linjär komplexitet¶

Komplexitet, nästlade loopar¶

Illustration, kvadratisk komplexitet¶

Exempel på komplexitet i stigande ordning¶

Objektorientering¶

Objekt i Python¶

Exempel: Inbyggda klassen list¶

Exempel: Inbyggda klassen list¶

Exempel: Inbyggda klassen list¶

Exempel: Inbyggda klassen list¶

Exempel: Inbyggda klassen list¶

Exempel: Inbyggda klassen list¶

Exempel: Inbyggda klassen list¶

Exempel: Inbyggda klassen list¶

Så vad är det nya om vi jobbat med objekt hela tiden?¶

1. Inkapsling (Encapsulation)¶

2. Abstraktion (Abstraction)¶

3. Arv (Inheritance) och/eller sammansättning (Composition)¶

4. Polymorfi (Polymorphism)¶

Klass eller prototyp?¶

Klassbaserad objektorientering¶

Klasser i föreläsningssalen¶

Egna klasser¶

Objektorienterad version av räkne-ADT:n¶

Klassdefinition¶

Metoddefinition¶

Magic methods i Python¶

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 `add_occurrence`?¶

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

Exempel: Inbyggda klassen `list`¶

Exempel: Inbyggda klassen `list`¶

Exempel: Inbyggda klassen `list`¶

Exempel: Inbyggda klassen `list`¶

Exempel: Inbyggda klassen `list`¶

Exempel: Inbyggda klassen `list`¶

Exempel: Inbyggda klassen `list`¶

Exempel: Inbyggda klassen `list`¶

`init`¶

`str`¶

Basklassen `object`¶

Klassen `object`¶