print(int())
print(list())
print(str())
print(float())

0
[]

0.0

names = list()
names.append

<function list.append(object, /)>

names = list()
names.append("Johan")
print(names)

['Johan']

names = list()
names.tjotahejti

---------------------------------------------------------------------------
AttributeError                            Traceback (most recent call last)
Cell In[15], line 2
      1 names = list()
----> 2 names.tjotahejti

AttributeError: 'list' object has no attribute 'tjotahejti'

names = list()
dir(names)

['__add__',
 '__class__',
 '__class_getitem__',
 '__contains__',
 '__delattr__',
 '__delitem__',
 '__dir__',
 '__doc__',
 '__eq__',
 '__format__',
 '__ge__',
 '__getattribute__',
 '__getitem__',
 '__gt__',
 '__hash__',
 '__iadd__',
 '__imul__',
 '__init__',
 '__init_subclass__',
 '__iter__',
 '__le__',
 '__len__',
 '__lt__',
 '__mul__',
 '__ne__',
 '__new__',
 '__reduce__',
 '__reduce_ex__',
 '__repr__',
 '__reversed__',
 '__rmul__',
 '__setattr__',
 '__setitem__',
 '__sizeof__',
 '__str__',
 '__subclasshook__',
 'append',
 'clear',
 'copy',
 'count',
 'extend',
 'index',
 'insert',
 'pop',
 'remove',
 'reverse',
 'sort']

class Person:

class Person:
    
    pass

p = Person()
print(type(p))

<class '__main__.Person'>

class Person:
    
    def __init__(self):
        self._interest = None

class Person:
    
    def __init__(self):
        self._interest = None

class Person:
    
    def __init__(self):
        self._interest = None

class Person:
    
    def __init__(self):
        self._interest = None
        
    def set_interest(self, interest):
        self._interest = interest
    
    def get_interest(self):
        return self._interest
    
    def share_interest(self, other):
        return self._interest == other.get_interest()
        
ada = Person()
ada.set_interest('programming')
print(ada.get_interest())

programming

def set_interest(self, interest):
        self._interest = interest

    def get_interest(self):
        return self._interest

    def share_interest(self, other):
        return self._interest == other.get_interest()

class Person:
    
    def __init__(self):
        self._interest = None
        
    def set_interest(self, interest):
        self._interest = interest
        
    def get_interest(self):
        return self._interest
        
    def share_interest(self, other):
        return self._interest == other.get_interest()

annie = Person()
annie.set_interest('rocketry')
grace = Person()
grace.set_interest('compilers')
margaret = Person()
margaret.set_interest('rocketry')

print(annie.share_interest(grace))
print(annie.share_interest(margaret))

False
True

annie = Person()
annie.set_interest('rocketry')
grace = Person()
grace.set_interest('compilers')
margaret = Person()
margaret.set_interest('rocketry')
margaret.share_interest(annie)

class Person:
    
    def __init__(self):
        self.interest = None

annie = Person()
annie.interest = 'rocketry'
grace = Person()
grace.interest = 'compilers'
margaret = Person()
margaret.interest = 'rocketry'

def matches(person_a, person_b):
    return person_a.interest == person_b.interest

print(matches(annie, grace))
print(matches(annie, margaret))

False
True

class Queue:
    
    def __init__(self):
        self._storage = []

class Queue:
    
    def __init__(self):
        self._storage = []

class Queue:
    
    def __init__(self):
        self._storage = []
    
    def enqueue(self, value):
        self._storage.append(value)
    
    def dequeue(self):
        if self._storage:
            return self._storage.pop(0)
        else:
            return None

class Queue:
    
    def __init__(self):
        self._storage = []
        
    def enqueue(self, value):
        self._storage.append(value)
        
    def dequeue(self):
        if self._storage:
            return self._storage.pop(0)
        else:
            return None

class Queue:
    
    def __init__(self):
        self._storage = []
        
    def enqueue(self, value):
        self._storage.append(value)
        
    def dequeue(self):
        if self._storage:
            return self._storage.pop(0)
        else:
            return None

q = Queue()
q.enqueue('a')
q.enqueue('b')
print(q.dequeue())
q.enqueue('c')
print(q.dequeue())
print(q.dequeue())
print(q.dequeue())

