l = ["en", "lista", "med", "värden"]
print(f"första värdet: {l[0]}")

s = "batteri"
print(f"{s=}")

def hejsan():
    print("Hejsan")

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

eggs = print_hello
eggs()

my_length_fun = len
another_print = print
another_print(my_length_fun(["a","short","list"]))

# insertionsort som högre ordningens funktion

def insertionsort(alist, order_fn):
    for i in range(1, len(alist)):
        currentvalue = alist[i]
        pos = i
        
        # argumentet order_fn till funktionen är den funktion som
        # ska användas för jämförelsen
        while (pos >= 1 and order_fn(alist[pos-1], currentvalue)):
            alist[pos]=alist[pos-1]
            pos -= 1
        alist[pos]=currentvalue
        
        
def asc_order(value1, value2):
    return value1 > value2

def desc_order(value1, value2):
    return value1 < value2

alist = [54,26,93,17,77,31,44,55,20]
insertionsort(alist, desc_order)
print("Desc:", alist)
insertionsort(alist, asc_order)
print("Asc:", alist)

# insertionsort som högre ordningens funktion med lambda-argument

def insertionsort(alist, order_fn):
    for i in range(1, len(alist)):
        currentvalue = alist[i]
        pos = i
        
        # argumentet order_fn till funktionen är den funktion som
        # ska användas för jämförelsen
        while (pos >= 1 and order_fn(alist[pos-1], currentvalue)):
            alist[pos]=alist[pos-1]
            pos -= 1
        alist[pos]=currentvalue

alist = [54,26,93,17,77,31,44,55,20]
insertionsort(alist, lambda x, y: x < y)
print("Desc:", alist)
insertionsort(alist, lambda x, y: x > y)
print("Asc:", alist)

# pythons inbyggda funktion sorted() kan ta emot nyckelordsargumentet key som är en
# funktion som den ska använda för att plocka fram värdet som något ska sorteras efter.

# säg att vi har en lista av ord-ordfrekvenspar
wordlist = [["ord1", 10], ["ord2", 32], ["ord3", 5]]

# vi skriver en funktion som tar ordfrekvenspar och returnerar dess frekvens
def get_freq(word_and_freq):
    return word_and_freq[1]

# vi kan nu skicka med funktionen till sort för att sortera listan efter frekvens
print(f"{sorted(wordlist, key=get_freq)=}")

# istället för att definiera en vanlig namngiven funktion, kan vi använda ett
# lambdauttryck (som evalueras till ett funktionsobjekt)
print(f"{sorted(wordlist, key=lambda word_and_freq: word_and_freq[1])=}")

max(values, key=func)
min(values, key=func)

wordlist = [["ord1", 10], ["ord2", 32], ["ord3", 5]]

# mest frekventa ordet, funktionsargumentet ska returnera det värde
# som max() ska använda för att jämföra element med varandra
print(f"max_word = {max(wordlist, key=lambda wf: wf[1])}")

# minst frekventa ordet, samma som max()
print(f"min_word = {min(wordlist, key=lambda wf: wf[1])}")

# kom ihåg, om vi itererar över ett dictionary är det nycklarna vi
# itererar över
contestants = {"ada": 1, "boris": -10, "cissi": 5, "doris": 3}
print(f"winner = {max(contestants, key=lambda name: contestants[name])}")

wordlist = [["apa", 10], ["fisk", 32], ["alligator", 5] ]
# ta fram alla ord i wordlist som börjar på "a"
# första argumentet är en funktion som returnerar True för de element som ska behållas
print(f"a_list = {filter(lambda wf: wf[0].startswith('a'), wordlist)}")

# ta fram alla ord i words vars sista tecken är char
words = ["bror", "bok", "bar", "barberare"]
char = "r"
print(f"ends_with_char = {list(filter(lambda word: word[-1] == char, words))}")

# titta bara på rader som inte har "N/A" som värde på index 2
for row in filter(lambda r: r[2] != "N/A", csv_data):
    pass # gör grejer

def happy_anniversary(name, occasion="födelsedagen", num=1):
    print(f"Grattis på {occasion}, {name}!")
    print(f"Tänk att du firat detta {num} gånger nu!")
happy_anniversary("Ragiähl")

