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

class Person:
    
    ...

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

<class '__main__.Person'>

class Person:
    
    def __init__(self):
        self._interest = None 
        
    def set_interest(self, interest):
        if isinstance(interest, str):
            self._interest = interest
            
    def get_interest(self):
        return self._interest

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 shared_interest(self, person):
        return self._interest == person.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()

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

print(f"{annie.shared_interest(grace)=}")
print(f"{annie.shared_interest(margaret)=}")

annie.shared_interest(grace)=False
annie.shared_interest(margaret)=True

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

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)
    
    def __str__(self):
        return f"(Queue: {str(self._storage)})"


q = Queue()
print(q)

(Queue: [])

class Queue:
    
    def __init__(self):
        self._front = None
        self._back = None
        
    def __iadd__(self, value):
        self.enqueue(value)
        return self

    def enqueue(self, value):
        element = {'value': value, 'next': None}
        if self._back is None:
            self._front = element
            self._back = element
        else:
            self._back['next'] = element
            self._back = element
        
    def dequeue(self):
        if self._front is not None:
            value = self._front['value']
            if self._front['next'] is None:
                self._front = None
                self._back = None
            else:
                self._front = self._front['next']
            return value

q = Queue()
q += 'Ada'
q = q.__iadd__('Ada')
string = "Mitt namn är "
string += "Johan"
print(string)
q += 'Bertil'
q += 'Cecilia'
print(f"{q.dequeue()=}")
print(f"{q.dequeue()=}")
q += 'David'
print(f"{q.dequeue()=}")
print(f"{q.dequeue()=}")
print(f"{q.dequeue()=}")

Mitt namn är Johan
q.dequeue()='Ada'
q.dequeue()='Ada'
q.dequeue()='Bertil'
q.dequeue()='Cecilia'
q.dequeue()='David'

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 0x7ff844db3c40>

q = Queue()
print(q.__str__())

<__main__.Queue object at 0x7ff844db3ca0>

q = Queue()
print(q.__str__)
print(q.__tjohej__)

<method-wrapper '__str__' of Queue object at 0x7ff844db1690>

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

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

class Queue:
    pass

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)
    
    def __str__(self):
        return f"(Queue: {str(self._storage)})"

q = Queue()
print(dir(q))

['__class__', '__delattr__', '__dict__', '__dir__', '__doc__', '__eq__', '__format__', '__ge__', '__getattribute__', '__gt__', '__hash__', '__init__', '__init_subclass__', '__le__', '__lt__', '__module__', '__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__setattr__', '__sizeof__', '__str__', '__subclasshook__', '__weakref__', '_storage', 'dequeue', 'enqueue']

class QueueList(list):
    
    def enqueue(self, value):
        self.append(value)
        
    def dequeue(self):
        if self:
            value = self[0]
            del self[0]
            return value

class Queue(list):
    
    def enqueue(self, value):
        self.append(value)
        
    def dequeue(self):
        if self:
            value = self[0]
            del self[0]
            return value
        
# Tests
q = Queue()
q.enqueue('Ada')
q.enqueue('Bertil')
q.enqueue('Cecilia')
print(f"{q.dequeue()=}")
print(f"{q.dequeue()=}")
q.enqueue('David')
print(f"{q.dequeue()=}")
print(f"{q.dequeue()=}")
print(f"{q.dequeue()=}")

q.dequeue()='Ada'
q.dequeue()='Bertil'
q.dequeue()='Cecilia'
q.dequeue()='David'
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))
print("Sorterat baserat på poäng:", sorted(value_pairs, key=second))

Högst poäng: ['Cissi', 7]
Lägst poäng: ['Bertil', 2]
Sorterat baserat på poäng: [['Bertil', 2], ['Ada', 3], ['Cissi', 7]]

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}")
        
b = Book("Sagan om ringen")
b.author = "J. R. R. Tolkien"
b.year = 1954
b.print_citation()

J. R. R. Tolkien. (1954). Sagan om ringen

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)

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

---------------------------------------------------------------------------
TypeError                                 Traceback (most recent call last)
Cell In[22], 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[23], 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[24], 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[25], 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.")

# 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.")

# 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.")

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.2¶

Johan Falkenjack, johan.falkenjack@liu.se¶

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

En mer konkret klass¶

Klassen Person¶

Klassen Person: Initiering av attribut¶

Klassen Person: Beteenden och metoder¶

Klassen Person: Testkörning¶

Namngivning¶

Exempel på klassnamn¶

Vanliga prefix till metodnamn¶

Magic methods i Python

__str__¶

Andra dundermetoder¶

Implementera operatorer för Queue¶

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¶

Vad ärver man av object?¶

Exempel: Queue med list som basklass¶

Mellanspel: Funktionsobjekt och högre ordningens funktioner¶

Funktionsobjekt¶

Funktionsobjekt¶

Exempel på funktionsobjekt¶

Högre ordningens funktioner¶

Exempel¶

Introduktion till klassdiagram i UML¶

UML - Unified Modelling Language¶

Klassdiagram¶

Klassdiagram¶

Book — en klass för böcker¶

Book-klassen, UML-diagram¶

Klassdiagram, Laboration 5, Del 1

Grafiska gränssnitt med tkinter¶

Programflöde: GUI¶

Om modulen tkinter¶

Widgets¶

Litet exempel¶

Laboration 5¶

Del 2¶

random-layout.py¶

Undantag (Exceptions)¶

Exempel på kod som utlöser undantag¶

Exception - exempel på OOP¶

Undantag - Exceptions¶

Exempel på olika undantag i Python¶

Hantera undantag i Python¶

Mönster för undandagshantering i Python¶

Exempel: Fånga inte undantag alls¶

Exempel: Fånga alla typer av undantag¶

Exempel: Fånga alla typer av undantag och skriv ut felmeddelandet¶

Exempel: Fånga och hantera olika typer av undantag på olika sätt¶

Anledningar till att använda undantag istället för villkorssatser¶

Kodstandarder¶

PEP 8 & PEP 257¶

Kodstandarder¶

Krav på PEP 8 och PEP 257¶

PEP 8¶

PEP 257¶

Utformning av en docstring¶

Docstring på flera rader¶

Detaljnivå på docstrings¶

Användning av docstrings kontra inlinekommentarer¶

Automatisk kontroll av PEP8 & PEP257¶

Testning och felsökning¶

Att testa sin kod¶

Använda python interaktivt¶

Rätta buggar¶

Övning¶

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

Klassen `Person`¶

Klassen `Person`: Initiering av attribut¶

Klassen `Person`: Beteenden och metoder¶

Klassen `Person`: Testkörning¶

`str`¶

Implementera operatorer för `Queue`¶

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

Vad ärver man av `object`?¶

Exempel: Queue med `list` som basklass¶

`Book` — en klass för böcker¶

Grafiska gränssnitt med `tkinter`¶

Om modulen `tkinter`¶

`random-layout.py`¶

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