a
b
c
None

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

q = Queue()
q._storage.append('a')
q._storage.append('b')
print(1, f"{q._storage.pop(0)=}")
q._storage.append('c')
print(2, f"{q._storage.pop(0)=}")
print(3, f"{q._storage.pop(0)=}")
print(4, f"{q._storage.pop(0)=}")

1 q._storage.pop(0)='a'
2 q._storage.pop(0)='b'
3 q._storage.pop(0)='c'

---------------------------------------------------------------------------
IndexError                                Traceback (most recent call last)
Cell In[28], line 8
      6 print(2, f"{q._storage.pop(0)=}")
      7 print(3, f"{q._storage.pop(0)=}")
----> 8 print(4, f"{q._storage.pop(0)=}")

IndexError: pop from empty list

class Queue:
    
    def __init__(self):
        self._front = None
        self._back = None
    
    def enqueue(self, value):
        elem = [value, None]
        if self._front is None and self._back is None:
            self._front = elem
            self._back = elem
        else:
            self._back[1] = elem
            self._back = elem
    
    def dequeue(self):
        if self._front is None:
            return None
        else:
            value = self._front[0]
            if self._front[1] is None:
                self._front = None
                self._back = None
            else:
                self._front = self._front[1]
            return value
        
    def __str__(self):
        res = []
        cur = self._front
        while cur:
            res.append(cur[0])
            cur = cur[1]
        return f"(Queue: {', '.join(res)})"

q = Queue()
print(1, q)
q.enqueue('a')
print(2, q)
q.enqueue('b')
print(3, q)
print(4, f"{q.dequeue()=}")
print(5, q)
q.enqueue('c')
print(6, q)
print(7, f"{q.dequeue()=}")
print(8, f"{q.dequeue()=}")
print(9, f"{q.dequeue()=}")

1 (Queue: )
2 (Queue: a)
3 (Queue: a, b)
4 q.dequeue()='a'
5 (Queue: b)
6 (Queue: b, c)
7 q.dequeue()='b'
8 q.dequeue()='c'
9 q.dequeue()=None

class Queue:
    
    class QueueElement:

        def __init__(self, value):
            self._value = value
            self._next = None

        def set_next(self, element):
            self._next = element

        def get_next(self):
            return self._next

        def get_value(self):
            return self._value

    def __init__(self):
        self._front = None
        self._back = None
    
    def enqueue(self, value):
        elem = Queue.QueueElement(value)
        # elem = self.QueueElement(value)
        if self._front is None and self._back is None:
            self._front = elem
            self._back = elem
        else:
            self._back.set_next(elem)
            self._back = elem
    
    def dequeue(self):
        if self._front is None:
            return None
        else:
            value = self._front.get_value()
            if self._front == self._back:
                self._front = None
                self._back = None
            else:
                self._front = self._front.get_next()
            return value
        
    def __str__(self):
        res = []
        cur = self._front
        while cur:
            res.append(cur.get_value())
            cur = cur.get_next()
        return f"(Queue: {', '.join(res)})"

q = Queue()
print(1, q)
q.enqueue('a')
print(2, q)
q.enqueue('b')
print(3, q)
print(4, f"{q.dequeue()=}")
print(5, q)
q.enqueue('c')
print(6, q)
print(7, f"{q.dequeue()=}")
print(8, f"{q.dequeue()=}")
print(9, f"{q.dequeue()=}")

1 (Queue: )
2 (Queue: a)
3 (Queue: a, b)
4 q.dequeue()='a'
5 (Queue: b)
6 (Queue: b, c)
7 q.dequeue()='b'
8 q.dequeue()='c'
9 q.dequeue()=None

class Queue:

def enqueue(self, value):
        self._storage.append(value)

class Queue:

    def __init__(self):
        self._storage = []
    ...

q = Queue()

class Queue:
    ...

    def __str__(self):
        return f"(Queue: {str(self._storage)})"
    ...

q = Queue()
print(q)
str(q)

class Queue:
    
    def __init__(self):
        self._storage = []
        
    def enqueue(self, value):
        self._storage.append(value)
        
    def dequeue(self):
        if self._storage:
            return self._storage.pop(0)
        else:
            return None