happy_anniversary("Önde", "namnsdagen, eller inte", 0)

happy_anniversary(num=42, name="Gjohl",)

def add(term1, term2):
    return term1 + term2

def multiply(factor1, factor2):
    return factor1 * factor2

def aggregate(*args, function=add):
    result = args[0]
    for arg in args[1:]:
        result = function(result, arg)
    return result

aggregate(1,2,3,4,5, function=add)

aggregate(1,2,3,4,5, function=multiply)

def print_pairs(**kwargs):
    for key, value in kwargs.items():
        print(f"{key}: {value}")
        
print_pairs(name="Norville Rogers", hometown="Coolsville, OH", company="Mystery, Inc.")
print_pairs(course_name="Graph Theory", exam1="0 points", exam2="3 points", grade="Let's never talk about this again.")

def add(term1, term2):
    return term1 + term2

def aggregate(*args, fun=add):
    result = args[0]
    for arg in args[1:]:
        result = fun(result, arg)
    return result

def multiply(factor1, factor2):
    return factor1 * factor2

aggregate(1,2,3,4,5, fun=multiply)

print("We", "can", "actually", "add", "however", "many", "arguments", "we", "want")

print("We can", "also change", "the separator", sep="\n")

print("or the", end=' ')
print("end")

with open("printtest.txt", 'w') as outfile:
    print("Or print to a file rather than stdout!", file=outfile)

# Importera tkinter
import tkinter as tk

# Ett rot-fönster
root = tk.Tk()
# Widgets läggs in i rot-fönstret
button = tk.Button(root, text="Press me!")
# Widgets layoutas
button.pack()

# Huvudloopen startas
root.mainloop()

# importera tkinter-modulen
from tkinter import *
# skapa ett Tk-fönster
window = Tk()
# starta GUI-loopen
mainloop()

# windows.py
from tkinter import *
# Skapa det första fönstret
root = Tk()
# Skapa det andra fönstret
top = Toplevel()
# Starta Tk-loopen
root.mainloop()

# utan att spara referens
Widget(parent, attribute1=v1, attribute2=v2, ...)
# med referensen sparad
w = Widget(parent, attribute1=v1, attribute2=v2, ...)

# importera tkinter-modulen
import tkinter as tk

# skapa ett rot-fönster
root = tk.Tk()
button = tk.Button(root, text="Press me!")
button.pack()

# starta GUI-loopen
root.mainloop()

button = tk.Button(root, text="OK", command=do_this)

# importera tkinter-modulen
import tkinter as tk

def callback():
    """Print a set string when called."""
    print("Something happened!")

# skapa ett Tk-fönster
root = tk.Tk()
button = tk.Button(root, text="Press Me!", command=callback)
button.pack()

# starta GUI-loopen
root.mainloop()

def key_handler(event):
    print("A key was pressed")

import tkinter as tkx

def callback():
    print("Something happened!", end=' ')

def over_me(event):
    print("You are over me!", end=' ')

def left_me(event):
    print("You left me!", end=' ')

# skapa ett Tk-fönster och knapp
root = tk.Tk()
button = tk.Button(root, text="Press Me!", command=callback)

# bind funktioner till Enter/Leave-händelserna
button.bind("<Enter>", over_me)
button.bind("<Leave>", left_me)
button.pack()

# starta GUI-loopen
root.mainloop()

import tkinter as tk

# skapa och placera en frame i ett fönster
root = tk.Tk()

def key(event):
    """Skriv ut debugutskrifter för textfält."""
    if event.widget == entry1:
        print(entry1.get())
    if event.widget == entry2:
        print("Entry 2 changed")
        
# Entry 1
entry1 = tk.Entry(root)
entry1.bind("<KeyRelease>", key)
entry1.pack()

# Entry 2
entry2 = tk.Entry(root)
entry2.bind("<KeyRelease>", key)
entry2.pack()
root.mainloop()

# grid.py
import tkinter as tk

# Framen läggs automatisk in i en tk.Tk()
frame = tk.Frame()

# placera frame i fönstret med hjälp av pack()
frame.pack()

# titel-label
title_label = tk.Label(frame, text="The best game character ever",
                       background="red")