q = Queue()
print(q)

<__main__.Queue object at 0x7f2f6c228070>

q = Queue()
q.tjohej

---------------------------------------------------------------------------
AttributeError                            Traceback (most recent call last)
Cell In[38], line 2
      1 q = Queue()
----> 2 q.tjohej

AttributeError: 'Queue' object has no attribute 'tjohej'

q = Queue()
q.__str__
q.__tjohej__

---------------------------------------------------------------------------
AttributeError                            Traceback (most recent call last)
Cell In[39], line 3
      1 q = Queue()
      2 q.__str__
----> 3 q.__tjohej__

AttributeError: 'Queue' object has no attribute '__tjohej__'

class Queue:
    pass

class QueueList(list):
    
    def enqueue(self, value):
        self.append(value)
        
    def dequeue(self):
        if self:
            return self.pop(0)
        else:
            return None

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

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

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

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

def hejsan():
    print("Hejsan")

print(type(hejsan))

<class 'function'>

def hejsan():
    print("Hejsan")

def print_hello():
    print("Hello World!")
    
bacon = print_hello
bacon()

Hello World!

def second(values):
    return values[1]

value_pairs = [ ["Ada", 3], ["Bertil", 2], ["Cissi", 7] ]

print("Högst poäng:", max(value_pairs, key=second))
print("Lägst poäng:", min(value_pairs, key=second))

Högst poäng: ['Cissi', 7]
Lägst poäng: ['Bertil', 2]

import tkinter as tk
import random

def clicked():
    colors = [("red", "white"), ("green", "black"), ("blue", "white")]
    bg_color, fg_color = random.choice(colors)
    label.config(bg=bg_color, fg=fg_color, text="button clicked")

def mouse_enter(event):
    label.config(text="mouse over")

def mouse_leave(event):
    label.config(text="mouse exit")

# skapa ett Tk-fönster
root = tk.Tk()

# skapa label-widget
label = tk.Label(root, text="Hello!")
label.pack(fill=tk.X)

# koppla ihop händelser med funktioner. OBS! Funktionsobjekt som argument.
label.bind("<Enter>", mouse_enter)
label.bind("<Leave>", mouse_leave)

# skapa knappen. OBS! Funktionsobjekt som argument
button = tk.Button(root, text="Press Me!", command=clicked)
button.pack(fill=tk.X)

# starta GUI-loopen
root.mainloop()

%%python
#!/usr/bin/env python3
"""Laboration 5 -- TDDE44

Exempel på slumpmässig layout-funktion. Layout-funktionen skickas som
argument när en instans av lab5.LayoutTester skapas.
"""

# Läs denna fil för att se hur gränssnittet skapats.
import lab5
import random

def random_layout(squares, frame_height, frame_width):
    """Placera ut fyrkanterna i listan squares slumpmässigt.
    Argument:
    squares -- Lista som innehåller tkinter.Label-objekt
    frame_height -- Höjden (int) på den Fram som fyrkanterna ligger i
    frame_width -- Bredden (int) på den Frame som fyrkanterna ligger i
    """
    # Slumpa ut positioner för alla fyrkanter utan att de hamnar utanför framen
    for square in squares:
        square_size = square.winfo_width()
        xpos = random.randint(0, frame_width - square_size)
        ypos = random.randint(0, frame_height - square_size)
        square.place(x=xpos, y=ypos)
        
if __name__ == "__main__":
    layout_tester = lab5.LayoutTester(random_layout)

Running 'random_layout(<squares>, 171, 829)'...
Running 'random_layout(<squares>, 171, 829)'...
Running 'random_layout(<squares>, 171, 829)'...
Running 'random_layout(<squares>, 171, 829)'...
Running 'random_layout(<squares>, 171, 829)'...
Running 'random_layout(<squares>, 171, 829)'...
Running 'random_layout(<squares>, 171, 829)'...

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

# Exempel 1
number = 5
name = "Ada"
print(number + name)

---------------------------------------------------------------------------
TypeError                                 Traceback (most recent call last)
Cell In[49], line 4
      2 number = 5
      3 name = "Ada"
----> 4 print(number + name)

TypeError: unsupported operand type(s) for +: 'int' and 'str'

# Exempel 2
ans = 5 / (42 * 0)

---------------------------------------------------------------------------
ZeroDivisionError                         Traceback (most recent call last)
Cell In[50], line 2
      1 # Exempel 2
----> 2 ans = 5 / (42 * 0)

ZeroDivisionError: division by zero

# Exempel 3
printt("Hello world")

---------------------------------------------------------------------------
NameError                                 Traceback (most recent call last)
Cell In[51], line 2
      1 # Exempel 3
----> 2 printt("Hello world")

NameError: name 'printt' is not defined

# nyckelordet try används för att påbörja ett try-block
try:
    # här lägger man koden som kan utlösa ett undantag
    # "försök utföra dessa satser"

# nyckelordet except används för att påbörja ett except-block
except [typ av undantag] [as <namn på undantagsinstans>]:
    # här lägger man koden för vad som ska hända vid undantag

except [typ av undantag] [as <namn på undantagsinstans>]:
    # flera olika typer av undandtag kan hanteras
    # genom att lägga till flera except-block

# koden i finally-blocket utförs både efter felfritt try-block
# och efter except-block körts vid fel i try-block
finally:
    # kod för att städa upp, t.ex. stänga fil eller nätverks-
    # anslutning

# krasch.py
# Exempel på kod som kraschar
letters = ["a", "b", "c", "d", "e", "f"]

index = 0
while True:
    print(f"letters[index]: {letters[index]}")
    index += 1
print("Program done.")

letters[index]: a
letters[index]: b
letters[index]: c
letters[index]: d
letters[index]: e
letters[index]: f

---------------------------------------------------------------------------
IndexError                                Traceback (most recent call last)
Cell In[52], line 7
      5 index = 0
      6 while True:
----> 7     print(f"letters[index]: {letters[index]}")
      8     index += 1
      9 print("Program done.")

IndexError: list index out of range

# undantag1.py
# Undantag hanterat, kraschar inte
letters = ["a", "b", "c", "d", "e", "f"]

try:
    index = 0
    while True:
        print("letters[index]: {}".format(letters[index]))
        index += 1
    print("Loop done.")
except:
    print("An exception was raised.")
print("Program done.")

letters[index]: a
letters[index]: b
letters[index]: c
letters[index]: d
letters[index]: e
letters[index]: f
An exception was raised.
Program done.

# undantag2.py
letters = ["a", "b", "c", "d", "e", "f"]
try:
    index = 0
    while True:
        print(letters[index])
        index += 1
# Om undantag inträffar kommer variabeln error referera till en
# instans av klassen Exception
except Exception as error:
    print("An exception was raised.")
    print(error)
print("Program done.")

a
b
c
d
e
f
An exception was raised.
list index out of range
Program done.

# undantag3.py
import random

def run_until_exception():
    values = ["a", 2, "c", 4, "e", "f"]
    try:
        while True:
            # slumpa fram två index som ev. kan vara ogiltiga
            index1 = random.randint(0, len(values))
            index2 = random.randint(0, len(values))
            # använd operatorn +. Fel om operanderna inte är samma datatyp.
            print(f"{values[index1]} + {values[index2]} -> {values[index1] + values[index2]}")
    except TypeError as exception:
        print(f"TypeError: {exception}. Tried {values[index1]} + {values[index2]}")
    except IndexError as exception:
        print(f"IndexError: {exception}, {len(values)=}, {index1=}, {index2=}")

run_until_exception()
print("Program done.")

c + a -> ca
f + a -> fa
TypeError: unsupported operand type(s) for +: 'int' and 'str'. Tried 4 + a
Program done.

def flatten_and_sort_without_duplicates(list):
    """Return flattened and sorted values of list without duplicates."""
    # flatten contents of list, i.e. [1, [2]] -> [1, 2]
    new = []
    for e in list:
        if type(e) == list:
            for e2 in e:
                new.append(e2)
       else:
            new.append(e)

    # sort values in new, [2, 3, 1, 3] -> [1, 2, 3, 3]
    sorted(new)

    # remove duplicates from sorted values e.g. [1, 2, 2, 3] -> [1, 2, 3]
    i = 0
    while i < len(new):
        # remove new[i] if it is equal to the subsequent value
        if new[i] = new[i+1]:
            new.remove(new[i])
        i += 1

    return new