title_label.grid(row=0, column=0, columnspan=2, sticky=tk.E+tk.W+tk.N+tk.S)

# namn-label
name_label = tk.Label(frame, text="Name")
name_label.grid(row=1, column=0, sticky=tk.NW)

# name-textfält
name_entry = tk.Entry(frame)
name_entry.grid(row=1, column=1, sticky=tk.NW)

# game-label
game_label = tk.Label(frame, text="Game")
game_label.grid(row=2, column=0, sticky=tk.NW)

# name-textfält
game_entry = tk.Entry(frame)
game_entry.grid(row=2, column=1, sticky=tk.NW)

# knapp
button = tk.Button(frame, text="Ok")
button.grid(row=3, column=1, sticky=tk.SE)
frame.mainloop()

s = tk.StringVar()
s.set("hej")
print(s.get())

# radio.py
import tkinter as tk

root = tk.Tk()

def radio():
    """Skriv ut värdet hos radio-knappen."""
    print(radio_value.get())

# Tk-variabel att lagra radioknapp-gruppens värde i
radio_value = tk.StringVar()
radio_value.set("svejsan")

# knapp 1
radio_button1 = tk.Radiobutton(root, text="Hejsan", variable=radio_value,
                               value="hejsan", command=radio)
radio_button1.pack()

# knapp 2
radio_button2 = tk.Radiobutton(root, text="Hoppsan", variable=radio_value,
                               value="hoppsan", command=radio)
radio_button2.pack()

# knapp 3
radio_button3 = tk.Radiobutton(root, text="Svejsan", variable=radio_value,
                               value="svejsan", command=radio)
radio_button3.pack()

root.mainloop()

def hello(name, index, mode):
    print(v.get())

v = tk.StringVar()
v.set("eggs")
v.trace('w', hello)
v.set("bacon")

# checkbox.py
import tkinter as tk

root = tk.Tk()

def check_changed(name, index, mode):
    """Skriv ut debug-utskrifter för checkboxar."""
    # name är namnet på den variabeln som triggade check_changed
    # i detta exempel finns två kandidater, check_val1 som har
    # namnet "check1" och check_val2 som har namnet "check2".
    if name == "check1":
        print("check 1: " + str(check_val1.get()), end='  |  ')
    elif name == "check2":
        print("check 2: " + str(check_val2.get()), end='  |  ')
        
# skapa en instans av IntVar som får namnet "check1"
check_val1 = tk.IntVar(name="check1")

# när värdet på check_val1 ändras, kör funktionen check_changed()
check_val1.trace('w', check_changed)

# skapa en instans av IntVar som får namnet "check2"
check_val2 = tk.IntVar(name="check2")

# när värdet på check_val2 ändras, kör funktionen check_changed()
check_val2.trace('w', check_changed)

# skapa två checkbuttons, koppla ihop dem med var sin variabel
checkbutton1 = tk.Checkbutton(root, variable=check_val1,
                              text="box of check I am")
checkbutton2 = tk.Checkbutton(root, variable=check_val2,
                              text="box of check I am too")

# lägg till knapparna till layouten
checkbutton1.pack()
checkbutton2.pack()

root.mainloop()

# optionmenu.py
import tkinter as tk

root = tk.Tk()

var = tk.StringVar(root)
var.set("one") # initial value

option = tk.OptionMenu(root, var, "one", "two", "three", "four")
option.pack()

def ok():
    print("value is", var.get(), end='  |  ')

button = tk.Button(root, text="OK", command=ok)
button.pack()

tk.mainloop()

if __name__ == "__main__":
 # kod här

def my_clever_function(an_argument, another_argument):
    print("\n--------------------\n")
    print("In my_clever_function:")
    print(f"{an_argument=}")
    print(f"{another_argument=}")

def count_integers(value_list):
    num_ints = 0
    for value in value_list:
        if type(value) == int:
            num_ints += 1
    return num_ints

print(f"{count_integers([1, 2, 3, 4])=}")
assert count_integers([1, 2, 3, 4, "5"]) == 5
#assert count_integers([1, 2, 3, 4]) == 3

# localglobal.py

def print_global_name():
    """Skriv ut globala variabeln name."""
    global name
    print(f"global name: {name}")