TDDE44 Programmering, grundkurs¶

Föreläsning 5.1-5.2¶

Johan Falkenjack, johan.falkenjack@liu.se¶

Föreläsningsöversikt, FÖ 5.1-5.2¶

Sammanfattning av period 1¶

Halvtidsutvärdering

Inför period 2¶

Att göra period 2¶

Laboration 5-7¶

Vad är objektorienterad programmering?¶

Objektorientering¶

Python är objektbaserat

Skapa objekt¶

Hur är en lista egentligen implementerad?¶

Hur är en lista egentligen implementerad?¶

Hur är en lista egentligen implementerad?¶

Behöver vi veta hur listan egentligen är implementerad?¶

Meddelanden¶

Metodanrop¶

Kan vi skicka vilka meddelanden som helst?¶

Funktionen dir¶

Vad avgör vilka attribut ett visst objekt har?¶

Objektets klass¶

Klasser¶

Klasser i föreläsningssalen¶

Klasser med olika syften¶

Vår första egna klass¶

Klassen Person: Nyckelordet class¶

Klassen Person: Konstruktor, self och instansvariabler¶

Klassen Person: Varför self._interest och inte self.interest?¶

Klassen Person: Beteenden och metoder¶

Klassen Person: Testkörning¶

Varför alla dessa metoder i Person?¶

Inkapsling (Encapsulation)¶

Vår andra egna klass: Datatypen kö (eng. queue)

Klassen Queue¶

Klassen Queue¶

Klassen Queue¶

Antag att vi bryter inkapslingen¶

Inkapsling minskar risken för liknande fel¶

Antag att vi ändrar implementationen av Queue

För den vetgirige¶

För den ännu mer vetgirige¶

Repetition: Klassdefinition¶

Repetition: Metoddefinition¶

Magic methods i Python¶

__init__¶

__str__¶

Andra dundermetoder¶

Men vänta lite...¶

Varför får vi inte AttributeError?¶

Varifrån kommer __str__-metoden Queue?¶

Klassen Queue ärver metoden __str__ från sin basklass, object¶

Arv - ett sätt att återanvända kod¶

Översikt (vi kommer inte arbeta mycket med arv i denna kurs, men det är viktigt att känna till)

Arv¶

Definiera en subklass¶

Klassen object¶

Exempel: Queue med list som basklass¶

Exempel: Queue med list som basklass¶

Mellanspel: Funktionsobjekt och högre ordningens funktioner¶

Funktionsobjekt¶

Funktionsobjekt¶

Exempel på funktionsobjekt¶

Högre ordningens funktioner¶

Exempel¶

Grafiska gränssnitt med tkinter¶

Programflöde: GUI¶

Om modulen tkinter¶

Widgets¶

Litet exempel¶

Laboration 5¶

Del 2¶

random-layout.py¶

Introduktion till klassdiagram i UML¶

UML - Unified Modelling Language¶

Klassdiagram¶

Klassdiagram¶

Book-klassen, definition¶

Book-klassen, UML-diagram¶

Funktionen `dir`¶

Klassen `Person`: Nyckelordet `class`¶

Klassen `Person`: Konstruktor, `self` och instansvariabler¶

Klassen `Person`: Varför `self._interest` och inte `self.interest`?¶

Klassen `Person`: Beteenden och metoder¶

Klassen `Person`: Testkörning¶

Varför alla dessa metoder i `Person`?¶

Klassen `Queue`¶

Klassen `Queue`¶

Klassen `Queue`¶

Antag att vi ändrar implementationen av `Queue`

`init`¶

`str`¶

Varför får vi inte `AttributeError`?¶

Varifrån kommer `str`-metoden `Queue`?¶

Klassen `Queue` ärver metoden `str` från sin basklass, `object`¶

Klassen `object`¶

Exempel: Queue med `list` som basklass¶

Exempel: Queue med `list` som basklass¶

Grafiska gränssnitt med `tkinter`¶

Om modulen `tkinter`¶

`random-layout.py`¶

Kod. https://trinket.io/python3/10b5ddc7a4 ¶