def change_and_print_local_name(name):
    """Ändra och skriv utlokala variabeln name."""
    # alla variabler i en funktion är lokala om inte annat anges
    secret = "When this function returns, I am gone."
    name = name * 2
    print(f"changed local name: {name}")

def change_and_print_global_name():
    """Ändra och skriv ut globala variabeln name."""
    global name
    name = name * 2
    print(f"changed global name: {name}")

name = "Ada"
print_global_name()
change_and_print_local_name(name)
print_global_name()
change_and_print_global_name()
print_global_name()

# localvars.py

def find_min_and_max(values):
    min_val = None
    max_val = None
    for value in values:
        if type(value) != int:
            continue
        if min_val is None and max_val is None:
            min_val = value
            max_val = value
            continue

        if value > max_val:
            max_val = value
        if value < min_val:
            min_val = value

    print(f"min: {min_val}, max: {max_val}")

my_values1 = ["a", 10, 90, -100, 80, 900, "nehepp"]
my_values2 = ["a", 1, 9, -10, 8, 90, "jahapp"]
find_min_and_max(my_values1)
find_min_and_max(my_values2)

# Här går koden sönder, varför?
print(max_val)
print(min_val)

# globalvars.py

min_val = None
max_val = None

def find_min_and_max(values):
    global min_val, max_val
    for value in values:
        if type(value) != int:
            continue
        # om vi inte har något min/max än
        if min_val is None and max_val is None:
            min_val = value
            max_val = value
            continue

        # uppdatera när vi hittar nytt min/max
        if value > max_val:
            max_val = value
        if value < min_val:
            min_val = value

    print(f"min: {min_val}, max: {max_val}")

my_values1 = ["a", 10, 90, -100, 80, 900, "nehepp"]
my_values2 = ["a", 1, 9, -10, 8, 90, "jahapp"]

find_min_and_max(my_values1)
print(max_val)
print(min_val)

# varför blir det fel här? Minsta heltalet är ju -10 i my_values2
find_min_and_max(my_values2)
print(max_val)
print(min_val)

# insertionsort original

def insertionsort(list_to_sort,order):
    for i in range(1,len(list_to_sort)):

        currentvalue = list_to_sort[i]
        pos = i

        if order == "ascending":
            while (pos >= 1 and list_to_sort[pos - 1] > currentvalue):
                list_to_sort[pos]=list_to_sort[pos - 1]
                pos = pos - 1
        elif order == "descending":
            while (pos >= 1 and list_to_sort[pos - 1] < currentvalue):
                list_to_sort[pos]=list_to_sort[pos - 1]
                pos = pos - 1

        list_to_sort[pos]=currentvalue


alist = [54,26,93,17,77,31,44,55,20]
insertionsort(alist, "ascending")
print("Ascending", alist)

alist = [54,26,93,17,77,31,44,55,20]
insertionsort(alist, "descending")
print("Descending", alist)

if order == "ascending":
    while (pos >= 1 and list_to_sort[pos - 1] > currentvalue):
        list_to_sort[pos]=list_to_sort[pos - 1]
        pos = pos - 1
elif order == "descending":
    while (pos >= 1 and list_to_sort[pos - 1] < currentvalue):
        list_to_sort[pos]=list_to_sort[pos - 1]
        pos = pos - 1

# insertionsort utbruten

def insertionsort(alist, order):
    for i in range(1, len(alist)):
        currentvalue = alist[i]
        pos = i

        while (pos >= 1 and prev_val_should_move(alist[pos-1],
                                                 currentvalue, order)):
            alist[pos] = alist[pos-1]
            pos -= 1
        alist[pos] = currentvalue


def prev_val_should_move(value1, value2, order):
    if order == "ascending":
        return value1 > value2
    elif order == "descending":
        return value1 < value2

alist = [54,26,93,17,77,31,44,55,20]
insertionsort(alist, "descending")
print("Desc:", alist)
insertionsort(alist, "ascending")
print("Asc:", alist)

Widget	Description
Button	A simple button, used to execute a command or other operation.
Canvas	Structured graphics. This widget can be used to draw graphs and plots, create graphics editors, and to implement custom widgets.
Checkbutton	Represents a variable that can have two distinct values. Clicking the button toggles between the values.
Entry	A text entry field.
Frame	A container widget. The frame can have a border and a background, and is used to group other widgets when creating an application or dialog layout.
Label	Displays a text or an image.
Listbox	Displays a list of alternatives. The listbox can be configured to get radiobutton or checklist behavior.

Widget	Description
Menu	A menu pane. Used to implement pulldown and popup menus.
Menubutton	A menubutton. Used to implement pulldown menus.
Message	Display a text. Similar to the label widget, but can automatically wrap text to a given width or aspect ratio.
Radiobutton	Represents one value of a variable that can have one of many values. Clicking the button sets the variable to that value, and clears all other radiobuttons associated with the same variable.
Scale	Allows you to set a numerical value by dragging a "slider".
Scrollbar	Standard scrollbars for use with canvas, entry, listbox, and text widgets.
Text	Formatted text display. Allows you to display and edit text with various styles and attributes. Also supports embedded images and windows.
Toplevel	A container widget displayed as a separate, top-level window.

729G46 Informationsteknologi och programmering¶

Tema 5, Föreläsning 5.1-5.2¶

Johan Falkenjack, johan.falkenjack@liu.se¶

Översikt¶

Tema 5

Grafiska gränssnitt och abstraktion/dekomposition i praktiken

Temauppgift 5¶

Seminarium och Rapport Tema 5¶

Repetition, f-strängar (Python 3.6+)¶

Funktionsobjekt

... även funktioner är objekt i Python

Funktionsobjekt¶

Exempel på funktionsobjekt¶

Högre ordningens funktioner¶

Konsekvenser av att funktioner är objekt¶

Högre ordningens funktioner¶

Exempel, med funktionsobjekt¶

Anonyma funktioner?¶

Lambda-uttryck¶

min(), max()¶

filter()¶

Flera sätt att binda värden till funktionsparametrar

Fem olika metoder

Enskilda parameterbindningar¶

Enskilda parameterbindningar¶

Sammansatta parameterbindningar¶

Sammansatta parameterbindningar¶

Sammansatta parameterbindningar¶

Sammansatta parameterbindningar¶

Exempel med print

Exempel med print¶

Fallet open

Fallet open, forts.

Grafiska användargränssnitt¶

Gränssnitt¶

Användargränssnitt¶

Grafiska användargränssnitt¶

Widget

Bakom kulisserna i ett GUI¶

Program- och interaktionsflöde för textbaserade gränssnitt¶

Exempel: Textbaserat gränssnitt

Exempel: Textbaserat gränssnitt

Programflöde: Textbaserat gränssnitt¶

Program- och interaktionsflöde för grafiska gränssnitt¶

Exempel: Textbaserat gränssnitt

Exempel: Textbaserat gränssnitt

Programflöde: GUI¶

Syfte med att skapa grafiska gränssnitt i Python med tkinter

Om tkinter¶

Widgets i tkinter

Objektorienterat GUI¶

Struktur på en GUI-applikation med tkinter¶

Var finns min widget?¶

Widgets i tkinter¶

Widgets i tkinter¶

Exempel på widgetanvändning¶

window.py¶

Flera fönster¶

Skapa widgets¶

Button¶

button.py¶

Få något att hända när man trycker på knappen¶

Ange widget-kommando¶

button-command.py¶

Händelser¶

Händelser forts.¶

Exempel på händelser¶

button-event.py¶

Label¶

Entry¶

entry.py¶

Frame¶

Layout¶

grid

Exempel på label, textfält och knapp

Exempel på label, textfält och knapp

grid forts.¶

Exempel på label, textfält och knapp

Radiobutton¶

Tk-variabler¶

`min()`, `max()`¶

`filter()`¶

Exempel med `print`

Exempel med `print`¶

Fallet `open`

Fallet `open`, forts.

Syfte med att skapa grafiska gränssnitt i Python med `tkinter`

Om `tkinter`¶

Widgets i `tkinter`

Struktur på en GUI-applikation med `tkinter`¶

Widgets i `tkinter`¶

Widgets i `tkinter`¶

`Button`¶

`Label`¶

`Entry`¶

`Frame`¶

`grid`

`grid` forts.¶

`OptionMenu`¶